@open3cl/engine 1.0.6 → 1.0.8

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

@@ -0,0 +1,178 @@
+export interface Sortie {
+  deperdition: Deperdition;
+  apport_et_besoin: ApportEtBesoin;
+  ef_conso: EfConso;
+  ep_conso: EpConso;
+  emission_ges: EmissionGes;
+  cout: Cout;
+  production_electricite: ProductionElectricite;
+  sortie_par_energie_collection: { sortie_par_energie: SortieParEnergie[] };
+  confort_ete?: ConfortEte;
+  qualite_isolation: QualiteIsolation;
+}
+
+export interface Deperdition {
+  hvent: number;
+  hperm: number;
+  deperdition_renouvellement_air: number;
+  deperdition_mur: number;
+  deperdition_plancher_bas: number;
+  deperdition_plancher_haut: number;
+  deperdition_baie_vitree: number;
+  deperdition_porte: number;
+  deperdition_pont_thermique: number;
+  deperdition_enveloppe: number;
+}
+
+export interface ApportEtBesoin {
+  surface_sud_equivalente: number;
+  apport_solaire_fr: number;
+  apport_interne_fr: number;
+  apport_solaire_ch: number;
+  apport_interne_ch: number;
+  fraction_apport_gratuit_ch: number;
+  fraction_apport_gratuit_depensier_ch: number;
+  pertes_distribution_ecs_recup: number;
+  pertes_distribution_ecs_recup_depensier: number;
+  pertes_stockage_ecs_recup: number;
+  pertes_generateur_ch_recup: number;
+  pertes_generateur_ch_recup_depensier: number;
+  nadeq: number;
+  v40_ecs_journalier: number;
+  v40_ecs_journalier_depensier: number;
+  besoin_ch: number;
+  besoin_ch_depensier: number;
+  besoin_ecs: number;
+  besoin_ecs_depensier: number;
+  besoin_fr: number;
+  besoin_fr_depensier: number;
+}
+
+export interface EfConso {
+  conso_ch: number;
+  conso_ch_depensier: number;
+  conso_ecs: number;
+  conso_ecs_depensier: number;
+  conso_eclairage: number;
+  conso_auxiliaire_generation_ch: number;
+  conso_auxiliaire_generation_ch_depensier: number;
+  conso_auxiliaire_distribution_ch: number;
+  conso_auxiliaire_generation_ecs: number;
+  conso_auxiliaire_generation_ecs_depensier: number;
+  conso_auxiliaire_distribution_ecs: number;
+  conso_auxiliaire_distribution_fr?: number;
+  conso_auxiliaire_ventilation: number;
+  conso_totale_auxiliaire: number;
+  conso_fr: number;
+  conso_fr_depensier: number;
+  conso_5_usages: number;
+  conso_5_usages_m2: number;
+}
+
+export interface EpConso {
+  ep_conso_ch: number;
+  ep_conso_ch_depensier: number;
+  ep_conso_ecs: number;
+  ep_conso_ecs_depensier: number;
+  ep_conso_eclairage: number;
+  ep_conso_auxiliaire_generation_ch: number;
+  ep_conso_auxiliaire_generation_ch_depensier: number;
+  ep_conso_auxiliaire_distribution_ch: number;
+  ep_conso_auxiliaire_generation_ecs: number;
+  ep_conso_auxiliaire_generation_ecs_depensier: number;
+  ep_conso_auxiliaire_distribution_ecs: number;
+  ep_conso_auxiliaire_distribution_fr?: number;
+  ep_conso_auxiliaire_ventilation: number;
+  ep_conso_totale_auxiliaire: number;
+  ep_conso_fr: number;
+  ep_conso_fr_depensier: number;
+  ep_conso_5_usages: number;
+  ep_conso_5_usages_m2: number;
+  classe_bilan_dpe: string;
+}
+
+export interface EmissionGes {
+  emission_ges_ch: number;
+  emission_ges_ch_depensier: number;
+  emission_ges_ecs: number;
+  emission_ges_ecs_depensier: number;
+  emission_ges_eclairage: number;
+  emission_ges_auxiliaire_generation_ch: number;
+  emission_ges_auxiliaire_generation_ch_depensier: number;
+  emission_ges_auxiliaire_distribution_ch: number;
+  emission_ges_auxiliaire_generation_ecs: number;
+  emission_ges_auxiliaire_generation_ecs_depensier: number;
+  emission_ges_auxiliaire_distribution_ecs: number;
+  emission_ges_auxiliaire_distribution_fr?: number;
+  emission_ges_auxiliaire_ventilation: number;
+  emission_ges_totale_auxiliaire: number;
+  emission_ges_fr: number;
+  emission_ges_fr_depensier: number;
+  emission_ges_5_usages: number;
+  emission_ges_5_usages_m2: number;
+  classe_emission_ges: string;
+}
+
+export interface Cout {
+  cout_ch: number;
+  cout_ch_depensier: number;
+  cout_ecs: number;
+  cout_ecs_depensier: number;
+  cout_eclairage: number;
+  cout_auxiliaire_generation_ch: number;
+  cout_auxiliaire_generation_ch_depensier: number;
+  cout_auxiliaire_distribution_ch: number;
+  cout_auxiliaire_generation_ecs: number;
+  cout_auxiliaire_generation_ecs_depensier: number;
+  cout_auxiliaire_distribution_ecs: number;
+  cout_auxiliaire_distribution_fr?: number;
+  cout_auxiliaire_ventilation: number;
+  cout_total_auxiliaire: number;
+  cout_fr: number;
+  cout_fr_depensier: number;
+  cout_5_usages: number;
+}
+
+export interface ProductionElectricite {
+  production_pv: number;
+  conso_elec_ac: number;
+  conso_elec_ac_ch: number;
+  conso_elec_ac_ecs: number;
+  conso_elec_ac_fr: number;
+  conso_elec_ac_eclairage: number;
+  conso_elec_ac_auxiliaire: number;
+  conso_elec_ac_autre_usage: number;
+}
+
+export interface SortieParEnergie {
+  enum_type_energie_id: number;
+  conso_ch: number;
+  conso_ecs: number;
+  conso_5_usages: number;
+  emission_ges_ch: number;
+  emission_ges_ecs: number;
+  emission_ges_5_usages: number;
+  cout_ch: number;
+  cout_ecs: number;
+  cout_5_usages: number;
+}
+
+export interface ConfortEte {
+  isolation_toiture?: boolean;
+  protection_solaire_exterieure: boolean;
+  aspect_traversant?: boolean;
+  brasseur_air?: boolean;
+  inertie_lourde: boolean;
+  enum_indicateur_confort_ete_id: number;
+}
+
+export interface QualiteIsolation {
+  ubat: number;
+  qualite_isol_enveloppe: number;
+  qualite_isol_mur?: number;
+  qualite_isol_plancher_haut_toit_terrasse?: number;
+  qualite_isol_plancher_haut_comble_perdu?: number;
+  qualite_isol_plancher_haut_comble_amenage?: number;
+  qualite_isol_plancher_bas?: number;
+  qualite_isol_menuiserie: number;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * @type {{[key: string]: string}}
+ */
+export const TypeHabitation = {
+  MAISON: 'MAISON',
+  APPARTEMENT: 'APPARTEMENT',
+  IMMEUBLE: 'IMMEUBLE'
+};

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

@@ -0,0 +1,8 @@
+/**
+ * @type {{[key: string]: string}}
+ */
+export const TypeVentilation = {
+  SIMPLE_FLUX_AUTO: 'SIMPLE_FLUX_AUTO',
+  SIMPLE_FLUX_HYGRO: 'SIMPLE_FLUX_HYGRO',
+  DOUBLE_FLUX: 'DOUBLE_FLUX'
+};

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

@@ -0,0 +1,33 @@
+import { DE } from './dpe.model';
+
+export interface Ventilation {
+  donnee_entree?: VentilationDE;
+  donnee_intermediaire?: VentilationDI;
+}
+
+export interface VentilationDE extends DE {
+  enum_type_ventilation_id: number;
+  surface_ventile: number;
+  plusieurs_facade_exposee: boolean;
+  tv_q4pa_conv_id?: number;
+  q4pa_conv_saisi?: number;
+  enum_methode_saisie_q4pa_conv_id: number;
+  tv_debits_ventilation_id: number;
+  ventilation_post_2012: boolean;
+  ref_produit_ventilation?: number;
+  cle_repartition_ventilation?: number;
+}
+
+export interface VentilationDI {
+  pvent_moy?: number;
+  q4pa_conv: number;
+  conso_auxiliaire_ventilation: number;
+  hperm: number;
+  hvent: number;
+}
+
+enum TypeVentilation {
+  SIMPLE_FLUX_AUTO = 'SIMPLE_FLUX_AUTO',
+  SIMPLE_FLUX_HYGRO = 'SIMPLE_FLUX_HYGRO',
+  DOUBLE_FLUX = 'DOUBLE_FLUX'
+}

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

@@ -0,0 +1,292 @@
+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';
+
+/**
+ * Accès aux données des tables de valeurs pour les baies vitrées
+ */
+export class BaieVitreeTvStore extends TvStore {
+  /**
+   * Coefficient de transmission thermique du vitrage (W/(m².K))
+   *
+   * @param enumTypeVitrageId {string}
+   * @param enumTypeGazLameId {string|undefined}
+   * @param enumInclinaisonVitrageId {string|undefined}
+   * @param vitrageVir {number|undefined}
+   * @param epaisseurLame {number|undefined}
+   * @return {number|undefined}
+   */
+  getUg(enumTypeVitrageId, enumTypeGazLameId, enumInclinaisonVitrageId, vitrageVir, epaisseurLame) {
+    const ug = tv['ug'].find(
+      (v) =>
+        v.enum_type_vitrage_id.split('|').includes(enumTypeVitrageId) &&
+        (!enumTypeGazLameId || v.enum_type_gaz_lame_id?.split('|').includes(enumTypeGazLameId)) &&
+        (!enumInclinaisonVitrageId ||
+          v.enum_inclinaison_vitrage_id?.split('|').includes(enumInclinaisonVitrageId)) &&
+        (!vitrageVir || parseInt(vitrageVir) === parseInt(v.vitrage_vir)) &&
+        (!epaisseurLame || parseFloat(v.epaisseur_lame) === epaisseurLame)
+    )?.ug;
+
+    if (!ug) {
+      logger.error(
+        `Pas de valeur forfaitaire ug pour enumTypeVitrageId:${enumTypeVitrageId}, enumTypeGazLameId:${enumTypeGazLameId}, enumInclinaisonVitrageId:${enumInclinaisonVitrageId}, vitrageVir:${vitrageVir}, epaisseurLame:${epaisseurLame}`
+      );
+      return;
+    }
+
+    return parseFloat(ug);
+  }
+
+  /**
+   * Épaisseurs disponibles pour les coefficients de transmission thermique du vitrage (W/(m².K))
+   *
+   * @return {number[]}
+   */
+  getEpaisseurAvailableForUg() {
+    return [
+      ...new Set(tv['ug'].map((value) => parseInt(value.epaisseur_lame) || 0).sort((a, b) => a - b))
+    ];
+  }
+
+  /**
+   * Proportion d’énergie solaire incidente qui pénètre dans le logement par la paroi vitrée
+   *
+   * @param enumTypeVitrageId {string}
+   * @param enumTypeBaieId {string}
+   * @param enumTypeMateriauxMenuiserieId {string}
+   * @param vitrageVir {number|undefined}
+   * @param enumTypePoseId {string|undefined}
+   * @return {number|undefined}
+   */
+  getSw(
+    enumTypeVitrageId,
+    enumTypeBaieId,
+    enumTypeMateriauxMenuiserieId,
+    vitrageVir,
+    enumTypePoseId
+  ) {
+    const sw = tv['sw'].find(
+      (v) =>
+        (!v.enum_type_vitrage_id ||
+          v.enum_type_vitrage_id.split('|').includes(enumTypeVitrageId)) &&
+        v.enum_type_baie_id.split('|').includes(enumTypeBaieId) &&
+        v.enum_type_materiaux_menuiserie_id.split('|').includes(enumTypeMateriauxMenuiserieId) &&
+        (!vitrageVir || parseInt(vitrageVir) === parseInt(v.vitrage_vir)) &&
+        (!enumTypePoseId || v.enum_type_pose_id.split('|').includes(enumTypePoseId))
+    )?.sw;
+
+    if (!sw) {
+      logger.error(
+        `Pas de valeur forfaitaire sw pour enumTypeVitrageId:${enumTypeVitrageId}, enumTypeBaieId:${enumTypeBaieId}, enumTypeMateriauxMenuiserieId:${enumTypeMateriauxMenuiserieId}, vitrageVir:${vitrageVir}, enumTypePoseId:${enumTypePoseId}`
+      );
+      return;
+    }
+
+    return parseFloat(sw);
+  }
+
+  /**
+   * Coefficient de transmission thermique des fenêtres
+   *
+   * @param enumTypeVitrageId {string}
+   * @param enumTypeBaieId {string}
+   * @param enumTypeMateriauxMenuiserieId {string}
+   * @param ug {number|undefined}
+   * @return {number|undefined}
+   */
+  getUw(enumTypeBaieId, enumTypeMateriauxMenuiserieId, ug) {
+    let uw;
+
+    /**
+     * Pas de notion de ug pour les parois polycarbonate ou verre
+     * enum_type_baie_id
+     * 1 - paroi en brique de verre pleine
+     * 2 - paroi en brique de verre creuse
+     * 3 - paroi en polycarbonnate
+     */
+    if (['1', '2', '3'].includes(enumTypeBaieId)) {
+      uw = tv['uw'].find((v) => v.enum_type_baie_id.split('|').includes(enumTypeBaieId))?.uw;
+    } else {
+      /**
+       * 3.3.2 Coefficients Uw des fenêtres / portes-fenêtres
+       * Les Uw associés à des Ug non présents dans les tableaux peuvent être obtenus par interpolation ou
+       * extrapolation avec les deux Ug tabulés les plus proches.
+       */
+      const ugValues =
+        tv['uw'].filter(
+          (v) =>
+            v.enum_type_baie_id.split('|').includes(enumTypeBaieId) &&
+            v.enum_type_materiaux_menuiserie_id.split('|').includes(enumTypeMateriauxMenuiserieId)
+        ) || [];
+
+      let ug1, ug2;
+
+      if (ugValues.length) {
+        [ug1, ug2] = getRange(ug, [...new Set(ugValues.map((value) => value.ug).sort())]);
+
+        const uw1 = ugValues.find((value) => value.ug === ug1)?.uw || 0;
+        const uw2 = ugValues.find((value) => value.ug === ug2)?.uw || 0;
+
+        const delta_uw = Number(uw2) - Number(uw1);
+        const delta_ug = ug2 - ug1 || 0;
+
+        if (delta_ug === 0) {
+          uw = Number(uw1);
+        } else {
+          // Interpolation linéaire si upb n'est pas une valeur connue
+          uw = Number(uw1) + (delta_uw * (ug - ug1)) / delta_ug;
+        }
+      }
+    }
+
+    if (!uw) {
+      logger.error(
+        `Pas de valeur forfaitaire uw pour enumTypeBaieId:${enumTypeBaieId}, enumTypeMateriauxMenuiserieId:${enumTypeMateriauxMenuiserieId}, ug:${ug}`
+      );
+      return;
+    }
+
+    return parseFloat(uw);
+  }
+
+  /**
+   * La présence de volets aux fenêtres et portes-fenêtres leur apporte un supplément d’isolation avec une résistance
+   * additionnelle ΔR
+   *
+   * @param enumTypeFermetureId {string}
+   * @return {number|undefined}
+   */
+  getDeltar(enumTypeFermetureId) {
+    const deltar = tv['deltar'].find((v) =>
+      v.enum_type_fermeture_id.split('|').includes(enumTypeFermetureId)
+    )?.deltar;
+
+    if (!deltar) {
+      logger.error(
+        `Pas de valeur forfaitaire deltar pour enumTypeFermetureId:${enumTypeFermetureId}`
+      );
+      return;
+    }
+
+    return parseFloat(deltar);
+  }
+
+  /**
+   * La présence de volets aux fenêtres et portes-fenêtres leur apporte un supplément d’isolation avec une résistance
+   * additionnelle ΔR
+   *
+   * @param enumTypeFermetureId {string}
+   * @param uw {number}
+   *
+   * @return {number|undefined}
+   */
+  getUjn(enumTypeFermetureId, uw) {
+    let ujn;
+    /**
+     * 3.3.3 Coefficients Ujn des fenêtres/portes-fenêtres
+     * Dans la suite, les Ujn associés à des Uw non présents dans les tableaux peuvent être obtenus par interpolation ou
+     * extrapolation avec les deux Uw tabulés les plus proches.
+     */
+    const deltar = this.getDeltar(enumTypeFermetureId);
+    const uwValues =
+      tv['ujn'].filter((v) => Number(v.deltar).toPrecision(2) === Number(deltar).toPrecision(2)) ||
+      [];
+
+    let uw1, uw2;
+
+    if (uwValues.length) {
+      [uw1, uw2] = getRange(uw, [...new Set(uwValues.map((value) => value.uw).sort())]);
+
+      const ujn1 =
+        uwValues.find((value) => Number(value.uw).toPrecision(2) === Number(uw1).toPrecision(2))
+          ?.ujn || 0;
+      const ujn2 =
+        uwValues.find((value) => Number(value.uw).toPrecision(2) === Number(uw2).toPrecision(2))
+          ?.ujn || 0;
+
+      const delta_ujn = Number(ujn2) - Number(ujn1);
+      const delta_uw = uw2 - uw1 || 0;
+
+      if (delta_uw === 0) {
+        ujn = Number(ujn1);
+      } else {
+        // Interpolation linéaire si uw n'est pas une valeur connue
+        ujn = Number(ujn1) + (delta_ujn * (uw - uw1)) / delta_uw;
+      }
+
+      if (!ujn) {
+        logger.error(
+          `Pas de valeur forfaitaire ujn pour enumTypeFermetureId:${enumTypeFermetureId}, uw:${uw}`
+        );
+        return;
+      }
+
+      return parseFloat(ujn);
+    }
+  }
+
+  /**
+   * Calcul de l’ombrage créé par un obstacle sur une paroi
+   *
+   * @param tvCoeffMasqueLointainNonHomogeneId {number}
+   * @return {number|undefined}
+   */
+  getOmbre(tvCoeffMasqueLointainNonHomogeneId) {
+    const ombre = tv['coef_masque_lointain_non_homoge'].find(
+      (v) =>
+        parseInt(v.tv_coef_masque_lointain_non_homogene_id) ===
+        parseInt(tvCoeffMasqueLointainNonHomogeneId)
+    )?.omb;
+
+    if (!ombre) {
+      logger.error(
+        `Pas de valeur forfaitaire ombre pour tvCoeffMasqueLointainNonHomogeneId:${tvCoeffMasqueLointainNonHomogeneId}`
+      );
+      return;
+    }
+
+    return parseFloat(ombre);
+  }
+
+  /**
+   * Calcul de l'incidence d'un masque proche sur une paroi
+   *
+   * @param tvCoefMasqueProcheId {number}
+   * @return {number|undefined}
+   */
+  getMasqueProche(tvCoefMasqueProcheId) {
+    const fe1 = tv['coef_masque_proche'].find(
+      (v) => parseInt(v.tv_coef_masque_proche_id) === parseInt(tvCoefMasqueProcheId)
+    )?.fe1;
+
+    if (!fe1) {
+      logger.error(`Pas de valeur fe1 pour tvCoefMasqueProcheId:${tvCoefMasqueProcheId}`);
+      return;
+    }
+
+    return parseFloat(fe1);
+  }
+
+  /**
+   * Calcul de l'incidence d'un masque lointain homogène sur une paroi
+   *
+   * @param tvCoefMasqueLointainHomogeneId {number}
+   * @return {number|undefined}
+   */
+  getMasqueLointainHomogene(tvCoefMasqueLointainHomogeneId) {
+    const fe2 = tv['coef_masque_lointain_homogene'].find(
+      (v) =>
+        parseInt(v.tv_coef_masque_lointain_homogene_id) === parseInt(tvCoefMasqueLointainHomogeneId)
+    )?.fe2;
+
+    if (!fe2) {
+      logger.error(
+        `Pas de valeur fe2 pour tvCoefMasqueLointainHomogeneId:${tvCoefMasqueLointainHomogeneId}`
+      );
+      return;
+    }
+
+    return parseFloat(fe2);
+  }
+}