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)