# 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
# 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
# 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
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
# 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
# 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 #---------------------------------------------------------
#--------------------------------------------------------- # 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
# 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
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
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
#--------------------------------------------------------- # 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
# 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
# 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
#----------------------------------------------------------------------------- # 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 #---------------------------------------------------------
# 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
# # 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
# # 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
#--------------------------------------------------------- # 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
#----------------------------------------------------------------------------- # 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
#--------------------------------------------------------- # 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
#----------------------------------------------------------------------------- # 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
# 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
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
#------------------------------------------------------------------ # 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
#--------------------------------------------------------- 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
#--------------------------------------------------------- # 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
#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
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
# 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
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]