MultiOptPy 1.20.2__py3-none-any.whl

multioptpy/Potential/keep_dihedral_angle_potential.py

@@ -0,0 +1,105 @@
+
+from multioptpy.Parameters.parameter import UnitValueLib
+from multioptpy.Utils.calc_tools import torch_calc_dihedral_angle_from_vec
+import torch
+
+class StructKeepDihedralAnglePotential:
+    def __init__(self, **kwarg):
+        self.config = kwarg
+        UVL = UnitValueLib()
+        self.hartree2kcalmol = UVL.hartree2kcalmol 
+        self.bohr2angstroms = UVL.bohr2angstroms 
+        self.hartree2kjmol = UVL.hartree2kjmol 
+        return
+    def calc_energy(self, geom_num_list, bias_pot_params=[]):
+        """
+        # required variables: self.config["keep_dihedral_angle_spring_const"],
+                              self.config["keep_dihedral_angle_atom_pairs"]
+                              self.config["keep_dihedral_angle_angle"]
+        bias_pot_params[0] : keep_dihedral_angle_spring_const
+        bias_pot_params[1] : keep_dihedral_angle_angle
+        """
+        a1 = geom_num_list[self.config["keep_dihedral_angle_atom_pairs"][1]-1] - geom_num_list[self.config["keep_dihedral_angle_atom_pairs"][0]-1]
+        a2 = geom_num_list[self.config["keep_dihedral_angle_atom_pairs"][2]-1] - geom_num_list[self.config["keep_dihedral_angle_atom_pairs"][1]-1]
+        a3 = geom_num_list[self.config["keep_dihedral_angle_atom_pairs"][3]-1] - geom_num_list[self.config["keep_dihedral_angle_atom_pairs"][2]-1]
+
+        angle = torch.abs(torch_calc_dihedral_angle_from_vec(a1, a2, a3))
+        if len(bias_pot_params) == 0:
+            energy = 0.5 * self.config["keep_dihedral_angle_spring_const"] * (angle - torch.deg2rad(torch.tensor(self.config["keep_dihedral_angle_angle"]))) ** 2
+        else:
+            energy = 0.5 * bias_pot_params[0] * (angle - torch.deg2rad(bias_pot_params[1])) ** 2
+      
+        return energy #hartree    
+
+
+class StructKeepDihedralAnglePotentialv2:
+    def __init__(self, **kwarg):
+        self.config = kwarg
+        UVL = UnitValueLib()
+        self.hartree2kcalmol = UVL.hartree2kcalmol 
+        self.bohr2angstroms = UVL.bohr2angstroms 
+        self.hartree2kjmol = UVL.hartree2kjmol 
+        return
+    def calc_energy(self, geom_num_list, bias_pot_params=[]):
+        """
+        # required variables: self.config["keep_dihedral_angle_v2_spring_const"], 
+                             self.config["keep_dihedral_angle_v2_angle"], 
+                             self.config["keep_dihedral_angle_v2_fragm1"],
+                             self.config["keep_dihedral_angle_v2_fragm2"],
+                             self.config["keep_dihedral_angle_v2_fragm3"],
+                             self.config["keep_dihedral_angle_v2_fragm4"],
+        bias_pot_params[0] : keep_dihedral_angle_v2_spring_const
+        bias_pot_params[1] : keep_dihedral_angle_v2_angle                  
+        """
+        fragm_1_center = torch.mean(geom_num_list[torch.tensor(self.config["keep_dihedral_angle_v2_fragm1"]) - 1], dim=0)
+        fragm_2_center = torch.mean(geom_num_list[torch.tensor(self.config["keep_dihedral_angle_v2_fragm2"]) - 1], dim=0)
+        fragm_3_center = torch.mean(geom_num_list[torch.tensor(self.config["keep_dihedral_angle_v2_fragm3"]) - 1], dim=0)
+        fragm_4_center = torch.mean(geom_num_list[torch.tensor(self.config["keep_dihedral_angle_v2_fragm4"]) - 1], dim=0)
+              
+        a1 = fragm_2_center - fragm_1_center
+        a2 = fragm_3_center - fragm_2_center
+        a3 = fragm_4_center - fragm_3_center
+
+        angle = torch.abs(torch_calc_dihedral_angle_from_vec(a1, a2, a3))
+        if len(bias_pot_params) == 0:
+            energy = 0.5 * self.config["keep_dihedral_angle_v2_spring_const"] * (angle - torch.deg2rad(torch.tensor(self.config["keep_dihedral_angle_v2_angle"]))) ** 2
+        else:
+            energy = 0.5 * bias_pot_params[0] * (angle - torch.deg2rad(bias_pot_params[1])) ** 2
+        return energy #hartree
+    
+class StructKeepDihedralAnglePotentialCos:
+    def __init__(self, **kwarg):
+        self.config = kwarg
+        UVL = UnitValueLib()
+        self.hartree2kcalmol = UVL.hartree2kcalmol 
+        self.bohr2angstroms = UVL.bohr2angstroms 
+        self.hartree2kjmol = UVL.hartree2kjmol 
+        return
+    def calc_energy(self, geom_num_list, bias_pot_params=[]):
+        """
+        # required variables: self.config["keep_dihedral_angle_cos_potential_const"],
+                             self.config["keep_dihedral_angle_cos_angle_const"], 
+                             self.config["keep_dihedral_angle_cos_angle"], 
+                             self.config["keep_dihedral_angle_cos_fragm1"],
+                             self.config["keep_dihedral_angle_cos_fragm2"],
+                             self.config["keep_dihedral_angle_cos_fragm3"],
+                             self.config["keep_dihedral_angle_cos_fragm4"],
+                             
+        """
+        potential_const = float(self.config["keep_dihedral_angle_cos_potential_const"])
+        angle_const = float(self.config["keep_dihedral_angle_cos_angle_const"])
+        
+        
+        fragm_1_center = torch.mean(geom_num_list[torch.tensor(self.config["keep_dihedral_angle_cos_fragm1"]) - 1], dim=0)
+        fragm_2_center = torch.mean(geom_num_list[torch.tensor(self.config["keep_dihedral_angle_cos_fragm2"]) - 1], dim=0)
+        fragm_3_center = torch.mean(geom_num_list[torch.tensor(self.config["keep_dihedral_angle_cos_fragm3"]) - 1], dim=0)
+        fragm_4_center = torch.mean(geom_num_list[torch.tensor(self.config["keep_dihedral_angle_cos_fragm4"]) - 1], dim=0)
+            
+        a1 = fragm_2_center - fragm_1_center
+        a2 = fragm_3_center - fragm_2_center
+        a3 = fragm_4_center - fragm_3_center
+
+        angle = torch_calc_dihedral_angle_from_vec(a1, a2, a3)
+        energy = 0.5 * potential_const * (1.0 -1* torch.cos(angle_const * angle - (torch.deg2rad(torch.tensor(self.config["keep_dihedral_angle_cos_angle"])))))
+              
+        return energy #hartree

