@open3cl/engine 1.11.1 → 1.11.3

package/11_ecs.spec.js

@@ -13,7 +13,8 @@ vi.mock('./enums.js', () => ({
     type_installation: {
       1: 'installation individuelle',
       2: 'installation collective',
-      3: 'installation collective multi-bâtiment'
+      3: 'installation collective multi-bâtiment',
+      4: 'installation de type inconnu'
     }
   }
 }));
@@ -566,6 +567,21 @@ describe('calc_ecs - rendement de distribution', () => {
     });
   });
 
+  test('type d’installation ni individuelle ni collective : aucun critère de configuration', () => {
+    const de = { enum_type_installation_id: '4' };
+    const ecs = makeEcs(de, [
+      {
+        donnee_entree: { position_volume_chauffe: 1 },
+        donnee_intermediaire: { conso_ecs: 0, conso_ecs_depensier: 0 }
+      }
+    ]);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'maison', false, null, null, false);
+
+    // Le matcher reste vide : ni configuration_logement ni type_reseau_collectif
+    expect(tv).toHaveBeenCalledWith('rendement_distribution_ecs', {});
+    expect(requestInput).not.toHaveBeenCalled();
+  });
+
   test('aucune ligne forfaitaire trouvée : rendement de distribution non renseigné', () => {
     const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
     vi.mocked(tv).mockReturnValue(undefined);

package/11_rdim_ecs_individuelle_unique.js

@@ -60,3 +60,81 @@ export function reconstituerRdimEcsIndividuelleUnique(th, instal_ecs, surfaceHab
   instal_ecs[0].donnee_entree.rdim_reconstitue = true;
   return true;
 }
+
+/**
+ * DPE immeuble avec plusieurs installations ECS individuelles, chacune décrite pour un logement type.
+ *
+ * Même convention d'export que l'installation unique (3.0.x, 2.0.x, 1.1.x) : pour chaque
+ * installation i, `surface_habitable` = Sh_i d'un logement type et `nombre_logement` = N_i, sans
+ * `rdim`, avec Σ Sh_i × N_i = SH. Tribu traite chaque installation indépendamment avec Rdim_i = N_i :
+ * Becs_i = Becs_immeuble × Sh_i × Rdim_i / SH / Rdim_i, puis Cecs = Σ Cecs_i × Rdim_i. L'export ADEME
+ * le confirme : besoin_ecs_i = Becs_immeuble × Sh_i / SH et conso_ecs = Σ conso_ecs_i × N_i.
+ *
+ * Sans rdim, Σ Sh_i ≠ SH : Open3CL se replie sur Becs_immeuble / nombre_appartement par
+ * installation et ne remultiplie pas la conso par N_i.
+ *
+ * Gardes :
+ * - Σ Sh_i × N_i ≈ SH (TOLERANCE_SURFACE_LOGEMENT_TYPE) : exclut les exports où Sh_i est déjà
+ *   la surface totale desservie (Σ Sh_i = SH, ex. N_i fractionnaires) ;
+ * - au moins un N_i > 1 : sinon rdim = 1 partout, sans effet (LICIEL, nombre_logement = 1).
+ *
+ * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - § 11.4 et § 17.1.3.2
+ * @see Tribu : Calcul_batiment.cs l. 581-588 (boucle par installation, Ratio = Sh·Rdim/SH,
+ * Becs / Rdim), l. 1660-1662 (Cecs_i / Rdim puis × Rdim) ; Calcul_installation_ECS.cs l. 75
+ * @see Guide Tribu TE-211208 « Particularités d'une répétition de systèmes d'ECS individuel dans un
+ * immeuble collectif » (Sh_ecs = surface d'un logement, Rdim = nombre d'installations identiques)
+ */
+
+/**
+ * Rdim implicites des installations ECS individuelles multiples d'un immeuble (dans l'ordre des
+ * installations), ou null si non concernées.
+ *
+ * @param th {string} type de bâtiment (maison, appartement, immeuble)
+ * @param instal_ecs {Array} installation_ecs
+ * @param surfaceHabitableImmeuble {number|string} surface habitable de l'immeuble (SH)
+ * @return {number[]|null}
+ */
+export function rdimsImplicitesEcsIndividuellesMultiples(th, instal_ecs, surfaceHabitableImmeuble) {
+  if (th !== 'immeuble' || !Array.isArray(instal_ecs) || instal_ecs.length < 2) return null;
+
+  const des = instal_ecs.map((inst) => inst?.donnee_entree);
+  const concernees = des.every(
+    (de) => de && String(de.enum_type_installation_id) === '1' && !de.rdim
+  );
+  if (!concernees) return null;
+
+  const SH = Number(surfaceHabitableImmeuble);
+  if (!(SH > 0)) return null;
+
+  const surfaces = des.map((de) => Number(de.surface_habitable));
+  const rdims = des.map((de) => Number(de.nombre_logement) || 1);
+  if (!surfaces.every((sh) => sh > 0) || !rdims.every((n) => n > 0)) return null;
+  if (!rdims.some((n) => n > 1)) return null;
+
+  const sommeShN = surfaces.reduce((acc, sh, i) => acc + sh * rdims[i], 0);
+  return Math.abs(sommeShN - SH) <= TOLERANCE_SURFACE_LOGEMENT_TYPE * SH ? rdims : null;
+}
+
+/**
+ * Reconstitue le rdim des installations ECS individuelles multiples d'un immeuble décrites pour un
+ * logement type. Chaque installation reçoit `rdim` = nombre_logement (1 si absent) et le flag
+ * `rdim_reconstitue`.
+ *
+ * @param th {string} type de bâtiment
+ * @param instal_ecs {Array} installation_ecs
+ * @param surfaceHabitableImmeuble {number|string} surface habitable de l'immeuble (SH)
+ * @return {boolean} true si les rdim ont été reconstitués
+ */
+export function reconstituerRdimEcsIndividuellesMultiples(
+  th,
+  instal_ecs,
+  surfaceHabitableImmeuble
+) {
+  const rdims = rdimsImplicitesEcsIndividuellesMultiples(th, instal_ecs, surfaceHabitableImmeuble);
+  if (rdims === null) return false;
+  instal_ecs.forEach((inst, i) => {
+    inst.donnee_entree.rdim = rdims[i];
+    inst.donnee_entree.rdim_reconstitue = true;
+  });
+  return true;
+}

package/11_rdim_ecs_individuelle_unique.spec.js

@@ -1,7 +1,9 @@
 import { describe, expect, test } from 'vitest';
 import {
   rdimImpliciteEcsIndividuelleUnique,
+  rdimsImplicitesEcsIndividuellesMultiples,
   reconstituerRdimEcsIndividuelleUnique,
+  reconstituerRdimEcsIndividuellesMultiples,
   TOLERANCE_SURFACE_LOGEMENT_TYPE
 } from './11_rdim_ecs_individuelle_unique.js';
 
@@ -111,3 +113,137 @@ describe("Rdim de l'installation ECS individuelle unique d'un immeuble", () => {
     });
   });
 });
