lammpsparser 0.0.10__tar.gz → 0.1.1__tar.gz

{lammpsparser-0.0.10 → lammpsparser-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lammpsparser
-Version: 0.0.10
+Version: 0.1.1
 Summary: Vector-oriented LAMMPS interface to rapidly iterate over series of atomistic structures or interatomic potentials.
 Project-URL: Homepage, https://github.com/pyiron/lammpsparser
 Project-URL: Documentation, https://github.com/pyiron/lammpsparser
@@ -41,22 +41,18 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Physics
-Requires-Python: <3.15,>=3.9
-Requires-Dist: ase<=3.29.0,>=3.22.1
-Requires-Dist: numpy<=2.5.3,>=1.26.0
-Requires-Dist: pandas<=3.0.6,>=2.0.3
-Requires-Dist: scipy<=1.18.1,>=1.11.1
-Provides-Extra: compatibility
-Requires-Dist: structuretoolkit<=0.0.47,>=0.0.30; extra == 'compatibility'
+Requires-Python: <3.15,>=3.11
+Requires-Dist: ase==3.29.0
+Requires-Dist: numpy<2.6.0,>=1.26.0
+Requires-Dist: pandas<3.2.0,>=2.0.3
+Requires-Dist: scipy<1.19.0,>=1.11.1
 Provides-Extra: h5md
-Requires-Dist: h5py<=3.16.0,>=3.9.0; extra == 'h5md'
+Requires-Dist: h5py<3.17.0,>=3.9.0; extra == 'h5md'
 Description-Content-Type: text/markdown
 
 # lammpsparser

{lammpsparser-0.0.10 → lammpsparser-0.1.1}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [
     "h5py", 
     "pandas", 
     "scipy", 
-    "hatchling==1.32.4",
+    "hatchling==1.33.0",
     "hatch-vcs==0.5.0",
 ]
 build-backend = "hatchling.build"
@@ -19,25 +19,23 @@ authors = [
 readme = "README.md"
 license = { file = "LICENSE" }
 keywords = ["pyiron"]
-requires-python = ">=3.9, <3.15"
+requires-python = ">=3.11, <3.15"
 classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Topic :: Scientific/Engineering :: Physics",
     "License :: OSI Approved :: BSD License",
     "Intended Audience :: Science/Research",
     "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
 ]
 dependencies = [
-    "ase>=3.22.1,<=3.29.0",
-    "numpy>=1.26.0,<=2.5.3",
-    "pandas>=2.0.3,<=3.0.6",
-    "scipy>=1.11.1,<=1.18.1",
+    "ase==3.29.0",
+    "numpy>=1.26.0,<2.6.0",
+    "pandas>=2.0.3,<3.2.0",
+    "scipy>=1.11.1,<1.19.0",
 ]
 dynamic = ["version"]
 
@@ -47,8 +45,7 @@ Documentation = "https://github.com/pyiron/lammpsparser"
 Repository = "https://github.com/pyiron/lammpsparser"
 
 [project.optional-dependencies]
-h5md = ["h5py>=3.9.0,<=3.16.0"]
-compatibility = ["structuretoolkit>=0.0.30,<=0.0.47"]
+h5md = ["h5py>=3.9.0,<3.17.0"]
 
 [tool.hatch.build]
 include = [

{lammpsparser-0.0.10 → lammpsparser-0.1.1}/src/lammpsparser/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.0.10'
-__version_tuple__ = version_tuple = (0, 0, 10)
+__version__ = version = '0.1.1'
+__version_tuple__ = version_tuple = (0, 1, 1)
 
 __commit_id__ = commit_id = None

{lammpsparser-0.0.10 → lammpsparser-0.1.1}/src/lammpsparser/compatibility/file.py

@@ -36,6 +36,9 @@ def lammps_file_interface_function(
     read_restart_file: bool = False,
     restart_file: str = "restart.out",
     dump_final_structure: bool = False,
+    n_print_dump: int | None = None,
+    n_print_thermo: int | None = None,
+    force_skewed: bool = False,
 ):
     """
     A single function to execute a LAMMPS calculation based on the LAMMPS job interface implemented in lammpsparser
@@ -90,6 +93,13 @@ def lammps_file_interface_function(
         restart_file (str): file name of the LAMMPS restart file to copy
         dump_final_structure (bool): in "md" mode, append a ``write_dump`` command after the ``run`` command to capture
             the final structure in ``dump.out`` if last step is not a regular dump step. Disabled by default.
+        n_print_dump (int, optional): Override the dump-file write interval (steps between successive
+            ``dump`` writes), independently of ``calc_kwargs["n_print"]``. Defaults to ``None``, which
+            falls back to ``calc_kwargs.get("n_print", 1)`` (the pre-existing behavior).
+        n_print_thermo (int, optional): Override the thermodynamic print interval (steps between
+            successive ``thermo`` output lines), independently of ``calc_kwargs["n_print"]``. Defaults
+            to ``None``, which leaves ``calc_kwargs["n_print"]`` untouched (the pre-existing behavior).
+            Has no effect in ``"static"`` mode, since that mode only ever performs a single step.
         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
@@ -115,6 +125,12 @@ def lammps_file_interface_function(
     else:
         calc_kwargs = calc_kwargs.copy()
 
+    dump_interval = (
+        n_print_dump if n_print_dump is not None else calc_kwargs.get("n_print", 1)
+    )
+    if n_print_thermo is not None:
+        calc_kwargs["n_print"] = n_print_thermo
+
     if lmp_command is None:
         lmp_command = (
             os.getenv("ASE_LAMMPSRUN_COMMAND", "mpiexec -n 1 --oversubscribe lmp_mpi")
@@ -150,7 +166,7 @@ def lammps_file_interface_function(
     dump_format = '"%d %d %20.15g %20.15g %20.15g %20.15g %20.15g %20.15g %20.15g %20.15g %20.15g"'
 
     lmp_str_lst += potential_lst
-    lmp_str_lst += ["variable dumptime equal {} ".format(calc_kwargs.get("n_print", 1))]
+    lmp_str_lst += [f"variable dumptime equal {dump_interval} "]
     lmp_str_lst += [
         "dump 1 all custom ${dumptime} dump.out " + dump_fields,
         "dump_modify 1 sort id format line " + dump_format,
@@ -195,7 +211,7 @@ def lammps_file_interface_function(
         if read_restart_file:
             lmp_str_lst += ["reset_timestep 0"]
         lmp_str_lst += [f"run {n_ionic_steps} "]
-        last_step_is_regular_dump = n_ionic_steps % calc_kwargs.get("n_print", 1) == 0
+        last_step_is_regular_dump = n_ionic_steps % dump_interval == 0
         if dump_final_structure and not last_step_is_regular_dump:
             lmp_str_lst += [
                 "write_dump all custom dump.out "
@@ -245,6 +261,7 @@ def lammps_file_interface_function(
         file_name="lammps.data",
         working_directory=working_directory,
         atom_type=atom_type,
+        force_skewed=force_skewed,
     )
 
     shell = subprocess.check_output(

lammpsparser-0.1.1/src/lammpsparser/compatibility/neighbors.py

@@ -0,0 +1,232 @@
+"""
+Minimal neighbour analysis for the compatibility layer.
+
+This is a reduced port of :mod:`structuretoolkit.analyse.neighbors` (originally by
+Joerg Neugebauer and Sam Waseda, Max-Planck-Institut für Eisenforschung GmbH,
+distributed under the "New BSD License"). Only the functionality required to
+derive bonds and angles for the LAMMPS ``bond`` and ``full`` atom styles is
+included.
+"""
+
+from __future__ import annotations
+
+import warnings
+
+import numpy as np
+from ase.atoms import Atoms
+from scipy.spatial import cKDTree
+
+
+def select_index(structure: Atoms, element: str) -> np.ndarray:
+    """
+    Select the indices of atoms in the structure that belong to a specific element.
+
+    Args:
+        structure (ase.atoms.Atoms): Atomic structure.
+        element (str): Chemical symbol.
+
+    Returns:
+        numpy.ndarray: Indices of the atoms of the given element.
+    """
+    return structure.symbols.indices()[element]
+
+
+def get_vertical_length(structure: Atoms) -> np.ndarray:
+    """
+    Length of each cell vector projected on the normal of the plane spanned by the
+    other two cell vectors.
+
+    Args:
+        structure (ase.atoms.Atoms): Atomic structure.
+
+    Returns:
+        numpy.ndarray: Projected cell lengths.
+    """
+    return np.linalg.det(structure.cell) / np.linalg.norm(
+        np.cross(
+            np.roll(structure.cell, -1, axis=0), np.roll(structure.cell, 1, axis=0)
+        ),
+        axis=-1,
+    )
+
+
+def get_extended_positions(
+    structure: Atoms, width: float
+) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Get the positions of all atoms in the supercell plus all periodic images within
+    ``width`` of the cell boundary.
+
+    Args:
+        structure (ase.atoms.Atoms): Atomic structure.
+        width (float): Width of the buffer layer on every periodic side of the box.
+
+    Returns:
+        tuple: Extended positions and the indices of the corresponding atoms in the
+        original structure.
+    """
+    if width < 0:
+        raise ValueError("Invalid width")
+    positions = structure.positions
+    if width == 0:
+        return positions, np.arange(len(positions))
+    scaled_width = width / get_vertical_length(structure=structure)
+    rep = 2 * np.ceil(scaled_width).astype(int) * structure.pbc + 1
+    rep = [np.arange(r) - int(r / 2) for r in rep]
+    meshgrid = np.stack(np.meshgrid(rep[0], rep[1], rep[2]), axis=-1).reshape(-1, 3)
+    v_repeated = np.einsum("ni,ij->nj", meshgrid, structure.cell)
+    v_repeated = v_repeated[:, np.newaxis, :] + positions[np.newaxis, :, :]
+    v_repeated = v_repeated.reshape(-1, 3)
+    indices = np.tile(np.arange(len(positions)), len(meshgrid))
+    dist = v_repeated - np.sum(structure.cell * 0.5, axis=0)
+    dist = (
+        np.absolute(np.einsum("ni,ij->nj", dist + 1e-8, np.linalg.inv(structure.cell)))
+        - 0.5
+    )
+    check_dist = np.all(dist - scaled_width < 0, axis=-1)
+    return v_repeated[check_dist], indices[check_dist] % len(positions)
+
+
+class Neighbors:
+    """
+    Neighbourhood information of each atom in a structure.
+
+    Attributes:
+        distances (numpy.ndarray): Distances to the neighbours of each atom. Missing
+            entries (beyond the cutoff radius) are filled with ``numpy.inf``.
+        indices (numpy.ndarray): Indices of the neighbours of each atom. Missing
+            entries are filled with ``numpy.iinfo(numpy.int32).max``.
+    """
+
+    def __init__(self, structure: Atoms, distances: np.ndarray, indices: np.ndarray):
+        self._structure = structure
+        self.distances = distances
+        self.indices = indices
+
+    def get_bonds(
+        self,
+        radius: float = np.inf,
+        max_shells: int | None = None,
+        prec: float = 0.1,
+    ) -> list[dict[str, list[list[int]]]]:
+        """
+        Group the neighbours of each atom into shells and chemical species.
+
+        Args:
+            radius (float): Maximum distance for a bond to be considered.
+            max_shells (int, optional): Maximum number of shells per species.
+            prec (float): Minimum distance gap between two shells; shells closer
+                than ``prec`` are merged into one.
+
+        Returns:
+            list: For each atom a dictionary mapping the chemical symbol of the
+            neighbours to a list of shells, each shell being a list of atom indices.
+        """
+        el_list = self._structure.get_chemical_symbols()
+        ind_shell = []
+        for d, i in zip(self.distances, self.indices):
+            cond = d < radius
+            dist_vec, ind_vec = d[cond], i[cond]
+            ind_where = np.where(np.diff(dist_vec) > prec)[0] + 1
+            ia_shells_dict: dict[str, list[list[int]]] = {}
+            for i_shell_list in [np.sort(g) for g in np.split(ind_vec, ind_where)]:
+                ia_shell_dict: dict[str, list[int]] = {}
+                for i_s in i_shell_list:
+                    ia_shell_dict.setdefault(el_list[i_s], []).append(i_s)
+                for el, ia_lst in ia_shell_dict.items():
+                    shells = ia_shells_dict.setdefault(el, [])
+                    if max_shells is not None and len(shells) + 1 > max_shells:
+                        continue
+                    shells.append(ia_lst)
+            ind_shell.append(ia_shells_dict)
+        return ind_shell
+
+
+def _estimate_width(
+    structure: Atoms,
+    num_neighbors: int,
+    cutoff_radius: float = np.inf,
+    width_buffer: float = 1.2,
+) -> float:
+    """
+    Estimate the width of the periodic buffer layer required to find all neighbours.
+
+    Args:
+        structure (ase.atoms.Atoms): Atomic structure.
+        num_neighbors (int): Number of neighbours.
+        cutoff_radius (float): Cutoff radius.
+        width_buffer (float): Relative safety margin.
+
+    Returns:
+        float: Width of the buffer layer.
+    """
+    if not any(structure.pbc):
+        return 0
+    elif cutoff_radius != np.inf:
+        return cutoff_radius
+    width = np.prod(np.linalg.norm(structure.cell, axis=-1))
+    width *= 4 / 3 * np.pi * np.max([num_neighbors, 8]) / len(structure)
+    return width_buffer * width ** (1 / 3)
+
+
+def get_neighbors(
+    structure: Atoms,
+    num_neighbors: int = 12,
+    cutoff_radius: float = np.inf,
+    width_buffer: float = 1.2,
+) -> Neighbors:
+    """
+    Get the neighbours of each atom in a structure, taking periodic boundary
+    conditions into account.
+
+    Args:
+        structure (ase.atoms.Atoms): Atomic structure.
+        num_neighbors (int): Maximum number of neighbours per atom.
+        cutoff_radius (float): Upper bound of the neighbour distance.
+        width_buffer (float): Relative safety margin of the periodic buffer layer.
+
+    Returns:
+        Neighbors: Neighbour distances and indices.
+    """
+    if num_neighbors <= 0:
+        raise ValueError("invalid number of neighbors")
+    if width_buffer < 0:
+        raise ValueError("width_buffer must be a positive float")
+    width = _estimate_width(
+        structure=structure,
+        num_neighbors=num_neighbors,
+        cutoff_radius=cutoff_radius,
+        width_buffer=width_buffer,
+    )
+    extended_positions, wrapped_indices = get_extended_positions(
+        structure=structure, width=width
+    )
+    if len(extended_positions) < num_neighbors + 1 and cutoff_radius == np.inf:
+        raise ValueError(
+            "num_neighbors too large - make width_buffer larger and/or make "
+            + "num_neighbors smaller"
+        )
+    distances, indices = cKDTree(extended_positions).query(
+        structure.positions,
+        k=num_neighbors + 1,
+        distance_upper_bound=cutoff_radius,
+    )
+    distances = np.asarray(distances).reshape(len(structure), num_neighbors + 1)
+    indices = np.asarray(indices).reshape(len(structure), num_neighbors + 1)
+    if cutoff_radius < np.inf and np.any(distances[:, -1] < np.inf):
+        warnings.warn(
+            "Number of neighbors found within the cutoff_radius is equal to "
+            + "num_neighbors. Increase num_neighbors to find all neighbors within "
+            + "cutoff_radius.",
+            stacklevel=2,
+        )
+    valid = distances < np.inf
+    indices[valid] = wrapped_indices[indices[valid]]
+    indices[~valid] = np.iinfo(np.int32).max
+    # The first column is the atom itself
+    max_column = np.sum(valid, axis=-1).max()
+    return Neighbors(
+        structure=structure,
+        distances=distances[:, 1:max_column],
+        indices=indices[:, 1:max_column],
+    )

{lammpsparser-0.0.10 → lammpsparser-0.1.1}/src/lammpsparser/compatibility/structure.py

@@ -5,9 +5,8 @@ from typing import cast
 
 import numpy as np
 from ase.atoms import Atoms
-from structuretoolkit.analyse import get_neighbors
-from structuretoolkit.common import select_index
 
+from lammpsparser.compatibility.neighbors import get_neighbors, select_index
 from lammpsparser.structure import LammpsStructure
 
 
@@ -329,7 +328,7 @@ def get_bonds(
     """
     Identify bonds in a structure based on neighbour distances.
 
-    Wraps :func:`structuretoolkit.analyse.get_neighbors` and its
+    Wraps :func:`lammpsparser.compatibility.neighbors.get_neighbors` and its
     ``get_bonds`` method to return a shell-based bond list for each atom.
 
     Args:
@@ -344,16 +343,12 @@ def get_bonds(
 
     Returns:
         list: Nested bond list as returned by
-        :meth:`structuretoolkit.analyse.neighbors.get_bonds`.
+        :meth:`lammpsparser.compatibility.neighbors.Neighbors.get_bonds`.
     """
     neighbors = get_neighbors(
         structure=structure,
         cutoff_radius=radius,
         num_neighbors=num_neighbors,
-        tolerance=2,
-        id_list=None,
         width_buffer=1.2,
-        mode="ragged",
-        norm_order=2,
     )
     return neighbors.get_bonds(radius=radius, max_shells=max_shells, prec=prec)

{lammpsparser-0.0.10 → lammpsparser-0.1.1}/src/lammpsparser/structure.py

@@ -554,6 +554,7 @@ def write_lammps_datafile(
     file_name: str = "lammps.data",
     working_directory: str | None = None,
     atom_type: str = "atomic",
+    force_skewed: bool = False,
 ) -> None:
     """
     Write an ASE structure to a LAMMPS data file.
@@ -579,6 +580,7 @@ def write_lammps_datafile(
             (default), ``"charge"``, ``"bond"``, or ``"full"``.
     """
     lammps_str = LammpsStructure(bond_dict=bond_dict, units=units, atom_type=atom_type)
+    lammps_str._force_skewed = force_skewed
     lammps_str.el_eam_lst = cast(list[str], list(potential_elements))
     lammps_str.structure = structure
     lammps_str.write_file(file_name=file_name, cwd=working_directory)