コード例 #1
0
#-----------------------------------------------------------------------------
# Exact solution specification for error calculations
#-----------------------------------------------------------------------------

richards_box_proctest.KnownSolution = 'NoKnownSolution'

#-----------------------------------------------------------------------------
# Set solver parameters
#-----------------------------------------------------------------------------
richards_box_proctest.Solver = 'Richards'
richards_box_proctest.Solver.MaxIter = 50000

richards_box_proctest.Solver.Nonlinear.MaxIter = 100
richards_box_proctest.Solver.Nonlinear.ResidualTol = 1e-6
richards_box_proctest.Solver.Nonlinear.EtaChoice = 'EtaConstant'
richards_box_proctest.Solver.Nonlinear.EtaValue = 1e-2
richards_box_proctest.Solver.Nonlinear.UseJacobian = True

richards_box_proctest.Solver.Nonlinear.DerivativeEpsilon = 1e-12

richards_box_proctest.Solver.Linear.KrylovDimension = 100

richards_box_proctest.Solver.Linear.Preconditioner = 'PFMG'

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

richards_box_proctest.run()
コード例 #2
0
ファイル: octree-simple.py プロジェクト: mahdadt/parflow-360
# Exact solution specification for error calculations
#-----------------------------------------------------------------------------

octree.KnownSolution = 'NoKnownSolution'

#-----------------------------------------------------------------------------
# Set solver parameters
#-----------------------------------------------------------------------------

octree.Solver = 'Richards'
octree.Solver.MaxIter = 5

octree.Solver.Nonlinear.MaxIter = 10
octree.Solver.Nonlinear.ResidualTol = 1e-9
octree.Solver.Nonlinear.EtaChoice = 'EtaConstant'
octree.Solver.Nonlinear.EtaValue = 1e-5
octree.Solver.Nonlinear.UseJacobian = True
octree.Solver.Nonlinear.DerivativeEpsilon = 1e-2

octree.Solver.Linear.KrylovDimension = 10

octree.Solver.Linear.Preconditioner = 'PFMG'

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

dir_name = get_absolute_path('test_output/octree')
mkdir(dir_name)
octree.run(working_directory=dir_name)
コード例 #3
0
ファイル: octree-simple.py プロジェクト: grapp1/kw-intern
#-----------------------------------------------------------------------------
# Exact solution specification for error calculations
#-----------------------------------------------------------------------------

octree_simple.KnownSolution = 'NoKnownSolution'

#-----------------------------------------------------------------------------
# Set solver parameters
#-----------------------------------------------------------------------------
octree_simple.Solver = 'Richards'
octree_simple.Solver.MaxIter = 5

octree_simple.Solver.Nonlinear.MaxIter = 10
octree_simple.Solver.Nonlinear.ResidualTol = 1e-9
octree_simple.Solver.Nonlinear.EtaChoice = 'EtaConstant'
octree_simple.Solver.Nonlinear.EtaValue = 1e-5
octree_simple.Solver.Nonlinear.UseJacobian = True
octree_simple.Solver.Nonlinear.DerivativeEpsilon = 1e-2

octree_simple.Solver.Linear.KrylovDimension = 10

octree_simple.Solver.Linear.Preconditioner = 'PFMG'
# octree_simple.Solver.Linear.Preconditioner.MGSemi.MaxIter = 1
# octree_simple.Solver.Linear.Preconditioner.MGSemi.MaxLevels = 100

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

octree_simple.run()
コード例 #4
0
LWvdz.Solver.Nonlinear.DerivativeEpsilon = 1e-14
LWvdz.Solver.Nonlinear.StepTol = 1e-25
LWvdz.Solver.Nonlinear.Globalization = 'LineSearch'
LWvdz.Solver.Linear.KrylovDimension = 80
LWvdz.Solver.Linear.MaxRestarts = 2

LWvdz.Solver.Linear.Preconditioner = 'MGSemi'
LWvdz.Solver.Linear.Preconditioner = 'PFMG'
LWvdz.Solver.Linear.Preconditioner.PCMatrixType = 'FullJacobian'

#---------------------------------------------------------
# Initial conditions: water pressure
#---------------------------------------------------------

# set water table to be at the bottom of the domain, the top layer is initially dry
LWvdz.ICPressure.Type = 'HydroStaticPatch'
LWvdz.ICPressure.GeomNames = 'domain'
LWvdz.Geom.domain.ICPressure.Value = -10.0

