Add method and results

src/nomad_simulations/schema_packages/workflow/general.py

@@ -1,16 +1,36 @@
-from nomad.datamodel import EntryArchive
+from nomad.datamodel import ArchiveSection, EntryArchive
 from nomad.datamodel.metainfo.workflow import Link, Task, Workflow
-from nomad.metainfo.util import MSubSectionList
+from nomad.metainfo import SubSection
 from structlog.stdlib import BoundLogger
 
 INCORRECT_N_TASKS = 'Incorrect number of tasks found.'
 
 
+class SimulationWorkflowMethod(ArchiveSection):
+    """
+    Base class for simulation workflow method sub-section definition.
+    """
+
+    pass
+
+
+class SimulationWorkflowResults(ArchiveSection):
+    """
+    Base class for simulation workflow results sub-section definition.
+    """
+
+    pass
+
+
 class SimulationWorkflow(Workflow):
     """
     Base class for simulation workflows.
     """
 
+    method = SubSection(sub_section=SimulationWorkflowMethod.m_def)
+
+    results = SubSection(sub_section=SimulationWorkflowResults.m_def)
+
     def normalize(self, archive: EntryArchive, logger: BoundLogger):
         """
         Generate tasks from the archive data outputs.
@@ -69,3 +89,15 @@ def normalize(self, archive: EntryArchive, logger: BoundLogger):
             if not self.outputs:
                 # assign parent outputs as workflow outputs
                 self.outputs.extend(parent_outputs)
+
+        if not self.method:
+            self.method = SimulationWorkflowMethod()
+
+        if not self.results:
+            self.results = SimulationWorkflowResults()
+
+        # set method as inputs
+        self.inputs.append(Link(name='Input method', section=self.method))
+
+        # set results as outputs
+        self.outputs.append(Link(name='Ouput results', section=self.results))

src/nomad_simulations/schema_packages/workflow/geometry_optimization.py

@@ -1,8 +1,106 @@
 from nomad.datamodel import EntryArchive
 from nomad.datamodel.metainfo.workflow import Link, Task
+from nomad.metainfo import MEnum, Quantity
+from nomad.metainfo.util import MSubSectionList
 from structlog.stdlib import BoundLogger
 
-from .general import SimulationWorkflow
+from nomad_simulations.schema_packages.outputs import Outputs
+
+from .general import (
+    SimulationWorkflow,
+    SimulationWorkflowMethod,
+    SimulationWorkflowResults,
+)
+
+
+class GeometryOptimizationMethod(SimulationWorkflowMethod):
+    optimization_type = Quantity(
+        type=MEnum('static', 'atomic', 'cell_shape', 'cell_volume'),
+        shape=[],
+        description="""
+        The type of geometry optimization, which denotes what is being optimized.
+
+        Allowed values are:
+
+        | Type                   | Description                               |
+
+        | ---------------------- | ----------------------------------------- |
+
+        | `"static"`             | no optimization |
+
+        | `"atomic"`             | the atomic coordinates alone are updated |
+
+        | `"cell_volume"`         | `"atomic"` + cell lattice paramters are updated isotropically |
+
+        | `"cell_shape"`        | `"cell_volume"` but without the isotropic constraint: all cell parameters are updated |
+
+        """,
+    )
+
+    optimization_method = Quantity(
+        type=str,
+        shape=[],
+        description="""
+        The method used for geometry optimization. Some known possible values are:
+        `"steepest_descent"`, `"conjugant_gradient"`, `"low_memory_broyden_fletcher_goldfarb_shanno"`.
+        """,
+    )
+
+    convergence_tolerance_energy_difference = Quantity(
+        type=float,
+        shape=[],
+        unit='joule',
+        description="""
+        The input energy difference tolerance criterion.
+        """,
+    )
+
+    convergence_tolerance_force_maximum = Quantity(
+        type=float,
+        shape=[],
+        unit='newton',
+        description="""
+        The input maximum net force tolerance criterion.
+        """,
+    )
+
+    convergence_tolerance_stress_maximum = Quantity(
+        type=float,
+        shape=[],
+        unit='pascal',
+        description="""
+        The input maximum stress tolerance criterion.
+        """,
+    )
+
+    convergence_tolerance_displacement_maximum = Quantity(
+        type=float,
+        shape=[],
+        unit='meter',
+        description="""
+        The input maximum displacement tolerance criterion.
+        """,
+    )
+
+    optimization_steps_maximum = Quantity(
+        type=int,
+        shape=[],
+        description="""
+        Maximum number of optimization steps.
+        """,
+    )
+
+    sampling_frequency = Quantity(
+        type=int,
+        shape=[],
+        description="""
+        The number of optimization steps between sucessive outputs.
+        """,
+    )
+
+
+class GeometryOptimizationResults(SimulationWorkflowResults):
+    pass
 
 
 class GeometryOptimization(SimulationWorkflow):
@@ -14,20 +112,33 @@ def normalize(self, archive: EntryArchive, logger: BoundLogger) -> None:
         """
         Specify the inputs and outputs of the tasks as the model system.
         """
+
+        # set up first method and results before we call base normalizer
+        if not self.method:
+            self.method = GeometryOptimizationMethod()
+
+        if not self.results:
+            self.results = GeometryOptimizationResults()
+
         super().normalize(archive, logger)
 
-        def to_system_links(task: Task) -> None:
-            task.inputs = [
-                Link(name='Input system', section=link.section.model_system_ref)
-                for link in task.inputs
-                if link.section and link.section.model_system_ref
-            ]
-            task.outputs = [
-                Link(name='Output system', section=link.section.model_system_ref)
-                for link in task.inputs
-                if link.section and link.section.model_system_ref
-            ]
-
-        to_system_links(self)
-        for task in self.tasks:
-            to_system_links(task)
+        def extend_links(task: Task) -> None:
+            def get_system_links(links: MSubSectionList, name: str) -> list[Link]:
+                return [
+                    Link(name=name, section=link.section.model_system_ref)
+                    for link in links
+                    if isinstance(link.section, Outputs)
+                    and link.section.model_system_ref
+                ]
+
+            task.inputs.extend(get_system_links(self.inputs, 'Input system'))
+            task.outputs.extend(get_system_links(self.outputs, 'Output system'))
+
+        if not self.name:
+            self.name = 'Geometry Optimization'
+
+        extend_links(self)
+        for n, task in enumerate(self.tasks):
+            if not task.name:
+                task.name = f'Step {n}'
+            extend_links(task)