diff --git a/src/16.2_production_enr.js b/src/16.2_production_enr.js new file mode 100644 index 0000000..2c6841f --- /dev/null +++ b/src/16.2_production_enr.js @@ -0,0 +1,328 @@ +import enums from './enums.js'; +import { mois_liste, tv } from './utils.js'; +import tvs from './tv.js'; + +export class ProductionENR { + #taplpi = { + chauffage: 0.02, + ecs: 0.05, + refroidissement: 0.25, + eclairage: 0.05, + auxiliaire_ventilation: 0.5, + auxiliaire_distribution: 0.05, + autres: 0.45 + }; + + /** + * Calcul des consommations d'électricité auto-consommée par enveloppe + * Mise à jour des conso ef en prenant en compte ces auto-consommations + * @param productionElecEnr + * @param Sh {string} + */ + calculateEnr(productionElecEnr, conso, Sh, th, zc_id) { + const productionElectricite = { + conso_elec_ac: 0, + production_pv: 0, + conso_elec_ac_ch: 0, + conso_elec_ac_auxiliaire_generation_ch: 0, + conso_elec_ac_ecs: 0, + conso_elec_ac_auxiliaire_generation_ecs: 0, + conso_elec_ac_fr: 0, + conso_elec_ac_ventilation: 0, + conso_elec_ac_eclairage: 0, + conso_elec_ac_auxiliaire_distribution_ecs: 0, + conso_elec_ac_auxiliaire_distribution_ch: 0, + conso_elec_ac_auxiliaire: 0, + conso_elec_ac_autre_usage: 0 + }; + + if (productionElecEnr && productionElecEnr.donnee_entree.presence_production_pv === 1) { + // Calcul de l'électricité auto-consommée pour chaque enveloppe + this.calculateConsoElecAc(productionElectricite, productionElecEnr, conso, zc_id, th, Sh); + + // Mise à jour des consommations ef en minorant l'énergie consommée par l'énergie autoconsommée par le poste + this.updateEfConso(productionElectricite, conso, Sh); + } + + return { + production_pv: productionElectricite.production_pv, + conso_elec_ac: productionElectricite.conso_elec_ac, + conso_elec_ac_ch: productionElectricite.conso_elec_ac_ch, + conso_elec_ac_ecs: productionElectricite.conso_elec_ac_ecs, + conso_elec_ac_fr: productionElectricite.conso_elec_ac_fr, + conso_elec_ac_eclairage: productionElectricite.conso_elec_ac_eclairage, + conso_elec_ac_auxiliaire: productionElectricite.conso_elec_ac_auxiliaire, + conso_elec_ac_autre_usage: productionElectricite.conso_elec_ac_autre_usage + }; + } + + /** + * Calcul de l'électricité auto-consommée pour chaque enveloppe + * @param productionElectricite production ENR totale du logement + * @param productionElecEnr installation ENR + * @param conso + * @param zc_id + * @param th + * @param Sh + */ + calculateConsoElecAc(productionElectricite, productionElecEnr, conso, zc_id, th, Sh) { + // Production d’électricité par des capteurs photovoltaïques Ppv (en kWh/m²) + const Ppv = this.getPpv(productionElecEnr, zc_id); + + // Consommation annuelle d’électricité pour les autres usages (kWhef/an) + const CelecTotAu = this.getCelecAu(th, Sh); + + /** + * Récupération des consommations électriques pour ch et ecs + * @type {SortieParEnergieItem} + */ + let consoElec = conso.sortie_par_energie_collection.sortie_par_energie.find( + (sortie) => sortie.enum_type_energie_id === '1' + ); + + /** + * Consommation totale annuelle d’électricité pour les 5 usages réglementaires et les usages mobiliers (kWhef/an) + */ + const Celec_tot = consoElec.conso_5_usages + CelecTotAu; + + // Autoconsommation proratisée à chaque usage + const production = this.getTapl(conso.ef_conso, consoElec, CelecTotAu, Celec_tot); + + /** + * Coefficient de calage représentant le taux d’auto-production maximum pouvant être atteint lorsque + * la production d’électricité renouvelable augmente + */ + const Tapl = Object.values(production).reduce((acc, valeur) => acc + valeur, 0); + + /** + * Taux de couverture, correspondant au ratio entre la production totale du site et la consommation + * annuelle tous usages (%) + */ + const Tcv = Ppv / Celec_tot; + + /** + * Taux d’autoproduction, correspondant au rapport entre la production d’électricité autoconsommée et la + * consommation d’énergie (tous usages) du bâtiment (%) + */ + const Tap = 1 / (1 / Tcv + 1 / Tapl); + + // Electricité photovoltaïque autoconsommée (kWhef/an) + const consoElecAc = Celec_tot * Tap; + + // Mise à jour des données intermédiaires pour l'installation ENR + productionElecEnr.donnee_intermediaire = productionElecEnr.donnee_intermediaire + ? productionElecEnr.donnee_intermediaire + : {}; + productionElecEnr.donnee_intermediaire.conso_elec_ac = consoElecAc; + productionElecEnr.donnee_intermediaire.taux_autoproduction = Tap; + productionElecEnr.donnee_intermediaire.production_pv = Ppv; + + productionElectricite.conso_elec_ac = consoElecAc; + productionElectricite.production_pv = Ppv; + + productionElectricite.conso_elec_ac_ch = (consoElecAc * production.conso_elec_ac_ch) / Tapl; + productionElectricite.conso_elec_ac_auxiliaire_generation_ch = + (consoElecAc * production.conso_elec_ac_auxiliaire_generation_ch) / Tapl; + productionElectricite.conso_elec_ac_ecs = (consoElecAc * production.conso_elec_ac_ecs) / Tapl; + productionElectricite.conso_elec_ac_auxiliaire_generation_ecs = + (consoElecAc * production.conso_elec_ac_auxiliaire_generation_ecs) / Tapl; + productionElectricite.conso_elec_ac_fr = (consoElecAc * production.conso_elec_ac_fr) / Tapl; + productionElectricite.conso_elec_ac_eclairage = + (consoElecAc * production.conso_elec_ac_eclairage) / Tapl; + productionElectricite.conso_elec_ac_ventilation = + (consoElecAc * production.conso_elec_ac_ventilation) / Tapl; + productionElectricite.conso_elec_ac_auxiliaire_distribution_ecs = + (consoElecAc * production.conso_elec_ac_auxiliaire_distribution_ecs) / Tapl; + productionElectricite.conso_elec_ac_auxiliaire_distribution_ch = + (consoElecAc * production.conso_elec_ac_auxiliaire_distribution_ch) / Tapl; + productionElectricite.conso_elec_ac_autre_usage = + CelecTotAu * production.conso_elec_ac_autre_usage; + + // Energies autoconsommée par les auxiliaires + const consoAcAuxiliaires = + productionElectricite.conso_elec_ac_auxiliaire_generation_ch + + productionElectricite.conso_elec_ac_auxiliaire_generation_ecs + + productionElectricite.conso_elec_ac_auxiliaire_distribution_ecs + + productionElectricite.conso_elec_ac_auxiliaire_distribution_ch + + productionElectricite.conso_elec_ac_ventilation; + + productionElectricite.conso_elec_ac_auxiliaire = consoAcAuxiliaires; + } + + /** + * Mise à jour des consommations ef en minorant l'énergie consommée par l'énergie autoconsommée par chaque enveloppe + * @param productionElectricite + * @param conso + * @param Sh + */ + updateEfConso(productionElectricite, conso, Sh) { + conso.ef_conso.conso_ecs -= productionElectricite.conso_elec_ac_ecs; + conso.ef_conso.conso_ch -= productionElectricite.conso_elec_ac_ch; + conso.ef_conso.conso_fr -= productionElectricite.conso_elec_ac_fr; + conso.ef_conso.conso_eclairage -= productionElectricite.conso_elec_ac_eclairage; + conso.ef_conso.conso_totale_auxiliaire -= productionElectricite.conso_elec_ac_auxiliaire; + + conso.ef_conso.conso_5_usages -= + productionElectricite.conso_elec_ac_ecs + + productionElectricite.conso_elec_ac_ch + + productionElectricite.conso_elec_ac_fr + + productionElectricite.conso_elec_ac_eclairage + + productionElectricite.conso_elec_ac_auxiliaire; + + conso.ef_conso.conso_5_usages_m2 = Math.floor(conso.ef_conso.conso_5_usages / Sh); + } + + /** + * Calcul des taux d'autoproduction consommés pour chaque enveloppe + * @param efConso {Ef_conso} + * @param consoElec + * @param ccom {number} + * @param consoElecTotale {number} + */ + getTapl(efConso, consoElec, ccom, consoElecTotale) { + const productionElectricite = { + conso_elec_ac_ch: 0, + conso_elec_ac_auxiliaire_generation_ch: 0, + conso_elec_ac_ecs: 0, + conso_elec_ac_auxiliaire_generation_ecs: 0, + conso_elec_ac_fr: 0, + conso_elec_ac_ventilation: 0, + conso_elec_ac_eclairage: 0, + conso_elec_ac_auxiliaire_distribution_ecs: 0, + conso_elec_ac_auxiliaire_distribution_ch: 0, + conso_elec_ac_autre_usage: 0 + }; + + // Consommation de chauffage récupérée directement depuis les consommations par énergie "électricité" + const chauffage = consoElec?.conso_ch; + if (chauffage) { + productionElectricite.conso_elec_ac_ch = + (this.#taplpi.chauffage * chauffage) / consoElecTotale; + } + + const auxiliaireGenerationCh = efConso.conso_auxiliaire_generation_ch; + if (auxiliaireGenerationCh) { + productionElectricite.conso_elec_ac_auxiliaire_generation_ch = + (this.#taplpi.chauffage * auxiliaireGenerationCh) / consoElecTotale; + } + + // Consommation ECS récupérée directement depuis les consommations par énergie "électricité" + const ecs = consoElec?.conso_ecs; + if (ecs) { + productionElectricite.conso_elec_ac_ecs = (this.#taplpi.ecs * ecs) / consoElecTotale; + } + + const auxiliaireGenerationEcs = efConso.conso_auxiliaire_generation_ecs; + if (auxiliaireGenerationEcs) { + productionElectricite.conso_elec_ac_auxiliaire_generation_ecs = + (this.#taplpi.ecs * auxiliaireGenerationEcs) / consoElecTotale; + } + + const refroidissement = efConso.conso_fr; + if (refroidissement) { + productionElectricite.conso_elec_ac_fr = + (this.#taplpi.refroidissement * refroidissement) / consoElecTotale; + } + + const eclairage = efConso.conso_eclairage; + if (eclairage) { + productionElectricite.conso_elec_ac_eclairage = + (this.#taplpi.eclairage * eclairage) / consoElecTotale; + } + + const auxiliaireVentilation = efConso.conso_auxiliaire_ventilation; + if (auxiliaireVentilation) { + productionElectricite.conso_elec_ac_ventilation = + (this.#taplpi.auxiliaire_ventilation * auxiliaireVentilation) / consoElecTotale; + } + + const auxiliaireDistributionEcs = efConso.conso_auxiliaire_distribution_ecs; + if (auxiliaireDistributionEcs) { + productionElectricite.conso_elec_ac_auxiliaire_distribution_ecs = + (this.#taplpi.auxiliaire_distribution * auxiliaireDistributionEcs) / consoElecTotale; + } + + const auxiliaireDistributionCh = efConso.conso_auxiliaire_distribution_ch; + if (auxiliaireDistributionCh) { + productionElectricite.conso_elec_ac_auxiliaire_distribution_ch = + (this.#taplpi.auxiliaire_distribution * auxiliaireDistributionCh) / consoElecTotale; + } + + productionElectricite.conso_elec_ac_autre_usage = + (this.#taplpi.autres * ccom) / consoElecTotale; + + return productionElectricite; + } + + /** + * Consommation annuelle d’électricité pour "autres usages" (kWhef/an) + * @param th + * @param Sh + * @returns {number} + */ + getCelecAu(th, Sh) { + /** + * Cum : consommation annuelle d’électricité des usages mobiliers + * Maison individuelle 29 + * Immeuble collectif 27 + */ + const Cum = th === 'maison' ? 29 : 27; + + // Consommation annuelle d’éclairage des parties communes en logement collectif + const CcomEcl = th === 'maison' ? 0 : 1.1; + + return (CcomEcl + Cum) * Sh; + } + + /** + * Production d’électricité par l'ensemble des capteurs photovoltaïques Ppv (en kWh/m²) + * + * @param productionElecEnr + * @param zc_id + * @returns {number} + */ + getPpv(productionElecEnr, zc_id) { + const ePvValues = tvs.e_pv; + const zc = enums.zone_climatique[zc_id]; + + let panneaux_pv_collection = productionElecEnr.panneaux_pv_collection?.panneaux_pv || []; + + if (!Array.isArray(panneaux_pv_collection)) { + panneaux_pv_collection = [panneaux_pv_collection]; + } + + return panneaux_pv_collection.reduce((acc, panneaux_pv) => { + const row = tv('coef_orientation_pv', { + enum_orientation_pv_id: panneaux_pv.enum_orientation_pv_id, + enum_inclinaison_pv_id: panneaux_pv.enum_inclinaison_pv_id + }); + + if (!row) { + return acc; + } + + /** + * Coefficient de pondération prenant en compte l’altération par rapport à l’orientation optimale (30° auSud) + * des panneaux photovoltaïques + */ + const k = row.coef_orientation_pv; + + // Surface des panneaux photovoltaïques orientés et inclinés de la même manière (m²) + const Scapteur = 1.6 * panneaux_pv.nombre_module || panneaux_pv.surface_totale_capteurs; + + // Rendement moyen des modules + const r = 0.17; + + // Coefficient de perte + const C = 0.86; + + for (const mois of mois_liste) { + // Ensoleillement en kWh/m² pour le mois + const Epv = ePvValues[mois][zc]; + acc += k * Scapteur * r * Epv * C; + } + + return acc; + }, 0); + } +} diff --git a/src/16.2_production_enr.spec.js b/src/16.2_production_enr.spec.js new file mode 100644 index 0000000..a6aa350 --- /dev/null +++ b/src/16.2_production_enr.spec.js @@ -0,0 +1,251 @@ +import { ProductionENR } from './16.2_production_enr.js'; + +describe('production ENR unit tests', () => { + /** + * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf Page 103 + */ + const productionENR = new ProductionENR(); + + test('should get conso elect au', () => { + // surface * 29 pour une maison + expect(productionENR.getCelecAu('maison', 10)).toBe(290); + + // surface * (27 + 1.1) pour un appartement + expect(productionENR.getCelecAu('appartement', 10)).toBe(281); + }); + + test('should get ppv 0 without ENR', () => { + let productionElecEnr = {}; + expect(productionENR.getPpv(productionElecEnr, 1)).toBe(0); + + productionElecEnr.panneaux_pv_collection = {}; + expect(productionENR.getPpv(productionElecEnr, 1)).toBe(0); + + productionElecEnr.panneaux_pv_collection = { + panneaux_pv: [] + }; + expect(productionENR.getPpv(productionElecEnr, 1)).toBe(0); + }); + + test('should get ppv 0 with unknown coef_orientation_pv', () => { + let productionElecEnr = { + panneaux_pv_collection: { + panneaux_pv: [ + { + enum_orientation_pv_id: 12, + enum_inclinaison_pv_id: 12 + }, + { + enum_orientation_pv_id: 15, + enum_inclinaison_pv_id: 12 + } + ] + } + }; + expect(productionENR.getPpv(productionElecEnr, 1)).toBe(0); + }); + + it.each([ + [2826.8015616000007, 8, 9.6], + [2120.1011712, undefined, 9.6] + ])( + 'should get ppv %s with nombre module %s and surface totale capteur %s', + (ppv, nombre_module, surface_totale_capteurs) => { + let productionElecEnr = { + panneaux_pv_collection: { + panneaux_pv: [ + { + surface_totale_capteurs: surface_totale_capteurs, + nombre_module: nombre_module, + enum_orientation_pv_id: 1, + enum_inclinaison_pv_id: 2 + } + ] + } + }; + expect(productionENR.getPpv(productionElecEnr, 1)).toBe(ppv); + } + ); + + test('should update ef conso', () => { + const productionElectricite = { + conso_elec_ac_fr: 100, + conso_elec_ac_ch: 150, + conso_elec_ac_ecs: 200, + conso_elec_ac_eclairage: 250, + conso_elec_ac_auxiliaire: 300 + }; + + const conso = { + ef_conso: { + conso_ecs: 1000, + conso_ch: 500, + conso_fr: 800, + conso_eclairage: 900, + conso_totale_auxiliaire: 1250, + conso_5_usages: 1500, + conso_5_usages_m2: 100 + } + }; + + productionENR.updateEfConso(productionElectricite, conso, 10); + + expect(conso).toStrictEqual({ + ef_conso: { + conso_ecs: 800, + conso_ch: 350, + conso_fr: 700, + conso_eclairage: 650, + conso_totale_auxiliaire: 950, + conso_5_usages: 500, + conso_5_usages_m2: 50 + } + }); + }); + + test('should get tapl', () => { + let productionElectricite = productionENR.getTapl({}, {}, 158, 2500); + + expect(productionElectricite).toStrictEqual({ + conso_elec_ac_ch: 0, + conso_elec_ac_eclairage: 0, + conso_elec_ac_ecs: 0, + conso_elec_ac_fr: 0, + conso_elec_ac_auxiliaire_distribution_ch: 0, + conso_elec_ac_auxiliaire_distribution_ecs: 0, + conso_elec_ac_auxiliaire_generation_ch: 0, + conso_elec_ac_auxiliaire_generation_ecs: 0, + conso_elec_ac_ventilation: 0, + conso_elec_ac_autre_usage: 0.028440000000000003 + }); + + const consoElec = { + conso_ch: 1000, + conso_ecs: 1500 + }; + + const efConso = { + conso_ecs: 1000, + conso_ch: 500, + conso_fr: 800, + conso_eclairage: 900, + conso_auxiliaire_distribution_ch: 250, + conso_auxiliaire_distribution_ecs: 110, + conso_auxiliaire_generation_ch: 100, + conso_auxiliaire_generation_ecs: 120, + conso_auxiliaire_ventilation: 150, + conso_totale_auxiliaire: 1250, + conso_5_usages: 1500, + conso_5_usages_m2: 100 + }; + + productionElectricite = productionENR.getTapl(efConso, consoElec, 158, 2500); + + expect(productionElectricite).toStrictEqual({ + conso_elec_ac_ch: 0.008, + conso_elec_ac_eclairage: 0.018, + conso_elec_ac_ecs: 0.03, + conso_elec_ac_fr: 0.08, + conso_elec_ac_auxiliaire_distribution_ch: 0.005, + conso_elec_ac_auxiliaire_distribution_ecs: 0.0022, + conso_elec_ac_auxiliaire_generation_ch: 0.0008, + conso_elec_ac_auxiliaire_generation_ecs: 0.0024, + conso_elec_ac_ventilation: 0.03, + conso_elec_ac_autre_usage: 0.028440000000000003 + }); + }); + + test('should calculate conso elec', () => { + let productionElecEnr = { + panneaux_pv_collection: { + panneaux_pv: [ + { + nombre_module: 8, + enum_orientation_pv_id: 1, + enum_inclinaison_pv_id: 2 + } + ] + } + }; + + let productionElectricite = { + conso_elec_ac: 0, + production_pv: 0, + conso_elec_ac_ch: 0, + conso_elec_ac_auxiliaire_generation_ch: 0, + conso_elec_ac_ecs: 0, + conso_elec_ac_auxiliaire_generation_ecs: 0, + conso_elec_ac_fr: 0, + conso_elec_ac_ventilation: 0, + conso_elec_ac_eclairage: 0, + conso_elec_ac_auxiliaire_distribution_ecs: 0, + conso_elec_ac_auxiliaire_distribution_ch: 0, + conso_elec_ac_auxiliaire: 0, + conso_elec_ac_autre_usage: 0 + }; + + const conso = { + ef_conso: { + conso_ecs: 1000, + conso_ch: 500, + conso_fr: 800, + conso_eclairage: 900, + conso_totale_auxiliaire: 1250, + conso_5_usages: 1500, + conso_5_usages_m2: 100 + }, + sortie_par_energie_collection: { + sortie_par_energie: [ + { + enum_type_energie_id: '1', + conso_5_usages: 1500, + conso_ch: 1000, + conso_ecs: 1500 + } + ] + } + }; + + productionENR.calculateConsoElecAc( + productionElectricite, + productionElecEnr, + conso, + 1, + 'maison', + 100 + ); + + expect(productionElectricite).toStrictEqual({ + conso_elec_ac: 1039.8691678904038, + production_pv: 2826.8015616000007, + conso_elec_ac_ch: 12.64278623574959, + conso_elec_ac_auxiliaire_generation_ch: 0, + conso_elec_ac_ecs: 47.41044838406096, + conso_elec_ac_auxiliaire_generation_ecs: 0, + conso_elec_ac_fr: 126.42786235749591, + conso_elec_ac_ventilation: 0, + conso_elec_ac_eclairage: 28.44626903043658, + conso_elec_ac_auxiliaire_distribution_ecs: 0, + conso_elec_ac_auxiliaire_distribution_ch: 0, + conso_elec_ac_auxiliaire: 0, + conso_elec_ac_autre_usage: 860.1136363636363 + }); + + expect(productionElecEnr).toStrictEqual({ + donnee_intermediaire: { + conso_elec_ac: 1039.8691678904038, + production_pv: 2826.8015616000007, + taux_autoproduction: 0.2363339017932736 + }, + panneaux_pv_collection: { + panneaux_pv: [ + { + enum_inclinaison_pv_id: 2, + enum_orientation_pv_id: 1, + nombre_module: 8 + } + ] + } + }); + }); +}); diff --git a/src/core/assets/domain/synchronize-solicitations-tables.js b/src/core/assets/domain/synchronize-solicitations-tables.js index b6ce4e8..5ef0f26 100644 --- a/src/core/assets/domain/synchronize-solicitations-tables.js +++ b/src/core/assets/domain/synchronize-solicitations-tables.js @@ -51,12 +51,14 @@ export class SynchronizeSolicitationsTables { excelSheets[sheetName].forEach((sheetValue) => { // Group by "ilpa" property if it exists or "classe_altitude" otherwise let groupKey = sheetValue.hasOwnProperty(ILPA_PROPERTY) - ? sheetValue.ilpa - : sheetValue.classe_altitude; + ? '.' + sheetValue.ilpa + : sheetValue.hasOwnProperty(CLASSE_ALTITUDE_PROPERTY) + ? '.' + sheetValue.classe_altitude + : ''; for (const sheetValueKey in sheetValue) { if (!EXCLUDED_PROPERTIES.includes(sheetValueKey)) { - const path = `${sheetName}.${groupKey}${sheetValue.hasOwnProperty(ILPA_PROPERTY) ? '.' + sheetValue.classe_altitude : ''}.${sheetValue.mois}.${sheetValueKey}`; + const path = `${sheetName}${groupKey}${sheetValue.hasOwnProperty(ILPA_PROPERTY) ? '.' + sheetValue.classe_altitude : ''}.${sheetValue.mois}.${sheetValueKey}`; set(output, path, parseFloat(sheetValue[sheetValueKey])); } } diff --git a/src/engine.js b/src/engine.js index ddc160b..c3f25e0 100644 --- a/src/engine.js +++ b/src/engine.js @@ -18,6 +18,7 @@ import { } from './utils.js'; import { Inertie } from './7_inertie.js'; import getFicheTechnique from './ficheTechnique.js'; +import { ProductionENR } from './16.2_production_enr.js'; function calc_th(map_id) { const map = enums.methode_application_dpe_log[map_id]; @@ -29,6 +30,7 @@ function calc_th(map_id) { } const inertie = new Inertie(); +const productionENR = new ProductionENR(); export function calcul_3cl(dpe) { sanitize_dpe(dpe); @@ -478,16 +480,13 @@ export function calcul_3cl(dpe) { prorataChauffage ); - const production_electricite = { - conso_elec_ac: 0, - conso_elec_ac_autre_usage: 0, - conso_elec_ac_auxiliaire: 0, - conso_elec_ac_ch: 0, - conso_elec_ac_eclairage: 0, - conso_elec_ac_ecs: 0, - conso_elec_ac_fr: 0, - production_pv: 0 - }; + const production_electricite = productionENR.calculateEnr( + dpe.logement.production_elec_enr, + conso, + Sh, + th, + zc_id + ); // get all baie_vitree orientations const ph_list = env.plancher_haut_collection.plancher_haut || []; diff --git a/src/tv.js b/src/tv.js index d4dfabf..3ca0acf 100644 --- a/src/tv.js +++ b/src/tv.js @@ -69951,6 +69951,128 @@ export const tvs = { } } }, + e_pv: { + Janvier: { + h1a: 50.1, + h1b: 41.5, + h1c: 61.5, + h2a: 52.6, + h2b: 44.6, + h2c: 55.5, + h2d: 123.7, + h3: 116.1 + }, + Février: { + h1a: 54.7, + h1b: 66.8, + h1c: 81.3, + h2a: 86.2, + h2b: 84.3, + h2c: 91.4, + h2d: 141.8, + h3: 129.4 + }, + Mars: { + h1a: 123.4, + h1b: 99, + h1c: 149.7, + h2a: 150.4, + h2b: 121.1, + h2c: 177.4, + h2d: 191.7, + h3: 181.5 + }, + Avril: { + h1a: 169.3, + h1b: 152.7, + h1c: 178.3, + h2a: 159.3, + h2b: 180.9, + h2c: 172, + h2d: 205.3, + h3: 244.1 + }, + Mai: { + h1a: 208.2, + h1b: 182.7, + h1c: 185, + h2a: 184.3, + h2b: 194.2, + h2c: 229.3, + h2d: 238.6, + h3: 260.7 + }, + Juin: { + h1a: 217.8, + h1b: 215.6, + h1c: 228.2, + h2a: 214.3, + h2b: 210.5, + h2c: 226.3, + h2d: 291.8, + h3: 296.5 + }, + Juillet: { + h1a: 221.9, + h1b: 227.4, + h1c: 236.7, + h2a: 210.3, + h2b: 227.4, + h2c: 251.2, + h2d: 313.6, + h3: 314.5 + }, + Aout: { + h1a: 173.3, + h1b: 188.8, + h1c: 211.5, + h2a: 186.8, + h2b: 213.7, + h2c: 231.4, + h2d: 284.5, + h3: 281 + }, + Septembre: { + h1a: 163.6, + h1b: 148.7, + h1c: 166.7, + h2a: 165.7, + h2b: 159.3, + h2c: 183, + h2d: 218.4, + h3: 225.8 + }, + Octobre: { + h1a: 88.9, + h1b: 101.5, + h1c: 100.3, + h2a: 92.3, + h2b: 126.5, + h2c: 107.8, + h2d: 138, + h3: 151.2 + }, + Novembre: { + h1a: 59.1, + h1b: 46.5, + h1c: 62.7, + h2a: 83.3, + h2b: 56.9, + h2c: 84.5, + h2d: 113.8, + h3: 113.2 + }, + Décembre: { + h1a: 43.2, + h1b: 47.9, + h1c: 43.5, + h2a: 52.1, + h2b: 37, + h2c: 51.3, + h2d: 105.3, + h3: 94.8 + } + }, e_fr_26: { 'inférieur à 400m': { Janvier: { diff --git a/src/tv/18.2_sollicitations_ext.ods b/src/tv/18.2_sollicitations_ext.ods index fc4ea0c..26ed9fe 100644 Binary files a/src/tv/18.2_sollicitations_ext.ods and b/src/tv/18.2_sollicitations_ext.ods differ