From a2ef619d7d2358629ac0380500ee32141021fcc6 Mon Sep 17 00:00:00 2001 From: "Leaf, Andrew T" Date: Fri, 29 Apr 2022 08:15:44 -0500 Subject: [PATCH 1/9] refactor(mf6model.py): delete old riv package setup method --- mfsetup/mf6model.py | 55 --------------------------------------------- 1 file changed, 55 deletions(-) diff --git a/mfsetup/mf6model.py b/mfsetup/mf6model.py index b9d8e0a4..cf61ea9f 100644 --- a/mfsetup/mf6model.py +++ b/mfsetup/mf6model.py @@ -701,61 +701,6 @@ def setup_lak(self, **kwargs): print("finished in {:.2f}s\n".format(time.time() - t0)) return lak - def setup_riv_old(self, rivdata=None, **kwargs): - """Set up River Package. - """ - package = 'riv' - print(f'\nSetting up {package.upper()} package...') - t0 = time.time() - - # RIV package from user input - if rivdata is None and 'source_data' in kwargs: - df = setup_basic_stress_data(self, **kwargs['source_data'], **kwargs['mfsetup_options']) - - else: - raise NotImplementedError(f"{package.upper()} package configuration file input " - "not understood. See the Configuration " - "File Gallery in the online docs for example input " - "Note that direct input to basic stress period packages " - "is currently not supported.") - if len(df) == 0: - print('No input specified or streams not in model.') - return - - # option to write stress_period_data to external files - external_files = self.cfg[package].get('external_files', True) - external_filename_fmt = self.cfg[package]['mfsetup_options']['external_filename_fmt'] - spd = setup_flopy_stress_period_data(self, package, df, - flopy_package_class=mf6.ModflowGwfriv, - variable_columns=['stage', 'cond', 'rbot'], - external_files=external_files, - external_filename_fmt=external_filename_fmt) - - #if external_files: - # # get the file path (allowing for different external file locations, specified name format, etc.) - # filename_format = package + '_{:03d}.dat' # stress period suffix - # filepaths = self.setup_external_filepaths(package, 'stress_period_data', - # filename_format=filename_format, - # file_numbers=sorted(df.per.unique().tolist())) - #else: - # filepaths = None - # - ## Setup basic stress package stress_period_data for Flopy or Modflow, - ## either as external files or a dictionary of recarrays. - #spd = setup_stress_period_data(df, self, mf6.ModflowGwfriv, - # filepaths=filepaths, - # external_files_folder=self.cfg['intermediate_data']['output_folder']) - - kwargs = self.cfg[package] - # need default options from rivdata instance or cfg defaults - kwargs.update(self.cfg[package]['options']) - kwargs = get_input_arguments(kwargs, mf6.ModflowGwfriv) - if not external_files: - kwargs['stress_period_data'] = spd - riv = mf6.ModflowGwfriv(self, **kwargs) - print("finished in {:.2f}s\n".format(time.time() - t0)) - return riv - def setup_chd(self, **kwargs): """Set up the CHD Package. From 5a15308a471fd1ccad53cdbdcbf7d2022b2023c0 Mon Sep 17 00:00:00 2001 From: "Leaf, Andrew T" Date: Fri, 29 Apr 2022 10:20:39 -0500 Subject: [PATCH 2/9] incomplete: implement specified flux boundaries in model setup workflow * refactor MF6model.setup_wel to follow same structure as other basic stress packages (use the _setup_basic_stress_package fn, which combines perimeter boundaries with user input and for the Well Package, potential input from a parent model) * implement general basic stress package support for MODFLOW-NWT models * move _setup_basic_stress_package to MFsetupMixin to use same workflow for both MODFLOW versions * TODO: get MODFLOW-NWT well package setup tests to pass; either adapt or remove any old tests related to specified flux boundaries * add specified flux perimeter boundary to the config file gallery for a working example * remove old Tmr class from tmr.py and any other kruft * update docs, including limitation that specified flux models must be co-linear --- mfsetup/bcs.py | 3 +- mfsetup/mf6_defaults.yml | 7 +- mfsetup/mf6model.py | 109 ++---------------- mfsetup/mfmodel.py | 126 ++++++++++++++++++++- mfsetup/mfnwt_defaults.yml | 50 +++++++- mfsetup/mfnwtmodel.py | 43 ++++++- mfsetup/tests/test_get_data_from_parent.py | 2 +- mfsetup/tests/test_mf6_shellmound.py | 4 +- mfsetup/tests/test_pleasant_mf6_inset.py | 6 +- mfsetup/tests/test_wateruse.py | 2 +- mfsetup/tests/test_wells.py | 6 +- mfsetup/wells.py | 23 ++-- 12 files changed, 248 insertions(+), 133 deletions(-) diff --git a/mfsetup/bcs.py b/mfsetup/bcs.py index b71f423a..a91de6d6 100644 --- a/mfsetup/bcs.py +++ b/mfsetup/bcs.py @@ -531,6 +531,7 @@ def setup_flopy_stress_period_data(model, package, data, flopy_package_class, else: if model.version == 'mf6': + flopy.modflow.ModflowWel.stress_period_data kspd = flopy_package_class.stress_period_data.empty(model, len(group), boundnames=True)[0] @@ -569,7 +570,7 @@ def setup_flopy_stress_period_data(model, package, data, flopy_package_class, else: for col in variable_columns: kspd[col] = group[col] - if 'boundname' in group.columns: + if 'boundname' in group.columns and 'boundname' in kspd: kspd['boundname'] = group['boundname'] spd[kper] = kspd else: diff --git a/mfsetup/mf6_defaults.yml b/mfsetup/mf6_defaults.yml index 601e4114..7496dabd 100644 --- a/mfsetup/mf6_defaults.yml +++ b/mfsetup/mf6_defaults.yml @@ -220,9 +220,10 @@ wel: output_files: lookup_file: '{}_wel_lookup.csv' # output file that maps wel package data to site numbers dropped_wells_file: '{}_dropped_wells.csv' # output file that records wells that were dropped during model setup - minimum_layer_thickness: 2. - external_files: True # option to write stress_period_data to external files - external_filename_fmt: "wel_{:03d}.dat" + mfsetup_options: + minimum_layer_thickness: 2. + external_files: True # option to write stress_period_data to external files + external_filename_fmt: "wel_{:03d}.dat" diff --git a/mfsetup/mf6model.py b/mfsetup/mf6model.py index cf61ea9f..935cf266 100644 --- a/mfsetup/mf6model.py +++ b/mfsetup/mf6model.py @@ -11,11 +11,7 @@ from flopy.utils.lgrutil import Lgr from gisutils import get_values_at_points -from mfsetup.bcs import ( - remove_inactive_bcs, - setup_basic_stress_data, - setup_flopy_stress_period_data, -) +from mfsetup.bcs import remove_inactive_bcs from mfsetup.discretization import ( ModflowGwfdis, create_vertical_pass_through_cells, @@ -548,7 +544,7 @@ def setup_rch(self, **kwargs): print("finished in {:.2f}s\n".format(time.time() - t0)) return rch - def setup_wel(self, **kwargs): + def setup_wel_old(self, **kwargs): """ Sets up the WEL package. """ @@ -731,102 +727,11 @@ def setup_riv(self, rivdata=None, **kwargs): rivdata=rivdata, **kwargs) - def _setup_basic_stress_package(self, package, flopy_package_class, - variable_columns, rivdata=None, - **kwargs): - print(f'\nSetting up {package.upper()} package...') - t0 = time.time() - - # possible future support to - # handle filenames of multiple packages - # leave this out for now because of additional complexity - # from multiple sets of external files - #existing_packages = getattr(self, package, None) - #filename = f"{self.name}.{package}" - #if existing_packages is not None: - # try: - # len(existing_packages) - # suffix = len(existing_packages) + 1 - # except: - # suffix = 1 - # filename = f"{self.name}-{suffix}.{package}" - - # perimeter boundary (CHD or WEL) - dfs = [] - if 'perimeter_boundary' in kwargs: - perimeter_cfg = kwargs['perimeter_boundary'] - if package == 'chd': - perimeter_cfg['boundary_type'] = 'head' - elif package == 'wel': - perimeter_cfg['boundary_type'] = 'flux' - else: - raise ValueError(f'Unsupported package for perimeter_boundary: {package.upper()}') - if 'inset_parent_period_mapping' not in perimeter_cfg: - perimeter_cfg['inset_parent_period_mapping'] = self.parent_stress_periods - if 'parent_start_time' not in perimeter_cfg: - perimeter_cfg['parent_start_date_time'] = self.parent.perioddata['start_datetime'][0] - self.tmr = TmrNew(self.parent, self, **perimeter_cfg) - df = self.tmr.get_inset_boundary_values() - - # add boundname to allow boundary flux to be tracked as observation - df['boundname'] = 'perimeter-heads' - dfs.append(df) - - # RIV package converted from SFR input - elif rivdata is not None: - if 'name' in rivdata.stress_period_data.columns: - rivdata.stress_period_data['boundname'] = rivdata.stress_period_data['name'] - dfs.append(rivdata.stress_period_data) - - # set up package from user input - if 'source_data' in kwargs: - df_sd = setup_basic_stress_data(self, **kwargs['source_data'], **kwargs['mfsetup_options']) - if df_sd is not None: - dfs.append(df_sd) - - if len(dfs) == 0: - print(f"{package.upper()} package:\n" - "No input specified or package configuration file input " - "not understood. See the Configuration " - "File Gallery in the online docs for example input " - "Note that direct input to basic stress period packages " - "is currently not supported.") - return - else: - df = pd.concat(dfs, axis=0) - - # option to write stress_period_data to external files - external_files = self.cfg[package].get('external_files', True) - external_filename_fmt = self.cfg[package]['mfsetup_options']['external_filename_fmt'] - spd = setup_flopy_stress_period_data(self, package, df, - flopy_package_class=flopy_package_class, - variable_columns=variable_columns, - external_files=external_files, - external_filename_fmt=external_filename_fmt) - - kwargs = self.cfg[package] - kwargs.update(self.cfg[package]['options']) - #kwargs['filename'] = filename - # add observation for perimeter BCs - # and any user input with a boundname col - obslist = [] - obsfile = f'{self.name}.{package}.obs.output.csv' - if 'perimeter_boundary' in kwargs: - perimeter_btype = f"perimeter-{perimeter_cfg['boundary_type']}" - obslist.append((perimeter_btype, package, perimeter_btype)) - if 'boundname' in df.columns: - unique_boundnames = df['boundname'].unique() - for bname in unique_boundnames: - obslist.append((bname, package, bname)) - if len(obslist) > 0: - kwargs['observations'] = {obsfile: obslist} - - kwargs = get_input_arguments(kwargs, flopy_package_class) - if not external_files: - kwargs['stress_period_data'] = spd - pckg = flopy_package_class(self, **kwargs) - print("finished in {:.2f}s\n".format(time.time() - t0)) - return pckg + def setup_wel(self, **kwargs): + """Set up the Well Package. + """ + return self._setup_basic_stress_package( + 'wel', mf6.ModflowGwfwel, ['q'], **kwargs) def setup_obs(self, **kwargs): diff --git a/mfsetup/mfmodel.py b/mfsetup/mfmodel.py index 8186af1c..ca40f482 100644 --- a/mfsetup/mfmodel.py +++ b/mfsetup/mfmodel.py @@ -25,7 +25,11 @@ from sfrmaker import Lines from sfrmaker.utils import assign_layers -from mfsetup.bcs import get_bc_package_cells +from mfsetup.bcs import ( + get_bc_package_cells, + setup_basic_stress_data, + setup_flopy_stress_period_data, +) from mfsetup.config import validate_configuration from mfsetup.fileio import ( check_source_files, @@ -57,8 +61,10 @@ setup_perioddata, setup_perioddata_group, ) +from mfsetup.tmr import TmrNew from mfsetup.units import convert_length_units, lenuni_text, lenuni_values from mfsetup.utils import flatten, get_input_arguments, get_packages, update +from mfsetup.wells import setup_wel_data if version.parse(gisutils.__version__) < version.parse('0.2.2'): warnings.warn('Automatic reprojection functionality requires gis-utils >= 0.2.2' @@ -1256,6 +1262,124 @@ def _setup_array(self, package, var, vmin=-1e30, vmax=1e30, source_model=source_model, source_package=source_package, **kwargs) + def _setup_basic_stress_package(self, package, flopy_package_class, + variable_columns, rivdata=None, + **kwargs): + print(f'\nSetting up {package.upper()} package...') + t0 = time.time() + + # possible future support to + # handle filenames of multiple packages + # leave this out for now because of additional complexity + # from multiple sets of external files + #existing_packages = getattr(self, package, None) + #filename = f"{self.name}.{package}" + #if existing_packages is not None: + # try: + # len(existing_packages) + # suffix = len(existing_packages) + 1 + # except: + # suffix = 1 + # filename = f"{self.name}-{suffix}.{package}" + + # perimeter boundary (CHD or WEL) + dfs = [] + if 'perimeter_boundary' in kwargs: + perimeter_cfg = kwargs['perimeter_boundary'] + if package == 'chd': + perimeter_cfg['boundary_type'] = 'head' + elif package == 'wel': + perimeter_cfg['boundary_type'] = 'flux' + else: + raise ValueError(f'Unsupported package for perimeter_boundary: {package.upper()}') + if 'inset_parent_period_mapping' not in perimeter_cfg: + perimeter_cfg['inset_parent_period_mapping'] = self.parent_stress_periods + if 'parent_start_time' not in perimeter_cfg: + perimeter_cfg['parent_start_date_time'] = self.parent.perioddata['start_datetime'][0] + self.tmr = TmrNew(self.parent, self, **perimeter_cfg) + df = self.tmr.get_inset_boundary_values() + + # add boundname to allow boundary flux to be tracked as observation + df['boundname'] = 'perimeter-heads' + dfs.append(df) + + # RIV package converted from SFR input + elif rivdata is not None: + if 'name' in rivdata.stress_period_data.columns: + rivdata.stress_period_data['boundname'] = rivdata.stress_period_data['name'] + dfs.append(rivdata.stress_period_data) + + # set up package from user input + + if 'source_data' in kwargs: + if package == 'wel': + dropped_wells_file =\ + kwargs['output_files']['dropped_wells_file'].format(self.name) + df_sd = setup_wel_data(self, + source_data=kwargs['source_data'], + dropped_wells_file=dropped_wells_file) + else: + df_sd = setup_basic_stress_data(self, **kwargs['source_data'], **kwargs['mfsetup_options']) + if df_sd is not None: + dfs.append(df_sd) + # set up package from parent model + elif self.cfg['parent'].get('default_source_data') and\ + hasattr(self.parent, package): + if package == 'wel': + dropped_wells_file =\ + kwargs['output_files']['dropped_wells_file'].format(self.name) + df_sd = setup_wel_data(self, + dropped_wells_file=dropped_wells_file) + else: + raise NotImplementedError(f"Setup of {package.upper()} " + "package from the parent model.") + if df_sd is not None: + dfs.append(df_sd) + if len(dfs) == 0: + print(f"{package.upper()} package:\n" + "No input specified or package configuration file input " + "not understood. See the Configuration " + "File Gallery in the online docs for example input " + "Note that direct input to basic stress period packages " + "is currently not supported.") + return + else: + df = pd.concat(dfs, axis=0) + + # option to write stress_period_data to external files + external_files = self.cfg[package]['mfsetup_options'].get('external_files', True) + external_filename_fmt = self.cfg[package]['mfsetup_options']['external_filename_fmt'] + spd = setup_flopy_stress_period_data(self, package, df, + flopy_package_class=flopy_package_class, + variable_columns=variable_columns, + external_files=external_files, + external_filename_fmt=external_filename_fmt) + + kwargs = self.cfg[package] + if isinstance(self.cfg[package]['options'], dict): + kwargs.update(self.cfg[package]['options']) + #kwargs['filename'] = filename + # add observation for perimeter BCs + # and any user input with a boundname col + obslist = [] + obsfile = f'{self.name}.{package}.obs.output.csv' + if 'perimeter_boundary' in kwargs: + perimeter_btype = f"perimeter-{perimeter_cfg['boundary_type']}" + obslist.append((perimeter_btype, package, perimeter_btype)) + if 'boundname' in df.columns: + unique_boundnames = df['boundname'].unique() + for bname in unique_boundnames: + obslist.append((bname, package, bname)) + if len(obslist) > 0: + kwargs['observations'] = {obsfile: obslist} + + kwargs = get_input_arguments(kwargs, flopy_package_class) + if not external_files: + kwargs['stress_period_data'] = spd + pckg = flopy_package_class(self, **kwargs) + print("finished in {:.2f}s\n".format(time.time() - t0)) + return pckg + def setup_grid(self): """Set up the attached modelgrid instance from configuration input """ diff --git a/mfsetup/mfnwt_defaults.yml b/mfsetup/mfnwt_defaults.yml index 5e7849c7..419f83dc 100644 --- a/mfsetup/mfnwt_defaults.yml +++ b/mfsetup/mfnwt_defaults.yml @@ -96,19 +96,61 @@ lak: sfr: +chd: + options: + source_data: + shapefile: + all_touched: True + head: + stat: 'min' + mfsetup_options: + external_files: True # option to write stress_period_data to external files + external_filename_fmt: "chd_{:03d}.dat" + +drn: + options: + source_data: + shapefile: + all_touched: True + elev: + stat: 'min' + mfsetup_options: + external_files: True # option to write stress_period_data to external files + external_filename_fmt: "drn_{:03d}.dat" + +ghb: + options: + source_data: + shapefile: + all_touched: True + bhead: + stat: 'min' + mfsetup_options: + external_files: True # option to write stress_period_data to external files + external_filename_fmt: "ghb_{:03d}.dat" + riv: + source_data: + shapefile: + all_touched: True + stage: + stat: 'min' output_files: rivdata_file: '{}_rivdata.csv' # table with auxillary information on river reaches (routing, source hydrography IDs, etc.) + mfsetup_options: + default_rbot_thickness: 1. + external_files: True # option to write stress_period_data to external files + external_filename_fmt: "riv_{:03d}.dat" wel: options: ['SPECIFY', '0.01'] - source_data: - period_stats: {0: 'mean'} # statistic to apply to each stress period 'mean' to average all data; to average values for a given month across the period (e.g. 'august') output_files: lookup_file: '{}_wel_lookup.csv' # output file that maps wel package data to site numbers dropped_wells_file: '{}_dropped_wells.csv' # output file that records wells that were dropped during model setup - minimum_layer_thickness: 2. - # Note: external files are not yet implemented for the wel package in MODFLOW-NWT models + mfsetup_options: + minimum_layer_thickness: 2. + external_files: True # option to write stress_period_data to external files + external_filename_fmt: "wel_{:03d}.dat" mnw: defaults: {losstype: 'skin', diff --git a/mfsetup/mfnwtmodel.py b/mfsetup/mfnwtmodel.py index ffe3d56e..76e1d6ba 100644 --- a/mfsetup/mfnwtmodel.py +++ b/mfsetup/mfnwtmodel.py @@ -430,7 +430,7 @@ def setup_upw(self, **kwargs): print("finished in {:.2f}s\n".format(time.time() - t0)) return upw - def setup_wel(self, **kwargs): + def setup_wel_old(self, **kwargs): """ Setup the WEL package, including boundary fluxes and any pumping. @@ -469,7 +469,7 @@ def setup_wel(self, **kwargs): print("finished in {:.2f}s\n".format(time.time() - t0)) return wel - def setup_ghb(self, **kwargs): + def setup_ghb_old(self, **kwargs): """ Set up the GHB package """ @@ -683,6 +683,43 @@ def setup_lak(self, **kwargs): print("finished in {:.2f}s\n".format(time.time() - t0)) return lak + + def setup_chd(self, **kwargs): + """Set up the CHD Package. + """ + return self._setup_basic_stress_package( + 'chd', fm.ModflowChd, ['shead', 'ehead'], **kwargs) + + + def setup_drn(self, **kwargs): + """Set up the Drain Package. + """ + return self._setup_basic_stress_package( + 'drn', fm.ModflowDrn, ['stage', 'cond'], **kwargs) + + + def setup_ghb(self, **kwargs): + """Set up the General Head Boundary Package. + """ + return self._setup_basic_stress_package( + 'ghb', fm.ModflowGhb, ['stage', 'cond'], **kwargs) + + + def setup_riv(self, rivdata=None, **kwargs): + """Set up the River Package. + """ + return self._setup_basic_stress_package( + 'riv', fm.ModflowRiv, ['stage', 'cond', 'rbot'], + rivdata=rivdata, **kwargs) + + + def setup_wel(self, **kwargs): + """Set up the Well Package. + """ + return self._setup_basic_stress_package( + 'wel', fm.ModflowWel, ['flux'], **kwargs) + + def setup_nwt(self, **kwargs): print('setting up NWT package...') @@ -806,7 +843,7 @@ def setup_gag(self, **kwargs): print("finished in {:.2f}s\n".format(time.time() - t0)) return gag - def setup_chd(self, **kwargs): + def setup_chd_old(self, **kwargs): """ Sets up the CHD package. """ diff --git a/mfsetup/tests/test_get_data_from_parent.py b/mfsetup/tests/test_get_data_from_parent.py index a3fb2109..2aa8cec4 100644 --- a/mfsetup/tests/test_get_data_from_parent.py +++ b/mfsetup/tests/test_get_data_from_parent.py @@ -120,7 +120,7 @@ def test_get_wel_package_from_parent(input, basic_model_instance, request): if 'source_data' in m.cfg['wel']: del m.cfg['wel']['source_data'] # well package - wel = m.setup_wel() + wel = m.setup_wel(**m.cfg['wel'], **m.cfg['wel']['mfsetup_options']) data = wel.stress_period_data.data if m.version != 'mf6': diff --git a/mfsetup/tests/test_mf6_shellmound.py b/mfsetup/tests/test_mf6_shellmound.py index 3dfb1be0..bae7e8a3 100644 --- a/mfsetup/tests/test_mf6_shellmound.py +++ b/mfsetup/tests/test_mf6_shellmound.py @@ -628,8 +628,8 @@ def test_basic_stress_package_setup(shellmound_model_with_dis, pckg_abbrv, def test_wel_setup(shellmound_model_with_dis): m = shellmound_model_with_dis # deepcopy(model) - m.cfg['wel']['external_files'] = False - wel = m.setup_wel() + m.cfg['wel']['mfsetup_options']['external_files'] = False + wel = m.setup_wel(**m.cfg['wel'], **m.cfg['wel']['mfsetup_options']) wel.write() assert os.path.exists(os.path.join(m.model_ws, wel.filename)) assert isinstance(wel, mf6.ModflowGwfwel) diff --git a/mfsetup/tests/test_pleasant_mf6_inset.py b/mfsetup/tests/test_pleasant_mf6_inset.py index 2eefc230..6d4898d6 100644 --- a/mfsetup/tests/test_pleasant_mf6_inset.py +++ b/mfsetup/tests/test_pleasant_mf6_inset.py @@ -356,8 +356,8 @@ def test_rch_setup(get_pleasant_mf6_with_dis, simulate_high_k_lakes): def test_wel_setup(get_pleasant_mf6_with_dis): m = get_pleasant_mf6_with_dis - m.cfg['wel']['external_files'] = False - wel = m.setup_wel() + m.cfg['wel']['mfsetup_options']['external_files'] = False + wel = m.setup_wel(**m.cfg['wel'], **m.cfg['wel']['mfsetup_options']) wel.write() assert os.path.exists(os.path.join(m.model_ws, wel.filename)) assert isinstance(wel, mf6.ModflowGwfwel) @@ -431,7 +431,7 @@ def test_external_tables(get_pleasant_mf6_with_dis): assert blocks['connectiondata'][0].strip().split()[1].strip('\'') == \ m.cfg['external_files']['lak_connectiondata'][0] - wel = m.setup_wel() + wel = m.setup_wel(**m.cfg['wel'], **m.cfg['wel']['mfsetup_options']) wel.write() for f in m.cfg['external_files']['wel_stress_period_data'].values(): assert os.path.exists(f) diff --git a/mfsetup/tests/test_wateruse.py b/mfsetup/tests/test_wateruse.py index cf55eec1..1b198da1 100644 --- a/mfsetup/tests/test_wateruse.py +++ b/mfsetup/tests/test_wateruse.py @@ -124,7 +124,7 @@ def test_resample_ss_first_period(inset_with_transient_parent, wu_data): assert m.perioddata.perlen[0] == 1 # test with transient first stress period - m.setup_wel() + m.setup_wel(**m.cfg['wel'], **m.cfg['wel']['mfsetup_options']) df = m.wel.stress_period_data.get_dataframe() # get expected steady state rates for period 0 diff --git a/mfsetup/tests/test_wells.py b/mfsetup/tests/test_wells.py index a1e034b6..82cb4ed1 100644 --- a/mfsetup/tests/test_wells.py +++ b/mfsetup/tests/test_wells.py @@ -30,7 +30,7 @@ def test_minimum_well_layer_thickness(shellmound_model_with_dis, all_layers): minthickness = 2 m.cfg['wel']['source_data']['csvfiles']['vertical_flux_distribution']\ ['minimum_layer_thickness'] = minthickness - df = setup_wel_data(m, for_external_files=False) + df = setup_wel_data(m, source_data=m.cfg['wel']['source_data']) assert np.all((-np.diff(all_layers, axis=0))[df.k, df.i, df.j] > minthickness) @@ -182,8 +182,8 @@ def test_get_open_interval_thicknesses(shellmound_model_with_dis, all_layers): reason='obscure decode issue with pfl nwt model top external file') def test_get_package_stress_period_data(models_with_dis): m = models_with_dis - m.cfg['wel']['external_files'] = False - wel = m.setup_wel() + m.cfg['wel']['mfsetup_options']['external_files'] = False + wel = m.setup_wel(**m.cfg['wel'], **m.cfg['wel']['mfsetup_options']) result = get_package_stress_period_data(models_with_dis, package_name='wel') assert isinstance(result, pd.DataFrame) assert len({'k', 'i', 'j'}.intersection(result.columns)) == 3 diff --git a/mfsetup/wells.py b/mfsetup/wells.py index df6e8699..b0abe908 100644 --- a/mfsetup/wells.py +++ b/mfsetup/wells.py @@ -13,7 +13,8 @@ from mfsetup.wateruse import get_mean_pumping_rates, resample_pumping_rates -def setup_wel_data(model, for_external_files=True): +def setup_wel_data(model, source_data=None, #for_external_files=True, + dropped_wells_file='dropped_wells.csv'): """Performs the part of well package setup that is independent of MODFLOW version. Returns a DataFrame with the information needed to set up stress_period_data. @@ -31,10 +32,9 @@ def setup_wel_data(model, for_external_files=True): df = pd.DataFrame(columns=columns) # check for source data - datasets = model.cfg['wel'].get('source_data') + datasets = source_data # delete the dropped wells file if it exists, to avoid confusion - dropped_wells_file = model.cfg['wel']['output_files']['dropped_wells_file'].format(model.name) if os.path.exists(dropped_wells_file): os.remove(dropped_wells_file) @@ -215,14 +215,19 @@ def setup_wel_data(model, for_external_files=True): # save a lookup file with well site numbers/categories df.sort_values(by=['boundname', 'per'], inplace=True) - df[['per', 'k', 'i', 'j', 'q', 'boundname']].to_csv(wel_lookup_file, index=False) + if model.version == 'mf6': + cols = ['per', 'k', 'i', 'j', 'q', 'boundname'] + else: + cols = ['per', 'k', 'i', 'j', 'flux', 'boundname'] + df.rename(columns={'q': 'flux'}, inplace=True) + df[cols].to_csv(wel_lookup_file, index=False) # convert to one-based and comment out header if df will be written straight to external file - if for_external_files: - df.rename(columns={'k': '#k'}, inplace=True) - df['#k'] += 1 - df['i'] += 1 - df['j'] += 1 + #if for_external_files: + # df.rename(columns={'k': '#k'}, inplace=True) + # df['#k'] += 1 + # df['i'] += 1 + # df['j'] += 1 return df From d92615b3fbc6d0edd1eeabed2401fa280b3bdd22 Mon Sep 17 00:00:00 2001 From: "Leaf, Andrew T" Date: Mon, 2 May 2022 11:26:38 -0500 Subject: [PATCH 3/9] feat(MFnwtModel): implement general basic stress package support for MODFLOW-NWT models; generalize _setup_basic_stress_package method and move to MFsetupMixin class --- docs/source/input/basic-stress.rst | 20 +- examples/Pleasant_lake_lgr_example.ipynb | 247 +++++++++++---------- mfsetup/bcs.py | 45 ++-- mfsetup/mfmodel.py | 17 +- mfsetup/mfnwt_defaults.yml | 6 +- mfsetup/mfnwtmodel.py | 6 +- mfsetup/tests/data/pleasant_nwt_test.yml | 4 +- mfsetup/tests/test_bcs.py | 7 +- mfsetup/tests/test_lgr.py | 2 +- mfsetup/tests/test_pfl_mfnwt_inset.py | 49 +--- mfsetup/tests/test_pleasant_mf6_inset.py | 3 +- mfsetup/tests/test_pleasant_mfnwt_inset.py | 6 +- mfsetup/wells.py | 13 +- 13 files changed, 224 insertions(+), 201 deletions(-) diff --git a/docs/source/input/basic-stress.rst b/docs/source/input/basic-stress.rst index 48d5249c..8b6b91e6 100644 --- a/docs/source/input/basic-stress.rst +++ b/docs/source/input/basic-stress.rst @@ -5,10 +5,6 @@ Specifying boundary conditions with the 'basic' MODFLOW stress packages .. note:: This page is a work in progress and needs some more work. -.. note:: - Basic stress packages are currenly only supported for Modflow 6, except - for the Constant Head (CHD) package in the context of perimeter boundary conditions. - This page describes configuration file input for the basic MODFLOW stress packages, including the CHD, DRN, GHB, RCH, RIV and WEL packages. The EVT package is not currently supported by Modflow-setup. The supported packages can be broadly placed into two categories. Feature or list-based packages such as CHD, DRN, GHB, RIV and WEL often represent discrete phenomena such as surface water features, pumping wells, or even lines that denote a perimeter boundary. Input to these packages in MODFLOW is tabular, consisting of a table for each stress period, with rows specifying stresses at individual grid cells representing the boundary features. In contrast, continuous or grid-based packages represent a stress field that applies to a large area, such as areal recharge. In past versions of MODFLOW, input to these packages was array-based, with values specified for all model cells, at each stress period. In MODFLOW 6, input to these packages can be array or list-based. The Recharge (RCH) Package is currently the only grid-based stress package supported by Modflow-setup. In keeping with the current structured grid-based paradigm of Modflow-setup, Modflow 6 recharge input is generated for the array-based recharge package (Langevin and others, 2017). @@ -59,7 +55,11 @@ Input for list-based basic stress packages follows a similar pattern to other pa * scalar values (items) are applied globally to the variable * rasters can be used to specify steady-state values that vary in space; values supplied with a raster are mapped to the model grid using zonal statistics. If the raster contains projection information (GeoTIFFs are preferred in part because of this), any reprojection to the model coorindate reference system (CRS) will be performed automatically as needed. Otherwise, the raster is assumed to be in the model projection. * (Not implemented yet) NetCDF input for gridded values that vary in time and space. Due to the lack of standardization in NetCDF coordinate reference information, automatic reprojection is currently not supported for NetCDF files; the data are assumed to be in the model CRS. + * ``mfsetup_options:`` Configuration options for Modflow-setup. General options that apply to all basic stress packages include: + * ``external_files:`` Whether to write the package input as external text arrays or tables (i.e., with ``open/close`` statements). By default ``True`` except in the case of list-based or tabular files for MODFLOW-NWT models, which are not supported. Adding support for this may require changes to Flopy, which handles external list-based files differently for MODFLOW-2005 style models. + * ``external_filename_fmt:`` Python string format for external file names. By default, ``"_{:03d}.dat"``. which results in filenames such as ``wel_000.dat``, ``wel_001.dat``, ``wel_002.dat``... for stress periods 0, 1, and 2, for example. + Other Modflow-setup options specific to individual packages are described below. Constant Head (CHD) Package ++++++++++++++++++++++++++++++ @@ -87,7 +87,7 @@ Input consists of specified head values that may vary in time or space. .. literalinclude:: ../../../mfsetup/tests/data/shellmound.yml :language: yaml - :lines: 285-296 + :lines: 285-298 Drain DRN Package @@ -136,7 +136,7 @@ Input consists of head elevations and conductances that may vary in time or spac .. literalinclude:: ../../../mfsetup/tests/data/shellmound.yml :language: yaml - :lines: 316-335 + :lines: 316-337 River (RIV) package ++++++++++++++++++++ @@ -162,7 +162,7 @@ Input consists of stages, river bottom elevations and conductances, .. literalinclude:: ../../../mfsetup/tests/data/shellmound.yml :language: yaml - :lines: 338-356 + :lines: 338-358 Example of setting up the RIV package using SFRmaker (via the ``sfr:`` block): @@ -206,7 +206,7 @@ Input consists of flux rates that may vary in time or space. .. literalinclude:: ../../../mfsetup/tests/data/shellmound.yml :language: yaml - :lines: 359-386 + :lines: 359-388 * ``wdnr_dataset`` block .. note:: @@ -219,9 +219,9 @@ Input consists of flux rates that may vary in time or space. * Example: - .. literalinclude:: ../../../examples/pleasant_lgr_inset.yml + .. literalinclude:: ../../../mfsetup/tests/data/pfl_nwt_test.yml :language: yaml - :lines: 79-86 + :lines: 113-118 **The** ``vertical_flux_distribution:`` **sub-block** * This sub-block specifies how Well Packages fluxes should be distributed vertically. diff --git a/examples/Pleasant_lake_lgr_example.ipynb b/examples/Pleasant_lake_lgr_example.ipynb index 5ef86272..2153ae6f 100644 --- a/examples/Pleasant_lake_lgr_example.ipynb +++ b/examples/Pleasant_lake_lgr_example.ipynb @@ -188,11 +188,11 @@ "output_type": "stream", "text": [ "creating shapely Polygons of grid cells...\n", - "finished in 0.09s\n", + "finished in 0.10s\n", "\n", "writing postproc/shps/plsnt_lgr_parent_grid.shp... Done\n", "creating shapely Polygons of grid cells...\n", - "finished in 0.07s\n", + "finished in 0.06s\n", "\n", "writing postproc/shps/plsnt_lgr_inset_grid.shp... Done\n" ] @@ -241,7 +241,7 @@ "\n", "Setting up plsnt_lgr_parent model from configuration in pleasant_lgr_parent.yml\n", "loading parent model /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/pleasant.nam...\n", - "finished in 0.15s\n", + "finished in 0.16s\n", "\n", "\n", "validating configuration...\n", @@ -262,12 +262,12 @@ "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/botm0.tif...\n", "finished in 0.02s\n", "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/botm1.tif...\n", - "finished in 0.03s\n", + "finished in 0.02s\n", "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/botm2.tif...\n", - "finished in 0.03s\n", + "finished in 0.02s\n", "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/botm3.tif...\n", - "finished in 0.03s\n", - "loading original-arrays/plsnt_lgr_parent_top.dat.original, shape=(25, 25), loading original-arrays/plsnt_lgr_parent_top.dat.original, shape=(25, 25), took 0.00s\n", + "finished in 0.02s\n", + "loading external/plsnt_lgr_parent_top.dat.original, shape=(25, 25), took 0.00s\n", "computing cell thicknesses...\n", "finished in 0.02s\n", "\n", @@ -298,7 +298,7 @@ "wrote original-arrays/plsnt_lgr_parent_lakarr_002.dat, took 0.00s\n", "wrote original-arrays/plsnt_lgr_parent_lakarr_003.dat, took 0.00s\n", "wrote original-arrays/plsnt_lgr_parent_lakarr_004.dat, took 0.00s\n", - "loading original-arrays/plsnt_lgr_parent_top.dat.original, shape=(25, 25), took 0.00s\n", + "loading external/plsnt_lgr_parent_top.dat.original, shape=(25, 25), took 0.00s\n", "computing cell thicknesses...\n", "finished in 0.02s\n", "\n", @@ -317,11 +317,11 @@ "setting up model grid...\n", "wrote /Users/aleaf/Documents/GitHub/modflow-setup/examples/pleasant_lgr/plsnt_lgr_parent_grid.json\n", "writing /Users/aleaf/Documents/GitHub/modflow-setup/examples/pleasant_lgr/postproc/shps/plsnt_lgr_parent_bbox.shp... Done\n", - "finished in 0.05s\n", + "finished in 0.02s\n", "\n", "loading configuration file /Users/aleaf/Documents/GitHub/modflow-setup/examples/pleasant_lgr_inset.yml...\n", "wrote ./external/plsnt_lgr_parent_irch.dat, took 0.00s\n", - "finished in 0.52s\n", + "finished in 0.47s\n", "\n", "\n", "validating configuration...\n", @@ -335,7 +335,7 @@ "--> building dataframe... (may take a while for large shapefiles)\n", "wrote /Users/aleaf/Documents/GitHub/modflow-setup/examples/pleasant_lgr/plsnt_lgr_inset_grid.json\n", "writing /Users/aleaf/Documents/GitHub/modflow-setup/examples/pleasant_lgr/postproc/shps/plsnt_lgr_inset_bbox.shp... Done\n", - "finished in 0.07s\n", + "finished in 0.08s\n", "\n", "(re)setting the idomain array...\n", "computing cell thicknesses...\n", @@ -346,7 +346,7 @@ "wrote original-arrays/plsnt_lgr_parent_lakarr_002.dat, took 0.00s\n", "wrote original-arrays/plsnt_lgr_parent_lakarr_003.dat, took 0.00s\n", "wrote original-arrays/plsnt_lgr_parent_lakarr_004.dat, took 0.00s\n", - "loading original-arrays/plsnt_lgr_parent_top.dat.original, shape=(25, 25), took 0.00s\n", + "loading external/plsnt_lgr_parent_top.dat.original, shape=(25, 25), took 0.00s\n", "computing cell thicknesses...\n", "finished in 0.02s\n", "\n", @@ -400,7 +400,7 @@ "wrote ./external/plsnt_lgr_parent_k33_002.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_parent_k33_003.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_parent_k33_004.dat, took 0.00s\n", - "finished in 0.17s\n", + "finished in 0.19s\n", "\n", "\n", "Setting up STO package...\n", @@ -414,11 +414,17 @@ "wrote ./external/plsnt_lgr_parent_ss_002.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_parent_ss_003.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_parent_ss_004.dat, took 0.00s\n", - "finished in 0.18s\n", + "finished in 0.19s\n", "\n", "\n", "Setting up RCH package...\n", - "wrote ./external/plsnt_lgr_parent_irch.dat, took 0.00s\n", + "wrote ./external/plsnt_lgr_parent_irch.dat, took 0.00s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "wrote ./external/plsnt_lgr_parent_rch_000.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_parent_rch_001.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_parent_rch_002.dat, took 0.00s\n", @@ -432,7 +438,7 @@ "wrote ./external/plsnt_lgr_parent_rch_010.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_parent_rch_011.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_parent_rch_012.dat, took 0.00s\n", - "finished in 0.07s\n", + "finished in 0.08s\n", "\n", "\n", "Setting up OC package...\n", @@ -441,40 +447,34 @@ "\n", "Setting up CHD package...\n", "\n", - "getting perimeter cells...\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "getting perimeter cells...\n", "creating shapely Polygons of grid cells...\n", "finished in 0.01s\n", "\n", "wrote /Users/aleaf/Documents/GitHub/modflow-setup/examples/pleasant_lgr/tables/boundary_cells.shp\n", - "perimeter cells took 0.17s\n", + "perimeter cells took 0.18s\n", "\n", "Calculating 3D interpolation weights...\n", - "finished in 0.30s\n", + "finished in 0.29s\n", "\n", "\n", "getting perimeter heads...\n", "for stress period 0, took 0.01s\n", "for stress period 1, took 0.00s\n", - "for stress period 2, took 0.00s\n", - "for stress period 3, took 0.00s\n", + "for stress period 2, took 0.01s\n", + "for stress period 3, took 0.01s\n", "for stress period 4, took 0.00s\n", - "for stress period 5, took 0.00s\n", - "for stress period 6, took 0.00s\n", - "for stress period 7, took 0.00s\n", - "for stress period 8, took 0.00s\n", - "for stress period 9, took 0.00s\n", - "for stress period 10, took 0.00s\n", + "for stress period 5, took 0.01s\n", + "for stress period 6, took 0.01s\n", + "for stress period 7, took 0.01s\n", + "for stress period 8, took 0.01s\n", + "for stress period 9, took 0.01s\n", + "for stress period 10, took 0.01s\n", "for stress period 11, took 0.00s\n", - "for stress period 12, took 0.01s\n", - "getting perimeter heads took 0.07s\n", + "for stress period 12, took 0.00s\n", + "getting perimeter heads took 0.08s\n", "\n", - "finished in 0.74s\n", + "finished in 0.77s\n", "\n", "\n", "Setting up SFR package...\n", @@ -502,7 +502,7 @@ "finished in 0.01s\n", "\n", "\n", - "SFRmaker version 0.9.1.post9+gebe22b0\n", + "SFRmaker version 0.9.1.post10+g4b87d29\n", "\n", "Creating sfr dataset...\n", "\n", @@ -521,7 +521,7 @@ "active area defined by: isfr array\n", "\n", "/Users/aleaf/Documents/GitHub/modflow-setup/examples/pleasant_lgr\n", - "Pleasant Lake test case version 0.1.post290.dev0+gb63386d\n", + "Pleasant Lake test case version 0.1.post329.dev0+g5a15308\n", "Parent model: /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/pleasant\n", "5 layer(s), 25 row(s), 25 column(s)\n", "delr: [200.00...200.00] meters\n", @@ -581,7 +581,7 @@ "active area defined by: isfr array\n", "\n", "\n", - "Time to create sfr dataset: 0.24s\n", + "Time to create sfr dataset: 0.27s\n", "\n", "running rasterstats.zonal_stats on buffered LineStrings...\n", "finished in 0.34s\n", @@ -610,7 +610,7 @@ "wrote original-arrays/plsnt_lgr_parent_lakarr_002.dat, took 0.00s\n", "wrote original-arrays/plsnt_lgr_parent_lakarr_003.dat, took 0.00s\n", "wrote original-arrays/plsnt_lgr_parent_lakarr_004.dat, took 0.00s\n", - "loading original-arrays/plsnt_lgr_parent_top.dat.original, shape=(25, 25), took 0.00s\n", + "loading external/plsnt_lgr_parent_top.dat.original, shape=(25, 25), took 0.00s\n", "computing cell thicknesses...\n", "finished in 0.02s\n", "\n", @@ -632,7 +632,7 @@ "finished in 0.02s\n", "\n", "wrote ./external/plsnt_lgr_parent_irch.dat, took 0.00s\n", - "finished in 1.19s\n", + "finished in 1.25s\n", "\n", "\n", "Setting up LAK package...\n", @@ -651,8 +651,14 @@ "Setting up WEL package...\n", "getting i, j locations...\n", "finished in 0.00s\n", - "\n", - "finished in 0.16s\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "finished in 0.18s\n", "\n", "\n", "Setting up OBS package...\n", @@ -699,30 +705,24 @@ "\n", "Setting up DIS package...\n", "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/dem40m.tif...\n", - "finished in 0.03s\n", + "finished in 0.02s\n", "wrote ./external/plsnt_lgr_inset_top.dat, took 0.00s\n", "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/botm0.tif...\n", - "finished in 0.03s\n", + "finished in 0.02s\n", "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/botm1.tif...\n", "finished in 0.02s\n", "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/botm2.tif...\n", "finished in 0.02s\n", "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/botm3.tif...\n", - "finished in 0.03s\n", - "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/pleasant_bathymetry.tif...\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "finished in 0.14s\n", - "caching data in /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/shps/all_lakes.shp...\n", + "finished in 0.02s\n", "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/pleasant_bathymetry.tif...\n", "finished in 0.14s\n", + "caching data in /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/shps/all_lakes.shp...\n", "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/pleasant_bathymetry.tif...\n", "finished in 0.13s\n", - "loading original-arrays/plsnt_lgr_inset_top.dat.original, shape=(70, 80), loading original-arrays/plsnt_lgr_inset_top.dat.original, shape=(70, 80), took 0.01s\n", + "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/pleasant_bathymetry.tif...\n", + "finished in 0.14s\n", + "loading external/plsnt_lgr_inset_top.dat.original, shape=(70, 80), took 0.00s\n", "computing cell thicknesses...\n", "finished in 0.16s\n", "\n", @@ -740,7 +740,7 @@ "wrote ./external/plsnt_lgr_inset_idomain_004.dat, took 0.00s\n", "(re)setting the idomain array...\n", "computing cell thicknesses...\n", - "finished in 0.17s\n", + "finished in 0.18s\n", "\n", "setting up model grid...\n", "\n", @@ -752,17 +752,17 @@ "finished in 0.07s\n", "\n", "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/pleasant_bathymetry.tif...\n", - "finished in 0.15s\n", + "finished in 0.17s\n", "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/pleasant_bathymetry.tif...\n", - "finished in 0.13s\n", + "finished in 0.15s\n", "wrote original-arrays/plsnt_lgr_inset_lakarr_000.dat, took 0.00s\n", "wrote original-arrays/plsnt_lgr_inset_lakarr_001.dat, took 0.00s\n", "wrote original-arrays/plsnt_lgr_inset_lakarr_002.dat, took 0.00s\n", "wrote original-arrays/plsnt_lgr_inset_lakarr_003.dat, took 0.00s\n", "wrote original-arrays/plsnt_lgr_inset_lakarr_004.dat, took 0.00s\n", - "loading original-arrays/plsnt_lgr_inset_top.dat.original, shape=(70, 80), took 0.00s\n", + "loading external/plsnt_lgr_inset_top.dat.original, shape=(70, 80), took 0.00s\n", "computing cell thicknesses...\n", - "finished in 0.16s\n", + "finished in 0.14s\n", "\n", "wrote ./external/plsnt_lgr_inset_top.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_inset_botm_000.dat, took 0.00s\n", @@ -783,10 +783,10 @@ "--> building dataframe... (may take a while for large shapefiles)\n", "wrote /Users/aleaf/Documents/GitHub/modflow-setup/examples/pleasant_lgr/plsnt_lgr_inset_grid.json\n", "writing /Users/aleaf/Documents/GitHub/modflow-setup/examples/pleasant_lgr/postproc/shps/plsnt_lgr_inset_bbox.shp... Done\n", - "finished in 0.07s\n", + "finished in 0.06s\n", "\n", "wrote ./external/plsnt_lgr_inset_irch.dat, took 0.00s\n", - "finished in 1.95s\n", + "finished in 1.94s\n", "\n", "\n", "Setting up IC package...\n", @@ -798,21 +798,21 @@ "wrote ./external/plsnt_lgr_inset_strt_002.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_inset_strt_003.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_inset_strt_004.dat, took 0.00s\n", - "finished in 0.19s\n", + "finished in 0.18s\n", "\n", "\n", "Setting up NPF package...\n", "wrote ./external/plsnt_lgr_inset_k_000.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_inset_k_001.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_inset_k_002.dat, took 0.00s\n", - "wrote ./external/plsnt_lgr_inset_k_003.dat, took 0.00s\n", + "wrote ./external/plsnt_lgr_inset_k_003.dat, took 0.01s\n", "wrote ./external/plsnt_lgr_inset_k_004.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_inset_k33_000.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_inset_k33_001.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_inset_k33_002.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_inset_k33_003.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_inset_k33_004.dat, took 0.00s\n", - "finished in 0.43s\n", + "finished in 0.41s\n", "\n", "\n", "Setting up STO package...\n", @@ -842,9 +842,15 @@ "wrote ./external/plsnt_lgr_inset_rch_008.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_inset_rch_009.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_inset_rch_010.dat, took 0.00s\n", - "wrote ./external/plsnt_lgr_inset_rch_011.dat, took 0.00s\n", + "wrote ./external/plsnt_lgr_inset_rch_011.dat, took 0.01s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "wrote ./external/plsnt_lgr_inset_rch_012.dat, took 0.00s\n", - "finished in 0.21s\n", + "finished in 0.18s\n", "\n", "\n", "Setting up OC package...\n", @@ -878,14 +884,14 @@ "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/pleasant_bathymetry.tif...\n", "finished in 0.13s\n", "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/pleasant_bathymetry.tif...\n", - "finished in 0.12s\n", + "finished in 0.13s\n", "\n", - "SFRmaker version 0.9.1.post9+gebe22b0\n", + "SFRmaker version 0.9.1.post10+g4b87d29\n", "\n", "Creating sfr dataset...\n", "\n", "Creating grid class instance from flopy Grid instance...\n", - "grid class created in 0.07s\n", + "grid class created in 0.06s\n", "\n", "Model grid information\n", "structured grid\n", @@ -898,14 +904,8 @@ "bounds: 554200.00, 389000.00, 557400.00, 391800.00\n", "active area defined by: isfr array\n", "\n", - "/Users/aleaf/Documents/GitHub/modflow-setup/examples/pleasant_lgr\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "plsnt_lgr_inset model version 0.post290.dev0+gb63386d\n", + "/Users/aleaf/Documents/GitHub/modflow-setup/examples/pleasant_lgr\n", + "plsnt_lgr_inset model version 0.post329.dev0+g5a15308\n", "Parent model: ./plsnt_lgr_parent\n", "5 layer(s), 70 row(s), 80 column(s)\n", "delr: [40.00...40.00] meters\n", @@ -965,10 +965,10 @@ "active area defined by: isfr array\n", "\n", "\n", - "Time to create sfr dataset: 0.35s\n", + "Time to create sfr dataset: 0.36s\n", "\n", "running rasterstats.zonal_stats on buffered LineStrings...\n", - "finished in 0.65s\n", + "finished in 0.64s\n", "\n", "\n", "Smoothing elevations...\n", @@ -998,9 +998,9 @@ "wrote original-arrays/plsnt_lgr_inset_lakarr_002.dat, took 0.00s\n", "wrote original-arrays/plsnt_lgr_inset_lakarr_003.dat, took 0.00s\n", "wrote original-arrays/plsnt_lgr_inset_lakarr_004.dat, took 0.00s\n", - "loading original-arrays/plsnt_lgr_inset_top.dat.original, shape=(70, 80), took 0.00s\n", + "loading external/plsnt_lgr_inset_top.dat.original, shape=(70, 80), took 0.00s\n", "computing cell thicknesses...\n", - "finished in 0.17s\n", + "finished in 0.14s\n", "\n", "wrote ./external/plsnt_lgr_inset_top.dat, took 0.00s\n", "wrote ./external/plsnt_lgr_inset_botm_000.dat, took 0.00s\n", @@ -1024,12 +1024,12 @@ "finished in 0.06s\n", "\n", "wrote ./external/plsnt_lgr_inset_irch.dat, took 0.00s\n", - "finished in 2.60s\n", + "finished in 2.58s\n", "\n", "\n", "Setting up LAK package...\n", "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/pleasant_bathymetry.tif...\n", - "finished in 0.13s\n", + "finished in 0.12s\n", "reading data from /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/source_data/rasters/pleasant_bathymetry.tif...\n", "finished in 0.21s\n", "wrote original-arrays/plsnt_lgr_inset_lakarr_000.dat, took 0.00s\n", @@ -1044,17 +1044,18 @@ "wrote original-arrays/plsnt_lgr_inset_lakarr_004.dat, took 0.00s\n", "setting up lakebed leakance zones...\n", "finished in 0.02s\n", - "wrote original-arrays/plsnt_lgr_inset_lakzones.dat, took 0.00s\n", + "wrote original-arrays/plsnt_lgr_inset_lakzones.dat, took 0.05s\n", "setting up tabfiles...\n", "wrote ./external/600059060_stage_area_volume.dat\n", - "finished in 0.88s\n", + "finished in 0.96s\n", "\n", "\n", "Setting up WEL package...\n", "getting i, j locations...\n", "finished in 0.00s\n", "\n", - "No wells in active model area\n", + "WEL package:\n", + "No input specified or package configuration file input not understood. See the Configuration File Gallery in the online docs for example input Note that direct input to basic stress period packages is currently not supported.\n", "\n", "Setting up OBS package...\n", "Reading observation files...\n", @@ -1082,11 +1083,17 @@ "\n", "\n", "Setting up the simulation water mover package...\n", - "finished in 0.00s\n", - "\n", - "finished setting up model in 11.25s\n", + "finished in 0.01s\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "finished setting up model in 11.33s\n", "\n", - "Pleasant Lake test case version 0.1.post290.dev0+gb63386d\n", + "Pleasant Lake test case version 0.1.post329.dev0+g5a15308\n", "Parent model: /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/pleasant\n", "5 layer(s), 25 row(s), 25 column(s)\n", "delr: [200.00...200.00] meters\n", @@ -1095,7 +1102,7 @@ "length units: meters\n", "xll: 553000.0; yll: 388000.0; rotation: 0.0\n", "Bounds: (553000.0, 558000.0, 388000.0, 393000.0)\n", - "Packages: dis ic npf sto rcha_0 oc chd_0 obs_0 sfr_0 wel_0 obs_1\n", + "Packages: dis ic npf sto rcha_0 oc chd_0 obs_0 sfr_0 wel_0 obs_1 obs_2\n", "13 period(s):\n", " per start_datetime end_datetime perlen steady nstp\n", " 0 2012-01-01 2012-01-01 1.0 True 1\n", @@ -1125,7 +1132,7 @@ { "data": { "text/plain": [ - "Pleasant Lake test case version 0.1.post290.dev0+gb63386d\n", + "Pleasant Lake test case version 0.1.post329.dev0+g5a15308\n", "Parent model: /Users/aleaf/Documents/GitHub/modflow-setup/examples/data/pleasant/pleasant\n", "5 layer(s), 25 row(s), 25 column(s)\n", "delr: [200.00...200.00] meters\n", @@ -1134,7 +1141,7 @@ "length units: meters\n", "xll: 553000.0; yll: 388000.0; rotation: 0.0\n", "Bounds: (553000.0, 558000.0, 388000.0, 393000.0)\n", - "Packages: dis ic npf sto rcha_0 oc chd_0 obs_0 sfr_0 wel_0 obs_1\n", + "Packages: dis ic npf sto rcha_0 oc chd_0 obs_0 sfr_0 wel_0 obs_1 obs_2\n", "13 period(s):\n", " per start_datetime end_datetime perlen steady nstp\n", " 0 2012-01-01 2012-01-01 1.0 True 1\n", @@ -1248,7 +1255,7 @@ { "data": { "text/plain": [ - "{'plsnt_lgr_inset': plsnt_lgr_inset model version 0.post290.dev0+gb63386d\n", + "{'plsnt_lgr_inset': plsnt_lgr_inset model version 0.post329.dev0+g5a15308\n", " Parent model: ./plsnt_lgr_parent\n", " 5 layer(s), 70 row(s), 80 column(s)\n", " delr: [40.00...40.00] meters\n", @@ -1291,7 +1298,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 13, @@ -1377,6 +1384,7 @@ " writing package wel_0...\n", "INFORMATION: maxbound in ('gwf6', 'wel', 'dimensions') changed to 2 based on size of stress_period_data\n", " writing package obs_1...\n", + " writing package obs_2...\n", " writing model plsnt_lgr_inset...\n", " writing model name file...\n", " writing package dis...\n", @@ -1389,7 +1397,7 @@ " writing package lak_0...\n", " writing package obs_0...\n", " writing package obs_1...\n", - "SFRmaker v. 0.9.1.post9+gebe22b0\n", + "SFRmaker v. 0.9.1.post10+g4b87d29\n", "\n", "Running Flopy v. 3.3.6 diagnostics...\n", "passed.\n", @@ -1481,9 +1489,11 @@ "FloPy is using the following executable to run the model: /Users/aleaf/Documents/software/modflow_exes/mf6\n", " MODFLOW 6\n", " U.S. GEOLOGICAL SURVEY MODULAR HYDROLOGIC MODEL\n", - " VERSION 6.2.2 07/30/2021\n", + " VERSION 6.3.0 03/04/2022\n", "\n", - " MODFLOW 6 compiled Aug 01 2021 12:51:08 with IFORT compiler (ver. 19.10.3)\n", + " MODFLOW 6 compiled Mar 07 2022 13:50:09 with Intel(R) Fortran Intel(R) 64\n", + " Compiler Classic for applications running on Intel(R) 64, Version 2021.5.0\n", + " Build 20211109_000000\n", "\n", "This software has been approved for release by the U.S. Geological \n", "Survey (USGS). Although the software has been subjected to rigorous \n", @@ -1499,7 +1509,7 @@ "and distribution information.\n", "\n", " \n", - " Run start date and time (yyyy/mm/dd hh:mm:ss): 2022/03/24 11:53:32\n", + " Run start date and time (yyyy/mm/dd hh:mm:ss): 2022/05/02 10:14:04\n", " \n", " Writing simulation list file: mfsim.lst\n", " Using Simulation name file: mfsim.nam\n", @@ -1518,8 +1528,8 @@ " Solving: Stress period: 12 Time step: 1\n", " Solving: Stress period: 13 Time step: 1\n", " \n", - " Run end date and time (yyyy/mm/dd hh:mm:ss): 2022/03/24 11:53:38\n", - " Elapsed run time: 5.219 Seconds\n", + " Run end date and time (yyyy/mm/dd hh:mm:ss): 2022/05/02 10:14:08\n", + " Elapsed run time: 4.260 Seconds\n", " \n", " Normal termination of simulation.\n" ] @@ -1624,7 +1634,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1733,6 +1743,9 @@ "name": "stdout", "output_type": "stream", "text": [ + "creating postproc/plsnt_lgr_parent/pdfs...\n", + "creating postproc/plsnt_lgr_parent/shps...\n", + "creating postproc/plsnt_lgr_parent/rasters...\n", "\n", "dis package...\n", "wrote postproc/plsnt_lgr_parent/rasters/thickness_lay0.tif\n", @@ -1842,7 +1855,13 @@ "Export of non-period data from transientlists not implemented!\n", "\n", "obs_1 package...\n", - "writing postproc/plsnt_lgr_parent/shps/obs1_stress_period_data.shp... Done\n", + "skipped, not implemented yet\n", + "\n", + "obs_2 package...\n", + "writing postproc/plsnt_lgr_parent/shps/obs2_stress_period_data.shp... Done\n", + "creating postproc/plsnt_lgr_inset/pdfs...\n", + "creating postproc/plsnt_lgr_inset/shps...\n", + "creating postproc/plsnt_lgr_inset/rasters...\n", "\n", "dis package...\n", "wrote postproc/plsnt_lgr_inset/rasters/thickness_lay0.tif\n", @@ -1926,7 +1945,13 @@ "wrote postproc/plsnt_lgr_inset/rasters/recharge_per6.tif\n", "wrote postproc/plsnt_lgr_inset/rasters/recharge_per7.tif\n", "wrote postproc/plsnt_lgr_inset/rasters/recharge_per8.tif\n", - "wrote postproc/plsnt_lgr_inset/rasters/recharge_per9.tif\n", + "wrote postproc/plsnt_lgr_inset/rasters/recharge_per9.tif\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "wrote postproc/plsnt_lgr_inset/rasters/recharge_per10.tif\n", "wrote postproc/plsnt_lgr_inset/rasters/recharge_per11.tif\n", "wrote postproc/plsnt_lgr_inset/rasters/recharge_per12.tif\n", @@ -1935,18 +1960,12 @@ "writing postproc/plsnt_lgr_inset/shps/plsnt_lgr_inset.sfr.shp... Done\n", "\n", "lak_0 package...\n", - "skipped, not implemented yet\n", + "skipping lak0.perioddata; efficient export not implemented\n", "\n", "obs_0 package...\n", "skipped, not implemented yet\n", "\n", - "obs_1 package...\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "obs_1 package...\n", "writing postproc/plsnt_lgr_inset/shps/obs1_stress_period_data.shp... Done\n" ] } diff --git a/mfsetup/bcs.py b/mfsetup/bcs.py index a91de6d6..d8da0137 100644 --- a/mfsetup/bcs.py +++ b/mfsetup/bcs.py @@ -64,6 +64,8 @@ def setup_basic_stress_data(model, shapefile=None, csvfile=None, if bc_cells.dtype == object: df['boundname'] = bc_cells.flat df.loc[df.boundname.isna(), 'boundname'] = 'unnamed' + # cull to just the cells with bcs + df = df.loc[cells_with_bc].copy() variables = {'head': head, 'elev': elev, 'bhead': bhead, 'stage': stage, 'cond': cond, 'rbot': rbot} @@ -71,8 +73,10 @@ def setup_basic_stress_data(model, shapefile=None, csvfile=None, if entry is not None: # Raster of variable values supplied if isinstance(entry, dict): - key = [k for k in entry.keys() if 'filename' in k.lower()][0] - filename = entry[key] + filename_entries = [k for k in entry.keys() if 'filename' in k.lower()] + if not any(filename_entries): + continue + filename = entry[filename_entries[0]] with rasterio.open(filename) as src: meta = src.meta @@ -92,19 +96,25 @@ def setup_basic_stress_data(model, shapefile=None, csvfile=None, stat = entry['stat'] results = zonal_stats(polygons, filename, stats=stat, all_touched=all_touched) - values = np.ones((m.nrow * m.ncol), dtype=float) * np.nan - values[cells_with_bc] = np.array([r[stat] for r in results]) + #values = np.ones((m.nrow * m.ncol), dtype=float) * np.nan + #values[cells_with_bc] = np.array([r[stat] for r in results]) + values = np.array([r[stat] for r in results]) + # cull to polygon statistics within model area + valid = values != None + values = values[valid] + df = df.loc[valid].copy() + units_key = [k for k in entry if 'units' in k] if len(units_key) > 0: values *= convert_length_units(entry[units_key[0]], model.length_units) - values = np.reshape(values, (m.nrow, m.ncol)) + #values = np.reshape(values, (m.nrow, m.ncol)) # add the layer and the values to the Modflow input DataFrame # assign layers so that the elevation is above the cell bottoms if var in ['head', 'elev', 'bhead']: - df['k'] = get_layer(model.dis.botm.array, df.i, df.j, values.flat) - df[var] = values.flat + df['k'] = get_layer(model.dis.botm.array, df.i, df.j, values) + df[var] = values # single global value specified elif isinstance(entry, numbers.Number): df[var] = entry @@ -498,8 +508,12 @@ def setup_flopy_stress_period_data(model, package, data, flopy_package_class, """ df = data.copy() + missing_variables = set(variable_columns).difference(df.columns) + if any(missing_variables): + raise ValueError(f"{package.upper()} Package: missing input for variables: " + f"{', '.join(missing_variables)}") # set up stress_period_data - if external_files: + if external_files and model.version == 'mf6': # get the file path (allowing for different external file locations, specified name format, etc.) filepaths = model.setup_external_filepaths(package, 'stress_period_data', filename_format=external_filename_fmt, @@ -521,17 +535,16 @@ def setup_flopy_stress_period_data(model, package, data, flopy_package_class, if kper in period_groups.groups: group = period_groups.get_group(kper) group.drop('per', axis=1, inplace=True) - if external_files: - if model.version == 'mf6': - group.to_csv(filepaths[kper]['filename'], index=False, sep=' ', float_format='%g') - # make a copy for the intermediate data folder, for consistency with mf-2005 - shutil.copy(filepaths[kper]['filename'], model.cfg['intermediate_data']['output_folder']) - else: - group.to_csv(filepaths[kper], index=False, sep=' ', float_format='%g') + if external_files and model.version == 'mf6': + group.to_csv(filepaths[kper]['filename'], index=False, sep=' ', float_format='%g') + # make a copy for the intermediate data folder, for consistency with mf-2005 + shutil.copy(filepaths[kper]['filename'], model.cfg['intermediate_data']['output_folder']) + + # external list or tabular type files not supported for MODFLOW-NWT + # adding support for this may require changes to Flopy else: if model.version == 'mf6': - flopy.modflow.ModflowWel.stress_period_data kspd = flopy_package_class.stress_period_data.empty(model, len(group), boundnames=True)[0] diff --git a/mfsetup/mfmodel.py b/mfsetup/mfmodel.py index ca40f482..c4889afd 100644 --- a/mfsetup/mfmodel.py +++ b/mfsetup/mfmodel.py @@ -1310,7 +1310,7 @@ def _setup_basic_stress_package(self, package, flopy_package_class, dfs.append(rivdata.stress_period_data) # set up package from user input - + df_sd = None if 'source_data' in kwargs: if package == 'wel': dropped_wells_file =\ @@ -1320,7 +1320,7 @@ def _setup_basic_stress_package(self, package, flopy_package_class, dropped_wells_file=dropped_wells_file) else: df_sd = setup_basic_stress_data(self, **kwargs['source_data'], **kwargs['mfsetup_options']) - if df_sd is not None: + if df_sd is not None and len(df_sd) > 0: dfs.append(df_sd) # set up package from parent model elif self.cfg['parent'].get('default_source_data') and\ @@ -1331,9 +1331,8 @@ def _setup_basic_stress_package(self, package, flopy_package_class, df_sd = setup_wel_data(self, dropped_wells_file=dropped_wells_file) else: - raise NotImplementedError(f"Setup of {package.upper()} " - "package from the parent model.") - if df_sd is not None: + print(f'Skipping setup of {package.upper()} Package from parent model-- not implemented.') + if df_sd is not None and len(df_sd) > 0: dfs.append(df_sd) if len(dfs) == 0: print(f"{package.upper()} package:\n" @@ -1347,7 +1346,12 @@ def _setup_basic_stress_package(self, package, flopy_package_class, df = pd.concat(dfs, axis=0) # option to write stress_period_data to external files - external_files = self.cfg[package]['mfsetup_options'].get('external_files', True) + if self.version == 'mf6': + external_files = self.cfg[package]['mfsetup_options'].get('external_files', True) + else: + # external list or tabular type files not supported for MODFLOW-NWT + # adding support for this may require changes to Flopy + external_files = False external_filename_fmt = self.cfg[package]['mfsetup_options']['external_filename_fmt'] spd = setup_flopy_stress_period_data(self, package, df, flopy_package_class=flopy_package_class, @@ -1372,7 +1376,6 @@ def _setup_basic_stress_package(self, package, flopy_package_class, obslist.append((bname, package, bname)) if len(obslist) > 0: kwargs['observations'] = {obsfile: obslist} - kwargs = get_input_arguments(kwargs, flopy_package_class) if not external_files: kwargs['stress_period_data'] = spd diff --git a/mfsetup/mfnwt_defaults.yml b/mfsetup/mfnwt_defaults.yml index 419f83dc..936cb3c8 100644 --- a/mfsetup/mfnwt_defaults.yml +++ b/mfsetup/mfnwt_defaults.yml @@ -101,7 +101,9 @@ chd: source_data: shapefile: all_touched: True - head: + shead: + stat: 'min' + ehead: stat: 'min' mfsetup_options: external_files: True # option to write stress_period_data to external files @@ -126,7 +128,7 @@ ghb: bhead: stat: 'min' mfsetup_options: - external_files: True # option to write stress_period_data to external files + external_files: False # option to write stress_period_data to external files external_filename_fmt: "ghb_{:03d}.dat" riv: diff --git a/mfsetup/mfnwtmodel.py b/mfsetup/mfnwtmodel.py index 76e1d6ba..a88c7d85 100644 --- a/mfsetup/mfnwtmodel.py +++ b/mfsetup/mfnwtmodel.py @@ -688,21 +688,21 @@ def setup_chd(self, **kwargs): """Set up the CHD Package. """ return self._setup_basic_stress_package( - 'chd', fm.ModflowChd, ['shead', 'ehead'], **kwargs) + 'chd', fm.ModflowChd, ['head'], **kwargs) def setup_drn(self, **kwargs): """Set up the Drain Package. """ return self._setup_basic_stress_package( - 'drn', fm.ModflowDrn, ['stage', 'cond'], **kwargs) + 'drn', fm.ModflowDrn, ['elev', 'cond'], **kwargs) def setup_ghb(self, **kwargs): """Set up the General Head Boundary Package. """ return self._setup_basic_stress_package( - 'ghb', fm.ModflowGhb, ['stage', 'cond'], **kwargs) + 'ghb', fm.ModflowGhb, ['bhead', 'cond'], **kwargs) def setup_riv(self, rivdata=None, **kwargs): diff --git a/mfsetup/tests/data/pleasant_nwt_test.yml b/mfsetup/tests/data/pleasant_nwt_test.yml index a632d6b5..5304f00d 100644 --- a/mfsetup/tests/data/pleasant_nwt_test.yml +++ b/mfsetup/tests/data/pleasant_nwt_test.yml @@ -89,15 +89,15 @@ wel: ghb: options: ['SPECIFY', '0.01'] - cond: 9 # m2/d source_data: shapefile: filename: '../../../examples/data/pleasant/source_data/shps/all_lakes.shp' id_column: 'HYDROID' include_ids: [600059161] # pond near pleasant lake - dem: + bhead: filename: '../../../examples/data/pleasant/source_data/rasters/dem40m.tif' elevation_units: 'meters' + cond: 9 # m2/d lak: theta: -0.7 # semi-implicit; negative value indicates that surfdep is read diff --git a/mfsetup/tests/test_bcs.py b/mfsetup/tests/test_bcs.py index d1ec482e..6c84e0eb 100644 --- a/mfsetup/tests/test_bcs.py +++ b/mfsetup/tests/test_bcs.py @@ -73,16 +73,19 @@ def test_ghb_sfr_overlap(pleasant_nwt_with_dis_bas6, project_root_path): {'filename': os.path.join(project_root_path, 'examples/data/pleasant/source_data/shps/ghb_lake.shp'), 'id_column': 'id' } - m.setup_ghb() + m.cfg['ghb']['source_data']['bhead'] = m.dis.top.array.mean() + m.cfg['ghb']['source_data']['cond'] = 100 + m.setup_ghb(**m.cfg['ghb'], **m.cfg['ghb']['mfsetup_options']) # using the isbc array to get the number of ghb cells # doesn't work because of this issue with layer 0 containing all i, j locations # (over-counts) + m._set_isbc() nwel, no_bc, nlak, n_highklake, nghb = np.bincount(m.isbc.ravel() + 1) spd = m.ghb.stress_period_data[0] cellids = list(zip(spd.k, spd.i, spd.j)) nghb = len(set(cellids)) # todo: figure out why some cells aren't getting intersected with ghb_lake.shp - assert nghb == 12 + assert nghb == 16 ghb_cells = set(zip(*np.where(m._isbc2d == 3))) m.setup_sfr() sfr_cells = set(zip(m.sfrdata.reach_data.i.values, diff --git a/mfsetup/tests/test_lgr.py b/mfsetup/tests/test_lgr.py index 47e9ad04..afa3a282 100644 --- a/mfsetup/tests/test_lgr.py +++ b/mfsetup/tests/test_lgr.py @@ -240,7 +240,7 @@ def test_lgr_load(pleasant_lgr_setup_from_yaml, m2 = MF6model.load_from_config(pleasant_lgr_test_cfg_path) assert m2.inset['plsnt_lgr_inset'].simulation is m2.simulation - assert set(m2.get_package_list()).difference(m.get_package_list()) == {'SFR_OBS', 'CHD_OBS'} + assert set(m2.get_package_list()).difference(m.get_package_list()) == {'WEL_OBS', 'SFR_OBS', 'CHD_OBS'} # can't compare equality if sfr obs was added by SFRmaker, because it won't be listed in m.get_package_list() # but will be listed in m2.get_package_list() #assert m == m2 diff --git a/mfsetup/tests/test_pfl_mfnwt_inset.py b/mfsetup/tests/test_pfl_mfnwt_inset.py index cad27b05..41d2aea0 100644 --- a/mfsetup/tests/test_pfl_mfnwt_inset.py +++ b/mfsetup/tests/test_pfl_mfnwt_inset.py @@ -364,28 +364,11 @@ def test_upw_setup(pfl_nwt_with_dis, case, simulate_high_k_lakes): np.array([10, 10, 10, 10, 10])) -@pytest.mark.skip("still need to fix TMR") -def test_wel_tmr(pfl_nwt_with_dis): - m = pfl_nwt_with_dis #deepcopy(pfl_nwt_with_dis) - m.setup_upw() - - # test with tmr - m.cfg['model']['perimeter_boundary_type'] = 'specified flux' - wel = m.setup_wel() - wel.write_file() - assert os.path.exists(m.cfg['wel']['output_files']['lookup_file']) - df = pd.read_csv(m.cfg['wel']['output_files']['lookup_file']) - bfluxes0 = df.loc[(df.boundname == 'boundary_flux') & (df.per == 0)] - assert len(bfluxes0) == (m.nrow*2 + m.ncol*2) * m.nlay - - def test_wel_setup(pfl_nwt_with_dis_bas6): m = pfl_nwt_with_dis_bas6 #deepcopy(pfl_nwt_with_dis)deepcopy(pfl_nwt_with_dis) m.setup_upw() - # test without tmr - m.cfg['model']['perimeter_boundary_type'] = 'specified head' - wel = m.setup_wel() + wel = m.setup_wel(**m.cfg['wel'], **m.cfg['wel']['mfsetup_options']) wel.write_file() assert os.path.exists(m.cfg['wel']['output_files']['lookup_file']) df = pd.read_csv(m.cfg['wel']['output_files']['lookup_file']) @@ -406,39 +389,29 @@ def test_wel_setup(pfl_nwt_with_dis_bas6): def test_wel_setup_drop_ids(pfl_nwt_with_dis_bas6): m = pfl_nwt_with_dis_bas6 # deepcopy(pfl_nwt_with_dis)deepcopy(pfl_nwt_with_dis) m.setup_upw() - m.cfg['wel']['source_data']['wdnr_dataset']['drop_ids'] = [4026] - wel = m.setup_wel() + m.cfg['wel']['mfsetup_options']['external_files'] = False + wel = m.setup_wel(**m.cfg['wel'], **m.cfg['wel']['mfsetup_options']) df = pd.read_csv(m.cfg['wel']['output_files']['lookup_file']) assert 'site4026' not in df.boundname.tolist() assert len(df) == len(wel.stress_period_data[1]) -@pytest.mark.skip("not implemented yet") def test_wel_setup_csv_by_per(pfl_nwt_with_dis_bas6): m = pfl_nwt_with_dis_bas6 # deepcopy(pfl_nwt_with_dis)deepcopy(pfl_nwt_with_dis) m.setup_upw() # test adding a wel from a csv file - m.cfg['wel']['source_data']['csvfile'] = 'plainfieldlakes/source_data/added_wells.csv' - wel = m.setup_wel() + m.cfg['wel']['source_data']['csvfile'] = { + 'filename':'plainfieldlakes/source_data/added_wells.csv', + 'data_column': 'flux', + 'id_column': 'name', + 'datetime_column': 'datetime' + } + wel = m.setup_wel(**m.cfg['wel'], **m.cfg['wel']['mfsetup_options']) assert -2000 in wel.stress_period_data[1]['flux'] -@pytest.mark.skip("still working wel") -def test_wel_wu_resampling(inset_with_transient_parent): - - m = inset_with_transient_parent #deepcopy(inset_with_transient_parent) - m.cfg['upw']['hk'] = 1 - m.cfg['upw']['vka'] = 1 - m.setup_upw() - - # test without tmr - m.cfg['model']['perimeter_boundary_type'] = 'specified head' - m.cfg['wel']['period_stats'] = 'resample' - wel = m.setup_wel() - - def test_mnw_setup(pfl_nwt_with_dis): m = pfl_nwt_with_dis #deepcopy(pfl_nwt_with_dis) @@ -628,7 +601,7 @@ def test_lake_gag_setup(pfl_nwt_with_dis): def test_perimeter_boundary_setup(pfl_nwt_with_dis_bas6): m = pfl_nwt_with_dis_bas6 #deepcopy(pfl_nwt_with_dis) - chd = m.setup_chd() + chd = m.setup_chd(**m.cfg['chd'], **m.cfg['chd']['mfsetup_options']) chd.write_file() assert os.path.exists(chd.fn_path) assert len(chd.stress_period_data.data.keys()) == len(set(m.cfg['parent']['copy_stress_periods'])) diff --git a/mfsetup/tests/test_pleasant_mf6_inset.py b/mfsetup/tests/test_pleasant_mf6_inset.py index 6d4898d6..5bd58d7b 100644 --- a/mfsetup/tests/test_pleasant_mf6_inset.py +++ b/mfsetup/tests/test_pleasant_mf6_inset.py @@ -578,7 +578,8 @@ def test_model_setup(pleasant_mf6_setup_from_yaml, tmpdir): 'OBS_1', # lak obs todo: specify names of mf6 packages with multiple instances 'CHD_0', 'OBS_0', # chd obs - 'OBS_2' # head obs + 'OBS_2', # head obs + 'OBS_3' # head obs } external_path = os.path.join(m.model_ws, 'external') external_files = glob.glob(external_path + '/*') diff --git a/mfsetup/tests/test_pleasant_mfnwt_inset.py b/mfsetup/tests/test_pleasant_mfnwt_inset.py index d3dc76dc..51864da4 100644 --- a/mfsetup/tests/test_pleasant_mfnwt_inset.py +++ b/mfsetup/tests/test_pleasant_mfnwt_inset.py @@ -61,7 +61,7 @@ def test_setup_lak(pleasant_nwt_with_dis_bas6): def test_ghb_setup(get_pleasant_nwt_with_dis_bas6): m = get_pleasant_nwt_with_dis_bas6 - ghb = m.setup_ghb() + ghb = m.setup_ghb(**m.cfg['ghb'], **m.cfg['ghb']['mfsetup_options']) ghb.write_file() assert os.path.exists(ghb.fn_path) assert isinstance(ghb, fm.ModflowGhb) @@ -75,7 +75,7 @@ def test_ghb_setup(get_pleasant_nwt_with_dis_bas6): # check that heads are above layer botms assert np.all(spd0['bhead'] > m.dis.botm.array[k, i, j]) - assert np.all(spd0['cond'] == m.cfg['ghb']['cond']) + assert np.all(spd0['cond'] == m.cfg['ghb']['source_data']['cond']) def test_wel_setup(get_pleasant_nwt_with_dis_bas6): @@ -85,7 +85,7 @@ def test_wel_setup(get_pleasant_nwt_with_dis_bas6): # test without tmr m.cfg['model']['perimeter_boundary_type'] = 'specified head' - wel = m.setup_wel() + wel = m.setup_wel(**m.cfg['wel'], **m.cfg['wel']['mfsetup_options']) wel.write_file() assert os.path.exists(m.cfg['wel']['output_files']['lookup_file']) df = pd.read_csv(m.cfg['wel']['output_files']['lookup_file']) diff --git a/mfsetup/wells.py b/mfsetup/wells.py index b0abe908..e5fd16c4 100644 --- a/mfsetup/wells.py +++ b/mfsetup/wells.py @@ -64,7 +64,7 @@ def setup_wel_data(model, source_data=None, #for_external_files=True, # set boundnames based on well locations in parent model parent_name = parent.name - spd['boundname'] = ['{}_({},{},{})'.format(parent_name, pk, pi, pj) + spd['boundname'] = ['{}_{}-{}-{}'.format(parent_name, pk, pi, pj) for pk, pi, pj in zip(parent_well_k, parent_well_i, parent_well_j)] parent_well_x = parent.modelgrid.xcellcenters[parent_well_i, parent_well_j] @@ -209,10 +209,19 @@ def setup_wel_data(model, source_data=None, #for_external_files=True, if df.boundname.isna().any(): no_name = df.boundname.isna() k, i, j = df.loc[no_name, ['k', 'i', 'j']].T.values - names = ['({},{},{})'.format(k, i, j) for k, i, j in zip(k, i, j)] + names = ['wel_{}-{}-{}'.format(k, i, j) for k, i, j in zip(k, i, j)] df.loc[no_name, 'boundname'] = names assert not df.boundname.isna().any() + # if boundname is all ints (or can be casted as such) + # convert to strings, otherwise MODFLOW may mistake + # the boundnames in any observation files as cellids + try: + [int(s) for s in df['boundname']] + df['boundname'] = [f"wel_{bn}" for bn in df['boundname']] + except: + pass + # save a lookup file with well site numbers/categories df.sort_values(by=['boundname', 'per'], inplace=True) if model.version == 'mf6': From bd91dff101ccd2f0909088a8dbb452d2e47b7b0b Mon Sep 17 00:00:00 2001 From: "Leaf, Andrew T" Date: Mon, 2 May 2022 21:42:56 -0500 Subject: [PATCH 4/9] feat(specified flux boundaries): implement general specified flux perimeter boundary; add to Shellmound TMR example --- docs/source/concepts/perimeter-bcs.rst | 19 ++++++-- mfsetup/fileio.py | 3 +- mfsetup/mfmodel.py | 4 +- mfsetup/tests/data/shellmound_tmr_inset.yml | 6 +-- mfsetup/tests/test_mf6_tmr_shellmound.py | 51 +++++++++++++++++++-- mfsetup/tmr.py | 20 ++++++-- 6 files changed, 87 insertions(+), 16 deletions(-) diff --git a/docs/source/concepts/perimeter-bcs.rst b/docs/source/concepts/perimeter-bcs.rst index 55163f44..81a19671 100644 --- a/docs/source/concepts/perimeter-bcs.rst +++ b/docs/source/concepts/perimeter-bcs.rst @@ -7,12 +7,14 @@ Often the area we are trying to model is part of a larger flow system, and we mu Features and Limitations ------------------------- -* Currently, specified head perimeter boundaries are supported via the MODFLOW 6 Constant Head (CHD) Package; specified flux boundaries using the MODFLOW 6 Well (WEL) Package are in `active development `_. It is envisioned that specified flux perimeter cells will follow the same basic structure/conceptualization as specified heads. +* Currently, specified head perimeter boundaries are supported via the MODFLOW Constant Head (CHD) Package; specified flux boundaries are supported via the MODFLOW Well (WEL) Package. * The parent model solution (providing the values for the boundaries) is assumed to align with the inset model time discretization. * The parent model may have different length units. * The parent model may be of a different MODFLOW version (e.g. MODFLOW 6 inset with a MODFLOW-NWT parent) -* The inset model grid need not align with the parent model grid; values from the parent model solution are interpolated linearly to the cell centers along the inset model perimeter in the x, y and z directions (using a barycentric triangular method similar to :py:func:`scipy.interpolate.griddata`). However, this means that there may be some mismatch between the parent and inset model solutions along the inset model perimeter, in places where there are abrupt or non-linear head gradients. Boundaries for inset models should always be set sufficiently far away that they do not appreciably impact the model solution in the area(s) of interest. The :ref:`LGR capability ` of Modflow-setup can help with this. +* For specified head perimeter boundaries, the inset model grid need not align with the parent model grid; values from the parent model solution are interpolated linearly to the cell centers along the inset model perimeter in the x, y and z directions (using a barycentric triangular method similar to :py:func:`scipy.interpolate.griddata`). However, this means that there may be some mismatch between the parent and inset model solutions along the inset model perimeter, in places where there are abrupt or non-linear head gradients. Boundaries for inset models should always be set sufficiently far away that they do not appreciably impact the model solution in the area(s) of interest. The :ref:`LGR capability ` of Modflow-setup can help with this. +* Specified flux boundaries are currently limited to the parent and inset models being colinear. * The perimeter may be irregular. For example, the edge of the model active area may follow a major surface water feature along the opposite side. +* Specified perimeter heads in MODFLOW-NWT models will have ending heads for each stress period assigned from the starting head of the next stress period (with the last period having the same starting and ending heads). The MODFLOW 6 Constant Head Package only supports assignment of a single head per stress period. This distinction only matters for models where stress periods are subdivided by multiple timesteps. Input @@ -36,7 +38,7 @@ Input to set up perimeter boundaries are specified in two places: 2) In a ``perimeter_boundary:`` sub-block for the relevant package (only specified heads via CHD are currently supported). - Input example: + Input example (specified head): .. code-block:: yaml @@ -44,6 +46,17 @@ Input to set up perimeter boundaries are specified in two places: perimeter_boundary: parent_head_file: 'data/pleasant/pleasant.hds' + Input example (specified flux, with optional shapefile defining an irregular perimeter boundary, + and the MODFLOW 6 binary grid file, which is required for reading the cell budget output from MODFLOW 6 parent models): + + .. code-block:: yaml + + wel: + perimeter_boundary: + shapefile: 'shellmound/tmr_parent/gis/irregular_boundary.shp' + parent_cell_budget_file: 'shellmound/tmr_parent/shellmound.cbc' + parent_binary_grid_file: 'shellmound/tmr_parent/shellmound.dis.grb' + Time discretization ------------------- diff --git a/mfsetup/fileio.py b/mfsetup/fileio.py index bfd744c7..6a4b2a31 100644 --- a/mfsetup/fileio.py +++ b/mfsetup/fileio.py @@ -384,7 +384,8 @@ def _parse_file_path_keys_from_source_data(source_data, prefix=None, paths=False 'ref', 'dat', 'nc', 'yml', 'json', - 'hds', 'cbb', 'cbc'] + 'hds', 'cbb', 'cbc', + 'grb'] file_keys = ['filename', 'filenames', 'binaryfile', diff --git a/mfsetup/mfmodel.py b/mfsetup/mfmodel.py index c4889afd..6edd9101 100644 --- a/mfsetup/mfmodel.py +++ b/mfsetup/mfmodel.py @@ -1288,8 +1288,10 @@ def _setup_basic_stress_package(self, package, flopy_package_class, perimeter_cfg = kwargs['perimeter_boundary'] if package == 'chd': perimeter_cfg['boundary_type'] = 'head' + boundname = 'perimeter-heads' elif package == 'wel': perimeter_cfg['boundary_type'] = 'flux' + boundname = 'perimeter-fluxes' else: raise ValueError(f'Unsupported package for perimeter_boundary: {package.upper()}') if 'inset_parent_period_mapping' not in perimeter_cfg: @@ -1300,7 +1302,7 @@ def _setup_basic_stress_package(self, package, flopy_package_class, df = self.tmr.get_inset_boundary_values() # add boundname to allow boundary flux to be tracked as observation - df['boundname'] = 'perimeter-heads' + df['boundname'] = boundname dfs.append(df) # RIV package converted from SFR input diff --git a/mfsetup/tests/data/shellmound_tmr_inset.yml b/mfsetup/tests/data/shellmound_tmr_inset.yml index c5a4cf1c..421810f7 100644 --- a/mfsetup/tests/data/shellmound_tmr_inset.yml +++ b/mfsetup/tests/data/shellmound_tmr_inset.yml @@ -18,7 +18,6 @@ model: 'rch', 'sfr', 'wel', - 'chd' ] external_path: 'external/' relative_external_filepaths: True @@ -117,7 +116,8 @@ sfr: # to the MODFLOW River package to_riv: [18047212] -chd: +wel: perimeter_boundary: shapefile: 'shellmound/tmr_parent/gis/irregular_boundary.shp' - parent_head_file: 'shellmound/tmr_parent/shellmound.hds' # needed for the perimeter boundary setup + parent_cell_budget_file: 'shellmound/tmr_parent/shellmound.cbc' # needed for the perimeter boundary setup + parent_binary_grid_file: 'shellmound/tmr_parent/shellmound.dis.grb' diff --git a/mfsetup/tests/test_mf6_tmr_shellmound.py b/mfsetup/tests/test_mf6_tmr_shellmound.py index 172b75dd..837b3c13 100644 --- a/mfsetup/tests/test_mf6_tmr_shellmound.py +++ b/mfsetup/tests/test_mf6_tmr_shellmound.py @@ -170,7 +170,7 @@ def test_ic_setup(shellmound_tmr_model_with_dis, from_binary): """Test starting heads setup from model top or parent model head solution (MODFLOW binary output).""" m = copy.deepcopy(shellmound_tmr_model_with_dis) - binaryfile = m.cfg['chd']['perimeter_boundary']['parent_head_file'] + binaryfile = str(Path(m.parent.model_ws) / f'{m.parent.name}.hds') if from_binary: config = {'strt': {'from_parent': {'binaryfile': binaryfile, 'period': 0 @@ -186,9 +186,22 @@ def test_ic_setup(shellmound_tmr_model_with_dis, from_binary): assert m.ic.strt.array[m.dis.idomain.array > 0].max() < 50 -def test_irregular_perimeter_boundary(shellmound_tmr_model_with_dis, tmpdir): +def test_irregular_perimeter_head_boundary(shellmound_tmr_model_with_dis, test_data_path, tmpdir): m = shellmound_tmr_model_with_dis - chd = m.setup_chd(**m.cfg['chd'], **m.cfg['chd']['mfsetup_options']) + + if 'wel' in m.cfg: + del m.cfg['wel'] + head_cfg = { + 'perimeter_boundary': { + 'shapefile': test_data_path / 'shellmound/tmr_parent/gis/irregular_boundary.shp', + 'parent_head_file': test_data_path / 'shellmound/tmr_parent/shellmound.hds' + }, + 'mfsetup_options': { + 'external_files': True, + 'external_filename_fmt': 'chd_{:03d}.dat' + } + } + chd = m.setup_chd(**head_cfg, **head_cfg['mfsetup_options']) ra = chd.stress_period_data.array[0] kh, ih, jh = zip(*ra['cellid']) @@ -324,3 +337,35 @@ def test_model_setup(shellmound_tmr_model_setup): def test_model_setup_and_run(shellmound_tmr_model_setup_and_run): m = shellmound_tmr_model_setup_and_run # todo: add test comparing shellmound parent heads to tmr heads + plot_figure = False + if plot_figure: + from matplotlib import pyplot as plt + parent_headfile = Path(m.parent.model_ws) / f"{m.parent.name}.hds" + parent_hds = bf.HeadFile(parent_headfile) + parent_heads = parent_hds.get_data(kstpkper=(0, 0)) + parent_heads = np.ma.masked_array(parent_heads, mask=parent_heads > 1e5) + inset_hds = bf.HeadFile(Path(m.model_ws).absolute() / f"{m.name}.hds") + inset_heads = inset_hds.get_data(kstpkper=(0, 0)) + inset_heads = np.ma.masked_array(inset_heads, mask=inset_heads > 1e5) + + fig = plt.figure(figsize=(12, 9)) + ax = fig.add_subplot(1, 1, 1, aspect="equal") + pmv = flopy.plot.PlotMapView(model=m.parent, ax=ax) + arr = pmv.plot_array(parent_heads[3]) + contours = pmv.contour_array(parent_heads[3], colors="white", levels=np.linspace(30, 38, 9)) + ax.clabel(contours, fmt="%2.2f") + plt.colorbar(arr, shrink=0.5, ax=ax) + ax.set_title("Simulated Heads") + xmin, xmax = ax.get_xlim() + ymin, ymax = ax.get_ylim() + + pmv = flopy.plot.PlotMapView(model=m, ax=ax) + arr = pmv.plot_array(inset_heads[3], vmin=parent_heads.min(), vmax=parent_heads.max()) + contours = pmv.contour_array(inset_heads[3], colors="red", levels=np.linspace(30, 38, 9)) + ax.clabel(contours, fmt="%2.2f") + plt.colorbar(arr, shrink=0.5, ax=ax) + ax.set_title("Simulated Heads") + ax.set_xlim(xmin, xmax) + ax.set_ylim(ymin, ymax) + plt.savefig(m.model_ws / 'head_comp.pdf') + j=2 diff --git a/mfsetup/tmr.py b/mfsetup/tmr.py index 3f18b940..312f93b4 100644 --- a/mfsetup/tmr.py +++ b/mfsetup/tmr.py @@ -1866,10 +1866,14 @@ def get_inset_boundary_values(self, for_external_files=False): #qz_interp=v_flux) # assign q values and flip the sign for flux counter to the CBB convention directions of right and bottom - self.inset_boundary_cell_faces.loc[self.inset_boundary_cell_faces.cellface=='top', 'q_interp'] = self.inset_boundary_cell_faces.qy_interp - self.inset_boundary_cell_faces.loc[self.inset_boundary_cell_faces.cellface=='bottom', 'q_interp'] = self.inset_boundary_cell_faces.qy_interp * -1 - self.inset_boundary_cell_faces.loc[self.inset_boundary_cell_faces.cellface=='left', 'q_interp'] = self.inset_boundary_cell_faces.qx_interp - self.inset_boundary_cell_faces.loc[self.inset_boundary_cell_faces.cellface=='right', 'q_interp'] = self.inset_boundary_cell_faces.qx_interp * -1 + top_faces = self.inset_boundary_cell_faces.cellface == 'top' + self.inset_boundary_cell_faces.loc[top_faces, 'q_interp'] = self.inset_boundary_cell_faces.loc[top_faces, 'qy_interp'] + bottom_faces = self.inset_boundary_cell_faces.cellface == 'bottom' + self.inset_boundary_cell_faces.loc[bottom_faces, 'q_interp'] = -self.inset_boundary_cell_faces.loc[bottom_faces, 'qy_interp'] + left_faces = self.inset_boundary_cell_faces.cellface == 'left' + self.inset_boundary_cell_faces.loc[left_faces, 'q_interp'] = self.inset_boundary_cell_faces.loc[left_faces, 'qx_interp'] + right_faces = self.inset_boundary_cell_faces.cellface == 'right' + self.inset_boundary_cell_faces.loc[right_faces, 'q_interp'] = -self.inset_boundary_cell_faces.loc[right_faces, 'qx_interp'] # convert specific discharge in inset cells to Q -- flux for well package self.inset_boundary_cell_faces['q'] = \ @@ -1887,7 +1891,13 @@ def get_inset_boundary_values(self, for_external_files=False): df['per'] = inset_per # boundary fluxes must be in active cells - dfs.append(df.loc[df['idomain'] > 0]) + # corresponding parent cells must be active too, + # otherwise a nan flux will be produced + # drop nan fluxes, which will revert these boundary cells to the + # default no-flow condition in MODFLOW + # (consistent with parent model cell being inactive) + keep = (df['idomain'] > 0) & ~df['q'].isna() + dfs.append(df.loc[keep].copy()) print("took {:.2f}s".format(time.time() - t1)) df = pd.concat(dfs) From 34219ac44b6c8b662d046a7af94f09bddd824912 Mon Sep 17 00:00:00 2001 From: "Leaf, Andrew T" Date: Tue, 3 May 2022 08:39:01 -0500 Subject: [PATCH 5/9] fix(tests): add missing plainfieldlakes/source_data/added_wells.csv data file --- mfsetup/tests/data/plainfieldlakes/source_data/added_wells.csv | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 mfsetup/tests/data/plainfieldlakes/source_data/added_wells.csv diff --git a/mfsetup/tests/data/plainfieldlakes/source_data/added_wells.csv b/mfsetup/tests/data/plainfieldlakes/source_data/added_wells.csv new file mode 100644 index 00000000..f6d57e0a --- /dev/null +++ b/mfsetup/tests/data/plainfieldlakes/source_data/added_wells.csv @@ -0,0 +1,2 @@ +per,datetime,name,x,y,k,flux +1,2011-01-01,well1,563343.92,414988.09,0,-2000 From 9852a585177b14325edbe5171fccd1a78aec0581 Mon Sep 17 00:00:00 2001 From: "Leaf, Andrew T" Date: Tue, 3 May 2022 11:59:24 -0500 Subject: [PATCH 6/9] refactor: * remove old ad-hoc methods for setting up basic stress boundaries * remove old Tmr class and associated tests --- mfsetup/bcs.py | 116 ----- mfsetup/mf6model.py | 57 --- mfsetup/mfmodel.py | 12 +- mfsetup/mfnwtmodel.py | 133 +----- mfsetup/tests/test_tmr.py | 62 +-- mfsetup/tmr.py | 928 +------------------------------------- mfsetup/wells.py | 1 - 7 files changed, 16 insertions(+), 1293 deletions(-) diff --git a/mfsetup/bcs.py b/mfsetup/bcs.py index d8da0137..c72d9495 100644 --- a/mfsetup/bcs.py +++ b/mfsetup/bcs.py @@ -153,122 +153,6 @@ def setup_basic_stress_data(model, shapefile=None, csvfile=None, df = df[cols].copy() return df - -#def setup_stress_period_data(data, model, flopy_package, -# filepaths=None, -# external_files_folder=None): -# """Setup basic stress package stress_period_data for Flopy or Modflow, -# either as external files or a dictionary of recarrays. -# -# Parameters -# ---------- -# data : DataFrame -# -# """ -# -# spd = {} -# by_period = data.groupby('per') -# for kper, df_per in by_period: -# if filepaths is not None: -# df_per = df_per.copy() -# df_per.drop('per', axis=1, inplace=True) -# df_per.rename(columns={'k': '#k'}, inplace=True) -# for col in '#k', 'i', 'j': -# df_per[col] += 1 -# df_per.to_csv(filepaths[kper]['filename'], index=False, sep=' ') -# # make a copy for the intermediate data folder, for consistency with mf-2005 -# shutil.copy(filepaths[kper]['filename'], external_files_folder) -# else: -# maxbound = len(df_per) -# spd[kper] = flopy_package.stress_period_data.empty(model, maxbound=maxbound, -# boundnames=True)[0] -# spd[kper]['cellid'] = list(zip(df_per['k'], df_per['i'], df_per['j'])) -# for col in 'cond', 'stage', 'rbot': -# spd[kper][col] = df_per[col] -# spd[kper]['boundname'] = ["'{}'".format(s) for s in df_per['name']] -# return spd - - -def setup_ghb_data(model): - - m = model - source_data = model.cfg['ghb'].get('source_data').copy() - # get the GHB cells - # todo: generalize more of the GHB setup code and move it somewhere else - if 'shapefile' in source_data: - shapefile_data = source_data['shapefile'] - key = [k for k in shapefile_data.keys() if 'filename' in k.lower()][0] - shapefile_name = shapefile_data.pop(key) - ghbcells = rasterize(shapefile_name, m.modelgrid, **shapefile_data) - else: - raise NotImplementedError('Only shapefile input supported for GHBs') - - cond = model.cfg['ghb'].get('cond') - if cond is None: - raise KeyError("key 'cond' not found in GHB yaml input. " - "Must supply conductance via this key for GHB setup.") - - # sample DEM for minimum elevation in each cell with a GHB - # todo: GHB: allow time-varying bheads via csv input - vertices = np.array(m.modelgrid.vertices)[ghbcells.flat > 0, :, :] - polygons = [Polygon(vrts) for vrts in vertices] - if 'dem' in source_data: - key = [k for k in source_data['dem'].keys() if 'filename' in k.lower()][0] - dem_filename = source_data['dem'].pop(key) - with rasterio.open(dem_filename) as src: - meta = src.meta - - # reproject the polygons to the dem crs if needed - try: - from gisutils import get_authority_crs - dem_crs = get_authority_crs(src.crs) - except: - dem_crs = pyproj.crs.CRS.from_user_input(src.crs) - if dem_crs != m.modelgrid.crs: - polygons = project(polygons, m.modelgrid.crs, dem_crs) - - all_touched = False - if meta['transform'][0] > m.modelgrid.delr[0]: - all_touched = True - results = zonal_stats(polygons, dem_filename, stats='min', - all_touched=all_touched) - min_elevs = np.ones((m.nrow * m.ncol), dtype=float) * np.nan - min_elevs[ghbcells.flat > 0] = np.array([r['min'] for r in results]) - units_key = [k for k in source_data['dem'] if 'units' in k] - if len(units_key) > 0: - min_elevs *= convert_length_units(source_data['dem'][units_key[0]], - model.length_units) - min_elevs = np.reshape(min_elevs, (m.nrow, m.ncol)) - else: - raise NotImplementedError('Must supply DEM to sample for GHB elevations\n' - '(GHB: source_data: dem:)') - - # make a DataFrame with MODFLOW input - i, j = np.indices((m.nrow, m.ncol)) - df = pd.DataFrame({'per': 0, - 'k': 0, - 'i': i.flat, - 'j': j.flat, - 'bhead': min_elevs.flat, - 'cond': cond}) - df.dropna(axis=0, inplace=True) - - # assign layers so that bhead is above botms - df['k'] = get_layer(model.dis.botm.array, df.i, df.j, df.bhead) - # remove GHB cells from places where the specified head is below the model - below_bottom_of_model = df.bhead < model.dis.botm.array[-1, df.i, df.j] + 0.01 - df = df.loc[~below_bottom_of_model].copy() - - # exclude inactive cells - k, i, j = df.k, df.i, df.j - if model.version == 'mf6': - active_cells = model.idomain[k, i, j] >= 1 - else: - active_cells = model.ibound[k, i, j] >= 1 - df = df.loc[active_cells] - return df - - def get_bc_package_cells(package, exclude_horizontal=True): """ diff --git a/mfsetup/mf6model.py b/mfsetup/mf6model.py index 935cf266..c5f3c1ca 100644 --- a/mfsetup/mf6model.py +++ b/mfsetup/mf6model.py @@ -22,7 +22,6 @@ make_lgr_idomain, ) from mfsetup.fileio import add_version_to_fileheader, flopy_mfsimulation_load -from mfsetup.fileio import load from mfsetup.fileio import load as load_config from mfsetup.fileio import load_cfg from mfsetup.ic import setup_strt @@ -39,10 +38,8 @@ from mfsetup.obs import setup_head_observations from mfsetup.oc import parse_oc_period_input from mfsetup.tdis import add_date_comments_to_tdis -from mfsetup.tmr import TmrNew from mfsetup.units import convert_time_units from mfsetup.utils import flatten, get_input_arguments -from mfsetup.wells import setup_wel_data class MF6model(MFsetupMixin, mf6.ModflowGwf): @@ -544,60 +541,6 @@ def setup_rch(self, **kwargs): print("finished in {:.2f}s\n".format(time.time() - t0)) return rch - def setup_wel_old(self, **kwargs): - """ - Sets up the WEL package. - """ - package = 'wel' - print('\nSetting up {} package...'.format(package.upper())) - t0 = time.time() - - # option to write stress_period_data to external files - external_files = self.cfg[package]['external_files'] - - # munge well package input - # returns dataframe with information to populate stress_period_data - df = setup_wel_data(self, for_external_files=external_files) - if len(df) == 0: - print('No wells in active model area') - return - - # set up stress_period_data - if external_files: - # get the file path (allowing for different external file locations, specified name format, etc.) - filename_format = self.cfg[package]['external_filename_fmt'] - filepaths = self.setup_external_filepaths(package, 'stress_period_data', - filename_format=filename_format, - file_numbers=sorted(df.per.unique().tolist())) - spd = {} - period_groups = df.groupby('per') - for kper in range(self.nper): - if kper in period_groups.groups: - group = period_groups.get_group(kper) - group.drop('per', axis=1, inplace=True) - if external_files: - group.to_csv(filepaths[kper]['filename'], index=False, sep=' ', float_format='%g') - # make a copy for the intermediate data folder, for consistency with mf-2005 - shutil.copy(filepaths[kper]['filename'], self.cfg['intermediate_data']['output_folder']) - else: - kspd = mf6.ModflowGwfwel.stress_period_data.empty(self, - len(group), - boundnames=True)[0] - kspd['cellid'] = list(zip(group.k, group.i, group.j)) - kspd['q'] = group['q'] - kspd['boundname'] = group['boundname'] - spd[kper] = kspd - else: - pass # spd[kper] = None - kwargs = self.cfg[package].copy() - kwargs.update(self.cfg[package]['options']) - if not external_files: - kwargs['stress_period_data'] = spd - kwargs = get_input_arguments(kwargs, mf6.ModflowGwfwel) - wel = mf6.ModflowGwfwel(self, **kwargs) - print("finished in {:.2f}s\n".format(time.time() - t0)) - return wel - def setup_lak(self, **kwargs): """ Sets up the Lake package. diff --git a/mfsetup/mfmodel.py b/mfsetup/mfmodel.py index 6edd9101..133ea941 100644 --- a/mfsetup/mfmodel.py +++ b/mfsetup/mfmodel.py @@ -15,13 +15,7 @@ mf6 = flopy.mf6 import gisutils import sfrmaker -from gisutils import ( - get_proj_str, - get_shapefile_crs, - get_values_at_points, - project, - shp2df, -) +from gisutils import get_shapefile_crs, get_values_at_points, project from sfrmaker import Lines from sfrmaker.utils import assign_layers @@ -61,7 +55,7 @@ setup_perioddata, setup_perioddata_group, ) -from mfsetup.tmr import TmrNew +from mfsetup.tmr import Tmr from mfsetup.units import convert_length_units, lenuni_text, lenuni_values from mfsetup.utils import flatten, get_input_arguments, get_packages, update from mfsetup.wells import setup_wel_data @@ -1298,7 +1292,7 @@ def _setup_basic_stress_package(self, package, flopy_package_class, perimeter_cfg['inset_parent_period_mapping'] = self.parent_stress_periods if 'parent_start_time' not in perimeter_cfg: perimeter_cfg['parent_start_date_time'] = self.parent.perioddata['start_datetime'][0] - self.tmr = TmrNew(self.parent, self, **perimeter_cfg) + self.tmr = Tmr(self.parent, self, **perimeter_cfg) df = self.tmr.get_inset_boundary_values() # add boundname to allow boundary flux to be tracked as observation diff --git a/mfsetup/mfnwtmodel.py b/mfsetup/mfnwtmodel.py index a88c7d85..61614a86 100644 --- a/mfsetup/mfnwtmodel.py +++ b/mfsetup/mfnwtmodel.py @@ -12,11 +12,7 @@ fm = flopy.modflow from flopy.modflow import Modflow -from mfsetup.bcs import ( - remove_inactive_bcs, - setup_flopy_stress_period_data, - setup_ghb_data, -) +from mfsetup.bcs import remove_inactive_bcs from mfsetup.discretization import ( deactivate_idomain_above, find_remove_isolated_cells, @@ -38,15 +34,12 @@ setup_lake_tablefiles, ) from mfsetup.mfmodel import MFsetupMixin -from mfsetup.obs import read_observation_data, setup_head_observations +from mfsetup.obs import setup_head_observations from mfsetup.oc import parse_oc_period_input from mfsetup.tdis import get_parent_stress_periods, setup_perioddata_group -from mfsetup.tmr import TmrNew from mfsetup.units import convert_length_units, itmuni_text, lenuni_text from mfsetup.utils import get_input_arguments, get_packages -from .wells import setup_wel_data - class MFnwtModel(MFsetupMixin, Modflow): """Class representing a MODFLOW-NWT model""" @@ -430,74 +423,6 @@ def setup_upw(self, **kwargs): print("finished in {:.2f}s\n".format(time.time() - t0)) return upw - def setup_wel_old(self, **kwargs): - """ - Setup the WEL package, including boundary fluxes and any pumping. - - This will need some additional customization if pumping is mixed with - the perimeter fluxes. - - - TODO: generalize well package setup with specific input requirements - - - """ - - print('setting up WEL package...') - t0 = time.time() - - # munge the well package input - # for_external_files only needs to be called on the modflow-6 side - df = setup_wel_data(self, for_external_files=False) - - # extend spd dtype to include comments - dtype = fm.ModflowWel.get_default_dtype() - - # setup stress period data - groups = df.groupby('per') - spd = {} - for per, perdf in groups: - ra = np.recarray(len(perdf), dtype=dtype) - for c in ['k', 'i', 'j']: - ra[c] = perdf[c] - ra['flux'] = perdf['q'] - spd[per] = ra - - wel = fm.ModflowWel(self, ipakcb=self.ipakcb, - options=self.cfg['wel']['options'], - stress_period_data=spd) - print("finished in {:.2f}s\n".format(time.time() - t0)) - return wel - - def setup_ghb_old(self, **kwargs): - """ - Set up the GHB package - """ - - print('setting up GHB package...') - t0 = time.time() - - df = setup_ghb_data(self) - - # extend spd dtype to include comments - dtype = fm.ModflowGhb.get_default_dtype() - - # setup stress period data - groups = df.groupby('per') - spd = {} - for per, perdf in groups: - ra = np.recarray(len(perdf), dtype=dtype) - for c in ['k', 'i', 'j', 'bhead', 'cond']: - ra[c] = perdf[c] - spd[per] = ra - - ghb = fm.ModflowGhb(self, ipakcb=self.ipakcb, - stress_period_data=spd) - self._reset_bc_arrays() - self._ibound = None - print("finished in {:.2f}s\n".format(time.time() - t0)) - return ghb - def setup_mnw2(self, **kwargs): print('setting up MNW2 package...') @@ -683,21 +608,18 @@ def setup_lak(self, **kwargs): print("finished in {:.2f}s\n".format(time.time() - t0)) return lak - def setup_chd(self, **kwargs): """Set up the CHD Package. """ return self._setup_basic_stress_package( 'chd', fm.ModflowChd, ['head'], **kwargs) - def setup_drn(self, **kwargs): """Set up the Drain Package. """ return self._setup_basic_stress_package( 'drn', fm.ModflowDrn, ['elev', 'cond'], **kwargs) - def setup_ghb(self, **kwargs): """Set up the General Head Boundary Package. """ @@ -712,14 +634,12 @@ def setup_riv(self, rivdata=None, **kwargs): 'riv', fm.ModflowRiv, ['stage', 'cond', 'rbot'], rivdata=rivdata, **kwargs) - def setup_wel(self, **kwargs): """Set up the Well Package. """ return self._setup_basic_stress_package( 'wel', fm.ModflowWel, ['flux'], **kwargs) - def setup_nwt(self, **kwargs): print('setting up NWT package...') @@ -843,55 +763,6 @@ def setup_gag(self, **kwargs): print("finished in {:.2f}s\n".format(time.time() - t0)) return gag - def setup_chd_old(self, **kwargs): - """ - Sets up the CHD package. - """ - package = 'chd' - print('\nSetting up {} package...'.format(package.upper())) - t0 = time.time() - package_config = self.cfg[package] - - # option to write stress_period_data to external files - external_files = False # not yet supported for MODFLOW-NWT - external_filename_fmt = package_config.get('external_filename_fmt') - - # perimeter boundary - if 'perimeter_boundary' in package_config: - perimeter_cfg = package_config['perimeter_boundary'] - perimeter_cfg['boundary_type'] = 'head' - if 'inset_parent_period_mapping' not in perimeter_cfg: - perimeter_cfg['inset_parent_period_mapping'] = self.parent_stress_periods - if 'parent_start_time' not in perimeter_cfg: - perimeter_cfg['parent_start_date_time'] = self.parent.perioddata['start_datetime'][0] - self.tmr = TmrNew(self.parent, self, **perimeter_cfg) - perimeter_df = self.tmr.get_inset_boundary_values() - - # get the stress period data - # this also sets up the external file paths - spd = setup_flopy_stress_period_data(self, package, perimeter_df, - flopy_package_class=fm.ModflowChd, - variable_columns=['head'], - external_files=external_files, - external_filename_fmt=external_filename_fmt) - - # placeholder for setting up user-specified CHD cells from CSV data - # todo: support for non-perimeter chd cells - df = pd.DataFrame() # insert function here to get csv data into dataframe - if len(df) == 0: - print('No other CHD input specified') - if 'perimeter_boundary' not in package_config: - return - - kwargs = self.cfg[package].copy() - if not external_files: - kwargs['stress_period_data'] = spd - - kwargs = get_input_arguments(kwargs, fm.ModflowChd) - chd = fm.ModflowChd(self, **kwargs) - print("setup of chd took {:.2f}s\n".format(time.time() - t0)) - return chd - def write_input(self): """Write the model input. """ diff --git a/mfsetup/tests/test_tmr.py b/mfsetup/tests/test_tmr.py index d1316533..5aa4b25a 100644 --- a/mfsetup/tests/test_tmr.py +++ b/mfsetup/tests/test_tmr.py @@ -19,7 +19,7 @@ from mfsetup.discretization import get_layer from mfsetup.fileio import exe_exists from mfsetup.grid import MFsetupGrid, get_ij -from mfsetup.tmr import Tmr, TmrNew, get_qx_qy_qz +from mfsetup.tmr import Tmr, get_qx_qy_qz from mfsetup.zbud import write_zonebudget6_input from .test_mf6_tmr_shellmound import ( @@ -46,56 +46,6 @@ def pleasant_model(request, 'pleasant_nwt_with_dis_bas6': pleasant_nwt_with_dis_bas6}[request.param] -@pytest.fixture(scope='function') -def tmr(pleasant_model): - m = pleasant_model - tmr = Tmr(m.parent, m, - parent_head_file=m.cfg['chd']['perimeter_boundary']['parent_head_file'], - inset_parent_layer_mapping=m.parent_layers, - inset_parent_period_mapping=m.parent_stress_periods) - return tmr - - -@pytest.fixture(scope='function') -def parent_heads(tmr): - headfile = tmr.hpth - hdsobj = bf.HeadFile(headfile) - yield hdsobj # provide the fixture value - # code below yield statement is executed after test function finishes - print("closing the heads file") - hdsobj.close() - - -def test_get_inset_boundary_heads(tmr, parent_heads): - """Verify that inset model specified head boundary accurately - reflects parent model head solution, including when cells - are dry or missing (e.g. pinched out cells in MF6). - """ - bheads_df = tmr.get_inset_boundary_heads(for_external_files=False) - groups = bheads_df.groupby('per') - all_kstpkper = parent_heads.get_kstpkper() - kstpkper_list = [all_kstpkper[0], all_kstpkper[-1]] - for kstp, kper in kstpkper_list: - hds = parent_heads.get_data(kstpkper=(kstp, kper)) - df = groups.get_group(kper) - df['cellid'] = list(zip(df.k, df.i, df.j)) - # check for duplicate locations (esp. corners) - # in mf2005, duplicate chd heads will be summed - assert not df.cellid.duplicated().any() - - # x, y, z locations of inset model boundary cells - ix = tmr.inset.modelgrid.xcellcenters[df.i, df.j] - iy = tmr.inset.modelgrid.ycellcenters[df.i, df.j] - iz = tmr.inset.modelgrid.zcellcenters[df.k, df.i, df.j] - - # parent model grid cells associated with inset boundary cells - i, j = get_ij(tmr.parent.modelgrid, ix, iy) - k = get_layer(tmr.parent.dis.botm.array, i, j, iz) - - # error between parent heads and inset heads - # todo: interpolate parent head solution to inset points for comparison - - @pytest.mark.parametrize('specific_discharge',(False, True)) def test_get_qx_qy_qz(tmpdir, parent_model_mf6, parent_model_nwt, specific_discharge): """Compare get_qx_qy_qz results between mf6 and nwt @@ -144,7 +94,7 @@ def test_tmr_new(pleasant_model): parent_headfile = Path(m.cfg['chd']['perimeter_boundary']['parent_head_file']) parent_cellbudgetfile = parent_headfile.with_suffix('.cbc') - tmr = TmrNew(m.parent, m, + tmr = Tmr(m.parent, m, parent_head_file=parent_headfile) results = tmr.get_inset_boundary_values(for_external_files=False) @@ -180,7 +130,7 @@ def test_get_boundary_cells_shapefile(shellmound_tmr_model_with_dis, test_data_p from mfexport import export export(m, m.modelgrid, 'dis', 'idomain', pdfs=False, output_path=tmpdir) boundary_shapefile = test_data_path / 'shellmound/tmr_parent/gis/irregular_boundary.shp' - tmr = TmrNew(m.parent, m, + tmr = Tmr(m.parent, m, inset_parent_period_mapping=m.parent_stress_periods, boundary_type='head') df = tmr.get_inset_boundary_cells(shapefile=boundary_shapefile) @@ -558,7 +508,7 @@ def test_get_boundary_heads(parent_model, inset_model, parent_budget_file = parent_ws / f'{parent_model.name}.cbc' parent_head_file = parent_ws / f'{parent_model.name}.hds' parent_binary_grid_file = parent_ws / f'{parent_model.name}.dis.grb' - tmr = TmrNew(parent_model, m, parent_head_file=parent_head_file, + tmr = Tmr(parent_model, m, parent_head_file=parent_head_file, boundary_type='head', ) perimeter_df = tmr.get_inset_boundary_values() @@ -739,7 +689,7 @@ def test_get_boundary_fluxes(parent_model, inset_model, parent_binary_grid_file = parent_ws / f'{parent_model.name}.dis.grb' else: parent_binary_grid_file = None - tmr = TmrNew(parent_model, m, parent_cell_budget_file=parent_budget_file, + tmr = Tmr(parent_model, m, parent_cell_budget_file=parent_budget_file, parent_binary_grid_file=parent_binary_grid_file, parent_head_file=parent_head_file, boundary_type='flux', @@ -956,7 +906,7 @@ def test_parent_xyzcellfacecenters(parent_model_mf6, inset_model_mf6): parent_budget_file = parent_ws / f'{parent_model_mf6.name}.cbc' parent_head_file = parent_ws / f'{parent_model_mf6.name}.hds' parent_binary_grid_file = parent_ws / f'{parent_model_mf6.name}.dis.grb' - tmr = TmrNew(parent_model_mf6, inset_model_mf6, parent_cell_budget_file=parent_budget_file, + tmr = Tmr(parent_model_mf6, inset_model_mf6, parent_cell_budget_file=parent_budget_file, parent_binary_grid_file=parent_binary_grid_file, parent_head_file=parent_head_file, boundary_type='flux', diff --git a/mfsetup/tmr.py b/mfsetup/tmr.py index 312f93b4..641dbeb4 100644 --- a/mfsetup/tmr.py +++ b/mfsetup/tmr.py @@ -1,4 +1,3 @@ -import os import time from pathlib import Path @@ -12,854 +11,12 @@ from flopy.discretization import StructuredGrid from flopy.mf6.utils.binarygrid_util import MfGrdFile from flopy.utils import binaryfile as bf -from flopy.utils.postprocessing import get_water_table -from scipy.interpolate import griddata -from mfsetup.discretization import ( - find_remove_isolated_cells, - weighted_average_between_layers, -) +from mfsetup.discretization import find_remove_isolated_cells from mfsetup.fileio import check_source_files from mfsetup.grid import get_cellface_midpoint, get_ij -from mfsetup.interpolate import ( - Interpolator, - get_source_dest_model_xys, - interp_weights, - interpolate, - regrid, -) +from mfsetup.interpolate import Interpolator, interp_weights from mfsetup.lakes import get_horizontal_connections -from mfsetup.sourcedata import ArraySourceData -from mfsetup.units import convert_length_units - - -class Tmr: - """ - Class for basic telescopic mesh refinement of a MODFLOW model. - Handles the case where the pfl_nwt grid is a rectangle exactly aligned with - the parent grid. - - Parameters - ---------- - parent_model : flopy.modflow.Modflow instance of parent model - Must have a valid, attached ModelGrid (modelgrid) attribute. - inset_model : flopy.modflow.Modflow instance of pfl_nwt model - Must have a valid, attached ModelGrid (modelgrid) attribute. - ModelGrid of pfl_nwt and parent models is used to determine cell - connections. - parent_head_file : filepath - MODFLOW binary head output - parent_cell_budget_file : filepath - MODFLOW binary cell budget output - - - Notes - ----- - Assumptions: - * Uniform parent and pfl_nwt grids, with equal delr and delc spacing. - * Inset model upper right corner coincides with an upper right corner of a cell - in the parent model - * Inset cell spacing is a factor of the parent cell spacing - (so that each pfl_nwt cell is only connected horizontally to one parent cell). - * Inset model row/col dimensions are multiples of parent model cells - (no parent cells that only partially overlap the pfl_nwt model) - * Horizontally, fluxes are uniformly distributed to child cells within a parent cell. The - * Vertically, fluxes are distributed based on transmissivity (sat. thickness x Kh) of - pfl_nwt model layers. - * The pfl_nwt model is fully penetrating. Total flux through each column of parent cells - is equal to the total flux through the corresponding columns of connected pfl_nwt model cells. - The get_inset_boundary_flux_side verifies this with an assertion statement. - - """ - flow_component = {'top': 'fff', 'bottom': 'fff', - 'left': 'frf', 'right': 'frf'} - flow_sign = {'top': 1, 'bottom': -1, - 'left': 1, 'right': -1} - - def __init__(self, parent_model, inset_model, - parent_head_file=None, parent_cell_budget_file=None, - parent_length_units=None, inset_length_units=None, - inset_parent_layer_mapping=None, - inset_parent_period_mapping=None, - ): - - self.inset = inset_model - self.parent = parent_model - self.inset._set_parent_modelgrid() - self.cbc = None - self._inset_parent_layer_mapping = inset_parent_layer_mapping - self._source_mask = None - self._inset_parent_period_mapping = inset_parent_period_mapping - self.hpth = None # path to parent heads output file - self.cpth = None # path to parent cell budget output file - - self.pi0 = None - self.pj0 = None - self.pi1 = None - self.pj1 = None - self.pi_list = None - self.pj_list = None - - if parent_length_units is None: - parent_length_units = self.inset.cfg['parent']['length_units'] - if inset_length_units is None: - inset_length_units = self.inset.length_units - self.length_unit_conversion = convert_length_units(parent_length_units, inset_length_units) - - if parent_head_file is None: - parent_head_file = os.path.join(self.parent.model_ws, - '{}.hds'.format(self.parent.name)) - if os.path.exists(parent_head_file): - self.hpth = parent_cell_budget_file - else: - self.hpth = parent_head_file - if parent_cell_budget_file is None: - for extension in 'cbc', 'cbb': - parent_cell_budget_file = os.path.join(self.parent.model_ws, - '{}.{}'.format(self.parent.name, extension)) - if os.path.exists(parent_cell_budget_file): - self.cpth = parent_cell_budget_file - break - else: - self.cpth = parent_cell_budget_file - - if self.hpth is None and self.cpth is None: - raise ValueError("No head or cell budget output files found for parent model {}".format(self.parent.name)) - - # get bounding cells in parent model for pfl_nwt model - irregular_domain = False - - # see if irregular domain - irregbound_cfg = self.inset.cfg['perimeter_boundary'].get('source_data',{}).get('irregular_boundary') - if irregbound_cfg is not None: - irregular_domain = True - irregbound_cfg['variable'] = 'perimeter_boundary' - irregbound_cfg['dest_model'] = self.inset - - - sd = ArraySourceData.from_config(irregbound_cfg) - data = sd.get_data() - idm_outline = data[0] - connections = get_horizontal_connections(idm_outline, connection_info=False, - layer_elevations=1, - delr=1, delc=1, inside=True) - self.pi_list, self.pj_list = connections.i.to_list(), connections.j.to_list() - # otherwise just get the corners of the inset if rectangular domain - else: - self.pi0, self.pj0 = get_ij(self.parent.modelgrid, - self.inset.modelgrid.xcellcenters[0, 0], - self.inset.modelgrid.ycellcenters[0, 0]) - self.pi1, self.pj1 = get_ij(self.parent.modelgrid, - self.inset.modelgrid.xcellcenters[-1, -1], - self.inset.modelgrid.ycellcenters[-1, -1]) - self.parent_nrow_in_inset = self.pi1 - self.pi0 + 1 - self.parent_ncol_in_inset = self.pj1 - self.pj0 + 1 - - # check for an even number of inset cells per parent cell in x and y directions - x_refinement = self.parent.modelgrid.delr[0] / self.inset.modelgrid.delr[0] - y_refinement = self.parent.modelgrid.delc[0] / self.inset.modelgrid.delc[0] - msg = "inset {0} of {1:.2f} {2} must be factor of parent {0} of {3:.2f} {4}" - if not int(x_refinement) == np.round(x_refinement, 2): - raise ValueError(msg.format('delr', self.inset.modelgrid.delr[0], self.inset.modelgrid.length_units, - self.parent.modelgrid.delr[0], self.parent.modelgrid.length_units)) - if not int(y_refinement) == np.round(y_refinement, 2): - raise ValueError(msg.format('delc', self.inset.modelgrid.delc[0], self.inset.modelgrid.length_units, - self.parent.modelgrid.delc[0], self.parent.modelgrid.length_units)) - if not np.allclose(x_refinement, y_refinement): - raise ValueError("grid must have same x and y discretization") - self.refinement = int(x_refinement) - - @property - def inset_parent_layer_mapping(self): - nlay = self.inset.nlay - # if mapping between source and dest model layers isn't specified - # use property from dest model - # this will be the DIS package layer mapping if specified - # otherwise same layering is assumed for both models - if self._inset_parent_layer_mapping is None: - return self.inset.parent_layers - elif self._inset_parent_layer_mapping is not None: - nspecified = len(self._inset_parent_layer_mapping) - if nspecified != nlay: - raise Exception("Variable should have {} layers " - "but only {} are specified: {}" - .format(nlay, nspecified, self._inset_parent_layer_mapping)) - return self._inset_parent_layer_mapping - - @property - def inset_parent_period_mapping(self): - nper = self.inset.nper - # if mapping between source and dest model periods isn't specified - # assume one to one mapping of stress periods between models - if self._inset_parent_period_mapping is None: - parent_periods = list(range(self.parent.nper)) - self._inset_parent_period_mapping = {i: parent_periods[i] - if i < self.parent.nper else parent_periods[-1] for i in range(nper)} - else: - return self._inset_parent_period_mapping - - @inset_parent_period_mapping.setter - def inset_parent_period_mapping(self, inset_parent_period_mapping): - self._inset_parent_period_mapping = inset_parent_period_mapping - - @property - def _source_grid_mask(self): - """Boolean array indicating window in parent model grid (subset of cells) - that encompass the pfl_nwt model domain. Used to speed up interpolation - of parent grid values onto pfl_nwt grid.""" - if self._source_mask is None: - mask = np.zeros((self.parent.modelgrid.nrow, - self.parent.modelgrid.ncol), dtype=bool) - if self.inset.parent_mask.shape == self.parent.modelgrid.xcellcenters.shape: - mask = self.inset.parent_mask - else: - x, y = np.squeeze(self.inset.bbox.exterior.coords.xy) - pi, pj = get_ij(self.parent.modelgrid, x, y) - pad = 3 - i0, i1 = pi.min() - pad, pi.max() + pad - j0, j1 = pj.min() - pad, pj.max() + pad - mask[i0:i1, j0:j1] = True - self._source_mask = mask - return self._source_mask - - @property - def interp_weights(self): - """For a given parent, only calculate interpolation weights - once to speed up re-gridding of arrays to pfl_nwt.""" - if self._interp_weights is None: - source_xy, dest_xy = get_source_dest_model_xys(self.parent.modelgrid, - self.inset.modelgrid, - source_mask=self._source_grid_mask) - self._interp_weights = interp_weights(source_xy, dest_xy) - return self._interp_weights - - def regrid_from_parent(self, source_array, - mask=None, - method='linear'): - """Interpolate values in source array onto - the destination model grid, using SpatialReference instances - attached to the source and destination models. - - Parameters - ---------- - source_array : ndarray - Values from source model to be interpolated to destination grid. - 1 or 2-D numpy array of same sizes as a - layer of the source model. - mask : ndarray (bool) - 1 or 2-D numpy array of same sizes as a - layer of the source model. True values - indicate cells to include in interpolation, - False values indicate cells that will be - dropped. - method : str ('linear', 'nearest') - Interpolation method. - """ - if mask is not None: - return regrid(source_array, self.parent.modelgrid, self.inset.modelgrid, - mask1=mask, - method=method) - if method == 'linear': - parent_values = source_array.flatten()[self._source_grid_mask.flatten()] - regridded = interpolate(parent_values, - *self.interp_weights) - elif method == 'nearest': - regridded = regrid(source_array, self.parent.modelgrid, self.inset.modelgrid, - method='nearest') - regridded = np.reshape(regridded, (self.inset.modelgrid.nrow, - self.inset.modelgrid.ncol)) - return regridded - - def get_parent_cells(self, side='top'): - """ - Get i, j locations in parent model along boundary of pfl_nwt model. - - Parameters - ---------- - pi0, pj0 : ints - Parent cell coinciding with origin (0, 0) cell of pfl_nwt model - pi1, pj1 : ints - Parent cell coinciding with lower right corner of pfl_nwt model - (location nrow, ncol) - side : str - Side of pfl_nwt model ('left', 'bottom', 'right', or 'top') - - Returns - ------- - i, j : 1D arrays of ints - i, j locations of parent cells along pfl_nwt model boundary - """ - pi0, pj0 = self.pi0, self.pj0 - pi1, pj1 = self.pi1 + 1, self.pj1 + 1 - - # Add a plus 1 because rounded to the nearest 10 for the rows and columns above. - parent_height = pi1 - pi0 # +1 - parent_width = pj1 - pj0 # +1 - - if side == 'top': - return np.ones(parent_width, dtype=int) * pi0-1, \ - np.arange(pj0, pj1) - elif side == 'left': - return np.arange(pi0, pi1), \ - np.ones(parent_height, dtype=int) * pj0-1 - elif side == 'bottom': - return np.ones(parent_width, dtype=int) * pi1-1, \ - np.arange(pj0, pj1) - elif side == 'right': - return np.arange(pi0, pi1), \ - np.ones(parent_height, dtype=int) * pj1-1 - - def get_inset_cells(self, i, j, - side='top'): - """ - Get boundary cells in pfl_nwt model corresponding to parent cells i, j. - - Parameters - ---------- - i, j : int - Cell in parent model connected to boundary of pfl_nwt model. - pi0, pj0 : int - Parent cell coinciding with origin (0, 0) cell of pfl_nwt model - refinement : int - Refinement level (i.e. 10 if there are 10 pfl_nwt cells for every parent cell). - side : str - Side of pfl_nwt model ('left', 'bottom', 'right', or 'top') - - Returns - ------- - i, j : 1D arrays of ints - Corresponding i, j locations along boundary of pfl_nwt grid - """ - pi0, pj0 = self.pi0, self.pj0 - refinement = self.refinement - - if side == 'top': - ij0 = (j - pj0) * refinement - ij1 = np.min([ij0 + refinement, - self.inset.ncol]) - ij = np.arange(ij0, ij1) - ii = np.array([0] * len(ij)) - elif side == 'left': - ii0 = (i - pi0) * refinement - ii1 = np.min([ii0 + refinement, - self.inset.nrow]) - ii = np.arange(ii0, ii1) - ij = np.array([0] * len(ii)) - elif side == 'right': - ii0 = (i - pi0) * refinement - ii1 = np.min([ii0 + refinement, - self.inset.nrow]) - ii = np.arange(ii0, ii1) - ij0 = np.min([(j - pj0 + 1) * refinement, - self.inset.ncol]) - 1 - ij = np.array([ij0] * len(ii)) - elif side == 'bottom': - # Needed to adjust - ij0 = (j - pj0) * refinement - ij1 = np.min([ij0 + refinement, - self.inset.ncol + 1]) - ij = np.arange(ij0, ij1) - ii0 = np.min([(i - pi0 + 1) * refinement, - self.inset.nrow]) - 1 - ii = np.array([ii0] * len(ij)) - return ii, ij - - def get_inset_boundary_flux_side(self, side): - """ - Compute fluxes between parent and pfl_nwt models on a side; - assuming that flux to among connecting child cells - is horizontally uniform within a parent cell, but can vary - vertically based on transmissivity. - - Parameters - ---------- - side : str - Side of pfl_nwt model (top, bottom, right, left) - - Returns - ------- - df : DataFrame - Columns k, i, j, Q; describing locations and boundary flux - quantities for the pfl_nwt model side. - """ - parent_cells = self.get_parent_cells(side=side) - nlay_inset = self.inset.nlay - - Qside = [] # boundary fluxes - kside = [] # k locations of boundary fluxes - iside = [] # i locations ... - jside = [] - for i, j in zip(*parent_cells): - - # get the pfl_nwt model cells - ii, jj = self.get_inset_cells(i, j, side=side) - - # parent model flow and layer bottoms - Q_parent = self.cbc[self.flow_component[side]][:, i, j] * self.flow_sign[side] - botm_parent = self.parent.dis.botm.array[:, i, j] - - # pfl_nwt model bottoms, and K - # assume equal transmissivity for child cell to a parent cell, within each layer - # (use average child cell k and thickness for each layer) - # These are the layer bottoms for the pfl_nwt - botm_inset = self.inset.dis.botm.array[:, ii, jj].mean(axis=1, dtype=np.float64) - # These are the ks from the pfl_nwt model - kh_inset = self.inset.upw.hk.array[:, ii, jj].mean(axis=1, dtype=np.float64) - - # determine aquifer top - water_table_parent = self.wt[i, j] - top_parent = self.parent.dis.top.array[i, j] - - Q_inset_ij = distribute_parent_fluxes_to_inset(Q_parent=Q_parent, - botm_parent=botm_parent, - top_parent=top_parent, - botm_inset=botm_inset, - kh_inset=kh_inset, - water_table_parent=water_table_parent) - assert len(ii) == self.refinement # no partial parent cells - Qside += np.array(list(Q_inset_ij / self.refinement) * len(ii)).ravel().tolist() - kside += list(range(0, nlay_inset)) * len(ii) - iside += sorted(ii.tolist() * nlay_inset) - jside += sorted(jj.tolist() * nlay_inset) - - # check that fluxes for the side match the parent - Qparent_side = self.get_parent_boundary_fluxes_side(parent_cells[0], - parent_cells[1], - side=side) - tol = 0.01 - assert np.abs(Qparent_side.sum() - np.sum(Qside)) < tol - - return pd.DataFrame({'k': kside, - 'i': iside, - 'j': jside, - 'flux': Qside}) - - def get_inset_boundary_fluxes(self, kstpkper=(0, 0)): - """Get all boundary fluxes for a stress period. - - Parameters - ---------- - kstpkper : tuple or list of tuples - zero-based (timestep, stress period) - - Returns - ------- - df : DataFrame of all pfl_nwt model boundary fluxes - With columns k, i, j, flux, and per - """ - assert 'UPW' in self.inset.get_package_list(), "need UPW package to get boundary fluxes" - assert 'DIS' in self.inset.get_package_list(), "need DIS package to get boundary fluxes" - - if not isinstance(kstpkper, list): - kstpkper = [kstpkper] - t0 = time.time() - print('getting boundary fluxes from {}...'.format(self.cpth)) - dfs = [] - for kp in kstpkper: - hdsobj = bf.HeadFile(self.hpth) - hds = hdsobj.get_data(kstpkper=kp) - hdry = -9999 - self.wt = get_water_table(hds, nodata=hdry) - - self.read_parent_cbc_per(kstpkper=kp) - - for side in ['top', 'left', 'bottom', 'right']: - print(side) - Qside = self.get_inset_boundary_flux_side(side) - Qside['per'] = kp[1] - dfs.append(Qside) - - df = pd.concat(dfs) - - # check that Qnet out of the parent model equals - # the derived fluxes on the pfl_nwt side - tol = 0.01 - for per, dfp in df.groupby('per'): - - Qnet_parent = self.get_parent_boundary_net_flux(kstpkper=per) - Qnet_inset = dfp.flux.sum() - assert np.abs(Qnet_parent - Qnet_inset) < tol - - print("finished in {:.2f}s\n".format(time.time() - t0)) - return df - - def read_parent_cbc_per(self, kstpkper=(0, 0)): - cbbobj = bf.CellBudgetFile(self.cpth) - text = {'FLOW RIGHT FACE': 'frf', - 'FLOW FRONT FACE': 'fff'} - self.cbc = {} - for fulltxt, shorttxt in text.items(): - self.cbc[shorttxt] = get_surface_bc_flux(cbbobj, fulltxt, - kstpkper=kstpkper, idx=0) - - def get_parent_boundary_fluxes_side(self, i, j, side, kstpkper=(0, 0)): - """Get boundary fluxes at a sequence of i, j locations - in the parent model, for a specified side of the pfl_nwt model, - for a given stress period. - - Parameters - ---------- - i : sequence of i locations - j : sequence of j locations - side : str - left, right, top or bottom - kstpkper : tuple - (timestep, Stress Period) - - Returns - ------- - Qside_parent : 2D array - Boundary fluxes through parent cells, along side of pfl_nwt model. - Signed with respect to pfl_nwt model (i.e., for flow through the - left face of the parent cells, into the right side of the - pfl_nwt model, the sign is positive (flow into the pfl_nwt model), - even though MODFLOW fluxes are right-positive. - Shape: (n parent layers, len(i, j)) - """ - if self.cbc is None: - self.read_parent_cbc_per(kstpkper=kstpkper) - Qside_parent = self.cbc[self.flow_component[side]][:, i, j] * self.flow_sign[side] - #Qside_inset = self.get_inset_boundary_flux_side(side) - - return Qside_parent - - def get_parent_boundary_net_flux(self, kstpkper=(0, 0)): - """ - - Parameters - ---------- - kstpkper : int, Stress Period - - Returns - ------- - Qnet_parent : float - Net flux from parent model, summed from parent cell by cell flow results. - """ - Qnet_parent = 0 - for side, flow_sign in self.flow_sign.items(): - parent_cells = self.get_parent_cells(side=side) - Qnet_parent += self.get_parent_boundary_fluxes_side(parent_cells[0], - parent_cells[1], - side=side, - kstpkper=kstpkper).sum() - return Qnet_parent - - def compare_specified_flux_budgets(self, kstpkper=(0, 0), outfile=None): - - kstp, per = kstpkper - from collections import defaultdict - components = defaultdict(dict) - # get pfl_nwt boundary fluxes from scratch, or attached wel package - if 'WEL' not in self.inset.get_package_list(): - df = self.get_inset_boundary_fluxes(kstpkper=(0, kstpkper)) - components['Boundary flux']['pfl_nwt'] = df.flux.sum() - else: - spd = self.inset.wel.stress_period_data[per] - rowsides = (spd['i'] == 0) | (spd['i'] == self.inset.nrow-1) - # only count the corners onces - colsides = ((spd['j'] == 0) | (spd['j'] == self.inset.ncol-1)) & \ - (spd['i'] > 0) & \ - (spd['i'] < self.inset.nrow-1) - isboundary = rowsides | colsides - components['Boundary flux (WEL)']['pfl_nwt'] = spd[isboundary]['flux'].sum() - components['Boundary flux (WEL)']['parent'] = self.get_parent_boundary_net_flux(kstpkper=kstpkper) - # (wells besides boundary flux wells) - components['Pumping (WEL)']['pfl_nwt'] = spd[~isboundary]['flux'].sum() - - if 'WEL' in self.parent.get_package_list(): - spd = self.parent.wel.stress_period_data[per] - in_inset = (spd['i'] >= self.pi0) & \ - (spd['i'] <= self.pi1) & \ - (spd['j'] >= self.pj0) & \ - (spd['j'] <= self.pj1) - components['Pumping (WEL)']['parent'] = spd[in_inset]['flux'].sum() - - # compare attached recharge packages - r_parent = self.parent.rch.rech.array[per].sum(axis=0) - r_parent_in_inset = r_parent[self.pi0:self.pi1 + 1, - self.pj0:self.pj1 + 1] - rsum_parent_in_inset = r_parent_in_inset.sum(axis=(0, 1)) * \ - self.parent.dis.delr[0]**2 - rsum_inset = self.inset.rch.rech.array[per].sum(axis=(0, 1, 2)) * \ - self.inset.dis.delr[0]**2 - - components['Recharge']['parent'] = rsum_parent_in_inset - components['Recharge']['pfl_nwt'] = rsum_inset - - for k, v in components.items(): - components[k]['rpd'] = 100 * v['pfl_nwt']/v['parent'] - if outfile is not None: - with open(outfile, 'w') as dest: - dest.write('component parent pfl_nwt rpd\n') - for k, v in components.items(): - dest.write('{} {parent} {inset} {rpd:.3f}\n'.format(k, **v)) - - print('component parent pfl_nwt rpd') - for k, v in components.items(): - print('{} {parent} {inset}'.format(k, **v)) - - def get_inset_boundary_heads(self, for_external_files=True): - - # source data - headfile = self.hpth - vmin, vmax = -1e30, 1e30, - check_source_files([headfile]) - hdsobj = bf.HeadFile(headfile) #, precision='single') - all_kstpkper = hdsobj.get_kstpkper() - - # get the last timestep in each stress period if there are more than one - #kstpkper = [] - #unique_kper = [] - #for (kstp, kper) in all_kstpkper: - # if kper not in unique_kper: - # kstpkper.append((kstp, kper)) - # unique_kper.append(kper) - last_steps = {kper: kstp for kstp, kper in all_kstpkper} - - #assert len(unique_kper) == len(set(self.copy_stress_periods)), \ - #"read {} from {},\nexpected stress periods: {}".format(kstpkper, - # headfile, - # sorted(list(set(self.copy_stress_periods))) - # ) - - # get active cells along model edge - if self.pi_list is None and self.pj_list is None: - k, i, j = self.inset.get_boundary_cells(exclude_inactive=True) - else: - ktmp =[] - for clay in range(self.inset.nlay): - ktmp += list(clay*np.ones(len(self.pi_list)).astype(int)) - itmp = self.inset.nlay * self.pi_list - jtmp = self.inset.nlay * self.pj_list - - # get rid of cells that are inactive - wh = np.where(self.inset.dis.idomain.array >0) - activecells = set([(i,j,k) for i,j,k in zip(wh[0],wh[1],wh[2])]) - chdcells = set([(kk,ii,jj) for ii,jj,kk in zip(itmp,jtmp,ktmp)]) - active_chd_cells = list(set(chdcells).intersection(activecells)) - - # unpack back to lists, then convert to numpy arrays - k, i, j = zip(*active_chd_cells) - k = np.array(k) - i = np.array(i) - j = np.array(j) - # get heads from parent model - # TODO: generalize head extraction from parent model using 3D interpolation - - dfs = [] - parent_periods = [] - for inset_per, parent_per in self.inset_parent_period_mapping.items(): - # skip getting data if parent period is already represented - # (heads will be reused) - if parent_per in parent_periods: - continue - else: - parent_periods.append(parent_per) - parent_kstpkper = last_steps[parent_per], parent_per - hds = hdsobj.get_data(kstpkper=parent_kstpkper) - - regridded = np.zeros((self.inset.nlay, self.inset.nrow, self.inset.ncol)) - for dest_k, source_k in self.inset_parent_layer_mapping.items(): - - # destination model layers copied from source model layers - if source_k <= 0: - arr = hds[0] - elif np.round(source_k, 4) in range(hds.shape[0]): - source_k = int(np.round(source_k, 4)) - arr = hds[source_k] - # destination model layers that are a weighted average - # of consecutive source model layers - else: - weight0 = source_k - np.floor(source_k) - source_k0 = int(np.floor(source_k)) - # first layer in the average can't be negative - source_k0 = 0 if source_k0 < 0 else source_k0 - source_k1 = int(np.ceil(source_k)) - arr = weighted_average_between_layers(hds[source_k0], - hds[source_k1], - weight0=weight0) - # interpolate from source model using source model grid - # exclude invalid values in interpolation from parent model - mask = self._source_grid_mask & (arr > vmin) & (arr < vmax) - - regriddedk = self.regrid_from_parent(arr, mask=mask, method='linear') - - assert regriddedk.shape == self.inset.modelgrid.shape[1:] - regridded[dest_k] = regriddedk * self.length_unit_conversion - - # drop heads in dry cells, but only in mf6 - # too much trouble with interpolated heads in mf2005 - head = regridded[k, i, j] - if self.inset.version == 'mf6': - wet = head > self.inset.dis.botm.array[k, i, j] - else: - wet = np.ones(len(head)).astype(bool) - - # make a DataFrame of regridded heads at perimeter cell locations - df = pd.DataFrame({'per': inset_per, - 'k': k[wet], - 'i': i[wet], - 'j': j[wet], - 'head': head[wet] - }) - dfs.append(df) - df = pd.concat(dfs) - - # convert to one-based and comment out header if df will be written straight to external file - if for_external_files: - df.rename(columns={'k': '#k'}, inplace=True) - df['#k'] += 1 - df['i'] += 1 - df['j'] += 1 - return df - - -def distribute_parent_fluxes_to_inset(Q_parent, botm_parent, top_parent, - botm_inset, kh_inset, water_table_parent, - phiramp=0.05): - """Redistributes a vertical column of parent model fluxes at a single - location i, j in the parent model, to the corresponding layers in the - pfl_nwt model, based on pfl_nwt model layer transmissivities, accounting for the - position of the water table in the parent model. - - Parameters - ---------- - Q_parent : 1D array, - Vertical column of horizontal fluxes through a cell face - at a location at a location i, j in the parent model. - (Length is n parent layers) - botm_parent : 1D array - Layer bottom elevations at location i, j in parent model. - (Length is n parent layers) - top_parent : float - Top elevation of parent model at location i, j - botm_inset : 1D array - Mean elevation of pfl_nwt cells along the boundary face, by layer. - (Length is n pfl_nwt layers) - kh_inset : 1D array - Mean hydraulic conductivity of pfl_nwt cells along the boundary face, by layer. - (Length is n pfl_nwt layers) - water_table_parent : float - Water table elevation in parent model. - phiramp : float - Fluxes in layers with saturated thickness fraction (sat thickness/total cell thickness) - below this threshold will be assigned to the next underlying layer with a - saturated thickness fraction above this threshold. (default 0.01) - - Returns - ------- - Q_inset : 1D array - Vertical column of horizontal fluxes through each layer of the pfl_nwt - model, for the group of pfl_nwt model cells corresponding to parent - location i, j (represents the sum of horizontal flux through the - boundary face of the pfl_nwt model cells in each layer). - (Length is n pfl_nwt layers). - - """ - - # check dimensions - txt = "Length of {0} {1} is {2}; " \ - "length of {0} botm elevation is {3}" - assert len(Q_parent) == len(botm_parent), \ - txt.format('parent', 'fluxes', len(Q_parent), len(botm_parent)) - assert len(botm_inset) == len(kh_inset), \ - txt.format('pfl_nwt', 'kh_inset', len(kh_inset), len(botm_inset)) - - # rename variables - Q1 = Q_parent - botm1 = botm_parent - botm2 = botm_inset - kh2 = kh_inset - aqtop = water_table_parent if water_table_parent < top_parent \ - else top_parent # top of the aquifer - - # Replace nans with 0s bc these are where cells are dry - Q1[np.isnan(Q1)] = 0 - # In parent model cells with sat thickness fraction less than phiramp, - # Distribute flux to next layer with sat thickness frac > phiramp - b_parent = -np.diff(np.array([top_parent] + list(botm_parent))) - sthick = aqtop - botm_parent - confined = (sthick - b_parent) > 0 - sthick[confined] = b_parent[confined] - stfrac = sthick/b_parent - q_excess = 0. - for k, stfk in enumerate(stfrac): - if stfk < phiramp: - q_excess += Q1[k] - Q1[k] = 0. - continue - Q1[k] = Q1[k] + q_excess - q_excess = 0. - - kh2 = np.append(kh2, [0]) # for any layers below bottom - - nlay1 = len(botm1) - nlay2 = len(botm2) - - # all botms in both models, in reverse order (layer-positive) - allbotms = np.sort(np.unique(np.hstack([botm1, botm2])))[::-1] - - # list layer numbers in parent and child model; - # for each flux connection between them - k1 = 0 - k2 = 0 - l1 = [] # layer in parent model - l2 = [] # layer in child model - for botm in allbotms: - l1.append(k1) - l2.append(k2) - if botm in botm1: - k1 += 1 - if botm in botm2: - k2 += 1 - - l1 = np.array(l1) # parent cell connections for pfl_nwt cells - l2 = np.array(l2) # pfl_nwt cell connections for parent cells - - # if bottom of pfl_nwt hangs below bottom of parent; - # last layer will >= nlay. Assign T=0 to these intervals. - l2[l2 >= nlay2] = nlay2 - # include any part of parent model hanging below pfl_nwt - # with the lowest layer in the transmissivity calculation - l1[l1 >= nlay1] = nlay1 - 1 - - # thickness of all layer connections between - # parent and child models - # (assign 0 for connections above the water table) - b = np.diff(sorted([aqtop] + allbotms.tolist()), axis=0)[::-1] - b[allbotms > aqtop] = 0 - - # get transmissivities - T2 = kh2[l2] * b - T1 = [] - for k in range(nlay1): - T1.append(np.sum(T2[l1 == k])) - - # get transmissivity fractions (weights) - tfrac = [] - # for each parent/pfl_nwt connection - for i2, i1 in enumerate(l1): - # compute transmissivity fraction (of parent cell) - itfrac = T2[i2] / T1[i1] if T2[i2] > 0 else 0 - tfrac.append(itfrac) - tfrac = np.array(tfrac) - - # assign incoming flux to each pfl_nwt/parent connection - # multiply by weight - Qs = Q1[l1] * tfrac - - # Where nan, make 0 - Qs[np.isnan(Qs)] = 0 - np.savetxt('../qs.dat', Qs) - # sum fluxes by pfl_nwt model layer - Q_inset = [] - for k in range(nlay2): - Q_inset.append(Qs[l2 == k].sum()) - - # check that total flux through column of cells - # matches for pfl_nwt layers and parent layers - assert np.abs(np.abs(np.sum(Q_parent)) - np.abs(np.sum(Q_inset))) < 1e-3 - return np.array(Q_inset) def get_kij_from_node3d(node3d, nrow, ncol): @@ -1082,7 +239,7 @@ def get_qx_qy_qz(cell_budget_file, binary_grid_file=None, return qx, qy, qz -class TmrNew: +class Tmr: """ Class for general telescopic mesh refinement of a MODFLOW model. Head or flux fields from parent model are interpolated to boundary cells of @@ -1197,8 +354,6 @@ def inset_parent_period_mapping(self): def inset_parent_period_mapping(self, inset_parent_period_mapping): self._inset_parent_period_mapping = inset_parent_period_mapping - - @property def interp_weights_flux(self): """For the two main directions of flux (i, j) and the four orientations of @@ -1339,9 +494,9 @@ def _inset_max_active_area(self): @property def inset_zone_within_parent(self): """The footprint of the inset model maximum active area footprint - (``TmrNew._inset_max_active_area``) within the parentmodel grid. + (``Tmr._inset_max_active_area``) within the parentmodel grid. In other words, all parent cells containing one or inset - model cell centers within ``TmrNew._inset_max_active_area`` (ones). + model cell centers within ``Tmr._inset_max_active_area`` (ones). Zeros indicate parent cells with no inset cells. """ # get the locations of the inset model cells within _inset_max_active_area @@ -1916,76 +1071,3 @@ def get_inset_boundary_values(self, for_external_files=False): df['i'] += 1 df['j'] += 1 return df - - #def interpolate_values(self, source_array, method='linear'): - # """Interpolate values in source array onto - # the destination model grid, using modelgrid instances - # attached to the source and destination models. -# - # Parameters - # ---------- - # source_array : ndarray - # Values from source model to be interpolated to destination grid. - # 3D numpy array of same shape as the source model. - # method : str ('linear', 'nearest') - # Interpolation method. -# - # Returns - # ------- - # interpolated : ndarray - # 3D array of interpolated values at the inset model grid locations. - # """ - # parent_values = source_array.flatten()[self._source_grid_mask.flatten()] - # if method == 'linear': - # interpolated = interpolate(parent_values, *self.interp_weights_heads, - # fill_value=None) - # elif method == 'nearest': - # # x, y, z locations of parent model head values - # px, py, pz = self.parent_xyzcellcenters - # # x, y, z locations of inset model boundary cells - # x, y, z = self.inset_boundary_cells[['x', 'y', 'z']].T.values - # interpolated = griddata((px, py, pz), parent_values, - # (x, y, z), method=method) - # return interpolated - - #def interpolate_flux_values(self, source_array, fluxdir, method='linear'): - # """Interpolate values in source array onto - # the destination model grid, using modelgrid instances - # attached to the source and destination models. -# - # Parameters - # ---------- - # source_array : 1d-array - # Flux values from parent model to be interpolated to destination grid. - # 1D numpy array of same shape as the Tmr properties of parent xyz - # fluxdir: str ('top','bottom','left','right') - # inset face at which flux is applied - # method : str ('linear', 'nearest') - # Interpolation method. -# - # Returns - # ------- - # interpolated : ndarray - # 3D array of interpolated values at the inset model grid locations. - # """ -# -# - # if method == 'linear': - # interpolated = interpolate(source_array, *self.interp_weights_flux[fluxdir], - # fill_value=None) -# - # elif method == 'nearest': - # # x, y, z locations of inset model boundary cells - # x, y, z = self.inset_boundary_cell_faces.loc[ - # self.inset_boundary_cell_faces.cellface== fluxdir][['xface', 'yface', 'zface']].T.values - # if fluxdir in ['top','bottom']: - # # x, y, z locations of parent model head values - # px, py, pz = self.x_iface_parent, self.y_iface_parent, self.z_iface_parent - # elif fluxdir == ['left','right']: - # # x, y, z locations of parent model head values - # px, py, pz = self.x_jface_parent, self.y_jface_parent, self.z_jface_parent - # # x, y, z locations of inset model boundary cells -# - # interpolated = griddata((px, py, pz), source_array, - # (x, y, z), method=method) - # return interpolated diff --git a/mfsetup/wells.py b/mfsetup/wells.py index e5fd16c4..ef1fc5e4 100644 --- a/mfsetup/wells.py +++ b/mfsetup/wells.py @@ -9,7 +9,6 @@ from mfsetup.fileio import append_csv, check_source_files from mfsetup.grid import get_ij from mfsetup.sourcedata import TransientTabularSourceData -from mfsetup.tmr import Tmr from mfsetup.wateruse import get_mean_pumping_rates, resample_pumping_rates From 3bac3068be6fabb6529b39da3defca7d1412ccfd Mon Sep 17 00:00:00 2001 From: "Leaf, Andrew T" Date: Tue, 3 May 2022 14:00:24 -0500 Subject: [PATCH 7/9] fix(MFnwtModel.setup_gag): update starting unit number to avoid collisions between lake and sfr packages; refactor: some more kruft removal aimed at boosting test coverage --- mfsetup/fileio.py | 13 - mfsetup/mfnwtmodel.py | 2 + mfsetup/model_version.py | 432 +-------------------- mfsetup/tests/test_pleasant_mf6_inset.py | 12 +- mfsetup/tests/test_pleasant_mfnwt_inset.py | 2 +- 5 files changed, 29 insertions(+), 432 deletions(-) diff --git a/mfsetup/fileio.py b/mfsetup/fileio.py index 6a4b2a31..71640975 100644 --- a/mfsetup/fileio.py +++ b/mfsetup/fileio.py @@ -34,19 +34,6 @@ def check_source_files(fileslist): raise IOError('Cannot find {}'.format(f)) -def load_array(filename, shape=None): - """Load an array, ensuring the correct shape.""" - arr = np.loadtxt(filename) - if shape is not None: - if arr.shape != shape: - if arr.size == np.prod(shape): - arr = np.reshape(arr, shape) - else: - raise ValueError("Data in {} have size {}; should be {}" - .format(filename, arr.shape, shape)) - return arr - - def load(filename): """Load a configuration file.""" filename = Path(filename) diff --git a/mfsetup/mfnwtmodel.py b/mfsetup/mfnwtmodel.py index 61614a86..1956c9e5 100644 --- a/mfsetup/mfnwtmodel.py +++ b/mfsetup/mfnwtmodel.py @@ -700,6 +700,8 @@ def setup_gag(self, **kwargs): # TODO: make private attribute to facilitate keeping track of lake IDs lak_files = ['lak{}_{}.ggo'.format(i+1, hydroid) for i, hydroid in enumerate(self.cfg['lak']['source_data']['lakes_shapefile']['include_ids'])] + # update the starting unit number of avoid collisions with other gage packages + starting_unit_number = np.max(np.abs(lake_unit)) + 1 # need to add streams at some point nstream_gages = 0 diff --git a/mfsetup/model_version.py b/mfsetup/model_version.py index d3101ff5..5bb245b1 100644 --- a/mfsetup/model_version.py +++ b/mfsetup/model_version.py @@ -1,356 +1,22 @@ - -# This file helps to compute a version number in source trees obtained from -# git-archive tarball (such as those provided by githubs download-from-tag -# feature). Distribution tarballs (built by setup.py sdist) and build -# directories (produced by setup.py build) will contain a much shorter file -# that just contains the computed version number. - -# This file is released into the public domain. Generated by -# versioneer-0.18 (https://github.com/warner/python-versioneer) - -"""Git implementation of _version.py.""" - -import errno +"""Modflow-setup adaptations to the Python Versionseer _version.py, +to enable versioning of models. +""" import os -import re -import subprocess -import sys - - -def get_keywords(): - """Get the keywords needed to look up the version information.""" - # these strings will be replaced by git during git-archive. - # setup.py/versioneer.py will grep for the variable names, so they must - # each be defined on a line of their own. _version.py will just call - # get_keywords(). - git_refnames = "$Format:%d$" - git_full = "$Format:%H$" - git_date = "$Format:%ci$" - keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} - return keywords - - -class VersioneerConfig: - """Container for Versioneer configuration parameters.""" - - -def get_config(path): - """Create, populate and return the VersioneerConfig() object.""" - # these strings are filled in when 'setup.py versioneer' creates - # _version.py - cfg = VersioneerConfig() - cfg.VCS = "git" - cfg.style = "pep440-post" - cfg.tag_prefix = "v" - cfg.parentdir_prefix = "None" - cfg.versionfile_source = "mfsetup/_version.py" - cfg.verbose = False - return cfg - - -class NotThisMethod(Exception): - """Exception raised if a method is not valid for the current scenario.""" - - -LONG_VERSION_PY = {} -HANDLERS = {} - - -def register_vcs_handler(vcs, method): # decorator - """Decorator to mark a method as the handler for a particular VCS.""" - def decorate(f): - """Store f in HANDLERS[vcs][method].""" - if vcs not in HANDLERS: - HANDLERS[vcs] = {} - HANDLERS[vcs][method] = f - return f - return decorate - - -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, - env=None): - """Call the given command(s).""" - assert isinstance(commands, list) - p = None - for c in commands: - try: - dispcmd = str([c] + args) - # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen([c] + args, cwd=cwd, env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None)) - break - except EnvironmentError: - e = sys.exc_info()[1] - if e.errno == errno.ENOENT: - continue - if verbose: - print("unable to run %s" % dispcmd) - print(e) - return None, None - else: - if verbose: - print("unable to find command, tried %s" % (commands,)) - return None, None - stdout = p.communicate()[0].strip() - if sys.version_info[0] >= 3: - stdout = stdout.decode() - if p.returncode != 0: - if verbose: - print("unable to run %s (error)" % dispcmd) - print("stdout was %s" % stdout) - return None, p.returncode - return stdout, p.returncode - - -def versions_from_parentdir(parentdir_prefix, root, verbose): - """Try to determine the version from the parent directory name. - - Source tarballs conventionally unpack into a directory that includes both - the project name and a version string. We will also support searching up - two directory levels for an appropriately named parent directory - """ - rootdirs = [] - - for i in range(3): - dirname = os.path.basename(root) - if dirname.startswith(parentdir_prefix): - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None, "date": None} - else: - rootdirs.append(root) - root = os.path.dirname(root) # up a level - - if verbose: - print("Tried directories %s but none started with prefix %s" % - (str(rootdirs), parentdir_prefix)) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - - -@register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs): - """Extract version information from the given file.""" - # the code embedded in _version.py can just fetch the value of these - # keywords. When used from setup.py, we don't want to import _version.py, - # so we do it with a regexp instead. This function is not used from - # _version.py. - keywords = {} - try: - f = open(versionfile_abs, "r") - for line in f.readlines(): - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - if line.strip().startswith("git_date ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["date"] = mo.group(1) - f.close() - except EnvironmentError: - pass - return keywords - - -@register_vcs_handler("git", "keywords") -def git_versions_from_keywords(keywords, tag_prefix, verbose): - """Get version information from git keywords.""" - if not keywords: - raise NotThisMethod("no keywords at all, weird") - date = keywords.get("date") - if date is not None: - # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant - # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 - # -like" string, which we must then edit to make compliant), because - # it's been around since git-1.5.3, and it's too difficult to - # discover which version we're using, or to work around using an - # older one. - date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - refnames = keywords["refnames"].strip() - if refnames.startswith("$Format"): - if verbose: - print("keywords are unexpanded, not using") - raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = set([r.strip() for r in refnames.strip("()").split(",")]) - # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of - # just "foo-1.0". If we see a "tag: " prefix, prefer those. - TAG = "tag: " - tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) - if not tags: - # Either we're using git < 1.8.3, or there really are no tags. We use - # a heuristic: assume all version tags have a digit. The old git %d - # expansion behaves like git log --decorate=short and strips out the - # refs/heads/ and refs/tags/ prefixes that would let us distinguish - # between branches and tags. By ignoring refnames without digits, we - # filter out many common branch names like "release" and - # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r'\d', r)]) - if verbose: - print("discarding '%s', no digits" % ",".join(refs - tags)) - if verbose: - print("likely tags: %s" % ",".join(sorted(tags))) - for ref in sorted(tags): - # sorting will prefer e.g. "2.0" over "2.0rc1" - if ref.startswith(tag_prefix): - r = ref[len(tag_prefix):] - if verbose: - print("picking %s" % r) - return {"version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None, - "date": date} - # no suitable tags, so version is "0+unknown", but full hex is still there - if verbose: - print("no suitable tags, using unknown + full revision id") - return {"version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags", "date": None} - - -@register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): - """Get version from 'git describe' in the root of the source tree. - - This only gets called if the git-archive 'subst' keywords were *not* - expanded, and _version.py hasn't already been rewritten with a short - version string, meaning we're inside a checked out source tree. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - - out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=True) - if rc != 0: - if verbose: - print("Directory %s not under git control" % root) - raise NotThisMethod("'git rev-parse --git-dir' returned error") - - # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] - # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%s*" % tag_prefix], - cwd=root) - # --long was added in git-1.5.5 - if describe_out is None: - raise NotThisMethod("'git describe' failed") - describe_out = describe_out.strip() - full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) - if full_out is None: - raise NotThisMethod("'git rev-parse' failed") - full_out = full_out.strip() - - pieces = {} - pieces["long"] = full_out - pieces["short"] = full_out[:7] # maybe improved later - pieces["error"] = None - - # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] - # TAG might have hyphens. - git_describe = describe_out - - # look for -dirty suffix - dirty = git_describe.endswith("-dirty") - pieces["dirty"] = dirty - if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] - - # now we have TAG-NUM-gHEX or HEX - - if "-" in git_describe: - # TAG-NUM-gHEX - mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) - if not mo: - # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = ("unable to parse git-describe output: '%s'" - % describe_out) - return pieces - - # tag - full_tag = mo.group(1) - if not full_tag.startswith(tag_prefix): - if verbose: - fmt = "tag '%s' doesn't start with prefix '%s'" - print(fmt % (full_tag, tag_prefix)) - pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" - % (full_tag, tag_prefix)) - return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] - - # distance: number of commits since tag - pieces["distance"] = int(mo.group(2)) - - # commit: short hex revision ID - pieces["short"] = mo.group(3) - - else: - # HEX: no tags - pieces["closest-tag"] = None - count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], - cwd=root) - pieces["distance"] = int(count_out) # total number of commits - - # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], - cwd=root)[0].strip() - pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - - return pieces - - -def plus_or_dot(pieces): - """Return a + if we don't already have one, else return a .""" - if "+" in pieces.get("closest-tag", ""): - return "." - return "+" - - -def render_pep440(pieces): - """Build up version string, with post-release "local version identifier". - - Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you - get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty - - Exceptions: - 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += plus_or_dot(pieces) - rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], - pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - -def render_pep440_pre(pieces): - """TAG[.post.devDISTANCE] -- No -dirty. - - Exceptions: - 1: no tags. 0.post.devDISTANCE - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += ".post.dev%d" % pieces["distance"] - else: - # exception #1 - rendered = "0.post.dev%d" % pieces["distance"] - return rendered +from mfsetup._version import ( + NotThisMethod, + get_config, + get_keywords, + git_pieces_from_vcs, + git_versions_from_keywords, + plus_or_dot, + render_git_describe, + render_git_describe_long, + render_pep440, + render_pep440_old, + render_pep440_pre, + versions_from_parentdir, +) def render_pep440_post(pieces, start_version='0'): @@ -381,68 +47,6 @@ def render_pep440_post(pieces, start_version='0'): return rendered -def render_pep440_old(pieces): - """TAG[.postDISTANCE[.dev0]] . - - The ".dev0" means dirty. - - Eexceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - return rendered - - -def render_git_describe(pieces): - """TAG[-DISTANCE-gHEX][-dirty]. - - Like 'git describe --tags --dirty --always'. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render_git_describe_long(pieces): - """TAG-DISTANCE-gHEX[-dirty]. - - Like 'git describe --tags --dirty --always -long'. - The distance/hash is unconditional. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - def render(pieces, style, start_version='0'): """Render the given version pieces into the requested style.""" if pieces["error"]: @@ -482,7 +86,7 @@ def get_versions(path=None, start_version='0'): # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which # case we can only use expanded keywords. print(os.path.abspath(path)) - cfg = get_config(path=path) + cfg = get_config()#path=path) verbose = cfg.verbose try: diff --git a/mfsetup/tests/test_pleasant_mf6_inset.py b/mfsetup/tests/test_pleasant_mf6_inset.py index 5bd58d7b..a20f723b 100644 --- a/mfsetup/tests/test_pleasant_mf6_inset.py +++ b/mfsetup/tests/test_pleasant_mf6_inset.py @@ -18,7 +18,7 @@ fm = flopy.modflow from mfsetup import MF6model from mfsetup.checks import check_external_files_for_nans -from mfsetup.fileio import exe_exists, load_cfg, read_mf6_block +from mfsetup.fileio import exe_exists, load_cfg, read_lak_ggo, read_mf6_block from mfsetup.testing import compare_inset_parent_values from mfsetup.tests.plot import make_lake_xsections from mfsetup.utils import get_input_arguments @@ -736,11 +736,15 @@ def test_mf6_results(tmpdir, project_root_path, pleasant_mf6_model_run, pleasant # this also tests that the gage package is writing to the correct unit df_mf6 = pd.read_csv('{}/pleasant_mf6/lake1.obs.csv'.format(tmpdir)) # this next line isn't working on Travis for some reason - #df_mfnwt = read_lak_ggo('{}/pleasant_nwt/lak1_600059060.ggo'.format(tmpdir), - # model=pleasant_nwt_model_run) + df_mfnwt = read_lak_ggo('{}/pleasant_nwt/lak1_600059060.ggo'.format(tmpdir), + model=pleasant_nwt_model_run) #if make_plot: # plt.plot(df_mf6.time, df_mf6.STAGE, label='mf6') # plt.plot(df_mfnwt.time, df_mfnwt.stageh, label='mfnwt') # plt.legend() - #lake_stage_rms = np.sqrt(np.mean((df_mfnwt.stage.values - df_mf6.STAGE.values) ** 2)) + lake_stage_rms = np.sqrt(np.mean((df_mfnwt['stageh'].values - df_mf6['STAGE'].values) ** 2)) + # TODO: not sure why there is a 0.15 offset in stage between the two models + # doesn't seem to be due to the ghb package + # or the high-k lakes, unless they aren't implemented in the modflow-nwt version + np.allclose(df_mfnwt['stageh'].values + 0.15, df_mf6['STAGE'].values, atol=0.01) #pdf.close() diff --git a/mfsetup/tests/test_pleasant_mfnwt_inset.py b/mfsetup/tests/test_pleasant_mfnwt_inset.py index 51864da4..ad0555cc 100644 --- a/mfsetup/tests/test_pleasant_mfnwt_inset.py +++ b/mfsetup/tests/test_pleasant_mfnwt_inset.py @@ -129,7 +129,7 @@ def test_model_setup(full_pleasant_nwt): assert os.path.exists(sfr_obs_filename) with open(sfr_obs_filename) as src: gagedata = src.read() - assert gagedata == '3 \n-1 -250 1 \n1 22 250 0 \n2 2 251 0 \n' + assert gagedata == '3 \n-1 -250 1 \n1 22 251 0 \n2 2 252 0 \n' def test_model_setup_and_run(pleasant_nwt_model_run): From b98d1689851a7813e444c19ece64ecafb3ce1bec Mon Sep 17 00:00:00 2001 From: "Leaf, Andrew T" Date: Tue, 3 May 2022 14:38:33 -0500 Subject: [PATCH 8/9] tests(test_equality): fix so that list_eq() actually gets called --- mfsetup/tests/test_equality.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/mfsetup/tests/test_equality.py b/mfsetup/tests/test_equality.py index 619a7aaa..603a986a 100644 --- a/mfsetup/tests/test_equality.py +++ b/mfsetup/tests/test_equality.py @@ -1,7 +1,8 @@ import copy from flopy.datbase import DataInterface -from flopy.mf6.data.mfdatalist import MFList +from flopy.mf6.data.mfdatalist import MFList as MF6List +from flopy.utils.util_list import MfList from mfsetup.equality import list_eq, model_eq, package_eq @@ -27,12 +28,12 @@ def test_list_equality(pleasant_model): for package in m1.get_package_list(): pck1 = getattr(m1, package.lower()) pck2 = getattr(m2, package.lower()) - for v in pck1.data_list: - if isinstance(v, DataInterface): + for v1, v2 in zip(pck1.data_list, pck2.data_list): + if isinstance(v1, DataInterface): try: - arr = v.array + arr = v1.array except: arr = None if arr is not None: - if isinstance(v, MFList): - assert list_eq(pck1, pck2) + if isinstance(v1, MF6List) or isinstance(v1, MfList): + assert list_eq(v1, v2) From 898aeab75ae5fe58ecadeed6683890469f936ec0 Mon Sep 17 00:00:00 2001 From: "Leaf, Andrew T" Date: Tue, 3 May 2022 14:39:01 -0500 Subject: [PATCH 9/9] docs: update release history --- docs/source/philosophy.rst | 4 ++-- docs/source/release-history.rst | 20 ++++++++++++-------- 2 files changed, 14 insertions(+), 10 deletions(-) diff --git a/docs/source/philosophy.rst b/docs/source/philosophy.rst index f4a291b9..ce6d201c 100644 --- a/docs/source/philosophy.rst +++ b/docs/source/philosophy.rst @@ -27,8 +27,8 @@ In contrast to Flopy, which is completely general, modflow-setup limits model co -.. _Configuration File Gallery: https://aleaf.github.io/modflow-setup/docs/build/html/examples.html#configuration-file-gallery -.. _Release History: https://aleaf.github.io/modflow-setup/release-history.html +.. _Configuration File Gallery: https://usgs.github.io/modflow-setup/docs/build/html/examples.html#configuration-file-gallery +.. _Release History: https://usgs.github.io/modflow-setup/release-history.html .. _hydrosense: https://ngwa.onlinelibrary.wiley.com/doi/abs/10.1111/j.1745-6584.2012.00936.x .. _step-wise modeling: https://www.haitjema.com/stepwise.html diff --git a/docs/source/release-history.rst b/docs/source/release-history.rst index 76b2b64b..8a57c01c 100644 --- a/docs/source/release-history.rst +++ b/docs/source/release-history.rst @@ -2,19 +2,23 @@ Release History =============== -Version 0.1 Initial release (2022-04-01) +Version 0.1 Initial release (2022-xx-xx) ---------------------------------------- * support for constructing MODFLOW-NWT or MODFLOW-6 models from scratch * supported source dataset formats include GeoTiff, Arc-Ascii grids, shapefiles, NetCDF, and CSV files * automatic reprojection of source datasets that have CRS information (GeoTiffs, shapefiles, etc.) -* model input can also be supplied from parent model package input or MODFLOW binary output -* supported MODFLOW-NWT packages: DIS, BAS6, OC, UPW, RCH, GHB, SFR2, LAK, WEL, MNW2, HYD, GAGE, NWT +* supported MODFLOW-NWT packages: DIS, BAS6, OC, UPW, RCH, GHB, SFR2, LAK, WEL, MNW2, HYD, GAGE, NWT, CHD, DRN, GHB, RIV * supported MODFLOW-6 packages: DIS, IC, OC, NPF, RCHA, SFR, LAK, WEL, OBS, IMS, TDIS, CHD, DRN, GHB, RIV -* Lake observations are set up automatically (one output file per lake) +* Lake observations are set up automatically (one output file per lake); basic stress package observations are also setup up automatically * SFR observations can be set up via ``observations`` block in the SFR package ``source_data`` * Telescopic mesh refinement (TMR) insets from MODFLOW-NWT or MODFLOW 6 models - * support for specified head boundaries from parent head solution - * specified head boundaries can be along model perimeter or irregular polygon of model active area + * support for specified head or flux perimeter boundaries from the parent model solution + * perimeter boundaries can be along the model bounding box perimeter, or an irregular polygon of the active model area + * model input can also be supplied from grid-independent source data, parent model package input (except for SFR, LAK, CHD, DRN, GHB, RIV), or MODFLOW binary output (perimeter boundaries and starting heads) + * Local grid refinement (LGR) insets supported for MODFLOW-6 models. - * The water mover (MVR) package is set up automatically at the simulation level for LGR models with SFR packages in the parent and inset model. -* see .yml configuation files in mfsetup/tests/data folder for examples of valid input to modflow-setup + * The water mover (MVR) package is set up automatically at the simulation level for LGR models with SFR packages in the parent and inset model. + +* see the `Configuration File Gallery`_ or the ``*.yml`` configuation files in mfsetup/tests/data folder for examples of valid input to modflow-setup + +.. _Configuration File Gallery: https://usgs.github.io/modflow-setup/docs/build/html/examples.html#configuration-file-gallery