MultiOptPy 1.20.2__py3-none-any.whl

multioptpy/MEP/pathopt_qsm_force.py

@@ -0,0 +1,174 @@
+import numpy as np
+import copy
+from scipy.signal import argrelextrema
+from multioptpy.Coordinate.redundant_coordinate import calc_int_grad_from_pBmat, calc_cart_grad_from_pBmat
+
+
+def extremum_list_index(energy_list):
+    local_max_energy_list_index = argrelextrema(energy_list, np.greater)
+    inverse_energy_list = (-1)*energy_list
+    local_min_energy_list_index = argrelextrema(inverse_energy_list, np.greater)
+
+    local_max_energy_list_index = local_max_energy_list_index[0].tolist()
+    local_min_energy_list_index = local_min_energy_list_index[0].tolist()
+    local_max_energy_list_index.append(0)
+    local_min_energy_list_index.append(0)
+    local_max_energy_list_index.append(0)
+    local_min_energy_list_index.append(0)
+    return local_max_energy_list_index, local_min_energy_list_index
+
+
+    
+    
+class CaluculationQSM:
+    def __init__(self, APPLY_CI_NEB=99999):
+        self.spring_constant_k = 0.01
+        self.APPLY_CI_NEB = APPLY_CI_NEB
+        self.force_const_for_cineb = 0.01
+
+    def calc_force(self, geometry_num_list, energy_list, gradient_list, optimize_num, element_list):
+        print("QSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSMQSM")
+        #ref. J. Chem. Phys. 124, 054109 (2006)
+        nnode = len(energy_list)
+        local_max_energy_list_index, local_min_energy_list_index = extremum_list_index(energy_list)
+        total_force_list = []
+        self.tau_list = []
+        for i in range(nnode):
+            if i == 0:
+                total_force_list.append(-1*np.array(gradient_list[0], dtype = "float64"))
+                self.tau_list.append(np.zeros_like(geometry_num_list[0], dtype = "float64"))
+                continue
+            elif i == nnode-1:
+                total_force_list.append(-1*np.array(gradient_list[nnode-1], dtype = "float64"))
+                self.tau_list.append(np.zeros_like(geometry_num_list[nnode-1], dtype = "float64"))
+                continue
+            tmp_grad = copy.copy(gradient_list[i]).reshape(-1, 1)
+            force, tangent_grad = self.calc_project_out_grad(geometry_num_list[i-1], geometry_num_list[i], geometry_num_list[i+1], tmp_grad, energy_list[i-1:i+2])     
+            if optimize_num > self.APPLY_CI_NEB and (i + 1 in local_max_energy_list_index or i - 1 in local_max_energy_list_index) and (i != 1 and i != nnode-2):
+                force *= 0.001
+                print("Restrect step of # NODE", i, " for CI-NEB")
+            elif optimize_num > self.APPLY_CI_NEB and (i in local_max_energy_list_index) and (i != 1 or i != nnode-2):
+                force = self.calc_ci_neb_force(tmp_grad, tangent_grad)
+                print("CI-NEB was applied to # NODE", i)
+            else:
+                pass
+            
+            
+           
+            total_force_list.append(-1*force.reshape(-1, 3))
+            self.tau_list.append(tangent_grad.reshape(-1, 3) / (np.linalg.norm(tangent_grad) + 1e-15))
+        
+        total_force_list = np.array(total_force_list, dtype = "float64")
+        total_force_list = projection(total_force_list, geometry_num_list)
+            
+        return total_force_list
+    
+    def calc_project_out_grad(self, coord_1, coord_2, coord_3, grad_2, energy_list):# grad: (3N, 1), geom_num_list: (N, 3)
+        natom = len(coord_2)
+        tmp_grad = copy.copy(grad_2)
+        if energy_list[0] < energy_list[1] and energy_list[1] < energy_list[2]:
+            B_mat = self.calc_B_matrix_for_NEB_tangent(coord_2, coord_3)
+            int_grad = calc_int_grad_from_pBmat(tmp_grad.reshape(3*natom, 1), B_mat)
+            projection_grad = calc_cart_grad_from_pBmat(-1*int_grad, B_mat)
+            proj_grad = tmp_grad.reshape(3*natom, 1) + projection_grad
+            tangent_grad = projection_grad
+        elif energy_list[0] > energy_list[1] and energy_list[1] > energy_list[2]:
+            B_mat = self.calc_B_matrix_for_NEB_tangent(coord_1, coord_2)
+            int_grad = calc_int_grad_from_pBmat(tmp_grad.reshape(3*natom, 1), B_mat)
+            projection_grad = calc_cart_grad_from_pBmat(-1*int_grad, B_mat)
+            proj_grad = tmp_grad.reshape(3*natom, 1) + projection_grad
+            tangent_grad = projection_grad
+        else:
+            B_mat_plus = self.calc_B_matrix_for_NEB_tangent(coord_2, coord_3)
+            B_mat_minus = self.calc_B_matrix_for_NEB_tangent(coord_1, coord_2)
+            int_grad_plus = calc_int_grad_from_pBmat(tmp_grad.reshape(3*natom, 1), B_mat_plus)
+            int_grad_minus = calc_int_grad_from_pBmat(tmp_grad.reshape(3*natom, 1), B_mat_minus)
+            max_ene = max(abs(energy_list[2] - energy_list[1]), abs(energy_list[1] - energy_list[0]))
+            min_ene = min(abs(energy_list[2] - energy_list[1]), abs(energy_list[1] - energy_list[0]))
+            a = (max_ene) / (max_ene + min_ene + 1e-8)
+            b = (min_ene) / (max_ene + min_ene + 1e-8)
+            
+            if energy_list[0] < energy_list[2]:
+                projection_grad_plus = calc_cart_grad_from_pBmat(-a*int_grad_plus, B_mat_plus)
+                projection_grad_minus = calc_cart_grad_from_pBmat(-b*int_grad_minus, B_mat_minus)
+            
+            else:
+                projection_grad_plus = calc_cart_grad_from_pBmat(-b*int_grad_plus, B_mat_plus)
+                projection_grad_minus = calc_cart_grad_from_pBmat(-a*int_grad_minus, B_mat_minus)
+            proj_grad = tmp_grad.reshape(3*natom, 1) + projection_grad_plus + projection_grad_minus
+            tangent_grad = projection_grad_plus + projection_grad_minus
+        return proj_grad, tangent_grad
+
+    
+    def calc_B_matrix_for_NEB_tangent(self, coord_1, coord_2):
+        natom = len(coord_2)
+        B_mat = np.zeros((natom, 3*natom))
+        
+        for i in range(natom):
+            norm_12 = np.linalg.norm(coord_1[i] - coord_2[i]) + 1e-15
+            dr12_dx2 = (coord_2[i][0] - coord_1[i][0]) / norm_12
+            dr12_dy2 = (coord_2[i][1] - coord_1[i][1]) / norm_12
+            dr12_dz2 = (coord_2[i][2] - coord_1[i][2]) / norm_12
+            B_mat[i][3*i] = dr12_dx2
+            B_mat[i][3*i+1] = dr12_dy2
+            B_mat[i][3*i+2] = dr12_dz2
+
+        return B_mat
+    
+    def calc_proj_hess(self, hess, node_num, geometry_num_list):
+        if node_num == 0 or node_num == len(geometry_num_list)-1:
+            return hess
+        proj_hess = projection_hess(hess, geometry_num_list, node_num)
+        # Make sure the Hessian is symmetric
+        proj_hess = 0.5 * (proj_hess + proj_hess.T)
+        return proj_hess
+    
+    
+    
+def projection(move_vector_list, geometry_list):
+    print("Applying projection to move vectors")
+    for i in range(1, len(geometry_list)-1):
+        vec_1 = geometry_list[i] - geometry_list[i-1]
+        vec_2 = geometry_list[i+1] - geometry_list[i]
+        vec_1_norm = np.linalg.norm(vec_1)
+        vec_2_norm = np.linalg.norm(vec_2)
+        if vec_1_norm < 1e-8 or vec_2_norm < 1e-8:
+            continue
+        vec_1 = vec_1 / vec_1_norm
+        vec_2 = vec_2 / vec_2_norm
+        vec_1 = vec_1.reshape(-1, 1)
+        vec_2 = vec_2.reshape(-1, 1)
+        # Gram-Schmidt process
+        vec_2 -= np.dot(vec_2.T, vec_1) * vec_1
+        if np.linalg.norm(vec_2) < 1e-8:
+            continue
+        vec_2 /= np.linalg.norm(vec_2)
+        
+        P = np.eye(len(vec_1)) - np.outer(vec_1, vec_1) - np.outer(vec_2, vec_2)
+        tmp_proj_move_vec = np.dot(P, move_vector_list[i].reshape(-1, 1))
+        move_vector_list[i] = tmp_proj_move_vec.reshape(-1, 3)
+    return move_vector_list
+
+
+def projection_hess(hessian, geometry_list, node_num):
+    print("Applying projection to Hessian")
+
+    vec_1 = geometry_list[node_num] - geometry_list[node_num-1]
+    vec_2 = geometry_list[node_num+1] - geometry_list[node_num]
+    vec_1_norm = np.linalg.norm(vec_1)
+    vec_2_norm = np.linalg.norm(vec_2)
+    if vec_1_norm < 1e-8 or vec_2_norm < 1e-8:
+        return hessian
+    vec_1 = vec_1 / vec_1_norm
+    vec_2 = vec_2 / vec_2_norm
+    vec_1 = vec_1.reshape(-1, 1)
+    vec_2 = vec_2.reshape(-1, 1)
+    # Gram-Schmidt process
+    vec_2 -= np.dot(vec_2.T, vec_1) * vec_1
+    if np.linalg.norm(vec_2) < 1e-8:
+        return hessian
+    vec_2 /= np.linalg.norm(vec_2)
+
+    P = np.eye(len(vec_1)) - np.outer(vec_1, vec_1) - np.outer(vec_2, vec_2)
+    tmp_proj_hess = np.dot(np.dot(P, hessian), P.T)
+    return tmp_proj_hess

