mgtoolbox-kernel 0.1.0__py3-none-any.whl

mgtoolbox_kernel/kernel/site.py

@@ -0,0 +1,219 @@
+from typing import Dict, Union, List
+import math
+import numpy as np
+from .mgclass import MGobject
+from .atom import Atom
+
+
+class Site(MGobject):
+    """
+    Site 站点类
+    用于描述材料结构中的站点
+    Parameters
+    ----------
+    object : [type]
+        [description]
+    """
+
+    def __init__(
+        self,
+        coord: np.ndarray,
+        occupier: Dict[Atom, float] = None,
+        label: str = "",
+        site_type: str = "",
+        attributes: Dict = None,
+    ):
+        """
+        __init__ 站点类初始化
+        站点类初始化函数
+        Parameters
+        ----------
+        coords : np.ndarray
+            站点位置分数坐标
+        occupier : Dict, optional
+            站点包含的原子及占据率信息, by default None
+        label: str, optional
+            站点标签信息
+        label: str, optional
+            站点类型信息
+        attributes : Dict, optional
+            站点类的其它可自定义属性, by default None。 如{"radius":10}
+        """
+        if attributes is None:
+            super().__init__(attributes={})
+        else:
+            super().__init__(attributes)
+        self.label: str = label
+        self.type: str = site_type
+        self.coord: np.ndarray = np.array(coord)
+        if occupier is None:
+            self.occupier: Dict[Atom, float] = {}
+        else:
+            self.occupier: Dict[Atom, float] = occupier
+
+
+    def __eq__(self, other: "Site") -> bool:
+        # 判断是否同一站点仅比较站点坐标
+        return np.all(np.isclose(self.coord, other.coord, rtol=0.001))
+
+    def __str__(self) -> str:
+        site_string = (
+            "\n{"
+            + "label:"
+            + self.label
+            + ", type:"
+            + str(self.type)
+            + ", coord:"
+            + str(self.coord)
+            + ", occupier:"
+            + str(self.occupier)
+            + "}"
+        )
+        return site_string
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    @property
+    def atoms(self) -> list:
+        return list(self.occupier.keys())
+
+    @property
+    def atom_symbols(self) -> list:
+        return [atom.symbol for atom in self.occupier.keys()]
+
+    @property
+    def atom_valences(self) -> list:
+        return [atom.valence_state for atom in self.occupier.keys()]
+
+    @property
+    def atom_occupancies(self) -> list:
+        return list(self.occupier.values())
+
+    @property
+    def x(self) -> float:
+        return self.coord[0]
+
+    @property
+    def y(self) -> float:
+        return self.coord[1]
+
+    @property
+    def z(self) -> float:
+        return self.coord[2]
+
+    @x.setter
+    def x(self, x: float):
+        self.coord[0] = x
+
+    @y.setter
+    def y(self, y: float):
+        self.coord[1] = y
+
+    @z.setter
+    def z(self, z: float):
+        self.coord[2] = z
+
+    @property
+    def is_ordered(self):
+        """站点是否有序(满足站点上只包含一个原子且占据率为1.0)
+
+        Returns
+        -------
+        bool
+            是否有序
+        """
+        return len(self.atoms) == 1 and math.isclose(self.atom_occupancies[0], 1.0)
+
+    def get_element_occupy(self, symbol: str):
+        """_summary_
+
+        Parameters
+        ----------
+        symbol : str
+            _description_
+
+        Returns
+        -------
+        _type_
+            _description_
+        """        
+        for atom, occupy in self.occupier.items():
+            if atom.symbol == symbol:
+                return occupy
+
+    def assign_occupier(self, atom: Atom, occupy: float = 1.0):
+        """
+        assign_occupier 设置站点包含的原子信息
+
+        设置站点包含的原子，如原子类型，占有率。
+
+        Parameters
+        ----------
+        atom : Atom
+            [添加的原子类型]
+        occupy : float, optional
+            [占据率], by default 1.0
+        """
+        if atom in self.atoms:  # 若站点上已存在该原子类型，则将占据率求和
+            self.occupier[atom] += occupy
+        else:
+            self.occupier[atom] = occupy
+
+    def assign_occupier_by_dict(self, occupiper_dict):
+        """_summary_
+
+        Parameters
+        ----------
+        occupiper_dict : _type_
+            _description_
+        """        
+        for k, v in occupiper_dict.items():
+            self.assign_occupier(k, v)
+
+    def assign_occupier_by_symbol(
+        self, symbol: str = "", valence_state: float = 0.0, occupy: float = 1.0
+    ):
+        """_summary_
+
+        Parameters
+        ----------
+        symbol : str, optional
+            _description_, by default ""
+        valence_state : float, optional
+            _description_, by default 0.0
+        occupy : float, optional
+            _description_, by default 1.0
+
+        Raises
+        ------
+        ValueError
+            _description_
+        """        
+        if len(symbol) > 0:
+            atom = Atom(symbol, valence_state)
+            if atom not in self.atoms:
+                self.assign_occupier(atom, occupy)
+        else:
+            raise ValueError("Symbol cannot be empty!!!")
+
+    def get_occupy_sum(self):
+        """_summary_
+
+        Returns
+        -------
+        _type_
+            _description_
+
+        Raises
+        ------
+        ValueError
+            _description_
+        """        
+        occu_sum = 0
+        for occupy in self.occupier.values():
+            occu_sum = occu_sum + occupy
+        if occu_sum > 1.0:
+            raise ValueError("occupy > 1.0")
+        return occu_sum
+

mgtoolbox_kernel/kernel/structure.py

@@ -0,0 +1,194 @@
+# -*- encoding: utf-8 -*-
+"""
+    @File    :   structure.py
+    @Time    :   2021/04/30 15:49:14
+    @Author  :   何冰 
+    @Email   :   shhebing@qq.com
+    @WebSite :   https://mgtoolbox.cn
+    @Desc    :   材料结构相关类。
+"""
+import re
+from typing import Dict, List, Union
+from pathlib import Path
+
+import numpy as np
+import scipy.spatial
+from mgtoolbox_kernel.io import read_structure_file, read_structure_data
+from .mgclass import MGobject
+from .atom import Atom
+from .cell import Cell
+from .site import Site
+
+
+class Structure(MGobject):
+    def __init__(self, sites: List[Site], cell: Cell, attributes=None):
+        if attributes is None:
+            attributes = {}
+        super().__init__(attributes)
+        self.sites: List[Site] = sites
+        self.cell: Cell = cell
+
+    def __repr__(self) -> str:
+        sstring = str({"cell": self.cell, "sites": self.sites})
+        return sstring
+
+    def add_site(self, site: Site):
+        self.sites.append(site)
+
+    def add_sites(self, sites: List[Site]):
+        self.sites += sites
+
+    def remove_sites(self, sites: List[Site]):
+        for site in sites:
+            self.sites.remove(site)
+
+    def set_cell(self, cell: Cell):
+        self.cell = cell
+
+    @property
+    def is_ordered(self):
+        """是否为有序结构
+
+        Returns
+        -------
+        bool
+            是否有序
+        """
+        return all((site.is_ordered for site in self.sites))
+
+    @staticmethod
+    def from_file(filename: Union[str, Path]) -> Union["Structure", List["Structure"]]:
+        structs_mode = read_structure_file(filename)
+        structs = []
+        for struct_mode in structs_mode:
+            struct = Structure.from_struct_model(struct_mode)
+            structs.append(struct)
+        if len(structs) == 1:
+            return structs[0]
+        else:
+            return structs
+
+    @staticmethod
+    def from_data(file_data: str):
+        # 默认cif格式文件数据
+        structs_mode = read_structure_data(file_data)
+        structs = []
+        for struct_mode in structs_mode:
+            struct = Structure.from_struct_model(struct_mode)
+            structs.append(struct)
+        if len(structs) == 1:
+            return structs[0]
+        else:
+            return structs
+
+    @staticmethod
+    def merge_eq_coords(coords):
+        Structure.adjust_coords(coords)
+        dm = scipy.spatial.distance_matrix(coords, coords)
+        type_list = list(range(dm.shape[0]))
+        for row in range(dm.shape[0]):
+            for col in range(row + 1, dm.shape[1]):
+                if dm[row][col] < 0.003:
+                    type_list[col] = type_list[row]
+        unique_ids = set(type_list)
+        ucoords = coords[list(unique_ids)]
+        return ucoords
+
+    @staticmethod
+    def adjust_coords(coords):
+        """调整分数坐标值
+        使得分数坐标值在0.999-1.001范围的坐标更改为0.0
+        Parameters
+        ----------
+        coords : _type_
+            _description_
+        """
+        abs_value = np.abs(coords - 1.0)
+        coords[abs_value < 0.001] = 0.0
+
+    @staticmethod
+    def from_struct_model(struct_mode: Dict):
+        lattice_paramteters = struct_mode["lattice_parameters"]
+        cell = Cell(
+            lattice_paramteters[0],
+            lattice_paramteters[1],
+            lattice_paramteters[2],
+            lattice_paramteters[3],
+            lattice_paramteters[4],
+            lattice_paramteters[5],
+        )
+        attributes = struct_mode['attributes']
+        sites = []
+        for struct_site in struct_mode["sites"]:
+            coords = np.mod(
+                np.dot(struct_mode["symm_ops"][0], struct_site["coord"])
+                + struct_mode["symm_ops"][1],
+                1.0,
+            )
+            # 合并等价位点中坐标相同位点
+            # Merge the points with the same coordinates in the equivalent points
+            ucoords = Structure.merge_eq_coords(coords)
+            for i, coord in enumerate(ucoords):
+                occupier = {}
+                for symbol, occupy in struct_site["occupancy"].items():
+                    if occupy < 0.0:
+                        raise ValueError("Structure file site occupy value error")
+                    sym = re.findall(r"[A-Z][a-z]?", symbol)
+                    if struct_mode["oxidation_state"]:
+                        atom = Atom(sym[0], struct_mode["oxidation_state"][symbol])
+                        occupier[atom] = occupy
+                    else:
+                        # -16 表示该离子化合价无法确定。
+                        atom = Atom(sym[0], -16)
+                        occupier[atom] = occupy
+                site = Site(coord, occupier)
+                site.label = struct_site["label"] + "_" + str(i)
+                site.type = struct_site["site_type"]
+                sites.append(site)
+        unique_sites = Structure.remove_duplicates_sites(sites)
+        return Structure(unique_sites, cell, attributes)
+
+    @staticmethod
+    def remove_duplicates_sites(sites: List[Site]):
+        result = []
+        for item in sites:
+            if item not in result:
+                result.append(item)
+            else:
+                result[result.index(item)].assign_occupier_by_dict(item.occupier)
+        return result
+
+    def write_to_cif(self, filename: str):
+        with Path(filename).open("+w") as f:
+            f.write(f"data_{Path(filename).stem}\n")
+
+            f.write("_cell_length_a       {}\n".format(self.cell.abc[0]))
+            f.write("_cell_length_b       {}\n".format(self.cell.abc[1]))
+            f.write("_cell_length_c       {}\n".format(self.cell.abc[2]))
+
+            f.write("_cell_angle_alpha    {}\n".format(self.cell.angles[0]))
+            f.write("_cell_angle_beta     {}\n".format(self.cell.angles[1]))
+            f.write("_cell_angle_gamma    {}\n".format(self.cell.angles[2]))
+
+            f.write("_symmetry_space_group_name_H-M    'P 1'\n")
+            f.write("_symmetry_Int_Tables_number        1\n")
+
+            f.write("loop_\n")
+            f.write("_symmetry_equiv_pos_site_id\n")
+            f.write("_symmetry_equiv_pos_as_xyz\n")
+            f.write("1        'x, y, z'\n")
+
+            f.write("loop_\n")
+            f.write("_atom_site_label\n")
+            f.write("_atom_site_type_symbol\n")
+            f.write("_atom_site_fract_x\n")
+            f.write("_atom_site_fract_y\n")
+            f.write("_atom_site_fract_z\n")
+            f.write("_atom_site_occupancy\n")
+            for site in self.sites:
+                for occupier, occupy in site.occupier.items():
+                    f.write(
+                        f"{site.label} {occupier.symbol} {site.x} {site.y} {site.z} {occupy}\n"
+                    )
+
+            f.write(f"#End of data_{Path(filename).stem}")

