@open3cl/engine 1.8.50 → 1.8.52

package/11_ecs.js

@@ -179,6 +179,33 @@ export function ratio_besoin_ecs_individuel(dpe, de, surfaceImmeuble, nombreAppa
   return ratio < 1 ? ratio : 1 / nombreAppartements;
 }
 
+/**
+ * enum_type_installation_id des installations ECS collectives :
+ * 2 - installation collective ; 3 - installation collective multi-bâtiment (réseau de chaleur)
+ */
+const TYPES_INSTALLATION_ECS_COLLECTIVE = ['2', '3'];
+
+/**
+ * Rdim (nombre d'installations individuelles identiques) sans objet pour une installation ECS
+ * collective décrite dans un DPE immeuble : elle dessert tout l'immeuble, le besoin ECS n'est donc
+ * pas ramené à un logement type. Sinon, le besoin serait divisé par rdim alors que les pertes de
+ * stockage (Qgw) et à l'arrêt (qp0) du générateur collectif restent celles de l'immeuble,
+ * effondrant les rendements de génération et de stockage.
+ * @see Guide Tribu TE-211208 p. 24 (Rdim = nombre d'installations individuelles identiques)
+ * @see Moteur_DPE.dll Calcul_batiment.cs l.583-592 (Becs / Rdim seulement pour une installation
+ * individuelle en immeuble ; Becs × Sh_ecs / SH sans Rdim pour une installation collective)
+ * @param th {string} type de bâtiment (maison, appartement, immeuble)
+ * @param de {Donnee_entree} donnée d'entrée de l'installation ECS
+ * @returns {boolean}
+ */
+export function isRdimEcsNeutralise(th, de) {
+  return (
+    th === 'immeuble' &&
+    TYPES_INSTALLATION_ECS_COLLECTIVE.includes(String(de.enum_type_installation_id)) &&
+    Number(de.rdim) > 1
+  );
+}
+
 export default function calc_ecs(
   dpe,
   ecs,
@@ -227,6 +254,12 @@ export default function calc_ecs(
         ((de.surface_habitable / (surfaceImmeuble || 1)) * (de.rdim || 1)) /
         (de.nombre_logement * nombreAppartements);
     }
+  } else if (isRdimEcsNeutralise(th, de)) {
+    /**
+     * Installation ECS collective d'un DPE immeuble : le besoin est celui de l'immeuble (pas de
+     * division par rdim), la consommation n'étant pas remultipliée par rdim (conso.js).
+     */
+    di.rdim_neutralise = true;
   } else if (de.rdim) {
     di.ratio_besoin_ecs = 1 / de.rdim || 1;
   }

package/11_ecs.spec.js

@@ -31,7 +31,7 @@ vi.mock('./14_generateur_ecs.js', () => ({
   default: vi.fn()
 }));
 
-const { default: calc_ecs } = await import('./11_ecs.js');
+const { default: calc_ecs, isRdimEcsNeutralise } = await import('./11_ecs.js');
 const { tv, requestInput } = await import('./utils.js');
 const { default: calc_gen_ecs } = await import('./14_generateur_ecs.js');
 
@@ -379,6 +379,91 @@ describe('calc_ecs - immeuble à plusieurs installations ECS (prorata des surfac
   });
 });
 
+/**
+ * Installation ECS collective unique d'un DPE immeuble : le rdim (nombre d'installations
+ * individuelles identiques) est sans objet, le besoin n'est pas divisé par rdim et la consommation
+ * n'est pas remultipliée par rdim à l'agrégation (conso.js getRdimEcs).
+ * @see Guide Tribu TE-211208 p. 24
+ * @see Moteur_DPE.dll Calcul_batiment.cs l.583-592 (Becs / Rdim seulement en installation individuelle)
+ */
+describe('calc_ecs - installation ECS collective en immeuble : rdim neutralisé', () => {
+  test.each([
+    ['collective', '2'],
+    ['collective multi-bâtiment', '3']
+  ])('installation %s, rdim 22 : besoin de l’immeuble (ratio 1)', (_libelle, type) => {
+    const ecs = makeEcs({
+      tv_rendement_distribution_ecs_id: '5',
+      enum_type_installation_id: type,
+      rdim: 22
+    });
+    calc_ecs({}, ecs, 1000, 1500, 1, 'ca1', 'h1a', 'immeuble', false, 681, 22, false, {});
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBe(1);
+    expect(ecs.donnee_intermediaire.besoin_ecs).toBe(1000);
+    expect(ecs.donnee_intermediaire.besoin_ecs_depensier).toBe(1500);
+    expect(ecs.donnee_intermediaire.rdim_neutralise).toBe(true);
+    // le générateur reçoit le besoin de l'immeuble (cohérent avec ses pertes Qgw / qp0)
+    expect(vi.mocked(calc_gen_ecs).mock.calls[0][2].besoin_ecs).toBe(1000);
+  });
+
+  test.each([
+    ['installation individuelle en immeuble', '1', 'immeuble', 0.25],
+    ['installation hybride collective-individuelle', '4', 'immeuble', 0.25],
+    ['DPE appartement (installation collective)', '2', 'appartement', 0.25],
+    ['DPE maison', '2', 'maison', 0.25]
+  ])('%s : division par rdim conservée', (_libelle, type, th, ratio) => {
+    const ecs = makeEcs({
+      tv_rendement_distribution_ecs_id: '5',
+      enum_type_installation_id: type,
+      rdim: 4
+    });
+    calc_ecs({}, ecs, 1000, 1500, 1, 'ca1', 'h1a', th, false, 200, null, false, {});
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBe(ratio);
+    expect(ecs.donnee_intermediaire.rdim_neutralise).toBeUndefined();
+  });
+
+  test('installation collective en immeuble, rdim 1 : inchangé (ratio 1, pas d’indicateur)', () => {
+    const ecs = makeEcs({
+      tv_rendement_distribution_ecs_id: '5',
+      enum_type_installation_id: '2',
+      rdim: 1
+    });
+    calc_ecs({}, ecs, 1000, 1500, 1, 'ca1', 'h1a', 'immeuble', false, 200, null, false, {});
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBe(1);
+    expect(ecs.donnee_intermediaire.rdim_neutralise).toBeUndefined();
+  });
+
+  test('immeuble multi-installations : prorata Sh / SH / rdim conservé (branche prioritaire)', () => {
+    const ecs = makeEcs({
+      tv_rendement_distribution_ecs_id: '5',
+      enum_type_installation_id: '2',
+      surface_habitable: 100,
+      rdim: 4
+    });
+    calc_ecs({}, ecs, 1000, 1500, 1, 'ca1', 'h1a', 'immeuble', false, 200, null, false, {}, true);
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBeCloseTo(100 / 200 / 4, 9);
+    expect(ecs.donnee_intermediaire.rdim_neutralise).toBeUndefined();
+  });
+});
+
+describe('isRdimEcsNeutralise', () => {
+  test.each([
+    ['immeuble', '2', 22, true],
+    ['immeuble', 3, '2', true],
+    ['immeuble', '2', 1, false],
+    ['immeuble', '2', undefined, false],
+    ['immeuble', '1', 22, false],
+    ['immeuble', '4', 22, false],
+    ['appartement', '2', 22, false],
+    ['maison', '2', 22, false]
+  ])('th %s, type %s, rdim %s → %s', (th, type, rdim, attendu) => {
+    expect(isRdimEcsNeutralise(th, { enum_type_installation_id: type, rdim })).toBe(attendu);
+  });
+});
+
 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/README.md

