@open3cl/engine 1.8.57 → 1.8.59

package/11_rdim_ecs_individuelle_unique.js

@@ -0,0 +1,62 @@
+/**
+ * DPE immeuble avec une installation ECS individuelle unique décrite pour un logement type.
+ *
+ * Certains logiciels (3.0.x, 2.0.x, 1.1.x) exportent l'installation ECS individuelle unique d'un
+ * immeuble avec `surface_habitable` = SH / N et `nombre_logement` = N, sans `rdim`. Le calcul de
+ * référence (Tribu) a été fait avec Rdim = N : le besoin est ramené à un logement
+ * (Becs = Becs_immeuble × Sh × Rdim / SH / Rdim = Becs_immeuble / N), les pertes de stockage sont
+ * celles d'un seul ballon (Vs non multiplié), puis la consommation est multipliée par Rdim.
+ *
+ * Sans rdim, Open3CL impute le besoin de tout l'immeuble à un seul ballon : conso_ecs −25 à −30 %.
+ * On reconstitue donc rdim = N, ce qui réutilise la chaîne existante (11_ecs.js : besoin / rdim,
+ * conso.js : conso × rdim).
+ *
+ * LICIEL (nombre_logement = 1, Rdim non exporté) n'est pas concerné.
+ *
+ * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - § 11.6, § 11.6.2 (p. 74-75) et § 17.2.2.3
+ * @see Tribu : Calcul_batiment.cs l. 583-588 (Ratio = Sh·Rdim/SH), l. 602-604 (Vs non multiplié),
+ * l. 1654-1664 et l. 1052 (Cecs / Rdim puis × Rdim)
+ * @see https://github.com/Open3CL/engine/issues/288
+ */
+
+/** Tolérance relative sur Sh_ecs × N ≈ SH */
+export const TOLERANCE_SURFACE_LOGEMENT_TYPE = 0.05;
+
+/**
+ * Rdim implicite de l'installation ECS individuelle unique d'un immeuble, ou null si non concernée.
+ *
+ * @param th {string} type de bâtiment (maison, appartement, immeuble)
+ * @param instal_ecs {Array} installation_ecs
+ * @param surfaceHabitableImmeuble {number|string} surface habitable de l'immeuble (SH)
+ * @return {number|null}
+ */
+export function rdimImpliciteEcsIndividuelleUnique(th, instal_ecs, surfaceHabitableImmeuble) {
+  if (th !== 'immeuble' || !Array.isArray(instal_ecs) || instal_ecs.length !== 1) return null;
+
+  const de = instal_ecs[0].donnee_entree;
+  if (!de || String(de.enum_type_installation_id) !== '1' || de.rdim) return null;
+
+  const N = Number(de.nombre_logement);
+  const SH = Number(surfaceHabitableImmeuble);
+  const sh = Number(de.surface_habitable);
+  if (!(N > 1) || !(SH > 0) || !(sh > 0)) return null;
+
+  return Math.abs(sh * N - SH) <= TOLERANCE_SURFACE_LOGEMENT_TYPE * SH ? N : null;
+}
+
+/**
+ * Reconstitue le rdim de l'installation ECS individuelle unique d'un immeuble décrite pour un
+ * logement type. L'installation reçoit `rdim` = nombre_logement et le flag `rdim_reconstitue`.
+ *
+ * @param th {string} type de bâtiment
+ * @param instal_ecs {Array} installation_ecs
+ * @param surfaceHabitableImmeuble {number|string} surface habitable de l'immeuble (SH)
+ * @return {boolean} true si le rdim a été reconstitué
+ */
+export function reconstituerRdimEcsIndividuelleUnique(th, instal_ecs, surfaceHabitableImmeuble) {
+  const rdim = rdimImpliciteEcsIndividuelleUnique(th, instal_ecs, surfaceHabitableImmeuble);
+  if (rdim === null) return false;
+  instal_ecs[0].donnee_entree.rdim = rdim;
+  instal_ecs[0].donnee_entree.rdim_reconstitue = true;
+  return true;
+}

package/11_rdim_ecs_individuelle_unique.spec.js