mgtoolbox_kernel/util/base.py

@@ -0,0 +1,141 @@
+# -*- encoding: utf-8 -*-
+import math
+import re
+import numpy as np
+import periodictable as pt
+from typing import Tuple
+
+def parse_sitesym(symlist, sep=','):
+    """Parses a sequence of site symmetries in the form used by
+    International Tables and returns corresponding rotation and
+    translation arrays.
+
+    Example:
+
+    >>> symlist = [
+    ...     'x,y,z',
+    ...     '-y+1/2,x+1/2,z',
+    ...     '-y,-x,-z',
+    ... ]
+    >>> rot, trans = parse_sitesym(symlist)
+    >>> rot
+    array([[[ 1,  0,  0],
+            [ 0,  1,  0],
+            [ 0,  0,  1]],
+    <BLANKLINE>
+        [[ 0, -1,  0],
+            [ 1,  0,  0],
+            [ 0,  0,  1]],
+    <BLANKLINE>
+        [[ 0, -1,  0],
+            [-1,  0,  0],
+            [ 0,  0, -1]]])
+    >>> trans
+    array([[ 0. ,  0. ,  0. ],
+        [ 0.5,  0.5,  0. ],
+        [ 0. ,  0. ,  0. ]])
+    """
+    nsym = len(symlist)
+    rot = np.zeros((nsym, 3, 3), dtype='int')
+    trans = np.zeros((nsym, 3))
+    
+    trans_pattern = r"([-+]?\d*\.\d*|[-+]?\d+)"
+    re_trans = re.compile(trans_pattern)
+    rot_pattern=r"[+-]?[xyz]"
+    re_rot = re.compile(rot_pattern)
+    
+    for i, sym in enumerate(symlist):
+        for j, s in enumerate(sym.split(sep)):
+            s = s.lower().strip()
+            #得到旋转字符
+            strs_matches = re_rot.findall(s)
+            #得到偏移数字
+            numbers_matches = re_trans.findall(s)
+            if len(numbers_matches)==2:
+                trans[i, j] = float(numbers_matches[0]) / float(numbers_matches[1])
+            elif len(numbers_matches)==1:
+                trans[i, j] = float(numbers_matches[0])
+            elif len(numbers_matches)==0:
+                trans[i, j] = 0.0
+            else:
+                raise Exception("Read symmetry trans string  error")
+            if len(strs_matches)<1:
+                raise Exception(
+                        'Error parsing %r. Invalid site symmetry: %s' %
+                        (s, sym))
+            for sxyz in strs_matches:
+                sign = 1.0
+                if len(sxyz)==2:
+                    if sxyz[0] in '+-':
+                        if sxyz[0] == '-':
+                            sign = -1.0
+                    xyz=sxyz[1]
+                elif len(sxyz)==1:
+                    xyz=sxyz[0]
+                    sign = 1.0
+                else:
+                    raise Exception(
+                        'Error parsing %r. Invalid site symmetry: %s' %
+                        (s, sym))
+                if xyz in 'xyz':
+                    k = ord(xyz) - ord('x')
+                    rot[i, j, k] = sign
+    return rot, trans
+def get_lattice_vectors(a, b, c, alpha, beta, gamma) -> np.ndarray:
+    """Get the cell vectors matrix(fix a-axis) from the cell parameters
+    Parameters
+    ----------
+    a : float
+        晶格参数:a
+    b : float
+        晶格参数:b
+    c : float
+        晶格参数:c
+    alpha : float
+        晶格参数:alpha
+    beta : float
+        晶格参数:beta
+    gamma : float
+        晶格参数:gamma
+
+    Returns
+    -------
+    numpy.ndarray
+        晶格矢量矩阵
+    """
+    angles_r = np.radians([alpha, beta, gamma])
+    cos_alpha, cos_beta, cos_gamma = np.cos(angles_r)
+    sin_alpha, sin_beta, sin_gamma = np.sin(angles_r)
+
+    # fix a-axis
+    vector_a = a * np.array([1, 0, 0])
+    vector_b = b * np.array([cos_gamma, sin_gamma, 0])
+    cx = cos_beta
+    cy = (cos_alpha - cos_beta * cos_gamma) / sin_gamma
+    cz_sqr = 1. - cx * cx - cy * cy
+    cz = np.sqrt(cz_sqr)
+    vector_c = c * np.array([cx, cy, cz])
+    return np.array([vector_a, vector_b, vector_c])
+
+
+def get_lattice_parameters(lattice_vectors: np.ndarray) -> Tuple:
+    """get lattice parameters from the lattice vectors matrix
+
+    Parameters
+    ----------
+    lattice_vectors : np.ndarray
+        晶格矢量
+
+    Returns
+    -------
+    元组类型
+        返回晶格常数:a,b,c,alpha,beta,gamma
+    """
+    abc = np.linalg.norm(lattice_vectors, axis=1)
+    arc_alpha = np.arccos(np.dot(lattice_vectors[1], lattice_vectors[2]) / (abc[1] * abc[2]))
+    arc_beta = np.arccos(np.dot(lattice_vectors[0], lattice_vectors[2]) / (abc[0] * abc[2]))
+    arc_gamma = np.arccos(np.dot(lattice_vectors[1], lattice_vectors[0]) / (abc[1] * abc[0]))
+    arc_values = np.array([arc_alpha, arc_beta, arc_gamma])
+    alpha, beta, gamma = arc_values * 180 / math.pi
+    return tuple([abc[0], abc[1], abc[2], alpha, beta, gamma])
+

mgtoolbox_kernel-0.1.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: mgtoolbox-kernel
+Version: 0.1.0
+Home-page: https://gitee.com/shuhebing/mgtoolbox_kernel
+Author: Bing He
+Author-email: shhebing@qq.com
+Requires-Python: >=3.7,<=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pycifrw
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: pandas
+Requires-Dist: spglib
+
+# MGToolBox Materials Genome Toolbox

mgtoolbox_kernel-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+mgtoolbox_kernel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mgtoolbox_kernel/io/__init__.py,sha256=c7NUxkUR7IzAvZKHEqa_81DaH-kZACXY748xWrXd1aA,868
+mgtoolbox_kernel/io/cif.py,sha256=vTqlmr7ONMPrhm3ytooqMNcpVm2_AA6o8bt3IAubZD4,6763
+mgtoolbox_kernel/io/vasp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mgtoolbox_kernel/io/vasp/poscar.py,sha256=ISmldKyDYVK50IySxvOByEqGHnP-bbjuQkD39JVNjqI,4559
+mgtoolbox_kernel/kernel/__init__.py,sha256=yzBH8rszXZTN8zjbpCG1iraBEsv7uMk3GlUEWoxOytM,32
+mgtoolbox_kernel/kernel/atom.py,sha256=mGV-IC7-WjuEe7ItEh3pHx0wi87uAtWRyOFhgKTGG9s,1430
+mgtoolbox_kernel/kernel/cell.py,sha256=n0NzltcoQiEy3fuFMP0cLc1UwjnslTnuuVgFpa1AviY,15296
+mgtoolbox_kernel/kernel/mgclass.py,sha256=7g_IdostJg7MgQLq-9geIzYI9ccouSDB-vI77xttKXw,179
+mgtoolbox_kernel/kernel/potential.py,sha256=zM50evBCTiYhFEeOzKdPsyvmqpBeClOqra3s0fHnm20,3329
+mgtoolbox_kernel/kernel/site.py,sha256=93_f1-np31o46ouXha-3SpNknymY4ng8QXQoGwmrYDs,5529
+mgtoolbox_kernel/kernel/structure.py,sha256=GtLd38cSo1tWjcVk-bywPn0qC2umCXX2T1981cHJl2Y,6805
+mgtoolbox_kernel/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mgtoolbox_kernel/util/base.py,sha256=n1YnhXpqhB9eFyTyxMhRff8QU9egtQ3wMxMMyGNqw_0,4431
+mgtoolbox_kernel-0.1.0.dist-info/METADATA,sha256=uVzqlJiFhGAE45fC_mHqFC85lzeceQy6Iw2EpKgzz_E,394
+mgtoolbox_kernel-0.1.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+mgtoolbox_kernel-0.1.0.dist-info/top_level.txt,sha256=Od6EGc_Q9VZLH9OaHl7lcjfJBBZQ-rjhZujgsw8-tRs,17
+mgtoolbox_kernel-0.1.0.dist-info/RECORD,,

mgtoolbox_kernel-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.40.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mgtoolbox_kernel-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mgtoolbox_kernel