def run_simulation(parallel=False, verbose=False):
#--------------------------------------------------------------------------
# Setup computational domain and quantities
#--------------------------------------------------------------------------
domain = rectangular_cross_domain(M, N)
domain.set_name('odomain') # Set sww filename
domain.set_datadir('.')
domain.set_quantity('elevation', topography) # Use function for elevation
domain.set_quantity('friction', 0.0) # Constant friction
domain.set_quantity('stage', expression='elevation') # Dry initial stage
domain.set_quantities_to_be_stored({'elevation': 2,'stage': 2,'xmomentum': 2,'ymomentum': 2})
domain.set_store_vertices_uniquely(False)
domain.set_flow_algorithm('DE1')
georef = Geo_reference(zone=56,xllcorner=100000.0,yllcorner=200000.0)
domain.set_georeference(georef)
#--------------------------------------------------------------------------
# Create pickled partition
#--------------------------------------------------------------------------
if myid == 0:
if verbose: print 'DUMPING PARTITION DATA'
sequential_distribute_dump(domain, numprocs, verbose=verbose, parameters=new_parameters)
#--------------------------------------------------------------------------
# Create the parallel domains
#--------------------------------------------------------------------------
if parallel:
if myid == 0 and verbose : print 'DISTRIBUTING TO PARALLEL DOMAIN'
pdomain = distribute(domain, verbose=verbose, parameters=new_parameters)
pdomain.set_name('pdomain')
if myid == 0 and verbose : print 'LOADING IN PARALLEL DOMAIN'
sdomain = sequential_distribute_load(filename='odomain', verbose = verbose)
sdomain.set_name('sdomain')
assert domain.get_datadir() == pdomain.get_datadir()
assert domain.get_store() == pdomain.get_store()
assert domain.get_store_centroids() == pdomain.get_store_centroids()
assert domain.smooth == pdomain.smooth
assert domain.reduction == pdomain.reduction
assert domain.minimum_storable_height == pdomain.minimum_storable_height
assert domain.get_flow_algorithm() == pdomain.get_flow_algorithm()
assert domain.get_minimum_allowed_height() == pdomain.get_minimum_allowed_height()
assert domain.geo_reference == pdomain.geo_reference
assert domain.get_datadir() == sdomain.get_datadir()
assert domain.get_store() == sdomain.get_store()
assert domain.get_store_centroids() == sdomain.get_store_centroids()
assert domain.smooth == sdomain.smooth
assert domain.reduction == sdomain.reduction
assert domain.minimum_storable_height == sdomain.minimum_storable_height
assert domain.get_flow_algorithm() == sdomain.get_flow_algorithm()
assert domain.get_minimum_allowed_height() == sdomain.get_minimum_allowed_height()
assert domain.geo_reference == sdomain.geo_reference
def _setup_original_domain(self, np=None):
"""
Create sequential domain and partition
"""
verbose = self.verbose
outname = self.outname
partition_dir = self.partition_dir
if np is None:
np = numprocs
# Only create the sequential domain on processor 0
if myid == 0:
if verbose: print('CREATING PARTITIONED DOMAIN')
# Let's see if we have already pickled this domain
pickle_name = outname+'_P%g_%g.pickle'% (1,0)
pickle_name = join(partition_dir,pickle_name)
if os.path.exists(pickle_name):
if verbose: print('Saved domain seems to already exist')
else:
domain = self.setup_domain(self)
if verbose: print('Saving Domain')
sequential_distribute_dump(domain, 1, partition_dir=partition_dir, verbose=verbose)
# Now partition the domain
if verbose: print('Load in saved sequential pickled domain')
domain = sequential_distribute_load_pickle_file(pickle_name, np=1, verbose = verbose)
par_pickle_name = outname+'_P%g_%g.pickle'% (np,0)
par_pickle_name = join(partition_dir,par_pickle_name)
if os.path.exists(par_pickle_name):
if verbose: print('Saved partitioned domain seems to already exist')
else:
if verbose: print('Dump partitioned domains')
sequential_distribute_dump(domain, np, partition_dir=partition_dir, verbose=verbose)
barrier()
#===============================================================================
# Setup parallel domain
#===============================================================================
if myid == 0 and verbose: print('LOADING PARTITIONED DOMAIN')
self.domain = sequential_distribute_load(filename=join(partition_dir,outname), verbose = self.verbose)
def _setup_original_domain(self, np=None):
"""
Create sequential domain and partition
"""
verbose = self.verbose
outname = self.outname
partition_dir = self.partition_dir
if np is None:
np = numprocs
# Only create the sequential domain on processor 0
if myid == 0:
if verbose: print 'CREATING PARTITIONED DOMAIN'
# Let's see if we have already pickled this domain
pickle_name = outname+'_P%g_%g.pickle'% (1,0)
pickle_name = join(partition_dir,pickle_name)
if os.path.exists(pickle_name):
if verbose: print 'Saved domain seems to already exist'
else:
domain = self.setup_domain(self)
if verbose: print 'Saving Domain'
sequential_distribute_dump(domain, 1, partition_dir=partition_dir, verbose=verbose)
# Now partition the domain
if verbose: print 'Load in saved sequential pickled domain'
domain = sequential_distribute_load_pickle_file(pickle_name, np=1, verbose = verbose)
par_pickle_name = outname+'_P%g_%g.pickle'% (np,0)
par_pickle_name = join(partition_dir,par_pickle_name)
if os.path.exists(par_pickle_name):
if verbose: print 'Saved partitioned domain seems to already exist'
else:
if verbose: print 'Dump partitioned domains'
sequential_distribute_dump(domain, np, partition_dir=partition_dir, verbose=verbose)
barrier()
#===============================================================================
# Setup parallel domain
#===============================================================================
if myid == 0 and verbose: print 'LOADING PARTITIONED DOMAIN'
self.domain = sequential_distribute_load(filename=join(partition_dir,outname), verbose = self.verbose)
def run_simulation(parallel=False, verbose=False):
#--------------------------------------------------------------------------
# Setup computational domain and quantities
#--------------------------------------------------------------------------
if myid == 0:
domain = rectangular_cross_domain(M, N)
domain.set_name('odomain') # Set sww filename
domain.set_datadir('.')
domain.set_quantity('elevation', topography) # Use function for elevation
domain.set_quantity('friction', 0.0) # Constant friction
domain.set_quantity('stage', expression='elevation') # Dry initial stage
else:
domain = None
#--------------------------------------------------------------------------
# Create pickled partition
#--------------------------------------------------------------------------
if myid == 0:
if verbose: print 'DUMPING PARTITION DATA'
sequential_distribute_dump(domain, numprocs, verbose=verbose, parameters=new_parameters)
#--------------------------------------------------------------------------
# Create the parallel domains
#--------------------------------------------------------------------------
if parallel:
if myid == 0 and verbose : print 'DISTRIBUTING TO PARALLEL DOMAIN'
pdomain = distribute(domain, verbose=verbose, parameters=new_parameters)
pdomain.set_name('pdomain')
if myid == 0 and verbose : print 'LOADING IN PARALLEL DOMAIN'
sdomain = sequential_distribute_load(filename='odomain', verbose = verbose)
sdomain.set_name('sdomain')
if myid == 0 and verbose: print 'EVOLVING pdomain'
setup_and_evolve(pdomain, verbose=verbose)
if myid == 0 and verbose: print 'EVOLVING sdomain'
setup_and_evolve(sdomain, verbose=verbose)
if myid == 0:
if verbose: print 'EVOLVING odomain'
setup_and_evolve(domain, verbose=verbose)
if myid == 0 and verbose:
parameter_file=open('odomain.txt', 'w')
from pprint import pprint
pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
parameter_file.close()
parameter_file=open('sdomain.txt', 'w')
from pprint import pprint
pprint(sdomain.get_algorithm_parameters(),parameter_file,indent=4)
parameter_file.close()
parameter_file=open('pdomain.txt', 'w')
from pprint import pprint
pprint(pdomain.get_algorithm_parameters(),parameter_file,indent=4)
parameter_file.close()
assert num.allclose(pdomain.quantities['stage'].centroid_values, sdomain.quantities['stage'].centroid_values)
assert num.allclose(pdomain.quantities['stage'].vertex_values, sdomain.quantities['stage'].vertex_values)
assert num.allclose(pdomain.vertex_coordinates, sdomain.vertex_coordinates)
assert num.allclose(pdomain.centroid_coordinates, sdomain.centroid_coordinates)
#---------------------------------
# Now compare the merged sww files
#---------------------------------
if myid == 0:
if verbose: print 'COMPARING SWW FILES'
odomain_v = util.get_output('odomain.sww')
odomain_c = util.get_centroids(odomain_v)
pdomain_v = util.get_output('pdomain.sww')
pdomain_c = util.get_centroids(pdomain_v)
sdomain_v = util.get_output('sdomain.sww')
sdomain_c = util.get_centroids(sdomain_v)
# Test some values against the original ordering
if verbose:
order = 2
print 'PDOMAIN CENTROID VALUES'
print num.linalg.norm(odomain_c.x-pdomain_c.x,ord=order)
print num.linalg.norm(odomain_c.y-pdomain_c.y,ord=order)
print num.linalg.norm(odomain_c.stage[-1]-pdomain_c.stage[-1],ord=order)
print num.linalg.norm(odomain_c.xmom[-1]-pdomain_c.xmom[-1],ord=order)
print num.linalg.norm(odomain_c.ymom[-1]-pdomain_c.ymom[-1],ord=order)
print num.linalg.norm(odomain_c.xvel[-1]-pdomain_c.xvel[-1],ord=order)
print num.linalg.norm(odomain_c.yvel[-1]-pdomain_c.yvel[-1],ord=order)
print 'SDOMAIN CENTROID VALUES'
print num.linalg.norm(odomain_c.x-sdomain_c.x,ord=order)
print num.linalg.norm(odomain_c.y-sdomain_c.y,ord=order)
print num.linalg.norm(odomain_c.stage[-1]-sdomain_c.stage[-1],ord=order)
print num.linalg.norm(odomain_c.xmom[-1]-sdomain_c.xmom[-1],ord=order)
print num.linalg.norm(odomain_c.ymom[-1]-sdomain_c.ymom[-1],ord=order)
print num.linalg.norm(odomain_c.xvel[-1]-sdomain_c.xvel[-1],ord=order)
print num.linalg.norm(odomain_c.yvel[-1]-sdomain_c.yvel[-1],ord=order)
print 'PDOMAIN VERTEX VALUES'
print num.linalg.norm(odomain_v.stage[-1]-pdomain_v.stage[-1],ord=order)
print num.linalg.norm(odomain_v.xmom[-1]-pdomain_v.xmom[-1],ord=order)
print num.linalg.norm(odomain_v.ymom[-1]-pdomain_v.ymom[-1],ord=order)
print num.linalg.norm(odomain_v.xvel[-1]-pdomain_v.xvel[-1],ord=order)
print num.linalg.norm(odomain_v.yvel[-1]-pdomain_v.yvel[-1],ord=order)
print 'SDOMAIN VERTEX VALUES'
print num.linalg.norm(odomain_v.stage[-1]-sdomain_v.stage[-1],ord=order)
print num.linalg.norm(odomain_v.xmom[-1]-sdomain_v.xmom[-1],ord=order)
print num.linalg.norm(odomain_v.ymom[-1]-sdomain_v.ymom[-1],ord=order)
print num.linalg.norm(odomain_v.xvel[-1]-sdomain_v.xvel[-1],ord=order)
print num.linalg.norm(odomain_v.yvel[-1]-sdomain_v.yvel[-1],ord=order)
assert num.allclose(odomain_c.stage,pdomain_c.stage)
assert num.allclose(odomain_c.xmom,pdomain_c.xmom)
assert num.allclose(odomain_c.ymom,pdomain_c.ymom)
assert num.allclose(odomain_c.xvel,pdomain_c.xvel)
assert num.allclose(odomain_c.yvel,pdomain_c.yvel)
assert num.allclose(odomain_v.x,pdomain_v.x)
assert num.allclose(odomain_v.y,pdomain_v.y)
assert num.linalg.norm(odomain_v.x-pdomain_v.x,ord=0) == 0
assert num.linalg.norm(odomain_v.y-pdomain_v.y,ord=0) == 0
assert num.linalg.norm(odomain_v.stage[-1]-pdomain_v.stage[-1],ord=0) < 100
assert num.linalg.norm(odomain_v.xmom[-1]-pdomain_v.xmom[-1],ord=0) < 100
assert num.linalg.norm(odomain_v.ymom[-1]-pdomain_v.ymom[-1],ord=0) < 100
assert num.linalg.norm(odomain_v.xvel[-1]-pdomain_v.xvel[-1],ord=0) < 100
assert num.linalg.norm(odomain_v.yvel[-1]-pdomain_v.yvel[-1],ord=0) < 100
assert num.allclose(odomain_c.x,sdomain_c.x)
assert num.allclose(odomain_c.y,sdomain_c.y)
assert num.allclose(odomain_c.stage,sdomain_c.stage)
assert num.allclose(odomain_c.xmom,sdomain_c.xmom)
assert num.allclose(odomain_c.ymom,sdomain_c.ymom)
assert num.allclose(odomain_c.xvel,sdomain_c.xvel)
assert num.allclose(odomain_c.yvel,sdomain_c.yvel)
assert num.allclose(odomain_v.x,sdomain_v.x)
assert num.allclose(odomain_v.y,sdomain_v.y)
order = 0
assert num.linalg.norm(odomain_v.x-sdomain_v.x,ord=order) == 0
assert num.linalg.norm(odomain_v.y-sdomain_v.y,ord=order) == 0
assert num.linalg.norm(odomain_v.stage[-1]-sdomain_v.stage[-1],ord=order) < 100
assert num.linalg.norm(odomain_v.xmom[-1]-sdomain_v.xmom[-1],ord=order) < 100
assert num.linalg.norm(odomain_v.ymom[-1]-sdomain_v.ymom[-1],ord=order) < 100
assert num.linalg.norm(odomain_v.xvel[-1]-sdomain_v.xvel[-1],ord=order) < 100
assert num.linalg.norm(odomain_v.yvel[-1]-sdomain_v.yvel[-1],ord=order) < 100
# COMPARE CENTROID PDOMAIN SDOMAIN
assert num.allclose(pdomain_c.x,sdomain_c.x)
assert num.allclose(pdomain_c.y,sdomain_c.y)
assert num.allclose(pdomain_c.stage[-1],sdomain_c.stage[-1])
assert num.allclose(pdomain_c.xmom[-1],sdomain_c.xmom[-1])
assert num.allclose(pdomain_c.ymom[-1],sdomain_c.ymom[-1])
assert num.allclose(pdomain_c.xvel[-1],sdomain_c.xvel[-1])
assert num.allclose(pdomain_c.yvel[-1],sdomain_c.yvel[-1])
# COMPARE VERTEX PDOMAIN SDOMAIN
assert num.allclose(pdomain_v.x,sdomain_v.x)
assert num.allclose(pdomain_v.y,sdomain_v.y)
assert num.allclose(pdomain_v.stage[-1],sdomain_v.stage[-1])
assert num.allclose(pdomain_v.xmom[-1],sdomain_v.xmom[-1])
assert num.allclose(pdomain_v.ymom[-1],sdomain_v.ymom[-1])
assert num.allclose(pdomain_v.xvel[-1],sdomain_v.xvel[-1])
assert num.allclose(pdomain_v.yvel[-1],sdomain_v.yvel[-1])
import os
os.remove('odomain.sww')
os.remove('pdomain.sww')
os.remove('sdomain.sww')
os.remove('odomain_P4_0.pickle')
os.remove('odomain_P4_1.pickle')
os.remove('odomain_P4_2.pickle')
os.remove('odomain_P4_3.pickle')
def run_simulation(parallel=False, verbose=False):
#--------------------------------------------------------------------------
# Setup computational domain and quantities
#--------------------------------------------------------------------------
domain = rectangular_cross_domain(M, N)
domain.set_name('odomain') # Set sww filename
domain.set_datadir('.')
domain.set_quantity('elevation', topography) # Use function for elevation
domain.set_quantity('friction', 0.0) # Constant friction
domain.set_quantity('stage', expression='elevation') # Dry initial stage
domain.set_quantities_to_be_stored({
'elevation': 2,
'stage': 2,
'xmomentum': 2,
'ymomentum': 2
})
domain.set_store_vertices_uniquely(False)
domain.set_flow_algorithm('DE1')
georef = Geo_reference(zone=56, xllcorner=100000.0, yllcorner=200000.0)
domain.set_georeference(georef)
#--------------------------------------------------------------------------
# Create pickled partition
#--------------------------------------------------------------------------
if myid == 0:
if verbose: print 'DUMPING PARTITION DATA'
sequential_distribute_dump(domain,
numprocs,
verbose=verbose,
parameters=new_parameters)
#--------------------------------------------------------------------------
# Create the parallel domains
#--------------------------------------------------------------------------
if parallel:
if myid == 0 and verbose: print 'DISTRIBUTING TO PARALLEL DOMAIN'
pdomain = distribute(domain,
verbose=verbose,
parameters=new_parameters)
pdomain.set_name('pdomain')
if myid == 0 and verbose: print 'LOADING IN PARALLEL DOMAIN'
sdomain = sequential_distribute_load(filename='odomain',
verbose=verbose)
sdomain.set_name('sdomain')
assert domain.get_datadir() == pdomain.get_datadir()
assert domain.get_store() == pdomain.get_store()
assert domain.get_store_centroids() == pdomain.get_store_centroids()
assert domain.smooth == pdomain.smooth
assert domain.reduction == pdomain.reduction
assert domain.minimum_storable_height == pdomain.minimum_storable_height
assert domain.get_flow_algorithm() == pdomain.get_flow_algorithm()
assert domain.get_minimum_allowed_height(
) == pdomain.get_minimum_allowed_height()
assert domain.geo_reference == pdomain.geo_reference
assert domain.get_datadir() == sdomain.get_datadir()
assert domain.get_store() == sdomain.get_store()
assert domain.get_store_centroids() == sdomain.get_store_centroids()
assert domain.smooth == sdomain.smooth
assert domain.reduction == sdomain.reduction
assert domain.minimum_storable_height == sdomain.minimum_storable_height
assert domain.get_flow_algorithm() == sdomain.get_flow_algorithm()
assert domain.get_minimum_allowed_height(
) == sdomain.get_minimum_allowed_height()
assert domain.geo_reference == sdomain.geo_reference
def run_simulation(parallel=False, verbose=False):
#--------------------------------------------------------------------------
# Setup computational domain and quantities
#--------------------------------------------------------------------------
domain = rectangular_cross_domain(M, N)
domain.set_name('odomain') # Set sww filename
domain.set_datadir('.')
domain.set_quantity('elevation', topography) # Use function for elevation
domain.set_quantity('friction', 0.0) # Constant friction
domain.set_quantity('stage', expression='elevation') # Dry initial stage
domain.set_quantities_to_be_stored({'elevation': 2,'stage': 2,'xmomentum': 2,'ymomentum': 2})
domain.set_store_vertices_uniquely(False)
domain.set_flow_algorithm('DE1')
georef = Geo_reference(zone=56,xllcorner=100000.0,yllcorner=200000.0)
domain.set_georeference(georef)
#--------------------------------------------------------------------------
# Create pickled partition
#--------------------------------------------------------------------------
if myid == 0:
if verbose: print('DUMPING PARTITION DATA')
sequential_distribute_dump(domain, numprocs, verbose=verbose, parameters=new_parameters)
#--------------------------------------------------------------------------
# Create the parallel domains
#--------------------------------------------------------------------------
if parallel:
if myid == 0 and verbose : print('DISTRIBUTING TO PARALLEL DOMAIN')
pdomain = distribute(domain, verbose=verbose, parameters=new_parameters)
pdomain.set_name('pdomain')
if myid == 0 and verbose : print('LOADING IN PARALLEL DOMAIN')
sdomain = sequential_distribute_load(filename='odomain', verbose = verbose)
sdomain.set_name('sdomain')
if myid == 0 and verbose : print('TESTING AGAINST SEQUENTIAL DOMAIN')
assert domain.get_datadir() == pdomain.get_datadir()
assert domain.get_store() == pdomain.get_store()
assert domain.get_store_centroids() == pdomain.get_store_centroids()
assert domain.smooth == pdomain.smooth
assert domain.reduction == pdomain.reduction
assert domain.minimum_storable_height == pdomain.minimum_storable_height
assert domain.get_flow_algorithm() == pdomain.get_flow_algorithm()
assert domain.get_minimum_allowed_height() == pdomain.get_minimum_allowed_height()
assert domain.geo_reference == pdomain.geo_reference
assert domain.get_datadir() == sdomain.get_datadir()
assert domain.get_store() == sdomain.get_store()
assert domain.get_store_centroids() == sdomain.get_store_centroids()
assert domain.smooth == sdomain.smooth
assert domain.reduction == sdomain.reduction
assert domain.minimum_storable_height == sdomain.minimum_storable_height
assert domain.get_flow_algorithm() == sdomain.get_flow_algorithm()
assert domain.get_minimum_allowed_height() == sdomain.get_minimum_allowed_height()
assert domain.geo_reference == sdomain.geo_reference
if myid == 0 and verbose : print('REMOVING DATA FILES')
if myid == 0:
import os
#os.remove('odomain.sww')
#os.remove('pdomain.sww')
#os.remove('sdomain.sww')
try:
os.remove('odomain_P4_0.pickle')
os.remove('odomain_P4_1.pickle')
os.remove('odomain_P4_2.pickle')
os.remove('odomain_P4_3.pickle')
import glob
[ os.remove(fl) for fl in glob.glob('*.npy') ]
except:
if verbose: print('remove files failed')
if myid == 0 and verbose : print('FINISHED')