@open3cl/engine 1.0.7 → 1.0.9

package/features/dpe/infrastructure/baieVitreeTv.store.spec.js

@@ -0,0 +1,352 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import { BaieVitreeTvStore } from './baieVitreeTv.store.js';
+
+/** @type {BaieVitreeTvStore} **/
+let tvStore;
+
+describe('Lecture des tables de valeurs', () => {
+  beforeEach(() => {
+    tvStore = new BaieVitreeTvStore();
+  });
+
+  describe('lecture des valeurs de ug', () => {
+    test.each([
+      {
+        label: 'Simple vitrage',
+        enumTypeVitrageId: '1',
+        expected: 5.8
+      },
+      {
+        label: "Survitrage non traité avec lame d'air 6mm",
+        enumTypeVitrageId: '4',
+        epaisseurLame: 6,
+        expected: 3.4
+      },
+      {
+        label: "Survitrage non traité avec lame d'air 20mm",
+        enumTypeVitrageId: '4',
+        epaisseurLame: 20,
+        expected: 2.8
+      },
+      {
+        label: "Double vitrage vertical traité avec lame d'air argon 14mm",
+        enumTypeVitrageId: '2',
+        epaisseurLame: 14,
+        enumTypeGazLameId: '2',
+        enumInclinaisonVitrageId: '1',
+        vitrageVir: '1',
+        expected: 1.2
+      },
+      {
+        label: "Double vitrage vertical non traité avec lame d'air argon 14mm",
+        enumTypeVitrageId: '2',
+        epaisseurLame: 14,
+        enumTypeGazLameId: '2',
+        enumInclinaisonVitrageId: '1',
+        vitrageVir: '0',
+        expected: 2.8
+      },
+      {
+        label: "Double vitrage horizontal non traité avec lame d'air inconnu 15mm",
+        enumTypeVitrageId: '2',
+        epaisseurLame: 15,
+        enumTypeGazLameId: '3',
+        enumInclinaisonVitrageId: '4',
+        vitrageVir: '0',
+        expected: 2.9
+      },
+      {
+        label: "Double vitrage horizontal non traité avec lame d'air inconnu 12mm",
+        enumTypeVitrageId: '2',
+        epaisseurLame: 12,
+        enumTypeGazLameId: '3',
+        enumInclinaisonVitrageId: '4',
+        vitrageVir: '0',
+        expected: 3.1
+      }
+    ])(
+      `ug pour baie vitrée $label`,
+      ({
+        enumTypeVitrageId,
+        enumTypeGazLameId = undefined,
+        enumInclinaisonVitrageId = undefined,
+        vitrageVir = undefined,
+        epaisseurLame = undefined,
+        expected
+      }) => {
+        expect(
+          tvStore.getUg(
+            enumTypeVitrageId,
+            enumTypeGazLameId,
+            enumInclinaisonVitrageId,
+            vitrageVir,
+            epaisseurLame
+          )
+        ).toBe(expected);
+      }
+    );
+
+    test('Récupération des valeurs des épaisseurs disponibles pour les valeurs de ug', () => {
+      expect(tvStore.getEpaisseurAvailableForUg()).toStrictEqual([
+        0, 6, 8, 10, 12, 14, 15, 16, 18, 20
+      ]);
+    });
+
+    test('pas de valeur de ug', () => {
+      const ug = tvStore.getUg('0', '0', '0', false, 0);
+      expect(ug).toBeUndefined();
+    });
+  });
+
+  describe('lecture des valeurs de sw', () => {
+    test.each([
+      {
+        label: 'Paroi en brique de verre pleine',
+        enumTypeBaieId: '1',
+        enumTypeMateriauxMenuiserieId: '1',
+        expected: 0.4
+      },
+      {
+        label: 'Paroi en polycarbonnate',
+        enumTypeBaieId: '3',
+        enumTypeMateriauxMenuiserieId: '2',
+        expected: 0.4
+      },
+      {
+        label: 'Fenêtres battantes',
+        enumTypeBaieId: '4',
+        enumTypeMateriauxMenuiserieId: '3',
+        enumTypeVitrageId: '1',
+        expected: 0.58
+      },
+      {
+        label: 'Fenêtres coulissantes',
+        enumTypeBaieId: '5',
+        enumTypeMateriauxMenuiserieId: '3',
+        enumTypeVitrageId: '3',
+        enumTypePoseId: '2',
+        expected: 0.41
+      },
+      {
+        label: 'Fenêtres coulissantes',
+        enumTypeBaieId: '5',
+        enumTypeMateriauxMenuiserieId: '3',
+        enumTypeVitrageId: '3',
+        enumTypePoseId: '2',
+        vitrageVir: 1,
+        expected: 0.37
+      },
+      {
+        label: 'Fenêtres coulissantes',
+        enumTypeBaieId: '5',
+        enumTypeMateriauxMenuiserieId: '3',
+        enumTypeVitrageId: '3',
+        enumTypePoseId: '2',
+        vitrageVir: '1',
+        expected: 0.37
+      }
+    ])(
+      `sw pour baie vitrée $label`,
+      ({
+        enumTypeVitrageId = undefined,
+        enumTypeBaieId,
+        enumTypeMateriauxMenuiserieId,
+        vitrageVir = undefined,
+        enumTypePoseId = undefined,
+        expected
+      }) => {
+        expect(
+          tvStore.getSw(
+            enumTypeVitrageId,
+            enumTypeBaieId,
+            enumTypeMateriauxMenuiserieId,
+            vitrageVir,
+            enumTypePoseId
+          )
+        ).toBe(expected);
+      }
+    );
+
+    test('pas de valeur de sw', () => {
+      const ug = tvStore.getSw('0', '0', '0', '0', '0');
+      expect(ug).toBeUndefined();
+    });
+  });
+
+  describe('lecture des valeurs de uw', () => {
+    test.each([
+      {
+        label: 'Paroi en brique de verre pleine',
+        enumTypeBaieId: '1',
+        enumTypeMateriauxMenuiserieId: '1',
+        expected: 3.5
+      },
+      {
+        label: 'Paroi en polycarbonnate',
+        enumTypeBaieId: '3',
+        enumTypeMateriauxMenuiserieId: '2',
+        expected: 3
+      },
+      {
+        label: 'uw non extrapolé pour Fenêtres battantes',
+        enumTypeBaieId: '4',
+        enumTypeMateriauxMenuiserieId: '6',
+        ug: 0.5,
+        expected: 1.3
+      },
+      {
+        label: 'uw extrapolé pour Fenêtres coulissantes',
+        enumTypeBaieId: '5',
+        enumTypeMateriauxMenuiserieId: '6',
+        ug: '2.45',
+        expected: 3.05
+      },
+      {
+        label: 'uw extrapolé pour Fenêtres coulissantes',
+        enumTypeBaieId: '5',
+        enumTypeMateriauxMenuiserieId: '6',
+        ug: '8',
+        expected: 8
+      }
+    ])(
+      `uw pour baie vitrée $label`,
+      ({ enumTypeBaieId, enumTypeMateriauxMenuiserieId, ug = undefined, expected }) => {
+        expect(tvStore.getUw(enumTypeBaieId, enumTypeMateriauxMenuiserieId, ug)).toBeCloseTo(
+          expected,
+          2
+        );
+      }
+    );
+
+    test('pas de valeur de uw', () => {
+      const ug = tvStore.getSw('0', '0', 0);
+      expect(ug).toBeUndefined();
+    });
+  });
+
+  describe('lecture des valeurs de ujn', () => {
+    test.each([
+      {
+        label: 'ujn non extrapolé',
+        enumTypeFermetureId: '2',
+        uw: 0.8,
+        expected: '0.8'
+      },
+      {
+        label: 'ujn extrapolé',
+        enumTypeFermetureId: '2',
+        uw: 0.85,
+        expected: '0.85'
+      },
+      {
+        label: 'ujn extrapolé > à la borne maximale des valeurs connues',
+        enumTypeFermetureId: '2',
+        uw: 7,
+        expected: '5.9'
+      }
+    ])(`ujn pour baie vitrée $label`, ({ enumTypeFermetureId, uw, expected }) => {
+      expect(tvStore.getUjn(enumTypeFermetureId, uw)).toBeCloseTo(expected, 2);
+    });
+
+    test('pas de valeur de ujn', () => {
+      const ug = tvStore.getUjn('0', 0);
+      expect(ug).toBeUndefined();
+    });
+  });
+
+  describe('lecture des valeurs de deltar', () => {
+    test.each([
+      {
+        label: 'Jalousie accordéon',
+        enumTypeFermetureId: '2',
+        expected: 0.08
+      },
+      {
+        label: 'Fermeture isolée sans ajours',
+        enumTypeFermetureId: '8',
+        expected: 0.25
+      }
+    ])(`deltar pour baie vitrée $label`, ({ enumTypeFermetureId, expected }) => {
+      expect(tvStore.getDeltar(enumTypeFermetureId)).toBe(expected);
+    });
+
+    test('pas de valeur de deltar', () => {
+      const ug = tvStore.getDeltar('0');
+      expect(ug).toBeUndefined();
+    });
+  });
+
+  describe('lecture des valeurs des masques lointains non homogènes', () => {
+    test.each([
+      {
+        label: '2 secteurs lateraux',
+        tvCoeffMasqueLointainNonHomogeneId: '1',
+        expected: 0
+      },
+      {
+        label: '2 secteurs lateraux',
+        tvCoeffMasqueLointainNonHomogeneId: '4',
+        expected: 15
+      }
+    ])(`ombre pour baie vitrée $label`, ({ tvCoeffMasqueLointainNonHomogeneId, expected }) => {
+      expect(tvStore.getOmbre(tvCoeffMasqueLointainNonHomogeneId)).toBe(expected);
+    });
+
+    test('pas de valeur de masque lointain non homogène', () => {
+      const ug = tvStore.getOmbre('0');
+      expect(ug).toBeUndefined();
+    });
+  });
+
+  describe('lecture des valeurs des masques proches', () => {
+    test.each([
+      {
+        label: 'Baie en fond de balcon ou fond et flanc de loggias',
+        tvCoefMasqueProcheId: '1',
+        expected: 0.4
+      },
+      {
+        label: 'Baie sous un balcon ou auvent',
+        tvCoefMasqueProcheId: '13',
+        expected: 0.8
+      }
+    ])(`incidence masque proche pour baie vitrée $label`, ({ tvCoefMasqueProcheId, expected }) => {
+      expect(tvStore.getMasqueProche(tvCoefMasqueProcheId)).toBe(expected);
+    });
+
+    test('pas de valeur de masque proche', () => {
+      const ug = tvStore.getMasqueProche('0');
+      expect(ug).toBeUndefined();
+    });
+  });
+
+  describe('lecture des valeurs des masques lointains homogènes', () => {
+    test.each([
+      {
+        label: 'Orientation nord, hauteur 15 ≤….< 30',
+        tvCoefMasqueLointainHomogeneId: '2',
+        expected: 0.82
+      },
+      {
+        label: 'Orientation sud, hauteur 60 ≤….< 90',
+        tvCoefMasqueLointainHomogeneId: '8',
+        expected: 0.1
+      }
+    ])(
+      `incidence masque proche pour baie vitrée $label`,
+      ({ tvCoefMasqueLointainHomogeneId, expected }) => {
+        expect(tvStore.getMasqueLointainHomogene(tvCoefMasqueLointainHomogeneId)).toBe(expected);
+      }
+    );
+
+    test('pas de valeur de masque lointain homogène', () => {
+      const ug = tvStore.getMasqueLointainHomogene('0');
+      expect(ug).toBeUndefined();
+    });
+  });
+
+  test('lecture des épaisseurs disponibles pour les coefficients de transmission thermique ug', () => {
+    const ug = tvStore.getEpaisseurAvailableForUg();
+    expect(ug).toStrictEqual([0, 6, 8, 10, 12, 14, 15, 16, 18, 20]);
+  });
+});

package/features/dpe/infrastructure/pontThermiqueTv.store.js

@@ -0,0 +1,112 @@
+import { tvs as tv } from '../../../tv-v2.js';
+import { logger } from '../../../core/util/logger/log-service.js';
+import { TvStore } from './tv.store.js';
+
+/**
+ * Accès aux données des tables de valeurs pour les baies vitrées
+ */
+export class PontThermiqueTvStore extends TvStore {
+  /**
+   * Valeur du pont thermique (W/(m.K)) via tv_pont_thermique_id
+   *
+   * @param tvPontThermiqueId {number}
+   * @return {number|undefined}
+   */
+  getKForMurById(tvPontThermiqueId) {
+    const k = tv['pont_thermique'].find(
+      (v) => parseInt(v.tv_pont_thermique_id) === tvPontThermiqueId
+    )?.k;
+
+    if (!k) {
+      logger.error(`Pas de valeur forfaitaire k pour tvPontThermiqueId:${tvPontThermiqueId}`);
+      return 0;
+    }
+
+    return parseFloat(k);
+  }
+
+  /**
+   * Valeur du pont thermique (W/(m.K))
+   *
+   * @param enumTypeLiaisonId {number}
+   * @param isolationMur {string}
+   * @return {number|undefined}
+   */
+  getKForMur(enumTypeLiaisonId, isolationMur) {
+    const k = tv['pont_thermique'].find(
+      (v) =>
+        parseInt(v.enum_type_liaison_id) === enumTypeLiaisonId &&
+        v.isolation_mur.toLowerCase() === isolationMur.toLowerCase()
+    )?.k;
+
+    if (!k) {
+      logger.error(`Pas de valeur forfaitaire k pour isolationMur:${isolationMur}`);
+      return;
+    }
+
+    return parseFloat(k);
+  }
+
+  /**
+   * Valeur du pont thermique (W/(m.K))
+   *
+   * @param enumTypeLiaisonId {number}
+   * @param isolationMur {string}
+   * @param isolationPlancher {string}
+   * @return {number|undefined}
+   */
+  getKForPlancher(enumTypeLiaisonId, isolationMur, isolationPlancher) {
+    const k = tv['pont_thermique'].find(
+      (v) =>
+        parseInt(v.enum_type_liaison_id) === enumTypeLiaisonId &&
+        v.isolation_mur.toLowerCase() === isolationMur.toLowerCase() &&
+        v.isolation_plancher.toLowerCase() === isolationPlancher.toLowerCase()
+    )?.k;
+
+    if (!k) {
+      logger.error(
+        `Pas de valeur forfaitaire k pour isolationMur:${isolationMur}, isolationPlancher:${isolationPlancher}`
+      );
+      return;
+    }
+
+    return parseFloat(k);
+  }
+
+  /**
+   * Valeur du pont thermique (W/(m.K))
+   *
+   * @param enumTypeLiaisonId {number}
+   * @param isolationMur {string}
+   * @param typePose {number}
+   * @param presenceRetourIsolation {number}
+   * @param largeurDormant {number}
+   * @return {number|undefined}
+   */
+  getKForMenuiserie(
+    enumTypeLiaisonId,
+    isolationMur,
+    typePose,
+    presenceRetourIsolation,
+    largeurDormant
+  ) {
+    const k = tv['pont_thermique'].find(
+      (v) =>
+        parseInt(v.enum_type_liaison_id) === enumTypeLiaisonId &&
+        v.isolation_mur.toLowerCase() === isolationMur.toLowerCase() &&
+        (!v.enum_type_pose_id || parseInt(v.enum_type_pose_id) === typePose) &&
+        (!v.presence_retour_isolation ||
+          parseInt(v.presence_retour_isolation) === presenceRetourIsolation) &&
+        (!v.largeur_dormant || !largeurDormant || parseInt(v.largeur_dormant) === largeurDormant)
+    )?.k;
+
+    if (!k) {
+      logger.error(
+        `Pas de valeur forfaitaire k pour isolationMur:${isolationMur}, typePose:${typePose}, presenceRetourIsolation:${presenceRetourIsolation}, largeurDormant:${largeurDormant}`
+      );
+      return;
+    }
+
+    return parseFloat(k);
+  }
+}