multioptpy/Potential/keep_outofplain_angle_potential.py

@@ -0,0 +1,70 @@
+
+from multioptpy.Parameters.parameter import UnitValueLib
+from multioptpy.Utils.calc_tools import torch_calc_outofplain_angle_from_vec
+import torch
+
+
+class StructKeepOutofPlainAnglePotential:
+    def __init__(self, **kwarg):
+        self.config = kwarg
+        UVL = UnitValueLib()
+        self.hartree2kcalmol = UVL.hartree2kcalmol 
+        self.bohr2angstroms = UVL.bohr2angstroms 
+        self.hartree2kjmol = UVL.hartree2kjmol 
+        return
+    def calc_energy(self, geom_num_list, bias_pot_params=[]):
+        """
+        # required variables: self.config["keep_out_of_plain_angle_spring_const"],
+                              self.config["keep_out_of_plain_angle_atom_pairs"]
+                              self.config["keep_out_of_plain_angle_angle"]
+        bias_pot_params[0] : keep_out_of_plain_angle_spring_const
+        bias_pot_params[1] : keep_out_of_plain_angle_angle 
+                        
+        """
+        a1 = geom_num_list[self.config["keep_out_of_plain_angle_atom_pairs"][1]-1] - geom_num_list[self.config["keep_out_of_plain_angle_atom_pairs"][0]-1]
+        a2 = geom_num_list[self.config["keep_out_of_plain_angle_atom_pairs"][2]-1] - geom_num_list[self.config["keep_out_of_plain_angle_atom_pairs"][0]-1]
+        a3 = geom_num_list[self.config["keep_out_of_plain_angle_atom_pairs"][3]-1] - geom_num_list[self.config["keep_out_of_plain_angle_atom_pairs"][0]-1]
+
+        angle = torch_calc_outofplain_angle_from_vec(a1, a2, a3)
+        if len(bias_pot_params) == 0:
+            energy = 0.5 * self.config["keep_out_of_plain_angle_spring_const"] * (angle - torch.deg2rad(torch.tensor(self.config["keep_out_of_plain_angle_angle"]))) ** 2
+        else:
+            energy = 0.5 * bias_pot_params[0] * (angle - torch.deg2rad(bias_pot_params[1])) ** 2
+        return energy #hartree 
+       
+class StructKeepOutofPlainAnglePotentialv2:
+    def __init__(self, **kwarg):
+        self.config = kwarg
+        UVL = UnitValueLib()
+        self.hartree2kcalmol = UVL.hartree2kcalmol 
+        self.bohr2angstroms = UVL.bohr2angstroms 
+        self.hartree2kjmol = UVL.hartree2kjmol 
+        return
+    
+    def calc_energy(self, geom_num_list, bias_pot_params=[]):
+        """
+        # required variables: self.config["keep_out_of_plain_angle_v2_spring_const"], 
+                             self.config["keep_out_of_plain_angle_v2_angle"], 
+                             self.config["keep_out_of_plain_angle_v2_fragm1"],
+                             self.config["keep_out_of_plain_angle_v2_fragm2"],
+                             self.config["keep_out_of_plain_angle_v2_fragm3"],
+                             self.config["keep_out_of_plain_angle_v2_fragm4"],
+                             
+        """
+        fragm_1_center = torch.mean(geom_num_list[torch.tensor(self.config["keep_out_of_plain_angle_v2_fragm1"]) - 1], dim=0)
+        fragm_2_center = torch.mean(geom_num_list[torch.tensor(self.config["keep_out_of_plain_angle_v2_fragm2"]) - 1], dim=0)
+        fragm_3_center = torch.mean(geom_num_list[torch.tensor(self.config["keep_out_of_plain_angle_v2_fragm3"]) - 1], dim=0)
+        fragm_4_center = torch.mean(geom_num_list[torch.tensor(self.config["keep_out_of_plain_angle_v2_fragm4"]) - 1], dim=0)
+
+              
+        a1 = fragm_2_center - fragm_1_center
+        a2 = fragm_3_center - fragm_1_center
+        a3 = fragm_4_center - fragm_1_center
+        
+        angle = torch_calc_outofplain_angle_from_vec(a1, a2, a3)
+        if len(bias_pot_params) == 0:
+            energy = 0.5 * self.config["keep_out_of_plain_angle_v2_spring_const"] * (angle - torch.deg2rad(torch.tensor(self.config["keep_out_of_plain_angle_v2_angle"]))) ** 2
+        else:
+            energy = 0.5 * bias_pot_params[0] * (angle - torch.deg2rad(bias_pot_params[1])) ** 2
+        return energy #hartree
+

multioptpy/Potential/keep_potential.py

@@ -0,0 +1,99 @@
+
+from multioptpy.Parameters.parameter import UnitValueLib
+import torch
+  
+class StructKeepPotential:
+    def __init__(self, **kwarg):
+        self.config = kwarg
+        UVL = UnitValueLib()
+        self.hartree2kcalmol = UVL.hartree2kcalmol 
+        self.bohr2angstroms = UVL.bohr2angstroms 
+        self.hartree2kjmol = UVL.hartree2kjmol 
+        return
+    
+    def calc_energy(self, geom_num_list, bias_pot_params=[]):
+        """
+        # required variables: self.config["keep_pot_spring_const"], 
+                             self.config["keep_pot_distance"], 
+                             self.config["keep_pot_atom_pairs"],
+        bias_pot_params[0] : keep_pot_spring_const
+        bias_pot_params[1] : keep_pot_distance
+        """
+        vector = torch.linalg.norm((geom_num_list[self.config["keep_pot_atom_pairs"][0]-1] - geom_num_list[self.config["keep_pot_atom_pairs"][1]-1]), ord=2)
+        if len(bias_pot_params) == 0:
+            energy = 0.5 * self.config["keep_pot_spring_const"] * (vector - self.config["keep_pot_distance"]/self.bohr2angstroms) ** 2
+        else:
+            energy = 0.5 * bias_pot_params[0] * (vector - bias_pot_params[1]/self.bohr2angstroms) ** 2
+        return energy #hartree
+    
+class StructKeepPotentialv2:
+    def __init__(self, **kwarg):
+        self.config = kwarg
+        UVL = UnitValueLib()
+        self.hartree2kcalmol = UVL.hartree2kcalmol 
+        self.bohr2angstroms = UVL.bohr2angstroms 
+        self.hartree2kjmol = UVL.hartree2kjmol 
+        return
+    def calc_energy(self, geom_num_list, bias_pot_params=[]):
+        """
+        # required variables: self.config["keep_pot_v2_spring_const"], 
+                             self.config["keep_pot_v2_distance"], 
+                             self.config["keep_pot_v2_fragm1"],
+                             self.config["keep_pot_v2_fragm2"],
+        bias_pot_params[0] : keep_pot_v2_spring_const
+        bias_pot_params[1] : keep_pot_v2_distance    
+        """
+        fragm_1_indices = torch.tensor(self.config["keep_pot_v2_fragm1"]) - 1
+        fragm_2_indices = torch.tensor(self.config["keep_pot_v2_fragm2"]) - 1
+
+        fragm_1_center = torch.mean(geom_num_list[fragm_1_indices], dim=0)
+        fragm_2_center = torch.mean(geom_num_list[fragm_2_indices], dim=0)
+        
+        distance = torch.linalg.norm(fragm_1_center - fragm_2_center, ord=2)
+        if len(bias_pot_params) == 0:
+            energy = 0.5 * self.config["keep_pot_v2_spring_const"] * (distance - self.config["keep_pot_v2_distance"]/self.bohr2angstroms) ** 2
+        
+        else:
+            energy = 0.5 * bias_pot_params[0] * (distance - bias_pot_params[1]/self.bohr2angstroms) ** 2
+        
+        return energy #hartree
+    
+class StructKeepPotentialAniso:
+    def __init__(self, **kwarg):
+        self.config = kwarg
+        UVL = UnitValueLib()
+        self.hartree2kcalmol = UVL.hartree2kcalmol 
+        self.bohr2angstroms = UVL.bohr2angstroms 
+        self.hartree2kjmol = UVL.hartree2kjmol 
+        return
+    def calc_energy(self, geom_num_list, bias_pot_params=[]):
+        """
+        # required variables:   self.config["aniso_keep_pot_v2_spring_const_mat"]
+                                self.config["aniso_keep_pot_v2_dist"] 
+                                self.config["aniso_keep_pot_v2_fragm1"]
+                                self.config["aniso_keep_pot_v2_fragm2"]
+                             
+        """
+        fragm_1_center = torch.tensor([0.0, 0.0, 0.0], dtype=torch.float64, requires_grad=True)
+        for i in self.config["aniso_keep_pot_v2_fragm1"]:
+            fragm_1_center = fragm_1_center + geom_num_list[i-1]
+        
+        fragm_1_center = fragm_1_center / len(self.config["aniso_keep_pot_v2_fragm1"])
+        
+        fragm_2_center = torch.tensor([0.0, 0.0, 0.0], dtype=torch.float64, requires_grad=True)
+        for i in self.config["aniso_keep_pot_v2_fragm2"]:
+            fragm_2_center = fragm_2_center + geom_num_list[i-1]
+        
+        fragm_2_center = fragm_2_center / len(self.config["aniso_keep_pot_v2_fragm2"])     
+        x_dist = torch.abs(fragm_1_center[0] - fragm_2_center[0])
+        y_dist = torch.abs(fragm_1_center[1] - fragm_2_center[1])
+        z_dist = torch.abs(fragm_1_center[2] - fragm_2_center[2])
+        eq_dist = self.config["aniso_keep_pot_v2_dist"]  / (3 ** 0.5) / self.bohr2angstroms
+        dist_vec = torch.stack([(x_dist - eq_dist) ** 2,(y_dist - eq_dist) ** 2,(z_dist - eq_dist) ** 2])
+        dist_vec = torch.reshape(dist_vec, (3, 1))
+        vec_pot = torch.matmul(torch.tensor(self.config["aniso_keep_pot_v2_spring_const_mat"], dtype=torch.float32), dist_vec)
+        
+        energy = torch.sum(vec_pot)
+        
+        
+        return energy #hartree

multioptpy/Potential/mechano_force_potential.py

@@ -0,0 +1,74 @@
+from multioptpy.Parameters.parameter import UnitValueLib
+
+import torch
+
+class LinearMechanoForcePotential:
+    def __init__(self, **kwarg):
+        #ref: J. Am. Chem. Soc. 2009, 131, 18, 6377–6379
+		#https://doi.org/10.1021/ja8095834
+        #FMPES
+        # This implementation is not tested yet.
+        self.config = kwarg
+        UVL = UnitValueLib()
+        self.hartree2kcalmol = UVL.hartree2kcalmol 
+        self.bohr2angstroms = UVL.bohr2angstroms 
+        self.hartree2kjmol = UVL.hartree2kjmol
+        self.pN2au = 1.213 * 10 ** (-5)
+        return
+    
+    def calc_energy(self, geom_num_list, bias_pot_params=[]):
+        """
+        # required variables: self.config["linear_mechano_force"], 
+                             self.config["linear_mechano_force_atoms_1"], 
+                             self.config["linear_mechano_force_atoms_2"],
+        bias_pot_params[0] : linear_mechano_force
+        """
+        direction_1 = geom_num_list[self.config["linear_mechano_force_atoms_1"][1] - 1] - geom_num_list[self.config["linear_mechano_force_atoms_1"][0] - 1]
+        direction_2 = geom_num_list[self.config["linear_mechano_force_atoms_2"][1] - 1] - geom_num_list[self.config["linear_mechano_force_atoms_2"][0] - 1]
+        norm_direction_1 = torch.linalg.norm(direction_1)
+        norm_direction_2 = torch.linalg.norm(direction_2)
+        unit_direction_1 = direction_1 / norm_direction_1
+        unit_direction_2 = direction_2 / norm_direction_2
+        
+        if len(bias_pot_params) == 0:
+            force_magnitude = 0.5 * self.config["linear_mechano_force"] * self.pN2au
+            energy = force_magnitude * torch.sum(unit_direction_1) + force_magnitude * torch.sum(unit_direction_2)
+        else:
+            force_magnitude = 0.5 * self.pN2au * bias_pot_params[0]
+            energy =  force_magnitude * torch.sum(unit_direction_1) + force_magnitude * torch.sum(unit_direction_2)
+        return energy #hartree
+        
+        
+class LinearMechanoForcePotentialv2:
+    def __init__(self, **kwarg):
+        #ref: J. Am. Chem. Soc. 2009, 131, 18, 6377–6379
+		#https://doi.org/10.1021/ja8095834
+        #FMPES
+        # This implementation is not tested yet.
+        self.config = kwarg
+        UVL = UnitValueLib()
+        self.hartree2kcalmol = UVL.hartree2kcalmol 
+        self.bohr2angstroms = UVL.bohr2angstroms 
+        self.hartree2kjmol = UVL.hartree2kjmol
+        self.pN2au = 1.213 * 10 ** (-5)
+        return
+    
+    def calc_energy(self, geom_num_list, bias_pot_params=[]):
+        """
+        # required variables: self.config["linear_mechano_force_v2"], 
+                             self.config["linear_mechano_force_atom_v2"], 
+        bias_pot_params[0] : linear_mechano_force_v2
+        """
+
+        direction = geom_num_list[self.config["linear_mechano_force_atom_v2"][0] - 1] - geom_num_list[self.config["linear_mechano_force_atom_v2"][1] - 1]
+        norm_direction = torch.linalg.norm(direction)  
+        
+        if len(bias_pot_params) == 0:
+            force_magnitude = self.config["linear_mechano_force"] * self.pN2au
+            energy = -1 * force_magnitude * norm_direction
+        else:
+            force_magnitude = self.pN2au * bias_pot_params[0]
+            energy = -1 * force_magnitude * norm_direction
+        
+        return energy #hartree    
+        

