mdkits 0.1a1__py3-none-any.whl

mdkits/util/cp2k_input_parsing.py

@@ -0,0 +1,46 @@
+"""
+filename: cp2k_input_parsing.py
+function: prase cp2k file
+"""
+
+
+import sys
+
+
+def parse_cell(cp2k_input_file):
+    """
+    function: parse cell information from cp2k input file
+    parameter:
+        cp2k_input_file: filename of cp2k input
+    return:
+        cell: list with 6 number
+    """
+    try:
+        with open(cp2k_input_file, 'r') as f:
+            cell = []
+            for line in f:
+                if "ABC" in line:
+                    xyz = line.split()[-3:]
+                    cell.extend(xyz)
+                if "ALPHA_BETA_GAMMA" in line:
+                    abc = line.split()[-3:]
+                    cell.extend(abc)
+            if len(cell) == 3:
+                cell.extend([90.0, 90.0, 90.0])
+
+            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")
+            return cell
+    except FileNotFoundError:
+        print(f'cp2k input file name "{cp2k_input_file}" is not found, assign a cp2k input file or assign a "cell"')
+        sys.exit(1)
+
+
+#def get_cell(cp2k_input_file, cell=None):
+#    if cell is None:
+#        cell = parse_cell(cp2k_input_file)
+#    else:
+#        cell = cell
+#        if len(cell) == 3:
+#            cell.extend([90.0, 90.0, 90.0])
+#
+#    return cell

mdkits/util/encapsulated_ase.py

@@ -0,0 +1,134 @@
+"""
+filename: encapsulated_ase.py
+function: some encapsulated ase method
+"""
+
+
+from ase.io import iread, read
+import io
+import numpy as np
+from ase.io.cube import read_cube_data
+
+
+def wrap_to_cell(chunk, cell, name, big=False):
+    """
+    function: encapsulated ase.Atom.wrap method
+    parameter:
+        chunk: a list of frame of structure
+        cell: a list of cell parameter
+        name: path of temp file to write
+        big: make 3X3X1 supercell
+    return:
+        write into a temp file
+    """
+    # wrap a chunk of .xyz sturcture in a cell, and write wraped structure to file
+    if len(chunk) > 1:
+        atoms = iread(io.StringIO('\n'.join(chunk)), format='xyz')
+    else:
+        atoms = iread(chunk, format='xyz')
+    with open(name, 'w') as f:
+        f.write('')
+    for atom in atoms:
+        atom.set_cell(cell)
+        atom.set_pbc(True)
+        atom.wrap()
+        if big:
+            from ase.build import make_supercell
+            P = [ [3, 0, 0], [0, 3, 0], [0, 0, 1] ]
+            atom = make_supercell(atom, P)
+        atom.write(f'{name}', append='a', format='xyz')
+
+
+def rdf(chunk, cell, bin_size, name, parallel=True):
+    """
+    not used
+    """
+    from ase.geometry.analysis import Analysis
+    from math import ceil
+    n = ceil(cell[2] / bin_size)
+    if parallel:
+        atoms = iread(io.StringIO('\n'.join(chunk)), format='xyz')
+    else:
+        atoms = iread(chunk, format='xyz')
+    atom_list = []
+    for atom in atoms:
+        atom.set_cell(cell)
+        atom.set_pbc(True)
+        atom_list.append(atom)
+    print(len(atom_list))
+    ana = Analysis(atom_list)
+    rdf = ana.get_rdf(3.5, n, elements=['O'])
+    rdf_array = np.vstack(rdf)
+    rdf_array = np.mean(rdf_array, axis=0)
+    print(name)
+    np.save(name, rdf_array)
+    ana.clear_cache()
+
+
+def ave_potential(filepath):
+    """
+    function: average hartree file in z_coordinate
+    parameter:
+        filepath: hartree cube file path
+    return:
+        z_potential: a list of potential alone z axes
+        z_coordinates: a list of coordinates of z axes
+    """
+    # 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 atoms_read_with_cell(file_name, cell=None, coord_mode=False, default_cell=np.array([0., 0., 0., 90., 90., 90.])):
+    """
+    function: read structure file return a Atoms object with cell
+    parameter:
+        file_name: structure file name
+        cell: cell list
+        coord_mode: if file name is coord format
+        default_cell: default cell of Atoms object
+    return:
+        atoms: Atoms object with cell
+    """
+    import sys, os
+    from . import cp2k_input_parsing, structure_parsing
+
+    if coord_mode:
+        xyz = structure_parsing.coord_to_xyz(file_name)
+        atoms = read(io.StringIO('\n'.join(xyz)), format='xyz')
+    else:
+        atoms = jread(file_name)
+
+    if cell == None:
+        cp2k_cell_file_name = ( 'cell.inc', 'setup.inp', 'input.inp' )
+        existing_cell_file = [ file for file in cp2k_cell_file_name if os.path.isfile(file) ]
+        if existing_cell_file:
+            cell = cp2k_input_parsing.parse_cell(existing_cell_file[0])
+
+    if np.array_equal(atoms.cell.cellpar(), default_cell):
+        if cell != None:
+            atoms.set_cell(cell)
+            print('cell: \n' + ', '.join(map(str, atoms.cell.cellpar())))
+            return atoms
+        else:
+            print("no cell")
+            sys.exit(1)
+    print('cell: \n' + ', '.join(map(str, atoms.cell.cellpar())))
+    return atoms
+
+
+def jread(filepath):
+    from ase.io import read
+    suffix = filepath.split('.')[-1]
+    if suffix == 'data':
+        atom = read(filepath, format='lammps-data', atom_style='atomic')
+    else:
+        atom = read(filepath)
+
+    return atom

mdkits/util/encapsulated_mda.py

@@ -0,0 +1,59 @@
+import MDAnalysis
+import numpy as np
+from . import numpy_geo
+
+
+def update_water(self, o_group, h_group, distance_judg=1.2, angle_judg:tuple[float, float]=None, return_index=False):
+    """
+    input: o and h atom
+    output: o and two h in this frame
+    """
+    oh_pair = MDAnalysis.lib.distances.capped_distance(o_group.positions, h_group.positions, min_cutoff=0, max_cutoff=distance_judg, box=self.u.dimensions, return_distances=False)
+
+    oh_o = oh_pair[:, 0]
+    unique_oh_o = np.unique(oh_o)
+
+    group_oh_h = {}
+    for oh_o_index in unique_oh_o:
+        oh_h_index = oh_pair[oh_o == oh_o_index, 1]
+        group_oh_h[oh_o_index] = oh_h_index
+
+    oh1_list = []
+    oh2_list = []
+    o_list = []
+    for oh_o_index in unique_oh_o:
+        oh_h_index = group_oh_h[oh_o_index]
+        if angle_judg is not None and len(oh_h_index) >= 2:
+                for i in range(len(oh_h_index)):
+                    for j in range(i + 1, len(oh_h_index)):
+                            h1_index = oh_h_index[i]
+                            h2_index = oh_h_index[j]
+
+                            o_pos = o_group[oh_o_index].position
+                            h1_pos = h_group[h1_index].position
+                            h2_pos = h_group[h2_index].position
+
+                            oh1_vec = h1_pos - o_pos
+                            oh2_vec = h2_pos - o_pos
+
+                            angle_deg = numpy_geo.vector_vector_angle(oh1_vec, oh2_vec)
+
+                            if angle_judg[0] <= angle_deg <= angle_judg[1]:
+                                o_list.append(oh_o_index)
+                                oh1_list.append(h1_index)
+                                oh2_list.append(h2_index)
+        elif len(oh_h_index) == 2:
+            o_list.append(oh_o_index)
+            oh1_list.append(oh_h_index[0])
+            oh2_list.append(oh_h_index[1])
+    oh1_index = np.array(oh1_list)
+    oh2_index = np.array(oh2_list)
+    o_index = np.array(o_list)
+
+    if return_index:
+        return o_index, oh1_index, oh2_index
+    else:
+        o = o_group[o_index]
+        oh1 = h_group[oh1_index]
+        oh2 = h_group[oh2_index]
+        return o, oh1, oh2

mdkits/util/fig_operation.py

@@ -0,0 +1,28 @@
+import os
+import matplotlib.pyplot as plt
+
+
+def savefig(fig, name, fold=None):
+    current_path = os.getcwd()
+    if fold:
+        if not os.path.exists(fold):
+            os.mkdir(fold)
+        fig.savefig(f"{current_path}/{fold}/{name}.png", format='png')
+        vector_fig_dir = f'pdf'
+        if not os.path.exists(vector_fig_dir):
+            os.mkdir(vector_fig_dir)
+        vector_fig_dir = f'pdf/{fold}'
+        if not os.path.exists(vector_fig_dir):
+            os.mkdir(vector_fig_dir)
+        fig.savefig(f"{current_path}/{vector_fig_dir}/{name}.pdf", format='pdf', transparent=True)
+    else:
+        fig.savefig(f"{current_path}/{name}.png", format='png')
+        vector_fig_dir = f'pdf'
+        if not os.path.exists(vector_fig_dir):
+            os.mkdir(vector_fig_dir)
+        fig.savefig(f"{current_path}/{vector_fig_dir}/{name}.pdf", format='pdf', transparent=True)
+
+
+def scaled_figsize(scale_w=1.0, scale_h=1.0):
+    default_size = plt.rcParams["figure.figsize"]
+    return [default_size[0]*scale_w, default_size[1]*scale_h]

mdkits/util/numpy_geo.py

@@ -0,0 +1,118 @@
+"""
+filename: numpy_geo.py
+function: some vector calculation with numpy
+"""
+
+
+from numpy import array, dot, abs, cross
+from numpy.linalg import norm
+import numpy as np
+
+
+
+def point_plane_distance(plane):
+# distance of point with a plane(a list with [normal_voctor, a_point_in_plane])
+    def point(point):
+        return abs(dot(plane[0], point - plane[1])) / norm(plane[0])
+    return point
+
+
+def point_point_distance(point1, point2):
+# distance of point with a point
+    return norm(point1 - point2)
+
+
+def point(frame):
+# return a point of atom, from .xyz file
+    def point_index(index):
+        return array(frame[index].split()[1:]).astype(float)
+    return point_index
+
+def plane(frame, index1, index2, index3):
+# return a normal voctor of a plane with three point(index and group)
+    get_point = point(frame)
+    base1 = get_point(index1)
+    base2 = get_point(index2)
+    base3 = get_point(index3)
+    return [cross(base2 - base1, base3 - base1), base3]
+
+
+def vector_between_two_vector(vector1, vector2):
+    vector1_unit = vector1 / np.linalg.norm(vector1)
+    vector2_unit = vector2 / np.linalg.norm(vector2)
+    vector = vector1_unit + vector2_unit
+    return vector
+
+
+def vector_vector_angle(vector, surface_vector):
+    cos = np.dot(vector, surface_vector) / (np.linalg.norm(vector) * np.linalg.norm(surface_vector))
+    vector_vector_angle = np.arccos(np.clip(cos, -1.0, 1.0))
+    vector_vector_angle = np.degrees(vector_vector_angle)
+    return vector_vector_angle
+
+
+def cell_to_wrap_coefficients(cell, z=False):
+    angle = np.radians(180-cell[-1])
+    dangle = [np.cos(angle), np.sin(angle)]
+    xyz = cell[0:3]
+    if z:
+        coefficients = np.array([
+            [(kx * xyz[0] + ky * dangle[0] * xyz[1]), (ky * dangle[1] * xyz[1]), kz * xyz[2]]
+            for kx in range(-1, 2)
+            for ky in range(-1, 2)
+            for kz in range(-1, 2)
+        ])
+    else:
+        coefficients = np.array([
+            [(kx * xyz[0] + ky * dangle[0] * xyz[1]), (ky * dangle[1] * xyz[1]), 0]
+            for kx in range(-1, 2)
+            for ky in range(-1, 2)
+        ])
+
+    return coefficients
+
+
+def unwrap(atom1, atom2, coefficients, max=0, total=False):
+    init_dist = point_point_distance(atom1, atom2)
+    if total:
+        atoms = atom2 + coefficients
+        distance = np.linalg.norm(atoms-atom1, axis=1)
+
+        return distance, atoms
+    else:
+        if init_dist > max:
+            min_dist = float('inf')
+            closest_point = None
+            atoms = atom2 + coefficients
+            distance = np.linalg.norm(atoms-atom1, axis=1)
+            min_index = np.argmin(distance)
+            min_dist = distance[min_index]
+            closest_point = atoms[min_index]
+
+        else:
+            closest_point = atom2
+            min_dist = init_dist
+
+        return min_dist, closest_point
+
+
+def find_surface(surface_group:np.ndarray, layer_tolerance=1, surface_tolerance=5):
+    sort_group = surface_group.sort()
+    layer_mean = []
+    current_layer = [sort_group[0]]
+    for i in range(1, len(sort_group)):
+        if abs(sort_group[i] - sort_group[i-1]) < layer_tolerance:
+            current_layer.append(sort_group[i])
+        else:
+            layer_mean.append(np.mean(current_layer))
+            current_layer = [sort_group[i]]
+    
+    if len(current_layer) == 1:
+        return layer_mean[0]
+
+    diff = np.diff(layer_mean)
+    if np.any(diff > surface_tolerance):
+        index = np.argmax(diff > 5)
+        return (layer_mean[index], layer_mean[index + 1])
+    else:
+        return layer_mean[-1]

mdkits/util/os_operation.py

@@ -0,0 +1,35 @@
+import os, shutil, atexit
+
+
+def make_temp_dir(temp_dir, delete=False):
+    if os.path.exists(temp_dir):
+        shutil.rmtree(temp_dir)
+    os.mkdir(temp_dir)
+    if delete:
+        atexit.register(remove_temp_dir, temp_dir)
+
+
+def remove_temp_dir(temp_dir):
+    shutil.rmtree(temp_dir)
+
+
+def default_file_name(match, last=False):
+    import glob
+    file_list = glob.glob(match)
+    if file_list:
+        if last:
+            default_file_name = sort_word_and_number(file_list)[-1]
+        else:
+            default_file_name = list(file_list)
+    else:
+        default_file_name = None
+
+    return default_file_name
+
+
+def sort_word_and_number(unsort_list):
+    import re
+    fns = lambda s: sum(((s,int(n))for s,n in re.findall('(\D+)(\d+)','a%s0'%s)),())
+    sorted_list = sorted(unsort_list, key=fns)
+
+    return sorted_list

mdkits/util/structure_parsing.py

@@ -0,0 +1,147 @@
+"""
+filename: structure_parsing.py
+function: prase file with .xyz structue
+"""
+
+
+import numpy as np
+
+
+def xyz_to_chunks(filename, thread):
+    """
+    function: split .xyz file to chunks to parallel analysis
+    """
+    with open(filename, 'r') as f:
+        data = f.read()
+
+    #with open(filename, 'r') as f:
+    #    atom_number = int(f.readline().split()[0]) + 2
+
+    atom_number = int(data[:data.index('\n') + 1]) + 2
+    line_data = data.split('\n')
+    chunk_size = (len(line_data) / atom_number) // thread
+    chunks = [line_data[i:i+int(chunk_size*atom_number)] for i in range(0, len(line_data), int(chunk_size*atom_number))]
+    return chunks
+
+
+def xyz_to_groups(filename, cut=0):
+    """
+    function: split .xyz file to groups, every groups is one single frame
+    """
+    with open(filename, 'r') as f:
+        data = f.read()
+
+    # read number of atoms
+    end_index = data.index('\n') + 1
+    natom = int(data[:end_index]) + 2
+
+    # seqrate file with natom +2
+    lines = data.split('\n')
+    groups = [lines[i+cut:i+natom] for i in range(0, len(lines), natom)][:-1]
+    return groups
+
+
+def xyz_to_specified_list(filename, atom_range, cut=0):
+    """
+    function: split .xyz file to specified list, specified atoms position list
+    """
+    with open(filename, 'r') as f:
+        data = f.read()
+
+    # read number of atoms
+    end_index = data.index('\n') + 1
+    natom = int(data[:end_index]) + 2
+
+    # seqrate file with natom +2
+    lines = data.split('\n')
+    if len(atom_range) > 1:
+        groups = [lines[i+atom_range[0]:i+atom_range[1]] for i in range(0, len(lines), natom)][:-1]
+    else:
+        groups = [lines[i+atom_range[0]] for i in range(0, len(lines), natom)][:-1]
+    return groups
+
+
+def xyz_to_specified_array(filename, atom_range, cut=0):
+    """
+    function: split .xyz file to specified list, specified atoms position list
+    """
+    with open(filename, 'r') as f:
+        data = f.read()
+
+    # read number of atoms
+    end_index = data.index('\n') + 1
+    natom = int(data[:end_index]) + 2
+
+    # seqrate file with natom +2
+    lines = data.split('\n')
+    if len(atom_range) > 1:
+        groups = [lines[i+atom_range[0]:i+atom_range[1]] for i in range(0, len(lines), natom)][:-1]
+    else:
+        groups = [lines[i+atom_range[0]] for i in range(0, len(lines), natom)][:-1]
+    groups = [groups[i][j].split()[1:] for i in range(len(groups)) for j in range(len(groups[i]))]
+    return np.array(groups, dtype=np.float64)
+
+
+def xyz_to_npy(filename):
+    """
+    function: parse .xyz file to numpy array with float dtype, and cut first column of atom type
+    """
+    data = xyz_to_groups(filename, cut=2)
+    new_data = [[list(map(float, subsublist.split()[1:])) for subsublist in sublist] for sublist in data]
+    return np.array(new_data)
+
+
+def chunk_to_groups(data):
+    """
+    function: split chunk to single frames
+    """
+    natom = int(data[0]) + 2
+    groups = [data[i:i+natom] for i in range(0, len(data), natom)][:-1]
+    return groups
+
+
+def groups_to_xyz(filename, groups, cut=None):
+    """
+    function: write groups(some of frame) to .xyz file
+    """
+    with open(filename, 'w') as f:
+        for group in groups:
+           for i in group[cut:]:
+               f.write(i + '\n')
+
+
+def group_to_xyz(filename, group, cut=None):
+    """
+    function: write groups(some of frame) to .xyz file
+    """
+    with open(filename, 'w') as f:
+       for i in group[cut:]:
+           f.write(i + '\n')
+
+
+def coord_to_xyz(filename):
+    with open(filename, 'r') as f:
+        data = f.read()
+    data = data.split('\n')
+    data.insert(0, '')
+    data.insert(0, str(len(data)-2))
+    return data
+
+
+def atom_mass_parse(group):
+    import periodictable
+    atom_mass_dict = {}
+    names = atom_name_parse()
+    for name in names:
+        if hasattr(periodictable, name):
+            atom = getattr(periodictable, name)
+            atom_mass_dict[name] = atom.mass
+        else:
+            print(f'dont have face named {name}, use mass is 0')
+            atom_mass_dict[name] = 0
+    return atom_mass_dict
+
+
+def atom_name_parse(group):
+    names = {row.split()[0] for row in group[2:]}
+    return names

mdkits-0.1a1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 jxxcr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.