@open3cl/engine 1.0.8 → 1.0.10

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

@@ -4,8 +4,7 @@ import { Ets } from './ets.model';
 import { InstallationChauffage } from './installation-chauffage.model';
 import { InstallationEcs } from './installation-ecs.model';
 import { Mur } from './mur.model';
-import { PlancherBas } from './plancher-bas.model';
-import { PlancherHaut } from './plancher-haut.model';
+import { PlancherBas, PlancherHaut } from './plancher.model';
 import { PontThermique } from './pont-thermique.model';
 import { Porte } from './porte.model';
 import { ProductionElecEnr } from './production-elec-enr.model';
@@ -187,7 +186,12 @@ export interface DE {
   reference?: string;
 }
 
-enum TypeHabitation {
+export enum TypeHabitation {
+  MAISON = 'MAISON',
+  APPARTEMENT = 'APPARTEMENT',
+  IMMEUBLE = 'IMMEUBLE'
+}
+export enum TypeDpe {
   MAISON = 'MAISON',
   APPARTEMENT = 'APPARTEMENT',
   IMMEUBLE = 'IMMEUBLE'

package/features/dpe/domain/models/{plancher-bas.model.ts → plancher.model.ts}

@@ -5,7 +5,12 @@ export interface PlancherBas {
   donnee_intermediaire?: PlancherBasDI;
 }
 
-export interface PlancherBasDE extends DE {
+export interface PlancherHaut {
+  donnee_entree?: PlancherHautDE;
+  donnee_intermediaire?: PlancherHautDI;
+}
+
+export interface PlancherDE extends DE {
   reference_lnc?: string;
   tv_coef_reduction_deperdition_id?: string; // TV
   surface_aiu?: number;
@@ -13,26 +18,45 @@ export interface PlancherBasDE extends DE {
   enum_cfg_isolation_lnc_id?: string; // ENUM cfg_isolation_lnc
   enum_type_adjacence_id?: string; // ENUM type_adjacence
   surface_paroi_opaque?: number;
-  upb0_saisi?: number;
-  tv_upb0_id?: string; // TV
-  enum_type_plancher_bas_id?: string; // ENUM type_plancher_bas
   enum_methode_saisie_u0_id?: string; // ENUM methode_saisie_u0
-  upb_saisi?: number;
+
   enum_type_isolation_id?: string; // ENUM type_isolation
   enum_periode_isolation_id?: string; // ENUM periode_isolation
   resistance_isolation?: number;
   epaisseur_isolation?: number;
-  tv_upb_id?: string; // TV
   enum_methode_saisie_u_id?: string; // ENUM methode_saisie_u
+}
+
+export interface PlancherDI {
+  b: number;
+}
+
+export interface PlancherBasDE extends PlancherDE {
+  upb0_saisi?: number;
+  tv_upb0_id?: string; // TV
+  enum_type_plancher_bas_id?: string; // ENUM type_plancher_bas
+  upb_saisi?: number;
+  tv_upb_id?: string; // TV
   calcul_ue: number;
   perimetre_ue?: number;
   surface_ue?: number;
   ue?: number;
 }
 
-export interface PlancherBasDI {
+export interface PlancherBasDI extends PlancherDI {
   upb: number;
   upb0: number;
   upb_final: number;
+}
+
+export interface PlancherHautDE extends PlancherDE {
+  uph0_saisi?: number;
+  tv_uph0_id?: string; // TV
+  enum_type_plancher_haut_id?: string; // ENUM type_plancher_bas
+  uph_saisi?: number;
+  tv_uph_id?: string; // TV
+}
+
+export interface PlancherHautDI extends PlancherDI {
   b: number;
 }

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

@@ -6,3 +6,11 @@ export const TypeHabitation = {
   APPARTEMENT: 'APPARTEMENT',
   IMMEUBLE: 'IMMEUBLE'
 };
+/**
+ * @type {{[key: string]: string}}
+ */
+export const TypeDpe = {
+  MAISON: 'MAISON',
+  APPARTEMENT: 'APPARTEMENT',
+  IMMEUBLE: 'IMMEUBLE'
+};

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

@@ -2,6 +2,7 @@ import { tvs as tv } from '../../../tv-v2.js';
 import { getRange } from '../../../utils.js';
 import { logger } from '../../../core/util/logger/log-service.js';
 import { TvStore } from './tv.store.js';
+import enums from '../../../enums.js';
 
 /**
  * Accès aux données des tables de valeurs pour les baies vitrées
@@ -289,4 +290,73 @@ export class BaieVitreeTvStore extends TvStore {
 
     return parseFloat(fe2);
   }
+
+  /**
+   * Calcul des coefficients de réduction de température des espaces tampons
+   *
+   * @param zoneClimatique {string}
+   * @param enumCfgIsolationLncId {number}
+   * @return {number|undefined}
+   */
+  getBver(zoneClimatique, enumCfgIsolationLncId) {
+    const bver = tv['coef_reduction_deperdition'].find(
+      (v) =>
+        zoneClimatique.toLowerCase().startsWith(v.zone_climatique?.toLowerCase()) &&
+        parseInt(v.enum_cfg_isolation_lnc_id) === parseInt(enumCfgIsolationLncId)
+    )?.b;
+
+    if (!bver) {
+      logger.error(
+        `Pas de valeur b pour zoneClimatique:${zoneClimatique}, enumCfgIsolationLncId:${enumCfgIsolationLncId}`
+      );
+      return;
+    }
+
+    return parseFloat(bver);
+  }
+
+  /**
+   * Calcul des coefficients de transparence des espaces tampons
+   *
+   * @param tvCoefTransparenceEtsId {number}
+   * @return {number|undefined}
+   */
+  getCoefTransparenceEts(tvCoefTransparenceEtsId) {
+    const coefTransparence = tv['coef_transparence_ets'].find(
+      (v) => parseInt(v.tv_coef_transparence_ets_id) === parseInt(tvCoefTransparenceEtsId)
+    )?.coef_transparence_ets;
+
+    if (!coefTransparence) {
+      logger.error(
+        `Pas de valeur coef_transparence_ets pour tvCoefTransparenceEtsId:${tvCoefTransparenceEtsId}`
+      );
+      return;
+    }
+
+    return parseFloat(coefTransparence);
+  }
+
+  /**
+   * @see 18.5 - Coefficients d’orientation et d’inclinaison des parois vitrées : C1
+   *
+   * @param enumOrientationId {number}
+   * @param enumInclinaisonVitrageId {number}
+   * @param zoneClimatiqueId {number}
+   * @param mois {string}
+   *
+   * @return {number|undefined}
+   */
+  getCoefficientBaieVitree(enumOrientationId, enumInclinaisonVitrageId, zoneClimatiqueId, mois) {
+    const orientation = enums.orientation[enumOrientationId];
+    const inclinaison = enums.inclinaison_vitrage[enumInclinaisonVitrageId];
+    const zoneClimatique = enums.zone_climatique[zoneClimatiqueId];
+
+    const c1ZoneClimatique = tv['c1'][zoneClimatique][mois];
+
+    if (inclinaison === 'horizontal') {
+      return c1ZoneClimatique[inclinaison];
+    }
+
+    return c1ZoneClimatique[`${orientation} ${inclinaison}`];
+  }
 }

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

@@ -345,6 +345,112 @@ describe('Lecture des tables de valeurs', () => {
     });
   });
 
+  describe('lecture des valeurs coefficients de réduction de température des espaces tampons', () => {
+    test.each([
+      {
+        label: 'lc non isolé + espace tampon solarisé orienté nord',
+        zoneClimatique: 'H1a',
+        enumCfgIsolationLncId: '9',
+        expected: 0.85
+      },
+      {
+        label: 'lc isolé + espace tampon solarisé orienté sud',
+        zoneClimatique: 'H2C',
+        enumCfgIsolationLncId: '7',
+        expected: 0.57
+      }
+    ])(
+      `incidence masque proche pour baie vitrée $label`,
+      ({ zoneClimatique, enumCfgIsolationLncId, expected }) => {
+        expect(tvStore.getBver(zoneClimatique, enumCfgIsolationLncId)).toBe(expected);
+      }
+    );
+
+    test('pas de valeur de coefficients de réduction de température', () => {
+      const ug = tvStore.getBver('h3C', 1);
+      expect(ug).toBeUndefined();
+    });
+  });
+
+  describe('lecture des valeurs de coefficients de transparence des espaces tampons', () => {
+    test.each([
+      {
+        label: 'Parois en polycarbonate',
+        tvCoefTransparenceEtsId: '9',
+        expected: 0.39
+      },
+      {
+        label: 'Parois triple vitrage en Bois / Bois-métal',
+        tvCoefTransparenceEtsId: '5',
+        expected: 0.49
+      }
+    ])(
+      `incidence masque proche pour baie vitrée $label`,
+      ({ tvCoefTransparenceEtsId, expected }) => {
+        expect(tvStore.getCoefTransparenceEts(tvCoefTransparenceEtsId)).toBe(expected);
+      }
+    );
+
+    test('pas de valeur de coefficients de transparence', () => {
+      const ug = tvStore.getCoefTransparenceEts(0);
+      expect(ug).toBeUndefined();
+    });
+  });
+
+  describe("lecture des coefficients d'orientation et inclinaison des parois vitrées", () => {
+    test.each([
+      {
+        label: 'Baie vitrée orientée nord, inclinaison inf25°',
+        enumOrientationId: '2',
+        enumInclinaisonVitrageId: '1',
+        zoneClimatiqueId: '1',
+        mois: 'Janvier',
+        expected: 0.52
+      },
+      {
+        label: 'Baie vitrée orientée nord, inclinaison inf25°',
+        enumOrientationId: '2',
+        enumInclinaisonVitrageId: '1',
+        zoneClimatiqueId: '1',
+        mois: 'Juillet',
+        expected: 1.98
+      },
+      {
+        label: 'Baie vitrée orientée sud, inclinaison sup75°',
+        enumOrientationId: '1',
+        enumInclinaisonVitrageId: '3',
+        zoneClimatiqueId: '2',
+        mois: 'Janvier',
+        expected: 1
+      },
+      {
+        label: 'Baie vitrée orientée sud, inclinaison horizontale',
+        enumOrientationId: '1',
+        enumInclinaisonVitrageId: '4',
+        zoneClimatiqueId: '2',
+        mois: 'Janvier',
+        expected: 0.58
+      }
+    ])(
+      `coefficient pour $label`,
+      ({ enumOrientationId, enumInclinaisonVitrageId, zoneClimatiqueId, mois, expected }) => {
+        expect(
+          tvStore.getCoefficientBaieVitree(
+            enumOrientationId,
+            enumInclinaisonVitrageId,
+            zoneClimatiqueId,
+            mois
+          )
+        ).toMatchObject(expected);
+      }
+    );
+  });
+
+  test('lecture des épaisseurs disponibles pour les coefficients de transmission thermique ug', () => {
+    const ug = tvStore.getEpaisseurAvailableForUg();
+    expect(ug).toStrictEqual([0, 6, 8, 10, 12, 14, 15, 16, 18, 20]);
+  });
+
   test('lecture des épaisseurs disponibles pour les coefficients de transmission thermique ug', () => {
     const ug = tvStore.getEpaisseurAvailableForUg();
     expect(ug).toStrictEqual([0, 6, 8, 10, 12, 14, 15, 16, 18, 20]);

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

@@ -0,0 +1,112 @@
+import { tvs as tv } from '../../../tv-v2.js';
+import { logger } from '../../../core/util/logger/log-service.js';
+import { TvStore } from './tv.store.js';
+
+/**
+ * Accès aux données des tables de valeurs pour les baies vitrées
+ */
+export class PontThermiqueTvStore extends TvStore {
+  /**
+   * Valeur du pont thermique (W/(m.K)) via tv_pont_thermique_id
+   *
+   * @param tvPontThermiqueId {number}
+   * @return {number|undefined}
+   */
+  getKForMurById(tvPontThermiqueId) {
+    const k = tv['pont_thermique'].find(
+      (v) => parseInt(v.tv_pont_thermique_id) === tvPontThermiqueId
+    )?.k;
+
+    if (!k) {
+      logger.error(`Pas de valeur forfaitaire k pour tvPontThermiqueId:${tvPontThermiqueId}`);
+      return 0;
+    }
+
+    return parseFloat(k);
+  }
+
+  /**
+   * Valeur du pont thermique (W/(m.K))
+   *
+   * @param enumTypeLiaisonId {number}
+   * @param isolationMur {string}
+   * @return {number|undefined}
+   */
+  getKForMur(enumTypeLiaisonId, isolationMur) {
+    const k = tv['pont_thermique'].find(
+      (v) =>
+        parseInt(v.enum_type_liaison_id) === enumTypeLiaisonId &&
+        v.isolation_mur.toLowerCase() === isolationMur.toLowerCase()
+    )?.k;
+
+    if (!k) {
+      logger.error(`Pas de valeur forfaitaire k pour isolationMur:${isolationMur}`);
+      return;
+    }
+
+    return parseFloat(k);
+  }
+
+  /**
+   * Valeur du pont thermique (W/(m.K))
+   *
+   * @param enumTypeLiaisonId {number}
+   * @param isolationMur {string}
+   * @param isolationPlancher {string}
+   * @return {number|undefined}
+   */
+  getKForPlancher(enumTypeLiaisonId, isolationMur, isolationPlancher) {
+    const k = tv['pont_thermique'].find(
+      (v) =>
+        parseInt(v.enum_type_liaison_id) === enumTypeLiaisonId &&
+        v.isolation_mur.toLowerCase() === isolationMur.toLowerCase() &&
+        v.isolation_plancher.toLowerCase() === isolationPlancher.toLowerCase()
+    )?.k;
+
+    if (!k) {
+      logger.error(
+        `Pas de valeur forfaitaire k pour isolationMur:${isolationMur}, isolationPlancher:${isolationPlancher}`
+      );
+      return;
+    }
+
+    return parseFloat(k);
+  }
+
+  /**
+   * Valeur du pont thermique (W/(m.K))
+   *
+   * @param enumTypeLiaisonId {number}
+   * @param isolationMur {string}
+   * @param typePose {number}
+   * @param presenceRetourIsolation {number}
+   * @param largeurDormant {number}
+   * @return {number|undefined}
+   */
+  getKForMenuiserie(
+    enumTypeLiaisonId,
+    isolationMur,
+    typePose,
+    presenceRetourIsolation,
+    largeurDormant
+  ) {
+    const k = tv['pont_thermique'].find(
+      (v) =>
+        parseInt(v.enum_type_liaison_id) === enumTypeLiaisonId &&
+        v.isolation_mur.toLowerCase() === isolationMur.toLowerCase() &&
+        (!v.enum_type_pose_id || parseInt(v.enum_type_pose_id) === typePose) &&
+        (!v.presence_retour_isolation ||
+          parseInt(v.presence_retour_isolation) === presenceRetourIsolation) &&
+        (!v.largeur_dormant || !largeurDormant || parseInt(v.largeur_dormant) === largeurDormant)
+    )?.k;
+
+    if (!k) {
+      logger.error(
+        `Pas de valeur forfaitaire k pour isolationMur:${isolationMur}, typePose:${typePose}, presenceRetourIsolation:${presenceRetourIsolation}, largeurDormant:${largeurDormant}`
+      );
+      return;
+    }
+
+    return parseFloat(k);
+  }
+}

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

@@ -0,0 +1,134 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import { PontThermiqueTvStore } from './pontThermiqueTv.store.js';
+
+/** @type {PontThermiqueTvStore} **/
+let tvStore;
+
+describe('Lecture des tables de valeurs', () => {
+  beforeEach(() => {
+    tvStore = new PontThermiqueTvStore();
+  });
+
+  describe('lecture des valeurs de k', () => {
+    test.each([
+      {
+        label: 'tv_pont_thermique_id existant',
+        tvPontThermiqueId: 1,
+        expected: 0.39
+      },
+      {
+        label: 'tv_pont_thermique_id inexistant',
+        tvPontThermiqueId: 0,
+        expected: 0
+      }
+    ])(
+      `k via tv_pont_thermique_id pour un pont thermique avec $label`,
+      ({ tvPontThermiqueId, expected }) => {
+        expect(tvStore.getKForMurById(tvPontThermiqueId)).toBe(expected);
+      }
+    );
+
+    test.each([
+      {
+        label: 'enum_type_liaison_id et isolation_mur qui correspondent',
+        enumTypeLiaisonId: 1,
+        isolationMur: 'Non isolé',
+        expected: 0.39
+      },
+      {
+        label: 'enum_type_liaison_id et isolation_mur qui ne correspondent à aucune entrée',
+        enumTypeLiaisonId: 0,
+        isolationMur: '',
+        expected: undefined
+      }
+    ])(`k pour un pont thermique via $label`, ({ enumTypeLiaisonId, isolationMur, expected }) => {
+      expect(tvStore.getKForMur(enumTypeLiaisonId, isolationMur)).toBe(expected);
+    });
+
+    test.each([
+      {
+        label: 'enum_type_liaison_id, isolation_mur et isolationPlancher qui correspondent',
+        enumTypeLiaisonId: 1,
+        isolationMur: 'Non isolé',
+        isolationPlancher: 'iti',
+        expected: 0.47
+      },
+      {
+        label: 'enum_type_liaison_id et isolation_mur qui ne correspondent à aucune entrée',
+        enumTypeLiaisonId: 0,
+        isolationMur: 'Non isolé',
+        isolationPlancher: 'iti',
+        expected: undefined
+      }
+    ])(
+      `k pour un pont thermique via $label`,
+      ({ enumTypeLiaisonId, isolationMur, isolationPlancher, expected }) => {
+        expect(tvStore.getKForPlancher(enumTypeLiaisonId, isolationMur, isolationPlancher)).toBe(
+          expected
+        );
+      }
+    );
+  });
+
+  test.each([
+    {
+      label:
+        'enum_type_liaison_id, isolation_mur, typePose, largeurDormant, sans largeurDormant et presenceRetourIsolation qui correspondent',
+      enumTypeLiaisonId: 5,
+      isolationMur: 'Non isolé',
+      typePose: 1,
+      presenceRetourIsolation: undefined,
+      largeurDormant: undefined,
+      expected: 0.43
+    },
+    {
+      label:
+        'enum_type_liaison_id, isolation_mur, typePose, largeurDormant, sans presenceRetourIsolation qui correspondent',
+      enumTypeLiaisonId: 5,
+      isolationMur: 'Non isolé',
+      typePose: 1,
+      presenceRetourIsolation: undefined,
+      largeurDormant: 5,
+      expected: 0.43
+    },
+    {
+      label:
+        'enum_type_liaison_id, isolation_mur, typePose, largeurDormant, presenceRetourIsolation qui correspondent',
+      enumTypeLiaisonId: 5,
+      isolationMur: 'iti',
+      typePose: 3,
+      presenceRetourIsolation: 1,
+      largeurDormant: 10,
+      expected: 0.13
+    },
+    {
+      label: 'enum_type_liaison_id et isolation_mur qui ne correspondent à aucune entrée',
+      enumTypeLiaisonId: 5,
+      isolationMur: 'undefined',
+      typePose: 1,
+      presenceRetourIsolation: '1',
+      largeurDormant: 5,
+      expected: undefined
+    }
+  ])(
+    `k pour un pont thermique via $label`,
+    ({
+      enumTypeLiaisonId,
+      isolationMur,
+      typePose,
+      presenceRetourIsolation,
+      largeurDormant,
+      expected
+    }) => {
+      expect(
+        tvStore.getKForMenuiserie(
+          enumTypeLiaisonId,
+          isolationMur,
+          typePose,
+          presenceRetourIsolation,
+          largeurDormant
+        )
+      ).toBe(expected);
+    }
+  );
+});