MultiOptPy 1.20.2__py3-none-any.whl

multioptpy/ModelFunction/opt_mesx.py

@@ -0,0 +1,47 @@
+import numpy as np
+
+class OptMESX:
+    def __init__(self):
+        #ref.: Chemical Physics Letters 674 (2017) 141-145
+       
+        self.switch_threshold = 5e-4
+        self.alpha = 1e-3
+        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):
+        delta_grad = grad_1 - grad_2
+        norm_delta_grad = np.linalg.norm(delta_grad)
+        if norm_delta_grad < 1e-8:
+            dgv_vec = np.zeros_like(delta_grad)
+        else:
+            dgv_vec = delta_grad / norm_delta_grad
+        dgv_vec = dgv_vec.reshape(-1, 1)
+        
+        P_matrix = np.eye((len(dgv_vec))) -1 * np.dot(dgv_vec, dgv_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)))
+        
+        gp_grad = gp_grad.reshape(len(grad_1), 3)
+        return gp_grad
+    
+    def calc_hess(self, grad_1, grad_2, hess_1, hess_2):
+        delta_grad = grad_1 - grad_2
+        norm_delta_grad = np.linalg.norm(delta_grad)
+        if norm_delta_grad < 1e-8:
+            dgv_vec = np.zeros_like(delta_grad)
+        else:
+            dgv_vec = delta_grad / norm_delta_grad
+        delta_grad = delta_grad.reshape(-1, 1)
+        dgv_vec = dgv_vec.reshape(-1, 1)
+        P_matrix = np.eye((len(dgv_vec))) -1 * np.dot(dgv_vec, dgv_vec.T)
+        P_matrix = 0.5 * (P_matrix + P_matrix.T)
+        gp_hess = 2.0 * np.dot(delta_grad, dgv_vec.T) + np.dot(P_matrix, 0.5 * (hess_1 + hess_2))
+        return gp_hess
+        

multioptpy/ModelFunction/opt_mesx_2.py

@@ -0,0 +1,49 @@
+import numpy as np
+
+class OptMESX2:
+    def __init__(self):
+        #ref.: Theor Chem Acc 99, 95–99 (1998)
+       
+        self.switch_threshold = 5e-4
+        self.alpha = 1e-3
+        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):
+        grad_1 = grad_1.reshape(-1, 1)
+        grad_2 = grad_2.reshape(-1, 1)
+        
+        delta_grad = grad_1 - grad_2
+        norm_delta_grad = np.linalg.norm(delta_grad)
+        if norm_delta_grad < 1e-8:
+            projection = np.zeros_like(delta_grad)
+        else:
+            projection = np.sum(grad_1 * delta_grad) / norm_delta_grad
+            
+        parallel = grad_1 - delta_grad * projection / norm_delta_grad
+        
+        gp_grad = (energy_1 - energy_2) * 140 * delta_grad + 1.0 * parallel
+        
+        gp_grad = gp_grad.reshape(-1, 3)
+        return gp_grad
+    
+    def calc_hess(self, grad_1, grad_2, hess_1, hess_2):
+        delta_grad = grad_1 - grad_2
+        norm_delta_grad = np.linalg.norm(delta_grad)
+        if norm_delta_grad < 1e-8:
+            dgv_vec = np.zeros_like(delta_grad)
+        else:
+            dgv_vec = delta_grad / norm_delta_grad
+        delta_grad = delta_grad.reshape(-1, 1)
+        dgv_vec = dgv_vec.reshape(-1, 1)
+        P_matrix = np.eye((len(dgv_vec))) -1 * np.dot(dgv_vec, dgv_vec.T)
+        P_matrix = 0.5 * (P_matrix + P_matrix.T)
+        
+        gp_hess = 2.0 * np.dot(delta_grad, dgv_vec.T) + np.dot(P_matrix, 0.5 * (hess_1 + hess_2))
+        return gp_hess

