@open3cl/engine 1.0.0

package/7_inertie.spec.js

@@ -0,0 +1,263 @@
+import { Inertie } from './7_inertie.js';
+
+describe('Inertie unit tests', () => {
+  /**
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf Page 53
+   */
+  const inertie = new Inertie();
+
+  it.each([
+    [1, 1, 0, 9],
+    [1, 1, 0, 11],
+    [1, 1, 0, 12],
+    [0, 1, 0, 10],
+    [1, 0, 2, 9],
+    [1, 0, 4, 9],
+    [1, 0, 9, 9],
+    [0, 0, 9, 10],
+    [0, 0, 3, 9],
+    [0, 0, 3, 9]
+  ])(
+    'should get inertie %s for plancher_bas with methode_saisie_u %s, type_isolation_id %s and type_plancher_bas %s',
+    (
+      inertie_result,
+      enum_methode_saisie_u_id,
+      enum_type_isolation_id,
+      enum_type_plancher_bas_id
+    ) => {
+      const de = {
+        enum_methode_saisie_u_id,
+        enum_type_isolation_id,
+        enum_type_plancher_bas_id
+      };
+      expect(inertie.calculateInertiePbLourd(de)).toBe(inertie_result);
+    }
+  );
+
+  it.each([
+    [1, 2, 8],
+    [1, 4, 8],
+    [1, 9, 8],
+    [0, 1, 8],
+    [1, 2, 8],
+    [1, 2, 11],
+    [0, 3, 8]
+  ])(
+    'should get inertie %s for plancher_haut with type_isolation_id %s and type_plancher_haut %s',
+    (inertie_result, enum_type_isolation_id, enum_type_plancher_haut_id) => {
+      const de = {
+        enum_type_isolation_id,
+        enum_type_plancher_haut_id
+      };
+      expect(inertie.calculateInertiePhLourd(de)).toBe(inertie_result);
+    }
+  );
+
+  it.each([
+    [1, 1, 0, 2, 0],
+    [1, 1, 0, 3, 0],
+    [1, 1, 0, 4, 0],
+    [1, 1, 0, 19, 0],
+    [1, 0, 2, 19, 0],
+    [1, 0, 4, 19, 0],
+    [1, 0, 9, 19, 0],
+    [0, 0, 1, 19, 0],
+    [1, 1, 0, 11, 8.3],
+    [1, 1, 0, 13, 8.3],
+    [0, 1, 0, 11, 6.2],
+    [0, 1, 0, 13, 6.2],
+    [1, 1, 0, 12, 11.3],
+    [0, 1, 0, 12, 9.2],
+    [1, 1, 0, 8, 10.6],
+    [0, 1, 0, 8, 9.2],
+    [1, 1, 0, 9, 10.6],
+    [0, 1, 0, 9, 9.2],
+    [1, 1, 0, 10, 10.6],
+    [0, 1, 0, 10, 9.2],
+    [1, 1, 0, 15, 10.6],
+    [0, 1, 0, 15, 9.2],
+    [0, 0, 0, 15, 9.2]
+  ])(
+    'should get inertie %s for mur with methode_saisie_u %s, type_isolation_id %s, materiaux_structure_mur %s and epaisseur_structure %s',
+    (
+      inertie_result,
+      enum_methode_saisie_u_id,
+      enum_type_isolation_id,
+      enum_materiaux_structure_mur_id,
+      epaisseur_structure
+    ) => {
+      const de = {
+        enum_methode_saisie_u_id,
+        enum_type_isolation_id,
+        enum_materiaux_structure_mur_id,
+        epaisseur_structure
+      };
+      expect(inertie.calculateInertieMurLourd(de)).toBe(inertie_result);
+    }
+  );
+
+  test('should get inertie for mur getting epaisseur_structure from description', () => {
+    const de = {
+      enum_type_isolation_id: 2,
+      enum_materiaux_structure_mur_id: 12
+    };
+    expect(inertie.calculateInertieMurLourd(de)).toBe(0);
+
+    de.description = "Mur en blocs de béton creux d'''épaisseur ≥ 25 cm non isolé";
+    expect(inertie.calculateInertieMurLourd(de)).toBe(1);
+
+    de.description = "Mur en blocs de béton creux d'épaisseur 4 cm non isolé";
+    expect(inertie.calculateInertieMurLourd(de)).toBe(0);
+
+    de.description = 'Mur en blocs de béton creux';
+    expect(inertie.calculateInertieMurLourd(de)).toBe(0);
+  });
+
+  test('should get inertie for plancher_bas with the majority surface', () => {
+    const enveloppe = {
+      plancher_bas_collection: {
+        plancher_bas: [
+          {
+            donnee_entree: {
+              enum_methode_saisie_u_id: 1,
+              enum_type_plancher_bas_id: 9,
+              surface_paroi_opaque: 100
+            }
+          },
+          {
+            donnee_entree: {
+              enum_methode_saisie_u_id: 0,
+              enum_type_plancher_bas_id: 9,
+              surface_paroi_opaque: 25
+            }
+          }
+        ]
+      },
+      plancher_haut_collection: {},
+      mur_collection: {}
+    };
+    // surface plancher_bas_lourd > 0.5 * surface plancher_bas
+    expect(inertie.calculateInertie(enveloppe).inertie_plancher_bas_lourd).toBe(1);
+
+    enveloppe.plancher_bas_collection.plancher_bas[0].donnee_entree.surface_paroi_opaque = 18;
+
+    // surface plancher_bas_lourd < 0.5 * surface plancher_bas
+    expect(inertie.calculateInertie(enveloppe).inertie_plancher_bas_lourd).toBe(0);
+  });
+
+  test('should get inertie for plancher_haut with the majority surface', () => {
+    const enveloppe = {
+      plancher_haut_collection: {
+        plancher_haut: [
+          {
+            donnee_entree: {
+              enum_type_isolation_id: 2,
+              enum_type_plancher_haut_id: 8,
+              surface_paroi_opaque: 100
+            }
+          },
+          {
+            donnee_entree: {
+              enum_type_isolation_id: 0,
+              enum_type_plancher_haut_id: 8,
+              surface_paroi_opaque: 25
+            }
+          }
+        ]
+      },
+      plancher_bas_collection: {},
+      mur_collection: {}
+    };
+    // surface plancher_haut_lourd > 0.5 * surface plancher_haut
+    expect(inertie.calculateInertie(enveloppe).inertie_plancher_haut_lourd).toBe(1);
+
+    enveloppe.plancher_haut_collection.plancher_haut[0].donnee_entree.surface_paroi_opaque = 18;
+
+    // surface plancher_haut_lourd < 0.5 * surface plancher_haut
+    expect(inertie.calculateInertie(enveloppe).inertie_plancher_haut_lourd).toBe(0);
+  });
+
+  test('should get inertie for mur with the majority surface', () => {
+    const enveloppe = {
+      mur_collection: {
+        mur: [
+          {
+            donnee_entree: {
+              enum_type_isolation_id: 2,
+              enum_materiaux_structure_mur_id: 2,
+              surface_paroi_opaque: 100
+            }
+          },
+          {
+            donnee_entree: {
+              enum_type_isolation_id: 1,
+              enum_materiaux_structure_mur_id: 2,
+              surface_paroi_opaque: 25
+            }
+          }
+        ]
+      },
+      plancher_bas_collection: {},
+      plancher_haut_collection: {}
+    };
+    // surface mur_lourd > 0.5 * surface mur
+    expect(inertie.calculateInertie(enveloppe).inertie_paroi_verticale_lourd).toBe(1);
+
+    enveloppe.mur_collection.mur[0].donnee_entree.surface_paroi_opaque = 18;
+
+    // surface mur_lourd < 0.5 * surface mur
+    expect(inertie.calculateInertie(enveloppe).inertie_paroi_verticale_lourd).toBe(0);
+  });
+
+  test('should get enum_classe_inertie_id', () => {
+    const enveloppe = {
+      mur_collection: {
+        mur: [
+          {
+            donnee_entree: {
+              enum_type_isolation_id: 2,
+              enum_materiaux_structure_mur_id: 2,
+              surface_paroi_opaque: 100
+            }
+          }
+        ]
+      },
+      plancher_bas_collection: {
+        plancher_bas: [
+          {
+            donnee_entree: {
+              enum_type_isolation_id: 2,
+              enum_type_plancher_bas_id: 9,
+              surface_paroi_opaque: 100
+            }
+          }
+        ]
+      },
+      plancher_haut_collection: {
+        plancher_haut: [
+          {
+            donnee_entree: {
+              enum_type_isolation_id: 2,
+              enum_type_plancher_haut_id: 8,
+              surface_paroi_opaque: 100
+            }
+          }
+        ]
+      }
+    };
+    // inertie_plancher_bas_lourd = 1 + inertie_plancher_haut_lourd = 1 + inertie_paroi_verticale_lourd = 1
+    expect(inertie.calculateInertie(enveloppe).enum_classe_inertie_id).toBe('1');
+
+    // inertie_plancher_bas_lourd = 1 + inertie_plancher_haut_lourd = 1 + inertie_paroi_verticale_lourd = 0
+    enveloppe.mur_collection.mur[0].donnee_entree.enum_type_isolation_id = 0;
+    expect(inertie.calculateInertie(enveloppe).enum_classe_inertie_id).toBe('2');
+
+    // inertie_plancher_bas_lourd = 1 + inertie_plancher_haut_lourd = 0 + inertie_paroi_verticale_lourd = 0
+    enveloppe.plancher_haut_collection.plancher_haut[0].donnee_entree.enum_type_isolation_id = 0;
+    expect(inertie.calculateInertie(enveloppe).enum_classe_inertie_id).toBe('3');
+
+    // inertie_plancher_bas_lourd = 0 + inertie_plancher_haut_lourd = 0 + inertie_paroi_verticale_lourd = 0
+    enveloppe.plancher_bas_collection.plancher_bas[0].donnee_entree.enum_type_isolation_id = 0;
+    expect(inertie.calculateInertie(enveloppe).enum_classe_inertie_id).toBe('4');
+  });
+});

