@open3cl/engine 1.0.7 → 1.0.8

package/features/dpe/domain/models/baie-vitree.model.ts

@@ -28,7 +28,7 @@ export interface BaieVitreeDE extends DE {
   enum_type_materiaux_menuiserie_id?: string; // ENUM type_materiaux_menuiserie
   enum_type_baie_id?: string; // ENUM type_baie
   uw_saisi?: number;
-  double_fenetre?: boolean;
+  double_fenetre?: number;
   uw_1?: number;
   sw_1?: number;
   uw_2?: number;
@@ -45,12 +45,10 @@ export interface BaieVitreeDE extends DE {
   sw_saisi?: number;
   enum_type_pose_id?: string; // ENUM type_pose
   enum_orientation_id?: string;
-  tv_coef_masque_proche_id?: string;
-  tv_coef_masque_lointain_homogene_id?: string;
+  tv_coef_masque_proche_id?: number;
+  tv_coef_masque_lointain_homogene_id?: number;
   masque_lointain_non_homogene_collection: {
-    masque_lointain_non_homogene: {
-      tv_coef_masque_lointain_non_homogene_id?: string; // TV
-    };
+    masque_lointain_non_homogene: MasqueLointainNonHomogene;
   }[];
 }
 
@@ -93,3 +91,7 @@ export interface BaieVitreeDoubleFenetreDI {
   uw: number;
   sw: number;
 }
+
+export interface MasqueLointainNonHomogene {
+  tv_coef_masque_lointain_non_homogene_id?: string;
+}

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

@@ -0,0 +1,292 @@
+import { tvs as tv } from '../../../tv-v2.js';
+import { getRange } from '../../../utils.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 BaieVitreeTvStore extends TvStore {
+  /**
+   * Coefficient de transmission thermique du vitrage (W/(m².K))
+   *
+   * @param enumTypeVitrageId {string}
+   * @param enumTypeGazLameId {string|undefined}
+   * @param enumInclinaisonVitrageId {string|undefined}
+   * @param vitrageVir {number|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) &&
+        (!enumTypeGazLameId || v.enum_type_gaz_lame_id?.split('|').includes(enumTypeGazLameId)) &&
+        (!enumInclinaisonVitrageId ||
+          v.enum_inclinaison_vitrage_id?.split('|').includes(enumInclinaisonVitrageId)) &&
+        (!vitrageVir || parseInt(vitrageVir) === parseInt(v.vitrage_vir)) &&
+        (!epaisseurLame || parseFloat(v.epaisseur_lame) === epaisseurLame)
+    )?.ug;
+
+    if (!ug) {
+      logger.error(
+        `Pas de valeur forfaitaire ug pour enumTypeVitrageId:${enumTypeVitrageId}, enumTypeGazLameId:${enumTypeGazLameId}, enumInclinaisonVitrageId:${enumInclinaisonVitrageId}, vitrageVir:${vitrageVir}, epaisseurLame:${epaisseurLame}`
+      );
+      return;
+    }
+
+    return parseFloat(ug);
+  }
+
+  /**
+   * Épaisseurs disponibles pour les coefficients de transmission thermique du vitrage (W/(m².K))
+   *
+   * @return {number[]}
+   */
+  getEpaisseurAvailableForUg() {
+    return [
+      ...new Set(tv['ug'].map((value) => parseInt(value.epaisseur_lame) || 0).sort((a, b) => a - b))
+    ];
+  }
+
+  /**
+   * Proportion d’énergie solaire incidente qui pénètre dans le logement par la paroi vitrée
+   *
+   * @param enumTypeVitrageId {string}
+   * @param enumTypeBaieId {string}
+   * @param enumTypeMateriauxMenuiserieId {string}
+   * @param vitrageVir {number|undefined}
+   * @param enumTypePoseId {string|undefined}
+   * @return {number|undefined}
+   */
+  getSw(
+    enumTypeVitrageId,
+    enumTypeBaieId,
+    enumTypeMateriauxMenuiserieId,
+    vitrageVir,
+    enumTypePoseId
+  ) {
+    const sw = tv['sw'].find(
+      (v) =>
+        (!v.enum_type_vitrage_id ||
+          v.enum_type_vitrage_id.split('|').includes(enumTypeVitrageId)) &&
+        v.enum_type_baie_id.split('|').includes(enumTypeBaieId) &&
+        v.enum_type_materiaux_menuiserie_id.split('|').includes(enumTypeMateriauxMenuiserieId) &&
+        (!vitrageVir || parseInt(vitrageVir) === parseInt(v.vitrage_vir)) &&
+        (!enumTypePoseId || v.enum_type_pose_id.split('|').includes(enumTypePoseId))
+    )?.sw;
+
+    if (!sw) {
+      logger.error(
+        `Pas de valeur forfaitaire sw pour enumTypeVitrageId:${enumTypeVitrageId}, enumTypeBaieId:${enumTypeBaieId}, enumTypeMateriauxMenuiserieId:${enumTypeMateriauxMenuiserieId}, vitrageVir:${vitrageVir}, enumTypePoseId:${enumTypePoseId}`
+      );
+      return;
+    }
+
+    return parseFloat(sw);
+  }
+
+  /**
+   * Coefficient de transmission thermique des fenêtres
+   *
+   * @param enumTypeVitrageId {string}
+   * @param enumTypeBaieId {string}
+   * @param enumTypeMateriauxMenuiserieId {string}
+   * @param ug {number|undefined}
+   * @return {number|undefined}
+   */
+  getUw(enumTypeBaieId, enumTypeMateriauxMenuiserieId, ug) {
+    let uw;
+
+    /**
+     * Pas de notion de ug pour les parois polycarbonate ou verre
+     * enum_type_baie_id
+     * 1 - paroi en brique de verre pleine
+     * 2 - paroi en brique de verre creuse
+     * 3 - paroi en polycarbonnate
+     */
+    if (['1', '2', '3'].includes(enumTypeBaieId)) {
+      uw = tv['uw'].find((v) => v.enum_type_baie_id.split('|').includes(enumTypeBaieId))?.uw;
+    } else {
+      /**
+       * 3.3.2 Coefficients Uw des fenêtres / portes-fenêtres
+       * Les Uw associés à des Ug non présents dans les tableaux peuvent être obtenus par interpolation ou
+       * extrapolation avec les deux Ug tabulés les plus proches.
+       */
+      const ugValues =
+        tv['uw'].filter(
+          (v) =>
+            v.enum_type_baie_id.split('|').includes(enumTypeBaieId) &&
+            v.enum_type_materiaux_menuiserie_id.split('|').includes(enumTypeMateriauxMenuiserieId)
+        ) || [];
+
+      let ug1, ug2;
+
+      if (ugValues.length) {
+        [ug1, ug2] = getRange(ug, [...new Set(ugValues.map((value) => value.ug).sort())]);
+
+        const uw1 = ugValues.find((value) => value.ug === ug1)?.uw || 0;
+        const uw2 = ugValues.find((value) => value.ug === ug2)?.uw || 0;
+
+        const delta_uw = Number(uw2) - Number(uw1);
+        const delta_ug = ug2 - ug1 || 0;
+
+        if (delta_ug === 0) {
+          uw = Number(uw1);
+        } else {
+          // Interpolation linéaire si upb n'est pas une valeur connue
+          uw = Number(uw1) + (delta_uw * (ug - ug1)) / delta_ug;
+        }
+      }
+    }
+
+    if (!uw) {
+      logger.error(
+        `Pas de valeur forfaitaire uw pour enumTypeBaieId:${enumTypeBaieId}, enumTypeMateriauxMenuiserieId:${enumTypeMateriauxMenuiserieId}, ug:${ug}`
+      );
+      return;
+    }
+
+    return parseFloat(uw);
+  }
+
+  /**
+   * La présence de volets aux fenêtres et portes-fenêtres leur apporte un supplément d’isolation avec une résistance
+   * additionnelle ΔR
+   *
+   * @param enumTypeFermetureId {string}
+   * @return {number|undefined}
+   */
+  getDeltar(enumTypeFermetureId) {
+    const deltar = tv['deltar'].find((v) =>
+      v.enum_type_fermeture_id.split('|').includes(enumTypeFermetureId)
+    )?.deltar;
+
+    if (!deltar) {
+      logger.error(
+        `Pas de valeur forfaitaire deltar pour enumTypeFermetureId:${enumTypeFermetureId}`
+      );
+      return;
+    }
+
+    return parseFloat(deltar);
+  }
+
+  /**
+   * La présence de volets aux fenêtres et portes-fenêtres leur apporte un supplément d’isolation avec une résistance
+   * additionnelle ΔR
+   *
+   * @param enumTypeFermetureId {string}
+   * @param uw {number}
+   *
+   * @return {number|undefined}
+   */
+  getUjn(enumTypeFermetureId, uw) {
+    let ujn;
+    /**
+     * 3.3.3 Coefficients Ujn des fenêtres/portes-fenêtres
+     * Dans la suite, les Ujn associés à des Uw non présents dans les tableaux peuvent être obtenus par interpolation ou
+     * extrapolation avec les deux Uw tabulés les plus proches.
+     */
+    const deltar = this.getDeltar(enumTypeFermetureId);
+    const uwValues =
+      tv['ujn'].filter((v) => Number(v.deltar).toPrecision(2) === Number(deltar).toPrecision(2)) ||
+      [];
+
+    let uw1, uw2;
+
+    if (uwValues.length) {
+      [uw1, uw2] = getRange(uw, [...new Set(uwValues.map((value) => value.uw).sort())]);
+
+      const ujn1 =
+        uwValues.find((value) => Number(value.uw).toPrecision(2) === Number(uw1).toPrecision(2))
+          ?.ujn || 0;
+      const ujn2 =
+        uwValues.find((value) => Number(value.uw).toPrecision(2) === Number(uw2).toPrecision(2))
+          ?.ujn || 0;
+
+      const delta_ujn = Number(ujn2) - Number(ujn1);
+      const delta_uw = uw2 - uw1 || 0;
+
+      if (delta_uw === 0) {
+        ujn = Number(ujn1);
+      } else {
+        // Interpolation linéaire si uw n'est pas une valeur connue
+        ujn = Number(ujn1) + (delta_ujn * (uw - uw1)) / delta_uw;
+      }
+
+      if (!ujn) {
+        logger.error(
+          `Pas de valeur forfaitaire ujn pour enumTypeFermetureId:${enumTypeFermetureId}, uw:${uw}`
+        );
+        return;
+      }
+
+      return parseFloat(ujn);
+    }
+  }
+
+  /**
+   * Calcul de l’ombrage créé par un obstacle sur une paroi
+   *
+   * @param tvCoeffMasqueLointainNonHomogeneId {number}
+   * @return {number|undefined}
+   */
+  getOmbre(tvCoeffMasqueLointainNonHomogeneId) {
+    const ombre = tv['coef_masque_lointain_non_homoge'].find(
+      (v) =>
+        parseInt(v.tv_coef_masque_lointain_non_homogene_id) ===
+        parseInt(tvCoeffMasqueLointainNonHomogeneId)
+    )?.omb;
+
+    if (!ombre) {
+      logger.error(
+        `Pas de valeur forfaitaire ombre pour tvCoeffMasqueLointainNonHomogeneId:${tvCoeffMasqueLointainNonHomogeneId}`
+      );
+      return;
+    }
+
+    return parseFloat(ombre);
+  }
+
+  /**
+   * Calcul de l'incidence d'un masque proche sur une paroi
+   *
+   * @param tvCoefMasqueProcheId {number}
+   * @return {number|undefined}
+   */
+  getMasqueProche(tvCoefMasqueProcheId) {
+    const fe1 = tv['coef_masque_proche'].find(
+      (v) => parseInt(v.tv_coef_masque_proche_id) === parseInt(tvCoefMasqueProcheId)
+    )?.fe1;
+
+    if (!fe1) {
+      logger.error(`Pas de valeur fe1 pour tvCoefMasqueProcheId:${tvCoefMasqueProcheId}`);
+      return;
+    }
+
+    return parseFloat(fe1);
+  }
+
+  /**
+   * Calcul de l'incidence d'un masque lointain homogène sur une paroi
+   *
+   * @param tvCoefMasqueLointainHomogeneId {number}
+   * @return {number|undefined}
+   */
+  getMasqueLointainHomogene(tvCoefMasqueLointainHomogeneId) {
+    const fe2 = tv['coef_masque_lointain_homogene'].find(
+      (v) =>
+        parseInt(v.tv_coef_masque_lointain_homogene_id) === parseInt(tvCoefMasqueLointainHomogeneId)
+    )?.fe2;
+
+    if (!fe2) {
+      logger.error(
+        `Pas de valeur fe2 pour tvCoefMasqueLointainHomogeneId:${tvCoefMasqueLointainHomogeneId}`
+      );
+      return;
+    }
+
+    return parseFloat(fe2);
+  }
+}

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]);
+  });
+});