mdkits 0.1.28__tar.gz → 0.1.29__tar.gz

{mdkits-0.1.28 → mdkits-0.1.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mdkits
-Version: 0.1.28
+Version: 0.1.29
 Summary: kits for md or dft
 License: MIT
 Keywords: molecular dynamics,density functional theory

{mdkits-0.1.28 → mdkits-0.1.29}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "mdkits"
-version = "0.1.28"
+version = "0.1.29"
 description = "kits for md or dft"
 readme = "README.md"
 authors = ["jxxcr <jixxcr@qq.com>"]

mdkits-0.1.29/src/mdkits/md_cli/angle.py

@@ -0,0 +1,127 @@
+import click
+from MDAnalysis import Universe
+from MDAnalysis.analysis.base import AnalysisBase
+import MDAnalysis
+import sys
+from mdkits.util import numpy_geo, encapsulated_mda, arg_type
+import numpy as np
+
+
+class Angle_distribution(AnalysisBase):
+    def __init__(self, filename, cell, water_height, update_water, surface, distance_judg=None, angle_judg=(None, None), dt=0.001, bin_size=5):
+        u = Universe(filename)
+        u.trajectory.ts.dt = dt
+        u.dimensions = cell
+
+        self.u = u
+        self.atomgroup = u.select_atoms("all")
+        self.bin_size = bin_size
+        self.frame_count = 0
+        self.surface = surface
+        self.update_water = update_water
+        self.mid_z = u.dimensions[2]/2
+
+        self.normal_up = np.array([0, 0, 1])
+        self.normal_down = np.array([0, 0, -1])
+        self.total_angle = 180
+
+        if water_height is None:
+            sys.exit("Please specify the water height")
+        else:
+            self.water_height = water_height
+
+        if self.update_water:
+            self.distance_judg = distance_judg
+            self.angle_judg = angle_judg
+
+        if surface is not None:
+            self.surface_group = self.atomgroup.select_atoms(f"{surface}")
+            if self.surface_group.n_atoms == 0:
+                sys.exit("Please specify the correct surface group")
+        else:
+            sys.exit("Please specify a surface group")
+
+        super(Angle_distribution, self).__init__(self.atomgroup.universe.trajectory, verbose=True)
+    
+    def _prepare(self):
+        self.bin_num = int(self.total_angle / self.bin_size) + 2
+        self.angle_w_distribution = np.zeros(self.bin_num, dtype=np.float64)
+        self.angle_oh_distribution = np.zeros(self.bin_num, dtype=np.float64)
+
+    def _append(self, angle, anglew=True):
+        bins = np.floor(angle / self.bin_size).astype(int) + 1
+
+        if anglew:
+            bins = bins[bins < len(self.angle_w_distribution)]
+            np.add.at(self.angle_w_distribution, bins, 1)
+        else:
+            bins = bins[bins < len(self.angle_oh_distribution)]
+            np.add.at(self.angle_oh_distribution, bins, 1)
+
+
+    def _single_frame(self):
+        surface = numpy_geo.find_surface(self.surface_group.positions[:, 2])
+
+        if len(surface) == 1:
+            o_group = self.atomgroup.select_atoms(f"name O and prop z < {surface[0]+self.water_height}", updating=True)
+        else:
+            o_group = self.atomgroup.select_atoms(f"name O and (prop z < {surface[0]+self.water_height} or prop z > {surface[1]-self.water_height})", updating=True)
+        
+        h_group = self.atomgroup.select_atoms("name H")
+
+        if self.update_water:
+            o, oh1, oh2 = encapsulated_mda.update_water(self, o_group=o_group, h_group=h_group, distance_judg=self.distance_judg, angle_judg=self.angle_judg, return_index=False)
+        else:
+            o = o_group
+            oh1 = self.atomgroup[o_group.indices + 1]
+            oh2 = self.atomgroup[o_group.indices + 2]
+
+        vec1 = MDAnalysis.lib.distances.minimize_vectors(oh1.positions - o.positions, self.u.dimensions)
+        vec2 = MDAnalysis.lib.distances.minimize_vectors(oh2.positions - o.positions, self.u.dimensions)
+
+        bisector = numpy_geo.vector_between_two_vector(vec1, vec2)
+
+        angle_vec1 = np.hstack((numpy_geo.vector_vector_angle(vec1[o.positions[:, 2] < self.mid_z], self.normal_up), numpy_geo.vector_vector_angle(vec1[o.positions[:, 2] > self.mid_z], self.normal_down)))
+
+        angle_vec2 = np.hstack((numpy_geo.vector_vector_angle(vec2[o.positions[:, 2] < self.mid_z], self.normal_up), numpy_geo.vector_vector_angle(vec2[o.positions[:, 2] > self.mid_z], self.normal_down)))
+
+        angle_bisector = np.hstack((numpy_geo.vector_vector_angle(bisector[o.positions[:, 2] < self.mid_z], self.normal_up), numpy_geo.vector_vector_angle(bisector[o.positions[:, 2] > self.mid_z], self.normal_down)))
+
+        self._append(angle_vec1, anglew=False)
+        self._append(angle_vec2, anglew=False)
+        self._append(angle_bisector)
+
+        self.frame_count += 1
+
+    def _conclude(self):
+        if self.frame_count > 0:
+            average_angle_w = self.angle_w_distribution / self.frame_count
+            average_angle_oh = self.angle_oh_distribution / (self.frame_count*2)
+            bins_z = np.arange(len(average_angle_w)) * self.bin_size
+            conbined_data = np.column_stack((bins_z, average_angle_w, average_angle_oh))
+            np.savetxt("angle_distribution.dat", conbined_data, header="angle\tw_suf_dist\toh_suf_dist", fmt='%.5f', delimiter='\t')
+
+
+@click.command(name="angle")
+@click.argument("filename", type=click.Path(exists=True))
+@click.option('--cell', type=arg_type.Cell, help="set cell, a list of lattice, --cell x,y,z or x,y,z,a,b,c")
+@click.option("--water_height", type=float, help="water height from surface")
+@click.option("--surface", type=str, help="surface group")
+@click.option('--update_water', is_flag=True, help='update water with distance or angle judgment')
+@click.option('--distance', type=float, help='update water distance judgment', default=1.2, show_default=True)
+@click.option('--angle', type=(float, float), help='update water angle judgment')
+@click.option('-r', type=arg_type.FrameRange, help='range of frame to analysis')
+def main(filename, cell, water_height, update_water, distance, angle, surface, r):
+    """analysis angle between normal vectors and OH vector or bisector"""
+    a = Angle_distribution(filename, cell, water_height, update_water, distance_judg=distance, angle_judg=angle, surface=surface)
+    if r is not None:
+        if len(r) == 2:
+            a.run(start=r[0], stop=r[1])
+        elif len(r) == 3:
+            a.run(start=r[0], stop=r[1], step=r[2])
+    else:
+        a.run()
+
+
+if __name__ == "__main__":
+    main()

{mdkits-0.1.28 → mdkits-0.1.29}/src/mdkits/md_cli/density.py

@@ -75,7 +75,7 @@ class Density_distribution(AnalysisBase):
             self._append(o.positions[:, 2])
 
         else:
-            group = self.atomgroup.select_atoms(f"{self.element}")
+            group = self.atomgroup.select_atoms(f"{self.element}", updating=True)
             self._append(group.positions[:, 2])
 
         if self.surface_group:

{mdkits-0.1.28 → mdkits-0.1.29}/src/mdkits/md_cli/hb_distribution.py

@@ -120,7 +120,7 @@ class Hb_distribution(AnalysisBase):
             self._append(hb_d, hb_a, o_group.positions[:, 2])
 
         if self.surface_group:
-            lower_z, upper_z = numpy_geo.find_surface(self.surface_group.positions[:, 2], layer_tolerance=1, surface_tolerance=5)
+            lower_z, upper_z = numpy_geo.find_surface(self.surface_group.positions[:, 2])
             self.surface_pos[0] += lower_z
             self.surface_pos[1] += upper_z
 
@@ -169,7 +169,7 @@ class Hb_distribution(AnalysisBase):
 @click.option('--angle', type=(float, float), help='update water angle judgment')
 @click.option('--index', type=int, help='index of an atom')
 def main(filename, hb_param, cell, surface, r, update_water, distance, angle, index):
-
+    """analysis hydrogen bond distribution along z-axis"""
     hb_dist = Hb_distribution(filename, cell, surface, update_water=update_water, distance_judg=distance, angle_judg=angle, hb_distance=hb_param[0], hb_angle=hb_param[1], index=index)
 
     if r is not None:

{mdkits-0.1.28 → mdkits-0.1.29}/src/mdkits/md_cli/md_cli.py

@@ -2,6 +2,7 @@ import click
 from mdkits.md_cli import (
     density,
     hb_distribution,
+    angle,
 )
 
 
@@ -13,6 +14,7 @@ def main(ctx):
 
 main.add_command(density.main)
 main.add_command(hb_distribution.main)
+main.add_command(angle.main)
 
 
 if __name__ == '__main__':

{mdkits-0.1.28 → mdkits-0.1.29}/src/mdkits/util/encapsulated_mda.py

@@ -3,7 +3,7 @@ import numpy as np
 from . import numpy_geo
 
 
-def update_water(self, o_group, h_group, distance_judg=1.2, angle_judg:tuple[float, float]=None, return_index=False):
+def update_water(self, o_group, h_group, distance_judg=1.2, angle_judg:tuple[float, float]=(None, None), return_index=False):
     """
     input: o and h atom
     output: o and two h in this frame
@@ -53,6 +53,9 @@ def update_water(self, o_group, h_group, distance_judg=1.2, angle_judg:tuple[flo
     if return_index:
         return o_index, oh1_index, oh2_index
     else:
+        if len(o_index) == 0:
+            raise ValueError("No water found in this atom group")
+
         o = o_group[o_index]
         oh1 = h_group[oh1_index]
         oh2 = h_group[oh2_index]

{mdkits-0.1.28 → mdkits-0.1.29}/src/mdkits/util/numpy_geo.py

@@ -45,7 +45,7 @@ def vector_between_two_vector(vector1, vector2):
 
 
 def vector_vector_angle(vector, surface_vector):
-    cos = np.dot(vector, surface_vector) / (np.linalg.norm(vector) * np.linalg.norm(surface_vector))
+    cos = np.dot(vector, surface_vector) / (np.linalg.norm(vector, axis=1) * np.linalg.norm(surface_vector))
     vector_vector_angle = np.arccos(np.clip(cos, -1.0, 1.0))
     vector_vector_angle = np.degrees(vector_vector_angle)
     return vector_vector_angle
@@ -96,7 +96,7 @@ def unwrap(atom1, atom2, coefficients, max=0, total=False):
         return min_dist, closest_point
 
 
-def find_surface(surface_group:np.ndarray, layer_tolerance=1, surface_tolerance=5):
+def find_surface(surface_group:np.ndarray, layer_tolerance=0.05, surface_tolerance=5):
     sort_group = np.sort(surface_group)
     layer_mean = []
     current_layer = [sort_group[0]]
@@ -108,12 +108,14 @@ def find_surface(surface_group:np.ndarray, layer_tolerance=1, surface_tolerance=
             current_layer = [sort_group[i]]
         layer_mean.append(np.mean(current_layer))
     
-    if len(current_layer) == 1:
-        return layer_mean[0]
+    if len(layer_mean) == 1:
+        return [layer_mean[0]]
 
     diff = np.diff(layer_mean)
     if np.any(diff > surface_tolerance):
-        index = np.argmax(diff > 5)
+        index = np.argmax(diff > surface_tolerance)
         return (layer_mean[index], layer_mean[index + 1])
     else:
+        if layer_mean[-1] > layer_mean[0]:
+            return [layer_mean[-1]]
         return (layer_mean[-1], layer_mean[0])

{mdkits-0.1.28 → mdkits-0.1.29}/src/mdkits/util/out_err.py

@@ -9,7 +9,7 @@ import sys, os
 def cell_output(atoms):
     cell = atoms.cell.cellpar()
     if not hasattr(atoms, "name"):
-        atoms.name = ""
+        atoms.name = "present"
     print(f"{atoms.name} cell: x = {cell[0]}, y = {cell[1]}, z = {cell[2]}, a = {cell[3]}\u00B0, b = {cell[4]}\u00B0, c = {cell[5]}\u00B0")