def test_tcol_snr():
"""
Test the triple collocation based estimation of
signal to noise ratio, absolute errors and rescaling coefficients
"""
n = 1000000
mean_signal = 0.3
sig_signal = 0.2
signal = np.random.normal(mean_signal, sig_signal, n)
sig_err_x = 0.02
sig_err_y = 0.07
sig_err_z = 0.04
err_x = np.random.normal(0, sig_err_x, n)
err_y = np.random.normal(0, sig_err_y, n)
err_z = np.random.normal(0, sig_err_z, n)
alpha_y = 0.2
alpha_z = 0.5
beta_y = 0.9
beta_z = 1.6
x = signal + err_x
y = alpha_y + beta_y * (signal + err_y)
z = alpha_z + beta_z * (signal + err_z)
beta_pred = 1. / np.array((1, beta_y, beta_z))
err_pred = np.array((sig_err_x, sig_err_y, sig_err_z))
snr_pred = np.array(((sig_signal / sig_err_x), (sig_signal / sig_err_y),
(sig_signal / sig_err_z)))
snr, err, beta = met.tcol_snr(x, y, z, ref_ind=0)
nptest.assert_almost_equal(beta, beta_pred, decimal=2)
nptest.assert_almost_equal(err, err_pred, decimal=2)
nptest.assert_almost_equal(np.sqrt(10**(snr / 10.)), snr_pred, decimal=1)
def test_tcol_snr():
"""
Test the triple collocation based estimation of
signal to noise ratio, absolute errors and rescaling coefficients
"""
n = 1000000
mean_signal = 0.3
sig_signal = 0.2
signal = np.random.normal(mean_signal, sig_signal, n)
sig_err_x = 0.02
sig_err_y = 0.07
sig_err_z = 0.04
err_x = np.random.normal(0, sig_err_x, n)
err_y = np.random.normal(0, sig_err_y, n)
err_z = np.random.normal(0, sig_err_z, n)
alpha_y = 0.2
alpha_z = 0.5
beta_y = 0.9
beta_z = 1.6
x = signal + err_x
y = alpha_y + beta_y * (signal + err_y)
z = alpha_z + beta_z * (signal + err_z)
beta_pred = 1. / np.array((1, beta_y, beta_z))
err_pred = np.array((sig_err_x, sig_err_y, sig_err_z))
snr_pred = np.array(
((sig_signal / sig_err_x), (sig_signal / sig_err_y), (sig_signal / sig_err_z)))
snr, err, beta = met.tcol_snr(x, y, z, ref_ind=0)
nptest.assert_almost_equal(beta, beta_pred, decimal=2)
nptest.assert_almost_equal(err, err_pred, decimal=2)
nptest.assert_almost_equal(np.sqrt(10 ** (snr / 10.)), snr_pred, decimal=1)
def test_tcol_error():
"""
Test the triple collocation error estimation based on
a random signal and error.
Also compare the results to the other method
"""
n = 1000000
signal = np.sin(np.linspace(0, 2 * np.pi, n))
sig_err_x = 0.02
sig_err_y = 0.07
sig_err_z = 0.04
err_pred = np.array((sig_err_x, sig_err_y, sig_err_z))
err_x = np.random.normal(0, sig_err_x, n)
err_y = np.random.normal(0, sig_err_y, n)
err_z = np.random.normal(0, sig_err_z, n)
alpha_y = 0.2
alpha_z = 0.5
beta_y = 0.9
beta_z = 1.6
x = signal + err_x
y = alpha_y + beta_y * (signal + err_y)
z = alpha_z + beta_z * (signal + err_z)
snr, err, beta = met.tcol_snr(x, y, z, ref_ind=0)
# classical triple collocation errors use scaled (removed alpha and beta)
# input arrays
ex, ey, ez = met.tcol_error(signal + err_x, signal + err_y, signal + err_z)
nptest.assert_almost_equal(err, np.array([ex, ey, ez]), decimal=2)
nptest.assert_almost_equal(err_pred, np.array([ex, ey, ez]), decimal=2)
def test_tcol_error():
"""
Test the triple collocation error estimation based on
a random signal and error.
Also compare the results to the other method
"""
n = 1000000
signal = np.sin(np.linspace(0, 2 * np.pi, n))
sig_err_x = 0.02
sig_err_y = 0.07
sig_err_z = 0.04
err_pred = np.array((sig_err_x, sig_err_y, sig_err_z))
err_x = np.random.normal(0, sig_err_x, n)
err_y = np.random.normal(0, sig_err_y, n)
err_z = np.random.normal(0, sig_err_z, n)
alpha_y = 0.2
alpha_z = 0.5
beta_y = 0.9
beta_z = 1.6
x = signal + err_x
y = alpha_y + beta_y * (signal + err_y)
z = alpha_z + beta_z * (signal + err_z)
snr, err, beta = met.tcol_snr(x, y, z, ref_ind=0)
# classical triple collocation errors use scaled (removed alpha and beta)
# input arrays
ex, ey, ez = met.tcol_error(signal + err_x, signal + err_y, signal + err_z)
nptest.assert_almost_equal(err, np.array([ex, ey, ez]), decimal=2)
nptest.assert_almost_equal(err_pred, np.array([ex, ey, ez]), decimal=2)
def calc_metrics(self, data, gpi_info):
"""
calculates the desired statistics
Parameters
----------
data : pandas.DataFrame
with 3 columns, the first column is the reference dataset
named 'ref'
the second and third column are the datasets to compare against
named 'k1 and k2'
gpi_info : tuple
Grid point info (i.e. gpi, lon, lat)
"""
dataset = super(HSAF_Metrics, self).calc_metrics(data, gpi_info)
for season in self.seasons:
if season != 'ALL':
subset = self.month_to_season[data.index.month] == season
else:
subset = np.ones(len(data), dtype=bool)
# number of observations
n_obs = subset.sum()
if n_obs < self.min_obs:
continue
dataset['{:}_n_obs'.format(season)][0] = n_obs
# get single dataset metrics
# calculate SNR
x = data[self.df_columns[0]].values[subset]
y = data[self.df_columns[1]].values[subset]
z = data[self.df_columns[2]].values[subset]
snr, err, beta = metrics.tcol_snr(x, y, z)
for i, name in enumerate(self.ds_names):
dataset['{:}_{:}_snr'.format(name, season)][0] = snr[i]
dataset['{:}_{:}_err_var'.format(name, season)][0] = err[i]
dataset['{:}_{:}_beta'.format(name, season)][0] = beta[i]
# calculate Pearson correlation
pearson_R, pearson_p = df_metrics.pearsonr(data)
pearson_R = pearson_R._asdict()
pearson_p = pearson_p._asdict()
# calculate Spearman correlation
spea_rho, spea_p = df_metrics.spearmanr(data)
spea_rho = spea_rho._asdict()
spea_p = spea_p._asdict()
# scale data to reference in order to calculate absolute metrics
data_scaled = scale(data, method='min_max')
# calculate bias
bias_nT = df_metrics.bias(data_scaled)
bias_dict = bias_nT._asdict()
# calculate ubRMSD
ubRMSD_nT = df_metrics.ubrmsd(data_scaled)
ubRMSD_dict = ubRMSD_nT._asdict()
for tds_name in self.tds_names:
R = pearson_R[tds_name]
p_R = pearson_p[tds_name]
rho = spea_rho[tds_name]
p_rho = spea_p[tds_name]
bias = bias_dict[tds_name]
ubRMSD = ubRMSD_dict[tds_name]
split_tds_name = tds_name.split('_and_')
tds_name_key = "{:}_{:}".format(
self.ds_names_lut[split_tds_name[0]],
self.ds_names_lut[split_tds_name[1]])
dataset['{:}_{:}_R'.format(tds_name_key, season)][0] = R
dataset['{:}_{:}_p_R'.format(tds_name_key, season)][0] = p_R
dataset['{:}_{:}_rho'.format(tds_name_key, season)][0] = rho
dataset['{:}_{:}_p_rho'.format(tds_name_key, season)][0] = \
p_rho
dataset['{:}_{:}_bias'.format(tds_name_key, season)][0] = bias
dataset['{:}_{:}_ubrmsd'.format(tds_name_key, season)][0] = \
ubRMSD
return dataset
def calc_metrics(self, data, gpi_info):
"""
calculates the desired statistics
Parameters
----------
data : pandas.DataFrame
with >2 columns, the first column is the reference dataset
named 'ref'
other columns are the data sets to compare against named 'other_i'
gpi_info : tuple
of (gpi, lon, lat)
Notes
-----
Kendall tau is calculation is optional at the moment
because the scipy implementation is very slow which is problematic for
global comparisons
"""
dataset = copy.deepcopy(self.result_template)
dataset['gpi'][0] = gpi_info[0]
dataset['lon'][0] = gpi_info[1]
dataset['lat'][0] = gpi_info[2]
# number of observations
subset = np.ones(len(data), dtype=bool)
n_obs = subset.sum()
if n_obs < 10:
return dataset
dataset['n_obs'][0] = n_obs
# calculate Pearson correlation
pearson_R, pearson_p = df_metrics.pearsonr(data)
pearson_R = pearson_R._asdict()
pearson_p = pearson_p._asdict()
# calculate Spearman correlation
spea_rho, spea_p = df_metrics.spearmanr(data)
spea_rho = spea_rho._asdict()
spea_p = spea_p._asdict()
# calculate bias
bias_nT = df_metrics.bias(data)
bias_dict = bias_nT._asdict()
# calculate RMSD
rmsd = df_metrics.rmsd(data)
rmsd_dict = rmsd._asdict()
# calculate MSE
mse, mse_corr, mse_bias, mse_var = df_metrics.mse(data)
mse_dict = mse._asdict()
mse_corr_dict = mse_corr._asdict()
mse_bias_dict = mse_bias._asdict()
mse_var_dict = mse_var._asdict()
# calulcate tau
if self.calc_tau:
tau, p_tau = df_metrics.kendalltau(data)
tau_dict = tau._asdict()
p_tau_dict = p_tau._asdict()
else:
tau = p_tau = p_tau_dict = tau_dict = None
#data_scaled = scale(data, method='mean_std')
# calculate ubRMSD
ubRMSD_nT = df_metrics.ubrmsd(data)
ubRMSD_dict = ubRMSD_nT._asdict()
# get single dataset metrics
# calculate SNR
x = data[self.df_columns[0]].values[subset]
y = data[self.df_columns[1]].values[subset]
z = data[self.df_columns[2]].values[subset]
snr, err, beta = metrics.tcol_snr(x, y, z)
for i, name in enumerate(self.ds_names):
dataset['{:}_snr'.format(name)][0] = snr[i]
dataset['{:}_err_var'.format(name)][0] = err[i]
dataset['{:}_beta'.format(name)][0] = beta[i]
for tds_name in self.tds_names:
R = pearson_R[tds_name]
p_R = pearson_p[tds_name]
rho = spea_rho[tds_name]
p_rho = spea_p[tds_name]
bias = bias_dict[tds_name]
mse = mse_dict[tds_name]
mse_corr = mse_corr_dict[tds_name]
mse_bias = mse_bias_dict[tds_name]
mse_var = mse_var_dict[tds_name]
rmsd = rmsd_dict[tds_name]
ubRMSD = ubRMSD_dict[tds_name]
if tau_dict and p_tau_dict:
tau = tau_dict[tds_name]
p_tau = p_tau_dict[tds_name]
split_tds_name = tds_name.split('_and_')
tds_name_key = "{:}_{:}".format(
self.ds_names_lut[split_tds_name[0]],
self.ds_names_lut[split_tds_name[1]])
dataset['R_between_{:}'.format(tds_name_key)][0] = R
dataset['p_R_between_{:}'.format(tds_name_key)][0] = p_R
dataset['rho_between_{:}'.format(tds_name_key)][0] = rho
dataset['p_rho_between_{:}'.format(tds_name_key)][0] = p_rho
dataset['bias_between_{:}'.format(tds_name_key)][0] = bias
dataset['mse_between_{:}'.format(tds_name_key)][0] = mse
dataset['mse_corr_between_{:}'.format(tds_name_key)][0] = mse_corr
dataset['mse_bias_between_{:}'.format(tds_name_key)][0] = mse_bias
dataset['mse_var_between_{:}'.format(tds_name_key)][0] = mse_var
dataset['rmsd_between_{:}'.format(tds_name_key)][0] = rmsd
dataset['ubRMSD_between_{:}'.format(tds_name_key)][0] = ubRMSD
if self.calc_tau:
dataset['tau_between_{:}'.format(tds_name_key)][0] = tau
dataset['p_tau_between_{:}'.format(tds_name_key)][0] = p_tau
return dataset
def run(cell=None, gpi=None):
if (cell is None) and (gpi is None):
print('No cell/gpi specified.')
return
smos = SMOS_io()
ascat = HSAF_io(ext=None)
mswep = MSWEP_io()
if gpi is not None:
cell = mswep.gpi2cell(gpi)
# Median Q/R from TC run.
Q_avg = 12.
R_avg = 74.
if platform.system() == 'Windows':
result_file = os.path.join('D:', 'work', 'MadKF', 'CONUS',
'result_%04i.csv' % cell)
else:
result_file = os.path.join('/', 'scratch', 'leuven', '320', 'vsc32046',
'output', 'MadKF', 'CONUS',
'result_%04i.csv' % cell)
dt = ['2010-01-01', '2015-12-31']
for data, info in mswep.iter_cell(cell, gpis=gpi):
# print info.name
# if True:
try:
precip = mswep.read(info.name)
sm_ascat = ascat.read(info.dgg_gpi)
sm_smos = smos.read(info.smos_gpi) * 100.
if (precip is None) | (sm_ascat is None) | (sm_smos is None):
continue
precip = calc_anomaly(precip[dt[0]:dt[1]],
method='moving_average',
longterm=False)
sm_ascat = calc_anomaly(sm_ascat[dt[0]:dt[1]],
method='moving_average',
longterm=False)
sm_smos = calc_anomaly(sm_smos[dt[0]:dt[1]],
method='moving_average',
longterm=False)
api = API(gamma=info.gamma)
# Regularize time steps
df = pd.DataFrame({
1: precip,
2: sm_ascat,
3: sm_smos
},
index=pd.date_range(dt[0], dt[1]))
n_inv_precip = len(np.where(np.isnan(df[1]))[0])
n_inv_ascat = len(np.where(np.isnan(df[2]))[0])
n_inv_smos = len(np.where(np.isnan(df[3]))[0])
n_inv_asc_smo = len(np.where(np.isnan(df[2]) & np.isnan(df[3]))[0])
df.loc[np.isnan(df[1]), 1] = 0.
# --- get OL ts ---
OL = np.full(len(precip), np.nan)
model = API(gamma=info.gamma)
for t, f in enumerate(df[1].values):
x = model.step(f)
OL[t] = x
# collocate OL and satellite data sets.
df2 = pd.DataFrame({
1: OL,
2: sm_ascat,
3: sm_smos
},
index=pd.date_range(dt[0], dt[1])).dropna()
# ----- Calculate uncertainties -----
# convert (static) forcing to model uncertainty
P_avg = Q_avg / (1 - info.gamma**2)
# calculate TCA based uncertainty and scaling coefficients
snr, err, beta = tcol_snr(df2[1].values, df2[2].values,
df2[3].values)
P_TC = err[0]**2
Q_TC = P_TC * (1 - info.gamma**2)
R_TC = (err[1] / beta[1])**2
H_TC = beta[1]
# Calculate RMSD based uncertainty
R_rmsd = (np.nanmean(
(df2[1].values - H_TC * df2[2].values)**2) - P_avg)
if R_rmsd < 0:
R_rmsd *= -1
# -----------------------------------
# ----- Run KF using TCA-based uncertainties -----
api_kf = API(gamma=info.gamma, Q=Q_TC)
R_2D = np.array([(err[1] / beta[1])**2, (err[2] / beta[2])**2])
H_2D = np.array([beta[1]**(-1), beta[2]**(-1)])
x_2d, P, checkvar1_2d, checkvar2_2d, checkvar3_2d, K1_2d, K2_2d = \
KF_2D(api_kf, df[1].values.copy(), df[2].values.copy(), df[3].values.copy(), R_2D, H=H_2D)
# ----- Run KF using TCA-based uncertainties -----
api_kf = API(gamma=info.gamma, Q=Q_TC)
x_kf, P, R_innov_kf, checkvar_kf, K_kf = \
KF(api_kf, df[1].values.copy(), df[2].values.copy(), R_TC, H=H_TC)
# ----- Run EnKF using TCA-based uncertainties -----
forc_pert = ['normal', 'additive', Q_TC]
obs_pert = ['normal', 'additive', R_TC]
x_tc, P, R_innov_tc, checkvar_tc, K_tc = \
EnKF(api, df[1].values.copy(), df[2].values.copy(), forc_pert, obs_pert, H=H_TC, n_ens=50)
# ----- Run EnKF using static uncertainties -----
forc_pert = ['normal', 'additive', Q_avg]
obs_pert = ['normal', 'additive', R_avg]
x_avg, P, R_innov_avg, checkvar_avg, K_avg = \
EnKF(api, df[1].values.copy(), df[2].values.copy(), forc_pert, obs_pert, H=H_TC, n_ens=50)
# ----- Run EnKF using RMSD-based uncertainties (corrected for model uncertainty) -----
t = timeit.default_timer()
forc_pert = ['normal', 'additive', Q_avg]
obs_pert = ['normal', 'additive', R_rmsd]
x_rmsd, P, R_innov_rmsd, checkvar_rmsd, K_rmsd = \
EnKF(api, df[1].values.copy(), df[2].values.copy(), forc_pert, obs_pert, H=H_TC, n_ens=50)
t_enkf = timeit.default_timer() - t
# ----- Run MadKF -----
t = timeit.default_timer()
x_madkf, P, R_madkf, Q_madkf, H_madkf, R_innov_madkf, checkvar_madkf, K_madkf = \
MadKF(api, df[1].values.copy(), df[2].values.copy(), n_ens=100, n_iter=20)
t_madkf = timeit.default_timer() - t
# TC evaluation of assimilation results
# df3 = pd.DataFrame({1: x_tc, 2: x_avg, 3: x_rmsd, 4: x_madkf, 5: sm_ascat, 6: sm_smos}, index=pd.date_range(dt[0], dt[1])).dropna()
#
# rmse_ana_tc = tcol_snr(df3[1].values, df3[5].values, df3[6].values)[1][0]
# rmse_ana_avg = tcol_snr(df3[2].values, df3[5].values, df3[6].values)[1][0]
# rmse_ana_rmsd = tcol_snr(df3[3].values, df3[5].values, df3[6].values)[1][0]
# rmse_ana_madkf = tcol_snr(df3[4].values, df3[5].values, df3[6].values)[1][0]
result = pd.DataFrame(
{
'lon': info.lon,
'lat': info.lat,
'col': info.col,
'row': info.row,
'P_tc': P_TC,
'Q_tc': Q_TC,
'R_tc': R_TC,
'H_tc': H_TC,
'K_tc': K_tc,
'R_innov_tc': R_innov_tc,
'checkvar_tc': checkvar_tc,
'K_kf': K_kf,
'R_innov_kf': R_innov_kf,
'checkvar_kf': checkvar_kf,
'K1_2d': K1_2d,
'K2_2d': K2_2d,
'checkvar1_2d': checkvar1_2d,
'checkvar2_2d': checkvar2_2d,
'checkvar3_2d': checkvar3_2d,
'P_avg': P_avg,
'Q_avg': Q_avg,
'R_avg': R_avg,
'K_avg': K_avg,
'R_innov_avg': R_innov_avg,
'checkvar_avg': checkvar_avg,
'R_rmsd': R_rmsd,
'K_rmsd': K_rmsd,
'R_innov_rmsd': R_innov_rmsd,
'checkvar_rmsd': checkvar_rmsd,
'P_madkf': Q_madkf / (1 - info.gamma**2),
'Q_madkf': Q_madkf,
'R_madkf': R_madkf,
'H_madkf': H_madkf,
'K_madkf': K_madkf,
'R_innov_madkf': R_innov_madkf,
'checkvar_madkf': checkvar_madkf,
't_enkf': t_enkf,
't_madkf': t_madkf,
'n_inv_precip': n_inv_precip,
'n_inv_ascat': n_inv_ascat,
'n_inv_smos': n_inv_smos,
'n_inv_asc_smo': n_inv_asc_smo
},
index=(info.name, ))
if (os.path.isfile(result_file) == False):
result.to_csv(result_file, float_format='%0.4f')
else:
result.to_csv(result_file,
float_format='%0.4f',
mode='a',
header=False)
except:
print('GPI failed.')
continue
ascat.close()
mswep.close()
def calc_metrics(self, data, gpi_info):
"""
calculates the desired statistics
Parameters
----------
data : pandas.DataFrame
with >2 columns, the first column is the reference dataset
named 'ref'
other columns are the data sets to compare against named 'other_i'
gpi_info : tuple
of (gpi, lon, lat)
Notes
-----
Kendall tau is calculation is optional at the moment
because the scipy implementation is very slow which is problematic for
global comparisons
"""
dataset = copy.deepcopy(self.result_template)
dataset['gpi'][0] = gpi_info[0]
dataset['lon'][0] = gpi_info[1]
dataset['lat'][0] = gpi_info[2]
# number of observations
subset = np.ones(len(data), dtype=bool)
n_obs = subset.sum()
if n_obs < 10:
return dataset
dataset['n_obs'][0] = n_obs
# calculate Pearson correlation
pearson_R, pearson_p = df_metrics.pearsonr(data)
pearson_R = pearson_R._asdict()
pearson_p = pearson_p._asdict()
# calculate Spearman correlation
spea_rho, spea_p = df_metrics.spearmanr(data)
spea_rho = spea_rho._asdict()
spea_p = spea_p._asdict()
# calculate bias
bias_nT = df_metrics.bias(data)
bias_dict = bias_nT._asdict()
# calculate RMSD
rmsd = df_metrics.rmsd(data)
rmsd_dict = rmsd._asdict()
# calculate MSE
mse, mse_corr, mse_bias, mse_var = df_metrics.mse(data)
mse_dict = mse._asdict()
mse_corr_dict = mse_corr._asdict()
mse_bias_dict = mse_bias._asdict()
mse_var_dict = mse_var._asdict()
# calulcate tau
if self.calc_tau:
tau, p_tau = df_metrics.kendalltau(data)
tau_dict = tau._asdict()
p_tau_dict = p_tau._asdict()
else:
tau = p_tau = p_tau_dict = tau_dict = None
#data_scaled = scale(data, method='mean_std')
# calculate ubRMSD
ubRMSD_nT = df_metrics.ubrmsd(data)
ubRMSD_dict = ubRMSD_nT._asdict()
# get single dataset metrics
# calculate SNR
x = data[self.df_columns[0]].values[subset]
y = data[self.df_columns[1]].values[subset]
z = data[self.df_columns[2]].values[subset]
snr, err, beta = metrics.tcol_snr(x, y, z)
for i, name in enumerate(self.ds_names):
dataset['{:}_snr'.format(name)][0] = snr[i]
dataset['{:}_err_var'.format(name)][0] = err[i]
dataset['{:}_beta'.format(name)][0] = beta[i]
for tds_name in self.tds_names:
R = pearson_R[tds_name]
p_R = pearson_p[tds_name]
rho = spea_rho[tds_name]
p_rho = spea_p[tds_name]
bias = bias_dict[tds_name]
mse = mse_dict[tds_name]
mse_corr = mse_corr_dict[tds_name]
mse_bias = mse_bias_dict[tds_name]
mse_var = mse_var_dict[tds_name]
rmsd = rmsd_dict[tds_name]
ubRMSD = ubRMSD_dict[tds_name]
if tau_dict and p_tau_dict:
tau = tau_dict[tds_name]
p_tau = p_tau_dict[tds_name]
split_tds_name = tds_name.split('_and_')
tds_name_key = "{:}_{:}".format(self.ds_names_lut[
split_tds_name[0]],
self.ds_names_lut[
split_tds_name[1]])
dataset['R_between_{:}'.format(tds_name_key)][0] = R
dataset['p_R_between_{:}'.format(tds_name_key)][0] = p_R
dataset['rho_between_{:}'.format(tds_name_key)][0] = rho
dataset['p_rho_between_{:}'.format(tds_name_key)][0] = p_rho
dataset['bias_between_{:}'.format(tds_name_key)][0] = bias
dataset['mse_between_{:}'.format(tds_name_key)][0] = mse
dataset['mse_corr_between_{:}'.format(tds_name_key)][0] = mse_corr
dataset['mse_bias_between_{:}'.format(tds_name_key)][0] = mse_bias
dataset['mse_var_between_{:}'.format(tds_name_key)][0] = mse_var
dataset['rmsd_between_{:}'.format(tds_name_key)][0] = rmsd
dataset['ubRMSD_between_{:}'.format(tds_name_key)][0] = ubRMSD
if self.calc_tau:
dataset['tau_between_{:}'.format(tds_name_key)][0] = tau
dataset['p_tau_between_{:}'.format(tds_name_key)][0] = p_tau
return dataset
def calc_metrics(self, data, gpi_info):
"""
calculates the desired statistics
Parameters
----------
data : pandas.DataFrame
with 3 columns, the first column is the reference dataset
named 'ref'
the second and third column are the datasets to compare against
named 'k1 and k2'
gpi_info : tuple
Grid point info (i.e. gpi, lon, lat)
"""
dataset = copy.deepcopy(self.result_template)
dataset['gpi'][0] = gpi_info[0]
dataset['lon'][0] = gpi_info[1]
dataset['lat'][0] = gpi_info[2]
for season in self.seasons:
if season != 'ALL':
subset = self.month_to_season[data.index.month] == season
else:
subset = np.ones(len(data), dtype=bool)
# number of observations
n_obs = subset.sum()
if n_obs < 10:
continue
dataset['{:}_n_obs'.format(season)][0] = n_obs
# get single dataset metrics
# calculate SNR
x = data[self.df_columns[0]].values[subset]
y = data[self.df_columns[1]].values[subset]
z = data[self.df_columns[2]].values[subset]
snr, err, beta = metrics.tcol_snr(x, y, z)
for i, name in enumerate(self.ds_names):
dataset['{:}_{:}_snr'.format(name, season)][0] = snr[i]
dataset['{:}_{:}_err_var'.format(name, season)][0] = err[i]
dataset['{:}_{:}_beta'.format(name, season)][0] = beta[i]
# calculate Pearson correlation
pearson_R, pearson_p = df_metrics.pearsonr(data)
pearson_R = pearson_R._asdict()
pearson_p = pearson_p._asdict()
# calculate Spearman correlation
spea_rho, spea_p = df_metrics.spearmanr(data)
spea_rho = spea_rho._asdict()
spea_p = spea_p._asdict()
# scale data to reference in order to calculate absolute metrics
data_scaled = scale(data, method='min_max')
# calculate bias
bias_nT = df_metrics.bias(data_scaled)
bias_dict = bias_nT._asdict()
# calculate ubRMSD
ubRMSD_nT = df_metrics.ubrmsd(data_scaled)
ubRMSD_dict = ubRMSD_nT._asdict()
for tds_name in self.tds_names:
R = pearson_R[tds_name]
p_R = pearson_p[tds_name]
rho = spea_rho[tds_name]
p_rho = spea_p[tds_name]
bias = bias_dict[tds_name]
ubRMSD = ubRMSD_dict[tds_name]
split_tds_name = tds_name.split('_and_')
tds_name_key = "{:}_{:}".format(self.ds_names_lut[
split_tds_name[0]],
self.ds_names_lut[
split_tds_name[1]])
dataset['{:}_{:}_R'.format(tds_name_key, season)][0] = R
dataset['{:}_{:}_p_R'.format(tds_name_key, season)][0] = p_R
dataset['{:}_{:}_rho'.format(tds_name_key, season)][0] = rho
dataset['{:}_{:}_p_rho'.format(tds_name_key, season)][0] = \
p_rho
dataset['{:}_{:}_bias'.format(tds_name_key, season)][0] = bias
dataset['{:}_{:}_ubrmsd'.format(tds_name_key, season)][0] = \
ubRMSD
return dataset