@open3cl/engine 1.0.0

package/13.2_generateur_combustion.js

@@ -0,0 +1,295 @@
+import { bug_for_bug_compat, convertExpression, tv, tvColumnLines } from './utils.js';
+import enums from './enums.js';
+import { updateGenerateurBouilleurs } from './13.2_generateur_combustion_bouilleur.js';
+import { updateGenerateurChaudieres } from './13.2_generateur_combustion_chaudiere.js';
+import { updateGenerateurPacs } from './13.2_generateur_pac.js';
+import getFicheTechnique from './ficheTechnique.js';
+
+function criterePn(Pn, matcher) {
+  let critere_list = tvColumnLines('generateur_combustion', 'critere_pn', matcher);
+  critere_list = critere_list.filter((critere) => critere);
+  let ret;
+  if (critere_list.length === 0) {
+    ret = null;
+  } else {
+    // change ≤ to <= in all critere_list
+    critere_list = critere_list.map((c) => c.replace('≤', '<='));
+    // find critere in critere_list that is true when executed
+    for (const critere of critere_list) {
+      if (eval(`let Pn=${Pn} ;${convertExpression(critere)}`)) {
+        ret = critere.replace('<=', '≤');
+        break;
+      }
+    }
+    if (!ret) console.warn('!! pas de critere trouvé pour pn !!');
+  }
+  return ret;
+}
+
+const E_tab = {
+  0: 2.5,
+  1: 1.75
+};
+
+const F_tab = {
+  0: -0.8,
+  1: -0.55
+};
+
+function excel_to_js_exec(box, pn, E, F) {
+  const formula = box
+    .replace(/ /g, '')
+    .replace(/,/g, '.')
+    .replace(/\*logPn/g, '*Math.log10(Pn)')
+    .replace(/\+logPn/g, '+Math.log10(Pn)')
+    .replace(/logPn/g, '*Math.log10(Pn)')
+    .replace(/%/g, '/100')
+    .replace(/\^/g, '**');
+  const js = `let Pn=${pn / 1000}, E=${E}, F=${F}; (${formula})`;
+  /* console.warn(js) */
+  const result = eval(js);
+  /* console.warn(result) */
+  return result;
+}
+
+/**
+ * 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."
+ *
+ * 2 - caractéristiques saisies à partir de la plaque signalétique ou d'une documentation technique du système à combustion : pn, autres données forfaitaires
+ * 3 - caractéristiques saisies à partir de la plaque signalétique ou d'une documentation technique du système à combustion : pn, rpn,rpint, autres données forfaitaires
+ * 4 - caractéristiques saisies à partir de la plaque signalétique ou d'une documentation technique du système à combustion : pn, rpn,rpint,qp0, autres données forfaitaires
+ * 5 - caractéristiques saisies à partir de la plaque signalétique ou d'une documentation technique du système à combustion : pn, rpn,rpint,qp0,temp_fonc_30,temp_fonc_100
+ *
+ * @param dpe {FullDpe}
+ * @param di {Donnee_intermediaire} données du générateur
+ * @param de {Donnee_entree} données du générateur
+ * @param type {'ecs'|'ch'}
+ * @param GV {number} déperdition de l'enveloppe
+ * @param tbase {number} température de fonctionnement du générateur
+ * @param methodeSaisie {number} méthode de saisie des caractéristiques du générateur
+ */
+export function tv_generateur_combustion(dpe, di, de, type, GV, tbase, methodeSaisie) {
+  const typeGenerateurKey = `enum_type_generateur_${type}_id`;
+  let enumTypeGenerateurId = de[typeGenerateurKey];
+  let row;
+
+  /**
+   * Certains DPE configurent mal les données du générateur ECS lorsque c'est un générateur mixte Chauffage + ECS
+   * Confrontation du type de générateur ECS et CH et prise en compte des données du générateur de chauffage
+   *
+   * enum_usage_generateur_id = 3 - 'chauffage + ecs'
+   */
+  if (bug_for_bug_compat && type === 'ecs' && de.enum_usage_generateur_id === '3') {
+    enumTypeGenerateurId = checkEcsVsChauffageForMixteGeneration(dpe, de, typeGenerateurKey);
+  }
+
+  /**
+   * Si le type de générateur est
+   * 84 - ECS - système collectif par défaut en abscence d'information : chaudière fioul pénalisante
+   * 119 - CH - système collectif par défaut en abscence d'information : chaudière fioul pénalisante
+   * On garde l'information à partir de tv_generateur_combustion_id.
+   */
+  if (
+    bug_for_bug_compat &&
+    ((type === 'ecs' && enumTypeGenerateurId === '84') ||
+      (type === 'ch' && enumTypeGenerateurId === '119')) &&
+    de.tv_generateur_combustion_id
+  ) {
+    row = tv('generateur_combustion', {
+      tv_generateur_combustion_id: de.tv_generateur_combustion_id
+    });
+    console.warn(`
+      Le générateur ${de.description} est caractérisé 'système collectif par défaut'. 
+      Utilisation de tv_generateur_combustion_id pour récupération des informations techniques du générateur.
+    `);
+  } else {
+    // Calcul de la puissance nominale si non définie
+    if (!di.pn) {
+      di.pn = (1.2 * GV * (19 - tbase)) / 0.95 ** 3;
+    }
+
+    let matcher = {};
+    matcher[typeGenerateurKey] = enumTypeGenerateurId;
+    matcher.critere_pn = criterePn(di.pn / (de.ratio_virtualisation * 1000), matcher);
+
+    row = tv('generateur_combustion', matcher);
+
+    /**
+     * Si l'identifiant du générateur à combustion utilisé n'est pas le bon, avertissement
+     */
+    if (
+      bug_for_bug_compat &&
+      type === 'ecs' &&
+      row.tv_generateur_combustion_id !== de.tv_generateur_combustion_id
+    ) {
+      const rowDpe = tv('generateur_combustion', {
+        tv_generateur_combustion_id: de.tv_generateur_combustion_id
+      });
+
+      // Si tv_generateur_combustion_id utilisé n'est pas
+      if (
+        rowDpe &&
+        (!rowDpe.enum_type_generateur_ecs_id ||
+          !rowDpe.enum_type_generateur_ecs_id.split('|').includes(de.enum_type_generateur_ecs_id))
+      ) {
+        console.error(`
+          Le DPE utilise les caractéristiques liées à tv_generateur_combustion_id = '${de.tv_generateur_combustion_id}' qui ne correspond pas au 
+          générateur ECS enum_type_generateur_ecs_id = '${de.enum_type_generateur_ecs_id}'. Les données utilisées par le DPE et les résultats
+          qui en découlent sont probablement erronés.
+        `);
+      }
+    }
+  }
+
+  if (!row) {
+    console.error(
+      'Pas de valeur forfaitaire trouvée pour le générateur à combustion ${de.description}'
+    );
+    return;
+  }
+
+  de.tv_generateur_combustion_id = Number(row.tv_generateur_combustion_id);
+
+  const E = E_tab[de.presence_ventouse];
+  const F = F_tab[de.presence_ventouse];
+
+  /**
+   * Si la consommation ECS est obtenue par virtualisation du générateur collectif pour les besoins individuels
+   * la puissance nominale est obtenu à partir de la puissance nominale du générateur collectif multiplié par le
+   * ratio de virtualisation
+   * 17.2.1 - Génération d’un DPE à l’appartement / Traitement des usages collectifs
+   */
+  if (![3, 4, 5].includes(methodeSaisie)) {
+    if (row.rpn) {
+      di.rpn = excel_to_js_exec(row.rpn, di.pn / (de.ratio_virtualisation || 1), E, F) / 100;
+    }
+    if (type === 'ch' && row.rpint) {
+      di.rpint = excel_to_js_exec(row.rpint, di.pn / (de.ratio_virtualisation || 1), E, F) / 100;
+    }
+  }
+
+  if (![4, 5].includes(methodeSaisie)) {
+    if (row.qp0_perc) {
+      const qp0_calc = excel_to_js_exec(row.qp0_perc, di.pn / (de.ratio_virtualisation || 1), E, F);
+      // Certaines chaudières ont un qp0 en % de pn, d'autres ont des valeurs constantes
+      di.qp0 = row.qp0_perc.includes('Pn')
+        ? qp0_calc * 1000 * (de.ratio_virtualisation || 1)
+        : row.qp0_perc.includes('%')
+          ? qp0_calc * di.pn
+          : qp0_calc * 1000;
+    } else {
+      di.qp0 = 0;
+    }
+  }
+
+  if (methodeSaisie === 1 || !di.pveilleuse) {
+    di.pveil = Number(row.pveil) || 0;
+  } else {
+    di.pveil = di.pveilleuse || 0;
+  }
+}
+
+/**
+ * Mise à jour du type de générateur si besoin
+ * @param dpe {FullDpe}
+ * @param de {Donnee_entree}
+ * @param type {'ch' | 'ecs'}
+ */
+export function updateGenerateurCombustion(dpe, de, type) {
+  updateGenerateurBouilleurs(dpe, de, type);
+  updateGenerateurChaudieres(dpe, de, type);
+  updateGenerateurPacs(dpe, de, type);
+  addInfosFromFichesTechniques(dpe, de);
+}
+
+/**
+ * Récupération d'informations complémentaires issues des fiches techniques pour les générateurs
+ *
+ * @param dpe {FullDpe}
+ * @param de {Donnee_entree}
+ */
+function addInfosFromFichesTechniques(dpe, de) {
+  // Récupération de la présence ou non d'un système de ventilation
+  const ficheTechnique = getFicheTechnique(
+    dpe,
+    '8',
+    'Présence ventilateur / dispositif circulation air dans circuit combustion',
+    [de.description]
+  )?.valeur;
+
+  if (ficheTechnique && ficheTechnique === 'oui') {
+    de.presenceVentilateur = 1;
+  }
+}
+
+/**
+ * Vérifier que les informations du générateur ECS sont bien les mêmes que celles du générateur de chauffage
+ * Dans le cas d'une génération mixte, le type du générateur doit être le même
+ * @param dpe {FullDpe}
+ * @param de {Donnee_entree}
+ * @param typeGenerateurKey {string}
+ * @returns {string}
+ */
+function checkEcsVsChauffageForMixteGeneration(dpe, de, typeGenerateurKey) {
+  const ecsGenerateurId = de[typeGenerateurKey];
+
+  /**
+   * Si le générateur ECS est un générateur par défaut, pas d'information assez précise pour redresser la donnée
+   *
+   * 78 - autre système à combustion gaz
+   * 79 - autre système à combustion fioul
+   * 80 - autre système à combustion bois
+   * 81 - autre système à combustion autres energies fossiles (charbon,pétrole etc…)
+   * 82 - autre système thermodynamique électrique
+   * 83 - autre système thermodynamique gaz
+   */
+  if (['78', '79', '80', '81', '82', '83'].includes(de[`previous_${typeGenerateurKey}`])) {
+    return ecsGenerateurId;
+  }
+
+  /**
+   * @type {InstallationChauffageItem[]}
+   */
+  const installationsCh = dpe.logement.installation_chauffage_collection.installation_chauffage;
+
+  // Récupération des générateurs de chauffage ayant pour usage ECS + Chauffage également
+  const generateursChMixtes = installationsCh.reduce((acc, ch) => {
+    return acc.concat(
+      ch.generateur_chauffage_collection.generateur_chauffage.filter(
+        (value) => value.donnee_entree.enum_usage_generateur_id === '3'
+      )
+    );
+  }, []);
+
+  if (generateursChMixtes.length) {
+    const firstChGenerateurMixte = generateursChMixtes[0];
+    const firstChGenerateurMixteId =
+      firstChGenerateurMixte.donnee_entree.enum_type_generateur_ch_id;
+    const typeGenerateurEcs = enums.type_generateur_ecs;
+    const typeGenerateurCh = enums.type_generateur_ch;
+
+    const ecsGenerateurType = typeGenerateurEcs[ecsGenerateurId];
+    const chGenerateurType = typeGenerateurCh[firstChGenerateurMixteId];
+
+    // Si les 2 générateurs n'ont pas le même type
+    if (ecsGenerateurType !== chGenerateurType) {
+      // Recherche de l'identifiant du générateur ECS identique au générateur de chauffage
+      const newEcsGenerateurId = Object.keys(typeGenerateurEcs).find(
+        (key) => typeGenerateurEcs[key] === typeGenerateurCh[firstChGenerateurMixteId]
+      );
+
+      if (newEcsGenerateurId) {
+        console.error(`
+          Le générateur mixte ECS + CH identifié pour la génération ECS '${ecsGenerateurType}' n'est pas le même que celui identifié pour le générateur de chauffage '${chGenerateurType}'.
+          On conserve le type de générateur de chauffage '${chGenerateurType}' pour la suite des calculs ECS.
+        `);
+
+        return newEcsGenerateurId;
+      }
+    }
+  }
+
+  return ecsGenerateurId;
+}

package/13.2_generateur_combustion_bouilleur.js

@@ -0,0 +1,173 @@
+import getFicheTechnique from './ficheTechnique.js';
+
+/**
+ * Pour les générateurs "poêles à bois bouilleur", les calculs sont faits comme pour les chaudières bois
+ * @param dpe {FullDpe}
+ * @param de {Donnee_entree}
+ * @param type {'ch' | 'ecs'}
+ */
+export function updateGenerateurBouilleurs(dpe, de, type) {
+  let ids;
+
+  /**
+   * 13.1 Inserts et poêles
+   * Les poêles à bois bouilleur sont traités comme des chaudières bois
+   * L'année d'installation du générateur est récupéré, si définit, depuis les fiches techniques
+   * Le générateur "chaudières bois" pour la même période est alors utilisé
+   *
+   * enum_type_generateur_ecs_id
+   * 13 - poêle à bois bouilleur bûche installé avant 2012
+   * 14 - poêle à bois bouilleur bûche installé à partir de 2012
+   * 115 - poêle à bois bouilleur granulés installé avant 2012
+   * 116 - poêle à bois bouilleur granulés installé à partir de 2012
+   */
+  if (type === 'ecs') {
+    // Ids des chaudières bois équivalentes pour les différentes périodes d'installation
+    ids = {
+      13: {
+        1948: '15',
+        1978: '16',
+        1995: '17',
+        2004: '18',
+        2013: '19',
+        2018: '20',
+        2019: '21'
+      },
+      14: {
+        1948: '15',
+        1978: '16',
+        1995: '17',
+        2004: '18',
+        2013: '19',
+        2018: '20',
+        2019: '21'
+      },
+      115: {
+        1948: '29',
+        1978: '30',
+        1995: '31',
+        2004: '32',
+        2013: '33',
+        2018: '33',
+        2019: '34'
+      },
+      116: {
+        1948: '29',
+        1978: '30',
+        1995: '31',
+        2004: '32',
+        2013: '33',
+        2018: '33',
+        2019: '34'
+      }
+    };
+  } else {
+    /**
+     * enum_type_generateur_ch_id
+     * 48 - poêle à bois bouilleur bûche installé avant 2012
+     * 49 - poêle à bois bouilleur bûche installé à partir de 2012
+     * 140 - poêle à bois bouilleur granulés installé avant 2012
+     * 141 - poêle à bois bouilleur granulés installé à partir de 2012
+     */
+    // Ids des chaudières bois équivalentes pour les différentes périodes d'installation
+    ids = {
+      48: {
+        1948: '55',
+        1978: '56',
+        1995: '57',
+        2004: '58',
+        2013: '59',
+        2018: '60',
+        2019: '61'
+      },
+      49: {
+        1948: '55',
+        1978: '56',
+        1995: '57',
+        2004: '58',
+        2013: '59',
+        2018: '60',
+        2019: '61'
+      },
+      140: {
+        1948: '69',
+        1978: '70',
+        1995: '71',
+        2004: '72',
+        2013: '73',
+        2018: '73',
+        2019: '74'
+      },
+      141: {
+        1948: '69',
+        1978: '70',
+        1995: '71',
+        2004: '72',
+        2013: '73',
+        2018: '73',
+        2019: '74'
+      }
+    };
+  }
+
+  updateGenerateurBouilleur(dpe, ids, de, type);
+}
+
+/**
+ * Récupération du générateur équivalent à utiliser à la place du générateur décrit
+ * La période du générateur équivalent est choisie par rapport à la date d'installation du générateur décrit
+ * Ex:
+ *  - Pour un poêle à bois bouilleur granulés installé en 2000, on prendra la chaudière bois granulés 1995-2003
+ *  - Pour un poêle à bois bouilleur bûche installé avant 1948, on prendra la chaudière bois bûche avant 1978
+ * @param dpe {FullDpe}
+ * @param ids
+ * @param de {Donnee_entree}
+ * @param type {'ch' | 'ecs'}
+ */
+function updateGenerateurBouilleur(dpe, ids, de, type) {
+  const enumType = `enum_type_generateur_${type}_id`;
+  const generateurId = de[enumType];
+
+  const steps = Object.keys(ids);
+
+  if (steps.includes(generateurId)) {
+    const values = ids[generateurId];
+
+    // Récupération de l'année d'installation du système ECS ou Chauffage dans les fiches techniques
+    const ficheTechnique = getFicheTechnique(dpe, '7', 'année', ['bouilleur'])?.valeur;
+
+    /**
+     * Par défaut:
+     * - Les poêles à bois bouilleur installées à partir de 2012 sont traités comme des chaudières bois installées entre 2004 et
+     * 2012.
+     * - Les poêles à bois bouilleur installées avant 2012 sont traités comme des chaudières bois installées entre 1978 et 1994.
+     */
+    let newGenerateurId = generateurId === 13 ? values[1978] : values[2004];
+
+    if (ficheTechnique) {
+      if (ficheTechnique.toString().toLowerCase() === 'avant 1948') {
+        newGenerateurId = values[1948];
+      } else {
+        const installationDate = parseInt(ficheTechnique, 10);
+
+        if (installationDate >= 2019) {
+          newGenerateurId = values[2019];
+        } else if (installationDate >= 2018) {
+          newGenerateurId = values[2018];
+        } else if (installationDate >= 2013) {
+          newGenerateurId = values[2013];
+        } else if (installationDate >= 2004) {
+          newGenerateurId = values[2004];
+        } else if (installationDate >= 1995) {
+          newGenerateurId = values[1995];
+        } else if (installationDate >= 1978) {
+          newGenerateurId = values[1978];
+        } else if (installationDate >= 1948) {
+          newGenerateurId = values[1948];
+        }
+      }
+    }
+
+    de[enumType] = newGenerateurId;
+  }
+}

