def compute(self, surface, crop_evaporation_factor, precipitation, evaporation, seepage):
"""Compute and return the vertical time series for the given surface as dictionary.
The incoming time series precipitation and evaporation always contain
non-negative event values although precipitation adds volume to the
open water and evaporation removes volume. The incoming time series
seepage can contain both positive and negative event values.
This method returns the vertical time series as the list of time series
[precipitation, evaporation, seepage, infiltation], where each time
series is specified in [m3/day].
The returned timeseries for precipitation and seepage only contain
non-negative event values as they add volume to the open water. The
returned timeseries for evaporation and infiltation only contain
non-positive event values as they remove volume.
Parameters:
* surface -- surface in [m2]
* crop_evaporation factor -- factor to multiply with the evaporation
* precipitation -- precipitation time series in [mm/day]
* evaporation -- evaporation time series in [mm/day]
* seepage -- seepage time series in [mm/day]
"""
vertical_timeseries_list = [
SparseTimeseriesStub(),
SparseTimeseriesStub(),
SparseTimeseriesStub(),
SparseTimeseriesStub(),
]
timeseries_list = [precipitation, evaporation, seepage]
index_evaporation = 1
for event_tuple in enumerate_events(*timeseries_list):
date = event_tuple[0][0]
if self.inside_range(date) < 0:
continue
elif self.inside_range(date) > 0:
break
for index in range(0, len(timeseries_list)):
value = event_tuple[index][1] * surface * 0.001
if index == index_evaporation:
value = value * crop_evaporation_factor
if value > 0:
value = -value
vertical_timeseries_list[index].add_value(date, value)
vertical_timeseries_list[3], vertical_timeseries_list[2] = split_timeseries(vertical_timeseries_list[2])
logger.debug("precipitation size: %d", len(list(vertical_timeseries_list[0].events())))
logger.debug("seepage size: %d", len(list(vertical_timeseries_list[2].events())))
return {
"precipitation": vertical_timeseries_list[0],
"evaporation": vertical_timeseries_list[1],
"seepage": vertical_timeseries_list[2],
"infiltration": vertical_timeseries_list[3],
}
def transform_evaporation_timeseries_penman_to_makkink(evaporation_timeseries):
"""Return the adjusted evaporation timeserie.
Parameters:
* evaporation_timeseries -- timeserie with evaporation [mm/day]
"""
result = SparseTimeseriesStub()
month_factor = [0.400, 0.933, 1.267, 1.300, 1.300, 1.310, 1.267, 1.193, 1.170, 0.900, 0.700, 0.000]
for evaporation_event in enumerate_events(evaporation_timeseries):
month_number = evaporation_event[0][0].month
factor = month_factor[month_number-1]
result.add_value(evaporation_event[0][0], evaporation_event[0][1]*factor)
return result
def total_daily_bucket_outcome(bucket2outcome):
"""Return the total daily flow off and net drainage of all buckets
Parameters:
* bucket2outcome -- dictionary of Bucket to BucketOutcome
"""
generator = ()
if len(bucket2outcome.keys()) > 0:
buckets, outcomes = zip(*((b, o) for (b, o) in bucket2outcome.items()))
interesting_timeseries = []
for outcome in outcomes:
interesting_timeseries.append(outcome.flow_off)
interesting_timeseries.append(outcome.net_drainage)
generator = ((event_tuple[0][0], create_bucket_to_daily_outcome(buckets, event_tuple_values(event_tuple))) \
for event_tuple in enumerate_events(*interesting_timeseries))
return generator
def export_table(configuration_slug, start_date, end_date, directory, input_directory):
configuration = WaterbalanceConf.objects.filter(slug=configuration_slug)[0]
waterbalance_computer = WaterbalanceComputer2(configuration)
#tests
input_ts = waterbalance_computer.get_input_timeseries(start_date, end_date)
buckets = waterbalance_computer.get_buckets_timeseries(start_date, end_date)
#step 3. Summarize according to labels
buckets_summary = waterbalance_computer.get_bucketflow_summary(start_date, end_date)
#step 4. Get vertical timeseries
vertical_openwater = waterbalance_computer.get_vertical_open_water_timeseries(start_date, end_date)
#step 5. Get level control
level_control = waterbalance_computer.get_level_control_timeseries(start_date, end_date)
#step 6. Get sluice_error
reference_timeseries = waterbalance_computer.get_reference_timeseries(start_date, end_date)
#sluice_error = waterbalance_computer.get_sluice_error_timeseries(start_date, end_date)
#step 7. Get fractions
fractions = waterbalance_computer.get_fraction_timeseries(start_date, end_date)
buckets_summary = {"undrained": buckets_summary.undrained,
"drained": buckets_summary.drained,
"hardened": buckets_summary.hardened,
"flow_off": buckets_summary.flow_off,
"indraft": buckets_summary.indraft,
"totals":buckets_summary.totals}
f = open(join(directory, "bastiaan-bucketoutcome.csv"), "w")
csvf = csv.writer(f)
#combine cols of table
header = ['year', 'month', 'day']
data_cols = []
header+= ['input - precipitation', 'input - evaporation', 'input - seepage']
data_cols.extend([input_ts['precipitation'], input_ts['evaporation'], input_ts['seepage']])
for bucket, outcome in buckets.iteritems():
header.append(bucket.name + ' kwel')
data_cols.append(outcome.seepage)
header.append(bucket.name + ' netto neerslag')
data_cols.append(outcome.net_precipitation)
header.append(bucket.name + ' afstroming')
data_cols.append(outcome.flow_off)
header.append(bucket.name + ' drainage')
data_cols.append(outcome.net_drainage)
header.append(bucket.name + ' storage upper bucket')
data_cols.append(outcome.storage)
for name, outcome in buckets_summary.iteritems():
header.append('summary ' + name)
data_cols.append(outcome)
csvf.writerow(header)
for event_tuple in enumerate_events(*data_cols):
row = []
date = event_tuple[0][0]
row.extend([date.year, date.month, date.day])
row.extend([event[1] for event in event_tuple])
csvf.writerow(row)
f.close()
f = open(join(directory, "bastiaan-owbalanceoutcome.csv"), "w")
csvf = csv.writer(f)
#combine cols of table
header = ['year', 'month', 'day']
data_cols = []
header+= ['bound - precipitation', 'bound - evaporation', 'bound - seepage']
data_cols.extend([input_ts['precipitation'], input_ts['evaporation'], input_ts['seepage']])
for name, outcome in buckets_summary.iteritems():
header.append('bucket_summary ' + name)
data_cols.append(outcome)
for name, outcome in vertical_openwater.iteritems():
header.append('ow ' + name)
data_cols.append(outcome)
for name, timeserie in input_ts['outgoing_timeseries'].iteritems():
header.append('fixed_out ' + str(name))
data_cols.append(timeserie)
for name, timeserie in input_ts['incoming_timeseries'].iteritems():
header.append('fixed_in ' + str(name))
data_cols.append(timeserie)
header.append('peilh_in')
data_cols.append(level_control['level_control']['intake_time_series'])
header.append('peilh_uit')
data_cols.append(level_control['level_control']['pump_time_series'])
for name, timeserie in level_control['open_water_cnt'].iteritems():
header.append('ow_result ' + name)
data_cols.append(timeserie)
csvf.writerow(header)
for event_tuple in enumerate_events(*data_cols):
row = []
date = event_tuple[0][0]
row.extend([date.year, date.month, date.day])
row.extend([event[1] for event in event_tuple])
csvf.writerow(row)
f.close()
def handle(self, *args, **options):
parser = OptionParser(option_list=self.option_list)
(options, args) = parser.parse_args()
directory = args[1]
area_slug = args[2]
start_date = datetime.strptime(args[3], "%Y-%m-%d")
end_date = datetime.strptime(args[4], "%Y-%m-%d")
if options.export_table:
export_table(area_slug, start_date, end_date, directory, directory)
else:
filename = join(directory, "timeserie.csv")
area, waterbalance_computer = create_waterbalance_computer(area_slug, start_date, end_date, filename)
bucket2outcome, level_control, waterbalance_outcome = \
waterbalance_computer.compute(area, start_date, end_date)
f = open(join(directory, "intermediate-results.csv"), "w")
for bucket, outcome in bucket2outcome.items():
self.write_timeseries(f, bucket.name, "afstroming", outcome.flow_off)
(drainage_timeseries, timeseries) = split_timeseries(outcome.net_drainage)
self.write_timeseries(f, bucket.name, "drainage", drainage_timeseries)
self.write_timeseries(f, bucket.name, "intrek", timeseries)
self.write_timeseries(f, bucket.name, "kwel", outcome.seepage)
(evaporation_timeseries, timeseries) = split_timeseries(outcome.net_precipitation)
self.write_timeseries(f, bucket.name, "verdamping", evaporation_timeseries)
self.write_timeseries(f, bucket.name, "neerslag", timeseries)
self.write_timeseries(f, "openwater", "inlaat peilbeheer", level_control[0])
self.write_timeseries(f, "openwater", "pomp peilbeheer", level_control[1])
f.close()
f = open(join(directory, "Bastiaan-results.csv"), "w")
f.write("bakje,jaar,maand,dag,berging,afstroming,netto drainage,kwel,netto neerslag\n")
for bucket, outcome in bucket2outcome.items():
for event_tuple in enumerate_events(outcome.storage,
outcome.flow_off,
outcome.net_drainage,
outcome.seepage,
outcome.net_precipitation):
date = event_tuple[0][0]
assert date == event_tuple[1][0]
assert date == event_tuple[2][0]
assert date == event_tuple[3][0]
assert date == event_tuple[4][0]
storage = event_tuple[0][1]
flow_off = event_tuple[1][1]
net_drainage = event_tuple[2][1]
seepage = event_tuple[3][1]
net_precipitation = event_tuple[4][1]
f.write("%s,%d,%d,%d,%f,%f,%f,%f,%f\n" % (bucket.name, date.year, date.month, date.day, storage, flow_off, net_drainage, seepage, net_precipitation))
f.close()
f = open(join(directory, "waterbalance-outcome.csv"), "w")
for key, timeseries in waterbalance_outcome.open_water_timeseries.iteritems():
self.write_timeseries(f, "open water timeseries", key, timeseries)
for key, timeseries in waterbalance_outcome.level_control_assignment.iteritems():
self.write_timeseries(f, "level control assignment", key, timeseries)
for key, timeseries in waterbalance_outcome.open_water_fractions.iteritems():
self.write_timeseries(f, "open water fractions", key, timeseries)
for key, timeseries in waterbalance_outcome.intake_fractions.iteritems():
self.write_timeseries(f, "intake fractions", key, timeseries)
