示例#1
0
# This runs a test case with the Richards' solver
# with simple flow domains, like a wall or a fault.

# set runname richards_ptest
tcl_precision = 17

# Import the ParFlow TCL package
#
from parflow import Run

richards_box_proctest = Run("richards_box_proctest", __file__)

richards_box_proctest.FileVersion = 4

richards_box_proctest.Process.Topology.P = 1
richards_box_proctest.Process.Topology.Q = 1
richards_box_proctest.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------
richards_box_proctest.ComputationalGrid.Lower.X = 0.0
richards_box_proctest.ComputationalGrid.Lower.Y = 0.0
richards_box_proctest.ComputationalGrid.Lower.Z = 0.0

richards_box_proctest.ComputationalGrid.DX = 1.0
richards_box_proctest.ComputationalGrid.DY = 1.0
richards_box_proctest.ComputationalGrid.DZ = 1.0

richards_box_proctest.ComputationalGrid.NX = 20
richards_box_proctest.ComputationalGrid.NY = 50
示例#2
0
#  This runs the basic default_richards test case.
#  This run, as written in this input file, should take
#  3 nonlinear iterations.

from parflow import Run
from parflow.tools.fs import mkdir, get_absolute_path

octree = Run("octree_simple", __file__)

#---------------------------------------------------------

octree.FileVersion = 4

octree.Process.Topology.P = 1
octree.Process.Topology.Q = 1
octree.Process.Topology.R = 1

#-----------------------------------------------------------------------------
# Computational Grid
#-----------------------------------------------------------------------------

octree.ComputationalGrid.Lower.X = -10.0
octree.ComputationalGrid.Lower.Y = 10.0
octree.ComputationalGrid.Lower.Z = 1.0

octree.ComputationalGrid.DX = 20.0
octree.ComputationalGrid.DY = 20.0
octree.ComputationalGrid.DZ = 1.0

octree.ComputationalGrid.NX = 8
octree.ComputationalGrid.NY = 8
示例#3
0
#  This runs the basic default_richards test case.
#  This run, as written in this input file, should take
#  3 nonlinear iterations.

#
# Import the ParFlow TCL package
#
from parflow import Run
octree_simple = Run("octree_simple", __file__)

octree_simple.FileVersion = 4

octree_simple.Process.Topology.P = 1
octree_simple.Process.Topology.Q = 1
octree_simple.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------

#-----------------------------------------------------------------------------
# Computational Grid
#-----------------------------------------------------------------------------
octree_simple.ComputationalGrid.Lower.X = -10.0
octree_simple.ComputationalGrid.Lower.Y = 10.0
octree_simple.ComputationalGrid.Lower.Z = 1.0

octree_simple.ComputationalGrid.DX = 20.0
octree_simple.ComputationalGrid.DY = 20.0
octree_simple.ComputationalGrid.DZ = 1.0
示例#4
0
LWvdz = Run("LWvdz", __file__)

#---------------------------------------------------------
# Copying slope files
#---------------------------------------------------------

dir_name = get_absolute_path('test_output/LWvdz')
mkdir(dir_name)
chdir(dir_name)

cp('$PF_SRC/test/input/lw.1km.slope_x.10x.pfb')
cp('$PF_SRC/test/input/lw.1km.slope_y.10x.pfb')

#---------------------------------------------------------

LWvdz.FileVersion = 4

LWvdz.Process.Topology.P = 1
LWvdz.Process.Topology.Q = 1
LWvdz.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------

LWvdz.ComputationalGrid.Lower.X = 0.0
LWvdz.ComputationalGrid.Lower.Y = 0.0
LWvdz.ComputationalGrid.Lower.Z = 0.0

LWvdz.ComputationalGrid.NX = 45
LWvdz.ComputationalGrid.NY = 32
示例#5
0
# Runs a simple sand draining problem, rectangular domain
# with variable dz and a heterogenous subsurface with different K the top and bottom layers

# Import the ParFlow TCL package
#
from parflow import Run
var_dz_1D = Run("var_dz_1D", __file__)

var_dz_1D.FileVersion = 4

