@open3cl/engine 1.0.0

package/6.1_apport_gratuit.spec.js

@@ -0,0 +1,181 @@
+import { calc_ai, calc_as } from './6.1_apport_gratuit.js';
+
+describe("Recherche de bugs dans le calcul de l'apport gratuit", () => {
+  /**
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf Page 43
+   */
+  test('calcul de f apport solaire', () => {
+    const ilpa = '0';
+    const ca = '400-800m';
+    const zc = 'h1c';
+    const bv = [
+      {
+        donnee_entree: {
+          description: 'Fenêtre  1 Nord - Fenêtres battantes bois, orientées Nord, simple vitrage',
+          enum_type_adjacence_id: '1',
+          surface_totale_baie: 1.76,
+          nb_baie: 2,
+          tv_ug_id: 1,
+          enum_type_vitrage_id: '1',
+          enum_inclinaison_vitrage_id: '3',
+          enum_methode_saisie_perf_vitrage_id: '1',
+          tv_uw_id: 561,
+          enum_type_materiaux_menuiserie_id: '3',
+          enum_type_baie_id: '4',
+          double_fenetre: 0,
+          uw_1: 5.4,
+          sw_1: 0.52,
+          enum_type_fermeture_id: '1',
+          presence_retour_isolation: 0,
+          largeur_dormant: 5,
+          tv_sw_id: 89,
+          enum_type_pose_id: '3',
+          enum_orientation_id: '2',
+          tv_coef_masque_proche_id: 19,
+          masque_lointain_non_homogene_collection: '',
+          reference: 'baie_vitree_0',
+          tv_coef_reduction_deperdition_id: 1
+        },
+        donnee_intermediaire: {
+          b: 1,
+          sw: 0.52,
+          ug: 5.8,
+          uw: 5.4,
+          u_menuiserie: 5.4,
+          fe2: 1,
+          fe1: 1
+        },
+        donnee_utilisateur: {
+          enum_type_adjacence_id: [
+            '1',
+            '2',
+            '3',
+            '4',
+            '5',
+            '6',
+            '7',
+            '8',
+            '9',
+            '10',
+            '11',
+            '12',
+            '13',
+            '14',
+            '15',
+            '16',
+            '17',
+            '18',
+            '19',
+            '20',
+            '21',
+            '22'
+          ],
+          enum_type_vitrage_id: ['1', '2', '3', '4', '5', '6'],
+          enum_type_baie_id: ['1', '2', '3', '4', '5', '6', '7', '8'],
+          enum_type_materiaux_menuiserie_id: ['1', '2', '3', '4', '5', '6', '7'],
+          vitrage_vir: 'bool',
+          enum_type_pose_id: ['1', '2', '3', '4'],
+          enum_type_fermeture_id: ['1', '2', '3', '4', '5', '6', '7', '8'],
+          presence_retour_isolation: 'bool',
+          largeur_dormant: 'float'
+        }
+      },
+      {
+        donnee_entree: {
+          description:
+            'Fenêtre  2 Sud - Fenêtres battantes bois, orientées Sud, simple vitrage avec volets battants bois',
+          enum_type_adjacence_id: '1',
+          surface_totale_baie: 4,
+          nb_baie: 2,
+          tv_ug_id: 1,
+          enum_type_vitrage_id: '1',
+          enum_inclinaison_vitrage_id: '3',
+          enum_methode_saisie_perf_vitrage_id: '1',
+          tv_uw_id: 561,
+          enum_type_materiaux_menuiserie_id: '3',
+          enum_type_baie_id: '4',
+          double_fenetre: 0,
+          uw_1: 5.4,
+          sw_1: 0.52,
+          tv_deltar_id: 6,
+          tv_ujn_id: 224,
+          enum_type_fermeture_id: '7',
+          presence_retour_isolation: 0,
+          largeur_dormant: 5,
+          tv_sw_id: 89,
+          enum_type_pose_id: '2',
+          enum_orientation_id: '1',
+          tv_coef_masque_proche_id: 19,
+          masque_lointain_non_homogene_collection: '',
+          reference: 'baie_vitree_1',
+          tv_coef_reduction_deperdition_id: 1
+        },
+        donnee_intermediaire: {
+          b: 1,
+          sw: 0.52,
+          ug: 5.8,
+          uw: 5.4,
+          ujn: 3.8,
+          u_menuiserie: 3.8,
+          fe2: 1,
+          fe1: 1
+        },
+        donnee_utilisateur: {
+          enum_type_adjacence_id: [
+            '1',
+            '2',
+            '3',
+            '4',
+            '5',
+            '6',
+            '7',
+            '8',
+            '9',
+            '10',
+            '11',
+            '12',
+            '13',
+            '14',
+            '15',
+            '16',
+            '17',
+            '18',
+            '19',
+            '20',
+            '21',
+            '22'
+          ],
+          enum_type_vitrage_id: ['1', '2', '3', '4', '5', '6'],
+          enum_type_baie_id: ['1', '2', '3', '4', '5', '6', '7', '8'],
+          enum_type_materiaux_menuiserie_id: ['1', '2', '3', '4', '5', '6', '7'],
+          vitrage_vir: 'bool',
+          enum_type_pose_id: ['1', '2', '3', '4'],
+          enum_type_fermeture_id: ['1', '2', '3', '4', '5', '6', '7', '8'],
+          presence_retour_isolation: 'bool',
+          largeur_dormant: 'float'
+        }
+      }
+    ];
+
+    expect(calc_as(ilpa, ca, zc, bv)).toStrictEqual({
+      apport_solaire_ch: 1551436.4819200002,
+      apport_solaire_fr: 97009.81888
+    });
+  });
+
+  /**
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf Page 43
+   */
+  test('calcul de f apport interne', () => {
+    const ilpa = '0';
+    const ca = '400-800m';
+    const zc = 'h1c';
+    const Sh = '42.5';
+    const nadeq = '1.234375';
+
+    expect(calc_ai(ilpa, ca, zc, Sh, nadeq)).toStrictEqual({
+      apport_interne_ch: 1459229.75,
+      apport_interne_fr: 8589.5569375
+    });
+  });
+});

