@open3cl/engine 1.0.6 → 1.0.8

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

@@ -0,0 +1,278 @@
+import { inject } from 'dioma';
+import { DeperditionMurService } from './mur/deperdition-mur.service.js';
+import { DeperditionPorteService } from './porte/deperdition-porte.service.js';
+import { DeperditionPlancherBasService } from './plancher_bas/deperdition-plancher-bas.service.js';
+import { DeperditionPlancherHautService } from './plancher_haut/deperdition-plancher-haut.service.js';
+import { DeperditionVentilationService } from './ventilation/deperdition-ventilation.service.js';
+import { DeperditionBaieVitreeService } from './baie_vitree/deperdition-baie-vitree.service.js';
+
+/**
+ * Calcul des déperditions de l’enveloppe
+ * @see Méthode de calcul 3CL-DPE 2021 (cotobre 2021) chapitre 3
+ */
+export class DeperditionEnveloppeService {
+  /**
+   * @type {DeperditionMurService}
+   */
+  #deperditionMurService;
+
+  /**
+   * @type {DeperditionPorteService}
+   */
+  #deperditionPorteService;
+
+  /**
+   * @type {DeperditionPlancherBasService}
+   */
+  #deperditionPlancherBasService;
+
+  /**
+   * @type {DeperditionPlancherHautService}
+   */
+  #deperditionPlancherHautService;
+
+  /**
+   * @type {DeperditionBaieVitreeService}
+   */
+  #deperditionBaieVitreeService;
+
+  /**
+   * @type {DeperditionVentilationService}
+   */
+  #deperditionVentilationService;
+
+  /**
+   * @type {number}
+   */
+  #surfaceDeperditive;
+
+  /**
+   * @type {number}
+   */
+  #surfaceIsolee;
+
+  /**
+   * @type {number}
+   */
+  #surfaceNonIsolee;
+
+  /**
+   * @type {number}
+   */
+  #surfaceMenuiserieAvecJoint;
+
+  /**
+   * @type {number}
+   */
+  #surfaceMenuiserieSansJoint;
+
+  /**
+   *
+   * @param deperditionMurService {DeperditionMurService}
+   * @param deperditionPorteService {DeperditionPorteService}
+   * @param deperditionPlancherBasService {DeperditionPlancherBasService}
+   * @param deperditionPlancherHautService {DeperditionPlancherHautService}
+   * @param deperditionBaieVitreeService {DeperditionBaieVitreeService}
+   * @param deperditionVentilationService {DeperditionVentilationService}
+   */
+  constructor(
+    deperditionMurService = inject(DeperditionMurService),
+    deperditionPorteService = inject(DeperditionPorteService),
+    deperditionPlancherBasService = inject(DeperditionPlancherBasService),
+    deperditionPlancherHautService = inject(DeperditionPlancherHautService),
+    deperditionBaieVitreeService = inject(DeperditionBaieVitreeService),
+    deperditionVentilationService = inject(DeperditionVentilationService)
+  ) {
+    this.#deperditionMurService = deperditionMurService;
+    this.#deperditionPorteService = deperditionPorteService;
+    this.#deperditionPlancherBasService = deperditionPlancherBasService;
+    this.#deperditionPlancherHautService = deperditionPlancherHautService;
+    this.#deperditionBaieVitreeService = deperditionBaieVitreeService;
+    this.#deperditionVentilationService = deperditionVentilationService;
+    this.#surfaceDeperditive = 0;
+    this.#surfaceIsolee = 0;
+    this.#surfaceNonIsolee = 0;
+    this.#surfaceMenuiserieAvecJoint = 0;
+    this.#surfaceMenuiserieSansJoint = 0;
+  }
+
+  /**
+   * Calcul des déperditions de l’enveloppe
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @returns {{hvent: number, hperm: number, deperdition_renouvellement_air: number, deperdition_mur: number, deperdition_plancher_bas: number, deperdition_plancher_haut: number, deperdition_baie_vitree: number, deperdition_porte: number, deperdition_pont_thermique: number, deperdition_enveloppe: number}}
+   */
+  deperditions(ctx, logement) {
+    const GV = this.#gv(ctx, logement.enveloppe);
+    const ventilation = this.#ventilation(ctx, logement);
+    return {
+      ...GV,
+      ...ventilation,
+      ...{
+        deperdition_enveloppe:
+          GV.deperdition_mur +
+          GV.deperdition_plancher_bas +
+          GV.deperdition_plancher_haut +
+          GV.deperdition_baie_vitree +
+          GV.deperdition_porte +
+          GV.deperdition_pont_thermique +
+          ventilation.hvent +
+          ventilation.hperm
+      }
+    };
+  }
+
+  /**
+   * Calcul des déperditions de l’enveloppe GV
+   *
+   * @param ctx {Contexte}
+   * @param enveloppe {Enveloppe}
+   *
+   * @return {Deperdition}
+   */
+  #gv(ctx, enveloppe) {
+    this.#surfaceDeperditive = 0;
+    this.#surfaceIsolee = 0;
+    this.#surfaceNonIsolee = 0;
+    this.#surfaceMenuiserieAvecJoint = 0;
+    this.#surfaceMenuiserieSansJoint = 0;
+
+    /**
+     * @type {Deperdition}
+     */
+    const deperditions = {
+      deperdition_mur: 0,
+      deperdition_plancher_bas: 0,
+      deperdition_plancher_haut: 0,
+      deperdition_baie_vitree: 0,
+      deperdition_porte: 0
+    };
+
+    enveloppe.mur_collection.mur?.forEach((m) => {
+      m.donnee_intermediaire = this.#deperditionMurService.execute(ctx, m.donnee_entree);
+      deperditions.deperdition_mur +=
+        m.donnee_intermediaire.b *
+        m.donnee_entree.surface_paroi_opaque *
+        m.donnee_intermediaire.umur;
+
+      if (m.donnee_intermediaire.b > 0) {
+        // Paroi déperditive si b != 0 et adjacence != 'local non déperditif'
+        if (m.donnee_entree.enum_type_adjacence_id !== '22') {
+          this.#surfaceDeperditive += m.donnee_entree.surface_paroi_opaque;
+        }
+        // Surface isolée si b != 0 et type d'isolation != 'inconnu' et != 'non isolé'
+        if (['1', '2'].includes(m.donnee_entree.enum_type_isolation_id)) {
+          this.#surfaceNonIsolee += m.donnee_entree.surface_paroi_opaque;
+        } else {
+          this.#surfaceIsolee += m.donnee_entree.surface_paroi_opaque;
+        }
+      }
+    });
+
+    enveloppe.porte_collection.porte?.forEach((p) => {
+      p.donnee_intermediaire = this.#deperditionPorteService.execute(ctx, p.donnee_entree);
+      deperditions.deperdition_porte +=
+        p.donnee_intermediaire.b * p.donnee_entree.surface_porte * p.donnee_intermediaire.uporte;
+
+      // Surface de porte déperditive si b != 0
+      if (p.donnee_intermediaire.b > 0) {
+        this.#surfaceDeperditive += p.donnee_entree.surface_porte;
+      }
+      // Surface de porte avec ou sans joint
+      if (p.donnee_entree.presence_joint) {
+        this.#surfaceMenuiserieAvecJoint += p.donnee_entree.surface_porte;
+      } else {
+        this.#surfaceMenuiserieSansJoint += p.donnee_entree.surface_porte;
+      }
+    });
+
+    const plancherBas = enveloppe.plancher_bas_collection.plancher_bas || [];
+    plancherBas?.forEach((pb) => {
+      pb.donnee_intermediaire = this.#deperditionPlancherBasService.execute(
+        ctx,
+        pb.donnee_entree,
+        plancherBas
+      );
+      deperditions.deperdition_plancher_bas +=
+        pb.donnee_intermediaire.b *
+        pb.donnee_entree.surface_paroi_opaque *
+        pb.donnee_intermediaire.upb_final;
+    });
+
+    enveloppe.plancher_haut_collection.plancher_haut?.forEach((ph) => {
+      ph.donnee_intermediaire = this.#deperditionPlancherHautService.execute(ctx, ph.donnee_entree);
+      deperditions.deperdition_plancher_haut +=
+        ph.donnee_intermediaire.b *
+        ph.donnee_entree.surface_paroi_opaque *
+        ph.donnee_intermediaire.uph;
+
+      if (ph.donnee_intermediaire.b > 0) {
+        // Plancher déperditif si b != 0 et adjacence != 'local non déperditif'
+        if (ph.donnee_entree.enum_type_adjacence_id !== '22') {
+          this.#surfaceDeperditive += ph.donnee_entree.surface_paroi_opaque;
+        }
+        // Surface isolée si b != 0 et type d'isolation != 'inconnu' et != 'non isolé'
+        if (['1', '2'].includes(ph.donnee_entree.enum_type_isolation_id)) {
+          this.#surfaceNonIsolee += ph.donnee_entree.surface_paroi_opaque;
+        } else {
+          this.#surfaceIsolee += ph.donnee_entree.surface_paroi_opaque;
+        }
+      }
+    });
+
+    enveloppe.baie_vitree_collection.baie_vitree?.forEach((bv) => {
+      bv.donnee_intermediaire = this.#deperditionBaieVitreeService.execute(ctx, bv);
+      deperditions.deperdition_baie_vitree +=
+        bv.donnee_intermediaire.b *
+        bv.donnee_entree.surface_totale_baie *
+        bv.donnee_intermediaire.u_menuiserie;
+
+      // Surface de baie vitrée déperditive si b != 0
+      if (bv.donnee_intermediaire.b > 0) {
+        this.#surfaceDeperditive += bv.donnee_entree.surface_totale_baie;
+      }
+      // Surface de baie vitrée avec ou sans joint
+      if (bv.donnee_entree.presence_joint) {
+        this.#surfaceMenuiserieAvecJoint += bv.donnee_entree.surface_totale_baie;
+      } else {
+        this.#surfaceMenuiserieSansJoint += bv.donnee_entree.surface_totale_baie;
+      }
+    });
+
+    return deperditions;
+  }
+
+  /**
+   * Calcul des déperditions par la ventilation
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   *
+   * @return {Deperdition}
+   */
+  #ventilation(ctx, logement) {
+    /**
+     * @type {Deperdition}
+     */
+    const deperditions = {
+      hperm: 0,
+      hvent: 0
+    };
+
+    logement.ventilation_collection.ventilation?.forEach((ventilation) => {
+      ventilation.donnee_intermediaire = this.#deperditionVentilationService.execute(
+        ctx,
+        ventilation.donnee_entree,
+        this.#surfaceDeperditive,
+        this.#surfaceIsolee,
+        this.#surfaceNonIsolee,
+        this.#surfaceMenuiserieAvecJoint,
+        this.#surfaceMenuiserieSansJoint
+      );
+      deperditions.hvent += ventilation.donnee_intermediaire.hvent;
+      deperditions.hperm += ventilation.donnee_intermediaire.hperm;
+    });
+
+    return deperditions;
+  }
+}

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