@open3cl/engine 1.0.10 → 1.0.12

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

@@ -0,0 +1,284 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import { GenerateurEcsService } from './generateur-ecs.service.js';
+import { InstallationEcsService } from './installation-ecs.service.js';
+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';
+
+/** @type {InstallationEcsService} **/
+let service;
+
+/** @type {GenerateurEcsService} **/
+let generateurEcsService;
+
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
+describe('Calcul des besoins et des pertes des installations ECS', () => {
+  beforeEach(() => {
+    generateurEcsService = new GenerateurEcsService();
+    service = new InstallationEcsService(generateurEcsService);
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
+  });
+
+  test.each([
+    {
+      label: "Installation ECS sans surface habitable pour l'installation",
+      surfaceHabitableLogement: 40,
+      besoin_ecs: 850,
+      besoin_ecs_depensier: 1050,
+      expected: { besoinEcsDepensierInstallation: 1050, besoinEcsInstallation: 850 }
+    },
+    {
+      label: "Installation ECS avec surface habitable pour l'installation",
+      surfaceHabitableLogement: 40,
+      surfaceHabitableInstallation: 50,
+      besoin_ecs: 850,
+      besoin_ecs_depensier: 1050,
+      expected: { besoinEcsDepensierInstallation: 1312.5, besoinEcsInstallation: 1062.5 }
+    }
+  ])(
+    'Calcul des besoins proratisés pour $label',
+    ({
+      surfaceHabitableLogement,
+      surfaceHabitableInstallation = undefined,
+      besoin_ecs,
+      besoin_ecs_depensier,
+      expected
+    }) => {
+      /** @type {Contexte} */
+      const ctx = { surfaceHabitable: surfaceHabitableLogement };
+
+      /** @type {{besoin_ecs: number, besoin_ecs_depensier: number}} */
+      const besoinEcs = { besoin_ecs, besoin_ecs_depensier };
+
+      /** @type {InstallationEcs} */
+      const installationEcs = {
+        donnee_entree: { surface_habitable: surfaceHabitableInstallation }
+      };
+
+      const besoinEcsInstallation = service.besoinEcsInstallation(ctx, installationEcs, besoinEcs);
+
+      expect(besoinEcsInstallation).toStrictEqual(expected);
+    }
+  );
+
+  test.each([
+    {
+      label: 'Installation individuelle avec générateur hors volume chauffé',
+      enumTypeInstallationId: 1,
+      positionVolumeChauffeStockage1: 0,
+      positionVolumeChauffeStockage2: 0,
+      positionVolumeChauffeStockage3: 0,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 0, depensier: 0 },
+        QdwColHVc: { conventionnel: 0, depensier: 0 },
+        QgwRecuperable: 0
+      }
+    },
+    {
+      label: 'Installation individuelle avec générateur hors volume chauffé',
+      enumTypeInstallationId: 1,
+      positionVolumeChauffeStockage2: 0,
+      positionVolumeChauffe2: 0,
+      positionVolumeChauffeStockage3: 0,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 0, depensier: 0 },
+        QdwColHVc: { conventionnel: 0, depensier: 0 },
+        QgwRecuperable: 0
+      }
+    },
+    {
+      label: 'Installation individuelle avec 1 générateur en volume chauffé',
+      enumTypeInstallationId: 1,
+      positionVolumeChauffeStockage1: 0,
+      positionVolumeChauffeStockage2: 1,
+      positionVolumeChauffeStockage3: 0,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 0, depensier: 0 },
+        QdwColHVc: { conventionnel: 0, depensier: 0 },
+        QgwRecuperable: 120
+      }
+    },
+    {
+      label: 'Installation individuelle avec 1 générateur en volume chauffé',
+      enumTypeInstallationId: 1,
+      positionVolumeChauffeStockage1: 0,
+      positionVolumeChauffe2: 1,
+      positionVolumeChauffeStockage3: 0,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 0, depensier: 0 },
+        QdwColHVc: { conventionnel: 0, depensier: 0 },
+        QgwRecuperable: 120
+      }
+    },
+    {
+      label: 'Installation individuelle avec 2 générateurs en volume chauffé',
+      enumTypeInstallationId: 1,
+      positionVolumeChauffeStockage1: 0,
+      positionVolumeChauffeStockage2: 1,
+      positionVolumeChauffeStockage3: 1,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 0, depensier: 0 },
+        QdwColHVc: { conventionnel: 0, depensier: 0 },
+        QgwRecuperable: 260
+      }
+    },
+    {
+      label: 'Installation collective avec générateur hors volume chauffé',
+      enumTypeInstallationId: 2,
+      positionVolumeChauffeStockage1: 0,
+      positionVolumeChauffeStockage2: 0,
+      positionVolumeChauffeStockage3: 0,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 16.8, depensier: 30.24 },
+        QdwColHVc: { conventionnel: 4.2, depensier: 7.56 },
+        QgwRecuperable: 0
+      }
+    },
+    {
+      label: 'Installation collective avec 1 générateur en volume chauffé',
+      enumTypeInstallationId: 2,
+      positionVolumeChauffeStockage1: 0,
+      positionVolumeChauffeStockage2: 0,
+      positionVolumeChauffeStockage3: 1,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 16.8, depensier: 30.24 },
+        QdwColHVc: { conventionnel: 4.2, depensier: 7.56 },
+        QgwRecuperable: 0
+      }
+    },
+    {
+      label: 'Installation collective avec 2 générateurs en volume chauffé',
+      enumTypeInstallationId: 2,
+      positionVolumeChauffeStockage1: 1,
+      positionVolumeChauffeStockage2: 1,
+      positionVolumeChauffeStockage3: 0,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 16.8, depensier: 30.24 },
+        QdwColHVc: { conventionnel: 4.2, depensier: 7.56 },
+        QgwRecuperable: 0
+      }
+    }
+  ])(
+    'Calcul des pertes de distribution et de stockage $label',
+    ({
+      enumTypeInstallationId,
+      positionVolumeChauffeStockage1,
+      positionVolumeChauffeStockage2,
+      positionVolumeChauffe2 = undefined,
+      positionVolumeChauffeStockage3,
+      expected
+    }) => {
+      /** @type {InstallationEcs} */
+      const installationEcs = {
+        donnee_entree: { enum_type_installation_id: enumTypeInstallationId },
+        generateur_ecs_collection: {
+          generateur_ecs: [
+            {
+              donnee_entree: { position_volume_chauffe_stockage: positionVolumeChauffeStockage1 },
+              donnee_utilisateur: { Qgw: 100 }
+            },
+            {
+              donnee_entree: {
+                position_volume_chauffe_stockage: positionVolumeChauffeStockage2,
+                position_volume_chauffe: positionVolumeChauffe2
+              },
+              donnee_utilisateur: { Qgw: 120 }
+            },
+            {
+              donnee_entree: { position_volume_chauffe_stockage: positionVolumeChauffeStockage3 },
+              donnee_utilisateur: { Qgw: 140 }
+            }
+          ]
+        }
+      };
+
+      service.pertesDistributionStockageEcsInstallation(installationEcs, 150, 270);
+
+      expect(installationEcs.donnee_utilisateur.QdwIndVc.conventionnel).toBeCloseTo(
+        expected.QdwIndVc.conventionnel,
+        5
+      );
+      expect(installationEcs.donnee_utilisateur.QdwIndVc.depensier).toBeCloseTo(
+        expected.QdwIndVc.depensier,
+        5
+      );
+      expect(installationEcs.donnee_utilisateur.QdwColVc.conventionnel).toBeCloseTo(
+        expected.QdwColVc.conventionnel,
+        5
+      );
+      expect(installationEcs.donnee_utilisateur.QdwColVc.depensier).toBeCloseTo(
+        expected.QdwColVc.depensier,
+        5
+      );
+      expect(installationEcs.donnee_utilisateur.QdwColHVc.conventionnel).toBeCloseTo(
+        expected.QdwColHVc.conventionnel,
+        5
+      );
+      expect(installationEcs.donnee_utilisateur.QdwColHVc.depensier).toBeCloseTo(
+        expected.QdwColHVc.depensier,
+        5
+      );
+      expect(installationEcs.donnee_utilisateur.QgwRecuperable).toBeCloseTo(
+        expected.QgwRecuperable,
+        5
+      );
+    }
+  );
+
+  test("Determination du caractère individuelle de l'installation", () => {
+    expect(service.isInstallationIndividuelle({ enum_type_installation_id: 1 })).toBeTruthy();
+    expect(service.isInstallationIndividuelle({ enum_type_installation_id: 2 })).toBeFalsy();
+    expect(service.isInstallationIndividuelle({ enum_type_installation_id: 3 })).toBeFalsy();
+    expect(service.isInstallationIndividuelle({ enum_type_installation_id: 4 })).toBeFalsy();
+  });
+
+  describe("Test d'intégration des installations ECS", () => {
+    test.each(corpus)('vérification des DI des installations ECS pour dpe %s', (ademeId) => {
+      let dpeRequest = getAdemeFileJson(ademeId);
+      dpeRequest = normalizerService.normalize(dpeRequest);
+
+      /** @type {Contexte} */
+      const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+      const installationsECS = structuredClone(
+        dpeRequest.logement.installation_ecs_collection?.installation_ecs || []
+      );
+      service.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
+      });
+
+      installationsECS.forEach((installationECS, i) => {
+        expect_or(
+          () =>
+            expect(installationECS.donnee_intermediaire.besoin_ecs).toBeCloseTo(
+              dpeRequest.logement.installation_ecs_collection.installation_ecs[i]
+                .donnee_intermediaire.besoin_ecs,
+              2
+            ),
+          () =>
+            expect(installationECS.donnee_intermediaire.besoin_ecs).toBeCloseTo(
+              dpeRequest.logement.installation_ecs_collection.installation_ecs[i]
+                .donnee_intermediaire.besoin_ecs * 1000,
+              2
+            )
+        );
+      });
+    });
+  });
+});

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.12",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {