@open3cl/engine 1.0.10 → 1.0.11

package/features/dpe/infrastructure/ecs/ecsTv.store.js

@@ -0,0 +1,22 @@
+import { tvs as tv } from '../../../../tv-v2.js';
+import { TvStore } from './../tv.store.js';
+
+/**
+ * Accès aux données des tables de valeurs pour le besoin en eau chaude sanitaire
+ */
+export class EcsTvStore extends TvStore {
+  /**
+   * Température moyenne d’eau froide sanitaire sur le mois j (°C).
+   * La température d’eau froide est une donnée climatique mensuelle pour chacune des 8 zones climatiques
+   * @see 11.1 Calcul du besoin d’ECS : Tefs
+   *
+   * @param classeAltitude {string}
+   * @param zoneClimatique {string}
+   * @param mois {string}
+   *
+   * @return {number|undefined}
+   */
+  getTefs(classeAltitude, zoneClimatique, mois) {
+    return tv['tefs'][classeAltitude][mois][zoneClimatique];
+  }
+}

package/features/dpe/infrastructure/ecs/ecsTv.store.spec.js

@@ -0,0 +1,33 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import { EcsTvStore } from './ecsTv.store.js';
+
+/** @type {EcsTvStore} **/
+let ecsTvStore;
+
+describe('Lecture des tables de valeurs', () => {
+  beforeEach(() => {
+    ecsTvStore = new EcsTvStore();
+  });
+
+  describe('Lecture des valeurs de tefs', () => {
+    test.each([
+      {
+        label: 'température moyenne eau froide sanitaire en janvier sur zone h1a inférieure à 400m',
+        classeAltitude: 'inférieur à 400m',
+        zoneClimatique: 'h1a',
+        mois: 'Janvier',
+        expected: 7.8
+      },
+      {
+        label:
+          'température moyenne eau froide sanitaire en Décembre sur zone h3 inférieure entre 400-800m',
+        classeAltitude: '400-800m',
+        zoneClimatique: 'h3',
+        mois: 'Décembre',
+        expected: 10.1
+      }
+    ])(`$label`, ({ classeAltitude, zoneClimatique, mois, expected }) => {
+      expect(ecsTvStore.getTefs(classeAltitude, zoneClimatique, mois)).toBe(expected);
+    });
+  });
+});

package/features/dpe/infrastructure/{baieVitreeTv.store.js → enveloppe/baieVitreeTv.store.js}

@@ -1,8 +1,8 @@
-import { tvs as tv } from '../../../tv-v2.js';
-import { getRange } from '../../../utils.js';
-import { logger } from '../../../core/util/logger/log-service.js';
-import { TvStore } from './tv.store.js';
-import enums from '../../../enums.js';
+import { tvs as tv } from '../../../../tv-v2.js';
+import { getRange } from '../../../../utils.js';
+import { logger } from '../../../../core/util/logger/log-service.js';
+import { TvStore } from './../tv.store.js';
+import enums from '../../../../enums.js';
 
 /**
  * Accès aux données des tables de valeurs pour les baies vitrées

package/features/dpe/infrastructure/{pontThermiqueTv.store.js → enveloppe/pontThermiqueTv.store.js}

@@ -1,6 +1,6 @@
-import { tvs as tv } from '../../../tv-v2.js';
-import { logger } from '../../../core/util/logger/log-service.js';
-import { TvStore } from './tv.store.js';
+import { tvs as tv } from '../../../../tv-v2.js';
+import { logger } from '../../../../core/util/logger/log-service.js';
+import { TvStore } from './../tv.store.js';
 
 /**
  * Accès aux données des tables de valeurs pour les baies vitrées

package/features/dpe/infrastructure/froid/frTv.store.js

@@ -0,0 +1,36 @@
+import { tvs as tv } from '../../../../tv-v2.js';
+import { TvStore } from './../tv.store.js';
+
+/**
+ * Accès aux données des tables de valeurs pour le besoin en froid
+ */
+export class FrTvStore extends TvStore {
+  /**
+   * Recherche des valeurs nécessaires au calcul du besoin en froid
+   * @see 10.2 Calcul du besoin mensuel de froid
+   * — e : nombre d’heures de chauffage pour un mois donné et une consigne de refroidissement à 26°C (comportement dépensier).
+   * — nref26 : nombre d’heures de chauffage pour un mois donné et une consigne de refroidissement à 26°C (comportement dépensier).
+   * — nref28 : nombre d’heures de chauffage pour un mois donné et une consigne de refroidissement à 28°C (comportement conventionnel).
+   * — e_fr_26 : ensoleillement reçu en période de refroidissement pour un mois donné et une consigne de refroidissement à 26°C (comportement conventionnel).
+   * — e_fr_28 : ensoleillement reçu en période de refroidissement pour un mois donné et une consigne de refroidissement à 28°C (comportement conventionnel).
+   * — textmoy_clim_26 : Température extérieure moyenne pour un mois donné et une consigne de refroidissement à 26°C (comportement conventionnel).
+   * — textmoy_clim_28 : nombre d’heures de chauffage pour un mois donné et une consigne de refroidissement à 28°C (comportement conventionnel).
+   *
+   * @param type {'e', nref26' | 'nref28' | 'e_fr_26' | 'e_fr_28' | 'textmoy_clim_26' | 'textmoy_clim_28'}
+   * @param classeAltitude {string}
+   * @param zoneClimatique {string}
+   * @param mois {string}
+   * @param ilpa {number|undefined} 1 si bien à inertie lourde, 0 sinon
+   *
+   * @return {number|undefined}
+   */
+  getData(type, classeAltitude, zoneClimatique, mois, ilpa = undefined) {
+    let values = tv[type];
+
+    if (ilpa !== undefined) {
+      values = values[ilpa];
+    }
+
+    return values[classeAltitude][mois][zoneClimatique];
+  }
+}

package/features/dpe/infrastructure/froid/frTv.store.spec.js

@@ -0,0 +1,52 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import { FrTvStore } from './frTv.store.js';
+
+/** @type {FrTvStore} **/
+let tvStore;
+
+describe('Lecture des tables de valeurs', () => {
+  beforeEach(() => {
+    tvStore = new FrTvStore();
+  });
+
+  describe('lecture des valeurs par zone climatique et altitude', () => {
+    test.each([
+      {
+        type: 'e',
+        ilpa: 1,
+        expected: 60.45
+      },
+      {
+        type: 'e',
+        ilpa: 0,
+        expected: 84.66
+      },
+      {
+        type: 'nref26',
+        expected: 5.98
+      },
+      {
+        type: 'nref28',
+        expected: 1.14
+      },
+      {
+        type: 'e_fr_26',
+        expected: 5.98
+      },
+      {
+        type: 'e_fr_28',
+        expected: 1.14
+      },
+      {
+        type: 'textmoy_clim_26',
+        expected: 28.4
+      },
+      {
+        type: 'textmoy_clim_28',
+        expected: 28.4
+      }
+    ])(`type: $type, ilpa: $ilpa`, ({ type, ilpa = undefined, expected }) => {
+      expect(tvStore.getData(type, '400-800m', 'h1a', 'Juin', ilpa)).toBe(expected);
+    });
+  });
+});

package/features/engine/domain/apport_et_besoin/apport-et-besoin.service.js

@@ -0,0 +1,74 @@
+import { inject } from 'dioma';
+import { BesoinEcsService } from './ecs/besoin-ecs.service.js';
+import { SurfaceSudEquivalenteService } from './surface-sud-equivalente.service.js';
+import { BesoinFroidService } from './froid/besoin-froid.service.js';
+import { ApportGratuitService } from './apport_gratuit/apport-gratuit.service.js';
+
+/**
+ * Calcul des déperditions de l’enveloppe GV
+ * @see Méthode de calcul 3CL-DPE 2021 (cotobre 2021) chapitre 3
+ */
+export class ApportEtBesoinService {
+  /**
+   * @type {SurfaceSudEquivalenteService}
+   */
+  #surfaceSudEquivalenteService;
+
+  /**
+   * @type {BesoinEcsService}
+   */
+  #besoinEcsService;
+
+  /**
+   * @type {BesoinFroidService}
+   */
+  #besoinFroidService;
+
+  /**
+   * @type {ApportGratuitService}
+   */
+  #apportGratuitService;
+
+  /**
+   * @param besoinEcsService {BesoinEcsService}
+   * @param besoinFroidService {BesoinFroidService}
+   * @param surfaceSudEquivalenteService {SurfaceSudEquivalenteService}
+   * @param apportGratuitService {ApportGratuitService}
+   */
+  constructor(
+    besoinEcsService = inject(BesoinEcsService),
+    besoinFroidService = inject(BesoinFroidService),
+    surfaceSudEquivalenteService = inject(SurfaceSudEquivalenteService),
+    apportGratuitService = inject(ApportGratuitService)
+  ) {
+    this.#besoinEcsService = besoinEcsService;
+    this.#besoinFroidService = besoinFroidService;
+    this.#surfaceSudEquivalenteService = surfaceSudEquivalenteService;
+    this.#apportGratuitService = apportGratuitService;
+  }
+
+  /**
+   * Détermination des apports et besoins pour le bien concerné
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @return {ApportEtBesoin}
+   */
+  execute(ctx, logement) {
+    return {
+      ...this.#besoinEcsService.execute(ctx),
+      ...{
+        surface_sud_equivalente: this.#surfaceSudEquivalenteService.execute(
+          ctx,
+          logement.enveloppe
+        ),
+        nadeq: ctx.nadeq,
+        v40_ecs_journalier: ctx.nadeq * 56,
+        v40_ecs_journalier_depensier: ctx.nadeq * 79
+      },
+      ...this.#besoinFroidService.execute(ctx, logement),
+      ...this.#apportGratuitService.apportInterne(ctx, logement),
+      ...this.#apportGratuitService.apportSolaire(ctx, logement)
+    };
+  }
+}

package/features/engine/domain/apport_et_besoin/apport-et-besoin.service.spec.js

@@ -0,0 +1,85 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { SurfaceSudEquivalenteService } from './surface-sud-equivalente.service.js';
+import { BaieVitreeTvStore } from '../../../dpe/infrastructure/enveloppe/baieVitreeTv.store.js';
+import { ApportEtBesoinService } from './apport-et-besoin.service.js';
+import { BesoinEcsService } from './ecs/besoin-ecs.service.js';
+import { BesoinFroidService } from './froid/besoin-froid.service.js';
+import { ApportGratuitService } from './apport_gratuit/apport-gratuit.service.js';
+
+/** @type {SurfaceSudEquivalenteService} **/
+let surfaceSudEquivalenteService;
+
+/** @type {BesoinEcsService} **/
+let besoinEcsService;
+
+/** @type {BesoinFroidService} **/
+let besoinFroidService;
+
+/** @type {ApportGratuitService} **/
+let apportGratuitService;
+
+/** @type {ApportEtBesoinService} **/
+let service;
+
+/** @type {BaieVitreeTvStore} **/
+let tvStore;
+
+describe('Calcul des apports et besoin du logement', () => {
+  beforeEach(() => {
+    tvStore = new BaieVitreeTvStore();
+    surfaceSudEquivalenteService = new SurfaceSudEquivalenteService(tvStore);
+    besoinEcsService = new BesoinEcsService();
+    besoinFroidService = new BesoinFroidService();
+    apportGratuitService = new ApportGratuitService();
+    service = new ApportEtBesoinService(
+      besoinEcsService,
+      besoinFroidService,
+      surfaceSudEquivalenteService,
+      apportGratuitService
+    );
+  });
+
+  test('Determination des apports et besoin du logement', () => {
+    vi.spyOn(surfaceSudEquivalenteService, 'execute').mockReturnValue(18.5);
+    vi.spyOn(besoinEcsService, 'execute').mockReturnValue({
+      besoin_ecs: 1526,
+      besoin_ecs_depensier: 2685.3
+    });
+    vi.spyOn(besoinFroidService, 'execute').mockReturnValue({
+      besoin_fr: 896,
+      besoin_fr_depensier: 1025.3
+    });
+    vi.spyOn(apportGratuitService, 'apportSolaire').mockReturnValue({
+      apport_solaire_ch: 5236.9,
+      apport_solaire_fr: 145.2
+    });
+    vi.spyOn(apportGratuitService, 'apportInterne').mockReturnValue({
+      apport_interne_ch: 1236.9,
+      apport_interne_fr: 3345.2
+    });
+
+    /** @type {Contexte} */
+    const ctx = { zoneClimatique: { id: 1 }, nadeq: 2.5 };
+    /** @type { Logement } **/
+    const logement = { enveloppe: {} };
+    expect(service.execute(ctx, logement)).toStrictEqual({
+      surface_sud_equivalente: 18.5,
+      besoin_ecs: 1526,
+      besoin_ecs_depensier: 2685.3,
+      besoin_fr: 896,
+      besoin_fr_depensier: 1025.3,
+      apport_solaire_ch: 5236.9,
+      apport_solaire_fr: 145.2,
+      apport_interne_ch: 1236.9,
+      apport_interne_fr: 3345.2,
+      nadeq: 2.5,
+      v40_ecs_journalier: 140,
+      v40_ecs_journalier_depensier: 197.5
+    });
+    expect(surfaceSudEquivalenteService.execute).toHaveBeenCalledWith(ctx, logement.enveloppe);
+    expect(besoinEcsService.execute).toHaveBeenCalledWith(ctx);
+    expect(besoinFroidService.execute).toHaveBeenCalledWith(ctx, logement);
+    expect(apportGratuitService.apportSolaire).toHaveBeenCalledWith(ctx, logement);
+    expect(apportGratuitService.apportInterne).toHaveBeenCalledWith(ctx, logement);
+  });
+});

package/features/engine/domain/apport_et_besoin/apport_gratuit/apport-gratuit.service.js

@@ -0,0 +1,134 @@
+import { inject } from 'dioma';
+import { SurfaceSudEquivalenteService } from '../surface-sud-equivalente.service.js';
+import { mois_liste } from '../../../../../utils.js';
+import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
+
+/**
+ * Calcul des apports gratuits
+ * Chapitre 6 Détermination des apports gratuits
+ *
+ * Methode_de_calcul_3CL_DPE_2021 - Page 42
+ * Octobre 2021
+ * @see consolide_anne…arrete_du_31_03_2021_relatif_aux_methodes_et_procedures_applicables.pdf
+ */
+export class ApportGratuitService {
+  /**
+   * @type {FrTvStore}
+   */
+  #frTvStore;
+
+  /**
+   * @type {SurfaceSudEquivalenteService}
+   */
+  #surfaceSudEquivalenteService;
+
+  /**
+   * @param frTvStore {FrTvStore}
+   * @param surfaceSudEquivalenteService {SurfaceSudEquivalenteService}
+   */
+  constructor(
+    frTvStore = inject(FrTvStore),
+    surfaceSudEquivalenteService = inject(SurfaceSudEquivalenteService)
+  ) {
+    this.#frTvStore = frTvStore;
+    this.#surfaceSudEquivalenteService = surfaceSudEquivalenteService;
+  }
+
+  /**
+   * Apports solaires gratuits du logement
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @returns {number}
+   */
+  apportSolaire(ctx, logement) {
+    const clim = logement.climatisation_collection?.climatisation || [];
+
+    return mois_liste.reduce(
+      (acc, mois) => {
+        acc.apport_solaire_ch += this.apportSolaireMois(
+          ctx,
+          logement.enveloppe,
+          mois,
+          this.#frTvStore.getData(
+            'e',
+            ctx.altitude.value,
+            ctx.zoneClimatique.value,
+            mois,
+            ctx.inertie.ilpa
+          )
+        );
+        if (clim.length > 0) {
+          acc.apport_solaire_fr += this.apportSolaireMois(
+            ctx,
+            logement.enveloppe,
+            mois,
+            this.#frTvStore.getData('e_fr_28', ctx.altitude.value, ctx.zoneClimatique.value, mois)
+          );
+        }
+        return acc;
+      },
+      { apport_solaire_ch: 0, apport_solaire_fr: 0 }
+    );
+  }
+
+  /**
+   * Apports internes gratuits du logement
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @returns {number}
+   */
+  apportInterne(ctx, logement) {
+    const clim = logement.climatisation_collection?.climatisation || [];
+
+    return mois_liste.reduce(
+      (acc, mois) => {
+        acc.apport_interne_ch += this.apportInterneMois(
+          ctx,
+          this.#frTvStore.getData(
+            'nref19',
+            ctx.altitude.value,
+            ctx.zoneClimatique.value,
+            mois,
+            ctx.inertie.ilpa
+          )
+        );
+        if (clim.length > 0) {
+          acc.apport_interne_fr += this.apportInterneMois(
+            ctx,
+            this.#frTvStore.getData('nref28', ctx.altitude.value, ctx.zoneClimatique.value, mois)
+          );
+        }
+        return acc;
+      },
+      { apport_interne_ch: 0, apport_interne_fr: 0 }
+    );
+  }
+
+  /**
+   * Apports solaires pour un mois donné
+   *
+   * @param ctx {Contexte}
+   * @param enveloppe {Enveloppe}
+   * @param mois {string}
+   * @param e {number} ensoleillement reçu, pour le mois, par une paroi verticale orientée au sud en absence d'ombrage (kWh/m²)
+   * @returns {number}
+   */
+  apportSolaireMois(ctx, enveloppe, mois, e) {
+    return 1000 * this.#surfaceSudEquivalenteService.ssdMois(ctx, enveloppe, mois) * e;
+  }
+
+  /**
+   * Apports internes dans le logement pour un mois donné
+   * Les apports internes de chaleur dus aux équipements prennent en compte l’ensemble des équipements
+   * « mobiliers » (cuisson, audiovisuel, informatique, lavage, froid, appareils ménagers)
+   *
+   * @param ctx {Contexte}
+   * @param nref {number} nombre d’heures de chauffage pour le mois
+   * @returns {number}
+   */
+  apportInterneMois(ctx, nref) {
+    return ((3.18 + 0.34) * ctx.surfaceHabitable + 90 * (132 / 168) * ctx.nadeq) * nref;
+  }
+}

package/features/engine/domain/apport_et_besoin/apport_gratuit/apport-gratuit.service.spec.js

@@ -0,0 +1,167 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { SurfaceSudEquivalenteService } from './../surface-sud-equivalente.service.js';
+import { ApportGratuitService } from './apport-gratuit.service.js';
+import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
+import { mois_liste } from '../../../../../utils.js';
+
+/** @type {FrTvStore} **/
+let frTvStore;
+
+/** @type {SurfaceSudEquivalenteService} **/
+let surfaceSudEquivalenteService;
+
+/** @type {ApportGratuitService} **/
+let service;
+
+describe('Calcul des apports gratuits au logement', () => {
+  beforeEach(() => {
+    frTvStore = new FrTvStore();
+    surfaceSudEquivalenteService = new SurfaceSudEquivalenteService();
+    service = new ApportGratuitService(frTvStore, surfaceSudEquivalenteService);
+  });
+
+  test.each([
+    {
+      label: 'avec climatisation',
+      withClimatisation: true
+    },
+    {
+      label: 'sans climatisation',
+      withClimatisation: false
+    }
+  ])('Determination des apports gratuits pour un logement $label', ({ withClimatisation }) => {
+    vi.spyOn(surfaceSudEquivalenteService, 'ssdMois').mockReturnValue(18.5);
+    vi.spyOn(frTvStore, 'getData').mockReturnValue(10);
+
+    /** @type {Contexte} */
+    const ctx = {
+      zoneClimatique: { value: 'h1a' },
+      altitude: { value: '400-800m' },
+      inertie: { ilpa: 1 }
+    };
+
+    /** @type { Logement } **/
+    const logement = { enveloppe: { porte_collection: {} } };
+
+    if (withClimatisation) {
+      logement.climatisation_collection = { climatisation: [{}] };
+    }
+
+    expect(service.apportSolaire(ctx, logement)).toStrictEqual({
+      apport_solaire_ch: 2220000,
+      apport_solaire_fr: withClimatisation ? 2220000 : 0
+    });
+    expect(surfaceSudEquivalenteService.ssdMois).toHaveBeenCalledWith(
+      ctx,
+      logement.enveloppe,
+      'Janvier'
+    );
+
+    for (const mois of mois_liste) {
+      expect(frTvStore.getData).toHaveBeenCalledWith(
+        'e',
+        ctx.altitude.value,
+        ctx.zoneClimatique.value,
+        mois,
+        ctx.inertie.ilpa
+      );
+
+      if (withClimatisation) {
+        expect(frTvStore.getData).toHaveBeenCalledWith(
+          'e_fr_28',
+          ctx.altitude.value,
+          ctx.zoneClimatique.value,
+          mois
+        );
+      } else {
+        expect(frTvStore.getData).not.toHaveBeenCalledWith(
+          'e_fr_28',
+          ctx.altitude.value,
+          ctx.zoneClimatique.value,
+          mois
+        );
+      }
+    }
+  });
+
+  test.each([
+    {
+      label: 'avec climatisation',
+      withClimatisation: true
+    },
+    {
+      label: 'sans climatisation',
+      withClimatisation: false
+    }
+  ])('Determination des apports internes pour un logement $label', ({ withClimatisation }) => {
+    vi.spyOn(frTvStore, 'getData').mockReturnValue(10);
+
+    /** @type {Contexte} */
+    const ctx = {
+      zoneClimatique: { value: 'h1a' },
+      altitude: { value: '400-800m' },
+      inertie: { ilpa: 1 },
+      surfaceHabitable: 12,
+      nadeq: 1.25
+    };
+
+    /** @type { Logement } **/
+    const logement = { enveloppe: { porte_collection: {} } };
+
+    if (withClimatisation) {
+      logement.climatisation_collection = { climatisation: [{}] };
+    }
+
+    expect(service.apportInterne(ctx, logement)).toStrictEqual({
+      apport_interne_ch: 15675.94285714286,
+      apport_interne_fr: withClimatisation ? 15675.94285714286 : 0
+    });
+
+    for (const mois of mois_liste) {
+      expect(frTvStore.getData).toHaveBeenCalledWith(
+        'nref19',
+        ctx.altitude.value,
+        ctx.zoneClimatique.value,
+        mois,
+        ctx.inertie.ilpa
+      );
+
+      if (withClimatisation) {
+        expect(frTvStore.getData).toHaveBeenCalledWith(
+          'nref28',
+          ctx.altitude.value,
+          ctx.zoneClimatique.value,
+          mois
+        );
+      } else {
+        expect(frTvStore.getData).not.toHaveBeenCalledWith(
+          'nref28',
+          ctx.altitude.value,
+          ctx.zoneClimatique.value,
+          mois
+        );
+      }
+    }
+  });
+
+  test('Determination des apports solaires pour un mois donné', () => {
+    vi.spyOn(surfaceSudEquivalenteService, 'ssdMois').mockReturnValue(18.5);
+
+    /** @type {Contexte} */
+    const ctx = { zoneClimatique: { id: 1 } };
+
+    /** @type { Enveloppe } **/
+    const enveloppe = {
+      porte_collection: {}
+    };
+    expect(service.apportSolaireMois(ctx, enveloppe, 'Janvier', 18)).toBe(333000);
+    expect(surfaceSudEquivalenteService.ssdMois).toHaveBeenCalledWith(ctx, enveloppe, 'Janvier');
+  });
+
+  test('Determination des apports internes dans le logement pour un mois donné', () => {
+    /** @type {Contexte} */
+    const ctx = { surfaceHabitable: 88, nadeq: 2 };
+
+    expect(service.apportInterneMois(ctx, 18)).toBeCloseTo(8121.39, 2);
+  });
+});