+
+/**
+ * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - § 11.4 et § 17.1.3.2
+ * @see Tribu : Calcul_batiment.cs l. 581-588 et l. 1660-1662 ; Calcul_installation_ECS.cs l. 75
+ */
+describe("Rdim des installations ECS individuelles multiples d'un immeuble", () => {
+  /** Installation ECS individuelle décrite pour un logement type */
+  const inst = (surface_habitable, nombre_logement, de = {}) => ({
+    donnee_entree: { enum_type_installation_id: '1', surface_habitable, nombre_logement, ...de }
+  });
+  /** Cas type 2244E3039157K : 48,82 × 2 + 78,09 × 6 = 566,18 ≈ SH = 566,16 */
+  const ecs = () => [inst(48.82, 2), inst(78.09, 6)];
+
+  describe('rdimsImplicitesEcsIndividuellesMultiples', () => {
+    test('installations individuelles, Σ Sh × N = SH, sans rdim : rdim_i = nombre_logement_i', () => {
+      expect(rdimsImplicitesEcsIndividuellesMultiples('immeuble', ecs(), 566.16)).toEqual([2, 6]);
+      expect(
+        rdimsImplicitesEcsIndividuellesMultiples(
+          'immeuble',
+          [
+            inst('48.82', '2', { enum_type_installation_id: 1 }),
+            inst('78.09', '6', { enum_type_installation_id: 1 })
+          ],
+          '566.16'
+        )
+      ).toEqual([2, 6]);
+    });
+
+    test('nombre_logement absent sur une installation : rdim = 1 pour celle-ci', () => {
+      // 100 × 4 + 50 × 1 = 450
+      expect(
+        rdimsImplicitesEcsIndividuellesMultiples(
+          'immeuble',
+          [inst(100, 4), inst(50, undefined)],
+          450
+        )
+      ).toEqual([4, 1]);
+    });
+
+    test('tolérance de 5 % sur Σ Sh × N ≈ SH', () => {
+      // Σ = 100 × 4 + 50 × 2 = 500 ; |500 − SH| ≤ 0,05 × SH ⇔ 476,19 ≤ SH ≤ 526,31
+      const deux = () => [inst(100, 4), inst(50, 2)];
+      expect(rdimsImplicitesEcsIndividuellesMultiples('immeuble', deux(), 526)).toEqual([4, 2]);
+      expect(rdimsImplicitesEcsIndividuellesMultiples('immeuble', deux(), 477)).toEqual([4, 2]);
+      expect(rdimsImplicitesEcsIndividuellesMultiples('immeuble', deux(), 527)).toBeNull();
+      expect(rdimsImplicitesEcsIndividuellesMultiples('immeuble', deux(), 476)).toBeNull();
+    });
+
+    test('surfaces exportées comme surface totale desservie (Σ Sh = SH) : non concerné', () => {
+      // Cas type 2224E1374434V : 74,4 × 3 + 31 × 1 = 254,2 ≠ SH = 105,4 = Σ Sh
+      expect(
+        rdimsImplicitesEcsIndividuellesMultiples('immeuble', [inst(74.4, 3), inst(31, 1)], 105.4)
+      ).toBeNull();
+    });
+
+    test('tous les nombre_logement à 1 (LICIEL) : non concerné', () => {
+      expect(
+        rdimsImplicitesEcsIndividuellesMultiples('immeuble', [inst(60, 1), inst(40, 1)], 100)
+      ).toBeNull();
+    });
+
+    test('un rdim exporté sur une installation : on conserve la saisie', () => {
+      expect(
+        rdimsImplicitesEcsIndividuellesMultiples(
+          'immeuble',
+          [inst(48.82, 2, { rdim: 2 }), inst(78.09, 6)],
+          566.16
+        )
+      ).toBeNull();
+    });
+
+    test('une installation collective : non concerné', () => {
+      expect(
+        rdimsImplicitesEcsIndividuellesMultiples(
+          'immeuble',
+          [inst(48.82, 2), inst(78.09, 6, { enum_type_installation_id: '2' })],
+          566.16
+        )
+      ).toBeNull();
+    });
+
+    test('maison ou appartement : non concerné', () => {
+      expect(rdimsImplicitesEcsIndividuellesMultiples('maison', ecs(), 566.16)).toBeNull();
+      expect(rdimsImplicitesEcsIndividuellesMultiples('appartement', ecs(), 566.16)).toBeNull();
+    });
+
+    test('installation unique : non concerné (cf. rdimImpliciteEcsIndividuelleUnique)', () => {
+      expect(rdimsImplicitesEcsIndividuellesMultiples('immeuble', [inst(64, 10)], 640)).toBeNull();
+    });
+
+    test('données manquantes ou invalides : non concerné', () => {
+      expect(rdimsImplicitesEcsIndividuellesMultiples('immeuble', undefined, 566.16)).toBeNull();
+      expect(rdimsImplicitesEcsIndividuellesMultiples('immeuble', [], 566.16)).toBeNull();
+      expect(
+        rdimsImplicitesEcsIndividuellesMultiples('immeuble', [inst(48.82, 2), {}], 566.16)
+      ).toBeNull();
+      expect(
+        rdimsImplicitesEcsIndividuellesMultiples('immeuble', [inst(48.82, 2), null], 566.16)
+      ).toBeNull();
+      expect(rdimsImplicitesEcsIndividuellesMultiples('immeuble', ecs(), undefined)).toBeNull();
+      expect(rdimsImplicitesEcsIndividuellesMultiples('immeuble', ecs(), 0)).toBeNull();
+      expect(
+        rdimsImplicitesEcsIndividuellesMultiples(
+          'immeuble',
+          [inst(48.82, 2), inst(undefined, 6)],
+          566.16
+        )
+      ).toBeNull();
+      expect(
+        rdimsImplicitesEcsIndividuellesMultiples('immeuble', [inst(100, 4), inst(50, -2)], 300)
+      ).toBeNull();
+    });
+  });
+
+  describe('reconstituerRdimEcsIndividuellesMultiples', () => {
+    test('installations concernées : rdim et flag positionnés sur chacune', () => {
+      const installations = ecs();
+      expect(reconstituerRdimEcsIndividuellesMultiples('immeuble', installations, 566.16)).toBe(
+        true
+      );
+      expect(installations[0].donnee_entree).toMatchObject({ rdim: 2, rdim_reconstitue: true });
+      expect(installations[1].donnee_entree).toMatchObject({ rdim: 6, rdim_reconstitue: true });
+    });
+
+    test('installations non concernées : inchangées', () => {
+      const installations = [inst(60, 1), inst(40, 1)];
+      expect(reconstituerRdimEcsIndividuellesMultiples('immeuble', installations, 100)).toBe(false);
+      installations.forEach((i) => {
+        expect(i.donnee_entree.rdim).toBeUndefined();
+        expect(i.donnee_entree.rdim_reconstitue).toBeUndefined();
+      });
+    });
+  });
+});

