@open3cl/engine 1.6.1 → 1.6.2

package/13.2_generateur_combustion_bouilleur.spec.js

@@ -0,0 +1,74 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+
+/**
+ * Dépendance mockée : `getFicheTechnique` (import par défaut), qui fournit l'année
+ * d'installation du poêle bouilleur. On contrôle sa valeur de retour uniquement.
+ */
+vi.mock('./ficheTechnique.js', () => ({
+  default: vi.fn()
+}));
+
+const { updateGenerateurBouilleurs } = await import('./13.2_generateur_combustion_bouilleur.js');
+const { default: getFicheTechnique } = await import('./ficheTechnique.js');
+
+beforeEach(() => {
+  vi.mocked(getFicheTechnique).mockReset();
+});
+
+/**
+ * 13.1 - Les poêles à bois bouilleur sont assimilés à des chaudières bois de la
+ * période correspondante.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.1
+ */
+describe('updateGenerateurBouilleurs - substitution par une chaudière bois équivalente', () => {
+  test('type non concerné : aucune substitution', () => {
+    getFicheTechnique.mockReturnValue(undefined);
+    const de = { enum_type_generateur_ch_id: '90' };
+    updateGenerateurBouilleurs({}, de, 'ch');
+    expect(de.enum_type_generateur_ch_id).toBe('90');
+  });
+
+  test('sans fiche technique : période par défaut 2004-2012 (ch, bûche 48 -> 58)', () => {
+    getFicheTechnique.mockReturnValue(undefined);
+    const de = { enum_type_generateur_ch_id: '48' };
+    updateGenerateurBouilleurs({}, de, 'ch');
+    // Valeur par défaut : chaudière bois 2004-2012 (values[2004])
+    expect(de.enum_type_generateur_ch_id).toBe('58');
+  });
+
+  test('fiche "avant 1948" : chaudière bois la plus ancienne (ch, bûche 48 -> 55)', () => {
+    getFicheTechnique.mockReturnValue({ valeur: 'avant 1948' });
+    const de = { enum_type_generateur_ch_id: '48' };
+    updateGenerateurBouilleurs({}, de, 'ch');
+    expect(de.enum_type_generateur_ch_id).toBe('55');
+  });
+
+  test.each([
+    ['2020', '61'], // >= 2019
+    ['2018', '60'], // >= 2018
+    ['2015', '59'], // >= 2013
+    ['2005', '58'], // >= 2004
+    ['1996', '57'], // >= 1995
+    ['1980', '56'], // >= 1978
+    ['1950', '55'] // >= 1948
+  ])('année %s : seuil de période appliqué (ch, bûche 48 -> %s)', (annee, attendu) => {
+    getFicheTechnique.mockReturnValue({ valeur: annee });
+    const de = { enum_type_generateur_ch_id: '48' };
+    updateGenerateurBouilleurs({}, de, 'ch');
+    expect(de.enum_type_generateur_ch_id).toBe(attendu);
+  });
+
+  test('type ECS (granulés 115) : utilise la table ECS des chaudières bois', () => {
+    getFicheTechnique.mockReturnValue({ valeur: '2016' });
+    const de = { enum_type_generateur_ecs_id: '115' };
+    updateGenerateurBouilleurs({}, de, 'ecs');
+    // granulés ECS : 2013->33 ; 2016 >= 2013 => 33
+    expect(de.enum_type_generateur_ecs_id).toBe('33');
+  });
+
+  test("la fiche technique est interrogée pour un 'bouilleur' dans le domaine '7'", () => {
+    getFicheTechnique.mockReturnValue({ valeur: '2000' });
+    updateGenerateurBouilleurs({}, { enum_type_generateur_ch_id: '48' }, 'ch');
+    expect(getFicheTechnique).toHaveBeenCalledWith({}, '7', 'année', ['bouilleur']);
+  });
+});

package/13.2_generateur_combustion_ch.spec.js

