@open3cl/engine 1.0.0

package/10_besoin_fr.js

@@ -0,0 +1,76 @@
+import { tvs } from './tv.js';
+import { mois_liste } from './utils.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';
+
+const Cin = {
+  'très lourde': 260000,
+  lourde: 260000,
+  moyenne: 165000,
+  légère: 110000
+};
+
+export function calc_besoin_fr_j(Sh, GV, inertie, aij_fr, asj_fr, nrefj, textmoy_clim_j, Tint) {
+  if (nrefj == 0) return 0;
+  const Rbth = (aij_fr + asj_fr) / (GV * (textmoy_clim_j - Tint) * nrefj);
+
+  if (Rbth < 1 / 2) return 0;
+
+  const t = (Cin[inertie] * Sh) / (3600 * GV);
+  const a = 1 + t / 15;
+  let futj;
+  if (Rbth === 1) futj = a / (a + 1);
+  else futj = (1 - Rbth ** -a) / (1 - Rbth ** (-a - 1));
+  const bfr = (aij_fr + asj_fr) / 1000 - ((futj * GV) / 1000) * (Tint - textmoy_clim_j) * nrefj;
+  return bfr;
+}
+
+export default function calc_besoin_fr(ca, zc, Sh, nadeq, GV, inertie, bv, ets) {
+  const Nref26 = tvs.nref26;
+  const Nref28 = tvs.nref28;
+  const e_fr_26 = tvs.e_fr_26;
+  const e_fr_28 = tvs.e_fr_28;
+  const textmoy_clim_26 = tvs.textmoy_clim_26;
+  const textmoy_clim_28 = tvs.textmoy_clim_28;
+
+  const ret = {
+    besoin_fr: 0,
+    besoin_fr_depensier: 0
+  };
+  for (const mois of mois_liste) {
+    const nref26 = Nref26[ca][mois][zc];
+    const nref28 = Nref28[ca][mois][zc];
+    const ej_fr_26 = e_fr_26[ca][mois][zc];
+    const ej_fr_28 = e_fr_28[ca][mois][zc];
+    const textmoy_clim_j_26 = textmoy_clim_26[ca][mois][zc];
+    const textmoy_clim_j_28 = textmoy_clim_28[ca][mois][zc];
+
+    const aij_fr = calc_ai_j(Sh, nadeq, nref28);
+    const aij_fr_dep = calc_ai_j(Sh, nadeq, nref26);
+    const ssej = calc_sse_j(bv, ets, ca, zc, mois);
+    const asj_fr = calc_as_j(ssej, ej_fr_28);
+    const asj_fr_dep = calc_as_j(ssej, ej_fr_26);
+
+    ret.besoin_fr += calc_besoin_fr_j(
+      Sh,
+      GV,
+      inertie,
+      aij_fr,
+      asj_fr,
+      nref28,
+      textmoy_clim_j_28,
+      28
+    );
+    ret.besoin_fr_depensier += calc_besoin_fr_j(
+      Sh,
+      GV,
+      inertie,
+      aij_fr_dep,
+      asj_fr_dep,
+      nref26,
+      textmoy_clim_j_26,
+      26
+    );
+  }
+  return ret;
+}

package/10_clim.js

@@ -0,0 +1,45 @@
+import { requestInputID, tv } from './utils.js';
+
+function tv_seer(di, de, du, zc_id) {
+  const matcher = {
+    enum_zone_climatique_id: zc_id,
+    enum_periode_installation_fr_id: requestInputID(de, du, 'periode_installation_fr')
+  };
+  const row = tv('seer', matcher, de);
+  if (row) {
+    de.tv_seer_id = Number(row.tv_seer_id);
+    di.eer = row.eer;
+  } else {
+    console.error('!! pas de valeur forfaitaire trouvée pour seer !!');
+  }
+}
+
+export default function calc_clim(clim, bfr, bfr_dep, zc_id, Sh) {
+  const de = clim.donnee_entree;
+  const di = clim.donnee_intermediaire || {};
+  const du = {};
+
+  const rs = de.surface_clim / Sh;
+  di.besoin_fr = bfr * rs;
+  di.besoin_fr_depensier = bfr_dep * rs;
+
+  /**
+   * Si la méthode de saisie n'est pas "Valeur forfaitaire" mais "caractéristiques saisies"
+   * Documentation 3CL : "Pour les installations récentes ou recommandées, les caractéristiques réelles des chaudières présentées sur les bases
+   * de données professionnelles peuvent être utilisées."
+   *
+   * 6 - caractéristiques saisies à partir de la plaque signalétique ou d'une documentation technique du système thermodynamique : scop/cop/eer
+   * 7 - déterminé à partir du rset/rsee( etude rt2012/re2020)
+   * 8 - seer saisi pour permettre la saisie de réseau de froid ou de système de climatisations qui ne sont pas éléctriques
+   */
+  const methodeSaisie = parseInt(de.enum_methode_saisie_carac_sys_id);
+  if (![6, 7, 8].includes(methodeSaisie) || !di.eer) {
+    tv_seer(di, de, du, zc_id);
+  }
+
+  di.conso_fr = (0.9 * di.besoin_fr) / di.eer;
+  di.conso_fr_depensier = (0.9 * di.besoin_fr_depensier) / di.eer;
+
+  clim.donnee_intermediaire = di;
+  clim.donnee_utilisateur = du;
+}

