@open3cl/engine 1.0.0

package/3_deperdition.js

@@ -0,0 +1,258 @@
+import enums from './enums.js';
+import calc_mur from './3.2.1_mur.js';
+import calc_pb from './3.2.2_plancher_bas.js';
+import calc_ph from './3.2.3_plancher_haut.js';
+import calc_bv from './3.3_baie_vitree.js';
+import calc_porte from './3.3.1.4_porte.js';
+import calc_pont_thermique from './3.4_pont_thermique.js';
+import calc_ventilation from './4_ventilation.js';
+
+function calc_Sdep(murs_list, porte_list, bv_list) {
+  const Smurs_dep = murs_list.reduce((acc, mur) => {
+    const type_adjacence = enums.type_adjacence[mur.donnee_entree.enum_type_adjacence_id];
+    if (mur.donnee_intermediaire.b === 0) return acc;
+    if (type_adjacence.includes('local non déperditif')) return acc;
+    else return acc + Number(mur.donnee_entree.surface_paroi_opaque);
+  }, 0);
+  const Sporte = porte_list.reduce((acc, porte) => {
+    if (porte.donnee_intermediaire.b === 0) return acc;
+    return acc + Number(porte.donnee_entree.surface_porte);
+  }, 0);
+  const Sbv = bv_list.reduce((acc, bv) => {
+    if (bv.donnee_intermediaire.b === 0) return acc;
+    return acc + Number(bv.donnee_entree.surface_totale_baie);
+  }, 0);
+  const Sdep = Smurs_dep + Sporte + Sbv;
+  return Sdep;
+}
+
+export function Umur(o) {
+  const de = o.donnee_entree;
+  const di = o.donnee_intermediaire;
+  return de.surface_paroi_opaque * di.umur * di.b;
+}
+
+export function Uph(o) {
+  const de = o.donnee_entree;
+  const di = o.donnee_intermediaire;
+  return de.surface_paroi_opaque * di.uph * di.b;
+}
+
+export function Upb(o) {
+  const de = o.donnee_entree;
+  const di = o.donnee_intermediaire;
+  return de.surface_paroi_opaque * di.upb_final * di.b;
+}
+
+export function Ubv(o) {
+  const de = o.donnee_entree;
+  const di = o.donnee_intermediaire;
+  return de.surface_totale_baie * di.u_menuiserie * di.b;
+}
+
+export function Uporte(o) {
+  const de = o.donnee_entree;
+  const di = o.donnee_intermediaire;
+  return de.surface_porte * di.uporte * di.b;
+}
+
+/**
+ * Compare la liste des ponts thermiques déclarés et calculés
+ * Retourne true si individuellement chacun des ponts thermiques est identique
+ * @param calculatedPTs
+ * @param declaredPTs
+ * @returns {boolean}
+ */
+function verifyPontsThermiquesEquality(calculatedPTs, declaredPTs) {
+  /**
+   * Pour les ponts thermiques déclarés, le facteur deperdition_pont_thermique étant déjà pris en compte, seul k est considéré
+   */
+  const uptForCalculatedPTs = calculatedPTs.map(
+    (calculatedPT) =>
+      calculatedPT.donnee_intermediaire.k *
+      (calculatedPT.donnee_entree.pourcentage_valeur_pont_thermique || 1)
+  );
+  const uptForDeclaredPTs = declaredPTs.map((declaredPT) => declaredPT.donnee_intermediaire.k);
+
+  return (
+    calculatedPTs.length === declaredPTs.length &&
+    !uptForCalculatedPTs.some((val, i) => {
+      return (
+        val.toFixed(3) !== uptForDeclaredPTs[i].toFixed(3) &&
+        val.toFixed(3) !==
+          (
+            uptForDeclaredPTs[i] *
+            (calculatedPTs[i].donnee_entree.pourcentage_valeur_pont_thermique || 1)
+          ).toFixed(3)
+      );
+    })
+  );
+}
+
+/**
+ * Compare la liste des murs déclarés et calculés
+ * Retourne true si individuellement chacun des murs est identique
+ * @param calculatedMurs
+ * @param declaredMurs
+ * @returns {boolean}
+ */
+function verifyMursEquality(calculatedMurs, declaredMurs) {
+  const uMurForCalculatedMurs = calculatedMurs.map(
+    (calculatedMur) =>
+      calculatedMur.donnee_entree.surface_paroi_opaque *
+      calculatedMur.donnee_intermediaire.umur *
+      calculatedMur.donnee_intermediaire.b
+  );
+  const uMurForDeclaredMurs = declaredMurs.map(
+    (declaredMur) =>
+      declaredMur.donnee_entree.surface_paroi_opaque *
+      declaredMur.donnee_intermediaire.umur *
+      declaredMur.donnee_intermediaire.b
+  );
+
+  return (
+    calculatedMurs.length === declaredMurs.length &&
+    !uMurForCalculatedMurs.some((val, i) => val.toFixed(3) !== uMurForDeclaredMurs[i].toFixed(3))
+  );
+}
+
+/**
+ * Calcul de la déperdition totale liée aux ponts thermiques
+ * @param dpe {FullDpe}
+ * @param calculatedPontsThermiques
+ * @param declaredPontsThermiques
+ * @return {number}
+ */
+function totalDeperditionPontThermique(dpe, calculatedPontsThermiques, declaredPontsThermiques) {
+  // Total déclaré des déperditions des ponts thermiques
+  const declaredDeperditionPT = dpe.logement.sortie.deperdition.deperdition_pont_thermique;
+
+  /**
+   * Comparaison des valeurs intermédiaires calculées et déclarées pour chacun des ponts thermiques
+   * @type {boolean}
+   */
+  const sameValues = verifyPontsThermiquesEquality(
+    calculatedPontsThermiques,
+    declaredPontsThermiques
+  );
+
+  const calculatedDeperditionPT = calculatedPontsThermiques.reduce(
+    (acc, pt) => acc + Upt(pt) || 0,
+    0
+  );
+
+  /**
+   * Si individuellement les ponts thermiques déclarés et calculés sont identiques, la déperdition totale devrait l'être également
+   * Pour certains DPE, il réside une différence que l'on prendra en compte pour la suite des calculs.
+   */
+  if (sameValues && calculatedDeperditionPT.toFixed(5) !== declaredDeperditionPT.toFixed(5)) {
+    console.error(
+      `Les valeurs des ponts thermiques calculées et déclarées pour le DPE ${dpe.numero_dpe} sont les mêmes mais le total des déperditions pour les ponts thermiques
+       ${declaredDeperditionPT} diffère du total calculé avec les mêmes valeurs ${declaredDeperditionPT}'. Le total déclaré est conservé.`
+    );
+    return declaredDeperditionPT;
+  }
+  return calculatedDeperditionPT;
+}
+
+/**
+ * Calcul de la déperdition totale liée aux murs
+ * @param dpe {FullDpe}
+ * @param calculatedMurs
+ * @param declaredMurs
+ * @return {number}
+ */
+function totalDeperditionMurs(dpe, calculatedMurs, declaredMurs) {
+  // Total déclaré des déperditions des murs
+  const declaredDeperditionMurs = dpe.logement.sortie.deperdition.deperdition_mur;
+
+  /**
+   * Comparaison des valeurs intermédiaires calculées et déclarées pour chacun des murs
+   * @type {boolean}
+   */
+  const sameValues = verifyMursEquality(calculatedMurs, declaredMurs);
+
+  const calculatedDeperditionMur = calculatedMurs.reduce((acc, mur) => acc + Umur(mur) || 0, 0);
+
+  /**
+   * Si individuellement les murs déclarés et calculés sont identiques, la déperdition totale devrait l'être également
+   * Pour certains DPE, il réside une différence que l'on prendra en compte pour la suite des calculs.
+   */
+  if (sameValues && calculatedDeperditionMur.toFixed(5) !== declaredDeperditionMurs.toFixed(5)) {
+    if (declaredDeperditionMurs.toFixed(5) > calculatedDeperditionMur.toFixed(5)) {
+      console.error(
+        `Les valeurs des murs calculées et déclarées pour le DPE ${dpe.numero_dpe} sont les mêmes mais le total déclaré des déperditions pour les murs
+       '${declaredDeperditionMurs}' diffère et est supérieure au total calculé avec les mêmes valeurs '${calculatedDeperditionMur}'. Le total déclaré est conservé.`
+      );
+
+      return declaredDeperditionMurs;
+    } else {
+      console.error(
+        `Les valeurs des murs calculées et déclarées pour le DPE ${dpe.numero_dpe} sont les mêmes mais le total déclaré des déperditions pour les murs
+       '${declaredDeperditionMurs}' diffère et est inférieure au total calculé avec les mêmes valeurs '${calculatedDeperditionMur}'. Le total calculé est conservé.`
+      );
+
+      return calculatedDeperditionMur;
+    }
+  }
+  return calculatedDeperditionMur;
+}
+
+export function Upt(pt) {
+  const de = pt.donnee_entree;
+  const di = pt.donnee_intermediaire;
+
+  return de.l * di.k * (de.pourcentage_valeur_pont_thermique || 1);
+}
+
+export default function calc_deperdition(cg, zc, th, effetJoule, dpe, Sh) {
+  const pc = cg.enum_periode_construction_id;
+  const logement = dpe.logement;
+  const enveloppe = logement.enveloppe;
+
+  const mur_list = enveloppe.mur_collection.mur || [];
+  const declaredMurs = structuredClone(mur_list);
+  const pb_list = enveloppe.plancher_bas_collection.plancher_bas || [];
+  const ph_list = enveloppe.plancher_haut_collection.plancher_haut || [];
+  const porte_list = enveloppe.porte_collection.porte || [];
+  const bv_list = enveloppe.baie_vitree_collection.baie_vitree || [];
+  const pt_list = enveloppe.pont_thermique_collection.pont_thermique || [];
+  const declaredPontsThermiques = structuredClone(pt_list);
+  const vt_list = logement.ventilation_collection.ventilation || [];
+
+  mur_list.forEach((mur) => calc_mur(mur, zc, pc, effetJoule));
+  pb_list.forEach((pb) => calc_pb(pb, zc, pc, effetJoule, pb_list));
+  ph_list.forEach((ph) => calc_ph(ph, zc, pc, effetJoule));
+  bv_list.forEach((bv) => calc_bv(bv, zc));
+  porte_list.forEach((porte) => calc_porte(porte, zc));
+  pt_list.forEach((pt) => calc_pont_thermique(pt, pc, logement));
+
+  const murs_list = mur_list.concat(ph_list);
+  const Sdep = calc_Sdep(murs_list, porte_list, bv_list);
+
+  vt_list.forEach((vt) => {
+    calc_ventilation(vt, cg, th, Sdep, Sh, mur_list, ph_list, porte_list, bv_list);
+  });
+
+  const d_mur = totalDeperditionMurs(dpe, mur_list, declaredMurs);
+  const d_pb = pb_list.reduce((acc, pb) => acc + Upb(pb) || 0, 0);
+  const d_ph = ph_list.reduce((acc, ph) => acc + Uph(ph) || 0, 0);
+  const d_bv = bv_list.reduce((acc, bv) => acc + Ubv(bv) || 0, 0);
+  const d_porte = porte_list.reduce((acc, porte) => acc + Uporte(porte) || 0, 0);
+  const d_pt = totalDeperditionPontThermique(dpe, pt_list, declaredPontsThermiques);
+  const hvent = vt_list.reduce((acc, vt) => acc + vt.donnee_intermediaire.hvent || 0, 0);
+  const hperm = vt_list.reduce((acc, vt) => acc + vt.donnee_intermediaire.hperm || 0, 0);
+
+  return {
+    hvent,
+    hperm,
+    deperdition_renouvellement_air: hvent + hperm,
+    deperdition_mur: d_mur,
+    deperdition_plancher_bas: d_pb,
+    deperdition_plancher_haut: d_ph,
+    deperdition_baie_vitree: d_bv,
+    deperdition_porte: d_porte,
+    deperdition_pont_thermique: d_pt,
+    deperdition_enveloppe: d_mur + d_pb + d_ph + d_bv + d_porte + d_pt + hvent + hperm
+  };
+}