@@ -0,0 +1,323 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+
+/**
+ * Dépendances mockées pour isoler la logique de calcul :
+ * - `enums` (import par défaut) : mapping type de générateur / type d'énergie, qui
+ *   sélectionne la branche de calcul du rendement et le coefficient K ;
+ * - `tv` : accès aux tables temp_fonc_30 / temp_fonc_100 (lignes contrôlées) ;
+ * - `requestInput` / `requestInputID` : passe-plats vers les données d'entrée ;
+ * - `bug_for_bug_compat` : désactivé pour isoler le comportement nominal.
+ */
+const state = vi.hoisted(() => ({ bug: false }));
+
+vi.mock('./enums.js', () => ({
+  default: {
+    type_generateur_ch: {
+      89: 'chaudière gaz standard 2001-2015',
+      55: 'chaudière bois bûche avant 1978',
+      96: 'chaudière gaz à condensation 2001-2015',
+      70: 'chaudière gaz basse température 2001-2015',
+      12: 'radiateur à gaz',
+      33: 'générateur à air chaud',
+      99: 'type de générateur inconnu'
+    },
+    type_energie: {
+      2: 'gaz naturel',
+      4: 'bois – bûches'
+    }
+  }
+}));
+
+vi.mock('./utils.js', () => ({
+  get bug_for_bug_compat() {
+    return state.bug;
+  },
+  tv: vi.fn(),
+  requestInput: vi.fn((de, du, field) => de[field]),
+  requestInputID: vi.fn((de, du, field) => de[`enum_${field}_id`])
+}));
+
+const { tv_temp_fonc_30_100, calc_generateur_combustion_ch } = await import(
+  './13.2_generateur_combustion_ch.js'
+);
+const { tv } = await import('./utils.js');
+
+beforeEach(() => {
+  vi.mocked(tv).mockReset();
+  state.bug = false;
+});
+
+/**
+ * 13.2.1.1 - Températures de fonctionnement à 30 % et 100 % de charge.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.1.1
+ */
+describe('tv_temp_fonc_30_100 - températures de fonctionnement', () => {
+  function emetteur(overrides = {}) {
+    return {
+      donnee_entree: {
+        enum_temp_distribution_ch_id: '3',
+        ...overrides
+      },
+      donnee_utilisateur: {}
+    };
+  }
+
+  test('les températures forfaitaires trouvées sont recopiées dans les données intermédiaires', () => {
+    tv.mockImplementation((table) =>
+      table === 'temp_fonc_30'
+        ? { tv_temp_fonc_30_id: '5', temp_fonc_30: '40' }
+        : { tv_temp_fonc_100_id: '6', temp_fonc_100: '70' }
+    );
+    const di = {};
+    const de = { enum_type_generateur_ch_id: '89' };
+    tv_temp_fonc_30_100(di, de, {}, [emetteur()], 1975);
+    expect(di.temp_fonc_30).toBe(40);
+    expect(di.temp_fonc_100).toBe(70);
+    expect(de.tv_temp_fonc_30_id).toBe('5');
+    expect(de.tv_temp_fonc_100_id).toBe('6');
+  });
+
+  test.each([
+    [1975, 'avant 1981'],
+    [1990, 'entre 1981 et 2000'],
+    [2010, 'après 2000']
+  ])("période des émetteurs déduite de l'année de construction %s : %s", (ac, periodeAttendue) => {
+    tv.mockReturnValue({ tv_temp_fonc_30_id: '1', temp_fonc_30: '40' });
+    tv_temp_fonc_30_100({}, { enum_type_generateur_ch_id: '89' }, {}, [emetteur()], ac);
+    expect(tv).toHaveBeenCalledWith(
+      'temp_fonc_30',
+      expect.objectContaining({ periode_emetteurs: periodeAttendue })
+    );
+  });
+
+  test('conserve la température la plus élevée entre plusieurs émetteurs', () => {
+    tv.mockImplementation((table, matcher) => {
+      if (table !== 'temp_fonc_30') return null;
+      // Le premier émetteur renvoie 40, le second 55
+      return matcher.enum_temp_distribution_ch_id === '3'
+        ? { tv_temp_fonc_30_id: 'a', temp_fonc_30: '40' }
+        : { tv_temp_fonc_30_id: 'b', temp_fonc_30: '55' };
+    });
+    const di = {};
+    tv_temp_fonc_30_100(
+      di,
+      { enum_type_generateur_ch_id: '89' },
+      {},
+      [emetteur(), emetteur({ enum_temp_distribution_ch_id: '4' })],
+      1975
+    );
+    expect(di.temp_fonc_30).toBe(55);
+  });
+
+  test('conserve la température à 100 % la plus élevée entre plusieurs émetteurs', () => {
+    tv.mockImplementation((table, matcher) => {
+      if (table !== 'temp_fonc_100') return null;
+      return matcher.enum_temp_distribution_ch_id === '3'
+        ? { tv_temp_fonc_100_id: 'a', temp_fonc_100: '60' }
+        : { tv_temp_fonc_100_id: 'b', temp_fonc_100: '75' };
+    });
+    const di = {};
+    tv_temp_fonc_30_100(
+      di,
+      { enum_type_generateur_ch_id: '89' },
+      {},
+      [emetteur(), emetteur({ enum_temp_distribution_ch_id: '4' })],
+      1975
+    );
+    // La comparaison `>` conserve la plus grande des deux valeurs
+    expect(di.temp_fonc_100).toBe(75);
+  });
+
+  test('aucune ligne forfaitaire trouvée : erreurs signalées pour temp_fonc_30 et temp_fonc_100', () => {
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    tv.mockReturnValue(null);
+    const di = {};
+    tv_temp_fonc_30_100(di, { enum_type_generateur_ch_id: '89' }, {}, [emetteur()], 1975);
+    expect(di.temp_fonc_30).toBeUndefined();
+    expect(di.temp_fonc_100).toBeUndefined();
+    expect(errSpy).toHaveBeenCalledTimes(2);
+    errSpy.mockRestore();
+  });
+});
+
+/**
+ * 13.2.1.2 - Rendement de génération des chaudières (rg PCI).
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.1.2
+ */
+describe('calc_generateur_combustion_ch - rendement de génération', () => {
+  test('chaudière gaz standard : rendement PCI et rendement dépensier', () => {
+    const di = { pn: 25000, rpn: 0.9, rpint: 0.85, qp0: 200, temp_fonc_30: 40, temp_fonc_100: 70 };
+    const de = {
+      enum_type_generateur_ch_id: '89',
+      enum_type_energie_id: '2',
+      type_energie: 'gaz naturel',
+      presence_regulation_combustion: false,
+      description: 't'
+    };
+    calc_generateur_combustion_ch({}, di, de, { cdimref: 0.8, cdimrefDep: 0.6 });
+    // valeurs de référence de régression (module réel, enums réels équivalents)
+    expect(di.rg).toBeCloseTo(0.8582190936918361, 9);
+    expect(di.rg_dep).toBeCloseTo(0.8706053178411902, 9);
+    expect(di.rendement_generation).toBeCloseTo(0.8582190936918361, 9);
+  });
+
+  test('chaudière bois : branche de calcul dédiée (QP50 / QP100)', () => {
+    const di = { pn: 30000, rpn: 0.75, rpint: 0.7, qp0: 300, temp_fonc_30: 40, temp_fonc_100: 70 };
+    const de = {
+      enum_type_generateur_ch_id: '55',
+      enum_type_energie_id: '4',
+      type_energie: 'bois – bûches',
+      description: 't'
+    };
+    calc_generateur_combustion_ch({}, di, de, { cdimref: 0.9, cdimrefDep: 0.7 });
+    // valeurs de référence de régression
+    expect(di.rg).toBeCloseTo(0.7044775930164003, 9);
+    expect(di.rg_dep).toBeCloseTo(0.7138933157828895, 9);
+  });
+
+  test('chaudière à condensation avec régulation : température de fonctionnement à 30 % utilisée', () => {
+    const di = { pn: 25000, rpn: 0.95, rpint: 0.92, qp0: 150, temp_fonc_30: 35, temp_fonc_100: 70 };
+    const de = {
+      enum_type_generateur_ch_id: '96',
+      enum_type_energie_id: '2',
+      type_energie: 'gaz naturel',
+      presence_regulation_combustion: true,
+      description: 't'
+    };
+    calc_generateur_combustion_ch({}, di, de, { cdimref: 0.8, cdimrefDep: 0.6 });
+    // valeurs de référence de régression
+    expect(di.rg).toBeCloseTo(0.9281152399114512, 9);
+    expect(di.rg_dep).toBeCloseTo(0.9344861707155592, 9);
+  });
+
+  test('radiateur à gaz : branche de calcul dédiée', () => {
+    const di = { pn: 20000, rpn: 0.9, rpint: 0.85, qp0: 200, temp_fonc_30: 40, temp_fonc_100: 70 };
+    const de = {
+      enum_type_generateur_ch_id: '12',
+      enum_type_energie_id: '2',
+      type_energie: 'gaz naturel',
+      presence_regulation_combustion: false,
+      description: 't'
+    };
+    calc_generateur_combustion_ch({}, di, de, { cdimref: 0.8, cdimrefDep: 0.6 });
+    // valeurs de référence de régression
+    expect(di.rg).toBeCloseTo(0.8851321252668564, 9);
+    expect(di.rg_dep).toBeCloseTo(0.8869221230591896, 9);
+  });
+
+  test('générateur à air chaud : branche de calcul dédiée', () => {
+    const di = { pn: 20000, rpn: 0.9, rpint: 0.85, qp0: 200, temp_fonc_30: 40, temp_fonc_100: 70 };
+    const de = {
+      enum_type_generateur_ch_id: '33',
+      enum_type_energie_id: '2',
+      type_energie: 'gaz naturel',
+      presence_regulation_combustion: false,
+      description: 't'
+    };
+    calc_generateur_combustion_ch({}, di, de, { cdimref: 0.8, cdimrefDep: 0.6 });
+    // valeurs de référence de régression
+    expect(di.rg).toBeCloseTo(0.8655833354015402, 9);
+    expect(di.rg_dep).toBeCloseTo(0.8746954076850985, 9);
+  });
+
+  test('chaudière basse température : coefficients dédiés (a = 0.1, b = 40)', () => {
+    const di = { pn: 20000, rpn: 0.9, rpint: 0.85, qp0: 200, temp_fonc_30: 40, temp_fonc_100: 70 };
+    const de = {
+      enum_type_generateur_ch_id: '70',
+      enum_type_energie_id: '2',
+      type_energie: 'gaz naturel',
+      presence_regulation_combustion: false,
+      description: 't'
+    };
+    calc_generateur_combustion_ch({}, di, de, { cdimref: 0.8, cdimrefDep: 0.6 });
+    // valeurs de référence de régression
+    expect(di.rg).toBeCloseTo(0.8513271171577527, 9);
+    expect(di.rg_dep).toBeCloseTo(0.8655664711109103, 9);
+  });
+
+  test('type de générateur inconnu : aucun rendement calculé (avertissement)', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const di = { pn: 20000, rpn: 0.9, rpint: 0.85, qp0: 200, temp_fonc_30: 40, temp_fonc_100: 70 };
+    const de = {
+      enum_type_generateur_ch_id: '99',
+      enum_type_energie_id: '2',
+      type_energie: 'gaz naturel',
+      description: 't'
+    };
+    calc_generateur_combustion_ch({}, di, de, { cdimref: 0.8, cdimrefDep: 0.6 });
+    // QPx renvoie undefined pour un type non reconnu -> rendement NaN
+    expect(Number.isNaN(di.rg)).toBe(true);
+    expect(warnSpy).toHaveBeenCalled();
+    warnSpy.mockRestore();
+  });
+
+  test('cdimref absent (du vide) : valeur de repli 0 -> Tch_xfinal saturé à 1', () => {
+    const di = { pn: 20000, rpn: 0.9, rpint: 0.85, qp0: 200, temp_fonc_30: 40, temp_fonc_100: 70 };
+    const de = {
+      enum_type_generateur_ch_id: '89',
+      enum_type_energie_id: '2',
+      type_energie: 'gaz naturel',
+      presence_regulation_combustion: false,
+      description: 't'
+    };
+    calc_generateur_combustion_ch({}, di, de, {});
+    // Cdimref = 0 -> x/0 = Infinity -> min(1, ...) = 1 pour tous les x, nominal = dépensier
+    expect(di.rg).toBeCloseTo(0.8967281540325838, 9);
+    expect(di.rg_dep).toBeCloseTo(0.8967281540325838, 9);
+  });
+
+  test('bug_for_bug_compat : correction de qp0 exprimé en kW (< 1) vers des W', () => {
+    state.bug = true;
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const di = { pn: 20000, rpn: 0.9, rpint: 0.85, qp0: 0.2, temp_fonc_30: 40, temp_fonc_100: 70 };
+    const de = {
+      enum_type_generateur_ch_id: '89',
+      enum_type_energie_id: '2',
+      type_energie: 'gaz naturel',
+      presence_regulation_combustion: false,
+      description: 't'
+    };
+    calc_generateur_combustion_ch({}, di, de, { cdimref: 0.8, cdimrefDep: 0.6 });
+    // qp0 < 1 -> multiplié par 1000 => 200 (passage kW -> W)
+    expect(di.qp0).toBe(200);
+    // valeur de référence de régression (chaudière standard, pn = 20000, qp0 corrigé à 200)
+    expect(di.rg).toBeCloseTo(0.8566147558351076, 9);
+    warnSpy.mockRestore();
+  });
+
+  test('la présence de régulation modifie le rendement (tf30 vs tf100)', () => {
+    const base = () => ({
+      pn: 25000,
+      rpn: 0.95,
+      rpint: 0.92,
+      qp0: 150,
+      temp_fonc_30: 35,
+      temp_fonc_100: 70
+    });
+    const deCommun = {
+      enum_type_generateur_ch_id: '96',
+      enum_type_energie_id: '2',
+      type_energie: 'gaz naturel',
+      description: 't'
+    };
+    const diAvec = base();
+    calc_generateur_combustion_ch(
+      {},
+      diAvec,
+      { ...deCommun, presence_regulation_combustion: true },
+      {
+        cdimref: 0.8,
+        cdimrefDep: 0.6
+      }
+    );
+    const diSans = base();
+    calc_generateur_combustion_ch(
+      {},
+      diSans,
+      { ...deCommun, presence_regulation_combustion: false },
+      { cdimref: 0.8, cdimrefDep: 0.6 }
+    );
+    // Avec régulation (tf plus basse) le rendement est plus élevé
+    expect(diAvec.rg).toBeGreaterThan(diSans.rg);
+  });
+});

