@open3cl/engine 1.0.10 → 1.0.12

package/features/engine/domain/apport_et_besoin/froid/besoin-froid.service.js

@@ -0,0 +1,131 @@
+import { mois_liste } from '../../../../../utils.js';
+import { inject } from 'dioma';
+import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
+import { ApportGratuitService } from '../apport_gratuit/apport-gratuit.service.js';
+
+/**
+ * Calcul du besoin en froid
+ * Chapitre 10.2 Calcul du besoin mensuel de froid
+ *
+ * Methode_de_calcul_3CL_DPE_2021 - Page 68
+ * Octobre 2021
+ * @see consolide_anne…arrete_du_31_03_2021_relatif_aux_methodes_et_procedures_applicables.pdf
+ */
+export class BesoinFroidService {
+  /**
+   * @type {ApportGratuitService}
+   */
+  #apportGratuitService;
+
+  /**
+   * @type {FrTvStore}
+   */
+  #tvStore;
+
+  /**
+   * @param tvStore {FrTvStore}
+   * @param apportGratuitService {ApportGratuitService}
+   */
+  constructor(tvStore = inject(FrTvStore), apportGratuitService = inject(ApportGratuitService)) {
+    this.#tvStore = tvStore;
+    this.#apportGratuitService = apportGratuitService;
+  }
+
+  /**
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @return {{besoin_fr: number, besoin_fr_depensier: number}}
+   */
+  execute(ctx, logement) {
+    const clim = logement.climatisation_collection?.climatisation || [];
+    if (clim.length === 0) {
+      return { besoin_fr: 0, besoin_fr_depensier: 0 };
+    }
+
+    return mois_liste.reduce(
+      (acc, mois) => {
+        acc.besoin_fr += this.besoinFrMois(ctx, logement, mois, false);
+        acc.besoin_fr_depensier += this.besoinFrMois(ctx, logement, mois, true);
+        return acc;
+      },
+      { besoin_fr: 0, besoin_fr_depensier: 0 }
+    );
+  }
+
+  /**
+   * Calcul du besoin en froid pour un mois donné
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @param mois {string}
+   * @param depensier {boolean}
+   * @returns {number}
+   */
+  besoinFrMois(ctx, logement, mois, depensier) {
+    const nref = this.#tvStore.getData(
+      depensier ? 'nref26' : 'nref28',
+      ctx.altitude.value,
+      ctx.zoneClimatique.value,
+      mois
+    );
+    if (nref === 0) return 0;
+
+    const eFr = this.#tvStore.getData(
+      depensier ? 'e_fr_26' : 'e_fr_28',
+      ctx.altitude.value,
+      ctx.zoneClimatique.value,
+      mois
+    );
+
+    // Température extérieure moyenne sur le mois j pendant les périodes de climatisation (°C)
+    const tempExtMoyClim = this.#tvStore.getData(
+      depensier ? 'textmoy_clim_26' : 'textmoy_clim_28',
+      ctx.altitude.value,
+      ctx.zoneClimatique.value,
+      mois
+    );
+
+    // Température de consigne en froid (°C)
+    const temperatureInterieure = depensier ? 26 : 28;
+
+    const aijFr = this.#apportGratuitService.apportInterneMois(ctx, nref);
+    const asjFr = this.#apportGratuitService.apportSolaireMois(ctx, logement.enveloppe, mois, eFr);
+
+    // Transfert thermique à travers l’enveloppe et le renouvellement d’air (W/K). Le GV prend en compte les
+    // échanges de chaleur par le renouvellement d‘air. Ces échanges sont calculés sur la période de refroidissement
+    // de la même façon que pour la période de chauffage
+    const GV = logement.sortie?.deperdition?.deperdition_enveloppe;
+
+    // Ratio de bilan thermique
+    const Rbth = (aijFr + asjFr) / (GV * (tempExtMoyClim - temperatureInterieure) * nref);
+
+    if (Rbth < 1 / 2) return 0;
+
+    // Constante de temps de la zone pour le refroidissement
+    const t = (this.#cin(ctx.inertie.id) * ctx.surfaceHabitable) / (3600 * GV);
+    const a = 1 + t / 15;
+
+    // Facteur d'utilisation des apports sur le mois
+    let fut = Rbth === 1 ? a / (a + 1) : (1 - Rbth ** -a) / (1 - Rbth ** (-a - 1));
+    return (
+      (aijFr + asjFr) / 1000 - ((fut * GV) / 1000) * (temperatureInterieure - tempExtMoyClim) * nref
+    );
+  }
+
+  /**
+   * Capacité thermique intérieure efficace de la zone (J/K)
+   * @param inertie
+   * @returns {number}
+   */
+  #cin(inertie) {
+    switch (inertie) {
+      case 1:
+      case 2:
+        return 260000;
+      case 3:
+        return 165000;
+      case 4:
+        return 110000;
+    }
+  }
+}

package/features/engine/domain/apport_et_besoin/froid/besoin-froid.service.spec.js

@@ -0,0 +1,229 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { DpeNormalizerService } from '../../../../normalizer/domain/dpe-normalizer.service.js';
+import { ContexteBuilder } from '../../contexte.builder.js';
+import corpus from '../../../../../../test/corpus-sano.json';
+import { getAdemeFileJson } from '../../../../../../test/test-helpers.js';
+import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
+import { ApportGratuitService } from '../apport_gratuit/apport-gratuit.service.js';
+import { BesoinFroidService } from './besoin-froid.service.js';
+
+/** @type {ApportGratuitService} **/
+let apportGratuitService;
+
+/** @type {BesoinFroidService} **/
+let service;
+
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
+/** @type {FrTvStore} **/
+let tvStore;
+
+describe('Calcul des besoins en froid du logement', () => {
+  beforeEach(() => {
+    tvStore = new FrTvStore();
+    apportGratuitService = new ApportGratuitService();
+    service = new BesoinFroidService(tvStore, apportGratuitService);
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
+  });
+
+  test('Besoins en froid à 0 si aucune climatisation dans le logement', () => {
+    vi.spyOn(tvStore, 'getData').mockReturnValue(10);
+
+    /** @type {Contexte} */
+    const ctx = { zoneClimatique: { id: 1 } };
+    expect(service.execute(ctx, {})).toStrictEqual({ besoin_fr: 0, besoin_fr_depensier: 0 });
+    expect(service.execute(ctx, { enveloppe: {} })).toStrictEqual({
+      besoin_fr: 0,
+      besoin_fr_depensier: 0
+    });
+    expect(service.execute(ctx, { climatisation_collection: {} })).toStrictEqual({
+      besoin_fr: 0,
+      besoin_fr_depensier: 0
+    });
+    expect(service.execute(ctx, { climatisation_collection: { climatisation: [] } })).toStrictEqual(
+      { besoin_fr: 0, besoin_fr_depensier: 0 }
+    );
+
+    expect(tvStore.getData).not.toHaveBeenCalled();
+  });
+
+  describe('Determination du besoin en froid pour un mois donné', () => {
+    test.each([
+      {
+        data: 0,
+        aijFr: 1,
+        asjFr: 0.2,
+        inertie: 4,
+        depensier: false,
+        expected: 0
+      },
+      {
+        data: 0,
+        aijFr: 1,
+        asjFr: 0.2,
+        inertie: 4,
+        depensier: true,
+        expected: 0
+      },
+      {
+        data: 58,
+        aijFr: 1,
+        asjFr: 0.2,
+        inertie: 4,
+        depensier: false,
+        expected: 0
+      },
+      {
+        data: 58,
+        aijFr: 1,
+        asjFr: 0.2,
+        inertie: 4,
+        depensier: true,
+        expected: 0
+      },
+      {
+        data: 30,
+        aijFr: 1000,
+        asjFr: 2580,
+        inertie: 4,
+        depensier: false,
+        expected: 6.25
+      },
+      {
+        data: 30,
+        aijFr: 1000,
+        asjFr: 2580,
+        inertie: 4,
+        depensier: true,
+        expected: 0
+      },
+      {
+        data: 30,
+        aijFr: 1500,
+        asjFr: 5580,
+        inertie: 4,
+        depensier: true,
+        expected: 12.38
+      },
+      {
+        data: 30,
+        aijFr: 10000,
+        asjFr: 2000,
+        inertie: 4,
+        depensier: false,
+        expected: 16.72
+      },
+      {
+        data: 30,
+        aijFr: 10000,
+        asjFr: 2000,
+        inertie: 1,
+        depensier: true,
+        expected: 20.25
+      },
+      {
+        data: 30,
+        aijFr: 10000,
+        asjFr: 2000,
+        inertie: 2,
+        depensier: true,
+        expected: 20.25
+      },
+      {
+        data: 30,
+        aijFr: 10000,
+        asjFr: 2000,
+        inertie: 3,
+        depensier: true,
+        expected: 19.66
+      },
+      {
+        data: 30,
+        aijFr: 10000,
+        asjFr: 2000,
+        inertie: 4,
+        depensier: true,
+        expected: 19.22
+      }
+    ])(
+      'nref: $data, eFr: $data, tempExtMoyClim: $data, aijFr: $aijFr, asjFr: $asjFr,' +
+        'inertie: $inertie, depensier: $depensier',
+      ({ data, aijFr, asjFr, inertie, depensier, expected }) => {
+        vi.spyOn(tvStore, 'getData').mockReturnValue(data);
+        vi.spyOn(apportGratuitService, 'apportInterneMois').mockReturnValue(aijFr);
+        vi.spyOn(apportGratuitService, 'apportSolaireMois').mockReturnValue(asjFr);
+
+        /** @type {Logement} **/
+        const logement = {
+          enveloppe: {},
+          sortie: { deperdition: { deperdition_enveloppe: 100 } }
+        };
+
+        /** @type {Contexte} */
+        const ctx = {
+          altitude: { value: '400-800m' },
+          zoneClimatique: { value: 'h1a' },
+          inertie: { id: inertie },
+          surfaceHabitable: 25
+        };
+
+        const ssd = service.besoinFrMois(ctx, logement, 'Janvier', depensier);
+
+        expect(tvStore.getData).toHaveBeenCalledWith(
+          depensier ? 'nref26' : 'nref28',
+          '400-800m',
+          'h1a',
+          'Janvier'
+        );
+        if (data > 0) {
+          expect(tvStore.getData).toHaveBeenCalledWith(
+            depensier ? 'e_fr_26' : 'e_fr_28',
+            '400-800m',
+            'h1a',
+            'Janvier'
+          );
+          expect(tvStore.getData).toHaveBeenCalledWith(
+            depensier ? 'textmoy_clim_26' : 'textmoy_clim_28',
+            '400-800m',
+            'h1a',
+            'Janvier'
+          );
+          expect(apportGratuitService.apportInterneMois).toHaveBeenCalledWith(ctx, data);
+          expect(apportGratuitService.apportSolaireMois).toHaveBeenCalledWith(
+            ctx,
+            {},
+            'Janvier',
+            data
+          );
+        }
+
+        expect(ssd).toBeCloseTo(expected, 2);
+      }
+    );
+  });
+
+  describe("Test d'intégration pour le besoin en froid", () => {
+    test.each(corpus)('vérification des sorties besoin_fr pour dpe %s', (ademeId) => {
+      /**
+       * @type {Dpe}
+       */
+      let dpeRequest = getAdemeFileJson(ademeId);
+      dpeRequest = normalizerService.normalize(dpeRequest);
+
+      /** @type {Contexte} */
+      const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+      const ecs = service.execute(ctx, dpeRequest.logement);
+      expect(ecs.besoin_fr).toBeCloseTo(dpeRequest.logement.sortie.apport_et_besoin.besoin_fr, 2);
+      expect(ecs.besoin_fr_depensier).toBeCloseTo(
+        dpeRequest.logement.sortie.apport_et_besoin.besoin_fr_depensier,
+        2
+      );
+    });
+  });
+});

package/features/engine/domain/{logement → apport_et_besoin}/surface-sud-equivalente.service.js

@@ -1,9 +1,9 @@
 import { mois_liste } from '../../../../utils.js';
 import { inject } from 'dioma';
-import { BaieVitreeTvStore } from '../../../dpe/infrastructure/baieVitreeTv.store.js';
+import { BaieVitreeTvStore } from '../../../dpe/infrastructure/enveloppe/baieVitreeTv.store.js';
 
 /**
- * Calcul e la surface sud équivalente du logement
+ * Calcul de la surface sud équivalente du logement
  * Chapitre 6.2 Détermination de la surface Sud équivalente
  *
  * Methode_de_calcul_3CL_DPE_2021 - Page 45
@@ -29,22 +29,21 @@ export class SurfaceSudEquivalenteService {
    * @return {number}
    */
   execute(ctx, enveloppe) {
-    const baiesVitrees = enveloppe.baie_vitree_collection?.baie_vitree || [];
-    const ets = enveloppe.ets_collection?.ets || [];
-
-    return mois_liste.reduce((acc, mois) => acc + this.ssdMois(ctx, baiesVitrees, ets, mois), 0);
+    return mois_liste.reduce((acc, mois) => acc + this.ssdMois(ctx, enveloppe, mois), 0);
   }
 
   /**
-   * Calcul de la surface sud du logement pour un mois donné
+   * Calcul de la surface sud équivalente du logement pour un mois donné
    *
    * @param ctx {Contexte}
-   * @param baiesVitrees {BaieVitree[]}
-   * @param ets {Ets}
+   * @param enveloppe {Enveloppe}
    * @param mois {string}
    * @returns {number}
    */
