lammpsparser 0.0.6__tar.gz → 0.0.8__tar.gz

{lammpsparser-0.0.6 → lammpsparser-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lammpsparser
-Version: 0.0.6
+Version: 0.0.8
 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
@@ -51,7 +51,7 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Python: <3.15,>=3.9
 Requires-Dist: ase<=3.29.0,>=3.22.1
 Requires-Dist: numpy<=2.4.6,>=1.26.0
-Requires-Dist: pandas<=3.0.3,>=2.0.3
+Requires-Dist: pandas<=3.0.5,>=2.0.3
 Requires-Dist: scipy<=1.17.1,>=1.11.1
 Provides-Extra: compatibility
 Requires-Dist: structuretoolkit<=0.0.45,>=0.0.30; extra == 'compatibility'

{lammpsparser-0.0.6 → lammpsparser-0.0.8}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [
     "h5py", 
     "pandas", 
     "scipy", 
-    "hatchling==1.30.1",
+    "hatchling==1.31.0",
     "hatch-vcs==0.5.0",
 ]
 build-backend = "hatchling.build"
@@ -36,7 +36,7 @@ classifiers = [
 dependencies = [
     "ase>=3.22.1,<=3.29.0",
     "numpy>=1.26.0,<=2.4.6",
-    "pandas>=2.0.3,<=3.0.3",
+    "pandas>=2.0.3,<=3.0.5",
     "scipy>=1.11.1,<=1.17.1",
 ]
 dynamic = ["version"]

{lammpsparser-0.0.6 → lammpsparser-0.0.8}/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.6'
-__version_tuple__ = version_tuple = (0, 0, 6)
+__version__ = version = '0.0.8'
+__version_tuple__ = version_tuple = (0, 0, 8)
 
 __commit_id__ = commit_id = None

{lammpsparser-0.0.6 → lammpsparser-0.0.8}/src/lammpsparser/compatibility/calculate.py

@@ -64,10 +64,10 @@ def calc_md(
         delta_press (float): Barostat timescale, but in your Lammps time units, whatever those
             are. (DEPRECATED.)
         job_name (str): Job name of the job to generate a unique random seed.
-        rotation_matrix (numpy.ndarray): The rotation matrix from the pyiron to Lammps coordinate
+        rotation_matrix (numpy.ndarray): The rotation matrix from the ASE to Lammps coordinate
             frame.
     """
-    if units not in LAMMPS_UNIT_CONVERSIONS.keys():
+    if units not in LAMMPS_UNIT_CONVERSIONS:
         raise NotImplementedError
     time_units = LAMMPS_UNIT_CONVERSIONS[units]["time"]
     temperature_units = LAMMPS_UNIT_CONVERSIONS[units]["temperature"]
@@ -103,7 +103,7 @@ def calc_md(
             raise ValueError(
                 "At most two temperatures can be provided "
                 "(for a linearly ramping target temperature), "
-                "but got {}".format(len(temperature))
+                f"but got {len(temperature)}"
             )
         temperature *= temperature_units
 
@@ -128,35 +128,24 @@ def calc_md(
         )
 
         if np.isscalar(pressure):
-            pressure_string = " iso {0} {0} {1}".format(
-                pressure, pressure_damping_timescale
-            )
+            pressure_string = f" iso {pressure} {pressure} {pressure_damping_timescale}"
         else:
             pressure_string = ""
             for ii, (coord, value) in enumerate(
                 zip(["x", "y", "z", "xy", "xz", "yz"], pressure)
             ):
                 if value is not None:
-                    pressure_string += " {0} {1} {1} {2}".format(
-                        coord, value, pressure_damping_timescale
+                    pressure_string += (
+                        f" {coord} {value} {value} {pressure_damping_timescale}"
                     )
                     # if ii > 2:
                     #     force_skewed = True
 
         if langevin:  # NPT(Langevin)
             fix_ensemble_str = "fix ensemble all nph" + pressure_string
-            thermo_str = "fix langevin all langevin {0} {1} {2} {3} zero yes".format(
-                str(temperature[0]),
-                str(temperature[1]),
-                str(temperature_damping_timescale),
-                str(seed),
-            )
+            thermo_str = f"fix langevin all langevin {temperature[0]!s} {temperature[1]!s} {temperature_damping_timescale!s} {seed!s} zero yes"
         else:  # NPT(Nose-Hoover)
-            fix_ensemble_str = "fix ensemble all npt temp {0} {1} {2}".format(
-                str(temperature[0]),
-                str(temperature[1]),
-                str(temperature_damping_timescale),
-            )
+            fix_ensemble_str = f"fix ensemble all npt temp {temperature[0]!s} {temperature[1]!s} {temperature_damping_timescale!s}"
             fix_ensemble_str += pressure_string
     elif temperature is not None:  # NVT
         if temperature.min() <= 0:
@@ -166,18 +155,9 @@ def calc_md(
 
         if langevin:  # NVT(Langevin)
             fix_ensemble_str = "fix ensemble all nve"
-            thermo_str = "fix langevin all langevin {0} {1} {2} {3} zero yes".format(
-                str(temperature[0]),
-                str(temperature[1]),
-                str(temperature_damping_timescale),
-                str(seed),
-            )
+            thermo_str = f"fix langevin all langevin {temperature[0]!s} {temperature[1]!s} {temperature_damping_timescale!s} {seed!s} zero yes"
         else:  # NVT(Nose-Hoover)
-            fix_ensemble_str = "fix ensemble all nvt temp {0} {1} {2}".format(
-                str(temperature[0]),
-                str(temperature[1]),
-                str(temperature_damping_timescale),
-            )
+            fix_ensemble_str = f"fix ensemble all nvt temp {temperature[0]!s} {temperature[1]!s} {temperature_damping_timescale!s}"
     else:  # NVE
         if langevin:
             warnings.warn("Temperature not set; Langevin ignored.")
@@ -190,8 +170,8 @@ def calc_md(
     if thermo_str != "":
         line_lst.append(thermo_str)
 
-    line_lst.append("variable thermotime equal {} ".format(n_print))
-    line_lst.append("timestep {}".format(time_step))
+    line_lst.append(f"variable thermotime equal {n_print} ")
+    line_lst.append(f"timestep {time_step}")
     if initial_temperature is not None and initial_temperature > 0:
         line_lst.append(
             _set_initial_velocity(
@@ -241,18 +221,14 @@ def calc_minimize(
         style ('cg'/'sd'/other values from Lammps docs): The style of the numeric minimization, either conjugate
             gradient, steepest descent, or other keys permissible from the Lammps docs on 'min_style'. (Default
             is 'cg' -- conjugate gradient.)
-        rotation_matrix (numpy.ndarray): The rotation matrix from the pyiron to Lammps coordinate frame.
+        rotation_matrix (numpy.ndarray): The rotation matrix from the ASE to Lammps coordinate frame.
     """
-    # This docstring is a source for the calc_minimize method in pyiron_atomistics.lammps.base.LammpsBase.calc_minimize and
-    # pyiron_atomistics.lammps.interactive.LammpsInteractive.calc_minimize -- Please ensure that changes to signature or
-    # defaults stay consistent!
-
     max_evaluations = 100 * max_iter
     if n_print > max_iter:
         warnings.warn("n_print larger than max_iter, adjusting to n_print=max_iter")
         n_print = max_iter
 
-    if units not in LAMMPS_UNIT_CONVERSIONS.keys():
+    if units not in LAMMPS_UNIT_CONVERSIONS:
         raise NotImplementedError
     energy_units = LAMMPS_UNIT_CONVERSIONS[units]["energy"]
     force_units = LAMMPS_UNIT_CONVERSIONS[units]["force"]
@@ -260,7 +236,7 @@ def calc_minimize(
     ionic_energy_tolerance *= energy_units
     ionic_force_tolerance *= force_units
 
-    line_lst = ["variable thermotime equal {} ".format(n_print)]
+    line_lst = [f"variable thermotime equal {n_print} "]
     line_lst += _get_thermo()
     if pressure is not None:
         if rotation_matrix is None:
@@ -278,14 +254,14 @@ def calc_minimize(
             pressure=pressure, rotation_matrix=rotation_matrix, units=units
         )
         if np.isscalar(pressure):
-            str_press = " iso {}".format(float(cast(Any, pressure)))
+            str_press = f" iso {float(cast(Any, pressure))}"
         else:
             str_press = ""
             for ii, (press, str_axis) in enumerate(
                 zip(pressure, ["x", "y", "z", "xy", "xz", "yz"])
             ):
                 if press is not None:
-                    str_press += " {} {}".format(str_axis, press)
+                    str_press += f" {str_axis} {press}"
                     # if ii > 2:
                     #     force_skewed = True
             if len(str_press) > 1:
@@ -407,11 +383,11 @@ def _pressure_to_lammps(pressure, rotation_matrix, units="metal"):
     In case of a single pressure value, it is again returned as a single pressure value, to be used with the "iso"
     option (i.e., coupled deformation in x, y, and z).
 
-    Finally, we also ensure that the units are converted from pyiron's GPa to whatever Lammps needs.
+    Finally, we also ensure that the units are converted from lammpsparser's GPa to whatever Lammps needs.
 
     Args:
         pressure (float/list/tuple/numpy.ndarray): The pressure(s) to convert.
-        rotation_matrix (numpy.ndarray): The 3x3 matrix rotating from the pyiron to Lammps coordinate frame.
+        rotation_matrix (numpy.ndarray): The 3x3 matrix rotating from the ASE to Lammps coordinate frame.
 
     Returns:
         (list): pxx, pyy, pzz, pxy, pxz, and pyz to be passed to Lammps.
@@ -433,7 +409,7 @@ def _pressure_to_lammps(pressure, rotation_matrix, units="metal"):
     if len(pressure) > 6:
         raise ValueError(
             "Pressure can have a maximum of 6 values, (x, y, z, xy, xz, and yz), but got "
-            + "{}".format(len(pressure))
+            + f"{len(pressure)}"
         )
     pressure = [float(p) if p is not None else None for p in pressure]
     pressure += (6 - len(pressure)) * [None]
@@ -451,7 +427,7 @@ def _pressure_to_lammps(pressure, rotation_matrix, units="metal"):
                 "Cells which are not orthorhombic or an upper-triangular cell are incompatible with Lammps "
                 "constant pressure calculations unless the entire pressure tensor is defined. "
                 "The reason is that Lammps demands such cells be represented with an "
-                "upper-triangular unit cell, thus a rotation between Lammps and pyiron coordinate "
+                "upper-triangular unit cell, thus a rotation between Lammps and ASE coordinate "
                 "frames is required; it is not possible to rotate the pressure tensor if any of "
                 "its components is None."
             )

{lammpsparser-0.0.6 → lammpsparser-0.0.8}/src/lammpsparser/compatibility/data.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
-from typing import Optional, Union
 
 import numpy as np
 
@@ -41,20 +42,20 @@ class CalcMDInput:
             frame.  Derived automatically when ``None``.
     """
 
-    temperature: Optional[Union[float, list]] = None
-    pressure: Optional[Union[float, list, np.ndarray]] = None
+    temperature: float | list | None = None
+    pressure: float | list | np.ndarray | None = 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
+    tloop: int | None = None
+    initial_temperature: float | None = None
     langevin: bool = False
-    delta_temp: Optional[float] = None
-    delta_press: Optional[float] = None
-    rotation_matrix: Optional[Union[list, np.ndarray]] = None
+    delta_temp: float | None = None
+    delta_press: float | None = None
+    rotation_matrix: list | np.ndarray | None = None
 
 
 @dataclass
@@ -81,7 +82,7 @@ class CalcMinimizeInput:
     ionic_energy_tolerance: float = 0.0
     ionic_force_tolerance: float = 1e-4
     max_iter: int = 100000
-    pressure: Optional[Union[float, list, np.ndarray]] = None
+    pressure: float | list | np.ndarray | None = None
     n_print: int = 1
     style: str = "cg"
-    rotation_matrix: Optional[Union[list, np.ndarray]] = None
+    rotation_matrix: list | np.ndarray | None = None

{lammpsparser-0.0.6 → lammpsparser-0.0.8}/src/lammpsparser/compatibility/file.py

@@ -1,8 +1,9 @@
+from __future__ import annotations
+
 import os
 import shutil
 import subprocess
 from dataclasses import asdict
-from typing import Optional, Union
 
 import pandas
 from ase.atoms import Atoms
@@ -24,26 +25,27 @@ def lammps_file_interface_function(
     structure: Atoms,
     potential: str,
     calc_mode: str = "static",
-    calc_kwargs: Optional[dict] = None,
-    calc_dataclass: Optional[Union[CalcMDInput, CalcMinimizeInput]] = None,
+    calc_kwargs: dict | None = None,
+    calc_dataclass: CalcMDInput | CalcMinimizeInput | None = None,
     units: str = "metal",
-    lmp_command: Optional[str] = None,
-    resource_path: Optional[str] = None,
-    input_control_file: Optional[dict] = None,
+    lmp_command: str | None = None,
+    resource_path: str | None = None,
+    input_control_file: dict | None = None,
     write_restart_file: bool = False,
     read_restart_file: bool = False,
     restart_file: str = "restart.out",
+    dump_final_structure: bool = False,
 ):
     """
-    A single function to execute a LAMMPS calculation based on the LAMMPS job implemented in pyiron
+    A single function to execute a LAMMPS calculation based on the LAMMPS job interface implemented in lammpsparser
 
     Examples:
 
     >>> import os
     >>> from ase.build import bulk
-    >>> from pyiron_atomistics.lammps.lammps import lammps_function
+    >>> from lammpsparser.compatibility.file import lammps_file_interface_function
     >>>
-    >>> shell_output, parsed_output, job_crashed = lammps_function(
+    >>> shell_output, parsed_output, job_crashed = lammps_file_interface_function(
     ...     working_directory=os.path.abspath("lmp_working_directory"),
     ...     structure=bulk("Al", cubic=True),
     ...     potential='2009--Mendelev-M-I--Al-Mg--LAMMPS--ipr1',
@@ -85,6 +87,8 @@ def lammps_file_interface_function(
         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
+        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.
         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
@@ -141,14 +145,21 @@ def lammps_file_interface_function(
         else:
             lmp_str_lst.append(line)
 
+    dump_fields = "id type xsu ysu zsu fx fy fz vx vy vz"
+    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 += [
-        "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"',
+        "dump 1 all custom ${dumptime} dump.out " + dump_fields,
+        "dump_modify 1 sort id format line " + dump_format,
     ]
 
     if calc_mode == "static":
+        if dump_final_structure:
+            raise ValueError(
+                "dump_final_structure is only applicable for molecular dynamics (md) calculations."
+            )
         lmp_str_constraint_lst = [
             k + " " + v
             for k, v in set_selective_dynamics(
@@ -168,7 +179,7 @@ def lammps_file_interface_function(
                 structure=structure, calc_md=True
             ).items()
         ]
-        if "n_ionic_steps" in calc_kwargs.keys():
+        if "n_ionic_steps" in calc_kwargs:
             n_ionic_steps = int(calc_kwargs.pop("n_ionic_steps"))
         else:
             n_ionic_steps = 1
@@ -182,8 +193,21 @@ def lammps_file_interface_function(
         )
         if read_restart_file:
             lmp_str_lst += ["reset_timestep 0"]
-        lmp_str_lst += ["run {} ".format(n_ionic_steps)]
+        lmp_str_lst += [f"run {n_ionic_steps} "]
+        last_step_is_regular_dump = n_ionic_steps % calc_kwargs.get("n_print", 1) == 0
+        if dump_final_structure and not last_step_is_regular_dump:
+            lmp_str_lst += [
+                "write_dump all custom dump.out "
+                + dump_fields
+                + " modify sort id format line "
+                + dump_format
+                + " append yes"
+            ]
     elif calc_mode == "minimize":
+        if dump_final_structure:
+            raise ValueError(
+                "dump_final_structure is only applicable for molecular dynamics (md) calculations."
+            )
         calc_kwargs["units"] = units
         lmp_str_constraint_lst = [
             k + " " + v
@@ -282,8 +306,8 @@ def lammps_file_initialization(
 
 
 def _modify_input_dict(
-    input_control_file: Optional[dict] = None,
-    lmp_str_lst: list[str] = [],
+    input_control_file: dict | None = None,
+    lmp_str_lst: list[str] | None = None,
 ):
     """
     Apply user-supplied overrides to a LAMMPS input line list.
@@ -302,13 +326,15 @@ def _modify_input_dict(
     Returns:
         list[str]: Modified (or unchanged) list of LAMMPS input lines.
     """
+    if lmp_str_lst is None:
+        lmp_str_lst = []
     if input_control_file is not None:
         lmp_tmp_lst, keys_used = [], []
         for line in lmp_str_lst:
             ls = line.split()
             if len(ls) >= 1:  # Remove empty lines
                 key = ls[0]
-                if key in input_control_file.keys():
+                if key in input_control_file:
                     lmp_tmp_lst.append(key + " " + input_control_file[key])
                     keys_used.append(key)
                 else:
@@ -322,7 +348,7 @@ def _modify_input_dict(
         return lmp_str_lst
 
 
-def _get_potential(potential, resource_path: Optional[str] = None):
+def _get_potential(potential, resource_path: str | None = None):
     """
     Resolve a potential specification to LAMMPS input lines and species list.
 

{lammpsparser-0.0.6 → lammpsparser-0.0.8}/src/lammpsparser/compatibility/output.py

@@ -6,6 +6,7 @@ def structure_from_parsed_output(
     parsed_output: dict,
     *,
     wrap: bool = False,
+    scale_atoms: bool = True,
     index: int = -1,
 ) -> Atoms:
     """Construct an `Atoms` object from parsed output data.
@@ -27,10 +28,12 @@ def structure_from_parsed_output(
     """
     # Take a copy of the initial structure as template and update the relevant properties
     atoms_copy = initial_structure.copy()
+    atoms_copy.set_cell(
+        parsed_output["generic"]["cells"][index], scale_atoms=scale_atoms
+    )
     atoms_copy.set_array("indices", parsed_output["generic"]["indices"][index])
     atoms_copy.set_positions(parsed_output["generic"]["positions"][index])
     atoms_copy.set_velocities(parsed_output["generic"]["velocities"][index])
-    atoms_copy.set_cell(parsed_output["generic"]["cells"][index])
     atoms_copy.set_pbc(True)
     if wrap:
         atoms_copy.wrap()

{lammpsparser-0.0.6 → lammpsparser-0.0.8}/src/lammpsparser/compatibility/structure.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from collections import OrderedDict
-from typing import Dict, Optional
+from typing import cast
 
 import numpy as np
 from ase.atoms import Atoms
@@ -12,15 +14,15 @@ from lammpsparser.structure import LammpsStructure
 class LammpsStructureCompatibility(LammpsStructure):
     def __init__(
         self,
-        bond_dict: Optional[Dict] = None,
+        bond_dict: dict | None = None,
         units: str = "metal",
         atom_type: str = "atomic",
     ):
         super().__init__(bond_dict=bond_dict, units=units, atom_type=atom_type)
-        self._molecule_ids: list[int] = []
+        self._molecule_ids: list[int] | None = []
 
     @property
-    def structure(self) -> Optional[Atoms]:
+    def structure(self) -> Atoms | None:
         """The ASE :class:`~ase.atoms.Atoms` object associated with this instance."""
         return self._structure
 
@@ -37,17 +39,28 @@ class LammpsStructureCompatibility(LammpsStructure):
             structure (ase.atoms.Atoms): The structure to serialise.
         """
         self._structure = structure
-        if self.atom_type == "full":
+        if self._atom_type == "full":
             input_str = self.structure_full()
-        elif self.atom_type == "bond":
+        elif self._atom_type == "bond":
             input_str = self.structure_bond()
-        elif self.atom_type == "charge":
+        elif self._atom_type == "charge":
             input_str = self.structure_charge()
-        else:  # self.atom_type == 'atomic'
+        else:  # self._atom_type == 'atomic'
             input_str = self.structure_atomic()
 
         self._string_input = input_str + self._get_velocities_input_string()
 
+    @property
+    def molecule_ids(self) -> list[int] | np.ndarray:
+        """Per-atom molecule IDs; defaults to all atoms in a single molecule."""
+        if self._molecule_ids is None or len(self._molecule_ids) == 0:
+            return np.ones(len(cast(Atoms, self._structure)), dtype=int)
+        return self._molecule_ids
+
+    @molecule_ids.setter
+    def molecule_ids(self, molecule_ids: list[int] | None):
+        self._molecule_ids = molecule_ids
+
     def structure_bond(self):
         """
         Serialise the structure for LAMMPS ``atom_style bond``.
@@ -120,7 +133,7 @@ class LammpsStructureCompatibility(LammpsStructure):
                 bond_type[i, j] = count
                 bond_type[j, i] = count
 
-        if self.structure.bonds is None:
+        if getattr(self.structure, "bonds", None) is None:
             if self.cutoff_radius is None:
                 bonds_lst = get_bonds(structure=self.structure, max_shells=1)
             else:
@@ -143,9 +156,7 @@ class LammpsStructureCompatibility(LammpsStructure):
 
         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"
-            )
+            bonds_str += f"{i_bond + 1:d} {b_type:d} {i_a:d} {i_b:d}" + "\n"
 
         return (
             self.lammps_header(
@@ -182,17 +193,23 @@ class LammpsStructureCompatibility(LammpsStructure):
         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())
-        }
+        if self.potential is not None:
+            q_dict = {
+                species_name: self.potential.get_charge(species_name)
+                for species_name in set(self.structure.get_chemical_symbols())
+            }
+        else:
+            q_dict = {
+                species_name: 0.0
+                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()
+        if self._bond_dict is not None and len(self._bond_dict.keys()) > 0:
+            cutoff_list = []
             for val in self._bond_dict.values():
                 cutoff_list.append(np.max(val["cutoff_list"]))
             max_cutoff = np.max(cutoff_list)
@@ -205,45 +222,42 @@ class LammpsStructureCompatibility(LammpsStructure):
             # 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
+                if el_1_list is not None and 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
                             )
-                            cutoff_dist = val["cutoff_list"][i]
-                            for j, ind in enumerate(
-                                np.array(neighbors.indices, dtype=object)[el_1_list]
+                            act_ind = ind[bool_1]
+                            bool_2 = np.isin(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
                             ):
-                                # 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
+                                angles_lst.append(
+                                    [final_ind[0] + 1, id_el + 1, final_ind[1] + 1]
                                 )
-                                act_ind = ind[bool_1]
-                                bool_2 = np.isin(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)
+                                angle_type_lst.append(angle_type)
 
         if len(bond_type_lst) == 0:
             num_bond_types = 0
@@ -277,9 +291,7 @@ class LammpsStructureCompatibility(LammpsStructure):
             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]
-                    )
+                    f"{i_bond + 1:d} {bond_type_lst[i_bond]:d} {id_vec[0]:d} {id_vec[1]:d}"
                     + "\n"
                 )
         else:
@@ -289,13 +301,7 @@ class LammpsStructureCompatibility(LammpsStructure):
             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],
-                    )
+                    f"{i_angle + 1:d} {angle_type_lst[i_angle]:d} {id_vec[0]:d} {id_vec[1]:d} {id_vec[2]:d}"
                     + "\n"
                 )
         else:
@@ -350,7 +356,6 @@ def get_bonds(
         tolerance=2,
         id_list=None,
         width_buffer=1.2,
-        allow_ragged=None,
         mode="ragged",
         norm_order=2,
     )