EnergySystemModels 20260416003__tar.gz → 20260416005__tar.gz

{energysystemmodels-20260416003 → energysystemmodels-20260416005}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: energysystemmodels
-Version: 20260416003
+Version: 20260416005
 Summary: Energy systems models are the mathematical models that are developed in order to represent as reliably as possible various energy-related problems.
 Author: Zoheir HADID
 Author-email: zoheir.hadid@gmail.com

{energysystemmodels-20260416003 → energysystemmodels-20260416005}/setup.py

@@ -11,7 +11,7 @@ setup(
     name='energysystemmodels',
 
 
-    version='20260416003',
+    version='20260416005',
 
     description='Energy systems models are the mathematical models that are developed in order to represent as reliably as possible various energy-related problems.',
 

{energysystemmodels-20260416003 → energysystemmodels-20260416005}/src/PV/ProductionElectriquePV.py

@@ -121,7 +121,7 @@ class SolarSystem:
         self.ac = pvlib.inverter.sandia(self.dc['v_mp'], self.dc['p_mp'], self.inverter)
         #print("puissance CA (courant alternatif)", self.ac)
         # Calcul de l'énergie annuelle
-        self.annual_energy = -self.ac.sum()
+        self.annual_energy = self.ac.sum()
 
         module_area = self.module['Area'] if self.module is not None else 0
         module_wc = self.module['Impo'] * self.module['Vmpo'] if self.module is not None else 0
@@ -148,30 +148,26 @@ class SolarSystem:
             'Productivite (kWh/kWc/an)',
         ])
 
-    def summary(self, nb_modules=1, module_wc=None, capex_eur_kwc=1200,
-                opex_eur_kwc=15, tarif_elec_eur_mwh=120, taux_autoconso=0.80):
+    def summary(self, nb_modules=1, module_wc=None,
+                capex_eur_m2=None, opex_eur_m2=None,
+                tarif_elec_eur_mwh=None, duree_vie=25):
         """Retourne un DataFrame de synthese technique et economique.
 
         Parameters
         ----------
         nb_modules : int
-            Nombre de modules dans l'installation (defaut 1).
+            Nombre de modules dans l'installation.
         module_wc : float or None
-            Puissance crete d'un module en Wc. Si None, deduite de
-            self.module['Impo'] * self.module['Vmpo'] (parametres STC).
-        capex_eur_kwc : float
-            Cout d'investissement (EUR/kWc TTC pose comprise).
-        opex_eur_kwc : float
-            Cout d'exploitation annuel (EUR/kWc/an).
-        tarif_elec_eur_mwh : float
-            Prix de l'electricite evitee (EUR/MWh).
-        taux_autoconso : float
-            Fraction de la production autoconsommee (0-1).
-
-        Returns
-        -------
-        pd.DataFrame
-            Tableau a deux colonnes (Indicateur, Valeur).
+            Puissance crete d'un module en Wc.
+        capex_eur_m2 : float or None
+            Cout d'investissement par m2 de panneau installe (EUR/m2).
+            Si None, pas d'analyse economique.
+        opex_eur_m2 : float or None
+            Cout d'exploitation annuel par m2 (EUR/m2/an).
+        tarif_elec_eur_mwh : float or None
+            Prix de l'electricite valorisee (EUR/MWh).
+        duree_vie : int
+            Duree de vie du projet en annees (defaut 25 ans).
         """
         if module_wc is None:
             module_wc = self.module['Impo'] * self.module['Vmpo']
@@ -183,18 +179,9 @@ class SolarSystem:
         module_area = self.module['Area'] if self.module is not None else 1.65
         surface_m2 = nb_modules * module_area
 