package/features/dpe/infrastructure/pontThermiqueTv.store.spec.js

@@ -0,0 +1,134 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import { PontThermiqueTvStore } from './pontThermiqueTv.store.js';
+
+/** @type {PontThermiqueTvStore} **/
+let tvStore;
+
+describe('Lecture des tables de valeurs', () => {
+  beforeEach(() => {
+    tvStore = new PontThermiqueTvStore();
+  });
+
+  describe('lecture des valeurs de k', () => {
+    test.each([
+      {
+        label: 'tv_pont_thermique_id existant',
+        tvPontThermiqueId: 1,
+        expected: 0.39
+      },
+      {
+        label: 'tv_pont_thermique_id inexistant',
+        tvPontThermiqueId: 0,
+        expected: 0
+      }
+    ])(
+      `k via tv_pont_thermique_id pour un pont thermique avec $label`,
+      ({ tvPontThermiqueId, expected }) => {
+        expect(tvStore.getKForMurById(tvPontThermiqueId)).toBe(expected);
+      }
+    );
+
+    test.each([
+      {
+        label: 'enum_type_liaison_id et isolation_mur qui correspondent',
+        enumTypeLiaisonId: 1,
+        isolationMur: 'Non isolé',
+        expected: 0.39
+      },
+      {
+        label: 'enum_type_liaison_id et isolation_mur qui ne correspondent à aucune entrée',
+        enumTypeLiaisonId: 0,
+        isolationMur: '',
+        expected: undefined
+      }
+    ])(`k pour un pont thermique via $label`, ({ enumTypeLiaisonId, isolationMur, expected }) => {
+      expect(tvStore.getKForMur(enumTypeLiaisonId, isolationMur)).toBe(expected);
+    });
+
+    test.each([
+      {
+        label: 'enum_type_liaison_id, isolation_mur et isolationPlancher qui correspondent',
+        enumTypeLiaisonId: 1,
+        isolationMur: 'Non isolé',
+        isolationPlancher: 'iti',
+        expected: 0.47
+      },
+      {
+        label: 'enum_type_liaison_id et isolation_mur qui ne correspondent à aucune entrée',
+        enumTypeLiaisonId: 0,
+        isolationMur: 'Non isolé',
+        isolationPlancher: 'iti',
+        expected: undefined
+      }
+    ])(
+      `k pour un pont thermique via $label`,
+      ({ enumTypeLiaisonId, isolationMur, isolationPlancher, expected }) => {
+        expect(tvStore.getKForPlancher(enumTypeLiaisonId, isolationMur, isolationPlancher)).toBe(
+          expected
+        );
+      }
+    );
+  });
+
+  test.each([
+    {
+      label:
+        'enum_type_liaison_id, isolation_mur, typePose, largeurDormant, sans largeurDormant et presenceRetourIsolation qui correspondent',
+      enumTypeLiaisonId: 5,
+      isolationMur: 'Non isolé',
+      typePose: 1,
+      presenceRetourIsolation: undefined,
+      largeurDormant: undefined,
+      expected: 0.43
+    },
+    {
+      label:
+        'enum_type_liaison_id, isolation_mur, typePose, largeurDormant, sans presenceRetourIsolation qui correspondent',
+      enumTypeLiaisonId: 5,
+      isolationMur: 'Non isolé',
+      typePose: 1,
+      presenceRetourIsolation: undefined,
+      largeurDormant: 5,
+      expected: 0.43
+    },
+    {
+      label:
+        'enum_type_liaison_id, isolation_mur, typePose, largeurDormant, presenceRetourIsolation qui correspondent',
+      enumTypeLiaisonId: 5,
+      isolationMur: 'iti',
+      typePose: 3,
+      presenceRetourIsolation: 1,
+      largeurDormant: 10,
+      expected: 0.13
+    },
+    {
+      label: 'enum_type_liaison_id et isolation_mur qui ne correspondent à aucune entrée',
+      enumTypeLiaisonId: 5,
+      isolationMur: 'undefined',
+      typePose: 1,
+      presenceRetourIsolation: '1',
+      largeurDormant: 5,
+      expected: undefined
+    }
+  ])(
+    `k pour un pont thermique via $label`,
+    ({
+      enumTypeLiaisonId,
+      isolationMur,
+      typePose,
+      presenceRetourIsolation,
+      largeurDormant,
+      expected
+    }) => {
+      expect(
+        tvStore.getKForMenuiserie(
+          enumTypeLiaisonId,
+          isolationMur,
+          typePose,
+          presenceRetourIsolation,
+          largeurDormant
+        )
+      ).toBe(expected);
+    }
+  );
+});

