@open3cl/engine 1.0.7 → 1.0.9

package/features/engine/domain/enveloppe/baie_vitree/deperdition-baie-vitree.service.spec.js

@@ -0,0 +1,484 @@
+import corpus from '../../../../../../test/corpus-sano.json';
+import { getAdemeFileJson } from '../../../../../../test/test-helpers.js';
+import { ContexteBuilder } from '../../contexte.builder.js';
+import { DpeNormalizerService } from '../../../../normalizer/domain/dpe-normalizer.service.js';
+import { DeperditionBaieVitreeService } from './deperdition-baie-vitree.service.js';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { BaieVitreeTvStore } from '../../../../dpe/infrastructure/baieVitreeTv.store.js';
+
+/** @type {DeperditionBaieVitreeService} **/
+let service;
+
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {BaieVitreeTvStore} **/
+let tvStore;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
+describe('Calcul de déperdition des baies vitrées', () => {
+  beforeEach(() => {
+    tvStore = new BaieVitreeTvStore();
+    service = new DeperditionBaieVitreeService(tvStore);
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
+  });
+
+  describe('Determination du coefficient sw', () => {
+    test('Doit retourner sw_saisi directement', () => {
+      vi.spyOn(tvStore, 'getSw').mockReturnValue(18.8);
+      /**
+       * @type {BaieVitree}
+       */
+      let bv = {
+        donnee_entree: {
+          enum_type_materiaux_menuiserie_id: '1',
+          enum_type_vitrage_id: '2',
+          enum_type_baie_id: '6',
+          vitrage_vir: '1',
+          enum_type_pose_id: '3',
+          sw_saisi: 4.5
+        }
+      };
+
+      let sw = service.sw(bv);
+      expect(tvStore.getSw).not.toHaveBeenCalled();
+      expect(sw).toBe(4.5);
+    });
+
+    test('Ne doit pas utiliser vitrage_vir et enum_type_pose_id si enum_type_materiaux_menuiserie_id = 1 ou 2', () => {
+      vi.spyOn(tvStore, 'getSw').mockReturnValue(18.8);
+      /**
+       * @type {BaieVitree}
+       */
+      let bv = {
+        donnee_entree: {
+          enum_type_materiaux_menuiserie_id: '1',
+          enum_type_vitrage_id: '2',
+          enum_type_baie_id: '6',
+          vitrage_vir: '1',
+          enum_type_pose_id: '3'
+        }
+      };
+
+      let sw = service.sw(bv);
+      expect(tvStore.getSw).toHaveBeenCalledWith('2', '6', '1', undefined, undefined);
+      expect(sw).toBe(18.8);
+    });
+
+    test('Doit utiliser vitrage_vir et enum_type_pose_id si enum_type_materiaux_menuiserie_id != 1 et != 2', () => {
+      vi.spyOn(tvStore, 'getSw').mockReturnValue(18.8);
+      /**
+       * @type {BaieVitree}
+       */
+      let bv = {
+        donnee_entree: {
+          enum_type_materiaux_menuiserie_id: '4',
+          enum_type_vitrage_id: '2',
+          enum_type_baie_id: '6',
+          vitrage_vir: '1',
+          enum_type_pose_id: '3'
+        }
+      };
+
+      let sw = service.sw(bv);
+      expect(tvStore.getSw).toHaveBeenCalledWith('2', '6', '4', '1', '3');
+      expect(sw).toBe(18.8);
+    });
+
+    test('Doit prendre en compte le survitrage si présent', () => {
+      vi.spyOn(tvStore, 'getSw').mockReturnValue(18.8);
+      /**
+       * @type {BaieVitree}
+       */
+      let bv = {
+        donnee_entree: {
+          enum_type_materiaux_menuiserie_id: '4',
+          enum_type_vitrage_id: '2',
+          enum_type_baie_id: '6',
+          vitrage_vir: '1',
+          enum_type_pose_id: '3',
+          double_fenetre: 1
+        },
+        baie_vitree_double_fenetre: {
+          donnee_entree: {
+            enum_type_materiaux_menuiserie_id: '4',
+            enum_type_vitrage_id: '2',
+            enum_type_baie_id: '6',
+            vitrage_vir: '1',
+            enum_type_pose_id: '3'
+          }
+        }
+      };
+
+      let sw = service.sw(bv);
+      expect(tvStore.getSw).toHaveBeenNthCalledWith(2, '2', '6', '4', '1', '3');
+      expect(sw).toBe(18.8 * 18.8);
+    });
+  });
+
+  describe('Determination du coefficient uw', () => {
+    test('Doit retourner uw_saisi directement', () => {
+      vi.spyOn(tvStore, 'getUw').mockReturnValue(18.8);
+
+      let uw = service.uw({ donnee_entree: { uw_saisi: 16.4 } }, 2.4);
+
+      expect(tvStore.getUw).not.toHaveBeenCalled();
+      expect(uw).toBe(16.4);
+    });
+
+    test('Doit appeler tvStore', () => {
+      vi.spyOn(tvStore, 'getUw').mockReturnValue(18.8);
+
+      let uw = service.uw(
+        { donnee_entree: { enum_type_baie_id: '10', enum_type_materiaux_menuiserie_id: '1' } },
+        2.4
+      );
+
+      expect(tvStore.getUw).toHaveBeenCalledWith('10', '1', 2.4);
+      expect(uw).toBe(18.8);
+    });
+
+    test('Doit prendre en compte le survitrage si présent', () => {
+      vi.spyOn(tvStore, 'getUw').mockReturnValue(18.8);
+      /**
+       * @type {BaieVitree}
+       */
+      let bv = {
+        donnee_entree: {
+          ug_saisi: 2.5,
+          enum_type_materiaux_menuiserie_id: '4',
+          enum_type_baie_id: '6',
+          double_fenetre: 1
+        },
+        baie_vitree_double_fenetre: {
+          donnee_entree: {
+            ug_saisi: 2.5,
+            enum_type_materiaux_menuiserie_id: '4',
+            enum_type_baie_id: '6'
+          }
+        }
+      };
+
+      let uw = service.uw(bv, 2.4);
+      expect(tvStore.getUw).toHaveBeenNthCalledWith(2, '6', '4', 2.5);
+      expect(uw).toBe(1 / (1 / 18.8 + 1 / 18.8 + 0.07));
+    });
+  });
+
+  describe('Determination du coefficient ug', () => {
+    test('Doit retourner ug_saisi directement', () => {
+      vi.spyOn(tvStore, 'getUg').mockReturnValue(18.8);
+
+      let ug = service.ug({ ug_saisi: 16.4 });
+
+      expect(tvStore.getUg).not.toHaveBeenCalled();
+      expect(ug).toBe(16.4);
+    });
+
+    test('Ne retourne aucune valeur pour les parois en brique ou polycarbonate', () => {
+      vi.spyOn(tvStore, 'getUg').mockReturnValue(18.8);
+
+      let ug = service.ug({ enum_type_baie_id: '1' });
+
+      expect(tvStore.getUg).not.toHaveBeenCalled();
+      expect(ug).toBeUndefined();
+
+      ug = service.ug({ enum_type_baie_id: '2' });
+
+      expect(tvStore.getUg).not.toHaveBeenCalled();
+      expect(ug).toBeUndefined();
+
+      ug = service.ug({ enum_type_baie_id: '3' });
+
+      expect(tvStore.getUg).not.toHaveBeenCalled();
+      expect(ug).toBeUndefined();
+    });
+
+    test('Doit appeler tvStore sans epaisseur, enum_type_gaz_lame_id, enum_inclinaison_vitrage_id, vitrage_vir pour les simples vitrages', () => {
+      vi.spyOn(tvStore, 'getUg').mockReturnValue(18.8);
+
+      /**
+       * @type {BaieVitreeDE}
+       */
+      let bvDE = {
+        enum_type_vitrage_id: '1',
+        vitrage_vir: '1',
+        enum_inclinaison_vitrage_id: '1',
+        enum_type_gaz_lame_id: '1',
+        epaisseur_lame: '18'
+      };
+
+      let uw = service.ug(bvDE);
+
+      expect(tvStore.getUg).toHaveBeenCalledWith('1', undefined, undefined, undefined, undefined);
+      expect(uw).toBe(18.8);
+    });
+
+    test('Doit appeler tvStore avec epaisseur, enum_type_gaz_lame_id, enum_inclinaison_vitrage_id, vitrage_vir pour les doubles vitrages', () => {
+      vi.spyOn(tvStore, 'getUg').mockReturnValue(18.8);
+
+      /**
+       * @type {BaieVitreeDE}
+       */
+      let bvDE = {
+        enum_type_vitrage_id: '2',
+        vitrage_vir: '1',
+        enum_inclinaison_vitrage_id: '2',
+        enum_type_gaz_lame_id: '1',
+        epaisseur_lame: '18'
+      };
+
+      let uw = service.ug(bvDE);
+
+      expect(tvStore.getUg).toHaveBeenCalledWith('2', '1', '2', '1', 18);
+      expect(uw).toBe(18.8);
+    });
+
+    test("Doit appeler tvStore avec l'epaisseur la plus proche dans celles qui sont disponibles", () => {
+      vi.spyOn(tvStore, 'getUg').mockReturnValue(18.8);
+      vi.spyOn(tvStore, 'getEpaisseurAvailableForUg').mockReturnValue([2, 4, 8]);
+
+      /**
+       * @type {BaieVitreeDE}
+       */
+      let bvDE = {
+        enum_type_vitrage_id: '2',
+        vitrage_vir: '1',
+        enum_inclinaison_vitrage_id: '2',
+        enum_type_gaz_lame_id: '1',
+        epaisseur_lame: '18'
+      };
+
+      let uw = service.ug(bvDE);
+
+      expect(tvStore.getUg).toHaveBeenCalledWith('2', '1', '2', '1', 8);
+      expect(uw).toBe(18.8);
+    });
+
+    test('Doit appeler tvStore avec un équivalent double vitrage pour un sur vitrage avec majoration de 0.1', () => {
+      vi.spyOn(tvStore, 'getUg').mockReturnValue(18.8);
+
+      /**
+       * @type {BaieVitreeDE}
+       */
+      let bvDE = {
+        enum_type_vitrage_id: '4',
+        vitrage_vir: '0',
+        enum_inclinaison_vitrage_id: '3',
+        enum_type_gaz_lame_id: '1',
+        epaisseur_lame: '20'
+      };
+
+      let uw = service.ug(bvDE);
+
+      expect(tvStore.getUg).toHaveBeenCalledWith('2', '1', '3', '0', 20);
+      expect(uw).toBe(18.8 + 0.1);
+    });
+  });
+
+  describe('Determination du facteur d’ensoleillement', () => {
+    test('Doit retourner fe1 = 1 et fe2 = 1 si aucun masque', () => {
+      vi.spyOn(tvStore, 'getMasqueProche').mockReturnValue(1.2);
+      vi.spyOn(tvStore, 'getMasqueLointainHomogene').mockReturnValue(3.4);
+      vi.spyOn(tvStore, 'getOmbre').mockReturnValue(0.5);
+
+      let [fe1, fe2] = service.fe({});
+
+      expect(tvStore.getMasqueProche).not.toHaveBeenCalled();
+      expect(tvStore.getMasqueLointainHomogene).not.toHaveBeenCalled();
+      expect(tvStore.getOmbre).not.toHaveBeenCalled();
+      expect(fe1).toBe(1);
+      expect(fe2).toBe(1);
+    });
+
+    test('Doit utiliser tvStore pour les masques proches', () => {
+      vi.spyOn(tvStore, 'getMasqueProche').mockReturnValue(1.2);
+      vi.spyOn(tvStore, 'getMasqueLointainHomogene').mockReturnValue(3.4);
+      vi.spyOn(tvStore, 'getOmbre').mockReturnValue(0.5);
+
+      let [fe1, fe2] = service.fe({ tv_coef_masque_proche_id: '1' });
+
+      expect(tvStore.getMasqueProche).toHaveBeenCalledWith('1');
+      expect(tvStore.getMasqueLointainHomogene).not.toHaveBeenCalled();
+      expect(tvStore.getOmbre).not.toHaveBeenCalled();
+      expect(fe1).toBe(1.2);
+      expect(fe2).toBe(1);
+    });
+
+    test('Doit utiliser tvStore pour les masques lointains homogènes', () => {
+      vi.spyOn(tvStore, 'getMasqueProche').mockReturnValue(1.2);
+      vi.spyOn(tvStore, 'getMasqueLointainHomogene').mockReturnValue(3.4);
+      vi.spyOn(tvStore, 'getOmbre').mockReturnValue(0.5);
+
+      let [fe1, fe2] = service.fe({ tv_coef_masque_lointain_homogene_id: '2' });
+
+      expect(tvStore.getMasqueLointainHomogene).toHaveBeenCalledWith('2');
+      expect(tvStore.getMasqueProche).not.toHaveBeenCalled();
+      expect(tvStore.getOmbre).not.toHaveBeenCalled();
+      expect(fe1).toBe(1);
+      expect(fe2).toBe(3.4);
+    });
+
+    test.each([
+      {
+        label: 'collection masque_lointain_non_homogene_collection undefined',
+        masqueLointainNonHomogene: undefined,
+        tvStoreMasqueLointainNonHomogene: undefined,
+        fe1Expected: 1,
+        fe2Expected: 1
+      },
+      {
+        label: 'collection masque_lointain_non_homogene_collection vide',
+        masqueLointainNonHomogene: { masque_lointain_non_homogene: undefined },
+        tvStoreMasqueLointainNonHomogene: undefined,
+        fe1Expected: 1,
+        fe2Expected: 1
+      },
+      {
+        label: 'collection masque_lointain_non_homogene_collection vide',
+        masqueLointainNonHomogene: { masque_lointain_non_homogene: [] },
+        tvStoreMasqueLointainNonHomogene: undefined,
+        fe1Expected: 1,
+        fe2Expected: 1
+      },
+      {
+        label: 'collection masque_lointain_non_homogene_collection non array',
+        masqueLointainNonHomogene: {
+          masque_lointain_non_homogene: { tv_coef_masque_lointain_non_homogene_id: '1' }
+        },
+        tvStoreMasqueLointainNonHomogene: '1',
+        fe1Expected: 1,
+        fe2Expected: 0.8
+      },
+      {
+        label: 'collection masque_lointain_non_homogene_collection array',
+        masqueLointainNonHomogene: {
+          masque_lointain_non_homogene: [
+            { tv_coef_masque_lointain_non_homogene_id: '1' },
+            { tv_coef_masque_lointain_non_homogene_id: '2' }
+          ]
+        },
+        tvStoreMasqueLointainNonHomogene: '1',
+        fe1Expected: 1,
+        fe2Expected: 0.6
+      },
+      {
+        label: 'collection masque_lointain_non_homogene_collection array and fe2 min 0',
+        masqueLointainNonHomogene: {
+          masque_lointain_non_homogene: [
+            { tv_coef_masque_lointain_non_homogene_id: '1' },
+            { tv_coef_masque_lointain_non_homogene_id: '2' }
+          ]
+        },
+        tvStoreMasqueLointainNonHomogene: '1',
+        tvStoreGetOmbreValue: 60,
+        fe1Expected: 1,
+        fe2Expected: 0
+      }
+    ])(
+      'Doit utiliser tvStore pour les masques lointains non homogènes pour $label',
+      ({
+        masqueLointainNonHomogene,
+        tvStoreMasqueLointainNonHomogene,
+        tvStoreGetOmbreValue = undefined,
+        fe1Expected,
+        fe2Expected
+      }) => {
+        vi.spyOn(tvStore, 'getMasqueProche').mockReturnValue(1.2);
+        vi.spyOn(tvStore, 'getMasqueLointainHomogene').mockReturnValue(3.4);
+        vi.spyOn(tvStore, 'getOmbre').mockReturnValue(tvStoreGetOmbreValue || 20);
+
+        let bvDE = {
+          masque_lointain_non_homogene_collection: masqueLointainNonHomogene
+        };
+        let [fe1, fe2] = service.fe(bvDE);
+
+        if (tvStoreMasqueLointainNonHomogene === undefined) {
+          expect(tvStore.getOmbre).not.toHaveBeenCalled();
+        } else {
+          expect(tvStore.getOmbre).toHaveBeenCalledWith(tvStoreMasqueLointainNonHomogene);
+        }
+
+        expect(tvStore.getMasqueLointainHomogene).not.toHaveBeenCalled();
+        expect(tvStore.getMasqueProche).not.toHaveBeenCalled();
+
+        expect(fe1).toBeCloseTo(fe1Expected, 2);
+        expect(fe2).toBeCloseTo(fe2Expected, 2);
+      }
+    );
+  });
+
+  test('Récupération du coefficient ujn', () => {
+    vi.spyOn(tvStore, 'getUjn').mockReturnValue(18.8);
+
+    let ujn = service.ujn({ ujn_saisi: 16.4 }, 2.4);
+
+    expect(tvStore.getUjn).not.toHaveBeenCalled();
+    expect(ujn).toBe(16.4);
+
+    ujn = service.ujn({ enum_type_fermeture_id: 1 }, 2.4);
+
+    expect(tvStore.getUjn).toHaveBeenCalledWith(1, 2.4);
+    expect(ujn).toBe(18.8);
+  });
+
+  test("Récupération de l'ombre apportée par un masque lointain", () => {
+    vi.spyOn(tvStore, 'getOmbre').mockReturnValue(12.4);
+
+    const ombre = service.calcOmbre({ tv_coef_masque_lointain_non_homogene_id: 16.4 });
+
+    expect(tvStore.getOmbre).toHaveBeenCalledWith(16.4);
+    expect(ombre).toBe(12.4);
+  });
+
+  test('u_menuiserie est définit par ujn seulement pour les baie vitrée avec fermeture', () => {
+    let bvDI = service.execute(
+      {},
+      { donnee_entree: { ujn_saisi: 5.6, enum_type_fermeture_id: 1 } }
+    );
+    expect(bvDI.u_menuiserie).toBeUndefined();
+
+    bvDI = service.execute({}, { donnee_entree: { ujn_saisi: 5.6, enum_type_fermeture_id: 2 } });
+    expect(bvDI.u_menuiserie).toBe(5.6);
+  });
+
+  describe("Test d'intégration des baies vitrées", () => {
+    test.each(corpus)('vérification des DI des baies vitrées pour dpe %s', (ademeId) => {
+      let dpeRequest = getAdemeFileJson(ademeId);
+      dpeRequest = normalizerService.normalize(dpeRequest);
+
+      /** @type {Contexte} */
+      const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+      const bvs = dpeRequest.logement.enveloppe.baie_vitree_collection?.baie_vitree || [];
+
+      bvs.forEach((bv) => {
+        const di = service.execute(ctx, bv);
+
+        expect(di.b).toBeCloseTo(bv.donnee_intermediaire.b, 2);
+
+        if (bv.donnee_intermediaire.ug) {
+          expect(di.ug).toBeCloseTo(bv.donnee_intermediaire.ug, 2);
+        } else {
+          expect(di.ug).toBeUndefined();
+        }
+
+        expect(di.uw).toBeCloseTo(bv.donnee_intermediaire.uw, 2);
+
+        if (bv.donnee_intermediaire.ujn) {
+          expect(di.ujn).toBeCloseTo(bv.donnee_intermediaire.ujn, 2);
+        } else {
+          expect(di.ujn).toBeUndefined();
+        }
+
+        expect(di.u_menuiserie).toBeCloseTo(bv.donnee_intermediaire.u_menuiserie, 2);
+        expect(di.sw).toBeCloseTo(bv.donnee_intermediaire.sw, 2);
+        expect(di.fe1).toBeCloseTo(bv.donnee_intermediaire.fe1, 2);
+        expect(di.fe2).toBeCloseTo(bv.donnee_intermediaire.fe2, 2);
+      });
+    });
+  });
+});

