@open3cl/engine 1.0.5 → 1.0.7

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/tv.store.js

@@ -0,0 +1,389 @@
+import { tvs as tv } from '../../../tv-v2.js';
+import { getRange } from '../../../utils.js';
+import { logger } from '../../../core/util/logger/log-service.js';
+import { TypeHabitation } from '../domain/models/type-habitation.model.js';
+
+/**
+ * Accès aux données des tables de valeurs
+ *
+ * /!\ Les tableaux des valeurs doivent souvent être ordonnés (ex: epaisseur_structure pour umur0)
+ */
+export class TvStore {
+  /**
+   * Coefficients U des portes
+   * Si le coefficient U des portes est connu et justifié, le saisir directement. Sinon, prendre les valeurs forfaitaires
+   *
+   * @see Chapitre 3.3.4
+   *
+   * @param enumTypePorteId {string} Identifiant du type de porte
+   * @return {number|undefined} Uporte si trouvé, sinon undefined
+   */
+  getUPorte(enumTypePorteId) {
+    const uPorte = tv['uporte'].find((v) =>
+      v.enum_type_porte_id.split('|').includes(enumTypePorteId)
+    )?.uporte;
+
+    if (!uPorte) {
+      logger.error(`Pas de valeur forfaitaire uPorte pour enumTypePorteId:${enumTypePorteId}`);
+      return;
+    }
+
+    logger.debug(`uPorte pour type ${enumTypePorteId} = ${uPorte}`);
+    return parseFloat(uPorte);
+  }
+
+  /**
+   * Coefficient de réduction des déperditions b
+   * @param enumTypeAdjacenceId {string}
+   * @param uVue {number|undefined}
+   * @param enumCfgIsolationLncId {string|undefined}
+   * @param rAiuAue {number|undefined}
+   * @param zc {string|undefined}
+   * @return {number|undefined}
+   */
+  getB(
+    enumTypeAdjacenceId,
+    uVue = undefined,
+    enumCfgIsolationLncId = undefined,
+    rAiuAue = undefined,
+    zc = undefined
+  ) {
+    const b = tv['coef_reduction_deperdition'].find(
+      (v) =>
+        (!enumTypeAdjacenceId ||
+          v.enum_type_adjacence_id.split('|').includes(enumTypeAdjacenceId)) &&
+        (!uVue || !v.uvue || parseFloat(v.uvue) === uVue) &&
+        (!enumCfgIsolationLncId ||
+          !v.enum_cfg_isolation_lnc_id ||
+          v.enum_cfg_isolation_lnc_id === enumCfgIsolationLncId) &&
+        (!zc ||
+          !v.zone_climatique ||
+          zc.toLowerCase().startsWith(v.zone_climatique.toLowerCase())) &&
+        (!rAiuAue ||
+          ((!v.aiu_aue_min || v.aiu_aue_min < rAiuAue) &&
+            (!v.aiu_aue_max || v.aiu_aue_max >= rAiuAue)))
+    )?.b;
+
+    if (!b) {
+      logger.error(`Pas de valeur forfaitaire b pour enumTypeAdjacenceId:${enumTypeAdjacenceId}`);
+      return;
+    }
+
+    logger.debug(`b pour enumTypeAdjacenceId ${enumTypeAdjacenceId} = ${b}`);
+    return parseFloat(b);
+  }
+
+  /**
+   * Coefficient surfacique équivalent
+   * @param enumTypeAdjacenceId {string}
+   * @return {number|undefined}
+   */
+  getUVue(enumTypeAdjacenceId) {
+    const uvue = tv['uvue'].find((v) => v.enum_type_adjacence_id === enumTypeAdjacenceId)?.uvue;
+
+    if (!uvue) {
+      logger.error(
+        `Pas de valeur forfaitaire uVue pour enumTypeAdjacenceId:${enumTypeAdjacenceId}`
+      );
+      return;
+    }
+
+    logger.debug(`uvue pour enumTypeAdjacenceId ${enumTypeAdjacenceId} = ${uvue}`);
+    return parseFloat(uvue);
+  }
+
+  /**
+   * Coefficient de transmission thermique du mur non isolé
+   * @param enumMateriauxStructureMurId {string}
+   * @param epaisseurStructure {number|undefined}
+   * @return {number|undefined}
+   */
+  getUmur0(enumMateriauxStructureMurId, epaisseurStructure = undefined) {
+    const umur0 = tv['umur0']
+      .filter((v) => v.enum_materiaux_structure_mur_id === enumMateriauxStructureMurId)
+      .find(
+        (v, idx, items) =>
+          !v.epaisseur_structure ||
+          !epaisseurStructure ||
+          !items[idx + 1] ||
+          epaisseurStructure < parseFloat(items[idx + 1].epaisseur_structure)
+      )?.umur0;
+
+    if (!umur0) {
+      logger.error(
+        `Pas de valeur forfaitaire umur0 pour enumMateriauxStructureMurId:${enumMateriauxStructureMurId}`
+      );
+      return;
+    }
+
+    logger.debug(
+      `umur0 pour enumMateriauxStructureMurId ${enumMateriauxStructureMurId} = ${umur0}`
+    );
+    return parseFloat(umur0);
+  }
+
+  /**
+   * Coefficient de transmission thermique du mur
+   * @param enumPeriodeConstructionId {string}
+   * @param enumZoneClimatiqueId {string}
+   * @param effetJoule {boolean}
+   * @return {number|undefined}
+   */
+  getUmur(enumPeriodeConstructionId, enumZoneClimatiqueId, effetJoule = false) {
+    const umur = tv['umur'].find(
+      (v) =>
+        v.enum_periode_construction_id.split('|').includes(enumPeriodeConstructionId) &&
+        v.enum_zone_climatique_id.split('|').includes(enumZoneClimatiqueId) &&
+        effetJoule === (parseInt(v.effet_joule) === 1)
+    )?.umur;
+
+    if (!umur) {
+      logger.error(
+        `Pas de valeur forfaitaire umur pour enumPeriodeConstructionId:${enumPeriodeConstructionId}, enumPeriodeConstructionId:${enumPeriodeConstructionId}`
+      );
+      return;
+    }
+
+    logger.debug(
+      `umur pour enumPeriodeConstructionId:${enumPeriodeConstructionId}, enumPeriodeConstructionId:${enumPeriodeConstructionId} = ${umur}`
+    );
+    return parseFloat(umur);
+  }
+
+  /**
+   * Coefficient de transmission thermique du plancher bas
+   * @param enumTypePlancherBasId {string}
+   * @return {number|undefined}
+   */
+  getUpb0(enumTypePlancherBasId) {
+    const upbO = tv['upb0'].find(
+      (v) => v.enum_type_plancher_bas_id === enumTypePlancherBasId
+    )?.upb0;
+
+    if (!upbO) {
+      logger.error(
+        `Pas de valeur forfaitaire upbO pour enumTypePlancherBasId:${enumTypePlancherBasId}`
+      );
+      return;
+    }
+
+    logger.debug(`upbO pour enumTypePlancherBasId ${enumTypePlancherBasId} = ${upbO}`);
+    return parseFloat(upbO);
+  }
+
+  /**
+   * Coefficient de transmission thermique du plancher bas
+   * @param enumPeriodeConstructionId {string}
+   * @param enumZoneClimatiqueId {string}
+   * @param effetJoule {boolean}
+   * @return {number|undefined}
+   */
+  getUpb(enumPeriodeConstructionId, enumZoneClimatiqueId, effetJoule = false) {
+    const upb = tv['upb'].find(
+      (v) =>
+        v.enum_zone_climatique_id.split('|').includes(enumZoneClimatiqueId) &&
+        v.enum_periode_construction_id.split('|').includes(enumPeriodeConstructionId) &&
+        effetJoule === (parseInt(v.effet_joule) === 1)
+    )?.upb;
+
+    if (!upb) {
+      logger.error(
+        `Pas de valeur forfaitaire upb pour enumPeriodeConstructionId:${enumPeriodeConstructionId}, enumPeriodeConstructionId:${enumPeriodeConstructionId}`
+      );
+      return;
+    }
+
+    logger.debug(
+      `upb pour enumPeriodeConstructionId:${enumPeriodeConstructionId}, enumPeriodeConstructionId:${enumPeriodeConstructionId} = ${upb}`
+    );
+    return parseFloat(upb);
+  }
+
+  /**
+   * Retourne la valeur UE la plus proche
+   * @param enumTypeAdjacenceId {string}
+   * @param enumPeriodeConstructionId {string}
+   * @param dsp {number} Valeur entière la plus proche de 2S/P
+   * @param upb {number} Valeur de upb
+   * @return {number|undefined}
+   */
+  getUeByUpd(enumTypeAdjacenceId, enumPeriodeConstructionId, dsp, upb) {
+    const ueValues =
+      tv['ue'].filter(
+        (v) =>
+          parseInt(v['2s_p']) === dsp &&
+          v.enum_type_adjacence_id.split('|').includes(enumTypeAdjacenceId) &&
+          v.enum_periode_construction_id.split('|').includes(enumPeriodeConstructionId)
+      ) || [];
+
+    const ueRange = [...new Set(ueValues.map((value) => value.upb).sort())];
+    let ue;
+    let upb1, upb2;
+
+    if (ueValues.length) {
+      [upb1, upb2] = getRange(upb, ueRange);
+
+      const ue1 = ueValues.find((value) => value.upb === upb1)?.ue || 0;
+      const ue2 = ueValues.find((value) => value.upb === upb2)?.ue || 0;
+
+      const delta_ue = Number(ue2) - Number(ue1);
+      const delta_upb = upb2 - upb1 || 0;
+
+      if (delta_upb === 0) {
+        ue = Number(ue1);
+      } else {
+        // Interpolation linéaire si upb n'est pas une valeur connue
+        ue = Number(ue1) + (delta_ue * (upb - upb1)) / delta_upb;
+      }
+    }
+
+    if (ue === undefined) {
+      logger.error(
+        `Pas de valeur forfaitaire ue pour enumTypeAdjacenceId:${enumTypeAdjacenceId}, enumPeriodeConstructionId:${enumPeriodeConstructionId}, 2S/P:${dsp}`
+      );
+      return;
+    }
+
+    logger.debug(
+      `ue pour enumTypeAdjacenceId:${enumTypeAdjacenceId}, enumPeriodeConstructionId:${enumPeriodeConstructionId}, 2S/P:${dsp} = ${ue}`
+    );
+    return parseFloat(ue);
+  }
+
+  /**
+   * Coefficient de transmission thermique du plancher haut
+   * @param enumTypePlancherHautId {string}
+   * @return {number|undefined}
+   */
+  getUph0(enumTypePlancherHautId) {
+    const uph0 = tv['uph0'].find((v) =>
+      v.enum_type_plancher_haut_id.split('|').includes(enumTypePlancherHautId)
+    )?.uph0;
+
+    if (!uph0) {
+      logger.error(
+        `Pas de valeur forfaitaire uph0 pour enumTypePlancherHautId:${enumTypePlancherHautId}`
+      );
+      return;
+    }
+
+    logger.debug(`upbO pour enumTypePlancherHautId ${enumTypePlancherHautId} = ${uph0}`);
+    return parseFloat(uph0);
+  }
+
+  /**
+   * Coefficient de transmission thermique du plancher bas
+   * @param enumPeriodeConstructionId {string}
+   * @param typeToiture {('combles'|'terrasse')}
+   * @param enumZoneClimatiqueId {string}
+   * @param effetJoule {boolean}
+   * @return {number|undefined}
+   */
+  getUph(enumPeriodeConstructionId, typeToiture, enumZoneClimatiqueId, effetJoule = false) {
+    const uph = tv['uph'].find(
+      (v) =>
+        v.enum_periode_construction_id.split('|').includes(enumPeriodeConstructionId) &&
+        v.enum_zone_climatique_id.split('|').includes(enumZoneClimatiqueId) &&
+        v.type_toiture === typeToiture &&
+        effetJoule === (parseInt(v.effet_joule) === 1)
+    )?.uph;
+
+    if (!uph) {
+      logger.error(
+        `Pas de valeur forfaitaire uph pour enumPeriodeConstructionId:${enumPeriodeConstructionId}, enumPeriodeConstructionId:${enumPeriodeConstructionId}, typeToiture:${typeToiture}`
+      );
+      return;
+    }
+
+    logger.debug(
+      `uph pour enumPeriodeConstructionId:${enumPeriodeConstructionId}, enumPeriodeConstructionId:${enumPeriodeConstructionId}, typeToiture:${typeToiture} = ${uph}`
+    );
+    return parseFloat(uph);
+  }
+
+  /**
+   * Coefficient de transmission thermique du plancher bas
+   * @param enumTypeVitrageId {string}
+   * @param enumTypeGazLameId {string|undefined}
+   * @param enumInclinaisonVitrageId {string|undefined}
+   * @param vitrageVir {boolean|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) &&
+        (!enumInclinaisonVitrageId ||
+          v.enum_inclinaison_vitrage_id.split('|').includes(enumInclinaisonVitrageId)) &&
+        (!enumTypeGazLameId || v.enum_type_gaz_lame_id.split('|').includes(enumTypeGazLameId)) &&
+        (!epaisseurLame || parseFloat(v.epaisseur_lame) === epaisseurLame) &&
+        (!vitrageVir || vitrageVir === (parseInt(v.vitrage_vir) === 1))
+    )?.ug;
+
+    if (!ug) {
+      logger.error(
+        `Pas de valeur forfaitaire ug pour enumTypeVitrageId:${enumTypeVitrageId}, enumTypeGazLameId:${enumTypeGazLameId}, enumInclinaisonVitrageId:${enumInclinaisonVitrageId}, vitrageVir:${vitrageVir}, epaisseurLame:${epaisseurLame}`
+      );
+      return;
+    }
+
+    logger.debug(
+      `ug pour enumTypeVitrageId:${enumTypeVitrageId}, enumTypeGazLameId:${enumTypeGazLameId}, enumInclinaisonVitrageId:${enumInclinaisonVitrageId}, vitrageVir:${vitrageVir}, epaisseurLame:${epaisseurLame} = ${ug}`
+    );
+    return parseFloat(ug);
+  }
+
+  /**
+   * Débits de la ventilation
+   * @param typeVentilation {number}
+   * @return {object|undefined}
+   */
+  getDebitsVentilation(typeVentilation) {
+    const debitsVentilation = tv['debits_ventilation'].find((v) =>
+      v.enum_type_ventilation_id.split('|').includes(typeVentilation)
+    );
+
+    if (!debitsVentilation) {
+      logger.error(
+        `Pas de valeur forfaitaire debits_ventilation pour enumTypeVentilationId: ${typeVentilation}`
+      );
+      return;
+    }
+
+    return debitsVentilation;
+  }
+
+  /**
+   * Valeur conventionnelle de la perméabilité sous 4Pa
+   * @see Chapitre 4 - Calcul des déperditions par renouvellement d’air
+   *
+   * @param periodConstruction {string}
+   * @param typeHabitation {TypeHabitation}
+   * @param isolationSurface {string | undefined}
+   * @param presenceJointsMenuiserie {string | undefined}
+   *
+   * @return {object|undefined}
+   */
+  getQ4paConv(periodConstruction, typeHabitation, isolationSurface, presenceJointsMenuiserie) {
+    const q4paConv = tv['q4pa_conv'].find(
+      (v) =>
+        v.enum_periode_construction_id.split('|').includes(periodConstruction) &&
+        v.type_habitation.split('/').includes(TypeHabitation[typeHabitation].toLowerCase()) &&
+        (isolationSurface === undefined || v.isolation_surfaces === isolationSurface) &&
+        (presenceJointsMenuiserie === undefined ||
+          v.presence_joints_menuiserie === presenceJointsMenuiserie)
+    );
+
+    if (!q4paConv) {
+      logger.error(
+        `Pas de valeur forfaitaire q4pa_conv pour periodConstruction: ${periodConstruction}, 
+        typeHabitation: ${typeHabitation}, isolationSurface: ${isolationSurface}, 
+        presenceJointsMenuiserie: ${presenceJointsMenuiserie}`
+      );
+      return;
+    }
+
+    return q4paConv;
+  }
+}