.. _ParFlow Input Keys: ParFlow Input Keys ================== The basic idea behind ParFlow input is a simple database of keys. The database contains entries which have a key and a value associated with that key. When ParFlow runs, it queries the database you have created by key names to get the values you have specified. The commands ``run.Key=`` in Python or pfset in TCL are used to create the database entries. A simple ParFlow input script contains a long list of these commands that set key values. Note that the ``run`` is the name a user gives to their run, and is a unique identifier to organize the key database and to anchor the files ParFlow writes. It should be noted that the keys are “dynamic” in that many are built up from values of other keys. For example if you have two wells named *northwell* and *southwell* then you will have to set some keys which specify the parameters for each well. The keys are built up in a simple sort of hierarchy. The following sections contain a description of all of the keys used by ParFlow. For an example of input files you can look at the ``test`` subdirectory of the ParFlow distribution. Looking over some examples should give you a good feel for how the file scripts are put together. Each key entry has the form: *type* **KeyName** default value Description The “type” is one of integer, double, string, list. Integer and double are IEEE numbers. String is a text string (for example, a filename). Strings can contain spaces if you use the proper python syntax (i.e. using double quotes). Lists are strings but they indicate the names of a series of items. For example you might need to specify the names of the geometries. You would do this using space separated names (what we are calling a list) “layer1 layer2 layer3”. The descriptions that follow are organized into functional areas. An example for each database entry is given. Note that units used for each physical quantity specified in the input file must be consistent with units used for all other quantities. The exact units used can be any consistent set as ParFlow does not assume any specific set of units. However, it is up to the user to make sure all specifications are indeed consistent. .. _Input File Format Number: Input File Format Number ~~~~~~~~~~~~~~~~~~~~~~~~ *integer* **FileVersion** no default This gives the value of the input file version number that this file fits. .. container:: list :: import parflow # Python syntax run = parflow.Run("test_run", __file__) run.FileVersion = 4 pfset FileVersion 4 # TCL syntax As development of the ParFlow code continues, the input file format will vary. We have thus included an input file format number as a way of verifying that the correct format type is being used. The user can check in the ``parflow/pfsimulator/parflow_lib/file_versions.h`` file to verify that the format number specified in the input file matches the defined value of ``PFIN_VERSION``. .. _Computing Topology: Computing Topology ~~~~~~~~~~~~~~~~~~ This section describes how processors are assigned in order to solve the domain in parallel. “P” allocates the number of processes to the grid-cells in x. “Q” allocates the number of processes to the grid-cells in y. “R” allocates the number of processes to the grid-cells in z. Please note “R” should always be 1 if you are running with Solver Richards :cite:p:`Jones-Woodward01` unless you’re running a totally saturated domain (solver IMPES). *integer* **Process.Topology.P** no default This assigns the process splits in the *x* direction. .. container:: list :: run.Process.Topology.P = 2 # Python syntax pfset Process.Topology.P 2 # TCL syntax *integer* **Process.Topology.Q** no default This assigns the process splits in the *y* direction. .. container:: list :: run.Process.Topology.Q = 1 # Python syntax pfset Process.Topology.Q 1 # TCL syntax *integer* **Process.Topology.R** no default This assigns the process splits in the *z* direction. .. container:: list :: run.Process.Topology.R = 1 # Python syntax pfset Process.Topology.R 1 # TCL syntax In addition, you can assign the computing topology when you initiate your parflow script using tcl. You must include the topology allocation when using tclsh and the parflow script. Example Usage (Python): :: [from Terminal] python3 default_single.py 2 1 1 [At the top of default_single.py you would include the following] np = int(sys.argv[1]) nq = int(sys.argv[2]) run.Process.Topology.P = np run.Process.Topology.Q = nq run.Process.Topology.R = 1 Example Usage (TCL): :: pfset Process.Topology.P np pfset Process.Topology.Q nq pfset Process.Topology.R 1 .. _Computational Grid: Computational Grid ~~~~~~~~~~~~~~~~~~ The computational grid is briefly described in :ref:`Defining the Problem`. The computational grid keys set the bottom left corner of the domain to a specific point in space. If using a ``.pfsol`` file, the bottom left corner location of the ``.pfsol`` file must be the points designated in the computational grid. The user can also assign the *x*, *y* and *z* location to correspond to a specific coordinate system (i.e. UTM). *double* **ComputationalGrid.Lower.X** no default This assigns the lower *x* coordinate location for the computational grid. .. container:: list :: run.ComputationalGrid.Lower.X = 0.0 # Python syntax pfset ComputationalGrid.Lower.X 0.0 # TCL syntax *double* **ComputationalGrid.Lower.Y** no default This assigns the lower *y* coordinate location for the computational grid. .. container:: list :: run.ComputationalGrid.Lower.Y = 0.0 # Python syntax pfset ComputationalGrid.Lower.Y 0.0 # TCL syntax *double* **ComputationalGrid.Lower.Z** no default This assigns the lower *z* coordinate location for the computational grid. .. container:: list :: run.ComputationalGrid.Lower.Z = 0.0 # Python syntax pfset ComputationalGrid.Lower.Z 0.0 # TCL syntax *integer* **ComputationalGrid.NX** no default This assigns the number of grid cells in the *x* direction for the computational grid. .. container:: list :: run.ComputationalGrid.NX = 10 # Python syntax pfset ComputationalGrid.NX 10 # TCL syntax *integer* **ComputationalGrid.NY** no default This assigns the number of grid cells in the *y* direction for the computational grid. .. container:: list :: run.ComputationalGrid.NY = 10 # Python syntax pfset ComputationalGrid.NY 10 # TCL syntax *integer* **ComputationalGrid.NZ** no default This assigns the number of grid cells in the *z* direction for the computational grid. .. container:: list :: run.ComputationalGrid.NZ = 10 # Python syntax pfset ComputationalGrid.NZ 10 # TCL syntax *real* **ComputationalGrid.DX** no default This defines the size of grid cells in the *x* direction. Units are *L* and are defined by the units of the hydraulic conductivity used in the problem. .. container:: list :: run.ComputationalGrid.DX = 10.0 # Python syntax pfset ComputationalGrid.DX 10.0 # TCL syntax *real* **ComputationalGrid.DY** no default This defines the size of grid cells in the *y* direction. Units are *L* and are defined by the units of the hydraulic conductivity used in the problem. .. container:: list :: run.ComputationalGrid.DY = 10.0 # Python syntax pfset ComputationalGrid.DY 10.0 # TCL syntax *real* **ComputationalGrid.DZ** no default This defines the size of grid cells in the *z* direction. Units are *L* and are defined by the units of the hydraulic conductivity used in the problem. .. container:: list :: run.ComputationalGrid.DZ = 1.0 # Python syntax pfset ComputationalGrid.DZ 1.0 # TCL syntax Example Usage (Python): :: #--------------------------------------------------------- # Computational Grid #--------------------------------------------------------- run.ComputationalGrid.Lower.X = -10.0 run.ComputationalGrid.Lower.Y = 10.0 run.ComputationalGrid.Lower.Z = 1.0 run.ComputationalGrid.NX = 18 run.ComputationalGrid.NY = 18 run.ComputationalGrid.NZ = 8 run.ComputationalGrid.DX = 8.0 run.ComputationalGrid.DY = 10.0 run.ComputationalGrid.DZ = 1.0 Example Usage (TCL): :: #--------------------------------------------------------- # Computational Grid #--------------------------------------------------------- pfset ComputationalGrid.Lower.X -10.0 pfset ComputationalGrid.Lower.Y 10.0 pfset ComputationalGrid.Lower.Z 1.0 pfset ComputationalGrid.NX 18 pfset ComputationalGrid.NY 18 pfset ComputationalGrid.NZ 8 pfset ComputationalGrid.DX 8.0 pfset ComputationalGrid.DY 10.0 pfset ComputationalGrid.DZ 1.0 *string* **UseClustering** True Run a clustering algorithm to create boxes in index space for iteration. By default an octree representation is used for iteration, this may result in iterating over many nodes in the octree. The **UseClustering** key will run a clustering algorithm to build a set of boxes for iteration. This does not always have a significant impact on performance and the clustering algorithm can be expensive to compute. For small problems and short running problems clustering is not recommended. Long running problems may or may not see a benefit. The result varies significantly based on the geometries in the problem. The Berger-Rigoutsos algorithm is currently used for clustering. :: run.UseClustering = False # Python syntax pfset UseClustering False # TCL syntax .. _Geometries: Geometries ~~~~~~~~~~ Here we define all “geometrical” information needed by ParFlow. For example, the domain (and patches on the domain where boundary conditions are to be imposed), lithology or hydrostratigraphic units, faults, initial plume shapes, and so on, are considered geometries. This input section is a little confusing. Two items are being specified, geometry inputs and geometries. A geometry input is a type of geometry input (for example a box or an input file). A geometry input can contain more than one geometry. A geometry input of type Box has a single geometry (the square box defined by the extants of the two points). A SolidFile input type can contain several geometries. *list* **GeomInput.Names** no default This is a list of the geometry input names which define the containers for all of the geometries defined for this problem. .. container:: list :: run.GeomInput.Names = "solidinput indinput boxinput" # Python syntax pfset GeomInput.Names "solidinput indinput boxinput" # TCL syntax *string* **GeomInput.\ *geom_input_name*.InputType** no default This defines the input type for the geometry input with *geom_input_name*. This key must be one of: **SolidFile, IndicatorField, IndicatorFieldNC**, **Box**. .. container:: list :: run.GeomInput.solidinput.InputType = "SolidFile" # Python syntax pfset GeomInput.solidinput.InputType "SolidFile" # TCL syntax *list* **GeomInput.\ *geom_input_name*.GeomNames** no default This is a list of the names of the geometries defined by the geometry input. For a geometry input type of Box, the list should contain a single geometry name. For the SolidFile geometry type this should contain a list with the same number of gemetries as were defined using GMS. The order of geometries in the SolidFile should match the names. For IndicatorField and IndicatorFieldNC types you need to specify the value in the input field which matches the name using GeomInput.\ *geom_input_name*.Value. Example Usage (Python): :: run.GeomInput.solidinput.GeomNames = "domain bottomlayer" run.GeomInput.solidinput.GeomNames = "domain bottomlayer middlelayer toplayer" Example Usage (TCL): :: pfset GeomInput.solidinput.GeomNames "domain bottomlayer" pfset GeomInput.solidinput.GeomNames "domain bottomlayer middlelayer toplayer" *string* **GeomInput.\ *geom_input_name*.Filename** no default For IndicatorField, IndicatorFieldNC and SolidFile geometry inputs this key specifies the input filename which contains the field or solid information. .. container:: list :: run.GeomInput.solidinput.FileName = "ocwd.pfsol" # Python syntax pfset GeomInput.solidinput.FileName "ocwd.pfsol" # TCL syntax *integer* **GeomInput.\ *geometry_input_name*.Value** no default For IndicatorField, IndicatorFieldNC geometry inputs you need to specify the mapping between values in the input file and the geometry names. The named geometry will be defined wherever the input file is equal to the specified value. .. container:: list :: run.GeomInput.sourceregion.Value = 11 # Python syntax pfset GeomInput.sourceregion.Value 11 # TCL syntax For box geometries you need to specify the location of the box. This is done by defining two corners of the the box. *double* **Geom.\ *box_geom_name*.Lower.X** no default This gives the lower X real space coordinate value of the previously specified box geometry of name *box_geom_name*. .. container:: list :: run.Geom.background.Lower.X = -1.0 # Python syntax pfset Geom.background.Lower.X -1.0 # TCL syntax *double* **Geom.\ *box_geom_name*.Lower.Y** no default This gives the lower Y real space coordinate value of the previously specified box geometry of name *box_geom_name*. .. container:: list :: run.Geom.background.Lower.Y = -1.0 # Python syntax pfset Geom.background.Lower.Y -1.0 # TCL syntax *double* **Geom.\ *box_geom_name*.Lower.Z** no default This gives the lower Z real space coordinate value of the previously specified box geometry of name *box_geom_name*. .. container:: list :: run.Geom.background.Lower.Z = -1.0 # Python syntax pfset Geom.background.Lower.Z -1.0 # TCL syntax *double* **Geom.\ *box_geom_name*.Upper.X** no default This gives the upper X real space coordinate value of the previously specified box geometry of name *box_geom_name*. .. container:: list :: run.Geom.background.Upper.X = 151.0 # Python syntax pfset Geom.background.Upper.X 151.0 # TCL syntax *double* **Geom.\ *box_geom_name*.Upper.Y** no default This gives the upper Y real space coordinate value of the previously specified box geometry of name *box_geom_name*. .. container:: list :: run.Geom.background.Upper.Y = 171.0 # Python syntax pfset Geom.background.Upper.Y 171.0 # TCL syntax *double* **Geom.\ *box_geom_name*.Upper.Z** no default This gives the upper Z real space coordinate value of the previously specified box geometry of name *box_geom_name*. .. container:: list :: run.Geom.background.Upper.Z = 11.0 # Python syntax pfset Geom.background.Upper.Z 11.0 # TCL syntax *list* **Geom.\ *geom_name*.Patches** no default Patches are defined on the surfaces of geometries. Currently you can only define patches on Box geometries and on the the first geometry in a SolidFile. For a Box the order is fixed (left right front back bottom top) but you can name the sides anything you want. For SolidFiles the order is printed by the conversion routine that converts GMS to SolidFile format. .. container:: list :: run.Geom.background.Patches = "left right front back bottom top" # Python syntax pfset Geom.background.Patches "left right front back bottom top" # TCL syntax Here is an example geometry input section which has three geometry inputs (TCL). Example Usage (Python): :: #--------------------------------------------------------- # The Names of the GeomInputs #--------------------------------------------------------- run.GeomInput.Names = "solidinput indinput boxinput" # # For a solid file geometry input type you need to specify the names # of the gemetries and the filename # run.GeomInput.solidinput.InputType = "SolidFile" # The names of the geometries contained in the solid file. Order is # important and defines the mapping. First geometry gets the first name. run.GeomInput.solidinput.GeomNames = "domain" # # Filename that contains the geometry # run.GeomInput.solidinput.FileName = "ocwd.pfsol" # # An indicator field is a 3D field of values. # The values within the field can be mapped # to ParFlow geometries. Indicator fields must match the # computation grid exactly! # run.GeomInput.indinput.InputType = "IndicatorField" run.GeomInput.indinput.GeomNames = "sourceregion concenregion" run.GeomInput.indinput.FileName = "ocwd.pfb" # # Within the indicator.pfb file, assign the values to each GeomNames # run.GeomInput.sourceregion.Value = 11 run.GeomInput.concenregion.Value = 12 # # A box is just a box defined by two points. # run.GeomInput.boxinput.InputType = "Box" run.GeomInput.boxinput.GeomName = "background" run.Geom.background.Lower.X = -1.0 run.Geom.background.Lower.Y = -1.0 run.Geom.background.Lower.Z = -1.0 run.Geom.background.Upper.X = 151.0 run.Geom.background.Upper.Y = 171.0 run.Geom.background.Upper.Z = 11.0 # # The patch order is fixed in the .pfsol file, but you # can call the patch name anything you # want (i.e. left right front back bottom top) # run.Geom.domain.Patches = ""z-upper x-lower y-lower" x-upper y-upper z-lower" Example Usage (TCL): :: #--------------------------------------------------------- # The Names of the GeomInputs #--------------------------------------------------------- pfset GeomInput.Names "solidinput indinput boxinput" # # For a solid file geometry input type you need to specify the names # of the gemetries and the filename # pfset GeomInput.solidinput.InputType "SolidFile" # The names of the geometries contained in the solid file. Order is # important and defines the mapping. First geometry gets the first name. pfset GeomInput.solidinput.GeomNames "domain" # # Filename that contains the geometry # pfset GeomInput.solidinput.FileName "ocwd.pfsol" # # An indicator field is a 3D field of values. # The values within the field can be mapped # to ParFlow geometries. Indicator fields must match the # computation grid exactly! # pfset GeomInput.indinput.InputType "IndicatorField" pfset GeomInput.indinput.GeomNames "sourceregion concenregion" pfset GeomInput.indinput.FileName "ocwd.pfb" # # Within the indicator.pfb file, assign the values to each GeomNames # pfset GeomInput.sourceregion.Value 11 pfset GeomInput.concenregion.Value 12 # # A box is just a box defined by two points. # pfset GeomInput.boxinput.InputType "Box" pfset GeomInput.boxinput.GeomName "background" pfset Geom.background.Lower.X -1.0 pfset Geom.background.Lower.Y -1.0 pfset Geom.background.Lower.Z -1.0 pfset Geom.background.Upper.X 151.0 pfset Geom.background.Upper.Y 171.0 pfset Geom.background.Upper.Z 11.0 # # The patch order is fixed in the .pfsol file, but you # can call the patch name anything you # want (i.e. left right front back bottom top) # pfset Geom.domain.Patches ""z-upper x-lower y-lower" x-upper y-upper z-lower" .. _Reservoirs: Reservoirs ~~~~~~~~~~ Here we define reservoirs for the model. Currently reservoirs have only been tested on domains where the top of domain lies at the top of the grid. This applies to all box domains and some terrain following grid domains. The format for this section of input is: *string* **Reservoirs.Names** no default This key specifies the names of the reservoirs for which input data will be given. .. container:: list :: run.Reservoirs.Names = "reservoir_1 reservoir_2 reservoir_3" # Python syntax pfset Reservoirs.Names "reservoir_1 reservoir_2 reservoir_3" # TCL syntax *double* **Reservoirs.\ *reservoir_name*.Release_X** no default This key specifies the x location of where the reservoir releases water. This cell will always be placed on the domain surface. *double* **Reservoirs.\ *reservoir_name*.Release_Y** no default This key specifies the y location of where the reservoir releases water. This cell will always be placed on the domain surface. *double* **Reservoirs.\ *reservoir_name*.Intake_X** no default This key specifies the x location of where the reservoir intakes water. This cell will always be placed on the domain surface. *double* **Reservoirs.\ *reservoir_name*.Intake_Y** no default This key specifies the y location of where the reservoir intakes water. This cell will always be placed on the domain surfacexxxxx. .. This value is set as an int because bools do not work with the table reader right now *int* **Reservoirs.\ *reservoir_name*.Has_Secondary_Intake_Cell** no default This key specifies if the reservoir has a secondary intake cell, with 0 evaluating to false and 1 evaluating to true. This cell will always be placed on the domain surface. *double* **Reservoirs.\ *reservoir_name*.Secondary_Intake_X** no default This optional key specifies the x location of where the reservoir's secondary intake cell intakes water. This cell will always be placed on the domain surface. This key is only used when the reservoir has a secondary intake cell, in which case it is required. *double* **Reservoirs.\ *reservoir_name*.Secondary_Intake_Y** no default This optional key specifies the y location of where the reservoir's secondary intake cell intakes water. This cell will always be placed on the domain surface. This key is only used when the reservoir has a secondary intake cell, in which case it is required. *double* **Reservoirs.\ *reservoir_name*.Min_Release_Storage** no default This key specifies the storage amount below which the reservoir will stop releasing water. Has units [L\ :sup:`3`]. *double* **Reservoirs.\ *reservoir_name*.Max_Storage** no default This key specifies a reservoirs maximum storage. If storage rises above this value, a reservoir will release extra water if necessary to get back down to this amount by the next timestep. Has units [L\ :sup:`3`] *double* **Reservoirs.\ *reservoir_name*.Storage** no default This key specifies the amount of water stored in the reservoir as a volume. Has same length units as the problem domain i.e. if domain is sized in meters this will be in m\ :sup:`3`. *double* **Reservoirs.\ *reservoir_name*.Release_Rate** no default [Type: double] This key specifies the rate in volume/time [L\ :sup:`3` \ :sup:`-1`] that the reservoir release water. The amount of time over which this amount is released is independent of solver timestep size. Overland_Flow_Solver *string* **Reservoirs.Overland_Flow_Solver** no default This key specifies which overland flow condition is used in the domain so that the slopes aroundthe reservoirs can be adjusted properly. Supported Options are **OverlandFlow** and **OverlandKinematic**. .. _Timing Information: Timing Information ~~~~~~~~~~~~~~~~~~ The data given in the timing section describe all the “temporal” information needed by ParFlow. The data items are used to describe time units for later sections, sequence iterations in time, indicate actual starting and stopping values and give instructions on when data is printed out. *double* **TimingInfo.BaseUnit** no default This key is used to indicate the base unit of time for entering time values. All time should be expressed as a multiple of this value. This should be set to the smallest interval of time to be used in the problem. For example, a base unit of “1” means that all times will be integer valued. A base unit of “0.5” would allow integers and fractions of 0.5 to be used for time input values. The rationale behind this restriction is to allow time to be discretized on some interval to enable integer arithmetic to be used when computing/comparing times. This avoids the problems associated with real value comparisons which can lead to events occurring at different timesteps on different architectures or compilers. This value is also used when describing “time cycling data” in, currently, the well and boundary condition sections. The lengths of the cycles in those sections will be integer multiples of this value, therefore it needs to be the smallest divisor which produces an integral result for every “real time” cycle interval length needed. .. container:: list :: run.TimingInfo.BaseUnit = 1.0 # Python syntax pfset TimingInfo.BaseUnit 1.0 # TCL syntax *integer* **TimingInfo.StartCount** no default This key is used to indicate the time step number that will be associated with the first advection cycle in a transient problem. The value **-1** indicates that advection is not to be done. The value **0** indicates that advection should begin with the given initial conditions. .. container:: list :: run.TimingInfo.StartCount = 0 # Python syntax pfset TimingInfo.StartCount 0 # TCL syntax *double* **TimingInfo.StartTime** no default This key is used to indicate the starting time for the simulation. .. container:: list :: run.TimingInfo.StartTime = 0.0 # Python syntax pfset TimingInfo.StartTime 0.0 # TCL syntax *double* **TimingInfo.StopTime** no default This key is used to indicate the stopping time for the simulation. .. container:: list :: run.TimingInfo.StopTime = 100.0 # Python syntax pfset TimingInfo.StopTime 100.0 # TCL syntax *double* **TimingInfo.DumpInterval** no default This key is the real time interval at which time-dependent output should be written. A value of **0** will produce undefined behavior. If the value is negative, output will be dumped out every :math:`n` time steps, where :math:`n` is the absolute value of the integer part of the value. .. container:: list :: run.TimingInfo.DumpInterval = 10.0 # Python syntax pfset TimingInfo.DumpInterval 10.0 # TCL syntax *integer* **TimingInfo.DumpIntervalExecutionTimeLimit** 0 This key is used to indicate a wall clock time to halt the execution of a run. At the end of each dump interval the time remaining in the batch job is compared with the user supplied value, if remaining time is less than or equal to the supplied value the execution is halted. Typically used when running on batch systems with time limits to force a clean shutdown near the end of the batch job. Time units is seconds, a value of **0** (the default) disables the check. Currently only supported on SLURM based systems, “–with-slurm” must be specified at configure time to enable. .. container:: list :: run.TimingInfo.DumpIntervalExecutionTimeLimit = 360 # Python syntax pfset TimingInfo.DumpIntervalExecutionTimeLimit 360 # TCL syntax For *Richards’ equation cases only* input is collected for time step selection. Input for this section is given as follows: *list* **TimeStep.Type** no default This key must be one of: **Constant** or **Growth**. The value **Constant** defines a constant time step. The value **Growth** defines a time step that starts as :math:`dt_0` and is defined for other steps as :math:`dt^{new} = \gamma dt^{old}` such that :math:`dt^{new} \leq dt_{max}` and :math:`dt^{new} \geq dt_{min}`. .. container:: list :: run.TimeStep.Type = "Constant" # Python syntax pfset TimeStep.Type "Constant" # TCL syntax *double* **TimeStep.Value** no default This key is used only if a constant time step is selected and indicates the value of the time step for all steps taken. .. container:: list :: run.TimeStep.Value = 0.001 # Python syntax pfset TimeStep.Value 0.001 # TCL syntax *double* **TimeStep.InitialStep** no default This key specifies the initial time step :math:`dt_0` if the **Growth** type time step is selected. .. container:: list :: run.TimeStep.InitialStep = 0.001 # Python syntax pfset TimeStep.InitialStep 0.001 # TCL syntax *double* **TimeStep.GrowthFactor** no default This key specifies the growth factor :math:`\gamma` by which a time step will be multiplied to get the new time step when the **Growth** type time step is selected. .. container:: list :: run.TimeStep.GrowthFactor = 1.5 # Python syntax pfset TimeStep.GrowthFactor 1.5 # TCL syntax *double* **TimeStep.MaxStep** no default This key specifies the maximum time step allowed, :math:`dt_{max}`, when the **Growth** type time step is selected. .. container:: list :: run.TimeStep.MaxStep = 86400 # Python syntax pfset TimeStep.MaxStep 86400 # TCL syntax *double* **TimeStep.MinStep** no default This key specifies the minimum time step allowed, :math:`dt_{min}`, when the **Growth** type time step is selected. .. container:: list :: run.TimeStep.MinStep = 1.0e-3 # Python syntax pfset TimeStep.MinStep 1.0e-3 # TCL syntax Here is a detailed example of how timing keys might be used in a simulation. Example Usage (Python): :: #----------------------------------------------------------------------------- # Setup timing info [hr] # 8760 hours in a year. Dumping files every 24 hours. Hourly timestep #----------------------------------------------------------------------------- run.TimingInfo.BaseUnit = 1.0 run.TimingInfo.StartCount = 0 run.TimingInfo.StartTime = 0.0 run.TimingInfo.StopTime = 8760.0 run.TimingInfo.DumpInterval = -24 ## Timing constant example run.TimeStep.Type = "Constant" run.TimeStep.Value = 1.0 ## Timing growth example run.TimeStep.Type = "Growth" run.TimeStep.InitialStep = 0.0001 run.TimeStep.GrowthFactor = 1.4 run.TimeStep.MaxStep = 1.0 run.TimeStep.MinStep = 0.0001 Example Usage (TCL): :: #----------------------------------------------------------------------------- # Setup timing info [hr] # 8760 hours in a year. Dumping files every 24 hours. Hourly timestep #----------------------------------------------------------------------------- pfset TimingInfo.BaseUnit 1.0 pfset TimingInfo.StartCount 0 pfset TimingInfo.StartTime 0.0 pfset TimingInfo.StopTime 8760.0 pfset TimingInfo.DumpInterval -24 ## Timing constant example pfset TimeStep.Type "Constant" pfset TimeStep.Value 1.0 ## Timing growth example pfset TimeStep.Type "Growth" pfset TimeStep.InitialStep 0.0001 pfset TimeStep.GrowthFactor 1.4 pfset TimeStep.MaxStep 1.0 pfset TimeStep.MinStep 0.0001 .. _Time Cycles: Time Cycles ~~~~~~~~~~~ The data given in the time cycle section describes how time intervals are created and named to be used for time-dependent boundary and well information needed by ParFlow. All the time cycles are synched to the **TimingInfo.BaseUnit** key described above and are *integer multipliers* of that value. *list* **Cycle.Names** no default This key is used to specify the named time cycles to be used in a simulation. It is a list of names and each name defines a time cycle and the number of items determines the total number of time cycles specified. Each named cycle is described using a number of keys defined below. .. container:: list :: run.Cycle.Names = "constant onoff" # Python syntax pfset Cycle.Names "constant onoff" # TCL syntax *list* **Cycle.\ *cycle_name*.Names** no default This key is used to specify the named time intervals for each cycle. It is a list of names and each name defines a time interval when a specific boundary condition is applied and the number of items determines the total number of intervals in that time cycle. .. container:: list :: run.Cycle.onoff.Names = "on off" # Python syntax pfset Cycle.onoff.Names "on off" # TCL syntax *integer* **Cycle.\ *cycle_name.interval_name*.Length** no default This key is used to specify the length of a named time intervals. It is an *integer multiplier* of the value set for the **TimingInfo.BaseUnit** key described above. The total length of a given time cycle is the sum of all the intervals multiplied by the base unit. .. container:: list :: run.Cycle.onoff.on.Length = 10 # Python syntax pfset Cycle.onoff.on.Length 10 # TCL syntax *integer* **Cycle.\ *cycle_name*.Repeat** no default This key is used to specify the how many times a named time interval repeats. A positive value specifies a number of repeat cycles a value of -1 specifies that the cycle repeat for the entire simulation. Example Usage (Python): :: run.Cycle.onoff.Repeat = -1 run.Cycle.onoff.Repeat = -1 Example Usage (TCL): :: pfset Cycle.onoff.Repeat -1 pfset Cycle.onoff.Repeat -1 Here is a detailed example of how time cycles might be used in a simulation. Example Usage (Python): :: #----------------------------------------------------------------------------- # Time Cycles #----------------------------------------------------------------------------- run.Cycle.Names = "constant rainrec" run.Cycle.constant.Names = "alltime" run.Cycle.constant.alltime.Length = 8760 run.Cycle.constant.Repeat = -1 # Creating a rain and recession period for the rest of year run.Cycle.rainrec.Names = "rain rec" run.Cycle.rainrec.rain.Length = 10 run.Cycle.rainrec.rec.Length = 8750 run.Cycle.rainrec.Repeat = -1 Example Usage (TCL): :: #----------------------------------------------------------------------------- # Time Cycles #----------------------------------------------------------------------------- pfset Cycle.Names "constant rainrec" pfset Cycle.constant.Names "alltime" pfset Cycle.constant.alltime.Length 8760 pfset Cycle.constant.Repeat -1 # Creating a rain and recession period for the rest of year pfset Cycle.rainrec.Names "rain rec" pfset Cycle.rainrec.rain.Length 10 pfset Cycle.rainrec.rec.Length 8750 pfset Cycle.rainrec.Repeat -1 .. _Domain: Domain ~~~~~~ The domain may be represented by any of the solid types in :ref:`Geometries` above that allow the definition of surface patches. These surface patches are used to define boundary conditions in :ref:`Boundary Conditions: Pressure` and :ref:`Boundary Conditions: Saturation` below. Subsequently, it is required that the union (or combination) of the defined surface patches equal the entire domain surface. NOTE: This requirement is NOT checked in the code. *string* **Domain.GeomName** no default This key specifies which of the named geometries is the problem domain. .. container:: list :: run.Domain.GeomName = "domain" # Python syntax pfset Domain.GeomName "domain" # TCL syntax .. _Phases and Contaminants: Phases and Contaminants ~~~~~~~~~~~~~~~~~~~~~~~ *list* **Phase.Names** no default This specifies the names of phases to be modeled. Currently only 1 or 2 phases may be modeled. .. container:: list :: run.Phase.Names = "water" # Python syntax pfset Phase.Names "water" # TCL syntax *list* **Contaminants.Names** no default This specifies the names of contaminants to be advected. .. container:: list :: run.Contaminants.Names = "tce" # Python syntax pfset Contaminants.Names "tce" # TCL syntax .. _Gravity, Phase Density and Phase Viscosity: Gravity, Phase Density and Phase Viscosity ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *double* **Gravity** no default Specifies the gravity constant to be used. .. container:: list :: run.Gravity = 1.0 # Python syntax pfset Gravity 1.0 # TCL syntax *string* **Phase.\ *phase_name*.Density.Type** no default This key specifies whether density will be a constant value or if it will be given by an equation of state of the form :math:`(rd)exp(cP)`, where :math:`P` is pressure, :math:`rd` is the density at atmospheric pressure, and :math:`c` is the phase compressibility constant. This key must be either **Constant** or **EquationOfState**. .. container:: list :: run.Phase.water.Density.Type = "Constant" # Python syntax pfset Phase.water.Density.Type "Constant" # TCL syntax *double* **Phase.\ *phase_name*.Density.Value** no default This specifies the value of density if this phase was specified to have a constant density value for the phase *phase_name*. .. container:: list :: run.Phase.water.Density.Value = 1.0 # Python syntax pfset Phase.water.Density.Value 1.0 # TCL syntax *double* **Phase.\ *phase_name*.Density.ReferenceDensity** no default This key specifies the reference density if an equation of state density function is specified for the phase *phase_name*. .. container:: list :: run.Phase.water.Density.ReferenceDensity = 1.0 # Python syntax pfset Phase.water.Density.ReferenceDensity 1.0 # TCL syntax *double* **Phase.\ *phase_name*.Density.CompressibilityConstant** no default This key specifies the phase compressibility constant if an equation of state density function is specified for the phase *phase|-name*. .. container:: list :: run.Phase.water.Density.CompressibilityConstant = 1.0 # Python syntax pfset Phase.water.Density.CompressibilityConstant 1.0 # TCL syntax *string* **Phase.\ *phase_name*.Viscosity.Type** Constant This key specifies whether viscosity will be a constant value. Currently, the only choice for this key is **Constant**. .. container:: list :: run.Phase.water.Viscosity.Type = "Constant" # Python syntax pfset Phase.water.Viscosity.Type "Constant" # TCL syntax *double* **Phase.\ *phase_name*.Viscosity.Value** no default This specifies the value of viscosity if this phase was specified to have a constant viscosity value. .. container:: list :: run.Phase.water.Viscosity.Value = 1.0 # Python syntax pfset Phase.water.Viscosity.Value 1.0 # TCL syntax .. _Chemical Reactions: Chemical Reactions ~~~~~~~~~~~~~~~~~~ *double* **Contaminants.\ *contaminant_name*.Degradation.Value** no default This key specifies the half-life decay rate of the named contaminant, *contaminant_name*. At present only first order decay reactions are implemented and it is assumed that one contaminant cannot decay into another. .. container:: list :: run.Contaminants.tce.Degradation.Value = 0.0 # Python syntax pfset Contaminants.tce.Degradation.Value 0.0 # TCL syntax .. _Permeability: Permeability ~~~~~~~~~~~~ In this section, permeability property values are assigned to grid points within geometries (specified in :ref:`Geometries` above) using one of the methods described below. Permeabilities are assumed to be a diagonal tensor with entries given as, .. math:: \left( \begin{array}{ccc} k_x({\bf x}) & 0 & 0 \\ 0 & k_y({\bf x}) & 0 \\ 0 & 0 & k_z({\bf x}) \end{array} \right) K({\bf x}), where :math:`K({\bf x})` is the permeability field given below. Specification of the tensor entries (:math:`k_x, k_y` and :math:`k_z`) will be given at the end of this section. The random field routines (*turning bands* and *pgs*) can use conditioning data if the user so desires. It is not necessary to use conditioning as ParFlow automatically defaults to not use conditioning data, but if conditioning is desired, the following key should be set: *string* **Perm.Conditioning.FileName** “NA” This key specifies the name of the file that contains the conditioning data. The default string **NA** indicates that conditioning data is not applicable. .. container:: list :: run.Perm.Conditioning.FileName = "well_cond.txt" # Python syntax pfset Perm.Conditioning.FileName "well_cond.txt" # TCL syntax The file that contains the conditioning data is a simple ascii file containing points and values. The format is: .. container:: list :: nlines x1 y1 z1 value1 x2 y2 z2 value2 . . . . . . . . . . . . xn yn zn valuen The value of *nlines* is just the number of lines to follow in the file, which is equal to the number of data points. The variables *xi,yi,zi* are the real space coordinates (in the units used for the given parflow run) of a point at which a fixed permeability value is to be assigned. The variable *valuei* is the actual permeability value that is known. Note that the coordinates are not related to the grid in any way. Conditioning does not require that fixed values be on a grid. The PGS algorithm will map the given value to the closest grid point and that will be fixed. This is done for speed reasons. The conditioned turning bands algorithm does not do this; conditioning is done for every grid point using the given conditioning data at the location given. Mapping to grid points for that algorithm does not give any speedup, so there is no need to do it. NOTE: The given values should be the actual measured values - adjustment in the conditioning for the lognormal distribution that is assumed is taken care of in the algorithms. The general format for the permeability input is as follows: *list* **Geom.Perm.Names** no default This key specifies all of the geometries to which a permeability field will be assigned. These geometries must cover the entire computational domain. .. container:: list :: run.GeomInput.Names = "background domain concen_region" # Python syntax pfset GeomInput.Names "background domain concen_region" # TCL syntax *string* **Geom.geometry_name.Perm.Type** no default This key specifies which method is to be used to assign permeability data to the named geometry, *geometry_name*. It must be either **Constant**, **TurnBands**, **ParGuass**, or **PFBFile**. The **Constant** value indicates that a constant is to be assigned to all grid cells within a geometry. The **TurnBand** value indicates that Tompson’s Turning Bands method is to be used to assign permeability data to all grid cells within a geometry :cite:p:`TAG89`. The **ParGauss** value indicates that a Parallel Gaussian Simulator method is to be used to assign permeability data to all grid cells within a geometry. The **PFBFile** value indicates that premeabilities are to be read from a ParFlow 3D binary file. Both the Turning Bands and Parallel Gaussian Simulators generate a random field with correlation lengths in the :math:`3` spatial directions given by :math:`\lambda_x`, :math:`\lambda_y`, and :math:`\lambda_z` with the geometric mean of the log normal field given by :math:`\mu` and the standard deviation of the normal field given by :math:`\sigma`. In generating the field both of these methods can be made to stratify the data, that is follow the top or bottom surface. The generated field can also be made so that the data is normal or log normal, with or without bounds truncation. Turning Bands uses a line process, the number of lines used and the resolution of the process can be changed as well as the maximum normalized frequency :math:`K_{\rm max}` and the normalized frequency increment :math:`\delta K`. The Parallel Gaussian Simulator uses a search neighborhood, the number of simulated points and the number of conditioning points can be changed. .. container:: list :: run.Geom.background.Perm.Type = "Constant" # Python syntax pfset Geom.background.Perm.Type "Constant" # TCL syntax *double* **Geom.\ *geometry_name*.Perm.Value** no default This key specifies the value assigned to all points in the named geometry, *geometry_name*, if the type was set to constant. .. container:: list :: run.Geom.domain.Perm.Value = 1.0 # Python syntax pfset Geom.domain.Perm.Value 1.0 # TCL syntax *double* **Geom.\ *geometry_name*.Perm.LambdaX** no default This key specifies the x correlation length, :math:`\lambda_x`, of the field generated for the named geometry, *geometry_name*, if either the Turning Bands or Parallel Gaussian Simulator are chosen. .. container:: list :: run.Geom.domain.Perm.LambdaX = 200.0 # Python syntax pfset Geom.domain.Perm.LambdaX 200.0 # TCL syntax *double* **Geom.\ *geometry_name*.Perm.LambdaY** no default This key specifies the y correlation length, :math:`\lambda_y`, of the field generated for the named geometry, *geometry_name*, if either the Turning Bands or Parallel Gaussian Simulator are chosen. .. container:: list :: run.Geom.domain.Perm.LambdaY = 200.0 # Python syntax pfset Geom.domain.Perm.LambdaY 200.0 # TCL syntax *double* **Geom.\ *geometry_name*.Perm.LambdaZ** no default This key specifies the z correlation length, :math:`\lambda_z`, of the field generated for the named geometry, *geometry_name*, if either the Turning Bands or Parallel Gaussian Simulator are chosen. .. container:: list :: run.Geom.domain.Perm.LambdaZ = 10.0 # Python syntax pfset Geom.domain.Perm.LambdaZ 10.0 # TCL syntax *double* **Geom.\ *geometry_name*.Perm.GeomMean** no default This key specifies the geometric mean, :math:`\mu`, of the log normal field generated for the named geometry, *geometry_name*, if either the Turning Bands or Parallel Gaussian Simulator are chosen. .. container:: list :: run.Geom.domain.Perm.GeomMean = 4.56 # Python syntax pfset Geom.domain.Perm.GeomMean 4.56 # TCL syntax *double* **Geom.\ *geometry_name*.Perm.Sigma** no default This key specifies the standard deviation, :math:`\sigma`, of the normal field generated for the named geometry, *geometry_name*, if either the Turning Bands or Parallel Gaussian Simulator are chosen. .. container:: list :: run.Geom.domain.Perm.Sigma = 2.08 # Python syntax pfset Geom.domain.Perm.Sigma 2.08 # TCL syntax *integer* **Geom.\ *geometry_name*.Perm.Seed** 1 This key specifies the initial seed for the random number generator used to generate the field for the named geometry, *geometry_name*, if either the Turning Bands or Parallel Gaussian Simulator are chosen. This number must be positive. .. container:: list :: run.Geom.domain.Perm.Seed = 1 # Python syntax pfset Geom.domain.Perm.Seed 1 # TCL syntax *integer* **Geom.\ *geometry_name*.Perm.NumLines** 100 This key specifies the number of lines to be used in the Turning Bands algorithm for the named geometry, *geometry_name*. .. container:: list :: run.Geom.domain.Perm.NumLines = 100 # Python syntax pfset Geom.domain.Perm.NumLines 100 # TCL syntax *double* **Geom.\ *geometry_name*.Perm.RZeta** 5.0 This key specifies the resolution of the line processes, in terms of the minimum grid spacing, to be used in the Turning Bands algorithm for the named geometry, *geometry_name*. Large values imply high resolution. .. container:: list :: run.Geom.domain.Perm.RZeta = 5.0 # Python syntax pfset Geom.domain.Perm.RZeta 5.0 # TCL syntax *double* **Geom.\ *geometry_name*.Perm.KMax** 100.0 This key specifies the the maximum normalized frequency, :math:`K_{\rm max}`, to be used in the Turning Bands algorithm for the named geometry, *geometry_name*. .. container:: list :: run.Geom.domain.Perm.KMax = 100.0 # Python syntax pfset Geom.domain.Perm.KMax 100.0 # TCL syntax *double* **Geom.\ *geometry_name*.Perm.DelK** 0.2 This key specifies the normalized frequency increment, :math:`\delta K`, to be used in the Turning Bands algorithm for the named geometry, *geometry_name*. .. container:: list :: run.Geom.domain.Perm.DelK = 0.2 # Python syntax pfset Geom.domain.Perm.DelK 0.2 # TCL syntax *integer* **Geom.\ *geometry_name*.Perm.MaxNPts** no default This key sets limits on the number of simulated points in the search neighborhood to be used in the Parallel Gaussian Simulator for the named geometry, *geometry_name*. .. container:: list :: run.Geom.domain.Perm.MaxNPts = 5 # Python syntax pfset Geom.domain.Perm.MaxNPts 5 # TCL syntax *integer* **Geom.\ *geometry_name*.Perm.MaxCpts** no default This key sets limits on the number of external conditioning points in the search neighborhood to be used in the Parallel Gaussian Simulator for the named geometry, *geometry_name*. .. container:: list :: run.Geom.domain.Perm.MaxCpts = 200 # Python syntax pfset Geom.domain.Perm.MaxCpts 200 # TCL syntax *string* **Geom.\ *geometry_name*.Perm.LogNormal** "LogTruncated" The key specifies when a normal, log normal, truncated normal or truncated log normal field is to be generated by the method for the named geometry, *geometry_name*. This value must be one of **Normal**, **Log**, **NormalTruncated** or **LogTruncate** and can be used with either Turning Bands or the Parallel Gaussian Simulator. .. container:: list :: run.Geom.domain.Perm.LogNormal = "LogTruncated" # Python syntax pfset Geom.domain.Perm.LogNormal "LogTruncated" # TCL syntax *string* **Geom.\ *geometry_name*.Perm.StratType** "Bottom" This key specifies the stratification of the permeability field generated by the method for the named geometry, *geometry_name*. The value must be one of **Horizontal**, **Bottom** or **Top** and can be used with either the Turning Bands or the Parallel Gaussian Simulator. .. container:: list :: run.Geom.domain.Perm.StratType = "Bottom" # Python syntax pfset Geom.domain.Perm.StratType "Bottom" # TCL syntax *double* **Geom.\ *geometry_name*.Perm.LowCutoff** no default This key specifies the low cutoff value for truncating the generated field for the named geometry, *geometry_name*, when either the NormalTruncated or LogTruncated values are chosen. .. container:: list :: run.Geom.domain.Perm.LowCutoff = 0.0 # Python syntax pfset Geom.domain.Perm.LowCutoff 0.0 # TCL syntax *double* **Geom.\ *geometry_name*.Perm.HighCutoff** no default This key specifies the high cutoff value for truncating the generated field for the named geometry, *geometry_name*, when either the NormalTruncated or LogTruncated values are chosen. .. container:: list :: run.Geom.domain.Perm.HighCutoff = 100.0 # Python syntax pfset Geom.domain.Perm.HighCutoff 100.0 # TCL syntax *string* **Geom.\ *geometry_name*.Perm.FileName** no default This key specifies that permeability values for the specified geometry, *geometry_name*, are given according to a user-supplied description in the “ParFlow binary” file whose filename is given as the value. For a description of the ParFlow Binary file format, see :ref:`ParFlow Binary Files (.pfb)`. The ParFlow binary file associated with the named geometry must contain a collection of permeability values corresponding in a one-to-one manner to the entire computational grid. That is to say, when the contents of the file are read into the simulator, a complete permeability description for the entire domain is supplied. Only those values associated with computational cells residing within the geometry (as it is represented on the computational grid) will be copied into data structures used during the course of a simulation. Thus, the values associated with cells outside of the geounit are irrelevant. For clarity, consider a couple of different scenarios. For example, the user may create a file for each geometry such that appropriate permeability values are given for the geometry and “garbage" values (e.g., some flag value) are given for the rest of the computational domain. In this case, a separate binary file is specified for each geometry. Alternatively, one may place all values representing the permeability field on the union of the geometries into a single binary file. Note that the permeability values must be represented in precisely the same configuration as the computational grid. Then, the same file could be specified for each geounit in the input file. Or, the computational domain could be described as a single geouint (in the ParFlow input file) in which case the permeability values would be read in only once. .. container:: list :: run.Geom.domain.Perm.FileName = "domain_perm.pfb" # Python syntax pfset Geom.domain.Perm.FileName "domain_perm.pfb" # TCL syntax *string* **Perm.TensorType** no default This key specifies whether the permeability tensor entries :math:`k_x, k_y` and :math:`k_z` will be specified as three constants within a set of regions covering the domain or whether the entries will be specified cell-wise by files. The choices for this key are **TensorByGeom** and **TensorByFile**. .. container:: list :: run.Perm.TensorType = "TensorByGeom" # Python syntax pfset Perm.TensorType "TensorByGeom" # TCL syntax *string* **Geom.Perm.TensorByGeom.Names** no default This key specifies all of the geometries to which permeability tensor entries will be assigned. These geometries must cover the entire computational domain. .. container:: list :: run.Geom.Perm.TensorByGeom.Names = "background domain" # Python syntax pfset Geom.Perm.TensorByGeom.Names "background domain" # TCL syntax *double* **Geom.\ *geometry_name*.Perm.TensorValX** no default This key specifies the value of :math:`k_x` for the geometry given by *geometry_name*. .. container:: list :: run.Geom.domain.Perm.TensorValX = 1.0 # Python syntax pfset Geom.domain.Perm.TensorValX 1.0 # TCL syntax *double* **Geom.\ *geometry_name*.Perm.TensorValY** no default This key specifies the value of :math:`k_y` for the geometry given by *geom_name*. .. container:: list :: run.Geom.domain.Perm.TensorValY = 1.0 # Python syntax pfset Geom.domain.Perm.TensorValY 1.0 # TCL syntax *double* **Geom.\ *geometry_name*.Perm.TensorValZ** no default This key specifies the value of :math:`k_z` for the geometry given by *geom_name*. .. container:: list :: run.Geom.domain.Perm.TensorValZ = 1.0 # Python syntax pfset Geom.domain.Perm.TensorValZ 1.0 # TCL syntax *string* **Geom.\ *geometry_name*.Perm.TensorFileX** no default This key specifies that :math:`k_x` values for the specified geometry, *geometry_name*, are given according to a user-supplied description in a ParFlow 3D binary file whose filename is given as the value. The only choice for the value of *geometry_name* is “domain”. .. container:: list :: run.Geom.domain.Perm.TensorByFileX = "perm_x.pfb" # Python syntax pfset Geom.domain.Perm.TensorByFileX "perm_x.pfb" # TCL syntax *string* **Geom.\ *geometry_name*.Perm.TensorFileY** no default This key specifies that :math:`k_y` values for the specified geometry, *geometry_name*, are given according to a user-supplied description in a ParFlow 3D binary file whose filename is given as the value. The only choice for the value of *geometry_name* is “domain”. .. container:: list :: run.Geom.domain.Perm.TensorByFileY = "perm_y.pfb" # Python syntax pfset Geom.domain.Perm.TensorByFileY "perm_y.pfb" # TCL syntax *string* **Geom.\ *geometry_name*.Perm.TensorFileZ** no default This key specifies that :math:`k_z` values for the specified geometry, *geometry_name*, are given according to a user-supplied description in a ParFlow 3D binary file whose filename is given as the value. The only choice for the value of *geometry_name* is “domain”. .. container:: list :: run.Geom.domain.Perm.TensorByFileZ = "perm_z.pfb" # Python syntax pfset Geom.domain.Perm.TensorByFileZ "perm_z.pfb" # TCL syntax .. _Porosity: Porosity ~~~~~~~~ Here, porosity values are assigned within geounits (specified in :ref:`Geometries` above) using one of the methods described below. The format for this section of input is: *list* **Geom.Porosity.GeomNames** no default This key specifies all of the geometries on which a porosity will be assigned. These geometries must cover the entire computational domain. .. container:: list :: run.Geom.Porosity.GeomNames = "background" # Python syntax pfset Geom.Porosity.GeomNames "background" # TCL syntax *string* **Geom.\ *geometry_name*.Porosity.Type** no default This key specifies which method is to be used to assign porosity data to the named geometry, *geometry_name*. The choices for this key are **Constant** and **PFBFile**. **Constant** indicates that a constant is to be assigned to all grid cells within a geometry. The **PFBFile** value indicates that porosity values are to be read from a ParFlow 3D binary file. .. container:: list :: run.Geom.background.Porosity.Type = "Constant" # Python syntax pfset Geom.background.Porosity.Type "Constant" # TCL syntax *double* **Geom.\ *geometry_name*.Porosity.Value** no default This key specifies the value assigned to all points in the named geometry, *geometry_name*, if the type was set to **Constant**. .. container:: list :: run.Geom.domain.Porosity.Value = 1.0 # Python syntax pfset Geom.domain.Porosity.Value 1.0 # TCL syntax *string* **Geom.\ *geometry_name*.Porosity.FileName** no default This key specifies that porosity values for the specified geometry, *geometry_name*, are given according to a user-supplied description in a ParFlow 3D binary file whose filename is given as the value. .. container:: list :: run.Geom.domain.Porosity.FileName = "porosity.pfb" # Python syntax pfset Geom.domain.Porosity.FileName "porosity.pfb" # TCL syntax .. _Specific Storage: Specific Storage ~~~~~~~~~~~~~~~~ Here, specific storage (:math:`S_s` in Equation :eq:`richard`) values are assigned within geounits (specified in :ref:`Geometries` above) using one of the methods described below. The format for this section of input is: *list* **Specific Storage.GeomNames** no default This key specifies all of the geometries on which a different specific storage value will be assigned. These geometries must cover the entire computational domain. .. container:: list :: run.SpecificStorage.GeomNames = "domain" # Python syntax pfset SpecificStorage.GeomNames "domain" # TCL syntax *string* **SpecificStorage.Type** no default This key specifies which method is to be used to assign specific storage data. The only choice currently available is **Constant** which indicates that a constant is to be assigned to all grid cells within a geometry. .. container:: list :: run.SpecificStorage.Type = "Constant" # Python syntax pfset SpecificStorage.Type "Constant" # TCL syntax *double* **Geom.\ *geometry_name*.SpecificStorage.Value** no default This key specifies the value assigned to all points in the named geometry, *geometry_name*, if the type was set to constant. .. container:: list :: run.Geom.domain.SpecificStorage.Value = 1.0e-4 # Python syntax pfset Geom.domain.SpecificStorage.Value 1.0e-4 # TCL syntax .. _dZ Multipliers: dZMultipliers ~~~~~~~~~~~~~ Here, dZ multipliers (:math:`\delta Z * m`) values are assigned within geounits (specified in :ref:`Geometries` above) using one of the methods described below. The format for this section of input is: *string* **Solver.Nonlinear.VariableDz** False This key specifies whether dZ multipliers are to be used, the default is False. The default indicates a false or non-active variable dz and each layer thickness is 1.0 [L]. .. container:: list :: run.Solver.Nonlinear.VariableDz = True # Python syntax pfset Solver.Nonlinear.VariableDz True # TCL syntax *list* **dzScale.GeomNames** no default This key specifies which problem domain is being applied a variable dz subsurface. These geometries must cover the entire computational domain. .. container:: list :: run.dzScale.GeomNames = "domain" # Python syntax pfset dzScale.GeomNames "domain" # TCL syntax *string* **dzScale.Type** no default This key specifies which method is to be used to assign variable vertical grid spacing. The choices currently available are **Constant** which indicates that a constant is to be assigned to all grid cells within a geometry, **nzList** which assigns all layers of a given model to a list value, and **PFBFile** which reads in values from a distributed ParFlow 3D binary file. .. container:: list :: run.dzScale.Type = "Constant" # Python syntax pfset dzScale.Type "Constant" # TCL syntax *list* **Specific dzScale.GeomNames** no default This key specifies all of the geometries on which a different dz scaling value will be assigned. These geometries must cover the entire computational domain. .. container:: list :: run.dzScale.GeomNames = "domain" # Python syntax pfset dzScale.GeomNames "domain" # TCL syntax *double* **Geom.\ *geometry_name*.dzScale.Value** no default This key specifies the value assigned to all points in the named geometry, *geometry_name*, if the type was set to constant. .. container:: list :: run.Geom.domain.dzScale.Value = 1.0 # Python syntax pfset Geom.domain.dzScale.Value 1.0 # TCL syntax *string* **Geom.\ *geometry_name*.dzScale.FileName** no default This key specifies file to be read in for variable dz values for the given geometry, *geometry_name*, if the type was set to **PFBFile**. .. container:: list :: run.Geom.domain.dzScale.FileName = "vardz.pfb" # Python syntax pfset Geom.domain.dzScale.FileName "vardz.pfb" # TCL syntax *integer* **dzScale.nzListNumber** no default This key indicates the number of layers with variable dz in the subsurface. This value is the same as the *ComputationalGrid.NZ* key. .. container:: list :: run.dzScale.nzListNumber = 10 # Python syntax pfset dzScale.nzListNumber 10 # TCL syntax *double* **Cell.\ *nzListNumber*.dzScale.Value** no default This key assigns the thickness of each layer defined by nzListNumber. ParFlow assigns the layers from the bottom-up (i.e. the bottom of the domain is layer 0, the top is layer NZ-1). The total domain depth (*Geom.domain.Upper.Z*) does not change with variable dz. The layer thickness is calculated by *ComputationalGrid.DZ \*dZScale*. *Note that* in Python a number is not an allowed character for a variable. Thus we proceed the layer number with an underscore "_" as shown in the example below. .. container:: list :: run.Cell._0.dzScale.Value = 1.0 # Python syntax pfset Cell.0.dzScale.Value 1.0 # TCL syntax Example Usage (Python): :: #-------------------------------------------- # Variable dz Assignments #------------------------------------------ # Set VariableDz to be true # Indicate number of layers (nzlistnumber), which is the same as nz # (1) There is nz*dz = total depth to allocate, # (2) Each layer’s thickness is dz*dzScale, and # (3) Assign the layer thickness from the bottom up. # In this example nz = 5; dz = 10; total depth 40; # Layers Thickness [m] # 0 15 Bottom layer # 1 15 # 2 5 # 3 4.5 # 4 0.5 Top layer run.Solver.Nonlinear.VariableDz = True run.dzScale.GeomNames = "domain" run.dzScale.Type = "nzList" run.dzScale.nzListNumber = 5 run.Cell._0.dzScale.Value = 1.5 run.Cell._1.dzScale.Value = 1.5 run.Cell._2.dzScale.Value = 0.5 run.Cell._3.dzScale.Value = 0.45 run.Cell._4.dzScale.Value = 0.05 Example Usage (TCL): :: #-------------------------------------------- # Variable dz Assignments #------------------------------------------ # Set VariableDz to be true # Indicate number of layers (nzlistnumber), which is the same as nz # (1) There is nz*dz = total depth to allocate, # (2) Each layer’s thickness is dz*dzScale, and # (3) Assign the layer thickness from the bottom up. # In this example nz = 5; dz = 10; total depth 40; # Layers Thickness [m] # 0 15 Bottom layer # 1 15 # 2 5 # 3 4.5 # 4 0.5 Top layer pfset Solver.Nonlinear.VariableDz True pfset dzScale.GeomNames "domain" pfset dzScale.Type "nzList" pfset dzScale.nzListNumber 5 pfset Cell.0.dzScale.Value 1.5 pfset Cell.1.dzScale.Value 1.5 pfset Cell.2.dzScale.Value 0.5 pfset Cell.3.dzScale.Value 0.45 pfset Cell.4.dzScale.Value 0.05 Example Usage (Python): .. container:: list :: #-------------------------------------------- # Variable dz Assignments #------------------------------------------ # Set VariableDz to be true # Indicate number of layers (nzlistnumber), which is the same as nz # (1) There is nz*dz = total depth to allocate, # (2) Each layer’s thickness is dz*dzScale, and # (3) Assign the layer thickness from the bottom up. # In this example nz = 5; dz = 10; total depth 40; # Layers Thickness [m] # 0 15 Bottom layer # 1 15 # 2 5 # 3 4.5 # 4 0.5 Top layer run.Solver.Nonlinear.VariableDz = True # Python syntax run.dzScale.GeomNames = "domain" # Python syntax run.dzScale.Type = "nzList" # Python syntax run.dzScale.nzListNumber = 5 # Python syntax run.Cell._0.dzScale.Value = 1.5 # Python syntax run.Cell._1.dzScale.Value = 1.5 # Python syntax run.Cell._2.dzScale.Value = 0.5 # Python syntax run.Cell._3.dzScale.Value = 0.45 # Python syntax run.Cell._4.dzScale.Value = 0.05 # Python syntax Example Usage (TCL): .. container:: list :: #-------------------------------------------- # Variable dz Assignments #------------------------------------------ # Set VariableDz to be true # Indicate number of layers (nzlistnumber), which is the same as nz # (1) There is nz*dz = total depth to allocate, # (2) Each layer’s thickness is dz*dzScale, and # (3) Assign the layer thickness from the bottom up. # In this example nz = 5; dz = 10; total depth 40; # Layers Thickness [m] # 0 15 Bottom layer # 1 15 # 2 5 # 3 4.5 # 4 0.5 Top layer pfset Solver.Nonlinear.VariableDz True # TCL syntax pfset dzScale.GeomNames "domain" # TCL syntax pfset dzScale.Type "nzList" # TCL syntax pfset dzScale.nzListNumber 5 # TCL syntax pfset Cell.0.dzScale.Value 1.5 # TCL syntax pfset Cell.1.dzScale.Value 1.5 # TCL syntax pfset Cell.2.dzScale.Value 0.5 # TCL syntax pfset Cell.3.dzScale.Value 0.45 # TCL syntax pfset Cell.4.dzScale.Value 0.05 # TCL syntax .. _Flow Barrier Keys: Flow Barriers ~~~~~~~~~~~~~ Here, the values for Flow Barriers described in :ref:`FB` can be input. These are only available with Solver **Richards** and can be specified in X, Y or Z directions independently using ParFlow binary files. These barriers are applied at the cell face at the location :math:`i+1/2`. That is a value of :math:`FB_x` specified at :math:`i` will be applied to the cell face at :math:`i+1/2` or between cells :math:`i` and :math:`i+1`. The same goes for :math:`FB_y` (:math:`j+1/2`) and :math:`FB_z` (:math:`k+1/2`). The flow barrier values are unitless and multiply the flux equation as shown in :eq:`qFBx`. The format for this section of input is: *string* **Solver.Nonlinear.FlowBarrierX** False This key specifies whether Flow Barriers are to be used in the X direction, the default is False. The default indicates a false or :math:`FB_x` value of one [-] everywhere in the domain. :: run.Solver.Nonlinear.FlowBarrierX = True # Python syntax pfset Solver.Nonlinear.FlowBarrierX True # TCL syntax *string* **Solver.Nonlinear.FlowBarrierY** False This key specifies whether Flow Barriers are to be used in the Y direction, the default is False. The default indicates a false or :math:`FB_y` value of one [-] everywhere in the domain. :: run.Solver.Nonlinear.FlowBarrierY = True # Python syntax pfset Solver.Nonlinear.FlowBarrierY True # TCL syntax *string* **Solver.Nonlinear.FlowBarrierZ** False This key specifies whether Flow Barriers are to be used in the Z direction, the default is False. The default indicates a false or :math:`FB_z` value of one [-] everywhere in the domain. :: run.Solver.Nonlinear.FlowBarrierZ = True # Python syntax pfset Solver.Nonlinear.FlowBarrierZ True # TCL syntax *string* **FBx.Type** no default This key specifies which method is to be used to assign flow barriers in X. The only choice currently available is **PFBFile** which reads in values from a distributed ParFlow binary file. :: run.FBx.Type = "PFBFile" # Python syntax pfset FBx.Type "PFBFile" # TCL syntax *string* **FBy.Type** no default This key specifies which method is to be used to assign flow barriers in Y. The only choice currently available is **PFBFile** which reads in values from a distributed pfb file. :: run.FBy.Type = "PFBFile" # Python syntax pfset FBy.Type "PFBFile" # TCL syntax *string* **FBz.Type** no default This key specifies which method is to be used to assign flow barriers in Z. The only choice currently available is **PFBFile** which reads in values from a distributed ParFlow binary file. :: run.FBz.Type = "PFBFile" # Python syntax pfset FBz.Type "PFBFile" # TCL syntax The Flow Barrier values may be read in from a ParFlow binary file over the entire domain. This is done as follows: *string* **Geom.domain.FBx.FileName** no default This key specifies file to be read in for the X flow barrier values for the domain, if the type was set to **PFBFile**. :: run.Geom.domain.FBx.FileName = "Flow_Barrier_X.pfb" # Python syntax pfset Geom.domain.FBx.FileName "Flow_Barrier_X.pfb" # TCL syntax *string* **Geom.domain.FBy.FileName** no default This key specifies file to be read in for the Y flow barrier values for the domain, if the type was set to **PFBFile**. :: run.Geom.domain.FBy.FileName = "Flow_Barrier_Y.pfb" # Python syntax pfset Geom.domain.FBy.FileName "Flow_Barrier_Y.pfb" # TCL syntax *string* **Geom.domain.FBz.FileName** no default This key specifies file to be read in for the Z flow barrier values for the domain, if the type was set to **PFBFile**. :: run.Geom.domain.FBz.FileName = "Flow_Barrier_Z.pfb" # Python syntax pfset Geom.domain.FBz.FileName "Flow_Barrier_Z.pfb" # TCL syntax .. _Manning's Roughness Values: Manning’s Roughness Values ~~~~~~~~~~~~~~~~~~~~~~~~~~ Here, Manning’s roughness values (:math:`n` in Equations :eq:`manningsx` and :eq:`manningsy`) are assigned to the upper boundary of the domain using one of the methods described below. The format for this section of input is: *list* **Mannings.GeomNames** no default This key specifies all of the geometries on which a different Mannings roughness value will be assigned. Mannings values may be assigned by **PFBFile** or as **Constant** by geometry. These geometries must cover the entire upper surface of the computational domain. .. container:: list :: run.Mannings.GeomNames = "domain" # Python syntax pfset Mannings.GeomNames "domain" # TCL syntax *string* **Mannings.Type** no default This key specifies which method is to be used to assign Mannings roughness data. The choices currently available are **Constant** which indicates that a constant is to be assigned to all grid cells within a geometry and **PFBFile** which indicates that all values are read in from a distributed, grid-based ParFlow 2D binary file. .. container:: list :: run.Mannings.Type = "Constant" # Python syntax pfset Mannings.Type "Constant" # TCL syntax *double* **Mannings.Geom.\ *geometry_name*.Value** no default This key specifies the value assigned to all points in the named geometry, *geometry_name*, if the type was set to constant. .. container:: list :: run.Mannings.Geom.domain.Value = 5.52e-6 # Python syntax pfset Mannings.Geom.domain.Value 5.52e-6 # TCL syntax *double* **Mannings.FileName** no default This key specifies the value assigned to all points be read in from a ParFlow 2D binary file. .. container:: list :: run.Mannings.FileName = "roughness.pfb" # Python syntax pfset Mannings.FileName "roughness.pfb" # TCL syntax Complete example of setting Mannings roughness :math:`n` values by geometry: Example Usage (Python): :: run.Mannings.Type = "Constant" run.Mannings.GeomNames = "domain" run.Mannings.Geom.domain.Value = 5.52e-6 Example Usage (TCL): :: pfset Mannings.Type "Constant" pfset Mannings.GeomNames "domain" pfset Mannings.Geom.domain.Value 5.52e-6 .. _Topographical Slopes: Topographical Slopes ~~~~~~~~~~~~~~~~~~~~ Here, topographical slope values (:math:`S_{f,x}` and :math:`S_{f,y}` in Equations :eq:`manningsx` and :eq:`manningsy`) are assigned to the upper boundary of the domain using one of the methods described below. Note that due to the negative sign in these equations :math:`S_{f,x}` and :math:`S_{f,y}` take a sign in the direction *opposite* of the direction of the slope. That is, negative slopes point "downhill" and positive slopes "uphill". The format for this section of input is: *list* **ToposlopesX.GeomNames** no default This key specifies all of the geometries on which a different :math:`x` topographic slope values will be assigned. Topographic slopes may be assigned by **PFBFile** or as **Constant** by geometry. These geometries must cover the entire upper surface of the computational domain. .. container:: list :: run.ToposlopesX.GeomNames = "domain" # Python syntax pfset ToposlopesX.GeomNames "domain" # TCL syntax *list* **ToposlopesY.GeomNames** no default This key specifies all of the geometries on which a different :math:`y` topographic slope values will be assigned. Topographic slopes may be assigned by **PFBFile** or as **Constant** by geometry. These geometries must cover the entire upper surface of the computational domain. .. container:: list :: run.ToposlopesY.GeomNames = "domain" # Python syntax pfset ToposlopesY.GeomNames "domain" # TCL syntax *string* **ToposlopesX.Type** no default This key specifies which method is to be used to assign topographic slopes. The choices currently available are **Constant** which indicates that a constant is to be assigned to all grid cells within a geometry and **PFBFile** which indicates that all values are read in from a distributed, grid-based ParFlow 2D binary file. .. container:: list :: run.ToposlopesX.Type = "Constant" # Python syntax pfset ToposlopesX.Type "Constant" # TCL syntax *double* **ToposlopesX.Geom.\ *geometry_name*.Value** no default This key specifies the value assigned to all points in the named geometry, *geometry_name*, if the type was set to constant. .. container:: list :: run.ToposlopeX.Geom.domain.Value = 0.001 # Python syntax pfset ToposlopeX.Geom.domain.Value 0.001 # TCL syntax *double* **ToposlopesX.FileName** no default This key specifies the value assigned to all points be read in from a ParFlow 2D binary file. .. container:: list :: run.TopoSlopesX.FileName = "lw.1km.slope_x.pfb" # Python syntax pfset TopoSlopesX.FileName "lw.1km.slope_x.pfb" # TCL syntax *double* **ToposlopesY.FileName** no default This key specifies the value assigned to all points be read in from a ParFlow 2D binary file. .. container:: list :: run.TopoSlopesY.FileName = "lw.1km.slope_y.pfb" # Python syntax pfset TopoSlopesY.FileName "lw.1km.slope_y.pfb" # TCL syntax Example of setting :math:`x` and :math:`y` slopes by geometry: Example Usage (Python): :: run.TopoSlopesX.Type = "Constant" run.TopoSlopesX.GeomNames = "domain" run.TopoSlopesX.Geom.domain.Value = 0.001 run.TopoSlopesY.Type = "Constant" run.TopoSlopesY.GeomNames = "domain" run.TopoSlopesY.Geom.domain.Value = -0.001 Example Usage (TCL): :: pfset TopoSlopesX.Type "Constant" pfset TopoSlopesX.GeomNames "domain" pfset TopoSlopesX.Geom.domain.Value 0.001 pfset TopoSlopesY.Type "Constant" pfset TopoSlopesY.GeomNames "domain" pfset TopoSlopesY.Geom.domain.Value -0.001 Example of setting :math:`x` and :math:`y` slopes by file: Example Usage (Python): :: run.TopoSlopesX.Type = "PFBFile" run.TopoSlopesX.GeomNames = "domain" run.TopoSlopesX.FileName = "lw.1km.slope_x.pfb" run.TopoSlopesY.Type = "PFBFile" run.TopoSlopesY.GeomNames = "domain" run.TopoSlopesY.FileName = "lw.1km.slope_y.pfb" Example Usage (TCL): :: pfset TopoSlopesX.Type "PFBFile" pfset TopoSlopesX.GeomNames "domain" pfset TopoSlopesX.FileName "lw.1km.slope_x.pfb" pfset TopoSlopesY.Type "PFBFile" pfset TopoSlopesY.GeomNames "domain" pfset TopoSlopesY.FileName "lw.1km.slope_y.pfb" .. _Channelwidths: Channelwidths ~~~~~~~~~~~~~ These keys are in development. They have been added to the pftools Python interface and can be set to read and print channewidth values, but have not yet been integrated with overland flow. Here, channel width values are assigned to the upper boundary of the domain using one of the methods described below. The format for this section of input is: *list* **Solver.Nonlinear.ChannelWidthExistX** False This key specifies whether a channelwidthX input is provided. *list* **Solver.Nonlinear.ChannelWidthExistY** False This key specifies whether a channelwidthY input is provided. *list* **ChannelWidthX.GeomNames** no default This key specifies all of the geometries on which a different ChannelWidthX values will be assigned. ChannelWidthX may be assigned by **PFBFile** or **NCFile** as **Constant** by geometry. These geometries must cover the entire upper surface of the computational domain. .. container:: list :: run.ChannelWidthX.GeomNames = "domain" # Python syntax pfset ChannelWidthX.GeomNames "domain" # TCL syntax *list* **ChannelWidthY.GeomNames** no default This key specifies all of the geometries on which a different ChannelWidthY values will be assigned. ChannelWidthX may be assigned by **PFBFile** or **NCFile** as **Constant** by geometry. These geometries must cover the entire upper surface of the computational domain. .. container:: list :: run.ChannelWidthY.GeomNames = "domain" # Python syntax pfset ChannelWidthY.GeomNames "domain" # TCL syntax *string* **ChannelWidthX.Type** Constant This key specifies which method is to be used to assign ChannelWidthX. The choices currently available are **Constant** which indicates that a constant is to be assigned to all grid cells within a geometry, **PFBFile** which indicates that all values are read in from a distributed, grid-based ParFlow 2D binary file and **NCFile** which indicates that all values are read in from a netcdf file. .. container:: list :: run.ChannelWidthX.Type = "Constant" # Python syntax pfset ChannelWidthX.Type "Constant" # TCL syntax *double* **ChannelWidthX.Geom.\ *geometry_name*.Value** 0.0 This key specifies the value assigned to all points in the named geometry, *geometry_name*, if the type was set to constant. .. container:: list :: run.ChannelWidthX.Geom.domain.Value = 100 # Python syntax pfset ChannelWidthX.Geom.domain.Value 100 # TCL syntax *double* **ChannelWidthX.FileName** no default This key specifies the value assigned to all points be read in from a ParFlow 2D binary file or a netcdf file. .. container:: list :: run.ChannelWidthX.FileName = "channel_x.pfb" # Python syntax pfset ChannelWidthX.FileName "channel_x.pfb" # TCL syntax *string* **ChannelWidthY.Type** Constant This key specifies which method is to be used to assign ChannelWidthY. The choices currently available are **Constant** which indicates that a constant is to be assigned to all grid cells within a geometry, **PFBFile** which indicates that all values are read in from a distributed, grid-based ParFlow 2D binary file and **NCFile** which indicates that all values are read in from a netcdf file. .. container:: list :: run.ChannelWidthY.Type = "Constant" # Python syntax pfset ChannelWidthY.Type "Constant" # TCL syntax *double* **ChannelWidthY.Geom.\ *geometry_name*.Value** 0.0 This key specifies the value assigned to all points in the named geometry, *geometry_name*, if the type was set to constant. .. container:: list :: run.ChannelWidthY.Geom.domain.Value = 100 # Python syntax pfset ChannelWidthY.Geom.domain.Value 100 # TCL syntax *double* **ChannelWidthY.FileName** no default This key specifies the value assigned to all points be read in from a ParFlow 2D binary file or a netcdf file. .. container:: list :: run.ChannelWidthY.FileName = "channel_y.pfb" # Python syntax pfset ChannelWidthY.FileName "channel_y.pfb" # TCL syntax Example of setting :math:`x` and :math:`y` channelwidths by geometry: Example Usage (Python): :: run.ChannelWidthX.Type = "Constant" run.ChannelWidthX.GeomNames = "domain" run.ChannelWidthX.Geom.domain.Value = 100 run.ChannelWidthY.Type = "Constant" run.ChannelWidthY.GeomNames = "domain" run.ChannelWidthY.Geom.domain.Value = 100 Example Usage (TCL): :: pfset ChannelWidthX.Type "Constant" pfset ChannelWidthX.GeomNames "domain" pfset ChannelWidthX.Geom.domain.Value 100 pfset ChannelWidthY.Type "Constant" pfset ChannelWidthY.GeomNames "domain" pfset ChannelWidthY.Geom.domain.Value 100 Example of setting :math:`x` and :math:`y` channelwidths by file: Example Usage (Python): :: run.ChannelWidthX.Type = "PFBFile" run.ChannelWidthX.GeomNames = "domain" run.ChannelWidthX.FileName = "channel_x.pfb" run.ChannelWidthY.Type = "PFBFile" run.ChannelWidthY.GeomNames = "domain" run.ChannelWidthY.FileName = "channel_y.pfb" Example Usage (TCL): :: pfset ChannelWidthX.Type "PFBFile" pfset ChannelWidthX.GeomNames "domain" pfset ChannelWidthX.FileName "channel_x.pfb" pfset ChannelWidthY.Type "PFBFile" pfset ChannelWidthY.GeomNames "domain" pfset ChannelWidthY.FileName "channel_y.pfb" .. _Retardation: Retardation ~~~~~~~~~~~ Here, retardation values are assigned for contaminants within geounits (specified in `Geometries` above) using one of the functions described below. The format for this section of input is: *list* **Geom.Retardation.GeomNames** no default This key specifies all of the geometries to which the contaminants will have a retardation function applied. .. container:: list :: run.GeomInput.Names = "background" # Python syntax pfset GeomInput.Names "background" # TCL syntax *string* **Geom.\ *geometry_name*.\ *contaminant_name*.Retardation.Type** no default This key specifies which function is to be used to compute the retardation for the named contaminant, *contaminant_name*, in the named geometry, *geometry_name*. The only choice currently available is **Linear** which indicates that a simple linear retardation function is to be used to compute the retardation. .. container:: list :: run.Geom.background.tce.Retardation.Type = "Linear" # Python syntax pfset Geom.background.tce.Retardation.Type "Linear" # TCL syntax *double* **Geom.\ *geometry_name*.\ *contaminant_name*.Retardation.Value** no default This key specifies the distribution coefficient for the linear function used to compute the retardation of the named contaminant, *contaminant_name*, in the named geometry, *geometry_name*. The value should be scaled by the density of the material in the geometry. .. container:: list :: run.Geom.domain.Retardation.Value = 0.2 # Python syntax pfset Geom.domain.Retardation.Value 0.2 # TCL syntax Full Multiphase Mobilities ~~~~~~~~~~~~~~~~~~~~~~~~~~ Here we define phase mobilities by specifying the relative permeability function. Input is specified differently depending on what problem is being specified. For full multi-phase problems, the following input keys are used. See the next section for the correct Richards’ equation input format. *string* **Phase.\ *phase_name*.Mobility.Type** no default This key specifies whether the mobility for *phase_name* will be a given constant or a polynomial of the form, :math:`(S - S_0)^{a}`, where :math:`S` is saturation, :math:`S_0` is irreducible saturation, and :math:`a` is some exponent. The possibilities for this key are **Constant** and **Polynomial**. .. container:: list :: run.Phase.water.Mobility.Type = "Constant" # Python syntax pfset Phase.water.Mobility.Type "Constant" # TCL syntax *double* **Phase.\ *phase_name*.Mobility.Value** no default This key specifies the constant mobility value for phase *phase_name*. .. container:: list :: run.Phase.water.Mobility.Value = 1.0 # Python syntax pfset Phase.water.Mobility.Value 1.0 # TCL syntax *double* **Phase.\ *phase_name*.Mobility.Exponent** 2.0 This key specifies the exponent used in a polynomial representation of the relative permeability. Currently, only a value of :math:`2.0` is allowed for this key. .. container:: list :: run.Phase.water.Mobility.Exponent = 2.0 # Python syntax pfset Phase.water.Mobility.Exponent 2.0 # TCL syntax *double* **Phase.\ *phase_name*.Mobility.IrreducibleSaturation** 0.0 This key specifies the irreducible saturation used in a polynomial representation of the relative permeability. Currently, only a value of 0.0 is allowed for this key. .. container:: list :: run.Phase.water.Mobility.IrreducibleSaturation = 0.0 # Python syntax pfset Phase.water.Mobility.IrreducibleSaturation 0.0 # TCL syntax .. _Richards RelPerm: Richards’ Equation Relative Permeabilities ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The following keys are used to describe relative permeability input for the Richards’ equation implementation. They will be ignored if a full two-phase formulation is used. *string* **Phase.RelPerm.Type** no default This key specifies the type of relative permeability function that will be used on all specified geometries. Note that only one type of relative permeability may be used for the entire problem. However, parameters may be different for that type in different geometries. For instance, if the problem consists of three geometries, then **VanGenuchten** may be specified with three different sets of parameters for the three different geometries. However, once **VanGenuchten** is specified, one geometry cannot later be specified to have **Data** as its relative permeability. The possible values for this key are **Constant, VanGenuchten, Haverkamp, Data,** and **Polynomial**. .. container:: list :: run.Phase.RelPerm.Type = "Constant" # Python syntax pfset Phase.RelPerm.Type "Constant" # TCL syntax The various possible functions are defined as follows. The **Constant** specification means that the relative permeability will be constant on the specified geounit. The **VanGenuchten** specification means that the relative permeability will be given as a Van Genuchten function :cite:p:`VanGenuchten80` with the form, .. math:: \begin{aligned} k_r(p) = \frac{(1 - \frac{(\alpha p)^{n-1}}{(1 + (\alpha p)^n)^m})^2} {(1 + (\alpha p)^n)^{m/2}},\end{aligned} where :math:`\alpha` and :math:`n` are soil parameters and :math:`m = 1 - 1/n`, on each region. The **Haverkamp** specification means that the relative permeability will be given in the following form :cite:p:`Haverkamp-Vauclin81`, .. math:: \begin{aligned} k_r(p) = \frac{A}{A + p^{\gamma}},\end{aligned} where :math:`A` and :math:`\gamma` are soil parameters, on each region. The **Data** specification is currently unsupported but will later mean that data points for the relative permeability curve will be given and ParFlow will set up the proper interpolation coefficients to get values between the given data points. The **Polynomial** specification defines a polynomial relative permeability function for each region of the form, .. math:: \begin{aligned} k_r(p) = \sum_{i=0}^{degree} c_ip^i.\end{aligned} *list* **Phase.RelPerm.GeomNames** no default This key specifies the geometries on which relative permeability will be given. The union of these geometries must cover the entire computational domain. .. container:: list :: run.Phase.RelPerm.Geonames = "domain" # Python syntax pfset Phase.RelPerm.Geonames "domain" # TCL syntax *double* **Geom.\ *geom_name*.RelPerm.Value** no default This key specifies the constant relative permeability value on the specified geometry. .. container:: list :: run.Geom.domain.RelPerm.Value = 0.5 # Python syntax pfset Geom.domain.RelPerm.Value 0.5 # TCL syntax *integer* **Phase.RelPerm.VanGenuchten.File** 0 This key specifies whether soil parameters for the VanGenuchten function are specified in a ParFlow 3D binary file or by region. The options are either 0 for specification by region, or 1 for specification in a file. Note that either all parameters are specified in files (each has their own input file) or none are specified by files. Parameters specified by files are: :math:`\alpha` and N. .. container:: list :: run.Phase.RelPerm.VanGenuchten.File = 1 # Python syntax pfset Phase.RelPerm.VanGenuchten.File 1 # TCL syntax *string* **Geom.\ *geom_name*.RelPerm.Alpha.Filename** no default This key specifies a ParFlow binary filename containing the alpha parameters for the VanGenuchten function cell-by-cell. The ONLY option for *geom_name* is “domain”. .. container:: list :: run.Geom.domain.RelPerm.Alpha.Filename = "alphas.pfb" # Python syntax pfset Geom.domain.RelPerm.Alpha.Filename "alphas.pfb" # TCL syntax *string* **Geom.\ *geom_name*.RelPerm.N.Filename** no default This key specifies a ParFlow binary filename containing the N parameters for the VanGenuchten function cell-by-cell. The ONLY option for *geom_name* is “domain”. .. container:: list :: run.Geom.domain.RelPerm.N.Filename = "Ns.pfb" # Python syntax pfset Geom.domain.RelPerm.N.Filename "Ns.pfb" # TCL syntax *double* **Geom.\ *geom_name*.RelPerm.Alpha** no default This key specifies the :math:`\alpha` parameter for the Van Genuchten function specified on *geom_name*. .. container:: list :: run.Geom.domain.RelPerm.Alpha = 0.005 # Python syntax pfset Geom.domain.RelPerm.Alpha 0.005 # TCL syntax *double* **Geom.\ *geom_name*.RelPerm.N** no default This key specifies the :math:`N` parameter for the Van Genuchten function specified on *geom_name*. .. container:: list :: run.Geom.domain.RelPerm.N = 2.0 # Python syntax pfset Geom.domain.RelPerm.N 2.0 # TCL syntax *int* **Geom.\ *geom_name*.RelPerm.NumSamplePoints** 0 This key specifies the number of sample points for a spline base interpolation table for the Van Genuchten function specified on *geom_name*. If this number is 0 (the default) then the function is evaluated directly. Using the interpolation table is faster but is less accurate. .. container:: list :: run.Geom.domain.RelPerm.NumSamplePoints = 20000 # Python syntax pfset Geom.domain.RelPerm.NumSamplePoints 20000 # TCL syntax *int* **Geom.\ *geom_name*.RelPerm.MinPressureHead** no default This key specifies the lower value for a spline base interpolation table for the Van Genuchten function specified on *geom_name*. The upper value of the range is 0. This value is used only when the table lookup method is used (*NumSamplePoints* is greater than 0). .. container:: list :: run.Geom.domain.RelPerm.MinPressureHead = -300 # Python syntax pfset Geom.domain.RelPerm.MinPressureHead -300 # TCL syntax *double* **Geom.\ *geom_name*.RelPerm.A** no default This key specifies the :math:`A` parameter for the Haverkamp relative permeability on *geom_name*. .. container:: list :: run.Geom.domain.RelPerm.A = 1.0 # Python syntax pfset Geom.domain.RelPerm.A 1.0 # TCL syntax *double* **Geom.\ *geom_name*.RelPerm.Gamma** no default This key specifies the the :math:`\gamma` parameter for the Haverkamp relative permeability on *geom_name*. .. container:: list :: run.Geom.domain.RelPerm.Gamma = 1.0 # Python syntax pfset Geom.domain.RelPerm.Gamma 1.0 # TCL syntax *integer* **Geom.\ *geom_name*.RelPerm.Degree** no default This key specifies the degree of the polynomial for the Polynomial relative permeability given on *geom_name*. .. container:: list :: run.Geom.domain.RelPerm.Degree = 1 # Python syntax pfset Geom.domain.RelPerm.Degree 1 # TCL syntax *double* **Geom.\ *geom_name*.RelPerm.Coeff.\ *coeff_number*** no default This key specifies the *coeff_number*\ th coefficient of the Polynomial relative permeability given on *geom_name*. Example Usage (Python): :: run.Geom.domain.RelPerm.Coeff._0 = 0.5 run.Geom.domain.RelPerm.Coeff._1 = 1.0 run.Geom.domain.RelPerm.Coeff.0 = 0.5 run.Geom.domain.RelPerm.Coeff.1 = 1.0 Example Usage (TCL): :: pfset Geom.domain.RelPerm.Coeff.0 0.5 pfset Geom.domain.RelPerm.Coeff.1 1.0 pfset Geom.domain.RelPerm.Coeff.0 0.5 pfset Geom.domain.RelPerm.Coeff.1 1.0 NOTE: For all these cases, if only one region is to be used (the domain), the background region should NOT be set as that single region. Using the background will prevent the upstream weighting from being correct near Dirichlet boundaries. .. _Phase Sources: Phase Sources ~~~~~~~~~~~~~ The following keys are used to specify phase source terms. The units of the source term are :math:`1/T`. So, for example, to specify a region with constant flux rate of :math:`L^3/T`, one must be careful to convert this rate to the proper units by dividing by the volume of the enclosing region. For *Richards’ equation* input, the source term must be given as a flux multiplied by density. *string* **PhaseSources.\ *phase_name*.Type** no default This key specifies the type of source to use for phase *phase_name*. Possible values for this key are **Constant** and **PredefinedFunction**. **Constant** type phase sources specify a constant phase source value for a given set of regions. **PredefinedFunction** type phase sources use a preset function (choices are listed below) to specify the source. Note that the **PredefinedFunction** type can only be used to set a single source over the entire domain and not separate sources over different regions. .. container:: list :: run.PhaseSources.water.Type = "Constant" # Python syntax pfset PhaseSources.water.Type "Constant" # TCL syntax *list* **PhaseSources.\ *phase_name*.GeomNames** no default This key specifies the names of the geometries on which source terms will be specified. This is used only for **Constant** type phase sources. Regions listed later “overlay” regions listed earlier. .. container:: list :: run.PhaseSources.water.GeomNames = "bottomlayer middlelayer toplayer" # Python syntax pfset PhaseSources.water.GeomNames "bottomlayer middlelayer toplayer" # TCL syntax *double* **PhaseSources.\ *phase_name*.Geom.\ *geom_name*.Value** no default This key specifies the value of a constant source term applied to phase *phase \_name* on geometry *geom_name*. .. container:: list :: run.PhaseSources.water.Geom.toplayer.Value = 1.0 # Python syntax pfset PhaseSources.water.Geom.toplayer.Value 1.0 # TCL syntax *string* **PhaseSources.\ *phase_name*.PredefinedFunction** no default This key specifies which of the predefined functions will be used for the source. Possible values for this key are **X, XPlusYPlusZ, X3Y2PlusSinXYPlus1,** and **XYZTPlus1PermTensor**. .. container:: list :: run.PhaseSources.water.PredefinedFunction = "XPlusYPlusZ" # Python syntax pfset PhaseSources.water.PredefinedFunction "XPlusYPlusZ" # TCL syntax The choices for this key correspond to sources as follows: **X**: :math:`{\rm source}\; = 0.0` **XPlusYPlusX**: :math:`{\rm source}\; = 0.0` **X3Y2PlusSinXYPlus1**: | :math:`{\rm source}\; = -(3x^2 y^2 + y\cos(xy))^2 - (2x^3 y + x\cos(xy))^2 - (x^3 y^2 + \sin(xy) + 1) (6x y^2 + 2x^3 -(x^2 +y^2) \sin(xy))` | This function type specifies that the source applied over the entire domain is as noted above. This corresponds to :math:`p=x^{3}y^{2}+\sin(xy)+1` in the problem :math:`-\nabla\cdot (p\nabla p)=f`. **X3Y4PlusX2PlusSinXYCosYPlus1**: | :math:`{\rm source}\; = -(3x^22 y^4 + 2x + y\cos(xy)\cos(y))^2 - (4x^3 y^3 + x\cos(xy)\cos(y) - \sin(xy)\sin(y))^2 - (x^3 y^4 + x^2 + \sin(xy)\cos(y) + 1) (6xy^4 + 2 - (x^2 + y^2 + 1)\sin(xy)\cos(y) + 12x^3 y^2 - 2x\cos(xy)\sin(y))` | This function type specifies that the source applied over the entire domain is as noted above. This corresponds to :math:`p=x^{3}y^{4}+x^{2}+\sin (xy)\cos(y) +1` in the problem :math:`-\nabla\cdot (p\nabla p)=f`. **XYZTPlus1**: | :math:`{\rm source}\; = xyz - t^2 (x^2 y^2 +x^2 z^2 +y^2 z^2)` | This function type specifies that the source applied over the entire domain is as noted above. This corresponds to :math:`p = xyzt + 1` in the problem :math:`\frac{\partial p}{\partial t}-\nabla\cdot (p\nabla p)=f`. **XYZTPlus1PermTensor**: | :math:`{\rm source}\; = xyz - t^2 (x^2 y^2 3 + x^2 z^2 2 + y^2 z^2)` | This function type specifies that the source applied over the entire domain is as noted above. This corresponds to :math:`p = xyzt + 1` in the problem :math:`\frac{\partial p}{\partial t}-\nabla\cdot (Kp\nabla p)=f`, where :math:`K = diag(1 \;\; 2 \;\; 3)`. .. _Capillary Pressures: Capillary Pressures ~~~~~~~~~~~~~~~~~~~ Here we define capillary pressure. Note: this section needs to be defined *only* for multi-phase flow and should not be defined for single phase and Richards’ equation cases. The format for this section of input is: *string* **CapPressure.\ *phase_name*.Type** "Constant" This key specifies the capillary pressure between phase :math:`0` and the named phase, *phase_name*. The only choice available is **Constant** which indicates that a constant capillary pressure exists between the phases. .. container:: list :: run.CapPressure.water.Type = "Constant" # Python syntax pfset CapPressure.water.Type "Constant" # TCL syntax *list* **CapPressure.\ *phase_name*.GeomNames** no default This key specifies the geometries that capillary pressures will be computed for in the named phase, *phase_name*. Regions listed later “overlay” regions listed earlier. Any geometries not listed will be assigned :math:`0.0` capillary pressure by ParFlow. .. container:: list :: run.CapPressure.water.GeomNames = "domain" # Python syntax pfset CapPressure.water.GeomNames "domain" # TCL syntax *double* **Geom.\ *geometry_name*.CapPressure.\ *phase_name*.Value** 0.0 This key specifies the value of the capillary pressure in the named geometry, *geometry_name*, for the named phase, *phase_name*. .. container:: list :: run.Geom.domain.CapPressure.water.Value = 0.0 # Python syntax pfset Geom.domain.CapPressure.water.Value 0.0 # TCL syntax *Important note*: the code currently works only for capillary pressure equal zero. .. _Saturation: Saturation ~~~~~~~~~~ This section is *only* relevant to the Richards’ equation cases. All keys relating to this section will be ignored for other cases. The following keys are used to define the saturation-pressure curve. *string* **Phase.Saturation.Type** no default This key specifies the type of saturation function that will be used on all specified geometries. Note that only one type of saturation may be used for the entire problem. However, parameters may be different for that type in different geometries. For instance, if the problem consists of three geometries, then **VanGenuchten** may be specified with three different sets of parameters for the three different geometries. However, once **VanGenuchten** is specified, one geometry cannot later be specified to have **Data** as its saturation. The possible values for this key are **Constant, VanGenuchten, Haverkamp, Data, Polynomial** and **PFBFile**. .. container:: list :: run.Phase.Saturation.Type = "Constant" # Python syntax pfset Phase.Saturation.Type "Constant" # TCL syntax The various possible functions are defined as follows. The **Constant** specification means that the saturation will be constant on the specified geounit. The **VanGenuchten** specification means that the saturation will be given as a Van Genuchten function :cite:p:`VanGenuchten80` with the form, .. math:: \begin{aligned} s(p) = \frac{s_{sat} - s_{res}}{(1 + (\alpha p)^n)^m} + s_{res},\end{aligned} where :math:`s_{sat}` is the saturation at saturated conditions, :math:`s_{res}` is the residual saturation, and :math:`\alpha` and :math:`n` are soil parameters with :math:`m = 1 - 1/n`, on each region. The **Haverkamp** specification means that the saturation will be given in the following form :cite:p:`Haverkamp-Vauclin81`, .. math:: \begin{aligned} s(p) = \frac{\A(s_{sat} - s_{res})}{A + p^{\gamma}} + s_{res},\end{aligned} where :math:`A` and :math:`\gamma` are soil parameters, on each region. The **Data** specification is currently unsupported but will later mean that data points for the saturation curve will be given and ParFlow will set up the proper interpolation coefficients to get values between the given data points. The **Polynomial** specification defines a polynomial saturation function for each region of the form, .. math:: \begin{aligned} s(p) = \sum_{i=0}^{degree} c_ip^i.\end{aligned} The **PFBFile** specification means that the saturation will be taken as a spatially varying but constant in pressure function given by data in a ParFlow 3D binary file. *list* **Phase.Saturation.GeomNames** no default This key specifies the geometries on which saturation will be given. The union of these geometries must cover the entire computational domain. .. container:: list :: run.Phase.Saturation.Geonames = "domain" # Python syntax pfset Phase.Saturation.Geonames "domain" # TCL syntax *double* **Geom.\ *geom_name*.Saturation.Value** no default This key specifies the constant saturation value on the *geom_name* region. .. container:: list :: run.Geom.domain.Saturation.Value = 0.5 # Python syntax pfset Geom.domain.Saturation.Value 0.5 # TCL syntax *integer* **Phase.Saturation.VanGenuchten.File** 0 This key specifies whether soil parameters for the VanGenuchten function are specified in a ParFlow 3D binary file or by region. The options are either 0 for specification by region, or 1 for specification in a file. Note that either all parameters are specified in files (each has their own input file) or none are specified by files. Parameters specified by files are :math:`\alpha`, N, SRes, and SSat. .. container:: list :: run.Phase.Saturation.VanGenuchten.File = 1 # Python syntax pfset Phase.Saturation.VanGenuchten.File 1 # TCL syntax *string* **Geom.\ *geom_name*.Saturation.Alpha.Filename** no default This key specifies a ParFlow binary filename containing the alpha parameters for the VanGenuchten function cell-by-cell. The ONLY option for *geom_name* is “domain”. .. container:: list :: .00.0000.pfb`` when using ParFlow’s saturated solver and ``run.out.vel.00000.pfb`` when using the Richards equation solver. :: run.Solver.PrintVelocities = True # Python syntax pfset Solver.PrintVelocities True # TCL syntax *string* **Solver.PrintSaturation** True This key is used to turn on printing of the saturation data. The printing of the data is controlled by values in the timing information section. The data is written as a ParFlow binary file. .. container:: list :: run.Solver.PrintSaturation = False # Python syntax pfset Solver.PrintSaturation False # TCL syntax *string* **Solver.PrintQxOverland** False This key is used to turn on printing of the x-direction overland flow data. The printing of the data is controlled by values in the timing information section. The data is written as a 2D ParFlow binary file with dimensions [NY, NX]. The values represent the x-direction surface flow velocity (ke_) in m/hr. For OverlandKinematic and OverlandDiffusive, values are located at cell edges (x-faces). For OverlandFlow, values are located at cell centers. To convert to volumetric flux, multiply by dy and dt. This key produces files in the format ``run.out.qx_overland.00000.pfb``. .. container:: list :: run.Solver.PrintQxOverland = True # Python syntax pfset Solver.PrintQxOverland True # TCL syntax *string* **Solver.PrintQyOverland** False This key is used to turn on printing of the y-direction overland flow data. The printing of the data is controlled by values in the timing information section. The data is written as a 2D ParFlow binary file with dimensions [NY, NX]. The values represent the y-direction surface flow velocity (kn_) in m/hr. For OverlandKinematic and OverlandDiffusive, values are located at cell edges (y-faces). For OverlandFlow, values are located at cell centers. To convert to volumetric flux, multiply by dx and dt. This key produces files in the format ``run.out.qy_overland.00000.pfb``. .. container:: list :: run.Solver.PrintQyOverland = True # Python syntax pfset Solver.PrintQyOverland True # TCL syntax *string* **Solver.PrintConcentration** True This key is used to turn on printing of the concentration data. The printing of the data is controlled by values in the timing information section. The data is written as a PFSB file. .. container:: list :: run.Solver.PrintConcentration = False # Python syntax pfset Solver.PrintConcentration False # TCL syntax *string* **Solver.PrintTop** False This key is used to turn on printing of the top of domain data. 'TopZIndex' is a NX * NY file with the Z index of the top of the domain. 'TopPatch' is the Patch index for the top of the domain. A value of -1 indicates an (i,j) column does not intersect the domain. The data is written as a ParFlow binary file. .. container:: list :: run.Solver.PrintTop = False # Python syntax pfset Solver.PrintTop False # TCL syntax *string* **Solver.PrintBottom** False This key is used to turn on printing of the bottom of domain data. 'BottomZIndex' is a NX * NY file with the Z index of the top of the domain. A value of -1 indicates an (i,j) column does not intersect the domain.The data is written as a ParFlow binary file. .. container:: list :: run.Solver.PrintBottom = False # Python syntax pfset Solver.PrintBottom False # TCL syntax *string* **Solver.PrintWells** True This key is used to turn on collection and printing of the well data. The data is collected at intervals given by values in the timing information section. Printing occurs at the end of the run when all collected data is written. .. container:: list :: run.Solver.PrintWells = False # Python syntax pfset Solver.PrintWells False # TCL syntax *string* **Solver.PrintReservoirs** True This key is used to turn on collection and printing of the reservoir data. The data is collected at intervals given by values in the timing information section. Printing occurs at the end of the run when all collected data is written. .. container:: list :: run.Solver.PrintReservoirs = False # Python syntax pfset Solver.PrintReservoirs False # TCL syntax *string* **Solver.PrintLSMSink** False This key is used to turn on printing of the flux array passed from ``CLM`` to ParFlow. Printing occurs at each **DumpInterval** time. .. container:: list :: run.Solver.PrintLSMSink = True # Python syntax pfset Solver.PrintLSMSink True # TCL syntax *string* **Solver.WriteSiloSubsurfData** False This key is used to specify printing of the subsurface data, Permeability and Porosity in silo binary file format. The data is printed after it is generated and before the main time stepping loop - only once during the run. This data may be read in by VisIT and other visualization packages. .. container:: list :: run.Solver.WriteSiloSubsurfData = True # Python syntax pfset Solver.WriteSiloSubsurfData True # TCL syntax *string* **Solver.WriteSiloPressure** False This key is used to specify printing of the saturation data in silo binary format. The printing of the data is controlled by values in the timing information section. This data may be read in by VisIT and other visualization packages. .. container:: list :: run.Solver.WriteSiloPressure = True # Python syntax pfset Solver.WriteSiloPressure True # TCL syntax *string* **Solver.WriteSiloSaturation** False This key is used to specify printing of the saturation data using silo binary format. The printing of the data is controlled by values in the timing information section. .. container:: list :: run.Solver.WriteSiloSaturation = True # Python syntax pfset Solver.WriteSiloSaturation True # TCL syntax *string* **Solver.WriteSiloConcentration** False This key is used to specify printing of the concentration data in silo binary format. The printing of the data is controlled by values in the timing information section. .. container:: list :: run.Solver.WriteSiloConcentration = True # Python syntax pfset Solver.WriteSiloConcentration True # TCL syntax *string* **Solver.WriteSiloVelocities** False This key is used to specify printing of the x, y and z velocity data in silo binary format. The printing of the data is controlled by values in the timing information section. .. container:: list :: run.Solver.WriteSiloVelocities = True # Python syntax pfset Solver.WriteSiloVelocities True # TCL syntax *string* **Solver.WriteSiloQxOverland** False This key is used to specify printing of the x-direction overland flow data in silo binary format. The printing of the data is controlled by values in the timing information section. The values represent x-direction surface flow velocity (ke_) in m/hr. For OverlandKinematic and OverlandDiffusive, values are located at cell edges (x-faces). For OverlandFlow, values are located at cell centers. .. container:: list :: run.Solver.WriteSiloQxOverland = True # Python syntax pfset Solver.WriteSiloQxOverland True # TCL syntax *string* **Solver.WriteSiloQyOverland** False This key is used to specify printing of the y-direction overland flow data in silo binary format. The printing of the data is controlled by values in the timing information section. The values represent y-direction surface flow velocity (kn_) in m/hr. For OverlandKinematic and OverlandDiffusive, values are located at cell edges (y-faces). For OverlandFlow, values are located at cell centers. .. container:: list :: run.Solver.WriteSiloQyOverland = True # Python syntax pfset Solver.WriteSiloQyOverland True # TCL syntax *string* **Solver.WriteSiloSlopes** False This key is used to specify printing of the x and y slope data using silo binary format. The printing of the data is controlled by values in the timing information section. .. container:: list :: run.Solver.WriteSiloSlopes = True # Python syntax pfset Solver.WriteSiloSlopes True # TCL syntax *string* **Solver.WriteSiloMannings** False This key is used to specify printing of the Manning’s roughness data in silo binary format. The printing of the data is controlled by values in the timing information section. .. container:: list :: run.Solver.WriteSiloMannings = True # Python syntax pfset Solver.WriteSiloMannings True # TCL syntax *string* **Solver.WriteSiloSpecificStorage** False This key is used to specify printing of the specific storage data in silo binary format. The printing of the data is controlled by values in the timing information section. .. container:: list :: run.Solver.WriteSiloSpecificStorage = True # Python syntax pfset Solver.WriteSiloSpecificStorage True # TCL syntax *string* **Solver.WriteSiloMask** False This key is used to specify printing of the mask data using silo binary format. The mask contains values equal to one for active cells and zero for inactive cells. The printing of the data is controlled by values in the timing information section. .. container:: list :: run.Solver.WriteSiloMask = True # Python syntax pfset Solver.WriteSiloMask True # TCL syntax *string* **Solver.WriteSiloEvapTrans** False This key is used to specify printing of the evaporation and rainfall flux data using silo binary format. This data comes from either ``clm`` or from external calls to ParFlow such as WRF. This data is in units of :math:`[L^3 T^{-1}]`. The printing of the data is controlled by values in the timing information section. .. container:: list :: run.Solver.WriteSiloEvapTrans = True # Python syntax pfset Solver.WriteSiloEvapTrans True # TCL syntax *string* **Solver.WriteSiloEvapTransSum** False This key is used to specify printing of the evaporation and rainfall flux data using silo binary format as a running, cumulative amount. This data comes from either ``clm`` or from external calls to ParFlow such as WRF. This data is in units of :math:`[L^3]`. The printing of the data is controlled by values in the timing information section. .. container:: list :: run.Solver.WriteSiloEvapTransSum = True # Python syntax pfset Solver.WriteSiloEvapTransSum True # TCL syntax *string* **Solver.WriteSiloOverlandSum** False This key is used to specify calculation and printing of the total overland outflow from the domain using silo binary format as a running cumulative amount. This is integrated along all domain boundaries and is calculated any location that slopes at the edge of the domain point outward. This data is in units of :math:`[L^3]`. The printing of the data is controlled by values in the timing information section. .. container:: list :: run.Solver.WriteSiloOverlandSum = True # Python syntax pfset Solver.WriteSiloOverlandSum True # TCL syntax *string* **Solver.WriteSiloTop** False Key used to control writing of two Silo files for the top of the domain. 'TopZIndex' is a NX * NY file with the Z index of the top of the domain. 'TopPatch' is the Patch index for the top of the domain. A value of -1 indicates an (i,j) column does not intersect the domain. .. container:: list :: run.Solver.WriteSiloTop = True # Python syntax pfset Solver.WriteSiloTop True # TCL syntax *string* **Solver.WriteSiloBottom** False Key used to control writing of one Silo file for the bottom of the domain. 'BottomZIndex' is a NX * NY file with the Z index of the bottom of the domain. A value of -1 indicates an (i,j) column does not intersect the domain. .. container:: list :: run.Solver.WriteSiloBottom = True # Python syntax pfset Solver.WriteSiloBottom True # TCL syntax *string* **Solver.WritePDISubsurfData** False This key is used to specify exposing of the subsurface data, Permeability and Porosity to PDI library. The data is exposed after it is generated and before the main time stepping loop - only once during the run. The data is subsequently managed by the PDI plugin according to the specification tree defined in conf.yaml. .. container:: list :: run.Solver.WritePDISubsurfData = True # Python syntax pfset Solver.WritePDISubsurfData True # TCL syntax *string* **Solver.WritePDIMannings** False This key is used to specify exposing of Manning’s roughness data to PDI library. The data exposure is controlled by values in the timing information section and is subsequently managed by the PDI plugin according to the specification tree defined in conf.yaml. .. container:: list :: run.Solver.WritePDIMannings = True # Python syntax pfset Solver.WritePDIMannings True # TCL syntax *string* **Solver.WritePDISlopes** False This key is used to turn on exposure of x and y slope data to PDI library. The data exposure is controlled by values in the timing information section and is subsequently managed by the PDI plugin according to the specification tree defined in conf.yaml. .. container:: list :: run.Solver.WritePDISlopes = True # Python syntax pfset Solver.WritePDISlopes True # TCL syntax *string* **Solver.WritePDIPressure** False This key is used to specify exposure of pressure data to PDI library. The data exposure is controlled by values in the timing information section and is subsequently managed by the PDI plugin according to the specification tree defined in conf.yaml. .. container:: list :: run.Solver.WritePDIPressure = True # Python syntax pfset Solver.WritePDIPressure True # TCL syntax *string* **Solver.WritePDISpecificStorage** False This key is used to specify exposure of specific storage data to PDI library. The data exposure is controlled by values in the timing information section and is subsequently managed by the PDI plugin according to the specification tree defined in conf.yaml. .. container:: list :: run.Solver.WritePDISpecificStorage = True # Python syntax pfset Solver.WritePDISpecificStorage True # TCL syntax *string* **Solver.WritePDIVelocities** False This key is used to turn on exposure of x,y,and z velocity data to PDI library. The data exposure is controlled by values in the timing information section and is subsequently managed by the PDI plugin according to the specification tree defined in conf.yaml. .. container:: list :: run.Solver.WritePDIVelocities = True # Python syntax pfset Solver.WritePDIVelocities True # TCL syntax *string* **Solver.WritePDIQxOverland** False This key is used to specify exposure of x-direction overland flow data to PDI library. The values represent x-direction surface flow velocity (ke_) in m/hr. For OverlandKinematic and OverlandDiffusive, values are located at cell edges (x-faces). For OverlandFlow, values are located at cell centers. The data exposure is controlled by values in the timing information section and is subsequently managed by the PDI plugin according to the specification tree defined in conf.yaml. .. container:: list :: run.Solver.WritePDIQxOverland = True # Python syntax pfset Solver.WritePDIQxOverland True # TCL syntax *string* **Solver.WritePDIQyOverland** False This key is used to specify exposure of y-direction overland flow data to PDI library. The values represent y-direction surface flow velocity (kn_) in m/hr. For OverlandKinematic and OverlandDiffusive, values are located at cell edges (y-faces). For OverlandFlow, values are located at cell centers. The data exposure is controlled by values in the timing information section and is subsequently managed by the PDI plugin according to the specification tree defined in conf.yaml. .. container:: list :: run.Solver.WritePDIQyOverland = True # Python syntax pfset Solver.WritePDIQyOverland True # TCL syntax *string* **Solver.WritePDISaturation** False This key is used to specify exposre of the saturation data to PDI library. The data exposure is controlled by values in the timing information section and is subsequently managed by the PDI plugin according to the specification tree defined in conf.yaml. .. container:: list :: run.Solver.WritePDISaturation = True # Python syntax pfset Solver.WritePDISaturation True # TCL syntax *string* **Solver.WritePDIMask** False This key is used to specify exposure of mask data to PDI library. The mask contains values equal to one for active cells and zero for inactive cells. The data exposure is controlled by values in the timing information section and is subsequently managed by the PDI plugin according to the specification tree defined in conf.yaml. .. container:: list :: run.Solver.WritePDIMask = True # Python syntax pfset Solver.WritePDIMask True # TCL syntax *string* **Solver.WritePDIDZMultiplier** False This key is used to specifiy the exposrue of DZ multipliers to PDI library. .. container:: list :: run.Solver.WritePDIDZMultiplier = True # Python syntax pfset Solver.WritePDIDZMultiplier True # TCL syntax *string* **Solver.WritePDIEvapTransSum** False This key is used to specify exposure of evaporation and rainfall flux data to PDI libraary, cumulative amount. This data comes from either clm or from external calls to ParFlow such as run.WRF = "This data is in units of :math:`[L3]`. The data exposure is controlled" by values in the timing information section and is subsequently managed by the PDI plugin according to the specification tree defined in conf.yaml. .. container:: list :: run.Solver.WritePDIEvapTransSum = True # Python syntax pfset Solver.WritePDIEvapTransSum True # TCL syntax *string* **Solver.WritePDIEvapTrans** False This key is used to specify exposure of the evaporation and rainfall flux data to PDI library. This data comes from either clm or from external calls to ParFlow such as WRF. This data is in units of :math:`[L3T-1]`. The data exposure is controlled by values in the timing information section and is subsequently managed by the PDI plugin according to the specification tree defined in conf.yaml. .. container:: list :: run.Solver.WritePDIEvapTrans = True # Python syntax pfset Solver.WritePDIEvapTrans True # TCL syntax *string* **Solver.WritePDIOverlandSum** False This key is used to specify calculation and exposrue of the total overland outflow from the domain PDI library as a running cumulative amount. This is integrated along all domain boundaries and is calculated any location that slopes at the edge of the domain point outward. This data is in units of :math:`[L^3]`. The data exposure is controlled by values in the timing information section and is subsequently managed by the PDI plugin according to the specification tree defined in conf.yaml. .. container:: list :: run.Solver.WritePDIOverlandSum = True # Python syntax pfset Solver.WritePDIOverlandSum True # TCL syntax *string* **Solver.WritePDIOverlandBCFlux** False This key is used to specify the expousre of overland bc flux to PDI library. .. container:: list :: run.Solver.WritePDIOverlandBCFlux = True # Python syntax pfset Solver.WritePDIOverlandBCFlux True # TCL syntax *string* **Solver.WritePDIWells** False This key is used to specify the expousre of wells data to PDI library. .. container:: list :: run.Solver.WritePDIWells = True # Python syntax pfset Solver.WritePDIWells True # TCL syntax *string* **Solver.WritePDIConcentration** False This key is used to specify the exposure of concentration data to PDI library. The data exposure is controlled by values in the timing information section. .. container:: list :: run.Solver.WritePDIConcentration = True # Python syntax pfset Solver.WritePDIConcentration True # TCL syntax *string* **Solver.TerrainFollowingGrid** False This key specifies that a terrain-following coordinate transform is used for solver Richards. This key sets x and y subsurface slopes to be the same as the Topographic slopes (a value of False sets these subsurface slopes to zero). These slopes are used in the Darcy fluxes to add a density, gravity -dependent term. This key will not change the output files (that is the output is still orthogonal) or the geometries (they will still follow the computational grid)– these two things are both to do items. This key only changes solver Richards, not solver Impes. .. container:: list :: run.Solver.TerrainFollowingGrid = True # Python syntax pfset Solver.TerrainFollowingGrid True # TCL syntax *string* **Solver.TerrainFollowingGrid.SlopeUpwindFormulation** Original This key specifies optional modifications to the terrain following grid formulation described in :ref:`TFG`. Choices for this key are **Original, Upwind, UpwindSine**. **Original** is the original TFG formulation documented in :cite:p:`M13`. The **Original** option calculates the :math:`\theta_x` and :math:`\theta_y` for a cell face as the average of the two adjacent cell slopes (i.e. assuming a cell centered slope calculation). The **Upwind** option uses the the :math:`\theta_x` and :math:`\theta_y` of a cell directly without averaging (i.e. assuming a face centered slope calculation). The **UpwindSine** is the same as the **Upwind** option but it also removes the Sine term from the TFG Darcy Formulation (in :ref:`TFG`). Note the **UpwindSine** option is for experimental purposes only and should not be used in standard simulations. Also note that the choice of **upwind** or **Original** formulation should consistent with the choice of overland flow boundary condition if overland flow is being used. The **upwind** and **UpwindSine** are consistent with **OverlandDiffusive** and **OverlandKinematic** while **Original** is consistent with **OverlandFow** :: run.Solver.TerrainFollowingGrid.SlopeUpwindFormulation = "Upwind" # Python syntax pfset Solver.TerrainFollowingGrid.SlopeUpwindFormulation "Upwind" # TCL syntax .. _SILO Options: SILO Options ~~~~~~~~~~~~ The following keys are used to control how SILO writes data. SILO allows writing to PDB and HDF5 file formats. SILO also allows data compression to be used, which can save signicant amounts of disk space for some problems. *string* **SILO.Filetype** PDB This key is used to specify the SILO filetype. Allowed values are PDB and HDF5. Note that you must have configured SILO with HDF5 in order to use that option. .. container:: list :: run.SILO.Filetype = "PDB" # Python syntax pfset SILO.Filetype "PDB" # TCL syntax *string* **SILO.CompressionOptions** This key is used to specify the SILO compression options. See the SILO manual for the DB_SetCompression command for information on available options. NOTE: the options available are highly dependent on the configure options when building SILO. .. container:: list :: run.SILO.CompressionOptions = "METHOD=GZIP" # Python syntax pfset SILO.CompressionOptions "METHOD=GZIP" # TCL syntax .. _RE Solver Parameters: Richards’ Equation Solver Parameters ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The following keys are used to specify various parameters used by the linear and nonlinear solvers in the Richards’ equation implementation. For information about these solvers, see :cite:t:`Woodward98` and :cite:t:`Ashby-Falgout90`. *double* **Solver.Nonlinear.ResidualTol** 1e-7 This key specifies the tolerance that measures how much the relative reduction in the nonlinear residual should be before nonlinear iterations stop. The magnitude of the residual is measured with the :math:`l^1` (max) norm. .. container:: list :: run.Solver.Nonlinear.ResidualTol = 1e-4 # Python syntax pfset Solver.Nonlinear.ResidualTol 1e-4 # TCL syntax *double* **Solver.Nonlinear.StepTol** 1e-7 This key specifies the tolerance that measures how small the difference between two consecutive nonlinear steps can be before nonlinear iterations stop. .. container:: list :: run.Solver.Nonlinear.StepTol = 1e-4 # Python syntax pfset Solver.Nonlinear.StepTol 1e-4 # TCL syntax *integer* **Solver.Nonlinear.MaxIter** 15 This key specifies the maximum number of nonlinear iterations allowed before iterations stop with a convergence failure. .. container:: list :: run.Solver.Nonlinear.MaxIter = 50 # Python syntax pfset Solver.Nonlinear.MaxIter 50 # TCL syntax *integer* **Solver.Linear.KrylovDimension** 10 This key specifies the maximum number of vectors to be used in setting up the Krylov subspace in the GMRES iterative solver. These vectors are of problem size and it should be noted that large increases in this parameter can limit problem sizes. However, increasing this parameter can sometimes help nonlinear solver convergence. .. container:: list :: run.Solver.Linear.KrylovDimension = 15 # Python syntax pfset Solver.Linear.KrylovDimension 15 # TCL syntax *integer* **Solver.Linear.MaxRestarts** 0 This key specifies the number of restarts allowed to the GMRES solver. Restarts start the development of the Krylov subspace over using the current iterate as the initial iterate for the next pass. .. container:: list :: run.Solver.Linear.MaxRestarts = 2 # Python syntax pfset Solver.Linear.MaxRestarts 2 # TCL syntax *integer* **Solver.MaxConvergenceFailures** 3 This key gives the maximum number of convergence failures allowed. Each convergence failure cuts the timestep in half and the solver tries to advance the solution with the reduced timestep. The default value is 3. Note that setting this value to a value greater than 9 may result in errors in how time cycles are calculated. Time is discretized in terms of the base time unit and if the solver begins to take very small timesteps :math:`smaller than base time unit 1000` the values based on time cycles will be change at slightly incorrect times. If the problem is failing converge so poorly that a large number of restarts are required, consider setting the timestep to a smaller value. .. container:: list :: run.Solver.MaxConvergenceFailures = 4 # Python syntax pfset Solver.MaxConvergenceFailures 4 # TCL syntax *string* **Solver.Nonlinear.PrintFlag** HighVerbosity This key specifies the amount of informational data that is printed to the ``*.out.kinsol.log`` file. Choices for this key are **NoVerbosity**, **LowVerbosity**, **NormalVerbosity** and **HighVerbosity**. The choice **NoVerbosity** prints no statistics about the nonlinear convergence process. The choice **LowVerbosity** outputs the nonlinear iteration count, the scaled norm of the nonlinear function, and the number of function calls. The choice **NormalVerbosity** prints the same as for **LowVerbosity** and also the global strategy statistics. The choice **HighVerbosity** prints the same as for **NormalVerbosity** with the addition of further Krylov iteration statistics. .. container:: list :: run.Solver.Nonlinear.PrintFlag = "NormalVerbosity" # Python syntax pfset Solver.Nonlinear.PrintFlag "NormalVerbosity" # TCL syntax *string* **Solver.Nonlinear.EtaChoice** Walker2 This key specifies how the linear system tolerance will be selected. The linear system is solved until a relative residual reduction of :math:`\eta` is achieved. Linear residual norms are measured in the :math:`l^2` norm. Choices for this key include **EtaConstant, Walker1** and **Walker2**. If the choice **EtaConstant** is specified, then :math:`\eta` will be taken as constant. The choices **Walker1** and **Walker2** specify choices for :math:`\eta` developed by Eisenstat and Walker :cite:p:`EW96`. The choice **Walker1** specifies that :math:`\eta` will be given by :math:`| \|F(u^k)\| - \|F(u^{k-1}) + J(u^{k-1})*p \| | / \|F(u^{k-1})\|`. The choice **Walker2** specifies that :math:`\eta` will be given by :math:`\gamma \|F(u^k)\| / \|F(u^{k-1})\|^{\alpha}`. For both of the last two choices, :math:`\eta` is never allowed to be less than 1e-4. .. container:: list :: run.Solver.Nonlinear.EtaChoice = "EtaConstant" # Python syntax pfset Solver.Nonlinear.EtaChoice "EtaConstant" # TCL syntax *double* **Solver.Nonlinear.EtaValue** 1e-4 This key specifies the constant value of :math:`\eta` for the EtaChoice key **EtaConstant**. .. container:: list :: run.Solver.Nonlinear.EtaValue = 1e-7 # Python syntax pfset Solver.Nonlinear.EtaValue 1e-7 # TCL syntax *double* **Solver.Nonlinear.EtaAlpha** 2.0 This key specifies the value of :math:`\alpha` for the case of EtaChoice being **Walker2**. .. container:: list :: run.Solver.Nonlinear.EtaAlpha = 1.0 # Python syntax pfset Solver.Nonlinear.EtaAlpha 1.0 # TCL syntax *double* **Solver.Nonlinear.EtaGamma** 0.9 This key specifies the value of :math:`\gamma` for the case of EtaChoice being **Walker2**. .. container:: list :: run.Solver.Nonlinear.EtaGamma = 0.7 # Python syntax pfset Solver.Nonlinear.EtaGamma 0.7 # TCL syntax *string* **Solver.Nonlinear.UseJacobian** False This key specifies whether the Jacobian will be used in matrix-vector products or whether a matrix-free version of the code will run. Choices for this key are **False** and **True**. Using the Jacobian will most likely decrease the number of nonlinear iterations but require more memory to run. .. container:: list :: run.Solver.Nonlinear.UseJacobian = True # Python syntax pfset Solver.Nonlinear.UseJacobian True # TCL syntax *double* **Solver.Nonlinear.DerivativeEpsilon** 1e-7 This key specifies the value of :math:`\epsilon` used in approximating the action of the Jacobian on a vector with approximate directional derivatives of the nonlinear function. This parameter is only used when the UseJacobian key is **False**. .. container:: list :: run.Solver.Nonlinear.DerivativeEpsilon = 1e-8 # Python syntax pfset Solver.Nonlinear.DerivativeEpsilon 1e-8 # TCL syntax *string* **Solver.Nonlinear.Globalization** LineSearch This key specifies the type of global strategy to use. Possible choices for this key are **InexactNewton** and **LineSearch**. The choice **InexactNewton** specifies no global strategy, and the choice **LineSearch** specifies that a line search strategy should be used where the nonlinear step can be lengthened or decreased to satisfy certain criteria. .. container:: list :: run.Solver.Nonlinear.Globalization = "LineSearch" # Python syntax pfset Solver.Nonlinear.Globalization "LineSearch" # TCL syntax *string* **Solver.Linear.Preconditioner** MGSemi This key specifies which preconditioner to use. Currently, the three choices are **NoPC, MGSemi, PFMG, PFMGOctree** and **SMG**. The choice **NoPC** specifies that no preconditioner should be used. The choice **MGSemi** specifies a semi-coarsening multigrid algorithm which uses a point relaxation method. The choice **SMG** specifies a semi-coarsening multigrid algorithm which uses plane relaxations. This method is more robust than **MGSemi**, but generally requires more memory and compute time. The choice **PFMGOctree** can be more efficient for problems with large numbers of inactive cells. .. container:: list :: run.Solver.Linear.Preconditioner = "MGSemi" # Python syntax pfset Solver.Linear.Preconditioner "MGSemi" # TCL syntax *string* **Solver.Linear.Preconditioner.SymmetricMat** Symmetric This key specifies whether the preconditioning matrix is symmetric. Choices for this key are **Symmetric** and **Nonsymmetric**. The choice **Symmetric** specifies that the symmetric part of the Jacobian will be used as the preconditioning matrix. The choice **Nonsymmetric** specifies that the full Jacobian will be used as the preconditioning matrix. NOTE: ONLY **Symmetric** CAN BE USED IF MGSemi IS THE SPECIFIED PRECONDITIONER! .. container:: list :: run.Solver.Linear.Preconditioner.SymmetricMat = "Symmetric" # Python syntax pfset Solver.Linear.Preconditioner.SymmetricMat "Symmetric" # TCL syntax *integer* **Solver.Linear.Preconditioner.\ *precond_method*.MaxIter** 1 This key specifies the maximum number of iterations to take in solving the preconditioner system with *precond_method* solver. .. container:: list :: run.Solver.Linear.Preconditioner.SMG.MaxIter = 2 # Python syntax pfset Solver.Linear.Preconditioner.SMG.MaxIter 2 # TCL syntax *integer* **Solver.Linear.Preconditioner.SMG.NumPreRelax** 1 This key specifies the number of relaxations to take before coarsening in the specified preconditioner method. Note that this key is only relevant to the SMG multigrid preconditioner. .. container:: list :: run.Solver.Linear.Preconditioner.SMG.NumPreRelax = 2 # Python syntax pfset Solver.Linear.Preconditioner.SMG.NumPreRelax 2 # TCL syntax *integer* **Solver.Linear.Preconditioner.SMG.NumPostRelax** 1 This key specifies the number of relaxations to take after coarsening in the specified preconditioner method. Note that this key is only relevant to the SMG multigrid preconditioner. .. container:: list :: run.Solver.Linear.Preconditioner.SMG.NumPostRelax = 0 # Python syntax pfset Solver.Linear.Preconditioner.SMG.NumPostRelax 0 # TCL syntax *string* **Solver.Linear.Preconditioner.PFMG.RAPType** NonGalerkin For the PFMG solver, this key specifies the *Hypre* RAP type. Valid values are **Galerkin** or **NonGalerkin** .. container:: list :: run.Solver.Linear.Preconditioner.PFMG.RAPType = "Galerkin" # Python syntax pfset Solver.Linear.Preconditioner.PFMG.RAPType "Galerkin" # TCL syntax *logical* **Solver.ResetSurfacePressure** False This key changes any surface pressure greater than a threshold value to another value in between solver timesteps. It works differently than the Spinup keys and is intended to help with slope errors and issues and provides some diagnostic information. The threshold keys are specified below. .. container:: list :: run.Solver.ResetSurfacePressure = "True" # Python syntax pfset Solver.ResetSurfacePressure "True" # TCL syntax *double* **Solver.ResetSurfacePressure.ThresholdPressure** 0.0 This key specifies a threshold value used in the **ResetSurfacePressure** key above. .. container:: list :: run.Solver.ResetSurfacePressure.ThresholdPressure = 10.0 # Python syntax pfset Solver.ResetSurfacePressure.ThresholdPressure 10.0 # TCL syntax *double* **Solver.ResetSurfacePressure.ResetPressure** 0.0 This key specifies a reset value used in the **ResetSurfacePressure** key above. .. container:: list :: run.Solver.ResetSurfacePressure.ResetPressure = 0.0 # Python syntax pfset Solver.ResetSurfacePressure.ResetPressure 0.0 # TCL syntax *logical* **Solver.SurfacePredictor** False This key activates a routine that uses the evap trans flux, Darcy flux, and available water storage in a surface cell to predict whether an unsaturated cell will pond during the next timestep. The pressure values are set with the key below. .. container:: list :: run.Solver.SurfacePredictor = "True" # Python syntax pfset Solver.SurfacePredictor "True" # TCL syntax *double* **Solver.SurfacePredictor.PressureValue** 0.00001 This key specifies a surface pressure if the **SurfacePredictor** key above is True and ponded conditions are predicted at a surface cell. A negative value allows the surface predictor algorithm to estimate the new surface pressure based on surrounding fluxes. .. container:: list :: run.Solver.SurfacePredictor.PressureValue = 0.001 # Python syntax pfset Solver.SurfacePredictor.PressureValue 0.001 # TCL syntax *logical* **Solver.SurfacePredictor.PrintValues** False This key specifies if the **SurfacePredictor** values are printed. .. container:: list :: run.Solver.SurfacePredictor.PrintValue = "True" # Python syntax pfset Solver.SurfacePredictor.PrintValue "True" # TCL syntax *logical* **Solver.SurfacePredictor.LateralFlows** False This key enables the use of overland flow lateral fluxes (qx_overland and qy_overland) in the surface predictor water balance calculation. When enabled, the predictor uses these surface flow values in addition to the subsurface fluxes to compute lateral flux divergence at the land surface. This improves the surface predictor's ability to estimate when ponding will occur by accounting for lateral redistribution of surface water. .. container:: list :: run.Solver.SurfacePredictor.LateralFlows = "True" # Python syntax pfset Solver.SurfacePredictor.LateralFlows "True" # TCL syntax *logical* **Solver.EvapTransFile** False This key specifies specifies that the Flux terms for Richards’ equation are read in from a ParFlow 3D binary file. This file has [T^-1] units corresponding to the flux value(s) divided by the layer thickness **DZ**. Note this key is for a steady-state flux and should not be used in conjunction with the transient key below. .. container:: list :: run.Solver.EvapTransFile = True # Python syntax pfset Solver.EvapTransFile True # TCL syntax *logical* **Solver.EvapTransFileTransient** False This key specifies specifies that the Flux terms for Richards’ equation are read in from a series of ParFlow 3D binary files. Each file has :math:`[T^-1]` units corresponding to the flux value(s) divided by the layer thickness **DZ**. Note this key should not be used with the key above, only one of these keys should be set to ``True`` at a time, not both. .. container:: list :: run.Solver.EvapTransFileTransient = True # Python syntax pfset Solver.EvapTransFileTransient True # TCL syntax *string* **Solver.EvapTrans.FileName** no default This key specifies specifies filename for the distributed ParFlow 3D binary file that contains the flux values for Richards’ equation. This file has :math:`[T^-1]` units corresponding to the flux value(s) divided by the layer thickness **DZ**. For the steady-state option (*Solver.EvapTransFile*=**True**) this key should be the complete filename. For the transient option (*Solver.EvapTransFileTransient*=**True**) then the filename is a header and ParFlow will load one file per timestep, with the form ``filename.00000.pfb``. EvapTrans values are considered as sources or sinks in Richards' equation, so they have no conflicts with boundary conditions. Consequently, sign flip is not required (i.e., incoming flluxes are positive and outgoing fluxes are negative). .. container:: list :: run.Solver.EvapTrans.FileName = "evap.trans.test.pfb" # Python syntax pfset Solver.EvapTrans.FileName "evap.trans.test.pfb" # TCL syntax *string* **Solver.LSM** none This key specifies whether a land surface model, such as ``CLM``, will be called each solver timestep. Choices for this key include **none** and **CLM**. Note that ``CLM`` must be compiled and linked at runtime for this option to be active. .. container:: list :: run.Solver.LSM = "CLM" # Python syntax pfset Solver.LSM "CLM" # TCL syntax .. _Spinup Options: Spinup Options ~~~~~~~~~~~~~~ These keys allow for *reduced or dampened physics* during model spinup or initialization. They are **only** intended for these initialization periods, **not** for regular runtime. *integer* **OverlandFlowSpinUp** 0 This key specifies that a *simplified* form of the overland flow boundary condition (Equation :eq:`overland_bc`) be used in place of the full equation. This formulation *removes lateral flow* and drives and ponded water pressures to zero. While this can be helpful in spinning up the subsurface, this is no longer coupled subsurface-surface flow. If set to zero (the default) this key behaves normally. .. container:: list :: run.OverlandFlowSpinUp = 1 # Python syntax pfset OverlandFlowSpinUp 1 # TCL syntax *double* **OverlandFlowSpinUpDampP1** 0.0 This key sets :math:`P_1` and provides exponential dampening to the pressure relationship in the overland flow equation by adding the following term: :math:`P_2*exp(\psi*P_1)` .. container:: list :: run.OverlandSpinupDampP1 = 10.0 # Python syntax pfset OverlandSpinupDampP1 10.0 # TCL syntax *double* **OverlandFlowSpinUpDampP2** 0.0 This key sets :math:`P_2` and provides exponential dampening to the pressure relationship in the overland flow equation adding the following term: :math:`P_2*exp(\psi*P_1)` .. container:: list :: run.OverlandSpinupDampP2 = 0.1 # Python syntax pfset OverlandSpinupDampP2 0.1 # TCL syntax *logical* **Solver.SpinUp** False This key removes surface pressure in between solver timesteps. It works differently than the Spinup keys above as the pressure will build up, then all pressures greater than zero will be reset to zero. .. container:: list :: run.Solver.SpinUp = "True" # Python syntax pfset Solver.SpinUp "True" # TCL syntax .. _CLM Solver Parameters: CLM Solver Parameters ~~~~~~~~~~~~~~~~~~~~~ *string* **Solver.CLM.Print1dOut** False This key specifies whether the ``CLM`` one dimensional (averaged over each processor) output file is written or not. Choices for this key include True and False. Note that ``CLM`` must be compiled and linked at runtime for this option to be active. .. container:: list :: run.Solver.CLM.Print1dOut = False # Python syntax pfset Solver.CLM.Print1dOut False # TCL syntax *integer* **Solver.CLM.IstepStart** 1 This key specifies the value of the counter, *istep* in ``CLM``. This key primarily determines the start of the output counter for ``CLM``. It is used to restart a run by setting the key to the ending step of the previous run plus one. Note that ``CLM`` must be compiled and linked at runtime for this option to be active. .. container:: list :: run.Solver.CLM.IstepStart = 8761 # Python syntax pfset Solver.CLM.IstepStart 8761 # TCL syntax *String* **Solver.CLM.MetForcing** no default This key specifies defines whether 1D (uniform over the domain), 2D (spatially distributed) or 3D (spatially distributed with multiple timesteps per ``.pfb`` forcing file) forcing data is used. Choices for this key are **1D**, **2D** and **3D**. This key has no default so the user *must* set it to 1D, 2D or 3D. Failure to set this key will cause ``CLM`` to still be run but with unpredictable values causing ``CLM`` to eventually crash. 1D meteorological forcing files are text files with single columns for each variable and each timestep per row, while 2D forcing files are distributed ParFlow binary files, one for each variable and timestep. File names are specified in the **Solver.CLM.MetFileName** variable below. Note that ``CLM`` must be compiled and linked at runtime for this option to be active. .. container:: list :: run.Solver.CLM.MetForcing = "2D" # Python syntax pfset Solver.CLM.MetForcing "2D" # TCL syntax *String* **Solver.CLM.MetFileName** no default This key specifies defines the file name for 1D, 2D or 3D forcing data. 1D meteorological forcing files are text files with single columns for each variable and each timestep per row, while 2D and 3D forcing files are distributed ParFlow binary files, one for each variable and timestep (2D) or one for each variable and *multiple* timesteps (3D). Behavior of this key is different for 1D and 2D and 3D cases, as specified by the **Solver.CLM.MetForcing** key above. For 1D cases, it is the *FULL FILE NAME*. Note that in this configuration, this forcing file is **not** distributed, the user does not provide copies such as ``narr.1hr.txt.0``, ``narr.1hr.txt.1`` for each processor. ParFlow only needs the single original file (*e.g.* ``narr.1hr.txt``). For 2D cases, this key is the BASE FILE NAME for the 2D forcing files, currently set to NLDAS, with individual files determined as follows ``NLDAS..