@open3cl/engine 1.0.10 → 1.0.12

package/features/dpe/domain/models/installation-ecs.model.ts

@@ -3,6 +3,7 @@ import { DE } from './dpe.model';
 export interface InstallationEcs {
   donnee_entree?: InstallationEcsDE;
   donnee_intermediaire?: InstallationEcsDI;
+  donnee_utilisateur?: InstallationEcsDU;
   generateur_ecs_collection?: { generateur_ecs: GenerateurEcs[] };
 }
 
@@ -35,8 +36,16 @@ export interface InstallationEcsDI {
   conso_ecs_depensier: number;
 }
 
+export interface InstallationEcsDU {
+  QdwIndVc: { conventionnel: number; depensier: number };
+  QdwColVc: { conventionnel: number; depensier: number };
+  QdwColHVc: { conventionnel: number; depensier: number };
+  QgwRecuperable: number;
+}
+
 export interface GenerateurEcs {
   donnee_entree?: GenerateurEcsDE;
+  donnee_utilisateur?: GenerateurEcsDU;
   donnee_intermediaire?: GenerateurEcsDI;
 }
 
@@ -55,8 +64,8 @@ export interface GenerateurEcsDE extends DE {
   date_arrete_reseau_chaleur?: string;
   tv_reseau_chaleur_id?: number;
   enum_type_stockage_ecs_id: number;
-  position_volume_chauffe: boolean;
-  position_volume_chauffe_stockage?: boolean;
+  position_volume_chauffe: number;
+  position_volume_chauffe_stockage?: number;
   volume_stockage: number;
   presence_ventouse?: boolean;
 }
@@ -74,3 +83,7 @@ export interface GenerateurEcsDI {
   conso_ecs_depensier: number;
   rendement_stockage?: number;
 }
+
+export interface GenerateurEcsDU {
+  Qgw?: number;
+}

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

@@ -12,5 +12,6 @@ export const TypeHabitation = {
 export const TypeDpe = {
   MAISON: 'MAISON',
   APPARTEMENT: 'APPARTEMENT',
+  APPARTEMENT_A_PARTIR_IMMEUBLE: 'APPARTEMENT_A_PARTIR_IMMEUBLE',
   IMMEUBLE: 'IMMEUBLE'
 };

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

@@ -0,0 +1,8 @@
+/**
+ * @type {{[key: string]: string}}
+ */
+export const TypeStockage = {
+  INSTANTANE: 'INSTANTANE',
+  INTEGRE: 'INTEGRE',
+  INDEPENDANT: 'INDEPENDANT'
+};

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

@@ -0,0 +1,65 @@
+import { tvs as tv } from '../../../../tv-v2.js';
+import { TvStore } from './../tv.store.js';
+import { logger } from '../../../../core/util/logger/log-service.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];
+  }
+
+  /**
+   * Coefficient de perte du ballon de stockage
+   * @see 11.6.2 Pertes des ballons électriques
+   *
+   * @param enumTypeGenerateurEcsId {string}
+   * @param volumeStockage {number}
+   *
+   * @return {number|undefined}
+   */
+  getPertesStockage(enumTypeGenerateurEcsId, volumeStockage) {
+    let volumeBallon;
+    if (volumeStockage <= 100) volumeBallon = '≤ 100';
+    else if (volumeStockage <= 200) volumeBallon = '100 <   ≤ 200';
+    else if (volumeStockage <= 300) volumeBallon = '200 <   ≤ 300';
+    else volumeBallon = '> 300';
+
+    const cr = tv['pertes_stockage'].find(
+      (v) =>
+        v.enum_type_generateur_ecs_id.split('|').includes(enumTypeGenerateurEcsId) &&
+        v.volume_ballon === volumeBallon
+    )?.cr;
+
+    if (!cr) {
+      logger.error(
+        `Pas de valeur forfaitaire cr pour enumTypeGenerateurEcsId:${enumTypeGenerateurEcsId}, volumeBallon:${volumeBallon}`
+      );
+      return;
+    }
+
+    return parseFloat(cr);
+  }
+
+  /**
+   * Récupération des ids des générateurs électriques ECS
+   * @return {[number]}
+   */
+  getElectriqueEcsGenerateurs() {
+    return tv['pertes_stockage'].flatMap((v) =>
+      v.enum_type_generateur_ecs_id.split('|').map(Number)
+    );
+  }
+}

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

