def run_simulation(parallel=False):
domain = create_domain_from_file(mesh_filename)
domain.set_quantity('stage', Set_Stage(756000.0, 756500.0, 2.0))
#--------------------------------------------------------------------------
# Create parallel domain if requested
#--------------------------------------------------------------------------
if parallel:
if myid == 0 and verbose: print 'DISTRIBUTING PARALLEL DOMAIN'
domain = distribute(domain)
#------------------------------------------------------------------------------
# Setup boundary conditions
# This must currently happen *after* domain has been distributed
#------------------------------------------------------------------------------
domain.store = False
Br = Reflective_boundary(domain) # Solid reflective wall
domain.set_boundary({'outflow' :Br, 'inflow' :Br, 'inner' :Br, 'exterior' :Br, 'open' :Br})
#------------------------------------------------------------------------------
# Evolution
#------------------------------------------------------------------------------
if parallel:
if myid == 0 and verbose: print 'PARALLEL EVOLVE'
else:
if verbose: print 'SEQUENTIAL EVOLVE'
for t in domain.evolve(yieldstep = yieldstep, finaltime = finaltime):
pass
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):
domain = create_domain_from_file(mesh_filename)
domain.set_quantity('stage', Set_Stage(756000.0, 756500.0, 2.0))
#--------------------------------------------------------------------------
# Create parallel domain if requested
#--------------------------------------------------------------------------
if parallel:
if myid == 0 and verbose: print('DISTRIBUTING PARALLEL DOMAIN')
domain = distribute(domain)
#------------------------------------------------------------------------------
# Setup boundary conditions
# This must currently happen *after* domain has been distributed
#------------------------------------------------------------------------------
domain.store = False
Br = Reflective_boundary(domain) # Solid reflective wall
domain.set_boundary({
'outflow': Br,
'inflow': Br,
'inner': Br,
'exterior': Br,
'open': Br
})
#------------------------------------------------------------------------------
# Evolution
#------------------------------------------------------------------------------
if parallel:
if myid == 0 and verbose: print('PARALLEL EVOLVE')
else:
if verbose: print('SEQUENTIAL EVOLVE')
for t in domain.evolve(yieldstep=yieldstep, finaltime=finaltime):
pass
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')
len1=length,
len2=width)
domain = anuga.Domain(points, vertices, boundary)
domain.set_name() # Output name
domain.set_flow_algorithm('DE0')
domain.set_store_vertices_uniquely(True)
domain.set_quantity('elevation', topography)
domain.set_quantity('friction', 0.01) # Constant friction
domain.set_quantity('stage',
expression='elevation') # Dry initial condition
else:
domain = None
domain = distribute(domain, verbose=True)
#domain.set_store_vertices_uniquely(False)
gate = Boyd_box_operator(domain,
end_points=[[9.0, 2.5], [13.0, 2.5]],
losses=1.5,
width=1.5,
height=0.0001,
apron=5.0,
use_momentum_jet=True,
use_velocity_head=False,
manning=0.013,
verbose=False)
# Close the gate
domain.set_name('channel3') # Output name
domain.set_flow_algorithm('DE0')
domain.print_statistics()
domain.set_quantity('elevation', topography) # elevation is a function
domain.set_quantity('friction', 0.01) # Constant friction
domain.set_quantity('stage',
expression='elevation') # Dry initial condition
else:
domain = None
#------------------------------------------------------------------------------
# Distribute domain on processor 0 to to other processors
#------------------------------------------------------------------------------
#parameters = dict(ghost_layer_width=3)
domain = anuga.distribute(domain, verbose=True)
#------------------------------------------------------------------------------
# Setup boundary conditions
#------------------------------------------------------------------------------
Bi = anuga.Dirichlet_boundary([0.4, 0, 0]) # Inflow
Br = anuga.Reflective_boundary(domain) # Solid reflective wall
Bo = anuga.Dirichlet_boundary([-5, 0, 0]) # Outflow
domain.set_boundary({'left': Bi, 'right': Bo, 'top': Br, 'bottom': Br})
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
for t in domain.evolve(yieldstep=0.1, finaltime=16.0):
if anuga.myid == 0:
domain = None
#------------------------------------------------------------------------------
# Print out polygon points and ids as check
#------------------------------------------------------------------------------
if myid == 0:
print '>>>>> erosion polygon1 contains ', polygon1
print '>>>>> erosion polygon2 contains ', polygon2
#------------------------------------------------------------------------------
# Distribute the domain onto the n partitions
#------------------------------------------------------------------------------
domain = distribute(domain)
domain.set_store_vertices_uniquely(True)
domain.set_quantities_to_be_stored({
'elevation': 2,
'stage': 2,
'xmomentum': 2,
'ymomentum': 2
})
#------------------------------------------------------------------------------
# Setup boundary conditions on the distributed domain
#------------------------------------------------------------------------------
Bi = anuga.Dirichlet_boundary([1.2, 0, 0]) # Inflow at depth
Br = anuga.Reflective_boundary(domain) # Solid reflective side walls
Bo = anuga.Dirichlet_boundary([-5, 0, 0]) # uncontrolled outflow
args = anuga.get_args()
alg = args.alg
verbose = args.verbose
domain.set_flow_algorithm(alg)
#------------------------------------------------------------------------------
# Setup initial conditions
#------------------------------------------------------------------------------
domain.set_quantity('elevation',0.0)
domain.set_quantity('friction', 0.0)
domain.set_quantity('stage', height)
else:
domain = None
domain = anuga.distribute(domain)
#-----------------------------------------------------------------------------
# Setup boundary conditions
#------------------------------------------------------------------------------
Br = anuga.Reflective_boundary(domain) # Solid reflective wall
# Associate boundary tags with boundary objects
domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br})
#-------------------------------------------------------------------------
# Produce a documentation of parameters
#-------------------------------------------------------------------------
from anuga.validation_utilities import save_parameters_tex
save_parameters_tex(domain)
def start_sim(run_id, Runs, scenario_name, Scenario, session, **kwargs):
yieldstep = kwargs['yieldstep']
finaltime = kwargs['finaltime']
logger = logging.getLogger(run_id)
max_triangle_area = kwargs['max_triangle_area']
logger.info('Starting hydrata_project')
if run_id == 'local_run':
base_dir = os.getcwd()
else:
base_dir = os.getcwd() + '/base_dir/%s/' % run_id
outname = run_id
meshname = base_dir + 'outputs/' + run_id + '.msh'
def get_filename(data_type, file_type):
files = os.listdir('%sinputs/%s' % (base_dir, data_type))
filename = '%sinputs/%s/%s' % (
base_dir, data_type, [f for f in files if f[-4:] == file_type][0])
return filename
boundary_data_filename = get_filename('boundary_data', '.shp')
elevation_data_filename = get_filename('elevation_data', '.tif')
try:
structures_filename = get_filename('structures', '.shp')
except OSError as e:
structures_filename = None
try:
rain_data_filename = get_filename('rain_data', '.shp')
except OSError as e:
rain_data_filename = None
try:
inflow_data_filename = get_filename('inflow_data', '.shp')
except OSError as e:
inflow_data_filename = None
try:
friction_data_filename = get_filename('friction_data', '.shp')
except OSError as e:
friction_data_filename = None
logger.info('boundary_data_filename: %s' % boundary_data_filename)
logger.info('structures_filename: %s' % structures_filename)
logger.info('rain_data_filename: %s' % rain_data_filename)
logger.info('inflow_data_filename: %s' % inflow_data_filename)
logger.info('friction_data_filename: %s' % friction_data_filename)
logger.info('elevation_data_filename: %s' % elevation_data_filename)
# create a list of project files
vector_filenames = [
boundary_data_filename, structures_filename, rain_data_filename,
inflow_data_filename, friction_data_filename
]
# set the projection system for ANUGA calculations from the geotiff elevation data
elevation_data_gdal = gdal.Open(elevation_data_filename)
project_spatial_ref = osr.SpatialReference()
project_spatial_ref.ImportFromWkt(elevation_data_gdal.GetProjectionRef())
project_spatial_ref_epsg_code = int(
project_spatial_ref.GetAttrValue("AUTHORITY", 1))
# check the spatial reference system of the project files matches that of the calculation
for filename in vector_filenames:
if filename:
prj_text = open(filename[:-4] + '.prj').read()
srs = osr.SpatialReference()
srs.ImportFromESRI([prj_text])
srs.AutoIdentifyEPSG()
logger.info('filename is: %s' % filename)
logger.info('EPSG is: %s' % srs.GetAuthorityCode(None))
if str(srs.GetAuthorityCode(None)) != str(
project_spatial_ref_epsg_code):
logger.warning('warning spatial refs are not maching: %s, %s' %
(srs.GetAuthorityCode(None),
project_spatial_ref_epsg_code))
logger.info('Setting up structures...')
if structures_filename:
structures = []
logger.info('processing structures from :%s' % structures_filename)
ogr_shapefile = ogr.Open(structures_filename)
ogr_layer = ogr_shapefile.GetLayer(0)
ogr_layer_feature = ogr_layer.GetNextFeature()
while ogr_layer_feature:
structure = json.loads(ogr_layer_feature.GetGeometryRef().
ExportToJson())['coordinates'][0]
structures.append(structure)
ogr_layer_feature = None
ogr_layer_feature = ogr_layer.GetNextFeature()
logger.info('structures: %s' % structures)
else:
logger.warning('warning: no structures found.')
structures = None
logger.info('Setting up friction...')
frictions = []
if friction_data_filename:
logger.info('processing frictions from :%s' % friction_data_filename)
ogr_shapefile = ogr.Open(friction_data_filename)
ogr_layer = ogr_shapefile.GetLayer(0)
ogr_layer_feature = ogr_layer.GetNextFeature()
while ogr_layer_feature:
friction_poly = json.loads(ogr_layer_feature.GetGeometryRef().
ExportToJson())['coordinates'][0]
friction_value = float(ogr_layer_feature.GetField('mannings'))
friction_couple = [friction_poly, friction_value]
frictions.append(friction_couple)
ogr_layer_feature = None
ogr_layer_feature = ogr_layer.GetNextFeature()
frictions.append(['All', 0.04])
logger.info('frictions: %s' % frictions)
else:
frictions.append(['All', 0.04])
logger.info('warning: no frictions found.')
logger.info('Setting up boundary conditions...')
ogr_shapefile = ogr.Open(boundary_data_filename)
ogr_layer = ogr_shapefile.GetLayer(0)
ogr_layer_definition = ogr_layer.GetLayerDefn()
logger.info('ogr_layer_definition.GetGeomType: %s' %
ogr_layer_definition.GetGeomType())
boundary_tag_index = 0
bdy_tags = {}
bdy = {}
ogr_layer_feature = ogr_layer.GetNextFeature()
while ogr_layer_feature:
boundary_tag_key = ogr_layer_feature.GetField('bdy_tag_k')
boundary_tag_value = ogr_layer_feature.GetField('bdy_tag_v')
bdy_tags[boundary_tag_key] = [
boundary_tag_index * 2, boundary_tag_index * 2 + 1
]
bdy[boundary_tag_key] = boundary_tag_value
geom = ogr_layer_feature.GetGeometryRef().GetPoints()
ogr_layer_feature = None
ogr_layer_feature = ogr_layer.GetNextFeature()
boundary_tag_index = boundary_tag_index + 1
logger.info('bdy_tags: %s' % bdy_tags)
logger.info('bdy: %s' % bdy)
boundary_data = su.read_polygon(boundary_data_filename)
create_mesh_from_regions(boundary_data,
boundary_tags=bdy_tags,
maximum_triangle_area=max_triangle_area,
interior_regions=None,
interior_holes=structures,
filename=meshname,
use_cache=False,
verbose=True)
domain = Domain(meshname, use_cache=False, verbose=True)
domain.set_name(outname)
domain.set_datadir(base_dir + '/outputs')
logger.info(domain.statistics())
poly_fun_pairs = [['Extent', elevation_data_filename.encode("utf-8")]]
topography_function = qs.composite_quantity_setting_function(
poly_fun_pairs,
domain,
nan_treatment='exception',
)
friction_function = qs.composite_quantity_setting_function(
frictions, domain)
domain.set_quantity('friction', friction_function, verbose=True)
domain.set_quantity('stage', 0.0)
domain.set_quantity('elevation',
topography_function,
verbose=True,
alpha=0.99)
domain.set_minimum_storable_height(0.005)
logger.info('Applying rainfall...')
if rain_data_filename:
ogr_shapefile = ogr.Open(rain_data_filename)
ogr_layer = ogr_shapefile.GetLayer(0)
rainfall = 0
ogr_layer_feature = ogr_layer.GetNextFeature()
while ogr_layer_feature:
rainfall = float(ogr_layer_feature.GetField('rate_mm_hr'))
polygon = su.read_polygon(rain_data_filename)
logger.info("applying Polygonal_rate_operator with rate, polygon:")
logger.info(rainfall)
logger.info(polygon)
Polygonal_rate_operator(domain,
rate=rainfall,
factor=1.0e-6,
polygon=polygon,
default_rate=0.0)
ogr_layer_feature = None
ogr_layer_feature = ogr_layer.GetNextFeature()
logger.info('Applying surface inflows...')
if inflow_data_filename:
ogr_shapefile = ogr.Open(inflow_data_filename)
ogr_layer = ogr_shapefile.GetLayer(0)
ogr_layer_definition = ogr_layer.GetLayerDefn()
ogr_layer_feature = ogr_layer.GetNextFeature()
while ogr_layer_feature:
in_fixed = float(ogr_layer_feature.GetField('in_fixed'))
line = ogr_layer_feature.GetGeometryRef().GetPoints()
logger.info("applying Inlet_operator with line, in_fixed:")
logger.info(line)
logger.info(in_fixed)
Inlet_operator(domain, line, in_fixed, verbose=False)
ogr_layer_feature = None
ogr_layer_feature = ogr_layer.GetNextFeature()
logger.info('Applying Boundary Conditions...')
logger.info('Available boundary tags: %s' % domain.get_boundary_tags())
Br = anuga.Reflective_boundary(domain)
Bd = anuga.Dirichlet_boundary([0.0, 0.0, 0.0])
Bt = anuga.Transmissive_boundary(domain)
for key, value in bdy.iteritems():
if value == 'Br':
bdy[key] = Br
elif value == 'Bd':
bdy[key] = Bd
elif value == 'Bt':
bdy[key] = Bt
else:
logger.info(
'No matching boundary condition exists - please check your shapefile attributes in: %s'
% boundary_data_filename)
# set a default value for exterior & interior boundary if it is not already set
try:
bdy['exterior']
except KeyError:
bdy['exterior'] = Br
try:
bdy['interior']
except KeyError:
bdy['interior'] = Br
logger.info('bdy: %s' % bdy)
domain.set_boundary(bdy)
domain = distribute(domain)
logger.info('Beginning evolve phase...')
for t in domain.evolve(yieldstep, finaltime):
domain.write_time()
print domain.timestepping_statistics()
logger.info(domain.timestepping_statistics(track_speeds=True))
percentage_complete = round(domain.time / domain.finaltime, 3) * 100
logger.info('%s percent complete' % percentage_complete)
if run_id != 'local_run':
write_percentage_complete(run_id, Runs, scenario_name, Scenario,
session, percentage_complete)
domain.sww_merge(delete_old=True)
barrier()
finalize()
sww_file = base_dir + '/outputs/' + run_id + '.sww'
sww_file = sww_file.encode(
'utf-8',
'ignore') # sometimes run_id gets turned to a unicode object by celery
util.Make_Geotif(swwFile=sww_file,
output_quantities=['depth', 'velocity'],
myTimeStep='max',
CellSize=max_triangle_area,
lower_left=None,
upper_right=None,
EPSG_CODE=project_spatial_ref_epsg_code,
proj4string=None,
velocity_extrapolation=True,
min_allowed_height=1.0e-05,
output_dir=(base_dir + '/outputs/'),
bounding_polygon=boundary_data,
internal_holes=structures,
verbose=False,
k_nearest_neighbours=3,
creation_options=[])
logger.info("Done. Nice work.")
domain.set_name() # Output name
domain.set_flow_algorithm('DE0')
domain.set_store_vertices_uniquely(True)
domain.set_quantity('elevation', topography)
domain.set_quantity('friction', 0.01) # Constant friction
domain.set_quantity('stage',
expression='elevation') # Dry initial condition
else:
domain = None
domain = distribute(domain, verbose = True)
#domain.set_store_vertices_uniquely(False)
gate = Boyd_box_operator(domain,
end_points=[[9.0, 2.5],[13.0, 2.5]],
losses=1.5,
width=1.5,
height = 0.0001,
apron=5.0,
use_momentum_jet=True,
use_velocity_head=False,
manning=0.013,
verbose=False)
def run_simulation(parallel=False, G = None, seq_interpolation_points=None, verbose=False):
#--------------------------------------------------------------------------
# Setup computational domain and quantities
#--------------------------------------------------------------------------
domain = rectangular_cross_domain(M, N)
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
#--------------------------------------------------------------------------
# Create the parallel domain
#--------------------------------------------------------------------------
if parallel:
if myid == 0 and verbose : print 'DISTRIBUTING PARALLEL DOMAIN'
domain = distribute(domain, verbose=False)
#--------------------------------------------------------------------------
# Setup domain parameters
#--------------------------------------------------------------------------
domain.set_name('runup') # Set sww filename
domain.set_datadir('.') # Set output dir
domain.set_flow_algorithm('2_0')
domain.set_quantities_to_be_stored(None)
#------------------------------------------------------------------------------
# Setup boundary conditions
# This must currently happen *AFTER* domain has been distributed
#------------------------------------------------------------------------------
Br = Reflective_boundary(domain) # Solid reflective wall
Bd = Dirichlet_boundary([-0.2,0.,0.]) # Constant boundary values
# Associate boundary tags with boundary objects
domain.set_boundary({'left': Br, 'right': Bd, 'top': Br, 'bottom': Br})
#------------------------------------------------------------------------------
# Find which sub_domain in which the interpolation points are located
#
# Sometimes the interpolation points sit exactly
# between two centroids, so in the parallel run we
# reset the interpolation points to the centroids
# found in the sequential run
#------------------------------------------------------------------------------
interpolation_points = [[0.4,0.5], [0.6,0.5], [0.8,0.5], [0.9,0.5]]
gauge_values = []
tri_ids = []
for i, point in enumerate(interpolation_points):
gauge_values.append([]) # Empty list for timeseries
#if is_inside_polygon(point, domain.get_boundary_polygon()):
#print "Point ", myid, i, point
try:
k = domain.get_triangle_containing_point(point)
if domain.tri_full_flag[k] == 1:
tri_ids.append(k)
else:
tri_ids.append(-1)
except:
tri_ids.append(-2)
#print " tri_ids ",myid, i, tri_ids[-1]
if verbose: print 'P%d has points = %s' %(myid, tri_ids)
c_coord = domain.get_centroid_coordinates()
interpolation_points = []
for id in tri_ids:
if id<1:
if verbose: print 'WARNING: Interpolation point not within the domain!'
interpolation_points.append(c_coord[id,:])
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
time = []
if parallel:
if myid == 0 and verbose: print 'PARALLEL EVOLVE'
else:
if myid == 0 and verbose: print 'SEQUENTIAL EVOLVE'
for t in domain.evolve(yieldstep = yieldstep, finaltime = finaltime):
if myid == 0 and verbose : domain.write_time()
# Record time series at known points
time.append(domain.get_time())
stage = domain.get_quantity('stage')
for i in range(4):
if tri_ids[i] > -1:
gauge_values[i].append(stage.centroid_values[tri_ids[i]])
#----------------------------------------
# Setup test arrays during sequential run
#----------------------------------------
if not parallel:
G = []
for i in range(4):
G.append(gauge_values[i])
success = True
for i in range(4):
if tri_ids[i] > -1:
#print num.max(num.array(gauge_values[i])- num.array(G[i]))
success = success and num.allclose(gauge_values[i], G[i])
assert_(success)
return G, interpolation_points
def run_simulation(parallel=False, verbose=False):
#--------------------------------------------------------------------------
# Setup computational domain and quantities
#--------------------------------------------------------------------------
if myid == 0:
anuga.create_mesh_from_regions(
boundaryPolygon,
boundary_tags={
'left': [0],
'top': [1],
'right': [2],
'bottom': [3]
},
maximum_triangle_area=1.0e+20,
minimum_triangle_angle=28.0,
filename='runup.msh',
interior_regions=[[higherResPolygon, 1. * 1. * 0.5],
[midResPolygon, 3.0 * 3.0 * 0.5]],
breaklines=list(riverWall.values()),
use_cache=False,
verbose=verbose,
regionPtArea=regionPtAreas)
sdomain = anuga.create_domain_from_file('runup.msh')
sdomain.set_flow_algorithm(alg)
sdomain.set_name('s_riverwall')
sdomain.set_datadir('.')
sdomain.set_store_vertices_uniquely()
#------------------
# Define topography
#------------------
def topography(x, y):
return -x / 150. * scale_me
def stagefun(x, y):
stg = -0.5 * scale_me
return stg
sdomain.set_quantity('elevation',
topography) # Use function for elevation
sdomain.set_quantity('friction', 0.03) # Constant friction
sdomain.set_quantity('stage',
stagefun) # Constant negative initial stage
else:
sdomain = None
#--------------------------------------------------------------------------
# Create the parallel domains
#--------------------------------------------------------------------------
if parallel:
if myid == 0 and verbose: print('DISTRIBUTING TO PARALLEL DOMAIN')
pdomain = distribute(sdomain, verbose=verbose)
pdomain.set_name('p_riverwall')
pdomain.set_store_vertices_uniquely()
if myid == 0 and verbose:
print(60 * '=')
print('EVOLVING pdomain')
print(60 * '=')
setup_and_evolve(pdomain, verbose=verbose)
barrier()
if myid == 0:
if verbose:
print(60 * '=')
print('EVOLVING sdomain')
print(60 * '=')
setup_and_evolve(sdomain, verbose=verbose)
barrier()
#---------------------------------
# Now compare the merged sww files
#---------------------------------
if myid == 0:
if verbose: print('COMPARING SWW FILES')
sdomain_v = util.get_output('s_riverwall.sww')
sdomain_c = util.get_centroids(sdomain_v)
pdomain_v = util.get_output('p_riverwall.sww')
pdomain_c = util.get_centroids(pdomain_v)
# Test some values against the original ordering
if verbose:
order = 0
print('PDOMAIN CENTROID VALUES')
print(num.linalg.norm(sdomain_c.x - pdomain_c.x, ord=order))
print(num.linalg.norm(sdomain_c.y - pdomain_c.y, ord=order))
print(
num.linalg.norm(sdomain_c.stage[-1] - pdomain_c.stage[-1],
ord=order))
print(
num.linalg.norm(sdomain_c.xmom[-1] - pdomain_c.xmom[-1],
ord=order))
print(
num.linalg.norm(sdomain_c.ymom[-1] - pdomain_c.ymom[-1],
ord=order))
print(
num.linalg.norm(sdomain_c.xvel[-1] - pdomain_c.xvel[-1],
ord=order))
print(
num.linalg.norm(sdomain_c.yvel[-1] - pdomain_c.yvel[-1],
ord=order))
assert num.allclose(sdomain_c.stage, pdomain_c.stage)
assert num.allclose(sdomain_c.xmom, pdomain_c.xmom)
assert num.allclose(sdomain_c.ymom, pdomain_c.ymom)
assert num.allclose(sdomain_c.xvel, pdomain_c.xvel)
assert num.allclose(sdomain_c.yvel, pdomain_c.yvel)
assert num.allclose(sdomain_v.x, pdomain_v.x)
assert num.allclose(sdomain_v.y, pdomain_v.y)
import os
os.remove('s_riverwall.sww')
os.remove('p_riverwall.sww')
os.remove('runup.msh')
def run_simulation(parallel=False, verbose=False):
#--------------------------------------------------------------------------
# Setup computational domain and quantities
#--------------------------------------------------------------------------
if myid == 0:
anuga.create_mesh_from_regions(boundaryPolygon,
boundary_tags={'left': [0],
'top': [1],
'right': [2],
'bottom': [3]},
maximum_triangle_area = 1.0e+20,
minimum_triangle_angle = 28.0,
filename = 'runup.msh',
interior_regions = [ [higherResPolygon, 1.*1.*0.5],
[midResPolygon, 3.0*3.0*0.5]],
breaklines=riverWall.values(),
use_cache=False,
verbose=verbose,
regionPtArea=regionPtAreas)
sdomain=anuga.create_domain_from_file('runup.msh')
sdomain.set_flow_algorithm(alg)
sdomain.set_name('s_riverwall')
sdomain.set_datadir('.')
sdomain.set_store_vertices_uniquely()
#------------------
# Define topography
#------------------
def topography(x,y):
return -x/150.*scale_me
def stagefun(x,y):
stg=-0.5*scale_me
return stg
sdomain.set_quantity('elevation',topography) # Use function for elevation
sdomain.set_quantity('friction',0.03) # Constant friction
sdomain.set_quantity('stage', stagefun) # Constant negative initial stage
else:
sdomain = None
#--------------------------------------------------------------------------
# Create the parallel domains
#--------------------------------------------------------------------------
if parallel:
if myid == 0 and verbose : print 'DISTRIBUTING TO PARALLEL DOMAIN'
pdomain = distribute(sdomain, verbose=verbose)
pdomain.set_name('p_riverwall')
pdomain.set_store_vertices_uniquely()
if myid == 0 and verbose:
print 60*'='
print 'EVOLVING pdomain'
print 60*'='
setup_and_evolve(pdomain, verbose=verbose)
barrier()
if myid == 0:
if verbose:
print 60*'='
print 'EVOLVING sdomain'
print 60*'='
setup_and_evolve(sdomain, verbose=verbose)
barrier()
#---------------------------------
# Now compare the merged sww files
#---------------------------------
if myid == 0:
if verbose: print 'COMPARING SWW FILES'
sdomain_v = util.get_output('s_riverwall.sww')
sdomain_c = util.get_centroids(sdomain_v)
pdomain_v = util.get_output('p_riverwall.sww')
pdomain_c = util.get_centroids(pdomain_v)
# Test some values against the original ordering
if verbose:
order = 0
print 'PDOMAIN CENTROID VALUES'
print num.linalg.norm(sdomain_c.x-pdomain_c.x,ord=order)
print num.linalg.norm(sdomain_c.y-pdomain_c.y,ord=order)
print num.linalg.norm(sdomain_c.stage[-1]-pdomain_c.stage[-1],ord=order)
print num.linalg.norm(sdomain_c.xmom[-1]-pdomain_c.xmom[-1],ord=order)
print num.linalg.norm(sdomain_c.ymom[-1]-pdomain_c.ymom[-1],ord=order)
print num.linalg.norm(sdomain_c.xvel[-1]-pdomain_c.xvel[-1],ord=order)
print num.linalg.norm(sdomain_c.yvel[-1]-pdomain_c.yvel[-1],ord=order)
assert num.allclose(sdomain_c.stage,pdomain_c.stage)
assert num.allclose(sdomain_c.xmom,pdomain_c.xmom)
assert num.allclose(sdomain_c.ymom,pdomain_c.ymom)
assert num.allclose(sdomain_c.xvel,pdomain_c.xvel)
assert num.allclose(sdomain_c.yvel,pdomain_c.yvel)
assert num.allclose(sdomain_v.x,pdomain_v.x)
assert num.allclose(sdomain_v.y,pdomain_v.y)
import os
os.remove('s_riverwall.sww')
os.remove('p_riverwall.sww')
os.remove('runup.msh')
domain.set_flow_algorithm('DE0')
print domain.statistics()
domain.set_quantity('elevation', topography) # elevation is a function
domain.set_quantity('friction', 0.01) # Constant friction
domain.set_quantity('stage', expression='elevation') # Dry initial condition
else:
domain = None
#------------------------------------------------------------------------------
# Distribute domain on processor 0 to to other processors
#------------------------------------------------------------------------------
#parameters = dict(ghost_layer_width=3)
domain = anuga.distribute(domain, verbose= True)
#------------------------------------------------------------------------------
# Setup boundary conditions
#------------------------------------------------------------------------------
Bi = anuga.Dirichlet_boundary([0.4, 0, 0]) # Inflow
Br = anuga.Reflective_boundary(domain) # Solid reflective wall
Bo = anuga.Dirichlet_boundary([-5, 0, 0]) # Outflow
domain.set_boundary({'left': Bi, 'right': Bo, 'top': Br, 'bottom': Br})
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
for t in domain.evolve(yieldstep=0.1, finaltime=16.0):
Stage = domain.quantities['stage'].centroid_values
Stage[:] = Stage + uZ
#domain.add_quantity('stage',
# function=okada_deformation,
# verbose=project.verbose,
# location='centroids')
domain.set_quantity('friction', 0.0)
else:
domain = None
#-------------------------------------------------------------------------------
# Distribute domain
#-------------------------------------------------------------------------------
domain = distribute(domain, verbose=project.verbose)
#===============================================================================
# Parallel Section
#===============================================================================
domain.set_quantities_to_be_stored({
'stage': 2,
'xmomentum': 2,
'ymomentum': 2,
'elevation': 2
})
domain.set_quantities_to_be_monitored(['stage', 'xmomentum', 'ymomentum'])
if myid == 0: print('running project:', project.scenario)
#------------------------------------------------------------------------------
def run_simulation(parallel=False, G = None, seq_interpolation_points=None, verbose=False):
#--------------------------------------------------------------------------
# Setup computational domain and quantities
#--------------------------------------------------------------------------
domain = rectangular_cross_domain(M, N)
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_low_froude(1)
domain.set_name('runup') # Set sww filename
domain.set_datadir('.') # Set output dir
#--------------------------------------------------------------------------
# Create the parallel domain
#--------------------------------------------------------------------------
if parallel:
if myid == 0 and verbose : print('DISTRIBUTING PARALLEL DOMAIN')
domain = distribute(domain, verbose=False)
#--------------------------------------------------------------------------
# Setup domain parameters
#--------------------------------------------------------------------------
domain.set_quantities_to_be_stored(None)
#------------------------------------------------------------------------------
# Setup boundary conditions
# This must currently happen *AFTER* domain has been distributed
#------------------------------------------------------------------------------
Br = Reflective_boundary(domain) # Solid reflective wall
Bd = Dirichlet_boundary([-0.2,0.,0.]) # Constant boundary values
# Associate boundary tags with boundary objects
domain.set_boundary({'left': Br, 'right': Bd, 'top': Br, 'bottom': Br})
#------------------------------------------------------------------------------
# Find which sub_domain in which the interpolation points are located
#
# Sometimes the interpolation points sit exactly
# between two centroids, so in the parallel run we
# reset the interpolation points to the centroids
# found in the sequential run
#------------------------------------------------------------------------------
interpolation_points = [[0.4,0.5], [0.6,0.5], [0.8,0.5], [0.9,0.5]]
gauge_values = []
tri_ids = []
for i, point in enumerate(interpolation_points):
gauge_values.append([]) # Empty list for timeseries
#if is_inside_polygon(point, domain.get_boundary_polygon()):
#print "Point ", myid, i, point
try:
k = domain.get_triangle_containing_point(point)
if domain.tri_full_flag[k] == 1:
tri_ids.append(k)
else:
tri_ids.append(-1)
except:
tri_ids.append(-2)
#print " tri_ids ",myid, i, tri_ids[-1]
if verbose: print('P%d has points = %s' %(myid, tri_ids))
c_coord = domain.get_centroid_coordinates()
interpolation_points = []
for id in tri_ids:
if id<1:
if verbose: print('WARNING: Interpolation point not within the domain!')
interpolation_points.append(c_coord[id,:])
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
time = []
if parallel:
if myid == 0 and verbose: print('PARALLEL EVOLVE')
else:
if myid == 0 and verbose: print('SEQUENTIAL EVOLVE')
for t in domain.evolve(yieldstep = yieldstep, finaltime = finaltime):
if myid == 0 and verbose : domain.write_time()
# Record time series at known points
time.append(domain.get_time())
stage = domain.get_quantity('stage')
for i in range(4):
if tri_ids[i] > -1:
gauge_values[i].append(stage.centroid_values[tri_ids[i]])
#----------------------------------------
# Setup test arrays during sequential run
#----------------------------------------
if not parallel:
G = []
for i in range(4):
G.append(gauge_values[i])
success = True
for i in range(4):
if tri_ids[i] > -1:
#print num.max(num.array(gauge_values[i])- num.array(G[i]))
success = success and num.allclose(gauge_values[i], G[i])
assert_(success)
return G, interpolation_points
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
#--------------------------------------------------------------------------
args = anuga.get_args()
alg = args.alg
verbose = args.verbose
domain.set_flow_algorithm(alg)
#-------------------------------------------------------------------------
# Setup initial conditions
#-------------------------------------------------------------------------
domain.set_quantity('elevation',0.0)
domain.set_quantity('friction', 0.0)
domain.set_quantity('stage', height)
else:
domain = None
domain = anuga.distribute(domain)
#-----------------------------------------------------------------------------
# Setup boundary conditions
#------------------------------------------------------------------------------
Br = anuga.Reflective_boundary(domain) # Solid reflective wall
# Associate boundary tags with boundary objects
domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br})
#-------------------------------------------------------------------------
# Produce a documentation of parameters
#-------------------------------------------------------------------------
from anuga.validation_utilities import save_parameters_tex
save_parameters_tex(domain)
domain = create_domain_from_file(mesh_filename)
domain.set_quantity('stage', Set_Stage(x0, x1, 1.0))
domain.set_name(domain_name)
domain.set_store(True)
domain.set_store_vertices_smoothly(False)
else:
domain = None
#--------------------------------------------------------------------------
# Distribute sequential domain on processor 0 to other processors
#--------------------------------------------------------------------------
if myid == 0 and verbose: print 'DISTRIBUTING DOMAIN'
domain = distribute(domain, verbose=verbose)
#--------------------------------------------------------------------------
# On all processors, setup evolve parameters for domains on all processors
# (all called "domain"
#--------------------------------------------------------------------------
domain.set_flow_algorithm('DE0')
domain.set_store_centroids()
domain.set_quantities_to_be_stored({
'elevation': 1,
'friction': 1,
'stage': 2,
'xmomentum': 2,
'ymomentum': 2
filename=project.name_stem + '.pts',
use_cache=project.cache,
verbose=project.verbose,
alpha=0.1)
else:
domain = None
#------------------------------------------------------------------------------
# Now produce parallel domain
#------------------------------------------------------------------------------
domain = distribute(domain,verbose=project.verbose)
domain.set_store_vertices_uniquely(False)
#------------------------------------------------------------------------------
# Setup information for slide scenario (to be applied 1 min into simulation
#------------------------------------------------------------------------------
if project.scenario == 'slide':
# Function for submarine slide
tsunami_source = anuga.slide_tsunami(length=35000.0,
depth=project.slide_depth,
slope=6.0,
thickness=500.0,
x0=project.slide_origin[0],
y0=project.slide_origin[1],
alpha=0.0,
domain = create_domain_from_file(mesh_filename)
domain.set_quantity('stage', Set_Stage(x0, x1, 1.0))
domain.set_name(domain_name)
domain.set_store(True)
domain.set_store_vertices_smoothly(False)
else:
domain = None
#--------------------------------------------------------------------------
# Distribute sequential domain on processor 0 to other processors
#--------------------------------------------------------------------------
if myid == 0 and verbose: print 'DISTRIBUTING DOMAIN'
domain = distribute(domain, verbose=verbose)
#--------------------------------------------------------------------------
# On all processors, setup evolve parameters for domains on all processors
# (all called "domain"
#--------------------------------------------------------------------------
domain.set_flow_algorithm('DE0')
domain.set_store_centroids()
domain.set_quantities_to_be_stored({'elevation':1,
'friction':1,
'stage':2,
'xmomentum':2,
'ymomentum':2})
#------------------------------------------------------------------------------
# Setup initial conditions
#------------------------------------------------------------------------------
domain.set_quantity('friction', 0.0)
domain.set_quantity('stage', stage_flat)
domain.set_quantity('elevation', bed_elevation)
else:
domain = None
#-----------------------------------------------------------------------------
# Parallel Domain
#-----------------------------------------------------------------------------
domain = distribute(domain)
#-----------------------------------------------------------------------------
# Setup boundary conditions
#------------------------------------------------------------------------------
from math import sin, pi, exp
Br = anuga.Reflective_boundary(domain) # Solid reflective wall
#Bt = anuga.Transmissive_boundary(domain) # Continue all values on boundary
#Bd = anuga.Dirichlet_boundary([1,0.,0.]) # Constant boundary values
# Associate boundary tags with boundary objects
domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br})
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')
