EnergySystemModels 20260416002__tar.gz → 20260416004__tar.gz

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

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

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

energysystemmodels-20260416004/src/PV/ProductionElectriquePV.py

@@ -0,0 +1,390 @@
+import pvlib
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+
+class SolarSystem:
+    def __init__(self, latitude, longitude, name, altitude, timezone, azimut, inclinaison):
+        self.latitude = latitude
+        self.longitude = longitude
+        self.name = name
+        self.altitude = altitude
+        self.timezone = timezone
+        self.azimut = azimut
+        self.inclinaison = inclinaison
+        self.weather = None
+        self.module = None
+        self.inverter = None
+        self.temperature_model_parameters = None
+        self.system = None
+        self.solpos = None
+        self.dni_extra = None
+        self.airmass = None
+        self.pressure = None
+        self.am_abs = None
+        self.aoi = None
+        self.total_irradiance = None
+        self.cell_temperature = None
+        self.effective_irradiance = None
+        self.dc = None
+        self.ac = None
+        self.annual_energy = None
+        self.df = None
+
+    def retrieve_module_inverter_data(self,
+            module_name='Canadian_Solar_CS5P_220M___2009_',
+            inverter_name='ABB__MICRO_0_25_I_OUTD_US_208__208V_',
+            temperature_model='open_rack_glass_glass'):
+        sandia_modules = pvlib.pvsystem.retrieve_sam('SandiaMod')
+        sapm_inverters = pvlib.pvsystem.retrieve_sam('cecinverter')
+        self.module = sandia_modules[module_name]
+        self.inverter = sapm_inverters[inverter_name]
+        self.temperature_model_parameters = pvlib.temperature.TEMPERATURE_MODEL_PARAMETERS['sapm'][temperature_model]
+
+    def retrieve_weather_data(self):
+        # Récupération des données météorologiques TMY à partir de PVGIS pour l'emplacement spécifié
+        weather = pvlib.iotools.get_pvgis_tmy(self.latitude, self.longitude, map_variables=True)[0]
+        weather.index.name = "utc_time"  # Définition du nom de l'index des données météorologiques
+        self.weather = weather
+        #print("Données météorologiques typiques :", self.weather)
+
+    def calculate_solar_parameters(self):
+        if self.weather is None:
+            self.retrieve_weather_data()
+        self.system = {'module': self.module, 'inverter': self.inverter, 'surface_azimuth': self.azimut}
+        # Définition de l'inclinaison de la surface du système solaire
+        self.system['surface_tilt'] = self.inclinaison
+        # Calcul de la position solaire
+        self.solpos = pvlib.solarposition.get_solarposition(
+            time=self.weather.index,
+            latitude=self.latitude,
+            longitude=self.longitude,
+            altitude=self.altitude,
+            temperature=self.weather["temp_air"],
+            pressure=pvlib.atmosphere.alt2pres(self.altitude),
+        )
+        #print("position du soleil===", self.solpos)
+        # Calcul du rayonnement solaire supplémentaire
+        self.dni_extra = pvlib.irradiance.get_extra_radiation(self.weather.index)
+        #print("rayonnement solaire suplémentaire", self.dni_extra)
+        # Calcul de la masse d'air relative
+        self.airmass = pvlib.atmosphere.get_relative_airmass(self.solpos['apparent_zenith'])
+        #print("masse d'air relative", self.airmass)
+        # Calcul de la pression atmosphérique
+        self.pressure = pvlib.atmosphere.alt2pres(self.altitude)
+        #print("pression atm", self.pressure)
+        # Calcul de la masse d'air absolue
+        self.am_abs = pvlib.atmosphere.get_absolute_airmass(self.airmass, self.pressure)
+        #print("masse d'air absolue", self.am_abs)
+        # Calcul de l'angle d'incidence
+        self.aoi = pvlib.irradiance.aoi(
+            self.system['surface_tilt'],
+            self.system['surface_azimuth'],
+            self.solpos["apparent_zenith"],
+            self.solpos["azimuth"],
+        )
+        #print("angle d'incidence", self.aoi)
+        # Calcul du rayonnement solaire total
+        self.total_irradiance = pvlib.irradiance.get_total_irradiance(
+            self.system['surface_tilt'],
+            self.system['surface_azimuth'],
+            self.solpos['apparent_zenith'],
+            self.solpos['azimuth'],
+            self.weather['dni'],
+            self.weather['ghi'],
+            self.weather['dhi'],
+            dni_extra=self.dni_extra,
+            model='haydavies',
+        )
+        #print("rayonnement solaire total", self.total_irradiance)
+        # Calcul de la température des cellules solaires
+        self.cell_temperature = pvlib.temperature.sapm_cell(
+            self.total_irradiance['poa_global'],
+            self.weather["temp_air"],
+            self.weather["wind_speed"],
+            **self.temperature_model_parameters,
+        )
+        #print("température des cellules solaires", self.cell_temperature)
+        # Calcul du rayonnement solaire effectif
+        self.effective_irradiance = pvlib.pvsystem.sapm_effective_irradiance(
+            self.total_irradiance['poa_direct'],
+            self.total_irradiance['poa_diffuse'],
+            self.am_abs,
+            self.aoi,
+            self.module,
+        )
+        #print("rayonnement solaire effectif", self.effective_irradiance)
+        # Calcul de la puissance CC (courant continu)
+        self.dc = pvlib.pvsystem.sapm(self.effective_irradiance, self.cell_temperature, self.module)
+        #print("puissance CC", self.dc)
+        # Calcul de la puissance CA (courant alternatif)
+        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()
+
+        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
+        prod_kwh = self.annual_energy / 1000
+
+        self.df = pd.DataFrame({'SolarSystem': [
+            self.name,
+            f"{self.latitude:.3f}",
+            f"{self.longitude:.3f}",
+            f"{self.azimut}",
+            f"{self.inclinaison}",
+            self.module.name if self.module is not None else "N/A",
+            f"{module_area:.3f}",
+            f"{module_wc:.1f}",
+            self.inverter.name if self.inverter is not None else "N/A",
+            f"{prod_kwh:.1f}",
+            f"{prod_kwh / (module_wc / 1000):.0f}" if module_wc > 0 else "N/A",
+        ]}, index=[
+            'Site', 'Latitude (deg)', 'Longitude (deg)',
+            'Azimut (deg)', 'Inclinaison (deg)',
+            'Module', 'Surface module (m2)', 'Puissance STC (Wc)',
+            'Onduleur',
+            'Production / module (kWh/an)',
+            'Productivite (kWh/kWc/an)',
+        ])
+
+    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.
+        module_wc : float or None
+            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']
+
+        prod_module_kwh = self.annual_energy / 1000
+        productivite = prod_module_kwh / (module_wc / 1000)
+        puissance_kwc = nb_modules * module_wc / 1000
+        prod_totale_mwh = prod_module_kwh * nb_modules / 1000
+        module_area = self.module['Area'] if self.module is not None else 1.65
+        surface_m2 = nb_modules * module_area
+
+        rows = [
+            ("--- SIMULATION ---", ""),
+            ("Site", self.name),
+            ("Module", self.module.name if self.module is not None else "N/A"),
+            ("Surface module", f"{module_area:.3f} m2"),
+            ("Nb modules", nb_modules),
+            ("Puissance crete", f"{puissance_kwc:.1f} kWc"),
+            ("Surface capteurs", f"{surface_m2:.0f} m2"),
+            ("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"),
+        ]
+
+        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)
+        plt.ylabel('Rendement energetique annuel (Wh)')
+
+    @staticmethod
+    def orientation_study(latitude, longitude, name, altitude, timezone,
+                          scenarios):
+        """Etude parametrique d'orientation et d'inclinaison.
+
+        Parameters
+        ----------
+        latitude, longitude, name, altitude, timezone :
+            Parametres du site (identiques a __init__).
+        scenarios : list[dict]
+            Liste de dicts avec cles 'nom', 'azimut', 'inclinaison'.
+
+        Returns
+        -------
+        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,
+                name=sc['nom'], altitude=altitude,
+                timezone=timezone,
+                azimut=sc['azimut'], inclinaison=sc['inclinaison']
+            )
+            pv.retrieve_module_inverter_data()
+            pv.calculate_solar_parameters()
+
+            module_wc = pv.module['Impo'] * pv.module['Vmpo']
+            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'],
+                'Inclinaison (deg)': sc['inclinaison'],
+                'Production (kWh/kWc/an)': round(prod_kwh_kwc, 1),
+            })
+
+        df = pd.DataFrame(resultats)
+        prod_max = df['Production (kWh/kWc/an)'].max()
+        df['Ecart vs Optimal (%)'] = (
+            (df['Production (kWh/kWc/an)'] - prod_max) / prod_max * 100
+        ).round(1)
+        df = df.sort_values('Production (kWh/kWc/an)', ascending=False)
+        df = df.reset_index(drop=True)
+
+        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))
+        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 fig

{energysystemmodels-20260416002 → energysystemmodels-20260416004}/src/ThermodynamicCycles/Chiller.py

@@ -76,10 +76,30 @@ class Object:
         self.Q_condTot = self.COND.Q_cond + self.DESURCH.Qdesurch
         self.COP = self.Q_condTot / self.COMP.Q_comp
 
-        self.df = pd.DataFrame({
-            
-            'Chiller': [self.EER,self.COP,self.COMP.Q_comp/1000,self.COMP.Q_losses/1000,self.EVAP.Q_evap/1000,self.Q_condTot/1000]
-        }, index=[ 'EER', 'COP','Q_comp (kW)','COMP.Q_losses (kW)','Q_evap (kW)', 'Q_condTot(kW)'])
+        T_evap = self.EVAP.Ti_degC
+        T_cond = self.COMP.Tcond_degC
+        lift = T_cond - T_evap
+        COP_Carnot = (T_cond + 273.15) / lift if lift > 0 else float('inf')
+
+        self.df = pd.DataFrame({'Chiller': [
+            self.fluid,
+            round(T_evap, 1), round(T_cond, 1), round(lift, 1),
+            round(self.EER, 3), round(self.COP, 3),
+            round(COP_Carnot, 2),
+            round(self.COP / COP_Carnot * 100, 1) if COP_Carnot < float('inf') else 0,
+            round(self.COMP.Q_comp / 1000, 2),
+            round(self.COMP.Q_losses / 1000, 2),
+            round(self.EVAP.Q_evap / 1000, 2),
+            round(self.Q_condTot / 1000, 2),
+            round(self.COMP.Outlet.T - 273.15, 1),
+            round(self.EVAP.Pi / 1e5, 2),
+            round(self.COND.Psat / 1e5, 2),
+        ]}, index=[
+            'Fluid', 'T_evap (C)', 'T_cond (C)', 'Lift (K)',
+            'EER', 'COP', 'COP_Carnot', 'Eta_Carnot (%)',
+            'Q_comp (kW)', 'Q_losses (kW)', 'Q_evap (kW)', 'Q_condTot (kW)',
+            'T_refoulement (C)', 'P_evap (bar)', 'P_cond (bar)',
+        ])
 
 
         self.points = [

energysystemmodels-20260416004/src/ThermodynamicCycles/Combustion/NG_Heating_Value.py

@@ -0,0 +1,130 @@
+import pandas as pd
+import re
+from typing import List
+
+class NG_Heating_Value:
+
+    # Masse atomique en g/mol
+    atomic_weights = {"C":12.011, "H":1.00794, "O":15.9994, "N":14.00674}
+
+    @staticmethod
+    def molar_mass(formula):
+        """Calcule la masse molaire d'une formule chimique simple (C,H,O,N)"""
+        formula_clean = formula.replace("n-","").replace("i-","").replace("neo-","")
+        matches = re.findall(r'([CHON])(\d*)', formula_clean)
+        mass = 0
+        for elem, num in matches:
+            n = int(num) if num else 1
+            mass += NG_Heating_Value.atomic_weights[elem] * n
+        return mass
+
+    # Données des composants
+    data = [
+        ["Methane", "CH4", 891.56, 802.69, 0.0447,  2.232],
+        ["Ethane", "C2H6", 1562.14, 1428.84, 0.0922, 1.756],
+        ["Propane", "C3H8", 2221.10, 2043.37, 0.1338, 1.685],
+        ["n-Butane", "n-C4H10", 2879.76, 2657.60, 0.1871,  1.731],
+        ["i-Butane", "i-C4H10", 2870.58, 2648.42, 0.1789,  1.693],
+        ["n-Pentane", "n-C5H12", 3538.60, 3272.00, 0.251,  2.313],
+        ["i-Pentane", "i-C5H12", 3531.68, 3265.08, 0.228,  2.313],
+        ["neo-Pentane", "neo-C5H12", 3517.43, 3250.83, 0.2121,  2.313],
+        ["n-Hexane", "n-C6H14", 4198.24, 3887.21, 0.295,  2.259],
+        ["Nitrogen", "N2", 0.0, 0.0, 0.0173,  1.025],
+        ["Carbon dioxide", "CO2", 0.0, 0.0, 0.0748,  0.650],
+        ["Hydrogen", "H2", 286.15, 241.72, -0.0048,  10.140]
+    ]
+    columns = ["Component","Formula","HHV","LHV","b_factor","Cp"]
+    df = pd.DataFrame(data, columns=columns)
+
+    class GasComponent:
+        """Classe interne pour représenter un composant gazeux"""
+        def __init__(self, formula: str, x: float):
+            self.formula = formula
+            self.x = x
+            # Masse molaire
+            self.M = NG_Heating_Value.molar_mass(formula)
+            # Chercher les propriétés dans le DataFrame
+            row = NG_Heating_Value.df.loc[NG_Heating_Value.df['Formula'] == formula]
+            if not row.empty:
+                self.HHV = row['HHV'].values[0]
+                self.LHV = row['LHV'].values[0]
+                self.b = row['b_factor'].values[0]
+                self.Cp = row['Cp'].values[0]
+            else:
+                self.HHV = 0
+                self.LHV = 0
+                self.b = 0
+                self.Cp = 0
+
+    def __init__(self, comps: List['NG_Heating_Value.GasComponent']):
+        self.c = comps
+
+    def M_mix(self):
+        return sum(ci.x * ci.M for ci in self.c)
+
+    def Cp_mix(self):
+        return sum(ci.x * ci.Cp for ci in self.c)
+
+    def HHV_mol(self):
+        return sum(ci.x * ci.HHV for ci in self.c)
+
+    def LHV_mol(self):
+        return sum(ci.x * ci.LHV for ci in self.c)
+
+    def sum_b(self):
+        return sum(ci.x * ci.b for ci in self.c)
+
+    def Z(self):
+        return 1 - self.sum_b()**2
+
+    def to_dataframe(self):
+        M = self.M_mix()
+        Cp = self.Cp_mix()
+        Hs = self.HHV_mol()
+        Hi = self.LHV_mol()
+        Z = self.Z()
+        R = 8.314510
+        P = 101.325
+        T = 273.15
+        M_AIR = 28.9626
+        Z_AIR = 0.99958
+
+        HHV_vol_MJ_Nm3 = Hs * P / (R * T)
+        LHV_vol_MJ_Nm3 = Hi * P / (R * T)
+        HHV_vol_real_MJ_Nm3 = HHV_vol_MJ_Nm3 / Z
+        LHV_vol_real_MJ_Nm3 = LHV_vol_MJ_Nm3 / Z
+        HHV_vol_kWh_Nm3 = HHV_vol_real_MJ_Nm3 / 3.6
+        LHV_vol_kWh_Nm3 = LHV_vol_real_MJ_Nm3 / 3.6
+
+        density = (P / (R * T)) * M
+        density_real = density / Z
+        d_rel = M / M_AIR
+        relative_d_rel = d_rel * Z_AIR / Z
+
+        HHV_mass_MJ_kg = Hs / M
+        LHV_mass_MJ_kg = Hi / M
+
+        Wobbe_index = HHV_vol_MJ_Nm3 / (d_rel ** 0.5)
+        Wobbe_real = (HHV_vol_MJ_Nm3 / Z) / (relative_d_rel ** 0.5)
+
+        data = [
+            ["Cp", Cp, "J/kg/K"],
+            ["Z mix", Z, "-"],
+            ["HHV mass (PCS)", HHV_mass_MJ_kg, "MJ/kg"],
+            ["LHV mass (PCI)", LHV_mass_MJ_kg, "MJ/kg"],
+            ["HHV vol", HHV_vol_MJ_Nm3, "MJ/Nm3"],
+            ["LHV vol", LHV_vol_MJ_Nm3, "MJ/Nm3"],
+            ["HHV real", HHV_vol_real_MJ_Nm3, "MJ/Nm3"],
+            ["LHV real", LHV_vol_real_MJ_Nm3, "MJ/Nm3"],
+            ["HHV vol", HHV_vol_kWh_Nm3, "kWh/Nm3"],
+            ["LHV vol", LHV_vol_kWh_Nm3, "kWh/Nm3"],
+            ["Density", density, "kg/Nm3"],
+            ["Density real", density_real, "kg/Nm3"],
+            ["Relative density", d_rel, "-"],
+            ["Relative density real", relative_d_rel, "-"],
+            ["Wobbe index", Wobbe_index, "MJ/Nm3"],
+            ["Wobbe real", Wobbe_real, "MJ/Nm3"],
+        ]
+        return pd.DataFrame(data, columns=["Property", "Value", "Unit"])
+
+

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

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