package/11_besoin_ecs.js

@@ -0,0 +1,25 @@
+import { tvs } from './tv.js';
+import { mois_liste, Njj } from './utils.js';
+
+export function calc_besoin_ecs_j(ca, mois, zc, nadeq, depensier) {
+  const tefsj = tvs.tefs[ca][mois][zc];
+  const njj = Njj[mois];
+
+  if (depensier) {
+    return (1.163 * nadeq * 79 * (40 - tefsj) * njj) / 1000;
+  } else {
+    return (1.163 * nadeq * 56 * (40 - tefsj) * njj) / 1000;
+  }
+}
+
+export default function calc_besoin_ecs(ca, zc, nadeq) {
+  const ret = {
+    besoin_ecs: 0,
+    besoin_ecs_depensier: 0
+  };
+  for (const mois of mois_liste) {
+    ret.besoin_ecs += calc_besoin_ecs_j(ca, mois, zc, nadeq, false);
+    ret.besoin_ecs_depensier += calc_besoin_ecs_j(ca, mois, zc, nadeq, true);
+  }
+  return ret;
+}

package/11_ecs.js

@@ -0,0 +1,95 @@
+import enums from './enums.js';
+import calc_gen_ecs from './14_generateur_ecs.js';
+import { tv, requestInput } from './utils.js';
+
+function tv_rendement_distribution_ecs(di, de, du, pvc) {
+  let matcher = {};
+
+  if (de.tv_rendement_distribution_ecs_id) {
+    matcher['tv_rendement_distribution_ecs_id'] = de.tv_rendement_distribution_ecs_id;
+  } else {
+    const type_installation = enums.type_installation[de.enum_type_installation_id];
+
+    let configuration_logement;
+    if (type_installation.includes('individuelle')) {
+      if (pvc === 1) {
+        configuration_logement = 'production volume habitable [+] pièces alimentées contiguës';
+      } else configuration_logement = 'production hors volume habitable';
+    } else if (type_installation.includes('collective')) {
+      let type_reseau_collectif;
+      if (type_installation.includes('multi-bâtiment')) {
+        configuration_logement = 'majorité des logements avec pièces alimentées non contiguës';
+      } else {
+        configuration_logement = 'majorité des logements avec pièces alimentées contiguës';
+      }
+      const isole = requestInput(de, du, 'reseau_distribution_isole', 'bool');
+      if (isole === 0) {
+        type_reseau_collectif = 'Réseau collectif non isolé';
+      } else {
+        const type_bouclage = requestInput(de, du, 'bouclage_reseau_ecs');
+        if (type_bouclage === "réseau d'ecs bouclé") {
+          type_reseau_collectif = 'Réseau collectif isolé bouclé';
+        } else {
+          configuration_logement = null;
+          type_reseau_collectif =
+            'Réseau collectif isolé avec traçage ou Réseau collectif isolé sans traçage ni bouclage';
+        }
+      }
+      matcher.type_reseau_collectif = type_reseau_collectif;
+    }
+    if (configuration_logement) matcher.configuration_logement = configuration_logement;
+  }
+
+  const row = tv('rendement_distribution_ecs', matcher);
+  if (row) {
+    di.rendement_distribution = Number(row.rd);
+    de.tv_rendement_distribution_ecs_id = Number(row.tv_rendement_distribution_ecs_id);
+  } else {
+    console.error('!! pas de valeur forfaitaire trouvée pour rd !!');
+  }
+}
+
+export default function calc_ecs(
+  dpe,
+  ecs,
+  becs,
+  becs_dep,
+  GV,
+  ca_id,
+  zc_id,
+  th,
+  virtualisationECS
+) {
+  const de = ecs.donnee_entree;
+  const di = {};
+  const du = {};
+
+  // La conso de chaque générateur ECS doit être ramenée au prorata de la surface du logement
+  di.ratio_besoin_ecs = 1;
+  if (virtualisationECS) {
+    di.ratio_besoin_ecs = de.cle_repartition_ecs || 1;
+  } else if (de.rdim) {
+    di.ratio_besoin_ecs = 1 / de.rdim || 1;
+  }
+
+  di.besoin_ecs = becs * di.ratio_besoin_ecs;
+  di.besoin_ecs_depensier = becs_dep * di.ratio_besoin_ecs;
+
+  const pvc = ecs.generateur_ecs_collection.generateur_ecs[0].donnee_entree.position_volume_chauffe;
+  tv_rendement_distribution_ecs(di, de, du, pvc);
+
+  const gen_ecs_list = ecs.generateur_ecs_collection.generateur_ecs;
+  gen_ecs_list.forEach((gen_ecs) => calc_gen_ecs(dpe, gen_ecs, di, de, GV, ca_id, zc_id, th));
+
+  di.conso_ecs = gen_ecs_list.reduce(
+    (acc, gen_ecs) => acc + gen_ecs.donnee_intermediaire.conso_ecs,
+    0
+  );
+  di.conso_ecs_depensier = gen_ecs_list.reduce(
+    (acc, gen_ecs) => acc + gen_ecs.donnee_intermediaire.conso_ecs_depensier,
+    0
+  );
+
+  ecs.donnee_intermediaire = di;
+  ecs.donnee_utilisateur = du;
+}

