@open3cl/engine 1.0.12 → 1.0.14

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

@@ -7,6 +7,14 @@ import { BesoinFroidService } from './froid/besoin-froid.service.js';
 import { ApportGratuitService } from './apport_gratuit/apport-gratuit.service.js';
 import { PerteEcsRecupService } from './ecs/perte-ecs-recup.service.js';
 import { InstallationEcsService } from '../ecs/installation-ecs.service.js';
+import { PerteChRecupService } from './ch/perte-ch-recup.service.js';
+import { BesoinChService } from './ch/besoin-ch.service.js';
+import corpus from '../../../../../test/corpus-sano.json';
+import { getAdemeFileJson } from '../../../../../test/test-helpers.js';
+import { PRECISION_PERCENT } from '../../../../../test/constant.js';
+import { DpeNormalizerService } from '../../../normalizer/domain/dpe-normalizer.service.js';
+import { ContexteBuilder } from '../contexte.builder.js';
+import { InstallationChService } from '../ch/installation-ch.service.js';
 
 /** @type {SurfaceSudEquivalenteService} **/
 let surfaceSudEquivalenteService;
@@ -20,12 +28,27 @@ let besoinFroidService;
 /** @type {InstallationEcsService} **/
 let installationEcsService;
 
+/** @type {InstallationChService} **/
+let installationChService;
+
 /** @type {PerteEcsRecupService} **/
 let perteEcsRecupService;
 
 /** @type {ApportGratuitService} **/
 let apportGratuitService;
 
+/** @type {PerteChRecupService} **/
+let perteChRecupService;
+
+/** @type {BesoinChService} **/
+let besoinChService;
+
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
 /** @type {ApportEtBesoinService} **/
 let service;
 