LWvdz.Geom.domain.ICPressure.RefGeom = 'domain'
LWvdz.Geom.domain.ICPressure.RefPatch = 'z_upper'

#spinup key
LWvdz.Solver.Spinup = False

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

LWvdz.run()
コード例 #5
0
#-----------------------------------------------------------------------------

var_dz_1D.KnownSolution = 'NoKnownSolution'

#-----------------------------------------------------------------------------
# Set solver parameters
#-----------------------------------------------------------------------------
var_dz_1D.Solver = 'Richards'
var_dz_1D.Solver.MaxIter = 2500

var_dz_1D.Solver.Nonlinear.MaxIter = 200
var_dz_1D.Solver.Nonlinear.ResidualTol = 1e-9
var_dz_1D.Solver.Nonlinear.EtaChoice = 'Walker1'
var_dz_1D.Solver.Nonlinear.EtaValue = 1e-5
var_dz_1D.Solver.Nonlinear.UseJacobian = True
#pfset Solver.Nonlinear.UseJacobian                     False
var_dz_1D.Solver.Nonlinear.DerivativeEpsilon = 1e-10

var_dz_1D.Solver.Linear.KrylovDimension = 10

var_dz_1D.Solver.Linear.Preconditioner = 'MGSemi'
var_dz_1D.Solver.Linear.Preconditioner = 'PFMG'
var_dz_1D.Solver.Linear.Preconditioner.MGSemi.MaxIter = 1
var_dz_1D.Solver.Linear.Preconditioner.MGSemi.MaxLevels = 10

#-----------------------------------------------------------------------------
# Run and do tests
#-----------------------------------------------------------------------------

var_dz_1D.run()
コード例 #6
0
BC_test.Solver.Linear.Preconditioner.MGSemi.MaxLevels = 10
BC_test.Solver.PrintSubsurf = False
BC_test. = 'Solver.Drop 1E_20'
BC_test.Solver.AbsTol = 1E-12
#  

BC_test.Solver.WriteSiloSubsurfData = True
BC_test.Solver.WriteSiloPressure = True
BC_test.Solver.WriteSiloSaturation = True

#---------------------------------------------------------
# Initial conditions: water pressure
#---------------------------------------------------------

# set water table to be at the bottom of the domain, the top layer is initially dry
BC_test.ICPressure.Type = 'HydroStaticPatch'
BC_test.ICPressure.GeomNames = 'domain'
BC_test.Geom.domain.ICPressure.Value = -3.0

BC_test.Geom.domain.ICPressure.RefGeom = 'domain'
BC_test.Geom.domain.ICPressure.RefPatch = 'z_upper'

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

# pfrun default_over
# pfundist default_over

BC_test.run()
コード例 #7
0
# Exact solution specification for error calculations
#-----------------------------------------------------------------------------

drich.KnownSolution = 'NoKnownSolution'

#-----------------------------------------------------------------------------
# Set solver parameters
#-----------------------------------------------------------------------------

drich.Solver = 'Richards'
drich.Solver.MaxIter = 5

drich.Solver.Nonlinear.MaxIter = 10
drich.Solver.Nonlinear.ResidualTol = 1e-9
drich.Solver.Nonlinear.EtaChoice = 'EtaConstant'
drich.Solver.Nonlinear.EtaValue = 1e-5
drich.Solver.Nonlinear.UseJacobian = True
drich.Solver.Nonlinear.DerivativeEpsilon = 1e-2

drich.Solver.Linear.KrylovDimension = 10

drich.Solver.Linear.Preconditioner = 'MGSemi'

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

dir_name = get_absolute_path('test_output/drich_w')
mkdir(dir_name)
drich.run(working_directory=dir_name)
コード例 #8
0
#-----------------------------------------------------------------------------
# Set solver parameters
#-----------------------------------------------------------------------------
pfmg_octree.Solver = 'Richards'
pfmg_octree.Solver.MaxIter = 5

pfmg_octree.Solver.Nonlinear.MaxIter = 10
pfmg_octree.Solver.Nonlinear.ResidualTol = 1e-9
pfmg_octree.Solver.Nonlinear.EtaChoice = 'EtaConstant'
pfmg_octree.Solver.Nonlinear.EtaValue = 1e-5
pfmg_octree.Solver.Nonlinear.UseJacobian = True
pfmg_octree.Solver.Nonlinear.DerivativeEpsilon = 1e-2

pfmg_octree.Solver.Linear.KrylovDimension = 10

pfmg_octree.Solver.Linear.Preconditioner = 'PFMGOctree'