package/4_ventilation.js

@@ -0,0 +1,197 @@
+import enums from './enums.js';
+import { tv, requestInputID, requestInput, bug_for_bug_compat } from './utils.js';
+import calc_pvent from './5_conso_ventilation.js';
+
+function tv_debits_ventilation(di, de, du) {
+  const matcher = {
+    enum_type_ventilation_id: requestInputID(de, du, 'type_ventilation')
+  };
+
+  const row = tv('debits_ventilation', matcher);
+  if (row) {
+    di.qvarep_conv = Number(row.qvarep_conv);
+    di.qvasouf_conv = Number(row.qvasouf_conv);
+    di.smea_conv = Number(row.smea_conv);
+    de.tv_debits_ventilation_id = Number(row.tv_debits_ventilation_id);
+  } else {
+    console.error('!! pas de valeur forfaitaire trouvée pour debits_ventilation !!');
+  }
+}
+
+function tv_q4pa_conv(di, de, cg, mur_list, ph_list, porte_list, bv_list) {
+  const surfaces = mur_list.concat(ph_list);
+  const surface_isolee = surfaces.reduce((acc, s) => {
+    const type_isolation = enums.type_isolation[s.donnee_entree.enum_type_isolation_id];
+    if (s.donnee_intermediaire.b === 0) return acc;
+    if (['non isolé', 'inconnu'].includes(type_isolation)) return acc;
+    else return acc + s.donnee_entree.surface_paroi_opaque;
+  }, 0);
+  const surface_non_isolee = surfaces.reduce((acc, s) => {
+    const type_isolation = enums.type_isolation[s.donnee_entree.enum_type_isolation_id];
+    if (s.donnee_intermediaire.b === 0) return acc;
+    if (['non isolé', 'inconnu'].includes(type_isolation)) {
+      return acc + s.donnee_entree.surface_paroi_opaque;
+    } else return acc;
+  }, 0);
+  let isolation_surfaces = surface_isolee > surface_non_isolee ? '1' : '0';
+
+  // presence joints menuiserie
+  let surface_bv_avec_joint = bv_list.reduce((acc, bv) => {
+    if (bv.donnee_entree.presence_joint) return acc + bv.donnee_entree.surface_totale_baie;
+    else return acc;
+  }, 0);
+  surface_bv_avec_joint += porte_list.reduce((acc, porte) => {
+    if (porte.donnee_entree.presence_joint) return acc + porte.donnee_entree.surface_porte;
+    else return acc;
+  }, 0);
+  let surface_bv_sans_joint = bv_list.reduce((acc, bv) => {
+    if (!bv.donnee_entree.presence_joint) return acc + bv.donnee_entree.surface_totale_baie;
+    else return acc;
+  }, 0);
+  surface_bv_sans_joint += porte_list.reduce((acc, porte) => {
+    if (!porte.donnee_entree.presence_joint) return acc + porte.donnee_entree.surface_porte;
+    else return acc;
+  }, 0);
+  let pjt =
+    surface_bv_avec_joint / (surface_bv_avec_joint + surface_bv_sans_joint) > 0.5 ? '1' : '0';
+
+  if (bug_for_bug_compat && de.tv_q4pa_conv_id) {
+    const rowQ4paConv = tv('q4pa_conv', {
+      tv_q4pa_conv_id: de.tv_q4pa_conv_id
+    });
+
+    if (rowQ4paConv) {
+      if (rowQ4paConv.isolation_surfaces !== isolation_surfaces) {
+        console.error(
+          `Calcul de hperm pour la ventilation ${de.description}. Le DPE considère isolation_surfaces = ${rowQ4paConv.isolation_surfaces} 
+          alors que ce devrait être isolation_surfaces = ${isolation_surfaces}. La valeur du DPE isolation_surfaces = ${rowQ4paConv.isolation_surfaces} est utilisée.`
+        );
+      }
+
+      if (rowQ4paConv.presence_joints_menuiserie !== pjt) {
+        console.error(
+          `Calcul de hperm pour la ventilation ${de.description}. Le DPE considère presence_joints_menuiserie = ${rowQ4paConv.presence_joints_menuiserie} 
+          alors que ce devrait être presence_joints_menuiserie = ${pjt}. La valeur du DPE presence_joints_menuiserie = ${rowQ4paConv.presence_joints_menuiserie} est utilisée.`
+        );
+      }
+    }
+  }
+
+  const matcher = {
+    enum_periode_construction_id: cg.enum_periode_construction_id,
+    enum_methode_application_dpe_log_id: cg.enum_methode_application_dpe_log_id,
+    isolation_surfaces,
+    presence_joints_menuiserie: pjt
+  };
+  const row = tv('q4pa_conv', matcher);
+  if (row) {
+    di.q4pa_conv = Number(row.q4pa_conv);
+    de.tv_q4pa_conv_id = Number(row.tv_q4pa_conv_id);
+  } else {
+    console.error('!! pas de valeur forfaitaire trouvée pour q4pa_conv !!');
+  }
+}
+
+const e_tab = {
+  1: 0.07,
+  0: 0.02
+};
+
+const f_tab = {
+  1: 15,
+  0: 20
+};
+
+function calc_hperm(di, surface_ventile, Hsp, Sdep, pfe) {
+  const e = e_tab[pfe];
+  const f = f_tab[pfe];
+  const Q4pa_env = di.q4pa_conv * Sdep;
+  const Q4pa = Q4pa_env + 0.45 * di.smea_conv * surface_ventile;
+  const n50 = Q4pa / ((4 / 50) ** (2 / 3) * Hsp * surface_ventile);
+  const Qvinf =
+    (Hsp * surface_ventile * n50 * e) /
+    (1 + (f / e) * ((di.qvasouf_conv - di.qvarep_conv) / (Hsp * n50)) ** 2);
+  di.hperm = 0.34 * Qvinf;
+}
+
+export default function calc_ventilation(
+  vt,
+  cg,
+  th,
+  Sdep,
+  Sh,
+  mur_list,
+  ph_list,
+  porte_list,
+  bv_list
+) {
+  const de = vt.donnee_entree;
+  const du = {};
+  const di = {};
+
+  let surface_ventile = requestInput(de, du, 'surface_ventile', 'float');
+
+  if (!surface_ventile) {
+    surface_ventile = Sh;
+  } else if (surface_ventile !== Sh) {
+    // S'il y a une répartition alors c'est que la vmc est collective. La surface à prendre en compte est la surface de l'immeuble
+    surface_ventile /= de.cle_repartition_ventilation || 1;
+  }
+
+  const Hsp = cg.hsp;
+
+  tv_debits_ventilation(di, de, du);
+  tv_q4pa_conv(di, de, cg, mur_list, ph_list, porte_list, bv_list);
+
+  di.hvent = 0.34 * di.qvarep_conv * surface_ventile;
+
+  let pfe = requestInput(de, du, 'plusieurs_facade_exposee', 'bool');
+
+  /**
+   * Si une fiche technique pour cette variable est présente, elle est prise en compte
+   * Les valeurs de plusieurs_facade_exposee n'étant pas toujours utilisées de la même manière
+   * dans tous les DPEs (parfois 0 = 'Oui', d'autres 0 = 'Non')
+   */
+  if (de.ficheTechniqueFacadesExposees) {
+    const pfeFicheTechnique = ['non', 'une'].includes(
+      de.ficheTechniqueFacadesExposees.valeur.toLowerCase()
+    )
+      ? 0
+      : 1;
+
+    if (pfeFicheTechnique !== pfe) {
+      console.error(
+        `La valeur de la variable plusieurs_facade_exposee ne correspond pas à celle présente 
+        dans la fiche technique "${de.ficheTechniqueFacadesExposees.description}". 
+        La valeur de la fiche technique est prise en compte.`
+      );
+    }
+
+    pfe = pfeFicheTechnique;
+  }
+
+  /**
+   * Si une fiche technique pour cette variable est présente, elle est prise en compte
+   * Les valeurs de ventilation_post_2012 n'étant pas toujours utilisées de la même manière
+   * dans tous les DPEs (parfois 0 = 'Oui', d'autres 0 = 'Non')
+   */
+  if (de.ficheTechniqueVentilationPost2012 && de.ventilation_post_2012 === 0) {
+    console.error(
+      `La valeur de la variable ventilation_post_2012 ne correspond pas à celle présente 
+      dans la fiche technique "${de.ficheTechniqueVentilationPost2012.description}". 
+      La valeur de la fiche technique est prise en compte.`
+    );
+
+    de.ventilation_post_2012 = 1;
+  }
+
+  calc_hperm(di, surface_ventile, Hsp, Sdep, pfe);
+  calc_pvent(di, de, du, th);
+
+  delete di.qvarep_conv;
+  delete di.qvasouf_conv;
+  delete di.smea_conv;
+
+  vt.donnee_intermediaire = di;
+  vt.donnee_utilisateur = du;
+}

