def create_domain(self, InitialOceanStage, InitialLandStage, flowAlg,
verbose):
"""
Make the domain and set the flow algorithm for a test. Produces an sww
that we can use for testing
"""
boundaryPolygon = [[0., 0.], [0., 100.], [100.0, 100.0], [100.0, 0.0]]
anuga.create_mesh_from_regions(boundaryPolygon,
boundary_tags={
'left': [0],
'top': [1],
'right': [2],
'bottom': [3]
},
maximum_triangle_area=20.,
minimum_triangle_angle=28.0,
filename='test_plot_utils.msh',
interior_regions=[],
verbose=False)
domain = anuga.create_domain_from_file('test_plot_utils.msh')
os.remove('test_plot_utils.msh')
# 05/05/2014 -- riverwalls only work with DE0 and DE1
domain.set_flow_algorithm(flowAlg)
domain.set_name('test_plot_utils')
domain.set_store_vertices_uniquely()
def topography(x, y):
return -x / 150.
def stagefun(x, y):
stg = InitialOceanStage * (x >= 50.) + InitialLandStage * (x < 50.)
return stg
domain.set_flow_algorithm(flowAlg)
#domain.set_quantity('elevation',topography,location='centroids')
domain.set_quantity('elevation', topography)
domain.set_quantity('friction', 0.03)
#domain.set_quantity('stage', stagefun,location='centroids')
domain.set_quantity('stage', stagefun)
if (verbose):
if (domain.store_centroids):
print ' Centroids stored'
else:
print ' Centroids estimated from vertices'
# Boundary conditions
Br = anuga.Reflective_boundary(domain)
domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br})
for t in domain.evolve(yieldstep=0.2, finaltime=1.0):
pass
return
def create_domain_DE1(self, wallHeight, InitialOceanStage,
InitialLandStage):
# Riverwall = list of lists, each with a set of x,y,z (and optional QFactor) values
riverWall = {
'centralWall': [[wallLoc, 0.0, wallHeight],
[wallLoc, 100.0, wallHeight]]
}
riverWall_Par = {'centralWall': {'Qfactor': 1.0}}
# Make the domain
anuga.create_mesh_from_regions(
boundaryPolygon,
boundary_tags={
'left': [0],
'top': [1],
'right': [2],
'bottom': [3]
},
maximum_triangle_area=200.,
minimum_triangle_angle=28.0,
filename='testRiverwall.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)
domain = anuga.create_domain_from_file('testRiverwall.msh')
# 05/05/2014 -- riverwalls only work with DE0 and DE1
domain.set_flow_algorithm('DE1')
domain.set_name('test_riverwall')
domain.set_store_vertices_uniquely()
def topography(x, y):
return -x / 150.
def stagefun(x, y):
stg = InitialOceanStage * (x >= 50.) + InitialLandStage * (x < 50.)
return stg
# 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', stagefun, location='centroids')
domain.riverwallData.create_riverwalls(riverWall,
riverWall_Par,
verbose=verbose)
# Boundary conditions
Br = anuga.Reflective_boundary(domain)
domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br})
return domain
def create_domain(self, InitialOceanStage, InitialLandStage, flowAlg, verbose):
"""
Make the domain and set the flow algorithm for a test. Produces an sww
that we can use for testing
"""
boundaryPolygon=[ [0., 0.], [0., 100.], [100.0, 100.0], [100.0, 0.0]]
anuga.create_mesh_from_regions(boundaryPolygon,
boundary_tags={'left': [0],
'top': [1],
'right': [2],
'bottom': [3]},
maximum_triangle_area = 20.,
minimum_triangle_angle = 28.0,
filename = 'test_plot_utils.msh',
interior_regions =[ ],
verbose=False)
domain=anuga.create_domain_from_file('test_plot_utils.msh')
os.remove('test_plot_utils.msh')
# 05/05/2014 -- riverwalls only work with DE0 and DE1
domain.set_flow_algorithm(flowAlg)
domain.set_name('test_plot_utils')
domain.set_store_vertices_uniquely()
def topography(x,y):
return -x/150.
def stagefun(x,y):
stg=InitialOceanStage*(x>=50.) + InitialLandStage*(x<50.)
return stg
domain.set_flow_algorithm(flowAlg)
#domain.set_quantity('elevation',topography,location='centroids')
domain.set_quantity('elevation',topography)
domain.set_quantity('friction',0.03)
#domain.set_quantity('stage', stagefun,location='centroids')
domain.set_quantity('stage', stagefun)
if(verbose):
if(domain.store_centroids):
print ' Centroids stored'
else:
print ' Centroids estimated from vertices'
# Boundary conditions
Br=anuga.Reflective_boundary(domain)
domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom':Br})
for t in domain.evolve(yieldstep=0.2,finaltime=1.0):
pass
return
def create_domain_DE0(self, wallHeight, InitialOceanStage, InitialLandStage, riverWall=None, riverWall_Par=None):
# Riverwall = list of lists, each with a set of x,y,z (and optional QFactor) values
if(riverWall is None):
riverWall={ 'centralWall':
[ [wallLoc, 0.0, wallHeight],
[wallLoc, 100.0, wallHeight]]
}
if(riverWall_Par is None):
riverWall_Par={'centralWall':{'Qfactor':1.0}}
# Make the domain
anuga.create_mesh_from_regions(boundaryPolygon,
boundary_tags={'left': [0],
'top': [1],
'right': [2],
'bottom': [3]},
maximum_triangle_area = 200.,
minimum_triangle_angle = 28.0,
filename = 'testRiverwall.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)
domain=anuga.create_domain_from_file('testRiverwall.msh')
# 05/05/2014 -- riverwalls only work with DE0 and DE1
domain.set_flow_algorithm('DE0')
domain.set_name('test_riverwall')
domain.set_store_vertices_uniquely()
def topography(x,y):
return -x/150.
def stagefun(x,y):
stg=InitialOceanStage*(x>=50.) + InitialLandStage*(x<50.)
return stg
# 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', stagefun,location='centroids')
domain.riverwallData.create_riverwalls(riverWall,riverWall_Par,verbose=verbose)
# Boundary conditions
Br=anuga.Reflective_boundary(domain)
domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom':Br})
return domain
def build_mesh(project):
"""
This is executed by processor 0 to build the mesh.
"""
# Ensure mesh_breaklines include riverwalls and breaklines
mesh_breaklines = \
su.combine_breakLines_and_riverWalls_for_mesh(project.breaklines,
project.riverwalls)
# Make the mesh
anuga.create_mesh_from_regions(
project.bounding_polygon,
boundary_tags=project.boundary_tags,
maximum_triangle_area=project.default_res,
filename=project.meshname,
interior_regions=project.interior_regions,
use_cache=False,
verbose=verbose,
breaklines=mesh_breaklines,
regionPtArea=project.region_point_areas,
)
# Make the domain using the mesh
domain = anuga.create_domain_from_file(project.meshname)
# Print some stats about mesh and domain
print 'Number of triangles = ', len(domain)
print 'The extent is ', domain.get_extent()
print domain.statistics()
# Print info on the smallest triangles
small_areas = domain.areas.argsort()
print ''
print 'LOCATIONS OF TRIANGLES WITH SMALLEST AREAS'
for i in range(10):
j = small_areas[i]
x = domain.centroid_coordinates[j, 0] \
+ domain.geo_reference.xllcorner
y = domain.centroid_coordinates[j, 1] \
+ domain.geo_reference.yllcorner
print ' Area ' + str(domain.areas[j]) + ' location: ' \
+ str(round(x, 1)) + ',' + str(round(y, 1))
print ''
return domain
def build_mesh(project):
"""
This is executed by processor 0 to build the mesh.
"""
# Ensure mesh_breaklines include riverwalls and breaklines
mesh_breaklines = su.combine_breakLines_and_riverWalls_for_mesh(project.breaklines, project.riverwalls)
# Make the mesh
anuga.create_mesh_from_regions(
project.bounding_polygon,
boundary_tags=project.boundary_tags,
maximum_triangle_area=project.default_res,
filename=project.meshname,
interior_regions=project.interior_regions,
use_cache=False,
verbose=verbose,
breaklines=mesh_breaklines,
regionPtArea=project.region_point_areas,
)
# Make the domain using the mesh
domain = anuga.create_domain_from_file(project.meshname)
# Print some stats about mesh and domain
print "Number of triangles = ", len(domain)
print "The extent is ", domain.get_extent()
print domain.statistics()
# Print info on the smallest triangles
small_areas = domain.areas.argsort()
print ""
print "LOCATIONS OF TRIANGLES WITH SMALLEST AREAS"
for i in range(10):
j = small_areas[i]
x = domain.centroid_coordinates[j, 0] + domain.geo_reference.xllcorner
y = domain.centroid_coordinates[j, 1] + domain.geo_reference.yllcorner
print " Area " + str(domain.areas[j]) + " location: " + str(round(x, 1)) + "," + str(round(y, 1))
print ""
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
anuga.create_mesh_from_regions(boundaryPolygon,
boundary_tags={'left': [0],
'top': [1],
'right': [2],
'bottom': [3]},
maximum_triangle_area = 200.,
minimum_triangle_angle = 28.0,
filename = 'test_boundaryfluxintegral.msh',
use_cache=False,
verbose=verbose)
domain=anuga.create_domain_from_file('test_boundaryfluxintegral.msh')
# 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
house_addition_poly_fun_pairs.append(
[ breaklines[i], house_height])
house_addition_poly_fun_pairs.append(['All', 0.])
#------------------------------------------------------------------------------
# Make domain
#------------------------------------------------------------------------------
if myid == 0:
mesh = anuga.create_mesh_from_regions(
project.bounding_polygon,
boundary_tags={'bottom': [0],
'right': [1],
'top': [2],
'left': [3]},
maximum_triangle_area=remainder_res,
interior_holes=holes,
breaklines=breaklines,
filename=meshname,
interior_regions=interior_regions,
use_cache=use_cache,
verbose=verbose)
domain = anuga.create_domain_from_file(meshname)
domain.set_flow_algorithm(alg)
if verbose: print domain.get_extent(absolute=True)
#------------------------------------------------------------------------------
# Setup initial conditions
#------------------------------------------------------------------------------
def setup_domain(simulation):
args = simulation.args
verbose = args.verbose
alg = args.alg
N = args.N
S = args.S
E = args.E
W = args.W
from catchment_info import create_catchment_list
from catchment_info import create_manning_list
CatchmentList = create_catchment_list(simulation)
ManningList = create_manning_list(simulation)
#---------------------------------------------------------------------------
# CREATING MESH
#---------------------------------------------------------------------------
bounding_polygon = [[W, S], [E, S], [E, N], [W, N]]
interior_regions = read_polygon_list(CatchmentList)
# FIXME: Have these in a shapefile / other file and read them in
breaklines = [[[306612.336559443, 6193708.75358065],
[306604.441364239, 6193693.17994946]],
[[306977.886673843, 6193753.44134088],
[306978.027867398, 6193710.94208076]],
[[306956.001672788, 6193750.89985688],
[306956.707640564, 6193706.14149989]],
[[306627.303076293, 6193697.45809624],
[306620.525785644, 6193683.62112783]],
[[307236.83565407, 6193741.01630802],
[307231.682089306, 6193721.03741996]],
[[307224.975395434, 6193742.71063068],
[307220.880782334, 6193723.36711362]],
[[307624.764946969, 6193615.98941489],
[307617.98765632, 6193601.44647871]],
[[307613.328268998, 6193623.19028621],
[307607.751123568, 6193610.97704368]]]
# Make the mesh
create_mesh_from_regions(bounding_polygon,
boundary_tags={
'south': [0],
'east': [1],
'north': [2],
'west': [3]
},
maximum_triangle_area=args.maximum_triangle_area,
interior_regions=interior_regions,
filename=args.meshname,
breaklines=breaklines,
use_cache=False,
verbose=True)
#---------------------------------------------------------------------------
# SETUP COMPUTATIONAL DOMAIN
#---------------------------------------------------------------------------
domain = Domain(args.meshname, use_cache=False, verbose=True)
domain.set_flow_algorithm(alg)
if (not domain.get_using_discontinuous_elevation()):
raise Exception, 'This model run relies on a discontinuous elevation solver (because of how topography is set up)'
domain.set_datadir(args.model_output_dir)
domain.set_name(args.outname)
print domain.statistics()
#------------------------------------------------------------------------------
# APPLY MANNING'S ROUGHNESSES
#------------------------------------------------------------------------------
if verbose: print 'Calculating complicated polygon friction function'
friction_list = read_polygon_list(ManningList)
domain.set_quantity(
'friction',
Polygon_function(friction_list,
default=args.base_friction,
geo_reference=domain.geo_reference))
# Set a Initial Water Level over the Domain
domain.set_quantity('stage', 0)
if verbose: print 'Setting up elevation interpolation function'
from anuga.utilities.quantity_setting_functions import make_nearestNeighbour_quantity_function
if verbose: print 'READING %s' % args.basename + '.csv'
elev_xyz = numpy.genfromtxt(fname=args.basename + '.csv', delimiter=',')
# Use nearest-neighbour interpolation of elevation
if verbose: print 'CREATING nearest neighbour interpolator'
elev_fun_wrapper = make_nearestNeighbour_quantity_function(
elev_xyz, domain)
if verbose: print 'Applying elevation interpolation function'
domain.set_quantity('elevation', elev_fun_wrapper, location='centroids')
return domain
breaklines[i] = breaklines[i] + [breaklines[i][0]]
house_addition_poly_fun_pairs.append([breaklines[i], house_height])
house_addition_poly_fun_pairs.append(['All', 0.])
#------------------------------------------------------------------------------
# Make domain
#------------------------------------------------------------------------------
if myid == 0:
mesh = anuga.create_mesh_from_regions(project.bounding_polygon,
boundary_tags={
'bottom': [0],
'right': [1],
'top': [2],
'left': [3]
},
maximum_triangle_area=remainder_res,
interior_holes=holes,
breaklines=breaklines,
filename=meshname,
interior_regions=interior_regions,
use_cache=use_cache,
verbose=verbose)
domain = anuga.create_domain_from_file(meshname)
domain.set_flow_algorithm(alg)
if verbose: print(domain.get_extent(absolute=True))
#------------------------------------------------------------------------------
# Setup initial conditions
#------------------------------------------------------------------------------
def main():
try:
try:
usage = "usage: lakeerode.py LakeRadius-in-meters [-m depthmultiplier] [-i initialbreachdepth]\n"
parser = optparse.OptionParser(usage=usage)
parser.add_option("-m",
dest="dm",
help="Depth Multiplier for lake")
parser.add_option("-i",
dest="initbreachdepth",
help="Initial breach depth for flood")
(options, inargs) = parser.parse_args()
if not inargs: parser.error("need parameters")
lakeradius = float(inargs[0])
dm = 1.0 #default
if (options.dm): dm = float(options.dm)
h = dm * 21.39 * math.pow(
(lakeradius / 1000), 0.62
) #max depth in meters to get V=0.01A**1.31 from Fassett and Head 2008
initbreachdepth = 15.0 #default
lakebelowconfining = 5
if (options.initbreachdepth):
initbreachdepth = float(options.initbreachdepth)
initbreachdepth = initbreachdepth + lakebelowconfining #set this to be a real initial head, not dependent on lakebelowconfining
extslope = -0.015
extslopeint = 0.015
#anuga critical parameter
anuga.g = gravity
#domain parameters
domainpolygon = [[0, 0], [0 * lakeradius, 2 * lakeradius],
[2 * lakeradius, 2 * lakeradius],
[2 * lakeradius, 1.2 * lakeradius],
[10 * lakeradius, 1.2 * lakeradius],
[10 * lakeradius, 0.8 * lakeradius],
[2 * lakeradius, 0.8 * lakeradius],
[2 * lakeradius, 0], [0, 0]]
outletregion = [[1.9 * lakeradius, 0.8 * lakeradius],
[1.9 * lakeradius, 1.2 * lakeradius],
[4.5 * lakeradius, 1.2 * lakeradius],
[4.5 * lakeradius, 0.8 * lakeradius]]
boundary_tags = {'exterior': [0]}
high_resolution = (lakeradius / 100)**2
base_resolution = high_resolution * 80.0
initbreachwidth = lakeradius / 50.0
interior_regions = [[outletregion, high_resolution]]
meshname = 'lake.msh'
m = anuga.create_mesh_from_regions(
domainpolygon,
boundary_tags,
maximum_triangle_area=base_resolution,
interior_regions=interior_regions,
filename=meshname,
use_cache=False)
evolved_quantities = [
'stage', 'xmomentum', 'ymomentum', 'concentration', 'sedvolx',
'sedvoly'
]
#evolved_quantities = ['stage', 'xmomentum', 'ymomentum', 'concentration']
domain = anuga.Domain(meshname,
use_cache=False,
evolved_quantities=evolved_quantities)
domain.g = anuga.g # make sure the domain inherits the package's gravity.
print 'Number of triangles = ', len(domain)
def find_nearest(array, value):
array = np.asarray(array)
idx = (np.abs(array - value)).argmin()
return idx
def topography(x, y):
xc = x - lakeradius
yc = y - lakeradius
#sets up lake
ellipsoid = -(h**2 * (1 -
((xc**2 + yc**2) / lakeradius**2)))**0.5
z = np.where(ellipsoid < 0, ellipsoid, 0.0)
#sets up exterior slope
z = np.where(
np.logical_and(x > lakeradius * 2, x <= lakeradius * 4),
(x - lakeradius * 2) * extslope +
abs(y - lakeradius) * extslopeint, z)
#setup flatlying area
z = np.where(x > lakeradius * 4, (lakeradius * 2) * extslope +
abs(y - lakeradius) * extslopeint, z)
# add gaussian noise, with zero mean and 0.1 m standard deviation.
#z=z+np.random.normal(0,0.1,z.shape)
# set up breach as a failure at the midpoint in a region
#mask1 = (x>=(lakeradius*2+(initbreachdepth/extslope)))
mask1 = (x >= lakeradius)
#mask2 = (x<=(lakeradius*2-(initbreachdepth/extslope)))
mask3 = (y >= ((lakeradius - (initbreachwidth / 2.0))))
mask4 = (y <= ((lakeradius + (initbreachwidth / 2.0))))
mask5 = (z > -initbreachdepth)
#mask=mask1 & mask2 & mask3 & mask4 & mask5
mask = mask1 & mask3 & mask4 & mask5
z[mask] = -initbreachdepth
return z
def initialstage(x, y):
clow = domain.get_quantity('elevation').get_values(
interpolation_points=[[2 * lakeradius, lakeradius]])
istage = clow + initbreachdepth - lakebelowconfining
#outsidelake. Force depth=0 (istage=topo) across rim.
#istage=np.where(x>lakeradius*2,topography(x,y),istage)
istage = np.where(x > lakeradius * 2, -10000, istage)
return istage
name = "Marslake" + str(lakeradius) + "_" + str(
grainD * 1000) + "mm"
domain.set_name(name)
# Choose between DE0 (less accurate), DE1 (more accurate, slower), DE2 (even more accurate, slower still)
domain.set_flow_algorithm('DE0')
domain.set_CFL(cfl=1)
domain.set_minimum_allowed_height(
0.01
) #raise the default minimum depth from 1 mm to 1 cm to speed the simulation (for computation)
domain.set_minimum_storable_height(
0.01
) #raise the default minimum depth from 1 mm to 1 cm to speed the simulation (for storage/visualization)
domain.set_maximum_allowed_speed(
1
) #maximum particle speed that is allowed in water shallower than minimum_allowed_height (back of the envelope suggests 1m/s should be below tau_crit)
np.seterr(invalid='ignore')
domain.set_quantity(
'elevation', topography,
location='centroids') # elevation is a function
voltotal = np.sum(domain.quantities['elevation'].centroid_values *
domain.areas)
domain.set_quantity('concentration', 0.00) # Start with no esd
domain.set_quantity(
'friction', 0.0545
) # Constant Manning friction. Only used to initialize domain (calculated every time step).
domain.set_quantity('stage', initialstage, location='centroids')
domain.set_quantities_to_be_stored({
'stage': 2,
'xmomentum': 2,
'ymomentum': 2,
'elevation': 2
})
np.seterr(invalid='warn')
# Setup boundary conditions
Br = anuga.Reflective_boundary(domain)
domain.set_boundary({'exterior': Br})
operatezero = suspendedtransport_operator(domain)
operateone = bedloadtransport_operator(domain)
operatetwo = friction_operator(domain)
operatethree = AoR_operator(domain)
initial = domain.get_quantity('elevation').get_values(
interpolation_points=[[2 * lakeradius, lakeradius]],
location='centroids')
initialdomain = copy.deepcopy(domain)
ystep = 300
ftime = 86400 * 10
count = 0
volthresh = 1000
for t in domain.evolve(yieldstep=ystep, finaltime=ftime):
print domain.timestepping_statistics()
print 'xmom:' + str(
domain.get_quantity('xmomentum').get_values(
interpolation_points=[[2 * lakeradius, lakeradius]],
location='centroids'))
volcurr = np.sum(
domain.quantities['elevation'].centroid_values *
domain.areas)
breacherosion = domain.get_quantity('elevation').get_values(
interpolation_points=[[2 * lakeradius, lakeradius]],
location='centroids') - initial
print 'erosion: ' + str(breacherosion)
volsed = np.sum(
domain.quantities['concentration'].centroid_values *
domain.quantities['height'].centroid_values * domain.areas)
conservation = (volcurr + volsed - voltotal) / voltotal
print 'conservation: ' + '{:.8%}'.format(conservation)
if (volsed < volthresh) & (count > 0):
print "No sediment moving...ending..."
break
count = count + 1
polyline = [[2 * lakeradius, lakeradius - 2 * initbreachwidth],
[2 * lakeradius, lakeradius + 2 * initbreachwidth]]
time, Q = anuga.get_flow_through_cross_section(
name + '.sww', polyline)
print Q
initname = "initial_" + str(lakeradius) + "_" + str(
grainD * 1000) + "mm" + ".asc"
finname = "final_" + str(lakeradius) + "_" + str(
grainD * 1000) + "mm" + ".asc"
fluxname = "flux_" + str(lakeradius) + "_" + str(
grainD * 1000) + "mm" + ".txt"
np.savetxt(fluxname, Q)
finalstats(domain, initialdomain, lakeradius)
np.save('XconcC.npy',
domain.quantities['concentration'].centroid_values)
np.save('XelevC.npy',
domain.quantities['elevation'].centroid_values)
np.save('XxmC.npy', domain.quantities['xmomentum'].centroid_values)
np.save('XymC.npy', domain.quantities['ymomentum'].centroid_values)
np.save('XstageC.npy', domain.quantities['stage'].centroid_values)
np.save('XconcV.npy',
domain.quantities['concentration'].vertex_values)
np.save('XelevV.npy', domain.quantities['elevation'].vertex_values)
np.save('XxmV.npy', domain.quantities['xmomentum'].vertex_values)
np.save('XymV.npy', domain.quantities['ymomentum'].vertex_values)
np.save('XstageV.npy', domain.quantities['stage'].vertex_values)
except optparse.OptionError, msg:
raise Usage(msg)
except Usage, err:
print >> sys.stderr, err.msg
# print >>sys.stderr, "for help use --help"
return 2
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')
[floodplain_width - 0.01, floodplain_length / 2., 0.5 * l0 * l0],
[floodplain_width + 0.01, floodplain_length / 2., 0.5 * l0 * l0],
]
if (myid == 0):
# Define domain with appropriate boundary conditions
anuga.create_mesh_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=1.0e+06, #0.5*l0*l0,
minimum_triangle_angle=28.0,
filename='channel_floodplain1.msh',
interior_regions=[],
breaklines=breakLines.values(),
regionPtArea=regionPtAreas,
verbose=True)
domain = anuga.create_domain_from_file('channel_floodplain1.msh')
domain.set_name('channel_floodplain1') # Output name
domain.set_flow_algorithm(alg)
else:
domain = None
def main():
try:
try:
usage = "usage: jezero.py -1*initialstage-in-m \n Note that -2260 flows but barely does anything. So range for jezero is ~2260 to 2200. \n"
parser = optparse.OptionParser(usage=usage)
(options, inargs) = parser.parse_args()
if not inargs: parser.error("need parameters")
jezerostage = -1.0 * float(inargs[0])
# Before doing anything else, set gravity to Mars
anuga.g = gravity
#domain parameters
poly_highres = anuga.read_polygon('JezeroData/PolyHi.csv')
poly_bound = anuga.read_polygon(
'JezeroData/PolyBoundBiggerPts.csv')
base_scale = 25600 #160 m #HIRES REGION
lowres = 10000 * base_scale # 10 km
boundary_tags = {'exterior': [0]}
# Define list of interior regions with associated resolutions
interior_regions = [[poly_highres, base_scale]]
meshname = 'JezeroData/jezero.msh'
mesh = anuga.create_mesh_from_regions(
poly_bound,
boundary_tags=boundary_tags,
maximum_triangle_area=lowres,
interior_regions=interior_regions,
verbose=True,
filename=meshname,
fail_if_polygons_outside=False)
evolved_quantities = [
'stage', 'xmomentum', 'ymomentum', 'concentration', 'sedvolx',
'sedvoly'
]
domain = anuga.Domain(meshname,
use_cache=False,
evolved_quantities=evolved_quantities)
domain.g = anuga.g # make sure the domain inherits the package's gravity.
domain.set_quantity("elevation",
filename="JezeroData/jbigger.pts",
use_cache=False,
verbose=True)
domain.smooth = True
name = "jezero" + str(jezerostage) + "_" + str(
grainD * 1000.0) + "mm"
domain.set_name(name)
# Choose between DE0 (less accurate), DE1 (more accurate, slower), DE2 (even more accurate, slower still)
domain.set_flow_algorithm('DE0')
domain.set_CFL(cfl=1.0)
domain.set_minimum_allowed_height(
0.01
) #raise the default minimum depth from 1 mm to 1 cm to speed the simulation (for computation)
domain.set_minimum_storable_height(
0.01
) #raise the default minimum depth from 1 mm to 1 cm to speed the simulation (for storage/visualization)
domain.set_maximum_allowed_speed(
1.0
) #maximum particle speed that is allowed in water shallower than minimum_allowed_height (back of the envelope suggests 1m/s should be below tau_crit)
np.seterr(invalid='ignore')
voltotal = np.sum(domain.quantities['elevation'].centroid_values *
domain.areas)
domain.set_quantity('concentration', 0.00) # Start with no esd
domain.set_quantity(
'friction', constantn
) # Constant Manning friction. Only used to initialize domain (calculated every time step).
domain.set_quantity('stage', -10000.0)
stagepolygon = anuga.read_polygon('JezeroData/stage.csv')
domain.set_quantity('stage', jezerostage, polygon=stagepolygon)
domain.set_quantities_to_be_stored({
'stage': 2,
'xmomentum': 2,
'ymomentum': 2,
'elevation': 2
})
np.seterr(invalid='warn')
Br = anuga.Reflective_boundary(domain)
domain.set_boundary({'exterior': Br})
# fixed_inflow = anuga.Inlet_operator(domain, stagepolygon, Q=1000.0)
operatezero = suspendedtransport_operator(domain)
operateone = bedloadtransport_operator(domain)
operatetwo = friction_operator(domain)
operatethree = AoR_operator(domain)
breachpoint = [[19080.340, 1097556.781]]
initialdomain = copy.deepcopy(domain)
initial = domain.get_quantity('elevation').get_values(
interpolation_points=breachpoint, location='centroids')
print str(initial)
ystep = 300.0
ftime = 86400.0 * 5.0
polyline = [[40000, 1090000], [15000, 1120000]]
count = 0
for t in domain.evolve(yieldstep=ystep, finaltime=ftime):
print domain.timestepping_statistics()
print 'xmom:' + str(
domain.get_quantity('xmomentum').get_values(
interpolation_points=breachpoint,
location='centroids'))
breacherosion = domain.get_quantity('elevation').get_values(
interpolation_points=breachpoint,
location='centroids') - initial
print 'erosion: ' + str(breacherosion)
volcurr = np.sum(
domain.quantities['elevation'].centroid_values *
domain.areas)
volsed = np.sum(
domain.quantities['concentration'].centroid_values *
domain.quantities['height'].centroid_values * domain.areas)
conservation = (volcurr + volsed - voltotal) / voltotal
print 'conservation: ' + '{:.8%}'.format(conservation)
count = count + 1
time, Q = anuga.get_flow_through_cross_section(
name + '.sww', polyline)
print Q
initname = "initial_" + name + ".asc"
finname = "final_" + name + ".asc"
fluxname = "flux_" + name + ".txt"
np.savetxt(fluxname, Q)
anuga.sww2dem(name + '.sww', initname, reduction=0)
anuga.sww2dem(name + '.sww', finname, reduction=(count - 1))
finalstats(domain, initialdomain)
np.save('XconcC.npy',
domain.quantities['concentration'].centroid_values)
np.save('XelevC.npy',
domain.quantities['elevation'].centroid_values)
np.save('XxmC.npy', domain.quantities['xmomentum'].centroid_values)
np.save('XymC.npy', domain.quantities['ymomentum'].centroid_values)
np.save('XstageC.npy', domain.quantities['stage'].centroid_values)
np.save('XconcV.npy',
domain.quantities['concentration'].vertex_values)
np.save('XelevV.npy', domain.quantities['elevation'].vertex_values)
np.save('XxmV.npy', domain.quantities['xmomentum'].vertex_values)
np.save('XymV.npy', domain.quantities['ymomentum'].vertex_values)
np.save('XstageV.npy', domain.quantities['stage'].vertex_values)
except optparse.OptionError, msg:
raise Usage(msg)
except Usage, err:
print >> sys.stderr, err.msg
# print >>sys.stderr, "for help use --help"
return 2
# Make a directory to store outputs
os.mkdir(project.output_run)
print 'OUTPUT FOLDER IS: ', project.output_run
anuga.copy_code_files(project.output_run,'run_model.py', 'project.py') # Write model files to folder
#------------------------------------------------------------------------------
# Create the triangular mesh and domain based on
# overall clipping polygon with a tagged
# boundary and interior regions as defined in project.py
#------------------------------------------------------------------------------
anuga.create_mesh_from_regions(project.bounding_polygon,
boundary_tags={'top': [0],
'ocean_east': [1],
'bottom': [2],
'onshore': [3]},
maximum_triangle_area=project.low_res_0,
filename=project.meshname,
interior_regions=[], #project.interior_regions,
breaklines=project.breakLines,
regionPtArea=project.regionPtAreas,
use_cache=False,
verbose=True)
domain=anuga.create_domain_from_file(project.meshname)
# 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_flow_algorithm('tsunami')
domain.verbose=True
E = 296730.
S = 6179960.
#------------------------------------------------------------------------------
# CREATING MESH
#------------------------------------------------------------------------------
bounding_polygon = [[W, S], [E, S], [E, N], [W, N]]
create_mesh_from_regions(bounding_polygon,
boundary_tags={
'south': [0],
'east': [1],
'north': [2],
'west': [3]
},
maximum_triangle_area=1.0,
filename=meshname,
use_cache=False,
verbose=True)
#------------------------------------------------------------------------------
# SETUP COMPUTATIONAL DOMAIN
#------------------------------------------------------------------------------
domain = Domain(meshname, use_cache=False, verbose=True)
domain.set_minimum_storable_height(0.0001)
domain.set_name(outname)
print(domain.statistics())
def create_domain(self,
InitialOceanStage,
InitialLandStage,
flowAlg='DE0',
verbose=False):
"""
Make the domain and set the flow algorithm for a test. Produces an sww
that we can use for testing
"""
boundaryPolygon = [[minX, minY], [minX, minY + 100.],
[minX + 100., minY + 100.], [minX + 100., minY]]
anuga.create_mesh_from_regions(
boundaryPolygon,
boundary_tags={
'left': [0],
'top': [1],
'right': [2],
'bottom': [3]
},
maximum_triangle_area=1.,
minimum_triangle_angle=28.0,
filename='test_quantity_setting_functions.msh',
interior_regions=[],
verbose=False)
domain = anuga.create_domain_from_file(
'test_quantity_setting_functions.msh')
os.remove('test_quantity_setting_functions.msh')
domain.set_flow_algorithm(flowAlg)
domain.set_name('test_quantity_setting_functions')
domain.set_store_vertices_uniquely()
def topography(x, y):
return -x / 150.
def stagefun(x, y):
stg = InitialOceanStage * (x >= 50.) + InitialLandStage * (x < 50.)
return stg
domain.set_flow_algorithm(flowAlg)
# domain.set_quantity('elevation',topography,location='centroids')
domain.set_quantity('elevation', topography)
domain.set_quantity('friction', 0.03)
#domain.set_quantity('stage', stagefun,location='centroids')
domain.set_quantity('stage', stagefun)
if (verbose):
if (domain.store_centroids):
print(' Centroids stored')
else:
print(' Centroids estimated from vertices')
# Boundary conditions
Br = anuga.Reflective_boundary(domain)
domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br})
return 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.")
def setup_domain(simulation):
args = simulation.args
verbose = args.verbose
alg = args.alg
N = args.N
S = args.S
E = args.E
W = args.W
from catchment_info import create_catchment_list
from catchment_info import create_manning_list
CatchmentList = create_catchment_list(simulation)
ManningList = create_manning_list(simulation)
#------------------------------------------------------------------------------
# CREATING MESH
#------------------------------------------------------------------------------
bounding_polygon = [[W, S], [E, S], [E, N], [W, N]]
#interior_regions = read_polygon_dir(CatchmentDictionary, join('Model', 'Bdy'))
interior_regions = read_polygon_list(CatchmentList)
# FIXME: Have these in a shapefile / other file and read them in
breaklines=[[[306612.336559443,6193708.75358065],
[306604.441364239,6193693.17994946]],
[[306977.886673843,6193753.44134088],
[306978.027867398,6193710.94208076]],
[[306956.001672788,6193750.89985688],
[306956.707640564,6193706.14149989]],
[[306627.303076293,6193697.45809624],
[306620.525785644,6193683.62112783]],
[[307236.83565407,6193741.01630802],
[307231.682089306,6193721.03741996]],
[[307224.975395434,6193742.71063068],
[307220.880782334,6193723.36711362]],
[[307624.764946969,6193615.98941489],
[307617.98765632,6193601.44647871]],
[[307613.328268998,6193623.19028621],
[307607.751123568,6193610.97704368]]]
# Make the mesh
create_mesh_from_regions(bounding_polygon,
boundary_tags={'south': [0], 'east': [1], 'north': [2], 'west': [3]},
maximum_triangle_area=args.maximum_triangle_area,
interior_regions=interior_regions,
filename=args.meshname,
breaklines=breaklines,
use_cache=False,
verbose=True)
#------------------------------------------------------------------------------
# SETUP COMPUTATIONAL DOMAIN
#------------------------------------------------------------------------------
domain = Domain(args.meshname, use_cache=False, verbose=True)
domain.set_flow_algorithm(alg)
if(not domain.get_using_discontinuous_elevation()):
raise Exception, 'This model run relies on a discontinuous elevation solver (because of how topography is set up)'
domain.set_datadir(args.model_output_dir)
domain.set_name(args.outname)
print domain.statistics()
#------------------------------------------------------------------------------
# APPLY MANNING'S ROUGHNESSES
#------------------------------------------------------------------------------
if verbose: print 'Calculating complicated polygon friction function'
friction_list = read_polygon_list(ManningList)
domain.set_quantity('friction', Polygon_function(friction_list, default=args.base_friction, geo_reference=domain.geo_reference))
# Set a Initial Water Level over the Domain
domain.set_quantity('stage', 0)
# Decompress the zip file to make a csv for reading
zipfile.ZipFile('DEM_bridges/towradgi_cleaner.zip').extract('towradgi.csv',path='DEM_bridges/')
if verbose: print 'Setting up elevation interpolation function'
from anuga.utilities.quantity_setting_functions import make_nearestNeighbour_quantity_function
elev_xyz=numpy.genfromtxt(fname=args.basename+'.csv',delimiter=',')
# Use nearest-neighbour interpolation of elevation
elev_fun_wrapper=make_nearestNeighbour_quantity_function(elev_xyz,domain)
if verbose: print 'Applying elevation interpolation function'
domain.set_quantity('elevation', elev_fun_wrapper, location='centroids')
os.remove('DEM_bridges/towradgi.csv') # Clean up csv file
return domain
craterlength=0.35
rimheight=0.12
rimwidth=0.14
extslope=0.04
buffslope=0.2
lakeslope=0.4
initbreachwidth=0.08
initbreachdepth=0.08
lakeregion=[[0,0],[0.28,0],[0.28,craterwidth],[0,craterwidth],[0,0]]
nextregion=[[0.28,0],[0.28,craterwidth],[4,craterwidth],[4,0],[0.28,0]]
endregion=[[4,craterwidth],[5,craterwidth],[5,0],[4,0],[4,craterwidth]]
meshname='lake.msh'
m = anuga.create_mesh_from_regions(domainpolygon, boundary_tags, maximum_triangle_area=low_res,interior_regions=interior_regions,filename=meshname, use_cache=False)
evolved_quantities = ['stage', 'xmomentum', 'ymomentum', 'concentration', 'sedvolx', 'sedvoly']
#evolved_quantities = ['stage', 'xmomentum', 'ymomentum', 'concentration']
domain = anuga.Domain(meshname, use_cache=False, evolved_quantities = evolved_quantities)
domain.g = anuga.g # make sure the domain inherits the package's gravity.
print 'Number of triangles = ', len(domain)
def find_nearest(array, value):
array = np.asarray(array)
idx = (np.abs(array - value)).argmin()
return idx
def topography(x, y):
maxx = np.max(x)
miny, maxy = np.min(y), np.max(y)
import matplotlib.pyplot as plt
plt.figure()
plt.plot(b_polygon[:, 0], b_polygon[:, 1])
for i, v in enumerate(b_polygon):
plt.annotate(str(v), xy=v, xytext=(-7, 7), textcoords='offset points')
plt.pause(0.01)
create_mesh_from_regions(
bounding_polygon,
boundary_tags={
'inflow': [12],
'bottom': [0, 1, 2, 3, 4, 5],
'top': [7, 8, 9, 10, 11],
'outflow': [6]
},
#boundary_tags=None,
maximum_triangle_area=0.1,
breaklines=riverWalls.values(),
interior_regions=interior_regions,
filename=meshname,
use_cache=False,
verbose=True)
#------------------------------------------------------------------------------
# SETUP COMPUTATIONAL DOMAIN
#------------------------------------------------------------------------------
domain = anuga.Domain(meshname, use_cache=False, verbose=True)
domain.set_minimum_storable_height(0.0)
domain.riverwallData.create_riverwalls(riverWalls)
for record in lines:
#Since we are dealing with multi polys, only take the first [0]
coords = json.loads(record[0])["coordinates"][0]
interior_regions.append([coords, 100])
#------------------------------------------------------------------------------
# Create the triangular mesh and domain based on
# overall clipping polygon with a tagged
# boundary and interior regions as defined in project.py
#------------------------------------------------------------------------------
meshname = project.tmppath + 'output.msh'
mesh = anuga.create_mesh_from_regions(
bounding_polygon,
boundary_tags={
'top': [0],
'east': [1],
'bottom': [2],
'west': [3]
},
maximum_triangle_area=project.default_res,
filename=meshname,
interior_regions=interior_regions,
interior_holes=interior_holes,
hole_tags=None,
breaklines=breaklines,
#breaklines = None,
use_cache=False,
verbose=True)
plt.plot(b[:,0],b[:,1])
plt.contour(x,y,z,[0.],colors='w')
plt.axis('equal')
#plt.axis('off')
plt.savefig('01bati_original+extent+curva0.png',bbox_inches='tight',dpi=300)
plt.close()
bounding_polygon=b[:-1,:]
tags={'left' : [3], 'bot' : [0],'right' : [1],'top' : [2]}
#el tama\~no m\'aximo
dx=48*5
anuga.create_mesh_from_regions(bounding_polygon,
boundary_tags=tags,
maximum_triangle_area=dx*dx,
filename='talcahuano4.msh',
use_cache=False,
verbose=True)
#----------la batimetria------------
#archivo con info de la proyeccion
sprj='Projection UTM \n'+ \
'Zone 55\n'+\
'Datum WGS84\n'+\
'Zunits NO\n'+\
'Units METERS\n'+\
'Spheroid WGS84\n'+\
'Xshift 500000\n'+\
'Yshift 10000000\n'+\
'Parameters'
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')
[floodplain_width/2., floodplain_length/2., 0.5*l0*l0],
[floodplain_width-0.01, floodplain_length/2., 0.5*l0*l0],
[floodplain_width+0.01, floodplain_length/2., 0.5*l0*l0],
]
if(myid==0):
# Define domain with appropriate boundary conditions
anuga.create_mesh_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 = 1.0e+06, #0.5*l0*l0,
minimum_triangle_angle = 28.0,
filename = 'channel_floodplain1.msh',
interior_regions = [ ],
breaklines=breakLines.values(),
regionPtArea=regionPtAreas,
verbose=True)
domain=anuga.create_domain_from_file('channel_floodplain1.msh')
domain.set_name('channel_floodplain1') # Output name
domain.set_flow_algorithm(alg)
else:
domain=None
barrier()
domain=distribute(domain)
[45., 45., 1.0*1.0*0.5],
[55., 55., 1.0*1.0*0.5],
[65., 65., 3.0*3.0*0.5],
[35., 35., 3.0*3.0*0.5] ]
if myid == 0:
#==================================================================
# Create Sequential Domain
#==================================================================
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=True,
regionPtArea=regionPtAreas)
domain=anuga.create_domain_from_file('runup.msh')
domain.set_flow_algorithm(alg)
domain.set_name('runup_riverwall')
domain.set_datadir('.')
