@open3cl/engine 1.0.9 → 1.0.11

package/features/dpe/domain/models/type-habitation.model.js

@@ -6,3 +6,11 @@ export const TypeHabitation = {
   APPARTEMENT: 'APPARTEMENT',
   IMMEUBLE: 'IMMEUBLE'
 };
+/**
+ * @type {{[key: string]: string}}
+ */
+export const TypeDpe = {
+  MAISON: 'MAISON',
+  APPARTEMENT: 'APPARTEMENT',
+  IMMEUBLE: 'IMMEUBLE'
+};

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,7 +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 { 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
@@ -289,4 +290,73 @@ export class BaieVitreeTvStore extends TvStore {
 
     return parseFloat(fe2);
   }
+
+  /**
+   * Calcul des coefficients de réduction de température des espaces tampons
+   *
+   * @param zoneClimatique {string}
+   * @param enumCfgIsolationLncId {number}
+   * @return {number|undefined}
+   */
+  getBver(zoneClimatique, enumCfgIsolationLncId) {
+    const bver = tv['coef_reduction_deperdition'].find(
+      (v) =>
+        zoneClimatique.toLowerCase().startsWith(v.zone_climatique?.toLowerCase()) &&
+        parseInt(v.enum_cfg_isolation_lnc_id) === parseInt(enumCfgIsolationLncId)
+    )?.b;
+
+    if (!bver) {
+      logger.error(
+        `Pas de valeur b pour zoneClimatique:${zoneClimatique}, enumCfgIsolationLncId:${enumCfgIsolationLncId}`
+      );
+      return;
+    }
+
+    return parseFloat(bver);
+  }
+
+  /**
+   * Calcul des coefficients de transparence des espaces tampons
+   *
+   * @param tvCoefTransparenceEtsId {number}
+   * @return {number|undefined}
+   */
+  getCoefTransparenceEts(tvCoefTransparenceEtsId) {
+    const coefTransparence = tv['coef_transparence_ets'].find(
+      (v) => parseInt(v.tv_coef_transparence_ets_id) === parseInt(tvCoefTransparenceEtsId)
+    )?.coef_transparence_ets;
+
+    if (!coefTransparence) {
+      logger.error(
+        `Pas de valeur coef_transparence_ets pour tvCoefTransparenceEtsId:${tvCoefTransparenceEtsId}`
+      );
+      return;
+    }
+
+    return parseFloat(coefTransparence);
+  }
+
+  /**
+   * @see 18.5 - Coefficients d’orientation et d’inclinaison des parois vitrées : C1
+   *
+   * @param enumOrientationId {number}
+   * @param enumInclinaisonVitrageId {number}
+   * @param zoneClimatiqueId {number}
+   * @param mois {string}
+   *
+   * @return {number|undefined}
+   */
+  getCoefficientBaieVitree(enumOrientationId, enumInclinaisonVitrageId, zoneClimatiqueId, mois) {
+    const orientation = enums.orientation[enumOrientationId];
+    const inclinaison = enums.inclinaison_vitrage[enumInclinaisonVitrageId];
+    const zoneClimatique = enums.zone_climatique[zoneClimatiqueId];
+
+    const c1ZoneClimatique = tv['c1'][zoneClimatique][mois];
+
+    if (inclinaison === 'horizontal') {
+      return c1ZoneClimatique[inclinaison];
+    }
+
+    return c1ZoneClimatique[`${orientation} ${inclinaison}`];
+  }
 }

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

@@ -345,6 +345,112 @@ describe('Lecture des tables de valeurs', () => {
     });
   });
 
+  describe('lecture des valeurs coefficients de réduction de température des espaces tampons', () => {
+    test.each([
+      {
+        label: 'lc non isolé + espace tampon solarisé orienté nord',
+        zoneClimatique: 'H1a',
+        enumCfgIsolationLncId: '9',
+        expected: 0.85
+      },
+      {
+        label: 'lc isolé + espace tampon solarisé orienté sud',
+        zoneClimatique: 'H2C',
+        enumCfgIsolationLncId: '7',
+        expected: 0.57
+      }
+    ])(
+      `incidence masque proche pour baie vitrée $label`,
+      ({ zoneClimatique, enumCfgIsolationLncId, expected }) => {
+        expect(tvStore.getBver(zoneClimatique, enumCfgIsolationLncId)).toBe(expected);
+      }
+    );
+
+    test('pas de valeur de coefficients de réduction de température', () => {
+      const ug = tvStore.getBver('h3C', 1);
+      expect(ug).toBeUndefined();
+    });
+  });
+
+  describe('lecture des valeurs de coefficients de transparence des espaces tampons', () => {
+    test.each([
+      {
+        label: 'Parois en polycarbonate',
+        tvCoefTransparenceEtsId: '9',
+        expected: 0.39
+      },
+      {
+        label: 'Parois triple vitrage en Bois / Bois-métal',
+        tvCoefTransparenceEtsId: '5',
+        expected: 0.49
+      }
+    ])(
+      `incidence masque proche pour baie vitrée $label`,
+      ({ tvCoefTransparenceEtsId, expected }) => {
+        expect(tvStore.getCoefTransparenceEts(tvCoefTransparenceEtsId)).toBe(expected);
+      }
+    );
+
+    test('pas de valeur de coefficients de transparence', () => {
+      const ug = tvStore.getCoefTransparenceEts(0);
+      expect(ug).toBeUndefined();
+    });
+  });
+
+  describe("lecture des coefficients d'orientation et inclinaison des parois vitrées", () => {
+    test.each([
+      {
+        label: 'Baie vitrée orientée nord, inclinaison inf25°',
+        enumOrientationId: '2',
+        enumInclinaisonVitrageId: '1',
+        zoneClimatiqueId: '1',
+        mois: 'Janvier',
+        expected: 0.52
+      },
+      {
+        label: 'Baie vitrée orientée nord, inclinaison inf25°',
+        enumOrientationId: '2',
+        enumInclinaisonVitrageId: '1',
+        zoneClimatiqueId: '1',
+        mois: 'Juillet',
+        expected: 1.98
+      },
+      {
+        label: 'Baie vitrée orientée sud, inclinaison sup75°',
+        enumOrientationId: '1',
+        enumInclinaisonVitrageId: '3',
+        zoneClimatiqueId: '2',
+        mois: 'Janvier',
+        expected: 1
+      },
+      {
+        label: 'Baie vitrée orientée sud, inclinaison horizontale',
+        enumOrientationId: '1',
+        enumInclinaisonVitrageId: '4',
+        zoneClimatiqueId: '2',
+        mois: 'Janvier',
+        expected: 0.58
+      }
+    ])(
+      `coefficient pour $label`,
+      ({ enumOrientationId, enumInclinaisonVitrageId, zoneClimatiqueId, mois, expected }) => {
+        expect(
+          tvStore.getCoefficientBaieVitree(
+            enumOrientationId,
+            enumInclinaisonVitrageId,
+            zoneClimatiqueId,
+            mois
+          )
+        ).toMatchObject(expected);
+      }
+    );
+  });
+
+  test('lecture des épaisseurs disponibles pour les coefficients de transmission thermique ug', () => {
+    const ug = tvStore.getEpaisseurAvailableForUg();
+    expect(ug).toStrictEqual([0, 6, 8, 10, 12, 14, 15, 16, 18, 20]);
+  });
+
   test('lecture des épaisseurs disponibles pour les coefficients de transmission thermique ug', () => {
     const ug = tvStore.getEpaisseurAvailableForUg();
     expect(ug).toStrictEqual([0, 6, 8, 10, 12, 14, 15, 16, 18, 20]);

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