package/5_conso_ventilation.js

@@ -0,0 +1,127 @@
+import { requestInput } from './utils.js';
+
+const pvent_moy_maison = {
+  'simple flux auto': {
+    0: 65,
+    1: 35
+  },
+  'simple flux hygro': {
+    0: 50,
+    1: 15
+  },
+  'double flux': {
+    0: 80,
+    1: 35
+  }
+};
+
+const pvent_immeuble = {
+  'simple flux auto': {
+    0: 0.46,
+    1: 0.25
+  },
+  'simple flux hygro': {
+    0: 0.46,
+    1: 0.25
+  },
+  'double flux': {
+    0: 1.1,
+    1: 0.6
+  }
+};
+
+/**
+ * 5 - Calcul des consommations d’auxiliaires de ventilation
+ * Retourne le coefficient en fonction du type d'habitation et du type de ventilation
+ * @param {string} th Type d'habitation (maison ou autre)
+ * @param {boolean} hybride Ventilation hybride ou pas
+ *
+ * @return {number}
+ */
+function getCoefficient(th, hybride) {
+  if (!hybride) {
+    return 1;
+  }
+  const ratio = th === 'maison' ? 14 : 28;
+  return ratio / (24 * 7);
+}
+
+export default function calc_pvent(di, de, du, th) {
+  const tv = requestInput(de, du, 'type_ventilation');
+  let post_2012 = requestInput(de, du, 'ventilation_post_2012', 'bool');
+
+  // can't calculate without these
+  if (tv === undefined || post_2012 === undefined) return;
+
+  let hybride = false;
+  let type;
+  switch (tv) {
+    case 'ventilation par ouverture des fenêtres':
+    case "ventilation par entrées d'air hautes et basses":
+    case 'ventilation naturelle par conduit':
+    case "ventilation naturelle par conduit avec entrées d'air hygro":
+    case 'puits climatique sans échangeur avant 2013':
+    case 'puits climatique sans échangeur à partir de 2013':
+    case 'puits climatique avec échangeur avant 2013':
+    case 'puits climatique avec échangeur à partir de 2013':
+      di.conso_auxiliaire_ventilation = 0;
+      return;
+    case 'ventilation hybride avant  2001':
+    case 'ventilation hybride de 2001 à 2012':
+    case 'ventilation hybride après 2012':
+    case "ventilation hybride avec entrées d'air hygro avant  2001":
+    case "ventilation hybride avec entrées d'air hygro de 2001 à 2012":
+    case "ventilation hybride avec entrées d'air hygro après 2012":
+      hybride = true;
+      post_2012 = 0;
+      /**
+       * @see Methode_de_calcul_3CL_DPE_2021-338.pdf, pages 41-42
+       * Les consommations d’auxiliaires pour une VMC hybride correspondent aux consommations d’une VMC
+       * classique autoréglable de 2001 à 2012 multipliées par le ratio du temps d’utilisation
+       */
+      type = 'simple flux auto';
+      break;
+    case 'ventilation mécanique sur conduit existant avant 2013':
+    case 'ventilation mécanique sur conduit existant à partir de 2013':
+    case 'vmc sf auto réglable avant 1982':
+    case 'vmc sf auto réglable de 1982 à 2000':
+    case 'vmc sf auto réglable de 2001 à 2012':
+    case 'vmc sf auto réglable après 2012':
+      type = 'simple flux auto';
+      break;
+    case 'vmc sf gaz avant  2001':
+    case 'vmc sf gaz de 2001 à 2012':
+    case 'vmc sf gaz après 2012':
+      console.error('vmc gaz ??');
+      return;
+    case 'vmc sf hygro b avant  2001':
+    case 'vmc sf hygro b de 2001 à 2012':
+    case 'vmc sf hygro b après 2012':
+    case 'vmc sf hygro a avant 2001':
+    case 'vmc sf hygro a de 2001 à 2012':
+    case 'vmc sf hygro a après 2012':
+    case 'vmc basse pression auto-réglable':
+    case 'vmc basse pression hygro a':
+    case 'vmc basse pression hygro b':
+      type = 'simple flux hygro';
+      break;
+    case 'vmc df individuelle avec échangeur avant 2013':
+    case 'vmc df individuelle avec échangeur à partir de 2013':
+    case 'vmc df collective avec échangeur avant 2013':
+    case 'vmc df collective avec échangeur à partir de 2013':
+    case 'vmc df sans échangeur avant 2013':
+    case 'vmc df sans échangeur après 2012':
+      type = 'double flux';
+      break;
+  }
+
+  const coef = getCoefficient(th, hybride);
+  if (th === 'maison') {
+    di.pvent_moy = pvent_moy_maison[type][post_2012] * coef;
+  } else {
+    const pvent = pvent_immeuble[type][post_2012];
+    const sv = requestInput(de, du, 'surface_ventile', 'float');
+    di.pvent_moy = pvent * di.qvarep_conv * sv * coef;
+  }
+  di.conso_auxiliaire_ventilation = 8.76 * di.pvent_moy;
+}

