@open3cl/engine 1.8.10 → 1.8.12

package/13.2_generateur_combustion.js

@@ -1,7 +1,10 @@
 import { bug_for_bug_compat, convertExpression, tv, tvColumnLines } from './utils.js';
 import enums from './enums.js';
 import { updateGenerateurBouilleurs } from './13.2_generateur_combustion_bouilleur.js';
-import { updateGenerateurChaudieres } from './13.2_generateur_combustion_chaudiere.js';
+import {
+  getChaudiereFioulDefautId,
+  updateGenerateurChaudieres
+} from './13.2_generateur_combustion_chaudiere.js';
 import { updateGenerateurPacs } from './13.2_generateur_pac.js';
 import getFicheTechnique from './ficheTechnique.js';
 import { evaluateFormula as evaluateTvFormula } from './formula.js';
@@ -128,6 +131,35 @@ export function tv_generateur_combustion(dpe, di, de, type, GV, tbase, methodeSa
     enumTypeGenerateurId = checkEcsVsChauffageForMixteGeneration(dpe, de, typeGenerateurKey);
   }
 
+  /**
+   * Système collectif par défaut : chaudière fioul standard datant de la construction du bâtiment.
+   * Si tv_generateur_combustion_id pointe vers une chaudière fioul compatible avec le système par défaut,
+   * la période de la chaudière est déterminée à partir de l'année de construction du bâtiment.
+   * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - §17.2.1.1
+   */
+  if (
+    ((type === 'ecs' && enumTypeGenerateurId === '84') ||
+      (type === 'ch' && enumTypeGenerateurId === '119')) &&
+    de.tv_generateur_combustion_id
+  ) {
+    const rowDpe = tv('generateur_combustion', {
+      tv_generateur_combustion_id: de.tv_generateur_combustion_id
+    });
+    const chaudiereFioulDefautId = getChaudiereFioulDefautId(
+      dpe,
+      type,
+      rowDpe?.[typeGenerateurKey]?.split('|')[0]
+    );
+
+    if (
+      chaudiereFioulDefautId &&
+      rowDpe?.[typeGenerateurKey]?.split('|').includes(enumTypeGenerateurId)
+    ) {
+      enumTypeGenerateurId = chaudiereFioulDefautId;
+      de[typeGenerateurKey] = chaudiereFioulDefautId;
+    }
+  }
+
   /**
    * Si le type de générateur est
    * 84 - ECS - système collectif par défaut en abscence d'information : chaudière fioul pénalisante

package/13.2_generateur_combustion.spec.js

@@ -43,7 +43,8 @@ vi.mock('./13.2_generateur_combustion_bouilleur.js', () => ({
   updateGenerateurBouilleurs: vi.fn()
 }));
 vi.mock('./13.2_generateur_combustion_chaudiere.js', () => ({
-  updateGenerateurChaudieres: vi.fn()
+  updateGenerateurChaudieres: vi.fn(),
+  getChaudiereFioulDefautId: vi.fn()
 }));
 vi.mock('./13.2_generateur_pac.js', () => ({
   updateGenerateurPacs: vi.fn()
@@ -67,7 +68,8 @@ const {
 const { tv, tvColumnLines } = await import('./utils.js');
 const { conventionPuissanceNominale } = await import('./13.2_generateur_combustion_pn.js');
 const { updateGenerateurBouilleurs } = await import('./13.2_generateur_combustion_bouilleur.js');
-const { updateGenerateurChaudieres } = await import('./13.2_generateur_combustion_chaudiere.js');
+const { updateGenerateurChaudieres, getChaudiereFioulDefautId } =
+  await import('./13.2_generateur_combustion_chaudiere.js');
 const { updateGenerateurPacs } = await import('./13.2_generateur_pac.js');
 const { default: getFicheTechnique } = await import('./ficheTechnique.js');
 
@@ -77,6 +79,7 @@ beforeEach(() => {
   vi.mocked(tvColumnLines).mockReturnValue([]);
   vi.mocked(updateGenerateurBouilleurs).mockReset();
   vi.mocked(updateGenerateurChaudieres).mockReset();
+  vi.mocked(getChaudiereFioulDefautId).mockReset();
   vi.mocked(updateGenerateurPacs).mockReset();
   vi.mocked(getFicheTechnique).mockReset();
   vi.mocked(conventionPuissanceNominale).mockReset();
@@ -317,6 +320,87 @@ describe('tv_generateur_combustion - compatibilité bug_for_bug_compat', () => {
     vi.restoreAllMocks();
   });
 
+  /**
+   * Système collectif par défaut : chaudière fioul standard datant de la construction du bâtiment.
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §17.2.1.1
+   */
+  describe('système collectif par défaut : chaudière selon l’année de construction', () => {
+    test('CH 119 + ligne compatible : type et ligne de la période de construction retenus', () => {
+      vi.mocked(getChaudiereFioulDefautId).mockReturnValue('79');
+      tv.mockImplementation((table, matcher) => {
+        if (matcher.tv_generateur_combustion_id === '16') {
+          return { tv_generateur_combustion_id: '16', enum_type_generateur_ch_id: '75|119' };
+        }
+        return { ...ROW_DEFAUT, tv_generateur_combustion_id: '20' };
+      });
+      const dpe = { logement: {} };
+      const di = { pn: 20000 };
+      const de = {
+        enum_type_generateur_ch_id: '119',
+        tv_generateur_combustion_id: '16',
+        ratio_virtualisation: 1,
+        presence_ventouse: 0
+      };
+      tv_generateur_combustion(dpe, di, de, 'ch', 200, -9, 1);
+
+      expect(getChaudiereFioulDefautId).toHaveBeenCalledWith(dpe, 'ch', '75');
+      expect(de.enum_type_generateur_ch_id).toBe('79');
+      // La ligne est recherchée avec le type de la période de construction
+      expect(tv).toHaveBeenCalledWith(
+        'generateur_combustion',
+        expect.objectContaining({ enum_type_generateur_ch_id: '79' })
+      );
+      expect(de.tv_generateur_combustion_id).toBe(20);
+    });
+
+    test('ECS 84 + ligne compatible : type de la période de construction retenu', () => {
+      vi.mocked(getChaudiereFioulDefautId).mockReturnValue('39');
+      tv.mockImplementation((table, matcher) => {
+        if (matcher.tv_generateur_combustion_id === '16') {
+          return { tv_generateur_combustion_id: '16', enum_type_generateur_ecs_id: '35|84' };
+        }
+        return { ...ROW_DEFAUT, tv_generateur_combustion_id: '20' };
+      });
+      const de = {
+        enum_type_generateur_ecs_id: '84',
+        tv_generateur_combustion_id: '16',
+        ratio_virtualisation: 1,
+        presence_ventouse: 0
+      };
+      tv_generateur_combustion({}, { pn: 20000 }, de, 'ecs', 200, -9, 1);
+
+      expect(getChaudiereFioulDefautId).toHaveBeenCalledWith({}, 'ecs', '35');
+      expect(de.enum_type_generateur_ecs_id).toBe('39');
+      expect(de.tv_generateur_combustion_id).toBe(20);
+    });
+
+    test('ligne non compatible avec le système par défaut : type inchangé', () => {
+      vi.mocked(getChaudiereFioulDefautId).mockReturnValue('39');
+      tv.mockReturnValue({ ...ROW_DEFAUT, enum_type_generateur_ecs_id: '57|104' });
+      const de = {
+        enum_type_generateur_ecs_id: '84',
+        tv_generateur_combustion_id: '42',
+        ratio_virtualisation: 1,
+        presence_ventouse: 0
+      };
+      tv_generateur_combustion({}, { pn: 20000 }, de, 'ecs', 200, -9, 1);
+      expect(de.enum_type_generateur_ecs_id).toBe('84');
+    });
+
+    test('année de construction inconnue : type inchangé', () => {
+      vi.mocked(getChaudiereFioulDefautId).mockReturnValue(undefined);
+      tv.mockReturnValue({ ...ROW_DEFAUT, enum_type_generateur_ch_id: '75|119' });
+      const de = {
+        enum_type_generateur_ch_id: '119',
+        tv_generateur_combustion_id: '16',
+        ratio_virtualisation: 1,
+        presence_ventouse: 0
+      };
+      tv_generateur_combustion({}, { pn: 20000 }, de, 'ch', 200, -9, 1);
+      expect(de.enum_type_generateur_ch_id).toBe('119');
+    });
+  });
+
   test('type 84 sans tv_generateur_combustion_id : retour au chemin forfaitaire nominal', () => {
     state.bug = true;
     tv.mockReturnValue({ ...ROW_DEFAUT });

package/13.2_generateur_combustion_chaudiere.js

@@ -1,5 +1,93 @@
 import getFicheTechnique from './ficheTechnique.js';
 
+/**
+ * Ids des chaudières fioul classiques / standard pour les différentes périodes d'installation
+ * (seuil = première année de la période)
+ */
+const CHAUDIERES_FIOUL_ECS = {
+  1948: '35',
+  1970: '36',
+  1976: '37',
+  1981: '38',
+  1991: '39',
+  2015: '40'
+};
+
+const CHAUDIERES_FIOUL_CH = {
+  1948: '75',
+  1970: '76',
+  1976: '77',
+  1981: '78',
+  1991: '79',
+  2015: '80'
+};
+
+/**
+ * Retourne l'identifiant associé au plus grand seuil inférieur ou égal à l'année donnée.
+ * Pour une année antérieure au premier seuil, l'identifiant du premier seuil est retenu.
+ * @param values {Record<string, string>}
+ * @param annee {number}
+ * @returns {string}
+ */
+export function findIdForAnnee(values, annee) {
+  const entries = Object.entries(values).sort((a, b) => b[0] - a[0]);
+
+  for (const [threshold, value] of entries) {
+    if (annee >= Number(threshold)) {
+      return value;
+    }
+  }
+
+  return entries[entries.length - 1][1];
+}
+
+/**
+ * Système collectif par défaut en absence d'information : chaudière fioul pénalisante
+ * (enum_type_generateur_ch_id = 119 / enum_type_generateur_ecs_id = 84)
+ *
+ * "En présence d'une installation de production collective de chauffage et d'ECS, si aucune information n'est
+ * communiquée sur les équipements collectifs, un calcul par défaut se fera avec une chaudière atmosphérique mixte
+ * standard datant de la construction du bâtiment. L'énergie utilisée par le système sera du fioul."
+ * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - §17.2.1.1
+ *
+ * Retourne l'identifiant de la chaudière fioul dont la période correspond à l'année de construction du bâtiment,
+ * ou undefined si l'année de construction n'est pas connue.
+ *
+ * Si la ligne tv_generateur_combustion_id saisie correspond à une chaudière fioul dont la période est
+ * postérieure ou égale à celle de la construction (chaudière remplacée), l'information est connue et
+ * doit être utilisée : "Dans le cas où certaines de ces informations sont connues sur l'installation
+ * collective, elles pourront être utilisées" (§17.2.1.1). Seule une période saisie antérieure à la
+ * construction, non crédible, est redressée.
+ *
+ * @param dpe {FullDpe}
+ * @param type {'ch' | 'ecs'}
+ * @param typeSaisiId {string|undefined} type de chaudière correspondant à la ligne tv saisie
+ * @returns {string|undefined}
+ */
+export function getChaudiereFioulDefautId(dpe, type, typeSaisiId) {
+  const anneeConstruction = parseInt(
+    dpe?.logement?.caracteristique_generale?.annee_construction,
+    10
+  );
+
+  if (Number.isNaN(anneeConstruction)) {
+    return undefined;
+  }
+
+  const chaudieres = type === 'ecs' ? CHAUDIERES_FIOUL_ECS : CHAUDIERES_FIOUL_CH;
+  const chaudiereConstructionId = findIdForAnnee(chaudieres, anneeConstruction);
+  const ids = Object.values(chaudieres);
+
+  if (
+    ids.includes(typeSaisiId) &&
+    ids.indexOf(typeSaisiId) >= ids.indexOf(chaudiereConstructionId)
+  ) {
+    return typeSaisiId;
+  }
+
+  return chaudiereConstructionId;
+}
+
 /**
  * Pour les générateurs "Autre système à combustion", les calculs sont faits comme pour les chaudières standard
  * @param dpe {FullDpe}
@@ -27,14 +115,7 @@ export function updateGenerateurChaudieres(dpe, de, type) {
         2001: '49',
         2015: '50'
       },
-      79: {
-        1948: '35',
-        1970: '36',
-        1976: '37',
-        1981: '38',
-        1991: '39',
-        2015: '40'
-      },
+      79: CHAUDIERES_FIOUL_ECS,
       80: {
         1948: '15',
         1978: '16',
@@ -44,14 +125,7 @@ export function updateGenerateurChaudieres(dpe, de, type) {
         2018: '20',
         2019: '21'
       },
-      81: {
-        1948: '35',
-        1970: '36',
-        1976: '37',
-        1981: '38',
-        1991: '39',
-        2015: '40'
-      }
+      81: CHAUDIERES_FIOUL_ECS
     };
   } else {
     /**
@@ -71,14 +145,7 @@ export function updateGenerateurChaudieres(dpe, de, type) {
         2001: '89',
         2015: '90'
       },
-      114: {
-        1948: '75',
-        1970: '76',
-        1976: '77',
-        1981: '78',
-        1991: '79',
-        2015: '80'
-      },
+      114: CHAUDIERES_FIOUL_CH,
       115: {
         1948: '55',
         1978: '56',
@@ -88,14 +155,7 @@ export function updateGenerateurChaudieres(dpe, de, type) {
         2018: '60',
         2019: '61'
       },
-      116: {
-        1948: '75',
-        1970: '76',
-        1976: '77',
-        1981: '78',
-        1991: '79',
-        2015: '80'
-      }
+      116: CHAUDIERES_FIOUL_CH
     };
   }
 

package/13.2_generateur_combustion_chaudiere.spec.js

@@ -9,7 +9,8 @@ vi.mock('./ficheTechnique.js', () => ({
   default: vi.fn()
 }));
 
-const { updateGenerateurChaudieres } = await import('./13.2_generateur_combustion_chaudiere.js');
+const { updateGenerateurChaudieres, findIdForAnnee, getChaudiereFioulDefautId } =
+  await import('./13.2_generateur_combustion_chaudiere.js');
 const { default: getFicheTechnique } = await import('./ficheTechnique.js');
 
 beforeEach(() => {
@@ -83,3 +84,84 @@ describe('updateGenerateurChaudieres - substitution par une chaudière équivale
     ]);
   });
 });
+
+describe('findIdForAnnee - sélection de la période', () => {
+  const values = { 1948: 'a', 1970: 'b', 1991: 'c' };
+
+  test('année égale à un seuil : période du seuil retenue', () => {
+    expect(findIdForAnnee(values, 1970)).toBe('b');
+  });
+
+  test('année entre deux seuils : période du seuil inférieur retenue', () => {
+    expect(findIdForAnnee(values, 1990)).toBe('b');
+  });
+
+  test('année postérieure au dernier seuil : période la plus récente', () => {
+    expect(findIdForAnnee(values, 2030)).toBe('c');
+  });
+
+  test('année antérieure au premier seuil : période la plus ancienne', () => {
+    expect(findIdForAnnee(values, 1900)).toBe('a');
+  });
+});
+
+/**
+ * Système collectif par défaut (ch 119 / ecs 84) : chaudière atmosphérique mixte standard
+ * datant de la construction du bâtiment, énergie fioul.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §17.2.1.1
+ */
+describe('getChaudiereFioulDefautId - chaudière fioul par défaut selon l’année de construction', () => {
+  const dpe = (annee) => ({
+    logement: { caracteristique_generale: { annee_construction: annee } }
+  });
+
+  test.each([
+    [1900, '75', '35'],
+    [1969, '75', '35'],
+    [1970, '76', '36'],
+    [1975, '76', '36'],
+    [1976, '77', '37'],
+    [1981, '78', '38'],
+    [1990, '78', '38'],
+    [1991, '79', '39'],
+    [2014, '79', '39'],
+    [2015, '80', '40'],
+    [2024, '80', '40']
+  ])('construction %s : chaudière ch %s / ecs %s', (annee, chId, ecsId) => {
+    expect(getChaudiereFioulDefautId(dpe(annee), 'ch')).toBe(chId);
+    expect(getChaudiereFioulDefautId(dpe(annee), 'ecs')).toBe(ecsId);
+  });
+
+  test('année de construction sous forme de chaîne : prise en compte', () => {
+    expect(getChaudiereFioulDefautId(dpe('1995'), 'ch')).toBe('79');
+  });
+
+  /**
+   * "Dans le cas où certaines de ces informations sont connues sur l'installation collective, elles
+   * pourront être utilisées et complétées par les valeurs par défaut" (§17.2.1.1).
+   * Une chaudière saisie d'une période postérieure ou égale à la construction (chaudière remplacée)
+   * est conservée ; une période antérieure à la construction, non crédible, est redressée.
+   */
+  test.each([
+    // [annee, type saisi, attendu, type]
+    [1930, '77', '77', 'ch'], // 2162E1020576I : chaudière 1976-1980 dans un bâtiment de 1930
+    [1970, '78', '78', 'ch'], // 2262E0012158B : chaudière 1981-1990 dans un bâtiment de 1970
+    [1930, '39', '39', 'ecs'], // 2262E0038009I : chaudière 1991-2014 dans un bâtiment de 1930
+    [1995, '79', '79', 'ch'], // même période que la construction
+    [1996, '75', '79', 'ch'], // 2368E2119912U : chaudière < 1970 dans un bâtiment de 1996
+    [2000, '36', '39', 'ecs'], // chaudière 1970-1975 dans un bâtiment de 2000
+    [1996, '99', '79', 'ch'], // type saisi hors chaudières fioul standard
+    [1996, undefined, '79', 'ch']
+  ])(
+    'construction %s, type saisi %s : chaudière %s retenue (%s)',
+    (annee, typeSaisi, attendu, type) => {
+      expect(getChaudiereFioulDefautId(dpe(annee), type, typeSaisi)).toBe(attendu);
+    }
+  );
+
+  test('année de construction absente : aucune chaudière par défaut', () => {
+    expect(getChaudiereFioulDefautId(dpe(undefined), 'ch')).toBeUndefined();
+    expect(getChaudiereFioulDefautId({}, 'ecs')).toBeUndefined();
+    expect(getChaudiereFioulDefautId(undefined, 'ecs')).toBeUndefined();
+  });
+});

package/14_generateur_ecs.js

@@ -15,6 +15,7 @@ import {
 import { conso_aux_gen } from './15_conso_aux.js';
 import { scopOrCop } from './12.4_pac.js';
 import getFicheTechnique from './ficheTechnique.js';
+import { getChaudiereFioulDefautId } from './13.2_generateur_combustion_chaudiere.js';
 
 function tv_pertes_stockage(di, de, VsCollectif) {
   let vb;
@@ -257,10 +258,19 @@ export default function calc_gen_ecs(dpe, gen_ecs, ecs_di, ecs_de, GV, ca_id, zc
         });
 
         if (row) {
-          // On prend par défaut le premier type de générateur pour effectuer les calculs de rendement
           const typeGenerateurEcs = row.enum_type_generateur_ecs_id?.split('|');
-
-          if (typeGenerateurEcs && typeGenerateurEcs.length) {
+          // Chaudière fioul standard datant de la construction du bâtiment (§17.2.1.1)
+          const chaudiereFioulDefautId = getChaudiereFioulDefautId(
+            dpe,
+            'ecs',
+            typeGenerateurEcs?.[0]
+          );
+
+          if (chaudiereFioulDefautId && typeGenerateurEcs?.includes('84')) {
+            // La chaudière fioul par défaut dépend de l'année de construction du bâtiment
+            de.enum_type_generateur_ecs_id = chaudiereFioulDefautId;
+          } else if (typeGenerateurEcs && typeGenerateurEcs.length) {
+            // On prend par défaut le premier type de générateur pour effectuer les calculs de rendement
             de.enum_type_generateur_ecs_id = typeGenerateurEcs[0];
           }
         }

package/14_generateur_ecs.spec.js

@@ -61,6 +61,10 @@ vi.mock('./ficheTechnique.js', () => ({
   default: vi.fn()
 }));
 
+vi.mock('./13.2_generateur_combustion_chaudiere.js', () => ({
+  getChaudiereFioulDefautId: vi.fn()
+}));
+
 const {
   default: calc_gen_ecs,
   rg_chauffe_eau_gaz,
@@ -73,6 +77,7 @@ const { tvColumnIDs, requestInput, requestInputID, tv, getVolumeStockageFromDesc
 const { tv_generateur_combustion } = await import('./13.2_generateur_combustion.js');
 const { scopOrCop } = await import('./12.4_pac.js');
 const { default: getFicheTechnique } = await import('./ficheTechnique.js');
+const { getChaudiereFioulDefautId } = await import('./13.2_generateur_combustion_chaudiere.js');
 
 /**
  * 14. Générateur d'ECS : rendements et consommations
@@ -632,6 +637,41 @@ describe('calc_gen_ecs - consommation par générateur', () => {
     expect(g.donnee_intermediaire.conso_ecs).toBeCloseTo(37.03703703703703, 9);
   });
 
+  /**
+   * Type 84 : chaudière fioul standard datant de la construction du bâtiment.
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §17.2.1.1
+   */
+  test('type 84 combustion compatible 84 : chaudière de la période de construction retenue', () => {
+    vi.mocked(getChaudiereFioulDefautId).mockReturnValue('39');
+    vi.mocked(tv).mockReturnValue({ enum_type_generateur_ecs_id: '35|84' });
+    const dpe = { logement: {} };
+    const g = gen({
+      type_energie: 'fioul domestique',
+      enum_type_generateur_ecs_id: '84',
+      tv_generateur_combustion_id: '16',
+      enum_methode_saisie_carac_sys_id: '1'
+    });
+    calc_gen_ecs(dpe, g, ecs_di, ecs_de, 0, '1', '1', 'immeuble');
+
+    expect(getChaudiereFioulDefautId).toHaveBeenCalledWith(dpe, 'ecs', '35');
+    // 39 au lieu du premier type de la ligne (35)
+    expect(g.donnee_entree.enum_type_generateur_ecs_id).toBe('39');
+  });
+
+  test('type 84 combustion non compatible 84 (générateur décrit) : premier type conservé', () => {
+    vi.mocked(getChaudiereFioulDefautId).mockReturnValue('39');
+    vi.mocked(tv).mockReturnValue({ enum_type_generateur_ecs_id: '57|104' });
+    const g = gen({
+      type_energie: 'gaz naturel',
+      enum_type_generateur_ecs_id: '84',
+      tv_generateur_combustion_id: '13',
+      enum_methode_saisie_carac_sys_id: '1'
+    });
+    calc_gen_ecs({}, g, ecs_di, ecs_de, 0, '1', '1', 'immeuble');
+
+    expect(g.donnee_entree.enum_type_generateur_ecs_id).toBe('57');
+  });
+
   /**
    * Réseau de chaleur : redressement de reseau_distribution_isole (bug_for_bug_compat).
    */

package/3.2.1_mur.js

@@ -8,9 +8,78 @@ import {
   getThicknessFromDescription
 } from './utils.js';
 import b from './3.1_b.js';
+import tvs from './tv.js';
 
 const scriptName = new URL(import.meta.url).pathname.split('/').pop();
 
+/**
+ * Ramène une épaisseur de structure sur une colonne de la table Umur0 du matériau déclaré.
+ *
+ * 3.2.1.2 Calcul des Umur0 : la valeur est lue dans le tableau du matériau de structure déclaré.
+ * Lorsque l'épaisseur saisie n'est pas une colonne de ce tableau (ex : 16 cm alors que la table
+ * propose 15 et 20), la recherche ne doit jamais basculer vers la ligne d'un autre matériau
+ * (cf. issue #138).
+ *
+ * La méthode ne précise pas la règle d'arrondi pour Umur0. Convention retenue (pratique des
+ * logiciels) : colonne la plus proche, et en cas d'égalité la colonne inférieure (la plus
+ * défavorable thermiquement). Les bornes ouvertes « ≤ x » / « ≥ x » sont ramenées à x.
+ *
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §3.2.1.2
+ *
+ * @param enumMateriauxStructureMurId {string|number}
+ * @param epaisseur {number|string}
+ * @returns {number|string} épaisseur d'une colonne de la table, ou la valeur initiale si la table
+ * ne propose pas d'épaisseur pour ce matériau ou si l'épaisseur n'est pas numérique
+ */
+export function epaisseurStructureTable(enumMateriauxStructureMurId, epaisseur) {
+  const ep = typeof epaisseur === 'number' ? epaisseur : Number(epaisseur);
+  if (!Number.isFinite(ep) || ep <= 0) return epaisseur;
+
+  const colonnes = tvs.umur0
+    .filter(
+      (row) =>
+        String(row.enum_materiaux_structure_mur_id) === String(enumMateriauxStructureMurId) &&
+        row.epaisseur_structure
+    )
+    .map((row) => {
+      const valeur = String(row.epaisseur_structure);
+      return {
+        valeur: parseFloat(valeur.replace(/[≤≥\s]/g, '')),
+        inf: valeur.includes('≤'),
+        sup: valeur.includes('≥')
+      };
+    })
+    .filter((colonne) => Number.isFinite(colonne.valeur));
+
+  if (colonnes.length === 0) return epaisseur;
+
+  const colonneOuverte = colonnes.find(
+    (c) => c.valeur === ep || (c.inf && ep <= c.valeur) || (c.sup && ep >= c.valeur)
+  );
+  if (colonneOuverte) return colonneOuverte.valeur;
+
+  return colonnes.reduce((best, c) => {
+    const d = Math.abs(c.valeur - ep);
+    const dBest = Math.abs(best.valeur - ep);
+    return d < dBest || (d === dBest && c.valeur < best.valeur) ? c : best;
+  }).valeur;
+}
+
+/**
+ * Copie du matcher umur0 dont l'épaisseur est ramenée sur une colonne de la table du matériau.
+ * @param matcher {{enum_materiaux_structure_mur_id: string, epaisseur_structure?: number}}
+ */
+function matcherEpaisseurTable(matcher) {
+  if (matcher.epaisseur_structure === undefined) return matcher;
+  return {
+    ...matcher,
+    epaisseur_structure: epaisseurStructureTable(
+      matcher.enum_materiaux_structure_mur_id,
+      matcher.epaisseur_structure
+    )
+  };
+}
+
 function tv_umur0(di, de, du) {
   const matcher = {
     enum_materiaux_structure_mur_id: de.enum_materiaux_structure_mur_id
@@ -52,7 +121,7 @@ function tv_umur0(di, de, du) {
       }
     }
   }
-  let row = tv('umur0', matcher);
+  let row = tv('umur0', matcherEpaisseurTable(matcher));
 
   if (bug_for_bug_compat) {
     if (
@@ -63,7 +132,7 @@ function tv_umur0(di, de, du) {
         'Mauvais valeur de umur0 trouvé pour une epaisseur > 80, la valeur va être recalculée avec une epaisseur / 10. Il arrive que la valeur soit en millimètres dans le dpe'
       );
       matcher.epaisseur_structure /= 10;
-      row = tv('umur0', matcher);
+      row = tv('umur0', matcherEpaisseurTable(matcher));
       if (Number(du.tv_umur0_id_avant) !== Number(row.tv_umur0_id)) {
         row = undefined;
       }

package/3.2.1_mur.spec.js

@@ -23,6 +23,25 @@ vi.mock('./3.1_b.js', () => ({
   default: vi.fn()
 }));
 
+/**
+ * Table `umur0` réduite (mockée) pour `epaisseurStructureTable` : matériau 26 (ossature bois avec
+ * isolant en remplissage < 2001) et matériau 2 (bornes ouvertes « ≤ » / « ≥ »).
+ */
+vi.mock('./tv.js', () => ({
+  default: {
+    umur0: [
+      { tv_umur0_id: '1', enum_materiaux_structure_mur_id: '1', umur0: '2.5' },
+      { tv_umur0_id: '2', enum_materiaux_structure_mur_id: '2', epaisseur_structure: '≤ 20' },
+      { tv_umur0_id: '3', enum_materiaux_structure_mur_id: '2', epaisseur_structure: '25' },
+      { tv_umur0_id: '4', enum_materiaux_structure_mur_id: '2', epaisseur_structure: '≥ 30' },
+      { tv_umur0_id: '144', enum_materiaux_structure_mur_id: '26', epaisseur_structure: '10' },
+      { tv_umur0_id: '145', enum_materiaux_structure_mur_id: '26', epaisseur_structure: '15' },
+      { tv_umur0_id: '146', enum_materiaux_structure_mur_id: '26', epaisseur_structure: '20' },
+      { tv_umur0_id: '151', enum_materiaux_structure_mur_id: '26', epaisseur_structure: '≥ 45' }
+    ]
+  }
+}));
+
 vi.mock('./utils.js', () => ({
   set_bug_for_bug_compat: vi.fn(),
   tv: vi.fn(),
@@ -35,7 +54,7 @@ vi.mock('./utils.js', () => ({
   }
 }));
 
-const { default: calc_mur } = await import('./3.2.1_mur.js');
+const { default: calc_mur, epaisseurStructureTable } = await import('./3.2.1_mur.js');
 const { tv, getThicknessFromDescription } = await import('./utils.js');
 
 /** Table `umur0` figée : U0 forfaitaire de la paroi nue. */
@@ -924,3 +943,66 @@ describe('calc_mur - doublage et isolation ITE/ITI (#146)', () => {
     expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_TABLE, 9);
   });
 });
+
+/**
+ * 3.2.1.2 Calcul des Umur0 : l'épaisseur saisie est ramenée sur une colonne de la table du
+ * matériau déclaré, sans jamais basculer vers un autre matériau (issue #138).
+ * Convention (la méthode ne précise pas l'arrondi) : colonne la plus proche, égalité => inférieure.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §3.2.1.2
+ */
+describe('epaisseurStructureTable - épaisseur hors table (issue #138)', () => {
+  test.each([
+    { epaisseur: 16, attendu: 15, cas: '16 cm => colonne 15 (DPE 2673E0055842U)' },
+    { epaisseur: 18, attendu: 20, cas: '18 cm => colonne 20 (la plus proche)' },
+    { epaisseur: 12, attendu: 10, cas: '12 cm => colonne 10' },
+    { epaisseur: 17.5, attendu: 15, cas: '17,5 cm (égalité) => colonne inférieure 15' },
+    { epaisseur: 8, attendu: 10, cas: 'sous la borne basse => première colonne' },
+    { epaisseur: 15, attendu: 15, cas: 'colonne exacte inchangée' },
+    { epaisseur: 50, attendu: 45, cas: 'au-delà de « ≥ 45 » => 45' },
+    { epaisseur: 40, attendu: 45, cas: '40 cm => « ≥ 45 » plus proche que 20' },
+    { epaisseur: '16', attendu: 15, cas: 'épaisseur fournie en chaîne' }
+  ])('matériau 26 : $cas', ({ epaisseur, attendu }) => {
+    expect(epaisseurStructureTable('26', epaisseur)).toBe(attendu);
+  });
+
+  test.each([
+    { epaisseur: 12, attendu: 20, cas: '« ≤ 20 » couvre toutes les épaisseurs inférieures' },
+    { epaisseur: 17.5, attendu: 20, cas: 'épaisseur décimale sous « ≤ 20 »' },
+    { epaisseur: 22, attendu: 20, cas: '22 cm => 20 (plus proche que 25)' },
+    { epaisseur: 24, attendu: 25, cas: '24 cm => 25' },
+    { epaisseur: 98, attendu: 30, cas: '« ≥ 30 » couvre toutes les épaisseurs supérieures' }
+  ])('matériau 2 (bornes ouvertes) : $cas', ({ epaisseur, attendu }) => {
+    expect(epaisseurStructureTable('2', epaisseur)).toBe(attendu);
+  });
+
+  test.each([
+    { materiau: '1', epaisseur: 30, cas: 'matériau sans épaisseur dans la table' },
+    { materiau: '99', epaisseur: 30, cas: 'matériau absent de la table' },
+    { materiau: '26', epaisseur: 0, cas: 'épaisseur nulle' },
+    { materiau: '26', epaisseur: 'abc', cas: 'épaisseur non numérique' }
+  ])('valeur inchangée : $cas', ({ materiau, epaisseur }) => {
+    expect(epaisseurStructureTable(materiau, epaisseur)).toBe(epaisseur);
+  });
+
+  test('calc_mur : le matcher umur0 reçoit la colonne de la table du matériau déclaré', () => {
+    const mur = {
+      donnee_entree: {
+        methode_saisie_u: 'non isolé',
+        methode_saisie_u0:
+          'déterminé selon le matériau et épaisseur à partir de la table de valeur forfaitaire',
+        enum_materiaux_structure_mur_id: '26',
+        epaisseur_structure: 16,
+        enum_type_doublage_id: '2'
+      }
+    };
+
+    calc_mur(mur, 'h1a', '1', '0');
+
+    expect(tv).toHaveBeenCalledWith('umur0', {
+      enum_materiaux_structure_mur_id: '26',
+      epaisseur_structure: 15
+    });
+    // L'épaisseur saisie n'est pas modifiée dans les données d'entrée
+    expect(mur.donnee_entree.epaisseur_structure).toBe(16);
+  });
+});

package/9_generateur_ch.js

@@ -5,6 +5,7 @@ import { conso_ch } from './9_conso_ch.js';
 import { calc_generateur_combustion_ch } from './13.2_generateur_combustion_ch.js';
 import { scopOrCop } from './12.4_pac.js';
 import { updateGenerateurCombustion } from './13.2_generateur_combustion.js';
+import { getChaudiereFioulDefautId } from './13.2_generateur_combustion_chaudiere.js';
 
 const ENUM_MATERIAUX_STRUCTURE_MUR_ANCIEN_IDS = ['2', '3', '4', '6', '8', '9', '14', '21'];
 const ENUM_CLASSES_INERTIE_LOURDES_IDS = ['1', '2'];
@@ -161,10 +162,15 @@ export function checkForGeneratorType(dpe, de, di, du) {
       });
 
       if (row) {
-        // On prend par défaut le premier type de générateur pour effectuer les calculs de rendement
         const typeGenerateurCh = row.enum_type_generateur_ch_id?.split('|');
-
-        if (typeGenerateurCh && typeGenerateurCh.length) {
+        // Chaudière fioul standard datant de la construction du bâtiment (§17.2.1.1)
+        const chaudiereFioulDefautId = getChaudiereFioulDefautId(dpe, 'ch', typeGenerateurCh?.[0]);
+
+        if (chaudiereFioulDefautId && typeGenerateurCh?.includes('119')) {
+          // La chaudière fioul par défaut dépend de l'année de construction du bâtiment
+          de.enum_type_generateur_ch_id = chaudiereFioulDefautId;
+        } else if (typeGenerateurCh && typeGenerateurCh.length) {
+          // On prend par défaut le premier type de générateur pour effectuer les calculs de rendement
           de.enum_type_generateur_ch_id = typeGenerateurCh[0];
         }
       }

package/9_generateur_ch.spec.js

@@ -57,6 +57,10 @@ vi.mock('./13.2_generateur_combustion.js', () => ({
   updateGenerateurCombustion: vi.fn()
 }));
 
+vi.mock('./13.2_generateur_combustion_chaudiere.js', () => ({
+  getChaudiereFioulDefautId: vi.fn()
+}));
+
 const {
   calc_Qrec_gen_j,
   calc_Qrec_gen_ecs_j,
@@ -72,6 +76,7 @@ const { conso_ch } = await import('./9_conso_ch.js');
 const { calc_generateur_combustion_ch } = await import('./13.2_generateur_combustion_ch.js');
 const { scopOrCop } = await import('./12.4_pac.js');
 const { updateGenerateurCombustion } = await import('./13.2_generateur_combustion.js');
+const { getChaudiereFioulDefautId } = await import('./13.2_generateur_combustion_chaudiere.js');
 
 beforeEach(() => {
   vi.mocked(requestInput).mockReset();
@@ -335,6 +340,47 @@ describe('checkForGeneratorType - classification du générateur', () => {
     checkForGeneratorType({}, de, {}, du);
     expect(de.enum_type_generateur_ch_id).toBe('119');
   });
+
+  /**
+   * Chaudière fioul par défaut : chaudière standard datant de la construction du bâtiment.
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §17.2.1.1
+   */
+  describe('cas 119 : chaudière fioul par défaut selon l’année de construction', () => {
+    beforeEach(() => {
+      vi.mocked(getChaudiereFioulDefautId).mockReset();
+      vi.mocked(requestInputID).mockReturnValue('119');
+    });
+
+    test('ligne combustion compatible 119 : chaudière de la période de construction retenue', () => {
+      vi.mocked(getChaudiereFioulDefautId).mockReturnValue('79');
+      vi.mocked(tv).mockReturnValue({ enum_type_generateur_ch_id: '75|119' });
+      const dpe = { logement: {} };
+      const de = { tv_generateur_combustion_id: 16 };
+      const du = {};
+      checkForGeneratorType(dpe, de, {}, du);
+
+      expect(getChaudiereFioulDefautId).toHaveBeenCalledWith(dpe, 'ch', '75');
+      // 79 au lieu du premier type de la ligne (75)
+      expect(de.enum_type_generateur_ch_id).toBe('79');
+      expect(du.isCombustionGenerator).toBe(true);
+    });
+
+    test('ligne combustion non compatible 119 (générateur décrit) : premier type conservé', () => {
+      vi.mocked(getChaudiereFioulDefautId).mockReturnValue('79');
+      vi.mocked(tv).mockReturnValue({ enum_type_generateur_ch_id: '97|139' });
+      const de = { tv_generateur_combustion_id: 13 };
+      checkForGeneratorType({}, de, {}, {});
+      expect(de.enum_type_generateur_ch_id).toBe('97');
+    });
+
+    test('année de construction inconnue : premier type de la ligne conservé', () => {
+      vi.mocked(getChaudiereFioulDefautId).mockReturnValue(undefined);
+      vi.mocked(tv).mockReturnValue({ enum_type_generateur_ch_id: '75|119' });
+      const de = { tv_generateur_combustion_id: 16 };
+      checkForGeneratorType({}, de, {}, {});
+      expect(de.enum_type_generateur_ch_id).toBe('75');
+    });
+  });
 });
 
 /**

package/README.md

@@ -370,14 +370,14 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <!-- CORPUS:START -->
 
-> **Version `1.8.8`** · à publier · branche `main` · généré le 2026-10-02
+> **Version `1.8.10`** · à 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>59 879</strong><br/><sub>DPE conformes</sub></td>
+<td align="center"><strong>59 881</strong><br/><sub>DPE conformes</sub></td>
 <td align="center"><strong>66,54 %</strong><br/><sub>réussite globale</sub></td>
 </tr>
 </table>
@@ -390,7 +390,7 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 | 🟢  | **Maison individuelle (2025)**<br/><sub>`dpe_maison_individuelle_2025.csv`</sub>                                        | **88,40 %** | `██████████████████░░` | 8 840 / 10 000 |
 | 🟡  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **74,14 %** | `███████████████░░░░░` |  7 413 / 9 999 |
 | 🟡  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **70,61 %** | `██████████████░░░░░░` | 7 061 / 10 000 |
-| 🟡  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **62,50 %** | `████████████░░░░░░░░` |  6 249 / 9 999 |
+| 🟡  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **62,52 %** | `█████████████░░░░░░░` |  6 251 / 9 999 |
 | 🔴  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **49,06 %** | `██████████░░░░░░░░░░` | 4 906 / 10 000 |
 | 🔴  | **Individuel généré depuis l'immeuble (2026)**<br/><sub>`dpe_individuel_a_partir_dpe_immeuble_2026.csv`</sub>           | **27,39 %** | `█████░░░░░░░░░░░░░░░` | 2 739 / 10 000 |
 
@@ -403,24 +403,24 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <table>
 <tr>
-<td align="center"><strong>5,31 ms</strong><br/><sub>moyenne</sub></td>
-<td align="center"><strong>4,65 ms</strong><br/><sub>médiane</sub></td>
+<td align="center"><strong>5,70 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>4,90 ms</strong><br/><sub>médiane</sub></td>
 <td align="center"><strong>0,12 ms</strong><br/><sub>min</sub></td>
-<td align="center"><strong>893,4 ms</strong><br/><sub>max</sub></td>
+<td align="center"><strong>798,8 ms</strong><br/><sub>max</sub></td>
 </tr>
 </table>
 
 | Corpus                                         | Moyenne | Médiane |     Min |      Max |     p95 |     p99 |
 | :--------------------------------------------- | ------: | ------: | ------: | -------: | ------: | ------: |
-| **Généraliste**                                | 4,56 ms | 4,09 ms | 0,21 ms |  37,2 ms | 8,41 ms | 12,0 ms |
-| **Appartement · chauffage individuel (2025)**  | 4,01 ms | 3,65 ms | 1,47 ms |  33,8 ms | 6,95 ms | 9,38 ms |
-| **Logement individuel (2025)**                 | 4,98 ms | 4,43 ms | 1,62 ms |  38,0 ms | 9,30 ms | 12,8 ms |
-| **Maison individuelle (2025)**                 | 5,92 ms | 5,33 ms | 1,85 ms |  40,3 ms | 10,6 ms | 13,7 ms |
-| **Immeuble · chauffage individuel**            | 6,70 ms | 5,72 ms | 0,13 ms | 136,8 ms | 13,4 ms | 22,2 ms |
-| **Appartement · chauffage collectif (2025)**   | 4,60 ms | 4,36 ms | 1,46 ms |  37,2 ms | 7,27 ms | 9,45 ms |
-| **Immeuble · chauffage collectif**             | 5,31 ms | 4,38 ms | 0,12 ms |  99,5 ms | 9,95 ms | 17,7 ms |
-| **Immeuble · chauffage mixte**                 | 5,38 ms | 4,34 ms | 0,20 ms | 893,4 ms | 11,2 ms | 18,5 ms |
-| **Individuel généré depuis l'immeuble (2026)** | 6,36 ms | 5,53 ms | 1,67 ms |  50,2 ms | 12,4 ms | 19,1 ms |
+| **Généraliste**                                | 4,45 ms | 3,97 ms | 0,21 ms |  28,3 ms | 8,17 ms | 12,3 ms |
+| **Appartement · chauffage individuel (2025)**  | 3,56 ms | 3,23 ms | 1,44 ms |  32,5 ms | 6,21 ms | 8,35 ms |
+| **Logement individuel (2025)**                 | 5,38 ms | 4,83 ms | 1,58 ms |  40,8 ms | 9,99 ms | 13,4 ms |
+| **Maison individuelle (2025)**                 | 9,51 ms | 7,86 ms | 1,74 ms | 102,7 ms | 21,7 ms | 32,8 ms |
+| **Immeuble · chauffage individuel**            | 7,00 ms | 6,01 ms | 0,12 ms | 104,2 ms | 14,2 ms | 21,8 ms |
+| **Appartement · chauffage collectif (2025)**   | 4,19 ms | 3,78 ms | 1,54 ms |  35,7 ms | 6,90 ms | 8,89 ms |
+| **Immeuble · chauffage collectif**             | 5,77 ms | 4,97 ms | 0,22 ms |  99,3 ms | 10,8 ms | 17,2 ms |
+| **Immeuble · chauffage mixte**                 | 5,60 ms | 4,49 ms | 0,19 ms | 798,8 ms | 11,9 ms | 19,9 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 5,85 ms | 4,98 ms | 1,60 ms |  49,9 ms | 11,1 ms | 16,4 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.10';
+const LIB_VERSION = '1.8.12';
 
 const dpeSanitizerService = new DpeSanitizerService();
 

package/package.json

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