MultiOptPy 1.20.2__py3-none-any.whl

multioptpy/IRC/euler.py

@@ -0,0 +1,439 @@
+import numpy as np
+import os
+import copy
+import csv
+
+from multioptpy.Utils.calc_tools import Calculationtools
+from multioptpy.Optimizer.hessian_update import ModelHessianUpdate
+from multioptpy.Potential.potential import BiasPotentialCalculation
+from multioptpy.Parameters.parameter import UnitValueLib, atomic_mass
+from multioptpy.IRC.converge_criteria import convergence_check
+from multioptpy.Visualization.visualization import Graph
+from multioptpy.PESAnalyzer.calc_irc_curvature import calc_irc_curvature_properties, save_curvature_properties_to_file
+
+
+class Euler:
+    """Euler method for IRC calculations
+    
+    A simple implementation of the IRC using Euler integration.
+    This method takes steps in the direction opposite to the gradient.
+    This method is not recommended for production use due to its simplicity
+    and potential instability, but serves as a basic example of IRC calculation.
+    
+    """
+    
+    def __init__(self, element_list, electric_charge_and_multiplicity, FC_count, file_directory, 
+                 final_directory, force_data, max_step=1000, step_size=0.01, init_coord=None, 
+                 init_hess=None, calc_engine=None, xtb_method=None, **kwargs):
+        """Initialize Euler IRC calculator
+        
+        Parameters
+        ----------
+        element_list : list
+            List of atomic elements
+        electric_charge_and_multiplicity : tuple
+            Charge and multiplicity for the system
+        FC_count : int
+            Frequency of full hessian recalculation
+        file_directory : str
+            Working directory
+        final_directory : str
+            Directory for final output
+        force_data : dict
+            Force field data for bias potential
+        max_step : int, optional
+            Maximum number of steps
+        step_size : float, optional
+            Step size for the IRC
+        init_coord : numpy.ndarray, optional
+            Initial coordinates
+        init_hess : numpy.ndarray, optional
+            Initial hessian
+        calc_engine : object, optional
+            Calculator engine
+        xtb_method : str, optional
+            XTB method specification
+        """
+        self.max_step = max_step
+        self.step_size = step_size
+        self.ModelHessianUpdate = ModelHessianUpdate()
+        self.CE = calc_engine
+        self.FC_count = FC_count
+        
+        # initial condition
+        self.coords = init_coord
+        self.init_hess = init_hess
+        self.xtb_method = xtb_method
+        
+        # convergence criteria
+        self.MAX_FORCE_THRESHOLD = 0.0004
+        self.RMS_FORCE_THRESHOLD = 0.0001
+
+        self.element_list = element_list
+        self.electric_charge_and_multiplicity = electric_charge_and_multiplicity
+        self.directory = file_directory
+        self.final_directory = final_directory
+        self.force_data = force_data
+        
+        # IRC data storage
+        self.irc_bias_energy_list = []
+        self.irc_energy_list = []
+        self.irc_mw_coords = []
+        self.irc_mw_gradients = []
+        self.irc_mw_bias_gradients = []
+        self.path_length = 0.0
+        self.path_bending_angle_list = []
+        
+        # Create data files
+        self.create_csv_file()
+        self.create_xyz_file()
+    
+    def create_csv_file(self):
+        """Create CSV file for energy and gradient data"""
+        self.csv_filename = os.path.join(self.directory, "irc_energies_gradients.csv")
+        with open(self.csv_filename, 'w', newline='') as csvfile:
+            writer = csv.writer(csvfile)
+            writer.writerow(['Step', 'Energy (Hartree)', 'Bias Energy (Hartree)', 'RMS Gradient', 'RMS Bias Gradient', 'Path Length'])
+    
+    def create_xyz_file(self):
+        """Create XYZ file for structure data"""
+        self.xyz_filename = os.path.join(self.directory, "irc_structures.xyz")
+        # Create empty file (will be appended to later)
+        open(self.xyz_filename, 'w').close()
+    
+    def save_to_csv(self, step, energy, bias_energy, gradient, bias_gradient, path_length):
+        """Save energy and gradient data to CSV file
+        
+        Parameters
+        ----------
+        step : int
+            Current step number
+        energy : float
+            Energy in Hartree
+        bias_energy : float
+            Bias energy in Hartree
+        gradient : numpy.ndarray
+            Gradient array
+        bias_gradient : numpy.ndarray
+            Bias gradient array
+        path_length : float
+            Current IRC path length
+        """
+        rms_grad = np.sqrt((gradient**2).mean())
+        rms_bias_grad = np.sqrt((bias_gradient**2).mean())
+        
+        with open(self.csv_filename, 'a', newline='') as csvfile:
+            writer = csv.writer(csvfile)
+            writer.writerow([step, energy, bias_energy, rms_grad, rms_bias_grad, path_length])
+    
+    def save_xyz_structure(self, step, coords):
+        """Save molecular structure to XYZ file
+        
+        Parameters
+        ----------
+        step : int
+            Current step number
+        coords : numpy.ndarray
+            Atomic coordinates in Bohr
+        """
+        # Convert coordinates to Angstroms
+        coords_angstrom = coords * UnitValueLib().bohr2angstroms
+        
+        with open(self.xyz_filename, 'a') as f:
+            # Number of atoms and comment line
+            f.write(f"{len(coords)}\n")
+            f.write(f"IRC Step {step}\n")
+            
+            # Atomic coordinates
+            for i, coord in enumerate(coords_angstrom):
+                f.write(f"{self.element_list[i]:<3} {coord[0]:15.10f} {coord[1]:15.10f} {coord[2]:15.10f}\n")
+    
+    def get_mass_array(self):
+        """Create arrays of atomic masses for mass-weighting operations"""
+        elem_mass_list = np.array([atomic_mass(elem) for elem in self.element_list], dtype="float64")
+        sqrt_mass_list = np.sqrt(elem_mass_list)
+        
+        # Create arrays for 3D operations (x,y,z for each atom)
+        three_elem_mass_list = np.repeat(elem_mass_list, 3)
+        three_sqrt_mass_list = np.repeat(sqrt_mass_list, 3)
+        
+        return elem_mass_list, sqrt_mass_list, three_elem_mass_list, three_sqrt_mass_list
+    
+    def mass_weight_hessian(self, hessian, three_sqrt_mass_list):
+        """Apply mass-weighting to the hessian matrix
+        
+        Parameters
+        ----------
+        hessian : numpy.ndarray
+            Hessian matrix in non-mass-weighted coordinates
+        three_sqrt_mass_list : numpy.ndarray
+            Array of sqrt(mass) values repeated for x,y,z per atom
+            
+        Returns
+        -------
+        numpy.ndarray
+            Mass-weighted hessian
+        """
+        mass_mat = np.diag(1.0 / three_sqrt_mass_list)
+        return np.dot(mass_mat, np.dot(hessian, mass_mat))
+    
+    def mass_weight_coordinates(self, coordinates, sqrt_mass_list):
+        """Convert coordinates to mass-weighted coordinates
+        
+        Parameters
+        ----------
+        coordinates : numpy.ndarray
+            Coordinates in non-mass-weighted form
+        sqrt_mass_list : numpy.ndarray
+            Array of sqrt(mass) values for each atom
+            
+        Returns
+        -------
+        numpy.ndarray
+            Mass-weighted coordinates
+        """
+        mw_coords = copy.deepcopy(coordinates)
+        for i in range(len(coordinates)):
+            mw_coords[i] = coordinates[i] * sqrt_mass_list[i]
+        return mw_coords
+    
+    def mass_weight_gradient(self, gradient, sqrt_mass_list):
+        """Convert gradient to mass-weighted form
+        
+        Parameters
+        ----------
+        gradient : numpy.ndarray
+            Gradient in non-mass-weighted form
+        sqrt_mass_list : numpy.ndarray
+            Array of sqrt(mass) values for each atom
+            
+        Returns
+        -------
+        numpy.ndarray
+            Mass-weighted gradient
+        """
+        mw_gradient = copy.deepcopy(gradient)
+        for i in range(len(gradient)):
+            mw_gradient[i] = gradient[i] / sqrt_mass_list[i]
+        return mw_gradient
+    
+    def unmass_weight_step(self, step, sqrt_mass_list):
+        """Convert a step vector from mass-weighted to non-mass-weighted coordinates
+        
+        Parameters
+        ----------
+        step : numpy.ndarray
+            Step in mass-weighted form
+        sqrt_mass_list : numpy.ndarray
+            Array of sqrt(mass) values for each atom
+            
+        Returns
+        -------
+        numpy.ndarray
+            Step in non-mass-weighted coordinates
+        """
+        unmw_step = copy.deepcopy(step)
+        for i in range(len(step)):
+            unmw_step[i] = step[i] / sqrt_mass_list[i]
+        return unmw_step
+    
+    def step(self, mw_gradient):
+        """Calculate a single Euler IRC step
+        
+        Parameters
+        ----------
+        mw_gradient : numpy.ndarray
+            Mass-weighted gradient
+            
+        Returns
+        -------
+        numpy.ndarray
+            Step vector in mass-weighted coordinates
+        float
+            Step length
+        """
+        # Flatten the gradient for vector operations
+        grad = mw_gradient.flatten()
+        grad_norm = np.linalg.norm(grad)
+        
+        # Step downhill, against the gradient
+        step_direction = -grad / grad_norm
+        step = self.step_size * step_direction
+        
+        return step.reshape(mw_gradient.shape), self.step_size
+    
+    def check_energy_oscillation(self, energy_list):
+        """Check if energy is oscillating (going up and down)
+        
+        Parameters
+        ----------
+        energy_list : list
+            List of energy values
+            
+        Returns
+        -------
+        bool
+            True if energy is oscillating, False otherwise
+        """
+        if len(energy_list) < 3:
+            return False
+        
+        # Check if the energy changes direction (from increasing to decreasing or vice versa)
+        last_diff = energy_list[-1] - energy_list[-2]
+        prev_diff = energy_list[-2] - energy_list[-3]
+        
+        # Return True if the energy direction has changed
+        return (last_diff * prev_diff) < 0
+        
+    def run(self):
+        """Run the Euler IRC calculation"""
+        print("Euler method for IRC calculation")
+        geom_num_list = self.coords
+        CalcBiaspot = BiasPotentialCalculation(self.directory)
+        
+        # Initialize oscillation counter
+        oscillation_counter = 0
+        
+        for iter in range(1, self.max_step + 1):
+            print("# STEP: ", iter)
+            exit_file_detect = os.path.exists(self.directory + "end.txt")
+
+            if exit_file_detect:
+                break
+             
+            # Calculate energy, gradient and new geometry
+            e, g, geom_num_list, finish_frag = self.CE.single_point(
+                self.final_directory, 
+                self.element_list, 
+                iter, 
+                self.electric_charge_and_multiplicity, 
+                self.xtb_method,  
+                UnitValueLib().bohr2angstroms * geom_num_list
+            )
+            
+            # Calculate bias potential
+            _, B_e, B_g, BPA_hessian = CalcBiaspot.main(
+                e, g, geom_num_list, self.element_list, 
+                self.force_data, g, iter-1, geom_num_list
+            )
+            
+            if finish_frag:
+                break
+            
+            # Get mass arrays for consistent mass-weighting
+            elem_mass_list, sqrt_mass_list, three_elem_mass_list, three_sqrt_mass_list = self.get_mass_array()
+            
+            # Mass-weight the gradients
+            mw_g = self.mass_weight_gradient(g, sqrt_mass_list)
+            mw_B_g = self.mass_weight_gradient(B_g, sqrt_mass_list)
+            
+            # Mass-weight the coordinates
+            mw_geom_num_list = self.mass_weight_coordinates(geom_num_list, sqrt_mass_list)
+
+            # Save structure to XYZ file
+            self.save_xyz_structure(iter, geom_num_list)
+            
+            # Save energy and gradient data to CSV
+            self.save_to_csv(iter, e, B_e, g, B_g, self.path_length)
+
+            # Store IRC data for calculation purposes (limit to keep only necessary data)
+            # Keep only last 3 points for calculations like path bending angles
+            if len(self.irc_energy_list) >= 3:
+                self.irc_energy_list.pop(0)
+                self.irc_bias_energy_list.pop(0)
+                self.irc_mw_coords.pop(0)
+                self.irc_mw_gradients.pop(0)
+                self.irc_mw_bias_gradients.pop(0)
+            
+            self.irc_energy_list.append(e)
+            self.irc_bias_energy_list.append(B_e)
+            self.irc_mw_coords.append(mw_geom_num_list)
+            self.irc_mw_gradients.append(mw_g)
+            self.irc_mw_bias_gradients.append(mw_B_g)
+            
+            # Check for energy oscillations
+            if self.check_energy_oscillation(self.irc_bias_energy_list):
+                oscillation_counter += 1
+                print(f"Energy oscillation detected ({oscillation_counter}/5)")
+                
+                if oscillation_counter >= 5:
+                    print("Terminating IRC: Energy oscillated for 5 consecutive steps")
+                    break
+            else:
+                # Reset counter if no oscillation is detected
+                oscillation_counter = 0
+                 
+            # Calculate path bending angle
+            if len(self.irc_mw_coords) >= 3:
+                bend_angle = Calculationtools().calc_multi_dim_vec_angle(
+                    self.irc_mw_coords[0]-self.irc_mw_coords[1], 
+                    self.irc_mw_coords[2]-self.irc_mw_coords[1]
+                )
+                self.path_bending_angle_list.append(np.degrees(bend_angle))
+                print("Path bending angle: ", np.degrees(bend_angle))
+
+            # Calculate Euler step
+            mw_step, step_length = self.step(mw_B_g)
+            
+            # Convert to non-mass-weighted step
+            step = self.unmass_weight_step(mw_step, sqrt_mass_list)
+            
+            # Update geometry
+            geom_num_list = geom_num_list + step
+            
+            # Remove center of mass motion
+            geom_num_list -= Calculationtools().calc_center_of_mass(geom_num_list, self.element_list)
+            
+            # Update path length
+            self.path_length += step_length
+            
+            # Check for convergence
+            if convergence_check(B_g, self.MAX_FORCE_THRESHOLD, self.RMS_FORCE_THRESHOLD) and iter > 10:
+                print("Convergence reached. (IRC)")
+                break
+            
+            # Print current geometry
+            print()
+            for i in range(len(geom_num_list)):    
+                x = geom_num_list[i][0] * UnitValueLib().bohr2angstroms
+                y = geom_num_list[i][1] * UnitValueLib().bohr2angstroms
+                z = geom_num_list[i][2] * UnitValueLib().bohr2angstroms
+                print(f"{self.element_list[i]:<3} {x:17.12f} {y:17.12f} {z:17.12f}")
+              
+            # Display information
+            print()
+            print("Energy         : ", e)
+            print("Bias Energy    : ", B_e)
+            print("RMS B. grad    : ", np.sqrt((B_g**2).mean()))
+            print("Path length    : ", self.path_length)
+            
+            if len(self.irc_mw_coords) > 1:
+                # Calculate curvature properties
+                unit_tangent_vector, curvature_vector, scalar_curvature, curvature_coupling = calc_irc_curvature_properties(
+                    mw_B_g, self.irc_mw_gradients[-2], self.mw_hessian, self.step_size
+                )
+                
+                print("Scalar curvature: ", scalar_curvature)
+                print("Curvature coupling: ", curvature_coupling.ravel())
+                
+                # Save curvature properties to file
+                save_curvature_properties_to_file(
+                    os.path.join(self.directory, "irc_curvature_properties.csv"),
+                    scalar_curvature,
+                    curvature_coupling
+                )
+                print()
+        
+        # Save final data visualization
+        G = Graph(self.directory)
+        G.single_plot(
+            np.array(range(len(self.path_bending_angle_list))),
+            np.array(self.path_bending_angle_list),
+            self.directory,
+            atom_num=0,
+            axis_name_1="# STEP",
+            axis_name_2="bending angle [degrees]",
+            name="IRC_bending"
+        )
+        
+        return