@open3cl/engine 1.0.5 → 1.0.7

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

@@ -0,0 +1,282 @@
+import { DeperditionEnveloppeService } from './deperdition-enveloppe.service.js';
+import corpus from '../../../../../test/corpus-sano.json';
+import { getAdemeFileJson } from '../../../../../test/test-helpers.js';
+import { ContexteBuilder } from '../contexte.builder.js';
+import { DeperditionPlancherBasService } from './plancher_bas/deperdition-plancher-bas.service.js';
+import { DeperditionMurService } from './mur/deperdition-mur.service.js';
+import { DeperditionPorteService } from './porte/deperdition-porte.service.js';
+import { DeperditionPlancherHautService } from './plancher_haut/deperdition-plancher-haut.service.js';
+import { DpeNormalizerService } from '../../../normalizer/domain/dpe-normalizer.service.js';
+import { TvStore } from '../../../dpe/infrastructure/tv.store.js';
+import { beforeEach, describe, expect, test } from 'vitest';
+import b from '../../../../3.1_b.js';
+
+/** @type {DeperditionPorteService} **/
+let deperditionPorteService;
+
+/** @type {DeperditionMurService} **/
+let deperditionMurService;
+
+/** @type {DeperditionPlancherBasService} **/
+let deperditionPlancherBasService;
+
+/** @type {DeperditionPlancherHautService} **/
+let deperditionPlancherHautService;
+
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
+/** @type {TvStore} **/
+let tvStore;
+
+/** @type {DeperditionEnveloppeService} **/
+let service;
+
+describe('Calcul des déperditions', () => {
+  beforeEach(() => {
+    tvStore = new TvStore();
+    deperditionPorteService = new DeperditionPorteService(tvStore);
+    deperditionMurService = new DeperditionMurService(tvStore);
+    deperditionPlancherBasService = new DeperditionPlancherBasService(tvStore);
+    deperditionPlancherHautService = new DeperditionPlancherHautService(tvStore);
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
+
+    service = new DeperditionEnveloppeService(
+      deperditionMurService,
+      deperditionPorteService,
+      deperditionPlancherBasService,
+      deperditionPlancherHautService
+    );
+  });
+
+  describe('Détermination du coefficient de réduction des déperditions b', () => {
+    test.each([
+      { enumTypeAdjacenceId: '1', label: 'extérieur', bExpected: 1 },
+      { enumTypeAdjacenceId: '2', label: 'paroi enterrée', bExpected: 1 },
+      { enumTypeAdjacenceId: '3', label: 'vide sanitaire', bExpected: 1 },
+      {
+        enumTypeAdjacenceId: '4',
+        label: "bâtiment ou local à usage autre que d'habitation",
+        bExpected: 0.2
+      },
+      { enumTypeAdjacenceId: '5', label: 'terre-plein', bExpected: 1 },
+      { enumTypeAdjacenceId: '6', label: 'sous-sol non chauffé', bExpected: 1 },
+      {
+        enumTypeAdjacenceId: '7',
+        enumCfgIsolationLncId: '1',
+        label: 'locaux non chauffés non accessible',
+        bExpected: 0.95
+      },
+      {
+        enumTypeAdjacenceId: '8',
+        surfaceAiu: 14.75,
+        surfaceAue: 300,
+        enumCfgIsolationLncId: '2',
+        label: 'garage',
+        bExpected: 0.9
+      },
+      {
+        enumTypeAdjacenceId: '9',
+        surfaceAiu: 8.14,
+        surfaceAue: 22.8,
+        enumCfgIsolationLncId: '4',
+        label: 'cellier',
+        bExpected: 0.95
+      },
+      {
+        enumTypeAdjacenceId: '10',
+        surfaceAiu: 8.14,
+        surfaceAue: 22.8,
+        enumCfgIsolationLncId: '9',
+        label: 'espace tampon solarisé (véranda,loggia fermée)',
+        bExpected: undefined
+      },
+      {
+        enumTypeAdjacenceId: '10',
+        surfaceAiu: 8.14,
+        surfaceAue: 22.8,
+        zoneClimatiqueId: '5',
+        enumCfgIsolationLncId: '9',
+        label: 'espace tampon solarisé (véranda,loggia fermée)',
+        bExpected: 0.85
+      },
+      {
+        enumTypeAdjacenceId: '11',
+        surfaceAiu: 50.2,
+        surfaceAue: 60,
+        enumCfgIsolationLncId: '4',
+        label: 'comble fortement ventilé',
+        bExpected: 0.95
+      },
+      {
+        enumTypeAdjacenceId: '12',
+        surfaceAiu: 74,
+        surfaceAue: 110,
+        enumCfgIsolationLncId: '4',
+        label: 'comble faiblement ventilé',
+        bExpected: 0.95
+      },
+      {
+        enumTypeAdjacenceId: '13',
+        surfaceAiu: 30,
+        surfaceAue: 45,
+        enumCfgIsolationLncId: '2',
+        label: 'comble très faiblement ventilé',
+        bExpected: 0.65
+      },
+      {
+        enumTypeAdjacenceId: '14',
+        surfaceAiu: 22,
+        surfaceAue: 15,
+        enumCfgIsolationLncId: '2',
+        label: "circulation sans ouverture directe sur l'extérieur",
+        bExpected: 0.35
+      },
+      {
+        enumTypeAdjacenceId: '15',
+        surfaceAiu: 20,
+        surfaceAue: 2.5,
+        enumCfgIsolationLncId: '2',
+        label: "circulation avec ouverture directe sur l'extérieur",
+        bExpected: 0.15
+      },
+      {
+        enumTypeAdjacenceId: '16',
+        surfaceAiu: 120,
+        surfaceAue: 300,
+        enumCfgIsolationLncId: '3',
+        label: 'circulation avec bouche ou gaine de désenfumage ouverte en permanence',
+        bExpected: 0.7
+      },
+      {
+        enumTypeAdjacenceId: '17',
+        label: "hall d'entrée avec dispositif de fermeture automatique",
+        bExpected: 0
+      },
+      {
+        enumTypeAdjacenceId: '18',
+        surfaceAiu: 335.22,
+        surfaceAue: 29.18,
+        enumCfgIsolationLncId: '2',
+        label: "hall d'entrée sans dispositif de fermeture automatique",
+        bExpected: 0.15
+      },
+      {
+        enumTypeAdjacenceId: '19',
+        surfaceAiu: 49,
+        surfaceAue: 65,
+        enumCfgIsolationLncId: '2',
+        label: 'garage privé collectif',
+        bExpected: 0.7
+      },
+      {
+        enumTypeAdjacenceId: '20',
+        label: "local tertiaire à l'intérieur de l'immeuble en contact avec l'appartement",
+        bExpected: 0.2
+      },
+      {
+        enumTypeAdjacenceId: '21',
+        surfaceAiu: 4.94,
+        surfaceAue: 8.8,
+        enumCfgIsolationLncId: '2',
+        label: 'autres dépendances',
+        bExpected: 0.75
+      },
+      {
+        enumTypeAdjacenceId: '22',
+        label: "local non déperditif (local à usage d'habitation chauffé)",
+        bExpected: 0
+      }
+    ])(
+      '$label (id:$enumTypeAdjacenceId)',
+      ({
+        enumTypeAdjacenceId,
+        surfaceAiu = undefined,
+        surfaceAue = undefined,
+        zoneClimatiqueId = undefined,
+        enumCfgIsolationLncId = undefined,
+        bExpected
+      }) => {
+        const data = {
+          enumTypeAdjacenceId,
+          surfaceAiu,
+          surfaceAue,
+          enumCfgIsolationLncId,
+          zoneClimatiqueId
+        };
+
+        const b = deperditionMurService.b(data);
+        expect(b).toBe(bExpected);
+      }
+    );
+  });
+
+  describe.skip('Benchmark', () => {
+    test('reworked', () => {
+      const data = {
+        enumTypeAdjacenceId: '8',
+        surfaceAiu: 2.82,
+        surfaceAue: 300,
+        enumCfgIsolationLncId: '2',
+        label: 'garage'
+      };
+
+      for (let i = 0; i < 1000; i++) {
+        const b = deperditionMurService.b(data);
+        expect(b).toBe(0.9);
+      }
+    });
+
+    test('legacy', () => {
+      const di = { b: undefined };
+      const de = {
+        enum_type_adjacence_id: '8',
+        surface_aiu: 2.82,
+        surface_aue: 300,
+        enum_cfg_isolation_lnc_id: '2'
+      };
+      const du = {};
+      const zc = '1';
+
+      for (let i = 0; i < 1000; i++) {
+        b(di, de, du, zc);
+        expect(di.b).toBe(0.9);
+      }
+    });
+  });
+
+  describe("Test d'intégration de calcul des deperditions", () => {
+    test.each(corpus)('deperditions pour dpe %s', (ademeId) => {
+      let dpeRequest = getAdemeFileJson(ademeId);
+      dpeRequest = normalizerService.normalize(dpeRequest);
+
+      /** @type {Contexte} */
+      const ctx = contexteBuilder.fromDpe(dpeRequest);
+      /** @type {Logement} */
+      const logement = dpeRequest.logement;
+      /** @type {Deperdition} */
+      const deperditions = service.deperditions(ctx, logement);
+
+      expect(deperditions.deperdition_mur).toBeCloseTo(
+        dpeRequest.logement.sortie.deperdition.deperdition_mur,
+        1
+      );
+      expect(deperditions.deperdition_porte).toBeCloseTo(
+        dpeRequest.logement.sortie.deperdition.deperdition_porte,
+        1
+      );
+      expect(deperditions.deperdition_plancher_bas).toBeCloseTo(
+        dpeRequest.logement.sortie.deperdition.deperdition_plancher_bas,
+        1
+      );
+      expect(deperditions.deperdition_plancher_haut).toBeCloseTo(
+        dpeRequest.logement.sortie.deperdition.deperdition_plancher_haut,
+        1
+      );
+    });
+  });
+});

