@open3cl/engine 1.0.13 → 1.0.15

package/13.2_generateur_combustion_ch.js

@@ -37,7 +37,7 @@ export function tv_temp_fonc_30_100(di, de, du, em_ch, ac) {
     const em_ch_de = em.donnee_entree;
     const em_ch_du = em.donnee_utilisateur;
     const matcher = {
-      type_generateur_ch_id: de.enum_type_generateur_ch_id,
+      enum_type_generateur_ch_id: de.enum_type_generateur_ch_id,
       enum_temp_distribution_ch_id: requestInputID(em_ch_de, em_ch_du, 'temp_distribution_ch'),
       periode_emetteurs: requestInput(em_ch_de, em_ch_du, 'periode_installation_emetteur')
     };

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

@@ -8,6 +8,7 @@ export interface Climatisation {
 export interface ClimatisationDE extends DE {
   tv_seer_id?: number;
   nombre_logement_echantillon?: number;
+  surface_clim?: number;
   enum_methode_calcul_conso_id: number;
   enum_periode_installation_fr_id: number;
   cle_repartition_clim?: number;

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

@@ -1,4 +1,5 @@
 import { DE } from './dpe.model';
+import { GenerateurEcsDU } from './installation-ecs.model';
 
 export interface InstallationChauffage {
   donnee_entree?: InstallationChauffageDE;
@@ -62,6 +63,7 @@ export interface EmetteurChauffageDI {
 
 export interface GenerateurChauffage {
   donnee_entree?: GenerateurChauffageDE;
+  donnee_utilisateur?: GenerateurChauffageDU;
   donnee_intermediaire?: GenerateurChauffageDI;
 }
 
@@ -99,3 +101,25 @@ export interface GenerateurChauffageDI {
   conso_ch: number;
   conso_ch_depensier: number;
 }
+
+export interface GenerateurChauffageDU {
+  ratio_virtualisation?: number;
+  typeGenerateur?: TypeGenerateur;
+  combustion: boolean;
+  pac: boolean;
+  generateur?: {
+    tv_generateur_combustion_id: string;
+    enum_type_generateur_ch_id: string;
+    type_generateur: string;
+    critere_pn: string;
+    pveil: string;
+    qp0_perc: string;
+    rpint: string;
+    rpn: string;
+  };
+}
+
+export enum TypeGenerateur {
+  CHAUDIERE = 'CHAUDIERE',
+  OTHER = 'OTHER'
+}

package/features/dpe/domain/models/type-generateur.model.js

@@ -0,0 +1,8 @@
+/**
+ * @type {{[key: string]: string}}
+ */
+export const TypeGenerateur = {
+  COMBUSTION: 'COMBUSTION',
+  PAC: 'PAC',
+  OTHER: 'OTHER'
+};

package/features/dpe/infrastructure/ch/chTv.store.js

@@ -0,0 +1,94 @@
+import { tvs as tv } from '../../../../tv-v2.js';
+import { TvStore } from './../tv.store.js';
+import { convertExpression } from '../../../../utils.js';
+import enums from '../../../../enums.js';
+import { logger } from '../../../../core/util/logger/log-service.js';
+
+/**
+ * Accès aux données des tables de valeurs pour le chauffage
+ */
+export class ChTvStore extends TvStore {
+  /**
+   * Récupération des ids des générateurs de chauffage à combustion
+   * @return {[number]}
+   */
+  getCombustionGenerateurs() {
+    return this.#getTypeGenerateurChId('generateur_combustion');
+  }
+  /**
+   * Récupération des ids des générateurs de chauffage pompes à chaleur
+   * @return {[number]}
+   */
+  getPacGenerateurs() {
+    return this.#getTypeGenerateurChId('scop');
+  }
+
+  /**
+   * @param tvType {string}
+   * @returns {any[]}
+   */
+  #getTypeGenerateurChId(tvType) {
+    return [
+      ...new Set(
+        tv[tvType].flatMap((v) =>
+          (v.enum_type_generateur_ch_id
+            ? v.enum_type_generateur_ch_id.split('|').map(Number)
+            : []
+          ).filter(Number.isFinite)
+        )
+      )
+    ].sort((a, b) => a - b);
+  }
+
+  /**
+   * Récupération des informations du générateur à combustion
+   * @param enumTypeGenerateurId
+   * @param pn
+   * @return {{tv_generateur_combustion_id: string, enum_type_generateur_ch_id: string, type_generateur: string, critere_pn: string, pveil: string, qp0_perc: string, rpint: string, rpn: string}}
+   */
+  getGenerateurCombustion(enumTypeGenerateurId, pn) {
+    return tv['generateur_combustion'].find(
+      (v) =>
+        v.enum_type_generateur_ch_id &&
+        v.enum_type_generateur_ch_id.split('|').includes(enumTypeGenerateurId) &&
+        (!v.critere_pn ||
+          eval(`let Pn=${pn} ;${convertExpression(v.critere_pn.replace('≤', '<='))}`))
+    );
+  }
+
+  /**
+   * Récupération de la température de fonctionnement
+   *
+   * @param pourcentageFonctionnement pourcentage de fonctionnement du générateur (30% ou 100%)
+   * @param enumTypeGenerateurId
+   * @param enumTemperatureDistribution
+   * @param enumPeriodeEmetteurs
+   * @return {number}
+   */
+  temperatureFonctionnement(
+    pourcentageFonctionnement,
+    enumTypeGenerateurId,
+    enumTemperatureDistribution,
+    enumPeriodeEmetteurs
+  ) {
+    const temperatureDistribution = enums.temp_distribution_ch[enumTemperatureDistribution];
+    const periodeEmetteur = enums.periode_installation_emetteur[enumPeriodeEmetteurs];
+
+    const temperature = tv[`temp_fonc_${pourcentageFonctionnement}`].find(
+      (v) =>
+        (!v.enum_type_generateur_ch_id ||
+          v.enum_type_generateur_ch_id.split('|').includes(enumTypeGenerateurId)) &&
+        v.temp_distribution_ch.toLowerCase() === temperatureDistribution?.toLowerCase() &&
+        v.periode_emetteurs.toLowerCase() === periodeEmetteur?.toLowerCase()
+    );
+
+    if (!temperature) {
+      logger.error(
+        `Pas de valeur forfaitaire temp_fonc_${pourcentageFonctionnement} pour enumTypeGenerateurId:${enumTypeGenerateurId}, enumTemperatureDistribution:${enumTemperatureDistribution}, enumPeriodeEmetteurs:${enumPeriodeEmetteurs}`
+      );
+      return;
+    }
+
+    return parseFloat(temperature[`temp_fonc_${pourcentageFonctionnement}`]);
+  }
+}

package/features/dpe/infrastructure/ch/chTv.store.spec.js

@@ -0,0 +1,99 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import { ChTvStore } from './chTv.store.js';
+
+/** @type {ChTvStore} **/
+let chTvStore;
+
+describe('Lecture des tables de valeurs', () => {
+  beforeEach(() => {
+    chTvStore = new ChTvStore();
+  });
+
+  test('ids des générateurs de chauffage à combustion', () => {
+    expect(chTvStore.getCombustionGenerateurs()).toStrictEqual([
+      48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+      71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
+      94, 95, 96, 97, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
+      134, 135, 136, 137, 138, 139, 140, 141, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
+      159, 160, 161
+    ]);
+  });
+
+  test('ids des générateurs de chauffage pompe à chaleur', () => {
+    expect(chTvStore.getPacGenerateurs()).toStrictEqual([
+      1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 143, 145, 146, 147, 162,
+      163, 164, 165, 166, 167, 168, 169, 170
+    ]);
+  });
+
+  test('Caractéristique du générateur à combustion', () => {
+    expect(chTvStore.getGenerateurCombustion('128', 125)).toStrictEqual({
+      tv_generateur_combustion_id: '2',
+      enum_type_generateur_ch_id: '86|128',
+      enum_type_generateur_ecs_id: '46|93',
+      type_generateur: 'Chaudière gaz  classique 1981-1985',
+      pn: 'Pn',
+      rpn: '84 + 2 logPn',
+      rpint: '80 + 3 logPn',
+      qp0_perc: '2%',
+      pveil: '150'
+    });
+
+    expect(chTvStore.getGenerateurCombustion('84', 125)).toStrictEqual({
+      tv_generateur_combustion_id: '26',
+      enum_type_generateur_ch_id: '84',
+      enum_type_generateur_ecs_id: '44',
+      type_generateur: 'Chaudière fioul à condensation après 2015',
+      critere_pn: '70<Pn≤400',
+      pn: 'Pn',
+      rpn: '94 + logPn',
+      rpint: '100 + logPn',
+      qp0_perc: '0.60%'
+    });
+  });
+
+  describe('Lecture des valeurs de temp_fonc_30 ou temp_fonc_100', () => {
+    test.each([
+      {
+        label:
+          "Chaudière standard après 1990, emetteurs entre 1981 et 2000, basse température d'émission",
+        pourcentageFonctionnement: 30,
+        enumTypeGenerateurId: '89',
+        enumTemperatureDistribution: 2,
+        enumPeriodeEmetteurs: 2,
+        expected: 45
+      },
+      {
+        label: "Emetteurs entre 1981 et 2000, basse température d'émission",
+        pourcentageFonctionnement: 100,
+        enumTypeGenerateurId: '89',
+        enumTemperatureDistribution: 2,
+        enumPeriodeEmetteurs: 2,
+        expected: 35
+      }
+    ])(
+      `$label`,
+      ({
+        pourcentageFonctionnement,
+        enumTypeGenerateurId,
+        enumTemperatureDistribution,
+        enumPeriodeEmetteurs,
+        expected
+      }) => {
+        expect(
+          chTvStore.temperatureFonctionnement(
+            pourcentageFonctionnement,
+            enumTypeGenerateurId,
+            enumTemperatureDistribution,
+            enumPeriodeEmetteurs
+          )
+        ).toBe(expected);
+      }
+    );
+
+    test('pas de valeur de temp_fonc_30 ou temp_fonc_100', () => {
+      const pertes_stockage = chTvStore.temperatureFonctionnement(100, 600, 600, 600);
+      expect(pertes_stockage).toBeUndefined();
+    });
+  });
+});

package/features/dpe/infrastructure/ecs/ecsTv.store.js

@@ -58,8 +58,10 @@ export class EcsTvStore extends TvStore {
    * @return {[number]}
    */
   getElectriqueEcsGenerateurs() {
-    return tv['pertes_stockage'].flatMap((v) =>
-      v.enum_type_generateur_ecs_id.split('|').map(Number)
-    );
+    return [
+      ...new Set(
+        tv['pertes_stockage'].flatMap((v) => v.enum_type_generateur_ecs_id.split('|').map(Number))
+      )
+    ];
   }
 }

package/features/dpe/infrastructure/ecs/ecsTv.store.spec.js

@@ -66,4 +66,8 @@ describe('Lecture des tables de valeurs', () => {
       expect(pertes_stockage).toBeUndefined();
     });
   });
+
+  test('ids des générateurs électriques ECS', () => {
+    expect(ecsTvStore.getElectriqueEcsGenerateurs()).toStrictEqual([68, 118, 69, 70, 71]);
+  });
 });

