@open3cl/engine 1.0.13 → 1.0.15

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

@@ -0,0 +1,39 @@
+import { inject } from 'dioma';
+import { GenerateurChService } from './generateur-ch.service.js';
+
+/**
+ * Calcul des installations de chauffage
+ *
+ * @see Méthode de calcul 3CL-DPE 2021 (cotobre 2021) chapitre 3
+ */
+export class InstallationChService {
+  /**
+   * @type {GenerateurChService}
+   */
+  #generateurChService;
+
+  /**
+   * @param generateurChService {GenerateurChService}
+   */
+  constructor(generateurChService = inject(GenerateurChService)) {
+    this.#generateurChService = generateurChService;
+  }
+
+  /**
+   * Détermination des données des installations de chauffage
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   */
+  execute(ctx, logement) {
+    const installationsChauffage =
+      logement.installation_chauffage_collection?.installation_chauffage || [];
+
+    installationsChauffage.forEach((installationChauffage) => {
+      /**
+       * Calcul des données nécessaires au calcul pour chaque générateur (qp0)
+       */
+      this.#generateurChService.execute(ctx, logement, installationChauffage);
+    });
+  }
+}

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

@@ -0,0 +1,41 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { InstallationChService } from './installation-ch.service.js';
+import { GenerateurChService } from './generateur-ch.service.js';
+
+/** @type {InstallationChService} **/
+let service;
+
+/** @type {GenerateurChService} **/
+let generateurChService;
+
+describe('Calcul des installations de chauffage', () => {
+  beforeEach(() => {
+    generateurChService = new GenerateurChService();
+    service = new InstallationChService(generateurChService);
+  });
+
+  test('Calcul des données des générateurs de chaque installation de chauffage', () => {
+    vi.spyOn(generateurChService, 'execute').mockReturnThis();
+
+    /** @type {InstallationChauffage} */
+    const installationCh = {
+      donnee_entree: { enum_type_installation_id: 1 },
+      generateur_chauffage_collection: {
+        generateur_chauffage: [{ donnee_entree: { position_volume_chauffe_stockage: 1 } }]
+      }
+    };
+
+    /** @type {Logement} */
+    const logement = {
+      installation_chauffage_collection: { installation_chauffage: [installationCh] }
+    };
+
+    /** @type {Contexte} */
+    const ctx = {
+      zoneClimatique: { id: 1 }
+    };
+
+    service.execute(ctx, logement);
+    expect(generateurChService.execute).toHaveBeenCalledWith(ctx, logement, installationCh);
+  });
+});

package/features/engine/domain/conso/conso.service.js

@@ -0,0 +1,26 @@
+import { inject } from 'dioma';
+import { ConsoFroidService } from './froid/conso-froid.service.js';
+
+export class ConsoService {
+  /**
+   * @type {ConsoFroidService}
+   */
+  #consoFroidService;
+
+  /**
+   * @param consoFroidService {ConsoFroidService}
+   */
+  constructor(consoFroidService = inject(ConsoFroidService)) {
+    this.#consoFroidService = consoFroidService;
+  }
+
+  /**
+   * Calcul des consommations
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   */
+  execute(ctx, logement) {
+    this.#consoFroidService.execute(ctx, logement);
+  }
+}

package/features/engine/domain/conso/conso.service.spec.js

@@ -0,0 +1,29 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { ConsoFroidService } from './froid/conso-froid.service.js';
+import { ConsoService } from './conso.service.js';
+
+/** @type {ConsoService} **/
+let service;
+
+/** @type {ConsoFroidService} **/
+let consoFroidService;
+
+describe('Calcul des consos du logement', () => {
+  beforeEach(() => {
+    consoFroidService = new ConsoFroidService();
+    service = new ConsoService(consoFroidService);
+  });
+
+  test('Determination des consommmations du logement', () => {
+    vi.spyOn(consoFroidService, 'execute').mockReturnThis();
+
+    /** @type {Contexte} */
+    const ctx = { zoneClimatique: { id: 1 }, nadeq: 2.5 };
+    /** @type { Logement } **/
+    const logement = { enveloppe: {} };
+
+    service.execute(ctx, logement);
+
+    expect(consoFroidService.execute).toHaveBeenCalledWith(ctx, logement);
+  });
+});

package/features/engine/domain/conso/froid/conso-froid.service.js

