mdkits 0.1.13__py3-none-any.whl → 1.2.3__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")
 
@@ -44,7 +45,7 @@ def main(atoms, adsorbate, cell, select, height, rotate, offset, cover):
 
     atoms.write(output_filename, format='cif')
 
-    print(os.path.abspath(output_filename))
+    out_err.path_output(output_filename)
 
 
 if __name__ == '__main__':

mdkits/build_cli/build_bulk.py

@@ -3,6 +3,7 @@
 import click, os
 from ase.build import bulk
 import numpy as np
+from mdkits.util import out_err
 
 
 @click.command(name='bulk')
@@ -29,7 +30,7 @@ def main(symbol, cs, a, b, c, alpha, covera, u, orth, cubic):
 
     o = f"{symbol}_{cs}.cif"
     atoms.write(o, format='cif')
-    print(os.path.abspath(o))
+    out_err.path_output(o)
 
 
 if __name__ == '__main__':

mdkits/build_cli/build_interface.py

@@ -23,6 +23,9 @@ def main(slab, sol, interval, cap, vacuum):
         slab_copy = slab.copy()
 
     sol_cell = sol.cell.cellpar()
+
+    interface_cell = [max(slab_cell[0], sol_cell[0]), max(slab_cell[1], sol_cell[1]), max(slab_cell[2], sol_cell[2]), max(slab_cell[3], sol_cell[3]), max(slab_cell[4], sol_cell[4]), max(slab_cell[5], sol_cell[5])]
+
     sol.set_pbc(True)
     sol.center()
     sol.positions[:, 2] += slab_cell[2] + interval
@@ -62,6 +65,8 @@ def main(slab, sol, interval, cap, vacuum):
         slab.set_cell(slab_cell)
         slab.center()
     
+    slab_cell[0] = interface_cell[0]
+    slab_cell[1] = interface_cell[1]
     if vacuum > 0:
         slab_cell[2] += vacuum
         slab.set_cell(slab_cell)

mdkits/build_cli/build_solution.py

@@ -2,29 +2,70 @@ import click, os
 from mdkits.util import arg_type
 from importlib import resources
 from mdkits.cli import convert
-import tempfile
+import tempfile, platform, subprocess, sys
 
 
 @click.command(name="solution")
 @click.argument("filename", type=click.Path(exists=True), nargs=-1)
 @click.option('--infile', is_flag=True, help="read input mode")
-@click.option('--install', is_flag=True, help="install julia and packmol")
+@click.option('--install_julia', is_flag=True, help="install julia for system")
+@click.option('--install_packmol', is_flag=True, help="init julia install packmol")
 @click.option('--water_number', type=int, help="number of water molecules", default=0, show_default=True)
 @click.option('-n', type=int, multiple=True, help="number of molecules")
 @click.option('--tolerance', type=float, help="tolerance of solution", default=3.5, 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('--gap', type=float, help="gap between solution and cell", default=1, show_default=True)
-def main(filename, infile, install, water_number, n, tolerance, cell, gap):
+def main(filename, infile, install_julia, install_packmol, water_number, n, tolerance, cell, gap):
     """
     build solution model
     """
-    if install:
+    os_name = platform.system()
+
+    if install_julia:
+        if os_name in ("Darwin", "Linux", "FreeBSD"):
+            try:
+                subprocess.run(
+                ["curl -fsSL https://install.julialang.org | sh"],
+                shell=True,  
+                check=True,
+            )
+                print("Julia installed (macOS, Linux, FreeBSD).")
+                sys.exit(1)
+            except subprocess.CalledProcessError as e:
+                print(f"Julia install failed: {e}")
+                sys.exit(0)
+        elif os_name == "Windows":
+            try:
+                subprocess.run(
+                    ["winget", "install", "--name", "Julia", "--id", "9NJNWW8PVKMN", "-e", "-s", "msstore"],
+                    check=True,
+                )
+                print("Julia installed (Windows).")
+                sys.exit(1)
+            except subprocess.CalledProcessError as e:
+                print(f"Julia install failed: {e}")
+                sys.exit(0)
+        else:
+            print(f"unsupport os: {os_name}")
+            sys.exit(0)
+
+    if install_packmol:
         import julia
         julia.install()
+
+        from julia.api import Julia
+        jl = Julia(compiled_modules=False)
+
+        from julia import Pkg, Main
+        Pkg.add("PyCall")
         Pkg.activate("Packmol", shared=True)
         Pkg.add("Packmol")
         Main.exit()
     else:
+        if os_name in ("Darwin", "Linux"):
+            from julia.api import Julia
+            jl = Julia(compiled_modules=False)
+
         from julia import Pkg, Main
 
         if cell is None:
@@ -33,6 +74,9 @@ def main(filename, infile, install, water_number, n, tolerance, cell, gap):
         if len(filename) == 0 and water_number == 0:
             raise ValueError("at least one file should be provided, or water_number should be greater than 0")
 
+        if os_name in ("Darwin", "Linux"):
+            Pkg.activate("Packmol", shared=True)
+
         while True:
             try:
                 Main.using("Packmol")

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)
@@ -53,7 +50,7 @@ def main(symbol, surface, size, kind, a, c, thickness, orth, vacuum):
     
     out_err.check_cell(atoms)
     atoms.write(out_filename)
-    print(os.path.abspath(out_filename))
+    out_err.path_output(out_filename)
 
 
 if __name__ == '__main__':

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/build_cli/supercell.py

@@ -34,7 +34,7 @@ def main(atoms, super, cell):
 
     o = f"{atoms.filename.split('.')[-2]}_{super[0]}{super[1]}{super[2]}.cif"
     super_atom.write(o)
-    print(os.path.abspath(o))
+    out_err.path_output(o)
 
 
 if __name__ == '__main__':

mdkits/cli/convert.py

@@ -57,7 +57,7 @@ def main(atoms, c, x, d, v, coord, cp2k, center, cell):
             f.write(f"ALPHA_BETA_GAMMA {cell[3]} {cell[4]} {cell[5]}\n")
 
 
-    print(os.path.abspath(o))
+    out_err.path_output(o)
 
 
 if __name__ == '__main__':

mdkits/cli/extract.py

@@ -4,16 +4,17 @@
 
 import os
 import click
-from mdkits.util import os_operation, arg_type
+from mdkits.util import os_operation, arg_type, out_err
 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", default="all", show_default=True)
+def main(input_file_name, r, c, select):
     """
     extract frames in trajectory file
     """
@@ -63,17 +69,22 @@ 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)
-        click.echo(os.path.abspath(o))
+        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)
+        out_err.path_output(o)
 
 
 if __name__ == '__main__':

mdkits/{cli → dft_cli/.back}/pdos.py

@@ -12,6 +12,7 @@ from mdkits.util import os_operation
 @click.option('-t', '--type', type=str, default='total', show_default=True)
 @click.option('-c', '--clos', type=tuple)
 def main(filename, type, clos):
+    """analysis cp2k pdos file"""
     if type == 'total':
         dos_obj = Cp2kPdos(filename[0])
         dos, ener = dos_obj.get_raw_dos(dos_type=type)

mdkits/{cli → dft_cli}/cube.py

@@ -14,14 +14,15 @@ def ave_cube_data(cube_data, range):
 
 @click.command(name='cube')
 @click.argument('filename', type=click.Path(exists=True), default=os_operation.default_file_name('*.cube', last=True))
+@click.argument('axis', type=click.Choice(['x','y','z', '0','1','2']), default='z')
 @click.option('-b', '--bulk_range', type=(float, float), help='parameter to calculate mean value of bulk', default=None)
 @click.option('-o', type=str, help='output file name, default is "cube.out"', default='cube.out', show_default=True)
-def main(filename, bulk_range, o):
+def main(filename, axis, bulk_range, o):
 	"""
 	analysis cube file
 	"""
 
-	cube_data = encapsulated_ase.ave_cube(filename)
+	cube_data = encapsulated_ase.ave_cube(filename, axis)
 
 	## if bulk range is exit, out put a difference of cube_data
 	if bulk_range is not None:

mdkits/dft_cli/dft_cli.py

@@ -0,0 +1,23 @@
+import click
+from mdkits.dft_cli import (
+    cube,
+    pdos,
+    fix,
+)
+from mdkits.dft_cli import 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)
+main.add_command(fix.main)
+main.add_command(pdos.main)
+
+if __name__ == '__main__':
+    main()

mdkits/dft_cli/fix.py

@@ -0,0 +1,54 @@
+import click
+from MDAnalysis import Universe
+from mdkits.util import encapsulated_ase, os_operation
+
+
+@click.command(name='fix')
+@click.argument('filename', type=click.Path(exists=True), default='./coord.xyz')
+@click.argument('group', type=str)
+@click.option('-o', type=str, help='output file name, default is "fix.inc"', default='fix.inc', show_default=True)
+def main(filename, group, o):
+    """
+    generate fix.inc file for cp2k
+    """
+    
+    with open(filename, 'r', encoding='utf-8') as fh:
+        lines = fh.read().splitlines()
+    first = lines[0].strip() if lines else ''
+    if not first.isdigit():
+        atoms_number = sum(1 for l in lines if l.strip())
+        s = '\n'.join([str(atoms_number), ''] + lines) + '\n'
+        import io
+        virtual_file = io.StringIO(s)
+        atoms = Universe(virtual_file, format='xyz').select_atoms(group)
+    else:
+        atoms = Universe(filename).select_atoms(group)
+    indices = atoms.indices + 1
+    fix_number = len(indices)
+    fix_output = f"{fix_number} atoms have been fixed."
+    
+    arr = sorted(set(int(i) for i in indices))
+    if not arr:
+        list_str = ""
+    else:
+        ranges = []
+        start = prev = arr[0]
+        for x in arr[1:]:
+            if x == prev + 1:
+                prev = x
+            else:
+                if start == prev:
+                    ranges.append(str(start))
+                else:
+                    ranges.append(f"{start}..{prev}")
+                start = prev = x
+        
+        if start == prev:
+            ranges.append(str(start))
+        else:
+            ranges.append(f"{start}..{prev}")
+        list_str = "# " + group + "\n" "# " + fix_output + "\n" + "LIST " + " ".join(ranges)
+
+    print(list_str)
+    with open(o, 'w') as f:
+        f.write(list_str + '\n')

mdkits/dft_cli/pdos.py