@@ -37,18 +60,26 @@ describe('Calcul des apports et besoin du logement', () => {
     tvStore = new BaieVitreeTvStore();
     surfaceSudEquivalenteService = new SurfaceSudEquivalenteService(tvStore);
     besoinEcsService = new BesoinEcsService();
+    besoinChService = new BesoinChService();
     besoinFroidService = new BesoinFroidService();
     installationEcsService = new InstallationEcsService();
+    installationChService = new InstallationChService();
     perteEcsRecupService = new PerteEcsRecupService();
     apportGratuitService = new ApportGratuitService();
+    perteChRecupService = new PerteChRecupService();
     service = new ApportEtBesoinService(
       besoinEcsService,
+      besoinChService,
       installationEcsService,
+      installationChService,
       perteEcsRecupService,
       besoinFroidService,
       surfaceSudEquivalenteService,
+      perteChRecupService,
       apportGratuitService
     );
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
   });
 
   test('Determination des apports et besoin du logement', () => {
@@ -57,6 +88,10 @@ describe('Calcul des apports et besoin du logement', () => {
       besoin_ecs: 1526,
       besoin_ecs_depensier: 2685.3
     });
+    vi.spyOn(besoinChService, 'execute').mockReturnValue({
+      besoin_ch_hp: 2563,
+      besoin_ch_depensier_hp: 3258.6
+    });
     vi.spyOn(besoinFroidService, 'execute').mockReturnValue({
       besoin_fr: 896,
       besoin_fr_depensier: 1025.3
@@ -70,10 +105,16 @@ describe('Calcul des apports et besoin du logement', () => {
       apport_interne_fr: 3345.2
     });
     vi.spyOn(installationEcsService, 'execute').mockReturnThis();
+    vi.spyOn(installationChService, 'execute').mockReturnThis();
     vi.spyOn(perteEcsRecupService, 'execute').mockReturnValue({
       pertes_distribution_ecs_recup: 354.2,
       pertes_distribution_ecs_recup_depensier: 532.6,
-      pertes_stockage_ecs_recup: 25.9
+      pertes_stockage_ecs_recup: 25.9,
+      pertes_stockage_ecs_recup_depensier: 12.9
+    });
+    vi.spyOn(perteChRecupService, 'execute').mockReturnValue({
+      pertes_generateur_ch_recup: 102.2,
+      pertes_generateur_ch_recup_depensier: 153.4
     });
 
     /** @type {Contexte} */
@@ -84,6 +125,8 @@ describe('Calcul des apports et besoin du logement', () => {
       surface_sud_equivalente: 18.5,
       besoin_ecs: 1526,
       besoin_ecs_depensier: 2685.3,
+      besoin_ch: 2080.7000000000003,
+      besoin_ch_depensier: 2559.7,
       besoin_fr: 896,
       besoin_fr_depensier: 1025.3,
       apport_solaire_ch: 5236.9,
@@ -95,12 +138,84 @@ describe('Calcul des apports et besoin du logement', () => {
       v40_ecs_journalier_depensier: 197.5,
       pertes_distribution_ecs_recup: 354.2,
       pertes_distribution_ecs_recup_depensier: 532.6,
-      pertes_stockage_ecs_recup: 25.9
+      pertes_generateur_ch_recup: 102.2,
+      pertes_generateur_ch_recup_depensier: 153.4,
+      pertes_stockage_ecs_recup: 25.9,
+      pertes_stockage_ecs_recup_depensier: 12.9
     });
     expect(surfaceSudEquivalenteService.execute).toHaveBeenCalledWith(ctx, logement.enveloppe);
     expect(besoinEcsService.execute).toHaveBeenCalledWith(ctx);
     expect(besoinFroidService.execute).toHaveBeenCalledWith(ctx, logement);
     expect(apportGratuitService.apportSolaire).toHaveBeenCalledWith(ctx, logement);
     expect(apportGratuitService.apportInterne).toHaveBeenCalledWith(ctx, logement);
+    expect(perteEcsRecupService.execute).toHaveBeenCalledWith(ctx, logement);
+    expect(perteChRecupService.execute).toHaveBeenCalledWith(ctx, logement);
+    expect(installationEcsService.execute).toHaveBeenCalledWith(ctx, logement, {
+      besoin_ecs: 1526,
+      besoin_ecs_depensier: 2685.3
+    });
+    expect(installationChService.execute).toHaveBeenCalledWith(ctx, logement);
+  });
+
+  describe("Test d'intégration pour les besoins en chauffage", () => {
+    test.each(corpus)(
+      'Vérification de la DI besoin_ch des besoins en chauffage pour dpe %s',
+      (ademeId) => {
+        /**
+         * @type {Dpe}
+         */
+        let dpeRequest = getAdemeFileJson(ademeId);
+        dpeRequest = normalizerService.normalize(dpeRequest);
+
+        dpeRequest.logement.donnees_de_calcul = {
+          apportsInterneDepensier: [],
+          apportsInterneCh: [],
+          apportsSolaire: [],
+          besoinChauffageHP: [],
+          besoinChauffageDepensierHP: []
+        };
+
+        /** @type {Contexte} */
+        const ctx = contexteBuilder.fromDpe(dpeRequest);
+        const apportEtBesoin = service.execute(ctx, dpeRequest.logement);
+
+        expect(
+          Math.abs(
+            apportEtBesoin.besoin_ch - dpeRequest.logement.sortie.apport_et_besoin.besoin_ch
+          ) / (dpeRequest.logement.sortie.apport_et_besoin.besoin_ch || 1)
+        ).toBeLessThan(PRECISION_PERCENT);
+      }
+    );
+
+    test.each(corpus)(
+      'Vérification de la DI besoin_ch_depensier des besoins en chauffage pour dpe %s',
+      (ademeId) => {
+        /**
+         * @type {Dpe}
+         */
+        let dpeRequest = getAdemeFileJson(ademeId);
+        dpeRequest = normalizerService.normalize(dpeRequest);
+
+        dpeRequest.logement.donnees_de_calcul = {
+          apportsInterneDepensier: [],
+          apportsInterneCh: [],
+          apportsSolaire: [],
+          besoinChauffageHP: [],
+          besoinChauffageDepensierHP: []
+        };
+
+        /** @type {Contexte} */
+        const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+        const apportEtBesoin = service.execute(ctx, dpeRequest.logement);
+
+        expect(
+          Math.abs(
+            apportEtBesoin.besoin_ch_depensier -
+              dpeRequest.logement.sortie.apport_et_besoin.besoin_ch_depensier
+          ) / (dpeRequest.logement.sortie.apport_et_besoin.besoin_ch_depensier || 1)
+        ).toBeLessThan(PRECISION_PERCENT);
+      }
+    );
   });
 });

package/features/engine/domain/apport_et_besoin/apport_gratuit/apport-gratuit.service.js

@@ -46,7 +46,7 @@ export class ApportGratuitService {
 
     return mois_liste.reduce(
       (acc, mois) => {
-        acc.apport_solaire_ch += this.apportSolaireMois(
+        const apportSolaire = this.apportSolaireMois(
           ctx,
           logement.enveloppe,
           mois,
@@ -58,6 +58,9 @@ export class ApportGratuitService {
             ctx.inertie.ilpa
           )
         );
+        acc.apport_solaire_ch += apportSolaire;
+        logement.donnees_de_calcul.apportsSolaire[mois] = apportSolaire;
+
         if (clim.length > 0) {
           acc.apport_solaire_fr += this.apportSolaireMois(
             ctx,
@@ -84,7 +87,7 @@ export class ApportGratuitService {
 
     return mois_liste.reduce(
       (acc, mois) => {
-        acc.apport_interne_ch += this.apportInterneMois(
+        const apportInterne = this.apportInterneMois(
           ctx,
           this.#frTvStore.getData(
             'nref19',
@@ -94,6 +97,19 @@ export class ApportGratuitService {
             ctx.inertie.ilpa
           )
         );
+        acc.apport_interne_ch += apportInterne;
+        logement.donnees_de_calcul.apportsInterneCh[mois] = apportInterne;
+        logement.donnees_de_calcul.apportsInterneDepensier[mois] = this.apportInterneMois(
+          ctx,
+          this.#frTvStore.getData(
+            'nref21',
+            ctx.altitude.value,
+            ctx.zoneClimatique.value,
+            mois,
+            ctx.inertie.ilpa
+          )
+        );
+
         if (clim.length > 0) {
           acc.apport_interne_fr += this.apportInterneMois(
             ctx,

package/features/engine/domain/apport_et_besoin/apport_gratuit/apport-gratuit.service.spec.js

@@ -41,7 +41,10 @@ describe('Calcul des apports gratuits au logement', () => {
     };
 
     /** @type { Logement } **/
-    const logement = { enveloppe: { porte_collection: {} } };
+    const logement = {
+      enveloppe: { porte_collection: {} },
+      donnees_de_calcul: { apportsSolaire: {} }
+    };
 
     if (withClimatisation) {
       logement.climatisation_collection = { climatisation: [{}] };
@@ -81,6 +84,8 @@ describe('Calcul des apports gratuits au logement', () => {
           mois
         );
       }
+
+      expect(logement.donnees_de_calcul.apportsSolaire[mois]).toBe(185000);
     }
   });
 
@@ -106,7 +111,10 @@ describe('Calcul des apports gratuits au logement', () => {
     };
 
     /** @type { Logement } **/
-    const logement = { enveloppe: { porte_collection: {} } };
+    const logement = {
+      enveloppe: { porte_collection: {} },
+      donnees_de_calcul: { apportsInterneCh: {}, apportsInterneDepensier: {} }
+    };
 
     if (withClimatisation) {
       logement.climatisation_collection = { climatisation: [{}] };
@@ -141,6 +149,9 @@ describe('Calcul des apports gratuits au logement', () => {
           mois
         );
       }
+
+      expect(logement.donnees_de_calcul.apportsInterneCh[mois]).toBeCloseTo(1306.33, 2);
+      expect(logement.donnees_de_calcul.apportsInterneDepensier[mois]).toBeCloseTo(1306.33, 2);
     }
   });
 

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

@@ -0,0 +1,150 @@
+import { mois_liste } from '../../../../../utils.js';
+import { inject } from 'dioma';
+import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
+
+/**
+ * Calcul du besoin en chauffage
+ * Chapitre 2 - Expression du besoin de chauffage
+ *
+ * Methode_de_calcul_3CL_DPE_2021 - Page 7
+ * Octobre 2021
+ * @see consolide_anne…arrete_du_31_03_2021_relatif_aux_methodes_et_procedures_applicables.pdf
+ */
+export class BesoinChService {
+  /**
+   * @type {FrTvStore}
+   */
+  #tvStore;
+
+  /**
+   * @param tvStore {FrTvStore}
+   */
+  constructor(tvStore = inject(FrTvStore)) {
+    this.#tvStore = tvStore;
+  }
+
+  /**
+   * Besoin de chauffage hors pertes récupérées
+   * 9.1.1 - Consommation de chauffage
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @return {{besoin_ch_hp: number, besoin_ch_depensier_hp: number, fraction_apport_gratuit_ch: number, fraction_apport_gratuit_depensier_ch: number}}
+   */
+  execute(ctx, logement) {
+    const besoinCh = mois_liste.reduce(
+      (acc, mois) => {
+        const dh19 = this.#tvStore.getData(
+          'dh19',
+          ctx.altitude.value,
+          ctx.zoneClimatique.value,
+          mois,
+          ctx.inertie.ilpa
+        );
+        const dh21 = this.#tvStore.getData(
+          'dh21',
+          ctx.altitude.value,
+          ctx.zoneClimatique.value,
+          mois,
+          ctx.inertie.ilpa
+        );
+
+        const besoinCh = this.besoinChHorsPertesRecuperees(ctx, logement, mois, dh19);
+        acc.besoin_ch_hp += besoinCh.besoinChMoisHP;
+        acc.fraction_apport_gratuit_ch += besoinCh.fractionApportGratuitMois;
+        logement.donnees_de_calcul.besoinChauffageHP[mois] = besoinCh.besoinChMoisHP;
+
+        const besoinChDepensier = this.besoinChHorsPertesRecuperees(ctx, logement, mois, dh21);
+        acc.besoin_ch_depensier_hp += besoinChDepensier.besoinChMoisHP;
+        acc.fraction_apport_gratuit_depensier_ch += besoinChDepensier.fractionApportGratuitMois;
+        logement.donnees_de_calcul.besoinChauffageDepensierHP[mois] =
+          besoinChDepensier.besoinChMoisHP;
+
+        acc.dh19 += dh19;
+        acc.dh21 += dh21;
+        return acc;
+      },
+      {
+        besoin_ch_hp: 0,
+        besoin_ch_depensier_hp: 0,
+        fraction_apport_gratuit_ch: 0,
+        fraction_apport_gratuit_depensier_ch: 0,
+        dh19: 0,
+        dh21: 0
+      }
+    );
+
+    besoinCh.fraction_apport_gratuit_ch /= besoinCh.dh19;
+    besoinCh.fraction_apport_gratuit_depensier_ch /= besoinCh.dh21;
+
+    delete besoinCh.dh19;
+    delete besoinCh.dh19;
+
+    return besoinCh;
+  }
+
+  /**
+   * Fraction des besoins de chauffage couverts par les apports gratuits pour un mois donné
+   * 6.1 Calcul de F
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @param mois {string}
+   * @param dh {number} - degrés-heures de chauffage sur le mois j (°Ch)
+   * @returns {number}
+   */
+  fractionBesoinCh(ctx, logement, mois, dh) {
+    // Apports internes dans le logement sur le mois
+    const Ai = logement.donnees_de_calcul.apportsInterneCh[mois];
+    // Apports solaires dans le logement sur le mois durant la période de chauffe
+    const As = logement.donnees_de_calcul.apportsSolaire[mois];
+
+    if (dh === 0) return 0;
+
+    let pow;
+    switch (ctx.inertie.id) {
+      // Inertie très lourde ou lourde
+      case 1:
+      case 2:
+        pow = 3.6;
+        break;
+      // Inertie moyenne
+      case 3:
+        pow = 2.9;
+        break;
+      // Inertie légère
+      case 4:
+        pow = 2.5;
+        break;
+    }
+
+    const Xj = (As + Ai) / (logement.sortie.deperdition.deperdition_enveloppe * dh);
+    return (Xj - Xj ** pow) / (1 - Xj ** pow);
+  }
+
+  /**
+   * Besoin de chauffage hors pertes récupérées sur le mois (kWh) :
+   * 9.1.1 - Consommation de chauffage
+   *
+   * Fraction des besoins de chauffage couverts par les apports gratuits sur le mois
+   * 6.1 - Calcul de F
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @param mois {string}
+   * @param dh {number} - degrés-heures de chauffage sur le mois j (°Ch)
+   * @returns {{besoinChMoisHP: number, fractionApportGratuitMois: number}}
+   */
+  besoinChHorsPertesRecuperees(ctx, logement, mois, dh) {
+    // Fraction des besoins de chauffage couverts par les apports gratuits pour un mois donné
+    const F = this.fractionBesoinCh(ctx, logement, mois, dh);
+
+    // Besoin de chauffage d’un logement par kelvin sur le mois j (W/K)
+    const BV = logement.sortie.deperdition.deperdition_enveloppe * (1 - F);
+
+    return {
+      besoinChMoisHP: (BV * dh) / 1000,
+      fractionApportGratuitMois: F * dh
+    };
+  }
+}

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

@@ -0,0 +1,145 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
+import { BesoinChService } from './besoin-ch.service.js';
+import { mois_liste } from '../../../../../utils.js';
+
+/** @type {BesoinChService} **/
+let service;
+
+/** @type {FrTvStore} **/
+let tvStore;
+
+describe('Calcul des besoins en chauffage du logement', () => {
+  beforeEach(() => {
+    tvStore = new FrTvStore();
+    service = new BesoinChService(tvStore);
+  });
+
+  test.each([
+    {
+      inertie: 1,
+      expected: 0.24
+    },
+    {
+      inertie: 2,
+      expected: 0.24
+    },
+    {
+      inertie: 3,
+      expected: 0.23
+    },
+    {
+      inertie: 4,
+      expected: 0.22
+    }
+  ])(
+    'Determination de la fraction des besoins de chauffage couverts par les apports gratuits pour un mois donné avec inertie = $inertie',
+    ({ inertie, expected }) => {
+      /** @type {Contexte} */
+      const ctx = { inertie: { id: inertie } };
+
+      /** @type { Logement } **/
+      const logement = {
+        donnees_de_calcul: {
+          apportsInterneCh: { Janvier: 102.5 },
+          apportsSolaire: { Janvier: 12.5 }
+        },
+        sortie: { deperdition: { deperdition_enveloppe: 25.9 } }
+      };
+      expect(service.fractionBesoinCh(ctx, logement, 'Janvier', 18)).toBeCloseTo(expected, 2);
+    }
+  );
+
+  test('Besoin de chauffage hors pertes récupérées et fraction des apports gratuits pour un mois', () => {
+    /** @type {Contexte} */
+    const ctx = { inertie: { id: 1 } };
+
+    /** @type { Logement } **/
+    const logement = {
+      donnees_de_calcul: {
+        apportsInterneCh: { Janvier: 102.5 },
+        apportsSolaire: { Janvier: 12.5 }
+      },
+      sortie: { deperdition: { deperdition_enveloppe: 25.9 } }
+    };
+
+    const besoinHP = service.besoinChHorsPertesRecuperees(ctx, logement, 'Janvier', 12.5);
+    expect(besoinHP.besoinChMoisHP).toBeCloseTo(0.2139, 4);
+    expect(besoinHP.fractionApportGratuitMois).toBeCloseTo(4.2412, 4);
+  });
+
+  test('Besoin total de chauffage hors pertes récupérées et fraction des apports gratuits', () => {
+    vi.spyOn(tvStore, 'getData').mockReturnValue(10);
+
+    /** @type {Contexte} */
+    const ctx = {
+      inertie: { id: 1, ilpa: 1 },
+      altitude: { value: '400-800m' },
+      zoneClimatique: { value: 'h3c' }
+    };
+
+    /** @type { Logement } **/
+    const logement = {
+      donnees_de_calcul: {
+        apportsInterneCh: {
+          Janvier: 102.5,
+          Février: 102.5,
+          Mars: 102.5,
+          Avril: 102.5,
+          Mai: 102.5,
+          Juin: 102.5,
+          Juillet: 102.5,
+          Aout: 102.5,
+          Septembre: 102.5,
+          Octobre: 102.5,
+          Novembre: 102.5,
+          Décembre: 102.5
+        },
+        apportsSolaire: {
+          Janvier: 102.5,
+          Février: 102.5,
+          Mars: 102.5,
+          Avril: 102.5,
+          Mai: 102.5,
+          Juin: 102.5,
+          Juillet: 102.5,
+          Aout: 102.5,
+          Septembre: 102.5,
+          Octobre: 102.5,
+          Novembre: 102.5,
+          Décembre: 102.5
+        },
+        besoinChauffageHP: {},
+        besoinChauffageDepensierHP: {}
+      },
+      sortie: { deperdition: { deperdition_enveloppe: 25.9 } }
+    };
+
+    const besoinTotalHP = service.execute(ctx, logement);
+    expect(besoinTotalHP.besoin_ch_hp).toBeCloseTo(1.1388, 4);
+    expect(besoinTotalHP.besoin_ch_depensier_hp).toBeCloseTo(1.1388, 4);
+    expect(besoinTotalHP.fraction_apport_gratuit_ch).toBeCloseTo(0.6336, 4);
+    expect(besoinTotalHP.fraction_apport_gratuit_depensier_ch).toBeCloseTo(0.6336, 4);
+
+    for (const mois of mois_liste) {
+      expect(tvStore.getData).toHaveBeenCalledWith(
+        'dh19',
+        ctx.altitude.value,
+        ctx.zoneClimatique.value,
+        mois,
+        ctx.inertie.ilpa
+      );
+
+      expect(tvStore.getData).toHaveBeenCalledWith(
+        'dh21',
+        ctx.altitude.value,
+        ctx.zoneClimatique.value,
+        mois,
+        ctx.inertie.ilpa
+      );
+
+      expect(logement.donnees_de_calcul.besoinChauffageHP[mois]).toBeCloseTo(0.0949, 4);
+      expect(logement.donnees_de_calcul.besoinChauffageDepensierHP[mois]).toBeCloseTo(0.0949, 4);
+    }
+  });
+});