@open3cl/engine 1.0.10 → 1.0.11

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

@@ -1,11 +1,23 @@
 import { TypeDpe, TypeHabitation } from '../../dpe/domain/models/type-habitation.model.js';
 import enums from '../../../enums.js';
+import { NadeqService } from './logement/nadeq.service.js';
+import { inject } from 'dioma';
 
 /**
  * Génère un contexte du logement à étudier avec des données persistées durant l'analyse
  */
 export class ContexteBuilder {
-  constructor() {}
+  /**
+   * @type {NadeqService}
+   */
+  #nadeqService;
+
+  /**
+   * @param nadeqService {NadeqService}
+   */
+  constructor(nadeqService = inject(NadeqService)) {
+    this.#nadeqService = nadeqService;
+  }
 
   /**
    * @param dpe {Dpe}
@@ -14,22 +26,40 @@ export class ContexteBuilder {
   fromDpe(dpe) {
     const caracteristiqueGenerale = dpe.logement.caracteristique_generale;
 
+    const typeDpe = this.#getTypeDpe(caracteristiqueGenerale);
+    const surfaceHabitable = this.#getSurfaceHabitable(caracteristiqueGenerale);
+    const inertieId = parseInt(dpe.logement.enveloppe?.inertie?.enum_classe_inertie_id);
+
     return {
       zoneClimatique: this.#zoneClimatique(dpe),
+      altitude: this.#altitude(dpe),
       typeHabitation: this.#getTypeHabitation(caracteristiqueGenerale),
-      typeDpe: this.#getTypeDpe(caracteristiqueGenerale),
+      typeDpe: typeDpe,
       enumPeriodeConstructionId: caracteristiqueGenerale.enum_periode_construction_id?.toString(),
       effetJoule: this.#hasEffetJoule(dpe),
-      surfaceHabitable: this.#getSurfaceHabitable(caracteristiqueGenerale),
+      surfaceHabitable: surfaceHabitable,
       hauteurSousPlafond: caracteristiqueGenerale.hsp,
-      nombreAppartement: caracteristiqueGenerale.nombre_appartement
+      nombreAppartement: caracteristiqueGenerale.nombre_appartement,
+      nadeq: this.#nadeqService.execute(
+        typeDpe,
+        surfaceHabitable,
+        caracteristiqueGenerale.nombre_appartement
+      ),
+      inertie: {
+        id: inertieId,
+        ilpa:
+          parseInt(dpe.logement.meteo?.batiment_materiaux_anciens) === 1 &&
+          [1, 2].includes(inertieId)
+            ? 1
+            : 0
+      }
     };
   }
 
   /**
    * La zone climatique à partir du type de DPE
    * @param dpe {Dpe}
-   * @return {{id: number, value: string}}
+   * @return {{id: string, value: string}}
    */
   #zoneClimatique(dpe) {
     const zoneClimatiqueId = parseInt(dpe.logement.meteo?.enum_zone_climatique_id);
@@ -39,6 +69,19 @@ export class ContexteBuilder {
     };
   }
 
+  /**
+   * La classe d'altitude à partir du type de DPE
+   * @param dpe {Dpe}
+   * @return {{id: string, value: string}}
+   */
+  #altitude(dpe) {
+    const altitudeId = parseInt(dpe.logement.meteo?.enum_classe_altitude_id);
+    return {
+      id: altitudeId.toString(),
+      value: enums.classe_altitude[altitudeId]
+    };
+  }
+
   /**
    * Si un générateur de chauffage par résistance électrique existe, alors effet joule vaut vrai
    * @param dpe {Dpe}

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

@@ -1,13 +1,18 @@
 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', () => {
@@ -79,11 +84,26 @@ describe('Generateur du contexte du calcul', () => {
     });
   });
 
+  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_zone_climatique_id: 1,
+          enum_classe_altitude_id: 2
         },
         caracteristique_generale: {
           enum_periode_construction_id: 4,
@@ -106,11 +126,16 @@ describe('Generateur du contexte du calcul', () => {
       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,
       typeHabitation: TypeHabitation.APPARTEMENT,
@@ -118,6 +143,10 @@ describe('Generateur du contexte du calcul', () => {
       zoneClimatique: {
         id: '4',
         value: 'h2a'
+      },
+      altitude: {
+        id: '3',
+        value: 'supérieur à 800m'
       }
     });
 
@@ -128,4 +157,31 @@ describe('Generateur du contexte du calcul', () => {
       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,7 +2,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';
-import { SurfaceSudEquivalenteService } from './logement/surface-sud-equivalente.service.js';
+import { ApportEtBesoinService } from './apport_et_besoin/apport-et-besoin.service.js';
 
 export class EngineService {
   /**
@@ -11,9 +11,9 @@ export class EngineService {
   #deperditionService;
 
   /**
-   * @type {SurfaceSudEquivalenteService}
+   * @type {ApportEtBesoinService}
    */
-  #surfaceSudEquivalenteService;
+  #apportEtBesoinService;
 
   /**
    * @type {ContexteBuilder}
@@ -22,16 +22,16 @@ export class EngineService {
 
   /**
    * @param deperditionService {DeperditionEnveloppeService}
-   * @param surfaceSudEquivalenteService {SurfaceSudEquivalenteService}
+   * @param apportEtBesoinService {ApportEtBesoinService}
    * @param contextBuilder {ContexteBuilder}
    */
   constructor(
     deperditionService = inject(DeperditionEnveloppeService),
-    surfaceSudEquivalenteService = inject(SurfaceSudEquivalenteService),
+    apportEtBesoinService = inject(ApportEtBesoinService),
     contextBuilder = inject(ContexteBuilder)
   ) {
     this.#deperditionService = deperditionService;
-    this.#surfaceSudEquivalenteService = surfaceSudEquivalenteService;
+    this.#apportEtBesoinService = apportEtBesoinService;
     this.#contextBuilder = contextBuilder;
   }
 
@@ -68,12 +68,10 @@ export class EngineService {
       proceededDpe.logement
     );
 
-    proceededDpe.logement.sortie.apport_et_besoin = {
-      surface_sud_equivalente: this.#surfaceSudEquivalenteService.execute(
-        ctx,
-        proceededDpe.logement.enveloppe
-      )
-    };
+    proceededDpe.logement.sortie.apport_et_besoin = this.#apportEtBesoinService.execute(
+      ctx,
+      proceededDpe.logement
+    );
 
     // Calcul des déperditions par renouvellement de l'air
 
@@ -114,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

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/espace_tampon/espace-tampon.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

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

@@ -1,7 +1,7 @@
 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 { BaieVitreeTvStore } from '../../../../dpe/infrastructure/enveloppe/baieVitreeTv.store.js';
 import { EspaceTamponService } from './espace-tampon.service.js';
 import { getAdemeFileJson } from '../../../../../../test/test-helpers.js';
 

package/features/engine/domain/enveloppe/pont_thermique/deperdition-pont-thermique.service.js

@@ -3,7 +3,7 @@ import { DeperditionService } from '../deperdition.service.js';
 import { logger } from '../../../../../core/util/logger/log-service.js';
 import { compareReferences } from '../../../../../utils.js';
 import { DeperditionMurService } from '../mur/deperdition-mur.service.js';
-import { PontThermiqueTvStore } from '../../../../dpe/infrastructure/pontThermiqueTv.store.js';
+import { PontThermiqueTvStore } from '../../../../dpe/infrastructure/enveloppe/pontThermiqueTv.store.js';
 import enums from '../../../../../enums.js';
 import { DeperditionPlancherHautService } from '../plancher_haut/deperdition-plancher-haut.service.js';
 import { DeperditionPlancherBasService } from '../plancher_bas/deperdition-plancher-bas.service.js';

package/features/engine/domain/enveloppe/pont_thermique/deperdition-pont-thermique.service.spec.js

@@ -4,7 +4,7 @@ import { ContexteBuilder } from '../../contexte.builder.js';
 import { DpeNormalizerService } from '../../../../normalizer/domain/dpe-normalizer.service.js';
 import { beforeEach, describe, expect, test, vi } from 'vitest';
 import { DeperditionPontThermiqueService } from './deperdition-pont-thermique.service.js';
