Issue 158/auxiliaires distribution ecs

src/15_conso_aux.js

@@ -1,6 +1,6 @@
 import enums from './enums.js';
 import tvs from './tv.js';
-import { mois_liste, Tbase } from './utils.js';
+import { mois_liste, Njj, Tbase } from './utils.js';
 
 const G_CHAUDIERE = 20;
 const G_RADIATEURS_GAZ = 40;
@@ -259,3 +259,112 @@ function getPuissanceCirculateur(em_ch, de, di, du, surfaceHabitable, GV, Tbase)
       Math.max(1, surfaceHabitable / 400)
   );
 }
+
+/**
+ * 15.2.3 Consommation des auxiliaires de distribution d'ECS
+ * Calcul installation par installation pour le cas appartement
+ *
+ * SI installation individuelle : conso = 0
+ * SI installation collective :
+ *   CAS 1 - enum_bouclage_reseau_ecs_id = 1 (non bouclé) : conso = 0
+ *   CAS 2 - enum_bouclage_reseau_ecs_id = 2 (bouclé) : calcul selon étapes 1-9
+ *   CAS 3 - enum_bouclage_reseau_ecs_id = 3 (traçage) : conso = 0.14 * BECS_annuel * Sh_install / Sh_logement
+ *
+ * @param ecs {object} installation ECS
+ * @param de {Donnee_entree} donnée d'entrée de l'installation ECS
+ * @param di {Donnee_intermediaire} donnée intermédiaire de l'installation ECS
+ * @param Sh_logement {number} surface habitable du logement
+ * @param Sh_immeuble {number} surface habitable de l'immeuble
+ * @param caId {number} id de la classe d'altitude
+ * @param zcId {number} id de la zone climatique
+ * @param nadeq {number} nombre d'unités d'équivalence
+ */
+export function conso_aux_distribution_ecs(
+  ecs,
+  de,
+  di,
+  Sh_logement,
+  Sh_immeuble,
+  caId,
+  zcId,
+  nadeq
+) {
+  const typeInstallation = parseInt(de.enum_type_installation_id);
+
+  if (typeInstallation === 1) {
+    di.conso_auxiliaire_distribution_ecs = 0;
+    return;
+  }
+
+  const enumBouclage = parseInt(de.enum_bouclage_reseau_ecs_id);
+
+  // CAS 1 - enum_bouclage_reseau_ecs_id =1 (réseau d'ECS non bouclé)
+  if (enumBouclage === 1) {
+    di.conso_auxiliaire_distribution_ecs = 0;
+    return;
+  }
+
+  // CAS 3 - enum_bouclage_reseau_ecs_id = 3 (traçage)
+  if (enumBouclage === 3) {
+    const BECS_annuel = di.besoin_ecs;
+    const Sh_install = de.surface_habitable || Sh_logement;
+    di.conso_auxiliaire_distribution_ecs = (0.14 * BECS_annuel * Sh_install) / Sh_logement;
+    return;
+  }
+
+  // CAS 2 - enum_bouclage_reseau_ecs_id = 2 (réseau bouclé)
+  const ca = enums.classe_altitude[caId];
+  const zc = enums.zone_climatique[zcId];
+
+  const Sh_install = de.surface_habitable;
+  const Niv_inst_ecs = de.nombre_niveau_installation_ecs || 1;
+
+  // Etape 3: Lb - longueur par défaut du bouclage ECS (m)
+  // Sh est la surface habitable des logements desservis par l'installation d'ECS
+  // Pour l'appartement, on utilise la surface à l'échelle de l'immeuble
+  const Sh = (Sh_install / Sh_logement) * Sh_immeuble;
+  const Lb = 4 * Math.pow(Sh / Niv_inst_ecs, 0.5) + 6 * (Niv_inst_ecs - 0.5);
+
+  // Etape 4: DeltaPb (kPa) - perte de charge dans le bouclage
+  const DeltaPb = 0.2 * Lb + 10;
+
+  let conso = 0;
+
+  for (const mois of mois_liste) {
+    // Besoin ECS mensuel pour le logement (kWh)
+    // spec : https://rt-re-batiment.developpement-durable.gouv.fr/IMG/pdf/consolide_annexe_1_arrete_du_31_03_2021_relatif_aux_methodes_et_procedures_applicables.pdf
+    // page 71-72
+    const tefsj = tvs.tefs[ca][mois][zc];
+    const njj = Njj[mois];
+    const BECS_j = (1.163 * nadeq * 56 * (40 - tefsj) * njj) / 1000;
+
+    // Etape 1: Qdwj_i (Wh) - pertes de distribution à l'échelle de l'immeuble
+    // Qd,w,j = (0.5 * Lvc / Sh + 0.112 + 0.028) * BECS_j
+    // Pour Ratecs=1 (bouclé): Lvc = 0.2 * Sh * Ratecs = 0.2 * Sh
+    // So Qd,w,j = (0.1 + 0.112 + 0.028) * BECS_j = 0.24 * BECS_j (kWh)
+    // Pour l'appartement: Qd,w,j est multiplié par Sh_immeuble / Sh_logement
+    const Qdwj_i = (0.24 * BECS_j * 1000 * Sh_install * Sh_immeuble) / (Sh_logement * Sh_logement);
+
+    // Etape 2: qdwj_i (m³/h) - débit de distribution ECS
+    const Nh_puisage_j = njj * 5;
+    const qdwj_i = Qdwj_i / (5.815 * Nh_puisage_j) / 1000;
+
+    // Etape 5: Phyd,j (W) - puissance hydraulique du bouclage
+    const Phyd_j = (qdwj_i * DeltaPb) / 3.6;
+
+    // Etape 6: Effcirb,j - efficacité du circulateur
+    const Effcirb_j = Math.pow(Phyd_j, 0.324) / 15.3;
+
+    // Etape 7: Pcirb,j (W) - puissance électrique du circulateur
+    const Pcirb_j = Math.max(20, Phyd_j / Effcirb_j);
+
+    // Etape 8: Qcirb,j (Wh) - consommation mensuelle du circulateur
+    const Nh_mois_j = njj * 24;
+    const Qcirb_j = Nh_puisage_j * Pcirb_j + (Nh_mois_j - Nh_puisage_j) * 20;
+
+    conso += Qcirb_j;
+  }
+
+  // Etape 9: conso annuelle ramenée à l'appartement (kWh)
+  di.conso_auxiliaire_distribution_ecs = (conso * Sh_logement) / Sh_immeuble / 1000;
+}

