def __init__(self, **kwargs): """ kwargs ={'baisnName':'Mackenzie', 'start_date':'2000-06-01', 'end_date':'2010-06-31', 'info_fl':r'C:\00_Work\02_Sim\00_Mackenzie\01_Data\01_Selected_RiverDischarge\RiverGages_description.csv', 'pthIn':r'C:\00_Work\02_Sim\00_Mackenzie\01_Data\01_Selected_RiverDischarge'} """ for key in kwargs: setattr(self, key, kwargs[key]) self._load_rivergages() self._idate = ts.Date('D', self.start_date) self._idateHStr = self._idate.strfmt('%Y/%m/%d') + ' 00:00' self._fdate = ts.Date('D', self.end_date) self._dates = ts.date_array(start_date=self._idate, end_date=self._fdate, freq='d') self.nr_days = self._fdate - self._idate + 1 self._get_matrix()
def Write_MESH_tsi(self, start_date, end_date, pthOut, nodata=0.0): self._idate = ts.Date(self.data.freq, start_date) self._fdate = ts.Date(self.data.freq, end_date) data = self.data['Flow'] indx = data.date_to_index(self._idate) fndx = data.date_to_index(self._fdate) data = data[indx:fndx + 1] salida = open(pthOut + '\\MESH_input_streamflow.txt', 'w') salida.write('%s\n' % ('Only one river gage')) salida.write('%5d %5d %5d %5d %5d %5d %5s \n' % (1, data.size, data.size, self._nhours, self._idate.year, self._idate.day_of_year, ' 00 ')) salida.write( '%5d %5d %5s \n' % (int(round(self._latMIN)), int(round(self._lonMIN)), self.idGage)) for i in xrange(data.size): if data[i]: val = data[i] else: val = nodata salida.write('%10.3f\n' % (val)) salida.close()
def test_load_usgs_flows(self): "Test loadind USGS water data." # F02217900 = load_usgs_flows('02217900') data_192810 = [180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 230, 300, 350, 300, 230, 200, 250, 270, 240, 200, 180, 180, 180, 180, 180] data_194912 = [276, 267, 267, 267, 262, 264, 269, 302, 291, 279, 310, 307, 304, 358, 425, 425, 371, 336, 336, 371, 336, 333, 336, 333, 317, 336, 410, 425, 384, 336, 330] assert(isinstance(F02217900, ts.TimeSeries)) assert_equal(F02217900.start_date, ts.Date('D', '1928-10-01')) assert_equal(F02217900.end_date, ts.Date('D', '1949-12-31')) dates = F02217900.dates assert_equal(F02217900[(dates.year == 1928) & (dates.month == 10)], data_192810) assert_equal(F02217900[(dates.year == 1949) & (dates.month == 12)], data_194912) # F02217500 = load_usgs_flows('02217500') data_190110 = [ 570, 1000, 1200, 900, 650, 580, 540, 520, 510, 530, 499, 535, 535, 572, 535, 535, 499, 499, 499, 499, 499, 499, 499, 499, 499, 499, 464, 499, 499, 499, 499] assert(isinstance(F02217500, ts.TimeSeries)) assert_equal(F02217500.start_date, ts.Date('D', '1901-10-01')) dates = F02217500.dates assert_equal(F02217500[(dates.year == 1901) & (dates.month == 10)], data_190110)
def setUp(self): series = ReferencedSeries(np.random.rand(360), start_date=ts.Date('M', '1970-01-01')) series[1:-1:10] = masked refperiod = ts.DateArray( [ts.Date('M', '1980-01-01'), ts.Date('M', '1990-01-01')], freq='M') self.series = series self.refperiod = refperiod
def test_get_refperiod(self): "Check that the reference period has always the proper frequency" a = ReferencedSeries(np.arange(2000, 2010), start_date=ts.Date('Y', '2000'), refperiod=(ts.Date('Y', '2003'), ts.Date('A', '2006'))) assert (isinstance(a.refperiod, ts.DateArray)) assert_equal(a.refperiod.freq, a.dates.freq) a = a.convert('M') assert_equal(a.refperiod.freq, a.dates.freq)
def _idx_from_dates(d1, d2, freq): """ Returns an index offset from datetimes d1 and d2. d1 is expected to be the last date in a date series and d2 is the out of sample date. Note that it rounds down the index if the date is before the next date at freq. """ d1 = ts.Date(freq, datetime=d1) d2 = ts.Date(freq, datetime=d2) return d2 - d1
def testPysDate(self): print "testPysDate" cusum = list(csv.reader(open("cusumpys.csv", "r"))) outof = len(self.pyssuite) for n, case in enumerate(self.pyssuite): print n+1, '/', outof case.train() progdate = case.cusum.dates.tolist() print progdate[0] print ts.Date('M', '1999-1') if progdate[0] != ts.Date('M', '1999-1'): raise AssertionError
def setUp(self): self.pdssuite = [] self.pyssuite = [] self.pdscross = {0:ts.Date('M', '2002-11'), 1:ts.Date('M', '2002-2'), 2:ts.Date('M', '2001-12')} self.pyscross = {0:ts.Date('M', '1999-10')} data = np.matrix(list(csv.reader(open("test.csv", "r")))) data = cs.dataFormat(data) self.pdssuite.append(cs.Cusum(data[0], 4, fcn = "pds", para = (1,"twoside", 36))) self.pdssuite.append(cs.Cusum(data[1], 4, fcn = "pds", para = (1,"upper", 36))) self.pdssuite.append(cs.Cusum(data[2], 4, fcn = "pds", para = (1,"lower", 36))) self.pyssuite.append(cs.Cusum(data[3], 4, fcn = "pys", para = (7.5, 0.5, 0., 0.9, 1.0)))
def _collect_and_plot(files): TS = [] location = [] for f in files: temperatures = [ section[1] for section in parse.parse_file(f)[1:-1] if section[1]['Plant'] == ['tmp'] ] for t in temperatures: if t['Step'][0] != '0000-00-00.01:00:00': print 'Not hourly readings of temperature. Abort.' break dates = ts.date_array(start_date=ts.Date('H', t['Start'][0]), length=len(t['Value'])) data = [ float(value.rsplit('/')[0]) for value in t['Value'] ] TS.append(ts.TimeSeries(data=data, dates=dates)) if location and t['Installation'][0] != location: print 'Location changed during reading of gs2 files. Probably some bad grouping of gs2 files.' location = t['Installation'][0] if TS: path = '/Users/tidemann/Documents/NTNU/devel/data/eklima/Telemark/' for file in os.listdir(path): try: series = xml.parse(path + file) sg.utils.plot_time_series([ts.concatenate((TS)), series], ['b-','r-'], [location, file]) except: print file, 'had no data.' else: print 'No temperature data.'
def setUp(self): "Setting common information" try: from BeautifulSoup import BeautifulSoup, SoupStrainer except ImportError: self.indices = None return # Load the file as a tree, but only take the SST table (border=1) from urllib import urlopen url = "http://www.cpc.noaa.gov/products/analysis_monitoring/"\ "ensostuff/ensoyears.shtml" url = urlopen(url) table = BeautifulSoup(url.read(), parseOnlyThese=SoupStrainer("table", border=1)) # Separate it by rows, but skip the first one (the header) years = [] indices = [] color = dict(red=+1, white=0, blue=-1) deft = [(None, 'color:white')] for row in table.findAll("tr")[1:]: cols = row.findAll('td') years.append(int(cols.pop(0).strong.string)) indices.append([ color[getattr(_.span, 'attrs', deft)[0][-1].split(':')[-1]] for _ in cols ]) start_date = ts.Date('M', year=years[0], month=1) self.indices = time_series(np.array(indices).ravel(), start_date=start_date)
def test_sorted(self): dates = [ts.Date('D', string='2007-01-%02i' % i) for i in (3, 2, 1)] (a, b) = zip(*[ (3., 30), (2., 20), (1., 10), ]) ndtype = [('a', np.float), ('b', np.int)] controldates = date_array(dates, freq='D') controldates.sort_chronologically() series = time_series(zip(*(a, b)), dates, freq='D', dtype=ndtype) assert_equal(series._data.tolist(), [(1., 10), (2., 20), (3., 30)]) assert_equal(series._dates, controldates) # trec = time_records(zip(*(a, b)), dates, freq='D', dtype=ndtype) assert_equal(trec._data.tolist(), [(1., 10), (2., 20), (3., 30)]) assert_equal(trec._dates, controldates) assert_equal(trec['a'], [1., 2., 3.]) assert_equal(trec.a, [1., 2., 3.]) # trec = fromrecords(zip(a, b), dates, names=('a', 'b')) assert_equal(trec._data.tolist(), [(1., 10), (2., 20), (3., 30)]) assert_equal(trec._dates, controldates) assert_equal(trec['a'], [1., 2., 3.]) assert_equal(trec.a, [1., 2., 3.]) # trec = fromarrays([a, b], dates, names=('a', 'b')) assert_equal(trec._data.tolist(), [(1., 10), (2., 20), (3., 30)]) assert_equal(trec._dates, controldates) assert_equal(trec['a'], [1., 2., 3.]) assert_equal(trec.a, [1., 2., 3.])
def setUp(self): "Initializes" data = [ -0.49, -0.38, -0.26, 0.54, 0.95, 0.60, 0.93, 0.80, 0.52, 0.15, -0.50, -0.58, -0.58, -0.70, -0.54, -0.80, -0.75, 0.33, -0.18, -0.55, -0.77, -0.73, -0.58, -0.68, -0.62, 0.75, 0.72, 0.50, 0.84, 0.64, 0.77, -0.03, 0.71, 0.17, 0.64, -0.12, -0.17, 0.34, 0.57, -0.57, -0.77, -0.56, -0.51, -0.80, 0.19, -0.83, 0.53, 0.72, 0.77, 0.64, 0.57, 0.51, 0.51, 0.67, 0.70, 0.40, 0.29, 0.23, 0.13, 0.00 ] refperiod = ts.DateArray( [ts.Date('M', '1980-01-01'), ts.Date('M', '1990-01-01')], freq='M') ensoi = ENSOIndicator(data, start_date=ts.Date('M', '1980-01-01')) ensoi.thresholds = (-0.5, 0.5) self.ensoi = ensoi
def test_force_reference(self): mseries = ts.time_series(np.arange(24), start_date=ts.Date('M', '2001-01')) aseries = ts.time_series([1, 2, 3], start_date=ts.Date('A', '2001-01')) # mtest = force_reference(aseries, mseries) assert_equal(mtest.freq, ts.check_freq('M')) assert_equal(mtest.dates[[0, -1]], mseries.dates[[0, -1]]) assert_equal(mtest, [1] * 12 + [2] * 12) mtest = force_reference(aseries, mseries, ma.sum) assert_equal(mtest, [1] * 12 + [2] * 12) # atest = force_reference(mseries, aseries) assert_equal(atest.freq, ts.check_freq('A')) assert_equal(atest.dates[[0, -1]], aseries.dates[[0, -1]]) assert_equal(atest, ma.array([5.5, 17.5, 0], mask=[0, 0, 1])) atest = force_reference(mseries, aseries, ma.sum) assert_equal(atest, ma.array([66, 210, 0], mask=[0, 0, 1]))
def _date_from_idx(d1, idx, freq): """ Returns the date from an index beyond the end of a date series. d1 is the datetime of the last date in the series. idx is the index distance of how far the next date should be from d1. Ie., 1 gives the next date from d1 at freq. """ tsd1 = ts.Date(freq, datetime=d1) tsd2 = datetime.datetime.fromordinal((tsd1 + idx).toordinal()) return tsd2
def test_mov_average_expw_mask(self): "Make sure that mov_average_expw doesn't modify the initial mask" N = 256 series = ts.time_series(np.random.rand(N), start_date=ts.Date('D', '2008-01-01')) series[96:128] = ma.masked controlmask = np.zeros(N, dtype=bool) controlmask[96:128] = True # test = mf.mov_average_expw(series, 16) assert_not_equal(test.mask, series.mask) assert_equal(series.mask, controlmask)
def test_check_refperiod(self): "Test that the reference period is always a DateArray" series = ReferencedSeries(np.arange(10), start_date=ts.Date('M', '2001-01')) refperiod = series._optinfo['reference_period'] self.failUnless(refperiod is None) series.refperiod = None refperiod = series._optinfo['reference_period'] self.failUnless(isinstance(refperiod, ts.DateArray)) assert_equal(refperiod.tovalues(), series.dates[[0, -1]].tovalues()) series.refperiod = None assert_equal(refperiod, series.dates[[0, -1]]) self.failUnless(isinstance(refperiod, ts.DateArray))
def formatScikitsTS(self, content): """Format a given date in a user friendly way. The textual representation of the date index is converted to a Date instance that can be easily formatted. :Parameter content: the content of the table cell being formatted """ date = ts.Date(self.ts_freq, value=int(content)) try: return date.datetime.strftime(self.ts_format) except ValueError: return content
def test_ensoindices_from_daily_indicator(self): "Try setting ensoindices from a daily indicator" ensoi = self.ensoi ensoi.set_monthly_indices(minimum_size=5, reference_season='NDJ') # bseries = climate_series(range(24), start_date=ts.Date('M', '1982-01'), ensoindicator=ensoi) control_indices = [ -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 ] control_indices = ts.time_series(control_indices, start_date=bseries.dates[0]) # Basic check assert_equal(bseries.ensoindices, control_indices) # Define daily series dseries = climate_series(range(730), start_date=ts.Date('D', '1982-01-01'), ensoindicator=ensoi) mseries = climate_series(range(24), start_date=ts.Date('M', '1982-01'), ensoindicator=dseries.ensoindicator) assert_equal(mseries.ensoindices, bseries.ensoindices)
def test_set_ensoindices(self): "Test setting indices" ONI = load_oni('standard') mseries = climate_series(np.random.rand(120), start_date=ts.Date('M', '1991-01'), ensoindicator=ONI) control = ONI['1991-01':'2001-01'] assert_equal(mseries.ensoindices, control.indices) test = mseries.set_ensoindices(full_year=True).copy() self.failUnless(mseries.ensoindicator.optinfo['full_year']) assert_equal(test, control.set_indices(full_year=True)) self.failUnless(control.optinfo['full_year']) assert_equal(test, mseries.ensoindices) assert_equal(mseries.set_ensoindices(lag=6), test.tshift(-6)) # mseries.set_ensoindices(full_year=True, lag=0) series = ts.lib.backward_fill(mseries.convert('D')) series_m = series.convert('M', ma.mean) assert_equal(test, series_m.ensoindices)
def test_ensoindices_on_irregular_series(self): "Try setting ensoindices on a non-regular series" ensoi = self.ensoi ensoi.set_monthly_indices(minimum_size=5, reference_season='NDJ') # bseries = climate_series(range(24), start_date=ts.Date('M', '1982-01'), ensoindicator=ensoi) control_indices = [ -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 ] control_indices = ts.time_series(control_indices, start_date=bseries.dates[0]) tseries = bseries[::2] assert_equal(tseries.ensoindices, control_indices[::2]) mseries = climate_series(tseries, ensoindicator=bseries.ensoindicator) assert_equal(mseries.ensoindices, bseries.ensoindices[::2]) mseries = climate_series(tseries, ensoindicator=bseries.ensoindicator)
# try: # import scikits.talkbox as tb # except: # raise ImportError("You need scikits.talkbox installed for timings") # t = timer() # mod_tb = tb.lpc(y, 2) # t_end = timer() # print str(t_end - t) + " seconds for talkbox.lpc" # print """For higher lag lengths ours quickly fills up memory and starts #thrashing the swap. Should we include talkbox C code or Cythonize the #Levinson recursion algorithm?""" ## Try with a pandas series import pandas import scikits.timeseries as ts d1 = ts.Date(year=1700, freq='A') #NOTE: have to have yearBegin offset for annual data until parser rewrite #should this be up to the user, or should it be done in TSM init? #NOTE: not anymore, it's end of year now ts_dr = ts.date_array(start_date=d1, length=len(sunspots.endog)) pandas_dr = pandas.DateRange(start=d1.datetime, periods=len(sunspots.endog), timeRule='A@DEC') #pandas_dr = pandas_dr.shift(-1, pandas.datetools.yearBegin) dates = np.arange(1700, 1700 + len(sunspots.endog)) dates = ts.date_array(dates, freq='A') #sunspots = pandas.Series(sunspots.endog, index=dates) #NOTE: pandas only does business days for dates it looks like import datetime dt_dates = np.asarray(lmap(datetime.datetime.fromordinal,
# Author: Vicent Mas - [email protected] """Storing time series created with scikits.timeseries module in PyTables. Example 1. """ import os import numpy as np import scikits.timeseries as ts import scikits.timeseries.lib.tstables as tstab import scikits.timeseries.lib.reportlib as rl ## a test series data = np.arange(1, 366) startdate = ts.Date(freq='D', year=2009, month=1, day=1) test_series = ts.time_series(data, start_date=startdate, freq='D') output_dir = '../timeseries' try: os.mkdir(output_dir) except OSError: pass ## write to csv file csv_file = os.path.abspath(os.path.join(output_dir, 'test_series.csv')) mycsv = open(csv_file, 'w') csvReport = rl.Report(test_series, delim=';', fixed_width=True) csvReport(output=mycsv) mycsv.close()
import scikits.timeseries as ts import numpy as np import numpy.ma as ma import csv import scikits.timeseries.lib.reportlib as rl import scipy.stats.mstats as stats data = np.matrix(list(csv.reader(open("spmstar.csv", "r")))) date = data[0, 1:] desc = data[1:, 0] data = np.array(data[1:, 1:]) first_date = ts.Date('M', '1999-01') desc = list(map(lambda x: x[0, 0], desc)) format = [float] * len(desc) format = zip(desc, format) #print format serieses = [ ts.time_series(i, start_date=first_date, dtype=float, fill_value=-99) for i in data ] serieses = [ i[i > -999] for i in [ma.masked_values(series, -999) for series in serieses] if len(i) > 48 ] print len(serieses) s = serieses[1] # for series in serieses: # try:
""" Look at some macro plots, then do some VARs and IRFs. """ import numpy as np import statsmodels.api as sm import scikits.timeseries as ts import scikits.timeseries.lib.plotlib as tplt data = sm.datasets.macrodata.load(as_pandas=False) data = data.data ### Create Timeseries Representations of a few vars dates = ts.date_array(start_date=ts.Date('Q', year=1959, quarter=1), end_date=ts.Date('Q', year=2009, quarter=3)) ts_data = data[['realgdp', 'realcons', 'cpi']].view(float).reshape(-1, 3) ts_data = np.column_stack((ts_data, (1 - data['unemp'] / 100) * data['pop'])) ts_series = ts.time_series(ts_data, dates) fig = tplt.tsfigure() fsp = fig.add_tsplot(221) fsp.tsplot(ts_series[:, 0], '-') fsp.set_title("Real GDP") fsp = fig.add_tsplot(222) fsp.tsplot(ts_series[:, 1], 'r-') fsp.set_title("Real Consumption") fsp = fig.add_tsplot(223) fsp.tsplot(ts_series[:, 2], 'g-') fsp.set_title("CPI")
def load_usgs_flows(site_no, cfgdict=usgs_config): """ Downloads hydrological data from the USGS site. Parameters ---------- site_no : str 2- to 15-digit identification number of the site whose information must be downloaded. netfile : {string}, optional URL of the USGS flow gage site. By default, the value is read from the configuration file. begin_date : {string}, optional First date to be retrieved. By default, the value is read from the configuration file. end_date : {None, string}, optional Last date to be retrieved. If None, uses the current date. datadir : {None, string}, optional Directory where to store the output. If None, uses the current directory. commentchar : {string}, optional Character corresponding to a comment. headerlines : {int}, optional Number of uncommented lines to skip from the beginning of the file. archive : {None, string}, optional Name of the ZIP archive where to read pre-stored data or when to store data newly retrieved. The default is read from the configuration file. Notes ----- The list of data codes valid for the ``data_type`` parameters are available on the `USGS site <http://waterdata.usgs.gov/nwis/pmcodes/pmcodes?pm_group=All+--+include+all+parameter+groups&pm_search=&format=html_table&show=parameter_group_nm&show=parameter_nm>`_ """ # Force the site_no to a 0-padded, 8-character string site_no = "%08i" % int(site_no) #data_type = cfgdict.get('data_type', '00060') data_type = '00060' data_letter = data_dict[data_type] usgsarchv = _check_archive(cfgdict) archfname = "%s%sD" % (data_letter, site_no) # try: zipf = zipfile.ZipFile(usgsarchv, 'r') series = cPickle.loads(zipf.read(archfname)) except IOError: zipf = zipfile.ZipFile(usgsarchv, 'w') except KeyError: zipf = zipfile.ZipFile(usgsarchv, 'a') else: if series.size > 0: return series else: zipf = zipfile.ZipFile(usgsarchv, 'a') # options = dict(usgs_site=cfgdict['netfile'], begin_date=cfgdict['begin_date'], data_type=data_type, site_no=site_no) end_date = cfgdict.get('end_date', None) if end_date is None: end_date = ts.now('D').strftime("%Y-%m-%d") options['end_date'] = end_date commd = "%(usgs_site)s/dv?format=rdb&cb_%(data_type)s=on&" + \ "begin_date=%(begin_date)s&end_date=%(end_date)s&" + \ "site_no=%(site_no)s" datadir = cfgdict.get('datadir', os.getcwd()) # We can't use np.lib._datasource.DataSource, the downloaded file has always # the same name and would be cached. sourcedir = np.lib._datasource.DataSource(datadir) dfile = urllib.urlopen(commd % options) # headers = int(cfgdict['headerlines']) # (datelist, datalist) = ([], []) for line in dfile.readlines(): line = line.strip().split("\t") if (not line) or (line[0][0] == '#'): continue try: datalist.append(line[3]) except IndexError: continue else: datelist.append(line[2]) series = ts.time_series( [float(_) for _ in datalist[headers:]], dates=[ts.Date('D', _) for _ in datelist[headers:]], freq='D') # zipf.writestr(archfname, cPickle.dumps(series)) zipf.close() return series
# Author: Vicent Mas - [email protected] """Storing time series created with scikits.timeseries module in PyTables. Example 3. """ import os import numpy as np import scikits.timeseries as ts import scikits.timeseries.lib.tstables as tstab # Generate random data data = np.cumprod(1 + np.random.normal(0, 1, 300)/100) series = ts.time_series(data, start_date=ts.Date(freq='M', year=1982, month=1)) # Write to a PyTables file output_dir = '../timeseries' try: os.mkdir(output_dir) except OSError: pass hdf5_name = 'scikits_test3.hdf5' filepath_hdf5 = os.path.join(output_dir, hdf5_name) h5file = tstab.open_file(filepath_hdf5, mode="w", title='Example table with csikits time series') group_doc = h5file.create_group("/", 'examples', 'Test Data') table = h5file.createTimeSeriesTable(group_doc, 'Example_3', series) h5file.close()
import numpy as np import numpy.ma as ma import matplotlib.pyplot as plt import scikits.timeseries as ts import scikits.timeseries.lib.plotlib as tpl # generate some random data data1 = np.cumprod(1 + np.random.normal(0, 1, 300)/100) data2 = np.cumprod(1 + np.random.normal(0, 1, 300)/100)*100 start_date = ts.Date(freq='M', year=1982, month=1) series1 = ts.time_series(data1, start_date=start_date-50) series2 = ts.time_series(data2, start_date=start_date) fig = tpl.tsfigure() fsp = fig.add_tsplot(111) # plot series on left axis fsp.tsplot(series1, 'b-', label='<- left series') fsp.set_ylim(ma.min(series1.series), ma.max(series1.series)) # create right axis fsp_right = fsp.add_yaxis(position='right', yscale='log') # plot series on right axis fsp_right.tsplot(series2, 'r-', label='-> right series') fsp_right.set_ylim(ma.min(series2.series), ma.max(series2.series)) # setup legend fsp.legend( (fsp.lines[-1], fsp_right.lines[-1]), (fsp.lines[-1].get_label(), fsp_right.lines[-1].get_label()), ) plt.show()
def get_date(datestr, fmt='%Y%m%d', ts_freq=None): datestr = datestr.replace('-', '') if ts_freq != None: return ts.Date(ts_freq, datestr) #e.g., 'B' else: return datetime.strptime(datestr, '%Y%m%d')
def gw_model_file(in_fname, out_fname, figure_dir=None): """" input: in_fname: name of input xls file out_fname: name of the output xls file figure_dir: name of the directory where to save the out figures """ # read the data from xls file in_book = xlrd.open_workbook(in_fname) sheet_names = in_book.sheet_names() sheet_names.remove('legend') out_book = xlwt.Workbook() for sheet_name in sheet_names: sheet = in_book.sheet_by_name(sheet_name) # read the input for one well t = sheet.nrows - 1 year = np.empty(t, 'int') month = np.empty(t, 'int') rainfall = np.empty(t) pumping = np.empty(t) meas_gwl = np.empty(t) r = np.empty(t) for i in range(t): year[i] = sheet.cell_value(i + 1, 0) month[i] = sheet.cell_value(i + 1, 1) rainfall[i] = sheet.cell_value(i + 1, 2) pumping[i] = sheet.cell_value(i + 1, 3) meas_gwl[i] = sheet.cell_value(i + 1, 4) r[i] = sheet.cell_value(i + 1, 5) F = sheet.cell_value(1, 6) G = sheet.cell_value(1, 7) hmin = sheet.cell_value(1, 8) # run the model gw_model = GW_1D(rainfall, pumping) gw_model.set_parameters(F, G, r, hmin) hini = meas_gwl[0] gw_model.run_model(hini, t) sim_gwl = gw_model.h lam = gw_model.lam sy = gw_model.sy discharge = gw_model.discharge print('Sy = %.5f' % sy) #write the output sheet = out_book.add_sheet(sheet_name) sheet.write(0, 0, 'year') sheet.write(0, 1, 'month') sheet.write(0, 2, 'rainfall') sheet.write(0, 3, 'pumping') sheet.write(0, 4, 'measured gwl') sheet.write(0, 5, 'simulated gwl') sheet.write(0, 6, 'recharge') sheet.write(0, 7, 'discharge') sheet.write(0, 8, 'lambda') sheet.write(0, 9, 'sy') for i in range(t): sheet.write(i + 1, 0, year[i]) sheet.write(i + 1, 1, month[i]) sheet.write(i + 1, 2, rainfall[i]) sheet.write(i + 1, 3, pumping[i]) sheet.write(i + 1, 4, meas_gwl[i]) sheet.write(i + 1, 5, sim_gwl[i]) sheet.write(i + 1, 6, rainfall[i] * r[i]) sheet.write(i + 1, 7, discharge[i]) sheet.write(1, 8, lam) sheet.write(1, 9, sy) first_date = ts.Date(freq='M', year=year[0], month=month[1]) gw_meas_series = ts.time_series(meas_gwl, start_date=first_date) gw_sim_series = ts.time_series(sim_gwl, start_date=first_date) if figure_dir is not None: # save the figure fig = plt.figure(figsize=(6, 4.5)) plt.plot(gw_meas_series, 'r', lw=3, label='measured') plt.plot(gw_sim_series, 'g', lw=3, label='simulated') plt.legend(loc='best') plt.ylabel('Groundwater Level') plt.savefig(figure_dir + '%s.png' % sheet_name) plt.close() print('%s completed succesfully' % sheet_name) # save the xls file out_book.save(out_fname)
def load_coaps_stationdata(station, cfgdict=coaps_config): """ Loads the temperatures and rainfall data for the current COAPS station. Parameters ---------- station : int COAPS station identification code. cfgdict : dictionary Dictionary of configuration options. By default, the configuration options are read from the :file:`.climpyrc` file Returns ------- stationdata : ClimateRecords A :class:`~scikits.climpy.core.ClimateRecords` object, with fields: tobs : int Number of temperature observations for the day. tmin : float Minimum recorded temperature (oC). tmax : float Maximum recorded temperature (oC). rain : float Recorded amount of precipitation (mm). """ # datadir = cfgdict['datadir'] coapsarchive = _check_archive(cfgdict) # archfilename = "COAPS%s" % station try: zipf = zipfile.ZipFile(coapsarchive, 'r') stationdata = cPickle.loads(zipf.read(archfilename)) except IOError: zipf = zipfile.ZipFile(coapsarchive, 'w') except (KeyError, ValueError): zipf = zipfile.ZipFile(coapsarchive, 'a') else: return stationdata # netfile = os.path.join(cfgdict['netfile.dir'], "%sascii.txt" % station) sourcedir = np.lib._datasource.DataSource(datadir) dfile = sourcedir.open(netfile) skip = int(cfgdict['headerlines']) missing_values = cfgdict['nodata'] dateconverter = lambda y, m, d : ts.Date('D', year=int(y), month=int(m), day=int(d)) converters = {4 : lambda s: np.round((float(s) - 32) / 1.8, 1), 5 : lambda s: np.round((float(s) - 32) / 1.8, 1), 6 : lambda s: 0.254 * float(s)} ndtype = [('nobs', int), ('tmin', float), ('tmax', float), ('rain', float)] series = ts.tsfromtxt(dfile, delimiter="\t", skiprows=skip, missing=missing_values, converters=converters, datecols=(0, 1, 2), dateconverter=dateconverter) series = series.view(ndtype) # Store metainfo metainfo = [] dfile.seek(0) for i in range(skip - 2): row = dfile.readline().strip() if not len(row): continue info = tuple([_.strip() for _ in row.split(":")]) if len(info) == 1: info = (info, '') metainfo.append(info) series._optinfo.update(metainfo=dict(metainfo)) zipf.writestr(archfilename, cPickle.dumps(series)) zipf.close() return series