@open3cl/engine 1.6.1 → 1.7.0

package/16.2_production_enr.spec.js

@@ -249,4 +249,192 @@ describe('production ENR unit tests', () => {
       }
     });
   });
+
+  test('should reuse an existing donnee_intermediaire when computing conso elec ac', () => {
+    // Le noeud donnee_intermediaire préexiste : il doit être conservé (et non recréé)
+    const productionElecEnr = {
+      donnee_intermediaire: { valeur_existante: 42 },
+      panneaux_pv_collection: {
+        panneaux_pv: [{ nombre_module: 8, enum_orientation_pv_id: 1, enum_inclinaison_pv_id: 2 }]
+      }
+    };
+
+    const productionElectricite = {};
+    const conso = {
+      ef_conso: {},
+      sortie_par_energie_collection: {
+        sortie_par_energie: [
+          { enum_type_energie_id: '1', conso_5_usages: 1500, conso_ch: 1000, conso_ecs: 1500 }
+        ]
+      }
+    };
+
+    productionENR.calculateConsoElecAc(
+      productionElectricite,
+      productionElecEnr,
+      conso,
+      1,
+      'maison',
+      10
+    );
+
+    // la clé préexistante est préservée, les champs calculés sont ajoutés
+    expect(productionElecEnr.donnee_intermediaire.valeur_existante).toBe(42);
+    expect(productionElecEnr.donnee_intermediaire.production_pv).toBe(2826.8015616000007);
+    expect(productionElecEnr.donnee_intermediaire.conso_elec_ac).toBeGreaterThan(0);
+  });
+
+  test('should get ppv when panneaux_pv is a single object (not an array)', () => {
+    const productionElecEnr = {
+      panneaux_pv_collection: {
+        panneaux_pv: {
+          nombre_module: 8,
+          enum_orientation_pv_id: 1,
+          enum_inclinaison_pv_id: 2
+        }
+      }
+    };
+    // même résultat qu'avec un tableau à un élément
+    expect(productionENR.getPpv(productionElecEnr, 1)).toBe(2826.8015616000007);
+  });
+
+  test('should update ep conso with a coeff ep override', () => {
+    const productionElectricite = {
+      conso_elec_ac_ecs: 200,
+      conso_elec_ac_ch: 150,
+      conso_elec_ac_fr: 100,
+      conso_elec_ac_eclairage: 250,
+      conso_elec_ac_auxiliaire: 300
+    };
+    const conso = {
+      ep_conso: {
+        ep_conso_ecs: 1000,
+        ep_conso_ch: 500,
+        ep_conso_fr: 800,
+        ep_conso_eclairage: 900,
+        ep_conso_totale_auxiliaire: 1250,
+        ep_conso_5_usages: 5000,
+        ep_conso_5_usages_m2: 100
+      }
+    };
+
+    // coeff_ep_override = 2 : chaque poste est minoré de 2 * autoconso
+    productionENR.updateEPConso(productionElectricite, conso, 10, 2);
+
+    expect(conso.ep_conso).toStrictEqual({
+      ep_conso_ecs: 600, // 1000 - 2*200
+      ep_conso_ch: 200, // 500 - 2*150
+      ep_conso_fr: 600, // 800 - 2*100
+      ep_conso_eclairage: 400, // 900 - 2*250
+      ep_conso_totale_auxiliaire: 650, // 1250 - 2*300
+      ep_conso_5_usages: 3000, // 5000 - 2*1000
+      ep_conso_5_usages_m2: 300 // floor(3000 / 10)
+    });
+  });
+
+  test('should update ep conso with the default coeff ep (1.9) when no override', () => {
+    const productionElectricite = {
+      conso_elec_ac_ecs: 200,
+      conso_elec_ac_ch: 150,
+      conso_elec_ac_fr: 100,
+      conso_elec_ac_eclairage: 250,
+      conso_elec_ac_auxiliaire: 300
+    };
+    const conso = {
+      ep_conso: {
+        ep_conso_ecs: 1000,
+        ep_conso_ch: 500,
+        ep_conso_fr: 800,
+        ep_conso_eclairage: 900,
+        ep_conso_totale_auxiliaire: 1250,
+        ep_conso_5_usages: 5000,
+        ep_conso_5_usages_m2: 100
+      }
+    };
+
+    // pas d'override => coefficient par défaut 1.9
+    productionENR.updateEPConso(productionElectricite, conso, 10);
+
+    expect(conso.ep_conso).toStrictEqual({
+      ep_conso_ecs: 620, // 1000 - 1.9*200
+      ep_conso_ch: 215, // 500 - 1.9*150
+      ep_conso_fr: 610, // 800 - 1.9*100
+      ep_conso_eclairage: 425, // 900 - 1.9*250
+      ep_conso_totale_auxiliaire: 680, // 1250 - 1.9*300
+      ep_conso_5_usages: 3100, // 5000 - 1.9*1000
+      ep_conso_5_usages_m2: 310 // floor(3100 / 10)
+    });
+  });
+
+  test.each([
+    ['une installation absente', null],
+    ["l'absence de production photovoltaïque", { donnee_entree: { presence_production_pv: 0 } }]
+  ])('calculateEnr retourne des autoconsommations nulles pour %s', (_label, productionElecEnr) => {
+    const conso = { ef_conso: {}, ep_conso: {} };
+
+    const ret = productionENR.calculateEnr(productionElecEnr, conso, 10, 'maison', 1, 100);
+
+    expect(ret).toStrictEqual({
+      production_pv: 0,
+      conso_elec_ac: 0,
+      conso_elec_ac_ch: 0,
+      conso_elec_ac_ecs: 0,
+      conso_elec_ac_fr: 0,
+      conso_elec_ac_eclairage: 0,
+      conso_elec_ac_auxiliaire: 0,
+      conso_elec_ac_autre_usage: 0
+    });
+  });
+
+  test('calculateEnr calcule et applique les autoconsommations en présence de PV', () => {
+    const productionElecEnr = {
+      donnee_entree: { presence_production_pv: 1 },
+      panneaux_pv_collection: {
+        panneaux_pv: [{ nombre_module: 8, enum_orientation_pv_id: 1, enum_inclinaison_pv_id: 2 }]
+      }
+    };
+    const conso = {
+      ef_conso: {
+        conso_ecs: 1000,
+        conso_ch: 500,
+        conso_fr: 800,
+        conso_eclairage: 900,
+        conso_totale_auxiliaire: 1250,
+        conso_5_usages: 1500,
+        conso_5_usages_m2: 100
+      },
+      ep_conso: {
+        ep_conso_ecs: 3000,
+        ep_conso_ch: 1500,
+        ep_conso_fr: 2000,
+        ep_conso_eclairage: 1800,
+        ep_conso_totale_auxiliaire: 2500,
+        ep_conso_5_usages: 10000,
+        ep_conso_5_usages_m2: 100
+      },
+      sortie_par_energie_collection: {
+        sortie_par_energie: [
+          { enum_type_energie_id: '1', conso_5_usages: 1500, conso_ch: 1000, conso_ecs: 1500 }
+        ]
+      }
+    };
+
+    const ret = productionENR.calculateEnr(productionElecEnr, conso, 10, 'maison', 1, 100);
+
+    // valeurs de référence de régression
+    expect(ret).toStrictEqual({
+      production_pv: 2826.8015616000007,
+      conso_elec_ac: 403.3632077277818,
+      conso_elec_ac_ch: 17.146151231786686,
+      conso_elec_ac_ecs: 64.29806711920007,
+      conso_elec_ac_fr: 171.46151231786683,
+      conso_elec_ac_eclairage: 38.57884027152004,
+      conso_elec_ac_auxiliaire: 0,
+      conso_elec_ac_autre_usage: 21.14245810055866
+    });
+
+    // les consommations d'énergie finale sont bien minorées par l'autoconsommation
+    expect(conso.ef_conso.conso_ecs).toBeLessThan(1000);
+    expect(conso.ef_conso.conso_5_usages).toBeLessThan(1500);
+  });
 });

