@open3cl/engine 1.8.37 → 1.8.39

package/15_conso_aux.js

@@ -345,6 +345,8 @@ export function getDeltaDim(em_ch) {
  * @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
+ * @param isImmeubleMultiEcs {boolean} immeuble à plusieurs installations ECS dont une collective :
+ * di.besoin_ecs est déjà proratisé (Becs_immeuble × Sh_ecs / SH / rdim, cf. 11_ecs.js)
  */
 export function conso_aux_distribution_ecs(
   ecs,
@@ -355,7 +357,8 @@ export function conso_aux_distribution_ecs(
   caId,
   zcId,
   nadeq,
-  nombre_niveau_immeuble
+  nombre_niveau_immeuble,
+  isImmeubleMultiEcs = false
 ) {
   const typeInstallation = parseInt(de.enum_type_installation_id);
 
@@ -375,6 +378,15 @@ export function conso_aux_distribution_ecs(
   // CAS 3 - enum_bouclage_reseau_ecs_id = 3 (traçage)
   if (enumBouclage === 3) {
     const BECS_annuel = di.besoin_ecs;
+    if (isImmeubleMultiEcs) {
+      /**
+       * Besoin déjà ramené à l'installation : pas de second prorata de surface.
+       * Tribu : Qtrac = 0,14 × Becs_immeuble × Sh_ecs / SH
+       * (Moteur_DPE.dll, Calcul_installation_ECS.C_circulateur et Calcul_batiment.Calcul_Cecs)
+       */
+      di.conso_auxiliaire_distribution_ecs = 0.14 * BECS_annuel * (Number(de.rdim) || 1);
+      return;
+    }
     const Sh_install = de.surface_habitable || Sh_logement;
     di.conso_auxiliaire_distribution_ecs = (0.14 * BECS_annuel * Sh_install) / Sh_logement;
     return;

package/15_conso_aux.spec.js

@@ -654,6 +654,47 @@ describe("conso_aux_distribution_ecs - auxiliaires de distribution d'ECS", () =>
     expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo(168, 10);
   });
 
+  test('traçage, immeuble à plusieurs installations ECS : besoin déjà proratisé, × rdim', () => {
+    const di = { besoin_ecs: 1000 };
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '3',
+        surface_habitable: 60,
+        rdim: 2
+      },
+      di,
+      175,
+      175,
+      1,
+      1,
+      30,
+      1,
+      true
+    );
+    // 0,14 × 1000 × 2 : pas de second prorata Sh_installation / Sh_logement
+    expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo(280, 10);
+  });
+
+  test('traçage, immeuble à plusieurs installations ECS, rdim absent : rdim = 1', () => {
+    const di = { besoin_ecs: 1000 };
+    conso_aux_distribution_ecs(
+      {},
+      { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: '3', surface_habitable: 60 },
+      di,
+      175,
+      175,
+      1,
+      1,
+      30,
+      1,
+      true
+    );
+    // 0,14 × 1000 × 1
+    expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo(140, 10);
+  });
+
   test("traçage sans surface d'installation : repli sur la surface du logement", () => {
     const di = { besoin_ecs: 1000 };
     conso_aux_distribution_ecs(

package/9_besoin_ch.js

@@ -89,7 +89,8 @@ export default function calc_besoin_ch(
     ca,
     zc,
     th,
-    nbLogements
+    nbLogements,
+    Sh
   );
 
   /**
@@ -220,7 +221,59 @@ export default function calc_besoin_ch(
   };
 }
 
-function calc_qrec(instal_ecs, nadeq, prorataEcs, ilpa, ca, zc, th, nbLogements) {
+/**
+ * Immeuble avec plusieurs installations ECS dont au moins une collective (installations
+ * collectives ou mixtes individuelles/collectives), toutes avec une surface habitable desservie.
+ * Le besoin ECS de chaque installation est alors Becs_immeuble × Sh_ecs / SH (cf. engine.js,
+ * isImmeubleMultiEcs).
+ */
+export function isImmeubleMultiEcs(instal_ecs, th, Sh) {
+  return (
+    th === 'immeuble' &&
+    instal_ecs.length > 1 &&
+    Number(Sh) > 0 &&
+    instal_ecs.some((e) => e.donnee_entree.enum_type_installation_id !== '1') &&
+    instal_ecs.every((e) => Number(e.donnee_entree.surface_habitable) > 0)
+  );
+}
+
+/**
+ * Prorata du besoin ECS de l'immeuble servant aux pertes de distribution récupérées d'une
+ * installation, cas isImmeubleMultiEcs. Tribu (Moteur_DPE.dll) :
+ * - Becs_inst = Becs_immeuble × Sh_ecs / SH (Calcul_batiment.Calcul_Cecs) ;
+ * - Qrec = 0,48 × Σ (Qdw_ind_vc × Rdim + Qdw_coll_vc) pour une installation individuelle,
+ *   0,48 × Σ (Qdw_ind_vc + Qdw_coll_vc) pour une collective (Calcul_batiment.cs, l. 374),
+ *   avec Qdw_ind_vc = 0,1 × Becs_inst et Qdw_coll_vc = 0,112 × Becs_inst
+ *   (Calcul_installation_ECS.cs, l. 347-350).
+ * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - §9.1.1 et §11.4
+ */
+export function prorataEcsImmeubleMulti(de, Sh, surfaceParLogement = true) {
+  const rdim =
+    surfaceParLogement && de.enum_type_installation_id === '1' ? Number(de.rdim) || 1 : 1;
+  return (Number(de.surface_habitable) / Number(Sh)) * rdim;
+}
+
+/**
+ * Convention d'export de Sh_ecs des installations individuelles (cf. 11_ecs.js,
+ * ratio_besoin_ecs_individuel) :
+ * - surface d'un logement (Σ Sh × rdim ≈ SH) → Sh_ecs à multiplier par rdim ;
+ * - surface totale desservie par l'installation (Σ Sh ≈ SH, ex. LICIEL) → pas de × rdim.
+ * Retourne true pour la convention « surface d'un logement ».
+ */
+export function isSurfaceEcsParLogement(instal_ecs, Sh) {
+  const des = instal_ecs.map((e) => e.donnee_entree);
+  const sommeSh = des.reduce((acc, d) => acc + (Number(d.surface_habitable) || 0), 0);
+  const sommeShRdim = des.reduce(
+    (acc, d) =>
+      acc +
+      (Number(d.surface_habitable) || 0) *
+        (d.enum_type_installation_id === '1' ? Number(d.rdim) || 1 : 1),
+    0
+  );
+  return Math.abs(sommeShRdim - Number(Sh)) < Math.abs(sommeSh - Number(Sh));
+}
+
+function calc_qrec(instal_ecs, nadeq, prorataEcs, ilpa, ca, zc, th, nbLogements, Sh) {
   const Nref21 = tvs.nref21[ilpa];
   const Nref19 = tvs.nref19[ilpa];
 
@@ -238,12 +291,16 @@ function calc_qrec(instal_ecs, nadeq, prorataEcs, ilpa, ca, zc, th, nbLogements)
   let Qrec_dep = 0;
   let total_becs_rdim = 0;
   let total_becs_dep_rdim = 0;
+  const multiEcs = isImmeubleMultiEcs(instal_ecs, th, Sh);
+  const surfaceParLogement = multiEcs && isSurfaceEcsParLogement(instal_ecs, Sh);
   instal_ecs.forEach((ecs) => {
     let becs_int = 0;
     let becs_dep_int = 0;
     const isInstallationSimple = ecs.donnee_entree.enum_type_installation_id === '1';
     const Tau = isInstallationSimple ? 0.1 : 0.212;
-    if (th === 'immeuble' && ecs.donnee_entree.rdim > 1) {
+    if (multiEcs) {
+      prorataEcs = prorataEcsImmeubleMulti(ecs.donnee_entree, Sh, surfaceParLogement);
+    } else if (th === 'immeuble' && ecs.donnee_entree.rdim > 1) {
       prorataEcs = ecs.donnee_entree.rdim / nbLogements;
     }
     for (const mois of mois_liste) {

package/9_besoin_ch.spec.js

@@ -56,7 +56,14 @@ vi.mock('./utils.js', () => ({
   }
 }));
 
-const { default: calc_besoin_ch, calc_Fj, calc_bvj } = await import('./9_besoin_ch.js');
+const {
+  default: calc_besoin_ch,
+  calc_Fj,
+  calc_bvj,
+  isImmeubleMultiEcs,
+  isSurfaceEcsParLogement,
+  prorataEcsImmeubleMulti
+} = await import('./9_besoin_ch.js');
 const { default: tvsBch } = await import('./tv.js');
 const { calc_ai_j, calc_as_j } = await import('./6.1_apport_gratuit.js');
 const { calc_sse_j } = await import('./6.2_surface_sud_equivalente.js');
@@ -550,3 +557,106 @@ describe('calc_besoin_ch - récupération des pertes des générateurs ECS seuls
     expect(ret.pertes_generateur_ch_recup).toBe(0);
   });
 });
+
+/**
+ * Immeuble à plusieurs installations ECS dont une collective (ex. installation mixte
+ * individuelle/collective) : besoin de chaque installation = Becs_immeuble × Sh_ecs / SH, × rdim
+ * pour une installation individuelle (Tribu, Calcul_batiment.Calcul_Cecs et l. 374).
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §9.1.1 et §11.4
+ */
+describe('calc_besoin_ch - immeuble à installations ECS individuelles et collectives', () => {
+  const ecsIndividuelle = (surface_habitable, rdim) => ({
+    donnee_entree: { enum_type_installation_id: '1', surface_habitable, rdim },
+    generateur_ecs_collection: { generateur_ecs: [] }
+  });
+  const ecsCollective = (surface_habitable) => ({
+    donnee_entree: { enum_type_installation_id: '2', surface_habitable, rdim: 1 },
+    generateur_ecs_collection: { generateur_ecs: [] }
+  });
+
+  beforeEach(() => {
+    utilState.bug = false;
+    vi.mocked(calc_ai_j).mockReset().mockReturnValue(5000);
+    vi.mocked(calc_as_j).mockReset().mockReturnValue(2000);
+    vi.mocked(calc_sse_j).mockReset().mockReturnValue(10);
+    vi.mocked(calc_besoin_ecs_j).mockReset().mockReturnValue(10);
+    vi.mocked(calc_Qrec_gen_j).mockReset().mockReturnValue(0);
+  });
+
+  test('isImmeubleMultiEcs : immeuble, plusieurs installations dont une collective, surfaces renseignées', () => {
+    const mixte = [ecsIndividuelle(20, 1), ecsCollective(155)];
+    expect(isImmeubleMultiEcs(mixte, 'immeuble', 175)).toBe(true);
+    expect(isImmeubleMultiEcs(mixte, 'appartement', 175)).toBe(false);
+    expect(isImmeubleMultiEcs([ecsCollective(155)], 'immeuble', 175)).toBe(false);
+    expect(
+      isImmeubleMultiEcs([ecsIndividuelle(20, 1), ecsIndividuelle(155, 1)], 'immeuble', 175)
+    ).toBe(false);
+    expect(isImmeubleMultiEcs([ecsIndividuelle(0, 1), ecsCollective(155)], 'immeuble', 175)).toBe(
+      false
+    );
+    expect(isImmeubleMultiEcs(mixte, 'immeuble', 0)).toBe(false);
+  });
+
+  test('prorataEcsImmeubleMulti : Sh_ecs / SH, × rdim pour une installation individuelle seulement', () => {
+    expect(
+      prorataEcsImmeubleMulti(
+        { enum_type_installation_id: '1', surface_habitable: 20, rdim: 3 },
+        200
+      )
+    ).toBeCloseTo(0.3, 12);
+    expect(
+      prorataEcsImmeubleMulti({ enum_type_installation_id: '1', surface_habitable: 20 }, 200)
+    ).toBeCloseTo(0.1, 12);
+    expect(
+      prorataEcsImmeubleMulti(
+        { enum_type_installation_id: '2', surface_habitable: 150, rdim: 3 },
+        200
+      )
+    ).toBeCloseTo(0.75, 12);
+  });
+
+  test("prorataEcsImmeubleMulti : pas de × rdim si Sh_ecs est la surface totale de l'installation", () => {
+    expect(
+      prorataEcsImmeubleMulti(
+        { enum_type_installation_id: '1', surface_habitable: 3713, rdim: 64 },
+        3918,
+        false
+      )
+    ).toBeCloseTo(3713 / 3918, 12);
+  });
+
+  test("isSurfaceEcsParLogement : détecte la convention d'export de Sh_ecs", () => {
+    // Σ Sh × rdim = 20 × 3 + 115 = 175 = SH → surface d'un logement
+    expect(isSurfaceEcsParLogement([ecsIndividuelle(20, 3), ecsCollective(115)], 175)).toBe(true);
+    // Σ Sh = 3713 + 205 = 3918 = SH (ex. LICIEL) → surface totale de l'installation
+    expect(isSurfaceEcsParLogement([ecsIndividuelle(3713, 64), ecsCollective(205)], 3918)).toBe(
+      false
+    );
+  });
+
+  test('isSurfaceEcsParLogement : surface ou rdim absents comptés 0 et 1', () => {
+    const sansRdim = { donnee_entree: { enum_type_installation_id: '1', surface_habitable: 50 } };
+    const sansSurface = { donnee_entree: { enum_type_installation_id: '2' } };
+    // Σ Sh = Σ Sh × rdim = 50 : égalité → convention « surface de l'installation »
+    expect(isSurfaceEcsParLogement([sansRdim, sansSurface], 50)).toBe(false);
+    // Σ Sh × rdim = 20 × 3 = 60 = SH, Σ Sh = 20
+    expect(isSurfaceEcsParLogement([ecsIndividuelle(20, 3), sansSurface], 60)).toBe(true);
+  });
+
+  test('pertes récupérées sans × rdim quand Σ Sh_ecs = SH (DPE 2369E3867365O, LICIEL)', () => {
+    const instal_ecs = [ecsIndividuelle(160, 8), ecsCollective(40)];
+    const ret = calc_besoin_ch(0, 0, 0, 0, 200, 100, 3, instal_ecs, [], [], null, 'immeuble', 9);
+    const total = (0.1 * 10 * (160 / 200) + 0.212 * 10 * (40 / 200)) * 1000;
+    expect(ret.pertes_distribution_ecs_recup).toBeCloseTo((0.48 * 100 * total) / 8760, 9);
+  });
+
+  test('pertes de distribution ECS récupérées pondérées par Sh_ecs / SH (et rdim en individuel)', () => {
+    // Σ Sh × rdim = 20 × 3 + 115 = 175 = SH : Sh_ecs exportée par logement
+    const instal_ecs = [ecsIndividuelle(20, 3), ecsCollective(115)];
+    const ret = calc_besoin_ch(0, 0, 0, 0, 175, 100, 3, instal_ecs, [], [], null, 'immeuble', 4);
+    // Σ Tau × Becs × prorata (Wh) : 0,1 × 10 × (20 / 175 × 3) + 0,212 × 10 × 115 / 175
+    const total = (0.1 * 10 * ((20 / 175) * 3) + 0.212 * 10 * (115 / 175)) * 1000;
+    // un seul mois : Qrec_j = Qrec = 0,48 × ΣNref19 / 8760 × total
+    expect(ret.pertes_distribution_ecs_recup).toBeCloseTo((0.48 * 100 * total) / 8760, 9);
+  });
+});

package/README.md

@@ -370,14 +370,14 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <!-- CORPUS:START -->
 
-> **Version `1.8.36`** · branche `main` · généré le 2026-10-09
+> **Version `1.8.38`** · branche `main` · généré le 2026-10-10
 > Seuil de tolérance **5%**
 
 <table>
 <tr>
 <td align="center"><strong>9</strong><br/><sub>corpus</sub></td>
 <td align="center"><strong>89 984</strong><br/><sub>DPE analysés</sub></td>
-<td align="center"><strong>61 950</strong><br/><sub>DPE conformes</sub></td>
+<td align="center"><strong>61 951</strong><br/><sub>DPE conformes</sub></td>
 <td align="center"><strong>68,85 %</strong><br/><sub>réussite globale</sub></td>
 </tr>
 </table>
@@ -388,7 +388,7 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 | 🟢  | **Appartement · chauffage individuel (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_individuel_2025.csv`</sub> | **92,53 %** | `███████████████████░` | 9 253 / 10 000 |
 | 🟢  | **Logement individuel (2025)**<br/><sub>`dpe_logement_individuel_2025.csv`</sub>                                        | **89,54 %** | `██████████████████░░` |  8 947 / 9 992 |
 | 🟢  | **Maison individuelle (2025)**<br/><sub>`dpe_maison_individuelle_2025.csv`</sub>                                        | **88,61 %** | `██████████████████░░` |  8 860 / 9 999 |
-| 🟡  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **84,21 %** | `█████████████████░░░` |  8 419 / 9 998 |
+| 🟡  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **84,22 %** | `█████████████████░░░` |  8 420 / 9 998 |
 | 🟡  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **71,60 %** | `██████████████░░░░░░` | 7 160 / 10 000 |
 | 🟡  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **66,19 %** | `█████████████░░░░░░░` |  6 618 / 9 999 |
 | 🔴  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **53,71 %** | `███████████░░░░░░░░░` |  5 369 / 9 997 |
@@ -403,24 +403,24 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <table>
 <tr>
-<td align="center"><strong>5,13 ms</strong><br/><sub>moyenne</sub></td>
-<td align="center"><strong>4,48 ms</strong><br/><sub>médiane</sub></td>
+<td align="center"><strong>4,77 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>4,18 ms</strong><br/><sub>médiane</sub></td>
 <td align="center"><strong>0,11 ms</strong><br/><sub>min</sub></td>
-<td align="center"><strong>468,0 ms</strong><br/><sub>max</sub></td>
+<td align="center"><strong>803,0 ms</strong><br/><sub>max</sub></td>
 </tr>
 </table>
 
 | Corpus                                         | Moyenne | Médiane |     Min |      Max |     p95 |     p99 |
 | :--------------------------------------------- | ------: | ------: | ------: | -------: | ------: | ------: |
-| **Généraliste**                                | 4,50 ms | 4,02 ms | 0,22 ms |  33,8 ms | 8,30 ms | 12,2 ms |
-| **Appartement · chauffage individuel (2025)**  | 3,59 ms | 3,26 ms | 1,42 ms |  25,6 ms | 6,19 ms | 7,93 ms |
-| **Logement individuel (2025)**                 | 5,29 ms | 4,77 ms | 1,61 ms |  35,7 ms | 9,74 ms | 13,2 ms |
-| **Maison individuelle (2025)**                 | 6,09 ms | 5,50 ms | 1,84 ms |  37,9 ms | 10,9 ms | 14,2 ms |
-| **Immeuble · chauffage individuel**            | 6,28 ms | 5,40 ms | 0,12 ms |  85,1 ms | 12,7 ms | 19,8 ms |
-| **Appartement · chauffage collectif (2025)**   | 3,96 ms | 3,55 ms | 1,40 ms |  33,4 ms | 6,53 ms | 8,28 ms |
-| **Immeuble · chauffage collectif**             | 5,22 ms | 4,41 ms | 0,11 ms |  93,8 ms | 9,69 ms | 16,8 ms |
-| **Immeuble · chauffage mixte**                 | 5,18 ms | 4,23 ms | 0,22 ms | 468,0 ms | 10,7 ms | 17,7 ms |
-| **Individuel généré depuis l'immeuble (2026)** | 6,07 ms | 5,20 ms | 1,63 ms |  47,3 ms | 11,7 ms | 18,6 ms |
+| **Généraliste**                                | 4,10 ms | 3,68 ms | 0,22 ms |  30,3 ms | 7,50 ms | 10,6 ms |
+| **Appartement · chauffage individuel (2025)**  | 3,65 ms | 3,31 ms | 1,44 ms |  25,0 ms | 6,29 ms | 8,11 ms |
+| **Logement individuel (2025)**                 | 4,48 ms | 3,99 ms | 1,56 ms |  42,6 ms | 8,07 ms | 11,5 ms |
+| **Maison individuelle (2025)**                 | 5,21 ms | 4,74 ms | 1,90 ms |  43,1 ms | 8,99 ms | 12,2 ms |
+| **Immeuble · chauffage individuel**            | 6,01 ms | 5,14 ms | 0,11 ms |  82,9 ms | 12,1 ms | 19,4 ms |
+| **Appartement · chauffage collectif (2025)**   | 4,14 ms | 3,77 ms | 1,38 ms |  34,4 ms | 6,76 ms | 8,60 ms |
+| **Immeuble · chauffage collectif**             | 5,32 ms | 4,53 ms | 0,13 ms | 104,0 ms | 9,82 ms | 17,4 ms |
+| **Immeuble · chauffage mixte**                 | 4,73 ms | 3,88 ms | 0,19 ms | 803,0 ms | 9,38 ms | 15,8 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 5,31 ms | 4,59 ms | 1,72 ms |  40,3 ms | 9,84 ms | 15,7 ms |
 
 <sub>La moyenne est tirée vers le haut par les DPE collectifs, dont le coût atteint plusieurs
 dizaines de fois la médiane : c’est la médiane qui décrit le cas courant, et p95/p99 le cas

package/conso.js

@@ -626,6 +626,28 @@ function getEcsConso(gen_ecs, field, coef, prorataECS, prefix) {
   }, 0);
 }
 
+/**
+ * Consommation des auxiliaires de génération ECS (circulateurs des générateurs).
+ * Le besoin d'une installation dimensionnée (rdim > 1) est exprimé par unité : comme la
+ * consommation ECS (cle_repartition_ecs × rdim), les auxiliaires de génération sont multipliés
+ * par le rdim de l'installation lorsque la conso est calculée à l'échelle du DPE (prorataECS = 1).
+ * @see Moteur_DPE.dll Calcul_batiment.cs l.660 (Qcirc_ecs1 += Qcirc × Rdim)
+ * @param ecs {InstallationEcs[]}
+ * @param field {string} conso_auxiliaire_generation_ecs[_depensier]
+ * @param coef {object}
+ * @param prorataECS {number}
+ * @returns {number}
+ */
+export function getAuxGenerationEcs(ecs, field, coef, prorataECS) {
+  return ecs.reduce((acc, inst) => {
+    const rdim = prorataECS === 1 ? Number(inst.donnee_entree.rdim) || 1 : 1;
+    return inst.generateur_ecs_collection.generateur_ecs.reduce((acc2, gen) => {
+      const conso = (gen.donnee_intermediaire[field] || 0) * rdim;
+      return acc2 + getConso(coef, 'électricité auxiliaire', conso);
+    }, acc);
+  }, 0);
+}
+
 /**
  * Calcul de la consommation globale de chauffage
  * @param gen_ch {Generateur_chauffage_collection}
@@ -721,15 +743,19 @@ function calc_conso_pond(
     prefix
   );
 
-  ret.auxiliaire_generation_ecs = gen_ecs.reduce((acc, gen_ecs) => {
-    const conso = gen_ecs.donnee_intermediaire.conso_auxiliaire_generation_ecs || 0;
-    return acc + getConso(coef, 'électricité auxiliaire', conso);
-  }, 0);
+  ret.auxiliaire_generation_ecs = getAuxGenerationEcs(
+    ecs_installations,
+    'conso_auxiliaire_generation_ecs',
+    coef,
+    prorataECS
+  );
 
-  ret.auxiliaire_generation_ecs_depensier = gen_ecs.reduce((acc, gen_ecs) => {
-    const conso = gen_ecs.donnee_intermediaire.conso_auxiliaire_generation_ecs_depensier || 0;
-    return acc + getConso(coef, 'électricité auxiliaire', conso);
-  }, 0);
+  ret.auxiliaire_generation_ecs_depensier = getAuxGenerationEcs(
+    ecs_installations,
+    'conso_auxiliaire_generation_ecs_depensier',
+    coef,
+    prorataECS
+  );
 
   ret.auxiliaire_distribution_ecs = ecs_installations.reduce((acc, inst) => {
     const conso = inst.donnee_intermediaire.conso_auxiliaire_distribution_ecs || 0;

package/conso.spec.js

@@ -55,6 +55,7 @@ const {
   getCoefCout,
   coefCoutProrata,
   masqueEnergie,
+  getAuxGenerationEcs,
   DATE_BAREME_COUT_2024
 } = await import('./conso.js');
 
@@ -734,3 +735,65 @@ describe('coefCoutProrata - ratio de surface des installations collectives', ()
     });
   });
 });
+
+/**
+ * Auxiliaires de génération ECS : multipliés par le rdim de l'installation (comme la conso ECS).
+ * @see Moteur_DPE.dll Calcul_batiment.cs l.660 (Qcirc_ecs1 += Qcirc × Rdim) ; autotests IC-echantillon-gaz.
+ */
+describe('getAuxGenerationEcs - auxiliaires de génération ECS et rdim', () => {
+  const coefUnitaire = { 'électricité auxiliaire': 1 };
+  const inst = (rdim, ...consos) =>
+    installEcs(
+      rdim === undefined ? {} : { rdim },
+      consos.map((c) =>
+        genEcs('1', {
+          conso_auxiliaire_generation_ecs: c,
+          conso_auxiliaire_generation_ecs_depensier: 2 * c
+        })
+      )
+    );
+
+  test('installation dimensionnée (rdim 3,25) : auxiliaires × rdim à l’échelle du DPE', () => {
+    const ecs = [inst(3.25, 2.74, 2.97), inst(undefined, 10)];
+    // (2,74 + 2,97) × 3,25 + 10 × 1
+    expect(
+      getAuxGenerationEcs(ecs, 'conso_auxiliaire_generation_ecs', coefUnitaire, 1)
+    ).toBeCloseTo((2.74 + 2.97) * 3.25 + 10, 9);
+    expect(
+      getAuxGenerationEcs(ecs, 'conso_auxiliaire_generation_ecs_depensier', coefUnitaire, 1)
+    ).toBeCloseTo(2 * ((2.74 + 2.97) * 3.25 + 10), 9);
+  });
+
+  test('appartement proratisé (prorataECS ≠ 1) : rdim non appliqué', () => {
+    const ecs = [inst(3.25, 4)];
+    expect(getAuxGenerationEcs(ecs, 'conso_auxiliaire_generation_ecs', coefUnitaire, 0.4)).toBe(4);
+  });
+
+  test('rdim non numérique ou générateur sans conso : neutre', () => {
+    const ecs = [inst('abc', 4), installEcs({ rdim: 2 }, [genEcs('1', {})])];
+    expect(getAuxGenerationEcs(ecs, 'conso_auxiliaire_generation_ecs', coefUnitaire, 1)).toBe(4);
+  });
+
+  test('calc_conso : auxiliaire_generation_ecs intègre le rdim', () => {
+    const ecs = [inst(2, 5)];
+    const res = calc_conso(100, 1, 1, [], [], ecs, [], 1, 1, DATE_DPE, coef_ep);
+    const sansRdim = calc_conso(
+      100,
+      1,
+      1,
+      [],
+      [],
+      [inst(undefined, 5)],
+      [],
+      1,
+      1,
+      DATE_DPE,
+      coef_ep
+    );
+    expect(res.ef_conso.conso_auxiliaire_generation_ecs).toBeCloseTo(
+      2 * sansRdim.ef_conso.conso_auxiliaire_generation_ecs,
+      9
+    );
+    expect(res.ef_conso.conso_auxiliaire_generation_ecs).toBeGreaterThan(0);
+  });
+});

package/engine.js

@@ -33,7 +33,7 @@ import getFicheTechnique from './ficheTechnique.js';
 import { ProductionENR, ratioProrataPvLogement } from './16.2_production_enr.js';
 import DpeSanitizerService from './dpe-sanitizer.service.js';
 
-const LIB_VERSION = '1.8.37';
+const LIB_VERSION = '1.8.39';
 
 const dpeSanitizerService = new DpeSanitizerService();
 
@@ -472,7 +472,8 @@ export function calcul_3cl(inputDpe, options) {
         ca_id,
         zc_id,
         apport_et_besoin.nadeq,
-        dpe.logement.caracteristique_generale.nombre_niveau_immeuble
+        dpe.logement.caracteristique_generale.nombre_niveau_immeuble,
+        isImmeubleMultiEcs
       );
     }
   });

package/engine.spec.js

@@ -486,7 +486,8 @@ describe('calcul_3cl - run intégral (maison)', () => {
       'ca1',
       'zc1',
       2, // nadeq
-      3 // nombre_niveau_immeuble
+      3, // nombre_niveau_immeuble
+      false // isImmeubleMultiEcs (maison)
     );
 
     // Climatisation présente : calc_clim appelé.

package/package.json

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