@open3cl/engine 1.8.9 → 1.8.10

package/9_besoin_ch.js

@@ -1,7 +1,11 @@
 import enums from './enums.js';
 import tvs from './tv.js';
 import { calc_besoin_ecs_j } from './11_besoin_ecs.js';
-import { calc_Qrec_gen_j } from './9_generateur_ch.js';
+import {
+  calc_Qrec_gen_ecs_j,
+  calc_Qrec_gen_j,
+  isGenerateurEcsSeulRecuperable
+} from './9_generateur_ch.js';
 import { calc_ai_j, calc_as_j } from './6.1_apport_gratuit.js';
 import { calc_sse_j } from './6.2_surface_sud_equivalente.js';
 import { bug_for_bug_compat, mois_liste } from './utils.js';
@@ -105,6 +109,20 @@ export default function calc_besoin_ch(
     )
   );
 
+  /**
+   * 9.1.1 - Générateurs de la collection ECS assurant l'ECS uniquement, avec Qp0 > 0 et situés en
+   * volume chauffé : leurs pertes de génération sont aussi récupérées pour le chauffage.
+   * Les générateurs 'chauffage + ecs' sont exclus car déjà présents dans la collection chauffage.
+   * @see issue #153
+   *
+   * @type {GenerateurEcsItem[]}
+   */
+  const gen_ecs_recup = instal_ecs.flatMap((inst_ecs) =>
+    (inst_ecs.generateur_ecs_collection?.generateur_ecs || []).filter(
+      isGenerateurEcsSeulRecuperable
+    )
+  );
+
   const besoin_ch_mois = {};
   const besoin_ch_mois_dep = {};
   for (const mois of mois_liste) {
@@ -145,6 +163,13 @@ export default function calc_besoin_ch(
       gen_recup_dep += calc_Qrec_gen_j(gen_ch, nref21, Bch_hp_j_dep) / ratio;
     });
 
+    gen_ecs_recup.forEach((gen_ecs) => {
+      // Même facteur 1000 que pour les générateurs de chauffage (compatibilité « bug for bug »)
+      const ratio = bug_for_bug_compat ? 1000 : 1;
+      gen_recup += calc_Qrec_gen_ecs_j(gen_ecs, nref19) / ratio;
+      gen_recup_dep += calc_Qrec_gen_ecs_j(gen_ecs, nref21) / ratio;
+    });
+
     pertes_generateur_ch_recup += gen_recup;
     pertes_generateur_ch_recup_depensier += gen_recup_dep;
 

package/9_besoin_ch.spec.js

@@ -42,7 +42,9 @@ vi.mock('./11_besoin_ecs.js', () => ({
 }));
 
 vi.mock('./9_generateur_ch.js', () => ({
-  calc_Qrec_gen_j: vi.fn()
+  calc_Qrec_gen_j: vi.fn(),
+  calc_Qrec_gen_ecs_j: vi.fn(),
+  isGenerateurEcsSeulRecuperable: vi.fn()
 }));
 
 const utilState = vi.hoisted(() => ({ bug: false }));
@@ -59,7 +61,8 @@ const { default: tvsBch } = await import('./tv.js');
 const { calc_ai_j, calc_as_j } = await import('./6.1_apport_gratuit.js');
 const { calc_sse_j } = await import('./6.2_surface_sud_equivalente.js');
 const { calc_besoin_ecs_j } = await import('./11_besoin_ecs.js');