package/features/engine/domain/enveloppe/deperdition-enveloppe.service.js

@@ -4,6 +4,8 @@ import { DeperditionPorteService } from './porte/deperdition-porte.service.js';
 import { DeperditionPlancherBasService } from './plancher_bas/deperdition-plancher-bas.service.js';
 import { DeperditionPlancherHautService } from './plancher_haut/deperdition-plancher-haut.service.js';
 import { DeperditionVentilationService } from './ventilation/deperdition-ventilation.service.js';
+import { DeperditionBaieVitreeService } from './baie_vitree/deperdition-baie-vitree.service.js';
+import { DeperditionPontThermiqueService } from './pont_thermique/deperdition-pont-thermique.service.js';
 
 /**
  * Calcul des déperditions de l’enveloppe
@@ -30,6 +32,16 @@ export class DeperditionEnveloppeService {
    */
   #deperditionPlancherHautService;
 
+  /**
+   * @type {DeperditionBaieVitreeService}
+   */
+  #deperditionBaieVitreeService;
+
+  /**
+   * @type {DeperditionPontThermiqueService}
+   */
+  #deperditionPontThermiqueService;
+
   /**
    * @type {DeperditionVentilationService}
    */
@@ -66,6 +78,8 @@ export class DeperditionEnveloppeService {
    * @param deperditionPorteService {DeperditionPorteService}
    * @param deperditionPlancherBasService {DeperditionPlancherBasService}
    * @param deperditionPlancherHautService {DeperditionPlancherHautService}
+   * @param deperditionBaieVitreeService {DeperditionBaieVitreeService}
+   * @param deperditionPontThermiqueService {DeperditionPontThermiqueService}
    * @param deperditionVentilationService {DeperditionVentilationService}
    */
   constructor(
@@ -73,12 +87,16 @@ export class DeperditionEnveloppeService {
     deperditionPorteService = inject(DeperditionPorteService),
     deperditionPlancherBasService = inject(DeperditionPlancherBasService),
     deperditionPlancherHautService = inject(DeperditionPlancherHautService),
+    deperditionBaieVitreeService = inject(DeperditionBaieVitreeService),
+    deperditionPontThermiqueService = inject(DeperditionPontThermiqueService),
     deperditionVentilationService = inject(DeperditionVentilationService)
   ) {
     this.#deperditionMurService = deperditionMurService;
     this.#deperditionPorteService = deperditionPorteService;
     this.#deperditionPlancherBasService = deperditionPlancherBasService;
     this.#deperditionPlancherHautService = deperditionPlancherHautService;
+    this.#deperditionBaieVitreeService = deperditionBaieVitreeService;
+    this.#deperditionPontThermiqueService = deperditionPontThermiqueService;
     this.#deperditionVentilationService = deperditionVentilationService;
     this.#surfaceDeperditive = 0;
     this.#surfaceIsolee = 0;
@@ -135,6 +153,8 @@ export class DeperditionEnveloppeService {
       deperdition_mur: 0,
       deperdition_plancher_bas: 0,
       deperdition_plancher_haut: 0,
+      deperdition_baie_vitree: 0,
+      deperdition_pont_thermique: 0,
       deperdition_porte: 0
     };
 
@@ -211,6 +231,12 @@ export class DeperditionEnveloppeService {
     });
 
     enveloppe.baie_vitree_collection.baie_vitree?.forEach((bv) => {
+      bv.donnee_intermediaire = this.#deperditionBaieVitreeService.execute(ctx, bv);
+      deperditions.deperdition_baie_vitree +=
+        bv.donnee_intermediaire.b *
+        bv.donnee_entree.surface_totale_baie *
+        bv.donnee_intermediaire.u_menuiserie;
+
       // Surface de baie vitrée déperditive si b != 0
       if (bv.donnee_intermediaire.b > 0) {
         this.#surfaceDeperditive += bv.donnee_entree.surface_totale_baie;
@@ -223,6 +249,18 @@ export class DeperditionEnveloppeService {
       }
     });
 
+    enveloppe.pont_thermique_collection.pont_thermique?.forEach((pt) => {
+      pt.donnee_intermediaire = this.#deperditionPontThermiqueService.execute(
+        ctx,
+        enveloppe,
+        pt.donnee_entree
+      );
+      deperditions.deperdition_pont_thermique +=
+        pt.donnee_entree.l *
+        pt.donnee_intermediaire.k *
+        (pt.donnee_entree.pourcentage_valeur_pont_thermique || 1);
+    });
+
     return deperditions;
   }
 

package/features/engine/domain/enveloppe/mur/deperdition-mur.service.js

@@ -165,4 +165,32 @@ export class DeperditionMurService extends DeperditionService {
      */
     return Math.min(2.5, Math.round(parseFloat(umur0) * PRECISION) / PRECISION);
   }
+
+  /**
+   * Retourner le type d'isolation du mur
+   * Si isolation inconnue, on considère isolation iti si la période d'isolation (à défaut année de construction) est > 1975
+   *
+   * @param ctx {Contexte}
+   * @param murDE {MurDE}
+   * @return {number}
+   */
+  typeIsolation(ctx, murDE) {
+    const typeIsolation = parseInt(murDE.enum_type_isolation_id);
+
+    // Type d'isolation inconnu
+    if (typeIsolation === 1) {
+      const periodeIsolation = murDE.enum_periode_isolation_id || ctx.enumPeriodeConstructionId;
+
+      // Année isolation / construction > 1974
+      if (parseInt(periodeIsolation) >= 3) {
+        // Isolation ITI
+        return 3;
+      } else {
+        // Non isolé
+        return 2;
+      }
+    }
+
+    return typeIsolation;
+  }
 }

