MultiOptPy 1.20.2__py3-none-any.whl

multioptpy/Optimizer/quickmin_neb.py

@@ -0,0 +1,245 @@
+import numpy as np
+from numpy.linalg import norm
+
+from multioptpy.Parameters.parameter import UnitValueLib
+
+class QuickMin_NEB:
+    """QuickMin optimizer for Nudged Elastic Band calculations.
+    
+    QuickMin is a minimization algorithm that combines molecular dynamics with 
+    steepest descent optimization. It retains the velocity component in the direction
+    of the force only when it's aligned with the force, providing efficient energy 
+    minimization for complex systems.
+    
+    Reference:
+    D. Sheppard, R. Terrell, and G. Henkelman, J. Chem. Phys. 128, 134106 (2008)
+    """
+    
+    def __init__(self, **config):
+        # Configuration parameters
+        self.config = config
+        
+        # Initialize flags
+        self.Initialization = True
+        self.iter = 0
+        
+        # QuickMin parameters
+        self.dt = config.get("dt", 0.1)  # Time step
+        self.dt_max = config.get("dt_max", 0.2)  # Maximum time step
+        self.dt_min = config.get("dt_min", 0.01)  # Minimum time step
+        self.dt_grow = config.get("dt_grow", 1.1)  # Time step growth factor
+        self.dt_shrink = config.get("dt_shrink", 0.5)  # Time step shrink factor
+        self.velocity_mixing = config.get("velocity_mixing", 0.9)  # Velocity mixing factor
+        
+        # Adaptive time steps for each image
+        self.dt_images = None
+        
+        # Maximum step size constraint
+        self.maxstep = config.get("maxstep", 0.1)
+        
+        # Storage for velocities and previous data
+        self.velocities = None
+        self.prev_forces = None
+        self.prev_positions = None
+        self.prev_energies = None
+        
+        # Unit conversion
+        self.bohr2angstroms = UnitValueLib().bohr2angstroms 
+        if 'bohr2angstroms' in config:
+            self.bohr2angstroms = config['bohr2angstroms']
+        
+        # For compatibility with other NEB implementations
+        self.TR_NEB = config.get("TR_NEB", None)
+        
+        print(f"Initialized QuickMin optimizer for NEB with dt={self.dt}, maxstep={self.maxstep}")
+        print(f"Using per-image adaptive time steps with growth factor={self.dt_grow}, shrink factor={self.dt_shrink}")
+    
+    def initialize_data(self, num_images):
+        """Initialize data structures for the optimization.
+        
+        Parameters:
+        ----------
+        num_images : int
+            Number of images in the NEB calculation
+        """
+        # Initialize time steps for each image
+        self.dt_images = np.ones(num_images) * self.dt
+        
+        # Initialize velocities with zero (no initial momentum)
+        self.velocities = [np.zeros_like(img) for img in range(num_images)]
+        
+        # Initialize storage for previous data
+        self.prev_forces = [None] * num_images
+        self.prev_positions = [None] * num_images
+        self.prev_energies = [None] * num_images
+        
+        print(f"Initialized QuickMin data for {num_images} images")
+    
+    def update_velocities_and_positions(self, positions, forces, energies):
+        """Update velocities and positions using the QuickMin algorithm.
+        
+        Parameters:
+        ----------
+        positions : list of ndarray
+            Current positions for all images
+        forces : list of ndarray
+            Current forces for all images
+        energies : list of float
+            Current energies for all images
+            
+        Returns:
+        -------
+        tuple
+            (new_velocities, steps) - Updated velocities and position steps for all images
+        """
+        new_velocities = []
+        steps = []
+        
+        # Process each image independently
+        for i, (position, force) in enumerate(zip(positions, forces)):
+            # Initialize velocity if needed
+            if self.velocities[i] is None or not isinstance(self.velocities[i], np.ndarray):
+                self.velocities[i] = np.zeros_like(position)
+            
+            # Ensure correct shape
+            if self.velocities[i].shape != force.shape:
+                self.velocities[i] = np.zeros_like(force)
+            
+            velocity = self.velocities[i]
+            
+            # Calculate dot product of velocity and force
+            v_dot_f = np.dot(velocity.flatten(), force.flatten())
+            
+            # Reset velocity if moving against the force
+            if v_dot_f <= 0:
+                velocity = np.zeros_like(velocity)
+                v_dot_f = 0
+            
+            # Calculate force magnitude
+            f_norm = norm(force.flatten())
+            
+            # Project velocity onto force direction
+            if f_norm > 1e-10:
+                f_hat = force.flatten() / f_norm
+                v_parallel = v_dot_f * f_hat
+                
+                # Update velocity (only keep component parallel to force)
+                new_v = v_parallel.reshape(velocity.shape)
+                
+                # Add force contribution for this time step
+                new_v += self.dt_images[i] * force
+            else:
+                # No force, maintain zero velocity
+                new_v = np.zeros_like(velocity)
+            
+            # Apply velocity mixing for stability
+            if self.velocity_mixing < 1.0:
+                new_v = self.velocity_mixing * new_v + (1.0 - self.velocity_mixing) * velocity
+            
+            # Calculate step
+            step = self.dt_images[i] * new_v
+            
+            # Apply maxstep constraint
+            step_length = norm(step.flatten())
+            if step_length > self.maxstep:
+                step = step * (self.maxstep / step_length)
+            
+            # Adjust time step based on energy change if we have previous data
+            if self.prev_energies[i] is not None:
+                energy_change = self.prev_energies[i] - energies[i]
+                if energy_change > 0:  # Energy decreased (good)
+                    # Increase time step
+                    self.dt_images[i] = min(self.dt_images[i] * self.dt_grow, self.dt_max)
+                else:  # Energy increased (bad)
+                    # Decrease time step and reset velocity
+                    self.dt_images[i] = max(self.dt_images[i] * self.dt_shrink, self.dt_min)
+                    new_v = np.zeros_like(velocity)  # Reset velocity completely
+            
+            # Store results
+            new_velocities.append(new_v)
+            steps.append(step)
+        
+        return new_velocities, steps
+    
+    def QuickMin_NEB_calc(self, geometry_num_list, total_force_list, pre_total_velocity, 
+                         optimize_num, total_velocity, cos_list, 
+                         biased_energy_list, pre_biased_energy_list, pre_geom):
+        """Calculate step using QuickMin for NEB.
+        
+        Parameters:
+        ----------
+        geometry_num_list : ndarray
+            Current geometry coordinates for all images
+        total_force_list : ndarray
+            Current forces for all images
+        pre_total_velocity : ndarray
+            Previous velocities for all images
+        optimize_num : int
+            Current optimization iteration number
+        total_velocity : ndarray
+            Current velocities for all images
+        cos_list : ndarray
+            Cosines between adjacent images
+        biased_energy_list : ndarray
+            Current energy for all images
+        pre_biased_energy_list : ndarray
+            Previous energy for all images
+        pre_geom : ndarray
+            Previous geometry coordinates for all images
+            
+        Returns:
+        -------
+        ndarray
+            Updated geometry coordinates for all images
+        """
+        print(f"\n{'='*50}\nNEB-QuickMin Iteration {self.iter}\n{'='*50}")
+        
+        # Get number of images
+        num_images = len(geometry_num_list)
+        
+        # Initialize data structures if first iteration
+        if self.Initialization:
+            self.initialize_data(num_images)
+            self.Initialization = False
+            print("First iteration - initializing QuickMin")
+            
+            # Initialize velocities from pre_total_velocity if available
+            if pre_total_velocity is not None and len(pre_total_velocity) >= num_images:
+                self.velocities = [vel.copy() if vel is not None else np.zeros_like(geometry_num_list[i]) 
+                                  for i, vel in enumerate(pre_total_velocity[:num_images])]
+        
+        # Print current time steps
+        min_dt = np.min(self.dt_images)
+        max_dt = np.max(self.dt_images)
+        avg_dt = np.mean(self.dt_images)
+        print(f"QuickMin time steps - range: [{min_dt:.4f}, {max_dt:.4f}], avg: {avg_dt:.4f}")
+        
+        # Update velocities and calculate steps
+        new_velocities, move_vectors = self.update_velocities_and_positions(
+            geometry_num_list, total_force_list, biased_energy_list
+        )
+        
+        # Apply trust region correction if TR_NEB is provided
+        if self.TR_NEB:
+            move_vectors = self.TR_NEB.TR_calc(geometry_num_list, total_force_list, move_vectors,
+                                             biased_energy_list, pre_biased_energy_list, pre_geom)
+        
+        # Store current data for next iteration
+        for i in range(num_images):
+            self.velocities[i] = new_velocities[i]
+            self.prev_forces[i] = total_force_list[i].copy()
+            self.prev_positions[i] = geometry_num_list[i].copy()
+            self.prev_energies[i] = biased_energy_list[i]
+        
+        # Update geometry using move vectors
+        new_geometry = []
+        for i, (geom, move) in enumerate(zip(geometry_num_list, move_vectors)):
+            new_geom = geom + move
+            new_geometry.append(new_geom)
+        
+        # Convert to numpy array and apply unit conversion
+        new_geometry = np.array(new_geometry)
+        new_geometry *= self.bohr2angstroms
+        
+        self.iter += 1
+        return new_geometry