package/11_nadeq.js

@@ -0,0 +1,87 @@
+export class Nadeq {
+  /**
+   * Return nadeq for maison or individual logement
+   * @param surfaceHabitableLogement {number}
+   * @returns {number}
+   */
+  calculateIndividualNadeq(surfaceHabitableLogement) {
+    let Nmax;
+
+    if (surfaceHabitableLogement < 30) Nmax = 1;
+    else if (surfaceHabitableLogement < 70) Nmax = 1.75 - 0.01875 * (70 - surfaceHabitableLogement);
+    else Nmax = 0.025 * surfaceHabitableLogement;
+
+    if (Nmax < 1.75) return Nmax;
+    else return 1.75 + 0.3 * (Nmax - 1.75);
+  }
+
+  /**
+   * Return nadeq for immeuble or collective logement
+   * @param surfaceHabitableImmeuble {number}
+   * @param nombreAppartement {number}
+   * @returns {number}
+   */
+  calculateCollectiveNadeq(surfaceHabitableImmeuble, nombreAppartement) {
+    const Shmoy = surfaceHabitableImmeuble / nombreAppartement;
+
+    let Nmax;
+    if (Shmoy < 10) Nmax = 1;
+    else if (Shmoy < 50) Nmax = 1.75 - 0.01875 * (50 - Shmoy);
+    else Nmax = 0.035 * Shmoy;
+
+    if (Nmax < 1.75) return nombreAppartement * Nmax;
+    else return nombreAppartement * (1.75 + 0.3 * (Nmax - 1.75));
+  }
+
+  /**
+   * Get nadeq for a DPE
+   * @param logement {Logement}
+   * @returns {number}
+   */
+  calculateNadeq(logement) {
+    /**
+     * enum_methode_application_dpe_log_id pour maison individuelle
+     * 1 - dpe maison individuelle
+     * 14 - dpe issu d'une étude thermique réglementaire RT2012 bâtiment : maison individuelle
+     * 18 - dpe issu d'une étude energie environement réglementaire RE2020 bâtiment : maison individuelle
+     */
+    if (
+      [1, 14, 18].includes(
+        Number(logement.caracteristique_generale.enum_methode_application_dpe_log_id)
+      )
+    ) {
+      return this.calculateIndividualNadeq(
+        logement.caracteristique_generale.surface_habitable_logement
+      );
+    } else if (
+      [2, 3, 4, 5, 31, 32, 35, 36, 37].includes(
+        Number(logement.caracteristique_generale.enum_methode_application_dpe_log_id)
+      )
+    ) {
+      /**
+       * enum_methode_application_dpe_log_id - pour appartements
+       * 2 - dpe appartement individuel chauffage individuel ecs individuel
+       * 3 - dpe appartement individuel chauffage collectif ecs individuel
+       * 4 - dpe appartement individuel chauffage individuel ecs collectif
+       * 5 - dpe appartement individuel chauffage collectif ecs collectif
+       * 31 - dpe appartement individuel chauffage mixte (collectif-individuel) ecs individuel
+       * 32 - dpe appartement individuel chauffage mixte (collectif-individuel) ecs collectif
+       * 35 - dpe appartement individuel chauffage mixte (collectif-individuel) ecs mixte (collectif-individuel)
+       * 36 - dpe appartement individuel chauffage individuel ecs mixte (collectif-individuel)
+       * 37 - dpe appartement individuel chauffage collectif ecs mixte (collectif-individuel)
+       */
+      return this.calculateCollectiveNadeq(
+        logement.caracteristique_generale.surface_habitable_logement,
+        1
+      );
+    }
+
+    /**
+     * enum_methode_application_dpe_log_id - pour immeuble ou DPE appartement généré à partir du DPE immeuble
+     */
+    return this.calculateCollectiveNadeq(
+      logement.caracteristique_generale.surface_habitable_immeuble,
+      logement.caracteristique_generale.nombre_appartement
+    );
+  }
+}