multioptpy/MEP/pathopt_qsmv2_force.py

@@ -0,0 +1,304 @@
+import numpy as np
+import copy
+from scipy.signal import argrelextrema
+
+
+def extremum_list_index(energy_list):
+    local_max_energy_list_index = argrelextrema(energy_list, np.greater)
+    inverse_energy_list = (-1)*energy_list
+    local_min_energy_list_index = argrelextrema(inverse_energy_list, np.greater)
+
+    local_max_energy_list_index = local_max_energy_list_index[0].tolist()
+    local_min_energy_list_index = local_min_energy_list_index[0].tolist()
+    local_max_energy_list_index.append(0)
+    local_min_energy_list_index.append(0)
+    local_max_energy_list_index.append(0)
+    local_min_energy_list_index.append(0)
+    return local_max_energy_list_index, local_min_energy_list_index
+
+class CaluculationQSMv2:
+    """
+    Implementation of Tangent-based Projection using Ayala & Schlegel (1997) method.
+    Replaces the B-matrix logic of QSM with geometric tangent propagation from the TS.
+    """
+    def __init__(self, APPLY_CI_NEB=99999):
+        self.spring_constant_k = 0.01
+        self.APPLY_CI_NEB = APPLY_CI_NEB
+        self.force_const_for_cineb = 0.01
+        self.tau_list = [] # Cache tangents for Hessian projection
+
+    def _normalize(self, v):
+        """Helper function to normalize a vector."""
+        norm = np.linalg.norm(v)
+        return v / norm if norm > 1e-10 else v
+
+    def _calc_arc_tangent(self, q_cur, q_uphill, t_uphill):
+        """Ayala & Schlegel Eq. 3c: Arc approximation"""
+        chord = q_cur - q_uphill
+        diff_norm_sq = np.dot(chord, chord)
+        denom = 2 * np.dot(t_uphill, chord)
+        
+        if abs(denom) < 1e-10:
+            return self._normalize(chord)
+
+        r = diff_norm_sq / denom
+        t_new = (chord - r * t_uphill) / r
+        return self._normalize(t_new)
+
+    def _calc_parabola_tangent(self, q_cur, q_uphill, t_uphill):
+        """Ayala & Schlegel Eq. 3d: Parabola approximation"""
+        chord = q_cur - q_uphill
+        chord_len = np.linalg.norm(chord)
+        if chord_len < 1e-10:
+            return t_uphill
+
+        cos_theta = np.dot(chord, t_uphill) / chord_len
+        theta = np.arccos(np.clip(cos_theta, -1.0, 1.0))
+        
+        proj = np.dot(chord, t_uphill)
+        n_vec = chord - proj * t_uphill
+        n_vec = self._normalize(n_vec)
+        
+        tan_val = np.tan(theta - (np.pi / 4.0))
+        t_new = n_vec - tan_val * (t_uphill - n_vec)
+        return self._normalize(t_new)
+
+    def _calculate_all_tangents(self, geometry_num_list, energy_list):
+        """
+        Calculate tangents for all nodes using Ayala & Schlegel logic.
+        Propagates from the highest energy point (TS) downwards.
+        """
+        geoms = np.array(geometry_num_list, dtype=np.float64)
+        energies = np.array(energy_list, dtype=np.float64)
+        n_images = len(geoms)
+        
+        # Flatten geometries to treat system as a single vector (3N dim)
+        flat_geoms = geoms.reshape(n_images, -1)
+        tangents = np.zeros_like(flat_geoms)
+
+        # 1. Find TS (Highest Energy)
+        # Exclude fixed endpoints (0 and -1) from being the TS source if possible
+        search_energies = energies.copy()
+     
+        ts_idx = np.argmax(search_energies)
+        
+        # Safety for edge cases
+        if ts_idx == 0: 
+            ts_idx = 1
+        if ts_idx == n_images - 1: 
+            ts_idx = n_images - 2
+
+        # 2. Tangent at TS (Eq. 3a)
+        q_ts = flat_geoms[ts_idx]
+        q_prev = flat_geoms[ts_idx - 1]
+        q_next = flat_geoms[ts_idx + 1]
+        
+        v_prev = q_prev - q_ts
+        v_next = q_next - q_ts
+        
+        dist_prev_sq = max(np.dot(v_prev, v_prev), 1e-10)
+        dist_next_sq = max(np.dot(v_next, v_next), 1e-10)
+        
+        ts_tangent = (v_next / dist_next_sq) - (v_prev / dist_prev_sq)
+        tangents[ts_idx] = self._normalize(ts_tangent)
+
+        # 3. Propagate Downhill (Reactant side: ts-1 -> 1)
+        for i in range(ts_idx - 1, 0, -1):
+            q_cur = flat_geoms[i]
+            q_uphill = flat_geoms[i+1]
+            t_uphill = tangents[i+1]
+            
+            chord = q_cur - q_uphill
+            chord_u = self._normalize(chord)
+            angle = np.arccos(np.clip(np.dot(chord_u, t_uphill), -1.0, 1.0))
+            
+            if angle <= (np.pi / 4.0):
+                tangents[i] = self._calc_arc_tangent(q_cur, q_uphill, t_uphill)
+            else:
+                tangents[i] = self._calc_parabola_tangent(q_cur, q_uphill, t_uphill)
+
+        # 4. Propagate Downhill (Product side: ts+1 -> N-2)
+        for i in range(ts_idx + 1, n_images - 1):
+            q_cur = flat_geoms[i]
+            q_uphill = flat_geoms[i-1]
+            t_uphill = tangents[i-1]
+            
+            chord = q_cur - q_uphill
+            chord_u = self._normalize(chord)
+            angle = np.arccos(np.clip(np.dot(chord_u, t_uphill), -1.0, 1.0))
+            
+            if angle <= (np.pi / 4.0):
+                tangents[i] = self._calc_arc_tangent(q_cur, q_uphill, t_uphill)
+            else:
+                tangents[i] = self._calc_parabola_tangent(q_cur, q_uphill, t_uphill)
+
+        # Reshape tangents back to (N, Atoms, 3)
+        return -1*tangents.reshape(geoms.shape)
+
+    def calc_force(self, geometry_num_list, energy_list, gradient_list, optimize_num, element_list):
+        print("AyalaMethodV2_AyalaMethodV2_AyalaMethodV2_AyalaMethodV2")
+        
+        nnode = len(energy_list)
+        local_max_energy_list_index, local_min_energy_list_index = extremum_list_index(energy_list)
+        
+        # Calculate Ayala Tangents for all nodes
+        ayala_tangents = self._calculate_all_tangents(geometry_num_list, energy_list)
+        
+        # Store for calc_proj_hess use
+        self.tau_list = ayala_tangents
+        
+        total_force_list = []
+
+        for i in range(nnode):
+            # Fixed Endpoints
+            if i == 0 or i == nnode - 1:
+                total_force_list.append(-1 * np.array(gradient_list[i], dtype="float64"))
+                continue
+            
+            # Current Gradient and Tangent
+            grad = np.array(gradient_list[i], dtype="float64").flatten()
+            tangent = ayala_tangents[i].flatten()
+            
+            # Project Gradient
+            # g_parallel = (g . tau) * tau
+            g_parallel = np.dot(grad, tangent) * tangent
+            g_perp = grad - g_parallel
+            
+            # Force Calculation
+            # Basic NEB Force (Projected Gradient): F = -g_perp
+            force = -1.0 * g_perp
+            
+            # CI-NEB Logic
+            # If CI-NEB is active and this node is a local max (TS candidate)
+            if optimize_num > self.APPLY_CI_NEB and (i in local_max_energy_list_index) and (i != 1 and i != nnode-2):
+                print(f"CI-NEB was applied to # NODE {i} (Ayala Tangent)")
+                # Invert the parallel component to climb up: F_ci = -g_perp + g_parallel
+                # (Usually F = -Grad_perp - Grad_parallel_spring + ..., here we simulate climbing)
+                # Removing spring force along path and adding potential force UP the path.
+                # Since standard force here is just -g_perp, adding climbing force means adding component along gradient?
+                # Standard CI-NEB: F = -Gradient + 2*(Gradient.Tangent)*Tangent
+                # F = - (g_perp + g_para) + 2 * g_para = -g_perp + g_para
+                force = -1.0 * g_perp + g_parallel
+                
+            elif optimize_num > self.APPLY_CI_NEB and (i + 1 in local_max_energy_list_index or i - 1 in local_max_energy_list_index) and (i != 1 and i != nnode-2):
+                # Restrict step for neighbors of TS (as in original code)
+                print(f"Restrict step of # NODE {i} for CI-NEB")
+                force *= 0.001
+
+            total_force_list.append(force.reshape(geometry_num_list[i].shape))
+
+        total_force_list = np.array(total_force_list, dtype="float64")
+        
+        # Note: Original code applied a global 'projection' here. 
+        # Since we explicitly projected using Ayala tangents inside the loop, 
+        # applying another Gram-Schmidt based on simple neighbor differences might be redundant or conflicting.
+        # However, if the original 'projection' function handles constraints other than the path tangent 
+        # (like removing rotation/translation), it might still be needed.
+        # Assuming 'projection' in the original snippet was purely for path orthogonality:
+        # We DO NOT call the global 'projection' function here to strictly follow the Ayala tangent method.
+        
+        return total_force_list
+
+    def calc_proj_hess(self, hess, node_num, geometry_num_list):
+        """
+        Project the Hessian using the cached Ayala tangent.
+        P = I - |tau><tau|
+        H_proj = P * H * P
+        """
+        # Ensure tangents are available (calc_force should be called before this)
+        if len(self.tau_list) == 0:
+            # Fallback or error handling if calc_force wasn't called. 
+            # For safety, we return original hess, or one needs to calculate tangents here using stored energies.
+            # Assuming usage pattern: calc_force -> opt step -> (optional) calc_hess
+            print("Warning: Tangent list empty in calc_proj_hess. Returning original Hessian.")
+            return hess
+            
+        if node_num == 0 or node_num == len(geometry_num_list)-1:
+            return hess
+
+        print(f"Applying Ayala tangent projection to Hessian at node {node_num}")
+        
+        tangent = self.tau_list[node_num].flatten()
+        
+        # Make Projector P = I - t * t.T
+        dim = len(tangent)
+        identity = np.eye(dim)
+        projector = identity - np.outer(tangent, tangent)
+        
+        # H_proj = P . H . P
+        # Note: hess is likely (3N, 3N)
+        tmp_proj_hess = np.dot(np.dot(projector, hess), projector.T)
+        
+        # Ensure symmetry
+        tmp_proj_hess = 0.5 * (tmp_proj_hess + tmp_proj_hess.T)
+        
+        return tmp_proj_hess
+
+    def get_tau(self, node_num):
+        """Returns the flattened tangent vector at the specified node."""
+        if len(self.tau_list) == 0:
+            raise ValueError("Tangent list is empty. Calculate forces first.")
+        return self.tau_list[node_num]
+
+    def calculate_gamma(self, q_triplet, E_triplet, g_triplet, tangent):
+        """
+        Calculates the curvature gamma along the path using quintic polynomial fitting.
+        
+        Args:
+            q_triplet: List of [q_prev, q_curr, q_next] coordinates
+            E_triplet: List of [E_prev, E_curr, E_next] energies
+            g_triplet: List of [g_prev, g_curr, g_next] gradients
+            tangent: Normalized tangent vector at the current node
+            
+        Returns:
+            gamma: Curvature (2nd derivative) along the path at the current node
+        """
+        q_prev, q_curr, q_next = q_triplet
+        E_prev, E_curr, E_next = E_triplet
+        g_prev, g_curr, g_next = g_triplet
+        
+        # 1. Distances along the path
+        dist_prev = np.linalg.norm(q_curr - q_prev)
+        dist_next = np.linalg.norm(q_next - q_curr)
+        
+        if dist_prev < 1e-6 or dist_next < 1e-6:
+            return 0.0
+
+        # s coordinates: prev at -dist_prev, curr at 0, next at +dist_next
+        s_p = -dist_prev
+        s_c = 0.0
+        s_n = dist_next
+        
+        # 2. Project gradients onto path
+        # Tangent at i-1: Approximated by direction from i-1 to i
+        t_prev = (q_curr - q_prev) / dist_prev
+        gp_proj = np.dot(g_prev.flatten(), t_prev.flatten())
+        
+        # Tangent at i: Given tangent
+        gc_proj = np.dot(g_curr.flatten(), tangent.flatten())
+        
+        # Tangent at i+1: Approximated by direction from i to i+1
+        t_next = (q_next - q_curr) / dist_next
+        gn_proj = np.dot(g_next.flatten(), t_next.flatten())
+        
+        # 3. Solve Quintic Polynomial Coefficients
+        # E(s) = c0 + c1*s + c2*s^2 + c3*s^3 + c4*s^4 + c5*s^5
+        A = np.array([
+            [1, s_p, s_p**2, s_p**3, s_p**4, s_p**5],
+            [1, s_c, s_c**2, s_c**3, s_c**4, s_c**5],
+            [1, s_n, s_n**2, s_n**3, s_n**4, s_n**5],
+            [0, 1, 2*s_p, 3*s_p**2, 4*s_p**3, 5*s_p**4],
+            [0, 1, 2*s_c, 3*s_c**2, 4*s_c**3, 5*s_c**4],
+            [0, 1, 2*s_n, 3*s_n**2, 4*s_n**3, 5*s_n**4]
+        ])
+        
+        b = np.array([E_prev, E_curr, E_next, gp_proj, gc_proj, gn_proj])
+        
+        try:
+            coeffs = np.linalg.solve(A, b)
+            # Curvature gamma = E''(0) = 2 * c2
+            gamma = 2.0 * coeffs[2]
+            return gamma
+        except np.linalg.LinAlgError:
+            # Fallback for singular matrix
+            return 0.0

