@open3cl/engine 1.0.8 → 1.0.10

package/features/engine/domain/contexte.builder.js

@@ -1,4 +1,5 @@
-import { TypeHabitation } from '../../dpe/domain/models/type-habitation.model.js';
+import { TypeDpe, TypeHabitation } from '../../dpe/domain/models/type-habitation.model.js';
+import enums from '../../../enums.js';
 
 /**
  * Génère un contexte du logement à étudier avec des données persistées durant l'analyse
@@ -11,14 +12,30 @@ export class ContexteBuilder {
    * @return {Contexte}
    */
   fromDpe(dpe) {
+    const caracteristiqueGenerale = dpe.logement.caracteristique_generale;
+
     return {
-      zoneClimatiqueId: dpe.logement.meteo?.enum_zone_climatique_id.toString(),
-      typeHabitation: this.#getTypeHabitation(dpe),
-      enumPeriodeConstructionId:
-        dpe.logement.caracteristique_generale.enum_periode_construction_id?.toString(),
+      zoneClimatique: this.#zoneClimatique(dpe),
+      typeHabitation: this.#getTypeHabitation(caracteristiqueGenerale),
+      typeDpe: this.#getTypeDpe(caracteristiqueGenerale),
+      enumPeriodeConstructionId: caracteristiqueGenerale.enum_periode_construction_id?.toString(),
       effetJoule: this.#hasEffetJoule(dpe),
-      surfaceHabitable: this.#getSurfaceHabitable(dpe),
-      hauteurSousPlafond: dpe.logement.caracteristique_generale.hsp
+      surfaceHabitable: this.#getSurfaceHabitable(caracteristiqueGenerale),
+      hauteurSousPlafond: caracteristiqueGenerale.hsp,
+      nombreAppartement: caracteristiqueGenerale.nombre_appartement
+    };
+  }
+
+  /**
+   * La zone climatique à partir du type de DPE
+   * @param dpe {Dpe}
+   * @return {{id: number, value: string}}
+   */
+  #zoneClimatique(dpe) {
+    const zoneClimatiqueId = parseInt(dpe.logement.meteo?.enum_zone_climatique_id);
+    return {
+      id: zoneClimatiqueId.toString(),
+      value: enums.zone_climatique[zoneClimatiqueId]
     };
   }
 
@@ -39,43 +56,20 @@ export class ContexteBuilder {
 
   /**
    * Le type d'habitation est détecté à partir du type de DPE
-   * @param dpe {Dpe}
+   * @param caracteristiqueGenerale {CaracteristiqueGenerale}
    * @return {TypeHabitation}
    */
-  #getTypeHabitation(dpe) {
-    const methodeApplication =
-      dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id;
+  #getTypeHabitation(caracteristiqueGenerale) {
+    const methodeApplication = parseInt(
+      caracteristiqueGenerale.enum_methode_application_dpe_log_id
+    );
 
-    if (['1', '14', '18'].includes(methodeApplication)) {
+    if ([1, 14, 18].includes(methodeApplication)) {
       return TypeHabitation.MAISON;
     } else if (
       [
-        '2',
-        '3',
-        '4',
-        '5',
-        '10',
-        '11',
-        '12',
-        '13',
-        '15',
-        '16',
-        '19',
-        '20',
-        '22',
-        '23',
-        '24',
-        '25',
-        '31',
-        '32',
-        '33',
-        '34',
-        '35',
-        '36',
-        '37',
-        '38',
-        '39',
-        '40'
+        2, 3, 4, 5, 10, 11, 12, 13, 15, 16, 19, 20, 22, 23, 24, 25, 31, 32, 33, 34, 35, 36, 37, 38,
+        39, 40
       ].includes(methodeApplication)
     ) {
       return TypeHabitation.APPARTEMENT;
@@ -84,10 +78,28 @@ export class ContexteBuilder {
   }
 
   /**
-   * @param dpe {Dpe}
+   * Le type de DPE est détecté à partir du type de DPE
+   * @param caracteristiqueGenerale {CaracteristiqueGenerale}
+   * @return {TypeDpe}
+   */
+  #getTypeDpe(caracteristiqueGenerale) {
+    const methodeApplication = parseInt(
+      caracteristiqueGenerale.enum_methode_application_dpe_log_id
+    );
+
+    if ([1, 14, 18].includes(methodeApplication)) {
+      return TypeDpe.MAISON;
+    } else if ([2, 3, 4, 5, 31, 32, 35, 36, 37].includes(methodeApplication)) {
+      return TypeDpe.APPARTEMENT;
+    }
+    return TypeDpe.IMMEUBLE;
+  }
+
+  /**
+   * @param caracteristiqueGenerale {CaracteristiqueGenerale}
    * @return {number}
    */
-  #getSurfaceHabitable(dpe) {
+  #getSurfaceHabitable(caracteristiqueGenerale) {
     /**
      * Certains DPE appartement sont générés à partir des données du DPE immeuble, la surface à prendre en compte est
      * celle de l'immeuble pour les besoins ECS
@@ -110,31 +122,15 @@ export class ContexteBuilder {
      * 40 - dpe appartement généré à partir des données DPE immeuble chauffage collectif ecs mixte (collectif-individuel)
      */
     if (
-      [
-        '10',
-        '11',
-        '12',
-        '13',
-        '15',
-        '16',
-        '19',
-        '20',
-        '22',
-        '23',
-        '24',
-        '25',
-        '33',
-        '34',
-        '38',
-        '39',
-        '40'
-      ].includes(dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id)
+      [10, 11, 12, 13, 15, 16, 19, 20, 22, 23, 24, 25, 33, 34, 38, 39, 40].includes(
+        parseInt(caracteristiqueGenerale.enum_methode_application_dpe_log_id)
+      )
     ) {
-      return dpe.logement.caracteristique_generale.surface_habitable_immeuble;
+      return caracteristiqueGenerale.surface_habitable_immeuble;
     }
 
-    return this.#getTypeHabitation(dpe) === TypeHabitation.IMMEUBLE
-      ? dpe.logement.caracteristique_generale.surface_habitable_immeuble
-      : dpe.logement.caracteristique_generale.surface_habitable_logement;
+    return this.#getTypeHabitation(caracteristiqueGenerale) === TypeHabitation.IMMEUBLE
+      ? caracteristiqueGenerale.surface_habitable_immeuble
+      : caracteristiqueGenerale.surface_habitable_logement;
   }
 }

package/features/engine/domain/contexte.builder.spec.js

@@ -1,5 +1,6 @@
 import { ContexteBuilder } from './contexte.builder.js';
 import { beforeEach, describe, expect, test } from 'vitest';
+import { TypeDpe, TypeHabitation } from '../../dpe/domain/models/type-habitation.model.js';
 
 /** @type {ContexteBuilder} **/
 let contexteBuilder;
@@ -12,13 +13,7 @@ describe('Generateur du contexte du calcul', () => {
   test('Contexte avec effet joule', () => {
     const dpe = {
       logement: {
-        meteo: { enum_zone_climatique_id: 1 },
-        caracteristique_generale: {
-          enum_periode_construction_id: 1,
-          surface_habitable_logement: 48.9,
-          surface_habitable_immeuble: 105,
-          hsp: 2.8
-        },
+        caracteristique_generale: {},
         installation_chauffage_collection: {
           installation_chauffage: [
             {
@@ -31,26 +26,15 @@ describe('Generateur du contexte du calcul', () => {
       }
     };
 
-    expect(contexteBuilder.fromDpe(dpe)).toStrictEqual({
-      effetJoule: true,
-      enumPeriodeConstructionId: '1',
-      zoneClimatiqueId: '1',
-      hauteurSousPlafond: 2.8,
-      surfaceHabitable: 105,
-      typeHabitation: 'IMMEUBLE'
+    expect(contexteBuilder.fromDpe(dpe)).toMatchObject({
+      effetJoule: true
     });
   });
 
   test('Contexte sans effet joule', () => {
     const dpe = {
       logement: {
-        meteo: { enum_zone_climatique_id: 1 },
-        caracteristique_generale: {
-          enum_periode_construction_id: 1,
-          surface_habitable_logement: 48.9,
-          surface_habitable_immeuble: 105,
-          hsp: 2.8
-        },
+        caracteristique_generale: {},
         installation_chauffage_collection: {
           installation_chauffage: [
             {
@@ -65,88 +49,83 @@ describe('Generateur du contexte du calcul', () => {
       }
     };
 
-    expect(contexteBuilder.fromDpe(dpe)).toStrictEqual({
-      effetJoule: false,
-      enumPeriodeConstructionId: '1',
-      zoneClimatiqueId: '1',
-      hauteurSousPlafond: 2.8,
-      surfaceHabitable: 105,
-      typeHabitation: 'IMMEUBLE'
+    expect(contexteBuilder.fromDpe(dpe)).toMatchObject({
+      effetJoule: false
     });
   });
 
   test('Contexte sans chauffage', () => {
     const dpe = {
       logement: {
-        meteo: { enum_zone_climatique_id: 1 },
-        caracteristique_generale: {
-          enum_periode_construction_id: 1,
-          surface_habitable_logement: 48.9,
-          surface_habitable_immeuble: 105,
-          hsp: 2.8
-        }
+        caracteristique_generale: {}
       }
     };
 
-    expect(contexteBuilder.fromDpe(dpe)).toStrictEqual({
-      effetJoule: false,
-      enumPeriodeConstructionId: '1',
-      zoneClimatiqueId: '1',
-      hauteurSousPlafond: 2.8,
-      surfaceHabitable: 105,
-      typeHabitation: 'IMMEUBLE'
+    expect(contexteBuilder.fromDpe(dpe)).toMatchObject({
+      effetJoule: false
     });
   });
 
   test('Contexte sans emetteur de chauffage', () => {
     const dpe = {
       logement: {
-        meteo: { enum_zone_climatique_id: 1 },
-        caracteristique_generale: {
-          enum_periode_construction_id: 1,
-          surface_habitable_logement: 48.9,
-          surface_habitable_immeuble: 105,
-          hsp: 2.8
-        },
+        caracteristique_generale: {},
         installation_chauffage_collection: {}
       }
     };
 
-    expect(contexteBuilder.fromDpe(dpe)).toStrictEqual({
-      effetJoule: false,
-      enumPeriodeConstructionId: '1',
-      zoneClimatiqueId: '1',
-      hauteurSousPlafond: 2.8,
-      surfaceHabitable: 105,
-      typeHabitation: 'IMMEUBLE'
+    expect(contexteBuilder.fromDpe(dpe)).toMatchObject({
+      effetJoule: false
     });
   });
 
-  test('Récupération de la surface habitable du logement concerné par le DPE', () => {
+  test('Récupération des informations du logement concerné par le DPE', () => {
     let dpe = {
       logement: {
+        meteo: {
+          enum_zone_climatique_id: 1
+        },
         caracteristique_generale: {
-          enum_periode_construction_id: 1,
+          enum_periode_construction_id: 4,
           surface_habitable_logement: 48.9,
           surface_habitable_immeuble: 105,
-          hsp: 2.8
+          hsp: 2.8,
+          nombre_appartement: 18
         }
       }
     };
 
     dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id = '1';
     expect(contexteBuilder.fromDpe(dpe)).toMatchObject({
-      surfaceHabitable: dpe.logement.caracteristique_generale.surface_habitable_logement
+      surfaceHabitable: dpe.logement.caracteristique_generale.surface_habitable_logement,
+      typeHabitation: TypeHabitation.MAISON,
+      typeDpe: TypeDpe.MAISON,
+      enumPeriodeConstructionId: '4',
+      hauteurSousPlafond: 2.8,
+      nombreAppartement: 18,
+      zoneClimatique: {
+        id: '1',
+        value: 'h1a'
+      }
     });
 
     dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id = '5';
+    dpe.logement.meteo.enum_zone_climatique_id = '4';
     expect(contexteBuilder.fromDpe(dpe)).toMatchObject({
-      surfaceHabitable: dpe.logement.caracteristique_generale.surface_habitable_logement
+      surfaceHabitable: dpe.logement.caracteristique_generale.surface_habitable_logement,
+      typeHabitation: TypeHabitation.APPARTEMENT,
+      typeDpe: TypeDpe.APPARTEMENT,
+      zoneClimatique: {
+        id: '4',
+        value: 'h2a'
+      }
     });
 
     dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id = '8';
     expect(contexteBuilder.fromDpe(dpe)).toMatchObject({
-      surfaceHabitable: dpe.logement.caracteristique_generale.surface_habitable_immeuble
+      surfaceHabitable: dpe.logement.caracteristique_generale.surface_habitable_immeuble,
+      typeHabitation: TypeHabitation.IMMEUBLE,
+      typeDpe: TypeDpe.IMMEUBLE
     });
   });
 });

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

@@ -1,12 +1,20 @@
 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';
+import { SurfaceSudEquivalenteService } from './logement/surface-sud-equivalente.service.js';
 
 export class EngineService {
   /**
    * @type {DeperditionEnveloppeService}
    */
   #deperditionService;
+
+  /**
+   * @type {SurfaceSudEquivalenteService}
+   */
+  #surfaceSudEquivalenteService;
+
   /**
    * @type {ContexteBuilder}
    */
@@ -14,13 +22,16 @@ export class EngineService {
 
   /**
    * @param deperditionService {DeperditionEnveloppeService}
+   * @param surfaceSudEquivalenteService {SurfaceSudEquivalenteService}
    * @param contextBuilder {ContexteBuilder}
    */
   constructor(
     deperditionService = inject(DeperditionEnveloppeService),
+    surfaceSudEquivalenteService = inject(SurfaceSudEquivalenteService),
     contextBuilder = inject(ContexteBuilder)
   ) {
     this.#deperditionService = deperditionService;
+    this.#surfaceSudEquivalenteService = surfaceSudEquivalenteService;
     this.#contextBuilder = contextBuilder;
   }
 
@@ -33,7 +44,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,
@@ -54,9 +65,16 @@ export class EngineService {
     // Calcul des déperditions
     proceededDpe.logement.sortie.deperdition = this.#deperditionService.deperditions(
       ctx,
-      dpe.logement
+      proceededDpe.logement
     );
 
+    proceededDpe.logement.sortie.apport_et_besoin = {
+      surface_sud_equivalente: this.#surfaceSudEquivalenteService.execute(
+        ctx,
+        proceededDpe.logement.enveloppe
+      )
+    };
+
     // Calcul des déperditions par renouvellement de l'air
 
     // Calcul de l'intermittence

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

@@ -31,7 +31,7 @@ export class DeperditionBaieVitreeService extends DeperditionService {
       surfaceAiu: bvDE.surface_aiu,
       surfaceAue: bvDE.surface_aue,
       enumCfgIsolationLncId: bvDE.enum_cfg_isolation_lnc_id,
-      zoneClimatiqueId: ctx.zoneClimatiqueId
+      zoneClimatique: ctx.zoneClimatique?.value
     });
 
     let sw = this.sw(bv);

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

@@ -5,6 +5,8 @@ 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';
+import { EspaceTamponService } from './espace_tampon/espace-tampon.service.js';
 
 /**
  * Calcul des déperditions de l’enveloppe
@@ -36,6 +38,16 @@ export class DeperditionEnveloppeService {
    */
   #deperditionBaieVitreeService;
 
+  /**
+   * @type {EspaceTamponService}
+   */
+  #espaceTamponService;
+
+  /**
+   * @type {DeperditionPontThermiqueService}
+   */
+  #deperditionPontThermiqueService;
+
   /**
    * @type {DeperditionVentilationService}
    */
@@ -73,6 +85,8 @@ export class DeperditionEnveloppeService {
    * @param deperditionPlancherBasService {DeperditionPlancherBasService}
    * @param deperditionPlancherHautService {DeperditionPlancherHautService}
    * @param deperditionBaieVitreeService {DeperditionBaieVitreeService}
+   * @param espaceTamponService {EspaceTamponService}
+   * @param deperditionPontThermiqueService {DeperditionPontThermiqueService}
    * @param deperditionVentilationService {DeperditionVentilationService}
    */
   constructor(
@@ -81,6 +95,8 @@ export class DeperditionEnveloppeService {
     deperditionPlancherBasService = inject(DeperditionPlancherBasService),
     deperditionPlancherHautService = inject(DeperditionPlancherHautService),
     deperditionBaieVitreeService = inject(DeperditionBaieVitreeService),
+    espaceTamponService = inject(EspaceTamponService),
+    deperditionPontThermiqueService = inject(DeperditionPontThermiqueService),
     deperditionVentilationService = inject(DeperditionVentilationService)
   ) {
     this.#deperditionMurService = deperditionMurService;
@@ -88,6 +104,8 @@ export class DeperditionEnveloppeService {
     this.#deperditionPlancherBasService = deperditionPlancherBasService;
     this.#deperditionPlancherHautService = deperditionPlancherHautService;
     this.#deperditionBaieVitreeService = deperditionBaieVitreeService;
+    this.#espaceTamponService = espaceTamponService;
+    this.#deperditionPontThermiqueService = deperditionPontThermiqueService;
     this.#deperditionVentilationService = deperditionVentilationService;
     this.#surfaceDeperditive = 0;
     this.#surfaceIsolee = 0;
@@ -145,6 +163,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 +258,28 @@ export class DeperditionEnveloppeService {
       }
     });
 
+    let ets = enveloppe.ets_collection?.ets;
+    if (ets) {
+      // Certaines vérandas sont dupliqués dans les DPE.
+      if (Array.isArray(ets)) {
+        ets = ets[0];
+      }
+
+      ets.donnee_intermediaire = this.#espaceTamponService.execute(ctx, ets);
+    }
+
+    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/deperdition-enveloppe.service.spec.js

@@ -99,7 +99,7 @@ describe('Calcul des déperditions', () => {
         enumTypeAdjacenceId: '10',
         surfaceAiu: 8.14,
         surfaceAue: 22.8,
-        zoneClimatiqueId: '5',
+        zoneClimatique: 'h2c',
         enumCfgIsolationLncId: '9',
         label: 'espace tampon solarisé (véranda,loggia fermée)',
         bExpected: 0.85
@@ -197,7 +197,7 @@ describe('Calcul des déperditions', () => {
         enumTypeAdjacenceId,
         surfaceAiu = undefined,
         surfaceAue = undefined,
-        zoneClimatiqueId = undefined,
+        zoneClimatique = undefined,
         enumCfgIsolationLncId = undefined,
         bExpected
       }) => {
@@ -206,7 +206,7 @@ describe('Calcul des déperditions', () => {
           surfaceAiu,
           surfaceAue,
           enumCfgIsolationLncId,
-          zoneClimatiqueId
+          zoneClimatique
         };
 
         const b = deperditionMurService.b(data);

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

@@ -1,4 +1,3 @@
-import enums from '../../../../enums.js';
 import { logger } from '../../../../core/util/logger/log-service.js';
 import { inject } from 'dioma';
 import { TvStore } from '../../../dpe/infrastructure/tv.store.js';
@@ -71,13 +70,13 @@ export class DeperditionService {
      * Prise en compte de la zone climatique
      */
     if (['10'].includes(enumTypeAdjacenceId)) {
-      if (!d.zoneClimatiqueId) {
+      if (!d.zoneClimatique) {
         logger.warn(
           `impossible de calculer b pour TypeAdjacenceId:${enumTypeAdjacenceId} sans zone climatique`
         );
         return;
       }
-      zc = enums.zone_climatique[parseInt(d.zoneClimatiqueId)];
+      zc = d.zoneClimatique;
     }
 
     return this.tvStore.getB(enumTypeAdjacenceId, uVue, d.enumCfgIsolationLncId, rAiuAue, zc);

package/features/engine/domain/enveloppe/espace_tampon/espace-tampon.service.js

@@ -0,0 +1,44 @@
+import { DeperditionService } from '../deperdition.service.js';
+import { inject } from 'dioma';
+import { BaieVitreeTvStore } from '../../../../dpe/infrastructure/baieVitreeTv.store.js';
+
+/**
+ * Calcul des déperditions des baies vitrées
+ * Chapitre 3.3 Calcul des parois vitrées
+ *
+ * Méthode de calcul 3CL-DPE 2021
+ * Octobre 2021
+ * @see consolide_anne…arrete_du_31_03_2021_relatif_aux_methodes_et_procedures_applicables.pdf
+ */
+export class EspaceTamponService extends DeperditionService {
+  /**
+   * @param tvStore {BaieVitreeTvStore}
+   */
+  constructor(tvStore = inject(BaieVitreeTvStore)) {
+    super(tvStore);
+  }
+
+  /**
+   * @param ctx {Contexte}
+   * @param ets {Ets}
+   * @return {EtsDI}
+   */
+  execute(ctx, ets) {
+    const bvDE = ets.donnee_entree;
+
+    const bver = this.tvStore.getBver(
+      ctx.zoneClimatique.value,
+      parseInt(bvDE.enum_cfg_isolation_lnc_id)
+    );
+
+    const coef_transparence_ets = this.tvStore.getCoefTransparenceEts(
+      parseInt(bvDE.tv_coef_transparence_ets_id)
+    );
+
+    /** @type {EtsDI} */
+    return {
+      bver,
+      coef_transparence_ets
+    };
+  }
+}

package/features/engine/domain/enveloppe/espace_tampon/espace-tampon.service.spec.js

@@ -0,0 +1,81 @@
+import { ContexteBuilder } from '../../contexte.builder.js';
+import { DpeNormalizerService } from '../../../../normalizer/domain/dpe-normalizer.service.js';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { BaieVitreeTvStore } from '../../../../dpe/infrastructure/baieVitreeTv.store.js';
+import { EspaceTamponService } from './espace-tampon.service.js';
+import { getAdemeFileJson } from '../../../../../../test/test-helpers.js';
+
+/** @type {EspaceTamponService} **/
+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 EspaceTamponService(tvStore);
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
+  });
+
+  describe('Determination des données intermédiaires', () => {
+    test('Doit retourner bver et  directement', () => {
+      vi.spyOn(tvStore, 'getBver').mockReturnValue(0.55);
+      vi.spyOn(tvStore, 'getCoefTransparenceEts').mockReturnValue(0.62);
+
+      /**
+       * @type {Contexte}
+       */
+      const ctx = {
+        zoneClimatique: { value: 'h1a' }
+      };
+
+      /**
+       * @type {Ets}
+       */
+      const ets = {
+        donnee_entree: {
+          enum_cfg_isolation_lnc_id: '10',
+          tv_coef_transparence_ets_id: '2'
+        }
+      };
+
+      let etsDI = service.execute(ctx, ets);
+      expect(tvStore.getBver).toHaveBeenCalledWith('h1a', 10);
+      expect(tvStore.getCoefTransparenceEts).toHaveBeenCalledWith(2);
+      expect(etsDI).toStrictEqual({ bver: 0.55, coef_transparence_ets: 0.62 });
+    });
+  });
+
+  describe("Test d'intégration des ets", () => {
+    test.each(['2273E0303205P', '2364E0984413P', '2283E0131604Y'])(
+      'vérification des DI des ets pour dpe %s',
+      (ademeId) => {
+        let dpeRequest = getAdemeFileJson(ademeId);
+        dpeRequest = normalizerService.normalize(dpeRequest);
+
+        /** @type {Contexte} */
+        const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+        let ets = dpeRequest.logement.enveloppe.ets_collection?.ets || {};
+        if (ets && Array.isArray(ets)) {
+          ets = ets[0];
+        }
+
+        const di = service.execute(ctx, ets);
+        expect(di.bver).toBeCloseTo(ets.donnee_intermediaire.bver, 2);
+        expect(di.coef_transparence_ets).toBeCloseTo(
+          ets.donnee_intermediaire.coef_transparence_ets,
+          2
+        );
+      }
+    );
+  });
+});