@open3cl/engine 1.6.2 → 1.7.0

package/15_conso_aux.js

@@ -1,6 +1,6 @@
 import enums from './enums.js';
 import tvs from './tv.js';
-import { mois_liste, Tbase } from './utils.js';
+import { mois_liste, Njj, Tbase } from './utils.js';
 
 const G_CHAUDIERE = 20;
 const G_RADIATEURS_GAZ = 40;
@@ -259,3 +259,123 @@ function getPuissanceCirculateur(em_ch, de, di, du, surfaceHabitable, GV, Tbase)
       Math.max(1, surfaceHabitable / 400)
   );
 }
+
+/**
+ * 15.2.3 Consommation des auxiliaires de distribution d'ECS
+ * Calcul installation par installation pour le cas appartement
+ *
+ * SI installation individuelle : conso = 0
+ * SI installation collective :
+ *   CAS 1 - enum_bouclage_reseau_ecs_id = 1 (non bouclé) : conso = 0
+ *   CAS 2 - enum_bouclage_reseau_ecs_id = 2 (bouclé) : calcul selon étapes 1-9
+ *   CAS 3 - enum_bouclage_reseau_ecs_id = 3 (traçage) : conso = 0.14 * BECS_annuel * Sh_install / Sh_logement
+ *
+ * @param ecs {object} installation ECS
+ * @param de {Donnee_entree} donnée d'entrée de l'installation ECS
+ * @param di {Donnee_intermediaire} donnée intermédiaire de l'installation ECS
+ * @param Sh_logement {number} surface habitable du logement
+ * @param Sh_immeuble {number} surface habitable de l'immeuble
+ * @param caId {number} id de la classe d'altitude
+ * @param zcId {number} id de la zone climatique
+ * @param nadeq {number} nombre d'unités d'équivalence
+ * @param nombre_niveau_immeuble {number} nombre de niveaux de l'immeuble
+ */
+export function conso_aux_distribution_ecs(
+  ecs,
+  de,
+  di,
+  Sh_logement,
+  Sh_immeuble,
+  caId,
+  zcId,
+  nadeq,
+  nombre_niveau_immeuble
+) {
+  const typeInstallation = parseInt(de.enum_type_installation_id);
+
+  if (typeInstallation === 1) {
+    di.conso_auxiliaire_distribution_ecs = 0;
+    return;
+  }
+
+  const enumBouclage = parseInt(de.enum_bouclage_reseau_ecs_id);
+
+  // CAS 1 - enum_bouclage_reseau_ecs_id =1 (réseau d'ECS non bouclé)
+  if (enumBouclage === 1 || isNaN(enumBouclage)) {
+    di.conso_auxiliaire_distribution_ecs = 0;
+    return;
+  }
+
+  // CAS 3 - enum_bouclage_reseau_ecs_id = 3 (traçage)
+  if (enumBouclage === 3) {
+    const BECS_annuel = di.besoin_ecs;
+    const Sh_install = de.surface_habitable || Sh_logement;
+    di.conso_auxiliaire_distribution_ecs = (0.14 * BECS_annuel * Sh_install) / Sh_logement;
+    return;
+  }
+
+  // CAS 2 - enum_bouclage_reseau_ecs_id = 2 (réseau bouclé)
+  const ca = enums.classe_altitude[caId];
+  const zc = enums.zone_climatique[zcId];
+
+  const ratioVirtu = parseFloat(de.ratio_virtualisation);
+  let Sh_immeuble_ratio = Sh_immeuble;
+  let Sh_install = de.surface_habitable || Sh_logement;
+  let Niv_inst_ecs = de.nombre_niveau_installation_ecs || 1;
+
+  if (!(Sh_immeuble > Sh_logement) && ratioVirtu > 0 && ratioVirtu < 1) {
+    Sh_immeuble_ratio = Sh_logement / ratioVirtu;
+    Sh_install = Sh_logement;
+    Niv_inst_ecs = nombre_niveau_immeuble || Niv_inst_ecs;
+  }
+
+  // Etape 3: Lb - longueur par défaut du bouclage ECS (m)
+  // Sh est la surface habitable des logements desservis par l'installation d'ECS
+  // Pour l'appartement, on utilise la surface à l'échelle de l'immeuble
+  const Sh = (Sh_install / Sh_logement) * Sh_immeuble_ratio;
+  const Lb = 4 * Math.pow(Sh / Niv_inst_ecs, 0.5) + 6 * (Niv_inst_ecs - 0.5);
+
+  // Etape 4: DeltaPb (kPa) - perte de charge dans le bouclage
+  const DeltaPb = 0.2 * Lb + 10;
+
+  let conso = 0;
+
+  for (const mois of mois_liste) {
+    // Besoin ECS mensuel pour le logement (kWh)
+    // spec : https://rt-re-batiment.developpement-durable.gouv.fr/IMG/pdf/consolide_annexe_1_arrete_du_31_03_2021_relatif_aux_methodes_et_procedures_applicables.pdf
+    // page 71-72
+    const tefsj = tvs.tefs[ca][mois][zc];
+    const njj = Njj[mois];
+    const BECS_j = (1.163 * nadeq * 56 * (40 - tefsj) * njj) / 1000;
+
+    // Etape 1: Qdwj_i (Wh) - pertes de distribution à l'échelle de l'immeuble
+    // Qd,w,j = (0.5 * Lvc / Sh + 0.112 + 0.028) * BECS_j
+    // Pour Ratecs=1 (bouclé): Lvc = 0.2 * Sh * Ratecs = 0.2 * Sh
+    // So Qd,w,j = (0.1 + 0.112 + 0.028) * BECS_j = 0.24 * BECS_j (kWh)
+    // Pour l'appartement: Qd,w,j est multiplié par Sh_immeuble_ratio / Sh_logement
+    const Qdwj_i =
+      (0.24 * BECS_j * 1000 * Sh_install * Sh_immeuble_ratio) / (Sh_logement * Sh_logement);
+
+    // Etape 2: qdwj_i (m³/h) - débit de distribution ECS
+    const Nh_puisage_j = njj * 5;
+    const qdwj_i = Qdwj_i / (5.815 * Nh_puisage_j) / 1000;
+
+    // Etape 5: Phyd,j (W) - puissance hydraulique du bouclage
+    const Phyd_j = (qdwj_i * DeltaPb) / 3.6;
+
+    // Etape 6: Effcirb,j - efficacité du circulateur
+    const Effcirb_j = Math.pow(Phyd_j, 0.324) / 15.3;
+
+    // Etape 7: Pcirb,j (W) - puissance électrique du circulateur
+    const Pcirb_j = Math.max(20, Phyd_j / Effcirb_j);
+
+    // Etape 8: Qcirb,j (Wh) - consommation mensuelle du circulateur
+    const Nh_mois_j = njj * 24;
+    const Qcirb_j = Nh_puisage_j * Pcirb_j + (Nh_mois_j - Nh_puisage_j) * 20;
+
+    conso += Qcirb_j;
+  }
+
+  // Etape 9: conso annuelle ramenée à l'appartement (kWh)
+  di.conso_auxiliaire_distribution_ecs = (conso * Sh_logement) / Sh_immeuble_ratio / 1000;
+}

