@open3cl/engine 1.0.10 → 1.0.12

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

@@ -0,0 +1,167 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { SurfaceSudEquivalenteService } from './../surface-sud-equivalente.service.js';
+import { ApportGratuitService } from './apport-gratuit.service.js';
+import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
+import { mois_liste } from '../../../../../utils.js';
+
+/** @type {FrTvStore} **/
+let frTvStore;
+
+/** @type {SurfaceSudEquivalenteService} **/
+let surfaceSudEquivalenteService;
+
+/** @type {ApportGratuitService} **/
+let service;
+
+describe('Calcul des apports gratuits au logement', () => {
+  beforeEach(() => {
+    frTvStore = new FrTvStore();
+    surfaceSudEquivalenteService = new SurfaceSudEquivalenteService();
+    service = new ApportGratuitService(frTvStore, surfaceSudEquivalenteService);
+  });
+
+  test.each([
+    {
+      label: 'avec climatisation',
+      withClimatisation: true
+    },
+    {
+      label: 'sans climatisation',
+      withClimatisation: false
+    }
+  ])('Determination des apports gratuits pour un logement $label', ({ withClimatisation }) => {
+    vi.spyOn(surfaceSudEquivalenteService, 'ssdMois').mockReturnValue(18.5);
+    vi.spyOn(frTvStore, 'getData').mockReturnValue(10);
+
+    /** @type {Contexte} */
+    const ctx = {
+      zoneClimatique: { value: 'h1a' },
+      altitude: { value: '400-800m' },
+      inertie: { ilpa: 1 }
+    };
+
+    /** @type { Logement } **/
+    const logement = { enveloppe: { porte_collection: {} } };
+
+    if (withClimatisation) {
+      logement.climatisation_collection = { climatisation: [{}] };
+    }
+
+    expect(service.apportSolaire(ctx, logement)).toStrictEqual({
+      apport_solaire_ch: 2220000,
+      apport_solaire_fr: withClimatisation ? 2220000 : 0
+    });
+    expect(surfaceSudEquivalenteService.ssdMois).toHaveBeenCalledWith(
+      ctx,
+      logement.enveloppe,
+      'Janvier'
+    );
+
+    for (const mois of mois_liste) {
+      expect(frTvStore.getData).toHaveBeenCalledWith(
+        'e',
+        ctx.altitude.value,
+        ctx.zoneClimatique.value,
+        mois,
+        ctx.inertie.ilpa
+      );
+
+      if (withClimatisation) {
+        expect(frTvStore.getData).toHaveBeenCalledWith(
+          'e_fr_28',
+          ctx.altitude.value,
+          ctx.zoneClimatique.value,
+          mois
+        );
+      } else {
+        expect(frTvStore.getData).not.toHaveBeenCalledWith(
+          'e_fr_28',
+          ctx.altitude.value,
+          ctx.zoneClimatique.value,
+          mois
+        );
+      }
+    }
+  });
+
+  test.each([
+    {
+      label: 'avec climatisation',
+      withClimatisation: true
+    },
+    {
+      label: 'sans climatisation',
+      withClimatisation: false
+    }
+  ])('Determination des apports internes pour un logement $label', ({ withClimatisation }) => {
+    vi.spyOn(frTvStore, 'getData').mockReturnValue(10);
+
+    /** @type {Contexte} */
+    const ctx = {
+      zoneClimatique: { value: 'h1a' },
+      altitude: { value: '400-800m' },
+      inertie: { ilpa: 1 },
+      surfaceHabitable: 12,
+      nadeq: 1.25
+    };
+
+    /** @type { Logement } **/
+    const logement = { enveloppe: { porte_collection: {} } };
+
+    if (withClimatisation) {
+      logement.climatisation_collection = { climatisation: [{}] };
+    }
+
+    expect(service.apportInterne(ctx, logement)).toStrictEqual({
+      apport_interne_ch: 15675.94285714286,
+      apport_interne_fr: withClimatisation ? 15675.94285714286 : 0
+    });
+
+    for (const mois of mois_liste) {
+      expect(frTvStore.getData).toHaveBeenCalledWith(
+        'nref19',
+        ctx.altitude.value,
+        ctx.zoneClimatique.value,
+        mois,
+        ctx.inertie.ilpa
+      );
+
+      if (withClimatisation) {
+        expect(frTvStore.getData).toHaveBeenCalledWith(
+          'nref28',
+          ctx.altitude.value,
+          ctx.zoneClimatique.value,
+          mois
+        );
+      } else {
+        expect(frTvStore.getData).not.toHaveBeenCalledWith(
+          'nref28',
+          ctx.altitude.value,
+          ctx.zoneClimatique.value,
+          mois
+        );
+      }
+    }
+  });
+
+  test('Determination des apports solaires pour un mois donné', () => {
+    vi.spyOn(surfaceSudEquivalenteService, 'ssdMois').mockReturnValue(18.5);
+
+    /** @type {Contexte} */
+    const ctx = { zoneClimatique: { id: 1 } };
+
+    /** @type { Enveloppe } **/
+    const enveloppe = {
+      porte_collection: {}
+    };
+    expect(service.apportSolaireMois(ctx, enveloppe, 'Janvier', 18)).toBe(333000);
+    expect(surfaceSudEquivalenteService.ssdMois).toHaveBeenCalledWith(ctx, enveloppe, 'Janvier');
+  });
+
+  test('Determination des apports internes dans le logement pour un mois donné', () => {
+    /** @type {Contexte} */
+    const ctx = { surfaceHabitable: 88, nadeq: 2 };
+
+    expect(service.apportInterneMois(ctx, 18)).toBeCloseTo(8121.39, 2);
+  });
+});

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

