mdkits 0.1.29__py3-none-any.whl → 0.2.0__py3-none-any.whl

mdkits/build_cli/adsorbate.py

@@ -18,6 +18,7 @@ from mdkits.util import arg_type, encapsulated_ase, out_err
 @click.option('--offset', type=click.Tuple([float, float]), help='adjust site', default=(0, 0), show_default=True)
 @click.option("--cover", type=int, help='cover the surface with adsorbate randomly')
 def main(atoms, adsorbate, cell, select, height, rotate, offset, cover):
+    """add adsorbate molcule to the surface"""
     if height is None:
         raise ValueError("height is required")
 

mdkits/build_cli/build_surface.py

@@ -22,10 +22,7 @@ def surface_check(obj, surface_type):
 @click.option('--orth', is_flag=True, help='if specified and true, forces the creation of a unit cell with orthogonal basis vectors. if the default is such a unit cell, this argument is not supported')
 @click.option('--vacuum', type=float, help='designate vacuum of surface, default is None', default=0.1, show_default=True)
 def main(symbol, surface, size, kind, a, c, thickness, orth, vacuum):
-    #if args.primitive:
-    #    a = args.a * 0.7071 * 2
-    #else:
-    #    a = args.a
+    """build a common surface"""
 
     vacuum = vacuum / 2
     build_surface = surface_check(build, surface)

mdkits/cli/extract.py

@@ -9,11 +9,12 @@ import MDAnalysis
 from MDAnalysis import Universe
 
 
-def write_to_xyz(u, frames, o, cut=None):
-    with MDAnalysis.Writer(o, u.atoms.n_atoms, format='XYZ') as w:
+def write_to_xyz(u, frames, o, select, cut=None):
+    ag = u.select_atoms(select)
+    with MDAnalysis.Writer(o, ag.atoms.n_atoms, format='XYZ') as w:
         for ts in u.trajectory:
             if ts.frame in frames:
-                w.write(u)
+                w.write(ag)
     if cut:
         with open(o, 'r') as fi, open(o+'t', 'w') as fo:
             for i, line in enumerate(fi):
@@ -22,13 +23,18 @@ def write_to_xyz(u, frames, o, cut=None):
         os.replace(o+'t', o)
 
 
-def write_to_xyz_s(u, frames, cut=None):
+def write_to_xyz_s(u, frames, select, cut=None):
     index = 0
+    ag = u.select_atoms(select)
+    if select:
+        dir = f'./coord/{"_".join(select.split())}'
+    else:
+        dir = './coord/all'
     for ts in u.trajectory:
         if ts.frame in frames:
-            o = f'./coord/coord_{index:03d}'
-            with MDAnalysis.Writer(o, u.atoms.n_atoms, format='XYZ') as w:
-                w.write(u)
+            o = f'{dir}/coord_{index:03d}'
+            with MDAnalysis.Writer(o, ag.atoms.n_atoms, format='XYZ') as w:
+                w.write(ag)
                 index += 1
             if cut:
                 with open(o, 'r') as fi, open(o+'t', 'w') as fo:
@@ -39,10 +45,10 @@ def write_to_xyz_s(u, frames, cut=None):
 
 @click.command(name='extract')
 @click.argument('input_file_name', type=click.Path(exists=True), default=os_operation.default_file_name('*-pos-1.xyz', last=True))
-@click.option('-o', type=str, help='output file name', default='extracted.xyz', show_default=True)
 @click.option('-r', type=arg_type.FrameRange, help='frame range to slice', default='-1', show_default=True)
 @click.option('-c', help='output a coord.xyz', is_flag=True)
-def main(input_file_name, o, r, c):
+@click.option("--select", type=str, help="select atoms to extract")
+def main(input_file_name, r, c, select):
     """
     extract frames in trajectory file
     """
@@ -63,16 +69,21 @@ def main(input_file_name, o, r, c):
         cut = None
 
     if len(r) == 3 and r[-1] is not None:
-        if not os.path.exists('./coord'):
-            os.makedirs('./coord')
+        if select:
+            dir = f'./coord/{"_".join(select.split())}'
+        else:
+            dir = './coord/all'
+        if not os.path.exists(dir):
+            os.makedirs(dir)
         else:
             import shutil
-            shutil.rmtree('./coord')
-            os.makedirs('./coord')
-        write_to_xyz_s(u, frames, cut=cut)
-        click.echo(os.path.abspath('./coord'))
+            shutil.rmtree(dir)
+            os.makedirs(dir)
+        write_to_xyz_s(u, frames, select, cut=cut)
+        click.echo(os.path.abspath(dir))
     else:
