@open3cl/engine 1.8.65 → 1.8.67

package/10_clim.js

@@ -14,10 +14,22 @@ function tv_seer(di, de, du, zc_id) {
   }
 }
 
-export default function calc_clim(clim, bfr, bfr_dep, zc_id, Sh) {
+/**
+ * @param clim {object} climatisation
+ * @param bfr {number} besoin de froid du bâtiment
+ * @param bfr_dep {number} besoin de froid dépensier du bâtiment
+ * @param zc_id {string} zone climatique
+ * @param Sh {number} surface de référence du calcul (SH immeuble pour un DPE généré depuis l'immeuble)
+ * @param prorataLogement {number} part du logement dans la consommation de froid de l'installation
+ * (Sh_logement / SH_immeuble pour un DPE appartement généré à partir de l'immeuble, 1 sinon). Les
+ * données intermédiaires restent à l'échelle de l'installation, comme dans le DPE de référence ;
+ * le prorata n'est appliqué qu'à l'agrégation des consommations du logement (conso.js).
+ * @see https://github.com/Open3CL/engine/issues/303
+ */
+export default function calc_clim(clim, bfr, bfr_dep, zc_id, Sh, prorataLogement = 1) {
   const de = clim.donnee_entree;
   const di = clim.donnee_intermediaire || {};
-  const du = {};
+  const du = { prorata_logement: prorataLogement };
 
   const rs = de.surface_clim / Sh;
   di.besoin_fr = bfr * rs;

package/10_clim.spec.js

@@ -105,6 +105,32 @@ describe('calc_clim - consommation de climatisation', () => {
     expect(c.donnee_intermediaire.eer).toBe(3);
   });
 
+  /**
+   * DPE appartement généré à partir de l'immeuble : la part du logement est transmise via
+   * donnee_utilisateur, les données intermédiaires restant à l'échelle de l'installation.
+   * @see https://github.com/Open3CL/engine/issues/303
+   */
+  test('prorata logement : mémorisé, données intermédiaires à l’échelle de l’installation', () => {
+    tv.mockReturnValue({ tv_seer_id: '5', eer: 3 });
+    const c = clim({ surface_clim: 100, enum_methode_saisie_carac_sys_id: '1' });
+
+    calc_clim(c, 1000, 1500, '1', 100, 0.25);
+
+    expect(c.donnee_utilisateur.prorata_logement).toBe(0.25);
+    // inchangé par le prorata : 0.9 * 1000 / 3
+    expect(c.donnee_intermediaire.besoin_fr).toBeCloseTo(1000, 9);
+    expect(c.donnee_intermediaire.conso_fr).toBeCloseTo(300, 9);
+  });
+
+  test('prorata logement absent : 1 par défaut', () => {
+    tv.mockReturnValue({ tv_seer_id: '5', eer: 3 });
+    const c = clim({ surface_clim: 100, enum_methode_saisie_carac_sys_id: '1' });
+
+    calc_clim(c, 1000, 1500, '1', 100);
+
+    expect(c.donnee_utilisateur.prorata_logement).toBe(1);
+  });
+
   test('aucune ligne forfaitaire trouvée : EER indéfini, conso non finie', () => {
     tv.mockReturnValue(null);
     const c = clim({ surface_clim: 50, enum_methode_saisie_carac_sys_id: '1' });

package/3.2.1_mur.js

@@ -80,6 +80,63 @@ function matcherEpaisseurTable(matcher) {
   };
 }
 
+/**
+ * Matériaux de structure des parois dites « anciennes », seules concernées par l'enduit isolant :
+ * « parois […] constituées de matériaux traditionnels à savoir pierres, terre, mur à colombage,
+ * brique ancienne ».
+ * 2, 3 - pierre de taille et moellons ; 4 - pisé / béton de terre ; 5, 6 - pan de bois (colombage) ;
+ * 7 - bois (rondin) ; 8, 9 - briques pleines ; 21 - autre matériau traditionnel ancien.
+ *
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §3.2.1
+ * @see https://github.com/Open3CL/engine/issues/295
+ */
+export const MATERIAUX_PAROI_ANCIENNE = [2, 3, 4, 5, 6, 7, 8, 9, 21];
+
+/**
+ * Umur0 interpolé linéairement entre les deux colonnes d'épaisseur de la table Umur0 qui encadrent
+ * strictement l'épaisseur saisie (pratique de certains logiciels, ex : béton banché de 32 cm).
+ *
+ * La méthode ne précise pas de règle d'interpolation pour Umur0 : cette valeur n'est utilisée qu'en
+ * compatibilité (bug_for_bug), lorsque le DPE d'origine l'a manifestement appliquée.
+ *
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §3.2.1.2
+ * @see https://github.com/Open3CL/engine/issues/295
+ *
+ * @param enumMateriauxStructureMurId {string|number}
+ * @param epaisseur {number|string}
+ * @returns {number|undefined} Umur0 interpolé, ou undefined si l'épaisseur n'est pas numérique,
+ * est une colonne de la table ou se situe hors des colonnes de la table
+ */
+export function umur0Interpole(enumMateriauxStructureMurId, epaisseur) {
+  const ep = Number(epaisseur);
+  if (!Number.isFinite(ep)) return undefined;
+
+  const points = tvs.umur0
+    .filter(
+      (row) =>
+        String(row.enum_materiaux_structure_mur_id) === String(enumMateriauxStructureMurId) &&
+        row.epaisseur_structure
+    )
+    .map((row) => ({
+      epaisseur: parseFloat(String(row.epaisseur_structure).replace(/[≤≥\s]/g, '')),
+      umur0: Number(row.umur0)
+    }))
+    .filter((point) => Number.isFinite(point.epaisseur))
+    .sort((a, b) => a.epaisseur - b.epaisseur);
+
+  for (let i = 0; i < points.length - 1; i++) {
+    const bas = points[i];
+    const haut = points[i + 1];
+    if (ep > bas.epaisseur && ep < haut.epaisseur) {
+      return (
+        bas.umur0 +
+        ((haut.umur0 - bas.umur0) * (ep - bas.epaisseur)) / (haut.epaisseur - bas.epaisseur)
+      );
+    }
+  }
+  return undefined;
+}
+
 function tv_umur0(di, de, du) {
   const matcher = {
     enum_materiaux_structure_mur_id: de.enum_materiaux_structure_mur_id
@@ -142,6 +199,27 @@ function tv_umur0(di, de, du) {
   if (row) {
     di.umur0 = Number(row.umur0);
     de.tv_umur0_id = Number(row.tv_umur0_id);
+
+    /**
+     * Certains logiciels interpolent Umur0 entre les deux colonnes d'épaisseur qui encadrent
+     * l'épaisseur saisie (ex : 2,28 pour un béton banché de 32 cm, entre 30 et 35 cm).
+     * Si l'Umur0 du DPE correspond à cette interpolation (tolérance empirique de 0,006), on la reprend.
+     * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §3.2.1.2
+     * @see https://github.com/Open3CL/engine/issues/295
+     */
+    if (bug_for_bug_compat && du.umur0_avant !== undefined) {
+      const umur0Interp = umur0Interpole(
+        de.enum_materiaux_structure_mur_id,
+        matcher.epaisseur_structure
+      );
+      if (
+        umur0Interp !== undefined &&
+        Math.abs(umur0Interp - di.umur0) > 0.001 &&
+        Math.abs(umur0Interp - Number(du.umur0_avant)) < 0.006
+      ) {
+        di.umur0 = umur0Interp;
+      }
+    }
   } else {
     console.error('!! pas de valeur forfaitaire trouvée pour umur0 !!');
   }
@@ -242,7 +320,25 @@ function calc_umur0(di, de, du, versionDpe) {
    * @see https://github.com/Open3CL/engine/issues/146
    */
   const type_isolation = parseInt(de.enum_type_isolation_id) || 1;
-  const hasIteOrIti = versionDpe >= 2.4 && [3, 4, 6, 7, 8].includes(type_isolation);
+  const isolationIteOuIti = [3, 4, 6, 7, 8].includes(type_isolation);
+  let hasIteOrIti = versionDpe >= 2.4 && isolationIteOuIti;
+
+  /**
+   * DPE antérieurs à la version 2.4 : certains logiciels n'y cumulent déjà pas le doublage avec une
+   * isolation ITE/ITI. Si l'Umur0 du DPE vaut min(2,5 ; Umur0 de la paroi nue), le doublage n'a pas
+   * été appliqué : on ne l'applique pas non plus.
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §3.2.1
+   * @see https://github.com/Open3CL/engine/issues/295
+   */
+  if (
+    bug_for_bug_compat &&
+    !hasIteOrIti &&
+    isolationIteOuIti &&
+    umur0_avant !== undefined &&
+    Math.abs(Number(umur0_avant) - Math.min(2.5, Number(di.umur0))) < 0.001
+  ) {
+    hasIteOrIti = true;
+  }
 
   // Si présence d'un doublage et pas d'isolation ITE/ITI
   if (type_doublage > 2 && !hasIteOrIti) {
@@ -272,10 +368,24 @@ function calc_umur0(di, de, du, versionDpe) {
     const umur0Enduit = 1 / (1 / di.umur0 + 0.7);
     di.umur0Enduit = umur0Enduit;
 
+    /**
+     * L'Umur0 exporté par certains logiciels est la valeur avant enduit, alors que l'Umur exporté
+     * intègre l'enduit. Si l'Umur du DPE vaut min(2,5 ; Umur0 avec enduit), le DPE a bien appliqué
+     * l'enduit : l'Umur0 d'origine ne doit pas être conservé.
+     * Garde : l'enduit isolant ne vaut que pour les parois anciennes (MATERIAUX_PAROI_ANCIENNE).
+     * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §3.2.1
+     * @see https://github.com/Open3CL/engine/issues/295
+     */
+    const enduitAppliqueDansDpe =
+      MATERIAUX_PAROI_ANCIENNE.includes(parseInt(de.enum_materiaux_structure_mur_id)) &&
+      umur_avant !== undefined &&
+      Math.abs(Number(umur_avant) - Math.min(2.5, umur0Enduit)) < 0.001;
+
     if (
       bug_for_bug_compat &&
       umur0_avant !== undefined &&
-      parseFloat(umur0_avant).toFixed(3) === Math.min(2.5, di.umur0).toFixed(3)
+      parseFloat(umur0_avant).toFixed(3) === Math.min(2.5, di.umur0).toFixed(3) &&
+      !enduitAppliqueDansDpe
     ) {
       console.error(`
         Le mur ${de.description} est une paroi dite 'paroi ancienne avec enduit', la valeur de Umur0 devrait prendre en compte cet enduit et devrait être ${umur0Enduit}.

package/3.2.1_mur.spec.js

@@ -37,7 +37,32 @@ vi.mock('./tv.js', () => ({
       { tv_umur0_id: '144', enum_materiaux_structure_mur_id: '26', epaisseur_structure: '10' },
       { tv_umur0_id: '145', enum_materiaux_structure_mur_id: '26', epaisseur_structure: '15' },
       { tv_umur0_id: '146', enum_materiaux_structure_mur_id: '26', epaisseur_structure: '20' },
-      { tv_umur0_id: '151', enum_materiaux_structure_mur_id: '26', epaisseur_structure: '≥ 45' }
+      { tv_umur0_id: '151', enum_materiaux_structure_mur_id: '26', epaisseur_structure: '≥ 45' },
+      // Béton banché (13) avec valeurs d'Umur0, pour l'interpolation (issue #295)
+      {
+        tv_umur0_id: '80',
+        enum_materiaux_structure_mur_id: '13',
+        epaisseur_structure: '35',
+        umur0: '2.2'
+      },
+      {
+        tv_umur0_id: '79',
+        enum_materiaux_structure_mur_id: '13',
+        epaisseur_structure: '30',
+        umur0: '2.4'
+      },
+      {
+        tv_umur0_id: '81',
+        enum_materiaux_structure_mur_id: '13',
+        epaisseur_structure: '≥ 45',
+        umur0: '1.9'
+      },
+      {
+        tv_umur0_id: '82',
+        enum_materiaux_structure_mur_id: '13',
+        epaisseur_structure: 'non numérique',
+        umur0: '9'
+      }
     ]
   }
 }));
@@ -54,7 +79,12 @@ vi.mock('./utils.js', () => ({
   }
 }));
 
-const { default: calc_mur, epaisseurStructureTable } = await import('./3.2.1_mur.js');
+const {
+  default: calc_mur,
+  epaisseurStructureTable,
+  umur0Interpole,
+  MATERIAUX_PAROI_ANCIENNE
+} = await import('./3.2.1_mur.js');
 const { tv, getThicknessFromDescription } = await import('./utils.js');
 
 /** Table `umur0` figée : U0 forfaitaire de la paroi nue. */
@@ -1006,3 +1036,243 @@ describe('epaisseurStructureTable - épaisseur hors table (issue #138)', () => {
     expect(mur.donnee_entree.epaisseur_structure).toBe(16);
   });
 });
+
+/**
+ * Correctifs de compatibilité (bug_for_bug) sur les murs.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §3.2.1
+ * @see https://github.com/Open3CL/engine/issues/295
+ */
+describe('issue #295 - enduit isolant sur paroi ancienne (MUR1)', () => {
+  /** Umur0 table (mock) = 2 ; Umur0 avec enduit = 1 / (1/2 + 0,7). */
+  const UMUR0_ENDUIT = 0.8333333333333334;
+
+  /**
+   * @param materiau {string}
+   * @param donnee_intermediaire {object}
+   */
+  const murAvecEnduit = (materiau, donnee_intermediaire) => ({
+    donnee_entree: {
+      methode_saisie_u: 'non isolé',
+      methode_saisie_u0:
+        'déterminé selon le matériau et épaisseur à partir de la table de valeur forfaitaire',
+      enum_materiaux_structure_mur_id: materiau,
+      epaisseur_structure: 30,
+      enum_type_doublage_id: '2',
+      enduit_isolant_paroi_ancienne: 1,
+      description: 'mur'
+    },
+    donnee_intermediaire
+  });
+
+  beforeEach(() => {
+    bugForBugCompat = true;
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  test.each([['2'], ['8'], ['9']])(
+    "matériau ancien %s : Umur0 exporté avant enduit mais Umur avec enduit => l'enduit est appliqué",
+    (materiau) => {
+      // Cas 2495E2914184U : umur0 exporté = 2 (avant enduit), umur exporté = Umur0 avec enduit
+      const mur = murAvecEnduit(materiau, { umur0: 2, umur: UMUR0_ENDUIT });
+
+      calc_mur(mur, 'h1a', '1', '0');
+
+      expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_ENDUIT, 9);
+      expect(mur.donnee_intermediaire.umur).toBeCloseTo(UMUR0_ENDUIT, 9);
+    }
+  );
+
+  test("matériau ancien : Umur du DPE sans enduit => l'Umur0 d'origine est conservé", () => {
+    const mur = murAvecEnduit('2', { umur0: 2, umur: 2 });
+
+    calc_mur(mur, 'h1a', '1', '0');
+
+    expect(mur.donnee_intermediaire.umur0).toBe(2);
+  });
+
+  test.each([['1'], ['12'], ['13']])(
+    "matériau %s (paroi non ancienne) : la correspondance de l'Umur avec enduit n'est pas retenue",
+    (materiau) => {
+      const mur = murAvecEnduit(materiau, { umur0: 2, umur: UMUR0_ENDUIT });
+
+      calc_mur(mur, 'h1a', '1', '0');
+
+      expect(mur.donnee_intermediaire.umur0).toBe(2);
+    }
+  );
+
+  test('hors bug_for_bug : l’enduit est toujours appliqué', () => {
+    bugForBugCompat = false;
+    const mur = murAvecEnduit('13', { umur0: 2, umur: 2 });
+
+    calc_mur(mur, 'h1a', '1', '0');
+
+    expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_ENDUIT, 9);
+  });
+
+  test('liste des matériaux de paroi ancienne (pierres, terre, colombage, brique ancienne)', () => {
+    expect(MATERIAUX_PAROI_ANCIENNE).toEqual([2, 3, 4, 5, 6, 7, 8, 9, 21]);
+    // inconnu, blocs de béton creux et béton banché ne sont pas des parois anciennes
+    [1, 12, 13].forEach((materiau) => expect(MATERIAUX_PAROI_ANCIENNE).not.toContain(materiau));
+  });
+});
+
+describe('issue #295 - interpolation de Umur0 entre deux épaisseurs (MUR2)', () => {
+  test.each([
+    { epaisseur: 32, attendu: 2.32, cas: '32 cm entre 30 (2,4) et 35 (2,2)' },
+    { epaisseur: '33', attendu: 2.28, cas: 'épaisseur fournie en chaîne' },
+    { epaisseur: 40, attendu: 2.05, cas: '40 cm entre 35 (2,2) et « ≥ 45 » (1,9)' }
+  ])('umur0Interpole : $cas', ({ epaisseur, attendu }) => {
+    expect(umur0Interpole('13', epaisseur)).toBeCloseTo(attendu, 9);
+  });
+
+  test.each([
+    { materiau: '13', epaisseur: 30, cas: 'épaisseur égale à une colonne' },
+    { materiau: '13', epaisseur: 25, cas: 'sous la première colonne' },
+    { materiau: '13', epaisseur: 50, cas: 'au-delà de la dernière colonne' },
+    { materiau: '13', epaisseur: 'abc', cas: 'épaisseur non numérique' },
+    { materiau: '13', epaisseur: undefined, cas: 'épaisseur absente' },
+    { materiau: '99', epaisseur: 32, cas: 'matériau absent de la table' }
+  ])('umur0Interpole : pas d’interpolation ($cas)', ({ materiau, epaisseur }) => {
+    expect(umur0Interpole(materiau, epaisseur)).toBeUndefined();
+  });
+
+  /**
+   * @param epaisseur {number}
+   * @param donnee_intermediaire {object|undefined}
+   */
+  const murBetonBanche = (epaisseur, donnee_intermediaire) => ({
+    donnee_entree: {
+      methode_saisie_u: 'non isolé',
+      methode_saisie_u0:
+        'déterminé selon le matériau et épaisseur à partir de la table de valeur forfaitaire',
+      enum_materiaux_structure_mur_id: '13',
+      epaisseur_structure: epaisseur,
+      enum_type_doublage_id: '2',
+      description: 'mur en béton banché'
+    },
+    donnee_intermediaire
+  });
+
+  beforeEach(() => {
+    // La table (mockée) renvoie la colonne 30 cm du béton banché
+    tv.mockImplementation((table) => {
+      if (table === 'umur0') return { umur0: '2.4', tv_umur0_id: '79' };
+      return null;
+    });
+  });
+
+  test("bug_for_bug : Umur0 du DPE égal à l'interpolation => valeur interpolée retenue", () => {
+    bugForBugCompat = true;
+    // Cas 2463E3034751T : Umur0 interpolé entre deux colonnes
+    const mur = murBetonBanche(32, { umur0: 2.318 });
+
+    calc_mur(mur, 'h1a', '1', '0');
+
+    expect(tv).toHaveBeenCalledWith('umur0', {
+      enum_materiaux_structure_mur_id: '13',
+      epaisseur_structure: 30
+    });
+    expect(mur.donnee_intermediaire.umur0).toBeCloseTo(2.32, 9);
+  });
+
+  test.each([
+    { bug: true, avant: { umur0: 2.4 }, cas: 'Umur0 du DPE égal à la colonne de la table' },
+    { bug: true, avant: { umur0: 2.326 }, cas: 'écart à l’interpolation ≥ 0,006' },
+    { bug: true, avant: undefined, cas: 'pas d’Umur0 dans le DPE' },
+    { bug: false, avant: { umur0: 2.32 }, cas: 'hors bug_for_bug' }
+  ])('valeur de la table conservée : $cas', ({ bug, avant }) => {
+    bugForBugCompat = bug;
+
+    const mur = murBetonBanche(32, avant);
+    calc_mur(mur, 'h1a', '1', '0');
+
+    expect(mur.donnee_intermediaire.umur0).toBe(2.4);
+  });
+
+  test('bug_for_bug : interpolation confondue avec la valeur de la table => table conservée', () => {
+    bugForBugCompat = true;
+    tv.mockImplementation((table) => {
+      if (table === 'umur0') return { umur0: '2.3205', tv_umur0_id: '79' };
+      return null;
+    });
+
+    const mur = murBetonBanche(32, { umur0: 2.32 });
+    calc_mur(mur, 'h1a', '1', '0');
+
+    expect(mur.donnee_intermediaire.umur0).toBe(2.3205);
+  });
+
+  test('bug_for_bug : épaisseur égale à une colonne => table conservée', () => {
+    bugForBugCompat = true;
+
+    const mur = murBetonBanche(30, { umur0: 2.4 });
+    calc_mur(mur, 'h1a', '1', '0');
+
+    expect(mur.donnee_intermediaire.umur0).toBe(2.4);
+  });
+});
+
+describe('issue #295 - doublage et isolation ITE/ITI pour les DPE < 2.4 (MUR3)', () => {
+  /** Umur0 avec doublage type 5 : 1 / (1/2 + 0,21). */
+  const UMUR0_AVEC_DOUBLAGE = 1.4084507042253522;
+
+  /**
+   * @param enum_type_isolation_id {string}
+   * @param donnee_intermediaire {object|undefined}
+   */
+  const murIsoleAvecDoublage = (enum_type_isolation_id, donnee_intermediaire) => ({
+    donnee_entree: {
+      methode_saisie_u: 'epaisseur isolation saisie justifiée par mesure ou observation',
+      methode_saisie_u0:
+        'déterminé selon le matériau et épaisseur à partir de la table de valeur forfaitaire',
+      enum_materiaux_structure_mur_id: '5',
+      epaisseur_structure: 30,
+      epaisseur_isolation: 10,
+      enum_type_doublage_id: '5',
+      enum_type_isolation_id
+    },
+    donnee_intermediaire
+  });
+
+  test.each([['3'], ['4'], ['6'], ['7'], ['8']])(
+    'bug_for_bug, v2.2, isolation %s : Umur0 du DPE = paroi nue => doublage non appliqué',
+    (typeIsolation) => {
+      bugForBugCompat = true;
+      // Cas 2375E0900891Q : Umur0 exporté = min(2,5 ; Umur0 nu)
+      const mur = murIsoleAvecDoublage(typeIsolation, { umur0: 2 });
+
+      calc_mur(mur, 'h1a', '1', '0', 2.2);
+
+      expect(mur.donnee_intermediaire.umur0).toBe(2);
+    }
+  );
+
+  test.each([
+    {
+      bug: true,
+      iso: '3',
+      avant: { umur0: UMUR0_AVEC_DOUBLAGE },
+      cas: 'Umur0 du DPE avec doublage'
+    },
+    { bug: true, iso: '3', avant: undefined, cas: 'pas d’Umur0 dans le DPE' },
+    { bug: true, iso: '2', avant: { umur0: 2 }, cas: 'mur sans isolation ITE/ITI' },
+    { bug: false, iso: '3', avant: { umur0: 2 }, cas: 'hors bug_for_bug' }
+  ])('v2.2 : doublage appliqué ($cas)', ({ bug, iso, avant }) => {
+    bugForBugCompat = bug;
+
+    const mur = murIsoleAvecDoublage(iso, avant);
+    calc_mur(mur, 'h1a', '1', '0', 2.2);
+
+    expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_AVEC_DOUBLAGE, 9);
+  });
+
+  test("bug_for_bug, v2.4 : comportement inchangé (doublage non cumulé à l'ITI)", () => {
+    bugForBugCompat = true;
+
+    const mur = murIsoleAvecDoublage('3', { umur0: UMUR0_AVEC_DOUBLAGE });
+    calc_mur(mur, 'h1a', '1', '0', 2.4);
+
+    expect(mur.donnee_intermediaire.umur0).toBe(2);
+  });
+});

package/README.md

@@ -375,57 +375,57 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <!-- CORPUS:START -->
 
-> **Version `1.8.64`** · branche `main` · généré le 2026-10-15
+> **Version `1.8.66`** · branche `main` · généré le 2026-10-16
 > Seuil de tolérance **5%**
 
 <table>
 <tr>
 <td align="center"><strong>9</strong><br/><sub>corpus</sub></td>
-<td align="center"><strong>89 418</strong><br/><sub>DPE analysés</sub></td>
-<td align="center"><strong>71 309</strong><br/><sub>DPE conformes</sub></td>
-<td align="center"><strong>79,75 %</strong><br/><sub>réussite globale</sub></td>
+<td align="center"><strong>88 332</strong><br/><sub>DPE analysés</sub></td>
+<td align="center"><strong>71 434</strong><br/><sub>DPE conformes</sub></td>
+<td align="center"><strong>80,87 %</strong><br/><sub>réussite globale</sub></td>
 </tr>
 </table>
 
-|     | Corpus                                                                                                                  |    Réussite |                        |  DPE conformes |
-| :-: | :---------------------------------------------------------------------------------------------------------------------- | ----------: | :--------------------- | -------------: |
-| 🔴  | **Généraliste**<br/><sub>`corpus_dpe.csv`</sub>                                                                         | **47,91 %** | `██████████░░░░░░░░░░` |  4 791 / 9 999 |
-| 🟢  | **Appartement · chauffage individuel (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_individuel_2025.csv`</sub> | **94,37 %** | `███████████████████░` | 9 437 / 10 000 |
-| 🟢  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **93,84 %** | `███████████████████░` | 9 384 / 10 000 |
-| 🟢  | **Logement individuel (2025)**<br/><sub>`dpe_logement_individuel_2025.csv`</sub>                                        | **91,80 %** | `██████████████████░░` |  9 173 / 9 992 |
-| 🟢  | **Maison individuelle (2025)**<br/><sub>`dpe_maison_individuelle_2025.csv`</sub>                                        | **89,93 %** | `██████████████████░░` |  8 992 / 9 999 |
-| 🟢  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **88,39 %** | `██████████████████░░` |  8 675 / 9 814 |
-| 🟢  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **85,35 %** | `█████████████████░░░` |  8 533 / 9 998 |
-| 🟡  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **69,57 %** | `██████████████░░░░░░` |  6 690 / 9 616 |
-| 🔴  | **Individuel généré depuis l'immeuble (2026)**<br/><sub>`dpe_individuel_a_partir_dpe_immeuble_2026.csv`</sub>           | **56,34 %** | `███████████░░░░░░░░░` | 5 634 / 10 000 |
+|     | Corpus                                                                                                                  |    Réussite |                        | DPE conformes |
+| :-: | :---------------------------------------------------------------------------------------------------------------------- | ----------: | :--------------------- | ------------: |
+| 🔴  | **Généraliste**<br/><sub>`corpus_dpe.csv`</sub>                                                                         | **49,26 %** | `██████████░░░░░░░░░░` | 4 856 / 9 857 |
+| 🟢  | **Appartement · chauffage individuel (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_individuel_2025.csv`</sub> | **95,39 %** | `███████████████████░` | 9 437 / 9 893 |
+| 🟢  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **94,54 %** | `███████████████████░` | 9 384 / 9 926 |
+| 🟢  | **Logement individuel (2025)**<br/><sub>`dpe_logement_individuel_2025.csv`</sub>                                        | **93,29 %** | `███████████████████░` | 9 173 / 9 833 |
+| 🟢  | **Maison individuelle (2025)**<br/><sub>`dpe_maison_individuelle_2025.csv`</sub>                                        | **92,03 %** | `██████████████████░░` | 8 992 / 9 771 |
+| 🟢  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **89,10 %** | `██████████████████░░` | 8 677 / 9 739 |
+| 🟢  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **86,00 %** | `█████████████████░░░` | 8 535 / 9 924 |
+| 🟡  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **70,48 %** | `██████████████░░░░░░` | 6 746 / 9 571 |
+| 🔴  | **Individuel généré depuis l'immeuble (2026)**<br/><sub>`dpe_individuel_a_partir_dpe_immeuble_2026.csv`</sub>           | **57,38 %** | `███████████░░░░░░░░░` | 5 634 / 9 818 |
 
 <sub>🟢 ≥ 85 % · 🟡 ≥ 60 % · 🔴 < 60 %</sub>
 
 #### Temps d’exécution
 
-> Durée de l’appel à `calcul_3cl` par DPE, sur 89 383 calculs.
+> Durée de l’appel à `calcul_3cl` par DPE, sur 88 298 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>6,03 ms</strong><br/><sub>moyenne</sub></td>
-<td align="center"><strong>5,41 ms</strong><br/><sub>médiane</sub></td>
-<td align="center"><strong>0,19 ms</strong><br/><sub>min</sub></td>
-<td align="center"><strong>763,7 ms</strong><br/><sub>max</sub></td>
+<td align="center"><strong>5,90 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>5,27 ms</strong><br/><sub>médiane</sub></td>
+<td align="center"><strong>0,11 ms</strong><br/><sub>min</sub></td>
+<td align="center"><strong>874,0 ms</strong><br/><sub>max</sub></td>
 </tr>
 </table>
 
 | Corpus                                         | Moyenne | Médiane |     Min |      Max |     p95 |     p99 |
 | :--------------------------------------------- | ------: | ------: | ------: | -------: | ------: | ------: |
-| **Généraliste**                                | 5,69 ms | 5,26 ms | 0,31 ms |  43,3 ms | 9,94 ms | 14,5 ms |
-| **Appartement · chauffage individuel (2025)**  | 4,38 ms | 4,08 ms | 1,56 ms |  34,5 ms | 7,30 ms | 9,34 ms |
-| **Appartement · chauffage collectif (2025)**   | 5,28 ms | 5,15 ms | 1,71 ms |  45,6 ms | 8,16 ms | 10,4 ms |
-| **Logement individuel (2025)**                 | 5,57 ms | 5,06 ms | 1,69 ms |  39,2 ms | 10,1 ms | 13,6 ms |
-| **Maison individuelle (2025)**                 | 6,58 ms | 5,99 ms | 1,96 ms |  45,7 ms | 11,6 ms | 15,3 ms |
-| **Immeuble · chauffage collectif**             | 6,51 ms | 5,85 ms | 0,23 ms | 163,5 ms | 11,7 ms | 19,1 ms |
-| **Immeuble · chauffage individuel**            | 7,69 ms | 6,64 ms | 0,19 ms | 121,8 ms | 15,4 ms | 24,7 ms |
-| **Immeuble · chauffage mixte**                 | 5,92 ms | 4,86 ms | 0,19 ms | 763,7 ms | 12,1 ms | 20,2 ms |
-| **Individuel généré depuis l'immeuble (2026)** | 6,65 ms | 5,78 ms | 1,75 ms |  60,9 ms | 12,6 ms | 20,5 ms |
+| **Généraliste**                                | 4,71 ms | 4,25 ms | 0,21 ms |  35,5 ms | 8,47 ms | 11,9 ms |
+| **Appartement · chauffage individuel (2025)**  | 4,35 ms | 4,04 ms | 1,48 ms |  41,0 ms | 7,22 ms | 9,56 ms |
+| **Appartement · chauffage collectif (2025)**   | 4,56 ms | 4,20 ms | 1,42 ms |  38,5 ms | 7,37 ms | 9,29 ms |
+| **Logement individuel (2025)**                 | 6,03 ms | 5,55 ms | 1,79 ms |  39,2 ms | 10,8 ms | 14,1 ms |
+| **Maison individuelle (2025)**                 | 7,11 ms | 6,66 ms | 2,05 ms |  40,4 ms | 12,1 ms | 16,0 ms |
+| **Immeuble · chauffage collectif**             | 6,10 ms | 5,34 ms | 0,22 ms | 102,6 ms | 11,1 ms | 19,0 ms |
+| **Immeuble · chauffage individuel**            | 7,30 ms | 6,25 ms | 0,11 ms | 146,4 ms | 14,7 ms | 23,0 ms |
+| **Immeuble · chauffage mixte**                 | 6,13 ms | 5,11 ms | 0,18 ms | 874,0 ms | 12,7 ms | 20,3 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 6,82 ms | 6,06 ms | 1,88 ms |  56,5 ms | 12,8 ms | 19,6 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/conso.js

@@ -983,6 +983,16 @@ function getChauffageConso(gen_ch, field, coef, prorataChauffage, prefix, facteu
   }, 0);
 }
 
+/**
+ * Part du logement dans la consommation de froid d'une installation (1 par défaut), positionnée par
+ * calc_clim pour les DPE appartement générés à partir de l'immeuble (issue #303).
+ * @param fr {object} climatisation
+ * @return {number}
+ */
+export function prorataFroidLogement(fr) {
+  return fr.donnee_utilisateur?.prorata_logement ?? 1;
+}
+
 function calc_conso_pond(
   Sh,
   zc_id,
@@ -1086,13 +1096,15 @@ function calc_conso_pond(
   ret.fr = fr_list.reduce((acc, fr) => {
     const typeEnergie = getTypeEnergie(fr.donnee_entree, 'fr');
     const conso =
-      fr.donnee_intermediaire.conso_fr * (typeEnergie === 'électricité fr' ? fAc('fr') : 1);
+      fr.donnee_intermediaire.conso_fr *
+      prorataFroidLogement(fr) *
+      (typeEnergie === 'électricité fr' ? fAc('fr') : 1);
 
     return acc + getConso(coef, typeEnergie, conso);
   }, 0);
 
   ret.fr_depensier = fr_list.reduce((acc, fr) => {
-    const conso = fr.donnee_intermediaire.conso_fr_depensier;
+    const conso = fr.donnee_intermediaire.conso_fr_depensier * prorataFroidLogement(fr);
     const typeEnergie = getTypeEnergie(fr.donnee_entree, 'fr');
 
     return acc + getConso(coef, typeEnergie, conso);

package/conso.spec.js

@@ -71,7 +71,8 @@ const {
   ARRETES_RESEAU_CHALEUR,
   COEF_GES_AUTRES_RESEAUX_CHALEUR,
   indexArreteReseauChaleur,
-  getContenuCo2ReseauChaleur
+  getContenuCo2ReseauChaleur,
+  prorataFroidLogement
 } = await import('./conso.js');
 const { tv } = await import('./utils.js');
 
@@ -298,6 +299,49 @@ describe('calc_conso - agrégation des consommations', () => {
     expect(net.cout.cout_eclairage).toBeCloseTo(brut.cout.cout_eclairage, 9);
   });
 
+  /**
+   * DPE appartement généré à partir de l'immeuble : conso de froid ramenée au logement par le
+   * prorata mémorisé dans donnee_utilisateur.prorata_logement.
+   * @see https://github.com/Open3CL/engine/issues/303
+   */
+  test('froid : conso et conso dépensière proratisées au logement', () => {
+    const fr = (du) => [
+      {
+        donnee_entree: { enum_type_energie_id: '1' },
+        donnee_intermediaire: { conso_fr: 400, conso_fr_depensier: 1000 },
+        donnee_utilisateur: du
+      }
+    ];
+    const plein = calc_conso(100, 1, 1, [], [], [], fr(undefined), 1, 1, DATE_DPE, coef_ep);
+    const lot = calc_conso(
+      100,
+      1,
+      1,
+      [],
+      [],
+      [],
+      fr({ prorata_logement: 0.25 }),
+      1,
+      1,
+      DATE_DPE,
+      coef_ep
+    );
+
+    expect(plein.ef_conso.conso_fr).toBeCloseTo(400, 9);
+    expect(lot.ef_conso.conso_fr).toBeCloseTo(100, 9);
+    expect(lot.ef_conso.conso_fr_depensier).toBeCloseTo(250, 9);
+    expect(lot.emission_ges.emission_ges_fr).toBeCloseTo(
+      plein.emission_ges.emission_ges_fr * 0.25,
+      9
+    );
+  });
+
+  test('prorataFroidLogement : valeur mémorisée, 1 par défaut', () => {
+    expect(prorataFroidLogement({ donnee_utilisateur: { prorata_logement: 0.3 } })).toBe(0.3);
+    expect(prorataFroidLogement({ donnee_utilisateur: {} })).toBe(1);
+    expect(prorataFroidLogement({})).toBe(1);
+  });
+
   test('autoconsommation PV : froid électrique minoré, froid non électrique non minoré', () => {
     const frElec = [
       {

package/engine.js

@@ -35,7 +35,7 @@ import DpeSanitizerService from './dpe-sanitizer.service.js';
 import { reconstituerRdimDpeGenereImmeuble } from './17.2_rdim_dpe_genere_immeuble.js';
 import { reconstituerRdimEcsIndividuelleUnique } from './11_rdim_ecs_individuelle_unique.js';
 
-const LIB_VERSION = '1.8.65';
+const LIB_VERSION = '1.8.67';
 
 const dpeSanitizerService = new DpeSanitizerService();
 
@@ -330,7 +330,18 @@ export function calcul_3cl(inputDpe, options) {
 
   const bfr = apport_et_besoin.besoin_fr;
   const bfr_dep = apport_et_besoin.besoin_fr_depensier;
-  clim.forEach((clim) => calc_clim(clim, bfr, bfr_dep, zc_id, ShChauffageAndEcs));
+  /**
+   * DPE appartement généré à partir de l'immeuble : besoin et conso de froid calculés à l'échelle de
+   * l'installation (immeuble), puis ramenés au logement au prorata Sh_logement / SH_immeuble, comme le
+   * chauffage et l'ECS (Tribu `Calcul_installation_froid.cs` l.62-64, `Calcul_batiment.cs`
+   * l.1114-1138).
+   * @see https://github.com/Open3CL/engine/issues/303
+   */
+  const prorataFroid =
+    dpeGenereImmeuble && Number(ShChauffageAndEcs) > Number(Sh) && Number(Sh) > 0
+      ? Number(Sh) / Number(ShChauffageAndEcs)
+      : 1;
+  clim.forEach((clim) => calc_clim(clim, bfr, bfr_dep, zc_id, ShChauffageAndEcs, prorataFroid));
 
   /**
    * La consommation ECS est obtenu pour certains types de DPE par virtualisation des générateurs collectifs en générateurs individuels virtuels

package/engine.spec.js

@@ -776,6 +776,38 @@ describe('calcul_3cl - surfaces immeuble / appartement et prorata', () => {
     // Auxiliaires ECS : Sh = surface logement, ramenée à l'immeuble dans le calcul.
     expect(conso_aux_distribution_ecs.mock.calls[0][3]).toBe(80);
     expect(conso_aux_distribution_ecs.mock.calls[0][4]).toBe(200);
+    // Froid : pas un DPE généré depuis l'immeuble, conso de froid non proratisée (#303).
+    expect(calc_clim.mock.calls[0][4]).toBe(200);
+    expect(calc_clim.mock.calls[0][5]).toBe(1);
+  });
+
+  /**
+   * @see https://github.com/Open3CL/engine/issues/303
+   */
+  test.each(['10', '11', '12', '13', '33', '34', '38', '39', '40'])(
+    "DPE appartement généré à partir de l'immeuble (map %s) : conso de froid proratisée Sh / SH",
+    (mapId) => {
+      enums.methode_application_dpe_log = { [mapId]: 'dpe appartement généré immeuble' };
+      const dpe = makeDpe();
+      dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id = mapId;
+
+      calcul_3cl(dpe, { sanitize: false });
+
+      // Besoin calculé sur SH immeuble (200), part du logement = 80 / 200.
+      expect(calc_clim.mock.calls[0][4]).toBe(200);
+      expect(calc_clim.mock.calls[0][5]).toBeCloseTo(0.4, 9);
+    }
+  );
+
+  test("DPE généré depuis l'immeuble avec SH immeuble ≤ Sh logement : prorata de froid neutre", () => {
+    enums.methode_application_dpe_log = { 10: 'dpe appartement généré immeuble' };
+    const dpe = makeDpe();
+    dpe.logement.caracteristique_generale.enum_methode_application_dpe_log_id = '10';
+    dpe.logement.caracteristique_generale.surface_habitable_immeuble = 80;
+
+    calcul_3cl(dpe, { sanitize: false });
+
+    expect(calc_clim.mock.calls[0][5]).toBe(1);
   });
 
   test('appartement : rapport SH immeuble / SH logement transmis au calcul du coût', () => {

package/package.json

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