@@ -0,0 +1,58 @@
+import { mois_liste, Njj } from '../../../../../utils.js';
+import { EcsTvStore } from '../../../../dpe/infrastructure/ecs/ecsTv.store.js';
+import { inject } from 'dioma';
+
+/**
+ * Calcul du besoin en eau chaude sanitaire
+ * Chapitre 11.1 Calcul du besoin d’ECS
+ *
+ * Methode_de_calcul_3CL_DPE_2021 - Page 70
+ * Octobre 2021
+ * @see consolide_anne…arrete_du_31_03_2021_relatif_aux_methodes_et_procedures_applicables.pdf
+ */
+export class BesoinEcsService {
+  /**
+   * @type {EcsTvStore}
+   */
+  #tvStore;
+
+  /**
+   * @param tvStore {EcsTvStore}
+   */
+  constructor(tvStore = inject(EcsTvStore)) {
+    this.#tvStore = tvStore;
+  }
+
+  /**
+   * @param ctx {Contexte}
+   * @return {{besoin_ecs: number, besoin_ecs_depensier: number}}
+   */
+  execute(ctx) {
+    return mois_liste.reduce(
+      (acc, mois) => {
+        acc.besoin_ecs += this.besoinEcsMois(ctx, mois, false);
+        acc.besoin_ecs_depensier += this.besoinEcsMois(ctx, mois, true);
+        return acc;
+      },
+      { besoin_ecs: 0, besoin_ecs_depensier: 0 }
+    );
+  }
+
+  /**
+   * Calcul du besoin ecs pour un mois donné
+   *
+   * @param ctx {Contexte}
+   * @param mois {string}
+   * @param depensier {boolean}
+   * @returns {number}
+   */
+  besoinEcsMois(ctx, mois, depensier) {
+    const tefs = this.#tvStore.getTefs(ctx.altitude.value, ctx.zoneClimatique.value, mois);
+
+    if (depensier) {
+      return (1.163 * ctx.nadeq * 79 * (40 - tefs) * Njj[mois]) / 1000;
+    } else {
+      return (1.163 * ctx.nadeq * 56 * (40 - tefs) * Njj[mois]) / 1000;
+    }
+  }
+}

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

@@ -0,0 +1,67 @@
+import corpus from '../../../../../../test/corpus-sano.json';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { DpeNormalizerService } from '../../../../normalizer/domain/dpe-normalizer.service.js';
+import { ContexteBuilder } from '../../contexte.builder.js';
+import { getAdemeFileJson } from '../../../../../../test/test-helpers.js';
+import { BesoinEcsService } from './besoin-ecs.service.js';
+import { EcsTvStore } from '../../../../dpe/infrastructure/ecs/ecsTv.store.js';
+
+/** @type {BesoinEcsService} **/
+let service;
+
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
+/** @type {EcsTvStore} **/
+let tvStore;
+
+describe('Calcul du besoin en eau chaude sanitaire', () => {
+  beforeEach(() => {
+    tvStore = new EcsTvStore();
+    service = new BesoinEcsService(tvStore);
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
+  });
+
+  test('Determination du besoin en eau chaude sanitaire pour un mois donné', () => {
+    vi.spyOn(tvStore, 'getTefs').mockReturnValue(0.5);
+
+    /** @type {Contexte} */
+    const ctx = {
+      altitude: {
+        value: '400-800m'
+      },
+      zoneClimatique: {
+        value: 'h1a'
+      },
+      nadeq: 2
+    };
+
+    expect(service.besoinEcsMois(ctx, 'Janvier', false)).toBeCloseTo(159.5, 2);
+    expect(service.besoinEcsMois(ctx, 'Janvier', true)).toBeCloseTo(225.01, 2);
+    expect(tvStore.getTefs).toHaveBeenCalledWith('400-800m', 'h1a', 'Janvier');
+  });
+
+  describe("Test d'intégration pour le besoin en eau chaude sanitaire", () => {
+    test.each(corpus)('vérification des sorties besoin_ecs 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);
+      expect(ecs.besoin_ecs).toBeCloseTo(dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs, 2);
+      expect(ecs.besoin_ecs_depensier).toBeCloseTo(
+        dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs_depensier,
+        2
+      );
+    });
+  });
+});

package/features/engine/domain/apport_et_besoin/ecs/perte-ecs-recup.service.js

@@ -0,0 +1,123 @@
+import { mois_liste } from '../../../../../utils.js';
+import { inject } from 'dioma';
+import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
+
+/**
+ * Calcul des pertes récupérées de distribution et de stockage d'ECS
+ * Chapitre 9.1.1 Consommation de chauffage
+ *
+ * Données calculées
+ *  — pertes_distribution_ecs_recup : pertes de distribution d'ECS récupérées(kWh)
+ *  — pertes_distribution_ecs_recup_depensier : pertes de distribution d'ECS récupérées(kWh) pour le scénario dépensier
+ *  — pertes_stockage_ecs_recup : pertes de stockage d'ECS récupérées(kWh)
+ *
+ * Methode_de_calcul_3CL_DPE_2021 - Page 57
+ * Octobre 2021
+ * @see consolide_anne…arrete_du_31_03_2021_relatif_aux_methodes_et_procedures_applicables.pdf
+ */
+export class PerteEcsRecupService {
+  /**
+   * @type {FrTvStore}
+   */
+  #tvStore;
+
+  /**
+   * @param tvStore {FrTvStore}
+   */
+  constructor(tvStore = inject(FrTvStore)) {
+    this.#tvStore = tvStore;
+  }
+
+  /**
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @return {{pertes_distribution_ecs_recup: number, pertes_distribution_ecs_recup_depensier: number, pertes_stockage_ecs_recup: number}}
+   */
+  execute(ctx, logement) {
+    return {
+      pertes_distribution_ecs_recup: this.pertesDistributionEcsRecup(ctx, logement, false),
+      pertes_distribution_ecs_recup_depensier: this.pertesDistributionEcsRecup(ctx, logement, true),
+      pertes_stockage_ecs_recup: this.pertesStockageEcsRecup(ctx, logement)
+    };
+  }
+
+  /**
+   * Pertes récupérées de distribution d’ECS pour le chauffage
+   * 9.1.1 Consommation de chauffage
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @param depensier {boolean}
+   * @returns {number}
+   */
+  pertesDistributionEcsRecup(ctx, logement, depensier) {
+    const installationsEcs = logement.installation_ecs_collection?.installation_ecs || [];
+
+    const pertesDistribution = installationsEcs.reduce((acc, installation) => {
+      /** @type {InstallationEcsDU}*/
+      const installationEcsDU = installation.donnee_utilisateur;
+
+      const pertesDistributionIndividuelleVolumeChauffee = depensier
+        ? installationEcsDU.QdwIndVc.depensier
+        : installationEcsDU.QdwIndVc.conventionnel;
+      const pertesDistributionCollectiveVolumeChauffee = depensier
+        ? installationEcsDU.QdwColVc.depensier
+        : installationEcsDU.QdwColVc.conventionnel;
+
+      return (
+        acc +
+        pertesDistributionIndividuelleVolumeChauffee +
+        pertesDistributionCollectiveVolumeChauffee
+      );
+    }, 0);
+
+    return mois_liste.reduce((acc, mois) => {
+      return (
+        acc +
+        (0.48 *
+          pertesDistribution *
+          this.#tvStore.getData(
+            depensier ? 'nref21' : 'nref19',
+            ctx.altitude.value,
+            ctx.zoneClimatique.value,
+            mois,
+            ctx.inertie.ilpa
+          )) /
+          8760
+      );
+    }, 0);
+  }
+
+  /**
+   * Pertes récupérées du stockage d’ECS pour le chauffage
+   * 9.1.1 Consommation de chauffage
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @returns {number}
+   */
+  pertesStockageEcsRecup(ctx, logement) {
+    const installationsEcs = logement.installation_ecs_collection?.installation_ecs || [];
+
+    let pertesStockage = installationsEcs.reduce((acc, installation) => {
+      /** @type {InstallationEcsDU}*/
+      const installationEcsDU = installation.donnee_utilisateur;
+
+      return acc + (0.48 * installationEcsDU.QgwRecuperable) / 8760.0;
+    }, 0);
+
+    return mois_liste.reduce((acc, mois) => {
+      return (
+        acc +
+        pertesStockage *
+          this.#tvStore.getData(
+            'nref19',
+            ctx.altitude.value,
+            ctx.zoneClimatique.value,
+            mois,
+            ctx.inertie.ilpa
+          )
+      );
+    }, 0);
+  }
+}