@@ -0,0 +1,113 @@
+import { describe, expect, test } from 'vitest';
+import {
+  rdimImpliciteEcsIndividuelleUnique,
+  reconstituerRdimEcsIndividuelleUnique,
+  TOLERANCE_SURFACE_LOGEMENT_TYPE
+} from './11_rdim_ecs_individuelle_unique.js';
+
+/**
+ * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - § 11.6, § 11.6.2 et § 17.2.2.3
+ * @see Tribu : Calcul_batiment.cs l. 583-588, l. 602-604, l. 1654-1664
+ * @see https://github.com/Open3CL/engine/issues/288
+ */
+describe("Rdim de l'installation ECS individuelle unique d'un immeuble", () => {
+  /** Installation ECS décrite pour un logement type : Sh = SH / N, nombre_logement = N */
+  const ecs = (de) => [
+    {
+      donnee_entree: {
+        enum_type_installation_id: '1',
+        surface_habitable: 64,
+        nombre_logement: 10,
+        ...de
+      }
+    }
+  ];
+
+  describe('rdimImpliciteEcsIndividuelleUnique', () => {
+    test('installation individuelle unique, Sh × N = SH, sans rdim : rdim = nombre_logement', () => {
+      // Cas type 2244E3131012H : N = 10
+      expect(rdimImpliciteEcsIndividuelleUnique('immeuble', ecs(), 640)).toBe(10);
+      expect(
+        rdimImpliciteEcsIndividuelleUnique(
+          'immeuble',
+          ecs({ enum_type_installation_id: 1, surface_habitable: '64', nombre_logement: '10' }),
+          '640'
+        )
+      ).toBe(10);
+    });
+
+    test('tolérance de 5 % sur Sh × N ≈ SH', () => {
+      expect(TOLERANCE_SURFACE_LOGEMENT_TYPE).toBe(0.05);
+      // |640 − SH| ≤ 0,05 × SH ⇔ 609,52 ≤ SH ≤ 673,68
+      expect(rdimImpliciteEcsIndividuelleUnique('immeuble', ecs(), 673)).toBe(10);
+      expect(rdimImpliciteEcsIndividuelleUnique('immeuble', ecs(), 610)).toBe(10);
+      expect(rdimImpliciteEcsIndividuelleUnique('immeuble', ecs(), 674)).toBeNull();
+      expect(rdimImpliciteEcsIndividuelleUnique('immeuble', ecs(), 609)).toBeNull();
+    });
+
+    test('installation décrite sur la surface de l’immeuble (Sh = SH) : non concernée', () => {
+      expect(
+        rdimImpliciteEcsIndividuelleUnique('immeuble', ecs({ surface_habitable: 640 }), 640)
+      ).toBeNull();
+    });
+
+    test('LICIEL : nombre_logement = 1 → non concerné', () => {
+      expect(
+        rdimImpliciteEcsIndividuelleUnique(
+          'immeuble',
+          ecs({ nombre_logement: 1, surface_habitable: 640 }),
+          640
+        )
+      ).toBeNull();
+    });
+
+    test('rdim exporté : on conserve la saisie', () => {
+      expect(rdimImpliciteEcsIndividuelleUnique('immeuble', ecs({ rdim: 4 }), 640)).toBeNull();
+      expect(rdimImpliciteEcsIndividuelleUnique('immeuble', ecs({ rdim: 1 }), 640)).toBeNull();
+    });
+
+    test('installation collective : non concernée', () => {
+      expect(
+        rdimImpliciteEcsIndividuelleUnique('immeuble', ecs({ enum_type_installation_id: '2' }), 640)
+      ).toBeNull();
+    });
+
+    test('maison ou appartement : non concerné', () => {
+      expect(rdimImpliciteEcsIndividuelleUnique('maison', ecs(), 640)).toBeNull();
+      expect(rdimImpliciteEcsIndividuelleUnique('appartement', ecs(), 640)).toBeNull();
+    });
+
+    test('plusieurs installations ECS : non concerné (#232)', () => {
+      expect(rdimImpliciteEcsIndividuelleUnique('immeuble', [...ecs(), ...ecs()], 640)).toBeNull();
+    });
+
+    test('données manquantes : non concerné', () => {
+      expect(rdimImpliciteEcsIndividuelleUnique('immeuble', undefined, 640)).toBeNull();
+      expect(rdimImpliciteEcsIndividuelleUnique('immeuble', [], 640)).toBeNull();
+      expect(rdimImpliciteEcsIndividuelleUnique('immeuble', [{}], 640)).toBeNull();
+      expect(rdimImpliciteEcsIndividuelleUnique('immeuble', ecs(), undefined)).toBeNull();
+      expect(rdimImpliciteEcsIndividuelleUnique('immeuble', ecs(), 0)).toBeNull();
+      expect(
+        rdimImpliciteEcsIndividuelleUnique('immeuble', ecs({ surface_habitable: undefined }), 640)
+      ).toBeNull();
+      expect(
+        rdimImpliciteEcsIndividuelleUnique('immeuble', ecs({ nombre_logement: undefined }), 640)
+      ).toBeNull();
+    });
+  });
+
+  describe('reconstituerRdimEcsIndividuelleUnique', () => {
+    test('installation concernée : rdim et flag positionnés', () => {
+      const inst = ecs();
+      expect(reconstituerRdimEcsIndividuelleUnique('immeuble', inst, 640)).toBe(true);
+      expect(inst[0].donnee_entree).toMatchObject({ rdim: 10, rdim_reconstitue: true });
+    });
+
+    test('installation non concernée : inchangée', () => {
+      const inst = ecs({ nombre_logement: 1 });
+      expect(reconstituerRdimEcsIndividuelleUnique('immeuble', inst, 640)).toBe(false);
+      expect(inst[0].donnee_entree.rdim).toBeUndefined();
+      expect(inst[0].donnee_entree.rdim_reconstitue).toBeUndefined();
+    });
+  });
+});

package/17.2_rdim_dpe_genere_immeuble.js

@@ -0,0 +1,73 @@
+/**
+ * DPE appartement généré à partir d'un DPE immeuble (méthodes 10 à 13, 33-34, 38-40).
+ *
+ * Certains logiciels (LICIEL / BBS_Slama) exportent une installation individuelle décrite sur la
+ * surface de l'immeuble entier (Sh_i ≈ SH immeuble) avec un `rdim` égal à 1, alors que le calcul
+ * (Tribu) a été fait avec un Rdim implicite égal au nombre de logements desservis. La consommation
+ * sortie ADEME vaut alors : clé × Σ C_i × (na × Sh_i / SH).
+ *
+ * En mode `bug_for_bug_compat`, on reconstitue ce rdim (`rdim = na × Sh_i / SH`), on calcule
+ * l'installation à l'échelle de l'immeuble, puis on applique la clé de répartition exportée :
+ *  - chauffage individuel, gestion homogène : coef_IFC = 1 → Cch_ap = Clé_ap × Cch (et Caux_ch) ;
+ *  - ECS : Cecs_ap = Cecs × Becs_ap / Becs (chaîne existante cle_ecs × rdim).
+ *
+ * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - § 17.2.2.2.2 (p. 115) et § 17.2.2.3.1 (p. 116)
+ * @see Tribu : Calcul_installation.cs l. 62 (Rdim lu en entrée), Calcul_batiment.cs l. 836-958
+ * (conso = Cch1 × Rdim) et l. 1560 (Cdimref = Pn × Rdim)
+ * @see https://github.com/Open3CL/engine/issues/287
+ */
+
+/** Ratio na × Sh_i / SH au-delà duquel l'installation est considérée comme « immeuble » */
+export const SEUIL_RDIM_IMPLICITE = 1.5;
+
+/**
+ * Rdim implicite d'une installation individuelle exportée avec rdim = 1, ou null si l'installation
+ * n'est pas concernée.
+ *
+ * @param de {object} donnee_entree de l'installation (chauffage ou ECS)
+ * @param surface {number|string} surface desservie par l'installation (Sh_i)
+ * @param nombreAppartement {number|string} nombre de logements de l'immeuble (na)
+ * @param surfaceHabitableImmeuble {number|string} surface habitable de l'immeuble (SH)
+ * @return {number|null}
+ */
+export function rdimImplicite(de, surface, nombreAppartement, surfaceHabitableImmeuble) {
+  if (!de || de.enum_type_installation_id !== '1') return null;
+  if ((Number(de.rdim) || 1) !== 1) return null;
+
+  const na = Number(nombreAppartement);
+  const SH = Number(surfaceHabitableImmeuble);
+  const Shi = Number(surface);
+  if (!(na > 1) || !(SH > 0) || !(Shi > 0)) return null;
+
+  const rdim = (na * Shi) / SH;
+  return rdim > SEUIL_RDIM_IMPLICITE ? rdim : null;
+}
+
+/**
+ * Reconstitue le rdim des installations individuelles d'un DPE appartement généré depuis un DPE
+ * immeuble. Les installations concernées reçoivent `rdim` reconstitué et le flag `rdim_reconstitue`.
+ * Chauffage et ECS sont traités indépendamment.
+ *
+ * @param cg {object} caracteristique_generale
+ * @param instal_ch {Array} installation_chauffage
+ * @param instal_ecs {Array} installation_ecs
+ * @return {{ch: boolean, ecs: boolean}} installations reconstituées
+ */
+export function reconstituerRdimDpeGenereImmeuble(cg, instal_ch, instal_ecs) {
+  const na = cg?.nombre_appartement;
+  const SH = cg?.surface_habitable_immeuble;
+
+  const appliquer = (installations, champSurface) =>
+    (installations || []).reduce((found, inst) => {
+      const de = inst.donnee_entree;
+      const rdim = rdimImplicite(de, de?.[champSurface], na, SH);
+      if (rdim === null) return found;
+      de.rdim = rdim;
+      de.rdim_reconstitue = true;
+      return true;
+    }, false);
+
+  const ch = appliquer(instal_ch, 'surface_chauffee');
+  const ecs = appliquer(instal_ecs, 'surface_habitable');
+  return { ch, ecs };
+}

