@open3cl/engine 1.0.11 → 1.0.13

package/features/dpe/domain/models/dpe.model.ts

@@ -159,6 +159,15 @@ export interface Logement {
   installation_ecs_collection: { installation_ecs: InstallationEcs[] };
   installation_chauffage_collection: { installation_chauffage: InstallationChauffage[] };
   sortie: Sortie;
+  donnees_de_calcul: LogementDonneesCalcul;
+}
+
+export interface LogementDonneesCalcul {
+  apportsInterneCh: { [key: string]: number };
+  apportsInterneDepensier: { [key: string]: number };
+  apportsSolaire: { [key: string]: number };
+  besoinChauffageHP: { [key: string]: number };
+  besoinChauffageDepensierHP: { [key: string]: number };
 }
 
 export interface Tertiaire extends Logement {}

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

@@ -71,7 +71,7 @@ export interface GenerateurChauffageDE extends DE {
   enum_type_generateur_ch_id: number;
   enum_usage_generateur_id: number;
   enum_type_energie_id: number;
-  position_volume_chauffe: boolean;
+  position_volume_chauffe: number;
   tv_rendement_generation_id?: number;
   tv_scop_id?: number;
   tv_temp_fonc_100_id?: number;
@@ -81,7 +81,7 @@ export interface GenerateurChauffageDE extends DE {
   identifiant_reseau_chaleur?: string;
   date_arrete_reseau_chaleur?: string;
   priorite_generateur_cascade?: number;
-  presence_ventouse?: boolean;
+  presence_ventouse?: number;
   presence_regulation_combustion?: boolean;
   enum_methode_saisie_carac_sys_id: number;
   enum_lien_generateur_emetteur_id: number;

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

@@ -1,5 +1,6 @@
 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
@@ -19,4 +20,46 @@ export class EcsTvStore extends TvStore {
   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

@@ -30,4 +30,40 @@ describe('Lecture des tables de valeurs', () => {
       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/froid/frTv.store.js

@@ -15,8 +15,10 @@ export class FrTvStore extends TvStore {
    * — 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).
+   * — dh19 : degrés heures de chauffage pour un mois donné à 19°C (comportement conventionnel).
+   * — dh21 : degrés heures de chauffage pour un mois donné à 21°C (comportement dépensier).
    *
-   * @param type {'e', nref26' | 'nref28' | 'e_fr_26' | 'e_fr_28' | 'textmoy_clim_26' | 'textmoy_clim_28'}
+   * @param type {'e', nref26' | 'nref28' | 'e_fr_26' | 'e_fr_28' | 'textmoy_clim_26' | 'textmoy_clim_28'| 'dh19'| 'dh21'}
    * @param classeAltitude {string}
    * @param zoneClimatique {string}
    * @param mois {string}
@@ -31,6 +33,6 @@ export class FrTvStore extends TvStore {
       values = values[ilpa];
     }
 
-    return values[classeAltitude][mois][zoneClimatique];
+    return parseFloat(values[classeAltitude][mois][zoneClimatique]);
   }
 }

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

@@ -3,6 +3,10 @@ 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';
+import { BesoinChService } from './ch/besoin-ch.service.js';
+import { PerteChRecupService } from './ch/perte-ch-recup.service.js';
 
 /**
  * Calcul des déperditions de l’enveloppe GV
@@ -19,11 +23,31 @@ export class ApportEtBesoinService {
    */
   #besoinEcsService;
 
+  /**
+   * @type {BesoinChService}
+   */
+  #besoinChService;
+
+  /**
+   * @type {InstallationEcsService}
+   */
+  #installationEcsService;
+
+  /**
+   * @type {PerteEcsRecupService}
+   */
+  #perteEcsRecupService;
+
   /**
    * @type {BesoinFroidService}
    */
   #besoinFroidService;
 
+  /**
+   * @type {PerteChRecupService}
+   */
+  #perteChRecupService;
+
   /**
    * @type {ApportGratuitService}
    */
@@ -31,19 +55,31 @@ export class ApportEtBesoinService {
 
   /**
    * @param besoinEcsService {BesoinEcsService}
+   * @param besoinChService {BesoinChService}
+   * @param installationEcsService {InstallationEcsService}
+   * @param perteEcsRecupService {PerteEcsRecupService}
    * @param besoinFroidService {BesoinFroidService}
    * @param surfaceSudEquivalenteService {SurfaceSudEquivalenteService}
+   * @param perteChRecupService {PerteChRecupService}
    * @param apportGratuitService {ApportGratuitService}
    */
   constructor(
     besoinEcsService = inject(BesoinEcsService),
+    besoinChService = inject(BesoinChService),
+    installationEcsService = inject(InstallationEcsService),
+    perteEcsRecupService = inject(PerteEcsRecupService),
     besoinFroidService = inject(BesoinFroidService),
     surfaceSudEquivalenteService = inject(SurfaceSudEquivalenteService),
+    perteChRecupService = inject(PerteChRecupService),
     apportGratuitService = inject(ApportGratuitService)
   ) {
     this.#besoinEcsService = besoinEcsService;
+    this.#besoinChService = besoinChService;
+    this.#installationEcsService = installationEcsService;
+    this.#perteEcsRecupService = perteEcsRecupService;
     this.#besoinFroidService = besoinFroidService;
     this.#surfaceSudEquivalenteService = surfaceSudEquivalenteService;
+    this.#perteChRecupService = perteChRecupService;
     this.#apportGratuitService = apportGratuitService;
   }
 
@@ -55,8 +91,35 @@ export class ApportEtBesoinService {
    * @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);
+
+    const apportsInternes = this.#apportGratuitService.apportInterne(ctx, logement);
+    const apportsSolaires = this.#apportGratuitService.apportSolaire(ctx, logement);
+
+    const pertesEcsRecup = this.#perteEcsRecupService.execute(ctx, logement);
+    // Besoin de chauffage hors pertes récupérées
+    const besoinChHP = this.#besoinChService.execute(ctx, logement);
+    const pertesChauffageRecup = this.#perteChRecupService.execute(ctx, logement);
+
+    const besoinCh = {
+      besoin_ch: besoinChHP.besoin_ch_hp,
+      besoin_ch_depensier: besoinChHP.besoin_ch_depensier_hp
+    };
+    besoinCh.besoin_ch -= pertesEcsRecup.pertes_distribution_ecs_recup;
+    besoinCh.besoin_ch -= pertesEcsRecup.pertes_stockage_ecs_recup;
+    besoinCh.besoin_ch -= pertesChauffageRecup.pertes_generateur_ch_recup;
+
+    besoinCh.besoin_ch_depensier -= pertesEcsRecup.pertes_distribution_ecs_recup_depensier;
+    besoinCh.besoin_ch_depensier -= pertesEcsRecup.pertes_stockage_ecs_recup_depensier;
+    besoinCh.besoin_ch_depensier -= pertesChauffageRecup.pertes_generateur_ch_recup_depensier;
+
     return {
-      ...this.#besoinEcsService.execute(ctx),
+      ...besoinEcs,
       ...{
         surface_sud_equivalente: this.#surfaceSudEquivalenteService.execute(
           ctx,
@@ -67,8 +130,11 @@ export class ApportEtBesoinService {
         v40_ecs_journalier_depensier: ctx.nadeq * 79
       },
       ...this.#besoinFroidService.execute(ctx, logement),
-      ...this.#apportGratuitService.apportInterne(ctx, logement),
-      ...this.#apportGratuitService.apportSolaire(ctx, logement)
+      ...apportsInternes,
+      ...apportsSolaires,
+      ...pertesEcsRecup,
+      ...pertesChauffageRecup,
+      ...besoinCh
     };
   }
 }

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

@@ -5,6 +5,15 @@ 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';
+import { PerteChRecupService } from './ch/perte-ch-recup.service.js';
+import { BesoinChService } from './ch/besoin-ch.service.js';
+import corpus from '../../../../../test/corpus-sano.json';
+import { getAdemeFileJson } from '../../../../../test/test-helpers.js';
+import { PRECISION_PERCENT } from '../../../../../test/constant.js';
+import { DpeNormalizerService } from '../../../normalizer/domain/dpe-normalizer.service.js';
+import { ContexteBuilder } from '../contexte.builder.js';
 
 /** @type {SurfaceSudEquivalenteService} **/
 let surfaceSudEquivalenteService;
@@ -15,9 +24,27 @@ let besoinEcsService;
 /** @type {BesoinFroidService} **/
 let besoinFroidService;
 
+/** @type {InstallationEcsService} **/
+let installationEcsService;
+
+/** @type {PerteEcsRecupService} **/
+let perteEcsRecupService;
+
 /** @type {ApportGratuitService} **/
 let apportGratuitService;
 
+/** @type {PerteChRecupService} **/
+let perteChRecupService;
+
+/** @type {BesoinChService} **/
+let besoinChService;
+
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
 /** @type {ApportEtBesoinService} **/
 let service;
 
@@ -29,14 +56,24 @@ describe('Calcul des apports et besoin du logement', () => {
     tvStore = new BaieVitreeTvStore();
     surfaceSudEquivalenteService = new SurfaceSudEquivalenteService(tvStore);
     besoinEcsService = new BesoinEcsService();
+    besoinChService = new BesoinChService();
     besoinFroidService = new BesoinFroidService();
+    installationEcsService = new InstallationEcsService();
+    perteEcsRecupService = new PerteEcsRecupService();
     apportGratuitService = new ApportGratuitService();
+    perteChRecupService = new PerteChRecupService();
     service = new ApportEtBesoinService(
       besoinEcsService,
+      besoinChService,
+      installationEcsService,
+      perteEcsRecupService,
       besoinFroidService,
       surfaceSudEquivalenteService,
+      perteChRecupService,
       apportGratuitService
     );
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
   });
 
   test('Determination des apports et besoin du logement', () => {
@@ -45,6 +82,10 @@ describe('Calcul des apports et besoin du logement', () => {
       besoin_ecs: 1526,
       besoin_ecs_depensier: 2685.3
     });
+    vi.spyOn(besoinChService, 'execute').mockReturnValue({
+      besoin_ch_hp: 2563,
+      besoin_ch_depensier_hp: 3258.6
+    });
     vi.spyOn(besoinFroidService, 'execute').mockReturnValue({
       besoin_fr: 896,
       besoin_fr_depensier: 1025.3
@@ -57,6 +98,17 @@ describe('Calcul des apports et besoin du logement', () => {
       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,
+      pertes_stockage_ecs_recup_depensier: 12.9
+    });
+    vi.spyOn(perteChRecupService, 'execute').mockReturnValue({
+      pertes_generateur_ch_recup: 102.2,
+      pertes_generateur_ch_recup_depensier: 153.4
+    });
 
     /** @type {Contexte} */
     const ctx = { zoneClimatique: { id: 1 }, nadeq: 2.5 };
@@ -66,6 +118,8 @@ describe('Calcul des apports et besoin du logement', () => {
       surface_sud_equivalente: 18.5,
       besoin_ecs: 1526,
       besoin_ecs_depensier: 2685.3,
+      besoin_ch: 2080.7000000000003,
+      besoin_ch_depensier: 2559.7,
       besoin_fr: 896,
       besoin_fr_depensier: 1025.3,
       apport_solaire_ch: 5236.9,
@@ -74,7 +128,13 @@ describe('Calcul des apports et besoin du logement', () => {
       apport_interne_fr: 3345.2,
       nadeq: 2.5,
       v40_ecs_journalier: 140,
-      v40_ecs_journalier_depensier: 197.5
+      v40_ecs_journalier_depensier: 197.5,
+      pertes_distribution_ecs_recup: 354.2,
+      pertes_distribution_ecs_recup_depensier: 532.6,
+      pertes_generateur_ch_recup: 102.2,
+      pertes_generateur_ch_recup_depensier: 153.4,
+      pertes_stockage_ecs_recup: 25.9,
+      pertes_stockage_ecs_recup_depensier: 12.9
     });
     expect(surfaceSudEquivalenteService.execute).toHaveBeenCalledWith(ctx, logement.enveloppe);
     expect(besoinEcsService.execute).toHaveBeenCalledWith(ctx);
@@ -82,4 +142,66 @@ describe('Calcul des apports et besoin du logement', () => {
     expect(apportGratuitService.apportSolaire).toHaveBeenCalledWith(ctx, logement);
     expect(apportGratuitService.apportInterne).toHaveBeenCalledWith(ctx, logement);
   });
+
+  describe("Test d'intégration pour les besoins en chauffage", () => {
+    test.each(corpus)(
+      'Vérification de la DI besoin_ch des besoins en chauffage pour dpe %s',
+      (ademeId) => {
+        /**
+         * @type {Dpe}
+         */
+        let dpeRequest = getAdemeFileJson(ademeId);
+        dpeRequest = normalizerService.normalize(dpeRequest);
+
+        dpeRequest.logement.donnees_de_calcul = {
+          apportsInterneDepensier: [],
+          apportsInterneCh: [],
+          apportsSolaire: [],
+          besoinChauffageHP: [],
+          besoinChauffageDepensierHP: []
+        };
+
+        /** @type {Contexte} */
+        const ctx = contexteBuilder.fromDpe(dpeRequest);
+        const apportEtBesoin = service.execute(ctx, dpeRequest.logement);
+
+        expect(
+          Math.abs(
+            apportEtBesoin.besoin_ch - dpeRequest.logement.sortie.apport_et_besoin.besoin_ch
+          ) / (dpeRequest.logement.sortie.apport_et_besoin.besoin_ch || 1)
+        ).toBeLessThan(PRECISION_PERCENT);
+      }
+    );
+
+    test.each(corpus)(
+      'Vérification de la DI besoin_ch_depensier des besoins en chauffage pour dpe %s',
+      (ademeId) => {
+        /**
+         * @type {Dpe}
+         */
+        let dpeRequest = getAdemeFileJson(ademeId);
+        dpeRequest = normalizerService.normalize(dpeRequest);
+
+        dpeRequest.logement.donnees_de_calcul = {
+          apportsInterneDepensier: [],
+          apportsInterneCh: [],
+          apportsSolaire: [],
+          besoinChauffageHP: [],
+          besoinChauffageDepensierHP: []
+        };
+
+        /** @type {Contexte} */
+        const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+        const apportEtBesoin = service.execute(ctx, dpeRequest.logement);
+
+        expect(
+          Math.abs(
+            apportEtBesoin.besoin_ch_depensier -
+              dpeRequest.logement.sortie.apport_et_besoin.besoin_ch_depensier
+          ) / (dpeRequest.logement.sortie.apport_et_besoin.besoin_ch_depensier || 1)
+        ).toBeLessThan(PRECISION_PERCENT);
+      }
+    );
+  });
 });

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

@@ -46,7 +46,7 @@ export class ApportGratuitService {
 
     return mois_liste.reduce(
       (acc, mois) => {
-        acc.apport_solaire_ch += this.apportSolaireMois(
+        const apportSolaire = this.apportSolaireMois(
           ctx,
           logement.enveloppe,
           mois,
@@ -58,6 +58,9 @@ export class ApportGratuitService {
             ctx.inertie.ilpa
           )
         );
+        acc.apport_solaire_ch += apportSolaire;
+        logement.donnees_de_calcul.apportsSolaire[mois] = apportSolaire;
+
         if (clim.length > 0) {
           acc.apport_solaire_fr += this.apportSolaireMois(
             ctx,
@@ -84,7 +87,7 @@ export class ApportGratuitService {
 
     return mois_liste.reduce(
       (acc, mois) => {
-        acc.apport_interne_ch += this.apportInterneMois(
+        const apportInterne = this.apportInterneMois(
           ctx,
           this.#frTvStore.getData(
             'nref19',
@@ -94,6 +97,19 @@ export class ApportGratuitService {
             ctx.inertie.ilpa
           )
         );
+        acc.apport_interne_ch += apportInterne;
+        logement.donnees_de_calcul.apportsInterneCh[mois] = apportInterne;
+        logement.donnees_de_calcul.apportsInterneDepensier[mois] = this.apportInterneMois(
+          ctx,
+          this.#frTvStore.getData(
+            'nref21',
+            ctx.altitude.value,
+            ctx.zoneClimatique.value,
+            mois,
+            ctx.inertie.ilpa
+          )
+        );
+
         if (clim.length > 0) {
           acc.apport_interne_fr += this.apportInterneMois(
             ctx,

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

@@ -41,7 +41,10 @@ describe('Calcul des apports gratuits au logement', () => {
     };
 
     /** @type { Logement } **/
-    const logement = { enveloppe: { porte_collection: {} } };
+    const logement = {
+      enveloppe: { porte_collection: {} },
+      donnees_de_calcul: { apportsSolaire: {} }
+    };
 
     if (withClimatisation) {
       logement.climatisation_collection = { climatisation: [{}] };
@@ -81,6 +84,8 @@ describe('Calcul des apports gratuits au logement', () => {
           mois
         );
       }
+
+      expect(logement.donnees_de_calcul.apportsSolaire[mois]).toBe(185000);
     }
   });
 
@@ -106,7 +111,10 @@ describe('Calcul des apports gratuits au logement', () => {
     };
 
     /** @type { Logement } **/
-    const logement = { enveloppe: { porte_collection: {} } };
+    const logement = {
+      enveloppe: { porte_collection: {} },
+      donnees_de_calcul: { apportsInterneCh: {}, apportsInterneDepensier: {} }
+    };
 
     if (withClimatisation) {
       logement.climatisation_collection = { climatisation: [{}] };
@@ -141,6 +149,9 @@ describe('Calcul des apports gratuits au logement', () => {
           mois
         );
       }
+
+      expect(logement.donnees_de_calcul.apportsInterneCh[mois]).toBeCloseTo(1306.33, 2);
+      expect(logement.donnees_de_calcul.apportsInterneDepensier[mois]).toBeCloseTo(1306.33, 2);
     }
   });