@open3cl/engine 1.8.8 → 1.8.9

package/13.2_generateur_combustion.js

@@ -5,6 +5,7 @@ import { updateGenerateurChaudieres } from './13.2_generateur_combustion_chaudie
 import { updateGenerateurPacs } from './13.2_generateur_pac.js';
 import getFicheTechnique from './ficheTechnique.js';
 import { evaluateFormula as evaluateTvFormula } from './formula.js';
+import { conventionPuissanceNominale } from './13.2_generateur_combustion_pn.js';
 
 function criterePn(Pn, matcher) {
   let critere_list = tvColumnLines('generateur_combustion', 'critere_pn', matcher);
@@ -41,6 +42,58 @@ function evaluateFormula(formulaOrValue, pn, E, F) {
   return evaluateTvFormula(formulaOrValue, pn, E, F);
 }
 
+/**
+ * Caractéristiques forfaitaires (rpn, rpint, qp0) d'un générateur à combustion.
+ *
+ * Si la consommation est obtenue par virtualisation du générateur collectif pour les besoins
+ * individuels, les formules sont évaluées sur la puissance du générateur collectif
+ * Pn(collectif) = pn / ratio, et qp0 est ramené au logement (× ratio).
+ * 17.2.1 - Génération d’un DPE à l’appartement / Traitement des usages collectifs
+ *
+ * Seules les caractéristiques non saisies (selon la méthode de saisie) sont renvoyées.
+ *
+ * @param row {object} ligne de la table generateur_combustion
+ * @param pn {number} puissance nominale du générateur (W)
+ * @param ratio {number} ratio de virtualisation
+ * @param E {number}
+ * @param F {number}
+ * @param type {'ecs'|'ch'}
+ * @param methodeSaisie {number}
+ * @returns {{rpn?: number, rpint?: number, qp0?: number}}
+ */
+export function caracteristiquesGenerateurCombustion(row, pn, ratio, E, F, type, methodeSaisie) {
+  const caracteristiques = {};
+
+  if (![3, 4, 5].includes(methodeSaisie)) {
+    if (row.rpn) {
+      caracteristiques.rpn = evaluateFormula(row.rpn, pn / ratio, E, F) / 100;
+    }
+    if (type === 'ch' && row.rpint) {
+      caracteristiques.rpint = evaluateFormula(row.rpint, pn / ratio, E, F) / 100;
+    }
+  }
+
+  if (![4, 5].includes(methodeSaisie)) {
+    if (row.qp0_perc) {
+      const qp0_calc = evaluateFormula(row.qp0_perc, pn / ratio, E, F);
+      // Certaines chaudières ont un qp0 en % de pn, d'autres ont des valeurs constantes
+      if (row.qp0_perc.includes('Pn')) {
+        caracteristiques.qp0 = qp0_calc * 1000 * ratio;
+      } else {
+        if (row.qp0_perc.includes('%')) {
+          caracteristiques.qp0 = qp0_calc * pn;
+        } else {
+          caracteristiques.qp0 = qp0_calc * 1000 * ratio;
+        }
+      }
+    } else {
+      caracteristiques.qp0 = 0;
+    }
+  }
+
+  return caracteristiques;
+}
+
 /**
  * Si la méthode de saisie n'est pas "Valeur forfaitaire" mais "caractéristiques saisies"
  * Documentation 3CL : "Pour les installations récentes ou recommandées, les caractéristiques réelles des chaudières présentées sur les bases
@@ -63,6 +116,7 @@ export function tv_generateur_combustion(dpe, di, de, type, GV, tbase, methodeSa
   const typeGenerateurKey = `enum_type_generateur_${type}_id`;
   let enumTypeGenerateurId = de[typeGenerateurKey];
   let row;
+  let selectionLigne;
 
   /**
    * Certains DPE configurent mal les données du générateur ECS lorsque c'est un générateur mixte Chauffage + ECS
@@ -99,11 +153,14 @@ export function tv_generateur_combustion(dpe, di, de, type, GV, tbase, methodeSa
       di.pn = (1.2 * GV * (19 - tbase)) / 0.95 ** 3;
     }
 
-    let matcher = {};
-    matcher[typeGenerateurKey] = enumTypeGenerateurId;
-    matcher.critere_pn = criterePn(di.pn / (de.ratio_virtualisation * 1000), matcher);
+    selectionLigne = (pn, ratio) => {
+      let matcher = {};
+      matcher[typeGenerateurKey] = enumTypeGenerateurId;
+      matcher.critere_pn = criterePn(pn / (ratio * 1000), matcher);
+      return tv('generateur_combustion', matcher);
+    };
 
-    row = tv('generateur_combustion', matcher);
+    row = selectionLigne(di.pn, de.ratio_virtualisation);
 
     /**
      * Si l'identifiant du générateur à combustion utilisé n'est pas le bon, avertissement
@@ -144,41 +201,69 @@ export function tv_generateur_combustion(dpe, di, de, type, GV, tbase, methodeSa
   const E = E_tab[de.presence_ventouse];
   const F = F_tab[de.presence_ventouse];
 
-  const ratioVirtualisation = de.ratio_virtualisation || 1;
+  let ratioVirtualisation = de.ratio_virtualisation || 1;
 
   /**
-   * Si la consommation ECS est obtenue par virtualisation du générateur collectif pour les besoins individuels
-   * la puissance nominale est obtenu à partir de la puissance nominale du générateur collectif multiplié par le
-   * ratio de virtualisation
-   * 17.2.1 - Génération d’un DPE à l’appartement / Traitement des usages collectifs
+   * Générateur collectif virtualisé : la puissance saisie dans le DPE peut être la puissance
+   * virtualisée Pe = a × Pn (convention 3CL) ou la puissance du générateur collectif Pn selon les
+   * logiciels (issue #124). La convention réellement utilisée est déduite des valeurs
+   * intermédiaires (rpn, qp0) présentes dans le DPE.
    */
-  if (![3, 4, 5].includes(methodeSaisie)) {
-    if (row.rpn) {
-      di.rpn = evaluateFormula(row.rpn, di.pn / ratioVirtualisation, E, F) / 100;
-    }
-    if (type === 'ch' && row.rpint) {
-      di.rpint = evaluateFormula(row.rpint, di.pn / ratioVirtualisation, E, F) / 100;
+  if (selectionLigne) {
+    const ligneOuDefaut = (pn, ratio) => selectionLigne(pn, ratio) || row;
+    const caracteristiques = (pn, ratio) =>
+      caracteristiquesGenerateurCombustion(
+        ligneOuDefaut(pn, ratio),
+        pn,
+        ratio,
+        E,
+        F,
+        type,
+        methodeSaisie
+      );
+    /**
+     * Formule rpn de la ligne sélectionnée pour un Pn(collectif) donné (W) : permet de retrouver
+     * Pn(collectif) à partir du rpn stocké (4e hypothèse).
+     */
+    const formuleRpn = (pnCollectif) => {
+      const ligne = selectionLigne(pnCollectif, 1);
+      return ligne?.rpn ? (p) => evaluateFormula(ligne.rpn, p, E, F) / 100 : undefined;
+    };
+    const puissance = conventionPuissanceNominale(
+      di.pn,
+      ratioVirtualisation,
+      { rpn: di.rpn, rpint: di.rpint, qp0: di.qp0 },
+      caracteristiques,
+      bug_for_bug_compat,
+      formuleRpn
+    );
+
+    if (puissance.convention === 'puissance_depuis_rpn') {
+      console.warn(
+        `La puissance nominale du générateur ${de.description} (${di.pn} W) n'est cohérente ni avec la puissance
+        virtualisée ni avec celle du générateur collectif. Puissance du générateur collectif recalculée à partir
+        du rpn du DPE (${di.rpn}) : Pn = ${puissance.pnCollectif / 1000} kW, utilisation de Pe = a × Pn = ${puissance.pn} W.`
+      );
+    } else if (puissance.convention !== 'individualisee') {
+      console.warn(
+        `La puissance nominale du générateur ${de.description} (${di.pn} W) est celle du générateur collectif : 
+        utilisation de la puissance ${puissance.pn} W et du ratio de virtualisation ${puissance.ratio} (${puissance.convention}).`
+      );
     }
-  }
 
-  if (![4, 5].includes(methodeSaisie)) {
-    if (row.qp0_perc) {
-      const qp0_calc = evaluateFormula(row.qp0_perc, di.pn / ratioVirtualisation, E, F);
-      // Certaines chaudières ont un qp0 en % de pn, d'autres ont des valeurs constantes
-      if (row.qp0_perc.includes('Pn')) {
-        di.qp0 = qp0_calc * 1000 * ratioVirtualisation;
-      } else {
-        if (row.qp0_perc.includes('%')) {
-          di.qp0 = qp0_calc * di.pn;
-        } else {
-          di.qp0 = qp0_calc * 1000 * ratioVirtualisation;
-        }
-      }
-    } else {
-      di.qp0 = 0;
+    if (puissance.convention !== 'individualisee') {
+      di.pn = puissance.pn;
+      ratioVirtualisation = puissance.ratio;
+      row = ligneOuDefaut(di.pn, ratioVirtualisation);
+      de.tv_generateur_combustion_id = Number(row.tv_generateur_combustion_id);
     }
   }
 
+  Object.assign(
+    di,
+    caracteristiquesGenerateurCombustion(row, di.pn, ratioVirtualisation, E, F, type, methodeSaisie)
+  );
+
   if (methodeSaisie === 1 || !di.pveilleuse) {
     di.pveil = Number(row.pveil) || 0;
   } else {

package/13.2_generateur_combustion.spec.js

@@ -51,10 +51,21 @@ vi.mock('./13.2_generateur_pac.js', () => ({
 vi.mock('./ficheTechnique.js', () => ({
   default: vi.fn()
 }));
+/**
+ * Détection de la convention de puissance (issue #124) : testée dans son propre spec. Par défaut,
+ * le double renvoie la convention individualisée (pn et ratio inchangés).
+ */
+vi.mock('./13.2_generateur_combustion_pn.js', () => ({
+  conventionPuissanceNominale: vi.fn((pn, ratio) => ({ pn, ratio, convention: 'individualisee' }))
+}));
 
-const { tv_generateur_combustion, updateGenerateurCombustion } =
-  await import('./13.2_generateur_combustion.js');
+const {
+  tv_generateur_combustion,
+  updateGenerateurCombustion,
+  caracteristiquesGenerateurCombustion
+} = await import('./13.2_generateur_combustion.js');
 const { tv, tvColumnLines } = await import('./utils.js');
+const { conventionPuissanceNominale } = await import('./13.2_generateur_combustion_pn.js');
 const { updateGenerateurBouilleurs } = await import('./13.2_generateur_combustion_bouilleur.js');
 const { updateGenerateurChaudieres } = await import('./13.2_generateur_combustion_chaudiere.js');
 const { updateGenerateurPacs } = await import('./13.2_generateur_pac.js');
@@ -68,6 +79,12 @@ beforeEach(() => {
   vi.mocked(updateGenerateurChaudieres).mockReset();
   vi.mocked(updateGenerateurPacs).mockReset();
   vi.mocked(getFicheTechnique).mockReset();
+  vi.mocked(conventionPuissanceNominale).mockReset();
+  vi.mocked(conventionPuissanceNominale).mockImplementation((pn, ratio) => ({
+    pn,
+    ratio,
+    convention: 'individualisee'
+  }));
   state.bug = false;
 });
 
@@ -535,3 +552,270 @@ describe('updateGenerateurCombustion - orchestration des substitutions', () => {
     expect(de.presenceVentilateur).toBeUndefined();
   });
 });
+
+/**
+ * Issue #124 : générateur collectif virtualisé, puissance saisie collective (Pn) ou individualisée
+ * (Pe = a × Pn) selon les logiciels.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2 et §17.2.1
+ */
+describe('tv_generateur_combustion - convention de puissance d’un générateur virtualisé (#124)', () => {
+  const ROW_PN = {
+    tv_generateur_combustion_id: '42',
+    rpn: '84 + 2 logPn',
+    rpint: '80 + 3 logPn',
+    qp0_perc: '1%',
+    pveil: '0'
+  };
+
+  test('la détection reçoit pn, ratio, valeurs du DPE et bug_for_bug_compat', () => {
+    state.bug = true;
+    tv.mockReturnValue({ ...ROW_PN });
+    const di = { pn: 23000, rpn: 0.87, qp0: 0.276 };
+    const de = {
+      enum_type_generateur_ch_id: '89',
+      ratio_virtualisation: 0.1,
+      presence_ventouse: 0
+    };
+    tv_generateur_combustion({}, di, de, 'ch', 200, -9, 1);
+    expect(conventionPuissanceNominale).toHaveBeenCalledWith(
+      23000,
+      0.1,
+      { rpn: 0.87, rpint: undefined, qp0: 0.276 },
+      expect.any(Function),
+      true,
+      expect.any(Function)
+    );
+  });
+
+  test('formule rpn fournie (4e hypothèse) : ligne sélectionnée sur Pn collectif, rpn en fraction', () => {
+    tvColumnLines.mockReturnValue(['Pn ≤ 70', 'Pn > 70']);
+    tv.mockReturnValue({ ...ROW_PN });
+    let formuleRpn;
+    conventionPuissanceNominale.mockImplementation((pn, ratio, _, __, ___, fn) => {
+      formuleRpn = fn;
+      return { pn, ratio, convention: 'individualisee' };
+    });
+    const di = { pn: 23000, rpint: 0.85 };
+    const de = {
+      enum_type_generateur_ch_id: '89',
+      ratio_virtualisation: 0.1,
+      presence_ventouse: 0
+    };
+    tv_generateur_combustion({}, di, de, 'ch', 200, -9, 1);
+    expect(conventionPuissanceNominale.mock.calls[0][2]).toEqual({
+      rpn: undefined,
+      rpint: 0.85,
+      qp0: undefined
+    });
+
+    tv.mockClear();
+    const formule = formuleRpn(696000);
+    // Pn collectif = 696 kW (ratio 1) -> critère « Pn > 70 »
+    expect(tv).toHaveBeenCalledWith(
+      'generateur_combustion',
+      expect.objectContaining({ critere_pn: 'Pn > 70' })
+    );
+    // Référence de régression : rpn = (84 + 2 log10(696)) / 100
+    expect(formule(696000)).toBeCloseTo((84 + 2 * Math.log10(696)) / 100, 9);
+  });
+
+  test('formule rpn : ligne absente ou sans rpn -> aucune formule', () => {
+    tv.mockReturnValueOnce({ ...ROW_PN });
+    let formuleRpn;
+    conventionPuissanceNominale.mockImplementation((pn, ratio, _, __, ___, fn) => {
+      formuleRpn = fn;
+      return { pn, ratio, convention: 'individualisee' };
+    });
+    const de = {
+      enum_type_generateur_ch_id: '89',
+      ratio_virtualisation: 0.1,
+      presence_ventouse: 0
+    };
+    tv_generateur_combustion({}, { pn: 23000 }, de, 'ch', 200, -9, 1);
+    tv.mockReturnValueOnce(null).mockReturnValueOnce({ ...ROW_PN, rpn: undefined });
+    expect(formuleRpn(696000)).toBeUndefined();
+    expect(formuleRpn(696000)).toBeUndefined();
+  });
+
+  test('pn recalculé depuis rpn : Pe retenu, ligne re-sélectionnée et avertissement explicite', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    tv.mockReturnValueOnce({ ...ROW_PN }).mockReturnValue({
+      ...ROW_PN,
+      tv_generateur_combustion_id: '43'
+    });
+    conventionPuissanceNominale.mockReturnValue({
+      pn: 2300,
+      ratio: 0.1,
+      convention: 'puissance_depuis_rpn',
+      pnCollectif: 23000
+    });
+    const di = { pn: 230, rpn: 0.8672, rpint: 0.8408 };
+    const de = {
+      description: 'Chaudière collective',
+      enum_type_generateur_ch_id: '89',
+      ratio_virtualisation: 0.1,
+      presence_ventouse: 0
+    };
+    tv_generateur_combustion({}, di, de, 'ch', 200, -9, 1);
+    expect(di.pn).toBe(2300);
+    expect(de.tv_generateur_combustion_id).toBe(43);
+    // Formules évaluées sur Pn collectif = 2300 / 0.1 = 23 kW
+    expect(di.rpn).toBeCloseTo((84 + 2 * Math.log10(23)) / 100, 9);
+    const message = warnSpy.mock.calls[0][0];
+    expect(message).toContain('(230 W)');
+    expect(message).toContain('Pn = 23 kW');
+    expect(message).toContain('Pe = a × Pn = 2300 W');
+    warnSpy.mockRestore();
+  });
+
+  test('fonction de caractéristiques fournie : ligne et formules évaluées sur pn / ratio', () => {
+    tvColumnLines.mockReturnValue(['Pn ≤ 70', 'Pn > 70']);
+    tv.mockReturnValue({ ...ROW_PN });
+    let caracteristiques;
+    conventionPuissanceNominale.mockImplementation((pn, ratio, _, fn) => {
+      caracteristiques = fn;
+      return { pn, ratio, convention: 'individualisee' };
+    });
+    const di = { pn: 23000 };
+    const de = {
+      enum_type_generateur_ch_id: '89',
+      ratio_virtualisation: 0.1,
+      presence_ventouse: 0
+    };
+    tv_generateur_combustion({}, di, de, 'ch', 200, -9, 1);
+
+    tv.mockClear();
+    const hypothese = caracteristiques(2300, 0.1);
+    // Pn collectif = 2300 / 0.1 = 23 kW -> critère « Pn ≤ 70 »
+    expect(tv).toHaveBeenCalledWith(
+      'generateur_combustion',
+      expect.objectContaining({ critere_pn: 'Pn ≤ 70' })
+    );
+    // Référence de régression : rpn = (84 + 2 log10(23)) / 100
+    expect(hypothese.rpn).toBeCloseTo((84 + 2 * Math.log10(23)) / 100, 9);
+    // qp0 en % : rapporté à la puissance saisie (2300 W)
+    expect(hypothese.qp0).toBeCloseTo(23, 9);
+  });
+
+  test('aucune ligne pour l’hypothèse testée : repli sur la ligne initiale', () => {
+    tv.mockReturnValueOnce({ ...ROW_PN }).mockReturnValue(null);
+    let caracteristiques;
+    conventionPuissanceNominale.mockImplementation((pn, ratio, _, fn) => {
+      caracteristiques = fn;
+      return { pn, ratio, convention: 'individualisee' };
+    });
+    const di = { pn: 23000 };
+    const de = {
+      enum_type_generateur_ch_id: '89',
+      ratio_virtualisation: 0.1,
+      presence_ventouse: 0
+    };
+    tv_generateur_combustion({}, di, de, 'ch', 200, -9, 1);
+    expect(caracteristiques(23000, 1).rpn).toBeCloseTo((84 + 2 * Math.log10(23)) / 100, 9);
+  });
+
+  test('convention individualisée : pn, ratio et identifiant inchangés', () => {
+    tv.mockReturnValue({ ...ROW_PN });
+    const di = { pn: 23000 };
+    const de = {
+      enum_type_generateur_ch_id: '89',
+      ratio_virtualisation: 0.1,
+      presence_ventouse: 0
+    };
+    tv_generateur_combustion({}, di, de, 'ch', 200, -9, 1);
+    expect(di.pn).toBe(23000);
+    // rpn évalué sur Pn collectif = 230 kW
+    expect(di.rpn).toBeCloseTo((84 + 2 * Math.log10(230)) / 100, 9);
+  });
+
+  test('puissance collective virtualisée : pn ramené à Pe, ligne et identifiant re-sélectionnés', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    tv.mockReturnValueOnce({ ...ROW_PN }).mockReturnValue({
+      ...ROW_PN,
+      tv_generateur_combustion_id: '43'
+    });
+    conventionPuissanceNominale.mockReturnValue({
+      pn: 2300,
+      ratio: 0.1,
+      convention: 'collective_virtualisee'
+    });
+    const di = { pn: 23000, rpn: 0.9, qp0: 23 };
+    const de = {
+      enum_type_generateur_ch_id: '89',
+      ratio_virtualisation: 0.1,
+      presence_ventouse: 0
+    };
+    tv_generateur_combustion({}, di, de, 'ch', 200, -9, 1);
+    expect(di.pn).toBe(2300);
+    expect(de.tv_generateur_combustion_id).toBe(43);
+    // Formules évaluées sur Pn collectif = 2300 / 0.1 = 23 kW
+    expect(di.rpn).toBeCloseTo((84 + 2 * Math.log10(23)) / 100, 9);
+    expect(di.rpint).toBeCloseTo((80 + 3 * Math.log10(23)) / 100, 9);
+    expect(di.qp0).toBeCloseTo(23, 9);
+    expect(warnSpy).toHaveBeenCalled();
+    warnSpy.mockRestore();
+  });
+
+  test('puissance collective non virtualisée (bug_for_bug_compat) : calcul sur pn avec ratio 1', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    state.bug = true;
+    tv.mockReturnValue({ ...ROW_PN });
+    conventionPuissanceNominale.mockReturnValue({
+      pn: 23000,
+      ratio: 1,
+      convention: 'collective_non_virtualisee'
+    });
+    const di = { pn: 23000, rpn: 0.87, qp0: 0.23 };
+    const de = {
+      enum_type_generateur_ch_id: '89',
+      ratio_virtualisation: 0.1,
+      presence_ventouse: 0
+    };
+    tv_generateur_combustion({}, di, de, 'ch', 200, -9, 1);
+    expect(di.pn).toBe(23000);
+    expect(di.rpn).toBeCloseTo((84 + 2 * Math.log10(23)) / 100, 9);
+    expect(di.qp0).toBeCloseTo(230, 9);
+    warnSpy.mockRestore();
+  });
+
+  test('générateur collectif par défaut (119, tv_generateur_combustion_id) : pas de détection', () => {
+    state.bug = true;
+    tv.mockReturnValue({ ...ROW_PN });
+    const di = { pn: 23000 };
+    const de = {
+      enum_type_generateur_ch_id: '119',
+      tv_generateur_combustion_id: '42',
+      ratio_virtualisation: 0.1,
+      presence_ventouse: 0
+    };
+    tv_generateur_combustion({}, di, de, 'ch', 200, -9, 1);
+    expect(conventionPuissanceNominale).not.toHaveBeenCalled();
+  });
+});
+
+describe('caracteristiquesGenerateurCombustion - selon la méthode de saisie', () => {
+  const ROW = { rpn: '84 + 2 logPn', rpint: '80 + 3 logPn', qp0_perc: '1%' };
+
+  test('méthode forfaitaire : rpn, rpint et qp0 calculés', () => {
+    expect(
+      Object.keys(caracteristiquesGenerateurCombustion(ROW, 23000, 1, 2.5, -0.8, 'ch', 1))
+    ).toEqual(['rpn', 'rpint', 'qp0']);
+  });
+
+  test('méthode 3 : rpn et rpint saisis, seul qp0 calculé', () => {
+    expect(caracteristiquesGenerateurCombustion(ROW, 23000, 1, 2.5, -0.8, 'ch', 3)).toEqual({
+      qp0: expect.any(Number)
+    });
+  });
+
+  test('méthodes 4 et 5 : aucune caractéristique calculée', () => {
+    expect(caracteristiquesGenerateurCombustion(ROW, 23000, 1, 2.5, -0.8, 'ch', 4)).toEqual({});
+    expect(caracteristiquesGenerateurCombustion(ROW, 23000, 1, 2.5, -0.8, 'ch', 5)).toEqual({});
+  });
+
+  test('qp0 constant en kW (sans % ni Pn) : ramené au logement par le ratio', () => {
+    expect(
+      caracteristiquesGenerateurCombustion({ qp0_perc: '0.5' }, 2300, 0.1, 2.5, -0.8, 'ecs', 1).qp0
+    ).toBeCloseTo(50, 9);
+  });
+});