@@ -0,0 +1,94 @@
+import { inject } from 'dioma';
+import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
+
+/**
+ * Calcul de la consommation en froid
+ * Chapitre 10.3 - Les consommations de refroidissement
+ *
+ * Methode_de_calcul_3CL_DPE_2021 - Page 69
+ * Octobre 2021
+ * @see consolide_anne…arrete_du_31_03_2021_relatif_aux_methodes_et_procedures_applicables.pdf
+ */
+export class ConsoFroidService {
+  /**
+   * @type {FrTvStore}
+   */
+  #frStore;
+
+  /**
+   * @param frStore {FrTvStore}
+   */
+  constructor(frStore = inject(FrTvStore)) {
+    this.#frStore = frStore;
+  }
+
+  /**
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @return {{besoin_fr: number, besoin_fr_depensier: number}}
+   */
+  execute(ctx, logement) {
+    const climatisations = logement.climatisation_collection?.climatisation || [];
+
+    climatisations.forEach((climatisation) => {
+      const consos = this.consoFroid(ctx, logement.sortie.apport_et_besoin, climatisation);
+
+      climatisation.donnee_intermediaire ??= {};
+      climatisation.donnee_intermediaire.besoin_fr = consos.besoin_fr;
+      climatisation.donnee_intermediaire.besoin_fr_depensier = consos.besoin_fr_depensier;
+      climatisation.donnee_intermediaire.conso_fr = consos.conso_fr;
+      climatisation.donnee_intermediaire.conso_fr_depensier = consos.conso_fr_depensier;
+    });
+  }
+
+  /**
+   * Calcul de la consommation en froid d'un système de refroidissement
+   *
+   * @param ctx {Contexte}
+   * @param apportEtBesoin {ApportEtBesoin}
+   * @param climatisation {Climatisation}
+   * @returns {{besoin_fr: number, besoin_fr_depensier: number, conso_fr: number, conso_fr_depensier: number}}
+   */
+  consoFroid(ctx, apportEtBesoin, climatisation) {
+    let eer;
+
+    /** @type {ClimatisationDE} **/
+    const climatisationDE = climatisation.donnee_entree;
+
+    /** @type {ClimatisationDI} **/
+    const climatisationDI = climatisation.donnee_intermediaire || {};
+
+    const ratioSurfaceClimatisation =
+      (climatisationDE.surface_clim || ctx.surfaceHabitable) / ctx.surfaceHabitable;
+    const besoin_fr = apportEtBesoin.besoin_fr * ratioSurfaceClimatisation;
+    const besoin_fr_depensier = apportEtBesoin.besoin_fr_depensier * ratioSurfaceClimatisation;
+
+    /**
+     * Si la méthode de saisie n'est pas "Valeur forfaitaire" mais "caractéristiques saisies"
+     * Documentation 3CL : "Pour les installations récentes ou recommandées, les caractéristiques réelles des chaudières présentées sur les bases
+     * de données professionnelles peuvent être utilisées."
+     *
+     * 6 - caractéristiques saisies à partir de la plaque signalétique ou d'une documentation technique du système thermodynamique : scop/cop/eer
+     * 7 - déterminé à partir du rset/rsee( etude rt2012/re2020)
+     * 8 - seer saisi pour permettre la saisie de réseau de froid ou de système de climatisations qui ne sont pas éléctriques
+     */
+    if (
+      ![6, 7, 8].includes(parseInt(climatisationDE.enum_methode_saisie_carac_sys_id)) ||
+      !climatisationDI.eer
+    ) {
+      eer = this.#frStore.getEer(
+        ctx.zoneClimatique.id,
+        parseInt(climatisationDE.enum_periode_installation_fr_id)
+      );
+    } else {
+      eer = climatisationDI.eer;
+    }
+
+    return {
+      besoin_fr,
+      besoin_fr_depensier,
+      conso_fr: (0.9 * besoin_fr) / eer,
+      conso_fr_depensier: (0.9 * besoin_fr_depensier) / eer
+    };
+  }
+}

package/features/engine/domain/conso/froid/conso-froid.service.spec.js