package/17.2_rdim_dpe_genere_immeuble.spec.js

@@ -0,0 +1,100 @@
+import { describe, expect, test } from 'vitest';
+import {
+  rdimImplicite,
+  reconstituerRdimDpeGenereImmeuble,
+  SEUIL_RDIM_IMPLICITE
+} from './17.2_rdim_dpe_genere_immeuble.js';
+
+/**
+ * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - § 17.2.2.2.2 et § 17.2.2.3.1
+ * @see https://github.com/Open3CL/engine/issues/287
+ */
+describe('Reconstitution du rdim des DPE appartement générés depuis un DPE immeuble', () => {
+  describe('rdimImplicite', () => {
+    test('installation individuelle décrite sur la surface de l’immeuble : rdim = na × Sh_i / SH', () => {
+      // Cas 2694E0022738J : na = 62, Sh_i = SH = 4 094 m² → rdim = 62
+      expect(rdimImplicite({ enum_type_installation_id: '1', rdim: 1 }, 4094, 62, 4094)).toBe(62);
+      expect(rdimImplicite({ enum_type_installation_id: '1' }, 2047, '62', '4094')).toBe(31);
+    });
+
+    test('installation collective : non concernée', () => {
+      expect(rdimImplicite({ enum_type_installation_id: '2', rdim: 1 }, 4094, 62, 4094)).toBeNull();
+    });
+
+    test('rdim exporté différent de 1 : on conserve la saisie', () => {
+      expect(rdimImplicite({ enum_type_installation_id: '1', rdim: 4 }, 4094, 62, 4094)).toBeNull();
+    });
+
+    test('ratio na × Sh_i / SH inférieur ou égal au seuil : installation d’un seul logement', () => {
+      expect(SEUIL_RDIM_IMPLICITE).toBe(1.5);
+      // 10 × 60 / 600 = 1 → logement seul
+      expect(rdimImplicite({ enum_type_installation_id: '1' }, 60, 10, 600)).toBeNull();
+      // 10 × 90 / 600 = 1,5 → seuil non dépassé
+      expect(rdimImplicite({ enum_type_installation_id: '1' }, 90, 10, 600)).toBeNull();
+      // 10 × 91 / 600 > 1,5
+      expect(rdimImplicite({ enum_type_installation_id: '1' }, 91, 10, 600)).toBeCloseTo(
+        1.516666667,
+        9
+      );
+    });
+
+    test('données manquantes ou un seul logement : non concerné', () => {
+      const de = { enum_type_installation_id: '1' };
+      expect(rdimImplicite(undefined, 100, 10, 100)).toBeNull();
+      expect(rdimImplicite(de, 100, 1, 100)).toBeNull();
+      expect(rdimImplicite(de, 100, undefined, 100)).toBeNull();
+      expect(rdimImplicite(de, 100, 10, 0)).toBeNull();
+      expect(rdimImplicite(de, undefined, 10, 100)).toBeNull();
+    });
+  });
+
+  describe('reconstituerRdimDpeGenereImmeuble', () => {
+    const cg = { nombre_appartement: 62, surface_habitable_immeuble: 4094 };
+    const ch = (surface, type = '1') => ({
+      donnee_entree: { enum_type_installation_id: type, rdim: 1, surface_chauffee: surface }
+    });
+    const ecs = (surface, type = '1') => ({
+      donnee_entree: { enum_type_installation_id: type, rdim: 1, surface_habitable: surface }
+    });
+
+    test('chauffage et ECS décrits à l’échelle de l’immeuble : rdim reconstitué sur les deux', () => {
+      const instCh = [ch(4094)];
+      const instEcs = [ecs(4094)];
+      expect(reconstituerRdimDpeGenereImmeuble(cg, instCh, instEcs)).toEqual({
+        ch: true,
+        ecs: true
+      });
+      expect(instCh[0].donnee_entree).toMatchObject({ rdim: 62, rdim_reconstitue: true });
+      expect(instEcs[0].donnee_entree).toMatchObject({ rdim: 62, rdim_reconstitue: true });
+    });
+
+    test('ECS seule à l’échelle de l’immeuble : rdim reconstitué sur l’ECS uniquement', () => {
+      const instCh = [ch(63.8)];
+      const instEcs = [ecs(4094)];
+      expect(reconstituerRdimDpeGenereImmeuble(cg, instCh, instEcs)).toEqual({
+        ch: false,
+        ecs: true
+      });
+      expect(instCh[0].donnee_entree.rdim_reconstitue).toBeUndefined();
+      expect(instEcs[0].donnee_entree).toMatchObject({ rdim: 62, rdim_reconstitue: true });
+    });
+
+    test('seules les installations concernées sont modifiées', () => {
+      const instCh = [ch(4094), ch(4094, '2'), ch(63.8)];
+      expect(reconstituerRdimDpeGenereImmeuble(cg, instCh, undefined)).toEqual({
+        ch: true,
+        ecs: false
+      });
+      expect(instCh[0].donnee_entree.rdim_reconstitue).toBe(true);
+      expect(instCh[1].donnee_entree.rdim_reconstitue).toBeUndefined();
+      expect(instCh[2].donnee_entree.rdim_reconstitue).toBeUndefined();
+    });
+
+    test('collections absentes', () => {
+      expect(reconstituerRdimDpeGenereImmeuble(undefined, undefined, undefined)).toEqual({
+        ch: false,
+        ecs: false
+      });
+    });
+  });
+});