-import { PontThermiqueTvStore } from '../../../../dpe/infrastructure/pontThermiqueTv.store.js';
+import { PontThermiqueTvStore } from '../../../../dpe/infrastructure/enveloppe/pontThermiqueTv.store.js';
 import { DeperditionMurService } from '../mur/deperdition-mur.service.js';
 import { DeperditionPlancherHautService } from '../plancher_haut/deperdition-plancher-haut.service.js';
 import { DeperditionPlancherBasService } from '../plancher_bas/deperdition-plancher-bas.service.js';

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

@@ -10,18 +10,19 @@ import { TypeDpe } from '../../../dpe/domain/models/type-habitation.model.js';
  */
 export class NadeqService {
   /**
-   * @param ctx {Contexte}
-   * @param bv {BaieVitree}
+   * @param typeDpe {TypeDpe}
+   * @param surfaceHabitable {number}
+   * @param nombreAppartement {number}
    * @return {number}
    */
-  execute(ctx) {
-    if (ctx.typeDpe === TypeDpe.MAISON) {
-      return this.#calculateIndividualNadeq(ctx.surfaceHabitable);
+  execute(typeDpe, surfaceHabitable, nombreAppartement) {
+    if (typeDpe === TypeDpe.MAISON) {
+      return this.#calculateIndividualNadeq(surfaceHabitable);
     }
 
     return this.#calculateCollectiveNadeq(
-      ctx.surfaceHabitable,
-      ctx.typeDpe === TypeDpe.APPARTEMENT ? 1 : ctx.nombreAppartement
+      surfaceHabitable,
+      typeDpe === TypeDpe.APPARTEMENT ? 1 : nombreAppartement
     );
   }
 

package/features/engine/domain/logement/nadeq.service.spec.js

@@ -18,11 +18,7 @@ describe('Nadeq unit tests', () => {
   ])(
     `Typologie MAISON : Nombre d'adultes équivalent $expectedNadeq pour une surface de logement $surfaceHabitable`,
     ({ expectedNadeq, surfaceHabitable }) => {
-      const ctx = {
-        surfaceHabitable: surfaceHabitable,
-        typeDpe: TypeDpe.MAISON
-      };
-      expect(service.execute(ctx)).toBe(expectedNadeq);
+      expect(service.execute(TypeDpe.MAISON, surfaceHabitable)).toBe(expectedNadeq);
     }
   );
 
@@ -36,11 +32,7 @@ describe('Nadeq unit tests', () => {
   ])(
     `Typologie APPARTEMENT : Nombre d'adultes équivalent $expectedNadeq pour une surface de logement $surfaceHabitable`,
     ({ expectedNadeq, surfaceHabitable }) => {
-      const ctx = {
-        surfaceHabitable: surfaceHabitable,
-        typeDpe: TypeDpe.APPARTEMENT
-      };
-      expect(service.execute(ctx)).toBeCloseTo(expectedNadeq, 2);
+      expect(service.execute(TypeDpe.APPARTEMENT, surfaceHabitable)).toBeCloseTo(expectedNadeq, 2);
     }
   );
 
@@ -60,12 +52,10 @@ describe('Nadeq unit tests', () => {
   ])(
     `Typologie IMMEUBLE : Nombre d'adultes équivalent $expectedNadeq pour une surface de logement $surfaceHabitable et un nombre d'apartement $nombreAppartement`,
     ({ expectedNadeq, surfaceHabitable, nombreAppartement }) => {
-      const ctx = {
-        surfaceHabitable: surfaceHabitable,
-        nombreAppartement: nombreAppartement,
-        typeDpe: TypeDpe.IMMEUBLE
-      };
-      expect(service.execute(ctx)).toBeCloseTo(expectedNadeq, 2);
+      expect(service.execute(TypeDpe.IMMEUBLE, surfaceHabitable, nombreAppartement)).toBeCloseTo(
+        expectedNadeq,
+        2
+      );
     }
   );
 });

package/features/engine/domain/models/contexte.model.ts

@@ -11,5 +11,14 @@ export interface Contexte {
     id: string;
     value: string;
   };
+  altitude: {
+    id: string;
+    value: string;
+  };
   effetJoule: boolean;
+  nadeq: number;
+  inertie: {
+    id: number;
+    ilpa: number;
+  };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open3cl/engine",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {