mdkits 0.1.27__tar.gz → 0.1.29__tar.gz

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

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

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

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

{mdkits-0.1.27 → mdkits-0.1.29}/src/mdkits/build_cli/cut_surface.py

@@ -70,7 +70,7 @@ def main(atoms, face, vacuum, size, cell, orth):
     super_surface = supercell.supercell(surface, size[0], size[1], 1)
 
     super_surface.write(o)
-    out_err.cell_output(super_surface.cell.cellpar())
+    out_err.cell_output(super_surface)
     out_err.path_output(o)
 
 

mdkits-0.1.29/src/mdkits/dft_cli/dft_cli.py

@@ -0,0 +1,19 @@
+import click
+from mdkits.dft_cli import (
+    cube,
+    pdos,
+)
+
+
+@click.group(name='dft')
+@click.pass_context
+def main(ctx):
+    """kits for dft analysis"""
+    pass
+
+
+main.add_command(cube.main)
+main.add_command(pdos.main)
+
+if __name__ == '__main__':
+    main()

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.27/src/mdkits/cli → 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.29/src/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 arg_type, os_operation, numpy_geo, encapsulated_mda
+import warnings, sys
+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:
+            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
+
+        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_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
+                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")
+@click.argument('filename', type=click.Path(exists=True), default=os_operation.default_file_name('*-pos-1.xyz', last=True))
+@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"""
+    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-0.1.29/src/mdkits/md_cli/md_cli.py

@@ -0,0 +1,21 @@
+import click
+from mdkits.md_cli import (
+    density,
+    hb_distribution,
+    angle,
+)
+
+
+@click.group(name='md')
+@click.pass_context
+def main(ctx):
+    """kits for MD analysis"""
+    pass
+
+main.add_command(density.main)
+main.add_command(hb_distribution.main)
+main.add_command(angle.main)
+
+
+if __name__ == '__main__':
+    main()

{mdkits-0.1.27 → mdkits-0.1.29}/src/mdkits/mdkits.py

@@ -1,14 +1,13 @@
 import click
 from mdkits.build_cli import build_cli
+from mdkits.dft_cli import dft_cli
+from mdkits.md_cli import md_cli
 from mdkits.cli import (
     convert,
     wrap,
     extract,
     data,
     plot,
-    density,
-    cube,
-    pdos,
 )
 
 
@@ -20,15 +19,14 @@ def cli(ctx):
     pass
 
 
+cli.add_command(md_cli.main)
+cli.add_command(dft_cli.main)
+cli.add_command(build_cli.cli_build)
 cli.add_command(convert.main)
 cli.add_command(wrap.main)
 cli.add_command(extract.main)
 cli.add_command(data.main)
 cli.add_command(plot.main)
-cli.add_command(density.main)
-cli.add_command(cube.main)
-cli.add_command(pdos.main)
-cli.add_command(build_cli.cli_build)
 
 
 if __name__ == '__main__':

{mdkits-0.1.27 → mdkits-0.1.29}/src/mdkits/util/arg_type.py

@@ -14,10 +14,8 @@ class CellType(click.ParamType):
 
             if len(cell) == 3:
                 cell += [90, 90, 90]
-                out_err.cell_output(cell)
                 return cell
             elif len(cell) == 6:
-                out_err.cell_output(cell)
                 return cell
             else:
                 self.fail(f"{value} is not a valid cell parameter", param, ctx)

{mdkits-0.1.27 → 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.27 → 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.29/src/mdkits/util/out_err.py

@@ -0,0 +1,29 @@
+"""
+output and error for cli
+"""
+
+import numpy as np
+import sys, os
+
+
+def cell_output(atoms):
+    cell = atoms.cell.cellpar()
+    if not hasattr(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")
+
+
+def path_output(file: str):
+    print(os.path.abspath(file))
+
+def check_cell(atoms, cell=None):
+    if cell is not None:
+        atoms.set_cell(cell)
+        cell_output(atoms)
+    elif not np.array_equal(atoms.cell.cellpar(), np.array([0., 0., 0., 90., 90., 90.])):
+        cell_output(atoms)
+    elif np.array_equal(atoms.cell.cellpar(), np.array([0., 0., 0., 90., 90., 90.])) and cell is not None:
+        atoms.set_cell(cell)
+        cell_output(atoms)
+    else:
+        raise ValueError("can't parse cell please use --cell set cell")

mdkits-0.1.27/src/mdkits/cli/hb_distribution.py

@@ -1,126 +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.accepter = np.zeros(bin_num, dtype=np.float64)
-        self.donor = np.zeros(bin_num, dtype=np.float64)
-
-    def _append(self, hb_d, hb_a):
-        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_d = bins_d[bins_d < len(self.donor)]
-        bins_a = bins_a[bins_a < len(self.accepter)]
-
-        np.add.at(self.donor, bins_d, 1)
-        np.add.at(self.accepter, bins_a, 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]
-        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)
-
-        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, hb_a)
-
-    def _conclude(self):
-        if self.frame_count > 0:
-            average_donor = self.donor / self.frame_count
-            average_accepter = self.accepter / self.frame_count
-            average_sum = average_donor + average_accepter
-
-        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_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))
-
-        np.savetxt("hb_distribution.dat", combined_data, header="Z\tAccepter\tDonor\tAccepter+Donor", 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.27/src/mdkits/util/out_err.py

@@ -1,26 +0,0 @@
-"""
-output and error for cli
-"""
-
-import numpy as np
-import sys, os
-
-
-def cell_output(cell):
-    print(f"system cell: x = {cell[0]}, y = {cell[1]}, z = {cell[2]}, a = {cell[3]}\u00B0, b = {cell[4]}\u00B0, c = {cell[5]}\u00B0")
-
-
-def path_output(file: str):
-    print(os.path.abspath(file))
-
-def check_cell(atoms, cell=None):
-    if cell is not None:
-        atoms.set_cell(cell)
-        cell_output(atoms.cell.cellpar())
-    if not np.array_equal(atoms.cell.cellpar(), np.array([0., 0., 0., 90., 90., 90.])):
-        cell_output(atoms.cell.cellpar())
-    elif np.array_equal(atoms.cell.cellpar(), np.array([0., 0., 0., 90., 90., 90.])) and cell is not None:
-        atoms.set_cell(cell)
-        cell_output(atoms.cell.cellpar())
-    else:
-        raise ValueError("can't parse cell please use --cell set cell")