@open3cl/engine 1.8.48 → 1.8.50

package/13.2_generateur_combustion.js

@@ -9,6 +9,11 @@ import { updateGenerateurPacs } from './13.2_generateur_pac.js';
 import getFicheTechnique from './ficheTechnique.js';
 import { evaluateFormula as evaluateTvFormula } from './formula.js';
 import { conventionPuissanceNominale } from './13.2_generateur_combustion_pn.js';
+import {
+  anneeInstallationGenerateur,
+  pnEstimeeDimensionnement,
+  valeurChaudiereMurale
+} from './13.2_generateur_combustion_pdim.js';
 
 function criterePn(Pn, matcher) {
   let critere_list = tvColumnLines('generateur_combustion', 'critere_pn', matcher);
@@ -122,6 +127,117 @@ export function caracteristiquesGenerateurCombustion(row, pn, ratio, E, F, type,
   return caracteristiques;
 }
 
+/**
+ * Estimation de la puissance nominale (W) d'un générateur à combustion dont la puissance n'est pas connue :
+ * Pch = Sh1 / Shtot × 1,2 × GV × (19 − Tbase) / 0,95³
+ *
+ * Si le générateur n'alimente qu'une partie du logement, la puissance est proratisée à la surface desservie.
+ * Le ratio est borné à ]0 ; 1] : une surface absente, nulle ou supérieure à Sh ne modifie pas Pch.
+ *
+ * Remarque : la méthode ne prévoit cette estimation que pour les générateurs individuels. Pour un générateur
+ * collectif sans pn, la même formule (GV du logement, convention pn = Pe) est une extrapolation.
+ *
+ * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.2.4 Calcul des puissances nominales (p.90-91)
+ *
+ * @param GV {number} déperditions enveloppe + renouvellement d'air (W/K)
+ * @param tbase {number} température extérieure de base (°C)
+ * @param ratioSurface {number} Sh_installation / Sh
+ * @returns {number}
+ */
+export function pnEstimee(GV, tbase, ratioSurface = 1) {
+  const prorata = ratioSurface > 0 && ratioSurface < 1 ? ratioSurface : 1;
+  return (prorata * 1.2 * GV * (19 - tbase)) / 0.95 ** 3;
+}
+
+/**
+ * Pose murale d'une chaudière, lue dans la sous-fiche technique « Chaudière murale » (catégorie 7
+ * pour le chauffage, 8 pour l'ECS) du générateur.
+ *
+ * @param dpe {FullDpe}
+ * @param de {Donnee_entree}
+ * @param type {'ch' | 'ecs'}
+ * @returns {boolean|undefined} undefined si non renseigné
+ */
+export function chaudiereMurale(dpe, de, type) {
+  const fiche = getFicheTechnique(dpe, type === 'ch' ? '7' : '8', 'Chaudière murale', [
+    de.description
+  ]);
+  return valeurChaudiereMurale(fiche?.valeur);
+}
+
+/**
+ * Volume de stockage (L) de la production d'ECS assurée par un générateur de chauffage mixte :
+ * générateur ECS mixte de même `reference_generateur_mixte`, sinon générateur ECS mixte unique.
+ *
+ * @param dpe {FullDpe}
+ * @param de {Donnee_entree} données du générateur de chauffage
+ * @returns {number|undefined}
+ */
+export function volumeStockageEcsMixte(dpe, de) {
+  const liste = (x) => (x === undefined || x === null ? [] : Array.isArray(x) ? x : [x]);
+  const generateursEcsMixtes = liste(dpe?.logement?.installation_ecs_collection?.installation_ecs)
+    .flatMap((installation) => liste(installation.generateur_ecs_collection?.generateur_ecs))
+    .filter((generateur) => String(generateur?.donnee_entree?.enum_usage_generateur_id) === '3');
+
+  const reference = de.reference_generateur_mixte;
+  const jumeau =
+    (reference !== undefined &&
+      reference !== null &&
+      generateursEcsMixtes.find(
+        (generateur) =>
+          String(generateur.donnee_entree.reference_generateur_mixte) === String(reference)
+      )) ||
+    (generateursEcsMixtes.length === 1 ? generateursEcsMixtes[0] : undefined);
+
+  return jumeau?.donnee_entree.volume_stockage;
+}
+
+/**
+ * Puissance nominale estimée (W) d'un générateur à combustion dont `pn` est absente.
+ *
+ * Méthode 3CL-DPE 2021 §13.2.2.4 : Pdim = max(Pch ; Pecs), puis table Pdim → Pn pour les chaudières
+ * (cf. 13.2_generateur_combustion_pdim.js). La méthode ne vise que les générateurs individuels :
+ * pour une installation collective, Pch est conservée (comportement historique).
+ *
+ * @param dpe {FullDpe}
+ * @param de {Donnee_entree} données du générateur
+ * @param type {'ch' | 'ecs'}
+ * @param pch {number} Pch (W) proratisée à la surface desservie
+ * @param optionsPn {{installationIndividuelle?: boolean, volumeStockage?: number}}
+ * @returns {number} Pn (W)
+ */
+export function pnEstimeeGenerateur(dpe, de, type, pch, optionsPn = {}) {
+  const installationIndividuelle =
+    optionsPn.installationIndividuelle ?? String(de.enum_type_installation_id) === '1';
+  if (!installationIndividuelle) {
+    return pch;
+  }
+
+  const usage = String(de.enum_usage_generateur_id);
+  const usageEcs = type === 'ecs' || usage === '3';
+  const usageChauffage = type === 'ch' || usage === '3';
+  const volumeStockage =
+    optionsPn.volumeStockage ??
+    (type === 'ecs' ? de.volume_stockage : usageEcs ? volumeStockageEcsMixte(dpe, de) : undefined);
+
+  const libelleTypeGenerateur =
+    enums[`type_generateur_${type}`]?.[de[`enum_type_generateur_${type}_id`]];
+
+  return pnEstimeeDimensionnement({
+    pch,
+    volumeStockage,
+    usageEcs,
+    usageChauffage,
+    libelleTypeGenerateur,
+    murale: chaudiereMurale(dpe, de, type),
+    anneeInstallation: anneeInstallationGenerateur(
+      de.annee_installation,
+      dpe?.logement?.caracteristique_generale?.annee_construction,
+      libelleTypeGenerateur
+    )
+  });
+}
+
 /**
  * Si la méthode de saisie n'est pas "Valeur forfaitaire" mais "caractéristiques saisies"
  * Documentation 3CL : "Pour les installations récentes ou recommandées, les caractéristiques réelles des chaudières présentées sur les bases
@@ -139,8 +255,22 @@ export function caracteristiquesGenerateurCombustion(row, pn, ratio, E, F, type,
  * @param GV {number} déperdition de l'enveloppe
  * @param tbase {number} température de fonctionnement du générateur
  * @param methodeSaisie {number} méthode de saisie des caractéristiques du générateur
+ * @param ratioSurface {number} part de la surface du logement desservie par le générateur
+ * (Sh_installation / Sh), utilisée pour proratiser la puissance nominale estimée (§13.2.2.4)
+ * @param optionsPn {{installationIndividuelle?: boolean, volumeStockage?: number}} données de
+ * l'installation pour l'estimation de Pn par Pdim (§13.2.2.4, cf. pnEstimeeGenerateur)
  */
-export function tv_generateur_combustion(dpe, di, de, type, GV, tbase, methodeSaisie) {
+export function tv_generateur_combustion(
+  dpe,
+  di,
+  de,
+  type,
+  GV,
+  tbase,
+  methodeSaisie,
+  ratioSurface = 1,
+  optionsPn = {}
+) {
   const typeGenerateurKey = `enum_type_generateur_${type}_id`;
   let enumTypeGenerateurId = de[typeGenerateurKey];
   let row;
@@ -207,7 +337,7 @@ export function tv_generateur_combustion(dpe, di, de, type, GV, tbase, methodeSa
   } else {
     // Calcul de la puissance nominale si non définie
     if (!di.pn) {
-      di.pn = (1.2 * GV * (19 - tbase)) / 0.95 ** 3;
+      di.pn = pnEstimeeGenerateur(dpe, de, type, pnEstimee(GV, tbase, ratioSurface), optionsPn);
     }
 
     selectionLigne = (pn, ratio) => {

package/13.2_generateur_combustion.spec.js

@@ -59,6 +59,14 @@ vi.mock('./ficheTechnique.js', () => ({
 vi.mock('./13.2_generateur_combustion_pn.js', () => ({
   conventionPuissanceNominale: vi.fn((pn, ratio) => ({ pn, ratio, convention: 'individualisee' }))
 }));
+/**
+ * Estimation Pdim → Pn (issue #271) : testée dans son propre spec. Par défaut, le double renvoie Pch.
+ */
+vi.mock('./13.2_generateur_combustion_pdim.js', () => ({
+  pnEstimeeDimensionnement: vi.fn(({ pch }) => pch),
+  anneeInstallationGenerateur: vi.fn(() => 2018),
+  valeurChaudiereMurale: vi.fn((v) => (v === 'oui' ? true : v === 'non' ? false : undefined))
+}));
 
 const {
   tv_generateur_combustion,
@@ -68,8 +76,14 @@ const {
   valeurVeilleuse,
   caracteristiquesGenerateurCombustion,
   puissanceFormuleQp0,
-  PN_MAX_QP0_CHAUDIERE_GAZ
+  PN_MAX_QP0_CHAUDIERE_GAZ,
+  pnEstimee,
+  pnEstimeeGenerateur,
+  chaudiereMurale,
+  volumeStockageEcsMixte
 } = await import('./13.2_generateur_combustion.js');
+const { pnEstimeeDimensionnement, anneeInstallationGenerateur } =
+  await import('./13.2_generateur_combustion_pdim.js');
 const { tv, tvColumnLines } = await import('./utils.js');
 const { conventionPuissanceNominale } = await import('./13.2_generateur_combustion_pn.js');
 const { updateGenerateurBouilleurs } = await import('./13.2_generateur_combustion_bouilleur.js');
@@ -127,6 +141,22 @@ describe('tv_generateur_combustion - caractéristiques du générateur', () => {
     expect(di.pn).toBe(12345);
   });
 
+  test('puissance nominale absente, générateur desservant 40 % du logement : Pn proratisée (issue #264)', () => {
+    tv.mockReturnValue({ ...ROW_DEFAUT });
+    const di = {};
+    const de = { enum_type_generateur_ch_id: '89', ratio_virtualisation: 1, presence_ventouse: 0 };
+    tv_generateur_combustion({}, di, de, 'ch', 200, -9, 1, 0.4);
+    expect(di.pn).toBeCloseTo(0.4 * 7837.877241580406, 9);
+  });
+
+  test('puissance nominale renseignée : le prorata de surface ne s’applique pas', () => {
+    tv.mockReturnValue({ ...ROW_DEFAUT });
+    const di = { pn: 12345 };
+    const de = { enum_type_generateur_ch_id: '89', ratio_virtualisation: 1, presence_ventouse: 0 };
+    tv_generateur_combustion({}, di, de, 'ch', 200, -9, 1, 0.4);
+    expect(di.pn).toBe(12345);
+  });
+
   test('méthode forfaitaire (1) en chauffage : rpn, rpint, qp0 et pveil renseignés', () => {
     tv.mockReturnValue({ ...ROW_DEFAUT });
     const di = { pn: 20000 };
@@ -1430,3 +1460,217 @@ describe('puissanceFormuleQp0 - plafond de Pn à 400 kW pour les chaudières gaz
     expect(qp0).toBeCloseTo(127.5468019078, 6);
   });
 });
+
+/**
+ * Estimation de la puissance nominale d'un générateur à combustion (pn absente).
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.2.4
+ */
+describe('pnEstimee - puissance nominale estimée (issue #264)', () => {
+  // 1,2 × 200 × (19 − (−9)) / 0,95³ -- valeur de référence de régression
+  const PCH_LOGEMENT = 7837.877241580406;
+
+  test('générateur desservant tout le logement : Pch = 1,2 × GV × (19 − Tbase) / 0,95³', () => {
+    expect(pnEstimee(200, -9)).toBeCloseTo(PCH_LOGEMENT, 9);
+    expect(pnEstimee(200, -9, 1)).toBeCloseTo(PCH_LOGEMENT, 9);
+  });
+
+  test('générateur desservant une partie du logement : Pch1 = Sh1 / Shtot × Pch', () => {
+    expect(pnEstimee(200, -9, 0.25)).toBeCloseTo(0.25 * PCH_LOGEMENT, 9);
+  });
+
+  test('deux générateurs se partageant le logement : Pch1 + Pch2 = Pch', () => {
+    expect(pnEstimee(200, -9, 0.3) + pnEstimee(200, -9, 0.7)).toBeCloseTo(PCH_LOGEMENT, 9);
+  });
+
+  test.each([
+    ['nul', 0],
+    ['négatif', -0.5],
+    ['supérieur à 1', 1.4],
+    ['non numérique', NaN],
+    ['absent', undefined]
+  ])('ratio %s : pas de prorata (Pch du logement)', (_libelle, ratio) => {
+    expect(pnEstimee(200, -9, ratio)).toBeCloseTo(PCH_LOGEMENT, 9);
+  });
+});
+
+/**
+ * Pn estimée par la puissance de dimensionnement (issue #271).
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.2.4
+ */
+describe('pnEstimeeGenerateur - Pdim = max(Pch ; Pecs) et table Pdim → Pn (issue #271)', () => {
+  const dpeAvecEcsMixte = (generateursEcs) => ({
+    logement: {
+      caracteristique_generale: { annee_construction: '1975' },
+      installation_ecs_collection: {
+        installation_ecs: [{ generateur_ecs_collection: { generateur_ecs: generateursEcs } }]
+      }
+    }
+  });
+
+  beforeEach(() => {
+    vi.mocked(pnEstimeeDimensionnement).mockClear();
+    vi.mocked(anneeInstallationGenerateur).mockClear();
+    vi.mocked(getFicheTechnique).mockReset();
+  });
+
+  test('installation collective : Pch conservée, pas de table', () => {
+    const de = { enum_type_installation_id: '2', enum_type_generateur_ch_id: '89' };
+    expect(pnEstimeeGenerateur({}, de, 'ch', 7800)).toBe(7800);
+    expect(pnEstimeeDimensionnement).not.toHaveBeenCalled();
+  });
+
+  test('option installationIndividuelle prioritaire sur la donnée du générateur', () => {
+    const de = { enum_type_installation_id: '1', enum_type_generateur_ecs_id: 'A' };
+    expect(pnEstimeeGenerateur({}, de, 'ecs', 7800, { installationIndividuelle: false })).toBe(
+      7800
+    );
+    expect(pnEstimeeDimensionnement).not.toHaveBeenCalled();
+  });
+
+  test('chaudière de chauffage seul : paramètres transmis (libellé, pose murale, année)', () => {
+    vi.mocked(getFicheTechnique).mockReturnValue({ valeur: 'oui' });
+    const dpe = { logement: { caracteristique_generale: { annee_construction: '1975' } } };
+    const de = {
+      description: 'Chaudière gaz',
+      enum_type_installation_id: '1',
+      enum_usage_generateur_id: '1',
+      enum_type_generateur_ch_id: '89',
+      annee_installation: '2010'
+    };
+    pnEstimeeGenerateur(dpe, de, 'ch', 7800);
+
+    expect(getFicheTechnique).toHaveBeenCalledWith(dpe, '7', 'Chaudière murale', ['Chaudière gaz']);
+    expect(anneeInstallationGenerateur).toHaveBeenCalledWith(
+      '2010',
+      '1975',
+      'chaudière gaz standard 2001-2015'
+    );
+    expect(pnEstimeeDimensionnement).toHaveBeenCalledWith({
+      pch: 7800,
+      volumeStockage: undefined,
+      usageEcs: false,
+      usageChauffage: true,
+      libelleTypeGenerateur: 'chaudière gaz standard 2001-2015',
+      murale: true,
+      anneeInstallation: 2018
+    });
+  });
+
+  test('chaudière mixte : volume de stockage du générateur ECS jumeau (reference_generateur_mixte)', () => {
+    const dpe = dpeAvecEcsMixte([
+      {
+        donnee_entree: {
+          enum_usage_generateur_id: '3',
+          reference_generateur_mixte: 'A',
+          volume_stockage: 0
+        }
+      },
+      {
+        donnee_entree: {
+          enum_usage_generateur_id: '3',
+          reference_generateur_mixte: 'B',
+          volume_stockage: 150
+        }
+      }
+    ]);
+    const de = {
+      enum_type_installation_id: '1',
+      enum_usage_generateur_id: '3',
+      enum_type_generateur_ch_id: '89',
+      reference_generateur_mixte: 'B'
+    };
+    pnEstimeeGenerateur(dpe, de, 'ch', 7800);
+    expect(pnEstimeeDimensionnement).toHaveBeenCalledWith(
+      expect.objectContaining({ volumeStockage: 150, usageEcs: true, usageChauffage: true })
+    );
+  });
+
+  test('générateur ECS : volume de stockage du générateur, usage ECS seul', () => {
+    vi.mocked(getFicheTechnique).mockReturnValue({ valeur: 'non' });
+    const de = {
+      description: 'Chaudière gaz',
+      enum_usage_generateur_id: '2',
+      enum_type_generateur_ecs_id: 'A',
+      volume_stockage: 10
+    };
+    pnEstimeeGenerateur({}, de, 'ecs', 7800, { installationIndividuelle: true });
+    expect(getFicheTechnique).toHaveBeenCalledWith({}, '8', 'Chaudière murale', ['Chaudière gaz']);
+    expect(pnEstimeeDimensionnement).toHaveBeenCalledWith(
+      expect.objectContaining({
+        volumeStockage: 10,
+        usageEcs: true,
+        usageChauffage: false,
+        libelleTypeGenerateur: 'chaudière gaz',
+        murale: false
+      })
+    );
+  });
+
+  test('volume de stockage transmis en option prioritaire', () => {
+    const de = { enum_type_installation_id: '1', enum_usage_generateur_id: '2' };
+    pnEstimeeGenerateur({}, de, 'ecs', 7800, { volumeStockage: 300 });
+    expect(pnEstimeeDimensionnement).toHaveBeenCalledWith(
+      expect.objectContaining({ volumeStockage: 300 })
+    );
+  });
+
+  test('tv_generateur_combustion : pn absente estimée via pnEstimeeGenerateur', () => {
+    vi.mocked(pnEstimeeDimensionnement).mockReturnValueOnce(24000);
+    vi.mocked(tv).mockReturnValue({ tv_generateur_combustion_id: '1', rpn: '90', rpint: '90' });
+    const di = {};
+    const de = {
+      enum_type_generateur_ch_id: '89',
+      enum_type_installation_id: '1',
+      enum_usage_generateur_id: '1'
+    };
+    tv_generateur_combustion({}, di, de, 'ch', 200, -9, 1);
+    expect(di.pn).toBe(24000);
+  });
+});
+
+describe('volumeStockageEcsMixte - volume de stockage de l’ECS d’un générateur mixte', () => {
+  const ecs = (usage, reference, volume) => ({
+    donnee_entree: {
+      enum_usage_generateur_id: usage,
+      reference_generateur_mixte: reference,
+      volume_stockage: volume
+    }
+  });
+  const dpe = (generateurs) => ({
+    logement: {
+      installation_ecs_collection: {
+        installation_ecs: { generateur_ecs_collection: { generateur_ecs: generateurs } }
+      }
+    }
+  });
+
+  test('jumeau par reference_generateur_mixte', () => {
+    const d = dpe([ecs('3', 'R1', 80), ecs('3', 'R2', 200)]);
+    expect(volumeStockageEcsMixte(d, { reference_generateur_mixte: 'R2' })).toBe(200);
+  });
+
+  test('sans référence : générateur ECS mixte unique', () => {
+    const d = dpe([ecs('2', undefined, 300), ecs('3', undefined, 0)]);
+    expect(volumeStockageEcsMixte(d, {})).toBe(0);
+  });
+
+  test('plusieurs générateurs mixtes sans référence commune : volume inconnu', () => {
+    const d = dpe([ecs('3', 'R1', 80), ecs('3', 'R2', 200)]);
+    expect(volumeStockageEcsMixte(d, { reference_generateur_mixte: 'R3' })).toBeUndefined();
+    expect(volumeStockageEcsMixte(d, {})).toBeUndefined();
+  });
+
+  test('aucune installation ECS', () => {
+    expect(volumeStockageEcsMixte({}, {})).toBeUndefined();
+    expect(
+      volumeStockageEcsMixte(dpe(ecs('3', 'R', 50)), { reference_generateur_mixte: 'R' })
+    ).toBe(50);
+  });
+});
+
+describe('chaudiereMurale - sous-fiche « Chaudière murale »', () => {
+  test('fiche absente : pose inconnue', () => {
+    vi.mocked(getFicheTechnique).mockReturnValue(null);
+    expect(chaudiereMurale({}, { description: 'x' }, 'ch')).toBeUndefined();
+  });
+});

package/13.2_generateur_combustion_pdim.js

@@ -0,0 +1,212 @@
+/**
+ * Estimation de la puissance nominale d'un générateur à combustion individuel lorsque `pn` n'est
+ * pas connue (repli du moteur quand `donnee_intermediaire.pn` est absente).
+ *
+ * Méthode 3CL-DPE 2021, §13.2.2.4 « Calcul des puissances nominales » (p.90-91) :
+ *  1. Pch = Sh1/Shtot × 1,2 × GV × (19 − Tbase) / (1000 × 0,95³)   (cf. `pnEstimee`)
+ *  2. Pecs selon le type de production d'ECS (volume de stockage Vs) ;
+ *  3. Pdim = max(Pch ; Pecs) ;
+ *  4. Pn des chaudières lue dans la table Pdim → Pn (chaudières murales installées avant 2006 ou
+ *     chaudières au sol / chaudières murales installées à partir de 2006).
+ *
+ * Les autres générateurs à combustion (radiateurs gaz, générateurs d'air chaud, poêles,
+ * accumulateurs, chauffe-eau…) conservent Pn = Pdim.
+ *
+ * Le moteur de référence (Tribu) ne fait pas cette estimation (Pn est une donnée d'entrée
+ * obligatoire) : elle relève du logiciel de saisie et sert surtout aux saisies incomplètes et aux
+ * recommandations.
+ *
+ * @see Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.2.4 Calcul des puissances nominales (p.90-91)
+ */
+
+/**
+ * Année à partir de laquelle les chaudières murales relèvent de la seconde colonne de la table
+ * Pdim → Pn.
+ */
+export const ANNEE_CHAUDIERE_MURALE_RECENTE = 2006;
+
+/**
+ * Table Pdim → Pn (kW) des chaudières : [Pdim max (kW), Pn murale < 2006 ou sol, Pn murale ≥ 2006].
+ * Au-delà de 40 kW : Pn = (Partie entière(Pdim / 5) + 1) × 5 pour les deux colonnes.
+ */
+const TABLE_PDIM_PN = [
+  [5, 18, 5],
+  [10, 18, 10],
+  [13, 18, 13],
+  [18, 18, 18],
+  [24, 24, 24],
+  [28, 28, 28],
+  [32, 32, 32],
+  [40, 40, 40]
+];
+
+/**
+ * Puissance de dimensionnement nécessaire pour l'ECS (kW) selon le volume de stockage (L).
+ *
+ * | Type de production | Volume de stockage | Pecs (kW)                  |
+ * |--------------------|--------------------|----------------------------|
+ * | Instantanée        | Vs = 0             | 21                         |
+ * | Semi-instantanée   | 0 < Vs ≤ 20        | 21 − 0,8 × Vs              |
+ * | Semi-accumulation  | 20 < Vs ≤ 150      | 5 − 1,751 × (Vs − 20) / 65 |
+ * | Accumulation       | 150 < Vs           | (7,14 × Vs + 428) / 1000   |
+ *
+ * Formules reprises telles que publiées (p.91).
+ *
+ * @param volumeStockage {number|string|undefined} Vs (L)
+ * @returns {number|undefined} Pecs (kW), undefined si le volume n'est pas renseigné
+ */
+export function puissanceEcs(volumeStockage) {
+  if (volumeStockage === undefined || volumeStockage === null || volumeStockage === '') {
+    return undefined;
+  }
+  const vs = Number(volumeStockage);
+  if (!Number.isFinite(vs) || vs < 0) return undefined;
+
+  if (vs === 0) return 21;
+  if (vs <= 20) return 21 - 0.8 * vs;
+  if (vs <= 150) return 5 - (1.751 * (vs - 20)) / 65;
+  return (7.14 * vs + 428) / 1000;
+}
+
+/**
+ * Pn (kW) d'une chaudière à partir de sa puissance de dimensionnement (table §13.2.2.4).
+ *
+ * @param pdim {number} Pdim (kW)
+ * @param muraleRecente {boolean} true pour une chaudière murale installée à partir de 2006,
+ * false pour une chaudière murale installée avant 2006 ou une chaudière au sol
+ * @returns {number} Pn (kW)
+ */
+export function pnChaudiere(pdim, muraleRecente) {
+  for (const [pdimMax, pnAncienneOuSol, pnMuraleRecente] of TABLE_PDIM_PN) {
+    if (pdim <= pdimMax) {
+      return muraleRecente ? pnMuraleRecente : pnAncienneOuSol;
+    }
+  }
+  return (Math.floor(pdim / 5) + 1) * 5;
+}
+
+/**
+ * Le générateur est-il une chaudière (table Pdim → Pn) ?
+ * Les « chaudière(s) … multi bâtiment modélisée comme un réseau de chaleur » ne sont pas
+ * concernées (générateurs collectifs).
+ *
+ * @param libelleTypeGenerateur {string|undefined} libellé enum_type_generateur_ch / _ecs
+ * @returns {boolean}
+ */
+export function isChaudiere(libelleTypeGenerateur) {
+  const libelle = (libelleTypeGenerateur ?? '').toString().toLowerCase();
+  return libelle.includes('chaudière') && !libelle.includes('réseau de chaleur');
+}
+
+/**
+ * Intervalle [min ; max] des années d'installation possibles d'après le libellé du type de
+ * générateur (« avant 1981 », « 2001-2015 », « après 2015 », « à partir de 2012 »…).
+ *
+ * @param libelleTypeGenerateur {string|undefined}
+ * @returns {{min: number, max: number}}
+ */
+export function periodeInstallationLibelle(libelleTypeGenerateur) {
+  const libelle = (libelleTypeGenerateur ?? '').toString().toLowerCase();
+  let match = libelle.match(/(\d{4})\s*-\s*(\d{4})/);
+  if (match) return { min: Number(match[1]), max: Number(match[2]) };
+
+  match = libelle.match(/avant (\d{4})/);
+  if (match) return { min: -Infinity, max: Number(match[1]) - 1 };
+
+  match = libelle.match(/(?:après|à partir de) (\d{4})/);
+  if (match) {
+    // « après 2015 » succède à « 2001-2015 » : 2015 appartient déjà à la période précédente
+    return { min: Number(match[1]) + (libelle.includes('après') ? 1 : 0), max: Infinity };
+  }
+
+  return { min: -Infinity, max: Infinity };
+}
+
+/**
+ * Année d'installation du générateur : année saisie, sinon année de construction ramenée dans la
+ * période indiquée par le type de générateur (une « chaudière gaz à condensation après 2015 » d'un
+ * bâtiment de 1970 a été installée après 2015).
+ *
+ * @param anneeInstallation {number|string|undefined} année d'installation saisie
+ * @param anneeConstruction {number|string|undefined} année de construction du bâtiment
+ * @param libelleTypeGenerateur {string|undefined}
+ * @returns {number|undefined}
+ */
+export function anneeInstallationGenerateur(
+  anneeInstallation,
+  anneeConstruction,
+  libelleTypeGenerateur
+) {
+  const saisie = parseInt(anneeInstallation, 10);
+  if (Number.isFinite(saisie)) return saisie;
+
+  const { min, max } = periodeInstallationLibelle(libelleTypeGenerateur);
+  const construction = parseInt(anneeConstruction, 10);
+  if (Number.isFinite(construction)) return Math.min(Math.max(construction, min), max);
+
+  // Période entièrement connue d'un seul côté de 2006 : la borne suffit
+  if (Number.isFinite(min) && min >= ANNEE_CHAUDIERE_MURALE_RECENTE) return min;
+  if (Number.isFinite(max) && max < ANNEE_CHAUDIERE_MURALE_RECENTE) return max;
+  return undefined;
+}
+
+/**
+ * Valeur de la sous-fiche technique « Chaudière murale » → true (oui), false (non), undefined.
+ * @param valeur {string|undefined}
+ * @returns {boolean|undefined}
+ */
+export function valeurChaudiereMurale(valeur) {
+  const v = (valeur ?? '').toString().trim().toLowerCase();
+  if (v.startsWith('oui')) return true;
+  if (v.startsWith('non')) return false;
+  return undefined;
+}
+
+/**
+ * Puissance nominale estimée (W) d'un générateur à combustion sans `pn` (§13.2.2.4).
+ *
+ * Choix de colonne de la table Pdim → Pn :
+ *  - chaudière murale (fiche technique « Chaudière murale : oui ») installée à partir de 2006 →
+ *    seconde colonne ;
+ *  - chaudière au sol (« Chaudière murale : non ») ou installée avant 2006 → première colonne ;
+ *  - type de pose inconnu → seconde colonne si installée à partir de 2006 (chaudières récentes
+ *    majoritairement murales), première sinon.
+ *
+ * @param params {{
+ *   pch: number,                      Pch (W), déjà proratisée à la surface desservie
+ *   volumeStockage?: number|string,   Vs (L) de la production d'ECS assurée par le générateur
+ *   usageEcs?: boolean,               le générateur produit de l'ECS (usage ECS ou mixte)
+ *   usageChauffage?: boolean,         le générateur assure le chauffage (défaut true)
+ *   libelleTypeGenerateur?: string,
+ *   murale?: boolean,                 pose murale (undefined si inconnue)
+ *   anneeInstallation?: number        année d'installation (undefined si inconnue)
+ * }}
+ * @returns {number} Pn (W)
+ */
+export function pnEstimeeDimensionnement({
+  pch,
+  volumeStockage,
+  usageEcs = false,
+  usageChauffage = true,
+  libelleTypeGenerateur,
+  murale,
+  anneeInstallation
+}) {
+  const pchKw = usageChauffage ? pch / 1000 : 0;
+  const pecsKw = usageEcs ? puissanceEcs(volumeStockage) : undefined;
+  const pdim = Math.max(pchKw, pecsKw ?? 0);
+
+  // Aucune donnée exploitable pour l'ECS d'un générateur ECS seul : comportement historique (Pch)
+  if (!usageChauffage && pecsKw === undefined) {
+    return pch;
+  }
+
+  if (!isChaudiere(libelleTypeGenerateur)) {
+    return pdim * 1000;
+  }
+
+  const recente =
+    anneeInstallation !== undefined && anneeInstallation >= ANNEE_CHAUDIERE_MURALE_RECENTE;
+  const muraleRecente = recente && murale !== false;
+  return pnChaudiere(pdim, muraleRecente) * 1000;
+}

package/13.2_generateur_combustion_pdim.spec.js

@@ -0,0 +1,259 @@
+import { describe, expect, test } from 'vitest';
+import {
+  ANNEE_CHAUDIERE_MURALE_RECENTE,
+  anneeInstallationGenerateur,
+  isChaudiere,
+  periodeInstallationLibelle,
+  pnChaudiere,
+  pnEstimeeDimensionnement,
+  puissanceEcs,
+  valeurChaudiereMurale
+} from './13.2_generateur_combustion_pdim.js';
+
+/**
+ * Module de calcul pur (aucune dépendance) : pas de mock nécessaire.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.2.4 Calcul des puissances nominales (p.90-91)
+ */
+describe('puissanceEcs - puissance de dimensionnement ECS selon le volume de stockage', () => {
+  test('production instantanée (Vs = 0) : Pecs = 21 kW', () => {
+    expect(puissanceEcs(0)).toBe(21);
+    expect(puissanceEcs('0.000')).toBe(21);
+  });
+
+  test('semi-instantanée (0 < Vs ≤ 20) : Pecs = 21 − 0,8 × Vs', () => {
+    expect(puissanceEcs(10)).toBeCloseTo(13, 9);
+    expect(puissanceEcs(20)).toBeCloseTo(5, 9);
+  });
+
+  test('semi-accumulation (20 < Vs ≤ 150) : Pecs = 5 − 1,751 × (Vs − 20) / 65', () => {
+    expect(puissanceEcs(85)).toBeCloseTo(5 - 1.751, 9);
+    expect(puissanceEcs(150)).toBeCloseTo(5 - (1.751 * 130) / 65, 9);
+  });
+
+  test('accumulation (Vs > 150) : Pecs = (7,14 × Vs + 428) / 1000', () => {
+    expect(puissanceEcs(200)).toBeCloseTo((7.14 * 200 + 428) / 1000, 9);
+  });
+
+  test.each([undefined, null, '', 'abc', -5])('volume %s non exploitable : undefined', (vs) => {
+    expect(puissanceEcs(vs)).toBeUndefined();
+  });
+});
+
+describe('pnChaudiere - table Pdim → Pn des chaudières', () => {
+  test.each([
+    [3, 18, 5],
+    [5, 18, 5],
+    [7, 18, 10],
+    [12, 18, 13],
+    [15, 18, 18],
+    [18, 18, 18],
+    [20, 24, 24],
+    [26, 28, 28],
+    [30, 32, 32],
+    [40, 40, 40]
+  ])('Pdim = %s kW : Pn = %s kW (murale < 2006 ou sol), %s kW (murale ≥ 2006)', (pdim, a, b) => {
+    expect(pnChaudiere(pdim, false)).toBe(a);
+    expect(pnChaudiere(pdim, true)).toBe(b);
+  });
+
+  test('Pdim > 40 kW : Pn = (Partie entière(Pdim / 5) + 1) × 5, quelle que soit la colonne', () => {
+    expect(pnChaudiere(41, false)).toBe(45);
+    expect(pnChaudiere(45, true)).toBe(50);
+    expect(pnChaudiere(57.3, true)).toBe(60);
+  });
+
+  test('Pn ≥ Pdim sur toute la table', () => {
+    for (let pdim = 0.5; pdim < 80; pdim += 0.5) {
+      expect(pnChaudiere(pdim, false)).toBeGreaterThanOrEqual(pdim);
+      expect(pnChaudiere(pdim, true)).toBeGreaterThanOrEqual(pdim);
+    }
+  });
+});
+
+describe('isChaudiere - générateurs concernés par la table Pdim → Pn', () => {
+  test.each([
+    ['chaudière gaz à condensation après 2015', true],
+    ['pompe à chaleur hybride : partie chaudière chaudière gaz à condensation après 2015', true],
+    ['chaudière(s) gaz multi bâtiment modélisée comme un réseau de chaleur', false],
+    ['radiateur à gaz indépendant ou autonome après 2006', false],
+    ['générateur à air chaud à combustion avant 2006', false],
+    ['accumulateur gaz classique après 2000', false],
+    [undefined, false]
+  ])('%s → %s', (libelle, attendu) => {
+    expect(isChaudiere(libelle)).toBe(attendu);
+  });
+});
+
+describe('periodeInstallationLibelle - période d’installation déduite du type de générateur', () => {
+  test.each([
+    ['chaudière gaz standard 2001-2015', 2001, 2015],
+    ['chaudière gaz classique avant 1981', -Infinity, 1980],
+    ['chaudière gaz à condensation après 2015', 2016, Infinity],
+    ['poêle à bois bouilleur bûche installé à partir de 2012', 2012, Infinity],
+    ['chaudière électrique', -Infinity, Infinity],
+    [undefined, -Infinity, Infinity]
+  ])('%s → [%s ; %s]', (libelle, min, max) => {
+    expect(periodeInstallationLibelle(libelle)).toStrictEqual({ min, max });
+  });
+});
+
+describe('anneeInstallationGenerateur - année d’installation retenue', () => {
+  test('année d’installation saisie prioritaire', () => {
+    expect(anneeInstallationGenerateur('2003', 1970, 'chaudière gaz après 2015')).toBe(2003);
+  });
+
+  test('repli : année de construction si elle est compatible avec le type de générateur', () => {
+    expect(anneeInstallationGenerateur(undefined, '2010', 'chaudière gaz standard 2001-2015')).toBe(
+      2010
+    );
+  });
+
+  test('repli : année de construction ramenée dans la période du type de générateur', () => {
+    expect(
+      anneeInstallationGenerateur(undefined, 1970, 'chaudière gaz à condensation après 2015')
+    ).toBe(2016);
+    expect(anneeInstallationGenerateur(undefined, 2020, 'chaudière gaz classique avant 1981')).toBe(
+      1980
+    );
+  });
+
+  test('sans année de construction : borne de la période si elle tranche par rapport à 2006', () => {
+    expect(anneeInstallationGenerateur(undefined, undefined, 'chaudière gaz après 2015')).toBe(
+      2016
+    );
+    expect(anneeInstallationGenerateur(undefined, undefined, 'chaudière gaz avant 1981')).toBe(
+      1980
+    );
+    expect(
+      anneeInstallationGenerateur(undefined, undefined, 'chaudière gaz standard 2001-2015')
+    ).toBeUndefined();
+    expect(
+      anneeInstallationGenerateur(undefined, undefined, 'chaudière électrique')
+    ).toBeUndefined();
+  });
+});
+
+describe('valeurChaudiereMurale - sous-fiche « Chaudière murale »', () => {
+  test.each([
+    ['oui', true],
+    [' Oui ', true],
+    ['non', false],
+    ['NC', undefined],
+    [undefined, undefined]
+  ])('%s → %s', (valeur, attendu) => {
+    expect(valeurChaudiereMurale(valeur)).toBe(attendu);
+  });
+});
+
+describe('pnEstimeeDimensionnement - Pn estimée (W) d’un générateur sans pn', () => {
+  const CHAUDIERE = 'chaudière gaz à condensation après 2015';
+
+  test('chaudière de chauffage seul, murale récente : Pn = table(Pch) seconde colonne', () => {
+    expect(
+      pnEstimeeDimensionnement({
+        pch: 7800,
+        libelleTypeGenerateur: CHAUDIERE,
+        murale: true,
+        anneeInstallation: 2018
+      })
+    ).toBe(10000);
+  });
+
+  test('chaudière au sol : première colonne (plancher 18 kW) même installée après 2006', () => {
+    expect(
+      pnEstimeeDimensionnement({
+        pch: 7800,
+        libelleTypeGenerateur: CHAUDIERE,
+        murale: false,
+        anneeInstallation: 2018
+      })
+    ).toBe(18000);
+  });
+
+  test('chaudière murale installée avant 2006 : première colonne', () => {
+    expect(
+      pnEstimeeDimensionnement({
+        pch: 2300,
+        libelleTypeGenerateur: 'chaudière gaz standard 1991-2000',
+        murale: true,
+        anneeInstallation: ANNEE_CHAUDIERE_MURALE_RECENTE - 1
+      })
+    ).toBe(18000);
+  });
+
+  test('pose inconnue : seconde colonne si installée à partir de 2006, première sinon', () => {
+    const base = { pch: 2300, libelleTypeGenerateur: CHAUDIERE };
+    expect(pnEstimeeDimensionnement({ ...base, anneeInstallation: 2006 })).toBe(5000);
+    expect(pnEstimeeDimensionnement({ ...base, anneeInstallation: 2005 })).toBe(18000);
+    expect(pnEstimeeDimensionnement({ ...base, anneeInstallation: undefined })).toBe(18000);
+  });
+
+  test('chaudière mixte à production instantanée : Pdim = max(Pch ; 21 kW)', () => {
+    expect(
+      pnEstimeeDimensionnement({
+        pch: 7800,
+        volumeStockage: 0,
+        usageEcs: true,
+        libelleTypeGenerateur: CHAUDIERE,
+        murale: true,
+        anneeInstallation: 2018
+      })
+    ).toBe(24000);
+  });
+
+  test('chaudière mixte à accumulation : Pecs faible, Pdim = Pch', () => {
+    expect(
+      pnEstimeeDimensionnement({
+        pch: 12500,
+        volumeStockage: 200,
+        usageEcs: true,
+        libelleTypeGenerateur: CHAUDIERE,
+        murale: true,
+        anneeInstallation: 2018
+      })
+    ).toBe(13000);
+  });
+
+  test('générateur ECS seul : Pdim = Pecs (Pch ignorée)', () => {
+    expect(
+      pnEstimeeDimensionnement({
+        pch: 30000,
+        volumeStockage: 10,
+        usageEcs: true,
+        usageChauffage: false,
+        libelleTypeGenerateur: CHAUDIERE,
+        murale: true,
+        anneeInstallation: 2018
+      })
+    ).toBe(13000);
+  });
+
+  test('générateur ECS seul sans volume de stockage : Pch conservée (comportement historique)', () => {
+    expect(
+      pnEstimeeDimensionnement({
+        pch: 7800,
+        usageEcs: true,
+        usageChauffage: false,
+        libelleTypeGenerateur: CHAUDIERE
+      })
+    ).toBe(7800);
+  });
+
+  test('générateur non-chaudière (radiateur gaz, air chaud…) : Pn = Pdim', () => {
+    expect(
+      pnEstimeeDimensionnement({
+        pch: 7800,
+        libelleTypeGenerateur: 'radiateur à gaz indépendant ou autonome après 2006'
+      })
+    ).toBeCloseTo(7800, 9);
+    expect(
+      pnEstimeeDimensionnement({
+        pch: 3000,
+        volumeStockage: 0,
+        usageEcs: true,
+        usageChauffage: false,
+        libelleTypeGenerateur: 'chauffe-eau gaz à production instantanée après 2015'
+      })
+    ).toBeCloseTo(21000, 9);
+  });
+});

package/14_generateur_ecs.js

@@ -380,7 +380,10 @@ export default function calc_gen_ecs(dpe, gen_ecs, ecs_di, ecs_de, GV, ca_id, zc
     const tbase = Tbase[ca][zc.slice(0, 2)];
 
     const methodeSaisie = parseInt(de.enum_methode_saisie_carac_sys_id);
-    tv_generateur_combustion(dpe, di, de, 'ecs', GV, tbase, methodeSaisie);
+    // §13.2.2.4 : Pn estimée (si absente) à partir de Pecs (volume de stockage) pour les installations individuelles
+    tv_generateur_combustion(dpe, di, de, 'ecs', GV, tbase, methodeSaisie, 1, {
+      installationIndividuelle: String(ecs_de.enum_type_installation_id) === '1'
+    });
 
     if (bug_for_bug_compat) {
       if (di.qp0 < 1) {

package/9_chauffage.js

@@ -80,7 +80,11 @@ export default function calc_chauffage(
 
     if (genChDu.isCombustionGenerator) {
       const methodeSaisie = parseInt(genChDe.enum_methode_saisie_carac_sys_id);
-      tv_generateur_combustion(dpe, genChDi, genChDe, 'ch', GV, tbase, methodeSaisie);
+      // §13.2.2.4 : Pn estimée proratisée à la surface chauffée par l'installation (individuelle uniquement :
+      // un générateur collectif dessert tout le bâtiment, la surface chauffée du logement n'est pas la sienne)
+      const ratioSurface =
+        String(genChDe.enum_type_installation_id) === '1' ? genChDe.surface_chauffee / Sh : 1;
+      tv_generateur_combustion(dpe, genChDi, genChDe, 'ch', GV, tbase, methodeSaisie, ratioSurface);
 
       const type_gen_ch_list = tvColumnIDs('temp_fonc_30', 'type_generateur_ch');
       if (type_gen_ch_list.includes(genChDe.enum_type_generateur_ch_id)) {

package/9_chauffage.spec.js

@@ -336,6 +336,42 @@ describe('calc_chauffage - générateurs à combustion', () => {
     expect(tv_temp_fonc_30_100).toHaveBeenCalled();
   });
 
+  /**
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.2.4 (prorata de Pch à la surface desservie)
+   */
+  test('ratio surface chauffée de l’installation / Sh transmis pour la Pn estimée (issue #264)', () => {
+    const ch = installation(
+      [generateur({ enum_type_generateur_ch_id: '5', enum_methode_saisie_carac_sys_id: '1' })],
+      [emetteur('1')],
+      { surface_chauffee: 40, enum_type_installation_id: '1' }
+    );
+    appel(ch, { Sh: 100, GV: 150 });
+    const args = vi.mocked(tv_generateur_combustion).mock.calls[0];
+    expect(args[3]).toBe('ch');
+    expect(args[4]).toBe(150);
+    expect(args[7]).toBeCloseTo(0.4, 9);
+  });
+
+  test('surface chauffée absente : repli sur Sh, ratio de 1', () => {
+    const ch = installation(
+      [generateur({ enum_type_generateur_ch_id: '5', enum_methode_saisie_carac_sys_id: '1' })],
+      [emetteur('1')],
+      { surface_chauffee: undefined, enum_type_installation_id: '1' }
+    );
+    appel(ch, { Sh: 100 });
+    expect(vi.mocked(tv_generateur_combustion).mock.calls[0][7]).toBe(1);
+  });
+
+  test('installation collective : pas de prorata, le générateur dessert tout le bâtiment', () => {
+    const ch = installation(
+      [generateur({ enum_type_generateur_ch_id: '5', enum_methode_saisie_carac_sys_id: '1' })],
+      [emetteur('1')],
+      { surface_chauffee: 40, enum_type_installation_id: '2' }
+    );
+    appel(ch, { Sh: 100 });
+    expect(vi.mocked(tv_generateur_combustion).mock.calls[0][7]).toBe(1);
+  });
+
   test('méthode 5 avec températures déjà connues : pas de recalcul', () => {
     const ch = installation(
       [

package/README.md

@@ -370,7 +370,7 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <!-- CORPUS:START -->
 
-> **Version `1.8.47`** · branche `main` · généré le 2026-10-11
+> **Version `1.8.49`** · branche `main` · généré le 2026-10-12
 > Seuil de tolérance **5%**
 
 <table>
@@ -403,24 +403,24 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <table>
 <tr>
-<td align="center"><strong>5,29 ms</strong><br/><sub>moyenne</sub></td>
-<td align="center"><strong>4,62 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>817,3 ms</strong><br/><sub>max</sub></td>
+<td align="center"><strong>5,56 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>4,89 ms</strong><br/><sub>médiane</sub></td>
+<td align="center"><strong>0,13 ms</strong><br/><sub>min</sub></td>
+<td align="center"><strong>581,4 ms</strong><br/><sub>max</sub></td>
 </tr>
 </table>
 
 | Corpus                                         | Moyenne | Médiane |     Min |      Max |     p95 |     p99 |
 | :--------------------------------------------- | ------: | ------: | ------: | -------: | ------: | ------: |
-| **Généraliste**                                | 5,04 ms | 4,61 ms | 0,23 ms |  39,5 ms | 9,03 ms | 12,6 ms |
-| **Appartement · chauffage individuel (2025)**  | 4,02 ms | 3,69 ms | 1,36 ms |  32,4 ms | 6,82 ms | 8,63 ms |
-| **Logement individuel (2025)**                 | 5,35 ms | 4,77 ms | 1,73 ms |  44,9 ms | 9,93 ms | 13,3 ms |
-| **Maison individuelle (2025)**                 | 5,82 ms | 5,20 ms | 1,91 ms |  74,9 ms | 10,4 ms | 13,9 ms |
-| **Immeuble · chauffage individuel**            | 6,33 ms | 5,37 ms | 0,11 ms | 115,2 ms | 12,8 ms | 20,1 ms |
-| **Appartement · chauffage collectif (2025)**   | 4,28 ms | 3,80 ms | 1,50 ms |  38,6 ms | 7,24 ms | 9,61 ms |
-| **Immeuble · chauffage collectif**             | 5,52 ms | 4,68 ms | 0,13 ms | 106,4 ms | 10,2 ms | 17,1 ms |
-| **Immeuble · chauffage mixte**                 | 5,32 ms | 4,33 ms | 0,21 ms | 817,3 ms | 10,8 ms | 18,5 ms |
-| **Individuel généré depuis l'immeuble (2026)** | 5,91 ms | 5,10 ms | 1,83 ms |  65,4 ms | 11,3 ms | 17,1 ms |
+| **Généraliste**                                | 4,50 ms | 4,07 ms | 0,21 ms |  36,7 ms | 8,24 ms | 11,2 ms |
+| **Appartement · chauffage individuel (2025)**  | 4,06 ms | 3,74 ms | 1,54 ms |  29,8 ms | 6,88 ms | 8,57 ms |
+| **Logement individuel (2025)**                 | 5,52 ms | 4,95 ms | 1,71 ms |  34,2 ms | 10,1 ms | 13,7 ms |
+| **Maison individuelle (2025)**                 | 6,52 ms | 5,95 ms | 2,14 ms |  49,4 ms | 11,6 ms | 14,7 ms |
+| **Immeuble · chauffage individuel**            | 6,74 ms | 5,70 ms | 0,13 ms | 159,0 ms | 13,9 ms | 21,9 ms |
+| **Appartement · chauffage collectif (2025)**   | 4,52 ms | 4,20 ms | 1,58 ms |  39,5 ms | 7,25 ms | 9,05 ms |
+| **Immeuble · chauffage collectif**             | 5,77 ms | 4,91 ms | 0,13 ms | 131,8 ms | 10,7 ms | 18,8 ms |
+| **Immeuble · chauffage mixte**                 | 5,79 ms | 4,72 ms | 0,21 ms | 581,4 ms | 12,2 ms | 19,9 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 6,62 ms | 5,72 ms | 1,79 ms |  58,3 ms | 12,5 ms | 20,3 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

@@ -33,7 +33,7 @@ import getFicheTechnique from './ficheTechnique.js';
 import { ProductionENR, ratioProrataPvLogement } from './16.2_production_enr.js';
 import DpeSanitizerService from './dpe-sanitizer.service.js';
 
-const LIB_VERSION = '1.8.48';
+const LIB_VERSION = '1.8.50';
 
 const dpeSanitizerService = new DpeSanitizerService();
 

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

@@ -4,6 +4,11 @@ import { excel_to_js_exec } from '../../../../utils.js';
 import { TvStore } from '../../../dpe/infrastructure/tv.store.js';
 import { EmetteurChService } from './emetteur-ch.service.js';
 import { TypeGenerateur } from '../../../dpe/domain/models/type-generateur.model.js';
+import enums from '../../../../enums.js';
+import {
+  anneeInstallationGenerateur,
+  pnEstimeeDimensionnement
+} from '../../../../13.2_generateur_combustion_pdim.js';
 
 /**
  * Calcul des données de calcul pour chacun des générateurs
@@ -73,7 +78,12 @@ export class GenerateurChService {
       if (generateurChauffage.donnee_utilisateur.combustion) {
         // Calcul de la puissance nominale si non définie
         if (!generateurChauffageDI.pn) {
-          generateurChauffage.donnee_intermediaire.pn = this.pn(ctx, logement);
+          generateurChauffage.donnee_intermediaire.pn = this.pn(
+            ctx,
+            logement,
+            installationChauffage,
+            generateurChauffage
+          );
         }
 
         generateurChauffage.donnee_utilisateur.generateur = this.#chTvStore.getGenerateurCombustion(
@@ -201,11 +211,72 @@ export class GenerateurChService {
    *
    * @param ctx {Contexte}
    * @param logement {Logement}
+   * @param installationChauffage {InstallationChauffage}
+   * @param generateurChauffage {GenerateurChauffage}
    * @return {number}
    */
-  pn(ctx, logement) {
+  pn(ctx, logement, installationChauffage, generateurChauffage) {
     const Tbase = this.#tvStore.getTempBase(ctx.altitude.id, ctx.zoneClimatique.id);
-    return (1.2 * logement.sortie.deperdition.deperdition_enveloppe * (19 - Tbase)) / 0.95 ** 3;
+    // §13.2.2.4 : générateur individuel n'alimentant qu'une partie du logement => prorata Sh_installation / Sh.
+    // Un générateur collectif dessert tout le bâtiment : pas de prorata.
+    const installationDE = installationChauffage?.donnee_entree;
+    const ratio =
+      String(installationDE?.enum_type_installation_id) === '1'
+        ? installationDE.surface_chauffee / ctx.surfaceHabitable
+        : 1;
+    const prorata = ratio > 0 && ratio < 1 ? ratio : 1;
+    const pch =
+      (prorata * 1.2 * logement.sortie.deperdition.deperdition_enveloppe * (19 - Tbase)) /
+      0.95 ** 3;
+
+    // §13.2.2.4 : Pdim = max(Pch ; Pecs) puis table Pdim → Pn des chaudières (générateurs individuels)
+    if (String(installationDE?.enum_type_installation_id) !== '1' || !generateurChauffage) {
+      return pch;
+    }
+
+    const generateurDE = generateurChauffage.donnee_entree;
+    const usageMixte = String(generateurDE.enum_usage_generateur_id) === '3';
+    const libelleTypeGenerateur = enums.type_generateur_ch[generateurDE.enum_type_generateur_ch_id];
+
+    return pnEstimeeDimensionnement({
+      pch,
+      volumeStockage: usageMixte ? this.volumeStockageEcsMixte(logement, generateurDE) : undefined,
+      usageEcs: usageMixte,
+      libelleTypeGenerateur,
+      // Fiches techniques non disponibles dans la nouvelle architecture : pose murale inconnue
+      murale: undefined,
+      anneeInstallation: anneeInstallationGenerateur(
+        generateurDE.annee_installation,
+        ctx.anneeConstruction,
+        libelleTypeGenerateur
+      )
+    });
+  }
+
+  /**
+   * Volume de stockage (L) de la production d'ECS assurée par un générateur de chauffage mixte :
+   * générateur ECS mixte de même `reference_generateur_mixte`, sinon générateur ECS mixte unique.
+   *
+   * @param logement {Logement}
+   * @param generateurChauffageDE {GenerateurChauffageDE}
+   * @return {number|undefined}
+   */
+  volumeStockageEcsMixte(logement, generateurChauffageDE) {
+    const generateursEcsMixtes = (logement.installation_ecs_collection?.installation_ecs || [])
+      .flatMap((installation) => installation.generateur_ecs_collection?.generateur_ecs || [])
+      .filter((generateur) => String(generateur.donnee_entree?.enum_usage_generateur_id) === '3');
+
+    const reference = generateurChauffageDE.reference_generateur_mixte;
+    const jumeau =
+      (reference !== undefined &&
+        reference !== null &&
+        generateursEcsMixtes.find(
+          (generateur) =>
+            String(generateur.donnee_entree.reference_generateur_mixte) === String(reference)
+        )) ||
+      (generateursEcsMixtes.length === 1 ? generateursEcsMixtes[0] : undefined);
+
+    return jumeau?.donnee_entree.volume_stockage;
   }
 
   /**

package/features/engine/domain/ch/generateur-ch.service.spec.js

@@ -79,3 +79,153 @@ describe('Températures de fonctionnement des générateurs de chauffage', () =>
     );
   });
 });
+
+/**
+ * Puissance nominale estimée d'un générateur à combustion sans pn.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.2.4
+ */
+describe('Puissance nominale estimée des générateurs de chauffage (issue #264)', () => {
+  /** @type {TvStore} */
+  let tvStore;
+  const ctx = { altitude: { id: 1 }, zoneClimatique: { id: 1 }, surfaceHabitable: 100 };
+  const logement = { sortie: { deperdition: { deperdition_enveloppe: 200 } } };
+  // 1,2 × 200 × (19 − (−9)) / 0,95³ -- valeur de référence de régression
+  const PCH_LOGEMENT = 7837.877241580406;
+
+  beforeEach(() => {
+    tvStore = new TvStore();
+    service = new GenerateurChService(new ChTvStore(), tvStore, new EmetteurChService());
+    vi.spyOn(tvStore, 'getTempBase').mockReturnValue(-9);
+  });
+
+  test('installation desservant tout le logement : Pch sans prorata', () => {
+    const installation = { donnee_entree: { surface_chauffee: 100, enum_type_installation_id: 1 } };
+    expect(service.pn(ctx, logement, installation)).toBeCloseTo(PCH_LOGEMENT, 9);
+    expect(tvStore.getTempBase).toHaveBeenCalledWith(1, 1);
+  });
+
+  test('installation desservant 40 % du logement : Pch proratisée à la surface chauffée', () => {
+    const installation = { donnee_entree: { surface_chauffee: 40, enum_type_installation_id: 1 } };
+    expect(service.pn(ctx, logement, installation)).toBeCloseTo(0.4 * PCH_LOGEMENT, 9);
+  });
+
+  test.each([
+    ['surface chauffée absente', { donnee_entree: { enum_type_installation_id: 1 } }],
+    [
+      'installation collective',
+      { donnee_entree: { surface_chauffee: 40, enum_type_installation_id: 2 } }
+    ],
+    ['installation absente', undefined],
+    [
+      'surface chauffée supérieure à Sh',
+      { donnee_entree: { surface_chauffee: 130, enum_type_installation_id: 1 } }
+    ],
+    [
+      'surface chauffée nulle',
+      { donnee_entree: { surface_chauffee: 0, enum_type_installation_id: 1 } }
+    ]
+  ])('%s : pas de prorata', (_libelle, installation) => {
+    expect(service.pn(ctx, logement, installation)).toBeCloseTo(PCH_LOGEMENT, 9);
+  });
+});
+
+/**
+ * Puissance nominale estimée par la puissance de dimensionnement : Pdim = max(Pch ; Pecs) puis table
+ * Pdim → Pn des chaudières (le calcul de la table est testé dans 13.2_generateur_combustion_pdim.spec.js).
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §13.2.2.4
+ */
+describe('Puissance nominale estimée : Pdim et table Pdim → Pn (issue #271)', () => {
+  /** @type {TvStore} */
+  let tvStore;
+  const ctx = {
+    altitude: { id: 1 },
+    zoneClimatique: { id: 1 },
+    surfaceHabitable: 100,
+    anneeConstruction: 1975
+  };
+  const installation = { donnee_entree: { surface_chauffee: 100, enum_type_installation_id: 1 } };
+  const logementAvecEcs = (generateursEcs) => ({
+    sortie: { deperdition: { deperdition_enveloppe: 200 } },
+    installation_ecs_collection: {
+      installation_ecs: [{ generateur_ecs_collection: { generateur_ecs: generateursEcs } }]
+    }
+  });
+  const generateur = (de) => ({ donnee_entree: de });
+
+  beforeEach(() => {
+    tvStore = new TvStore();
+    service = new GenerateurChService(new ChTvStore(), tvStore, new EmetteurChService());
+    vi.spyOn(tvStore, 'getTempBase').mockReturnValue(-9);
+  });
+
+  test('chaudière de chauffage seul installée après 2015 : Pch = 7,84 kW → Pn = 10 kW', () => {
+    const logement = logementAvecEcs([]);
+    const gen = generateur({ enum_type_generateur_ch_id: '97', enum_usage_generateur_id: 1 });
+    expect(service.pn(ctx, logement, installation, gen)).toBe(10000);
+  });
+
+  test('chaudière 1991-2000 (pose inconnue, avant 2006) : plancher 18 kW', () => {
+    const logement = logementAvecEcs([]);
+    const gen = generateur({ enum_type_generateur_ch_id: '88', enum_usage_generateur_id: 1 });
+    expect(service.pn(ctx, logement, installation, gen)).toBe(18000);
+  });
+
+  test('chaudière mixte instantanée : Pdim = max(Pch ; 21 kW) → Pn = 24 kW', () => {
+    const logement = logementAvecEcs([
+      { donnee_entree: { enum_usage_generateur_id: 2, volume_stockage: 300 } },
+      { donnee_entree: { enum_usage_generateur_id: 3, volume_stockage: 0 } }
+    ]);
+    const gen = generateur({ enum_type_generateur_ch_id: '97', enum_usage_generateur_id: 3 });
+    expect(service.pn(ctx, logement, installation, gen)).toBe(24000);
+  });
+
+  test('radiateur gaz : Pn = Pdim (pas de table)', () => {
+    const logement = logementAvecEcs([]);
+    const gen = generateur({ enum_type_generateur_ch_id: '54', enum_usage_generateur_id: 1 });
+    expect(service.pn(ctx, logement, installation, gen)).toBeCloseTo(7837.877241580406, 9);
+  });
+
+  test('installation collective : Pch conservée', () => {
+    const logement = logementAvecEcs([]);
+    const collective = { donnee_entree: { enum_type_installation_id: 2 } };
+    const gen = generateur({ enum_type_generateur_ch_id: '97', enum_usage_generateur_id: 1 });
+    expect(service.pn(ctx, logement, collective, gen)).toBeCloseTo(7837.877241580406, 9);
+  });
+
+  test('volume de stockage du générateur ECS mixte jumeau (reference_generateur_mixte)', () => {
+    const ecs = (reference, volume) => ({
+      donnee_entree: {
+        enum_usage_generateur_id: '3',
+        reference_generateur_mixte: reference,
+        volume_stockage: volume
+      }
+    });
+    const logement = logementAvecEcs([ecs('A', 0), ecs('B', 200)]);
+    expect(service.volumeStockageEcsMixte(logement, { reference_generateur_mixte: 'B' })).toBe(200);
+    expect(service.volumeStockageEcsMixte(logement, {})).toBeUndefined();
+    expect(service.volumeStockageEcsMixte({}, {})).toBeUndefined();
+    expect(
+      service.volumeStockageEcsMixte(
+        { installation_ecs_collection: { installation_ecs: [{}] } },
+        { reference_generateur_mixte: 'B' }
+      )
+    ).toBeUndefined();
+  });
+
+  test('execute : le générateur est transmis à l’estimation de pn', () => {
+    vi.spyOn(service, 'pn').mockReturnValue(24000);
+    vi.spyOn(service, 'caracteristiques').mockReturnValue({});
+    const gen = {
+      donnee_entree: { enum_type_generateur_ch_id: '97', enum_lien_generateur_emetteur_id: 1 },
+      donnee_intermediaire: {}
+    };
+    const inst = {
+      donnee_entree: { enum_type_installation_id: 1 },
+      generateur_chauffage_collection: { generateur_chauffage: [gen] }
+    };
+    const logement = logementAvecEcs([]);
+    service.execute(ctx, logement, inst);
+    expect(service.pn).toHaveBeenCalledWith(ctx, logement, inst, gen);
+    expect(gen.donnee_intermediaire.pn).toBe(24000);
+  });
+});

package/package.json

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