mdkits 0.1.30__tar.gz → 0.2.1__tar.gz

{mdkits-0.1.30 → mdkits-0.2.1}/PKG-INFO

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

{mdkits-0.1.30 → mdkits-0.2.1}/pyproject.toml

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

{mdkits-0.1.30 → mdkits-0.2.1}/src/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-0.1.30 → mdkits-0.2.1}/src/mdkits/md_cli/density.py

@@ -118,14 +118,20 @@ class Density_distribution(AnalysisBase):
 @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)
-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-0.1.30 → mdkits-0.2.1}/src/mdkits/md_cli/hb_distribution.py

@@ -5,7 +5,7 @@ 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")

{mdkits-0.1.30 → mdkits-0.2.1}/src/mdkits/md_cli/md_cli.py

@@ -5,6 +5,7 @@ from mdkits.md_cli import (
     angle,
     density,
     hb_distribution,
+    vac,
     rdf,
     msd,
     monitor,
@@ -21,6 +22,7 @@ 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)

{mdkits-0.1.30 → mdkits-0.2.1}/src/mdkits/md_cli/rdf.py

@@ -2,9 +2,20 @@ 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')
@@ -18,10 +29,13 @@ def main(filename, cell, group, range, r):
     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='density')
+    crdf = rdf.InterRDF(group1, group2, verbose=True, range=(range[0], range[1]), norm='rdf')
+
 
     if r is not None:
         if len(r) == 2:
@@ -31,8 +45,8 @@ def main(filename, cell, group, range, r):
     else:
         crdf.run()
 
-    combin = np.column_stack((crdf.results.bins, crdf.results.rdf))
-    np.savetxt(o, combin, header="A\tgr", fmt="%.5f", delimiter='\t')
+    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__":

mdkits-0.2.1/src/mdkits/md_cli/vac.py

@@ -0,0 +1,67 @@
+import numpy as np
+import click
+import MDAnalysis
+from MDAnalysis import Universe
+from MDAnalysis.analysis.base import AnalysisBase
+from mdkits.util import os_operation, arg_type
+
+
+class Velocity_AutoCorrelation(AnalysisBase):
+    def __init__(self, filename, select, dt=0.001):
+        u = Universe(filename)
+        u.trajectory.ts.dt = dt
+        self.u = u
+        self.atomgroup = u.select_atoms(select)
+
+        super(Velocity_AutoCorrelation, self).__init__(self.atomgroup.universe.trajectory, verbose=True)
+
+    def _prepare(self):
+        self.cvv = []
+        self.v0 = self.atomgroup.positions
+        self.normalize = 1/np.sum(self.v0*self.v0)
+        self.cvv.append(np.sum(self.v0*self.v0)*self.normalize)
+
+
+    def _append(self, cvv):
+        self.cvv.append(cvv*self.normalize)
+
+    def _single_frame(self):
+        cvv = np.sum(self.atomgroup.positions*self.v0)
+        self._append(cvv)
+
+    def _conclude(self):
+        self.cvv = np.array(self.cvv)
+
+        sf = self.cvv.shape[0]
+        f = np.abs(np.fft.fft(self.cvv))
+
+        faxis = np.fft.fftfreq(sf, d=1/sf)
+        pf = np.where(faxis>0)
+        faxis = faxis[pf]
+        f = f[pf]
+
+        combine = np.column_stack((np.arange(len(self.cvv)), self.cvv))
+
+        np.savetxt('vac.dat', combine, fmt='%.5f', header="frame\tvac")
+        np.savetxt('f.dat', np.column_stack((faxis, f)), fmt='%.5f')
+
+
+@click.command(name="vac")
+@click.argument("filename", type=click.Path(exists=True), default=os_operation.default_file_name('*-vel-1.xyz', last=True))
+@click.option("--select", type=str, default="all", help="atom selection", show_default=True)
+@click.option('-r', type=arg_type.FrameRange, help='range of frame to analysis')
+def main(filename, select, r):
+    """analysis velocity autocorrelation function"""
+    a = Velocity_AutoCorrelation(filename, select)
+
+    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.30/src/mdkits/cli/,hb_distribution_down.py

@@ -1,114 +0,0 @@
-#!/usr/bin/env python3
-
-import numpy as np
-import argparse
-import MDAnalysis
-from MDAnalysis import Universe
-from MDAnalysis.analysis.base import AnalysisBase
-from util import cp2k_input_parsing
-import warnings
-warnings.filterwarnings("ignore")
-
-
-class Hb_distribution(AnalysisBase):
-    def __init__(self, filename, cell, surface, dt=0.001, hb_distance=3.5, hb_angle=35, 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.hb_distance = hb_distance
-        self.hb_angle = hb_angle
-        self.bin_size = bin_size
-        self.surface = surface
-        self.frame_count = 0
-        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.donor = np.zeros(bin_num, dtype=np.float64)
-
-    def _append(self, hb_d):
-        bins_d = np.floor(hb_d / self.bin_size).astype(int) + 1
-
-        bins_d = bins_d[bins_d < len(self.donor)]
-
-        np.add.at(self.donor, bins_d, 1)
-
-        self.frame_count += 1
-
-    def _single_frame(self):
-        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]
-
-        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)
-        )
-
-        mid_z = (self.surface[0] + self.surface[1]) / 2
-
-        condition_d = ((angle_o0h1_o0_o1 < self.hb_angle) | (angle_o0h2_o0_o1 < self.hb_angle)) & (o0.positions[:, 2] - o1.positions[:, 2] > 0)
-        #condition_d = ((angle_o0h1_o0_o1 < self.hb_angle) | (angle_o0h2_o0_o1 < self.hb_angle)) & (((o0.positions[:, 2] < mid_z) & (o0.positions[:, 2] - o1.positions[:, 2] > 0)) | ((o0.positions[:, 2] > mid_z) & (o0.positions[:, 2] - o1.positions[:, 2] < 0)))
-        #condition_a = ((angle_o1h1_o1_o0 < self.hb_angle) | (angle_o1h2_o1_o0 < self.hb_angle)) & (((o1.positions[:, 2] < mid_z) & (o1.positions[:, 2] - o0.positions[:, 2] > 1.5)) | ((o1.positions[:, 2] > mid_z) & (o1.positions[:, 2] - o0.positions[:, 2] < -1.5)))
-
-        hb_d = (o0.positions[:, 2][condition_d] + o1.positions[:, 2][condition_d]) / 2
-        #hb_a = (o0.positions[:, 2][condition_a] + o1.positions[:, 2][condition_a]) / 2
-
-        self._append(hb_d)
-
-    def _conclude(self):
-        if self.frame_count > 0:
-            average_donor = self.donor / self.frame_count
-
-        bins_z = np.arange(len(self.donor)) * self.bin_size
-
-        lower_z, upper_z = self.surface
-        mask = (bins_z >= lower_z) & (bins_z <= upper_z)
-        filtered_bins_z = bins_z[mask] - lower_z
-        filtered_average_donor = average_donor[mask]
-
-        combined_data = np.column_stack((filtered_bins_z, filtered_average_donor))
-
-        filename = 'hb_distribution_down.dat'
-        np.savetxt(filename, combined_data, header="Z\tDonor", fmt='%.5f', delimiter='\t')
-
-
-def parse_data(s):
-    return [float(x) for x in s.replace(',', ' ').split()]
-
-
-def parse_r(s):
-    return [int(x) for x in s.replace(':', ' ').split()]
-
-
-def parse_argument():
-    parser = argparse.ArgumentParser(description="analysis hb distribution")
-    parser.add_argument('filename', type=str, help='filename to analysis')
-    parser.add_argument('--cp2k_input_file', type=str, help='input file name of cp2k, default is "input.inp"', default='input.inp')
-    parser.add_argument('-r', type=parse_r, help='range of analysis', default=[0, -1, 1])
-    parser.add_argument('--cell', type=parse_data, help='set cell, a list of lattice, --cell x,y,z or x,y,z,a,b,c')
-    parser.add_argument('--surface', type=parse_data, help='[down_surface_z, up_surface_z]')
-    parser.add_argument('--hb_param', type=parse_data, help='[hb_distance, hb_angle], default is [3.5, 35]', default=[3.5, 35])
-
-    return parser.parse_args()
-
-
-def main():
-    args = parse_argument()
-    cell = cp2k_input_parsing.get_cell(args.cp2k_input_file, args.cell)
-
-    hb_dist = Hb_distribution(args.filename, cell, args.surface, hb_distance=args.hb_param[0], hb_angle=args.hb_param[1])
-    hb_dist.run(start=args.r[0], stop=args.r[1], step=args.r[2])
-
-
-if __name__ == '__main__':
-    main()

