vitrum 1.0.0__tar.gz

vitrum-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 R-Chr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vitrum-1.0.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include src/vitrum *.csv

vitrum-1.0.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: vitrum
+Version: 1.0.0
+Summary: vitrum is a package for generating input data and analyzing simulation data of glass structures
+Author-email: Rasmus Christensen <rasmus.christensen.a1@tohoku.ac.jp>
+License: MIT
+Project-URL: Homepage, https://github.com/R-Chr/vitrum
+Project-URL: Repository, https://github.com/R-Chr/vitrum
+Project-URL: Documentation, https://vitrum.readthedocs.io/en/latest/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+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: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: ase
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Requires-Dist: pymatgen
+Requires-Dist: ruamel-yaml==0.17.9
+Requires-Dist: numba
+Requires-Dist: matplotlib
+Provides-Extra: workflows
+Requires-Dist: fireworks; extra == "workflows"
+Requires-Dist: jobflow; extra == "workflows"
+Requires-Dist: atomate2; extra == "workflows"
+Provides-Extra: volume-estimation
+Requires-Dist: atomate2; extra == "volume-estimation"
+Requires-Dist: mp_api; extra == "volume-estimation"
+Provides-Extra: persistent-homology
+Requires-Dist: dionysus; extra == "persistent-homology"
+Dynamic: license-file
+
+# ⚗️ vitrum
+
+**vitrum** is a Python package designed for the generation, analysis, and simulation of disordered and glassy atomic structures. It provides a comprehensive suite of tools for structural characterization, diffusion analysis, and tools for machine learning-driven potential development.
+
+## 🚧 Active development
+vitrum is under active development. As of 1.0, the public API follows [semantic versioning](https://semver.org/) — breaking changes will be reflected in a major version bump and noted in the [changelog](CHANGELOG.md).
+
+## 📖 Documentation
+Please see the `docs` folder for detailed documentation or check the [online documentation](https://vitrum.readthedocs.io/en/latest/).
+
+## 📦 Installation
+
+To install `vitrum`, you can clone the repository and install it in editable mode:
+
+```bash
+git clone https://github.com/R-Chr/vitrum.git
+cd vitrum
+pip install -e .
+```
+
+To install dependencies for simulation workflows (atomate2, fireworks, jobflow):
+
+```bash
+pip install -e .[workflows]
+```
+
+## 🚀 Examples
+See the [`examples`](examples/) folder for runnable Jupyter notebooks demonstrating scattering/RDF analysis, Qn speciation, and random structure generation, among others.
+
+## 🎯 Scope and Functionality
+
+`vitrum` offers:
+
+### 1. Structural Characterization
+*   **Scattering Functions**: Calculate partial and total Radial Distribution Functions (RDF) and Structure Factors ($S(q)$) for both Neutron and X-ray scattering (`vitrum.scattering`).
+*   **Ring Analysis**: Analyze ring size distributions and statistics in network glasses (`vitrum.rings`).
+*   **Topological Analysis**: Compute persistent homology to identify medium-range order and topological features (`vitrum.persistent_homology`).
+*   **Coordination & Angles**: Analyze bond angle distributions and coordination environments (`vitrum.coordination`).
+
+### 2. Dynamics & Diffusion
+*   **Diffusion Analysis**: Calculate Mean Squared Displacement (MSD), diffusion coefficients, and Van Hove correlation functions (`vitrum.diffusion`).
+
+### 3. Machine Learning & Workflows
+*   **BALACE Framework**: A Batch Active Learning framework for Atomistic Simulations (`vitrum.batch_active`) (requires `workflows` dependencies).
+    *   Automated workflow for training Machine Learning Interatomic Potentials (MLIPs) based on ACE .
+    *   Integration with VASP and LAMMPS for data generation and active learning loops.
+    *   Job management via Fireworks and Jobflow.
+
+
+## 👥 Author
+Rasmus Christensen (rasmusc@bio.aau.dk)
+
+## ⭐ Acknowledgements
+`vitrum` relies on several powerful open-source packages:
+*   [ASE](https://wiki.fysik.dtu.dk/ase/)
+*   [Pymatgen](https://pymatgen.org/)
+*   [NumPy](https://numpy.org/) / [SciPy](https://scipy.org/) / [pandas](https://pandas.pydata.org/)
+*   [scikit-learn](https://scikit-learn.org/)
+*   [Dionysus](https://mrzv.org/software/dionysus2/) / [DioDe](https://github.com/mrzv/diode)
+*   [Atomate2](https://github.com/materialsproject/atomate2) / [Jobflow](https://materialsproject.github.io/jobflow/) / [Fireworks](https://materialsproject.github.io/fireworks/)

vitrum-1.0.0/README.md

@@ -0,0 +1,60 @@
+# ⚗️ vitrum
+
+**vitrum** is a Python package designed for the generation, analysis, and simulation of disordered and glassy atomic structures. It provides a comprehensive suite of tools for structural characterization, diffusion analysis, and tools for machine learning-driven potential development.
+
+## 🚧 Active development
+vitrum is under active development. As of 1.0, the public API follows [semantic versioning](https://semver.org/) — breaking changes will be reflected in a major version bump and noted in the [changelog](CHANGELOG.md).
+
+## 📖 Documentation
+Please see the `docs` folder for detailed documentation or check the [online documentation](https://vitrum.readthedocs.io/en/latest/).
+
+## 📦 Installation
+
+To install `vitrum`, you can clone the repository and install it in editable mode:
+
+```bash
+git clone https://github.com/R-Chr/vitrum.git
+cd vitrum
+pip install -e .
+```
+
+To install dependencies for simulation workflows (atomate2, fireworks, jobflow):
+
+```bash
+pip install -e .[workflows]
+```
+
+## 🚀 Examples
+See the [`examples`](examples/) folder for runnable Jupyter notebooks demonstrating scattering/RDF analysis, Qn speciation, and random structure generation, among others.
+
+## 🎯 Scope and Functionality
+
+`vitrum` offers:
+
+### 1. Structural Characterization
+*   **Scattering Functions**: Calculate partial and total Radial Distribution Functions (RDF) and Structure Factors ($S(q)$) for both Neutron and X-ray scattering (`vitrum.scattering`).
+*   **Ring Analysis**: Analyze ring size distributions and statistics in network glasses (`vitrum.rings`).
+*   **Topological Analysis**: Compute persistent homology to identify medium-range order and topological features (`vitrum.persistent_homology`).
+*   **Coordination & Angles**: Analyze bond angle distributions and coordination environments (`vitrum.coordination`).
+
+### 2. Dynamics & Diffusion
+*   **Diffusion Analysis**: Calculate Mean Squared Displacement (MSD), diffusion coefficients, and Van Hove correlation functions (`vitrum.diffusion`).
+
+### 3. Machine Learning & Workflows
+*   **BALACE Framework**: A Batch Active Learning framework for Atomistic Simulations (`vitrum.batch_active`) (requires `workflows` dependencies).
+    *   Automated workflow for training Machine Learning Interatomic Potentials (MLIPs) based on ACE .
+    *   Integration with VASP and LAMMPS for data generation and active learning loops.
+    *   Job management via Fireworks and Jobflow.
+
+
+## 👥 Author
+Rasmus Christensen (rasmusc@bio.aau.dk)
+
+## ⭐ Acknowledgements
+`vitrum` relies on several powerful open-source packages:
+*   [ASE](https://wiki.fysik.dtu.dk/ase/)
+*   [Pymatgen](https://pymatgen.org/)
+*   [NumPy](https://numpy.org/) / [SciPy](https://scipy.org/) / [pandas](https://pandas.pydata.org/)
+*   [scikit-learn](https://scikit-learn.org/)
+*   [Dionysus](https://mrzv.org/software/dionysus2/) / [DioDe](https://github.com/mrzv/diode)
+*   [Atomate2](https://github.com/materialsproject/atomate2) / [Jobflow](https://materialsproject.github.io/jobflow/) / [Fireworks](https://materialsproject.github.io/fireworks/)

vitrum-1.0.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vitrum"
+description = "vitrum is a package for generating input data and analyzing simulation data of glass structures"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+    { name = "Rasmus Christensen", email = "rasmus.christensen.a1@tohoku.ac.jp" },
+]
+requires-python = ">=3.10"
+dynamic = ["version"]
+dependencies = [
+    "numpy",
+    "ase",
+    "pandas",
+    "scikit-learn",
+    "scipy",
+    "pymatgen",
+    "ruamel-yaml==0.17.9",
+    "numba",
+    "matplotlib",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Chemistry",
+]
+
+[project.urls]
+Homepage = "https://github.com/R-Chr/vitrum"
+Repository = "https://github.com/R-Chr/vitrum"
+Documentation = "https://vitrum.readthedocs.io/en/latest/"
+
+[project.optional-dependencies]
+workflows = ["fireworks", "jobflow", "atomate2"]
+volume_estimation = ["atomate2", "mp_api"]
+# diode (used by persistent_homology.py) is not a normal PyPI package;
+# see docs/vitrum/install.md for its manual install instructions.
+persistent_homology = ["dionysus"]
+
+[tool.setuptools.dynamic]
+version = { attr = "vitrum.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+vitrum = ["scattering_lengths.csv", "x_ray_scattering_factor_coefficients.csv"]

vitrum-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vitrum-1.0.0/src/vitrum/__init__.py

@@ -0,0 +1,15 @@
+from vitrum.glass_atoms import GlassAtoms
+from vitrum.coordination import Coordination
+from vitrum.diffusion import Diffusion
+from vitrum.rings import RingAnalysis
+from vitrum.scattering import Scattering
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "GlassAtoms",
+    "Coordination",
+    "Diffusion",
+    "RingAnalysis",
+    "Scattering",
+]

vitrum-1.0.0/src/vitrum/batch_active/database.py

@@ -0,0 +1,72 @@
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+
+
+def update_ace_database(
+    wd: str,
+    atoms: list,
+    iteration: int,
+    force_threshold: int = 100,
+    train_test_method: str = "composition",
+    train_test_fraction: float = 0.2,
+    database_paths=None,
+    metadata=None,
+):
+    """
+    Update the ACE database with new structures.
+
+    Parameters:
+        wd (str): Working directory.
+        atoms (list): List of ASE atoms objects.
+        iteration (int): Current iteration number.
+        force_threshold (int): Force threshold for filtering structures.
+        train_test_method (str): Method for splitting data into train and test sets.
+        train_test_split (float): Fraction of data to be used for testing.
+        database_paths (dict): Paths to the existing train and test databases.
+        metadata (str): Metadata for the structures.
+    """
+    energy = [i.get_total_energy() for i in atoms]
+    force = [i.get_forces().tolist() for i in atoms]
+    stress = [i.get_stress() for i in atoms]
+    data = {"energy": energy, "forces": force, "stress": stress, "ase_atoms": atoms, "iteration": iteration}
+    if metadata:
+        data["sample_type"] = metadata
+    # create a DataFrame
+    df = pd.DataFrame(data)
+    df["stress"] = df["stress"].apply(np.array)
+    print(f"Iteration {iteration} has {len(df)} structures")
+    df = df[~df["forces"].apply(lambda x: np.max(x) > force_threshold)]
+    df = df[~df["forces"].apply(lambda x: np.min(x) < -force_threshold)]
+    print(f"{len(df)} structures remain after force threshold filter")
+
+    if train_test_method == "random":
+        # Randomly split the data into train and test sets
+        df_new = train_test_split(df, test_size=train_test_fraction, random_state=42)
+
+    elif train_test_method == "composition":
+        # determine train/test split
+        composition_set = set()
+        for atoms in df["ase_atoms"]:
+            composition_set.add(atoms.get_chemical_formula())
+
+        # Choose a random sample of the unique compositions
+        composition_list = list(composition_set)
+        np.random.shuffle(composition_list)
+        test_comps = composition_list[: int(len(composition_list) * train_test_fraction)]
+        # Create a mask to filter the DataFrame
+        mask = df["ase_atoms"].apply(lambda atoms: atoms.get_chemical_formula() in test_comps)
+        # Filter the DataFrame
+        df_new = [df[~mask], df[mask]]
+
+    print(f"{len(df_new[0])} structures added to train set and {len(df_new[1])} structures added to test set")
+
+    if database_paths:
+        for ind, file in enumerate([database_paths["train"], database_paths["test"]]):
+            df_old = pd.read_pickle(file, compression="gzip")
+            df_concat = pd.concat([df_old] + [df_new[ind]])
+            df_concat.to_pickle(file, compression="gzip", protocol=4)
+    else:
+        df_new[0].to_pickle(f"{wd}/train_data.pckl.gzip", compression="gzip", protocol=4)
+        df_new[1].to_pickle(f"{wd}/test_data.pckl.gzip", compression="gzip", protocol=4)
+        return {"train": f"{wd}/train_data.pckl.gzip", "test": f"{wd}/test_data.pckl.gzip"}

vitrum-1.0.0/src/vitrum/batch_active/flows.py

@@ -0,0 +1,118 @@
+try:
+    from atomate2.vasp.jobs.core import StaticMaker
+    from atomate2.vasp.jobs.md import MDMaker
+    from atomate2.vasp.sets.core import StaticSetGenerator
+    from atomate2.vasp.sets.core import MDSetGenerator
+except ImportError:
+    raise ImportError("atomate2 is required for flows. Please install vitrum[batch_active].")
+from pymatgen.io.vasp import Kpoints
+
+
+def static_flow(structure, name=False, incar_settings={}, kpoint=False, potcar_functional="PBE_54"):
+    if not name:
+        name = structure.reduced_formula
+    num_atoms = len(structure)
+    incar_set = {
+        "EDIFF": (10**-5) * num_atoms,
+        "ENAUG": None,
+        "EDIFFG": None,
+        "ALGO": "Normal",
+        "ENCUT": 520,
+        "ISMEAR": 0,
+        "ISPIN": 1,  # Do not consider magnetism in AIMD simulations
+        "LREAL": "Auto",
+        "LAECHG": False,
+        "LASPH": True,
+        "LCHARG": False,
+        "GGA": None,  # Just let VASP decide based on POTCAR - the default PE
+        "LPLANE": False,  # LPLANE is recommended to be False on Cray machines
+        "LDAUPRINT": 0,
+        "ISIF": 2,
+        "SIGMA": 0.05,
+        "LVTOT": None,
+        "LMIXTAU": None,
+        "NELM": 200,
+        "PREC": "Normal",
+        "NCORE": 16,
+        "NSIM": 32,
+    }
+    incar_set.update(incar_settings)
+    if not kpoint:
+        kpoint = Kpoints()  # Gamma centered, 1x1x1 KPOINTS with no shift
+
+    run_vasp_kwargs = {"job_type": "direct"}
+
+    static_maker = StaticMaker(
+        name=name,
+        input_set_generator=StaticSetGenerator(
+            user_incar_settings=incar_set, user_kpoints_settings=kpoint, user_potcar_functional=potcar_functional
+        ),
+        run_vasp_kwargs=run_vasp_kwargs,
+    )
+
+    return static_maker.make(structure)
+
+
+def md_flow(
+    structure,
+    temperature=5000,
+    steps=100,
+    name=False,
+    timestep=1,
+    incar_settings={},
+    kpoint=False,
+    potcar_functional="PBE_54",
+):
+    if not name:
+        name = structure.reduced_formula
+    num_atoms = len(structure)
+
+    incar_set = {
+        "EDIFF": (10**-5) * num_atoms,
+        "ENAUG": None,
+        "EDIFFG": None,
+        "ALGO": "Normal",
+        "ENCUT": 520,
+        "ISMEAR": 0,
+        "ISPIN": 1,  # Do not consider magnetism in AIMD simulations
+        "LREAL": "Auto",
+        "LAECHG": False,
+        "LASPH": True,
+        "LCHARG": False,
+        "GGA": None,  # Just let VASP decide based on POTCAR - the default PE
+        "LPLANE": False,  # LPLANE is recommended to be False on Cray machines
+        "LDAUPRINT": 0,
+        "ISIF": 2,
+        "SIGMA": 0.05,
+        "LVTOT": None,
+        "LMIXTAU": None,
+        "NELM": 200,
+        "PREC": "Normal",
+        "NCORE": 16,
+        "NSIM": 32,
+    }
+
+    incar_set.update(incar_settings)
+
+    if not kpoint:
+        kpoint = Kpoints()  # Gamma centered, 1x1x1 KPOINTS with no shift
+
+    run_vasp_kwargs = {"job_type": "direct"}
+
+    aimd_maker = MDMaker(
+        name=name,
+        input_set_generator=MDSetGenerator(
+            ensemble="nvt",
+            start_temp=temperature,
+            end_temp=temperature,
+            nsteps=steps,
+            time_step=timestep,
+            # adapted from MPMorph settings
+            user_incar_settings=incar_set,
+            user_kpoints_settings=kpoint,
+            user_potcar_functional=potcar_functional,
+        ),
+        run_vasp_kwargs=run_vasp_kwargs,
+    )
+
+    return aimd_maker.make(structure)

vitrum-1.0.0/src/vitrum/batch_active/get_structures.py

@@ -0,0 +1,160 @@
+import shutil
+import subprocess
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from ase.io import read
+from pymatgen.io.ase import AseAtomsAdaptor
+
+from vitrum.io_helpers import correct_atom_types, get_LAMMPS_dump_timesteps
+
+
+def get_wflow_id_from_run_uuid(lp, run_uuid):
+    wf_ids = [
+        i
+        for i in lp.get_wf_ids()
+        if lp.workflows.find_one({"nodes": i}, projection=["metadata"]).get("metadata", {}).get("uuid") == run_uuid
+    ]
+    return wf_ids
+
+
+def get_atoms_from_wfs(lp, run_uuids, high_temp_params, sampling=":", state=None):
+    """
+    Reads all atoms from a workflow given by uuid and returns them.
+
+    Parameters:
+        run_uuids : list
+            list of uuids of the workflows to read from.
+        sampling : str or list or int, optional
+            If sampling is a string, it is interpreted as a slice string for numpy.
+            If it is an integer, it is interpreted as the number of samples to take.
+            If it is a list, it is interpreted as a list of indices to sample.
+            Defaults to ":".
+
+    Returns:
+        atoms: list
+            A list of ase atoms objects.
+    """
+    wf_ids = sum([get_wflow_id_from_run_uuid(lp, id) for id in run_uuids], [])
+    atoms = []
+    metadata = []
+
+    if state == "train_ace_high_temp":
+        sampling = high_temp_params["sampling"]
+    else:
+        sampling = sampling
+
+    for wf_id in wf_ids:
+        wf = lp.get_wf_by_fw_id(wf_id)
+        launch_dirs = [fw.launches[0].launch_dir if fw.launches else None for fw in wf.fws]
+        for dirs, fw in zip(launch_dirs, wf.fws):
+            if fw.state == "COMPLETED":
+                atoms_fw = read(f"{dirs}/OUTCAR.gz", format="vasp-out", index=":")
+                num_samples = len(atoms_fw)
+                if sampling == ":":
+                    atoms = atoms + atoms_fw
+                    num_samples = len(atoms_fw)
+                elif isinstance(sampling, int):
+                    sample_index = np.linspace(0, num_samples - 1, sampling, dtype=int)
+                    atoms = atoms + [atoms_fw[i] for i in sample_index]
+                    num_samples = len(sample_index)
+                elif isinstance(sampling, list):
+                    atoms = atoms + [atoms_fw[i] for i in sampling]
+                    num_samples = len(sampling)
+                metadata = metadata + [fw.spec["sample_type"]] * num_samples
+
+    return atoms, metadata
+
+
+def get_structures_from_lammps(
+    folder,
+    potential_folder,
+    atom_types,
+    potential,
+    pace_select=True,
+    force_glass_structures=True,
+    use_spaced_timesteps=False,
+    max_gamma_structures=500,
+):
+    select_files = []
+    forced_files = []
+
+    folder_path = Path(folder)
+    for dirpath in folder_path.rglob("*"):  # Recursively iterate over all directories/files
+        if dirpath.is_dir():  # Ensure it's a directory
+            for file in ["glass.dump", "gamma.dump"]:
+                file_path = dirpath / file  # Use pathlib's `/` operator to join paths
+                if file_path.exists():  # Check if file exists
+                    file_path_str = str(file_path)  # .replace(")", r"\)").replace("(", r"\(")
+
+                    if pace_select:
+                        if force_glass_structures:
+                            if file == "glass.dump":
+                                forced_files.append(file_path_str)
+                            else:
+                                select_files.append(file_path_str)
+                        else:
+                            select_files.append(file_path_str)
+                    else:
+                        forced_files.append(file_path_str)
+
+    gamma_file = f"{folder}/gamma_structures.dat"
+    with open(gamma_file, "wb") as wfd:
+        for f in select_files:
+            with open(f, "rb") as fd:
+                shutil.copyfileobj(fd, wfd)
+
+    atoms_selected = []
+    atoms_forced = []
+
+    if pace_select is True:
+        print("Running PACE select")
+        atoms_selected += select_structures(
+            potential_folder, atom_types, gamma_file, potential, num_select_structures=max_gamma_structures
+        )
+
+    for file_path in forced_files:
+        atoms = read(file_path, format="lammps-dump-text", index=":")
+        if len(atoms) == 0:
+            continue
+        symbol_change_map = {i + 1: x for i, x in enumerate(atom_types)}
+        atoms = correct_atom_types(atoms, symbol_change_map)
+
+        if use_spaced_timesteps is True:
+            timesteps = get_LAMMPS_dump_timesteps(file_path)
+            spaced_timesteps = [0]
+            for ind, time in enumerate(timesteps):
+                if time > timesteps[spaced_timesteps[-1]] + 100:
+                    spaced_timesteps.append(ind)
+            atoms_forced += [atoms[t] for t in spaced_timesteps]
+        else:
+            atoms_forced += atoms
+
+    print(f"Included {len(atoms_selected)} selected structures and {len(atoms_forced)} forced structures.")
+    metadata = ["gamma"] * len(atoms_selected) + ["manual"] * len(atoms_forced)
+    structures = [AseAtomsAdaptor().get_structure(atom) for atom in atoms_selected] + [
+        AseAtomsAdaptor().get_structure(atom) for atom in atoms_forced
+    ]
+
+    return structures, metadata
+
+
+def select_structures(folder, atom_types, gamma_file, potential, num_select_structures=500):
+    atom_string = " ".join([str(atom) for atom in atom_types])
+    if potential == "pace":
+        subprocess.run(
+            f"pace_select -p {folder}/output_potential.yaml -a "
+            f'{folder}/output_potential.asi -e "{atom_string}"'
+            f" -m {num_select_structures} {gamma_file}",
+            shell=True,
+        )
+    elif potential == "grace":
+        subprocess.run(
+            f"pace_select -p {folder}/FS_model.yaml"
+            f' -a {folder}/FS_model.asi -e "{atom_string}"'
+            f" -m {num_select_structures} {gamma_file}",
+            shell=True,
+        )
+    atoms = pd.read_pickle("selected.pkl.gz", compression="gzip")
+    return [structure for structure in atoms["ase_atoms"]]