-  ssdMois(ctx, baiesVitrees, ets, mois) {
+  ssdMois(ctx, enveloppe, mois) {
+    const baiesVitrees = enveloppe.baie_vitree_collection?.baie_vitree || [];
+    let ets = enveloppe.ets_collection?.ets || [];
+
     let SseVerandaj = 0;
 
     /**

package/features/engine/domain/{logement → apport_et_besoin}/surface-sud-equivalente.service.spec.js

@@ -4,7 +4,7 @@ import { DpeNormalizerService } from '../../../normalizer/domain/dpe-normalizer.
 import { ContexteBuilder } from '../contexte.builder.js';
 import { SurfaceSudEquivalenteService } from './surface-sud-equivalente.service.js';
 import { getAdemeFileJson } from '../../../../../test/test-helpers.js';
-import { BaieVitreeTvStore } from '../../../dpe/infrastructure/baieVitreeTv.store.js';
+import { BaieVitreeTvStore } from '../../../dpe/infrastructure/enveloppe/baieVitreeTv.store.js';
 
 /** @type {SurfaceSudEquivalenteService} **/
 let service;
@@ -18,7 +18,7 @@ let contexteBuilder;
 /** @type {BaieVitreeTvStore} **/
 let tvStore;
 
-describe('Calcul de déperdition des portes', () => {
+describe('Calcul de la surface sud équivalente du logement', () => {
   beforeEach(() => {
     tvStore = new BaieVitreeTvStore();
     service = new SurfaceSudEquivalenteService(tvStore);
@@ -118,12 +118,17 @@ describe('Calcul de déperdition des portes', () => {
     test("Aucune pour les baies vitrées qui ne donnent pas sur l'extérieur", () => {
       expect(service.execute({}, [])).toBe(0);
 
-      const baiesVitrees = [
-        {
-          donnee_entree: { enum_type_adjacence_id: 18 }
+      /** @type {Enveloppe} */
+      const enveloppe = {
+        baie_vitree_collection: {
+          baie_vitree: [
+            {
+              donnee_entree: { enum_type_adjacence_id: 18 }
+            }
+          ]
         }
-      ];
-      expect(service.ssdMois({}, baiesVitrees, [], 'Janvier')).toBe(0);
+      };
+      expect(service.ssdMois({}, enveloppe, 'Janvier')).toBe(0);
     });
 
     test("Baies vitrées donnant sur l'extérieur", () => {
@@ -131,17 +136,23 @@ describe('Calcul de déperdition des portes', () => {
 
       /** @type {Contexte} */
       const ctx = { zoneClimatique: { id: 1 } };
-      const baiesVitrees = [
-        {
-          donnee_entree: {
-            enum_type_adjacence_id: 1,
-            enum_orientation_id: 2,
-            surface_totale_baie: 10
-          },
-          donnee_intermediaire: { sw: 1 }
+
+      /** @type {Enveloppe} */
+      const enveloppe = {
+        baie_vitree_collection: {
+          baie_vitree: [
+            {
+              donnee_entree: {
+                enum_type_adjacence_id: 1,
+                enum_orientation_id: 2,
+                surface_totale_baie: 10
+              },
+              donnee_intermediaire: { sw: 1 }
+            }
+          ]
         }
-      ];
-      expect(service.ssdMois(ctx, baiesVitrees, [], 'Janvier')).toBe(5);
+      };
+      expect(service.ssdMois(ctx, enveloppe, 'Janvier')).toBe(5);
       expect(tvStore.getCoefficientBaieVitree).toHaveBeenCalledWith(2, 3, 1, 'Janvier');
     });
 
@@ -150,37 +161,46 @@ describe('Calcul de déperdition des portes', () => {
 
       /** @type {Contexte} */
       const ctx = { zoneClimatique: { id: 1 } };
-      const baiesVitrees = [
-        {
-          donnee_entree: {
-            enum_type_adjacence_id: 10,
-            enum_orientation_id: 2,
-            surface_totale_baie: 10
-          },
-          donnee_intermediaire: { sw: 1 }
+
+      /** @type {Enveloppe} */
+      const enveloppe = {
+        baie_vitree_collection: {
+          baie_vitree: [
+            {
+              donnee_entree: {
+                enum_type_adjacence_id: 10,
+                enum_orientation_id: 2,
+                surface_totale_baie: 10
+              },
+              donnee_intermediaire: { sw: 1 }
+            },
+            {
+              donnee_entree: {
+                enum_type_adjacence_id: 1,
+                enum_orientation_id: 2,
+                surface_totale_baie: 10
+              },
+              donnee_intermediaire: { sw: 1 }
+            }
+          ]
         },
-        {
-          donnee_entree: {
-            enum_type_adjacence_id: 1,
-            enum_orientation_id: 2,
-            surface_totale_baie: 10
-          },
-          donnee_intermediaire: { sw: 1 }
-        }
-      ];
-      const ets = {
-        donnee_intermediaire: { bver: 0.6, coef_transparence_ets: 0.4 },
-        baie_ets_collection: {
-          baie_ets: {
-            donnee_entree: {
-              enum_inclinaison_vitrage_id: 3,
-              enum_orientation_id: 1,
-              surface_totale_baie: 7
+        ets_collection: {
+          ets: {
+            donnee_intermediaire: { bver: 0.6, coef_transparence_ets: 0.4 },
+            baie_ets_collection: {
+              baie_ets: {
+                donnee_entree: {
+                  enum_inclinaison_vitrage_id: 3,
+                  enum_orientation_id: 1,
+                  surface_totale_baie: 7
+                }
+              }
             }
           }
         }
       };
-      expect(service.ssdMois(ctx, baiesVitrees, ets, 'Janvier')).toBe(6.5224);
+
+      expect(service.ssdMois(ctx, enveloppe, 'Janvier')).toBe(6.5224);
       expect(tvStore.getCoefficientBaieVitree).toHaveBeenCalledWith(2, 3, 1, 'Janvier');
       expect(tvStore.getCoefficientBaieVitree).toHaveBeenCalledWith(1, 3, 1, 'Janvier');
     });

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}
@@ -89,8 +132,12 @@ export class ContexteBuilder {
 
     if ([1, 14, 18].includes(methodeApplication)) {
       return TypeDpe.MAISON;
-    } else if ([2, 3, 4, 5, 31, 32, 35, 36, 37].includes(methodeApplication)) {
+    } else if (
+      [2, 3, 4, 5, 15, 16, 19, 20, 22, 23, 24, 25, 31, 32, 35, 36, 37].includes(methodeApplication)
+    ) {
       return TypeDpe.APPARTEMENT;
+    } else if ([10, 11, 12, 13, 33, 34, 38, 39, 40].includes(methodeApplication)) {
+      return TypeDpe.APPARTEMENT_A_PARTIR_IMMEUBLE;
     }
     return TypeDpe.IMMEUBLE;
   }