atomistics 0.2.1__tar.gz → 0.2.2__tar.gz

{atomistics-0.2.1/atomistics.egg-info → atomistics-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: atomistics
-Version: 0.2.1
+Version: 0.2.2
 Summary: Interfaces for atomistic simulation codes and workflows
 Author-email: Jan Janssen <janssen@mpie.de>
 License: BSD 3-Clause License
@@ -53,7 +53,7 @@ Requires-Dist: numpy==1.26.4
 Requires-Dist: scipy<=1.15.2,>=1.11.1
 Requires-Dist: spglib<=2.5.0,>=2.0.2
 Provides-Extra: phonopy
-Requires-Dist: phonopy<=2.37.0,>=2.20.0; extra == "phonopy"
+Requires-Dist: phonopy<=2.38.0,>=2.20.0; extra == "phonopy"
 Requires-Dist: seekpath<=2.1.0,>=1.9.0; extra == "phonopy"
 Requires-Dist: structuretoolkit<=0.0.31,>=0.0.10; extra == "phonopy"
 Provides-Extra: gpaw
@@ -77,9 +77,11 @@ Requires-Dist: requests<=2.32.3,>=2.24.0; extra == "experimental"
 Provides-Extra: sphinxdft
 Requires-Dist: sphinx-parser==0.0.1; extra == "sphinxdft"
 Provides-Extra: qe
-Requires-Dist: pwtools==1.2.3; extra == "qe"
+Requires-Dist: pwtools==1.3.0; extra == "qe"
 Provides-Extra: tqdm
 Requires-Dist: tqdm==4.67.1; extra == "tqdm"
+Provides-Extra: vasp
+Requires-Dist: pyiron_vasp==0.2.4; extra == "vasp"
 
 # atomistics
 [![Pipeline](https://github.com/pyiron/atomistics/actions/workflows/pipeline.yml/badge.svg)](https://github.com/pyiron/atomistics/actions/workflows/pipeline.yml)

{atomistics-0.2.1 → atomistics-0.2.2}/atomistics/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-02-26T23:14:56+0100",
+ "date": "2025-03-05T08:13:01+0100",
  "dirty": true,
  "error": null,
- "full-revisionid": "66b638e04263084c998d140d01f3e866e0b5a8cf",
- "version": "0.2.1"
+ "full-revisionid": "5b518f33f60f904bf2c88dff51b72a07fe99091c",
+ "version": "0.2.2"
 }
 '''  # END VERSION_JSON
 

{atomistics-0.2.1 → atomistics-0.2.2}/atomistics/calculators/sphinxdft.py

@@ -5,6 +5,7 @@ import scipy.constants
 from ase.atoms import Atoms
 from sphinx_parser.ase import get_structure_group, id_spx_to_ase
 from sphinx_parser.input import sphinx
+from sphinx_parser.jobs import apply_minimization
 from sphinx_parser.output import collect_energy_dat, collect_eval_forces
 from sphinx_parser.potential import get_paw_from_structure
 from sphinx_parser.toolkit import to_sphinx
@@ -20,11 +21,10 @@ HARTREE_TO_EV = scipy.constants.physical_constants["Hartree energy in eV"][0]
 HARTREE_OVER_BOHR_TO_EV_OVER_ANGSTROM = HARTREE_TO_EV / BOHR_TO_ANGSTROM
 
 
-def _write_input(
+def _generate_input(
     structure: Atoms,
-    working_directory: str,
     maxSteps: int = 100,
-    eCut: float = 25.0,
+    energy_cutoff_in_eV: float = 500.0,
     kpoint_coords: Optional[list[float, float, float]] = None,
     kpoint_folding: Optional[list[int, int, int]] = None,
 ):
@@ -39,7 +39,7 @@ def _write_input(
     )
     pawPot_group = get_paw_from_structure(structure)
     basis_group = sphinx.basis.create(
-        eCut=eCut,
+        eCut=energy_cutoff_in_eV / HARTREE_TO_EV,
         kPoint=sphinx.basis.kPoint.create(coords=kpoint_coords),
         folding=kpoint_folding,
     )
@@ -50,7 +50,7 @@ def _write_input(
         ),
         rho=sphinx.initialGuess.rho.create(atomicOrbitals=True),
     )
-    input_sx = sphinx.create(
+    return sphinx.create(
         pawPot=pawPot_group,
         structure=struct_group,
         main=main_group,
@@ -58,8 +58,6 @@ def _write_input(
         PAWHamiltonian=paw_group,
         initialGuess=initial_guess_group,
     )
-    with open(os.path.join(working_directory, "input.sx"), "w") as f:
-        f.write(to_sphinx(input_sx))
 
 
 class OutputParser:
@@ -90,12 +88,54 @@ class OutputParser:
         raise NotImplementedError()
 
 
+def optimize_positions_with_sphinxdft(
+    structure: Atoms,
+    working_directory: str,
+    executable_function: callable,
+    max_electronic_steps: int = 100,
+    energy_cutoff_in_eV: float = 500.0,
+    mode: str = "linQN",
+    dEnergy: float = 1.0e-6,
+    max_ionic_steps: int = 50,
+    kpoint_coords: Optional[list[float, float, float]] = None,
+    kpoint_folding: Optional[list[int, int, int]] = None,
+) -> Atoms:
+    if kpoint_coords is None:
+        kpoint_coords = [0.5, 0.5, 0.5]
+    if kpoint_folding is None:
+        kpoint_folding = [3, 3, 3]
+    input_sx = _generate_input(
+        structure=structure,
+        maxSteps=max_electronic_steps,
+        energy_cutoff_in_eV=energy_cutoff_in_eV,
+        kpoint_coords=kpoint_coords,
+        kpoint_folding=kpoint_folding,
+    )
+    input_sx = apply_minimization(
+        sphinx_input=input_sx,
+        mode=mode,
+        dEnergy=dEnergy,
+        maxSteps=max_ionic_steps,
+    )
+    with open(os.path.join(working_directory, "input.sx"), "w") as f:
+        f.write(to_sphinx(input_sx))
+    executable_function(working_directory)
+    structure_copy = structure.copy()
+    structure_copy.positions = (
+        collect_eval_forces(os.path.join(working_directory, "relaxHist.sx"))[
+            "positions"
+        ][-1][id_spx_to_ase(structure)]
+        / BOHR_TO_ANGSTROM
+    )
+    return structure_copy
+
+
 def calc_static_with_sphinxdft(
     structure: Atoms,
     working_directory: str,
     executable_function: callable,
-    maxSteps: int = 100,
-    eCut: float = 25,
+    max_electronic_steps: int = 100,
+    energy_cutoff_in_eV: float = 500.0,
     kpoint_coords: Optional[list[float, float, float]] = None,
     kpoint_folding: Optional[list[int, int, int]] = None,
     output_keys=OutputStatic.keys(),
@@ -104,14 +144,15 @@ def calc_static_with_sphinxdft(
         kpoint_coords = [0.5, 0.5, 0.5]
     if kpoint_folding is None:
         kpoint_folding = [3, 3, 3]
-    _write_input(
+    input_sx = _generate_input(
         structure=structure,
-        working_directory=working_directory,
-        maxSteps=maxSteps,
-        eCut=eCut,
+        maxSteps=max_electronic_steps,
+        energy_cutoff_in_eV=energy_cutoff_in_eV,
         kpoint_coords=kpoint_coords,
         kpoint_folding=kpoint_folding,
     )
+    with open(os.path.join(working_directory, "input.sx"), "w") as f:
+        f.write(to_sphinx(input_sx))
     executable_function(working_directory)
     output_obj = OutputParser(working_directory=working_directory, structure=structure)
     result_dict = OutputStatic(
@@ -129,20 +170,37 @@ def evaluate_with_sphinx(
     tasks: list,
     working_directory: str,
     executable_function: callable,
-    maxSteps: int = 100,
-    eCut: float = 25,
+    max_electronic_steps: int = 100,
+    energy_cutoff_in_eV: float = 500,
     kpoint_coords: Optional[list[float, float, float]] = None,
     kpoint_folding: Optional[list[int, int, int]] = None,
+    sphinx_optimizer_kwargs: Optional[dict] = None,
 ) -> dict:
     if kpoint_coords is None:
         kpoint_coords = [0.5, 0.5, 0.5]
     if kpoint_folding is None:
         kpoint_folding = [3, 3, 3]
-    if "calc_energy" in tasks or "calc_forces" in tasks or "calc_stress" in tasks:
+    if sphinx_optimizer_kwargs is None:
+        sphinx_optimizer_kwargs = {}
+    results = {}
+    if "optimize_positions" in tasks:
+        results["structure_with_optimized_positions"] = (
+            optimize_positions_with_sphinxdft(
+                structure=structure,
+                max_electronic_steps=max_electronic_steps,
+                energy_cutoff_in_eV=energy_cutoff_in_eV,
+                kpoint_coords=kpoint_coords,
+                kpoint_folding=kpoint_folding,
+                working_directory=working_directory,
+                executable_function=executable_function,
+                **sphinx_optimizer_kwargs,
+            )
+        )
+    elif "calc_energy" in tasks or "calc_forces" in tasks or "calc_stress" in tasks:
         return calc_static_with_sphinxdft(
             structure=structure,
-            maxSteps=maxSteps,
-            eCut=eCut,
+            max_electronic_steps=max_electronic_steps,
+            energy_cutoff_in_eV=energy_cutoff_in_eV,
             kpoint_coords=kpoint_coords,
             kpoint_folding=kpoint_folding,
             working_directory=working_directory,
@@ -151,3 +209,4 @@ def evaluate_with_sphinx(
         )
     else:
         raise ValueError("The SphinxDFT calculator does not implement:", tasks)
+    return results

atomistics-0.2.2/atomistics/calculators/vasp.py

@@ -0,0 +1,219 @@
+import os
+from typing import Optional
+
+from ase.atoms import Atoms
+from ase.calculators.vasp.create_input import GenerateVaspInput
+from pyiron_vasp.vasp.output import parse_vasp_output
+
+from atomistics.calculators.interface import get_quantities_from_tasks
+from atomistics.calculators.wrapper import as_task_dict_evaluator
+from atomistics.shared.output import OutputStatic
+
+
+class OutputParser:
+    def __init__(self, working_directory, structure):
+        self._output_dict = parse_vasp_output(
+            working_directory=working_directory, structure=structure
+        )
+
+    def get_energy(self):
+        return self._output_dict["generic"]["energy_tot"][-1]
+
+    def get_forces(self):
+        return self._output_dict["generic"]["forces"][-1]
+
+    def get_volume(self):
+        return self._output_dict["generic"]["volume"][-1]
+
+    def get_stress(self):
+        return self._output_dict["generic"]["stresses"][-1]
+
+
+def write_input(working_directory, atoms, **kwargs):
+    vip = GenerateVaspInput()
+    vip.set(**kwargs)
+    vip.initialize(atoms=atoms)
+    os.makedirs(working_directory, exist_ok=True)
+    vip.write_input(atoms=atoms, directory=working_directory)
+
+
+def calc_static_with_vasp(
+    structure: Atoms,
+    working_directory: str,
+    executable_function: callable,
+    prec: str = "Accurate",
+    algo: str = "Fast",
+    lreal: bool = False,
+    lwave: bool = False,
+    lorbit: int = 0,
+    kpts: Optional[list[int, int, int]] = None,
+    output_keys: dict = OutputStatic.keys(),
+    **kwargs,
+) -> dict:
+    if kpts is None:
+        kpts = [4, 4, 4]
+    write_input(
+        working_directory=working_directory,
+        atoms=structure,
+        prec=prec,
+        algo=algo,
+        lreal=lreal,
+        lwave=lwave,
+        lorbit=lorbit,
+        kpts=kpts,
+        **kwargs,
+    )
+    executable_function(working_directory)
+    output_obj = OutputParser(working_directory=working_directory, structure=structure)
+    result_dict = OutputStatic(
+        forces=output_obj.get_forces,
+        energy=output_obj.get_energy,
+        stress=output_obj.get_stress,
+        volume=output_obj.get_volume,
+    ).get(output_keys=output_keys)
+    return result_dict
+
+
+def optimize_positions_with_vasp(
+    structure: Atoms,
+    working_directory: str,
+    executable_function: callable,
+    prec: str = "Accurate",
+    algo: str = "Fast",
+    lreal: bool = False,
+    lwave: bool = False,
+    lorbit: int = 0,
+    isif: int = 2,
+    ibrion: int = 2,
+    nsw: int = 100,
+    kpts: Optional[list[int, int, int]] = None,
+    **kwargs,
+) -> Atoms:
+    if kpts is None:
+        kpts = [4, 4, 4]
+    write_input(
+        working_directory=working_directory,
+        atoms=structure,
+        prec=prec,
+        algo=algo,
+        lreal=lreal,
+        lwave=lwave,
+        lorbit=lorbit,
+        kpts=kpts,
+        isif=isif,
+        ibrion=ibrion,
+        nsw=nsw,
+        **kwargs,
+    )
+    executable_function(working_directory)
+    output_dict = parse_vasp_output(
+        working_directory=working_directory, structure=structure
+    )
+    structure_copy = structure.copy()
+    structure_copy.positions = output_dict["generic"]["positions"][-1]
+    return structure_copy
+
+
+def optimize_positions_and_volume_with_vasp(
+    structure: Atoms,
+    working_directory: str,
+    executable_function: callable,
+    prec: str = "Accurate",
+    algo: str = "Fast",
+    lreal: bool = False,
+    lwave: bool = False,
+    lorbit: int = 0,
+    isif: int = 3,
+    ibrion: int = 2,
+    nsw: int = 100,
+    kpts: Optional[list[int, int, int]] = None,
+    **kwargs,
+) -> Atoms:
+    if kpts is None:
+        kpts = [4, 4, 4]
+    write_input(
+        working_directory=working_directory,
+        atoms=structure,
+        prec=prec,
+        algo=algo,
+        lreal=lreal,
+        lwave=lwave,
+        lorbit=lorbit,
+        kpts=kpts,
+        isif=isif,
+        ibrion=ibrion,
+        nsw=nsw,
+        **kwargs,
+    )
+    executable_function(working_directory)
+    output_dict = parse_vasp_output(
+        working_directory=working_directory, structure=structure
+    )
+    structure_copy = structure.copy()
+    structure_copy.set_cell(output_dict["generic"]["cells"][-1], scale_atoms=True)
+    structure_copy.positions = output_dict["generic"]["positions"][-1]
+    return structure_copy
+
+
+@as_task_dict_evaluator
+def evaluate_with_vasp(
+    structure: Atoms,
+    tasks: list,
+    working_directory: str,
+    executable_function: callable,
+    prec: str = "Accurate",
+    algo: str = "Fast",
+    lreal: bool = False,
+    lwave: bool = False,
+    lorbit: int = 0,
+    kpts: Optional[list[int, int, int]] = None,
+    **kwargs,
+) -> dict:
+    if kpts is None:
+        kpts = [4, 4, 4]
+    results = {}
+    if "optimize_positions_and_volume" in tasks:
+        results["structure_with_optimized_positions_and_volume"] = (
+            optimize_positions_and_volume_with_vasp(
+                structure=structure,
+                working_directory=working_directory,
+                executable_function=executable_function,
+                prec=prec,
+                algo=algo,
+                lreal=lreal,
+                lwave=lwave,
+                lorbit=lorbit,
+                kpts=kpts,
+                **kwargs,
+            )
+        )
+    elif "optimize_positions" in tasks:
+        results["structure_with_optimized_positions"] = optimize_positions_with_vasp(
+            structure=structure,
+            working_directory=working_directory,
+            executable_function=executable_function,
+            prec=prec,
+            algo=algo,
+            lreal=lreal,
+            lwave=lwave,
+            lorbit=lorbit,
+            kpts=kpts,
+            **kwargs,
+        )
+    elif "calc_energy" in tasks or "calc_forces" in tasks or "calc_stress" in tasks:
+        return calc_static_with_vasp(
+            structure=structure,
+            working_directory=working_directory,
+            executable_function=executable_function,
+            prec=prec,
+            algo=algo,
+            lreal=lreal,
+            lwave=lwave,
+            lorbit=lorbit,
+            kpts=kpts,
+            output_keys=get_quantities_from_tasks(tasks=tasks),
+            **kwargs,
+        )
+    else:
+        raise ValueError("The VASP calculator does not implement:", tasks)
+    return results

{atomistics-0.2.1 → atomistics-0.2.2/atomistics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: atomistics
-Version: 0.2.1
+Version: 0.2.2
 Summary: Interfaces for atomistic simulation codes and workflows
 Author-email: Jan Janssen <janssen@mpie.de>
 License: BSD 3-Clause License
@@ -53,7 +53,7 @@ Requires-Dist: numpy==1.26.4
 Requires-Dist: scipy<=1.15.2,>=1.11.1
 Requires-Dist: spglib<=2.5.0,>=2.0.2
 Provides-Extra: phonopy
-Requires-Dist: phonopy<=2.37.0,>=2.20.0; extra == "phonopy"
+Requires-Dist: phonopy<=2.38.0,>=2.20.0; extra == "phonopy"
 Requires-Dist: seekpath<=2.1.0,>=1.9.0; extra == "phonopy"
 Requires-Dist: structuretoolkit<=0.0.31,>=0.0.10; extra == "phonopy"
 Provides-Extra: gpaw
@@ -77,9 +77,11 @@ Requires-Dist: requests<=2.32.3,>=2.24.0; extra == "experimental"
 Provides-Extra: sphinxdft
 Requires-Dist: sphinx-parser==0.0.1; extra == "sphinxdft"
 Provides-Extra: qe
-Requires-Dist: pwtools==1.2.3; extra == "qe"
+Requires-Dist: pwtools==1.3.0; extra == "qe"
 Provides-Extra: tqdm
 Requires-Dist: tqdm==4.67.1; extra == "tqdm"
+Provides-Extra: vasp
+Requires-Dist: pyiron_vasp==0.2.4; extra == "vasp"
 
 # atomistics
 [![Pipeline](https://github.com/pyiron/atomistics/actions/workflows/pipeline.yml/badge.svg)](https://github.com/pyiron/atomistics/actions/workflows/pipeline.yml)

{atomistics-0.2.1 → atomistics-0.2.2}/atomistics.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ atomistics/calculators/hessian.py
 atomistics/calculators/interface.py
 atomistics/calculators/qe.py
 atomistics/calculators/sphinxdft.py
+atomistics/calculators/vasp.py
 atomistics/calculators/wrapper.py
 atomistics/calculators/lammps/__init__.py
 atomistics/calculators/lammps/commands.py
@@ -88,4 +89,5 @@ tests/test_quasiharmonic_ase_emt.py
 tests/test_quasiharmonic_lammpslib.py
 tests/test_quasiharmonic_lammpslib_functional.py
 tests/test_referencedata.py
-tests/test_sphinx_parser.py
+tests/test_sphinx_parser.py
+tests/test_vasp_parser.py

{atomistics-0.2.1 → atomistics-0.2.2}/atomistics.egg-info/requires.txt

@@ -26,15 +26,18 @@ dynaphopy<=1.17.16,>=1.17.5
 pyiron_lammps<=0.4.0,>=0.3.2
 
 [phonopy]
-phonopy<=2.37.0,>=2.20.0
+phonopy<=2.38.0,>=2.20.0
 seekpath<=2.1.0,>=1.9.0
 structuretoolkit<=0.0.31,>=0.0.10
 
 [qe]
-pwtools==1.2.3
+pwtools==1.3.0
 
 [sphinxdft]
 sphinx-parser==0.0.1
 
 [tqdm]
 tqdm==4.67.1
+
+[vasp]
+pyiron_vasp==0.2.4

{atomistics-0.2.1 → atomistics-0.2.2}/pyproject.toml

@@ -38,7 +38,7 @@ Repository = "https://github.com/pyiron/atomistics"
 
 [project.optional-dependencies]
 phonopy = [
-    "phonopy>=2.20.0,<=2.37.0",
+    "phonopy>=2.20.0,<=2.38.0",
     "seekpath>=1.9.0,<=2.1.0",
     "structuretoolkit>=0.0.10,<=0.0.31",
 ]
@@ -68,11 +68,14 @@ sphinxdft = [
     "sphinx-parser==0.0.1"
 ]
 qe = [
-    "pwtools==1.2.3"
+    "pwtools==1.3.0"
 ]
 tqdm = [
     "tqdm==4.67.1"
 ]
+vasp = [
+    "pyiron_vasp==0.2.4"
+]
 
 [tool.setuptools.packages.find]
 include = ["atomistics*"]

{atomistics-0.2.1 → atomistics-0.2.2}/tests/test_evcurve_eos.py

@@ -1,8 +1,11 @@
+from ase.build import bulk
 import numpy as np
 
 import unittest
 
 from atomistics.workflows.evcurve.fit import fit_equation_of_state
+from atomistics.workflows.evcurve.debye import DebyeModel
+from atomistics.workflows.evcurve.thermo import get_thermo_bulk_model
 
 
 class TestEvCurve(unittest.TestCase):
@@ -72,6 +75,74 @@ class TestEvCurve(unittest.TestCase):
         fit_dict = fit_equation_of_state(
             volume_lst=self.volumes, energy_lst=self.energies, fittype="vinet"
         )
+        print(fit_dict)
         self.assertAlmostEqual(fit_dict["volume_eq"], 66.43032532814925)
         self.assertAlmostEqual(fit_dict["bulkmodul_eq"], 77.61265363975706)
         self.assertAlmostEqual(fit_dict["b_prime_eq"], 1.2734991618131122)
+
+
+class TestThermo(unittest.TestCase):
+    def setUp(self):
+        self._volumes = [
+            63.10883669478296,
+            63.77314023893856,
+            64.43744378309412,
+            65.10174732724975,
+            65.7660508714054,
+            66.43035441556098,
+            67.09465795971657,
+            67.7589615038722,
+            68.42326504802779,
+            69.08756859218344,
+            69.75187213633905,
+        ]
+        self._thermo = get_thermo_bulk_model(
+            temperatures=np.arange(1.0, 1550.0, 50.0),
+            debye_model=DebyeModel(
+                fit_dict={
+                    "energy_eq": -13.439961346483864,
+                    "volume_eq": 66.43032532814925,
+                    "bulkmodul_eq": 77.61265363975706,
+                    "b_prime_eq": 1.2734991618131122,
+                    "volume": self._volumes,
+                    "fit_dict": {
+                        "fit_type": "vinet",
+                    }
+                },
+                masses=bulk("Al", cubic=True).get_masses(),
+                num_steps=50,
+            ),
+        )
+
+    def test_copy(self):
+        thermo_copy = self._thermo.copy()
+        self.assertEqual(len(thermo_copy.__dict__), len(self._thermo.__dict__))
+
+    def test_num_atoms(self):
+        self.assertEqual(self._thermo.num_atoms, 1)
+        self._thermo.num_atoms = 2
+        self.assertEqual(self._thermo.num_atoms, 2)
+        self._thermo.num_atoms = 1
+
+    def test_d_temp(self):
+        self.assertEqual(self._thermo._d_temp, 50.0)
+
+    def test_d_vol(self):
+        self.assertTrue(np.isclose(self._thermo._d_vol, 0.13557215186849447))
+
+    def test_volumes(self):
+        self.assertTrue(np.isclose(self._thermo.volumes[0], self._volumes[0]))
+        self.assertTrue(np.isclose(self._thermo.volumes[-1], self._volumes[-1]))
+        self.assertEqual(len(self._thermo.volumes), 50)
+
+    def test_entropy(self):
+        self._thermo._entropy = None
+        self.assertEqual(self._thermo.entropy.shape[0], 31)
+        self.assertEqual(self._thermo.entropy.shape[1], 50)
+        self._thermo._entropy = None
+
+    def test_pressure(self):
+        self._thermo._pressure = None
+        self.assertEqual(self._thermo.pressure.shape[0], 31)
+        self.assertEqual(self._thermo.pressure.shape[1], 50)
+        self._thermo._pressure = None

{atomistics-0.2.1 → atomistics-0.2.2}/tests/test_evcurve_sphinxdft.py

@@ -19,10 +19,10 @@ def validate_fitdict(fit_dict):
     lst = [
         fit_dict["bulkmodul_eq"] > 55,
         fit_dict["bulkmodul_eq"] < 65,
-        fit_dict["energy_eq"] > -227.76,
-        fit_dict["energy_eq"] < -227.75,
-        fit_dict["volume_eq"] > 70.37,
-        fit_dict["volume_eq"] < 70.38,
+        fit_dict["energy_eq"] > -227.72,
+        fit_dict["energy_eq"] < -227.71,
+        fit_dict["volume_eq"] > 70.92,
+        fit_dict["volume_eq"] < 70.93,
     ]
     if not all(lst):
         print(fit_dict)
@@ -57,8 +57,8 @@ class TestEvCurve(unittest.TestCase):
             task_dict=task_dict,
             working_directory=os.path.abspath("."),
             executable_function=evaluate_sphinx,
-            maxSteps=100,
-            eCut=25,
+            max_electronic_steps=100,
+            energy_cutoff_in_eV=500.0,
             kpoint_coords=[0.5, 0.5, 0.5],
             kpoint_folding=[3, 3, 3],
         )

{atomistics-0.2.1 → atomistics-0.2.2}/tests/test_phonons_ase_emt.py

@@ -39,3 +39,23 @@ class TestPhonons(unittest.TestCase):
         self.assertTrue("group_velocities" in mesh_dict.keys())
         self.assertTrue("frequency_points" in dos_dict.keys())
         self.assertTrue("total_dos" in dos_dict.keys())
+        dynmat_shape = workflow.get_dynamical_matrix().shape
+        self.assertEqual(dynmat_shape[0], 12)
+        self.assertEqual(dynmat_shape[1], 12)
+        hessmat_shape = workflow.get_hesse_matrix().shape
+        self.assertEqual(hessmat_shape[0], 324)
+        self.assertEqual(hessmat_shape[1], 324)
+        band_dict = workflow.get_band_structure()
+        self.assertEqual(len(band_dict['qpoints']), 6)
+        for vec in band_dict['qpoints']:
+            self.assertTrue(vec.shape[0] in [34, 39, 78, 101, 95])
+            self.assertEqual(vec.shape[1], 3)
+        self.assertEqual(len(band_dict['distances']), 6)
+        for vec in band_dict['distances']:
+            self.assertTrue(vec.shape[0] in [34, 39, 78, 101, 95])
+        self.assertEqual(len(band_dict['frequencies']), 6)
+        for vec in band_dict['frequencies']:
+            self.assertTrue(vec.shape[0] in [34, 39, 78, 101, 95])
+            self.assertEqual(vec.shape[1], 12)
+        self.assertIsNone(band_dict['eigenvectors'])
+        self.assertIsNone(band_dict['group_velocities'])

{atomistics-0.2.1 → atomistics-0.2.2}/tests/test_phonons_lammpsfile.py

@@ -131,3 +131,23 @@ class TestPhonons(unittest.TestCase):
         self.assertTrue(thermal_dict["free_energy"][0] > 0.1)
         self.assertTrue(thermal_dict["free_energy"][-1] < -2.6)
         self.assertTrue(thermal_dict["free_energy"][-1] > -2.7)
+        dynmat_shape = workflow.get_dynamical_matrix().shape
+        self.assertEqual(dynmat_shape[0], 12)
+        self.assertEqual(dynmat_shape[1], 12)
+        hessmat_shape = workflow.get_hesse_matrix().shape
+        self.assertEqual(hessmat_shape[0], 324)
+        self.assertEqual(hessmat_shape[1], 324)
+        band_dict = workflow.get_band_structure()
+        self.assertEqual(len(band_dict['qpoints']), 6)
+        for vec in band_dict['qpoints']:
+            self.assertTrue(vec.shape[0] in [34, 39, 78, 101, 95])
+            self.assertEqual(vec.shape[1], 3)
+        self.assertEqual(len(band_dict['distances']), 6)
+        for vec in band_dict['distances']:
+            self.assertTrue(vec.shape[0] in [34, 39, 78, 101, 95])
+        self.assertEqual(len(band_dict['frequencies']), 6)
+        for vec in band_dict['frequencies']:
+            self.assertTrue(vec.shape[0] in [34, 39, 78, 101, 95])
+            self.assertEqual(vec.shape[1], 12)
+        self.assertIsNone(band_dict['eigenvectors'])
+        self.assertIsNone(band_dict['group_velocities'])

{atomistics-0.2.1 → atomistics-0.2.2}/tests/test_phonons_lammpslib.py

@@ -107,3 +107,23 @@ class TestPhonons(unittest.TestCase):
         self.assertTrue(thermal_dict["free_energy"][0] > 0.1)
         self.assertTrue(thermal_dict["free_energy"][-1] < -2.6)
         self.assertTrue(thermal_dict["free_energy"][-1] > -2.7)
+        dynmat_shape = workflow.get_dynamical_matrix().shape
+        self.assertEqual(dynmat_shape[0],12)
+        self.assertEqual(dynmat_shape[1], 12)
+        hessmat_shape = workflow.get_hesse_matrix().shape
+        self.assertEqual(hessmat_shape[0], 324)
+        self.assertEqual(hessmat_shape[1], 324)
+        band_dict = workflow.get_band_structure()
+        self.assertEqual(len(band_dict['qpoints']), 6)
+        for vec in band_dict['qpoints']:
+            self.assertTrue(vec.shape[0] in [34, 39, 78, 101, 95])
+            self.assertEqual(vec.shape[1], 3)
+        self.assertEqual(len(band_dict['distances']), 6)
+        for vec in band_dict['distances']:
+            self.assertTrue(vec.shape[0] in [34, 39, 78, 101, 95])
+        self.assertEqual(len(band_dict['frequencies']), 6)
+        for vec in band_dict['frequencies']:
+            self.assertTrue(vec.shape[0] in [34, 39, 78, 101, 95])
+            self.assertEqual(vec.shape[1], 12)
+        self.assertIsNone(band_dict['eigenvectors'])
+        self.assertIsNone(band_dict['group_velocities'])

{atomistics-0.2.1 → atomistics-0.2.2}/tests/test_sphinx_parser.py

@@ -6,7 +6,17 @@ import numpy as np
 from ase.build import bulk
 
 try:
-    from atomistics.calculators.sphinxdft import OutputParser, _write_input, calc_static_with_sphinxdft, evaluate_with_sphinx, HARTREE_TO_EV, HARTREE_OVER_BOHR_TO_EV_OVER_ANGSTROM, BOHR_TO_ANGSTROM
+    from sphinx_parser.toolkit import to_sphinx
+    from atomistics.calculators.sphinxdft import (
+        OutputParser,
+        _generate_input,
+        calc_static_with_sphinxdft,
+        optimize_positions_with_sphinxdft,
+        evaluate_with_sphinx,
+        HARTREE_TO_EV,
+        HARTREE_OVER_BOHR_TO_EV_OVER_ANGSTROM,
+        BOHR_TO_ANGSTROM,
+    )
 
     skip_sphinx_test = False
 except ImportError:
@@ -37,30 +47,25 @@ class TestSphinxParser(unittest.TestCase):
     def test_write_input(self):
         folder = "test"
         os.makedirs(folder, exist_ok=True)
-        _write_input(
+        input_sx = to_sphinx(_generate_input(
             structure=self._structure,
-            working_directory=folder,
             maxSteps=100,
-            eCut=25.0,
+            energy_cutoff_in_eV=25.0 * HARTREE_TO_EV,
             kpoint_coords=None,
             kpoint_folding=None,
-        )
-        file = os.path.join(folder, "input.sx")
-        self.assertTrue(os.path.exists(file))
-        with open(file, "r") as f:
-            lines = f.readlines()
+        ))
 
         self.assertEqual(
-            "	eCut = 25.0;\n",
-            "".join([l for l in lines if "eCut" in l])
+            "	eCut = " + str(25.0 * HARTREE_TO_EV / HARTREE_TO_EV) + ";",
+            "".join([l for l in input_sx.split("\n") if "eCut" in l])
         )
         self.assertEqual(
-            "	folding = [3, 3, 3];\n",
-            "".join([l for l in lines if "folding" in l])
+            "	folding = [3, 3, 3];",
+            "".join([l for l in input_sx.split("\n") if "folding" in l])
         )
         self.assertEqual(
-            "		potType = \"AtomPAW\";\n",
-            "".join([l for l in lines if "potType" in l])
+            "		potType = \"AtomPAW\";",
+            "".join([l for l in input_sx.split("\n") if "potType" in l])
         )
         shutil.rmtree(folder)
 
@@ -69,8 +74,8 @@ class TestSphinxParser(unittest.TestCase):
             structure=self._structure,
             working_directory=self._output_directory,
             executable_function=executable_function,
-            maxSteps=100,
-            eCut=25,
+            max_electronic_steps=100,
+            energy_cutoff_in_eV=25.0 * HARTREE_TO_EV,
             kpoint_coords=None,
             kpoint_folding=None,
             output_keys=["volume", "forces", "energy"],
@@ -82,13 +87,28 @@ class TestSphinxParser(unittest.TestCase):
             np.array([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]),
         )))
 
-    def test_evaluate_with_sphinx(self):
+    def test_optimize_positions_with_sphinxdft(self):
+        structure_result = optimize_positions_with_sphinxdft(
+            structure=self._structure,
+            working_directory=self._output_directory,
+            executable_function=executable_function,
+            max_electronic_steps=100,
+            energy_cutoff_in_eV=25.0 * HARTREE_TO_EV,
+            kpoint_coords=None,
+            kpoint_folding=None,
+            mode="linQN",
+            dEnergy=1.0e-6,
+            max_ionic_steps=50,
+        )
+        self.assertEqual(len(structure_result), len(self._structure))
+
+    def test_evaluate_with_sphinx_energy_and_forces(self):
         results = evaluate_with_sphinx(
             task_dict={"calc_energy": self._structure, "calc_forces": self._structure},
             working_directory=self._output_directory,
             executable_function=executable_function,
-            maxSteps=100,
-            eCut=25,
+            max_electronic_steps=100,
+            energy_cutoff_in_eV=25.0 * HARTREE_TO_EV,
             kpoint_coords=None,
             kpoint_folding=None,
         )
@@ -97,3 +117,21 @@ class TestSphinxParser(unittest.TestCase):
             results["forces"],
             np.array([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]),
         )))
+
+    def test_evaluate_with_sphinx_structure_optimization(self):
+        results = evaluate_with_sphinx(
+            task_dict={"optimize_positions": self._structure},
+            working_directory=self._output_directory,
+            executable_function=executable_function,
+            max_electronic_steps=100,
+            energy_cutoff_in_eV=25.0 * HARTREE_TO_EV,
+            kpoint_coords=None,
+            kpoint_folding=None,
+            sphinx_optimizer_kwargs={
+                "mode": "linQN",
+                "dEnergy": 1.0e-6,
+                "max_ionic_steps": 50,
+            },
+        )
+        self.assertTrue("structure_with_optimized_positions" in results.keys())
+        self.assertEqual(len(results), 1)

atomistics-0.2.2/tests/test_vasp_parser.py

@@ -0,0 +1,68 @@
+import os
+import shutil
+from unittest import TestCase
+
+from ase.build import bulk
+
+from atomistics.calculators.vasp import (
+    evaluate_with_vasp,
+)
+from atomistics.workflows import optimize_positions, optimize_positions_and_volume
+
+
+os.environ["VASP_PP_PATH"] = os.path.abspath(os.path.join(__file__, "..", "static", "vasp"))
+
+def copy_file_funct(working_directory):
+    outcar_file = os.path.abspath(os.path.join(__file__, "..", "static", "vasp", "OUTCAR"))
+    shutil.copy(outcar_file, working_directory)
+
+
+class TestVaspParser(TestCase):
+    def setUp(self):
+        self._structure = bulk("Al", a=4.05, cubic=True)
+
+    def test_optimize_positions_with_vasp_task(self):
+        result = evaluate_with_vasp(
+            task_dict=optimize_positions(self._structure),
+            working_directory="opt_pos_task",
+            executable_function=copy_file_funct,
+            prec="Accurate",
+            algo="Fast",
+            lreal=False,
+            lwave=False,
+            lorbit=0,
+            xc="pbe"
+        )
+        self.assertEqual(len(result), 1)
+
+    def test_optimize_positions_and_volume_with_vasp_task(self):
+        result = evaluate_with_vasp(
+            task_dict=optimize_positions_and_volume(self._structure),
+            working_directory="opt_vol_task",
+            executable_function=copy_file_funct,
+            prec="Accurate",
+            algo="Fast",
+            lreal=False,
+            lwave=False,
+            lorbit=0,
+            xc="pbe"
+        )
+        self.assertEqual(len(result), 1)
+
+    def test_calc_static_task(self):
+        result = evaluate_with_vasp(
+            task_dict={
+                "calc_energy": self._structure,
+                "calc_forces": self._structure,
+                "calc_stress": self._structure,
+            },
+            working_directory="opt_vol_task",
+            executable_function=copy_file_funct,
+            prec="Accurate",
+            algo="Fast",
+            lreal=False,
+            lwave=False,
+            lorbit=0,
+            xc="pbe"
+        )
+        self.assertEqual(len(result), 3)