teehr 0.5.0__tar.gz → 0.5.1.dev10__tar.gz

{teehr-0.5.0 → teehr-0.5.1.dev10}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: teehr
-Version: 0.5.0
+Version: 0.5.1.dev10
 Summary: Tools for Exploratory Evaluation in Hydrologic Research
 License: GNU v3
+License-File: LICENSE.md
 Author: RTI International
 Requires-Python: >=3.10,<3.14
 Classifier: License :: Other/Proprietary License

{teehr-0.5.0 → teehr-0.5.1.dev10}/pyproject.toml

@@ -1,12 +1,13 @@
 [tool.poetry]
 name = "teehr"
-version = "0.5.0"
+version = "0.5.1dev10"
 description = "Tools for Exploratory Evaluation in Hydrologic Research"
 authors = [
     "RTI International",
     "Matthew Denno <mdenno@rti.org>",
     "Katie van Werkhoven <kvanwerkhoven@rti.org>",
     "Sam Lamont <slamont@rti.org>",
+    "Sam Landsteiner <slandsteiner@rti.org>",
 ]
 license = "GNU v3"
 readme = "README.md"

{teehr-0.5.0 → teehr-0.5.1.dev10}/src/teehr/__init__.py

@@ -1,7 +1,7 @@
 """Initialize the TEEHR package."""
 import warnings
 
-__version__ = "0.5.0"
+__version__ = "0.5.1dev10"
 
 with warnings.catch_warnings():
     warnings.simplefilter("ignore", UserWarning)
@@ -10,7 +10,7 @@ with warnings.catch_warnings():
 from teehr.evaluation.evaluation import Evaluation  # noqa
 from teehr.models.metrics.deterministic_models import DeterministicMetrics  # noqa
 from teehr.models.metrics.probabilistic_models import ProbabilisticMetrics  # noqa
-from teehr.models.metrics.signature_models import SignatureMetrics  # noqa
+from teehr.models.metrics.signature_models import Signatures  # noqa
 from teehr.models.metrics.bootstrap_models import Bootstrappers  # noqa
 from teehr.models.metrics.basemodels import Operators  # noqa
 from teehr.models.pydantic_table_models import (  # noqa

{teehr-0.5.0 → teehr-0.5.1.dev10}/src/teehr/examples/03-metric_queries.ipynb

@@ -118,7 +118,7 @@
    "outputs": [],
    "source": [
     "from teehr import DeterministicMetrics as metrics\n",
-    "from teehr import SignatureMetrics as sig_metrics"
+    "from teehr import Signatures as sig_metrics"
    ]
   },
   {

{teehr-0.5.0 → teehr-0.5.1.dev10}/src/teehr/fetching/usgs/usgs.py

@@ -44,7 +44,9 @@ from teehr.fetching.const import (
     USGS_VARIABLE_MAPPER
 )
 
-DATETIME_STR_FMT = "%Y-%m-%dT%H:%M:00+0000"
+HOURLY_DATETIME_STR_FMT = "%Y-%m-%dT%H:%M:00+0000"
+DAILY_DATETIME_STR_FMT = "%Y-%m-%d"
+
 DAYLIGHT_SAVINGS_PAD = timedelta(hours=2)
 
 pd.options.mode.copy_on_write = True
@@ -211,11 +213,22 @@ def _fetch_usgs_streamflow(
 ) -> pd.DataFrame:
     """Fetch USGS gage data and format to TEEHR format."""
     logger.debug("Fetching USGS streamflow data from NWIS.")
-    start_dt_str = start_date.strftime(DATETIME_STR_FMT)
+
+    if service == "iv":
+        datetime_str_format = HOURLY_DATETIME_STR_FMT
+    elif service == "dv":
+        datetime_str_format = DAILY_DATETIME_STR_FMT
+    else:
+        err_msg = f"Service '{service}' is not supported. Valid options are 'iv' and 'dv'."
+        logger.error(err_msg)
+        raise ValueError(err_msg)
+
+    start_dt_str = start_date.strftime(datetime_str_format)
+
     end_dt_str = (
         end_date
         - timedelta(minutes=1)
-    ).strftime(DATETIME_STR_FMT)
+    ).strftime(datetime_str_format)
 
     # Parse out list of sites.
     parsed_sites = _parse_site_id_list(sites)

{teehr-0.5.0 → teehr-0.5.1.dev10}/src/teehr/metrics/bootstrap_funcs.py

@@ -4,13 +4,8 @@ import logging
 
 import pandas as pd
 import numpy as np
-# from arch.bootstrap import (
-#     StationaryBootstrap,
-#     CircularBlockBootstrap,
-# )
 
 from teehr.models.metrics.basemodels import MetricsBasemodel
-# from teehr.metrics.gumboot_bootstrap import GumbootBootstrap
 
 logger = logging.getLogger(__name__)
 
@@ -57,6 +52,33 @@ def create_circularblock_func(model: MetricsBasemodel) -> Callable:
             )
         else:
             return results.ravel()
+
+    def signature_bootstrap_func(p: pd.Series) -> Dict:
+        """Bootstrap function."""
+        bs = CircularBlockBootstrap(
+            model.bootstrap.block_size,
+            p,
+            seed=model.bootstrap.seed,
+            random_state=model.bootstrap.random_state
+        )
+
+        results = bs.apply(
+            model.func(model),
+            model.bootstrap.reps
+        )
+
+        if model.bootstrap.quantiles is not None:
+            return _calculate_quantiles(
+                model.output_field_name,
+                results,
+                model.bootstrap.quantiles,
+            )
+        else:
+            return results.ravel()
+
+    if len(model.input_field_names) == 1:
+        return signature_bootstrap_func
+
     return bootstrap_func
 
 
@@ -91,6 +113,34 @@ def create_gumboot_func(model: MetricsBasemodel) -> Callable:
             )
         else:
             return results.ravel()
+
+    def signature_bootstrap_func(p: pd.Series, vt: pd.Series) -> Dict:
+        """Bootstrap function."""
+        bs = GumbootBootstrap(
+            p,
+            value_time=vt,
+            seed=model.bootstrap.seed,
+            water_year_month=model.bootstrap.water_year_month,
+            boot_year_file=model.bootstrap.boot_year_file
+        )
+
+        results = bs.apply(
+            model.func(model),
+            model.bootstrap.reps
+        )
+
+        if model.bootstrap.quantiles is not None:
+            return _calculate_quantiles(
+                model.output_field_name,
+                results,
+                model.bootstrap.quantiles,
+            )
+        else:
+            return results.ravel()
+
+    if len(model.input_field_names) == 1:
+        return signature_bootstrap_func
+
     return bootstrap_func
 
 
@@ -124,4 +174,31 @@ def create_stationary_func(model: MetricsBasemodel) -> Callable:
             )
         else:
             return results.ravel()
+
+    def signature_bootstrap_func(p: pd.Series) -> Dict:
+        """Bootstrap function."""
+        bs = StationaryBootstrap(
+            model.bootstrap.block_size,
+            p,
+            seed=model.bootstrap.seed,
+            random_state=model.bootstrap.random_state
+        )
+
+        results = bs.apply(
+            model.func(model),
+            model.bootstrap.reps
+        )
+
+        if model.bootstrap.quantiles is not None:
+            return _calculate_quantiles(
+                model.output_field_name,
+                results,
+                model.bootstrap.quantiles,
+            )
+        else:
+            return results.ravel()
+
+    if len(model.input_field_names) == 1:
+        return signature_bootstrap_func
+
     return bootstrap_func

{teehr-0.5.0 → teehr-0.5.1.dev10}/src/teehr/metrics/deterministic_funcs.py

@@ -2,6 +2,7 @@
 import numpy as np
 import numpy.typing as npt
 import pandas as pd
+from scipy.stats import rankdata
 
 from teehr.models.metrics.basemodels import MetricsBasemodel
 from teehr.models.metrics.basemodels import TransformEnum
@@ -10,6 +11,8 @@ from typing import Callable, Optional
 import logging
 logger = logging.getLogger(__name__)
 
+EPSILON = 1e-6  # Small constant to avoid division by zero
+
 
 def _transform(
         p: pd.Series,
@@ -22,6 +25,12 @@ def _transform(
     if model.transform is not None:
         match model.transform:
             case TransformEnum.log:
+                if model.add_epsilon:
+                    logger.debug(
+                        "Applying epsilon before log transform"
+                    )
+                    p = p + EPSILON
+                    s = s + EPSILON
                 logger.debug("Applying log transform")
                 p = np.log(p)
                 s = np.log(s)
@@ -42,6 +51,12 @@ def _transform(
                 p = np.exp(p)
                 s = np.exp(s)
             case TransformEnum.inv:
+                if model.add_epsilon:
+                    logger.debug(
+                        "Applying epsilon before inverse transform"
+                    )
+                    p = p + EPSILON
+                    s = s + EPSILON
                 logger.debug("Applying inverse transform")
                 p = 1.0 / p
                 s = 1.0 / s
@@ -125,7 +140,12 @@ def relative_bias(model: MetricsBasemodel) -> Callable:
         """Relative Bias."""
         p, s = _transform(p, s, model)
         difference = s - p
-        return np.sum(difference)/np.sum(p)
+        if model.add_epsilon:
+            result = np.sum(difference)/(np.sum(p) + EPSILON)
+        else:
+            result = np.sum(difference)/np.sum(p)
+
+        return result
 
     return relative_bias_inner
 
@@ -142,7 +162,12 @@ def mean_absolute_relative_error(model: MetricsBasemodel) -> Callable:
         """Absolute Relative Error."""
         p, s = _transform(p, s, model)
         absolute_difference = np.abs(s - p)
-        return np.sum(absolute_difference)/np.sum(p)
+        if model.add_epsilon:
+            result = np.sum(absolute_difference)/(np.sum(p) + EPSILON)
+        else:
+            result = np.sum(absolute_difference)/np.sum(p)
+
+        return result
 
     return mean_absolute_relative_error_inner
 
@@ -157,7 +182,12 @@ def multiplicative_bias(model: MetricsBasemodel) -> Callable:
     def multiplicative_bias_inner(p: pd.Series, s: pd.Series) -> float:
         """Multiplicative Bias."""
         p, s = _transform(p, s, model)
-        return np.mean(s)/np.mean(p)
+        if model.add_epsilon:
+            result = np.mean(s)/(np.mean(p) + EPSILON)
+        else:
+            result = np.mean(s)/np.mean(p)
+
+        return result
 
     return multiplicative_bias_inner
 
@@ -172,11 +202,45 @@ def pearson_correlation(model: MetricsBasemodel) -> Callable:
     def pearson_correlation_inner(p: pd.Series, s: pd.Series) -> float:
         """Pearson Correlation Coefficient."""
         p, s = _transform(p, s, model)
-        return np.corrcoef(s, p)[0][1]
+
+        if model.add_epsilon:
+            # Calculate covariance between p and s
+            numerator = np.cov(p, s)[0, 1]
+
+            # Calculate standard deviations and multiply them
+            denominator = np.nanstd(p) * np.nanstd(s) + EPSILON
+
+            # Calculate correlation coefficient
+            result = numerator / denominator
+
+        else:
+            result = np.corrcoef(s, p)[0][1]
+
+        return result
 
     return pearson_correlation_inner
 
 
+def variability_ratio(model: MetricsBasemodel) -> Callable:
+    """Create the Variability Ratio metric function.
+
+    :math:`VR=\\frac{\\sigma_{sec}}{\\sigma_{prim}}`
+    """ # noqa
+    logger.debug("Building the variability_ratio metric function")
+
+    def variability_ratio_inner(p: pd.Series, s: pd.Series) -> float:
+        """Variability Ratio."""
+        p, s = _transform(p, s, model)
+        if model.add_epsilon:
+            result = (np.std(s))/(np.std(p) + EPSILON)
+        else:
+            result = np.std(s)/np.std(p)
+
+        return result
+
+    return variability_ratio_inner
+
+
 def r_squared(model: MetricsBasemodel) -> Callable:
     """Create the R-squared metric function.
 
@@ -187,8 +251,23 @@ def r_squared(model: MetricsBasemodel) -> Callable:
     def r_squared_inner(p: pd.Series, s: pd.Series) -> float:
         """R-squared."""
         p, s = _transform(p, s, model)
-        pearson_correlation_coefficient = np.corrcoef(s, p)[0][1]
-        return np.power(pearson_correlation_coefficient, 2)
+
+        if model.add_epsilon:
+            # Calculate covariance between p and s
+            numerator = np.cov(p, s)[0, 1]
+
+            # Calculate standard deviations and multiply them
+            denominator = np.nanstd(p) * np.nanstd(s) + EPSILON
+
+            # Calculate correlation coefficient and square it
+            pearson_correlation_coefficient = numerator / denominator
+            result = np.power(pearson_correlation_coefficient, 2)
+
+        else:
+            pearson_correlation_coefficient = np.corrcoef(s, p)[0][1]
+            result = np.power(pearson_correlation_coefficient, 2)
+
+        return result
 
     return r_squared_inner
 
@@ -235,10 +314,18 @@ def annual_peak_relative_bias(model: MetricsBasemodel) -> Callable:
         secondary_yearly_max_values = df.groupby(
             df.value_time.dt.year
         ).secondary_value.max()
-        return np.sum(
-            secondary_yearly_max_values
-            - primary_yearly_max_values
-            ) / np.sum(primary_yearly_max_values)
+        if model.add_epsilon:
+            result = np.sum(
+                secondary_yearly_max_values
+                - primary_yearly_max_values
+                ) / (np.sum(primary_yearly_max_values) + EPSILON)
+        else:
+            result = np.sum(
+                secondary_yearly_max_values
+                - primary_yearly_max_values
+                ) / np.sum(primary_yearly_max_values)
+
+        return result
 
     return annual_peak_relative_bias_inner
 
@@ -254,13 +341,23 @@ def spearman_correlation(model: MetricsBasemodel) -> Callable:
         """Spearman Rank Correlation Coefficient."""
         p, s = _transform(p, s, model)
 
-        primary_rank = p.rank()
-        secondary_rank = s.rank()
-        count = len(p)
-        return 1 - (
-            6 * np.sum(np.abs(primary_rank - secondary_rank)**2)
-            / (count * (count**2 - 1))
-            )
+        # calculate ranks (average method for ties)
+        primary_ranks = rankdata(p, method='average')
+        secondary_ranks = rankdata(s, method='average')
+
+        # calculate covariance between p_rank and s_rank
+        covariance = np.cov(primary_ranks, secondary_ranks)[0, 1]
+
+        # calculate standard deviations of ranks
+        std_primary = np.std(primary_ranks)
+        std_secondary = np.std(secondary_ranks)
+
+        if model.add_epsilon:
+            result = covariance / (std_primary * std_secondary + EPSILON)
+        else:
+            result = covariance / (std_primary * std_secondary)
+
+        return result
 
     return spearman_correlation_inner
 
@@ -282,7 +379,10 @@ def nash_sutcliffe_efficiency(model: MetricsBasemodel) -> Callable:
         p, s = _transform(p, s, model)
 
         numerator = np.sum(np.subtract(p, s) ** 2)
-        denominator = np.sum(np.subtract(p, np.mean(p)) ** 2)
+        if model.add_epsilon:
+            denominator = np.sum(np.subtract(p, np.mean(p)) ** 2) + EPSILON
+        else:
+            denominator = np.sum(np.subtract(p, np.mean(p)) ** 2)
         if numerator == np.nan or denominator == np.nan:
             return np.nan
         if denominator == 0:
@@ -313,7 +413,10 @@ def nash_sutcliffe_efficiency_normalized(model: MetricsBasemodel) -> Callable:
         p, s = _transform(p, s, model)
 
         numerator = np.sum(np.subtract(p, s) ** 2)
-        denominator = np.sum(np.subtract(p, np.mean(p)) ** 2)
+        if model.add_epsilon:
+            denominator = np.sum(np.subtract(p, np.mean(p)) ** 2) + EPSILON
+        else:
+            denominator = np.sum(np.subtract(p, np.mean(p)) ** 2)
         if numerator == np.nan or denominator == np.nan:
             return np.nan
         if denominator == 0:
@@ -343,10 +446,16 @@ def kling_gupta_efficiency(model: MetricsBasemodel) -> Callable:
         linear_correlation = np.corrcoef(s, p)[0, 1]
 
         # Relative variability
-        relative_variability = np.std(s) / np.std(p)
+        if model.add_epsilon:
+            relative_variability = np.std(s) / (np.std(p) + EPSILON)
+        else:
+            relative_variability = np.std(s) / np.std(p)
 
         # Relative mean
-        relative_mean = np.mean(s) / np.mean(p)
+        if model.add_epsilon:
+            relative_mean = np.mean(s) / (np.mean(p) + EPSILON)
+        else:
+            relative_mean = np.mean(s) / np.mean(p)
 
         # Scaled Euclidean distance
         euclidean_distance = np.sqrt(
@@ -379,13 +488,21 @@ def kling_gupta_efficiency_mod1(model: MetricsBasemodel) -> Callable:
         linear_correlation = np.corrcoef(s, p)[0, 1]
 
         # Variability_ratio
-        variability_ratio = (
-            (np.std(s) / np.mean(s))
-            / (np.std(p) / np.mean(p))
-        )
-
+        if model.add_epsilon:
+            variability_ratio = (
+                (np.std(s) / (np.mean(s) + EPSILON))
+                / (np.std(p) / (np.mean(p) + EPSILON))
+            )
+        else:
+            variability_ratio = (
+                (np.std(s) / np.mean(s))
+                / (np.std(p) / np.mean(p))
+            )
         # Relative mean (same as kge)
-        relative_mean = (np.mean(s) / np.mean(p))
+        if model.add_epsilon:
+            relative_mean = (np.mean(s) / (np.mean(p) + EPSILON))
+        else:
+            relative_mean = (np.mean(s) / np.mean(p))
 
         # Scaled Euclidean distance
         euclidean_distance = np.sqrt(
@@ -417,14 +534,24 @@ def kling_gupta_efficiency_mod2(model: MetricsBasemodel) -> Callable:
         linear_correlation = np.corrcoef(s, p)[0, 1]
 
         # Relative variability (same as kge)
-        relative_variability = (np.std(s) / np.std(p))
+        if model.add_epsilon:
+            relative_variability = (np.std(s) / (np.std(p) + EPSILON))
+        else:
+            relative_variability = (np.std(s) / np.std(p))
 
         # bias component
-        bias_component = (
-            ((np.mean(s) - np.mean(p)) ** 2)
-            /
-            (np.std(p) ** 2)
-        )
+        if model.add_epsilon:
+            bias_component = (
+                ((np.mean(s) - np.mean(p)) ** 2)
+                /
+                ((np.std(p) ** 2) + EPSILON)
+            )
+        else:
+            bias_component = (
+                ((np.mean(s) - np.mean(p)) ** 2)
+                /
+                (np.std(p) ** 2)
+            )
 
         # Scaled Euclidean distance
         euclidean_distance = np.sqrt(
@@ -499,7 +626,12 @@ def root_mean_standard_deviation_ratio(model: MetricsBasemodel) -> Callable:
         p, s = _transform(p, s, model)
         rmse = _root_mean_squared_error(p, s)
         obs_std_dev = np.std(p)
-        return rmse / obs_std_dev
+        if model.add_epsilon:
+            result = rmse / (obs_std_dev + EPSILON)
+        else:
+            result = rmse / obs_std_dev
+
+        return result
 
     return root_mean_standard_deviation_ratio_inner
 

{teehr-0.5.0 → teehr-0.5.1.dev10}/src/teehr/metrics/signature_funcs.py

@@ -8,6 +8,8 @@ from typing import Callable, Optional
 import logging
 logger = logging.getLogger(__name__)
 
+EPSILON = 1e-6  # Small constant to avoid division by zero
+
 
 def _transform(
         p: pd.Series,
@@ -19,6 +21,9 @@ def _transform(
     if model.transform is not None:
         match model.transform:
             case TransformEnum.log:
+                if model.add_epsilon:
+                    logger.debug("Adding epsilon to avoid log(0)")
+                    p = p + EPSILON
                 logger.debug("Applying log transform")
                 p = np.log(p)
             case TransformEnum.sqrt:
@@ -34,6 +39,9 @@ def _transform(
                 logger.debug("Applying exponential transform")
                 p = np.exp(p)
             case TransformEnum.inv:
+                if model.add_epsilon:
+                    logger.debug("Adding epsilon to avoid division by zero")
+                    p = p + EPSILON
                 logger.debug("Applying inverse transform")
                 p = 1.0 / p
             case TransformEnum.abs:
@@ -151,3 +159,60 @@ def sum(model: MetricsBasemodel) -> Callable:
         return np.sum(p)
 
     return sum_inner
+
+
+def flow_duration_curve_slope(model: MetricsBasemodel) -> Callable:
+    """Create flow duration curve slope metric function."""
+    logger.debug("Building the flow duration curve slope metric function")
+
+    def flow_duration_curve_slope_inner(
+        p: pd.Series,
+    ) -> float:
+        """Flow duration curve slope."""
+        # ensure percentiles are within valid range
+        if not (0 <= model.lower_quantile <= 1):
+            raise ValueError(
+                "Lower quantile must be between 0 and 1"
+                )
+        if not (0 <= model.upper_quantile <= 1):
+            raise ValueError(
+                "Upper quantile must be between 0 and 1"
+                )
+
+        # ensure lower quantile is less than upper quantile
+        if model.lower_quantile >= model.upper_quantile:
+            raise ValueError(
+                "Lower quantile must be less than upper quantile"
+                )
+
+        # apply any specified transform
+        p = _transform(p, model)
+
+        # sort the streamflow values in descending order
+        p_sorted = p.sort_values(ascending=False).reset_index(drop=True)
+
+        # calculate exceedance probabilities
+        n = len(p_sorted)
+        fdc_probs = (p_sorted.index/(n+1))
+
+        # determine indices for the specified quantiles
+        lower_idx = np.argmin(np.abs(fdc_probs - model.lower_quantile))
+        upper_idx = np.argmin(np.abs(fdc_probs - model.upper_quantile))
+
+        # check for as_percentile flag
+        if model.as_percentile:
+            fdc_probs = fdc_probs * 100
+
+        # calculate slope between the two quantiles
+        if model.add_epsilon:
+            slope = (p_sorted.iloc[upper_idx] - p_sorted.iloc[lower_idx]) / ((
+                fdc_probs[upper_idx] - fdc_probs[lower_idx]
+            ) + EPSILON)
+        else:
+            slope = (p_sorted.iloc[upper_idx] - p_sorted.iloc[lower_idx]) / (
+                fdc_probs[upper_idx] - fdc_probs[lower_idx]
+            )
+
+        return slope
+
+    return flow_duration_curve_slope_inner

{teehr-0.5.0 → teehr-0.5.1.dev10}/src/teehr/models/calculated_fields/row_level.py

@@ -267,7 +267,7 @@ class ThresholdValueExceeded(CalculatedFieldABC, CalculatedFieldBaseModel):
         Default: "primary_value"
     - threshold_field_name:
         The name of the column containing the threshold value.
-        Default: 0
+        Default: "secondary_value"
     - output_field_name:
         The name of the column to store the boolean value.
         Default: "threshold_value_exceeded"
@@ -290,7 +290,51 @@ class ThresholdValueExceeded(CalculatedFieldABC, CalculatedFieldBaseModel):
         def func(input_value: pd.Series,
                  threshold_value: pd.Series
                  ) -> pd.Series:
-            mask = input_value > threshold_value
+            mask = input_value.astype(float) > threshold_value.astype(float)
+            return mask
+
+        sdf = sdf.withColumn(
+            self.output_field_name,
+            func(self.input_field_name,
+                 self.threshold_field_name)
+        )
+        return sdf
+
+
+class ThresholdValueNotExceeded(CalculatedFieldABC, CalculatedFieldBaseModel):
+    """Adds boolean column indicating if the input value is less than or equal to a threshold.
+
+    Properties
+    ----------
+    - input_field_name:
+        The name of the column containing the primary value.
+        Default: "primary_value"
+    - threshold_field_name:
+        The name of the column containing the threshold value.
+        Default: "secondary_value"
+    - output_field_name:
+        The name of the column to store the boolean value.
+        Default: "threshold_value_not_exceeded"
+
+    """ # noqa
+
+    input_field_name: str = Field(
+        default="primary_value"
+    )
+    threshold_field_name: str = Field(
+        default="secondary_value"
+    )
+    output_field_name: str = Field(
+        default="threshold_value_not_exceeded"
+    )
+
+    def apply_to(self, sdf: ps.DataFrame) -> ps.DataFrame:
+        """Apply the calculated field to the Spark DataFrame."""
+        @pandas_udf(returnType=T.BooleanType())
+        def func(input_value: pd.Series,
+                 threshold_value: pd.Series
+                 ) -> pd.Series:
+            mask = input_value.astype(float) <= threshold_value.astype(float)
             return mask
 
         sdf = sdf.withColumn(
@@ -429,5 +473,6 @@ class RowLevelCalculatedFields:
     Seasons = Seasons
     ForecastLeadTime = ForecastLeadTime
     ThresholdValueExceeded = ThresholdValueExceeded
+    ThresholdValueNotExceeded = ThresholdValueNotExceeded
     DayOfYear = DayOfYear
     HourOfYear = HourOfYear