multioptpy/ModelFunction/seam_model_function.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+
+class SeamModelFunction:
+    def __init__(self):
+        #ref.: J. Phys. Chem. A 2009, 113, 9, 1704-1710
+        self.alpha = 0.05
+        return
+    
+    def calc_energy(self, energy_1, energy_2):
+        tot_energy = 0.5 * (energy_1 + energy_2) + (energy_1 - energy_2) ** 2 / (self.alpha)
+        return tot_energy
+    
+    def calc_grad(self, energy_1, energy_2, grad_1, grad_2):
+        
+        smf_grad_1 = 0.5 * (grad_1) + 0.5 * (grad_2) + 2 * (energy_1 - energy_2) * (grad_1 - grad_2) / (self.alpha)
+        smf_grad_2 = 0.5 * (grad_1) + 0.5 * (grad_2) + 2 * (energy_1 - energy_2) * (grad_1 - grad_2) / (self.alpha)
+        return smf_grad_1, smf_grad_2
+    
+    def calc_hess(self, energy_1, energy_2, grad_1, grad_2, hess_1, hess_2):
+        grad_1 = grad_1.reshape(-1, 1)
+        grad_2 = grad_2.reshape(-1, 1)
+        delta_grad = grad_1 - grad_2
+        delta_energy = energy_1 - energy_2
+        smf_hess = 0.5 * (hess_1 + hess_2) + (2.0 / self.alpha) * np.dot(delta_grad, delta_grad.T) + (2.0 / self.alpha) * delta_energy * (hess_1 - hess_2)
+        
+        return smf_hess

multioptpy/ModelHessian/approx_hessian.py

