mdkits 0.1.27__py3-none-any.whl → 0.1.28__py3-none-any.whl

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/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/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], layer_tolerance=1, surface_tolerance=5)
+            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):
+
+    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,19 @@
+import click
+from mdkits.md_cli import (
+    density,
+    hb_distribution,
+)
+
+
+@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)
+
+
+if __name__ == '__main__':
+    main()

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/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/util/out_err.py

@@ -6,8 +6,11 @@ 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 cell_output(atoms):
+    cell = atoms.cell.cellpar()
+    if not hasattr(atoms, "name"):
+        atoms.name = ""
+    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):
@@ -16,11 +19,11 @@ def path_output(file: str):
 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())
+        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.cell.cellpar())
+        cell_output(atoms)
     else:
         raise ValueError("can't parse cell please use --cell set cell")

{mdkits-0.1.27.dist-info → mdkits-0.1.28.dist-info}/METADATA

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

{mdkits-0.1.27.dist-info → mdkits-0.1.28.dist-info}/RECORD

@@ -6,38 +6,41 @@ mdkits/build_cli/build_cli.py,sha256=sqjnq5aHWLYLbNzN5SORkEYeYaewLagFuSvspJxyh7E
 mdkits/build_cli/build_interface.py,sha256=3EDxUb-vGHFuat1Ex_wojVsN8PtzHiGrnDQIEa9WZ60,2448
 mdkits/build_cli/build_solution.py,sha256=7bwaDH-vLBNRzGoYXT72bzLVXdQAZ4HXNuUDuR7AI78,5377
 mdkits/build_cli/build_surface.py,sha256=cBEQ-KR_6j-Mcsxrwvzyl6p1SiY_chIytrCu7MS3q08,2794
-mdkits/build_cli/cut_surface.py,sha256=R0Snr-y23SYLfNhdBC5VgT4KFY1SOGn5hZlVvX5CUvw,2757
+mdkits/build_cli/cut_surface.py,sha256=_f0t2OyBKb8ZV04b3GezfSDUN4XFd5kQM-yWbSmOofs,2742
 mdkits/build_cli/supercell.py,sha256=3iTTt3DHaERWDFonhBRS0oqWhjFh6pbS5SpIR-O1gYg,1034
 mdkits/build_cli/water.xyz,sha256=ByLDz-rYhw_wLPBU78lIQHe4s4Xf5Ckjft-Dus3czIc,171
 "mdkits/cli/,hb_distribution_down.py",sha256=i3NguzGebqCgy4uuVBeFajZRZnXtjhsJBPDGDdumlWA,4733
 mdkits/cli/convert.py,sha256=OmQ-7hmw0imgfgCJaWFEy3ePixsU7VKf0mGuJ6jRpn0,1795
-mdkits/cli/cube.py,sha256=G-QNup8W6J1-LCcEl1EHsV3nstd23byePDOcE_95t18,1176
 mdkits/cli/data.py,sha256=FGA4S9Cfo6WUJBSPWKOJrrZXHo_Qza-jNG1P_Dw7yi4,3262
-mdkits/cli/density.py,sha256=Y4grT8p7CsxggGYo_nGE9z_wlkJeQS5eYWKJQcoA014,5559
 mdkits/cli/extract.py,sha256=bqqJBmSaVyPYyEseGpUJcMBufIfDLTNRdmUfJ0txE5E,2498
 mdkits/cli/hartree_potential.py,sha256=XcJfsJ5Y2d5MQfD45p06_gV1fTJbDSrNhCnZ3Sz2Vb0,2233
 mdkits/cli/hartree_potential_ave.py,sha256=25oy3QsgIdxrTFpTqpnGvLAheb-d6poeLMN7iuGT3Xk,3335
 mdkits/cli/hb.py,sha256=lADr4tlctbtQ3_f_UpznkLnSI0MJlAT-pknEf_dwrnU,5330
-mdkits/cli/hb_distribution.py,sha256=VpTyOhU9oucWUnqUSmLgZfMb5g0tR0q7vrxakLSrKxI,5120
 mdkits/cli/packmol_input.py,sha256=76MjjMMRDaW2q459B5mEpXDYSSn14W-JXudOOsx-8E4,2849
-mdkits/cli/pdos.py,sha256=ALAZ5uOaoT0UpCyKYleWxwmk569HMzKTTK-lMJeicM8,1411
 mdkits/cli/plot.py,sha256=1yh5dq5jnQDuyWlxV_9g5ztsnuFHVu4ouYQ9VJYSrUU,8938
 mdkits/cli/wrap.py,sha256=AUxGISuiCfEjdMYl-TKc2VMCPHSybWKrMIOTn_6kSp0,1043
 mdkits/config/__init__.py,sha256=ZSwmnPK02LxJLMgcYmNb-tIOk8fEuHf5jpqD3SDHWLg,1039
 mdkits/config/settings.yml,sha256=PY7u0PbFLuxSnd54H5tI9oMjUf-mzyADqSZtm99BwG0,71
