MultiOptPy 1.20.2__py3-none-any.whl

multioptpy/Potential/spacer_model_potential.py

@@ -0,0 +1,221 @@
+
+from multioptpy.Parameters.parameter import UnitValueLib, UFF_VDW_distance_lib, UFF_VDW_well_depth_lib
+from multioptpy.Optimizer.fire import FIRE
+
+import numpy as np
+import torch
+import copy
+
+
+class SpacerModelPotential:
+    def __init__(self, mm_pot_type="UFF", **kwarg):
+        if mm_pot_type == "UFF":
+            self.VDW_distance_lib = UFF_VDW_distance_lib #function
+            self.VDW_well_depth_lib = UFF_VDW_well_depth_lib #function
+        else:
+            raise "Unexpected MM potential type"
+        self.config = kwarg
+        
+        UVL = UnitValueLib()
+        self.hartree2kcalmol = UVL.hartree2kcalmol 
+        self.bohr2angstroms = UVL.bohr2angstroms 
+        self.hartree2kjmol = UVL.hartree2kjmol 
+        
+        self.a = 1.0
+        self.num2tgtatomlabel = {}
+        for num, tgt_atom_num in enumerate(self.config["spacer_model_potential_target"]):
+            self.num2tgtatomlabel[num] = tgt_atom_num - 1
+
+        self.nparticle = self.config["spacer_model_potential_particle_number"]
+        self.element_list = self.config["element_list"]
+        self.natom = len(self.element_list)
+        self.particle_num_list = None
+
+        self.file_directory = self.config["directory"]
+        self.lj_repulsive_order = 12.0
+        self.lj_attractive_order = 6.0
+        
+        self.micro_iteration = 5000 * self.config["spacer_model_potential_particle_number"]
+        self.rand_search_iteration = 250 * self.config["spacer_model_potential_particle_number"]
+        self.threshold = 2e-6
+        self.init = True
+        return
+    
+    def save_state(self):      
+        with open(self.file_directory + "/spacer.xyz", "a") as f:
+            f.write(str(len(self.tmp_geom_num_list_for_save)) + "\n")
+            f.write("spacer\n")
+            for i in range(len(self.tmp_geom_num_list_for_save)):
+                f.write(self.tmp_element_list_for_save[i] + " " + str(self.tmp_geom_num_list_for_save[i][0].item()) + " " + str(self.tmp_geom_num_list_for_save[i][1].item()) + " " + str(self.tmp_geom_num_list_for_save[i][2].item()) + "\n")
+        
+        return
+    
+
+    def lennard_johns_potential(self, distance, sigma, epsilon):
+        ene = epsilon * ((sigma/distance) ** self.lj_repulsive_order -2 * (sigma/distance) ** self.lj_attractive_order)
+        return ene
+
+
+    def morse_potential(self, distance, sigma, epsilon):
+        ene = epsilon * (torch.exp(-2 * self.a * (distance - sigma)) -2 * torch.exp(-1 * self.a * (distance - sigma)))
+        return ene
+
+    
+    def barrier_switching_potential(self, distance, sigma):
+        normalized_distance = distance / sigma
+        min_norm_dist = 0.9
+        max_norm_dist = 1.0
+        const = 0.5
+        
+        in_range = (normalized_distance >= min_norm_dist) & (normalized_distance < max_norm_dist)
+        out_of_range = normalized_distance >= max_norm_dist
+        ene = torch.zeros_like(normalized_distance) 
+
+        normalized_diff = (normalized_distance - min_norm_dist) / (max_norm_dist - min_norm_dist)
+        ene[in_range] = -const * (
+            1 - 10 * normalized_diff[in_range]**3
+            + 15 * normalized_diff[in_range]**4
+            - 6 * normalized_diff[in_range]**5
+        ) + const
+
+        ene[out_of_range] = const * normalized_distance[out_of_range]
+        ene = torch.sum(ene)
+        return ene
+
+    
+    def calc_potential(self, geom_num_list, particle_num_list, bias_pot_params):
+        energy = 0.0
+        particle_sigma = self.config["spacer_model_potential_distance"] / self.bohr2angstroms
+        particle_epsilon = self.config["spacer_model_potential_well_depth"] / self.hartree2kjmol
+        #atom-particle interactions
+        spacer_indices = torch.tensor([i for i in range(len(self.config["element_list"]))])
+        geom_particles = geom_num_list[spacer_indices]  # shape: (M, 3), M = len(spacer_model_potential_target)
+        atom_sigmas = torch.tensor([self.VDW_distance_lib(self.config["element_list"][idx]) for idx in spacer_indices])
+        atom_epsilons = torch.tensor([self.VDW_well_depth_lib(self.config["element_list"][idx]) for idx in spacer_indices])
+        sigma = particle_sigma + atom_sigmas.unsqueeze(1)  # shape: (M, 1) + (1, N) -> (M, N)
+        epsilon = torch.sqrt(particle_epsilon * atom_epsilons.unsqueeze(1))  # shape: (M, 1)
+        diffs = geom_particles.unsqueeze(1) - particle_num_list.unsqueeze(0)  # shape: (M, N, 3)
+        distances = torch.linalg.norm(diffs, dim=-1)  # shape: (M, N)
+        pairwise_energies = self.lennard_johns_potential(distances, sigma, epsilon)
+        energy = energy + pairwise_energies.sum()
+
+        #particle-particle interactions
+        diffs = particle_num_list.unsqueeze(1) - particle_num_list.unsqueeze(0)  # shape: (N, N, 3)
+        distances = torch.linalg.norm(diffs, dim=-1)  # shape: (N, N), diagonal is 0 (self distance)
+        i, j = torch.triu_indices(distances.shape[0], distances.shape[1], offset=1)
+        pairwise_distances = distances[i, j]  
+        pairwise_energies = self.lennard_johns_potential(pairwise_distances, 2 * particle_sigma, particle_epsilon)
+        energy = energy + pairwise_energies.sum()
+
+        #avoid scattering particle to outside of cavity
+        target_geom = geom_num_list[np.array(self.config["spacer_model_potential_target"]) - 1]
+
+        norm_diff = torch.abs(torch.linalg.norm(target_geom, dim=1).unsqueeze(1) - torch.linalg.norm(particle_num_list, dim=1).unsqueeze(0))
+        min_dist, min_idx = torch.min(norm_diff, dim=0)
+     
+        element_indices = [self.num2tgtatomlabel[idx.item()] for idx in min_idx]
+        atom_sigmas = self.config["spacer_model_potential_cavity_scaling"] * torch.tensor(
+            [self.VDW_distance_lib(self.config["element_list"][idx]) for idx in element_indices]
+        )
+
+        energy =  energy + self.barrier_switching_potential(min_dist, atom_sigmas)
+
+        self.tmp_geom_num_list_for_save = torch.cat([geom_num_list, particle_num_list], dim=0) * self.bohr2angstroms
+        self.tmp_element_list_for_save = self.config["element_list"] + ["He"] * len(particle_num_list)
+        
+        return energy
+    
+    def rand_search(self, geom_num_list, bias_pot_params):
+        max_energy = 1e+10
+        print("rand_search")
+        for i in range(self.rand_search_iteration):
+            center = torch.mean(geom_num_list[np.array(self.config["spacer_model_potential_target"])-1], dim=0)
+            tmp_particle_num_list = torch.normal(mean=0, std=100, size=(self.config["spacer_model_potential_particle_number"], 3)) + center
+            energy = self.calc_potential(geom_num_list, tmp_particle_num_list, bias_pot_params)
+            if energy < max_energy:
+                max_energy = energy
+                self.particle_num_list = tmp_particle_num_list
+        print("rand_search done")
+        print("max_energy: ", max_energy.item())
+        return
+    
+    
+    def microiteration(self, geom_num_list, bias_pot_params):
+        nparticle = self.config["spacer_model_potential_particle_number"]
+        if self.init:
+            self.rand_search(geom_num_list, bias_pot_params)
+            self.init = False
+        
+        prev_particle_grad = torch.zeros_like(self.particle_num_list)
+        Opt = FIRE()
+        Opt.display_flag = False
+        
+        for j in range(self.micro_iteration):
+
+            
+            particle_grad = torch.func.jacrev(self.calc_potential, argnums=1)(geom_num_list, self.particle_num_list, bias_pot_params)
+            if torch.linalg.norm(particle_grad) < self.threshold:
+                print("Converged!")
+                print("M. itr: ", j)
+                break
+            if j == self.micro_iteration - 1:
+                print("Not converged!")
+                break
+            
+            tmp_particle_list = copy.copy(self.particle_num_list.clone().detach().numpy()).reshape(3*nparticle, 1)
+            tmp_particle_grad = copy.copy(particle_grad.clone().detach().numpy()).reshape(3*nparticle, 1)
+            tmp_prev_particle_grad = copy.copy(prev_particle_grad.clone().detach().numpy()).reshape(3*nparticle, 1)
+
+            move_vector = Opt.run(tmp_particle_list, tmp_particle_grad, tmp_prev_particle_grad, pre_geom=[], B_e=0.0, pre_B_e=0.0, pre_move_vector=[], initial_geom_num_list=[], g=[], pre_g=[])
+            move_vector = torch.tensor(move_vector, dtype=torch.float64).reshape(nparticle, 3)
+            self.particle_num_list = self.particle_num_list - 0.5 * move_vector
+            # update rot_angle_list
+            if j % 100 == 0:
+                print("M. itr: ", j)
+                print("energy: ", self.calc_potential(geom_num_list, self.particle_num_list, bias_pot_params).item())
+                print("particle_grad: ", np.linalg.norm(particle_grad.detach().numpy()))
+            
+
+            prev_particle_grad = particle_grad
+        
+        
+        energy = self.calc_potential(geom_num_list, self.particle_num_list, bias_pot_params)
+        print("energy: ", self.calc_potential(geom_num_list, self.particle_num_list, bias_pot_params).item())
+        return energy
+    
+    
+    def calc_energy(self, geom_num_list, bias_pot_params=[]):
+        """
+        # required variables:self.config["spacer_model_potential_target"]
+                             self.config["spacer_model_potential_distance"]
+                             self.config["spacer_model_potential_well_depth"]
+                             self.config["spacer_model_potential_cavity_scaling"]
+                             self.config["spacer_model_potential_particle_number"]
+                             self.config["element_list"]
+                             self.config["directory"]
+                             
+        """
+        energy = self.microiteration(geom_num_list, bias_pot_params)
+        
+        return energy
+    
+    def calc_pot_for_eff_hess(self, coord_and_ell_angle, bias_pot_params):
+        geom_num_list = coord_and_ell_angle[:len(self.element_list)*3].reshape(-1, 3)
+        particle_num_list = coord_and_ell_angle[len(self.element_list)*3:].reshape(self.nparticle, 3)
+        energy = self.calc_potential(geom_num_list, particle_num_list, bias_pot_params)
+        return energy
+
+
+    def calc_eff_hessian(self, geom_num_list, bias_pot_params):
+        transformed_geom_num_list = geom_num_list.reshape(-1, 1)
+        transformed_particle_num_list = self.particle_num_list.reshape(-1, 1)
+        coord_and_particle = torch.cat((transformed_geom_num_list, transformed_particle_num_list), dim=0)
+        combined_hess = torch.func.hessian(self.calc_pot_for_eff_hess, argnums=0)(coord_and_particle, bias_pot_params).reshape(len(self.element_list)*3+self.nparticle*3, len(self.element_list)*3+self.nparticle*3)
+        coupling_hess_1 = combined_hess[:len(self.element_list)*3, len(self.element_list)*3:]
+        coupling_hess_2 = combined_hess[len(self.element_list)*3:, :len(self.element_list)*3]
+        angle_hess = combined_hess[len(self.element_list)*3:, len(self.element_list)*3:]
+        eff_hess = -1 * torch.matmul(torch.matmul(coupling_hess_1, torch.linalg.inv(angle_hess)), coupling_hess_2)
+        return eff_hess
+
+    
+#[[solvent particle well depth (kJ/mol)] [solvent particle e.q. distance (ang.)] [scaling of cavity (2.0)] [number of particles] [target atoms (2,3-5)] ...]

