@open3cl/engine 1.8.17 → 1.8.19

package/11_ecs.js

@@ -149,7 +149,8 @@ export default function calc_ecs(
   surfaceImmeuble,
   nombreAppartements,
   isImmeubleSystemEcsIndividuels,
-  becsParMois
+  becsParMois,
+  isImmeubleMultiEcs = false
 ) {
   const de = ecs.donnee_entree;
   const di = {};
@@ -157,7 +158,18 @@ export default function calc_ecs(
 
   // La conso de chaque générateur ECS doit être ramenée au prorata de la surface du logement
   di.ratio_besoin_ecs = 1;
-  if (virtualisationECS) {
+  if (isImmeubleMultiEcs) {
+    /**
+     * Immeuble avec plusieurs installations ECS (collectives ou mixtes) : ratio de besoin =
+     * surface habitable desservie par l'installation / surface habitable de l'immeuble,
+     * sans normalisation ni plafonnement. Le besoin est exprimé par unité dimensionnée (/ rdim),
+     * la consommation étant remultipliée par rdim lors de l'agrégation (conso.js, cle_repartition_ecs).
+     * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - §11.4
+     * @see Moteur_DPE.dll Calcul_batiment.Calcul_Cecs() et Calcul_Cecs_installation_2()
+     */
+    di.ratio_besoin_ecs =
+      Number(de.surface_habitable) / Number(surfaceImmeuble) / (Number(de.rdim) || 1);
+  } else if (virtualisationECS) {
     di.ratio_besoin_ecs = de.cle_repartition_ecs || 1;
   } else if (isImmeubleSystemEcsIndividuels) {
     if (nombreAppartements) {

package/11_ecs.spec.js

@@ -148,6 +148,104 @@ describe('calc_ecs - ratio de besoin ECS', () => {
   });
 });
 
+/**
+ * Immeuble à plusieurs installations ECS collectives ou mixtes (#232) :
+ * ratio = Sh_ecs / Sh immeuble / (rdim || 1), prorata brut sans normalisation ni plafond.
+ * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - §11.4
+ * @see Moteur_DPE.dll Calcul_batiment.Calcul_Cecs() (l.579-593)
+ */
+describe('calc_ecs - immeuble à plusieurs installations ECS (prorata des surfaces)', () => {
+  /** Calcule le ratio d'une installation dans le cas immeuble multi-ECS. */
+  function calcImmeuble(de, surfaceImmeuble, options = {}) {
+    const ecs = makeEcs({ tv_rendement_distribution_ecs_id: '5', ...de });
+    calc_ecs(
+      {},
+      ecs,
+      1000,
+      1500,
+      1,
+      'ca1',
+      'h1a',
+      'immeuble',
+      options.virtualisation ?? false,
+      surfaceImmeuble,
+      options.nombreAppartements ?? null,
+      options.individuels ?? false,
+      {},
+      options.multiEcs ?? true
+    );
+    return ecs.donnee_intermediaire;
+  }
+
+  test('autotest IC1-0-2 : 2 installations collectives 20 et 155 m² sur 175 m²', () => {
+    const di1 = calcImmeuble({ enum_type_installation_id: '2', surface_habitable: 20 }, 175);
+    const di2 = calcImmeuble({ enum_type_installation_id: '2', surface_habitable: 155 }, 175);
+
+    expect(di1.ratio_besoin_ecs).toBeCloseTo(20 / 175, 9); // 0,1143
+    expect(di2.ratio_besoin_ecs).toBeCloseTo(155 / 175, 9); // 0,8857
+    expect(di1.ratio_besoin_ecs + di2.ratio_besoin_ecs).toBeCloseTo(1, 9);
+    expect(di1.besoin_ecs).toBeCloseTo((1000 * 20) / 175, 9);
+  });
+
+  test('somme des surfaces < Sh immeuble (461 sur 922) : prorata brut 0,5 sans normalisation', () => {
+    const di = calcImmeuble({ enum_type_installation_id: '2', surface_habitable: 461 }, 922);
+
+    expect(di.ratio_besoin_ecs).toBe(0.5);
+    expect(di.besoin_ecs).toBe(500);
+  });
+
+  test('somme des surfaces > Sh immeuble : prorata brut sans plafonnement', () => {
+    const di = calcImmeuble({ enum_type_installation_id: '2', surface_habitable: 7706 }, 8726);
+
+    expect(di.ratio_besoin_ecs).toBeCloseTo(7706 / 8726, 9);
+  });
+
+  test('immeuble mixte : installation individuelle 800 m², rdim 13, sur 2400 m² => besoin par unité', () => {
+    const di = calcImmeuble(
+      { enum_type_installation_id: '1', surface_habitable: 800, rdim: 13 },
+      2400
+    );
+
+    expect(di.ratio_besoin_ecs).toBeCloseTo(800 / 2400 / 13, 9); // 0,02564
+    expect(di.ratio_besoin_ecs).toBeCloseTo(0.02564, 5);
+  });
+
+  test('rdim nul ou absent : diviseur 1', () => {
+    expect(
+      calcImmeuble({ surface_habitable: 50, rdim: 0, enum_type_installation_id: '2' }, 200)
+        .ratio_besoin_ecs
+    ).toBe(0.25);
+    expect(
+      calcImmeuble({ surface_habitable: '50', enum_type_installation_id: '2' }, '200')
+        .ratio_besoin_ecs
+    ).toBe(0.25);
+  });
+
+  test('besoin_ecs_depensier suit le même ratio que besoin_ecs', () => {
+    const di = calcImmeuble({ enum_type_installation_id: '2', surface_habitable: 20 }, 175);
+
+    expect(di.besoin_ecs_depensier).toBeCloseTo((1500 * 20) / 175, 9);
+    expect(di.besoin_ecs_depensier / di.besoin_ecs).toBeCloseTo(1.5, 9);
+  });
+
+  test('prioritaire sur la clé de répartition et la branche « tout individuel »', () => {
+    const di = calcImmeuble(
+      { enum_type_installation_id: '2', surface_habitable: 100, cle_repartition_ecs: 0.9 },
+      200,
+      { virtualisation: true, individuels: true, nombreAppartements: 4 }
+    );
+
+    expect(di.ratio_besoin_ecs).toBe(0.5);
+  });
+
+  test('sans indicateur multi-ECS (valeur par défaut) : comportement historique conservé (1 / rdim)', () => {
+    const ecs = makeEcs({ tv_rendement_distribution_ecs_id: '5', surface_habitable: 100, rdim: 4 });
+    calc_ecs({}, ecs, 1000, 1500, 1, 'ca1', 'h1a', 'immeuble', false, 200, null, false, {});
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBe(0.25);
+  });
+});
+
 describe('calc_ecs - rendement de distribution', () => {
   test('la ligne forfaitaire alimente rendement_distribution et l’identifiant de table', () => {
     const de = { tv_rendement_distribution_ecs_id: '5' };

package/15_conso_aux.js

@@ -236,16 +236,28 @@ function getPuissanceCirculateur(em_ch, de, di, du, surfaceHabitable, GV, Tbase)
 
   const nbNiveauChauffage = de.nombre_niveau_installation_ch || 1;
 
+  /**
+   * Surface desservie par l'installation : le réseau (Lem) et le nombre de circulateurs
+   * (Sh / 400) sont ceux de l'installation, pas ceux du bâtiment entier (ex. immeuble à
+   * installations individuelles par logement), comme le moteur de référence CSTB (Tribu).
+   *
+   * En DPE immeuble, une installation décrite représente rdim logements identiques : le
+   * circulateur est dimensionné pour un logement (surface / rdim) puis multiplié par rdim
+   * (Tribu, Calcul_batiment.cs : Caux_dist_ch += Caux_dist_ch_installation × Rdim).
+   */
+  const rdim = de.rdim_installation_ch || 1;
+  const surfaceInstallation = (de.surface_chauffee || surfaceHabitable) / rdim;
+  const nbCirculateurs = Math.max(1, surfaceInstallation / 400);
+
   // Calcul de la longueur du réseau le plus défavorisé
-  const Lem = 5 * Fcot * (nbNiveauChauffage + (surfaceHabitable / nbNiveauChauffage) ** 0.5);
+  const Lem = 5 * Fcot * (nbNiveauChauffage + (surfaceInstallation / nbNiveauChauffage) ** 0.5);
 
   // Pertes de charge du réseau (kPa)
   const deltaPemnom = 0.15 * Lem + deltaPem;
 
   // Ratio du besoin couvert par l’équipement
   const nbGenerateurCascade = du.nbGenerateurCascade || 1;
-  const ratioSurfaceChauffage =
-    (de.surface_chauffee || surfaceHabitable) / (surfaceHabitable * nbGenerateurCascade);
+  const ratioSurfaceChauffage = surfaceInstallation / (surfaceHabitable * nbGenerateurCascade);
 
   // Chute nominale de température de dimensionnement
   const deltaDim = getDeltaDim(em_ch);
@@ -255,11 +267,8 @@ function getPuissanceCirculateur(em_ch, de, di, du, surfaceHabitable, GV, Tbase)
 
   const Qvemnom = (Pnc * ratioSurfaceChauffage) / (1.163 * deltaDim);
 
-  return Math.max(
-    30,
-    6.44 *
-      ((deltaPemnom * Qvemnom) / Math.max(1, surfaceHabitable / 400)) ** 0.676 *
-      Math.max(1, surfaceHabitable / 400)
+  return (
+    rdim * Math.max(30, 6.44 * ((deltaPemnom * Qvemnom) / nbCirculateurs) ** 0.676 * nbCirculateurs)
   );
 }
 

package/15_conso_aux.spec.js

@@ -299,6 +299,73 @@ describe('conso_aux_distribution_ch - auxiliaires de distribution', () => {
     // Pcirc ∝ Qvemnom^0,676 et Qvemnom ∝ 1/ΔθDim : diviser ΔθDim par 2 multiplie Pcirc par 2^0,676
     expect(toutBasse / bassepuisHaute).toBeCloseTo(2 ** 0.676, 9);
   });
+
+  /**
+   * Cas des autotests CSTB IC1-0-1/11/12 : immeuble de 175 m² à installations individuelles,
+   * l'installation étudiée dessert un logement de 80 m². Lem et le nombre de circulateurs sont
+   * ceux de l'installation (80 m²), pas ceux de l'immeuble (Tribu : Pcirc = 46,594 W).
+   */
+  test("installation partielle : Lem calculée sur la surface desservie par l'installation", () => {
+    const calcul = (de, sh) => {
+      const di = {};
+      conso_aux_distribution_ch(emCh, de, di, {}, sh, 1, 1, '0', 100000);
+      return di.conso_auxiliaire_distribution_ch;
+    };
+    const partielle = calcul({ surface_chauffee: 80 }, 175);
+    // valeur de référence de régression
+    expect(partielle).toBeCloseTo(125.15085008075532, 9);
+    // Lem dépend de la seule surface de l'installation : même réseau que pour un logement seul
+    // de 80 m² recevant la même puissance (GV × 80 / 175)
+    const di = {};
+    conso_aux_distribution_ch(emCh, {}, di, {}, 80, 1, 1, '0', (100000 * 80) / 175);
+    expect(partielle).toBeCloseTo(di.conso_auxiliaire_distribution_ch, 9);
+  });
+
+  test("installation de plus de 400 m² : nombre de circulateurs selon la surface de l'installation", () => {
+    const calcul = (de, sh) => {
+      const di = {};
+      conso_aux_distribution_ch(emCh, de, di, {}, sh, 1, 1, '0', 1000000);
+      return di.conso_auxiliaire_distribution_ch;
+    };
+    const partielle = calcul({ surface_chauffee: 800 }, 1600);
+    const di = {};
+    conso_aux_distribution_ch(emCh, {}, di, {}, 800, 1, 1, '0', 500000);
+    expect(partielle).toBeCloseTo(di.conso_auxiliaire_distribution_ch, 9);
+  });
+
+  /**
+   * DPE immeuble : une installation décrite représente rdim logements identiques. Tribu
+   * dimensionne le circulateur d'un logement (surface / rdim) puis multiplie la consommation
+   * par rdim (Calcul_batiment.cs : Caux_dist_ch += Caux_dist_ch_installation × Rdim).
+   * Cas réel 2437E4022989X (LICIEL) : 4 installations de 281,5 m², rdim 4 → 2 699,04 kWh.
+   */
+  test('immeuble, installation représentant rdim logements : circulateur par logement × rdim', () => {
+    const calcul = (de, sh, gv) => {
+      const di = {};
+      conso_aux_distribution_ch(emCh, de, di, {}, sh, 1, 1, '0', gv);
+      return di.conso_auxiliaire_distribution_ch;
+    };
+    const avecRdim = calcul({ surface_chauffee: 800, rdim_installation_ch: 4 }, 1600, 1000000);
+    // un logement de 200 m² recevant la puissance de 200 m² sur 1 600 m², multiplié par 4
+    const logement = calcul({}, 200, (1000000 * 200) / 1600);
+    expect(avecRdim).toBeCloseTo(4 * logement, 9);
+    // valeur de référence de régression
+    expect(avecRdim).toBeCloseTo(1114.9777138082252, 9);
+    // sans rdim, l'installation de 800 m² aurait un seul réseau de 800 m²
+    expect(calcul({ surface_chauffee: 800 }, 1600, 1000000)).not.toBeCloseTo(avecRdim, 3);
+  });
+
+  test('rdim égal à 1 : aucun effet', () => {
+    const calcul = (de) => {
+      const di = {};
+      conso_aux_distribution_ch(emCh, de, di, {}, 175, 1, 1, '0', 100000);
+      return di.conso_auxiliaire_distribution_ch;
+    };
+    expect(calcul({ surface_chauffee: 80, rdim_installation_ch: 1 })).toBeCloseTo(
+      calcul({ surface_chauffee: 80 }),
+      12
+    );
+  });
 });
 
 /**

package/9_chauffage.js

@@ -12,6 +12,16 @@ import enums from './enums.js';
 /**
  * @param dpe {FullDpe}
  */
+/**
+ * DPE immeuble (même règle que calc_th du moteur : « appartement » ou « maison » priment).
+ * @param map_id {string|number} enum_methode_application_dpe_log_id
+ * @return {boolean}
+ */
+export function isImmeuble(map_id) {
+  const map = enums.methode_application_dpe_log?.[map_id] || '';
+  return map.includes('immeuble') && !map.includes('appartement') && !map.includes('maison');
+}
+
 export default function calc_chauffage(
   dpe,
   ch,
@@ -60,6 +70,7 @@ export default function calc_chauffage(
     genChDe.ratio_virtualisation = de.ratio_virtualisation || 1;
     genChDe.cle_repartition_ch = de.cle_repartition_ch || 1;
     genChDe.surface_chauffee = de.surface_chauffee || Sh;
+    genChDe.rdim_installation_ch = isImmeuble(map_id) ? Number(de.rdim) || 1 : 1;
     genChDe.nombre_niveau_installation_ch = de.nombre_niveau_installation_ch || 1;
     genChDe.fch = Fch || 0.5;
 

package/9_chauffage.spec.js

@@ -46,11 +46,20 @@ vi.mock('./13.2_generateur_combustion_ch.js', () => ({
 vi.mock('./enums.js', () => ({
   default: {
     classe_altitude: { 1: 'ca1', 2: 'ca2' },
+    methode_application_dpe_log: {
+      2: 'dpe appartement individuel chauffage individuel ecs individuel',
+      6: 'dpe immeuble collectif chauffage individuel ecs individuel',
+      10: 'dpe appartement généré à partir des données dpe immeuble chauffage individuel ecs individuel'
+    },
     zone_climatique: { 1: 'h1a', 2: 'h2b', 3: 'h3c' }
   }
 }));
 
-const { default: calc_chauffage, tauxChargeForGenerator } = await import('./9_chauffage.js');
+const {
+  default: calc_chauffage,
+  tauxChargeForGenerator,
+  isImmeuble
+} = await import('./9_chauffage.js');
 const { requestInput, tv, tvColumnIDs } = await import('./utils.js');
 const { calc_emetteur_ch } = await import('./9_emetteur_ch.js');
 const { calc_generateur_ch, checkForGeneratorType, hasConsoForAuxDistribution } =
@@ -234,6 +243,41 @@ describe('calc_chauffage - mise à l’échelle du besoin selon la surface', ()
   });
 });
 
+describe('calc_chauffage - rdim de l’installation transmis au générateur', () => {
+  const rdimGen = (ch) =>
+    ch.generateur_chauffage_collection.generateur_chauffage[0].donnee_entree.rdim_installation_ch;
+
+  test('DPE immeuble : rdim de l’installation repris', () => {
+    const ch = installation([generateur()], [emetteur('1')], { rdim: '4' });
+    appel(ch, { map_id: 6 });
+    expect(rdimGen(ch)).toBe(4);
+  });
+
+  test('DPE immeuble sans rdim : 1', () => {
+    const ch = installation([generateur()], [emetteur('1')]);
+    appel(ch, { map_id: 6 });
+    expect(rdimGen(ch)).toBe(1);
+  });
+
+  test('DPE appartement (y compris issu d’un DPE immeuble) : rdim ignoré', () => {
+    const ch = installation([generateur()], [emetteur('1')], { rdim: '4' });
+    appel(ch, { map_id: 10 });
+    expect(rdimGen(ch)).toBe(1);
+    appel(ch, { map_id: 2 });
+    expect(rdimGen(ch)).toBe(1);
+  });
+});
+
+describe('isImmeuble', () => {
+  test('immeuble uniquement, pas appartement issu d’un immeuble ni méthode inconnue', () => {
+    expect(isImmeuble(6)).toBe(true);
+    expect(isImmeuble('6')).toBe(true);
+    expect(isImmeuble(10)).toBe(false);
+    expect(isImmeuble(2)).toBe(false);
+    expect(isImmeuble(999)).toBe(false);
+  });
+});
+
 describe('calc_chauffage - facteur de couverture solaire (Fch)', () => {
   test('facteur saisi directement pris tel quel', () => {
     const ch = installation([generateur()], [emetteur('1')]);

package/README.md

@@ -370,28 +370,28 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <!-- CORPUS:START -->
 
-> **Version `1.8.15`** · branche `main` · généré le 2026-10-02
+> **Version `1.8.18`** · branche `main` · généré le 2026-10-03
 > Seuil de tolérance **5%**
 
 <table>
 <tr>
 <td align="center"><strong>9</strong><br/><sub>corpus</sub></td>
 <td align="center"><strong>89 990</strong><br/><sub>DPE analysés</sub></td>
-<td align="center"><strong>60 383</strong><br/><sub>DPE conformes</sub></td>
-<td align="center"><strong>67,10 %</strong><br/><sub>réussite globale</sub></td>
+<td align="center"><strong>60 638</strong><br/><sub>DPE conformes</sub></td>
+<td align="center"><strong>67,38 %</strong><br/><sub>réussite globale</sub></td>
 </tr>
 </table>
 
 |     | Corpus                                                                                                                  |    Réussite |                        |  DPE conformes |
 | :-: | :---------------------------------------------------------------------------------------------------------------------- | ----------: | :--------------------- | -------------: |
 | 🔴  | **Généraliste**<br/><sub>`corpus_dpe.csv`</sub>                                                                         | **46,54 %** | `█████████░░░░░░░░░░░` | 4 654 / 10 000 |
-| 🟢  | **Appartement · chauffage individuel (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_individuel_2025.csv`</sub> | **92,46 %** | `██████████████████░░` | 9 246 / 10 000 |
+| 🟢  | **Appartement · chauffage individuel (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_individuel_2025.csv`</sub> | **92,52 %** | `███████████████████░` | 9 252 / 10 000 |
 | 🟢  | **Logement individuel (2025)**<br/><sub>`dpe_logement_individuel_2025.csv`</sub>                                        | **89,46 %** | `██████████████████░░` |  8 939 / 9 992 |
 | 🟢  | **Maison individuelle (2025)**<br/><sub>`dpe_maison_individuelle_2025.csv`</sub>                                        | **88,56 %** | `██████████████████░░` | 8 856 / 10 000 |
-| 🟡  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **75,88 %** | `███████████████░░░░░` |  7 587 / 9 999 |
+| 🟡  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **76,05 %** | `███████████████░░░░░` |  7 604 / 9 999 |
 | 🟡  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **71,24 %** | `██████████████░░░░░░` | 7 124 / 10 000 |
-| 🟡  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **62,78 %** | `█████████████░░░░░░░` |  6 277 / 9 999 |
-| 🔴  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **49,61 %** | `██████████░░░░░░░░░░` | 4 961 / 10 000 |
+| 🟡  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **63,34 %** | `█████████████░░░░░░░` |  6 333 / 9 999 |
+| 🔴  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **51,37 %** | `██████████░░░░░░░░░░` | 5 137 / 10 000 |
 | 🔴  | **Individuel généré depuis l'immeuble (2026)**<br/><sub>`dpe_individuel_a_partir_dpe_immeuble_2026.csv`</sub>           | **27,39 %** | `█████░░░░░░░░░░░░░░░` | 2 739 / 10 000 |
 
 <sub>🟢 ≥ 85 % · 🟡 ≥ 60 % · 🔴 < 60 %</sub>
@@ -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,61 ms</strong><br/><sub>moyenne</sub></td>
-<td align="center"><strong>4,83 ms</strong><br/><sub>médiane</sub></td>
-<td align="center"><strong>0,13 ms</strong><br/><sub>min</sub></td>
-<td align="center"><strong>553,5 ms</strong><br/><sub>max</sub></td>
+<td align="center"><strong>4,82 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>4,21 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>529,8 ms</strong><br/><sub>max</sub></td>
 </tr>
 </table>
 
 | Corpus                                         | Moyenne | Médiane |     Min |      Max |     p95 |     p99 |
 | :--------------------------------------------- | ------: | ------: | ------: | -------: | ------: | ------: |
-| **Généraliste**                                | 5,81 ms | 4,80 ms | 0,23 ms |  65,1 ms | 12,7 ms | 21,9 ms |
-| **Appartement · chauffage individuel (2025)**  | 4,53 ms | 4,10 ms | 1,55 ms |  34,9 ms | 7,91 ms | 11,3 ms |
-| **Logement individuel (2025)**                 | 5,04 ms | 4,40 ms | 1,65 ms |  44,6 ms | 9,54 ms | 13,2 ms |
-| **Maison individuelle (2025)**                 | 5,61 ms | 5,02 ms | 1,84 ms |  42,6 ms | 10,0 ms | 13,8 ms |
-| **Immeuble · chauffage individuel**            | 6,64 ms | 5,59 ms | 0,13 ms | 124,6 ms | 13,4 ms | 21,2 ms |
-| **Appartement · chauffage collectif (2025)**   | 5,10 ms | 4,85 ms | 1,58 ms |  39,5 ms | 8,31 ms | 11,3 ms |
-| **Immeuble · chauffage collectif**             | 5,58 ms | 4,68 ms | 0,13 ms | 127,9 ms | 10,1 ms | 17,8 ms |
-| **Immeuble · chauffage mixte**                 | 6,34 ms | 5,01 ms | 0,18 ms | 553,5 ms | 14,1 ms | 25,2 ms |
-| **Individuel généré depuis l'immeuble (2026)** | 5,85 ms | 5,04 ms | 1,57 ms |  49,4 ms | 11,0 ms | 16,7 ms |
+| **Généraliste**                                | 4,19 ms | 3,76 ms | 0,20 ms |  33,9 ms | 7,64 ms | 10,2 ms |
+| **Appartement · chauffage individuel (2025)**  | 3,71 ms | 3,37 ms | 1,36 ms |  30,7 ms | 6,39 ms | 8,02 ms |
+| **Logement individuel (2025)**                 | 4,61 ms | 4,10 ms | 1,53 ms |  34,8 ms | 8,54 ms | 11,6 ms |
+| **Maison individuelle (2025)**                 | 5,26 ms | 4,71 ms | 1,73 ms |  45,6 ms | 9,47 ms | 12,3 ms |
+| **Immeuble · chauffage individuel**            | 5,97 ms | 5,12 ms | 0,11 ms |  86,4 ms | 11,9 ms | 18,8 ms |
+| **Appartement · chauffage collectif (2025)**   | 4,13 ms | 3,74 ms | 1,50 ms |  33,6 ms | 6,79 ms | 8,46 ms |
+| **Immeuble · chauffage collectif**             | 5,30 ms | 4,49 ms | 0,14 ms | 104,9 ms | 9,79 ms | 17,5 ms |
+| **Immeuble · chauffage mixte**                 | 4,93 ms | 4,06 ms | 0,19 ms | 529,8 ms | 10,1 ms | 16,7 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 5,26 ms | 4,52 ms | 1,62 ms |  38,7 ms | 9,78 ms | 15,3 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/engine.js

@@ -33,7 +33,7 @@ import getFicheTechnique from './ficheTechnique.js';
 import { ProductionENR } from './16.2_production_enr.js';
 import DpeSanitizerService from './dpe-sanitizer.service.js';
 
-const LIB_VERSION = '1.8.17';
+const LIB_VERSION = '1.8.19';
 
 const dpeSanitizerService = new DpeSanitizerService();
 
@@ -323,17 +323,37 @@ export function calcul_3cl(inputDpe, options) {
   let becs = apport_et_besoin.besoin_ecs;
   let becs_dep = apport_et_besoin.besoin_ecs_depensier;
   let isImmeubleSystemEcsIndividuels = false;
+  let isImmeubleMultiEcs = false;
 
   /**
    * 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
+   *
+   * Immeuble avec plusieurs installations ECS (collectives ou mixtes) : le besoin est réparti
+   * au prorata de la surface habitable desservie par chaque installation (Sh_ecs / Sh immeuble),
+   * sans normalisation ni plafonnement (cf. calc_ecs).
+   * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - §11.4
+   * @see Guide Tribu TE-211208 p. 24 ; Moteur_DPE.dll Calcul_batiment.Calcul_Cecs()
    */
   if (ecs.length > 1) {
     // Immeuble avec différents systèmes individuels
     isImmeubleSystemEcsIndividuels =
       th === 'immeuble' && ecs.every((e) => e.donnee_entree.enum_type_installation_id === '1');
 
-    if (!isImmeubleSystemEcsIndividuels) {
+    if (th === 'immeuble' && !isImmeubleSystemEcsIndividuels) {
+      isImmeubleMultiEcs =
+        Number(cg.surface_habitable_immeuble) > 0 &&
+        ecs.every((e) => Number(e.donnee_entree.surface_habitable) > 0);
+
+      if (!isImmeubleMultiEcs) {
+        console.warn(
+          `Immeuble avec plusieurs installations ECS : surface habitable de l'immeuble ou d'une installation ECS absente ou nulle.
+          Repli sur la division du besoin ECS par 2 (§11.4).`
+        );
+      }
+    }
+
+    if (!isImmeubleSystemEcsIndividuels && !isImmeubleMultiEcs) {
       becs /= 2;
       becs_dep /= 2;
     }
@@ -438,7 +458,8 @@ export function calcul_3cl(inputDpe, options) {
       dpe.logement.caracteristique_generale.surface_habitable_immeuble,
       dpe.logement.caracteristique_generale.nombre_appartement,
       isImmeubleSystemEcsIndividuels,
-      apport_et_besoin.besoin_ecs_par_mois || {}
+      apport_et_besoin.besoin_ecs_par_mois || {},
+      isImmeubleMultiEcs
     );
 
     if (!dpeGenereImmeuble) {

package/engine.spec.js

@@ -565,7 +565,7 @@ describe('calcul_3cl - surfaces immeuble / appartement et prorata', () => {
     expect(conso_aux_distribution_ecs.mock.calls[0][3]).toBe(200);
   });
 
-  test('immeuble : systèmes ECS non tous individuels => besoin divisé par deux', () => {
+  test('immeuble : systèmes ECS non tous individuels sans surfaces => repli sur la division par deux', () => {
     enums.methode_application_dpe_log = { 1: 'dpe immeuble collectif' };
     const dpe = makeDpe();
     dpe.logement.installation_ecs_collection.installation_ecs = [
@@ -578,11 +578,86 @@ describe('calcul_3cl - surfaces immeuble / appartement et prorata', () => {
         generateur_ecs_collection: { generateur_ecs: [] }
       }
     ];
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
 
     calcul_3cl(dpe, { sanitize: false });
 
     expect(calc_ecs.mock.calls[0][11]).toBe(false);
     expect(calc_ecs.mock.calls[0][2]).toBe(50); // 100 / 2
+    expect(calc_ecs.mock.calls[0][13]).toBe(false); // pas de prorata des surfaces
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('Repli sur la division'));
+    warn.mockRestore();
+  });
+
+  /**
+   * Immeuble à plusieurs installations ECS collectives ou mixtes : répartition au prorata des
+   * surfaces (cf. calc_ecs), sans division par 2.
+   * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - §11.4
+   */
+  describe('immeuble à plusieurs installations ECS collectives ou mixtes (#232)', () => {
+    function makeImmeubleMultiEcs(surfaces, surfaceImmeuble = 200) {
+      enums.methode_application_dpe_log = { 1: 'dpe immeuble collectif' };
+      const dpe = makeDpe();
+      dpe.logement.caracteristique_generale.surface_habitable_immeuble = surfaceImmeuble;
+      dpe.logement.installation_ecs_collection.installation_ecs = surfaces.map((s, i) => ({
+        donnee_entree: { enum_type_installation_id: i === 0 ? '1' : '2', surface_habitable: s },
+        generateur_ecs_collection: { generateur_ecs: [] }
+      }));
+      return dpe;
+    }
+
+    test('surfaces renseignées : besoin non divisé et prorata des surfaces signalé à calc_ecs', () => {
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      calcul_3cl(makeImmeubleMultiEcs([20, 155]), { sanitize: false });
+
+      expect(calc_ecs).toHaveBeenCalledTimes(2);
+      calc_ecs.mock.calls.forEach((call) => {
+        expect(call[2]).toBe(100); // besoin_ecs non divisé
+        expect(call[3]).toBe(120); // besoin_ecs_depensier non divisé
+        expect(call[11]).toBe(false);
+        expect(call[13]).toBe(true);
+      });
+      expect(warn).not.toHaveBeenCalled();
+      warn.mockRestore();
+    });
+
+    test.each([
+      ['une surface d’installation nulle', [0, 155], 200],
+      ['une surface d’installation absente', [undefined, 155], 200],
+      ['la surface de l’immeuble nulle', [20, 155], 0]
+    ])('%s : repli sur la division par deux avec avertissement', (_, surfaces, sh) => {
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      calcul_3cl(makeImmeubleMultiEcs(surfaces, sh), { sanitize: false });
+
+      expect(calc_ecs.mock.calls[0][2]).toBe(50);
+      expect(calc_ecs.mock.calls[0][3]).toBe(60);
+      expect(calc_ecs.mock.calls[0][13]).toBe(false);
+      expect(warn).toHaveBeenCalledWith(expect.stringContaining('Repli sur la division'));
+      warn.mockRestore();
+    });
+
+    test('appartement avec deux installations renseignées : division par deux inchangée', () => {
+      const dpe = makeImmeubleMultiEcs([40, 40]);
+      enums.methode_application_dpe_log = { 1: 'dpe appartement individuel' };
+
+      calcul_3cl(dpe, { sanitize: false });
+
+      expect(calc_ecs.mock.calls[0][2]).toBe(50);
+      expect(calc_ecs.mock.calls[0][13]).toBe(false);
+    });
+
+    test('immeuble dont toutes les installations sont individuelles : branche existante inchangée', () => {
+      const dpe = makeImmeubleMultiEcs([100, 100]);
+      dpe.logement.installation_ecs_collection.installation_ecs.forEach(
+        (e) => (e.donnee_entree.enum_type_installation_id = '1')
+      );
+
+      calcul_3cl(dpe, { sanitize: false });
+
+      expect(calc_ecs.mock.calls[0][2]).toBe(100);
+      expect(calc_ecs.mock.calls[0][11]).toBe(true);
+      expect(calc_ecs.mock.calls[0][13]).toBe(false);
+    });
   });
 
   test('maison avec deux systèmes ECS => besoin divisé par deux', () => {

package/package.json

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