@@ -0,0 +1,119 @@
+from pymatgen.io.cp2k import outputs
+import click
+from mdkits.util import arg_type
+from pymatgen.electronic_structure.core import Spin
+import pandas as pd
+import numpy as np
+
+
+def calculate_gaussian_dos(E_grid, eigenvalues, weights, sigma):
+    """
+    使用高斯函数对离散能级进行展宽计算 DOS。
+    利用 NumPy 广播机制进行高效计算。
+    """
+    # E_grid shape: (N_grid,) -> 变为列向量 (N_grid, 1)
+    # eigenvalues shape: (N_eigen,) -> 变为行向量 (1, N_eigen)
+    # delta_E shape: (N_grid, N_eigen)，包含了每个网格点到每个本征值的距离
+    delta_E = E_grid[:, np.newaxis] - eigenvalues[np.newaxis, :]
+    
+    # 计算高斯项
+    prefactor = 1.0 / (sigma * np.sqrt(2 * np.pi))
+    gaussians = prefactor * np.exp(-0.5 * (delta_E / sigma)**2)
+    
+    # 对所有本征值求和，并乘上权重
+    # axis=1 表示沿着本征值的方向求和，最终得到 (N_grid,) 的数组
+    dos_values = np.sum(gaussians * weights[np.newaxis, :], axis=1)
+    
+    return dos_values
+
+
+
+@click.command(name='pdos')
+@click.option('-i', type=arg_type.FileList, default='*-k*.*', help='pdos files generated by CP2K', show_default=True)
+@click.option('--no-reference', is_flag=True, help='if specified, reference energy will not be shifted to fermi level')
+@click.option('-o', type=str, help='output file name')
+def main(filename, no_reference, o):
+    total_dict = {}
+    for file in filename:
+        dos = outputs.parse_pdos(file, total=True)
+        
+        pdos = dos[0]
+        tdos = dos[1]
+        element = list(pdos.keys())[0]
+        data_dict = {}
+        steplen = 0.2
+        fermi = pdos[element][list(pdos[element].keys())[0]].efermi
+        gap =  pdos[element][list(pdos[element].keys())[0]].get_gap()
+        sigma = 0.02
+
+        energies = pdos[element][list(pdos[element].keys())[0]].energies
+        n_min = np.floor((energies.min() - fermi) / steplen)
+        n_max = np.ceil((energies.max() - fermi) / steplen)
+        integers = np.arange(n_min, n_max + 1)
+        bins = fermi + integers * steplen
+        #e_min = energies.min() - 3 * sigma
+        #e_max = energies.max() + 3 * sigma
+        #n_step_left = np.ceil((fermi - e_min) / steplen).astype(int)
+        #n_step_right = np.ceil((e_max - fermi) / steplen).astype(int)
+        #indices = np.arange(-n_step_left, n_step_right + 1)
+        #bins = fermi + indices * steplen
+        #bins = int((energies[-1]-energies[0])/steplen)
+
+
+        dos, ener = np.histogram(energies, bins=bins, weights=tdos.get_densities(Spin.up), range=(energies[0], energies[-1]))
+        #dos = calculate_gaussian_dos(bins + steplen/2, energies, tdos.get_densities(Spin.up), sigma)
+        #data_dict['energy'] = bins + steplen/2
+        data_dict['energy'] = ener[:-1] + steplen/2
+
+
+        df = pd.DataFrame(data_dict)
+
+        df['total'] = 0
+        for orb_key in pdos[element].keys():
+            data_obj = pdos[element][orb_key]
+            weights = data_obj.get_densities(Spin.up)
+            dos, ener = np.histogram(energies, bins=bins, weights=weights, range=(energies[0], energies[-1]))
+            #dos = calculate_gaussian_dos(bins + steplen/2, energies, weights, sigma)
+            df[orb_key] = dos/steplen
+            df['total'] += dos/steplen
+
+
+        if Spin.down in pdos[element][list(pdos[element].keys())[0]].densities:
+            df['total_down'] = 0
+            for orb_key in pdos[element].keys():
+                data_obj = pdos[element][orb_key]
+                weights = data_obj.get_densities(Spin.down)
+                dos, ener = np.histogram(energies, bins=bins, weights=weights, range=(energies[0], energies[-1]))
+                #dos = calculate_gaussian_dos(bins + steplen/2, energies, weights, sigma)
+                df[f'{orb_key}_down'] = dos/steplen
+                df['total_down'] += dos/steplen
+
+        if o is None:
+            out_filename = f"{element}.pdos"
+        else:
+            out_filename = o
+
+        total_dict[element] = df
+
+        if not no_reference:
+            df['energy'] = df['energy'] - fermi
+
+        with open(out_filename, 'w') as f:
+            header = '#' + ' '.join([str(key) for key in df.columns]) + '\n'
+            f.write(header)
+            df.to_csv(f, sep='\t', index=False, header=False)
+
+
+    energy = list(total_dict.values())[0]['energy']
+
+    total_dos = 0
+    for element, df in total_dict.items():
+        total_dos += df['total']
+
+    total_df = pd.DataFrame({'energy': energy, 'total': total_dos})
+
+    
+    with open('total.pdos', 'w') as f:
+        header = '# energy total_dos' + '\n' + f'# Fermi Level: {fermi}' + f'gap: {gap}' + '\n'
+        f.write(header)
+        total_df.to_csv(f, sep='\t', index=False, header=False)

mdkits/md_cli/angle.py

@@ -0,0 +1,122 @@
+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
+from .setting import common_setting
+
+
+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 surface[1] == 0:
+            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 + self.bin_size / 2
+            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", help="analysis angle between normal vectors and OH vector or bisector")
+@common_setting
+@click.option("--water_height", type=float, help="water height from surface")
+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()