@open3cl/engine 1.8.30 → 1.8.31

package/9_conso_ch.js

@@ -59,6 +59,11 @@ function coef_ch(Fch) {
   };
 }
 
+/**
+ * Calcule la consommation de chauffage du générateur (di.conso_ch, di.conso_ch_depensier).
+ * @return {number} besoin de chauffage effectivement couvert par le générateur (kWh), utilisé
+ * pour ses auxiliaires de génération (§15.1 : Caux_g = Paux_g × Bch_générateur / Pn)
+ */
 export function conso_ch(
   di,
   de,
@@ -94,7 +99,7 @@ export function conso_ch(
 
   switch (cfg_ch) {
     case 'installation de chauffage collectif avec base + appoint': {
-      calc_ch_base_appoint(
+      return calc_ch_base_appoint(
         di,
         de,
         bch,
@@ -111,7 +116,6 @@ export function conso_ch(
         ilpa,
         tbase
       );
-      break;
     }
     case 'convecteurs bi-jonction': {
       // Installation individuelle
@@ -136,7 +140,7 @@ export function conso_ch(
       di.conso_ch = consoInd.conso_ch + consoColl.conso_ch;
       di.conso_ch_depensier = consoInd.conso_ch_dep + consoColl.conso_ch_dep;
 
-      break;
+      return bch;
     }
     default: {
       const { conso_ch, conso_ch_dep } = calc_conso_ch_default(
@@ -155,7 +159,12 @@ export function conso_ch(
       );
       di.conso_ch = conso_ch;
       di.conso_ch_depensier = conso_ch_dep;
-      break;
+      /**
+       * Part du besoin couverte par le générateur selon la configuration (ex. 0,75 / 0,25 pour une
+       * chaudière en relève d'une chaudière bois, 0,8 / 0,2 pour une chaudière en relève de PAC).
+       * Les PAC hybrides ont déjà leur part (prorata de zone) dans bch.
+       */
+      return isPacHybride(de.enum_type_generateur_ch_id) ? bch : coef * bch;
     }
   }
 }
@@ -224,6 +233,12 @@ function calc_ch_base_appoint(
   ilpa,
   tbase
 ) {
+  /**
+   * Besoin couvert par le générateur : part de base (pos 0) ou d'appoint (bch - base), au prorata
+   * de la surface de ses émetteurs. Autotest CSTB APP3-0-3 : chaudière bois en base (Tribu
+   * Bgen = 3108,34 kWh, Qaux_ch = 13,27 kWh), générateur d'air chaud en appoint (Qaux_ch = 0).
+   */
+  let besoinCouvert = 0;
   if (bch > 0) {
     let bch_base = 0;
 
@@ -296,15 +311,28 @@ function calc_ch_base_appoint(
     }
     if (!isAppoint) {
       const ratio_s_em = em.donnee_entree.surface_chauffee / de.surface_chauffee;
+      besoinCouvert = ratio_s_em * (bch_base / 1000);
       di.conso_ch = (ratio_s_em * (bch_base / 1000) * Ich * Int) / Rend;
     } else {
       const ratio_s_em =
         em.donnee_entree.surface_chauffee / emAppoint.donnee_entree.surface_chauffee;
+      besoinCouvert = ratio_s_em * (bch - bch_base / 1000);
       di.conso_ch = (ratio_s_em * (bch - bch_base / 1000) * Int * Ich) / Rend;
     }
 
     di.conso_ch = Math.max(di.conso_ch, 0);
   }
+  return Math.max(besoinCouvert, 0);
+}
+
+/**
+ * PAC hybride (partie PAC ou partie chaudière) : enum_type_generateur_ch_id 145 à 170.
+ * @param typeGenerateurId {string|number}
+ * @return {boolean}
+ */
+export function isPacHybride(typeGenerateurId) {
+  const id = Number.parseInt(typeGenerateurId);
+  return id >= 145 && id <= 170;
 }
 
 function getEmetteursFromGenerateur(de, em_filt, pos, cfg_ch) {

package/9_conso_ch.spec.js

@@ -50,7 +50,7 @@ vi.mock('./enums.js', () => ({
   }
 }));
 
-const { conso_ch } = await import('./9_conso_ch.js');
+const { conso_ch, isPacHybride } = await import('./9_conso_ch.js');
 const { default: tvs } = await import('./tv.js');
 const { requestInputID } = await import('./utils.js');
 const { rendement_emission } = await import('./9_emetteur_ch.js');
@@ -366,7 +366,7 @@ describe('conso_ch - installation collective base + appoint', () => {
       s_chauffee_inst,
       gen_ch_list
     ] = baseAppointArgs(pos, opts);
-    conso_ch(
+    di.besoinCouvert = conso_ch(
       di,
       de,
       {},
@@ -401,6 +401,23 @@ describe('conso_ch - installation collective base + appoint', () => {
     expect(di.conso_ch).toBeCloseTo(55.55555555555556, 9);
   });
 
+  /**
+   * Besoin couvert retourné (auxiliaires de génération, §15.1) : base = Σ besoin de base (kWh),
+   * appoint = bch - base ; la somme vaut le besoin de l'installation (50 kWh).
+   */
+  test('besoin couvert : part de base (pos 0) et part d’appoint (pos 1) = besoin total', () => {
+    const base = callBaseAppoint(0).besoinCouvert;
+    const appoint = callBaseAppoint(1).besoinCouvert;
+    // référence de régression
+    expect(base).toBeCloseTo(5, 9);
+    expect(appoint).toBeCloseTo(45, 9);
+    expect(base + appoint).toBeCloseTo(50, 9);
+  });
+
+  test('besoin couvert nul quand la part de base calculée est nulle', () => {
+    expect(callBaseAppoint(0, { pn: 100 }).besoinCouvert).toBe(0);
+  });
+
   test('puissance nulle (pe = 0) : le besoin de base est forfaitairement la moitié du besoin', () => {
     const di = callBaseAppoint(0, { pn: 0 });
     // pe = 0 => bch_base_j = besoin_ch_mois * 0.5 sur chaque mois
@@ -509,3 +526,106 @@ describe('conso_ch - installation collective base + appoint', () => {
     expect(di.conso_ch).toBeUndefined();
   });
 });
+
+/**
+ * Besoin couvert par le générateur (retour de conso_ch), utilisé pour ses auxiliaires de
+ * génération (§15.1 : Caux_g = Paux_g × Bch_générateur / Pn).
+ * Autotests CSTB APP5-0-5 (relève de PAC, 0,8 / 0,2) et IC4-0-1 (relève d'une chaudière bois,
+ * 0,75 / 0,25).
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §9 et §15.1
+ */
+describe('conso_ch - besoin couvert par le générateur', () => {
+  beforeEach(() => {
+    vi.mocked(requestInputID).mockReset();
+    vi.mocked(rendement_emission).mockReset();
+    vi.mocked(calc_intermittence).mockReset();
+    vi.mocked(rendement_emission).mockReturnValue(0.8);
+    vi.mocked(calc_intermittence).mockImplementation((_gv, _sh, _hsp, i0) => i0);
+  });
+
+  function appel(de, pos, cfg, bch = 1000) {
+    const di = { rg: 1, rg_dep: 1 };
+    return conso_ch(
+      di,
+      { surface_chauffee: 100, ...de },
+      {},
+      pos,
+      cfg,
+      [emetteur(1)],
+      150,
+      100,
+      2.5,
+      bch,
+      2 * bch,
+      -9.5,
+      0,
+      1,
+      1
+    );
+  }
+
+  test.each([
+    ['installation de chauffage avec chaudière en relève de pac', 0, 800],
+    ['installation de chauffage avec chaudière en relève de pac', 1, 200],
+    [
+      'installation de chauffage avec une chaudière ou une pac en relève d’une chaudière bois',
+      0,
+      750
+    ],
+    [
+      'installation de chauffage avec une chaudière ou une pac en relève d’une chaudière bois',
+      1,
+      250
+    ],
+    ['installation de chauffage simple', 0, 1000]
+  ])('%s, position %i : besoin couvert = coefficient × besoin (%d)', (cfg, pos, attendu) => {
+    expect(appel({ enum_type_generateur_ch_id: '10' }, pos, cfg)).toBeCloseTo(attendu, 9);
+  });
+
+  test('PAC hybride : part déjà appliquée au besoin, pas de second coefficient', () => {
+    const cfg = 'installation de chauffage avec chaudière en relève de pac';
+    expect(appel({ enum_type_generateur_ch_id: '148' }, 1, cfg)).toBe(1000);
+  });
+
+  test('convecteurs bi-jonction : tout le besoin est couvert', () => {
+    expect(appel({ enum_type_generateur_ch_id: '10' }, 0, 'convecteurs bi-jonction')).toBe(1000);
+  });
+
+  test('base + appoint collectif : besoin nul => besoin couvert nul', () => {
+    const di = { rg: 1, rg_dep: 1, pn: 0 };
+    const couvert = conso_ch(
+      di,
+      { surface_chauffee: 100, enum_type_generateur_ch_id: '10' },
+      {},
+      0,
+      'installation de chauffage collectif avec base + appoint',
+      [emetteur(1)],
+      150,
+      100,
+      2.5,
+      0,
+      0,
+      -9.5,
+      0,
+      1,
+      1,
+      { Janvier: 0, Février: 0 },
+      100,
+      []
+    );
+    expect(couvert).toBe(0);
+  });
+});
+
+describe('isPacHybride', () => {
+  test.each([
+    ['145', true],
+    [170, true],
+    ['148', true],
+    ['144', false],
+    ['171', false],
+    [undefined, false]
+  ])('type %s : %s', (id, attendu) => {
+    expect(isPacHybride(id)).toBe(attendu);
+  });
+});

package/9_generateur_ch.js

@@ -249,8 +249,6 @@ export function calc_generateur_ch(
     tv_rendement_generation(di, de, du);
   }
 
-  conso_aux_gen(di, de, 'ch', bch, bch_dep);
-
   /**
    * 15 Calcul des consommations d’auxiliaires des installations de chauffage (Caux_ch) et d’ECS (Caux_ecs)
    */
@@ -258,7 +256,7 @@ export function calc_generateur_ch(
     conso_aux_distribution_ch(em_ch, de, di, du, Sh, zc_id, ca_id, ilpa, GV);
   }
   const paroi_ancienne = isParoisAncienneInertieLourde(dpe);
-  conso_ch(
+  const besoinCouvert = conso_ch(
     di,
     de,
     du,
@@ -279,6 +277,17 @@ export function calc_generateur_ch(
     gen_ch_list
   );
 
+  /**
+   * 15.1 Auxiliaires de génération : Caux_g = Paux_g × Bch / Pn, avec Bch le besoin couvert par
+   * ce générateur (part de base / d'appoint, relève), et non le besoin de toute l'installation.
+   * Autotests CSTB APP5-0-5 (chaudière fioul en relève de PAC, Tribu Qaux_ch = 2,13 kWh) et
+   * IC4-0-1 (chaudière en relève d'une chaudière bois).
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §15.1
+   */
+  const besoinGenerateur = besoinCouvert ?? bch;
+  const besoinGenerateurDep = bch > 0 ? (bch_dep * besoinGenerateur) / bch : 0;
+  conso_aux_gen(di, de, 'ch', besoinGenerateur, besoinGenerateurDep);
+
   gen_ch.donnee_intermediaire = di;
   gen_ch.donnee_utilisateur = du;
 }

package/9_generateur_ch.spec.js

@@ -602,3 +602,71 @@ describe('calc_generateur_ch - orchestration du calcul générateur', () => {
     expect(gen.donnee_utilisateur).toBeDefined();
   });
 });
+
+/**
+ * 15.1 Auxiliaires de génération : Caux_g = Paux_g × Bch_générateur / Pn, avec le besoin
+ * effectivement couvert par le générateur (retourné par conso_ch : part de relève, de base ou
+ * d'appoint) et non le besoin de toute l'installation.
+ * Autotest CSTB APP5-0-5 : chaudière fioul en relève de PAC (part 0,2), Tribu Qaux_ch = 2,13 kWh.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §15.1
+ */
+describe('calc_generateur_ch - besoin couvert transmis aux auxiliaires de génération', () => {
+  const dpe = {
+    logement: {
+      enveloppe: { inertie: { enum_classe_inertie_id: '3' }, mur_collection: { mur: [] } }
+    }
+  };
+
+  function appel(gen, bch, bchDep) {
+    calc_generateur_ch(
+      dpe,
+      gen,
+      1,
+      [{ donnee_entree: { enum_lien_generateur_emetteur_id: '1' } }],
+      'installation de chauffage avec chaudière en relève de pac',
+      bch,
+      bchDep,
+      150,
+      100,
+      2.5,
+      1,
+      1,
+      0,
+      -9.5,
+      {},
+      100,
+      [gen]
+    );
+  }
+
+  test('relève : besoin couvert (part 0,2) et dépensier au même prorata', () => {
+    vi.mocked(conso_ch).mockReturnValue(200);
+    const gen = { donnee_entree: { enum_type_generateur_ch_id: '1' }, donnee_intermediaire: {} };
+    appel(gen, 1000, 1500);
+    expect(conso_aux_gen).toHaveBeenCalledWith(
+      gen.donnee_intermediaire,
+      gen.donnee_entree,
+      'ch',
+      200,
+      300
+    );
+    // les auxiliaires de génération sont calculés après la consommation du générateur
+    expect(vi.mocked(conso_ch).mock.invocationCallOrder[0]).toBeLessThan(
+      vi.mocked(conso_aux_gen).mock.invocationCallOrder[0]
+    );
+  });
+
+  test('conso_ch sans besoin couvert retourné : repli sur le besoin transmis', () => {
+    vi.mocked(conso_ch).mockReturnValue(undefined);
+    const gen = { donnee_entree: { enum_type_generateur_ch_id: '1' }, donnee_intermediaire: {} };
+    appel(gen, 1000, 1500);
+    expect(vi.mocked(conso_aux_gen).mock.calls[0].slice(2)).toEqual(['ch', 1000, 1500]);
+  });
+
+  test('besoin nul : besoin dépensier nul (pas de division par zéro)', () => {
+    vi.mocked(conso_ch).mockReturnValue(0);
+    const gen = { donnee_entree: { enum_type_generateur_ch_id: '1' }, donnee_intermediaire: {} };
+    appel(gen, 0, 0);
+    expect(vi.mocked(conso_aux_gen).mock.calls[0].slice(2)).toEqual(['ch', 0, 0]);
+  });
+});

package/engine.js

@@ -33,7 +33,7 @@ import getFicheTechnique from './ficheTechnique.js';
 import { ProductionENR } from './16.2_production_enr.js';
 import DpeSanitizerService from './dpe-sanitizer.service.js';
 
-const LIB_VERSION = '1.8.30';
+const LIB_VERSION = '1.8.31';
 
 const dpeSanitizerService = new DpeSanitizerService();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open3cl/engine",
-  "version": "1.8.30",
+  "version": "1.8.31",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {