@open3cl/engine 1.8.33 → 1.8.35

package/11_ecs.js

@@ -136,6 +136,49 @@ function calc_auxiliaire_distribution_ecs_immeuble(de, surfaceImmeuble, becsParM
   return 0;
 }
 
+/** Écart relatif toléré entre la somme des surfaces ECS exportées et SH. */
+const TOLERANCE_SURFACE_ECS = 0.05;
+
+/**
+ * Ratio de besoin ECS d'une installation individuelle d'un immeuble (par unité dimensionnée).
+ *
+ * Tribu (Moteur_DPE.dll, Calcul_batiment.Calcul_Cecs) : Ratio = Sh_ecs × Rdim / SH puis
+ * Becs = Becs_immeuble × Ratio / Rdim, la consommation étant remultipliée par rdim à l'agrégation
+ * (conso.js, cle_repartition_ecs). Les logiciels n'exportent pas tous Sh_ecs de la même façon :
+ * - surface d'un logement (Σ Sh × rdim ≈ SH) → ratio = Sh / SH ;
+ * - surface totale desservie par l'installation (Σ Sh ≈ SH) → ratio = Sh / SH / rdim.
+ * La convention est détectée sur l'ensemble des installations ECS du DPE. Repli sur
+ * 1 / nombre d'appartements si la surface est absente, si aucune des deux sommes ne retrouve SH
+ * (à TOLERANCE_SURFACE_ECS près) ou si le ratio est ≥ 1.
+ * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - §11.4
+ */
+export function ratio_besoin_ecs_individuel(dpe, de, surfaceImmeuble, nombreAppartements) {
+  const sh = Number(de.surface_habitable);
+  const SH = Number(surfaceImmeuble);
+  if (!(sh > 0 && SH > 0)) return 1 / nombreAppartements;
+
+  const installations = dpe?.logement?.installation_ecs_collection?.installation_ecs || [
+    { donnee_entree: de }
+  ];
+  const des = installations.map((inst) => inst.donnee_entree);
+  const sommeSh = des.reduce((acc, d) => acc + (Number(d.surface_habitable) || 0), 0);
+  const sommeShRdim = des.reduce(
+    (acc, d) => acc + (Number(d.surface_habitable) || 0) * (Number(d.rdim) || 1),
+    0
+  );
+  const ecartParLogement = Math.abs(sommeShRdim - SH);
+  const ecartParInstallation = Math.abs(sommeSh - SH);
+  const surfaceParLogement = ecartParLogement < ecartParInstallation;
+
+  // Surfaces exportées incohérentes avec SH (installations partielles, surface moyenne…) : repli
+  if (Math.min(ecartParLogement, ecartParInstallation) > TOLERANCE_SURFACE_ECS * SH) {
+    return 1 / nombreAppartements;
+  }
+
+  const ratio = surfaceParLogement ? sh / SH : sh / SH / (Number(de.rdim) || 1);
+  return ratio < 1 ? ratio : 1 / nombreAppartements;
+}
+
 export default function calc_ecs(
   dpe,
   ecs,
@@ -173,7 +216,12 @@ export default function calc_ecs(
     di.ratio_besoin_ecs = de.cle_repartition_ecs || 1;
   } else if (isImmeubleSystemEcsIndividuels) {
     if (nombreAppartements) {
-      di.ratio_besoin_ecs = 1 / nombreAppartements;
+      di.ratio_besoin_ecs = ratio_besoin_ecs_individuel(
+        dpe,
+        de,
+        surfaceImmeuble,
+        nombreAppartements
+      );
     } else {
       di.ratio_besoin_ecs =
         ((de.surface_habitable / (surfaceImmeuble || 1)) * (de.rdim || 1)) /

package/11_ecs.spec.js

@@ -82,6 +82,139 @@ describe('calc_ecs - ratio de besoin ECS', () => {
     expect(ecs.donnee_intermediaire.besoin_ecs).toBeCloseTo(25, 9);
   });
 
+  /**
+   * Immeuble à ECS individuelles de surfaces différentes (cas CSTB IC1-0-3 / IC1-0-5 : 4
+   * appartements de 20, 30, 45 et 80 m² sur 175 m², rdim 1) : besoin au prorata de la surface
+   * desservie, comme Tribu (Becs appartement 1 = Becs immeuble × 20 / 175).
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §11.4
+   */
+  test('immeuble à ECS individuelles : ratio = surface desservie / surface de l’immeuble', () => {
+    const des = [20, 30, 45, 80].map((surface) => ({
+      tv_rendement_distribution_ecs_id: '5',
+      surface_habitable: surface,
+      rdim: 1
+    }));
+    const dpe = {
+      logement: { installation_ecs_collection: { installation_ecs: des.map((de) => makeEcs(de)) } }
+    };
+    const ratios = dpe.logement.installation_ecs_collection.installation_ecs.map((ecs) => {
+      calc_ecs(dpe, ecs, 100, 200, 1, 'ca1', 'h1a', 'immeuble', false, 175, 4, true);
+      return ecs.donnee_intermediaire;
+    });
+
+    expect(ratios[0].ratio_besoin_ecs).toBeCloseTo(20 / 175, 9);
+    expect(ratios[0].besoin_ecs).toBeCloseTo((100 * 20) / 175, 9);
+    expect(ratios[0].besoin_ecs_depensier).toBeCloseTo((200 * 20) / 175, 9);
+    expect(ratios[3].ratio_besoin_ecs).toBeCloseTo(80 / 175, 9);
+    expect(ratios.reduce((acc, di) => acc + di.ratio_besoin_ecs, 0)).toBeCloseTo(1, 9);
+  });
+
+  test('immeuble à ECS individuelles, surface d’un logement exportée (Σ Sh × rdim = SH) : ratio = Sh / SH', () => {
+    // 3 installations de 100 m² par logement, rdim 2, 2 et 1 → 500 m²
+    const dpe = {
+      logement: {
+        installation_ecs_collection: {
+          installation_ecs: [2, 2, 1].map((rdim) =>
+            makeEcs({ tv_rendement_distribution_ecs_id: '5', surface_habitable: 100, rdim })
+          )
+        }
+      }
+    };
+    const [ecs] = dpe.logement.installation_ecs_collection.installation_ecs;
+    calc_ecs(dpe, ecs, 100, 200, 1, 'ca1', 'h1a', 'immeuble', false, 500, 5, true);
+
+    // besoin par logement ; la conso est remultipliée par rdim à l'agrégation
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBeCloseTo(100 / 500, 9);
+  });
+
+  test('immeuble à ECS individuelles, surface desservie totale exportée (Σ Sh = SH) : ratio = Sh / SH / rdim', () => {
+    // 2 installations desservant 300 m² (rdim 3) et 200 m² (rdim 2) → 500 m²
+    const dpe = {
+      logement: {
+        installation_ecs_collection: {
+          installation_ecs: [
+            makeEcs({ tv_rendement_distribution_ecs_id: '5', surface_habitable: 300, rdim: 3 }),
+            makeEcs({ tv_rendement_distribution_ecs_id: '5', surface_habitable: 200, rdim: 2 })
+          ]
+        }
+      }
+    };
+    const [ecs] = dpe.logement.installation_ecs_collection.installation_ecs;
+    calc_ecs(dpe, ecs, 100, 200, 1, 'ca1', 'h1a', 'immeuble', false, 500, 5, true);
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBeCloseTo(300 / 500 / 3, 9);
+  });
+
+  test('immeuble à ECS individuelles, rdim absent : rdim pris à 1', () => {
+    // 4 installations de 50 m² sans rdim : Σ Sh = 200 m² = SH
+    const dpe = {
+      logement: {
+        installation_ecs_collection: {
+          installation_ecs: [1, 2, 3, 4].map(() =>
+            makeEcs({ tv_rendement_distribution_ecs_id: '5', surface_habitable: 50 })
+          )
+        }
+      }
+    };
+    const [ecs] = dpe.logement.installation_ecs_collection.installation_ecs;
+    calc_ecs(dpe, ecs, 100, 200, 1, 'ca1', 'h1a', 'immeuble', false, 200, 5, true);
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBeCloseTo(50 / 200, 9);
+  });
+
+  test('immeuble à ECS individuelles, installation voisine sans surface ni rdim : ignorée dans la détection', () => {
+    const dpe = {
+      logement: {
+        installation_ecs_collection: {
+          installation_ecs: [
+            makeEcs({ tv_rendement_distribution_ecs_id: '5', surface_habitable: 100, rdim: 2 }),
+            makeEcs({ tv_rendement_distribution_ecs_id: '5' })
+          ]
+        }
+      }
+    };
+    const [ecs] = dpe.logement.installation_ecs_collection.installation_ecs;
+    calc_ecs(dpe, ecs, 100, 200, 1, 'ca1', 'h1a', 'immeuble', false, 200, 2, true);
+
+    // Σ Sh × rdim = 200 = SH → surface par logement
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBeCloseTo(100 / 200, 9);
+  });
+
+  test('immeuble à ECS individuelles, surfaces exportées incohérentes avec SH → repli 1 / nombre d’appartements', () => {
+    // 2 installations de 88,67 m², rdim 1,33 (LICIEL) : Σ Sh = 177, Σ Sh × rdim = 236 ≠ 266 m²
+    const dpe = {
+      logement: {
+        installation_ecs_collection: {
+          installation_ecs: [1, 2].map(() =>
+            makeEcs({
+              tv_rendement_distribution_ecs_id: '5',
+              surface_habitable: 88.67,
+              rdim: 1.333
+            })
+          )
+        }
+      }
+    };
+    const [ecs] = dpe.logement.installation_ecs_collection.installation_ecs;
+    calc_ecs(dpe, ecs, 100, 200, 1, 'ca1', 'h1a', 'immeuble', false, 266, 4, true);
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBe(0.25);
+  });
+
+  test('immeuble à ECS individuelles, surface couvrant tout l’immeuble → repli 1 / nombre d’appartements', () => {
+    const ecs = makeEcs({ tv_rendement_distribution_ecs_id: '5', surface_habitable: 175 });
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'immeuble', false, 175, 4, true);
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBe(0.25);
+  });
+
+  test('immeuble à ECS individuelles, surface de l’immeuble absente → repli 1 / nombre d’appartements', () => {
+    const ecs = makeEcs({ tv_rendement_distribution_ecs_id: '5', surface_habitable: 20 });
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'immeuble', false, null, 4, true);
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBe(0.25);
+  });
+
   test('présence de rdim : ratio = 1 / rdim', () => {
     const de = { tv_rendement_distribution_ecs_id: '5', rdim: 2 };
     const ecs = makeEcs(de);

package/16.2_production_enr.js

@@ -3,6 +3,38 @@ import { mois_liste, tv } from './utils.js';
 import tvs from './tv.js';
 import { DEFAULT_COEFF_EP } from './conso.js';
 
+/**
+ * Méthodes d'application « appartement chauffage individuel ECS individuel » : l'installation PV
+ * déclarée est celle du logement, aucune proratisation (exports ADEME non proratisés, cf. 2528E1249844E).
+ */
+const MAP_APPARTEMENT_INDIVIDUEL = ['2', '22', '25'];
+
+/**
+ * Coefficient de proratisation au logement de la production d'une installation PV d'immeuble.
+ *
+ * Le moteur de référence (Tribu, `Calcul_batiment.cs` l.1142-1156) calcule le taux de couverture
+ * Tcv = Ppv / Celec_tot avec la surface du logement : pour un appartement desservi par une
+ * installation d'immeuble, la surface de capteurs doit être ramenée au logement
+ * (S_capteur × Sh_logement / Sh_immeuble), comme pour les générateurs collectifs (l.253, l.303).
+ *
+ * @param th {string} type de bâtiment ('maison', 'appartement', 'immeuble')
+ * @param map_id {string} enum_methode_application_dpe_log_id
+ * @param surfaceLogement {number|string} surface_habitable_logement
+ * @param surfaceImmeuble {number|string} surface_habitable_immeuble
+ * @returns {number} 1 si aucune proratisation, sinon Sh_logement / Sh_immeuble
+ */
+export function ratioProrataPvLogement(th, map_id, surfaceLogement, surfaceImmeuble) {
+  const shl = Number(surfaceLogement);
+  const shi = Number(surfaceImmeuble);
+  if (th !== 'appartement' || MAP_APPARTEMENT_INDIVIDUEL.includes(String(map_id))) {
+    return 1;
+  }
+  if (!(shl > 0) || !(shi > shl)) {
+    return 1;
+  }
+  return shl / shi;
+}
+
 export class ProductionENR {
   /**
    * Taux d'autoproduction limite par poste Taplpi (§16.2).
@@ -29,8 +61,9 @@ export class ProductionENR {
    * @param th {string}
    * @param zc_id {string}
    * @param coeff_ep_override {number?}
+   * @param ratioPv {number?} proratisation au logement d'une installation d'immeuble (cf. ratioProrataPvLogement)
    */
-  calculateEnr(productionElecEnr, conso, Sh, th, zc_id, coeff_ep_override) {
+  calculateEnr(productionElecEnr, conso, Sh, th, zc_id, coeff_ep_override, ratioPv = 1) {
     const productionElectricite = {
       conso_elec_ac: 0,
       production_pv: 0,
@@ -49,7 +82,15 @@ export class ProductionENR {
 
     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);
+      this.calculateConsoElecAc(
+        productionElectricite,
+        productionElecEnr,
+        conso,
+        zc_id,
+        th,
+        Sh,
+        ratioPv
+      );
 
       // Mise à jour des consommations d'énergie finale en minorant l'énergie consommée par l'énergie autoconsommée par le poste
       this.updateEfConso(productionElectricite, conso, Sh);
@@ -78,10 +119,19 @@ export class ProductionENR {
    * @param zc_id
    * @param th
    * @param Sh
+   * @param ratioPv {number?}
    */
-  calculateConsoElecAc(productionElectricite, productionElecEnr, conso, zc_id, th, Sh) {
+  calculateConsoElecAc(
+    productionElectricite,
+    productionElecEnr,
+    conso,
+    zc_id,
+    th,
+    Sh,
+    ratioPv = 1
+  ) {
     // Production d’électricité par des capteurs photovoltaïques Ppv (en kWh/m²)
-    const Ppv = this.getPpv(productionElecEnr, zc_id);
+    const Ppv = this.getPpv(productionElecEnr, zc_id, ratioPv);
 
     // Consommation annuelle d’électricité pour les autres usages (kWhef/an)
     const CelecTotAu = this.getCelecAu(th, Sh);
@@ -342,9 +392,11 @@ export class ProductionENR {
    *
    * @param productionElecEnr
    * @param zc_id
+   * @param ratioPv {number?} proratisation au logement (1 = aucune). Non appliquée aux installations
+   * qui exportent un ratio_virtualisation (déjà virtualisées par le logiciel).
    * @returns {number}
    */
-  getPpv(productionElecEnr, zc_id) {
+  getPpv(productionElecEnr, zc_id, ratioPv = 1) {
     const ePvValues = tvs.e_pv;
     const zc = enums.zone_climatique[zc_id];
 
@@ -370,8 +422,23 @@ export class ProductionENR {
        */
       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;
+      /**
+       * Surface des panneaux photovoltaïques orientés et inclinés de la même manière (m²).
+       * Le moteur de référence n'a que S_capteur en entrée (Tribu `photovoltaique.cs` l.8) : la
+       * surface saisie est prioritaire, le forfait 1,6 m²/module ne sert qu'à défaut de surface.
+       */
+      let Scapteur = panneaux_pv.surface_totale_capteurs || 1.6 * panneaux_pv.nombre_module;
+
+      /**
+       * Installation d'immeuble : surface ramenée au logement (Sh_logement / Sh_immeuble).
+       * Si l'installation exporte un ratio_virtualisation, le logiciel de saisie a déjà virtualisé
+       * l'installation au logement et la production ADEME n'est pas proratisée (corpus : 36 exports
+       * LICIEL, autoconsommation ADEME reproduite sans proratisation, jamais avec ; ex. 2501E3381654V,
+       * 2369E0282894H, 2469E2989760O) : pas de proratisation supplémentaire.
+       */
+      if (ratioPv !== 1 && panneaux_pv.ratio_virtualisation == null) {
+        Scapteur *= ratioPv;
+      }
 
       // Rendement moyen des modules
       const r = 0.17;

package/16.2_production_enr.spec.js

@@ -1,4 +1,4 @@
-import { ProductionENR } from './16.2_production_enr.js';
+import { ProductionENR, ratioProrataPvLogement } from './16.2_production_enr.js';
 import { describe, expect, test, it } from 'vitest';
 
 describe('production ENR unit tests', () => {
@@ -47,8 +47,12 @@ describe('production ENR unit tests', () => {
   });
 
   it.each([
-    [2826.8015616000007, 8, 9.6],
-    [2120.1011712, undefined, 9.6]
+    // surface saisie prioritaire sur le forfait 1,6 m²/module (Tribu : seule S_capteur en entrée)
+    [2120.1011712, 8, 9.6],
+    [2120.1011712, undefined, 9.6],
+    // à défaut de surface : 1,6 m² × nombre de modules
+    [2826.8015616000007, 8, undefined],
+    [2826.8015616000007, 8, 0]
   ])(
     'should get ppv %s with nombre module %s and surface totale capteur %s',
     (ppv, nombre_module, surface_totale_capteurs) => {
@@ -68,6 +72,97 @@ describe('production ENR unit tests', () => {
     }
   );
 
+  describe('proratisation au logement des installations PV d’immeuble', () => {
+    const panneau = (extra = {}) => ({
+      panneaux_pv_collection: {
+        panneaux_pv: [
+          {
+            surface_totale_capteurs: 9.6,
+            nombre_module: 8,
+            enum_orientation_pv_id: 1,
+            enum_inclinaison_pv_id: 2,
+            ...extra
+          }
+        ]
+      }
+    });
+
+    test('ratio 1 par défaut : production de l’installation complète', () => {
+      expect(productionENR.getPpv(panneau(), 1)).toBe(2120.1011712);
+    });
+
+    test('la production est proratisée par Sh_logement / Sh_immeuble', () => {
+      expect(productionENR.getPpv(panneau(), 1, 0.25)).toBeCloseTo(2120.1011712 * 0.25, 9);
+    });
+
+    test.each([0.1, 0.01, 0])(
+      'installation déjà virtualisée par le logiciel (ratio_virtualisation %s) : pas de proratisation',
+      (ratio_virtualisation) => {
+        expect(productionENR.getPpv(panneau({ ratio_virtualisation }), 1, 0.25)).toBe(2120.1011712);
+      }
+    );
+
+    test('le ratio_virtualisation est ignoré sans proratisation (maison, appartement individuel)', () => {
+      expect(productionENR.getPpv(panneau({ ratio_virtualisation: 0.1 }), 1, 1)).toBe(2120.1011712);
+    });
+
+    test('2469E1760405R : 2 m² saisis, 18 modules, Sh 67,42 / 1 921,43 m²', () => {
+      // Ppv = S × Sh_log / Sh_imm × Σ k·0,17·Epv·0,86 : la production dépend de la surface
+      // retenue (2 m², pas 1,6 × 18 = 28,8 m²) et est ramenée au logement.
+      const ratio = ratioProrataPvLogement('appartement', '5', 67.42, 1921.43);
+      const pvImmeuble = productionENR.getPpv(
+        panneau({ surface_totale_capteurs: 2, nombre_module: 18 }),
+        1
+      );
+      const pvLogement = productionENR.getPpv(
+        panneau({ surface_totale_capteurs: 2, nombre_module: 18 }),
+        1,
+        ratio
+      );
+      expect(pvImmeuble).toBeCloseTo((2120.1011712 / 9.6) * 2, 9);
+      expect(pvLogement).toBeCloseTo(pvImmeuble * (67.42 / 1921.43), 9);
+    });
+
+    test('calculateEnr transmet le ratio à la production PV', () => {
+      const conso = {
+        ef_conso: { conso_ecs: 1000, conso_5_usages: 1500 },
+        ep_conso: { ep_conso_5_usages: 10000 },
+        sortie_par_energie_collection: {
+          sortie_par_energie: [{ enum_type_energie_id: '1', conso_5_usages: 1500 }]
+        }
+      };
+      const ret = productionENR.calculateEnr(
+        { donnee_entree: { presence_production_pv: 1 }, ...panneau() },
+        conso,
+        10,
+        'appartement',
+        1,
+        undefined,
+        0.5
+      );
+      expect(ret.production_pv).toBeCloseTo(2120.1011712 * 0.5, 9);
+    });
+  });
+
+  describe('ratioProrataPvLogement', () => {
+    test.each([
+      ['appartement, installation d’immeuble (map 5)', 'appartement', '5', 50, 200, 0.25],
+      ['appartement issu d’un DPE immeuble (map 33)', 'appartement', '33', 50, 200, 0.25],
+      ['surfaces sous forme de chaînes', 'appartement', '32', '48.3', '1113.35', 48.3 / 1113.35],
+      ['maison', 'maison', '1', 50, 200, 1],
+      ['immeuble', 'immeuble', '6', 200, 200, 1],
+      ['appartement chauffage + ECS individuels (map 2)', 'appartement', '2', 50, 200, 1],
+      ['appartement RT2012 individuel (map 22)', 'appartement', '22', 50, 200, 1],
+      ['appartement RE2020 individuel (map 25)', 'appartement', '25', 50, 200, 1],
+      ['surface immeuble absente', 'appartement', '5', 50, undefined, 1],
+      ['surface logement absente', 'appartement', '5', undefined, 200, 1],
+      ['surface immeuble égale à celle du logement', 'appartement', '5', 50, 50, 1],
+      ['surface immeuble inférieure à celle du logement', 'appartement', '5', 50, 40, 1]
+    ])('%s', (_label, th, mapId, shl, shi, attendu) => {
+      expect(ratioProrataPvLogement(th, mapId, shl, shi)).toBeCloseTo(attendu, 12);
+    });
+  });
+
   test('should update ef conso', () => {
     const productionElectricite = {
       conso_elec_ac_fr: 100,

package/README.md

@@ -370,57 +370,57 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <!-- CORPUS:START -->
 
-> **Version `1.8.32`** · branche `main` · généré le 2026-10-09
+> **Version `1.8.34`** · branche `main` · généré le 2026-10-09
 > Seuil de tolérance **5%**
 
 <table>
 <tr>
 <td align="center"><strong>9</strong><br/><sub>corpus</sub></td>
-<td align="center"><strong>89 987</strong><br/><sub>DPE analysés</sub></td>
-<td align="center"><strong>60 962</strong><br/><sub>DPE conformes</sub></td>
-<td align="center"><strong>67,75 %</strong><br/><sub>réussite globale</sub></td>
+<td align="center"><strong>89 986</strong><br/><sub>DPE analysés</sub></td>
+<td align="center"><strong>61 945</strong><br/><sub>DPE conformes</sub></td>
+<td align="center"><strong>68,84 %</strong><br/><sub>réussite globale</sub></td>
 </tr>
 </table>
 
 |     | Corpus                                                                                                                  |    Réussite |                        |  DPE conformes |
 | :-: | :---------------------------------------------------------------------------------------------------------------------- | ----------: | :--------------------- | -------------: |
-| 🔴  | **Généraliste**<br/><sub>`corpus_dpe.csv`</sub>                                                                         | **46,14 %** | `█████████░░░░░░░░░░░` | 4 614 / 10 000 |
+| 🔴  | **Généraliste**<br/><sub>`corpus_dpe.csv`</sub>                                                                         | **46,13 %** | `█████████░░░░░░░░░░░` |  4 613 / 9 999 |
 | 🟢  | **Appartement · chauffage individuel (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_individuel_2025.csv`</sub> | **92,53 %** | `███████████████████░` | 9 253 / 10 000 |
 | 🟢  | **Logement individuel (2025)**<br/><sub>`dpe_logement_individuel_2025.csv`</sub>                                        | **89,54 %** | `██████████████████░░` |  8 947 / 9 992 |
 | 🟢  | **Maison individuelle (2025)**<br/><sub>`dpe_maison_individuelle_2025.csv`</sub>                                        | **88,60 %** | `██████████████████░░` |  8 859 / 9 999 |
-| 🟡  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **77,02 %** | `███████████████░░░░░` |  7 700 / 9 998 |
+| 🟡  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **84,21 %** | `█████████████████░░░` |  8 419 / 9 998 |
 | 🟡  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **71,59 %** | `██████████████░░░░░░` | 7 159 / 10 000 |
-| 🟡  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **65,11 %** | `█████████████░░░░░░░` |  6 510 / 9 999 |
-| 🔴  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **52,15 %** | `██████████░░░░░░░░░░` |  5 214 / 9 999 |
+| 🟡  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **66,19 %** | `█████████████░░░░░░░` |  6 618 / 9 999 |
+| 🔴  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **53,72 %** | `███████████░░░░░░░░░` |  5 371 / 9 999 |
 | 🔴  | **Individuel généré depuis l'immeuble (2026)**<br/><sub>`dpe_individuel_a_partir_dpe_immeuble_2026.csv`</sub>           | **27,06 %** | `█████░░░░░░░░░░░░░░░` | 2 706 / 10 000 |
 
 <sub>🟢 ≥ 85 % · 🟡 ≥ 60 % · 🔴 < 60 %</sub>
 
 #### Temps d’exécution
 
-> Durée de l’appel à `calcul_3cl` par DPE, sur 89 953 calculs.
+> Durée de l’appel à `calcul_3cl` par DPE, sur 89 952 calculs.
 > La copie défensive de l’entrée et la lecture du fichier sont exclues de la mesure.
 
 <table>
 <tr>
-<td align="center"><strong>5,04 ms</strong><br/><sub>moyenne</sub></td>
-<td align="center"><strong>4,40 ms</strong><br/><sub>médiane</sub></td>
-<td align="center"><strong>0,12 ms</strong><br/><sub>min</sub></td>
-<td align="center"><strong>540,9 ms</strong><br/><sub>max</sub></td>
+<td align="center"><strong>5,76 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>5,07 ms</strong><br/><sub>médiane</sub></td>
+<td align="center"><strong>0,17 ms</strong><br/><sub>min</sub></td>
+<td align="center"><strong>856,2 ms</strong><br/><sub>max</sub></td>
 </tr>
 </table>
 
 | Corpus                                         | Moyenne | Médiane |     Min |      Max |     p95 |     p99 |
 | :--------------------------------------------- | ------: | ------: | ------: | -------: | ------: | ------: |
-| **Généraliste**                                | 4,72 ms | 4,29 ms | 0,22 ms |  39,9 ms | 8,47 ms | 12,0 ms |
-| **Appartement · chauffage individuel (2025)**  | 3,77 ms | 3,41 ms | 1,43 ms |  30,2 ms | 6,59 ms | 8,63 ms |
-| **Logement individuel (2025)**                 | 4,70 ms | 4,16 ms | 1,67 ms |  35,0 ms | 8,73 ms | 11,8 ms |
-| **Maison individuelle (2025)**                 | 5,69 ms | 5,09 ms | 1,67 ms |  53,0 ms | 10,4 ms | 13,8 ms |
-| **Immeuble · chauffage individuel**            | 6,13 ms | 5,22 ms | 0,12 ms |  77,1 ms | 12,3 ms | 19,5 ms |
-| **Appartement · chauffage collectif (2025)**   | 4,20 ms | 3,77 ms | 1,44 ms |  24,5 ms | 6,96 ms | 9,09 ms |
-| **Immeuble · chauffage collectif**             | 5,33 ms | 4,49 ms | 0,12 ms |  99,2 ms | 9,91 ms | 18,2 ms |
-| **Immeuble · chauffage mixte**                 | 5,06 ms | 4,14 ms | 0,20 ms | 540,9 ms | 10,6 ms | 16,8 ms |
-| **Individuel généré depuis l'immeuble (2026)** | 5,77 ms | 5,02 ms | 1,64 ms |  45,3 ms | 10,9 ms | 16,5 ms |
+| **Généraliste**                                | 4,95 ms | 4,55 ms | 0,23 ms |  34,8 ms | 8,96 ms | 12,0 ms |
+| **Appartement · chauffage individuel (2025)**  | 3,85 ms | 3,49 ms | 1,48 ms |  37,6 ms | 6,63 ms | 8,69 ms |
+| **Logement individuel (2025)**                 | 5,66 ms | 5,09 ms | 1,71 ms |  45,2 ms | 10,5 ms | 14,0 ms |
+| **Maison individuelle (2025)**                 | 6,33 ms | 5,75 ms | 2,00 ms |  43,8 ms | 11,1 ms | 14,6 ms |
+| **Immeuble · chauffage individuel**            | 6,54 ms | 5,58 ms | 0,17 ms |  81,9 ms | 13,2 ms | 21,7 ms |
+| **Appartement · chauffage collectif (2025)**   | 4,44 ms | 4,09 ms | 1,55 ms |  36,6 ms | 7,30 ms | 10,3 ms |
+| **Immeuble · chauffage collectif**             | 5,41 ms | 4,58 ms | 0,20 ms |  97,7 ms | 9,90 ms | 18,1 ms |
+| **Immeuble · chauffage mixte**                 | 6,86 ms | 5,57 ms | 0,27 ms | 856,2 ms | 14,8 ms | 25,4 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 7,86 ms | 6,93 ms | 1,81 ms |  67,1 ms | 16,5 ms | 26,4 ms |
 
 <sub>La moyenne est tirée vers le haut par les DPE collectifs, dont le coût atteint plusieurs
 dizaines de fois la médiane : c’est la médiane qui décrit le cas courant, et p95/p99 le cas

package/engine.js

@@ -30,10 +30,10 @@ import {
 } from './utils.js';
 import { Inertie } from './7_inertie.js';
 import getFicheTechnique from './ficheTechnique.js';
-import { ProductionENR } from './16.2_production_enr.js';
+import { ProductionENR, ratioProrataPvLogement } from './16.2_production_enr.js';
 import DpeSanitizerService from './dpe-sanitizer.service.js';
 
-const LIB_VERSION = '1.8.33';
+const LIB_VERSION = '1.8.35';
 
 const dpeSanitizerService = new DpeSanitizerService();
 
@@ -598,12 +598,22 @@ export function calcul_3cl(inputDpe, options) {
     th === 'immeuble' ? Nb_lgt : 1
   );
 
+  // Proratisation au logement d'une installation PV d'immeuble (appartement)
+  const ratioPv = ratioProrataPvLogement(
+    th,
+    map_id,
+    cg.surface_habitable_logement,
+    cg.surface_habitable_immeuble
+  );
+
   const production_electricite = productionENR.calculateEnr(
     dpe.logement.production_elec_enr,
     conso,
     Sh,
     th,
-    zc_id
+    zc_id,
+    undefined,
+    ratioPv
   );
 
   const conso1_7 = calc_conso(
@@ -627,7 +637,8 @@ export function calcul_3cl(inputDpe, options) {
     Sh,
     th,
     zc_id,
-    COEFF_EP_1_7
+    COEFF_EP_1_7,
+    ratioPv
   );
 
   const conso2_3 = calc_conso(
@@ -651,7 +662,8 @@ export function calcul_3cl(inputDpe, options) {
     Sh,
     th,
     zc_id,
-    COEFF_EP_2_3
+    COEFF_EP_2_3,
+    ratioPv
   );
 
   // get all baie_vitree orientations

package/engine.spec.js

@@ -75,8 +75,12 @@ vi.mock('./ficheTechnique.js', () => ({ default: vi.fn() }));
 // On expose des méthodes mockées récupérables dans les tests.
 const calculateInertie = vi.fn();
 const calculateEnr = vi.fn();
+const ratioProrataPvLogement = vi.fn();
 vi.mock('./7_inertie.js', () => ({ Inertie: vi.fn(() => ({ calculateInertie })) }));
-vi.mock('./16.2_production_enr.js', () => ({ ProductionENR: vi.fn(() => ({ calculateEnr })) }));
+vi.mock('./16.2_production_enr.js', () => ({
+  ProductionENR: vi.fn(() => ({ calculateEnr })),
+  ratioProrataPvLogement: (...args) => ratioProrataPvLogement(...args)
+}));
 
 // Le service de sanitisation est instancié au chargement puis appelé : `execute`
 // renvoie l'entrée telle quelle.
@@ -153,6 +157,8 @@ beforeEach(() => {
   };
   vi.mocked(calc_conso).mockReturnValue(consoResult);
   vi.mocked(calculateEnr).mockReturnValue({ pv: 1 });
+  ratioProrataPvLogement.mockReset();
+  ratioProrataPvLogement.mockReturnValue(0.25);
   vi.mocked(calc_confort_ete).mockReturnValue('confort');
   vi.mocked(calc_qualite_isolation).mockReturnValue('qualite');
 });
@@ -426,17 +432,24 @@ describe('calcul_3cl - run intégral (maison)', () => {
     expect(calc_conso.mock.calls[0][7]).toBe(1);
     expect(calc_conso.mock.calls[0][8]).toBe(1);
 
-    // 3 calculs de production ENR ; le 1ᵉʳ sans coefficient.
+    // Coefficient de proratisation PV calculé à partir du type de bâtiment, de la méthode et des surfaces.
+    expect(ratioProrataPvLogement).toHaveBeenCalledWith('maison', '1', 80, 200);
+
+    // 3 calculs de production ENR ; le 1ᵉʳ sans coefficient ; le ratio PV est transmis aux 3 passes.
     expect(calculateEnr).toHaveBeenCalledTimes(3);
     expect(calculateEnr.mock.calls[0]).toEqual([
       dpe.logement.production_elec_enr,
       consoResult,
       80,
       'maison',
-      'zc1'
+      'zc1',
+      undefined,
+      0.25
     ]);
     expect(calculateEnr.mock.calls[1][5]).toBe(1.7);
     expect(calculateEnr.mock.calls[2][5]).toBe(2.3);
+    expect(calculateEnr.mock.calls[1][6]).toBe(0.25);
+    expect(calculateEnr.mock.calls[2][6]).toBe(0.25);
 
     // Sorties agrégées.
     expect(dpe.logement.sortie.deperdition).toEqual({ deperdition_enveloppe: 300 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open3cl/engine",
-  "version": "1.8.33",
+  "version": "1.8.35",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {