def get_simulator(self):
"""
Return a DefaultSimulator based on `cfg`.
Returns
-------
DefaultSimulator instance
"""
# Read region, model and datasets config files
region_config_file = os.path.join(self.config_dir,
self.region_config_file)
region_config = yaml_config.RegionConfig(region_config_file)
model_config_file = os.path.join(self.config_dir,
self.model_config_file)
model_config = yaml_config.ModelConfig(model_config_file)
datasets_config_file = os.path.join(self.config_dir,
self.datasets_config_file)
datasets_config = yaml_config.YamlContent(datasets_config_file)
# Build some interesting constructs
region_model = RegionModelRepository(region_config, model_config,
self.model_t, self.epsg)
interp_repos = InterpolationParameterRepository(model_config)
geo_ts = get_geo_ts_collection(datasets_config, self.data_dir)
# If region and interpolation ids are not present, just use fake ones
region_id = 0 if not hasattr(self, "region_id") else int(
self.region_id)
interpolation_id = 0 if not hasattr(self, "interpolation_id") \
else int(self.interpolation_id)
# set up the simulator
simulator = DefaultSimulator(region_id, interpolation_id, region_model,
geo_ts, interp_repos, None)
return simulator
def test_compute_lwc_percentiles(self):
# Simulation time axis
year, month, day, hour = 2010, 9, 1, 0
dt = api.deltahours(24)
n_steps = 400
utc = api.Calendar() # No offset gives Utc
t0 = utc.time(api.YMDhms(year, month, day, hour))
time_axis = api.Timeaxis(t0, dt, n_steps)
# Some fake ids
region_id = 0
interpolation_id = 0
# Simulation coordinate system
epsg = "32633"
# Model
model_t = pt_gs_k.PTGSKModel
# Configs and repositories
dataset_config_file = path.join(path.dirname(__file__), "netcdf",
"atnsjoen_datasets.yaml")
region_config_file = path.join(path.dirname(__file__), "netcdf",
"atnsjoen_calibration_region.yaml")
region_config = RegionConfig(region_config_file)
model_config = ModelConfig(self.model_config_file)
dataset_config = YamlContent(dataset_config_file)
region_model_repository = RegionModelRepository(
region_config, model_config, model_t, epsg)
interp_repos = InterpolationParameterRepository(model_config)
netcdf_geo_ts_repos = []
for source in dataset_config.sources:
station_file = source["params"]["stations_met"]
netcdf_geo_ts_repos.append(
GeoTsRepository(source["params"], station_file, ""))
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)
n_cells = simulator.region_model.size()
state_repos = DefaultStateRepository(model_t, n_cells)
cid = 1
simulator.region_model.set_state_collection(cid, True)
simulator.run(time_axis, state_repos.get_state(0))
percentile_list = [10, 25, 50, 75, 90]
# From here, things could be calculated without copies (except for 't')
# TODO: Graham optimize with numba :-)
cells = simulator.region_model.get_cells()
lwcs = [np.array(cell.sc.gs_lwc.v) for cell in cells] # Contiguous
t = np.array([
cells[0].sc.gs_lwc.time(i)
for i in range(cells[0].sc.gs_lwc.size())
])
percentiles = np.percentile(np.array(lwcs), percentile_list, 0)
def test_compute_lwc_percentiles(self):
# Simulation time axis
year, month, day, hour = 2010, 9, 1, 0
dt = api.deltahours(24)
n_steps = 400
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
# Simulation coordinate system
epsg = "32633"
# Model
model_t = pt_gs_k.PTGSKModel
# Configs and repositories
dataset_config_file = path.join(path.dirname(__file__), "netcdf",
"atnsjoen_datasets.yaml")
region_config_file = path.join(path.dirname(__file__), "netcdf",
"atnsjoen_calibration_region.yaml")
region_config = RegionConfig(region_config_file)
model_config = ModelConfig(self.model_config_file)
dataset_config = YamlContent(dataset_config_file)
region_model_repository = RegionModelRepository(
region_config, model_config, model_t, epsg)
interp_repos = InterpolationParameterRepository(model_config)
netcdf_geo_ts_repos = []
for source in dataset_config.sources:
station_file = source["params"]["stations_met"]
netcdf_geo_ts_repos.append(
GeoTsRepository(source["params"], station_file, ""))
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)
n_cells = simulator.region_model.size()
state_repos = DefaultStateRepository(model_t, n_cells)
cid = 1
simulator.region_model.set_state_collection(cid, True)
simulator.run(time_axis, state_repos.get_state(0))
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 test_run_arome_ensemble(self):
# Simulation time axis
year, month, day, hour = 2015, 7, 26, 0
n_hours = 30
dt = api.deltahours(1)
utc = api.Calendar() # No offset gives Utc
t0 = utc.time(api.YMDhms(year, month, day, hour))
time_axis = api.Timeaxis(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"
# Model
model_t = pt_gs_k.PTGSKOptModel
# Configs and repositories
region_config = RegionConfig(self.region_config_file)
model_config = ModelConfig(self.model_config_file)
region_model_repository = RegionModelRepository(
region_config, model_config, model_t, epsg)
interp_repos = InterpolationParameterRepository(model_config)
base_dir = path.join(shyftdata_dir, "netcdf", "arome")
pattern = "fc*.nc"
try:
geo_ts_repository = AromeDataRepository(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)
n_cells = simulator.region_model.size()
state_repos = DefaultStateRepository(model_t, n_cells)
simulators = simulator.create_ensembles(time_axis, t0,
state_repos.get_state(0))
for s in simulators:
s.simulate()
def run_simulator(self, model_t):
# Simulation time axis
dt0 = api.YMDhms(2015, 8, 24, 6)
n_hours = 30
dt = api.deltahours(1)
utc = api.Calendar() # No offset gives Utc
t0 = utc.time(dt0)
time_axis = api.Timeaxis(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_config = RegionConfig(self.region_config_file)
model_config = ModelConfig(self.model_config_file)
region_model_repository = RegionModelRepository(
region_config, model_config, model_t, epsg)
interp_repos = InterpolationParameterRepository(model_config)
date_str = "{}{:02}{:02}_{:02}".format(dt0.year, dt0.month, dt0.day,
dt0.hour)
base_dir = path.join(shyftdata_dir, "repository",
"arome_data_repository")
f1 = "arome_metcoop_red_default2_5km_{}.nc".format(date_str)
f2 = "arome_metcoop_red_test2_5km_{}.nc".format(date_str)
ar1 = AromeDataRepository(epsg,
base_dir,
filename=f1,
allow_subset=True)
ar2 = AromeDataRepository(epsg,
base_dir,
filename=f2,
elevation_file=f1,
allow_subset=True)
geo_ts_repository = GeoTsRepositoryCollection([ar1, ar2])
simulator = DefaultSimulator(region_id, interpolation_id,
region_model_repository,
geo_ts_repository, interp_repos, None)
n_cells = simulator.region_model.size()
state_repos = DefaultStateRepository(model_t, n_cells)
simulator.run(time_axis, state_repos.get_state(0))
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 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
year, month, day, hour = 2010, 9, 1, 0
dt = api.deltahours(24)
n_steps = 400
utc = api.Calendar() # No offset gives Utc
t0 = utc.time(api.YMDhms(year, month, day, hour))
time_axis = api.Timeaxis(t0, dt, n_steps)
# Some fake ids
region_id = 0
interpolation_id = 0
# Simulation coordinate system
epsg = "32633"
# Model
model_t = pt_gs_k.PTGSKOptModel
# Configs and repositories
dataset_config_file = path.join(path.dirname(__file__), "netcdf",
"atnsjoen_datasets.yaml")
region_config_file = path.join(path.dirname(__file__), "netcdf",
"atnsjoen_calibration_region.yaml")
region_config = RegionConfig(region_config_file)
model_config = ModelConfig(self.model_config_file)
dataset_config = YamlContent(dataset_config_file)
region_model_repository = RegionModelRepository(
region_config, model_config, model_t, epsg)
interp_repos = InterpolationParameterRepository(model_config)
netcdf_geo_ts_repos = []
for source in dataset_config.sources:
station_file = source["params"]["stations_met"]
netcdf_geo_ts_repos.append(
GeoTsRepository(source["params"], station_file, ""))
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)
n_cells = simulator.region_model.size()
state_repos = DefaultStateRepository(model_t, n_cells)
simulator.run(time_axis, state_repos.get_state(0))
cid = 1
target_discharge = 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(api.YMDhms(2011, 4, 1, 0))
# kirchner_time_axis = api.Timeaxis(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(api.YMDhms(2010, 11, 1, 0))
gs_time_axis = api.Timeaxis(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])
t_vs = np.array(target_discharge.v)
t_ts = np.array(
[target_discharge.time(i) for i in range(target_discharge.size())])
f_vs = np.array(found_discharge.v)
f_ts = np.array(
[found_discharge.time(i) for i in range(found_discharge.size())])
def interpolation_repository(self):
return InterpolationParameterRepository(InterpolationConfig())
def construct_repos(self, overrides):
"""
Construct repositories
"""
# Read region, model and datasets config files
region_config_file = os.path.join(self.config_dir,
self.region_config_file)
self.region_config = RegionConfig(region_config_file)
self.model_config_file = os.path.join(self.config_dir,
self.model_config_file)
model_config = ModelConfig(self.model_config_file,
overrides=overrides.get("model", {}))
datasets_config_file = os.path.join(self.config_dir,
self.datasets_config_file)
datasets_config = YamlContent(datasets_config_file)
interpolation_config_file = os.path.join(
self.config_dir, self.interpolation_config_file)
interpolation_config = InterpolationConfig(interpolation_config_file)
# Construct RegionModelRepository
self.region_model = region_model_repo_constructor(
self.region_config.repository()['class'], self.region_config,
model_config, self.region_model_id)
# Construct InterpolationParameterRepository
self.interp_repos = InterpolationParameterRepository(
interpolation_config)
# Construct GeoTsRepository
self.geo_ts = geots_repo_from_config(
datasets_config_file,
self.region_config.domain()["EPSG"])
# Construct destination repository
self.dst_repo = []
if hasattr(datasets_config, 'destinations'):
for repo in datasets_config.destinations:
repo['repository'] = target_repo_constructor(
repo['repository'], repo['params'])
#[dst['time_axis'].update({'start_datetime': utctime_from_datetime(dst['time_axis']['start_datetime'])})
# for dst in repo['1D_timeseries'] if dst['time_axis'] is not None]
[
dst.update({'time_axis': self.time_axis})
if dst['time_axis'] is None else dst.update({
'time_axis':
api.Timeaxis(
utctime_from_datetime(
dst['time_axis']['start_datetime']),
dst['time_axis']['time_step_length'],
dst['time_axis']['number_of_steps'])
}) for dst in repo['1D_timeseries']
]
self.dst_repo.append(repo)
# Construct reference data repository
self.ref_repo = []
if hasattr(self, 'references'):
for repo in self.references:
repo_ = target_repo_constructor(repo['repository'],
repo['params'])
[dst.update({'repo': repo_}) for dst in repo['1D_timeseries']]
self.ref_repo.extend(repo['1D_timeseries'])
# Construct StateRepository
if hasattr(self, 'initial_state'):
self.initial_state_repo = self.initial_state['repository'][
'class'](**self.initial_state['repository']['params'])
if hasattr(self, 'end_state'):
self.end_state_repo = self.end_state['repository']['class'](
**self.end_state['repository']['params'])
def construct_interp_repo(interp_config):
return InterpolationParameterRepository(interp_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])
init_values = {'gs': {'acc_melt': 0.0,
'albedo': 0.65,
'alpha': 6.25,
'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())
'max_distance': 600000.0,
'max_members': 10,
'distance_measure_factor': 1
}
},
'relative_humidity': {
'method': 'idw',
'params': {
'max_distance': 600000.0,
'max_members': 10,
'distance_measure_factor': 1
}
}
}
interpolation_repository = InterpolationParameterRepository(InterpolationConfig())
del InterpolationConfig
class HbvRegionModelRepository(RegionModelRepository):
"""
Statkraft GIS service based version of repository for RegionModel objects.
"""
def __init__(self, region_id_config):
"""
Parameters
----------
region_id_config: dictionary(region_id:HbvRegionModelConfig)
"""
self._region_id_config = region_id_config