@open3cl/engine 1.0.8 → 1.0.10

package/features/engine/domain/logement/nadeq.service.js

@@ -0,0 +1,62 @@
+import { TypeDpe } from '../../../dpe/domain/models/type-habitation.model.js';
+
+/**
+ * Calcul du nombre d’adultes équivalent Nadeq
+ * Chapitre 11.1 Calcul du besoin d’ECS
+ *
+ * Methode_de_calcul_3CL_DPE_2021 - Page 70
+ * Octobre 2021
+ * @see consolide_anne…arrete_du_31_03_2021_relatif_aux_methodes_et_procedures_applicables.pdf
+ */
+export class NadeqService {
+  /**
+   * @param ctx {Contexte}
+   * @param bv {BaieVitree}
+   * @return {number}
+   */
+  execute(ctx) {
+    if (ctx.typeDpe === TypeDpe.MAISON) {
+      return this.#calculateIndividualNadeq(ctx.surfaceHabitable);
+    }
+
+    return this.#calculateCollectiveNadeq(
+      ctx.surfaceHabitable,
+      ctx.typeDpe === TypeDpe.APPARTEMENT ? 1 : ctx.nombreAppartement
+    );
+  }
+
+  /**
+   * Calcul de nadeq pour une maison ou un logement individuel
+   * @param surfaceHabitableLogement {number}
+   * @returns {number}
+   */
+  #calculateIndividualNadeq(surfaceHabitableLogement) {
+    let Nmax;
+
+    if (surfaceHabitableLogement < 30) Nmax = 1;
+    else if (surfaceHabitableLogement < 70) Nmax = 1.75 - 0.01875 * (70 - surfaceHabitableLogement);
+    else Nmax = 0.025 * surfaceHabitableLogement;
+
+    if (Nmax < 1.75) return Nmax;
+    else return 1.75 + 0.3 * (Nmax - 1.75);
+  }
+
+  /**
+   * Calcul de nadeq pour un logement collectif
+   *
+   * @param surfaceHabitableImmeuble {number}
+   * @param nombreAppartement {number}
+   * @returns {number}
+   */
+  #calculateCollectiveNadeq(surfaceHabitableImmeuble, nombreAppartement) {
+    const Shmoy = surfaceHabitableImmeuble / nombreAppartement;
+
+    let Nmax;
+    if (Shmoy < 10) Nmax = 1;
+    else if (Shmoy < 50) Nmax = 1.75 - 0.01875 * (50 - Shmoy);
+    else Nmax = 0.035 * Shmoy;
+
+    if (Nmax < 1.75) return nombreAppartement * Nmax;
+    else return nombreAppartement * (1.75 + 0.3 * (Nmax - 1.75));
+  }
+}

package/features/engine/domain/logement/nadeq.service.spec.js

