@open3cl/engine 1.0.0

package/15_conso_aux.js

@@ -0,0 +1,257 @@
+import enums from './enums.js';
+import tvs from './tv.js';
+import { mois_liste, Tbase } from './utils.js';
+
+const G_CHAUDIERE = 20;
+const G_RADIATEURS_GAZ = 40;
+const G_CHAUDIERE_BOIS = 73.3;
+const H_CHAUDIERE = 1.6;
+const H_GENERATEUR_AIR_CHAUD = 4;
+const H_CHAUDIERE_BOIS = 10.5;
+
+/**
+ * 15.1 Consommation des auxiliaires de génération
+ * @param di {Donnee_intermediaire}
+ * @param de {Donnee_entree}
+ * @param type {'ecs'|'ch'}
+ * @param besoin {number} Besoin en chauffage ou ecs pour ce générateur
+ * @param besoin_dep {number} Besoin en chauffage ou ecs pour ce générateur (mode dépensier)
+ * @param Sh {number} Surface habitable du logement
+ */
+export function conso_aux_gen(di, de, type, besoin, besoin_dep, Sh) {
+  const typeGenerateur = parseInt(de[`enum_type_generateur_${type}_id`]);
+
+  const presenceVentilateur = de.presenceVentilateur || 0;
+
+  const g = getG(type, typeGenerateur, presenceVentilateur === 1);
+  const h = getH(type, typeGenerateur, presenceVentilateur === 1);
+
+  let pe = di.pn / (de.ratio_virtualisation || 1);
+
+  // Pour les chaudières gaz ou fioul : si Pn > 400 kW alors Pn = 400 kW
+  if (g === G_CHAUDIERE && pe > 400000) {
+    pe = 400000;
+  }
+  // Pour les générateurs d’air chaud : si Pn > 300 kW alors Pn = 300 kW
+  if (h === H_GENERATEUR_AIR_CHAUD && pe > 300000) {
+    pe = 300000;
+  }
+  // Pour les chaudières bois : si Pn > 70 kW alors Pn = 70 kW
+  if (g === G_CHAUDIERE_BOIS && pe > 70000) {
+    pe = 70000;
+  }
+
+  const Paux_g_ch = g + (h * (pe / 1000)) / (de.ratio_virtualisation || 1);
+
+  let ratio = 1;
+
+  // Pour le chauffage, le besoin de chauffage est proratisé à la surface chauffée
+  if (type === 'ch') {
+    const Sc = de.surface_chauffee || Sh;
+    ratio = Sc / Sh;
+  }
+
+  di[`conso_auxiliaire_generation_${type}`] =
+    ((de.ratio_virtualisation || 1) * (Paux_g_ch * besoin * ratio)) / pe || 0;
+  di[`conso_auxiliaire_generation_${type}_depensier`] =
+    (Paux_g_ch * besoin_dep * ratio) / di.pn || 0;
+}
+
+/**
+ * Récupération du facteur G en fonction du type de générateur
+ * @param type {'ecs'|'ch'}
+ * @param id {number}
+ * @param presenceVentilateur {boolean} - Seules les chaudières bois assistées par ventilateur sont concernées
+ */
+function getG(type, id, presenceVentilateur) {
+  const values = {
+    ch: [
+      { min: 85, max: 97, value: G_CHAUDIERE }, // Chaudières à gaz
+      { min: 148, max: 149, value: G_CHAUDIERE }, // PAC hybride : partie chaudière gaz
+      { min: 127, max: 139, value: G_CHAUDIERE }, // Chaudière gpl/propane/butane
+      { min: 160, max: 161, value: G_CHAUDIERE }, // PAC hybride : partie chaudière gpl/propane/butane
+      { min: 75, max: 84, value: G_CHAUDIERE }, // Chaudières fioul
+      { min: 150, max: 151, value: G_CHAUDIERE }, // PAC hybride : partie chaudière fioul
+      { min: 53, max: 54, value: G_RADIATEURS_GAZ }, // Radiateur à gaz
+      { min: 55, max: 74, value: G_CHAUDIERE_BOIS, withVentilateur: true }, // Chaudières bois assistées par ventilateur
+      { min: 152, max: 156, value: G_CHAUDIERE_BOIS, withVentilateur: true } // PAC hybride : partie chaudière bois
+    ],
+    ecs: [
+      { min: 45, max: 57, value: G_CHAUDIERE }, // Chaudières à gaz
+      { min: 120, max: 121, value: G_CHAUDIERE }, // PAC hybride : partie chaudière gaz
+      { min: 92, max: 104, value: G_CHAUDIERE }, // Chaudière gpl/propane/butane
+      { min: 132, max: 133, value: G_CHAUDIERE }, // PAC hybride : partie chaudière gpl/propane/butane
+      { min: 35, max: 44, value: G_CHAUDIERE }, // Chaudières fioul
+      { min: 122, max: 123, value: G_CHAUDIERE }, // PAC hybride : partie chaudière fioul
+      { min: 13, max: 34, value: G_CHAUDIERE_BOIS, withVentilateur: true }, // Chaudières bois assistées par ventilateur
+      { min: 122, max: 123, value: G_CHAUDIERE_BOIS, withVentilateur: true } // PAC hybride : partie chaudière bois
+    ]
+  };
+
+  return getFacteur(values, type, id, presenceVentilateur);
+}
+
+/**
+ * Récupération du facteur H en fonction du type de générateur
+ * @param type {'ecs'|'ch'}
+ * @param id {number}
+ * @param presenceVentilateur {boolean} - Seules les chaudières bois assistées par ventilateur sont concernées
+ */
+function getH(type, id, presenceVentilateur) {
+  const values = {
+    ch: [
+      { min: 85, max: 97, value: H_CHAUDIERE }, // Chaudières à gaz
+      { min: 148, max: 149, value: H_CHAUDIERE }, // PAC hybride : partie chaudière gaz
+      { min: 127, max: 139, value: H_CHAUDIERE }, // Chaudière gpl/propane/butane
+      { min: 160, max: 161, value: H_CHAUDIERE }, // PAC hybride : partie chaudière gpl/propane/butane
+      { min: 75, max: 84, value: H_CHAUDIERE }, // Chaudières fioul
+      { min: 150, max: 151, value: H_CHAUDIERE }, // PAC hybride : partie chaudière fioul
+      { min: 50, max: 52, value: H_GENERATEUR_AIR_CHAUD }, // Générateurs à air chaud
+      { min: 55, max: 74, value: H_CHAUDIERE_BOIS, withVentilateur: true }, // Chaudières bois assistées par ventilateur
+      { min: 152, max: 156, value: H_CHAUDIERE_BOIS, withVentilateur: true } // PAC hybride : partie chaudière bois
+    ],
+    ecs: [
+      { min: 45, max: 57, value: H_CHAUDIERE }, // Chaudières à gaz
+      { min: 120, max: 121, value: H_CHAUDIERE }, // PAC hybride : partie chaudière gaz
+      { min: 92, max: 104, value: H_CHAUDIERE }, // Chaudière gpl/propane/butane
+      { min: 132, max: 133, value: H_CHAUDIERE }, // PAC hybride : partie chaudière gpl/propane/butane
+      { min: 35, max: 44, value: H_CHAUDIERE }, // Chaudières fioul
+      { min: 122, max: 123, value: H_CHAUDIERE }, // PAC hybride : partie chaudière fioul
+      { min: 13, max: 34, value: H_CHAUDIERE_BOIS, withVentilateur: true }, // Chaudières bois assistées par ventilateur
+      { min: 122, max: 123, value: H_CHAUDIERE_BOIS, withVentilateur: true } // PAC hybride : partie chaudière bois
+    ]
+  };
+
+  return getFacteur(values, type, id, presenceVentilateur);
+}
+
+function getFacteur(values, type, id, presenceVentilateur) {
+  const ranges = values[type] || [];
+  for (const range of ranges) {
+    if (id >= range.min && id <= range.max) {
+      if (!range.withVentilateur || presenceVentilateur) {
+        return range.value;
+      }
+    }
+  }
+
+  return 0;
+}
+
+/**
+ * Calcul de la consommation des auxiliaires de distribution de chauffage
+ * @param em_ch { EmetteurChauffageItem[]}
+ * @param de {Donnee_entree} donnée du générateur de chauffage
+ * @param di {Donnee_intermediaire} donnée intermédiaire du générateur de chauffage
+ * @param du {object} donnée utilisateur du générateur de chauffage
+ * @param surfaceHabitable {number}
+ * @param zcId {number} id de la zone climatique du bien
+ * @param caId {number} id de la classe d'altitude du bien
+ * @param ilpa {number} 1 si bien à inertie lourde, 0 sinon
+ * @param GV {number} déperdition de l'enveloppe
+ */
+export function conso_aux_distribution_ch(
+  em_ch,
+  de,
+  di,
+  du,
+  surfaceHabitable,
+  zcId,
+  caId,
+  ilpa,
+  GV
+) {
+  const ca = enums.classe_altitude[caId];
+  const zc = enums.zone_climatique[zcId];
+
+  const Nref19 = tvs.nref19[ilpa];
+
+  let nref19 = 0;
+
+  for (const mois of mois_liste) {
+    nref19 += Nref19[ca][mois][zc];
+  }
+
+  const Pcircem19 = getPuissanceCirculateur(
+    em_ch,
+    de,
+    di,
+    du,
+    surfaceHabitable,
+    GV,
+    Tbase[ca][zc.slice(0, 2)]
+  );
+
+  di[`conso_auxiliaire_distribution_ch`] = (Pcircem19 * nref19) / 1000;
+}
+
+/**
+ * 15.2.1 Puissance des circulateurs de chauffage
+ * @param em_ch { EmetteurChauffageItem[]}
+ * @param de {Donnee_entree} donnée du générateur de chauffage
+ * @param di {Donnee_intermediaire} donnée intermédiaire du générateur de chauffage
+ * @param du {object} donnée utilisateur du générateur de chauffage
+ * @param surfaceHabitable {number}
+ * @param GV {number} déperdition de l'enveloppe
+ * @param Tbase {number} température
+ */
+function getPuissanceCirculateur(em_ch, de, di, du, surfaceHabitable, GV, Tbase) {
+  const typeEmetteur = parseInt(em_ch[0].donnee_entree.enum_type_emission_distribution_id);
+  const temperatureEmetteur = parseInt(em_ch[0].donnee_entree.enum_temp_distribution_ch_id);
+
+  // Perte de charge de l’émetteur
+  let deltaPem = 35;
+  let Fcot = 0.802;
+
+  /**
+   * 15.2.1 Puissance des circulateurs de chauffage
+   * Plancher/plafond chauffant => deltaPemnom = 15
+   * Radiateurs monotube => deltaPemnom = 30
+   * Radiateurs autres => deltaPemnom = 10
+   */
+  if ([6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 43, 44].includes(typeEmetteur)) {
+    deltaPem = 15;
+    Fcot = 0.156;
+  } else if ([24, 25, 26, 27, 28, 29, 30, 31].includes(typeEmetteur)) {
+    deltaPem = 30;
+  } else if ([10, 19, 32, 33, 34, 35, 36, 37, 38, 39, 45].includes(typeEmetteur)) {
+    deltaPem = 10;
+  }
+
+  /**
+   * En présence de plusieurs types d’émetteurs, le coefficient Fcot le plus défavorable sera pris, c’est-à-dire pour
+   * l’émetteur « Autre ».
+   */
+  if (em_ch.length > 1) {
+    Fcot = 0.802;
+  }
+
+  const nbNiveauChauffage = de.nombre_niveau_installation_ch || 1;
+
+  // Calcul de la longueur du réseau le plus défavorisé
+  const Lem = 5 * Fcot * (nbNiveauChauffage + (surfaceHabitable / nbNiveauChauffage) ** 0.5);
+
+  // Pertes de charge du réseau (kPa)
+  const deltaPemnom = 0.15 * Lem + deltaPem;
+
+  // Ratio du besoin couvert par l’équipement
+  const nbGenerateurCascade = du.nbGenerateurCascade || 1;
+  const ratioSurfaceChauffage =
+    (de.surface_chauffee || surfaceHabitable) / (surfaceHabitable * nbGenerateurCascade);
+
+  // Chute nominale de température de dimensionnement
+  // 4 - température de distribution de chauffage haute
+  const deltaDim = temperatureEmetteur === 4 ? 15 : 7.5;
+
+  // Puissance nominale en chaud (kW)
+  const Pnc = 10 ** -3 * GV * (20 - Tbase);
+
+  const Qvemnom = (Pnc * ratioSurfaceChauffage) / (1.163 * deltaDim);
+
+  return Math.max(
+    30,
+    6.44 *
+      ((deltaPemnom * Qvemnom) / Math.max(1, surfaceHabitable / 400)) ** 0.676 *
+      Math.max(1, surfaceHabitable / 400)
+  );
+}