mdkits-0.1.30/src/mdkits/cli/hartree_potential.py

@@ -1,59 +0,0 @@
-#!/usr/bin/env python3
-
-################################################
-# averange cp2k output(or some else file correspond to ase.io.read_cube_data) hartree.cube to z coordinate with python
-## file path is need to pay attention
-## cycle parameter is need to pay attention
-## buck range is need to pay attention
-################################################
-
-from numpy import empty, array, mean, append, concatenate
-from argparse import ArgumentParser
-from util import encapsulated_ase, os_operation
-
-
-def array_type(string):
-	number_list = string.split(',')
-	number_array = array(number_list, dtype=float)
-	return number_array
-
-
-def buck_potential(xaxe, potential, range):
-	mix = concatenate((xaxe.reshape(-1, 1), potential.reshape(-1, 1)), axis=1)
-	mask = (mix[:,0] >= range[0]) & (mix[:,0] <=range[1])
-	buck_potential = mix[mask]
-	ave_potential = mean(buck_potential[:,1])
-	return ave_potential
-
-
-# set argument
-parser = ArgumentParser(description='to handle cp2k output file hartree cube, name should be "hartree-*.cube"')
-parser.add_argument('file_name', type=str, nargs='?', help='hartree cube file', default=os_operation.default_file_name('*-v_hartree-1_*.cube', last=True))
-parser.add_argument('-b', '--buck_range', type=array_type, help='parameter to calculate mean value of buck', default=None)
-parser.add_argument('-o', type=str, help='output file name, default is "out.put"', default='hartree.out')
-
-args = parser.parse_args()
-
-
-## init output potential file's shape, and define a z axe
-init_array = encapsulated_ase.ave_potential(args.file_name)
-potential = empty((0, init_array[0].shape[0]))
-z_coordinates = array((init_array[1])).reshape(-1, 1)
-
-potential = encapsulated_ase.ave_potential(args.file_name)[0]
-
-aved = mean(potential, axis=0)
-total_potential = append(z_coordinates, potential.reshape(-1, 1), axis=1)
-
-## if buck range is exit, out put a difference of potential
-if args.buck_range is not None:
-	buck_potential = buck_potential(z_coordinates, potential, args.buck_range)
-	print(buck_potential)
-	with open('hartree_potential.dat', 'w') as f:
-		f.write(f"{buck_potential}" + '\n')
-
-## write output
-with open(args.o, 'w') as f:
-	for value in total_potential:
-		f.write(" ".join(map(str, value)) + '\n')
-

mdkits-0.1.30/src/mdkits/cli/hartree_potential_ave.py

@@ -1,84 +0,0 @@
-#!/usr/bin/env python3
-
-################################################
-# averange cp2k output(or some else file correspond to ase.io.read_cube_data) hartree.cube to z coordinate with python
-## file path is need to pay attention
-## cycle parameter is need to pay attention
-## buck range is need to pay attention
-################################################
-
-from ase.io.cube import read_cube_data
-import numpy as np
-import argparse
-
-def array_type(string):
-	number_list = string.split(',')
-	number_array = np.array(number_list, dtype=int)
-	return number_array
-
-
-def ave_potential(filepath):
-	# is to average hartree file in z_coordinate
-	
-	## read data from filepath
-	data, atoms = read_cube_data(filepath)
-	
-	## define need parameter
-	npoints = data.shape[2]
-	step_size = atoms.cell[2, 2] / ( npoints - 1 )
-	
-	## average hartree file, and calculate z_coordinates
-	z_coordinates = [i * step_size for i in range(npoints)]
-	z_potential = 27.2114 * data[:, :, :].sum(axis=(0, 1)) / ( data.shape[0] * data.shape[1] )
-	return z_potential, z_coordinates
-
-
-def buck_potential(xaxe, potential, range):
-	mix = np.concatenate((xaxe.reshape(-1, 1), potential.reshape(-1, 1)), axis=1)
-	mask = (mix[:,0] >= range[0]) & (mix[:,0] <=range[1])
-	buck_potential = mix[mask]
-	ave_potential = np.mean(buck_potential[:,1])
-	return ave_potential
-
-
-# set argument
-parser = argparse.ArgumentParser(description='to handle cp2k output file hartree cube, name should be "hartree-*.cube"')
-parser.add_argument('folder_path', type=str, help='folder that contain all hartree cube file')
-parser.add_argument('cyc_range', type=array_type, help='cycle parameter, need to seperate with ",", similar with range() -- 1,201  1,201,10')
-parser.add_argument('-b', '--buck_range', type=array_type, help='parameter to calculate mean value of buck', default=None)
-parser.add_argument('-o', type=str, help='output file name, default is "out.put"', default='hartree.out')
-
-args = parser.parse_args()
-
-
-## init output potential file's shape, and define a z axe
-init_array = ave_potential('{}/hartree-{}.cube'.format(args.folder_path, args.cyc_range[0]))
-potential = np.empty((0, init_array[0].shape[0]))
-z_coordinates = np.array((init_array[1])).reshape(-1, 1)
-
-## average one hartree file
-if len(args.cyc_range) == 3:
-	for i in range(args.cyc_range[0], args.cyc_range[1], args.cyc_range[2]):
-		file_path = '{}/hartree-{}.cube'.format(args.folder_path, i)
-		potential = np.append(potential, [ave_potential(file_path)[0]], axis=0)
-else:
-	for i in range(args.cyc_range[0], args.cyc_range[1]):
-		file_path = '{}/hartree-{}.cube'.format(args.folder_path, i)
-		potential = np.append(potential, [ave_potential(file_path)[0]], axis=0)
-
-## average every averaged harterr file, and append to z_coordinates
-#aved_potential = potential[:, :].sum(axis=0) / len(range(1, 201))
-aved = np.mean(potential, axis=0)
-total_potential = np.append(z_coordinates, aved.reshape(-1, 1), axis=1)
-
-## if buck range is exit, out put a difference of potential
-if args.buck_range is not None:
-	buck_potential = buck_potential(z_coordinates, aved, args.buck_range)
-	with open(args.o + 'diff', 'w') as f:
-		f.write("{}\t{}\t{}".format(aved[0], buck_potential, aved[0]-buck_potential))
-
-## write output
-with open(args.o, 'w') as f:
-	for value in total_potential:
-		f.write(" ".join(map(str, value)) + '\n')
-

mdkits-0.1.30/src/mdkits/cli/hb.py

@@ -1,101 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse, multiprocessing, os
-import numpy as np
-from util import (
-    structure_parsing,
-    numpy_geo,
-    os_operation,
-    cp2k_input_parsing,
-    )
-
-
-def hb_count(chunk, index, cell, filename, hb_distance=3.5, hb_angle=35):
-    groups = structure_parsing.chunk_to_groups(chunk)
-    groups_hb_list = []
-    coefficients = numpy_geo.cell_to_wrap_coefficients(cell)
-    for group in groups:
-        group_hb_array = np.zeros((3, 1))
-        present_index = index
-        o_present = group[present_index].split()
-        if o_present[0] == 'O':
-            o_present = np.array(o_present[1:], dtype=np.float64)
-            group_hb_array[2, 0] += 1
-            for other_index in range(2, len(group)):
-                o_other = group[other_index].split()
-                if o_other[0] == 'O':
-                    o_other = np.array(o_other[1:], dtype=np.float64)
-                    oo_distance, o_other = numpy_geo.unwrap(o_present, o_other, coefficients, max=0)
-                    if oo_distance < hb_distance and oo_distance > 1:
-                        _, o_present_h1 = numpy_geo.unwrap(o_present, np.array(group[present_index+1].split()[1:], dtype=np.float64), coefficients)
-                        _, o_present_h2 = numpy_geo.unwrap(o_present, np.array(group[present_index+2].split()[1:], dtype=np.float64), coefficients)
-                        _, o_other_h1 = numpy_geo.unwrap(o_other, np.array(group[other_index+1].split()[1:], dtype=np.float64), coefficients)
-                        _, o_other_h2 = numpy_geo.unwrap(o_other, np.array(group[other_index+2].split()[1:], dtype=np.float64), coefficients)
-
-                        o_present_o_other_h1_angle = numpy_geo.vector_vector_angle(o_present-o_other, o_other_h1-o_other)
-                        o_present_o_other_h2_angle = numpy_geo.vector_vector_angle(o_present-o_other, o_other_h2-o_other)
-                        if o_present_o_other_h1_angle < hb_angle or o_present_o_other_h2_angle < hb_angle:
-                            group_hb_array[0, 0] += 1
-                        o_other_o_present_h1_angle = numpy_geo.vector_vector_angle(o_other-o_present, o_present_h1-o_present)
-                        o_other_o_present_h2_angle = numpy_geo.vector_vector_angle(o_other-o_present, o_present_h2-o_present)
-                        if o_other_o_present_h1_angle < hb_angle or o_other_o_present_h2_angle < hb_angle:
-                            group_hb_array[1, 0] += 1
-        groups_hb_list.append(group_hb_array)
-    groups_hb_array = np.vstack(groups_hb_list)
-    group_hb_acc_array = np.sum(groups_hb_array[0::3], axis=0).reshape(1, -1)
-    group_hb_don_array = np.sum(groups_hb_array[1::3], axis=0).reshape(1, -1)
-    group_hb_num_array = np.sum(groups_hb_array[2::3], axis=0).reshape(1, -1)
-    group_hb_array = np.vstack([group_hb_acc_array, group_hb_don_array, group_hb_num_array])
-    np.save(filename, group_hb_array)
-
-
-def parse_data(s):
-    return [float(x) for x in s.replace(',', ' ').split()]
-
-def parse_argument():
-    parser = argparse.ArgumentParser(description="analysis an O atom's hydrogen bond in water")
-    parser.add_argument('index', type=int, help='index of target atom in coord.xyz, or all of hb distribution on z')
-    parser.add_argument('input_file_name', type=str, nargs='?', help='input file name', default=os_operation.default_file_name('wraped.xyz', last=True))
-    parser.add_argument('--cp2k_input_file', type=str, help='input file name of cp2k, default is "input.inp"', default='input.inp')
-    parser.add_argument('--cell', type=parse_data, help='set cell, a list of lattice, --cell x,y,z or x,y,z,a,b,c')
-    parser.add_argument('--hb_param', type=parse_data, help='[hb_distance, hb_angle], default is [3.5, 35]', default=[3.5, 35])
-    parser.add_argument('--process', type=int, help='paralle process number default is 28', default=28)
-    parser.add_argument('--temp', help='keep temp file', action='store_false')
-
-    return parser.parse_args()
-
-def main():
-    args = parse_argument()
-    output = f'./hb_{args.index}.dat'
-    cell = cp2k_input_parsing.get_cell(args.cp2k_input_file, args.cell)
-    chunks = structure_parsing.xyz_to_chunks(args.input_file_name, args.process)
-    temp_dir = f'{os.environ.get("TEMP_DIR")}/{os.getpid()}'
-    os_operation.make_temp_dir(temp_dir, delete=args.temp)
-
-    for index, chunk in enumerate(chunks):
-        t = multiprocessing.Process(target=hb_count, args=[chunk, args.index, cell, f'{temp_dir}/chunk_{index}.temp'])
-        t.start()
-
-    for t in multiprocessing.active_children():
-        t.join()
-
-    chunks_array_list = []
-    for i in range(len(chunks)):
-        chunk_array = np.load(f'{temp_dir}/chunk_{i}.temp.npy')
-        chunks_array_list.append(chunk_array)
-    chunks_array = np.vstack(chunks_array_list)
-    chunks_array = np.mean(chunks_array, axis=1)
-
-    with open(output, 'w') as f:
-        f.write(f"# {args.index}\n")
-        f.write(f"accepter : {chunks_array[0]:.2f}\n")
-        f.write(f"donor    : {chunks_array[1]:.2f}\n")
-        f.write(f"total    : {chunks_array[0]+chunks_array[1]:.2f}\n")
-    print(f"# {args.index}")
-    print(f"accepter : {chunks_array[0]:.2f}")
-    print(f"donor    : {chunks_array[1]:.2f}")
-    print(f"total    : {chunks_array[0]+chunks_array[1]:.2f}")
-
-
-if __name__ == '__main__':
-    main()

