@open3cl/engine 1.8.7 → 1.8.9

package/engine.js

@@ -33,7 +33,7 @@ import getFicheTechnique from './ficheTechnique.js';
 import { ProductionENR } from './16.2_production_enr.js';
 import DpeSanitizerService from './dpe-sanitizer.service.js';
 
-const LIB_VERSION = '1.8.7';
+const LIB_VERSION = '1.8.9';
 
 const dpeSanitizerService = new DpeSanitizerService();
 
@@ -573,7 +573,8 @@ export function calcul_3cl(inputDpe, options) {
     prorataECS,
     prorataChauffage,
     dateDpe,
-    coef_ep
+    coef_ep,
+    th === 'immeuble' ? Nb_lgt : 1
   );
 
   const production_electricite = productionENR.calculateEnr(
@@ -595,7 +596,8 @@ export function calcul_3cl(inputDpe, options) {
     prorataECS,
     prorataChauffage,
     dateDpe,
-    coef_ep_1_7
+    coef_ep_1_7,
+    th === 'immeuble' ? Nb_lgt : 1
   );
 
   productionENR.calculateEnr(
@@ -618,7 +620,8 @@ export function calcul_3cl(inputDpe, options) {
     prorataECS,
     prorataChauffage,
     dateDpe,
-    coef_ep_2_3
+    coef_ep_2_3,
+    th === 'immeuble' ? Nb_lgt : 1
   );
 
   productionENR.calculateEnr(

package/features/engine/domain/apport_et_besoin/surface-sud-equivalente.service.js

@@ -42,88 +42,154 @@ export class SurfaceSudEquivalenteService {
    */
   ssdMois(ctx, enveloppe, mois) {
     const baiesVitrees = enveloppe.baie_vitree_collection?.baie_vitree || [];
-    let ets = enveloppe.ets_collection?.ets || [];
+    const zc = ctx.zoneClimatique.id;
 
-    let SseVerandaj = 0;
+    /**
+     * Baies vitrées donnant directement sur l'extérieur
+     */
+    const sseBaiesExt = baiesVitrees
+      .filter((bv) => parseInt(bv.donnee_entree.enum_type_adjacence_id) === 1)
+      .reduce((acc, bv) => acc + this.ssdBaieMois(bv, zc, mois), 0);
 
     /**
-     * Si une véranda est présente, on calcul l'mpact de l’espace tampon solarisé sur les apports solaires à travers
-     * les baies vitrées qui séparent le logement de l'espace tampon
-     *
      * 6.3 Traitement des espaces tampons solarisés
      * 10 - 'espace tampon solarisé (véranda,loggia fermée)'
+     *
+     * Plusieurs espaces tampons solarisés (issue #101) : T, bver, Sst et Ssd sont propres à chaque
+     * véranda. Sse = Sse_ext + Σ(v) Sse_veranda_v, chaque baie adjacence 10 n'étant comptée que dans
+     * la véranda sur laquelle elle donne (baie.reference_lnc = ets.reference).
+     * Sse_ver n'est calculée que pour les baies vitrées qui séparent le logement de l'espace tampon :
+     * sans aucune de ces baies, les apports de l'espace tampon n'entrent pas dans le logement.
      */
-    if (ets) {
-      // Certaines vérandas sont dupliqués dans les DPE.
-      if (Array.isArray(ets)) {
-        ets = ets[0];
-      }
-
-      if (ets) {
-        const bver = ets.donnee_intermediaire.bver;
-        const T = ets.donnee_intermediaire.coef_transparence_ets;
-
-        /**
-         * Surface sud équivalente représentant l’impact des apports solaires associés au rayonnement solaire
-         * traversant directement l’espace tampon pour arriver dans la partie habitable du logement
-         * Calculés pour les baies vitrées qui séparent le logement de l'espace tampon
-         * @type {number}
-         */
-        const Ssdj = this.getBaiesSurEspaceTampon(baiesVitrees).reduce((acc, bv) => {
-          return acc + T * this.ssdBaieMois(bv, ctx.zoneClimatique.id, mois);
-        }, 0);
-
-        /**
-         * Surface sud équivalente représentant les apports solaires indirects dans le logement
-         */
-        let baies = ets.baie_ets_collection.baie_ets;
-
-        if (!Array.isArray(baies)) {
-          baies = [baies];
-        }
-
-        /**
-         * Apports totaux à travers l'espace tampon
-         * @type {number}
-         */
-        const Sstj = baies.reduce((acc, bv) => {
-          return acc + this.ssdBaieMois(bv, ctx.zoneClimatique.id, mois, 0.8 * T + 0.024);
-        }, 0);
-
-        /**
-         * Surface sud équivalente représentant l’impact des apports solaires indirects associés au rayonnement
-         * solaire entrant dans la partie habitable du logement après de multiples réflexions dans l’espace tampon solarisé
-         * @type {number}
-         */
-        const Ssindj = Sstj - Ssdj;
-
-        /**
-         * Impact de l’espace tampon solarisé sur les apports solaires à travers les baies vitrées qui séparent le logement
-         * de l'espace tampon
-         * @type {number}
-         */
-        SseVerandaj = Ssdj + Ssindj * bver;
-      }
+    const etsList = this.dedoublonnerEts(this.getEtsList(enveloppe));
+    const baiesParEts = this.rattacherBaiesAuxEts(
+      this.getBaiesSurEspaceTampon(baiesVitrees),
+      etsList
+    );
+
+    return etsList.reduce(
+      (acc, ets, idx) => acc + this.sseVerandaMois(ets, baiesParEts[idx], zc, mois),
+      sseBaiesExt
+    );
+  }
+
+  /**
+   * Surface sud équivalente apportée par une véranda sur un mois donné (§6.3)
+   *
+   * @param ets {Ets}
+   * @param baiesAdjVeranda {BaieVitree[]} baies vitrées séparant le logement de cette véranda
+   * @param zc {string} zone climatique du logement
+   * @param mois {string}
+   * @returns {number}
+   */
+  sseVerandaMois(ets, baiesAdjVeranda, zc, mois) {
+    // Véranda sans baie vitrée vers le logement : aucun apport solaire
+    if (baiesAdjVeranda.length === 0) {
+      return 0;
     }
 
-    return baiesVitrees.reduce((acc, baieVitree) => {
-      const typeAdjacence = parseInt(baieVitree.donnee_entree.enum_type_adjacence_id);
+    const bver = ets.donnee_intermediaire.bver;
+    const T = ets.donnee_intermediaire.coef_transparence_ets;
+
+    /**
+     * Surface sud équivalente représentant l’impact des apports solaires associés au rayonnement solaire
+     * traversant directement l’espace tampon pour arriver dans la partie habitable du logement
+     * Calculés pour les baies vitrées qui séparent le logement de cet espace tampon
+     * @type {number}
+     */
+    const Ssdj = baiesAdjVeranda.reduce((acc, bv) => acc + T * this.ssdBaieMois(bv, zc, mois), 0);
 
-      /**
-       * 6.3 Traitement des espaces tampons solarisés
-       * 10 - 'espace tampon solarisé (véranda,loggia fermée)'
-       */
-      if (typeAdjacence === 10 && ets) {
-        return acc + SseVerandaj;
-      }
+    /**
+     * Baies de l'espace tampon donnant sur l'extérieur (propres à chaque véranda)
+     */
+    let baies = ets.baie_ets_collection?.baie_ets || [];
 
-      // Pour les fenêtres qui ne donnent pas sur l'extérieur, pas de surface sud équivalente
-      if (typeAdjacence !== 1) {
-        return acc;
-      }
+    if (!Array.isArray(baies)) {
+      baies = [baies];
+    }
 
-      return acc + this.ssdBaieMois(baieVitree, ctx.zoneClimatique.id, mois);
+    /**
+     * Apports totaux à travers l'espace tampon
+     * @type {number}
+     */
+    const Sstj = baies.reduce((acc, bv) => {
+      return acc + this.ssdBaieMois(bv, zc, mois, 0.8 * T + 0.024);
     }, 0);
+
+    /**
+     * Surface sud équivalente représentant l’impact des apports solaires indirects associés au rayonnement
+     * solaire entrant dans la partie habitable du logement après de multiples réflexions dans l’espace tampon solarisé
+     * @type {number}
+     */
+    const Ssindj = Sstj - Ssdj;
+
+    /**
+     * Impact de l’espace tampon solarisé sur les apports solaires à travers les baies vitrées qui séparent le logement
+     * de l'espace tampon
+     */
+    return Ssdj + Ssindj * bver;
+  }
+
+  /**
+   * Liste des espaces tampons solarisés du logement (la collection peut contenir un objet unique,
+   * un tableau, ou être absente selon les DPE)
+   *
+   * @param enveloppe {Enveloppe}
+   * @returns {Ets[]}
+   */
+  getEtsList(enveloppe) {
+    const ets = enveloppe.ets_collection?.ets;
+    if (!ets) {
+      return [];
+    }
+    return Array.isArray(ets) ? ets : [ets];
+  }
+
+  /**
+   * Certaines vérandas sont dupliquées dans les DPE : une même véranda (même référence, ou à défaut
+   * même contenu) ne doit être comptée qu'une seule fois.
+   *
+   * @param etsList {Ets[]}
+   * @returns {Ets[]}
+   */
+  dedoublonnerEts(etsList) {
+    const vues = new Set();
+    return etsList.filter((ets) => {
+      if (!ets) return false;
+      const reference = ets.donnee_entree?.reference;
+      const cle = reference ? `ref:${reference}` : `json:${JSON.stringify(ets)}`;
+      if (vues.has(cle)) return false;
+      vues.add(cle);
+      return true;
+    });
+  }
+
+  /**
+   * Rattache chaque baie vitrée adjacence 10 à l'espace tampon sur lequel elle donne
+   * (baie.donnee_entree.reference_lnc = ets.donnee_entree.reference).
+   *
+   * Une baie sans lien exploitable (reference_lnc absente ou ne correspondant à aucune véranda) est
+   * rattachée à la première véranda : c'est le comportement historique, et le seul possible quand le
+   * DPE ne comporte qu'une véranda.
+   *
+   * @param baiesAdjVeranda {BaieVitree[]}
+   * @param etsList {Ets[]}
+   * @returns {BaieVitree[][]} baies par véranda, dans l'ordre de etsList
+   */
+  rattacherBaiesAuxEts(baiesAdjVeranda, etsList) {
+    const baiesParEts = etsList.map(() => []);
+    // Aucune véranda exploitable : les baies adjacence 10 ne peuvent être rattachées à aucun ETS
+    if (etsList.length === 0) {
+      return baiesParEts;
+    }
+    baiesAdjVeranda.forEach((bv) => {
+      const referenceLnc = bv.donnee_entree.reference_lnc;
+      const idx = referenceLnc
+        ? etsList.findIndex((ets) => ets.donnee_entree?.reference === referenceLnc)
+        : -1;
+      baiesParEts[idx === -1 ? 0 : idx].push(bv);
+    });
+    return baiesParEts;
   }
 
   /**

package/features/engine/domain/apport_et_besoin/surface-sud-equivalente.service.spec.js

@@ -0,0 +1,280 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { SurfaceSudEquivalenteService } from './surface-sud-equivalente.service.js';
+
+/**
+ * Orientations utilisées dans les tests (identifiants arbitraires : le store est un double de test)
+ */
+const SUD = '1';
+const NORD = '2';
+const EST = '3';
+const HORIZONTAL = '5';
+
+/**
+ * Coefficients C1 de janvier (sud = 1, est = 0,40, nord = 0,31, horizontal = 0,3) utilisés pour les
+ * cas de test d'Olivier (issue #101). Indexés par orientation.
+ */
+const C1 = { [SUD]: 1, [NORD]: 0.31, [EST]: 0.4, [HORIZONTAL]: 0.3 };
+
+/** @type {{ getCoefficientBaieVitree: import('vitest').Mock }} */
+let tvStore;
+
+/** @type {SurfaceSudEquivalenteService} */
+let service;
+
+/** @type {Contexte} */
+const ctx = { zoneClimatique: { id: '2', value: 'h1b' } };
+
+/** Fabrique une baie vitrée avec les données d'entrée/intermédiaires utiles au calcul. */
+function baie({ adjacence = '1', surface, orientationId = SUD, sw = 1, referenceLnc }) {
+  const bv = {
+    donnee_entree: {
+      enum_type_adjacence_id: adjacence,
+      enum_orientation_id: orientationId,
+      enum_inclinaison_vitrage_id: '3',
+      surface_totale_baie: surface
+    },
+    donnee_intermediaire: { sw }
+  };
+  if (referenceLnc !== undefined) bv.donnee_entree.reference_lnc = referenceLnc;
+  return bv;
+}
+
+/** Fabrique une baie de l'espace tampon donnant sur l'extérieur (pas de donnée intermédiaire). */
+function baieEts(surface, orientationId) {
+  return {
+    donnee_entree: {
+      enum_orientation_id: orientationId,
+      enum_inclinaison_vitrage_id: '3',
+      surface_totale_baie: surface
+    }
+  };
+}
+
+/** Fabrique une véranda avec ses propres T, bver et baies extérieures. */
+function veranda(reference, T, bver, baiesExt) {
+  return {
+    donnee_entree: { reference },
+    donnee_intermediaire: { bver, coef_transparence_ets: T },
+    baie_ets_collection: {
+      baie_ets: baiesExt.map(([surface, orientationId]) => baieEts(surface, orientationId))
+    }
+  };
+}
+
+function enveloppe(baiesVitrees, ets) {
+  return {
+    baie_vitree_collection: { baie_vitree: baiesVitrees },
+    ets_collection: ets === undefined ? {} : { ets }
+  };
+}
+
+describe('Calcul de la surface sud équivalente (§6.2 / §6.3)', () => {
+  beforeEach(() => {
+    tvStore = {
+      getCoefficientBaieVitree: vi.fn((orientation) => C1[orientation])
+    };
+    service = new SurfaceSudEquivalenteService(tvStore);
+  });
+
+  describe('ssdBaieMois', () => {
+    test('interroge la table C1 avec orientation, inclinaison, zone climatique et mois', () => {
+      const bv = baie({ surface: 10, orientationId: EST, sw: 0.5 });
+      // 10 * 0,40 * 0,5
+      expect(service.ssdBaieMois(bv, '2', 'Janvier')).toBeCloseTo(2, 9);
+      expect(tvStore.getCoefficientBaieVitree).toHaveBeenCalledWith(3, 3, 2, 'Janvier');
+    });
+
+    test('inclinaison absente : vitrage vertical (3) par défaut ; facteurs fe1/fe2 appliqués', () => {
+      const bv = baie({ surface: 10, sw: 0.5 });
+      delete bv.donnee_entree.enum_inclinaison_vitrage_id;
+      bv.donnee_intermediaire.fe1 = 0.8;
+      bv.donnee_intermediaire.fe2 = 0.5;
+      expect(service.ssdBaieMois(bv, '2', 'Janvier')).toBeCloseTo(10 * 0.5 * 0.8 * 0.5, 9);
+      expect(tvStore.getCoefficientBaieVitree).toHaveBeenCalledWith(1, 3, 2, 'Janvier');
+    });
+
+    test('un coefficient explicite remplace le facteur solaire sw de la baie', () => {
+      expect(service.ssdBaieMois(baieEts(10, SUD), '2', 'Janvier', 0.3)).toBeCloseTo(3, 9);
+    });
+  });
+
+  describe('ssdMois - sans espace tampon solarisé', () => {
+    test('somme des baies donnant sur l’extérieur ; les autres adjacences sont ignorées', () => {
+      const bvList = [
+        baie({ surface: 10, sw: 0.5 }),
+        baie({ adjacence: '10', surface: 4 }),
+        baie({ adjacence: '3', surface: 4 })
+      ];
+      expect(service.ssdMois(ctx, enveloppe(bvList), 'Janvier')).toBeCloseTo(5, 9);
+    });
+
+    test('ets_collection vide (tableau) ou absente : seules les baies extérieures comptent', () => {
+      const bvList = [baie({ surface: 10, sw: 0.5 }), baie({ adjacence: '10', surface: 4 })];
+      expect(service.ssdMois(ctx, enveloppe(bvList, []), 'Janvier')).toBeCloseTo(5, 9);
+      expect(
+        service.ssdMois(ctx, { baie_vitree_collection: { baie_vitree: bvList } }, 'Janvier')
+      ).toBeCloseTo(5, 9);
+    });
+
+    test('aucune baie vitrée : surface sud équivalente nulle', () => {
+      expect(service.ssdMois(ctx, {}, 'Janvier')).toBe(0);
+    });
+  });
+
+  describe('ssdMois - un espace tampon solarisé', () => {
+    test('apports directs + indirects : Sse = Sse_ext + Ssd + (Sst - Ssd) × bver', () => {
+      // T = 0,5, bver = 0,8, baie extérieure ETS 10 m² sud (unique, non tableau)
+      const ets = {
+        donnee_entree: {},
+        donnee_intermediaire: { bver: 0.8, coef_transparence_ets: 0.5 },
+        baie_ets_collection: { baie_ets: baieEts(10, SUD) }
+      };
+      const bvList = [baie({ surface: 10, sw: 0.5 }), baie({ adjacence: '10', surface: 2 })];
+      // Ssd = 0,5 × 2 × 1 × 1 = 1 ; Sst = 10 × (0,8 × 0,5 + 0,024) = 4,24
+      // Sse_ver = 1 + (4,24 - 1) × 0,8 = 3,592
+      expect(service.ssdMois(ctx, enveloppe(bvList, ets), 'Janvier')).toBeCloseTo(5 + 3.592, 9);
+    });
+
+    test('ETS sans baie adjacence 10 : bver et T sans effet, Sse_ver non ajoutée', () => {
+      const ets = veranda('V', 0.5, 0.8, [[10, SUD]]);
+      const bvList = [baie({ surface: 10, sw: 0.5 })];
+      expect(service.ssdMois(ctx, enveloppe(bvList, ets), 'Janvier')).toBeCloseTo(5, 9);
+    });
+
+    test('ETS sans baie extérieure : Sst = 0', () => {
+      const ets = {
+        donnee_entree: {},
+        donnee_intermediaire: { bver: 0.5, coef_transparence_ets: 0.5 }
+      };
+      const bvList = [baie({ adjacence: '10', surface: 2 })];
+      // Ssd = 1 ; Sse_ver = 1 + (0 - 1) × 0,5 = 0,5
+      expect(service.ssdMois(ctx, enveloppe(bvList, ets), 'Janvier')).toBeCloseTo(0.5, 9);
+    });
+
+    test('la Sse_ver n’est comptée qu’une fois quel que soit le nombre de baies adjacence 10', () => {
+      const ets = veranda('V', 0.5, 0.8, [[10, SUD]]);
+      const uneBaie = [baie({ adjacence: '10', surface: 2 })];
+      const deuxBaies = [
+        baie({ adjacence: '10', surface: 1 }),
+        baie({ adjacence: '10', surface: 1 })
+      ];
+      expect(service.ssdMois(ctx, enveloppe(deuxBaies, ets), 'Janvier')).toBeCloseTo(
+        service.ssdMois(ctx, enveloppe(uneBaie, ets), 'Janvier'),
+        9
+      );
+    });
+  });
+
+  /**
+   * 6.3 Plusieurs espaces tampons solarisés (issue #101) : T, bver, Sst et Ssd sont propres à chaque
+   * véranda ; Sse = Sse_ext + Σ(v) Sse_veranda_v. Une baie adjacence 10 n'entre que dans la véranda
+   * sur laquelle elle donne (reference_lnc = ets.reference).
+   * Cas de test fournis par Olivier (thermicien) : C1 sud = 1, est = 0,40, nord = 0,31 ; Fe = 1.
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §6.3
+   */
+  describe('ssdMois - plusieurs espaces tampons solarisés (issue #101)', () => {
+    // Baie extérieure 10 m² sud, Sw = 0,5 => Sse_ext = 5
+    const baieExt = baie({ surface: 10, sw: 0.5 });
+    // V1 : T = 0,62, bver = 0,55, baies vers l'extérieur 8 m² sud + 4 m² est
+    const V1 = veranda('V1', 0.62, 0.55, [
+      [8, SUD],
+      [4, EST]
+    ]);
+    // V2 : T = 0,45, bver = 0,85, baie vers l'extérieur 6 m² nord
+    const V2 = veranda('V2', 0.45, 0.85, [[6, NORD]]);
+    const baiesV1 = [
+      baie({ adjacence: '10', surface: 4, sw: 0.47, referenceLnc: 'V1' }),
+      baie({ adjacence: '10', surface: 2, sw: 0.47, referenceLnc: 'V1' })
+    ];
+    const baiesV2 = [
+      baie({ adjacence: '10', surface: 2, orientationId: NORD, sw: 0.47, referenceLnc: 'V2' }),
+      baie({ adjacence: '10', surface: 1, orientationId: NORD, sw: 0.47, referenceLnc: 'V2' })
+    ];
+
+    // SseV1 = 1,7484 + (4,992 - 1,7484) × 0,55 = 3,53238
+    const SSE_V1 = 3.53238;
+    // SseV2 = 0,196695 + (0,71424 - 0,196695) × 0,85 = 0,63660825
+    const SSE_V2 = 0.63660825;
+
+    test('CT1 - cas de l’issue : Sse = Sse_ext + SseV1 + SseV2 avec T et bver propres', () => {
+      const env = enveloppe([baieExt, ...baiesV1, ...baiesV2], [V1, V2]);
+      expect(service.ssdMois(ctx, env, 'Janvier')).toBeCloseTo(5 + SSE_V1 + SSE_V2, 9);
+    });
+
+    test('CT2 - seules les baies de V2 : le Sst de V1 n’est pas appliqué', () => {
+      const env = enveloppe([baieExt, ...baiesV2], [V1, V2]);
+      expect(service.ssdMois(ctx, env, 'Janvier')).toBeCloseTo(5 + SSE_V2, 9);
+    });
+
+    test('CT3 - seules les baies de V1 : V2 sans baie vers le logement apporte 0', () => {
+      const env = enveloppe([baieExt, ...baiesV1], [V1, V2]);
+      expect(service.ssdMois(ctx, env, 'Janvier')).toBeCloseTo(5 + SSE_V1, 9);
+    });
+
+    test('CT4 - véranda dupliquée : pas de double comptage', () => {
+      const env = enveloppe([baieExt, ...baiesV1], [V1, structuredClone(V1)]);
+      expect(service.ssdMois(ctx, env, 'Janvier')).toBeCloseTo(5 + SSE_V1, 9);
+    });
+
+    test('baies sans reference_lnc : rattachées à la première véranda (comportement historique)', () => {
+      const env = enveloppe(
+        [
+          baieExt,
+          baie({ adjacence: '10', surface: 4, sw: 0.47 }),
+          baie({ adjacence: '10', surface: 2, sw: 0.47 })
+        ],
+        [V1, V2]
+      );
+      expect(service.ssdMois(ctx, env, 'Janvier')).toBeCloseTo(5 + SSE_V1, 9);
+    });
+
+    test('l’ordre des vérandas dans la collection est sans effet', () => {
+      const env = enveloppe([baieExt, ...baiesV1, ...baiesV2], [V2, V1]);
+      expect(service.ssdMois(ctx, env, 'Janvier')).toBeCloseTo(5 + SSE_V1 + SSE_V2, 9);
+    });
+
+    test('execute somme la surface sud équivalente de chaque mois', () => {
+      const env = enveloppe([baieExt, ...baiesV1, ...baiesV2], [V1, V2]);
+      // C1 indépendant du mois dans le double de test : 12 × valeur de janvier
+      expect(service.execute(ctx, env)).toBeCloseTo(12 * (5 + SSE_V1 + SSE_V2), 9);
+    });
+  });
+
+  describe('dedoublonnerEts / rattacherBaiesAuxEts / getEtsList', () => {
+    test('getEtsList : objet unique, tableau ou absence', () => {
+      const ets = { donnee_entree: {} };
+      expect(service.getEtsList({ ets_collection: { ets } })).toEqual([ets]);
+      expect(service.getEtsList({ ets_collection: { ets: [ets] } })).toEqual([ets]);
+      expect(service.getEtsList({})).toEqual([]);
+    });
+
+    test('dédoublonnage par référence, à défaut par contenu identique ; éléments vides ignorés', () => {
+      const a = { donnee_entree: { reference: 'A' }, x: 1 };
+      const aBis = { donnee_entree: { reference: 'A' }, x: 2 };
+      const sansRef = { donnee_intermediaire: { bver: 1 } };
+      const autreSansRef = { donnee_intermediaire: { bver: 2 } };
+      expect(
+        service.dedoublonnerEts([a, aBis, sansRef, structuredClone(sansRef), autreSansRef, null])
+      ).toEqual([a, sansRef, autreSansRef]);
+    });
+
+    test('rattachement par reference_lnc ; référence inconnue ou absente => première véranda', () => {
+      const ets = [{ donnee_entree: { reference: 'A' } }, { donnee_entree: { reference: 'B' } }];
+      const bA = { donnee_entree: { reference_lnc: 'A' } };
+      const bB = { donnee_entree: { reference_lnc: 'B' } };
+      const bInconnue = { donnee_entree: { reference_lnc: 'Z' } };
+      const bSans = { donnee_entree: {} };
+      expect(service.rattacherBaiesAuxEts([bA, bB, bInconnue, bSans], ets)).toEqual([
+        [bA, bInconnue, bSans],
+        [bB]
+      ]);
+    });
+
+    test('véranda sans donnee_entree : seules les baies sans lien lui sont rattachées', () => {
+      const ets = [{}, { donnee_entree: { reference: 'B' } }];
+      const bB = { donnee_entree: { reference_lnc: 'B' } };
+      const bSans = { donnee_entree: {} };
+      expect(service.rattacherBaiesAuxEts([bB, bSans], ets)).toEqual([[bSans], [bB]]);
+    });
+  });
+});

package/features/engine/domain/engine.service.js

@@ -138,7 +138,10 @@ export class EngineService {
       delete m.baie_vitree_double_fenetre?.donnee_intermediaire;
       delete m.donnee_intermediaire;
     });
-    delete dpe.logement.enveloppe.ets_collection.ets?.donnee_intermediaire;
+    // Un DPE peut comporter un ou plusieurs espaces tampons solarisés (objet ou tableau)
+    [dpe.logement.enveloppe.ets_collection.ets]
+      .flat()
+      .forEach((ets) => delete ets?.donnee_intermediaire);
     dpe.logement.enveloppe.plancher_bas_collection.plancher_bas?.map(
       (m) => delete m.donnee_intermediaire
     );

package/features/engine/domain/engine.service.spec.js

@@ -227,4 +227,18 @@ describe('EngineService (orchestration de la méthode 3CL)', () => {
     // Aucun tableau interne ni production_elec_enr : les `?.` court-circuitent
     expect(() => service.execute(dpeMinimal())).not.toThrow();
   });
+
+  test('nettoie les données intermédiaires de chaque espace tampon solarisé (issue #101)', () => {
+    const dpe = dpeComplet();
+    dpe.logement.enveloppe.ets_collection.ets = [
+      { donnee_intermediaire: { bver: 0.55 } },
+      { donnee_intermediaire: { bver: 0.85 } },
+      null
+    ];
+    const resultat = service.execute(dpe);
+    const [v1, v2, vide] = resultat.logement.enveloppe.ets_collection.ets;
+    expect(v1.donnee_intermediaire).toBeUndefined();
+    expect(v2.donnee_intermediaire).toBeUndefined();
+    expect(vide).toBeNull();
+  });
 });

package/features/engine/domain/enveloppe/deperdition-enveloppe.service.js

@@ -258,14 +258,15 @@ export class DeperditionEnveloppeService {
       }
     });
 
-    let ets = enveloppe.ets_collection?.ets;
+    /**
+     * Un DPE peut comporter plusieurs espaces tampons solarisés (issue #101) : bver et le coefficient
+     * de transparence sont propres à chacun d'eux.
+     */
+    const ets = enveloppe.ets_collection?.ets;
     if (ets) {
-      // Certaines vérandas sont dupliqués dans les DPE.
-      if (Array.isArray(ets)) {
-        ets = ets[0];
-      }
-
-      ets.donnee_intermediaire = this.#espaceTamponService.execute(ctx, ets);
+      (Array.isArray(ets) ? ets : [ets]).forEach((e) => {
+        e.donnee_intermediaire = this.#espaceTamponService.execute(ctx, e);
+      });
     }
 
     enveloppe.pont_thermique_collection.pont_thermique?.forEach((pt) => {