@@ -0,0 +1,71 @@
+import { describe, expect, test } from 'vitest';
+import { NadeqService } from './nadeq.service.js';
+import { TypeDpe } from '../../../dpe/domain/models/type-habitation.model.js';
+
+describe('Nadeq unit tests', () => {
+  /**
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf Page 70
+   */
+  const service = new NadeqService();
+
+  test.each([
+    { surfaceHabitable: 8, expectedNadeq: 1 },
+    { surfaceHabitable: 28, expectedNadeq: 1 },
+    { surfaceHabitable: 45, expectedNadeq: 1.28125 },
+    { surfaceHabitable: 51, expectedNadeq: 1.39375 },
+    { surfaceHabitable: 70, expectedNadeq: 1.75 },
+    { surfaceHabitable: 75, expectedNadeq: 1.7875 }
+  ])(
+    `Typologie MAISON : Nombre d'adultes équivalent $expectedNadeq pour une surface de logement $surfaceHabitable`,
+    ({ expectedNadeq, surfaceHabitable }) => {
+      const ctx = {
+        surfaceHabitable: surfaceHabitable,
+        typeDpe: TypeDpe.MAISON
+      };
+      expect(service.execute(ctx)).toBe(expectedNadeq);
+    }
+  );
+
+  test.each([
+    { surfaceHabitable: 8, expectedNadeq: 1 },
+    { surfaceHabitable: 28, expectedNadeq: 1.3375 },
+    { surfaceHabitable: 45, expectedNadeq: 1.65625 },
+    { surfaceHabitable: 51, expectedNadeq: 1.7605 },
+    { surfaceHabitable: 70, expectedNadeq: 1.96 },
+    { surfaceHabitable: 75, expectedNadeq: 2.0125 }
+  ])(
+    `Typologie APPARTEMENT : Nombre d'adultes équivalent $expectedNadeq pour une surface de logement $surfaceHabitable`,
+    ({ expectedNadeq, surfaceHabitable }) => {
+      const ctx = {
+        surfaceHabitable: surfaceHabitable,
+        typeDpe: TypeDpe.APPARTEMENT
+      };
+      expect(service.execute(ctx)).toBeCloseTo(expectedNadeq, 2);
+    }
+  );
+
+  test.each([
+    { surfaceHabitable: 8, expectedNadeq: 1, nombreAppartement: 1 },
+    { surfaceHabitable: 8, expectedNadeq: 2, nombreAppartement: 2 },
+    { surfaceHabitable: 28, expectedNadeq: 1.3375, nombreAppartement: 1 },
+    { surfaceHabitable: 28, expectedNadeq: 2.15, nombreAppartement: 2 },
+    { surfaceHabitable: 45, expectedNadeq: 1.65625, nombreAppartement: 1 },
+    { surfaceHabitable: 45, expectedNadeq: 2.46875, nombreAppartement: 2 },
+    { surfaceHabitable: 51, expectedNadeq: 1.7605, nombreAppartement: 1 },
+    { surfaceHabitable: 51, expectedNadeq: 2.58125, nombreAppartement: 2 },
+    { surfaceHabitable: 70, expectedNadeq: 1.96, nombreAppartement: 1 },
+    { surfaceHabitable: 70, expectedNadeq: 2.9375, nombreAppartement: 2 },
+    { surfaceHabitable: 75, expectedNadeq: 2.0125, nombreAppartement: 1 },
+    { surfaceHabitable: 75, expectedNadeq: 3.03125, nombreAppartement: 2 }
+  ])(
+    `Typologie IMMEUBLE : Nombre d'adultes équivalent $expectedNadeq pour une surface de logement $surfaceHabitable et un nombre d'apartement $nombreAppartement`,
+    ({ expectedNadeq, surfaceHabitable, nombreAppartement }) => {
+      const ctx = {
+        surfaceHabitable: surfaceHabitable,
+        nombreAppartement: nombreAppartement,
+        typeDpe: TypeDpe.IMMEUBLE
+      };
+      expect(service.execute(ctx)).toBeCloseTo(expectedNadeq, 2);
+    }
+  );
+});

package/features/engine/domain/logement/surface-sud-equivalente.service.js