-        capex = puissance_kwc * capex_eur_kwc
-        opex = puissance_kwc * opex_eur_kwc
-        eco_annuelle = prod_totale_mwh * taux_autoconso * tarif_elec_eur_mwh
-        gain_net = eco_annuelle - opex
-        tri = capex / gain_net if gain_net > 0 else np.inf
-
         rows = [
+            ("--- SIMULATION ---", ""),
             ("Site", self.name),
-            ("Latitude", f"{self.latitude:.3f} deg"),
-            ("Longitude", f"{self.longitude:.3f} deg"),
-            ("Azimut", f"{self.azimut} deg"),
-            ("Inclinaison", f"{self.inclinaison} deg"),
             ("Module", self.module.name if self.module is not None else "N/A"),
             ("Surface module", f"{module_area:.3f} m2"),
             ("Nb modules", nb_modules),
@@ -203,15 +190,106 @@ class SolarSystem:
             ("Production / module", f"{prod_module_kwh:.1f} kWh/an"),
             ("Productivite specifique", f"{productivite:.0f} kWh/kWc/an"),
             ("Production totale", f"{prod_totale_mwh:.1f} MWh/an"),
-            ("Taux autoconsommation", f"{taux_autoconso*100:.0f} %"),
-            ("CAPEX", f"{capex/1000:.0f} kEUR"),
-            ("OPEX annuel", f"{opex/1000:.1f} kEUR/an"),
-            ("Economies annuelles", f"{eco_annuelle/1000:.1f} kEUR/an"),
-            ("Gain net annuel", f"{gain_net/1000:.1f} kEUR/an"),
-            ("TRI simple", f"{tri:.1f} ans"),
         ]
+
+        if all(v is not None for v in [capex_eur_m2, opex_eur_m2,
+                                        tarif_elec_eur_mwh]):
+            capex = surface_m2 * capex_eur_m2
+            opex = surface_m2 * opex_eur_m2
+            valorisation = prod_totale_mwh * tarif_elec_eur_mwh
+            gain_net = valorisation - opex
+            payback = capex / gain_net if gain_net > 0 else np.inf
+            roi = ((gain_net * duree_vie - capex) / capex * 100) if capex > 0 else 0
+
+            # TRI : taux r tel que sum(gain_net/(1+r)^t, t=1..N) = capex
+            tri = 0.0
+            if gain_net > 0 and capex > 0:
+                from scipy.optimize import brentq
+                def npv(r):
+                    return sum(gain_net / (1 + r) ** t
+                               for t in range(1, duree_vie + 1)) - capex
+                try:
+                    tri = brentq(npv, -0.5, 5.0) * 100
+                except Exception:
+                    tri = 0.0
+
+            rows += [
+                ("--- HYPOTHESES ECO ---", ""),
+                ("CAPEX", f"{capex_eur_m2} EUR/m2"),
+                ("OPEX", f"{opex_eur_m2} EUR/m2/an"),
+                ("Tarif electricite", f"{tarif_elec_eur_mwh} EUR/MWh"),
+                ("Duree de vie", f"{duree_vie} ans"),
+                ("--- RESULTATS ECO ---", ""),
+                ("Investissement", f"{capex/1000:.0f} kEUR"),
+                ("Valorisation annuelle", f"{valorisation/1000:.1f} kEUR/an"),
+                ("OPEX annuel", f"{opex/1000:.1f} kEUR/an"),
+                ("Gain net annuel", f"{gain_net/1000:.1f} kEUR/an"),
+                ("Payback", f"{payback:.1f} ans"),
+                ("ROI ({0} ans)".format(duree_vie), f"{roi:.0f} %"),
+                ("TRI", f"{tri:.1f} %"),
+            ]
+
         return pd.DataFrame(rows, columns=["Indicateur", "Valeur"])
 
+    def plot(self, figsize=(14, 5), nb_modules=1):
+        """Trace la production horaire AC et le profil mensuel."""
+        ac_kw = self.ac * nb_modules / 1000
+
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=figsize)
+
+        ax1.plot(ac_kw.values, linewidth=0.3)
+        ax1.set_xlabel('Heure de l\'annee')
+        ax1.set_ylabel('Production AC (kW)')
+        ax1.set_title(f'{self.name} - Production horaire ({nb_modules} modules)')
+        ax1.grid(True, alpha=0.3)
+
+        monthly = ac_kw.resample('ME').sum()
+        total_mwh = abs(ac_kw.sum()) / 1000
+        ax2.bar(range(len(monthly)), monthly.values, color='orange')
+        ax2.set_xticks(range(len(monthly)))
+        ax2.set_xticklabels(['J','F','M','A','M','J','J','A','S','O','N','D'][:len(monthly)])
+        ax2.set_ylabel('Production mensuelle (kWh)')
+        ax2.set_title(f'{self.name} - Profil mensuel | Total : {total_mwh:.1f} MWh/an')
+        ax2.grid(axis='y', alpha=0.3)
+
+        plt.tight_layout()
+        plt.show()
+        return fig
+
+    def to_excel(self, filename=None, nb_modules=1):
+        """Exporte la production horaire en fichier Excel.
+
+        Parameters
+        ----------
+        filename : str or None
+            Chemin du fichier. Si None, genere '{name}_production.xlsx'.
+        nb_modules : int
+            Nombre de modules (defaut 1).
+
+        Returns
+        -------
+        str
+            Chemin du fichier cree.
+        """
+        if filename is None:
+            filename = f"{self.name.replace(' ', '_')}_production.xlsx"
+
+        df_export = pd.DataFrame({
+            'Production_AC_kW': self.ac * nb_modules / 1000,
+            'Irradiance_POA_W_m2': self.total_irradiance['poa_global'],
+            'T_cellule_C': self.cell_temperature,
+            'T_air_C': self.weather['temp_air'],
+        })
+        df_export.index.name = 'datetime_utc'
+
+        with pd.ExcelWriter(filename, engine='openpyxl') as writer:
+            df_export.to_excel(writer, sheet_name='Horaire')
+            df_export.resample('ME').sum().to_excel(writer, sheet_name='Mensuel')
+            self.df.to_excel(writer, sheet_name='Synthese')
+
+        print(f"Export : {filename}")
+        return filename
+
     def plot_annual_energy(self):
         energies = pd.Series({self.name: self.annual_energy})
         energies.plot(kind='bar', rot=0)
@@ -219,7 +297,7 @@ class SolarSystem:
 
     @staticmethod
     def orientation_study(latitude, longitude, name, altitude, timezone,
-                          scenarios, save_fig=None):
+                          scenarios):
         """Etude parametrique d'orientation et d'inclinaison.
 
         Parameters
@@ -228,16 +306,17 @@ class SolarSystem:
             Parametres du site (identiques a __init__).
         scenarios : list[dict]
             Liste de dicts avec cles 'nom', 'azimut', 'inclinaison'.
-            Exemple : [{'nom': 'Sud 35', 'azimut': 180, 'inclinaison': 35}]
-        save_fig : str or None
-            Chemin du fichier image a sauvegarder. Si None, pas de sauvegarde.
 
         Returns
         -------
-        pd.DataFrame
+        df : pd.DataFrame
             Tableau comparatif trie par production decroissante.
+        df_monthly : pd.DataFrame
+            Production mensuelle (kWh/kWc) par scenario (colonnes)
+            et par mois (index).
         """
         resultats = []
+        monthly_data = {}
         for sc in scenarios:
             pv = SolarSystem(
                 latitude=latitude, longitude=longitude,
@@ -246,12 +325,15 @@ class SolarSystem:
                 azimut=sc['azimut'], inclinaison=sc['inclinaison']
             )
             pv.retrieve_module_inverter_data()
-            pv.retrieve_weather_data()
             pv.calculate_solar_parameters()
 
             module_wc = pv.module['Impo'] * pv.module['Vmpo']
