Add metrics to summarize reliability score

pipelines/apDetectorVisitQualityCore.yaml

@@ -8,6 +8,10 @@ tasks:
       atools.numDiaSourcesAll: NumDiaSourcesAllMetric
       atools.numDipoles: NumDipolesMetric
       atools.numSsObjects: NumSsObjectsMetric
+      atools.numDiaSourcesHighReliability: NumDiaSourcesHighReliabilityMetric
+      atools.numDiaSourcesLowReliability: NumDiaSourcesLowReliabilityMetric
+      atools.numDiaSourcesNanReliability: NumDiaSourcesNanReliabilityMetric
+      atools.diaSourcesGoodVsBadRatio: DiaSourcesGoodVsBadRatioMetric
       connections.outputName: assocDiaSrcCore
       atools.simpleSky: SimpleDiaPlot
       python: |

python/lsst/analysis/tools/actions/scalar/scalarActions.py

@@ -13,13 +13,17 @@
     "MinAction",
     "FracInRange",
     "FracNan",
+    "DivideScalar",
+    "CountThreshold",
+    "CountNan"
 )
 
 import operator
 from typing import cast
 
 import numpy as np
 from lsst.pex.config import ChoiceField, Field
+from lsst.pex.config.configurableActions import ConfigurableActionField
 
 from ...interfaces import KeyedData, KeyedDataSchema, Scalar, ScalarAction, Vector
 from ...statistics import nansigmaMad
@@ -284,3 +288,94 @@ def __call__(self, data: KeyedData, **kwargs) -> Scalar:
             return 100.0 * result
         else:
             return result
+
+
+class DivideScalar(ScalarAction):
+    """Calculate (A/B) for scalars."""
+
+    actionA = ConfigurableActionField[ScalarAction](doc="Action which supplies scalar A")
+    actionB = ConfigurableActionField[ScalarAction](doc="Action which supplies scalar B")
+
+    def getInputSchema(self) -> KeyedDataSchema:
+        yield from self.actionA.getInputSchema()
+        yield from self.actionB.getInputSchema()
+
+    def __call__(self, data: KeyedData, **kwargs) -> Scalar:
+        scalarA = self.actionA(data, **kwargs)
+        scalarB = self.actionB(data, **kwargs)
+        if scalarB == 0:
+            raise ValueError("Denominator is zero!")
+        return scalarA / scalarB
+
+
+class CountThreshold(ScalarAction):
+    """Compute the count that is above or below a specified threshold.
+    The operator is specified as a string, for example, "lt", "le", "ge", "gt"
+    for the mathematical operations <, <=, >=, >. To compute the count of
+    elements with values less than a given threshold, use op="le".
+    """
+
+    op = ChoiceField[str](
+        doc="Operator name string.",
+        allowed={
+            "lt": "less than threshold",
+            "le": "less than or equal to threshold",
+            "ge": "greater than or equal to threshold",
+            "gt": "greater than threshold",
+        },
+    )
+    threshold = Field[float](doc="Threshold to apply.")
+    vectorKey = Field[str](doc="Name of column")
+    percent = Field[bool](doc="Express result as percentage", default=False)
+
+    def getInputSchema(self) -> KeyedDataSchema:
+        return ((self.vectorKey, Vector),)
+
+    def __call__(self, data: KeyedData, **kwargs) -> Scalar:
+        mask = self.getMask(**kwargs)
+        values = data[self.vectorKey.format(**kwargs)]
+        values = values[mask]
+        values = values[np.logical_not(np.isnan(values))]
+        result = cast(
+            Scalar,
+            float(np.sum(getattr(operator, self.op)(values, self.threshold))),
+        )
+        if self.percent:
+            return 100.0 * result
+        else:
+            return result
+
+
+class CountNan(ScalarAction):
+    """Compute the count of vector entries that are NaN."""
+
+    vectorKey = Field[str](doc="Name of column")
+    percent = Field[bool](doc="Express result as percentage", default=False)
+
+    def getInputSchema(self) -> KeyedDataSchema:
+        return ((self.vectorKey, Vector),)
+
+    def __call__(self, data: KeyedData, **kwargs) -> Scalar:
+        """Return the fraction of rows with NaN values.
+
+        Parameters
+        ----------
+        data : `KeyedData`
+
+        Returns
+        -------
+        result : `Scalar`
+            The count (or percentage) of rows with NaN values.
+        """
+        mask = self.getMask(**kwargs)
+        values = cast(Vector, data[self.vectorKey.format(**kwargs)])[mask]
+        nvalues = len(values)
+        values = values[np.isnan(values)]
+        result = cast(
+            Scalar,
+            float(len(values)),  # type: ignore
+        )
+        if self.percent:
+            return 100.0 * result
+        else:
+            return result

python/lsst/analysis/tools/atools/diaSourceMetrics.py

@@ -24,9 +24,13 @@
     "NumDiaSourcesAllMetric",
     "NumDiaSourcesMetric",
     "NumDipolesMetric",
+    "NumDiaSourcesHighReliabilityMetric",
+    "NumDiaSourcesLowReliabilityMetric",
+    "NumDiaSourcesNanReliabilityMetric",
+    "DiaSourcesGoodVsBadRatioMetric",
 )
 
-from ..actions.scalar import CountAction
+from ..actions.scalar import CountAction, CountNan, DivideScalar, CountThreshold
 from ..actions.vector import FlagSelector, GoodDiaSourceSelector
 from ..interfaces import AnalysisTool
 
@@ -76,3 +80,71 @@ def setDefaults(self):
 
         # the units for the quantity (count, an astropy quantity)
         self.produce.metric.units = {"numDipoles": "ct"}
+
+
+class NumDiaSourcesHighReliabilityMetric(AnalysisTool):
+    """Calculate the number of DIA Sources with reliability score higher than
+    the threshold."""
+
+    def setDefaults(self):
+        super().setDefaults()
+
+        # Count dia sources with reliability lower than the threshold
+        self.process.calculateActions.numDiaSourcesHighReliability = CountThreshold(op="gt",
+        threshold=0.9, vectorKey="reliability")
+
+        # The units for the quantity (count, an astropy quantity)
+        self.produce.metric.units = {"numDiaSourcesHighReliability": "ct"}
+
+
+class NumDiaSourcesLowReliabilityMetric(AnalysisTool):
+    """Calculate the number of DIA Sources with reliability score lower than
+    the threshold."""
+
+    def setDefaults(self):
+        super().setDefaults()
+
+        # Count dia sources with reliability lower than the threshold
+        self.process.calculateActions.numDiaSourcesLowReliability = CountThreshold(op="lt",
+        threshold=0.1, vectorKey="reliability")
+
+        # The units for the quantity (count, an astropy quantity)
+        self.produce.metric.units = {"numDiaSourcesLowReliability": "ct"}
+
+
+class NumDiaSourcesNanReliabilityMetric(AnalysisTool):
+    """Calculate the number of DIA Sources with Nan reliability score."""
+
+    def setDefaults(self):
+        super().setDefaults()
+
+        # Count dia sources with reliability lower than the threshold
+        self.process.calculateActions.numDiaSourcesNanReliability = CountNan(vectorKey="reliability")
+
+        # The units for the quantity (count, an astropy quantity)
+        self.produce.metric.units = {"numDiaSourcesNanReliability": "ct"}
+
+
+class DiaSourcesGoodVsBadRatioMetric(AnalysisTool):
+    """Calculate the ratio of 'good' vs 'bad' DIA Sources."""
+
+    def setDefaults(self):
+        super().setDefaults()
+
+        # Count dia sources with reliability higher than the threshold
+        self.process.buildActions.numDiaSourcesHighReliability = CountThreshold(op="gt",
+        threshold=0.9, vectorKey="reliability")
+
+        # Count dia sources with reliability lower than the threshold
+        self.process.buildActions.numDiaSourcesLowReliability = CountThreshold(op="lt",
+        threshold=0.1, vectorKey="reliability")
+
+        # Calculate ratio of good vs bad DIA Sources
+        self.process.calculateActions.DiaSourcesGoodVsBadRatio = DivideScalar(
+            actionA=self.process.buildActions.numDiaSourcesHighReliability, 
+            actionB=self.process.buildActions.numDiaSourcesLowReliability
+        )
+
+        # The units for the quantity (dimensionless, an astropy quantity)
+        self.produce.metric.units = {"DiaSourcesGoodVsBadRatio": ""}
+