@@ -0,0 +1,169 @@
+import { mois_liste } from '../../../../utils.js';
+import { inject } from 'dioma';
+import { BaieVitreeTvStore } from '../../../dpe/infrastructure/baieVitreeTv.store.js';
+
+/**
+ * Calcul e la surface sud équivalente du logement
+ * Chapitre 6.2 Détermination de la surface Sud équivalente
+ *
+ * Methode_de_calcul_3CL_DPE_2021 - Page 45
+ * Octobre 2021
+ * @see consolide_anne…arrete_du_31_03_2021_relatif_aux_methodes_et_procedures_applicables.pdf
+ */
+export class SurfaceSudEquivalenteService {
+  /**
+   * @type {BaieVitreeTvStore}
+   */
+  #tvStore;
+
+  /**
+   * @param tvStore {BaieVitreeTvStore}
+   */
+  constructor(tvStore = inject(BaieVitreeTvStore)) {
+    this.#tvStore = tvStore;
+  }
+
+  /**
+   * @param ctx {Contexte}
+   * @param enveloppe {Enveloppe}
+   * @return {number}
+   */
+  execute(ctx, enveloppe) {
+    const baiesVitrees = enveloppe.baie_vitree_collection?.baie_vitree || [];
+    const ets = enveloppe.ets_collection?.ets || [];
+
+    return mois_liste.reduce((acc, mois) => acc + this.ssdMois(ctx, baiesVitrees, ets, mois), 0);
+  }
+
+  /**
+   * Calcul de la surface sud du logement pour un mois donné
+   *
+   * @param ctx {Contexte}
+   * @param baiesVitrees {BaieVitree[]}
+   * @param ets {Ets}
+   * @param mois {string}
+   * @returns {number}
+   */
+  ssdMois(ctx, baiesVitrees, ets, mois) {
+    let SseVerandaj = 0;
+
+    /**
+     * Si une véranda est présente, on calcul l'mpact de l’espace tampon solarisé sur les apports solaires à travers
+     * les baies vitrées qui séparent le logement de l'espace tampon
+     *
+     * 6.3 Traitement des espaces tampons solarisés
+     * 10 - 'espace tampon solarisé (véranda,loggia fermée)'
+     */
+    if (ets) {
+      // Certaines vérandas sont dupliqués dans les DPE.
+      if (Array.isArray(ets)) {
+        ets = ets[0];
+      }
+
+      if (ets) {
+        const bver = ets.donnee_intermediaire.bver;
+        const T = ets.donnee_intermediaire.coef_transparence_ets;
+
+        /**
+         * Surface sud équivalente représentant l’impact des apports solaires associés au rayonnement solaire
+         * traversant directement l’espace tampon pour arriver dans la partie habitable du logement
+         * Calculés pour les baies vitrées qui séparent le logement de l'espace tampon
+         * @type {number}
+         */
+        const Ssdj = this.getBaiesSurEspaceTampon(baiesVitrees).reduce((acc, bv) => {
+          return acc + T * this.ssdBaieMois(bv, ctx.zoneClimatique.id, mois);
+        }, 0);
+
+        /**
+         * Surface sud équivalente représentant les apports solaires indirects dans le logement
+         */
+        let baies = ets.baie_ets_collection.baie_ets;
+
+        if (!Array.isArray(baies)) {
+          baies = [baies];
+        }
+
+        /**
+         * Apports totaux à travers l'espace tampon
+         * @type {number}
+         */
+        const Sstj = baies.reduce((acc, bv) => {
+          return acc + this.ssdBaieMois(bv, ctx.zoneClimatique.id, mois, 0.8 * T + 0.024);
+        }, 0);
+
+        /**
+         * Surface sud équivalente représentant l’impact des apports solaires indirects associés au rayonnement
+         * solaire entrant dans la partie habitable du logement après de multiples réflexions dans l’espace tampon solarisé
+         * @type {number}
+         */
+        const Ssindj = Sstj - Ssdj;
+
+        /**
+         * Impact de l’espace tampon solarisé sur les apports solaires à travers les baies vitrées qui séparent le logement
+         * de l'espace tampon
+         * @type {number}
+         */
+        SseVerandaj = Ssdj + Ssindj * bver;
+      }
+    }
+
+    return baiesVitrees.reduce((acc, baieVitree) => {
+      const typeAdjacence = parseInt(baieVitree.donnee_entree.enum_type_adjacence_id);
+
+      /**
+       * 6.3 Traitement des espaces tampons solarisés
+       * 10 - 'espace tampon solarisé (véranda,loggia fermée)'
+       */
+      if (typeAdjacence === 10 && ets) {
+        return acc + SseVerandaj;
+      }
+
+      // Pour les fenêtres qui ne donnent pas sur l'extérieur, pas de surface sud équivalente
+      if (typeAdjacence !== 1) {
+        return acc;
+      }
+
+      return acc + this.ssdBaieMois(baieVitree, ctx.zoneClimatique.id, mois);
+    }, 0);
+  }
+
+  /**
+   * Retourne la liste des baies vitrées qui donnent sur l'espace tampon solarisé
+   * @param baiesVitrees {BaieVitree[]}
+   */
+  getBaiesSurEspaceTampon(baiesVitrees) {
+    return baiesVitrees.filter((bv) => parseInt(bv.donnee_entree.enum_type_adjacence_id) === 10);
+  }
+
+  /**
+   * Calcul de la surface sud équivalente pour une baie vitrée bv et pendant un mois donné
+   *
+   * @param baieVitree {BaieVitree|BaieEts}
+   * @param zc {string} zone climatique du logement
+   * @param mois {string} mois au cours duquel calculer la surface sur équivalente de la baie vitrée
+   * @param coeff {number} coefficient à appliquer à cette surface sud
+   * @returns {number}
+   */
+  ssdBaieMois(baieVitree, zc, mois, coeff) {
+    const baieVitreeDE = baieVitree.donnee_entree;
+    const baieVitreeDI = baieVitree.donnee_intermediaire || {};
+
+    const C1 = this.#tvStore.getCoefficientBaieVitree(
+      parseInt(baieVitreeDE.enum_orientation_id),
+      parseInt(baieVitreeDE.enum_inclinaison_vitrage_id ?? 3),
+      parseInt(zc),
+      mois
+    );
+
+    const fe1 = baieVitreeDI.fe1 ?? 1;
+    const fe2 = baieVitreeDI.fe2 ?? 1;
+
+    return (
+      baieVitreeDE.surface_totale_baie *
+      C1 *
+      (coeff || baieVitree.donnee_intermediaire.sw) *
+      fe1 *
+      fe2
+    );
+  }
+}