package/features/engine/domain/enveloppe/deperdition.service.js

@@ -0,0 +1,101 @@
+import enums from '../../../../enums.js';
+import { logger } from '../../../../core/util/logger/log-service.js';
+import { inject } from 'dioma';
+import { TvStore } from '../../../dpe/infrastructure/tv.store.js';
+
+/**
+ * Calcul des déperditions de l’enveloppe GV
+ * @see Méthode de calcul 3CL-DPE 2021 (cotobre 2021) chapitre 3
+ */
+export class DeperditionService {
+  /**
+   * @type {TvStore}
+   */
+  tvStore;
+
+  /**
+   * @param tvStore {TvStore}
+   */
+  constructor(tvStore = inject(TvStore)) {
+    this.tvStore = tvStore;
+  }
+
+  /**
+   * Détermination des déperditions pour l'enveloppe concernée
+   * @param ctx {Contexte}
+   * @param de {DE}
+   * @return void
+   */
+  /* eslint-disable no-unused-vars */
+  execute(ctx, de) {
+    throw new Error('Unsupported operation');
+  }
+
+  /**
+   * Détermination du coefficient de réduction des déperditions b
+   * @see Méthode de calcul 3CL-DPE 2021 (cotobre 2021) chapitre 3.1
+   *
+   * @param d {DeperditionData}
+   * @return {number|undefined} Retourne le coefficient de réduction des déperditions b ou undefined si le calcul est impossible
+   */
+  b(d) {
+    let uVue,
+      zc,
+      rAiuAue = undefined;
+    let enumTypeAdjacenceId = d.enumTypeAdjacenceId;
+
+    if (
+      ['8', '9', '11', '12', '13', '14', '15', '16', '17', '18', '19', '21'].includes(
+        enumTypeAdjacenceId
+      )
+    ) {
+      if (!d.surfaceAue || d.surfaceAue === 0) {
+        return 0;
+      }
+
+      /**
+       * @see Méthode de calcul 3CL-DPE 2021 (cotobre 2021)
+       * chapitre 3.1 Détermination du coefficient de réduction des déperditions b
+       * 'Dans le cas de locaux non chauffés non accessibles (mitoyenneté, espace sans accès…), forfaitairement b = 0,95.'
+       */
+      if (d.enumCfgIsolationLncId === '1') {
+        enumTypeAdjacenceId = undefined;
+      } else {
+        uVue = this.tvStore.getUVue(enumTypeAdjacenceId) || 0;
+        rAiuAue = d.surfaceAiu / d.surfaceAue;
+      }
+    }
+
+    /**
+     * Type d'adjacence 10: 'espace tampon solarisé (véranda,loggia fermée)'
+     * Prise en compte de la zone climatique
+     */
+    if (['10'].includes(enumTypeAdjacenceId)) {
+      if (!d.zoneClimatiqueId) {
+        logger.warn(
+          `impossible de calculer b pour TypeAdjacenceId:${enumTypeAdjacenceId} sans zone climatique`
+        );
+        return;
+      }
+      zc = enums.zone_climatique[parseInt(d.zoneClimatiqueId)];
+    }
+
+    return this.tvStore.getB(enumTypeAdjacenceId, uVue, d.enumCfgIsolationLncId, rAiuAue, zc);
+  }
+
+  /**
+   * Si Année d'isolation connue alors on prend cette donnée.
+   * Sinon
+   *   Si Année de construction ≤74 alors Année d’isolation = 75-77
+   *   Sinon Année d’isolation = Année de construction
+   *
+   * @param enumPeriodeIsolationId {number}
+   * @param ctx {Contexte}
+   * @return {string} ID de la période d'isolation
+   */
+  getEnumPeriodeIsolationId(enumPeriodeIsolationId, ctx) {
+    return (
+      enumPeriodeIsolationId || Math.max(parseInt(ctx.enumPeriodeConstructionId), 3).toString()
+    );
+  }
+}