multioptpy/ModelFunction/__init__.py

@@ -0,0 +1,7 @@
+from .seam_model_function import SeamModelFunction
+from .avoiding_model_function import AvoidingModelFunction
+from .binary_image_ts_search_model_function import BITSSModelFunction
+from .conical_model_function import ConicalModelFunction
+from .opt_mesx import OptMESX
+from .opt_mesx_2 import OptMESX2
+from .opt_meci import OptMECI

multioptpy/ModelFunction/avoiding_model_function.py

@@ -0,0 +1,29 @@
+import numpy as np
+
+class AvoidingModelFunction:
+    def __init__(self):
+        #ref.: Advances in Physical Chemistry 2012, 2012, 1-13.
+        self.alpha = 0.01
+        return
+    
+    def calc_energy(self, energy_1, energy_2):
+        U = self.alpha / 2.0 * np.exp(-1 * (energy_1 - energy_2) ** 2 / self.alpha)
+        tot_energy = 0.5 * (energy_1 + energy_2) + 0.5 * np.sqrt((energy_1 - energy_2) ** 2 + 4.0 * U)
+        return tot_energy
+    
+    def calc_grad(self, energy_1, energy_2, grad_1, grad_2):
+        b = np.exp(-1 * (energy_1 - energy_2) ** 2 / self.alpha)
+        U = self.alpha / 2.0 * b
+        a = np.sqrt((energy_1 - energy_2) ** 2 + 4.0 * U)
+        dU_dq1 = -1 * (energy_1 - energy_2) * grad_1 * b 
+        dU_dq2 = (energy_1 - energy_2) * grad_2 * b
+
+        smf_grad_1 = 0.5 * (grad_1 + grad_2) + 0.5 * (1.0 /a) * ( 2.0 * (energy_1 - energy_2) * (grad_1) + 8.0 * U * dU_dq1) + 0.5 * (1.0 /a) * (-2.0 * (energy_1 - energy_2) * (grad_2) + 8.0 * U * dU_dq2)
+        smf_grad_2 = 0.5 * (grad_1 + grad_2) + 0.5 * (1.0 /a) * ( 2.0 * (energy_1 - energy_2) * (grad_1) + 8.0 * U * dU_dq1) + 0.5 * (1.0 /a) * (-2.0 * (energy_1 - energy_2) * (grad_2) + 8.0 * U * dU_dq2)
+        
+        return smf_grad_1, smf_grad_2
+
+    def calc_hess(self, energy_1, energy_2, grad_1, grad_2, hess_1, hess_2):
+        
+        
+        return

multioptpy/ModelFunction/binary_image_ts_search_model_function.py

@@ -0,0 +1,47 @@
+import numpy as np
+
+#J. Chem. Phys. 157, 124107 (2022)
+#https://doi.org/10.1063/5.0102145
+
+class BITSSModelFunction:
+    def __init__(self, geom_num_list_1, geom_num_list_2):
+        self.f = 0.5
+        self.alpha = 10.0
+        self.beta = 0.1
+        self.d = np.linalg.norm(geom_num_list_1 - geom_num_list_2)
+        
+        return
+        
+    def calc_energy(self, energy_1, energy_2, geom_num_list_1, geom_num_list_2, gradient_1, gradient_2, iter):
+        current_distance = np.linalg.norm(geom_num_list_1 - geom_num_list_2)
+        if iter % 500 == 0:
+
+            self.E_B = abs(energy_1 - energy_2)
+            self.kappa_e = self.alpha / (2.0 * self.E_B + 1e-10)
+        
+            unit_vec = (geom_num_list_1 - geom_num_list_2) / current_distance
+            
+     
+            
+            proj_grad_1 = gradient_1 * unit_vec * (-1)
+            proj_grad_2 = gradient_2 * unit_vec
+
+            a = np.sqrt(np.linalg.norm(proj_grad_1) + np.linalg.norm(proj_grad_2)) / (2 ** 1.5 * self.beta * self.d + 1e-10)
+            b = self.E_B / (self.beta * self.d ** 2 + 1e-10)
+            self.kappa_d = max(a, b)
+            self.d = np.linalg.norm(geom_num_list_1 - geom_num_list_2)
+        
+        self.d = max((1.0 - self.f) * self.d, 1e-10)
+        energy = energy_1 + energy_2 + self.kappa_e * (energy_1 + energy_2) ** 2 + self.kappa_d * (current_distance - self.d) ** 2
+        
+        return energy
+        
+    def calc_grad(self, energy_1, energy_2, geom_num_list_1, geom_num_list_2, gradient_1, gradient_2):
+        current_vec = geom_num_list_1 - geom_num_list_2
+        current_dist = np.linalg.norm(current_vec) + 1e-10
+
+        bitss_grad_1 = gradient_1 + gradient_2 + 2.0 * self.kappa_e * (energy_1 - energy_2) * (gradient_1 - gradient_2) + current_vec * 2.0 * self.kappa_d * (current_dist - self.d) / current_dist
+
+        bitss_grad_2 = gradient_1 + gradient_2 + 2.0 * self.kappa_e * (energy_1 - energy_2) * (gradient_1 - gradient_2) - current_vec * 2.0 * self.kappa_d * (current_dist - self.d) / current_dist
+        
+        return bitss_grad_1, bitss_grad_2

multioptpy/ModelFunction/conical_model_function.py

@@ -0,0 +1,26 @@
+import numpy as np
+
+
+class ConicalModelFunction:
+    def __init__(self):
+        #ref.: J. Phys. Chem. B 2008, 112, 2, 405–413
+        self.alpha = 0.025
+        self.sigma = 3.5
+        return
+    
+    def calc_energy(self, energy_1, energy_2):
+        delta_ene = energy_1 - energy_2
+        
+        tot_energy = 0.5 * (energy_1 + energy_2) + self.sigma * delta_ene ** 2 / (delta_ene + self.alpha)
+        return tot_energy
+    
+    def calc_grad(self, energy_1, energy_2, grad_1, grad_2):
+        delta_ene = energy_1 - energy_2
+        mf_grad_1 = 0.5 * (grad_1) + 0.5 * (grad_2) + self.sigma * (delta_ene ** 2.0 + 2.0 * self.alpha * delta_ene) / (delta_ene + self.alpha) ** 2.0 * (grad_1 - grad_2)
+        mf_grad_2 = 0.5 * (grad_1) + 0.5 * (grad_2) + self.sigma * (delta_ene ** 2.0 + 2.0 * self.alpha * delta_ene) / (delta_ene + self.alpha) ** 2.0 * (grad_1 - grad_2)
+        return mf_grad_1, mf_grad_2
+    
+    def calc_hess(self, energy_1, energy_2, grad_1, grad_2, hess_1, hess_2):
+        
+        
+        return

