@open3cl/engine 1.0.12 → 1.0.14

package/13.2_generateur_combustion_ch.js

@@ -37,7 +37,7 @@ export function tv_temp_fonc_30_100(di, de, du, em_ch, ac) {
     const em_ch_de = em.donnee_entree;
     const em_ch_du = em.donnee_utilisateur;
     const matcher = {
-      type_generateur_ch_id: de.enum_type_generateur_ch_id,
+      enum_type_generateur_ch_id: de.enum_type_generateur_ch_id,
       enum_temp_distribution_ch_id: requestInputID(em_ch_de, em_ch_du, 'temp_distribution_ch'),
       periode_emetteurs: requestInput(em_ch_de, em_ch_du, 'periode_installation_emetteur')
     };

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

@@ -159,6 +159,15 @@ export interface Logement {
   installation_ecs_collection: { installation_ecs: InstallationEcs[] };
   installation_chauffage_collection: { installation_chauffage: InstallationChauffage[] };
   sortie: Sortie;
+  donnees_de_calcul: LogementDonneesCalcul;
+}
+
+export interface LogementDonneesCalcul {
+  apportsInterneCh: { [key: string]: number };
+  apportsInterneDepensier: { [key: string]: number };
+  apportsSolaire: { [key: string]: number };
+  besoinChauffageHP: { [key: string]: number };
+  besoinChauffageDepensierHP: { [key: string]: number };
 }
 
 export interface Tertiaire extends Logement {}

package/features/dpe/domain/models/installation-chauffage.model.ts

@@ -1,4 +1,5 @@
 import { DE } from './dpe.model';
+import { GenerateurEcsDU } from './installation-ecs.model';
 
 export interface InstallationChauffage {
   donnee_entree?: InstallationChauffageDE;
@@ -62,6 +63,7 @@ export interface EmetteurChauffageDI {
 
 export interface GenerateurChauffage {
   donnee_entree?: GenerateurChauffageDE;
+  donnee_utilisateur?: GenerateurChauffageDU;
   donnee_intermediaire?: GenerateurChauffageDI;
 }
 
@@ -71,7 +73,7 @@ export interface GenerateurChauffageDE extends DE {
   enum_type_generateur_ch_id: number;
   enum_usage_generateur_id: number;
   enum_type_energie_id: number;
-  position_volume_chauffe: boolean;
+  position_volume_chauffe: number;
   tv_rendement_generation_id?: number;
   tv_scop_id?: number;
   tv_temp_fonc_100_id?: number;
@@ -81,7 +83,7 @@ export interface GenerateurChauffageDE extends DE {
   identifiant_reseau_chaleur?: string;
   date_arrete_reseau_chaleur?: string;
   priorite_generateur_cascade?: number;
-  presence_ventouse?: boolean;
+  presence_ventouse?: number;
   presence_regulation_combustion?: boolean;
   enum_methode_saisie_carac_sys_id: number;
   enum_lien_generateur_emetteur_id: number;
@@ -99,3 +101,25 @@ export interface GenerateurChauffageDI {
   conso_ch: number;
   conso_ch_depensier: number;
 }
+
+export interface GenerateurChauffageDU {
+  ratio_virtualisation?: number;
+  typeGenerateur?: TypeGenerateur;
+  combustion: boolean;
+  pac: boolean;
+  generateur?: {
+    tv_generateur_combustion_id: string;
+    enum_type_generateur_ch_id: string;
+    type_generateur: string;
+    critere_pn: string;
+    pveil: string;
+    qp0_perc: string;
+    rpint: string;
+    rpn: string;
+  };
+}
+
+export enum TypeGenerateur {
+  CHAUDIERE = 'CHAUDIERE',
+  OTHER = 'OTHER'
+}

package/features/dpe/domain/models/type-generateur.model.js

@@ -0,0 +1,8 @@
+/**
+ * @type {{[key: string]: string}}
+ */
+export const TypeGenerateur = {
+  COMBUSTION: 'COMBUSTION',
+  PAC: 'PAC',
+  OTHER: 'OTHER'
+};

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

@@ -0,0 +1,94 @@
+import { tvs as tv } from '../../../../tv-v2.js';
+import { TvStore } from './../tv.store.js';
+import { convertExpression } from '../../../../utils.js';
+import enums from '../../../../enums.js';
+import { logger } from '../../../../core/util/logger/log-service.js';
+
+/**
+ * Accès aux données des tables de valeurs pour le chauffage
+ */
+export class ChTvStore extends TvStore {
+  /**
+   * Récupération des ids des générateurs de chauffage à combustion
+   * @return {[number]}
+   */
+  getCombustionGenerateurs() {
+    return this.#getTypeGenerateurChId('generateur_combustion');
+  }
+  /**
+   * Récupération des ids des générateurs de chauffage pompes à chaleur
+   * @return {[number]}
+   */
+  getPacGenerateurs() {
+    return this.#getTypeGenerateurChId('scop');
+  }
+
+  /**
+   * @param tv {string}
+   * @returns {any[]}
+   */
+  #getTypeGenerateurChId(tv) {
+    return [
+      ...new Set(
+        tv[tv].flatMap((v) =>
+          (v.enum_type_generateur_ch_id
+            ? v.enum_type_generateur_ch_id.split('|').map(Number)
+            : []
+          ).filter(Number.isFinite)
+        )
+      )
+    ].sort((a, b) => a - b);
+  }
+
+  /**
+   * Récupération des informations du générateur à combustion
+   * @param enumTypeGenerateurId
+   * @param pn
+   * @return {{tv_generateur_combustion_id: string, enum_type_generateur_ch_id: string, type_generateur: string, critere_pn: string, pveil: string, qp0_perc: string, rpint: string, rpn: string}}
+   */
+  getGenerateurCombustion(enumTypeGenerateurId, pn) {
+    return tv['generateur_combustion'].find(
+      (v) =>
+        v.enum_type_generateur_ch_id &&
+        v.enum_type_generateur_ch_id.split('|').includes(enumTypeGenerateurId) &&
+        (!v.critere_pn ||
+          eval(`let Pn=${pn} ;${convertExpression(v.critere_pn.replace('≤', '<='))}`))
+    );
+  }
+
+  /**
+   * Récupération de la température de fonctionnement
+   *
+   * @param pourcentageFonctionnement pourcentage de fonctionnement du générateur (30% ou 100%)
+   * @param enumTypeGenerateurId
+   * @param enumTemperatureDistribution
+   * @param enumPeriodeEmetteurs
+   * @return {number}
+   */
+  temperatureFonctionnement(
+    pourcentageFonctionnement,
+    enumTypeGenerateurId,
+    enumTemperatureDistribution,
+    enumPeriodeEmetteurs
+  ) {
+    const temperatureDistribution = enums.temp_distribution_ch[enumTemperatureDistribution];
+    const periodeEmetteur = enums.periode_installation_emetteur[enumPeriodeEmetteurs];
+
+    const temperature = tv[`temp_fonc_${pourcentageFonctionnement}`].find(
+      (v) =>
+        (!v.enum_type_generateur_ch_id ||
+          v.enum_type_generateur_ch_id.split('|').includes(enumTypeGenerateurId)) &&
+        v.temp_distribution_ch.toLowerCase() === temperatureDistribution?.toLowerCase() &&
+        v.periode_emetteurs.toLowerCase() === periodeEmetteur?.toLowerCase()
+    );
+
+    if (!temperature) {
+      logger.error(
+        `Pas de valeur forfaitaire temp_fonc_${pourcentageFonctionnement} pour enumTypeGenerateurId:${enumTypeGenerateurId}, enumTemperatureDistribution:${enumTemperatureDistribution}, enumPeriodeEmetteurs:${enumPeriodeEmetteurs}`
+      );
+      return;
+    }
+
+    return parseFloat(temperature[`temp_fonc_${pourcentageFonctionnement}`]);
+  }
+}

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

@@ -0,0 +1,99 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import { ChTvStore } from './chTv.store.js';
+
+/** @type {ChTvStore} **/
+let chTvStore;
+
+describe('Lecture des tables de valeurs', () => {
+  beforeEach(() => {
+    chTvStore = new ChTvStore();
+  });
+
+  test('ids des générateurs de chauffage à combustion', () => {
+    expect(chTvStore.getCombustionGenerateurs()).toStrictEqual([
+      48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+      71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
+      94, 95, 96, 97, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
+      134, 135, 136, 137, 138, 139, 140, 141, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
+      159, 160, 161
+    ]);
+  });
+
+  test('ids des générateurs de chauffage pompe à chaleur', () => {
+    expect(chTvStore.getPacGenerateurs()).toStrictEqual([
+      1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 143, 145, 146, 147, 162,
+      163, 164, 165, 166, 167, 168, 169, 170
+    ]);
+  });
+
+  test('Caractéristique du générateur à combustion', () => {
+    expect(chTvStore.getGenerateurCombustion('128', 125)).toStrictEqual({
+      tv_generateur_combustion_id: '2',
+      enum_type_generateur_ch_id: '86|128',
+      enum_type_generateur_ecs_id: '46|93',
+      type_generateur: 'Chaudière gaz  classique 1981-1985',
+      pn: 'Pn',
+      rpn: '84 + 2 logPn',
+      rpint: '80 + 3 logPn',
+      qp0_perc: '2%',
+      pveil: '150'
+    });
+
+    expect(chTvStore.getGenerateurCombustion('84', 125)).toStrictEqual({
+      tv_generateur_combustion_id: '26',
+      enum_type_generateur_ch_id: '84',
+      enum_type_generateur_ecs_id: '44',
+      type_generateur: 'Chaudière fioul à condensation après 2015',
+      critere_pn: '70<Pn≤400',
+      pn: 'Pn',
+      rpn: '94 + logPn',
+      rpint: '100 + logPn',
+      qp0_perc: '0.60%'
+    });
+  });
+
+  describe('Lecture des valeurs de temp_fonc_30 ou temp_fonc_100', () => {
+    test.each([
+      {
+        label:
+          "Chaudière standard après 1990, emetteurs entre 1981 et 2000, basse température d'émission",
+        pourcentageFonctionnement: 30,
+        enumTypeGenerateurId: '89',
+        enumTemperatureDistribution: 2,
+        enumPeriodeEmetteurs: 2,
+        expected: 45
+      },
+      {
+        label: "Emetteurs entre 1981 et 2000, basse température d'émission",
+        pourcentageFonctionnement: 100,
+        enumTypeGenerateurId: '89',
+        enumTemperatureDistribution: 2,
+        enumPeriodeEmetteurs: 2,
+        expected: 35
+      }
+    ])(
+      `$label`,
+      ({
+        pourcentageFonctionnement,
+        enumTypeGenerateurId,
+        enumTemperatureDistribution,
+        enumPeriodeEmetteurs,
+        expected
+      }) => {
+        expect(
+          chTvStore.temperatureFonctionnement(
+            pourcentageFonctionnement,
+            enumTypeGenerateurId,
+            enumTemperatureDistribution,
+            enumPeriodeEmetteurs
+          )
+        ).toBe(expected);
+      }
+    );
+
+    test('pas de valeur de temp_fonc_30 ou temp_fonc_100', () => {
+      const pertes_stockage = chTvStore.temperatureFonctionnement(100, 600, 600, 600);
+      expect(pertes_stockage).toBeUndefined();
+    });
+  });
+});

package/features/dpe/infrastructure/ecs/ecsTv.store.js

@@ -58,8 +58,10 @@ export class EcsTvStore extends TvStore {
    * @return {[number]}
    */
   getElectriqueEcsGenerateurs() {
-    return tv['pertes_stockage'].flatMap((v) =>
-      v.enum_type_generateur_ecs_id.split('|').map(Number)
-    );
+    return [
+      ...new Set(
+        tv['pertes_stockage'].flatMap((v) => v.enum_type_generateur_ecs_id.split('|').map(Number))
+      )
+    ];
   }
 }

package/features/dpe/infrastructure/ecs/ecsTv.store.spec.js

@@ -66,4 +66,8 @@ describe('Lecture des tables de valeurs', () => {
       expect(pertes_stockage).toBeUndefined();
     });
   });
+
+  test('ids des générateurs électriques ECS', () => {
+    expect(ecsTvStore.getElectriqueEcsGenerateurs()).toStrictEqual([68, 118, 69, 70, 71]);
+  });
 });

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