package/6.2_surface_sud_equivalente.js

@@ -0,0 +1,109 @@
+import enums from './enums.js';
+import tvs from './tv.js';
+import { mois_liste } from './utils.js';
+
+export function calc_sse_j(bv_list, ets, ca, zc, mois) {
+  const ssej = bv_list.reduce((acc, bv) => {
+    const typeAdjacence = parseInt(bv.donnee_entree.enum_type_adjacence_id);
+
+    /**
+     * 6.3 Traitement des espaces tampons solarisés
+     * 10 - 'espace tampon solarisé (véranda,loggia fermée)'
+     */
+    if (typeAdjacence === 10 && ets) {
+      // Certaines vérandas sont dupliqués dans les DPE.
+      if (Array.isArray(ets)) {
+        ets = ets[0];
+      }
+
+      const bver = ets.donnee_intermediaire.bver;
+      const T = ets.donnee_intermediaire.coef_transparence_ets;
+
+      /**
+       * Surface sud équivalente représentant l’impact des apports solaires associés au rayonnement solaire
+       * traversant directement l’espace tampon pour arriver dans la partie habitable du logement
+       * Calculés pour les baies vitrées qui séparent le logement de l'espace tampon
+       * @type {number}
+       */
+      const Ssdj = getBaiesSurEspaceTampon(bv_list).reduce((acc, bv) => {
+        return acc + T * getSsd(bv, zc, mois, bv.donnee_intermediaire.sw);
+      }, 0);
+
+      /**
+       * Surface sud équivalente représentant les apports solaires indirects dans le logement
+       */
+      let baies = ets.baie_ets_collection.baie_ets;
+
+      if (!Array.isArray(baies)) {
+        baies = [baies];
+      }
+
+      const Sstj = baies.reduce((acc, bv) => {
+        return acc + getSsd(bv, zc, mois, 0.8 * T + 0.024);
+      }, 0);
+
+      /**
+       * Surface sud équivalente représentant l’impact des apports solaires associés au rayonnement
+       * solaire entrant dans la partie habitable du logement après de multiples réflexions dans l’espace tampon solarisé
+       * @type {number}
+       */
+      const Ssindj = Sstj - Ssdj;
+
+      /**
+       * Impact de l’espace tampon solarisé sur les apports solaires à travers les baies vitrées qui séparent le logement
+       * de l'espace tampon
+       * @type {number}
+       */
+      const SseVerandaj = Ssdj + Ssindj * bver;
+
+      return acc + SseVerandaj;
+    }
+
+    // Pour les fenêtres qui ne donnent pas sur l'extérieur, pas de surface sud équivalente
+    if (typeAdjacence !== 1) {
+      return acc;
+    }
+
+    return acc + getSsd(bv, zc, mois, bv.donnee_intermediaire.sw);
+  }, 0);
+  return ssej;
+}
+
+/**
+ * Retourne la liste des baies vitrées qui donnent sur l'espace tampon solarisé
+ * @param baiesVitrees {BaieVitreeItem[]}
+ */
+function getBaiesSurEspaceTampon(baiesVitrees) {
+  return baiesVitrees.filter((bv) => bv.donnee_entree.enum_type_adjacence_id === '10');
+}
+
+/**
+ * Calcul de la surface sur équivalente pour la baie vitrée bv pendant le mois $mois
+ *
+ * @param bv {BaieVitreeItem}
+ * @param zc {string} zone climatique du logement
+ * @param mois {string} mois au cours duquel calculer la surface sur équivalente de la baie vitrée
+ * @param coeff {number} coefficient à appliquer à cette surface sud
+ * @returns {number}
+ */
+function getSsd(bv, zc, mois, coeff) {
+  const c1 = tvs.c1;
+
+  const de = bv.donnee_entree;
+  const di = bv.donnee_intermediaire || {};
+
+  const orientation = enums.orientation[de.enum_orientation_id];
+  const inclinaison = enums.inclinaison_vitrage[de.enum_inclinaison_vitrage_id ?? 3];
+  let oi = `${orientation} ${inclinaison}`;
+  if (inclinaison === 'horizontal') oi = 'horizontal';
+  const c1j = c1[zc][mois][oi];
+
+  const fe1 = di.fe1 ?? 1;
+  const fe2 = di.fe2 ?? 1;
+
+  return de.surface_totale_baie * c1j * coeff * fe1 * fe2;
+}
+
+export function calc_sse(ca, zc, bv_list, ets) {
+  return mois_liste.reduce((acc, mois) => acc + calc_sse_j(bv_list, ets, ca, zc, mois), 0);
+}

