SimpleTask feature

examples/README.md

@@ -39,7 +39,7 @@ python3 job.py
 - exmp016_autoci: Use AUTO-CI to run CISD/def2-SVP single-point
 - exmp017_roci: Perform a ROCIS calculation
 - exmp018_cipsi: Perform a ICE-CI calculation
-- exmp019_engrad: Perfrom an energy & gradient calculation with r²SCAN-3c
+- exmp019_engrad: Perform an energy & gradient calculation with r²SCAN-3c
 - exmp020_smd: Run a r²SCAN-3c+SMD(Water) calculation
 - exmp021_basis: Run a BP86/def2-SVP energy calculation with additional diffuse function for oxygen
 - exmp022_scf_block: Run a PBE0/def2-SVP energy calculation and rotate the initial SCF guess
@@ -59,7 +59,7 @@ python3 job.py
 - exmp036_solvator: Run ORCAs autosolvation workflow (solvator)
 - exmp037_s2: Get the S² expectation value from an unrestricted calculation
 - exmp038_integrals: Get integrals from a calculation
-- exmp039_neb: Perfrom a transition state search with NEB
+- exmp039_neb: Perform a transition state search with NEB
 - exmp040_xzyfraglib: Assign fragments with external fragment library (frag_lib.xyz)
 - exmp041_graph: How to print overview of the available results in output
 - exmp042_element: Access cardinal numbers of a structure
@@ -73,5 +73,9 @@ python3 job.py
 - exmp050_docker: Use DOCKER to dock water with water
 - exmp051_libxc: Shows modification of DFT LibXC parameters via the method block
 - exmp052_densities: Perform UHF calculation and obtain density and spin-density in AO-basis
-- exmp053_opencosmors: Run OpenCOSMO-RS task 
-
+- exmp053_opencosmors: Run OpenCOSMO-RS task
+- exmp057_singlepoint_simpletask: B3LYP/def2-SVP single-point with CPCM(water) using the `SinglePointTask` functionality
+- exmp058_engrad_simpletask: r²SCAN-3c energy & gradient calculation using the `EngradTask` functionality
+- exmp059_opt_simpletask: B3LYP/def2-SVP geometry optimization with CPCM(water) using the `OptTask` functionality
+- exmp060_freq_simpletask: TPSS/def2-SVP frequency calculation using the `FreqTask` functionality
+- exmp061_goat_simpletask: GFN2-xTB GOAT conformer search using the `GoatTask` functionality

examples/exmp057_singlepoint_simpletask/inp.xyz

@@ -0,0 +1,5 @@
+3
+
+O         -3.56626        1.77639        0.00000
+H         -2.59626        1.77639        0.00000
+H         -3.88959        1.36040       -0.81444

examples/exmp057_singlepoint_simpletask/job.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+import sys
+from pathlib import Path
+
+from opi.input.simple_keywords import AtomicCharge
+from opi.input.structures import Structure
+from opi.simple_tasks import SinglePointResults, SinglePointTask
+
+
+def run_exmp057(
+    structure: Structure | None = None, working_dir: Path = Path("RUN")
+) -> SinglePointResults:
+    # > if no structure is given read structure from inp.xyz
+    if structure is None:
+        structure = Structure.from_xyz("inp.xyz")
+
+    # > set up the task
+    simple_task = SinglePointTask(
+        method="b3lyp", basis_set="def2-svp", solvation_model="cpcm", solvent="water"
+    )
+    # > there are task and method-specific settings, these can be set through kwargs
+
+    # > It is possible to modify the input object associated with the task object for more specific settings
+    simple_task.input.add_simple_keywords(AtomicCharge.HIRSHFELD)
+
+    # > run the calculation with given data
+    singlepoint_result = simple_task.run("job", structure, working_dir=working_dir)
+
+    # > check if the ORCA calculation terminated normally
+    if not singlepoint_result.status:
+        print("SinglePoint task failed")
+        sys.exit(1)
+
+    # > extract primary property from the `TaskResults` object. For a single point calculation, it is the final energy.
+    final_energy = singlepoint_result.final_energy
+
+    print(f"Final single point energy: {final_energy: 10f} Eh")
+
+    return singlepoint_result
+
+
+if __name__ == "__main__":
+    run_exmp057()

examples/exmp058_engrad_simpletask/inp.xyz

@@ -0,0 +1,5 @@
+3
+
+O         -3.56626        1.77639        0.00000
+H         -2.59626        1.77639        0.00000
+H         -3.88959        1.36040       -0.81444

examples/exmp058_engrad_simpletask/job.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+import sys
+from pathlib import Path
+
+from opi.input.structures import Structure
+from opi.simple_tasks import EngradResults, EngradTask
+
+
+def run_exmp058(
+    structure: Structure | None = None, working_dir: Path = Path("RUN")
+) -> EngradResults:
+    # > if no structure is given read structure from inp.xyz
+    if structure is None:
+        structure = Structure.from_xyz("inp.xyz")
+
+    engrad_task = EngradTask(method="r2scan-3c")
+    engrad_result = engrad_task.run("job", structure, working_dir=working_dir)
+
+    if not engrad_result.status:
+        print(f"Engrad task failed, see output file: {engrad_result.output.get_outfile()}")
+        sys.exit(1)
+
+    print("FINAL SINGLE POINT ENERGY")
+    print(engrad_result.final_energy)
+    print("SCF ENERGY")
+    print(engrad_result.output.get_energies()["SCF"])
+
+    return engrad_result
+
+
+if __name__ == "__main__":
+    run_exmp058()

examples/exmp059_opt_simpletask/inp.xyz

@@ -0,0 +1,10 @@
+8
+Coordinates from ORCA-job job E -79.174339553991
+  C          -0.07696488620844      0.00264225043565      0.01503449747601
+  C           1.42297403167085      0.00026730705255      0.00170779972564
+  H          -0.52956432516482      0.16759451146808      0.99517342002418
+  H          -0.47206799721260      0.78060586812661     -0.64348212080303
+  H          -0.47202276565405     -0.94827280862626     -0.35199393102178
+  H           1.83370076026311      0.95190889480824      0.34680814012902
+  H           1.83362978930886     -0.78232192510389      0.64382744884855
+  H           1.80356539299709     -0.17242409816099     -1.00707525437860

examples/exmp059_opt_simpletask/job.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+import sys
+from pathlib import Path
+
+from opi.input.structures import Structure
+from opi.simple_tasks import OptResults, OptSettings, OptTask
+from opi.simple_tasks.method_settings import DftSettings
+
+
+def run_exmp059(structure: Structure | None = None, working_dir: Path = Path("RUN")) -> OptResults:
+    # > if no structure is given read structure from inp.xyz
+    if structure is None:
+        structure = Structure.from_xyz("../exmp057_singlepoint_simpletask/inp.xyz")
+
+    # > set up the task
+    simple_task = OptTask(
+        method="b3lyp",
+        basis_set="def2-svp",
+        solvation_model="cpcm",
+        solvent="water",
+        method_settings=DftSettings(scf_maxiter=150),
+        task_settings=OptSettings(opt_threshold="tight"),
+    )
+    # > there are task and method-specific settings, these can be set through kwargs
+
+    # > run the calculation with given data
+    opt_result = simple_task.run("job", structure, working_dir=working_dir)
+
+    # > check if the ORCA calculation terminated normally
+    if not opt_result.status:
+        print("Opt task failed")
+        sys.exit(1)
+
+    # > extract optimized structure from the `OptResults` object
+    structure = opt_result.structure
+
+    print("Optimized Structure:")
+    print(structure.format_orca())
+
+    return opt_result
+
+
+if __name__ == "__main__":
+    run_exmp059()

examples/exmp060_freq_simpletask/inp.xyz

@@ -0,0 +1,5 @@
+3
+
+O                        -3.56626                        1.77639                        0.00000
+H                        -2.59626                        1.77639                        0.00000
+H                        -3.88959                        1.36040                       -0.81444

examples/exmp060_freq_simpletask/job.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+import sys
+from pathlib import Path
+
+from opi.input.structures import Structure
+from opi.output.ir_mode import IrMode
+from opi.simple_tasks import FreqResults, FreqTask
+
+
+def run_exmp060(structure: Structure | None = None, working_dir: Path = Path("RUN")) -> FreqResults:
+    # > if no structure is given read structure from inp.xyz
+    if structure is None:
+        structure = Structure.from_xyz("inp.xyz")
+
+    freq_task = FreqTask(method="tpss", basis_set="def2-svp")
+    freq_result = freq_task.run("job", structure, working_dir=working_dir)
+
+    if not freq_result.status:
+        print(f"Freq task failed, see output file: {freq_result.output.get_outfile()}")
+        sys.exit(1)
+
+    output = freq_result.output
+
+    ir_dict = output.get_ir()
+    print(IrMode.header())
+    for ir_mode in ir_dict.values():
+        print(ir_mode)
+
+    ngeoms = len(output.results_properties.geometries)
+    print("N GEOMETRIES")
+    print(ngeoms)
+    print("FINAL SINGLE POINT ENERGY")
+    print(output.get_final_energy())
+    print("Temperature [K]")
+    print(output.results_properties.geometries[0].thermochemistry_energies[0].temperature)
+    print("Final Gibbs free energy")
+    print(output.get_free_energy())
+    print("Zero-point energy")
+    print(output.get_zpe())
+    print("Final enthalpy H")
+    print(output.get_enthalpy())
+    print("Final entropy S")
+    print(output.get_entropy())
+    print("G-E(el)")
+    print(freq_result.free_energy_delta)
+
+    return freq_result
+
+
+if __name__ == "__main__":
+    run_exmp060()