package/features/engine/domain/apport_et_besoin/ecs/perte-ecs-recup.service.spec.js

@@ -0,0 +1,205 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import corpus from '../../../../../../test/corpus-sano.json';
+import { expect_or, getAdemeFileJson } from '../../../../../../test/test-helpers.js';
+import { DpeNormalizerService } from '../../../../normalizer/domain/dpe-normalizer.service.js';
+import { ContexteBuilder } from '../../contexte.builder.js';
+import { PerteEcsRecupService } from './perte-ecs-recup.service.js';
+import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
+import { mois_liste } from '../../../../../utils.js';
+import { EcsTvStore } from '../../../../dpe/infrastructure/ecs/ecsTv.store.js';
+import { GenerateurEcsService } from '../../ecs/generateur-ecs.service.js';
+import { InstallationEcsService } from '../../ecs/installation-ecs.service.js';
+
+/** @type {PerteEcsRecupService} **/
+let service;
+
+/** @type {FrTvStore} **/
+let tvStore;
+
+/** @type {InstallationEcsService} **/
+let installationEcsService;
+
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
+describe('Calcul des pertes de distribution et stockage récupérées', () => {
+  beforeEach(() => {
+    tvStore = new FrTvStore();
+    service = new PerteEcsRecupService(tvStore);
+    installationEcsService = new InstallationEcsService(new GenerateurEcsService(new EcsTvStore()));
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
+  });
+
+  test.each([
+    {
+      label: 'Installation ECS en mode conventionnel',
+      depensier: false,
+      expected: 0.36
+    },
+    {
+      label: 'Installation ECS en mode dépensier',
+      depensier: true,
+      expected: 0.72
+    }
+  ])('Calcul des pertes de distribution récupérées pour $label', ({ depensier, expected }) => {
+    vi.spyOn(tvStore, 'getData').mockReturnValue(1.5);
+
+    /** @type {Contexte} */
+    const ctx = {
+      altitude: { value: '400-800m' },
+      zoneClimatique: { value: 'h1a' },
+      inertie: { ilpa: 1 }
+    };
+
+    /** @type {Logement} */
+    const logement = {
+      installation_ecs_collection: {
+        installation_ecs: [
+          {
+            donnee_utilisateur: {
+              QdwIndVc: { conventionnel: 100, depensier: 200 },
+              QdwColVc: { conventionnel: 50, depensier: 120 }
+            }
+          },
+          {
+            donnee_utilisateur: {
+              QdwIndVc: { conventionnel: 150, depensier: 280 },
+              QdwColVc: { conventionnel: 65, depensier: 135 }
+            }
+          }
+        ]
+      }
+    };
+
+    expect(service.pertesDistributionEcsRecup(ctx, logement, depensier)).toBeCloseTo(expected, 2);
+    for (const mois of mois_liste) {
+      expect(tvStore.getData).toHaveBeenCalledWith(
+        depensier ? 'nref21' : 'nref19',
+        '400-800m',
+        'h1a',
+        mois,
+        1
+      );
+    }
+  });
+
+  test('Calcul des pertes de stockage récupérées pour une installation ECS', () => {
+    vi.spyOn(tvStore, 'getData').mockReturnValue(1.5);
+
+    /** @type {Contexte} */
+    const ctx = {
+      altitude: { value: '400-800m' },
+      zoneClimatique: { value: 'h1a' },
+      inertie: { ilpa: 1 }
+    };
+
+    /** @type {Logement} */
+    const logement = {
+      installation_ecs_collection: {
+        installation_ecs: [
+          { donnee_utilisateur: { QgwRecuperable: 120 } },
+          { donnee_utilisateur: { QgwRecuperable: 150 } }
+        ]
+      }
+    };
+
+    expect(service.pertesStockageEcsRecup(ctx, logement)).toBeCloseTo(0.27);
+    for (const mois of mois_liste) {
+      expect(tvStore.getData).toHaveBeenCalledWith('nref19', '400-800m', 'h1a', mois, 1);
+    }
+  });
+
+  describe("Test d'intégration des installations ECS", () => {
+    test.each(corpus)(
+      'vérification des pertes de distribution ecs recup des installations ECS pour dpe %s',
+      (ademeId) => {
+        let dpeRequest = getAdemeFileJson(ademeId);
+        dpeRequest = normalizerService.normalize(dpeRequest);
+
+        /** @type {Contexte} */
+        const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+        installationEcsService.execute(ctx, dpeRequest.logement, {
+          besoin_ecs: dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs,
+          besoin_ecs_depensier: dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs_depensier
+        });
+
+        const pertesStockage = service.execute(ctx, dpeRequest.logement);
+
+        expect_or(
+          () =>
+            expect(pertesStockage.pertes_distribution_ecs_recup).toBeCloseTo(
+              dpeRequest.logement.sortie.apport_et_besoin.pertes_distribution_ecs_recup
+            ),
+          () =>
+            expect(pertesStockage.pertes_distribution_ecs_recup * 1000).toBeCloseTo(
+              dpeRequest.logement.sortie.apport_et_besoin.pertes_distribution_ecs_recup
+            )
+        );
+      }
+    );
+    test.each(corpus)(
+      'vérification des pertes de distribution ecs recup depensier des installations ECS pour dpe %s',
+      (ademeId) => {
+        let dpeRequest = getAdemeFileJson(ademeId);
+        dpeRequest = normalizerService.normalize(dpeRequest);
+
+        /** @type {Contexte} */
+        const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+        installationEcsService.execute(ctx, dpeRequest.logement, {
+          besoin_ecs: dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs,
+          besoin_ecs_depensier: dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs_depensier
+        });
+
+        const pertesStockage = service.execute(ctx, dpeRequest.logement);
+
+        expect_or(
+          () =>
+            expect(pertesStockage.pertes_distribution_ecs_recup_depensier).toBeCloseTo(
+              dpeRequest.logement.sortie.apport_et_besoin.pertes_distribution_ecs_recup_depensier
+            ),
+          () =>
+            expect(pertesStockage.pertes_distribution_ecs_recup_depensier * 1000).toBeCloseTo(
+              dpeRequest.logement.sortie.apport_et_besoin.pertes_distribution_ecs_recup_depensier
+            )
+        );
+      }
+    );
+    test.each(corpus)(
+      'vérification des pertes de stockage ecs recup des installations ECS pour dpe %s',
+      (ademeId) => {
+        let dpeRequest = getAdemeFileJson(ademeId);
+        dpeRequest = normalizerService.normalize(dpeRequest);
+
+        /** @type {Contexte} */
+        const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+        installationEcsService.execute(ctx, dpeRequest.logement, {
+          besoin_ecs: dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs,
+          besoin_ecs_depensier: dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs_depensier
+        });
+
+        const pertesStockage = service.execute(ctx, dpeRequest.logement);
+        expect_or(
+          () =>
+            expect(pertesStockage.pertes_stockage_ecs_recup).toBeCloseTo(
+              dpeRequest.logement.sortie.apport_et_besoin.pertes_stockage_ecs_recup
+            ),
+          () =>
+            expect(pertesStockage.pertes_stockage_ecs_recup).toBeCloseTo(
+              dpeRequest.logement.sortie.apport_et_besoin.pertes_stockage_ecs_recup * 1000
+            ),
+          () =>
+            expect(pertesStockage.pertes_stockage_ecs_recup * 1000).toBeCloseTo(
+              dpeRequest.logement.sortie.apport_et_besoin.pertes_stockage_ecs_recup
+            )
+        );
+      }
+    );
+  });
+});