def dynamic(self):
# update model time using the current pcraster timestep value
self.modelTime.update(self.currentTimeStep())
# reading
data_available = True
if data_available:
input_value = vos.netcdf2PCRobjClone(ncFile = self.input_netcdf['file_name'],
varName = self.input_netcdf['variable_name'],
dateInput = str(self.modelTime.fulldate),
useDoy = None,
cloneMapFileName = self.clone_map_file)
data_available = True
else:
print "No values are available for this date: "+str(self.modelTime)
data_available = False
if data_available: output_value = input_value
# upscaling
if data_available and self.resample_factor > 1.0:
# upscaling using cell area
cell_area = pcr.ifthen(pcr.defined(output_value), self.cell_area)
output_value_in_pcraster = \
vos.getValDivZero(\
pcr.areatotal(output_value*self.cell_area, self.unique_ids),\
pcr.areatotal(self.cell_area, self.unique_ids), vos.smallNumber)
# resample to the output clone resolution
output_value = vos.regridToCoarse(pcr.pcr2numpy(output_value_in_pcraster, vos.MV),
self.resample_factor, "max", vos.MV)
# reporting
if data_available:
# time stamp
timestepPCR = self.modelTime.timeStepPCR
timeStamp = datetime.datetime(self.modelTime.year,\
self.modelTime.month,\
self.modelTime.day,0)
# write to netcdf
self.output.data2NetCDF(self.output_netcdf['file_name'],\
self.output_netcdf['variable_name'],\
output_value,\
timeStamp)
# closing the file at the end of
if self.modelTime.isLastTimeStep(): self.output.close(self.output_netcdf['file_name'])
def dynamic(self):
# re-calculate model time using current pcraster timestep value
self.modelTime.update(self.currentTimeStep())
# processing / calculating only at the last day of the month:
if self.modelTime.endMonth == True:
#~ # open totalWaterStorageThickness (unit: m, monthly average values)
#~ value_at_5min = vos.netcdf2PCRobjClone(\
#~ self.input_files["model_total_water_storage"],\
#~ "total_thickness_of_water_storage",\
#~ str(self.modelTime.fulldate), useDoy = "end-month")
# open totalWaterStorageThickness (unit: m, monthly average values)
value_at_5min = vos.netcdf2PCRobjClone(\
self.input_files["model_total_water_storage"],\
self.input_files["model_total_water_storage_variable_name"],\
str(self.modelTime.fulldate), useDoy = "end-month")
# upscale to one degree resolution
value_at_1deg_but_5min_cell = \
vos.getValDivZero(\
pcr.areatotal(self.cell_area*value_at_5min,\
self.one_degree_id),\
pcr.areatotal(self.cell_area,self.one_degree_id),
vos.smallNumber)
# resample from 5 arc minute cells to one degree cells
value_at_1deg = vos.regridToCoarse(\
pcr.pcr2numpy(value_at_1deg_but_5min_cell,vos.MV),self.resample_factor,"max",vos.MV)
#
# reporting
timestepPCR = self.modelTime.timeStepPCR
timeStamp = datetime.datetime(self.modelTime.year,\
self.modelTime.month,\
self.modelTime.day,0)
# write it to netcdf
self.output.data2NetCDF(self.output_files['one_degree_tws']['model'],\
"pcrglobwb_tws",\
value_at_1deg,\
timeStamp)
useDoy = "Yes", \
cloneMapFileName = clone_map_file,\
LatitudeLongitude = True,\
specificFillValue = None)
fraction_of_surface_water = pcr.ifthen(
landmask, pcr.cover(fraction_of_surface_water, 0.0))
# - upscale it to 30 arc-min (dimensionless)
fraction_of_surface_water_30min = pcr.areatotal(
fraction_of_surface_water * cell_area,
cell_ids_30min) / cell_area_30min
# calculate surface water level at 30 arc-min resolution
surface_water_level_30min = channel_storage_30min / (pcr.max(
fraction_of_surface_water_30min, minimum_fraction_of_surface_water) *
cell_area_30min)
# convert it 30 arcmin arrays
surface_water_level_30min_arrays = vos.regridToCoarse(
pcr.pcr2numpy(surface_water_level_30min, vos.MV), upscaling_factor,
"max", vos.MV)
# save it to netcdf file
ncFileName = netcdf_file[var_name]['file_name']
msg = "Saving to the netcdf file: " + str(
netcdf_file[var_name]['file_name'])
logger.info(msg)
time_stamp_used = datetime.datetime(i_year, 12, 31, 0)
netcdf_report.data2NetCDF(ncFileName, varDict.netcdf_short_name[var_name],
surface_water_level_30min_arrays,
time_stamp_used)
def main():
# make output directory
try:
os.makedirs(output_directory)
except:
if cleanOutputDir == True:
os.system('rm -r ' + output_directory + "/*")
# change the current directory/path to output directory
os.chdir(output_directory)
# make temporary directory
tmp_directory = output_directory + "/tmp"
os.makedirs(tmp_directory)
vos.clean_tmp_dir(tmp_directory)
# format and initialize logger
logger_initialize = Logger(output_directory)
logger.info('Start processing for 5 arc-min resolution!')
# clone and landmask for 5 arc-min resolution
pcr.setclone(clone_map_05min_file)
landmask = pcr.defined(clone_map_05min_file)
# read thickness value (at 5 arc min resolution)
logger.info('Reading the thickness at 5 arc-min resolution!')
thickness = pcr.ifthen(landmask,\
vos.netcdf2PCRobjCloneWithoutTime(thickness_05min_netcdf['filename'], "average_corrected", clone_map_05min_file))
#
# update landmask
landmask = pcr.defined(thickness)
# read aquifer properties at 5 arc min resolution
logger.info(
'Reading saturated conductivity and specific yield at 5 arc-min resolution!'
)
saturated_conductivity = pcr.ifthen(landmask,\
vos.netcdf2PCRobjCloneWithoutTime(\
aquifer_properties_05min_netcdf['filename'],\
"kSatAquifer" , clone_map_05min_file))
specific_yield = pcr.ifthen(landmask,\
vos.netcdf2PCRobjCloneWithoutTime(\
aquifer_properties_05min_netcdf['filename'],\
"specificYield", clone_map_05min_file))
# saving 5 min parameters to a netcdf file
logger.info('Saving groundwater parameter parameters to a netcdf file: ' +
output_05min_filename)
#
output_05min_netcdf = outputNetCDF.OutputNetCDF(clone_map_05min_file)
#
variable_names = ["saturated_conductivity", "specific_yield", "thickness"]
units = ["m/day", "1", "m"]
variable_fields = [
pcr.pcr2numpy(saturated_conductivity, vos.MV),
pcr.pcr2numpy(specific_yield, vos.MV),
pcr.pcr2numpy(thickness, vos.MV),
]
pcr.report(saturated_conductivity, "saturated_conductivity_05min.map")
pcr.report(specific_yield, "specific_yield_05min.map")
pcr.report(thickness, "thickness_05min.map")
output_05min_netcdf.createNetCDF(output_05min_filename, variable_names,
units)
output_05min_netcdf.changeAtrribute(output_05min_filename,
netcdf_attributes)
output_05min_netcdf.data2NetCDF(output_05min_filename, variable_names,
variable_fields)
logger.info('Start processing for 30 arc-min resolution!')
# upscaling thickness to 30 arc min resolution
logger.info('Upscaling thickness from 5 arc-min resolution to 30 arc-min!')
thickness_05min_array = pcr.pcr2numpy(thickness, vos.MV)
thickness_30min_array = vos.regridToCoarse(thickness_05min_array, 30. / 5.,
"average")
#
# set clone for 30 arc min resolution
pcr.setclone(clone_map_30min_file)
#
landmask = pcr.defined(clone_map_30min_file)
thickness = pcr.ifthen(
landmask, pcr.numpy2pcr(pcr.Scalar, thickness_30min_array, vos.MV))
#
# update landmask
landmask = pcr.defined(thickness)
# read aquifer properties at 30 arc min resolution
logger.info(
'Reading saturated conductivity and specific yield at 30 arc-min resolution!'
)
saturated_conductivity = pcr.ifthen(landmask,\
vos.netcdf2PCRobjCloneWithoutTime(\
aquifer_properties_30min_netcdf['filename'],\
"kSatAquifer" , clone_map_30min_file))
specific_yield = pcr.ifthen(landmask,\
vos.netcdf2PCRobjCloneWithoutTime(\
aquifer_properties_30min_netcdf['filename'],\
"specificYield", clone_map_30min_file))
# saving 30 min parameters to a netcdf file
logger.info('Saving groundwater parameter parameters to a netcdf file: ' +
output_30min_filename)
#
output_30min_netcdf = outputNetCDF.OutputNetCDF(clone_map_30min_file)
#
variable_names = ["saturated_conductivity", "specific_yield", "thickness"]
units = ["m/day", "1", "m"]
variable_fields = [
pcr.pcr2numpy(saturated_conductivity, vos.MV),
pcr.pcr2numpy(specific_yield, vos.MV),
pcr.pcr2numpy(thickness, vos.MV),
]
pcr.report(saturated_conductivity, "saturated_conductivity_30min.map")
pcr.report(specific_yield, "specific_yield_30min.map")
pcr.report(thickness, "thickness_30min.map")
output_30min_netcdf.createNetCDF(output_30min_filename, variable_names,
units)
output_30min_netcdf.changeAtrribute(output_30min_filename,
netcdf_attributes)
output_30min_netcdf.data2NetCDF(output_30min_filename, variable_names,
variable_fields)
# read extreme value map
file_name = file_names[i_file]
extreme_value_05min_map = pcr.readmap(file_name)
# upscale it to 30 arcmin resolution:
if map_type_name == "HESSEL_RESULT":
extreme_value_30min_map_at_5min_resolution = pcr.areamaximum(
extreme_value_05min_map, cell_ids_30min)
else:
extreme_value_30min_map_at_5min_resolution = pcr.areatotal(
extreme_value_05min_map, cell_ids_30min)
# convert it to 30 arcmin numpy array and store it in a dictionary
extreme_value_30min_at_5min_resolution = pcr.pcr2numpy(
extreme_value_30min_map_at_5min_resolution, vos.MV)
resampling_factor = np.int(30. / (5.))
extreme_value_30min[file_name] = vos.regridToCoarse(
extreme_value_30min_at_5min_resolution, resampling_factor, "max",
vos.MV)
# - set the clone map to 30 arcmin resolution
if with_upscaling or map_type_name == "HESSEL_RESULT":
resampling_factor = np.int(30. / (5.))
num_of_rows = np.round(pcr.clone().nrRows() / resampling_factor, 2)
num_of_cols = np.round(pcr.clone().nrCols() / resampling_factor, 2)
x_min = np.round(pcr.clone().west(), 2)
y_max = np.round(pcr.clone().north(), 2)
cell_length = pcr.clone().cellSize() * resampling_factor
# set the cell length manually
cell_length = '0.5'
#
# - make the map using 'mapattr' command
cmd = 'mapattr -s -R ' + str(num_of_rows) + \
None, False, None, True)
cell_ids_30min = pcr.ifthen(pcr.scalar(cell_ids_30min) > 0.0, cell_ids_30min)
# a dictionary that will contain 30 arcmin numpy array
extreme_value_30min = {}
# upscaling to 30 arc-min:
for i_file in range(0, len(file_names)):
# read extreme value map
file_name = file_names[i_file]
extreme_value_05min_map = pcr.readmap(file_name)
# upscale it to 30 arcmin resolution:
extreme_value_30min_map_at_5min_resolution = pcr.areatotal(extreme_value_05min_map, cell_ids_30min)
# convert it to 30 arcmin numpy array and store it in a dictionary
extreme_value_30min_at_5min_resolution = pcr.pcr2numpy(extreme_value_30min_map_at_5min_resolution, vos.MV)
resampling_factor = np.int(30. / (5.))
extreme_value_30min[file_name] = vos.regridToCoarse(extreme_value_30min_at_5min_resolution, resampling_factor, "max", vos.MV)
# save numpy arrays to 30 arcmin maps
#
# - set the clone map to 30 arcmin resolution
num_of_rows = np.round(pcr.clone().nrRows() / resampling_factor , 2)
num_of_cols = np.round(pcr.clone().nrCols() / resampling_factor , 2)
x_min = np.round(pcr.clone().west() , 2)
y_max = np.round(pcr.clone().north() , 2)
cell_length = pcr.clone().cellSize() * resampling_factor
# set the cell length manually
cell_length = '0.5'
#
# - make the map using 'mapattr' command
cmd = 'mapattr -s -R ' + str(num_of_rows) + \
' -C ' + str(num_of_cols) + \
year) + "_maximum.nc"
cmd = 'cdo timmax ' + inp_file_name + " " + out_file_name
print(cmd)
os.system(cmd)
# time stamp for netcdf reporting
timeStamp = datetime.datetime(year, 12, 31, 0)
# read value and report it at 5 arcmin resolution
print("Reading values at 5 arcmin resolution.")
value_at_05_min = vos.netcdf2PCRobjCloneWithoutTime(ncFile = out_file_name, varName = variable_name, \
cloneMapFileName = clone_map_05min_file)
value_at_05_min = pcr.cover(value_at_05_min, 0.0)
numpy_at_05_min = pcr.pcr2numpy(value_at_05_min, vos.MV)
report_netcdf_05min.data2NetCDF(output_file_05min, \
variable_name, \
numpy_at_05_min, \
timeStamp)
# upscale it to 30 arcmin resolution and report it
print("Upscale to 30 arcmin resolution.")
value_at_30_min = pcr.areatotal(value_at_05_min * cell_area_05min, cell_ids_30min) /\
pcr.areatotal( cell_area_05min, cell_ids_30min)
value_at_30_min = pcr.cover(value_at_30_min, 0.0)
numpy_at_30_min = vos.regridToCoarse(pcr.pcr2numpy(value_at_30_min, vos.MV), \
int(30./5.), "average", vos.MV)
report_netcdf_30min.data2NetCDF(output_file_30min, \
variable_name, \
numpy_at_30_min, \
timeStamp)
LatitudeLongitude = True,\
specificFillValue = None)
channel_storage = pcr.ifthen(landmask, pcr.cover(channel_storage, 0.0))
# - upscale it to 30 arc-min (unit: m3)
channel_storage_30min = pcr.areatotal(channel_storage, cell_ids_30min)
# read fraction_of_surface_water and upscale it to 30 arc-min (dimensionless)
fraction_of_surface_water = vos.netcdf2PCRobjClone(input_files['file_name']['dynamicFracWat'], \
"fraction_of_surface_water", time_index_in_netcdf_file,\
useDoy = "Yes", \
cloneMapFileName = clone_map_file,\
LatitudeLongitude = True,\
specificFillValue = None)
fraction_of_surface_water = pcr.ifthen(landmask, pcr.cover(fraction_of_surface_water, 0.0))
# - upscale it to 30 arc-min (dimensionless)
fraction_of_surface_water_30min = pcr.areatotal(fraction_of_surface_water * cell_area, cell_ids_30min) / cell_area_30min
# calculate surface water level at 30 arc-min resolution
surface_water_level_30min = channel_storage_30min / (pcr.max(fraction_of_surface_water_30min, minimum_fraction_of_surface_water) * cell_area_30min)
# convert it 30 arcmin arrays
surface_water_level_30min_arrays = vos.regridToCoarse(pcr.pcr2numpy(surface_water_level_30min, vos.MV), upscaling_factor, "max", vos.MV)
# save it to netcdf file
ncFileName = netcdf_file[var_name]['file_name']
msg = "Saving to the netcdf file: " + str(netcdf_file[var_name]['file_name'])
logger.info(msg)
time_stamp_used = datetime.datetime(i_year, 12, 31, 0)
netcdf_report.data2NetCDF(ncFileName, varDict.netcdf_short_name[var_name], surface_water_level_30min_arrays, time_stamp_used)