multioptpy/Potential/nanoreactor_potential.py

@@ -0,0 +1,52 @@
+
+from multioptpy.Parameters.parameter import UnitValueLib, atomic_mass
+
+import torch
+  
+  
+      
+class NanoReactorPotential:
+    def __init__(self, **kwarg):
+        # ref.:https://doi.org/10.1038/nchem.2099, https://doi.org/10.1021/acs.jctc.4c00826
+        self.config = kwarg
+        UVL = UnitValueLib()
+        self.hartree2kcalmol = UVL.hartree2kcalmol 
+        self.bohr2angstroms = UVL.bohr2angstroms 
+        self.hartree2kjmol = UVL.hartree2kjmol 
+        self.au2sec = UVL.au2sec
+        self.inner_wall = torch.tensor(self.config["inner_wall"] / self.bohr2angstroms, dtype=torch.float64)
+        self.outer_wall = torch.tensor(self.config["outer_wall"] / self.bohr2angstroms, dtype=torch.float64)
+        self.contraction_time = torch.tensor(self.config["contraction_time"] * 10 ** -12 / self.au2sec, dtype=torch.float64) #pico-sec to au
+        self.expansion_time = torch.tensor(self.config["expansion_time"] * 10 ** -12 / self.au2sec, dtype=torch.float64) #pico-sec to au
+        
+        self.contraction_force_const = self.config["contraction_force_const"] / self.hartree2kcalmol * self.bohr2angstroms ** 2 # kcal/mol/A^2 to hartree/bohr^2
+        self.expansion_force_const = self.config["expansion_force_const"] / self.hartree2kcalmol * self.bohr2angstroms ** 2 # kcal/mol/A^2 to hartree/bohr^2
+        self.element_list = self.config["element_list"]
+        self.atom_mass_list = torch.tensor([[atomic_mass(element)] for element in self.element_list], dtype=torch.float64)
+
+        return
+    
+    def calc_energy(self, geom_num_list, time):#geom_num_list: (n_atoms, 3), bohr time: au 
+        """
+        # required variables: self.inner_wall, 
+                             self.outer_wall, 
+                             self.contraction_time,
+                             self.expansion_time,
+                             self.contraction_force_const,
+                             self.expansion_force_const,
+                             self.element_list
+        """
+        distance_list = torch.linalg.norm(geom_num_list, ord=2, dim=1).reshape(-1, 1)
+        distance_inner = distance_list - self.inner_wall
+        distance_outer = distance_list - self.outer_wall
+        
+        f_t = torch.heaviside(torch.floor(time / (self.contraction_time + self.expansion_time)) - (time / (self.contraction_time + self.expansion_time)) + (self.contraction_time / (self.contraction_time + self.expansion_time)), torch.tensor(0.5, dtype=torch.float64))
+        
+        
+        U_c = torch.where(distance_list < self.inner_wall, self.atom_mass_list * 0.5 * self.contraction_force_const * distance_inner ** 2, torch.zeros_like(distance_inner))
+        
+        U_e = torch.where(distance_list > self.outer_wall, self.atom_mass_list * 0.5 * self.contraction_force_const * distance_outer ** 2,
+                          torch.where(distance_list < self.inner_wall, self.atom_mass_list * 0.5 * self.expansion_force_const * distance_inner ** 2, torch.zeros_like(distance_list)))
+        energy = torch.sum(f_t * U_c + (1.0 - f_t) * U_e)
+        return energy #hartree
+