package/features/engine/domain/logement/surface-sud-equivalente.service.spec.js

@@ -0,0 +1,210 @@
+import corpus from '../../../../../test/corpus-sano.json';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { DpeNormalizerService } from '../../../normalizer/domain/dpe-normalizer.service.js';
+import { ContexteBuilder } from '../contexte.builder.js';
+import { SurfaceSudEquivalenteService } from './surface-sud-equivalente.service.js';
+import { getAdemeFileJson } from '../../../../../test/test-helpers.js';
+import { BaieVitreeTvStore } from '../../../dpe/infrastructure/baieVitreeTv.store.js';
+
+/** @type {SurfaceSudEquivalenteService} **/
+let service;
+
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
+/** @type {BaieVitreeTvStore} **/
+let tvStore;
+
+describe('Calcul de déperdition des portes', () => {
+  beforeEach(() => {
+    tvStore = new BaieVitreeTvStore();
+    service = new SurfaceSudEquivalenteService(tvStore);
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
+  });
+
+  describe('Determination de la surface sud équivalente pour une baie vitrée bv et pendant un mois donné', () => {
+    test.each([
+      {
+        enumOrientationId: 2,
+        enumInclinaisonVitrageId: 3,
+        fe1: 1,
+        fe2: 1,
+        sw: 0.2,
+        coeff: 1,
+        expected: 5
+      },
+      {
+        enumOrientationId: 2,
+        enumInclinaisonVitrageId: undefined,
+        fe1: 1,
+        fe2: 1,
+        sw: 0.2,
+        coeff: 1,
+        expected: 5
+      },
+      {
+        enumOrientationId: 2,
+        enumInclinaisonVitrageId: undefined,
+        fe1: 1,
+        fe2: 1,
+        sw: 0.2,
+        coeff: undefined,
+        expected: 1
+      },
+      {
+        enumOrientationId: 2,
+        enumInclinaisonVitrageId: 3,
+        fe1: 0.5,
+        fe2: 0.5,
+        sw: 0.2,
+        coeff: 1,
+        expected: 1.25
+      },
+      {
+        enumOrientationId: 2,
+        enumInclinaisonVitrageId: 3,
+        fe1: undefined,
+        fe2: undefined,
+        sw: 0.2,
+        coeff: 1,
+        expected: 5
+      }
+    ])(
+      'enumOrientationId: $enumOrientationId, enumInclinaisonVitrageId: $enumInclinaisonVitrageId, fe1: $fe1,' +
+        'fe2: $fe2, sw: $sw, coeff: $coeff',
+      ({
+        enumOrientationId,
+        enumInclinaisonVitrageId = undefined,
+        fe1,
+        fe2,
+        sw,
+        coeff = undefined,
+        expected
+      }) => {
+        vi.spyOn(tvStore, 'getCoefficientBaieVitree').mockReturnValue(0.5);
+
+        /** @type {BaieVitree} */
+        const baieVitree = {
+          donnee_entree: {
+            enum_orientation_id: enumOrientationId,
+            enum_inclinaison_vitrage_id: enumInclinaisonVitrageId,
+            surface_totale_baie: 10
+          },
+          donnee_intermediaire: { fe1, fe2, sw }
+        };
+
+        const ssd = service.ssdBaieMois(baieVitree, '1', 'Janvier', coeff);
+
+        if (enumInclinaisonVitrageId === undefined) {
+          enumInclinaisonVitrageId = 3;
+        }
+
+        expect(tvStore.getCoefficientBaieVitree).toHaveBeenCalledWith(
+          enumOrientationId,
+          enumInclinaisonVitrageId,
+          1,
+          'Janvier'
+        );
+        expect(ssd).toBe(expected);
+      }
+    );
+  });
+
+  describe('Determination de la surface sud équivalente des baies vitrées bv', () => {
+    test("Aucune pour les baies vitrées qui ne donnent pas sur l'extérieur", () => {
+      expect(service.execute({}, [])).toBe(0);
+
+      const baiesVitrees = [
+        {
+          donnee_entree: { enum_type_adjacence_id: 18 }
+        }
+      ];
+      expect(service.ssdMois({}, baiesVitrees, [], 'Janvier')).toBe(0);
+    });
+
+    test("Baies vitrées donnant sur l'extérieur", () => {
+      vi.spyOn(tvStore, 'getCoefficientBaieVitree').mockReturnValue(0.5);
+
+      /** @type {Contexte} */
+      const ctx = { zoneClimatique: { id: 1 } };
+      const baiesVitrees = [
+        {
+          donnee_entree: {
+            enum_type_adjacence_id: 1,
+            enum_orientation_id: 2,
+            surface_totale_baie: 10
+          },
+          donnee_intermediaire: { sw: 1 }
+        }
+      ];
+      expect(service.ssdMois(ctx, baiesVitrees, [], 'Janvier')).toBe(5);
+      expect(tvStore.getCoefficientBaieVitree).toHaveBeenCalledWith(2, 3, 1, 'Janvier');
+    });
+
+    test('Baies vitrées donnant sur un espace tampon solarisé', () => {
+      vi.spyOn(tvStore, 'getCoefficientBaieVitree').mockReturnValue(0.5);
+
+      /** @type {Contexte} */
+      const ctx = { zoneClimatique: { id: 1 } };
+      const baiesVitrees = [
+        {
+          donnee_entree: {
+            enum_type_adjacence_id: 10,
+            enum_orientation_id: 2,
+            surface_totale_baie: 10
+          },
+          donnee_intermediaire: { sw: 1 }
+        },
+        {
+          donnee_entree: {
+            enum_type_adjacence_id: 1,
+            enum_orientation_id: 2,
+            surface_totale_baie: 10
+          },
+          donnee_intermediaire: { sw: 1 }
+        }
+      ];
+      const ets = {
+        donnee_intermediaire: { bver: 0.6, coef_transparence_ets: 0.4 },
+        baie_ets_collection: {
+          baie_ets: {
+            donnee_entree: {
+              enum_inclinaison_vitrage_id: 3,
+              enum_orientation_id: 1,
+              surface_totale_baie: 7
+            }
+          }
+        }
+      };
+      expect(service.ssdMois(ctx, baiesVitrees, ets, 'Janvier')).toBe(6.5224);
+      expect(tvStore.getCoefficientBaieVitree).toHaveBeenCalledWith(2, 3, 1, 'Janvier');
+      expect(tvStore.getCoefficientBaieVitree).toHaveBeenCalledWith(1, 3, 1, 'Janvier');
+    });
+  });
+
+  describe("Test d'intégration pour surface sud équivalente", () => {
+    test.each(corpus)(
+      'vérification des DI de la surface sud équivalente pour dpe %s',
+      (ademeId) => {
+        /**
+         * @type {Dpe}
+         */
+        let dpeRequest = getAdemeFileJson(ademeId);
+        dpeRequest = normalizerService.normalize(dpeRequest);
+
+        /** @type {Contexte} */
+        const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+        const sse = service.execute(ctx, dpeRequest.logement.enveloppe);
+        expect(sse).toBeCloseTo(
+          dpeRequest.logement.sortie.apport_et_besoin.surface_sud_equivalente,
+          2
+        );
+      }
+    );
+  });
+});

