@open3cl/engine 1.7.2 → 1.8.0

package/11_besoin_ecs.js

@@ -24,11 +24,14 @@ export function calc_besoin_ecs_j(ca, mois, zc, nadeq, depensier) {
 export default function calc_besoin_ecs(ca, zc, nadeq) {
   const ret = {
     besoin_ecs: 0,
-    besoin_ecs_depensier: 0
+    besoin_ecs_depensier: 0,
+    besoin_ecs_par_mois: {}
   };
   for (const mois of mois_liste) {
-    ret.besoin_ecs += calc_besoin_ecs_j(ca, mois, zc, nadeq, false);
+    const becs_j = calc_besoin_ecs_j(ca, mois, zc, nadeq, false);
+    ret.besoin_ecs += becs_j;
     ret.besoin_ecs_depensier += calc_besoin_ecs_j(ca, mois, zc, nadeq, true);
+    ret.besoin_ecs_par_mois[mois] = becs_j;
   }
   return ret;
 }

package/11_ecs.js

@@ -1,6 +1,6 @@
 import enums from './enums.js';
 import calc_gen_ecs from './14_generateur_ecs.js';
-import { tv, requestInput } from './utils.js';
+import { tv, requestInput, mois_liste, Njj } from './utils.js';
 
 function tv_rendement_distribution_ecs(di, de, du, pvc) {
   let matcher = {};
@@ -49,6 +49,89 @@ function tv_rendement_distribution_ecs(di, de, du, pvc) {
   }
 }
 
+/**
+ * Calcul de la consommation des auxiliaires de distribution ECS - CAS IMMEUBLE
+ * Calcul installation par installation pour les réseaux collectifs bouclés ou avec traçage.
+ *
+ * @param {object} de - donnee_entree de l'installation ECS
+ * @param {number} surfaceImmeuble - surface habitable totale de l'immeuble (m²)
+ * @param {object} becsParMois - besoin ECS mensuel de l'immeuble {Janvier: X, Février: X, ...} [kWh]
+ * @returns {number} conso_auxiliaire_distribution_ecs_installation [Wh]
+ */
+function calc_auxiliaire_distribution_ecs_immeuble(de, surfaceImmeuble, becsParMois) {
+  const type_installation = enums.type_installation[de.enum_type_installation_id];
+
+  // Seulement pour les installations collectives
+  if (!type_installation || !type_installation.includes('collective')) {
+    return 0;
+  }
+
+  const enum_bouclage_id = String(de.enum_bouclage_reseau_ecs_id);
+  const surface_installation = de.surface_habitable || 0;
+  const surface_immeuble_total = surfaceImmeuble || 1;
+  const ratio_surface = surface_installation / surface_immeuble_total;
+
+  // CAS 1 : réseau non bouclé → 0
+  if (enum_bouclage_id === '1') {
+    return 0;
+  }
+
+  // CAS 3 : traçage → 0.14 × BECS_annuel × ratio_surface [Wh]
+  if (enum_bouclage_id === '3') {
+    const becs_annuel_kwh = Object.values(becsParMois).reduce((acc, v) => acc + v, 0);
+    // becs_annuel est en kWh → × 1000 pour obtenir des Wh
+    return 0.14 * becs_annuel_kwh * 1000 * ratio_surface;
+  }
+
+  // CAS 2 : réseau bouclé → calcul complet 9 étapes [Wh]
+  if (enum_bouclage_id === '2') {
+    const Sh_inst = surface_installation;
+    const Niv_inst = Number(de.nombre_niveau_installation_ecs) || 1;
+
+    // Étape 3 : Calcul de Lb pour l'installation i
+    // Lb = 1.2 × (1.1 × Sh_inst/nombre_niveaux + 4 × nombre_niveaux)
+    const Lb = 1.2 * (1.1 * (Sh_inst / Niv_inst) + 4 * Niv_inst);
+
+    // Étape 4 : DeltaPb = 0.2 × Lb + 10
+    const DeltaPb = 0.2 * Lb + 10;
+
+    let Qcirc_annuel = 0;
+
+    for (const mois of mois_liste) {
+      const Njj_mois = Njj[mois];
+      const becs_immeuble_j_kwh = becsParMois[mois] || 0;
+
+      // Étape 1 : Qdwj_i [kWh]
+      const Qdwj_i = 0.24 * becs_immeuble_j_kwh * ratio_surface;
+
+      // Étape 2 : qdwj_i [m³/h]
+      // Note: la spec officielle utilise Qdwj en Wh et divise par 1000 ensuite.
+      // Le moteur fournit becs en kWh, donc Qdwj est en kWh → on ne divise pas par 1000.
+      const qdwj_i = Qdwj_i / (5.815 * 5 * Njj_mois);
+
+      // Étape 5 : Phyd,j [W]
+      // Phyd,j = DeltaPb [kPa] × 1000 × qdwj_i [m³/h] / 3600
+      const Phyd_j = (DeltaPb * 1000 * qdwj_i) / 3600;
+
+      // Étape 6 : Effcirb,j (rendement pompe)
+      const Effcirb_j = Phyd_j > 0 ? 0.035 * Math.pow(Phyd_j, 0.45) : 0;
+
+      // Étape 7 : Pcirb,j [W] = max(Phyd,j / Effcirb,j, 20)
+      const Pcirb_j = Effcirb_j > 0 ? Math.max(Phyd_j / Effcirb_j, 20) : 20;
+
+      // Étape 8 : Qcirb,j [Wh]
+      const Qcirb_j = (5 * Pcirb_j + 19 * 20) * Njj_mois;
+
+      Qcirc_annuel += Qcirb_j;
+    }
+
+    // Étape 9 : conso annuelle en Wh
+    return Qcirc_annuel;
+  }
+
+  return 0;
+}
+
 export default function calc_ecs(
   dpe,
   ecs,
@@ -61,7 +144,8 @@ export default function calc_ecs(
   virtualisationECS,
   surfaceImmeuble,
   nombreAppartements,
-  isImmeubleSystemEcsIndividuels
+  isImmeubleSystemEcsIndividuels,
+  becsParMois
 ) {
   const de = ecs.donnee_entree;
   const di = {};
@@ -101,6 +185,19 @@ export default function calc_ecs(
     0
   );
 
+  // Calcul de la consommation des auxiliaires de distribution ECS pour l'immeuble
+  // Résultat en Wh, converti en kWh pour cohérence avec le reste du moteur
+  if (th === 'immeuble' && becsParMois && Object.keys(becsParMois).length > 0) {
+    const conso_aux_wh = calc_auxiliaire_distribution_ecs_immeuble(
+      de,
+      surfaceImmeuble,
+      becsParMois
+    );
+    di.conso_auxiliaire_distribution_ecs = conso_aux_wh / 1000;
+  } else {
+    di.conso_auxiliaire_distribution_ecs = 0;
+  }
+
   ecs.donnee_intermediaire = di;
   ecs.donnee_utilisateur = du;
 }

package/11_ecs.spec.js

@@ -21,7 +21,10 @@ vi.mock('./enums.js', () => ({
 vi.mock('./utils.js', () => ({
   set_bug_for_bug_compat: vi.fn(),
   tv: vi.fn(),
-  requestInput: vi.fn()
+  requestInput: vi.fn(),
+  // Calendrier réduit à deux mois pour le calcul mensuel des auxiliaires de distribution
+  mois_liste: ['Janvier', 'Février'],
+  Njj: { Janvier: 31, Février: 28 }
 }));
 
 vi.mock('./14_generateur_ecs.js', () => ({
@@ -281,3 +284,138 @@ describe('calc_ecs - agrégation des consommations', () => {
     expect(ecs.donnee_intermediaire.conso_ecs_depensier).toBe(28);
   });
 });
+
+/**
+ * Consommation des auxiliaires de distribution ECS - cas immeuble
+ * Seuls les réseaux collectifs bouclés ou avec traçage consomment de l'énergie.
+ */
+describe('calc_ecs - auxiliaires de distribution ECS (immeuble)', () => {
+  /** Calcule l'ECS d'un immeuble et retourne la conso des auxiliaires de distribution [kWh]. */
+  function consoAuxDistribution(deExtra, becsParMois, surfaceImmeuble = 400, th = 'immeuble') {
+    const ecs = makeEcs({ tv_rendement_distribution_ecs_id: '5', ...deExtra });
+    calc_ecs(
+      {},
+      ecs,
+      100,
+      200,
+      1,
+      'ca1',
+      'h1a',
+      th,
+      false,
+      surfaceImmeuble,
+      null,
+      false,
+      becsParMois
+    );
+    return ecs.donnee_intermediaire.conso_auxiliaire_distribution_ecs;
+  }
+
+  test.each([
+    ['logement autre qu’un immeuble', 'maison', { Janvier: 1000 }],
+    ['besoin mensuel absent', 'immeuble', undefined],
+    ['besoin mensuel vide', 'immeuble', {}]
+  ])('%s : pas de consommation', (_libelle, th, becsParMois) => {
+    expect(
+      consoAuxDistribution(
+        { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: '2' },
+        becsParMois,
+        400,
+        th
+      )
+    ).toBe(0);
+  });
+
+  test.each([
+    ['type d’installation inconnu', { enum_type_installation_id: '9' }],
+    ['installation individuelle', { enum_type_installation_id: '1' }],
+    [
+      'réseau collectif non bouclé',
+      { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: '1' }
+    ],
+    ['type de bouclage non renseigné', { enum_type_installation_id: '2' }]
+  ])('%s : pas de consommation', (_libelle, de) => {
+    expect(consoAuxDistribution(de, { Janvier: 1000 })).toBe(0);
+  });
+
+  test('réseau avec traçage : 0,14 × besoin annuel × ratio de surface', () => {
+    const conso = consoAuxDistribution(
+      { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: 3, surface_habitable: 100 },
+      { Janvier: 100, Février: 50 }
+    );
+
+    // 0,14 × 150 kWh × 1000 × (100 / 400) = 5250 Wh => 5,25 kWh
+    expect(conso).toBeCloseTo(5.25, 9);
+  });
+
+  test('réseau avec traçage sans surfaces renseignées : ratio de surface nul', () => {
+    const conso = consoAuxDistribution(
+      { enum_type_installation_id: '3', enum_bouclage_reseau_ecs_id: '3' },
+      { Janvier: 100 },
+      null
+    );
+
+    // surface_habitable absente => 0 ; surface de l'immeuble absente => 1
+    expect(conso).toBe(0);
+  });
+
+  test('réseau bouclé sans besoin : puissance minimale du circulateur de 20 W', () => {
+    const conso = consoAuxDistribution(
+      { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: '2', surface_habitable: 100 },
+      { Janvier: 0 }
+    );
+
+    // Pcirb = 20 W chaque mois : (5 × 20 + 19 × 20) × (31 + 28) jours = 28320 Wh
+    expect(conso).toBeCloseTo(28.32, 9);
+  });
+
+  test('réseau bouclé à faible besoin : puissance du circulateur ramenée au minimum de 20 W', () => {
+    const conso = consoAuxDistribution(
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: 100,
+        nombre_niveau_installation_ecs: 2
+      },
+      { Janvier: 1000, Février: 1000 }
+    );
+
+    // Phyd / Effcirb < 20 W => Pcirb = 20 W, identique au cas sans besoin
+    expect(conso).toBeCloseTo(28.32, 9);
+  });
+
+  test('réseau bouclé : calcul complet de la consommation du circulateur', () => {
+    const conso = consoAuxDistribution(
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: 100,
+        nombre_niveau_installation_ecs: '2'
+      },
+      { Janvier: 10000 }
+    );
+
+    // Lb = 1,2 × (1,1 × 100 / 2 + 4 × 2) = 75,6 m ; ΔPb = 0,2 × Lb + 10 = 25,12 kPa
+    // Janvier : Phyd ≈ 4,645 W => Pcirb ≈ 66,49 W ; Février (besoin absent) : Pcirb = 20 W
+    // Référence de régression (calcul des 9 étapes de la méthode) : 35526,3879475995 Wh
+    expect(conso).toBeCloseTo(35.526387947599495, 9);
+  });
+
+  test('réseau bouclé sans nombre de niveaux : un seul niveau par défaut', () => {
+    const avecUnNiveau = consoAuxDistribution(
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: 100,
+        nombre_niveau_installation_ecs: 1
+      },
+      { Janvier: 10000 }
+    );
+    const sansNiveau = consoAuxDistribution(
+      { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: '2', surface_habitable: 100 },
+      { Janvier: 10000 }
+    );
+
+    expect(sansNiveau).toBe(avecUnNiveau);
+  });
+});

package/3.2.1_mur.js

@@ -122,7 +122,7 @@ function tv_umur(di, de, du, pc_id, zc, effetJoule) {
   }
 }
 
-function calc_umur0(di, de, du) {
+function calc_umur0(di, de, du, versionDpe) {
   const umur0_avant = du.umur0_avant;
   const umur_avant = du.umur_avant;
 
@@ -166,8 +166,17 @@ function calc_umur0(di, de, du) {
     }
   }
 
-  // Si présence d'un doublage
-  if (type_doublage > 2) {
+  /**
+   * Le doublage NE doit PAS être cumulé à une isolation ITE ou ITI.
+   * Il doit uniquement être pris en compte en l'absence d'isolation ITE/ITI (ex: ITR seule, non isolé, inconnu).
+   * Types avec ITE ou ITI : 3 (iti), 4 (ite), 6 (iti+ite), 7 (iti+itr), 8 (ite+itr)
+   * @see https://github.com/Open3CL/engine/issues/146
+   */
+  const type_isolation = parseInt(de.enum_type_isolation_id) || 1;
+  const hasIteOrIti = versionDpe >= 2.4 && [3, 4, 6, 7, 8].includes(type_isolation);
+
+  // Si présence d'un doublage et pas d'isolation ITE/ITI
+  if (type_doublage > 2 && !hasIteOrIti) {
     let umur0Doublage;
 
     // 3 - doublage indéterminé ou lame d'air inf 15 mm
@@ -212,7 +221,7 @@ function calc_umur0(di, de, du) {
   di.umur0 = Math.min(2.5, di.umur0);
 }
 
-export default function calc_mur(mur, zc, pc_id, effetJoule) {
+export default function calc_mur(mur, zc, pc_id, effetJoule, versionDpe) {
   const de = mur.donnee_entree;
   const du = {};
   const di = {};
@@ -228,12 +237,12 @@ export default function calc_mur(mur, zc, pc_id, effetJoule) {
   const methode_saisie_u = requestInput(de, du, 'methode_saisie_u');
   switch (methode_saisie_u) {
     case 'non isolé':
-      calc_umur0(di, de, du);
+      calc_umur0(di, de, du, versionDpe);
       di.umur = Math.min(di.umur0, 2.5);
       break;
     case 'epaisseur isolation saisie justifiée par mesure ou observation':
     case 'epaisseur isolation saisie justifiée à partir des documents justificatifs autorisés': {
-      calc_umur0(di, de, du);
+      calc_umur0(di, de, du, versionDpe);
       const epaisseurIsolation = requestInput(de, du, 'epaisseur_isolation', 'int') * 0.01;
 
       if (epaisseurIsolation) {
@@ -251,7 +260,7 @@ export default function calc_mur(mur, zc, pc_id, effetJoule) {
     }
     case "resistance isolation saisie justifiée observation de l'isolant installé et mesure de son épaisseur":
     case 'resistance isolation saisie justifiée  à partir des documents justificatifs autorisés': {
-      calc_umur0(di, de, du);
+      calc_umur0(di, de, du, versionDpe);
       const resistanceIsolation = requestInput(de, du, 'resistance_isolation', 'float');
 
       if (resistanceIsolation) {
@@ -268,19 +277,19 @@ export default function calc_mur(mur, zc, pc_id, effetJoule) {
       break;
     }
     case 'isolation inconnue  (table forfaitaire)':
-      calc_umur0(di, de, du);
+      calc_umur0(di, de, du, versionDpe);
       tv_umur(di, de, du, pc_id, zc, effetJoule);
       di.umur = Math.min(di.umur, di.umur0);
       break;
     case "année d'isolation différente de l'année de construction saisie justifiée (table forfaitaire)": {
-      calc_umur0(di, de, du);
+      calc_umur0(di, de, du, versionDpe);
       const pi_id = requestInputID(de, du, 'periode_isolation') || pc_id;
       tv_umur(di, de, du, pi_id, zc, effetJoule);
       di.umur = Math.min(di.umur, di.umur0);
       break;
     }
     case 'année de construction saisie (table forfaitaire)': {
-      calc_umur0(di, de, du);
+      calc_umur0(di, de, du, versionDpe);
       // Si l'année d'isolation est connue, il faut l'utiliser et pas l'année de construction
       let pi_id = de.enum_periode_isolation_id || pc_id;
       if (!de.enum_periode_isolation_id) {

package/3.2.1_mur.spec.js

@@ -819,3 +819,108 @@ describe('calc_mur - méthode de saisie de U inconnue', () => {
     warn.mockRestore();
   });
 });
+
+/**
+ * Le doublage n'est plus cumulé à une isolation ITE ou ITI à partir de la version 2.4 du DPE.
+ * Les DPE antérieurs (2 à 2.3) ont été établis avec le cumul : on conserve ce comportement.
+ * @see https://github.com/Open3CL/engine/issues/146
+ */
+describe('calc_mur - doublage et isolation ITE/ITI (#146)', () => {
+  /** Umur0 issu de la table forfaitaire mockée. */
+  const UMUR0_TABLE = 2;
+  /** Umur0 avec doublage type 4 ou 5 cumulé : 1 / (1/2 + 0,21). */
+  const UMUR0_AVEC_DOUBLAGE = 1.4084507042253522;
+
+  /**
+   * @param enum_type_isolation_id {string}
+   * @param enum_type_doublage_id {string}
+   * @return {object}
+   */
+  const murIsoleAvecDoublage = (enum_type_isolation_id, enum_type_doublage_id = '5') => ({
+    donnee_entree: {
+      methode_saisie_u: 'epaisseur isolation saisie justifiée par mesure ou observation',
+      methode_saisie_u0:
+        'déterminé selon le matériau et épaisseur à partir de la table de valeur forfaitaire',
+      enum_materiaux_structure_mur_id: '5',
+      epaisseur_structure: 30,
+      epaisseur_isolation: 10,
+      enum_type_doublage_id,
+      enum_type_isolation_id
+    }
+  });
+
+  describe('DPE en version 2.4 et supérieure', () => {
+    test.each([
+      ['iti', '3'],
+      ['ite', '4'],
+      ['iti+ite', '6'],
+      ['iti+itr', '7'],
+      ['ite+itr', '8']
+    ])("isolation %s : le doublage n'est pas cumulé", (_label, typeIsolation) => {
+      const mur = murIsoleAvecDoublage(typeIsolation);
+
+      calc_mur(mur, 'h1a', '1', '0', 2.4);
+
+      expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_TABLE, 9);
+    });
+
+    test.each([
+      ['inconnu', '1'],
+      ['non isolé', '2'],
+      ['itr', '5'],
+      ["isolé mais type d'isolation inconnu", '9']
+    ])('isolation %s : le doublage est cumulé', (_label, typeIsolation) => {
+      const mur = murIsoleAvecDoublage(typeIsolation);
+
+      calc_mur(mur, 'h1a', '1', '0', 2.4);
+
+      expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_AVEC_DOUBLAGE, 9);
+    });
+
+    test('type_isolation absent : le doublage est cumulé', () => {
+      const mur = murIsoleAvecDoublage(undefined);
+
+      calc_mur(mur, 'h1a', '1', '0', 2.5);
+
+      expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_AVEC_DOUBLAGE, 9);
+    });
+  });
+
+  describe('DPE antérieurs à la version 2.4', () => {
+    test.each([[2], [2.1], [2.2], [2.3]])(
+      'version %s : le doublage reste cumulé à une isolation ITI',
+      (versionDpe) => {
+        const mur = murIsoleAvecDoublage('3');
+
+        calc_mur(mur, 'h1a', '1', '0', versionDpe);
+
+        expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_AVEC_DOUBLAGE, 9);
+      }
+    );
+
+    test('version absente : le doublage reste cumulé à une isolation ITE', () => {
+      const mur = murIsoleAvecDoublage('4');
+
+      calc_mur(mur, 'h1a', '1', '0');
+
+      expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_AVEC_DOUBLAGE, 9);
+    });
+  });
+
+  test.each([
+    ['isolation inconnue  (table forfaitaire)'],
+    [
+      "année d'isolation différente de l'année de construction saisie justifiée (table forfaitaire)"
+    ],
+    ['année de construction saisie (table forfaitaire)'],
+    ['resistance isolation saisie justifiée  à partir des documents justificatifs autorisés']
+  ])('methode_saisie_u "%s" : la version du DPE est prise en compte', (methode_saisie_u) => {
+    const mur = murIsoleAvecDoublage('3');
+    mur.donnee_entree.methode_saisie_u = methode_saisie_u;
+    mur.donnee_entree.resistance_isolation = 2.5;
+
+    calc_mur(mur, 'h1a', '1', '0', 2.4);
+
+    expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_TABLE, 9);
+  });
+});

package/3_deperdition.js

@@ -224,7 +224,12 @@ export default function calc_deperdition(cg, zc, th, effetJoule, dpe, Sh) {
   const declaredPontsThermiques = structuredClone(pt_list);
   const vt_list = logement.ventilation_collection.ventilation || [];
 
-  mur_list.forEach((mur) => calc_mur(mur, zc, pc, effetJoule));
+  /**
+   * Version de la méthode appliquée au DPE. Absente des DPE partiels : les calculs qui en
+   * dépendent retombent alors sur le comportement historique.
+   */
+  const versionDpe = parseFloat(dpe.administratif?.enum_version_id);
+  mur_list.forEach((mur) => calc_mur(mur, zc, pc, effetJoule, versionDpe));
   pb_list.forEach((pb) => calc_pb(pb, zc, pc, effetJoule, pb_list));
   ph_list.forEach((ph) => calc_ph(ph, zc, pc, effetJoule));
   bv_list.forEach((bv) => calc_bv(bv, zc));

package/3_deperdition.spec.js

@@ -125,6 +125,7 @@ describe('Upt - déperdition linéique des ponts thermiques', () => {
 
 /** Fabrique un DPE minimal avec une enveloppe pré-calculée. */
 function makeDpe({
+  enum_version_id = '2.4',
   mur = [],
   pb = [],
   ph = [],
@@ -141,6 +142,7 @@ function makeDpe({
   }
   return {
     numero_dpe: 'TEST',
+    administratif: enum_version_id === null ? undefined : { enum_version_id },
     logement: {
       sortie: { deperdition },
       enveloppe: {
@@ -239,6 +241,51 @@ describe("calc_deperdition - agrégation des déperditions de l'enveloppe", () =
     expect(calc_ventilation).toHaveBeenCalledTimes(1);
   });
 
+  /**
+   * Certains calculs de Umur dépendent de la version de la méthode appliquée au DPE
+   * (cumul du doublage avec une isolation ITE/ITI avant la version 2.4).
+   * @see https://github.com/Open3CL/engine/issues/146
+   */
+  describe('version du DPE transmise au calcul des murs', () => {
+    /** @return {object[]} */
+    const murCollection = () => [
+      {
+        donnee_entree: { surface_paroi_opaque: 10, enum_type_adjacence_id: '1' },
+        donnee_intermediaire: { umur: 0.5, b: 1 }
+      }
+    ];
+
+    test.each([
+      ['2.3', 2.3],
+      ['2.4', 2.4],
+      ['2.5', 2.5]
+    ])('enum_version_id "%s" transmis à calc_mur', (enum_version_id, expected) => {
+      const dpe = makeDpe({
+        enum_version_id,
+        mur: murCollection(),
+        ventilation: [{ donnee_intermediaire: { hvent: 0, hperm: 0 } }],
+        deperdition_mur: 5
+      });
+
+      calc_deperdition({ enum_periode_construction_id: '1' }, 'h1a', 'th', '0', dpe, 100);
+
+      expect(calc_mur).toHaveBeenCalledWith(expect.anything(), 'h1a', '1', '0', expected);
+    });
+
+    test('bloc administratif absent : calc_mur reçoit NaN et conserve le comportement historique', () => {
+      const dpe = makeDpe({
+        enum_version_id: null,
+        mur: murCollection(),
+        ventilation: [{ donnee_intermediaire: { hvent: 0, hperm: 0 } }],
+        deperdition_mur: 5
+      });
+
+      calc_deperdition({ enum_periode_construction_id: '1' }, 'h1a', 'th', '0', dpe, 100);
+
+      expect(calc_mur).toHaveBeenCalledWith(expect.anything(), 'h1a', '1', '0', NaN);
+    });
+  });
+
   /**
    * calc_Sdep (surface déperditive transmise à la ventilation) exclut les parois à coefficient
    * b nul et les parois adjacentes à un local non déperditif. Les parois à déperdition nulle

package/README.md

@@ -23,8 +23,6 @@ Implémentation open source du moteur Open3CL de l'ADEME.
     ·
     <a href="https://github.com/Open3CL/engine/issues/new?labels=enhancement&template=feature-request---.md">Créer une feature</a>
     &middot;
-    <a href="https://open3cl.github.io/engine/build/">Démo en ligne</a>
-    &middot;
     <a href="https://open3cl.github.io/engine/reports/corpus">Rapports de corpus</a>
   </p>
 </div>
@@ -57,7 +55,6 @@ Implémentation open source du moteur Open3CL de l'ADEME.
         <li><a href="#api-publique">API publique</a></li>
         <li><a href="#options-de-calcul">Options de calcul</a></li>
         <li><a href="#lire-le-résultat">Lire le résultat</a></li>
-        <li><a href="#tester-un-dpe-sans-écrire-de-code">Tester un DPE sans écrire de code</a></li>
       </ul>
     </li>
     <li><a href="#-tests-de-corpus">Tests de corpus</a>
@@ -142,12 +139,11 @@ flowchart LR
 
 ### L'écosystème Open3CL
 
-| Ressource                                                             | Description                                                    |
-| :-------------------------------------------------------------------- | :------------------------------------------------------------- |
-| [open3cl.fr](https://open3cl.fr)                                      | Le site du projet                                              |
-| [Démonstrateur](https://open3cl.github.io/engine/build/)              | Chargez un DPE XML et comparez les sorties du moteur, en ligne |
-| [Rapports de corpus](https://open3cl.github.io/engine/reports/corpus) | Le tableau de bord interactif des résultats sur DPE réels      |
-| [@open3cl/engine](https://www.npmjs.com/package/@open3cl/engine)      | Le paquet npm                                                  |
+| Ressource                                                             | Description                                               |
+| :-------------------------------------------------------------------- | :-------------------------------------------------------- |
+| [open3cl.fr](https://open3cl.fr)                                      | Le site du projet                                         |
+| [Rapports de corpus](https://open3cl.github.io/engine/reports/corpus) | Le tableau de bord interactif des résultats sur DPE réels |
+| [@open3cl/engine](https://www.npmjs.com/package/@open3cl/engine)      | Le paquet npm                                             |
 
 <p align="right">(<a href="#readme-top">Retour sommaire</a>)</p>
 
@@ -292,17 +288,6 @@ Le DPE renvoyé est l'objet d'entrée, enrichi de `logement.sortie` :
 | `sortie.confort_ete` / `qualite_isolation` | Indicateurs de confort d'été et de qualité d'isolation |
 | `sortie.production_electricite`            | Production photovoltaïque                              |
 
-### Tester un DPE sans écrire de code
-
-Le [démonstrateur en ligne](https://open3cl.github.io/engine/build/) accepte un DPE au format XML, l'envoie au moteur et
-affiche **côte à côte** les valeurs du DPE d'origine, celles calculées par Open3CL, et le différentiel.
-
-C'est le moyen le plus rapide de qualifier un écart : problème dans le DPE d'origine, ou bug dans la librairie ?
-
-<p align="right">(<a href="#readme-top">Retour sommaire</a>)</p>
-
----
-
 ## 🧪 Tests de corpus
 
 > Un corpus, c'est une liste de numéros de DPE réels. Le moteur les rejoue **tous**, compare ses sorties à celles du

package/conso.js

@@ -249,6 +249,7 @@ export default function calc_conso(
       null,
       prorataECS,
       prorataChauffage,
+      ecs,
       conso_aux_distribution_ecs_total
     ),
     ep_conso: calc_conso_pond(
@@ -262,6 +263,7 @@ export default function calc_conso(
       coeffEp,
       prorataECS,
       prorataChauffage,
+      ecs,
       conso_aux_distribution_ecs_total
     ),
     emission_ges: calc_conso_pond(
@@ -275,6 +277,7 @@ export default function calc_conso(
       coef_ges,
       prorataECS,
       prorataChauffage,
+      ecs,
       conso_aux_distribution_ecs_total
     ),
     cout: calc_conso_pond(
@@ -288,6 +291,7 @@ export default function calc_conso(
       coef_cout,
       prorataECS,
       prorataChauffage,
+      ecs,
       conso_aux_distribution_ecs_total
     )
   };
@@ -343,7 +347,8 @@ export default function calc_conso(
       '',
       null,
       prorataECS,
-      prorataChauffage
+      prorataChauffage,
+      type_energie === 'électricité' ? ecs : []
     );
     conso_en = {
       conso_ch: conso_en._ch,
@@ -474,7 +479,7 @@ function calc_conso_pond(
   coef,
   prorataECS,
   prorataChauffage,
-  conso_aux_distribution_ecs_total
+  ecs_installations
 ) {
   const ret = {};
   ret.auxiliaire_ventilation = vt_list.reduce((acc, vt) => {
@@ -538,11 +543,10 @@ function calc_conso_pond(
     return acc + getConso(coef, 'électricité auxiliaire', conso);
   }, 0);
 
-  ret.auxiliaire_distribution_ecs = getConso(
-    coef,
-    'électricité auxiliaire',
-    conso_aux_distribution_ecs_total || 0
-  );
+  ret.auxiliaire_distribution_ecs = ecs_installations.reduce((acc, inst) => {
+    const conso = inst.donnee_intermediaire.conso_auxiliaire_distribution_ecs || 0;
+    return acc + getConso(coef, 'électricité auxiliaire', conso);
+  }, 0);
 
   ret.ecs = getEcsConso(gen_ecs, 'conso_ecs', coef, prorataECS, prefix);
 

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.7.2';
+const LIB_VERSION = '1.8.0';
 
 const dpeSanitizerService = new DpeSanitizerService();
 
@@ -437,7 +437,8 @@ export function calcul_3cl(inputDpe, options) {
       virtualisationECS,
       dpe.logement.caracteristique_generale.surface_habitable_immeuble,
       dpe.logement.caracteristique_generale.nombre_appartement,
-      isImmeubleSystemEcsIndividuels
+      isImmeubleSystemEcsIndividuels,
+      apport_et_besoin.besoin_ecs_par_mois || {}
     );
 
     if (!dpeGenereImmeuble) {

package/features/engine/domain/enveloppe/mur/deperdition-mur.service.js

@@ -129,20 +129,29 @@ export class DeperditionMurService extends DeperditionService {
     }
 
     /**
-     * Pour l’ensemble des parois, la présence d’un doublage apporte une résistance thermique supplémentaire
+     * Pour l’ensemble des parois, la présence d’un doublage apporte une résistance thermique supplémentaire.
+     * Cependant, lorsqu'une isolation ITE ou ITI est présente, le doublage NE doit PAS être cumulé.
+     * Le doublage n'est pris en compte que si aucune isolation ITE/ITI n'est appliquée.
+     * Types d'isolation avec ITE ou ITI : 3 (iti), 4 (ite), 6 (iti+ite), 7 (iti+itr), 8 (ite+itr)
+     * @see https://github.com/Open3CL/engine/issues/146
      */
-    switch (murDE.enum_type_doublage_id) {
-      case '3':
-        // doublage indéterminé ou lame d'air inf 15 mm
-        umur0 = 1 / (1 / umur0 + 0.1);
-        break;
-      case '4': // doublage indéterminé ou lame d'air sup 15 mm
-      case '5': // doublage connu (plâtre brique bois)
-        umur0 = 1 / (1 / umur0 + 0.21);
-        break;
-      default:
-        // absence de doublage ou inconnu
-        break;
+    const typeIsolation = parseInt(murDE.enum_type_isolation_id) || 1;
+    const hasIteOrIti = [3, 4, 6, 7, 8].includes(typeIsolation);
+
+    if (!hasIteOrIti) {
+      switch (murDE.enum_type_doublage_id) {
+        case '3':
+          // doublage indéterminé ou lame d'air inf 15 mm
+          umur0 = 1 / (1 / umur0 + 0.1);
+          break;
+        case '4': // doublage indéterminé ou lame d'air sup 15 mm
+        case '5': // doublage connu (plâtre brique bois)
+          umur0 = 1 / (1 / umur0 + 0.21);
+          break;
+        default:
+          // absence de doublage ou inconnu
+          break;
+      }
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open3cl/engine",
-  "version": "1.7.2",
+  "version": "1.8.0",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {
@@ -28,8 +28,9 @@
     "prepare": "husky install",
     "assets:sync": "node scripts/synchronize_assets.js",
     "version:update": "node scripts/update_version.js",
+    "reports:charts": "node scripts/generate_corpus_history_chart.js",
     "reports:preview": "npm run http-server dist/reports/corpus -o",
-    "reports:readme": "node scripts/generate_corpus_readme.js"
+    "reports:readme": "node scripts/generate_corpus_readme.js && npm run reports:charts"
   },
   "repository": {
     "type": "git",