-            prod_kwh_kwc = pv.annual_energy / 1000 / (module_wc / 1000)
+            ac_kwh_kwc = pv.ac / module_wc
+            monthly = ac_kwh_kwc.resample('ME').sum()
+            monthly.index = range(1, len(monthly) + 1)
+            monthly_data[sc['nom']] = monthly
 
+            prod_kwh_kwc = pv.annual_energy / 1000 / (module_wc / 1000)
             resultats.append({
                 'Configuration': sc['nom'],
                 'Azimut (deg)': sc['azimut'],
@@ -267,23 +349,42 @@ class SolarSystem:
         df = df.sort_values('Production (kWh/kWc/an)', ascending=False)
         df = df.reset_index(drop=True)
 
-        # Graphique comparatif
+        df_monthly = pd.DataFrame(monthly_data)
+        return df, df_monthly
+
+    @staticmethod
+    def plot_orientation_study(df, df_monthly, name='', save_fig=None):
+        """Trace les profils mensuels par orientation.
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            Resultat de orientation_study() (tableau annuel).
+        df_monthly : pd.DataFrame
+            Profils mensuels par scenario.
+        name : str
+            Nom du site (pour le titre).
+        save_fig : str or None
+            Chemin fichier image. Si None, pas de sauvegarde.
+        """
         fig, ax = plt.subplots(figsize=(12, 6))
-        colors = ['green' if i == 0 else 'orange'
-                  for i in range(len(df))]
-        ax.bar(range(len(df)), df['Production (kWh/kWc/an)'],
-               color=colors)
-        ax.set_xticks(range(len(df)))
-        ax.set_xticklabels(df['Configuration'], rotation=45, ha='right')
-        ax.set_ylabel('Production annuelle (kWh/kWc/an)')
-        ax.set_title(f'Comparaison productivite PV selon orientation - {name}')
-        ax.axhline(y=prod_max, color='green', linestyle='--', alpha=0.5,
-                   label='Production optimale')
-        ax.legend()
-        ax.grid(axis='y', alpha=0.3)
+        mois_labels = ['Jan','Fev','Mar','Avr','Mai','Jun',
+                       'Jul','Aou','Sep','Oct','Nov','Dec']
+        totaux = df.set_index('Configuration')['Production (kWh/kWc/an)']
+        for col in df_monthly.columns:
+            total = totaux.get(col, df_monthly[col].sum())
+            ax.plot(df_monthly.index, df_monthly[col], 'o-',
+                    linewidth=1.5, markersize=4,
+                    label=f'{col} ({total:.0f} kWh/kWc/an)')
+        ax.set_xticks(range(1, len(df_monthly) + 1))
+        ax.set_xticklabels(mois_labels[:len(df_monthly)])
+        ax.set_xlabel('Mois')
+        ax.set_ylabel('Production mensuelle (kWh/kWc)')
+        ax.set_title(f'Profil mensuel par orientation - {name}')
+        ax.legend(fontsize=11)
+        ax.grid(True, alpha=0.3)
         fig.tight_layout()
         if save_fig:
             fig.savefig(save_fig, dpi=150)
         plt.show()
-
-        return df
+        return fig

energysystemmodels-20260416005/src/ThermodynamicCycles/Combustion/NG_Boiler_Efficiency_EN1295X.py

@@ -0,0 +1,292 @@
+import numpy as np
+import pandas as pd
+import re
+from ThermodynamicCycles.Combustion.NG_Heating_Value import NG_Heating_Value
+
+
+class NG_Boiler_Efficiency:
+    """
+    EN12952-15 / EN12953-11 indirect method boiler efficiency calculator.
+    Computes heat losses (flue gas sensible, CO, radiation, condensation)
+    and derives LHV/HHV efficiencies for natural gas boilers.
+    """
+
+    R = 8.314510          # J/mol/K
+    VMOL = 22.414e-3      # m3/mol at 0C, 101.325 kPa
+    T_NTP = 273.15        # K (Normal Temperature 0C)
+    P_NTP = 101.325       # kPa
+
+    # Dry air molar composition
+    DRY_AIR = {'CO2': 0.00033, 'O2': 0.20946, 'N2': 0.78102, 'Ar': 0.00919}
+
+    # Flue gas Cp in kJ/Nm3/K (mean values for typical boiler temperature range)
+    FG_CP = {'CO2': 1.7, 'H2O': 1.5, 'N2': 1.3, 'O2': 1.3, 'Ar': 0.93}
+
+    # Radiation loss constants
+    RADIATION_CONSTANT = {'water_tube': 0.0113, 'fire_tube': 0.0072}
+
+    # CO net calorific value kJ/Nm3
+    NCV_CO = 12633.0
+
+    # Latent heat of water vaporization kJ/kg at 25C
+    LATENT_HEAT_WATER = 2442.5
+
+    def __init__(
+        self,
+        gas_composition: dict,
+        ng_flow_Nm3h: float,
+        ng_temperature_C: float = 25.0,
+        ng_LHV_kWh_Nm3: float = None,
+        flue_gas_temperature_C: float = 180.0,
+        O2_measured: float = 0.035,
+        O2_basis: str = 'dry',
+        CO_ppm: float = 0.0,
+        ambient_temperature_C: float = 25.0,
+        ambient_RH: float = 0.5,
+        ambient_pressure_mbar: float = 1013.25,
+        air_temperature_C: float = None,
+        boiler_type: str = 'water_tube',
+        design_useful_heat_kW: float = 1000.0,
+        electrical_credit_kW: float = 0.0,
+        other_heat_credit_kW: float = 0.0,
+        T_ref: float = 25.0,
+    ):
+        self.gas_composition = gas_composition
+        self.ng_flow = ng_flow_Nm3h
+        self.ng_temperature = ng_temperature_C
+        self.ng_LHV_kWh_Nm3_input = ng_LHV_kWh_Nm3
+        self.T_fg = flue_gas_temperature_C
+        self.O2_measured = O2_measured
+        self.O2_basis = O2_basis
+        self.CO_ppm = CO_ppm
+        self.T_amb = ambient_temperature_C
+        self.RH = ambient_RH
+        self.P_atm = ambient_pressure_mbar * 100.0  # Pa
+        self.T_air = air_temperature_C if air_temperature_C is not None else ambient_temperature_C
+        self.boiler_type = boiler_type
+        self.design_useful_heat_kW = design_useful_heat_kW
+        self.electrical_credit = electrical_credit_kW
+        self.other_heat_credit = other_heat_credit_kW
+        self.T_ref = T_ref
+        self.df = None
+
+    def calculate(self):
+        # --- 1. NG properties via NG_Heating_Value ---
+        comps = [
+            NG_Heating_Value.GasComponent(formula, x)
+            for formula, x in self.gas_composition.items()
+        ]
+        ng_props = NG_Heating_Value(comps)
+        props_df = ng_props.df
+
+        def get_prop(name, unit):
+            row = props_df[(props_df['Property'] == name) & (props_df['Unit'] == unit)]
+            return row['Value'].values[0] if not row.empty else None
+
+        LHV_kWh = get_prop('LHV vol', 'kWh/Nm3') if self.ng_LHV_kWh_Nm3_input is None else self.ng_LHV_kWh_Nm3_input
+        HHV_kWh = get_prop('HHV vol', 'kWh/Nm3')
+        density = get_prop('Density real', 'kg/Nm3')
+        Cp_mass = ng_props.Cp_mix()  # J/kg/K
+
+        # --- 2. NG heat power ---
+        Cp_kWh_Nm3_K = (Cp_mass * density) / 3.6e6  # J/kg/K * kg/Nm3 -> J/Nm3/K -> kWh/Nm3/K
+        sensible_heat = Cp_kWh_Nm3_K * (self.ng_temperature - self.T_ref)
+        Q_ng_LHV = (LHV_kWh + sensible_heat) * self.ng_flow  # kW
+        Q_ng_HHV = (HHV_kWh + sensible_heat) * self.ng_flow  # kW
+
+        # --- 3. Ambient air moisture ---
+        Psat = 610.78 * np.exp(17.2694 * self.T_amb / (self.T_amb + 237.29))  # Pa
+        Pw = self.RH * Psat
+        x_H2O_air = Pw / self.P_atm  # molar fraction
+
+        # --- 4-5. Wet air composition ---
+        wet_air = {}
+        for species, xi in self.DRY_AIR.items():
+            wet_air[species] = xi * (1 - x_H2O_air)
+        wet_air['H2O'] = x_H2O_air
+
+        # --- 6. Stoichiometric combustion ---
+        stoich_O2 = 0.0    # Nm3 O2 per Nm3 fuel
+        stoich_CO2 = 0.0   # Nm3 CO2 produced per Nm3 fuel
+        stoich_H2O = 0.0   # Nm3 H2O produced per Nm3 fuel
+        stoich_N2_fuel = 0.0
+
+        for formula, x in self.gas_composition.items():
+            if formula == 'N2':
+                stoich_N2_fuel += x
+                continue
+            if formula == 'CO2':
+                stoich_CO2 += x
+                continue
+            if formula == 'H2':
+                stoich_O2 += x * 0.5
+                stoich_H2O += x * 1.0
+                continue
+
+            # Parse CnHm
+            clean = formula.replace("n-", "").replace("i-", "").replace("neo-", "")
+            matches = re.findall(r'([CHON])(\d*)', clean)
+            atoms = {elem: int(num) if num else 1 for elem, num in matches}
+            n_C = atoms.get('C', 0)
+            n_H = atoms.get('H', 0)
+
+            if n_C == 0 and n_H == 0:
+                continue
+
+            O2_needed = n_C + n_H / 4.0
+            stoich_O2 += x * O2_needed
+            stoich_CO2 += x * n_C
+            stoich_H2O += x * n_H / 2.0
+
+        # Stoichiometric air (Nm3 air / Nm3 fuel) based on O2 in dry air
+        stoich_air = stoich_O2 / self.DRY_AIR['O2']
+
+        # --- 7. Excess air from O2 measurement ---
+        O2_dry_frac = self.O2_measured
+        if self.O2_basis == 'wet':
+            # Convert wet O2 to dry O2 (approximate)
+            # Need iterative approach, but use first approximation
+            O2_dry_frac = self.O2_measured / (1 - x_H2O_air)
+
+        O2_dry_pct = O2_dry_frac * 100.0
+        O2_ref_pct = self.DRY_AIR['O2'] * 100.0
+
+        total_air_ratio = O2_ref_pct / (O2_ref_pct - O2_dry_pct)
+        total_air = stoich_air * total_air_ratio  # Nm3 wet air / Nm3 fuel
+        excess_air_pct = (total_air_ratio - 1) * 100.0
+
+        # --- 8. Flue gas composition (Nm3 per Nm3 fuel) ---
+        fg = {}
+        fg['CO2'] = stoich_CO2 + total_air * wet_air.get('CO2', 0)
+        fg['H2O'] = stoich_H2O + total_air * wet_air.get('H2O', 0)
+        fg['O2'] = total_air * wet_air.get('O2', 0) - stoich_O2
+        fg['N2'] = stoich_N2_fuel + total_air * wet_air.get('N2', 0)
+        fg['Ar'] = total_air * wet_air.get('Ar', 0)
+
+        fg_total = sum(fg.values())  # Nm3 flue gas / Nm3 fuel
+        fg_dry = fg_total - fg['H2O']
+
+        # Flue gas flows
+        fg_flow = fg_total * self.ng_flow  # Nm3/h
+        fg_flow_dry = fg_dry * self.ng_flow
+
+        # H2O volume fraction in flue gas
+        x_H2O_fg = fg['H2O'] / fg_total
+
+        # --- 9-10. Flue gas sensible heat loss ---
+        dT = self.T_fg - self.T_ref
+        # Weighted Cp of flue gas mixture (kJ/Nm3_mix/K)
+        Cp_fg_mix = sum(fg[sp] / fg_total * self.FG_CP.get(sp, 1.3) for sp in fg)
+
+        flue_gas_loss = fg_flow * Cp_fg_mix * dT / 3600.0  # kW
+
+        # CO loss
+        CO_loss = self.CO_ppm * 1e-6 * fg_flow_dry * self.NCV_CO / 3600.0  # kW
+
+        # Radiation loss
+        k_rad = self.RADIATION_CONSTANT.get(self.boiler_type, 0.0113)
+        radiation_loss = k_rad * self.design_useful_heat_kW ** 0.7  # kW
+
+        # --- 11. Condensation check ---
+        # Dew point from H2O partial pressure in flue gas
+        P_H2O_fg = x_H2O_fg * self.P_atm  # Pa
+        # Inverse of Antoine: T_dew = 237.29 * ln(P/610.78) / (17.2694 - ln(P/610.78))
+        if P_H2O_fg > 0:
+            ln_ratio = np.log(P_H2O_fg / 610.78)
+            T_condensation = 237.29 * ln_ratio / (17.2694 - ln_ratio)
+        else:
+            T_condensation = 0.0
+
+        condensation_recovery = 0.0
+        if self.T_fg < T_condensation:
+            # Saturation pressure at flue gas temperature
+            Psat_fg = 610.78 * np.exp(17.2694 * self.T_fg / (self.T_fg + 237.29))
+            # Maximum H2O that can remain as vapor (mole fraction)
+            x_H2O_sat = Psat_fg / self.P_atm
+            # Condensed water: difference in Nm3 per Nm3 fuel
+            H2O_remaining_vapor = x_H2O_sat / (1 - x_H2O_sat) * (fg_total - fg['H2O'])
+            H2O_condensed_Nm3 = max(0, fg['H2O'] - H2O_remaining_vapor)  # Nm3/Nm3_fuel
+            # Convert to kg: 1 Nm3 H2O = 18.015 / 22.414 = 0.8034 kg
+            H2O_condensed_kg_per_Nm3_fuel = H2O_condensed_Nm3 * 18.015 / 22.414
+            H2O_condensed_kg_h = H2O_condensed_kg_per_Nm3_fuel * self.ng_flow
+
+            # Latent heat recovery
+            latent_recovery = H2O_condensed_kg_h * self.LATENT_HEAT_WATER / 3600.0  # kW
+            # Sensible heat recovery from cooling condensate from T_condensation to T_fg
+            sensible_recovery = H2O_condensed_kg_h * 4.18 * (T_condensation - self.T_fg) / 3600.0  # kW
+            condensation_recovery = latent_recovery + sensible_recovery
+
+        # --- 12. Boiler efficiency (indirect method) ---
+        heat_credits = self.electrical_credit + self.other_heat_credit
+
+        # LHV basis
+        total_losses_LHV = flue_gas_loss + CO_loss + radiation_loss - condensation_recovery
+        efficiency_LHV = 1.0 - total_losses_LHV / (Q_ng_LHV + heat_credits) if (Q_ng_LHV + heat_credits) > 0 else 0.0
+
+        # HHV basis: flue gas loss must include latent heat of ALL water vapor
+        # Additional latent heat = total H2O in flue gas (as vapor) * latent heat
+        H2O_vapor_Nm3_h = fg['H2O'] * self.ng_flow  # Nm3/h of water vapor
+        if self.T_fg < T_condensation:
+            H2O_vapor_Nm3_h = H2O_remaining_vapor * self.ng_flow
+        H2O_vapor_kg_h = H2O_vapor_Nm3_h * 18.015 / 22.414
+        latent_loss_all_water = H2O_vapor_kg_h * self.LATENT_HEAT_WATER / 3600.0  # kW
+
+        flue_gas_loss_HHV = flue_gas_loss + latent_loss_all_water
+        total_losses_HHV = flue_gas_loss_HHV + CO_loss + radiation_loss - condensation_recovery
+        efficiency_HHV = 1.0 - total_losses_HHV / (Q_ng_HHV + heat_credits) if (Q_ng_HHV + heat_credits) > 0 else 0.0
+
+        # --- 13. Useful heat ---
+        useful_heat_LHV = efficiency_LHV * Q_ng_LHV + heat_credits
+        useful_heat_HHV = efficiency_HHV * Q_ng_HHV + heat_credits
+
+        # --- Build output DataFrame ---
+        rows = [
+            ('--- INPUTS ---', ''),
+            ('NG flow (Nm3/h)', round(self.ng_flow, 2)),
+            ('LHV (kWh/Nm3)', round(LHV_kWh, 4)),
+            ('HHV (kWh/Nm3)', round(HHV_kWh, 4)),
+            ('T flue gas (C)', round(self.T_fg, 1)),
+            ('O2 dry (%)', round(O2_dry_pct, 2)),
+            ('Boiler type', self.boiler_type),
+            ('--- COMBUSTION ---', ''),
+            ('Air/fuel ratio (Nm3/Nm3)', round(total_air, 3)),
+            ('Excess air (%)', round(excess_air_pct, 1)),
+            ('Flue gas flow (Nm3/h)', round(fg_flow, 1)),
+            ('Condensation T (C)', round(T_condensation, 1)),
+            ('--- HEAT BALANCE (LHV) ---', ''),
+            ('NG heat input (kW)', round(Q_ng_LHV, 1)),
+            ('Flue gas loss (kW)', round(flue_gas_loss, 1)),
+            ('CO loss (kW)', round(CO_loss, 2)),
+            ('Radiation loss (kW)', round(radiation_loss, 2)),
+            ('Condensation recovery (kW)', round(condensation_recovery, 2)),
+            ('Total losses (kW)', round(total_losses_LHV, 1)),
+            ('Heat credits (kW)', round(heat_credits, 1)),
+            ('Useful heat (kW)', round(useful_heat_LHV, 1)),
+            ('Efficiency LHV (%)', round(efficiency_LHV * 100, 2)),
+            ('--- HEAT BALANCE (HHV) ---', ''),
+            ('Efficiency HHV (%)', round(efficiency_HHV * 100, 2)),
+        ]
+
+        self.df = pd.DataFrame(rows, columns=['Parameter', 'Value'])
+        self.df = self.df.set_index('Parameter')
+
+        # Store key results as attributes for programmatic access
+        self.LHV_kWh_Nm3 = LHV_kWh
+        self.HHV_kWh_Nm3 = HHV_kWh
+        self.Q_ng_LHV = Q_ng_LHV
+        self.Q_ng_HHV = Q_ng_HHV
+        self.efficiency_LHV = efficiency_LHV
+        self.efficiency_HHV = efficiency_HHV
+        self.useful_heat_LHV = useful_heat_LHV
+        self.useful_heat_HHV = useful_heat_HHV
+        self.excess_air_pct = excess_air_pct
+        self.air_fuel_ratio = total_air
+        self.fg_flow_Nm3h = fg_flow
+        self.T_condensation = T_condensation
+        self.condensation_recovery = condensation_recovery
+        self.flue_gas_loss = flue_gas_loss
+        self.radiation_loss = radiation_loss
+        self.CO_loss = CO_loss
+        self.total_losses_LHV = total_losses_LHV
+
+        return self.df