mdkits 0.1.13__py3-none-any.whl → 1.2.3__py3-none-any.whl

mdkits/{cli → md_cli}/density.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 
 import numpy as np
-import click
+import click, math
 from MDAnalysis import Universe
 from MDAnalysis.analysis.base import AnalysisBase
 from mdkits.util import (
@@ -10,6 +10,7 @@ from mdkits.util import (
     encapsulated_mda,
     os_operation,
 )
+from .setting import common_setting
 import warnings, sys
 warnings.filterwarnings("ignore")
 
@@ -75,30 +76,33 @@ 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:
-            lower_z, upper_z = numpy_geo.find_surface(self.surface_group.positions[:, 2], layer_tolerance=1, surface_tolerance=5)
-            self.surface_pos[0] += lower_z
-            self.surface_pos[1] += upper_z
+            surface = numpy_geo.find_surface(self.surface_group.positions[:, 2])
+            self.surface_pos[0] += surface[0]
+            self.surface_pos[1] += surface[1]
 
         self.frame_count += 1
 
     def _conclude(self):
         if self.frame_count > 0:
-            V = self.u.dimensions[0] * self.u.dimensions[1] * self.bin_size
+            V = self.u.dimensions[0] * self.u.dimensions[1] * math.sin(math.radians(180 - self.u.dimensions[-1])) * self.bin_size
 
             if self.atomic_mass:
                 density_distribution = (self.density_distribution * self.atomic_mass * 1.660539 / V) / self.frame_count
             else:
                 density_distribution = (self.density_distribution * (10000/6.02) / V) / self.frame_count
 
-            bins_z = np.arange(len(self.density_distribution)) * self.bin_size
+            bins_z = np.arange(len(self.density_distribution)) * self.bin_size + self.bin_size / 2
 
             if self.surface:
                 lower_z = self.surface_pos[0] / self.frame_count
-                upper_z = self.surface_pos[1] / self.frame_count
+                if self.surface_pos[1] == 0:
+                    upper_z = np.inf
+                else:
+                    upper_z = self.surface_pos[1] / self.frame_count
 
                 mask = (bins_z >= lower_z) & (bins_z <= upper_z)
                 filtered_bins_z = bins_z[mask] - lower_z
@@ -110,24 +114,25 @@ class Density_distribution(AnalysisBase):
 
             np.savetxt(self.o, conbined_data, header="Z\tdensity", fmt='%.5f', delimiter='\t')
 
-@click.command(name='density')
-@click.argument('filename', type=click.Path(exists=True), default=os_operation.default_file_name('*-pos-1.xyz', last=True))
-@click.option('--cell', type=arg_type.Cell, help='set cell from cp2k input file or a list of lattice: --cell x,y,z or x,y,z,a,b,c', default='input.inp', show_default=True)
-@click.option('--element', type=str, help='element to analysis')
+@click.command(name='density', help="analysis density or concentration of element in a trajectory file")
+@common_setting
+@click.option('--group', type=str, help='group to analysis')
 @click.option('--atomic_mass', type=float, help='output density unit (g/cm3), should give atomic mass of element, else is concentration unit (mol/L)')
 @click.option('-o', type=str, help='output file name', default='density_{element}.dat', show_default=True)
-@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('--surface', type=str, help='surface element')
-def main(filename, cell, o, element, atomic_mass, update_water, distance, angle, surface):
+def main(filename, cell, o, group, atomic_mass, update_water, distance, angle, surface, r):
     """
     analysis density or concentration of element in a trajectory file
     """
 
-    density_dist = Density_distribution(filename, cell, o=o, distance_judg=distance, angle_judg=angle, element=element, atomic_mass=atomic_mass, update_water=update_water, surface=surface)
+    density_dist = Density_distribution(filename, cell, o=o, distance_judg=distance, angle_judg=angle, element=group, atomic_mass=atomic_mass, update_water=update_water, surface=surface)
 
-    density_dist.run()
+    if r is not None:
+        if len(r) == 2:
+            density_dist.run(start=r[0], stop=r[1])
+        elif len(r) == 3:
+            density_dist.run(start=r[0], stop=r[1], step=r[2])
+    else:
+        density_dist.run()
 
 
 if __name__ == '__main__':

mdkits/md_cli/dipole.py

@@ -0,0 +1,124 @@
+import numpy as np
+import click
+import MDAnalysis
+from MDAnalysis import Universe
+from MDAnalysis.analysis.base import AnalysisBase
+from mdkits.util import (
+    arg_type,
+    numpy_geo,
+    encapsulated_mda,
+    os_operation
+)
+from .setting import common_setting
+import sys
+
+
+class Dipole_distribution(AnalysisBase):
+    def __init__(self, filename, cell, update_water, distance_judg, angle_judg, surface, dt=0.001, bin_size=0.2):
+        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
+
+        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:
+            self.surface_group = False
+
+        super(Dipole_distribution, self).__init__(self.atomgroup.universe.trajectory, verbose=True)
+
+    def _prepare(self):
+        self.bin_num = int(self.u.dimensions[2] / self.bin_size) + 2
+        self.dipole_distribution = np.zeros(self.bin_num, dtype=np.float64)
+        self.o_count = np.zeros(self.bin_num, dtype=np.float64)
+
+        if self.surface_group:
+            self.surface_pos = np.zeros(2)
+
+    def _append(self, angle, z):
+        bins = np.floor(z / self.bin_size).astype(int) + 1
+        np.add.at(self.dipole_distribution, bins, angle)
+        np.add.at(self.o_count, bins , 1)
+
+    def _single_frame(self):
+        o_group = self.atomgroup.select_atoms("name O")
+
+        if self.update_water:
+            h_group = self.atomgroup.select_atoms("name H")
+            o, oh1, oh2 = encapsulated_mda.update_water(self, o_group, h_group, distance_judg=self.distance_judg, angle_judg=self.angle_judg, return_index=False)
+        else:
+            o = o_group
+            oh1 = self.atomgroup[o.indices + 1]
+            oh2 = self.atomgroup[o.indices + 2]
+
+        if self.surface_group:
+            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
+
+        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_bisector = np.hstack((bisector[o.positions[:, 2] < self.mid_z][:, 2] / np.linalg.norm(bisector[o.positions[:, 2] < self.mid_z], axis=1), -bisector[o.positions[:, 2] > self.mid_z][:, 2] / np.linalg.norm(bisector[o.positions[:, 2] > self.mid_z], axis=1)))
+
+        self._append(angle_bisector, np.hstack((o.positions[:, 2][o.positions[:, 2] < self.mid_z], o.positions[:, 2][o.positions[:, 2] > self.mid_z])))
+
+        self.frame_count += 1
+
+    def _conclude(self):
+        if self.frame_count > 0:
+            average_dipole = self.dipole_distribution / self.o_count
+            water_density = (self.o_count * (15.999+1.0008*2) * 1.660539 / (self.u.dimensions[0] * self.u.dimensions[1] * self.bin_size)) / self.frame_count
+            average_dipole = average_dipole * water_density
+            bins_z = np.arange(len(average_dipole)) * self.bin_size + self.bin_size / 2
+
+            if self.surface:
+                lower_z = self.surface_pos[0] / self.frame_count
+                if self.surface_pos[1] == 0:
+                    upper_z = np.inf
+                else:
+                    upper_z = self.surface_pos[1] / self.frame_count
+
+                mask = (bins_z >= lower_z) & (bins_z <= upper_z)
+                filtered_bins_z = bins_z[mask] - lower_z
+                filtered_dipole_distribution = average_dipole[mask]
+
+                conbined_data = np.column_stack((filtered_bins_z, filtered_dipole_distribution))
+            else:
+                conbined_data = np.column_stack((bins_z, average_dipole))
+
+            np.savetxt("dipole_distribution.dat", conbined_data, header="z\tDipole Z Positions\tWater Density", fmt='%.5f', delimiter='\t')
+
+
+@click.command(name="dipole")
+@common_setting
+def main(filename, cell, update_water, distance, angle, surface, r):
+    """analysis dipole along z-axis"""
+    a = Dipole_distribution(filename, cell, 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/md_cli/hb_distribution.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+
+import numpy as np
+import click
+import MDAnalysis
+from MDAnalysis import Universe
+from MDAnalysis.analysis.base import AnalysisBase
+from mdkits.util import numpy_geo, encapsulated_mda
+import warnings, sys
+from .setting import common_setting
+warnings.filterwarnings("ignore")
+
+
+class Hb_distribution(AnalysisBase):
+    def __init__(self, filename, cell, surface, update_water, distance_judg, angle_judg, hb_distance, hb_angle, bin_size=0.2, dt=0.001, index=None):
+        u = Universe(filename)
+        u.trajectory.ts.dt = dt
+        u.dimensions = cell
+        self.u = u
+        self.atomgroup = u.select_atoms("all")
+        self.hb_distance = hb_distance
+        self.hb_angle = hb_angle
+        self.bin_size = bin_size
+        self.surface = surface
+        self.update_water = update_water
+        self.frame_count = 0
+        np.set_printoptions(threshold=np.inf)
+
+        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:
+            self.surface_group = False
+
+        if self.update_water:
+            self.distance_judg = distance_judg
+            self.angle_judg = angle_judg
+        
+        if index is not None:
+            self.index = index
+            self.hb_d_index = 0
+            self.hb_a_index = 0
+        else:
+            self.index = None
+
+        super(Hb_distribution, self).__init__(self.atomgroup.universe.trajectory, verbose=True)
+
+    def _prepare(self):
+        bin_num = int(self.u.dimensions[2] / self.bin_size) + 2
+        self.accepter = np.zeros(bin_num, dtype=np.float64)
+        self.donor = np.zeros(bin_num, dtype=np.float64)
+        self.od = np.zeros(bin_num, dtype=np.float64)
+        if self.surface_group:
+            self.surface_pos = np.zeros(2)
+
+    def _append(self, hb_d, hb_a, o):
+        bins_d = np.floor(hb_d / self.bin_size).astype(int) + 1
+        bins_a = np.floor(hb_a / self.bin_size).astype(int) + 1
+        bins_o = np.floor(o / self.bin_size).astype(int) + 1
+
+        bins_d = bins_d[bins_d < len(self.donor)]
+        bins_a = bins_a[bins_a < len(self.accepter)]
+        bins_o = bins_o[bins_o < len(self.od)]
+
+        np.add.at(self.donor, bins_d, 1)
+        np.add.at(self.accepter, bins_a, 1)
+        np.add.at(self.od, bins_o, 1)
+
+    def _single_frame(self):
+        if self.update_water:
+            o = self.atomgroup.select_atoms("name O")
+            h = self.atomgroup.select_atoms("name H")
+
+            o_group, oh1, oh2 = encapsulated_mda.update_water(self, o, h, distance_judg=self.distance_judg, angle_judg=self.angle_judg, return_index=False)
+
+            o_pair = MDAnalysis.lib.distances.capped_distance(o_group.positions, o_group.positions, min_cutoff=0, max_cutoff=self.hb_distance, box=self.u.dimensions, return_distances=False)
+
+            o0 = o_group[o_pair[:, 0]]
+            o1 = o_group[o_pair[:, 1]]
+
+            o0h1 = oh1[o_pair[:, 0]]
+            o0h2 = oh2[o_pair[:, 0]]
+            o1h1 = oh1[o_pair[:, 1]]
+            o1h2 = oh2[o_pair[:, 1]]
+        else:
+            o_group = self.atomgroup.select_atoms("name O")
+            o_pair = MDAnalysis.lib.distances.capped_distance(o_group.positions, o_group.positions, min_cutoff=0, max_cutoff=self.hb_distance, box=self.u.dimensions, return_distances=False)
+
+            o0 = o_group[o_pair[:, 0]]
+            o1 = o_group[o_pair[:, 1]]
+
+            o0h1 = self.atomgroup[o0.indices + 1]
+            o0h2 = self.atomgroup[o0.indices + 2]
+            o1h1 = self.atomgroup[o1.indices + 1]
+            o1h2 = self.atomgroup[o1.indices + 2]
+
+        angle_o0h1_o0_o1 = np.degrees(
+            MDAnalysis.lib.distances.calc_angles(o0h1.positions, o0.positions, o1.positions, box=self.u.dimensions)
+        )
+        angle_o0h2_o0_o1 = np.degrees(
+            MDAnalysis.lib.distances.calc_angles(o0h2.positions, o0.positions, o1.positions, box=self.u.dimensions)
+        )
+        angle_o1h1_o1_o0 = np.degrees(
+            MDAnalysis.lib.distances.calc_angles(o1h1.positions, o1.positions, o0.positions, box=self.u.dimensions)
+        )
+        angle_o1h2_o1_o0 = np.degrees(
+            MDAnalysis.lib.distances.calc_angles(o1h2.positions, o1.positions, o0.positions, box=self.u.dimensions)
+        )
+
+        condition_d = (angle_o0h1_o0_o1 < self.hb_angle) | (angle_o0h2_o0_o1 < self.hb_angle)
+        condition_a = (angle_o1h1_o1_o0 < self.hb_angle) | (angle_o1h2_o1_o0 < self.hb_angle)
+
+        if self.index is not None:
+            self.hb_d_index += o0.positions[:, 2][condition_d & (o0.indices == self.index)].shape[0]
+            self.hb_a_index += o0.positions[:, 2][condition_a & (o0.indices == self.index)].shape[0]
+        else:
+            hb_d = o0.positions[:, 2][condition_d]
+            hb_a = o0.positions[:, 2][condition_a]
+
+            self._append(hb_d, hb_a, o_group.positions[:, 2])
+
+        if self.surface_group:
+            surface = numpy_geo.find_surface(self.surface_group.positions[:, 2])
+            self.surface_pos[0] += surface[0]
+            self.surface_pos[1] += surface[1]
+
+        self.frame_count += 1
+
+    def _conclude(self):
+        if self.frame_count > 0 and self.index is None:
+            average_od = self.od / self.frame_count
+            average_donor = np.nan_to_num((self.donor / self.frame_count) / average_od, nan=0)
+            average_accepter = np.nan_to_num((self.accepter / self.frame_count) / average_od, nan=0)
+            average_sum = average_donor + average_accepter
+
+            bins_z = np.arange(len(self.donor)) * self.bin_size + self.bin_size / 2
+
+            if self.surface:
+                lower_z = self.surface_pos[0] / self.frame_count
+                if self.surface_pos[1] == 0:
+                    upper_z = np.inf
+                else:
+                    upper_z = self.surface_pos[1] / self.frame_count
+
+                mask = (bins_z >= lower_z) & (bins_z <= upper_z)
+                filtered_bins_z = bins_z[mask] - lower_z
+                filtered_average_accepter = average_accepter[mask]
+                filtered_average_donor = average_donor[mask]
+                filtered_average_sum = average_sum[mask]
+
+                combined_data = np.column_stack((filtered_bins_z, filtered_average_accepter, filtered_average_donor, filtered_average_sum))
+            else:
+                combined_data = np.column_stack((bins_z, average_accepter, average_donor, average_sum))
+
+            np.savetxt("hb_distribution.dat", combined_data, header="Z\tAccepter\tDonor\tAccepter+Donor", fmt='%.5f', delimiter='\t')
+
+        if self.index is not None and self.frame_count > 0:
+            self.hb_d_index /= self.frame_count
+            self.hb_a_index /= self.frame_count
+            output = f"# {self.index}\naccepter     : {self.hb_a_index}\ndonor        : {self.hb_d_index}\ntotal        : {self.hb_a_index + self.hb_d_index}"
+            with open(f"hb_{self.index}.dat", "a") as f:
+                f.write(output)
+            print(output)
+
+
+@click.command(name="hb", help="analysis hydrogen bond distribution along z-axis")
+@common_setting
+@click.option('--hb_param', type=click.Tuple([float, float]), help='parameter for hydrogen bond', default=(3.5, 35), show_default=True)
+@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:
+        if len(r) == 2:
+            hb_dist.run(start=r[0], stop=r[1])
+        elif len(r) == 3:
+            hb_dist.run(start=r[0], stop=r[1], step=r[2])
+    else:
+        hb_dist.run()
+
+
+if __name__ == '__main__':
+    main()

mdkits/md_cli/md_cli.py

@@ -0,0 +1,32 @@
+import click
+from mdkits.md_cli import (
+    wrap,
+    dipole,
+    angle,
+    density,
+    hb_distribution,
+    vac,
+    rdf,
+    msd,
+    monitor,
+)
+
+
+@click.group(name='md')
+@click.pass_context
+def cli(ctx):
+    """kits for MD analysis"""
+
+cli.add_command(wrap.main)
+cli.add_command(density.main)
+cli.add_command(dipole.main)
+cli.add_command(angle.main)
+cli.add_command(hb_distribution.main)
+cli.add_command(vac.main)
+cli.add_command(rdf.main)
+cli.add_command(msd.main)
+cli.add_command(monitor.main)
+
+
+if __name__ == '__main__':
+    cli()

mdkits/md_cli/monitor.py

@@ -0,0 +1,104 @@
+import click
+from .setting import common_setting
+import MDAnalysis
+from MDAnalysis import Universe
+from MDAnalysis.analysis.base import AnalysisBase
+from mdkits.util import arg_type, numpy_geo
+import numpy as np
+import sys
+
+
+class Monitor(AnalysisBase):
+    def __init__(self, filename, cell, index, surface, dt=0.001):
+        u = Universe(filename)
+        u.trajectory.ts.dt = dt
+        u.dimensions = cell
+
+        self.u = u
+        self.atomgroup = self.u.select_atoms("all")
+        self.surface = surface
+
+        if index is None:
+            sys.exit("Please specify at least one atom to monitor")
+        else:
+            self.index = index
+            self.group = " or ".join([ f"index {i}" for i in self.index ])
+
+        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:
+            self.surface_group = False
+
+        super(Monitor, self).__init__(self.atomgroup.universe.trajectory, verbose=True)
+
+    def _prepare(self):
+        self.height = []
+        if len(self.index) == 2:
+            self.distance = []
+        elif len(self.index) == 3:
+            self.distance = []
+            self.angle = []
+    
+    def _single_frame(self):
+        if self.surface_group:
+            surface = numpy_geo.find_surface(self.surface_group.positions[:, 2])
+        else:
+            surface = [0]
+
+        self.height.append(self.atomgroup.select_atoms(self.group).positions[:, 2] - surface[0])
+
+        if len(self.index) == 2:
+            vec = MDAnalysis.lib.distances.minimize_vectors(self.atomgroup[self.index[0]].position - self.atomgroup[self.index[1]].position, self.u.dimensions)
+
+            self.distance.append(np.linalg.norm(vec))
+
+        if len(self.index) == 3:
+            vec1 = MDAnalysis.lib.distances.minimize_vectors(self.atomgroup[self.index[0]].position - self.atomgroup[self.index[1]].position, self.u.dimensions)
+            vec2 = MDAnalysis.lib.distances.minimize_vectors(self.atomgroup[self.index[2]].position - self.atomgroup[self.index[1]].position, self.u.dimensions)
+
+            self.distance.append(np.array([np.linalg.norm(vec1), np.linalg.norm(vec2)]))
+            self.angle.append(numpy_geo.vector_vector_angle(vec1, vec2))
+
+    def _conclude(self):
+        frame_count = np.arange(self.u.trajectory.n_frames).reshape(-1, 1)
+
+        self.height = np.vstack(self.height)
+
+        np.savetxt("monitor.dat", np.hstack((frame_count, self.height)), fmt="%.5f", header=f"frame\t{'  '.join(self.atomgroup.select_atoms(self.group).names)}")
+
+        if len(self.index) == 2:
+            self.distance = np.vstack(self.distance)
+
+            np.savetxt("monitor.dat", np.hstack((frame_count, self.height, self.distance)), fmt="%.5f", header=f"frame\t\t{'  '.join(self.atomgroup.select_atoms(self.group).names)}\t{self.atomgroup.names[self.index[0]]}-{self.atomgroup.names[self.index[1]]}")
+        elif len(self.index) == 3:
+            self.distance = np.vstack(self.distance)
+            self.angle = np.vstack(self.angle)
+
+            np.savetxt("monitor.dat", np.hstack((frame_count, self.height, self.distance, self.angle)), fmt="%.5f", header=f"frame\t\t{'  '.join(self.atomgroup.select_atoms(self.group).names)}\t{self.atomgroup.names[self.index[0]]}-{self.atomgroup.names[self.index[1]]}\t{self.atomgroup.names[self.index[2]]}-{self.atomgroup.names[self.index[1]]}\t{self.atomgroup.names[self.index[0]]}-{self.atomgroup.names[self.index[1]]}-{self.atomgroup.names[self.index[2]]}")
+
+
+@click.command(name="monitor")
+@click.argument("filename", type=click.Path(exists=True))
+@click.option("--index", "-i", type=int, help="index of atom to monitor", multiple=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("--surface", type=str, help="surface group")
+@click.option('-r', type=arg_type.FrameRange, help='range of frame to analysis')
+def main(filename, cell, index, surface, r):
+    """
+    monitor the property of between atoms
+    """
+    a = Monitor(filename, cell, index, 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/md_cli/msd.py

@@ -0,0 +1,44 @@
+import click
+import MDAnalysis as mda
+import MDAnalysis.analysis.msd as msd
+import numpy as np
+from mdkits.util import arg_type
+
+
+@click.command(name="msd")
+@click.argument("filename", type=click.Path(exists=True))
+@click.argument('type', type=click.Choice(['xyz', 'xy', 'yz', 'xz', 'x', 'y', 'z']))
+@click.argument("group", type=str)
+@click.option('-r', type=arg_type.FrameRange, help='range of frame to analysis')
+def main(filename, type, group, r):
+    """analysis msd along the given axis"""
+    u = mda.Universe(filename)
+    MSD = msd.EinsteinMSD(u, select=group, msd_type=type, fft=True)
+    if r is not None:
+        if len(r) == 2:
+            MSD.run(start=r[0], stop=r[1], verbose=True)
+        elif len(r) == 3:
+            MSD.run(start=r[0], stop=r[1], step=r[2], verbose=True)
+    else:
+        MSD.run(verbose=True)
+
+    data = np.arange(1, MSD.n_frames + 1).reshape(-1, 1)
+    s = "_"
+    name = f"{s.join(group.split(' '))}"
+    o = f"msd_{type}_{name}.dat"
+    header = ''
+    msd_cols = []
+    for i in range(MSD.n_particles):
+        msd_cols.append(MSD.results.msds_by_particle[:, i].reshape(-1, 1))
+        header += name + f"_{i}\t"
+    msd_array = np.concatenate(msd_cols, axis=1)
+    mean_col = np.mean(msd_array, axis=1, keepdims=True)
+    data = np.concatenate((data, mean_col, msd_array), axis=1)
+    header = "frame\tmean\t" + header
+
+    np.savetxt(o, data, fmt="%.5f", delimiter="\t", header=header)
+
+
+
+if __name__ == '__main__':
+    main()

mdkits/md_cli/rdf.py

@@ -0,0 +1,53 @@
+import MDAnalysis as mda
+from MDAnalysis.analysis import rdf
+import numpy as np
+import click
+from scipy import integrate
+from mdkits.util import arg_type
+
+
+def calculate_Gab(r_values, gab_values):
+    dr = r_values[1] - r_values[0]
+
+    integrand = 4 * np.pi * r_values**2 * gab_values
+
+    G_ab = np.cumsum(integrand) * dr
+
+    return G_ab
+
+
+@click.command(name="rdf")
+@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("--group", type=click.Tuple([str, str]), help="two group to analysis")
+@click.option('--range', type=click.Tuple([float, float]), help="the range of rdf")
+@click.option('-r', type=arg_type.FrameRange, help='range of frame to analysis')
+def main(filename, cell, group, range, r):
+    """analysis the radial distribution function"""
+    u = mda.Universe(filename)
+    u.trajectory.ts.dt = 0.0001
+    u.dimensions = cell
+    o = f"rdf_{'_'.join(group).replace(' ', '_')}.dat"
+
+    rho = 32/(9.86**3)
+
+    group1 = u.select_atoms(group[0])
+    group2 = u.select_atoms(group[1])
+
+    crdf = rdf.InterRDF(group1, group2, verbose=True, range=(range[0], range[1]), norm='rdf')
+
+
+    if r is not None:
+        if len(r) == 2:
+            crdf.run(start=r[0], stop=r[1])
+        elif len(r) == 3:
+            crdf.run(start=r[0], stop=r[1], step=r[2])
+    else:
+        crdf.run()
+
+    combin = np.column_stack((crdf.results.bins, crdf.results.rdf, calculate_Gab(crdf.results.bins, crdf.results.rdf)*rho))
+    np.savetxt(o, combin, header="A\tgr\tNr", fmt="%.5f", delimiter='\t')
+
+
+if __name__ == "__main__":
+    main()

mdkits/md_cli/setting.py

@@ -0,0 +1,14 @@
+import click
+from mdkits.util import arg_type, os_operation
+
+
+def common_setting(f):
+    f = click.argument('filename', type=click.Path(exists=True), default=os_operation.default_file_name('*-pos-1.xyz', last=True))(f)
+    f = click.option('-r', type=arg_type.FrameRange, help='range of frame to analysis')(f)
+    f = click.option('--angle', type=(float, float), help='update water angle judgment')(f)
+    f = click.option('--distance', type=float, help='update water distance judgment', default=1.2, show_default=True)(f)
+    f = click.option('--update_water', is_flag=True, help='update water with distance or angle judgment')(f)
+    f = click.option("--surface", type=str, help="surface group")(f)
+    f = 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")(f)
+
+    return f