@@ -0,0 +1,147 @@
+import numpy as np
+
+from multioptpy.ModelHessian.fischer import FischerApproxHessian
+from multioptpy.ModelHessian.fischerd3 import FischerD3ApproxHessian
+from multioptpy.ModelHessian.fischerd4 import FischerD4ApproxHessian
+from multioptpy.ModelHessian.gfnff import GFNFFApproxHessian
+from multioptpy.ModelHessian.gfn0xtb import GFN0XTBApproxHessian
+from multioptpy.ModelHessian.lindh import LindhApproxHessian
+from multioptpy.ModelHessian.lindh2007d2 import Lindh2007D2ApproxHessian
+from multioptpy.ModelHessian.lindh2007d3 import Lindh2007D3ApproxHessian
+from multioptpy.ModelHessian.lindh2007d4 import Lindh2007D4ApproxHessian
+from multioptpy.ModelHessian.morse import MorseApproxHessian
+from multioptpy.ModelHessian.schlegel import SchlegelApproxHessian
+from multioptpy.ModelHessian.schlegeld3 import SchlegelD3ApproxHessian
+from multioptpy.ModelHessian.schlegeld4 import SchlegelD4ApproxHessian
+from multioptpy.ModelHessian.swartd2 import SwartD2ApproxHessian
+from multioptpy.ModelHessian.swartd3 import SwartD3ApproxHessian
+from multioptpy.ModelHessian.swartd4 import SwartD4ApproxHessian
+from multioptpy.ModelHessian.shortrange import ShortRangeCorrectionHessian
+from multioptpy.ModelHessian.tshess import TransitionStateHessian
+
+from multioptpy.Parameters.parameter import UnitValueLib
+
+class ApproxHessian:
+    def __init__(self):
+        return
+    
+    def main(self, coord, element_list, cart_gradient, approx_hess_type="lindh2007d3"):
+        #coord: Bohr
+        
+        
+        if "gfnff" in approx_hess_type.lower():
+            GFNFFAH = GFNFFApproxHessian()
+            hess_proj = GFNFFAH.main(coord, element_list, cart_gradient)
+        elif "gfn0xtb" in approx_hess_type.lower():
+            GFN0AH = GFN0XTBApproxHessian()
+            hess_proj = GFN0AH.main(coord, element_list, cart_gradient)
+        elif "fischerd3" in approx_hess_type.lower():
+            FAHD3 = FischerD3ApproxHessian()
+            hess_proj = FAHD3.main(coord, element_list, cart_gradient)
+        elif "fischerd4" in approx_hess_type.lower():
+            FAHD4 = FischerD4ApproxHessian()
+            hess_proj = FAHD4.main(coord, element_list, cart_gradient)
+        
+        elif "schlegeld3" in approx_hess_type.lower():
+            SAHD3 = SchlegelD3ApproxHessian()
+            hess_proj = SAHD3.main(coord, element_list, cart_gradient)
+        elif "schlegeld4" in approx_hess_type.lower():
+            SAHD4 = SchlegelD4ApproxHessian()
+            hess_proj = SAHD4.main(coord, element_list, cart_gradient)
+        elif "schlegel" in approx_hess_type.lower():
+            SAH = SchlegelApproxHessian()
+            hess_proj = SAH.main(coord, element_list, cart_gradient)
+        
+        elif "swartd3" in approx_hess_type.lower():
+            SWHD3 = SwartD3ApproxHessian()
+            hess_proj = SWHD3.main(coord, element_list, cart_gradient)
+        elif "swartd4" in approx_hess_type.lower():
+            SWHD4 = SwartD4ApproxHessian()
+            hess_proj = SWHD4.main(coord, element_list, cart_gradient)
+        elif "swart" in approx_hess_type.lower():
+            SWH = SwartD2ApproxHessian()
+            hess_proj = SWH.main(coord, element_list, cart_gradient)
+        elif "lindh2007d3" in approx_hess_type.lower():
+            LH2007D3 = Lindh2007D3ApproxHessian()
+            hess_proj = LH2007D3.main(coord, element_list, cart_gradient)
+        elif "lindh2007d4" in approx_hess_type.lower():
+            LH2007D4 = Lindh2007D4ApproxHessian()
+            hess_proj = LH2007D4.main(coord, element_list, cart_gradient)
+        elif "lindh2007" in approx_hess_type.lower():
+            LH2007 = Lindh2007D2ApproxHessian()
+            hess_proj = LH2007.main(coord, element_list, cart_gradient)
+        elif "lindh" in approx_hess_type.lower():
+            LAH = LindhApproxHessian()
+            hess_proj = LAH.main(coord, element_list, cart_gradient)
+        elif "fischer" in approx_hess_type.lower():
+            FH = FischerApproxHessian()
+            hess_proj = FH.main(coord, element_list, cart_gradient)
+        elif "morse" in approx_hess_type.lower():
+            MH = MorseApproxHessian()
+            hess_proj = MH.create_model_hessian(coord, element_list)
+        else:
+            print("Approximate Hessian type not recognized. Using default Lindh (2007) D3 model...")
+            LH2007D3 = Lindh2007D3ApproxHessian()
+            hess_proj = LH2007D3.main(coord, element_list, cart_gradient)
+            
+        if "ts" in approx_hess_type.lower():
+            print("Applying transition state Hessian modification...")
+            TSH = TransitionStateHessian()
+            hess_proj = TSH.create_ts_hessian(hess_proj, cart_gradient)
+        
+        if "sr" in approx_hess_type.lower():
+            SRCH = ShortRangeCorrectionHessian()
+            hess_proj = SRCH.main(coord, element_list, hess_proj)
+        
+        if "clip" in approx_hess_type.lower():
+            print("Applying eigenvalue clipping...")
+            #eigenvalue smoothing
+            eigval, eigvec = np.linalg.eigh(hess_proj)
+            eigval = np.asarray(eigval)
+            eigval = smooth_eigval(eigval, alpha=0.1)
+            hess_proj = np.dot(eigvec, np.dot(np.diag(eigval), eigvec.T))
+          
+        return hess_proj#cart_hess
+
+
+def smooth_eigval(eigval, alpha=0.1):
+    """Smooth eigenvalues to avoid abnormally large values"""
+    eigval = np.asarray(eigval)
+    result = eigval.astype(float, copy=True)
+    mask = np.abs(eigval) >= 1.0
+    result[mask] = np.sign(eigval[mask]) * (2.0 - 1.0 / (np.abs(eigval)[mask] ** alpha))
+    return result
+
+
+def test():
+    AH = ApproxHessian()
+    words = ["O        1.607230637      0.000000000     -4.017111134",
+             "O        1.607230637      0.463701826     -2.637210910",
+             "H        2.429229637      0.052572461     -2.324941515",
+             "H        0.785231637     -0.516274287     -4.017735703"]
+    
+    elements = []
+    coord = []
+    
+    for word in words:
+        sw = word.split()
+        elements.append(sw[0])
+        coord.append(sw[1:4])
+    
+    coord = np.array(coord, dtype="float64")/UnitValueLib().bohr2angstroms#Bohr
+    gradient = np.array([[-0.0028911  ,  -0.0015559   ,  0.0002471],
+                         [ 0.0028769  ,  -0.0013954   ,  0.0007272],
+                         [-0.0025737   ,  0.0013921   , -0.0007226],
+                         [ 0.0025880   ,  0.0015592  ,  -0.0002518]], dtype="float64")#a. u.
+    
+    hess_proj = AH.main(coord, elements, gradient)
+    
+    return hess_proj
+
+
+
+if __name__ == "__main__":#test
+    test()
+    
+    
+    

multioptpy/ModelHessian/calc_params.py