multioptpy/Potential/switching_potential.py

@@ -0,0 +1,258 @@
+
+from multioptpy.Parameters.parameter import UnitValueLib
+import torch
+
+class WellPotential:
+    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["well_pot_wall_energy"]
+                              self.config["well_pot_fragm_1"]
+                              self.config["well_pot_fragm_2"]
+                              self.config["well_pot_limit_dist"]
+                              
+                              
+        """
+        fragm_1_center = torch.tensor([0.0, 0.0, 0.0], dtype=torch.float32, requires_grad=True)
+        for i in self.config["well_pot_fragm_1"]:
+            fragm_1_center = fragm_1_center + geom_num_list[i-1]
+        
+        fragm_1_center = fragm_1_center / len(self.config["well_pot_fragm_1"])
+        
+        fragm_2_center = torch.tensor([0.0, 0.0, 0.0], dtype=torch.float32, requires_grad=True)
+        for i in self.config["well_pot_fragm_2"]:
+            fragm_2_center = fragm_2_center + geom_num_list[i-1]
+        
+        fragm_2_center = fragm_2_center / len(self.config["well_pot_fragm_2"])        
+        
+        vec_norm = torch.linalg.norm(fragm_1_center - fragm_2_center) 
+        a = float(self.config["well_pot_limit_dist"][0]) / self.bohr2angstroms
+        b = float(self.config["well_pot_limit_dist"][1]) / self.bohr2angstroms
+        c = float(self.config["well_pot_limit_dist"][2]) / self.bohr2angstroms
+        d = float(self.config["well_pot_limit_dist"][3]) / self.bohr2angstroms
+        short_dist_linear_func_slope = 0.5 / (b - a)
+        short_dist_linear_func_intercept = 1.0 - 0.5 * b / (b - a) 
+        long_dist_linear_func_slope = 0.5 / (c - d)
+        long_dist_linear_func_intercept = 1.0 - 0.5 * c / (c - d) 
+
+        x_short = short_dist_linear_func_slope * vec_norm + short_dist_linear_func_intercept
+        x_long = long_dist_linear_func_slope * vec_norm + long_dist_linear_func_intercept
+
+        if vec_norm <= a:
+            energy = (self.config["well_pot_wall_energy"] / self.hartree2kjmol) * (-3.75 * x_short + 2.875)
+            
+        elif a < vec_norm and vec_norm <= b:
+            energy = (self.config["well_pot_wall_energy"] / self.hartree2kjmol) * (2.0 - 20.0 * x_short ** 3 + 30.0 * x_short ** 4 - 12.0 * x_short ** 5)
+                
+        elif b < vec_norm and vec_norm < c:
+            energy = torch.tensor(0.0, requires_grad=True, dtype=torch.float32)
+            
+        elif c <= vec_norm and vec_norm < d:
+            energy = (self.config["well_pot_wall_energy"] / self.hartree2kjmol) * (2.0 - 20.0 * x_long ** 3 + 30.0 * x_long ** 4 - 12.0 * x_long ** 5)
+            
+        elif d <= vec_norm:
+            energy = (self.config["well_pot_wall_energy"] / self.hartree2kjmol) * (-3.75 * x_long + 2.875)
+            
+        else:
+            print("well pot error")
+            raise "well pot error"
+        #print(energy)
+        return energy
+
+
+class WellPotentialWall:
+    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["wall_well_pot_wall_energy"]
+                              self.config["wall_well_pot_direction"] 
+                              self.config["wall_well_pot_limit_dist"]
+                              self.config["wall_well_pot_target"]
+                              
+                              
+        """
+        
+        if self.config["wall_well_pot_direction"] == "x":
+            direction_num = 0
+        elif self.config["wall_well_pot_direction"] == "y":
+            direction_num = 1
+        elif self.config["wall_well_pot_direction"] == "z":
+            direction_num = 2
+                     
+        
+        
+        energy = 0.0
+        for i in self.config["wall_well_pot_target"]:
+
+            vec_norm = abs(torch.linalg.norm(geom_num_list[i-1][direction_num])) 
+                     
+            a = float(self.config["wall_well_pot_limit_dist"][0]) / self.bohr2angstroms
+            b = float(self.config["wall_well_pot_limit_dist"][1]) / self.bohr2angstroms
+            c = float(self.config["wall_well_pot_limit_dist"][2]) / self.bohr2angstroms
+            d = float(self.config["wall_well_pot_limit_dist"][3]) / self.bohr2angstroms
+            short_dist_linear_func_slope = 0.5 / (b - a)
+            short_dist_linear_func_intercept = 1.0 - 0.5 * b / (b - a) 
+            long_dist_linear_func_slope = 0.5 / (c - d)
+            long_dist_linear_func_intercept = 1.0 - 0.5 * c / (c - d) 
+
+            x_short = short_dist_linear_func_slope * vec_norm + short_dist_linear_func_intercept
+            x_long = long_dist_linear_func_slope * vec_norm + long_dist_linear_func_intercept
+
+            if vec_norm <= a:
+                energy += (self.config["wall_well_pot_wall_energy"] / self.hartree2kjmol) * (-3.75 * x_short + 2.875)
+                
+            elif a < vec_norm and vec_norm <= b:
+                energy += (self.config["wall_well_pot_wall_energy"] / self.hartree2kjmol) * (2.0 - 20.0 * x_short ** 3 + 30.0 * x_short ** 4 - 12.0 * x_short ** 5)
+                    
+            elif b < vec_norm and vec_norm < c:
+                energy += torch.tensor(0.0, requires_grad=True, dtype=torch.float32)
+                
+            elif c <= vec_norm and vec_norm < d:
+                energy += (self.config["wall_well_pot_wall_energy"] / self.hartree2kjmol) * (2.0 - 20.0 * x_long ** 3 + 30.0 * x_long ** 4 - 12.0 * x_long ** 5)
+                
+            elif d <= vec_norm:
+                energy += (self.config["wall_well_pot_wall_energy"] / self.hartree2kjmol) * (-3.75 * x_long + 2.875)
+                
+            else:
+                print("well pot error")
+                raise "well pot error"
+                
+ 
+        #print(energy)
+        return energy
+    
+class WellPotentialVP:
+    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["void_point_well_pot_wall_energy"]
+                              self.config["void_point_well_pot_coordinate"] 
+                              self.config["void_point_well_pot_limit_dist"]
+                              self.config["void_point_well_pot_target"]
+                              
+                              
+        """
+        self.config["void_point_well_pot_coordinate"]  = torch.tensor(self.config["void_point_well_pot_coordinate"], dtype=torch.float32)
+
+        
+        energy = 0.0
+        for i in self.config["void_point_well_pot_target"]:
+
+            vec_norm = torch.linalg.norm(geom_num_list[i-1] - self.config["void_point_well_pot_coordinate"]) 
+                     
+            a = float(self.config["void_point_well_pot_limit_dist"][0]) / self.bohr2angstroms
+            b = float(self.config["void_point_well_pot_limit_dist"][1]) / self.bohr2angstroms
+            c = float(self.config["void_point_well_pot_limit_dist"][2]) / self.bohr2angstroms
+            d = float(self.config["void_point_well_pot_limit_dist"][3]) / self.bohr2angstroms
+            short_dist_linear_func_slope = 0.5 / (b - a)
+            short_dist_linear_func_intercept = 1.0 - 0.5 * b / (b - a) 
+            long_dist_linear_func_slope = 0.5 / (c - d)
+            long_dist_linear_func_intercept = 1.0 - 0.5 * c / (c - d) 
+
+            x_short = short_dist_linear_func_slope * vec_norm + short_dist_linear_func_intercept
+            x_long = long_dist_linear_func_slope * vec_norm + long_dist_linear_func_intercept
+
+            if vec_norm <= a:
+                energy += (self.config["void_point_well_pot_wall_energy"] / self.hartree2kjmol) * (-3.75 * x_short + 2.875)
+                
+            elif a < vec_norm and vec_norm <= b:
+                energy += (self.config["void_point_well_pot_wall_energy"] / self.hartree2kjmol) * (2.0 - 20.0 * x_short ** 3 + 30.0 * x_short ** 4 - 12.0 * x_short ** 5)
+                    
+            elif b < vec_norm and vec_norm < c:
+                energy += torch.tensor(0.0, requires_grad=True, dtype=torch.float32)
+                
+            elif c <= vec_norm and vec_norm < d:
+                energy += (self.config["void_point_well_pot_wall_energy"] / self.hartree2kjmol) * (2.0 - 20.0 * x_long ** 3 + 30.0 * x_long ** 4 - 12.0 * x_long ** 5)
+                
+            elif d <= vec_norm:
+                energy += (self.config["void_point_well_pot_wall_energy"] / self.hartree2kjmol) * (-3.75 * x_long + 2.875)
+                
+            else:
+                print("well pot error")
+                raise "well pot error"
+                
+ 
+        #print(energy)
+        return energy
+    
+    
+class WellPotentialAround:
+    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["around_well_pot_wall_energy"]
+                              self.config["around_well_pot_center"] 
+                              self.config["around_well_pot_limit_dist"]
+                              self.config["around_well_pot_target"]
+                              
+                              
+        """
+        geom_center_coord = torch.tensor([0.0, 0.0, 0.0], dtype=torch.float32, requires_grad=True)
+        for i in self.config["around_well_pot_center"]:
+            geom_center_coord = geom_center_coord + geom_num_list[i-1]
+        geom_center_coord = geom_center_coord/len(self.config["around_well_pot_center"])
+        energy = 0.0
+        for i in self.config["around_well_pot_target"]:
+
+            vec_norm = torch.linalg.norm(geom_num_list[i-1] - geom_center_coord) 
+                     
+            a = float(self.config["around_well_pot_limit_dist"][0]) / self.bohr2angstroms
+            b = float(self.config["around_well_pot_limit_dist"][1]) / self.bohr2angstroms
+            c = float(self.config["around_well_pot_limit_dist"][2]) / self.bohr2angstroms
+            d = float(self.config["around_well_pot_limit_dist"][3]) / self.bohr2angstroms
+            short_dist_linear_func_slope = 0.5 / (b - a)
+            short_dist_linear_func_intercept = 1.0 - 0.5 * b / (b - a) 
+            long_dist_linear_func_slope = 0.5 / (c - d)
+            long_dist_linear_func_intercept = 1.0 - 0.5 * c / (c - d) 
+
+            x_short = short_dist_linear_func_slope * vec_norm + short_dist_linear_func_intercept
+            x_long = long_dist_linear_func_slope * vec_norm + long_dist_linear_func_intercept
+
+            if vec_norm <= a:
+                energy += (self.config["around_well_pot_wall_energy"] / self.hartree2kjmol) * (-3.75 * x_short + 2.875)
+                
+            elif a < vec_norm and vec_norm <= b:
+                energy += (self.config["around_well_pot_wall_energy"] / self.hartree2kjmol) * (2.0 - 20.0 * x_short ** 3 + 30.0 * x_short ** 4 - 12.0 * x_short ** 5)
+                    
+            elif b < vec_norm and vec_norm < c:
+                energy += torch.tensor(0.0, requires_grad=True, dtype=torch.float32)
+                
+            elif c <= vec_norm and vec_norm < d:
+                energy += (self.config["around_well_pot_wall_energy"] / self.hartree2kjmol) * (2.0 - 20.0 * x_long ** 3 + 30.0 * x_long ** 4 - 12.0 * x_long ** 5)
+                
+            elif d <= vec_norm:
+                energy += (self.config["around_well_pot_wall_energy"] / self.hartree2kjmol) * (-3.75 * x_long + 2.875)
+                
+            else:
+                print("well pot error")
+                raise "well pot error"
+                
+ 
+        #print(energy)
+        return energy

