@open3cl/engine 1.0.11 → 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

@@ -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/engine/domain/apport_et_besoin/apport-et-besoin.service.js

@@ -3,6 +3,8 @@ 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
@@ -19,6 +21,16 @@ export class ApportEtBesoinService {
    */
   #besoinEcsService;
 
+  /**
+   * @type {InstallationEcsService}
+   */
+  #installationEcsService;
+
+  /**
+   * @type {PerteEcsRecupService}
+   */
+  #perteEcsRecupService;
+
   /**
    * @type {BesoinFroidService}
    */
@@ -31,17 +43,23 @@ export class ApportEtBesoinService {
 
   /**
    * @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;
@@ -55,8 +73,15 @@ 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);
+
     return {
-      ...this.#besoinEcsService.execute(ctx),
+      ...besoinEcs,
       ...{
         surface_sud_equivalente: this.#surfaceSudEquivalenteService.execute(
           ctx,
@@ -68,7 +93,8 @@ export class ApportEtBesoinService {
       },
       ...this.#besoinFroidService.execute(ctx, logement),
       ...this.#apportGratuitService.apportInterne(ctx, logement),
-      ...this.#apportGratuitService.apportSolaire(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

@@ -5,6 +5,8 @@ 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;
@@ -15,6 +17,12 @@ let besoinEcsService;
 /** @type {BesoinFroidService} **/
 let besoinFroidService;
 
+/** @type {InstallationEcsService} **/
+let installationEcsService;
+
+/** @type {PerteEcsRecupService} **/
+let perteEcsRecupService;
+
 /** @type {ApportGratuitService} **/
 let apportGratuitService;
 
@@ -30,9 +38,13 @@ describe('Calcul des apports et besoin du logement', () => {
     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
@@ -57,6 +69,12 @@ 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
+    });
 
     /** @type {Contexte} */
     const ctx = { zoneClimatique: { id: 1 }, nadeq: 2.5 };
@@ -74,7 +92,10 @@ 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_stockage_ecs_recup: 25.9
     });
     expect(surfaceSudEquivalenteService.execute).toHaveBeenCalledWith(ctx, logement.enveloppe);
     expect(besoinEcsService.execute).toHaveBeenCalledWith(ctx);

package/features/engine/domain/apport_et_besoin/ecs/perte-ecs-recup.service.js

@@ -0,0 +1,123 @@
+import { mois_liste } from '../../../../../utils.js';
+import { inject } from 'dioma';
+import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
+
+/**
+ * Calcul des pertes récupérées de distribution et de stockage d'ECS
+ * Chapitre 9.1.1 Consommation de chauffage
+ *
+ * Données calculées
+ *  — pertes_distribution_ecs_recup : pertes de distribution d'ECS récupérées(kWh)
+ *  — pertes_distribution_ecs_recup_depensier : pertes de distribution d'ECS récupérées(kWh) pour le scénario dépensier
+ *  — pertes_stockage_ecs_recup : pertes de stockage d'ECS récupérées(kWh)
+ *
+ * Methode_de_calcul_3CL_DPE_2021 - Page 57
+ * Octobre 2021
+ * @see consolide_anne…arrete_du_31_03_2021_relatif_aux_methodes_et_procedures_applicables.pdf
+ */
+export class PerteEcsRecupService {
+  /**
+   * @type {FrTvStore}
+   */
+  #tvStore;
+
+  /**
+   * @param tvStore {FrTvStore}
+   */
+  constructor(tvStore = inject(FrTvStore)) {
+    this.#tvStore = tvStore;
+  }
+
+  /**
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @return {{pertes_distribution_ecs_recup: number, pertes_distribution_ecs_recup_depensier: number, pertes_stockage_ecs_recup: number}}
+   */
+  execute(ctx, logement) {
+    return {
+      pertes_distribution_ecs_recup: this.pertesDistributionEcsRecup(ctx, logement, false),
+      pertes_distribution_ecs_recup_depensier: this.pertesDistributionEcsRecup(ctx, logement, true),
+      pertes_stockage_ecs_recup: this.pertesStockageEcsRecup(ctx, logement)
+    };
+  }
+
+  /**
+   * Pertes récupérées de distribution d’ECS pour le chauffage
+   * 9.1.1 Consommation de chauffage
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @param depensier {boolean}
+   * @returns {number}
+   */
+  pertesDistributionEcsRecup(ctx, logement, depensier) {
+    const installationsEcs = logement.installation_ecs_collection?.installation_ecs || [];
+
+    const pertesDistribution = installationsEcs.reduce((acc, installation) => {
+      /** @type {InstallationEcsDU}*/
+      const installationEcsDU = installation.donnee_utilisateur;
+
+      const pertesDistributionIndividuelleVolumeChauffee = depensier
+        ? installationEcsDU.QdwIndVc.depensier
+        : installationEcsDU.QdwIndVc.conventionnel;
+      const pertesDistributionCollectiveVolumeChauffee = depensier
+        ? installationEcsDU.QdwColVc.depensier
+        : installationEcsDU.QdwColVc.conventionnel;
+
+      return (
+        acc +
+        pertesDistributionIndividuelleVolumeChauffee +
+        pertesDistributionCollectiveVolumeChauffee
+      );
+    }, 0);
+
+    return mois_liste.reduce((acc, mois) => {
+      return (
+        acc +
+        (0.48 *
+          pertesDistribution *
+          this.#tvStore.getData(
+            depensier ? 'nref21' : 'nref19',
+            ctx.altitude.value,
+            ctx.zoneClimatique.value,
+            mois,
+            ctx.inertie.ilpa
+          )) /
+          8760
+      );
+    }, 0);
+  }
+
+  /**
+   * Pertes récupérées du stockage d’ECS pour le chauffage
+   * 9.1.1 Consommation de chauffage
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @returns {number}
+   */
+  pertesStockageEcsRecup(ctx, logement) {
+    const installationsEcs = logement.installation_ecs_collection?.installation_ecs || [];
+
+    let pertesStockage = installationsEcs.reduce((acc, installation) => {
+      /** @type {InstallationEcsDU}*/
+      const installationEcsDU = installation.donnee_utilisateur;
+
+      return acc + (0.48 * installationEcsDU.QgwRecuperable) / 8760.0;
+    }, 0);
+
+    return mois_liste.reduce((acc, mois) => {
+      return (
+        acc +
+        pertesStockage *
+          this.#tvStore.getData(
+            'nref19',
+            ctx.altitude.value,
+            ctx.zoneClimatique.value,
+            mois,
+            ctx.inertie.ilpa
+          )
+      );
+    }, 0);
+  }
+}