-const { calc_Qrec_gen_j } = await import('./9_generateur_ch.js');
+const { calc_Qrec_gen_j, calc_Qrec_gen_ecs_j, isGenerateurEcsSeulRecuperable } =
+  await import('./9_generateur_ch.js');
 
 /**
  * 9. Besoins de chauffage (Bch)
@@ -401,3 +404,149 @@ describe('calc_besoin_ch - branches complémentaires', () => {
     expect(ret.pertes_generateur_ch_recup).toBeCloseTo(1, 9);
   });
 });
+
+/**
+ * 9.1.1 - Pertes récupérées de génération : générateurs de la collection ECS assurant l'ECS
+ * uniquement, avec Qp0 > 0 et en volume chauffé (issue #153).
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §9.1.1
+ */
+describe('calc_besoin_ch - récupération des pertes des générateurs ECS seuls (#153)', () => {
+  const genEcsSeul = {
+    donnee_entree: { enum_usage_generateur_id: '2', position_volume_chauffe: 1 },
+    donnee_intermediaire: { qp0: 100 }
+  };
+  const genEcsMixte = {
+    donnee_entree: { enum_usage_generateur_id: '3', position_volume_chauffe: 1 },
+    donnee_intermediaire: { qp0: 100 }
+  };
+  const instal_ecs = [
+    {
+      donnee_entree: { enum_type_installation_id: '2', rdim: 1 },
+      generateur_ecs_collection: { generateur_ecs: [genEcsSeul, genEcsMixte] }
+    }
+  ];
+
+  beforeEach(() => {
+    utilState.bug = false;
+    vi.mocked(calc_ai_j).mockReset().mockReturnValue(5000);
+    vi.mocked(calc_as_j).mockReset().mockReturnValue(2000);
+    vi.mocked(calc_sse_j).mockReset().mockReturnValue(10);
+    vi.mocked(calc_besoin_ecs_j).mockReset().mockReturnValue(10);
+    vi.mocked(calc_Qrec_gen_j).mockReset().mockReturnValue(0);
+    vi.mocked(calc_Qrec_gen_ecs_j).mockReset();
+    vi.mocked(isGenerateurEcsSeulRecuperable)
+      .mockReset()
+      .mockImplementation((gen) => gen === genEcsSeul);
+  });
+
+  test('seuls les générateurs retenus par isGenerateurEcsSeulRecuperable sont calculés', () => {
+    vi.mocked(calc_Qrec_gen_ecs_j).mockReturnValue(500);
+    calc_besoin_ch(0, 0, 0, 0, 100, 100, 3, instal_ecs, [], [], null, 'maison', 1);
+
+    // un appel conventionnel (nref19 = 100) et un appel dépensier (nref21 = 120) pour le seul mois
+    expect(calc_Qrec_gen_ecs_j).toHaveBeenCalledTimes(2);
+    expect(calc_Qrec_gen_ecs_j).toHaveBeenCalledWith(genEcsSeul, 100);
+    expect(calc_Qrec_gen_ecs_j).toHaveBeenCalledWith(genEcsSeul, 120);
+    expect(calc_Qrec_gen_ecs_j).not.toHaveBeenCalledWith(genEcsMixte, expect.anything());
+  });
+
+  test('la récupération du générateur ECS seul s’ajoute aux pertes récupérées et réduit le besoin', () => {
+    vi.mocked(isGenerateurEcsSeulRecuperable).mockReturnValue(false);
+    const sansRecup = calc_besoin_ch(
+      0,
+      0,
+      0,
+      0,
+      100,
+      100,
+      3,
+      instal_ecs,
+      [],
+      [],
+      null,
+      'maison',
+      1
+    );
+
+    vi.mocked(isGenerateurEcsSeulRecuperable).mockImplementation((gen) => gen === genEcsSeul);
+    vi.mocked(calc_Qrec_gen_ecs_j).mockImplementation((gen, nref) => (nref === 100 ? 500 : 600));
+    const avecRecup = calc_besoin_ch(
+      0,
+      0,
+      0,
+      0,
+      100,
+      100,
+      3,
+      instal_ecs,
+      [],
+      [],
+      null,
+      'maison',
+      1
+    );
+
+    expect(avecRecup.pertes_generateur_ch_recup).toBeCloseTo(500, 9);
+    expect(avecRecup.pertes_generateur_ch_recup_depensier).toBeCloseTo(600, 9);
+    // 500 Wh récupérés => besoin réduit de 0,5 kWh
+    expect(sansRecup.besoin_ch - avecRecup.besoin_ch).toBeCloseTo(0.5, 9);
+    expect(sansRecup.besoin_ch_depensier - avecRecup.besoin_ch_depensier).toBeCloseTo(0.6, 9);
+  });
+
+  test('cumul avec la récupération des générateurs de chauffage', () => {
+    vi.mocked(calc_Qrec_gen_j).mockReturnValue(1000);
+    vi.mocked(calc_Qrec_gen_ecs_j).mockReturnValue(500);
+    const instal_ch = [
+      {
+        generateur_chauffage_collection: {
+          generateur_chauffage: [
+            { donnee_intermediaire: { qp0: 1 }, donnee_entree: { position_volume_chauffe: 1 } }
+          ]
+        }
+      }
+    ];
+    const ret = calc_besoin_ch(
+      0,
+      0,
+      0,
+      0,
+      100,
+      100,
+      3,
+      instal_ecs,
+      instal_ch,
+      [],
+      null,
+      'maison',
+      1
+    );
+    expect(ret.pertes_generateur_ch_recup).toBeCloseTo(1500, 9);
+  });
+
+  test('compatibilité "bug for bug" : même facteur 1000 que pour les générateurs de chauffage', () => {
+    utilState.bug = true;
+    vi.mocked(calc_Qrec_gen_ecs_j).mockReturnValue(500);
+    const ret = calc_besoin_ch(0, 0, 0, 0, 100, 100, 3, instal_ecs, [], [], null, 'maison', 1);
+    expect(ret.pertes_generateur_ch_recup).toBeCloseTo(0.5, 9);
+  });
+
+  test('installation ECS sans générateur : pas de récupération', () => {
+    const ret = calc_besoin_ch(
+      0,
+      0,
+      0,
+      0,
+      100,
+      100,
+      3,
+      [{ donnee_entree: { enum_type_installation_id: '2' }, generateur_ecs_collection: {} }],
+      [],
+      [],
+      null,
+      'maison',
+      1
+    );
+    expect(calc_Qrec_gen_ecs_j).not.toHaveBeenCalled();
+    expect(ret.pertes_generateur_ch_recup).toBe(0);
+  });
+});