@@ -0,0 +1,152 @@
+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 { ConsoFroidService } from './conso-froid.service.js';
+
+/** @type {ConsoFroidService} **/
+let service;
+
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
+/** @type {FrTvStore} **/
+let tvStore;
+
+describe('Calcul des consos en froid du logement', () => {
+  beforeEach(() => {
+    tvStore = new FrTvStore();
+    service = new ConsoFroidService(tvStore);
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
+  });
+
+  test.each([
+    {
+      label: 'Climatisation avec méthode de saisie 6, sans surface clim',
+      enumMethodeSaisieCaracSysId: 6,
+      eerInitial: 125,
+      expected: { conso_fr: 7.2, conso_fr_depensier: 10.8 }
+    },
+    {
+      label: 'Climatisation avec méthode de saisie 7, sans surface clim',
+      enumMethodeSaisieCaracSysId: 7,
+      eerInitial: 125,
+      expected: { conso_fr: 7.2, conso_fr_depensier: 10.8 }
+    },
+    {
+      label: 'Climatisation avec méthode de saisie 8, sans surface clim',
+      enumMethodeSaisieCaracSysId: 8,
+      eerInitial: 125,
+      expected: { conso_fr: 7.2, conso_fr_depensier: 10.8 }
+    },
+    {
+      label: 'Climatisation avec méthode de saisie 6, avec surface clim',
+      enumMethodeSaisieCaracSysId: 6,
+      eerInitial: 125,
+      surfaceClim: 80,
+      expected: { conso_fr: 5.76, conso_fr_depensier: 8.64 }
+    },
+    {
+      label: 'Climatisation avec méthode de saisie 7, avec surface clim',
+      enumMethodeSaisieCaracSysId: 7,
+      eerInitial: 125,
+      surfaceClim: 80,
+      expected: { conso_fr: 5.76, conso_fr_depensier: 8.64 }
+    },
+    {
+      label: 'Climatisation avec méthode de saisie 8, avec surface clim',
+      enumMethodeSaisieCaracSysId: 8,
+      eerInitial: 125,
+      surfaceClim: 80,
+      expected: { conso_fr: 5.76, conso_fr_depensier: 8.64 }
+    },
+    {
+      label: 'Climatisation avec méthode de saisie 5, sans surface clim',
+      enumMethodeSaisieCaracSysId: 5,
+      eer: 90,
+      expected: { conso_fr: 10, conso_fr_depensier: 15 }
+    },
+    {
+      label: 'Climatisation avec méthode de saisie 5, avec surface clim',
+      enumMethodeSaisieCaracSysId: 5,
+      eer: 90,
+      surfaceClim: 80,
+      expected: { conso_fr: 8, conso_fr_depensier: 12 }
+    }
+  ])(
+    'Détermination des consommations des systèmes de refroidissement pour $label',
+    ({
+      enumMethodeSaisieCaracSysId,
+      surfaceClim = undefined,
+      eer = undefined,
+      eerInitial,
+      expected
+    }) => {
+      vi.spyOn(tvStore, 'getEer').mockReturnValue(eer);
+
+      /** @type {Contexte} */
+      const contexte = {
+        zoneClimatique: { id: 1 },
+        surfaceHabitable: 100
+      };
+
+      /** @type {Climatisation} */
+      const climatisation = {
+        donnee_entree: {
+          enum_methode_saisie_carac_sys_id: enumMethodeSaisieCaracSysId,
+          surface_clim: surfaceClim
+        },
+        donnee_intermediaire: { eer: eerInitial }
+      };
+
+      /** @type {ApportEtBesoin} */
+      const apportEtBesoin = {
+        besoin_fr: 1000,
+        besoin_fr_depensier: 1500
+      };
+
+      const consoFroid = service.consoFroid(contexte, apportEtBesoin, climatisation);
+      expect(consoFroid.conso_fr).toBeCloseTo(expected.conso_fr, 2);
+      expect(consoFroid.conso_fr_depensier).toBeCloseTo(expected.conso_fr_depensier, 2);
+    }
+  );
+
+  describe("Test d'intégration pour le besoin en froid", () => {
+    test.each(corpus)('vérification des sorties besoin_fr et conso_fr pour dpe %s', (ademeId) => {
+      /**
+       * @type {Dpe}
+       */
+      let dpeRequest = getAdemeFileJson(ademeId);
+      dpeRequest = normalizerService.normalize(dpeRequest);
+
+      /** @type {Contexte} */
+      const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+      const climatisations = structuredClone(
+        dpeRequest.logement.climatisation_collection?.climatisation || []
+      );
+      service.execute(ctx, dpeRequest.logement);
+
+      climatisations.forEach((climatisation, i) => {
+        console.log('climatisation.donnee_intermediaire.besoin_fr');
+        expect(climatisation.donnee_intermediaire.besoin_fr).toBeCloseTo(
+          dpeRequest.logement.climatisation_collection.climatisation[i].donnee_intermediaire
+            .besoin_fr,
+          2
+        );
+        console.log(climatisation.donnee_intermediaire.conso_fr);
+        expect(climatisation.donnee_intermediaire.conso_fr).toBeCloseTo(
+          dpeRequest.logement.climatisation_collection.climatisation[i].donnee_intermediaire
+            .conso_fr,
+          2
+        );
+      });
+    });
+  });
+});