package/features/engine/domain/enveloppe/mur/deperdition-mur.service.spec.js

@@ -315,6 +315,67 @@ describe('Calcul de déperdition des murs', () => {
     });
   });
 
+  test.each([
+    {
+      label: 'mur avec isolation inconnue et période isolation 1975',
+      enumTypeIsolationId: 1,
+      enumPeriodIsolationId: 3,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 3
+    },
+    {
+      label: 'mur avec isolation inconnue et période construction 1975',
+      enumTypeIsolationId: 1,
+      enumPeriodIsolationId: undefined,
+      enumPeriodeConstructionId: 6,
+      typeIsolationExpected: 3
+    },
+    {
+      label: 'mur avec isolation inconnue et période isolation 1974',
+      enumTypeIsolationId: 1,
+      enumPeriodIsolationId: 2,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 2
+    },
+    {
+      label: 'mur avec isolation inconnue et période construction 1974',
+      enumTypeIsolationId: 1,
+      enumPeriodIsolationId: undefined,
+      enumPeriodeConstructionId: 1,
+      typeIsolationExpected: 2
+    },
+    {
+      label: 'mur avec isolation iti+ite',
+      enumTypeIsolationId: 6,
+      enumPeriodIsolationId: 1,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 6
+    }
+  ])(
+    "Récupération du type d'isolation pour $label",
+    ({
+      enumTypeIsolationId,
+      enumPeriodIsolationId = undefined,
+      enumPeriodeConstructionId = undefined,
+      typeIsolationExpected
+    }) => {
+      /**
+       * @type {MurDE}
+       */
+      let murDE = {
+        enum_type_isolation_id: enumTypeIsolationId,
+        enum_periode_isolation_id: enumPeriodIsolationId
+      };
+
+      /**
+       * @type {Contexte}
+       */
+      const ctx = { enumPeriodeConstructionId };
+
+      expect(service.typeIsolation(ctx, murDE)).toBe(typeIsolationExpected);
+    }
+  );
+
   describe("Test d'intégration de mur", () => {
     test.each(corpus)('vérification des DI des murs pour dpe %s', (ademeId) => {
       let dpeRequest = getAdemeFileJson(ademeId);