MultiOptPy 1.20.3__py3-none-any.whl → 1.20.5__py3-none-any.whl

multioptpy/Calculator/ase_calculation_tools.py

@@ -22,6 +22,8 @@ from multioptpy.Calculator.ase_tools.fairchem import ASE_FAIRCHEM
 from multioptpy.Calculator.ase_tools.mace import ASE_MACE
 from multioptpy.Calculator.ase_tools.mopac import ASE_MOPAC
 from multioptpy.Calculator.ase_tools.pygfn0 import ASE_GFN0
+from multioptpy.Calculator.ase_tools.gxtb_dev import ASE_gxTB_Dev
+
 
 """
 referrence:
@@ -89,7 +91,9 @@ class Calculation:
         if self.software_type == "gaussian":
             print("Calculating exact Hessian using Gaussian...")
             exact_hess = calc_obj.calc_analytic_hessian()  # in hartree/Bohr^2
-        
+        elif self.software_type == "orca":
+            hess_path = calc_obj.run_frequency_analysis()
+            exact_hess = calc_obj.get_hessian_matrix(hess_path)
         else:
             vib = Vibrations(atoms=calc_obj.atom_obj, delta=0.001, name="z_hess_"+timestamp)
             vib.run()
@@ -124,7 +128,7 @@ class Calculation:
             file_list = glob.glob(file_directory+"/*_[0-9].xyz")
     
         for num, input_file in enumerate(file_list):
-            try:
+            if True:#try:
                 if geom_num_list is None:
                     positions, _, electric_charge_and_multiplicity = xyz2list(input_file, electric_charge_and_multiplicity)
                 else:
@@ -155,11 +159,11 @@ class Calculation:
                 elif iter % self.FC_COUNT == 0 or self.hessian_flag:
                     # exact numerical hessian
                     _ = self.calc_exact_hess(calc_obj, positions, element_list)             
-            except Exception as error:
-                print(error)
-                print("This molecule could not be optimized.")
-                finish_frag = True
-                return np.array([0]), np.array([0]), np.array([0]), finish_frag 
+            #except Exception as error:
+            #    print(error)
+            #    print("This molecule could not be optimized.")
+            #    finish_frag = True
+            #    return np.array([0]), np.array([0]), np.array([0]), finish_frag 
 
         positions /= self.bohr2angstroms
         self.energy = e
@@ -286,7 +290,10 @@ class ASEEngine(CalculationEngine):
                     timestamp = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S_%f")[:-2]
                     if software_type == "gaussian":
                         exact_hess = calc_obj.calc_analytic_hessian()  # in hartree/Bohr^2
-                        exact_hess = exact_hess 
+                   
+                    elif software_type == "orca":
+                        hess_path = calc_obj.run_frequency_analysis()
+                        exact_hess = calc_obj.get_hessian_matrix(hess_path)
                     else:
                         vib = Vibrations(atoms=calc_obj.atom_obj, delta=0.001, name="z_hess_"+timestamp)
                         vib.run()
@@ -431,6 +438,12 @@ def setup_calculator(atom_obj, software_type, electric_charge_and_multiplicity,
                              input_file=input_file)
         return calc_obj
 
+    if software_type == "gxtb_dev":
+        calc_obj = ASE_gxTB_Dev(atom_obj=atom_obj,
+                             electric_charge_and_multiplicity=electric_charge_and_multiplicity,
+                             software_type=software_type)
+        return calc_obj
+    
     # Unknown software type
     raise ValueError(f"Unsupported software type: {software_type}")
 

multioptpy/Calculator/ase_tools/gxtb_dev.py

@@ -0,0 +1,41 @@
+class ASE_gxTB_Dev:
+    """
+    Wrapper class to set up and run g-xTB (preliminary version) calculations via ASE.
+    $ pip install pygxtb==0.7.0
+    
+    """
+    def __init__(self, **kwargs):
+        
+        self.atom_obj = kwargs.get('atom_obj', None)
+        self.electric_charge_and_multiplicity = kwargs.get('electric_charge_and_multiplicity', None)
+        self.software_path = kwargs.get('software_path', None)
+        self.software_type = kwargs.get('software_type', None)
+        from pygxtb import PygxTB
+        self.pygxtb = PygxTB
+        
+    def set_calculator(self):
+        """
+        Sets the ASE calculator object based on software_type.
+        """
+        
+        charge = 0  # Default charge
+        if self.electric_charge_and_multiplicity is not None:
+            try:
+                # Get charge from [charge, multiplicity] list
+                charge = int(self.electric_charge_and_multiplicity[0])
+            except (IndexError, TypeError, ValueError):
+                print(f"Warning: Could not parse charge from {self.electric_charge_and_multiplicity}. Defaulting to 0.")
+                pass
+        
+        # Instantiate GFN0 class and pass the charge
+        gxtb_calc = self.pygxtb(charge=charge)
+        return gxtb_calc
+        
+
+    def run(self):
+        """
+        Attaches the calculator to the atoms object and returns it.
+        """
+        calc_obj = self.set_calculator()
+        self.atom_obj.calc = calc_obj
+        return self.atom_obj

multioptpy/Calculator/ase_tools/orca.py

@@ -1,22 +1,236 @@
 import os
+import shutil
+import subprocess
+import numpy as np
+from ase.calculators.orca import ORCA, OrcaProfile
+from ase.data import atomic_numbers
+
+"""
+Please specify the absolute path to the ORCA executable in software_path.conf using the format orca::<path>. For Linux, provide the path to the binary (e.g., /absolute/path/to/orca), and for Windows, provide the path to the executable file (e.g., C:\absolute\path\to\orca.exe).
+"""
+
 
 class ASE_ORCA:
+    TARGET_ORCA_VERSION = '6.1.0'
+
     def __init__(self, **kwargs):
         self.atom_obj = kwargs.get('atom_obj', None)
         self.electric_charge_and_multiplicity = kwargs.get('electric_charge_and_multiplicity', None)
-        self.input_file = kwargs.get('input_file', None)
+        
+        # NOTE: self.input_file is updated in _setup_calculator to enforce 'orca.inp' in CWD.
+        raw_input_file = kwargs.get('input_file', 'orca.inp')
+        self.input_file = os.path.abspath(raw_input_file).replace('\\', '/')
+        
         self.orca_path = kwargs.get('orca_path', None)
-        self.functional = kwargs.get('functional', None)
-        self.basis_set = kwargs.get('basis_set', None)
-    
+        self.functional = kwargs.get('functional', 'B3LYP')
+        self.basis_set = kwargs.get('basis_set', 'def2-SVP')
+
+        # Optional ORCA input blocks (raw string)
+        self.orca_blocks = kwargs.get('orca_blocks', '')
+
+        # Auto-fix for unsupported Pople basis sets on heavy elements
+        self.auto_fix_basis = kwargs.get('auto_fix_basis', True)
+        self.heavy_atom_basis = kwargs.get('heavy_atom_basis', 'def2-SVP')
+
+    def _resolve_orca_exe(self, provided_path):
+        """
+        Resolve the absolute path to the ORCA executable.
+        Handles directories, stripping whitespace from config files, and WSL/Windows paths.
+        """
+        if not provided_path:
+            return None
+        
+        # CRITICAL FIX: Strip whitespace/newlines that might come from config parsing
+        clean_path = provided_path.strip()
+        # Expand ~ to home directory if present
+        clean_path = os.path.expanduser(clean_path)
+        clean_path = os.path.normpath(clean_path)
+
+        candidates = []
+        # If the path is a directory, look for the executable inside it
+        if os.path.isdir(clean_path):
+            candidates.append(os.path.join(clean_path, 'orca'))
+            candidates.append(os.path.join(clean_path, 'orca.exe'))
+        else:
+            # If it's a file path (or doesn't exist yet), use it as is
+            candidates.append(clean_path)
+
+        for candidate in candidates:
+            # Check if file exists
+            if os.path.exists(candidate) and os.path.isfile(candidate):
+                return os.path.abspath(candidate)
+            
+            # Check system PATH
+            resolved = shutil.which(candidate)
+            if resolved and os.path.exists(resolved):
+                return os.path.abspath(resolved)
+
+        # Use repr() in error message to reveal hidden characters like \n
+        candidate_reprs = [repr(c) for c in candidates]
+        raise FileNotFoundError(f"Cannot locate ORCA executable. Checked: {', '.join(candidate_reprs)}")
+
+    def _is_pople_basis(self, basis_name):
+        if not basis_name: return False
+        b = basis_name.strip().lower()
+        return b.startswith("6-31") or b.startswith("6-311")
+
+    def _get_heavy_elements_for_pople(self):
+        if self.atom_obj is None: return []
+        symbols = self.atom_obj.get_chemical_symbols()
+        return sorted({s for s in symbols if atomic_numbers.get(s, 0) > 30})
+
+    def _build_orca_blocks(self):
+        blocks = (self.orca_blocks or "").strip()
+        heavy_elements = []
+        if self._is_pople_basis(self.basis_set):
+            heavy_elements = self._get_heavy_elements_for_pople()
+
+        if heavy_elements:
+            if not self.auto_fix_basis:
+                raise ValueError("Unsupported Pople basis for heavy elements.")
+
+            basis_lines = ["%basis"]
+            for elem in heavy_elements:
+                # Per user instruction: No ECP, just GTO
+                basis_lines.append(f'  NewGTO {elem} "{self.heavy_atom_basis}"')
+            basis_lines.append("end")
+
+            if blocks:
+                blocks = blocks + "\n" + "\n".join(basis_lines)
+            else:
+                blocks = "\n".join(basis_lines)
+
+        return blocks if blocks else ""
+
+    def _print_orca_output_on_error(self):
+        """Helper to print ORCA output file content if it exists."""
+        if not hasattr(self, 'input_file'): return
+        
+        out_file = os.path.splitext(self.input_file)[0] + ".out"
+        if os.path.exists(out_file):
+            print(f"\n--- ORCA OUTPUT ({out_file}) ---")
+            try:
+                with open(out_file, 'r', encoding='utf-8', errors='replace') as f:
+                    content = f.read()
+                    print(content[-3000:] if len(content) > 3000 else content)
+            except Exception as e:
+                print(f"Failed to read output file: {e}")
+            print("--- END ORCA OUTPUT ---\n")
+        else:
+            print(f"\n--- ORCA OUTPUT NOT FOUND ({out_file}) ---\n")
+
+    def _setup_calculator(self, task_keyword):
+        # Force usage of Current Working Directory + "orca.inp"
+        cwd = os.getcwd()
+        label_path = os.path.join(cwd, 'orca').replace('\\', '/')
+        self.input_file = label_path + '.inp'
+        
+        print(f"DEBUG: ASE Label Path : {label_path}")
+
+        simple_input = f"{self.functional} {self.basis_set} {task_keyword}"
+        
+        profile_obj = None
+        if self.orca_path:
+            real_exe_path = self._resolve_orca_exe(self.orca_path)
+            orca_dir = os.path.dirname(real_exe_path)
+            path_env = os.environ.get('PATH', '')
+            if orca_dir not in path_env:
+                os.environ['PATH'] = orca_dir + os.pathsep + path_env
+
+            ase_safe_path = real_exe_path.replace('\\', '/')
+            profile_obj = OrcaProfile(ase_safe_path)
+            print(f"DEBUG: ORCA Executable: {ase_safe_path}")
+
+        orca_blocks = self._build_orca_blocks()
+        
+        calc = ORCA(
+            label=label_path,
+            profile=profile_obj,
+            charge=int(self.electric_charge_and_multiplicity[0]),
+            mult=int(self.electric_charge_and_multiplicity[1]),
+            orcasimpleinput=simple_input,
+            orcablocks=orca_blocks
+        )
+        
+        self.atom_obj.calc = calc
+        return self.atom_obj
+
     def run(self):
-       
-        from ase.calculators.orca import ORCA
-        input_dir = os.path.dirname(self.input_file)
-        self.atom_obj.calc = ORCA(label=input_dir,
-                            profile=self.orca_path,
-                            charge=int(self.electric_charge_and_multiplicity[0]),
-                            mult=int(self.electric_charge_and_multiplicity[1]),
-                            orcasimpleinput=self.functional+' '+self.basis_set)
-                            #orcablocks='%pal nprocs 16 end')
-        return self.atom_obj
+        self._setup_calculator("EnGrad")
+        print(f"--- Starting Gradient Calculation (ORCA {self.TARGET_ORCA_VERSION}) ---")
+        try:
+            forces = self.atom_obj.get_forces()
+            potential_energy = self.atom_obj.get_potential_energy()
+            print("Gradient calculation completed.")
+            return forces, potential_energy
+        except subprocess.CalledProcessError as e:
+            print(f"CRITICAL: ORCA execution failed with exit code {e.returncode}")
+            self._print_orca_output_on_error()
+            raise e
+        except Exception as e:
+            print(f"CRITICAL: An unexpected error occurred: {e}")
+            self._print_orca_output_on_error()
+            raise e
+
+    def run_frequency_analysis(self):
+        print(f"--- Starting Frequency Calculation (ORCA {self.TARGET_ORCA_VERSION}) ---")
+        self._setup_calculator("Freq")
+        try:
+            self.atom_obj.get_potential_energy()
+            print("Frequency calculation completed.")
+            # Use self.input_file to construct hess_path instead of relying on calc.label
+            hess_path = os.path.splitext(self.input_file)[0] + ".hess"
+            return hess_path
+        except subprocess.CalledProcessError as e:
+            print(f"CRITICAL: ORCA Frequency execution failed with exit code {e.returncode}")
+            self._print_orca_output_on_error()
+            raise e
+        except Exception as e:
+            print(f"CRITICAL: An unexpected error occurred during frequency analysis: {e}")
+            self._print_orca_output_on_error()
+            raise e
+
+    def get_hessian_matrix(self, hess_file_path=None):
+        if hess_file_path is None:
+            # Default to orca.hess in the same dir as input_file
+            input_dir = os.path.dirname(self.input_file)
+            hess_file_path = os.path.join(input_dir, 'orca.hess')
+
+        if not os.path.exists(hess_file_path):
+            raise FileNotFoundError(f"Hessian file not found: {hess_file_path}")
+
+        print(f"Reading Hessian from: {hess_file_path}")
+        
+        with open(hess_file_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+
+        hessian_matrix = None
+        iterator = iter(lines)
+        for line in iterator:
+            if "$hessian" in line:
+                dim_line = next(iterator).strip().split()
+                # Parse dimensions: square matrix usually provides just one dimension
+                if len(dim_line) == 1:
+                    n_rows = int(dim_line[0])
+                    n_cols = n_rows
+                else:
+                    n_rows, n_cols = map(int, dim_line[:2])
+                
+                hessian_matrix = np.zeros((n_rows, n_cols))
+                col_pointer = 0
+                while col_pointer < n_cols:
+                    header = next(iterator).strip()
+                    if not header: break
+                    col_indices = [int(c) for c in header.split()]
+                    for r in range(n_rows):
+                        row_data = next(iterator).strip().split()
+                        row_idx = int(row_data[0])
+                        values = [float(x) for x in row_data[1:]]
+                        for i, val in enumerate(values):
+                            hessian_matrix[row_idx, col_indices[i]] = val
+                    col_pointer += len(col_indices)
+                break
+
+        if hessian_matrix is None:
+            raise ValueError("Could not find $hessian block in the file.")
+        return hessian_matrix

multioptpy/OtherMethod/spring_pair_method.py

@@ -0,0 +1,314 @@
+import numpy as np
+import os
+import shutil
+
+from multioptpy.Utils.calc_tools import Calculationtools
+from multioptpy.Visualization.visualization import Graph
+
+class SpringPairMethod:
+    """
+    Implementation of the Spring Pair Method (SPM) with Adaptive Step Size & Momentum.
+    Modified to accept a SINGLE initial structure and auto-generate the second one via perturbation.
+    """
+    def __init__(self, config):
+        self.config = config
+        
+        # --- TUNING PARAMETERS ---
+        self.k_spring = 10.0 
+        self.l_s = max(getattr(self.config, 'L_covergence', 0.1), 0.1)
+        self.initial_drift_step = 0.01
+        self.climb_step_size = 0.50 
+        self.drift_limit = 100
+        self.momentum = 0.3
+        self.MAX_FORCE_THRESHOLD = 0.00100
+        self.RMS_FORCE_THRESHOLD = 0.00005
+        
+        # Magnitude of random perturbation to generate Image 2 (Bohr)
+        self.perturbation_scale = 0.1 
+        
+    def RMS(self, mat):
+        return np.sqrt(np.mean(mat**2))
+    
+    def print_info(self, dat, phase):
+        print(f"[[{phase} information]]")
+        print(f"                                                image_1               image_2")
+        print(f"energy (Hartree)                       : {dat['energy_1']:.8f}   {dat['energy_2']:.8f}")
+        print(f"gradient RMS                           : {self.RMS(dat['gradient_1']):.6f}   {self.RMS(dat['gradient_2']):.6f}")
+        
+        if "perp_force_1" in dat:
+            print(f"perp_force (Drift)                     : {self.RMS(dat['perp_force_1']):.6f}   {self.RMS(dat['perp_force_2']):.6f}")
+            print(f"spring_force                           : {self.RMS(dat['spring_force_1']):.6f}   {self.RMS(dat['spring_force_2']):.6f}")
+            
+        print(f"spring_length (Bohr)                   : {dat['spring_length']:.6f}")
+        step_info = dat.get('step_size', 0)
+        print(f"DEBUG: k={self.k_spring:.1f}, step={step_info:.6f}")
+        print("-" * 80)
+        return
+
+    def get_spring_vectors(self, geom_1, geom_2):
+        diff = geom_2 - geom_1
+        dist = np.linalg.norm(diff)
+        if dist < 1e-10:
+            rand_vec = np.random.randn(*diff.shape)
+            unit_vec = rand_vec / np.linalg.norm(rand_vec)
+            dist = 1e-10 
+        else:
+            unit_vec = diff / dist
+        return dist, unit_vec
+
+    def decompose_gradient(self, gradient, unit_vec):
+        grad_flat = gradient.flatten()
+        vec_flat = unit_vec.flatten()
+        grad_par_mag = np.dot(grad_flat, vec_flat)
+        grad_par = grad_par_mag * unit_vec
+        grad_perp = gradient - grad_par
+        return grad_par, grad_perp
+
+    def _generate_perturbed_structure(self, geom, scale):
+        """Generate a new structure by adding random perturbation to the given geometry."""
+        # Generate random noise
+        noise = np.random.randn(*geom.shape)
+        # Normalize to unit vectors per atom to distribute perturbation evenly
+        norms = np.linalg.norm(noise, axis=1, keepdims=True)
+        noise = noise / (norms + 1e-10)
+        # Scale the noise
+        perturbation = noise * scale
+        return geom + perturbation
+
+    def iteration(self, file_directory_1, SP1, element_list, electric_charge_and_multiplicity, FIO1):
+        """
+        Main SPM Optimization Loop.
+        Accepts ONE initial structure. Image 2 is auto-generated.
+        """
+        G = Graph(self.config.iEIP_FOLDER_DIRECTORY)
+        ENERGY_LIST_1, ENERGY_LIST_2 = [], []
+        GRAD_LIST_1, GRAD_LIST_2 = [], []
+
+        # --- Initialize Image 2 from Image 1 ---
+        print("### Initializing SPM ###")
+        print(f"Base Structure (Image 1): {file_directory_1}")
+        
+        # 1. Get initial geometry of Image 1
+        # We perform a dummy single point calculation or just read the geom if possible.
+        # Here we run SP1 to get the geometry and energy reliably.
+        init_energy, init_grad, init_geom, err = SP1.single_point(
+            file_directory_1, element_list, "init_check", 
+            electric_charge_and_multiplicity, self.config.force_data["xtb"]
+        )
+        if err:
+            print("[Error] Failed to read initial structure.")
+            return
+
+        # 2. Generate Image 2 geometry
+        print(f"Generating Image 2 with random perturbation (Scale: {self.perturbation_scale} Bohr)...")
+        init_geom_2 = self._generate_perturbed_structure(init_geom, self.perturbation_scale)
+        
+        # Create a directory for Image 2 (internally managed)
+        # We can just use the same SP1 object but we need a file path for it.
+        # We will generate input files for Image 2 on the fly using FIO1 logic.
+        # Note: We reuse SP1 and FIO1 for both images since they share physics/settings.
+        
+        # Initialize loop variables
+        geom_num_list_1 = init_geom
+        geom_num_list_2 = init_geom_2
+        
+        velocity_1 = np.zeros((len(element_list), 3))
+        velocity_2 = np.zeros((len(element_list), 3))
+        
+        current_drift_step = self.initial_drift_step
+        
+        # Variables to store the latest geometry
+        new_geom_1 = None
+        new_geom_2 = None
+
+        for cycle in range(0, self.config.microiterlimit):
+            if os.path.isfile(self.config.iEIP_FOLDER_DIRECTORY+"end.txt"):
+                break
+            
+            print(f"### Cycle {cycle} Start ###")
+
+            # =========================================================================
+            # 1. Drifting Phase
+            # =========================================================================
+            print(f"--- Drifting Phase (Cycle {cycle}) ---")
+            
+            prev_force_drift_1 = None
+            prev_force_drift_2 = None
+            
+            drift_temp_label = f"{cycle}_drift_temp"
+
+            for d_step in range(self.drift_limit):
+                iter_label = drift_temp_label
+                
+                # Make input files for this step
+                # Note: file_directory_1/2 here are just strings for the input file path
+                # generated by _make_next_input.
+                # However, SP1.single_point expects the directory path or file path depending on implementation.
+                # Assuming _make_next_input returns the PATH to the input file.
+                
+                input_path_1 = self._make_next_input(FIO1, geom_num_list_1, element_list, electric_charge_and_multiplicity, iter_label + "_img1")
+                input_path_2 = self._make_next_input(FIO1, geom_num_list_2, element_list, electric_charge_and_multiplicity, iter_label + "_img2")
+                
+                # 1. QM Calculation
+                # We reuse SP1 for both. It's just a calculator.
+                energy_1, gradient_1, g1_read, error_flag_1 = SP1.single_point(input_path_1, element_list, iter_label + "_img1", electric_charge_and_multiplicity, self.config.force_data["xtb"])
+                energy_2, gradient_2, g2_read, error_flag_2 = SP1.single_point(input_path_2, element_list, iter_label + "_img2", electric_charge_and_multiplicity, self.config.force_data["xtb"])
+                
+                # Update geom from read result to be safe, or stick to internal numpy array
+                # Using internal array (geom_num_list_1/2) is safer for consistency unless optimizer changes it.
+                # But let's align them just in case output orientation changed.
+                # g1_read, g2_read = Calculationtools().kabsch_algorithm(g1_read, g2_read)
+                # geom_num_list_1, geom_num_list_2 = g1_read, g2_read
+                
+                # Align current internal geometries
+                geom_num_list_1, geom_num_list_2 = Calculationtools().kabsch_algorithm(geom_num_list_1, geom_num_list_2)
+
+                if error_flag_1 or error_flag_2:
+                    return
+
+                # 2. Vector & Force Calculation
+                ds, vs = self.get_spring_vectors(geom_num_list_1, geom_num_list_2)
+                
+                _, grad_perp_1 = self.decompose_gradient(gradient_1, vs)
+                _, grad_perp_2 = self.decompose_gradient(gradient_2, vs)
+                
+                force_perp_1 = -grad_perp_1
+                force_perp_2 = -grad_perp_2
+                
+                spring_force_mag = self.k_spring * (ds - self.l_s)
+                spring_force_1 = spring_force_mag * vs 
+                spring_force_2 = spring_force_mag * (-vs)
+                
+                total_force_1 = force_perp_1 + spring_force_1
+                total_force_2 = force_perp_2 + spring_force_2
+                
+                # --- Adaptive Step Logic ---
+                if prev_force_drift_1 is not None:
+                    dot_1 = np.sum(prev_force_drift_1 * total_force_1)
+                    dot_2 = np.sum(prev_force_drift_2 * total_force_2)
+                    
+                    if dot_1 < 0 or dot_2 < 0:
+                        current_drift_step *= 0.5
+                        velocity_1 *= 0.1 
+                        velocity_2 *= 0.1
+                        print(f"  [Auto-Brake] Oscillation detected at step {d_step}. Reduced drift step to {current_drift_step:.6f}")
+                    else:
+                        current_drift_step = min(current_drift_step * 1.05, self.initial_drift_step)
+                
+                prev_force_drift_1 = total_force_1.copy()
+                prev_force_drift_2 = total_force_2.copy()
+
+                # Update Position
+                velocity_1 = self.momentum * velocity_1 + current_drift_step * total_force_1
+                velocity_2 = self.momentum * velocity_2 + current_drift_step * total_force_2
+                
+                geom_num_list_1 += velocity_1
+                geom_num_list_2 += velocity_2
+                
+                # Check Convergence
+                drift_metric = max(self.RMS(force_perp_1), self.RMS(force_perp_2))
+                
+                if d_step % 5 == 0: 
+                    info_dat = {
+                        "energy_1": energy_1, "energy_2": energy_2,
+                        "gradient_1": gradient_1, "gradient_2": gradient_2,
+                        "perp_force_1": force_perp_1, "perp_force_2": force_perp_2,
+                        "spring_force_1": spring_force_1, "spring_force_2": spring_force_2,
+                        "spring_length": ds, 
+                        "step_size": current_drift_step,
+                        "convergence_metric": drift_metric
+                    }
+                    self.print_info(info_dat, f"Cycle {cycle} - Drifting {d_step}")
+
+                if drift_metric < self.RMS_FORCE_THRESHOLD:
+                    print(f"  >> Drifting converged at step {d_step}")
+                    break
+            
+            # =========================================================================
+            # 2. Climbing Phase
+            # =========================================================================
+            print(f"--- Climbing Phase (Cycle {cycle}) ---")
+            
+            iter_label = f"{cycle}_climb"
+            
+            input_path_1 = self._make_next_input(FIO1, geom_num_list_1, element_list, electric_charge_and_multiplicity, iter_label + "_img1")
+            input_path_2 = self._make_next_input(FIO1, geom_num_list_2, element_list, electric_charge_and_multiplicity, iter_label + "_img2")
+            
+            energy_1, gradient_1, g1_read, error_flag_1 = SP1.single_point(input_path_1, element_list, iter_label + "_img1", electric_charge_and_multiplicity, self.config.force_data["xtb"])
+            energy_2, gradient_2, g2_read, error_flag_2 = SP1.single_point(input_path_2, element_list, iter_label + "_img2", electric_charge_and_multiplicity, self.config.force_data["xtb"])
+            
+            geom_num_list_1, geom_num_list_2 = Calculationtools().kabsch_algorithm(geom_num_list_1, geom_num_list_2)
+            
+            ds, vs = self.get_spring_vectors(geom_num_list_1, geom_num_list_2)
+            grad_par_1, _ = self.decompose_gradient(gradient_1, vs)
+            grad_par_2, _ = self.decompose_gradient(gradient_2, vs)
+            
+            active_climb_step = self.climb_step_size
+            
+            # Move UP
+            geom_num_list_1 += active_climb_step * grad_par_1
+            geom_num_list_2 += active_climb_step * grad_par_2
+            
+            # Update 'new_geom' for final output reference
+            new_geom_1 = geom_num_list_1.copy()
+            new_geom_2 = geom_num_list_2.copy()
+            
+            grad_norm_1 = np.linalg.norm(gradient_1)
+            grad_norm_2 = np.linalg.norm(gradient_2)
+            global_metric = min(grad_norm_1, grad_norm_2)
+
+            info_dat = {
+                "energy_1": energy_1, "energy_2": energy_2,
+                "gradient_1": gradient_1, "gradient_2": gradient_2,
+                "par_force_1": grad_par_1, "par_force_2": grad_par_2, 
+                "spring_length": ds, "convergence_metric": global_metric,
+                "step_size": active_climb_step
+            }
+            self.print_info(info_dat, f"Cycle {cycle} - Climbing")
+            
+            ENERGY_LIST_1.append(energy_1 * self.config.hartree2kcalmol)
+            ENERGY_LIST_2.append(energy_2 * self.config.hartree2kcalmol)
+            GRAD_LIST_1.append(grad_norm_1)
+            GRAD_LIST_2.append(grad_norm_2)
+
+            if cycle > 5 and global_metric < self.MAX_FORCE_THRESHOLD:
+                print("!!! Global Convergence Reached !!!")
+                print(f"Saddle point candidate found around cycle {cycle}")
+                break
+
+        # --- END OF OPTIMIZATION LOOP ---
+        
+        # Save the optimized structure
+        if new_geom_1 is not None and new_geom_2 is not None:
+            avg_geom = (new_geom_1 + new_geom_2) / 2.0
+            avg_geom_ang = avg_geom * self.config.bohr2angstroms
+            
+            dir_name = os.path.basename(os.path.normpath(self.config.iEIP_FOLDER_DIRECTORY))
+            output_xyz_name = f"{dir_name}_optimized.xyz"
+            
+            try:
+                with open(output_xyz_name, "w") as f:
+                    num_atoms = len(element_list)
+                    f.write(f"{num_atoms}\n")
+                    f.write(f"SPM Optimized Saddle Point (Average)\n")
+                    for i, elem in enumerate(element_list):
+                        x, y, z = avg_geom_ang[i]
+                        f.write(f"{elem} {x:.10f} {y:.10f} {z:.10f}\n")
+                print(f"\n[Success] Final optimized structure saved to: {output_xyz_name}")
+            except Exception as e:
+                print(f"\n[Error] Failed to save optimized structure: {e}")
+
+        return
+
+    def _make_next_input(self, FIO, geom, element_list, charge_mult, iter_label):
+        """
+        Creates a PSI4 input file and returns its path.
+        """
+        geom_tolist = (geom * self.config.bohr2angstroms).tolist()
+        for i, elem in enumerate(element_list):
+            geom_tolist[i].insert(0, elem)
+        geom_tolist.insert(0, charge_mult)
+        
+        # FIO.make_psi4_input_file usually returns the directory or path.
+        # Ensure this matches your FIO implementation.
+        return FIO.make_psi4_input_file([geom_tolist], iter_label)

multioptpy/ieip.py

@@ -15,6 +15,7 @@ from multioptpy.OtherMethod.addf import ADDFlikeMethod
 from multioptpy.OtherMethod.twopshs import twoPSHSlikeMethod
 from multioptpy.OtherMethod.elastic_image_pair import ElasticImagePair
 from multioptpy.OtherMethod.modelfunction import ModelFunctionOptimizer
+from multioptpy.OtherMethod.spring_pair_method import SpringPairMethod
 
 class IEIPConfig:
     """