package/13.2_generateur_combustion_chaudiere.spec.js

@@ -0,0 +1,85 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+
+/**
+ * Dépendance mockée : `getFicheTechnique` (import par défaut), qui fournit l'année
+ * d'installation utilisée pour choisir le générateur équivalent. On contrôle sa valeur
+ * de retour ; son fonctionnement interne n'est pas testé ici.
+ */
+vi.mock('./ficheTechnique.js', () => ({
+  default: vi.fn()
+}));
+
+const { updateGenerateurChaudieres } = await import('./13.2_generateur_combustion_chaudiere.js');
+const { default: getFicheTechnique } = await import('./ficheTechnique.js');
+
+beforeEach(() => {
+  vi.mocked(getFicheTechnique).mockReset();
+});
+
+/**
+ * 13.2 - Les "autres systèmes à combustion" sont assimilés à des chaudières standard
+ * de la période correspondante.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2
+ */
+describe('updateGenerateurChaudieres - substitution par une chaudière équivalente', () => {
+  test('type non concerné : aucune substitution, pas de champ previous', () => {
+    getFicheTechnique.mockReturnValue(undefined);
+    const de = { enum_type_generateur_ch_id: '90' };
+    updateGenerateurChaudieres({}, de, 'ch');
+    expect(de.enum_type_generateur_ch_id).toBe('90');
+    expect(de.previous_enum_type_generateur_ch_id).toBeUndefined();
+  });
+
+  test('sans fiche technique : identifiant conservé mais previous renseigné (ch, gaz 113)', () => {
+    getFicheTechnique.mockReturnValue(undefined);
+    const de = { enum_type_generateur_ch_id: '113' };
+    updateGenerateurChaudieres({}, de, 'ch');
+    expect(de.enum_type_generateur_ch_id).toBe('113');
+    expect(de.previous_enum_type_generateur_ch_id).toBe('113');
+  });
+
+  test('fiche "avant 1948" : chaudière la plus ancienne de la table (ch, gaz 113 -> 85)', () => {
+    getFicheTechnique.mockReturnValue({ valeur: 'avant 1948' });
+    const de = { enum_type_generateur_ch_id: '113' };
+    updateGenerateurChaudieres({}, de, 'ch');
+    expect(de.enum_type_generateur_ch_id).toBe('85');
+    expect(de.previous_enum_type_generateur_ch_id).toBe('113');
+  });
+
+  test('année 1985 : seuil 1981 retenu (ch, gaz 113 -> 86)', () => {
+    getFicheTechnique.mockReturnValue({ valeur: '1985' });
+    const de = { enum_type_generateur_ch_id: '113' };
+    updateGenerateurChaudieres({}, de, 'ch');
+    expect(de.enum_type_generateur_ch_id).toBe('86');
+  });
+
+  test('année postérieure au dernier seuil : chaudière la plus récente (ch, gaz 113 -> 90)', () => {
+    getFicheTechnique.mockReturnValue({ valeur: '2030' });
+    const de = { enum_type_generateur_ch_id: '113' };
+    updateGenerateurChaudieres({}, de, 'ch');
+    expect(de.enum_type_generateur_ch_id).toBe('90');
+  });
+
+  test('type ECS (fioul 79) : utilise la table ECS et le seuil correspondant', () => {
+    getFicheTechnique.mockReturnValue({ valeur: '1972' });
+    const de = { enum_type_generateur_ecs_id: '79' };
+    updateGenerateurChaudieres({}, de, 'ecs');
+    // seuils fioul ECS : 1948->35, 1970->36 ... 1972 >= 1970 => 36
+    expect(de.enum_type_generateur_ecs_id).toBe('36');
+    expect(de.previous_enum_type_generateur_ecs_id).toBe('79');
+  });
+
+  test("la fiche technique est interrogée avec le bon domaine ('7' pour ch, '8' pour ecs)", () => {
+    getFicheTechnique.mockReturnValue({ valeur: '2000' });
+    updateGenerateurChaudieres({}, { enum_type_generateur_ch_id: '113' }, 'ch');
+    expect(getFicheTechnique).toHaveBeenCalledWith({}, '7', 'année', [
+      'Autre système à combustion'
+    ]);
+
+    getFicheTechnique.mockClear();
+    updateGenerateurChaudieres({}, { enum_type_generateur_ecs_id: '79' }, 'ecs');
+    expect(getFicheTechnique).toHaveBeenCalledWith({}, '8', 'année', [
+      'Autre système à combustion'
+    ]);
+  });
+});

