@open3cl/engine 1.0.9 → 1.0.10

package/features/dpe/domain/models/type-habitation.model.js

@@ -6,3 +6,11 @@ export const TypeHabitation = {
   APPARTEMENT: 'APPARTEMENT',
   IMMEUBLE: 'IMMEUBLE'
 };
+/**
+ * @type {{[key: string]: string}}
+ */
+export const TypeDpe = {
+  MAISON: 'MAISON',
+  APPARTEMENT: 'APPARTEMENT',
+  IMMEUBLE: 'IMMEUBLE'
+};

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

@@ -2,6 +2,7 @@ import { tvs as tv } from '../../../tv-v2.js';
 import { getRange } from '../../../utils.js';
 import { logger } from '../../../core/util/logger/log-service.js';
 import { TvStore } from './tv.store.js';
+import enums from '../../../enums.js';
 
 /**
  * Accès aux données des tables de valeurs pour les baies vitrées
@@ -289,4 +290,73 @@ export class BaieVitreeTvStore extends TvStore {
 
     return parseFloat(fe2);
   }
+
+  /**
+   * Calcul des coefficients de réduction de température des espaces tampons
+   *
+   * @param zoneClimatique {string}
+   * @param enumCfgIsolationLncId {number}
+   * @return {number|undefined}
+   */
+  getBver(zoneClimatique, enumCfgIsolationLncId) {
+    const bver = tv['coef_reduction_deperdition'].find(
+      (v) =>
+        zoneClimatique.toLowerCase().startsWith(v.zone_climatique?.toLowerCase()) &&
+        parseInt(v.enum_cfg_isolation_lnc_id) === parseInt(enumCfgIsolationLncId)
+    )?.b;
+
+    if (!bver) {
+      logger.error(
+        `Pas de valeur b pour zoneClimatique:${zoneClimatique}, enumCfgIsolationLncId:${enumCfgIsolationLncId}`
+      );
+      return;
+    }
+
+    return parseFloat(bver);
+  }
+
+  /**
+   * Calcul des coefficients de transparence des espaces tampons
+   *
+   * @param tvCoefTransparenceEtsId {number}
+   * @return {number|undefined}
+   */
+  getCoefTransparenceEts(tvCoefTransparenceEtsId) {
+    const coefTransparence = tv['coef_transparence_ets'].find(
+      (v) => parseInt(v.tv_coef_transparence_ets_id) === parseInt(tvCoefTransparenceEtsId)
+    )?.coef_transparence_ets;
+
+    if (!coefTransparence) {
+      logger.error(
+        `Pas de valeur coef_transparence_ets pour tvCoefTransparenceEtsId:${tvCoefTransparenceEtsId}`
+      );
+      return;
+    }
+
+    return parseFloat(coefTransparence);
+  }
+
+  /**
+   * @see 18.5 - Coefficients d’orientation et d’inclinaison des parois vitrées : C1
+   *
+   * @param enumOrientationId {number}
+   * @param enumInclinaisonVitrageId {number}
+   * @param zoneClimatiqueId {number}
+   * @param mois {string}
+   *
+   * @return {number|undefined}
+   */
+  getCoefficientBaieVitree(enumOrientationId, enumInclinaisonVitrageId, zoneClimatiqueId, mois) {
+    const orientation = enums.orientation[enumOrientationId];
+    const inclinaison = enums.inclinaison_vitrage[enumInclinaisonVitrageId];
+    const zoneClimatique = enums.zone_climatique[zoneClimatiqueId];
+
+    const c1ZoneClimatique = tv['c1'][zoneClimatique][mois];
+
+    if (inclinaison === 'horizontal') {
+      return c1ZoneClimatique[inclinaison];
+    }
+
+    return c1ZoneClimatique[`${orientation} ${inclinaison}`];
+  }
 }

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

@@ -345,6 +345,112 @@ describe('Lecture des tables de valeurs', () => {
     });
   });
 
+  describe('lecture des valeurs coefficients de réduction de température des espaces tampons', () => {
+    test.each([
+      {
+        label: 'lc non isolé + espace tampon solarisé orienté nord',
+        zoneClimatique: 'H1a',
+        enumCfgIsolationLncId: '9',
+        expected: 0.85
+      },
+      {
+        label: 'lc isolé + espace tampon solarisé orienté sud',
+        zoneClimatique: 'H2C',
+        enumCfgIsolationLncId: '7',
+        expected: 0.57
+      }
+    ])(
+      `incidence masque proche pour baie vitrée $label`,
+      ({ zoneClimatique, enumCfgIsolationLncId, expected }) => {
+        expect(tvStore.getBver(zoneClimatique, enumCfgIsolationLncId)).toBe(expected);
+      }
+    );
+
+    test('pas de valeur de coefficients de réduction de température', () => {
+      const ug = tvStore.getBver('h3C', 1);
+      expect(ug).toBeUndefined();
+    });
+  });
+
+  describe('lecture des valeurs de coefficients de transparence des espaces tampons', () => {
+    test.each([
+      {
+        label: 'Parois en polycarbonate',
+        tvCoefTransparenceEtsId: '9',
+        expected: 0.39
+      },
+      {
+        label: 'Parois triple vitrage en Bois / Bois-métal',
+        tvCoefTransparenceEtsId: '5',
+        expected: 0.49
+      }
+    ])(
+      `incidence masque proche pour baie vitrée $label`,
+      ({ tvCoefTransparenceEtsId, expected }) => {
+        expect(tvStore.getCoefTransparenceEts(tvCoefTransparenceEtsId)).toBe(expected);
+      }
+    );
+
+    test('pas de valeur de coefficients de transparence', () => {
+      const ug = tvStore.getCoefTransparenceEts(0);
+      expect(ug).toBeUndefined();
+    });
+  });
+
+  describe("lecture des coefficients d'orientation et inclinaison des parois vitrées", () => {
+    test.each([
+      {
+        label: 'Baie vitrée orientée nord, inclinaison inf25°',
+        enumOrientationId: '2',
+        enumInclinaisonVitrageId: '1',
+        zoneClimatiqueId: '1',
+        mois: 'Janvier',
+        expected: 0.52
+      },
+      {
+        label: 'Baie vitrée orientée nord, inclinaison inf25°',
+        enumOrientationId: '2',
+        enumInclinaisonVitrageId: '1',
+        zoneClimatiqueId: '1',
+        mois: 'Juillet',
+        expected: 1.98
+      },
+      {
+        label: 'Baie vitrée orientée sud, inclinaison sup75°',
+        enumOrientationId: '1',
+        enumInclinaisonVitrageId: '3',
+        zoneClimatiqueId: '2',
+        mois: 'Janvier',
+        expected: 1
+      },
+      {
+        label: 'Baie vitrée orientée sud, inclinaison horizontale',
+        enumOrientationId: '1',
+        enumInclinaisonVitrageId: '4',
+        zoneClimatiqueId: '2',
+        mois: 'Janvier',
+        expected: 0.58
+      }
+    ])(
+      `coefficient pour $label`,
+      ({ enumOrientationId, enumInclinaisonVitrageId, zoneClimatiqueId, mois, expected }) => {
+        expect(
+          tvStore.getCoefficientBaieVitree(
+            enumOrientationId,
+            enumInclinaisonVitrageId,
+            zoneClimatiqueId,
+            mois
+          )
+        ).toMatchObject(expected);
+      }
+    );
+  });
+
+  test('lecture des épaisseurs disponibles pour les coefficients de transmission thermique ug', () => {
+    const ug = tvStore.getEpaisseurAvailableForUg();
+    expect(ug).toStrictEqual([0, 6, 8, 10, 12, 14, 15, 16, 18, 20]);
+  });
+
   test('lecture des épaisseurs disponibles pour les coefficients de transmission thermique ug', () => {
     const ug = tvStore.getEpaisseurAvailableForUg();
     expect(ug).toStrictEqual([0, 6, 8, 10, 12, 14, 15, 16, 18, 20]);

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

@@ -2,12 +2,19 @@ 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}
    */
@@ -15,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;
   }
 
@@ -55,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

@@ -6,6 +6,7 @@ import { DeperditionPlancherHautService } from './plancher_haut/deperdition-plan
 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
@@ -37,6 +38,11 @@ export class DeperditionEnveloppeService {
    */
   #deperditionBaieVitreeService;
 
+  /**
+   * @type {EspaceTamponService}
+   */
+  #espaceTamponService;
+
   /**
    * @type {DeperditionPontThermiqueService}
    */
@@ -79,6 +85,7 @@ export class DeperditionEnveloppeService {
    * @param deperditionPlancherBasService {DeperditionPlancherBasService}
    * @param deperditionPlancherHautService {DeperditionPlancherHautService}
    * @param deperditionBaieVitreeService {DeperditionBaieVitreeService}
+   * @param espaceTamponService {EspaceTamponService}
    * @param deperditionPontThermiqueService {DeperditionPontThermiqueService}
    * @param deperditionVentilationService {DeperditionVentilationService}
    */
@@ -88,6 +95,7 @@ export class DeperditionEnveloppeService {
     deperditionPlancherBasService = inject(DeperditionPlancherBasService),
     deperditionPlancherHautService = inject(DeperditionPlancherHautService),
     deperditionBaieVitreeService = inject(DeperditionBaieVitreeService),
+    espaceTamponService = inject(EspaceTamponService),
     deperditionPontThermiqueService = inject(DeperditionPontThermiqueService),
     deperditionVentilationService = inject(DeperditionVentilationService)
   ) {
@@ -96,6 +104,7 @@ export class DeperditionEnveloppeService {
     this.#deperditionPlancherBasService = deperditionPlancherBasService;
     this.#deperditionPlancherHautService = deperditionPlancherHautService;
     this.#deperditionBaieVitreeService = deperditionBaieVitreeService;
+    this.#espaceTamponService = espaceTamponService;
     this.#deperditionPontThermiqueService = deperditionPontThermiqueService;
     this.#deperditionVentilationService = deperditionVentilationService;
     this.#surfaceDeperditive = 0;
@@ -249,6 +258,16 @@ 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,