-        write_to_xyz(u, frames, o, cut=cut)
+        o = f"{os.path.basename(u.filename).split('.')[0]}_{'_'.join([str(i) for i in r])}_{'_'.join(select.split()) if select else 'all'}.xyz"
+        write_to_xyz(u, frames, o, select, cut=cut)
         click.echo(os.path.abspath(o))
 
 

mdkits/md_cli/angle.py

@@ -5,6 +5,7 @@ import MDAnalysis
 import sys
 from mdkits.util import numpy_geo, encapsulated_mda, arg_type
 import numpy as np
+from .setting import common_setting
 
 
 class Angle_distribution(AnalysisBase):
@@ -102,15 +103,9 @@ class Angle_distribution(AnalysisBase):
             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.command(name="angle", help="analysis angle between normal vectors and OH vector or bisector")
+@common_setting
 @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)

mdkits/md_cli/density.py

@@ -10,6 +10,7 @@ from mdkits.util import (
     encapsulated_mda,
     os_operation,
 )
+from .setting import common_setting
 import warnings, sys
 warnings.filterwarnings("ignore")
 
@@ -79,9 +80,10 @@ class Density_distribution(AnalysisBase):
             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]
+            if len(surface) > 1:
+                self.surface_pos[1] += surface[1]
 
         self.frame_count += 1
 
@@ -98,7 +100,8 @@ class Density_distribution(AnalysisBase):
 
             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
 
                 mask = (bins_z >= lower_z) & (bins_z <= upper_z)
                 filtered_bins_z = bins_z[mask] - lower_z
@@ -110,16 +113,11 @@ 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):
     """
     analysis density or concentration of element in a trajectory file

mdkits/md_cli/dipole.py

@@ -0,0 +1,120 @@
+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
+
+            if self.surface:
+                lower_z, upper_z = self.surface_pos / 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

@@ -5,8 +5,9 @@ import click
 import MDAnalysis
 from MDAnalysis import Universe
 from MDAnalysis.analysis.base import AnalysisBase
-from mdkits.util import arg_type, os_operation, numpy_geo, encapsulated_mda
+from mdkits.util import numpy_geo, encapsulated_mda
 import warnings, sys
+from .setting import common_setting
 warnings.filterwarnings("ignore")
 
 
@@ -120,23 +121,27 @@ 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])
-            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]
+            if len(surface) > 1:
+                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 = (self.donor / self.frame_count) / average_od
-            average_accepter = (self.accepter / self.frame_count) / average_od
+            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
 
             if self.surface:
-                lower_z, upper_z = self.surface_pos/self.frame_count
+                surface = self.surface_pos/self.frame_count
+                lower_z = surface[0]
+                if surface[1] ==0:
+                    upper_z = np.inf
                 mask = (bins_z >= lower_z) & (bins_z <= upper_z)
                 filtered_bins_z = bins_z[mask] - lower_z
                 filtered_average_accepter = average_accepter[mask]
@@ -158,15 +163,9 @@ class Hb_distribution(AnalysisBase):
             print(output)
 
 
-@click.command(name="hb")
-@click.argument('filename', type=click.Path(exists=True), default=os_operation.default_file_name('*-pos-1.xyz', last=True))
+@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('--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 element')
-@click.option('-r', type=arg_type.FrameRange, help='range of frame to analysis')
-@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('--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"""

mdkits/md_cli/md_cli.py

@@ -1,21 +1,32 @@
 import click
 from mdkits.md_cli import (
+    wrap,
+    dipole,
+    angle,
     density,
     hb_distribution,
-    angle,
+    vac,
+    rdf,
+    msd,
+    monitor,
 )
 
 
 @click.group(name='md')
 @click.pass_context
-def main(ctx):
+def cli(ctx):
     """kits for MD analysis"""
-    pass
 
-main.add_command(density.main)
-main.add_command(hb_distribution.main)
-main.add_command(angle.main)
+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__':
-    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,30 @@
+import click
+import MDAnalysis as mda
+import MDAnalysis.analysis.msd as msd
+import numpy as np
+
+
+@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)
+def main(filename, type, group):
+    """analysis msd along the given axis"""
+    u = mda.Universe(filename)
+    MSD = msd.EinsteinMSD(u, select=group, msd_type=type, fft=True)
+    MSD.run(verbose=True)
+
+    data = np.arange(1, MSD.n_frames + 1).reshape(-1, 1)
+    s = "_"
+    name = f"{s.join(group.split(' '))}"
+    header = ''
+    for i in range(MSD.n_particles):
+        data = np.concatenate((data, MSD.results.msds_by_particle[:, i].reshape(-1, 1)), axis=1)
+        header += name + f"_{i}\t"
+
+    np.savetxt(f"msd_{type}.dat", data, fmt="%.5f", delimiter="\t", header=f"frame\t{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