multioptpy/ModelFunction/opt_meci.py

@@ -0,0 +1,50 @@
+import numpy as np
+
+class OptMECI:
+    def __init__(self):
+        # ref.:https://doi.org/10.1021/ct1000268
+       
+        self.switch_threshold = 5e-4
+        self.alpha = 1e-3
+        self.approx_cdv_vec = None
+        self.prev_dgv_vec = None
+        self.dgv_vec = None
+        
+        return
+    
+    def calc_energy(self, energy_1, energy_2):
+        tot_energy = (energy_1 + energy_2) / 2.0 
+        print("energy_1:", energy_1, "hartree")
+        print("energy_2:", energy_2, "hartree")
+        print("energy_1 - energy_2:", abs(energy_1 - energy_2), "hartree")
+        return tot_energy
+        
+    def calc_grad(self, energy_1, energy_2, grad_1, grad_2):
+        if self.approx_cdv_vec is None:
+            self.approx_cdv_vec = np.ones((len(grad_1)*3, 1))
+
+        delta_grad = grad_1 - grad_2
+        dgv_vec = delta_grad / np.linalg.norm(delta_grad)
+        dgv_vec = dgv_vec.reshape(-1, 1)
+        
+        if self.prev_dgv_vec is None:
+            self.prev_dgv_vec = dgv_vec
+        
+        self.approx_cdv_vec = (np.dot(self.approx_cdv_vec.T, dgv_vec) * self.prev_dgv_vec -1 * np.dot(self.prev_dgv_vec.T, dgv_vec) * self.approx_cdv_vec) / np.sqrt(np.dot(self.approx_cdv_vec.T, dgv_vec) ** 2 + np.dot(self.prev_dgv_vec.T, dgv_vec) ** 2) 
+
+        P_matrix = np.eye((len(dgv_vec))) -1 * np.dot(dgv_vec, dgv_vec.T) -1 * np.dot(self.approx_cdv_vec, self.approx_cdv_vec.T)
+        P_matrix = 0.5 * (P_matrix + P_matrix.T)
+        gp_grad =  2 * (energy_1 - energy_2) * dgv_vec + np.dot(P_matrix, 0.5 * (grad_1.reshape(-1, 1) + grad_2.reshape(-1, 1)))
+        
+        self.prev_dgv_vec = dgv_vec
+        gp_grad = gp_grad.reshape(len(grad_1), 3)
+        return gp_grad
+
+
+    def calc_hess(self, hess_1, hess_2):
+        mean_hess = 0.5 * (hess_1 + hess_2)
+        P_matrix = np.eye((len(self.prev_dgv_vec))) -1 * np.dot(self.prev_dgv_vec, self.prev_dgv_vec.T) -1 * np.dot(self.approx_cdv_vec, self.approx_cdv_vec.T)
+        P_matrix = 0.5 * (P_matrix + P_matrix.T)
+        
+        gp_hess = np.dot(P_matrix, np.dot(mean_hess, P_matrix))
+        return gp_hess