def test_cell_data_to_netcdf(self):
region_model = self.region_model_repo.get_region_model('test')
self.region_model_repo.cell_data_to_netcdf(
region_model, os.path.join(self.test_dir, 'test'))
# open the file and be sure it works
output_nc = os.path.join(self.test_dir, 'test_cell_data.nc')
self.region['repository']['params']['data_file'] = output_nc
tmp_rm = CFRegionModelRepository(self.region,
self.model).get_region_model('test')
self.assertIsInstance(tmp_rm, PTGSKModel,
'Error with {}'.format(output_nc))
shutil.rmtree(self.test_dir)
def test_run_arome_ensemble(self):
# Simulation time axis
utc = api.Calendar() # No offset gives Utc
t0 = utc.time(2015, 7, 26, 0)
n_hours = 30
dt = api.deltahours(1)
time_axis = api.TimeAxisFixedDeltaT(t0, dt, n_hours)
# Some dummy ids not needed for the netcdf based repositories
region_id = 0
interpolation_id = 0
# Simulation coordinate system
epsg = "32633"
# Configs and repositories
region_model_repository = CFRegionModelRepository(
self.region_config, self.model_config)
interp_repos = InterpolationParameterRepository(
self.interpolation_config)
base_dir = path.join(shyftdata_dir, "netcdf", "arome")
pattern = "fc*.nc"
try:
geo_ts_repository = MetNetcdfDataRepository(epsg,
base_dir,
filename=pattern,
allow_subset=True)
except Exception as e:
print("**** test_run_arome_ensemble: Arome data missing or"
" wrong, test inconclusive ****")
print("****{}****".format(e))
self.skipTest(
"**** test_run_arome_ensemble: Arome data missing or wrong, test "
"inconclusive ****\n\t exception:{}".format(e))
simulator = DefaultSimulator(region_id, interpolation_id,
region_model_repository,
geo_ts_repository, interp_repos, None)
state_repos = DefaultStateRepository(simulator.region_model)
simulators = simulator.create_ensembles(time_axis, t0,
state_repos.get_state(0))
for s in simulators:
s.simulate()
def test_compute_lwc_percentiles(self):
# Simulation time axis
year, month, day, hour = 2013, 9, 1, 0
dt = api.deltahours(24)
n_steps = 364
utc = api.Calendar() # No offset gives Utc
t0 = utc.time(year, month, day, hour)
time_axis = api.TimeAxisFixedDeltaT(t0, dt, n_steps)
# Some fake ids
region_id = 0
interpolation_id = 0
# Model
region_model_repository = CFRegionModelRepository(
self.region_config, self.model_config)
interp_repos = InterpolationParameterRepository(
self.interpolation_config)
netcdf_geo_ts_repos = [
CFDataRepository(32633,
source["params"]["filename"],
padding=source["params"]['padding'])
for source in self.dataset_config.sources
]
geo_ts_repository = GeoTsRepositoryCollection(netcdf_geo_ts_repos)
# Construct target discharge series
simulator = DefaultSimulator(region_id, interpolation_id,
region_model_repository,
geo_ts_repository, interp_repos, None)
state_repos = DefaultStateRepository(simulator.region_model)
cid = 1228
simulator.region_model.set_state_collection(cid, True)
simulator.run(time_axis=time_axis, state=state_repos.get_state(0))
# TODO: Update the regression test below with correct result
# self.assertAlmostEqual(simulator.region_model.cells[0].rc.pe_output.values[0], 0.039768354, 5) # just to verify pot.evap by regression, mm/h
percentile_list = [10, 25, 50, 75, 90]
def nc_region_model_repo_constructor(region_config, model_config,
region_model_id):
from shyft.repository.netcdf.cf_region_model_repository import CFRegionModelRepository
return CFRegionModelRepository(region_config, model_config)
def test_snow_and_ground_water_response_calibration(self):
"""
Test dual calibration strategy:
* First fit the three Kirchner parameters for
ground water response during July, August, and
September.
* Then fit two snow routine parameters (tx and max_water)
from November to April.
"""
# Simulation time axis
dt = api.deltahours(24)
n_steps = 364
utc = api.Calendar() # No offset gives Utc
t0 = utc.time(2013, 9, 1, 0)
time_axis = api.TimeAxisFixedDeltaT(t0, dt, n_steps)
# Some fake ids
region_id = 0
interpolation_id = 0
opt_model_t = self.model_config.model_type().opt_model_t
model_config = ModelConfig(self.model_config_file,
overrides={'model_t': opt_model_t})
region_model_repository = CFRegionModelRepository(
self.region_config, model_config)
interp_repos = InterpolationParameterRepository(
self.interpolation_config)
netcdf_geo_ts_repos = [
CFDataRepository(32633,
source["params"]["filename"],
padding=source["params"]['padding'])
for source in self.dataset_config.sources
]
geo_ts_repository = GeoTsRepositoryCollection(netcdf_geo_ts_repos)
# Construct target discharge series
simulator = DefaultSimulator(region_id, interpolation_id,
region_model_repository,
geo_ts_repository, interp_repos, None)
state_repos = DefaultStateRepository(simulator.region_model)
simulator.run(time_axis, state_repos.get_state(0))
cid = 1228
target_discharge = api.TsTransform().to_average(
t0, dt, n_steps,
simulator.region_model.statistics.discharge([cid]))
# Construct kirchner parameters
param = simulator.region_model.parameter_t(
simulator.region_model.get_region_parameter())
print_param("True solution", param)
kirchner_param_min = simulator.region_model.parameter_t(param)
kirchner_param_max = simulator.region_model.parameter_t(param)
# Kichner parameters are quite abstract (no physical meaning), so simply scale them
kirchner_param_min.kirchner.c1 *= 0.8
kirchner_param_min.kirchner.c2 *= 0.8
kirchner_param_min.kirchner.c3 *= 0.8
kirchner_param_max.kirchner.c1 *= 1.2
kirchner_param_max.kirchner.c2 *= 1.2
kirchner_param_max.kirchner.c3 *= 1.2
# kirchner_t_start = utc.time(2011, 4, 1, 0)
# kirchner_time_axis = api.TimeAxisFixedDeltaT(kirchner_t_start, dt, 150)
kirchner_time_axis = time_axis
# Construct gamma snow parameters (realistic tx and max_lwc)
gamma_snow_param_min = simulator.region_model.parameter_t(param)
gamma_snow_param_max = simulator.region_model.parameter_t(param)
gamma_snow_param_min.gs.tx = -1.0 # Min snow/rain temperature threshold
gamma_snow_param_min.gs.max_water = 0.05 # Min 8% max water in snow in costal regions
gamma_snow_param_max.gs.tx = 1.0
gamma_snow_param_max.gs.max_water = 0.25 # Max 35% max water content, or we get too little melt
gs_t_start = utc.time(2013, 11, 1, 0)
gs_time_axis = api.TimeAxisFixedDeltaT(gs_t_start, dt, 250)
# gs_time_axis = time_axis
# Find parameters
target_spec = api.TargetSpecificationPts(target_discharge,
api.IntVector([cid]), 1.0,
api.KLING_GUPTA)
target_spec_vec = api.TargetSpecificationVector(
) # TODO: We currently dont fix list initializer for vectors
target_spec_vec.append(target_spec)
# Construct a fake, perturbed starting point for calibration
p_vec = [param.get(i) for i in range(param.size())]
for i, name in enumerate(
[param.get_name(i) for i in range(len(p_vec))]):
if name not in ("c1" "c2", "c3", "TX", "max_water"):
next
if name in ("c1", "c2", "c3"):
p_vec[i] = random.uniform(0.8 * p_vec[i], 1.2 * p_vec[i])
elif name == "TX":
p_vec[i] = random.uniform(gamma_snow_param_min.gs.tx,
gamma_snow_param_max.gs.tx)
elif name == "max_water":
p_vec[i] = random.uniform(gamma_snow_param_min.gs.max_water,
gamma_snow_param_max.gs.max_water)
param.set(p_vec)
print_param("Initial guess", param)
# Two pass optimization, once for the ground water response, and second time for
kirchner_p_opt = simulator.optimize(kirchner_time_axis,
state_repos.get_state(0),
target_spec_vec, param,
kirchner_param_min,
kirchner_param_max)
gamma_snow_p_opt = simulator.optimize(gs_time_axis,
state_repos.get_state(0),
target_spec_vec, kirchner_p_opt,
gamma_snow_param_min,
gamma_snow_param_max)
print_param("Half way result", kirchner_p_opt)
print_param("Result", gamma_snow_p_opt)
simulator.region_model.set_catchment_parameter(cid, gamma_snow_p_opt)
simulator.run(time_axis, state_repos.get_state(0))
found_discharge = simulator.region_model.statistics.discharge([cid])
'iso_pot_energy': 0.0,
'lwc': 0.1,
'sdc_melt_mean': 0.0,
'surface_heat': 30000.0,
'temp_swe': 0.0},
'kirchner': {'q': 0.01}}
# time of simulation
ta = time_axis_from_dict(TimeDict)
ip_conf = interp_config()
ip_repo = InterpolationParameterRepository(ip_conf)
# region repository
region_repo = CFRegionModelRepository(RegionDict, ModelDict)
# region_model
region_model = region_repo.get_region_model('demo')
region_model.interpolation_parameter = ip_repo.get_parameters(0) #just a '0' for now
# forcing data (geo-timeseries) repository
geots_repo = construct_geots_repo(ForcingData, epsg = region_model.bounding_region.epsg())
# a bounding box for data selection
bbox = region_model.bounding_region.bounding_box(region_model.bounding_region.epsg())
period = ta.total_period() #just defined above
class CFRegionModelRepositoryTestCase(unittest.TestCase):
# Create a temporary directory
test_dir = tempfile.mkdtemp()
region = {
'region_model_id':
'test', # a unique name identifier of the simulation
'domain': {
'EPSG': 32633,
'nx': 400,
'ny': 80,
'step_x': 1000,
'step_y': 1000,
'lower_left_x': 100000,
'lower_left_y': 6960000
},
'repository': {
'class': CFRegionModelRepository,
'params': {
'data_file':
os.path.join(shyftdata_dir,
'netcdf/orchestration-testdata/cell_data.nc')
}
},
}
model = {
'model_t': PTGSKModel, # model to construct
'model_parameters': {
'ae': {
'ae_scale_factor': 1.5
},
'gs': {
'calculate_iso_pot_energy': False,
'fast_albedo_decay_rate': 6.752787747748934,
'glacier_albedo': 0.4,
'initial_bare_ground_fraction': 0.04,
'max_albedo': 0.9,
'max_water': 0.1,
'min_albedo': 0.6,
'slow_albedo_decay_rate': 37.17325702015658,
'snow_cv': 0.4,
'snow_cv_altitude_factor': 0.0,
'snow_cv_forest_factor': 0.0,
'tx': -0.5752881492890207,
'snowfall_reset_depth': 5.0,
'surface_magnitude': 30.0,
'wind_const': 1.0,
'wind_scale': 1.8959672005350063,
'winter_end_day_of_year': 100
},
'kirchner': {
'c1': -3.336197322290274,
'c2': 0.33433661533385695,
'c3': -0.12503959620315988
},
'p_corr': {
'scale_factor': 1.0
},
'pt': {
'albedo': 0.2,
'alpha': 1.26
},
'routing': {
'alpha': 0.9,
'beta': 3.0,
'velocity': 0.0
}
}
}
region_model_repo = CFRegionModelRepository(region, model)
def test_get_region_model(self):
region_model = self.region_model_repo.get_region_model('test')
self.assertIsInstance(
region_model, PTGSKModel,
'Correct model type not returned from CFRegionModelRepository')
def test_cell_data_to_netcdf(self):
region_model = self.region_model_repo.get_region_model('test')
self.region_model_repo.cell_data_to_netcdf(
region_model, os.path.join(self.test_dir, 'test'))
# open the file and be sure it works
output_nc = os.path.join(self.test_dir, 'test_cell_data.nc')
self.region['repository']['params']['data_file'] = output_nc
tmp_rm = CFRegionModelRepository(self.region,
self.model).get_region_model('test')
self.assertIsInstance(tmp_rm, PTGSKModel,
'Error with {}'.format(output_nc))
shutil.rmtree(self.test_dir)