package/8_intermittence.js

@@ -0,0 +1,5 @@
+export function calc_intermittence(GV, Sh, Hsp, i0) {
+  const G = GV / (Sh * Hsp);
+  const INT = i0 / (1 + 0.1 * (G - 1));
+  return INT;
+}

package/9_besoin_ch.js

@@ -0,0 +1,198 @@
+import enums from './enums.js';
+import tvs from './tv.js';
+import { calc_Qdw_j } from './14_generateur_ecs.js';
+import { calc_besoin_ecs_j } from './11_besoin_ecs.js';
+import { calc_Qrec_gen_j } from './9_generateur_ch.js';
+import { calc_ai_j, calc_as_j } from './6.1_apport_gratuit.js';
+import { calc_sse_j } from './6.2_surface_sud_equivalente.js';
+import { mois_liste } from './utils.js';
+
+export default function calc_besoin_ch(
+  ilpa,
+  ca_id,
+  zc_id,
+  inertie_id,
+  Sh,
+  GV,
+  nadeq,
+  instal_ecs,
+  instal_ch,
+  bv,
+  ets
+) {
+  const ca = enums.classe_altitude[ca_id];
+  const zc = enums.zone_climatique[zc_id];
+  const inertie = enums.classe_inertie[inertie_id];
+
+  let besoin_ch = 0;
+  let besoin_ch_depensier = 0;
+
+  const dh21 = tvs.dh21[ilpa];
+  const dh19 = tvs.dh19[ilpa];
+  const Nref21 = tvs.nref21[ilpa];
+  const Nref19 = tvs.nref19[ilpa];
+
+  let sumNref19 = 0;
+  let sumNref21 = 0;
+  let sumDh19 = 0;
+  let sumDh21 = 0;
+  let QrecDistr = 0;
+  let QrecDistrDepensier = 0;
+  const e = tvs.e[ilpa];
+
+  let pertes_distribution_ecs_recup = 0;
+  let pertes_distribution_ecs_recup_depensier = 0;
+  let pertes_stockage_ecs_recup = 0;
+  let pertes_stockage_ecs_recup_depensier = 0;
+  let pertes_generateur_ch_recup = 0;
+  let pertes_generateur_ch_recup_depensier = 0;
+  let fraction_apport_gratuit_ch = 0;
+  let fraction_apport_gratuit_depensier_ch = 0;
+
+  const Qgw_total = instal_ecs.reduce((acc, instal_ecs) => {
+    const gen_ecs = instal_ecs.generateur_ecs_collection.generateur_ecs;
+
+    // 17.2.1.1 Calcul des consommations de chauffage, de refroidissement, d’ECS et d’auxiliaires
+    // Pour les installations ECS collectives, pas de récupération de stockage d'ECS
+    if (Number.parseInt(instal_ecs.donnee_entree.enum_type_installation_id) !== 1) {
+      return acc;
+    }
+
+    return (
+      acc +
+      gen_ecs.reduce((acc, gen_ecs) => {
+        // Pas de récupération de stockage si le ballon est hors volume chauffé
+        if (
+          gen_ecs.donnee_entree.position_volume_chauffe_stockage === 0 ||
+          gen_ecs.donnee_entree.position_volume_chauffe === 0
+        ) {
+          return acc;
+        }
+
+        return acc + (gen_ecs.donnee_intermediaire.Qgw || 0);
+      }, 0)
+    );
+  }, 0);
+
+  /**
+   * 11.4 Plusieurs systèmes d’ECS (limité à 2 systèmes différents par logement)
+   * Les besoins en ECS pour chaque générateur sont / 2
+   */
+  const prorataEcs = instal_ecs.length > 1 ? 0.5 : 1;
+
+  /**
+   * Création de la liste des générateurs de chauffage pour lesquels il y a une récupération d'énergie
+   *
+   * 9.1.1 - Pertes récupérées de génération pour le chauffage sur le mois j (Wh)
+   * Ce calcul ne s’applique qu’au générateur pour lesquels des pertes à l’arrêt Qp0 sont prises en compte.
+   * Seules les pertes des générateurs et des ballons de stockage en volume chauffé sont récupérables. Les pertes
+   * récupérées des générateurs d’air chaud sont nulles.
+   *
+   * @type {GenerateurChauffageItem[]}
+   */
+  const gen_ch_recup = instal_ch.flatMap((inst_ch) =>
+    inst_ch.generateur_chauffage_collection.generateur_chauffage.filter(
+      (gen_ch) =>
+        gen_ch.donnee_intermediaire.qp0 && (gen_ch.donnee_entree.position_volume_chauffe ?? 0)
+    )
+  );
+
+  for (const mois of mois_liste) {
+    const nref19 = Nref19[ca][mois][zc];
+    const nref21 = Nref21[ca][mois][zc];
+
+    const Qrec_stock_19 = (0.48 * nref19 * Qgw_total) / (24 * 365);
+    const Qrec_stock_21 = (0.48 * nref21 * Qgw_total) / (24 * 365);
+    pertes_stockage_ecs_recup += Qrec_stock_19 / 1000;
+    pertes_stockage_ecs_recup_depensier += Qrec_stock_21 / 1000;
+
+    // pertes distribution
+    const becs_j = calc_besoin_ecs_j(ca, mois, zc, nadeq, false) * prorataEcs;
+    const becs_j_dep = calc_besoin_ecs_j(ca, mois, zc, nadeq, true) * prorataEcs;
+    sumNref19 += nref19;
+    sumNref21 += nref21;
+
+    QrecDistr += instal_ecs.reduce((acc, ecs) => acc + calc_Qdw_j(ecs, becs_j), 0);
+    QrecDistrDepensier += instal_ecs.reduce((acc, ecs) => acc + calc_Qdw_j(ecs, becs_j_dep), 0);
+
+    // bvj
+    const dh19j = dh19[ca][mois][zc];
+    sumDh19 += dh19j;
+    const dh21j = dh21[ca][mois][zc];
+    sumDh21 += dh21j;
+    const aij = calc_ai_j(Sh, nadeq, nref19);
+    const aij_dep = calc_ai_j(Sh, nadeq, nref21);
+    const ssej = calc_sse_j(bv, ets, ca, zc, mois);
+    const ej = e[ca][mois][zc];
+    const asj = calc_as_j(ssej, ej);
+    const Fj = calc_Fj(GV, asj, aij, dh19j, inertie);
+    const Fj_dep = calc_Fj(GV, asj, aij_dep, dh21j, inertie);
+
+    fraction_apport_gratuit_ch += Fj * dh19j;
+    fraction_apport_gratuit_depensier_ch += Fj_dep * dh21j;
+
+    const bvj = dh19j === 0 ? 0 : calc_bvj(GV, Fj);
+    const bvj_dep = dh21j === 0 ? 0 : calc_bvj(GV, Fj_dep);
+
+    // pertes generation
+    const Bch_hp_j = bvj * dh19j;
+    const Bch_hp_j_dep = bvj_dep * dh21j;
+
+    gen_ch_recup.forEach((gen_ch) => {
+      pertes_generateur_ch_recup += calc_Qrec_gen_j(gen_ch, nref19, Bch_hp_j) / (1000 * 1000);
+      pertes_generateur_ch_recup_depensier +=
+        calc_Qrec_gen_j(gen_ch, nref21, Bch_hp_j_dep) / (1000 * 1000);
+    });
+
+    besoin_ch += Bch_hp_j / 1000;
+    besoin_ch_depensier += Bch_hp_j_dep / 1000;
+  }
+
+  pertes_distribution_ecs_recup = (0.48 * sumNref19 * QrecDistr) / 8760;
+  pertes_distribution_ecs_recup_depensier = (0.48 * sumNref21 * QrecDistrDepensier) / 8760;
+
+  const recup =
+    pertes_distribution_ecs_recup + pertes_stockage_ecs_recup + pertes_generateur_ch_recup;
+  const recup_depensier =
+    pertes_distribution_ecs_recup_depensier +
+    pertes_stockage_ecs_recup_depensier +
+    pertes_generateur_ch_recup_depensier;
+
+  besoin_ch -= recup;
+  besoin_ch_depensier -= recup_depensier;
+
+  fraction_apport_gratuit_ch /= sumDh19;
+  fraction_apport_gratuit_depensier_ch /= sumDh21;
+
+  return {
+    besoin_ch,
+    besoin_ch_depensier,
+    pertes_distribution_ecs_recup,
+    pertes_distribution_ecs_recup_depensier,
+    pertes_stockage_ecs_recup,
+    /* pertes_stockage_ecs_recup_depensier: pertes_stockage_ecs_recup_depensier, */
+    pertes_generateur_ch_recup,
+    pertes_generateur_ch_recup_depensier,
+    fraction_apport_gratuit_ch,
+    fraction_apport_gratuit_depensier_ch
+  };
+}
+
+function calc_Fj(GV, asj, aij, dhj, inertie) {
+  if (dhj == 0) return 0;
+
+  let pow;
+  if (inertie === 'très lourde' || inertie === 'lourde') pow = 3.6;
+  else if (inertie === 'moyenne') pow = 2.9;
+  else if (inertie === 'légère') pow = 2.5;
+
+  const Xj = (asj + aij) / (GV * dhj);
+  const Fj = (Xj - Xj ** pow) / (1 - Xj ** pow);
+  /* console.warn(Fj) */
+  return Fj;
+}
+
+function calc_bvj(GV, Fj) {
+  const bvj = GV * (1 - Fj);
+  return bvj;
+}