package/7_inertie.js

@@ -0,0 +1,178 @@
+import enums from './enums.js';
+import { getThicknessFromDescription, getKeyByValue } from './utils.js';
+
+export class Inertie {
+  #classeInertieMapping = {
+    0: 'légère',
+    1: 'moyenne',
+    2: 'lourde',
+    3: 'très lourde'
+  };
+
+  /**
+   * Return 1 if the plancher_haut has high inertia, 0 otherwise
+   * @param de {Donnee_entree}
+   * @returns {number}
+   */
+  calculateInertiePhLourd(de) {
+    const type_isolation = Number.parseInt(de.enum_type_isolation_id);
+
+    /**
+     * Type isolation
+     * 2 - Non isolé
+     * 4 - ITE
+     * 9 - isolé mais type d'isolation inconnu
+     */
+    if ([2, 4, 9].includes(type_isolation)) {
+      /**
+       * Type Plancher Haut
+       * 8 - Dalle béton
+       * 11 - Plafond lourd type entrevous terre-cuite, poutrelles béton
+       */
+      const type_plancher_haut = Number.parseInt(de.enum_type_plancher_haut_id);
+      if (!type_plancher_haut || [8, 11].includes(type_plancher_haut)) return 1;
+    }
+    return 0;
+  }
+
+  /**
+   * Return 1 if the plancher_bas has high inertia, 0 otherwise
+   * @param de {Donnee_entree}
+   * @returns {number}
+   */
+  calculateInertiePbLourd(de) {
+    const methode_saisie_u = Number.parseInt(de.enum_methode_saisie_u_id);
+    const type_isolation = Number.parseInt(de.enum_type_isolation_id);
+
+    /**
+     * Type isolation
+     * 2 - Non isolé
+     * 4 - ITE
+     * 9 - isolé mais type d'isolation inconnu
+     *
+     * Méthode Saisie
+     * 1 - non isolé
+     */
+    if (methode_saisie_u === 1 || [2, 4, 9].includes(type_isolation)) {
+      /**
+       * Type Plancher Bas
+       * 9 - Dalle béton
+       * 11 - Plancher lourd type entrevous terre-cuite, poutrelles béton
+       * 12 - Plancher à entrevous isolant
+       */
+      const type_plancher_bas = Number.parseInt(de.enum_type_plancher_bas_id);
+      if (!type_plancher_bas || [9, 11, 12].includes(type_plancher_bas)) return 1;
+    }
+    return 0;
+  }
+
+  /**
+   * Return 1 if the mur has high inertia, 0 otherwise
+   * @param de {Donnee_entree}
+   * @returns {number}
+   */
+  calculateInertieMurLourd(de) {
+    const methode_saisie_u = Number.parseInt(de.enum_methode_saisie_u_id);
+    const type_isolation = Number.parseInt(de.enum_type_isolation_id);
+
+    /**
+     * Type isolation
+     * 2 - Non isolé
+     * 4 - ITE
+     * 9 - isolé mais type d'isolation inconnu
+     *
+     * Méthode Saisie
+     * 1 - non isolé
+     */
+    if (methode_saisie_u === 1 || [2, 4, 9].includes(type_isolation)) {
+      const materiaux_structure_mur = Number.parseInt(de.enum_materiaux_structure_mur_id);
+      let epaisseur_structure = Number.parseFloat(de.epaisseur_structure);
+
+      if (!epaisseur_structure) {
+        epaisseur_structure = getThicknessFromDescription(de.description);
+      }
+
+      /**
+       * Matériaux Structure mur
+       * 2 - Murs en pierre de taille et moellons constitué d'un seul matériaux
+       * 3 - Murs en pierre de taille et moellons avec remplissage tout venant
+       * 4 - Murs en pisé ou béton de terre stabilisé (à partir d'argile crue)
+       * 19 - Murs sandwich béton/isolant/béton (sans isolation rapportée)
+       * 21 - Autre matériau traditionel ancien
+       */
+      if ([2, 3, 4, 19].includes(materiaux_structure_mur)) return 1;
+
+      /**
+       * Matériaux Structure mur
+       * 11 - Murs en blocs de béton pleins
+       * 13 - Murs en béton banché
+       */
+      if ([11, 13].includes(materiaux_structure_mur) && epaisseur_structure > 7) return 1;
+
+      /**
+       * Matériaux Structure mur
+       * 12 - Murs en blocs de béton creux
+       */
+      if ([12].includes(materiaux_structure_mur) && epaisseur_structure > 11) return 1;
+
+      /**
+       * Matériaux Structure mur
+       * 8 - Murs en briques pleines simples
+       * 9 - Murs en briques pleines doubles avec lame d'air
+       * 10 - Murs en briques creuses
+       * 15 - Brique terre cuite alvéolaire
+       */
+      if ([8, 9, 10, 15].includes(materiaux_structure_mur) && epaisseur_structure > 10.5) return 1;
+    }
+    return 0;
+  }
+
+  /**
+   * Get the inertia for a DPE based on the inertia of plancher_haut, plancher_bas and mur
+   * @param enveloppe {Enveloppe}
+   */
+  calculateInertie(enveloppe) {
+    const inertie = {
+      inertie_plancher_bas_lourd: this.#calculateInertieForCollection(
+        enveloppe.plancher_bas_collection.plancher_bas || [],
+        this.calculateInertiePbLourd
+      ),
+      inertie_plancher_haut_lourd: this.#calculateInertieForCollection(
+        enveloppe.plancher_haut_collection.plancher_haut || [],
+        this.calculateInertiePhLourd
+      ),
+      inertie_paroi_verticale_lourd: this.#calculateInertieForCollection(
+        enveloppe.mur_collection.mur || [],
+        this.calculateInertieMurLourd
+      )
+    };
+
+    const nb_inertie_lourde =
+      inertie.inertie_plancher_bas_lourd +
+      inertie.inertie_plancher_haut_lourd +
+      inertie.inertie_paroi_verticale_lourd;
+
+    return {
+      ...inertie,
+      enum_classe_inertie_id: getKeyByValue(
+        enums.classe_inertie,
+        this.#classeInertieMapping[nb_inertie_lourde]
+      )
+    };
+  }
+
+  /**
+   * Return 1 if the collection has high inertia (majority high inertia surface), 0 otherwise
+   * @param collection {PlancherBasItem[] || PlancherHautItem[] || MurItem[]}
+   * @param method - method to apply on each item to get inertia type
+   * @returns {number}
+   */
+  #calculateInertieForCollection(collection, method) {
+    const s_lourd = collection.reduce((acc, item) => {
+      const de = item.donnee_entree;
+      return acc + de.surface_paroi_opaque * method(de);
+    }, 0);
+    const s_total = collection.reduce((acc, pb) => acc + pb.donnee_entree.surface_paroi_opaque, 0);
+    return s_lourd / s_total >= 0.5 ? 1 : 0;
+  }
+}