package/15_conso_aux.spec.js

@@ -1,10 +1,13 @@
 import { beforeEach, describe, expect, test, vi } from 'vitest';
 
 /**
- * Dépendances mockées uniquement pour `conso_aux_distribution_ch` :
+ * Dépendances mockées pour `conso_aux_distribution_ch` et `conso_aux_distribution_ecs` :
  * - `enums` : libellés de classe d'altitude / zone climatique ;
  * - `tvs.nref19` : nombre d'heures de fonctionnement mensuel ;
- * - `mois_liste` / `Tbase` : réduits à des valeurs contrôlées.
+ * - `tvs.tefs` : température d'eau froide sanitaire mensuelle ;
+ * - `mois_liste` / `Njj` / `Tbase` : réduits à des valeurs contrôlées.
+ * L'année est réduite à un seul mois (Janvier, 31 jours) pour rendre les
+ * consommations attendues calculables à la main.
  * `conso_aux_gen` n'utilise aucune de ces dépendances (calcul autonome).
  */
 vi.mock('./enums.js', () => ({
@@ -16,16 +19,20 @@ vi.mock('./enums.js', () => ({
 
 vi.mock('./tv.js', () => ({
   default: {
-    nref19: { 0: { ca1: { Janvier: { h1a: 100 } } } }
+    nref19: { 0: { ca1: { Janvier: { h1a: 100 } } } },
+    tefs: { ca1: { Janvier: { h1a: 10 } } }
   }
 }));
 
 vi.mock('./utils.js', () => ({
   mois_liste: ['Janvier'],
+  Njj: { Janvier: 31 },
   Tbase: { ca1: { h1: -9 } }
 }));
 
-const { conso_aux_gen, conso_aux_distribution_ch } = await import('./15_conso_aux.js');
+const { conso_aux_gen, conso_aux_distribution_ch, conso_aux_distribution_ecs } = await import(
+  './15_conso_aux.js'
+);
 
 /**
  * 15.1 Consommation des auxiliaires de génération
@@ -223,3 +230,321 @@ describe('conso_aux_distribution_ch - auxiliaires de distribution', () => {
     expect(di.conso_auxiliaire_distribution_ch).toBeCloseTo(136.51553416032854, 9);
   });
 });
+
+/**
+ * 15.2.3 Consommation des auxiliaires de distribution d'ECS
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §15.2.3
+ *
+ * Les scénarios ci-dessous s'appuient sur l'année réduite à Janvier (31 jours,
+ * tefs = 10 °C) définie par les mocks en tête de fichier :
+ * - Nh_puisage = 31 × 5 = 155 h
+ * - Nh_mois    = 31 × 24 = 744 h
+ */
+describe("conso_aux_distribution_ecs - auxiliaires de distribution d'ECS", () => {
+  // Consommation du circulateur maintenu à 20 W sur toutes les heures du mois (kWh)
+  const CONSO_PLANCHER_20W = (31 * 24 * 20) / 1000; // 14,88 kWh
+
+  test('installation individuelle : consommation nulle', () => {
+    const di = {};
+    conso_aux_distribution_ecs(
+      {},
+      { enum_type_installation_id: '1', enum_bouclage_reseau_ecs_id: '2' },
+      di,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    expect(di.conso_auxiliaire_distribution_ecs).toBe(0);
+  });
+
+  test("réseau d'ECS non bouclé (id 1) : consommation nulle", () => {
+    const di = {};
+    conso_aux_distribution_ecs(
+      {},
+      { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: '1' },
+      di,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    expect(di.conso_auxiliaire_distribution_ecs).toBe(0);
+  });
+
+  test('type de bouclage non renseigné : consommation nulle', () => {
+    const di = {};
+    conso_aux_distribution_ecs({}, { enum_type_installation_id: '2' }, di, 50, 2000, 1, 1, 30);
+    expect(di.conso_auxiliaire_distribution_ecs).toBe(0);
+  });
+
+  test('réseau avec traçage (id 3) : 0,14 × BECS × Sh_installation / Sh_logement', () => {
+    const di = { besoin_ecs: 1000 };
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '3',
+        surface_habitable: 60
+      },
+      di,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    // 0,14 × 1000 × 60 / 50
+    expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo(168, 10);
+  });
+
+  test("traçage sans surface d'installation : repli sur la surface du logement", () => {
+    const di = { besoin_ecs: 1000 };
+    conso_aux_distribution_ecs(
+      {},
+      { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: '3' },
+      di,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    // Sh_install = Sh_logement => 0,14 × 1000
+    expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo(140, 10);
+  });
+
+  test('réseau bouclé, faible puissance hydraulique : plancher de 20 W', () => {
+    const di = {};
+    // Immeuble réduit au logement (18 m²) et nadeq faible : Phyd ≈ 0,07 W, donc
+    // Pcirb calculée (≈ 2,6 W) passe sous le plancher de 20 W tous les mois.
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: 18,
+        nombre_niveau_installation_ecs: 1
+      },
+      di,
+      18,
+      18,
+      1,
+      1,
+      1.15
+    );
+    expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo(CONSO_PLANCHER_20W, 10);
+  });
+
+  test('réseau bouclé : consommation ramenée au prorata Sh_logement / Sh_immeuble', () => {
+    const di = {};
+    // Même régime de plancher (Pcirb ≈ 11 W) : la consommation immeuble (14,88 kWh)
+    // est ramenée à l'appartement, soit un dixième ici.
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: 50,
+        nombre_niveau_installation_ecs: 1
+      },
+      di,
+      50,
+      500,
+      1,
+      1,
+      0.5
+    );
+    expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo((CONSO_PLANCHER_20W * 50) / 500, 10);
+  });
+
+  test('réseau bouclé, circulateur au-dessus du plancher de 20 W', () => {
+    const di = {};
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: 50,
+        nombre_niveau_installation_ecs: 2
+      },
+      di,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    // valeur de référence de régression (Pcirb ≈ 549 W pendant les heures de puisage)
+    expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo(2.4208575056559525, 9);
+  });
+
+  test('plus de niveaux desservis : bouclage plus court, donc consommation plus faible', () => {
+    const scenario = (Niv) => {
+      const di = {};
+      conso_aux_distribution_ecs(
+        {},
+        {
+          enum_type_installation_id: '2',
+          enum_bouclage_reseau_ecs_id: '2',
+          surface_habitable: 50,
+          nombre_niveau_installation_ecs: Niv
+        },
+        di,
+        50,
+        2000,
+        1,
+        1,
+        30
+      );
+      return di.conso_auxiliaire_distribution_ecs;
+    };
+    // Lb = 4 × (Sh / Niv)^0,5 + 6 × (Niv − 0,5) : sur cet immeuble, Lb décroît avec Niv
+    expect(scenario(1)).toBeCloseTo(2.767218880573735, 9);
+    expect(scenario(4)).toBeCloseTo(2.2222299894932647, 9);
+    expect(scenario(4)).toBeLessThan(scenario(1));
+  });
+
+  test("réseau bouclé sans surface ni nombre de niveaux d'installation : valeurs par défaut", () => {
+    const diDefaut = {};
+    conso_aux_distribution_ecs(
+      {},
+      { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: '2' },
+      diDefaut,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    const diExplicite = {};
+    // Sh_install = Sh_logement et Niv = 1
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: 50,
+        nombre_niveau_installation_ecs: 1
+      },
+      diExplicite,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    expect(diDefaut.conso_auxiliaire_distribution_ecs).toBeCloseTo(
+      diExplicite.conso_auxiliaire_distribution_ecs,
+      10
+    );
+  });
+
+  test("installation desservant tout l'immeuble : Sh_installation étendue à l'immeuble", () => {
+    const di = {};
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: 2000,
+        nombre_niveau_installation_ecs: 2
+      },
+      di,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    // valeur de référence de régression
+    expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo(72.84189246242042, 9);
+  });
+});
+
+/**
+ * 15.2.3 - Cas des DPE d'appartement dont `surface_habitable_immeuble` est
+ * renseignée avec la surface du logement : l'échelle de l'immeuble est alors
+ * reconstruite à partir du ratio de virtualisation de l'installation.
+ */
+describe("conso_aux_distribution_ecs - surface d'immeuble incohérente", () => {
+  const RATIO_VIRTUALISATION = 0.0211;
+  const SH_LOGEMENT = 18;
+  // 18 / 0,0211 = 853,08 m²
+  const SH_IMMEUBLE_RECONSTRUITE = SH_LOGEMENT / RATIO_VIRTUALISATION;
+
+  /** @param de {object} @param Sh_immeuble {number} @param nbNiveauImmeuble {number} */
+  const consoEcs = (de, Sh_immeuble, nbNiveauImmeuble) => {
+    const di = {};
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: SH_LOGEMENT,
+        nombre_niveau_installation_ecs: 1,
+        ...de
+      },
+      di,
+      SH_LOGEMENT,
+      Sh_immeuble,
+      1,
+      1,
+      1.15,
+      nbNiveauImmeuble
+    );
+    return di.conso_auxiliaire_distribution_ecs;
+  };
+
+  test("surface d'immeuble égale à celle du logement : reconstruite via le ratio de virtualisation", () => {
+    const reconstruite = consoEcs(
+      { ratio_virtualisation: String(RATIO_VIRTUALISATION) },
+      SH_LOGEMENT,
+      1
+    );
+
+    // Sans reconstruction, le prorata vaut 1 et le circulateur reste au plancher de 20 W
+    expect(reconstruite).not.toBeCloseTo((31 * 24 * 20) / 1000, 6);
+    expect(reconstruite).toBeCloseTo(0.45766695775765603, 9);
+
+    // Équivalent à une surface d'immeuble correctement renseignée
+    const renseignee = consoEcs({}, SH_IMMEUBLE_RECONSTRUITE, 1);
+    expect(reconstruite).toBeCloseTo(renseignee, 10);
+  });
+
+  test("reconstruction : le nombre de niveaux de l'immeuble prime sur celui de l'installation", () => {
+    // nombre_niveau_installation_ecs = 1 est la valeur du logement, incohérente
+    // avec la surface d'immeuble reconstruite
+    expect(
+      consoEcs({ ratio_virtualisation: String(RATIO_VIRTUALISATION) }, SH_LOGEMENT, 6)
+    ).toBeCloseTo(0.4237342712345093, 9);
+  });
+
+  test("reconstruction sans nombre de niveaux d'immeuble : repli sur celui de l'installation", () => {
+    expect(
+      consoEcs(
+        {
+          ratio_virtualisation: String(RATIO_VIRTUALISATION),
+          nombre_niveau_installation_ecs: 3
+        },
+        SH_LOGEMENT,
+        undefined
+      )
+    ).toBeCloseTo(0.4253220756819142, 9);
+  });
+
+  test('ratio de virtualisation égal à 1 : aucune reconstruction', () => {
+    expect(consoEcs({ ratio_virtualisation: '1' }, SH_LOGEMENT, 6)).toBeCloseTo(
+      (31 * 24 * 20) / 1000,
+      10
+    );
+  });
+
+  test("surface d'immeuble cohérente : le ratio de virtualisation est ignoré", () => {
+    expect(
+      consoEcs({ ratio_virtualisation: String(RATIO_VIRTUALISATION) }, SH_IMMEUBLE_RECONSTRUITE, 6)
+    ).toBeCloseTo(consoEcs({}, SH_IMMEUBLE_RECONSTRUITE, 6), 10);
+  });
+});