package/9_chauffage.js

@@ -71,7 +71,9 @@ export default function calc_chauffage(
     genChDe.cle_repartition_ch = de.cle_repartition_ch || 1;
     genChDe.enum_type_installation_id = de.enum_type_installation_id;
     genChDe.surface_chauffee = de.surface_chauffee || Sh;
-    genChDe.rdim_installation_ch = isImmeuble(map_id) ? Number(de.rdim) || 1 : 1;
+    genChDe.rdim_installation_ch =
+      isImmeuble(map_id) || de.rdim_reconstitue ? Number(de.rdim) || 1 : 1;
+    genChDe.rdim_reconstitue = de.rdim_reconstitue;
     genChDe.nombre_niveau_installation_ch = de.nombre_niveau_installation_ch || 1;
     genChDe.fch = Fch || 0.5;
 

package/9_chauffage.spec.js

@@ -278,6 +278,15 @@ describe('calc_chauffage - rdim de l’installation transmis au générateur', (
     appel(ch, { map_id: 2 });
     expect(rdimGen(ch)).toBe(1);
   });
+
+  test('DPE appartement issu d’un DPE immeuble avec rdim reconstitué (issue #287) : rdim repris', () => {
+    const ch = installation([generateur()], [emetteur('1')], { rdim: 62, rdim_reconstitue: true });
+    appel(ch, { map_id: 10 });
+    expect(rdimGen(ch)).toBe(62);
+    expect(
+      ch.generateur_chauffage_collection.generateur_chauffage[0].donnee_entree.rdim_reconstitue
+    ).toBe(true);
+  });
 });
 
 describe('isImmeuble', () => {

package/README.md

@@ -23,7 +23,7 @@ Implémentation open source du moteur Open3CL de l'ADEME.
     ·
     <a href="https://github.com/Open3CL/engine/issues/new?labels=enhancement&template=feature-request---.md">Créer une feature</a>
     &middot;
-    <a href="https://open3cl.github.io/engine/reports/corpus">Rapports de corpus</a>
+    <a href="https://open3cl.github.io/engine/">🏠 Démo 3D en ligne</a>
   </p>
 </div>
 
@@ -33,6 +33,21 @@ Implémentation open source du moteur Open3CL de l'ADEME.
 
 </div>
 
+<br />
+
+<div align="center">
+
+### 🏠 Voir un DPE en 3D
+
+**[➡️ Ouvrir la démo 3D en ligne](https://open3cl.github.io/engine/)**
+
+Chargez le DPE d'un logement : Open3CL le recalcule dans le navigateur et en reconstruit la maquette 3D.
+Chaque paroi, fenêtre et équipement s'affiche avec ses déperditions — consultables et modifiables en direct.
+
+[open3cl_3D_demo_resized.webm](https://github.com/user-attachments/assets/534a7f78-a493-41b7-9f73-128076349d84)
+
+</div>
+
 <details>
   <summary>📚 Sommaire</summary>
   <ol>
@@ -92,7 +107,7 @@ consommations, émissions de gaz à effet de serre, coûts et étiquettes.
 | 🔍 **Vérifiable**       | ~90 000 DPE réels rejoués à chaque version, résultats publiés (voir [Résultats corpus](#résultats-corpus)) |
 | 🧩 **Sans dépendance**  | Pure JavaScript (ESM), aucun service externe, fonctionne en Node.js comme dans un navigateur               |
 | 📦 **Prête à intégrer** | Entrée XML ADEME ou objet JSON, sortie JSON complète                                                       |
-| 🆓 **Libre**            | Licence GPL-3.0, développée au grand jour                                                                  |
+| 🆓 **Libre**            | Licence MIT, développée au grand jour                                                                      |
 
 ### Ce que fait le moteur
 
@@ -139,11 +154,11 @@ flowchart LR
 
 ### L'écosystème Open3CL
 
-| Ressource                                                             | Description                                               |
-| :-------------------------------------------------------------------- | :-------------------------------------------------------- |
-| [open3cl.fr](https://open3cl.fr)                                      | Le site du projet                                         |
-| [Rapports de corpus](https://open3cl.github.io/engine/reports/corpus) | Le tableau de bord interactif des résultats sur DPE réels |
-| [@open3cl/engine](https://www.npmjs.com/package/@open3cl/engine)      | Le paquet npm                                             |
+| Ressource                                                        | Description                                                                |
+| :--------------------------------------------------------------- | :------------------------------------------------------------------------- |
+| [Démo 3D](https://open3cl.github.io/engine/)                     | Visualisation 3D des déperditions d'un DPE, recalculées dans le navigateur |
+| [open3cl.fr](https://open3cl.fr)                                 | Le site du projet                                                          |
+| [@open3cl/engine](https://www.npmjs.com/package/@open3cl/engine) | Le paquet npm                                                              |
 
 <p align="right">(<a href="#readme-top">Retour sommaire</a>)</p>
 
@@ -318,24 +333,14 @@ d'environnement, quotas de l'API ADEME, structure des rapports.
 ### Le rapport interactif
 
 Chaque exécution produit un tableau de bord HTML : jauge de réussite, ratio par contrôle, liste des DPE au-dessus du
-seuil avec le **détail des propriétés en écart**, et comparaison entre deux branches.
+seuil avec le **détail des propriétés en écart**, et comparaison entre deux branches. Il est écrit dans
+`dist/reports/corpus` et se consulte en local :
 
-<div align="center">
-  <a href="https://open3cl.github.io/engine/reports/corpus">
-    <img src="images/corpus-report.png" alt="Rapport de corpus Open3CL" width="900">
-  </a>
-  <br/>
-  <sub>👉 <a href="https://open3cl.github.io/engine/reports/corpus"><strong>Ouvrir le rapport interactif</strong></a></sub>
-</div>
+```sh
+npm run reports:preview   # sert dist/reports/corpus et ouvre le navigateur
+```
 
-> [!NOTE]
-> GitHub neutralise les scripts et les `iframe` dans les fichiers markdown : le rapport ne peut donc pas être
-> **intégré**
-> tel quel dans ce README. Il est affiché ici sous forme d'aperçu cliquable, et reste consultable en ligne ou en local :
->
-> ```sh
-> npm run reports:preview   # sert dist/reports/corpus et ouvre le navigateur
-> ```
+Les chiffres de la dernière exécution sont repris ci-dessous, dans [Résultats corpus](#résultats-corpus).
 
 ### Lancer un corpus
 
@@ -370,21 +375,21 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <!-- CORPUS:START -->
 
-> **Version `1.8.56`** · branche `main` · généré le 2026-10-13
+> **Version `1.8.58`** · branche `main` · généré le 2026-10-14
 > Seuil de tolérance **5%**
 
 <table>
 <tr>
 <td align="center"><strong>9</strong><br/><sub>corpus</sub></td>
 <td align="center"><strong>89 418</strong><br/><sub>DPE analysés</sub></td>
-<td align="center"><strong>66 706</strong><br/><sub>DPE conformes</sub></td>
-<td align="center"><strong>74,60 %</strong><br/><sub>réussite globale</sub></td>
+<td align="center"><strong>69 329</strong><br/><sub>DPE conformes</sub></td>
+<td align="center"><strong>77,53 %</strong><br/><sub>réussite globale</sub></td>
 </tr>
 </table>
 
 |     | Corpus                                                                                                                  |    Réussite |                        |  DPE conformes |
 | :-: | :---------------------------------------------------------------------------------------------------------------------- | ----------: | :--------------------- | -------------: |
-| 🔴  | **Généraliste**<br/><sub>`corpus_dpe.csv`</sub>                                                                         | **47,08 %** | `█████████░░░░░░░░░░░` |  4 708 / 9 999 |
+| 🔴  | **Généraliste**<br/><sub>`corpus_dpe.csv`</sub>                                                                         | **47,67 %** | `██████████░░░░░░░░░░` |  4 767 / 9 999 |
 | 🟢  | **Appartement · chauffage individuel (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_individuel_2025.csv`</sub> | **92,90 %** | `███████████████████░` | 9 290 / 10 000 |
 | 🟢  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **91,72 %** | `██████████████████░░` | 9 172 / 10 000 |
 | 🟢  | **Logement individuel (2025)**<br/><sub>`dpe_logement_individuel_2025.csv`</sub>                                        | **90,47 %** | `██████████████████░░` |  9 040 / 9 992 |
@@ -392,7 +397,7 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 | 🟢  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **85,04 %** | `█████████████████░░░` |  8 346 / 9 814 |
 | 🟡  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **84,58 %** | `█████████████████░░░` |  8 456 / 9 998 |
 | 🔴  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **59,86 %** | `████████████░░░░░░░░` |  5 756 / 9 616 |
-| 🔴  | **Individuel généré depuis l'immeuble (2026)**<br/><sub>`dpe_individuel_a_partir_dpe_immeuble_2026.csv`</sub>           | **30,49 %** | `██████░░░░░░░░░░░░░░` | 3 049 / 10 000 |
+| 🔴  | **Individuel généré depuis l'immeuble (2026)**<br/><sub>`dpe_individuel_a_partir_dpe_immeuble_2026.csv`</sub>           | **56,13 %** | `███████████░░░░░░░░░` | 5 613 / 10 000 |
 
 <sub>🟢 ≥ 85 % · 🟡 ≥ 60 % · 🔴 < 60 %</sub>
 
@@ -403,24 +408,24 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <table>
 <tr>
-<td align="center"><strong>5,09 ms</strong><br/><sub>moyenne</sub></td>
-<td align="center"><strong>4,44 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>854,0 ms</strong><br/><sub>max</sub></td>
+<td align="center"><strong>5,46 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>4,80 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>655,4 ms</strong><br/><sub>max</sub></td>
 </tr>
 </table>
 
 | Corpus                                         | Moyenne | Médiane |     Min |      Max |     p95 |     p99 |
 | :--------------------------------------------- | ------: | ------: | ------: | -------: | ------: | ------: |
-| **Généraliste**                                | 5,11 ms | 4,71 ms | 0,20 ms |  34,6 ms | 9,00 ms | 12,2 ms |
-| **Appartement · chauffage individuel (2025)**  | 3,79 ms | 3,44 ms | 1,48 ms |  33,9 ms | 6,57 ms | 8,40 ms |
-| **Appartement · chauffage collectif (2025)**   | 4,45 ms | 4,04 ms | 1,63 ms |  39,4 ms | 7,29 ms | 9,55 ms |
-| **Logement individuel (2025)**                 | 4,68 ms | 4,12 ms | 1,66 ms |  46,7 ms | 8,62 ms | 12,6 ms |
-| **Maison individuelle (2025)**                 | 5,24 ms | 4,81 ms | 1,94 ms |  50,8 ms | 8,85 ms | 11,8 ms |
-| **Immeuble · chauffage collectif**             | 4,99 ms | 4,28 ms | 0,12 ms |  99,4 ms | 8,96 ms | 14,0 ms |
-| **Immeuble · chauffage individuel**            | 5,73 ms | 4,88 ms | 0,12 ms |  98,8 ms | 11,1 ms | 18,4 ms |
-| **Immeuble · chauffage mixte**                 | 4,87 ms | 3,97 ms | 0,18 ms | 854,0 ms | 9,80 ms | 16,0 ms |
-| **Individuel généré depuis l'immeuble (2026)** | 6,94 ms | 5,65 ms | 1,82 ms |  88,8 ms | 15,2 ms | 25,7 ms |
+| **Généraliste**                                | 4,56 ms | 4,11 ms | 0,22 ms |  28,4 ms | 8,39 ms | 11,5 ms |
+| **Appartement · chauffage individuel (2025)**  | 4,13 ms | 3,83 ms | 1,53 ms |  33,1 ms | 6,90 ms | 8,83 ms |
+| **Appartement · chauffage collectif (2025)**   | 4,69 ms | 4,36 ms | 1,65 ms |  38,2 ms | 7,69 ms | 10,3 ms |
+| **Logement individuel (2025)**                 | 5,25 ms | 4,70 ms | 1,64 ms |  43,6 ms | 9,63 ms | 12,9 ms |
+| **Maison individuelle (2025)**                 | 6,17 ms | 5,56 ms | 1,99 ms |  53,3 ms | 11,0 ms | 14,5 ms |
+| **Immeuble · chauffage collectif**             | 5,61 ms | 4,85 ms | 0,21 ms | 104,4 ms | 10,3 ms | 16,3 ms |
+| **Immeuble · chauffage individuel**            | 6,70 ms | 5,71 ms | 0,11 ms | 164,2 ms | 13,6 ms | 21,3 ms |
+| **Immeuble · chauffage mixte**                 | 5,70 ms | 4,65 ms | 0,20 ms | 655,4 ms | 12,0 ms | 19,4 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 6,33 ms | 5,45 ms | 1,65 ms |  53,8 ms | 11,9 ms | 19,5 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
@@ -441,6 +446,7 @@ flowchart TD
     subgraph fait ["✅ Fait"]
         A1["Site Open3CL"]
         A2["Rapports de corpus interactifs"]
+        A3["Démo 3D en ligne"]
     end
     subgraph cours ["🚧 En cours"]
         B1["Refonte technique"]
@@ -450,13 +456,14 @@ flowchart TD
     fait --> cours
 ```
 
-| Étape               | Statut      | Détail                                                           |
-| :------------------ | :---------- | :--------------------------------------------------------------- |
-| Site Open3CL        | ✅ Terminé  | [open3cl.fr](https://open3cl.fr)                                 |
-| Rapports de tests   | ✅ Terminé  | Tableau de bord interactif publié à chaque exécution             |
-| Refonte technique   | 🚧 En cours | Découpage par article de la méthode, couverture de tests à 100 % |
-| DPE à l'immeuble    | 🚧 En cours | Fiabilisation des appartements générés depuis un DPE immeuble    |
-| Certification ADEME | 🚧 En cours | Objectif de long terme                                           |
+| Étape               | Statut      | Détail                                                                                           |
+| :------------------ | :---------- | :----------------------------------------------------------------------------------------------- |
+| Site Open3CL        | ✅ Terminé  | [open3cl.fr](https://open3cl.fr)                                                                 |
+| Démo 3D en ligne    | ✅ Terminé  | [Visualisation 3D des déperditions](https://open3cl.github.io/engine/), publiée sur GitHub Pages |
+| Rapports de tests   | ✅ Terminé  | Tableau de bord interactif généré à chaque exécution                                             |
+| Refonte technique   | 🚧 En cours | Découpage par article de la méthode, couverture de tests à 100 %                                 |
+| DPE à l'immeuble    | 🚧 En cours | Fiabilisation des appartements générés depuis un DPE immeuble                                    |
+| Certification ADEME | 🚧 En cours | Objectif de long terme                                                                           |
 
 Le détail complet des bugs et fonctionnalités en cours est dans les
 [issues](https://github.com/Open3CL/engine/issues).

package/conso.js

@@ -962,9 +962,11 @@ function getChauffageConso(gen_ch, field, coef, prorataChauffage, prefix, facteu
     const conso =
       gen_ch.donnee_intermediaire[field] * (typeEnergie === 'électricité ch' ? facteurAc : 1);
 
-    // La clé de répartition n'est utilisée que dans le cadre des chauffages collectifs
+    // La clé de répartition n'est utilisée que dans le cadre des chauffages collectifs, ou d'un
+    // chauffage individuel calculé à l'échelle de l'immeuble (rdim reconstitué, § 17.2.2.2.2)
     const repartition =
-      gen_ch.donnee_entree.enum_type_installation_id !== '1'
+      gen_ch.donnee_entree.enum_type_installation_id !== '1' ||
+      gen_ch.donnee_entree.rdim_reconstitue
         ? gen_ch.donnee_entree.cle_repartition_ch || prorataChauffage
         : prorataChauffage;
 
@@ -1014,7 +1016,10 @@ function calc_conso_pond(
   ret.auxiliaire_generation_ch = gen_ch.reduce((acc, gen_ch) => {
     const conso =
       (gen_ch.donnee_intermediaire.conso_auxiliaire_generation_ch || 0) *
-      fAc('auxiliaire_generation_ch');
+      fAc('auxiliaire_generation_ch') *
+      (gen_ch.donnee_entree.rdim_reconstitue
+        ? gen_ch.donnee_entree.cle_repartition_ch || prorataChauffage
+        : 1);
     return acc + getConso(coef, 'électricité auxiliaire', conso);
   }, 0);
 

package/conso.spec.js

@@ -393,6 +393,66 @@ describe('calc_conso - agrégation des consommations', () => {
     expect(res.ef_conso.conso_auxiliaire_distribution_ch).toBe(200);
   });
 
+  test('chauffage individuel avec rdim reconstitué (issue #287) : clé appliquée à conso et aux. génération, pas à la distribution', () => {
+    // § 17.2.2.2.2 : chauffage individuel, coef_IFC = 1 → Cch_ap = Clé_ap × Cch_immeuble
+    const ch = [
+      installCh({ cle_repartition_ch: 0.25, enum_methode_calcul_conso_id: '3' }, [
+        genCh(
+          '1',
+          {
+            conso_ch: 1000,
+            conso_ch_depensier: 1200,
+            conso_auxiliaire_generation_ch: 40,
+            conso_auxiliaire_distribution_ch: 80
+          },
+          { rdim_reconstitue: true }
+        )
+      ])
+    ];
+
+    const res = calc_conso(100, 1, 1, [], ch, [], [], 1, 1, DATE_DPE, coef_ep);
+
+    expect(res.ef_conso.conso_ch).toBe(250);
+    expect(res.ef_conso.conso_auxiliaire_generation_ch).toBe(10);
+    // Distribution non proratisée, comme dans les sorties ADEME
+    expect(res.ef_conso.conso_auxiliaire_distribution_ch).toBe(80);
+  });
+
+  test('chauffage individuel sans rdim reconstitué : clé ignorée (prorata chauffage)', () => {
+    const ch = [
+      installCh({ cle_repartition_ch: 0.25, enum_methode_calcul_conso_id: '3' }, [
+        genCh('1', {
+          conso_ch: 1000,
+          conso_ch_depensier: 1200,
+          conso_auxiliaire_generation_ch: 40
+        })
+      ])
+    ];
+
+    const res = calc_conso(100, 1, 1, [], ch, [], [], 1, 1, DATE_DPE, coef_ep);
+
+    expect(res.ef_conso.conso_ch).toBe(1000);
+    expect(res.ef_conso.conso_auxiliaire_generation_ch).toBe(40);
+  });
+
+  test('chauffage individuel avec rdim reconstitué et clé nulle : repli sur le prorata chauffage, comme la conso', () => {
+    // clé installation 0 et prorata 0 → clé générateur 0 → repli sur prorataChauffage (0)
+    const ch = [
+      installCh({ cle_repartition_ch: 0, enum_methode_calcul_conso_id: '3' }, [
+        genCh(
+          '1',
+          { conso_ch: 1000, conso_ch_depensier: 1200, conso_auxiliaire_generation_ch: 40 },
+          { rdim_reconstitue: true }
+        )
+      ])
+    ];
+
+    const res = calc_conso(100, 1, 1, [], ch, [], [], 1, 0, DATE_DPE, coef_ep);
+
+    expect(res.ef_conso.conso_ch).toBe(0);
+    expect(res.ef_conso.conso_auxiliaire_generation_ch).toBe(0);
+  });
+
   test('installation avec clé absente (non collective) : répartition = prorata chauffage', () => {
     const ch = [
       installCh(

package/engine.js

@@ -32,8 +32,10 @@ import { Inertie } from './7_inertie.js';
 import getFicheTechnique from './ficheTechnique.js';
 import { ProductionENR, ratioProrataPvLogement } from './16.2_production_enr.js';
 import DpeSanitizerService from './dpe-sanitizer.service.js';
+import { reconstituerRdimDpeGenereImmeuble } from './17.2_rdim_dpe_genere_immeuble.js';
+import { reconstituerRdimEcsIndividuelleUnique } from './11_rdim_ecs_individuelle_unique.js';
 
-const LIB_VERSION = '1.8.57';
+const LIB_VERSION = '1.8.59';
 
 const dpeSanitizerService = new DpeSanitizerService();
 
@@ -290,7 +292,27 @@ export function calcul_3cl(inputDpe, options) {
   const ilpa = logement.meteo.batiment_materiaux_anciens === 1 ? '1' : '0';
 
   const ecs = logement.installation_ecs_collection.installation_ecs || [];
+  /**
+   * Immeuble avec une installation ECS individuelle unique décrite pour un logement type
+   * (Sh_ecs × nombre_logement ≈ SH, sans rdim) : rdim = nombre_logement.
+   * @see https://github.com/Open3CL/engine/issues/288
+   */
+  reconstituerRdimEcsIndividuelleUnique(th, ecs, cg.surface_habitable_immeuble);
   const Nb_lgt = cg.nombre_appartement || 1;
+
+  /**
+   * DPE appartement généré depuis un DPE immeuble : installation individuelle décrite sur la surface
+   * de l'immeuble avec un rdim exporté à 1 → reconstitution du rdim implicite, calcul à l'échelle de
+   * l'immeuble puis application de la clé de répartition (§ 17.2.2.2.2).
+   * @see https://github.com/Open3CL/engine/issues/287
+   */
+  const rdimReconstitue =
+    bug_for_bug_compat && dpeGenereImmeuble
+      ? reconstituerRdimDpeGenereImmeuble(cg, instal_ch, ecs)
+      : { ch: false, ecs: false };
+  // Type de bâtiment pour le besoin / l'ECS (thCalc) et pour le taux de charge (thCh)
+  const thCalc = rdimReconstitue.ecs ? 'immeuble' : th;
+  const thCh = rdimReconstitue.ch ? 'immeuble' : th;
   const hsp = cg.hsp;
   const clim = logement.climatisation_collection.climatisation || [];
   let apport_et_besoin = calc_apport_et_besoin(
@@ -339,9 +361,9 @@ export function calcul_3cl(inputDpe, options) {
   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');
+      thCalc === 'immeuble' && ecs.every((e) => e.donnee_entree.enum_type_installation_id === '1');
 
-    if (th === 'immeuble' && !isImmeubleSystemEcsIndividuels) {
+    if (thCalc === 'immeuble' && !isImmeubleSystemEcsIndividuels) {
       isImmeubleMultiEcs =
         Number(cg.surface_habitable_immeuble) > 0 &&
         ecs.every((e) => Number(e.donnee_entree.surface_habitable) > 0);
@@ -454,7 +476,7 @@ export function calcul_3cl(inputDpe, options) {
       GV,
       ca_id,
       zc_id,
-      th,
+      thCalc,
       virtualisationECS,
       dpe.logement.caracteristique_generale.surface_habitable_immeuble,
       dpe.logement.caracteristique_generale.nombre_appartement,
@@ -521,7 +543,7 @@ export function calcul_3cl(inputDpe, options) {
     instal_ch,
     bv_list,
     ets,
-    th,
+    thCalc,
     dpe.logement.caracteristique_generale.nombre_appartement
   );
   apport_et_besoin = { ...apport_et_besoin, ...besoin_ch };
@@ -535,7 +557,7 @@ export function calcul_3cl(inputDpe, options) {
    * 13.2.1.2 Présence d’un ou plusieurs générateurs à combustion indépendants
    * Calcul des taux de charge pour chacun des générateurs de chauffage
    */
-  tauxChargeForGenerator(instal_ch, GV, ca_id, zc_id, th);
+  tauxChargeForGenerator(instal_ch, GV, ca_id, zc_id, thCh);
 
   instal_ch.forEach((ch) => {
     calc_chauffage(

package/engine.spec.js

@@ -70,6 +70,12 @@ 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() }));
+vi.mock('./17.2_rdim_dpe_genere_immeuble.js', () => ({
+  reconstituerRdimDpeGenereImmeuble: vi.fn()
+}));
+vi.mock('./11_rdim_ecs_individuelle_unique.js', () => ({
+  reconstituerRdimEcsIndividuelleUnique: vi.fn()
+}));
 
 // Les instances Inertie / ProductionENR sont créées au chargement du module.
 // On expose des méthodes mockées récupérables dans les tests.
@@ -112,6 +118,9 @@ 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;
+const { reconstituerRdimDpeGenereImmeuble } = await import('./17.2_rdim_dpe_genere_immeuble.js');
+const { reconstituerRdimEcsIndividuelleUnique } =
+  await import('./11_rdim_ecs_individuelle_unique.js');
 
 /** Objet conso renvoyé par le mock de `calc_conso` (mêmes réf pour les 3 appels). */
 let consoResult;
@@ -1098,6 +1107,123 @@ describe('calcul_3cl - réalignements ECS (bug_for_bug_compat)', () => {
   });
 });
 
+/**
+ * DPE appartement généré depuis un DPE immeuble : reconstitution du rdim (issue #287).
+ * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - § 17.2.2.2.2
+ */
+describe('calcul_3cl - rdim reconstitué des DPE générés depuis un DPE immeuble (#287)', () => {
+  const METHODE_GENEREE = '10';
+
+  function makeDpeGenere() {
+    enums.methode_application_dpe_log = {
+      1: 'dpe maison individuelle',
+      [METHODE_GENEREE]:
+        'dpe appartement généré à partir des données dpe immeuble chauffage individuel ecs individuel'
+    };
+    const dpe = makeDpe();
+    dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id = METHODE_GENEREE;
+    return dpe;
+  }
+
+  /** Type de bâtiment transmis à calc_ecs, calc_besoin_ch et au taux de charge. */
+  const thTransmis = () => ({
+    ecs: calc_ecs.mock.calls[0][7],
+    besoinCh: calc_besoin_ch.mock.calls[0][11],
+    tauxCharge: tauxChargeForGenerator.mock.calls[0][4]
+  });
+
+  test('bug_for_bug_compat : reconstitution appelée avec les caractéristiques et les installations', () => {
+    bugForBugCompat = true;
+    vi.mocked(reconstituerRdimDpeGenereImmeuble).mockReturnValue({ ch: false, ecs: false });
+    const dpe = makeDpeGenere();
+
+    calcul_3cl(dpe, { sanitize: false });
+
+    expect(reconstituerRdimDpeGenereImmeuble).toHaveBeenCalledWith(
+      dpe.logement.caracteristique_generale,
+      dpe.logement.installation_chauffage_collection.installation_chauffage,
+      dpe.logement.installation_ecs_collection.installation_ecs
+    );
+    expect(thTransmis()).toEqual({
+      ecs: 'appartement',
+      besoinCh: 'appartement',
+      tauxCharge: 'appartement'
+    });
+  });
+
+  test('chauffage et ECS reconstitués : calcul à l’échelle de l’immeuble partout', () => {
+    bugForBugCompat = true;
+    vi.mocked(reconstituerRdimDpeGenereImmeuble).mockReturnValue({ ch: true, ecs: true });
+
+    calcul_3cl(makeDpeGenere(), { sanitize: false });
+
+    expect(thTransmis()).toEqual({ ecs: 'immeuble', besoinCh: 'immeuble', tauxCharge: 'immeuble' });
+  });
+
+  test('chauffage seul reconstitué : seul le taux de charge passe à l’échelle de l’immeuble', () => {
+    bugForBugCompat = true;
+    vi.mocked(reconstituerRdimDpeGenereImmeuble).mockReturnValue({ ch: true, ecs: false });
+
+    calcul_3cl(makeDpeGenere(), { sanitize: false });
+
+    expect(thTransmis()).toEqual({
+      ecs: 'appartement',
+      besoinCh: 'appartement',
+      tauxCharge: 'immeuble'
+    });
+  });
+
+  test('ECS seule reconstituée : besoin et ECS à l’échelle de l’immeuble, pas le taux de charge', () => {
+    bugForBugCompat = true;
+    vi.mocked(reconstituerRdimDpeGenereImmeuble).mockReturnValue({ ch: false, ecs: true });
+
+    calcul_3cl(makeDpeGenere(), { sanitize: false });
+
+    expect(thTransmis()).toEqual({
+      ecs: 'immeuble',
+      besoinCh: 'immeuble',
+      tauxCharge: 'appartement'
+    });
+  });
+
+  test('sans bug_for_bug_compat : aucune reconstitution', () => {
+    calcul_3cl(makeDpeGenere(), { sanitize: false });
+
+    expect(reconstituerRdimDpeGenereImmeuble).not.toHaveBeenCalled();
+    expect(thTransmis().tauxCharge).toBe('appartement');
+  });
+
+  test('DPE non généré depuis un immeuble : aucune reconstitution, même en bug_for_bug_compat', () => {
+    bugForBugCompat = true;
+
+    calcul_3cl(makeDpe(), { sanitize: false });
+
+    expect(reconstituerRdimDpeGenereImmeuble).not.toHaveBeenCalled();
+    expect(thTransmis().tauxCharge).toBe('maison');
+  });
+});
+
+describe('calcul_3cl - rdim de l’installation ECS individuelle unique d’un immeuble (#288)', () => {
+  test('reconstitution appelée avec le type de bâtiment, les installations ECS et SH, avant le calcul ECS', () => {
+    const dpe = makeDpe();
+    dpe.logement.caracteristique_generale.surface_habitable_immeuble = 640;
+    // la reconstitution doit précéder le calcul de l'ECS (besoin / rdim)
+    vi.mocked(reconstituerRdimEcsIndividuelleUnique).mockImplementationOnce(() => {
+      expect(calc_ecs).not.toHaveBeenCalled();
+      return false;
+    });
+
+    calcul_3cl(dpe, { sanitize: false });
+
+    expect(reconstituerRdimEcsIndividuelleUnique).toHaveBeenCalledWith(
+      'maison',
+      dpe.logement.installation_ecs_collection.installation_ecs,
+      640
+    );
+    expect(calc_ecs).toHaveBeenCalled();
+  });
+});
+
 describe('get_conso_coeff_1_7_2027', () => {
   test('projette la conso EP 2027 pour une maison', () => {
     vi.mocked(classe_bilan_dpe).mockReturnValue('C');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open3cl/engine",
-  "version": "1.8.57",
+  "version": "1.8.59",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {
@@ -84,7 +84,7 @@
     "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz"
   },
   "author": "Open3Cl",
-  "license": "GPL-3.0",
+  "license": "MIT",
   "engines": {
     "node": ">=24.14.1"
   },