@open3cl/engine 1.8.8 → 1.8.10

package/engine.js

@@ -33,7 +33,7 @@ import getFicheTechnique from './ficheTechnique.js';
 import { ProductionENR } from './16.2_production_enr.js';
 import DpeSanitizerService from './dpe-sanitizer.service.js';
 
-const LIB_VERSION = '1.8.8';
+const LIB_VERSION = '1.8.10';
 
 const dpeSanitizerService = new DpeSanitizerService();
 
@@ -573,7 +573,8 @@ export function calcul_3cl(inputDpe, options) {
     prorataECS,
     prorataChauffage,
     dateDpe,
-    coef_ep
+    coef_ep,
+    th === 'immeuble' ? Nb_lgt : 1
   );
 
   const production_electricite = productionENR.calculateEnr(
@@ -595,7 +596,8 @@ export function calcul_3cl(inputDpe, options) {
     prorataECS,
     prorataChauffage,
     dateDpe,
-    coef_ep_1_7
+    coef_ep_1_7,
+    th === 'immeuble' ? Nb_lgt : 1
   );
 
   productionENR.calculateEnr(
@@ -618,7 +620,8 @@ export function calcul_3cl(inputDpe, options) {
     prorataECS,
     prorataChauffage,
     dateDpe,
-    coef_ep_2_3
+    coef_ep_2_3,
+    th === 'immeuble' ? Nb_lgt : 1
   );
 
   productionENR.calculateEnr(

package/features/engine/domain/apport_et_besoin/ch/perte-ch-recup.service.js

@@ -52,27 +52,73 @@ export class PerteChRecupService {
    */
   pertesGenerateurChRecup(ctx, logement, depensier) {
     const generateursWithPertesGeneration = this.generateursWithPertesGeneration(logement);
+    const generateursEcsSeulsWithPertesGeneration =
+      this.generateursEcsSeulsWithPertesGeneration(logement);
 
     return mois_liste.reduce((acc, mois) => {
+      const nref = this.#tvStore.getData(
+        depensier ? 'nref21' : 'nref19',
+        ctx.altitude.value,
+        ctx.zoneClimatique.value,
+        mois,
+        ctx.inertie.ilpa
+      );
       return (
         acc +
         this.Qrec(
           generateursWithPertesGeneration,
-          this.#tvStore.getData(
-            depensier ? 'nref21' : 'nref19',
-            ctx.altitude.value,
-            ctx.zoneClimatique.value,
-            mois,
-            ctx.inertie.ilpa
-          ),
+          nref,
           depensier
             ? logement.donnees_de_calcul.besoinChauffageDepensierHP[mois]
             : logement.donnees_de_calcul.besoinChauffageHP[mois]
-        )
+        ) +
+        this.QrecEcsSeul(generateursEcsSeulsWithPertesGeneration, nref)
       );
     }, 0);
   }
 
+  /**
+   * Générateurs de la collection ECS assurant l'ECS uniquement dont les pertes de génération sont
+   * récupérées pour le chauffage (issue #153) :
+   * — pertes à l'arrêt Qp0 > 0
+   * — situés en volume chauffé
+   * — usage ECS uniquement (enum_usage_generateur_id = 2). Les générateurs 'chauffage + ecs' sont
+   *   déjà pris en compte dans la collection des générateurs de chauffage.
+   *
+   * @param logement {Logement}
+   * @return {GenerateurEcs[]}
+   */
+  generateursEcsSeulsWithPertesGeneration(logement) {
+    const installationsEcs = logement.installation_ecs_collection?.installation_ecs || [];
+
+    return installationsEcs.flatMap((installation) =>
+      (installation.generateur_ecs_collection?.generateur_ecs || []).filter((generateurEcs) => {
+        const generateurEcsDE = generateurEcs.donnee_entree || {};
+        const generateurEcsDI = generateurEcs.donnee_intermediaire || {};
+        return (
+          Number(generateurEcsDI.qp0 || 0) > 0 &&
+          Number(generateurEcsDE.position_volume_chauffe ?? 0) === 1 &&
+          parseInt(generateurEcsDE.enum_usage_generateur_id) === 2
+        );
+      })
+    );
+  }
+
+  /**
+   * Pertes récupérées de génération pour le chauffage sur le mois j (Wh) pour les générateurs
+   * assurant l'ECS uniquement : Dperj = Nrefj * 1790 / 8760
+   *
+   * @param generateurs {GenerateurEcs[]}
+   * @param nref {number}
+   * @return {number}
+   */
+  QrecEcsSeul(generateurs, nref) {
+    return generateurs.reduce((acc, generateur) => {
+      const Cper = Number(generateur.donnee_entree.presence_ventouse || 0) === 1 ? 0.75 : 0.5;
+      return acc + 0.48 * Cper * generateur.donnee_intermediaire.qp0 * this.#pertes_gen_ecs(nref);
+    }, 0);
+  }
+
   /**
    * Pertes récupérées des générateurs de chauffage pour le chauffage
    * 9.1.1 Consommation de chauffage

package/features/engine/domain/apport_et_besoin/ch/perte-ch-recup.service.spec.js

@@ -0,0 +1,185 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
+import { PerteChRecupService } from './perte-ch-recup.service.js';
+import { mois_liste } from '../../../../../utils.js';
+
+/** @type {PerteChRecupService} **/
+let service;
+
+/** @type {FrTvStore} **/
+let tvStore;
+
+/**
+ * 9.1.1 Pertes récupérées de génération pour le chauffage
+ * Qgen_rec_j = 0,48 * Cper * Qp0 * Dperj
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §9.1.1
+ */
+describe('Calcul des pertes récupérées de génération pour le chauffage', () => {
+  /** @type {Contexte} */
+  const ctx = {
+    altitude: { value: '400-800m' },
+    zoneClimatique: { value: 'h1a' },
+    inertie: { ilpa: 0 }
+  };
+
+  /** Besoins de chauffage hors pertes (kWh) : 10 kWh par mois */
+  const donneesDeCalcul = {
+    besoinChauffageHP: Object.fromEntries(mois_liste.map((m) => [m, 10])),
+    besoinChauffageDepensierHP: Object.fromEntries(mois_liste.map((m) => [m, 12]))
+  };
+
+  /** Générateur ECS seul (usage 2), en volume chauffé, Qp0 = 100 W */
+  function generateurEcs(de = {}, di = { qp0: 100 }) {
+    return {
+      donnee_entree: {
+        enum_usage_generateur_id: 2,
+        position_volume_chauffe: 1,
+        presence_ventouse: 0,
+        ...de
+      },
+      donnee_intermediaire: di
+    };
+  }
+
+  /** Logement avec une installation ECS et, optionnellement, des générateurs de chauffage */
+  function logement(generateursEcs = [], generateursCh = []) {
+    return {
+      donnees_de_calcul: donneesDeCalcul,
+      installation_ecs_collection: {
+        installation_ecs: [{ generateur_ecs_collection: { generateur_ecs: generateursEcs } }]
+      },
+      installation_chauffage_collection: {
+        installation_chauffage: [
+          { generateur_chauffage_collection: { generateur_chauffage: generateursCh } }
+        ]
+      }
+    };
+  }
+
+  beforeEach(() => {
+    tvStore = new FrTvStore();
+    service = new PerteChRecupService(tvStore);
+    // Nref constant : 100 h (conventionnel) / 120 h (dépensier) pour chacun des 12 mois
+    vi.spyOn(tvStore, 'getData').mockImplementation((type) => (type === 'nref21' ? 120 : 100));
+  });
+
+  describe('Générateurs ECS assurant l’ECS uniquement (issue #153)', () => {
+    test('ECS seul sans ventouse : 0,48 * 0,5 * Qp0 * Nref * 1790 / 8760 par mois', () => {
+      const result = service.execute(ctx, logement([generateurEcs()]));
+
+      // 12 * 0.48 * 0.5 * 100 * (100 * 1790 / 8760) / 1000 = 5.884931506... kWh
+      expect(result.pertes_generateur_ch_recup).toBeCloseTo(5.884931506849315, 9);
+      // 12 * 0.48 * 0.5 * 100 * (120 * 1790 / 8760) / 1000 = 7.061917808... kWh
+      expect(result.pertes_generateur_ch_recup_depensier).toBeCloseTo(7.061917808219178, 9);
+    });
+
+    test('ECS seul avec ventouse : Cper = 0,75', () => {
+      const result = service.execute(ctx, logement([generateurEcs({ presence_ventouse: 1 })]));
+      expect(result.pertes_generateur_ch_recup).toBeCloseTo(1.5 * 5.884931506849315, 9);
+    });
+
+    test.each([
+      { cas: 'hors volume chauffé', de: { position_volume_chauffe: 0 }, di: { qp0: 100 } },
+      {
+        cas: 'position non renseignée',
+        de: { position_volume_chauffe: undefined },
+        di: { qp0: 100 }
+      },
+      {
+        cas: "usage 'chauffage + ecs' (déjà compté)",
+        de: { enum_usage_generateur_id: 3 },
+        di: { qp0: 100 }
+      },
+      { cas: 'Qp0 nul', de: {}, di: { qp0: 0 } },
+      { cas: 'Qp0 absent', de: {}, di: null }
+    ])('pas de récupération pour un générateur ECS $cas', ({ de, di }) => {
+      const result = service.execute(ctx, logement([generateurEcs(de, di)]));
+      expect(result.pertes_generateur_ch_recup).toBe(0);
+      expect(result.pertes_generateur_ch_recup_depensier).toBe(0);
+    });
+
+    test('logement sans installation ECS ni chauffage : aucune récupération', () => {
+      const result = service.execute(ctx, { donnees_de_calcul: donneesDeCalcul });
+      expect(result.pertes_generateur_ch_recup).toBe(0);
+    });
+
+    test('installation ECS sans collection de générateurs : aucune récupération', () => {
+      const result = service.execute(ctx, {
+        donnees_de_calcul: donneesDeCalcul,
+        installation_ecs_collection: { installation_ecs: [{}] }
+      });
+      expect(result.pertes_generateur_ch_recup).toBe(0);
+    });
+  });
+
+  describe('Générateurs de chauffage', () => {
+    /** Générateur de chauffage en volume chauffé, Pn = 10 000 W, Qp0 = 100 W */
+    function generateurCh(de = {}) {
+      return {
+        donnee_entree: {
+          position_volume_chauffe: 1,
+          enum_type_generateur_ch_id: 85,
+          enum_usage_generateur_id: 1,
+          ...de
+        },
+        donnee_intermediaire: { pn: 10000, qp0: 100 }
+      };
+    }
+
+    test('usage chauffage : Dperj = min(Nref, 1,3 * Bch / (0,3 * Pn))', () => {
+      const result = service.execute(ctx, logement([], [generateurCh()]));
+      // Dperj = min(100, 1.3 * 10 * 1000 / 3000) = 4.333.. h
+      // 12 * 0.48 * 0.5 * 100 * 4.333.. / 1000 = 1.248 kWh
+      expect(result.pertes_generateur_ch_recup).toBeCloseTo(1.248, 9);
+    });
+
+    test('usage ECS : Dperj = Nref * 1790 / 8760', () => {
+      const result = service.execute(
+        ctx,
+        logement([], [generateurCh({ enum_usage_generateur_id: 2 })])
+      );
+      expect(result.pertes_generateur_ch_recup).toBeCloseTo(5.884931506849315, 9);
+    });
+
+    test('usage chauffage + ECS avec ventouse : cumul des deux durées, Cper = 0,75', () => {
+      const result = service.execute(
+        ctx,
+        logement([], [generateurCh({ enum_usage_generateur_id: 3, presence_ventouse: 1 })])
+      );
+      // Dperj = min(100, 4.333.. + 20.4337..) ; 12 * 0.48 * 0.75 * 100 * Dperj / 1000
+      expect(result.pertes_generateur_ch_recup).toBeCloseTo(10.699397260273972, 9);
+    });
+
+    test.each([
+      { cas: 'hors volume chauffé', de: { position_volume_chauffe: 0 } },
+      { cas: 'à air chaud (50)', de: { enum_type_generateur_ch_id: 50 } },
+      { cas: 'à air chaud (52)', de: { enum_type_generateur_ch_id: 52 } }
+    ])('pas de récupération pour un générateur de chauffage $cas', ({ de }) => {
+      const result = service.execute(ctx, logement([], [generateurCh(de)]));
+      expect(result.pertes_generateur_ch_recup).toBe(0);
+    });
+
+    test('installation de chauffage sans collection de générateurs : aucune récupération', () => {
+      const result = service.execute(ctx, {
+        donnees_de_calcul: donneesDeCalcul,
+        installation_chauffage_collection: { installation_chauffage: [{}] }
+      });
+      expect(result.pertes_generateur_ch_recup).toBe(0);
+    });
+
+    test('cumul générateur de chauffage + générateur ECS seul', () => {
+      const result = service.execute(ctx, logement([generateurEcs()], [generateurCh()]));
+      expect(result.pertes_generateur_ch_recup).toBeCloseTo(1.248 + 5.884931506849315, 9);
+    });
+
+    test('un générateur ECS mixte (usage 3) n’est pas compté deux fois', () => {
+      const ch = generateurCh({ enum_usage_generateur_id: 3 });
+      const seul = service.execute(ctx, logement([], [ch]));
+      const avecEcsMixte = service.execute(
+        ctx,
+        logement([generateurEcs({ enum_usage_generateur_id: 3 })], [ch])
+      );
+      expect(avecEcsMixte.pertes_generateur_ch_recup).toBe(seul.pertes_generateur_ch_recup);
+    });
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open3cl/engine",
-  "version": "1.8.8",
+  "version": "1.8.10",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {

package/utils.js

@@ -277,10 +277,15 @@ export function requestInput(de, du, field, type) {
     return enums[field][de[enum_name]];
   } else {
     // not enums
+    // `!type` couvre aussi NaN, 0 et '' (valeurs falsy)
     if (!type) {
       console.error(`requestInput: type is not defined for ${field}`);
       return null;
     }
+    if (!['string', 'number', 'boolean'].includes(typeof type)) {
+      console.error(`requestInput: type has an unexpected type (${typeof type}) for ${field}`);
+      return null;
+    }
     du[field] = type;
     return de[field];
   }

package/utils.spec.js

@@ -287,6 +287,59 @@ describe('Utils unit tests', () => {
       spy.mockRestore();
     });
 
+    test.each([
+      ['NaN', Number.NaN],
+      ['0', 0],
+      ['une chaîne vide', '']
+    ])(
+      'requestInput : champ non enum avec %s comme type est traité comme un type absent',
+      (_libelle, type) => {
+        const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+        const de = { epaisseur: 5 };
+        const du = {};
+        expect(requestInput(de, du, 'epaisseur', type)).toBeNull();
+        expect(spy).toHaveBeenCalledWith('requestInput: type is not defined for epaisseur');
+        // Le type invalide n'est pas publié dans donnee_utilisateur
+        expect(du).toStrictEqual({});
+        spy.mockRestore();
+      }
+    );
+
+    test.each([
+      ['un objet', { a: 1 }, 'object'],
+      ['un tableau', ['number'], 'object'],
+      ['une fonction', () => 'number', 'function'],
+      ['un symbole', Symbol('number'), 'symbol'],
+      ['un bigint', 10n, 'bigint']
+    ])(
+      'requestInput : champ non enum avec %s comme type journalise une erreur et retourne null',
+      (_libelle, type, typeAttendu) => {
+        const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+        const de = { epaisseur: 5 };
+        const du = {};
+        expect(requestInput(de, du, 'epaisseur', type)).toBeNull();
+        expect(spy).toHaveBeenCalledWith(
+          `requestInput: type has an unexpected type (${typeAttendu}) for epaisseur`
+        );
+        expect(du).toStrictEqual({});
+        spy.mockRestore();
+      }
+    );
+
+    test.each([
+      ['une chaîne', 'string'],
+      ['un nombre', 1],
+      ['un booléen', true]
+    ])('requestInput : champ non enum avec %s comme type est accepté', (_libelle, type) => {
+      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const de = { epaisseur: 5 };
+      const du = {};
+      expect(requestInput(de, du, 'epaisseur', type)).toBe(5);
+      expect(du.epaisseur).toBe(type);
+      expect(spy).not.toHaveBeenCalled();
+      spy.mockRestore();
+    });
+
     test('requestInputID : sans type publie les clés et retourne l identifiant', () => {
       const de = { enum_materiaux_id: '1' };
       const du = {};