var_dz_1D.Process.Topology.P = 1
var_dz_1D.Process.Topology.Q = 1
var_dz_1D.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------
var_dz_1D.ComputationalGrid.Lower.X = 0.0
var_dz_1D.ComputationalGrid.Lower.Y = 0.0
var_dz_1D.ComputationalGrid.Lower.Z = 0.0

var_dz_1D.ComputationalGrid.DX = 1.0
var_dz_1D.ComputationalGrid.DY = 1.0
var_dz_1D.ComputationalGrid.DZ = 0.1

var_dz_1D.ComputationalGrid.NX = 1
var_dz_1D.ComputationalGrid.NY = 1
var_dz_1D.ComputationalGrid.NZ = 14

#---------------------------------------------------------
# The Names of the GeomInputs
示例#6
0
#  This runs the tilted-v catchment problem
#  similar to that in Kollet and Maxwell (2006) AWR

#
# Import the ParFlow TCL package
#
from parflow import Run
BC_test = Run("BC_test", __file__)

BC_test.FileVersion = 4

BC_test.Process.Topology.P = 1
BC_test.Process.Topology.Q = 2
BC_test.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------
BC_test.ComputationalGrid.Lower.X = 0.0
BC_test.ComputationalGrid.Lower.Y = 0.0
BC_test.ComputationalGrid.Lower.Z = 0.0

BC_test.ComputationalGrid.NX = 30
BC_test.ComputationalGrid.NY = 30
BC_test.ComputationalGrid.NZ = 30

BC_test.ComputationalGrid.DX = 10.0
BC_test.ComputationalGrid.DY = 10.0
BC_test.ComputationalGrid.DZ = .05

#---------------------------------------------------------
示例#7
0
#---------------------------------------------------------
#  This runs the tilted-v catchment problem
#  similar to that in Kollet and Maxwell (2006) AWR
#---------------------------------------------------------

from parflow import Run
from parflow.tools.fs import mkdir, get_absolute_path

dover = Run("default_overland_pfmg_jac", __file__)

#---------------------------------------------------------

dover.FileVersion = 4

dover.Process.Topology.P = 1
dover.Process.Topology.Q = 1
dover.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------

dover.ComputationalGrid.Lower.X = 0.0
dover.ComputationalGrid.Lower.Y = 0.0
dover.ComputationalGrid.Lower.Z = 0.0

dover.ComputationalGrid.NX = 30
dover.ComputationalGrid.NY = 30
dover.ComputationalGrid.NZ = 30

dover.ComputationalGrid.DX = 10.0
示例#8
0
#  This runs the basic pfmg test case based off of default richards
#  This run, as written in this input file, should take
#  3 nonlinear iterations.

#
# Import the ParFlow TCL package
#
from parflow import Run
pfmg_octree = Run("pfmg_octree", __file__)

pfmg_octree.FileVersion = 4

pfmg_octree.Process.Topology.P = 1
pfmg_octree.Process.Topology.Q = 1
pfmg_octree.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------
pfmg_octree.ComputationalGrid.Lower.X = -10.0
pfmg_octree.ComputationalGrid.Lower.Y = 10.0
pfmg_octree.ComputationalGrid.Lower.Z = 1.0

pfmg_octree.ComputationalGrid.DX = 8.8888888888888893
pfmg_octree.ComputationalGrid.DY = 10.666666666666666
pfmg_octree.ComputationalGrid.DZ = 1.0

pfmg_octree.ComputationalGrid.NX = 10
pfmg_octree.ComputationalGrid.NY = 10
pfmg_octree.ComputationalGrid.NZ = 8
示例#9
0
rain_flux = -0.05
rec_flux = 0.0

#---------------------------------------------------------
# Import ParFlow
#---------------------------------------------------------

from parflow import Run
from parflow.tools.fs import mkdir, get_absolute_path

wby = Run("water_balance_y", __file__)

#---------------------------------------------------------

wby.FileVersion = 4

#---------------------------------------------------------
# Processor topology
#---------------------------------------------------------

