def test_output(file_name): LW_Test.write(file_name, file_format='yaml') with open(get_absolute_path(f'{file_name}.yaml')) as new, \ open(get_absolute_path('$PF_SRC/test/correct_output/LW_test_ref.yaml.ref')) as ref: if new.read() == ref.read(): print('Success we have the same file') return True else: print('Files are different') return False
def verify_vegp_data(data): assert data path = get_absolute_path('$PF_SRC/test/correct_output/vegp_data.ref.json') with open(path, 'r') as rf: ref_data = json.load(rf) assert data == ref_data
def test_clmin_round_trip(clm): path = Path(get_absolute_path('drv_clmin.dat')) if path.exists(): path.unlink() CLMExporter(clm).write_input() new_clm = Run('clm', __file__) CLMImporter(new_clm).input_file(path) verify_clmin_data(new_clm)
def verify_vegm_data(data): # Test the shape and a few data points assert data.shape == (5, 5, 23) assert data[1, 1, 14] == 1 assert data[3, 4, 1] == -98.138 assert data[1, 2, 3] == 0.265 # Now test the whole array path = get_absolute_path('$PF_SRC/test/correct_output/drv_vegm.ref.npy') ref_data = np.load(path) assert np.array_equal(data, ref_data)
def load_csv_file(self, tableFile, encoding='utf-8-sig'): with open(get_absolute_path(tableFile), 'r', encoding=encoding) as csv_file: data_line = False for line in csv_file.readlines(): tokens = _csv_line_tokenizer(line) if data_line: self._process_data_line(tokens) else: data_line = self._process_first_line(tokens) return self
def test_vegp_round_trip(clm): path = Path(get_absolute_path('drv_vegp.dat')) if path.exists(): path.unlink() CLMExporter(clm).write_parameters() new_clm = Run('clm', __file__) veg_params = new_clm.Solver.CLM.Vegetation.Parameters # Set the land cover items veg_params.LandNames = veg_params.LandNames CLMImporter(new_clm).parameters_file(path) verify_vegp_data(new_clm)
def load_csv_file(self, table_file, encoding='utf-8-sig'): """Method to load a .csv file of a table of subsurface parameters Args: table_file (str): Path to the input .csv file. encoding='utf-8-sig': encoding of input file. """ with open(get_absolute_path(table_file), 'r', encoding=encoding) as csv_file: data_line = False for line in csv_file: tokens = _csv_line_tokenizer(line) if data_line: self._process_data_line(tokens) else: data_line = self._process_first_line(tokens) return self
sabino.ComputationalGrid.NZ = 20 #----------------------------------------------------------------------------- # Names of the GeomInputs #----------------------------------------------------------------------------- sabino.GeomInput.Names = 'domaininput' sabino.GeomInput.domaininput.GeomName = 'domain' sabino.GeomInput.domaininput.GeomNames = 'domain' #----------------------------------------------------------------------------- # PFSOL generation #----------------------------------------------------------------------------- sabino_mask = load_patch_matrix_from_sa_file(get_absolute_path('$PF_SRC/test/input/Sabino_Mask.sa')) # sabino_mask = load_patch_matrix_from_asc_file(get_absolute_path('$PF_SRC/test/input/Sabino_Mask.asc')) # sabino_mask = load_patch_matrix_from_image_file(get_absolute_path('$PF_SRC/test/input/Sabino_Mask.png')) # sabino_mask = load_patch_matrix_from_image_file(get_absolute_path('$PF_SRC/test/input/Sabino_Mask.tiff')) SolidFileBuilder(top=1, bottom=2, side=3) \ .mask(sabino_mask) \ .write('sabino_domain.pfsol', xllcorner=0, yllcorner=0, cellsize=90, vtk=True) \ .for_key(sabino.GeomInput.domaininput) #----------------------------------------------------------------------------- sabino.Geom.domain.Patches = 'top bottom edge' #----------------------------------------------------------------------------- # Domain Geometry
def write(self, name, xllcorner=0, yllcorner=0, cellsize=0, vtk=False): self.name = name output_file_path = get_absolute_path(name) if self.mask_array is None: raise Exception('No mask were define') jSize, iSize = self.mask_array.shape leftMask = np.zeros((jSize, iSize), dtype=np.int16) rightMask = np.zeros((jSize, iSize), dtype=np.int16) backMask = np.zeros((jSize, iSize), dtype=np.int16) frontMask = np.zeros((jSize, iSize), dtype=np.int16) bottomMask = np.zeros((jSize, iSize), dtype=np.int16) topMask = np.zeros((jSize, iSize), dtype=np.int16) for j in range(jSize): for i in range(iSize): if self.mask_array[j, i] != 0: patch_value = 0 if self.patch_ids_side is None else self.patch_ids_side[ j, i] # Left (-x) if i == 0 or self.mask_array[j, i - 1] == 0: leftMask[ j, i] = patch_value if patch_value else self.side_id # Right (+x) if i + 1 == iSize or self.mask_array[j, i + 1] == 0: rightMask[ j, i] = patch_value if patch_value else self.side_id # Back (-y) (y flipped) if j + 1 == jSize or self.mask_array[j + 1, i] == 0: backMask[ j, i] = patch_value if patch_value else self.side_id # Front (+y) (y flipped) if j == 0 or self.mask_array[j - 1, i] == 0: frontMask[ j, i] = patch_value if patch_value else self.side_id # Bottom (-z) patch_value = 0 if self.patch_ids_bottom is None else self.patch_ids_bottom[ j, i] bottomMask[ j, i] = patch_value if patch_value else self.bottom_id # Top (+z) patch_value = 0 if self.patch_ids_top is None else self.patch_ids_top[ j, i] topMask[j, i] = patch_value if patch_value else self.top_id # Generate asc / sa files writeFn = write_patch_matrix_as_asc settings = { 'xllcorner': xllcorner, 'yllcorner': yllcorner, 'cellsize': cellsize, 'NODATA_value': 0, } short_name = name[:-6] left_file_path = get_absolute_path(f'{short_name}_left.asc') writeFn(leftMask, left_file_path, **settings) right_file_path = get_absolute_path(f'{short_name}_right.asc') writeFn(rightMask, right_file_path, **settings) front_file_path = get_absolute_path(f'{short_name}_front.asc') writeFn(frontMask, front_file_path, **settings) back_file_path = get_absolute_path(f'{short_name}_back.asc') writeFn(backMask, back_file_path, **settings) top_file_path = get_absolute_path(f'{short_name}_top.asc') writeFn(topMask, top_file_path, **settings) bottom_file_path = get_absolute_path(f'{short_name}_bottom.asc') writeFn(bottomMask, bottom_file_path, **settings) # Trigger conversion print('=== pfmask-to-pfsol ===: BEGIN') extra = [] if vtk: extra.append('--vtk') extra.append(f'{output_file_path[:-6]}.vtk') os.system( f'$PARFLOW_DIR/bin/pfmask-to-pfsol --mask-top {top_file_path} --mask-bottom {bottom_file_path} --mask-left {left_file_path} --mask-right {right_file_path} --mask-front {front_file_path} --mask-back {back_file_path} --pfsol {output_file_path} {" ".join(extra)}' ) print('=== pfmask-to-pfsol ===: END') return self
#----------------------------------------------------------------------------- # Test CLM with multiple reuse values for input. The same test is run # with different timesteps and reuse values set to match. E.G. 1s = reuse 1, 0.1s = reuse 10. #----------------------------------------------------------------------------- from parflow import Run from parflow.tools.fs import cp, mkdir, get_absolute_path clm = Run("clm_reuse", __file__) #----------------------------------------------------------------------------- # Copying input files #----------------------------------------------------------------------------- dir_name = get_absolute_path('test_output/clm_reuse') mkdir(dir_name) cp('$PF_SRC/test/tcl/clm/clm-reuse/drv_clmin.dat', dir_name) cp('$PF_SRC/test/tcl/clm/clm-reuse/drv_vegm.dat', dir_name) cp('$PF_SRC/test/tcl/clm/clm-reuse/drv_vegp.dat', dir_name) cp('$PF_SRC/test/tcl/clm/clm-reuse/forcing_1.txt', dir_name) #----------------------------------------------------------------------------- # Setting test variables #----------------------------------------------------------------------------- # Total runtime of simulation stopt = 100 # Reuse values to run with reuseValues = [1, 4]
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)
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)
def driver_file_written_times(): return { key: os.stat(get_absolute_path(x)).st_mtime for key, x in default_driver_file_names.items() }
# 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)
def test_subsurface_table(file_name): path = '$PF_SRC/test/correct_output/tables_LW_subsurface.txt.ref' ref = Path(get_absolute_path(path)).read_text() new = Path(get_absolute_path(file_name)).read_text() assert ref == new
sabino = Run("sabino", __file__) #----------------------------------------------------------------------------- # PFSOL generation #----------------------------------------------------------------------------- color_to_patch = { '#FFFFFF': 0, # Discard '#466CFF': 2, # River '#C56C00': 3, # Land '#1900FF': 4, # Sea '#3DFFFF': 5, # Lake } mask = load_patch_matrix_from_image_file( get_absolute_path('$PF_SRC/test/input/mask.png')) top_patches = load_patch_matrix_from_image_file( get_absolute_path('$PF_SRC/test/input/mask_top.png'), color_to_patch, fall_back_id=6) side_patches = load_patch_matrix_from_image_file( get_absolute_path('$PF_SRC/test/input/mask_side.png'), color_to_patch, fall_back_id=3) #----------------------------------------------------------------------------- SolidFileBuilder(bottom=1) \ .mask(mask) \
# Exact solution specification for error calculations #----------------------------------------------------------------------------- smg.KnownSolution = 'NoKnownSolution' #----------------------------------------------------------------------------- # Set solver parameters #----------------------------------------------------------------------------- smg.Solver = 'Richards' smg.Solver.MaxIter = 5 smg.Solver.Nonlinear.MaxIter = 10 smg.Solver.Nonlinear.ResidualTol = 1e-9 smg.Solver.Nonlinear.EtaChoice = 'EtaConstant' smg.Solver.Nonlinear.EtaValue = 1e-5 smg.Solver.Nonlinear.UseJacobian = True smg.Solver.Nonlinear.DerivativeEpsilon = 1e-2 smg.Solver.Linear.KrylovDimension = 10 smg.Solver.Linear.Preconditioner = 'SMG' #----------------------------------------------------------------------------- # Run and Unload the ParFlow output files #----------------------------------------------------------------------------- dir_name = get_absolute_path('test_output/smg') mkdir(dir_name) smg.run(working_directory=dir_name)
clm.Solver.CLM.Vegetation.Map.Clay.Value = 0.265 clm.Solver.CLM.Vegetation.Map.Color.Type = 'Constant' clm.Solver.CLM.Vegetation.Map.Color.Value = 2 #--------------------------------------------------------- # Setting land use fractions #--------------------------------------------------------- clm.Solver.CLM.Vegetation.Map.LandFrac.forest_en.Type = 'Constant' clm.Solver.CLM.Vegetation.Map.LandFrac.forest_en.Value = 0.0 forest_eb_mat = np.zeros((clm.ComputationalGrid.NX, clm.ComputationalGrid.NY)) forest_eb_mat[1, :] = 1.0 file_name = 'forest_eb_mat.pfb' write_array(get_absolute_path(file_name), forest_eb_mat) clm.Solver.CLM.Vegetation.Map.LandFrac.forest_eb.Type = 'PFBFile' clm.Solver.CLM.Vegetation.Map.LandFrac.forest_eb.FileName = file_name clm.Solver.CLM.Vegetation.Map.LandFrac.forest_dn.Type = 'Constant' clm.Solver.CLM.Vegetation.Map.LandFrac.forest_dn.Value = 0.5 clm.Solver.CLM.Vegetation.Map.LandFrac.forest_db.Type = 'Constant' clm.Solver.CLM.Vegetation.Map.LandFrac.forest_db.Value = 0.0 #--------------------------------------------------------- # Testing clm data reader for veg mapping #--------------------------------------------------------- # Reading drv_vegm.dat into 3D array
# 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 get_absolute_path, mkdir, chdir 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 #---------------------------------------------------------
# this runs CLM test case # # Import the ParFlow TCL package # from parflow import Run from parflow.tools.fs import mkdir, get_absolute_path clm_samrai = Run("clm_samrai", __file__) dir_name = get_absolute_path('test_output/clm_samrai') mkdir(dir_name) # foreach dir {qflx_evap_grnd eflx_lh_tot qflx_evap_tot qflx_tran_veg correct_output qflx_infl swe_out eflx_lwrad_out t_grnd diag_out qflx_evap_soi eflx_soil_grnd eflx_sh_tot qflx_evap_veg qflx_top_soil} { # file mkdir $dir # } #----------------------------------------------------------------------------- # File input version number #----------------------------------------------------------------------------- clm_samrai.FileVersion = 4 #----------------------------------------------------------------------------- # Process Topology #----------------------------------------------------------------------------- P = 1 Q = 1 R = 1 NumPatches = [lindex $argv 3]
# 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)
#----------------------------------------------------------------------------- # this runs CLM test case #----------------------------------------------------------------------------- from parflow import Run from parflow.tools.fs import mkdir, cp, get_absolute_path #----------------------------------------------------------------------------- # Making output directories and copying input files #----------------------------------------------------------------------------- clm_jac = Run("clm_jac", __file__) dir_name = get_absolute_path('test_output/clm_jac') mkdir(dir_name) directories = [ 'qflx_evap_grnd', 'eflx_lh_tot', 'qflx_evap_tot', 'qflx_tran_veg', 'correct_output', 'qflx_infl', 'swe_out', 'eflx_lwrad_out', 't_grnd', 'diag_out', 'qflx_evap_soi', 'eflx_soil_grnd', 'eflx_sh_tot', 'qflx_evap_veg', 'qflx_top_soil' ] for directory in directories: mkdir(dir_name + '/' + directory) cp('$PF_SRC/test/tcl/clm/drv_clmin.dat', dir_name) cp('$PF_SRC/test/tcl/clm/drv_vegm.dat', dir_name) cp('$PF_SRC/test/tcl/clm/drv_vegp.dat', dir_name) cp('$PF_SRC/test/tcl/clm/narr_1hr.sc3.txt.0', dir_name)
#-------------------------------------------------------------- # This runs the a Little Washita Test Problem with variable dz # and a constant rain forcing. The full Jacobian is use and there is no dampening in the # overland flow. #-------------------------------------------------------------- from parflow import Run from parflow.tools.fs import cp, mkdir, chdir, get_absolute_path 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 #---------------------------------------------------------
#----------------------------------------------------------------------------- # This is a 2D crater problem w/ time varying input and topography #----------------------------------------------------------------------------- from parflow import Run from parflow.tools.fs import cp, mkdir, get_absolute_path crater = Run("crater", __file__) # --------------------------------------------------------- # Copy testing data in test directory # --------------------------------------------------------- dir_name = get_absolute_path('test_output/crater') mkdir(dir_name) cp('$PF_SRC/test/input/crater2D.pfsol', dir_name) # --------------------------------------------------------- crater.FileVersion = 4 crater.Process.Topology.P = 1 crater.Process.Topology.Q = 1 crater.Process.Topology.R = 1 #--------------------------------------------------------- # Computational Grid #--------------------------------------------------------- crater.ComputationalGrid.Lower.X = 0.0
def test_fewer_land_names(clm): vegm_file = Path(get_absolute_path('drv_vegm.dat')) vegp_file = Path(get_absolute_path('drv_vegp.dat')) for path in (vegm_file, vegp_file): if path.exists(): path.unlink() CLMExporter(clm).write_map().write_parameters() new_clm = Run('clm', __file__) veg_params = new_clm.Solver.CLM.Vegetation.Parameters veg_map = new_clm.Solver.CLM.Vegetation.Map # Set only two land cover items veg_params.LandNames = 'forest_en forest_eb' CLMImporter(new_clm) \ .map_file(vegm_file) \ .parameters_file(vegp_file) assert veg_params.LandNames == ['forest_en', 'forest_eb'] assert 'water' not in veg_params.keys() assert 'water' not in veg_map.keys() veg_map.LandFrac.forest_en.Value = 0.6 veg_map.LandFrac.forest_eb.Value = 0.4 veg_map.LandFrac.forest_en.Type = 'Constant' veg_map.LandFrac.forest_eb.Type = 'Constant' new_clm.ComputationalGrid.NX = 5 new_clm.ComputationalGrid.NY = 5 CLMExporter(new_clm).write_map().write_parameters() vegm_data = read_clm(vegm_file, type='vegm') vegp_data = read_clm(vegp_file, type='vegp') # These should be 0.6 and 0.4 shape = vegm_data.shape[:2] assert np.array_equal(vegm_data[:, :, 5], np.full(shape, 0.6)) assert np.array_equal(vegm_data[:, :, 6], np.full(shape, 0.4)) # All of the vegm data after the 2 land types should be zero last_land_ind = 6 zeros = np.zeros(shape) for i in range(last_land_ind + 1, vegm_data.shape[2]): assert np.array_equal(vegm_data[:, :, i], zeros) # All of the vegp data after the second land type should be equal # to the default default_vegp = CLMExporter(new_clm)._default_vegp_values for key, val in vegp_data.items(): for i in range(2, len(val)): assert val[i] == default_vegp[key] # Make sure at least one of the other values is correct key = 'z0m' ind = 1 val = 2.2 assert vegp_data[key][ind] != default_vegp[key] assert vegp_data[key][ind] == val
sabino.ComputationalGrid.NZ = 20 #----------------------------------------------------------------------------- # Names of the GeomInputs #----------------------------------------------------------------------------- sabino.GeomInput.Names = 'domaininput' sabino.GeomInput.domaininput.GeomName = 'domain' sabino.GeomInput.domaininput.GeomNames = 'domain' #----------------------------------------------------------------------------- # PFSOL generation #----------------------------------------------------------------------------- sabino_mask = load_patch_matrix_from_pfb_file(get_absolute_path('$PF_SRC/test/input/sabino_mask.pfb')) SolidFileBuilder(top=1, bottom=2, side=3) \ .mask(sabino_mask) \ .write('sabino_domain.pfsol', xllcorner=0, yllcorner=0, cellsize=90, vtk=True) \ .for_key(sabino.GeomInput.domaininput) #----------------------------------------------------------------------------- sabino.Geom.domain.Patches = 'top bottom edge' #----------------------------------------------------------------------------- # Domain Geometry #----------------------------------------------------------------------------- sabino.Geom.domain.Lower.X = 0.0
#----------------------------------------------------------------------------- # Testing pfset with a .pfidb file #----------------------------------------------------------------------------- from pathlib import Path from parflow import Run from parflow.tools.fs import get_absolute_path dsingle = Run("dsingle", __file__) dsingle.pfset(pfidb_file=get_absolute_path( '$PF_SRC/test/correct_output/dsingle.pfidb.ref')) # Test pfidb generated, _ = dsingle.write() old_text = Path(generated).read_text() dsingle2 = Run.from_definition(generated) generated, _ = dsingle2.write() new_text = Path(generated).read_text() assert old_text and new_text assert old_text == new_text # Test yaml generated, _ = dsingle.write(file_format='yaml') old_text = Path(generated).read_text()
# 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)
#----------------------------------------------------------------------------- # pfset: flat_map #----------------------------------------------------------------------------- pfset_test.pfset( flat_map={ 'Phase.Saturation.Type': 'VanGenuchten', 'Phase.Saturation.GeomNames': 'domain', }) pfset_test.Phase.pfset(flat_map={ 'RelPerm.Type': 'VanGenuchten', 'RelPerm.GeomNames': 'domain', }) #----------------------------------------------------------------------------- #----------------------------------------------------------------------------- pfset_test.validate() generatedFile, runFile = pfset_test.write(file_format='yaml') # Prevent regression with open(generatedFile) as new, open( get_absolute_path( '$PF_SRC/test/correct_output/pfset_test.yaml.ref')) as ref: if new.read() == ref.read(): print('Success we have the same file') else: print('Files are different') sys.exit(1)
#----------------------------------------------------------------------------- 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)