def test_DoubleVector(self):
v1 = api.DoubleVector([i for i in range(10)]) # empy
v2 = api.DoubleVector.FromNdArray(np.arange(0, 10.0, 0.5))
v3 = api.DoubleVector(np.arange(0, 10.0, 0.5))
self.assertEqual(len(v1), 10)
self.assertEqual(len(v2), 20)
self.assertEqual(len(v3), 20)
self.assertAlmostEqual(v2[3], 1.5)
def test_min_max_check_ts_fill(self):
ta=api.TimeAxis(0, 1, 5)
ts_src=api.TimeSeries(ta, values=api.DoubleVector([1.0, -1.0, 2.0, float('nan'), 4.0]), point_fx=api.POINT_AVERAGE_VALUE)
cts=api.TimeSeries(ta, values=api.DoubleVector([1.0, 1.8, 2.0, 2.0, 4.0]), point_fx=api.POINT_AVERAGE_VALUE)
ts_qac=ts_src.min_max_check_ts_fill(v_max=10.0, v_min=-10.0, dt_max=300, cts=cts)
self.assertAlmostEqual(ts_qac.value(3), 2.0)
ts_qac=ts_src.min_max_check_ts_fill(v_max=10.0, v_min=0.0, dt_max=300, cts=cts)
self.assertAlmostEqual(ts_qac.value(1), 1.8) # -1 out, replaced with linear between
self.assertAlmostEqual(ts_qac.value(3), 2.0)
def test_create_from_x_y_z_vector(self):
x = api.DoubleVector([1.0, 4.0, 7.0])
y = api.DoubleVector([2.0, 5.0, 8.0])
z = api.DoubleVector([3.0, 6.0, 9.0])
gpv = api.GeoPointVector.create_from_x_y_z(x, y, z)
for i in range(3):
self.assertAlmostEqual(gpv[i].x, 3 * i + 1)
self.assertAlmostEqual(gpv[i].y, 3 * i + 2)
self.assertAlmostEqual(gpv[i].z, 3 * i + 3)
def _create_shyft_ts(self):
b = 946684800 # 2000.01.01 00:00:00
h = 3600 #one hour in seconds
values = np.array([1.0, 2.0, 3.0])
shyft_ts_factory = api.TsFactory()
return shyft_ts_factory.create_point_ts(len(values), b, h,
api.DoubleVector(values))
def test_calibration_ts_case(self):
times=[0, 3600, 3600 + 2*3600]
ta=api.TimeAxis(api.UtcTimeVector(times[0:-1]), times[-1])
values=api.DoubleVector([0.0]*(len(times) - 1))
ts=api.TimeSeries(ta, values, point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE)
target=api.TargetSpecificationPts(ts, api.IntVector([0]), 1.0, api.ABS_DIFF, 1.0, 1.0, 1.0, api.CELL_CHARGE, 'water_balance')
self.assertIsNotNone(target)
def test_abs(self):
c=api.Calendar()
t0=c.time(2016, 1, 1)
dt=api.deltahours(1)
n=4
v=api.DoubleVector([1.0, -1.5, float("nan"), 3.0])
ta=api.TimeAxisFixedDeltaT(t0, dt, n)
ts0=api.TimeSeries(ta=ta, values=v, point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE)
tsa=api.TimeSeries('a')
ts1=tsa.abs()
ts1_blob=ts1.serialize()
ts1=api.TimeSeries.deserialize(ts1_blob)
self.assertTrue(ts1.needs_bind())
bts=ts1.find_ts_bind_info()
self.assertEqual(len(bts), 1)
bts[0].ts.bind(ts0)
ts1.bind_done()
self.assertFalse(ts1.needs_bind())
self.assertAlmostEqual(ts0.value(0), ts1.value(0), 6)
self.assertAlmostEqual(abs(ts0.value(1)), ts1.value(1), 6)
self.assertTrue(math.isnan(ts1.value(2)))
self.assertAlmostEqual(ts0.value(3), ts1.value(3), 6)
tsv0=api.TsVector()
tsv0.append(ts0)
tsv1=tsv0.abs()
self.assertAlmostEqual(tsv0[0].value(0), tsv1[0].value(0), 6)
self.assertAlmostEqual(abs(tsv0[0].value(1)), tsv1[0].value(1), 6)
self.assertTrue(math.isnan(tsv1[0].value(2)))
self.assertAlmostEqual(tsv0[0].value(3), tsv1[0].value(3), 6)
def verify_parameter_for_calibration(self,
param,
expected_size,
valid_names,
test_dict=None):
min_p_value = -1e+10
max_p_value = +1e+10
test_dict = test_dict or dict()
self.assertEqual(expected_size, param.size(),
"expected parameter size changed")
pv = api.DoubleVector([param.get(i) for i in range(param.size())])
for i in range(param.size()):
v = param.get(i)
self.assertTrue(v > min_p_value and v < max_p_value)
if i not in test_dict:
pv[i] = v * 1.01
param.set(
pv
) # set the complete vector, only used during C++ calibration, but we verify it here
x = param.get(i)
self.assertAlmostEqual(v * 1.01, x, 3,
"Expect new value when setting value")
else:
pv[i] = test_dict[i]
param.set(pv)
x = param.get(i)
self.assertAlmostEqual(x, test_dict[i], 1,
"Expect new value when setting value")
p_name = param.get_name(i)
self.assertTrue(len(p_name) > 0, "parameter name should exist")
self.assertEqual(valid_names[i], p_name)
def test_store(self):
ds = SmGTsRepository(PREPROD)
nl = [u'/shyft/test/a', u'/shyft/test/b',
u'/shyft/test/c'] #[u'/ICC-test-v9.2']
t0 = 946684800 # time_t/unixtime 2000.01.01 00:00:00
dt = 3600 #one hour in seconds
values = np.array([1.0, 2.0, 3.0])
shyft_ts_factory = api.TsFactory()
shyft_result_ts = shyft_ts_factory.create_point_ts(
len(values), t0, dt, api.DoubleVector(values))
shyft_catchment_result = dict()
shyft_catchment_result[nl[0]] = shyft_result_ts
shyft_catchment_result[nl[1]] = shyft_result_ts
shyft_catchment_result[nl[2]] = shyft_result_ts
r = ds.store(shyft_catchment_result)
self.assertEqual(r, True)
# now read back the ts.. and verify it's there..
read_period = api.UtcPeriod(t0, t0 + 3 * dt)
rts_list = ds.read(nl, read_period)
self.assertIsNotNone(rts_list)
c2 = rts_list[nl[-1]]
[
self.assertAlmostEqual(c2.value(i), values[i])
for i in range(len(values))
]
def _call_qm(self, prep_fcst_lst, weights, geo_points, ta,
input_source_types, nb_prior_scenarios):
# Check interpolation period is within time axis (ta)
ta_start = ta.time(0)
ta_end = ta.time(ta.size() - 1) # start of last time step
interp_start = ta_start + api.deltahours(self.qm_interp_hours[0])
interp_end = ta_start + api.deltahours(self.qm_interp_hours[1])
if interp_start > ta_end:
interp_start = api.no_utctime
interp_end = api.no_utctime
if interp_end > ta_end:
interp_end = ta_end
# Re-organize data before sending to api.quantile_map_forecast. For each source type and geo_point, group
# forecasts as TsVectorSets, send to api.quantile_map_forecast and return results as ensemble of source-keyed
# dictionaries of geo-ts
# First re-organize weights - one weight per TVS.
weight_sets = api.DoubleVector([w for ws in weights for w in ws])
# New version
results = [{} for i in range(nb_prior_scenarios)]
for src in input_source_types:
qm_scenarios = []
for geo_pt_idx, geo_pt in enumerate(geo_points):
forecast_sets = api.TsVectorSet()
for i, fcst_group in enumerate(prep_fcst_lst):
for j, forecast in enumerate(fcst_group):
scenarios = api.TsVector()
for member in forecast:
scenarios.append(member[src][geo_pt_idx].ts)
forecast_sets.append(scenarios)
if i == self.repo_prior_idx and j == 0:
prior_data = scenarios
# TODO: read prior if repo_prior_idx is None
qm_scenarios.append(
api.quantile_map_forecast(forecast_sets, weight_sets,
prior_data, ta, interp_start,
interp_end, True))
# Alternative: convert to array to enable slicing
# arr = np.array(qm_scenarios)
# Now organize to desired output format: ensemble of source-keyed dictionaries of geo-ts
for i in range(0, nb_prior_scenarios):
# source_dict = {}
# ts_vct = arr[:, i]
ts_vct = [x[i] for x in qm_scenarios]
vct = self.source_vector_map[src]()
[
vct.append(self.source_type_map[src](geo_pt, ts))
for geo_pt, ts in zip(geo_points, ts_vct)
]
# Alternatives:
# vct[:] = [self.source_type_map[src](geo_pt, ts) for geo_pt, ts in zip(geo_points, ts_vct)]
# vct = self.source_vector_map[src]([self.source_type_map[src](geo_pt, ts) for geo_pt, ts in zip(geo_points, ts_vct)])
results[i][src] = vct
return results
def _create_constant_geo_ts(self, geo_ts_type, geo_point, utc_period, value):
"""Create a time point ts, with one value at the start
of the supplied utc_period."""
tv = api.UtcTimeVector()
tv.push_back(utc_period.start)
vv = api.DoubleVector()
vv.push_back(value)
cts = api.TsFactory().create_time_point_ts(utc_period, tv, vv, api.POINT_AVERAGE_VALUE)
return geo_ts_type(geo_point, cts)
def _make_shyft_ts_from_xts(xts):
if not isinstance(xts, ITimeSeries):
raise SmgDataError("Supplied xts should be of type ITimeSeries")
t = api.UtcTimeVector()
v = api.DoubleVector()
for i in range(xts.Count):
t.push_back(xts.Time(i).ToUnixTime())
v.push_back(xts.Value(i).V)
shyft_ts = api.TsFactory().create_time_point_ts(api.UtcPeriod(t[0], t[-1]), t, v)
return shyft_ts
def test_min_max_check_linear_fill(self):
ta=api.TimeAxis(0, 1, 5)
ts_src=api.TimeSeries(ta, values=api.DoubleVector([1.0, -1.0, 2.0, float('nan'), 4.0]), point_fx=api.POINT_AVERAGE_VALUE)
ts_qac=ts_src.min_max_check_linear_fill(v_max=10.0, v_min=-10.0, dt_max=300)
self.assertAlmostEqual(ts_qac.value(3), 3.0)
ts_qac=ts_src.min_max_check_linear_fill(v_max=10.0, v_min=0.0, dt_max=300)
self.assertAlmostEqual(ts_qac.value(1), 1.5) # -1 out, replaced with linear between
self.assertAlmostEqual(ts_qac.value(3), 3.0)
ts_qac=ts_src.min_max_check_linear_fill(v_max=10.0, v_min=0.0, dt_max=0)
self.assertTrue(not math.isfinite(ts_qac.value(3))) # should give nan, not allowed to fill in
self.assertTrue(not math.isfinite(ts_qac.value(1))) # should give nan, not allowed to fill in
def test_create_TargetSpecificationPts(self):
t = api.TargetSpecificationPts();
t.scale_factor = 1.0
t.calc_mode = api.NASH_SUTCLIFFE
t.calc_mode = api.KLING_GUPTA;
t.s_r = 1.0 # KGEs scale-factors
t.s_a = 2.0
t.s_b = 3.0
self.assertAlmostEqual(t.scale_factor, 1.0)
# create a ts with some points
cal = api.Calendar();
start = cal.time(api.YMDhms(2015, 1, 1, 0, 0, 0))
dt = api.deltahours(1)
tsf = api.TsFactory();
times = api.UtcTimeVector()
times.push_back(start + 1 * dt);
times.push_back(start + 3 * dt);
times.push_back(start + 4 * dt)
values = api.DoubleVector()
values.push_back(1.0)
values.push_back(3.0)
values.push_back(np.nan)
tsp = tsf.create_time_point_ts(api.UtcPeriod(start, start + 24 * dt), times, values)
# convert it from a time-point ts( as returned from current smgrepository) to a fixed interval with timeaxis, needed by calibration
tst = api.TsTransform()
tsa = tst.to_average(start, dt, 24, tsp)
# tsa2 = tst.to_average(start,dt,24,tsp,False)
# tsa_staircase = tst.to_average_staircase(start,dt,24,tsp,False) # nans infects the complete interval to nan
# tsa_staircase2 = tst.to_average_staircase(start,dt,24,tsp,True) # skip nans, nans are 0
# stuff it into the target spec.
# also show how to specify snow-calibration
cids = api.IntVector([0, 2, 3])
t2 = api.TargetSpecificationPts(tsa,cids, 0.7, api.KLING_GUPTA, 1.0, 1.0, 1.0, api.SNOW_COVERED_AREA)
t2.catchment_property = api.SNOW_WATER_EQUIVALENT
self.assertEqual(t2.catchment_property, api.SNOW_WATER_EQUIVALENT)
self.assertIsNotNone(t2.catchment_indexes)
for i in range(len(cids)):
self.assertEqual(cids[i],t2.catchment_indexes[i])
t.ts = tsa
#TODO: Does not work, list of objects are not yet convertible tv = api.TargetSpecificationVector([t, t2])
tv=api.TargetSpecificationVector()
tv.append(t)
tv.append(t2)
# now verify we got something ok
self.assertEqual(2, tv.size())
self.assertAlmostEqual(tv[0].ts.value(1), 1.5) # average value 0..1 ->0.5
self.assertAlmostEqual(tv[0].ts.value(2), 2.5) # average value 0..1 ->0.5
self.assertAlmostEqual(tv[0].ts.value(3), 3.0) # average value 0..1 ->0.5
# and that the target vector now have its own copy of ts
tsa.set(1, 3.0)
self.assertAlmostEqual(tv[0].ts.value(1), 1.5) # make sure the ts passed onto target spec, is a copy
self.assertAlmostEqual(tsa.value(1), 3.0) # and that we really did change the source
def test_double_vector(self):
dv_from_list = api.DoubleVector([x for x in range(10)])
dv_np = np.arange(10.0)
dv_from_np = api.DoubleVector.from_numpy(dv_np)
self.assertEqual(len(dv_from_list), 10)
assert_array_almost_equal(dv_from_list.to_numpy(), dv_np)
assert_array_almost_equal(dv_from_np.to_numpy(), dv_np)
dv_from_np[5] = 8
dv_from_np.append(11)
dv_from_np.push_back(12)
dv_np[5] = 8
dv_np.resize(12)
dv_np[10] = 11
dv_np[11] = 12
assert_array_almost_equal(dv_from_np.to_numpy(), dv_np)
def _downscaling(self, forecast, target_grid, ta_fixed_dt):
# Using idw for time being
prep_fcst = {}
for src_type, fcst in forecast.items():
if src_type == 'precipitation':
# just setting som idw_params for time being
idw_params = api.IDWPrecipitationParameter()
idw_params.max_distance = 15000
idw_params.max_members = 4
idw_params.scale_factor = 1.0
prep_fcst[src_type] = api.idw_precipitation(
fcst, target_grid, ta_fixed_dt, idw_params)
elif src_type == 'temperature':
# just setting som idw_params for time being
idw_params = api.IDWTemperatureParameter()
idw_params.max_distance = 15000
idw_params.max_members = 4
idw_params.gradient_by_equation = False
prep_fcst[src_type] = api.idw_temperature(
fcst, target_grid, ta_fixed_dt, idw_params)
elif src_type == 'radiation':
# just setting som idw_params for time being
idw_params = api.IDWParameter()
idw_params.max_distance = 15000
idw_params.max_members = 4
idw_params.distance_measure_factor = 1
slope_factor = api.DoubleVector([0.9] * len(target_grid))
prep_fcst[src_type] = api.idw_radiation(
fcst, target_grid, ta_fixed_dt, idw_params, slope_factor)
elif src_type == 'wind_speed':
# just setting som idw_params for time being
idw_params = api.IDWParameter()
idw_params.max_distance = 15000
idw_params.max_members = 4
idw_params.distance_measure_factor = 1
prep_fcst[src_type] = api.idw_wind_speed(
fcst, target_grid, ta_fixed_dt, idw_params)
elif src_type == 'relative_humidity':
# just setting som idw_params for time being
idw_params = api.IDWParameter()
idw_params.max_distance = 15000
idw_params.max_members = 4
idw_params.distance_measure_factor = 1
prep_fcst[src_type] = api.idw_relative_humidity(
fcst, target_grid, ta_fixed_dt, idw_params)
return prep_fcst
def test_idw_radiation_transform_from_set_to_grid(self):
"""
Test IDW interpolation transforms wind_speed time-series according to time-axis and range.
"""
idw_p = api.IDWParameter()
self.assertEqual(idw_p.max_distance, 200000)
self.assertEqual(idw_p.max_members, 10)
fx = lambda z : [15 for x in range(self.n)]
arome_grid = self._create_geo_radiation_grid(self.nx, self.ny, self.dx_arome, fx)
dest_grid_points = self._create_geo_point_grid(self.mnx, self.mny, self.dx_model)
ta = api.TimeAxisFixedDeltaT(self.t, self.d * 3, int(self.n / 3))
radiation_slope_factors = api.DoubleVector()
radiation_slope_factors[:] = [ 0.9 for i in range(len(dest_grid_points))]
dest_grid = api.idw_radiation(arome_grid, dest_grid_points, ta, idw_p, radiation_slope_factors)
self.assertIsNotNone(dest_grid)
self.assertEqual(len(dest_grid), self.mnx * self.mny)
def test_merge_points(self):
a=api.TimeSeries() # a empty at beginning, we allow that.
tb=api.TimeAxis(0, 1, 5)
b=api.TimeSeries(tb, values=api.DoubleVector([1.0, -1.0, 2.0, 3.0, 4.0]), point_fx=api.POINT_AVERAGE_VALUE)
a.merge_points(b) # now a should equal b
c=api.TimeSeries(api.TimeAxis(api.UtcTimeVector([3, 10, 11]), t_end=12), fill_value=9.0, point_fx=api.POINT_AVERAGE_VALUE)
a.merge_points(c) # now a should have new values for t=3, plus new time-points 11 and 12
self.assertEqual(len(a), 7)
assert_array_almost_equal(a.values.to_numpy(), np.array([1.0, -1.0, 2.0, 9.0, 4.0, 9.0, 9.0]))
assert_array_almost_equal(a.time_axis.time_points, np.array([0,1,2,3,4,10,11,12]))
xa= api.TimeSeries("some_unbound_ts")
xa.merge_points(a) # now it should be bound, and it's values are from a
self.assertEqual(len(xa), 7)
assert_array_almost_equal(xa.values.to_numpy(), np.array([1.0, -1.0, 2.0, 9.0, 4.0, 9.0, 9.0]))
assert_array_almost_equal(xa.time_axis.time_points, np.array([0,1,2,3,4,10,11,12]))
d=api.TimeSeries(api.TimeAxis(api.UtcTimeVector([3, 10, 11]), t_end=12), fill_value=10.0, point_fx=api.POINT_AVERAGE_VALUE)
xa.merge_points(d) #now that xa is bound, also check we get updated
self.assertEqual(len(xa), 7)
assert_array_almost_equal(xa.values.to_numpy(), np.array([1.0, -1.0, 2.0, 10.0, 4.0, 10.0, 10.0]))
assert_array_almost_equal(xa.time_axis.time_points, np.array([0, 1, 2, 3, 4, 10, 11, 12]))
radcaly24 = api.RadiationCalculator(radparamy)
radcaly3 = api.RadiationCalculator(radparamy)
radresy = api.RadiationResponse()
radresy1 = api.RadiationResponse()
radresy24 = api.RadiationResponse()
radresy3 = api.RadiationResponse()
# we now can simply run the routine step by step:
try:
del net_rad
del ra_rad
del rah_rad
except:
pass
net_rad = api.DoubleVector()
swcalc_step1 = api.DoubleVector()
ra_rad = api.DoubleVector()
ra_rad1 = api.DoubleVector()
rah_rad = api.DoubleVector()
rat_rad = api.DoubleVector()
declin_arr = api.DoubleVector()
radtheorint_arr = api.DoubleVector()
swcalc_step24 = api.DoubleVector()
radcalc_step24 = api.DoubleVector()
swcalc_step3 = api.DoubleVector()
radcalc_step3 = api.DoubleVector()
i = 0
j = 1
def run_radiation(latitude_deg, slope_deg, aspect_deg, elevation, albedo, turbidity, temperature, rhumidity, flag = 'instant', method='dingman'):
"""Module creates shyft radiation model with different timesteps and run it for a defined period of time (1 year with 24-hours averaging) """
import numpy as np
import math
from shyft import api
# single method test
# here I will try to reproduce the Fig.1b from Allen2006 (reference)
utc = api.Calendar()
n = 365 # nr of time steps: 1 year, daily data
t_start = utc.time(2002, 1, 1) # starting at the beginning of the year 1970
# converting station data
tempP1 = temperature # [degC], real data should be used
rhP1 = rhumidity #[%], real data should be used
rsm = 0.0
radparam = api.RadiationParameter(albedo,turbidity)
radcal_inst = api.RadiationCalculator(radparam)
radcal_1h = api.RadiationCalculator(radparam)
radcal_24h = api.RadiationCalculator(radparam)
radcal_3h = api.RadiationCalculator(radparam)
radres_inst = api.RadiationResponse()
radres_1h = api.RadiationResponse()
radres_24h = api.RadiationResponse()
radres_3h = api.RadiationResponse()
rv_rso = [] # clear-sky radiation, result vector
rv_ra = [] # extraterrestrial radiation, result vector
rv_net = [] # net radiation
rv_net_sw = [] #net short-wave
rv_net_lw = [] #net long-wave
dayi = 0
doy = api.DoubleVector()
# running 24-h timestep
step = api.deltahours(24)
tadays = api.TimeAxis(t_start, step, n + 1) # days
k = 1
while (k <= n):
doy.append(dayi)
k += 1
dayi += 1
if flag=='24-hour':
dayi = 0
doy = api.DoubleVector()
# running 24-h timestep
step = api.deltahours(24)
tadays = api.TimeAxis(t_start, step, n+1) # days
k = 1
while (k<=n):
time1 = tadays.time(k-1)
if method=='dingman':
radcal_24h.net_radiation_step(radres_24h, latitude_deg, time1, step, slope_deg, aspect_deg,
tempP1, rhP1, elevation, rsm)
else:
radcal_24h.net_radiation_step_asce_st(radres_24h, latitude_deg, time1, step, slope_deg, aspect_deg, tempP1, rhP1, elevation, rsm)
rv_rso.append(radres_24h.sw_t)
rv_ra.append(radres_24h.ra)
rv_net.append(radres_24h.net)
rv_net_sw.append(radres_24h.net_sw)
rv_net_lw.append(radres_24h.net_lw)
# print(radres_24h.ra)
doy.append(dayi)
k+=1
dayi += 1
# doy.append(dayi)
elif flag=='3-hour':
# running 3h timestep
step = api.deltahours(3)
ta3 = api.TimeAxis(t_start, step, n * 8) # hours, 1h timestep
rso_3h = [] #clear-sky radiation
ra_3h = [] # extraterrestrial radiation
net_sw_3h = []
net_lw_3h = []
net_3h = []
k = 1
while (k<n*8):
time0 = ta3.time(k-1)
if method=='dingman':
radcal_3h.net_radiation_step(radres_3h, latitude_deg, time0, step, slope_deg, aspect_deg, tempP1,
rhP1, elevation, rsm)
else:
radcal_3h.net_radiation_step_asce_st(radres_3h, latitude_deg, time0, step, slope_deg, aspect_deg, tempP1, rhP1, elevation, rsm)
rso_3h.append(radres_3h.sw_t)
ra_3h.append(radres_3h.ra)
net_sw_3h.append(radres_3h.net_sw)
net_lw_3h.append(radres_3h.net_lw)
net_3h.append(radres_3h.net)
k+=1
rv_rso = [sum(rso_3h[i:i + 8]) for i in range(0, len(rso_3h), 8)]
rv_ra = [sum(ra_3h[i:i + 8]) for i in range(0, len(ra_3h), 8)]
rv_net_sw = [sum(net_sw_3h[i:i + 8]) for i in range(0, len(net_sw_3h), 8)]
rv_net_lw = [sum(net_lw_3h[i:i + 8])/8 for i in range(0, len(net_lw_3h), 8)]
rv_net = [sum(net_3h[i:i + 8]) for i in range(0, len(net_3h), 8)]
elif flag=='1-hour':
# runing 1h timestep
step = api.deltahours(1)
ta = api.TimeAxis(t_start, step, n * 24) # hours, 1h timestep
rso_1h = []
ra_1h = []
net_sw_1h = []
net_lw_1h = []
net_1h = []
k = 1
while (k<n*24):
time1 = ta.time(k-1)
if method=='dingman':
radcal_1h.net_radiation_step(radres_1h, latitude_deg, time1, step, slope_deg, aspect_deg,
tempP1, rhP1, elevation, rsm)
else:
radcal_1h.net_radiation_step_asce_st(radres_1h, latitude_deg, time1, step, slope_deg, aspect_deg, tempP1, rhP1, elevation,rsm)
rso_1h.append(radres_1h.sw_t)
ra_1h.append(radres_1h.ra)
net_sw_1h.append(radres_1h.net_sw)
net_lw_1h.append(radres_1h.net_lw)
net_1h.append(radres_1h.net)
k += 1
rv_rso = [sum(rso_1h[i:i + 24]) for i in range(0, len(rso_1h), 24)]
rv_ra = [sum(ra_1h[i:i + 24]) for i in range(0, len(ra_1h), 24)]
rv_net_sw = [sum(net_sw_1h[i:i + 24]) for i in range(0, len(net_sw_1h), 24)]
rv_net_lw = [sum(net_lw_1h[i:i + 24])/24 for i in range(0, len(net_lw_1h), 24)]
rv_net = [sum(net_1h[i:i + 24]) for i in range(0, len(net_1h), 24)]
elif flag=='instant':
# running instantaneous with dmin timstep
minutes = 60
dmin = 1
step = api.deltaminutes(dmin)
tamin = api.TimeAxis(t_start,step , n * 24 * minutes)
rso_inst = []
ra_inst = []
net_sw_inst = []
net_lw_inst = []
net_inst = []
doy1 = []
k = 0
while (k < n*24*minutes):
timemin = tamin.time(k)
radcal_inst.net_radiation(radres_inst, latitude_deg, timemin, slope_deg, aspect_deg, tempP1, rhP1,
elevation, rsm)
rso_inst.append(radres_inst.sw_t)
ra_inst.append(radres_inst.ra)
net_sw_inst.append(radres_inst.net_sw)
net_lw_inst.append(radres_inst.net_lw)
net_inst.append(radres_inst.net)
doy1.append(k)
k += 1
rv_rso = [sum(rso_inst[i:i+24*minutes])/(24*minutes) for i in range(0,len(rso_inst),24*minutes)]
rv_ra = [sum(ra_inst[i:i + 24 * minutes]) /(24 * minutes) for i in range(0, len(ra_inst), 24 * minutes)]
rv_net_sw = [sum(net_sw_inst[i:i + 24*minutes])/(24*minutes) for i in range(0, len(net_sw_inst), 24*minutes)]
rv_net_lw = [sum(net_lw_inst[i:i + 24*minutes])/(24*minutes) for i in range(0, len(net_lw_inst), 24*minutes)]
rv_net = [sum(net_inst[i:i + 24*minutes])/(24*minutes) for i in range(0, len(net_inst), 24*minutes)]
else:
return 'Nothing todo. Please, specify timestep'
return doy, rv_ra, rv_rso, rv_net_sw, rv_net_lw, rv_net
def test_create_TargetSpecificationPts(self):
t = api.TargetSpecificationPts()
t.scale_factor = 1.0
t.calc_mode = api.NASH_SUTCLIFFE
t.calc_mode = api.KLING_GUPTA
t.calc_mode = api.ABS_DIFF
t.calc_mode = api.RMSE
t.s_r = 1.0 # KGEs scale-factors
t.s_a = 2.0
t.s_b = 3.0
self.assertIsNotNone(t.uid)
t.uid = 'test'
self.assertEqual(t.uid, 'test')
self.assertAlmostEqual(t.scale_factor, 1.0)
# create a ts with some points
cal = api.Calendar()
start = cal.time(2015, 1, 1, 0, 0, 0)
dt = api.deltahours(1)
tsf = api.TsFactory()
times = api.UtcTimeVector()
times.push_back(start + 1 * dt)
times.push_back(start + 3 * dt)
times.push_back(start + 4 * dt)
values = api.DoubleVector()
values.push_back(1.0)
values.push_back(3.0)
values.push_back(np.nan)
tsp = tsf.create_time_point_ts(api.UtcPeriod(start, start + 24 * dt),
times, values)
# convert it from a time-point ts( as returned from current smgrepository) to a fixed interval with timeaxis, needed by calibration
tst = api.TsTransform()
tsa = tst.to_average(start, dt, 24, tsp)
# tsa2 = tst.to_average(start,dt,24,tsp,False)
# tsa_staircase = tst.to_average_staircase(start,dt,24,tsp,False) # nans infects the complete interval to nan
# tsa_staircase2 = tst.to_average_staircase(start,dt,24,tsp,True) # skip nans, nans are 0
# stuff it into the target spec.
# also show how to specify snow-calibration
cids = api.IntVector([0, 2, 3])
t2 = api.TargetSpecificationPts(tsa, cids, 0.7, api.KLING_GUPTA, 1.0,
1.0, 1.0, api.SNOW_COVERED_AREA,
'test_uid')
self.assertEqual(t2.uid, 'test_uid')
t2.catchment_property = api.SNOW_WATER_EQUIVALENT
self.assertEqual(t2.catchment_property, api.SNOW_WATER_EQUIVALENT)
t2.catchment_property = api.CELL_CHARGE
self.assertEqual(t2.catchment_property, api.CELL_CHARGE)
self.assertIsNotNone(t2.catchment_indexes)
for i in range(len(cids)):
self.assertEqual(cids[i], t2.catchment_indexes[i])
t.ts = api.TimeSeries(tsa) # target spec is now a regular TimeSeries
tv = api.TargetSpecificationVector()
tv[:] = [t, t2]
# now verify we got something ok
self.assertEqual(2, tv.size())
self.assertAlmostEqual(tv[0].ts.value(1),
1.5) # average value 0..1 ->0.5
self.assertAlmostEqual(tv[0].ts.value(2),
2.5) # average value 0..1 ->0.5
# self.assertAlmostEqual(tv[0].ts.value(3), 3.0) # original flat out at end, but now:
self.assertTrue(math.isnan(
tv[0].ts.value(3))) # strictly linear between points.
# and that the target vector now have its own copy of ts
tsa.set(1, 3.0)
self.assertAlmostEqual(
tv[0].ts.value(1),
1.5) # make sure the ts passed onto target spec, is a copy
self.assertAlmostEqual(tsa.value(1),
3.0) # and that we really did change the source
# Create a clone of target specification vector
tv2 = api.TargetSpecificationVector(tv)
self.assertEqual(2, tv2.size())
self.assertAlmostEqual(tv2[0].ts.value(1),
1.5) # average value 0..1 ->0.5
self.assertAlmostEqual(tv2[0].ts.value(2),
2.5) # average value 0..1 ->0.5
self.assertTrue(math.isnan(
tv2[0].ts.value(3))) # average value 0..1 ->0.5
tv2[0].scale_factor = 10.0
self.assertAlmostEqual(tv[0].scale_factor, 1.0)
self.assertAlmostEqual(tv2[0].scale_factor, 10.0)
# test we can create from breakpoint time-series
ts_bp = api.TimeSeries(api.TimeAxis(api.UtcTimeVector([0, 25, 20]),
30),
fill_value=2.0,
point_fx=api.POINT_AVERAGE_VALUE)
tspec_bp = api.TargetSpecificationPts(ts_bp, cids, 0.7,
api.KLING_GUPTA, 1.0, 1.0, 1.0,
api.CELL_CHARGE, 'test_uid')
self.assertIsNotNone(tspec_bp)
def p_max(self):
return api.DoubleVector([
self._config.calibration_parameters[name]['max']
for name in self.calib_param_names
])
def _call_qm_old(self, prep_fcst_lst, weights, geo_points, ta,
input_source_types, nb_prior_scenarios):
# TODO: Extend handling to cover all cases and send out warnings if interpolation period is modified
# Check ta against interpolation start and end times
# Simple logic for time being, should be refined for the overlap cases
ta_start = ta.time(0)
ta_end = ta.time(ta.size() - 1) # start of last time step
interp_start = ta_start + api.deltahours(self.qm_interp_hours[0])
interp_end = ta_start + api.deltahours(self.qm_interp_hours[1])
if interp_start > ta_end:
interp_start = api.no_utctime
interp_end = api.no_utctime
if interp_end > ta_end:
interp_end = ta_end
# Re-organize data before sending to api.quantile_map_forecast. For each source type and geo_point, group
# forecasts as TsVectorSets, send to api.quantile_map_forecast and return results as ensemble of source-keyed
# dictionaries of geo-ts
# First re-organize weights - one weight per TVS.
weight_sets = api.DoubleVector([w for ws in weights for w in ws])
# New version
# results = [{} for i in range(nb_prior_scenarios)]
# for src in input_source_types:
# qm_scenarios = []
# for geo_pt_idx, geo_pt in enumerate(geo_points):
# forecast_sets = api.TsVectorSet()
# for i, fcst_group in enumerate(prep_fcst_lst) :
# for j, forecast in enumerate(fcst_group):
# scenarios = api.TsVector()
# for member in forecast:
# scenarios.append(member[src][geo_pt_idx].ts)
# forecast_sets.append(scenarios)
# if i == self.repo_prior_idx and j==0:
# prior_data = scenarios
# # TODO: read prior if repo_prior_idx is None
#
# qm_scenarios.append(api.quantile_map_forecast(forecast_sets, weight_sets, prior_data, ta,
# interp_start, interp_end, True))
#
# # Alternative: convert to array to enable slicing
# # arr = np.array(qm_scenarios)
#
# # Now organize to desired output format: ensemble of source-keyed dictionaries of geo-ts
# for i in range(0,nb_prior_scenarios):
# # source_dict = {}
# # ts_vct = arr[:, i]
# ts_vct = [x[i] for x in qm_scenarios]
# vct = self.source_vector_map[src]()
# [vct.append(self.source_type_map[src](geo_pt, ts)) for geo_pt, ts in zip(geo_points, ts_vct)]
# # Alternatives:
# # vct[:] = [self.source_type_map[src](geo_pt, ts) for geo_pt, ts in zip(geo_points, ts_vct)]
# # vct = self.source_vector_map[src]([self.source_type_map[src](geo_pt, ts) for geo_pt, ts in zip(geo_points, ts_vct)])
# results[i][src] = vct
# return results
# Old version
weight_sets = api.DoubleVector([w for ws in weights for w in ws])
dict = {}
for src in input_source_types:
qm_scenarios = []
for geo_pt_idx, geo_pt in enumerate(geo_points):
forecast_sets = api.TsVectorSet()
for i, fcst_group in enumerate(prep_fcst_lst):
for j, forecast in enumerate(fcst_group):
scenarios = api.TsVector()
for member in forecast:
scenarios.append(member[src][geo_pt_idx].ts)
forecast_sets.append(scenarios)
# TODO: handle prior similarly if repo_prior_idx is None
if i == self.repo_prior_idx and j == 0:
prior_data = scenarios
qm_scenarios.append(
api.quantile_map_forecast(forecast_sets, weight_sets,
prior_data, ta, interp_start,
interp_end, True))
dict[src] = np.array(qm_scenarios)
# Now organize to desired output format: ensenble of source-keyed dictionaries of geo-ts
# TODO: write function to extract info about prior like number of scenarios
nb_prior_scenarios = dict[input_source_types[0]].shape[1]
results = []
for i in range(0, nb_prior_scenarios):
source_dict = {}
for src in input_source_types:
ts_vct = dict[src][:, i]
vct = self.source_vector_map[src]()
[
vct.append(self.source_type_map[src](geo_pt, ts))
for geo_pt, ts in zip(geo_points, ts_vct)
]
# Alternatives:
# vct[:] = [self.source_type_map[src](geo_pt, ts) for geo_pt, ts in zip(geo_points, ts_vct)]
# vct = self.source_vector_map[src]([self.source_type_map[src](geo_pt, ts) for geo_pt, ts in zip(geo_points, ts_vct)])
source_dict[src] = vct
results.append(source_dict)
return results
def _create_shyft_ts(self):
b = 946684800 # 2000.01.01 00:00:00
h = 3600 # One hour in seconds
v = np.array([1.0, 2.0, 3.0])
return api.TsFactory().create_point_ts(len(v), b, h,
api.DoubleVector(v))
