mdkits 0.1.29__py3-none-any.whl → 0.2.0__py3-none-any.whl

mdkits/cli/hartree_potential_ave.py

@@ -1,84 +0,0 @@
-#!/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

@@ -1,101 +0,0 @@
-#!/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/packmol_input.py

@@ -1,76 +0,0 @@
-import argparse
-
-
-def parse_cell(s):
-    return [float(x) for x in s.replace(',', ' ').split()]
-
-
-def parse_argument():
-    parser = argparse.ArgumentParser(description='generate packmol input file with give parameter')
-    parser.add_argument('--size', type=int, help='water size default is 30', default=30)
-    parser.add_argument('--cell', type=parse_cell, help='input box size(a,b,c)')
-    parser.add_argument('--addwat', type=int, help='add some additional water, default is 0', default=0)
-    parser.add_argument('--ioncon', type=float, help='concentration of sol box, default is 0.0', default=0.0)
-    parser.add_argument('--tolerance', type=float, help='tolerance of packmol, default is 2.5', default=2.5)
-    parser.add_argument('--watpath', type=str, help='water xyz file path', default='C:\\home\\.can\\temp\\packmol\\default\\water.xyz')
-    parser.add_argument('--ionpath', type=str, help='ion xyz file path')
-    parser.add_argument('-o', type=str, help='output file name, default is "input.pm"', default='input.pm')
-    parser.add_argument('--output', type=str, help='output file name of packmol, default is "solbox.xyz"', default='solbox.xyz')
-
-    return parser.parse_args()
-
-
-def get_water_number():
-    water_number = water_volume / water_size
-
-    return int(round(water_number, 0))
-
-
-def get_ion_number(concentration):
-    ion_number = ( (concentration * avogadro) / 1e+27 ) * water_volume
-
-    return int(round(ion_number, 0))
-
-
-def main():
-    global water_volume, water_size, avogadro
-    args = parse_argument()
-    water_volume = args.cell[0] * args.cell[1] * args.cell[2]
-    water_size = args.size
-    avogadro = 6.02214179e+23
-    water_number = get_water_number() + args.addwat
-    ion_number = get_ion_number(args.ioncon)
-
-    if ion_number == 0:
-        packmol_input_str = f"""
-        tolerance {args.tolerance}
-        filetype xyz
-        output {args.output}
-        pbc {args.cell[3]} {args.cell[4]} {args.cell[5]}
-        structure {args.watpath}
-          number {water_number}
-          inside box 2. 2. 2. {args.cell[0]-2} {args.cell[1]-2} {args.cell[2]-2}
-        end structure
-        """
-    else:
-        packmol_input_str = f"""
-        tolerance {args.tolerance}
-        filetype xyz
-        output {args.output}
-        pbc {args.cell[3]} {args.cell[4]} {args.cell[5]}
-        structure {args.watpath}
-          number {water_number}
-          inside box 2. 2. 2. {args.cell[0]-2} {args.cell[1]-2} {args.cell[2]-2}
-        end structure
-        structure {args.ionpath}
-          number {ion_number}
-          inside box 2. 2. 2. {args.cell[0]-2} {args.cell[1]-2} {args.cell[2]-2}
-        end structure
-        """
-
-    with open(args.o, 'w') as f:
-        f.write(packmol_input_str)
-
-
-if __name__ == '__main__':
-    main()