@@ -0,0 +1,69 @@
+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);
+    });
+  });
+
+  describe('Lecture des valeurs de pertes_stockage', () => {
+    test.each([
+      {
+        label: 'Ballon électrique à accumulation horizontal < 100L',
+        enumTypeGenerateurEcsId: '68',
+        volumeStockage: 50,
+        expected: 0.39
+      },
+      {
+        label: 'Ballon électrique à accumulation horizontal entre 100L et 200L',
+        enumTypeGenerateurEcsId: '68',
+        volumeStockage: 150,
+        expected: 0.33
+      },
+      {
+        label: 'Ballon électrique à accumulation horizontal entre 200L et 300L',
+        enumTypeGenerateurEcsId: '68',
+        volumeStockage: 250,
+        expected: 0.3
+      },
+      {
+        label: 'Ballon électrique à accumulation horizontal > 300L',
+        enumTypeGenerateurEcsId: '68',
+        volumeStockage: 301,
+        expected: 0.3
+      }
+    ])(`$label`, ({ enumTypeGenerateurEcsId, volumeStockage, expected }) => {
+      expect(ecsTvStore.getPertesStockage(enumTypeGenerateurEcsId, volumeStockage)).toBe(expected);
+    });
+
+    test('pas de valeur de pertes_stockage', () => {
+      const pertes_stockage = ecsTvStore.getPertesStockage('298', 600);
+      expect(pertes_stockage).toBeUndefined();
+    });
+  });
+});

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,100 @@
+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';
+import { InstallationEcsService } from '../ecs/installation-ecs.service.js';
+import { PerteEcsRecupService } from './ecs/perte-ecs-recup.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 {InstallationEcsService}
+   */
+  #installationEcsService;
+
+  /**
+   * @type {PerteEcsRecupService}
+   */
+  #perteEcsRecupService;
+
+  /**
+   * @type {BesoinFroidService}
+   */
+  #besoinFroidService;
+
+  /**
+   * @type {ApportGratuitService}
+   */
+  #apportGratuitService;
+
+  /**
+   * @param besoinEcsService {BesoinEcsService}
+   * @param installationEcsService {InstallationEcsService}
+   * @param perteEcsRecupService {PerteEcsRecupService}
+   * @param besoinFroidService {BesoinFroidService}
+   * @param surfaceSudEquivalenteService {SurfaceSudEquivalenteService}
+   * @param apportGratuitService {ApportGratuitService}
+   */
+  constructor(
+    besoinEcsService = inject(BesoinEcsService),
+    installationEcsService = inject(InstallationEcsService),
+    perteEcsRecupService = inject(PerteEcsRecupService),
+    besoinFroidService = inject(BesoinFroidService),
+    surfaceSudEquivalenteService = inject(SurfaceSudEquivalenteService),
+    apportGratuitService = inject(ApportGratuitService)
+  ) {
+    this.#besoinEcsService = besoinEcsService;
+    this.#installationEcsService = installationEcsService;
+    this.#perteEcsRecupService = perteEcsRecupService;
+    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) {
+    const besoinEcs = this.#besoinEcsService.execute(ctx);
+
+    /**
+     * Détermination des besoins et pertes des installations ECS
+     */
+    this.#installationEcsService.execute(ctx, logement, besoinEcs);
+
+    return {
+      ...besoinEcs,
+      ...{
+        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),
+      ...this.#perteEcsRecupService.execute(ctx, logement)
+    };
+  }
+}

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

@@ -0,0 +1,106 @@
+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';
+import { PerteEcsRecupService } from './ecs/perte-ecs-recup.service.js';
+import { InstallationEcsService } from '../ecs/installation-ecs.service.js';
+
+/** @type {SurfaceSudEquivalenteService} **/
+let surfaceSudEquivalenteService;
+
+/** @type {BesoinEcsService} **/
+let besoinEcsService;
+
+/** @type {BesoinFroidService} **/
+let besoinFroidService;
+
+/** @type {InstallationEcsService} **/
+let installationEcsService;
+
+/** @type {PerteEcsRecupService} **/
+let perteEcsRecupService;
+
+/** @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();
+    installationEcsService = new InstallationEcsService();
+    perteEcsRecupService = new PerteEcsRecupService();
+    apportGratuitService = new ApportGratuitService();
+    service = new ApportEtBesoinService(
+      besoinEcsService,
+      installationEcsService,
+      perteEcsRecupService,
+      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
+    });
+    vi.spyOn(installationEcsService, 'execute').mockReturnThis();
+    vi.spyOn(perteEcsRecupService, 'execute').mockReturnValue({
+      pertes_distribution_ecs_recup: 354.2,
+      pertes_distribution_ecs_recup_depensier: 532.6,
+      pertes_stockage_ecs_recup: 25.9
+    });
+
+    /** @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,
+      pertes_distribution_ecs_recup: 354.2,
+      pertes_distribution_ecs_recup_depensier: 532.6,
+      pertes_stockage_ecs_recup: 25.9
+    });
+    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;
+  }
+}