package/features/engine/domain/apport_et_besoin/ecs/perte-ecs-recup.service.spec.js

@@ -0,0 +1,205 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import corpus from '../../../../../../test/corpus-sano.json';
+import { expect_or, getAdemeFileJson } from '../../../../../../test/test-helpers.js';
+import { DpeNormalizerService } from '../../../../normalizer/domain/dpe-normalizer.service.js';
+import { ContexteBuilder } from '../../contexte.builder.js';
+import { PerteEcsRecupService } from './perte-ecs-recup.service.js';
+import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
+import { mois_liste } from '../../../../../utils.js';
+import { EcsTvStore } from '../../../../dpe/infrastructure/ecs/ecsTv.store.js';
+import { GenerateurEcsService } from '../../ecs/generateur-ecs.service.js';
+import { InstallationEcsService } from '../../ecs/installation-ecs.service.js';
+
+/** @type {PerteEcsRecupService} **/
+let service;
+
+/** @type {FrTvStore} **/
+let tvStore;
+
+/** @type {InstallationEcsService} **/
+let installationEcsService;
+
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
+describe('Calcul des pertes de distribution et stockage récupérées', () => {
+  beforeEach(() => {
+    tvStore = new FrTvStore();
+    service = new PerteEcsRecupService(tvStore);
+    installationEcsService = new InstallationEcsService(new GenerateurEcsService(new EcsTvStore()));
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
+  });
+
+  test.each([
+    {
+      label: 'Installation ECS en mode conventionnel',
+      depensier: false,
+      expected: 0.36
+    },
+    {
+      label: 'Installation ECS en mode dépensier',
+      depensier: true,
+      expected: 0.72
+    }
+  ])('Calcul des pertes de distribution récupérées pour $label', ({ depensier, expected }) => {
+    vi.spyOn(tvStore, 'getData').mockReturnValue(1.5);
+
+    /** @type {Contexte} */
+    const ctx = {
+      altitude: { value: '400-800m' },
+      zoneClimatique: { value: 'h1a' },
+      inertie: { ilpa: 1 }
+    };
+
+    /** @type {Logement} */
+    const logement = {
+      installation_ecs_collection: {
+        installation_ecs: [
+          {
+            donnee_utilisateur: {
+              QdwIndVc: { conventionnel: 100, depensier: 200 },
+              QdwColVc: { conventionnel: 50, depensier: 120 }
+            }
+          },
+          {
+            donnee_utilisateur: {
+              QdwIndVc: { conventionnel: 150, depensier: 280 },
+              QdwColVc: { conventionnel: 65, depensier: 135 }
+            }
+          }
+        ]
+      }
+    };
+
+    expect(service.pertesDistributionEcsRecup(ctx, logement, depensier)).toBeCloseTo(expected, 2);
+    for (const mois of mois_liste) {
+      expect(tvStore.getData).toHaveBeenCalledWith(
+        depensier ? 'nref21' : 'nref19',
+        '400-800m',
+        'h1a',
+        mois,
+        1
+      );
+    }
+  });
+
+  test('Calcul des pertes de stockage récupérées pour une installation ECS', () => {
+    vi.spyOn(tvStore, 'getData').mockReturnValue(1.5);
+
+    /** @type {Contexte} */
+    const ctx = {
+      altitude: { value: '400-800m' },
+      zoneClimatique: { value: 'h1a' },
+      inertie: { ilpa: 1 }
+    };
+
+    /** @type {Logement} */
+    const logement = {
+      installation_ecs_collection: {
+        installation_ecs: [
+          { donnee_utilisateur: { QgwRecuperable: 120 } },
+          { donnee_utilisateur: { QgwRecuperable: 150 } }
+        ]
+      }
+    };
+
+    expect(service.pertesStockageEcsRecup(ctx, logement)).toBeCloseTo(0.27);
+    for (const mois of mois_liste) {
+      expect(tvStore.getData).toHaveBeenCalledWith('nref19', '400-800m', 'h1a', mois, 1);
+    }
+  });
+
+  describe("Test d'intégration des installations ECS", () => {
+    test.each(corpus)(
+      'vérification des pertes de distribution ecs recup des installations ECS pour dpe %s',
+      (ademeId) => {
+        let dpeRequest = getAdemeFileJson(ademeId);
+        dpeRequest = normalizerService.normalize(dpeRequest);
+
+        /** @type {Contexte} */
+        const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+        installationEcsService.execute(ctx, dpeRequest.logement, {
+          besoin_ecs: dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs,
+          besoin_ecs_depensier: dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs_depensier
+        });
+
+        const pertesStockage = service.execute(ctx, dpeRequest.logement);
+
+        expect_or(
+          () =>
+            expect(pertesStockage.pertes_distribution_ecs_recup).toBeCloseTo(
+              dpeRequest.logement.sortie.apport_et_besoin.pertes_distribution_ecs_recup
+            ),
+          () =>
+            expect(pertesStockage.pertes_distribution_ecs_recup * 1000).toBeCloseTo(
+              dpeRequest.logement.sortie.apport_et_besoin.pertes_distribution_ecs_recup
+            )
+        );
+      }
+    );
+    test.each(corpus)(
+      'vérification des pertes de distribution ecs recup depensier des installations ECS pour dpe %s',
+      (ademeId) => {
+        let dpeRequest = getAdemeFileJson(ademeId);
+        dpeRequest = normalizerService.normalize(dpeRequest);
+
+        /** @type {Contexte} */
+        const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+        installationEcsService.execute(ctx, dpeRequest.logement, {
+          besoin_ecs: dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs,
+          besoin_ecs_depensier: dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs_depensier
+        });
+
+        const pertesStockage = service.execute(ctx, dpeRequest.logement);
+
+        expect_or(
+          () =>
+            expect(pertesStockage.pertes_distribution_ecs_recup_depensier).toBeCloseTo(
+              dpeRequest.logement.sortie.apport_et_besoin.pertes_distribution_ecs_recup_depensier
+            ),
+          () =>
+            expect(pertesStockage.pertes_distribution_ecs_recup_depensier * 1000).toBeCloseTo(
+              dpeRequest.logement.sortie.apport_et_besoin.pertes_distribution_ecs_recup_depensier
+            )
+        );
+      }
+    );
+    test.each(corpus)(
+      'vérification des pertes de stockage ecs recup des installations ECS pour dpe %s',
+      (ademeId) => {
+        let dpeRequest = getAdemeFileJson(ademeId);
+        dpeRequest = normalizerService.normalize(dpeRequest);
+
+        /** @type {Contexte} */
+        const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+        installationEcsService.execute(ctx, dpeRequest.logement, {
+          besoin_ecs: dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs,
+          besoin_ecs_depensier: dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs_depensier
+        });
+
+        const pertesStockage = service.execute(ctx, dpeRequest.logement);
+        expect_or(
+          () =>
+            expect(pertesStockage.pertes_stockage_ecs_recup).toBeCloseTo(
+              dpeRequest.logement.sortie.apport_et_besoin.pertes_stockage_ecs_recup
+            ),
+          () =>
+            expect(pertesStockage.pertes_stockage_ecs_recup).toBeCloseTo(
+              dpeRequest.logement.sortie.apport_et_besoin.pertes_stockage_ecs_recup * 1000
+            ),
+          () =>
+            expect(pertesStockage.pertes_stockage_ecs_recup * 1000).toBeCloseTo(
+              dpeRequest.logement.sortie.apport_et_besoin.pertes_stockage_ecs_recup
+            )
+        );
+      }
+    );
+  });
+});

