@open3cl/engine 1.0.5 → 1.0.7

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

@@ -0,0 +1,140 @@
+import { TypeHabitation } from '../../dpe/domain/models/type-habitation.model.js';
+
+/**
+ * Génère un contexte du logement à étudier avec des données persistées durant l'analyse
+ */
+export class ContexteBuilder {
+  constructor() {}
+
+  /**
+   * @param dpe {Dpe}
+   * @return {Contexte}
+   */
+  fromDpe(dpe) {
+    return {
+      zoneClimatiqueId: dpe.logement.meteo?.enum_zone_climatique_id.toString(),
+      typeHabitation: this.#getTypeHabitation(dpe),
+      enumPeriodeConstructionId:
+        dpe.logement.caracteristique_generale.enum_periode_construction_id?.toString(),
+      effetJoule: this.#hasEffetJoule(dpe),
+      surfaceHabitable: this.#getSurfaceHabitable(dpe),
+      hauteurSousPlafond: dpe.logement.caracteristique_generale.hsp
+    };
+  }
+
+  /**
+   * Si un générateur de chauffage par résistance électrique existe, alors effet joule vaut vrai
+   * @param dpe {Dpe}
+   * @return {boolean}
+   */
+  #hasEffetJoule(dpe) {
+    return (
+      dpe.logement.installation_chauffage_collection?.installation_chauffage?.find((ic) =>
+        ic.emetteur_chauffage_collection?.emetteur_chauffage?.find(
+          (emetteur) => parseInt(emetteur.donnee_entree.enum_type_emission_distribution_id) <= 10
+        )
+      ) !== undefined
+    );
+  }
+
+  /**
+   * Le type d'habitation est détecté à partir du type de DPE
+   * @param dpe {Dpe}
+   * @return {TypeHabitation}
+   */
+  #getTypeHabitation(dpe) {
+    const methodeApplication =
+      dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id;
+
+    if (['1', '14', '18'].includes(methodeApplication)) {
+      return TypeHabitation.MAISON;
+    } else if (
+      [
+        '2',
+        '3',
+        '4',
+        '5',
+        '10',
+        '11',
+        '12',
+        '13',
+        '15',
+        '16',
+        '19',
+        '20',
+        '22',
+        '23',
+        '24',
+        '25',
+        '31',
+        '32',
+        '33',
+        '34',
+        '35',
+        '36',
+        '37',
+        '38',
+        '39',
+        '40'
+      ].includes(methodeApplication)
+    ) {
+      return TypeHabitation.APPARTEMENT;
+    }
+    return TypeHabitation.IMMEUBLE;
+  }
+
+  /**
+   * @param dpe {Dpe}
+   * @return {number}
+   */
+  #getSurfaceHabitable(dpe) {
+    /**
+     * Certains DPE appartement sont générés à partir des données du DPE immeuble, la surface à prendre en compte est
+     * celle de l'immeuble pour les besoins ECS
+     * 10 - dpe appartement généré à partir des données DPE immeuble chauffage individuel ecs individuel
+     * 11 - dpe appartement généré à partir des données DPE immeuble chauffage collectif ecs individuel
+     * 12 - dpe appartement généré à partir des données DPE immeuble chauffage individuel ecs collectif
+     * 13 - dpe appartement généré à partir des données DPE immeuble chauffage collectif ecs collectif
+     * 15 - dpe issu d'une étude thermique réglementaire RT2012 bâtiment : appartement chauffage collectif ecs collectif
+     * 16 - dpe issu d'une étude thermique réglementaire RT2012 bâtiment : appartement chauffage individuel ecs collectif
+     * 19 - dpe issu d'une étude energie environement réglementaire RE2020 bâtiment : appartement chauffage collectif ecs collectif
+     * 20 - dpe issu d'une étude energie environement réglementaire RE2020 bâtiment : appartement chauffage individuel ecs collectif
+     * 22 - dpe issu d'une étude thermique réglementaire RT2012 bâtiment : appartement chauffage individuel ecs individuel
+     * 23 - dpe issu d'une étude thermique réglementaire RT2012 bâtiment : appartement chauffage collectif ecs individuel
+     * 24 - dpe issu d'une étude energie environement réglementaire RE2020 bâtiment : appartement chauffage collectif ecs individuel
+     * 25 - dpe issu d'une étude energie environement réglementaire RE2020 bâtiment : appartement chauffage individuel ecs individuel
+     * 33 - dpe appartement généré à partir des données DPE immeuble chauffage mixte (collectif-individuel) ecs individuel
+     * 34 - dpe appartement généré à partir des données DPE immeuble chauffage mixte (collectif-individuel) ecs collectif
+     * 38 - dpe appartement généré à partir des données DPE immeuble chauffage mixte (collectif-individuel) ecs mixte (collectif-individuel)
+     * 39 - dpe appartement généré à partir des données DPE immeuble chauffage individuel ecs mixte (collectif-individuel)
+     * 40 - dpe appartement généré à partir des données DPE immeuble chauffage collectif ecs mixte (collectif-individuel)
+     */
+    if (
+      [
+        '10',
+        '11',
+        '12',
+        '13',
+        '15',
+        '16',
+        '19',
+        '20',
+        '22',
+        '23',
+        '24',
+        '25',
+        '33',
+        '34',
+        '38',
+        '39',
+        '40'
+      ].includes(dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id)
+    ) {
+      return dpe.logement.caracteristique_generale.surface_habitable_immeuble;
+    }
+
+    return this.#getTypeHabitation(dpe) === TypeHabitation.IMMEUBLE
+      ? dpe.logement.caracteristique_generale.surface_habitable_immeuble
+      : dpe.logement.caracteristique_generale.surface_habitable_logement;
+  }
+}

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

@@ -0,0 +1,152 @@
+import { ContexteBuilder } from './contexte.builder.js';
+import { beforeEach, describe, expect, test } from 'vitest';
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
+describe('Generateur du contexte du calcul', () => {
+  beforeEach(() => {
+    contexteBuilder = new ContexteBuilder();
+  });
+
+  test('Contexte avec effet joule', () => {
+    const dpe = {
+      logement: {
+        meteo: { enum_zone_climatique_id: 1 },
+        caracteristique_generale: {
+          enum_periode_construction_id: 1,
+          surface_habitable_logement: 48.9,
+          surface_habitable_immeuble: 105,
+          hsp: 2.8
+        },
+        installation_chauffage_collection: {
+          installation_chauffage: [
+            {
+              emetteur_chauffage_collection: {
+                emetteur_chauffage: [{ donnee_entree: { enum_type_emission_distribution_id: '1' } }]
+              }
+            }
+          ]
+        }
+      }
+    };
+
+    expect(contexteBuilder.fromDpe(dpe)).toStrictEqual({
+      effetJoule: true,
+      enumPeriodeConstructionId: '1',
+      zoneClimatiqueId: '1',
+      hauteurSousPlafond: 2.8,
+      surfaceHabitable: 105,
+      typeHabitation: 'IMMEUBLE'
+    });
+  });
+
+  test('Contexte sans effet joule', () => {
+    const dpe = {
+      logement: {
+        meteo: { enum_zone_climatique_id: 1 },
+        caracteristique_generale: {
+          enum_periode_construction_id: 1,
+          surface_habitable_logement: 48.9,
+          surface_habitable_immeuble: 105,
+          hsp: 2.8
+        },
+        installation_chauffage_collection: {
+          installation_chauffage: [
+            {
+              emetteur_chauffage_collection: {
+                emetteur_chauffage: [
+                  { donnee_entree: { enum_type_emission_distribution_id: '12' } }
+                ]
+              }
+            }
+          ]
+        }
+      }
+    };
+
+    expect(contexteBuilder.fromDpe(dpe)).toStrictEqual({
+      effetJoule: false,
+      enumPeriodeConstructionId: '1',
+      zoneClimatiqueId: '1',
+      hauteurSousPlafond: 2.8,
+      surfaceHabitable: 105,
+      typeHabitation: 'IMMEUBLE'
+    });
+  });
+
+  test('Contexte sans chauffage', () => {
+    const dpe = {
+      logement: {
+        meteo: { enum_zone_climatique_id: 1 },
+        caracteristique_generale: {
+          enum_periode_construction_id: 1,
+          surface_habitable_logement: 48.9,
+          surface_habitable_immeuble: 105,
+          hsp: 2.8
+        }
+      }
+    };
+
+    expect(contexteBuilder.fromDpe(dpe)).toStrictEqual({
+      effetJoule: false,
+      enumPeriodeConstructionId: '1',
+      zoneClimatiqueId: '1',
+      hauteurSousPlafond: 2.8,
+      surfaceHabitable: 105,
+      typeHabitation: 'IMMEUBLE'
+    });
+  });
+
+  test('Contexte sans emetteur de chauffage', () => {
+    const dpe = {
+      logement: {
+        meteo: { enum_zone_climatique_id: 1 },
+        caracteristique_generale: {
+          enum_periode_construction_id: 1,
+          surface_habitable_logement: 48.9,
+          surface_habitable_immeuble: 105,
+          hsp: 2.8
+        },
+        installation_chauffage_collection: {}
+      }
+    };
+
+    expect(contexteBuilder.fromDpe(dpe)).toStrictEqual({
+      effetJoule: false,
+      enumPeriodeConstructionId: '1',
+      zoneClimatiqueId: '1',
+      hauteurSousPlafond: 2.8,
+      surfaceHabitable: 105,
+      typeHabitation: 'IMMEUBLE'
+    });
+  });
+
+  test('Récupération de la surface habitable du logement concerné par le DPE', () => {
+    let dpe = {
+      logement: {
+        caracteristique_generale: {
+          enum_periode_construction_id: 1,
+          surface_habitable_logement: 48.9,
+          surface_habitable_immeuble: 105,
+          hsp: 2.8
+        }
+      }
+    };
+
+    dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id = '1';
+    expect(contexteBuilder.fromDpe(dpe)).toMatchObject({
+      surfaceHabitable: dpe.logement.caracteristique_generale.surface_habitable_logement
+    });
+
+    dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id = '5';
+    expect(contexteBuilder.fromDpe(dpe)).toMatchObject({
+      surfaceHabitable: dpe.logement.caracteristique_generale.surface_habitable_logement
+    });
+
+    dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id = '8';
+    expect(contexteBuilder.fromDpe(dpe)).toMatchObject({
+      surfaceHabitable: dpe.logement.caracteristique_generale.surface_habitable_immeuble
+    });
+  });
+});

