@open3cl/engine 1.8.50 → 1.8.51

package/README.md

@@ -370,7 +370,7 @@ 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.50`** · branche `main` · généré le 2026-10-12
 > Seuil de tolérance **5%**
 
 <table>
@@ -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,86 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>5,18 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>549,4 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,94 ms | 4,45 ms | 0,23 ms |  35,1 ms | 9,08 ms | 13,0 ms |
+| **Appartement · chauffage individuel (2025)**  | 4,79 ms | 4,42 ms | 1,59 ms |  39,2 ms | 8,31 ms | 11,2 ms |
+| **Logement individuel (2025)**                 | 5,40 ms | 4,84 ms | 1,68 ms |  42,3 ms | 10,0 ms | 13,4 ms |
+| **Maison individuelle (2025)**                 | 6,47 ms | 5,87 ms | 1,94 ms |  55,6 ms | 11,4 ms | 14,6 ms |
+| **Immeuble · chauffage individuel**            | 7,31 ms | 6,23 ms | 0,12 ms | 153,7 ms | 14,9 ms | 23,5 ms |
+| **Appartement · chauffage collectif (2025)**   | 4,94 ms | 4,79 ms | 1,61 ms |  34,7 ms | 7,75 ms | 9,99 ms |
+| **Immeuble · chauffage collectif**             | 6,38 ms | 5,54 ms | 0,13 ms | 119,4 ms | 11,9 ms | 21,2 ms |
+| **Immeuble · chauffage mixte**                 | 5,90 ms | 4,82 ms | 0,22 ms | 549,4 ms | 12,7 ms | 20,4 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 6,63 ms | 5,69 ms | 1,75 ms |  67,7 ms | 12,3 ms | 20,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/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);
   }, []);
@@ -408,7 +486,7 @@ export default function calc_conso(
         value.donnee_entree.cle_repartition_ecs =
           (ecs.donnee_entree.cle_repartition_ecs || 1) * (ecs.donnee_entree.rdim || 1);
         (value.donnee_utilisateur = value.donnee_utilisateur || {}).coeffEmissionGes =
-          getGesCoeffForGenerateur(value, 'ecs', dateDpe);
+          getGesCoeffForGenerateur(value, 'ecs', dateDpe, versionLogiciel);
       });
     }
     return acc.concat(generateur_ecs);

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 {
@@ -58,8 +66,13 @@ const {
   getAuxGenerationEcs,
   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 +445,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 +456,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 +474,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(
@@ -1169,3 +1184,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.51';
 
 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.51",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {