@open3cl/engine 1.8.49 → 1.8.51

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);
@@ -144,6 +149,95 @@ export function pnEstimee(GV, tbase, 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
@@ -163,6 +257,8 @@ export function pnEstimee(GV, tbase, ratioSurface = 1) {
  * @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,
@@ -172,7 +268,8 @@ export function tv_generateur_combustion(
   GV,
   tbase,
   methodeSaisie,
-  ratioSurface = 1
+  ratioSurface = 1,
+  optionsPn = {}
 ) {
   const typeGenerateurKey = `enum_type_generateur_${type}_id`;
   let enumTypeGenerateurId = de[typeGenerateurKey];
@@ -240,7 +337,7 @@ export function tv_generateur_combustion(
   } else {
     // Calcul de la puissance nominale si non définie
     if (!di.pn) {
-      di.pn = pnEstimee(GV, tbase, ratioSurface);
+      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,
@@ -69,8 +77,13 @@ const {
   caracteristiquesGenerateurCombustion,
   puissanceFormuleQp0,
   PN_MAX_QP0_CHAUDIERE_GAZ,
-  pnEstimee
+  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');
@@ -1479,3 +1492,185 @@ describe('pnEstimee - puissance nominale estimée (issue #264)', () => {
     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;
+}