pyiron-workflow-atomistics 0.0.3__tar.gz

pyiron_workflow_atomistics-0.0.3/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Max-Planck-Institut für Nachhaltige Materialien GmbH - Computational Materials Design (CM) Department
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pyiron_workflow_atomistics-0.0.3/MANIFEST.in

@@ -0,0 +1,6 @@
+include LICENSE
+include versioneer.py
+include docs/README.md
+include pyproject.toml
+include pyiron_workflow_atomistics/_version.py
+recursive-include pyiron_workflow_atomistics *.py

pyiron_workflow_atomistics-0.0.3/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: pyiron_workflow_atomistics
+Version: 0.0.3
+Summary: A pyiron module for atomistic simulation workflows
+Author-email: pyiron team <pyiron@mpie.de>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2024, Max-Planck-Institut für Nachhaltige Materialien GmbH - Computational Materials Design (CM) Department
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        * Redistributions of source code must retain the above copyright notice, this
+          list of conditions and the following disclaimer.
+        
+        * Redistributions in binary form must reproduce the above copyright notice,
+          this list of conditions and the following disclaimer in the documentation
+          and/or other materials provided with the distribution.
+        
+        * Neither the name of the copyright holder nor the names of its
+          contributors may be used to endorse or promote products derived from
+          this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Homepage, https://pyiron.org/
+Project-URL: Documentation, https://pyiron_workflow_atomistics.readthedocs.io
+Project-URL: Repository, https://github.com/pyiron/pyiron_workflow_atomistics
+Keywords: pyiron,atomistics,workflow
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Scientific/Engineering
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Intended Audience :: Science/Research
+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
+Requires-Python: <3.14,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<1.27.0,>=1.22.0
+Requires-Dist: pandas<2.4.0,>=1.3.0
+Requires-Dist: matplotlib<3.11.0,>=3.10.6
+Requires-Dist: ase<3.27.0,>=3.21.0
+Requires-Dist: scipy<1.17.0,>=1.4.0
+Requires-Dist: pyiron-workflow<=0.15.2,>=0.14.1
+Requires-Dist: pymatgen<2025.7.0,>=2024.8.8
+Requires-Dist: pyiron_snippets<=0.2.0,>=0.1.0
+Requires-Dist: scikit-learn<1.8.0,>=1.0.0
+Dynamic: license-file
+
+# pyiron_workflow_atomistics
+
+## Overview
+
+This repository contains a pyiron module for atomistic simulation workflows, providing tools and utilities for working with atomic structures, grain boundaries, and various atomistic calculations.
+
+## Features
+
+- **Grain Boundary Analysis**: Tools for analyzing and manipulating grain boundaries, including:
+  - GB plane detection and analysis
+  - Cleavage plane identification
+  - Structure manipulation for GB studies
+
+- **Structure Manipulation**: Utilities for working with atomic structures:
+  - Bulk structure handling
+  - Structure featurization
+  - Calculator integration
+
+- **Workflow Integration**: Seamless integration with pyiron workflow system for:
+  - Automated structure calculations
+  - Data processing and analysis
+  - Results visualization
+
+## Installation
+
+The package can be installed via pip:
+
+```bash
+pip install pyiron_workflow_atomistics
+```
+
+Or via conda:
+
+```bash
+conda install -c conda-forge pyiron_workflow_atomistics
+```
+
+## Dependencies
+
+The package requires:
+- Python >= 3.9, < 3.13
+- numpy < 2.0.0
+- pandas >= 1.3.0
+- matplotlib >= 3.4.0
+- ase >= 3.22.0
+- scipy >= 1.7.0
+- pyiron_workflow
+- pymatgen >= 2024.8.8
+- pyiron_snippets
+- scikit-learn >= 1.0.0
+
+## Usage
+
+### Grain Boundary Analysis
+
+```python
+from pyiron_workflow_atomistics.gb.analysis import find_GB_plane
+from pyiron_workflow_atomistics.gb.cleavage import cleave_gb_structure
+
+# Find GB plane in a structure
+gb_info = find_GB_plane(atoms, featuriser, axis="c")
+
+# Cleave structure at GB
+cleaved_structures, cleavage_planes = cleave_gb_structure(
+    base_structure=atoms,
+    axis_to_cleave="c",
+    target_coord=target_coord
+)
+```
+
+### Structure Calculations
+
+```python
+from pyiron_workflow_atomistics.calculator import calculate_structure_node
+
+# Run structure calculations
+results = calculate_structure_node(
+    structure=atoms,
+    calc=calculator,
+    output_dir="calculations"
+)
+```
+
+## Documentation
+
+For detailed documentation, visit our [ReadTheDocs page](https://pyiron_workflow_atomistics.readthedocs.io).
+
+## Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.rst) for details.
+
+## License
+
+This project is licensed under the BSD License - see the [LICENSE](LICENSE) file for details.
+
+## Citation
+
+If you use this package in your research, please cite:
+
+```bibtex
+@software{pyiron_workflow_atomistics,
+  author = {pyiron team},
+  title = {pyiron_workflow_atomistics},
+  year = {2024},
+  url = {https://github.com/pyiron/pyiron_workflow_atomistics}
+}
+```

pyiron_workflow_atomistics-0.0.3/docs/README.md

@@ -0,0 +1,107 @@
+# pyiron_workflow_atomistics
+
+## Overview
+
+This repository contains a pyiron module for atomistic simulation workflows, providing tools and utilities for working with atomic structures, grain boundaries, and various atomistic calculations.
+
+## Features
+
+- **Grain Boundary Analysis**: Tools for analyzing and manipulating grain boundaries, including:
+  - GB plane detection and analysis
+  - Cleavage plane identification
+  - Structure manipulation for GB studies
+
+- **Structure Manipulation**: Utilities for working with atomic structures:
+  - Bulk structure handling
+  - Structure featurization
+  - Calculator integration
+
+- **Workflow Integration**: Seamless integration with pyiron workflow system for:
+  - Automated structure calculations
+  - Data processing and analysis
+  - Results visualization
+
+## Installation
+
+The package can be installed via pip:
+
+```bash
+pip install pyiron_workflow_atomistics
+```
+
+Or via conda:
+
+```bash
+conda install -c conda-forge pyiron_workflow_atomistics
+```
+
+## Dependencies
+
+The package requires:
+- Python >= 3.9, < 3.13
+- numpy < 2.0.0
+- pandas >= 1.3.0
+- matplotlib >= 3.4.0
+- ase >= 3.22.0
+- scipy >= 1.7.0
+- pyiron_workflow
+- pymatgen >= 2024.8.8
+- pyiron_snippets
+- scikit-learn >= 1.0.0
+
+## Usage
+
+### Grain Boundary Analysis
+
+```python
+from pyiron_workflow_atomistics.gb.analysis import find_GB_plane
+from pyiron_workflow_atomistics.gb.cleavage import cleave_gb_structure
+
+# Find GB plane in a structure
+gb_info = find_GB_plane(atoms, featuriser, axis="c")
+
+# Cleave structure at GB
+cleaved_structures, cleavage_planes = cleave_gb_structure(
+    base_structure=atoms,
+    axis_to_cleave="c",
+    target_coord=target_coord
+)
+```
+
+### Structure Calculations
+
+```python
+from pyiron_workflow_atomistics.calculator import calculate_structure_node
+
+# Run structure calculations
+results = calculate_structure_node(
+    structure=atoms,
+    calc=calculator,
+    output_dir="calculations"
+)
+```
+
+## Documentation
+
+For detailed documentation, visit our [ReadTheDocs page](https://pyiron_workflow_atomistics.readthedocs.io).
+
+## Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.rst) for details.
+
+## License
+
+This project is licensed under the BSD License - see the [LICENSE](LICENSE) file for details.
+
+## Citation
+
+If you use this package in your research, please cite:
+
+```bibtex
+@software{pyiron_workflow_atomistics,
+  author = {pyiron team},
+  title = {pyiron_workflow_atomistics},
+  year = {2024},
+  url = {https://github.com/pyiron/pyiron_workflow_atomistics}
+}
+```

pyiron_workflow_atomistics-0.0.3/pyiron_workflow_atomistics/__init__.py

@@ -0,0 +1,6 @@
+from . import _version
+
+__version__ = _version.get_versions()["version"]
+
+from . import _version
+__version__ = _version.get_versions()['version']

pyiron_workflow_atomistics-0.0.3/pyiron_workflow_atomistics/_version.py

@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.29) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2025-11-02T19:31:27+0100",
+ "dirty": true,
+ "error": null,
+ "full-revisionid": "bf2c5ea91d7e3cb7e01fdd83c155d02a8961f49d",
+ "version": "0.0.3"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

pyiron_workflow_atomistics-0.0.3/pyiron_workflow_atomistics/ase_calculator.py

@@ -0,0 +1,326 @@
+import json
+import os
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+import pyiron_workflow as pwf
+from ase import Atoms
+from ase.calculators.calculator import Calculator
+from ase.io import write as ase_write
+from ase.optimize import BFGS
+
+
+def ase_calc_structure(
+    structure: Atoms,
+    calc: Calculator,
+    optimizer_class=BFGS,
+    optimizer_kwargs: Optional[Dict[str, Any]] = None,
+    record_interval: int = 1,
+    fmax: float = 0.01,
+    max_steps: int = 10000,
+    properties: Tuple[str, ...] = ("energy", "forces", "stresses", "volume"),
+    write_to_disk: bool = False,
+    working_directory: str = "calc_output",
+    initial_struct_path: Optional[str] = "initial_structure.xyz",
+    initial_results_path: Optional[str] = "initial_results.json",
+    traj_struct_path: Optional[str] = "trajectory.xyz",
+    traj_results_path: Optional[str] = "trajectory_results.json",
+    final_struct_path: Optional[str] = "final_structure.xyz",
+    final_results_path: Optional[str] = "final_results.json",
+    data_pickle: str = "job_data.pkl.gz",
+) -> Dict[str, Any]:
+    """
+    Relax an ASE Atoms object with a customizable optimizer and recording interval,
+    attach properties to each snapshot and write extended XYZ,
+    and store trajectory data as a pickled DataFrame including structures.
+
+    Returns
+    -------
+    dict with keys:
+      - initial: {{structure, results}}
+      - trajectory: list of {{structure, results}}
+      - final: {{structure, results}}
+      - converged: bool
+    """
+    # Setup
+    props = [p.strip() for p in properties]
+    os.makedirs(working_directory, exist_ok=True)
+    optimizer_kwargs = optimizer_kwargs or {}
+
+    def gather(atoms: Atoms) -> Dict[str, Any]:
+        all_results: Dict[str, Any] = {
+            "energy": atoms.get_potential_energy(),
+            "forces": atoms.get_forces().tolist(),
+            "cell": atoms.get_cell().tolist(),
+            "volume": atoms.get_volume(),
+            "positions": atoms.get_positions().tolist(),
+            "numbers": atoms.get_atomic_numbers().tolist(),
+            "masses": atoms.get_masses().tolist(),
+        }
+        if "stresses" in props:
+            try:
+                all_results["stresses"] = atoms.get_stress().tolist()
+            except Exception:
+                pass
+        mapping = {
+            "charges": "get_charges",
+            "dipole": "get_dipole_moment",
+            "magmoms": "get_magnetic_moments",
+            "virial": "get_virial",
+            "pressure": "get_pressure",
+        }
+        for key, method in mapping.items():
+            if key in props:
+                try:
+                    val = getattr(atoms, method)()
+                    all_results[key] = val.tolist() if hasattr(val, "tolist") else val
+                except Exception:
+                    pass
+        missing = [p for p in props if p not in all_results]
+        if missing:
+            raise KeyError(f"Requested properties not available: {missing}")
+        return {p: all_results[p] for p in props}
+
+    def attach_props(atoms: Atoms, results: Dict[str, Any]):
+        # Attach energy
+        if "energy" in results:
+            atoms.info["energy"] = results["energy"]
+        # Attach forces
+        if "forces" in results:
+            atoms.set_array("forces", np.array(results["forces"]))
+        # Attach stresses
+        if "stresses" in results:
+            atoms.info["stresses"] = results["stresses"]
+        return atoms
+
+    atoms = structure.copy()
+    atoms.calc = calc
+
+    # Initial snapshot
+    initial_res = gather(atoms)
+    initial_atoms = attach_props(atoms.copy(), initial_res)
+    initial = {"structure": initial_atoms, "results": initial_res}
+    if write_to_disk and initial_struct_path:
+        ase_write(os.path.join(working_directory, initial_struct_path), initial_atoms)
+    if write_to_disk and initial_results_path:
+        with open(os.path.join(working_directory, initial_results_path), "w") as f:
+            json.dump(initial_res, f, indent=2)
+
+    # Trajectory recording
+    trajectory: List[Dict[str, Any]] = []
+
+    def record_step():
+        snap = atoms.copy()
+        snap_res = gather(atoms)
+        snap_att = attach_props(snap, snap_res)
+        trajectory.append({"structure": snap_att, "results": snap_res})
+        if write_to_disk and traj_struct_path:
+            ase_write(
+                os.path.join(working_directory, traj_struct_path), snap_att, append=True
+            )
+
+    # Optimize
+    optimizer = optimizer_class(atoms, **optimizer_kwargs)
+    optimizer.attach(record_step, interval=record_interval)
+    converged = optimizer.run(fmax=fmax, steps=max_steps)
+
+    # Write trajectory results JSON
+    if write_to_disk and traj_results_path:
+        traj_res_list = [step["results"] for step in trajectory]
+        with open(os.path.join(working_directory, traj_results_path), "w") as f:
+            json.dump(traj_res_list, f, indent=2)
+
+    # Final snapshot
+    final_res = gather(atoms)
+    final_atoms = attach_props(atoms.copy(), final_res)
+    # print(final_res)
+    final = {"structure": final_atoms, "results": final_res}
+    if write_to_disk and final_struct_path:
+        ase_write(os.path.join(working_directory, final_struct_path), final_atoms)
+    if write_to_disk and final_results_path:
+        with open(os.path.join(working_directory, final_results_path), "w") as f:
+            json.dump(final_res, f, indent=2)
+
+    # Build DataFrame including structures
+    df = pd.DataFrame(
+        [{"structure": step["structure"], **step["results"]} for step in trajectory]
+    )
+    df.to_pickle(os.path.join(working_directory, data_pickle), compression="gzip")
+
+    return {
+        "initial": initial,
+        "trajectory": trajectory,
+        "final": final,
+        "converged": bool(converged),
+    }
+
+
+def ase_calculate_structure_node_interface(
+    structure: Atoms,
+    calc: Calculator,
+    optimizer_class=BFGS,
+    optimizer_kwargs: dict[str, Any] | None = None,
+    record_interval: int = 1,
+    fmax: float = 0.01,
+    max_steps: int = 10000,
+    properties: Tuple[str, ...] = ("energy", "forces", "stresses"),
+    write_to_disk: bool = False,
+    working_directory: str = "calc_output",
+    initial_struct_path: Optional[str] = "initial_structure.xyz",
+    initial_results_path: Optional[str] = "initial_results.json",
+    traj_struct_path: Optional[str] = "trajectory.xyz",
+    traj_results_path: Optional[str] = "trajectory_results.json",
+    final_struct_path: Optional[str] = "final_structure.xyz",
+    final_results_path: Optional[str] = "final_results.json",
+    data_pickle: str = "job_data.pkl.gz",
+    calc_structure_fn: Callable[..., Any] = ase_calc_structure,
+) -> Tuple[Atoms, Dict[str, Any], bool]:
+    """
+    Node wrapper to call calc_structure_fn (default: ase_calc_structure)
+    with all ASE kwargs forwarded from node inputs.
+    """
+    out = calc_structure_fn(
+        structure=structure,
+        calc=calc,
+        optimizer_class=optimizer_class,
+        optimizer_kwargs=optimizer_kwargs,
+        record_interval=record_interval,
+        fmax=fmax,
+        max_steps=max_steps,
+        properties=properties,
+        write_to_disk=write_to_disk,
+        working_directory=working_directory,
+        initial_struct_path=initial_struct_path,
+        initial_results_path=initial_results_path,
+        traj_struct_path=traj_struct_path,
+        traj_results_path=traj_results_path,
+        final_struct_path=final_struct_path,
+        final_results_path=final_results_path,
+        data_pickle=data_pickle,
+    )
+    atoms = out["final"]["structure"]
+    final_results = out["final"]["results"]
+    converged = out["converged"]
+    converged = bool(converged)
+    # print(atoms, final_results, converged)
+    return atoms, final_results, converged
+
+
+@pwf.as_function_node("atoms", "results", "converged")
+def calculate_structure_node(
+    structure: Atoms,
+    # calc_structure_fn: Callable[..., Any] = ase_calculate_structure_node_interface,
+    calc_structure_fn=ase_calculate_structure_node_interface,
+    calc_structure_fn_kwargs: dict[str, Any] | None = None,
+) -> Tuple[Atoms, dict[str, Any], bool]:
+    if calc_structure_fn_kwargs is None:
+        calc_structure_fn_kwargs = {}
+    atoms, final_results, converged = calc_structure_fn(
+        structure=structure, **calc_structure_fn_kwargs
+    )
+    # print(calc_structure_fn_kwargs["working_directory"])
+    return atoms, final_results, converged
+
+
+@pwf.as_function_node("output")
+def extract_values(results_list, key):
+    """
+    Extract a list of values for a specified key from a list of result dictionaries.
+
+    Parameters
+    ----------
+    results_list : list of dict
+        Each dict should contain the specified key.
+    key : str
+        The dictionary key to extract values for (e.g., 'energy', 'volume').
+
+    Returns
+    -------
+    values : list
+        List of values corresponding to key from each dict.
+
+    Raises
+    ------
+    KeyError
+        If any entry in results_list is missing the specified key.
+    """
+    try:
+        extracted_values = [entry[key] for entry in results_list]
+    except Exception as e:
+        # print(results_list, key)
+        print(f"Error {e} when trying to parse output")
+        extracted_values = np.nan
+    return extracted_values
+
+
+@pwf.as_function_node("full_calc_kwargs2")
+def fillin_default_calckwargs(
+    calc_kwargs: dict[str, Any],
+    default_values: dict[str, Any] | None | str = None,
+    remove_keys: list[str] | None = None,
+) -> dict[str, Any]:
+    # 1) overlay any user-supplied default overrides
+    built_in = {}
+    if isinstance(default_values, dict):
+        built_in.update(default_values)
+
+    # 2) start with everything user passed in
+    full: dict[str, Any] = dict(calc_kwargs)
+
+    # 3) fill in missing built-ins
+    for key, default in built_in.items():
+        full.setdefault(key, default)
+
+    # 4) ensure properties is a tuple
+    if "properties" in full:
+        full["properties"] = tuple(full["properties"])
+
+    # 5) remove any keys requested
+    if remove_keys:
+        for key in remove_keys:
+            full.pop(key, None)
+
+    return full
+
+
+@pwf.as_function_node("kwargs_variant")
+def generate_kwargs_variant(
+    base_kwargs: dict[str, Any],
+    key: str,
+    value: Any,
+):
+    from copy import deepcopy
+
+    kwargs_variant = deepcopy(base_kwargs)
+    kwargs_variant[key] = value
+    return kwargs_variant
+
+
+@pwf.as_function_node("kwargs_variants")
+def generate_kwargs_variants(
+    base_kwargs: dict[str, Any],
+    key: str,
+    values: list[Any],
+):
+    """
+    Given a base kwargs dict, produce one dict per value in `values`,
+    each with `key` set to that value (overriding any existing entry).
+
+    Parameters
+    ----------
+    base_kwargs
+        The original kwargs to copy.
+    key
+        The dict key whose value you want to vary.
+    values
+        A list of values to assign to `key`.
+
+    Returns
+    -------
+    List of dicts
+        Each is a shallow copy of base_kwargs with base_kwargs[key] = value.
+    """
+    return_kwargs = [{**base_kwargs, key: v} for v in values]
+    # print(return_kwargs)
+    return return_kwargs