#pfset Solver.Linear.Preconditioner.PFMGOctree.BoxSizePowerOf2 3
pfmg_octree.Solver.Linear.Preconditioner.PFMGOctree.BoxSizePowerOf2 = 2

#pfset Solver.Linear.Preconditioner.PFMG.MaxIter          1
#pfset Solver.Linear.Preconditioner.PFMG.NumPreRelax      100
#pfset Solver.Linear.Preconditioner.PFMG.NumPostRelax     100
#pfset Solver.Linear.Preconditioner.PFMG.Smoother         100

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

pfmg_octree.run()
コード例 #9
0
ファイル: default_single.py プロジェクト: grapp1/kw-intern
#-----------------------------------------------------------------------------
# Phase sources:
#-----------------------------------------------------------------------------

dsingle.PhaseSources.water.Type = 'Constant'
dsingle.PhaseSources.water.GeomNames = 'background'
dsingle.PhaseSources.water.Geom.background.Value = 0.0

dsingle.PhaseConcen.water.tce.Type = 'Constant'
dsingle.PhaseConcen.water.tce.GeomNames = 'concen_region'
dsingle.PhaseConcen.water.tce.Geom.concen_region.Value = 0.8

dsingle.Solver.WriteSiloSubsurfData = True
dsingle.Solver.WriteSiloPressure = True
dsingle.Solver.WriteSiloSaturation = True
dsingle.Solver.WriteSiloConcentration = True

#-----------------------------------------------------------------------------
# The Solver Impes MaxIter default value changed so to get previous
# results we need to set it back to what it was
#-----------------------------------------------------------------------------
dsingle.Solver.MaxIter = 5

dsingle.KnownSolution = 'NoKnownSolution'
#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

dsingle.run()
コード例 #10
0
#-----------------------------------------------------------------------------
# Exact solution specification for error calculations
#-----------------------------------------------------------------------------

rich_fbx.KnownSolution = 'NoKnownSolution'

#-----------------------------------------------------------------------------
# Set solver parameters
#-----------------------------------------------------------------------------

rich_fbx.Solver = 'Richards'
rich_fbx.Solver.MaxIter = 50000

rich_fbx.Solver.Nonlinear.MaxIter = 100
rich_fbx.Solver.Nonlinear.ResidualTol = 1e-6
rich_fbx.Solver.Nonlinear.EtaChoice = 'EtaConstant'
rich_fbx.Solver.Nonlinear.EtaValue = 1e-2
rich_fbx.Solver.Nonlinear.UseJacobian = True

rich_fbx.Solver.Nonlinear.DerivativeEpsilon = 1e-12

rich_fbx.Solver.Linear.KrylovDimension = 100

rich_fbx.Solver.Linear.Preconditioner = 'PFMG'

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

rich_fbx.run()
コード例 #11
0
ファイル: var_dz_1D.py プロジェクト: mahdadt/parflow-360
vardz.KnownSolution = 'NoKnownSolution'

#-----------------------------------------------------------------------------
# Set solver parameters
#-----------------------------------------------------------------------------

vardz.Solver = 'Richards'
vardz.Solver.MaxIter = 2500

vardz.Solver.Nonlinear.MaxIter = 200
vardz.Solver.Nonlinear.ResidualTol = 1e-9
vardz.Solver.Nonlinear.EtaChoice = 'Walker1'
vardz.Solver.Nonlinear.EtaValue = 1e-5
vardz.Solver.Nonlinear.UseJacobian = True
vardz.Solver.Nonlinear.DerivativeEpsilon = 1e-10

vardz.Solver.Linear.KrylovDimension = 10

vardz.Solver.Linear.Preconditioner = 'MGSemi'
vardz.Solver.Linear.Preconditioner = 'PFMG'
vardz.Solver.Linear.Preconditioner.MGSemi.MaxIter = 1
vardz.Solver.Linear.Preconditioner.MGSemi.MaxLevels = 10

#-----------------------------------------------------------------------------
# Run and do tests
#-----------------------------------------------------------------------------

dir_name = get_absolute_path('test_output/vardz')
mkdir(dir_name)
vardz.run(working_directory=dir_name)
コード例 #12
0
ファイル: small_domain.py プロジェクト: grapp1/kw-intern
# Exact solution specification for error calculations
#-----------------------------------------------------------------------------

small_domain.KnownSolution = 'NoKnownSolution'

#-----------------------------------------------------------------------------
# Set solver parameters
#-----------------------------------------------------------------------------
small_domain.Solver = 'Richards'
small_domain.Solver.MaxIter = 10000