mdkits-0.1.30/src/mdkits/cli/packmol_input.py

@@ -1,76 +0,0 @@
-import argparse
-
-
-def parse_cell(s):
-    return [float(x) for x in s.replace(',', ' ').split()]
-
-
-def parse_argument():
-    parser = argparse.ArgumentParser(description='generate packmol input file with give parameter')
-    parser.add_argument('--size', type=int, help='water size default is 30', default=30)
-    parser.add_argument('--cell', type=parse_cell, help='input box size(a,b,c)')
-    parser.add_argument('--addwat', type=int, help='add some additional water, default is 0', default=0)
-    parser.add_argument('--ioncon', type=float, help='concentration of sol box, default is 0.0', default=0.0)
-    parser.add_argument('--tolerance', type=float, help='tolerance of packmol, default is 2.5', default=2.5)
-    parser.add_argument('--watpath', type=str, help='water xyz file path', default='C:\\home\\.can\\temp\\packmol\\default\\water.xyz')
-    parser.add_argument('--ionpath', type=str, help='ion xyz file path')
-    parser.add_argument('-o', type=str, help='output file name, default is "input.pm"', default='input.pm')
-    parser.add_argument('--output', type=str, help='output file name of packmol, default is "solbox.xyz"', default='solbox.xyz')
-
-    return parser.parse_args()
-
-
-def get_water_number():
-    water_number = water_volume / water_size
-
-    return int(round(water_number, 0))
-
-
-def get_ion_number(concentration):
-    ion_number = ( (concentration * avogadro) / 1e+27 ) * water_volume
-
-    return int(round(ion_number, 0))
-
-
-def main():
-    global water_volume, water_size, avogadro
-    args = parse_argument()
-    water_volume = args.cell[0] * args.cell[1] * args.cell[2]
-    water_size = args.size
-    avogadro = 6.02214179e+23
-    water_number = get_water_number() + args.addwat
-    ion_number = get_ion_number(args.ioncon)
-
-    if ion_number == 0:
-        packmol_input_str = f"""
-        tolerance {args.tolerance}
-        filetype xyz
-        output {args.output}
-        pbc {args.cell[3]} {args.cell[4]} {args.cell[5]}
-        structure {args.watpath}
-          number {water_number}
-          inside box 2. 2. 2. {args.cell[0]-2} {args.cell[1]-2} {args.cell[2]-2}
-        end structure
-        """
-    else:
-        packmol_input_str = f"""
-        tolerance {args.tolerance}
-        filetype xyz
-        output {args.output}
-        pbc {args.cell[3]} {args.cell[4]} {args.cell[5]}
-        structure {args.watpath}
-          number {water_number}
-          inside box 2. 2. 2. {args.cell[0]-2} {args.cell[1]-2} {args.cell[2]-2}
-        end structure
-        structure {args.ionpath}
-          number {ion_number}
-          inside box 2. 2. 2. {args.cell[0]-2} {args.cell[1]-2} {args.cell[2]-2}
-        end structure
-        """
-
-    with open(args.o, 'w') as f:
-        f.write(packmol_input_str)
-
-
-if __name__ == '__main__':
-    main()