package/features/dpe/infrastructure/tv.store.js

@@ -301,39 +301,6 @@ export class TvStore {
     return parseFloat(uph);
   }
 
-  /**
-   * Coefficient de transmission thermique du plancher bas
-   * @param enumTypeVitrageId {string}
-   * @param enumTypeGazLameId {string|undefined}
-   * @param enumInclinaisonVitrageId {string|undefined}
-   * @param vitrageVir {boolean|undefined}
-   * @param epaisseurLame {number|undefined}
-   * @return {number|undefined}
-   */
-  getUg(enumTypeVitrageId, enumTypeGazLameId, enumInclinaisonVitrageId, vitrageVir, epaisseurLame) {
-    const ug = tv['ug'].find(
-      (v) =>
-        v.enum_type_vitrage_id.split('|').includes(enumTypeVitrageId) &&
-        (!enumInclinaisonVitrageId ||
-          v.enum_inclinaison_vitrage_id.split('|').includes(enumInclinaisonVitrageId)) &&
-        (!enumTypeGazLameId || v.enum_type_gaz_lame_id.split('|').includes(enumTypeGazLameId)) &&
-        (!epaisseurLame || parseFloat(v.epaisseur_lame) === epaisseurLame) &&
-        (!vitrageVir || vitrageVir === (parseInt(v.vitrage_vir) === 1))
-    )?.ug;
-
-    if (!ug) {
-      logger.error(
-        `Pas de valeur forfaitaire ug pour enumTypeVitrageId:${enumTypeVitrageId}, enumTypeGazLameId:${enumTypeGazLameId}, enumInclinaisonVitrageId:${enumInclinaisonVitrageId}, vitrageVir:${vitrageVir}, epaisseurLame:${epaisseurLame}`
-      );
-      return;
-    }
-
-    logger.debug(
-      `ug pour enumTypeVitrageId:${enumTypeVitrageId}, enumTypeGazLameId:${enumTypeGazLameId}, enumInclinaisonVitrageId:${enumInclinaisonVitrageId}, vitrageVir:${vitrageVir}, epaisseurLame:${epaisseurLame} = ${ug}`
-    );
-    return parseFloat(ug);
-  }
-
   /**
    * Débits de la ventilation
    * @param typeVentilation {number}