@open3cl/engine 1.0.9 → 1.0.11

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

@@ -0,0 +1,168 @@
+import { mois_liste } from '../../../../utils.js';
+import { inject } from 'dioma';
+import { BaieVitreeTvStore } from '../../../dpe/infrastructure/enveloppe/baieVitreeTv.store.js';
+
+/**
+ * Calcul de 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) {
+    return mois_liste.reduce((acc, mois) => acc + this.ssdMois(ctx, enveloppe, mois), 0);
+  }
+
+  /**
+   * Calcul de la surface sud équivalente du logement pour un mois donné
+   *
+   * @param ctx {Contexte}
+   * @param enveloppe {Enveloppe}
+   * @param mois {string}
+   * @returns {number}
+   */
+  ssdMois(ctx, enveloppe, mois) {
+    const baiesVitrees = enveloppe.baie_vitree_collection?.baie_vitree || [];
+    let ets = enveloppe.ets_collection?.ets || [];
+
+    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/apport_et_besoin/surface-sud-equivalente.service.spec.js

@@ -0,0 +1,230 @@
+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/enveloppe/baieVitreeTv.store.js';
+
+/** @type {SurfaceSudEquivalenteService} **/
+let service;
+
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
+/** @type {BaieVitreeTvStore} **/
+let tvStore;
+
+describe('Calcul de la surface sud équivalente du logement', () => {
+  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);
+
+      /** @type {Enveloppe} */
+      const enveloppe = {
+        baie_vitree_collection: {
+          baie_vitree: [
+            {
+              donnee_entree: { enum_type_adjacence_id: 18 }
+            }
+          ]
+        }
+      };
+      expect(service.ssdMois({}, enveloppe, '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 } };
+
+      /** @type {Enveloppe} */
+      const enveloppe = {
+        baie_vitree_collection: {
+          baie_vitree: [
+            {
+              donnee_entree: {
+                enum_type_adjacence_id: 1,
+                enum_orientation_id: 2,
+                surface_totale_baie: 10
+              },
+              donnee_intermediaire: { sw: 1 }
+            }
+          ]
+        }
+      };
+      expect(service.ssdMois(ctx, enveloppe, '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 } };
+
+      /** @type {Enveloppe} */
+      const enveloppe = {
+        baie_vitree_collection: {
+          baie_vitree: [
+            {
+              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 }
+            }
+          ]
+        },
+        ets_collection: {
+          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, enveloppe, '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/contexte.builder.js

@@ -1,24 +1,84 @@
-import { TypeHabitation } from '../../dpe/domain/models/type-habitation.model.js';
+import { TypeDpe, TypeHabitation } from '../../dpe/domain/models/type-habitation.model.js';
+import enums from '../../../enums.js';
+import { NadeqService } from './logement/nadeq.service.js';
+import { inject } from 'dioma';
 
 /**
  * Génère un contexte du logement à étudier avec des données persistées durant l'analyse
  */
 export class ContexteBuilder {
-  constructor() {}
+  /**
+   * @type {NadeqService}
+   */
+  #nadeqService;
+
+  /**
+   * @param nadeqService {NadeqService}
+   */
+  constructor(nadeqService = inject(NadeqService)) {
+    this.#nadeqService = nadeqService;
+  }
 
   /**
    * @param dpe {Dpe}
    * @return {Contexte}
    */
   fromDpe(dpe) {
+    const caracteristiqueGenerale = dpe.logement.caracteristique_generale;
+
+    const typeDpe = this.#getTypeDpe(caracteristiqueGenerale);
+    const surfaceHabitable = this.#getSurfaceHabitable(caracteristiqueGenerale);
+    const inertieId = parseInt(dpe.logement.enveloppe?.inertie?.enum_classe_inertie_id);
+
     return {
-      zoneClimatiqueId: dpe.logement.meteo?.enum_zone_climatique_id.toString(),
-      typeHabitation: this.#getTypeHabitation(dpe),
-      enumPeriodeConstructionId:
-        dpe.logement.caracteristique_generale.enum_periode_construction_id?.toString(),
+      zoneClimatique: this.#zoneClimatique(dpe),
+      altitude: this.#altitude(dpe),
+      typeHabitation: this.#getTypeHabitation(caracteristiqueGenerale),
+      typeDpe: typeDpe,
+      enumPeriodeConstructionId: caracteristiqueGenerale.enum_periode_construction_id?.toString(),
       effetJoule: this.#hasEffetJoule(dpe),
-      surfaceHabitable: this.#getSurfaceHabitable(dpe),
-      hauteurSousPlafond: dpe.logement.caracteristique_generale.hsp
+      surfaceHabitable: surfaceHabitable,
+      hauteurSousPlafond: caracteristiqueGenerale.hsp,
+      nombreAppartement: caracteristiqueGenerale.nombre_appartement,
+      nadeq: this.#nadeqService.execute(
+        typeDpe,
+        surfaceHabitable,
+        caracteristiqueGenerale.nombre_appartement
+      ),
+      inertie: {
+        id: inertieId,
+        ilpa:
+          parseInt(dpe.logement.meteo?.batiment_materiaux_anciens) === 1 &&
+          [1, 2].includes(inertieId)
+            ? 1
+            : 0
+      }
+    };
+  }
+
+  /**
+   * La zone climatique à partir du type de DPE
+   * @param dpe {Dpe}
+   * @return {{id: string, value: string}}
+   */
+  #zoneClimatique(dpe) {
+    const zoneClimatiqueId = parseInt(dpe.logement.meteo?.enum_zone_climatique_id);
+    return {
+      id: zoneClimatiqueId.toString(),
+      value: enums.zone_climatique[zoneClimatiqueId]
+    };
+  }
+
+  /**
+   * La classe d'altitude à partir du type de DPE
+   * @param dpe {Dpe}
+   * @return {{id: string, value: string}}
+   */
+  #altitude(dpe) {
+    const altitudeId = parseInt(dpe.logement.meteo?.enum_classe_altitude_id);
+    return {
+      id: altitudeId.toString(),
+      value: enums.classe_altitude[altitudeId]
     };
   }
 
@@ -39,43 +99,20 @@ export class ContexteBuilder {
 
   /**
    * Le type d'habitation est détecté à partir du type de DPE
-   * @param dpe {Dpe}
+   * @param caracteristiqueGenerale {CaracteristiqueGenerale}
    * @return {TypeHabitation}
    */
-  #getTypeHabitation(dpe) {
-    const methodeApplication =
-      dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id;
+  #getTypeHabitation(caracteristiqueGenerale) {
+    const methodeApplication = parseInt(
+      caracteristiqueGenerale.enum_methode_application_dpe_log_id
+    );
 
-    if (['1', '14', '18'].includes(methodeApplication)) {
+    if ([1, 14, 18].includes(methodeApplication)) {
       return TypeHabitation.MAISON;
     } else if (
       [
-        '2',
-        '3',
-        '4',
-        '5',
-        '10',
-        '11',
-        '12',
-        '13',
-        '15',
-        '16',
-        '19',
-        '20',
-        '22',
-        '23',
-        '24',
-        '25',
-        '31',
-        '32',
-        '33',
-        '34',
-        '35',
-        '36',
-        '37',
-        '38',
-        '39',
-        '40'
+        2, 3, 4, 5, 10, 11, 12, 13, 15, 16, 19, 20, 22, 23, 24, 25, 31, 32, 33, 34, 35, 36, 37, 38,
+        39, 40
       ].includes(methodeApplication)
     ) {
       return TypeHabitation.APPARTEMENT;
@@ -84,10 +121,28 @@ export class ContexteBuilder {
   }
 
   /**
-   * @param dpe {Dpe}
+   * Le type de DPE est détecté à partir du type de DPE
+   * @param caracteristiqueGenerale {CaracteristiqueGenerale}
+   * @return {TypeDpe}
+   */
+  #getTypeDpe(caracteristiqueGenerale) {
+    const methodeApplication = parseInt(
+      caracteristiqueGenerale.enum_methode_application_dpe_log_id
+    );
+
+    if ([1, 14, 18].includes(methodeApplication)) {
+      return TypeDpe.MAISON;
+    } else if ([2, 3, 4, 5, 31, 32, 35, 36, 37].includes(methodeApplication)) {
+      return TypeDpe.APPARTEMENT;
+    }
+    return TypeDpe.IMMEUBLE;
+  }
+
+  /**
+   * @param caracteristiqueGenerale {CaracteristiqueGenerale}
    * @return {number}
    */
-  #getSurfaceHabitable(dpe) {
+  #getSurfaceHabitable(caracteristiqueGenerale) {
     /**
      * Certains DPE appartement sont générés à partir des données du DPE immeuble, la surface à prendre en compte est
      * celle de l'immeuble pour les besoins ECS
@@ -110,31 +165,15 @@ export class ContexteBuilder {
      * 40 - dpe appartement généré à partir des données DPE immeuble chauffage collectif ecs mixte (collectif-individuel)
      */
     if (
-      [
-        '10',
-        '11',
-        '12',
-        '13',
-        '15',
-        '16',
-        '19',
-        '20',
-        '22',
-        '23',
-        '24',
-        '25',
-        '33',
-        '34',
-        '38',
-        '39',
-        '40'
-      ].includes(dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id)
+      [10, 11, 12, 13, 15, 16, 19, 20, 22, 23, 24, 25, 33, 34, 38, 39, 40].includes(
+        parseInt(caracteristiqueGenerale.enum_methode_application_dpe_log_id)
+      )
     ) {
-      return dpe.logement.caracteristique_generale.surface_habitable_immeuble;
+      return caracteristiqueGenerale.surface_habitable_immeuble;
     }
 
-    return this.#getTypeHabitation(dpe) === TypeHabitation.IMMEUBLE
-      ? dpe.logement.caracteristique_generale.surface_habitable_immeuble
-      : dpe.logement.caracteristique_generale.surface_habitable_logement;
+    return this.#getTypeHabitation(caracteristiqueGenerale) === TypeHabitation.IMMEUBLE
+      ? caracteristiqueGenerale.surface_habitable_immeuble
+      : caracteristiqueGenerale.surface_habitable_logement;
   }
 }