package/16_conso_eclairage.spec.js

@@ -0,0 +1,62 @@
+import { describe, expect, test, vi } from 'vitest';
+
+/**
+ * Le module ne dépend que du mapping enum_zone_climatique_id -> libellé de zone.
+ * On le mocke afin d'isoler le test du contenu réel de `enums`.
+ */
+vi.mock('./enums.js', () => ({
+  default: {
+    zone_climatique: {
+      1: 'h1a',
+      2: 'h1b',
+      3: 'h1c',
+      4: 'h2a',
+      5: 'h2b',
+      6: 'h2c',
+      7: 'h2d',
+      8: 'h3'
+    }
+  }
+}));
+
+const { default: calc_conso_eclairage } = await import('./16_conso_eclairage.js');
+
+/**
+ * 16.1 Consommation d'éclairage (Cecl)
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §16.1
+ *
+ * Cecl = (C * Pecl * Nh) / 1000 avec C = 0.9 (interrupteur) et Pecl = 1.4 W/m²
+ * Nh = nombre d'heures de fonctionnement de l'éclairage, fonction de la zone climatique.
+ */
+describe("Calcul de la consommation d'éclairage (Cecl)", () => {
+  // [enum_zone_climatique_id, libellé, Nh, Cecl attendu]
+  test.each([
+    ['1', 'h1a', 1500, (0.9 * 1.4 * 1500) / 1000],
+    ['2', 'h1b', 1445, (0.9 * 1.4 * 1445) / 1000],
+    ['3', 'h1c', 1476, (0.9 * 1.4 * 1476) / 1000],
+    ['4', 'h2a', 1500, (0.9 * 1.4 * 1500) / 1000],
+    ['5', 'h2b', 1531, (0.9 * 1.4 * 1531) / 1000],
+    ['6', 'h2c', 1566, (0.9 * 1.4 * 1566) / 1000],
+    ['7', 'h2d', 1566, (0.9 * 1.4 * 1566) / 1000],
+    ['8', 'h3', 1506, (0.9 * 1.4 * 1506) / 1000]
+  ])(
+    'zone climatique %s (%s) : Nh=%d heures => Cecl attendu',
+    (zc_id, _libelle, _nh, cecl_attendu) => {
+      expect(calc_conso_eclairage(zc_id)).toBeCloseTo(cecl_attendu, 10);
+    }
+  );
+
+  test('la consommation est identique pour deux zones ayant le même Nh (h1a et h2a)', () => {
+    expect(calc_conso_eclairage('1')).toBeCloseTo(calc_conso_eclairage('4'), 10);
+  });
+
+  test("la consommation croît avec le nombre d'heures (h1b < h3 < h2c)", () => {
+    expect(calc_conso_eclairage('2')).toBeLessThan(calc_conso_eclairage('8'));
+    expect(calc_conso_eclairage('8')).toBeLessThan(calc_conso_eclairage('6'));
+  });
+
+  test('retourne NaN pour un identifiant de zone climatique inconnu', () => {
+    // enums.zone_climatique[zc_id] est undefined => Nh[undefined] est undefined => NaN
+    expect(calc_conso_eclairage('99')).toBeNaN();
+  });
+});

