@open3cl/engine 1.8.11 → 1.8.13

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.4_pont_thermique.js

@@ -213,6 +213,28 @@ function tv_k(pt_di, di, de, du, pc_id, logement) {
         return;
       }
 
+      /**
+       * 3.4 Calcul des déperditions par les ponts thermiques (issue #212)
+       * « Les ponts thermiques des parois au niveau des circulations communes ne sont pas pris en compte. »
+       * La règle porte sur les parois : elle s'applique au plancher de la liaison comme au mur.
+       * 14 à 18 - Circulations communes / halls d'entrée
+       * 22 - Local non déperditif (local à usage d'habitation chauffé)
+       *
+       * Ambiguïté : la méthode ne tranche pas explicitement le cas du plancher en adjacence 22 et les moteurs
+       * certifiés divergent (3cl-2024.6.1.0 exporte k = 0, Tribu 1.4.25.1 et BBS 2024.6.1.0 conservent la
+       * valeur forfaitaire sur les « planchers mitoyens »). Comme pour le mur ci-dessus, on s'appuie sur la
+       * valeur du DPE : k = 0 si le DPE a retenu k = 0, sinon la valeur forfaitaire est recalculée.
+       */
+      if (
+        ['14', '15', '16', '17', '18', '22'].includes(
+          String(plancher.donnee_entree.enum_type_adjacence_id)
+        ) &&
+        pt_di.k === 0
+      ) {
+        di.k = 0;
+        return;
+      }
+
       /**
        * 3.4.3 Plancher haut / mur
        * Les ponts thermiques des planchers haut en structure légère sont négligés.

package/3.4_pont_thermique.spec.js

@@ -889,3 +889,131 @@ describe('calc_pont_thermique - cas limites', () => {
     expect(pt.donnee_intermediaire.k).toBeUndefined();
   });
 });
+
+/**
+ * Issue #212 : l'exclusion des parois non déperditives s'applique aussi au plancher des liaisons
+ * plancher bas / mur et plancher haut lourd / mur, pas seulement au mur.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §3.4
+ */
+describe('calc_pont_thermique - plancher sur paroi non déperditive (issue #212)', () => {
+  /** Mur extérieur lourd isolé ITI + plancher lourd isolé ITE avec l'adjacence donnée. */
+  function liaison(type_liaison, adjacencePlancher, k = 0.9) {
+    const mur = [
+      {
+        donnee_entree: { reference: 'M1', enum_type_adjacence_id: '1', type_isolation: 'iti' },
+        donnee_utilisateur: {}
+      }
+    ];
+    const plancher = {
+      donnee_entree: {
+        reference: 'P1',
+        enum_type_adjacence_id: adjacencePlancher,
+        enum_type_plancher_bas_id: '1',
+        enum_type_plancher_haut_id: '1',
+        type_isolation: 'ite'
+      },
+      donnee_utilisateur: {}
+    };
+    const pt = pontThermique(
+      {
+        type_liaison,
+        enum_type_liaison_id: type_liaison === 'plancher bas / mur' ? '1' : '3',
+        reference_1: 'P1',
+        reference_2: 'M1',
+        description: 'plancher / mur'
+      },
+      k
+    );
+    return { mur, plancher, pt };
+  }
+
+  test('cas 2557E3382433Y : plancher bas sur local habitation chauffé (22), mur extérieur, k DPE nul : k = 0', () => {
+    const { mur, plancher, pt } = liaison('plancher bas / mur', '22', 0);
+
+    calc_pont_thermique(pt, '1', logement({ mur, pb: [plancher] }));
+
+    expect(pt.donnee_intermediaire.k).toBe(0);
+    expect(tv).not.toHaveBeenCalled();
+  });
+
+  test('plancher mitoyen (22) avec k DPE non nul (Tribu / BBS) : valeur forfaitaire recalculée', () => {
+    tv.mockReturnValue({ k: '0.71', tv_pont_thermique_id: '12' });
+    const { mur, plancher, pt } = liaison('plancher bas / mur', '22', 0.71);
+
+    calc_pont_thermique(pt, '1', logement({ mur, pb: [plancher] }));
+
+    expect(tv).toHaveBeenCalledWith('pont_thermique', {
+      enum_type_liaison_id: '1',
+      isolation_mur: '^iti$',
+      isolation_plancher: '^ite$'
+    });
+    expect(pt.donnee_intermediaire.k).toBe(0.71);
+  });
+
+  test('cas 2534E3387900I : plancher haut lourd sous local habitation chauffé (22), mur extérieur : k = 0', () => {
+    const { mur, plancher, pt } = liaison('plancher haut lourd / mur', '22', 0);
+
+    calc_pont_thermique(pt, '1', logement({ mur, ph: [plancher] }));
+
+    expect(pt.donnee_intermediaire.k).toBe(0);
+    expect(tv).not.toHaveBeenCalled();
+  });
+
+  test.each(['14', '15', '16', '17', '18'])(
+    'plancher bas sur circulation commune / hall (%s) avec k DPE nul : k = 0 sans accès table',
+    (adjacence) => {
+      const { mur, plancher, pt } = liaison('plancher bas / mur', adjacence, 0);
+
+      calc_pont_thermique(pt, '1', logement({ mur, pb: [plancher] }));
+
+      expect(pt.donnee_intermediaire.k).toBe(0);
+      expect(tv).not.toHaveBeenCalled();
+    }
+  );
+
+  test('plancher haut lourd sous circulation (14) avec k DPE nul : k = 0', () => {
+    const { mur, plancher, pt } = liaison('plancher haut lourd / mur', '14', 0);
+
+    calc_pont_thermique(pt, '1', logement({ mur, ph: [plancher] }));
+
+    expect(pt.donnee_intermediaire.k).toBe(0);
+    expect(tv).not.toHaveBeenCalled();
+  });
+
+  test('plancher bas sur hall (17) avec k DPE non nul : valeur forfaitaire conservée (même règle que pour le mur)', () => {
+    tv.mockReturnValue({ k: '0.71', tv_pont_thermique_id: '12' });
+    const { mur, plancher, pt } = liaison('plancher bas / mur', '17', 0.71);
+
+    calc_pont_thermique(pt, '1', logement({ mur, pb: [plancher] }));
+
+    expect(tv).toHaveBeenCalledWith('pont_thermique', {
+      enum_type_liaison_id: '1',
+      isolation_mur: '^iti$',
+      isolation_plancher: '^ite$'
+    });
+    expect(pt.donnee_intermediaire.k).toBe(0.71);
+  });
+
+  test('contre-test : plancher bas sur sous-sol non chauffé (6) : pont thermique compté (pas de b sur les PT)', () => {
+    tv.mockReturnValue({ k: '0.71', tv_pont_thermique_id: '12' });
+    const { mur, plancher, pt } = liaison('plancher bas / mur', '6', 0);
+
+    calc_pont_thermique(pt, '1', logement({ mur, pb: [plancher] }));
+
+    expect(tv).toHaveBeenCalledWith('pont_thermique', {
+      enum_type_liaison_id: '1',
+      isolation_mur: '^iti$',
+      isolation_plancher: '^ite$'
+    });
+    expect(pt.donnee_intermediaire.k).toBe(0.71);
+  });
+
+  test('contre-test : plancher bas sur local tertiaire (20) : pont thermique compté', () => {
+    tv.mockReturnValue({ k: '0.71', tv_pont_thermique_id: '12' });
+    const { mur, plancher, pt } = liaison('plancher bas / mur', '20', 0.71);
+
+    calc_pont_thermique(pt, '1', logement({ mur, pb: [plancher] }));
+
+    expect(pt.donnee_intermediaire.k).toBe(0.71);
+  });
+});

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,27 +370,27 @@ 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.12`** · à 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>66,54 %</strong><br/><sub>réussite globale</sub></td>
+<td align="center"><strong>59 886</strong><br/><sub>DPE conformes</sub></td>
+<td align="center"><strong>66,55 %</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,28 %** | `█████████░░░░░░░░░░░` | 4 628 / 10 000 |
+| 🔴  | **Généraliste**<br/><sub>`corpus_dpe.csv`</sub>                                                                         | **46,31 %** | `█████████░░░░░░░░░░░` | 4 631 / 10 000 |
 | 🟢  | **Appartement · chauffage individuel (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_individuel_2025.csv`</sub> | **91,80 %** | `██████████████████░░` | 9 180 / 10 000 |
 | 🟢  | **Logement individuel (2025)**<br/><sub>`dpe_logement_individuel_2025.csv`</sub>                                        | **88,70 %** | `██████████████████░░` |  8 863 / 9 992 |
 | 🟢  | **Maison individuelle (2025)**<br/><sub>`dpe_maison_individuelle_2025.csv`</sub>                                        | **88,40 %** | `██████████████████░░` | 8 840 / 10 000 |
 | 🟡  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **74,14 %** | `███████████████░░░░░` |  7 413 / 9 999 |