package/6.1_apport_gratuit.js

@@ -0,0 +1,61 @@
+import tvs from './tv.js';
+import { mois_liste } from './utils.js';
+import { calc_sse_j } from './6.2_surface_sud_equivalente.js';
+
+export function calc_ai_j(Sh, nadeq, nrefj) {
+  /**
+   * L'unité retenue est le Wh conformément à la spécification, cependant
+   * il est possible de rencontrer des valeurs avec une unité en kWh dans les DPE.
+   */
+  return ((3.18 + 0.34) * Sh + 90 * (132 / 168) * nadeq) * nrefj;
+}
+
+export function calc_as_j(ssej, ej) {
+  /**
+   * L'unité retenue est le Wh conformément à la spécification, cependant
+   * il est possible de rencontrer des valeurs avec une unité en kWh dans les DPE.
+   */
+  return 1000 * ssej * ej;
+}
+
+export function calc_ai(ilpa, ca, zc, Sh, nadeq) {
+  const Nref19 = tvs.nref19[ilpa];
+  const Nref28 = tvs.nref28;
+
+  const ret = {
+    apport_interne_ch: 0,
+    /* apport_interne_ch_depensier: 0, */
+    apport_interne_fr: 0
+    /* apport_interne_fr_depensier: 0 */
+  };
+  for (const mois of mois_liste) {
+    const nref19 = Nref19[ca][mois][zc];
+    const nref28 = Nref28[ca][mois][zc];
+    ret.apport_interne_ch += calc_ai_j(Sh, nadeq, nref19);
+    /* ret.apport_interne_ch_depensier += calc_ai_j(Sh, nadeq, nref21) */
+    ret.apport_interne_fr += calc_ai_j(Sh, nadeq, nref28);
+    /* ret.apport_interne_fr_depensier += calc_ai_j(Sh, nadeq, nref26) */
+  }
+  return ret;
+}
+
+export function calc_as(ilpa, ca, zc, bv, ets) {
+  const e = tvs.e[ilpa];
+  const e_fr_28 = tvs.e_fr_28;
+
+  const ret = {
+    apport_solaire_ch: 0,
+    apport_solaire_fr: 0
+    /* apport_solaire_fr_depensier: 0 */
+  };
+  for (const mois of mois_liste) {
+    const ssej = calc_sse_j(bv, ets, ca, zc, mois);
+    const ej = e[ca][mois][zc];
+    const ej_fr_28 = e_fr_28[ca][mois][zc];
+
+    ret.apport_solaire_ch += calc_as_j(ssej, ej);
+    ret.apport_solaire_fr += calc_as_j(ssej, ej_fr_28);
+    /* ret.apport_solaire_fr_depensier += calc_as_j(ssej, ej_fr_26) */
+  }
+  return ret;
+}