@@ -0,0 +1,227 @@
+import numpy as np
+from multioptpy.Parameters.parameter import D2_S6_parameter
+
+
+def calc_vdw_isotopic(x_ij, y_ij, z_ij, C6_param_ij, C6_VDW_ij):
+   
+    x_ij = x_ij + 1.0e-12
+    y_ij = y_ij + 1.0e-12
+    z_ij = z_ij + 1.0e-12
+    a_vdw = 20.0
+    t_1 = D2_S6_parameter * C6_param_ij
+    t_2 = x_ij ** 2 
+    t_3 = y_ij ** 2 
+    t_4 = z_ij ** 2
+    t_5 = t_2 + t_3 + t_4
+    t_6 = t_5 ** 2
+    t_7 = t_6 ** 2 
+    t_10 = t_5 ** 0.5
+    t_11 = 0.1 / C6_VDW_ij
+   
+    t_15 = np.exp(-1 * a_vdw * (t_10 * t_11 - 0.1)) + 1.0e-12
+    t_16 = 0.1 + t_15
+    t_17 = 0.1 / t_16
+    t_24 = t_16 ** 2
+    t_25 = 0.1 / t_24
+    t_29 = t_11 * t_15
+    t_33 = 0.1 / t_7
+    t_41 = a_vdw ** 2
+    t_42 = C6_VDW_ij ** 2
+    t_44 = t_41 / t_42
+    t_45 = t_15 ** 2
+    #print(t_1, t_2, t_3, t_4, t_5, t_6, t_7, t_10, t_11, t_15, t_16, t_17, t_24, t_25, t_29, t_33, t_41, t_42, t_44, t_45)
+    t_62 = -0.48 * t_1 / t_7 / t_5 * t_17 * t_2 + 0.13 * t_1 / t_10 / t_7 *  t_25 * t_2 * a_vdw * t_29 + 0.6 * t_1 * t_33 * t_17 - 0.2 * t_1 * t_33 / t_24 / t_16 * t_44 * t_2 * t_45 - t_1 / t_10 / t_6 / t_5 * t_25 * a_vdw * t_29 + t_1 * t_33 * t_25 * t_44 * t_2 * t_15
+    
+    return t_62
+
+def calc_vdw_anisotropic(x_ij, y_ij, z_ij, C6_param_ij, C6_VDW_ij):
+    a_vdw = 20.0
+    x_ij = x_ij + 1.0e-12
+    y_ij = y_ij + 1.0e-12
+    z_ij = z_ij + 1.0e-12
+    
+    t_1 = D2_S6_parameter * C6_param_ij
+    t_2 = x_ij ** 2
+    t_3 = y_ij ** 2 
+    t_4 = z_ij ** 2 
+    t_5 = t_2 + t_3 + t_4
+    t_6 = t_5 ** 2
+    t_7 = t_6 ** 2
+    t_11 = t_5 ** 0.5
+    t_12 = 0.1 / C6_VDW_ij
+   
+    t_16 = np.exp(-1 * a_vdw * (t_11 * t_12 - 0.1)) + 1.0e-12
+    t_17 = 0.1 + t_16 
+    t_25 = t_17 ** 2 
+    t_26 = 0.1 / t_25
+    t_35 = 0.1 / t_7
+    t_40 = a_vdw ** 2
+    t_41 = C6_VDW_ij ** 2
+    t_43 = t_40 / t_41
+    t_44 = t_16 ** 2
+    #print(t_1, t_2, t_3, t_4, t_5, t_6, t_7, t_11, t_12, t_16, t_17, t_25, t_26, t_35, t_40, t_41, t_43, t_44)
+    t_56 = -0.48 * t_1 / t_7 / t_5 / t_17 * x_ij * y_ij + 0.13 * t_1 / t_11 / t_7 * t_26 * x_ij * a_vdw * t_12 * y_ij * t_16 - 0.2 * t_1 * t_35 / t_25 / t_17 * t_43 * x_ij * t_44 * y_ij + t_1 * t_35 * t_26 * t_43 * x_ij * y_ij * t_16
+    #print(t_16, t_56)
+    return t_56
+    
+    
+def outofplane2(t_xyz):
+    r_1 = t_xyz[0] - t_xyz[3]
+    q_41 = np.linalg.norm(r_1)
+    e_41 = r_1 / q_41
+
+    r_2 = t_xyz[1] - t_xyz[3]
+    q_42 = np.linalg.norm(r_2)
+    e_42 = r_2 / q_42
+
+    r_3 = t_xyz[2] - t_xyz[3]
+    q_43 = np.linalg.norm(r_3)
+    e_43 = r_3 / q_43
+
+    cosfi1 = np.dot(e_43, e_42)
+
+    fi_1 = np.arccos(cosfi1)
+
+    if abs(fi_1 - np.pi) < 1e-12:
+        teta = 0.0
+        bt = 0.0
+        return teta, bt
+
+    cosfi2 = np.dot(e_41, e_43)
+    fi_2 = np.arccos(cosfi2)
+    #deg_fi_2 = 180.0 * fi_2 / np.pi
+
+    cosfi3 = np.dot(e_41, e_42)
+
+    fi_3 = np.arccos(cosfi3)
+    #deg_fi_3 = 180.0 * fi_3 / np.pi
+
+    c14 = np.zeros((3, 3))
+
+    c14[0] = t_xyz[0]
+    c14[1] = t_xyz[3]
+
+    r_42 = t_xyz[1] - t_xyz[3]
+    r_43 = t_xyz[2] - t_xyz[3]
+    c14[2][0] = r_42[1] * r_43[2] - r_42[2] * r_43[1]
+    c14[2][1] = r_42[2] * r_43[0] - r_42[0] * r_43[2]
+    c14[2][2] = r_42[0] * r_43[1] - r_42[1] * r_43[0]
+
+    if ((c14[2][0] ** 2 + c14[2][1] ** 2 + c14[2][2] ** 2) < 1e-12):
+        teta = 0.0
+        bt = 0.0
+        return teta, bt
+    c14[2][0] = c14[2][0] + t_xyz[3][0]
+    c14[2][1] = c14[2][1] + t_xyz[3][1]
+    c14[2][2] = c14[2][2] + t_xyz[3][2]
+
+    teta, br_14 = bend2(c14)
+
+    teta = teta -0.5 * np.pi
+
+    bt = np.zeros((4, 3))
+
+    for i_x in range(1, 4):
+        i_y = (i_x + 1) % 4 + (i_x + 1) // 4
+        i_z = (i_y + 1) % 4 + (i_y + 1) // 4
+        
+        bt[0][i_x-1] = -1 * br_14[2][i_x-1]
+        bt[1][i_x-1] = -1 * br_14[2][i_y-1]
+        bt[2][i_x-1] = -1 * br_14[2][i_z-1]
+        bt[3][i_x-1] = -1 * (bt[0][i_x-1] + bt[1][i_x-1] + bt[2][i_x-1])
+        
+    bt *= -1.0 
+
+    return teta, bt# angle, move_vector
+
+def torsion2(t_xyz):
+    r_ij_1, b_r_ij = stretch2(t_xyz[0:2])
+    r_ij_2, b_r_jk = stretch2(t_xyz[1:3])
+    r_ij_3, b_r_kl = stretch2(t_xyz[2:4])
+
+    fi_2, b_fi_2 = bend2(t_xyz[0:3])
+    fi_3, b_fi_3 = bend2(t_xyz[1:4])
+    sin_fi_2 = np.sin(fi_2)
+    sin_fi_3 = np.sin(fi_3)
+    cos_fi_2 = np.cos(fi_2)
+    cos_fi_3 = np.cos(fi_3)
+    costau = ( (b_r_ij[0][1] * b_r_jk[1][2] - b_r_jk[1][1] * b_r_ij[0][2])) * (b_r_jk[0][1] * b_r_kl[1][2] - b_r_jk[0][2] * b_r_kl[1][1]) + (b_r_ij[0][2] * b_r_jk[1][0] - b_r_ij[0][0] * b_r_jk[1][2]) * (b_r_jk[0][2] * b_r_kl[1][0] - b_r_jk[0][0] * b_r_kl[1][2]) + (b_r_ij[0][0] * b_r_jk[1][1] - b_r_ij[0][1] * b_r_jk[1][0]) * (b_r_jk[0][0] * b_r_kl[1][1] - b_r_jk[0][1] * b_r_kl[1][0]) / (sin_fi_2 * sin_fi_3)
+    sintau = (b_r_ij[1][0] * (b_r_jk[0][1] * b_r_kl[1][2] - b_r_jk[0][2] * b_r_kl[1][1]) + b_r_ij[1][1] * (b_r_jk[0][2] * b_r_kl[1][0] - b_r_jk[0][0] * b_r_kl[1][2]) + b_r_ij[1][2] * (b_r_jk[0][0] * b_r_kl[1][1] - b_r_jk[0][1] * b_r_kl[1][0])) / (sin_fi_2 * sin_fi_3)
+
+    tau = np.arctan2(sintau, costau)
+
+    if abs(tau) == np.pi:
+        tau = np.pi
+
+    bt = np.zeros((4, 3))
+    for i_x in range(1,4):
+        i_y = i_x + 1
+        if i_y > 3:
+            i_y = i_y - 3
+        i_z = i_y + 1
+        if i_z > 3:
+            i_z = i_z - 3
+        bt[0][i_x-1] = (b_r_ij[1][i_y-1] * b_r_jk[1][i_z-1] - b_r_ij[1][i_z-1] * b_r_jk[1][i_y-1]) / (r_ij_1 * sin_fi_2 ** 2)
+        bt[3][i_x-1] = (b_r_kl[0][i_y-1] * b_r_jk[0][i_z-1] - b_r_kl[0][i_z-1] * b_r_jk[0][i_y-1]) / (r_ij_3 * sin_fi_3 ** 2)
+        bt[1][i_x-1] = -1 * ((r_ij_2 - r_ij_1 * cos_fi_2) * bt[0][i_x-1] + r_ij_3 * cos_fi_3 * bt[3][i_x-1]) / r_ij_2
+        bt[2][i_x-1] = -1 * (bt[0][i_x-1] + bt[1][i_x-1] + bt[3][i_x-1])
+
+    for ix in range(1, 4):
+        iy = ix + 1
+        if iy > 3:
+            iy = iy - 3
+        iz = iy + 1
+        if iz > 3:
+            iz = iz - 3
+        bt[0][ix-1] = (b_r_ij[1][iy-1] * b_r_jk[1][iz-1] - b_r_ij[1][iz-1] * b_r_jk[1][iy-1]) / (r_ij_1 * sin_fi_2 ** 2)
+        bt[3][ix-1] = (b_r_kl[0][iy-1] * b_r_jk[0][iz-1] - b_r_kl[0][iz-1] * b_r_jk[0][iy-1]) / (r_ij_3 * sin_fi_3 ** 2)
+        bt[1][ix-1] = -1 * ((r_ij_2 - r_ij_1 * cos_fi_2) * bt[0][ix-1] + r_ij_3 * cos_fi_3 * bt[3][ix-1]) / r_ij_2
+        bt[2][ix-1] = -1 * (bt[0][ix-1] + bt[1][ix-1] + bt[3][ix-1])
+
+    return tau, bt # angle, move_vector
+
+def bend2(t_xyz):
+    r_ij_1, b_r_ij = stretch2(t_xyz[0:2])
+    r_jk_1, b_r_jk = stretch2(t_xyz[1:3])
+    c_o = 0.0
+    crap = 0.0
+    for i in range(3):
+        c_o += b_r_ij[0][i] * b_r_jk[1][i]
+        crap += b_r_ij[0][i] ** 2
+        crap += b_r_jk[1][i] ** 2
+
+    if np.sqrt(crap) < 1e-12:
+        fir = np.pi - np.arcsin(np.sqrt(crap))
+        si = np.sqrt(crap)
+    else:
+        fir = np.arccos(c_o)
+        si = np.sqrt(1 - c_o ** 2)
+
+    if np.abs(fir - np.pi) < 1e-12:
+        fir = np.pi
+
+    bf = np.zeros((3, 3))
+    denom_1 = r_ij_1 * si
+    denom_2 = r_jk_1 * si
+    
+    for i in range(3):
+        if denom_1 < 1e-12:
+            bf[0][i] = 0.0
+        else:
+            bf[0][i] = (c_o * b_r_ij[0][i] - b_r_jk[1][i]) / denom_1
+        if denom_2 < 1e-12:
+            bf[2][i] = 0.0
+        else:
+            bf[2][i] = (c_o * b_r_jk[1][i] - b_r_ij[0][i]) / denom_2
+        bf[1][i] = -1 * (bf[0][i] + bf[2][i])
+
+    return fir, bf # angle, move_vector
+
+def stretch2(t_xyz):
+    dist = t_xyz[0] - t_xyz[1]
+    norm_dist = np.linalg.norm(dist)
+    b = np.zeros((2,3))
+    b[0] = -1 * dist / norm_dist
+    b[1] = dist / norm_dist
+    return norm_dist, b # distance, move_vectors (unit_vector)
+