@open3cl/engine 1.2.9 → 1.3.0

package/11_besoin_ecs.js

@@ -1,6 +1,15 @@
 import { tvs } from './tv.js';
 import { mois_liste, Njj } from './utils.js';
 
+/**
+ * Calcul du besoin ecs en kw/h
+ * @param ca
+ * @param mois
+ * @param zc
+ * @param nadeq
+ * @param depensier
+ * @return {number}
+ */
 export function calc_besoin_ecs_j(ca, mois, zc, nadeq, depensier) {
   const tefsj = tvs.tefs[ca][mois][zc];
   const njj = Njj[mois];

package/14_generateur_ecs.js

@@ -75,27 +75,28 @@ function tv_facteur_couverture_solaire(di, de, zc_id, th) {
   }
 }
 
-// 15.2.3
 export function calc_Qdw_j(instal_ecs, becs_j) {
   const de = instal_ecs.donnee_entree;
   const du = instal_ecs.donnee_utilisateur || {};
 
   const type_installation = requestInput(de, du, 'type_installation');
 
-  let Qdw_ind_vc_j;
-  let Qdw_col_vc_j = 0;
+  const Qdw_ind_vc = calc_Qdw_ind_j(becs_j);
+  const Qdw_coll_vc = calc_Qdw_col_j(instal_ecs, becs_j, type_installation);
 
-  const Rat_ecs = 1;
-  const Lvc = 0.2 * Rat_ecs;
+  return (Qdw_ind_vc + Qdw_coll_vc) * 0.48;
+}
 
-  Qdw_ind_vc_j = 0.5 * Lvc * becs_j;
+// 15.2.3
+export function calc_Qdw_ind_j(becs_j) {
+  return (0.1 * becs_j) / 8760.0;
+}
 