package/13.2_generateur_pac.spec.js

@@ -0,0 +1,64 @@
+import { describe, expect, test } from 'vitest';
+
+/**
+ * Ce module ne dépend d'aucune table de valeurs ni d'aucun enum : la logique est
+ * entièrement déterminée par les données d'entrée. Aucun mock n'est donc nécessaire.
+ */
+const { updateGenerateurPacs } = await import('./13.2_generateur_pac.js');
+
+/**
+ * 13.2 - Substitution des générateurs "autre système thermodynamique" par un CET
+ * sur air ambiant équivalent selon la période d'installation.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2
+ */
+describe('updateGenerateurPacs - substitution des générateurs thermodynamiques', () => {
+  test("aucune période d'installation renseignée : aucune modification", () => {
+    const de = { enum_type_generateur_ecs_id: '82' };
+    updateGenerateurPacs({}, de, 'ecs');
+    expect(de.enum_type_generateur_ecs_id).toBe('82');
+  });
+
+  test.each([
+    ['1', '10'],
+    ['2', '11'],
+    ['3', '12']
+  ])(
+    'ECS type 82 (autre système thermodynamique électrique), période %s : générateur remplacé par %s',
+    (periode, attendu) => {
+      const de = {
+        enum_type_generateur_ecs_id: '82',
+        enum_periode_installation_ecs_thermo_id: periode
+      };
+      updateGenerateurPacs({}, de, 'ecs');
+      expect(de.enum_type_generateur_ecs_id).toBe(attendu);
+    }
+  );
+
+  test('ECS type 82 avec période inconnue : type conservé tel quel', () => {
+    const de = {
+      enum_type_generateur_ecs_id: '82',
+      enum_periode_installation_ecs_thermo_id: '9'
+    };
+    updateGenerateurPacs({}, de, 'ecs');
+    expect(de.enum_type_generateur_ecs_id).toBe('82');
+  });
+
+  test('ECS type différent de 82 : aucune substitution même avec une période', () => {
+    const de = {
+      enum_type_generateur_ecs_id: '50',
+      enum_periode_installation_ecs_thermo_id: '1'
+    };
+    updateGenerateurPacs({}, de, 'ecs');
+    expect(de.enum_type_generateur_ecs_id).toBe('50');
+  });
+
+  test('type ch avec une période : la substitution ECS ne s’applique pas', () => {
+    const de = {
+      enum_type_generateur_ch_id: '82',
+      enum_periode_installation_ecs_thermo_id: '1'
+    };
+    updateGenerateurPacs({}, de, 'ch');
+    // La branche de substitution est réservée au type 'ecs' : valeur inchangée
+    expect(de.enum_type_generateur_ch_id).toBe('82');
+  });
+});