-| 🟡  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **70,61 %** | `██████████████░░░░░░` | 7 061 / 10 000 |
-| 🟡  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **62,50 %** | `████████████░░░░░░░░` |  6 249 / 9 999 |
+| 🟡  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **70,63 %** | `██████████████░░░░░░` | 7 063 / 10 000 |
+| 🟡  | **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>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>5,49 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>4,81 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>842,5 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,60 ms | 4,18 ms | 0,22 ms |  34,3 ms | 8,29 ms | 11,3 ms |
+| **Appartement · chauffage individuel (2025)**  | 3,94 ms | 3,52 ms | 1,41 ms |  29,4 ms | 6,94 ms | 10,8 ms |
+| **Logement individuel (2025)**                 | 5,12 ms | 4,56 ms | 1,59 ms |  38,6 ms | 9,60 ms | 13,1 ms |
+| **Maison individuelle (2025)**                 | 6,45 ms | 5,83 ms | 1,90 ms |  41,6 ms | 11,7 ms | 15,6 ms |
+| **Immeuble · chauffage individuel**            | 6,64 ms | 5,67 ms | 0,11 ms |  74,6 ms | 13,5 ms | 21,9 ms |
+| **Appartement · chauffage collectif (2025)**   | 4,74 ms | 4,39 ms | 1,57 ms |  34,6 ms | 7,84 ms | 11,9 ms |
+| **Immeuble · chauffage collectif**             | 5,91 ms | 5,13 ms | 0,14 ms | 145,5 ms | 11,0 ms | 19,2 ms |
+| **Immeuble · chauffage mixte**                 | 5,97 ms | 4,83 ms | 0,21 ms | 842,5 ms | 12,5 ms | 21,1 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 6,01 ms | 5,13 ms | 1,68 ms |  57,9 ms | 11,4 ms | 17,9 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.11';
+const LIB_VERSION = '1.8.13';
 
 const dpeSanitizerService = new DpeSanitizerService();
 