+export function calc_Qdw_col_j(instal_ecs, becs_j, type_installation) {
   if (type_installation.includes('installation collective')) {
-    Qdw_col_vc_j = 0.112 * becs_j;
+    return (0.112 * becs_j) / 8760.0;
   }
-
-  instal_ecs.donnee_utilisateur = du;
-  return Qdw_col_vc_j + Qdw_ind_vc_j;
+  return 0;
 }
 
 function calc_Qgw(di, de, du, ecs_de) {

package/6.1_apport_gratuit.js

@@ -7,7 +7,7 @@ export function calc_ai_j(Sh, nadeq, nrefj) {
    * L'unité retenue est le Wh conformément à la spécification, cependant
    * il est possible de rencontrer des valeurs avec une unité en kWh dans les DPE.
    */
-  return ((3.18 + 0.34) * Sh + 90 * (132 / 168) * nadeq) * nrefj;
+  return ((3.18 + 0.34) * Sh + (132 / 168) * nadeq * 90) * nrefj;
 }
 
 export function calc_as_j(ssej, ej) {

package/8_intermittence.js

@@ -1,5 +1,4 @@
 export function calc_intermittence(GV, Sh, Hsp, i0) {
   const G = GV / (Sh * Hsp);
-  const INT = i0 / (1 + 0.1 * (G - 1));
-  return INT;
+  return i0 / (1 + 0.1 * (G - 1));
 }

package/9_besoin_ch.js

@@ -32,35 +32,37 @@ export default function calc_besoin_ch(
   const Nref21 = tvs.nref21[ilpa];
   const Nref19 = tvs.nref19[ilpa];
 
-  let sumNref19 = 0;
-  let sumNref21 = 0;
   let sumDh19 = 0;
   let sumDh21 = 0;
-  let QrecDistr = 0;
-  let QrecDistrDepensier = 0;
   const e = tvs.e[ilpa];
 
   let pertes_distribution_ecs_recup = 0;
   let pertes_distribution_ecs_recup_depensier = 0;
   let pertes_stockage_ecs_recup = 0;
-  let pertes_stockage_ecs_recup_depensier = 0;
   let pertes_generateur_ch_recup = 0;
   let pertes_generateur_ch_recup_depensier = 0;
   let fraction_apport_gratuit_ch = 0;
   let fraction_apport_gratuit_depensier_ch = 0;
 
-  const Qgw_total = instal_ecs.reduce((acc, instal_ecs) => {
+  /**
+   * 11.4 Plusieurs systèmes d’ECS (limité à 2 systèmes différents par logement)
+   * Les besoins en ECS pour chaque générateur sont / 2
+   */
+  const prorataEcs = instal_ecs.length > 1 ? 0.5 : 1;
+
+  let Qdw_total_ecs = 0;
+  let Qdw_total_ecs_dep = 0;
+  let Qgw_total_ecs = 0;
+  instal_ecs.forEach((instal_ecs) => {
+    let Qgw;
     const gen_ecs = instal_ecs.generateur_ecs_collection.generateur_ecs;
 
     // 17.2.1.1 Calcul des consommations de chauffage, de refroidissement, d’ECS et d’auxiliaires
     // Pour les installations ECS collectives, pas de récupération de stockage d'ECS
     if (Number.parseInt(instal_ecs.donnee_entree.enum_type_installation_id) !== 1) {
-      return acc;
-    }
-
-    return (
-      acc +
-      gen_ecs.reduce((acc, gen_ecs) => {
+      Qgw = 0;
+    } else {
+      Qgw = gen_ecs.reduce((acc, gen_ecs) => {
         // Pas de récupération de stockage si le ballon est hors volume chauffé
         if (
           gen_ecs.donnee_entree.position_volume_chauffe_stockage === 0 ||
@@ -70,15 +72,21 @@ export default function calc_besoin_ch(
         }
 
         return acc + (gen_ecs.donnee_intermediaire.Qgw || 0);
-      }, 0)
-    );
-  }, 0);
+      }, 0);
+    }
 
-  /**
-   * 11.4 Plusieurs systèmes d’ECS (limité à 2 systèmes différents par logement)
-   * Les besoins en ECS pour chaque générateur sont / 2
-   */
-  const prorataEcs = instal_ecs.length > 1 ? 0.5 : 1;
+    Qgw_total_ecs += (0.48 * Qgw * (instal_ecs.donnee_entree.rdim || 1)) / 8760;
+  });
+
+  for (const mois of mois_liste) {
+    // en kw/h
+    const becsj = calc_besoin_ecs_j(ca, mois, zc, nadeq, false) * prorataEcs;
+    // en kw/h
+    const becs_j_dep = calc_besoin_ecs_j(ca, mois, zc, nadeq, true) * prorataEcs;
+
+    Qdw_total_ecs += instal_ecs.reduce((acc, ecs) => acc + calc_Qdw_j(ecs, becsj), 0);
+    Qdw_total_ecs_dep += instal_ecs.reduce((acc, ecs) => acc + calc_Qdw_j(ecs, becs_j_dep), 0);
+  }
 
   /**
    * Création de la liste des générateurs de chauffage pour lesquels il y a une récupération d'énergie
@@ -97,29 +105,17 @@ export default function calc_besoin_ch(
     )
   );
 
+  const besoin_ch_mois = {};
+  const besoin_ch_mois_dep = {};
   for (const mois of mois_liste) {
     const nref19 = Nref19[ca][mois][zc];
     const nref21 = Nref21[ca][mois][zc];
 
-    const Qrec_stock_19 = (0.48 * nref19 * Qgw_total) / (24 * 365);
-    const Qrec_stock_21 = (0.48 * nref21 * Qgw_total) / (24 * 365);
-    pertes_stockage_ecs_recup += Qrec_stock_19 / 1000;
-    pertes_stockage_ecs_recup_depensier += Qrec_stock_21 / 1000;
-
-    // pertes distribution
-    const becs_j = calc_besoin_ecs_j(ca, mois, zc, nadeq, false) * prorataEcs;
-    const becs_j_dep = calc_besoin_ecs_j(ca, mois, zc, nadeq, true) * prorataEcs;
-    sumNref19 += nref19;
-    sumNref21 += nref21;
-
-    QrecDistr += instal_ecs.reduce((acc, ecs) => acc + calc_Qdw_j(ecs, becs_j), 0);
-    QrecDistrDepensier += instal_ecs.reduce((acc, ecs) => acc + calc_Qdw_j(ecs, becs_j_dep), 0);
-
     // bvj
     const dh19j = dh19[ca][mois][zc];
-    sumDh19 += dh19j;
+    sumDh19 += dh19j * GV;
     const dh21j = dh21[ca][mois][zc];
-    sumDh21 += dh21j;
+    sumDh21 += dh21j * GV;
     const aij = calc_ai_j(Sh, nadeq, nref19);
     const aij_dep = calc_ai_j(Sh, nadeq, nref21);
     const ssej = calc_sse_j(bv, ets, ca, zc, mois);
@@ -128,38 +124,46 @@ export default function calc_besoin_ch(
     const Fj = calc_Fj(GV, asj, aij, dh19j, inertie);
     const Fj_dep = calc_Fj(GV, asj, aij_dep, dh21j, inertie);
 
-    fraction_apport_gratuit_ch += Fj * dh19j;
-    fraction_apport_gratuit_depensier_ch += Fj_dep * dh21j;
+    fraction_apport_gratuit_ch += Fj * GV * dh19j;
+    fraction_apport_gratuit_depensier_ch += Fj_dep * GV * dh21j;
 
     const bvj = dh19j === 0 ? 0 : calc_bvj(GV, Fj);
     const bvj_dep = dh21j === 0 ? 0 : calc_bvj(GV, Fj_dep);
 
-    // pertes generation
     const Bch_hp_j = bvj * dh19j;
     const Bch_hp_j_dep = bvj_dep * dh21j;
 
+    let gen_recup = 0;
+    let gen_recup_dep = 0;
+
     gen_ch_recup.forEach((gen_ch) => {
-      pertes_generateur_ch_recup += calc_Qrec_gen_j(gen_ch, nref19, Bch_hp_j) / (1000 * 1000);
-      pertes_generateur_ch_recup_depensier +=
-        calc_Qrec_gen_j(gen_ch, nref21, Bch_hp_j_dep) / (1000 * 1000);
+      gen_recup += calc_Qrec_gen_j(gen_ch, nref19, Bch_hp_j);
+      gen_recup_dep += calc_Qrec_gen_j(gen_ch, nref21, Bch_hp_j_dep);
     });
 
-    besoin_ch += Bch_hp_j / 1000;
-    besoin_ch_depensier += Bch_hp_j_dep / 1000;
-  }
+    pertes_generateur_ch_recup += gen_recup;
+    pertes_generateur_ch_recup_depensier += gen_recup_dep;
+
+    const pertes_distribution_ecs_recup_j = nref19 * Qdw_total_ecs * 1000;
+    const pertes_distribution_ecs_recup_j_dep = nref21 * Qdw_total_ecs_dep * 1000;
+    pertes_distribution_ecs_recup += pertes_distribution_ecs_recup_j;
+    pertes_distribution_ecs_recup_depensier += pertes_distribution_ecs_recup_j_dep;
 
-  pertes_distribution_ecs_recup = (0.48 * sumNref19 * QrecDistr) / 8760;
-  pertes_distribution_ecs_recup_depensier = (0.48 * sumNref21 * QrecDistrDepensier) / 8760;
+    const pertes_stockage_ecs_recup_j = nref19 * Qgw_total_ecs;
+    pertes_stockage_ecs_recup += pertes_stockage_ecs_recup_j;
+    const pertes_stockage_ecs_recup_j_dep = nref21 * Qgw_total_ecs;
 
-  const recup =
-    pertes_distribution_ecs_recup + pertes_stockage_ecs_recup + pertes_generateur_ch_recup;
-  const recup_depensier =
-    pertes_distribution_ecs_recup_depensier +
-    pertes_stockage_ecs_recup_depensier +
-    pertes_generateur_ch_recup_depensier;
+    besoin_ch_mois[mois] = bvj * dh19j;
+    besoin_ch_mois_dep[mois] = bvj_dep * dh21j;
+    besoin_ch_mois[mois] -=
+      pertes_distribution_ecs_recup_j + pertes_stockage_ecs_recup_j + gen_recup;
+    besoin_ch_mois_dep[mois] -=
+      pertes_distribution_ecs_recup_j_dep + pertes_stockage_ecs_recup_j_dep + gen_recup_dep;
+    besoin_ch_mois[mois] = Math.max(besoin_ch_mois[mois], 0);
+    besoin_ch += besoin_ch_mois[mois] / 1000;
 
-  besoin_ch -= recup;
-  besoin_ch_depensier -= recup_depensier;
+    besoin_ch_depensier += besoin_ch_mois_dep[mois] / 1000;
+  }
 
   fraction_apport_gratuit_ch /= sumDh19;
   fraction_apport_gratuit_depensier_ch /= sumDh21;
@@ -167,10 +171,10 @@ export default function calc_besoin_ch(
   return {
     besoin_ch,
     besoin_ch_depensier,
+    besoin_ch_mois,
     pertes_distribution_ecs_recup,
     pertes_distribution_ecs_recup_depensier,
     pertes_stockage_ecs_recup,
-    /* pertes_stockage_ecs_recup_depensier: pertes_stockage_ecs_recup_depensier, */
     pertes_generateur_ch_recup,
     pertes_generateur_ch_recup_depensier,
     fraction_apport_gratuit_ch,
@@ -179,20 +183,17 @@ export default function calc_besoin_ch(
 }
 
 function calc_Fj(GV, asj, aij, dhj, inertie) {
-  if (dhj == 0) return 0;
+  if (dhj === 0) return 0;
 
-  let pow;
-  if (inertie === 'très lourde' || inertie === 'lourde') pow = 3.6;
-  else if (inertie === 'moyenne') pow = 2.9;
-  else if (inertie === 'légère') pow = 2.5;
+  let alpha;
+  if (inertie === 'très lourde' || inertie === 'lourde') alpha = 3.6;
+  else if (inertie === 'moyenne') alpha = 2.9;
+  else if (inertie === 'légère') alpha = 2.5;
 
   const Xj = (asj + aij) / (GV * dhj);
-  const Fj = (Xj - Xj ** pow) / (1 - Xj ** pow);
-  /* console.warn(Fj) */
-  return Fj;
+  return (Xj - Xj ** alpha) / (1 - Xj ** alpha);
 }
 
 function calc_bvj(GV, Fj) {
-  const bvj = GV * (1 - Fj);
-  return bvj;
+  return GV * (1 - Fj);
 }

package/9_chauffage.js

@@ -9,6 +9,9 @@ import { tv_generateur_combustion } from './13.2_generateur_combustion.js';
 import { tv_temp_fonc_30_100 } from './13.2_generateur_combustion_ch.js';
 import enums from './enums.js';
 
+/**
+ * @param dpe {FullDpe}
+ */
 export default function calc_chauffage(
   dpe,
   ch,
@@ -22,7 +25,8 @@ export default function calc_chauffage(
   Sh,
   hsp,
   ac,
-  ilpa
+  ilpa,
+  besoin_ch_mois
 ) {
   const de = ch.donnee_entree;
   const di = {};
@@ -150,7 +154,11 @@ export default function calc_chauffage(
       hsp,
       ca_id,
       zc_id,
-      ilpa
+      ilpa,
+      tbase,
+      besoin_ch_mois,
+      ch.donnee_entree.surface_chauffee,
+      gen_ch
     );
 
     // Si plusieurs générateurs de chauffage, la consommation des auxiliaires est répartie sur chacun d'eux

package/9_conso_ch.js

@@ -1,6 +1,8 @@
-import { requestInputID } from './utils.js';
+import { mois_liste, requestInputID } from './utils.js';
 import { rendement_emission } from './9_emetteur_ch.js';
 import { calc_intermittence } from './8_intermittence.js';
+import tvs from './tv.js';
+import enums from './enums.js';
 
 function coef_ch(Fch) {
   return {
@@ -56,9 +58,32 @@ function coef_ch(Fch) {
   };
 }
 
-export function conso_ch(di, de, du, _pos, cfg_ch, em_list, GV, Sh, hsp, bch, bch_dep) {
+export function conso_ch(
+  di,
+  de,
+  du,
+  _pos,
+  cfg_ch,
+  em_list,
+  GV,
+  Sh,
+  hsp,
+  bch,
+  bch_dep,
+  tbase,
+  ilpa,
+  ca_id,
+  zc_id,
+  besoin_ch_mois,
+  s_chauffee_inst,
+  gen_ch_list
+) {
   const gen_lge_id = requestInputID(de, du, 'lien_generateur_emetteur');
   const coef = coef_ch(de.fch || 0.5)[cfg_ch][_pos] || 1;
+
+  let conso_ch = 0;
+  let conso_ch_dep;
+
   let em_filt;
 
   if (em_list.length === 1) {
@@ -69,27 +94,203 @@ export function conso_ch(di, de, du, _pos, cfg_ch, em_list, GV, Sh, hsp, bch, bc
     );
   }
 
-  const hasMultipleEmetteur = em_filt.length > 1;
-
-  const emetteur_eq = em_filt.reduce((acc, em) => {
-    const int = calc_intermittence(GV, Sh, hsp, em.donnee_intermediaire.i0);
-    const r_em = rendement_emission(em);
-
-    /**
-     * 9.1.3 Installation avec plusieurs émissions pour un même générateur
-     * La part de la consommation traitée par chaque émetteur est proratisé par le ratio des surfaces habitables.
-     * @type {number|number}
-     */
-    const ratio_s = hasMultipleEmetteur
-      ? em.donnee_entree.surface_chauffee / de.surface_chauffee
-      : 1;
-
-    const Ich = 1 / r_em;
-    return acc + ratio_s * int * Ich;
-  }, 0);
-
-  const Ich = emetteur_eq / di.rg;
-  const Ich_dep = emetteur_eq / di.rg_dep;
-  di.conso_ch = coef * Ich * bch;
-  di.conso_ch_depensier = coef * Ich_dep * bch_dep;
+  switch (cfg_ch) {
+    case 'installation de chauffage collectif avec base + appoint': {
+      calc_ch_base_appoint(
+        di,
+        de,
+        bch,
+        besoin_ch_mois,
+        zc_id,
+        ca_id,
+        em_list,
+        gen_ch_list,
+        _pos,
+        GV,
+        Sh,
+        hsp,
+        s_chauffee_inst,
+        ilpa,
+        tbase
+      );
+      break;
+    }
+    case 'installation de chauffage avec chaudière en relève de pac avec insert ou poêle bois en appoint': {
+      calc_ch_pac_insert_bois(di, de, em_list, _pos, bch, GV, Sh, hsp, gen_ch_list);
+      break;
+    }
+    default: {
+      const hasMultipleEmetteur = em_filt.length > 1;
+
+      const emetteur_eq = em_filt.reduce((acc, em) => {
+        const int = calc_intermittence(GV, Sh, hsp, em.donnee_intermediaire.i0);
+        const r_em = rendement_emission(em);
+
+        /**
+         * 9.1.3 Installation avec plusieurs émissions pour un même générateur
+         * La part de la consommation traitée par chaque émetteur est proratisé par le ratio des surfaces habitables.
+         * @type {number|number}
+         */
+        const ratio_s = hasMultipleEmetteur
+          ? em.donnee_entree.surface_chauffee / de.surface_chauffee
+          : 1;
+
+        const Ich = 1 / r_em;
+        return acc + ratio_s * int * Ich;
+      }, 0);
+
+      const Ich = emetteur_eq / di.rg;
+      const Ich_dep = emetteur_eq / di.rg_dep;
+      conso_ch = coef * Ich * bch;
+      conso_ch_dep = coef * Ich_dep * bch_dep;
+
+      di.conso_ch = conso_ch;
+      di.conso_ch_depensier = conso_ch_dep;
+      break;
+    }
+  }
+}
+
+/**
+ * 9.8 Installation de chauffage collectif avec base + appoint
+ */
+function calc_ch_base_appoint(
+  di,
+  de,
+  bch,
+  besoin_ch_mois,
+  zc_id,
+  ca_id,
+  em_list,
+  gen_ch_list,
+  _pos,
+  GV,
+  Sh,
+  hsp,
+  s_chauffee_inst,
+  ilpa,
+  tbase
+) {
+  if (bch > 0) {
+    let bch_base = 0;
+
+    const zc = enums.zone_climatique[zc_id];
+    const ca = enums.classe_altitude[ca_id];
+
+    const emBase = em_list[0];
+    const genBase = gen_ch_list[0];
+    const emAppoint = em_list[1];
+    const genAppoint = gen_ch_list[1];
+    const em = _pos === 0 ? emBase : emAppoint;
+    const gen = _pos === 0 ? genBase : genAppoint;
+    const isAppoint = _pos !== 0;
+    const Int = calc_intermittence(GV, Sh, hsp, em.donnee_intermediaire.i0);
+    const Rend = rendement_emission(em);
+    const Ich = 1 / (gen.donnee_intermediaire.rendement_generation || 1);
+
+    const rd = emBase.donnee_intermediaire.rendement_distribution;
+    const rr = emBase.donnee_intermediaire.rendement_regulation;
+    const re = emBase.donnee_intermediaire.rendement_emission;
+
+    const pn = genBase.donnee_intermediaire.pn;
+    const pe = pn > 0 ? (pn / 1000) * rd * rr * re : 0;
+
+    const dh14 = tvs.dh14;
+    const text = tvs.text;
+    const nrefs = tvs.nref19;
+    const idx_ilpa = ilpa ? 1 : 0;
+
+    const dh14Saison = mois_liste.reduce((acc, mois) => acc + dh14[idx_ilpa][ca][mois][zc], 0);
+    const rdim = de.rdim || 1;
+    const ratio_s = (s_chauffee_inst * rdim) / Sh;
+    const bch1 = (bch * ratio_s) / rdim;
+    const t = 14 - (pe * dh14Saison) / bch1;
+
+    di.conso_ch = 0;
+    for (const mois of mois_liste) {
+      let bch_base_j = 0;
+
+      if (pe > 0) {
+        // Nombre d’heures de chauffage sur le mois j
+        const nrefj = nrefs[idx_ilpa][ca][mois][zc];
+        // Température extérieure moyenne dans la zone climatique sur le mois j (°C)
+        const textj = text[idx_ilpa][ca][mois][zc];
+        // Degrés heures de base 14 pour le mois j (°Ch)
+        const dh14j = dh14[idx_ilpa][ca][mois][zc];
+
+        const xj = 0.5 * ((t - tbase) / (textj - tbase));
+
+        // Degré heure base T sur le mois j
+        let dhtj =
+          nrefj *
+          (textj - tbase) *
+          Math.pow(xj, 5) *
+          (14 - 28 * xj + 20 * Math.pow(xj, 2) - 5 * Math.pow(xj, 3));
+        if (dhtj < 0) {
+          dhtj = 0;
+        }
+
+        let ratioDh = dh14j > 0 ? 1 - dhtj / dh14j : 0;
+        if (ratioDh <= 0) {
+          bch_base_j = 0;
+        } else {
+          bch_base_j = besoin_ch_mois[mois] * ratioDh;
+        }
+      } else {
+        bch_base_j = besoin_ch_mois[mois] * 0.5;
+      }
+      bch_base += bch_base_j;
+    }
+    if (!isAppoint) {
+      const ratio_s_em = em.donnee_entree.surface_chauffee / de.surface_chauffee;
+      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;
+      di.conso_ch = (ratio_s_em * (bch - bch_base / 1000) * Int * Ich) / Rend;
+    }
+
+    di.conso_ch = Math.max(di.conso_ch, 0);
+  }
+}
+
+/**
+ * 9.7 Installation de chauffage avec chaudière en relève de PAC avec insert ou
+ * poêle bois en appoint
+ *
+ * @param di {Donnee_intermediaire}
+ * @param de {Donnee_entree}
+ * @param em_list {EmetteurChauffageItem[]}
+ * @param bch {number}
+ * @param _pos {number}
+ * @param GV {number}
+ * @param Sh {number}
+ * @param hsp {number}
+ * @param gen_ch_list {GenerateurChauffageItem[]}
+ */
+function calc_ch_pac_insert_bois(di, de, em_list, _pos, bch, GV, Sh, hsp, gen_ch_list) {
+  if (bch > 0) {
+    const Ich1 = 1 / (gen_ch_list[0].donnee_intermediaire.rendement_generation || 1);
+    const Ich2 = 1 / (gen_ch_list[1].donnee_intermediaire.rendement_generation || 1);
+    const Ich3 = 1 / (gen_ch_list[2].donnee_intermediaire.rendement_generation || 1);
+
+    em_list.forEach((em) => {
+      const ratio_s_em = em.donnee_entree.surface_chauffee / de.surface_chauffee;
+      const Int = calc_intermittence(GV, Sh, hsp, em.donnee_intermediaire.i0);
+      const Rend = rendement_emission(em);
+
+      if (em.donnee_entree.enum_lien_generateur_emetteur_id === '1' && (_pos === 0 || _pos === 1)) {
+        if (_pos === 0) {
+          di.conso_ch = (ratio_s_em * Ich1 * bch * Int * 0.8 * 0.75) / Rend;
+        }
+        if (_pos === 1) {
+          di.conso_ch = (ratio_s_em * Ich2 * bch * Int * 0.8 * 0.25) / Rend;
+        }
+      } else if (_pos === 2) {
+        di.conso_ch = ratio_s_em * ((Ich3 * bch * Int * 0.25) / Rend);
+      }
+    });
+
+    console.log(di.conso_ch);
+  }
 }

package/9_emetteur_ch.js

@@ -3,11 +3,11 @@ import { TvsStore } from './core/tv/infrastructure/tvs.store.js';
 
 const tvsStore = new TvsStore();
 
-export function rendement_emission(em) {
+export function rendement_emission(em, rg = 1) {
   const re = em.donnee_intermediaire.rendement_emission;
   const rd = em.donnee_intermediaire.rendement_distribution;
   const rr = em.donnee_intermediaire.rendement_regulation;
-  return re * rd * rr;
+  return rg * re * rd * rr;
 }
 
 function tv_rendement_distribution_ch(di, de) {

package/9_generateur_ch.js

@@ -6,14 +6,15 @@ import { calc_generateur_combustion_ch } from './13.2_generateur_combustion_ch.j
 import { scopOrCop } from './12.4_pac.js';
 import { updateGenerateurCombustion } from './13.2_generateur_combustion.js';
 
+const ENUM_MATERIAUX_STRUCTURE_MUR_ANCIEN_IDS = ['2', '3', '4', '6', '8', '9', '14', '21'];
+const ENUM_CLASSES_INERTIE_LOURDES_IDS = ['1', '2'];
+
 function pertes_gen_ch(Bch_hp_j, pn) {
-  const pertes = (1.3 * Bch_hp_j) / (0.3 * pn);
-  return pertes;
+  return (1.3 * Bch_hp_j) / (0.3 * pn);
 }
 
 function pertes_gen_ecs(nrefj) {
-  const pertes = (nrefj * 1790) / 8760;
-  return pertes;
+  return (nrefj * 1790) / 8760;
 }
 
 export function calc_Qrec_gen_j(gen_ch, nrefj, Bch_hp_j) {
@@ -40,8 +41,7 @@ export function calc_Qrec_gen_j(gen_ch, nrefj, Bch_hp_j) {
   }
 
   gen_ch.donnee_utilisateur = du;
-  const Qrec_gen_j = 0.48 * Cper * di.qp0 * Dperj || 0;
-  return Qrec_gen_j;
+  return 0.48 * Cper * di.qp0 * Dperj || 0;
 }
 
 function tv_rendement_generation(di, de, du) {
@@ -159,7 +159,11 @@ export function calc_generateur_ch(
   hsp,
   ca_id,
   zc_id,
-  ilpa
+  ilpa,
+  tbase,
+  besoin_ch_mois,
+  s_chauffee_inst,
+  gen_ch_list
 ) {
   const de = gen_ch.donnee_entree;
   const du = gen_ch.donnee_utilisateur || {};
@@ -201,8 +205,27 @@ export function calc_generateur_ch(
   if (hasConsoForAuxDistribution(de.enum_type_generateur_ch_id)) {
     conso_aux_distribution_ch(em_ch, de, di, du, Sh, zc_id, ca_id, ilpa, GV);
   }
-
-  conso_ch(di, de, du, _pos, cfg_ch, em_ch, GV, Sh, hsp, bch, bch_dep);
+  const paroi_ancienne = isParoisAncienneInertieLourde(dpe);
+  conso_ch(
+    di,
+    de,
+    du,
+    _pos,
+    cfg_ch,
+    em_ch,
+    GV,
+    Sh,
+    hsp,
+    bch,
+    bch_dep,
+    tbase,
+    paroi_ancienne,
+    ca_id,
+    zc_id,
+    besoin_ch_mois,
+    s_chauffee_inst,
+    gen_ch_list
+  );
 
   gen_ch.donnee_intermediaire = di;
   gen_ch.donnee_utilisateur = du;
@@ -228,3 +251,32 @@ export function hasConsoForAuxDistribution(enum_type_generateur_ch_id) {
     (enum_type_generateur_ch_id >= 4 && enum_type_generateur_ch_id <= 19)
   );
 }
+
+/**
+ * 18.3 Cas des bâtiments à inertie lourde, constitués de parois anciennes
+ *
+ * Afin d’être considéré comme un bâtiment à inertie lourde, constitués de parois anciennes, le bâtiment doit :
+ * * Etre constitué de murs en matériaux anciens : terre, pierre, brique ancienne, colombage, … ;
+ * * Avoir une inertie lourde.
+ *
+ * En présence de plusieurs types de parois, le bâtiment sera considéré comme constitué de parois anciennes si la surface
+ * de parois anciennes est majoritaire.
+ * @param dpe {FullDpe}
+ */
+function isParoisAncienneInertieLourde(dpe) {
+  const murs = dpe.logement.enveloppe.mur_collection.mur.filter(
+    (mur) => mur.donnee_intermediaire.b > 0
+  );
+  const nbTotalMurs = murs.length;
+  const nbMursAnciens = murs.filter((mur) =>
+    ENUM_MATERIAUX_STRUCTURE_MUR_ANCIEN_IDS.includes(
+      mur.donnee_entree.enum_materiaux_structure_mur_id
+    )
+  ).length;
+
+  const isInertieLourde = ENUM_CLASSES_INERTIE_LOURDES_IDS.includes(
+    dpe.logement.enveloppe.inertie.enum_classe_inertie_id
+  );
+
+  return isInertieLourde && nbMursAnciens / nbTotalMurs >= 0.5;
+}

package/9_generateur_ch.spec.js

@@ -3,6 +3,11 @@ import { describe, expect, test } from 'vitest';
 
 describe('Recherche de bugs dans le calcul de la consommation des generateurs de chauffage', () => {
   test('calcul de la consommation des generateurs de chauffage pour 2475E2510509B', () => {
+    const dpe = {
+      logement: {
+        enveloppe: { inertie: { enum_classe_inertie_id: '5' }, mur_collection: { mur: [] } }
+      }
+    };
     const gen_ch = {
       donnee_entree: {
         description: 'Electrique - Convecteur électrique NFC, NF** et NF***',
@@ -60,6 +65,7 @@ describe('Recherche de bugs dans le calcul de la consommation des generateurs de
     const ac = 1;
 
     calc_generateur_ch(
+      dpe,
       gen_ch,
       _pos,
       em_ch,

package/engine.js

@@ -434,6 +434,8 @@ export function calcul_3cl(dpe) {
 
   const bch = apport_et_besoin.besoin_ch;
   const bch_dep = apport_et_besoin.besoin_ch_depensier;
+  const besoin_ch_mois = { ...apport_et_besoin.besoin_ch_mois };
+  delete apport_et_besoin.besoin_ch_mois;
 
   /**
    * 13.2.1.2 Présence d’un ou plusieurs générateurs à combustion indépendants
@@ -455,7 +457,8 @@ export function calcul_3cl(dpe) {
       ShChauffageAndEcs,
       hsp,
       ac,
-      ilpa
+      ilpa,
+      besoin_ch_mois
     );
   });
 

package/package.json

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

package/utils.js

@@ -57,6 +57,7 @@ export const Njj = {
 // sum all Njj values
 export const Njj_sum = Object.values(Njj).reduce((acc, val) => acc + val, 0);
 
+/** @type {string[]} **/
 export const mois_liste = [
   'Janvier',
   'Février',