lammpsparser 0.0.1__py3-none-any.whl

lammpsparser/compatibility/file.py

@@ -0,0 +1,285 @@
+import os
+import shutil
+import subprocess
+from typing import Optional
+
+import pandas
+from ase.atoms import Atoms
+
+from lammpsparser.compatibility.calculate import (
+    calc_md,
+    calc_minimize,
+    calc_static,
+)
+from lammpsparser.compatibility.constraints import set_selective_dynamics
+from lammpsparser.output import parse_lammps_output
+from lammpsparser.potential import get_potential_by_name
+from lammpsparser.structure import write_lammps_datafile
+
+
+def lammps_file_interface_function(
+    working_directory: str,
+    structure: Atoms,
+    potential: str,
+    calc_mode: str = "static",
+    calc_kwargs: Optional[dict] = None,
+    units: str = "metal",
+    lmp_command: str = "mpiexec -n 1 --oversubscribe lmp_mpi -in lmp.in",
+    resource_path: Optional[str] = None,
+    input_control_file: Optional[dict] = None,
+    write_restart_file: bool = False,
+    read_restart_file: bool = False,
+    restart_file: str = "restart.out",
+):
+    """
+    A single function to execute a LAMMPS calculation based on the LAMMPS job implemented in pyiron
+
+    Examples:
+
+    >>> import os
+    >>> from ase.build import bulk
+    >>> from pyiron_atomistics.lammps.lammps import lammps_function
+    >>>
+    >>> shell_output, parsed_output, job_crashed = lammps_function(
+    ...     working_directory=os.path.abspath("lmp_working_directory"),
+    ...     structure=bulk("Al", cubic=True),
+    ...     potential='2009--Mendelev-M-I--Al-Mg--LAMMPS--ipr1',
+    ...     calc_mode="md",
+    ...     calc_kwargs={"temperature": 500.0, "pressure": 0.0, "n_ionic_steps": 1000, "n_print": 100},
+    ...     cutoff_radius=None,
+    ...     units="metal",
+    ...     bonds_kwargs={},
+    ...      enable_h5md=False,
+    ... )
+
+    Args:
+        working_directory (str): directory in which the LAMMPS calculation is executed
+        structure (Atoms): ase.atoms.Atoms - atomistic structure
+        potential (str): Name of the LAMMPS potential based on the NIST database and the OpenKIM database
+        calc_mode (str): select mode of calculation ["static", "md", "minimize", "vcsgc"]
+        calc_kwargs (dict): key-word arguments for the calculate function, the input parameters depend on the calc_mode:
+          "static": No parameters
+          "md": "temperature", "pressure", "n_ionic_steps", "time_step", "n_print", "temperature_damping_timescale",
+                "pressure_damping_timescale", "seed", "tloop", "initial_temperature", "langevin", "delta_temp",
+                "delta_press", job_name", "rotation_matrix"
+          "minimize": "ionic_energy_tolerance", "ionic_force_tolerance", "max_iter", "pressure", "n_print", "style",
+                      "rotation_matrix"
+          "vcsgc": "mu", "ordered_element_list", "target_concentration", "kappa", "mc_step_interval", "swap_fraction",
+                   "temperature_mc", "window_size", "window_moves", "temperature", "pressure", "n_ionic_steps",
+                   "time_step", "n_print", "temperature_damping_timescale", "pressure_damping_timescale", "seed",
+                   "initial_temperature", "langevin", "job_name", "rotation_matrix"
+        cutoff_radius (float): cut-off radius for the interatomic potential
+        units (str): Units for LAMMPS
+        bonds_kwargs (dict): key-word arguments to create atomistic bonds:
+          "species", "element_list", "cutoff_list", "max_bond_list", "bond_type_list", "angle_type_list",
+        server_kwargs (dict): key-word arguments to create server object - the available parameters are:
+          "user", "host", "run_mode", "queue", "qid", "cores", "threads", "new_h5", "structure_id", "run_time",
+          "memory_limit", "accept_crash", "additional_arguments", "gpus", "conda_environment_name",
+          "conda_environment_path"
+        enable_h5md (bool): activate h5md mode for LAMMPS
+        write_restart_file (bool): enable writing the LAMMPS restart file
+        read_restart_file (bool): enable loading the LAMMPS restart file
+        restart_file (str): file name of the LAMMPS restart file to copy
+        executable_version (str): LAMMPS version to for the execution
+        executable_path (str): path to the LAMMPS executable
+        input_control_file (str|list|dict): Option to modify the LAMMPS input file directly
+
+    Returns:
+        str, dict, bool: Tuple consisting of the shell output (str), the parsed output (dict) and a boolean flag if
+                         the execution raised an accepted error.
+    """
+    if calc_kwargs is None:
+        calc_kwargs = {}
+    else:
+        calc_kwargs = calc_kwargs.copy()
+
+    os.makedirs(working_directory, exist_ok=True)
+    potential_lst, potential_replace, species = _get_potential(
+        potential=potential, resource_path=resource_path
+    )
+
+    lmp_str_lst = []
+    atom_type = "atomic"
+    for l in lammps_file_initialization(
+        structure=structure,
+        units=units,
+        read_restart_file=read_restart_file,
+        restart_file=restart_file,
+    ):
+        if l.strip().startswith("units") and "units" in potential_replace:
+            lmp_str_lst.append(potential_replace["units"])
+        elif l.strip().startswith("atom_style") and "atom_style" in potential_replace:
+            lmp_str_lst.append(potential_replace["atom_style"])
+            atom_type = potential_replace["atom_style"].split()[-1]
+        elif l.strip().startswith("dimension") and "dimension" in potential_replace:
+            lmp_str_lst.append(potential_replace["dimension"])
+        else:
+            lmp_str_lst.append(l)
+
+    lmp_str_lst += potential_lst
+    lmp_str_lst += ["variable dumptime equal {} ".format(calc_kwargs.get("n_print", 1))]
+    lmp_str_lst += [
+        "dump 1 all custom ${dumptime} dump.out id type xsu ysu zsu fx fy fz vx vy vz",
+        'dump_modify 1 sort id format line "%d %d %20.15g %20.15g %20.15g %20.15g %20.15g %20.15g %20.15g %20.15g %20.15g"',
+    ]
+
+    if calc_mode == "static":
+        lmp_str_lst += [
+            k + " " + v
+            for k, v in set_selective_dynamics(
+                structure=structure, calc_md=False
+            ).items()
+        ]
+        lmp_str_tmp_lst = calc_static()
+        lmp_str_lst = _modify_input_dict(
+            input_control_file=input_control_file,
+            lmp_str_lst=lmp_str_lst + lmp_str_tmp_lst[:-1],
+        )
+        lmp_str_lst.append(lmp_str_tmp_lst[-1])
+    elif calc_mode == "md":
+        lmp_str_lst += [
+            k + " " + v
+            for k, v in set_selective_dynamics(
+                structure=structure, calc_md=True
+            ).items()
+        ]
+        if "n_ionic_steps" in calc_kwargs.keys():
+            n_ionic_steps = int(calc_kwargs.pop("n_ionic_steps"))
+        else:
+            n_ionic_steps = 1
+        if read_restart_file:
+            calc_kwargs["initial_temperature"] = 0.0
+        calc_kwargs["units"] = units
+        lmp_str_lst += calc_md(**calc_kwargs)
+        lmp_str_lst = _modify_input_dict(
+            input_control_file=input_control_file,
+            lmp_str_lst=lmp_str_lst,
+        )
+        if read_restart_file:
+            lmp_str_lst += ["reset_timestep 0"]
+        lmp_str_lst += ["run {} ".format(n_ionic_steps)]
+    elif calc_mode == "minimize":
+        calc_kwargs["units"] = units
+        lmp_str_lst += [
+            k + " " + v
+            for k, v in set_selective_dynamics(
+                structure=structure, calc_md=False
+            ).items()
+        ]
+        lmp_str_tmp_lst, structure = calc_minimize(structure=structure, **calc_kwargs)
+        lmp_str_lst = _modify_input_dict(
+            input_control_file=input_control_file,
+            lmp_str_lst=lmp_str_lst + lmp_str_tmp_lst[:-1],
+        )
+        lmp_str_lst.append(lmp_str_tmp_lst[-1])
+    else:
+        raise ValueError(
+            f"calc_mode must be one of: static, md or minimize, not {calc_mode}"
+        )
+    if read_restart_file:
+        shutil.copyfile(
+            os.path.abspath(restart_file),
+            os.path.join(working_directory, os.path.basename(restart_file)),
+        )
+    if write_restart_file:
+        lmp_str_lst.append(f"write_restart {os.path.basename(restart_file)}")
+
+    with open(os.path.join(working_directory, "lmp.in"), "w") as f:
+        f.writelines([l + "\n" for l in lmp_str_lst])
+
+    write_lammps_datafile(
+        structure=structure,
+        potential_elements=species,
+        bond_dict=None,
+        units=units,
+        file_name="lammps.data",
+        working_directory=working_directory,
+        atom_type=atom_type,
+    )
+
+    shell = subprocess.check_output(
+        lmp_command,
+        cwd=working_directory,
+        shell=True,
+        universal_newlines=True,
+        env=os.environ.copy(),
+    )
+    output = parse_lammps_output(
+        working_directory=working_directory,
+        structure=structure,
+        potential_elements=species,
+        units=units,
+        prism=None,
+        dump_h5_file_name="dump.h5",
+        dump_out_file_name="dump.out",
+        log_lammps_file_name="log.lammps",
+    )
+    return shell, output, False
+
+
+def lammps_file_initialization(
+    structure, dimension=3, units="metal", read_restart_file=False, restart_file=None
+):
+    init_commands = ["units " + units]
+    boundary = " ".join(["p" if coord else "f" for coord in structure.pbc])
+    if read_restart_file:
+        init_commands.append(f"read_restart {os.path.basename(restart_file)}")
+    else:
+        init_commands += [
+            "dimension " + str(dimension),
+            "boundary " + boundary + "",
+            "atom_style atomic",
+            "read_data lammps.data",
+        ]
+    return init_commands
+
+
+def _modify_input_dict(
+    input_control_file: Optional[dict] = None,
+    lmp_str_lst: list[str] = [],
+):
+    if input_control_file is not None:
+        lmp_tmp_lst, keys_used = [], []
+        for l in lmp_str_lst:
+            ls = l.split()
+            if len(ls) >= 1:  # Remove empty lines
+                key = ls[0]
+                if key in input_control_file.keys():
+                    lmp_tmp_lst.append(key + " " + input_control_file[key])
+                    keys_used.append(key)
+                else:
+                    lmp_tmp_lst.append(l)
+        for k, v in input_control_file.items():
+            if k not in keys_used:
+                lmp_tmp_lst.append(k + " " + v)
+
+        return lmp_tmp_lst
+    else:
+        return lmp_str_lst
+
+
+def _get_potential(potential, resource_path: Optional[str] = None):
+    if isinstance(potential, str):
+        potential_dataframe = get_potential_by_name(
+            potential_name=potential, resource_path=resource_path
+        )
+    elif isinstance(potential, pandas.DataFrame):
+        potential_dataframe = potential.iloc[0]
+    elif isinstance(potential, pandas.Series):
+        potential_dataframe = potential
+    else:
+        raise TypeError()
+
+    potential_replace = {}
+    potential_lst = []
+    for l in potential_dataframe["Config"]:
+        if l.startswith("units"):
+            potential_replace["units"] = l
+        elif l.startswith("atom_style"):
+            potential_replace["atom_style"] = l
+        elif l.startswith("dimension"):
+            potential_replace["dimension"] = l
+        else:
+            potential_lst.append(l)
+
+    return potential_lst, potential_replace, potential_dataframe["Species"]

lammpsparser/compatibility/structure.py

@@ -0,0 +1,336 @@
+from collections import OrderedDict
+from typing import Dict, Optional
+
+import numpy as np
+from ase.atoms import Atoms
+from structuretoolkit.analyse import get_neighbors
+from structuretoolkit.common import select_index
+
+from lammpsparser.structure import LammpsStructure
+
+
+class LammpsStructureCompatibility(LammpsStructure):
+    def __init__(
+        self,
+        bond_dict: Optional[Dict] = None,
+        units: str = "metal",
+        atom_type: str = "atomic",
+    ):
+        super().__init__(bond_dict=bond_dict, units=units, atom_type=atom_type)
+        self._molecule_ids = []
+
+    @property
+    def structure(self) -> Optional[Atoms]:
+        """
+
+        Returns:
+
+        """
+        return self._structure
+
+    @structure.setter
+    def structure(self, structure):
+        """
+
+        Args:
+            structure:
+
+        Returns:
+
+        """
+        self._structure = structure
+        if self.atom_type == "full":
+            input_str = self.structure_full()
+        elif self.atom_type == "bond":
+            input_str = self.structure_bond()
+        elif self.atom_type == "charge":
+            input_str = self.structure_charge()
+        else:  # self.atom_type == 'atomic'
+            input_str = self.structure_atomic()
+
+        self._string_input = input_str + self._get_velocities_input_string()
+
+    def structure_bond(self):
+        """
+
+        Returns:
+
+        """
+        species_lammps_id_dict = self.get_lammps_id_dict(self.el_eam_lst)
+        self.molecule_ids = None
+        # analyze structure to get molecule_ids, bonds, angles etc
+        coords = self.rotate_positions(self._structure)
+
+        elements = self._structure.get_chemical_symbols()
+
+        ## Standard atoms stuff
+        atoms = "Atoms \n\n"
+        # atom_style bond
+        # format: atom-ID, molecule-ID, atom_type, x, y, z
+        format_str = "{0:d} {1:d} {2:d} {3:f} {4:f} {5:f} "
+        if len(self._structure.positions[0]) == 3:
+            for id_atom, (x, y, z) in enumerate(coords):
+                id_mol = self.molecule_ids[id_atom]
+                atoms += (
+                    format_str.format(
+                        id_atom + 1,
+                        id_mol,
+                        species_lammps_id_dict[elements[id_atom]],
+                        x,
+                        y,
+                        z,
+                    )
+                    + "\n"
+                )
+        elif len(self._structure.positions[0]) == 2:
+            for id_atom, (x, y) in enumerate(coords):
+                id_mol = self.molecule_ids[id_atom]
+                atoms += (
+                    format_str.format(
+                        id_atom + 1,
+                        id_mol,
+                        species_lammps_id_dict[elements[id_atom]],
+                        x,
+                        y,
+                        0.0,
+                    )
+                    + "\n"
+                )
+        else:
+            raise ValueError("dimension 1 not yet implemented")
+
+        ## Bond related.
+        # This seems independent from the lammps atom type ids, because bonds only use atom ids
+        el_list = set(self._structure.get_chemical_symbols())
+        el_dict = OrderedDict()
+        for object_id, el in enumerate(el_list):
+            el_dict[el] = object_id
+
+        n_s = len(el_list)
+        bond_type = np.ones([n_s, n_s], dtype=int)
+        count = 0
+        for i in range(n_s):
+            for j in range(i, n_s):
+                count += 1
+                bond_type[i, j] = count
+                bond_type[j, i] = count
+
+        if self.structure.bonds is None:
+            if self.cutoff_radius is None:
+                bonds_lst = get_bonds(structure=self.structure, max_shells=1)
+            else:
+                bonds_lst = get_bonds(
+                    structure=self.structure, radius=self.cutoff_radius
+                )
+            bonds = []
+
+            for ia, i_bonds in enumerate(bonds_lst):
+                el_i = el_dict[elements[ia]]
+                for el_j, b_lst in i_bonds.items():
+                    b_type = bond_type[el_i][el_dict[el_j]]
+                    for i_shell, ib_shell_lst in enumerate(b_lst):
+                        for ib in np.unique(ib_shell_lst):
+                            if ia < ib:  # avoid double counting of bonds
+                                bonds.append([ia + 1, ib + 1, b_type])
+
+            self.structure.bonds = np.array(bonds)
+        bonds = self.structure.bonds
+
+        bonds_str = "Bonds \n\n"
+        for i_bond, (i_a, i_b, b_type) in enumerate(bonds):
+            bonds_str += (
+                "{0:d} {1:d} {2:d} {3:d}".format(i_bond + 1, b_type, i_a, i_b) + "\n"
+            )
+
+        return (
+            self.lammps_header(
+                structure=self.structure,
+                cell_dimensions=self.simulation_cell(),
+                species_lammps_id_dict=species_lammps_id_dict,
+                nbonds=len(bonds),
+                nbond_types=np.max(np.array(bonds)[:, 2]),
+            )
+            + "\n"
+            + atoms
+            + "\n"
+            + bonds_str
+            + "\n"
+        )
+
+    def structure_full(self):
+        """
+        Write routine to create atom structure static file for atom_type='full' that can be loaded by LAMMPS
+
+        Returns:
+
+        """
+        species_lammps_id_dict = self.get_lammps_id_dict(self.el_eam_lst)
+        self.molecule_ids = None
+        coords = self.rotate_positions(self._structure)
+
+        # extract electric charges from potential file
+        q_dict = {
+            species_name: self.potential.get_charge(species_name)
+            for species_name in set(self.structure.get_chemical_symbols())
+        }
+
+        bonds_lst, angles_lst = [], []
+        bond_type_lst, angle_type_lst = [], []
+        # Using a cutoff distance to draw the bonds instead of the number of neighbors
+        # Only if any bonds are defined
+        if len(self._bond_dict.keys()) > 0:
+            cutoff_list = list()
+            for val in self._bond_dict.values():
+                cutoff_list.append(np.max(val["cutoff_list"]))
+            max_cutoff = np.max(cutoff_list)
+            # Calculate neighbors only once
+            neighbors = get_neighbors(
+                structure=self.structure, cutoff_radius=max_cutoff
+            )
+
+            # Draw bonds between atoms is defined in self._bond_dict
+            # Go through all elements for which bonds are defined
+            for element, val in self._bond_dict.items():
+                el_1_list = select_index(structure=self._structure, element=element)
+                if el_1_list is not None:
+                    if len(el_1_list) > 0:
+                        for i, v in enumerate(val["element_list"]):
+                            el_2_list = select_index(
+                                structure=self._structure, element=v
+                            )
+                            cutoff_dist = val["cutoff_list"][i]
+                            for j, ind in enumerate(
+                                np.array(neighbors.indices, dtype=object)[el_1_list]
+                            ):
+                                # Only chose those indices within the cutoff distance and which belong
+                                # to the species defined in the element_list
+                                # i is the index of each bond type, and j is the element index
+                                id_el = el_1_list[j]
+                                bool_1 = (
+                                    np.array(neighbors.distances, dtype=object)[id_el]
+                                    <= cutoff_dist
+                                )
+                                act_ind = ind[bool_1]
+                                bool_2 = np.in1d(act_ind, el_2_list)
+                                final_ind = act_ind[bool_2]
+                                # Get the bond and angle type
+                                bond_type = val["bond_type_list"][i]
+                                angle_type = val["angle_type_list"][i]
+                                # Draw only maximum allowed bonds
+                                final_ind = final_ind[: val["max_bond_list"][i]]
+                                for fi in final_ind:
+                                    bonds_lst.append([id_el + 1, fi + 1])
+                                    bond_type_lst.append(bond_type)
+                                # Draw angles if at least 2 bonds are present and if an angle type is defined for this
+                                # particular set of bonds
+                                if (
+                                    len(final_ind) >= 2
+                                    and val["angle_type_list"][i] is not None
+                                ):
+                                    angles_lst.append(
+                                        [final_ind[0] + 1, id_el + 1, final_ind[1] + 1]
+                                    )
+                                    angle_type_lst.append(angle_type)
+
+        if len(bond_type_lst) == 0:
+            num_bond_types = 0
+        else:
+            num_bond_types = int(np.max(bond_type_lst))
+        if len(angle_type_lst) == 0:
+            num_angle_types = 0
+        else:
+            num_angle_types = int(np.max(angle_type_lst))
+
+        atoms = "Atoms \n\n"
+
+        # format: atom-ID, molecule-ID, atom_type, q, x, y, z
+        format_str = "{0:d} {1:d} {2:d} {3:f} {4:f} {5:f} {6:f}"
+        el_lst = self.structure.get_chemical_symbols()
+        for id_atom, (el, coord) in enumerate(zip(el_lst, coords)):
+            atoms += (
+                format_str.format(
+                    id_atom + 1,
+                    self.molecule_ids[id_atom],
+                    species_lammps_id_dict[el],
+                    q_dict[el],
+                    coord[0],
+                    coord[1],
+                    coord[2],
+                )
+                + "\n"
+            )
+
+        if len(bonds_lst) > 0:
+            bonds_str = "Bonds \n\n"
+            for i_bond, id_vec in enumerate(bonds_lst):
+                bonds_str += (
+                    "{0:d} {1:d} {2:d} {3:d}".format(
+                        i_bond + 1, bond_type_lst[i_bond], id_vec[0], id_vec[1]
+                    )
+                    + "\n"
+                )
+        else:
+            bonds_str = "\n"
+
+        if len(angles_lst) > 0:
+            angles_str = "Angles \n\n"
+            for i_angle, id_vec in enumerate(angles_lst):
+                angles_str += (
+                    "{0:d} {1:d} {2:d} {3:d} {4:d}".format(
+                        i_angle + 1,
+                        angle_type_lst[i_angle],
+                        id_vec[0],
+                        id_vec[1],
+                        id_vec[2],
+                    )
+                    + "\n"
+                )
+        else:
+            angles_str = "\n"
+        return (
+            self.lammps_header(
+                structure=self.structure,
+                cell_dimensions=self.simulation_cell(),
+                species_lammps_id_dict=species_lammps_id_dict,
+                nbonds=len(bonds_lst),
+                nangles=len(angles_lst),
+                nbond_types=num_bond_types,
+                nangle_types=num_angle_types,
+            )
+            + " \n"
+            + atoms
+            + "\n"
+            + bonds_str
+            + "\n"
+            + angles_str
+            + "\n"
+        )
+
+
+def get_bonds(
+    structure: Atoms, radius=np.inf, max_shells=None, prec=0.1, num_neighbors=20
+):
+    """
+
+    Args:
+        structure (ase.Atoms):
+        radius (float):
+        max_shells:
+        prec: minimum distance between any two clusters (if smaller considered to be single cluster)
+        num_neighbors:
+
+    Returns:
+
+    """
+    neighbors = get_neighbors(
+        structure=structure,
+        cutoff_radius=radius,
+        num_neighbors=num_neighbors,
+        tolerance=2,
+        id_list=None,
+        width_buffer=1.2,
+        allow_ragged=None,
+        mode="ragged",
+        norm_order=2,
+    )
+    return neighbors.get_bonds(radius=radius, max_shells=max_shells, prec=prec)