@open3cl/engine 1.0.0

package/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
+          }
+        ]
+      }
+    });
+  });
+});

package/16_conso_eclairage.js

@@ -0,0 +1,37 @@
+import enums from './enums.js';
+
+/**
+ * Nombre moyen d'heures d'éclairage annuel pour chacune des zones
+ * @type {{h1a: number, h1b: number, h1c: number, h2a: number, h2b: number, h2c: number, h2d: number, h3: number}}
+ */
+const Nh = {
+  h1a: 1500,
+  h1b: 1445,
+  h1c: 1476,
+  h2a: 1500,
+  h2b: 1531,
+  h2c: 1566,
+  h2d: 1566,
+  h3: 1506
+};
+
+/**
+ * 16.1 Consommation d’éclairage (Cecl)
+ * @param zc_id
+ * @returns {number}
+ */
+export default function calc_conso_eclairage(zc_id) {
+  const zc = enums.zone_climatique[zc_id];
+
+  // Coefficient correspondant au taux d'utilisation de l'éclairage en l'absence d'éclairage naturel. Il prend la
+  // valeur de 0,9 pour une commande de l’éclairage par interrupteur (considéré dans les logements).
+  const C = 0.9;
+
+  // Puissance d’éclairage conventionnelle, égale à 1,4 W/m2
+  const Pecl = 1.4;
+
+  // Nombre d’heures de fonctionnement de l’éclairage sur l'année
+  const nh = Nh[zc];
+
+  return (C * Pecl * nh) / 1000;
+}

package/2021_04_13_confort_ete.js

@@ -0,0 +1,61 @@
+import enums from './enums.js';
+import { getKeyByValue, requestInput } from './utils.js';
+
+export default function calc_confort_ete(inertie_id, bv, ph) {
+  const classe_inertie = enums.classe_inertie[inertie_id];
+
+  const orientations = bv.reduce((acc, bv) => {
+    const orientation = bv.donnee_entree.enum_orientation_id;
+    if (!acc.includes(orientation)) acc.push(orientation);
+    return acc;
+  }, []);
+  const aspect_traversant = orientations.length > 1 ? 1 : 0;
+
+  const isolation_toiture = ph.reduce((acc, ph) => {
+    const de = ph.donnee_entree;
+    const du = ph.donnee_utilisateur;
+    const type_adjacence = requestInput(de, du, 'type_adjacence');
+    if (type_adjacence === 'extérieur') {
+      const type_isolation = requestInput(de, du, 'type_isolation');
+      if (type_isolation === 'inconnu' || type_isolation === 'non isolé') return 0;
+    }
+    return acc;
+  }, 1);
+
+  let inertie_lourde = 0;
+  if (classe_inertie === 'lourde') inertie_lourde = 1;
+  if (classe_inertie === 'très lourde') inertie_lourde = 1;
+
+  // TODO use `presence_protection_solaire_exterieure` ??
+  const protection_solaire_exterieure = bv.reduce((acc, bv) => {
+    const de = bv.donnee_entree;
+    const du = bv.donnee_utilisateur;
+    const orientation = requestInput(de, du, 'orientation');
+    if (orientation === 'nord') return acc;
+    const type_fermerture = requestInput(de, du, 'type_fermeture');
+    if (type_fermerture === 'abscence de fermeture pour la baie vitrée') return 0;
+    return acc;
+  }, 1);
+
+  const confort_ete = {
+    inertie_lourde,
+    aspect_traversant,
+    isolation_toiture,
+    protection_solaire_exterieure,
+    brasseur_air: 0
+  };
+
+  const nv_bon =
+    confort_ete.inertie_lourde + confort_ete.aspect_traversant + confort_ete.brasseur_air;
+  let nv_confort_ete;
+  if (confort_ete.protection_solaire_exterieure === 0 || confort_ete.isolation_toiture === 0) {
+    nv_confort_ete = 'insuffisant';
+  } else if (nv_bon >= 2) nv_confort_ete = 'bon';
+  else nv_confort_ete = 'moyen';
+
+  confort_ete.enum_indicateur_confort_ete_id = getKeyByValue(
+    enums.indicateur_confort_ete,
+    nv_confort_ete
+  );
+  return confort_ete;
+}

package/2021_04_13_qualite_isolation.js

@@ -0,0 +1,174 @@
+/**
+ * @returns {number}
+ */
+function qualite_isol(dep, surface, seuil1, seuil2, seuil3) {
+  /**
+   * 1 - Très bonne
+   * 2 - Bonne
+   * 3 - Moyenne
+   * 4 - Insuffisante
+   */
+  let u = 0;
+
+  if (dep && surface) {
+    u = dep / surface;
+  }
+
+  if (u < seuil1) return 1;
+  else if (u < seuil2) return 2;
+  else if (u < seuil3) return 3;
+  return 4;
+}
+
+export default function calc_qualite_isolation(enveloppe, dp) {
+  /**
+   * enum_type_adjacence_id = 22 - Local non déperditif (local à usage d'habitation chauffé)
+   */
+  const mur_list = (enveloppe.mur_collection.mur || []).filter(
+    (mur) => mur.donnee_entree.enum_type_adjacence_id !== '22' && mur.donnee_intermediaire.b > 0
+  );
+
+  const planchersHauts = enveloppe.plancher_haut_collection.plancher_haut || [];
+  const planchersBas = (enveloppe.plancher_bas_collection.plancher_bas || []).filter(
+    (mur) => mur.donnee_entree.enum_type_adjacence_id !== '22'
+  );
+  const baiesVitrees = (enveloppe.baie_vitree_collection.baie_vitree || []).filter(
+    (porte) => porte.donnee_intermediaire.b > 0
+  );
+  const portes = (enveloppe.porte_collection.porte || []).filter(
+    (porte) => porte.donnee_intermediaire.b > 0
+  );
+
+  let phCombleAmenagee = [];
+  let phCombleToitTerrasse = [];
+  let phComblePerdue = [];
+
+  planchersHauts.forEach((plancherHaut) => {
+    if (plancherHaut.donnee_entree.enum_type_adjacence_id !== '1') {
+      phComblePerdue.push(plancherHaut);
+    } else {
+      if (
+        plancherHaut.donnee_entree.enum_type_plancher_haut_id === '12' ||
+        plancherHaut.donnee_entree.description?.toLowerCase().indexOf('combles aménagés') !== -1
+      ) {
+        phCombleAmenagee.push(plancherHaut);
+      } else {
+        phCombleToitTerrasse.push(plancherHaut);
+      }
+    }
+  });
+
+  const Umurs = mur_list.reduce(
+    (acc, mur) => acc + mur.donnee_entree.surface_paroi_opaque * mur.donnee_intermediaire.umur,
+    0
+  );
+  const surfaceMurs = mur_list.reduce(
+    (acc, mur) => acc + mur.donnee_entree.surface_paroi_opaque,
+    0
+  );
+
+  const UplancherBas = planchersBas.reduce(
+    (acc, pb) => acc + pb.donnee_entree.surface_paroi_opaque * pb.donnee_intermediaire.upb,
+    0
+  );
+  const surfacePlanchersBas = planchersBas.reduce(
+    (acc, pb) => acc + pb.donnee_entree.surface_paroi_opaque,
+    0
+  );
+
+  const UphComblesAmenagees = phCombleAmenagee.reduce(
+    (acc, ph) => acc + ph.donnee_entree.surface_paroi_opaque * ph.donnee_intermediaire.uph,
+    0
+  );
+  const UphComblesPerdues = phComblePerdue.reduce(
+    (acc, ph) => acc + ph.donnee_entree.surface_paroi_opaque * ph.donnee_intermediaire.uph,
+    0
+  );
+  const UphToitsTerrasses = phCombleToitTerrasse.reduce(
+    (acc, ph) => acc + ph.donnee_entree.surface_paroi_opaque * ph.donnee_intermediaire.uph,
+    0
+  );
+
+  const surfaceComblesAmenagees = phCombleAmenagee
+    .filter((mur) => mur.donnee_entree.enum_type_adjacence_id !== '22')
+    .reduce((acc, ph) => acc + ph.donnee_entree.surface_paroi_opaque, 0);
+  const surfaceComblesPerdues = phComblePerdue
+    .filter((mur) => mur.donnee_entree.enum_type_adjacence_id !== '22')
+    .reduce((acc, ph) => acc + ph.donnee_entree.surface_paroi_opaque, 0);
+  const surfaceToitsTerrasses = phCombleToitTerrasse
+    .filter((mur) => mur.donnee_entree.enum_type_adjacence_id !== '22')
+    .reduce((acc, ph) => acc + ph.donnee_entree.surface_paroi_opaque, 0);
+
+  const Umenuiseries =
+    baiesVitrees.reduce(
+      (acc, bv) =>
+        acc + bv.donnee_entree.surface_totale_baie * bv.donnee_intermediaire.u_menuiserie,
+      0
+    ) +
+    portes.reduce(
+      (acc, porte) => acc + porte.donnee_entree.surface_porte * porte.donnee_intermediaire.uporte,
+      0
+    );
+  const surfacePortes = portes.reduce((acc, porte) => acc + porte.donnee_entree.surface_porte, 0);
+  const surfaceBaiesVitrees = baiesVitrees.reduce(
+    (acc, bv) => acc + bv.donnee_entree.surface_totale_baie,
+    0
+  );
+
+  const deperdition =
+    dp.deperdition_mur +
+    dp.deperdition_plancher_bas +
+    dp.deperdition_plancher_haut +
+    dp.deperdition_baie_vitree +
+    dp.deperdition_porte +
+    dp.deperdition_pont_thermique;
+  const surfacePlanchersHauts =
+    surfaceComblesAmenagees + surfaceComblesPerdues + surfaceToitsTerrasses;
+  const surfaceDeperditives =
+    surfaceMurs + surfacePlanchersBas + surfacePlanchersHauts + surfaceBaiesVitrees + surfacePortes;
+  const ubat = deperdition / surfaceDeperditives;
+
+  const ret = {
+    ubat,
+    qualite_isol_enveloppe: qualite_isol(deperdition, surfaceDeperditives, 0.45, 0.65, 0.85),
+    qualite_isol_mur: qualite_isol(Umurs, surfaceMurs, 0.3, 0.45, 0.65),
+    qualite_isol_plancher_bas: qualite_isol(UplancherBas, surfacePlanchersBas, 0.25, 0.45, 0.65),
+    qualite_isol_menuiserie: qualite_isol(
+      Umenuiseries,
+      surfaceBaiesVitrees + surfacePortes,
+      1.6,
+      2.2,
+      3
+    )
+  };
+
+  if (UphComblesAmenagees > 0) {
+    ret.qualite_isol_plancher_haut_comble_amenage = qualite_isol(
+      UphComblesAmenagees,
+      surfaceComblesAmenagees,
+      0.18,
+      0.25,
+      0.3
+    );
+  }
+  if (UphToitsTerrasses > 0) {
+    ret.qualite_isol_plancher_haut_toit_terrasse = qualite_isol(
+      UphToitsTerrasses,
+      surfaceToitsTerrasses,
+      0.25,
+      0.3,
+      0.35
+    );
+  }
+  if (UphComblesPerdues > 0) {
+    ret.qualite_isol_plancher_haut_comble_perdu = qualite_isol(
+      UphComblesPerdues,
+      surfaceComblesPerdues,
+      0.15,
+      0.2,
+      0.3
+    );
+  }
+
+  return ret;
+}

package/3.1_b.js

@@ -0,0 +1,141 @@
+import enums from './enums.js';
+import { tv, requestInput, requestInputID, bug_for_bug_compat } from './utils.js';
+
+function findRanges(inputNumber) {
+  const ranges = [0.25, 0.5, 0.75, 1, 1.25, 2, 2.5, 3, 3.5, 4, 6, 8, 10, 25, 50];
+  const result = [];
+
+  if (inputNumber < ranges[0]) {
+    result.push(null);
+    result.push(ranges[0]);
+  } else if (inputNumber > ranges[ranges.length - 1]) {
+    result.push(ranges[ranges.length - 1]);
+    result.push(null);
+  } else {
+    for (let i = 0; i < ranges.length; i++) {
+      if (inputNumber <= ranges[i]) {
+        if (i > 0) {
+          result.push(ranges[i - 1]);
+        }
+        result.push(ranges[i]);
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+export default function b(di, de, du, zc_id) {
+  const zc = enums.zone_climatique[zc_id].slice(0, 2);
+
+  du.enum_type_adjacence_id = Object.keys(enums.type_adjacence);
+  const matcher = {
+    enum_type_adjacence_id: requestInputID(de, du, 'type_adjacence')
+  };
+
+  if (de.enum_type_adjacence_id === '10') {
+    matcher.zone_climatique = zc;
+    matcher.enum_cfg_isolation_lnc_id = requestInputID(de, du, 'cfg_isolation_lnc');
+    /* du.enum_cfg_isolation_lnc_id = ['6', '7', '8', '9', '10', '11'] */
+  } else if (
+    ['8', '9', '11', '12', '13', '14', '15', '16', '17', '18', '19', '21'].includes(
+      de.enum_type_adjacence_id.toString()
+    )
+  ) {
+    if (de.surface_aue === 0) {
+      // cf page 10
+      // NOTE: bizarre de regarder aue pour un local chauffé non accessible
+      // voir 2287E2336469P
+      di.b = 0;
+      return;
+    }
+    matcher.enum_cfg_isolation_lnc_id = requestInputID(de, du, 'cfg_isolation_lnc');
+    if (matcher.enum_cfg_isolation_lnc_id === '1') {
+      // local chauffé non accessible
+      // aiu/aue non connu
+      delete matcher.enum_type_adjacence_id;
+    } else {
+      requestInput(de, du, 'surface_aiu', 'float');
+      requestInput(de, du, 'surface_aue', 'float');
+
+      if (de.surface_aiu === de.surface_aue) {
+        const defaultAiuAueMin = '0,75 <';
+        const defaultAiuAueMax = '≤ 1,00';
+
+        matcher.aiu_aue_min = defaultAiuAueMin;
+        matcher.aiu_aue_max = defaultAiuAueMax;
+
+        /**
+         * Certains DPE utilisent seulement aiu_aue_max = '≤ 0,25' alors que le ratio surface_aiu / surface_aue est 1 et donc
+         * on devrait avoir aiu_aue_min: '0,75 <' et aiu_aue_max: '≤ 1,00',
+         */
+        if (bug_for_bug_compat && de.tv_coef_reduction_deperdition_id) {
+          const rowCoeffReductionpertes = tv('coef_reduction_deperdition', {
+            tv_coef_reduction_deperdition_id: de.tv_coef_reduction_deperdition_id
+          });
+
+          if (rowCoeffReductionpertes) {
+            matcher.aiu_aue_min = rowCoeffReductionpertes.aiu_aue_min || defaultAiuAueMin;
+            matcher.aiu_aue_max = rowCoeffReductionpertes.aiu_aue_max || defaultAiuAueMax;
+
+            if (
+              matcher.aiu_aue_min !== defaultAiuAueMin ||
+              matcher.aiu_aue_max !== defaultAiuAueMax
+            ) {
+              console.error(
+                `Le calcul de b pour ${de.description} devrait se faire avec aiu_aue_min: '0,75 <' et aiu_aue_max: '≤ 1,00'
+                car surface_aiu === surface_aue. aiu_aue_min = ${matcher.aiu_aue_min} et aiu_aue_max = ${matcher.aiu_aue_max}
+                sont cependant utilisés par le DPE. Prise en compte de ces valeurs pour la suite des calculs`
+              );
+            }
+          }
+        }
+      } else {
+        const ranges = findRanges(de.surface_aiu / de.surface_aue);
+        if (ranges[0]) {
+          // Si le rapport des surfaces est égale à la borne inférieure, utilisation de la borne supérieure
+          // et prise en compte de l'égalité
+          if (ranges[0] === de.surface_aiu / de.surface_aue) {
+            matcher.aiu_aue_max =
+              '≤ ' +
+              ranges[0]
+                .toLocaleString(undefined, {
+                  minimumFractionDigits: 2,
+                  maximumFractionDigits: 2,
+                  useGrouping: false
+                })
+                .replace('.', ',');
+          } else {
+            matcher.aiu_aue_min =
+              ranges[0]
+                .toLocaleString(undefined, {
+                  minimumFractionDigits: 2,
+                  maximumFractionDigits: 2,
+                  useGrouping: false
+                })
+                .replace('.', ',') + ' <';
+          }
+        }
+        if (ranges[1]) {
+          matcher.aiu_aue_max =
+            '≤ ' +
+            ranges[1]
+              .toLocaleString(undefined, {
+                minimumFractionDigits: 2,
+                maximumFractionDigits: 2,
+                useGrouping: false
+              })
+              .replace('.', ',');
+        }
+      }
+    }
+  }
+
+  const row = tv('coef_reduction_deperdition', matcher);
+  if (row) {
+    di.b = Number(row.b);
+    de.tv_coef_reduction_deperdition_id = Number(row.tv_coef_reduction_deperdition_id);
+  } else {
+    console.error('!! pas de valeur forfaitaire trouvée pour b !!');
+  }
+}