small_domain.Solver.Nonlinear.MaxIter = 15
small_domain.Solver.Nonlinear.ResidualTol = 1e-9
small_domain.Solver.Nonlinear.StepTol = 1e-9
small_domain.Solver.Nonlinear.EtaValue = 1e-5
small_domain.Solver.Nonlinear.UseJacobian = True
small_domain.Solver.Nonlinear.DerivativeEpsilon = 1e-7

small_domain.Solver.Linear.KrylovDimension = 25
small_domain.Solver.Linear.MaxRestarts = 2

small_domain.Solver.Linear.Preconditioner = 'MGSemi'
small_domain.Solver.Linear.Preconditioner.MGSemi.MaxIter = 1
small_domain.Solver.Linear.Preconditioner.MGSemi.MaxLevels = 100

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

small_domain.run()
コード例 #13
0
overland_flux.Solver.PrintSubsurf = False
overland_flux. = 'Solver.Drop 1E_20'
overland_flux.Solver.AbsTol = 1E-9
#  
overland_flux.Solver.WriteSiloSubsurfData = True
overland_flux.Solver.WriteSiloPressure = True
overland_flux.Solver.WriteSiloSaturation = True
overland_flux.Solver.WriteSiloConcentration = True

#---------------------------------------------------------
# Initial conditions: water pressure
#---------------------------------------------------------

# set water table to be at the bottom of the domain, the top layer is initially dry
overland_flux.ICPressure.Type = 'HydroStaticPatch'
overland_flux.ICPressure.GeomNames = 'domain'
overland_flux.Geom.domain.ICPressure.Value = -3.0

overland_flux.Geom.domain.ICPressure.RefGeom = 'domain'
overland_flux.Geom.domain.ICPressure.RefPatch = 'z_upper'

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

# pfrun $runname
# pfundist $runname


overland_flux.run()
コード例 #14
0
# Initial conditions: water pressure
#---------------------------------------------------------

# set water table to be at the bottom of the domain, the top layer is initially dry
dover_1.ICPressure.Type = 'HydroStaticPatch'
dover_1.ICPressure.GeomNames = 'domain'
dover_1.Geom.domain.ICPressure.Value = -3.0

dover_1.Geom.domain.ICPressure.RefGeom = 'domain'
dover_1.Geom.domain.ICPressure.RefPatch = 'z_upper'

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

dover_1.run()

#-----------------------------------------------------------------------------
# Testing serial run
#-----------------------------------------------------------------------------


dover_2 = dover_1.clone('dover_2')

dover_2.TopoSlopesX.Type = 'Constant'
dover_2.TopoSlopesX.GeomNames = 'left right channel'
dover_2.TopoSlopesX.Geom.left.Value = -0.002
dover_2.TopoSlopesX.Geom.right.Value = 0.002
dover_2.TopoSlopesX.Geom.channel.Value = 0.00

dover_2.run()
コード例 #15
0
default_overland_pfmg_octree_jac.Solver.Linear.MaxRestart = 2

default_overland_pfmg_octree_jac.Solver.Linear.Preconditioner = 'PFMGOctree'
default_overland_pfmg_octree_jac.Solver.PrintSubsurf = False
default_overland_pfmg_octree_jac.Solver.Drop = 1E-20
default_overland_pfmg_octree_jac.Solver.AbsTol = 1E-9
#  
default_overland_pfmg_octree_jac.Solver.WriteSiloSubsurfData = True
default_overland_pfmg_octree_jac.Solver.WriteSiloPressure = True
default_overland_pfmg_octree_jac.Solver.WriteSiloSaturation = True
default_overland_pfmg_octree_jac.Solver.WriteSiloConcentration = True

#---------------------------------------------------------
# Initial conditions: water pressure
#---------------------------------------------------------

# set water table to be at the bottom of the domain, the top layer is initially dry
default_overland_pfmg_octree_jac.ICPressure.Type = 'HydroStaticPatch'
default_overland_pfmg_octree_jac.ICPressure.GeomNames = 'domain'
default_overland_pfmg_octree_jac.Geom.domain.ICPressure.Value = -3.0

default_overland_pfmg_octree_jac.Geom.domain.ICPressure.RefGeom = 'domain'
default_overland_pfmg_octree_jac.Geom.domain.ICPressure.RefPatch = 'z_upper'

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------


default_overland_pfmg_octree_jac.run()
コード例 #16
0
wbx.Solver.WriteSiloSubsurfData = True
wbx.Solver.WriteSiloPressure = True
wbx.Solver.WriteSiloSaturation = True
wbx.Solver.WriteSiloConcentration = True
wbx.Solver.WriteSiloSlopes = True
wbx.Solver.WriteSiloMask = True
wbx.Solver.WriteSiloEvapTrans = True
wbx.Solver.WriteSiloEvapTransSum = True
wbx.Solver.WriteSiloOverlandSum = True
wbx.Solver.WriteSiloMannings = True
wbx.Solver.WriteSiloSpecificStorage = True

#---------------------------------------------------------
# Initial conditions: water pressure
#---------------------------------------------------------

# set water table to be at the bottom of the domain, the top layer is initially dry
wbx.ICPressure.Type = 'HydroStaticPatch'
wbx.ICPressure.GeomNames = 'domain'

wbx.Geom.domain.ICPressure.Value = -3.0

wbx.Geom.domain.ICPressure.RefGeom = 'domain'
wbx.Geom.domain.ICPressure.RefPatch = 'z_upper'

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

wbx.run()
コード例 #17
0
#     puts $diff
#     set passed 0
# } 

# pfsave $silo -silo "single_block.silo"
silo_single_block = [pfload "single_block.silo"]
diff = [pfmdiff $silo $silo_single_block 10]
# if {[string length $diff] != 0 } {
#     puts "FAILED : Silo MP format does not match Silo single block format"
#     puts $diff
#     set passed 0
# } 

#set silo [pfload -silo default_richards.out.pmpio.press.00001.silo]
# pfsave $silo -sa "single_block.sa"
diff = [pfmdiff $silo_single_block $pfb 8]
# if {[string length $diff] != 0 } {
#     puts "FAILED : Silo Single Block format does not match PFB format"
#     puts $diff
#     set passed 0
# } 


# if $passed {
#     puts "default_richards_with_siloPMPIO : PASSED"
# } {
#     puts "default_richards_with_siloPMPIO : FAILED"
# }

default_richards_with_silopmpio.run()
コード例 #18
0
sabino.Cell._15.dzScale.Value = 0.02
sabino.Cell._16.dzScale.Value = 0.01
sabino.Cell._17.dzScale.Value = 0.006
sabino.Cell._18.dzScale.Value = 0.003
sabino.Cell._19.dzScale.Value = 0.001

sabino.Solver.MaxIter = 25000000
sabino.Solver.Drop = 1E-20
sabino.Solver.AbsTol = 1E-8
sabino.Solver.MaxConvergenceFailures = 8
sabino.Solver.Nonlinear.MaxIter = 80
sabino.Solver.Nonlinear.ResidualTol = 1e-6

sabino.Solver.Nonlinear.EtaChoice = 'EtaConstant'
sabino.Solver.Nonlinear.EtaValue = 0.001
sabino.Solver.Nonlinear.UseJacobian = True
sabino.Solver.Nonlinear.DerivativeEpsilon = 1e-16
sabino.Solver.Nonlinear.StepTol = 1e-30
sabino.Solver.Nonlinear.Globalization = 'LineSearch'
sabino.Solver.Linear.KrylovDimension = 70
sabino.Solver.Linear.MaxRestarts = 2

sabino.Solver.Linear.Preconditioner = 'PFMG'
sabino.Solver.Linear.Preconditioner.PCMatrixType = 'FullJacobian'

#-----------------------------------------------------------------------------
# Distribute inputs and run simulation
#-----------------------------------------------------------------------------

sabino.run()
コード例 #19
0
dover.Solver.Nonlinear.DerivativeEpsilon = 1e-8
dover.Solver.Nonlinear.StepTol = 1e-20
dover.Solver.Nonlinear.Globalization = 'LineSearch'
dover.Solver.Linear.KrylovDimension = 20
dover.Solver.Linear.MaxRestart = 2

dover.Solver.Linear.Preconditioner = 'PFMG'
dover.Solver.PrintSubsurf = False
dover.Solver.Drop = 1E-20
dover.Solver.AbsTol = 1E-9

#---------------------------------------------------------
# Initial conditions: water pressure
#---------------------------------------------------------

# set water table to be at the bottom of the domain, the top layer is initially dry
dover.ICPressure.Type = 'HydroStaticPatch'
dover.ICPressure.GeomNames = 'domain'
dover.Geom.domain.ICPressure.Value = -3.0

dover.Geom.domain.ICPressure.RefGeom = 'domain'
dover.Geom.domain.ICPressure.RefPatch = 'z_upper'

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

dir_name = get_absolute_path('test_output/dover_pj')
mkdir(dir_name)
dover.run(working_directory=dir_name)
コード例 #20
0
#    pfset Patch.z-upper.BCPressure.Type		      OverlandDiffusive
#    pfset Solver.Nonlinear.UseJacobian                       True
#    pfset Solver.Linear.Preconditioner.PCMatrixType         FullJacobian

#    set runname Slab.$name.OverlandDif
#    puts "Running $runname OverlandDiffusive Jacobian True Nonsymmetric Preconditioner"
#    pfrun $runname
#    pfundist $runname
#    if $runcheck==1 {
#      set passed 1
#      foreach i "00000 00001 00002 00003 00004 00005 00006 00007 00008 00009 00010" {
#        if ![pftestFile $runname.out.press.$i.pfb "Max difference in Pressure for timestep $i" $sig_digits] {
#          set passed 0
#        }
#        if ![pftestFile  $runname.out.satur.$i.pfb "Max difference in Saturation for timestep $i" $sig_digits] {
#          set passed 0
#        }
#      }
#      if $passed {
#        puts "$runname : PASSED"
#      } {
#        puts "$runname : FAILED"
#      }
#    }

# }

dir_name = get_absolute_path('test_output/os_dwe')
mkdir(dir_name)
overland.run(working_directory=dir_name)
コード例 #21
0
in_file = [pfload $in_filename]

code = [catch {eval pfgetgrid $in_file} grid]

# Extract grid size information
dimension = [lindex $grid 0]
origin = [lindex $grid 1]
interval = [lindex $grid 2]

nx = [lindex $dimension 0]
ny = [lindex $dimension 1]
nz = [lindex $dimension 2]

x = [lindex $origin 0]
y = [lindex $origin 1]
z = [lindex $origin 2]

dx = [lindex $interval 0]
dy = [lindex $interval 1]
dz = [lindex $interval 2]

z_zero_plane = [pfgetsubbox $in_file 0 0 0 $nx $ny 1]

# pfsave $z_zero_plane -pfb $out_filename

#  


extract_plane_z_equal_zero.run()
コード例 #22
0
richards_box_proctest_vardz.Solver.MaxIter = 50000

richards_box_proctest_vardz.Solver.Nonlinear.MaxIter = 100
richards_box_proctest_vardz.Solver.Nonlinear.ResidualTol = 1e-7

richards_box_proctest_vardz.Solver.Nonlinear.EtaChoice = 'EtaConstant'
richards_box_proctest_vardz.Solver.Nonlinear.EtaValue = 1e-2

# used to test analytical and FD jacobian combinations
richards_box_proctest_vardz.Solver.Nonlinear.UseJacobian = True
#pfset Solver.Nonlinear.UseJacobian                       False

richards_box_proctest_vardz.Solver.Nonlinear.DerivativeEpsilon = 1e-14

richards_box_proctest_vardz.Solver.Linear.KrylovDimension = 100

# used to test different linear preconditioners

richards_box_proctest_vardz.Solver.Linear.Preconditioner = 'PFMG'
##pfset Solver.Linear.Preconditioner                       PFMGOctree
##pfset Solver.Linear.Preconditioner                       MGSemi
##pfset Solver.Linear.Preconditioner                       SMG

richards_box_proctest_vardz.UseClustering = False

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

richards_box_proctest_vardz.run()
コード例 #23
0
#Writing output options for CLM
#  PFB only, no SILO, no native CLM logs
PFCLM_SC.Solver.PrintLSMSink = False
PFCLM_SC.Solver.CLM.CLMDumpInterval = 1
PFCLM_SC.Solver.CLM.CLMFileDir = 'output/'
PFCLM_SC.Solver.CLM.BinaryOutDir = False
PFCLM_SC.Solver.CLM.IstepStart = 1
PFCLM_SC.Solver.WriteCLMBinary = False
PFCLM_SC.Solver.WriteSiloCLM = False
PFCLM_SC.Solver.CLM.WriteLogs = False
PFCLM_SC.Solver.CLM.WriteLastRST = True
PFCLM_SC.Solver.CLM.DailyRST = False
PFCLM_SC.Solver.CLM.SingleFile = True

#---------------------------------------------------
# Initial conditions: water pressure
#---------------------------------------------------

PFCLM_SC.ICPressure.Type = 'HydroStaticPatch'
PFCLM_SC.ICPressure.GeomNames = 'domain'
PFCLM_SC.Geom.domain.ICPressure.Value = -1.0
PFCLM_SC.Geom.domain.ICPressure.RefGeom = 'domain'
PFCLM_SC.Geom.domain.ICPressure.RefPatch = 'z_upper'

#-----------------------------------------------------------------------------
# Run ParFlow
#-----------------------------------------------------------------------------

PFCLM_SC.run()
コード例 #24
0
ファイル: pfmg_octree.py プロジェクト: mahdadt/parflow-360
pfmg.KnownSolution = 'NoKnownSolution'

#-----------------------------------------------------------------------------
# Set solver parameters
#-----------------------------------------------------------------------------

pfmg.Solver = 'Richards'
pfmg.Solver.MaxIter = 5

pfmg.Solver.Nonlinear.MaxIter = 10
pfmg.Solver.Nonlinear.ResidualTol = 1e-9
pfmg.Solver.Nonlinear.EtaChoice = 'EtaConstant'
pfmg.Solver.Nonlinear.EtaValue = 1e-5
pfmg.Solver.Nonlinear.UseJacobian = True
pfmg.Solver.Nonlinear.DerivativeEpsilon = 1e-2

pfmg.Solver.Linear.KrylovDimension = 10

pfmg.Solver.Linear.Preconditioner = 'PFMGOctree'

pfmg.Solver.Linear.Preconditioner.PFMGOctree.BoxSizePowerOf2 = 2

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

dir_name = get_absolute_path('test_output/pfmg_octree')
mkdir(dir_name)
pfmg.run(working_directory=dir_name)
コード例 #25
0
water_balance_y.Solver.WriteSiloSubsurfData = True
water_balance_y.Solver.WriteSiloPressure = True
water_balance_y.Solver.WriteSiloSaturation = True
water_balance_y.Solver.WriteSiloConcentration = True
water_balance_y.Solver.WriteSiloSlopes = True
water_balance_y.Solver.WriteSiloMask = True
water_balance_y.Solver.WriteSiloEvapTrans = True
water_balance_y.Solver.WriteSiloEvapTransSum = True
water_balance_y.Solver.WriteSiloOverlandSum = True
water_balance_y.Solver.WriteSiloMannings = True
water_balance_y.Solver.WriteSiloSpecificStorage = True

#---------------------------------------------------------
# Initial conditions: water pressure
#---------------------------------------------------------

# set water table to be at the bottom of the domain, the top layer is initially dry
water_balance_y.ICPressure.Type = 'HydroStaticPatch'
water_balance_y.ICPressure.GeomNames = 'domain'

water_balance_y.Geom.domain.ICPressure.Value = -3.0

water_balance_y.Geom.domain.ICPressure.RefGeom = 'domain'
water_balance_y.Geom.domain.ICPressure.RefPatch = 'z_upper'

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

water_balance_y.run()
コード例 #26
0
#-----------------------------------------------------------------------------

rbp.KnownSolution = 'NoKnownSolution'

#-----------------------------------------------------------------------------
# Set solver parameters
#-----------------------------------------------------------------------------

rbp.Solver = 'Richards'
rbp.Solver.MaxIter = 50000

rbp.Solver.Nonlinear.MaxIter = 100
rbp.Solver.Nonlinear.ResidualTol = 1e-6
rbp.Solver.Nonlinear.EtaChoice = 'EtaConstant'
rbp.Solver.Nonlinear.EtaValue = 1e-2
rbp.Solver.Nonlinear.UseJacobian = True

rbp.Solver.Nonlinear.DerivativeEpsilon = 1e-12

rbp.Solver.Linear.KrylovDimension = 100

rbp.Solver.Linear.Preconditioner = 'PFMG'

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

dir_name = get_absolute_path('test_output/rbp')
mkdir(dir_name)
rbp.run(working_directory=dir_name)
コード例 #27
0
#   }
# }

# run with KWE upwinding and analytical jacobian and nonsymmetric preconditioner
overland_tiltedV_DWE.Patch.z_upper.BCPressure.Type = 'OverlandDiffusive'
overland_tiltedV_DWE.Solver.Nonlinear.UseJacobian = True
overland_tiltedV_DWE.Solver.Linear.Preconditioner.PCMatrixType = 'FullJacobian'

