def main():
startDate = "2003-01-01" #YYYY-MM-DD
endDate = "2010-12-31" #YYYY-MM-DD
# time object
modelTime = ModelTime() # timeStep info: year, month, day, doy, hour, etc
modelTime.getStartEndTimeSteps(startDate, endDate)
#
# upscaling the PCR-GLOBWB results from five minute to one degree:
upscalingModel = UpscalingFramework(input_files,\
output_files,\
modelTime,\
tmpDir)
dynamic_framework = DynamicFramework(upscalingModel,\
modelTime.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
# reset time object
modelTime = ModelTime() # timeStep info: year, month, day, doy, hour, etc
modelTime.getStartEndTimeSteps(startDate, endDate)
#
# evaluate model results to grace product
graceEvaluation = GraceEvaluation(input_files,\
output_files,\
modelTime,\
tmpDir)
dynamic_framework = DynamicFramework(graceEvaluation,\
modelTime.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
def main():
# prepare logger and its directory
log_file_location = output['folder'] + "/log/"
try:
os.makedirs(log_file_location)
except:
cmd = 'rm -r ' + log_file_location + "/*"
os.system(cmd)
pass
vos.initialize_logging(log_file_location)
# time object
modelTime = ModelTime() # timeStep info: year, month, day, doy, hour, etc
modelTime.getStartEndTimeSteps(startDate, endDate, nrOfTimeSteps)
calculationModel = CalcFramework(cloneMapFileName,\
pcraster_files, \
modelTime, \
output, inputEPSG, outputEPSG, resample_method)
dynamic_framework = DynamicFramework(calculationModel,
modelTime.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
def initialize_config(self, fileName):
logger.info("PCRGlobWB: initialize_config")
try:
self.configuration = Configuration(fileName,
relative_ini_meteo_paths=True)
pcr.setclone(self.configuration.cloneMap)
# set start and end time based on configuration
self.model_time = ModelTime()
self.model_time.getStartEndTimeSteps(
self.configuration.globalOptions['startTime'],
self.configuration.globalOptions['endTime'])
self.model_time.update(0)
self.shape = self.calculate_shape()
logger.info("Shape of maps is %s", str(self.shape))
self.model = None
except:
import traceback
traceback.print_exc()
raise
def main():
# get the full path of configuration/ini file given in the system argument
iniFileName = os.path.abspath(sys.argv[1])
# debug option
debug_mode = False
if len(sys.argv) > 2:
if sys.argv[2] == "debug": debug_mode = True
# object to handle configuration/ini file
configuration = Configuration(iniFileName = iniFileName, \
debug_mode = debug_mode)
# timeStep info: year, month, day, doy, hour, etc
currTimeStep = ModelTime()
# Running the deterministic_runner
currTimeStep.getStartEndTimeSteps(configuration.globalOptions['startTime'],
configuration.globalOptions['endTime'])
logger.info('Model run starts.')
deterministic_runner = DeterministicRunner(configuration, currTimeStep)
dynamic_framework = DynamicFramework(deterministic_runner,
currTimeStep.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
def initialize(self, config_file_location=None):
"""
Initializes the model: read config file, load variables, get timestep information, etc.
"""
self.configuration = Configuration(config_file_location)
self.initial_state = None
self.currTimeStep = ModelTime(
) # timeStep info: year, month, day, doy, hour, etc
self.currTimeStep.getStartEndTimeSteps(
self.configuration.globalOptions['startTime'],
self.configuration.globalOptions['endTime'])
self.deterministic_runner = DeterministicRunner(
self.configuration, self.currTimeStep, self.initial_state)
self.dynamic_framework = DynamicFramework(self.deterministic_runner, 1)
self.dynamic_framework.setQuiet(True)
self.dynamic_framework._runInitial()
self.dynamic_framework._runResume()
# set timestep (to allow updates on a per-timestep-basis)
self.currenttimestep = 0
logger.info('Model initialized. Spin-up might be required.')
def main():
initial_state = None
configuration = Configuration()
spin_up = SpinUp(configuration) # object for spin_up
currTimeStep = ModelTime(
) # timeStep info: year, month, day, doy, hour, etc
# spinningUp
noSpinUps = int(configuration.globalOptions['maxSpinUpsInYears'])
if noSpinUps > 0:
logger.info('Spin-Up #Total Years: ' + str(noSpinUps))
spinUpRun = 0
has_converged = False
while spinUpRun < noSpinUps and has_converged == False:
spinUpRun += 1
currTimeStep.getStartEndTimeStepsForSpinUp(
configuration.globalOptions['startTime'], spinUpRun, noSpinUps)
logger.info('Spin-Up Run No. ' + str(spinUpRun))
deterministic_runner = DeterministicRunner(configuration,
currTimeStep,
initial_state)
all_state_begin = deterministic_runner.model.getAllState()
dynamic_framework = DynamicFramework(deterministic_runner,
currTimeStep.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
all_state_end = deterministic_runner.model.getAllState()
has_converged = spin_up.checkConvergence(
all_state_begin, all_state_end, spinUpRun,
deterministic_runner.model.routing.cellArea)
initial_state = deterministic_runner.model.getState()
#
# Running the deterministic_runner (excluding DA scheme)
currTimeStep.getStartEndTimeSteps(configuration.globalOptions['startTime'],
configuration.globalOptions['endTime'])
logger.info('Transient simulation run started.')
deterministic_runner = DeterministicRunner(configuration, currTimeStep,
initial_state)
dynamic_framework = DynamicFramework(deterministic_runner,
currTimeStep.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
def spinup(self):
"""
Spin-up the model. This is required to obtain realistic starting conditions for the model run.
It runs on a yearly basis until the required convergence or max. allowed spin-up runs is reached.
"""
spin_up = SpinUp(self.configuration) # object for spin_up
self.currTimeStep = ModelTime(
) # timeStep info: year, month, day, doy, hour, etc
# spin-up
noSpinUps = int(self.configuration.globalOptions['maxSpinUpsInYears'])
if noSpinUps > 0:
logger.info('Spin-Up #Total Years: ' + str(noSpinUps))
spinUpRun = 0
has_converged = False
while spinUpRun < noSpinUps and has_converged == False:
spinUpRun += 1
self.currTimeStep.getStartEndTimeStepsForSpinUp(
self.configuration.globalOptions['startTime'], spinUpRun,
noSpinUps)
logger.info('Spin-Up Run No. ' + str(spinUpRun))
deterministic_runner = DeterministicRunner(
self.configuration, self.currTimeStep, self.initial_state)
all_state_begin = deterministic_runner.model.getAllState()
self.dynamic_framework = DynamicFramework(
deterministic_runner, self.currTimeStep.nrOfTimeSteps)
self.dynamic_framework.setQuiet(True)
self.dynamic_framework.run()
all_state_end = deterministic_runner.model.getAllState()
has_converged = spin_up.checkConvergence(
all_state_begin, all_state_end, spinUpRun,
deterministic_runner.model.routing.cellArea)
self.initial_state = deterministic_runner.model.getState()
# setting model ready after spin-up
self.currTimeStep.getStartEndTimeSteps(
self.configuration.globalOptions['startTime'],
self.configuration.globalOptions['endTime'])
self.deterministic_runner = DeterministicRunner(
self.configuration, self.currTimeStep, self.initial_state)
logger.info(
'End of spin-up. Model is ready for transient simulation run.')
def main():
# time object
modelTime = ModelTime() # timeStep info: year, month, day, doy, hour, etc
modelTime.getStartEndTimeSteps(startDate, endDate, nrOfTimeSteps)
calculationModel = CalcFramework(cloneMapFileName,\
pcraster_files, \
output, \
modelTime)
dynamic_framework = DynamicFramework(calculationModel,
modelTime.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
def main():
# time object
modelTime = ModelTime() # timeStep info: year, month, day, doy, hour, etc
modelTime.getStartEndTimeSteps(startDate, endDate)
# resample netcdf
resampleModel = ResampleFramework(input_netcdf,\
output_netcdf,\
modelTime,\
tmpDir)
dynamic_framework = DynamicFramework(resampleModel,
modelTime.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
def main():
# input_file
input_file = "/projects/0/dfguu/users/edwin/pcr-globwb-aqueduct/historical/1958-2001_watch/"
input_file = sys.argv[1]
# netcdf variable name
input_variable_name = sys.argv[2]
# timeStep info: year, month, day, doy, hour, etc
start_date = "2015-01-01"
end_date = "2015-12-31"
start_date = sys.argv[3]
end_date = sys.argv[4]
#
currTimeStep = ModelTime()
currTimeStep.getStartEndTimeSteps(start_date, end_date)
# output folder from this calculation
output_folder = "/scratch-shared/edwin/mekong_basin_temperature/test/"
output_folder = sys.argv[5]
# - if exists, cleaning the previous output directory:
if os.path.isdir(output_folder): shutil.rmtree(output_folder)
# - making the output folder
os.makedirs(output_folder)
# output file, variable name and unit
output_file = output_folder + "/" + sys.argv[6]
variable_name = sys.argv[7]
variable_unit = sys.argv[8]
# logger
# - making a log directory
log_file_directory = output_folder + "/" + "log/"
os.makedirs(log_file_directory)
# - initialize logging
vos.initialize_logging(log_file_directory)
# Running the deterministic_runner
logger.info('Starting the calculation.')
deterministic_runner = DeterministicRunner(currTimeStep, input_file, input_variable_name, output_file, variable_name, variable_unit)
dynamic_framework = DynamicFramework(deterministic_runner, currTimeStep.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
def main():
# prepare the output directory
try:
os.makedirs(pcraster_output['output_folder'])
except:
os.system('rm -r ' + str(pcraster_output['output_folder']))
pass
# - making the directory for storing global extent output files
os.makedirs(pcraster_output['output_folder'] + "/global/")
# - making the directory for storing regional extent output files
os.makedirs(pcraster_output['output_folder'] + "/regional/")
# prepare logger and its directory
log_file_location = pcraster_output['output_folder'] + "/log/"
try:
os.makedirs(log_file_location)
except:
pass
vos.initialize_logging(log_file_location)
# prepare a temporary folder
tmp_file_location = pcraster_output['output_folder'] + "/tmp/"
try:
os.makedirs(tmp_file_location)
except:
pass
# time object
modelTime = ModelTime() # timeStep info: year, month, day, doy, hour, etc
modelTime.getStartEndTimeSteps(startDate, endDate)
calculationModel = CalcFramework(globeCloneMapFileName, localCloneMapFileName, \
netcdf_input, \
pcraster_output, \
modelTime, \
inputEPSG, outputEPSG, resample_method)
dynamic_framework = DynamicFramework(calculationModel,
modelTime.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
def main():
# - prepare the output folder
if os.path.exists(output_folder): shutil.rmtree(output_folder)
os.makedirs(output_folder)
# prepare logger and its directory
log_file_location = output_folder + "/log/"
os.makedirs(log_file_location)
vos.initialize_logging(log_file_location)
# time object
modelTime = ModelTime() # timeStep info: year, month, day, doy, hour, etc
modelTime.getStartEndTimeSteps(startDate, endDate)
#~ print modelTime.nrOfTimeSteps
# calculation model/framework
calculationModel = AreaOperationNetcdfToPCRasterTSS(netcdf_input_file = netcdf_input_file, \
areaMapFileName = areaMapFileName, \
areaPointMapFileName = areaPointMapFileName, \
netcdf_input_clone_map_file = netcdf_input_clone_map_file, \
output_folder = output_folder, \
unit_conversion_factor = unit_conversion_factor, \
unit_conversion_offset = unit_conversion_offset, \
modelTime = modelTime, \
inputProjection = inputProjection, \
outputProjection = outputProjection, \
resample_method = resample_method, \
tss_daily_output_file = tss_daily_output_file, \
tss_10day_output_file = tss_10day_output_file, \
report_10day_pcr_files = True
)
number_of_time_steps = modelTime.nrOfTimeSteps
#~ number_of_time_steps = 100
dynamic_framework = DynamicFramework(calculationModel, number_of_time_steps)
dynamic_framework.setQuiet(True)
# - start the calculation
dynamic_framework.run()
def main():
# the output folder from this calculation
output_folder = "/scratch-shared/edwinvua/data_for_diede/netcdf_process/climatology_average/"
output_folder = sys.argv[1]
# totat_runoff_input_file
totat_runoff_input_file = "/scratch-shared/edwinvua/data_for_diede/flow_scenarios/climatology_average_totalRunoff_monthTot_output_1979-2015.nc"
totat_runoff_input_file = sys.argv[2]
# timeStep info: year, month, day, doy, hour, etc
start_date = "2015-01-01"
end_date = "2015-12-31"
start_date = sys.argv[3]
end_date = sys.argv[4]
#
currTimeStep = ModelTime()
currTimeStep.getStartEndTimeSteps(start_date, end_date)
# - if exists, cleaning the previous output directory:
if os.path.isdir(output_folder): shutil.rmtree(output_folder)
# - making the output folder
os.makedirs(output_folder)
# logger
# - making a log directory
log_file_directory = output_folder + "/" + "log/"
os.makedirs(log_file_directory)
# - initialize logging
vos.initialize_logging(log_file_directory)
# Running the deterministic_runner
logger.info('Starting the calculation.')
deterministic_runner = DeterministicRunner(currTimeStep, output_folder, totat_runoff_input_file)
dynamic_framework = DynamicFramework(deterministic_runner,currTimeStep.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
def main():
# print disclaimer
disclaimer.print_disclaimer()
# get the full path of configuration/ini file given in the system argument
iniFileName = os.path.abspath(sys.argv[1])
# debug option
debug_mode = False
if len(sys.argv) > 2:
if sys.argv[2] == "debug" or sys.argv[2] == "debug_parallel":
debug_mode = True
# options to perform steady state calculation
steady_state_only = False
if len(sys.argv) > 3:
if sys.argv[3] == "steady-state-only": steady_state_only = True
# object to handle configuration/ini file
configuration = Configuration(iniFileName = iniFileName, \
debug_mode = debug_mode, \
steady_state_only = steady_state_only)
# timeStep info: year, month, day, doy, hour, etc
currTimeStep = ModelTime()
# Running the deterministic_runner
currTimeStep.getStartEndTimeSteps(configuration.globalOptions['startTime'],
configuration.globalOptions['endTime'])
logger.info('Model run starts.')
deterministic_runner = DeterministicRunner(configuration, currTimeStep)
dynamic_framework = DynamicFramework(deterministic_runner,
currTimeStep.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
def main():
# get the full path of configuration/ini file given in the system argument
iniFileName = os.path.abspath(sys.argv[1])
# debug option
debug_mode = False
if len(sys.argv) > 2:
if sys.argv[2] == "debug" or sys.argv[
2] == "debug_parallel" or sys.argv[2] == "debug-parallel":
debug_mode = True
# object to handle configuration/ini file
configuration = Configuration(iniFileName = iniFileName, \
debug_mode = debug_mode, \
no_modification = False)
# parallel option
this_run_is_part_of_a_set_of_parallel_run = False
if len(sys.argv) > 2:
if sys.argv[2] == "parallel" or sys.argv[
2] == "debug_parallel" or sys.argv[2] == "debug-parallel":
this_run_is_part_of_a_set_of_parallel_run = True
# for a non parallel run (usually 30min), a specific directory given in the system argument (sys.argv[3]) will be assigned for a given parameter combination:
if this_run_is_part_of_a_set_of_parallel_run == False:
# modfiying 'outputDir' (based on the given system argument)
configuration.globalOptions['outputDir'] += "/" + str(
sys.argv[3]) + "/"
# for a parallel run (usually 5min), we assign a specific directory based on the clone number/code:
if this_run_is_part_of_a_set_of_parallel_run:
# modfiying outputDir, clone-map and landmask (based on the given system arguments)
clone_code = str(sys.argv[3])
configuration.globalOptions['outputDir'] += "/" + clone_code + "/"
configuration.globalOptions['cloneMap'] = configuration.globalOptions[
'cloneMap'] % (clone_code)
configuration.globalOptions['landmask'] = configuration.globalOptions[
'landmask'] % (clone_code)
# set configuration
configuration.set_configuration(system_arguments=sys.argv)
# timeStep info: year, month, day, doy, hour, etc
currTimeStep = ModelTime()
# object for spin_up
spin_up = SpinUp(configuration)
# spinning-up
noSpinUps = int(configuration.globalOptions['maxSpinUpsInYears'])
initial_state = None
if noSpinUps > 0:
logger.info('Spin-Up #Total Years: ' + str(noSpinUps))
spinUpRun = 0
has_converged = False
while spinUpRun < noSpinUps and has_converged == False:
spinUpRun += 1
currTimeStep.getStartEndTimeStepsForSpinUp(
configuration.globalOptions['startTime'], spinUpRun, noSpinUps)
logger.info('Spin-Up Run No. ' + str(spinUpRun))
deterministic_runner = DeterministicRunner(configuration,
currTimeStep,
initial_state, sys.argv)
all_state_begin = deterministic_runner.model.getAllState()
dynamic_framework = DynamicFramework(deterministic_runner,
currTimeStep.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
all_state_end = deterministic_runner.model.getAllState()
has_converged = spin_up.checkConvergence(
all_state_begin, all_state_end, spinUpRun,
deterministic_runner.model.routing.cellArea)
initial_state = deterministic_runner.model.getState()
#
# Running the deterministic_runner (excluding DA scheme)
currTimeStep.getStartEndTimeSteps(configuration.globalOptions['startTime'],
configuration.globalOptions['endTime'])
logger.info('Transient simulation run started.')
deterministic_runner = DeterministicRunner(configuration, currTimeStep,
initial_state, sys.argv)
dynamic_framework = DynamicFramework(deterministic_runner,
currTimeStep.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
def main():
# print disclaimer
disclaimer.print_disclaimer()
# get the full path of configuration/ini file given in the system argument
iniFileName = os.path.abspath(sys.argv[1])
# debug option
debug_mode = False
if len(sys.argv) > 2:
if sys.argv[2] == "debug": debug_mode = True
# object to handle configuration/ini file
configuration = Configuration(iniFileName = iniFileName, \
debug_mode = debug_mode)
# timeStep info: year, month, day, doy, hour, etc
currTimeStep = ModelTime()
# object for spin_up
spin_up = SpinUp(configuration)
# spinningUp
noSpinUps = int(configuration.globalOptions['maxSpinUpsInYears'])
initial_state = None
if noSpinUps > 0:
logger.info('Spin-Up #Total Years: ' + str(noSpinUps))
spinUpRun = 0
has_converged = False
while spinUpRun < noSpinUps and has_converged == False:
spinUpRun += 1
currTimeStep.getStartEndTimeStepsForSpinUp(
configuration.globalOptions['startTime'], spinUpRun, noSpinUps)
logger.info('Spin-Up Run No. ' + str(spinUpRun))
deterministic_runner = DeterministicRunner(configuration,
currTimeStep,
initial_state)
all_state_begin = deterministic_runner.model.getAllState()
dynamic_framework = DynamicFramework(deterministic_runner,
currTimeStep.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
all_state_end = deterministic_runner.model.getAllState()
has_converged = spin_up.checkConvergence(
all_state_begin, all_state_end, spinUpRun,
deterministic_runner.model.routing.cellArea)
initial_state = deterministic_runner.model.getState()
# Running the deterministic_runner (excluding DA scheme)
currTimeStep.getStartEndTimeSteps(configuration.globalOptions['startTime'],
configuration.globalOptions['endTime'])
logger.info('Transient simulation run started.')
deterministic_runner = DeterministicRunner(configuration, currTimeStep,
initial_state)
dynamic_framework = DynamicFramework(deterministic_runner,
currTimeStep.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
# for debugging to PCR-GLOBWB version one
if configuration.debug_to_version_one:
logger.info('\n\n\n\n\n' + 'Executing PCR-GLOBWB version 1.' +
'\n\n\n\n\n')
# reset modelTime object
currTimeStep = None
currTimeStep = ModelTime()
currTimeStep.getStartEndTimeSteps(
configuration.globalOptions['startTime'],
configuration.globalOptions['endTime'])
# execute PCR-GLOBWB version 1
# - including comparing model outputs (from versions one and two)
pcrglobwb_one = oldcalc_framework.PCRGlobWBVersionOne(configuration, \
currTimeStep, \
deterministic_runner.model.routing.landmask, \
deterministic_runner.model.routing.cellArea)
dynamic_framework = DynamicFramework(pcrglobwb_one,
currTimeStep.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
def main():
# get the full path of configuration/ini file given in the system argument
iniFileName = os.path.abspath(sys.argv[1])
# debug option
debug_mode = False
if len(sys.argv) > 2:
if sys.argv[2] == "debug": debug_mode = True
# object to handle configuration/ini file
configuration = Configuration(iniFileName = iniFileName, \
debug_mode = debug_mode)
# timeStep info: year, month, day, doy, hour, etc
currTimeStep = ModelTime()
# object for spin_up
spin_up = SpinUp(configuration)
# spinningUp
noSpinUps = int(configuration.globalOptions['maxSpinUpsInYears'])
initial_state = None
if noSpinUps > 0:
logger.info('Spin-Up #Total Years: ' + str(noSpinUps))
spinUpRun = 0
has_converged = False
while spinUpRun < noSpinUps and has_converged == False:
spinUpRun += 1
currTimeStep.getStartEndTimeStepsForSpinUp(
configuration.globalOptions['startTime'], spinUpRun, noSpinUps)
logger.info('Spin-Up Run No. ' + str(spinUpRun))
deterministic_runner = DeterministicRunner(configuration,
currTimeStep,
initial_state)
all_state_begin = deterministic_runner.model.getAllState()
dynamic_framework = DynamicFramework(deterministic_runner,
currTimeStep.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()
all_state_end = deterministic_runner.model.getAllState()
has_converged = spin_up.checkConvergence(
all_state_begin, all_state_end, spinUpRun,
deterministic_runner.model.routing.cellArea)
initial_state = deterministic_runner.model.getState()
#
# Running the deterministic_runner (excluding DA scheme)
currTimeStep.getStartEndTimeSteps(configuration.globalOptions['startTime'],
configuration.globalOptions['endTime'])
logger.info('Transient simulation run started.')
deterministic_runner = DeterministicRunner(configuration, currTimeStep,
initial_state)
dynamic_framework = DynamicFramework(deterministic_runner,
currTimeStep.nrOfTimeSteps)
dynamic_framework.setQuiet(True)
dynamic_framework.run()