-mdkits/mdkits.py,sha256=7yZHo13dn_Nn5K7BNIrEXFN44WoZoWD_MqgRQGhTJEU,627
+mdkits/dft_cli/cube.py,sha256=G-QNup8W6J1-LCcEl1EHsV3nstd23byePDOcE_95t18,1176
+mdkits/dft_cli/dft_cli.py,sha256=Ou9-e4uGhDJJk2Gdg7tcj6iKApkAJZFSbN1hr7SlCMc,281
+mdkits/dft_cli/pdos.py,sha256=ALAZ5uOaoT0UpCyKYleWxwmk569HMzKTTK-lMJeicM8,1411
+mdkits/md_cli/density.py,sha256=Y4grT8p7CsxggGYo_nGE9z_wlkJeQS5eYWKJQcoA014,5559
+mdkits/md_cli/hb_distribution.py,sha256=CLWddtrmrKAPxSM-rq2EHwLSy8WhLOQ61FOPE824f9g,8283
+mdkits/md_cli/md_cli.py,sha256=Ju5BrLrreWnf5taHUULbdQPPIhD6N_Cbr0erjjv3HnA,306
+mdkits/mdkits.py,sha256=UGCAbVml8MdXXG--LGo8BUm9BXofg9P3HKIEDTUbd48,635
+mdkits/util/.fig_operation.py.swp,sha256=iZYqdYMj4UKS1rmbXv8Ve2FcVBcNljX7Y43-neMdPSk,12288
 mdkits/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mdkits/util/arg_type.py,sha256=Dc4tC0V-F2dA83QShLFxZckBYM2TebthzL425s2buLo,2523
+mdkits/util/arg_type.py,sha256=o4Fz5VaNBpCWvnJ0u7tKex1sOGx9d2PFtXHmEFMJbA4,2437
 mdkits/util/cp2k_input_parsing.py,sha256=7NMVOYEGycarokLJlhLoWWilciM7sd8MWp5FVTF7hqI,1223
 mdkits/util/encapsulated_ase.py,sha256=uhqIhsALxzwJYuFrfOYGGC6U0QLm_dcZNridvfl_XGc,4339
 mdkits/util/encapsulated_mda.py,sha256=td3H24u3eHOIS2nwPucfIaMxeaVxI77oFI8nnNhw7vo,2217
 mdkits/util/fig_operation.py,sha256=FwffNUtXorMl6qE04FipgzcVljEQii7wrNJUCJMyY3E,1045
 mdkits/util/numpy_geo.py,sha256=1Op8THoQeyqybSZAi7hVxohYCr4SzY6ndZC8_gAGXDA,3619
 mdkits/util/os_operation.py,sha256=ErN2ExjX9vZRfPe3ypsj4eyoQTEePqzlEX0Xm1N4lL4,980
-mdkits/util/out_err.py,sha256=xP36kwp4eYnFs-ZPWL8_9VPWXK31Q_ZeiawQfHHpvvs,835
+mdkits/util/out_err.py,sha256=1clfZpZX1alky_z2nw_A6X8zsG8ofIG-xmXjZyddDjU,893
 mdkits/util/structure_parsing.py,sha256=mRPMJeih3O-ST7HeETDvBEkfV-1psT-XgxyYgDadV0U,4152
-mdkits-0.1.27.dist-info/entry_points.txt,sha256=xoWWZ_yL87S501AzCO2ZjpnVuYkElC6z-8J3tmuIGXQ,44
-mdkits-0.1.27.dist-info/LICENSE,sha256=VLaqyB0r_H7y3hUntfpPWcE3OATTedHWI983htLftcQ,1081
-mdkits-0.1.27.dist-info/METADATA,sha256=u3mxa5DCBEs8cSbRY3r2PONdh7YbD2HA88tCy1r9p9Q,6907
-mdkits-0.1.27.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-mdkits-0.1.27.dist-info/RECORD,,
+mdkits-0.1.28.dist-info/entry_points.txt,sha256=xoWWZ_yL87S501AzCO2ZjpnVuYkElC6z-8J3tmuIGXQ,44
+mdkits-0.1.28.dist-info/LICENSE,sha256=VLaqyB0r_H7y3hUntfpPWcE3OATTedHWI983htLftcQ,1081
+mdkits-0.1.28.dist-info/METADATA,sha256=60_KTg3G4c4ncwBHPQJXWAwVXi6oQddLVJgoU5tuJV8,6907
+mdkits-0.1.28.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+mdkits-0.1.28.dist-info/RECORD,,

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()