wby.Process.Topology.P = 1
wby.Process.Topology.Q = 1
wby.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------

wby.ComputationalGrid.Lower.X = 0.0
wby.ComputationalGrid.Lower.Y = 0.0
示例#10
0
from parflowio.pyParflowio import PFData
import numpy as np

rich_fbx = Run("richards_FBx", __file__)

#---------------------------------------------------------
# Creating and navigating to output directory
#---------------------------------------------------------

dir_name = get_absolute_path('test_output/rich_fbx')
mkdir(dir_name)
chdir(dir_name)

#------------------------------------------------------------------

rich_fbx.FileVersion = 4

rich_fbx.Process.Topology.P = 1
rich_fbx.Process.Topology.Q = 1
rich_fbx.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------

rich_fbx.ComputationalGrid.Lower.X = 0.0
rich_fbx.ComputationalGrid.Lower.Y = 0.0
rich_fbx.ComputationalGrid.Lower.Z = 0.0

rich_fbx.ComputationalGrid.DX = 1.0
rich_fbx.ComputationalGrid.DY = 1.0
示例#11
0
#---------------------------------------------------------
# Runs a simple sand draining problem, rectangular domain
# with variable dz and a heterogenous subsurface with different K the top and bottom layers
#---------------------------------------------------------

from parflow import Run
from parflow.tools.fs import mkdir, get_absolute_path

vardz = Run("var_d5z_1D", __file__)

#---------------------------------------------------------

vardz.FileVersion = 4

vardz.Process.Topology.P = 1
vardz.Process.Topology.Q = 1
vardz.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------

vardz.ComputationalGrid.Lower.X = 0.0
vardz.ComputationalGrid.Lower.Y = 0.0
vardz.ComputationalGrid.Lower.Z = 0.0

vardz.ComputationalGrid.DX = 1.0
vardz.ComputationalGrid.DY = 1.0
vardz.ComputationalGrid.DZ = 0.1

vardz.ComputationalGrid.NX = 1
示例#12
0
#  This is a 2D sloped problem w/ time varying input and topography
#  it is used as a test of active/inactive efficiency
#
#    Reed Maxwell, 11/08
#

#
# Import the ParFlow TCL package
#
from parflow import Run
small_domain = Run("small_domain", __file__)

size = 1

small_domain.FileVersion = 4

small_domain.Process.Topology.P = 1
small_domain.Process.Topology.Q = 1
small_domain.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------
small_domain.ComputationalGrid.Lower.X = 0.0
small_domain.ComputationalGrid.Lower.Y = 0.0
small_domain.ComputationalGrid.Lower.Z = 0.0

small_domain.ComputationalGrid.NX = 100 * size
small_domain.ComputationalGrid.NY = 1
small_domain.ComputationalGrid.NZ = 100 * size
示例#13
0
#  This runs the tilted-v catchment problem
#  similar to that in Kollet and Maxwell (2006) AWR

tcl_precision = 17

# set runname flux_overland

#
# Import the ParFlow TCL package
#
from parflow import Run
overland_flux = Run("overland_flux", __file__)

overland_flux.FileVersion = 4

overland_flux.Process.Topology.P = [lindex $argv 0]
overland_flux.Process.Topology.Q = [lindex $argv 1]
overland_flux.Process.Topology.R = [lindex $argv 2]

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------
overland_flux.ComputationalGrid.Lower.X = 0.0
overland_flux.ComputationalGrid.Lower.Y = 0.0
overland_flux.ComputationalGrid.Lower.Z = 0.0

overland_flux.ComputationalGrid.NX = 30
overland_flux.ComputationalGrid.NY = 30
overland_flux.ComputationalGrid.NZ = 30

overland_flux.ComputationalGrid.DX = 10.0
示例#14
0
#-----------------------------------------------------------------------------
#  Testing serial runs within same script
#-----------------------------------------------------------------------------

from parflow import Run
dover_1 = Run("dover_1", __file__)

dover_1.FileVersion = 4