package/features/engine/domain/contexte.builder.js

@@ -132,8 +132,12 @@ export class ContexteBuilder {
 
     if ([1, 14, 18].includes(methodeApplication)) {
       return TypeDpe.MAISON;
-    } else if ([2, 3, 4, 5, 31, 32, 35, 36, 37].includes(methodeApplication)) {
+    } else if (
+      [2, 3, 4, 5, 15, 16, 19, 20, 22, 23, 24, 25, 31, 32, 35, 36, 37].includes(methodeApplication)
+    ) {
       return TypeDpe.APPARTEMENT;
+    } else if ([10, 11, 12, 13, 33, 34, 38, 39, 40].includes(methodeApplication)) {
+      return TypeDpe.APPARTEMENT_A_PARTIR_IMMEUBLE;
     }
     return TypeDpe.IMMEUBLE;
   }

package/features/engine/domain/ecs/generateur-ecs.service.js

@@ -0,0 +1,106 @@
+import { TypeStockage } from '../../../dpe/domain/models/type-stockage.model.js';
+import { inject } from 'dioma';
+import { EcsTvStore } from '../../../dpe/infrastructure/ecs/ecsTv.store.js';
+
+/**
+ * Calcul des données de calcul pour chacun des générateurs
+ * Données calculées
+ *   — Qgw : pertes liées au stockage de l'ECS pour chaque générateur
+ */
+export class GenerateurEcsService {
+  /**
+   * @type {EcsTvStore}
+   */
+  #tvStore;
+
+  /**
+   * @param tvStore {EcsTvStore}
+   */
+  constructor(tvStore = inject(EcsTvStore)) {
+    this.#tvStore = tvStore;
+  }
+
+  /**
+   * Détermination des apports et besoins pour le bien concerné
+   *
+   * @param installationEcs {InstallationEcs}
+   */
+  execute(installationEcs) {
+    const generateursEcs = installationEcs.generateur_ecs_collection.generateur_ecs || [];
+
+    generateursEcs.forEach((generateurEcs) => {
+      /** @type {GenerateurEcsDE}*/
+      const generateurEcsDE = generateurEcs.donnee_entree;
+
+      generateurEcs.donnee_utilisateur = {
+        Qgw: this.pertesStockage(generateurEcsDE)
+      };
+    });
+  }
+
+  /**
+   * Pertes de stockage d'un générateur ECS.
+   * Seules les générateurs avec stockage indépendant et dissocié du générateur sont concernés
+   *
+   * 11.6.1 - Pertes de stockage des ballons d’accumulation
+   * 11.6.2 - Pertes des ballons électriques
+   *
+   * @param generateurEcsDE {GenerateurEcsDE}
+   * @return {number}
+   */
+  pertesStockage(generateurEcsDE) {
+    const electrique = this.generateurElectrique(generateurEcsDE);
+    const typeStockage = this.typeStockage(generateurEcsDE);
+
+    if (typeStockage === TypeStockage.INSTANTANE) {
+      return 0;
+    }
+
+    let Qgw;
+    let volumeStockage = generateurEcsDE.volume_stockage;
+
+    if (electrique) {
+      const cr = this.#tvStore.getPertesStockage(
+        generateurEcsDE.enum_type_generateur_ecs_id,
+        volumeStockage
+      );
+      // Les pertes de stockage des ballons électriques (Wh)
+      Qgw = ((8592 * 45) / 24) * volumeStockage * cr;
+    } else {
+      // La présence d’un ballon de préparation de l’ECS est responsable de pertes de stockage Qgw (Wh)
+      Qgw = 67662 * volumeStockage ** 0.55;
+    }
+
+    return Qgw;
+  }
+
+  /**
+   * Return true si le générateur ECS est électrique
+   *
+   * 1 - abscence de stockage d'ecs (production instantanée)
+   * 2 - stockage indépendant de la production
+   * 3 - stockage intégré à la production
+   *
+   * @param generateurEcsDE {GenerateurEcsDE}
+   * @return {boolean}
+   */
+  generateurElectrique(generateurEcsDE) {
+    return this.#tvStore
+      .getElectriqueEcsGenerateurs()
+      .includes(parseInt(generateurEcsDE.enum_type_generateur_ecs_id));
+  }
+
+  /**
+   * Return le type de stockage d'ECS
+   *
+   * @param generateurEcsDE {GenerateurEcsDE}
+   * @return TypeStockage
+   */
+  typeStockage(generateurEcsDE) {
+    return parseInt(generateurEcsDE.enum_type_stockage_ecs_id) === 1
+      ? TypeStockage.INSTANTANE
+      : parseInt(generateurEcsDE.enum_type_stockage_ecs_id) === 2
+        ? TypeStockage.INDEPENDANT
+        : TypeStockage.INTEGRE;
+  }
+}

package/features/engine/domain/ecs/generateur-ecs.service.spec.js

@@ -0,0 +1,136 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { GenerateurEcsService } from './generateur-ecs.service.js';
+import { EcsTvStore } from '../../../dpe/infrastructure/ecs/ecsTv.store.js';
+import { TypeStockage } from '../../../dpe/domain/models/type-stockage.model.js';
+
+/** @type {GenerateurEcsService} **/
+let service;
+
+/** @type {EcsTvStore} **/
+let tvStore;
+
+describe('Calcul des informations techniques des générateurs ECS', () => {
+  beforeEach(() => {
+    tvStore = new EcsTvStore();
+    service = new GenerateurEcsService(tvStore);
+  });
+
+  describe("Calcul des pertes de stockage d'un générateur", () => {
+    test.each([
+      {
+        label: 'Générateur ECS avec production instantanée',
+        enumTypeGenerateurEcsId: 1,
+        enumTypeStockageEcsId: 1,
+        volumeStockage: 100,
+        expected: 0
+      },
+      {
+        label: 'Générateur ECS avec stockage intégré au générateur',
+        enumTypeGenerateurEcsId: 1,
+        enumTypeStockageEcsId: 2,
+        volumeStockage: 100,
+        expected: 851814.11
+      },
+      {
+        label: 'Générateur ECS électrique avec stockage indépendant de 100L',
+        enumTypeGenerateurEcsId: 2,
+        enumTypeStockageEcsId: 3,
+        electrique: true,
+        volumeStockage: 250,
+        expected: 1288800
+      },
+      {
+        label: 'Générateur ECS à gaz avec stockage indépendant de 200L',
+        enumTypeGenerateurEcsId: 1,
+        enumTypeStockageEcsId: 3,
+        volumeStockage: 200,
+        expected: 1247128.86
+      }
+    ])(
+      '$label',
+      ({
+        enumTypeGenerateurEcsId,
+        volumeStockage,
+        enumTypeStockageEcsId,
+        electrique = false,
+        expected
+      }) => {
+        vi.spyOn(tvStore, 'getPertesStockage').mockReturnValue(0.32);
+        vi.spyOn(tvStore, 'getElectriqueEcsGenerateurs').mockReturnValue([2]);
+
+        /** @type {GenerateurEcsDE} */
+        const generateurEcsDE = {
+          enum_type_generateur_ecs_id: enumTypeGenerateurEcsId,
+          volume_stockage: volumeStockage,
+          enum_type_stockage_ecs_id: enumTypeStockageEcsId
+        };
+
+        const pertesStockage = service.pertesStockage(generateurEcsDE);
+
+        if (electrique) {
+          expect(tvStore.getPertesStockage).toHaveBeenCalledWith(
+            enumTypeGenerateurEcsId,
+            volumeStockage
+          );
+        }
+        expect(pertesStockage).toBeCloseTo(expected, 2);
+      }
+    );
+
+    test('Ajout des données utilisateurs sur tous les générateurs', () => {
+      /** @type {InstallationEcs} */
+      const installationsEcs = {
+        generateur_ecs_collection: {
+          generateur_ecs: [
+            {
+              donnee_entree: {
+                enum_type_stockage_ecs_id: 2,
+                enum_type_energie_id: 2,
+                volume_stockage: 100
+              }
+            },
+            {
+              donnee_entree: {
+                enum_type_stockage_ecs_id: 2,
+                enum_type_energie_id: 2,
+                volume_stockage: 150
+              }
+            },
+            {
+              donnee_entree: {
+                enum_type_stockage_ecs_id: 1,
+                enum_type_energie_id: 2,
+                volume_stockage: 150
+              }
+            }
+          ]
+        }
+      };
+
+      service.execute(installationsEcs);
+
+      expect(
+        installationsEcs.generateur_ecs_collection.generateur_ecs[0].donnee_utilisateur.Qgw
+      ).toBeCloseTo(851814.112128, 2);
+      expect(
+        installationsEcs.generateur_ecs_collection.generateur_ecs[1].donnee_utilisateur.Qgw
+      ).toBeCloseTo(1064620.98719, 2);
+      expect(
+        installationsEcs.generateur_ecs_collection.generateur_ecs[2].donnee_utilisateur.Qgw
+      ).toBe(0);
+    });
+  });
+
+  test("Determination du type d'énergie électrique du générateur", () => {
+    vi.spyOn(tvStore, 'getElectriqueEcsGenerateurs').mockReturnValue([1]);
+    expect(service.generateurElectrique({ enum_type_generateur_ecs_id: 1 })).toBeTruthy();
+    expect(service.generateurElectrique({ enum_type_generateur_ecs_id: 2 })).toBeFalsy();
+    expect(tvStore.getElectriqueEcsGenerateurs).toHaveBeenCalled();
+  });
+
+  test('Determination du type de stockage du générateur', () => {
+    expect(service.typeStockage({ enum_type_stockage_ecs_id: 1 })).toBe(TypeStockage.INSTANTANE);
+    expect(service.typeStockage({ enum_type_stockage_ecs_id: 2 })).toBe(TypeStockage.INDEPENDANT);
+    expect(service.typeStockage({ enum_type_stockage_ecs_id: 3 })).toBe(TypeStockage.INTEGRE);
+  });
+});

package/features/engine/domain/ecs/installation-ecs.service.js

@@ -0,0 +1,156 @@
+import { GenerateurEcsService } from './generateur-ecs.service.js';
+import { inject } from 'dioma';
+
+/**
+ * Calcul des besoins et pertes des installations ECS
+ * Données calculées
+ *  — besoin_ecs : besoin en eau chaude sanitaire en mode conventionnel proratisé pour l'installation
+ *  — besoin_ecs_depensier : besoin en eau chaude sanitaire en mode dépensier proratisé pour l'installation
+ *  — besoin_ecs_depensier : pertes liées au stockage de l'ECS pour chaque générateur
+ *  — QdwIndVc: pertes de la distribution individuelle en volume chauffé pour le mois j (Wh)
+ *  — QdwColVc: pertes de la distribution collective en volume chauffé pour le mois j (Wh)
+ *  — QdwColHVc: pertes de la distribution collective hors volume chauffé pour le mois j (Wh)
+ *
+ * @see Méthode de calcul 3CL-DPE 2021 (cotobre 2021) chapitre 3
+ */
+export class InstallationEcsService {
+  /**
+   * @type {GenerateurEcsService}
+   */
+  #generateurEcsService;
+
+  /**
+   * @param generateurEcsService {GenerateurEcsService}
+   */
+  constructor(generateurEcsService = inject(GenerateurEcsService)) {
+    this.#generateurEcsService = generateurEcsService;
+  }
+
+  /**
+   * Détermination des besoins et pertes des installations ECS
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @param besoinEcs {{besoin_ecs: number, besoin_ecs_depensier: number}}
+   */
+  execute(ctx, logement, besoinEcs) {
+    const installationsEcs = logement.installation_ecs_collection?.installation_ecs || [];
+
+    installationsEcs.forEach((installationEcs) => {
+      /**
+       * Calcul des données nécessaires au calcul pour chaque générateur (perteStockage)
+       */
+      this.#generateurEcsService.execute(installationEcs);
+
+      const { besoinEcsInstallation, besoinEcsDepensierInstallation } = this.besoinEcsInstallation(
+        ctx,
+        installationEcs,
+        besoinEcs
+      );
+
+      installationEcs.donnee_intermediaire = {
+        besoin_ecs: besoinEcsInstallation,
+        besoin_ecs_depensier: besoinEcsDepensierInstallation
+      };
+
+      /**
+       * Calcul des pertes de stockage et génération au niveau de l'installation
+       */
+      this.pertesDistributionStockageEcsInstallation(
+        installationEcs,
+        besoinEcsInstallation,
+        besoinEcsDepensierInstallation
+      );
+    });
+  }
+
+  /**
+   * Return true si l'installation est individuelle
+   * @param installationEcsDE {InstallationEcsDE}
+   */
+  isInstallationIndividuelle(installationEcsDE) {
+    return parseInt(installationEcsDE.enum_type_installation_id) === 1;
+  }
+
+  /**
+   * Return le besoin rationalisé de l'installation par rapport au besoin glbal du logement
+   *
+   * @param ctx {Contexte}
+   * @param installationEcs {InstallationEcs}
+   * @param besoinEcs {{besoin_ecs: number, besoin_ecs_depensier: number}} besoin ECS total du logement
+   *
+   * @returns {{besoinEcsInstallation: number, besoinEcsDepensierInstallation: number}}
+   */
+  besoinEcsInstallation(ctx, installationEcs, besoinEcs) {
+    /** @type {InstallationEcsDE} */
+    const installationEcsDE = installationEcs.donnee_entree;
+
+    let besoinEcsInstallation;
+    let besoinEcsDepensierInstallation;
+
+    const ratio =
+      (installationEcsDE.surface_habitable || ctx.surfaceHabitable) / ctx.surfaceHabitable;
+    besoinEcsInstallation = besoinEcs.besoin_ecs * ratio;
+    besoinEcsDepensierInstallation = besoinEcs.besoin_ecs_depensier * ratio;
+
+    return { besoinEcsInstallation, besoinEcsDepensierInstallation };
+  }
+
+  /**
+   * Pertes de distribution et stockage ECS au niveau de l'installation
+   * 15.2.3 - Consommation des auxiliaires de distribution d’ECS
+   *
+   * QdwIndVc: pertes de la distribution individuelle en volume chauffé pour le mois j (Wh)
+   * QdwColVc: pertes de la distribution collective en volume chauffé pour le mois j (Wh)
+   * QdwColHVc: pertes de la distribution collective hors volume chauffé pour le mois j (Wh)
+   *
+   * 11.6.1 - Pertes de stockage des ballons d’accumulation
+   * 11.6.2 - Pertes des ballons électriques
+   * Qgw:  pertes brutes annuelles de stockage (Wh)
+   *
+   * @param installationEcs {InstallationEcs}
+   * @param besoinEcsInstallation {number}
+   * @param besoinEcsDepensierInstallation {number}
+   */
+  pertesDistributionStockageEcsInstallation(
+    installationEcs,
+    besoinEcsInstallation,
+    besoinEcsDepensierInstallation
+  ) {
+    /** @type {InstallationEcsDE}*/
+    const installationEcsDE = installationEcs.donnee_entree;
+    const installationIndividuelle = this.isInstallationIndividuelle(installationEcsDE);
+
+    installationEcs.donnee_utilisateur = {
+      QdwIndVc: {
+        conventionnel: 0.1 * besoinEcsInstallation,
+        depensier: 0.1 * besoinEcsDepensierInstallation
+      },
+      QdwColVc: {
+        conventionnel: installationIndividuelle ? 0 : 0.112 * besoinEcsInstallation,
+        depensier: installationIndividuelle ? 0 : 0.112 * besoinEcsDepensierInstallation
+      },
+      QdwColHVc: {
+        conventionnel: installationIndividuelle ? 0 : 0.028 * besoinEcsInstallation,
+        depensier: installationIndividuelle ? 0 : 0.028 * besoinEcsDepensierInstallation
+      }
+    };
+
+    // 17.2.1.1 Calcul des consommations de chauffage, de refroidissement, d’ECS et d’auxiliaires
+    // Pour les installations ECS collectives, pas de récupération de stockage d'ECS
+    installationEcs.donnee_utilisateur.QgwRecuperable = 0;
+    if (installationIndividuelle) {
+      installationEcs.donnee_utilisateur.QgwRecuperable =
+        installationEcs.generateur_ecs_collection?.generateur_ecs
+          .filter(
+            (generateurEcs) =>
+              parseInt(generateurEcs.donnee_entree.position_volume_chauffe_stockage) === 1 ||
+              (generateurEcs.donnee_entree.position_volume_chauffe_stockage === undefined &&
+                parseInt(generateurEcs.donnee_entree.position_volume_chauffe) === 1)
+          )
+          .reduce((acc, generateurEcs) => {
+            return acc + generateurEcs.donnee_utilisateur.Qgw;
+          }, 0);
+    }
+  }
+}

package/features/engine/domain/ecs/installation-ecs.service.spec.js

@@ -0,0 +1,284 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import { GenerateurEcsService } from './generateur-ecs.service.js';
+import { InstallationEcsService } from './installation-ecs.service.js';
+import corpus from '../../../../../test/corpus-sano.json';
+import { expect_or, getAdemeFileJson } from '../../../../../test/test-helpers.js';
+import { DpeNormalizerService } from '../../../normalizer/domain/dpe-normalizer.service.js';
+import { ContexteBuilder } from '../contexte.builder.js';
+
+/** @type {InstallationEcsService} **/
+let service;
+
+/** @type {GenerateurEcsService} **/
+let generateurEcsService;
+
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
+describe('Calcul des besoins et des pertes des installations ECS', () => {
+  beforeEach(() => {
+    generateurEcsService = new GenerateurEcsService();
+    service = new InstallationEcsService(generateurEcsService);
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
+  });
+
+  test.each([
+    {
+      label: "Installation ECS sans surface habitable pour l'installation",
+      surfaceHabitableLogement: 40,
+      besoin_ecs: 850,
+      besoin_ecs_depensier: 1050,
+      expected: { besoinEcsDepensierInstallation: 1050, besoinEcsInstallation: 850 }
+    },
+    {
+      label: "Installation ECS avec surface habitable pour l'installation",
+      surfaceHabitableLogement: 40,
+      surfaceHabitableInstallation: 50,
+      besoin_ecs: 850,
+      besoin_ecs_depensier: 1050,
+      expected: { besoinEcsDepensierInstallation: 1312.5, besoinEcsInstallation: 1062.5 }
+    }
+  ])(
+    'Calcul des besoins proratisés pour $label',
+    ({
+      surfaceHabitableLogement,
+      surfaceHabitableInstallation = undefined,
+      besoin_ecs,
+      besoin_ecs_depensier,
+      expected
+    }) => {
+      /** @type {Contexte} */
+      const ctx = { surfaceHabitable: surfaceHabitableLogement };
+
+      /** @type {{besoin_ecs: number, besoin_ecs_depensier: number}} */
+      const besoinEcs = { besoin_ecs, besoin_ecs_depensier };
+
+      /** @type {InstallationEcs} */
+      const installationEcs = {
+        donnee_entree: { surface_habitable: surfaceHabitableInstallation }
+      };
+
+      const besoinEcsInstallation = service.besoinEcsInstallation(ctx, installationEcs, besoinEcs);
+
+      expect(besoinEcsInstallation).toStrictEqual(expected);
+    }
+  );
+
+  test.each([
+    {
+      label: 'Installation individuelle avec générateur hors volume chauffé',
+      enumTypeInstallationId: 1,
+      positionVolumeChauffeStockage1: 0,
+      positionVolumeChauffeStockage2: 0,
+      positionVolumeChauffeStockage3: 0,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 0, depensier: 0 },
+        QdwColHVc: { conventionnel: 0, depensier: 0 },
+        QgwRecuperable: 0
+      }
+    },
+    {
+      label: 'Installation individuelle avec générateur hors volume chauffé',
+      enumTypeInstallationId: 1,
+      positionVolumeChauffeStockage2: 0,
+      positionVolumeChauffe2: 0,
+      positionVolumeChauffeStockage3: 0,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 0, depensier: 0 },
+        QdwColHVc: { conventionnel: 0, depensier: 0 },
+        QgwRecuperable: 0
+      }
+    },
+    {
+      label: 'Installation individuelle avec 1 générateur en volume chauffé',
+      enumTypeInstallationId: 1,
+      positionVolumeChauffeStockage1: 0,
+      positionVolumeChauffeStockage2: 1,
+      positionVolumeChauffeStockage3: 0,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 0, depensier: 0 },
+        QdwColHVc: { conventionnel: 0, depensier: 0 },
+        QgwRecuperable: 120
+      }
+    },
+    {
+      label: 'Installation individuelle avec 1 générateur en volume chauffé',
+      enumTypeInstallationId: 1,
+      positionVolumeChauffeStockage1: 0,
+      positionVolumeChauffe2: 1,
+      positionVolumeChauffeStockage3: 0,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 0, depensier: 0 },
+        QdwColHVc: { conventionnel: 0, depensier: 0 },
+        QgwRecuperable: 120
+      }
+    },
+    {
+      label: 'Installation individuelle avec 2 générateurs en volume chauffé',
+      enumTypeInstallationId: 1,
+      positionVolumeChauffeStockage1: 0,
+      positionVolumeChauffeStockage2: 1,
+      positionVolumeChauffeStockage3: 1,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 0, depensier: 0 },
+        QdwColHVc: { conventionnel: 0, depensier: 0 },
+        QgwRecuperable: 260
+      }
+    },
+    {
+      label: 'Installation collective avec générateur hors volume chauffé',
+      enumTypeInstallationId: 2,
+      positionVolumeChauffeStockage1: 0,
+      positionVolumeChauffeStockage2: 0,
+      positionVolumeChauffeStockage3: 0,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 16.8, depensier: 30.24 },
+        QdwColHVc: { conventionnel: 4.2, depensier: 7.56 },
+        QgwRecuperable: 0
+      }
+    },
+    {
+      label: 'Installation collective avec 1 générateur en volume chauffé',
+      enumTypeInstallationId: 2,
+      positionVolumeChauffeStockage1: 0,
+      positionVolumeChauffeStockage2: 0,
+      positionVolumeChauffeStockage3: 1,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 16.8, depensier: 30.24 },
+        QdwColHVc: { conventionnel: 4.2, depensier: 7.56 },
+        QgwRecuperable: 0
+      }
+    },
+    {
+      label: 'Installation collective avec 2 générateurs en volume chauffé',
+      enumTypeInstallationId: 2,
+      positionVolumeChauffeStockage1: 1,
+      positionVolumeChauffeStockage2: 1,
+      positionVolumeChauffeStockage3: 0,
+      expected: {
+        QdwIndVc: { conventionnel: 15, depensier: 27 },
+        QdwColVc: { conventionnel: 16.8, depensier: 30.24 },
+        QdwColHVc: { conventionnel: 4.2, depensier: 7.56 },
+        QgwRecuperable: 0
+      }
+    }
+  ])(
+    'Calcul des pertes de distribution et de stockage $label',
+    ({
+      enumTypeInstallationId,
+      positionVolumeChauffeStockage1,
+      positionVolumeChauffeStockage2,
+      positionVolumeChauffe2 = undefined,
+      positionVolumeChauffeStockage3,
+      expected
+    }) => {
+      /** @type {InstallationEcs} */
+      const installationEcs = {
+        donnee_entree: { enum_type_installation_id: enumTypeInstallationId },
+        generateur_ecs_collection: {
+          generateur_ecs: [
+            {
+              donnee_entree: { position_volume_chauffe_stockage: positionVolumeChauffeStockage1 },
+              donnee_utilisateur: { Qgw: 100 }
+            },
+            {
+              donnee_entree: {
+                position_volume_chauffe_stockage: positionVolumeChauffeStockage2,
+                position_volume_chauffe: positionVolumeChauffe2
+              },
+              donnee_utilisateur: { Qgw: 120 }
+            },
+            {
+              donnee_entree: { position_volume_chauffe_stockage: positionVolumeChauffeStockage3 },
+              donnee_utilisateur: { Qgw: 140 }
+            }
+          ]
+        }
+      };
+
+      service.pertesDistributionStockageEcsInstallation(installationEcs, 150, 270);
+
+      expect(installationEcs.donnee_utilisateur.QdwIndVc.conventionnel).toBeCloseTo(
+        expected.QdwIndVc.conventionnel,
+        5
+      );
+      expect(installationEcs.donnee_utilisateur.QdwIndVc.depensier).toBeCloseTo(
+        expected.QdwIndVc.depensier,
+        5
+      );
+      expect(installationEcs.donnee_utilisateur.QdwColVc.conventionnel).toBeCloseTo(
+        expected.QdwColVc.conventionnel,
+        5
+      );
+      expect(installationEcs.donnee_utilisateur.QdwColVc.depensier).toBeCloseTo(
+        expected.QdwColVc.depensier,
+        5
+      );
+      expect(installationEcs.donnee_utilisateur.QdwColHVc.conventionnel).toBeCloseTo(
+        expected.QdwColHVc.conventionnel,
+        5
+      );
+      expect(installationEcs.donnee_utilisateur.QdwColHVc.depensier).toBeCloseTo(
+        expected.QdwColHVc.depensier,
+        5
+      );
+      expect(installationEcs.donnee_utilisateur.QgwRecuperable).toBeCloseTo(
+        expected.QgwRecuperable,
+        5
+      );
+    }
+  );
+
+  test("Determination du caractère individuelle de l'installation", () => {
+    expect(service.isInstallationIndividuelle({ enum_type_installation_id: 1 })).toBeTruthy();
+    expect(service.isInstallationIndividuelle({ enum_type_installation_id: 2 })).toBeFalsy();
+    expect(service.isInstallationIndividuelle({ enum_type_installation_id: 3 })).toBeFalsy();
+    expect(service.isInstallationIndividuelle({ enum_type_installation_id: 4 })).toBeFalsy();
+  });
+
+  describe("Test d'intégration des installations ECS", () => {
+    test.each(corpus)('vérification des DI des installations ECS pour dpe %s', (ademeId) => {
+      let dpeRequest = getAdemeFileJson(ademeId);
+      dpeRequest = normalizerService.normalize(dpeRequest);
+
+      /** @type {Contexte} */
+      const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+      const installationsECS = structuredClone(
+        dpeRequest.logement.installation_ecs_collection?.installation_ecs || []
+      );
+      service.execute(ctx, dpeRequest.logement, {
+        besoin_ecs: dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs,
+        besoin_ecs_depensier: dpeRequest.logement.sortie.apport_et_besoin.besoin_ecs_depensier
+      });
+
+      installationsECS.forEach((installationECS, i) => {
+        expect_or(
+          () =>
+            expect(installationECS.donnee_intermediaire.besoin_ecs).toBeCloseTo(
+              dpeRequest.logement.installation_ecs_collection.installation_ecs[i]
+                .donnee_intermediaire.besoin_ecs,
+              2
+            ),
+          () =>
+            expect(installationECS.donnee_intermediaire.besoin_ecs).toBeCloseTo(
+              dpeRequest.logement.installation_ecs_collection.installation_ecs[i]
+                .donnee_intermediaire.besoin_ecs * 1000,
+              2
+            )
+        );
+      });
+    });
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open3cl/engine",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {