@open3cl/engine 1.8.14 → 1.8.15

package/13.2_generateur_combustion_ch.js

@@ -62,7 +62,170 @@ export function tempDistributionChPourTempFonc(emChDe, emChDu) {
   return tempDistribution;
 }
 
+/**
+ * Périodes d'installation des émetteurs (table temp_fonc_30 / temp_fonc_100), de la plus ancienne
+ * à la plus récente.
+ */
+export const PERIODES_INSTALLATION_EMETTEUR = ['avant 1981', 'entre 1981 et 2000', 'après 2000'];
+
+/**
+ * Tolérance (°C) pour considérer qu'une température de fonctionnement issue des tables reproduit
+ * celle stockée dans le DPE.
+ */
+export const TOLERANCE_TEMP_FONC = 0.01;
+
+/**
+ * 13.2.1.5 Chaudières basse température et condensation
+ * « Si l'année d'installation des émetteurs est inconnue, prendre l'année de construction du
+ * bâtiment. »
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.1.5
+ *
+ * @param ac {number} année de construction du bâtiment
+ * @return {string} période d'installation des émetteurs
+ */
+export function periodeEmetteurAnneeConstruction(ac) {
+  if (ac < 1981) return PERIODES_INSTALLATION_EMETTEUR[0];
+  if (ac < 2000) return PERIODES_INSTALLATION_EMETTEUR[1];
+  return PERIODES_INSTALLATION_EMETTEUR[2];
+}
+
+function estNumerique(valeur) {
+  return (
+    valeur !== null && valeur !== undefined && valeur !== '' && Number.isFinite(Number(valeur))
+  );
+}
+
+/**
+ * Lignes des tables temp_fonc_30 / temp_fonc_100 retenues pour un générateur (maximum sur les
+ * émetteurs), en affectant `periodeParDefaut` aux émetteurs dont la période d'installation n'est
+ * pas saisie. Les émetteurs sans réseau de distribution (enum_temp_distribution_ch_id = 1) sont
+ * exclus. Utilisé uniquement pour la déduction de période en mode bug_for_bug_compat.
+ *
+ * @param de {object} donnee_entree du générateur
+ * @param em_ch {object[]} émetteurs de l'installation
+ * @param periodeParDefaut {string} période affectée aux émetteurs sans période saisie
+ * @return {{row_30: object|null, row_100: object|null}}
+ */
+export function temp_fonc_pour_periode(de, em_ch, periodeParDefaut) {
+  let row_30 = null;
+  let row_100 = null;
+  for (const em of em_ch) {
+    const em_ch_de = em.donnee_entree;
+    const em_ch_du = em.donnee_utilisateur;
+    if (String(requestInputID(em_ch_de, em_ch_du, 'temp_distribution_ch')) === '1') continue;
+    const matcher = {
+      enum_type_generateur_ch_id: de.enum_type_generateur_ch_id,
+      enum_temp_distribution_ch_id: tempDistributionChPourTempFonc(em_ch_de, em_ch_du),
+      periode_emetteurs:
+        requestInput(em_ch_de, em_ch_du, 'periode_installation_emetteur') || periodeParDefaut
+    };
+    const r30 = tv('temp_fonc_30', matcher);
+    const r100 = tv('temp_fonc_100', matcher);
+    if (r30 && (!row_30 || Number(r30.temp_fonc_30) > Number(row_30.temp_fonc_30))) row_30 = r30;
+    if (r100 && (!row_100 || Number(r100.temp_fonc_100) > Number(row_100.temp_fonc_100))) {
+      row_100 = r100;
+    }
+  }
+  return { row_30, row_100 };
+}
+
+/**
+ * Mode bug_for_bug_compat uniquement (issue #220).
+ *
+ * Certains logiciels (ex. 4.1.1 / moteur 3cl-2024.6.1.0, LICIEL) calculent les températures de
+ * fonctionnement avec une période d'installation des émetteurs qu'ils n'exportent pas, mais
+ * stockent temp_fonc_30 / temp_fonc_100 dans les données intermédiaires du générateur. La période
+ * est alors retrouvée en testant chaque période candidate (appliquée à tous les émetteurs sans
+ * période saisie) et en ne retenant que celles qui reproduisent les DEUX valeurs du DPE.
+ *
+ * - une seule candidate : retenue ;
+ * - plusieurs : celle de l'année de construction si elle en fait partie, sinon la plus récente ;
+ * - aucune : null (repli sur l'année de construction, valeurs hors tables).
+ *
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.1.5
+ *
+ * @param tempFonc30Dpe {number} temp_fonc_30 d'origine du DPE
+ * @param tempFonc100Dpe {number} temp_fonc_100 d'origine du DPE
+ * @param de {object} donnee_entree du générateur
+ * @param em_ch {object[]} émetteurs de l'installation
+ * @param ac {number} année de construction
+ * @return {string|null} période déduite, ou null si aucune période ne reproduit le DPE
+ */
+export function periodeEmetteursDeduiteDuDpe(tempFonc30Dpe, tempFonc100Dpe, de, em_ch, ac) {
+  const candidates = PERIODES_INSTALLATION_EMETTEUR.filter((periode) => {
+    const { row_30, row_100 } = temp_fonc_pour_periode(de, em_ch, periode);
+    return (
+      row_30 &&
+      row_100 &&
+      Math.abs(Number(row_30.temp_fonc_30) - tempFonc30Dpe) <= TOLERANCE_TEMP_FONC &&
+      Math.abs(Number(row_100.temp_fonc_100) - tempFonc100Dpe) <= TOLERANCE_TEMP_FONC
+    );
+  });
+  if (candidates.length === 0) return null;
+  const periodeConstruction = periodeEmetteurAnneeConstruction(ac);
+  if (candidates.includes(periodeConstruction)) return periodeConstruction;
+  return candidates[candidates.length - 1];
+}
+
+/**
+ * Indique si la déduction de la période des émetteurs à partir des données intermédiaires du DPE
+ * doit être tentée : mode bug_for_bug_compat, au moins un émetteur (avec réseau de distribution)
+ * sans période saisie, et temp_fonc_30 ET temp_fonc_100 d'origine présentes et numériques.
+ *
+ * @param tempFonc30Dpe {*} temp_fonc_30 d'origine du DPE
+ * @param tempFonc100Dpe {*} temp_fonc_100 d'origine du DPE
+ * @param em_ch {object[]} émetteurs de l'installation
+ * @return {boolean}
+ */
+export function deductionPeriodeEmetteursActive(tempFonc30Dpe, tempFonc100Dpe, em_ch) {
+  if (!bug_for_bug_compat) return false;
+  if (!estNumerique(tempFonc30Dpe) || !estNumerique(tempFonc100Dpe)) return false;
+  return em_ch.some(
+    (em) =>
+      String(requestInputID(em.donnee_entree, em.donnee_utilisateur, 'temp_distribution_ch')) !==
+        '1' &&
+      !requestInput(em.donnee_entree, em.donnee_utilisateur, 'periode_installation_emetteur')
+  );
+}
+
+/**
+ * Températures de fonctionnement à 30 % et 100 % de charge.
+ *
+ * `di` est la donnee_intermediaire du générateur issue du DPE d'entrée : à l'appel, temp_fonc_30 /
+ * temp_fonc_100 contiennent les valeurs d'origine du DPE (jamais une valeur recalculée par
+ * Open3CL). En mode bug_for_bug_compat, elles servent uniquement à retrouver la période
+ * d'installation des émetteurs non exportée (issue #220) ; les valeurs retenues proviennent
+ * toujours des tables (tv_temp_fonc_30_id / tv_temp_fonc_100_id renseignés).
+ *
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.1.5
+ */
 export function tv_temp_fonc_30_100(di, de, du, em_ch, ac) {
+  const tempFonc30Dpe = di.temp_fonc_30;
+  const tempFonc100Dpe = di.temp_fonc_100;
+  if (deductionPeriodeEmetteursActive(tempFonc30Dpe, tempFonc100Dpe, em_ch)) {
+    const periode = periodeEmetteursDeduiteDuDpe(
+      Number(tempFonc30Dpe),
+      Number(tempFonc100Dpe),
+      de,
+      em_ch,
+      ac
+    );
+    if (periode) {
+      const { row_30, row_100 } = temp_fonc_pour_periode(de, em_ch, periode);
+      console.warn(
+        `période d'installation des émetteurs déduite des données intermédiaires du DPE : ${periode} (générateur ${de.description}, temp_fonc_30 = ${row_30.temp_fonc_30}, temp_fonc_100 = ${row_100.temp_fonc_100})`
+      );
+      de.tv_temp_fonc_30_id = row_30.tv_temp_fonc_30_id;
+      di.temp_fonc_30 = Number(row_30.temp_fonc_30);
+      de.tv_temp_fonc_100_id = row_100.tv_temp_fonc_100_id;
+      di.temp_fonc_100 = Number(row_100.temp_fonc_100);
+      return;
+    }
+    console.warn(
+      `période d'installation des émetteurs non déductible pour le générateur ${de.description} : valeurs hors tables / donnée d'entrée incohérente (temp_fonc_30 = ${tempFonc30Dpe}, temp_fonc_100 = ${tempFonc100Dpe}). Repli sur l'année de construction.`
+    );
+  }
+
   for (const em of em_ch) {
     const em_ch_de = em.donnee_entree;
     const em_ch_du = em.donnee_utilisateur;
@@ -73,9 +236,7 @@ export function tv_temp_fonc_30_100(di, de, du, em_ch, ac) {
     };
 
     if (!matcher.periode_emetteurs) {
-      if (ac < 1981) matcher.periode_emetteurs = 'avant 1981';
-      else if (ac < 2000) matcher.periode_emetteurs = 'entre 1981 et 2000';
-      else matcher.periode_emetteurs = 'après 2000';
+      matcher.periode_emetteurs = periodeEmetteurAnneeConstruction(ac);
     }
 
     const row_30 = tv('temp_fonc_30', matcher);

package/13.2_generateur_combustion_ch.spec.js

@@ -38,8 +38,14 @@ vi.mock('./utils.js', () => ({
   requestInputID: vi.fn((de, du, field) => de[`enum_${field}_id`])
 }));
 
-const { tv_temp_fonc_30_100, tempDistributionChPourTempFonc, calc_generateur_combustion_ch } =
-  await import('./13.2_generateur_combustion_ch.js');
+const {
+  tv_temp_fonc_30_100,
+  tempDistributionChPourTempFonc,
+  calc_generateur_combustion_ch,
+  periodeEmetteursDeduiteDuDpe,
+  periodeEmetteurAnneeConstruction,
+  PERIODES_INSTALLATION_EMETTEUR
+} = await import('./13.2_generateur_combustion_ch.js');
 const { tv } = await import('./utils.js');
 
 beforeEach(() => {
@@ -194,6 +200,284 @@ describe('tv_temp_fonc_30_100 - températures de fonctionnement', () => {
   );
 });
 
+/**
+ * Issue #220 - période d'installation des émetteurs absente du DPE.
+ *
+ * Mode strict : « Si l'année d'installation des émetteurs est inconnue, prendre l'année de
+ * construction du bâtiment. » En mode bug_for_bug_compat uniquement, la période est retrouvée à
+ * partir des temp_fonc_30 / temp_fonc_100 d'origine stockées dans le DPE (règle de l'expert).
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.1.5
+ */
+describe('tv_temp_fonc_30_100 - période des émetteurs absente (issue #220)', () => {
+  /**
+   * Table de test (contrôlée, indépendante des tables réelles) pour une chaudière à condensation :
+   * [température de distribution][période] -> [id, temp_fonc_30, temp_fonc_100].
+   */
+  const TABLE = {
+    2: {
+      'avant 1981': ['1', '32', '60'],
+      'entre 1981 et 2000': ['4', '24.5', '35'],
+      'après 2000': ['7', '24.5', '35']
+    },
+    3: {
+      'avant 1981': ['2', '38', '80'],
+      'entre 1981 et 2000': ['5', '35', '70'],
+      'après 2000': ['8', '32', '60']
+    },
+    4: {
+      'avant 1981': ['3', '38', '80'],
+      'entre 1981 et 2000': ['6', '35', '70'],
+      'après 2000': ['9', '35', '70']
+    }
+  };
+
+  function tvTable(table, matcher) {
+    const ligne = TABLE[matcher.enum_temp_distribution_ch_id]?.[matcher.periode_emetteurs];
+    if (!ligne) return null;
+    return table === 'temp_fonc_30'
+      ? { tv_temp_fonc_30_id: `30-${ligne[0]}`, temp_fonc_30: ligne[1] }
+      : { tv_temp_fonc_100_id: `100-${ligne[0]}`, temp_fonc_100: ligne[2] };
+  }
+
+  function emetteur(tempDistribution, periode) {
+    const de = { enum_temp_distribution_ch_id: tempDistribution };
+    if (periode) de.periode_installation_emetteur = periode;
+    return { donnee_entree: de, donnee_utilisateur: {} };
+  }
+
+  const genCondensation = () => ({ enum_type_generateur_ch_id: '97', description: 'chaudière' });
+
+  let warnSpy;
+  beforeEach(() => {
+    tv.mockImplementation(tvTable);
+    warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    return () => warnSpy.mockRestore();
+  });
+
+  test('T1 strict : période absente, construction 1900 -> « avant 1981 » (38/80), valeurs du DPE ignorées', () => {
+    const di = { temp_fonc_30: 32, temp_fonc_100: 60 };
+    const de = genCondensation();
+    tv_temp_fonc_30_100(di, de, {}, [emetteur('3')], 1900);
+    // Valeurs DPE (32) < table (38) : la table l'emporte, aucune déduction en mode strict
+    expect(di.temp_fonc_30).toBe(38);
+    expect(di.temp_fonc_100).toBe(80);
+    expect(de.tv_temp_fonc_30_id).toBe('30-2');
+    expect(de.tv_temp_fonc_100_id).toBe('100-2');
+    expect(tv).not.toHaveBeenCalledWith(
+      'temp_fonc_30',
+      expect.objectContaining({ periode_emetteurs: 'après 2000' })
+    );
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  test('T2 bug_for_bug_compat : DPE à 32/60 -> période « après 2000 » déduite, valeurs et ids issus des tables', () => {
+    state.bug = true;
+    const di = { temp_fonc_30: 32, temp_fonc_100: 60 };
+    const de = genCondensation();
+    tv_temp_fonc_30_100(di, de, {}, [emetteur('3')], 1900);
+    expect(di.temp_fonc_30).toBe(32);
+    expect(di.temp_fonc_100).toBe(60);
+    expect(de.tv_temp_fonc_30_id).toBe('30-8');
+    expect(de.tv_temp_fonc_100_id).toBe('100-8');
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        "période d'installation des émetteurs déduite des données intermédiaires du DPE : après 2000"
+      )
+    );
+  });
+
+  test('T2 bis bug_for_bug_compat : valeurs du DPE sous forme de chaînes acceptées', () => {
+    state.bug = true;
+    const di = { temp_fonc_30: '32', temp_fonc_100: '60' };
+    tv_temp_fonc_30_100(di, genCondensation(), {}, [emetteur('3')], 1900);
+    expect(di.temp_fonc_30).toBe(32);
+    expect(di.temp_fonc_100).toBe(60);
+  });
+
+  test('T3 bug_for_bug_compat : période saisie « avant 1981 » jamais écrasée (38/80 conservé)', () => {
+    state.bug = true;
+    const di = { temp_fonc_30: 32, temp_fonc_100: 60 };
+    const de = genCondensation();
+    tv_temp_fonc_30_100(di, de, {}, [emetteur('3', 'avant 1981')], 1900);
+    expect(di.temp_fonc_30).toBe(38);
+    expect(di.temp_fonc_100).toBe(80);
+    expect(de.tv_temp_fonc_30_id).toBe('30-2');
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  test('T4 bug_for_bug_compat : distribution haute, construction 1990, DPE 35/70 -> 2 candidates, période de construction retenue', () => {
+    state.bug = true;
+    const di = { temp_fonc_30: 35, temp_fonc_100: 70 };
+    const de = genCondensation();
+    tv_temp_fonc_30_100(di, de, {}, [emetteur('4')], 1990);
+    expect(di.temp_fonc_30).toBe(35);
+    expect(di.temp_fonc_100).toBe(70);
+    // « entre 1981 et 2000 » (ids 6) et non « après 2000 » (ids 9)
+    expect(de.tv_temp_fonc_30_id).toBe('30-6');
+    expect(de.tv_temp_fonc_100_id).toBe('100-6');
+  });
+
+  test('T5 bug_for_bug_compat : DPE 33/62 hors tables -> repli sur l’année de construction et avertissement', () => {
+    state.bug = true;
+    const di = { temp_fonc_30: 33, temp_fonc_100: 62 };
+    const de = genCondensation();
+    tv_temp_fonc_30_100(di, de, {}, [emetteur('3')], 1990);
+    // Repli strict : « entre 1981 et 2000 » -> 35/70 (> 33/62 donc retenu)
+    expect(di.temp_fonc_30).toBe(35);
+    expect(di.temp_fonc_100).toBe(70);
+    expect(de.tv_temp_fonc_30_id).toBe('30-5');
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("valeurs hors tables / donnée d'entrée incohérente")
+    );
+  });
+
+  test.each([
+    ['temp_fonc_100 absente', { temp_fonc_30: 32 }],
+    ['temp_fonc_30 absente', { temp_fonc_100: 60 }],
+    ['temp_fonc_30 non numérique', { temp_fonc_30: 'abc', temp_fonc_100: 60 }],
+    ['temp_fonc_100 vide', { temp_fonc_30: 32, temp_fonc_100: '' }],
+    ['temp_fonc_30 nulle', { temp_fonc_30: null, temp_fonc_100: 60 }]
+  ])(
+    'T6 bug_for_bug_compat : %s -> aucune déduction (règle de l’année de construction)',
+    (_, di) => {
+      state.bug = true;
+      tv_temp_fonc_30_100(di, genCondensation(), {}, [emetteur('3')], 1900);
+      expect(tv).not.toHaveBeenCalledWith(
+        'temp_fonc_30',
+        expect.objectContaining({ periode_emetteurs: 'après 2000' })
+      );
+      expect(tv).not.toHaveBeenCalledWith(
+        'temp_fonc_30',
+        expect.objectContaining({ periode_emetteurs: 'entre 1981 et 2000' })
+      );
+      expect(warnSpy).not.toHaveBeenCalled();
+    }
+  );
+
+  test('T7 bug_for_bug_compat : deux émetteurs sans période (moyenne + haute), DPE 35/70 -> même période pour tous, règle du maximum', () => {
+    state.bug = true;
+    const di = { temp_fonc_30: 35, temp_fonc_100: 70 };
+    const de = genCondensation();
+    /**
+     * avant 1981 : max(38, 38) / max(80, 80) = 38/80 -> rejetée
+     * entre 1981 et 2000 : max(35, 35) / max(70, 70) = 35/70 -> candidate
+     * après 2000 : max(32, 35) / max(60, 70) = 35/70 -> candidate
+     * Construction 1900 (« avant 1981 ») hors candidates -> la plus récente : « après 2000 ».
+     */
+    tv_temp_fonc_30_100(di, de, {}, [emetteur('3'), emetteur('4')], 1900);
+    expect(di.temp_fonc_30).toBe(35);
+    expect(di.temp_fonc_100).toBe(70);
+    // Maximum atteint par l'émetteur « haute » en « après 2000 » (ids 9)
+    expect(de.tv_temp_fonc_30_id).toBe('30-9');
+    expect(de.tv_temp_fonc_100_id).toBe('100-9');
+  });
+
+  test('bug_for_bug_compat : un émetteur saisi et un émetteur sans période -> seule la période absente est déduite', () => {
+    state.bug = true;
+    const di = { temp_fonc_30: 35, temp_fonc_100: 70 };
+    const de = genCondensation();
+    // Émetteur saisi « entre 1981 et 2000 » (moyenne : 35/70) + émetteur basse sans période
+    tv_temp_fonc_30_100(di, de, {}, [emetteur('3', 'entre 1981 et 2000'), emetteur('2')], 1900);
+    expect(di.temp_fonc_30).toBe(35);
+    expect(di.temp_fonc_100).toBe(70);
+    expect(tv).toHaveBeenCalledWith(
+      'temp_fonc_30',
+      expect.objectContaining({
+        enum_temp_distribution_ch_id: '3',
+        periode_emetteurs: 'entre 1981 et 2000'
+      })
+    );
+    expect(tv).not.toHaveBeenCalledWith(
+      'temp_fonc_30',
+      expect.objectContaining({
+        enum_temp_distribution_ch_id: '3',
+        periode_emetteurs: 'après 2000'
+      })
+    );
+  });
+
+  test('bug_for_bug_compat : émetteur sans réseau de distribution (id 1) exclu', () => {
+    state.bug = true;
+    const di = { temp_fonc_30: 32, temp_fonc_100: 60 };
+    tv_temp_fonc_30_100(di, genCondensation(), {}, [emetteur('1'), emetteur('3')], 1900);
+    expect(di.temp_fonc_30).toBe(32);
+    expect(di.temp_fonc_100).toBe(60);
+  });
+
+  test('bug_for_bug_compat : seul un émetteur sans réseau de distribution est sans période -> aucune déduction', () => {
+    state.bug = true;
+    const di = { temp_fonc_30: 32, temp_fonc_100: 60 };
+    tv_temp_fonc_30_100(
+      di,
+      genCondensation(),
+      {},
+      [emetteur('1'), emetteur('3', 'avant 1981')],
+      1900
+    );
+    expect(di.temp_fonc_30).toBe(38);
+    expect(di.temp_fonc_100).toBe(80);
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  test('bug_for_bug_compat : une seule des deux valeurs reproduite -> période rejetée (tolérance 0,01 °C)', () => {
+    state.bug = true;
+    // 32/60.02 : « après 2000 » ne reproduit que temp_fonc_30 -> aucune candidate
+    const di = { temp_fonc_30: 32, temp_fonc_100: 60.02 };
+    tv_temp_fonc_30_100(di, genCondensation(), {}, [emetteur('3')], 1900);
+    expect(di.temp_fonc_30).toBe(38);
+    expect(di.temp_fonc_100).toBe(80);
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('valeurs hors tables'));
+  });
+
+  test('bug_for_bug_compat : écart inférieur à la tolérance accepté', () => {
+    state.bug = true;
+    const di = { temp_fonc_30: 32.005, temp_fonc_100: 59.995 };
+    tv_temp_fonc_30_100(di, genCondensation(), {}, [emetteur('3')], 1900);
+    expect(di.temp_fonc_30).toBe(32);
+    expect(di.temp_fonc_100).toBe(60);
+  });
+});
+
+describe('periodeEmetteursDeduiteDuDpe', () => {
+  const de = { enum_type_generateur_ch_id: '97' };
+  const em = [{ donnee_entree: { enum_temp_distribution_ch_id: '3' }, donnee_utilisateur: {} }];
+
+  test('aucune ligne de table trouvée pour une période : période non candidate', () => {
+    tv.mockReturnValue(null);
+    expect(periodeEmetteursDeduiteDuDpe(32, 60, de, em, 1900)).toBeNull();
+  });
+
+  test('ligne temp_fonc_100 absente : période non candidate', () => {
+    tv.mockImplementation((table) =>
+      table === 'temp_fonc_30' ? { tv_temp_fonc_30_id: '1', temp_fonc_30: '32' } : null
+    );
+    expect(periodeEmetteursDeduiteDuDpe(32, 60, de, em, 1900)).toBeNull();
+  });
+
+  test('toutes les périodes candidates : période de construction retenue', () => {
+    tv.mockImplementation((table) =>
+      table === 'temp_fonc_30'
+        ? { tv_temp_fonc_30_id: '1', temp_fonc_30: '32' }
+        : { tv_temp_fonc_100_id: '1', temp_fonc_100: '60' }
+    );
+    expect(periodeEmetteursDeduiteDuDpe(32, 60, de, em, 1900)).toBe(
+      PERIODES_INSTALLATION_EMETTEUR[0]
+    );
+    expect(periodeEmetteursDeduiteDuDpe(32, 60, de, em, 2010)).toBe('après 2000');
+  });
+});
+
+describe('periodeEmetteurAnneeConstruction', () => {
+  test.each([
+    [1980, 'avant 1981'],
+    [1981, 'entre 1981 et 2000'],
+    [1999, 'entre 1981 et 2000'],
+    [2000, 'après 2000']
+  ])('année de construction %s : %s', (ac, periode) => {
+    expect(periodeEmetteurAnneeConstruction(ac)).toBe(periode);
+  });
+});
+
 describe('tempDistributionChPourTempFonc', () => {
   test('émetteur sans type d’émission : température déclarée renvoyée telle quelle', () => {
     expect(tempDistributionChPourTempFonc({ enum_temp_distribution_ch_id: '3' }, {})).toBe('3');

package/README.md

@@ -370,57 +370,57 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <!-- CORPUS:START -->
 
-> **Version `1.8.12`** · à publier · branche `main` · généré le 2026-10-02
+> **Version `1.8.14`** · à publier · branche `main` · généré le 2026-10-02
 > Seuil de tolérance **5%**
 
 <table>
 <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>60 087</strong><br/><sub>DPE conformes</sub></td>
-<td align="center"><strong>66,77 %</strong><br/><sub>réussite globale</sub></td>
+<td align="center"><strong>60 314</strong><br/><sub>DPE conformes</sub></td>
+<td align="center"><strong>67,02 %</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,31 %** | `█████████░░░░░░░░░░░` | 4 631 / 10 000 |
+| 🔴  | **Généraliste**<br/><sub>`corpus_dpe.csv`</sub>                                                                         | **46,36 %** | `█████████░░░░░░░░░░░` | 4 636 / 10 000 |
 | 🟢  | **Appartement · chauffage individuel (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_individuel_2025.csv`</sub> | **92,42 %** | `██████████████████░░` | 9 242 / 10 000 |
-| 🟢  | **Logement individuel (2025)**<br/><sub>`dpe_logement_individuel_2025.csv`</sub>                                        | **89,39 %** | `██████████████████░░` |  8 932 / 9 992 |
-| 🟢  | **Maison individuelle (2025)**<br/><sub>`dpe_maison_individuelle_2025.csv`</sub>                                        | **88,41 %** | `██████████████████░░` | 8 841 / 10 000 |
-| 🟡  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **74,24 %** | `███████████████░░░░░` |  7 423 / 9 999 |
-| 🟡  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **71,10 %** | `██████████████░░░░░░` | 7 110 / 10 000 |
-| 🟡  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **62,65 %** | `█████████████░░░░░░░` |  6 264 / 9 999 |
-| 🔴  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **49,05 %** | `██████████░░░░░░░░░░` | 4 905 / 10 000 |
+| 🟢  | **Logement individuel (2025)**<br/><sub>`dpe_logement_individuel_2025.csv`</sub>                                        | **89,42 %** | `██████████████████░░` |  8 935 / 9 992 |
+| 🟢  | **Maison individuelle (2025)**<br/><sub>`dpe_maison_individuelle_2025.csv`</sub>                                        | **88,50 %** | `██████████████████░░` | 8 850 / 10 000 |
+| 🟡  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **75,85 %** | `███████████████░░░░░` |  7 584 / 9 999 |
+| 🟡  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **71,18 %** | `██████████████░░░░░░` | 7 118 / 10 000 |
+| 🟡  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **62,67 %** | `█████████████░░░░░░░` |  6 266 / 9 999 |
+| 🔴  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **49,44 %** | `██████████░░░░░░░░░░` | 4 944 / 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 |
 
 <sub>🟢 ≥ 85 % · 🟡 ≥ 60 % · 🔴 < 60 %</sub>
 
 #### Temps d’exécution
 
-> Durée de l’appel à `calcul_3cl` par DPE, sur 89 950 calculs.
+> Durée de l’appel à `calcul_3cl` par DPE, sur 89 956 calculs.
 > La copie défensive de l’entrée et la lecture du fichier sont exclues de la mesure.
 
 <table>
 <tr>
-<td align="center"><strong>5,30 ms</strong><br/><sub>moyenne</sub></td>
-<td align="center"><strong>4,64 ms</strong><br/><sub>médiane</sub></td>
+<td align="center"><strong>5,23 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>4,55 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>600,7 ms</strong><br/><sub>max</sub></td>
+<td align="center"><strong>622,7 ms</strong><br/><sub>max</sub></td>
 </tr>
 </table>
 
 | Corpus                                         | Moyenne | Médiane |     Min |      Max |     p95 |     p99 |
 | :--------------------------------------------- | ------: | ------: | ------: | -------: | ------: | ------: |
-| **Généraliste**                                | 4,30 ms | 3,86 ms | 0,20 ms |  30,9 ms | 7,81 ms | 10,7 ms |
-| **Appartement · chauffage individuel (2025)**  | 3,75 ms | 3,39 ms | 1,45 ms |  27,1 ms | 6,51 ms | 8,46 ms |
-| **Logement individuel (2025)**                 | 5,31 ms | 4,77 ms | 1,60 ms |  39,2 ms | 9,77 ms | 12,9 ms |
-| **Maison individuelle (2025)**                 | 7,02 ms | 6,29 ms | 2,10 ms |  50,3 ms | 12,9 ms | 19,2 ms |
-| **Immeuble · chauffage individuel**            | 6,13 ms | 5,23 ms | 0,11 ms |  95,6 ms | 12,4 ms | 19,6 ms |
-| **Appartement · chauffage collectif (2025)**   | 4,61 ms | 4,32 ms | 1,56 ms |  34,9 ms | 7,47 ms | 10,9 ms |
-| **Immeuble · chauffage collectif**             | 5,38 ms | 4,58 ms | 0,20 ms | 100,0 ms | 9,96 ms | 16,9 ms |
-| **Immeuble · chauffage mixte**                 | 5,18 ms | 4,17 ms | 0,19 ms | 600,7 ms | 11,0 ms | 18,2 ms |
-| **Individuel généré depuis l'immeuble (2026)** | 5,99 ms | 5,17 ms | 1,63 ms |  48,8 ms | 11,5 ms | 16,9 ms |
+| **Généraliste**                                | 4,22 ms | 3,76 ms | 0,22 ms |  34,7 ms | 7,72 ms | 11,0 ms |
+| **Appartement · chauffage individuel (2025)**  | 3,84 ms | 3,52 ms | 1,45 ms |  30,9 ms | 6,58 ms | 8,40 ms |
+| **Logement individuel (2025)**                 | 4,70 ms | 4,15 ms | 1,59 ms |  35,3 ms | 8,68 ms | 12,1 ms |
+| **Maison individuelle (2025)**                 | 6,54 ms | 5,89 ms | 1,98 ms |  41,2 ms | 11,9 ms | 17,0 ms |
+| **Immeuble · chauffage individuel**            | 6,29 ms | 5,33 ms | 0,11 ms | 132,2 ms | 12,8 ms | 20,0 ms |
+| **Appartement · chauffage collectif (2025)**   | 4,41 ms | 4,00 ms | 1,48 ms |  33,8 ms | 7,37 ms | 9,64 ms |
+| **Immeuble · chauffage collectif**             | 6,38 ms | 5,37 ms | 0,20 ms | 105,0 ms | 13,4 ms | 24,1 ms |
+| **Immeuble · chauffage mixte**                 | 4,95 ms | 4,03 ms | 0,20 ms | 622,7 ms | 10,3 ms | 16,3 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 5,76 ms | 4,91 ms | 1,65 ms |  48,0 ms | 11,0 ms | 16,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/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.14';
+const LIB_VERSION = '1.8.15';
 
 const dpeSanitizerService = new DpeSanitizerService();
 

package/features/engine/domain/ch/emetteur-ch.service.js

@@ -1,5 +1,25 @@
 import { ChTvStore } from '../../../dpe/infrastructure/ch/chTv.store.js';
 import { inject } from 'dioma';
+import { bug_for_bug_compat } from '../../../../utils.js';
+import { logger } from '../../../../core/util/logger/log-service.js';
+
+/**
+ * Périodes d'installation des émetteurs (enum_periode_installation_emetteur_id), de la plus
+ * ancienne à la plus récente.
+ */
+export const PERIODES_INSTALLATION_EMETTEUR = [1, 2, 3];
+
+/**
+ * Tolérance (°C) pour considérer qu'une température de fonctionnement issue des tables reproduit
+ * celle stockée dans le DPE.
+ */
+export const TOLERANCE_TEMP_FONC = 0.01;
+
+function estNumerique(valeur) {
+  return (
+    valeur !== null && valeur !== undefined && valeur !== '' && Number.isFinite(Number(valeur))
+  );
+}
 
 /**
  * Calcul des données des émetteurs de chauffage
@@ -28,69 +48,173 @@ export class EmetteurChService {
    *
    * @param ctx {Contexte}
    * @param emetteurChauffage {EmetteurChauffage}
+   * @param periodeParDefaut {number|undefined} période à retenir si elle n'est pas saisie (déduite
+   * des données intermédiaires du DPE en mode bug_for_bug_compat, cf. issue #220)
    */
-  periodeInstallationEmetteur(ctx, emetteurChauffage) {
+  periodeInstallationEmetteur(ctx, emetteurChauffage, periodeParDefaut = undefined) {
     const periodeInstallationEmetteur = parseInt(
       emetteurChauffage.donnee_entree.enum_periode_installation_emetteur_id
     );
 
     if (!periodeInstallationEmetteur) {
+      if (periodeParDefaut) {
+        return periodeParDefaut;
+      }
       return ctx.anneeConstruction < 1981 ? 1 : ctx.anneeConstruction < 2000 ? 2 : 3;
     }
 
     return periodeInstallationEmetteur;
   }
 
+  /**
+   * Émetteurs pris en compte pour les températures de fonctionnement : ceux disposant d'un réseau
+   * de distribution (enum_temp_distribution_ch_id ≠ 1).
+   *
+   * @param emetteursChauffage {EmetteurChauffage[]}
+   * @return {EmetteurChauffage[]}
+   */
+  #emetteursAvecDistribution(emetteursChauffage) {
+    return emetteursChauffage.filter(
+      (emetteurChauffage) =>
+        parseInt(emetteurChauffage.donnee_entree.enum_temp_distribution_ch_id) !== 1
+    );
+  }
+
+  /**
+   * Mode bug_for_bug_compat uniquement (issue #220).
+   *
+   * Certains logiciels calculent les températures de fonctionnement avec une période
+   * d'installation des émetteurs qu'ils n'exportent pas, mais stockent temp_fonc_30 /
+   * temp_fonc_100 dans les données intermédiaires du générateur. Chaque période candidate est
+   * affectée à tous les émetteurs sans période saisie ; seules celles qui reproduisent les DEUX
+   * valeurs du DPE (tolérance 0,01 °C) sont retenues :
+   * - une seule candidate : retenue ;
+   * - plusieurs : celle de l'année de construction si elle en fait partie, sinon la plus récente ;
+   * - aucune : undefined (repli sur l'année de construction).
+   *
+   * Aucune déduction si le mode bug_for_bug_compat est désactivé, si l'une des deux températures
+   * du DPE est absente ou non numérique, ou si tous les émetteurs ont une période saisie.
+   *
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.1.5
+   *
+   * @param ctx {Contexte}
+   * @param generateurChauffageDE {GenerateurChauffageDE}
+   * @param emetteursChauffage {EmetteurChauffage[]}
+   * @param temperaturesDpe {{temp_fonc_30: number, temp_fonc_100: number}|undefined} valeurs
+   * d'origine des données intermédiaires du générateur dans le DPE
+   * @return {number|undefined} période déduite (enum_periode_installation_emetteur_id)
+   */
+  periodeInstallationEmetteurDeduite(
+    ctx,
+    generateurChauffageDE,
+    emetteursChauffage,
+    temperaturesDpe
+  ) {
+    if (
+      !bug_for_bug_compat ||
+      !estNumerique(temperaturesDpe?.temp_fonc_30) ||
+      !estNumerique(temperaturesDpe?.temp_fonc_100)
+    ) {
+      return undefined;
+    }
+
+    const emetteursSansPeriode = this.#emetteursAvecDistribution(emetteursChauffage).filter(
+      (emetteurChauffage) =>
+        !parseInt(emetteurChauffage.donnee_entree.enum_periode_installation_emetteur_id)
+    );
+    if (emetteursSansPeriode.length === 0) {
+      return undefined;
+    }
+
+    const tempFonc30Dpe = Number(temperaturesDpe.temp_fonc_30);
+    const tempFonc100Dpe = Number(temperaturesDpe.temp_fonc_100);
+
+    const candidates = PERIODES_INSTALLATION_EMETTEUR.filter((periode) => {
+      const { temp_fonc_30, temp_fonc_100 } = this.temperatureFonctionnement(
+        ctx,
+        generateurChauffageDE,
+        emetteursChauffage,
+        periode
+      );
+      return (
+        estNumerique(temp_fonc_30) &&
+        estNumerique(temp_fonc_100) &&
+        Math.abs(temp_fonc_30 - tempFonc30Dpe) <= TOLERANCE_TEMP_FONC &&
+        Math.abs(temp_fonc_100 - tempFonc100Dpe) <= TOLERANCE_TEMP_FONC
+      );
+    });
+
+    if (candidates.length === 0) {
+      logger.warn(
+        `période d'installation des émetteurs non déductible : valeurs hors tables / donnée d'entrée incohérente (temp_fonc_30 = ${tempFonc30Dpe}, temp_fonc_100 = ${tempFonc100Dpe}). Repli sur l'année de construction.`
+      );
+      return undefined;
+    }
+
+    const periodeConstruction = this.periodeInstallationEmetteur(ctx, { donnee_entree: {} });
+    const periode = candidates.includes(periodeConstruction)
+      ? periodeConstruction
+      : candidates[candidates.length - 1];
+
+    logger.info(
+      `période d'installation des émetteurs déduite des données intermédiaires du DPE : ${periode} (temp_fonc_30 = ${tempFonc30Dpe}, temp_fonc_100 = ${tempFonc100Dpe})`
+    );
+    return periode;
+  }
+
   /**
    * Calcul des températures de fonctionnement à 30% ou 100%
    *
    * @param ctx {Contexte}
    * @param generateurChauffageDE {GenerateurChauffageDE}
    * @param emetteursChauffage {EmetteurChauffage[]}
+   * @param periodeParDefaut {number|undefined} période affectée aux émetteurs sans période saisie
+   * (à défaut : année de construction)
    * @return {{temp_fonc_30: number, temp_fonc_100: number}}
    */
-  temperatureFonctionnement(ctx, generateurChauffageDE, emetteursChauffage) {
+  temperatureFonctionnement(
+    ctx,
+    generateurChauffageDE,
+    emetteursChauffage,
+    periodeParDefaut = undefined
+  ) {
     let temperatureFonctionnement30;
     let temperatureFonctionnement100;
 
-    emetteursChauffage
-      .filter(
-        (emetteurChauffage) =>
-          parseInt(emetteurChauffage.donnee_entree.enum_temp_distribution_ch_id) !== 1
-      )
-      .forEach((emetteurChauffage) => {
-        // Récupération de la température de distribution
-        const temperatureDistribution = Number(
-          emetteurChauffage.donnee_entree.enum_temp_distribution_ch_id
-        );
-
-        // Récupération de la période d'installation de distribution
-        const periodeInstallationEmetteur = this.periodeInstallationEmetteur(
-          ctx,
-          emetteurChauffage
-        );
-
-        const tempFonctionnement30 = this.#chTvStore.temperatureFonctionnement(
-          '30',
-          generateurChauffageDE.enum_type_generateur_ch_id,
-          temperatureDistribution,
-          periodeInstallationEmetteur
-        );
-
-        const tempFonctionnement100 = this.#chTvStore.temperatureFonctionnement(
-          '100',
-          generateurChauffageDE.enum_type_generateur_ch_id,
-          temperatureDistribution,
-          periodeInstallationEmetteur
-        );
-
-        if (!temperatureFonctionnement30 || tempFonctionnement30 > temperatureFonctionnement30) {
-          temperatureFonctionnement30 = tempFonctionnement30;
-        }
-        if (!temperatureFonctionnement100 || tempFonctionnement100 > temperatureFonctionnement100) {
-          temperatureFonctionnement100 = tempFonctionnement100;
-        }
-      });
+    this.#emetteursAvecDistribution(emetteursChauffage).forEach((emetteurChauffage) => {
+      // Récupération de la température de distribution
+      const temperatureDistribution = Number(
+        emetteurChauffage.donnee_entree.enum_temp_distribution_ch_id
+      );
+
+      // Récupération de la période d'installation de distribution
+      const periodeInstallationEmetteur = this.periodeInstallationEmetteur(
+        ctx,
+        emetteurChauffage,
+        periodeParDefaut
+      );
+
+      const tempFonctionnement30 = this.#chTvStore.temperatureFonctionnement(
+        '30',
+        generateurChauffageDE.enum_type_generateur_ch_id,
+        temperatureDistribution,
+        periodeInstallationEmetteur
+      );
+
+      const tempFonctionnement100 = this.#chTvStore.temperatureFonctionnement(
+        '100',
+        generateurChauffageDE.enum_type_generateur_ch_id,
+        temperatureDistribution,
+        periodeInstallationEmetteur
+      );
+
+      if (!temperatureFonctionnement30 || tempFonctionnement30 > temperatureFonctionnement30) {
+        temperatureFonctionnement30 = tempFonctionnement30;
+      }
+      if (!temperatureFonctionnement100 || tempFonctionnement100 > temperatureFonctionnement100) {
+        temperatureFonctionnement100 = tempFonctionnement100;
+      }
+    });
 
     return {
       temp_fonc_30: temperatureFonctionnement30,

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

@@ -1,6 +1,27 @@
 import { beforeEach, describe, expect, test, vi } from 'vitest';
-import { ChTvStore } from '../../../dpe/infrastructure/ch/chTv.store.js';
-import { EmetteurChService } from './emetteur-ch.service.js';
+
+/**
+ * Dépendances mockées :
+ * - `bug_for_bug_compat` (utils.js) : piloté par le test ;
+ * - `logger` : traces de déduction de la période des émetteurs (issue #220).
+ */
+const state = vi.hoisted(() => ({ bug: false }));
+
+vi.mock('../../../../utils.js', async (importOriginal) => ({
+  ...(await importOriginal()),
+  get bug_for_bug_compat() {
+    return state.bug;
+  }
+}));
+
+vi.mock('../../../../core/util/logger/log-service.js', () => ({
+  logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }
+}));
+
+const { ChTvStore } = await import('../../../dpe/infrastructure/ch/chTv.store.js');
+const { EmetteurChService, PERIODES_INSTALLATION_EMETTEUR } =
+  await import('./emetteur-ch.service.js');
+const { logger } = await import('../../../../core/util/logger/log-service.js');
 
 /** @type {EmetteurChService} **/
 let service;
@@ -10,6 +31,7 @@ let chTvStore;
 
 describe('Calcul des caractéristiques des générateurs de chauffage', () => {
   beforeEach(() => {
+    state.bug = false;
     chTvStore = new ChTvStore();
     service = new EmetteurChService(chTvStore);
   });
@@ -37,6 +59,19 @@ describe('Calcul des caractéristiques des générateurs de chauffage', () => {
     ).toBe(3);
   });
 
+  test("Période par défaut (déduite) utilisée uniquement si la période n'est pas saisie", () => {
+    expect(
+      service.periodeInstallationEmetteur({ anneeConstruction: 1850 }, { donnee_entree: {} }, 3)
+    ).toBe(3);
+    expect(
+      service.periodeInstallationEmetteur(
+        { anneeConstruction: 1850 },
+        { donnee_entree: { enum_periode_installation_emetteur_id: 1 } },
+        3
+      )
+    ).toBe(1);
+  });
+
   test('Détermination des températures de fonctionnement à 30 et 100% de charge', () => {
     vi.spyOn(chTvStore, 'temperatureFonctionnement')
       .mockReturnValueOnce(25)
@@ -76,3 +111,206 @@ describe('Calcul des caractéristiques des générateurs de chauffage', () => {
     expect(chTvStore.temperatureFonctionnement).toHaveBeenCalledWith('100', 80, 2, 2);
   });
 });
+
+/**
+ * Issue #220 - période d'installation des émetteurs absente du DPE.
+ * Mode strict : année de construction. Mode bug_for_bug_compat : période retrouvée à partir des
+ * temp_fonc_30 / temp_fonc_100 d'origine du DPE.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.1.5
+ */
+describe('Déduction de la période des émetteurs depuis les données du DPE (issue #220)', () => {
+  /**
+   * Table de test contrôlée (chaudière à condensation) :
+   * [température de distribution][période] -> [temp_fonc_30, temp_fonc_100].
+   */
+  const TABLE = {
+    2: { 1: [32, 60], 2: [24.5, 35], 3: [24.5, 35] },
+    3: { 1: [38, 80], 2: [35, 70], 3: [32, 60] },
+    4: { 1: [38, 80], 2: [35, 70], 3: [35, 70] }
+  };
+
+  const generateurDE = { enum_type_generateur_ch_id: '97' };
+
+  function emetteur(tempDistribution, periode) {
+    const de = { enum_temp_distribution_ch_id: tempDistribution };
+    if (periode) de.enum_periode_installation_emetteur_id = periode;
+    return { donnee_entree: de };
+  }
+
+  beforeEach(() => {
+    state.bug = true;
+    vi.mocked(logger.info).mockReset();
+    vi.mocked(logger.warn).mockReset();
+    chTvStore = new ChTvStore();
+    service = new EmetteurChService(chTvStore);
+    vi.spyOn(chTvStore, 'temperatureFonctionnement').mockImplementation(
+      (pourcentage, _type, tempDistribution, periode) =>
+        TABLE[tempDistribution]?.[periode]?.[pourcentage === '30' ? 0 : 1]
+    );
+  });
+
+  test('périodes candidates ordonnées de la plus ancienne à la plus récente', () => {
+    expect(PERIODES_INSTALLATION_EMETTEUR).toStrictEqual([1, 2, 3]);
+  });
+
+  test('T1 strict : bug_for_bug_compat désactivé -> aucune déduction (année de construction)', () => {
+    state.bug = false;
+    const ctx = { anneeConstruction: 1900 };
+    const periode = service.periodeInstallationEmetteurDeduite(ctx, generateurDE, [emetteur(3)], {
+      temp_fonc_30: 32,
+      temp_fonc_100: 60
+    });
+    expect(periode).toBeUndefined();
+    expect(chTvStore.temperatureFonctionnement).not.toHaveBeenCalled();
+    expect(
+      service.temperatureFonctionnement(ctx, generateurDE, [emetteur(3)], periode)
+    ).toStrictEqual({ temp_fonc_30: 38, temp_fonc_100: 80 });
+  });
+
+  test('T2 bug_for_bug_compat : DPE 32/60, construction 1900 -> période « après 2000 » (3)', () => {
+    const ctx = { anneeConstruction: 1900 };
+    const periode = service.periodeInstallationEmetteurDeduite(ctx, generateurDE, [emetteur(3)], {
+      temp_fonc_30: 32,
+      temp_fonc_100: 60
+    });
+    expect(periode).toBe(3);
+    expect(
+      service.temperatureFonctionnement(ctx, generateurDE, [emetteur(3)], periode)
+    ).toStrictEqual({ temp_fonc_30: 32, temp_fonc_100: 60 });
+    expect(logger.info).toHaveBeenCalledWith(
+      expect.stringContaining(
+        "période d'installation des émetteurs déduite des données intermédiaires du DPE"
+      )
+    );
+  });
+
+  test('T2 bis bug_for_bug_compat : valeurs du DPE sous forme de chaînes acceptées', () => {
+    expect(
+      service.periodeInstallationEmetteurDeduite(
+        { anneeConstruction: 1900 },
+        generateurDE,
+        [emetteur(3)],
+        { temp_fonc_30: '32', temp_fonc_100: '60' }
+      )
+    ).toBe(3);
+  });
+
+  test('T3 bug_for_bug_compat : période saisie -> aucune déduction, période saisie conservée', () => {
+    const ctx = { anneeConstruction: 1900 };
+    const emetteurs = [emetteur(3, 1)];
+    const periode = service.periodeInstallationEmetteurDeduite(ctx, generateurDE, emetteurs, {
+      temp_fonc_30: 32,
+      temp_fonc_100: 60
+    });
+    expect(periode).toBeUndefined();
+    expect(service.temperatureFonctionnement(ctx, generateurDE, emetteurs, 3)).toStrictEqual({
+      temp_fonc_30: 38,
+      temp_fonc_100: 80
+    });
+  });
+
+  test('T4 bug_for_bug_compat : distribution haute, construction 1990, DPE 35/70 -> période de construction (2)', () => {
+    expect(
+      service.periodeInstallationEmetteurDeduite(
+        { anneeConstruction: 1990 },
+        generateurDE,
+        [emetteur(4)],
+        { temp_fonc_30: 35, temp_fonc_100: 70 }
+      )
+    ).toBe(2);
+  });
+
+  test('T5 bug_for_bug_compat : DPE 33/62 hors tables -> aucune candidate, avertissement', () => {
+    expect(
+      service.periodeInstallationEmetteurDeduite(
+        { anneeConstruction: 1990 },
+        generateurDE,
+        [emetteur(3)],
+        { temp_fonc_30: 33, temp_fonc_100: 62 }
+      )
+    ).toBeUndefined();
+    expect(logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining("valeurs hors tables / donnée d'entrée incohérente")
+    );
+  });
+
+  test.each([
+    ['données intermédiaires absentes', undefined],
+    ['temp_fonc_100 absente', { temp_fonc_30: 32 }],
+    ['temp_fonc_30 absente', { temp_fonc_100: 60 }],
+    ['temp_fonc_30 non numérique', { temp_fonc_30: 'abc', temp_fonc_100: 60 }],
+    ['temp_fonc_100 vide', { temp_fonc_30: 32, temp_fonc_100: '' }],
+    ['temp_fonc_30 nulle', { temp_fonc_30: null, temp_fonc_100: 60 }]
+  ])('T6 bug_for_bug_compat : %s -> aucune déduction', (_, di) => {
+    expect(
+      service.periodeInstallationEmetteurDeduite(
+        { anneeConstruction: 1900 },
+        generateurDE,
+        [emetteur(3)],
+        di
+      )
+    ).toBeUndefined();
+    expect(chTvStore.temperatureFonctionnement).not.toHaveBeenCalled();
+  });
+
+  test('T7 bug_for_bug_compat : deux émetteurs sans période (moyenne + haute), DPE 35/70 -> règle du maximum, période la plus récente', () => {
+    /**
+     * 1 : max(38, 38) / max(80, 80) -> rejetée ; 2 : 35/70 -> candidate ;
+     * 3 : max(32, 35) / max(60, 70) = 35/70 -> candidate.
+     * Construction 1900 (période 1) hors candidates -> la plus récente : 3.
+     */
+    const ctx = { anneeConstruction: 1900 };
+    const emetteurs = [emetteur(3), emetteur(4)];
+    const periode = service.periodeInstallationEmetteurDeduite(ctx, generateurDE, emetteurs, {
+      temp_fonc_30: 35,
+      temp_fonc_100: 70
+    });
+    expect(periode).toBe(3);
+    expect(service.temperatureFonctionnement(ctx, generateurDE, emetteurs, periode)).toStrictEqual({
+      temp_fonc_30: 35,
+      temp_fonc_100: 70
+    });
+  });
+
+  test('bug_for_bug_compat : seul un émetteur sans réseau de distribution est sans période -> aucune déduction', () => {
+    expect(
+      service.periodeInstallationEmetteurDeduite(
+        { anneeConstruction: 1900 },
+        generateurDE,
+        [emetteur(1), emetteur(3, 1)],
+        { temp_fonc_30: 32, temp_fonc_100: 60 }
+      )
+    ).toBeUndefined();
+  });
+
+  test('bug_for_bug_compat : aucune valeur de table trouvée -> aucune candidate', () => {
+    vi.mocked(chTvStore.temperatureFonctionnement).mockReturnValue(undefined);
+    expect(
+      service.periodeInstallationEmetteurDeduite(
+        { anneeConstruction: 1900 },
+        generateurDE,
+        [emetteur(3)],
+        { temp_fonc_30: 32, temp_fonc_100: 60 }
+      )
+    ).toBeUndefined();
+  });
+
+  test('bug_for_bug_compat : une seule des deux valeurs reproduite -> période rejetée (tolérance 0,01 °C)', () => {
+    expect(
+      service.periodeInstallationEmetteurDeduite(
+        { anneeConstruction: 1900 },
+        generateurDE,
+        [emetteur(3)],
+        { temp_fonc_30: 32, temp_fonc_100: 60.02 }
+      )
+    ).toBeUndefined();
+    expect(
+      service.periodeInstallationEmetteurDeduite(
+        { anneeConstruction: 1900 },
+        generateurDE,
+        [emetteur(3)],
+        { temp_fonc_30: 32.005, temp_fonc_100: 59.995 }
+      )
+    ).toBe(3);
+  });
+});

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

@@ -309,10 +309,24 @@ export class GenerateurChService {
         temp_fonc_100: generateurChauffageDI.temp_fonc_100
       };
     } else {
+      /**
+       * Mode bug_for_bug_compat (issue #220) : période d'installation des émetteurs non exportée
+       * retrouvée à partir des temp_fonc_30 / temp_fonc_100 d'origine du DPE (données
+       * intermédiaires du générateur, non encore recalculées à ce stade). Sans déduction possible,
+       * la règle §13.2.1.5 s'applique (année de construction).
+       * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.1.5
+       */
+      const periodeDeduite = this.#emetteurChService.periodeInstallationEmetteurDeduite(
+        ctx,
+        generateurChauffageDE,
+        emetteursChauffage,
+        generateurChauffageDI
+      );
       return this.#emetteurChService.temperatureFonctionnement(
         ctx,
         generateurChauffage.donnee_entree,
-        emetteursChauffage
+        emetteursChauffage,
+        periodeDeduite
       );
     }
   }

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