dover_1.Process.Topology.P = 1
dover_1.Process.Topology.Q = 1
dover_1.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------
dover_1.ComputationalGrid.Lower.X = 0.0
dover_1.ComputationalGrid.Lower.Y = 0.0
dover_1.ComputationalGrid.Lower.Z = 0.0

dover_1.ComputationalGrid.NX = 30
dover_1.ComputationalGrid.NY = 30
dover_1.ComputationalGrid.NZ = 30

dover_1.ComputationalGrid.DX = 10.0
dover_1.ComputationalGrid.DY = 10.0
dover_1.ComputationalGrid.DZ = .05

#---------------------------------------------------------
# The Names of the GeomInputs
#---------------------------------------------------------
示例#15
0
#  This runs the tilted-v catchment problem
#  similar to that in Kollet and Maxwell (2006) AWR

tcl_precision = 17

# set runname default_overland

#
# Import the ParFlow TCL package
#
from parflow import Run
default_overland_pfmg_octree_jac = Run("default_overland_pfmg_octree_jac", __file__)

default_overland_pfmg_octree_jac.FileVersion = 4

default_overland_pfmg_octree_jac.Process.Topology.P = 1
default_overland_pfmg_octree_jac.Process.Topology.Q = 1
default_overland_pfmg_octree_jac.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------
default_overland_pfmg_octree_jac.ComputationalGrid.Lower.X = 0.0
default_overland_pfmg_octree_jac.ComputationalGrid.Lower.Y = 0.0
default_overland_pfmg_octree_jac.ComputationalGrid.Lower.Z = 0.0

default_overland_pfmg_octree_jac.ComputationalGrid.NX = 30
default_overland_pfmg_octree_jac.ComputationalGrid.NY = 30
default_overland_pfmg_octree_jac.ComputationalGrid.NZ = 30

default_overland_pfmg_octree_jac.ComputationalGrid.DX = 10.0
示例#16
0
#
# Import the ParFlow TCL package
#
import sys
sys.path.append("..")
from parflow import Run

dsingle = Run("dsingle", __file__)

#-----------------------------------------------------------------------------
# File input version number
#-----------------------------------------------------------------------------
dsingle.FileVersion = 4

#-----------------------------------------------------------------------------
# Process Topology
#-----------------------------------------------------------------------------

dsingle.Process.Topology.P = 1
dsingle.Process.Topology.Q = 1
dsingle.Process.Topology.R = 1

#-----------------------------------------------------------------------------
# Computational Grid
#-----------------------------------------------------------------------------
dsingle.ComputationalGrid.Lower.X = -10.0
dsingle.ComputationalGrid.Lower.Y = 10.0
dsingle.ComputationalGrid.Lower.Z = 1.0

dsingle.ComputationalGrid.DX = 8.8888888888888893
dsingle.ComputationalGrid.DY = 10.666666666666666
示例#17
0
#
# Import the ParFlow TCL package
#
from parflow import Run
default_richards_with_silopmpio = Run("default_richards_with_silopmpio", __file__)

# Examples of compression options for SILO
# Note compression only works for HDF5
#pfset SILO.Filetype "HDF5"
#pfset SILO.CompressionOptions "METHOD=GZIP"
#pfset SILO.CompressionOptions "METHOD=SZIP"
#pfset SILO.CompressionOptions "METHOD=FPZIP"
#pfset SILO.CompressionOptions "ERRMODE=FALLBACK METHOD=GZIP"

default_richards_with_silopmpio.FileVersion = 4

default_richards_with_silopmpio.Process.Topology.P = 1
default_richards_with_silopmpio.Process.Topology.Q = 1
default_richards_with_silopmpio.Process.Topology.R = 2

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------
default_richards_with_silopmpio.ComputationalGrid.Lower.X = -10.0
default_richards_with_silopmpio.ComputationalGrid.Lower.Y = 10.0
default_richards_with_silopmpio.ComputationalGrid.Lower.Z = 1.0

default_richards_with_silopmpio.ComputationalGrid.DX = 8.8888888888888893
default_richards_with_silopmpio.ComputationalGrid.DY = 10.666666666666666
default_richards_with_silopmpio.ComputationalGrid.DZ = 1.0
示例#18
0
#---------------------------------------------------------
# SCRIPT TO RUN LITTLE WASHITA DOMAIN WITH TERRAIN-FOLLOWING GRID
# Using combination of tables and domain builder
#---------------------------------------------------------

import sys

from parflow import Run
from parflow.tools.fs import get_absolute_path
from parflow.tools.builders import SubsurfacePropertiesBuilder, DomainBuilder

LW_Test = Run("LW_Test", __file__)

LW_Test.FileVersion = 4

#-----------------------------------------------------------------------------
# Set Processor topology
#-----------------------------------------------------------------------------

LW_Test.Process.Topology.P = 1
LW_Test.Process.Topology.Q = 1
LW_Test.Process.Topology.R = 1

#-----------------------------------------------------------------------------
# Computational Grid
#-----------------------------------------------------------------------------

LW_Test.ComputationalGrid.Lower.X = 0.0
LW_Test.ComputationalGrid.Lower.Y = 0.0
LW_Test.ComputationalGrid.Lower.Z = 0.0
示例#19
0
#-----------------------------------------------------------------------------
# Setting test variables
#-----------------------------------------------------------------------------

# Total runtime of simulation
stopt = 100

# Reuse values to run with
reuseValues = [1, 4]

#-----------------------------------------------------------------------------
# File input version number
#-----------------------------------------------------------------------------

clm.FileVersion = 4

#-----------------------------------------------------------------------------
# Process Topology
#-----------------------------------------------------------------------------

clm.Process.Topology.P = 1
clm.Process.Topology.Q = 1
clm.Process.Topology.R = 1

#-----------------------------------------------------------------------------
# Computational Grid
#-----------------------------------------------------------------------------

clm.ComputationalGrid.Lower.X = 0.0
clm.ComputationalGrid.Lower.Y = 0.0
示例#20
0
#---------------------------------------------------------
#  Testing overland flow diffusive wave
# Running a parking lot sloping slab pointed in 8 directions
# With diffusive BC options
#---------------------------------------------------------

from parflow import Run
from parflow.tools.fs import mkdir, get_absolute_path

overland = Run("overland_slopingslab_DWE", __file__)

#---------------------------------------------------------

overland.FileVersion = 4

overland.Process.Topology.P = 1
overland.Process.Topology.Q = 1
overland.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------

overland.ComputationalGrid.Lower.X = 0.0
overland.ComputationalGrid.Lower.Y = 0.0
overland.ComputationalGrid.Lower.Z = 0.0

overland.ComputationalGrid.NX = 5
overland.ComputationalGrid.NY = 5
overland.ComputationalGrid.NZ = 1
示例#21
0
#-----------------------------------------------------------------------------
#  This runs the basic default_richards test case.
#  This run, as written in this input file, should take
#  3 nonlinear iterations.
#-----------------------------------------------------------------------------

from parflow import Run
from parflow.tools.fs import mkdir, get_absolute_path

drich = Run("default_richards_wells", __file__)

#---------------------------------------------------------

drich.FileVersion = 4

drich.Process.Topology.P = 1
drich.Process.Topology.Q = 1
drich.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------

drich.ComputationalGrid.Lower.X = -10.0
drich.ComputationalGrid.Lower.Y = 10.0
drich.ComputationalGrid.Lower.Z = 1.0

drich.ComputationalGrid.DX = 8.8888888888888893
drich.ComputationalGrid.DY = 10.666666666666666
drich.ComputationalGrid.DZ = 1.0
示例#22
0
# This runs a test case with the Richards' solver
# with a simple flow domain and different BCs on the top.
# The domain geometry is purposefully smaller than the computational grid
# making more than 1/2 the domain inactive in Y.  When run with topology
# 1 2 1 this will test PF behavior for inactive processors, for different BCs
# and solver configurations.

# set runname richards_ptest_vdz
tcl_precision = 17

# Import the ParFlow TCL package
#
from parflow import Run
richards_box_proctest_vardz = Run("richards_box_proctest_vardz", __file__)

richards_box_proctest_vardz.FileVersion = 4

richards_box_proctest_vardz.Process.Topology.P = 1
richards_box_proctest_vardz.Process.Topology.Q = 1
richards_box_proctest_vardz.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------
richards_box_proctest_vardz.ComputationalGrid.Lower.X = 0.0
richards_box_proctest_vardz.ComputationalGrid.Lower.Y = 0.0
richards_box_proctest_vardz.ComputationalGrid.Lower.Z = 0.0

richards_box_proctest_vardz.ComputationalGrid.DX = 1.0
richards_box_proctest_vardz.ComputationalGrid.DY = 1.0
richards_box_proctest_vardz.ComputationalGrid.DZ = 1.0
示例#23
0
os.chdir('output')

# copy CLM files
shutil.copyfile('../inputs/drv_clmin.dat', 'drv_clmin.dat')
shutil.copyfile('../inputs/drv_vegm.dat', 'drv_vegm.dat')
shutil.copyfile('../inputs/drv_vegp.dat', 'drv_vegp.dat')

# Set our Run Name
PFCLM_SC = Run("PFCLM_SC", __file__)

stopt = 8760

#-----------------------------------------------------------------------------
# File input version number
#-----------------------------------------------------------------------------
PFCLM_SC.FileVersion = 4

#-----------------------------------------------------------------------------
# Process Topology
#-----------------------------------------------------------------------------

PFCLM_SC.Process.Topology.P = 1
PFCLM_SC.Process.Topology.Q = 1
PFCLM_SC.Process.Topology.R = 1

#-----------------------------------------------------------------------------
# Computational Grid
#-----------------------------------------------------------------------------
PFCLM_SC.ComputationalGrid.Lower.X = 0.0
PFCLM_SC.ComputationalGrid.Lower.Y = 0.0
PFCLM_SC.ComputationalGrid.Lower.Z = 0.0
示例#24
0
#------------------------------------------------------------------
#  This runs the basic pfmg test case based off of default richards
#  This run, as written in this input file, should take
#  3 nonlinear iterations.
#------------------------------------------------------------------

from parflow import Run
from parflow.tools.fs import mkdir, get_absolute_path

pfmg = Run("pfmg_octree", __file__)

#------------------------------------------------------------------

pfmg.FileVersion = 4

pfmg.Process.Topology.P = 1
pfmg.Process.Topology.Q = 1
pfmg.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------

pfmg.ComputationalGrid.Lower.X = -10.0
pfmg.ComputationalGrid.Lower.Y = 10.0
pfmg.ComputationalGrid.Lower.Z = 1.0

pfmg.ComputationalGrid.DX = 8.8888888888888893
pfmg.ComputationalGrid.DY = 10.666666666666666
pfmg.ComputationalGrid.DZ = 1.0
示例#25
0
#---------------------------------------------------------
rain_flux = -0.05
rec_flux = 0.0

#---------------------------------------------------------
# Import the ParFlow TCL package
#---------------------------------------------------------
from parflow import Run
water_balance_y = Run("water_balance_y", __file__)

#---------------------------------------------------------
# Name of the run
#---------------------------------------------------------
# set runname water_balance

water_balance_y.FileVersion = 4

#---------------------------------------------------------
# Processor topology
#---------------------------------------------------------
water_balance_y.Process.Topology.P = 1
water_balance_y.Process.Topology.Q = 1
water_balance_y.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------
water_balance_y.ComputationalGrid.Lower.X = 0.0
water_balance_y.ComputationalGrid.Lower.Y = 0.0
water_balance_y.ComputationalGrid.Lower.Z = 0.0
示例#26
0
#---------------------------------------------------------
# This runs a test case with the Richards' solver
# with simple flow domains, like a wall or a fault.
#---------------------------------------------------------

from parflow import Run
from parflow.tools.fs import mkdir, get_absolute_path

rbp = Run("rbp", __file__)

#---------------------------------------------------------

rbp.FileVersion = 4

rbp.Process.Topology.P = 1
rbp.Process.Topology.Q = 1
rbp.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------

rbp.ComputationalGrid.Lower.X = 0.0
rbp.ComputationalGrid.Lower.Y = 0.0
rbp.ComputationalGrid.Lower.Z = 0.0

rbp.ComputationalGrid.DX = 1.0
rbp.ComputationalGrid.DY = 1.0
rbp.ComputationalGrid.DZ = 1.0

rbp.ComputationalGrid.NX = 20
示例#27
0
#running different configuraitons of tilted V

tcl_precision = 17

# Import the ParFlow TCL package
#
from parflow import Run

overland_tiltedV_DWE = Run("overland_tiltedV_DWE", __file__)

overland_tiltedV_DWE.FileVersion = 4

overland_tiltedV_DWE.Process.Topology.P = 1
overland_tiltedV_DWE.Process.Topology.Q = 1
overland_tiltedV_DWE.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------
overland_tiltedV_DWE.ComputationalGrid.Lower.X = 0.0
overland_tiltedV_DWE.ComputationalGrid.Lower.Y = 0.0
overland_tiltedV_DWE.ComputationalGrid.Lower.Z = 0.0

overland_tiltedV_DWE.ComputationalGrid.NX = 5
overland_tiltedV_DWE.ComputationalGrid.NY = 5
overland_tiltedV_DWE.ComputationalGrid.NZ = 1

overland_tiltedV_DWE.ComputationalGrid.DX = 10.0
overland_tiltedV_DWE.ComputationalGrid.DY = 10.0
overland_tiltedV_DWE.ComputationalGrid.DZ = .05
示例#28
0
rain_flux = -0.05
rec_flux = 0.0

#---------------------------------------------------------
# Import ParFlow
#---------------------------------------------------------

from parflow import Run
from parflow.tools.fs import mkdir, get_absolute_path

wbx = Run("wbx", __file__)

#---------------------------------------------------------

wbx.FileVersion = 4

#---------------------------------------------------------
# Processor topology
#---------------------------------------------------------

wbx.Process.Topology.P = 1
wbx.Process.Topology.Q = 1
wbx.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------

wbx.ComputationalGrid.Lower.X = 0.0
wbx.ComputationalGrid.Lower.Y = 0.0
示例#29
0
# This runs a test case with the Richards' solver
# with simple flow domains, like a wall or a fault.

# set runname richards_FBx
tcl_precision = 17

# Import the ParFlow TCL package
#
from parflow import Run
richards_FBx = Run("richards_FBx", __file__)

richards_FBx.FileVersion = 4

richards_FBx.Process.Topology.P = 1
richards_FBx.Process.Topology.Q = 1
richards_FBx.Process.Topology.R = 1

#---------------------------------------------------------
# Computational Grid
#---------------------------------------------------------
richards_FBx.ComputationalGrid.Lower.X = 0.0
richards_FBx.ComputationalGrid.Lower.Y = 0.0
richards_FBx.ComputationalGrid.Lower.Z = 0.0

richards_FBx.ComputationalGrid.DX = 1.0
richards_FBx.ComputationalGrid.DY = 1.0
richards_FBx.ComputationalGrid.DZ = 1.0

richards_FBx.ComputationalGrid.NX = 20
richards_FBx.ComputationalGrid.NY = 20
richards_FBx.ComputationalGrid.NZ = 20
示例#30
0
verbose = 1

tcl_precision = 17

DBL_MAX = 3.40282346638528859811704183485e+38
NEG_DBL_MAX = [expr -$DBL_MAX ]

#
# Import the ParFlow TCL package
#
from parflow import Run
compute_wb = Run("compute_wb", __file__)

compute_wb.FileVersion = 4

# if { $::argc != 3 } {
#     puts "Invalid args : <dir> <start_time> <stop_time>"
#     exit -1
# }

dir_new = [lindex $::argv 0]
start = [lindex $::argv 1]
stop = [lindex $::argv 2]

# set runname $dir_new

dir = [pwd]
# cd $dir_new
# set mask [pfload $runname.out.mask.silo]
# set specific_storage [pfload $runname.out.specific_storage.silo]