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