@@ -15,8 +15,10 @@ export class FrTvStore extends TvStore {
    * — e_fr_28 : ensoleillement reçu en période de refroidissement pour un mois donné et une consigne de refroidissement à 28°C (comportement conventionnel).
    * — textmoy_clim_26 : Température extérieure moyenne pour un mois donné et une consigne de refroidissement à 26°C (comportement conventionnel).
    * — textmoy_clim_28 : nombre d’heures de chauffage pour un mois donné et une consigne de refroidissement à 28°C (comportement conventionnel).
+   * — dh19 : degrés heures de chauffage pour un mois donné à 19°C (comportement conventionnel).
+   * — dh21 : degrés heures de chauffage pour un mois donné à 21°C (comportement dépensier).
    *
-   * @param type {'e', nref26' | 'nref28' | 'e_fr_26' | 'e_fr_28' | 'textmoy_clim_26' | 'textmoy_clim_28'}
+   * @param type {'e', nref26' | 'nref28' | 'e_fr_26' | 'e_fr_28' | 'textmoy_clim_26' | 'textmoy_clim_28'| 'dh19'| 'dh21'}
    * @param classeAltitude {string}
    * @param zoneClimatique {string}
    * @param mois {string}
@@ -31,6 +33,6 @@ export class FrTvStore extends TvStore {
       values = values[ilpa];
     }
 
-    return values[classeAltitude][mois][zoneClimatique];
+    return parseFloat(values[classeAltitude][mois][zoneClimatique]);
   }
 }

package/features/dpe/infrastructure/tv.store.js

@@ -353,4 +353,32 @@ export class TvStore {
 
     return q4paConv;
   }
+
+  /**
+   * Température extérieure de base(°C)
+   *
+   * @param classeAltitude {string}
+   * @param zoneClimatique {string}
+   */
+  getTempBase(classeAltitude, zoneClimatique) {
+    const Tbase = {
+      1: {
+        h1: -9.5,
+        h2: -6.5,
+        h3: -3.5
+      },
+      2: {
+        h1: -11.5,
+        h2: -8.5,
+        h3: -5.5
+      },
+      3: {
+        h1: -13.5,
+        h2: -10.5,
+        h3: -7.5
+      }
+    };
+
+    return Tbase[classeAltitude][zoneClimatique];
+  }
 }

