diff --git a/flopy/mf6/modflow/__init__.py b/flopy/mf6/modflow/__init__.py index a83e0ec897..c009179e2d 100644 --- a/flopy/mf6/modflow/__init__.py +++ b/flopy/mf6/modflow/__init__.py @@ -25,14 +25,17 @@ from .mfgwfapi import ModflowGwfapi from .mfgwfbuy import ModflowGwfbuy from .mfgwfchd import ModflowGwfchd +from .mfgwfchdg import ModflowGwfchdg from .mfgwfcsub import ModflowGwfcsub from .mfgwfdis import ModflowGwfdis from .mfgwfdisu import ModflowGwfdisu from .mfgwfdisv import ModflowGwfdisv from .mfgwfdrn import ModflowGwfdrn +from .mfgwfdrng import ModflowGwfdrng from .mfgwfevt import ModflowGwfevt from .mfgwfevta import ModflowGwfevta from .mfgwfghb import ModflowGwfghb +from .mfgwfghbg import ModflowGwfghbg from .mfgwfgnc import ModflowGwfgnc from .mfgwfgwe import ModflowGwfgwe from .mfgwfgwf import ModflowGwfgwf @@ -49,11 +52,13 @@ from .mfgwfrch import ModflowGwfrch from .mfgwfrcha import ModflowGwfrcha from .mfgwfriv import ModflowGwfriv +from .mfgwfrivg import ModflowGwfrivg from .mfgwfsfr import ModflowGwfsfr from .mfgwfsto import ModflowGwfsto from .mfgwfuzf import ModflowGwfuzf from .mfgwfvsc import ModflowGwfvsc from .mfgwfwel import ModflowGwfwel +from .mfgwfwelg import ModflowGwfwelg from .mfgwt import ModflowGwt from .mfgwtadv import ModflowGwtadv from .mfgwtapi import ModflowGwtapi diff --git a/flopy/mf6/modflow/mfgwe.py b/flopy/mf6/modflow/mfgwe.py index d0d1f10639..f024d9e61d 100644 --- a/flopy/mf6/modflow/mfgwe.py +++ b/flopy/mf6/modflow/mfgwe.py @@ -42,6 +42,9 @@ class ModflowGwe(MFModel): save_flows : keyword keyword to indicate that all model package flow terms will be written to the file specified with 'budget fileout' in output control. + dependent_variable_scaling : keyword + flag to scale x and rhs to avoid very large positive or negative dependent + variable values nc_mesh2d_filerecord : record netcdf layered mesh fileout record. nc_structured_filerecord : record @@ -87,6 +90,7 @@ def __init__( print_input=None, print_flows=None, save_flows=None, + dependent_variable_scaling=None, nc_mesh2d_filerecord=None, nc_structured_filerecord=None, nc_filerecord=None, @@ -112,6 +116,8 @@ def __init__( self.print_flows = self.name_file.print_flows self.name_file.save_flows.set_data(save_flows) self.save_flows = self.name_file.save_flows + self.name_file.dependent_variable_scaling.set_data(dependent_variable_scaling) + self.dependent_variable_scaling = self.name_file.dependent_variable_scaling self.name_file.nc_mesh2d_filerecord.set_data(nc_mesh2d_filerecord) self.nc_mesh2d_filerecord = self.name_file.nc_mesh2d_filerecord self.name_file.nc_structured_filerecord.set_data(nc_structured_filerecord) diff --git a/flopy/mf6/modflow/mfgwecnd.py b/flopy/mf6/modflow/mfgwecnd.py index a21898848b..1555436707 100644 --- a/flopy/mf6/modflow/mfgwecnd.py +++ b/flopy/mf6/modflow/mfgwecnd.py @@ -33,8 +33,11 @@ class ModflowGwecnd(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. alh : [double precision] longitudinal dispersivity in horizontal direction. if flow is strictly horizontal, then this is the longitudinal dispersivity that will be used. if diff --git a/flopy/mf6/modflow/mfgwedis.py b/flopy/mf6/modflow/mfgwedis.py index 28b47d3907..304cc6e100 100644 --- a/flopy/mf6/modflow/mfgwedis.py +++ b/flopy/mf6/modflow/mfgwedis.py @@ -49,8 +49,11 @@ class ModflowGwedis(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. packagedata : record ncf6 filein ncf6_filename Contains data for the ncf package. Data can be passed as a dictionary to the ncf package with variable names as keys and package data as values. Data for @@ -199,7 +202,7 @@ class ModflowGwedis(MFPackage): "preserve_case true", "reader urword", "optional true", - "prerelease true", + "developmode true", ], [ "block options", diff --git a/flopy/mf6/modflow/mfgwedisu.py b/flopy/mf6/modflow/mfgwedisu.py index c2b494b708..7339edf08f 100644 --- a/flopy/mf6/modflow/mfgwedisu.py +++ b/flopy/mf6/modflow/mfgwedisu.py @@ -290,7 +290,7 @@ class ModflowGwedisu(MFPackage): "preserve_case true", "reader urword", "optional true", - "prerelease true", + "developmode true", ], [ "block dimensions", diff --git a/flopy/mf6/modflow/mfgwedisv.py b/flopy/mf6/modflow/mfgwedisv.py index 2e5e5d7559..389c20f60c 100644 --- a/flopy/mf6/modflow/mfgwedisv.py +++ b/flopy/mf6/modflow/mfgwedisv.py @@ -52,8 +52,11 @@ class ModflowGwedisv(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. packagedata : record ncf6 filein ncf6_filename Contains data for the ncf package. Data can be passed as a dictionary to the ncf package with variable names as keys and package data as values. Data for @@ -229,7 +232,7 @@ class ModflowGwedisv(MFPackage): "preserve_case true", "reader urword", "optional true", - "prerelease true", + "developmode true", ], [ "block options", diff --git a/flopy/mf6/modflow/mfgweic.py b/flopy/mf6/modflow/mfgweic.py index 5e35dd2468..f6e37172ea 100644 --- a/flopy/mf6/modflow/mfgweic.py +++ b/flopy/mf6/modflow/mfgweic.py @@ -23,8 +23,11 @@ class ModflowGweic(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. strt : [double precision] is the initial (starting) temperature---that is, the temperature at the beginning of the gwe model simulation. strt must be specified for all gwe diff --git a/flopy/mf6/modflow/mfgwenam.py b/flopy/mf6/modflow/mfgwenam.py index 7f399fc957..7b1e0b7702 100644 --- a/flopy/mf6/modflow/mfgwenam.py +++ b/flopy/mf6/modflow/mfgwenam.py @@ -36,6 +36,9 @@ class ModflowGwenam(MFPackage): save_flows : keyword keyword to indicate that all model package flow terms will be written to the file specified with 'budget fileout' in output control. + dependent_variable_scaling : keyword + flag to scale x and rhs to avoid very large positive or negative dependent + variable values nc_mesh2d_filerecord : (ncmesh2dfile) netcdf layered mesh fileout record. * ncmesh2dfile : string @@ -129,7 +132,6 @@ class ModflowGwenam(MFPackage): "reader urword", "optional true", "mf6internal idv_scale", - "prerelease true", ], [ "block options", @@ -290,6 +292,7 @@ def __init__( print_input=None, print_flows=None, save_flows=None, + dependent_variable_scaling=None, nc_mesh2d_filerecord=None, nc_structured_filerecord=None, nc_filerecord=None, @@ -312,6 +315,9 @@ def __init__( self.print_input = self.build_mfdata("print_input", print_input) self.print_flows = self.build_mfdata("print_flows", print_flows) self.save_flows = self.build_mfdata("save_flows", save_flows) + self.dependent_variable_scaling = self.build_mfdata( + "dependent_variable_scaling", dependent_variable_scaling + ) self.nc_mesh2d_filerecord = self.build_mfdata( "nc_mesh2d_filerecord", nc_mesh2d_filerecord ) diff --git a/flopy/mf6/modflow/mfgweoc.py b/flopy/mf6/modflow/mfgweoc.py index d000b56120..1270a025d3 100644 --- a/flopy/mf6/modflow/mfgweoc.py +++ b/flopy/mf6/modflow/mfgweoc.py @@ -92,6 +92,7 @@ class ModflowGweoc(MFPackage): "reader urword", "tagged true", "optional true", + "mf6internal budfilerec", ], [ "block options", @@ -132,6 +133,7 @@ class ModflowGweoc(MFPackage): "reader urword", "tagged true", "optional true", + "mf6internal budcsvfilerec", ], [ "block options", @@ -162,6 +164,7 @@ class ModflowGweoc(MFPackage): "reader urword", "tagged true", "optional true", + "mf6internal tempfilerec", ], [ "block options", @@ -183,6 +186,7 @@ class ModflowGweoc(MFPackage): "reader urword", "tagged false", "optional false", + "mf6internal tempfile", ], [ "block options", @@ -191,6 +195,7 @@ class ModflowGweoc(MFPackage): "shape", "reader urword", "optional true", + "mf6internal tempprintrec", ], [ "block options", diff --git a/flopy/mf6/modflow/mfgwfchdg.py b/flopy/mf6/modflow/mfgwfchdg.py new file mode 100644 index 0000000000..8b6148cec0 --- /dev/null +++ b/flopy/mf6/modflow/mfgwfchdg.py @@ -0,0 +1,288 @@ +# autogenerated file, do not modify + +from os import PathLike, curdir +from typing import Union + +from flopy.mf6.data.mfdatautil import ArrayTemplateGenerator, ListTemplateGenerator +from flopy.mf6.mfpackage import MFChildPackages, MFPackage + + +class ModflowGwfchdg(MFPackage): + """ + ModflowGwfchdg defines a CHDG package. + + Parameters + ---------- + model + Model that this package is a part of. Package is automatically + added to model when it is initialized. + loading_package : bool, default False + Do not set this parameter. It is intended for debugging and internal + processing purposes only. + auxiliary : [string] + defines an array of one or more auxiliary variable names. there is no limit on + the number of auxiliary variables that can be provided on this line; however, + lists of information provided in subsequent blocks must have a column of data + for each auxiliary variable name defined here. the number of auxiliary + variables detected on this line determines the value for naux. comments cannot + be provided anywhere on this line as they will be interpreted as auxiliary + variable names. auxiliary variables may not be used by the package, but they + will be available for use by other parts of the program. the program will + terminate with an error if auxiliary variables are specified on more than one + line in the options block. + auxmultname : string + name of auxiliary variable to be used as multiplier of chd head value. + print_input : keyword + keyword to indicate that the list of constant-head information will be written + to the listing file immediately after it is read. + print_flows : keyword + keyword to indicate that the list of constant-head flow rates will be printed + to the listing file for every stress period time step in which 'budget print' + is specified in output control. if there is no output control option and + 'print_flows' is specified, then flow rates are printed for the last time step + of each stress period. + save_flows : keyword + keyword to indicate that constant-head flow terms will be written to the file + specified with 'budget fileout' in output control. + observations : record obs6 filein obs6_filename + Contains data for the obs package. Data can be passed as a dictionary to the + obs package with variable names as keys and package data as values. Data for + the observations variable is also acceptable. See obs package documentation for + more information. + export_array_netcdf : keyword + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. + dev_no_newton : keyword + turn off newton for unconfined cells + maxbound : integer + integer value specifying the maximum number of constant-head cells that will be + specified for use during any stress period. + head : [double precision] + is the head at the boundary. + aux : [double precision] + is an array of values for auxiliary variable aux(iaux), where iaux is a value + from 1 to naux, and aux(iaux) must be listed as part of the auxiliary + variables. a separate array can be specified for each auxiliary variable. if + the value specified here for the auxiliary variable is the same as auxmultname, + then the head array will be multiplied by this array. + + filename : str or PathLike, optional + Name or path of file where this package is stored. + pname : str, optional + Package name. + **kwargs + Extra keywords for :class:`flopy.mf6.mfpackage.MFPackage`. + + """ + + auxiliary = ArrayTemplateGenerator(("gwf6", "chdg", "options", "auxiliary")) + obs_filerecord = ListTemplateGenerator( + ("gwf6", "chdg", "options", "obs_filerecord") + ) + head = ArrayTemplateGenerator(("gwf6", "chdg", "period", "head")) + aux = ArrayTemplateGenerator(("gwf6", "chdg", "period", "aux")) + package_abbr = "gwfchdg" + _package_type = "chdg" + dfn_file_name = "gwf-chdg.dfn" + dfn = [ + ["header", "multi-package", "package-type stress-package"], + [ + "block options", + "name readarraygrid", + "type keyword", + "reader urword", + "optional false", + "developmode true", + "default true", + ], + [ + "block options", + "name auxiliary", + "type string", + "shape (naux)", + "reader urword", + "optional true", + ], + [ + "block options", + "name auxmultname", + "type string", + "shape", + "reader urword", + "optional true", + ], + [ + "block options", + "name print_input", + "type keyword", + "reader urword", + "optional true", + "mf6internal iprpak", + ], + [ + "block options", + "name print_flows", + "type keyword", + "reader urword", + "optional true", + "mf6internal iprflow", + ], + [ + "block options", + "name save_flows", + "type keyword", + "reader urword", + "optional true", + "mf6internal ipakcb", + ], + [ + "block options", + "name obs_filerecord", + "type record obs6 filein obs6_filename", + "shape", + "reader urword", + "tagged true", + "optional true", + "construct_package obs", + "construct_data observations", + "parameter_name continuous", + ], + [ + "block options", + "name obs6", + "type keyword", + "shape", + "in_record true", + "reader urword", + "tagged true", + "optional false", + ], + [ + "block options", + "name filein", + "type keyword", + "shape", + "in_record true", + "reader urword", + "tagged true", + "optional false", + ], + [ + "block options", + "name obs6_filename", + "type string", + "preserve_case true", + "in_record true", + "tagged false", + "reader urword", + "optional false", + ], + [ + "block options", + "name export_array_netcdf", + "type keyword", + "reader urword", + "optional true", + "mf6internal export_nc", + "extended true", + ], + [ + "block options", + "name dev_no_newton", + "type keyword", + "reader urword", + "optional true", + "mf6internal inewton", + ], + [ + "block dimensions", + "name maxbound", + "type integer", + "reader urword", + "optional true", + ], + [ + "block period", + "name iper", + "type integer", + "block_variable true", + "in_record true", + "tagged false", + "shape", + "valid", + "reader urword", + "optional false", + ], + [ + "block period", + "name head", + "type double precision", + "shape (nodes)", + "reader readarray", + "layered true", + "netcdf true", + "default 3.e30", + ], + [ + "block period", + "name aux", + "type double precision", + "shape (nodes)", + "reader readarray", + "layered true", + "netcdf true", + "optional true", + "mf6internal auxvar", + ], + ] + + def __init__( + self, + model, + loading_package=False, + auxiliary=None, + auxmultname=None, + print_input=None, + print_flows=None, + save_flows=None, + observations=None, + export_array_netcdf=None, + dev_no_newton=None, + maxbound=None, + head=3e30, + aux=None, + filename=None, + pname=None, + **kwargs, + ): + """Initialize ModflowGwfchdg.""" + super().__init__( + parent=model, + package_type="chdg", + filename=filename, + pname=pname, + loading_package=loading_package, + **kwargs, + ) + + self.auxiliary = self.build_mfdata("auxiliary", auxiliary) + self.auxmultname = self.build_mfdata("auxmultname", auxmultname) + self.print_input = self.build_mfdata("print_input", print_input) + self.print_flows = self.build_mfdata("print_flows", print_flows) + self.save_flows = self.build_mfdata("save_flows", save_flows) + self._obs_filerecord = self.build_mfdata("obs_filerecord", None) + self._obs_package = self.build_child_package( + "obs", observations, "continuous", self._obs_filerecord + ) + self.export_array_netcdf = self.build_mfdata( + "export_array_netcdf", export_array_netcdf + ) + self.dev_no_newton = self.build_mfdata("dev_no_newton", dev_no_newton) + self.maxbound = self.build_mfdata("maxbound", maxbound) + self.head = self.build_mfdata("head", head) + self.aux = self.build_mfdata("aux", aux) + + self._init_complete = True diff --git a/flopy/mf6/modflow/mfgwfdis.py b/flopy/mf6/modflow/mfgwfdis.py index 88ad8d1edd..d28c91ea50 100644 --- a/flopy/mf6/modflow/mfgwfdis.py +++ b/flopy/mf6/modflow/mfgwfdis.py @@ -49,8 +49,11 @@ class ModflowGwfdis(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. packagedata : record ncf6 filein ncf6_filename Contains data for the ncf package. Data can be passed as a dictionary to the ncf package with variable names as keys and package data as values. Data for @@ -199,7 +202,7 @@ class ModflowGwfdis(MFPackage): "preserve_case true", "reader urword", "optional true", - "prerelease true", + "developmode true", ], [ "block options", diff --git a/flopy/mf6/modflow/mfgwfdisu.py b/flopy/mf6/modflow/mfgwfdisu.py index d4abe1f359..e45634f643 100644 --- a/flopy/mf6/modflow/mfgwfdisu.py +++ b/flopy/mf6/modflow/mfgwfdisu.py @@ -290,7 +290,7 @@ class ModflowGwfdisu(MFPackage): "preserve_case true", "reader urword", "optional true", - "prerelease true", + "developmode true", ], [ "block dimensions", diff --git a/flopy/mf6/modflow/mfgwfdisv.py b/flopy/mf6/modflow/mfgwfdisv.py index ef1202320c..457ba7c05c 100644 --- a/flopy/mf6/modflow/mfgwfdisv.py +++ b/flopy/mf6/modflow/mfgwfdisv.py @@ -52,8 +52,11 @@ class ModflowGwfdisv(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. packagedata : record ncf6 filein ncf6_filename Contains data for the ncf package. Data can be passed as a dictionary to the ncf package with variable names as keys and package data as values. Data for @@ -229,7 +232,7 @@ class ModflowGwfdisv(MFPackage): "preserve_case true", "reader urword", "optional true", - "prerelease true", + "developmode true", ], [ "block options", diff --git a/flopy/mf6/modflow/mfgwfdrng.py b/flopy/mf6/modflow/mfgwfdrng.py new file mode 100644 index 0000000000..e1386a1118 --- /dev/null +++ b/flopy/mf6/modflow/mfgwfdrng.py @@ -0,0 +1,343 @@ +# autogenerated file, do not modify + +from os import PathLike, curdir +from typing import Union + +from flopy.mf6.data.mfdatautil import ArrayTemplateGenerator, ListTemplateGenerator +from flopy.mf6.mfpackage import MFChildPackages, MFPackage + + +class ModflowGwfdrng(MFPackage): + """ + ModflowGwfdrng defines a DRNG package. + + Parameters + ---------- + model + Model that this package is a part of. Package is automatically + added to model when it is initialized. + loading_package : bool, default False + Do not set this parameter. It is intended for debugging and internal + processing purposes only. + auxiliary : [string] + defines an array of one or more auxiliary variable names. there is no limit on + the number of auxiliary variables that can be provided on this line; however, + lists of information provided in subsequent blocks must have a column of data + for each auxiliary variable name defined here. the number of auxiliary + variables detected on this line determines the value for naux. comments cannot + be provided anywhere on this line as they will be interpreted as auxiliary + variable names. auxiliary variables may not be used by the package, but they + will be available for use by other parts of the program. the program will + terminate with an error if auxiliary variables are specified on more than one + line in the options block. + auxmultname : string + name of auxiliary variable to be used as multiplier of drain conductance. + auxdepthname : string + name of a variable listed in auxiliary that defines the depth at which drainage + discharge will be scaled. if a positive value is specified for the auxdepthname + auxiliary variable, then elev is the elevation at which the drain starts to + discharge and elev + ddrn (assuming ddrn is the auxdepthname variable) is the + elevation when the drain conductance (cond) scaling factor is 1. if a negative + drainage depth value is specified for ddrn, then elev + ddrn is the elevation + at which the drain starts to discharge and elev is the elevation when the + conductance (cond) scaling factor is 1. a linear- or cubic-scaling is used to + scale the drain conductance (cond) when the standard or newton-raphson + formulation is used, respectively. this discharge scaling option is described + in more detail in chapter 3 of the supplemental technical information. + print_input : keyword + keyword to indicate that the list of drain information will be written to the + listing file immediately after it is read. + print_flows : keyword + keyword to indicate that the list of drain flow rates will be printed to the + listing file for every stress period time step in which 'budget print' is + specified in output control. if there is no output control option and + 'print_flows' is specified, then flow rates are printed for the last time step + of each stress period. + save_flows : keyword + keyword to indicate that drain flow terms will be written to the file specified + with 'budget fileout' in output control. + observations : record obs6 filein obs6_filename + Contains data for the obs package. Data can be passed as a dictionary to the + obs package with variable names as keys and package data as values. Data for + the observations variable is also acceptable. See obs package documentation for + more information. + mover : keyword + keyword to indicate that this instance of the drain package can be used with + the water mover (mvr) package. when the mover option is specified, additional + memory is allocated within the package to store the available, provided, and + received water. + export_array_netcdf : keyword + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. + dev_cubic_scaling : keyword + cubic-scaling is used to scale the drain conductance + maxbound : integer + integer value specifying the maximum number of drains cells that will be + specified for use during any stress period. + elev : [double precision] + is the elevation of the drain. + cond : [double precision] + is the hydraulic conductance of the interface between the aquifer and the + drain. + aux : [double precision] + is an array of values for auxiliary variable aux(iaux), where iaux is a value + from 1 to naux, and aux(iaux) must be listed as part of the auxiliary + variables. a separate array can be specified for each auxiliary variable. if + the value specified here for the auxiliary variable is the same as auxmultname, + then the conductance array will be multiplied by this array. + + filename : str or PathLike, optional + Name or path of file where this package is stored. + pname : str, optional + Package name. + **kwargs + Extra keywords for :class:`flopy.mf6.mfpackage.MFPackage`. + + """ + + auxiliary = ArrayTemplateGenerator(("gwf6", "drng", "options", "auxiliary")) + obs_filerecord = ListTemplateGenerator( + ("gwf6", "drng", "options", "obs_filerecord") + ) + elev = ArrayTemplateGenerator(("gwf6", "drng", "period", "elev")) + cond = ArrayTemplateGenerator(("gwf6", "drng", "period", "cond")) + aux = ArrayTemplateGenerator(("gwf6", "drng", "period", "aux")) + package_abbr = "gwfdrng" + _package_type = "drng" + dfn_file_name = "gwf-drng.dfn" + dfn = [ + ["header", "multi-package", "package-type stress-package"], + [ + "block options", + "name readarraygrid", + "type keyword", + "reader urword", + "optional false", + "developmode true", + "default true", + ], + [ + "block options", + "name auxiliary", + "type string", + "shape (naux)", + "reader urword", + "optional true", + ], + [ + "block options", + "name auxmultname", + "type string", + "shape", + "reader urword", + "optional true", + ], + [ + "block options", + "name auxdepthname", + "type string", + "shape", + "reader urword", + "optional true", + ], + [ + "block options", + "name print_input", + "type keyword", + "reader urword", + "optional true", + "mf6internal iprpak", + ], + [ + "block options", + "name print_flows", + "type keyword", + "reader urword", + "optional true", + "mf6internal iprflow", + ], + [ + "block options", + "name save_flows", + "type keyword", + "reader urword", + "optional true", + "mf6internal ipakcb", + ], + [ + "block options", + "name obs_filerecord", + "type record obs6 filein obs6_filename", + "shape", + "reader urword", + "tagged true", + "optional true", + "construct_package obs", + "construct_data observations", + "parameter_name continuous", + ], + [ + "block options", + "name obs6", + "type keyword", + "shape", + "in_record true", + "reader urword", + "tagged true", + "optional false", + ], + [ + "block options", + "name filein", + "type keyword", + "shape", + "in_record true", + "reader urword", + "tagged true", + "optional false", + ], + [ + "block options", + "name obs6_filename", + "type string", + "preserve_case true", + "in_record true", + "tagged false", + "reader urword", + "optional false", + ], + [ + "block options", + "name mover", + "type keyword", + "tagged true", + "reader urword", + "optional true", + ], + [ + "block options", + "name export_array_netcdf", + "type keyword", + "reader urword", + "optional true", + "mf6internal export_nc", + "extended true", + ], + [ + "block options", + "name dev_cubic_scaling", + "type keyword", + "reader urword", + "optional true", + "mf6internal icubicsfac", + ], + [ + "block dimensions", + "name maxbound", + "type integer", + "reader urword", + "optional true", + ], + [ + "block period", + "name iper", + "type integer", + "block_variable true", + "in_record true", + "tagged false", + "shape", + "valid", + "reader urword", + "optional false", + ], + [ + "block period", + "name elev", + "type double precision", + "shape (nodes)", + "reader readarray", + "layered true", + "netcdf true", + "default 3.e30", + ], + [ + "block period", + "name cond", + "type double precision", + "shape (nodes)", + "reader readarray", + "layered true", + "netcdf true", + "default 3.e30", + ], + [ + "block period", + "name aux", + "type double precision", + "shape (nodes)", + "reader readarray", + "layered true", + "netcdf true", + "optional true", + "mf6internal auxvar", + ], + ] + + def __init__( + self, + model, + loading_package=False, + auxiliary=None, + auxmultname=None, + auxdepthname=None, + print_input=None, + print_flows=None, + save_flows=None, + observations=None, + mover=None, + export_array_netcdf=None, + dev_cubic_scaling=None, + maxbound=None, + elev=3e30, + cond=3e30, + aux=None, + filename=None, + pname=None, + **kwargs, + ): + """Initialize ModflowGwfdrng.""" + super().__init__( + parent=model, + package_type="drng", + filename=filename, + pname=pname, + loading_package=loading_package, + **kwargs, + ) + + self.auxiliary = self.build_mfdata("auxiliary", auxiliary) + self.auxmultname = self.build_mfdata("auxmultname", auxmultname) + self.auxdepthname = self.build_mfdata("auxdepthname", auxdepthname) + self.print_input = self.build_mfdata("print_input", print_input) + self.print_flows = self.build_mfdata("print_flows", print_flows) + self.save_flows = self.build_mfdata("save_flows", save_flows) + self._obs_filerecord = self.build_mfdata("obs_filerecord", None) + self._obs_package = self.build_child_package( + "obs", observations, "continuous", self._obs_filerecord + ) + self.mover = self.build_mfdata("mover", mover) + self.export_array_netcdf = self.build_mfdata( + "export_array_netcdf", export_array_netcdf + ) + self.dev_cubic_scaling = self.build_mfdata( + "dev_cubic_scaling", dev_cubic_scaling + ) + self.maxbound = self.build_mfdata("maxbound", maxbound) + self.elev = self.build_mfdata("elev", elev) + self.cond = self.build_mfdata("cond", cond) + self.aux = self.build_mfdata("aux", aux) + + self._init_complete = True diff --git a/flopy/mf6/modflow/mfgwfevt.py b/flopy/mf6/modflow/mfgwfevt.py index 3fc1e7fbbf..44f7e7d7e2 100644 --- a/flopy/mf6/modflow/mfgwfevt.py +++ b/flopy/mf6/modflow/mfgwfevt.py @@ -64,8 +64,8 @@ class ModflowGwfevt(MFPackage): indicates that the proportion of the evapotranspiration rate at the et surface will be specified as petm0 in list input. maxbound : integer - integer value specifying the maximum number of evapotranspiration cells cells - that will be specified for use during any stress period. + integer value specifying the maximum number of evapotranspiration cells that + will be specified for use during any stress period. nseg : integer number of et segments. default is one. when nseg is greater than 1, the pxdp and petm arrays must be of size nseg - 1 and be listed in order from the diff --git a/flopy/mf6/modflow/mfgwfevta.py b/flopy/mf6/modflow/mfgwfevta.py index 21668f696a..4fd535f6cb 100644 --- a/flopy/mf6/modflow/mfgwfevta.py +++ b/flopy/mf6/modflow/mfgwfevta.py @@ -65,8 +65,11 @@ class ModflowGwfevta(MFPackage): the observations variable is also acceptable. See obs package documentation for more information. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. ievt : [integer] ievt is the layer number that defines the layer in each vertical column where evapotranspiration is applied. if ievt is omitted, evapotranspiration by @@ -274,6 +277,7 @@ class ModflowGwfevta(MFPackage): "reader readarray", "numeric_index true", "optional true", + "netcdf true", ], [ "block period", @@ -281,6 +285,7 @@ class ModflowGwfevta(MFPackage): "type double precision", "shape (ncol*nrow; ncpl)", "reader readarray", + "netcdf true", "default 0.", ], [ @@ -290,6 +295,7 @@ class ModflowGwfevta(MFPackage): "shape (ncol*nrow; ncpl)", "reader readarray", "time_series true", + "netcdf true", "default 1.e-3", ], [ @@ -298,6 +304,7 @@ class ModflowGwfevta(MFPackage): "type double precision", "shape (ncol*nrow; ncpl)", "reader readarray", + "netcdf true", "default 1.0", ], [ @@ -307,6 +314,7 @@ class ModflowGwfevta(MFPackage): "shape (ncol*nrow; ncpl)", "reader readarray", "time_series true", + "netcdf true", "mf6internal auxvar", ], ] diff --git a/flopy/mf6/modflow/mfgwfghbg.py b/flopy/mf6/modflow/mfgwfghbg.py new file mode 100644 index 0000000000..415872ee4e --- /dev/null +++ b/flopy/mf6/modflow/mfgwfghbg.py @@ -0,0 +1,308 @@ +# autogenerated file, do not modify + +from os import PathLike, curdir +from typing import Union + +from flopy.mf6.data.mfdatautil import ArrayTemplateGenerator, ListTemplateGenerator +from flopy.mf6.mfpackage import MFChildPackages, MFPackage + + +class ModflowGwfghbg(MFPackage): + """ + ModflowGwfghbg defines a GHBG package. + + Parameters + ---------- + model + Model that this package is a part of. Package is automatically + added to model when it is initialized. + loading_package : bool, default False + Do not set this parameter. It is intended for debugging and internal + processing purposes only. + auxiliary : [string] + defines an array of one or more auxiliary variable names. there is no limit on + the number of auxiliary variables that can be provided on this line; however, + lists of information provided in subsequent blocks must have a column of data + for each auxiliary variable name defined here. the number of auxiliary + variables detected on this line determines the value for naux. comments cannot + be provided anywhere on this line as they will be interpreted as auxiliary + variable names. auxiliary variables may not be used by the package, but they + will be available for use by other parts of the program. the program will + terminate with an error if auxiliary variables are specified on more than one + line in the options block. + auxmultname : string + name of auxiliary variable to be used as multiplier of general-head boundary + conductance. + print_input : keyword + keyword to indicate that the list of general-head boundary information will be + written to the listing file immediately after it is read. + print_flows : keyword + keyword to indicate that the list of general-head boundary flow rates will be + printed to the listing file for every stress period time step in which 'budget + print' is specified in output control. if there is no output control option + and 'print_flows' is specified, then flow rates are printed for the last time + step of each stress period. + save_flows : keyword + keyword to indicate that general-head boundary flow terms will be written to + the file specified with 'budget fileout' in output control. + observations : record obs6 filein obs6_filename + Contains data for the obs package. Data can be passed as a dictionary to the + obs package with variable names as keys and package data as values. Data for + the observations variable is also acceptable. See obs package documentation for + more information. + mover : keyword + keyword to indicate that this instance of the general-head boundary package can + be used with the water mover (mvr) package. when the mover option is + specified, additional memory is allocated within the package to store the + available, provided, and received water. + export_array_netcdf : keyword + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. + maxbound : integer + integer value specifying the maximum number of general-head boundary cells that + will be specified for use during any stress period. + bhead : [double precision] + is the boundary head. + cond : [double precision] + is the hydraulic conductance of the interface between the aquifer cell and the + boundary. + aux : [double precision] + is an array of values for auxiliary variable aux(iaux), where iaux is a value + from 1 to naux, and aux(iaux) must be listed as part of the auxiliary + variables. a separate array can be specified for each auxiliary variable. if + the value specified here for the auxiliary variable is the same as auxmultname, + then the conductance array will be multiplied by this array. + + filename : str or PathLike, optional + Name or path of file where this package is stored. + pname : str, optional + Package name. + **kwargs + Extra keywords for :class:`flopy.mf6.mfpackage.MFPackage`. + + """ + + auxiliary = ArrayTemplateGenerator(("gwf6", "ghbg", "options", "auxiliary")) + obs_filerecord = ListTemplateGenerator( + ("gwf6", "ghbg", "options", "obs_filerecord") + ) + bhead = ArrayTemplateGenerator(("gwf6", "ghbg", "period", "bhead")) + cond = ArrayTemplateGenerator(("gwf6", "ghbg", "period", "cond")) + aux = ArrayTemplateGenerator(("gwf6", "ghbg", "period", "aux")) + package_abbr = "gwfghbg" + _package_type = "ghbg" + dfn_file_name = "gwf-ghbg.dfn" + dfn = [ + ["header", "multi-package", "package-type stress-package"], + [ + "block options", + "name readarraygrid", + "type keyword", + "reader urword", + "optional false", + "developmode true", + "default true", + ], + [ + "block options", + "name auxiliary", + "type string", + "shape (naux)", + "reader urword", + "optional true", + ], + [ + "block options", + "name auxmultname", + "type string", + "shape", + "reader urword", + "optional true", + ], + [ + "block options", + "name print_input", + "type keyword", + "reader urword", + "optional true", + "mf6internal iprpak", + ], + [ + "block options", + "name print_flows", + "type keyword", + "reader urword", + "optional true", + "mf6internal iprflow", + ], + [ + "block options", + "name save_flows", + "type keyword", + "reader urword", + "optional true", + "mf6internal ipakcb", + ], + [ + "block options", + "name obs_filerecord", + "type record obs6 filein obs6_filename", + "shape", + "reader urword", + "tagged true", + "optional true", + "construct_package obs", + "construct_data observations", + "parameter_name continuous", + ], + [ + "block options", + "name obs6", + "type keyword", + "shape", + "in_record true", + "reader urword", + "tagged true", + "optional false", + ], + [ + "block options", + "name filein", + "type keyword", + "shape", + "in_record true", + "reader urword", + "tagged true", + "optional false", + ], + [ + "block options", + "name obs6_filename", + "type string", + "preserve_case true", + "in_record true", + "tagged false", + "reader urword", + "optional false", + ], + [ + "block options", + "name mover", + "type keyword", + "tagged true", + "reader urword", + "optional true", + ], + [ + "block options", + "name export_array_netcdf", + "type keyword", + "reader urword", + "optional true", + "mf6internal export_nc", + "extended true", + ], + [ + "block dimensions", + "name maxbound", + "type integer", + "reader urword", + "optional true", + ], + [ + "block period", + "name iper", + "type integer", + "block_variable true", + "in_record true", + "tagged false", + "shape", + "valid", + "reader urword", + "optional false", + ], + [ + "block period", + "name bhead", + "type double precision", + "shape (nodes)", + "reader readarray", + "layered true", + "netcdf true", + "default 3.e30", + ], + [ + "block period", + "name cond", + "type double precision", + "shape (nodes)", + "reader readarray", + "layered true", + "netcdf true", + "default 3.e30", + ], + [ + "block period", + "name aux", + "type double precision", + "shape (nodes)", + "reader readarray", + "layered true", + "netcdf true", + "optional true", + "mf6internal auxvar", + ], + ] + + def __init__( + self, + model, + loading_package=False, + auxiliary=None, + auxmultname=None, + print_input=None, + print_flows=None, + save_flows=None, + observations=None, + mover=None, + export_array_netcdf=None, + maxbound=None, + bhead=3e30, + cond=3e30, + aux=None, + filename=None, + pname=None, + **kwargs, + ): + """Initialize ModflowGwfghbg.""" + super().__init__( + parent=model, + package_type="ghbg", + filename=filename, + pname=pname, + loading_package=loading_package, + **kwargs, + ) + + self.auxiliary = self.build_mfdata("auxiliary", auxiliary) + self.auxmultname = self.build_mfdata("auxmultname", auxmultname) + self.print_input = self.build_mfdata("print_input", print_input) + self.print_flows = self.build_mfdata("print_flows", print_flows) + self.save_flows = self.build_mfdata("save_flows", save_flows) + self._obs_filerecord = self.build_mfdata("obs_filerecord", None) + self._obs_package = self.build_child_package( + "obs", observations, "continuous", self._obs_filerecord + ) + self.mover = self.build_mfdata("mover", mover) + self.export_array_netcdf = self.build_mfdata( + "export_array_netcdf", export_array_netcdf + ) + self.maxbound = self.build_mfdata("maxbound", maxbound) + self.bhead = self.build_mfdata("bhead", bhead) + self.cond = self.build_mfdata("cond", cond) + self.aux = self.build_mfdata("aux", aux) + + self._init_complete = True diff --git a/flopy/mf6/modflow/mfgwfhfb.py b/flopy/mf6/modflow/mfgwfhfb.py index eb6158f8fc..90e3ef1b1d 100644 --- a/flopy/mf6/modflow/mfgwfhfb.py +++ b/flopy/mf6/modflow/mfgwfhfb.py @@ -20,12 +20,12 @@ class ModflowGwfhfb(MFPackage): Do not set this parameter. It is intended for debugging and internal processing purposes only. print_input : keyword - keyword to indicate that the list of horizontal flow barriers will be written - to the listing file immediately after it is read. + keyword to indicate that the list of hydraulic flow barriers will be written to + the listing file immediately after it is read. maxhfb : integer - integer value specifying the maximum number of horizontal flow barriers that + integer value specifying the maximum number of hydraulic flow barriers that will be entered in this input file. the value of maxhfb is used to allocate - memory for the horizontal flow barriers. + memory for the hydraulic flow barriers. stress_period_data : [(cellid1, cellid2, hydchr)] * cellid1 : [integer] identifier for the first cell. For a structured grid that uses the DIS input @@ -35,14 +35,14 @@ class ModflowGwfhfb(MFPackage): input file, then CELLID1 is the node numbers for the cell. The barrier is located between cells designated as CELLID1 and CELLID2. For models that use the DIS and DISV grid types, the layer number for CELLID1 and CELLID2 must be - the same. For all grid types, cells must be horizontally adjacent or the - program will terminate with an error. + the same. For all grid types, cells must be horizontally or vertically + adjacent. * cellid2 : [integer] identifier for the second cell. See CELLID1 for description of how to specify. * hydchr : double precision - is the hydraulic characteristic of the horizontal-flow barrier. The hydraulic + is the hydraulic characteristic of the hydraulic-flow barrier. The hydraulic characteristic is the barrier hydraulic conductivity divided by the width of - the horizontal-flow barrier. If the hydraulic characteristic is negative, then + the hydraulic-flow barrier. If the hydraulic characteristic is negative, then the absolute value of HYDCHR acts as a multiplier to the conductance between the two model cells specified as containing the barrier. For example, if the value for HYDCHR was specified as -1.5, the conductance calculated for the two diff --git a/flopy/mf6/modflow/mfgwfic.py b/flopy/mf6/modflow/mfgwfic.py index 478b6d095a..f21082e5fe 100644 --- a/flopy/mf6/modflow/mfgwfic.py +++ b/flopy/mf6/modflow/mfgwfic.py @@ -23,8 +23,11 @@ class ModflowGwfic(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. strt : [double precision] is the initial (starting) head---that is, head at the beginning of the gwf model simulation. strt must be specified for all simulations, including diff --git a/flopy/mf6/modflow/mfgwflak.py b/flopy/mf6/modflow/mfgwflak.py index 57761fad00..f761adb648 100644 --- a/flopy/mf6/modflow/mfgwflak.py +++ b/flopy/mf6/modflow/mfgwflak.py @@ -106,8 +106,8 @@ class ModflowGwflak(MFPackage): seconds to model time units. time_conversion should be set to 1.0, 60.0, 3,600.0, 86,400.0, and 31,557,600.0 when using time units (time_units) of seconds, minutes, hours, days, or years in the simulation, respectively. - convtime does not need to be specified if no lake outlets are specified or - time_units are seconds. + time_conversion does not need to be specified if no lake outlets are specified + or time_units are seconds. length_conversion : double precision real value that is used to convert outlet user-specified manning's roughness coefficients or gravitational acceleration used to calculate outlet flows from diff --git a/flopy/mf6/modflow/mfgwfnpf.py b/flopy/mf6/modflow/mfgwfnpf.py index f31bcdb47d..1a1f1af634 100644 --- a/flopy/mf6/modflow/mfgwfnpf.py +++ b/flopy/mf6/modflow/mfgwfnpf.py @@ -39,7 +39,10 @@ class ModflowGwfnpf(MFPackage): signifies that the conductance will be calculated using arithmetic-mean thickness and harmonic-mean hydraulic conductivity. if the user does not specify a value for alternative_cell_averaging, then the harmonic-mean method - will be used. this option cannot be used if the xt3d option is invoked. + will be used. this option cannot be used if the xt3d option is invoked. the + amt-hmk alternative_cell_averaging option, in combination with the + dry_cell_saturation option, can be used to calculate the same horizontal + conductance as modflow-usg when upstream weighting is used (laycon=4). thickstrt : keyword indicates that cells having a negative icelltype are confined, and their cell thickness for conductance calculations will be computed as strt-bot rather than @@ -101,6 +104,16 @@ class ModflowGwfnpf(MFPackage): added to the right-hand side. If the RHS keyword is excluded, then the XT3D terms will be put into the coefficient matrix. + highest_cell_saturation : keyword + keyword indicating that the maximum cell bottom will be used to calculate the + saturation used to calculate the horizontal conductance between cells. this + option is intended to prevent flow from leaving a dry cell and is based on + cite{painter2008robust}. this option is only applied when the newton-raphson + formulation is used, a warning will be issued if this option is specified and + the newton-raphson formulation is not specified in the gwf name file. this + option, in combination with the amt-hmk alternative_cell_averaging option, can + be used to calculate the same horizontal conductance as modflow-usg when + upstream weighting is used (laycon=4). save_specific_discharge : keyword keyword to indicate that x, y, and z components of specific discharge will be calculated at cell centers and written to the budget file, which is specified @@ -133,8 +146,11 @@ class ModflowGwfnpf(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. dev_no_newton : keyword turn off newton for unconfined cells dev_omega : double precision @@ -375,6 +391,14 @@ class ModflowGwfnpf(MFPackage): "optional true", "mf6internal ixt3drhs", ], + [ + "block options", + "name highest_cell_saturation", + "type keyword", + "reader urword", + "optional true", + "mf6internal ihighcellsat", + ], [ "block options", "name save_specific_discharge", @@ -586,6 +610,7 @@ def __init__( perched=None, rewet_record=None, xt3doptions=None, + highest_cell_saturation=None, save_specific_discharge=None, save_saturation=None, k22overk=None, @@ -627,6 +652,9 @@ def __init__( self.perched = self.build_mfdata("perched", perched) self.rewet_record = self.build_mfdata("rewet_record", rewet_record) self.xt3doptions = self.build_mfdata("xt3doptions", xt3doptions) + self.highest_cell_saturation = self.build_mfdata( + "highest_cell_saturation", highest_cell_saturation + ) self.save_specific_discharge = self.build_mfdata( "save_specific_discharge", save_specific_discharge ) diff --git a/flopy/mf6/modflow/mfgwfoc.py b/flopy/mf6/modflow/mfgwfoc.py index 654904c43f..a5a083b4f1 100644 --- a/flopy/mf6/modflow/mfgwfoc.py +++ b/flopy/mf6/modflow/mfgwfoc.py @@ -92,6 +92,7 @@ class ModflowGwfoc(MFPackage): "reader urword", "tagged true", "optional true", + "mf6internal budfilerec", ], [ "block options", @@ -132,6 +133,7 @@ class ModflowGwfoc(MFPackage): "reader urword", "tagged true", "optional true", + "mf6internal budcsvfilerec", ], [ "block options", @@ -162,6 +164,7 @@ class ModflowGwfoc(MFPackage): "reader urword", "tagged true", "optional true", + "mf6internal headfilerec", ], [ "block options", @@ -191,6 +194,7 @@ class ModflowGwfoc(MFPackage): "shape", "reader urword", "optional true", + "mf6internal headprintrec", ], [ "block options", diff --git a/flopy/mf6/modflow/mfgwfrch.py b/flopy/mf6/modflow/mfgwfrch.py index ec537d48fe..7c3556f5df 100644 --- a/flopy/mf6/modflow/mfgwfrch.py +++ b/flopy/mf6/modflow/mfgwfrch.py @@ -61,8 +61,8 @@ class ModflowGwfrch(MFPackage): the observations variable is also acceptable. See obs package documentation for more information. maxbound : integer - integer value specifying the maximum number of recharge cells cells that will - be specified for use during any stress period. + integer value specifying the maximum number of recharge cells that will be + specified for use during any stress period. stress_period_data : [(cellid, recharge, aux, boundname)] * cellid : [integer] is the cell identifier, and depends on the type of grid that is used for the diff --git a/flopy/mf6/modflow/mfgwfrcha.py b/flopy/mf6/modflow/mfgwfrcha.py index 7ee952df2b..e319c01310 100644 --- a/flopy/mf6/modflow/mfgwfrcha.py +++ b/flopy/mf6/modflow/mfgwfrcha.py @@ -65,8 +65,11 @@ class ModflowGwfrcha(MFPackage): the observations variable is also acceptable. See obs package documentation for more information. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. irch : [integer] irch is the layer number that defines the layer in each vertical column where recharge is applied. if irch is omitted, recharge by default is applied to @@ -270,6 +273,7 @@ class ModflowGwfrcha(MFPackage): "reader readarray", "numeric_index true", "optional true", + "netcdf true", ], [ "block period", @@ -278,6 +282,7 @@ class ModflowGwfrcha(MFPackage): "shape (ncol*nrow; ncpl)", "reader readarray", "time_series true", + "netcdf true", "default 1.e-3", ], [ @@ -288,6 +293,7 @@ class ModflowGwfrcha(MFPackage): "reader readarray", "time_series true", "optional true", + "netcdf true", "mf6internal auxvar", ], ] diff --git a/flopy/mf6/modflow/mfgwfrivg.py b/flopy/mf6/modflow/mfgwfrivg.py new file mode 100644 index 0000000000..3472aef279 --- /dev/null +++ b/flopy/mf6/modflow/mfgwfrivg.py @@ -0,0 +1,321 @@ +# autogenerated file, do not modify + +from os import PathLike, curdir +from typing import Union + +from flopy.mf6.data.mfdatautil import ArrayTemplateGenerator, ListTemplateGenerator +from flopy.mf6.mfpackage import MFChildPackages, MFPackage + + +class ModflowGwfrivg(MFPackage): + """ + ModflowGwfrivg defines a RIVG package. + + Parameters + ---------- + model + Model that this package is a part of. Package is automatically + added to model when it is initialized. + loading_package : bool, default False + Do not set this parameter. It is intended for debugging and internal + processing purposes only. + auxiliary : [string] + defines an array of one or more auxiliary variable names. there is no limit on + the number of auxiliary variables that can be provided on this line; however, + lists of information provided in subsequent blocks must have a column of data + for each auxiliary variable name defined here. the number of auxiliary + variables detected on this line determines the value for naux. comments cannot + be provided anywhere on this line as they will be interpreted as auxiliary + variable names. auxiliary variables may not be used by the package, but they + will be available for use by other parts of the program. the program will + terminate with an error if auxiliary variables are specified on more than one + line in the options block. + auxmultname : string + name of auxiliary variable to be used as multiplier of riverbed conductance. + print_input : keyword + keyword to indicate that the list of river information will be written to the + listing file immediately after it is read. + print_flows : keyword + keyword to indicate that the list of river flow rates will be printed to the + listing file for every stress period time step in which 'budget print' is + specified in output control. if there is no output control option and + 'print_flows' is specified, then flow rates are printed for the last time step + of each stress period. + save_flows : keyword + keyword to indicate that river flow terms will be written to the file specified + with 'budget fileout' in output control. + observations : record obs6 filein obs6_filename + Contains data for the obs package. Data can be passed as a dictionary to the + obs package with variable names as keys and package data as values. Data for + the observations variable is also acceptable. See obs package documentation for + more information. + mover : keyword + keyword to indicate that this instance of the river package can be used with + the water mover (mvr) package. when the mover option is specified, additional + memory is allocated within the package to store the available, provided, and + received water. + export_array_netcdf : keyword + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. + maxbound : integer + integer value specifying the maximum number of rivers cells that will be + specified for use during any stress period. + stage : [double precision] + is the head in the river. + cond : [double precision] + is the riverbed hydraulic conductance. + rbot : [double precision] + is the elevation of the bottom of the riverbed. + aux : [double precision] + is an array of values for auxiliary variable aux(iaux), where iaux is a value + from 1 to naux, and aux(iaux) must be listed as part of the auxiliary + variables. a separate array can be specified for each auxiliary variable. if + the value specified here for the auxiliary variable is the same as auxmultname, + then the conductance array will be multiplied by this array. + + filename : str or PathLike, optional + Name or path of file where this package is stored. + pname : str, optional + Package name. + **kwargs + Extra keywords for :class:`flopy.mf6.mfpackage.MFPackage`. + + """ + + auxiliary = ArrayTemplateGenerator(("gwf6", "rivg", "options", "auxiliary")) + obs_filerecord = ListTemplateGenerator( + ("gwf6", "rivg", "options", "obs_filerecord") + ) + stage = ArrayTemplateGenerator(("gwf6", "rivg", "period", "stage")) + cond = ArrayTemplateGenerator(("gwf6", "rivg", "period", "cond")) + rbot = ArrayTemplateGenerator(("gwf6", "rivg", "period", "rbot")) + aux = ArrayTemplateGenerator(("gwf6", "rivg", "period", "aux")) + package_abbr = "gwfrivg" + _package_type = "rivg" + dfn_file_name = "gwf-rivg.dfn" + dfn = [ + ["header", "multi-package", "package-type stress-package"], + [ + "block options", + "name readarraygrid", + "type keyword", + "reader urword", + "optional false", + "developmode true", + "default True", + ], + [ + "block options", + "name auxiliary", + "type string", + "shape (naux)", + "reader urword", + "optional true", + ], + [ + "block options", + "name auxmultname", + "type string", + "shape", + "reader urword", + "optional true", + ], + [ + "block options", + "name print_input", + "type keyword", + "reader urword", + "optional true", + "mf6internal iprpak", + ], + [ + "block options", + "name print_flows", + "type keyword", + "reader urword", + "optional true", + "mf6internal iprflow", + ], + [ + "block options", + "name save_flows", + "type keyword", + "reader urword", + "optional true", + "mf6internal ipakcb", + ], + [ + "block options", + "name obs_filerecord", + "type record obs6 filein obs6_filename", + "shape", + "reader urword", + "tagged true", + "optional true", + "construct_package obs", + "construct_data observations", + "parameter_name continuous", + ], + [ + "block options", + "name obs6", + "type keyword", + "shape", + "in_record true", + "reader urword", + "tagged true", + "optional false", + ], + [ + "block options", + "name filein", + "type keyword", + "shape", + "in_record true", + "reader urword", + "tagged true", + "optional false", + ], + [ + "block options", + "name obs6_filename", + "type string", + "preserve_case true", + "in_record true", + "tagged false", + "reader urword", + "optional false", + ], + [ + "block options", + "name mover", + "type keyword", + "tagged true", + "reader urword", + "optional true", + ], + [ + "block options", + "name export_array_netcdf", + "type keyword", + "reader urword", + "optional true", + "mf6internal export_nc", + "extended true", + ], + [ + "block dimensions", + "name maxbound", + "type integer", + "reader urword", + "optional true", + ], + [ + "block period", + "name iper", + "type integer", + "block_variable True", + "in_record true", + "tagged false", + "shape", + "valid", + "reader urword", + "optional false", + ], + [ + "block period", + "name stage", + "type double precision", + "shape (nodes)", + "reader readarray", + "layered true", + "netcdf true", + "default 3.e30", + ], + [ + "block period", + "name cond", + "type double precision", + "shape (nodes)", + "reader readarray", + "layered true", + "netcdf true", + "default 3.e30", + ], + [ + "block period", + "name rbot", + "type double precision", + "shape (nodes)", + "reader readarray", + "layered true", + "netcdf true", + "default 3.e30", + ], + [ + "block period", + "name aux", + "type double precision", + "shape (nodes)", + "reader readarray", + "layered true", + "netcdf true", + "optional true", + "mf6internal auxvar", + ], + ] + + def __init__( + self, + model, + loading_package=False, + auxiliary=None, + auxmultname=None, + print_input=None, + print_flows=None, + save_flows=None, + observations=None, + mover=None, + export_array_netcdf=None, + maxbound=None, + stage=3e30, + cond=3e30, + rbot=3e30, + aux=None, + filename=None, + pname=None, + **kwargs, + ): + """Initialize ModflowGwfrivg.""" + super().__init__( + parent=model, + package_type="rivg", + filename=filename, + pname=pname, + loading_package=loading_package, + **kwargs, + ) + + self.auxiliary = self.build_mfdata("auxiliary", auxiliary) + self.auxmultname = self.build_mfdata("auxmultname", auxmultname) + self.print_input = self.build_mfdata("print_input", print_input) + self.print_flows = self.build_mfdata("print_flows", print_flows) + self.save_flows = self.build_mfdata("save_flows", save_flows) + self._obs_filerecord = self.build_mfdata("obs_filerecord", None) + self._obs_package = self.build_child_package( + "obs", observations, "continuous", self._obs_filerecord + ) + self.mover = self.build_mfdata("mover", mover) + self.export_array_netcdf = self.build_mfdata( + "export_array_netcdf", export_array_netcdf + ) + self.maxbound = self.build_mfdata("maxbound", maxbound) + self.stage = self.build_mfdata("stage", stage) + self.cond = self.build_mfdata("cond", cond) + self.rbot = self.build_mfdata("rbot", rbot) + self.aux = self.build_mfdata("aux", aux) + + self._init_complete = True diff --git a/flopy/mf6/modflow/mfgwfsto.py b/flopy/mf6/modflow/mfgwfsto.py index 9143acd7af..c9aa6d0876 100644 --- a/flopy/mf6/modflow/mfgwfsto.py +++ b/flopy/mf6/modflow/mfgwfsto.py @@ -41,8 +41,11 @@ class ModflowGwfsto(MFPackage): keyword that specifies input grid arrays, which already support the layered keyword, should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. dev_original_specific_storage : keyword flag indicating the original storage specific storage formulation should be used diff --git a/flopy/mf6/modflow/mfgwfwel.py b/flopy/mf6/modflow/mfgwfwel.py index 6b557e0f17..54da47dcf4 100644 --- a/flopy/mf6/modflow/mfgwfwel.py +++ b/flopy/mf6/modflow/mfgwfwel.py @@ -65,6 +65,13 @@ class ModflowGwfwel(MFPackage): well extraction rates that have been reduced by the program. Entries are only written if the extraction rates are reduced. + flow_reduction_length : keyword + keyword that indicates the auto_flow_reduce value is a length instead of a + fraction of the cell thickness. a warning will be issued if the + flow_reduction_length option is specified but the auto_flow_reduce option is + not specified in the options block. the program will terminate with an error if + the flow_reduction_length option is specified and the auto_flow_reduce value + specified in the options block is less than or equal to zero. timeseries : record ts6 filein ts6_filename Contains data for the ts package. Data can be passed as a dictionary to the ts package with variable names as keys and package data as values. Data for the @@ -230,6 +237,14 @@ class ModflowGwfwel(MFPackage): "tagged false", "optional false", ], + [ + "block options", + "name flow_reduction_length", + "type keyword", + "reader urword", + "optional true", + "mf6internal iflowredlen", + ], [ "block options", "name ts_filerecord", @@ -394,6 +409,7 @@ def __init__( save_flows=None, auto_flow_reduce=None, afrcsv_filerecord=None, + flow_reduction_length=None, timeseries=None, observations=None, mover=None, @@ -423,6 +439,9 @@ def __init__( self.afrcsv_filerecord = self.build_mfdata( "afrcsv_filerecord", afrcsv_filerecord ) + self.flow_reduction_length = self.build_mfdata( + "flow_reduction_length", flow_reduction_length + ) self._ts_filerecord = self.build_mfdata("ts_filerecord", None) self._ts_package = self.build_child_package( "ts", timeseries, "timeseries", self._ts_filerecord diff --git a/flopy/mf6/modflow/mfgwfwelg.py b/flopy/mf6/modflow/mfgwfwelg.py new file mode 100644 index 0000000000..5fec9ff505 --- /dev/null +++ b/flopy/mf6/modflow/mfgwfwelg.py @@ -0,0 +1,388 @@ +# autogenerated file, do not modify + +from os import PathLike, curdir +from typing import Union + +from flopy.mf6.data.mfdatautil import ArrayTemplateGenerator, ListTemplateGenerator +from flopy.mf6.mfpackage import MFChildPackages, MFPackage + + +class ModflowGwfwelg(MFPackage): + """ + ModflowGwfwelg defines a WELG package. + + Parameters + ---------- + model + Model that this package is a part of. Package is automatically + added to model when it is initialized. + loading_package : bool, default False + Do not set this parameter. It is intended for debugging and internal + processing purposes only. + auxiliary : [string] + defines an array of one or more auxiliary variable names. there is no limit on + the number of auxiliary variables that can be provided on this line; however, + lists of information provided in subsequent blocks must have a column of data + for each auxiliary variable name defined here. the number of auxiliary + variables detected on this line determines the value for naux. comments cannot + be provided anywhere on this line as they will be interpreted as auxiliary + variable names. auxiliary variables may not be used by the package, but they + will be available for use by other parts of the program. the program will + terminate with an error if auxiliary variables are specified on more than one + line in the options block. + auxmultname : string + name of auxiliary variable to be used as multiplier of well flow rate. + print_input : keyword + keyword to indicate that the list of well information will be written to the + listing file immediately after it is read. + print_flows : keyword + keyword to indicate that the list of well flow rates will be printed to the + listing file for every stress period time step in which 'budget print' is + specified in output control. if there is no output control option and + 'print_flows' is specified, then flow rates are printed for the last time step + of each stress period. + save_flows : keyword + keyword to indicate that well flow terms will be written to the file specified + with 'budget fileout' in output control. + auto_flow_reduce : double precision + keyword and real value that defines the fraction of the cell thickness used as + an interval for smoothly adjusting negative pumping rates to 0 in cells with + head values less than or equal to the bottom of the cell. negative pumping + rates are adjusted to 0 or a smaller negative value when the head in the cell + is equal to or less than the calculated interval above the cell bottom. + auto_flow_reduce is set to 0.1 if the specified value is less than or equal to + zero. by default, negative pumping rates are not reduced during a simulation. + this auto_flow_reduce option only applies to wells in model cells that are + marked as 'convertible' (icelltype /= 0) in the node property flow (npf) input + file. reduction in flow will not occur for wells in cells marked as confined + (icelltype = 0). + afrcsv_filerecord : (afrcsvfile) + * afrcsvfile : string + name of the comma-separated value (CSV) output file to write information about + well extraction rates that have been reduced by the program. Entries are only + written if the extraction rates are reduced. + + flow_reduction_length : keyword + keyword that indicates the auto_flow_reduce value is a length instead of a + fraction of the cell thickness. a warning will be issued if the + flow_reduction_length option is specified but the auto_flow_reduce option is + not specified in the options block. the program will terminate with an error if + the flow_reduction_length option is specified and the auto_flow_reduce value + specified in the options block is less than or equal to zero. + observations : record obs6 filein obs6_filename + Contains data for the obs package. Data can be passed as a dictionary to the + obs package with variable names as keys and package data as values. Data for + the observations variable is also acceptable. See obs package documentation for + more information. + mover : keyword + keyword to indicate that this instance of the well package can be used with the + water mover (mvr) package. when the mover option is specified, additional + memory is allocated within the package to store the available, provided, and + received water. + export_array_netcdf : keyword + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. + maxbound : integer + integer value specifying the maximum number of wells cells that will be + specified for use during any stress period. + q : [double precision] + is the volumetric well rate. a positive value indicates recharge (injection) + and a negative value indicates discharge (extraction). + aux : [double precision] + is an array of values for auxiliary variable aux(iaux), where iaux is a value + from 1 to naux, and aux(iaux) must be listed as part of the auxiliary + variables. a separate array can be specified for each auxiliary variable. if + the value specified here for the auxiliary variable is the same as auxmultname, + then the well rate array will be multiplied by this array. + + filename : str or PathLike, optional + Name or path of file where this package is stored. + pname : str, optional + Package name. + **kwargs + Extra keywords for :class:`flopy.mf6.mfpackage.MFPackage`. + + """ + + auxiliary = ArrayTemplateGenerator(("gwf6", "welg", "options", "auxiliary")) + afrcsv_filerecord = ListTemplateGenerator( + ("gwf6", "welg", "options", "afrcsv_filerecord") + ) + obs_filerecord = ListTemplateGenerator( + ("gwf6", "welg", "options", "obs_filerecord") + ) + q = ArrayTemplateGenerator(("gwf6", "welg", "period", "q")) + aux = ArrayTemplateGenerator(("gwf6", "welg", "period", "aux")) + package_abbr = "gwfwelg" + _package_type = "welg" + dfn_file_name = "gwf-welg.dfn" + dfn = [ + ["header", "multi-package", "package-type stress-package"], + [ + "block options", + "name readarraygrid", + "type keyword", + "reader urword", + "optional false", + "developmode true", + "default true", + ], + [ + "block options", + "name auxiliary", + "type string", + "shape (naux)", + "reader urword", + "optional true", + ], + [ + "block options", + "name auxmultname", + "type string", + "shape", + "reader urword", + "optional true", + ], + [ + "block options", + "name print_input", + "type keyword", + "reader urword", + "optional true", + "mf6internal iprpak", + ], + [ + "block options", + "name print_flows", + "type keyword", + "reader urword", + "optional true", + "mf6internal iprflow", + ], + [ + "block options", + "name save_flows", + "type keyword", + "reader urword", + "optional true", + "mf6internal ipakcb", + ], + [ + "block options", + "name auto_flow_reduce", + "type double precision", + "reader urword", + "optional true", + "mf6internal flowred", + ], + [ + "block options", + "name afrcsv_filerecord", + "type record auto_flow_reduce_csv fileout afrcsvfile", + "shape", + "reader urword", + "tagged true", + "optional true", + "mf6internal afrcsv_rec", + ], + [ + "block options", + "name auto_flow_reduce_csv", + "type keyword", + "shape", + "in_record true", + "reader urword", + "tagged true", + "optional false", + "mf6internal afrcsv", + ], + [ + "block options", + "name fileout", + "type keyword", + "shape", + "in_record true", + "reader urword", + "tagged true", + "optional false", + ], + [ + "block options", + "name afrcsvfile", + "type string", + "preserve_case true", + "shape", + "in_record true", + "reader urword", + "tagged false", + "optional false", + ], + [ + "block options", + "name flow_reduction_length", + "type keyword", + "reader urword", + "optional true", + "mf6internal iflowredlen", + ], + [ + "block options", + "name obs_filerecord", + "type record obs6 filein obs6_filename", + "shape", + "reader urword", + "tagged true", + "optional true", + "construct_package obs", + "construct_data observations", + "parameter_name continuous", + ], + [ + "block options", + "name filein", + "type keyword", + "shape", + "in_record true", + "reader urword", + "tagged true", + "optional false", + ], + [ + "block options", + "name obs6", + "type keyword", + "shape", + "in_record true", + "reader urword", + "tagged true", + "optional false", + ], + [ + "block options", + "name obs6_filename", + "type string", + "preserve_case true", + "in_record true", + "tagged false", + "reader urword", + "optional false", + ], + [ + "block options", + "name mover", + "type keyword", + "tagged true", + "reader urword", + "optional true", + ], + [ + "block options", + "name export_array_netcdf", + "type keyword", + "reader urword", + "optional true", + "mf6internal export_nc", + "extended true", + ], + [ + "block dimensions", + "name maxbound", + "type integer", + "reader urword", + "optional true", + ], + [ + "block period", + "name iper", + "type integer", + "block_variable true", + "in_record true", + "tagged false", + "shape", + "valid", + "reader urword", + "optional false", + ], + [ + "block period", + "name q", + "type double precision", + "shape (nodes)", + "reader readarray", + "layered true", + "netcdf true", + "default 3.e30", + ], + [ + "block period", + "name aux", + "type double precision", + "shape (nodes)", + "reader readarray", + "layered true", + "netcdf true", + "optional true", + "mf6internal auxvar", + ], + ] + + def __init__( + self, + model, + loading_package=False, + auxiliary=None, + auxmultname=None, + print_input=None, + print_flows=None, + save_flows=None, + auto_flow_reduce=None, + afrcsv_filerecord=None, + flow_reduction_length=None, + observations=None, + mover=None, + export_array_netcdf=None, + maxbound=None, + q=3e30, + aux=None, + filename=None, + pname=None, + **kwargs, + ): + """Initialize ModflowGwfwelg.""" + super().__init__( + parent=model, + package_type="welg", + filename=filename, + pname=pname, + loading_package=loading_package, + **kwargs, + ) + + self.auxiliary = self.build_mfdata("auxiliary", auxiliary) + self.auxmultname = self.build_mfdata("auxmultname", auxmultname) + self.print_input = self.build_mfdata("print_input", print_input) + self.print_flows = self.build_mfdata("print_flows", print_flows) + self.save_flows = self.build_mfdata("save_flows", save_flows) + self.auto_flow_reduce = self.build_mfdata("auto_flow_reduce", auto_flow_reduce) + self.afrcsv_filerecord = self.build_mfdata( + "afrcsv_filerecord", afrcsv_filerecord + ) + self.flow_reduction_length = self.build_mfdata( + "flow_reduction_length", flow_reduction_length + ) + self._obs_filerecord = self.build_mfdata("obs_filerecord", None) + self._obs_package = self.build_child_package( + "obs", observations, "continuous", self._obs_filerecord + ) + self.mover = self.build_mfdata("mover", mover) + self.export_array_netcdf = self.build_mfdata( + "export_array_netcdf", export_array_netcdf + ) + self.maxbound = self.build_mfdata("maxbound", maxbound) + self.q = self.build_mfdata("q", q) + self.aux = self.build_mfdata("aux", aux) + + self._init_complete = True diff --git a/flopy/mf6/modflow/mfgwt.py b/flopy/mf6/modflow/mfgwt.py index 5faee07daf..ffea8ab81d 100644 --- a/flopy/mf6/modflow/mfgwt.py +++ b/flopy/mf6/modflow/mfgwt.py @@ -42,6 +42,9 @@ class ModflowGwt(MFModel): save_flows : keyword keyword to indicate that all model package flow terms will be written to the file specified with 'budget fileout' in output control. + dependent_variable_scaling : keyword + flag to scale x and rhs to avoid very large positive or negative dependent + variable values nc_mesh2d_filerecord : record netcdf layered mesh fileout record. nc_structured_filerecord : record @@ -87,6 +90,7 @@ def __init__( print_input=None, print_flows=None, save_flows=None, + dependent_variable_scaling=None, nc_mesh2d_filerecord=None, nc_structured_filerecord=None, nc_filerecord=None, @@ -112,6 +116,8 @@ def __init__( self.print_flows = self.name_file.print_flows self.name_file.save_flows.set_data(save_flows) self.save_flows = self.name_file.save_flows + self.name_file.dependent_variable_scaling.set_data(dependent_variable_scaling) + self.dependent_variable_scaling = self.name_file.dependent_variable_scaling self.name_file.nc_mesh2d_filerecord.set_data(nc_mesh2d_filerecord) self.nc_mesh2d_filerecord = self.name_file.nc_mesh2d_filerecord self.name_file.nc_structured_filerecord.set_data(nc_structured_filerecord) diff --git a/flopy/mf6/modflow/mfgwtadv.py b/flopy/mf6/modflow/mfgwtadv.py index 52ef78ec35..41d1f85d54 100644 --- a/flopy/mf6/modflow/mfgwtadv.py +++ b/flopy/mf6/modflow/mfgwtadv.py @@ -20,8 +20,8 @@ class ModflowGwtadv(MFPackage): Do not set this parameter. It is intended for debugging and internal processing purposes only. scheme : string - scheme used to solve the advection term. can be upstream, central, or tvd. if - not specified, upstream weighting is the default weighting scheme. + scheme used to solve the advection term. can be upstream, central, tvd or + utvd. if not specified, upstream weighting is the default weighting scheme. ats_percel : double precision fractional cell distance submitted by the adv package to the adaptive time stepping (ats) package. if ats_percel is specified and the ats package is @@ -53,7 +53,7 @@ class ModflowGwtadv(MFPackage): "block options", "name scheme", "type string", - "valid central upstream tvd", + "valid central upstream tvd utvd", "reader urword", "optional true", ], diff --git a/flopy/mf6/modflow/mfgwtdis.py b/flopy/mf6/modflow/mfgwtdis.py index 6c08fc0ea8..a32722915f 100644 --- a/flopy/mf6/modflow/mfgwtdis.py +++ b/flopy/mf6/modflow/mfgwtdis.py @@ -49,8 +49,11 @@ class ModflowGwtdis(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. packagedata : record ncf6 filein ncf6_filename Contains data for the ncf package. Data can be passed as a dictionary to the ncf package with variable names as keys and package data as values. Data for @@ -199,7 +202,7 @@ class ModflowGwtdis(MFPackage): "preserve_case true", "reader urword", "optional true", - "prerelease true", + "developmode true", ], [ "block options", diff --git a/flopy/mf6/modflow/mfgwtdisu.py b/flopy/mf6/modflow/mfgwtdisu.py index 6299c7e28c..df4674d08f 100644 --- a/flopy/mf6/modflow/mfgwtdisu.py +++ b/flopy/mf6/modflow/mfgwtdisu.py @@ -290,7 +290,7 @@ class ModflowGwtdisu(MFPackage): "preserve_case true", "reader urword", "optional true", - "prerelease true", + "developmode true", ], [ "block dimensions", diff --git a/flopy/mf6/modflow/mfgwtdisv.py b/flopy/mf6/modflow/mfgwtdisv.py index 62bb4e3943..469999a33e 100644 --- a/flopy/mf6/modflow/mfgwtdisv.py +++ b/flopy/mf6/modflow/mfgwtdisv.py @@ -52,8 +52,11 @@ class ModflowGwtdisv(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. packagedata : record ncf6 filein ncf6_filename Contains data for the ncf package. Data can be passed as a dictionary to the ncf package with variable names as keys and package data as values. Data for @@ -229,7 +232,7 @@ class ModflowGwtdisv(MFPackage): "preserve_case true", "reader urword", "optional true", - "prerelease true", + "developmode true", ], [ "block options", diff --git a/flopy/mf6/modflow/mfgwtdsp.py b/flopy/mf6/modflow/mfgwtdsp.py index 7a223c10ac..d6038c65bb 100644 --- a/flopy/mf6/modflow/mfgwtdsp.py +++ b/flopy/mf6/modflow/mfgwtdsp.py @@ -33,8 +33,11 @@ class ModflowGwtdsp(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. diffc : [double precision] effective molecular diffusion coefficient. alh : [double precision] diff --git a/flopy/mf6/modflow/mfgwtic.py b/flopy/mf6/modflow/mfgwtic.py index fe3c10a899..558f1ed9e2 100644 --- a/flopy/mf6/modflow/mfgwtic.py +++ b/flopy/mf6/modflow/mfgwtic.py @@ -23,8 +23,11 @@ class ModflowGwtic(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. strt : [double precision] is the initial (starting) concentration---that is, concentration at the beginning of the gwt model simulation. strt must be specified for all gwt diff --git a/flopy/mf6/modflow/mfgwtist.py b/flopy/mf6/modflow/mfgwtist.py index 814cb0477e..fe21310334 100644 --- a/flopy/mf6/modflow/mfgwtist.py +++ b/flopy/mf6/modflow/mfgwtist.py @@ -64,8 +64,11 @@ class ModflowGwtist(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. porosity : [double precision] porosity of the immobile domain specified as the immobile domain pore volume per immobile domain volume. diff --git a/flopy/mf6/modflow/mfgwtmst.py b/flopy/mf6/modflow/mfgwtmst.py index dd128f0951..3cbda7b8ec 100644 --- a/flopy/mf6/modflow/mfgwtmst.py +++ b/flopy/mf6/modflow/mfgwtmst.py @@ -46,8 +46,11 @@ class ModflowGwtmst(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. porosity : [double precision] is the mobile domain porosity, defined as the mobile domain pore volume per mobile domain volume. additional information on porosity within the context of diff --git a/flopy/mf6/modflow/mfgwtnam.py b/flopy/mf6/modflow/mfgwtnam.py index e904e92259..52ed9c64e4 100644 --- a/flopy/mf6/modflow/mfgwtnam.py +++ b/flopy/mf6/modflow/mfgwtnam.py @@ -36,6 +36,9 @@ class ModflowGwtnam(MFPackage): save_flows : keyword keyword to indicate that all model package flow terms will be written to the file specified with 'budget fileout' in output control. + dependent_variable_scaling : keyword + flag to scale x and rhs to avoid very large positive or negative dependent + variable values nc_mesh2d_filerecord : (ncmesh2dfile) netcdf layered mesh fileout record. * ncmesh2dfile : string @@ -129,7 +132,6 @@ class ModflowGwtnam(MFPackage): "reader urword", "optional true", "mf6internal idv_scale", - "prerelease true", ], [ "block options", @@ -290,6 +292,7 @@ def __init__( print_input=None, print_flows=None, save_flows=None, + dependent_variable_scaling=None, nc_mesh2d_filerecord=None, nc_structured_filerecord=None, nc_filerecord=None, @@ -312,6 +315,9 @@ def __init__( self.print_input = self.build_mfdata("print_input", print_input) self.print_flows = self.build_mfdata("print_flows", print_flows) self.save_flows = self.build_mfdata("save_flows", save_flows) + self.dependent_variable_scaling = self.build_mfdata( + "dependent_variable_scaling", dependent_variable_scaling + ) self.nc_mesh2d_filerecord = self.build_mfdata( "nc_mesh2d_filerecord", nc_mesh2d_filerecord ) diff --git a/flopy/mf6/modflow/mfgwtoc.py b/flopy/mf6/modflow/mfgwtoc.py index 2fdcba64a6..7137af6639 100644 --- a/flopy/mf6/modflow/mfgwtoc.py +++ b/flopy/mf6/modflow/mfgwtoc.py @@ -92,6 +92,7 @@ class ModflowGwtoc(MFPackage): "reader urword", "tagged true", "optional true", + "mf6internal budfilerec", ], [ "block options", @@ -132,6 +133,7 @@ class ModflowGwtoc(MFPackage): "reader urword", "tagged true", "optional true", + "mf6internal budcsvfilerec", ], [ "block options", @@ -162,6 +164,7 @@ class ModflowGwtoc(MFPackage): "reader urword", "tagged true", "optional true", + "mf6internal concfilerec", ], [ "block options", @@ -183,6 +186,7 @@ class ModflowGwtoc(MFPackage): "reader urword", "tagged false", "optional false", + "mf6internal concfile", ], [ "block options", @@ -191,6 +195,7 @@ class ModflowGwtoc(MFPackage): "shape", "reader urword", "optional true", + "mf6internal concprintrec", ], [ "block options", diff --git a/flopy/mf6/modflow/mfgwtsrc.py b/flopy/mf6/modflow/mfgwtsrc.py index f0d99fbd49..653f2305b3 100644 --- a/flopy/mf6/modflow/mfgwtsrc.py +++ b/flopy/mf6/modflow/mfgwtsrc.py @@ -57,6 +57,20 @@ class ModflowGwtsrc(MFPackage): obs package with variable names as keys and package data as values. Data for the observations variable is also acceptable. See obs package documentation for more information. + highest_saturated : keyword + apply mass source loading rate to specified cellid or highest underlying cell + with a cell saturation greater than zero. the highest_saturated option has an + additional complication for certain types of grids specified using the disu + package. when the disu package is used, a cell may have more than one cell + underlying it. if the overlying cell were to become inactive, there is no + straightforward method for determining how to apportion the mass source loading + rate to the underlying cells. in this case, the approach described by + cite{modflowusg} is used. the mass source loading rate is assigned to the first + active cell encountered (determined by searching through the underlying cell + numbers from the lowest number to the highest number). in this manner, the + total mass source loading rate is conserved; however, the spatial distribution + of the applied mass source loading rate may not be maintained as layers become + dry or wet during a simulation. maxbound : integer integer value specifying the maximum number of sources cells that will be specified for use during any stress period. @@ -235,7 +249,6 @@ class ModflowGwtsrc(MFPackage): "type keyword", "reader urword", "optional true", - "prerelease true", "mf6internal highest_sat", ], [ @@ -320,6 +333,7 @@ def __init__( save_flows=None, timeseries=None, observations=None, + highest_saturated=None, maxbound=None, stress_period_data=None, filename=None, @@ -350,6 +364,9 @@ def __init__( self._obs_package = self.build_child_package( "obs", observations, "continuous", self._obs_filerecord ) + self.highest_saturated = self.build_mfdata( + "highest_saturated", highest_saturated + ) self.maxbound = self.build_mfdata("maxbound", maxbound) self.stress_period_data = self.build_mfdata( "stress_period_data", stress_period_data diff --git a/flopy/mf6/modflow/mfprtdis.py b/flopy/mf6/modflow/mfprtdis.py index dbb915c81e..89ea68f765 100644 --- a/flopy/mf6/modflow/mfprtdis.py +++ b/flopy/mf6/modflow/mfprtdis.py @@ -49,8 +49,11 @@ class ModflowPrtdis(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. packagedata : record ncf6 filein ncf6_filename Contains data for the ncf package. Data can be passed as a dictionary to the ncf package with variable names as keys and package data as values. Data for @@ -198,7 +201,7 @@ class ModflowPrtdis(MFPackage): "preserve_case true", "reader urword", "optional true", - "prerelease true", + "developmode true", ], [ "block options", diff --git a/flopy/mf6/modflow/mfprtdisv.py b/flopy/mf6/modflow/mfprtdisv.py index c9dfeee9bf..6c87de4e28 100644 --- a/flopy/mf6/modflow/mfprtdisv.py +++ b/flopy/mf6/modflow/mfprtdisv.py @@ -50,8 +50,11 @@ class ModflowPrtdisv(MFPackage): keyword that specifies input griddata arrays should be written to layered ascii output files. export_array_netcdf : keyword - keyword that specifies input griddata arrays should be written to the model - output netcdf file. + keyword that specifies input gridded arrays should be written to the model + output netcdf file with attributes that support using the generated file as a + modflow 6 simulation input. this option only has an effect when an output + model netcdf file is configured and the simulation is run in validate mode, + otherwise it is ignored. packagedata : record ncf6 filein ncf6_filename Contains data for the ncf package. Data can be passed as a dictionary to the ncf package with variable names as keys and package data as values. Data for @@ -226,7 +229,7 @@ class ModflowPrtdisv(MFPackage): "preserve_case true", "reader urword", "optional true", - "prerelease true", + "developmode true", ], [ "block options", diff --git a/flopy/mf6/modflow/mfprtoc.py b/flopy/mf6/modflow/mfprtoc.py index bd8c09ce7c..9eb5e9be6a 100644 --- a/flopy/mf6/modflow/mfprtoc.py +++ b/flopy/mf6/modflow/mfprtoc.py @@ -144,6 +144,7 @@ class ModflowPrtoc(MFPackage): "reader urword", "tagged true", "optional true", + "mf6internal budfilerec", ], [ "block options", @@ -184,6 +185,7 @@ class ModflowPrtoc(MFPackage): "reader urword", "tagged true", "optional true", + "mf6internal budcsvfilerec", ], [ "block options", @@ -214,6 +216,7 @@ class ModflowPrtoc(MFPackage): "reader urword", "tagged true", "optional true", + "mf6internal trackfilerec", ], [ "block options", @@ -244,6 +247,7 @@ class ModflowPrtoc(MFPackage): "reader urword", "tagged true", "optional true", + "mf6internal trackcsvfilerec", ], [ "block options", @@ -286,6 +290,7 @@ class ModflowPrtoc(MFPackage): "type keyword", "reader urword", "optional true", + "mf6internal track_subf_exit", ], [ "block options", @@ -330,6 +335,7 @@ class ModflowPrtoc(MFPackage): "reader urword", "tagged true", "optional true", + "mf6internal ttimesrec", "removed 6.6.0", ], [ @@ -361,6 +367,7 @@ class ModflowPrtoc(MFPackage): "reader urword", "tagged true", "optional true", + "mf6internal ttimesfilerec", "removed 6.6.0", ], [ @@ -391,13 +398,14 @@ class ModflowPrtoc(MFPackage): "type keyword", "reader urword", "optional true", + "mf6internal dev_dump_evtrace", ], [ "block dimensions", "name ntracktimes", "type integer", "reader urword", - "optional false", + "optional true", ], [ "block tracktimes", @@ -405,6 +413,7 @@ class ModflowPrtoc(MFPackage): "type recarray time", "shape (ntracktimes)", "reader urword", + "optional true", ], [ "block tracktimes", @@ -414,6 +423,7 @@ class ModflowPrtoc(MFPackage): "tagged false", "in_record true", "reader urword", + "optional false", ], [ "block period", diff --git a/flopy/mf6/modflow/mfprtprp.py b/flopy/mf6/modflow/mfprtprp.py index 0eb872a560..410b770025 100644 --- a/flopy/mf6/modflow/mfprtprp.py +++ b/flopy/mf6/modflow/mfprtprp.py @@ -31,15 +31,19 @@ class ModflowPrtprp(MFPackage): is brent's method. exit_solve_tolerance : double precision the convergence tolerance for iterative solution of particle exit location and - time in the generalized pollock's method. a value of 0.00001 works well for - many problems, but the value that strikes the best balance between accuracy and - runtime is problem-dependent. + time in the generalized pollock's method. the variable being solved for varies + from 0 to 1. a tolerance of 0.00001 works well for many problems, but the + value that strikes the best balance between accuracy and runtime is problem- + dependent. local_z : keyword indicates that 'zrpt' defines the local z coordinate of the release point - within the cell, with value of 0 at the bottom and 1 at the top of the cell. - if the cell is partially saturated at release time, the top of the cell is - considered to be the water table elevation (the head in the cell) rather than - the top defined by the user. + within the cell, with value of 0 at the bottom and 1 at the effective top of + the cell. if the cell is convertible and partially saturated at release time, + the effective top of the cell is considered to be the water table elevation + (the head in the cell) rather than the top defined by the user, and is + constrained to be no higher than the geometric top of the cell and no lower + than the cell bottom. if the cell is confined, the effective top is the + geometric top. extend_tracking : keyword indicates that particles should be tracked beyond the end of the simulation's final time step (using that time step's flows) until particles terminate or @@ -91,6 +95,9 @@ class ModflowPrtprp(MFPackage): that happens to be inactive at release time, the particle is to be moved to the topmost active cell below it, if any. by default, a particle is not released into the simulation if its release point's cell is inactive at release time. + note that drape does not apply to attempted release into a cell for which + idomain <= 0, which is considered not to exist in the simulation. attempted + release into a such a cell results in an error. release_timesrecord : (release_times, times) * release_times : keyword keyword indicating release times will follow @@ -124,6 +131,10 @@ class ModflowPrtprp(MFPackage): releasesetting selections. if none of these are provided, a single release time is configured at the beginning of the first time step of the simulation's first stress period. + coordinate_check_method : string + approach for verifying that release point coordinates are in the cell with the + specified id. possible values are none and eager. by default, release point + coordinates are checked at release time, i.e. eager. dev_cycle_detection_window : integer integer value defining the size of the window (number of consecutive exit events) used for cycle detection. defaults to 0, disabling cycle detection. @@ -505,7 +516,6 @@ class ModflowPrtprp(MFPackage): "valid none eager", "reader urword", "optional true", - "prerelease true", "mf6internal ichkmeth", "default eager", ], @@ -717,6 +727,7 @@ def __init__( dev_forceternary=None, release_time_tolerance=None, release_time_frequency=None, + coordinate_check_method="eager", dev_cycle_detection_window=None, nreleasepts=None, nreleasetimes=None, @@ -774,6 +785,9 @@ def __init__( self.release_time_frequency = self.build_mfdata( "release_time_frequency", release_time_frequency ) + self.coordinate_check_method = self.build_mfdata( + "coordinate_check_method", coordinate_check_method + ) self.dev_cycle_detection_window = self.build_mfdata( "dev_cycle_detection_window", dev_cycle_detection_window ) diff --git a/flopy/mf6/modflow/mfutlats.py b/flopy/mf6/modflow/mfutlats.py index 7b3c047958..2ee5359ee7 100644 --- a/flopy/mf6/modflow/mfutlats.py +++ b/flopy/mf6/modflow/mfutlats.py @@ -24,9 +24,11 @@ class ModflowUtlats(MFPackage): for adaptive time stepping. perioddata : [(iperats, dt0, dtmin, dtmax, dtadj, dtfailadj)] * iperats : integer - is the period number to designate for adaptive time stepping. The remaining - ATS values on this line will apply to period iperats. iperats must be greater - than zero. A warning is printed if iperats is greater than nper. + is the period number to apply the adaptive time stepping. Adaptive time + stepping is only activated for those periods with a corresponding iperats entry + in the perioddata block. The remaining ATS values on this line will apply to + period iperats. iperats must be greater than zero. A warning is printed if + iperats is greater than nper. * dt0 : double precision is the initial time step length for period iperats. If dt0 is zero, then the final step from the previous stress period will be used as the initial time diff --git a/flopy/mf6/utils/codegen/filters.py b/flopy/mf6/utils/codegen/filters.py index 783e09a4d7..3d4ee82a4c 100644 --- a/flopy/mf6/utils/codegen/filters.py +++ b/flopy/mf6/utils/codegen/filters.py @@ -359,9 +359,8 @@ def _filter_metadata(metadata): meta_.append(" ".join(s)) return meta_ - dfn_copy = dfn.copy() - legacy_dfn = dfn_copy.pop("legacy_dfn", {}) - legacy_meta = dfn_copy.pop("legacy_meta", []) + legacy_dfn = dfn.get("legacy_dfn", {}) + legacy_meta = dfn.get("legacy_meta", []) legacy_dfn = _dfn(legacy_dfn, _filter_metadata(legacy_meta)) if component_base == "MFPackage": attrs.extend( @@ -370,7 +369,6 @@ def _filter_metadata(metadata): f"_package_type = '{component_name[1]}'", f"dfn_file_name = '{dfn_file_name(component_name)}'", f"dfn = {pformat(legacy_dfn, indent=10, width=sys.maxsize)}", - f"spec = {pformat(dfn_copy, indent=10, width=sys.maxsize)}", ] ) diff --git a/tach.toml b/tach.toml index f23dddcc92..3fbd2aa001 100644 --- a/tach.toml +++ b/tach.toml @@ -1,13 +1,13 @@ +interfaces = [] exclude = [ - ".*__pycache__", - ".*egg-info", + "**/*__pycache__", + "**/*egg-info", "autotest", "docs", ] source_roots = [ ".", ] -root_module = "ignore" [[modules]] path = "flopy.datbase" @@ -16,11 +16,11 @@ depends_on = [] [[modules]] path = "flopy.discretization.grid" depends_on = [ - { path = "flopy.export.shapefile_utils" }, - { path = "flopy.utils.crs" }, - { path = "flopy.utils.geometry" }, - { path = "flopy.utils.geospatial_utils" }, - { path = "flopy.utils.gridutil" }, + "flopy.export.shapefile_utils", + "flopy.utils.crs", + "flopy.utils.geometry", + "flopy.utils.geospatial_utils", + "flopy.utils.gridutil", ] [[modules]] @@ -30,25 +30,25 @@ depends_on = [] [[modules]] path = "flopy.discretization.structuredgrid" depends_on = [ - { path = "flopy.discretization.grid" }, - { path = "flopy.mf6.utils.binarygrid_util" }, + "flopy.discretization.grid", + "flopy.mf6.utils.binarygrid_util", ] [[modules]] path = "flopy.discretization.unstructuredgrid" depends_on = [ - { path = "flopy.discretization.grid" }, - { path = "flopy.mf6.utils.binarygrid_util" }, - { path = "flopy.utils.geometry" }, - { path = "flopy.utils.gridgen" }, + "flopy.discretization.grid", + "flopy.mf6.utils.binarygrid_util", + "flopy.utils.geometry", + "flopy.utils.gridgen", ] [[modules]] path = "flopy.discretization.vertexgrid" depends_on = [ - { path = "flopy.discretization.grid" }, - { path = "flopy.mf6.utils.binarygrid_util" }, - { path = "flopy.utils.geometry" }, + "flopy.discretization.grid", + "flopy.mf6.utils.binarygrid_util", + "flopy.utils.geometry", ] [[modules]] @@ -58,26 +58,26 @@ depends_on = [] [[modules]] path = "flopy.export.metadata" depends_on = [ - { path = "flopy.utils.flopy_io" }, + "flopy.utils.flopy_io", ] [[modules]] path = "flopy.export.netcdf" depends_on = [ - { path = "flopy.export.longnames" }, - { path = "flopy.export.metadata" }, - { path = "flopy.utils.crs" }, - { path = "flopy.utils.parse_version" }, + "flopy.export.longnames", + "flopy.export.metadata", + "flopy.utils.crs", + "flopy.utils.parse_version", ] [[modules]] path = "flopy.export.shapefile_utils" depends_on = [ - { path = "flopy.datbase" }, - { path = "flopy.discretization.grid" }, - { path = "flopy.utils.crs" }, - { path = "flopy.utils.flopy_io" }, - { path = "flopy.utils.geospatial_utils" }, + "flopy.datbase", + "flopy.discretization.grid", + "flopy.utils.crs", + "flopy.utils.flopy_io", + "flopy.utils.geospatial_utils", ] [[modules]] @@ -87,166 +87,166 @@ depends_on = [] [[modules]] path = "flopy.export.utils" depends_on = [ - { path = "flopy.datbase" }, - { path = "flopy.export.longnames" }, - { path = "flopy.export.netcdf" }, - { path = "flopy.export.shapefile_utils" }, - { path = "flopy.export.unitsformat" }, - { path = "flopy.export.vtk" }, - { path = "flopy.mbase" }, - { path = "flopy.pakbase" }, - { path = "flopy.utils.crs" }, - { path = "flopy.utils.flopy_io" }, - { path = "flopy.utils.geometry" }, + "flopy.datbase", + "flopy.export.longnames", + "flopy.export.netcdf", + "flopy.export.shapefile_utils", + "flopy.export.unitsformat", + "flopy.export.vtk", + "flopy.mbase", + "flopy.pakbase", + "flopy.utils.crs", + "flopy.utils.flopy_io", + "flopy.utils.geometry", ] [[modules]] path = "flopy.export.vtk" depends_on = [ - { path = "flopy.datbase" }, + "flopy.datbase", ] [[modules]] path = "flopy.mbase" depends_on = [ - { path = "flopy.discretization.grid" }, - { path = "flopy.export.utils" }, - { path = "flopy.utils.flopy_io" }, + "flopy.discretization.grid", + "flopy.export.utils", + "flopy.utils.flopy_io", ] [[modules]] path = "flopy.mf6.coordinates.modeldimensions" depends_on = [ - { path = "flopy.mf6.coordinates.modelgrid" }, - { path = "flopy.mf6.coordinates.simulationtime" }, - { path = "flopy.mf6.data.mfstructure" }, - { path = "flopy.mf6.mfbase" }, - { path = "flopy.mf6.utils.mfenums" }, - { path = "flopy.utils.datautil" }, + "flopy.mf6.coordinates.modelgrid", + "flopy.mf6.coordinates.simulationtime", + "flopy.mf6.data.mfstructure", + "flopy.mf6.mfbase", + "flopy.mf6.utils.mfenums", + "flopy.utils.datautil", ] [[modules]] path = "flopy.mf6.coordinates.modelgrid" depends_on = [ - { path = "flopy.mf6.data.mfstructure" }, - { path = "flopy.mf6.utils.mfenums" }, + "flopy.mf6.data.mfstructure", + "flopy.mf6.utils.mfenums", ] [[modules]] path = "flopy.mf6.coordinates.simulationtime" depends_on = [ - { path = "flopy.mf6.mfbase" }, + "flopy.mf6.mfbase", ] [[modules]] path = "flopy.mf6.data.mfdata" depends_on = [ - { path = "flopy.datbase" }, - { path = "flopy.export.utils" }, - { path = "flopy.mbase" }, - { path = "flopy.mf6.coordinates.modeldimensions" }, - { path = "flopy.mf6.data.mfdatastorage" }, - { path = "flopy.mf6.data.mfdatautil" }, - { path = "flopy.mf6.data.mfstructure" }, - { path = "flopy.mf6.mfbase" }, - { path = "flopy.utils.datautil" }, + "flopy.datbase", + "flopy.export.utils", + "flopy.mbase", + "flopy.mf6.coordinates.modeldimensions", + "flopy.mf6.data.mfdatastorage", + "flopy.mf6.data.mfdatautil", + "flopy.mf6.data.mfstructure", + "flopy.mf6.mfbase", + "flopy.utils.datautil", ] [[modules]] path = "flopy.mf6.data.mfdataarray" depends_on = [ - { path = "flopy.datbase" }, - { path = "flopy.mf6.data.mfdata" }, - { path = "flopy.mf6.data.mfdatastorage" }, - { path = "flopy.mf6.data.mffileaccess" }, - { path = "flopy.mf6.data.mfstructure" }, - { path = "flopy.mf6.mfbase" }, - { path = "flopy.mf6.utils.mfenums" }, - { path = "flopy.plot.plotutil" }, - { path = "flopy.utils.datautil" }, + "flopy.datbase", + "flopy.mf6.data.mfdata", + "flopy.mf6.data.mfdatastorage", + "flopy.mf6.data.mffileaccess", + "flopy.mf6.data.mfstructure", + "flopy.mf6.mfbase", + "flopy.mf6.utils.mfenums", + "flopy.plot.plotutil", + "flopy.utils.datautil", ] [[modules]] path = "flopy.mf6.data.mfdatalist" depends_on = [ - { path = "flopy.datbase" }, - { path = "flopy.mbase" }, - { path = "flopy.mf6.data.mfdata" }, - { path = "flopy.mf6.data.mfdatastorage" }, - { path = "flopy.mf6.data.mfdatautil" }, - { path = "flopy.mf6.data.mffileaccess" }, - { path = "flopy.mf6.data.mfstructure" }, - { path = "flopy.mf6.mfbase" }, - { path = "flopy.mf6.utils.mfenums" }, - { path = "flopy.utils.datautil" }, + "flopy.datbase", + "flopy.mbase", + "flopy.mf6.data.mfdata", + "flopy.mf6.data.mfdatastorage", + "flopy.mf6.data.mfdatautil", + "flopy.mf6.data.mffileaccess", + "flopy.mf6.data.mfstructure", + "flopy.mf6.mfbase", + "flopy.mf6.utils.mfenums", + "flopy.utils.datautil", ] [[modules]] path = "flopy.mf6.data.mfdataplist" depends_on = [ - { path = "flopy.datbase" }, - { path = "flopy.discretization.structuredgrid" }, - { path = "flopy.discretization.unstructuredgrid" }, - { path = "flopy.discretization.vertexgrid" }, - { path = "flopy.mf6.data.mfdata" }, - { path = "flopy.mf6.data.mfdatalist" }, - { path = "flopy.mf6.data.mfdatastorage" }, - { path = "flopy.mf6.data.mfdatautil" }, - { path = "flopy.mf6.data.mffileaccess" }, - { path = "flopy.mf6.data.mfstructure" }, - { path = "flopy.mf6.mfbase" }, - { path = "flopy.mf6.utils.mfenums" }, - { path = "flopy.utils.datautil" }, + "flopy.datbase", + "flopy.discretization.structuredgrid", + "flopy.discretization.unstructuredgrid", + "flopy.discretization.vertexgrid", + "flopy.mf6.data.mfdata", + "flopy.mf6.data.mfdatalist", + "flopy.mf6.data.mfdatastorage", + "flopy.mf6.data.mfdatautil", + "flopy.mf6.data.mffileaccess", + "flopy.mf6.data.mfstructure", + "flopy.mf6.mfbase", + "flopy.mf6.utils.mfenums", + "flopy.utils.datautil", ] [[modules]] path = "flopy.mf6.data.mfdatascalar" depends_on = [ - { path = "flopy.datbase" }, - { path = "flopy.mf6.data.mfdata" }, - { path = "flopy.mf6.data.mfdatastorage" }, - { path = "flopy.mf6.data.mfdatautil" }, - { path = "flopy.mf6.data.mffileaccess" }, - { path = "flopy.mf6.data.mfstructure" }, - { path = "flopy.mf6.mfbase" }, - { path = "flopy.plot.plotutil" }, - { path = "flopy.utils.datautil" }, + "flopy.datbase", + "flopy.mf6.data.mfdata", + "flopy.mf6.data.mfdatastorage", + "flopy.mf6.data.mfdatautil", + "flopy.mf6.data.mffileaccess", + "flopy.mf6.data.mfstructure", + "flopy.mf6.mfbase", + "flopy.plot.plotutil", + "flopy.utils.datautil", ] [[modules]] path = "flopy.mf6.data.mfdatastorage" depends_on = [ - { path = "flopy.mf6.data.mfdatautil" }, - { path = "flopy.mf6.data.mffileaccess" }, - { path = "flopy.mf6.data.mfstructure" }, - { path = "flopy.mf6.mfbase" }, - { path = "flopy.utils.datautil" }, + "flopy.mf6.data.mfdatautil", + "flopy.mf6.data.mffileaccess", + "flopy.mf6.data.mfstructure", + "flopy.mf6.mfbase", + "flopy.utils.datautil", ] [[modules]] path = "flopy.mf6.data.mfdatautil" depends_on = [ - { path = "flopy.mf6.coordinates.modeldimensions" }, - { path = "flopy.mf6.data.mfdatastorage" }, - { path = "flopy.mf6.data.mfstructure" }, - { path = "flopy.mf6.mfbase" }, - { path = "flopy.utils.datautil" }, + "flopy.mf6.coordinates.modeldimensions", + "flopy.mf6.data.mfdatastorage", + "flopy.mf6.data.mfstructure", + "flopy.mf6.mfbase", + "flopy.utils.datautil", ] [[modules]] path = "flopy.mf6.data.mffileaccess" depends_on = [ - { path = "flopy.mf6.data.mfdatautil" }, - { path = "flopy.mf6.data.mfstructure" }, - { path = "flopy.mf6.mfbase" }, - { path = "flopy.utils.binaryfile" }, - { path = "flopy.utils.datautil" }, + "flopy.mf6.data.mfdatautil", + "flopy.mf6.data.mfstructure", + "flopy.mf6.mfbase", + "flopy.utils.binaryfile", + "flopy.utils.datautil", ] [[modules]] path = "flopy.mf6.data.mfstructure" depends_on = [ - { path = "flopy.mf6.mfbase" }, + "flopy.mf6.mfbase", ] [[modules]] @@ -256,95 +256,95 @@ depends_on = [] [[modules]] path = "flopy.mf6.mfmodel" depends_on = [ - { path = "flopy.discretization.grid" }, - { path = "flopy.discretization.modeltime" }, - { path = "flopy.discretization.structuredgrid" }, - { path = "flopy.discretization.unstructuredgrid" }, - { path = "flopy.discretization.vertexgrid" }, - { path = "flopy.export.utils" }, - { path = "flopy.mbase" }, - { path = "flopy.mf6.coordinates.modeldimensions" }, - { path = "flopy.mf6.data.mfdata" }, - { path = "flopy.mf6.data.mfdatalist" }, - { path = "flopy.mf6.data.mfdatautil" }, - { path = "flopy.mf6.data.mfstructure" }, - { path = "flopy.mf6.mfbase" }, - { path = "flopy.mf6.mfpackage" }, - { path = "flopy.mf6.utils.mfenums" }, - { path = "flopy.mf6.utils.output_util" }, - { path = "flopy.plot.plotutil" }, - { path = "flopy.utils.check" }, - { path = "flopy.utils.datautil" }, + "flopy.discretization.grid", + "flopy.discretization.modeltime", + "flopy.discretization.structuredgrid", + "flopy.discretization.unstructuredgrid", + "flopy.discretization.vertexgrid", + "flopy.export.utils", + "flopy.mbase", + "flopy.mf6.coordinates.modeldimensions", + "flopy.mf6.data.mfdata", + "flopy.mf6.data.mfdatalist", + "flopy.mf6.data.mfdatautil", + "flopy.mf6.data.mfstructure", + "flopy.mf6.mfbase", + "flopy.mf6.mfpackage", + "flopy.mf6.utils.mfenums", + "flopy.mf6.utils.output_util", + "flopy.plot.plotutil", + "flopy.utils.check", + "flopy.utils.datautil", ] [[modules]] path = "flopy.mf6.mfpackage" depends_on = [ - { path = "flopy.mbase" }, - { path = "flopy.mf6.coordinates.modeldimensions" }, - { path = "flopy.mf6.data.mfdata" }, - { path = "flopy.mf6.data.mfdataarray" }, - { path = "flopy.mf6.data.mfdatalist" }, - { path = "flopy.mf6.data.mfdataplist" }, - { path = "flopy.mf6.data.mfdatascalar" }, - { path = "flopy.mf6.data.mfdatautil" }, - { path = "flopy.mf6.data.mfstructure" }, - { path = "flopy.mf6.mfbase" }, - { path = "flopy.mf6.utils.output_util" }, - { path = "flopy.pakbase" }, - { path = "flopy.plot.plotutil" }, - { path = "flopy.utils.check" }, - { path = "flopy.utils.datautil" }, + "flopy.mbase", + "flopy.mf6.coordinates.modeldimensions", + "flopy.mf6.data.mfdata", + "flopy.mf6.data.mfdataarray", + "flopy.mf6.data.mfdatalist", + "flopy.mf6.data.mfdataplist", + "flopy.mf6.data.mfdatascalar", + "flopy.mf6.data.mfdatautil", + "flopy.mf6.data.mfstructure", + "flopy.mf6.mfbase", + "flopy.mf6.utils.output_util", + "flopy.pakbase", + "flopy.plot.plotutil", + "flopy.utils.check", + "flopy.utils.datautil", ] [[modules]] path = "flopy.mf6.mfsimbase" depends_on = [ - { path = "flopy.mbase" }, - { path = "flopy.mf6.data.mfdata" }, - { path = "flopy.mf6.data.mfdatalist" }, - { path = "flopy.mf6.data.mfdatautil" }, - { path = "flopy.mf6.data.mfstructure" }, - { path = "flopy.mf6.mfbase" }, - { path = "flopy.mf6.mfmodel" }, - { path = "flopy.mf6.mfpackage" }, - { path = "flopy.mf6.utils.binaryfile_utils" }, - { path = "flopy.mf6.utils.mfobservation" }, + "flopy.mbase", + "flopy.mf6.data.mfdata", + "flopy.mf6.data.mfdatalist", + "flopy.mf6.data.mfdatautil", + "flopy.mf6.data.mfstructure", + "flopy.mf6.mfbase", + "flopy.mf6.mfmodel", + "flopy.mf6.mfpackage", + "flopy.mf6.utils.binaryfile_utils", + "flopy.mf6.utils.mfobservation", ] [[modules]] path = "flopy.mf6.modflow.mfgwe" depends_on = [ - { path = "flopy.mf6.data.mfdatautil" }, - { path = "flopy.mf6.mfmodel" }, + "flopy.mf6.data.mfdatautil", + "flopy.mf6.mfmodel", ] [[modules]] path = "flopy.mf6.modflow.mfgwedisu" depends_on = [ - { path = "flopy.mf6.data.mfdatautil" }, - { path = "flopy.mf6.mfpackage" }, + "flopy.mf6.data.mfdatautil", + "flopy.mf6.mfpackage", ] [[modules]] path = "flopy.mf6.modflow.mfsimulation" depends_on = [ - { path = "flopy.mf6.mfsimbase" }, + "flopy.mf6.mfsimbase", ] [[modules]] path = "flopy.mf6.utils.binaryfile_utils" depends_on = [ - { path = "flopy.utils.binaryfile" }, + "flopy.utils.binaryfile", ] [[modules]] path = "flopy.mf6.utils.binarygrid_util" depends_on = [ - { path = "flopy.discretization.structuredgrid" }, - { path = "flopy.discretization.unstructuredgrid" }, - { path = "flopy.discretization.vertexgrid" }, - { path = "flopy.utils.utils_def" }, + "flopy.discretization.structuredgrid", + "flopy.discretization.unstructuredgrid", + "flopy.discretization.vertexgrid", + "flopy.utils.utils_def", ] [[modules]] @@ -373,26 +373,26 @@ depends_on = [] [[modules]] path = "flopy.mf6.utils.model_splitter" depends_on = [ - { path = "flopy.mf6.data.mfdataarray" }, - { path = "flopy.mf6.data.mfdatalist" }, - { path = "flopy.mf6.data.mfdataplist" }, - { path = "flopy.mf6.data.mfdatascalar" }, - { path = "flopy.mf6.mfbase" }, - { path = "flopy.plot.plotutil" }, + "flopy.mf6.data.mfdataarray", + "flopy.mf6.data.mfdatalist", + "flopy.mf6.data.mfdataplist", + "flopy.mf6.data.mfdatascalar", + "flopy.mf6.mfbase", + "flopy.plot.plotutil", ] [[modules]] path = "flopy.mf6.utils.output_util" depends_on = [ - { path = "flopy.mbase" }, - { path = "flopy.pakbase" }, - { path = "flopy.utils.observationfile" }, + "flopy.mbase", + "flopy.pakbase", + "flopy.utils.observationfile", ] [[modules]] path = "flopy.mf6.utils.postprocessing" depends_on = [ - { path = "flopy.mf6.utils.binarygrid_util" }, + "flopy.mf6.utils.binarygrid_util", ] [[modules]] @@ -402,29 +402,29 @@ depends_on = [] [[modules]] path = "flopy.mf6.utils.testutils" depends_on = [ - { path = "flopy.utils.datautil" }, + "flopy.utils.datautil", ] [[modules]] path = "flopy.pakbase" depends_on = [ - { path = "flopy.utils.check" }, - { path = "flopy.utils.flopy_io" }, + "flopy.utils.check", + "flopy.utils.flopy_io", ] [[modules]] path = "flopy.plot.crosssection" depends_on = [ - { path = "flopy.plot.plotutil" }, - { path = "flopy.utils.geometry" }, - { path = "flopy.utils.geospatial_utils" }, + "flopy.plot.plotutil", + "flopy.utils.geometry", + "flopy.utils.geospatial_utils", ] [[modules]] path = "flopy.plot.map" depends_on = [ - { path = "flopy.plot.plotutil" }, - { path = "flopy.utils.geometry" }, + "flopy.plot.plotutil", + "flopy.utils.geometry", ] [[modules]] @@ -434,11 +434,11 @@ depends_on = [] [[modules]] path = "flopy.plot.plotutil" depends_on = [ - { path = "flopy.datbase" }, - { path = "flopy.plot.map" }, - { path = "flopy.utils.geometry" }, - { path = "flopy.utils.geospatial_utils" }, - { path = "flopy.utils.particletrackfile" }, + "flopy.datbase", + "flopy.plot.map", + "flopy.utils.geometry", + "flopy.utils.geospatial_utils", + "flopy.utils.particletrackfile", ] [[modules]] @@ -448,22 +448,22 @@ depends_on = [] [[modules]] path = "flopy.utils.binaryfile" depends_on = [ - { path = "flopy.utils.datafile" }, - { path = "flopy.utils.gridutil" }, + "flopy.utils.datafile", + "flopy.utils.gridutil", ] [[modules]] path = "flopy.utils.check" depends_on = [ - { path = "flopy.utils.flopy_io" }, - { path = "flopy.utils.recarray_utils" }, - { path = "flopy.utils.util_array" }, + "flopy.utils.flopy_io", + "flopy.utils.recarray_utils", + "flopy.utils.util_array", ] [[modules]] path = "flopy.utils.compare" depends_on = [ - { path = "flopy.utils.mfreadnam" }, + "flopy.utils.mfreadnam", ] [[modules]] @@ -473,15 +473,15 @@ depends_on = [] [[modules]] path = "flopy.utils.cvfdutil" depends_on = [ - { path = "flopy.utils.utl_import" }, + "flopy.utils.utl_import", ] [[modules]] path = "flopy.utils.datafile" depends_on = [ - { path = "flopy.discretization.structuredgrid" }, - { path = "flopy.export.shapefile_utils" }, - { path = "flopy.plot.plotutil" }, + "flopy.discretization.structuredgrid", + "flopy.export.shapefile_utils", + "flopy.plot.plotutil", ] [[modules]] @@ -491,25 +491,25 @@ depends_on = [] [[modules]] path = "flopy.utils.flopy_io" depends_on = [ - { path = "flopy.utils.util_list" }, + "flopy.utils.util_list", ] [[modules]] path = "flopy.utils.formattedfile" depends_on = [ - { path = "flopy.utils.datafile" }, + "flopy.utils.datafile", ] [[modules]] path = "flopy.utils.geometry" depends_on = [ - { path = "flopy.utils.geospatial_utils" }, + "flopy.utils.geospatial_utils", ] [[modules]] path = "flopy.utils.geospatial_utils" depends_on = [ - { path = "flopy.utils.geometry" }, + "flopy.utils.geometry", ] [[modules]] @@ -519,41 +519,41 @@ depends_on = [] [[modules]] path = "flopy.utils.gridgen" depends_on = [ - { path = "flopy.export.shapefile_utils" }, - { path = "flopy.mbase" }, - { path = "flopy.utils.cvfdutil" }, - { path = "flopy.utils.flopy_io" }, - { path = "flopy.utils.geospatial_utils" }, - { path = "flopy.utils.util_array" }, + "flopy.export.shapefile_utils", + "flopy.mbase", + "flopy.utils.cvfdutil", + "flopy.utils.flopy_io", + "flopy.utils.geospatial_utils", + "flopy.utils.util_array", ] [[modules]] path = "flopy.utils.gridintersect" depends_on = [ - { path = "flopy.utils.geometry" }, - { path = "flopy.utils.geospatial_utils" }, - { path = "flopy.utils.utl_import" }, + "flopy.utils.geometry", + "flopy.utils.geospatial_utils", + "flopy.utils.utl_import", ] [[modules]] path = "flopy.utils.gridutil" depends_on = [ - { path = "flopy.utils.cvfdutil" }, + "flopy.utils.cvfdutil", ] [[modules]] path = "flopy.utils.lgrutil" depends_on = [ - { path = "flopy.utils.cvfdutil" }, - { path = "flopy.utils.util_array" }, + "flopy.utils.cvfdutil", + "flopy.utils.util_array", ] [[modules]] path = "flopy.utils.mflistfile" depends_on = [ - { path = "flopy.utils.flopy_io" }, - { path = "flopy.utils.observationfile" }, - { path = "flopy.utils.utils_def" }, + "flopy.utils.flopy_io", + "flopy.utils.observationfile", + "flopy.utils.utils_def", ] [[modules]] @@ -563,10 +563,10 @@ depends_on = [] [[modules]] path = "flopy.utils.modpathfile" depends_on = [ - { path = "flopy.export.shapefile_utils" }, - { path = "flopy.utils.flopy_io" }, - { path = "flopy.utils.geometry" }, - { path = "flopy.utils.particletrackfile" }, + "flopy.export.shapefile_utils", + "flopy.utils.flopy_io", + "flopy.utils.geometry", + "flopy.utils.particletrackfile", ] [[modules]] @@ -576,14 +576,14 @@ depends_on = [] [[modules]] path = "flopy.utils.observationfile" depends_on = [ - { path = "flopy.utils.flopy_io" }, - { path = "flopy.utils.utils_def" }, + "flopy.utils.flopy_io", + "flopy.utils.utils_def", ] [[modules]] path = "flopy.utils.optionblock" depends_on = [ - { path = "flopy.utils.flopy_io" }, + "flopy.utils.flopy_io", ] [[modules]] @@ -593,23 +593,23 @@ depends_on = [] [[modules]] path = "flopy.utils.particletrackfile" depends_on = [ - { path = "flopy.export.shapefile_utils" }, - { path = "flopy.utils.geometry" }, + "flopy.export.shapefile_utils", + "flopy.utils.geometry", ] [[modules]] path = "flopy.utils.postprocessing" depends_on = [ - { path = "flopy.utils.binaryfile" }, - { path = "flopy.utils.formattedfile" }, + "flopy.utils.binaryfile", + "flopy.utils.formattedfile", ] [[modules]] path = "flopy.utils.rasters" depends_on = [ - { path = "flopy.utils.geometry" }, - { path = "flopy.utils.geospatial_utils" }, - { path = "flopy.utils.utl_import" }, + "flopy.utils.geometry", + "flopy.utils.geospatial_utils", + "flopy.utils.utl_import", ] [[modules]] @@ -627,30 +627,30 @@ depends_on = [] [[modules]] path = "flopy.utils.swroutputfile" depends_on = [ - { path = "flopy.utils.utils_def" }, + "flopy.utils.utils_def", ] [[modules]] path = "flopy.utils.triangle" depends_on = [ - { path = "flopy.mbase" }, - { path = "flopy.utils.cvfdutil" }, - { path = "flopy.utils.geospatial_utils" }, + "flopy.mbase", + "flopy.utils.cvfdutil", + "flopy.utils.geospatial_utils", ] [[modules]] path = "flopy.utils.util_array" depends_on = [ - { path = "flopy.datbase" }, - { path = "flopy.utils.binaryfile" }, - { path = "flopy.utils.flopy_io" }, + "flopy.datbase", + "flopy.utils.binaryfile", + "flopy.utils.flopy_io", ] [[modules]] path = "flopy.utils.util_list" depends_on = [ - { path = "flopy.datbase" }, - { path = "flopy.utils.recarray_utils" }, + "flopy.datbase", + "flopy.utils.recarray_utils", ] [[modules]] @@ -660,24 +660,24 @@ depends_on = [] [[modules]] path = "flopy.utils.utl_import" depends_on = [ - { path = "flopy.utils.parse_version" }, + "flopy.utils.parse_version", ] [[modules]] path = "flopy.utils.voronoi" depends_on = [ - { path = "flopy.utils.cvfdutil" }, - { path = "flopy.utils.geometry" }, - { path = "flopy.utils.triangle" }, - { path = "flopy.utils.utl_import" }, + "flopy.utils.cvfdutil", + "flopy.utils.geometry", + "flopy.utils.triangle", + "flopy.utils.utl_import", ] [[modules]] path = "flopy.utils.zonbud" depends_on = [ - { path = "flopy.export.utils" }, - { path = "flopy.mbase" }, - { path = "flopy.utils.binaryfile" }, - { path = "flopy.utils.flopy_io" }, - { path = "flopy.utils.utils_def" }, + "flopy.export.utils", + "flopy.mbase", + "flopy.utils.binaryfile", + "flopy.utils.flopy_io", + "flopy.utils.utils_def", ]