package/13.2_generateur_combustion_ch.js

@@ -0,0 +1,195 @@
+import enums from './enums.js';
+import { bug_for_bug_compat, requestInput, requestInputID, tv } from './utils.js';
+
+const coef_pond = {
+  0.05: 0.1,
+  0.15: 0.25,
+  0.25: 0.2,
+  0.35: 0.15,
+  0.45: 0.1,
+  0.55: 0.1,
+  0.65: 0.05,
+  0.75: 0.025,
+  0.85: 0.025,
+  0.95: 0
+};
+
+const K = {
+  électricité: 1,
+  'gaz naturel': 1.11,
+  gpl: 1.09,
+  'fioul domestique': 1.07,
+  'bois – bûches': 1.08,
+  'bois – granulés (pellets) ou briquettes': 1.08,
+  'bois – plaquettes forestières': 1.08,
+  'bois – plaquettes d’industrie': 1.08,
+  'réseau de chauffage urbain': 1,
+  charbon: 1.04,
+  propane: 1.11,
+  butane: 1.11,
+  "électricité d'origine renouvelable utilisée dans le bâtiment": undefined,
+  'autre combustible fossile': undefined,
+  'réseau de froid urbain': undefined
+};
+
+export function tv_temp_fonc_30_100(di, de, du, em_ch, ac) {
+  for (const em of em_ch) {
+    const em_ch_de = em.donnee_entree;
+    const em_ch_du = em.donnee_utilisateur;
+    const matcher = {
+      type_generateur_ch_id: de.enum_type_generateur_ch_id,
+      enum_temp_distribution_ch_id: requestInputID(em_ch_de, em_ch_du, 'temp_distribution_ch'),
+      periode_emetteurs: requestInput(em_ch_de, em_ch_du, 'periode_installation_emetteur')
+    };
+
+    if (!matcher.periode_emetteurs) {
+      if (ac < 1981) matcher.periode_emetteurs = 'avant 1981';
+      else if (ac < 2000) matcher.periode_emetteurs = 'entre 1981 et 2000';
+      else matcher.periode_emetteurs = 'après 2000';
+    }
+
+    const row_30 = tv('temp_fonc_30', matcher);
+    const row_100 = tv('temp_fonc_100', matcher);
+
+    if (row_30) {
+      if (!di.temp_fonc_30 || Number(row_30.temp_fonc_30) > di.temp_fonc_30) {
+        de.tv_temp_fonc_30_id = row_30.tv_temp_fonc_30_id;
+        di.temp_fonc_30 = Number(row_30.temp_fonc_30);
+      }
+    } else {
+      console.error('!! pas de valeur forfaitaire trouvée pour temp_fonc_30 !!');
+    }
+
+    if (row_100) {
+      if (!di.temp_fonc_100 || Number(row_100.temp_fonc_100) > di.temp_fonc_100) {
+        de.tv_temp_fonc_100_id = row_100.tv_temp_fonc_100_id;
+        di.temp_fonc_100 = Number(row_100.temp_fonc_100);
+      }
+    } else {
+      console.error('!! pas de valeur forfaitaire trouvée pour temp_fonc_100 !!');
+    }
+  }
+}
+
+function Tch_xfinal(x, Cdimref) {
+  return Math.min(1, x / Cdimref);
+}
+
+function QPx(x, de, di) {
+  const type_gen_ch = enums.type_generateur_ch[de.enum_type_generateur_ch_id];
+  const type_energie = enums.type_energie[de.enum_type_energie_id];
+  const k = K[type_energie];
+  const pn = di.pn / 1000;
+  const rpn = (100 * di.rpn) / k;
+  const rpint = (100 * di.rpint) / k;
+  let qp0 = (di.qp0 * k) / 1000;
+  const tf30 = di.temp_fonc_30;
+  const tf100 = di.temp_fonc_100;
+
+  let QPx;
+  if (type_gen_ch.includes('radiateur à gaz')) {
+    QPx = ((1.04 * (100 - rpn)) / rpn) * pn * x;
+  } else if (type_gen_ch.includes('chaudière bois') || type_gen_ch.includes('chaudière charbon')) {
+    const QP50 = (0.5 * pn * (100 - rpint)) / rpint;
+    const QP100 = (pn * (100 - rpn)) / rpn;
+    if (x < 0.5) QPx = 0.15 * qp0 + ((QP50 - 0.15 * qp0) * x) / 0.5;
+    else QPx = 2 * QP50 - QP100 + ((QP100 - QP50) * x) / 0.5;
+  } else if (type_gen_ch.includes('chaudière')) {
+    let tf;
+    if (de.presence_regulation_combustion) tf = tf30;
+    else tf = tf100;
+    let QP30, a, b;
+    if (type_gen_ch.includes('basse température')) {
+      a = 0.1;
+      b = 40;
+    } else if (type_gen_ch.includes('condensation')) {
+      a = 0.2;
+      b = 33;
+    } else {
+      a = 0.1;
+      b = 50;
+    }
+    QP30 = (0.3 * pn * (100 - (rpint + a * (b - tf)))) / (rpint + a * (b - tf));
+    const QP100 = (pn * (100 - (rpn + 0.1 * (70 - tf100)))) / (rpn + 0.1 * (70 - tf100));
+    const QP15 = QP30 / 2;
+    if (type_gen_ch.includes('basse température') || type_gen_ch.includes('condensation')) {
+      if (x < 0.15) QPx = 0.15 * qp0 + ((QP15 - 0.15 * qp0) * x) / 0.15;
+      else if (x < 0.3) QPx = QP15 + ((QP30 - QP15) * (x - 0.15)) / 0.15;
+      else QPx = QP30 + ((QP100 - QP30) * (x - 0.3)) / 0.7;
+    } else {
+      if (x < 0.3) QPx = 0.15 * qp0 + ((QP30 - 0.15 * qp0) * x) / 0.3;
+      else QPx = QP30 + ((QP100 - QP30) * (x - 0.3)) / 0.7;
+    }
+  } else if (type_gen_ch.includes('générateur à air chaud')) {
+    // Change QP0 to be in decimal
+    di.qp0 = di.qp0 / 100;
+    qp0 = (di.qp0 * k) / 1000;
+
+    const QP50 = (0.5 * pn * (100 - rpint)) / rpint;
+    const QP100 = (pn * (100 - rpn)) / rpn;
+    if (x < 0.5) QPx = 0.15 * qp0 + ((QP50 - 0.15 * qp0) * x) / 0.5;
+    else QPx = 2 * QP50 - QP100 + ((QP100 - QP50) * x) / 0.5;
+  } else {
+    console.warn('!! type_generateur_ch n’est pas connu !!');
+  }
+  /* console.warn('QPx', QPx) */
+  return QPx;
+}
+
+function Px(x, di, Cdimref) {
+  const Px = (di.pn / 1000) * Tch_xfinal(x, Cdimref);
+  return Px;
+}
+
+function Pfou(x, di, Cdimref) {
+  // find coef_pond[x] in coef_pond where x is closest to x_final
+  return Px(x, di, Cdimref) * coef_pond[x];
+}
+
+function Pcons(x, de, di, Cdimref) {
+  const x_final = Tch_xfinal(x, Cdimref);
+  return Pfou(x, di, Cdimref) * (1 + QPx(x_final, de, di) / Px(x, di, Cdimref));
+}
+
+export function calc_generateur_combustion_ch(dpe, di, de, du) {
+  if (bug_for_bug_compat) {
+    if (di.qp0 < 1) {
+      di.qp0 *= 1000;
+      console.warn(
+        `Correction di.qp0 pour le générateur de chauffage ${de.description}. Passage de la valeur en W`
+      );
+    }
+  }
+
+  // La puissance de la veilleuse est à prendre en compte seulement si elle est présente dans l'installation
+  if (!di.pveilleuse) {
+    di.pveil = 0;
+  }
+
+  const Cdimref = du.cdimref || 0;
+  const Cdimref_dep = du.cdimrefDep || 0;
+  const Pmfou = Object.keys(coef_pond).reduce((acc, x) => acc + Pfou(x, di, Cdimref), 0);
+  const Pmcons = Object.keys(coef_pond).reduce((acc, x) => acc + Pcons(x, de, di, Cdimref), 0);
+  const Pmfou_dep = Object.keys(coef_pond).reduce((acc, x) => acc + Pfou(x, di, Cdimref_dep), 0);
+  const Pmcons_dep = Object.keys(coef_pond).reduce(
+    (acc, x) => acc + Pcons(x, de, di, Cdimref_dep),
+    0
+  );
+  const type_energie = requestInput(de, du, 'type_energie');
+  const k = K[type_energie];
+
+  // Pveil and QP0 are in kW
+  const Pveil = di.pveil / 1000;
+  const QP0 = di.qp0 / 1000;
+
+  const rg_pcs = Pmfou / (Pmcons + 0.45 * QP0 + Pveil);
+  const rg_pcs_dep = Pmfou_dep / (Pmcons_dep + 0.45 * QP0 + Pveil);
+
+  const rg_pci = rg_pcs * k;
+  const rg_pci_dep = rg_pcs_dep * k;
+  di.rendement_generation = rg_pci;
+
+  // for Ich
+  di.rg = rg_pci;
+  di.rg_dep = rg_pci_dep;
+}