lammpsparser 0.0.3__tar.gz → 0.0.5__tar.gz

lammpsparser-0.0.5/.gitignore

@@ -0,0 +1,218 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

{lammpsparser-0.0.3 → lammpsparser-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lammpsparser
-Version: 0.0.3
+Version: 0.0.5
 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
@@ -50,9 +50,11 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Python: <3.15,>=3.9
 Requires-Dist: ase<=3.28.0,>=3.22.1
-Requires-Dist: numpy<=2.4.3,>=1.26.0
-Requires-Dist: pandas<=3.0.2,>=2.0.3
+Requires-Dist: numpy<=2.4.6,>=1.26.0
+Requires-Dist: pandas<=3.0.3,>=2.0.3
 Requires-Dist: scipy<=1.17.1,>=1.11.1
+Provides-Extra: compatibility
+Requires-Dist: structuretoolkit<=0.0.44,>=0.0.30; extra == 'compatibility'
 Provides-Extra: h5md
 Requires-Dist: h5py<=3.16.0,>=3.9.0; extra == 'h5md'
 Description-Content-Type: text/markdown

{lammpsparser-0.0.3 → lammpsparser-0.0.5}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [
     "h5py", 
     "pandas", 
     "scipy", 
-    "hatchling==1.29.0",
+    "hatchling==1.30.1",
     "hatch-vcs==0.5.0",
 ]
 build-backend = "hatchling.build"
@@ -35,8 +35,8 @@ classifiers = [
 ]
 dependencies = [
     "ase>=3.22.1,<=3.28.0",
-    "numpy>=1.26.0,<=2.4.3",
-    "pandas>=2.0.3,<=3.0.2",
+    "numpy>=1.26.0,<=2.4.6",
+    "pandas>=2.0.3,<=3.0.3",
     "scipy>=1.11.1,<=1.17.1",
 ]
 dynamic = ["version"]
@@ -48,6 +48,7 @@ Repository = "https://github.com/pyiron/lammpsparser"
 
 [project.optional-dependencies]
 h5md = ["h5py>=3.9.0,<=3.16.0"]
+compatibility = ["structuretoolkit>=0.0.30,<=0.0.44"]
 
 [tool.hatch.build]
 include = [

lammpsparser-0.0.5/src/lammpsparser/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.0.5'
+__version_tuple__ = version_tuple = (0, 0, 5)
+
+__commit_id__ = commit_id = None

{lammpsparser-0.0.3 → lammpsparser-0.0.5}/src/lammpsparser/compatibility/calculate.py

@@ -1,4 +1,5 @@
 import warnings
+from typing import Any, cast
 
 import numpy as np
 from ase.atoms import Atoms
@@ -121,7 +122,7 @@ def calc_md(
                 "Target temperature for fix nvt/npt/nph cannot be 0 or negative"
             )
 
-        force_skewed = False
+        # force_skewed = False
         pressure = _pressure_to_lammps(
             pressure=pressure, rotation_matrix=rotation_matrix, units=units
         )
@@ -139,8 +140,8 @@ def calc_md(
                     pressure_string += " {0} {1} {1} {2}".format(
                         coord, value, pressure_damping_timescale
                     )
-                    if ii > 2:
-                        force_skewed = True
+                    # if ii > 2:
+                    #     force_skewed = True
 
         if langevin:  # NPT(Langevin)
             fix_ensemble_str = "fix ensemble all nph" + pressure_string
@@ -277,7 +278,7 @@ def calc_minimize(
             pressure=pressure, rotation_matrix=rotation_matrix, units=units
         )
         if np.isscalar(pressure):
-            str_press = " iso {}".format(pressure)
+            str_press = " iso {}".format(float(cast(Any, pressure)))
         else:
             str_press = ""
             for ii, (press, str_axis) in enumerate(
@@ -307,10 +308,31 @@ def calc_minimize(
 
 
 def calc_static():
+    """
+    Generate LAMMPS input commands for a single-point (static) energy calculation.
+
+    Configures thermodynamic output and runs zero MD steps so that LAMMPS
+    computes and prints forces, stresses, and energies for the current
+    configuration without moving any atoms.
+
+    Returns:
+        list[str]: LAMMPS input lines to append to the input script.
+    """
     return ["variable thermotime equal 1"] + _get_thermo() + ["run 0"]
 
 
 def _get_thermo():
+    """
+    Return the standard thermodynamic output commands used by all calc modes.
+
+    Writes step, temperature, potential energy, total energy, full pressure
+    tensor, and volume every ``${thermotime}`` steps.  The ``${thermotime}``
+    variable must be defined before these lines are appended.
+
+    Returns:
+        list[str]: Three LAMMPS input lines: ``thermo_style``,
+        ``thermo_modify``, and ``thermo``.
+    """
     return [
         "thermo_style custom step temp pe etotal pxx pxy pxz pyy pyz pzz vol",
         "thermo_modify format float %20.15g",
@@ -319,6 +341,20 @@ def _get_thermo():
 
 
 def _is_isotropic_hydrostatic(pressure):
+    """
+    Return ``True`` when ``pressure`` describes an isotropic, hydrostatic state.
+
+    A pressure specification is considered isotropic and hydrostatic when the
+    three diagonal (axial) components are equal and the three off-diagonal
+    (shear) components are either all ``None`` or all equal to zero.
+
+    Args:
+        pressure (list): Six-element list ``[pxx, pyy, pzz, pxy, pxz, pyz]``
+            where ``None`` means "unconstrained".
+
+    Returns:
+        bool: ``True`` if the pressure is isotropic hydrostatic.
+    """
     axial_all_alike = None not in pressure[:3] and np.allclose(
         pressure[:3], pressure[0]
     )
@@ -432,12 +468,22 @@ def _pressure_to_lammps(pressure, rotation_matrix, units="metal"):
 
 def _get_rotation_matrix(structure, pressure):
     """
+    Derive the rotation matrix from the structure's prism and optionally perturb
+    the cell to support non-diagonal pressure components.
+
+    If the requested pressure includes shear components and the cell is not
+    already triclinic, a tiny cell perturbation is applied so that LAMMPS
+    permits the off-diagonal deformations.
 
     Args:
-        pressure:
+        structure (ase.atoms.Atoms): Current atomic structure.
+        pressure (float or list): Pressure specification (scalar or up to six
+            components).
 
     Returns:
-
+        tuple:
+            - numpy.ndarray: 3×3 rotation matrix from the ASE to LAMMPS frame.
+            - ase.atoms.Atoms: Possibly perturbed structure.
     """
     if structure is not None:
         prism = UnfoldingPrism(structure.cell)

{lammpsparser-0.0.3 → lammpsparser-0.0.5}/src/lammpsparser/compatibility/constraints.py

@@ -2,7 +2,28 @@ import numpy as np
 from ase.atoms import Atoms
 
 
-def _get_fixed_atom_boolean_vector(structure: Atoms):
+def _get_fixed_atom_boolean_vector(structure: Atoms) -> np.ndarray:
+    """
+    Convert ASE constraints to a per-atom, per-direction boolean array.
+
+    Translates ASE :class:`~ase.constraints.FixAtoms` and
+    :class:`~ase.constraints.FixedPlane` constraints on ``structure`` into a
+    boolean array where ``True`` indicates that the corresponding degree of
+    freedom is frozen.
+
+    Args:
+        structure (ase.atoms.Atoms): Structure whose ``constraints`` attribute
+            is inspected.
+
+    Returns:
+        numpy.ndarray: Boolean array of shape ``(N, 3)`` where ``True`` means
+        the atom's motion in that Cartesian direction is fixed.
+
+    Raises:
+        ValueError: If a constraint type other than ``FixAtoms`` or
+            ``FixedPlane`` is encountered, or if the ``FixedPlane`` direction
+            is not one of the supported axis combinations.
+    """
     fixed_atom_vector = np.array([[False, False, False]] * len(structure))
     for c in structure.constraints:
         c_dict = c.todict()
@@ -27,8 +48,39 @@ def _get_fixed_atom_boolean_vector(structure: Atoms):
     return fixed_atom_vector
 
 
-def set_selective_dynamics(structure: Atoms, calc_md: bool = False):
-    control_dict = {}
+def set_selective_dynamics(structure: Atoms, calc_md: bool = False) -> dict[str, str]:
+    """
+    Translate ASE constraints into LAMMPS ``group`` / ``fix setforce`` commands.
+
+    Groups atoms by their frozen degrees of freedom and generates the
+    corresponding LAMMPS commands to zero the force (and optionally the
+    velocity) on those atoms.  Supports constraints on individual Cartesian
+    directions (x, y, z) as well as the combined xy, yz, and zx pairs.
+
+    The LAMMPS equivalent of ASE's ``FixAtoms`` is ``fix setforce 0.0 0.0 0.0``
+    and ``FixedPlane`` along an axis is ``fix setforce 0.0 NULL NULL`` (or the
+    appropriate permutation).
+
+    Args:
+        structure (ase.atoms.Atoms): Structure whose ``constraints`` are
+            mapped to LAMMPS commands.
+        calc_md (bool): If ``True``, also add ``velocity … set`` commands to
+            initialise constrained atoms with zero velocity (required for MD
+            to prevent initial kinetic energy in frozen directions).
+
+    Returns:
+        dict[str, str]: Ordered mapping of LAMMPS command keyword to the rest
+        of the command line.  For example::
+
+            {
+                "group constraintxyz": "id 1 2 3",
+                "fix constraintxyz": "constraintxyz setforce 0.0 0.0 0.0",
+                "velocity constraintxyz": "set 0.0 0.0 0.0",  # only when calc_md=True
+            }
+
+        Returns an empty dict if the structure has no constraints.
+    """
+    control_dict: dict[str, str] = {}
     if len(structure.constraints) > 0:
         sel_dyn = _get_fixed_atom_boolean_vector(structure=structure)
         # Enter loop only if constraints present

lammpsparser-0.0.5/src/lammpsparser/compatibility/data.py

@@ -0,0 +1,87 @@
+from dataclasses import dataclass
+from typing import Optional, Union
+
+import numpy as np
+
+
+@dataclass
+class CalcMDInput:
+    """
+    Input parameters for a LAMMPS molecular-dynamics run via :func:`~lammpsparser.compatibility.calculate.calc_md`.
+
+    All time-like values (``time_step``, ``temperature_damping_timescale``,
+    ``pressure_damping_timescale``) are given in femtoseconds and are
+    internally rescaled to the target LAMMPS unit system before being written
+    to the input script.
+
+    Attributes:
+        temperature: Target temperature in K.  Scalar for a fixed target, or
+            a two-element list ``[T_start, T_end]`` for a linear ramp.  If
+            ``None``, an NVE run is performed.
+        pressure: Target pressure in GPa.  Scalar for isotropic, list of up
+            to 6 values for ``[xx, yy, zz, xy, xz, yz]`` components.  ``None``
+            values leave the corresponding cell degree of freedom unconstrained.
+            If ``None``, no barostat is applied.
+        n_ionic_steps: Number of MD timesteps to run.
+        time_step: MD timestep in fs (default: ``1.0``).
+        n_print: Write thermo and dump output every this many steps.
+        temperature_damping_timescale: Nosé–Hoover thermostat coupling time
+            in fs (LAMMPS ``Tdamp``).
+        pressure_damping_timescale: Nosé–Hoover barostat coupling time in fs
+            (LAMMPS ``Pdamp``).
+        seed: Random seed for velocity initialisation and Langevin dynamics.
+        tloop: Optional ``tloop`` argument for the ``fix nvt/npt`` command.
+        initial_temperature: Temperature used to initialise velocities.
+            ``None`` defaults to twice the target temperature.  ``0`` skips
+            velocity initialisation.
+        langevin: Use Langevin dynamics instead of Nosé–Hoover.
+        delta_temp: Deprecated alias for ``temperature_damping_timescale``.
+        delta_press: Deprecated alias for ``pressure_damping_timescale``.
+        rotation_matrix: 3×3 rotation matrix from the ASE to LAMMPS coordinate
+            frame.  Derived automatically when ``None``.
+    """
+
+    temperature: Optional[Union[float, list]] = None
+    pressure: Optional[Union[float, list, np.ndarray]] = None
+    n_ionic_steps: int = 1
+    time_step: float = 1.0
+    n_print: int = 100
+    temperature_damping_timescale: float = 100.0
+    pressure_damping_timescale: float = 1000.0
+    seed: int = 80996
+    tloop: Optional[int] = None
+    initial_temperature: Optional[float] = None
+    langevin: bool = False
+    delta_temp: Optional[float] = None
+    delta_press: Optional[float] = None
+    rotation_matrix: Optional[Union[list, np.ndarray]] = None
+
+
+@dataclass
+class CalcMinimizeInput:
+    """
+    Input parameters for a LAMMPS geometry optimisation via :func:`~lammpsparser.compatibility.calculate.calc_minimize`.
+
+    Attributes:
+        ionic_energy_tolerance: Convergence criterion on the energy change
+            between consecutive steps in eV (LAMMPS ``etol``).  The
+            minimisation stops when ``|ΔE| ≤ ionic_energy_tolerance``.
+        ionic_force_tolerance: Convergence criterion on the global force
+            vector magnitude in eV/Å (LAMMPS ``ftol``).
+        max_iter: Maximum number of minimisation iterations.
+        pressure: Target pressure in GPa for cell relaxation.  Scalar for
+            isotropic, list of up to 6 Voigt components.  ``None`` means
+            fixed-volume relaxation.
+        n_print: Write thermo and dump output every this many steps.
+        style: LAMMPS ``min_style`` keyword (e.g. ``"cg"`` for conjugate
+            gradient, ``"sd"`` for steepest descent).
+        rotation_matrix: 3×3 rotation matrix from the ASE to LAMMPS frame.
+    """
+
+    ionic_energy_tolerance: float = 0.0
+    ionic_force_tolerance: float = 1e-4
+    max_iter: int = 100000
+    pressure: Optional[Union[float, list, np.ndarray]] = None
+    n_print: int = 1
+    style: str = "cg"
+    rotation_matrix: Optional[Union[list, np.ndarray]] = None