package/features/engine/domain/engine.service.js

@@ -0,0 +1,139 @@
+import { inject } from 'dioma';
+import { ContexteBuilder } from './contexte.builder.js';
+import { DeperditionEnveloppeService } from './enveloppe/deperdition-enveloppe.service.js';
+
+export class EngineService {
+  /**
+   * @type {DeperditionEnveloppeService}
+   */
+  #deperditionService;
+  /**
+   * @type {ContexteBuilder}
+   */
+  #contextBuilder;
+
+  /**
+   * @param deperditionService {DeperditionEnveloppeService}
+   * @param contextBuilder {ContexteBuilder}
+   */
+  constructor(
+    deperditionService = inject(DeperditionEnveloppeService),
+    contextBuilder = inject(ContexteBuilder)
+  ) {
+    this.#deperditionService = deperditionService;
+    this.#contextBuilder = contextBuilder;
+  }
+
+  /**
+   * Applique la méthode 3CL à l'entrée du DPE
+   * @param dpe {Dpe}
+   * @return {Dpe} Nouveau DPE avec les données intermédiaires et les sorties calculées
+   */
+  execute(dpe) {
+    /** @type {Dpe} */
+    const proceededDpe = this.#removeComputedData(JSON.parse(JSON.stringify(dpe)));
+
+    console.error(`Process DPE ${proceededDpe.numero_dpe}`);
+
+    proceededDpe.logement.sortie = {
+      deperdition: undefined,
+      apport_et_besoin: undefined,
+      ef_conso: undefined,
+      ep_conso: undefined,
+      emission_ges: undefined,
+      cout: undefined,
+      production_electricite: undefined,
+      sortie_par_energie_collection: undefined,
+      confort_ete: undefined,
+      qualite_isolation: undefined
+    };
+    const ctx = this.#contextBuilder.fromDpe(proceededDpe);
+
+    // Calcul de l'inertie
+
+    // Calcul des déperditions
+    proceededDpe.logement.sortie.deperdition = this.#deperditionService.deperditions(
+      ctx,
+      dpe.logement
+    );
+
+    // Calcul des déperditions par renouvellement de l'air
+
+    // Calcul de l'intermittence
+
+    // Calcul des apports gratuit
+
+    // Calcul des besoins de chauffage
+
+    // Calcul des rendements des installations
+
+    // Calcul des rendements des générations
+
+    // Calcul des rendements des générateurs ECS
+
+    // Calcul des consommations chauffage
+
+    // Calcul des consommations de froid
+
+    // Calcul des consommations ECS
+
+    // Calcul des consommations d'auxiliaires des installations de chauffage et ECS
+
+    // Calcul des consommations d'auxiliaires de ventilation
+
+    // Calcul des consommations éclairage et production d'électricités
+
+    // Calcul du DPE dans le collectif
+
+    return proceededDpe;
+  }
+
+  /**
+   * Supprime toutes les données calculées d'un DPE
+   * Utilisé en particulier pour les DPE déjà existant.
+   * @param dpe {Dpe}
+   * @return {Dpe} DPE sans les données intermédiaires et les sorties calculées
+   */
+  #removeComputedData(dpe) {
+    delete dpe.logement.sortie;
+    delete dpe.logement.enveloppe.inertie;
+
+    dpe.logement.enveloppe.mur_collection.mur?.map((m) => delete m.donnee_intermediaire);
+    dpe.logement.enveloppe.baie_vitree_collection.baie_vitree?.map((m) => {
+      delete m.baie_vitree_double_fenetre?.donnee_intermediaire;
+      delete m.donnee_intermediaire;
+    });
+    delete dpe.logement.enveloppe.ets_collection.ets?.donnee_intermediaire;
+    dpe.logement.enveloppe.plancher_bas_collection.plancher_bas?.map(
+      (m) => delete m.donnee_intermediaire
+    );
+    dpe.logement.enveloppe.plancher_haut_collection.plancher_haut?.map(
+      (m) => delete m.donnee_intermediaire
+    );
+    dpe.logement.enveloppe.pont_thermique_collection.pont_thermique?.map(
+      (m) => delete m.donnee_intermediaire
+    );
+    dpe.logement.enveloppe.porte_collection.porte?.map((m) => delete m.donnee_intermediaire);
+    dpe.logement.climatisation_collection.climatisation?.map((m) => delete m.donnee_intermediaire);
+    dpe.logement.ventilation_collection.ventilation?.map((m) => delete m.donnee_intermediaire);
+    dpe.logement.ventilation_collection.ventilation?.map((m) => delete m.donnee_intermediaire);
+    dpe.logement.installation_ecs_collection.installation_ecs?.map((m) => {
+      m.generateur_ecs_collection.generateur_ecs?.map((n) => {
+        delete n.donnee_intermediaire;
+      });
+      delete m.donnee_intermediaire;
+    });
+    dpe.logement.installation_chauffage_collection.installation_chauffage?.map((m) => {
+      m.emetteur_chauffage_collection.emetteur_chauffage?.map((n) => {
+        delete n.donnee_intermediaire;
+      });
+      m.generateur_chauffage_collection.generateur_chauffage?.map((n) => {
+        delete n.donnee_intermediaire;
+      });
+      delete m.donnee_intermediaire;
+    });
+    delete dpe.logement.production_elec_enr?.donnee_intermediaire;
+
+    return dpe;
+  }
+}

package/features/engine/domain/engine.service.spec.js

@@ -0,0 +1,7 @@
+import { describe, test } from 'vitest';
+
+describe.skip('Application de la méthode 3CL', () => {
+  test('test complet de calcul (validation ADEME?)', () => {
+    // const dpe = EngineService.execute(originalDpe);=
+  });
+});

package/features/engine/domain/enveloppe/deperdition-enveloppe.service.js

@@ -0,0 +1,262 @@
+import { inject } from 'dioma';
+import { DeperditionMurService } from './mur/deperdition-mur.service.js';
+import { DeperditionPorteService } from './porte/deperdition-porte.service.js';
+import { DeperditionPlancherBasService } from './plancher_bas/deperdition-plancher-bas.service.js';
+import { DeperditionPlancherHautService } from './plancher_haut/deperdition-plancher-haut.service.js';
+import { DeperditionVentilationService } from './ventilation/deperdition-ventilation.service.js';
+
+/**
+ * Calcul des déperditions de l’enveloppe
+ * @see Méthode de calcul 3CL-DPE 2021 (cotobre 2021) chapitre 3
+ */
+export class DeperditionEnveloppeService {
+  /**
+   * @type {DeperditionMurService}
+   */
+  #deperditionMurService;
+
+  /**
+   * @type {DeperditionPorteService}
+   */
+  #deperditionPorteService;
+
+  /**
+   * @type {DeperditionPlancherBasService}
+   */
+  #deperditionPlancherBasService;
+
+  /**
+   * @type {DeperditionPlancherHautService}
+   */
+  #deperditionPlancherHautService;
+
+  /**
+   * @type {DeperditionVentilationService}
+   */
+  #deperditionVentilationService;
+
+  /**
+   * @type {number}
+   */
+  #surfaceDeperditive;
+
+  /**
+   * @type {number}
+   */
+  #surfaceIsolee;
+
+  /**
+   * @type {number}
+   */
+  #surfaceNonIsolee;
+
+  /**
+   * @type {number}
+   */
+  #surfaceMenuiserieAvecJoint;
+
+  /**
+   * @type {number}
+   */
+  #surfaceMenuiserieSansJoint;
+
+  /**
+   *
+   * @param deperditionMurService {DeperditionMurService}
+   * @param deperditionPorteService {DeperditionPorteService}
+   * @param deperditionPlancherBasService {DeperditionPlancherBasService}
+   * @param deperditionPlancherHautService {DeperditionPlancherHautService}
+   * @param deperditionVentilationService {DeperditionVentilationService}
+   */
+  constructor(
+    deperditionMurService = inject(DeperditionMurService),
+    deperditionPorteService = inject(DeperditionPorteService),
+    deperditionPlancherBasService = inject(DeperditionPlancherBasService),
+    deperditionPlancherHautService = inject(DeperditionPlancherHautService),
+    deperditionVentilationService = inject(DeperditionVentilationService)
+  ) {
+    this.#deperditionMurService = deperditionMurService;
+    this.#deperditionPorteService = deperditionPorteService;
+    this.#deperditionPlancherBasService = deperditionPlancherBasService;
+    this.#deperditionPlancherHautService = deperditionPlancherHautService;
+    this.#deperditionVentilationService = deperditionVentilationService;
+    this.#surfaceDeperditive = 0;
+    this.#surfaceIsolee = 0;
+    this.#surfaceNonIsolee = 0;
+    this.#surfaceMenuiserieAvecJoint = 0;
+    this.#surfaceMenuiserieSansJoint = 0;
+  }
+
+  /**
+   * Calcul des déperditions de l’enveloppe
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   * @returns {{hvent: number, hperm: number, deperdition_renouvellement_air: number, deperdition_mur: number, deperdition_plancher_bas: number, deperdition_plancher_haut: number, deperdition_baie_vitree: number, deperdition_porte: number, deperdition_pont_thermique: number, deperdition_enveloppe: number}}
+   */
+  deperditions(ctx, logement) {
+    const GV = this.#gv(ctx, logement.enveloppe);
+    const ventilation = this.#ventilation(ctx, logement);
+    return {
+      ...GV,
+      ...ventilation,
+      ...{
+        deperdition_enveloppe:
+          GV.deperdition_mur +
+          GV.deperdition_plancher_bas +
+          GV.deperdition_plancher_haut +
+          GV.deperdition_baie_vitree +
+          GV.deperdition_porte +
+          GV.deperdition_pont_thermique +
+          ventilation.hvent +
+          ventilation.hperm
+      }
+    };
+  }
+
+  /**
+   * Calcul des déperditions de l’enveloppe GV
+   *
+   * @param ctx {Contexte}
+   * @param enveloppe {Enveloppe}
+   *
+   * @return {Deperdition}
+   */
+  #gv(ctx, enveloppe) {
+    this.#surfaceDeperditive = 0;
+    this.#surfaceIsolee = 0;
+    this.#surfaceNonIsolee = 0;
+    this.#surfaceMenuiserieAvecJoint = 0;
+    this.#surfaceMenuiserieSansJoint = 0;
+
+    /**
+     * @type {Deperdition}
+     */
+    const deperditions = {
+      deperdition_mur: 0,
+      deperdition_plancher_bas: 0,
+      deperdition_plancher_haut: 0,
+      deperdition_porte: 0
+    };
+
+    enveloppe.mur_collection.mur?.forEach((m) => {
+      m.donnee_intermediaire = this.#deperditionMurService.execute(ctx, m.donnee_entree);
+      deperditions.deperdition_mur +=
+        m.donnee_intermediaire.b *
+        m.donnee_entree.surface_paroi_opaque *
+        m.donnee_intermediaire.umur;
+
+      if (m.donnee_intermediaire.b > 0) {
+        // Paroi déperditive si b != 0 et adjacence != 'local non déperditif'
+        if (m.donnee_entree.enum_type_adjacence_id !== '22') {
+          this.#surfaceDeperditive += m.donnee_entree.surface_paroi_opaque;
+        }
+        // Surface isolée si b != 0 et type d'isolation != 'inconnu' et != 'non isolé'
+        if (['1', '2'].includes(m.donnee_entree.enum_type_isolation_id)) {
+          this.#surfaceNonIsolee += m.donnee_entree.surface_paroi_opaque;
+        } else {
+          this.#surfaceIsolee += m.donnee_entree.surface_paroi_opaque;
+        }
+      }
+    });
+
+    enveloppe.porte_collection.porte?.forEach((p) => {
+      p.donnee_intermediaire = this.#deperditionPorteService.execute(ctx, p.donnee_entree);
+      deperditions.deperdition_porte +=
+        p.donnee_intermediaire.b * p.donnee_entree.surface_porte * p.donnee_intermediaire.uporte;
+
+      // Surface de porte déperditive si b != 0
+      if (p.donnee_intermediaire.b > 0) {
+        this.#surfaceDeperditive += p.donnee_entree.surface_porte;
+      }
+      // Surface de porte avec ou sans joint
+      if (p.donnee_entree.presence_joint) {
+        this.#surfaceMenuiserieAvecJoint += p.donnee_entree.surface_porte;
+      } else {
+        this.#surfaceMenuiserieSansJoint += p.donnee_entree.surface_porte;
+      }
+    });
+
+    const plancherBas = enveloppe.plancher_bas_collection.plancher_bas || [];
+    plancherBas?.forEach((pb) => {
+      pb.donnee_intermediaire = this.#deperditionPlancherBasService.execute(
+        ctx,
+        pb.donnee_entree,
+        plancherBas
+      );
+      deperditions.deperdition_plancher_bas +=
+        pb.donnee_intermediaire.b *
+        pb.donnee_entree.surface_paroi_opaque *
+        pb.donnee_intermediaire.upb_final;
+    });
+
+    enveloppe.plancher_haut_collection.plancher_haut?.forEach((ph) => {
+      ph.donnee_intermediaire = this.#deperditionPlancherHautService.execute(ctx, ph.donnee_entree);
+      deperditions.deperdition_plancher_haut +=
+        ph.donnee_intermediaire.b *
+        ph.donnee_entree.surface_paroi_opaque *
+        ph.donnee_intermediaire.uph;
+
+      if (ph.donnee_intermediaire.b > 0) {
+        // Plancher déperditif si b != 0 et adjacence != 'local non déperditif'
+        if (ph.donnee_entree.enum_type_adjacence_id !== '22') {
+          this.#surfaceDeperditive += ph.donnee_entree.surface_paroi_opaque;
+        }
+        // Surface isolée si b != 0 et type d'isolation != 'inconnu' et != 'non isolé'
+        if (['1', '2'].includes(ph.donnee_entree.enum_type_isolation_id)) {
+          this.#surfaceNonIsolee += ph.donnee_entree.surface_paroi_opaque;
+        } else {
+          this.#surfaceIsolee += ph.donnee_entree.surface_paroi_opaque;
+        }
+      }
+    });
+
+    enveloppe.baie_vitree_collection.baie_vitree?.forEach((bv) => {
+      // Surface de baie vitrée déperditive si b != 0
+      if (bv.donnee_intermediaire.b > 0) {
+        this.#surfaceDeperditive += bv.donnee_entree.surface_totale_baie;
+      }
+      // Surface de baie vitrée avec ou sans joint
+      if (bv.donnee_entree.presence_joint) {
+        this.#surfaceMenuiserieAvecJoint += bv.donnee_entree.surface_totale_baie;
+      } else {
+        this.#surfaceMenuiserieSansJoint += bv.donnee_entree.surface_totale_baie;
+      }
+    });
+
+    return deperditions;
+  }
+
+  /**
+   * Calcul des déperditions par la ventilation
+   *
+   * @param ctx {Contexte}
+   * @param logement {Logement}
+   *
+   * @return {Deperdition}
+   */
+  #ventilation(ctx, logement) {
+    /**
+     * @type {Deperdition}
+     */
+    const deperditions = {
+      hperm: 0,
+      hvent: 0
+    };
+
+    logement.ventilation_collection.ventilation?.forEach((ventilation) => {
+      ventilation.donnee_intermediaire = this.#deperditionVentilationService.execute(
+        ctx,
+        ventilation.donnee_entree,
+        this.#surfaceDeperditive,
+        this.#surfaceIsolee,
+        this.#surfaceNonIsolee,
+        this.#surfaceMenuiserieAvecJoint,
+        this.#surfaceMenuiserieSansJoint
+      );
+      deperditions.hvent += ventilation.donnee_intermediaire.hvent;
+      deperditions.hperm += ventilation.donnee_intermediaire.hperm;
+    });
+
+    return deperditions;
+  }
+}