From 9fc694bd558237d37d9c877331e2939e2c61ac03 Mon Sep 17 00:00:00 2001
From: Thibault Hallouin <thibault.hallouin@inrae.fr>
Date: Tue, 27 Dec 2022 12:13:10 +0100
Subject: [PATCH] add missing opening/closing curly brackets in for/if-else
structures
---
.../evalhyd/detail/determinist/evaluator.hpp | 69 +++++++----
include/evalhyd/detail/masks.hpp | 108 ++++++++++++++++--
.../evalhyd/detail/probabilist/evaluator.hpp | 42 ++++---
include/evalhyd/detail/uncertainty.hpp | 32 ++++--
include/evalhyd/detail/utils.hpp | 20 ++++
include/evalhyd/evald.hpp | 54 ++++++++-
include/evalhyd/evalp.hpp | 74 +++++++++++-
tests/test_determinist.cpp | 6 +-
tests/test_probabilist.cpp | 3 +-
9 files changed, 341 insertions(+), 67 deletions(-)
diff --git a/include/evalhyd/detail/determinist/evaluator.hpp b/include/evalhyd/detail/determinist/evaluator.hpp
index bd2b745..71a93c1 100644
--- a/include/evalhyd/detail/determinist/evaluator.hpp
+++ b/include/evalhyd/detail/determinist/evaluator.hpp
@@ -74,7 +74,8 @@ namespace evalhyd
t_msk = xt::ones<bool>({n_msk, n_srs, n_tim});
xt::view(t_msk, xt::all()) =
xt::view(msk, xt::all(), xt::newaxis(), xt::all());
- for (std::size_t m = 0; m < n_msk; m++) {
+ for (std::size_t m = 0; m < n_msk; m++)
+ {
xt::view(t_msk, m) =
xt::where(obs_nan | prd_nan,
false, xt::view(t_msk, m));
@@ -116,13 +117,15 @@ namespace evalhyd
void Evaluator<D2, B2>::calc_mean_obs()
{
mean_obs = xt::zeros<double>(mean_dims);
- for (std::size_t m = 0; m < n_msk; m++) {
+ for (std::size_t m = 0; m < n_msk; m++)
+ {
// apply the mask
// (using NaN workaround until reducers work on masked_view)
auto obs_masked = xt::where(xt::view(t_msk, m), q_obs, NAN);
// compute variable one sample at a time
- for (std::size_t e = 0; e < n_exp; e++) {
+ for (std::size_t e = 0; e < n_exp; e++)
+ {
// apply the bootstrap sampling
auto obs = xt::view(obs_masked, xt::all(), b_exp[e]);
xt::view(mean_obs, m, e) =
@@ -143,13 +146,15 @@ namespace evalhyd
void Evaluator<D2, B2>::calc_mean_prd()
{
mean_prd = xt::zeros<double>(mean_dims);
- for (std::size_t m = 0; m < n_msk; m++) {
+ for (std::size_t m = 0; m < n_msk; m++)
+ {
// apply the mask
// (using NaN workaround until reducers work on masked_view)
auto prd_masked = xt::where(xt::view(t_msk, m), q_prd, NAN);
// compute variable one sample at a time
- for (std::size_t e = 0; e < n_exp; e++) {
+ for (std::size_t e = 0; e < n_exp; e++)
+ {
// apply the bootstrap sampling
auto prd = xt::view(prd_masked, xt::all(), b_exp[e]);
xt::view(mean_prd, m, e) =
@@ -190,12 +195,14 @@ namespace evalhyd
void Evaluator<D2, B2>::calc_quad_obs()
{
quad_obs = xt::zeros<double>(inter_dims);
- for (std::size_t m = 0; m < n_msk; m++) {
+ for (std::size_t m = 0; m < n_msk; m++)
+ {
// apply the mask
// (using NaN workaround until reducers work on masked_view)
auto obs_masked = xt::where(xt::view(t_msk, m), q_obs, NAN);
- for (std::size_t e = 0; e < n_exp; e++) {
+ for (std::size_t e = 0; e < n_exp; e++)
+ {
xt::view(quad_obs, m, e) = xt::square(
obs_masked - xt::view(mean_obs, m, e)
);
@@ -218,12 +225,14 @@ namespace evalhyd
void Evaluator<D2, B2>::calc_quad_prd()
{
quad_prd = xt::zeros<double>(inter_dims);
- for (std::size_t m = 0; m < n_msk; m++) {
+ for (std::size_t m = 0; m < n_msk; m++)
+ {
// apply the mask
// (using NaN workaround until reducers work on masked_view)
auto prd_masked = xt::where(xt::view(t_msk, m), q_prd, NAN);
- for (std::size_t e = 0; e < n_exp; e++) {
+ for (std::size_t e = 0; e < n_exp; e++)
+ {
xt::view(quad_prd, m, e) = xt::square(
prd_masked - xt::view(mean_prd, m, e)
);
@@ -260,14 +269,16 @@ namespace evalhyd
// calculate error in timing and dynamics $r_{pearson}$
// (Pearson's correlation coefficient)
r_pearson = xt::zeros<double>(inner_dims);
- for (std::size_t m = 0; m < n_msk; m++) {
+ for (std::size_t m = 0; m < n_msk; m++)
+ {
// apply the mask
// (using NaN workaround until reducers work on masked_view)
auto prd_masked = xt::where(xt::view(t_msk, m), q_prd, NAN);
auto obs_masked = xt::where(xt::view(t_msk, m), q_obs, NAN);
// compute variable one sample at a time
- for (std::size_t e = 0; e < n_exp; e++) {
+ for (std::size_t e = 0; e < n_exp; e++)
+ {
auto prd = xt::view(prd_masked, xt::all(), b_exp[e]);
auto obs = xt::view(obs_masked, xt::all(), b_exp[e]);
auto r_num = xt::nansum(
@@ -309,14 +320,16 @@ namespace evalhyd
{
// calculate error in spread of flow $alpha$
alpha = xt::zeros<double>(inner_dims);
- for (std::size_t m = 0; m < n_msk; m++) {
+ for (std::size_t m = 0; m < n_msk; m++)
+ {
// apply the mask
// (using NaN workaround until reducers work on masked_view)
auto prd_masked = xt::where(xt::view(t_msk, m), q_prd, NAN);
auto obs_masked = xt::where(xt::view(t_msk, m), q_obs, NAN);
// compute variable one sample at a time
- for (std::size_t e = 0; e < n_exp; e++) {
+ for (std::size_t e = 0; e < n_exp; e++)
+ {
auto prd = xt::view(prd_masked, xt::all(), b_exp[e]);
auto obs = xt::view(obs_masked, xt::all(), b_exp[e]);
xt::view(alpha, m, e) =
@@ -342,14 +355,16 @@ namespace evalhyd
{
// calculate $bias$
bias = xt::zeros<double>(inner_dims);
- for (std::size_t m = 0; m < n_msk; m++) {
+ for (std::size_t m = 0; m < n_msk; m++)
+ {
// apply the mask
// (using NaN workaround until reducers work on masked_view)
auto prd_masked = xt::where(xt::view(t_msk, m), q_prd, NAN);
auto obs_masked = xt::where(xt::view(t_msk, m), q_obs, NAN);
// compute variable one sample at a time
- for (std::size_t e = 0; e < n_exp; e++) {
+ for (std::size_t e = 0; e < n_exp; e++)
+ {
auto prd = xt::view(prd_masked, xt::all(), b_exp[e]);
auto obs = xt::view(obs_masked, xt::all(), b_exp[e]);
xt::view(bias, m, e) =
@@ -371,13 +386,15 @@ namespace evalhyd
{
// compute RMSE
RMSE = xt::zeros<double>(final_dims);
- for (std::size_t m = 0; m < n_msk; m++) {
+ for (std::size_t m = 0; m < n_msk; m++)
+ {
// apply the mask
// (using NaN workaround until reducers work on masked_view)
auto quad_err_masked = xt::where(xt::view(t_msk, m), quad_err, NAN);
// compute variable one sample at a time
- for (std::size_t e = 0; e < n_exp; e++) {
+ for (std::size_t e = 0; e < n_exp; e++)
+ {
auto err2 = xt::view(quad_err_masked, xt::all(), b_exp[e]);
xt::view(RMSE, xt::all(), m, e) = xt::sqrt(xt::nanmean(err2, -1));
}
@@ -399,13 +416,15 @@ namespace evalhyd
void Evaluator<D2, B2>::calc_NSE()
{
NSE = xt::zeros<double>(final_dims);
- for (std::size_t m = 0; m < n_msk; m++) {
+ for (std::size_t m = 0; m < n_msk; m++)
+ {
// apply the mask
// (using NaN workaround until reducers work on masked_view)
auto quad_err_masked = xt::where(xt::view(t_msk, m), quad_err, NAN);
// compute variable one sample at a time
- for (std::size_t e = 0; e < n_exp; e++) {
+ for (std::size_t e = 0; e < n_exp; e++)
+ {
// compute squared errors operands
auto err2 = xt::view(quad_err_masked, xt::all(), b_exp[e]);
xt::xtensor<double, 1> f_num =
@@ -438,8 +457,10 @@ namespace evalhyd
void Evaluator<D2, B2>::calc_KGE()
{
KGE = xt::zeros<double>(final_dims);
- for (std::size_t m = 0; m < n_msk; m++) {
- for (std::size_t e = 0; e < n_exp; e++) {
+ for (std::size_t m = 0; m < n_msk; m++)
+ {
+ for (std::size_t e = 0; e < n_exp; e++)
+ {
// compute KGE
xt::view(KGE, xt::all(), m, e) = 1 - xt::sqrt(
xt::square(xt::view(r_pearson, m, e) - 1)
@@ -474,8 +495,10 @@ namespace evalhyd
void Evaluator<D2, B2>::calc_KGEPRIME()
{
KGEPRIME = xt::zeros<double>(final_dims);
- for (std::size_t m = 0; m < n_msk; m++) {
- for (std::size_t e = 0; e < n_exp; e++) {
+ for (std::size_t m = 0; m < n_msk; m++)
+ {
+ for (std::size_t e = 0; e < n_exp; e++)
+ {
// calculate error in spread of flow $gamma$
auto gamma = xt::view(alpha, m, e)
* (xt::view(mean_obs, m, e, xt::all(), 0)
diff --git a/include/evalhyd/detail/masks.hpp b/include/evalhyd/detail/masks.hpp
index d4a1c6b..46313e5 100644
--- a/include/evalhyd/detail/masks.hpp
+++ b/include/evalhyd/detail/masks.hpp
@@ -62,32 +62,42 @@ namespace evalhyd
std::set<std::string> supported_op =
{"<", ">", "<=", ">=", "!=", "=="};
if (mt[1].str().empty())
+ {
throw std::runtime_error(
"missing operator for streamflow masking condition"
);
+ }
else if (supported_op.find(mt[1]) != supported_op.end())
{
if ((mt[2].str() == "median")
|| (mt[2].str() == "mean")
|| (mt[2].str() == "quantile"))
+ {
conditions.push_back({mt[1].str(), mt[2].str(), mt[3].str()});
+ }
else
+ {
// it is a simple numerical value, swap last two
conditions.push_back({mt[1].str(), mt[3].str(), mt[2].str()});
+ }
}
else
+ {
throw std::runtime_error(
"invalid operator for streamflow masking "
"condition: " + mt[1].str()
);
+ }
}
// check that a maximum of two conditions were provided
if (conditions.size() > 2)
+ {
throw std::runtime_error(
"no more than two streamflow masking conditions "
"can be provided"
);
+ }
subset[var] = conditions;
}
@@ -119,11 +129,15 @@ namespace evalhyd
// check whether it is all indices, a range of indices, or an index
if (m[1] == ":")
+ {
// it is all indices (i.e. t{:}) so keep everything
condition.emplace_back();
+ }
else if (m[2].str().empty())
+ {
// it is an index (i.e. t{#})
condition.push_back({m[1].str()});
+ }
else
{
// it is a range of indices (i.e. t{#:#})
@@ -160,9 +174,11 @@ namespace evalhyd
// check if conditions were found in parsing
if (subset.empty())
+ {
throw std::runtime_error(
"no valid condition found to generate mask(s)"
);
+ }
// initialise a boolean expression for the masks
xt::xtensor<bool, 1> t_msk = xt::zeros<bool>(q_obs.shape());
@@ -179,25 +195,33 @@ namespace evalhyd
{
// preprocess streamflow depending on kind
auto get_q = [&]() {
- if (var == "q_obs") {
+ if (var == "q_obs")
+ {
return q_obs;
}
- else if (var == "q_prd_median") {
+ else if (var == "q_prd_median")
+ {
if (q_prd.size() < 1)
+ {
throw std::runtime_error(
"condition on streamflow predictions "
"not allowed for generating masks"
);
+ }
xt::xtensor<double, 1> q_prd_median =
xt::median(q_prd, 0);
return q_prd_median;
}
- else { // i.e. (var == "q_prd_mean")
+ else
+ {
+ // i.e. (var == "q_prd_mean")
if (q_prd.size() < 1)
+ {
throw std::runtime_error(
"condition on streamflow predictions "
"not allowed for generating masks"
);
+ }
xt::xtensor<double, 1> q_prd_mean =
xt::mean(q_prd, 0);
return q_prd_mean;
@@ -206,16 +230,26 @@ namespace evalhyd
auto q = get_q();
// define lambda function to precompute mean/median/quantile
- auto get_val = [&](const std::string& str, const std::string& num) {
- if (str.empty())
- // it is a simple numerical value
+ auto get_val =
+ [&](const std::string& str, const std::string& num)
+ {
+ if (str.empty()) // it is a simple numerical value
+ {
return std::stod(num);
+ }
else if (str == "median")
+ {
return xt::median(q);
+ }
else if (str == "mean")
+ {
return xt::mean(q)();
+ }
else // (str == "quantile")
+ {
return eh::maths::quantile(q, std::stod(num));
+ }
+
};
// preprocess conditions to identify special cases
@@ -238,8 +272,13 @@ namespace evalhyd
if ((opr2 == ">") || (opr2 == ">="))
{
if (val2 > val1)
+ {
without = true;
- else { within = true; }
+ }
+ else
+ {
+ within = true;
+ }
}
}
else if ((opr1 == ">") || (opr1 == ">="))
@@ -247,8 +286,13 @@ namespace evalhyd
if ((opr2 == "<") || (opr2 == "<="))
{
if (val2 > val1)
+ {
within = true;
- else { without = true; }
+ }
+ else
+ {
+ without = true;
+ }
}
}
}
@@ -258,58 +302,90 @@ namespace evalhyd
if (within)
{
if ((opr1 == "<") && (opr2 == ">"))
+ {
t_msk = xt::where((q < val1) & (q > val2),
1, t_msk);
+ }
else if ((opr1 == "<=") && (opr2 == ">"))
+ {
t_msk = xt::where((q <= val1) & (q > val2),
1, t_msk);
+ }
else if ((opr1 == "<") && (opr2 == ">="))
+ {
t_msk = xt::where((q < val1) & (q >= val2),
1, t_msk);
+ }
else if ((opr1 == "<=") && (opr2 == ">="))
+ {
t_msk = xt::where((q <= val1) & (q >= val2),
1, t_msk);
+ }
if ((opr2 == "<") && (opr1 == ">"))
+ {
t_msk = xt::where((q < val2) & (q > val1),
1, t_msk);
+ }
else if ((opr2 == "<=") && (opr1 == ">"))
+ {
t_msk = xt::where((q <= val2) & (q > val1),
1, t_msk);
+ }
else if ((opr2 == "<") && (opr1 == ">="))
+ {
t_msk = xt::where((q < val2) & (q >= val1),
1, t_msk);
+ }
else if ((opr2 == "<=") && (opr1 == ">="))
+ {
t_msk = xt::where((q <= val2) & (q >= val1),
1, t_msk);
+ }
}
else if (without)
{
if ((opr1 == "<") && (opr2 == ">"))
+ {
t_msk = xt::where((q < val1) | (q > val2),
1, t_msk);
+ }
else if ((opr1 == "<=") && (opr2 == ">"))
+ {
t_msk = xt::where((q <= val1) | (q > val2),
1, t_msk);
+ }
else if ((opr1 == "<") && (opr2 == ">="))
+ {
t_msk = xt::where((q < val1) | (q >= val2),
1, t_msk);
+ }
else if ((opr1 == "<=") && (opr2 == ">="))
+ {
t_msk = xt::where((q <= val1) & (q >= val2),
1, t_msk);
+ }
if ((opr2 == "<") && (opr1 == ">"))
+ {
t_msk = xt::where((q < val2) | (q > val1),
1, t_msk);
+ }
else if ((opr2 == "<=") && (opr1 == ">"))
+ {
t_msk = xt::where((q <= val2) | (q > val1),
1, t_msk);
+ }
else if ((opr2 == "<") && (opr1 == ">="))
+ {
t_msk = xt::where((q < val2) | (q >= val1),
1, t_msk);
+ }
else if ((opr2 == "<=") && (opr1 == ">="))
+ {
t_msk = xt::where((q <= val2) | (q >= val1),
1, t_msk);
+ }
}
else
{
@@ -320,40 +396,54 @@ namespace evalhyd
// apply masking condition to given subset
if (opr == "<")
+ {
t_msk = xt::where(
q < val, 1, t_msk
);
+ }
else if (opr == ">")
+ {
t_msk = xt::where(
q > val, 1, t_msk
);
+ }
else if (opr == "<=")
+ {
t_msk = xt::where(
q <= val, 1, t_msk
);
+ }
else if (opr == ">=")
+ {
t_msk = xt::where(
q >= val, 1, t_msk
);
+ }
else if (opr == "==")
+ {
t_msk = xt::where(
xt::equal(q, val), 1, t_msk
);
+ }
else if (opr == "!=")
+ {
t_msk = xt::where(
xt::not_equal(q, val), 1, t_msk
);
+ }
}
}
}
- // condition on time index
+ // condition on time index
else if (var == "t")
{
for (const auto & sequence : cond)
{
if (sequence.empty())
+ {
// i.e. t{:}
xt::view(t_msk, xt::all()) = 1;
+ }
else
{
// convert string indices to integer indices
diff --git a/include/evalhyd/detail/probabilist/evaluator.hpp b/include/evalhyd/detail/probabilist/evaluator.hpp
index 7574b19..ca209d0 100644
--- a/include/evalhyd/detail/probabilist/evaluator.hpp
+++ b/include/evalhyd/detail/probabilist/evaluator.hpp
@@ -22,31 +22,31 @@ namespace evalhyd
{
private:
using view1d_xtensor2d_double_type = decltype(
- xt::view(
- std::declval<const D2&>(),
- std::declval<std::size_t>(),
- xt::all()
- )
+ xt::view(
+ std::declval<const D2&>(),
+ std::declval<std::size_t>(),
+ xt::all()
+ )
);
using view2d_xtensor4d_double_type = decltype(
- xt::view(
- std::declval<const D4&>(),
- std::declval<std::size_t>(),
- std::declval<std::size_t>(),
- xt::all(),
- xt::all()
- )
+ xt::view(
+ std::declval<const D4&>(),
+ std::declval<std::size_t>(),
+ std::declval<std::size_t>(),
+ xt::all(),
+ xt::all()
+ )
);
using view2d_xtensor4d_bool_type = decltype(
- xt::view(
- std::declval<const B4&>(),
- std::declval<std::size_t>(),
- std::declval<std::size_t>(),
- xt::all(),
- xt::all()
- )
+ xt::view(
+ std::declval<const B4&>(),
+ std::declval<std::size_t>(),
+ std::declval<std::size_t>(),
+ xt::all(),
+ xt::all()
+ )
);
// members for input data
@@ -81,7 +81,9 @@ namespace evalhyd
// initialise a mask if none provided
// (corresponding to no temporal subset)
if (msk.size() < 1)
+ {
t_msk = xt::ones<bool>({std::size_t {1}, q_obs.size()});
+ }
// determine size for recurring dimensions
n = q_obs.size();
@@ -96,9 +98,11 @@ namespace evalhyd
auto sum_nan = xt::eval(xt::sum(prd_nan, -1));
if (xt::amin(sum_nan) != xt::amax(sum_nan))
+ {
throw std::runtime_error(
"predictions across members feature non-equal lengths"
);
+ }
auto msk_nan = xt::where(obs_nan | xt::row(prd_nan, 0))[0];
diff --git a/include/evalhyd/detail/uncertainty.hpp b/include/evalhyd/detail/uncertainty.hpp
index e55d046..9599b44 100644
--- a/include/evalhyd/detail/uncertainty.hpp
+++ b/include/evalhyd/detail/uncertainty.hpp
@@ -39,7 +39,8 @@ namespace evalhyd
std::tm tm = {};
std::istringstream ss(str);
ss >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S");
- if (ss.fail()) {
+ if (ss.fail())
+ {
throw std::runtime_error("datetime string parsing failed");
}
tm.tm_year += 400; // add 400y to avoid dates prior 1970
@@ -59,11 +60,14 @@ namespace evalhyd
// check constant time interval
auto ti = x_timepoints[1] - x_timepoints[0];
for (std::size_t t = 1; t < x_timepoints.size() - 1; t++)
- if (x_timepoints[t + 1] - x_timepoints[t] != ti) {
+ {
+ if (x_timepoints[t + 1] - x_timepoints[t] != ti)
+ {
throw std::runtime_error(
"time interval not constant across datetimes"
);
}
+ }
// identify start and end years for period
int start_yr = v_tm.front().tm_year + 1900;
@@ -73,7 +77,8 @@ namespace evalhyd
std::tm start_hy = v_tm.front();
xt::xtensor<int, 1> year_blocks = xt::zeros<int>({v_tm.size()});
- for (int y = start_yr; y < end_yr; y++) {
+ for (int y = start_yr; y < end_yr; y++)
+ {
// define window for year blocks
start_hy.tm_year = y - 1900;
auto start = std::chrono::system_clock::from_time_t(
@@ -89,7 +94,8 @@ namespace evalhyd
// check that year is complete (without a rigorous leap year check)
int n_days = xt::sum(wdw)();
- if ((n_days != 365) && (n_days != 366)) {
+ if ((n_days != 365) && (n_days != 366))
+ {
throw std::runtime_error(
"year starting in " + std::to_string(y)
+ " is incomplete"
@@ -101,7 +107,8 @@ namespace evalhyd
}
// check that time series ends on the last day of a year block
- if (year_blocks(year_blocks.size() - 1) == 0) {
+ if (year_blocks(year_blocks.size() - 1) == 0)
+ {
throw std::runtime_error(
"final day of final year not equal to first day of "
"first year minus one time step"
@@ -116,7 +123,8 @@ namespace evalhyd
std::vector<xt::xkeep_slice<int>> samples;
// compute metrics for each sample
- for (int s = 0; s < n_samples; s++) {
+ for (int s = 0; s < n_samples; s++)
+ {
// select bootstrapped years
auto exp = xt::view(experiment, s);
@@ -128,7 +136,8 @@ namespace evalhyd
);
xt::xtensor<int, 1> idx = xt::concatenate(xt::xtuple(i0, i1), 0);
- for (std::size_t p = 2; p < exp.size(); p++) {
+ for (std::size_t p = 2; p < exp.size(); p++)
+ {
auto i = xt::flatten_indices(
xt::argwhere(xt::equal(year_blocks, exp(p)))
);
@@ -146,7 +155,8 @@ namespace evalhyd
// TODO: wait for xt::quantile to be available
// or implement it internally for n-dim expressions
// summary 2: series of quantiles across samples
- if (summary == 2) {
+ if (summary == 2)
+ {
// // adjust last axis size (from samples to number of statistics)
// auto s = values.shape();
// s.pop_back();
@@ -161,7 +171,8 @@ namespace evalhyd
// TODO: wait for xt::stddev to be fixed for rtensor
// or implement it internally for n-dim expressions
// summary 1: mean and standard deviation across samples
- else if (summary == 1) {
+ else if (summary == 1)
+ {
// // adjust last axis size (from samples to number of statistics)
// auto s = values.shape();
// s.pop_back();
@@ -175,7 +186,8 @@ namespace evalhyd
return values;
}
// summary 0: raw (keep all samples)
- else {
+ else
+ {
return values;
}
}
diff --git a/include/evalhyd/detail/utils.hpp b/include/evalhyd/detail/utils.hpp
index 369fd4f..1d11b4b 100644
--- a/include/evalhyd/detail/utils.hpp
+++ b/include/evalhyd/detail/utils.hpp
@@ -41,11 +41,13 @@ namespace evalhyd
{
// add elements to pre-computation set
for (const auto& element : elements[metric])
+ {
if (found_elements.find(element) == found_elements.end())
{
found_elements.insert(element);
required_elements.push_back(element);
}
+ }
// add metric dependencies to pre-computation set
if (dependencies.find(metric) != dependencies.end())
@@ -59,11 +61,13 @@ namespace evalhyd
}
// add dependency elements to pre-computation set
for (const auto& element : elements[dependency])
+ {
if (found_elements.find(element) == found_elements.end())
{
found_elements.insert(element);
required_elements.push_back(element);
}
+ }
}
}
}
@@ -104,30 +108,42 @@ namespace evalhyd
{
// check n_samples
if (bootstrap.find("n_samples") == bootstrap.end())
+ {
throw std::runtime_error(
"number of samples missing for bootstrap"
);
+ }
// check len_sample
if (bootstrap.find("len_sample") == bootstrap.end())
+ {
throw std::runtime_error(
"length of sample missing for bootstrap"
);
+ }
// check summary
if (bootstrap.find("summary") == bootstrap.end())
+ {
throw std::runtime_error(
"summary missing for bootstrap"
);
+ }
auto s = bootstrap.find("summary")->second;
// TODO: change upper bound when mean+stddev and quantiles implemented
if ((s < 0) || (s > 0))
+ {
throw std::runtime_error(
"invalid value for bootstrap summary"
);
+ }
// set seed
if (bootstrap.find("seed") == bootstrap.end())
+ {
xt::random::seed(time(nullptr));
+ }
else
+ {
xt::random::seed(bootstrap.find("seed")->second);
+ }
}
namespace evalp
@@ -151,11 +167,15 @@ namespace evalhyd
{
if (std::find(threshold_metrics.begin(), threshold_metrics.end(),
metric) != threshold_metrics.end())
+ {
if (thresholds.size() < 1)
+ {
throw std::runtime_error(
"missing thresholds *q_thr* required to "
"compute " + metric
);
+ }
+ }
}
}
}
diff --git a/include/evalhyd/evald.hpp b/include/evalhyd/evald.hpp
index 625ae23..4cd63a2 100644
--- a/include/evalhyd/evald.hpp
+++ b/include/evalhyd/evald.hpp
@@ -180,27 +180,40 @@ namespace evalhyd
// check that data dimensions are compatible
// > time
if (q_obs_.shape(1) != q_prd_.shape(1))
+ {
throw std::runtime_error(
"observations and predictions feature different "
"temporal lengths"
);
+ }
if (t_msk_.size() > 0)
+ {
if (q_obs_.shape(1) != t_msk_.shape(1))
+ {
throw std::runtime_error(
"observations and masks feature different "
"temporal lengths"
);
+ }
+ }
if (!dts.empty())
+ {
if (q_obs_.shape(1) != dts.size())
+ {
throw std::runtime_error(
"observations and datetimes feature different "
"temporal lengths"
);
+ }
+ }
+
// > series
if (q_obs_.shape(0) != 1)
+ {
throw std::runtime_error(
"observations contain more than one time series"
);
+ }
// retrieve dimensions
std::size_t n_tim = q_obs_.shape(1);
@@ -209,26 +222,33 @@ namespace evalhyd
// initialise a mask if none provided
// (corresponding to no temporal subset)
- auto gen_msk = [&]() {
+ auto gen_msk = [&]()
+ {
// if t_msk provided, it takes priority
if (t_msk_.size() > 0)
+ {
return t_msk_;
+ }
// else if m_cdt provided, use them to generate t_msk
else if (m_cdt.size() > 0)
{
B2 c_msk = xt::zeros<bool>({n_msk, n_tim});
for (std::size_t m = 0; m < n_msk; m++)
+ {
xt::view(c_msk, m) =
masks::generate_mask_from_conditions(
m_cdt[0], xt::view(q_obs_, 0), q_prd_
);
+ }
return c_msk;
}
// if neither t_msk nor m_cdt provided, generate dummy mask
else
+ {
return B2({xt::ones<bool>({std::size_t{1}, n_tim})});
+ }
};
auto msk = gen_msk();
@@ -247,16 +267,20 @@ namespace evalhyd
else if ( transform == "inv" )
{
if ( epsilon == -9 )
+ {
// determine an epsilon value to avoid zero divide
epsilon = xt::mean(q_obs_)() * 0.01;
+ }
return D2(1. / (q + epsilon));
}
else if ( transform == "log" )
{
if ( epsilon == -9 )
+ {
// determine an epsilon value to avoid log zero
epsilon = xt::mean(q_obs_)() * 0.01;
+ }
return D2(xt::log(q + epsilon));
}
@@ -265,8 +289,10 @@ namespace evalhyd
if ( exponent < 0 )
{
if ( epsilon == -9 )
+ {
// determine an epsilon value to avoid zero divide
epsilon = xt::mean(q_obs_)() * 0.01;
+ }
return D2(xt::pow(q + epsilon, exponent));
}
@@ -293,9 +319,11 @@ namespace evalhyd
if ((n_samples != -9) && (len_sample != -9))
{
if (dts.empty())
+ {
throw std::runtime_error(
"bootstrap requested but datetimes not provided"
);
+ }
exp = uncertainty::bootstrap(
dts, n_samples, len_sample
@@ -337,21 +365,37 @@ namespace evalhyd
for ( const auto& element : req_elt )
{
if ( element == "mean_obs" )
+ {
evaluator.calc_mean_obs();
+ }
else if ( element == "mean_prd" )
+ {
evaluator.calc_mean_prd();
+ }
else if ( element == "quad_err" )
+ {
evaluator.calc_quad_err();
+ }
else if ( element == "quad_obs" )
+ {
evaluator.calc_quad_obs();
+ }
else if ( element == "quad_prd" )
+ {
evaluator.calc_quad_prd();
+ }
else if ( element == "r_pearson" )
+ {
evaluator.calc_r_pearson();
+ }
else if ( element == "alpha" )
+ {
evaluator.calc_alpha();
+ }
else if ( element == "bias" )
+ {
evaluator.calc_bias();
+ }
}
// pre-compute required dep
@@ -371,28 +415,36 @@ namespace evalhyd
{
if (std::find(req_dep.begin(), req_dep.end(), metric)
== req_dep.end())
+ {
evaluator.calc_RMSE();
+ }
r.emplace_back(uncertainty::summarise(evaluator.RMSE, summary));
}
else if ( metric == "NSE" )
{
if (std::find(req_dep.begin(), req_dep.end(), metric)
== req_dep.end())
+ {
evaluator.calc_NSE();
+ }
r.emplace_back(uncertainty::summarise(evaluator.NSE, summary));
}
else if ( metric == "KGE" )
{
if (std::find(req_dep.begin(), req_dep.end(), metric)
== req_dep.end())
+ {
evaluator.calc_KGE();
+ }
r.emplace_back(uncertainty::summarise(evaluator.KGE, summary));
}
else if ( metric == "KGEPRIME" )
{
if (std::find(req_dep.begin(), req_dep.end(), metric)
== req_dep.end())
+ {
evaluator.calc_KGEPRIME();
+ }
r.emplace_back(uncertainty::summarise(evaluator.KGEPRIME, summary));
}
}
diff --git a/include/evalhyd/evalp.hpp b/include/evalhyd/evalp.hpp
index 7a044c3..c41277a 100644
--- a/include/evalhyd/evalp.hpp
+++ b/include/evalhyd/evalp.hpp
@@ -159,47 +159,75 @@ namespace evalhyd
// check that data dimensions are compatible
// > time
if (q_obs_.shape(1) != q_prd_.shape(3))
+ {
throw std::runtime_error(
"observations and predictions feature different "
"temporal lengths"
);
+ }
if (t_msk_.size() > 0)
+ {
if (q_obs_.shape(1) != t_msk_.shape(3))
+ {
throw std::runtime_error(
"observations and masks feature different "
"temporal lengths"
);
+ }
+ }
if (!dts.empty())
+ {
if (q_obs_.shape(1) != dts.size())
+ {
throw std::runtime_error(
"observations and datetimes feature different "
"temporal lengths"
);
+ }
+ }
+
// > leadtimes
if (t_msk_.size() > 0)
+ {
if (q_prd_.shape(1) != t_msk_.shape(1))
+ {
throw std::runtime_error(
"predictions and temporal masks feature different "
"numbers of lead times"
);
+ }
+ }
+
// > sites
if (q_obs_.shape(0) != q_prd_.shape(0))
+ {
throw std::runtime_error(
"observations and predictions feature different "
"numbers of sites"
);
+ }
if (t_msk_.size() > 0)
+ {
if (q_obs_.shape(0) != t_msk_.shape(0))
+ {
throw std::runtime_error(
"observations and temporal masks feature different "
"numbers of sites"
);
+ }
+ }
+
if (m_cdt.size() > 0)
+ {
if (q_obs_.shape(0) != m_cdt.shape(0))
+ {
throw std::runtime_error(
"observations and masking conditions feature different "
"numbers of sites"
);
+ }
+ }
+
// retrieve dimensions
std::size_t n_sit = q_prd_.shape(0);
@@ -246,18 +274,28 @@ namespace evalhyd
utils::find_requirements(metrics, elt, dep, req_elt, req_dep);
// generate masks from conditions if provided
- auto gen_msk = [&]() {
+ auto gen_msk = [&]()
+ {
B4 c_msk = xt::zeros<bool>({n_sit, n_ltm, n_msk, n_tim});
if (m_cdt.size() > 0)
+ {
for (std::size_t s = 0; s < n_sit; s++)
+ {
for (std::size_t l = 0; l < n_ltm; l++)
+ {
for (std::size_t m = 0; m < n_msk; m++)
+ {
xt::view(c_msk, s, l, m) =
masks::generate_mask_from_conditions(
xt::view(m_cdt, s, m),
xt::view(q_obs_, s),
xt::view(q_prd_, s, l)
);
+ }
+ }
+ }
+ }
+
return c_msk;
};
const B4 c_msk = gen_msk();
@@ -269,9 +307,11 @@ namespace evalhyd
if ((n_samples != -9) && (len_sample != -9))
{
if (dts.empty())
+ {
throw std::runtime_error(
"bootstrap requested but datetimes not provided"
);
+ }
b_exp = uncertainty::bootstrap(dts, n_samples, len_sample);
}
@@ -286,12 +326,15 @@ namespace evalhyd
// initialise data structure for outputs
std::vector<xt::xarray<double>> r;
for (const auto& metric : metrics)
+ {
r.emplace_back(xt::zeros<double>(dim[metric]));
+ }
auto summary = bootstrap.find("summary")->second;
// compute variables one site at a time to minimise memory imprint
for (std::size_t s = 0; s < n_sit; s++)
+ {
// compute variables one lead time at a time to minimise memory imprint
for (std::size_t l = 0; l < n_ltm; l++)
{
@@ -314,24 +357,38 @@ namespace evalhyd
for (const auto& element : req_elt)
{
if ( element == "o_k" )
+ {
evaluator.calc_o_k();
+ }
else if ( element == "bar_o" )
+ {
evaluator.calc_bar_o();
+ }
else if ( element == "y_k" )
+ {
evaluator.calc_y_k();
+ }
else if ( element == "q_qnt" )
+ {
evaluator.calc_q_qnt();
+ }
}
// pre-compute required dep
for (const auto& dependency : req_dep)
{
if ( dependency == "bs" )
+ {
evaluator.calc_bs();
+ }
else if ( dependency == "qs" )
+ {
evaluator.calc_qs();
+ }
else if ( dependency == "crps" )
+ {
evaluator.calc_crps();
+ }
}
// retrieve or compute requested metrics
@@ -343,7 +400,9 @@ namespace evalhyd
{
if (std::find(req_dep.begin(), req_dep.end(), metric)
== req_dep.end())
+ {
evaluator.calc_BS();
+ }
// (sites, lead times, subsets, samples, thresholds)
xt::view(r[m], s, l, xt::all(), xt::all(), xt::all()) =
uncertainty::summarise(evaluator.BS, summary);
@@ -352,7 +411,9 @@ namespace evalhyd
{
if (std::find(req_dep.begin(), req_dep.end(), metric)
== req_dep.end())
+ {
evaluator.calc_BSS();
+ }
// (sites, lead times, subsets, samples, thresholds)
xt::view(r[m], s, l, xt::all(), xt::all(), xt::all()) =
uncertainty::summarise(evaluator.BSS, summary);
@@ -361,7 +422,9 @@ namespace evalhyd
{
if (std::find(req_dep.begin(), req_dep.end(), metric)
== req_dep.end())
+ {
evaluator.calc_BS_CRD();
+ }
// (sites, lead times, subsets, samples, thresholds, components)
xt::view(r[m], s, l, xt::all(), xt::all(), xt::all(), xt::all()) =
uncertainty::summarise(evaluator.BS_CRD, summary);
@@ -370,7 +433,10 @@ namespace evalhyd
{
if (std::find(req_dep.begin(), req_dep.end(), metric)
== req_dep.end())
+ {
evaluator.calc_BS_LBD();
+ }
+
// (sites, lead times, subsets, samples, thresholds, components)
xt::view(r[m], s, l, xt::all(), xt::all(), xt::all(), xt::all()) =
uncertainty::summarise(evaluator.BS_LBD, summary);
@@ -379,7 +445,9 @@ namespace evalhyd
{
if (std::find(req_dep.begin(), req_dep.end(), metric)
== req_dep.end())
+ {
evaluator.calc_QS();
+ }
// (sites, lead times, subsets, samples, quantiles)
xt::view(r[m], s, l, xt::all(), xt::all(), xt::all()) =
uncertainty::summarise(evaluator.QS, summary);
@@ -388,14 +456,16 @@ namespace evalhyd
{
if (std::find(req_dep.begin(), req_dep.end(), metric)
== req_dep.end())
+ {
evaluator.calc_CRPS();
+ }
// (sites, lead times, subsets, samples)
xt::view(r[m], s, l, xt::all(), xt::all()) =
uncertainty::summarise(evaluator.CRPS, summary);
}
}
}
-
+ }
return r;
};
}
diff --git a/tests/test_determinist.cpp b/tests/test_determinist.cpp
index 5239076..d5f725e 100644
--- a/tests/test_determinist.cpp
+++ b/tests/test_determinist.cpp
@@ -301,8 +301,10 @@ TEST(DeterministTests, TestMissingData)
std::vector<xt::xarray<double>> metrics_nan =
evalhyd::evald<xt::xtensor<double, 2>, xt::xtensor<bool, 2>>(observed, predicted, metrics);
- for (std::size_t m = 0; m < metrics.size(); m++) {
- for (std::size_t p = 0; p < predicted.shape(0); p++) {
+ for (std::size_t m = 0; m < metrics.size(); m++)
+ {
+ for (std::size_t p = 0; p < predicted.shape(0); p++)
+ {
// compute metrics on subset of observations and predictions (i.e.
// eliminating region with NaN in observations or predictions manually)
xt::xtensor<double, 1> obs =
diff --git a/tests/test_probabilist.cpp b/tests/test_probabilist.cpp
index c258b0c..342cbf0 100644
--- a/tests/test_probabilist.cpp
+++ b/tests/test_probabilist.cpp
@@ -377,7 +377,8 @@ TEST(ProbabilistTests, TestMissingData)
);
// check that numerical results are identical
- for (std::size_t m = 0; m < metrics.size(); m++) {
+ for (std::size_t m = 0; m < metrics.size(); m++)
+ {
// for leadtime 1
EXPECT_TRUE(
xt::allclose(
--
GitLab