@@ -370,29 +370,29 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <!-- CORPUS:START -->
 
-> **Version `1.8.49`** · branche `main` · généré le 2026-10-12
+> **Version `1.8.51`** · branche `main` · généré le 2026-10-12
 > Seuil de tolérance **5%**
 
 <table>
 <tr>
 <td align="center"><strong>9</strong><br/><sub>corpus</sub></td>
 <td align="center"><strong>89 984</strong><br/><sub>DPE analysés</sub></td>
-<td align="center"><strong>62 220</strong><br/><sub>DPE conformes</sub></td>
-<td align="center"><strong>69,15 %</strong><br/><sub>réussite globale</sub></td>
+<td align="center"><strong>65 391</strong><br/><sub>DPE conformes</sub></td>
+<td align="center"><strong>72,67 %</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,45 %** | `█████████░░░░░░░░░░░` |  4 645 / 9 999 |
-| 🟢  | **Appartement · chauffage individuel (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_individuel_2025.csv`</sub> | **92,84 %** | `███████████████████░` | 9 284 / 10 000 |
+| 🔴  | **Généraliste**<br/><sub>`corpus_dpe.csv`</sub>                                                                         | **46,65 %** | `█████████░░░░░░░░░░░` |  4 665 / 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,27 %** | `██████████████████░░` | 9 127 / 10 000 |
 | 🟢  | **Logement individuel (2025)**<br/><sub>`dpe_logement_individuel_2025.csv`</sub>                                        | **89,93 %** | `██████████████████░░` |  8 986 / 9 992 |
-| 🟢  | **Maison individuelle (2025)**<br/><sub>`dpe_maison_individuelle_2025.csv`</sub>                                        | **88,83 %** | `██████████████████░░` |  8 882 / 9 999 |
+| 🟢  | **Maison individuelle (2025)**<br/><sub>`dpe_maison_individuelle_2025.csv`</sub>                                        | **88,88 %** | `██████████████████░░` |  8 887 / 9 999 |
 | 🟡  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **84,51 %** | `█████████████████░░░` |  8 449 / 9 998 |
-| 🟡  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **71,71 %** | `██████████████░░░░░░` | 7 171 / 10 000 |
-| 🟡  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **66,41 %** | `█████████████░░░░░░░` |  6 640 / 9 999 |
-| 🔴  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **54,15 %** | `███████████░░░░░░░░░` |  5 413 / 9 997 |
-| 🔴  | **Individuel généré depuis l'immeuble (2026)**<br/><sub>`dpe_individuel_a_partir_dpe_immeuble_2026.csv`</sub>           | **27,50 %** | `██████░░░░░░░░░░░░░░` | 2 750 / 10 000 |
+| 🟡  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **74,46 %** | `███████████████░░░░░` |  7 445 / 9 999 |
+| 🔴  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **56,59 %** | `███████████░░░░░░░░░` |  5 657 / 9 997 |
+| 🔴  | **Individuel généré depuis l'immeuble (2026)**<br/><sub>`dpe_individuel_a_partir_dpe_immeuble_2026.csv`</sub>           | **28,85 %** | `██████░░░░░░░░░░░░░░` | 2 885 / 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,56 ms</strong><br/><sub>moyenne</sub></td>
-<td align="center"><strong>4,89 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>581,4 ms</strong><br/><sub>max</sub></td>
+<td align="center"><strong>5,45 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>4,78 ms</strong><br/><sub>médiane</sub></td>
+<td align="center"><strong>0,15 ms</strong><br/><sub>min</sub></td>
+<td align="center"><strong>841,3 ms</strong><br/><sub>max</sub></td>
 </tr>
 </table>
 
 | Corpus                                         | Moyenne | Médiane |     Min |      Max |     p95 |     p99 |
 | :--------------------------------------------- | ------: | ------: | ------: | -------: | ------: | ------: |
-| **Généraliste**                                | 4,50 ms | 4,07 ms | 0,21 ms |  36,7 ms | 8,24 ms | 11,2 ms |
-| **Appartement · chauffage individuel (2025)**  | 4,06 ms | 3,74 ms | 1,54 ms |  29,8 ms | 6,88 ms | 8,57 ms |
-| **Logement individuel (2025)**                 | 5,52 ms | 4,95 ms | 1,71 ms |  34,2 ms | 10,1 ms | 13,7 ms |
-| **Maison individuelle (2025)**                 | 6,52 ms | 5,95 ms | 2,14 ms |  49,4 ms | 11,6 ms | 14,7 ms |
-| **Immeuble · chauffage individuel**            | 6,74 ms | 5,70 ms | 0,13 ms | 159,0 ms | 13,9 ms | 21,9 ms |
-| **Appartement · chauffage collectif (2025)**   | 4,52 ms | 4,20 ms | 1,58 ms |  39,5 ms | 7,25 ms | 9,05 ms |
-| **Immeuble · chauffage collectif**             | 5,77 ms | 4,91 ms | 0,13 ms | 131,8 ms | 10,7 ms | 18,8 ms |
-| **Immeuble · chauffage mixte**                 | 5,79 ms | 4,72 ms | 0,21 ms | 581,4 ms | 12,2 ms | 19,9 ms |
-| **Individuel généré depuis l'immeuble (2026)** | 6,62 ms | 5,72 ms | 1,79 ms |  58,3 ms | 12,5 ms | 20,3 ms |
+| **Généraliste**                                | 4,50 ms | 4,05 ms | 0,20 ms |  31,7 ms | 8,21 ms | 11,1 ms |
+| **Appartement · chauffage individuel (2025)**  | 4,06 ms | 3,72 ms | 1,41 ms |  25,8 ms | 6,98 ms | 8,99 ms |
+| **Appartement · chauffage collectif (2025)**   | 4,59 ms | 4,24 ms | 1,54 ms |  36,0 ms | 7,48 ms | 9,85 ms |
+| **Logement individuel (2025)**                 | 5,25 ms | 4,72 ms | 1,67 ms |  35,7 ms | 9,73 ms | 13,1 ms |
+| **Maison individuelle (2025)**                 | 6,28 ms | 5,68 ms | 1,90 ms |  54,8 ms | 11,2 ms | 14,4 ms |
+| **Immeuble · chauffage individuel**            | 6,81 ms | 5,72 ms | 0,15 ms | 173,2 ms | 13,9 ms | 22,8 ms |
+| **Immeuble · chauffage collectif**             | 5,66 ms | 4,82 ms | 0,19 ms | 103,6 ms | 10,4 ms | 17,8 ms |
+| **Immeuble · chauffage mixte**                 | 5,50 ms | 4,52 ms | 0,20 ms | 841,3 ms | 11,4 ms | 18,4 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 6,44 ms | 5,54 ms | 1,68 ms |  71,5 ms | 12,0 ms | 19,9 ms |
 
 <sub>La moyenne est tirée vers le haut par les DPE collectifs, dont le coût atteint plusieurs
 dizaines de fois la médiane : c’est la médiane qui décrit le cas courant, et p95/p99 le cas

package/conso.js

@@ -1,7 +1,7 @@
 import enums from './enums.js';
 import calc_conso_eclairage from './16_conso_eclairage.js';
 import tvs from './tv.js';
-import { tv } from './utils.js';
+import { bug_for_bug_compat, tv } from './utils.js';
 
 export const COEFF_EP_2_3 = 2.3;
 export const COEFF_EP_1_9 = 1.9;
@@ -311,53 +311,130 @@ function getConso(coef, type_energie, conso) {
   return conso;
 }
 
+/**
+ * Arrêtés « réseaux de chaleur » et table de valeurs associée (modèle de données de l'observatoire
+ * DPE, `modele_donnee/arrete_reseau_chaleur.json`). Le nom de la table ne correspond pas à l'année
+ * de l'arrêté (ex. l'arrêté du 05/07/2024 publie la table `reseau_chaleur_2023`).
+ * - date_arrete : valeur attendue dans `date_arrete_reseau_chaleur` ;
+ * - date_application : date à partir de laquelle l'arrêté s'applique (DPE sans date d'arrêté).
+ */
+export const ARRETES_RESEAU_CHALEUR = [
+  { table: 'reseau_chaleur_2020', date_arrete: '2020-10-12', date_application: '2020-10-17' },
+  { table: 'reseau_chaleur_2021', date_arrete: '2021-10-21', date_application: '2022-01-18' },
+  { table: 'reseau_chaleur_2022', date_arrete: '2023-03-16', date_application: '2023-04-16' },
+  { table: 'reseau_chaleur_2023', date_arrete: '2024-07-05', date_application: '2024-08-09' },
+  { table: 'reseau_chaleur_2024', date_arrete: '2025-04-11', date_application: '2025-05-26' },
+  { table: 'reseau_chaleur_2025', date_arrete: '2026-04-25', date_application: '2026-05-25' }
+];
+
+/** Facteur « AUTRES RESEAUX DE CHALEUR » (réseau non répertorié ou inconnu), kgCO2/kWh */
+export const COEF_GES_AUTRES_RESEAUX_CHALEUR = 0.385;
+
+/**
+ * Normalise une date (chaîne ISO ou Date) au format AAAA-MM-JJ, null si invalide.
+ * @param date {string|Date|undefined}
+ * @returns {string|null}
+ */
+function isoDate(date) {
+  if (typeof date !== 'string' && !(date instanceof Date)) return null;
+  const d = new Date(date);
+  return isNaN(d.getTime()) ? null : d.toISOString().slice(0, 10);
+}
+
+/**
+ * Index (dans ARRETES_RESEAU_CHALEUR) de l'arrêté réseau de chaleur utilisé par le générateur :
+ * - `date_arrete_reseau_chaleur` renseignée : dernier arrêté publié à cette date ou avant ;
+ * - sinon : dernier arrêté applicable à la date d'établissement du DPE ;
+ * - date antérieure au premier arrêté ou illisible : premier arrêté.
+ * @param dateArrete {string|undefined} date_arrete_reseau_chaleur du générateur
+ * @param dateDpe {string|undefined} date d'établissement du DPE
+ * @returns {number}
+ */
+export function indexArreteReseauChaleur(dateArrete, dateDpe) {
+  const arrete = isoDate(dateArrete);
+  const ref = arrete ?? isoDate(dateDpe);
+  const champ = arrete ? 'date_arrete' : 'date_application';
+  let index = 0;
+  if (ref) {
+    ARRETES_RESEAU_CHALEUR.forEach((a, i) => {
+      if (a[champ] <= ref) index = i;
+    });
+  }
+  return index;
+}
+
+/**
+ * Contenu CO2 d'un réseau de chaleur répertorié (kgCO2/kWh).
+ *
+ * Le facteur réglementaire est le contenu CO2 en analyse de cycle de vie (`contenu_co2_acv`) de la
+ * table publiée par l'arrêté utilisé. Si l'identifiant n'y figure pas (réseau retiré d'un arrêté plus
+ * récent), on retient la table antérieure la plus récente qui le contient. Réseau introuvable :
+ * facteur « autres réseaux de chaleur » (0,385).
+ *
+ * Mode bug_for_bug_compat : avec l'arrêté du 05/07/2024 (table reseau_chaleur_2023), LICIEL
+ * transmet au moteur le contenu CO2 hors ACV (`contenu_co2`) : 1 226/1 234 générateurs LICIEL des
+ * corpus immeuble, alors que DPEWIN, Pleiades et 4.1.1 exportent la valeur ACV (ex. réseau 6403C
+ * de Pau : 0,047 au lieu de 0,061).
+ *
+ * @param identifiant_reseau {string}
+ * @param dateArrete {string|undefined}
+ * @param dateDpe {string|undefined}
+ * @param versionLogiciel {string|undefined} administratif.diagnostiqueur.version_logiciel
+ * @returns {number}
+ */
+export function getContenuCo2ReseauChaleur(
+  identifiant_reseau,
+  dateArrete,
+  dateDpe,
+  versionLogiciel
+) {
+  const index = indexArreteReseauChaleur(dateArrete, dateDpe);
+
+  for (let i = index; i >= 0; i--) {
+    const { table } = ARRETES_RESEAU_CHALEUR[i];
+    const row = tv(table, { identifiant_reseau });
+    if (row) {
+      const contenuHorsAcv =
+        bug_for_bug_compat &&
+        table === 'reseau_chaleur_2023' &&
+        /liciel/i.test(versionLogiciel || '');
+      return Number(contenuHorsAcv ? row.contenu_co2 : row.contenu_co2_acv);
+    }
+  }
+
+  console.error(
+    `Aucun coefficient GES trouvé pour le réseau de chaleur ${identifiant_reseau} : valeur « autres réseaux de chaleur » ${COEF_GES_AUTRES_RESEAUX_CHALEUR}`
+  );
+  return COEF_GES_AUTRES_RESEAUX_CHALEUR;
+}
+
 /**
  * Récupération du coefficient d'émission GES pour le générateur
  * @param gen_ch {GenerateurChauffageItem||GenerateurEcsItem}
  * @param suffix {'ch'|'ecs'}
  * @param dateDpe {string} date d'établissement du DPE
+ * @param versionLogiciel {string} version du logiciel de saisie
  * @returns {number}
  */
-function getGesCoeffForGenerateur(gen_ch, suffix, dateDpe) {
+function getGesCoeffForGenerateur(gen_ch, suffix, dateDpe, versionLogiciel) {
   const typeEnergie = getTypeEnergie(gen_ch.donnee_entree, suffix);
 
-  let anneeDpe;
-  try {
-    if (gen_ch.donnee_entree.date_arrete_reseau_chaleur) {
-      anneeDpe = new Date(gen_ch.donnee_entree.date_arrete_reseau_chaleur).getFullYear() - 1;
-    } else {
-      anneeDpe = new Date(dateDpe).getFullYear() - 1;
-    }
-
-    if (anneeDpe < 2024) {
-      anneeDpe = 2022;
-    }
-  } catch (e) {
-    anneeDpe = 2022;
-  }
-
-  const key_reseau_chaleur = `reseau_chaleur_${anneeDpe}`;
-
   /**
    * Cas spécifique des réseaux de chaleur urbain qui ont des coefficients différents en fonction de réseau de distribution
    */
   if (typeEnergie === 'réseau de chauffage urbain') {
-    const identifiant_reseau = gen_ch.donnee_entree.identifiant_reseau_chaleur;
-
-    if (identifiant_reseau) {
-      const row = tv(key_reseau_chaleur, { identifiant_reseau });
-
-      if (row) {
-        return row.contenu_co2_acv;
-      } else {
-        console.error(`
-          Aucun coefficient GES trouvé pour le réseau de chaleur ${identifiant_reseau}
-        `);
-      }
-    } else {
-      // Prendre la valeur pour "AUTRES RESEAUX DE CHALEUR"
-      return 0.385;
+    const { identifiant_reseau_chaleur, date_arrete_reseau_chaleur } = gen_ch.donnee_entree;
+
+    if (identifiant_reseau_chaleur) {
+      return getContenuCo2ReseauChaleur(
+        identifiant_reseau_chaleur,
+        date_arrete_reseau_chaleur,
+        dateDpe,
+        versionLogiciel
+      );
     }
+    // Prendre la valeur pour "AUTRES RESEAUX DE CHALEUR"
+    return COEF_GES_AUTRES_RESEAUX_CHALEUR;
   }
 
   return coef_ges[typeEnergie] ?? 1;
@@ -377,7 +454,8 @@ export default function calc_conso(
   coeffEp,
   nbLogements = 1,
   ratioSurfaceCollectif = 1,
-  facteursAc = {}
+  facteursAc = {},
+  versionLogiciel = undefined
 ) {
   const gen_ch = ch.reduce((acc, ch) => {
     const generateur_chauffage = ch.generateur_chauffage_collection.generateur_chauffage;
@@ -393,7 +471,7 @@ export default function calc_conso(
         ch.donnee_entree.enum_methode_calcul_conso_id;
       value.donnee_entree.enum_type_installation_id = ch.donnee_entree.enum_type_installation_id;
       (value.donnee_utilisateur = value.donnee_utilisateur || {}).coeffEmissionGes =
-        getGesCoeffForGenerateur(value, 'ch', dateDpe);
+        getGesCoeffForGenerateur(value, 'ch', dateDpe, versionLogiciel);
     });
     return acc.concat(generateur_chauffage);
   }, []);
@@ -406,9 +484,9 @@ export default function calc_conso(
       // S'il existe une clé de repartition ECS, utilisation de celle-ci pour répartir la conso ECS collective à l'appartement
       generateur_ecs.forEach((value) => {
         value.donnee_entree.cle_repartition_ecs =
-          (ecs.donnee_entree.cle_repartition_ecs || 1) * (ecs.donnee_entree.rdim || 1);
+          (ecs.donnee_entree.cle_repartition_ecs || 1) * getRdimEcs(ecs);
         (value.donnee_utilisateur = value.donnee_utilisateur || {}).coeffEmissionGes =
-          getGesCoeffForGenerateur(value, 'ecs', dateDpe);
+          getGesCoeffForGenerateur(value, 'ecs', dateDpe, versionLogiciel);
       });
     }
     return acc.concat(generateur_ecs);
@@ -794,6 +872,19 @@ function getEcsConso(gen_ecs, field, coef, prorataECS, prefix, facteurAc = 1) {
   }, 0);
 }
 
+/**
+ * Rdim appliqué à la consommation d'une installation ECS lors de l'agrégation. Il vaut 1 lorsque le
+ * besoin n'a pas été divisé par rdim (installation ECS collective en immeuble, cf. 11_ecs.js
+ * isRdimEcsNeutralise), afin de rester cohérent avec le besoin calculé.
+ * @see Moteur_DPE.dll Calcul_batiment.cs l.1067 (conso × Rdim, Rdim = 1 transmis en collectif)
+ * @param inst {InstallationEcs}
+ * @returns {number}
+ */
+export function getRdimEcs(inst) {
+  if (inst.donnee_intermediaire?.rdim_neutralise) return 1;
+  return Number(inst.donnee_entree.rdim) || 1;
+}
+
 /**
  * Consommation des auxiliaires de génération ECS (circulateurs des générateurs).
  * Le besoin d'une installation dimensionnée (rdim > 1) est exprimé par unité : comme la
@@ -809,7 +900,7 @@ function getEcsConso(gen_ecs, field, coef, prorataECS, prefix, facteurAc = 1) {
  */
 export function getAuxGenerationEcs(ecs, field, coef, prorataECS, facteurAc = 1) {
   return ecs.reduce((acc, inst) => {
-    const rdim = prorataECS === 1 ? Number(inst.donnee_entree.rdim) || 1 : 1;
+    const rdim = prorataECS === 1 ? getRdimEcs(inst) : 1;
     return inst.generateur_ecs_collection.generateur_ecs.reduce((acc2, gen) => {
       const conso = (gen.donnee_intermediaire[field] || 0) * rdim * facteurAc;
       return acc2 + getConso(coef, 'électricité auxiliaire', conso);

package/conso.spec.js

@@ -37,13 +37,21 @@ vi.mock('./tv.js', () => ({
   }
 }));
 
+/** Mode bug_for_bug_compat piloté par les tests (export « live » du module utils mocké). */
+const utilsState = vi.hoisted(() => ({ bugForBugCompat: false }));
+
+/** Lecture des tables par défaut : réseau de chaleur "R1" connu, "R2" inconnu. */
+const tvParDefaut = (table, matcher) => {
+  if (matcher?.identifiant_reseau === 'R1') return { contenu_co2_acv: 0.15 };
+  return null;
+};
+
 vi.mock('./utils.js', () => ({
   set_bug_for_bug_compat: vi.fn(),
-  tv: vi.fn((table, matcher) => {
-    // Réseau de chaleur "R1" connu, "R2" inconnu
-    if (matcher?.identifiant_reseau === 'R1') return { contenu_co2_acv: 0.15 };
-    return null;
-  })
+  get bug_for_bug_compat() {
+    return utilsState.bugForBugCompat;
+  },
+  tv: vi.fn((table, matcher) => tvParDefaut(table, matcher))
 }));
 
 const {
@@ -56,10 +64,16 @@ const {
   coefCoutProrata,
   masqueEnergie,
   getAuxGenerationEcs,
+  getRdimEcs,
   DATE_BAREME_COUT_2024,
   appointBijonction,
-  coutBijonction
+  coutBijonction,
+  ARRETES_RESEAU_CHALEUR,
+  COEF_GES_AUTRES_RESEAUX_CHALEUR,
+  indexArreteReseauChaleur,
+  getContenuCo2ReseauChaleur
 } = await import('./conso.js');
+const { tv } = await import('./utils.js');
 
 /**
  * Classe énergétique (bilan DPE)
@@ -432,7 +446,7 @@ describe('calc_conso - agrégation des consommations', () => {
     expect(res.emission_ges.emission_ges_ch).toBeCloseTo(150, 9);
   });
 
-  test('réseau de chaleur inconnu (identifiant sans ligne) : erreur signalée', () => {
+  test('réseau de chaleur inconnu (identifiant sans ligne) : erreur signalée, facteur « autres réseaux » 0,385', () => {
     const ch = [
       installCh({ cle_repartition_ch: 1 }, [
         genCh(
@@ -443,8 +457,10 @@ describe('calc_conso - agrégation des consommations', () => {
       ])
     ];
 
-    calc_conso(100, 1, 1, [], ch, [], [], 1, 1, DATE_DPE, coef_ep);
+    const res = calc_conso(100, 1, 1, [], ch, [], [], 1, 1, DATE_DPE, coef_ep);
     expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('R2'));
+    // Plus de repli sur 1 kgCO2/kWh (GES = consommation) : 1000 * 0,385
+    expect(res.emission_ges.emission_ges_ch).toBeCloseTo(385, 9);
   });
 
   test('réseau de chaleur sans identifiant : coefficient GES forfaitaire 0,385', () => {
@@ -459,8 +475,8 @@ describe('calc_conso - agrégation des consommations', () => {
     expect(res.emission_ges.emission_ges_ch).toBeCloseTo(385, 9);
   });
 
-  test("date de DPE invalide (levée d'exception) : année de repli 2022", () => {
-    // date_arrete_reseau_chaleur = Symbol => new Date(...) lève => catch => 2022
+  test("date d'arrêté réseau de chaleur invalide : aucune exception", () => {
+    // date_arrete_reseau_chaleur = Symbol : ignorée (repli sur la date du DPE)
     const ch = [
       installCh({ cle_repartition_ch: 1 }, [
         genCh(
@@ -536,6 +552,20 @@ describe('calc_conso - agrégation des consommations', () => {
     expect(res.ef_conso.conso_ecs).toBe(600);
   });
 
+  test('ECS collective en immeuble, rdim neutralisé (11_ecs.js) : conso non remultipliée par rdim', () => {
+    const inst = installEcs({ cle_repartition_ecs: 2, rdim: 22 }, [
+      genEcs('1', { conso_ecs: 100, conso_ecs_depensier: 120 })
+    ]);
+    inst.donnee_intermediaire.rdim_neutralise = true;
+
+    const res = calc_conso(100, 1, 1, [], [], [inst], [], 1, 1, DATE_DPE, coef_ep);
+    // clé = 2 × 1 (rdim neutralisé) => conso_ecs = 100 × 2
+    expect(inst.generateur_ecs_collection.generateur_ecs[0].donnee_entree.cle_repartition_ecs).toBe(
+      2
+    );
+    expect(res.ef_conso.conso_ecs).toBe(200);
+  });
+
   test('ECS avec prorataECS différent de 1 : clé issue du prorata', () => {
     // Quand prorataECS !== 1, la boucle ECS ne renseigne pas donnee_utilisateur :
     // on la fournit en amont (coefficient GES déjà connu) pour refléter les données réelles.
@@ -976,6 +1006,14 @@ describe('getAuxGenerationEcs - auxiliaires de génération ECS et rdim', () =>
     expect(getAuxGenerationEcs(ecs, 'conso_auxiliaire_generation_ecs', coefUnitaire, 1)).toBe(4);
   });
 
+  test('installation ECS collective en immeuble (rdim neutralisé) : auxiliaires non multipliés', () => {
+    const collective = inst(22, 4);
+    collective.donnee_intermediaire.rdim_neutralise = true;
+    const ecs = [collective, inst(3, 1)];
+    // 4 × 1 (rdim neutralisé) + 1 × 3
+    expect(getAuxGenerationEcs(ecs, 'conso_auxiliaire_generation_ecs', coefUnitaire, 1)).toBe(7);
+  });
+
   test('calc_conso : auxiliaire_generation_ecs intègre le rdim', () => {
     const ecs = [inst(2, 5)];
     const res = calc_conso(100, 1, 1, [], [], ecs, [], 1, 1, DATE_DPE, coef_ep);
@@ -1000,6 +1038,23 @@ describe('getAuxGenerationEcs - auxiliaires de génération ECS et rdim', () =>
   });
 });
 
+/**
+ * Rdim appliqué à la conso ECS lors de l'agrégation : 1 si le besoin n'a pas été divisé par rdim.
+ * @see Moteur_DPE.dll Calcul_batiment.cs l.1067
+ */
+describe('getRdimEcs', () => {
+  test.each([
+    ['rdim renseigné', { rdim: 3 }, {}, 3],
+    ['rdim chaîne', { rdim: '2.5' }, {}, 2.5],
+    ['rdim absent', {}, {}, 1],
+    ['rdim non numérique', { rdim: 'abc' }, {}, 1],
+    ['rdim neutralisé', { rdim: 22 }, { rdim_neutralise: true }, 1],
+    ['sans donnée intermédiaire', { rdim: 4 }, undefined, 4]
+  ])('%s', (_libelle, de, di, attendu) => {
+    expect(getRdimEcs({ donnee_entree: de, donnee_intermediaire: di })).toBe(attendu);
+  });
+});
+
 /**
  * Convecteurs bi-jonction (§9.1.6) : base (60 %) facturée en électricité collective, appoint
  * individuel (40 %) en électricité individuelle.
@@ -1169,3 +1224,166 @@ describe('appointBijonction / coutBijonction', () => {
     );
   });
 });
+
+/**
+ * Facteur d'émission des réseaux de chaleur urbains : table de l'arrêté utilisé
+ * (modele_donnee/arrete_reseau_chaleur.json de l'observatoire DPE).
+ */
+describe('réseaux de chaleur - sélection de l’arrêté et du contenu CO2', () => {
+  let errorSpy;
+
+  beforeEach(() => {
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.mocked(tv).mockReset();
+    utilsState.bugForBugCompat = false;
+  });
+
+  afterEach(() => {
+    errorSpy.mockRestore();
+    vi.mocked(tv).mockImplementation(tvParDefaut);
+    utilsState.bugForBugCompat = false;
+  });
+
+  /** Tables mockées : identifiant -> { table: ligne } */
+  const mockTables = (lignes) =>
+    vi
+      .mocked(tv)
+      .mockImplementation((table, matcher) => lignes[matcher.identifiant_reseau]?.[table] ?? null);
+
+  test('six arrêtés, dans l’ordre chronologique, table ≠ année de l’arrêté', () => {
+    expect(ARRETES_RESEAU_CHALEUR.map((a) => a.table)).toEqual([
+      'reseau_chaleur_2020',
+      'reseau_chaleur_2021',
+      'reseau_chaleur_2022',
+      'reseau_chaleur_2023',
+      'reseau_chaleur_2024',
+      'reseau_chaleur_2025'
+    ]);
+    // L'arrêté du 05/07/2024 publie la table 2023 (cause du bug : 2024 - 1 = 2023 forcé à 2022)
+    expect(ARRETES_RESEAU_CHALEUR[3]).toMatchObject({
+      table: 'reseau_chaleur_2023',
+      date_arrete: '2024-07-05'
+    });
+    const dates = ARRETES_RESEAU_CHALEUR.map((a) => a.date_arrete);
+    expect([...dates].sort()).toEqual(dates);
+    ARRETES_RESEAU_CHALEUR.forEach((a) => expect(a.date_application >= a.date_arrete).toBe(true));
+  });
+
+  test.each([
+    ['2020-10-12', 0],
+    ['2021-10-21', 1],
+    ['2022-01-18', 1], // date hors liste : dernier arrêté publié avant
+    ['2023-03-16', 2],
+    ['2024-07-05', 3],
+    ['2024-07-10', 3],
+    ['2025-04-11', 4],
+    ['2026-04-25', 5],
+    ['2030-01-01', 5],
+    ['2019-01-01', 0]
+  ])('date_arrete_reseau_chaleur %s : arrêté n°%i', (dateArrete, index) => {
+    // La date du DPE est ignorée quand la date d'arrêté est renseignée
+    expect(indexArreteReseauChaleur(dateArrete, '2030-01-01')).toBe(index);
+  });
+
+  test.each([
+    ['2022-01-17', 0],
+    ['2022-01-18', 1],
+    ['2023-04-15', 1], // arrêté du 16/03/2023 applicable au 16/04/2023 seulement
+    ['2023-04-16', 2],
+    ['2024-08-09', 3],
+    [undefined, 0],
+    ['date invalide', 0]
+  ])('sans date d’arrêté, DPE du %s : arrêté applicable n°%i', (dateDpe, index) => {
+    expect(indexArreteReseauChaleur(undefined, dateDpe)).toBe(index);
+  });
+
+  test('date d’arrêté illisible (non chaîne) : repli sur la date du DPE', () => {
+    expect(indexArreteReseauChaleur(Symbol('invalide'), '2024-08-09')).toBe(3);
+    expect(indexArreteReseauChaleur(new Date('2024-07-05'), undefined)).toBe(3);
+  });
+
+  test('arrêté du 05/07/2024 : lecture de reseau_chaleur_2023 et contenu ACV (cas Pau 6403C)', () => {
+    mockTables({
+      '6403C': { reseau_chaleur_2023: { contenu_co2: '0.047', contenu_co2_acv: '0.061' } }
+    });
+    expect(getContenuCo2ReseauChaleur('6403C', '2024-07-05', '2025-01-24', 'Pleiades')).toBe(0.061);
+    expect(tv).toHaveBeenCalledTimes(1);
+    expect(tv).toHaveBeenCalledWith('reseau_chaleur_2023', { identifiant_reseau: '6403C' });
+  });
+
+  test('bug_for_bug_compat + LICIEL + table 2023 : contenu CO2 hors ACV transmis par le logiciel', () => {
+    utilsState.bugForBugCompat = true;
+    mockTables({
+      '6403C': {
+        reseau_chaleur_2023: { contenu_co2: '0.047', contenu_co2_acv: '0.061' },
+        reseau_chaleur_2022: { contenu_co2: '0.1', contenu_co2_acv: '0.2' }
+      }
+    });
+    const liciel = 'LICIEL Diagnostics v4 [Version XML:305]';
+    expect(getContenuCo2ReseauChaleur('6403C', '2024-07-05', '2025-01-24', liciel)).toBe(0.047);
+    // Autre logiciel : valeur ACV
+    expect(getContenuCo2ReseauChaleur('6403C', '2024-07-05', '2025-01-24', 'DPEWIN V5.2.5')).toBe(
+      0.061
+    );
+    expect(getContenuCo2ReseauChaleur('6403C', '2024-07-05', '2025-01-24', undefined)).toBe(0.061);
+    // LICIEL avec un autre arrêté (16/03/2023 -> table 2022) : valeur ACV
+    expect(getContenuCo2ReseauChaleur('6403C', '2023-03-16', '2023-06-01', liciel)).toBe(0.2);
+  });
+
+  test('sans bug_for_bug_compat, LICIEL lit aussi le contenu ACV', () => {
+    mockTables({
+      R: { reseau_chaleur_2023: { contenu_co2: '0.047', contenu_co2_acv: '0.061' } }
+    });
+    expect(getContenuCo2ReseauChaleur('R', '2024-07-05', undefined, 'LICIEL')).toBe(0.061);
+  });
+
+  test('réseau absent de la table de l’arrêté : table antérieure la plus récente qui le contient', () => {
+    mockTables({
+      R: {
+        reseau_chaleur_2021: { contenu_co2: '0.3', contenu_co2_acv: '0.33' },
+        reseau_chaleur_2020: { contenu_co2: '0.4', contenu_co2_acv: '0.44' }
+      }
+    });
+    expect(getContenuCo2ReseauChaleur('R', '2024-07-05', undefined, undefined)).toBe(0.33);
+    expect(vi.mocked(tv).mock.calls.map((c) => c[0])).toEqual([
+      'reseau_chaleur_2023',
+      'reseau_chaleur_2022',
+      'reseau_chaleur_2021'
+    ]);
+  });
+
+  test('réseau introuvable dans toutes les tables : facteur « autres réseaux de chaleur » 0,385 et erreur', () => {
+    mockTables({});
+    expect(COEF_GES_AUTRES_RESEAUX_CHALEUR).toBe(0.385);
+    expect(getContenuCo2ReseauChaleur('XXXX', '2024-07-05', undefined, undefined)).toBe(0.385);
+    expect(tv).toHaveBeenCalledTimes(4);
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('XXXX'));
+  });
+
+  test('calc_conso : facteur réseau appliqué au chauffage et à l’ECS, version logiciel transmise', () => {
+    utilsState.bugForBugCompat = true;
+    mockTables({
+      '6403C': { reseau_chaleur_2023: { contenu_co2: '0.047', contenu_co2_acv: '0.061' } }
+    });
+    const de = { identifiant_reseau_chaleur: '6403C', date_arrete_reseau_chaleur: '2024-07-05' };
+    const ch = [
+      installCh({ cle_repartition_ch: 1 }, [
+        genCh('3', { conso_ch: 1000, conso_ch_depensier: 1200 }, de)
+      ])
+    ];
+    const ecs = [
+      installEcs({ cle_repartition_ecs: 1 }, [
+        genEcs('3', { conso_ecs: 500, conso_ecs_depensier: 600 }, de)
+      ])
+    ];
+    const args = [100, 1, 1, [], ch, ecs, [], 1, 1, '2025-01-24', coef_ep, 1, 1, {}];
+
+    const licielRes = calc_conso(...args, 'LICIEL Diagnostics v4');
+    // 1000 * 0,047 et 500 * 0,047 (valeur ADEME du DPE 2564E0255485Z) — avant : 1000 * 1
+    expect(licielRes.emission_ges.emission_ges_ch).toBeCloseTo(47, 9);
+    expect(licielRes.emission_ges.emission_ges_ecs).toBeCloseTo(23.5, 9);
+
+    const autreRes = calc_conso(...args);
+    expect(autreRes.emission_ges.emission_ges_ch).toBeCloseTo(61, 9);
+  });
+});

package/engine.js

@@ -33,7 +33,7 @@ import getFicheTechnique from './ficheTechnique.js';
 import { ProductionENR, ratioProrataPvLogement } from './16.2_production_enr.js';
 import DpeSanitizerService from './dpe-sanitizer.service.js';
 
-const LIB_VERSION = '1.8.50';
+const LIB_VERSION = '1.8.52';
 
 const dpeSanitizerService = new DpeSanitizerService();
 
@@ -85,6 +85,7 @@ export function calcul_3cl(inputDpe, options) {
   }
   const modele = enums.modele_dpe[dpe.administratif.enum_modele_dpe_id];
   const dateDpe = dpe.administratif.date_etablissement_dpe;
+  const versionLogiciel = dpe.administratif.diagnostiqueur?.version_logiciel;
   if (modele !== 'dpe 3cl 2021 méthode logement') {
     console.error('Moteur dpe non implémenté pour le modèle: ' + modele);
     return null;
@@ -606,7 +607,9 @@ export function calcul_3cl(inputDpe, options) {
     dateDpe,
     coef_ep,
     th === 'immeuble' ? Nb_lgt : 1,
-    ratioSurfaceCoutCollectif
+    ratioSurfaceCoutCollectif,
+    {},
+    versionLogiciel
   );
 
   // Proratisation au logement d'une installation PV d'immeuble (appartement)
@@ -648,7 +651,8 @@ export function calcul_3cl(inputDpe, options) {
       coef_ep,
       th === 'immeuble' ? Nb_lgt : 1,
       ratioSurfaceCoutCollectif,
-      facteursAc
+      facteursAc,
+      versionLogiciel
     );
     conso.emission_ges = consoNette.emission_ges;
     // Ligne électricité de sortie_par_energie nette de l'autoconsommation (issue #34)
@@ -669,7 +673,9 @@ export function calcul_3cl(inputDpe, options) {
     dateDpe,
     coef_ep_1_7,
     th === 'immeuble' ? Nb_lgt : 1,
-    ratioSurfaceCoutCollectif
+    ratioSurfaceCoutCollectif,
+    {},
+    versionLogiciel
   );
 
   productionENR.calculateEnr(
@@ -695,7 +701,9 @@ export function calcul_3cl(inputDpe, options) {
     dateDpe,
     coef_ep_2_3,
     th === 'immeuble' ? Nb_lgt : 1,
-    ratioSurfaceCoutCollectif
+    ratioSurfaceCoutCollectif,
+    {},
+    versionLogiciel
   );
 
   productionENR.calculateEnr(

package/engine.spec.js

@@ -518,6 +518,24 @@ describe('calcul_3cl - run intégral (maison)', () => {
     expect(dpe.logement.sortie.cout).toEqual({ cout_5_usages: 2 });
   });
 
+  test('version du logiciel de saisie transmise à tous les calculs de conso (facteur GES réseau de chaleur)', () => {
+    const dpe = makeDpe();
+    dpe.administratif.diagnostiqueur = { version_logiciel: 'LICIEL Diagnostics v4' };
+    const facteurs = { ch: 0.8 };
+    vi.mocked(calculateEnr).mockImplementationOnce((enr, conso, Sh, th, zc, coef, ratio, f) => {
+      Object.assign(f, facteurs);
+      return { pv: 1 };
+    });
+
+    calcul_3cl(dpe, { sanitize: false });
+
+    // Lue avant l'écrasement de `diagnostiqueur` par la version du moteur
+    expect(calc_conso).toHaveBeenCalledTimes(4);
+    calc_conso.mock.calls.forEach((call) => expect(call[14]).toBe('LICIEL Diagnostics v4'));
+    expect(calc_conso.mock.calls[0][13]).toEqual({});
+    expect(calc_conso.mock.calls[1][13]).toEqual(facteurs);
+  });
+
   test('bâtiment matériaux anciens => ilpa = 1 ; incohérence inertie => erreur loggée', () => {
     const dpe = makeDpe();
     dpe.logement.meteo.batiment_materiaux_anciens = 1;

package/package.json

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