package/features/engine/domain/enveloppe/mur/deperdition-mur.service.js

@@ -0,0 +1,168 @@
+import { logger } from '../../../../../core/util/logger/log-service.js';
+import { inject } from 'dioma';
+import { PRECISION } from '../../constants.js';
+import { DeperditionService } from '../deperdition.service.js';
+import { TvStore } from '../../../../dpe/infrastructure/tv.store.js';
+
+/**
+ * Calcul des déperditions de l’enveloppe GV
+ * Chapitre 3.2.1 Calcul des Umur
+ *
+ * Méthode de calcul 3CL-DPE 2021
+ * Octobre 2021
+ * @see consolide_anne…arrete_du_31_03_2021_relatif_aux_methodes_et_procedures_applicables.pdf
+ */
+export class DeperditionMurService extends DeperditionService {
+  /**
+   * @param tvStore {TvStore}
+   */
+  constructor(tvStore = inject(TvStore)) {
+    super(tvStore);
+  }
+
+  /**
+   * @param ctx {Contexte}
+   * @param murDE {MurDE}
+   * @return {MurDI}
+   */
+  execute(ctx, murDE) {
+    const umur0 = this.#umur0(murDE);
+    const umur = this.#umur(murDE, umur0, ctx);
+    const b = this.b({
+      enumTypeAdjacenceId: murDE.enum_type_adjacence_id,
+      surfaceAiu: murDE.surface_aiu,
+      surfaceAue: murDE.surface_aue,
+      enumCfgIsolationLncId: murDE.enum_cfg_isolation_lnc_id,
+      tvCoefReductionDeperditionId: murDE.tv_coef_reduction_deperdition_id,
+      zoneClimatiqueId: ctx.zoneClimatiqueId
+    });
+
+    /** @type {MurDI} */
+    return { umur0, umur, b };
+  }
+
+  /**
+   * @param murDE {MurDE}
+   * @param umur0 {number}
+   * @param ctx {Contexte}
+   * @return {number|undefined}
+   */
+  #umur(murDE, umur0, ctx) {
+    // On determine umur_nu (soit umur0 soit 2.5 comme valeur minimale forfaitaire)
+    const umurNu = Math.min(umur0, 2.5);
+
+    const enumPeriodeIsolationId = this.getEnumPeriodeIsolationId(
+      murDE.enum_periode_isolation_id,
+      ctx
+    );
+
+    // Selon l'isolation, on applique un calcul au mur nu pour simuler son isolation
+    let umur;
+    switch (murDE.enum_methode_saisie_u_id) {
+      case '1': // non isolé
+        umur = umurNu;
+        break;
+      case '2': // isolation inconnue (table forfaitaire)
+        umur = Math.min(
+          umurNu,
+          this.tvStore.getUmur(ctx.enumPeriodeConstructionId, ctx.zoneClimatiqueId, ctx.effetJoule)
+        );
+        break;
+      case '7': // année d'isolation différente de l'année de construction
+      case '8': // année de construction saisie
+        umur = Math.min(
+          umurNu,
+          this.tvStore.getUmur(enumPeriodeIsolationId, ctx.zoneClimatiqueId, ctx.effetJoule)
+        );
+        break;
+      case '3': // epaisseur isolation saisie justifiée par mesure ou observation
+      case '4': {
+        // epaisseur isolation saisie (en cm)
+        const epaisseurIsolation = murDE.epaisseur_isolation;
+        if (epaisseurIsolation) {
+          umur = 1 / (1 / umurNu + (murDE.epaisseur_isolation * 0.01) / 0.04);
+        } else {
+          logger.warn(
+            `Le mur ${murDE.description} ne possède pas de donnée d'entrée pour epaisseur_isolation 
+              alors que methode_saisie_u = 'epaisseur isolation saisie'`
+          );
+          umur = Math.min(umur0, 2.5);
+        }
+        break;
+      }
+      case '5':
+      case '6':
+        // resistance isolation saisie
+        umur = 1 / (1 / umurNu + murDE.resistance_isolation);
+        break;
+      default:
+        // saisie direct de la valeur de u
+        umur = murDE.umur_saisi;
+        break;
+    }
+
+    return Math.round(parseFloat(umur) * PRECISION) / PRECISION;
+  }
+
+  /**
+   * @param murDE {MurDE}
+   * @return {number|undefined}
+   */
+  #umur0(murDE) {
+    let umur0;
+    switch (murDE.enum_methode_saisie_u0_id) {
+      case '1':
+        umur0 = this.tvStore.getUmur0(murDE.enum_materiaux_structure_mur_id);
+        break;
+      case '2':
+        umur0 = this.tvStore.getUmur0(
+          murDE.enum_materiaux_structure_mur_id,
+          murDE.epaisseur_structure
+        );
+        break;
+      case '5':
+        // Valeur u saisie directement umur0 vide
+        return;
+      default:
+        // Valeur saisie
+        return murDE.umur0_saisi;
+    }
+
+    /**
+     * Pour l’ensemble des parois, la présence d’un doublage apporte une résistance thermique supplémentaire
+     */
+    switch (murDE.enum_type_doublage_id) {
+      case '3':
+        // doublage indéterminé ou lame d'air inf 15 mm
+        umur0 = 1 / (1 / umur0 + 0.1);
+        break;
+      case '4': // doublage indéterminé ou lame d'air sup 15 mm
+      case '5': // doublage connu (plâtre brique bois)
+        umur0 = 1 / (1 / umur0 + 0.21);
+        break;
+      default:
+        // absence de doublage ou inconnu
+        break;
+    }
+
+    /**
+     * Pour les parois dites « anciennes », c’est-à-dire constituées de matériaux traditionnels à savoir pierres, terre, mur à
+     * colombage, brique ancienne, la présence d’un enduit isolant n’est pas considérée comme une isolation. Cependant,
+     * cet enduit apporte une correction d’isolation qu’il faut prendre en compte
+     *
+     * la paroi est une paroi ancienne sur laquelle a été appliquée un enduit isolant (Renduit=0,7m².K.W-1) 0 : non 1 : oui.
+     * (Attention ! nom de propriété pas tout à fait explicite)
+     * OBSOLETE > remplacé par enduit_isolant_paroi_ancienne
+     */
+    if (murDE.enduit_isolant_paroi_ancienne) {
+      umur0 = 1 / (1 / umur0 + 0.7);
+    }
+
+    /**
+     * @todo Comportement non clairement documenté
+     * Dans beaucoup de cas umur0 retourné en le min entre 2.5 et la valeur trouvée,
+     * mais pas de documentation sur ce point dans la méthode 3CL
+     */
+    return Math.min(2.5, Math.round(parseFloat(umur0) * PRECISION) / PRECISION);
+  }
+}