@@ -0,0 +1,81 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { GenerateurChService } from './generateur-ch.service.js';
+import { EmetteurChService } from './emetteur-ch.service.js';
+import { ChTvStore } from '../../../dpe/infrastructure/ch/chTv.store.js';
+import { TvStore } from '../../../dpe/infrastructure/tv.store.js';
+
+/** @type {GenerateurChService} **/
+let service;
+
+/** @type {EmetteurChService} **/
+let emetteurChService;
+
+/**
+ * Températures de fonctionnement du générateur (délégation au service émetteurs).
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.1.5
+ */
+describe('Températures de fonctionnement des générateurs de chauffage', () => {
+  const ctx = { anneeConstruction: 1900 };
+  const emetteurs = [{ donnee_entree: { enum_temp_distribution_ch_id: 3 } }];
+
+  beforeEach(() => {
+    emetteurChService = new EmetteurChService(new ChTvStore());
+    service = new GenerateurChService(new ChTvStore(), new TvStore(), emetteurChService);
+    vi.spyOn(emetteurChService, 'temperatureFonctionnement').mockReturnValue({
+      temp_fonc_30: 32,
+      temp_fonc_100: 60
+    });
+    vi.spyOn(emetteurChService, 'periodeInstallationEmetteurDeduite').mockReturnValue(3);
+  });
+
+  test('caractéristiques saisies (méthode 5) avec temp_fonc_30 et temp_fonc_100 : valeurs conservées', () => {
+    const generateur = {
+      donnee_entree: { enum_methode_saisie_carac_sys_id: 5, enum_type_generateur_ch_id: '97' },
+      donnee_intermediaire: { temp_fonc_30: 41, temp_fonc_100: 72 }
+    };
+    expect(service.temperatureFonctionnement(ctx, generateur, emetteurs)).toStrictEqual({
+      temp_fonc_30: 41,
+      temp_fonc_100: 72
+    });
+    expect(emetteurChService.periodeInstallationEmetteurDeduite).not.toHaveBeenCalled();
+    expect(emetteurChService.temperatureFonctionnement).not.toHaveBeenCalled();
+  });
+
+  test('valeurs forfaitaires : période déduite des données intermédiaires du DPE transmise au calcul (issue #220)', () => {
+    const generateurDE = { enum_methode_saisie_carac_sys_id: 1, enum_type_generateur_ch_id: '97' };
+    const generateurDI = { temp_fonc_30: 32, temp_fonc_100: 60 };
+    const generateur = { donnee_entree: generateurDE, donnee_intermediaire: generateurDI };
+
+    expect(service.temperatureFonctionnement(ctx, generateur, emetteurs)).toStrictEqual({
+      temp_fonc_30: 32,
+      temp_fonc_100: 60
+    });
+    // Les valeurs d'origine du DPE (di du générateur) servent à la déduction
+    expect(emetteurChService.periodeInstallationEmetteurDeduite).toHaveBeenCalledWith(
+      ctx,
+      generateurDE,
+      emetteurs,
+      generateurDI
+    );
+    expect(emetteurChService.temperatureFonctionnement).toHaveBeenCalledWith(
+      ctx,
+      generateurDE,
+      emetteurs,
+      3
+    );
+  });
+
+  test('méthode 5 sans temp_fonc_100 : calcul forfaitaire depuis les émetteurs', () => {
+    vi.mocked(emetteurChService.periodeInstallationEmetteurDeduite).mockReturnValue(undefined);
+    const generateurDE = { enum_methode_saisie_carac_sys_id: 5, enum_type_generateur_ch_id: '97' };
+    const generateur = { donnee_entree: generateurDE, donnee_intermediaire: { temp_fonc_30: 32 } };
+
+    service.temperatureFonctionnement(ctx, generateur, emetteurs);
+    expect(emetteurChService.temperatureFonctionnement).toHaveBeenCalledWith(
+      ctx,
+      generateurDE,
+      emetteurs,
+      undefined
+    );
+  });
+});

package/package.json

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