@open3cl/engine 1.0.7 → 1.0.9

package/features/engine/domain/enveloppe/plancher_bas/deperdition-plancher-bas.service.js

@@ -166,4 +166,50 @@ export class DeperditionPlancherBasService extends DeperditionService {
 
     return Math.round(parseFloat(upbFinal) * PRECISION) / PRECISION;
   }
+
+  /**
+   * Retourner le type d'isolation du plancher
+   * Si isolation inconnue :
+   *  - Les planchers sur terre-plein sont considérés non isolés avant 2001 et isolés par l’extérieur (en sous-face) à partir de 2001
+   *  - Les autres planchers sont considérés isolés par l’extérieur
+   *
+   * @param ctx {Contexte}
+   * @param plancherBasDE {PlancherBasDE}
+   * @return {number}
+   */
+  typeIsolation(ctx, plancherBasDE) {
+    const typeIsolation = parseInt(plancherBasDE.enum_type_isolation_id);
+
+    // Type d'isolation inconnu
+    if (typeIsolation === 1) {
+      const typeAdjacence = parseInt(plancherBasDE.enum_type_adjacence_id);
+      const periodeIsolation =
+        parseInt(plancherBasDE.enum_periode_isolation_id) ||
+        parseInt(ctx.enumPeriodeConstructionId);
+
+      // Plancher sur terre-plein
+      if (typeAdjacence === 5) {
+        // Année isolation / construction < 2001
+        if (periodeIsolation < 7) {
+          // Non isolé
+          return 2;
+        } else {
+          // Isolation ITE
+          return 4;
+        }
+      } else {
+        // Année isolation / construction < 1975
+        if (periodeIsolation < 3) {
+          // Non isolé
+          return 2;
+        } else {
+          // Isolation ITE
+          return 4;
+        }
+      }
+    }
+
+    // Isolation ITE si "isolé mais type d'isolation inconnu"
+    return typeIsolation === 9 ? 4 : typeIsolation;
+  }
 }

package/features/engine/domain/enveloppe/plancher_bas/deperdition-plancher-bas.service.spec.js

@@ -170,6 +170,91 @@ describe('Calcul de déperdition des planchers bas', () => {
     });
   });
 