@@ -34,7 +34,6 @@ src/Distillation/PengRobinson.py
 src/Distillation/__init__.py
 src/Distillation/diag_enthalpy_models.py
 src/Distillation/reverse_engineer_enthalpies.py
-src/EnergySystemModels/__init__.py
 src/Facture/ATR_Transport_Distribution.py
 src/Facture/SONALGAZ_Elec.py
 src/Facture/SONALGAZ_gaz.py
@@ -151,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_Heating_Value.py
 src/ThermodynamicCycles/Combustion/__init__.py
 src/ThermodynamicCycles/Compressor/Compressor.py
 src/ThermodynamicCycles/Compressor/Compressor_m.py

{energysystemmodels-20260416002 → energysystemmodels-20260416004}/src/energysystemmodels.egg-info/top_level.txt

@@ -1,7 +1,6 @@
 AHU
 CEE
 Distillation
-EnergySystemModels
 Facture
 HeatTransfer
 IPMVP

energysystemmodels-20260416002/src/EnergySystemModels/__init__.py

@@ -1,35 +0,0 @@
-"""EnergySystemModels - Namespace package for energy system modeling.
-
-This package re-exports all sub-packages so that both import styles work:
-    from EnergySystemModels.PV.ProductionElectriquePV import SolarSystem
-    from PV.ProductionElectriquePV import SolarSystem  # legacy
-"""
-
-import importlib
-import sys
-import os
-
-# Add src/ to path so sub-packages resolve
-_src_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-if _src_dir not in sys.path:
-    sys.path.insert(0, _src_dir)
-
-# Lazy re-export of all sub-packages
-_subpackages = [
-    'AHU', 'CEE', 'Distillation', 'Facture', 'HeatTransfer',
-    'IPMVP', 'MeteoCiel', 'NodeEditor', 'OpenWeatherMap', 'PV',
-    'PinchAnalysis', 'PyqtSimulator', 'ThermodynamicCycles', 'TkinterGUI',
-]
-
-for _pkg in _subpackages:
-    try:
-        _mod = importlib.import_module(_pkg)
-        sys.modules[f'EnergySystemModels.{_pkg}'] = _mod
-        # Also register sub-modules already loaded
-        _prefix = f'{_pkg}.'
-        for _key in list(sys.modules.keys()):
-            if _key.startswith(_prefix):
-                _subname = _key[len(_prefix):]
-                sys.modules[f'EnergySystemModels.{_pkg}.{_subname}'] = sys.modules[_key]
-    except ImportError:
-        pass