package/13_rendement_distribution_ecs.spec.js

@@ -0,0 +1,38 @@
+import { describe, expect, test, vi } from 'vitest';
+
+/**
+ * Dépendances mockées pour isoler le module :
+ * - `enums.type_installation` : libellé du type d'installation dérivé de l'identifiant d'entrée.
+ * La fonction actuelle se contente de résoudre le type d'installation sans modifier l'objet ECS ;
+ * ces tests figent ce contrat (aucune mutation, retour indéfini) pour détecter toute régression.
+ */
+vi.mock('./enums.js', () => ({
+  default: {
+    type_installation: { 1: 'installation individuelle', 2: 'installation collective' }
+  }
+}));
+
+const { default: rendement_distribution_ecs } = await import('./13_rendement_distribution_ecs.js');
+
+/**
+ * 13. Rendement de distribution de l'ECS
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13
+ */
+describe('rendement_distribution_ecs', () => {
+  test('ne retourne aucune valeur (fonction sans effet de sortie)', () => {
+    const ecs = { donnee_entree: { enum_type_installation_id: '1' } };
+    expect(rendement_distribution_ecs(ecs)).toBeUndefined();
+  });
+
+  test('ne mute pas les données d’entrée de l’installation ECS', () => {
+    const de = { enum_type_installation_id: '2' };
+    const ecs = { donnee_entree: de };
+    rendement_distribution_ecs(ecs);
+    expect(ecs.donnee_entree).toEqual({ enum_type_installation_id: '2' });
+  });
+
+  test('accepte un type d’installation inconnu sans lever d’erreur', () => {
+    const ecs = { donnee_entree: { enum_type_installation_id: '999' } };
+    expect(() => rendement_distribution_ecs(ecs)).not.toThrow();
+  });
+});

package/14_generateur_ecs.js

@@ -165,14 +165,14 @@ function type_generateur_ecs(di, de, du, usage_generateur) {
   return type_generateur;
 }
 
-function rg_chauffe_eau_gaz(di, besoin_ecs) {
+export function rg_chauffe_eau_gaz(di, besoin_ecs) {
   return (
     1 /
     (1 / di.rpn + 1790 * (di.qp0 / (besoin_ecs * 1000)) + 6970 * (di.pveil / (besoin_ecs * 1000)))
   );
 }
 
-function rgrs_chaudiere(di, besoin_ecs) {
+export function rgrs_chaudiere(di, besoin_ecs) {
   return (
     1 /
     (1 / di.rpn +
@@ -181,7 +181,7 @@ function rgrs_chaudiere(di, besoin_ecs) {
   );
 }
 
-function rg_accumulateur_gaz(di, besoin_ecs) {
+export function rg_accumulateur_gaz(di, besoin_ecs) {
   return (
     1 /
     (1 / di.rpn +
@@ -190,7 +190,7 @@ function rg_accumulateur_gaz(di, besoin_ecs) {
   );
 }
 
-function rgrsReseauUrbain(de, ecs_de) {
+export function rgrsReseauUrbain(de, ecs_de) {
   /**
    * Le rendement de génération d'un réseau de chaleur dépend de son caractère isolé ou non.
    * D'après la spécification 3CL-DPE, le type de RCU est porté par enum_type_generateur_ecs_id :