package/features/dpe/infrastructure/froid/frTv.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 froid
@@ -35,4 +36,30 @@ export class FrTvStore extends TvStore {
 
     return parseFloat(values[classeAltitude][mois][zoneClimatique]);
   }
+
+  /**
+   * Coefficient d’efficience énergétique
+   * @see 10.3 - Les consommations de refroidissement
+   *
+   * @param zoneClimatiqueId {string}
+   * @param periodeInstallationId {number}
+   *
+   * @return {number|undefined}
+   */
+  getEer(zoneClimatiqueId, periodeInstallationId) {
+    const eer = tv['seer'].find(
+      (v) =>
+        v.enum_zone_climatique_id.split('|').includes(zoneClimatiqueId) &&
+        parseInt(v.enum_periode_installation_fr_id) === periodeInstallationId
+    )?.eer;
+
+    if (!eer) {
+      logger.error(
+        `Pas de valeur forfaitaire eer pour zoneClimatiqueId:${zoneClimatiqueId}, periodeInstallationId:${periodeInstallationId}`
+      );
+      return;
+    }
+
+    return parseFloat(eer);
+  }
 }

package/features/dpe/infrastructure/froid/frTv.store.spec.js

@@ -49,4 +49,26 @@ describe('Lecture des tables de valeurs', () => {
       expect(tvStore.getData(type, '400-800m', 'h1a', 'Juin', ilpa)).toBe(expected);
     });
   });
