@open3cl/engine 1.0.11 → 1.0.13

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

@@ -0,0 +1,313 @@
+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 { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
+import { mois_liste } from '../../../../../utils.js';
+import { PerteChRecupService } from './perte-ch-recup.service.js';
+import { BesoinChService } from './besoin-ch.service.js';
+import { ApportGratuitService } from '../apport_gratuit/apport-gratuit.service.js';
+import { PRECISION_PERCENT } from '../../../../../../test/constant.js';
+
+/** @type {PerteChRecupService} **/
+let service;
+
+/** @type {BesoinChService} **/
+let besoinChService;
+
+/** @type {ApportGratuitService} **/
+let apportGratuitService;
+
+/** @type {FrTvStore} **/
+let tvStore;
+
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
+describe('Calcul des pertes de génération de chauffage récupérées', () => {
+  beforeEach(() => {
+    tvStore = new FrTvStore();
+    service = new PerteChRecupService(tvStore);
+    besoinChService = new BesoinChService();
+    apportGratuitService = new ApportGratuitService();
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
+  });
+
+  test.each([
+    {
+      label: 'Installation CH uniquement avec ventouse, utilisation de nref',
+      enumUsageGenerateurId: 1,
+      presenceVentouse: 1,
+      expected: 562.5
+    },
+    {
+      label: 'Installation CH uniquement sans ventouse, utilisation de nref',
+      enumUsageGenerateurId: 1,
+      presenceVentouse: 0,
+      expected: 375
+    },
+    {
+      label: "Installation CH uniquement sans ventouse, pas d'utilisation de nref",
+      enumUsageGenerateurId: 1,
+      presenceVentouse: 0,
+      nref: 500,
+      expected: 7971.08
+    },
+    {
+      label: 'Installation ECS uniquement avec ventouse',
+      enumUsageGenerateurId: 2,
+      presenceVentouse: 1,
+      expected: 114.94
+    },
+    {
+      label: 'Installation ECS uniquement sans ventouse',
+      enumUsageGenerateurId: 2,
+      presenceVentouse: 0,
+      expected: 76.627
+    },
+    {
+      label: 'Installation ECS + CH avec ventouse, utilisation de nref',
+      enumUsageGenerateurId: 3,
+      presenceVentouse: 1,
+      expected: 562.5
+    },
+    {
+      label: 'Installation ECS + CH sans ventouse, utilisation de nref',
+      enumUsageGenerateurId: 3,
+      presenceVentouse: 0,
+      expected: 375
+    },
+    {
+      label: "Installation ECS + CH sans ventouse, pas d'utilisation de nref",
+      enumUsageGenerateurId: 3,
+      presenceVentouse: 0,
+      nref: 450,
+      expected: 10729.642
+    }
+  ])(
+    'Calcul des pertes récupérées de génération pour le chauffage sur un mois pour $label',
+    ({ enumUsageGenerateurId, presenceVentouse, nref = undefined, expected }) => {
+      /** @type {GenerateurChauffage[]} */
+      const generateurs = [
+        {
+          donnee_entree: {
+            presence_ventouse: presenceVentouse,
+            enum_usage_generateur_id: enumUsageGenerateurId
+          },
+          donnee_intermediaire: { pn: 25000, qp0: 125 }
+        }
+      ];
+
+      expect(service.Qrec(generateurs, nref ?? 12.5, 1532.9)).toBeCloseTo(expected, 3);
+    }
+  );
+
+  test('Filtre des générateurs avec pertes de génération', () => {
+    const generateur1 = {
+      donnee_entree: {}
+    };
+    const generateur2 = {
+      donnee_entree: { position_volume_chauffe: 0, enum_type_generateur_ch_id: 45 }
+    };
+    const generateur3 = {
+      donnee_entree: { position_volume_chauffe: 0, enum_type_generateur_ch_id: 50 }
+    };
+    const generateur4 = {
+      donnee_entree: { position_volume_chauffe: 1, enum_type_generateur_ch_id: 50 }
+    };
+    const generateur5 = {
+      donnee_entree: { position_volume_chauffe: 1, enum_type_generateur_ch_id: 48 }
+    };
+
+    /** @type {Logement} */
+    let logement = { installation_chauffage_collection: {} };
+    expect(service.generateursWithPertesGeneration(logement)).toStrictEqual([]);
+
+    logement.installation_chauffage_collection = { installation_chauffage: [] };
+    expect(service.generateursWithPertesGeneration(logement)).toStrictEqual([]);
+
+    logement.installation_chauffage_collection = {
+      installation_chauffage: [{ generateur_chauffage_collection: {} }]
+    };
+    expect(service.generateursWithPertesGeneration(logement)).toStrictEqual([]);
+
+    logement.installation_chauffage_collection = {
+      installation_chauffage: [{ generateur_chauffage_collection: { generateur_chauffage: [] } }]
+    };
+    expect(service.generateursWithPertesGeneration(logement)).toStrictEqual([]);
+
+    logement.installation_chauffage_collection = {
+      installation_chauffage: [
+        {
+          generateur_chauffage_collection: {
+            generateur_chauffage: [generateur1, generateur2, generateur3]
+          }
+        },
+        { generateur_chauffage_collection: { generateur_chauffage: [generateur4, generateur5] } }
+      ]
+    };
+    expect(service.generateursWithPertesGeneration(logement)).toStrictEqual([generateur5]);
+  });
+
+  test.each([
+    {
+      label: 'Installation CH en mode conventionnel',
+      depensier: false,
+      expected: 288
+    },
+    {
+      label: 'Installation CH en mode dépensier',
+      depensier: true,
+      expected: 540
+    }
+  ])('Pertes de chauffage récupérées pour $label', ({ depensier, expected }) => {
+    vi.spyOn(tvStore, 'getData').mockReturnValue(depensier ? 1.5 : 0.8);
+
+    /** @type {Contexte} */
+    const ctx = {
+      altitude: { value: '400-800m' },
+      zoneClimatique: { value: 'h1a' },
+      inertie: { ilpa: 1 }
+    };
+
+    /** @type {Logement} */
+    const logement = {
+      installation_chauffage_collection: {
+        installation_chauffage: [
+          {
+            generateur_chauffage_collection: {
+              generateur_chauffage: [
+                {
+                  donnee_entree: {
+                    position_volume_chauffe: 1,
+                    enum_type_generateur_ch_id: 48,
+                    enum_usage_generateur_id: 1
+                  },
+                  donnee_intermediaire: { pn: 25000, qp0: 125 }
+                }
+              ]
+            }
+          }
+        ]
+      },
+      donnees_de_calcul: {
+        besoinChauffageHP: {
+          Janvier: 102.5,
+          Février: 102.5,
+          Mars: 102.5,
+          Avril: 102.5,
+          Mai: 102.5,
+          Juin: 102.5,
+          Juillet: 102.5,
+          Aout: 102.5,
+          Septembre: 102.5,
+          Octobre: 102.5,
+          Novembre: 102.5,
+          Décembre: 102.5
+        },
+        besoinChauffageDepensierHP: {
+          Janvier: 112.5,
+          Février: 112.5,
+          Mars: 112.5,
+          Avril: 112.5,
+          Mai: 112.5,
+          Juin: 112.5,
+          Juillet: 112.5,
+          Aout: 112.5,
+          Septembre: 112.5,
+          Octobre: 112.5,
+          Novembre: 112.5,
+          Décembre: 112.5
+        }
+      }
+    };
+
+    expect(service.pertesGenerateurChRecup(ctx, logement, depensier)).toBeCloseTo(expected, 3);
+    for (const mois of mois_liste) {
+      expect(tvStore.getData).toHaveBeenCalledWith(
+        depensier ? 'nref21' : 'nref19',
+        '400-800m',
+        'h1a',
+        mois,
+        1
+      );
+    }
+  });
+
+  describe("Test d'intégration des installations CH", () => {
+    test.each(corpus)('vérification des pertes de génération ch pour dpe %s', (ademeId) => {
+      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);
+      apportGratuitService.apportInterne(ctx, dpeRequest.logement);
+      apportGratuitService.apportSolaire(ctx, dpeRequest.logement);
+      besoinChService.execute(ctx, dpeRequest.logement);
+      const pertesGeneration = service.execute(ctx, dpeRequest.logement);
+
+      const expectedValue = dpeRequest.logement.sortie.apport_et_besoin.pertes_generateur_ch_recup;
+      const calculatedValue = pertesGeneration.pertes_generateur_ch_recup;
+
+      expect_or(
+        () =>
+          expect(Math.abs(calculatedValue - expectedValue) / (expectedValue || 1)).toBeLessThan(
+            PRECISION_PERCENT
+          ),
+        () =>
+          expect(
+            Math.abs(calculatedValue - expectedValue * 1000) / (expectedValue * 1000 || 1)
+          ).toBeLessThan(PRECISION_PERCENT)
+      );
+    });
+
+    test.each(corpus)(
+      'vérification des pertes de génération ch depensier des installations CH pour dpe %s',
+      (ademeId) => {
+        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);
+        apportGratuitService.apportInterne(ctx, dpeRequest.logement);
+        apportGratuitService.apportSolaire(ctx, dpeRequest.logement);
+        besoinChService.execute(ctx, dpeRequest.logement);
+        const pertesGeneration = service.execute(ctx, dpeRequest.logement);
+
+        const expectedValue =
+          dpeRequest.logement.sortie.apport_et_besoin.pertes_generateur_ch_recup_depensier;
+        const calculatedValue = pertesGeneration.pertes_generateur_ch_recup_depensier;
+
+        expect_or(
+          () =>
+            expect(Math.abs(calculatedValue - expectedValue) / (expectedValue || 1)).toBeLessThan(
+              PRECISION_PERCENT
+            ),
+          () =>
+            expect(
+              Math.abs(calculatedValue - expectedValue * 1000) / (expectedValue * 1000 || 1)
+            ).toBeLessThan(PRECISION_PERCENT)
+        );
+      }
+    );
+  });
+});

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

@@ -0,0 +1,127 @@
+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;
+  }
+
+  /**
+   * Pertes de distribution et de stockage ECS (kWh)
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @return {{pertes_distribution_ecs_recup: number, pertes_distribution_ecs_recup_depensier: number, pertes_stockage_ecs_recup: number, pertes_stockage_ecs_recup_depensier: number}}
+   */
+  execute(ctx, logement) {
+    return {
+      pertes_distribution_ecs_recup: this.pertesDistributionEcsRecup(ctx, logement, false) / 1000,
+      pertes_distribution_ecs_recup_depensier:
+        this.pertesDistributionEcsRecup(ctx, logement, true) / 1000,
+      pertes_stockage_ecs_recup: this.pertesStockageEcsRecup(ctx, logement, false) / 1000,
+      pertes_stockage_ecs_recup_depensier: this.pertesStockageEcsRecup(ctx, logement, true) / 1000
+    };
+  }
+
+  /**
+   * Pertes récupérées de distribution d’ECS pour le chauffage (Wh)
+   * 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 (Wh)
+   * 9.1.1 Consommation de chauffage
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @param depensier {boolean}
+   * @returns {number}
+   */
+  pertesStockageEcsRecup(ctx, logement, depensier) {
+    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(
+            depensier ? 'nref21' : '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,220 @@
+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.192
+    },
+    {
+      label: 'Installation ECS en mode dépensier',
+      depensier: true,
+      expected: 0.725
+    }
+  ])('Calcul des pertes de distribution récupérées pour $label', ({ depensier, expected }) => {
+    vi.spyOn(tvStore, 'getData').mockReturnValue(depensier ? 1.5 : 0.8);
+
+    /** @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, 3);
+    for (const mois of mois_liste) {
+      expect(tvStore.getData).toHaveBeenCalledWith(
+        depensier ? 'nref21' : 'nref19',
+        '400-800m',
+        'h1a',
+        mois,
+        1
+      );
+    }
+  });
+
+  test.each([
+    {
+      label: 'Installation ECS en mode conventionnel',
+      depensier: false,
+      expected: 63.209
+    },
+    {
+      label: 'Installation ECS en mode dépensier',
+      depensier: true,
+      expected: 118.516
+    }
+  ])('Calcul des pertes de stockage récupérées pour $label', ({ depensier, expected }) => {
+    vi.spyOn(tvStore, 'getData').mockReturnValue(depensier ? 1.5 : 0.8);
+
+    /** @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: 120012 } },
+          { donnee_utilisateur: { QgwRecuperable: 150 } }
+        ]
+      }
+    };
+
+    expect(service.pertesStockageEcsRecup(ctx, logement, depensier)).toBeCloseTo(expected, 3);
+    for (const mois of mois_liste) {
+      expect(tvStore.getData).toHaveBeenCalledWith(
+        depensier ? 'nref21' : '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 * 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;
   }