@open3cl/engine 1.8.16 → 1.8.18

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

@@ -41,7 +41,13 @@ export function conso_aux_gen(di, de, type, besoin, besoin_dep, Sh) {
     pe = 70000;
   }
 
-  const Paux_g_ch = g + (h * (pe / 1000)) / (de.ratio_virtualisation || 1);
+  /**
+   * Installation collective virtualisée : Paux_g (W) est celle du générateur de l'immeuble
+   * (Pn = pe, puissance immeuble) et Caux_g = Paux_g × Bch_logement / Pn. Le terme G ne doit pas
+   * être proratisé par ratio_virtualisation (sinon G × ratio), comme le moteur CSTB (Tribu).
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §15.1
+   */
+  const Paux_g_ch = g + h * (pe / 1000);
 
   // Pour les installations collectives, la conso des auxiliaires est calculée à partir du besoin de l'appartement
   let besoinAppart = besoin * (de[`cle_repartition_${type}`] || 1);
@@ -55,10 +61,9 @@ export function conso_aux_gen(di, de, type, besoin, besoin_dep, Sh) {
     ratio = Sc / Sh;
   }
 
-  di[`conso_auxiliaire_generation_${type}`] =
-    ((de.ratio_virtualisation || 1) * (Paux_g_ch * besoinAppart * ratio)) / pe || 0;
+  di[`conso_auxiliaire_generation_${type}`] = (Paux_g_ch * besoinAppart * ratio) / pe || 0;
   di[`conso_auxiliaire_generation_${type}_depensier`] =
-    (Paux_g_ch * besoinAppartDep * ratio) / di.pn || 0;
+    (Paux_g_ch * besoinAppartDep * ratio) / (di.pn / (de.ratio_virtualisation || 1)) || 0;
 }
 
 /**

package/15_conso_aux.spec.js

@@ -131,6 +131,49 @@ describe('conso_aux_gen - auxiliaires de génération', () => {
     expect(diInconnu.conso_auxiliaire_generation_autre).toBe(0);
     expect(diInconnu.conso_auxiliaire_generation_autre_depensier).toBe(0);
   });
+
+  /**
+   * Installation collective virtualisée (appartement) : di.pn est la puissance ramenée au logement,
+   * pe = di.pn / ratio_virtualisation la puissance du générateur de l'immeuble.
+   * Caux_g = (G + H × Pn_immeuble) × Bch_logement / Pn_immeuble : G n'est pas proratisé.
+   * Cas des autotests CSTB APP5-0-1 (chaudière fioul collective, Tribu Qaux_ch = 15,9928 kWh).
+   */
+  test('installation virtualisée : Paux_g calculée sur le générateur immeuble, G non proratisé', () => {
+    const diVirt = { pn: 35000 };
+    conso_aux_gen(
+      diVirt,
+      { enum_type_generateur_ch_id: '78', ratio_virtualisation: 0.1 },
+      'ch',
+      1000,
+      1200,
+      100
+    );
+    // pe = 350 kW => Paux = 20 + 1,6 × 350 = 580 W ; conso = 580 × 1000 / 350000
+    expect(diVirt.conso_auxiliaire_generation_ch).toBeCloseTo(580 / 350, 10);
+    expect(diVirt.conso_auxiliaire_generation_ch_depensier).toBeCloseTo((580 * 1.2) / 350, 10);
+  });
+
+  test('installation virtualisée : identique au calcul non virtualisé du générateur immeuble', () => {
+    const diVirt = { pn: 2000 };
+    const diImmeuble = { pn: 20000 };
+    conso_aux_gen(
+      diVirt,
+      { enum_type_generateur_ecs_id: '50', ratio_virtualisation: 0.1 },
+      'ecs',
+      800,
+      1000,
+      100
+    );
+    conso_aux_gen(diImmeuble, { enum_type_generateur_ecs_id: '50' }, 'ecs', 800, 1000, 100);
+    expect(diVirt.conso_auxiliaire_generation_ecs).toBeCloseTo(
+      diImmeuble.conso_auxiliaire_generation_ecs,
+      10
+    );
+    expect(diVirt.conso_auxiliaire_generation_ecs_depensier).toBeCloseTo(
+      diImmeuble.conso_auxiliaire_generation_ecs_depensier,
+      10
+    );
+  });
 });
 
 /**

package/README.md

@@ -370,22 +370,22 @@ 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.17`** · branche `main` · généré le 2026-10-02
 > 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 389</strong><br/><sub>DPE conformes</sub></td>
+<td align="center"><strong>67,11 %</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 |
@@ -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,88 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>4,24 ms</strong><br/><sub>médiane</sub></td>
+<td align="center"><strong>0,12 ms</strong><br/><sub>min</sub></td>
+<td align="center"><strong>799,7 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**                                | 3,87 ms | 3,49 ms | 0,20 ms |  31,7 ms | 6,99 ms | 9,56 ms |
+| **Appartement · chauffage individuel (2025)**  | 3,54 ms | 3,23 ms | 1,45 ms |  29,3 ms | 6,14 ms | 7,86 ms |
+| **Logement individuel (2025)**                 | 4,86 ms | 4,32 ms | 1,52 ms |  35,5 ms | 9,06 ms | 12,6 ms |
+| **Maison individuelle (2025)**                 | 5,70 ms | 5,06 ms | 1,82 ms |  54,9 ms | 10,4 ms | 14,0 ms |
+| **Immeuble · chauffage individuel**            | 6,10 ms | 5,17 ms | 0,17 ms |  73,6 ms | 12,3 ms | 20,2 ms |
+| **Appartement · chauffage collectif (2025)**   | 3,87 ms | 3,50 ms | 1,46 ms |  35,8 ms | 6,37 ms | 8,52 ms |
+| **Immeuble · chauffage collectif**             | 5,29 ms | 4,44 ms | 0,12 ms |  89,5 ms | 9,69 ms | 17,0 ms |
+| **Immeuble · chauffage mixte**                 | 5,20 ms | 4,26 ms | 0,19 ms | 799,7 ms | 10,6 ms | 17,6 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 5,53 ms | 4,72 ms | 1,58 ms |  45,9 ms | 10,6 ms | 15,8 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.16';
+const LIB_VERSION = '1.8.18';
 
 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.16",
+  "version": "1.8.18",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {