Metal binding data, trajectories, and the start of stereochemistry

emmet-api/emmet/api/core/documentation.py

@@ -293,6 +293,11 @@
         "description": "Route for molecular bonding data. See the `MoleculeBondingDoc` schema for a full list \
             of fields returned by this route."
     },
+    {
+        "name": "Molecules Metal Binding",
+        "description": "Route for data regarding metal binding to molecules. See the `MetalBindingDoc` schema \
+            for a full list of fields returned by this route."
+    },
     {
         "name": "Molecules Orbitals",
         "description": "Route for molecular orbital information obtained via Natural Bonding Orbital analysis. \

emmet-api/emmet/api/routes/molecules/metal_binding/query_operators.py

@@ -0,0 +1,134 @@
+from typing import Any, Optional, Union
+from fastapi import Query
+from maggma.api.query_operator import QueryOperator
+from maggma.api.utils import STORE_PARAMS
+
+
+class BindingDataQuery(QueryOperator):
+    """
+    Method to generate a query on binding data.
+    """
+
+    def query(
+        self,
+        metal_element: Optional[str] = Query(
+            None,
+            description="Element symbol for coordinated metal, e.g. 'Li' for lithium or 'Mg' for magnesium",
+        ),
+        min_metal_partial_charge: Optional[float] = Query(
+            None,
+            description="Minimum metal partial charge."
+        ),
+        max_metal_partial_charge: Optional[float] = Query(
+            None,
+            description="Maximum metal partial charge."
+        ),
+        min_metal_partial_spin: Optional[float] = Query(
+            None,
+            description="Minimum metal partial spin (only meaningful for open-shell systems)."
+        ),
+        max_metal_partial_spin: Optional[float] = Query(
+            None,
+            description="Maximum metal partial spin (only meaningful for open-shell systems)."
+        ),
+        min_metal_assigned_charge: Optional[float] = Query(
+            None,
+            description="Minimum charge of the metal, determined by analyzing partial charges/spins."
+        ),
+        max_metal_assigned_charge: Optional[float] = Query(
+            None,
+            description="Maximum charge of the metal, determined by analyzing partial charges/spins."
+        ),
+        min_metal_assigned_spin: Optional[Union[int, float]] = Query(
+            None,
+            description="Minimum spin multiplicity of the metal, determined by analyzing partial spins."
+        ),
+        max_metal_assigned_spin: Optional[Union[int, float]] = Query(
+            None,
+            description="Maximum spin multiplicity of the metal, determined by analyzing partial spins."
+        ),
+        min_number_coordinate_bonds: Optional[int] = Query(
+            None,
+            description="Minimum number of atoms coordinated to the metal."
+        ),
+        max_number_coordinate_bonds: Optional[int] = Query(
+            None,
+            description="Maximum number of atoms coordinated to the metal."
+        ),
+        min_binding_energy: Optional[float] = Query(
+            None,
+            description="Minimum binding electronic energy (units: eV)"
+        ),
+        max_binding_energy: Optional[float] = Query(
+            None,
+            description="Maximum binding electronic energy (units: eV)"
+        ),
+        min_binding_enthalpy: Optional[float] = Query(
+            None,
+            description="Minimum binding enthalpy (units: eV)"
+        ),
+        max_binding_enthalpy: Optional[float] = Query(
+            None,
+            description="Maximum binding enthalpy (units: eV)"
+        ),
+        min_binding_entropy: Optional[float] = Query(
+            None,
+            description="Minimum binding entropy (units: eV/K)"
+        ),
+        max_binding_entropy: Optional[float] = Query(
+            None,
+            description="Maximum binding entropy (units: eV/K)"
+        ),
+        min_binding_free_energy: Optional[float] = Query(
+            None,
+            description="Minimum binding free energy (units: eV)"
+        ),
+        max_binding_free_energy: Optional[float] = Query(
+            None,
+            description="Maximum binding free energy (units: eV)"
+        )
+    ) -> STORE_PARAMS:
+
+        crit: Dict[str, Any] = dict()  # type: ignore
+
+        if metal_element:
+            crit["binding_data.metal_element"] = metal_element
+
+        d = {
+            "metal_partial_charge": [min_metal_partial_charge, max_metal_partial_charge],
+            "metal_partial_spin": [min_metal_partial_spin, max_metal_partial_spin],
+            "metal_assigned_charge": [min_metal_assigned_charge, max_metal_assigned_charge],
+            "metal_assigned_spin": [min_metal_assigned_spin, max_metal_assigned_spin],
+            "number_coordinate_bonds": [min_number_coordinate_bonds, max_number_coordinate_bonds],
+            "binding_energy": [min_binding_energy, max_binding_energy],
+            "binding_enthalpy": [min_binding_enthalpy, max_binding_enthalpy],
+            "binding_entropy": [min_binding_entropy, max_binding_entropy],
+            "binding_free_energy": [min_binding_free_energy, max_binding_free_energy]
+        }
+
+        for entry in d:
+            key = "binding_data." + entry
+            if d[entry][0] is not None or d[entry][1] is not None:  # type: ignore
+                crit[key] = dict()
+
+            if d[entry][0] is not None:  # type: ignore
+                crit[key]["$gte"] = d[entry][0]  # type: ignore
+
+            if d[entry][1] is not None:  # type: ignore
+                crit[key]["$lte"] = d[entry][1]  # type: ignore
+
+        return {"criteria": crit}
+
+    def ensure_indexes(self):  # pragma: no cover
+        return [
+            ("binding_data.metal_element", False),
+            ("binding_data.metal_partial_charge", False),
+            ("binding_data.metal_partial_spin", False),
+            ("binding_data.metal_assigned_charge", False),
+            ("binding_data.metal_assigned_spin", False),
+            ("binding_data.number_coordinate_bonds", False),
+            ("binding_data.binding_energy", False),
+            ("binding_data.binding_enthalpy", False),
+            ("binding_data.binding_entropy", False),
+            ("binding_data.binding_free_energy", False),
+        ]

emmet-api/emmet/api/routes/molecules/metal_binding/resources.py

@@ -0,0 +1,54 @@
+from maggma.api.resource import ReadOnlyResource
+from emmet.core.molecules.metal_binding import MetalBindingDoc
+
+from maggma.api.query_operator import PaginationQuery, SortQuery, SparseFieldsQuery
+
+from emmet.api.routes.molecules.molecules.query_operators import (
+    MultiMPculeIDQuery,
+    ExactCalcMethodQuery,
+    FormulaQuery,
+    ChemsysQuery,
+    ElementsQuery,
+    ChargeSpinQuery
+)
+from emmet.api.routes.molecules.metal_binding.query_operators import BindingDataQuery
+from emmet.api.routes.molecules.utils import MethodQuery, MultiPropertyIDQuery
+from emmet.api.core.settings import MAPISettings
+from emmet.api.core.global_header import GlobalHeaderProcessor
+
+
+def metal_binding_resource(metal_binding_store):
+    resource = ReadOnlyResource(
+        metal_binding_store,
+        MetalBindingDoc,
+        query_operators=[
+            MultiMPculeIDQuery(),
+            ExactCalcMethodQuery(),
+            FormulaQuery(),
+            ChemsysQuery(),
+            ElementsQuery(),
+            ChargeSpinQuery(),
+            MethodQuery(),
+            BindingDataQuery(),
+            MultiPropertyIDQuery(),
+            SortQuery(),
+            PaginationQuery(),
+            SparseFieldsQuery(
+                MetalBindingDoc,
+                default_fields=[
+                    "molecule_id",
+                    "property_id",
+                    "solvent",
+                    "method",
+                    "last_updated"
+                ],
+            ),
+        ],
+        header_processor=GlobalHeaderProcessor(),
+        tags=["Molecules Metal Binding"],
+        sub_path="/metal_binding/",
+        disable_validation=True,
+        timeout=MAPISettings().TIMEOUT,
+    )
+
+    return resource

emmet-api/emmet/api/routes/molecules/orbitals/query_operators.py

@@ -415,7 +415,7 @@ def query(
         ),
         max_energy_difference: Optional[float] = Query(
             None,
-            description="Minimum energy difference between interacting orbitals"
+            description="Maximum energy difference between interacting orbitals"
         ),
         min_fock_element: Optional[float] = Query(
             None,

emmet-api/emmet/api/routes/molecules/redox/query_operators.py

@@ -11,50 +11,45 @@ class RedoxPotentialQuery(QueryOperator):
 
     def query(
         self,
-        electrode: str = Query(
-            "H",
-            description="Reference electrode to be queried (e.g. 'H', 'Li', 'Mg')."
-        ),
         min_reduction_potential: Optional[float] = Query(
             None,
-            description="Minimum reduction potential using the selected reference electrode."
+            description="Minimum reduction potential."
         ),
         max_reduction_potential: Optional[float] = Query(
             None,
-            description="Maximum reduction potential using the selected reference electrode."
+            description="Maximum reduction potential."
         ),
         min_oxidation_potential: Optional[float] = Query(
             None,
-            description="Minimum oxidation potential using the selected reference electrode."
+            description="Minimum oxidation potential."
         ),
         max_oxidation_potential: Optional[float] = Query(
             None,
-            description="Maximum oxidation potential using the selected reference electrode."
+            description="Maximum oxidation potential."
         ),
     ) -> STORE_PARAMS:
 
         crit: Dict[str, Any] = dict()  # type: ignore
 
         d = {
-            "oxidation_potentials": [min_oxidation_potential, max_oxidation_potential],
-            "reduction_potentials": [min_reduction_potential, max_reduction_potential]
+            "oxidation_potential": [min_oxidation_potential, max_oxidation_potential],
+            "reduction_potential": [min_reduction_potential, max_reduction_potential]
         }
 
-        for entry in d:
-            key = entry + "." + electrode
-            if d[entry][0] is not None or d[entry][1] is not None:
+        for key in d:
+            if d[key][0] is not None or d[key][1] is not None:
                 crit[key] = dict()
 
-            if d[entry][0] is not None:
-                crit[key]["$gte"] = d[entry][0]
+            if d[key][0] is not None:
+                crit[key]["$gte"] = d[key][0]
 
-            if d[entry][1] is not None:
-                crit[key]["$lte"] = d[entry][1]
+            if d[key][1] is not None:
+                crit[key]["$lte"] = d[key][1]
 
         return {"criteria": crit}
 
     def ensure_indexes(self):  # pragma: no cover
         return [
-            ("oxidation_potentials", False),
-            ("reduction_potentials", False),
+            ("oxidation_potential", False),
+            ("reduction_potential", False),
         ]

emmet-api/emmet/api/routes/molecules/tasks/query_operators.py

@@ -3,9 +3,7 @@
 from fastapi import Query
 from typing import Optional
 
-
-# TODO: might need these utils once pmg changes are in place (see below)
-# from emmet.api.routes.tasks.utils import calcs_reversed_to_trajectory, task_to_entry
+from emmet.api.routes.molecules.tasks.utils import calcs_reversed_to_trajectory
 
 
 class MultipleTaskIDsQuery(QueryOperator):
@@ -95,8 +93,44 @@ def post_process(self, docs, query):
         return d
 
 
-# TODO: class TrajectoryQuery(QueryOperator):
-# Need to write Trajectory class in pmg for Molecules
+class TrajectoryQuery(QueryOperator):
+    """
+    Method to generate a query on calculation trajectory data from task documents
+    """
+
+    def query(
+        self,
+        task_ids: Optional[str] = Query(
+            None, description="Comma-separated list of task_ids to query on"
+        ),
+    ) -> STORE_PARAMS:
+
+        crit = {}
+
+        if task_ids:
+            crit.update(
+                {
+                    "task_id": {
+                        "$in": [task_id.strip() for task_id in task_ids.split(",")]
+                    }
+                }
+            )
+
+        return {"criteria": crit}
+
+    def post_process(self, docs, query):
+        """
+        Post processing to generatore trajectory data
+        """
 
-# TODO: class EntryQuery(QueryOperator):
-# Need to write MoleculeEntry class in pmg
+        d = [
+            {
+                "task_id": doc["task_id"],
+                "trajectories": jsanitize(
+                    calcs_reversed_to_trajectory(doc["calcs_reversed"])
+                ),
+            }
+            for doc in docs
+        ]
+
+        return d

emmet-api/emmet/api/routes/molecules/tasks/resources.py

@@ -10,13 +10,12 @@
 from emmet.api.routes.molecules.tasks.query_operators import (
     DeprecationQuery,
     MultipleTaskIDsQuery,
-    # TODO:
-    # TrajectoryQuery,
+    TrajectoryQuery,
     # EntryQuery,
 )
 from emmet.api.core.global_header import GlobalHeaderProcessor
 from emmet.api.core.settings import MAPISettings
-from emmet.core.tasks import DeprecationDoc
+from emmet.core.tasks import DeprecationDoc, TrajectoryDoc
 from emmet.core.qchem.task import TaskDocument
 
 timeout = MAPISettings().TIMEOUT
@@ -65,5 +64,17 @@ def task_deprecation_resource(task_store):
     return resource
 
 
-# TODO: def trajectory_resource(task_store):
-# TODO: def entries_resource(task_store):
+def trajectory_resource(task_store):
+    resource = ReadOnlyResource(
+        task_store,
+        TrajectoryDoc,
+        query_operators=[TrajectoryQuery(), PaginationQuery()],
+        key_fields=["task_id", "calcs_reversed"],
+        tags=["Molecules Tasks"],
+        sub_path="/tasks/trajectory/",
+        header_processor=GlobalHeaderProcessor(),
+        timeout=timeout,
+        disable_validation=True,
+    )
+
+    return resource