package/features/engine/domain/enveloppe/pont_thermique/deperdition-pont-thermique.service.js

@@ -175,7 +175,10 @@ export class DeperditionPontThermiqueService extends DeperditionService {
       return this.defaultValue(pontThermiqueDE);
     }
 
-    if (!this.plancherBasHasPontThermique(plancherBasDE)) {
+    if (
+      !this.plancherHasPontThermiqueAdjacence(plancherBasDE) ||
+      !this.plancherBasHasPontThermique(plancherBasDE)
+    ) {
       return 0;
     }
 
@@ -206,7 +209,10 @@ export class DeperditionPontThermiqueService extends DeperditionService {
       return this.defaultValue(pontThermiqueDE);
     }
 
-    if (!this.plancherHautHasPontThermique(plancherHautDE)) {
+    if (
+      !this.plancherHasPontThermiqueAdjacence(plancherHautDE) ||
+      !this.plancherHautHasPontThermique(plancherHautDE)
+    ) {
       return 0;
     }
 
@@ -391,6 +397,26 @@ export class DeperditionPontThermiqueService extends DeperditionService {
     return true;
   }
 
+  /**
+   * Retourne true si l'adjacence du plancher (bas ou haut) permet un pont thermique avec le mur (issue #212)
+   *
+   * 3.4 Calcul des déperditions par les ponts thermiques
+   * Les ponts thermiques des parois au niveau des circulations communes ne sont pas pris en compte.
+   * La règle porte sur les parois en général : elle s'applique au plancher de la liaison comme au mur.
+   * 14 - Circulation sans ouverture directe sur l'extérieur
+   * 15 - Circulation avec ouverture directe sur l'extérieur
+   * 16 - Circulation avec bouche ou gaine de désenfumage ouverte en permanence
+   * 17 - Hall d'entrée avec dispositif de fermeture automatique
+   * 18 - Hall d'entrée sans dispositif de fermeture automatique
+   * 22 - Local non déperditif (local à usage d'habitation chauffé) : le plancher n'est pas déperditif
+   *
+   * @param plancherDE {PlancherBasDE|PlancherHautDE}
+   * @return {boolean}
+   */
+  plancherHasPontThermiqueAdjacence(plancherDE) {
+    return ![14, 15, 16, 17, 18, 22].includes(parseInt(plancherDE.enum_type_adjacence_id));
+  }
+
   /**
    * Retourne true si le plancher haut est concerné par un pont thermique
    * @param plancherHautDE {PlancherHautDE}

package/features/engine/domain/enveloppe/pont_thermique/deperdition-pont-thermique.service.spec.js

@@ -0,0 +1,125 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { DeperditionPontThermiqueService } from './deperdition-pont-thermique.service.js';
+
+/**
+ * Tests unitaires isolés de `DeperditionPontThermiqueService` (nouvelle architecture).
+ *
+ * Le store des tables de valeurs et les services de déperdition des parois sont remplacés par des
+ * doubles de test : seule la logique propre au service (exclusions de ponts thermiques) est vérifiée.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §3.4
+ */
+
+let tvStore;
+let murService;
+let plancherHautService;
+let plancherBasService;
+
+/** @type {DeperditionPontThermiqueService} */
+let service;
+
+const ctx = {};
+
+beforeEach(() => {
+  tvStore = {
+    getKForPlancher: vi.fn(() => 0.71),
+    getKForMur: vi.fn(() => 0.82),
+    getKForMenuiserie: vi.fn(() => 0.3),
+    getKForMurById: vi.fn(() => 0.5)
+  };
+  murService = { typeIsolation: vi.fn(() => 3) };
+  plancherHautService = { typeIsolation: vi.fn(() => 4) };
+  plancherBasService = { typeIsolation: vi.fn(() => 4) };
+  service = new DeperditionPontThermiqueService(
+    tvStore,
+    murService,
+    plancherHautService,
+    plancherBasService
+  );
+});
+
+/** Enveloppe : mur extérieur lourd + plancher (bas ou haut) lourd avec l'adjacence donnée. */
+function enveloppe(adjacencePlancher, adjacenceMur = '1') {
+  const plancher = {
+    donnee_entree: {
+      reference: 'P1',
+      enum_type_adjacence_id: adjacencePlancher,
+      enum_type_plancher_bas_id: '1',
+      enum_type_plancher_haut_id: '1'
+    }
+  };
+  return {
+    mur_collection: {
+      mur: [
+        {
+          donnee_entree: {
+            reference: 'M1',
+            enum_type_adjacence_id: adjacenceMur,
+            enum_materiaux_structure_mur_id: '1'
+          }
+        }
+      ]
+    },
+    plancher_bas_collection: { plancher_bas: [plancher] },
+    plancher_haut_collection: { plancher_haut: [plancher] }
+  };
+}
+
+function pontThermique(enumTypeLiaisonId) {
+  return {
+    enum_methode_saisie_pont_thermique_id: '1',
+    enum_type_liaison_id: enumTypeLiaisonId,
+    reference_1: 'P1',
+    reference_2: 'M1',
+    description: 'plancher / mur'
+  };
+}
+
+describe('DeperditionPontThermiqueService - adjacence du plancher (issue #212)', () => {
+  test.each(['14', '15', '16', '17', '18', '22'])(
+    'adjacence %s : plancher sans pont thermique',
+    (adjacence) => {
+      expect(service.plancherHasPontThermiqueAdjacence({ enum_type_adjacence_id: adjacence })).toBe(
+        false
+      );
+    }
+  );
+
+  test.each(['1', '3', '5', '6', '7', '20'])(
+    'adjacence %s : plancher avec pont thermique',
+    (adj) => {
+      expect(service.plancherHasPontThermiqueAdjacence({ enum_type_adjacence_id: adj })).toBe(true);
+    }
+  );
+
+  test('cas 2557E3382433Y : plancher bas / mur, plancher sur local habitation chauffé (22) : k = 0', () => {
+    const di = service.execute(ctx, enveloppe('22'), pontThermique('1'));
+    expect(di.k).toBe(0);
+    expect(tvStore.getKForPlancher).not.toHaveBeenCalled();
+  });
+
+  test('cas 2534E3387900I : plancher haut lourd / mur, plafond sous local habitation chauffé (22) : k = 0', () => {
+    const di = service.execute(ctx, enveloppe('22'), pontThermique('3'));
+    expect(di.k).toBe(0);
+    expect(tvStore.getKForPlancher).not.toHaveBeenCalled();
+  });
+
+  test('plancher bas sur hall d’entrée (17) : k = 0', () => {
+    expect(service.execute(ctx, enveloppe('17'), pontThermique('1')).k).toBe(0);
+  });
+
+  test('contre-test : plancher bas sur sous-sol non chauffé (6) : valeur tabulée (pas de b sur les PT)', () => {
+    const di = service.execute(ctx, enveloppe('6'), pontThermique('1'));
+    expect(tvStore.getKForPlancher).toHaveBeenCalledWith(1, expect.anything(), expect.anything());
+    expect(di.k).toBe(0.71);
+  });
+
+  test('contre-test : plancher haut lourd sur extérieur : valeur tabulée', () => {
+    const di = service.execute(ctx, enveloppe('1'), pontThermique('3'));
+    expect(tvStore.getKForPlancher).toHaveBeenCalledWith(3, expect.anything(), expect.anything());
+    expect(di.k).toBe(0.71);
+  });
+
+  test('mur sur circulation (14) : k = 0 quelle que soit l’adjacence du plancher', () => {
+    expect(service.execute(ctx, enveloppe('1', '14'), pontThermique('1')).k).toBe(0);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open3cl/engine",
-  "version": "1.8.11",
+  "version": "1.8.13",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {
@@ -17,7 +17,7 @@
     "test:unit": "vitest run src",
     "test:unit:ci": "vitest run src --coverage",
     "test:corpus": "node test/corpus/run_all_corpus_checks.js",
-    "test:corpus:all": "node test/corpus/run_all_corpus_checks.js && npm run reports:readme",
+    "test:corpus:all": "npm run reports:clean && node test/corpus/run_all_corpus_checks.js && npm run reports:readme",
     "test:corpus:all+database": "npm run test:corpus:all && node test/corpus/corpus_database.js",
     "qa:lint": "eslint .",
     "qa:lint:fix": "npm run qa:lint -- --fix",
@@ -29,6 +29,7 @@
     "assets:sync": "node scripts/synchronize_assets.js",
     "version:update": "node scripts/update_version.js",
     "reports:preview": "npm run http-server dist/reports/corpus -o",
+    "reports:clean": "node scripts/clean_corpus_reports.js",
     "reports:readme": "node scripts/generate_corpus_readme.js",
     "reports:stamp": "node scripts/stamp_corpus_release.js",
     "reports:version": "node scripts/corpus_version.js"