@open3cl/engine 1.0.8 → 1.0.9

package/features/dpe/domain/models/dpe.model.ts

@@ -4,8 +4,7 @@ import { Ets } from './ets.model';
 import { InstallationChauffage } from './installation-chauffage.model';
 import { InstallationEcs } from './installation-ecs.model';
 import { Mur } from './mur.model';
-import { PlancherBas } from './plancher-bas.model';
-import { PlancherHaut } from './plancher-haut.model';
+import { PlancherBas, PlancherHaut } from './plancher.model';
 import { PontThermique } from './pont-thermique.model';
 import { Porte } from './porte.model';
 import { ProductionElecEnr } from './production-elec-enr.model';
@@ -187,7 +186,12 @@ export interface DE {
   reference?: string;
 }
 
-enum TypeHabitation {
+export enum TypeHabitation {
+  MAISON = 'MAISON',
+  APPARTEMENT = 'APPARTEMENT',
+  IMMEUBLE = 'IMMEUBLE'
+}
+export enum TypeDpe {
   MAISON = 'MAISON',
   APPARTEMENT = 'APPARTEMENT',
   IMMEUBLE = 'IMMEUBLE'

package/features/dpe/domain/models/{plancher-bas.model.ts → plancher.model.ts}

@@ -5,7 +5,12 @@ export interface PlancherBas {
   donnee_intermediaire?: PlancherBasDI;
 }
 
-export interface PlancherBasDE extends DE {
+export interface PlancherHaut {
+  donnee_entree?: PlancherHautDE;
+  donnee_intermediaire?: PlancherHautDI;
+}
+
+export interface PlancherDE extends DE {
   reference_lnc?: string;
   tv_coef_reduction_deperdition_id?: string; // TV
   surface_aiu?: number;
@@ -13,26 +18,45 @@ export interface PlancherBasDE extends DE {
   enum_cfg_isolation_lnc_id?: string; // ENUM cfg_isolation_lnc
   enum_type_adjacence_id?: string; // ENUM type_adjacence
   surface_paroi_opaque?: number;
-  upb0_saisi?: number;
-  tv_upb0_id?: string; // TV
-  enum_type_plancher_bas_id?: string; // ENUM type_plancher_bas
   enum_methode_saisie_u0_id?: string; // ENUM methode_saisie_u0
-  upb_saisi?: number;
+
   enum_type_isolation_id?: string; // ENUM type_isolation
   enum_periode_isolation_id?: string; // ENUM periode_isolation
   resistance_isolation?: number;
   epaisseur_isolation?: number;
-  tv_upb_id?: string; // TV
   enum_methode_saisie_u_id?: string; // ENUM methode_saisie_u
+}
+
+export interface PlancherDI {
+  b: number;
+}
+
+export interface PlancherBasDE extends PlancherDE {
+  upb0_saisi?: number;
+  tv_upb0_id?: string; // TV
+  enum_type_plancher_bas_id?: string; // ENUM type_plancher_bas
+  upb_saisi?: number;
+  tv_upb_id?: string; // TV
   calcul_ue: number;
   perimetre_ue?: number;
   surface_ue?: number;
   ue?: number;
 }
 
-export interface PlancherBasDI {
+export interface PlancherBasDI extends PlancherDI {
   upb: number;
   upb0: number;
   upb_final: number;
+}
+
+export interface PlancherHautDE extends PlancherDE {
+  uph0_saisi?: number;
+  tv_uph0_id?: string; // TV
+  enum_type_plancher_haut_id?: string; // ENUM type_plancher_bas
+  uph_saisi?: number;
+  tv_uph_id?: string; // TV
+}
+
+export interface PlancherHautDI extends PlancherDI {
   b: number;
 }

package/features/dpe/infrastructure/pontThermiqueTv.store.js

@@ -0,0 +1,112 @@
+import { tvs as tv } from '../../../tv-v2.js';
+import { logger } from '../../../core/util/logger/log-service.js';
+import { TvStore } from './tv.store.js';
+
+/**
+ * Accès aux données des tables de valeurs pour les baies vitrées
+ */
+export class PontThermiqueTvStore extends TvStore {
+  /**
+   * Valeur du pont thermique (W/(m.K)) via tv_pont_thermique_id
+   *
+   * @param tvPontThermiqueId {number}
+   * @return {number|undefined}
+   */
+  getKForMurById(tvPontThermiqueId) {
+    const k = tv['pont_thermique'].find(
+      (v) => parseInt(v.tv_pont_thermique_id) === tvPontThermiqueId
+    )?.k;
+
+    if (!k) {
+      logger.error(`Pas de valeur forfaitaire k pour tvPontThermiqueId:${tvPontThermiqueId}`);
+      return 0;
+    }
+
+    return parseFloat(k);
+  }
+
+  /**
+   * Valeur du pont thermique (W/(m.K))
+   *
+   * @param enumTypeLiaisonId {number}
+   * @param isolationMur {string}
+   * @return {number|undefined}
+   */
+  getKForMur(enumTypeLiaisonId, isolationMur) {
+    const k = tv['pont_thermique'].find(
+      (v) =>
+        parseInt(v.enum_type_liaison_id) === enumTypeLiaisonId &&
+        v.isolation_mur.toLowerCase() === isolationMur.toLowerCase()
+    )?.k;
+
+    if (!k) {
+      logger.error(`Pas de valeur forfaitaire k pour isolationMur:${isolationMur}`);
+      return;
+    }
+
+    return parseFloat(k);
+  }
+
+  /**
+   * Valeur du pont thermique (W/(m.K))
+   *
+   * @param enumTypeLiaisonId {number}
+   * @param isolationMur {string}
+   * @param isolationPlancher {string}
+   * @return {number|undefined}
+   */
+  getKForPlancher(enumTypeLiaisonId, isolationMur, isolationPlancher) {
+    const k = tv['pont_thermique'].find(
+      (v) =>
+        parseInt(v.enum_type_liaison_id) === enumTypeLiaisonId &&
+        v.isolation_mur.toLowerCase() === isolationMur.toLowerCase() &&
+        v.isolation_plancher.toLowerCase() === isolationPlancher.toLowerCase()
+    )?.k;
+
+    if (!k) {
+      logger.error(
+        `Pas de valeur forfaitaire k pour isolationMur:${isolationMur}, isolationPlancher:${isolationPlancher}`
+      );
+      return;
+    }
+
+    return parseFloat(k);
+  }
+
+  /**
+   * Valeur du pont thermique (W/(m.K))
+   *
+   * @param enumTypeLiaisonId {number}
+   * @param isolationMur {string}
+   * @param typePose {number}
+   * @param presenceRetourIsolation {number}
+   * @param largeurDormant {number}
+   * @return {number|undefined}
+   */
+  getKForMenuiserie(
+    enumTypeLiaisonId,
+    isolationMur,
+    typePose,
+    presenceRetourIsolation,
+    largeurDormant
+  ) {
+    const k = tv['pont_thermique'].find(
+      (v) =>
+        parseInt(v.enum_type_liaison_id) === enumTypeLiaisonId &&
+        v.isolation_mur.toLowerCase() === isolationMur.toLowerCase() &&
+        (!v.enum_type_pose_id || parseInt(v.enum_type_pose_id) === typePose) &&
+        (!v.presence_retour_isolation ||
+          parseInt(v.presence_retour_isolation) === presenceRetourIsolation) &&
+        (!v.largeur_dormant || !largeurDormant || parseInt(v.largeur_dormant) === largeurDormant)
+    )?.k;
+
+    if (!k) {
+      logger.error(
+        `Pas de valeur forfaitaire k pour isolationMur:${isolationMur}, typePose:${typePose}, presenceRetourIsolation:${presenceRetourIsolation}, largeurDormant:${largeurDormant}`
+      );
+      return;
+    }
+
+    return parseFloat(k);
+  }
+}

package/features/dpe/infrastructure/pontThermiqueTv.store.spec.js

@@ -0,0 +1,134 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import { PontThermiqueTvStore } from './pontThermiqueTv.store.js';
+
+/** @type {PontThermiqueTvStore} **/
+let tvStore;
+
+describe('Lecture des tables de valeurs', () => {
+  beforeEach(() => {
+    tvStore = new PontThermiqueTvStore();
+  });
+
+  describe('lecture des valeurs de k', () => {
+    test.each([
+      {
+        label: 'tv_pont_thermique_id existant',
+        tvPontThermiqueId: 1,
+        expected: 0.39
+      },
+      {
+        label: 'tv_pont_thermique_id inexistant',
+        tvPontThermiqueId: 0,
+        expected: 0
+      }
+    ])(
+      `k via tv_pont_thermique_id pour un pont thermique avec $label`,
+      ({ tvPontThermiqueId, expected }) => {
+        expect(tvStore.getKForMurById(tvPontThermiqueId)).toBe(expected);
+      }
+    );
+
+    test.each([
+      {
+        label: 'enum_type_liaison_id et isolation_mur qui correspondent',
+        enumTypeLiaisonId: 1,
+        isolationMur: 'Non isolé',
+        expected: 0.39
+      },
+      {
+        label: 'enum_type_liaison_id et isolation_mur qui ne correspondent à aucune entrée',
+        enumTypeLiaisonId: 0,
+        isolationMur: '',
+        expected: undefined
+      }
+    ])(`k pour un pont thermique via $label`, ({ enumTypeLiaisonId, isolationMur, expected }) => {
+      expect(tvStore.getKForMur(enumTypeLiaisonId, isolationMur)).toBe(expected);
+    });
+
+    test.each([
+      {
+        label: 'enum_type_liaison_id, isolation_mur et isolationPlancher qui correspondent',
+        enumTypeLiaisonId: 1,
+        isolationMur: 'Non isolé',
+        isolationPlancher: 'iti',
+        expected: 0.47
+      },
+      {
+        label: 'enum_type_liaison_id et isolation_mur qui ne correspondent à aucune entrée',
+        enumTypeLiaisonId: 0,
+        isolationMur: 'Non isolé',
+        isolationPlancher: 'iti',
+        expected: undefined
+      }
+    ])(
+      `k pour un pont thermique via $label`,
+      ({ enumTypeLiaisonId, isolationMur, isolationPlancher, expected }) => {
+        expect(tvStore.getKForPlancher(enumTypeLiaisonId, isolationMur, isolationPlancher)).toBe(
+          expected
+        );
+      }
+    );
+  });
+
+  test.each([
+    {
+      label:
+        'enum_type_liaison_id, isolation_mur, typePose, largeurDormant, sans largeurDormant et presenceRetourIsolation qui correspondent',
+      enumTypeLiaisonId: 5,
+      isolationMur: 'Non isolé',
+      typePose: 1,
+      presenceRetourIsolation: undefined,
+      largeurDormant: undefined,
+      expected: 0.43
+    },
+    {
+      label:
+        'enum_type_liaison_id, isolation_mur, typePose, largeurDormant, sans presenceRetourIsolation qui correspondent',
+      enumTypeLiaisonId: 5,
+      isolationMur: 'Non isolé',
+      typePose: 1,
+      presenceRetourIsolation: undefined,
+      largeurDormant: 5,
+      expected: 0.43
+    },
+    {
+      label:
+        'enum_type_liaison_id, isolation_mur, typePose, largeurDormant, presenceRetourIsolation qui correspondent',
+      enumTypeLiaisonId: 5,
+      isolationMur: 'iti',
+      typePose: 3,
+      presenceRetourIsolation: 1,
+      largeurDormant: 10,
+      expected: 0.13
+    },
+    {
+      label: 'enum_type_liaison_id et isolation_mur qui ne correspondent à aucune entrée',
+      enumTypeLiaisonId: 5,
+      isolationMur: 'undefined',
+      typePose: 1,
+      presenceRetourIsolation: '1',
+      largeurDormant: 5,
+      expected: undefined
+    }
+  ])(
+    `k pour un pont thermique via $label`,
+    ({
+      enumTypeLiaisonId,
+      isolationMur,
+      typePose,
+      presenceRetourIsolation,
+      largeurDormant,
+      expected
+    }) => {
+      expect(
+        tvStore.getKForMenuiserie(
+          enumTypeLiaisonId,
+          isolationMur,
+          typePose,
+          presenceRetourIsolation,
+          largeurDormant
+        )
+      ).toBe(expected);
+    }
+  );
+});

package/features/engine/domain/engine.service.js

@@ -1,6 +1,7 @@
 import { inject } from 'dioma';
 import { ContexteBuilder } from './contexte.builder.js';
 import { DeperditionEnveloppeService } from './enveloppe/deperdition-enveloppe.service.js';
+import { logger } from '../../../core/util/logger/log-service.js';
 
 export class EngineService {
   /**
@@ -33,7 +34,7 @@ export class EngineService {
     /** @type {Dpe} */
     const proceededDpe = this.#removeComputedData(JSON.parse(JSON.stringify(dpe)));
 
-    console.error(`Process DPE ${proceededDpe.numero_dpe}`);
+    logger.info(`Process DPE ${proceededDpe.numero_dpe}`);
 
     proceededDpe.logement.sortie = {
       deperdition: undefined,

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

@@ -5,6 +5,7 @@ import { DeperditionPlancherBasService } from './plancher_bas/deperdition-planch
 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
@@ -36,6 +37,11 @@ export class DeperditionEnveloppeService {
    */
   #deperditionBaieVitreeService;
 
+  /**
+   * @type {DeperditionPontThermiqueService}
+   */
+  #deperditionPontThermiqueService;
+
   /**
    * @type {DeperditionVentilationService}
    */
@@ -73,6 +79,7 @@ export class DeperditionEnveloppeService {
    * @param deperditionPlancherBasService {DeperditionPlancherBasService}
    * @param deperditionPlancherHautService {DeperditionPlancherHautService}
    * @param deperditionBaieVitreeService {DeperditionBaieVitreeService}
+   * @param deperditionPontThermiqueService {DeperditionPontThermiqueService}
    * @param deperditionVentilationService {DeperditionVentilationService}
    */
   constructor(
@@ -81,6 +88,7 @@ export class DeperditionEnveloppeService {
     deperditionPlancherBasService = inject(DeperditionPlancherBasService),
     deperditionPlancherHautService = inject(DeperditionPlancherHautService),
     deperditionBaieVitreeService = inject(DeperditionBaieVitreeService),
+    deperditionPontThermiqueService = inject(DeperditionPontThermiqueService),
     deperditionVentilationService = inject(DeperditionVentilationService)
   ) {
     this.#deperditionMurService = deperditionMurService;
@@ -88,6 +96,7 @@ export class DeperditionEnveloppeService {
     this.#deperditionPlancherBasService = deperditionPlancherBasService;
     this.#deperditionPlancherHautService = deperditionPlancherHautService;
     this.#deperditionBaieVitreeService = deperditionBaieVitreeService;
+    this.#deperditionPontThermiqueService = deperditionPontThermiqueService;
     this.#deperditionVentilationService = deperditionVentilationService;
     this.#surfaceDeperditive = 0;
     this.#surfaceIsolee = 0;
@@ -145,6 +154,7 @@ export class DeperditionEnveloppeService {
       deperdition_plancher_bas: 0,
       deperdition_plancher_haut: 0,
       deperdition_baie_vitree: 0,
+      deperdition_pont_thermique: 0,
       deperdition_porte: 0
     };
 
@@ -239,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);

package/features/engine/domain/enveloppe/plancher_bas/deperdition-plancher-bas.service.js

@@ -166,4 +166,50 @@ export class DeperditionPlancherBasService extends DeperditionService {
 
     return Math.round(parseFloat(upbFinal) * PRECISION) / PRECISION;
   }
+
+  /**
+   * Retourner le type d'isolation du plancher
+   * Si isolation inconnue :
+   *  - Les planchers sur terre-plein sont considérés non isolés avant 2001 et isolés par l’extérieur (en sous-face) à partir de 2001
+   *  - Les autres planchers sont considérés isolés par l’extérieur
+   *
+   * @param ctx {Contexte}
+   * @param plancherBasDE {PlancherBasDE}
+   * @return {number}
+   */
+  typeIsolation(ctx, plancherBasDE) {
+    const typeIsolation = parseInt(plancherBasDE.enum_type_isolation_id);
+
+    // Type d'isolation inconnu
+    if (typeIsolation === 1) {
+      const typeAdjacence = parseInt(plancherBasDE.enum_type_adjacence_id);
+      const periodeIsolation =
+        parseInt(plancherBasDE.enum_periode_isolation_id) ||
+        parseInt(ctx.enumPeriodeConstructionId);
+
+      // Plancher sur terre-plein
+      if (typeAdjacence === 5) {
+        // Année isolation / construction < 2001
+        if (periodeIsolation < 7) {
+          // Non isolé
+          return 2;
+        } else {
+          // Isolation ITE
+          return 4;
+        }
+      } else {
+        // Année isolation / construction < 1975
+        if (periodeIsolation < 3) {
+          // Non isolé
+          return 2;
+        } else {
+          // Isolation ITE
+          return 4;
+        }
+      }
+    }
+
+    // Isolation ITE si "isolé mais type d'isolation inconnu"
+    return typeIsolation === 9 ? 4 : typeIsolation;
+  }
 }

package/features/engine/domain/enveloppe/plancher_bas/deperdition-plancher-bas.service.spec.js

@@ -170,6 +170,91 @@ describe('Calcul de déperdition des planchers bas', () => {
     });
   });
 
+  test.each([
+    {
+      label:
+        'plancher bas avec isolation inconnue, adjacence terre-plein et période isolation 1974',
+      enumTypeIsolationId: 1,
+      enumTypeAdjacenceId: 5,
+      enumPeriodIsolationId: 1,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 2
+    },
+    {
+      label:
+        'plancher bas avec isolation inconnue, adjacence terre-plein et période construction 2000',
+      enumTypeIsolationId: 1,
+      enumTypeAdjacenceId: 5,
+      enumPeriodIsolationId: undefined,
+      enumPeriodeConstructionId: 6,
+      typeIsolationExpected: 2
+    },
+    {
+      label:
+        'plancher bas avec isolation inconnue, adjacence terre-plein et période isolation 2001',
+      enumTypeIsolationId: 1,
+      enumPeriodIsolationId: 7,
+      enumTypeAdjacenceId: 5,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 4
+    },
+    {
+      label: 'plancher bas avec isolation inconnue, adjacence garage et période isolation 1974',
+      enumTypeIsolationId: 1,
+      enumPeriodIsolationId: 2,
+      enumTypeAdjacenceId: 8,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 2
+    },
+    {
+      label: 'plancher bas avec isolation inconnue, adjacence garage et période isolation 1975',
+      enumTypeIsolationId: 1,
+      enumPeriodIsolationId: 3,
+      enumTypeAdjacenceId: 8,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 4
+    },
+    {
+      label: 'plancher bas avec isolation de type "isolé mais type d\'isolation inconnu"',
+      enumTypeIsolationId: 9,
+      enumPeriodIsolationId: 1,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 4
+    },
+    {
+      label: 'plancher bas avec isolation iti+ite',
+      enumTypeIsolationId: 6,
+      enumPeriodIsolationId: 1,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 6
+    }
+  ])(
+    "Récupération du type d'isolation pour $label",
+    ({
+      enumTypeIsolationId,
+      enumPeriodIsolationId = undefined,
+      enumTypeAdjacenceId = undefined,
+      enumPeriodeConstructionId = undefined,
+      typeIsolationExpected
+    }) => {
+      /**
+       * @type {PlancherBasDE}
+       */
+      let plancherBasDE = {
+        enum_type_isolation_id: enumTypeIsolationId,
+        enum_type_adjacence_id: enumTypeAdjacenceId,
+        enum_periode_isolation_id: enumPeriodIsolationId
+      };
+
+      /**
+       * @type {Contexte}
+       */
+      const ctx = { enumPeriodeConstructionId };
+
+      expect(service.typeIsolation(ctx, plancherBasDE)).toBe(typeIsolationExpected);
+    }
+  );
+
   describe("Test d'intégration de plancher bas", () => {
     test.each(corpus)('vérification des DI des pb pour dpe %s', (ademeId) => {
       /**