package/6.2_surface_sud_equivalente.js

@@ -6,7 +6,8 @@ export function calc_sse_j(bv_list, ets, ca, zc, mois) {
   const baiesAdjVeranda = bv_list.filter((bv) => bv.donnee_entree.enum_type_adjacence_id === '10');
   const baiesAdjExt = bv_list.filter((bv) => bv.donnee_entree.enum_type_adjacence_id === '1');
 
-  if (!ets) {
+  //ets peut etre un tableau vide  ou undefined selon les DPE, d'où la vérification ajoutée sur le tableau et sa longueur
+  if (!ets || (Array.isArray(ets) && ets.length === 0)) {
     return baiesAdjExt.reduce((acc, bv) => {
       return acc + getSsd(bv, zc, mois, bv.donnee_intermediaire.sw);
     }, 0);

package/conso.js

@@ -218,6 +218,11 @@ export default function calc_conso(
     return acc.concat(generateur_chauffage);
   }, []);
 
+  ecs = Array.isArray(ecs) ? ecs : [];
+
+  const conso_aux_distribution_ecs_total = ecs.reduce((acc, ecs) => {
+    return acc + (ecs.donnee_intermediaire.conso_auxiliaire_distribution_ecs || 0);
+  }, 0);
   const gen_ecs = ecs.reduce((acc, ecs) => {
     const generateur_ecs = ecs.generateur_ecs_collection.generateur_ecs;
     if (prorataECS === 1) {
@@ -243,7 +248,8 @@ export default function calc_conso(
       'conso',
       null,
       prorataECS,
-      prorataChauffage
+      prorataChauffage,
+      conso_aux_distribution_ecs_total
     ),
     ep_conso: calc_conso_pond(
       Sh,
@@ -255,7 +261,8 @@ export default function calc_conso(
       'ep_conso',
       coeffEp,
       prorataECS,
-      prorataChauffage
+      prorataChauffage,
+      conso_aux_distribution_ecs_total
     ),
     emission_ges: calc_conso_pond(
       Sh,
@@ -267,7 +274,8 @@ export default function calc_conso(
       'emission_ges',
       coef_ges,
       prorataECS,
-      prorataChauffage
+      prorataChauffage,
+      conso_aux_distribution_ecs_total
     ),
     cout: calc_conso_pond(
       Sh,
@@ -279,7 +287,8 @@ export default function calc_conso(
       'cout',
       coef_cout,
       prorataECS,
-      prorataChauffage
+      prorataChauffage,
+      conso_aux_distribution_ecs_total
     )
   };
   ret.ep_conso.classe_bilan_dpe = classe_bilan_dpe(
@@ -464,7 +473,8 @@ function calc_conso_pond(
   prefix,
   coef,
   prorataECS,
-  prorataChauffage
+  prorataChauffage,
+  conso_aux_distribution_ecs_total
 ) {
   const ret = {};
   ret.auxiliaire_ventilation = vt_list.reduce((acc, vt) => {
@@ -528,7 +538,11 @@ function calc_conso_pond(
     return acc + getConso(coef, 'électricité auxiliaire', conso);
   }, 0);
 
-  ret.auxiliaire_distribution_ecs = 0;
+  ret.auxiliaire_distribution_ecs = getConso(
+    coef,
+    'électricité auxiliaire',
+    conso_aux_distribution_ecs_total || 0
+  );
 
   ret.ecs = getEcsConso(gen_ecs, 'conso_ecs', coef, prorataECS, prefix);
 

package/conso.spec.js

@@ -188,6 +188,7 @@ function genEcs(energieId, di, deExtra = {}) {
 function installEcs(deExtra, gens) {
   return {
     donnee_entree: { ...deExtra },
+    donnee_intermediaire: {},
     generateur_ecs_collection: { generateur_ecs: gens }
   };
 }
@@ -434,6 +435,25 @@ describe('calc_conso - agrégation des consommations', () => {
     expect(res.ep_conso.ep_conso_ecs).toBeCloseTo(190, 9);
   });
 
+  test.each([
+    ['absente', undefined],
+    ['nulle', null],
+    ['non tabulaire', { installation_ecs: [] }]
+  ])('collection ECS %s : traitée comme une liste vide', (_libelle, ecs) => {
+    const chFixture = () => [
+      installCh({ cle_repartition_ch: 1 }, [
+        genCh('1', { conso_ch: 1000, conso_ch_depensier: 1200 })
+      ])
+    ];
+
+    const res = calc_conso(100, 1, 1, [], chFixture(), ecs, [], 1, 1, DATE_DPE, coef_ep);
+
+    // Identique à un appel avec une collection ECS vide : aucune conso ni auxiliaire d'ECS
+    expect(res).toEqual(calc_conso(100, 1, 1, [], chFixture(), [], [], 1, 1, DATE_DPE, coef_ep));
+    expect(res.ef_conso.conso_ecs).toBe(0);
+    expect(res.ef_conso.conso_auxiliaire_distribution_ecs).toBe(0);
+  });
+
   test('ventilation et froid : auxiliaires et froid agrégés par énergie', () => {
     const vt = [
       {

package/engine.js

@@ -3,6 +3,7 @@ import calc_deperdition from './3_deperdition.js';
 import calc_apport_et_besoin from './apport_et_besoin.js';
 import calc_clim from './10_clim.js';
 import calc_ecs from './11_ecs.js';
+import { conso_aux_distribution_ecs } from './15_conso_aux.js';
 import calc_besoin_ch from './9_besoin_ch.js';
 import calc_chauffage, { tauxChargeForGenerator } from './9_chauffage.js';
 import calc_confort_ete from './2021_04_13_confort_ete.js';
@@ -31,7 +32,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.6.2';
+const LIB_VERSION = '1.7.0';
 
 const dpeSanitizerService = new DpeSanitizerService();
 
@@ -90,6 +91,7 @@ export function calcul_3cl(inputDpe, options) {
 
   const cg = logement.caracteristique_generale;
   const map_id = cg.enum_methode_application_dpe_log_id;
+  const dpeGenereImmeuble = ['10', '11', '12', '13', '33', '34', '38', '39', '40'].includes(map_id);
   const th = calc_th(map_id);
 
   if (logement.enveloppe === undefined) {
@@ -435,6 +437,20 @@ export function calcul_3cl(inputDpe, options) {
       dpe.logement.caracteristique_generale.nombre_appartement,
       isImmeubleSystemEcsIndividuels
     );
+
+    if (!dpeGenereImmeuble) {
+      conso_aux_distribution_ecs(
+        ecs,
+        ecs.donnee_entree,
+        ecs.donnee_intermediaire,
+        Sh,
+        cg.surface_habitable_immeuble,
+        ca_id,
+        zc_id,
+        apport_et_besoin.nadeq,
+        dpe.logement.caracteristique_generale.nombre_niveau_immeuble
+      );
+    }
   });
 
   /**

package/engine.spec.js

@@ -65,6 +65,7 @@ vi.mock('./10_clim.js', () => ({ default: vi.fn() }));
 vi.mock('./11_ecs.js', () => ({ default: vi.fn() }));
 vi.mock('./9_besoin_ch.js', () => ({ default: vi.fn() }));
 vi.mock('./9_chauffage.js', () => ({ default: vi.fn(), tauxChargeForGenerator: vi.fn() }));
+vi.mock('./15_conso_aux.js', () => ({ conso_aux_distribution_ecs: vi.fn() }));
 vi.mock('./2021_04_13_confort_ete.js', () => ({ default: vi.fn() }));
 vi.mock('./2021_04_13_qualite_isolation.js', () => ({ default: vi.fn() }));
 vi.mock('./ficheTechnique.js', () => ({ default: vi.fn() }));
@@ -102,6 +103,7 @@ const calc_clim = (await import('./10_clim.js')).default;
 const calc_ecs = (await import('./11_ecs.js')).default;
 const calc_besoin_ch = (await import('./9_besoin_ch.js')).default;
 const { default: calc_chauffage, tauxChargeForGenerator } = await import('./9_chauffage.js');
+const { conso_aux_distribution_ecs } = await import('./15_conso_aux.js');
 const calc_confort_ete = (await import('./2021_04_13_confort_ete.js')).default;
 const calc_qualite_isolation = (await import('./2021_04_13_qualite_isolation.js')).default;
 const getFicheTechnique = (await import('./ficheTechnique.js')).default;
@@ -172,6 +174,7 @@ function makeDpe() {
         surface_habitable_logement: 80,
         surface_habitable_immeuble: 200,
         nombre_appartement: 4,
+        nombre_niveau_immeuble: 3,
         hsp: 2.5,
         annee_construction: 1990
       },
@@ -192,6 +195,7 @@ function makeDpe() {
         installation_ecs: [
           {
             donnee_entree: { enum_type_installation_id: '1' },
+            donnee_intermediaire: {},
             generateur_ecs_collection: { generateur_ecs: [] }
           }
         ]
@@ -455,6 +459,22 @@ describe('calcul_3cl - run intégral (maison)', () => {
     expect(calc_ecs.mock.calls[0][2]).toBe(100);
     expect(calc_ecs.mock.calls[0][11]).toBe(false);
 
+    // Auxiliaires de distribution ECS calculés pour l'installation (maison => map hors
+    // liste des DPE générés à partir des données d'immeuble).
+    const ecs = dpe.logement.installation_ecs_collection.installation_ecs[0];
+    expect(conso_aux_distribution_ecs).toHaveBeenCalledTimes(1);
+    expect(conso_aux_distribution_ecs).toHaveBeenCalledWith(
+      ecs,
+      ecs.donnee_entree,
+      ecs.donnee_intermediaire,
+      80, // Sh (maison)
+      200, // surface_habitable_immeuble
+      'ca1',
+      'zc1',
+      2, // nadeq
+      3 // nombre_niveau_immeuble
+    );
+
     // Climatisation présente : calc_clim appelé.
     expect(calc_clim).toHaveBeenCalledTimes(1);
   });
@@ -484,6 +504,7 @@ describe('calcul_3cl - run intégral (maison)', () => {
     expect(calc_apport_et_besoin.mock.calls[0][5]).toBe(1);
     // Pas d'ECS ni de clim à traiter.
     expect(calc_ecs).not.toHaveBeenCalled();
+    expect(conso_aux_distribution_ecs).not.toHaveBeenCalled();
     expect(calc_clim).not.toHaveBeenCalled();
   });
 });
@@ -538,6 +559,9 @@ describe('calcul_3cl - surfaces immeuble / appartement et prorata', () => {
     // isImmeubleSystemEcsIndividuels = true, besoin non divisé.
     expect(calc_ecs.mock.calls[0][11]).toBe(true);
     expect(calc_ecs.mock.calls[0][2]).toBe(100);
+    // Auxiliaires ECS calculés par installation, avec Sh = surface immeuble.
+    expect(conso_aux_distribution_ecs).toHaveBeenCalledTimes(2);
+    expect(conso_aux_distribution_ecs.mock.calls[0][3]).toBe(200);
   });
 
   test('immeuble : systèmes ECS non tous individuels => besoin divisé par deux', () => {
@@ -593,6 +617,77 @@ describe('calcul_3cl - surfaces immeuble / appartement et prorata', () => {
     expect(calc_conso.mock.calls[0][0]).toBe(80);
     expect(calc_conso.mock.calls[0][7]).toBeCloseTo(0.4, 9); // prorataECS
     expect(calc_conso.mock.calls[0][8]).toBeCloseTo(0.4, 9); // prorataChauffage
+    // Auxiliaires ECS : Sh = surface logement, ramenée à l'immeuble dans le calcul.
+    expect(conso_aux_distribution_ecs.mock.calls[0][3]).toBe(80);
+    expect(conso_aux_distribution_ecs.mock.calls[0][4]).toBe(200);
+  });
+});
+
+describe("calcul_3cl - auxiliaires de distribution d'ECS", () => {
+  // Méthodes d'application « appartement généré à partir des données DPE immeuble » :
+  // les auxiliaires de distribution d'ECS ne sont pas calculés pour ces DPE.
+  const MAP_IDS_GENERES_IMMEUBLE = ['10', '11', '12', '13', '33', '34', '38', '39', '40'];
+
+  test.each(MAP_IDS_GENERES_IMMEUBLE)(
+    "DPE appartement généré à partir des données d'immeuble (map %s) : auxiliaires non calculés",
+    (mapId) => {
+      enums.methode_application_dpe_log = {
+        [mapId]: 'dpe appartement généré à partir des données dpe immeuble chauffage collectif'
+      };
+      const dpe = makeDpe();
+      dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id = mapId;
+
+      calcul_3cl(dpe, { sanitize: false });
+
+      // L'installation est bien traitée par ailleurs, seul le calcul des auxiliaires est ignoré.
+      expect(calc_ecs).toHaveBeenCalledTimes(1);
+      expect(conso_aux_distribution_ecs).not.toHaveBeenCalled();
+    }
+  );
+
+  test('appartement non généré depuis un immeuble (map 15) : auxiliaires calculés', () => {
+    enums.methode_application_dpe_log = { 15: 'dpe appartement collectif' };
+    const dpe = makeDpe();
+    dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id = '15';
+
+    calcul_3cl(dpe, { sanitize: false });
+
+    expect(conso_aux_distribution_ecs).toHaveBeenCalledTimes(1);
+  });
+
+  test('une installation ECS par appel : chaque installation est traitée', () => {
+    const dpe = makeDpe();
+    const installations = [
+      {
+        donnee_entree: { enum_type_installation_id: '1' },
+        donnee_intermediaire: { tag: 'ecs1' },
+        generateur_ecs_collection: { generateur_ecs: [] }
+      },
+      {
+        donnee_entree: { enum_type_installation_id: '2' },
+        donnee_intermediaire: { tag: 'ecs2' },
+        generateur_ecs_collection: { generateur_ecs: [] }
+      }
+    ];
+    dpe.logement.installation_ecs_collection.installation_ecs = installations;
+
+    calcul_3cl(dpe, { sanitize: false });
+
+    expect(conso_aux_distribution_ecs).toHaveBeenCalledTimes(2);
+    installations.forEach((ecs, i) => {
+      expect(conso_aux_distribution_ecs.mock.calls[i][0]).toBe(ecs);
+      expect(conso_aux_distribution_ecs.mock.calls[i][1]).toBe(ecs.donnee_entree);
+      expect(conso_aux_distribution_ecs.mock.calls[i][2]).toBe(ecs.donnee_intermediaire);
+    });
+  });
+
+  test("nombre de niveaux de l'immeuble absent : transmis tel quel", () => {
+    const dpe = makeDpe();
+    dpe.logement.caracteristique_generale.nombre_niveau_immeuble = undefined;
+
+    calcul_3cl(dpe, { sanitize: false });
+
+    expect(conso_aux_distribution_ecs.mock.calls[0][8]).toBeUndefined();
   });
 });
 

package/package.json

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