package/features/engine/domain/models/contexte.model.ts

@@ -1,10 +1,15 @@
-import { TypeHabitation } from '../../../dpe/domain/models/dpe.model';
+import { TypeDpe, TypeHabitation } from '../../../dpe/domain/models/dpe.model';
 
 export interface Contexte {
   typeHabitation: TypeHabitation;
-  enumPeriodeConstructionId: string;
-  surfaceHabitable: string;
-  hauteurSousPlafond: string;
-  zoneClimatiqueId: string;
+  typeDpe: TypeDpe;
+  enumPeriodeConstructionId: number;
+  surfaceHabitable: number;
+  hauteurSousPlafond: number;
+  nombreAppartement: number;
+  zoneClimatique: {
+    id: string;
+    value: string;
+  };
   effetJoule: boolean;
 }

package/features/engine/domain/models/deperdition.model.ts

@@ -4,5 +4,5 @@ export interface DeperditionData {
   surfaceAue?: number;
   enumCfgIsolationLncId?: string;
   tvCoefReductionDeperditionId?: string;
-  zoneClimatiqueId?: string;
+  zoneClimatique?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open3cl/engine",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {

package/features/dpe/domain/models/plancher-haut.model.ts

@@ -1,33 +0,0 @@
-import { DE } from './dpe.model';
-
-export interface PlancherHaut {
-  donnee_entree?: PlancherHautDE;
-  donnee_intermediaire?: PlancherHautDI;
-}
-
-export interface PlancherHautDE extends DE {
-  reference_lnc?: string;
-  tv_coef_reduction_deperdition_id?: string; // TV
-  surface_aiu?: number;
-  surface_aue?: number;
-  enum_cfg_isolation_lnc_id?: string; // ENUM cfg_isolation_lnc
-  enum_type_adjacence_id?: string; // ENUM type_adjacence
-  surface_paroi_opaque?: number;
-  uph0_saisi?: number;
-  tv_uph0_id?: string; // TV
-  enum_type_plancher_haut_id?: string; // ENUM type_plancher_bas
-  enum_methode_saisie_u0_id?: string; // ENUM methode_saisie_u0
-  uph_saisi?: number;
-  enum_type_isolation_id?: string; // ENUM type_isolation
-  enum_periode_isolation_id?: string; // ENUM periode_isolation
-  resistance_isolation?: number;
-  epaisseur_isolation?: number;
-  tv_uph_id?: string; // TV
-  enum_methode_saisie_u_id?: string; // ENUM methode_saisie_u
-}
-
-export interface PlancherHautDI {
-  uph: number;
-  uph0: number;
-  b: number;
-}