MultiOptPy 1.20.2__py3-none-any.whl

multioptpy/Optimizer/trim.py

@@ -0,0 +1,273 @@
+import numpy as np
+from scipy.optimize import newton
+
+from multioptpy.Utils.calc_tools import Calculationtools
+
+class TRIM:
+    def __init__(self, saddle_order=0):
+        """
+        Trust Region Image Minimization (TRIM) for transition state optimization.
+        
+        ref.: https://doi.org/10.1016/0009-2614(91)90115-P
+              Helgaker, 1991
+        """
+        # Trust region parameters
+        self.trust_radius = 0.3          # Default trust radius
+        self.trust_radius_min = 0.01     # Minimum trust radius
+        self.trust_radius_max = 0.5      # Maximum trust radius
+        
+        # Transition state mode parameters
+        self.roots = [0]                 # Indices of eigenvalues to follow uphill (default: lowest mode)
+        self.ts_mode_history = []        # History of transition state modes
+        self.mode_following_threshold = 0.7  # Dot product threshold for mode following
+        
+        # Step control parameters
+        self.max_step_norm = 0.5         # Maximum allowed step size
+        self.min_eigenvalue_shift = 1e-8 # Minimum eigenvalue shift for numerical stability
+        
+        # Convergence tracking
+        self.predicted_energy_changes = []
+        self.iter = 0
+        self.H = None                    # Store Hessian for energy prediction
+        self.saddle_order = saddle_order  # Desired saddle order
+        # Logging and diagnostics
+        self.debug = False
+        
+    def log(self, message):
+        """Print log message if debug is enabled."""
+        if self.debug:
+            print(f"TRIM: {message}")
+        else:
+            # Always print important information even when debug is disabled
+            if "μ=" in message or "norm(step)" in message:
+                print(f"TRIM: {message}")
+    
+    def update_ts_mode(self, eigvals, eigvecs):
+        """
+        Update the transition state mode to follow based on eigenvalues and eigenvectors.
+        
+        Parameters:
+        -----------
+        eigvals : numpy.ndarray
+            Eigenvalues of the Hessian matrix
+        eigvecs : numpy.ndarray
+            Eigenvectors of the Hessian matrix
+        """
+        # Sort eigenvalues to find the lowest (potentially negative) ones
+        idx = np.argsort(eigvals)
+        
+        # Default to following the lowest mode (idx[0])
+        if not self.ts_mode_history:
+            self.roots = [idx[0:self.saddle_order]]
+            self.ts_mode_history.append(eigvecs[:, idx[0:self.saddle_order]])
+            return
+        
+        # If we have history, ensure we follow the consistent mode
+        prev_mode = self.ts_mode_history[-1]
+        overlaps = np.abs([np.dot(prev_mode.flatten(), eigvecs[:, i].flatten()) for i in idx[:3]])
+        
+        # Find the mode with highest overlap with previous mode
+        max_overlap_idx = np.argmax(overlaps)
+        if overlaps[max_overlap_idx] > self.mode_following_threshold:
+            # Use the mode with highest overlap
+            self.roots = [idx[max_overlap_idx]]
+        else:
+            # Default to lowest eigenvalue if no good overlap
+            self.roots = [idx[0:self.saddle_order]]
+        
+        self.ts_mode_history.append(eigvecs[:, self.roots[0:self.saddle_order]])
+        self.log(f"Following mode with eigenvalue {eigvals[self.roots[0]]:.6f}")
+    
+    def quadratic_model(self, gradient, hessian, step):
+        """
+        Predict energy change using quadratic model.
+        
+        Parameters:
+        -----------
+        gradient : numpy.ndarray
+            Current gradient
+        hessian : numpy.ndarray
+            Current Hessian matrix
+        step : numpy.ndarray
+            Step vector
+            
+        Returns:
+        --------
+        float
+            Predicted energy change
+        """
+        step_flat = step.flatten()
+        grad_flat = gradient.flatten()
+        
+        linear_term = np.dot(grad_flat, step_flat)
+        quadratic_term = 0.5 * np.dot(step_flat, np.dot(hessian, step_flat))
+        
+        return linear_term + quadratic_term
+
+    def get_step(self, forces, hessian, eigvals, eigvecs):
+        """
+        Calculate the TRIM step.
+        
+        Parameters:
+        -----------
+        
+        forces : numpy.ndarray
+            Current forces (-gradient)
+        hessian : numpy.ndarray
+            Current Hessian matrix
+        eigvals : numpy.ndarray
+            Eigenvalues of the Hessian
+        eigvecs : numpy.ndarray
+            Eigenvectors of the Hessian
+        
+        Returns:
+        --------
+        numpy.ndarray
+            Calculated step vector
+        """
+        gradient = -forces
+        self.H = hessian  # Store for energy prediction
+        
+        
+        # Update transition state mode
+        if self.saddle_order > 0:
+            self.update_ts_mode(eigvals, eigvecs)
+            print(f"Signs of eigenvalue and -vector of root(s) {self.roots} will be reversed!")
+        
+        
+        # Transform gradient to basis of eigenvectors
+        gradient_ = eigvecs.T.dot(gradient.flatten())
+        
+        if self.saddle_order > 0:
+            # Construct image function by inverting the signs of the eigenvalue and
+            # -vector of the mode to follow uphill.
+            eigvals_ = eigvals.copy()
+            eigvals_[self.roots] *= -1
+            gradient_ = gradient_.copy()
+            gradient_[self.roots] *= -1
+        else:
+            eigvals_ = eigvals.copy()
+            gradient_ = gradient_.copy()
+        
+        def get_step(mu):
+            """Calculate step with level shift parameter mu."""
+            zetas = -gradient_ / (eigvals_ - mu)
+            # Replace nan with 0.
+            zetas = np.nan_to_num(zetas)
+            # Transform to original basis
+            step = np.dot(eigvecs, zetas[:, np.newaxis])
+            return step
+        
+        def get_step_norm(mu):
+            """Calculate norm of step with level shift parameter mu."""
+            return np.linalg.norm(get_step(mu))
+        
+        def func(mu):
+            """Function to find mu such that step norm equals trust radius."""
+            return get_step_norm(mu) - self.trust_radius
+        
+        # Initialize level shift parameter
+        mu = 0
+        norm0 = get_step_norm(mu)
+        
+        # Apply trust radius constraint if needed
+        if norm0 > self.trust_radius:
+            try:
+                mu, res = newton(func, x0=mu, full_output=True)
+                if res.converged:
+                    self.log(f"Using levelshift of μ={mu:.4f}")
+                else:
+                    self.log("Newton method for levelshift did not converge, using simple scaling")
+                    mu = 0
+                    step = get_step(mu)
+                    step = step * (self.trust_radius / norm0)
+                    return step
+            except:
+                self.log("Error in levelshift calculation, using simple scaling")
+                mu = 0
+                step = get_step(mu)
+                step = step * (self.trust_radius / norm0)
+                return step
+        else:
+            self.log("Took pure newton step without levelshift")
+        
+        # Calculate final step
+        step = get_step(mu)
+        step_norm = np.linalg.norm(step)
+        self.log(f"norm(step)={step_norm:.6f}")
+        
+        # Store predicted energy change
+        predicted_change = self.quadratic_model(gradient, self.H, step)
+        self.predicted_energy_changes.append(predicted_change)
+        
+        return step
+        
+    def run(self, geom_num_list, B_g, hessian, trust_radius, original_move_vector):
+        """
+        Run TRIM optimization step
+        
+        Parameters:
+        -----------
+        geom_num_list : numpy.ndarray
+            Current geometry
+        energy : float
+            Current energy value
+        B_g : numpy.ndarray
+            Current gradient (forces with sign flipped)
+        original_move_vector : numpy.ndarray
+            Step calculated by the original method (ignored in TRIM)
+        hessian : numpy.ndarray, optional
+            Current Hessian matrix (required for TRIM)
+        trust_radius : float
+            Trust radius for the optimization step
+        original_move_vector : numpy.ndarray
+            Step calculated by the original method (ignored in TRIM)
+
+        Returns:
+        --------
+        numpy.ndarray
+            Optimized step vector
+        """
+        print("TRIM method")
+        n_coords = len(geom_num_list)
+        step_norm = np.linalg.norm(original_move_vector)
+        print(f"Original step norm: {step_norm:.6f}, Trust radius: {trust_radius:.6f}")
+        self.trust_radius = trust_radius
+        if step_norm < self.trust_radius:
+            print("Step is within trust radius, using original move vector")
+            return original_move_vector
+        
+        # Check if Hessian is provided
+        if hessian is None:
+            print("Error: Hessian matrix is required for TRIM method")
+            return original_move_vector  # Fallback to steepest descent
+        
+        hessian = Calculationtools().project_out_hess_tr_and_rot_for_coord(hessian, geom_num_list.reshape(-1, 3), geom_num_list.reshape(-1, 3), display_eigval=False)
+        
+        # Compute eigenvalues and eigenvectors of the Hessian
+        try:
+            eigvals, eigvecs = np.linalg.eigh(hessian)
+        except np.linalg.LinAlgError:
+            print("Warning: Eigenvalue computation failed, using diagonal approximation")
+            # Use diagonal approximation if eigenvalue computation fails
+            H_diag = np.diag(np.diag(hessian))
+            eigvals = np.diag(H_diag)
+            eigvecs = np.eye(len(eigvals))
+        
+        # Reshape forces for compatibility
+        forces = -B_g.reshape(-1)  # Convert gradient to forces (sign flip)
+        
+        # Calculate TRIM step
+        move_vector = self.get_step(forces, hessian, eigvals, eigvecs)
+        
+        # Ensure step has correct shape
+        move_vector = -1*move_vector.reshape(n_coords, 1)
+        
+        # Final safety checks
+        move_norm = np.linalg.norm(move_vector)
+        if move_norm < 1e-10 or np.any(np.isnan(move_vector)) or np.any(np.isinf(move_vector)):
+            print("Warning: Step issue detected, using scaled gradient instead")
+            move_vector = original_move_vector
+        
+        self.iter += 1
+        return move_vector

multioptpy/Optimizer/trust_radius.py

@@ -0,0 +1,207 @@
+import numpy as np
+
+class TrustRadius:    
+    def __init__(self, 
+                 initial_trust_radius=0.3,
+                 min_trust_radius=0.01, 
+                 max_trust_radius=0.5,
+                 history_size=5,
+                 adaptive_factor_scale=0.8,
+                 energy_precision_threshold=1e-8,
+                 quality='Normal'):
+        """
+        Initialize the composite-step trust radius method
+        
+        Args:
+            initial_trust_radius: Initial trust radius value
+            min_trust_radius: Minimum allowed trust radius
+            max_trust_radius: Maximum allowed trust radius
+            history_size: Number of previous steps to consider in history
+            adaptive_factor_scale: Scale factor for adaptive adjustment (0-1)
+            energy_precision_threshold: Threshold for energy precision
+            quality: Convergence quality setting ('VeryBasic', 'Basic', 'Normal', 'Good', 'VeryGood')
+        """
+        # Basic parameters
+        self.trust_radius = initial_trust_radius
+        self.min_trust_radius = min_trust_radius
+        self.max_trust_radius = max_trust_radius
+        
+        # Adaptive parameters
+        self.history_size = history_size
+        self.adaptive_factor_scale = adaptive_factor_scale
+        self.energy_precision_threshold = energy_precision_threshold
+        
+        # History data
+        self.energy_ratios = []  # History of actual/predicted energy change ratios
+        self.step_sizes = []     # History of step sizes
+        self.energy_changes = [] # History of energy changes
+        
+        # Optimization state
+        self.iteration_count = 0
+        self.last_energy = None
+        
+      
+        # AMS convergence criteria based on quality setting
+        self.set_convergence_quality(quality)
+    
+    def set_min_trust_radius(self, min_trust_radius):
+        """Set minimum trust radius"""
+        self.min_trust_radius = min_trust_radius
+    
+    def set_max_trust_radius(self, max_trust_radius):
+        """Set maximum trust radius"""
+        self.max_trust_radius = max_trust_radius
+    
+    
+    
+    def set_convergence_quality(self, quality):
+        """
+        Set convergence criteria based on quality setting
+        
+        Args:
+            quality: Quality setting ('VeryBasic', 'Basic', 'Normal', 'Good', 'VeryGood')
+        """
+        # Default to Normal if invalid quality is provided
+        if quality not in ['VeryBasic', 'Basic', 'Normal', 'Good', 'VeryGood']:
+            quality = 'Normal'
+            
+        quality_map = {
+            'VeryBasic': {'energy': 1e-3, 'gradients': 1e-1, 'step': 1.0, 'stress': 5e-2},
+            'Basic':     {'energy': 1e-4, 'gradients': 1e-2, 'step': 0.1, 'stress': 5e-3},
+            'Normal':    {'energy': 1e-5, 'gradients': 1e-3, 'step': 0.01, 'stress': 5e-4},
+            'Good':      {'energy': 1e-6, 'gradients': 1e-4, 'step': 0.001, 'stress': 5e-5},
+            'VeryGood':  {'energy': 1e-7, 'gradients': 1e-5, 'step': 0.0001, 'stress': 5e-6}
+        }
+        
+        self.convergence_criteria = quality_map[quality]
+        self.quality = quality
+    
+    def calculate_adaptive_factor(self):
+        """
+        Calculate adaptive adjustment factor based on optimization history
+        
+        Returns:
+            float: Adaptive factor determining adjustment strength
+        """
+        # Return default value if no history is available
+        if len(self.energy_ratios) == 0:
+            return 2.0
+        
+        # Calculate based on recent prediction accuracy
+        recent_ratios = self.energy_ratios[-min(self.history_size, len(self.energy_ratios)):]
+        ratio_variance = np.var(recent_ratios) if len(recent_ratios) > 1 else 0.0
+        
+        # More cautious adjustment when prediction variance is high
+        base_factor = 2.0 * np.exp(-ratio_variance)
+        
+        # More cautious when approaching convergence
+        if self.is_approaching_convergence():
+            base_factor *= self.adaptive_factor_scale
+        
+      
+        
+        return max(1.1, min(base_factor, 3.0))  # Limit to range 1.1-3.0
+    
+    def is_approaching_convergence(self):
+        """
+        Determine if optimization is approaching convergence
+        
+        Returns:
+            bool: True if approaching convergence
+        """
+        if len(self.energy_changes) < 2:
+            return False
+        
+        # Check if recent energy changes are small and decreasing
+        recent_changes = np.abs(self.energy_changes[-min(3, len(self.energy_changes)):])
+        return np.all(recent_changes < 0.01) and np.mean(recent_changes) < 0.005
+    
+    
+    def update_trust_radii(self, 
+                          B_e, 
+                          pre_B_e, 
+                          pre_B_g, 
+                          pre_move_vector, 
+                          model_hess, 
+                          geom_num_list, 
+                          trust_radii,
+                          atom_types=None,
+                          constraints=None):
+        """
+        Update trust radius using composite-step approach
+        
+        Args:
+            B_e: Current energy
+            pre_B_e: Previous energy
+            pre_B_g: Previous gradient
+            pre_move_vector: Previous movement vector
+            model_hess: Model Hessian
+            geom_num_list: Geometry number list
+            trust_radii: Current trust radius
+            atom_types: Optional list of atom types
+            constraints: Optional constraint information
+            
+        Returns:
+            float: Updated trust radius
+        """
+        if self.iteration_count == 0:
+            self.iteration_count += 1
+            return trust_radii
+      
+        
+        # Calculate predicted energy change
+        Ce = (np.dot(pre_B_g.reshape(1, len(geom_num_list)), 
+                    pre_move_vector.reshape(len(geom_num_list), 1)) + 
+              0.5 * np.dot(np.dot(pre_move_vector.reshape(1, len(geom_num_list)), 
+                                 model_hess), 
+                          pre_move_vector.reshape(len(geom_num_list), 1)))
+        
+        # Handle numerical stability
+        if abs(Ce) < self.energy_precision_threshold:
+            Ce += np.sign(Ce) * self.energy_precision_threshold
+            if abs(Ce) < self.energy_precision_threshold:  # If sign is unknown
+                Ce = self.energy_precision_threshold
+        
+        # Ratio of actual to predicted energy change
+        r = (pre_B_e - B_e) / Ce
+        
+        # Update history
+        self.energy_ratios.append(float(r))
+        self.step_sizes.append(float(np.linalg.norm(pre_move_vector)))
+        self.energy_changes.append(float(pre_B_e - B_e))
+        
+        # Calculate adaptive factor
+        adaptive_factor = self.calculate_adaptive_factor()
+        
+        # Debug information
+        print(f"Iteration: {self.iteration_count}")
+        print(f"Energy ratio (actual/predicted): {r}")
+        print(f"Adaptive factor: {adaptive_factor}")
+        print(f"Current trust radius: {trust_radii}")
+        
+        # Trust radius adjustment logic (improved version)
+        r_min = 0.25
+        r_good = 0.75
+        
+        if r <= r_min or r >= (2.0 - r_min):
+            # Decrease trust radius for poor prediction
+            trust_radii /= adaptive_factor
+            print("Decrease trust radius")
+        elif r >= r_good and r <= (2.0 - r_good):
+            # For good prediction
+            if abs(np.linalg.norm(pre_move_vector) - trust_radii) < self.energy_precision_threshold:
+                # Increase trust radius if previous step was limited by trust radius
+                trust_radii *= adaptive_factor ** 0.5
+                print("Increase trust radius")
+            else:
+                # Otherwise maintain trust radius
+                print("Keep trust radius (good prediction)")
+        else:
+            # Maintain trust radius for moderate prediction
+            print("Keep trust radius (moderate prediction)")
+        
+        self.iteration_count += 1
+                
+        # Clip final trust radius between min and max values
+        return np.clip(trust_radii, self.min_trust_radius, self.max_trust_radius)
+    

multioptpy/Optimizer/trust_radius_neb.py

@@ -0,0 +1,121 @@
+import numpy as np
+
+
+class TR_NEB:
+    def __init__(self, **config):
+        self.NEB_FOLDER_DIRECTORY = config.get("NEB_FOLDER_DIRECTORY", None)
+        self.fix_init_edge = config.get("fix_init_edge", False)
+        self.fix_end_edge = config.get("fix_end_edge", False)
+        self.apply_convergence_criteria = config.get("apply_convergence_criteria", False)
+        self.threshold_max_force = 0.00045
+        self.threshold_rms_force = 0.00030
+        self.threshold_max_displacement = 0.0018
+        self.threshold_rms_displacement = 0.0012
+                
+        return
+    
+    def TR_calc(self, geometry_num_list, total_force_list, total_delta, biased_energy_list, pre_biased_energy_list, pre_geom):
+        if self.fix_init_edge:
+            move_vector = [total_delta[0]*0.0]
+        else:
+            init_norm_move_vector = np.linalg.norm(total_delta[0])
+            init_tr = min(0.5, init_norm_move_vector)
+            if init_norm_move_vector < 1e-15:
+                move_vector = [total_delta[0]*0.0]
+            else:
+                move_vector = [init_tr * total_delta[0] / init_norm_move_vector]
+            
+        trust_radii_1_list = []
+        trust_radii_2_list = []
+        
+        for i in range(1, len(total_delta)-1):
+            #if biased_energy_list[i] > pre_biased_energy_list[i] and pre_geom is not None:
+            #    total_delta[i] = pre_geom[i] - geometry_num_list[i]
+            #    print("Energy increased... ")
+            
+            trust_radii_1 = np.linalg.norm(geometry_num_list[i] - geometry_num_list[i-1]) / 2.0
+            trust_radii_2 = np.linalg.norm(geometry_num_list[i] - geometry_num_list[i+1]) / 2.0
+            
+            trust_radii_1_list.append(str(trust_radii_1*2))
+            trust_radii_2_list.append(str(trust_radii_2*2))
+            
+            normalized_vec_1 = (geometry_num_list[i-1] - geometry_num_list[i])/(np.linalg.norm(geometry_num_list[i-1] - geometry_num_list[i]) + 1e-15)
+            normalized_vec_2 = (geometry_num_list[i+1] - geometry_num_list[i])/(np.linalg.norm(geometry_num_list[i+1] - geometry_num_list[i]) + 1e-15)
+            normalized_delta =  total_delta[i] / np.linalg.norm(total_delta[i])
+            
+            cos_1 = np.sum(normalized_vec_1 * normalized_delta) 
+            cos_2 = np.sum(normalized_vec_2 * normalized_delta)
+            
+            force_move_vec_cos = np.sum(total_force_list[i] * total_delta[i]) / (np.linalg.norm(total_force_list[i]) * np.linalg.norm(total_delta[i])) 
+            
+            if force_move_vec_cos >= 0: #Projected velocity-verlet algorithm
+                if (cos_1 > 0 and cos_2 < 0) or (cos_1 < 0 and cos_2 > 0):
+                    if np.linalg.norm(total_delta[i]) > trust_radii_1 and cos_1 > 0:
+                        move_vector.append(total_delta[i]*trust_radii_1/np.linalg.norm(total_delta[i]))
+                        
+                    elif np.linalg.norm(total_delta[i]) > trust_radii_2 and cos_2 > 0:
+                        move_vector.append(total_delta[i]*trust_radii_2/np.linalg.norm(total_delta[i]))
+                        
+                    else:
+                        move_vector.append(total_delta[i])
+                        
+                elif (cos_1 < 0 and cos_2 < 0):
+                    move_vector.append(total_delta[i])
+                    
+                else:
+                    if np.linalg.norm(total_delta[i]) > trust_radii_1:
+                        move_vector.append(total_delta[i]*trust_radii_1/np.linalg.norm(total_delta[i]))
+                        
+                    elif np.linalg.norm(total_delta[i]) > trust_radii_2:
+                        move_vector.append(total_delta[i]*trust_radii_2/np.linalg.norm(total_delta[i]))
+                        
+                    else:
+                        move_vector.append(total_delta[i])      
+            else:
+                print("no displacements (Projected velocity-verlet algorithm): # NODE "+str(i))
+                move_vector.append(total_delta[i] * 0.0) 
+            
+            
+        with open(self.NEB_FOLDER_DIRECTORY+"procrustes_distance_1.csv", "a") as f:
+            f.write(",".join(trust_radii_1_list)+"\n")
+        
+        with open(self.NEB_FOLDER_DIRECTORY+"procrustes_distance_2.csv", "a") as f:
+            f.write(",".join(trust_radii_2_list)+"\n")
+        
+        if self.fix_end_edge:
+            move_vector.append(total_delta[-1]*0.0)
+        else:
+            end_norm_move_vector = np.linalg.norm(total_delta[-1])
+            end_tr = min(0.5, end_norm_move_vector) 
+            if end_norm_move_vector < 1e-15:
+                move_vector.append(total_delta[-1]*0.0)
+            else:
+                move_vector.append(end_tr * total_delta[-1] / end_norm_move_vector)
+        
+        if self.apply_convergence_criteria:
+            move_vector = self.check_convergence(total_force_list, move_vector)
+        
+        return move_vector        
+    
+    def check_convergence(self, total_force_list, move_vec_list):
+        
+        for i in range(1, len(total_force_list)-1):
+            max_grad = np.max(total_force_list[i])
+            rms_grad = np.sqrt(np.sum(total_force_list[i]**2)/(len(total_force_list[i])*3))
+            max_move = np.max(move_vec_list[i])
+            rms_move = np.sqrt(np.sum(move_vec_list[i]**2)/(len(move_vec_list[i])*3))
+            print("--------------------")
+            print("NODE #"+str(i))
+            print(f"MAXIMUM NEB FORCE    :    {float(max_grad):12.8f}")
+            print(f"RMS NEB FORCE        :    {float(rms_grad):12.8f}")
+            print(f"MAXIMUM DISPLACEMENT :    {float(max_move):12.8f}")
+            print(f"RMS DISPLACEMENT     :    {float(rms_move):12.8f}")
+            
+            if max_grad < self.threshold_max_force and rms_grad < self.threshold_rms_force and max_move < self.threshold_max_displacement and rms_move < self.threshold_rms_displacement:
+                print("Converged?: YES")
+                move_vec_list[i] = move_vec_list[i]*0.0
+            else:
+                print("Converged?: NO")
+        print("--------------------")
+        return move_vec_list
+    

multioptpy/Optimizer/yogi.py

@@ -0,0 +1,60 @@
+import numpy as np
+import copy
+
+
+class YOGI:
+    def __init__(self, **config):
+        #https://doi.org/10.1145/3441501.3441507
+        self.adam_count = 1
+        self.DELTA = 0.05
+        self.beta_m = 0.9
+        self.beta_v = 0.999
+        self.Epsilon = 1e-8
+        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("YOGI")
+        if self.Initialization:
+            self.adam_m = geom_num_list * 0.0
+            self.adam_v = geom_num_list * 0.0
+            self.Initialization = False
+        
+        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
+        
+        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(adam_v[i] - (1.0 - self.beta_v) * np.sign(adam_v[i] - B_g[i] ** 2) * (B_g[i])**2)
+    
+                    
+        move_vector = []
+
+        for i in range(len(geom_num_list)):
+            move_vector.append(self.DELTA*(new_adam_m[i])/np.sqrt((new_adam_v[i])+self.Epsilon))
+                
+        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