mdkits 0.1a1__py3-none-any.whl

mdkits/cli/,hb_distribution.py

@@ -0,0 +1,126 @@
+#!/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/cli/,hb_distribution_down.py

@@ -0,0 +1,114 @@
+#!/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/cli/adsorbate.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+
+from ase import io, build
+from ase.collections import g2
+import argparse, os
+import numpy as np
+from util import encapsulated_ase
+
+
+def parse_size(s):
+    if s == None:
+        return None
+    return [float(x) for x in s.replace(',', ' ').split()]
+
+
+def parse_index(s):
+    return [int(x)-1 for x in s.replace(',', ' ').split()]
+
+
+def parse_argument():
+    parser = argparse.ArgumentParser(description='add some adsorbate')
+    parser.add_argument('filename', type=str, help='init structure filename')
+    parser.add_argument('-m', type=str, help='atom or molecule to add')
+    parser.add_argument('--index', type=parse_index, help='index(list) of atom to add atom(top site)')
+    parser.add_argument('--offset', type=parse_size, help='adjust site, default is 0,0', default='0,0')
+    parser.add_argument('--height', type=float, help='designate vacuum of surface, default is None', default=0.0)
+    parser.add_argument('-x', type=float, help='rotate axis and angle')
+    parser.add_argument('-y', type=float, help='rotate axis and angle')
+    parser.add_argument('-z', type=float, help='rotate axis and angle')
+    parser.add_argument('-o', type=str, help='specify the output file name without suffix, default is "adsorbated.cif"', default='adsorbated.cif')
+    parser.add_argument('--coord', help='coord format', action='store_true')
+    parser.add_argument('--cell', type=parse_size, help='set xyz file cell, --cell x,y,z,a,b,c')
+    parser.add_argument('--cp2k', help='output cp2k format', action='store_true')
+
+    return parser.parse_args()
+
+def main():
+    args = parse_argument()
+    atoms = encapsulated_ase.atoms_read_with_cell(args.filename, cell=args.cell, coord_mode=args.coord)
+
+    if len(args.offset) < 2:
+        args.offset.append(0)
+    offset = np.array(args.offset)
+
+    position_list = []
+    for atom in atoms:
+        if atom.index in args.index:
+            position_list.append(np.copy(atom.position[0:2])+offset)
+
+    if args.m in g2.names:
+        molecule = build.molecule(args.m)
+        if args.x:
+            molecule.rotate(args.x, 'x')
+        if args.y:
+            molecule.rotate(args.y, 'y')
+        if args.z:
+            molecule.rotate(args.z, 'z')
+        for position in position_list:
+            build.add_adsorbate(atoms, molecule, args.height, position=position)
+    else:
+        for position in position_list:
+            build.add_adsorbate(atoms, args.m, args.height, position=position)
+
+
+    if args.cp2k:
+        args.o = 'coord.xyz'
+        atoms.write(args.o, format='xyz')
+        with open(args.o, 'r') as f:
+            lines = f.readlines()
+        with open(args.o, 'w') as f:
+            f.writelines(lines[2:])
+        with open('cell.inc', 'w') as f:
+            cell = atoms.get_cell().cellpar()
+            f.write('ABC [angstrom] ' + str(cell[0]) + ' ' + str(cell[1]) + ' ' + str(cell[2]) + ' ' + '\n')
+            f.write('ALPHA_BETA_GAMMA ' + str(cell[3]) + ' ' + str(cell[4]) + ' ' + str(cell[5]) + '\n')
+    else:
+        atoms.write(args.o, format='cif')
+
+    print(os.path.abspath(args.o))
+
+
+if __name__ == '__main__':
+    main()
+

mdkits/cli/build_bulk.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+
+import argparse
+from ase.build import bulk
+from ase.geometry import cell_to_cellpar
+from ase.io import write
+
+
+def parse_size(s):
+    return [int(x) for x in s.replace(',', ' ').split()]
+
+
+def parse_argument():
+    parser = argparse.ArgumentParser(description='build a surface structure of matel')
+    parser.add_argument('symbol', type=str, help='designate the symbol of matel')
+    parser.add_argument('--crystal', type=str, help='designate the crystal of structure')
+    parser.add_argument('--orth', help='outpue orthorhombic crystal', action='store_true')
+    parser.add_argument('-a', type=float, help='designate a lattice constant')
+    parser.add_argument('--primitve', help='designate a lattice constant of real', action='store_true')
+    parser.add_argument('-o', type=str, help='output structure name', default='bulk.xyz')
+    parser.add_argument('-c', help='output coord.xyz and cell.inc', action='store_true')
+    parser.add_argument('-k', help='output kpoint.inc', action='store_true')
+
+    return parser.parse_args()
+
+
+def main():
+    args = parse_argument()
+    if args.primitve:
+        a = args.a * 0.7071 * 2
+    else:
+        a = args.a
+    atoms = bulk(args.symbol, args.crystal, a=a, orthorhombic=args.orth)
+    if args.c:
+        atoms.write('coord.xyz', format='xyz')
+        with open('coord.xyz', 'r') as f:
+            lines = f.readlines()[2:]
+        with open('coord.xyz', 'w') as f:
+            f.writelines(lines)
+        with open('cell.inc', 'w') as f:
+            cell = list(cell_to_cellpar(atoms.cell))
+            f.write('ABC [angstrom] ' + str(cell[0]) + ' ' + str(cell[1]) + ' ' + str(cell[2]) + ' ' + '\n')
+            f.write('ALPHA_BETA_GAMMA ' + str(cell[3]) + ' ' + str(cell[4]) + ' ' + str(cell[5]) + '\n')
+        if args.k:
+            with open('kpoint.inc', 'w') as f:
+                if True:
+                    if True:
+                        f.write(f"SCHEME MONKHORST-PACK {int(round(30/cell[0]))} {int(round(30/cell[1]))} {int(round(30/cell[2]))}" + "\n")
+    else:
+        atoms.write(args.o)
+
+
+if __name__ == '__main__':
+    main()
+

mdkits/cli/build_interface.py

@@ -0,0 +1,86 @@
+from ase.io import write, read
+import argparse
+from ase.geometry import cell_to_cellpar, cellpar_to_cell
+import math
+
+
+def parse_argument():
+    parser = argparse.ArgumentParser(description='combain solbox and surface to a interface')
+    parser.add_argument('--surface', type=str, help='surface path')
+    parser.add_argument('--sol', type=str, help='solbox path')
+    parser.add_argument('--move', type=float, help='move at z, default = 0', default=0)
+    parser.add_argument('--interval', type=float, help='interval between surface to sol, default is 2', default=2)
+    parser.add_argument('--vacuum', type=float, help='vacuum of structure, default is 0', default=0)
+    parser.add_argument('--symmetry', help='two side interface, default is false', action='store_true')
+    parser.add_argument('--ne', help='two side interface, one side is Ne atom, default is false', action='store_true')
+    parser.add_argument('-o', type=str, help='output file name', default='interface')
+
+    return parser.parse_args()
+
+
+def chformat(input_filename, output_filename, format):
+    atoms = read(input_filename)
+    write(output_filename, atoms, format=format)
+
+
+def main():
+    args = parse_argument()
+    surface = read(args.surface)
+    surface.set_pbc(True)
+    surface.center()
+    sy_surface = surface.copy()
+    cell = surface.get_cell()
+    [lenx, leny, lenz, anga, angb, angc] = cell_to_cellpar(cell)
+
+    solbox = read(args.sol)
+    solbox_cell = solbox.cell.cellpar()
+    solbox.set_pbc(True)
+    solbox.center()
+    tmp_list = solbox.get_positions()
+    tmp_list[:, 2] += lenz + args.interval
+    solbox.set_positions(tmp_list)
+
+    surface.extend(solbox)
+    surface.cell = [lenx, leny, (lenz + args.interval + solbox_cell[2] + args.interval), anga, angb, angc]
+    surface.center()
+
+    if args.symmetry:
+        tmp_list = surface.get_positions()
+        tmp_list[:, 2] += -(lenz + args.interval + solbox_cell[2] + args.interval)
+        surface.set_positions(tmp_list)
+        surface.extend(sy_surface)
+        surface.cell = [lenx, leny, (lenz + args.interval + solbox_cell[2] + args.interval + lenz + args.vacuum), anga, angb, angc]
+        surface.center()
+    elif args.ne:
+        from ase import Atoms
+        ne_interval = 4 # adjust water density
+        ne_cell = [lenx, leny, 2, 90, 90, 90]
+        ne_position = []
+        ne_symbols = []
+        ne_site = [int(lenx//ne_interval), int(leny//ne_interval)]
+        for i in range(ne_site[0]):
+            for j in range(ne_site[1]):
+                ne_position.append((i*ne_interval, j*ne_interval, 0))
+                ne_symbols.append('Ne')
+        ne_atoms = Atoms(symbols=ne_symbols, positions=ne_position, cell=ne_cell)
+        ne_atoms.center()
+        tmp_list = surface.get_positions()
+        tmp_list[:, 2] += -(lenz + args.interval + solbox_cell[2])
+        surface.set_positions(tmp_list)
+        surface.extend(ne_atoms)
+        surface.cell = [lenx, leny, (lenz + args.interval + solbox_cell[2] + args.interval + 2 + args.vacuum), anga, angb, angc]
+        surface.center()
+    else:
+        surface.set_pbc(True)
+        tmp_list = surface.get_positions()
+        #tmp_list[:, 2] -= lenz
+        tmp_list[:, 2] -= args.move
+        surface.set_positions(tmp_list)
+
+
+    write(args.o + '.xyz', surface, format='extxyz')
+    write(args.o + '.cif', surface, format='cif')
+    #chformat(args.o + '.cif', args.o + '.xyz', format='xyz')
+
+if __name__ == '__main__':
+    main()

mdkits/cli/build_surface.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+
+import argparse, sys
+from ase import build
+from ase.geometry import cell_to_cellpar
+from ase.io import write
+import numpy as np
+
+
+
+def parse_size(s):
+    if s == None:
+        return None
+    return [int(x) for x in s.replace(',', ' ').split()]
+
+
+def surface_check(obj, surface_type):
+    if hasattr(obj, surface_type):
+        return getattr(obj, surface_type)
+    else:
+        print(f'dont have face named {surface_type}')
+        exit()
+
+
+def parse_argument():
+    parser = argparse.ArgumentParser(description='build a surface structure of matel')
+    parser.add_argument('symbol', type=str, help='designate the symbol of matel')
+    parser.add_argument('--face', type=str, help='designate the face of surface')
+    parser.add_argument('-a', type=float, help='designate a lattice constant', default=None)
+    parser.add_argument('--primitive', help='designate a lattice constant of real', action='store_true')
+    parser.add_argument('--size', type=parse_size, help='designate surface size(a,b,c)')
+    parser.add_argument('--vacuum', type=float, help='designate vacuum of surface, default is None', default=0.0)
+    parser.add_argument('--adsorbate', type=str, help='add adsorbate on surface', default=None)
+    parser.add_argument('--position', type=str, help='position of adsorbate', default='ontop')
+    parser.add_argument('--offset', type=str, help='offset')
+    parser.add_argument('--height', type=float, help='position of adsorbate', default=1)
+    parser.add_argument('-o', type=str, help='output structure name', default='surface.xyz')
+    parser.add_argument('-c', help='output coord.xyz and cell.inc', action='store_true')
+    parser.add_argument('-k', type=parse_size, help='output kpoint.inc(a,b,c)', default=None)
+    parser.add_argument('--autok',  help='output kpoint.inc', action='store_true')
+    parser.add_argument('--orth',  help='orth cell', action='store_true')
+    parser.add_argument('--coverh',  type=int, help='cover H atom', default=0)
+
+    return parser.parse_args()
+
+
+def main():
+    args = parse_argument()
+    if args.primitive:
+        a = args.a * 0.7071 * 2
+    else:
+        a = args.a
+
+    vacuum = args.vacuum / 2
+
+    build_surface = surface_check(build, args.face)
+
+    if args.orth:
+        atoms = build_surface(args.symbol, args.size, a=a, vacuum=vacuum, orthogonal=args.orth)
+    else:
+        atoms = build_surface(args.symbol, args.size, a=a, vacuum=vacuum)
+
+    # add adsorbate
+    if args.adsorbate != None:
+        ## add H2Oa and OH
+        if args.adsorbate in ['H2Oa', 'OH']:
+            if args.adsorbate in ['OH']:
+                h2o = build.molecule(args.adsorbate)
+                h2o.rotate(90, 'y')
+                build.add_adsorbate(atoms, h2o, args.height, position=args.position, offset=args.offset)
+            else:
+                h2o = build.molecule('H2O')
+                h2o.rotate(90, 'y')
+                build.add_adsorbate(atoms, h2o, args.height, position=args.position, offset=args.offset)
+        ## add H2Ob
+        elif args.adsorbate in  ['H2Ob']:
+            h2o = build.molecule('H2O')
+            h2o.rotate(90, 'z')
+            h2o.rotate(45, 'y')
+            build.add_adsorbate(atoms, h2o, args.height, position=args.position, offset=args.offset)
+        ## add default something
+        else:
+            build.add_adsorbate(atoms, args.adsorbate, args.height, position=args.position, offset=args.offset)
+
+    # add h with coverage
+    if args.coverh != 0:
+        ## get atom position at surface
+        surface_positions_dict = {}
+        for atom in atoms:
+            if atom.tag == 1:
+                surface_positions_dict[atom.index] = atom.position
+        ## error checking
+        if site_number := len(surface_positions_dict) < args.coverh:
+            print(f"coverh is too big, please less then {site_number}")
+            sys.exit()
+        ## get random site
+        random_site_list = np.random.choice(list(surface_positions_dict.keys()), args.coverh, replace=False)
+        random_site_list = np.unique(random_site_list)
+        ## add H atom at hollow site
+        for site in random_site_list:
+            site_position = surface_positions_dict[site][0:2]
+            build.add_adsorbate(atoms, 'H', 2, position=site_position, offset=(0.3, 0.3))
+
+    # control output format
+    ## output with coord.xyz(cp2k format)
+    if args.c:
+        atoms.write('coord.xyz', format='xyz')
+        with open('coord.xyz', 'r') as f:
+            lines = f.readlines()[2:]
+        with open('coord.xyz', 'w') as f:
+            f.writelines(lines)
+        with open('cell.inc', 'w') as f:
+            cell = list(cell_to_cellpar(atoms.cell))
+            f.write('ABC [angstrom] ' + str(cell[0]) + ' ' + str(cell[1]) + ' ' + str(cell[2]) + ' ' + '\n')
+            f.write('ALPHA_BETA_GAMMA ' + str(cell[3]) + ' ' + str(cell[4]) + ' ' + str(cell[5]) + '\n')
+            ## output kpoint file with specific number
+            if args.k != None:
+                if True: #judge M or G
+                    with open('kpoint.inc', 'w') as f:
+                        f.write(f"SCHEME MONKHORST-PACK {args.k[0]} {args.k[1]} {args.k[2]}" + "\n")
+            ## output kpoint file autoly
+            if args.autok:
+                if True: # judge matel or semi or else
+                    if True: # judge M or G
+                        with open('kpoint.inc', 'w') as f:
+                            f.write(f"SCHEME MONKHORST-PACK {int(round(30/cell[0]))} {int(round(30/cell[1]))} {int(round(30/cell[2]))}" + "\n")
+    ## output default format or specific xyz file
+    else:
+        atoms.write(args.o)
+
+
+if __name__ == '__main__':
+    main()
+

mdkits/cli/cmdline.py

@@ -0,0 +1,41 @@
+"""Command line"""
+import click
+from click import Context
+
+from mdtool import __version__
+from mdtool.config import settings
+from mdtool.log import init_log
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+@click.option(
+    '-V',
+    '--version',
+    is_flag=True,
+    help='Show version and exit.'
+)  # If it's true, it will override `settings.VERBOSE`
+@click.option('-v', '--verbose', is_flag=True, help='Show more info.')
+@click.option(
+    '--debug',
+    is_flag=True,
+    help='Enable debug.'
+)  # If it's true, it will override `settings.DEBUG`
+def main(ctx: Context, version: str, verbose: bool, debug: bool):
+    """Main commands"""
+    if version:
+        click.echo(__version__)
+    elif ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+    else:
+        if verbose:
+            settings.set('VERBOSE', True)
+        if debug:
+            settings.set('DEBUG', True)
+
+
+@main.command()
+def run():
+    """Run command"""
+    init_log()
+    click.echo('run......')