mdkits 0.1a1__py3-none-any.whl

mdkits/cli/data.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+
+import numpy as np
+import click
+import os, glob
+
+
+def match_file(patch):
+    pwd = os.getcwd()
+    match_file = glob.glob(os.path.join(pwd, patch))
+
+    return match_file
+
+
+@click.command(name='data')
+@click.argument('filename', nargs=-1, type=click.Path(exists=True))
+@click.option('--nor', help='normalized data', is_flag=True)
+@click.option('--gaus', type=int, help='gaussian filter 1d data', default=0)
+@click.option('--fold', help='fold and average', is_flag=True)
+@click.option('--err', help='error bar of data', is_flag=True)
+@click.option('--int_cn', type=float, nargs=2, help='integrate gofr data to coordination number', default=None)
+def main(filename, nor, gaus, fold, err, int_cn):
+    """
+    trade data file with different method
+    """
+
+    for data_file in filename:
+        data = np.loadtxt(data_file)
+        data_name = data_file.split(os.sep)[-1]
+        if len(data.shape) == 1:
+            data = np.hstack((np.arange(data.shape[0]).reshape(-1, 1), data.reshape(-1, 1)))
+        data_range = data.shape[1]
+        if nor:
+            nor_data = data.copy()
+            for i in range(1, data_range):
+                nor_data[:, i] = data[:, i] / np.max(data[:, i])
+            np.savetxt(f'./nor_{data_name}', nor_data, fmt='%.2e', delimiter='\t')
+        elif gaus > 0:
+            from scipy.ndimage import gaussian_filter1d
+            gaus_data = data.copy()
+            for i in range(1, data_range):
+                gaus_data[:, i] = gaussian_filter1d(data[:, i], gaus)
+            np.savetxt(f"./gaus_{data_name}", gaus_data, fmt='%.2e', delimiter='\t')
+        elif fold:
+            data_shape = data.shape
+            mid = int(data_shape[0] // 2)
+            left_data = data[:mid, 1:]
+            right_data = data[mid:, 1:][::-1]
+            if data_shape[0] % 2 != 0:
+                left_data = np.vstack((left_data, right_data[-1]))
+                mid += 1
+            fold_data = (left_data + right_data) / 2
+            fold_data = np.hstack((data[:mid, 0].reshape(-1, 1), fold_data))
+            np.savetxt(f"./fold_{data_name}", fold_data, fmt='%.2e', delimiter='\t')
+        elif err:
+            err_data = data.copy()
+            std_dev_list = []
+            for i in range(1, data_range):
+                split_array = np.array_split(err_data[:, i], 5)
+                averages = np.array([np.mean(part) for part in split_array])
+                std_dev = averages.std(axis=0)
+                std_dev_list.append(std_dev)
+            np.savetxt(f"./error_{data_name}", np.vstack(std_dev_list), fmt='%.5f', delimiter='\t')
+        elif int_cn is not None:
+            from scipy import integrate
+            rho = 32/(9.86**3)
+            x = data[:, 0]
+            mask = (x >= int_cn[0]) & (x <= int_cn[1])
+            filtered_x = x[mask]
+            filtered_y = data[:, 1][mask]
+            integrate_y = 4 * np.pi * rho * np.insert(integrate.cumulative_trapezoid(filtered_y*filtered_x**2, filtered_x), 0, 0)
+            np.savetxt(f"int_cn_{data_name}", np.hstack((filtered_x.reshape(-1, 1), integrate_y.reshape(-1, 1))), fmt='%.5f', delimiter='\t')
+
+
+
+        print(f"================ processing of {data_name} is done ===================")
+
+
+if __name__ == '__main__':
+    main()

mdkits/cli/density.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+
+import numpy as np
+import click
+import MDAnalysis
+from MDAnalysis import Universe
+from MDAnalysis.analysis.base import AnalysisBase
+from mdtool.util import cp2k_input_parsing, numpy_geo, encapsulated_mda
+import warnings
+warnings.filterwarnings("ignore")
+
+
+class Density_distribution(AnalysisBase):
+    def __init__(self, filename, cell, o, distance_judg, angle_judg, dt=0.001, bin_size=0.2, return_index=False):
+        u = Universe(filename)
+        u.trajectory.ts.dt = dt
+        u.dimensions = cell
+
+        self.u = u
+        self.o = o
+        self.distance_judg = distance_judg
+        self.angle_judg = angle_judg
+        self.atomgroup = u.select_atoms("all")
+        self.mid_z = u.dimensions[2]/2
+        self.bin_size = bin_size
+        self.frame_count = 0
+        self.return_index = return_index
+
+        super(Density_distribution, self).__init__(self.atomgroup.universe.trajectory, verbose=True)
+
+    def _prepare(self):
+        self.bin_num = int(self.u.dimensions[2] / self.bin_size) + 2
+        self.density_distribution = np.zeros(self.bin_num, dtype=np.float64)
+        if self.surface:
+            self.surface_pos = ()
+
+    def _append(self, z):
+        bins = np.floor(z / self.bin_size).astype(int) + 1
+        np.add.at(self.density_distribution, bins, 1)
+
+    def _single_frame(self):
+        if self.water:
+            o_group = self.atomgroup.select_atoms("name O")
+            h_group = self.atomgroup.select_atoms("name H")
+
+            o, oh1, oh2 = encapsulated_mda.update_water(self, o_group, h_group, distance_judg=self.distance_judg, angle_judg=self.angle_judg, return_index=self.return_index)
+
+            self._append(o.positions[:, 2])
+
+        else:
+            group = self.atomgroup.select_atoms(f"name {self.element}")
+            self._append(group.positions[:, 2])
+
+        self.
+        self.frame_count += 1
+
+    def _conclude(self):
+        if self.frame_count > 0:
+            V = self.u.dimensions[0] * self.u.dimensions[1] * self.bin_size
+
+            if self.water:
+                density_distribution = (self.density_distribution * (15.999+1.008*2) * 1.660539 / V) / self.frame_count
+            else:
+                density_distribution = (self.density_distribution * (10000/6.02) / V) / self.frame_count
+
+            bins_z = np.arange(len(self.density_distribution)) * self.bin_size
+
+            surface = self.find_surface(self.atomgroup.select_atoms("name Pt"))
+
+            lower_z, upper_z = surface
+            mask = (bins_z >= lower_z) & (bins_z <= upper_z)
+            filtered_bins_z = bins_z[mask] - lower_z
+            filtered_density_distribution = density_distribution[mask]
+            conbined_data = np.column_stack((filtered_bins_z, filtered_density_distribution))
+
+            np.savetxt(self.o, conbined_data, header="Z\tdensity", fmt='%.5f', delimiter='\t')
+
+@click.command(name='density')
+@click.argument('filename', type=click.Path(exists=True), default=os_operation.default_file_name('*-pos-1.xyz', last=True))
+@click.option('--cell', type=arg_type.Cell, help='set xyz file cell, --cell x,y,z,a,b,c')
+@click.option('--cell', type=arg_type.Cell, help='set cell from cp2k input file or a list of lattice: --cell x,y,z or x,y,z,a,b,c', default='input.inp', show_default=True)
+@click.option('-o', type=str, help='output file name', default='density.dat', show_default=True)
+def main(filename, cell, o):
+    density_dist = Density_distribution(filename, cell, o=o)
+    density_dist.run()
+
+
+if __name__ == '__main__':
+    main()

mdkits/cli/density2.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+
+import os, sys, argparse
+import numpy as np
+import math
+import multiprocessing
+from util import (
+    structure_parsing,
+    cp2k_input_parsing,
+    os_operation,
+    atom_count,
+    )
+
+
+def array_type(string):
+	number_list = string.split(',')
+	number_array = array(number_list, dtype=float)
+	return number_array
+
+
+def get_cell(cp2k_input_file, cell=None):
+    if cell is None:
+        cell = cp2k_input_parsing.parse_cell(cp2k_input_file)
+    else:
+        cell = cell
+        if len(cell) == 3:
+            cell.extend([90.0, 90.0, 90.0])
+
+    return cell
+
+
+def parse_cell(s):
+    if s == None:
+        return None
+    return [float(x) for x in s.replace(',', ' ').split()]
+
+
+# set argument
+def parse_argument():
+    parser = argparse.ArgumentParser(description='calculate water density destribution alone z axis')
+
+    parser.add_argument('input_file_name', type=str, nargs='?', help='input file name', default=os_operation.default_file_name('*-pos-1.xyz', last=True))
+    #parser.add_argument('-a', type=str, help='atom to statistic', default='O')
+    parser.add_argument('-o', type=str, help='output file name, default is "density.dat"', default='density.dat')
+    parser.add_argument('-r', type=array_type, help='bulk range')
+    parser.add_argument('--cp2k_input_file', type=str, help='input file name of cp2k, default is "input.inp"', default='input.inp')
+    parser.add_argument('--cell', type=parse_cell, help='set cell, a list of lattice, [x,y,z] or [x,y,z,a,b,c]')
+    parser.add_argument('--process', type=int, help='paralle process number default is 28', default=28)
+    parser.add_argument('--temp', help='keep temp file', action='store_false')
+
+    return parser.parse_args()
+
+
+def main():
+    args = parse_argument()
+    bin_size = 0.2
+    cell = get_cell(args.cp2k_input_file, args.cell)
+    temp_dir = f'{os.environ.get("TEMP_DIR")}/{os.getpid()}'
+    os_operation.make_temp_dir(temp_dir, delete=args.temp)
+    chunks = structure_parsing.xyz_to_chunks(args.input_file_name, args.process)
+    group = structure_parsing.chunk_to_groups(chunks[0])[0]
+    atom_names = structure_parsing.atom_name_parse(group)
+    for atom_name in atom_names:
+        for index, chunk in enumerate(chunks):
+            t = multiprocessing.Process(target=atom_count.atom_number_count, args=[chunk, bin_size, cell[2], atom_name, f'{temp_dir}/chunk_{index}.temp'])
+            t.start()
+
+        for t in multiprocessing.active_children():
+            t.join()
+
+        chunks_array_list = []
+        for i in range(len(chunks)):
+            chunk_array = np.load(f'{temp_dir}/chunk_{i}.temp.npy')
+            chunks_array_list.append(chunk_array)
+        chunks_array = np.vstack(chunks_array_list)
+        chunks_array = np.mean(chunks_array, axis=0)
+        if atom_name == 'O':
+            chunks_array = chunks_array * (15.999+1.0080*2) * 1.660539 / (cell[0]*cell[1]*bin_size)
+            with open(f'density_water.dat', 'w') as f:
+                for i in range(len(chunks_array)):
+                    f.write(str((i+1)*bin_size) + '\t' + str(chunks_array[i]) + '\n')
+
+        chunks_array = chunks_array * (10000/6.02) / (cell[0]*cell[1]*bin_size)
+        with open(f'density_{atom_name}.dat', 'w') as f:
+            for i in range(len(chunks_array)):
+                f.write(str((i+1)*bin_size) + '\t' + str(chunks_array[i]) + '\n')
+
+        print(f"density analysis of {atom_name} is done")
+
+if __name__ == '__main__':
+    main()

mdkits/cli/extract.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+
+# extract final structure form pos.xyz file
+
+import os
+import click
+from mdtool.util import os_operation, arg_type
+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:
+        for ts in u.trajectory:
+            if ts.frame in frames:
+                w.write(u)
+    if cut:
+        with open(o, 'r') as fi, open(o+'t', 'w') as fo:
+            for i, line in enumerate(fi):
+                if i >= cut:
+                    fo.write(line)
+        os.replace(o+'t', o)
+
+
+def write_to_xyz_s(u, frames, cut=None):
+    index = 0
+    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)
+                index += 1
+            if cut:
+                with open(o, 'r') as fi, open(o+'t', 'w') as fo:
+                    for i, line in enumerate(fi):
+                        if i >= cut:
+                            fo.write(line)
+                os.replace(o+'t', o)
+
+@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):
+    """
+    extract frames in trajectory file
+    """
+
+    u = Universe(input_file_name)
+    if len(r) == 1:
+        print(f"frame range slice is {r}")
+        group = u.trajectory[r]
+    else:
+        print(f"frame range slice is {slice(*r)}")
+        group = u.trajectory[slice(*r)]
+    click.echo(f"total frames is {len(u.trajectory)}")
+    frames = [ts.frame for ts in group]
+
+    if c:
+        cut = 2
+    else:
+        cut = None
+
+    if len(r) == 3 and r[-1] is not None:
+        if not os.path.exists('./coord'):
+            os.makedirs('./coord')
+        else:
+            import shutil
+            shutil.rmtree('./coord')
+            os.makedirs('./coord')
+        write_to_xyz_s(u, frames, cut=cut)
+        click.echo(os.path.abspath('./coord'))
+    else:
+        write_to_xyz(u, frames, o, cut=cut)
+        click.echo(os.path.abspath(o))
+
+
+if __name__ == '__main__':
+    main()

mdkits/cli/hartree_potential.py

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

mdkits/cli/hartree_potential_ave.py

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

mdkits/cli/hb.py

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

mdkits/cli/log.py

@@ -0,0 +1,64 @@
+"""Log"""
+import logging
+import os
+from logging.config import dictConfig
+
+from mdtool.config import settings
+
+os.makedirs(settings.LOGPATH, exist_ok=True)
+
+
+def verbose_formatter(verbose: int) -> str:
+    """formatter factory"""
+    if verbose is True:
+        return 'verbose'
+    return 'simple'
+
+
+def update_log_level(debug: bool, level: str) -> str:
+    """update log level"""
+    if debug is True:
+        level_num = logging.DEBUG
+    else:
+        level_num = logging.getLevelName(level)
+    settings.set('LOGLEVEL', logging.getLevelName(level_num))
+    return settings.LOGLEVEL
+
+
+def init_log() -> None:
+    """Init log config."""
+    log_level = update_log_level(settings.DEBUG, str(settings.LOGLEVEL).upper())
+
+    log_config = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {
+            'verbose': {
+                'format': '%(asctime)s %(levelname)s %(name)s %(process)d %(thread)d %(message)s',
+            },
+            'simple': {
+                'format': '%(asctime)s %(levelname)s %(name)s %(message)s',
+            },
+        },
+        "handlers": {
+            "console": {
+                "formatter": verbose_formatter(settings.VERBOSE),
+                'level': 'DEBUG',
+                "class": "logging.StreamHandler",
+            },
+            'file': {
+                'class': 'logging.handlers.RotatingFileHandler',
+                'level': 'DEBUG',
+                'formatter': verbose_formatter(settings.VERBOSE),
+                'filename': os.path.join(settings.LOGPATH, 'all.log'),
+                'maxBytes': 1024 * 1024 * 1024 * 200,  # 200M
+                'backupCount': '5',
+                'encoding': 'utf-8'
+            },
+        },
+        "loggers": {
+            '': {'level': log_level, 'handlers': ['console']},
+        }
+    }
+
+    dictConfig(log_config)