multioptpy/Optimizer/radam.py

@@ -0,0 +1,75 @@
+import numpy as np
+import copy
+
+
+    
+class RADAM:
+    def __init__(self, **config):
+         #arXiv:1908.03265v4
+        self.adam_count = 1
+        self.DELTA = 0.03
+        self.beta_m = 0.9
+        self.beta_v = 0.999
+        self.Epsilon = 1e-12
+        self.Initialization = True
+        self.config = config
+        self.hessian = None
+        self.bias_hessian = None
+   
+        return
+    
+    def run(self, geom_num_list, B_g, pre_B_g=[], pre_geom=[], B_e=0.0, pre_B_e=0.0, pre_move_vector=[], initial_geom_num_list=[], g=[], pre_g=[]):
+        print("RADAM")
+        if self.Initialization:
+            self.adam_m = geom_num_list * 0.0
+            self.adam_v = geom_num_list * 0.0
+            self.Initialization = False
+        rho_inf = 2.0 / (1.0- self.beta_v) - 1.0 
+         
+        adam_count = self.adam_count
+        adam_m = self.adam_m
+        adam_v = self.adam_v
+        new_adam_m = adam_m*0.0
+        new_adam_v = adam_v*0.0
+        
+        new_adam_m_hat = []
+        new_adam_v_hat = []
+        for i in range(len(geom_num_list)):
+            new_adam_m[i] = copy.copy(self.beta_m*adam_m[i] + (1.0-self.beta_m)*(B_g[i]))
+            new_adam_v[i] = copy.copy((self.beta_v*adam_v[i]) + (1.0-self.beta_v)*(B_g[i] - new_adam_m[i])**2) + self.Epsilon
+            new_adam_m_hat.append(np.array(new_adam_m[i], dtype="float64")/(1.0-self.beta_m**adam_count))        
+            new_adam_v_hat.append(np.array(new_adam_v[i], dtype="float64")/(1.0-self.beta_v**adam_count))
+        rho = rho_inf - (2.0*adam_count*self.beta_v**adam_count)/(1.0 -self.beta_v**adam_count)
+                    
+        move_vector = []
+        if rho > 4.0:
+            l_alpha = []
+            for j in range(len(new_adam_v)):
+                l_alpha.append(np.sqrt((abs(1.0 - self.beta_v**adam_count))/new_adam_v[j]))
+            l_alpha = np.array(l_alpha, dtype="float64")
+            r = np.sqrt(((rho-4.0)*(rho-2.0)*rho_inf)/((rho_inf-4.0)*(rho_inf-2.0)*rho))
+            for i in range(len(geom_num_list)):
+                move_vector.append(self.DELTA*r*new_adam_m_hat[i]*l_alpha[i])
+        else:
+            for i in range(len(geom_num_list)):
+                move_vector.append(self.DELTA*new_adam_m_hat[i])
+        
+        self.adam_m = new_adam_m
+        self.adam_v = new_adam_v
+        self.adam_count += 1
+        
+        return move_vector#Bohr.
+    
+    def set_hessian(self, hessian):
+        self.hessian = hessian
+        return
+
+    def set_bias_hessian(self, bias_hessian):
+        self.bias_hessian = bias_hessian
+        return
+    
+    def get_hessian(self):
+        return self.hessian
+    
+    def get_bias_hessian(self):
+        return self.bias_hessian

multioptpy/Optimizer/rfo_neb.py

@@ -0,0 +1,302 @@
+import numpy as np
+from abc import ABC, abstractmethod
+from multioptpy.Optimizer import trust_radius_neb
+from multioptpy.Optimizer.fire_neb import FIREOptimizer
+from scipy.signal import argrelextrema
+from multioptpy.Optimizer import rsirfo
+import os
+import copy
+
+class OptimizationAlgorithm(ABC):
+    """Base class for optimization algorithms"""
+    
+    @abstractmethod
+    def optimize(self, geometry_num_list, total_force_list, **kwargs):
+        """Execute optimization step"""
+        pass
+
+    def _load_or_init_hessian(self, num, natoms, config):
+        """Load existing Hessian or initialize identity matrix"""
+        hessian_file = os.path.join(config.NEB_FOLDER_DIRECTORY, f"tmp_hessian_{num}.npy")
+        if os.path.exists(hessian_file):
+            return np.load(hessian_file)
+        else:
+            # print(f"Warning: Hessian file {hessian_file} not found. Using identity matrix.")
+            return np.eye(3 * natoms)
+
+    def _setup_rfo_optimizer(self, num, total_nodes, optimize_num, is_qsm=False):
+        """Configure RSIRFO instance based on node type"""
+        is_endpoint = (num == 0 or num == total_nodes - 1)
+        
+        if is_endpoint:
+            # Endpoints: Minimize (order 0), larger trust radius
+            OPT = rsirfo.RSIRFO(method="rsirfo_fsb", saddle_order=0, trust_radius=0.5)
+        else:
+            # Intermediate
+            # QSM usually targets saddle order 0 (path finding), NEB might target saddle order 1
+            saddle_order = 0 if is_qsm else 1
+            OPT = rsirfo.RSIRFO(method="rsirfo_bofill", saddle_order=saddle_order, trust_radius=0.1)
+        
+        OPT.iteration = optimize_num
+        return OPT
+
+    def _apply_ayala_hessian_update(self, hessian, num, total_nodes, geometry_num_list, 
+                                  biased_energy_list, total_force_list, STRING_FORCE_CALC):
+        """
+        Common Method: Update Hessian using Quintic Polynomial Fit (Ayala Stage 1).
+        Checks if STRING_FORCE_CALC supports the required methods.
+        """
+        # Skip endpoints
+        if num == 0 or num == total_nodes - 1:
+            return hessian
+            
+        # Check if the Force Calculator supports Ayala methods
+        if not hasattr(STRING_FORCE_CALC, 'get_tau') or not hasattr(STRING_FORCE_CALC, 'calculate_gamma'):
+            return hessian
+
+        tangent = STRING_FORCE_CALC.get_tau(num)
+        
+        # Extract local triplet safely
+        start_idx = max(0, num - 1)
+        end_idx = min(len(geometry_num_list), num + 2)
+        
+        gamma = STRING_FORCE_CALC.calculate_gamma(
+            geometry_num_list[start_idx:end_idx],
+            biased_energy_list[start_idx:end_idx],
+            total_force_list[start_idx:end_idx],
+            tangent
+        )
+        
+        # Add curvature along the tangent direction
+        # H_new = H_old + gamma * |t><t|
+        hessian += gamma * np.outer(tangent, tangent)
+        
+        return hessian
+
+    def _limit_step_size(self, move_vec, is_endpoint):
+        """Limit the norm of the movement vector"""
+        move_vec_norm = np.linalg.norm(move_vec)
+        limit = 0.2 if is_endpoint else 0.1
+        
+        if move_vec_norm > 1e-8:
+            return move_vec / move_vec_norm * min(limit, move_vec_norm)
+        return move_vec
+
+
+class RFOOptimizer(OptimizationAlgorithm):
+    """Rational Function Optimization (RFO) optimizer (Standard NEB)"""
+    
+    def __init__(self, config):
+        self.config = config
+        self.NEB_TR = trust_radius_neb.TR_NEB(
+            NEB_FOLDER_DIRECTORY=config.NEB_FOLDER_DIRECTORY, 
+            fix_init_edge=config.fix_init_edge,
+            fix_end_edge=config.fix_end_edge,
+            apply_convergence_criteria=config.apply_convergence_criteria
+        )
+        self.apply_ts_opt = True
+        self.ratio_of_rfo_step = getattr(config, "ratio_of_rfo_step", 0.5)
+    
+    def set_apply_ts_opt(self, apply_ts_opt):
+        self.apply_ts_opt = apply_ts_opt
+    
+    def optimize(self, geometry_num_list, total_force_list, prev_geometry_num_list, 
+                prev_total_force_list, optimize_num, biased_energy_list, 
+                pre_biased_energy_list, pre_total_velocity, total_velocity, 
+                cos_list, pre_geom, STRING_FORCE_CALC):
+        
+        natoms = len(geometry_num_list[0])
+        total_nodes = len(geometry_num_list)
+        
+        # 1. Calc Force
+        proj_total_force_list = STRING_FORCE_CALC.calc_force(
+            geometry_num_list, biased_energy_list, total_force_list, optimize_num, self.config.element_list)
+        
+        maxima_indices = argrelextrema(biased_energy_list, np.greater)[0]
+        rfo_delta_list = []
+        
+        for num, total_force in enumerate(total_force_list):
+            # A. Load Hessian
+            hessian = self._load_or_init_hessian(num, natoms, self.config)
+            
+            # B. Setup Optimizer
+            # Note: Standard RFOOptimizer logic for 'intermediate' nodes differs slightly (saddle_order=1)
+            # We preserve the original logic here manually or via the helper with is_qsm=False
+            if num == 0 or num == total_nodes - 1:
+                OPT = rsirfo.RSIRFO(method="rsirfo_fsb", saddle_order=0, trust_radius=0.2)
+            else:
+                OPT = rsirfo.RSIRFO(method="rsirfo_bofill", saddle_order=0, trust_radius=0.1)
+                if num in maxima_indices and self.apply_ts_opt:
+                    pass
+                else:
+                    OPT.switch_NEB_mode()
+
+            OPT.iteration = optimize_num
+            OPT.set_bias_hessian(np.zeros((3*natoms, 3*natoms)))
+            
+            # C. Hessian Processing
+           
+            # [ADDED] Apply Ayala Curvature Correction if available
+            hessian = self._apply_ayala_hessian_update(
+                hessian, num, total_nodes, geometry_num_list, 
+                biased_energy_list, total_force_list, STRING_FORCE_CALC
+            )
+
+            OPT.set_hessian(hessian)
+           
+            # D. Prepare Steps
+            if optimize_num == 0:
+                OPT.Initialization = True
+                pre_B_g, pre_geom_node = None, None
+            else:
+                OPT.Initialization = False
+                pre_B_g = prev_total_force_list[num].reshape(-1, 1)
+                pre_geom_node = prev_geometry_num_list[num].reshape(-1, 1)        
+                
+            curr_geom_node = geometry_num_list[num].reshape(-1, 1)
+            B_g = total_force.reshape(-1, 1)
+            
+            # E. Run
+            move_vec = OPT.run(curr_geom_node, B_g, pre_B_g, pre_geom_node, 0.0, 0.0, [], [], B_g, pre_B_g)
+            
+            # F. Limit Step
+            move_vec = self._limit_step_size(move_vec, num == 0 or num == total_nodes - 1)
+            
+            rfo_delta_list.append(move_vec.reshape(-1, 3))
+            
+            # G. Save
+            new_hessian = OPT.get_hessian()
+            np.save(os.path.join(self.config.NEB_FOLDER_DIRECTORY, f"tmp_hessian_{num}.npy"), new_hessian)
+            
+        # 3. TR Calc
+        rfo_move_vector_list = self.NEB_TR.TR_calc(
+            geometry_num_list, total_force_list, rfo_delta_list, 
+            biased_energy_list, pre_biased_energy_list, pre_geom
+        )
+      
+        # 4. FIRE
+        fire_optimizer = FIREOptimizer(self.config)
+        tmp_new_geom = fire_optimizer.optimize(
+            geometry_num_list, proj_total_force_list, 
+            pre_total_velocity, optimize_num, total_velocity, 
+            cos_list, biased_energy_list, pre_biased_energy_list, pre_geom
+        )
+        tmp_new_geom = np.array(tmp_new_geom, dtype="float64") / self.config.bohr2angstroms
+        fire_move_vector_list = tmp_new_geom - geometry_num_list
+        
+        # 5. Combine
+        move_vector_list = []
+        for i in range(len(geometry_num_list)):
+            if i == 0 or i == len(geometry_num_list) - 1:
+                move_vector_list.append(-1.0 * rfo_move_vector_list[i])
+            else:
+                move_vector_list.append((1.0 - self.ratio_of_rfo_step) * fire_move_vector_list[i] - 
+                                      self.ratio_of_rfo_step * rfo_move_vector_list[i])
+                
+        move_vector_list = np.array(move_vector_list, dtype="float64")
+        new_geometry_list = (geometry_num_list + move_vector_list) * self.config.bohr2angstroms
+        
+        return new_geometry_list
+
+
+class RFOQSMOptimizer(OptimizationAlgorithm):
+    """Rational Function Optimization (RFO) optimizer for QSM (Quadratic String Method)"""
+    
+    def __init__(self, config):
+        self.config = config
+        self.NEB_TR = trust_radius_neb.TR_NEB(
+            NEB_FOLDER_DIRECTORY=config.NEB_FOLDER_DIRECTORY, 
+            fix_init_edge=config.fix_init_edge,
+            fix_end_edge=config.fix_end_edge,
+            apply_convergence_criteria=config.apply_convergence_criteria
+        )
+        self.ratio_of_rfo_step = getattr(config, "ratio_of_rfo_step", 0.5)
+        self.is_qsmv2 = getattr(config, "qsmv2", False)
+    
+    def optimize(self, geometry_num_list, total_force_list, prev_geometry_num_list, 
+                prev_total_force_list, optimize_num, biased_energy_list, 
+                pre_biased_energy_list, pre_total_velocity, total_velocity, 
+                cos_list, pre_geom, STRING_FORCE_CALC):
+        
+        natoms = len(geometry_num_list[0])
+        total_nodes = len(geometry_num_list)
+        
+        # 1. Calc Force
+        proj_total_force_list = STRING_FORCE_CALC.calc_force(
+            geometry_num_list, biased_energy_list, total_force_list, optimize_num, self.config.element_list)
+        
+        rfo_delta_list = []
+        
+        for num, total_force in enumerate(total_force_list):
+            # A. Load Hessian
+            hessian = self._load_or_init_hessian(num, natoms, self.config)
+            
+            # B. Setup Optimizer (QSM mode uses saddle_order=0 for intermediates usually)
+            OPT = self._setup_rfo_optimizer(num, total_nodes, optimize_num, is_qsm=True)
+            OPT.set_bias_hessian(np.zeros((3*natoms, 3*natoms)))
+            
+            # C. Hessian Processing
+            hessian = STRING_FORCE_CALC.calc_proj_hess(hessian, num, geometry_num_list)
+            
+            # [ADDED] Apply Ayala Curvature Correction (Use the base class method)
+            if self.is_qsmv2:
+                hessian = self._apply_ayala_hessian_update(
+                    hessian, num, total_nodes, geometry_num_list, 
+                    biased_energy_list, total_force_list, STRING_FORCE_CALC
+                )
+            
+            OPT.set_hessian(hessian)
+           
+            # D. Prepare Steps
+            if optimize_num == 0:
+                OPT.Initialization = True
+                pre_B_g, pre_geom_node = None, None
+            else:
+                OPT.Initialization = False
+                pre_B_g = prev_total_force_list[num].reshape(-1, 1)
+                pre_geom_node = prev_geometry_num_list[num].reshape(-1, 1)
+            
+            curr_geom_node = geometry_num_list[num].reshape(-1, 1)
+            B_g = total_force.reshape(-1, 1)
+            
+            # E. Run
+            move_vec = OPT.run(curr_geom_node, B_g, pre_B_g, pre_geom_node, 0.0, 0.0, [], [], B_g, pre_B_g)
+            
+            # F. Limit Step
+            move_vec = self._limit_step_size(move_vec, num == 0 or num == total_nodes - 1)
+            
+            rfo_delta_list.append(move_vec.reshape(-1, 3))
+            
+            # G. Save
+            new_hessian = OPT.get_hessian()
+            np.save(os.path.join(self.config.NEB_FOLDER_DIRECTORY, f"tmp_hessian_{num}.npy"), new_hessian)
+            
+        # 3. TR Calc
+        rfo_move_vector_list = self.NEB_TR.TR_calc(
+            geometry_num_list, total_force_list, rfo_delta_list, 
+            biased_energy_list, pre_biased_energy_list, pre_geom
+        )
+
+        # 4. FIRE
+        fire_optimizer = FIREOptimizer(self.config)
+        tmp_new_geom = fire_optimizer.optimize(
+            geometry_num_list, proj_total_force_list, 
+            pre_total_velocity, optimize_num, total_velocity, 
+            cos_list, biased_energy_list, pre_biased_energy_list, pre_geom
+        )
+        tmp_new_geom = np.array(tmp_new_geom, dtype="float64") / self.config.bohr2angstroms
+        fire_move_vector_list = tmp_new_geom - geometry_num_list
+        
+        # 5. Combine
+        move_vector_list = []
+        for i in range(total_nodes):
+            if i == 0 or i == total_nodes - 1:
+                move_vector_list.append(fire_move_vector_list[i])
+            else:
+                move_vector_list.append((1.0 - self.ratio_of_rfo_step) * fire_move_vector_list[i] - 
+                                      self.ratio_of_rfo_step * rfo_move_vector_list[i])
+                
+        move_vector_list = np.array(move_vector_list, dtype="float64")
+        new_geometry_list = (geometry_num_list + move_vector_list) * self.config.bohr2angstroms
+        
+        return new_geometry_list