EnergySystemModels 20260416003__tar.gz → 20260416004__tar.gz

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

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

@@ -11,7 +11,7 @@ setup(
     name='energysystemmodels',
 
 
-    version='20260416003',
+    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-20260416003 → energysystemmodels-20260416004}/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-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-20260416003 → energysystemmodels-20260416004}/src/energysystemmodels.egg-info/PKG-INFO

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

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

energysystemmodels-20260416003/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