@open3cl/engine 1.0.10 → 1.0.12

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/ecs/generateur-ecs.service.js

@@ -0,0 +1,106 @@
+import { TypeStockage } from '../../../dpe/domain/models/type-stockage.model.js';
+import { inject } from 'dioma';
+import { EcsTvStore } from '../../../dpe/infrastructure/ecs/ecsTv.store.js';
+
+/**
+ * Calcul des données de calcul pour chacun des générateurs
+ * Données calculées
+ *   — Qgw : pertes liées au stockage de l'ECS pour chaque générateur
+ */
+export class GenerateurEcsService {
+  /**
+   * @type {EcsTvStore}
+   */
+  #tvStore;
+
+  /**
+   * @param tvStore {EcsTvStore}
+   */
+  constructor(tvStore = inject(EcsTvStore)) {
+    this.#tvStore = tvStore;
+  }
+
+  /**
+   * Détermination des apports et besoins pour le bien concerné
+   *
+   * @param installationEcs {InstallationEcs}
+   */
+  execute(installationEcs) {
+    const generateursEcs = installationEcs.generateur_ecs_collection.generateur_ecs || [];
+
+    generateursEcs.forEach((generateurEcs) => {
+      /** @type {GenerateurEcsDE}*/
+      const generateurEcsDE = generateurEcs.donnee_entree;
+
+      generateurEcs.donnee_utilisateur = {
+        Qgw: this.pertesStockage(generateurEcsDE)
+      };
+    });
+  }
+
+  /**
+   * Pertes de stockage d'un générateur ECS.
+   * Seules les générateurs avec stockage indépendant et dissocié du générateur sont concernés
+   *
+   * 11.6.1 - Pertes de stockage des ballons d’accumulation
+   * 11.6.2 - Pertes des ballons électriques
+   *
+   * @param generateurEcsDE {GenerateurEcsDE}
+   * @return {number}
+   */
+  pertesStockage(generateurEcsDE) {
+    const electrique = this.generateurElectrique(generateurEcsDE);
+    const typeStockage = this.typeStockage(generateurEcsDE);
+
+    if (typeStockage === TypeStockage.INSTANTANE) {
+      return 0;
+    }
+
+    let Qgw;
+    let volumeStockage = generateurEcsDE.volume_stockage;
+
+    if (electrique) {
+      const cr = this.#tvStore.getPertesStockage(
+        generateurEcsDE.enum_type_generateur_ecs_id,
+        volumeStockage
+      );
+      // Les pertes de stockage des ballons électriques (Wh)
+      Qgw = ((8592 * 45) / 24) * volumeStockage * cr;
+    } else {
+      // La présence d’un ballon de préparation de l’ECS est responsable de pertes de stockage Qgw (Wh)
+      Qgw = 67662 * volumeStockage ** 0.55;
+    }
+
+    return Qgw;
+  }
+
+  /**
+   * Return true si le générateur ECS est électrique
+   *
+   * 1 - abscence de stockage d'ecs (production instantanée)
+   * 2 - stockage indépendant de la production
+   * 3 - stockage intégré à la production
+   *
+   * @param generateurEcsDE {GenerateurEcsDE}
+   * @return {boolean}
+   */
+  generateurElectrique(generateurEcsDE) {
+    return this.#tvStore
+      .getElectriqueEcsGenerateurs()
+      .includes(parseInt(generateurEcsDE.enum_type_generateur_ecs_id));
+  }
+
+  /**
+   * Return le type de stockage d'ECS
+   *
+   * @param generateurEcsDE {GenerateurEcsDE}
+   * @return TypeStockage
+   */
+  typeStockage(generateurEcsDE) {
+    return parseInt(generateurEcsDE.enum_type_stockage_ecs_id) === 1
+      ? TypeStockage.INSTANTANE
+      : parseInt(generateurEcsDE.enum_type_stockage_ecs_id) === 2
+        ? TypeStockage.INDEPENDANT
+        : TypeStockage.INTEGRE;
+  }
+}

package/features/engine/domain/ecs/generateur-ecs.service.spec.js

