def test_end_state_reported(self):
settings = self.setoptions(self.settings_file, ['repEndMaps', 'repStateMaps', 'repDischargeMaps'])
lisfloodexe(settings)
maskinfo = MaskInfo.instance()
comparator = NetCDFComparator(maskinfo.info.mask)
end_files = [os.path.join(settings.output_dir, f) for f in os.listdir(settings.output_dir) if f.endswith('.end.nc')]
state_files = [os.path.join(settings.output_dir, f) for f in os.listdir(settings.output_dir) if f.endswith('.nc') and '.end.' not in f]
assert end_files
assert state_files
# assert that unique timestep in end maps is equal to last timestep in state maps
errors = []
for end_file in end_files:
basename = end_file.replace('.end.nc', '')
state_file = '{}.nc'.format(basename)
if not os.path.exists(state_file):
continue
state_nc = Dataset(state_file)
end_nc = Dataset(end_file)
var_name = [k for k in state_nc.variables if len(state_nc.variables[k].dimensions) == 3][0]
vara = state_nc.variables[var_name]
varb = end_nc.variables['{}.end'.format(var_name)]
assert 'time' not in end_nc.variables
# compare latest timestep in state map with unique timestep in end map
err = comparator.compare_arrays(vara[-1][:, :], varb[:, :], varname=basename)
if err:
errors.append(err)
assert not errors
def test_state_reported(self):
settings = self.setoptions(self.settings_file, ['repStateMaps'])
lisfloodexe(settings)
no_files = [os.path.join(settings.output_dir, f) for f in os.listdir(settings.output_dir) if f.endswith('.end.nc')]
files = [os.path.join(settings.output_dir, f) for f in os.listdir(settings.output_dir) if f.endswith('.nc') and '.end.' not in f]
assert files
assert not no_files
def _not_reported_map(self,
settings_file,
opts_to_set=None,
opts_to_unset=None,
map_to_check=None,
mocker=None):
if isinstance(map_to_check, str):
# single map to check in writenet calls args
map_to_check = [map_to_check]
settings = self.setoptions(settings_file, opts_to_set, opts_to_unset)
mock_api = mocker.MagicMock(name='writenet')
mock_api.side_effect = self.dummywritenet
mocker.patch('lisflood.global_modules.output.writenet', new=mock_api)
mock_api2 = mocker.MagicMock(name='timeseries')
mocker.patch('lisflood.global_modules.output.TimeoutputTimeseries',
new=mock_api2)
mock_api3 = mocker.MagicMock(name='reportpcr')
mocker.patch('lisflood.global_modules.output.report', new=mock_api3)
lisfloodexe(settings)
res = True
for c in lisflood.global_modules.output.writenet.call_args_list:
args, kwargs = c
if any(m == args[4] for m in map_to_check):
res = False
break
assert res
def test_dates_steps_6h(self):
settings_a = self.setoptions(self.settings_files['full'],
opts_to_set=['repStateMaps', 'repEndMaps', 'repDischargeMaps',
'repSnowMaps', 'repLZMaps', 'repUZMaps'],
vars_to_set={'StepStart': '30/07/2016 06:00', 'StepEnd': '31/07/2016 18:00',
'DtSec': '21600',
'PathOut': '$(PathRoot)/out/1'}
)
mk_path_out('data/LF_ETRS89_UseCase/out/1')
lisfloodexe(settings_a)
settings_b = self.setoptions(self.settings_files['full'],
opts_to_set=['repStateMaps', 'repEndMaps', 'repDischargeMaps',
'repSnowMaps', 'repLZMaps', 'repUZMaps'],
vars_to_set={'StepStart': 24225, 'StepEnd': 24231,
'DtSec': '21600',
'PathOut': '$(PathRoot)/out/2'})
mk_path_out('data/LF_ETRS89_UseCase/out/2')
lisfloodexe(settings_b)
assert settings_a.step_start_int == 24225
assert settings_a.step_end_int == 24231
assert settings_a.step_start == settings_a.step_start_dt.strftime('%d/%m/%Y %H:%M')
assert settings_a.step_end == settings_a.step_end_dt.strftime('%d/%m/%Y %H:%M')
assert settings_b.step_start_dt == datetime.datetime(2016, 7, 30, 6, 0)
assert settings_b.step_end_dt == datetime.datetime(2016, 7, 31, 18, 0)
comparator = NetCDFComparator(settings_a.maskpath, array_equal=True)
out_a = settings_a.output_dir
out_b = settings_b.output_dir
comparator.compare_dirs(out_a, out_b)
def run(self, dt_sec, step_start, step_end):
output_dir = mk_path_out(
'data/LF_ETRS89_UseCase/out/test_results{}'.format(dt_sec))
opts_to_unset = ("repStateSites", "repRateSites", "repStateUpsGauges",
"repRateUpsGauges", "repMeteoUpsGauges",
"repsimulateLakes", "repStateMaps",
"repsimulateReservoirs", "repSnowMaps", "repPFMaps",
"repLZMaps", "repUZMaps", "repGwPercUZLZMaps",
"repRWS", "repTotalWUse", "repWIndex",
"repSurfaceRunoffMaps", "repRainMaps", "repSnowMaps",
"repSnowCoverMaps", "repSnowMeltMaps", "repThetaMaps",
"repThetaForestMaps", "repLZMaps", "repUZMaps",
"repGwPercUZLZMaps", "repRWS", "repPFMaps",
"repPFForestMaps")
settings = setoptions(self.settings_files['base'],
opts_to_set=(
'repDischargeTs',
'repDischargeMaps',
) + self.modules_to_set,
opts_to_unset=opts_to_unset,
vars_to_set={
'StepStart': step_start,
'StepEnd': step_end,
'DtSec': dt_sec,
'PathOut': output_dir
})
lisfloodexe(settings)
def test_rice_only(self, mocker):
settings = self.setoptions(self.settings_files['base'],
'riceIrrigation')
mock_api = mocker.MagicMock(name='loadmap')
mock_api2 = mocker.MagicMock(name='loadmap_notcalled')
mock_api.side_effect = self.dummyloadmap
mock_api2.side_effect = self.dummyloadmap
mocker.patch('lisflood.hydrological_modules.riceirrigation.loadmap',
new=mock_api)
mocker.patch('lisflood.hydrological_modules.reservoir.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.evapowater.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.waterabstraction.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.inflow.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.lakes.loadmap',
new=mock_api2)
lisfloodexe(settings)
calls = [
call('RiceFlooding'),
call('RicePercolation'),
call('RicePlantingDay1'),
call('RiceHarvestDay1'),
call('RicePlantingDay2'),
call('RiceHarvestDay2'),
]
lisflood.hydrological_modules.riceirrigation.loadmap.assert_has_calls(
calls)
assert not lisflood.hydrological_modules.waterabstraction.loadmap.called
assert not lisflood.hydrological_modules.evapowater.loadmap.called
assert not lisflood.hydrological_modules.reservoir.loadmap.called
assert not lisflood.hydrological_modules.inflow.loadmap.called
assert not lisflood.hydrological_modules.lakes.loadmap.called
def run_subcathmenttest_by_dtsec(self, dt_sec, step_end, step_start, report_steps='1..9999', wateruse_on=False):
modules_to_unset = self.modules_to_unset if not wateruse_on else []
modules_to_set = self.modules_to_unset if wateruse_on else []
# long run entire domain
path_out_domain = mk_path_out('data/LF_ETRS89_UseCase/out/longrun_domain{}'.format(dt_sec))
settings_longrun = self.setoptions(self.settings_files['cold'], opts_to_unset=modules_to_unset,
opts_to_set=modules_to_set,
vars_to_set={'StepStart': step_start,
'StepEnd': step_end,
'PathOut': path_out_domain,
'ReportSteps': report_steps,
'DtSec': dt_sec})
# ** execute
lisfloodexe(settings_longrun)
# long run entire on subdomain
path_out_subdomain = mk_path_out('data/LF_ETRS89_UseCase/out/longrun_subdomain{}'.format(dt_sec))
settings_longrun_subdomain = self.setoptions(self.settings_files['cold'], opts_to_unset=modules_to_unset,
vars_to_set={'StepStart': step_start,
'StepEnd': step_end,
'PathOut': path_out_subdomain,
'ReportSteps': report_steps,
'MaskMap': '$(PathRoot)/maps/subcatchment_mask.map',
'DtSec': dt_sec})
# ** execute
lisfloodexe(settings_longrun_subdomain)
# ****** compare *******
# compare using the last maskmap (subcatchment_mask.map)
settings = LisSettings.instance()
nc_comparator = NetCDFComparator(settings.maskpath, array_equal=True)
nc_comparator.compare_dirs(path_out_subdomain, path_out_domain)
def test_pf_only(self, mocker):
settings = self.setoptions(self.settings_files['base'], 'simulatePF')
mock_api = mocker.MagicMock(name='loadmap')
mock_api2 = mocker.MagicMock(name='loadmap_notcalled')
mock_api.side_effect = self.dummyloadmap
mock_api2.side_effect = self.dummyloadmap
mocker.patch('lisflood.hydrological_modules.soil.loadmap',
new=mock_api)
mocker.patch('lisflood.hydrological_modules.riceirrigation.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.reservoir.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.evapowater.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.waterabstraction.loadmap',
new=mock_api2)
lisfloodexe(settings)
calls = [
call('HeadMax'),
]
lisflood.hydrological_modules.soil.loadmap.assert_has_calls(calls)
assert not lisflood.hydrological_modules.riceirrigation.loadmap.called
assert not lisflood.hydrological_modules.waterabstraction.loadmap.called
assert not lisflood.hydrological_modules.evapowater.loadmap.called
assert not lisflood.hydrological_modules.reservoir.loadmap.called
def test_lakes_only(self, mocker):
settings = self.setoptions(self.settings_file, 'simulateLakes')
mock_api = mocker.MagicMock(name='loadmap')
mock_api.side_effect = self.dummyloadmap
mocker.patch('lisflood.hydrological_modules.lakes.loadmap',
new=mock_api)
lisfloodexe(settings)
calls = [call('LakeSites')]
lisflood.hydrological_modules.lakes.loadmap.assert_has_calls(calls)
def test_no_reported(self):
path_out = mk_path_out('data/LF_ETRS89_UseCase/out/testrep')
settings = self.setoptions(self.settings_files['base'],
vars_to_set={'PathOut': path_out})
lisfloodexe(settings)
files = [
os.path.join(settings.output_dir, f)
for f in os.listdir(settings.output_dir)
if f.endswith('.nc') or f.endswith('.tss')
]
assert not files
def run_init(self, dt_sec, step_start, step_end):
path_out_init = mk_path_out(
'data/LF_ETRS89_UseCase/out/test_init_{}'.format(dt_sec))
settings = setoptions(self.settings_files['prerun'],
opts_to_set=self.modules_to_set,
vars_to_set={
'DtSec': dt_sec,
'PathOut': path_out_init,
'StepStart': step_start,
'StepEnd': step_end,
})
lisfloodexe(settings)
def test_dates_steps_day(self):
settings_a = self.setoptions(self.settings_file,
opts_to_set=[
'repStateMaps', 'repEndMaps',
'repDischargeMaps', 'repSnowMaps',
'repLZMaps', 'repUZMaps'
],
opts_to_unset=['simulateLakes'])
lisfloodexe(settings_a)
settings_b = self.setoptions(self.settings_file,
opts_to_set=[
'repStateMaps', 'repEndMaps',
'repDischargeMaps', 'repSnowMaps',
'repLZMaps', 'repUZMaps'
],
opts_to_unset=['simulateLakes'],
vars_to_set={
'StepStart': 213,
'StepEnd': 215,
'PathOut':
'$(PathRoot)/outputs/compare'
})
lisfloodexe(settings_b)
assert settings_a.step_start_int == 213
assert settings_a.step_end_int == 215
assert settings_a.step_start == settings_a.step_start_dt.strftime(
'%d/%m/%Y %H:%M')
assert settings_a.step_end == settings_a.step_end_dt.strftime(
'%d/%m/%Y %H:%M')
assert settings_b.step_start_dt == datetime.datetime(2000, 7, 30, 6, 0)
assert settings_b.step_end_dt == datetime.datetime(2000, 8, 1, 6, 0)
maskinfo = MaskInfo.instance()
comparator = NetCDFComparator(maskinfo.info.mask)
out_a = settings_a.output_dir
out_b = settings_b.output_dir
errors = comparator.compare_dirs(out_a, out_b)
assert not errors
rm_files = [
os.path.join(out_a, f) for f in os.listdir(out_a)
if f.endswith('.nc') or f.endswith('.tss')
]
rm_files += [
os.path.join(out_b, f) for f in os.listdir(out_b)
if f.endswith('.nc') or f.endswith('.tss')
]
for f in rm_files:
os.unlink(f)
def test_reservoirs_only(self, mocker):
settings = self.setoptions(self.settings_file, 'simulateReservoirs')
mock_api = mocker.MagicMock(name='loadmap')
mock_api.side_effect = self.dummyloadmap
mocker.patch('lisflood.hydrological_modules.reservoir.loadmap',
new=mock_api)
lisfloodexe(settings)
calls = [
call('ReservoirSites'),
call('ReservoirSites', pcr=True),
call('adjust_Normal_Flood'),
call('ReservoirRnormqMult'),
call('ReservoirInitialFillValue')
]
lisflood.hydrological_modules.reservoir.loadmap.assert_has_calls(calls)
def _not_reported_tss(self, settings_file, opts_to_set=None, opts_to_unset=None, tss_to_check=None, mocker=None):
if isinstance(tss_to_check, str):
tss_to_check = [tss_to_check]
settings = self.setoptions(settings_file, opts_to_set, opts_to_unset)
mock_api = mocker.MagicMock(name='timeseries')
mocker.patch('lisflood.global_modules.output.TimeoutputTimeseries', new=mock_api)
lisfloodexe(settings)
assert len(lisflood.global_modules.output.TimeoutputTimeseries.call_args_list) > 0
res = True
for c in lisflood.global_modules.output.TimeoutputTimeseries.call_args_list:
args, kwargs = c
if any(tss == args[0] for tss in tss_to_check):
res = False
break
assert res
def _reported_tss(self, settings_file, opts_to_set=None, opts_to_unset=None, tss_to_check=None, mocker=None):
if isinstance(tss_to_check, str):
tss_to_check = [tss_to_check]
settings = self.setoptions(settings_file, opts_to_set, opts_to_unset)
mock_api = mocker.MagicMock(name='timeseries')
mocker.patch('lisflood.global_modules.output.TimeoutputTimeseries', new=mock_api)
lisfloodexe(settings)
assert len(lisflood.global_modules.output.TimeoutputTimeseries.call_args_list) > 0
to_check = copy(tss_to_check)
for c in lisflood.global_modules.output.TimeoutputTimeseries.call_args_list:
args, kwargs = c
for tss in tss_to_check:
if tss in args[0]:
to_check.remove(tss)
if not to_check:
break
assert not to_check
def test_state_reported(self):
path_out = mk_path_out('data/LF_ETRS89_UseCase/out/testrep')
settings = self.setoptions(self.settings_files['base'],
['repStateMaps'],
vars_to_set={'PathOut': path_out})
lisfloodexe(settings)
no_files = [
os.path.join(settings.output_dir, f)
for f in os.listdir(settings.output_dir) if f.endswith('.end.nc')
]
files = [
os.path.join(settings.output_dir, f)
for f in os.listdir(settings.output_dir)
if f.endswith('.nc') and '.end.' not in f
]
assert files
assert not no_files
def _reported_map(self, settings_file, opts_to_set=None, opts_to_unset=None,
map_to_check=None, mocker=None, files_to_check=None):
"""
Check that writenet function was called for the list of maps to check and that files are correctly named
:param settings_file:
:param opts_to_set:
:param opts_to_unset:
:param map_to_check:
:param mocker:
:param files_to_check:
:return:
"""
if isinstance(map_to_check, str):
# single map to check in writenet calls args
map_to_check = [map_to_check]
elif not map_to_check:
map_to_check = []
if not files_to_check:
files_to_check = []
settings = self.setoptions(settings_file, opts_to_set, opts_to_unset)
mock_api = mocker.MagicMock(name='writenet')
mock_api.side_effect = self.dummywritenet
mocker.patch('lisflood.global_modules.output.writenet', new=mock_api)
lisfloodexe(settings)
assert len(lisflood.global_modules.output.writenet.call_args_list) > 0
to_check = copy(map_to_check)
f_to_check = copy(files_to_check)
for c in lisflood.global_modules.output.writenet.call_args_list:
args, kwargs = c
for m in map_to_check:
if m == args[4] and m in to_check:
to_check.remove(m)
if not to_check:
break
path = Path(args[2]).name
for f in files_to_check:
if f == path and f in f_to_check:
f_to_check.remove(f)
if not f_to_check:
break
assert not to_check
assert not f_to_check
def test_dates_before_1970(self):
settings = self.setoptions(self.settings_files['full'],
opts_to_set=[
'repStateMaps', 'repEndMaps',
'repDischargeMaps', 'repSnowMaps',
'repLZMaps', 'repUZMaps'
],
vars_to_set={
'StepStart': '01/01/1951 06:00',
'StepEnd': '05/01/1951 06:00',
'CalendarDayStart': '01/01/1900 00:00',
'DtSec': '21600',
'PathOut': '$(PathRoot)/out/0',
'PathMeteo': '$(PathRoot)/meteo_1950'
})
mk_path_out('data/LF_ETRS89_UseCase/out/0')
lisfloodexe(settings)
assert settings.step_start_int == 74510
assert settings.step_end_int == 74526
assert settings.step_start_dt == datetime.datetime(1951, 1, 1, 6, 0)
assert settings.step_end_dt == datetime.datetime(1951, 1, 5, 6, 0)
def test_end_state_reported(self):
path_out = mk_path_out('data/LF_ETRS89_UseCase/out/testrep')
settings = self.setoptions(
self.settings_files['base'],
['repEndMaps', 'repStateMaps', 'repDischargeMaps'],
vars_to_set={'PathOut': path_out})
lisfloodexe(settings)
comparator = NetCDFComparator(settings.maskpath, array_equal=True)
end_files = [
os.path.join(settings.output_dir, f)
for f in os.listdir(settings.output_dir) if f.endswith('.end.nc')
]
state_files = [
os.path.join(settings.output_dir, f)
for f in os.listdir(settings.output_dir)
if f.endswith('.nc') and '.end.' not in f
]
assert end_files
assert state_files
# assert that unique timestep in end maps is equal to last timestep in state maps
for end_file in end_files:
basename = end_file.replace('.end.nc', '')
state_file = '{}.nc'.format(basename)
if not os.path.exists(state_file):
continue
state_nc = Dataset(state_file)
end_nc = Dataset(end_file)
var_name = [
k for k in state_nc.variables
if len(state_nc.variables[k].dimensions) == 3
][0]
vara = state_nc.variables[var_name]
varb = end_nc.variables['{}.end'.format(var_name)]
assert 'time' not in end_nc.variables
# compare latest timestep in state map with unique timestep in end map
comparator.compare_arrays(vara[-1][:, :],
varb[:, :],
varname=basename)
assert not comparator.errors
def test_basic(self, mocker):
settings = self.setoptions(self.settings_files['base'])
mock_api = mocker.MagicMock(name='loadmap_notcalled')
mock_api2 = mocker.MagicMock(name='loadmap')
mock_api.side_effect = self.dummyloadmap
mock_api2.side_effect = self.dummyloadmap
mocker.patch('lisflood.hydrological_modules.reservoir.loadmap',
new=mock_api)
mocker.patch('lisflood.hydrological_modules.evapowater.loadmap',
new=mock_api)
mocker.patch('lisflood.hydrological_modules.waterabstraction.loadmap',
new=mock_api)
mocker.patch('lisflood.hydrological_modules.inflow.loadmap',
new=mock_api)
mocker.patch('lisflood.hydrological_modules.lakes.loadmap',
new=mock_api)
mocker.patch('lisflood.hydrological_modules.riceirrigation.loadmap',
new=mock_api)
mocker.patch('lisflood.hydrological_modules.transmission.loadmap',
new=mock_api)
mocker.patch('lisflood.hydrological_modules.waterabstraction.loadmap',
new=mock_api)
mocker.patch('lisflood.hydrological_modules.routing.loadmap',
new=mock_api2)
lisfloodexe(settings)
calls = [
call('CrossSection2AreaInitValue'),
call('PrevSideflowInitValue'),
]
for c in calls:
assert c not in lisflood.hydrological_modules.routing.loadmap.mock_calls
assert not lisflood.hydrological_modules.reservoir.loadmap.called
assert not lisflood.hydrological_modules.evapowater.loadmap.called
assert not lisflood.hydrological_modules.waterabstraction.loadmap.called
assert not lisflood.hydrological_modules.inflow.loadmap.called
assert not lisflood.hydrological_modules.lakes.loadmap.called
assert not lisflood.hydrological_modules.riceirrigation.loadmap.called
assert not lisflood.hydrological_modules.transmission.loadmap.called
assert not lisflood.hydrological_modules.waterabstraction.loadmap.called
def test_split_routing_only(self, mocker):
settings = self.setoptions(self.settings_file, 'SplitRouting')
mock_api = mocker.MagicMock(name='loadmap')
mock_api2 = mocker.MagicMock(name='loadmap_notcalled')
mock_api.side_effect = self.dummyloadmap
mock_api2.side_effect = self.dummyloadmap
mocker.patch('lisflood.hydrological_modules.routing.loadmap',
new=mock_api)
mocker.patch('lisflood.hydrological_modules.reservoir.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.evapowater.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.waterabstraction.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.inflow.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.lakes.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.riceirrigation.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.transmission.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.waterabstraction.loadmap',
new=mock_api2)
lisfloodexe(settings)
calls = [
call('CrossSection2AreaInitValue'),
call('PrevSideflowInitValue'),
]
lisflood.hydrological_modules.routing.loadmap.assert_has_calls(calls)
assert not lisflood.hydrological_modules.reservoir.loadmap.called
assert not lisflood.hydrological_modules.evapowater.loadmap.called
assert not lisflood.hydrological_modules.waterabstraction.loadmap.called
assert not lisflood.hydrological_modules.inflow.loadmap.called
assert not lisflood.hydrological_modules.lakes.loadmap.called
assert not lisflood.hydrological_modules.riceirrigation.loadmap.called
assert not lisflood.hydrological_modules.transmission.loadmap.called
assert not lisflood.hydrological_modules.waterabstraction.loadmap.called
def test_waterabstraction_only(self, mocker):
settings = self.setoptions(self.settings_files['base'], [
'groundwaterSmooth', 'wateruse', 'TransientWaterDemandChange',
'wateruseRegion'
])
mock_api = mocker.MagicMock(name='loadmap')
mock_api2 = mocker.MagicMock(name='loadmap_notcalled')
mock_api.side_effect = self.dummyloadmap
mock_api2.side_effect = self.dummyloadmap
mocker.patch('lisflood.hydrological_modules.transmission.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.inflow.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.lakes.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.riceirrigation.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.reservoir.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.evapowater.loadmap',
new=mock_api2)
mocker.patch('lisflood.hydrological_modules.waterabstraction.loadmap',
new=mock_api)
lisfloodexe(settings)
assert not lisflood.hydrological_modules.riceirrigation.loadmap.called
assert not lisflood.hydrological_modules.transmission.loadmap.called
assert not lisflood.hydrological_modules.inflow.loadmap.called
assert not lisflood.hydrological_modules.lakes.loadmap.called
assert not lisflood.hydrological_modules.evapowater.loadmap.called
assert not lisflood.hydrological_modules.reservoir.loadmap.called
calls = [
call('WUsePercRemain'),
call('maxNoWateruse'),
call('GroundwaterBodies'),
call('WUseRegion'),
]
for c in calls:
assert c in lisflood.hydrological_modules.waterabstraction.loadmap.mock_calls
def test_initvars(self):
output_dir = mk_path_out(
'data/LF_ETRS89_UseCase/out/test_results_initvars')
opts_to_unset = ("repStateSites", "repRateSites", "repStateUpsGauges",
"repRateUpsGauges", "repMeteoUpsGauges",
"repsimulateLakes", "repStateMaps",
"repsimulateReservoirs", "repSnowMaps", "repPFMaps",
"repLZMaps", "repUZMaps", "repGwPercUZLZMaps",
"repRWS", "repTotalWUse", "repWIndex",
"repSurfaceRunoffMaps", "repRainMaps", "repSnowMaps",
"repSnowCoverMaps", "repSnowMeltMaps", "repThetaMaps",
"repThetaForestMaps", "repLZMaps", "repUZMaps",
"repDischargeTs", "repDischargeMaps",
"repGwPercUZLZMaps", "repRWS", "repPFMaps",
"repPFForestMaps")
settings = setoptions(self.settings_files['base'],
opts_to_set=('repEndMaps', ) +
self.modules_to_set,
opts_to_unset=opts_to_unset,
vars_to_set={
'StepStart': '02/02/2016 06:00',
'StepEnd': '05/02/2016 06:00',
'PathOut': output_dir
})
lisfloodexe(settings)
initcond_files = ('ch2cr.end.nc', 'chcro.end.nc', 'chside.end.nc',
'cseal.end.nc', 'cum.end.nc', 'cumf.end.nc',
'cumi.end.nc', 'dis.end.nc', 'dslf.end.nc',
'dsli.end.nc', 'dslr.end.nc', 'frost.end.nc',
'lz.end.nc', 'rsfil.end.nc', 'scova.end.nc',
'scovb.end.nc', 'scovc.end.nc', 'tha.end.nc',
'thb.end.nc', 'thc.end.nc', 'thfa.end.nc',
'thfb.end.nc', 'thfc.end.nc', 'thia.end.nc',
'thib.end.nc', 'thic.end.nc', 'uz.end.nc',
'uzf.end.nc', 'uzi.end.nc', 'wdept.end.nc')
for f in initcond_files:
assert os.path.exists(os.path.join(output_dir, f))
def test_raisexc(self):
with pytest.raises(LisfloodError) as e:
assert lisfloodexe(self.settings_path)
assert 'Option timestepInit was not parsable.' in str(e.value)
def run_warmstart_by_dtsec(self,
dt_sec,
step_end,
step_start,
report_steps='1..9999'):
modules_to_unset = [
'simulateReservoirs',
'repsimulateReservoirs',
'wateruse',
'useWaterDemandAveYear',
'wateruseRegion',
]
check_every = 13 # steps
# init
path_out_init = mk_path_out(
'data/LF_ETRS89_UseCase/out/init{}'.format(dt_sec))
settings_prerun = self.setoptions(self.settings_files['prerun'],
opts_to_unset=modules_to_unset,
vars_to_set={
'DtSec': dt_sec,
'PathOut': path_out_init,
'StepStart': step_start,
'ReportSteps': report_steps,
'StepEnd': step_end
})
step_end_dt = settings_prerun.step_end_dt
# ** execute
lisfloodexe(settings_prerun)
# long run
lzavin_path = settings_prerun.binding['LZAvInflowMap']
avgdis_path = settings_prerun.binding['AvgDis']
path_out_reference = mk_path_out(
'data/LF_ETRS89_UseCase/out/longrun_reference{}'.format(dt_sec))
settings_longrun = self.setoptions(self.settings_files['cold'],
opts_to_unset=modules_to_unset,
vars_to_set={
'StepStart': step_start,
'StepEnd': step_end,
'LZAvInflowMap': lzavin_path,
'PathOut': path_out_reference,
'AvgDis': avgdis_path,
'ReportSteps': report_steps,
'DtSec': dt_sec
})
# ** execute
lisfloodexe(settings_longrun)
# warm run (1. Cold start)
run_number = 1
cold_start_step_end = step_start
path_out = mk_path_out('data/LF_ETRS89_UseCase/out/run{}_{}'.format(
dt_sec, run_number))
settings_coldstart = self.setoptions(self.settings_files['cold'],
opts_to_unset=modules_to_unset,
vars_to_set={
'StepStart': step_start,
'StepEnd':
cold_start_step_end,
'LZAvInflowMap': lzavin_path,
'PathOut': path_out,
'AvgDis': avgdis_path,
'ReportSteps': report_steps,
'DtSec': dt_sec
})
# ** execute
lisfloodexe(settings_coldstart)
# warm run (2. single step warm start/stop with initial conditions from previous run)
prev_settings = settings_coldstart
warm_step_start = prev_settings.step_end_dt + timedelta(seconds=dt_sec)
warm_step_end = warm_step_start
timestep_init = prev_settings.step_end_dt.strftime('%d/%m/%Y %H:%M')
nc_comparator = NetCDFComparator(settings_prerun.maskpath)
tss_comparator = TSSComparator(array_equal=True)
while warm_step_start <= step_end_dt:
run_number += 1
path_init = prev_settings.output_dir
path_out = mk_path_out(
'data/LF_ETRS89_UseCase/out/run{}_{}'.format(
dt_sec, run_number))
settings_warmstart = self.setoptions(
self.settings_files['warm'],
opts_to_unset=modules_to_unset,
vars_to_set={
'StepStart': warm_step_start.strftime('%d/%m/%Y %H:%M'),
'StepEnd': warm_step_end.strftime('%d/%m/%Y %H:%M'),
'LZAvInflowMap': lzavin_path,
'PathOut': path_out,
'PathInit': path_init,
'timestepInit': timestep_init,
'AvgDis': avgdis_path,
'ReportSteps': report_steps,
'DtSec': dt_sec
})
# ** execute
lisfloodexe(settings_warmstart)
# checking values at current timestep (using datetime)
if not (run_number % check_every):
# ****** compare *******
# compare every 13 timesteps to speed up test
timestep_dt = settings_warmstart.step_end_dt # NetCDFComparator takes datetime.datetime as timestep
timestep = settings_warmstart.step_end_int
nc_comparator.compare_dirs(path_out,
path_out_reference,
timestep=timestep_dt)
tss_comparator.compare_dirs(path_out,
path_out_reference,
timestep=timestep)
# setup for next warm start/stop
prev_settings = settings_warmstart
warm_step_start = prev_settings.step_end_dt + timedelta(
seconds=dt_sec)
warm_step_end = warm_step_start
timestep_init = prev_settings.step_end_dt.strftime(
'%d/%m/%Y %H:%M')
def test_no_reported(self):
settings = self.setoptions(self.settings_file)
lisfloodexe(settings)
files = [os.path.join(settings.output_dir, f) for f in os.listdir(settings.output_dir) if f.endswith('.nc') or f.endswith('.tss')]
assert not files
def setup_class(cls):
lisfloodexe(cls.settings_path)
def _reported_map(self,
settings_file,
opts_to_set=None,
opts_to_unset=None,
map_to_check=None,
mocker=None,
files_to_check=None):
"""
Check that writenet function was called for the list of maps to check and that files are correctly named
:param settings_file:
:param opts_to_set:
:param opts_to_unset:
:param map_to_check:
:param mocker:
:param files_to_check:
:return:
"""
if isinstance(map_to_check, str):
# single map to check in writenet calls args
map_to_check = [map_to_check]
elif not map_to_check:
map_to_check = []
if not files_to_check:
files_to_check = []
settings = self.setoptions(settings_file, opts_to_set, opts_to_unset)
mock_api = mocker.MagicMock(name='writenet')
mock_api.side_effect = self.dummywritenet
mocker.patch('lisflood.global_modules.output.writenet', new=mock_api)
mock_api2 = mocker.MagicMock(name='timeseries')
mocker.patch('lisflood.global_modules.output.TimeoutputTimeseries',
new=mock_api2)
mock_api3 = mocker.MagicMock(name='reportpcr')
mocker.patch('lisflood.global_modules.output.report', new=mock_api3)
# ** execute lisflood
lisfloodexe(settings)
assert len(lisflood.global_modules.output.writenet.call_args_list) > 0
to_check = copy(map_to_check)
# remove extensions (in Lisflood settings you can have names like lzavin.map but you check for lzavin.nc)
f_to_check = [os.path.splitext(f)[0] for f in copy(files_to_check)]
for c in lisflood.global_modules.output.writenet.call_args_list:
args, kwargs = c
for m in map_to_check:
if m == args[4] and m in to_check:
to_check.remove(m)
if not to_check:
break
path = os.path.splitext(Path(args[2]).name)[0]
for f in files_to_check:
f = os.path.splitext(f)[0]
if f == path and f in f_to_check:
f_to_check.remove(f)
if not f_to_check:
break
assert not to_check
assert not f_to_check