package/features/engine/domain/contexte.builder.js

@@ -36,6 +36,7 @@ export class ContexteBuilder {
       typeHabitation: this.#getTypeHabitation(caracteristiqueGenerale),
       typeDpe: typeDpe,
       enumPeriodeConstructionId: caracteristiqueGenerale.enum_periode_construction_id?.toString(),
+      anneeConstruction: parseInt(caracteristiqueGenerale.annee_construction),
       effetJoule: this.#hasEffetJoule(dpe),
       surfaceHabitable: surfaceHabitable,
       hauteurSousPlafond: caracteristiqueGenerale.hsp,

package/features/engine/domain/contexte.builder.spec.js

@@ -106,6 +106,7 @@ describe('Generateur du contexte du calcul', () => {
           enum_classe_altitude_id: 2
         },
         caracteristique_generale: {
+          annee_construction: 2005,
           enum_periode_construction_id: 4,
           surface_habitable_logement: 48.9,
           surface_habitable_immeuble: 105,
@@ -120,6 +121,7 @@ describe('Generateur du contexte du calcul', () => {
       surfaceHabitable: dpe.logement.caracteristique_generale.surface_habitable_logement,
       typeHabitation: TypeHabitation.MAISON,
       typeDpe: TypeDpe.MAISON,
+      anneeConstruction: 2005,
       enumPeriodeConstructionId: '4',
       hauteurSousPlafond: 2.8,
       nombreAppartement: 18,

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

@@ -21,12 +21,12 @@ export class GenerateurEcsService {
   }
 
   /**
-   * Détermination des apports et besoins pour le bien concerné
+   * Détermination des données de calcul pour une installation ECS
    *
    * @param installationEcs {InstallationEcs}
    */
   execute(installationEcs) {
-    const generateursEcs = installationEcs.generateur_ecs_collection.generateur_ecs || [];
+    const generateursEcs = installationEcs.generateur_ecs_collection?.generateur_ecs || [];
 
     generateursEcs.forEach((generateurEcs) => {
       /** @type {GenerateurEcsDE}*/

package/features/engine/domain/engine.service.js

@@ -3,6 +3,7 @@ import { ContexteBuilder } from './contexte.builder.js';
 import { DeperditionEnveloppeService } from './enveloppe/deperdition-enveloppe.service.js';
 import { logger } from '../../../core/util/logger/log-service.js';
 import { ApportEtBesoinService } from './apport_et_besoin/apport-et-besoin.service.js';
+import { ConsoService } from './conso/conso.service.js';
 
 export class EngineService {
   /**
@@ -15,6 +16,11 @@ export class EngineService {
    */
   #apportEtBesoinService;
 
+  /**
+   * @type {ConsoService}
+   */
+  #consoService;
+
   /**
    * @type {ContexteBuilder}
    */
@@ -23,15 +29,18 @@ export class EngineService {
   /**
    * @param deperditionService {DeperditionEnveloppeService}
    * @param apportEtBesoinService {ApportEtBesoinService}
+   * @param consoService {ConsoService}
    * @param contextBuilder {ContexteBuilder}
    */
   constructor(
     deperditionService = inject(DeperditionEnveloppeService),
     apportEtBesoinService = inject(ApportEtBesoinService),
+    consoService = inject(ConsoService),
     contextBuilder = inject(ContexteBuilder)
   ) {
     this.#deperditionService = deperditionService;
     this.#apportEtBesoinService = apportEtBesoinService;
+    this.#consoService = consoService;
     this.#contextBuilder = contextBuilder;
   }
 
@@ -98,6 +107,7 @@ export class EngineService {
     // Calcul des consommations chauffage
 
     // Calcul des consommations de froid
+    this.#consoService.execute(ctx, proceededDpe.logement);
 
     // Calcul des consommations ECS
 

package/features/engine/domain/models/contexte.model.ts

@@ -4,6 +4,7 @@ export interface Contexte {
   typeHabitation: TypeHabitation;
   typeDpe: TypeDpe;
   enumPeriodeConstructionId: number;
+  anneeConstruction: number;
   surfaceHabitable: number;
   hauteurSousPlafond: number;
   nombreAppartement: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open3cl/engine",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {