Merge pull request #29 from pyiron/add_calc_minimize

Add calc minimize

Author: samwaseda

sphinx_parser/jobs.py

@@ -3,16 +3,30 @@
 from sphinx_parser.potential import get_paw_from_structure
 
 
-def calc_static(
-    structure,
-    eCut=25,
-    xc=1,
-    spinPolarized=False,
-    maxSteps=30,
-    ekt=0.2,
-    k_point_coords=[0.5, 0.5, 0.5],
+def set_base_parameters(
+    structure: "ase.Atoms",
+    eCut: float = 25,
+    xc: int = 1,
+    maxSteps: int = 30,
+    ekt: float = 0.2,
+    k_point_coords: list = [0.5, 0.5, 0.5],
 ):
+    """
+    Set the base parameters for the sphinx input file
+
+    Args:
+        structure (ase.Atoms): ASE Atoms object
+        eCut (float, optional): Energy cutoff. Defaults to 25.
+        xc (int, optional): Exchange-correlation functional. Defaults to 1.
+        maxSteps (int, optional): Maximum number of steps. Defaults to 30.
+        ekt (float, optional): Temperature. Defaults to 0.2.
+        k_point_coords (list, optional): K-point coordinates. Defaults to [0.5, 0.5, 0.5].
+
+    Returns:
+        dict: Sphinx input dictionary
+    """
     struct_group, spin_lst = get_structure_group(structure)
+    spinPolarized = spin_lst is not None
     main_group = sphinx.main.create(
         scfDiag=sphinx.main.scfDiag.create(
             maxSteps=maxSteps, blockCCG=sphinx.main.scfDiag.blockCCG.create()
@@ -40,3 +54,64 @@ def calc_static(
         initialGuess=initial_guess_group,
     )
     return input_sx
+
+
+def apply_minimization(sphinx_input, mode="linQN", dEnergy=1.0e-6, maxSteps=50):
+    """
+    Apply minimization to the sphinx input file
+
+    Args:
+        sphinx_input (dict): Sphinx input dictionary
+        mode (str, optional): Minimization mode. Defaults to "linQN".
+        dEnergy (float, optional): Energy tolerance. Defaults to 1.0e-6.
+        maxSteps (int, optional): Maximum number of steps. Defaults to 50.
+
+    Returns:
+        dict: Sphinx input dictionary
+    """
+    input_sx = sphinx_input.copy()
+    if "main" not in input_sx or "scfDiag" not in input_sx["main"]:
+        raise ValueError("main group not found - run set_base_parameters first")
+    if mode == "linQN":
+        input_sx["main"] = sphinx.main.create(
+            linQN=sphinx.main.linQN.create(
+                dEnergy=dEnergy,
+                maxSteps=maxSteps,
+                bornOppenheimer=sphinx.main.linQN.bornOppenheimer.create(
+                    scfDiag=input_sx["main"]["scfDiag"]
+                ),
+            )
+        )
+    elif mode == "QN":
+        input_sx["main"] = sphinx.main.create(
+            QN=sphinx.main.QN.create(
+                dEnergy=dEnergy,
+                maxSteps=maxSteps,
+                bornOppenheimer=sphinx.main.QN.bornOppenheimer.create(
+                    scfDiag=input_sx["main"]["scfDiag"]
+                ),
+            )
+        )
+    elif mode == "ricQN":
+        input_sx["main"] = sphinx.main.create(
+            ricQN=sphinx.main.ricQN.create(
+                dEnergy=dEnergy,
+                maxSteps=maxSteps,
+                bornOppenheimer=sphinx.main.ricQN.bornOppenheimer.create(
+                    scfDiag=input_sx["main"]["scfDiag"]
+                ),
+            )
+        )
+    elif mode == "ricTS":
+        input_sx["main"] = sphinx.main.create(
+            ricTS=sphinx.main.ricTS.create(
+                dEnergy=dEnergy,
+                maxSteps=maxSteps,
+                bornOppenheimer=sphinx.main.ricTS.bornOppenheimer.create(
+                    scfDiag=input_sx["main"]["scfDiag"]
+                ),
+            )
+        )
+    else:
+        raise ValueError("mode not recognized")
+    return input_sx

tests/unit/test_jobs.py

@@ -1,15 +1,31 @@
 import unittest
 from ase.build import bulk
-from sphinx_parser.jobs import calc_static
+from sphinx_parser.jobs import set_base_parameters, apply_minimization
 from sphinx_parser.toolkit import to_sphinx
 
 
 class TestJobs(unittest.TestCase):
     def test_magnetic_bulk(self):
         structure = bulk("Fe", cubic=True)
-        self.assertTrue("atomicSpin" in to_sphinx(calc_static(structure)))
+        self.assertTrue("atomicSpin" in to_sphinx(set_base_parameters(structure)))
         structure = bulk("Al", cubic=True)
-        self.assertFalse("atomicSpin" in to_sphinx(calc_static(structure)))
+        self.assertFalse("atomicSpin" in to_sphinx(set_base_parameters(structure)))
+
+    def test_calc_minimize(self):
+        structure = bulk("Fe", cubic=True)
+        input_sx = set_base_parameters(structure)
+        default_input_sx = to_sphinx(apply_minimization(input_sx))
+        self.assertTrue("linQN" in default_input_sx)
+        for term in ["ricQN", "QN", "ricTS"]:
+            self.assertEqual(
+                to_sphinx(apply_minimization(input_sx, mode=term)),
+                default_input_sx.replace("linQN", term),
+            )
+        with self.assertRaises(ValueError):
+            apply_minimization(input_sx, mode="not_a_valid_mode")
+        input_sx.pop("main")
+        with self.assertRaises(ValueError):
+            apply_minimization(input_sx)
 
 
 if __name__ == "__main__":