package/9_generateur_ch.js

@@ -44,6 +44,52 @@ export function calc_Qrec_gen_j(gen_ch, nrefj, Bch_hp_j) {
   return 0.48 * Cper * di.qp0 * Dperj || 0;
 }
 
+/**
+ * 9.1.1 - Pertes récupérées de génération pour le chauffage sur le mois j (Wh)
+ * pour un générateur de la collection ECS assurant l'ECS uniquement.
+ *
+ * Pour les générateurs assurant l'ECS uniquement :
+ *   Dperj = Nrefj * 1790 / 8760
+ *   Qgen_rec_j = 0,48 * Cper * Qp0 * Dperj
+ *
+ * Seuls les générateurs avec des pertes à l'arrêt (Qp0 > 0), situés en volume chauffé et dont
+ * l'usage est 'ecs' sont concernés. Les générateurs 'chauffage + ecs' sont déjà pris en compte via
+ * la collection des générateurs de chauffage (cf. issue #153).
+ *
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §9.1.1
+ *
+ * @param gen_ecs {GenerateurEcsItem}
+ * @param nrefj {number}
+ * @returns {number}
+ */
+export function calc_Qrec_gen_ecs_j(gen_ecs, nrefj) {
+  const de = gen_ecs.donnee_entree;
+  const di = gen_ecs.donnee_intermediaire || {};
+
+  if (!isGenerateurEcsSeulRecuperable(gen_ecs)) return 0;
+
+  const Cper = Number(de.presence_ventouse) === 1 ? 0.75 : 0.5;
+  return 0.48 * Cper * di.qp0 * pertes_gen_ecs(nrefj);
+}
+
+/**
+ * Un générateur ECS est concerné par la récupération des pertes de génération pour le chauffage
+ * s'il a des pertes à l'arrêt (Qp0 > 0), s'il est en volume chauffé et si son usage est 'ecs' seul
+ * (enum_usage_generateur_id = 2).
+ *
+ * @param gen_ecs {GenerateurEcsItem}
+ * @returns {boolean}
+ */
+export function isGenerateurEcsSeulRecuperable(gen_ecs) {
+  const de = gen_ecs.donnee_entree || {};
+  const di = gen_ecs.donnee_intermediaire || {};
+  return (
+    Number(di.qp0 || 0) > 0 &&
+    Number(de.position_volume_chauffe ?? 0) === 1 &&
+    Number(de.enum_usage_generateur_id) === 2
+  );
+}
+
 function tv_rendement_generation(di, de, du) {
   const matcher = {
     enum_type_generateur_ch_id: requestInputID(de, du, 'type_generateur_ch')

package/9_generateur_ch.spec.js

@@ -59,6 +59,8 @@ vi.mock('./13.2_generateur_combustion.js', () => ({
 
 const {
   calc_Qrec_gen_j,
+  calc_Qrec_gen_ecs_j,
+  isGenerateurEcsSeulRecuperable,
   type_generateur_ch,
   checkForGeneratorType,
   calc_generateur_ch,
@@ -147,6 +149,71 @@ describe('calc_Qrec_gen_j - pertes de génération récupérées', () => {
   });
 });
 
+/**
+ * 9.1.1 Pertes récupérées de génération pour le chauffage : générateur de la collection ECS
+ * assurant l'ECS uniquement (issue #153).
+ * Dperj = Nrefj * 1790 / 8760 ; Qgen_rec_j = 0,48 * Cper * Qp0 * Dperj
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §9.1.1
+ */
+describe('calc_Qrec_gen_ecs_j / isGenerateurEcsSeulRecuperable - générateur ECS seul', () => {
+  /** Générateur ECS seul (usage 2), en volume chauffé, avec Qp0 = 100 W. */
+  function generateurEcs(overridesDe = {}, di = { qp0: 100 }) {
+    return {
+      donnee_entree: {
+        position_volume_chauffe: 1,
+        enum_usage_generateur_id: '2',
+        presence_ventouse: 0,
+        ...overridesDe
+      },
+      donnee_intermediaire: di
+    };
+  }
+
+  test('ECS seul, sans ventouse (Cper = 0.5) : 0.48 * 0.5 * Qp0 * Nref * 1790 / 8760', () => {
+    // 0.48 * 0.5 * 100 * (50 * 1790 / 8760) = 245.205479452...
+    expect(calc_Qrec_gen_ecs_j(generateurEcs(), 50)).toBeCloseTo(245.20547945205482, 9);
+  });
+
+  test('ECS seul, avec ventouse (Cper = 0.75)', () => {
+    // 0.48 * 0.75 * 100 * (50 * 1790 / 8760) = 367.808219178...
+    const gen = generateurEcs({ presence_ventouse: 1 });
+    expect(calc_Qrec_gen_ecs_j(gen, 50)).toBeCloseTo(367.8082191780822, 9);
+  });
+
+  test('la récupération est indépendante du besoin de chauffage et proportionnelle à Nref', () => {
+    const gen = generateurEcs();
+    expect(calc_Qrec_gen_ecs_j(gen, 100)).toBeCloseTo(2 * calc_Qrec_gen_ecs_j(gen, 50), 9);
+  });
+
+  test('générateur hors volume chauffé : aucune récupération', () => {
+    const gen = generateurEcs({ position_volume_chauffe: 0 });
+    expect(isGenerateurEcsSeulRecuperable(gen)).toBe(false);
+    expect(calc_Qrec_gen_ecs_j(gen, 50)).toBe(0);
+  });
+
+  test('position en volume chauffé non renseignée : aucune récupération', () => {
+    const gen = generateurEcs({ position_volume_chauffe: undefined });
+    expect(calc_Qrec_gen_ecs_j(gen, 50)).toBe(0);
+  });
+
+  test("usage 'chauffage + ecs' : exclu (déjà compté dans la collection chauffage)", () => {
+    const gen = generateurEcs({ enum_usage_generateur_id: '3' });
+    expect(isGenerateurEcsSeulRecuperable(gen)).toBe(false);
+    expect(calc_Qrec_gen_ecs_j(gen, 50)).toBe(0);
+  });
+
+  test('Qp0 nul ou absent : aucune récupération', () => {
+    expect(calc_Qrec_gen_ecs_j(generateurEcs({}, { qp0: 0 }), 50)).toBe(0);
+    expect(calc_Qrec_gen_ecs_j(generateurEcs({}, null), 50)).toBe(0);
+    expect(isGenerateurEcsSeulRecuperable({})).toBe(false);
+  });
+
+  test('identifiants numériques acceptés (usage 2, position 1)', () => {
+    const gen = generateurEcs({ enum_usage_generateur_id: 2, position_volume_chauffe: '1' });
+    expect(isGenerateurEcsSeulRecuperable(gen)).toBe(true);
+  });
+});
+
 /**
  * Détermination du type de générateur exploitable pour un usage donné.
  */

package/README.md

@@ -377,19 +377,19 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 <tr>
 <td align="center"><strong>9</strong><br/><sub>corpus</sub></td>
 <td align="center"><strong>89 990</strong><br/><sub>DPE analysés</sub></td>
-<td align="center"><strong>59 757</strong><br/><sub>DPE conformes</sub></td>
-<td align="center"><strong>66,40 %</strong><br/><sub>réussite globale</sub></td>
+<td align="center"><strong>59 879</strong><br/><sub>DPE conformes</sub></td>
+<td align="center"><strong>66,54 %</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,23 %** | `█████████░░░░░░░░░░░` | 4 623 / 10 000 |
-| 🟢  | **Appartement · chauffage individuel (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_individuel_2025.csv`</sub> | **91,76 %** | `██████████████████░░` | 9 176 / 10 000 |
-| 🟢  | **Logement individuel (2025)**<br/><sub>`dpe_logement_individuel_2025.csv`</sub>                                        | **88,41 %** | `██████████████████░░` |  8 834 / 9 992 |
+| 🔴  | **Généraliste**<br/><sub>`corpus_dpe.csv`</sub>                                                                         | **46,28 %** | `█████████░░░░░░░░░░░` | 4 628 / 10 000 |
+| 🟢  | **Appartement · chauffage individuel (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_individuel_2025.csv`</sub> | **91,80 %** | `██████████████████░░` | 9 180 / 10 000 |
+| 🟢  | **Logement individuel (2025)**<br/><sub>`dpe_logement_individuel_2025.csv`</sub>                                        | **88,70 %** | `██████████████████░░` |  8 863 / 9 992 |
 | 🟢  | **Maison individuelle (2025)**<br/><sub>`dpe_maison_individuelle_2025.csv`</sub>                                        | **88,40 %** | `██████████████████░░` | 8 840 / 10 000 |
 | 🟡  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **74,14 %** | `███████████████░░░░░` |  7 413 / 9 999 |
-| 🟡  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **69,77 %** | `██████████████░░░░░░` | 6 977 / 10 000 |
+| 🟡  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **70,61 %** | `██████████████░░░░░░` | 7 061 / 10 000 |
 | 🟡  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **62,50 %** | `████████████░░░░░░░░` |  6 249 / 9 999 |
 | 🔴  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **49,06 %** | `██████████░░░░░░░░░░` | 4 906 / 10 000 |
 | 🔴  | **Individuel généré depuis l'immeuble (2026)**<br/><sub>`dpe_individuel_a_partir_dpe_immeuble_2026.csv`</sub>           | **27,39 %** | `█████░░░░░░░░░░░░░░░` | 2 739 / 10 000 |
@@ -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>4,74 ms</strong><br/><sub>moyenne</sub></td>
-<td align="center"><strong>4,14 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>480,3 ms</strong><br/><sub>max</sub></td>
+<td align="center"><strong>5,31 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>4,65 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>893,4 ms</strong><br/><sub>max</sub></td>
 </tr>
 </table>
 
 | Corpus                                         | Moyenne | Médiane |     Min |      Max |     p95 |     p99 |
 | :--------------------------------------------- | ------: | ------: | ------: | -------: | ------: | ------: |
-| **Généraliste**                                | 4,07 ms | 3,66 ms | 0,21 ms |  29,4 ms | 7,48 ms | 10,1 ms |
-| **Appartement · chauffage individuel (2025)**  | 3,58 ms | 3,27 ms | 1,22 ms |  23,6 ms | 6,14 ms | 7,97 ms |
-| **Logement individuel (2025)**                 | 4,62 ms | 4,06 ms | 1,45 ms |  35,7 ms | 8,83 ms | 12,5 ms |
-| **Maison individuelle (2025)**                 | 5,74 ms | 5,21 ms | 1,74 ms |  49,6 ms | 10,4 ms | 13,7 ms |
-| **Immeuble · chauffage individuel**            | 5,70 ms | 4,84 ms | 0,11 ms |  73,3 ms | 11,6 ms | 17,9 ms |
-| **Appartement · chauffage collectif (2025)**   | 4,07 ms | 3,70 ms | 1,30 ms |  30,5 ms | 6,90 ms | 10,3 ms |
-| **Immeuble · chauffage collectif**             | 4,90 ms | 4,11 ms | 0,12 ms | 101,4 ms | 9,06 ms | 15,4 ms |
-| **Immeuble · chauffage mixte**                 | 4,60 ms | 3,75 ms | 0,19 ms | 480,3 ms | 9,46 ms | 15,9 ms |
-| **Individuel généré depuis l'immeuble (2026)** | 5,38 ms | 4,62 ms | 1,56 ms |  41,0 ms | 10,3 ms | 15,8 ms |
+| **Généraliste**                                | 4,56 ms | 4,09 ms | 0,21 ms |  37,2 ms | 8,41 ms | 12,0 ms |
+| **Appartement · chauffage individuel (2025)**  | 4,01 ms | 3,65 ms | 1,47 ms |  33,8 ms | 6,95 ms | 9,38 ms |
+| **Logement individuel (2025)**                 | 4,98 ms | 4,43 ms | 1,62 ms |  38,0 ms | 9,30 ms | 12,8 ms |
+| **Maison individuelle (2025)**                 | 5,92 ms | 5,33 ms | 1,85 ms |  40,3 ms | 10,6 ms | 13,7 ms |
+| **Immeuble · chauffage individuel**            | 6,70 ms | 5,72 ms | 0,13 ms | 136,8 ms | 13,4 ms | 22,2 ms |
+| **Appartement · chauffage collectif (2025)**   | 4,60 ms | 4,36 ms | 1,46 ms |  37,2 ms | 7,27 ms | 9,45 ms |
+| **Immeuble · chauffage collectif**             | 5,31 ms | 4,38 ms | 0,12 ms |  99,5 ms | 9,95 ms | 17,7 ms |
+| **Immeuble · chauffage mixte**                 | 5,38 ms | 4,34 ms | 0,20 ms | 893,4 ms | 11,2 ms | 18,5 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 6,36 ms | 5,53 ms | 1,67 ms |  50,2 ms | 12,4 ms | 19,1 ms |
 
 <sub>La moyenne est tirée vers le haut par les DPE collectifs, dont le coût atteint plusieurs
 dizaines de fois la médiane : c’est la médiane qui décrit le cas courant, et p95/p99 le cas

package/engine.js

@@ -33,7 +33,7 @@ import getFicheTechnique from './ficheTechnique.js';
 import { ProductionENR } from './16.2_production_enr.js';
 import DpeSanitizerService from './dpe-sanitizer.service.js';
 
-const LIB_VERSION = '1.8.9';
+const LIB_VERSION = '1.8.10';
 
 const dpeSanitizerService = new DpeSanitizerService();
 

package/features/engine/domain/apport_et_besoin/ch/perte-ch-recup.service.js

@@ -52,27 +52,73 @@ export class PerteChRecupService {
    */
   pertesGenerateurChRecup(ctx, logement, depensier) {
     const generateursWithPertesGeneration = this.generateursWithPertesGeneration(logement);
+    const generateursEcsSeulsWithPertesGeneration =
+      this.generateursEcsSeulsWithPertesGeneration(logement);
 
     return mois_liste.reduce((acc, mois) => {
+      const nref = this.#tvStore.getData(
+        depensier ? 'nref21' : 'nref19',
+        ctx.altitude.value,
+        ctx.zoneClimatique.value,
+        mois,
+        ctx.inertie.ilpa
+      );
       return (
         acc +
         this.Qrec(
           generateursWithPertesGeneration,
-          this.#tvStore.getData(
-            depensier ? 'nref21' : 'nref19',
-            ctx.altitude.value,
-            ctx.zoneClimatique.value,
-            mois,
-            ctx.inertie.ilpa
-          ),
+          nref,
           depensier
             ? logement.donnees_de_calcul.besoinChauffageDepensierHP[mois]
             : logement.donnees_de_calcul.besoinChauffageHP[mois]
-        )
+        ) +
+        this.QrecEcsSeul(generateursEcsSeulsWithPertesGeneration, nref)
       );
     }, 0);
   }
 
+  /**
+   * Générateurs de la collection ECS assurant l'ECS uniquement dont les pertes de génération sont
+   * récupérées pour le chauffage (issue #153) :
+   * — pertes à l'arrêt Qp0 > 0
+   * — situés en volume chauffé
+   * — usage ECS uniquement (enum_usage_generateur_id = 2). Les générateurs 'chauffage + ecs' sont
+   *   déjà pris en compte dans la collection des générateurs de chauffage.
+   *
+   * @param logement {Logement}
+   * @return {GenerateurEcs[]}
+   */
+  generateursEcsSeulsWithPertesGeneration(logement) {
+    const installationsEcs = logement.installation_ecs_collection?.installation_ecs || [];
+
+    return installationsEcs.flatMap((installation) =>
+      (installation.generateur_ecs_collection?.generateur_ecs || []).filter((generateurEcs) => {
+        const generateurEcsDE = generateurEcs.donnee_entree || {};
+        const generateurEcsDI = generateurEcs.donnee_intermediaire || {};
+        return (
+          Number(generateurEcsDI.qp0 || 0) > 0 &&
+          Number(generateurEcsDE.position_volume_chauffe ?? 0) === 1 &&
+          parseInt(generateurEcsDE.enum_usage_generateur_id) === 2
+        );
+      })
+    );
+  }
+
+  /**
+   * Pertes récupérées de génération pour le chauffage sur le mois j (Wh) pour les générateurs
+   * assurant l'ECS uniquement : Dperj = Nrefj * 1790 / 8760
+   *
+   * @param generateurs {GenerateurEcs[]}
+   * @param nref {number}
+   * @return {number}
+   */
+  QrecEcsSeul(generateurs, nref) {
+    return generateurs.reduce((acc, generateur) => {
+      const Cper = Number(generateur.donnee_entree.presence_ventouse || 0) === 1 ? 0.75 : 0.5;
+      return acc + 0.48 * Cper * generateur.donnee_intermediaire.qp0 * this.#pertes_gen_ecs(nref);
+    }, 0);
+  }
+
   /**
    * Pertes récupérées des générateurs de chauffage pour le chauffage
    * 9.1.1 Consommation de chauffage

package/features/engine/domain/apport_et_besoin/ch/perte-ch-recup.service.spec.js

@@ -0,0 +1,185 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
+import { PerteChRecupService } from './perte-ch-recup.service.js';
+import { mois_liste } from '../../../../../utils.js';
+
+/** @type {PerteChRecupService} **/
+let service;
+
+/** @type {FrTvStore} **/
+let tvStore;
+
+/**
+ * 9.1.1 Pertes récupérées de génération pour le chauffage
+ * Qgen_rec_j = 0,48 * Cper * Qp0 * Dperj
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §9.1.1
+ */
+describe('Calcul des pertes récupérées de génération pour le chauffage', () => {
+  /** @type {Contexte} */
+  const ctx = {
+    altitude: { value: '400-800m' },
+    zoneClimatique: { value: 'h1a' },
+    inertie: { ilpa: 0 }
+  };
+
+  /** Besoins de chauffage hors pertes (kWh) : 10 kWh par mois */
+  const donneesDeCalcul = {
+    besoinChauffageHP: Object.fromEntries(mois_liste.map((m) => [m, 10])),
+    besoinChauffageDepensierHP: Object.fromEntries(mois_liste.map((m) => [m, 12]))
+  };
+
+  /** Générateur ECS seul (usage 2), en volume chauffé, Qp0 = 100 W */
+  function generateurEcs(de = {}, di = { qp0: 100 }) {
+    return {
+      donnee_entree: {
+        enum_usage_generateur_id: 2,
+        position_volume_chauffe: 1,
+        presence_ventouse: 0,
+        ...de
+      },
+      donnee_intermediaire: di
+    };
+  }
+
+  /** Logement avec une installation ECS et, optionnellement, des générateurs de chauffage */
+  function logement(generateursEcs = [], generateursCh = []) {
+    return {
+      donnees_de_calcul: donneesDeCalcul,
+      installation_ecs_collection: {
+        installation_ecs: [{ generateur_ecs_collection: { generateur_ecs: generateursEcs } }]
+      },
+      installation_chauffage_collection: {
+        installation_chauffage: [
+          { generateur_chauffage_collection: { generateur_chauffage: generateursCh } }
+        ]
+      }
+    };
+  }
+
+  beforeEach(() => {
+    tvStore = new FrTvStore();
+    service = new PerteChRecupService(tvStore);
+    // Nref constant : 100 h (conventionnel) / 120 h (dépensier) pour chacun des 12 mois
+    vi.spyOn(tvStore, 'getData').mockImplementation((type) => (type === 'nref21' ? 120 : 100));
+  });
+
+  describe('Générateurs ECS assurant l’ECS uniquement (issue #153)', () => {
+    test('ECS seul sans ventouse : 0,48 * 0,5 * Qp0 * Nref * 1790 / 8760 par mois', () => {
+      const result = service.execute(ctx, logement([generateurEcs()]));
+
+      // 12 * 0.48 * 0.5 * 100 * (100 * 1790 / 8760) / 1000 = 5.884931506... kWh
+      expect(result.pertes_generateur_ch_recup).toBeCloseTo(5.884931506849315, 9);
+      // 12 * 0.48 * 0.5 * 100 * (120 * 1790 / 8760) / 1000 = 7.061917808... kWh
+      expect(result.pertes_generateur_ch_recup_depensier).toBeCloseTo(7.061917808219178, 9);
+    });
+
+    test('ECS seul avec ventouse : Cper = 0,75', () => {
+      const result = service.execute(ctx, logement([generateurEcs({ presence_ventouse: 1 })]));
+      expect(result.pertes_generateur_ch_recup).toBeCloseTo(1.5 * 5.884931506849315, 9);
+    });
+
+    test.each([
+      { cas: 'hors volume chauffé', de: { position_volume_chauffe: 0 }, di: { qp0: 100 } },
+      {
+        cas: 'position non renseignée',
+        de: { position_volume_chauffe: undefined },
+        di: { qp0: 100 }
+      },
+      {
+        cas: "usage 'chauffage + ecs' (déjà compté)",
+        de: { enum_usage_generateur_id: 3 },
+        di: { qp0: 100 }
+      },
+      { cas: 'Qp0 nul', de: {}, di: { qp0: 0 } },
+      { cas: 'Qp0 absent', de: {}, di: null }
+    ])('pas de récupération pour un générateur ECS $cas', ({ de, di }) => {
+      const result = service.execute(ctx, logement([generateurEcs(de, di)]));
+      expect(result.pertes_generateur_ch_recup).toBe(0);
+      expect(result.pertes_generateur_ch_recup_depensier).toBe(0);
+    });
+
+    test('logement sans installation ECS ni chauffage : aucune récupération', () => {
+      const result = service.execute(ctx, { donnees_de_calcul: donneesDeCalcul });
+      expect(result.pertes_generateur_ch_recup).toBe(0);
+    });
+
+    test('installation ECS sans collection de générateurs : aucune récupération', () => {
+      const result = service.execute(ctx, {
+        donnees_de_calcul: donneesDeCalcul,
+        installation_ecs_collection: { installation_ecs: [{}] }
+      });
+      expect(result.pertes_generateur_ch_recup).toBe(0);
+    });
+  });
+
+  describe('Générateurs de chauffage', () => {
+    /** Générateur de chauffage en volume chauffé, Pn = 10 000 W, Qp0 = 100 W */
+    function generateurCh(de = {}) {
+      return {
+        donnee_entree: {
+          position_volume_chauffe: 1,
+          enum_type_generateur_ch_id: 85,
+          enum_usage_generateur_id: 1,
+          ...de
+        },
+        donnee_intermediaire: { pn: 10000, qp0: 100 }
+      };
+    }
+
+    test('usage chauffage : Dperj = min(Nref, 1,3 * Bch / (0,3 * Pn))', () => {
+      const result = service.execute(ctx, logement([], [generateurCh()]));
+      // Dperj = min(100, 1.3 * 10 * 1000 / 3000) = 4.333.. h
+      // 12 * 0.48 * 0.5 * 100 * 4.333.. / 1000 = 1.248 kWh
+      expect(result.pertes_generateur_ch_recup).toBeCloseTo(1.248, 9);
+    });
+
+    test('usage ECS : Dperj = Nref * 1790 / 8760', () => {
+      const result = service.execute(
+        ctx,
+        logement([], [generateurCh({ enum_usage_generateur_id: 2 })])
+      );
+      expect(result.pertes_generateur_ch_recup).toBeCloseTo(5.884931506849315, 9);
+    });
+
+    test('usage chauffage + ECS avec ventouse : cumul des deux durées, Cper = 0,75', () => {
+      const result = service.execute(
+        ctx,
+        logement([], [generateurCh({ enum_usage_generateur_id: 3, presence_ventouse: 1 })])
+      );
+      // Dperj = min(100, 4.333.. + 20.4337..) ; 12 * 0.48 * 0.75 * 100 * Dperj / 1000
+      expect(result.pertes_generateur_ch_recup).toBeCloseTo(10.699397260273972, 9);
+    });
+
+    test.each([
+      { cas: 'hors volume chauffé', de: { position_volume_chauffe: 0 } },
+      { cas: 'à air chaud (50)', de: { enum_type_generateur_ch_id: 50 } },
+      { cas: 'à air chaud (52)', de: { enum_type_generateur_ch_id: 52 } }
+    ])('pas de récupération pour un générateur de chauffage $cas', ({ de }) => {
+      const result = service.execute(ctx, logement([], [generateurCh(de)]));
+      expect(result.pertes_generateur_ch_recup).toBe(0);
+    });
+
+    test('installation de chauffage sans collection de générateurs : aucune récupération', () => {
+      const result = service.execute(ctx, {
+        donnees_de_calcul: donneesDeCalcul,
+        installation_chauffage_collection: { installation_chauffage: [{}] }
+      });
+      expect(result.pertes_generateur_ch_recup).toBe(0);
+    });
+
+    test('cumul générateur de chauffage + générateur ECS seul', () => {
+      const result = service.execute(ctx, logement([generateurEcs()], [generateurCh()]));
+      expect(result.pertes_generateur_ch_recup).toBeCloseTo(1.248 + 5.884931506849315, 9);
+    });
+
+    test('un générateur ECS mixte (usage 3) n’est pas compté deux fois', () => {
+      const ch = generateurCh({ enum_usage_generateur_id: 3 });
+      const seul = service.execute(ctx, logement([], [ch]));
+      const avecEcsMixte = service.execute(
+        ctx,
+        logement([generateurEcs({ enum_usage_generateur_id: 3 })], [ch])
+      );
+      expect(avecEcsMixte.pertes_generateur_ch_recup).toBe(seul.pertes_generateur_ch_recup);
+    });
+  });
+});

package/package.json

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