EnergySystemModels 20260416004__tar.gz → 20260416006__tar.gz

{energysystemmodels-20260416004 → energysystemmodels-20260416006}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: energysystemmodels
-Version: 20260416004
+Version: 20260416006
 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-20260416004 → energysystemmodels-20260416006}/setup.py

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

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

@@ -0,0 +1,302 @@
+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
+
+        # Water vapor remaining after condensation (Nm3/Nm3_fuel)
+        if self.T_fg < T_condensation:
+            H2O_vapor = H2O_remaining_vapor
+            H2O_condensed = fg['H2O'] - H2O_remaining_vapor
+        else:
+            H2O_vapor = fg['H2O']
+            H2O_condensed = 0.0
+
+        H2O_vapor_kg_h = H2O_vapor * self.ng_flow * 18.015 / 22.414
+        H2O_condensed_kg_h = H2O_condensed * self.ng_flow * 18.015 / 22.414
+
+        # Condensate loss: water leaving envelope at T_fg (sensible heat)
+        condensate_loss = H2O_condensed_kg_h * 4.18 * (self.T_fg - self.T_ref) / 3600.0  # kW
+
+        # === LHV basis ===
+        # Condensation recovery = latent + sensible heat recovered
+        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 includes latent heat of water REMAINING as vapor
+        latent_vapor = H2O_vapor_kg_h * self.LATENT_HEAT_WATER / 3600.0  # kW
+        flue_gas_loss_HHV = flue_gas_loss + latent_vapor
+        total_losses_HHV = flue_gas_loss_HHV + CO_loss + radiation_loss + condensate_loss
+        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

{energysystemmodels-20260416004 → energysystemmodels-20260416006}/src/ThermodynamicCycles/Combustion/NG_Heating_Value.py

@@ -58,6 +58,7 @@ class NG_Heating_Value:
 
     def __init__(self, comps: List['NG_Heating_Value.GasComponent']):
         self.c = comps
+        self.df = self.to_dataframe()
 
     def M_mix(self):
         return sum(ci.x * ci.M for ci in self.c)

{energysystemmodels-20260416004 → energysystemmodels-20260416006}/src/energysystemmodels.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: energysystemmodels
-Version: 20260416004
+Version: 20260416006
 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-20260416004 → energysystemmodels-20260416006}/src/energysystemmodels.egg-info/SOURCES.txt

@@ -150,6 +150,7 @@ src/ThermodynamicCycles/Aeraulic/StraightPipe.py
 src/ThermodynamicCycles/Aeraulic/__init__.py
 src/ThermodynamicCycles/Combustion/Combustor_cantera.py
 src/ThermodynamicCycles/Combustion/Gaz_Boiler.py
+src/ThermodynamicCycles/Combustion/NG_Boiler_Efficiency_EN1295X.py
 src/ThermodynamicCycles/Combustion/NG_Heating_Value.py
 src/ThermodynamicCycles/Combustion/__init__.py
 src/ThermodynamicCycles/Compressor/Compressor.py