package/2021_04_13_confort_ete.spec.js

@@ -0,0 +1,159 @@
+import { describe, expect, test, vi } from 'vitest';
+
+/**
+ * Dépendances mockées pour isoler `calc_confort_ete` :
+ * - `enums.classe_inertie` : détermine le caractère « lourd » de l'inertie ;
+ * - `getKeyByValue` : réduit à un passe-plat renvoyant directement le libellé
+ *   de confort (on assertera donc `enum_indicateur_confort_ete_id` = libellé) ;
+ * - `requestInput` : passe-plat lisant le champ demandé dans les données d'entrée.
+ */
+vi.mock('./enums.js', () => ({
+  default: {
+    classe_inertie: { 1: 'légère', 2: 'moyenne', 3: 'lourde', 4: 'très lourde' },
+    indicateur_confort_ete: { 1: 'insuffisant', 2: 'moyen', 3: 'bon' }
+  }
+}));
+
+vi.mock('./utils.js', () => ({
+  getKeyByValue: (object, value) => value,
+  requestInput: (de, du, field) => de[field]
+}));
+
+const { default: calc_confort_ete } = await import('./2021_04_13_confort_ete.js');
+
+/** Fabrique une baie vitrée : `enum_orientation_id` sert au caractère traversant,
+ * `orientation` et `type_fermeture` à la protection solaire. */
+function baie({ orientationId, orientation = 'sud', typeFermeture = 'volet' }) {
+  return {
+    donnee_entree: {
+      enum_orientation_id: orientationId,
+      orientation,
+      type_fermeture: typeFermeture
+    },
+    donnee_utilisateur: {}
+  };
+}
+
+/** Fabrique un plancher haut avec son type d'adjacence et d'isolation. */
+function plancherHaut({ typeAdjacence = 'extérieur', typeIsolation = 'isolé' }) {
+  return {
+    donnee_entree: { type_adjacence: typeAdjacence, type_isolation: typeIsolation },
+    donnee_utilisateur: {}
+  };
+}
+
+/**
+ * Indicateur de confort d'été
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - annexe confort d'été
+ */
+describe("calc_confort_ete - indicateur de confort d'été", () => {
+  test('inertie lourde + aspect traversant : niveau « bon »', () => {
+    // deux orientations distinctes => aspect_traversant = 1 ; inertie lourde = 1 => nv_bon = 2
+    const bv = [baie({ orientationId: '1' }), baie({ orientationId: '2' })];
+    const ph = [plancherHaut({ typeIsolation: 'isolé' })];
+
+    const ret = calc_confort_ete('3', bv, ph);
+
+    expect(ret.inertie_lourde).toBe(1);
+    expect(ret.aspect_traversant).toBe(1);
+    expect(ret.enum_indicateur_confort_ete_id).toBe('bon');
+  });
+
+  test('inertie « très lourde » également considérée comme lourde', () => {
+    const bv = [baie({ orientationId: '1' }), baie({ orientationId: '2' })];
+    const ph = [plancherHaut({})];
+
+    const ret = calc_confort_ete('4', bv, ph);
+
+    expect(ret.inertie_lourde).toBe(1);
+  });
+
+  test('une seule orientation : aspect non traversant', () => {
+    const bv = [baie({ orientationId: '1' }), baie({ orientationId: '1' })];
+    const ph = [plancherHaut({})];
+
+    const ret = calc_confort_ete('2', bv, ph);
+
+    expect(ret.aspect_traversant).toBe(0);
+  });
+
+  test('inertie légère sans aspect traversant : niveau « moyen »', () => {
+    // nv_bon = 0 (< 2) mais protections OK => moyen
+    const bv = [baie({ orientationId: '1' })];
+    const ph = [plancherHaut({})];
+
+    const ret = calc_confort_ete('1', bv, ph);
+
+    expect(ret.inertie_lourde).toBe(0);
+    expect(ret.enum_indicateur_confort_ete_id).toBe('moyen');
+  });
+
+  test("toiture non isolée donnant sur l'extérieur : niveau « insuffisant »", () => {
+    const bv = [baie({ orientationId: '1' }), baie({ orientationId: '2' })];
+    const ph = [plancherHaut({ typeAdjacence: 'extérieur', typeIsolation: 'non isolé' })];
+
+    const ret = calc_confort_ete('3', bv, ph);
+
+    expect(ret.isolation_toiture).toBe(0);
+    expect(ret.enum_indicateur_confort_ete_id).toBe('insuffisant');
+  });
+
+  test("toiture d'isolation inconnue donnant sur l'extérieur : isolation nulle", () => {
+    const bv = [baie({ orientationId: '1' })];
+    const ph = [plancherHaut({ typeAdjacence: 'extérieur', typeIsolation: 'inconnu' })];
+
+    const ret = calc_confort_ete('3', bv, ph);
+
+    expect(ret.isolation_toiture).toBe(0);
+  });
+
+  test('toiture non isolée mais non extérieure : isolation préservée', () => {
+    const bv = [baie({ orientationId: '1' }), baie({ orientationId: '2' })];
+    const ph = [plancherHaut({ typeAdjacence: 'local non chauffé', typeIsolation: 'non isolé' })];
+
+    const ret = calc_confort_ete('3', bv, ph);
+
+    expect(ret.isolation_toiture).toBe(1);
+  });
+
+  test('baie non nord sans fermeture : protection solaire nulle => « insuffisant »', () => {
+    const bv = [
+      baie({
+        orientationId: '1',
+        orientation: 'sud',
+        typeFermeture: 'abscence de fermeture pour la baie vitrée'
+      })
+    ];
+    const ph = [plancherHaut({})];
+
+    const ret = calc_confort_ete('3', bv, ph);
+
+    expect(ret.protection_solaire_exterieure).toBe(0);
+    expect(ret.enum_indicateur_confort_ete_id).toBe('insuffisant');
+  });
+
+  test('baie nord sans fermeture : ignorée, protection solaire préservée', () => {
+    const bv = [
+      baie({
+        orientationId: '1',
+        orientation: 'nord',
+        typeFermeture: 'abscence de fermeture pour la baie vitrée'
+      }),
+      baie({
+        orientationId: '2',
+        orientation: 'nord',
+        typeFermeture: 'abscence de fermeture pour la baie vitrée'
+      })
+    ];
+    const ph = [plancherHaut({})];
+
+    const ret = calc_confort_ete('3', bv, ph);
+
+    expect(ret.protection_solaire_exterieure).toBe(1);
+  });
+
+  test("le brasseur d'air est toujours absent (0) dans ce calcul", () => {
+    const ret = calc_confort_ete('3', [baie({ orientationId: '1' })], [plancherHaut({})]);
+    expect(ret.brasseur_air).toBe(0);
+  });
+});

package/2021_04_13_qualite_isolation.js

@@ -1,7 +1,7 @@
 /**
  * @returns {number}
  */
-function qualite_isol(dep, surface, seuil1, seuil2, seuil3) {
+export function qualite_isol(dep, surface, seuil1, seuil2, seuil3) {
   /**
    * 1 - Très bonne
    * 2 - Bonne