+
+  describe('Lecture des valeurs de coefficient d’efficience énergétique eer', () => {
+    test.each([
+      {
+        zoneClimatiqueId: '2',
+        periodeInstallationId: 1,
+        expected: 3.6
+      },
+      {
+        zoneClimatiqueId: '8',
+        periodeInstallationId: 2,
+        expected: 5.415
+      }
+    ])(`type: $type, ilpa: $ilpa`, ({ zoneClimatiqueId, periodeInstallationId, expected }) => {
+      expect(tvStore.getEer(zoneClimatiqueId, periodeInstallationId)).toBe(expected);
+    });
+
+    test('pas de valeur de eer', () => {
+      const eer = tvStore.getEer('8', 8);
+      expect(eer).toBeUndefined();
+    });
+  });
 });

package/features/dpe/infrastructure/tv.store.js

@@ -353,4 +353,32 @@ export class TvStore {
 
     return q4paConv;
   }
+
+  /**
+   * Température extérieure de base(°C)
+   *
+   * @param classeAltitude {string}
+   * @param zoneClimatique {string}
+   */
+  getTempBase(classeAltitude, zoneClimatique) {
+    const Tbase = {
+      1: {
+        h1: -9.5,
+        h2: -6.5,
+        h3: -3.5
+      },
+      2: {
+        h1: -11.5,
+        h2: -8.5,
+        h3: -5.5
+      },
+      3: {
+        h1: -13.5,
+        h2: -10.5,
+        h3: -7.5
+      }
+    };
+
+    return Tbase[classeAltitude][zoneClimatique];
+  }
 }

package/features/dpe/infrastructure/tv.store.spec.js

@@ -565,6 +565,18 @@ describe('Lecture des tables de valeurs', () => {
     });
   });
 
+  test('lecture des valeurs de tempBase', () => {
+    expect(tvStore.getTempBase('1', 'h1')).toBe(-9.5);
+    expect(tvStore.getTempBase('1', 'h2')).toBe(-6.5);
+    expect(tvStore.getTempBase('1', 'h3')).toBe(-3.5);
+    expect(tvStore.getTempBase('2', 'h1')).toBe(-11.5);
+    expect(tvStore.getTempBase('2', 'h2')).toBe(-8.5);
+    expect(tvStore.getTempBase('2', 'h3')).toBe(-5.5);
+    expect(tvStore.getTempBase('3', 'h1')).toBe(-13.5);
+    expect(tvStore.getTempBase('3', 'h2')).toBe(-10.5);
+    expect(tvStore.getTempBase('3', 'h3')).toBe(-7.5);
+  });
+
   describe.skip('Benchmark b', () => {
     test('reworked', () => {
       for (let i = 0; i < 1000; i++) {

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

@@ -7,6 +7,7 @@ import { InstallationEcsService } from '../ecs/installation-ecs.service.js';
 import { PerteEcsRecupService } from './ecs/perte-ecs-recup.service.js';
 import { BesoinChService } from './ch/besoin-ch.service.js';
 import { PerteChRecupService } from './ch/perte-ch-recup.service.js';
+import { InstallationChService } from '../ch/installation-ch.service.js';
 
 /**
  * Calcul des déperditions de l’enveloppe GV
@@ -33,6 +34,11 @@ export class ApportEtBesoinService {
    */
   #installationEcsService;
 
+  /**
+   * @type {InstallationChService}
+   */
+  #installationChService;
+
   /**
    * @type {PerteEcsRecupService}
    */
@@ -57,6 +63,7 @@ export class ApportEtBesoinService {
    * @param besoinEcsService {BesoinEcsService}
    * @param besoinChService {BesoinChService}
    * @param installationEcsService {InstallationEcsService}
+   * @param installationChService {InstallationChService}
    * @param perteEcsRecupService {PerteEcsRecupService}
    * @param besoinFroidService {BesoinFroidService}
    * @param surfaceSudEquivalenteService {SurfaceSudEquivalenteService}
@@ -67,6 +74,7 @@ export class ApportEtBesoinService {
     besoinEcsService = inject(BesoinEcsService),
     besoinChService = inject(BesoinChService),
     installationEcsService = inject(InstallationEcsService),
+    installationChService = inject(InstallationChService),
     perteEcsRecupService = inject(PerteEcsRecupService),
     besoinFroidService = inject(BesoinFroidService),
     surfaceSudEquivalenteService = inject(SurfaceSudEquivalenteService),
@@ -76,6 +84,7 @@ export class ApportEtBesoinService {
     this.#besoinEcsService = besoinEcsService;
     this.#besoinChService = besoinChService;
     this.#installationEcsService = installationEcsService;
+    this.#installationChService = installationChService;
     this.#perteEcsRecupService = perteEcsRecupService;
     this.#besoinFroidService = besoinFroidService;
     this.#surfaceSudEquivalenteService = surfaceSudEquivalenteService;
@@ -98,6 +107,11 @@ export class ApportEtBesoinService {
      */
     this.#installationEcsService.execute(ctx, logement, besoinEcs);
 
+    /**
+     * Détermination des données des installations de chauffage
+     */
+    this.#installationChService.execute(ctx, logement);
+
     const apportsInternes = this.#apportGratuitService.apportInterne(ctx, logement);
     const apportsSolaires = this.#apportGratuitService.apportSolaire(ctx, logement);
 

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

@@ -14,6 +14,7 @@ import { getAdemeFileJson } from '../../../../../test/test-helpers.js';
 import { PRECISION_PERCENT } from '../../../../../test/constant.js';
 import { DpeNormalizerService } from '../../../normalizer/domain/dpe-normalizer.service.js';
 import { ContexteBuilder } from '../contexte.builder.js';
+import { InstallationChService } from '../ch/installation-ch.service.js';
 
 /** @type {SurfaceSudEquivalenteService} **/
 let surfaceSudEquivalenteService;
@@ -27,6 +28,9 @@ let besoinFroidService;
 /** @type {InstallationEcsService} **/
 let installationEcsService;
 
+/** @type {InstallationChService} **/
+let installationChService;
+
 /** @type {PerteEcsRecupService} **/
 let perteEcsRecupService;
 
@@ -59,6 +63,7 @@ describe('Calcul des apports et besoin du logement', () => {
     besoinChService = new BesoinChService();
     besoinFroidService = new BesoinFroidService();
     installationEcsService = new InstallationEcsService();
+    installationChService = new InstallationChService();
     perteEcsRecupService = new PerteEcsRecupService();
     apportGratuitService = new ApportGratuitService();
     perteChRecupService = new PerteChRecupService();
@@ -66,6 +71,7 @@ describe('Calcul des apports et besoin du logement', () => {
       besoinEcsService,
       besoinChService,
       installationEcsService,
+      installationChService,
       perteEcsRecupService,
       besoinFroidService,
       surfaceSudEquivalenteService,
@@ -99,6 +105,7 @@ describe('Calcul des apports et besoin du logement', () => {
       apport_interne_fr: 3345.2
     });
     vi.spyOn(installationEcsService, 'execute').mockReturnThis();
+    vi.spyOn(installationChService, 'execute').mockReturnThis();
     vi.spyOn(perteEcsRecupService, 'execute').mockReturnValue({
       pertes_distribution_ecs_recup: 354.2,
       pertes_distribution_ecs_recup_depensier: 532.6,
@@ -141,6 +148,13 @@ describe('Calcul des apports et besoin du logement', () => {
     expect(besoinFroidService.execute).toHaveBeenCalledWith(ctx, logement);
     expect(apportGratuitService.apportSolaire).toHaveBeenCalledWith(ctx, logement);
     expect(apportGratuitService.apportInterne).toHaveBeenCalledWith(ctx, logement);
+    expect(perteEcsRecupService.execute).toHaveBeenCalledWith(ctx, logement);
+    expect(perteChRecupService.execute).toHaveBeenCalledWith(ctx, logement);
+    expect(installationEcsService.execute).toHaveBeenCalledWith(ctx, logement, {
+      besoin_ecs: 1526,
+      besoin_ecs_depensier: 2685.3
+    });
+    expect(installationChService.execute).toHaveBeenCalledWith(ctx, logement);
   });
 
   describe("Test d'intégration pour les besoins en chauffage", () => {

package/features/engine/domain/ch/emetteur-ch.service.js

@@ -0,0 +1,100 @@
+import { ChTvStore } from '../../../dpe/infrastructure/ch/chTv.store.js';
+import { inject } from 'dioma';
+
+/**
+ * Calcul des données des émetteurs de chauffage
+ * Données calculées
+ *   — temperature de distribution
+ *   — période d'installation des émetteurs
+ */
+export class EmetteurChService {
+  /**
+   * @type {ChTvStore}
+   */
+  #chTvStore;
+
+  /**
+   * @param chTvStore {ChTvStore}
+   */
+  constructor(chTvStore = inject(ChTvStore)) {
+    this.#chTvStore = chTvStore;
+  }
+
+  /**
+   * Détermination de l'année d'installation d'un émetteur
+   *
+   * 13.2.1.5 Chaudières basse température et condensation
+   * Si l’année d’installation des émetteurs est inconnue, prendre l’année de construction du bâtiment.
+   *
+   * @param ctx {Contexte}
+   * @param emetteurChauffage {EmetteurChauffage}
+   */
+  periodeInstallationEmetteur(ctx, emetteurChauffage) {
+    const periodeInstallationEmetteur = parseInt(
+      emetteurChauffage.donnee_entree.enum_periode_installation_emetteur_id
+    );
+
+    if (!periodeInstallationEmetteur) {
+      return ctx.anneeConstruction < 1981 ? 1 : ctx.anneeConstruction < 2000 ? 2 : 3;
+    }
+
+    return periodeInstallationEmetteur;
+  }
+
+  /**
+   * Calcul des températures de fonctionnement à 30% ou 100%
+   *
+   * @param ctx {Contexte}
+   * @param generateurChauffageDE {GenerateurChauffageDE}
+   * @param emetteursChauffage {EmetteurChauffage[]}
+   * @return {{temp_fonc_30: number, temp_fonc_100: number}}
+   */
+  temperatureFonctionnement(ctx, generateurChauffageDE, emetteursChauffage) {
+    let temperatureFonctionnement30;
+    let temperatureFonctionnement100;
+
+    emetteursChauffage
+      .filter(
+        (emetteurChauffage) =>
+          parseInt(emetteurChauffage.donnee_entree.enum_temp_distribution_ch_id) !== 1
+      )
+      .forEach((emetteurChauffage) => {
+        // Récupération de la température de distribution
+        const temperatureDistribution = Number(
+          emetteurChauffage.donnee_entree.enum_temp_distribution_ch_id
+        );
+
+        // Récupération de la période d'installation de distribution
+        const periodeInstallationEmetteur = this.periodeInstallationEmetteur(
+          ctx,
+          emetteurChauffage
+        );
+
+        const tempFonctionnement30 = this.#chTvStore.temperatureFonctionnement(
+          '30',
+          generateurChauffageDE.enum_type_generateur_ch_id,
+          temperatureDistribution,
+          periodeInstallationEmetteur
+        );
+
+        const tempFonctionnement100 = this.#chTvStore.temperatureFonctionnement(
+          '100',
+          generateurChauffageDE.enum_type_generateur_ch_id,
+          temperatureDistribution,
+          periodeInstallationEmetteur
+        );
+
+        if (!temperatureFonctionnement30 || tempFonctionnement30 > temperatureFonctionnement30) {
+          temperatureFonctionnement30 = tempFonctionnement30;
+        }
+        if (!temperatureFonctionnement100 || tempFonctionnement100 > temperatureFonctionnement100) {
+          temperatureFonctionnement100 = tempFonctionnement100;
+        }
+      });
+
+    return {
+      temp_fonc_30: temperatureFonctionnement30,
+      temp_fonc_100: temperatureFonctionnement100
+    };
+  }
+}