@@ -0,0 +1,136 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { GenerateurEcsService } from './generateur-ecs.service.js';
+import { EcsTvStore } from '../../../dpe/infrastructure/ecs/ecsTv.store.js';
+import { TypeStockage } from '../../../dpe/domain/models/type-stockage.model.js';
+
+/** @type {GenerateurEcsService} **/
+let service;
+
+/** @type {EcsTvStore} **/
+let tvStore;
+
+describe('Calcul des informations techniques des générateurs ECS', () => {
+  beforeEach(() => {
+    tvStore = new EcsTvStore();
+    service = new GenerateurEcsService(tvStore);
+  });
+
+  describe("Calcul des pertes de stockage d'un générateur", () => {
+    test.each([
+      {
+        label: 'Générateur ECS avec production instantanée',
+        enumTypeGenerateurEcsId: 1,
+        enumTypeStockageEcsId: 1,
+        volumeStockage: 100,
+        expected: 0
+      },
+      {
+        label: 'Générateur ECS avec stockage intégré au générateur',
+        enumTypeGenerateurEcsId: 1,
+        enumTypeStockageEcsId: 2,
+        volumeStockage: 100,
+        expected: 851814.11
+      },
+      {
+        label: 'Générateur ECS électrique avec stockage indépendant de 100L',
+        enumTypeGenerateurEcsId: 2,
+        enumTypeStockageEcsId: 3,
+        electrique: true,
+        volumeStockage: 250,
+        expected: 1288800
+      },
+      {
+        label: 'Générateur ECS à gaz avec stockage indépendant de 200L',
+        enumTypeGenerateurEcsId: 1,
+        enumTypeStockageEcsId: 3,
+        volumeStockage: 200,
+        expected: 1247128.86
+      }
+    ])(
+      '$label',
+      ({
+        enumTypeGenerateurEcsId,
+        volumeStockage,
+        enumTypeStockageEcsId,
+        electrique = false,
+        expected
+      }) => {
+        vi.spyOn(tvStore, 'getPertesStockage').mockReturnValue(0.32);
+        vi.spyOn(tvStore, 'getElectriqueEcsGenerateurs').mockReturnValue([2]);
+
+        /** @type {GenerateurEcsDE} */
+        const generateurEcsDE = {
+          enum_type_generateur_ecs_id: enumTypeGenerateurEcsId,
+          volume_stockage: volumeStockage,
+          enum_type_stockage_ecs_id: enumTypeStockageEcsId
+        };
+
+        const pertesStockage = service.pertesStockage(generateurEcsDE);
+
+        if (electrique) {
+          expect(tvStore.getPertesStockage).toHaveBeenCalledWith(
+            enumTypeGenerateurEcsId,
+            volumeStockage
+          );
+        }
+        expect(pertesStockage).toBeCloseTo(expected, 2);
+      }
+    );
+
+    test('Ajout des données utilisateurs sur tous les générateurs', () => {
+      /** @type {InstallationEcs} */
+      const installationsEcs = {
+        generateur_ecs_collection: {
+          generateur_ecs: [
+            {
+              donnee_entree: {
+                enum_type_stockage_ecs_id: 2,
+                enum_type_energie_id: 2,
+                volume_stockage: 100
+              }
+            },
+            {
+              donnee_entree: {
+                enum_type_stockage_ecs_id: 2,
+                enum_type_energie_id: 2,
+                volume_stockage: 150
+              }
+            },
+            {
+              donnee_entree: {
+                enum_type_stockage_ecs_id: 1,
+                enum_type_energie_id: 2,
+                volume_stockage: 150
+              }
+            }
+          ]
+        }
+      };
+
+      service.execute(installationsEcs);
+
+      expect(
+        installationsEcs.generateur_ecs_collection.generateur_ecs[0].donnee_utilisateur.Qgw
+      ).toBeCloseTo(851814.112128, 2);
+      expect(
+        installationsEcs.generateur_ecs_collection.generateur_ecs[1].donnee_utilisateur.Qgw
+      ).toBeCloseTo(1064620.98719, 2);
+      expect(
+        installationsEcs.generateur_ecs_collection.generateur_ecs[2].donnee_utilisateur.Qgw
+      ).toBe(0);
+    });
+  });
+
+  test("Determination du type d'énergie électrique du générateur", () => {
+    vi.spyOn(tvStore, 'getElectriqueEcsGenerateurs').mockReturnValue([1]);
+    expect(service.generateurElectrique({ enum_type_generateur_ecs_id: 1 })).toBeTruthy();
+    expect(service.generateurElectrique({ enum_type_generateur_ecs_id: 2 })).toBeFalsy();
+    expect(tvStore.getElectriqueEcsGenerateurs).toHaveBeenCalled();
+  });
+
+  test('Determination du type de stockage du générateur', () => {
+    expect(service.typeStockage({ enum_type_stockage_ecs_id: 1 })).toBe(TypeStockage.INSTANTANE);
+    expect(service.typeStockage({ enum_type_stockage_ecs_id: 2 })).toBe(TypeStockage.INDEPENDANT);
+    expect(service.typeStockage({ enum_type_stockage_ecs_id: 3 })).toBe(TypeStockage.INTEGRE);
+  });
+});

