@open3cl/engine 1.0.14 → 1.0.15

package/features/dpe/domain/models/climatisation.model.ts

@@ -8,6 +8,7 @@ export interface Climatisation {
 export interface ClimatisationDE extends DE {
   tv_seer_id?: number;
   nombre_logement_echantillon?: number;
+  surface_clim?: number;
   enum_methode_calcul_conso_id: number;
   enum_periode_installation_fr_id: number;
   cle_repartition_clim?: number;

package/features/dpe/infrastructure/ch/chTv.store.js

@@ -24,13 +24,13 @@ export class ChTvStore extends TvStore {
   }
 
   /**
-   * @param tv {string}
+   * @param tvType {string}
    * @returns {any[]}
    */
-  #getTypeGenerateurChId(tv) {
+  #getTypeGenerateurChId(tvType) {
     return [
       ...new Set(
-        tv[tv].flatMap((v) =>
+        tv[tvType].flatMap((v) =>
           (v.enum_type_generateur_ch_id
             ? v.enum_type_generateur_ch_id.split('|').map(Number)
             : []

package/features/dpe/infrastructure/froid/frTv.store.js

@@ -1,5 +1,6 @@
 import { tvs as tv } from '../../../../tv-v2.js';
 import { TvStore } from './../tv.store.js';
+import { logger } from '../../../../core/util/logger/log-service.js';
 
 /**
  * Accès aux données des tables de valeurs pour le besoin en froid
@@ -35,4 +36,30 @@ export class FrTvStore extends TvStore {
 
     return parseFloat(values[classeAltitude][mois][zoneClimatique]);
   }
+
+  /**
+   * Coefficient d’efficience énergétique
+   * @see 10.3 - Les consommations de refroidissement
+   *
+   * @param zoneClimatiqueId {string}
+   * @param periodeInstallationId {number}
+   *
+   * @return {number|undefined}
+   */
+  getEer(zoneClimatiqueId, periodeInstallationId) {
+    const eer = tv['seer'].find(
+      (v) =>
+        v.enum_zone_climatique_id.split('|').includes(zoneClimatiqueId) &&
+        parseInt(v.enum_periode_installation_fr_id) === periodeInstallationId
+    )?.eer;
+
+    if (!eer) {
+      logger.error(
+        `Pas de valeur forfaitaire eer pour zoneClimatiqueId:${zoneClimatiqueId}, periodeInstallationId:${periodeInstallationId}`
+      );
+      return;
+    }
+
+    return parseFloat(eer);
+  }
 }

package/features/dpe/infrastructure/froid/frTv.store.spec.js

@@ -49,4 +49,26 @@ describe('Lecture des tables de valeurs', () => {
       expect(tvStore.getData(type, '400-800m', 'h1a', 'Juin', ilpa)).toBe(expected);
     });
   });
+
+  describe('Lecture des valeurs de coefficient d’efficience énergétique eer', () => {
+    test.each([
+      {
+        zoneClimatiqueId: '2',
+        periodeInstallationId: 1,
+        expected: 3.6
+      },
+      {
+        zoneClimatiqueId: '8',
+        periodeInstallationId: 2,
+        expected: 5.415
+      }
+    ])(`type: $type, ilpa: $ilpa`, ({ zoneClimatiqueId, periodeInstallationId, expected }) => {
+      expect(tvStore.getEer(zoneClimatiqueId, periodeInstallationId)).toBe(expected);
+    });
+
+    test('pas de valeur de eer', () => {
+      const eer = tvStore.getEer('8', 8);
+      expect(eer).toBeUndefined();
+    });
+  });
 });

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

@@ -1,9 +1,9 @@
 import { inject } from 'dioma';
 import { ChTvStore } from '../../../dpe/infrastructure/ch/chTv.store.js';
-import { TypeGenerateur } from '../../../dpe/domain/models/installation-chauffage.model.js';
 import { excel_to_js_exec } from '../../../../utils.js';
 import { TvStore } from '../../../dpe/infrastructure/tv.store.js';
 import { EmetteurChService } from './emetteur-ch.service.js';
+import { TypeGenerateur } from '../../../dpe/domain/models/type-generateur.model.js';
 
 /**
  * Calcul des données de calcul pour chacun des générateurs

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/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/package.json

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