@open3cl/engine 1.0.9 → 1.0.11

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

@@ -1,24 +1,24 @@
 import { ContexteBuilder } from './contexte.builder.js';
-import { beforeEach, describe, expect, test } from 'vitest';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { TypeDpe, TypeHabitation } from '../../dpe/domain/models/type-habitation.model.js';
+import { NadeqService } from './logement/nadeq.service.js';
+
+/** @type {NadeqService} **/
+let nadeqService;
 
 /** @type {ContexteBuilder} **/
 let contexteBuilder;
 
 describe('Generateur du contexte du calcul', () => {
   beforeEach(() => {
-    contexteBuilder = new ContexteBuilder();
+    nadeqService = new NadeqService();
+    contexteBuilder = new ContexteBuilder(nadeqService);
   });
 
   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 +31,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 +54,134 @@ 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('Contexte avec calcul du nadeq', () => {
+    vi.spyOn(nadeqService, 'execute').mockReturnValue(1.58);
+    const dpe = {
+      logement: {
+        caracteristique_generale: {},
+        installation_chauffage_collection: {}
+      }
+    };
+
+    expect(contexteBuilder.fromDpe(dpe)).toMatchObject({
+      nadeq: 1.58
+    });
+  });
+
+  test('Récupération des informations du logement concerné par le DPE', () => {
     let dpe = {
       logement: {
+        meteo: {
+          enum_zone_climatique_id: 1,
+          enum_classe_altitude_id: 2
+        },
         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'
+      },
+      altitude: {
+        id: '2',
+        value: '400-800m'
+      }
     });
 
     dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id = '5';
+    dpe.logement.meteo.enum_zone_climatique_id = '4';
+    dpe.logement.meteo.enum_classe_altitude_id = '3';
     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'
+      },
+      altitude: {
+        id: '3',
+        value: 'supérieur à 800m'
+      }
     });
 
     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
     });
   });
+
+  test('Contexte avec calcul ilpa', () => {
+    const dpe = {
+      logement: {
+        caracteristique_generale: {},
+        meteo: {
+          batiment_materiaux_anciens: 0
+        },
+        enveloppe: {
+          inertie: {
+            enum_classe_inertie_id: 4
+          }
+        }
+      }
+    };
+
+    expect(contexteBuilder.fromDpe(dpe)).toMatchObject({ inertie: { id: 4, ilpa: 0 } });
+
+    dpe.logement.enveloppe.inertie.enum_classe_inertie_id = 1;
+    expect(contexteBuilder.fromDpe(dpe)).toMatchObject({ inertie: { id: 1, ilpa: 0 } });
+
+    dpe.logement.meteo.batiment_materiaux_anciens = 1;
+    expect(contexteBuilder.fromDpe(dpe)).toMatchObject({ inertie: { id: 1, ilpa: 1 } });
+
+    dpe.logement.enveloppe.inertie.enum_classe_inertie_id = 2;
+    expect(contexteBuilder.fromDpe(dpe)).toMatchObject({ inertie: { id: 2, ilpa: 1 } });
+  });
 });

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 { ApportEtBesoinService } from './apport_et_besoin/apport-et-besoin.service.js';
 
 export class EngineService {
   /**
    * @type {DeperditionEnveloppeService}
    */
   #deperditionService;
+
+  /**
+   * @type {ApportEtBesoinService}
+   */
+  #apportEtBesoinService;
+
   /**
    * @type {ContexteBuilder}
    */
@@ -15,13 +22,16 @@ export class EngineService {
 
   /**
    * @param deperditionService {DeperditionEnveloppeService}
+   * @param apportEtBesoinService {ApportEtBesoinService}
    * @param contextBuilder {ContexteBuilder}
    */
   constructor(
     deperditionService = inject(DeperditionEnveloppeService),
+    apportEtBesoinService = inject(ApportEtBesoinService),
     contextBuilder = inject(ContexteBuilder)
   ) {
     this.#deperditionService = deperditionService;
+    this.#apportEtBesoinService = apportEtBesoinService;
     this.#contextBuilder = contextBuilder;
   }
 
@@ -55,7 +65,12 @@ 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 = this.#apportEtBesoinService.execute(
+      ctx,
+      proceededDpe.logement
     );
 
     // Calcul des déperditions par renouvellement de l'air
@@ -97,7 +112,6 @@ export class EngineService {
    */
   #removeComputedData(dpe) {
     delete dpe.logement.sortie;
-    delete dpe.logement.enveloppe.inertie;
 
     dpe.logement.enveloppe.mur_collection.mur?.map((m) => delete m.donnee_intermediaire);
     dpe.logement.enveloppe.baie_vitree_collection.baie_vitree?.map((m) => {

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

@@ -1,6 +1,6 @@
 import { DeperditionService } from '../deperdition.service.js';
 import { inject } from 'dioma';
-import { BaieVitreeTvStore } from '../../../../dpe/infrastructure/baieVitreeTv.store.js';
+import { BaieVitreeTvStore } from '../../../../dpe/infrastructure/enveloppe/baieVitreeTv.store.js';
 
 /**
  * Calcul des déperditions des baies vitrées
@@ -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/baie_vitree/deperdition-baie-vitree.service.spec.js

@@ -4,7 +4,7 @@ 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';
+import { BaieVitreeTvStore } from '../../../../dpe/infrastructure/enveloppe/baieVitreeTv.store.js';
 
 /** @type {DeperditionBaieVitreeService} **/
 let service;

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,

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/enveloppe/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/enveloppe/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
+        );
+      }
+    );
+  });
+});

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

@@ -34,7 +34,7 @@ export class DeperditionMurService extends DeperditionService {
       surfaceAue: murDE.surface_aue,
       enumCfgIsolationLncId: murDE.enum_cfg_isolation_lnc_id,
       tvCoefReductionDeperditionId: murDE.tv_coef_reduction_deperdition_id,
-      zoneClimatiqueId: ctx.zoneClimatiqueId
+      zoneClimatique: ctx.zoneClimatique.value
     });
 
     /** @type {MurDI} */
@@ -65,14 +65,14 @@ export class DeperditionMurService extends DeperditionService {
       case '2': // isolation inconnue (table forfaitaire)
         umur = Math.min(
           umurNu,
-          this.tvStore.getUmur(ctx.enumPeriodeConstructionId, ctx.zoneClimatiqueId, ctx.effetJoule)
+          this.tvStore.getUmur(ctx.enumPeriodeConstructionId, ctx.zoneClimatique.id, ctx.effetJoule)
         );
         break;
       case '7': // année d'isolation différente de l'année de construction
       case '8': // année de construction saisie
         umur = Math.min(
           umurNu,
-          this.tvStore.getUmur(enumPeriodeIsolationId, ctx.zoneClimatiqueId, ctx.effetJoule)
+          this.tvStore.getUmur(enumPeriodeIsolationId, ctx.zoneClimatique.id, ctx.effetJoule)
         );
         break;
       case '3': // epaisseur isolation saisie justifiée par mesure ou observation