package/13.2_generateur_combustion.spec.js

@@ -28,7 +28,8 @@ vi.mock('./enums.js', () => ({
     type_generateur_ch: {
       89: 'chaudière gaz standard 2001-2015',
       X: 'chaudière fioul',
-      Y: 'chaudière gaz'
+      Y: 'chaudière gaz',
+      Z: 'générateur sans équivalent ECS'
     },
     type_generateur_ecs: {
       50: 'chaudière gaz standard',
@@ -563,6 +564,28 @@ describe('tv_generateur_combustion - génération mixte (checkEcsVsChauffageForM
     errSpy.mockRestore();
   });
 
+  test('type CH sans équivalent ECS : type de générateur ECS conservé sans message d’alignement', () => {
+    state.bug = true;
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    tv.mockReturnValue({ ...ROW_DEFAUT });
+    const di = { pn: 20000 };
+    // CH mixte 'Z' : aucun type ECS portant le même libellé -> pas d'alignement possible
+    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(dpeAvecChMixte('Z'), di, de, 'ecs', 200, -9, 1);
+    expect(tv).toHaveBeenCalledWith(
+      'generateur_combustion',
+      expect.objectContaining({ enum_type_generateur_ecs_id: 'A' })
+    );
+    expect(errSpy).not.toHaveBeenCalled();
+    errSpy.mockRestore();
+  });
+
   test('types ECS et CH identiques : type de générateur ECS conservé', () => {
     state.bug = true;
     tv.mockReturnValue({ ...ROW_DEFAUT });

package/13.2_generateur_combustion_bouilleur.spec.js

@@ -58,6 +58,14 @@ describe('updateGenerateurBouilleurs - substitution par une chaudière bois équ
     expect(de.enum_type_generateur_ch_id).toBe(attendu);
   });
 
+  test('année numérique antérieure à 1948 : aucune période correspondante, valeur par défaut conservée', () => {
+    getFicheTechnique.mockReturnValue({ valeur: '1900' });
+    const de = { enum_type_generateur_ch_id: '48' };
+    updateGenerateurBouilleurs({}, de, 'ch');
+    // Aucun seuil atteint : on garde la chaudière bois par défaut 2004-2012 (values[2004])
+    expect(de.enum_type_generateur_ch_id).toBe('58');
+  });
+
   test('type ECS (granulés 115) : utilise la table ECS des chaudières bois', () => {
     getFicheTechnique.mockReturnValue({ valeur: '2016' });
     const de = { enum_type_generateur_ecs_id: '115' };

package/13.2_generateur_combustion_ch.spec.js

@@ -173,6 +173,27 @@ describe('tv_temp_fonc_30_100 - températures de fonctionnement', () => {
     expect(di.temp_fonc_100).toBe(75);
   });
 
+  test('une température à 100 % plus basse issue d’un second émetteur ne remplace pas la valeur retenue', () => {
+    tv.mockImplementation((table, matcher) => {
+      if (table !== 'temp_fonc_100') return null;
+      // Le premier émetteur renvoie 75, le second 60 (plus basse)
+      return matcher.enum_temp_distribution_ch_id === '3'
+        ? { tv_temp_fonc_100_id: 'a', temp_fonc_100: '75' }
+        : { tv_temp_fonc_100_id: 'b', temp_fonc_100: '60' };
+    });
+    const di = {};
+    const de = { enum_type_generateur_ch_id: '89' };
+    tv_temp_fonc_30_100(
+      di,
+      de,
+      {},
+      [emetteur(), emetteur({ enum_temp_distribution_ch_id: '4' })],
+      1975
+    );
+    expect(di.temp_fonc_100).toBe(75);
+    expect(de.tv_temp_fonc_100_id).toBe('a');
+  });
+
   test('aucune ligne forfaitaire trouvée : erreurs signalées pour temp_fonc_30 et temp_fonc_100', () => {
     const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
     tv.mockReturnValue(null);
@@ -709,6 +730,26 @@ describe('calc_generateur_combustion_ch - rendement de génération', () => {
     warnSpy.mockRestore();
   });
 
+  test('bug_for_bug_compat : qp0 déjà exprimé en W (>= 1) conservé sans correction', () => {
+    state.bug = true;
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const di = { pn: 20000, rpn: 0.9, rpint: 0.85, qp0: 200, temp_fonc_30: 40, temp_fonc_100: 70 };
+    const de = {
+      enum_type_generateur_ch_id: '89',
+      enum_type_energie_id: '2',
+      type_energie: 'gaz naturel',
+      presence_regulation_combustion: false,
+      description: 't'
+    };
+    calc_generateur_combustion_ch({}, di, de, { cdimref: 0.8, cdimrefDep: 0.6 });
+    // qp0 >= 1 -> pas de multiplication par 1000, pas d'avertissement
+    expect(di.qp0).toBe(200);
+    expect(warnSpy).not.toHaveBeenCalled();
+    // même résultat que la correction d'un qp0 de 0,2 kW (référence de régression ci-dessus)
+    expect(di.rg).toBeCloseTo(0.8557877790761849, 9);
+    warnSpy.mockRestore();
+  });
+
   test('la présence de régulation modifie le rendement (tf30 vs tf100)', () => {
     const base = () => ({
       pn: 25000,

package/14_generateur_ecs.spec.js

@@ -559,6 +559,23 @@ describe('calc_gen_ecs - consommation par générateur', () => {
     expect(g.donnee_intermediaire.Qgw).toBe(0);
   });
 
+  test('installation collective : volume de la fiche non numérique ignoré, volume saisi conservé', () => {
+    // « ba » (texte avant le premier « l ») n'est pas un nombre -> VsFiche = NaN, rejeté
+    vi.mocked(getFicheTechnique).mockReturnValue({ valeur: 'ballon' });
+    ecs_de.enum_type_installation_id = '2';
+    ecs_de.ratio_virtualisation = 1;
+    const g = gen({
+      type_energie: 'gaz',
+      enum_type_generateur_ecs_id: 'autre',
+      type_stockage_ecs: 'ballon',
+      volume_stockage: 150
+    });
+    calc_gen_ecs({}, g, ecs_di, ecs_de, 0, '1', '1', 'immeuble');
+
+    // Vs = volume saisi (150), identique au cas d'une fiche « 150 L »
+    expect(g.donnee_intermediaire.Qgw).toBeCloseTo(1064620.987190969, 9);
+  });
+
   test('bug_for_bug_compat : volume proratisé recalé sur la description', () => {
     state.bug = true;
     vi.mocked(getVolumeStockageFromDescription).mockReturnValue(100);
@@ -852,6 +869,61 @@ describe('calc_gen_ecs - consommation par générateur', () => {
     expect(g.donnee_entree.enum_type_generateur_ecs_id).toBe('84');
   });
 
+  test('type 84 combustion : ligne combustion sans type ECS, type 84 conservé', () => {
+    vi.mocked(getChaudiereFioulDefautId).mockReturnValue(undefined);
+    vi.mocked(tv).mockReturnValue({ tv_generateur_combustion_id: '42' });
+    const g = gen({
+      type_energie: 'gaz',
+      enum_type_generateur_ecs_id: '84',
+      tv_generateur_combustion_id: '42',
+      enum_methode_saisie_carac_sys_id: '1'
+    });
+    calc_gen_ecs({}, g, ecs_di, ecs_de, 0, '1', '1', 'maison');
+
+    // Aucune liste de types ECS exploitable dans la ligne : pas de redressement
+    expect(g.donnee_entree.enum_type_generateur_ecs_id).toBe('84');
+  });
+
+  test('type 84 sans combustion ni pompe à chaleur : ni calcul SCOP ni redressement du type', () => {
+    const g = gen({
+      type_energie: 'gaz',
+      enum_type_generateur_ecs_id: '84',
+      enum_methode_saisie_carac_sys_id: '1'
+    });
+    calc_gen_ecs({}, g, ecs_di, ecs_de, 0, '1', '1', 'maison');
+
+    expect(scopOrCop).not.toHaveBeenCalled();
+    expect(tv_generateur_combustion).not.toHaveBeenCalled();
+    expect(g.donnee_entree.enum_type_generateur_ecs_id).toBe('84');
+  });
+
+  test('bug_for_bug_compat : qp0 déjà en W (>= 1) conservé sans correction', () => {
+    state.bug = true;
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    vi.mocked(tvColumnIDs).mockImplementation((table) =>
+      table === 'generateur_combustion' ? ['chaud'] : []
+    );
+    vi.mocked(tv_generateur_combustion).mockImplementation((dpe, di) => {
+      di.rpn = 0.9;
+      di.qp0 = 100;
+      di.pn = 20000;
+      di.pveilleuse = 1;
+      di.pveil = 0;
+    });
+    const g = gen({
+      type_energie: 'gaz',
+      enum_type_generateur_ecs_id: 'chaud',
+      enum_methode_saisie_carac_sys_id: '1'
+    });
+    calc_gen_ecs({}, g, ecs_di, ecs_de, 0, '1', '1', 'maison');
+
+    expect(g.donnee_intermediaire.qp0).toBe(100);
+    expect(warnSpy).not.toHaveBeenCalled();
+    // même rendement que pour un qp0 de 0,1 kW corrigé en 100 W (cf. test de correction)
+    expect(g.donnee_intermediaire.rendement_generation).toBeCloseTo(0.3446955189582535, 9);
+    warnSpy.mockRestore();
+  });
+
   test('type 84 pompe à chaleur : déduit via tv_scop_id', () => {
     vi.mocked(scopOrCop).mockImplementation((di) => {
       di.scop = 3;

package/15_conso_aux.spec.js

@@ -355,6 +355,26 @@ describe('conso_aux_distribution_ch - auxiliaires de distribution', () => {
     expect(di.conso_auxiliaire_distribution_ch).toBeCloseTo(372.082418731648, 9);
   });
 
+  test('émetteur hors listes (type 1, « autre ») : perte de charge par défaut deltaPem=35, Fcot=0,802', () => {
+    const conso = (type) => {
+      const em = [
+        {
+          donnee_entree: {
+            enum_type_emission_distribution_id: type,
+            enum_temp_distribution_ch_id: '3'
+          }
+        }
+      ];
+      const di = {};
+      conso_aux_distribution_ch(em, {}, di, {}, 100, 1, 1, '0', 100000);
+      return di.conso_auxiliaire_distribution_ch;
+    };
+    // Type 24 (monotube) : deltaPem=30, même Fcot (0,802) -> seul deltaPem diffère
+    expect(conso('1')).toBeGreaterThan(conso('24'));
+    // Type 10 (radiateurs autres) : deltaPem=10
+    expect(conso('24')).toBeGreaterThan(conso('10'));
+  });
+
   /**
    * Seuls les émetteurs reliés au générateur (même enum_lien_generateur_emetteur_id) dimensionnent
    * son circulateur. Autotest CSTB IC5-0-3 : chaudière (lien 1) sur plancher chauffant + convecteurs

package/3.1_b.spec.js

@@ -365,4 +365,27 @@ describe('b - calcul du coefficient de réduction des déperditions', () => {
     });
     expect(di.b).toBe(0.7);
   });
+
+  test('adjacence hors liste aiu/aue (type 10 absent, type inconnu) : seul le type est apparié', () => {
+    tv.mockReturnValue({ b: '0.5', tv_coef_reduction_deperdition_id: '7' });
+    const di = {};
+    const de = { enum_type_adjacence_id: '1' };
+    b(di, de, {}, 1);
+    expect(tv).toHaveBeenCalledWith(TABLE, { enum_type_adjacence_id: '1' });
+    expect(di.b).toBe(0.5);
+  });
+
+  test('rapport inférieur à la plus petite borne : seule la borne max est renseignée', () => {
+    tv.mockReturnValue({ b: '0.9', tv_coef_reduction_deperdition_id: '3' });
+    const de = {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      surface_aiu: 1,
+      surface_aue: 10
+    };
+    b({}, de, {}, 1);
+    const matcher = tv.mock.calls[0][1];
+    expect(matcher.aiu_aue_max).toBe('≤ 0,25');
+    expect(matcher.aiu_aue_min).toBeUndefined();
+  });
 });

package/3.2.1_mur.spec.js

@@ -226,6 +226,63 @@ describe('calc_mur - calcul de Umur0 par table forfaitaire (tv_umur0)', () => {
     error.mockRestore();
   });
 
+  test('bug_for_bug : épaisseur absente et ligne tv_umur0_id sans épaisseur : matcher inchangé', () => {
+    bugForBugCompat = true;
+    const error = vi.spyOn(console, 'error').mockImplementation(() => {});
+    tv.mockImplementation((table, matcher) => {
+      if (table === 'umur0' && matcher.tv_umur0_id) return { tv_umur0_id: '1' };
+      if (table === 'umur0') return { ...ROW_UMUR0 };
+      return null;
+    });
+    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: '5',
+        description: 'mur sans épaisseur',
+        tv_umur0_id: 1,
+        enum_type_doublage_id: '2'
+      }
+    };
+
+    calc_mur(mur, 'h1a', '1', '0');
+
+    // Aucune épaisseur à reprendre : pas d'avertissement et épaisseur nulle conservée
+    expect(error).not.toHaveBeenCalled();
+    expect(tv).toHaveBeenLastCalledWith('umur0', {
+      enum_materiaux_structure_mur_id: '5',
+      epaisseur_structure: 0
+    });
+    error.mockRestore();
+  });
+
+  test('bug_for_bug : ligne tv_umur0_id introuvable : matcher inchangé', () => {
+    bugForBugCompat = true;
+    tv.mockImplementation((table, matcher) => {
+      if (table === 'umur0' && matcher.tv_umur0_id) return undefined;
+      if (table === 'umur0') return { ...ROW_UMUR0 };
+      return null;
+    });
+    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: '5',
+        tv_umur0_id: 1,
+        enum_type_doublage_id: '2'
+      }
+    };
+
+    calc_mur(mur, 'h1a', '1', '0');
+
+    expect(tv).toHaveBeenLastCalledWith('umur0', {
+      enum_materiaux_structure_mur_id: '5',
+      epaisseur_structure: 0
+    });
+  });
+
   test('bug_for_bug : épaisseur > 80 recalculée en la divisant par 10 (valeur en millimètres)', () => {
     bugForBugCompat = true;
     const error = vi.spyOn(console, 'error').mockImplementation(() => {});
@@ -423,6 +480,48 @@ describe('calc_mur - prise en compte du doublage', () => {
     }
   );
 
+  test('bug_for_bug : doublage de type 1 sans description : type de doublage inchangé', () => {
+    bugForBugCompat = true;
+    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: '5',
+        epaisseur_structure: 30,
+        enum_type_doublage_id: '1'
+      }
+    };
+
+    calc_mur(mur, 'h1a', '1', '0');
+
+    // Type 1 (pas de doublage) : Umur0 de la table non modifié
+    expect(mur.donnee_intermediaire.umur0).toBe(2);
+  });
+
+  test('bug_for_bug : type de doublage > 2 inconnu (6) : aucune résistance de doublage ajoutée', () => {
+    bugForBugCompat = true;
+    const error = vi.spyOn(console, 'error').mockImplementation(() => {});
+    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: '5',
+        epaisseur_structure: 30,
+        enum_type_doublage_id: '6'
+      }
+    };
+
+    calc_mur(mur, 'h1a', '1', '0');
+
+    // Le type 6 est hors énumération type_doublage (1 à 5) : aucune résistance de doublage n'est
+    // définie, ni dans le calcul ni dans la vérification de minoration. Comportement actuel figé :
+    // Umur0 devient NaN (donnée d'entrée invalide, non protégée par le moteur).
+    expect(mur.donnee_intermediaire.umur0).toBeNaN();
+    error.mockRestore();
+  });
+
   test('bug_for_bug : DPE minorant Umur0 à 2,5 avant doublage : avertissement (Umur0 avant)', () => {
     bugForBugCompat = true;
     const error = vi.spyOn(console, 'error').mockImplementation(() => {});

package/3.2.3_plancher_haut.spec.js

@@ -342,6 +342,35 @@ describe('calc_ph - compatibilité bug for bug (récupération depuis tv_uph_id)
     error.mockRestore();
   });
 
+  test('ligne tv_uph_id introuvable : type_toiture et effet_joule calculés conservés', () => {
+    const error = vi.spyOn(console, 'error').mockImplementation(() => {});
+    tv.mockImplementation((table, matcher) => {
+      if (table === 'uph0') return { ...ROW_UPH0 };
+      if (table === 'uph' && matcher.tv_uph_id) return undefined;
+      if (table === 'uph') return { ...ROW_UPH };
+      return null;
+    });
+
+    const ph = {
+      donnee_entree: {
+        methode_saisie_u: 'isolation inconnue  (table forfaitaire)',
+        methode_saisie_u0: 'type de paroi inconnu (valeur par défaut)',
+        type_adjacence: 'extérieur',
+        type_plancher_haut: 'terrasse',
+        tv_uph_id: 7,
+        description: 'PH test'
+      }
+    };
+
+    calc_ph(ph, 'h1a', '1', '0');
+
+    // Aucune correction issue du DPE : pas d'avertissement, matcher final en 'terrasse'
+    expect(error).not.toHaveBeenCalled();
+    expect(tv).toHaveBeenCalledWith('uph', expect.objectContaining({ type_toiture: 'terrasse' }));
+    expect(ph.donnee_intermediaire.uph).toBe(0.3);
+    error.mockRestore();
+  });
+
   test('effet_joule du DPE différent : la valeur du DPE est conservée dans le matcher', () => {
     const error = vi.spyOn(console, 'error').mockImplementation(() => {});
     tv.mockImplementation((table, matcher) => {