@open3cl/engine 1.8.49 → 1.8.51

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.49';
+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/features/engine/domain/ch/generateur-ch.service.js

@@ -4,6 +4,11 @@ import { excel_to_js_exec } from '../../../../utils.js';
 import { TvStore } from '../../../dpe/infrastructure/tv.store.js';
 import { EmetteurChService } from './emetteur-ch.service.js';
 import { TypeGenerateur } from '../../../dpe/domain/models/type-generateur.model.js';
+import enums from '../../../../enums.js';
+import {
+  anneeInstallationGenerateur,
+  pnEstimeeDimensionnement
+} from '../../../../13.2_generateur_combustion_pdim.js';
 
 /**
  * Calcul des données de calcul pour chacun des générateurs
@@ -76,7 +81,8 @@ export class GenerateurChService {
           generateurChauffage.donnee_intermediaire.pn = this.pn(
             ctx,
             logement,
-            installationChauffage
+            installationChauffage,
+            generateurChauffage
           );
         }
 
@@ -206,9 +212,10 @@ export class GenerateurChService {
    * @param ctx {Contexte}
    * @param logement {Logement}
    * @param installationChauffage {InstallationChauffage}
+   * @param generateurChauffage {GenerateurChauffage}
    * @return {number}
    */
-  pn(ctx, logement, installationChauffage) {
+  pn(ctx, logement, installationChauffage, generateurChauffage) {
     const Tbase = this.#tvStore.getTempBase(ctx.altitude.id, ctx.zoneClimatique.id);
     // §13.2.2.4 : générateur individuel n'alimentant qu'une partie du logement => prorata Sh_installation / Sh.
     // Un générateur collectif dessert tout le bâtiment : pas de prorata.
@@ -218,9 +225,58 @@ export class GenerateurChService {
         ? installationDE.surface_chauffee / ctx.surfaceHabitable
         : 1;
     const prorata = ratio > 0 && ratio < 1 ? ratio : 1;
-    return (
-      (prorata * 1.2 * logement.sortie.deperdition.deperdition_enveloppe * (19 - Tbase)) / 0.95 ** 3
-    );
+    const pch =
+      (prorata * 1.2 * logement.sortie.deperdition.deperdition_enveloppe * (19 - Tbase)) /
+      0.95 ** 3;
+
+    // §13.2.2.4 : Pdim = max(Pch ; Pecs) puis table Pdim → Pn des chaudières (générateurs individuels)
+    if (String(installationDE?.enum_type_installation_id) !== '1' || !generateurChauffage) {
+      return pch;
+    }
+
+    const generateurDE = generateurChauffage.donnee_entree;
+    const usageMixte = String(generateurDE.enum_usage_generateur_id) === '3';
+    const libelleTypeGenerateur = enums.type_generateur_ch[generateurDE.enum_type_generateur_ch_id];
+
+    return pnEstimeeDimensionnement({
+      pch,
+      volumeStockage: usageMixte ? this.volumeStockageEcsMixte(logement, generateurDE) : undefined,
+      usageEcs: usageMixte,
+      libelleTypeGenerateur,
+      // Fiches techniques non disponibles dans la nouvelle architecture : pose murale inconnue
+      murale: undefined,
+      anneeInstallation: anneeInstallationGenerateur(
+        generateurDE.annee_installation,
+        ctx.anneeConstruction,
+        libelleTypeGenerateur
+      )
+    });
+  }
+
+  /**
+   * Volume de stockage (L) de la production d'ECS assurée par un générateur de chauffage mixte :
+   * générateur ECS mixte de même `reference_generateur_mixte`, sinon générateur ECS mixte unique.
+   *
+   * @param logement {Logement}
+   * @param generateurChauffageDE {GenerateurChauffageDE}
+   * @return {number|undefined}
+   */
+  volumeStockageEcsMixte(logement, generateurChauffageDE) {
+    const generateursEcsMixtes = (logement.installation_ecs_collection?.installation_ecs || [])
+      .flatMap((installation) => installation.generateur_ecs_collection?.generateur_ecs || [])
+      .filter((generateur) => String(generateur.donnee_entree?.enum_usage_generateur_id) === '3');
+
+    const reference = generateurChauffageDE.reference_generateur_mixte;
+    const jumeau =
+      (reference !== undefined &&
+        reference !== null &&
+        generateursEcsMixtes.find(
+          (generateur) =>
+            String(generateur.donnee_entree.reference_generateur_mixte) === String(reference)
+        )) ||
+      (generateursEcsMixtes.length === 1 ? generateursEcsMixtes[0] : undefined);
+
+    return jumeau?.donnee_entree.volume_stockage;
   }
 
   /**

package/features/engine/domain/ch/generateur-ch.service.spec.js

@@ -128,3 +128,104 @@ describe('Puissance nominale estimée des générateurs de chauffage (issue #264
     expect(service.pn(ctx, logement, installation)).toBeCloseTo(PCH_LOGEMENT, 9);
   });
 });
+
+/**
+ * Puissance nominale estimée par la puissance de dimensionnement : Pdim = max(Pch ; Pecs) puis table
+ * Pdim → Pn des chaudières (le calcul de la table est testé dans 13.2_generateur_combustion_pdim.spec.js).
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.2.4
+ */
+describe('Puissance nominale estimée : Pdim et table Pdim → Pn (issue #271)', () => {
+  /** @type {TvStore} */
+  let tvStore;
+  const ctx = {
+    altitude: { id: 1 },
+    zoneClimatique: { id: 1 },
+    surfaceHabitable: 100,
+    anneeConstruction: 1975
+  };
+  const installation = { donnee_entree: { surface_chauffee: 100, enum_type_installation_id: 1 } };
+  const logementAvecEcs = (generateursEcs) => ({
+    sortie: { deperdition: { deperdition_enveloppe: 200 } },
+    installation_ecs_collection: {
+      installation_ecs: [{ generateur_ecs_collection: { generateur_ecs: generateursEcs } }]
+    }
+  });
+  const generateur = (de) => ({ donnee_entree: de });
+
+  beforeEach(() => {
+    tvStore = new TvStore();
+    service = new GenerateurChService(new ChTvStore(), tvStore, new EmetteurChService());
+    vi.spyOn(tvStore, 'getTempBase').mockReturnValue(-9);
+  });
+
+  test('chaudière de chauffage seul installée après 2015 : Pch = 7,84 kW → Pn = 10 kW', () => {
+    const logement = logementAvecEcs([]);
+    const gen = generateur({ enum_type_generateur_ch_id: '97', enum_usage_generateur_id: 1 });
+    expect(service.pn(ctx, logement, installation, gen)).toBe(10000);
+  });
+
+  test('chaudière 1991-2000 (pose inconnue, avant 2006) : plancher 18 kW', () => {
+    const logement = logementAvecEcs([]);
+    const gen = generateur({ enum_type_generateur_ch_id: '88', enum_usage_generateur_id: 1 });
+    expect(service.pn(ctx, logement, installation, gen)).toBe(18000);
+  });
+
+  test('chaudière mixte instantanée : Pdim = max(Pch ; 21 kW) → Pn = 24 kW', () => {
+    const logement = logementAvecEcs([
+      { donnee_entree: { enum_usage_generateur_id: 2, volume_stockage: 300 } },
+      { donnee_entree: { enum_usage_generateur_id: 3, volume_stockage: 0 } }
+    ]);
+    const gen = generateur({ enum_type_generateur_ch_id: '97', enum_usage_generateur_id: 3 });
+    expect(service.pn(ctx, logement, installation, gen)).toBe(24000);
+  });
+
+  test('radiateur gaz : Pn = Pdim (pas de table)', () => {
+    const logement = logementAvecEcs([]);
+    const gen = generateur({ enum_type_generateur_ch_id: '54', enum_usage_generateur_id: 1 });
+    expect(service.pn(ctx, logement, installation, gen)).toBeCloseTo(7837.877241580406, 9);
+  });
+
+  test('installation collective : Pch conservée', () => {
+    const logement = logementAvecEcs([]);
+    const collective = { donnee_entree: { enum_type_installation_id: 2 } };
+    const gen = generateur({ enum_type_generateur_ch_id: '97', enum_usage_generateur_id: 1 });
+    expect(service.pn(ctx, logement, collective, gen)).toBeCloseTo(7837.877241580406, 9);
+  });
+
+  test('volume de stockage du générateur ECS mixte jumeau (reference_generateur_mixte)', () => {
+    const ecs = (reference, volume) => ({
+      donnee_entree: {
+        enum_usage_generateur_id: '3',
+        reference_generateur_mixte: reference,
+        volume_stockage: volume
+      }
+    });
+    const logement = logementAvecEcs([ecs('A', 0), ecs('B', 200)]);
+    expect(service.volumeStockageEcsMixte(logement, { reference_generateur_mixte: 'B' })).toBe(200);
+    expect(service.volumeStockageEcsMixte(logement, {})).toBeUndefined();
+    expect(service.volumeStockageEcsMixte({}, {})).toBeUndefined();
+    expect(
+      service.volumeStockageEcsMixte(
+        { installation_ecs_collection: { installation_ecs: [{}] } },
+        { reference_generateur_mixte: 'B' }
+      )
+    ).toBeUndefined();
+  });
+
+  test('execute : le générateur est transmis à l’estimation de pn', () => {
+    vi.spyOn(service, 'pn').mockReturnValue(24000);
+    vi.spyOn(service, 'caracteristiques').mockReturnValue({});
+    const gen = {
+      donnee_entree: { enum_type_generateur_ch_id: '97', enum_lien_generateur_emetteur_id: 1 },
+      donnee_intermediaire: {}
+    };
+    const inst = {
+      donnee_entree: { enum_type_installation_id: 1 },
+      generateur_chauffage_collection: { generateur_chauffage: [gen] }
+    };
+    const logement = logementAvecEcs([]);
+    service.execute(ctx, logement, inst);
+    expect(service.pn).toHaveBeenCalledWith(ctx, logement, inst, gen);
+    expect(gen.donnee_intermediaire.pn).toBe(24000);
+  });
+});

package/package.json

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