# set runname TiltedV_OverlandDif
# puts "##########"
# puts "Running $runname Jacobian True Nonsymmetric Preconditioner"
# pfrun $runname
# pfundist $runname
# if $runcheck==1 {
#   set passed 1
#   foreach i "00000 00001 00002 00003 00004 00005 00006 00007 00008 00009 00010" {
#     if ![pftestFile $runname.out.press.$i.pfb "Max difference in Pressure for timestep $i" $sig_digits] {
#       set passed 0
#     }
#     if ![pftestFile  $runname.out.satur.$i.pfb "Max difference in Saturation for timestep $i" $sig_digits] {
#       set passed 0
#     }
#   }
#   if $passed {
#     puts "$runname : PASSED"
#   } {
#     puts "$runname : FAILED"
#   }
# }
overland_tiltedV_DWE.run()
コード例 #28
0
wbx.Solver.WriteSiloSaturation = True
wbx.Solver.WriteSiloConcentration = True
wbx.Solver.WriteSiloSlopes = True
wbx.Solver.WriteSiloMask = True
wbx.Solver.WriteSiloEvapTrans = True
wbx.Solver.WriteSiloEvapTransSum = True
wbx.Solver.WriteSiloOverlandSum = True
wbx.Solver.WriteSiloMannings = True
wbx.Solver.WriteSiloSpecificStorage = True

#---------------------------------------------------------
# Initial conditions: water pressure
#---------------------------------------------------------

# set water table to be at the bottom of the domain, the top layer is initially dry
wbx.ICPressure.Type = 'HydroStaticPatch'
wbx.ICPressure.GeomNames = 'domain'

wbx.Geom.domain.ICPressure.Value = -3.0

wbx.Geom.domain.ICPressure.RefGeom = 'domain'
wbx.Geom.domain.ICPressure.RefPatch = 'z_upper'

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

dir_name = get_absolute_path('test_output/wbx')
mkdir(dir_name)
wbx.run(working_directory=dir_name)
コード例 #29
0
#-----------------------------------------------------------------------------
# Exact solution specification for error calculations
#-----------------------------------------------------------------------------

richards_FBx.KnownSolution = 'NoKnownSolution'

#-----------------------------------------------------------------------------
# Set solver parameters
#-----------------------------------------------------------------------------
richards_FBx.Solver = 'Richards'
richards_FBx.Solver.MaxIter = 50000

richards_FBx.Solver.Nonlinear.MaxIter = 100
richards_FBx.Solver.Nonlinear.ResidualTol = 1e-6
richards_FBx.Solver.Nonlinear.EtaChoice = 'EtaConstant'
richards_FBx.Solver.Nonlinear.EtaValue = 1e-2
richards_FBx.Solver.Nonlinear.UseJacobian = True

richards_FBx.Solver.Nonlinear.DerivativeEpsilon = 1e-12

richards_FBx.Solver.Linear.KrylovDimension = 100

richards_FBx.Solver.Linear.Preconditioner = 'PFMG'

#-----------------------------------------------------------------------------
# Run and Unload the ParFlow output files
#-----------------------------------------------------------------------------

richards_FBx.run()
コード例 #30
0
ファイル: pfclm.py プロジェクト: vineetbansal/pfclm
#Writing output options for CLM
#  PFB only, no SILO, no native CLM logs
PFCLM_SC.Solver.PrintLSMSink = False
PFCLM_SC.Solver.CLM.CLMDumpInterval = 1
PFCLM_SC.Solver.CLM.CLMFileDir = OUTPUT_DIR
PFCLM_SC.Solver.CLM.BinaryOutDir = False
PFCLM_SC.Solver.CLM.IstepStart = 1
PFCLM_SC.Solver.WriteCLMBinary = False
PFCLM_SC.Solver.WriteSiloCLM = False
PFCLM_SC.Solver.CLM.WriteLogs = False
PFCLM_SC.Solver.CLM.WriteLastRST = True
PFCLM_SC.Solver.CLM.DailyRST = False
PFCLM_SC.Solver.CLM.SingleFile = True

#---------------------------------------------------
# Initial conditions: water pressure
#---------------------------------------------------

PFCLM_SC.ICPressure.Type = 'HydroStaticPatch'
PFCLM_SC.ICPressure.GeomNames = 'domain'
PFCLM_SC.Geom.domain.ICPressure.Value = -1.0
PFCLM_SC.Geom.domain.ICPressure.RefGeom = 'domain'
PFCLM_SC.Geom.domain.ICPressure.RefPatch = 'z_upper'

#-----------------------------------------------------------------------------
# Run ParFlow
#-----------------------------------------------------------------------------

PFCLM_SC.run(working_directory=OUTPUT_DIR)