package/features/dpe/infrastructure/tv.store.spec.js

@@ -565,6 +565,18 @@ describe('Lecture des tables de valeurs', () => {
     });
   });
 
+  test('lecture des valeurs de tempBase', () => {
+    expect(tvStore.getTempBase('1', 'h1')).toBe(-9.5);
+    expect(tvStore.getTempBase('1', 'h2')).toBe(-6.5);
+    expect(tvStore.getTempBase('1', 'h3')).toBe(-3.5);
+    expect(tvStore.getTempBase('2', 'h1')).toBe(-11.5);
+    expect(tvStore.getTempBase('2', 'h2')).toBe(-8.5);
+    expect(tvStore.getTempBase('2', 'h3')).toBe(-5.5);
+    expect(tvStore.getTempBase('3', 'h1')).toBe(-13.5);
+    expect(tvStore.getTempBase('3', 'h2')).toBe(-10.5);
+    expect(tvStore.getTempBase('3', 'h3')).toBe(-7.5);
+  });
+
   describe.skip('Benchmark b', () => {
     test('reworked', () => {
       for (let i = 0; i < 1000; i++) {

package/features/engine/domain/apport_et_besoin/apport-et-besoin.service.js

@@ -5,6 +5,9 @@ import { BesoinFroidService } from './froid/besoin-froid.service.js';
 import { ApportGratuitService } from './apport_gratuit/apport-gratuit.service.js';
 import { InstallationEcsService } from '../ecs/installation-ecs.service.js';
 import { PerteEcsRecupService } from './ecs/perte-ecs-recup.service.js';
+import { BesoinChService } from './ch/besoin-ch.service.js';
+import { PerteChRecupService } from './ch/perte-ch-recup.service.js';
+import { InstallationChService } from '../ch/installation-ch.service.js';
 
 /**
  * Calcul des déperditions de l’enveloppe GV
@@ -21,11 +24,21 @@ export class ApportEtBesoinService {
    */
   #besoinEcsService;
 
+  /**
+   * @type {BesoinChService}
+   */
+  #besoinChService;
+
   /**
    * @type {InstallationEcsService}
    */
   #installationEcsService;
 
+  /**
+   * @type {InstallationChService}
+   */
+  #installationChService;
+
   /**
    * @type {PerteEcsRecupService}
    */
@@ -36,6 +49,11 @@ export class ApportEtBesoinService {
    */
   #besoinFroidService;
 
+  /**
+   * @type {PerteChRecupService}
+   */
+  #perteChRecupService;
+
   /**
    * @type {ApportGratuitService}
    */
@@ -43,25 +61,34 @@ export class ApportEtBesoinService {
 
   /**
    * @param besoinEcsService {BesoinEcsService}
+   * @param besoinChService {BesoinChService}
    * @param installationEcsService {InstallationEcsService}
+   * @param installationChService {InstallationChService}
    * @param perteEcsRecupService {PerteEcsRecupService}
    * @param besoinFroidService {BesoinFroidService}
    * @param surfaceSudEquivalenteService {SurfaceSudEquivalenteService}
+   * @param perteChRecupService {PerteChRecupService}
    * @param apportGratuitService {ApportGratuitService}
    */
   constructor(
     besoinEcsService = inject(BesoinEcsService),
+    besoinChService = inject(BesoinChService),
     installationEcsService = inject(InstallationEcsService),
+    installationChService = inject(InstallationChService),
     perteEcsRecupService = inject(PerteEcsRecupService),
     besoinFroidService = inject(BesoinFroidService),
     surfaceSudEquivalenteService = inject(SurfaceSudEquivalenteService),
+    perteChRecupService = inject(PerteChRecupService),
     apportGratuitService = inject(ApportGratuitService)
   ) {
     this.#besoinEcsService = besoinEcsService;
+    this.#besoinChService = besoinChService;
     this.#installationEcsService = installationEcsService;
+    this.#installationChService = installationChService;
     this.#perteEcsRecupService = perteEcsRecupService;
     this.#besoinFroidService = besoinFroidService;
     this.#surfaceSudEquivalenteService = surfaceSudEquivalenteService;
+    this.#perteChRecupService = perteChRecupService;
     this.#apportGratuitService = apportGratuitService;
   }
 
@@ -80,6 +107,31 @@ export class ApportEtBesoinService {
      */
     this.#installationEcsService.execute(ctx, logement, besoinEcs);
 
+    /**
+     * Détermination des données des installations de chauffage
+     */
+    this.#installationChService.execute(ctx, logement);
+
+    const apportsInternes = this.#apportGratuitService.apportInterne(ctx, logement);
+    const apportsSolaires = this.#apportGratuitService.apportSolaire(ctx, logement);
+
+    const pertesEcsRecup = this.#perteEcsRecupService.execute(ctx, logement);
+    // Besoin de chauffage hors pertes récupérées
+    const besoinChHP = this.#besoinChService.execute(ctx, logement);
+    const pertesChauffageRecup = this.#perteChRecupService.execute(ctx, logement);
+
+    const besoinCh = {
+      besoin_ch: besoinChHP.besoin_ch_hp,
+      besoin_ch_depensier: besoinChHP.besoin_ch_depensier_hp
+    };
+    besoinCh.besoin_ch -= pertesEcsRecup.pertes_distribution_ecs_recup;
+    besoinCh.besoin_ch -= pertesEcsRecup.pertes_stockage_ecs_recup;
+    besoinCh.besoin_ch -= pertesChauffageRecup.pertes_generateur_ch_recup;
+
+    besoinCh.besoin_ch_depensier -= pertesEcsRecup.pertes_distribution_ecs_recup_depensier;
+    besoinCh.besoin_ch_depensier -= pertesEcsRecup.pertes_stockage_ecs_recup_depensier;
+    besoinCh.besoin_ch_depensier -= pertesChauffageRecup.pertes_generateur_ch_recup_depensier;
+
     return {
       ...besoinEcs,
       ...{
@@ -92,9 +144,11 @@ export class ApportEtBesoinService {
         v40_ecs_journalier_depensier: ctx.nadeq * 79
       },
       ...this.#besoinFroidService.execute(ctx, logement),
-      ...this.#apportGratuitService.apportInterne(ctx, logement),
-      ...this.#apportGratuitService.apportSolaire(ctx, logement),
-      ...this.#perteEcsRecupService.execute(ctx, logement)
+      ...apportsInternes,
+      ...apportsSolaires,
+      ...pertesEcsRecup,
+      ...pertesChauffageRecup,
+      ...besoinCh
     };
   }
 }