package/11_nadeq.spec.js

@@ -0,0 +1,55 @@
+import { Nadeq } from './11_nadeq.js';
+
+describe('Nadeq unit tests', () => {
+  /**
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf Page 70
+   */
+  const nadeq = new Nadeq();
+
+  it.each([
+    [1, 8],
+    [1, 28],
+    [1.28125, 45],
+    [1.39375, 51],
+    [1.75, 70],
+    [1.7875, 75]
+  ])(
+    'should get individual nadeq %s for surface_habitable_logement %s',
+    (expectedNadeq, surface_habitable_logement) => {
+      const logement = {
+        caracteristique_generale: {
+          enum_methode_application_dpe_log_id: 1,
+          surface_habitable_logement
+        }
+      };
+      expect(nadeq.calculateNadeq(logement)).toBe(expectedNadeq);
+    }
+  );
+
+  it.each([
+    [1, 8, 1],
+    [2, 8, 2],
+    [1.3375, 28, 1],
+    [2.15, 28, 2],
+    [1.65625, 45, 1],
+    [2.46875, 45, 2],
+    [1.7605, 51, 1],
+    [2.58125, 51, 2],
+    [1.96, 70, 1],
+    [2.9375, 70, 2],
+    [2.0125, 75, 1],
+    [3.03125, 75, 2]
+  ])(
+    'should get collective nadeq %s for surface_habitable_immeuble %s, nombre_appartement %s',
+    (expectedNadeq, surface_habitable_immeuble, nombre_appartement) => {
+      const logement = {
+        caracteristique_generale: {
+          enum_methode_application_dpe_log_id: 6,
+          surface_habitable_immeuble,
+          nombre_appartement
+        }
+      };
+      expect(nadeq.calculateNadeq(logement)).toBeCloseTo(expectedNadeq, 2);
+    }
+  );
+});

package/12.4_pac.js

@@ -0,0 +1,54 @@
+import { requestInputID, tv } from './utils.js';
+
+/**
+ * Calcul ou récupération des paramètres scop ou cop
+ * @param di {Donnee_intermediaire}
+ * @param de {Donnee_entree}
+ * @param du {Object}
+ * @param zc_id {string}
+ * @param ed_id {string|null}
+ * @param type {'ecs'|'ch'}
+ */
+export function scopOrCop(di, de, du, zc_id, ed_id, type) {
+  /**
+   * Si la méthode de saisie n'est pas "Valeur forfaitaire" mais "caractéristiques saisies"
+   * Documentation 3CL : "Pour les installations récentes ou recommandées, les caractéristiques réelles présentées sur les bases
+   * de données professionnelles peuvent être utilisées."
+   *
+   * 6 - caractéristiques saisies à partir de la plaque signalétique ou d'une documentation technique du système thermodynamique : scop/cop/eer
+   */
+  if (de.enum_methode_saisie_carac_sys_id === '6') {
+    di.rg = di.scop || di.cop;
+    di.rg_dep = di.scop || di.cop;
+  } else {
+    tv_scop(di, de, du, zc_id, ed_id, type);
+  }
+}
+
+function tv_scop(di, de, du, zc_id, ed_id, type) {
+  const matcher = {
+    enum_zone_climatique_id: zc_id
+  };
+  matcher[`enum_type_generateur_${type}_id`] = requestInputID(de, du, `type_generateur_${type}`);
+  if (ed_id) matcher.enum_type_emission_distribution_id = ed_id;
+  const row = tv('scop', matcher, de);
+  if (row) {
+    const scop = row.scop_ou_cop;
+    di[scop] = Number(row.scop);
+
+    if (de.tv_scop_id && de.tv_scop_id !== Number(row.tv_scop_id)) {
+      console.error(`
+        Le paramètre ${scop} utilisé par le DPE est erroné. 
+        Utilisation de tv_scop_id = ${de.tv_scop_id} alors que devrait être utilisé tv_scop_id = ${row.tv_scop_id} (utilisé dans la suite du calcul) 
+      `);
+    }
+
+    de.tv_scop_id = Number(row.tv_scop_id);
+
+    // for Ich
+    di.rg = di[scop];
+    di.rg_dep = di[scop];
+  } else {
+    console.error('!! pas de valeur forfaitaire trouvée pour scop !!');
+  }
+}