def test_extend_vector_of_timeseries(self): t0=api.utctime_now() dt=api.deltahours(1) n=512 tsvector=api.TsVector() ta=api.TimeAxisFixedDeltaT(t0 + 3*n*dt, dt, 2*n) tsvector.push_back(api.TimeSeries( ta=api.TimeAxisFixedDeltaT(t0, dt, 2*n), fill_value=1.0, point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE)) tsvector.push_back(api.TimeSeries( ta=api.TimeAxisFixedDeltaT(t0 + 2*n*dt, dt, 2*n), fill_value=2.0, point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE)) extension=api.TimeSeries(ta=ta, fill_value=8.0, point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE) # extend after all time-series in the vector extended_tsvector=tsvector.extend_ts(extension) # assert first element for i in range(2*n): self.assertEqual(extended_tsvector[0](t0 + i*dt), 1.0) for i in range(n): self.assertTrue(math.isnan(extended_tsvector[0](t0 + (2*n + i)*dt))) for i in range(2*n): self.assertEqual(extended_tsvector[0](t0 + (3*n + i)*dt), 8.0) # assert second element for i in range(2*n): self.assertEqual(extended_tsvector[1](t0 + (2*n + i)*dt), 2.0) for i in range(n): self.assertEqual(extended_tsvector[1](t0 + (4*n + i)*dt), 8.0) tsvector_2=api.TsVector() tsvector_2.push_back(api.TimeSeries( ta=api.TimeAxisFixedDeltaT(t0 + 2*n*dt, dt, 4*n), fill_value=10.0, point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE)) tsvector_2.push_back(api.TimeSeries( ta=api.TimeAxisFixedDeltaT(t0 + 4*n*dt, dt, 4*n), fill_value=20.0, point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE)) # extend each element in tsvector by the corresponding element in tsvector_2 extended_tsvector=tsvector.extend_ts(tsvector_2) # assert first element for i in range(2*n): self.assertEqual(extended_tsvector[0](t0 + i*dt), 1.0) for i in range(4*n): self.assertEqual(extended_tsvector[0](t0 + (2*n + i)*dt), 10.0) # assert second element for i in range(2*n): self.assertEqual(extended_tsvector[1](t0 + (2*n + i)*dt), 2.0) for i in range(4*n): self.assertEqual(extended_tsvector[1](t0 + (4*n + i)*dt), 20.0)
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 test_percentiles(self): c=api.Calendar() t0=c.time(2016, 1, 1) dt=api.deltahours(1) n=240 ta=api.TimeAxisFixedDeltaT(t0, dt, n) timeseries=api.TsVector() for i in range(10): timeseries.append( api.TimeSeries(ta=ta, fill_value=i, point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE)) wanted_percentiles=api.IntVector([api.statistics_property.MIN_EXTREME, 0, 10, 50, api.statistics_property.AVERAGE, 70, 100, api.statistics_property.MAX_EXTREME]) ta_day=api.TimeAxisFixedDeltaT(t0, dt*24, n//24) ta_day2=api.TimeAxis(t0, dt*24, n//24) percentiles=api.percentiles(timeseries, ta_day, wanted_percentiles) percentiles2=timeseries.percentiles(ta_day2, wanted_percentiles) # just to verify it works with alt. syntax self.assertEqual(len(percentiles2), len(percentiles)) for i in range(len(ta_day)): self.assertAlmostEqual(0.0, percentiles[0].value(i), 3, "min-extreme ") self.assertAlmostEqual(0.0, percentiles[1].value(i), 3, " 0-percentile") self.assertAlmostEqual(0.9, percentiles[2].value(i), 3, " 10-percentile") self.assertAlmostEqual(4.5, percentiles[3].value(i), 3, " 50-percentile") self.assertAlmostEqual(4.5, percentiles[4].value(i), 3, " -average") self.assertAlmostEqual(6.3, percentiles[5].value(i), 3, " 70-percentile") self.assertAlmostEqual(9.0, percentiles[6].value(i), 3, "100-percentile") self.assertAlmostEqual(9.0, percentiles[7].value(i), 3, "max-extreme")
def _create_forecast_set(self, n_fc, t0, dt, n_steps, dt_fc, fx): """ Parameters ---------- n_fc : int number of forecasts, e.g. 8 t0 : utctime start of first forecast dt : utctimespan delta t for forecast-ts n_steps : number of steps in one forecast-ts dt_fc : utctimespan delta t between each forecast, like deltahours(6) fx : lambda time_axis: a function returning a DoubleVector with values for the supplied time-axis Returns ------- api.TsVector() """ fc_set = api.TsVector() for i in range(n_fc): ta = api.Timeaxis2(t0 + i * dt_fc, dt, n_steps) ts = api.Timeseries( ta=ta, values=fx(ta), point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE) fc_set.append(ts) return fc_set
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 test_vector_of_timeseries(self): dv = np.arange(self.ta.size()) v = api.DoubleVector.from_numpy(dv) tsf = api.TsFactory(); tsa = tsf.create_point_ts(self.n, self.t, self.d, v) tsvector = api.TsVector() self.assertEqual(len(tsvector), 0) tsvector.push_back(tsa) self.assertEqual(len(tsvector), 1)
def test_ts_factory(self): dv=np.arange(self.ta.size()) v=api.DoubleVector.from_numpy(dv) t=api.UtcTimeVector(); for i in range(self.ta.size()): t.push_back(self.ta(i).start) t.push_back(self.ta(self.ta.size() - 1).end) tsf=api.TsFactory() ts1=tsf.create_point_ts(self.ta.size(), self.t, self.d, v) ts2=tsf.create_time_point_ts(self.ta.total_period(), t, v) tslist=api.TsVector() tslist.push_back(ts1) tslist.push_back(ts2) self.assertEqual(tslist.size(), 2)
def test_percentiles_with_min_max_extremes(self): """ the percentiles function now also supports picking out the min-max peak value within each interval. Setup test-data so that we have a well known percentile result, but also have peak-values within the interval that we can verify. We let hour ts 0..9 have values 0..9 constant 24*10 days then modify ts[1], every day first value to a peak min value equal to - day_no*1 every day second value to a peak max value equal to + day_no*1 every day 3rd value to a nan value ts[1] should then have same average value for each day (so same percentile) but min-max extreme should be equal to +- day_no*1 """ c=api.Calendar() t0=c.time(2016, 1, 1) dt=api.deltahours(1) n=240 ta=api.TimeAxis(t0, dt, n) timeseries=api.TsVector() p_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE for i in range(10): timeseries.append(api.TimeSeries(ta=ta, fill_value=i, point_fx=p_fx)) ts=timeseries[1] # pick this one to insert min/max extremes for i in range(0, 240, 24): ts.set(i + 0, 1.0 - 100*i/24.0) ts.set(i + 1, 1.0 + 100*i/24.0) # notice that when i==0, this gives 1.0 ts.set(i + 2, float('nan')) # also put in a nan, just to verify it is ignored during average processing wanted_percentiles=api.IntVector([api.statistics_property.MIN_EXTREME, 0, 10, 50, api.statistics_property.AVERAGE, 70, 100, api.statistics_property.MAX_EXTREME]) ta_day=api.TimeAxis(t0, dt*24, n//24) percentiles=api.percentiles(timeseries, ta_day, wanted_percentiles) for i in range(len(ta_day)): if i == 0: # first timestep, the min/max extremes are picked from 0'th and 9'th ts. self.assertAlmostEqual(0.0, percentiles[0].value(i), 3, "min-extreme ") self.assertAlmostEqual(9.0, percentiles[7].value(i), 3, "min-extreme ") else: self.assertAlmostEqual(1.0 - 100.0*i*24.0/24.0, percentiles[0].value(i), 3, "min-extreme ") self.assertAlmostEqual(1.0 + 100.0*i*24.0/24.0, percentiles[7].value(i), 3, "max-extreme") self.assertAlmostEqual(0.0, percentiles[1].value(i), 3, " 0-percentile") self.assertAlmostEqual(0.9, percentiles[2].value(i), 3, " 10-percentile") self.assertAlmostEqual(4.5, percentiles[3].value(i), 3, " 50-percentile") self.assertAlmostEqual(4.5, percentiles[4].value(i), 3, " -average") self.assertAlmostEqual(6.3, percentiles[5].value(i), 3, " 70-percentile") self.assertAlmostEqual(9.0, percentiles[6].value(i), 3, "100-percentile")
def test_vector_of_timeseries(self): dv=np.arange(self.ta.size()) v=api.DoubleVector.from_numpy(dv) tsf=api.TsFactory() tsa=tsf.create_point_ts(self.n, self.t, self.d, v) tsvector=api.TsVector() self.assertEqual(len(tsvector), 0) tsvector.push_back(tsa) self.assertEqual(len(tsvector), 1) tsvector.push_back(tsa) vv=tsvector.values_at_time(self.ta.time(3)) # verify it's easy to get out vectorized results at time t self.assertEqual(len(vv), len(tsvector)) self.assertAlmostEqual(vv[0], 3.0) self.assertAlmostEqual(vv[1], 3.0) ts_list=[tsa, tsa] vv=api.ts_vector_values_at_time(ts_list, self.ta.time(4)) # also check it work with list(TimeSeries) self.assertEqual(len(vv), len(tsvector)) self.assertAlmostEqual(vv[0], 4.0) self.assertAlmostEqual(vv[1], 4.0)
def test_timeseries_vector(self): c=api.Calendar() t0=api.utctime_now() dt=api.deltahours(1) n=240 ta=api.TimeAxisFixedDeltaT(t0, dt, n) a=api.TimeSeries(ta=ta, fill_value=3.0, point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE) b=api.TimeSeries(ta=ta, fill_value=2.0, point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE) v=api.TsVector() v.append(a) v.append(b) self.assertEqual(len(v), 2) self.assertAlmostEqual(v[0].value(0), 3.0, "expect first ts to be 3.0") aa=api.TimeSeries(ta=a.time_axis, values=a.values, point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE) # copy construct (really copy the values!) a.fill(1.0) self.assertAlmostEqual(v[0].value(0), 1.0, "expect first ts to be 1.0, because the vector keeps a reference ") self.assertAlmostEqual(aa.value(0), 3.0)
from statkraft.ltm.state import quantity from statkraft.ltm.scripting import plot_ts import matplotlib.pyplot as plt rr = RunRepository() t0 = sa.utctime_now() run_id = rr.find_closest_operational_run(t0) run = rr.recreate(run_id=run_id) calendar = sa.Calendar("Europe/Oslo") dt = 3 * calendar.HOUR n = calendar.diff_units(run.time_axis.total_period().start, run.time_axis.total_period().end, dt) time_axis = sa.TimeAxis(run.start_utc, dt, n) norway = run.model.countries['Norway'] tsv = quantity(sa.TsVector(), "EUR") legend_list = [] #val_in_eur = quantity(sa.TsVector(), "EUR") values = None for m_area in norway.aggregation_list: price = m_area.power_price(time_axis=time_axis, unit="EUR/MWh") production = m_area.production(time_axis=time_axis, unit="MWh") val_in_eur = price * production if values is None: values = val_in_eur else: values += val_in_eur
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
from statkraft.ltm.io.run_repository import RunRepository import shyft.api as sa from statkraft.ltm.state import quantity from statkraft.ltm.io.converter import to_pandas rr = RunRepository() t0 = sa.utctime_now() - sa.Calendar.DAY run_id = rr.find_closest_operational_run(t0) run = rr.recreate(run_id=run_id) areas = ["SE1", "SE2", "SE3", "SE4"] energy_inflow = quantity(sa.TsVector(), "GWh") time_axis = sa.TimeAxis(sa.utctime_now(), sa.Calendar.MONTH, 24) years = run.run_info.scenario_years for key in run.model.areas.keys(): area = run.model.areas[key] if area.market_price_area != None and area.market_price_area.name in areas: storable_inflow = area.aggregated_hydro.storable_inflow( unit="GWh", time_axis=time_axis) non_storable_inflow = area.aggregated_hydro.nonstorable_inflow( unit="GWh", time_axis=time_axis) bypass = area.aggregated_hydro.bypass(unit="GWh", time_axis=time_axis) spill = area.aggregated_hydro.spillage(unit="GWh", time_axis=time_axis) energy_inflow += storable_inflow + non_storable_inflow - bypass - spill df, pip = to_pandas(energy_inflow) df = df.magnitude df.columns = years + [df.columns[-1]] df.to_csv("inflow_sweden.csv")
import matplotlib.pyplot as plt import shyft.api as sa from statkraft.ltm.io.run_repository import RunRepository from statkraft.ltm.scripting import plot_ts from statkraft.ltm.state import quantity rr = RunRepository() rid = rr.find_closest_operational_run(sa.utctime_now()) run = rr.recreate(run_id=rid) time_axis = sa.TimeAxis(run.start_utc, sa.Calendar.DAY, 52 * 7) tsv = quantity(sa.TsVector(), "EUR/MWh") legend_list = [] for area_name, area in run.model.areas.items(): legend_list.append(area_name) tsv.extend(area.power_price.mean(time_axis=time_axis).magnitude) plot_ts(tsv) plt.legend(legend_list) plt.show()
from statkraft.ltm.io.run_repository import RunRepository import shyft.api as sa from statkraft.ltm.state import quantity from statkraft.ltm.scripting import plot_ts import matplotlib.pyplot as plt from statkraft.ltm.io.converter import to_pandas rr = RunRepository() t0 = sa.utctime_now() - sa.Calendar.DAY * 2 res = rr.search(labels=["operational", "norway"], created_from=t0) areas = ["NO1", "NO2", "NO5"] tsv = quantity(sa.TsVector(), "GWh") tot_cons_list = [] legend_list = [] for key in res.keys(): run_info = res[key] run = rr.recreate(run_id=key) legend_list.append(key) time_axis = sa.TimeAxis(sa.utctime_now(), sa.Calendar.DAY, 365) tot_cons = quantity(sa.TsVector(), "GWh") for key1 in run.model.market.areas.keys(): this_area = run.model.market.areas[key1] if key1 in areas: cons = this_area.consumption.mean(unit="GWh", time_axis=time_axis) tot_cons += cons tot_cons_list.append(tot_cons) diff_cons = tot_cons_list[0] - tot_cons_list[1] tsv.extend(diff_cons.magnitude)
def test_a_time_series_vector(self): c=api.Calendar() t0=api.utctime_now() dt=api.deltahours(1) n=240 ta=api.TimeAxisFixedDeltaT(t0, dt, n) a=api.TimeSeries(ta=ta, fill_value=3.0, point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE) b=api.TimeSeries(ta=ta, fill_value=2.0, point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE) c=api.TimeSeries(ta=ta, fill_value=10.0, point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE) v=api.TsVector() v.append(a) v.append(b) self.assertEqual(len(v), 2) self.assertAlmostEqual(v[0].value(0), 3.0, "expect first ts to be 3.0") aa=api.TimeSeries(ta=a.time_axis, values=a.values, point_fx=api.point_interpretation_policy.POINT_AVERAGE_VALUE) # copy construct (really copy the values!) a.fill(1.0) self.assertAlmostEqual(v[0].value(0), 1.0, "expect first ts to be 1.0, because the vector keeps a reference ") self.assertAlmostEqual(aa.value(0), 3.0) vt=v.values_at(t0).to_numpy() self.assertEqual(len(vt), len(v)) v1=v[0:1] self.assertEqual(len(v1), 1) self.assertAlmostEqual(v1[0].value(0), 1.0) v_clone=api.TsVector(v) self.assertEqual(len(v_clone), len(v)) del v_clone[-1] self.assertEqual(len(v_clone), 1) self.assertEqual(len(v), 2) v_slice_all=v.slice(api.IntVector()) v_slice_1=v.slice(api.IntVector([1])) v_slice_12=v.slice(api.IntVector([0, 1])) self.assertEqual(len(v_slice_all), 2) self.assertEqual(len(v_slice_1), 1) self.assertAlmostEqual(v_slice_1[0].value(0), 2.0) self.assertEqual(len(v_slice_12), 2) self.assertAlmostEqual(v_slice_12[0].value(0), 1.0) # multiplication by scalar v_x_2a=v*2.0 v_x_2b=2.0*v for i in range(len(v)): self.assertAlmostEqual(v_x_2a[i].value(0), 2*v[i].value(0)) self.assertAlmostEqual(v_x_2b[i].value(0), 2*v[i].value(0)) # division by scalar v_d_a=v/3.0 v_d_b=3.0/v for i in range(len(v)): self.assertAlmostEqual(v_d_a[i].value(0), v[i].value(0)/3.0) self.assertAlmostEqual(v_d_b[i].value(0), 3.0/v[i].value(0)) # addition by scalar v_a_a=v + 3.0 v_a_b=3.0 + v for i in range(len(v)): self.assertAlmostEqual(v_a_a[i].value(0), v[i].value(0) + 3.0) self.assertAlmostEqual(v_a_b[i].value(0), 3.0 + v[i].value(0)) # sub by scalar v_s_a=v - 3.0 v_s_b=3.0 - v for i in range(len(v)): self.assertAlmostEqual(v_s_a[i].value(0), v[i].value(0) - 3.0) self.assertAlmostEqual(v_s_b[i].value(0), 3.0 - v[i].value(0)) # multiplication vector by ts v_x_ts=v*c ts_x_v=c*v for i in range(len(v)): self.assertAlmostEqual(v_x_ts[i].value(0), v[i].value(0)*c.value(0)) self.assertAlmostEqual(ts_x_v[i].value(0), c.value(0)*v[i].value(0)) # division vector by ts v_d_ts=v/c ts_d_v=c/v for i in range(len(v)): self.assertAlmostEqual(v_d_ts[i].value(0), v[i].value(0)/c.value(0)) self.assertAlmostEqual(ts_d_v[i].value(0), c.value(0)/v[i].value(0)) # add vector by ts v_a_ts=v + c ts_a_v=c + v for i in range(len(v)): self.assertAlmostEqual(v_a_ts[i].value(0), v[i].value(0) + c.value(0)) self.assertAlmostEqual(ts_a_v[i].value(0), c.value(0) + v[i].value(0)) # sub vector by ts v_s_ts=v - c ts_s_v=c - v for i in range(len(v)): self.assertAlmostEqual(v_s_ts[i].value(0), v[i].value(0) - c.value(0)) self.assertAlmostEqual(ts_s_v[i].value(0), c.value(0) - v[i].value(0)) # vector mult vector va=v vb=2.0*v v_m_v=va*vb self.assertEqual(len(v_m_v), len(va)) for i in range(len(va)): self.assertAlmostEqual(v_m_v[i].value(0), va[i].value(0)*vb[i].value(0)) # vector div vector v_d_v=va/vb self.assertEqual(len(v_d_v), len(va)) for i in range(len(va)): self.assertAlmostEqual(v_d_v[i].value(0), va[i].value(0)/vb[i].value(0)) # vector add vector v_a_v=va + vb self.assertEqual(len(v_a_v), len(va)) for i in range(len(va)): self.assertAlmostEqual(v_a_v[i].value(0), va[i].value(0) + vb[i].value(0)) # vector sub vector v_s_v=va - vb self.assertEqual(len(v_s_v), len(va)) for i in range(len(va)): self.assertAlmostEqual(v_s_v[i].value(0), va[i].value(0) - vb[i].value(0)) # vector unary minus v_u=- va self.assertEqual(len(v_u), len(va)) for i in range(len(va)): self.assertAlmostEqual(v_u[i].value(0), -va[i].value(0)) # integral functions, just to verify exposure works, and one value is according to spec. ta2=api.TimeAxis(t0, dt*24, n//24) v_avg=v.average(ta2) v_int=v.integral(ta2) v_acc=v.accumulate(ta2) v_sft=v.time_shift(dt*24) self.assertIsNotNone(v_avg) self.assertIsNotNone(v_int) self.assertIsNotNone(v_acc) self.assertIsNotNone(v_sft) self.assertAlmostEqual(v_avg[0].value(0), 1.0) self.assertAlmostEqual(v_int[0].value(0), 86400.0) self.assertAlmostEqual(v_acc[0].value(0), 0.0) self.assertAlmostEqual(v_sft[0].time(0), t0 + dt*24) # min/max functions min_v_double=va.min(-1000.0) max_v_double=va.max(1000.0) self.assertAlmostEqual(min_v_double[0].value(0), -1000.0) self.assertAlmostEqual(max_v_double[0].value(0), +1000.0) min_v_double=api.min(va, -1000.0) max_v_double=api.max(va, +1000.0) self.assertAlmostEqual(min_v_double[0].value(0), -1000.0) self.assertAlmostEqual(max_v_double[0].value(0), +1000.0) # c = 10.0 c1000=100.0*c min_v_double=va.min(-c1000) max_v_double=va.max(c1000) self.assertAlmostEqual(min_v_double[0].value(0), -c1000.value(0)) self.assertAlmostEqual(max_v_double[0].value(0), c1000.value(0)) min_v_double=api.min(va, -c1000) max_v_double=api.max(va, c1000) self.assertAlmostEqual(min_v_double[0].value(0), -c1000.value(0)) self.assertAlmostEqual(max_v_double[0].value(0), c1000.value(0)) v1000=va*1000.0 min_v_double=va.min(-v1000) max_v_double=va.max(v1000) self.assertAlmostEqual(min_v_double[0].value(0), -v1000[0].value(0)) self.assertAlmostEqual(max_v_double[0].value(0), v1000[0].value(0)) min_v_double=api.min(va, -v1000) max_v_double=api.max(va, v1000) self.assertAlmostEqual(min_v_double[0].value(0), -v1000[0].value(0)) self.assertAlmostEqual(max_v_double[0].value(0), v1000[0].value(0)) # finally, test that exception is raised if we try to multiply two unequal sized vectors try: x=v_clone*va self.assertTrue(False, 'We expected exception for unequal sized ts-vector op') except RuntimeError as re: pass # also test that empty vector + vector -> vector etc. va_2=va + api.TsVector() va_3=api.TsVector() + va va_4=va - api.TsVector() va_5=api.TsVector() - va va_x=api.TsVector() + api.TsVector() self.assertEqual(len(va_2), len(va)) self.assertEqual(len(va_3), len(va)) self.assertEqual(len(va_4), len(va)) self.assertEqual(len(va_5), len(va)) self.assertEqual(not va_x, True) self.assertEqual(not va_2, False) va_2_ok=False va_x_ok=True if va_2: va_2_ok=True if va_x: va_x_ok=False self.assertTrue(va_2_ok) self.assertTrue(va_x_ok)
l_reservoirs = {} legend_list = [] for key in run.model.areas.keys(): emps_area = run.model.areas[key] max_volume_as_energy = quantity(0, "GWh") max_tag = None #print(emps_area.name) if not emps_area.detailed_hydro is None: for res_key in emps_area.detailed_hydro.reservoirs.keys(): res = emps_area.detailed_hydro.reservoirs[res_key] res_volume_as_energy = res.max_volume_as_energy if res_volume_as_energy > max_volume_as_energy: max_volume_as_energy = res_volume_as_energy max_tag = res.local_tag if max_tag is not None: max_res = emps_area.detailed_hydro.reservoirs[max_tag] l_reservoirs[key] = max_res else: print("hæh?") tsv = quantity(sa.TsVector(), "GWh") #print(l_reservoirs) for key in l_reservoirs.keys(): obj_res = l_reservoirs[key] legend_list.append(obj_res.name) obj_res_mean_volume = obj_res.energy.mean(time_axis=time_axis, unit="GWh") tsv.extend(obj_res_mean_volume.magnitude) plot_ts(tsv) plt.legend(legend_list) plt.show(block=True)
l_reservoirs = {} legend_list = [] for key in run.model.areas.keys(): emps_area = run.model.areas[key] max_volume = 0 max_tag = None if not emps_area.detailed_hydro is None: for res_key in emps_area.detailed_hydro.reservoirs.keys(): res = emps_area.detailed_hydro.reservoirs[res_key] res_volume = res.max_volume.magnitude if res_volume > max_volume: max_volume = res_volume max_tag = res.local_tag if max_tag is not None: max_res = emps_area.detailed_hydro.reservoirs[max_tag] l_reservoirs[key] = max_res else: print("hæh?") tsv = quantity(sa.TsVector(), "m**3") print(l_reservoirs) for key in l_reservoirs.keys(): obj_res = l_reservoirs[key] legend_list.append(obj_res.name) obj_res_mean_volume = obj_res.volume.mean(time_axis=time_axis, unit="m**3") tsv.extend(obj_res_mean_volume.magnitude) plot_ts(tsv) plt.legend(legend_list) plt.show(block=True)