@open3cl/engine 1.0.11 → 1.0.13

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 * 1000,
+        besoinEcsDepensierInstallation * 1000
+      );
+    });
+  }
+
+  /**
+   * 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 global 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} // en Wh
+   * @param besoinEcsDepensierInstallation {number} // en Wh
+   */
+  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
+            )
+        );
+      });
+    });
+  });
+});