def test_AverageAccessor(self): dv=np.arange(self.ta.size()) v=api.DoubleVector.FromNdArray(dv) t=api.UtcTimeVector(); for i in xrange(self.ta.size()): t.push_back(self.ta(i).start) t.push_back(self.ta(self.ta.size()-1).end) #important! needs n+1 points to determine n periods in the timeaxis 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) tax=api.Timeaxis(self.ta.start()+api.deltaminutes(30),api.deltahours(1),self.ta.size()) avg1=api.AverageAccessorTs(ts1,tax) self.assertEquals(avg1.size(),tax.size())
def test_extract_conversion_factors_from_string(self): u = utime('hours since 1970-01-01 00:00:00') t_origin = api.Calendar(u.tzoffset).time( api.YMDhms(u.origin.year, u.origin.month, u.origin.day, u.origin.hour, u.origin.minute, u.origin.second)) delta_t_dic = { 'days': api.deltahours(24), 'hours': api.deltahours(1), 'minutes': api.deltaminutes(1) } delta_t = delta_t_dic[u.units] self.assertIsNotNone(u) self.assertEqual(delta_t, api.deltahours(1)) self.assertEqual(t_origin, 0)
def test_average_accessor(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) # important! needs n+1 points to determine n periods in the timeaxis 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) tax = api.Timeaxis(self.ta.total_period().start + api.deltaminutes(30), api.deltahours(1), self.ta.size()) avg1 = api.AverageAccessorTs(ts1, tax) self.assertEqual(avg1.size(), tax.size()) self.assertIsNotNone(ts2)
def test_ts_transform(self): dv=np.arange(self.ta.size()) v=api.DoubleVector.FromNdArray(dv) t=api.UtcTimeVector(); for i in xrange(self.ta.size()): t.push_back(self.ta(i).start) #t.push_back(self.ta(self.ta.size()-1).end) #important! needs n+1 points to determine n periods in the timeaxis tax=api.Timeaxis(self.ta.start()+api.deltaminutes(30),api.deltahours(1),self.ta.size()) 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) ts3=api.TsFixed(tax,v) tst=api.TsTransform() tt1=tst.to_average(tax.start(),tax.delta(),tax.size(),ts1) tt2=tst.to_average(tax.start(),tax.delta(),tax.size(),ts2) tt3=tst.to_average(tax.start(),tax.delta(),tax.size(),ts3) self.assertEqual(tt1.size(),tax.size()) self.assertEqual(tt2.size(),tax.size()) self.assertEqual(tt3.size(),tax.size())
def test_ts_transform(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) #important! needs n+1 points to determine n periods in the timeaxis t_start=self.ta.total_period().start dt=api.deltahours(1) tax=api.TimeAxisFixedDeltaT(t_start + api.deltaminutes(30), dt, self.ta.size()) 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) ts3=api.TsFixed(tax, v, api.POINT_INSTANT_VALUE) tst=api.TsTransform() tt1=tst.to_average(t_start, dt, tax.size(), ts1) tt2=tst.to_average(t_start, dt, tax.size(), ts2) tt3=tst.to_average(t_start, dt, tax.size(), ts3) self.assertEqual(tt1.size(), tax.size()) self.assertEqual(tt2.size(), tax.size()) self.assertEqual(tt3.size(), tax.size())
def test_rating_curve_ts(self): t0=api.utctime_now() ta=api.TimeAxis(t0, api.deltaminutes(30), 48*2) data=np.linspace(0, 10, ta.size()) ts=api.TimeSeries(ta, data, api.POINT_INSTANT_VALUE) rcf1=api.RatingCurveFunction() rcf1.add_segment(0, 1, 0, 1) rcf1.add_segment(api.RatingCurveSegment(5, 2, 0, 1)) rcf2=api.RatingCurveFunction() rcf2.add_segment(0, 3, 0, 1) rcf2.add_segment(api.RatingCurveSegment(8, 4, 0, 1)) rcp=api.RatingCurveParameters() rcp.add_curve(t0, rcf1) rcp.add_curve(t0 + api.deltahours(24), rcf2) sts=api.TimeSeries("a") rcsts=sts.rating_curve(rcp) rcsts_blob=rcsts.serialize() rcsts_2=api.TimeSeries.deserialize(rcsts_blob) self.assertTrue(rcsts_2.needs_bind()) fbi=rcsts_2.find_ts_bind_info() self.assertEqual(len(fbi), 1) fbi[0].ts.bind(ts) rcsts_2.bind_done() self.assertFalse(rcsts_2.needs_bind()) self.assertEqual(len(rcsts_2), len(ts)) for i in range(rcsts_2.size()): expected=(1*ts.get(i).v if ts.get(i).v < 5 else 2*ts.get(i).v) if ts.get(i).t < t0 + api.deltahours(24) else ( 3*ts.get(i).v if ts.get(i).v < 8 else 4*ts.get(i).v) self.assertEqual(rcsts_2.get(i).t, ts.get(i).t) self.assertEqual(rcsts_2.get(i).v, expected)
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
from shyft import api from netcdftime import utime import numpy as np """ These are the current supported regular time-step intervals """ delta_t_dic = {'days': api.deltahours(24), 'hours': api.deltahours(1), 'minutes': api.deltaminutes(1), 'seconds': api.Calendar.SECOND} def convert_netcdf_time(time_spec, t): """ Converts supplied numpy array to shyft utctime given netcdf time_spec. Throws exception if time-unit is not supported, i.e. not part of delta_t_dic as specified in this file. Parameters ---------- time_spec: string from netcdef like 'hours since 1970-01-01 00:00:00' t: numpy array Returns ------- numpy array type int64 with new shyft utctime units (seconds since 1970utc) """ u = utime(time_spec) t_origin = api.Calendar(int(u.tzoffset)).time( api.YMDhms(u.origin.year, u.origin.month, u.origin.day, u.origin.hour, u.origin.minute, u.origin.second)) delta_t = delta_t_dic[u.units] return (t_origin + delta_t * t[:]).astype(np.int64)
# This file is part of Shyft. Copyright 2015-2018 SiH, JFB, OS, YAS, Statkraft AS # See file COPYING for more details **/ from shyft import api from netcdftime import utime import numpy as np """ These are the current supported regular time-step intervals """ delta_t_dic = {'days': api.deltahours(24), 'hours': api.deltahours(1), 'minutes': api.deltaminutes(1), 'seconds': api.Calendar.SECOND} def convert_netcdf_time(time_spec, t): """ Converts supplied numpy array to shyft utctime given netcdf time_spec. Throws exception if time-unit is not supported, i.e. not part of delta_t_dic as specified in this file. Parameters ---------- time_spec: string from netcdef like 'hours since 1970-01-01 00:00:00' t: numpy array Returns ------- numpy array type int64 with new shyft utctime units (seconds since 1970utc) """ u = utime(time_spec) t_origin = api.Calendar(int(u.tzoffset)).time( api.YMDhms(u.origin.year, u.origin.month, u.origin.day, u.origin.hour, u.origin.minute, u.origin.second)) #print (t[0],t_origin,delta_t_dic[u.units]) delta_t = delta_t_dic[u.units]
def test_extract_conversion_factors_from_string(self): u = utime('hours since 1970-01-01 00:00:00') t_origin = api.Calendar(u.tzoffset).time( api.YMDhms(u.origin.year, u.origin.month, u.origin.day, u.origin.hour, u.origin.minute, u.origin.second)) delta_t_dic = {'days': api.deltahours(24), 'hours': api.deltahours(1), 'minutes': api.deltaminutes(1)} delta_t = delta_t_dic[u.units] self.assertIsNotNone(u) self.assertEqual(delta_t, api.deltahours(1)) self.assertEqual(t_origin, 0)
from shyft import api from netcdftime import utime import numpy as np """ These are the current supported regular time-step intervals """ delta_t_dic = { 'days': api.deltahours(24), 'hours': api.deltahours(1), 'minutes': api.deltaminutes(1), 'seconds': api.Calendar.SECOND } def convert_netcdf_time(time_spec, t): """ Converts supplied numpy array to shyft utctime given netcdf time_spec. Throws exception if time-unit is not supported, i.e. not part of delta_t_dic as specified in this file. Parameters ---------- time_spec: string from netcdef like 'hours since 1970-01-01 00:00:00' t: numpy array Returns ------- numpy array type int64 with new shyft utctime units (seconds since 1970utc) """ u = utime(time_spec) t_origin = api.Calendar(int(u.tzoffset)).time( api.YMDhms(u.origin.year, u.origin.month, u.origin.day, u.origin.hour, u.origin.minute, u.origin.second))