@open3cl/engine 1.8.68 → 1.9.1

package/11_ecs.js

@@ -58,11 +58,12 @@ function tv_rendement_distribution_ecs(di, de, du, pvc) {
  * Calcul installation par installation pour les réseaux collectifs bouclés ou avec traçage.
  *
  * @param {object} de - donnee_entree de l'installation ECS
+ * @param {object} di - donnee_intermediaire de l'installation ECS (reçoit la longueur de bouclage lb)
  * @param {number} surfaceImmeuble - surface habitable totale de l'immeuble (m²)
  * @param {object} becsParMois - besoin ECS mensuel de l'immeuble {Janvier: X, Février: X, ...} [kWh]
  * @returns {number} conso_auxiliaire_distribution_ecs_installation [Wh]
  */
-function calc_auxiliaire_distribution_ecs_immeuble(de, surfaceImmeuble, becsParMois) {
+function calc_auxiliaire_distribution_ecs_immeuble(de, di, surfaceImmeuble, becsParMois) {
   const type_installation = enums.type_installation[de.enum_type_installation_id];
 
   // Seulement pour les installations collectives
@@ -95,6 +96,7 @@ function calc_auxiliaire_distribution_ecs_immeuble(de, surfaceImmeuble, becsParM
     // Étape 3 : Calcul de Lb pour l'installation i
     // Lb = 1.2 × (1.1 × Sh_inst/nombre_niveaux + 4 × nombre_niveaux)
     const Lb = 1.2 * (1.1 * (Sh_inst / Niv_inst) + 4 * Niv_inst);
+    di.lb = Lb;
 
     // Étape 4 : DeltaPb = 0.2 × Lb + 10
     const DeltaPb = 0.2 * Lb + 10;
@@ -287,6 +289,7 @@ export default function calc_ecs(
   if (th === 'immeuble' && becsParMois && Object.keys(becsParMois).length > 0) {
     const conso_aux_wh = calc_auxiliaire_distribution_ecs_immeuble(
       de,
+      di,
       surfaceImmeuble,
       becsParMois
     );

package/11_ecs.spec.js

@@ -734,4 +734,36 @@ describe('calc_ecs - auxiliaires de distribution ECS (immeuble)', () => {
 
     expect(sansNiveau).toBe(avecUnNiveau);
   });
+
+  /** Calcule l'ECS d'un immeuble et retourne la donnée intermédiaire de l'installation. */
+  function donneeIntermediaireImmeuble(deExtra) {
+    const ecs = makeEcs({ tv_rendement_distribution_ecs_id: '5', ...deExtra });
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'immeuble', false, 400, null, false, {
+      Janvier: 10000
+    });
+    return ecs.donnee_intermediaire;
+  }
+
+  test('réseau bouclé : longueur de bouclage lb exposée dans la donnée intermédiaire', () => {
+    const di = donneeIntermediaireImmeuble({
+      enum_type_installation_id: '2',
+      enum_bouclage_reseau_ecs_id: '2',
+      surface_habitable: 100,
+      nombre_niveau_installation_ecs: '2'
+    });
+
+    // Lb = 1,2 × (1,1 × 100 / 2 + 4 × 2) = 75,6 m
+    expect(di.lb).toBeCloseTo(75.6, 9);
+  });
+
+  test.each([
+    ['réseau avec traçage', { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: '3' }],
+    [
+      'réseau collectif non bouclé',
+      { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: '1' }
+    ],
+    ['installation individuelle', { enum_type_installation_id: '1' }]
+  ])('%s : pas de longueur de bouclage lb', (_libelle, de) => {
+    expect(donneeIntermediaireImmeuble(de).lb).toBeUndefined();
+  });
 });

package/15_conso_aux.js

@@ -283,6 +283,12 @@ function getPuissanceCirculateur(em_ch, de, di, du, surfaceHabitable, GV, Tbase)
   // Calcul de la longueur du réseau le plus défavorisé
   const Lem = 5 * Fcot * (nbNiveauChauffage + (surfaceInstallation / nbNiveauChauffage) ** 0.5);
 
+  // Exposition de la longueur du réseau (lb) dans les données intermédiaires des émetteurs desservis
+  em_ch.forEach((em) => {
+    em.donnee_intermediaire = em.donnee_intermediaire || {};
+    em.donnee_intermediaire.lb = Lem;
+  });
+
   // Pertes de charge du réseau (kPa)
   const deltaPemnom = 0.15 * Lem + deltaPem;
 
@@ -412,6 +418,7 @@ export function conso_aux_distribution_ecs(
   // Pour l'appartement, on utilise la surface à l'échelle de l'immeuble
   const Sh = (Sh_install / Sh_logement) * Sh_immeuble_ratio;
   const Lb = 4 * Math.pow(Sh / Niv_inst_ecs, 0.5) + 6 * (Niv_inst_ecs - 0.5);
+  di.lb = Lb;
 
   // Etape 4: DeltaPb (kPa) - perte de charge dans le bouclage
   const DeltaPb = 0.2 * Lb + 10;

package/15_conso_aux.spec.js

@@ -389,6 +389,73 @@ describe('conso_aux_distribution_ch - auxiliaires de distribution', () => {
     );
   });
 
+  /**
+   * La longueur du réseau le plus défavorisé (Lem) est exposée sous le nom lb dans la donnée
+   * intermédiaire de chaque émetteur desservi par le circulateur.
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §15.2.1
+   */
+  test('longueur du réseau lb exposée dans la donnée intermédiaire des émetteurs', () => {
+    const em = [
+      {
+        donnee_entree: {
+          enum_type_emission_distribution_id: '10',
+          enum_temp_distribution_ch_id: '3'
+        },
+        donnee_intermediaire: { rendement_emission: 0.95 }
+      }
+    ];
+    conso_aux_distribution_ch(em, {}, {}, {}, 100, 1, 1, '0', 100000);
+    // Lem = 5 × Fcot × (Niv + (Sh / Niv)^0,5) = 5 × 0,802 × (1 + 10) = 44,11 m
+    expect(em[0].donnee_intermediaire.lb).toBeCloseTo(44.11, 9);
+    // les autres données intermédiaires de l'émetteur sont conservées
+    expect(em[0].donnee_intermediaire.rendement_emission).toBe(0.95);
+  });
+
+  test('lb : plancher chauffant sur 2 niveaux, donnée intermédiaire absente créée', () => {
+    const em = [
+      {
+        donnee_entree: {
+          enum_type_emission_distribution_id: '6',
+          enum_temp_distribution_ch_id: '3'
+        }
+      }
+    ];
+    conso_aux_distribution_ch(em, { nombre_niveau_installation_ch: 2 }, {}, {}, 200, 1, 1, '0', 1);
+    // Lem = 5 × 0,156 × (2 + (200 / 2)^0,5) = 9,36 m
+    expect(em[0].donnee_intermediaire.lb).toBeCloseTo(9.36, 9);
+  });
+
+  test('lb : seuls les émetteurs reliés au générateur reçoivent la longueur du réseau', () => {
+    const plancher = {
+      donnee_entree: {
+        enum_type_emission_distribution_id: '6',
+        enum_temp_distribution_ch_id: '3',
+        enum_lien_generateur_emetteur_id: '1'
+      }
+    };
+    const convecteur = {
+      donnee_entree: {
+        enum_type_emission_distribution_id: '1',
+        enum_temp_distribution_ch_id: '3',
+        enum_lien_generateur_emetteur_id: '2'
+      }
+    };
+    conso_aux_distribution_ch(
+      [plancher, convecteur],
+      { enum_lien_generateur_emetteur_id: '1' },
+      {},
+      {},
+      100,
+      1,
+      1,
+      '0',
+      100000
+    );
+    // Lem = 5 × 0,156 × (1 + 10) = 8,58 m
+    expect(plancher.donnee_intermediaire.lb).toBeCloseTo(8.58, 9);
+    expect(convecteur.donnee_intermediaire).toBeUndefined();
+  });
+
   test('aucun émetteur relié au générateur : tous les émetteurs sont conservés', () => {
     const em = (lien) => ({
       donnee_entree: {
@@ -776,6 +843,40 @@ describe("conso_aux_distribution_ecs - auxiliaires de distribution d'ECS", () =>
     expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo(2.4208575056559525, 9);
   });
 
+  test('réseau bouclé : longueur de bouclage lb exposée dans la donnée intermédiaire', () => {
+    const di = {};
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: 50,
+        nombre_niveau_installation_ecs: 4
+      },
+      di,
+      50,
+      1600,
+      1,
+      1,
+      30
+    );
+    // Sh = 1600 m² (échelle immeuble) : Lb = 4 × (1600 / 4)^0,5 + 6 × (4 − 0,5) = 80 + 21 = 101 m
+    expect(di.lb).toBeCloseTo(101, 9);
+  });
+
+  test.each([
+    [
+      'installation individuelle',
+      { enum_type_installation_id: '1', enum_bouclage_reseau_ecs_id: '2' }
+    ],
+    ['réseau non bouclé', { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: '1' }],
+    ['réseau avec traçage', { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: '3' }]
+  ])('%s : pas de longueur de bouclage lb', (_libelle, de) => {
+    const di = { besoin_ecs: 1000 };
+    conso_aux_distribution_ecs({}, de, di, 50, 2000, 1, 1, 30);
+    expect(di.lb).toBeUndefined();
+  });
+
   test('plus de niveaux desservis : bouclage plus court, donc consommation plus faible', () => {
     const scenario = (Niv) => {
       const di = {};

package/4_ventilation.js

@@ -38,6 +38,16 @@ export function isLigneQ4paMemePeriode(rowQ4paConv, cg) {
     .includes(String(cg.enum_periode_construction_id));
 }
 
+/**
+ * Vrai si la ligne de la table `q4pa_conv` considère les surfaces isolées (`isolation_surfaces` = 1)
+ * alors que le recalcul à partir des parois les donne non isolées (`isolation_surfaces` = 0).
+ */
+export function isLigneQ4paSurfacesIsolees(rowQ4paConv, isolationSurfacesRecalculee) {
+  return (
+    String(rowQ4paConv.isolation_surfaces) === '1' && String(isolationSurfacesRecalculee) === '0'
+  );
+}
+
 function tv_q4pa_conv(di, de, cg, mur_list, ph_list, porte_list, bv_list) {
   const surfaces = mur_list.concat(ph_list);
   const surface_isolee = surfaces.reduce((acc, s) => {
@@ -108,10 +118,18 @@ function tv_q4pa_conv(di, de, cg, mur_list, ph_list, porte_list, bv_list) {
        * 1948, surfaces isolées », 2, alors que toutes les parois sont non isolées → ligne 1, 4,6).
        * Si la ligne saisie correspond à la période de construction du DPE, on la reprend en entier
        * (isolation et joints) pour reproduire le calcul du logiciel.
+       *
+       * Sens unique : la reprise ne s'applique que si la ligne indique des surfaces isolées alors que
+       * le recalcul les donne non isolées. Dans le sens inverse (ligne « non isolées », recalcul
+       * « isolées »), le DPE a pu être modifié par l'appelant (scénario d'isolation des parois) :
+       * la valeur recalculée est utilisée.
        * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §4
        */
       if (rowQ4paConv.isolation_surfaces !== isolation_surfaces) {
-        if (isLigneQ4paMemePeriode(rowQ4paConv, cg)) {
+        if (
+          isLigneQ4paSurfacesIsolees(rowQ4paConv, isolation_surfaces) &&
+          isLigneQ4paMemePeriode(rowQ4paConv, cg)
+        ) {
           console.error(
             `Calcul de hperm pour la ventilation ${de.description}. Le DPE considère isolation_surfaces = ${rowQ4paConv.isolation_surfaces} \n          alors que ce devrait être isolation_surfaces = ${isolation_surfaces}. La ligne q4pa_conv ${de.tv_q4pa_conv_id} du DPE est conservée.`
           );

package/4_ventilation.spec.js

@@ -23,7 +23,8 @@ const {
   default: calc_ventilation,
   calc_hperm,
   presenceJointNonRenseignee,
-  isLigneQ4paMemePeriode
+  isLigneQ4paMemePeriode,
+  isLigneQ4paSurfacesIsolees
 } = await import('./4_ventilation.js');
 const { tv } = await import('./utils.js');
 const { default: calc_pvent } = await import('./5_conso_ventilation.js');
@@ -522,25 +523,88 @@ describe('calc_ventilation - compatibilité bug_for_bug_compat activée', () =>
       errorSpy.mockRestore();
     });
 
-    test('ligne 12 (non isolé, avec joints) reprise en entier, malgré des baies sans joint', async () => {
+    test('ligne isolée de la même période, joints absents de la ligne : joints « 0 » repris', async () => {
+      const { calc_ventilation_bug, tvBug } = await chargerAvecBug(ROW_10);
+      vi.spyOn(console, 'error').mockImplementation(() => {});
+      const baieAvecJoint = [{ donnee_entree: { surface_totale_baie: 10, presence_joint: 1 } }];
+
+      calc_ventilation_bug(vtLigne(10), CG, 'th', 80, 100, murNonIsole, [], [], baieAvecJoint);
+
+      // la ligne reprise prime sur les joints recalculés ('1')
+      expect(tvBug).toHaveBeenLastCalledWith(
+        'q4pa_conv',
+        expect.objectContaining({ isolation_surfaces: '1', presence_joints_menuiserie: '0' })
+      );
+    });
+
+    test('ligne isolée de la même période avec joints : joints « 1 » repris malgré des baies sans joint', async () => {
       const { calc_ventilation_bug, tvBug } = await chargerAvecBug({
-        q4pa_conv: '2.5',
-        tv_q4pa_conv_id: '12',
-        enum_periode_construction_id: '1',
-        isolation_surfaces: '0',
+        ...ROW_10,
+        tv_q4pa_conv_id: '11',
         presence_joints_menuiserie: '1'
       });
       vi.spyOn(console, 'error').mockImplementation(() => {});
-      const { murs } = surfacesIsolantes();
 
-      calc_ventilation_bug(vtLigne(12), CG, 'th', 80, 100, murs, [], [], baieSansJoint);
+      calc_ventilation_bug(vtLigne(11), CG, 'th', 80, 100, murNonIsole, [], [], baieSansJoint);
 
       expect(tvBug).toHaveBeenLastCalledWith(
         'q4pa_conv',
-        expect.objectContaining({ isolation_surfaces: '0', presence_joints_menuiserie: '1' })
+        expect.objectContaining({ isolation_surfaces: '1', presence_joints_menuiserie: '1' })
       );
     });
 
+    /**
+     * Sens unique : ligne « non isolées » alors que les parois sont isolées (cas d'un scénario de
+     * rénovation où l'appelant isole les murs du DPE). La ligne n'est pas reprise : l'isolation et
+     * les joints sont recalculés comme avant #312.
+     */
+    describe('ligne non isolée alors que les parois sont isolées (sens inverse)', () => {
+      const ROW_12 = {
+        q4pa_conv: '2.5',
+        tv_q4pa_conv_id: '12',
+        enum_periode_construction_id: '1',
+        isolation_surfaces: '0',
+        presence_joints_menuiserie: '1'
+      };
+
+      test('isolation recalculée utilisée et écart des joints signalé', async () => {
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+        const { calc_ventilation_bug, tvBug } = await chargerAvecBug(ROW_12);
+        const { murs } = surfacesIsolantes();
+
+        calc_ventilation_bug(vtLigne(12), CG, 'th', 80, 100, murs, [], [], baieSansJoint);
+
+        expect(tvBug).toHaveBeenLastCalledWith(
+          'q4pa_conv',
+          expect.objectContaining({ isolation_surfaces: '1', presence_joints_menuiserie: '0' })
+        );
+        expect(errorSpy).toHaveBeenCalledWith(
+          expect.stringContaining('La valeur recalculée isolation_surfaces = 1 est utilisée')
+        );
+        expect(errorSpy).toHaveBeenCalledWith(
+          expect.stringContaining(
+            'La valeur recalculée presence_joints_menuiserie = 0 est utilisée'
+          )
+        );
+        expect(errorSpy).not.toHaveBeenCalledWith(expect.stringContaining('est conservée'));
+        errorSpy.mockRestore();
+      });
+
+      test('presence_joint non exporté : seuls les joints de la ligne du DPE sont repris', async () => {
+        vi.spyOn(console, 'error').mockImplementation(() => {});
+        const { calc_ventilation_bug, tvBug } = await chargerAvecBug(ROW_12);
+        const { murs } = surfacesIsolantes();
+        const baies = [{ donnee_entree: { surface_totale_baie: 10 } }];
+
+        calc_ventilation_bug(vtLigne(12), CG, 'th', 80, 100, murs, [], [], baies);
+
+        expect(tvBug).toHaveBeenLastCalledWith(
+          'q4pa_conv',
+          expect.objectContaining({ isolation_surfaces: '1', presence_joints_menuiserie: '1' })
+        );
+      });
+    });
+
     test('ligne d’une autre période : la valeur recalculée est conservée', async () => {
       const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
       const { calc_ventilation_bug, tvBug } = await chargerAvecBug({
@@ -612,3 +676,19 @@ describe('isLigneQ4paMemePeriode', () => {
     expect(isLigneQ4paMemePeriode(null, { enum_periode_construction_id: '1' })).toBe(false);
   });
 });
+
+describe('isLigneQ4paSurfacesIsolees', () => {
+  test('ligne « surfaces isolées » et recalcul « non isolées » : vrai', () => {
+    expect(isLigneQ4paSurfacesIsolees({ isolation_surfaces: '1' }, '0')).toBe(true);
+    expect(isLigneQ4paSurfacesIsolees({ isolation_surfaces: 1 }, 0)).toBe(true);
+  });
+
+  test('ligne « non isolées » et recalcul « isolées » : faux (sens inverse)', () => {
+    expect(isLigneQ4paSurfacesIsolees({ isolation_surfaces: '0' }, '1')).toBe(false);
+  });
+
+  test('valeurs concordantes ou ligne sans critère : faux', () => {
+    expect(isLigneQ4paSurfacesIsolees({ isolation_surfaces: '1' }, '1')).toBe(false);
+    expect(isLigneQ4paSurfacesIsolees({}, '0')).toBe(false);
+  });
+});

package/engine.js

@@ -35,7 +35,7 @@ import DpeSanitizerService from './dpe-sanitizer.service.js';
 import { reconstituerRdimDpeGenereImmeuble } from './17.2_rdim_dpe_genere_immeuble.js';
 import { reconstituerRdimEcsIndividuelleUnique } from './11_rdim_ecs_individuelle_unique.js';
 
-const LIB_VERSION = '1.8.68';
+const LIB_VERSION = '1.9.1';
 
 const dpeSanitizerService = new DpeSanitizerService();
 

package/package.json

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