def create_domain(self, flowalg):
# Riverwall = list of lists, each with a set of x,y,z (and optional QFactor) values
# Make the domain
domain = anuga.create_domain_from_regions(
boundaryPolygon,
boundary_tags={
'left': [0],
'top': [1],
'right': [2],
'bottom': [3]
},
mesh_filename='test_boundaryfluxintegral.msh',
maximum_triangle_area=200.,
minimum_triangle_angle=28.0,
use_cache=False,
verbose=verbose)
# 05/05/2014 -- riverwalls only work with DE0 and DE1
domain.set_flow_algorithm(flowalg)
domain.set_name('test_boundaryfluxintegral')
domain.set_store_vertices_uniquely()
def topography(x, y):
return -x / 150.
# NOTE: Setting quantities at centroids is important for exactness of tests
domain.set_quantity('elevation', topography, location='centroids')
domain.set_quantity('friction', 0.03)
domain.set_quantity('stage', topography, location='centroids')
# Boundary conditions
Br = anuga.Reflective_boundary(domain)
Bd = anuga.Dirichlet_boundary([0., 0., 0.])
domain.set_boundary({'left': Br, 'right': Bd, 'top': Br, 'bottom': Br})
return domain
def CreateDomain(topo_in, bound_in, datadir, inlet_btag, outlet_btag, res,
parlist):
# Import Channel topography DEM
# Create DEM from asc data
anuga.asc2dem(topo_in + '.asc', use_cache=False, verbose=True)
# Create DEM from asc data
anuga.dem2pts(topo_in + '.dem', use_cache=False, verbose=True)
# Define boundaries for mesh
# Read in coordinate file
bounding_polygon = anuga.read_polygon(bound_in + '.csv')
print(inlet_btag)
#Determine tag to assign as reflective exterior
for i in numpy.arange(1, 4):
print(i)
if int(i) == int(inlet_btag):
print(str(inlet_btag) + ' already taken')
else:
print(str(i) + ' used as exterior tag')
break
# Create mesh with bounding polygon
domain = anuga.create_domain_from_regions(bounding_polygon,
boundary_tags={
'inlet': [inlet_btag],
'exterior': [i],
'outlet': [outlet_btag]
},
maximum_triangle_area=res,
mesh_filename=parlist + '.msh',
use_cache=False,
verbose=True)
# Name domain and decide where to save
domain.set_name(parlist)
domain.set_datadir('.')
return domain
def create_domain(self, flowalg):
# Riverwall = list of lists, each with a set of x,y,z (and optional QFactor) values
# Make the domain
domain = anuga.create_domain_from_regions(boundaryPolygon,
boundary_tags={'left': [0],
'top': [1],
'right': [2],
'bottom': [3]},
mesh_filename='test_boundaryfluxintegral.msh',
maximum_triangle_area = 200.,
minimum_triangle_angle = 28.0,
use_cache=False,
verbose=verbose)
# 05/05/2014 -- riverwalls only work with DE0 and DE1
domain.set_flow_algorithm(flowalg)
domain.set_name('test_boundaryfluxintegral')
domain.set_store_vertices_uniquely()
def topography(x,y):
return -x/150.
# NOTE: Setting quantities at centroids is important for exactness of tests
domain.set_quantity('elevation',topography,location='centroids')
domain.set_quantity('friction',0.03)
domain.set_quantity('stage', topography,location='centroids')
# Boundary conditions
Br=anuga.Reflective_boundary(domain)
Bd=anuga.Dirichlet_boundary([0., 0., 0.])
domain.set_boundary({'left': Br, 'right': Bd, 'top': Br, 'bottom':Br})
return domain
def run_model():
"""Run a tsunami simulation for a scenario."""
# Read in boundary from ordered sts file
event_sts = anuga.create_sts_boundary(project.event_sts)
# Reading the landward defined points, this incorporates the original
# clipping polygon minus the 100m contour
landward_boundary = anuga.read_polygon(project.landward_boundary_file, do_complex_check=False)
# Combine sts polyline with landward points
bounding_polygon_sts = event_sts + landward_boundary
# Number of boundary segments
num_ocean_segments = len(event_sts) - 1
# Number of landward_boundary points
num_land_points = anuga.file_length(project.landward_boundary_file)
# Boundary tags refer to project.landward_boundary_file
# 4 points equals 5 segments start at N
boundary_tags={'back': range(num_ocean_segments+1,
num_ocean_segments+num_land_points),
'side': [num_ocean_segments,
num_ocean_segments+num_land_points],
'ocean': range(num_ocean_segments)}
# Build mesh and domain
log.debug('bounding_polygon_sts=%s' % str(bounding_polygon_sts))
log.debug('boundary_tags=%s' % str(boundary_tags))
log.debug('project.bounding_maxarea=%s' % str(project.bounding_maxarea))
log.debug('project.interior_regions=%s' % str(project.interior_regions))
log.debug('project.mesh_file=%s' % str(project.mesh_file))
domain = anuga.create_domain_from_regions(bounding_polygon_sts,
boundary_tags=boundary_tags,
maximum_triangle_area=project.bounding_maxarea,
interior_regions=project.interior_regions,
mesh_filename=project.mesh_file,
use_cache=False,
verbose=False)
domain.geo_reference.zone = project.zone_number
log.info('\n%s' % domain.statistics())
domain.set_name(project.scenario)
domain.set_datadir(project.output_folder)
domain.set_minimum_storable_height(0.01) # Don't store depth less than 1cm
# set overall friction before setting in interior regions
domain.set_quantity('friction', project.friction)
# set friction in interior regions, if any defined
friction_list = []
for (irtype, filename, friction) in project.interior_regions_list:
if irtype.lower() == 'friction':
friction_list.append([filename, friction])
if friction_list:
log.debug('friction_list=%s' % str(friction_list))
poly_friction = []
for (fname, friction) in friction_list:
full_fname = os.path.join(project.polygons_folder, fname)
log.debug('Reading friction polygon: %s' % full_fname)
poly = anuga.read_polygon(full_fname)
poly_friction.append((poly, friction))
log.debug('poly=%s' % str(poly))
domain.set_quantity('friction',
anuga.Polygon_function(poly_friction,
default=project.friction,
geo_reference=domain.geo_reference))
# Set the initial stage in the offcoast region only
if project.land_initial_conditions:
IC = anuga.Polygon_function(project.land_initial_conditions,
default=project.initial_tide,
geo_reference=domain.geo_reference)
else:
IC = project.initial_tide
domain.set_quantity('stage', IC, use_cache=True, verbose=False)
domain.set_quantity('elevation',
filename=project.combined_elevation_file,
use_cache=True, verbose=False, alpha=project.alpha)
# Setup boundary conditions
log.debug('Set boundary - available tags: %s' % domain.get_boundary_tags())
Br = anuga.Reflective_boundary(domain)
Bt = anuga.Transmissive_stage_zero_momentum_boundary(domain)
Bd = anuga.Dirichlet_boundary([project.initial_tide, 0, 0])
Bf = anuga.Field_boundary(project.event_sts+'.sts',
domain, mean_stage=project.initial_tide, time_thinning=1,
## NICK debug default_boundary=anuga.Dirichlet_boundary([0, 0, 0]),
default_boundary=Bt,
boundary_polygon=bounding_polygon_sts,
use_cache=True, verbose=False)
domain.set_boundary({'back': Br,
'side': Bt,
'ocean': Bf})
# Evolve system through time
t0 = time.time()
for t in domain.evolve(yieldstep=project.yieldstep,
finaltime=project.finaltime,
skip_initial_step=False):
log.info('\n%s' % domain.timestepping_statistics())
log.info('\n%s' % domain.boundary_statistics(tags='ocean'))
log.info('Simulation took %.2f seconds' % (time.time()-t0))
verbose=project.verbose)
# Create pts file for onshore DEM
anuga.dem2pts(project.name_stem+'.dem', use_cache=project.cache,
verbose=project.verbose)
#------------------------------------------------------------------------------
# Create the triangular mesh and domain based on
# overall clipping polygon with a tagged
# boundary and interior regions as defined in project.py
#------------------------------------------------------------------------------
domain = anuga.create_domain_from_regions(project.bounding_polygon,
boundary_tags={'top': [0],
'ocean_east': [1],
'bottom': [2],
'onshore': [3]},
maximum_triangle_area=project.default_res,
mesh_filename=project.meshname,
interior_regions=project.interior_regions,
use_cache=project.cache,
verbose=project.verbose)
# Print some stats about mesh and domain
print 'Number of triangles = ', len(domain)
print 'The extent is ', domain.get_extent()
print domain.statistics()
#------------------------------------------------------------------------------
# Setup parameters of computational domain
#------------------------------------------------------------------------------
domain.set_name('cairns_' + project.scenario) # Name of sww file
domain.set_datadir('.') # Store sww output here
# point_sw = [xleft, ybottom]
# point_se = [xright, ybottom]
# point_nw = [xleft, ytop]
# point_ne = [xright, ytop]
# bounding_polygon = [point_se,
# point_ne,
# point_nw,
# point_sw]
bounding_polygon = gpd.read_file('area/domain.shp')
# domain= anuga.create_domain_from_regions(bounding_polygon, boundary_tags={'bottom':[0],}, maximum_triangle_area=0.001,verbose=True)
domain = anuga.create_domain_from_regions(
list(bounding_polygon.exterior[0].coords),
boundary_tags={
'bottom': [0],
},
maximum_triangle_area=0.0001,
# minimum_triangle_area=1
)
domain.set_name('excessive_rain_para')
domain.set_quantity('elevation',
filename=topography_file,
location='centroids') # Use function for elevation
domain.set_quantity('friction', 0.3,
location='centroids') # Constant friction
domain.set_quantity('stage', expression='elevation',
location='centroids') # Dry Bed
domain.set_quantity('SS0', 0, location='centroids')
# Create pts file for onshore DEM
anuga.dem2pts(name_stem+'.dem', use_cache=v_cache, verbose=v_verbose)
#------------------------------------------------------------------------------
# Create the triangular mesh and domain based on
# overall clipping polygon with a tagged
# boundary and interior regions as defined in project.py
#------------------------------------------------------------------------------
domain = anuga.create_domain_from_regions(bounding_polygon,
boundary_tags={'land_sse': [0],
'land_s': [1],
'bottom': [2],
'ocean_wsw': [3],
'ocean_w': [4],
'ocean_wnw': [5],
'top': [6],
'land_nne': [7],
'land_ese': [8],
'land_se': [9]},
maximum_triangle_area=default_res,
mesh_filename=meshname,
interior_regions=interior_regions,
use_cache=v_cache,
verbose=v_verbose)
# Print some stats about mesh and domain
print 'Number of triangles = ', len(domain)
print 'The extent is ', domain.get_extent()
print domain.statistics()
#------------------------------------------------------------------------------
# Setup parameters of computational domain
anuga.dem2pts(dem_cdf_file, use_cache=cache, verbose=verbose)
interior_regions = [] # this makes huge mesh [bounding_polygon, base_scale] ]
# name + list of segments
boundary_tags = { 'in': [0] } # {'in': [0], 'other': [1,2,3,4] }
#------------------------------------------------------------------------------
# Create the triangular mesh and domain based on
# overall clipping polygon with a tagged
# boundary and interior regions as defined in project.py
#------------------------------------------------------------------------------
domain = anuga.create_domain_from_regions(bounding_polygon,
boundary_tags=boundary_tags,
maximum_triangle_area=default_res,
mesh_filename=mesh_file,
interior_regions=interior_regions,
use_cache=cache,
verbose=verbose)
# Print some stats about mesh and domain
print 'Number of triangles = ', len(domain)
print 'The extent is ', domain.get_extent()
print domain.statistics()
domain.set_name(name) # Name of sww file
domain.set_datadir('.') # Store sww output here
#domain.set_minimum_storable_height(0.01) # Store only depth > 1cm
domain.set_flow_algorithm('DE0')
def generate_cairns_domain(gpu=False):
#-----------------------------------------------------------------------
# Preparation of topographic data
# Convert ASC 2 DEM 2 PTS using source data
# and store result in source data
#-----------------------------------------------------------------------
# Create DEM from asc data
anuga.asc2dem(project.name_stem+'.asc', use_cache=True, verbose=True)
# Create pts file for onshore DEM
anuga.dem2pts(project.name_stem+'.dem', use_cache=True, verbose=True)
#-----------------------------------------------------------------------
# Create the triangular mesh and domain based on
# overall clipping polygon with a tagged
# boundary and interior regions as defined in project.py
#-----------------------------------------------------------------------
domain = anuga.create_domain_from_regions(project.bounding_polygon,
boundary_tags={'top': [0],
'ocean_east': [1],
'bottom': [2],
'onshore': [3]},
maximum_triangle_area=project.default_res,
mesh_filename=project.meshname,
interior_regions=project.interior_regions,
use_cache=True,
verbose=True)
if gpu :
#domain.__class__ = GPU_domain
domain = GPU_domain(domain=domain)
# Print some stats about mesh and domain
print 'Number of triangles = ', len(domain)
#print 'The extent is ', domain.get_extent()
#print domain.statistics()
#-----------------------------------------------------------------------
# Setup parameters of computational domain
#-----------------------------------------------------------------------
domain.set_name('cairns_' + project.scenario) # Name of sww file
domain.set_datadir('.') # Store sww output here
domain.set_minimum_storable_height(0.01) # Store only depth > 1cm
domain.set_flow_algorithm('tsunami')
#-----------------------------------------------------------------------
# Setup initial conditions
#-----------------------------------------------------------------------
tide = 0.0
domain.set_quantity('stage', tide)
domain.set_quantity('friction', 0.0)
domain.set_quantity('elevation',
filename=project.name_stem + '.pts',
use_cache=True,
verbose=True,
alpha=0.1)
#-----------------------------------------------------------------------
# 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=domain,
verbose=True)
#-----------------------------------------------------------------------
# Setup boundary conditions
#-----------------------------------------------------------------------
print 'Available boundary tags', domain.get_boundary_tags()
Bd = anuga.Dirichlet_boundary([tide, 0, 0]) # Mean water level
Bs = anuga.Transmissive_stage_zero_momentum_boundary(domain)
# Neutral boundary
if project.scenario == 'fixed_wave':
# Huge 50m wave starting after 60 seconds and lasting 1 hour.
Bw=anuga.Transmissive_n_momentum_zero_t_momentum_set_stage_boundary(
domain=domain,
function=lambda t: [(60<t<3660)*50, 0, 0])
domain.set_boundary({'ocean_east': Bw,
'bottom': Bs,
'onshore': Bd,
'top': Bs})
if project.scenario == 'slide':
# Boundary conditions for slide scenario
domain.set_boundary({'ocean_east': Bd,
'bottom': Bd,
'onshore': Bd,
'top': Bd})
if gpu:
if '-gpu' in sys.argv:
domain.using_gpu = True
print " --> Enable GPU version"
return domain
channel_polygon = [ [floodplain_width/2. - chan_width/2., +l0],
[floodplain_width/2. - chan_width/2., floodplain_length - l0],
[floodplain_width/2. + chan_width/2., floodplain_length - l0],
[floodplain_width/2. + chan_width/2., +l0]
]
if myid == 0:
# Define domain with appropriate boundary conditions
domain = anuga.create_domain_from_regions( boundary_polygon,
boundary_tags={'left': [0],
'top1': [1],
'chan_out': [2],
'top2': [3],
'right': [4],
'bottom1': [5],
'chan_in': [6],
'bottom2': [7] },
maximum_triangle_area = 0.5*l0*l0,
minimum_triangle_angle = 28.0,
mesh_filename = 'channel_floodplain.msh',
interior_regions = [ ],
#interior_regions = [\
# [channel_polygon, 0.5*l0*l0] ],
use_cache=False,
verbose=verbose)
domain.set_name('channel_floodplain') # Output name
domain.set_flow_algorithm(alg)
#------------------------------------------------------------------------------
# Setup initial conditions
#------------------------------------------------------------------------------
[floodplain_width / 2. - chan_width / 2., floodplain_length - l0],
[floodplain_width / 2. + chan_width / 2., floodplain_length - l0],
[floodplain_width / 2. + chan_width / 2., +l0]
]
if myid == 0:
# Define domain with appropriate boundary conditions
domain = anuga.create_domain_from_regions(
boundary_polygon,
boundary_tags={
'left': [0],
'top1': [1],
'chan_out': [2],
'top2': [3],
'right': [4],
'bottom1': [5],
'chan_in': [6],
'bottom2': [7]
},
maximum_triangle_area=0.5 * l0 * l0,
minimum_triangle_angle=28.0,
mesh_filename='channel_floodplain.msh',
interior_regions=[],
#interior_regions = [\
# [channel_polygon, 0.5*l0*l0] ],
use_cache=False,
verbose=verbose)
domain.set_name('channel_floodplain') # Output name
domain.set_flow_algorithm(alg)
#------------------------------------------------------------------------------
# Setup initial conditions
poly_from_box(35, 40, 3.5, 8.5),
] # downstream box
building_tags = [
{"upstream": [1]}, # Set segment[0], default others
None, # Use default interior tag
{"downstream": [0, 1]},
] # set segments[0,1],default others
# create a domain mesh, with 3 building holes in it
domain = anuga.create_domain_from_regions(
boundary_poly,
boundary_tags=boundary_tags,
maximum_triangle_area=resolution,
mesh_filename="building.msh",
interior_holes=building_polys,
hole_tags=building_tags,
use_cache=True, # to speed it up
verbose=True,
) # log output on
domain.set_name("buildings") # Output name
# ------------------------------------------------------------------------------
# Setup initial conditions
# ------------------------------------------------------------------------------
def topography(x, y):
return -x / 15 # gentle linear bed slope
def run_chennai(sim_id):
project_root = os.path.abspath(os.path.dirname(__file__))
if not os.path.exists(project_root):
os.makedirs(project_root)
print "project_root = " + project_root
inputs_dir = '%s/inputs/' % project_root
if not os.path.exists(inputs_dir):
os.makedirs(inputs_dir)
print "inputs_dir = " + inputs_dir
working_dir = '%s/working/%s/' % (project_root, sim_id)
if not os.path.exists(working_dir):
os.makedirs(working_dir)
print "working_dir = " + working_dir
outputs_dir = '%s/outputs/%s' % (project_root, sim_id)
if not os.path.exists(outputs_dir):
os.makedirs(outputs_dir)
print "outputs_dir = " + outputs_dir
# get data
print "downloading data..."
urllib.urlretrieve(
'http://chennaifloodmanagement.org/uploaded/layers/utm44_1arc_v3.tif',
inputs_dir + 'utm44_1arc_v3.tif'
)
print os.listdir(inputs_dir)
# configure logging TODO: get this working!
log_location = project_root + '/' + sim_id + '.log'
open(log_location, 'a').close()
log.console_logging_level = log.INFO
log.log_logging_level = log.DEBUG
log.log_filename = log_location
print "# log.log_filename is: " + log.log_filename
print "# log_location is: " + log_location
log.debug('A message at DEBUG level')
log.info('Another message, INFO level')
print "# starting"
bounding_polygon_01 = [
[303382.14647903712, 1488780.8996663219],
[351451.89152459265, 1499834.3704521982],
[378957.03975921532, 1493150.8764886451],
[422656.80798244767, 1504204.3472745214],
[433196.16384805075, 1471300.9923770288],
[421885.63560203766, 1413463.0638462803],
[408261.59021479468, 1372590.9276845511],
[371245.31595511554, 1427344.16669366],
[316492.0769460068, 1417833.0406686035],
[303382.14647903712, 1488780.8996663219]
]
boundary_tags_01 = {
'inland': [0, 1, 2, 6, 7, 8],
'ocean': [3, 4, 5]
}
print "# Create domain:"
print "# mesh_filename = " + working_dir + 'mesh_01.msh'
domain = anuga.create_domain_from_regions(bounding_polygon=bounding_polygon_01,
boundary_tags=boundary_tags_01,
mesh_filename=working_dir + 'mesh_01.msh',
maximum_triangle_area=100000,
verbose=True)
domain.set_name(sim_id)
domain.set_datadir(outputs_dir)
poly_fun_pairs = [
[
'Extent',
inputs_dir + 'utm44_1arc_v3.tif'
]
]
print "# create topography_function"
print "input raster = " + inputs_dir + 'utm44_1arc_v3.tif'
topography_function = qs.composite_quantity_setting_function(
poly_fun_pairs,
domain,
nan_treatment='exception',
)
print topography_function
print "# set_quantity elevation"
domain.set_quantity('elevation', topography_function) # Use function for elevation
domain.set_quantity('friction', 0.03) # Constant friction
domain.set_quantity('stage', 1) # Constant initial stage
print "# all quantities set"
print "# Setup boundary conditions"
Br = anuga.Reflective_boundary(domain) # Solid reflective wall
Bt = anuga.Transmissive_boundary(domain) # Continue all values on boundary
Bd = anuga.Dirichlet_boundary([-20, 0., 0.]) # Constant boundary values
Bi = anuga.Dirichlet_boundary([10.0, 0, 0]) # Inflow
Bw = anuga.Time_boundary(
domain=domain, # Time dependent boundary
function=lambda t: [(10 * sin(t * 2 * pi) - 0.3) * exp(-t), 0.0, 0.0]
)
print "# Associate boundary tags with boundary objects"
domain.set_boundary({'inland': Br, 'ocean': Bd})
print domain.get_boundary_tags()
catchmentrainfall = Rainfall(
domain=domain,
rate=0.2
)
# # Note need path to File in String.
# # Else assumed in same directory
domain.forcing_terms.append(catchmentrainfall)
print "# Evolve system through time"
counter_timestep = 0
for t in domain.evolve(yieldstep=300, finaltime=6000):
counter_timestep += 1
print counter_timestep
print domain.timestepping_statistics()
asc_out_momentum = outputs_dir + '/' + sim_id + '_momentum.asc'
asc_out_depth = outputs_dir + '/' + sim_id + '_depth.asc'
anuga.sww2dem(outputs_dir + '/' + sim_id + '.sww',
asc_out_momentum,
quantity='momentum',
number_of_decimal_places=3,
cellsize=30,
reduction=max,
verbose=True)
anuga.sww2dem(outputs_dir + '/' + sim_id + '.sww',
asc_out_depth,
quantity='depth',
number_of_decimal_places=3,
cellsize=30,
reduction=max,
verbose=True)
outputs =[asc_out_depth, asc_out_momentum]
for output in outputs:
print "# Convert ASCII grid to GeoTiff so geonode can import it"
src_ds = gdal.Open(output)
dst_filename = (output[:-3] + 'tif')
print "# Create gtif instance"
driver = gdal.GetDriverByName("GTiff")
print "# Output to geotiff"
dst_ds = driver.CreateCopy(dst_filename, src_ds, 0)
print "# Properly close the datasets to flush the disk"
dst_filename = None
src_ds = None
print "Done. Nice work."
poly2 = [p12, p1, p4, p14, p15, p7, p10, p13]
poly3 = [p14, p5, p6, p15]
interiors = [[poly1, max_tri_area_inu], [poly2, max_tri_area_focus], [poly3, max_tri_area_base]]
# ------------------------------------------------------------------------------
###STEP-1 Mesh Creation
# ------------------------------------------------------------------------------
if p_stepMesh:
dirStruct(domain_name)
os.chdir(prj_output_dir)
domain = anuga.create_domain_from_regions(bounding_polygon,
boundary_tags,
maximum_triangle_area=max_tri_area_base,
mesh_filename=prj_output_dir + os.sep + mesh_file,
interior_regions=interiors,
use_cache=p_cache,
verbose=p_verbose)
domain.set_name(domain_name)
domain.set_datadir(prj_output_dir)
domain.set_flow_algorithm(flow_alg)
domain.set_minimum_storable_height(p_minimum_storable_height)
domain.set_quantity('elevation', topography, location='vertices')
domain.set_quantity('friction', p_friction)
domain.set_quantity('stage', initial_stage)
# ------------------------------------------------------------------------------
Br = anuga.Reflective_boundary(domain) # Solid reflective wall
Bt = anuga.Transmissive_boundary(domain) # Continue all values on boundary
Bs = anuga.Transmissive_stage_zero_momentum_boundary(domain)
# Resolution for most of the mesh
base_resolution = 100.0 # m^2
# Resolution in particular area of interest
york_resolution = 50.0 # m^2
interior_regions = [[york_polygon, york_resolution]]
##
domain = anuga.create_domain_from_regions(
bounding_polygon,
boundary_tags={
'bottom': [0],
'right': [1],
'top': [2],
'left': [3]
},
maximum_triangle_area=base_resolution,
interior_regions=interior_regions)
domain.set_name('york1') # Name of sww file
dplotter = animate.Domain_plotter(domain)
plt.triplot(dplotter.triang, linewidth=0.4)
plt.show()
##
domain.set_quantity('elevation',
filename=topography_file,
location='centroids') # Use function for elevation
# Only create sequential domain on processor 0
#===============================================================================
if myid == 0:
#------------------------------------------------------------------------------
# Create the triangular mesh and domain based on
# overall clipping polygon with a tagged
# boundary and interior regions as defined in project.py
#------------------------------------------------------------------------------
print('project name: ', project.name_stem)
domain = anuga.create_domain_from_regions(
project.bounding_polygon,
boundary_tags={
'bottom': [0],
'ocean_east': [1],
'top': [2],
'onshore': [3]
},
maximum_triangle_area=project.res_whole,
mesh_filename=project.meshname,
interior_regions=project.interior_regions,
use_cache=True,
verbose=True)
# Print some stats about mesh and domain
print('Number of triangles = ', len(domain))
print('The extent is ', domain.get_extent())
print(domain.statistics())
#------------------------------------------------------------------------------
# Setup parameters of computational domain
#------------------------------------------------------------------------------
# Import Channel topography DEM
# Create DEM from asc data
anuga.asc2dem(topo_in + '.asc', use_cache=False, verbose=True)
# Create DEM from asc data
anuga.dem2pts(topo_in + '.dem', use_cache=False, verbose=True)
# Define boundaries for mesh
# Read in coordinate file
bounding_polygon = anuga.read_polygon(bound_in + '.csv')
# Create mesh with bounding polygon
domain = anuga.create_domain_from_regions(bounding_polygon,
boundary_tags={
'inlet': [inlet_btag],
'exterior': [ref_btag],
'outlet': [outlet_btag]
},
maximum_triangle_area=res,
mesh_filename=identifier + '.msh',
use_cache=False,
verbose=True)
# Name domain and decide where to save
domain.set_name(identifier)
domain.set_datadir('.')
# Set quantities for domain
# Set elevation from topography file
domain.set_quantity('elevation', filename=topo_in + '.pts')
# Set Manning Roughness of bed
domain.set_quantity('friction', 0.030)
# Set initial stage (if dry bed, set to elevation)
# Create pts file for onshore DEM
anuga.dem2pts(name_stem+'.dem', use_cache=v_cache, verbose=v_verbose)
#------------------------------------------------------------------------------
# Create the triangular mesh and domain based on
# overall clipping polygon with a tagged
# boundary and interior regions as defined in project.py
#------------------------------------------------------------------------------
domain = anuga.create_domain_from_regions(busselton_extent,
boundary_tags={'land_sse': [0],
'land_s': [1],
'bottom': [2],
'ocean_wsw': [3],
'ocean_w': [4],
'ocean_wnw': [5],
'top': [6],
'land_nne': [7],
'land_ese': [8],
'land_se': [9]},
maximum_triangle_area=default_res,
mesh_filename=meshname,
use_cache=v_cache,
verbose=v_verbose)
# Print some stats about mesh and domain
print 'Number of triangles = ', len(domain)
print 'The extent is ', domain.get_extent()
print domain.statistics()
#------------------------------------------------------------------------------
# Setup parameters of computational domain
# Create sequential domain
#======================================
if(myid==0):
# Boundary tags refer to project.landward_boundary
# 4 points equals 5 segments start at N
boundary_tags={'back': range(num_ocean_segments+1,
num_ocean_segments+num_land_points),
'side': [num_ocean_segments,
num_ocean_segments+num_land_points],
'ocean': range(num_ocean_segments)}
# Build mesh and domain
domain = anuga.create_domain_from_regions(bounding_polygon_sts,
boundary_tags=boundary_tags,
maximum_triangle_area=project.bounding_maxarea,
interior_regions=project.interior_regions,
mesh_filename=project.meshes,
use_cache=False,
verbose=verbose)
log.critical(domain.statistics())
# FIXME(Ole): How can we make this more automatic?
domain.geo_reference.zone = project.zone
domain.set_name(project.scenario_name)
domain.set_datadir(project.output_run)
domain.set_flow_algorithm(alg)
#-------------------------------------------------------------------------------
InitialLandStage=6.
riverWall = { 'centralWall':
[ [wallLoc, 0.0, wallHeight],
[wallLoc, 100.0, wallHeight]]
}
riverWall_Par = {'centralWall':{'Qfactor':1.0}}
domain = anuga.create_domain_from_regions(boundaryPolygon,
boundary_tags={'left': [0],
'top': [1],
'right': [2],
'bottom': [3]},
maximum_triangle_area = 10.0,
minimum_triangle_angle = 28.0,
interior_regions =[ ], #[ [higherResPolygon, 1.*1.*0.5],
# [midResPolygon, 3.0*3.0*0.5]],
breaklines=tobreaklines(riverWall)+inlet1_poly+inlet2_poly,
regionPtArea=regionPtAreas,
use_cache=False,
verbose=False)
domain.set_name('run_pump')
domain.set_store_vertices_uniquely(True)
#=======================================
# Setup Initial conditions
#=======================================
#------------------------------------------------------------------------------
# Do the domain creation on processor 0
#------------------------------------------------------------------------------
if myid == 0:
# Create DEM from asc data
anuga.asc2dem('11_fbe_c.asc', use_cache=False, verbose=True)
# Create DEM from asc data
anuga.dem2pts('11_fbe_c.dem', use_cache=False, verbose=True)
bounding_polygon = anuga.read_polygon('channel.csv')
domain = anuga.create_domain_from_regions(bounding_polygon,
boundary_tags={'exterior': [1]},
maximum_triangle_area=1,
mesh_filename='11f.msh',
use_cache=False,
verbose=True)
#Name domain
domain.set_name('11_fbe_c')
domain.set_datadir('.')
#Set quantities for domain, set dry bed
domain.set_quantity('elevation', filename='11_fbe_c.pts')
domain.set_quantity('friction', 0.040)
domain.set_quantity('stage', expression='elevation')
#Define and set boundaries
Br = anuga.Reflective_boundary(domain) # Solid reflective wall
Bt = anuga.Transmissive_boundary(domain) # Continue all values on boundary
from anuga.operators.rate_operators import Rate_operator
#op1 = Rate_operator(domain, rate=lambda t: 10.0 if (t>=0.0) else 0.0, polygon=polygon2)
op2 = Rate_operator(domain, rate=lambda t: 10.0 if (t>=0.0) else 0.0, radius=1.0, center=(10.0, 3.0))
def dyn_t(t):
return t+0.5
op1 = Rate_operator(domain, polygon=polygon1)
domain.set_starttime(-0.1)
boundary_tags={'bottom': [0],
'right': [1],
'top': [2],
'left': [3]}
dodm = anuga.create_domain_from_regions(polygon2,boundary_tags,
maximum_triangle_area = 0.5,
)
from anuga import Region
region1 = Region(domain,radius = 1.0, center = (10.0, 3.0))
if isinstance(region1, Region):
op2.region = region1
else:
op2.region = Region(domain, poly=region1, expand_polygon=True)
if isinstance(polygon1, Region):
op1.region = polygon1
else:
op1.region = Region(domain, poly=polygon1, expand_polygon=True)
from self_try import get_circumference_indices
def run_model():
"""Run a tsunami simulation for a scenario."""
log.info('@'*90)
log.info('@ Running simulation')
log.info('@'*90)
# Read in boundary from ordered sts file
event_sts = anuga.create_sts_boundary(project.event_sts)
# Reading the landward defined points, this incorporates the original
# clipping polygon minus the 100m contour
landward_boundary = anuga.read_polygon(project.landward_boundary)
# Combine sts polyline with landward points
bounding_polygon_sts = event_sts + landward_boundary
# Number of boundary segments
num_ocean_segments = len(event_sts) - 1
# Number of landward_boundary points
num_land_points = anuga.file_length(project.landward_boundary)
# Boundary tags refer to project.landward_boundary
# 4 points equals 5 segments start at N
boundary_tags={'back': range(num_ocean_segments+1,
num_ocean_segments+num_land_points),
'side': [num_ocean_segments,
num_ocean_segments+num_land_points],
'ocean': range(num_ocean_segments)}
# Build mesh and domain
log.debug('bounding_polygon_sts=%s' % str(bounding_polygon_sts))
log.debug('boundary_tags=%s' % str(boundary_tags))
log.debug('project.bounding_maxarea=%s' % str(project.bounding_maxarea))
log.debug('project.interior_regions=%s' % str(project.interior_regions))
log.debug('project.meshes=%s' % str(project.meshes))
domain = anuga.create_domain_from_regions(bounding_polygon_sts,
boundary_tags=boundary_tags,
maximum_triangle_area=project.bounding_maxarea,
interior_regions=project.interior_regions,
mesh_filename=project.meshes,
use_cache=False,
verbose=False)
domain.geo_reference.zone = project.zone
log.info('\n%s' % domain.statistics())
domain.set_name(project.scenario_name)
domain.set_datadir(project.output_folder)
domain.set_minimum_storable_height(0.01) # Don't store depth less than 1cm
# Set the initial stage in the offcoast region only
if project.land_initial_conditions:
IC = anuga.Polygon_function(project.land_initial_conditions,
default=project.tide,
geo_reference=domain.geo_reference)
else:
IC = project.tide
domain.set_quantity('stage', IC, use_cache=True, verbose=False)
domain.set_quantity('friction', project.friction)
domain.set_quantity('elevation',
filename=project.combined_elevation_filestem+'.pts',
use_cache=True, verbose=False, alpha=project.alpha)
# Setup boundary conditions
log.debug('Set boundary - available tags: %s' % domain.get_boundary_tags())
Br = anuga.Reflective_boundary(domain)
Bt = anuga.Transmissive_stage_zero_momentum_boundary(domain)
Bd = anuga.Dirichlet_boundary([project.tide, 0, 0])
Bf = anuga.Field_boundary(project.event_sts+'.sts',
domain, mean_stage=project.tide, time_thinning=1,
default_boundary=anuga.Dirichlet_boundary([0, 0, 0]),
boundary_polygon=bounding_polygon_sts,
use_cache=True, verbose=False)
domain.set_boundary({'back': Br,
'side': Bt,
'ocean': Bf})
# Evolve system through time
t0 = time.time()
for t in domain.evolve(yieldstep=project.yieldstep,
finaltime=project.finaltime,
skip_initial_step=False):
log.info('\n%s' % domain.timestepping_statistics())
log.info('\n%s' % domain.boundary_statistics(tags='ocean'))
log.info('Simulation took %.2f seconds' % (time.time()-t0))
#======================================
if (myid == 0):
# Boundary tags refer to project.landward_boundary
# 4 points equals 5 segments start at N
boundary_tags = {
'back': range(num_ocean_segments + 1,
num_ocean_segments + num_land_points),
'side': [num_ocean_segments, num_ocean_segments + num_land_points],
'ocean': range(num_ocean_segments)
}
# Build mesh and domain
domain = anuga.create_domain_from_regions(
bounding_polygon_sts,
boundary_tags=boundary_tags,
maximum_triangle_area=project.bounding_maxarea,
interior_regions=project.interior_regions,
mesh_filename=project.meshes,
use_cache=False,
verbose=verbose)
log.critical(domain.statistics())
# FIXME(Ole): How can we make this more automatic?
domain.geo_reference.zone = project.zone
domain.set_name(project.scenario_name)
domain.set_datadir(project.output_run)
domain.set_flow_algorithm(alg)
#-------------------------------------------------------------------------------
# Setup initial conditions
# Place 3 buildings downstream
building_polys = [ poly_from_box(10, 15, 2.5, 7.5), # upstream box
poly_from_box(22.5, 27.5, 1.5, 6.5), # middle box
poly_from_box(35, 40, 3.5, 8.5)] # downstream box
building_tags = [ { 'upstream' : [1]}, # Set segment[0], default others
None, # Use default interior tag
{ 'downstream' : [0,1]} ] # set segments[0,1],default others
# create a domain mesh, with 3 building holes in it
domain = anuga.create_domain_from_regions(boundary_poly,
boundary_tags=boundary_tags,
maximum_triangle_area = resolution,
mesh_filename = 'building.msh',
interior_holes = building_polys,
hole_tags = building_tags,
use_cache=True, # to speed it up
verbose=True) # log output on
domain.set_name('buildings') # Output name
#------------------------------------------------------------------------------
# Setup initial conditions
#------------------------------------------------------------------------------
def topography(x,y):
return -x/15 # gentle linear bed slope
domain.set_quantity('elevation', topography) # Use function for elevation
domain.set_quantity('friction', 0.03) # Constant friction
maximum_triangle_area=base_resolution,
interior_regions=interior_regions
)
"""
#domain = anuga.rectangular_cross_domain(10,5,len1 = 2.5, len2 = 1.0)
bounding_polygon = [[0.0, 0.0],
[20.0, 0.0],
[20.0, 10.0],
[0.0, 10.0]]
boundary_tags={'bottom': [0],
'right': [1],
'top': [2],
'left': [3]}
domain = anuga.create_domain_from_regions(bounding_polygon,
boundary_tags,
maximum_triangle_area = 0.5,
)
domain.set_name("small_resolution1")
#domain.set_name('merewether1') # Name of sww file
#dplotter = anuga.Domain_plotter(domain)
#plt.triplot(dplotter.triang, linewidth = 0.4);
domain.set_quantity('elevation', 0.5)
domain.set_quantity('friction', 0.01) # Constant friction
domain.set_quantity('stage',
expression='elevation') # Dry initial condition
Bi = anuga.Dirichlet_boundary([2.0, 0, 0]) # Inflow
Bo = anuga.Dirichlet_boundary([-2, 0, 0])
Br = anuga.Reflective_boundary(domain) # Solid reflective wall
domain.set_boundary({'left': Bi, 'right': Br, 'top': Br, 'bottom': Br})
anuga.dem2pts(project.name_stem + '.dem',
use_cache=project.cache,
verbose=project.verbose)
#------------------------------------------------------------------------------
# Create the triangular mesh and domain based on overall clipping
# polygons with a tagged boundary and interior regions as defined
# in project.py
#------------------------------------------------------------------------------
domain = anuga.create_domain_from_regions(
project.bounding_polygon,
boundary_tags={
'east': [0],
'bottom_ocean': [1],
'west': [2],
'onshore': [3]
},
maximum_triangle_area=project.default_res,
mesh_filename=project.meshname,
interior_regions=project.interior_regions,
use_cache=project.cache,
verbose=project.verbose)
# Print some stats about mesh and domain
print 'Number of triangles = ', len(domain)
print 'The extent is ', domain.get_extent()
print domain.statistics()
#------------------------------------------------------------------------------
# Setup parameters of computational domain
#------------------------------------------------------------------------------
domain.set_name('pwrj_' + project.scenario) # Name of sww file
def generate_cairns_domain(gpu=False):
#-----------------------------------------------------------------------
# Preparation of topographic data
# Convert ASC 2 DEM 2 PTS using source data
# and store result in source data
#-----------------------------------------------------------------------
# Create DEM from asc data
anuga.asc2dem(project.name_stem + '.asc', use_cache=True, verbose=True)
# Create pts file for onshore DEM
anuga.dem2pts(project.name_stem + '.dem', use_cache=True, verbose=True)
#-----------------------------------------------------------------------
# Create the triangular mesh and domain based on
# overall clipping polygon with a tagged
# boundary and interior regions as defined in project.py
#-----------------------------------------------------------------------
domain = anuga.create_domain_from_regions(
project.bounding_polygon,
boundary_tags={
'top': [0],
'ocean_east': [1],
'bottom': [2],
'onshore': [3]
},
maximum_triangle_area=project.default_res,
mesh_filename=project.meshname,
interior_regions=project.interior_regions,
use_cache=True,
verbose=True)
if gpu:
#domain.__class__ = GPU_domain
domain = GPU_domain(domain=domain)
# Print some stats about mesh and domain
print 'Number of triangles = ', len(domain)
#print 'The extent is ', domain.get_extent()
#print domain.statistics()
#-----------------------------------------------------------------------
# Setup parameters of computational domain
#-----------------------------------------------------------------------
domain.set_name('cairns_' + project.scenario) # Name of sww file
domain.set_datadir('.') # Store sww output here
domain.set_minimum_storable_height(0.01) # Store only depth > 1cm
domain.set_flow_algorithm('tsunami')
#-----------------------------------------------------------------------
# Setup initial conditions
#-----------------------------------------------------------------------
tide = 0.0
domain.set_quantity('stage', tide)
domain.set_quantity('friction', 0.0)
domain.set_quantity('elevation',
filename=project.name_stem + '.pts',
use_cache=True,
verbose=True,
alpha=0.1)
#-----------------------------------------------------------------------
# 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=domain,
verbose=True)
#-----------------------------------------------------------------------
# Setup boundary conditions
#-----------------------------------------------------------------------
print 'Available boundary tags', domain.get_boundary_tags()
Bd = anuga.Dirichlet_boundary([tide, 0, 0]) # Mean water level
Bs = anuga.Transmissive_stage_zero_momentum_boundary(domain)
# Neutral boundary
if project.scenario == 'fixed_wave':
# Huge 50m wave starting after 60 seconds and lasting 1 hour.
Bw = anuga.Transmissive_n_momentum_zero_t_momentum_set_stage_boundary(
domain=domain, function=lambda t: [(60 < t < 3660) * 50, 0, 0])
domain.set_boundary({
'ocean_east': Bw,
'bottom': Bs,
'onshore': Bd,
'top': Bs
})
if project.scenario == 'slide':
# Boundary conditions for slide scenario
domain.set_boundary({
'ocean_east': Bd,
'bottom': Bd,
'onshore': Bd,
'top': Bd
})
if gpu:
if '-gpu' in sys.argv:
domain.using_gpu = True
print " --> Enable GPU version"
return domain
InitialLandStage=6.
riverWall = { 'centralWall':
[ [wallLoc, 0.0, wallHeight],
[wallLoc, 100.0, wallHeight]]
}
riverWall_Par = {'centralWall':{'Qfactor':1.0}}
domain = anuga.create_domain_from_regions(boundaryPolygon,
boundary_tags={'left': [0],
'top': [1],
'right': [2],
'bottom': [3]},
maximum_triangle_area = 10.0,
minimum_triangle_angle = 28.0,
interior_regions =[ ], #[ [higherResPolygon, 1.*1.*0.5],
# [midResPolygon, 3.0*3.0*0.5]],
breaklines=tobreaklines(riverWall)+inlet1_poly+inlet2_poly,
regionPtArea=regionPtAreas,
use_cache=False,
verbose=False)
domain.set_name('run_pump')
domain.set_store_vertices_uniquely(True)
#=======================================
# Setup Initial conditions
#=======================================
# Create roughness raster from asc data
#anuga.asc2dem('11_man_c.asc', use_cache=False, verbose=True)
# Create roughness raster from asc data
#anuga.dem2pts('11_man_c.dem', use_cache=False,
# verbose=True)
# In[3]:
bounding_polygon = anuga.read_polygon('extent.csv')
domain = anuga.create_domain_from_regions(bounding_polygon,
boundary_tags={
'top': [0],
'right': [1],
'bottom': [2],
'left': [3]
},
maximum_triangle_area=1,
mesh_filename='11f.msh',
use_cache=False,
verbose=True)
#domain = anuga.Domain(points, vertices, boundary)
domain.set_name('11_fbe_c')
domain.set_datadir('.')
domain.set_quantity('elevation', filename='11_fbe_c.pts')
#domain.set_quantity('friction',filename='11_man_c.pts')
domain.set_quantity('friction', 0.261)
domain.set_quantity('stage', expression='elevation') # DRY BED