@@ -174,6 +175,9 @@ class IEIPConfig:
         self.dimer_trial_angle = getattr(args, 'dimer_trial_angle', np.pi / 32.0)
         self.dimer_max_iterations = getattr(args, 'dimer_max_iterations', 1000)
 
+        # Add config flag check if needed
+        self.use_spm = getattr(args, 'use_spm', False)
+
         # Create output directory
         os.mkdir(self.iEIP_FOLDER_DIRECTORY)
     
@@ -205,7 +209,9 @@ class iEIP:
         self.addf_like_method = ADDFlikeMethod(self.config)
         self.twoPshs = twoPSHSlikeMethod(self.config)
         self.dimer_method = DimerMethod(self.config)
-
+        self.spring_pair_method = SpringPairMethod(self.config)
+        
+        
 
     def optimize(self):
         """Load calculation modules based on configuration and run optimization"""
@@ -322,7 +328,13 @@ class iEIP:
                 SP_list[0],
                 self.config.electric_charge_and_multiplicity_list[0], 
                 FIO_img_list[0])
-    
+        elif getattr(self.config, 'use_spm', False):
+            print("Using Spring Pair Method (SPM)")
+            self.spring_pair_method.iteration(
+                file_directory_list[0],
+                SP_list[0], element_list_list[0], 
+                self.config.electric_charge_and_multiplicity_list[0], 
+                FIO_img_list[0])
         else:
             self.elastic_image_pair.iteration(
                 file_directory_list[0], file_directory_list[1], 

multioptpy/interface.py

@@ -5,7 +5,7 @@ import numpy as np
 
 """
     MultiOptPy
-    Copyright (C) 2023-2025 ss0832
+    Copyright (C) 2023-2026 ss0832
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -133,6 +133,8 @@ def call_ieipparser(parser):
     parser.add_argument('-dimer_sep','--dimer_separation', help="set dimer separation (default: 0.0001)", type=float, default=0.0001)
     parser.add_argument('-dimer_trial_angle','--dimer_trial_angle', help="set dimer trial angle (default: pi/32)", type=float, default=np.pi / 32.0)
     parser.add_argument('-dimer_maxiter','--dimer_max_iterations', help="set max iterations for dimer method (default: 1000)", type=int, default=1000)
+    parser.add_argument('-use_spm','--use_spm', help="Use Spring Pair method for searching direction of TS (default: False)", action='store_true'
+                        )    
     return parser
 
 def call_optimizeparser(parser):

multioptpy/optimization.py

@@ -339,8 +339,6 @@ class StandardHandler(BasePotentialHandler):
         state.Model_hess = copy.deepcopy(self.calculator.Model_hess)
         return state
 
-
-
 class ModelFunctionHandler(BasePotentialHandler):
     def __init__(self, calc1, calc2, mf_args, config, file_io, base_dir, force_data):
         super().__init__(config, file_io, base_dir, force_data)
@@ -360,13 +358,11 @@ class ModelFunctionHandler(BasePotentialHandler):
         self.bitss_geom2_history = []
         self.bitss_ref_geom = None
         
-      
         self.bitss_initialized = False 
 
         if self.is_bitss:
             self._setup_bitss_initialization()
 
- 
     def _load_mf_class(self):
         if self.method_name == "opt_meci": 
             return OptMECI()
@@ -396,7 +392,6 @@ class ModelFunctionHandler(BasePotentialHandler):
         if len(self.params) < 1:
             raise ValueError("BITSS requires a reference geometry file path.")
         
-    
         temp_io = FileIO(self.base_dir, self.params[0])
         g_list, _, _ = temp_io.make_geometry_list(self.config.electric_charge_and_multiplicity)
         
@@ -414,7 +409,6 @@ class ModelFunctionHandler(BasePotentialHandler):
             n_atoms = len(self.single_element_list)
             geom_1, geom_2 = state.geometry[:n_atoms], state.geometry[n_atoms:]
             
-          
             if not self.bitss_initialized:
                 self.mf_instance = BITSSModelFunction(geom_1, geom_2)
                 self._apply_config_params()
@@ -422,11 +416,18 @@ class ModelFunctionHandler(BasePotentialHandler):
         else:
             geom_1 = geom_2 = state.geometry
 
-     
         # State 1
         e1, g1, ex1 = self._run_calc(self.calc1, geom_1, self.single_element_list, self.config.electric_charge_and_multiplicity, "State1", iter_idx)
+        
         # State 2
-        chg_mult_2 = self.config.electric_charge_and_multiplicity if self.is_bitss else [int(self.params[0]), int(self.params[1])]
+        if self.is_bitss:
+            chg_mult_2 = self.config.electric_charge_and_multiplicity
+        else:
+            if len(self.params) >= 2:
+                chg_mult_2 = [int(self.params[0]), int(self.params[1])]
+            else:
+                chg_mult_2 = self.config.electric_charge_and_multiplicity
+
         e2, g2, ex2 = self._run_calc(self.calc2, geom_2, self.single_element_list, chg_mult_2, "State2", iter_idx)
 
         if ex1 or ex2:
@@ -530,7 +531,6 @@ class ModelFunctionHandler(BasePotentialHandler):
         
         return state
 
-   
     def _make_block_diag_hess(self, h1, h2):
         d1 = h1.shape[0]
         d2 = h2.shape[0]
@@ -554,9 +554,30 @@ class ModelFunctionHandler(BasePotentialHandler):
         os.makedirs(run_dir, exist_ok=True)
         old_dir = calc_inst.BPA_FOLDER_DIRECTORY
         calc_inst.BPA_FOLDER_DIRECTORY = run_dir
+        
+        # Charge/Multiplicity update for PySCF compatibility
+        calc_inst.electronic_charge = chg_mult[0]
+        calc_inst.spin_multiplicity = chg_mult[1]
+
         geom_str = self.file_io.print_geometry_list(geom * self.config.bohr2angstroms, elems, chg_mult, display_flag=True)
         inp_path = self.file_io.make_psi4_input_file(geom_str, iter_idx, path=run_dir)
-        e, g, _, ex = calc_inst.single_point(inp_path, [element_number(el) for el in elems], iter_idx, chg_mult, method="")
+        
+        # Method string for xTB
+        method_str = getattr(calc_inst, "xtb_method", "")
+        if method_str is None:
+            method_str = ""
+
+        # [FIX] Convert list to numpy array (int) to avoid 'list has no attribute tolist' error in tblite tools
+        atom_nums = np.array([element_number(el) for el in elems], dtype=int)
+
+        e, g, _, ex = calc_inst.single_point(
+            inp_path, 
+            atom_nums,  # Passing numpy array instead of list
+            iter_idx, 
+            chg_mult, 
+            method=method_str
+        )
+        
         calc_inst.BPA_FOLDER_DIRECTORY = old_dir
         return e, g, ex
 
@@ -569,8 +590,7 @@ class ModelFunctionHandler(BasePotentialHandler):
                 f.write(f"{len(g)}\nBITSS_Step {s}\n")
                 for i, atom in enumerate(g):
                     f.write(f"{self.single_element_list[i]:2s} {atom[0]:12.8f} {atom[1]:12.8f} {atom[2]:12.8f}\n")
-                    
-                    
+  
 class ONIOMHandler(BasePotentialHandler):
     """
     Handles ONIOM calculations with microiterations.

{multioptpy-1.20.3.dist-info → multioptpy-1.20.5.dist-info}/METADATA

@@ -1,21 +1,21 @@
 Metadata-Version: 2.4
 Name: MultiOptPy
-Version: 1.20.3
+Version: 1.20.5
 Summary: Multifunctional geometry optimization tools for quantum chemical calculations.
 Author-email: ss0832 <highlighty876@gmail.com>
-License: GPLv3
+License-Expression: GPL-3.0-or-later
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy~=2.2.0
+Requires-Dist: numpy>=2.2.0
 Requires-Dist: scipy>=1.13.0
-Requires-Dist: matplotlib~=3.10.0
+Requires-Dist: matplotlib>=3.10.0
 Requires-Dist: torch~=2.6.0
-Requires-Dist: pyscf~=2.9.0
-Requires-Dist: tblite~=0.4.0
+Requires-Dist: pyscf>=2.9.0
+Requires-Dist: tblite>=0.4.0
 Requires-Dist: ase~=3.26.0
 Requires-Dist: fairchem-core~=2.7.0
-Requires-Dist: sympy~=1.13.0
+Requires-Dist: sympy>=1.13.0
 Dynamic: license-file
 
 # MultiOptPy
@@ -29,7 +29,7 @@ Dynamic: license-file
 [![Buy Me A Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-ffdd00?style=for-the-badge&logo=buy-me-a-coffee&logoColor=black)](https://buymeacoffee.com/ss0832)
 
 [![PyPI Downloads](https://static.pepy.tech/personalized-badge/multioptpy?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/multioptpy)
-[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17839100.svg)](https://doi.org/10.5281/zenodo.17839100)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17973395.svg)](https://doi.org/10.5281/zenodo.17973395)
 
 If this tool helped your studies, education, or saved your time, I'd appreciate a coffee!
 Your support serves as a great encouragement for this personal project and fuels my next journey.
@@ -80,9 +80,9 @@ conda create -n test_mop python=3.12.7
 conda activate test_mop
 
 ## 3. Download and install MultiOptPy:
-wget https://github.com/ss0832/MultiOptPy/archive/refs/tags/v1.20.3.zip
-unzip v1.20.3.zip
-cd MultiOptPy-1.20.3
+wget https://github.com/ss0832/MultiOptPy/archive/refs/tags/v1.20.4.zip
+unzip v1.20.4.zip
+cd MultiOptPy-1.20.4
 pip install -r requirements.txt
 
 ## 4. Copy the test configuration file and run the AutoTS workflow:
@@ -107,10 +107,10 @@ python run_autots.py aldol_rxn.xyz -cfg config_autots_run_xtb_test.json
 # Installation via pip (Linux)
 conda create -n <env-name> python=3.12 pip
 conda activate <env-name>
-pip install git+https://github.com/ss0832/MultiOptPy.git@v1.20.3
-wget https://github.com/ss0832/MultiOptPy/archive/refs/tags/v1.20.3.zip
-unzip v1.20.3.zip
-cd MultiOptPy-1.20.3
+pip install git+https://github.com/ss0832/MultiOptPy.git@v1.20.4
+wget https://github.com/ss0832/MultiOptPy/archive/refs/tags/v1.20.4.zip
+unzip v1.20.4.zip
+cd MultiOptPy-1.20.4
 
 ## 💻 Command Line Interface (CLI) Functionality (v1.20.2)
 # The following eight core functionalities are available as direct executable commands in your terminal after installation:
@@ -412,13 +412,13 @@ If you use MultiOptPy in your research, please cite it as follows:
   month        = dec,
   year         = 2025,
   publisher    = {Zenodo},
-  version      = {v1.20.2},
-  doi          = {10.5281/zenodo.17839100},
-  url          = {[https://doi.org/10.5281/zenodo.17839100](https://doi.org/10.5281/zenodo.17839100)}
+  version      = {v1.20.4},
+  doi          = {10.5281/zenodo.17973395},
+  url          = {https://doi.org/10.5281/zenodo.17973395}
 }
 ```
 ```
-ss0832. (2025). MultiOptPy: Multifunctional geometry optimization tools for quantum chemical calculations (v1.20.2). Zenodo. https://doi.org/10.5281/zenodo.17839100
+ss0832. (2025). MultiOptPy: Multifunctional geometry optimization tools for quantum chemical calculations (v1.20.4). Zenodo. https://doi.org/10.5281/zenodo.17973395
 ```
 
 ## Setting Up an Environment for Using NNP(UMA) on Windows 11

{multioptpy-1.20.3.dist-info → multioptpy-1.20.5.dist-info}/RECORD

@@ -1,15 +1,15 @@
 multioptpy/__init__.py,sha256=OJ7BAhHT2pWsIdC5wZfhCA5J8zW-odvaym9ySpPZ3Hw,125
 multioptpy/entrypoints.py,sha256=rizxMJSbFq2aAKpcsPIy1CTIh_ZCGkDpCEEkvMOy6uc,39130
 multioptpy/fileio.py,sha256=BJVhls9P_GU-ZB_nZgTgUPejru8-lJ1Qi-typHsG0WY,27175
-multioptpy/ieip.py,sha256=7zjvxW76k-5-tdgCpW0u4QzQBQtrLkcTYzNauhTX0qA,16182
-multioptpy/interface.py,sha256=t0wzrHhMxn4gV65NHoQ4_zbAVd6tCX0U87Z6sjvIXXc,81835
+multioptpy/ieip.py,sha256=XjN3ii1xVclXdSVb6g1gO1Q_7VtOBFR9jK7MjdFZrFM,16786
+multioptpy/interface.py,sha256=Xohjpk1ofcEmDygGg93dRh9Dzha6VjbtcefmcoXqoZE,82013
 multioptpy/irc.py,sha256=lTb1atfC5_QgW9a7FqQC-e-CXlTEhi1lms-zie_dEhI,20777
 multioptpy/moleculardynamics.py,sha256=FGA2fulBbNx26gCUSoauaOMoT0dIIddemXEiAoHC6p0,20359
 multioptpy/neb.py,sha256=eQQsB8HrDOZ4rlvHOUIwfR52QNDvuhvH1am5h6K7Ho0,59339
-multioptpy/optimization.py,sha256=DmjXV0pZAqShys0hVAV5bjW3N4NGQfK7nZCiGwEGelg,100722
+multioptpy/optimization.py,sha256=FBMueS5ChGCZvCHsY7S8hCLf4nrWvjNMcEfWfj8vIdU,101480
 multioptpy/optimizer.py,sha256=Nm6uDEMiv9u5_CPdhQYqGzwmCqHNzDIdYeYIn9z5EwM,42047
 multioptpy/Calculator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-multioptpy/Calculator/ase_calculation_tools.py,sha256=gJsqUhv_JVv5_OrHbOD3IvSdfkJuRz4pQ14a_xmkknA,20143
+multioptpy/Calculator/ase_calculation_tools.py,sha256=TxLpUsXM2Cg3U4jUfquZzq6IhGz7FbLj1GO8nWijzzw,20830
 multioptpy/Calculator/dxtb_calculation_tools.py,sha256=s3LTuypTsfZEIrnkuOQUOCegfh9LCyUG0tI3zzYiliQ,16492
 multioptpy/Calculator/emt_calculation_tools.py,sha256=aq4I3yM0_A7PFCX2sB5qHfEoij2LP0cqYu_BQkMztMQ,21762
 multioptpy/Calculator/gpaw_calculation_tools.py,sha256=P2a8YSCzHvgSdvPS_HQo-liLkVBQ1ePr4tooHJm2aL4,8079
@@ -25,10 +25,11 @@ multioptpy/Calculator/ase_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 multioptpy/Calculator/ase_tools/fairchem.py,sha256=n7sZVEik1iw-gjTXyUx6uGQbJhn9FhhCJXatKQGK8oY,1627
 multioptpy/Calculator/ase_tools/gamess.py,sha256=OvRD5TGze--x-ZKqLPUAC78UwVlZwLDf-B4VoHrjp9I,904
 multioptpy/Calculator/ase_tools/gaussian.py,sha256=y4r64zX2o5zORUDt_h6SmnsBQ3wM8WQr7zP1XVmcw74,7829
+multioptpy/Calculator/ase_tools/gxtb_dev.py,sha256=cBWenNu4PYtgQ-kelwmMqJ0FK4WxnCd-IGOA_BxX-y0,1529
 multioptpy/Calculator/ase_tools/mace.py,sha256=AsyUkTFrOI-kSnDT4d7ehViQfCRT5fG8wdYUTn56RCw,928
 multioptpy/Calculator/ase_tools/mopac.py,sha256=RUMNikbmVxIvoTi4H8JU3fXY2vBu6BzPxcv0NPd_L-k,723
 multioptpy/Calculator/ase_tools/nwchem.py,sha256=0NPIaX1_mzkzLh_r9e3WJA6fEiNrksEbXFwbATHkNuw,1162
-multioptpy/Calculator/ase_tools/orca.py,sha256=-9D5bqzQzn9IkvbYGC-OJtJKbneGKFKQVBcOhldvfw8,1026
+multioptpy/Calculator/ase_tools/orca.py,sha256=JjTCvW3YT1KwaImkIxyd8FcUgz8BHO5ZFGHqiX3lJKc,10141
 multioptpy/Calculator/ase_tools/pygfn0.py,sha256=N-Rrtu8wvduPxRSGQMYK9LmQiWCtfCbkBOTXjhHK-gE,1468
 multioptpy/Constraint/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 multioptpy/Constraint/constraint_condition.py,sha256=wS14fYCzP1V4_d1HLElW3a6fxKfEEX3EjxPvvbRPhZ8,44202
@@ -166,6 +167,7 @@ multioptpy/OtherMethod/dimer.py,sha256=54oqeExIqP_PPBpaZAwo59X11n6k1BgttpYIGKnJ7
 multioptpy/OtherMethod/elastic_image_pair.py,sha256=YSXjfrmHRRnl5YZ5JVZMLsDSCyfY911Q2F5qp6dj1rQ,33586
 multioptpy/OtherMethod/modelfunction.py,sha256=GX_YvA8rOzcKeaZcth6L-S0q9wdsTLA07E9sjOaFyRU,26168
 multioptpy/OtherMethod/newton_traj.py,sha256=gozEqyOCpD4zbYMf3IwPKIMC7v4D7ddXCu1MUz8tzxE,20154
+multioptpy/OtherMethod/spring_pair_method.py,sha256=6YdLCIO-OOt_Mzzf8JFFtWVYAIa1Tsdi1VCxEbbPuto,15577
 multioptpy/OtherMethod/twopshs.py,sha256=GmBLKTNK-HqFpVmGgwmrtw9-IOf_hPYlUTslx95Sl20,49969
 multioptpy/PESAnalyzer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 multioptpy/PESAnalyzer/calc_irc_curvature.py,sha256=YVZBydXcYLfO0Y8ZYGS7WXokkORfVQaO6zPbXwhQJt4,4986
@@ -241,9 +243,9 @@ multioptpy/Wrapper/ieip_wrapper.py,sha256=H0Fa7x5mzyFu5rnig7GdcZGX9LFclzRxDuREX5
 multioptpy/Wrapper/md_wrapper.py,sha256=EGQKY8BwBbjWkXxKQGlelzht872OsUp9GmyxPDgWav4,3050
 multioptpy/Wrapper/neb_wrapper.py,sha256=ZOyHhuSDKA5hABnQB7PYPfbQ9OyaAj9KKBeKu_HLiY4,3254
 multioptpy/Wrapper/optimize_wrapper.py,sha256=b5DoiSb5Y4YjzYaSfxNa4A5QMn7_UzAvActPOpL78Ok,2667
-multioptpy-1.20.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-multioptpy-1.20.3.dist-info/METADATA,sha256=cb066MXMa4CKsFP3rVjz-jlP5_VLdlHsTCBIOPXJqbY,16733
-multioptpy-1.20.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multioptpy-1.20.3.dist-info/entry_points.txt,sha256=u2Y0tgYMu7UyZumhLCfoME92lCQXhurAAsixL_B3caw,404
-multioptpy-1.20.3.dist-info/top_level.txt,sha256=_MXQNcS1xJbRbGnYUM-F_G-PlLK7wTIkuqx-EvfAhRc,11
-multioptpy-1.20.3.dist-info/RECORD,,
+multioptpy-1.20.5.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+multioptpy-1.20.5.dist-info/METADATA,sha256=FWxTaqF3RW7uxZd5o8HJGtc6kdUI6VRK8RX6cFnF--k,16712
+multioptpy-1.20.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multioptpy-1.20.5.dist-info/entry_points.txt,sha256=u2Y0tgYMu7UyZumhLCfoME92lCQXhurAAsixL_B3caw,404
+multioptpy-1.20.5.dist-info/top_level.txt,sha256=_MXQNcS1xJbRbGnYUM-F_G-PlLK7wTIkuqx-EvfAhRc,11
+multioptpy-1.20.5.dist-info/RECORD,,