examples/exmp061_goat_simpletask/inp.xyz

@@ -0,0 +1,10 @@
+8
+Coordinates from ORCA-job job E -79.174339553991
+  C          -0.07696488620844      0.00264225043565      0.01503449747601
+  C           1.42297403167085      0.00026730705255      0.00170779972564
+  H          -0.52956432516482      0.16759451146808      0.99517342002418
+  H          -0.47206799721260      0.78060586812661     -0.64348212080303
+  H          -0.47202276565405     -0.94827280862626     -0.35199393102178
+  H           1.83370076026311      0.95190889480824      0.34680814012902
+  H           1.83362978930886     -0.78232192510389      0.64382744884855
+  H           1.80356539299709     -0.17242409816099     -1.00707525437860

examples/exmp061_goat_simpletask/job.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+#!/usr/bin/env python3
+import sys
+from pathlib import Path
+
+from opi.input.structures import Properties, Structure
+from opi.simple_tasks import GoatSettings, GoatTask
+
+
+def run_exmp061(
+    structure: Structure | None = None, working_dir: Path = Path("RUN")
+) -> tuple[list[Structure], list[Properties]]:
+
+    # > if no structure is given read structure from inp.xyz
+    if structure is None:
+        structure = Structure.from_xyz("inp.xyz")
+
+    goat_settings = GoatSettings(goat_maxiter=128, goat_explore=True)
+    goat_task = GoatTask("gfn2-xtb", task_settings=goat_settings)
+
+    goat_result = goat_task.run("job", structure, working_dir=working_dir, ncores=4)
+
+    # > check if the ORCA calculation terminated normally
+    if not goat_result.status:
+        print("GOAT task failed")
+        sys.exit(1)
+
+    structures, properties_list = goat_result.primary_property
+
+    # > Print structures that were read
+    for structure, properties in zip(structures, properties_list):
+        print(f"FINAL ENERGY: {properties.energy_total}")
+        print(structure.to_xyz_block())
+
+    return structures, properties_list
+
+
+if __name__ == "__main__":
+    run_exmp061()

pyproject.toml

@@ -128,6 +128,7 @@ markers = [
     "input: input side unit tests",
     "unit: unit tests",
     "json_files: Export JSON files with --update-json-files",
+    "simpletasks: simpletasks unit tests",
 ]
 
 

src/opi/input/blocks/base.py

@@ -169,6 +169,25 @@ def format_orca(self) -> str:
 
         return s
 
+    def __or__(self, other: "Block") -> "Block":
+        """
+        Merges two instances of `Block`. If a common attribute exists in both `self` and `other`, the value in `other` will be given precedence.
+        Parameters
+        ----------
+        other: Block
+            Instance of `Block` to be merged into `self`
+
+        Returns
+        -------
+        Block
+            New instance of `Block` with attributes of `self` and `other`.
+
+        """
+        new_block = self.__class__.model_validate(
+            {**self.model_dump(exclude_none=True), **other.model_dump(exclude_none=True)}
+        )
+        return new_block
+
     @property
     def name(self) -> str:
         return self._name
@@ -189,3 +208,44 @@ def init_inputpath(cls, inp: Any) -> Any:
             return InputFilePath(file=inp)
         else:
             return inp
+
+    @classmethod
+    def get_subclass_by_name(cls, name: str) -> type["Block"]:
+        """
+        Look up a ``Block`` subclass by its class name or ORCA block name.
+
+        Matching is case-insensitive and checks both the Python class name
+        (e.g. ``"BlockScf"``) and the ORCA block name returned by the
+        subclass's ``name`` property (e.g. ``"scf"``).
+
+        Parameters
+        ----------
+        name : str
+            Class name or ORCA block name of the desired subclass.
+
+        Returns
+        -------
+        type[Block]
+            The matching subclass.
+
+        Raises
+        ------
+        ValueError
+            If no subclass matches ``name``.
+        """
+        # Search for `Block` class by OPI name
+        opi_block_name_matches = {sub.__name__.lower(): sub for sub in cls.__subclasses__()}
+        # Search for `Block` class by ORCA block name
+        orca_block_name_matches = {sub().name.lower(): sub for sub in cls.__subclasses__()}
+        # Collect matches across both criteria
+        all_matches = opi_block_name_matches.get(name.lower()) or orca_block_name_matches.get(
+            name.lower()
+        )
+
+        # If no match is found, raise ValueError
+        if all_matches is None:
+            raise ValueError(
+                f"No Block subclass found with name {name!r}. Available: {list(opi_block_name_matches.keys())}"
+            )
+
+        return all_matches

src/opi/input/blocks/block_ice.py

@@ -21,4 +21,4 @@ class BlockIce(Block):
     etol: float | None = None
     icetype: Literal["CFGs", "CSFs", "DETs"] | None = None
     # > algorithm details
-    integrals: Literal["exact", "ri"] | None
+    integrals: Literal["exact", "ri"] | None = None