+  test.each([
+    {
+      label:
+        'plancher bas avec isolation inconnue, adjacence terre-plein et période isolation 1974',
+      enumTypeIsolationId: 1,
+      enumTypeAdjacenceId: 5,
+      enumPeriodIsolationId: 1,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 2
+    },
+    {
+      label:
+        'plancher bas avec isolation inconnue, adjacence terre-plein et période construction 2000',
+      enumTypeIsolationId: 1,
+      enumTypeAdjacenceId: 5,
+      enumPeriodIsolationId: undefined,
+      enumPeriodeConstructionId: 6,
+      typeIsolationExpected: 2
+    },
+    {
+      label:
+        'plancher bas avec isolation inconnue, adjacence terre-plein et période isolation 2001',
+      enumTypeIsolationId: 1,
+      enumPeriodIsolationId: 7,
+      enumTypeAdjacenceId: 5,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 4
+    },
+    {
+      label: 'plancher bas avec isolation inconnue, adjacence garage et période isolation 1974',
+      enumTypeIsolationId: 1,
+      enumPeriodIsolationId: 2,
+      enumTypeAdjacenceId: 8,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 2
+    },
+    {
+      label: 'plancher bas avec isolation inconnue, adjacence garage et période isolation 1975',
+      enumTypeIsolationId: 1,
+      enumPeriodIsolationId: 3,
+      enumTypeAdjacenceId: 8,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 4
+    },
+    {
+      label: 'plancher bas avec isolation de type "isolé mais type d\'isolation inconnu"',
+      enumTypeIsolationId: 9,
+      enumPeriodIsolationId: 1,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 4
+    },
+    {
+      label: 'plancher bas avec isolation iti+ite',
+      enumTypeIsolationId: 6,
+      enumPeriodIsolationId: 1,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 6
+    }
+  ])(
+    "Récupération du type d'isolation pour $label",
+    ({
+      enumTypeIsolationId,
+      enumPeriodIsolationId = undefined,
+      enumTypeAdjacenceId = undefined,
+      enumPeriodeConstructionId = undefined,
+      typeIsolationExpected
+    }) => {
+      /**
+       * @type {PlancherBasDE}
+       */
+      let plancherBasDE = {
+        enum_type_isolation_id: enumTypeIsolationId,
+        enum_type_adjacence_id: enumTypeAdjacenceId,
+        enum_periode_isolation_id: enumPeriodIsolationId
+      };
+
+      /**
+       * @type {Contexte}
+       */
+      const ctx = { enumPeriodeConstructionId };
+
+      expect(service.typeIsolation(ctx, plancherBasDE)).toBe(typeIsolationExpected);
+    }
+  );
+
   describe("Test d'intégration de plancher bas", () => {
     test.each(corpus)('vérification des DI des pb pour dpe %s', (ademeId) => {
       /**

package/features/engine/domain/enveloppe/plancher_haut/deperdition-plancher-haut.service.js

@@ -133,4 +133,37 @@ export class DeperditionPlancherHautService extends DeperditionService {
         return 'combles';
     }
   }
+
+  /**
+   * Retourner le type d'isolation du plancher haut
+   * Si isolation inconnue :
+   *  - Pour les bâtiments d’avant 1975, la paroi est considérée comme non isolée
+   *  - Pour les bâtiments construits à partir de 1975, les plafonds sont considérés isolés par l’extérieur
+   *
+   * @param ctx {Contexte}
+   * @param plancherHautDE {PlancherHautDE}
+   * @return {number}
+   */
+  typeIsolation(ctx, plancherHautDE) {
+    const typeIsolation = parseInt(plancherHautDE.enum_type_isolation_id);
+
+    // Type d'isolation inconnu
+    if (typeIsolation === 1) {
+      const periodeIsolation =
+        parseInt(plancherHautDE.enum_periode_isolation_id) ||
+        parseInt(ctx.enumPeriodeConstructionId);
+
+      // Année isolation / construction < 1975
+      if (periodeIsolation < 3) {
+        // Non isolé
+        return 2;
+      } else {
+        // Isolation ITE
+        return 4;
+      }
+    }
+
+    // Isolation ITE si "isolé mais type d'isolation inconnu"
+    return typeIsolation === 9 ? 4 : typeIsolation;
+  }
 }

package/features/engine/domain/enveloppe/plancher_haut/deperdition-plancher-haut.service.spec.js

@@ -181,6 +181,67 @@ describe('Calcul de déperdition des planchers haut', () => {
     });
   });
 
+  test.each([
+    {
+      label: 'plafond avec isolation inconnue et période isolation 1974',
+      enumTypeIsolationId: 1,
+      enumPeriodIsolationId: 1,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 2
+    },
+    {
+      label: 'plafond avec isolation inconnue et période construction 1974',
+      enumTypeIsolationId: 1,
+      enumPeriodIsolationId: undefined,
+      enumPeriodeConstructionId: 1,
+      typeIsolationExpected: 2
+    },
+    {
+      label: 'plafond avec isolation inconnue et période isolation 1975',
+      enumTypeIsolationId: 1,
+      enumPeriodIsolationId: 3,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 4
+    },
+    {
+      label: 'plafond avec isolation de type "isolé mais type d\'isolation inconnu"',
+      enumTypeIsolationId: 9,
+      enumPeriodIsolationId: 1,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 4
+    },
+    {
+      label: 'plafond avec isolation iti+ite',
+      enumTypeIsolationId: 6,
+      enumPeriodIsolationId: 1,
+      enumPeriodeConstructionId: undefined,
+      typeIsolationExpected: 6
+    }
+  ])(
+    "Récupération du type d'isolation pour $label",
+    ({
+      enumTypeIsolationId,
+      enumPeriodIsolationId = undefined,
+      enumPeriodeConstructionId = undefined,
+      typeIsolationExpected
+    }) => {
+      /**
+       * @type {PlancherHautDE}
+       */
+      let plancherHautDE = {
+        enum_type_isolation_id: enumTypeIsolationId,
+        enum_periode_isolation_id: enumPeriodIsolationId
+      };
+
+      /**
+       * @type {Contexte}
+       */
+      const ctx = { enumPeriodeConstructionId };
+
+      expect(service.typeIsolation(ctx, plancherHautDE)).toBe(typeIsolationExpected);
+    }
+  );
+
   describe("Test d'intégration de plancher haut", () => {
     test.each(corpus)('vérification des DI des ph pour dpe %s', (ademeId) => {
       /**

package/features/engine/domain/enveloppe/pont_thermique/deperdition-pont-thermique.service.js

@@ -0,0 +1,439 @@
+import { inject } from 'dioma';
+import { DeperditionService } from '../deperdition.service.js';
+import { logger } from '../../../../../core/util/logger/log-service.js';
+import { compareReferences } from '../../../../../utils.js';
+import { DeperditionMurService } from '../mur/deperdition-mur.service.js';
+import { PontThermiqueTvStore } from '../../../../dpe/infrastructure/pontThermiqueTv.store.js';
+import enums from '../../../../../enums.js';
+import { DeperditionPlancherHautService } from '../plancher_haut/deperdition-plancher-haut.service.js';
+import { DeperditionPlancherBasService } from '../plancher_bas/deperdition-plancher-bas.service.js';
+
+/**
+ * Calcul des déperditions des ponts thermiques
+ * Chapitre 3.4 Calcul des déperditions par les ponts thermiques
+ *
+ * Méthode de calcul 3CL-DPE 2021
+ * Octobre 2021
+ * @see consolide_anne…arrete_du_31_03_2021_relatif_aux_methodes_et_procedures_applicables.pdf
+ *
+ * Si le coefficient U des portes est connu et justifié, le saisir directement. Sinon, prendre les valeurs tabulées
+ */
+export class DeperditionPontThermiqueService extends DeperditionService {
+  /**
+   * @type {DeperditionMurService}
+   */
+  #deperditionMurService;
+
+  /**
+   * @type {DeperditionPlancherHautService}
+   */
+  #deperditionPlancherHautService;
+
+  /**
+   * @type {DeperditionPlancherBasService}
+   */
+  #deperditionPlancherBasService;
+
+  /**
+   * @param tvStore {PontThermiqueTvStore}
+   * @param deperditionMurService {DeperditionMurService}
+   * @param deperditionPlancherHautService {DeperditionPlancherHautService}
+   * @param deperditionPlancherBasService {DeperditionPlancherBasService}
+   */
+  constructor(
+    tvStore = inject(PontThermiqueTvStore),
+    deperditionMurService = inject(DeperditionMurService),
+    deperditionPlancherHautService = inject(DeperditionPlancherHautService),
+    deperditionPlancherBasService = inject(DeperditionPlancherBasService)
+  ) {
+    super(tvStore);
+    this.#deperditionMurService = deperditionMurService;
+    this.#deperditionPlancherHautService = deperditionPlancherHautService;
+    this.#deperditionPlancherBasService = deperditionPlancherBasService;
+  }
+
+  /**
+   * @param ctx {Contexte}
+   * @param enveloppe {Enveloppe}
+   * @param pontThermiqueDE {PontThermiqueDE}
+   * @return {PontThermiqueDI}
+   */
+  execute(ctx, enveloppe, pontThermiqueDE) {
+    /** @type {PontThermiqueDI} */
+    const di = {
+      k: undefined
+    };
+
+    if ([2, 3].includes(parseInt(pontThermiqueDE.enum_methode_saisie_pont_thermique_id))) {
+      // valeur justifiée saisie à partir des documents justificatifs autorisés
+      // saisie direct k depuis rset/rsee( etude rt2012/re2020)
+      di.k = pontThermiqueDE.k_saisi;
+
+      if (!di.k) {
+        logger.error(`
+          Aucune valeur de k_saisi pour le pont thermique '${pontThermiqueDE.reference}' alors que la donnée est saisie
+        `);
+      }
+    } else {
+      // valeur forfaitaire
+      di.k = this.k(ctx, pontThermiqueDE, enveloppe);
+    }
+
+    if (di.k === undefined) {
+      logger.error(`
+        Aucune valeur k n'a été trouvée pour le pont thermique '${pontThermiqueDE.description}'.
+      `);
+      di.k = this.defaultValue(pontThermiqueDE);
+    }
+
+    return di;
+  }
+
+  /**
+   * Coefficient de transmission thermique du vitrage (W/(m².K))
+   *
+   * @param ctx {Contexte}
+   * @param pontThermiqueDE {PontThermiqueDE}
+   * @param enveloppe {Enveloppe}
+   * @return {number|undefined}
+   */
+  k(ctx, pontThermiqueDE, enveloppe) {
+    if (!pontThermiqueDE.reference_1) {
+      logger.error(`
+        Impossible de trouver un mur ayant pour référence '${pontThermiqueDE.reference_1}' ou '${pontThermiqueDE.reference_2}'.
+      `);
+      return this.defaultValue(pontThermiqueDE);
+    }
+
+    const typeLiaison = parseInt(pontThermiqueDE.enum_type_liaison_id);
+
+    /**
+     * @type {MurDE|undefined}
+     */
+    const mur = this.mur(pontThermiqueDE, enveloppe);
+
+    if (mur && !this.murHasPontThermique(mur, typeLiaison)) {
+      return 0;
+    }
+
+    const isolationMur = this.isolationMur(ctx, mur);
+
+    switch (typeLiaison) {
+      // 'plancher bas / mur'
+      case 1: {
+        return this.pontThermiquePlancherBasMur(ctx, pontThermiqueDE, enveloppe, isolationMur);
+      }
+      // 'plancher haut lourd / mur'
+      case 3: {
+        return this.pontThermiquePlancherHautMur(ctx, pontThermiqueDE, enveloppe, isolationMur);
+      }
+      // 'menuiserie / mur'
+      case 5: {
+        return this.pontThermiqueMenuiserieMur(pontThermiqueDE, enveloppe, isolationMur);
+      }
+      //'plancher intermédiaire lourd / mur'
+      // 'refend / mur'
+      case 2:
+      case 4: {
+        return this.tvStore.getKForMur(typeLiaison, enums.type_isolation[isolationMur]);
+      }
+    }
+  }
+
+  /**
+   * Calcul de l'isolation du mur
+   *
+   * @param ctx {Contexte}
+   * @param murDE {MurDE}
+   * @return {number}
+   */
+  isolationMur(ctx, murDE) {
+    if (murDE) {
+      return this.#deperditionMurService.typeIsolation(ctx, murDE);
+    } else {
+      // Isolation ITI si le mur n'est pas défini
+      return 3;
+    }
+  }
+
+  /**
+   * Calcul du pont thermique 'plancher bas / mur'
+   *
+   * @param ctx {Contexte}
+   * @param pontThermiqueDE {PontThermiqueDE}
+   * @param enveloppe {Enveloppe}
+   * @param isolationMur {number}
+   * @return {number|undefined}
+   */
+  pontThermiquePlancherBasMur(ctx, pontThermiqueDE, enveloppe, isolationMur) {
+    const plancherBasDE = this.plancherBas(pontThermiqueDE, enveloppe);
+
+    if (!plancherBasDE) {
+      logger.error(`
+        Impossible de trouver un plancher bas ayant pour référence '${pontThermiqueDE.reference_1}' ou '${pontThermiqueDE.reference_2}'.
+      `);
+      return this.defaultValue(pontThermiqueDE);
+    }
+
+    if (!this.plancherBasHasPontThermique(plancherBasDE)) {
+      return 0;
+    }
+
+    const isolationPlancher = this.#deperditionPlancherBasService.typeIsolation(ctx, plancherBasDE);
+    return this.tvStore.getKForPlancher(
+      1,
+      enums.type_isolation[isolationMur],
+      enums.type_isolation[isolationPlancher]
+    );
+  }
+
+  /**
+   Calcul du pont thermique 'plancher haut lourd / mur'
+   *
+   * @param ctx {Contexte}
+   * @param pontThermiqueDE {PontThermiqueDE}
+   * @param enveloppe {Enveloppe}
+   * @param isolationMur {number}
+   * @return {number|undefined}
+   */
+  pontThermiquePlancherHautMur(ctx, pontThermiqueDE, enveloppe, isolationMur) {
+    const plancherHautDE = this.plancherHaut(pontThermiqueDE, enveloppe);
+
+    if (!plancherHautDE) {
+      logger.error(`
+        Impossible de trouver un plancher haut ayant pour référence '${pontThermiqueDE.reference_1}' ou '${pontThermiqueDE.reference_2}'.
+      `);
+      return this.defaultValue(pontThermiqueDE);
+    }
+
+    if (!this.plancherHautHasPontThermique(plancherHautDE)) {
+      return 0;
+    }
+
+    const isolationPlancher = this.#deperditionPlancherHautService.typeIsolation(
+      ctx,
+      plancherHautDE
+    );
+    return this.tvStore.getKForPlancher(
+      3,
+      enums.type_isolation[isolationMur],
+      enums.type_isolation[isolationPlancher]
+    );
+  }
+
+  /**
+   Calcul du pont thermique 'menuiserie / mur'
+   *
+   * @param pontThermiqueDE {PontThermiqueDE}
+   * @param enveloppe {Enveloppe}
+   * @param isolationMur {number}
+   * @return {number|undefined}
+   */
+  pontThermiqueMenuiserieMur(pontThermiqueDE, enveloppe, isolationMur) {
+    const menuiserieDE = this.menuiserie(pontThermiqueDE, enveloppe);
+
+    if (!menuiserieDE) {
+      logger.error(`
+        Impossible de trouver une menuiserie ayant pour référence '${pontThermiqueDE.reference_1}' ou '${pontThermiqueDE.reference_2}'.
+      `);
+      return this.defaultValue(pontThermiqueDE);
+    }
+
+    if (parseInt(menuiserieDE.enum_type_vitrage_id) === 5) {
+      return 0;
+    }
+
+    let typePose = parseInt(menuiserieDE.enum_type_pose_id || 3);
+
+    // Pour les types sans objet
+    if (typePose === 4) {
+      typePose = 3;
+    }
+
+    const largeurDormant = menuiserieDE.largeur_dormant;
+    const presenceRetourIsolation = menuiserieDE.presence_retour_isolation;
+
+    return this.tvStore.getKForMenuiserie(
+      5,
+      enums.type_isolation[isolationMur],
+      typePose,
+      presenceRetourIsolation,
+      largeurDormant
+    );
+  }
+
+  /**
+   * Récupération du mur sur lequel se réfère ce pont thermique à partir des références
+   *
+   * @param pontThermiqueDE {PontThermiqueDE}
+   * @param enveloppe {Enveloppe}
+   * @return {MurDE|undefined}
+   */
+  mur(pontThermiqueDE, enveloppe) {
+    return (enveloppe.mur_collection?.mur || []).find(
+      (mur) =>
+        compareReferences(mur.donnee_entree.reference, pontThermiqueDE.reference_1) ||
+        compareReferences(mur.donnee_entree.reference, pontThermiqueDE.reference_2)
+    )?.donnee_entree;
+  }
+
+  /**
+   * Récupération du plancher bas sur lequel se réfère ce pont thermique à partir des références
+   *
+   * @param pontThermiqueDE {PontThermiqueDE}
+   * @param enveloppe {Enveloppe}
+   * @return {PlancherBasDE|undefined}
+   */
+  plancherBas(pontThermiqueDE, enveloppe) {
+    return (enveloppe.plancher_bas_collection?.plancher_bas || []).find(
+      (plancher) =>
+        compareReferences(plancher.donnee_entree.reference, pontThermiqueDE.reference_1) ||
+        compareReferences(plancher.donnee_entree.reference, pontThermiqueDE.reference_2)
+    )?.donnee_entree;
+  }
+
+  /**
+   * Récupération du plancher haut sur lequel se réfère ce pont thermique à partir des références
+   *
+   * @param pontThermiqueDE {PontThermiqueDE}
+   * @param enveloppe {Enveloppe}
+   * @return {PlancherHautDE|undefined}
+   */
+  plancherHaut(pontThermiqueDE, enveloppe) {
+    return (enveloppe.plancher_haut_collection?.plancher_haut || []).find(
+      (plancher) =>
+        compareReferences(plancher.donnee_entree.reference, pontThermiqueDE.reference_1) ||
+        compareReferences(plancher.donnee_entree.reference, pontThermiqueDE.reference_2)
+    )?.donnee_entree;
+  }
+
+  /**
+   * Récupération de la menuiserie (baie vitrée ou porte) sur laquelle se réfère ce pont thermique
+   *
+   * @param pontThermiqueDE {PontThermiqueDE}
+   * @param enveloppe {Enveloppe}
+   * @return {BaieVitreeDE|PorteDE|undefined}
+   */
+  menuiserie(pontThermiqueDE, enveloppe) {
+    return (enveloppe.baie_vitree_collection?.baie_vitree || [])
+      .concat(enveloppe.porte_collection?.porte || [])
+      .find(
+        (menuiserie) =>
+          compareReferences(menuiserie.donnee_entree.reference, pontThermiqueDE.reference_1) ||
+          compareReferences(menuiserie.donnee_entree.reference, pontThermiqueDE.reference_2)
+      )?.donnee_entree;
+  }
+
+  /**
+   * Retourne true si le mur est concerné par un pont thermique
+   * @param murDE {MurDE}
+   * @param typeLiaison {number}
+   */
+  murHasPontThermique(murDE, typeLiaison) {
+    /**
+     * 3.4 Calcul des déperditions par les ponts thermiques
+     * Les ponts thermiques des parois au niveau des circulations communes ne sont pas pris en compte.
+     * 14 - Circulation sans ouverture directe sur l'extérieur
+     * 15 - Circulation avec ouverture directe sur l'extérieur
+     * 16 - Circulation avec bouche ou gaine de désenfumage ouverte en permanence
+     * 17 - Hall d'entrée avec dispositif de fermeture automatique
+     * 18 - Hall d'entrée sans dispositif de fermeture automatique
+     * 22 - Local non déperditif ( local à usage d'habitation chauffé)
+     */
+    // @todo vérifier la liste
+    if ([14, 15, 16, 17, 18, 22].includes(parseInt(murDE.enum_type_adjacence_id))) {
+      return false;
+    }
+
+    /**
+     * 3.4.1 Mur Plancher bas / mur
+     * 3.4.3 Plancher haut / mur
+     *
+     * Seuls les murs et planchers bas constitués d’un matériau lourd (béton, brique, …) sont considérés ici. Pour les autres
+     * cas ce pont thermique est pris nul.
+     *
+     * 5 - Murs en pan de bois sans remplissage tout venant
+     * 6 - Murs en pan de bois avec remplissage tout venant
+     * 7 - Murs bois (rondin)
+     * 16 - Béton cellulaire avant 2013
+     * 18 - Murs en ossature bois avec isolant en remplissage ≥ 2006
+     * 24 - Murs en ossature bois avec isolant en remplissage 2001-2005
+     * 25 - Murs en ossature bois sans remplissage
+     * 26 - Murs en ossature bois avec isolant en remplissage <2001
+     * 27 - Murs en ossature bois avec remplissage tout venant
+     */
+    if (typeLiaison === 1 || typeLiaison === 3) {
+      return ![5, 6, 7, 16, 18, 24, 25, 26, 27].includes(
+        parseInt(murDE.enum_materiaux_structure_mur_id)
+      );
+    }
+
+    /**
+     * 3.4.5 Menuiserie / mur
+     * Les ponts thermiques avec les parois en structure bois (ossature bois, rondin de bois, pans de bois) sont négligés.
+     * enum_materiaux_structure_mur_id
+     *
+     * 5 - Murs en pan de bois sans remplissage tout venant
+     * 6 - Murs en pan de bois avec remplissage tout venant
+     * 7 - Murs bois (rondin)
+     * 18 - Murs en ossature bois avec isolant en remplissage ≥ 2006
+     * 24 - Murs en ossature bois avec isolant en remplissage 2001-2005
+     * 25 - Murs en ossature bois sans remplissage
+     * 26 - Murs en ossature bois avec isolant en remplissage <2001
+     * 27 - Murs en ossature bois avec remplissage tout venant
+     */
+    if (typeLiaison === 4) {
+      return ![5, 6, 7, 18, 24, 25, 26, 27].includes(
+        parseInt(murDE.enum_materiaux_structure_mur_id)
+      );
+    }
+
+    return true;
+  }
+
+  /**
+   * Retourne true si le plancher haut est concerné par un pont thermique
+   * @param plancherHautDE {PlancherHautDE}
+   * @return {boolean}
+   */
+  plancherHautHasPontThermique(plancherHautDE) {
+    /**
+     * 3.4.3 Plancher haut / mur
+     *
+     * Les ponts thermiques des planchers haut en structure légère sont négligés.
+     * type_plancher_haut
+
+     * 9 - Plafond bois sur solives bois
+     * 10 - Plafond bois sous solives bois
+     */
+    // @todo d'autres type de plancher haut ?
+    return ![9, 10].includes(parseInt(plancherHautDE.enum_type_plancher_haut_id));
+  }
+
+  /**
+   * Retourne true si le plancher bas est concerné par un pont thermique
+   *
+   * @param plancherBasDE {PlancherBasDE}
+   */
+  plancherBasHasPontThermique(plancherBasDE) {
+    /**
+     * 3.4.3 Plancher haut / mur
+     *
+     * Seuls les planchers bas constitués d’un matériau lourd (béton, brique, …) sont considérés ici. Pour les autres
+     * cas ce pont thermique est pris nul.
+
+     * 4 - Plancher entre solives bois avec ou sans remplissage
+     * 10 - Plancher bois sur solives bois
+     */
+    // @todo d'autres type de plancher bas ?
+    return ![4, 10].includes(parseInt(plancherBasDE.enum_type_plancher_bas_id));
+  }
+
+  /**
+   *
+   * @param ptDE {PontThermiqueDE}
+   */
+  defaultValue(ptDE) {
+    return this.tvStore.getKForMurById(ptDE.tv_pont_thermique_id);
+  }
+}