@open3cl/engine 1.8.13 → 1.8.15

package/13.2_generateur_combustion.js

@@ -200,6 +200,7 @@ export function tv_generateur_combustion(dpe, di, de, type, GV, tbase, methodeSa
     if (
       bug_for_bug_compat &&
       type === 'ecs' &&
+      row &&
       row.tv_generateur_combustion_id !== de.tv_generateur_combustion_id
     ) {
       const rowDpe = tv('generateur_combustion', {
@@ -223,7 +224,7 @@ export function tv_generateur_combustion(dpe, di, de, type, GV, tbase, methodeSa
 
   if (!row) {
     console.error(
-      'Pas de valeur forfaitaire trouvée pour le générateur à combustion ${de.description}'
+      `Pas de valeur forfaitaire trouvée pour le générateur à combustion ${de.description} (${typeGenerateurKey} = '${enumTypeGenerateurId}')`
     );
     return;
   }
@@ -377,21 +378,21 @@ function checkEcsVsChauffageForMixteGeneration(dpe, de, typeGenerateurKey) {
     );
   }, []);
 
-  if (generateursChMixtes.length) {
-    const firstChGenerateurMixte = generateursChMixtes[0];
-    const firstChGenerateurMixteId =
-      firstChGenerateurMixte.donnee_entree.enum_type_generateur_ch_id;
+  const chGenerateurMixte = findGenerateurChMixteJumeau(generateursChMixtes, de);
+
+  if (chGenerateurMixte) {
+    const chGenerateurMixteId = chGenerateurMixte.donnee_entree.enum_type_generateur_ch_id;
     const typeGenerateurEcs = enums.type_generateur_ecs;
     const typeGenerateurCh = enums.type_generateur_ch;
 
     const ecsGenerateurType = typeGenerateurEcs[ecsGenerateurId];
-    const chGenerateurType = typeGenerateurCh[firstChGenerateurMixteId];
+    const chGenerateurType = typeGenerateurCh[chGenerateurMixteId];
 
     // Si les 2 générateurs n'ont pas le même type
     if (ecsGenerateurType !== chGenerateurType) {
       // Recherche de l'identifiant du générateur ECS identique au générateur de chauffage
       const newEcsGenerateurId = Object.keys(typeGenerateurEcs).find(
-        (key) => typeGenerateurEcs[key] === typeGenerateurCh[firstChGenerateurMixteId]
+        (key) => typeGenerateurEcs[key] === typeGenerateurCh[chGenerateurMixteId]
       );
 
       if (newEcsGenerateurId) {
@@ -407,3 +408,64 @@ function checkEcsVsChauffageForMixteGeneration(dpe, de, typeGenerateurKey) {
 
   return ecsGenerateurId;
 }
+
+/**
+ * Recherche du générateur de chauffage mixte « jumeau » du générateur ECS mixte.
+ * Méthode 3CL-DPE 2021 §13.2 et §14 : un générateur mixte chauffage + ECS est un seul et même
+ * appareil, avec les mêmes caractéristiques pour les deux usages. Il ne faut donc pas apparier le
+ * générateur ECS avec n'importe quel générateur de chauffage mixte du DPE (issue #210).
+ *
+ * Ordre de recherche :
+ * 1. même `reference_generateur_mixte` ;
+ * 2. même `tv_generateur_combustion_id` ;
+ * 3. même énergie (`enum_type_energie_id`), si un seul générateur de chauffage mixte correspond ;
+ * 4. générateur de chauffage mixte unique du DPE, si son énergie n'est pas incompatible.
+ *
+ * @param generateursChMixtes {GenerateurChauffageItem[]} générateurs de chauffage d'usage 'chauffage + ecs'
+ * @param de {Donnee_entree} données du générateur ECS
+ * @returns {GenerateurChauffageItem|null} null si aucun jumeau ne peut être identifié sans ambiguïté
+ */
+export function findGenerateurChMixteJumeau(generateursChMixtes, de) {
+  const sameValue = (a, b) =>
+    a !== undefined && a !== null && b !== undefined && b !== null && String(a) === String(b);
+
+  if (de.reference_generateur_mixte) {
+    const generateur = generateursChMixtes.find((ch) =>
+      sameValue(ch.donnee_entree.reference_generateur_mixte, de.reference_generateur_mixte)
+    );
+    if (generateur) return generateur;
+  }
+
+  if (de.tv_generateur_combustion_id) {
+    const generateur = generateursChMixtes.find((ch) =>
+      sameValue(ch.donnee_entree.tv_generateur_combustion_id, de.tv_generateur_combustion_id)
+    );
+    if (generateur) return generateur;
+  }
+
+  if (de.enum_type_energie_id) {
+    const generateurs = generateursChMixtes.filter((ch) =>
+      sameValue(ch.donnee_entree.enum_type_energie_id, de.enum_type_energie_id)
+    );
+    if (generateurs.length === 1) return generateurs[0];
+    // Plusieurs générateurs de même énergie et de même type : jumeaux identiques,
+    // aucune ambiguïté sur le type à retenir pour l'ECS (cas 2275E1945671L)
+    const type = generateurs[0]?.donnee_entree.enum_type_generateur_ch_id;
+    if (
+      generateurs.length > 1 &&
+      generateurs.every((ch) => sameValue(ch.donnee_entree.enum_type_generateur_ch_id, type))
+    ) {
+      return generateurs[0];
+    }
+  }
+
+  if (generateursChMixtes.length === 1) {
+    const generateur = generateursChMixtes[0];
+    const energieCh = generateur.donnee_entree.enum_type_energie_id;
+    if (!de.enum_type_energie_id || !energieCh || sameValue(energieCh, de.enum_type_energie_id)) {
+      return generateur;
+    }
+  }
+
+  return null;
+}

package/13.2_generateur_combustion.spec.js

@@ -62,6 +62,7 @@ vi.mock('./13.2_generateur_combustion_pn.js', () => ({
 
 const {
   tv_generateur_combustion,
+  findGenerateurChMixteJumeau,
   updateGenerateurCombustion,
   caracteristiquesGenerateurCombustion
 } = await import('./13.2_generateur_combustion.js');
@@ -607,6 +608,201 @@ describe('tv_generateur_combustion - génération mixte (checkEcsVsChauffageForM
   });
 });
 
+/**
+ * Issue #210 : l'ECS mixte doit être appariée avec SON générateur de chauffage mixte (même appareil),
+ * et non avec le premier générateur de chauffage mixte du DPE.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2 et §14
+ */
+describe('findGenerateurChMixteJumeau - appariement ECS / chauffage mixte (issue #210)', () => {
+  const ch = (donnees) => ({ donnee_entree: { enum_usage_generateur_id: '3', ...donnees } });
+
+  test('même reference_generateur_mixte : prioritaire sur le tv_generateur_combustion_id', () => {
+    const chTv = ch({ tv_generateur_combustion_id: '11' });
+    const chRef = ch({ reference_generateur_mixte: 'GEN#1', tv_generateur_combustion_id: '13' });
+    const de = { reference_generateur_mixte: 'GEN#1', tv_generateur_combustion_id: '11' };
+    expect(findGenerateurChMixteJumeau([chTv, chRef], de)).toBe(chRef);
+  });
+
+  test('reference_generateur_mixte sans correspondance : repli sur le tv_generateur_combustion_id', () => {
+    const chElec = ch({ reference_generateur_mixte: 'AUTRE', tv_generateur_combustion_id: null });
+    const chGaz = ch({ tv_generateur_combustion_id: 11 });
+    const de = { reference_generateur_mixte: 'GEN#1', tv_generateur_combustion_id: '11' };
+    // Comparaison insensible au type (nombre / chaîne)
+    expect(findGenerateurChMixteJumeau([chElec, chGaz], de)).toBe(chGaz);
+  });
+
+  test('cas 2448E4606320D : ECS gaz (tv 11) appariée au CH 95 (tv 11) et non au premier CH mixte (106, électrique)', () => {
+    const ch106 = ch({ enum_type_generateur_ch_id: '106', enum_type_energie_id: '1' });
+    const ch95 = ch({
+      enum_type_generateur_ch_id: '95',
+      tv_generateur_combustion_id: '11',
+      enum_type_energie_id: '2'
+    });
+    const de = {
+      enum_type_generateur_ecs_id: '55',
+      tv_generateur_combustion_id: '11',
+      enum_type_energie_id: '2'
+    };
+    expect(findGenerateurChMixteJumeau([ch106, ch95], de)).toBe(ch95);
+  });
+
+  test('cas 2193E1043519Y : ECS gaz (tv 13) appariée au CH 97 (tv 13) et non au CH 111 (réseau de chaleur)', () => {
+    const ch111 = ch({ enum_type_generateur_ch_id: '111', enum_type_energie_id: '2' });
+    const ch97 = ch({
+      enum_type_generateur_ch_id: '97',
+      tv_generateur_combustion_id: '13',
+      enum_type_energie_id: '2'
+    });
+    const de = {
+      enum_type_generateur_ecs_id: '57',
+      tv_generateur_combustion_id: '13',
+      enum_type_energie_id: '2'
+    };
+    expect(findGenerateurChMixteJumeau([ch111, ch97], de)).toBe(ch97);
+  });
+
+  test('pas de référence ni de tv commun : un seul générateur de même énergie → retenu', () => {
+    const chElec = ch({ enum_type_energie_id: '1' });
+    const chFioul = ch({ enum_type_energie_id: '3' });
+    const de = { tv_generateur_combustion_id: '99', enum_type_energie_id: '3' };
+    expect(findGenerateurChMixteJumeau([chElec, chFioul], de)).toBe(chFioul);
+  });
+
+  test('plusieurs générateurs de même énergie sans autre critère : ambiguïté → aucun appariement', () => {
+    const de = { enum_type_energie_id: '2' };
+    const generateurs = [ch({ enum_type_energie_id: '2' }), ch({ enum_type_energie_id: '2' })];
+    expect(findGenerateurChMixteJumeau(generateurs, de)).toBeNull();
+  });
+
+  test('plusieurs générateurs de même énergie et de types différents : ambiguïté → aucun appariement', () => {
+    const de = { enum_type_energie_id: '13' };
+    const generateurs = [
+      ch({ enum_type_generateur_ch_id: '134', enum_type_energie_id: '13' }),
+      ch({ enum_type_generateur_ch_id: '92', enum_type_energie_id: '13' })
+    ];
+    expect(findGenerateurChMixteJumeau(generateurs, de)).toBeNull();
+  });
+
+  test('cas 2275E1945671L : plusieurs générateurs de même énergie et de même type → le premier est retenu', () => {
+    const ch1 = ch({
+      enum_type_generateur_ch_id: '134',
+      enum_type_energie_id: '13',
+      tv_generateur_combustion_id: '8'
+    });
+    const ch2 = ch({
+      enum_type_generateur_ch_id: 134,
+      enum_type_energie_id: 13,
+      tv_generateur_combustion_id: '8'
+    });
+    const de = {
+      enum_type_generateur_ecs_id: '92',
+      tv_generateur_combustion_id: '1',
+      enum_type_energie_id: '13'
+    };
+    expect(findGenerateurChMixteJumeau([ch1, ch2], de)).toBe(ch1);
+  });
+
+  test('générateur de chauffage mixte unique sans énergie renseignée : retenu (comportement historique)', () => {
+    const unique = ch({ enum_type_generateur_ch_id: 'X' });
+    expect(findGenerateurChMixteJumeau([unique], { enum_type_energie_id: '2' })).toBe(unique);
+    expect(findGenerateurChMixteJumeau([unique], {})).toBe(unique);
+  });
+
+  test('générateur de chauffage mixte unique d’une autre énergie : pas son jumeau → aucun appariement', () => {
+    const unique = ch({ enum_type_energie_id: '1' });
+    expect(findGenerateurChMixteJumeau([unique], { enum_type_energie_id: '2' })).toBeNull();
+  });
+
+  test('aucun générateur de chauffage mixte : aucun appariement', () => {
+    expect(findGenerateurChMixteJumeau([], { tv_generateur_combustion_id: '11' })).toBeNull();
+  });
+});
+
+describe('tv_generateur_combustion - génération mixte avec plusieurs générateurs de chauffage (issue #210)', () => {
+  function dpeAvecChMixtes(generateurs) {
+    return {
+      logement: {
+        installation_chauffage_collection: {
+          installation_chauffage: generateurs.map((donnees) => ({
+            generateur_chauffage_collection: {
+              generateur_chauffage: [
+                { donnee_entree: { enum_usage_generateur_id: '3', ...donnees } }
+              ]
+            }
+          }))
+        }
+      }
+    };
+  }
+
+  test('le type ECS est aligné sur le jumeau (même tv) et non sur le premier générateur mixte', () => {
+    state.bug = true;
+    tv.mockReturnValue({ ...ROW_DEFAUT });
+    // 1er CH mixte 'X' (fioul, autre tv), jumeau 'Y' (gaz, même tv 42) -> ECS 'A' (gaz) conservée
+    const dpe = dpeAvecChMixtes([
+      { enum_type_generateur_ch_id: 'X', tv_generateur_combustion_id: '7' },
+      { enum_type_generateur_ch_id: 'Y', tv_generateur_combustion_id: '42' }
+    ]);
+    const de = {
+      enum_type_generateur_ecs_id: 'A',
+      enum_usage_generateur_id: '3',
+      tv_generateur_combustion_id: '42',
+      ratio_virtualisation: 1,
+      presence_ventouse: 0
+    };
+    tv_generateur_combustion(dpe, { pn: 20000 }, de, 'ecs', 200, -9, 1);
+    expect(tv).toHaveBeenCalledWith(
+      'generateur_combustion',
+      expect.objectContaining({ enum_type_generateur_ecs_id: 'A' })
+    );
+    expect(tv).not.toHaveBeenCalledWith(
+      'generateur_combustion',
+      expect.objectContaining({ enum_type_generateur_ecs_id: 'B' })
+    );
+  });
+
+  test('jumeau non identifiable (ambiguïté) : type ECS conservé', () => {
+    state.bug = true;
+    tv.mockReturnValue({ ...ROW_DEFAUT });
+    // Deux CH mixtes de même énergie mais de types différents : aucun jumeau certain
+    const dpe = dpeAvecChMixtes([
+      { enum_type_generateur_ch_id: 'X', enum_type_energie_id: '2' },
+      { enum_type_generateur_ch_id: 'Z', enum_type_energie_id: '2' }
+    ]);
+    const de = {
+      enum_type_generateur_ecs_id: 'A',
+      enum_usage_generateur_id: '3',
+      enum_type_energie_id: '2',
+      tv_generateur_combustion_id: '42',
+      ratio_virtualisation: 1,
+      presence_ventouse: 0
+    };
+    tv_generateur_combustion(dpe, { pn: 20000 }, de, 'ecs', 200, -9, 1);
+    expect(tv).toHaveBeenCalledWith(
+      'generateur_combustion',
+      expect.objectContaining({ enum_type_generateur_ecs_id: 'A' })
+    );
+  });
+
+  test('aucune ligne forfaitaire pour un générateur ECS mixte : erreur sans plantage', () => {
+    state.bug = true;
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    tv.mockReturnValue(null);
+    const de = {
+      enum_type_generateur_ecs_id: 'A',
+      enum_usage_generateur_id: '3',
+      tv_generateur_combustion_id: '42',
+      ratio_virtualisation: 1,
+      presence_ventouse: 0
+    };
+    expect(() =>
+      tv_generateur_combustion(dpeAvecChMixtes([]), { pn: 20000 }, de, 'ecs', 200, -9, 1)
+    ).not.toThrow();
+    expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('Pas de valeur forfaitaire'));
+    errSpy.mockRestore();
+  });
+});
+
 /**
  * 13.2 - Orchestration des substitutions de générateurs et enrichissement fiches techniques.
  * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2

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);