multioptpy/Potential/universal_potential.py

@@ -0,0 +1,34 @@
+
+from multioptpy.Parameters.parameter import UnitValueLib
+
+import numpy as np
+import torch
+import itertools
+  
+      
+class UniversalPotential:
+    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["universal_pot_const"], 
+                             self.config["universal_pot_target"], 
+        """
+        energy = 0.0
+        
+        point = geom_num_list[self.config["universal_pot_target"][0]-1]
+        for i in range(1, len(self.config["universal_pot_target"])):
+            point = point + geom_num_list[self.config["universal_pot_target"][i]-1]
+        
+        point = point / len(self.config["universal_pot_target"])
+        
+        for i in self.config["universal_pot_target"]:
+            energy = energy + self.config["universal_pot_const"] / self.hartree2kjmol / len(list(itertools.combinations(self.config["universal_pot_target"], 2))) * torch.linalg.norm(geom_num_list[i-1] - point)
+        
+        return energy

multioptpy/Potential/value_range_potential.py

@@ -0,0 +1,36 @@
+
+from multioptpy.Parameters.parameter import UnitValueLib
+from multioptpy.Utils.calc_tools import torch_calc_partial_center
+
+import torch
+
+class ValueRangePotential:
+    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=[]):
+        # ref.:https://doi.org/10.1063/5.0197592 (bond range potential)
+        """
+        # required variables: self.config["value_range_upper_const"]
+                              self.config["value_range_lower_const"]
+                              self.config["value_range_upper_distance"]
+                              self.config["value_range_lower_distance"]
+                              self.config["value_range_fragm_1"]
+                              self.config["value_range_fragm_2"]
+        """
+        fragm_1_center = torch_calc_partial_center(geom_num_list, self.config["value_range_fragm_1"])
+        fragm_2_center = torch_calc_partial_center(geom_num_list, self.config["value_range_fragm_2"])
+        
+        distance = torch.linalg.norm(fragm_1_center - fragm_2_center)
+        
+        upper_distance = self.config["value_range_upper_distance"] / self.bohr2angstroms
+        lower_distance = self.config["value_range_lower_distance"] / self.bohr2angstroms
+        upper_const = self.config["value_range_upper_const"]
+        lower_const = self.config["value_range_lower_const"]
+        energy = torch.log((1 + torch.exp(upper_const * (distance - upper_distance))) * (1 + torch.exp(lower_const * (lower_distance - distance))))
+        return energy

multioptpy/Potential/void_point_potential.py

@@ -0,0 +1,25 @@
+
+from multioptpy.Parameters.parameter import UnitValueLib
+import torch
+
+class VoidPointPotential:
+    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["void_point_pot_spring_const"],
+                              self.config["void_point_pot_atoms"]
+                              self.config["void_point_pot_coord"]  #need to convert tensor type 
+                              
+                              self.config["void_point_pot_distance"]
+                              self.config["void_point_pot_order"]
+                        
+        """
+        vector = torch.linalg.norm((geom_num_list[self.config["void_point_pot_atoms"]-1] - self.config["void_point_pot_coord"]), ord=2)
+        energy = (1 / self.config["void_point_pot_order"]) * self.config["void_point_pot_spring_const"] * (vector - self.config["void_point_pot_distance"]/self.bohr2angstroms) ** self.config["void_point_pot_order"]
+        return energy #hartree