src/6.2_surface_sud_equivalente.js

@@ -6,7 +6,8 @@ export function calc_sse_j(bv_list, ets, ca, zc, mois) {
   const baiesAdjVeranda = bv_list.filter((bv) => bv.donnee_entree.enum_type_adjacence_id === '10');
   const baiesAdjExt = bv_list.filter((bv) => bv.donnee_entree.enum_type_adjacence_id === '1');
 
-  if (!ets) {
+  //ets peut etre un tableau vide  ou undefined selon les DPE, d'où la vérification ajoutée sur le tableau et sa longueur
+  if (!ets || (Array.isArray(ets) && ets.length === 0)) {
     return baiesAdjExt.reduce((acc, bv) => {
       return acc + getSsd(bv, zc, mois, bv.donnee_intermediaire.sw);
     }, 0);

src/conso.js

@@ -205,6 +205,11 @@ export default function calc_conso(
     return acc.concat(generateur_chauffage);
   }, []);
 
+  ecs = Array.isArray(ecs) ? ecs : [];
+
+  const conso_aux_distribution_ecs_total = ecs.reduce((acc, ecs) => {
+    return acc + (ecs.donnee_intermediaire.conso_auxiliaire_distribution_ecs || 0);
+  }, 0);
   const gen_ecs = ecs.reduce((acc, ecs) => {
     const generateur_ecs = ecs.generateur_ecs_collection.generateur_ecs;
     if (prorataECS === 1) {
@@ -230,7 +235,8 @@ export default function calc_conso(
       'conso',
       null,
       prorataECS,
-      prorataChauffage
+      prorataChauffage,
+      conso_aux_distribution_ecs_total
     ),
     ep_conso: calc_conso_pond(
       Sh,
@@ -242,7 +248,8 @@ export default function calc_conso(
       'ep_conso',
       coeffEp,
       prorataECS,
-      prorataChauffage
+      prorataChauffage,
+      conso_aux_distribution_ecs_total
     ),
     emission_ges: calc_conso_pond(
       Sh,
@@ -254,7 +261,8 @@ export default function calc_conso(
       'emission_ges',
       coef_ges,
       prorataECS,
-      prorataChauffage
+      prorataChauffage,
+      conso_aux_distribution_ecs_total
     ),
     cout: calc_conso_pond(
       Sh,
@@ -266,7 +274,8 @@ export default function calc_conso(
       'cout',
       coef_cout,
       prorataECS,
-      prorataChauffage
+      prorataChauffage,
+      conso_aux_distribution_ecs_total
     )
   };
   ret.ep_conso.classe_bilan_dpe = classe_bilan_dpe(
@@ -451,7 +460,8 @@ function calc_conso_pond(
   prefix,
   coef,
   prorataECS,
-  prorataChauffage
+  prorataChauffage,
+  conso_aux_distribution_ecs_total
 ) {
   const ret = {};
   ret.auxiliaire_ventilation = vt_list.reduce((acc, vt) => {
@@ -515,7 +525,11 @@ function calc_conso_pond(
     return acc + getConso(coef, 'électricité auxiliaire', conso);
   }, 0);
 
-  ret.auxiliaire_distribution_ecs = 0;
+  ret.auxiliaire_distribution_ecs = getConso(
+    coef,
+    'électricité auxiliaire',
+    conso_aux_distribution_ecs_total || 0
+  );
 
   ret.ecs = getEcsConso(gen_ecs, 'conso_ecs', coef, prorataECS, prefix);
 

src/engine.js

@@ -3,6 +3,7 @@ import calc_deperdition from './3_deperdition.js';
 import calc_apport_et_besoin from './apport_et_besoin.js';
 import calc_clim from './10_clim.js';
 import calc_ecs from './11_ecs.js';
+import { conso_aux_distribution_ecs } from './15_conso_aux.js';
 import calc_besoin_ch from './9_besoin_ch.js';
 import calc_chauffage, { tauxChargeForGenerator } from './9_chauffage.js';
 import calc_confort_ete from './2021_04_13_confort_ete.js';
@@ -426,6 +427,17 @@ export function calcul_3cl(inputDpe, options) {
       dpe.logement.caracteristique_generale.nombre_appartement,
       isImmeubleSystemEcsIndividuels
     );
+
+    conso_aux_distribution_ecs(
+      ecs,
+      ecs.donnee_entree,
+      ecs.donnee_intermediaire,
+      Sh,
+      cg.surface_habitable_immeuble,
+      ca_id,
+      zc_id,
+      apport_et_besoin.nadeq
+    );
   });
 
   /**

src/features/dpe/domain/models/installation-ecs.model.ts

@@ -34,6 +34,7 @@ export interface InstallationEcsDI {
   production_ecs_solaire?: number;
   conso_ecs: number;
   conso_ecs_depensier: number;
+  conso_auxiliaire_distribution_ecs?: number;
 }
 
 export interface InstallationEcsDU {

src/features/engine/domain/contexte.builder.js

@@ -39,6 +39,8 @@ export class ContexteBuilder {
       anneeConstruction: parseInt(caracteristiqueGenerale.annee_construction),
       effetJoule: this.#hasEffetJoule(dpe),
       surfaceHabitable: surfaceHabitable,
+      surfaceHabitableLogement: caracteristiqueGenerale.surface_habitable_logement,
+      surfaceHabitableImmeuble: caracteristiqueGenerale.surface_habitable_immeuble,
       hauteurSousPlafond: caracteristiqueGenerale.hsp,
       nombreAppartement: caracteristiqueGenerale.nombre_appartement,
       nadeq: this.#nadeqService.execute(

src/features/engine/domain/ecs/installation-ecs.service.js

@@ -1,4 +1,6 @@
 import { GenerateurEcsService } from './generateur-ecs.service.js';
+import { EcsTvStore } from '../../../../dpe/infrastructure/ecs/ecsTv.store.js';
+import { mois_liste, Njj } from '../../../../../utils.js';
 import { inject } from 'dioma';
 
 /**
@@ -10,20 +12,28 @@ import { inject } from 'dioma';
  *  — QdwIndVc: pertes de la distribution individuelle en volume chauffé pour le mois j (Wh)
  *  — QdwColVc: pertes de la distribution collective en volume chauffé pour le mois j (Wh)
  *  — QdwColHVc: pertes de la distribution collective hors volume chauffé pour le mois j (Wh)
+ *  — conso_auxiliaire_distribution_ecs: consommation des auxiliaires de distribution d'ECS (kWh)
  *
- * @see Méthode de calcul 3CL-DPE 2021 (cotobre 2021) chapitre 3
+ * @see Méthode de calcul 3CL-DPE 2021 (octobre 2021) chapitre 15.2.3
  */
 export class InstallationEcsService {
   /**
    * @type {GenerateurEcsService}
    */
   #generateurEcsService;
 
+  /**
+   * @type {EcsTvStore}
+   */
+  #tvStore;
+
   /**
    * @param generateurEcsService {GenerateurEcsService}
+   * @param tvStore {EcsTvStore}
    */
-  constructor(generateurEcsService = inject(GenerateurEcsService)) {
+  constructor(generateurEcsService = inject(GenerateurEcsService), tvStore = inject(EcsTvStore)) {
     this.#generateurEcsService = generateurEcsService;
+    this.#tvStore = tvStore;
   }
 
   /**
@@ -61,6 +71,11 @@ export class InstallationEcsService {
         besoinEcsInstallation * 1000,
         besoinEcsDepensierInstallation * 1000
       );
+
+      /**
+       * 15.2.3 Consommation des auxiliaires de distribution d'ECS
+       */
+      this.consoAuxiliaireDistributionEcs(ctx, installationEcs);
     });
   }
 
@@ -153,4 +168,93 @@ export class InstallationEcsService {
           }, 0);
     }
   }
+
+  /**
+   * 15.2.3 Consommation des auxiliaires de distribution d'ECS
+   *
+   * SI installation individuelle : conso = 0
+   * SI installation collective :
+   *   CAS 1 - enum_bouclage_reseau_ecs_id = 1 (non bouclé) : conso = 0
+   *   CAS 2 - enum_bouclage_reseau_ecs_id = 2 (bouclé) : calcul selon étapes 1-9
+   *   CAS 3 - enum_bouclage_reseau_ecs_id = 3 (traçage) : conso = 0.14 * BECS_annuel * Sh_install / Sh_logement
+   *
+   * @param ctx {Contexte}
+   * @param installationEcs {InstallationEcs}
+   */
+  consoAuxiliaireDistributionEcs(ctx, installationEcs) {
+    const installationEcsDE = installationEcs.donnee_entree;
+    const installationEcsDI = installationEcs.donnee_intermediaire;
+
+    const typeInstallation = parseInt(installationEcsDE.enum_type_installation_id);
+
+    if (typeInstallation === 1) {
+      installationEcsDI.conso_auxiliaire_distribution_ecs = 0;
+      return;
+    }
+
+    const enumBouclage = parseInt(installationEcsDE.enum_bouclage_reseau_ecs_id);
+
+    if (enumBouclage === 1) {
+      installationEcsDI.conso_auxiliaire_distribution_ecs = 0;
+      return;
+    }
+
+    const Sh_logement = ctx.surfaceHabitable;
+    const Sh_immeuble = ctx.surfaceHabitableImmeuble || Sh_logement;
+    const Sh_install = installationEcsDE.surface_habitable || Sh_logement;
+
+    if (enumBouclage === 3) {
+      const BECS_annuel = installationEcsDI.besoin_ecs;
+      installationEcsDI.conso_auxiliaire_distribution_ecs =
+        (0.14 * BECS_annuel * Sh_install) / Sh_logement;
+      return;
+    }
+
+    // CAS 2 - enum_bouclage_reseau_ecs_id = 2 (réseau bouclé)
+    const Niv_inst_ecs = installationEcsDE.nombre_niveau_installation_ecs || 1;
+    const nadeq = ctx.nadeq;
+    const ca = ctx.altitude.value;
+    const zc = ctx.zoneClimatique.value;
+
+    // Etape 3: Lb - longueur par défaut du bouclage ECS (m)
+    const Sh = (Sh_install / Sh_logement) * Sh_immeuble;
+    const Lb = 4 * Math.pow(Sh / Niv_inst_ecs, 0.5) + 6 * (Niv_inst_ecs - 0.5);
+
+    // Etape 4: DeltaPb (kPa) - perte de charge dans le bouclage
+    const DeltaPb = 0.2 * Lb + 10;
+
+    let conso = 0;
+
+    for (const mois of mois_liste) {
+      const tefsj = this.#tvStore.getTefs(ca, zc, mois);
+      const njj = Njj[mois];
+      const BECS_j = (1.163 * nadeq * 56 * (40 - tefsj) * njj) / 1000;
+
+      // Etape 1: Qdwj (Wh) - pertes de distribution à l'échelle de l'immeuble
+      const Qdwj = (0.24 * BECS_j * 1000 * Sh_install * Sh_immeuble) / (Sh_logement * Sh_logement);
+
+      // Etape 2: qdwj (m³/h) - débit de distribution ECS
+      const Nh_puisage_j = njj * 5;
+      const qdwj = Qdwj / (5.85 * Nh_puisage_j) / 1000;
+
+      // Etape 5: Phyd,j (W) - puissance hydraulique du bouclage
+      const Phyd_j = (qdwj * DeltaPb) / 3.6;
+
+      // Etape 6: Effcirb,j - efficacité du circulateur
+      const Effcirb_j = 0.324 / Math.pow(Phyd_j, 1 / 15.3);
+
+      // Etape 7: Pcirb,j (W) - puissance électrique du circulateur
+      const Pcirb_j = Math.max(20, Phyd_j / Effcirb_j);
+
+      // Etape 8: Qcirb,j (Wh) - consommation mensuelle du circulateur
+      const Nh_mois_j = njj * 24;
+      const Qcirb_j = Nh_puisage_j * Pcirb_j + (Nh_mois_j - Nh_puisage_j) * 20;
+
+      conso += Qcirb_j;
+    }
+
+    // Etape 9: conso annuelle ramenée à l'appartement (kWh)
+    installationEcsDI.conso_auxiliaire_distribution_ecs =
+      (conso * Sh_logement) / Sh_immeuble / 1000;
+  }
 }