package/features/engine/domain/apport_et_besoin/ecs/besoin-ecs.service.js

@@ -0,0 +1,58 @@
+import { mois_liste, Njj } from '../../../../../utils.js';
+import { EcsTvStore } from '../../../../dpe/infrastructure/ecs/ecsTv.store.js';
+import { inject } from 'dioma';
+
+/**
+ * Calcul du besoin en eau chaude sanitaire
+ * 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 BesoinEcsService {
+  /**
+   * @type {EcsTvStore}
+   */
+  #tvStore;
+
+  /**
+   * @param tvStore {EcsTvStore}
+   */
+  constructor(tvStore = inject(EcsTvStore)) {
+    this.#tvStore = tvStore;
+  }
+
+  /**
+   * @param ctx {Contexte}
+   * @return {{besoin_ecs: number, besoin_ecs_depensier: number}}
+   */
+  execute(ctx) {
+    return mois_liste.reduce(
+      (acc, mois) => {
+        acc.besoin_ecs += this.besoinEcsMois(ctx, mois, false);
+        acc.besoin_ecs_depensier += this.besoinEcsMois(ctx, mois, true);
+        return acc;
+      },
+      { besoin_ecs: 0, besoin_ecs_depensier: 0 }
+    );
+  }
+
+  /**
+   * Calcul du besoin ecs pour un mois donné
+   *
+   * @param ctx {Contexte}
+   * @param mois {string}
+   * @param depensier {boolean}
+   * @returns {number}
+   */
+  besoinEcsMois(ctx, mois, depensier) {
+    const tefs = this.#tvStore.getTefs(ctx.altitude.value, ctx.zoneClimatique.value, mois);
+
+    if (depensier) {
+      return (1.163 * ctx.nadeq * 79 * (40 - tefs) * Njj[mois]) / 1000;
+    } else {
+      return (1.163 * ctx.nadeq * 56 * (40 - tefs) * Njj[mois]) / 1000;
+    }
+  }
+}