package/features/engine/domain/ecs/installation-ecs.service.js

@@ -0,0 +1,156 @@
+import { GenerateurEcsService } from './generateur-ecs.service.js';
+import { inject } from 'dioma';
+
+/**
+ * Calcul des besoins et pertes des installations ECS
+ * Données calculées
+ *  — besoin_ecs : besoin en eau chaude sanitaire en mode conventionnel proratisé pour l'installation
+ *  — besoin_ecs_depensier : besoin en eau chaude sanitaire en mode dépensier proratisé pour l'installation
+ *  — besoin_ecs_depensier : pertes liées au stockage de l'ECS pour chaque générateur
+ *  — QdwIndVc: pertes de la distribution individuelle en volume chauffé pour le mois j (Wh)
+ *  — QdwColVc: pertes de la distribution collective en volume chauffé pour le mois j (Wh)
+ *  — QdwColHVc: pertes de la distribution collective hors volume chauffé pour le mois j (Wh)
+ *
+ * @see Méthode de calcul 3CL-DPE 2021 (cotobre 2021) chapitre 3
+ */
+export class InstallationEcsService {
+  /**
+   * @type {GenerateurEcsService}
+   */
+  #generateurEcsService;
+
+  /**
+   * @param generateurEcsService {GenerateurEcsService}
+   */
+  constructor(generateurEcsService = inject(GenerateurEcsService)) {
+    this.#generateurEcsService = generateurEcsService;
+  }
+
+  /**
+   * Détermination des besoins et pertes des installations ECS
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @param besoinEcs {{besoin_ecs: number, besoin_ecs_depensier: number}}
+   */
+  execute(ctx, logement, besoinEcs) {
+    const installationsEcs = logement.installation_ecs_collection?.installation_ecs || [];
+
+    installationsEcs.forEach((installationEcs) => {
+      /**
+       * Calcul des données nécessaires au calcul pour chaque générateur (perteStockage)
+       */
+      this.#generateurEcsService.execute(installationEcs);
+
+      const { besoinEcsInstallation, besoinEcsDepensierInstallation } = this.besoinEcsInstallation(
+        ctx,
+        installationEcs,
+        besoinEcs
+      );
+
+      installationEcs.donnee_intermediaire = {
+        besoin_ecs: besoinEcsInstallation,
+        besoin_ecs_depensier: besoinEcsDepensierInstallation
+      };
+
+      /**
+       * Calcul des pertes de stockage et génération au niveau de l'installation
+       */
+      this.pertesDistributionStockageEcsInstallation(
+        installationEcs,
+        besoinEcsInstallation,
+        besoinEcsDepensierInstallation
+      );
+    });
+  }
+
+  /**
+   * Return true si l'installation est individuelle
+   * @param installationEcsDE {InstallationEcsDE}
+   */
+  isInstallationIndividuelle(installationEcsDE) {
+    return parseInt(installationEcsDE.enum_type_installation_id) === 1;
+  }
+
+  /**
+   * Return le besoin rationalisé de l'installation par rapport au besoin glbal du logement
+   *
+   * @param ctx {Contexte}
+   * @param installationEcs {InstallationEcs}
+   * @param besoinEcs {{besoin_ecs: number, besoin_ecs_depensier: number}} besoin ECS total du logement
+   *
+   * @returns {{besoinEcsInstallation: number, besoinEcsDepensierInstallation: number}}
+   */
+  besoinEcsInstallation(ctx, installationEcs, besoinEcs) {
+    /** @type {InstallationEcsDE} */
+    const installationEcsDE = installationEcs.donnee_entree;
+
+    let besoinEcsInstallation;
+    let besoinEcsDepensierInstallation;
+
+    const ratio =
+      (installationEcsDE.surface_habitable || ctx.surfaceHabitable) / ctx.surfaceHabitable;
+    besoinEcsInstallation = besoinEcs.besoin_ecs * ratio;
+    besoinEcsDepensierInstallation = besoinEcs.besoin_ecs_depensier * ratio;
+
+    return { besoinEcsInstallation, besoinEcsDepensierInstallation };
+  }
+
+  /**
+   * Pertes de distribution et stockage ECS au niveau de l'installation
+   * 15.2.3 - Consommation des auxiliaires de distribution d’ECS
+   *
+   * QdwIndVc: pertes de la distribution individuelle en volume chauffé pour le mois j (Wh)
+   * QdwColVc: pertes de la distribution collective en volume chauffé pour le mois j (Wh)
+   * QdwColHVc: pertes de la distribution collective hors volume chauffé pour le mois j (Wh)
+   *
+   * 11.6.1 - Pertes de stockage des ballons d’accumulation
+   * 11.6.2 - Pertes des ballons électriques
+   * Qgw:  pertes brutes annuelles de stockage (Wh)
+   *
+   * @param installationEcs {InstallationEcs}
+   * @param besoinEcsInstallation {number}
+   * @param besoinEcsDepensierInstallation {number}
+   */
+  pertesDistributionStockageEcsInstallation(
+    installationEcs,
+    besoinEcsInstallation,
+    besoinEcsDepensierInstallation
+  ) {
+    /** @type {InstallationEcsDE}*/
+    const installationEcsDE = installationEcs.donnee_entree;
+    const installationIndividuelle = this.isInstallationIndividuelle(installationEcsDE);
+
+    installationEcs.donnee_utilisateur = {
+      QdwIndVc: {
+        conventionnel: 0.1 * besoinEcsInstallation,
+        depensier: 0.1 * besoinEcsDepensierInstallation
+      },
+      QdwColVc: {
+        conventionnel: installationIndividuelle ? 0 : 0.112 * besoinEcsInstallation,
+        depensier: installationIndividuelle ? 0 : 0.112 * besoinEcsDepensierInstallation
+      },
+      QdwColHVc: {
+        conventionnel: installationIndividuelle ? 0 : 0.028 * besoinEcsInstallation,
+        depensier: installationIndividuelle ? 0 : 0.028 * besoinEcsDepensierInstallation
+      }
+    };
+
+    // 17.2.1.1 Calcul des consommations de chauffage, de refroidissement, d’ECS et d’auxiliaires
+    // Pour les installations ECS collectives, pas de récupération de stockage d'ECS
+    installationEcs.donnee_utilisateur.QgwRecuperable = 0;
+    if (installationIndividuelle) {
+      installationEcs.donnee_utilisateur.QgwRecuperable =
+        installationEcs.generateur_ecs_collection?.generateur_ecs
+          .filter(
+            (generateurEcs) =>
+              parseInt(generateurEcs.donnee_entree.position_volume_chauffe_stockage) === 1 ||
+              (generateurEcs.donnee_entree.position_volume_chauffe_stockage === undefined &&
+                parseInt(generateurEcs.donnee_entree.position_volume_chauffe) === 1)
+          )
+          .reduce((acc, generateurEcs) => {
+            return acc + generateurEcs.donnee_utilisateur.Qgw;
+          }, 0);
+    }
+  }
+}