pyphyschemtools 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

pyphyschemtools/.ipynb_checkpoints/cheminformatics-checkpoint.py

@@ -0,0 +1,230 @@
+############################################################
+#                       easy_rdkit
+############################################################
+from .visualID_Eng import fg, bg, hl
+from .core import centerTitle, centertxt
+
+import rdkit
+from rdkit import Chem
+from rdkit.Chem import AllChem, GetPeriodicTable, Draw, rdCoordGen
+import pandas as pd
+from rdkit.Chem.Draw import rdMolDraw2D
+from IPython.display import SVG
+from PIL import Image
+
+class easy_rdkit():
+    """
+    A helper class to analyze and visualize molecules using RDKit.
+    Provides tools for Lewis structure analysis and advanced 2D drawing.
+    """
+
+    def __init__(self,smiles, canonical=True):
+        """
+        Initialize the molecule object from a SMILES string.
+        
+        Args:
+            smiles (str): The SMILES representation of the molecule.
+            canonical (bool): If True, converts the SMILES to its canonical form 
+                              to ensure consistent atom numbering and uniqueness.
+        """
+        from rdkit import Chem
+        
+        mol = Chem.MolFromSmiles(smiles)
+        if mol is None:
+            raise ValueError(f"Invalid SMILES string: {smiles}")
+            
+        if canonical:
+            # Generate canonical isomeric SMILES
+            self.smiles = Chem.MolToSmiles(mol, isomericSmiles=True, canonical=True)
+            # Re-load the molecule from the canonical SMILES to sync atom indices
+            self.mol = Chem.MolFromSmiles(self.smiles)
+        else:
+            self.mol=mol
+            self.smiles = smiles
+        
+    def analyze_lewis(self):
+        """
+        Performs a Lewis structure analysis for each atom in the molecule.
+        Calculates valence electrons, lone pairs, formal charges, and octet rule compliance.
+        
+        Returns:
+            pd.DataFrame: A table containing detailed Lewis electronic data per atom.
+        """
+        if self.mol is None:
+            raise ValueError(f"Molécule invalide pour {self.smiles} (SMILES incorrect ?)")
+        
+        pt = GetPeriodicTable()
+        rows = []
+    
+        for atom in self.mol.GetAtoms():
+            Z = atom.GetAtomicNum()
+            valence_e = pt.GetNOuterElecs(Z)
+            bonding_e = atom.GetTotalValence()
+            formal_charge = atom.GetFormalCharge()
+            num_bonds = int(sum(bond.GetBondTypeAsDouble() for bond in atom.GetBonds()))
+            # hybridization = atom.GetHybridization()
+            nonbonding = valence_e - bonding_e - formal_charge
+    
+            lone_pairs = max(0, nonbonding // 2)
+    
+            if Z==1 or Z==2:  # règle du duet
+                target = 2
+            else:       # règle de l’octet
+                target = 8
+    
+            missing_e = max(0, target/2 - (bonding_e + 2*lone_pairs))
+            vacancies = int(missing_e)
+            total_e = 2*(lone_pairs + bonding_e)
+    
+            if total_e > 8:
+                octet_msg = "❌ hypercoordiné"
+            elif total_e < 8 and Z > 2:
+                octet_msg = "❌ électron-déficient"
+            elif total_e == 8:
+                octet_msg = "✅ octet"    
+            elif total_e == 2 and (Z == 1 or Z == 2):
+                octet_msg = "✅ duet"
+            else:
+                octet_msg = "🤔"
+            rows.append({
+                "index atome": atom.GetIdx(),
+                "symbole": atom.GetSymbol(),
+                "e- valence": valence_e,
+                "e- liants": bonding_e,
+                "charge formelle": formal_charge,
+                "doublets non-liants (DNL)": lone_pairs,
+                "lacunes ([])": vacancies,
+                "nombre de liaisons": num_bonds,
+                "e- total (octet ?)": total_e,
+                "O/H/D ?": octet_msg
+            })
+        return pd.DataFrame(rows)    
+            
+    def show_mol(self,
+                 size: tuple=(400,400),
+                 show_Lewis: bool=False,
+                 plot_conjugation: bool=False,
+                 plot_aromatic: bool=False,
+                 show_n: bool=False,
+                 show_hybrid: bool=False,
+                 show_H: bool=False,
+                 rep3D: bool=False,
+                 macrocycle: bool=False,
+                 highlightAtoms: list=[],
+                 legend: str=''
+                ):
+        """
+        Renders the molecule in 2D SVG format with optional property overlays.
+        
+        Args:
+            size (tuple): Drawing dimensions in pixels.
+            show_Lewis (bool): Annotates atoms with Lone Pairs and Vacancies.
+            plot_conjugation (bool): Highlights conjugated bonds in blue.
+            plot_aromatic (bool): Highlights aromatic rings in red.
+            show_n (bool): Displays atom indices.
+            show_hybrid (bool): Displays atom hybridization (sp3, sp2, etc.).
+            show_H (bool): Adds explicit Hydrogens to the drawing.
+            rep3D (bool): Computes a 3D-like conformation before drawing.
+            macrocycle (bool): Uses CoordGen for better rendering of large rings (e.g., Cyclodextrins).
+            highlightAtoms (list): List of indices to highlight.
+            legend (str): Title or legend text for the drawing.
+        """
+
+        def safe_add_hs():
+            try:
+                return Chem.AddHs(self.mol)
+            except Exception as e:
+                print(f"[Warning] Impossible d'ajouter les H pour {self.smiles} ({e}), on garde la version brute.")
+                return mol      
+        
+        if show_H and not show_Lewis:
+            mol = Chem.AddHs(self.mol)
+        else:
+            mol = self.mol
+        if show_Lewis:
+            mol = safe_add_hs()
+            self.mol = mol
+            df = self.analyze_lewis()
+            lewis_info = {row["index atome"]: (row["doublets non-liants (DNL)"], row["lacunes ([])"])
+                          for _, row in df.iterrows()}
+        else:
+            df = None
+            
+        if rep3D:
+            mol = Chem.AddHs(self.mol)
+            self.mol = mol
+            AllChem.EmbedMolecule(mol)
+
+        if macrocycle:
+            rdCoordGen.AddCoords(self.mol)
+                
+        d2d = rdMolDraw2D.MolDraw2DSVG(size[0],size[1])
+        
+        atoms = list(mol.GetAtoms())
+    
+        if plot_conjugation:
+            from collections import defaultdict
+            Chem.SetConjugation(mol)
+            colors = [(0.0, 0.0, 1.0, 0.4)]
+            athighlights = defaultdict(list)
+            arads = {}
+            bndhighlights = defaultdict(list)
+            for bond in mol.GetBonds():
+                aid1 = bond.GetBeginAtomIdx()
+                aid2 = bond.GetEndAtomIdx()
+            
+                if bond.GetIsConjugated():
+                    bid = mol.GetBondBetweenAtoms(aid1,aid2).GetIdx()
+                    bndhighlights[bid].append(colors[0])
+            
+        if plot_aromatic:
+            from collections import defaultdict
+            colors = [(1.0, 0.0, 0.0, 0.4)]
+            athighlights = defaultdict(list)
+            arads = {}
+            for a in atoms:
+                if a.GetIsAromatic():
+                    aid = a.GetIdx()
+                    athighlights[aid].append(colors[0])
+                    arads[aid] = 0.3
+                    
+            bndhighlights = defaultdict(list)
+            for bond in mol.GetBonds():
+                aid1 = bond.GetBeginAtomIdx()
+                aid2 = bond.GetEndAtomIdx()
+            
+                if bond.GetIsAromatic():
+                    bid = mol.GetBondBetweenAtoms(aid1,aid2).GetIdx()
+                    bndhighlights[bid].append(colors[0])
+            
+        if show_hybrid or show_Lewis:
+            for i,atom in enumerate(atoms):
+                # print(i,atom.GetDegree(),atom.GetImplicitValence())
+                note_parts = []
+                if show_hybrid and(atom.GetValence(rdkit.Chem.rdchem.ValenceType.IMPLICIT) > 0 or atom.GetDegree() > 1):
+                    note_parts.append(str(atom.GetHybridization()))
+                if show_Lewis and i in lewis_info:
+                    lp, vac = lewis_info[i]
+                    if lp > 0:
+                        note_parts.append(f" {lp}DNL")
+                    if vac > 0:
+                        note_parts.append(f" {vac}[]")
+                if note_parts:
+                    mol.GetAtomWithIdx(i).SetProp('atomNote',"".join(note_parts))
+                # print(f"Atom {i+1:3}: {atom.GetAtomicNum():3} {atom.GetSymbol():>2} {atom.GetHybridization()}")
+            if show_Lewis:
+                display(df)
+    
+        if show_n:
+            d2d.drawOptions().addAtomIndices=show_n
+    
+        if plot_aromatic or plot_conjugation:
+            d2d.DrawMoleculeWithHighlights(mol,legend,dict(athighlights),dict(bndhighlights),arads,{})
+        else:
+            d2d.DrawMolecule(mol,legend=legend, highlightAtoms=highlightAtoms)
+            
+        d2d.FinishDrawing()
+        display(SVG(d2d.GetDrawingText()))
+
+        return
+

pyphyschemtools/.ipynb_checkpoints/kinetics-checkpoint.py

@@ -0,0 +1,272 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from scipy.optimize import curve_fit
+import os
+import re
+
+class KORD:
+    """
+    Initialize the kinetic study with experimental data.
+    Reaction: alpha A = beta B
+    
+    Args:
+        - t_exp (array-like): Time values.
+        - G_exp (array-like): Measured physical quantity (Absorbance, Conductivity, etc.).
+
+    Fixed Parameters:
+        - alpha (float): Stoichiometric coefficient for A reactant (smallest positive integer). Default is 1.0.
+        - beta (float): Stoichiometric coefficient for B product (smallest positive integer). Default is 1.0.
+        - A0 (float): Initial concentration. Note: G_theo is independent of A0 for Order 1. Default is 1.0.
+
+    Adjustable Variables (Initial Guesses):
+        - k_guess (float, optional): Initial estimate for the rate constant. Default is 0.01.
+        - G_0_guess (float, optional): Initial estimate for the initial measured value (G at t=0). if None, it will be initialized as G_exp[0]
+        - G_inf_guess (float, optional): Initial estimate for the final measured value (G at infinity). if None, it will be initialized as G_exp[-1]
+        
+    Other Args:
+        - verbose (bool): If True, enables debug messages and detailed optimization logs.
+        - headers (tuple of strings): headers of the t_exp and G_exp arrays read in the excel file
+    """
+    
+    def __init__(self, t_exp, G_exp, headers, A0=1.0, alpha=1.0, beta=1.0, k_guess=0.01,
+                 G_0_guess = None, G_inf_guess = None, verbose=False):
+
+        # Force conversion to float arrays to prevent 'object' dtype issues.
+        # This ensures [0, 0.5, ...] (objects) become [0.0, 0.5, ...] (floats),
+        # allowing NumPy mathematical functions (like np.exp) to operate correctly.
+        self.t_exp = np.array(t_exp, dtype=float)
+        self.G_exp = np.array(G_exp, dtype=float)
+        self.headers = headers
+        # Ensure fixed parameters are treated as native floats.
+        # This prevents errors during optimization if values are passed as strings or tuples.
+        self.A0 = float(A0)
+        self.alpha = float(alpha)
+        self.beta = float(beta)
+
+        self.k_guess = k_guess
+        self.G_0_guess = G_0_guess if G_0_guess is not None else G_exp[0]
+        self.G_inf_guess = G_inf_guess if G_inf_guess is not None else G_exp[-1]
+        self.results = {}
+        self.verbose = verbose
+        # Color mapping for orders
+        self.order_colors = {0: 'red', 1: 'green', 2: 'blue'}
+        self.ansi_colors = {0: "\033[91m", 1: "\033[92m", 2: "\033[94m"}
+        self.reset = "\033[0m"
+        # t_fin = self.A0 / (self.alpha * self.k_guess)
+        # print(f"{t_fin=}")
+
+    @staticmethod
+    def load_from_excel(file_path, exp_number, sheet_name=0, show_data=True):
+        """
+        Static method to extract data from an Excel file.
+        Selects the pair of columns (t, G) corresponding to the experiment number.
+        Also loads parameters (A0, alpha, beta)
+        Format:
+            Row 1: Headers for t and G
+            Row 2: [A]0 value (in the G column)
+            Row 3: alpha value (in the G column)
+            Row 4: beta value (in the G column)
+            Row 5+: [t, G] data points
+        """
+        # 1. Check if file exists
+        if not os.path.exists(file_path):
+            print(f"❌ Error: The file '{file_path}' was not found.")
+            return None
+
+        try:
+            df = pd.read_excel(file_path, sheet_name=sheet_name)
+        except Exception as e:
+            print(f"❌ Error while reading the Excel file: {e}")
+            return None
+
+        idx_t, idx_G = 2*(exp_number-1), 2*(exp_number-1)+1
+
+        # --- Parameter Extraction (Now looking in the G column: idx_G) ---
+        def parse_param(val):
+            if isinstance(val, str):
+                match = re.search(r"(\d+\.?\d*)", val)
+                return float(match.group(1)) if match else 1.0
+            return float(val) if pd.notnull(val) else 1.0
+            
+        total_cols = len(df.columns)
+        num_experiments = total_cols // 2
+        print(f"Experiments detected: {num_experiments}")
+        
+        # Parameters are expected in rows 2, 3, and 4 of Excel (indices 0, 1, 2)
+        a0    = parse_param(df.iloc[0, idx_G])
+        alpha = parse_param(df.iloc[1, idx_G])
+        beta  = parse_param(df.iloc[2, idx_G])
+
+        # --- Data Extraction (From index 3 onwards) ---
+        data = df.iloc[3:, [idx_t, idx_G]].dropna()
+        
+        label_t = KORD._clean_pandas_suffix(df.columns[idx_t])
+        label_G = KORD._clean_pandas_suffix(df.columns[idx_G])
+        data.columns = [label_t, label_G]
+
+        print(f"✅ Loaded: {label_G} (Exp {exp_number})")
+        print(f"   [Parameters from {label_G}] A0: {a0:.4e} mol.L-1 | alpha: {alpha} | beta: {beta}\n")
+        
+        if show_data:
+            from IPython.display import display
+            display(data)
+        
+        return data.iloc[:, 0].values, data.iloc[:, 1].values, (label_t, label_G), (a0, alpha, beta)
+        
+    @staticmethod
+    def _clean_pandas_suffix(name):
+        """
+        Safely removes the '.1', '.2' suffixes added by Pandas for duplicate names.
+        Only matches a dot followed by digits at the VERY END of the string.
+        Example: 'mol.L-1.1' -> 'mol.L-1'
+        """
+        return re.sub(r'\.\d+$', '', str(name))
+        
+    def G0_theo(self, t, k, G0, Ginf):
+        """
+        Continuous linear model for optimization.
+        Allows A(t) to be negative so curve_fit can find the gradient.
+        """
+        return G0 + (float(self.alpha) * k * t / float(self.A0)) * (Ginf - G0)
+
+    def G1_theo(self, t, k, G0, Ginf):
+        """Model for Order 1 kinetics"""
+        return Ginf + np.exp(-self.alpha * k * t) * (G0 - Ginf)
+
+    def G2_theo(self, t, k, G0, Ginf):
+        """Model for Order 2 kinetics"""
+        return Ginf - (Ginf - G0) / (1 + self.A0 * self.alpha * k * t)
+
+    def fit(self, k_guess, G_0_guess, G_inf_guess, order=1):
+        """
+        Fits the chosen kinetic model to the experimental data, with order=order (Default: 1)
+        verbose=True: prints the initial guess vector p0
+        """
+        models = {0: self.G0_theo, 1: self.G1_theo, 2: self.G2_theo}
+        func = models[order]
+        
+        # Initial guess vector [k, G0, Ginf]
+        p0 = [self.k_guess, self.G_0_guess, self.G_inf_guess]
+        
+        # 1. Inspection des types des paramètres de classe
+        # print(f"--- TYPE CHECK (Order {order}) ---")
+        # print(f"self.A0:    {type(self.A0)} | Value: {self.A0}")
+        # print(f"self.alpha: {type(self.alpha)} | Value: {self.alpha}")
+        # print("----------------------------------")
+        # print(f"p0 types:  {[type(x) for x in p0]}")
+        # print(f"t_exp type: {type(self.t_exp)} | dtype: {self.t_exp.dtype}")
+        # print(f"G_exp type: {type(self.G_exp)} | dtype: {self.G_exp.dtype}")
+        # print("----------------------------------")
+        # print(self.t_exp)
+        # print("----------------------------------")
+        
+        if self.verbose:
+            c = self.ansi_colors[order]
+            print(f"{c}--- DEBUG INITIAL GUESS (Order {order}) ---{self.reset}")
+            print(f"  GUESS: k: {p0[0]:.2e} | G0: {p0[1]:.4f} | Ginf: {p0[2]:.4f}")
+            
+        try:
+            popt, _ = curve_fit(func, self.t_exp, self.G_exp, p0=p0)
+            k_opt, G0_opt, Ginf_opt = popt
+            G_theo = func(self.t_exp, *popt)
+
+            rmsd = np.sqrt(np.mean((self.G_exp - G_theo)**2))
+            
+            # t1/2 calculation
+            if order == 0: t_half = self.A0 / (2 * self.alpha * k_opt)
+            elif order == 1: t_half = np.log(2) / (self.alpha * k_opt)
+            else: t_half = 1 / (self.A0 * self.alpha * k_opt)
+
+            if self.verbose:
+                # Aligned exactly with the GUESS print for easy comparison
+                print(f"  OPTIM: k: {k_opt:.2e} | G0: {G0_opt:.4f} | Ginf: {Ginf_opt:.4f}")
+                print(f"  ✅ RMSD: {rmsd:.2e}")
+            
+            self.results[order] = {
+                'k': k_opt, 'G0': G0_opt, 'Ginf': Ginf_opt, 
+                'rmsd': rmsd, 't_half': t_half, 'G_theo': G_theo
+            }
+            return self.results[order]
+        except Exception as e:
+            print(f"Could not fit order {order}: {e}")
+            return None
+
+    def plot_all_fits(self):
+        """Plots experimental data and all three kinetic models for visual comparison."""
+        plt.figure(figsize=(10, 6))
+        ax1 = plt.gca()
+        
+        ax1.scatter(self.t_exp, self.G_exp, label="Experimental", color='black', s=35, alpha=0.5)
+
+        t_smooth = np.linspace(self.t_exp.min(), self.t_exp.max(), 500)
+        models = {0: self.G0_theo, 1: self.G1_theo, 2: self.G2_theo}
+
+        for order in [0, 1, 2]:
+            if order not in self.results:
+                self.fit(self.k_guess, self.G_0_guess, self.G_inf_guess, order)
+            
+            res = self.results[order]
+
+            G_smooth = models[order](t_smooth, res['k'], res['G0'], res['Ginf'])
+            # if order == 0:
+            #     t_fin = self.A0 / (self.alpha * res['k'])
+            #     print(f"{t_fin=}")
+            
+            ax1.plot(t_smooth, G_smooth, 
+                     label=f"Order {order} (RMSD: {res['rmsd']:.2e})", 
+                     color=self.order_colors[order], lw=2)
+
+        # 3. Add horizontal lines for the BEST model
+        best_order = self.get_best_order(verbose=False)
+        best_res = self.results[best_order]
+        best_color = self.order_colors[best_order]
+        
+        ax1.axhline(best_res['G0'], color=best_color, linestyle='--', alpha=0.6)
+        ax1.axhline(best_res['Ginf'], color=best_color, linestyle='--', alpha=0.6)
+
+        # 4. Add the second axis for the fitted values
+        ax2 = ax1.twinx()
+        ax2.set_ylim(ax1.get_ylim()) # Keep scales aligned
+        ax2.set_yticks([best_res['G0'], best_res['Ginf']])
+        ax2.set_yticklabels([f"G0_fit={best_res['G0']:.3f}", f"Ginf_fit={best_res['Ginf']:.3f}"])
+        ax2.tick_params(axis='y', labelcolor=best_color)
+        
+        ax1.set_xlabel("Time")
+        ax1.set_ylabel("Quantity G")
+        ax1.set_title(f"KORD Kinetic Models Comparison (0, 1, 2). Label exp = {self.headers[1]}")
+        ax1.legend()
+        # ax1.grid(True, linestyle=':', alpha=0.6)
+        plt.show()
+        
+    def get_best_order(self, verbose=True):
+        """Determines and prints the best model based on the lowest RMSD."""
+        for i in [0, 1, 2]:
+            if i not in self.results: self.fit(self.k_guess, self.G_0_guess,
+                                               self.G_inf_guess, i)
+            
+        best_order = min(self.results, key=lambda x: self.results[x]['rmsd'])
+        res = self.results[best_order]
+        
+        if verbose:
+            # ANSI Escape sequences for color in terminal/notebook
+            reset = self.reset
+            color = self.ansi_colors[best_order]
+    
+            print(f"--- {color}KORD CONCLUSION ---")
+            print(f"Best model: ORDER {best_order}")
+            print(f"Initial concentration: {self.A0:.3e} mol.L-1")
+            print(f"alpha: {self.alpha}")
+            print(f"beta: {self.beta}")
+            print()
+            print(f"RMSD: {res['rmsd']:.2e}")
+            print(f"k: {res['k']:.3e}")
+            print(f"t1/2: {res['t_half']:.3f}")
+            print()
+            print(f"G0_exp: {self.G_exp[0]:.3e}")
+            print(f"G0_fit: {res['G0']:.3e}")
+            print(f"Ginf_fit: {res['Ginf']:.3e}")
+            print(f"------------------------{reset}")
+            return 
+        else:
+            return best_order

pyphyschemtools/__init__.py

@@ -1,5 +1,5 @@
 # tools4pyPhysChem/__init__.py
-__version__ = "0.3.2"
+__version__ = "0.3.4"
 __last_update__ = "2026-02-03"
 
 import importlib

pyphyschemtools/kinetics.py

@@ -6,78 +6,113 @@ import os
 import re
 
 class KORD:
-    def __init__(self, t_exp, G_exp, headers, A0=1.0, alpha=1.0, k_guess=0.01, verbose=False):
-        """
-        Initialize the kinetic study with experimental data.
+    """
+    Initialize the kinetic study with experimental data.
+    Reaction: alpha A = beta B
+    
+    Args:
+        - t_exp (array-like): Time values.
+        - G_exp (array-like): Measured physical quantity (Absorbance, Conductivity, etc.).
+
+    Fixed Parameters:
+        - alpha (float): Stoichiometric coefficient for A reactant (smallest positive integer). Default is 1.0.
+        - beta (float): Stoichiometric coefficient for B product (smallest positive integer). Default is 1.0.
+        - A0 (float): Initial concentration. Note: G_theo is independent of A0 for Order 1. Default is 1.0.
+
+    Adjustable Variables (Initial Guesses):
+        - k_guess (float, optional): Initial estimate for the rate constant. Default is 0.01.
+        - G_0_guess (float, optional): Initial estimate for the initial measured value (G at t=0). if None, it will be initialized as G_exp[0]
+        - G_inf_guess (float, optional): Initial estimate for the final measured value (G at infinity). if None, it will be initialized as G_exp[-1]
         
-        Parameters:
-        t_exp (array-like): Time values.
-        G_exp (array-like): Measured physical quantity (Absorbance, Conductivity, etc.).
-        A0 (float): Initial concentration. Default is 1.0.
-        alpha (float): Stoichiometric coefficient. Default is 1.0.
-        k_guess (float): rate constant. Default is 0.01
-        verbose (bool): kind of debug variable
-        """
-        self.t_exp = np.array(t_exp)
-        self.G_exp = np.array(G_exp)
+    Other Args:
+        - verbose (bool): If True, enables debug messages and detailed optimization logs.
+        - headers (tuple of strings): headers of the t_exp and G_exp arrays read in the excel file
+    """
+    
+    def __init__(self, t_exp, G_exp, headers, A0=1.0, alpha=1.0, beta=1.0, k_guess=0.01,
+                 G_0_guess = None, G_inf_guess = None, verbose=False):
+
+        # Force conversion to float arrays to prevent 'object' dtype issues.
+        # This ensures [0, 0.5, ...] (objects) become [0.0, 0.5, ...] (floats),
+        # allowing NumPy mathematical functions (like np.exp) to operate correctly.
+        self.t_exp = np.array(t_exp, dtype=float)
+        self.G_exp = np.array(G_exp, dtype=float)
         self.headers = headers
-        self.A0 = A0
-        self.alpha = alpha
+        # Ensure fixed parameters are treated as native floats.
+        # This prevents errors during optimization if values are passed as strings or tuples.
+        self.A0 = float(A0)
+        self.alpha = float(alpha)
+        self.beta = float(beta)
+
         self.k_guess = k_guess
+        self.G_0_guess = G_0_guess if G_0_guess is not None else G_exp[0]
+        self.G_inf_guess = G_inf_guess if G_inf_guess is not None else G_exp[-1]
         self.results = {}
         self.verbose = verbose
         # Color mapping for orders
         self.order_colors = {0: 'red', 1: 'green', 2: 'blue'}
         self.ansi_colors = {0: "\033[91m", 1: "\033[92m", 2: "\033[94m"}
         self.reset = "\033[0m"
+        # t_fin = self.A0 / (self.alpha * self.k_guess)
+        # print(f"{t_fin=}")
 
     @staticmethod
     def load_from_excel(file_path, exp_number, sheet_name=0, show_data=True):
         """
         Static method to extract data from an Excel file.
         Selects the pair of columns (t, G) corresponding to the experiment number.
+        Also loads parameters (A0, alpha, beta)
+        Format:
+            Row 1: Headers for t and G
+            Row 2: [A]0 value (in the G column)
+            Row 3: alpha value (in the G column)
+            Row 4: beta value (in the G column)
+            Row 5+: [t, G] data points
         """
         # 1. Check if file exists
         if not os.path.exists(file_path):
             print(f"❌ Error: The file '{file_path}' was not found.")
-            return None, None
+            return None
 
         try:
             df = pd.read_excel(file_path, sheet_name=sheet_name)
         except Exception as e:
             print(f"❌ Error while reading the Excel file: {e}")
-            return None, None
+            return None
+
+        idx_t, idx_G = 2*(exp_number-1), 2*(exp_number-1)+1
 
+        # --- Parameter Extraction (Now looking in the G column: idx_G) ---
+        def parse_param(val):
+            if isinstance(val, str):
+                match = re.search(r"(\d+\.?\d*)", val)
+                return float(match.group(1)) if match else 1.0
+            return float(val) if pd.notnull(val) else 1.0
+            
         total_cols = len(df.columns)
         num_experiments = total_cols // 2
-        
         print(f"Experiments detected: {num_experiments}")
         
-        for i in range(1, num_experiments + 1):
-            it, ig = 2*(i-1), 2*(i-1)+1
-            # Clean names for display using regex
-            n_t = KORD._clean_pandas_suffix(df.columns[it])
-            n_g = KORD._clean_pandas_suffix(df.columns[ig])
-            pts = len(df.iloc[:, [it, ig]].dropna())
-            print(f"  [{i}] {n_t} | {n_g} ({pts} points)")
-        print(f"-----------------------\n")
-        
-        if exp_number < 1 or exp_number > num_experiments:
-            print(f"⚠️ Error: Experiment {exp_number} does not exist (Choice: 1 to {num_experiments}).")
-            return None, None, None, None
+        # Parameters are expected in rows 2, 3, and 4 of Excel (indices 0, 1, 2)
+        a0    = parse_param(df.iloc[0, idx_G])
+        alpha = parse_param(df.iloc[1, idx_G])
+        beta  = parse_param(df.iloc[2, idx_G])
+
+        # --- Data Extraction (From index 3 onwards) ---
+        data = df.iloc[3:, [idx_t, idx_G]].dropna()
         
-        # Position-based extraction
-        idx_t, idx_G = 2*(exp_number-1), 2*(exp_number-1)+1
         label_t = KORD._clean_pandas_suffix(df.columns[idx_t])
         label_G = KORD._clean_pandas_suffix(df.columns[idx_G])
-
-        data = df.iloc[:, [idx_t, idx_G]].dropna()
         data.columns = [label_t, label_G]
-        print(f"✅ Loaded: {label_G} (Exp {exp_number})\n")
+
+        print(f"✅ Loaded: {label_G} (Exp {exp_number})")
+        print(f"   [Parameters from {label_G}] A0: {a0:.4e} mol.L-1 | alpha: {alpha} | beta: {beta}\n")
         
-        if show_data: display(data)
+        if show_data:
+            from IPython.display import display
+            display(data)
         
-        return data.iloc[:, 0].values, data.iloc[:, 1].values, (label_t, label_G)
+        return data.iloc[:, 0].values, data.iloc[:, 1].values, (label_t, label_G), (a0, alpha, beta)
         
     @staticmethod
     def _clean_pandas_suffix(name):
@@ -89,21 +124,21 @@ class KORD:
         return re.sub(r'\.\d+$', '', str(name))
         
     def G0_theo(self, t, k, G0, Ginf):
-        """Model for Order 0 kinetics."""
-        t_fin = self.A0 / (self.alpha * k)
-        return np.where(t <= t_fin, 
-                        G0 + (self.alpha * k * t / self.A0) * (Ginf - G0), 
-                        Ginf)
+        """
+        Continuous linear model for optimization.
+        Allows A(t) to be negative so curve_fit can find the gradient.
+        """
+        return G0 + (float(self.alpha) * k * t / float(self.A0)) * (Ginf - G0)
 
     def G1_theo(self, t, k, G0, Ginf):
-        """Model for Order 1 kinetics."""
+        """Model for Order 1 kinetics"""
         return Ginf + np.exp(-self.alpha * k * t) * (G0 - Ginf)
 
     def G2_theo(self, t, k, G0, Ginf):
-        """Model for Order 2 kinetics."""
+        """Model for Order 2 kinetics"""
         return Ginf - (Ginf - G0) / (1 + self.A0 * self.alpha * k * t)
 
-    def fit(self, order=1, k_guess=None):
+    def fit(self, k_guess, G_0_guess, G_inf_guess, order=1):
         """
         Fits the chosen kinetic model to the experimental data, with order=order (Default: 1)
         verbose=True: prints the initial guess vector p0
@@ -111,10 +146,21 @@ class KORD:
         models = {0: self.G0_theo, 1: self.G1_theo, 2: self.G2_theo}
         func = models[order]
         
-        # Initial guess [k, G0, Ginf]
-        current_k = k_guess if k_guess is not None else self.k_guess
         # Initial guess vector [k, G0, Ginf]
-        p0 = [current_k, self.G_exp[0], self.G_exp[-1]]
+        p0 = [self.k_guess, self.G_0_guess, self.G_inf_guess]
+        
+        # 1. Inspection des types des paramètres de classe
+        # print(f"--- TYPE CHECK (Order {order}) ---")
+        # print(f"self.A0:    {type(self.A0)} | Value: {self.A0}")
+        # print(f"self.alpha: {type(self.alpha)} | Value: {self.alpha}")
+        # print("----------------------------------")
+        # print(f"p0 types:  {[type(x) for x in p0]}")
+        # print(f"t_exp type: {type(self.t_exp)} | dtype: {self.t_exp.dtype}")
+        # print(f"G_exp type: {type(self.G_exp)} | dtype: {self.G_exp.dtype}")
+        # print("----------------------------------")
+        # print(self.t_exp)
+        # print("----------------------------------")
+        
         if self.verbose:
             c = self.ansi_colors[order]
             print(f"{c}--- DEBUG INITIAL GUESS (Order {order}) ---{self.reset}")
@@ -124,6 +170,7 @@ class KORD:
             popt, _ = curve_fit(func, self.t_exp, self.G_exp, p0=p0)
             k_opt, G0_opt, Ginf_opt = popt
             G_theo = func(self.t_exp, *popt)
+
             rmsd = np.sqrt(np.mean((self.G_exp - G_theo)**2))
             
             # t1/2 calculation
@@ -148,46 +195,78 @@ class KORD:
     def plot_all_fits(self):
         """Plots experimental data and all three kinetic models for visual comparison."""
         plt.figure(figsize=(10, 6))
-        plt.scatter(self.t_exp, self.G_exp, label="Experimental", color='black', s=35, alpha=0.5)
+        ax1 = plt.gca()
+        
+        ax1.scatter(self.t_exp, self.G_exp, label="Experimental", color='black', s=35, alpha=0.5)
 
         t_smooth = np.linspace(self.t_exp.min(), self.t_exp.max(), 500)
         models = {0: self.G0_theo, 1: self.G1_theo, 2: self.G2_theo}
-        
+
         for order in [0, 1, 2]:
             if order not in self.results:
-                self.fit(order)
+                self.fit(self.k_guess, self.G_0_guess, self.G_inf_guess, order)
             
             res = self.results[order]
 
             G_smooth = models[order](t_smooth, res['k'], res['G0'], res['Ginf'])
+            # if order == 0:
+            #     t_fin = self.A0 / (self.alpha * res['k'])
+            #     print(f"{t_fin=}")
             
-            plt.plot(t_smooth, G_smooth, 
+            ax1.plot(t_smooth, G_smooth, 
                      label=f"Order {order} (RMSD: {res['rmsd']:.2e})", 
                      color=self.order_colors[order], lw=2)
+
+        # 3. Add horizontal lines for the BEST model
+        best_order = self.get_best_order(verbose=False)
+        best_res = self.results[best_order]
+        best_color = self.order_colors[best_order]
+        
+        ax1.axhline(best_res['G0'], color=best_color, linestyle='--', alpha=0.6)
+        ax1.axhline(best_res['Ginf'], color=best_color, linestyle='--', alpha=0.6)
+
+        # 4. Add the second axis for the fitted values
+        ax2 = ax1.twinx()
+        ax2.set_ylim(ax1.get_ylim()) # Keep scales aligned
+        ax2.set_yticks([best_res['G0'], best_res['Ginf']])
+        ax2.set_yticklabels([f"G0_fit={best_res['G0']:.3f}", f"Ginf_fit={best_res['Ginf']:.3f}"])
+        ax2.tick_params(axis='y', labelcolor=best_color)
         
-        plt.xlabel("Time")
-        plt.ylabel("Quantity G")
-        plt.title(f"KORD Kinetic Models Comparison (0, 1, 2). Label exp = {self.headers[1]}")
-        plt.legend()
-        plt.grid(True, linestyle=':', alpha=0.6)
+        ax1.set_xlabel("Time")
+        ax1.set_ylabel("Quantity G")
+        ax1.set_title(f"KORD Kinetic Models Comparison (0, 1, 2). Label exp = {self.headers[1]}")
+        ax1.legend()
+        # ax1.grid(True, linestyle=':', alpha=0.6)
         plt.show()
         
-    def get_best_order(self):
+    def get_best_order(self, verbose=True):
         """Determines and prints the best model based on the lowest RMSD."""
         for i in [0, 1, 2]:
-            if i not in self.results: self.fit(i)
+            if i not in self.results: self.fit(self.k_guess, self.G_0_guess,
+                                               self.G_inf_guess, i)
             
         best_order = min(self.results, key=lambda x: self.results[x]['rmsd'])
         res = self.results[best_order]
         
-        # ANSI Escape sequences for color in terminal/notebook
-        reset = self.reset
-        color = self.ansi_colors[best_order]
-
-        print(f"--- {color}KORD CONCLUSION ---")
-        print(f"Best model: ORDER {best_order}")
-        print(f"RMSD: {res['rmsd']:.2e}")
-        print(f"k: {res['k']:.3e}")
-        print(f"t1/2: {res['t_half']:.3f}")
-        print(f"------------------------{reset}")
-        return
+        if verbose:
+            # ANSI Escape sequences for color in terminal/notebook
+            reset = self.reset
+            color = self.ansi_colors[best_order]
+    
+            print(f"--- {color}KORD CONCLUSION ---")
+            print(f"Best model: ORDER {best_order}")
+            print(f"Initial concentration: {self.A0:.3e} mol.L-1")
+            print(f"alpha: {self.alpha}")
+            print(f"beta: {self.beta}")
+            print()
+            print(f"RMSD: {res['rmsd']:.2e}")
+            print(f"k: {res['k']:.3e}")
+            print(f"t1/2: {res['t_half']:.3f}")
+            print()
+            print(f"G0_exp: {self.G_exp[0]:.3e}")
+            print(f"G0_fit: {res['G0']:.3e}")
+            print(f"Ginf_fit: {res['Ginf']:.3e}")
+            print(f"------------------------{reset}")
+            return 
+        else:
+            return best_order

{pyphyschemtools-0.3.2.dist-info → pyphyschemtools-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyphyschemtools
-Version: 0.3.2
+Version: 0.3.4
 Summary: A comprehensive Python toolbox for physical chemistry and cheminformatics
 Author-email: "Romuald POTEAU, LPCNO" <romuald.poteau@utoulouse.fr>
 Project-URL: Repository, https://github.com/rpoteau/pyphyschemtools

{pyphyschemtools-0.3.2.dist-info → pyphyschemtools-0.3.4.dist-info}/RECORD

@@ -1,13 +1,12 @@
 pyphyschemtools/.readthedocs.yaml,sha256=ZTw2bOyF9p3JpeF8Ux0fwhYWO6KHCsroNEOvnXxbYGM,469
-pyphyschemtools/.visualID_Eng.py.swp,sha256=e47tjB8u-H3ZCAru897onACs2xbR2XhrLBMLhqrrzS8,20480
 pyphyschemtools/Chem3D.py,sha256=NuhoLvWpeATO88UklXg-3XqPpIiHqvP__b2tLHrypL8,34718
 pyphyschemtools/ML.py,sha256=kR_5vm5TOOjVef8uXCW57y7685ts6K6OkRMBYKP_cYw,1599
 pyphyschemtools/PeriodicTable.py,sha256=LfLSFOzRkirREQlwfeSR3TyvgHyjGiltIZXNmvBkbhQ,13526
-pyphyschemtools/__init__.py,sha256=zHorm9gKJs_YFIpVg33jdWp4e6p9EhgKVBBB6XRDZ_k,1442
+pyphyschemtools/__init__.py,sha256=CqTWs1geGKDrA9V_CnzNFTukpwQ8-z9qQl7FwluLrqo,1442
 pyphyschemtools/aithermo.py,sha256=kF8wtuYIJzkUKM2AGubmn9haAJKz-XaBskZ7HjivJeY,14984
 pyphyschemtools/cheminformatics.py,sha256=Qps_JSYWOzZQcXwKElI1iWGjWAPDgwmtDKuJwONsKmI,8977
 pyphyschemtools/core.py,sha256=5fRu83b125w2p_m2H521fLjktyswZHJXNKww1wfBwbU,4847
-pyphyschemtools/kinetics.py,sha256=3YyzzQ7FKZ7wNALRDsLNLhpZpDp38LHWOUfMojsh8hE,7696
+pyphyschemtools/kinetics.py,sha256=IVZSY38ai9yO8GyMVXpywfzKMZ6K8Q3n-2UiElOoCyA,11737
 pyphyschemtools/spectra.py,sha256=eCN9X6pK5k4KMcfWUskedWYwtxbrmJH_BvFXU1GZfVo,21702
 pyphyschemtools/survey.py,sha256=YjZhhb8GFVNXoXSCxgGdZFqmCtNCx7O_uiFVCcGBYYo,24268
 pyphyschemtools/sympyUtilities.py,sha256=LgLloh9dD9Mkff2WNoSnrJa3hxK0axOnK-4GS9wPtT0,1545
@@ -17,7 +16,9 @@ pyphyschemtools/visualID_Eng.py,sha256=W-rYHg4g090JUpTJxtbBZVZ2lXShq8f0ALeiNjFqW
 pyphyschemtools/.ipynb_checkpoints/Chem3D-checkpoint.py,sha256=NuhoLvWpeATO88UklXg-3XqPpIiHqvP__b2tLHrypL8,34718
 pyphyschemtools/.ipynb_checkpoints/PeriodicTable-checkpoint.py,sha256=LfLSFOzRkirREQlwfeSR3TyvgHyjGiltIZXNmvBkbhQ,13526
 pyphyschemtools/.ipynb_checkpoints/aithermo-checkpoint.py,sha256=kF8wtuYIJzkUKM2AGubmn9haAJKz-XaBskZ7HjivJeY,14984
+pyphyschemtools/.ipynb_checkpoints/cheminformatics-checkpoint.py,sha256=Qps_JSYWOzZQcXwKElI1iWGjWAPDgwmtDKuJwONsKmI,8977
 pyphyschemtools/.ipynb_checkpoints/core-checkpoint.py,sha256=5fRu83b125w2p_m2H521fLjktyswZHJXNKww1wfBwbU,4847
+pyphyschemtools/.ipynb_checkpoints/kinetics-checkpoint.py,sha256=IVZSY38ai9yO8GyMVXpywfzKMZ6K8Q3n-2UiElOoCyA,11737
 pyphyschemtools/.ipynb_checkpoints/spectra-checkpoint.py,sha256=eCN9X6pK5k4KMcfWUskedWYwtxbrmJH_BvFXU1GZfVo,21702
 pyphyschemtools/.ipynb_checkpoints/survey-checkpoint.py,sha256=Rcw0xb0_nwsxETleB1C2xjKmZfrUw4PXDm48CMSptHU,45816
 pyphyschemtools/.ipynb_checkpoints/sympyUtilities-checkpoint.py,sha256=LgLloh9dD9Mkff2WNoSnrJa3hxK0axOnK-4GS9wPtT0,1545
@@ -86,8 +87,8 @@ pyphyschemtools/resources/svg/qrcode-pyPhysChem.png,sha256=rP7X-9eHL7HYj4ffmwBML
 pyphyschemtools/resources/svg/repository-open-graph-template.png,sha256=UlnW5BMkLGOv6IAnEi7teDYS_5qeSLmpxRMT9r9m-5Q,51470
 pyphyschemtools/resources/svg/tools4pyPC_banner.png,sha256=z7o_kBK0sIBsXHEJrT2GyLHu-0T0T3S8YkWcpxR2joA,89058
 pyphyschemtools/resources/svg/tools4pyPC_banner.svg,sha256=BXxXHra9vwahaiet1IJW4q8QLA03crSeCIQYo30VpN8,651579
-pyphyschemtools-0.3.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-pyphyschemtools-0.3.2.dist-info/METADATA,sha256=FSgiMf_Yn_gfmV-X7BwpyLNRs6OkkEJARWeMemRX_yQ,1328
-pyphyschemtools-0.3.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pyphyschemtools-0.3.2.dist-info/top_level.txt,sha256=N92w2qk4LQ42OSdzK1R2h_x1CyUFaFBOrOML2RnmFgE,16
-pyphyschemtools-0.3.2.dist-info/RECORD,,
+pyphyschemtools-0.3.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pyphyschemtools-0.3.4.dist-info/METADATA,sha256=hb_ShyL8oPomJKdJODh18tFkUEnkjNkrn1M4PvRTE58,1328
+pyphyschemtools-0.3.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pyphyschemtools-0.3.4.dist-info/top_level.txt,sha256=N92w2qk4LQ42OSdzK1R2h_x1CyUFaFBOrOML2RnmFgE,16
+pyphyschemtools-0.3.4.dist-info/RECORD,,