package/16.2_production_enr.js

@@ -0,0 +1,328 @@
+import enums from './enums.js';
+import { mois_liste, tv } from './utils.js';
+import tvs from './tv.js';
+
+export class ProductionENR {
+  #taplpi = {
+    chauffage: 0.02,
+    ecs: 0.05,
+    refroidissement: 0.25,
+    eclairage: 0.05,
+    auxiliaire_ventilation: 0.5,
+    auxiliaire_distribution: 0.05,
+    autres: 0.45
+  };
+
+  /**
+   * Calcul des consommations d'électricité auto-consommée par enveloppe
+   * Mise à jour des conso ef en prenant en compte ces auto-consommations
+   * @param productionElecEnr
+   * @param Sh {string}
+   */
+  calculateEnr(productionElecEnr, conso, Sh, th, zc_id) {
+    const productionElectricite = {
+      conso_elec_ac: 0,
+      production_pv: 0,
+      conso_elec_ac_ch: 0,
+      conso_elec_ac_auxiliaire_generation_ch: 0,
+      conso_elec_ac_ecs: 0,
+      conso_elec_ac_auxiliaire_generation_ecs: 0,
+      conso_elec_ac_fr: 0,
+      conso_elec_ac_ventilation: 0,
+      conso_elec_ac_eclairage: 0,
+      conso_elec_ac_auxiliaire_distribution_ecs: 0,
+      conso_elec_ac_auxiliaire_distribution_ch: 0,
+      conso_elec_ac_auxiliaire: 0,
+      conso_elec_ac_autre_usage: 0
+    };
+
+    if (productionElecEnr && productionElecEnr.donnee_entree.presence_production_pv === 1) {
+      // Calcul de l'électricité auto-consommée pour chaque enveloppe
+      this.calculateConsoElecAc(productionElectricite, productionElecEnr, conso, zc_id, th, Sh);
+
+      // Mise à jour des consommations ef en minorant l'énergie consommée par l'énergie autoconsommée par le poste
+      this.updateEfConso(productionElectricite, conso, Sh);
+    }
+
+    return {
+      production_pv: productionElectricite.production_pv,
+      conso_elec_ac: productionElectricite.conso_elec_ac,
+      conso_elec_ac_ch: productionElectricite.conso_elec_ac_ch,
+      conso_elec_ac_ecs: productionElectricite.conso_elec_ac_ecs,
+      conso_elec_ac_fr: productionElectricite.conso_elec_ac_fr,
+      conso_elec_ac_eclairage: productionElectricite.conso_elec_ac_eclairage,
+      conso_elec_ac_auxiliaire: productionElectricite.conso_elec_ac_auxiliaire,
+      conso_elec_ac_autre_usage: productionElectricite.conso_elec_ac_autre_usage
+    };
+  }
+
+  /**
+   * Calcul de l'électricité auto-consommée pour chaque enveloppe
+   * @param productionElectricite production ENR totale du logement
+   * @param productionElecEnr installation ENR
+   * @param conso
+   * @param zc_id
+   * @param th
+   * @param Sh
+   */
+  calculateConsoElecAc(productionElectricite, productionElecEnr, conso, zc_id, th, Sh) {
+    // Production d’électricité par des capteurs photovoltaïques Ppv (en kWh/m²)
+    const Ppv = this.getPpv(productionElecEnr, zc_id);
+
+    // Consommation annuelle d’électricité pour les autres usages (kWhef/an)
+    const CelecTotAu = this.getCelecAu(th, Sh);
+
+    /**
+     * Récupération des consommations électriques pour ch et ecs
+     * @type {SortieParEnergieItem}
+     */
+    let consoElec = conso.sortie_par_energie_collection.sortie_par_energie.find(
+      (sortie) => sortie.enum_type_energie_id === '1'
+    );
+
+    /**
+     * Consommation totale annuelle d’électricité pour les 5 usages réglementaires et les usages mobiliers (kWhef/an)
+     */
+    const Celec_tot = consoElec.conso_5_usages + CelecTotAu;
+
+    // Autoconsommation proratisée à chaque usage
+    const production = this.getTapl(conso.ef_conso, consoElec, CelecTotAu, Celec_tot);
+
+    /**
+     * Coefficient de calage représentant le taux d’auto-production maximum pouvant être atteint lorsque
+     * la production d’électricité renouvelable augmente
+     */
+    const Tapl = Object.values(production).reduce((acc, valeur) => acc + valeur, 0);
+
+    /**
+     * Taux de couverture, correspondant au ratio entre la production totale du site et la consommation
+     * annuelle tous usages (%)
+     */
+    const Tcv = Ppv / Celec_tot;
+
+    /**
+     * Taux d’autoproduction, correspondant au rapport entre la production d’électricité autoconsommée et la
+     * consommation d’énergie (tous usages) du bâtiment (%)
+     */
+    const Tap = 1 / (1 / Tcv + 1 / Tapl);
+
+    // Electricité photovoltaïque autoconsommée (kWhef/an)
+    const consoElecAc = Celec_tot * Tap;
+
+    // Mise à jour des données intermédiaires pour l'installation ENR
+    productionElecEnr.donnee_intermediaire = productionElecEnr.donnee_intermediaire
+      ? productionElecEnr.donnee_intermediaire
+      : {};
+    productionElecEnr.donnee_intermediaire.conso_elec_ac = consoElecAc;
+    productionElecEnr.donnee_intermediaire.taux_autoproduction = Tap;
+    productionElecEnr.donnee_intermediaire.production_pv = Ppv;
+
+    productionElectricite.conso_elec_ac = consoElecAc;
+    productionElectricite.production_pv = Ppv;
+
+    productionElectricite.conso_elec_ac_ch = (consoElecAc * production.conso_elec_ac_ch) / Tapl;
+    productionElectricite.conso_elec_ac_auxiliaire_generation_ch =
+      (consoElecAc * production.conso_elec_ac_auxiliaire_generation_ch) / Tapl;
+    productionElectricite.conso_elec_ac_ecs = (consoElecAc * production.conso_elec_ac_ecs) / Tapl;
+    productionElectricite.conso_elec_ac_auxiliaire_generation_ecs =
+      (consoElecAc * production.conso_elec_ac_auxiliaire_generation_ecs) / Tapl;
+    productionElectricite.conso_elec_ac_fr = (consoElecAc * production.conso_elec_ac_fr) / Tapl;
+    productionElectricite.conso_elec_ac_eclairage =
+      (consoElecAc * production.conso_elec_ac_eclairage) / Tapl;
+    productionElectricite.conso_elec_ac_ventilation =
+      (consoElecAc * production.conso_elec_ac_ventilation) / Tapl;
+    productionElectricite.conso_elec_ac_auxiliaire_distribution_ecs =
+      (consoElecAc * production.conso_elec_ac_auxiliaire_distribution_ecs) / Tapl;
+    productionElectricite.conso_elec_ac_auxiliaire_distribution_ch =
+      (consoElecAc * production.conso_elec_ac_auxiliaire_distribution_ch) / Tapl;
+    productionElectricite.conso_elec_ac_autre_usage =
+      CelecTotAu * production.conso_elec_ac_autre_usage;
+
+    // Energies autoconsommée par les auxiliaires
+    const consoAcAuxiliaires =
+      productionElectricite.conso_elec_ac_auxiliaire_generation_ch +
+      productionElectricite.conso_elec_ac_auxiliaire_generation_ecs +
+      productionElectricite.conso_elec_ac_auxiliaire_distribution_ecs +
+      productionElectricite.conso_elec_ac_auxiliaire_distribution_ch +
+      productionElectricite.conso_elec_ac_ventilation;
+
+    productionElectricite.conso_elec_ac_auxiliaire = consoAcAuxiliaires;
+  }
+
+  /**
+   * Mise à jour des consommations ef en minorant l'énergie consommée par l'énergie autoconsommée par chaque enveloppe
+   * @param productionElectricite
+   * @param conso
+   * @param Sh
+   */
+  updateEfConso(productionElectricite, conso, Sh) {
+    conso.ef_conso.conso_ecs -= productionElectricite.conso_elec_ac_ecs;
+    conso.ef_conso.conso_ch -= productionElectricite.conso_elec_ac_ch;
+    conso.ef_conso.conso_fr -= productionElectricite.conso_elec_ac_fr;
+    conso.ef_conso.conso_eclairage -= productionElectricite.conso_elec_ac_eclairage;
+    conso.ef_conso.conso_totale_auxiliaire -= productionElectricite.conso_elec_ac_auxiliaire;
+
+    conso.ef_conso.conso_5_usages -=
+      productionElectricite.conso_elec_ac_ecs +
+      productionElectricite.conso_elec_ac_ch +
+      productionElectricite.conso_elec_ac_fr +
+      productionElectricite.conso_elec_ac_eclairage +
+      productionElectricite.conso_elec_ac_auxiliaire;
+
+    conso.ef_conso.conso_5_usages_m2 = Math.floor(conso.ef_conso.conso_5_usages / Sh);
+  }
+
+  /**
+   * Calcul des taux d'autoproduction consommés pour chaque enveloppe
+   * @param efConso {Ef_conso}
+   * @param consoElec
+   * @param ccom {number}
+   * @param consoElecTotale {number}
+   */
+  getTapl(efConso, consoElec, ccom, consoElecTotale) {
+    const productionElectricite = {
+      conso_elec_ac_ch: 0,
+      conso_elec_ac_auxiliaire_generation_ch: 0,
+      conso_elec_ac_ecs: 0,
+      conso_elec_ac_auxiliaire_generation_ecs: 0,
+      conso_elec_ac_fr: 0,
+      conso_elec_ac_ventilation: 0,
+      conso_elec_ac_eclairage: 0,
+      conso_elec_ac_auxiliaire_distribution_ecs: 0,
+      conso_elec_ac_auxiliaire_distribution_ch: 0,
+      conso_elec_ac_autre_usage: 0
+    };
+
+    // Consommation de chauffage récupérée directement depuis les consommations par énergie "électricité"
+    const chauffage = consoElec?.conso_ch;
+    if (chauffage) {
+      productionElectricite.conso_elec_ac_ch =
+        (this.#taplpi.chauffage * chauffage) / consoElecTotale;
+    }
+
+    const auxiliaireGenerationCh = efConso.conso_auxiliaire_generation_ch;
+    if (auxiliaireGenerationCh) {
+      productionElectricite.conso_elec_ac_auxiliaire_generation_ch =
+        (this.#taplpi.chauffage * auxiliaireGenerationCh) / consoElecTotale;
+    }
+
+    // Consommation ECS récupérée directement depuis les consommations par énergie "électricité"
+    const ecs = consoElec?.conso_ecs;
+    if (ecs) {
+      productionElectricite.conso_elec_ac_ecs = (this.#taplpi.ecs * ecs) / consoElecTotale;
+    }
+
+    const auxiliaireGenerationEcs = efConso.conso_auxiliaire_generation_ecs;
+    if (auxiliaireGenerationEcs) {
+      productionElectricite.conso_elec_ac_auxiliaire_generation_ecs =
+        (this.#taplpi.ecs * auxiliaireGenerationEcs) / consoElecTotale;
+    }
+
+    const refroidissement = efConso.conso_fr;
+    if (refroidissement) {
+      productionElectricite.conso_elec_ac_fr =
+        (this.#taplpi.refroidissement * refroidissement) / consoElecTotale;
+    }
+
+    const eclairage = efConso.conso_eclairage;
+    if (eclairage) {
+      productionElectricite.conso_elec_ac_eclairage =
+        (this.#taplpi.eclairage * eclairage) / consoElecTotale;
+    }
+
+    const auxiliaireVentilation = efConso.conso_auxiliaire_ventilation;
+    if (auxiliaireVentilation) {
+      productionElectricite.conso_elec_ac_ventilation =
+        (this.#taplpi.auxiliaire_ventilation * auxiliaireVentilation) / consoElecTotale;
+    }
+
+    const auxiliaireDistributionEcs = efConso.conso_auxiliaire_distribution_ecs;
+    if (auxiliaireDistributionEcs) {
+      productionElectricite.conso_elec_ac_auxiliaire_distribution_ecs =
+        (this.#taplpi.auxiliaire_distribution * auxiliaireDistributionEcs) / consoElecTotale;
+    }
+
+    const auxiliaireDistributionCh = efConso.conso_auxiliaire_distribution_ch;
+    if (auxiliaireDistributionCh) {
+      productionElectricite.conso_elec_ac_auxiliaire_distribution_ch =
+        (this.#taplpi.auxiliaire_distribution * auxiliaireDistributionCh) / consoElecTotale;
+    }
+
+    productionElectricite.conso_elec_ac_autre_usage =
+      (this.#taplpi.autres * ccom) / consoElecTotale;
+
+    return productionElectricite;
+  }
+
+  /**
+   * Consommation annuelle d’électricité pour "autres usages" (kWhef/an)
+   * @param th
+   * @param Sh
+   * @returns {number}
+   */
+  getCelecAu(th, Sh) {
+    /**
+     * Cum : consommation annuelle d’électricité des usages mobiliers
+     * Maison individuelle 29
+     * Immeuble collectif 27
+     */
+    const Cum = th === 'maison' ? 29 : 27;
+
+    // Consommation annuelle d’éclairage des parties communes en logement collectif
+    const CcomEcl = th === 'maison' ? 0 : 1.1;
+
+    return (CcomEcl + Cum) * Sh;
+  }
+
+  /**
+   * Production d’électricité par l'ensemble des capteurs photovoltaïques Ppv (en kWh/m²)
+   *
+   * @param productionElecEnr
+   * @param zc_id
+   * @returns {number}
+   */
+  getPpv(productionElecEnr, zc_id) {
+    const ePvValues = tvs.e_pv;
+    const zc = enums.zone_climatique[zc_id];
+
+    let panneaux_pv_collection = productionElecEnr.panneaux_pv_collection?.panneaux_pv || [];
+
+    if (!Array.isArray(panneaux_pv_collection)) {
+      panneaux_pv_collection = [panneaux_pv_collection];
+    }
+
+    return panneaux_pv_collection.reduce((acc, panneaux_pv) => {
+      const row = tv('coef_orientation_pv', {
+        enum_orientation_pv_id: panneaux_pv.enum_orientation_pv_id,
+        enum_inclinaison_pv_id: panneaux_pv.enum_inclinaison_pv_id
+      });
+
+      if (!row) {
+        return acc;
+      }
+
+      /**
+       * Coefficient de pondération prenant en compte l’altération par rapport à l’orientation optimale (30° auSud)
+       * des panneaux photovoltaïques
+       */
+      const k = row.coef_orientation_pv;
+
+      // Surface des panneaux photovoltaïques orientés et inclinés de la même manière (m²)
+      const Scapteur = 1.6 * panneaux_pv.nombre_module || panneaux_pv.surface_totale_capteurs;
+
+      // Rendement moyen des modules
+      const r = 0.17;
+
+      // Coefficient de perte
+      const C = 0.86;
+
+      for (const mois of mois_liste) {
+        // Ensoleillement en kWh/m² pour le mois
+        const Epv = ePvValues[mois][zc];
+        acc += k * Scapteur * r * Epv * C;
+      }
+
+      return acc;
+    }, 0);
+  }
+}