def _build_regular_mesh_dict(self,
maxArea=1000,
is_segments=True,
save=False,
geo=None):
# make a normalised mesh
# pretty regular size, with some segments thrown in.
# don't pass in the geo ref.
# it is applied in domain
m = Mesh() #geo_reference=geo)
m.addUserVertex(0, 0)
m.addUserVertex(1.0, 0)
m.addUserVertex(0, 1.0)
m.addUserVertex(1.0, 1.0)
m.auto_segment(alpha=100)
if is_segments:
dict = {}
dict['points'] = [[.10, .10], [.90, .20]]
dict['segments'] = [[0, 1]]
dict['segment_tags'] = ['wall1']
m.addVertsSegs(dict)
dict = {}
dict['points'] = [[.10, .90], [.40, .20]]
dict['segments'] = [[0, 1]]
dict['segment_tags'] = ['wall2']
m.addVertsSegs(dict)
dict = {}
dict['points'] = [[.20, .90], [.60, .60]]
dict['segments'] = [[0, 1]]
dict['segment_tags'] = ['wall3']
m.addVertsSegs(dict)
dict = {}
dict['points'] = [[.60, .20], [.90, .90]]
dict['segments'] = [[0, 1]]
dict['segment_tags'] = ['wall4']
m.addVertsSegs(dict)
m.generateMesh(mode="Q", maxArea=maxArea, minAngle=20.0)
if save is True:
m.export_mesh_file("aaaa.tsh")
mesh_dict = m.Mesh2IOTriangulationDict()
#Add vert attribute info to the mesh
mesh_dict['vertex_attributes'] = []
# There has to be a better way of doing this..
for vertex in mesh_dict['vertices']:
mesh_dict['vertex_attributes'].append([10.0])
return mesh_dict
def _build_regular_mesh_dict(self,
maxArea=1000,
is_segments=True,
save=False,
geo=None):
# make a normalised mesh
# pretty regular size, with some segments thrown in.
# don't pass in the geo ref.
# it is applied in domain
m = Mesh() #geo_reference=geo)
m.addUserVertex(0,0)
m.addUserVertex(1.0,0)
m.addUserVertex(0,1.0)
m.addUserVertex(1.0,1.0)
m.auto_segment(alpha = 100 )
if is_segments:
dict = {}
dict['points'] = [[.10,.10],[.90,.20]]
dict['segments'] = [[0,1]]
dict['segment_tags'] = ['wall1']
m.addVertsSegs(dict)
dict = {}
dict['points'] = [[.10,.90],[.40,.20]]
dict['segments'] = [[0,1]]
dict['segment_tags'] = ['wall2']
m.addVertsSegs(dict)
dict = {}
dict['points'] = [[.20,.90],[.60,.60]]
dict['segments'] = [[0,1]]
dict['segment_tags'] = ['wall3']
m.addVertsSegs(dict)
dict = {}
dict['points'] = [[.60,.20],[.90,.90]]
dict['segments'] = [[0,1]]
dict['segment_tags'] = ['wall4']
m.addVertsSegs(dict)
m.generateMesh(mode = "Q", maxArea = maxArea, minAngle=20.0)
if save is True:
m.export_mesh_file("aaaa.tsh")
mesh_dict = m.Mesh2IOTriangulationDict()
#Add vert attribute info to the mesh
mesh_dict['vertex_attributes'] = []
# There has to be a better way of doing this..
for vertex in mesh_dict['vertices']:
mesh_dict['vertex_attributes'].append([10.0])
return mesh_dict
def setUp(self):
def elevation_function(x, y):
return -x
""" Setup for all tests. """
mesh_file = tempfile.mktemp(".tsh")
points = [[0.0,0.0],[6.0,0.0],[6.0,6.0],[0.0,6.0]]
m = Mesh()
m.add_vertices(points)
m.auto_segment()
m.generate_mesh(verbose=False)
m.export_mesh_file(mesh_file)
# Create shallow water domain
domain = anuga.Domain(mesh_file)
os.remove(mesh_file)
domain.default_order = 2
# This test was made before tight_slope_limiters were introduced
# Since were are testing interpolation values this is OK
domain.tight_slope_limiters = 0
# Set some field values
domain.set_quantity('elevation', elevation_function)
domain.set_quantity('friction', 0.03)
domain.set_quantity('xmomentum', 3.0)
domain.set_quantity('ymomentum', 4.0)
######################
# Boundary conditions
B = anuga.Transmissive_boundary(domain)
domain.set_boundary( {'exterior': B})
# This call mangles the stage values.
domain.distribute_to_vertices_and_edges()
domain.set_quantity('stage', 1.0)
domain.set_name('datatest' + str(time.time()))
domain.smooth = True
domain.reduction = mean
self.domain = domain
def _create_mesh_from_regions(bounding_polygon,
boundary_tags,
maximum_triangle_area=None,
filename=None,
interior_regions=None,
interior_holes=None,
hole_tags=None,
poly_geo_reference=None,
mesh_geo_reference=None,
minimum_triangle_angle=28.0,
fail_if_polygons_outside=True,
breaklines=None,
verbose=True,
regionPtArea=None):
"""_create_mesh_from_regions - internal function.
See create_mesh_from_regions for documentation.
"""
# check the segment indexes - throw an error if they are out of bounds
if boundary_tags is not None:
max_points = len(bounding_polygon)
for key in boundary_tags.keys():
if len([x for x in boundary_tags[key] if x > max_points-1]) >= 1:
msg = 'Boundary tag %s has segment out of bounds. '\
%(str(key))
msg += 'Number of points in bounding polygon = %d' % max_points
raise SegmentError(msg)
for i in range(max_points):
found = False
for tag in boundary_tags:
if i in boundary_tags[tag]:
found = True
if found is False:
msg = 'Segment %d was not assigned a boundary_tag.' % i
msg += 'Default tag "exterior" will be assigned to missing segment'
#raise Exception(msg)
# Fixme: Use proper Python warning
if verbose: log.critical('WARNING: %s' % msg)
#In addition I reckon the polygons could be of class Geospatial_data
#(DSG) If polygons were classes caching would break in places.
# Simple check
bounding_polygon = ensure_numeric(bounding_polygon, num.float)
msg = 'Bounding polygon must be a list of points or an Nx2 array'
assert len(bounding_polygon.shape) == 2, msg
assert bounding_polygon.shape[1] == 2, msg
#
if interior_regions is not None:
# Test that all the interior polygons are inside the
# bounding_poly and throw out those that aren't fully
# included. #Note, Both poly's have the same geo_ref,
# therefore don't take into account # geo_ref
polygons_inside_boundary = []
for interior_polygon, res in interior_regions:
indices = inside_polygon(interior_polygon, bounding_polygon,
closed = True, verbose = False)
if len(indices) <> len(interior_polygon):
msg = 'Interior polygon %s is not fully inside'\
%(str(interior_polygon))
msg += ' bounding polygon: %s.' %(str(bounding_polygon))
if fail_if_polygons_outside is True:
raise PolygonError(msg)
else:
msg += ' I will ignore it.'
log.critical(msg)
else:
polygons_inside_boundary.append([interior_polygon, res])
# Record only those that were fully contained
interior_regions = polygons_inside_boundary
# the following segment of code could be used to Test that all the
# interior polygons are inside the bounding_poly... however it might need
# to be change a bit
#
#count = 0
#for i in range(len(interior_regions)):
# region = interior_regions[i]
# interior_polygon = region[0]
# if len(inside_polygon(interior_polygon, bounding_polygon,
# closed = True, verbose = False)) <> len(interior_polygon):
# print 'WARNING: interior polygon %d is outside bounding polygon' %(i)
# count += 1
#if count == 0:
# print 'interior regions OK'
#else:
# print 'check out your interior polygons'
# print 'check %s in production directory' %figname
# import sys; sys.exit()
if interior_holes is not None:
# Test that all the interior polygons are inside the bounding_poly
for interior_polygon in interior_holes:
# Test that we have a polygon
if len(num.array(interior_polygon).flat) < 6:
msg = 'Interior hole polygon %s has too few (<3) points.\n' \
%(str(interior_polygon))
msg = msg + '(Insure that you have specified a LIST of interior hole polygons)'
raise PolygonError(msg)
indices = inside_polygon(interior_polygon, bounding_polygon,
closed = True, verbose = False)
if len(indices) <> len(interior_polygon):
msg = 'Interior polygon %s is outside bounding polygon: %s'\
%(str(interior_polygon), str(bounding_polygon))
raise PolygonError(msg)
# Resolve geo referencing
if mesh_geo_reference is None:
xllcorner = min(bounding_polygon[:,0])
yllcorner = min(bounding_polygon[:,1])
#
if poly_geo_reference is None:
zone = DEFAULT_ZONE
else:
zone = poly_geo_reference.get_zone()
[(xllcorner,yllcorner)] = poly_geo_reference.get_absolute( \
[(xllcorner,yllcorner)])
# create a geo_ref, based on the llc of the bounding_polygon
mesh_geo_reference = Geo_reference(xllcorner = xllcorner,
yllcorner = yllcorner,
zone = zone)
m = Mesh(geo_reference=mesh_geo_reference)
# build a list of discrete segments from the breakline polygons
if breaklines is not None:
points, verts = polylist2points_verts(breaklines)
m.add_points_and_segments(points, verts)
# Do bounding polygon
m.add_region_from_polygon(bounding_polygon,
segment_tags=boundary_tags,
geo_reference=poly_geo_reference)
# Find one point inside region automatically
if interior_regions is not None:
excluded_polygons = []
for polygon, res in interior_regions:
excluded_polygons.append( polygon )
else:
excluded_polygons = None
# Convert bounding poly to absolute values
# this sort of thing can be fixed with the geo_points class
if poly_geo_reference is not None:
bounding_polygon_absolute = \
poly_geo_reference.get_absolute(bounding_polygon)
else:
bounding_polygon_absolute = bounding_polygon
inner_point = point_in_polygon(bounding_polygon_absolute)
inner = m.add_region(inner_point[0], inner_point[1])
inner.setMaxArea(maximum_triangle_area)
# Do interior regions
# if interior_regions is not None:
# for polygon, res in interior_regions:
# m.add_region_from_polygon(polygon,
# geo_reference=poly_geo_reference)
# # convert bounding poly to absolute values
# if poly_geo_reference is not None:
# polygon_absolute = \
# poly_geo_reference.get_absolute(polygon)
# else:
# polygon_absolute = polygon
# inner_point = point_in_polygon(polygon_absolute)
# region = m.add_region(inner_point[0], inner_point[1])
# region.setMaxArea(res)
if interior_regions is not None:
for polygon, res in interior_regions:
m.add_region_from_polygon(polygon,
max_triangle_area=res,
geo_reference=poly_geo_reference)
# Do interior holes
if interior_holes is not None:
for n, polygon in enumerate(interior_holes):
try:
tags = hole_tags[n]
except:
tags = {}
m.add_hole_from_polygon(polygon,
segment_tags=tags,
geo_reference=poly_geo_reference)
# 22/04/2014
# Add user-specified point-based regions with max area
if(regionPtArea is not None):
for i in range(len(regionPtArea)):
inner = m.add_region(regionPtArea[i][0], regionPtArea[i][1])
inner.setMaxArea(regionPtArea[i][2])
# NOTE (Ole): This was moved here as it is annoying if mesh is always
# stored irrespective of whether the computation
# was cached or not. This caused Domain to
# recompute as it has meshfile as a dependency
# Decide whether to store this mesh or return it
if filename is None:
return m
else:
if verbose: log.critical("Generating mesh to file '%s'" % filename)
m.generate_mesh(minimum_triangle_angle=minimum_triangle_angle,
verbose=verbose)
m.export_mesh_file(filename)
return m
def _create_mesh_from_regions(bounding_polygon,
boundary_tags,
maximum_triangle_area=None,
filename=None,
interior_regions=None,
interior_holes=None,
hole_tags=None,
poly_geo_reference=None,
mesh_geo_reference=None,
minimum_triangle_angle=28.0,
fail_if_polygons_outside=True,
breaklines=None,
verbose=True,
regionPtArea=None):
"""_create_mesh_from_regions - internal function.
See create_mesh_from_regions for documentation.
"""
# check the segment indexes - throw an error if they are out of bounds
if boundary_tags is not None:
max_points = len(bounding_polygon)
for key in boundary_tags.keys():
if len([x for x in boundary_tags[key] if x > max_points - 1]) >= 1:
msg = 'Boundary tag %s has segment out of bounds. '\
%(str(key))
msg += 'Number of points in bounding polygon = %d' % max_points
raise SegmentError(msg)
for i in range(max_points):
found = False
for tag in boundary_tags:
if i in boundary_tags[tag]:
found = True
if found is False:
msg = 'Segment %d was not assigned a boundary_tag.' % i
msg += 'Default tag "exterior" will be assigned to missing segment'
#raise Exception(msg)
# Fixme: Use proper Python warning
if verbose: log.critical('WARNING: %s' % msg)
#In addition I reckon the polygons could be of class Geospatial_data
#(DSG) If polygons were classes caching would break in places.
# Simple check
bounding_polygon = ensure_numeric(bounding_polygon, num.float)
msg = 'Bounding polygon must be a list of points or an Nx2 array'
assert len(bounding_polygon.shape) == 2, msg
assert bounding_polygon.shape[1] == 2, msg
#
if interior_regions is not None:
# Test that all the interior polygons are inside the
# bounding_poly and throw out those that aren't fully
# included. #Note, Both poly's have the same geo_ref,
# therefore don't take into account # geo_ref
polygons_inside_boundary = []
for interior_polygon, res in interior_regions:
indices = inside_polygon(interior_polygon,
bounding_polygon,
closed=True,
verbose=False)
if len(indices) <> len(interior_polygon):
msg = 'Interior polygon %s is not fully inside'\
%(str(interior_polygon))
msg += ' bounding polygon: %s.' % (str(bounding_polygon))
if fail_if_polygons_outside is True:
raise PolygonError(msg)
else:
msg += ' I will ignore it.'
log.critical(msg)
else:
polygons_inside_boundary.append([interior_polygon, res])
# Record only those that were fully contained
interior_regions = polygons_inside_boundary
# the following segment of code could be used to Test that all the
# interior polygons are inside the bounding_poly... however it might need
# to be change a bit
#
#count = 0
#for i in range(len(interior_regions)):
# region = interior_regions[i]
# interior_polygon = region[0]
# if len(inside_polygon(interior_polygon, bounding_polygon,
# closed = True, verbose = False)) <> len(interior_polygon):
# print 'WARNING: interior polygon %d is outside bounding polygon' %(i)
# count += 1
#if count == 0:
# print 'interior regions OK'
#else:
# print 'check out your interior polygons'
# print 'check %s in production directory' %figname
# import sys; sys.exit()
if interior_holes is not None:
# Test that all the interior polygons are inside the bounding_poly
for interior_polygon in interior_holes:
# Test that we have a polygon
if len(num.array(interior_polygon).flat) < 6:
msg = 'Interior hole polygon %s has too few (<3) points.\n' \
%(str(interior_polygon))
msg = msg + '(Insure that you have specified a LIST of interior hole polygons)'
raise PolygonError(msg)
indices = inside_polygon(interior_polygon,
bounding_polygon,
closed=True,
verbose=False)
if len(indices) <> len(interior_polygon):
msg = 'Interior polygon %s is outside bounding polygon: %s'\
%(str(interior_polygon), str(bounding_polygon))
raise PolygonError(msg)
# Resolve geo referencing
if mesh_geo_reference is None:
xllcorner = min(bounding_polygon[:, 0])
yllcorner = min(bounding_polygon[:, 1])
#
if poly_geo_reference is None:
zone = DEFAULT_ZONE
else:
zone = poly_geo_reference.get_zone()
[(xllcorner,yllcorner)] = poly_geo_reference.get_absolute( \
[(xllcorner,yllcorner)])
# create a geo_ref, based on the llc of the bounding_polygon
mesh_geo_reference = Geo_reference(xllcorner=xllcorner,
yllcorner=yllcorner,
zone=zone)
m = Mesh(geo_reference=mesh_geo_reference)
# build a list of discrete segments from the breakline polygons
if breaklines is not None:
points, verts = polylist2points_verts(breaklines)
m.add_points_and_segments(points, verts)
# Do bounding polygon
m.add_region_from_polygon(bounding_polygon,
segment_tags=boundary_tags,
geo_reference=poly_geo_reference)
# Find one point inside region automatically
if interior_regions is not None:
excluded_polygons = []
for polygon, res in interior_regions:
excluded_polygons.append(polygon)
else:
excluded_polygons = None
# Convert bounding poly to absolute values
# this sort of thing can be fixed with the geo_points class
if poly_geo_reference is not None:
bounding_polygon_absolute = \
poly_geo_reference.get_absolute(bounding_polygon)
else:
bounding_polygon_absolute = bounding_polygon
inner_point = point_in_polygon(bounding_polygon_absolute)
inner = m.add_region(inner_point[0], inner_point[1])
inner.setMaxArea(maximum_triangle_area)
# Do interior regions
# if interior_regions is not None:
# for polygon, res in interior_regions:
# m.add_region_from_polygon(polygon,
# geo_reference=poly_geo_reference)
# # convert bounding poly to absolute values
# if poly_geo_reference is not None:
# polygon_absolute = \
# poly_geo_reference.get_absolute(polygon)
# else:
# polygon_absolute = polygon
# inner_point = point_in_polygon(polygon_absolute)
# region = m.add_region(inner_point[0], inner_point[1])
# region.setMaxArea(res)
if interior_regions is not None:
for polygon, res in interior_regions:
m.add_region_from_polygon(polygon,
max_triangle_area=res,
geo_reference=poly_geo_reference)
# Do interior holes
if interior_holes is not None:
for n, polygon in enumerate(interior_holes):
try:
tags = hole_tags[n]
except:
tags = {}
m.add_hole_from_polygon(polygon,
segment_tags=tags,
geo_reference=poly_geo_reference)
# 22/04/2014
# Add user-specified point-based regions with max area
if (regionPtArea is not None):
for i in range(len(regionPtArea)):
inner = m.add_region(regionPtArea[i][0], regionPtArea[i][1])
inner.setMaxArea(regionPtArea[i][2])
# NOTE (Ole): This was moved here as it is annoying if mesh is always
# stored irrespective of whether the computation
# was cached or not. This caused Domain to
# recompute as it has meshfile as a dependency
# Decide whether to store this mesh or return it
if filename is None:
return m
else:
if verbose: log.critical("Generating mesh to file '%s'" % filename)
m.generate_mesh(minimum_triangle_angle=minimum_triangle_angle,
verbose=verbose)
m.export_mesh_file(filename)
return m
def setUp(self):
# print "****set up****"
# Create an sww file
# Set up an sww that has a geo ref.
# have it cover an area in Australia. 'gong maybe
# Don't have many triangles though!
# Site Name: GDA-MGA: (UTM with GRS80 ellipsoid)
# Zone: 56
# Easting: 222908.705 Northing: 6233785.284
# Latitude: -34 0 ' 0.00000 '' Longitude: 150 0 ' 0.00000 ''
# Grid Convergence: -1 40 ' 43.13 '' Point Scale: 1.00054660
# geo-ref
# Zone: 56
# Easting: 220000 Northing: 6230000
# have a big area covered.
mesh_file = tempfile.mktemp(".tsh")
points_lat_long = [[-33, 152], [-35, 152], [-35, 150], [-33, 150]]
spat = Geospatial_data(data_points=points_lat_long, points_are_lats_longs=True)
points_ab = spat.get_data_points(absolute=True)
geo = Geo_reference(56, 400000, 6000000)
spat.set_geo_reference(geo)
m = Mesh()
m.add_vertices(spat)
m.auto_segment()
m.generate_mesh(verbose=False)
m.export_mesh_file(mesh_file)
# Create shallow water domain
domain = Domain(mesh_file)
os.remove(mesh_file)
domain.default_order = 2
# Set some field values
# domain.set_quantity('stage', 1.0)
domain.set_quantity("elevation", -0.5)
domain.set_quantity("friction", 0.03)
######################
# Boundary conditions
B = Transmissive_boundary(domain)
domain.set_boundary({"exterior": B})
######################
# Initial condition - with jumps
bed = domain.quantities["elevation"].vertex_values
stage = num.zeros(bed.shape, num.float)
h = 0.3
for i in range(stage.shape[0]):
if i % 2 == 0:
stage[i, :] = bed[i, :] + h
else:
stage[i, :] = bed[i, :]
domain.set_quantity("stage", stage)
domain.set_quantity("xmomentum", stage * 22.0)
domain.set_quantity("ymomentum", stage * 55.0)
domain.distribute_to_vertices_and_edges()
self.domain = domain
C = domain.get_vertex_coordinates()
self.X = C[:, 0:6:2].copy()
self.Y = C[:, 1:6:2].copy()
self.F = bed
# sww_file = tempfile.mktemp("")
self.domain.set_name("tid_P0")
self.domain.format = "sww"
self.domain.smooth = True
self.domain.reduction = mean
sww = SWW_file(self.domain)
sww.store_connectivity()
sww.store_timestep()
self.domain.time = 2.0
sww.store_timestep()
self.sww = sww # so it can be deleted
# Create another sww file
mesh_file = tempfile.mktemp(".tsh")
points_lat_long = [[-35, 152], [-36, 152], [-36, 150], [-35, 150]]
spat = Geospatial_data(data_points=points_lat_long, points_are_lats_longs=True)
points_ab = spat.get_data_points(absolute=True)
geo = Geo_reference(56, 400000, 6000000)
spat.set_geo_reference(geo)
m = Mesh()
m.add_vertices(spat)
m.auto_segment()
m.generate_mesh(verbose=False)
m.export_mesh_file(mesh_file)
# Create shallow water domain
domain = Domain(mesh_file)
os.remove(mesh_file)
domain.default_order = 2
# Set some field values
# domain.set_quantity('stage', 1.0)
domain.set_quantity("elevation", -40)
domain.set_quantity("friction", 0.03)
######################
# Boundary conditions
B = Transmissive_boundary(domain)
domain.set_boundary({"exterior": B})
######################
# Initial condition - with jumps
bed = domain.quantities["elevation"].vertex_values
stage = num.zeros(bed.shape, num.float)
h = 30.0
for i in range(stage.shape[0]):
if i % 2 == 0:
stage[i, :] = bed[i, :] + h
else:
stage[i, :] = bed[i, :]
domain.set_quantity("stage", stage)
domain.set_quantity("xmomentum", stage * 22.0)
domain.set_quantity("ymomentum", stage * 55.0)
domain.distribute_to_vertices_and_edges()
self.domain2 = domain
C = domain.get_vertex_coordinates()
self.X2 = C[:, 0:6:2].copy()
self.Y2 = C[:, 1:6:2].copy()
self.F2 = bed
# sww_file = tempfile.mktemp("")
domain.set_name("tid_P1")
domain.format = "sww"
domain.smooth = True
domain.reduction = mean
sww = SWW_file(domain)
sww.store_connectivity()
sww.store_timestep()
domain.time = 2.0
sww.store_timestep()
self.swwII = sww # so it can be deleted
# print "sww.filename", sww.filename
# Create a csv file
self.csv_file = tempfile.mktemp(".csv")
fd = open(self.csv_file, "wb")
writer = csv.writer(fd)
writer.writerow(
["LONGITUDE", "LATITUDE", STR_VALUE_LABEL, CONT_VALUE_LABEL, "ROOF_TYPE", WALL_TYPE_LABEL, SHORE_DIST_LABEL]
)
writer.writerow(["151.5", "-34", "199770", "130000", "Metal", "Timber", 20.0])
writer.writerow(["151", "-34.5", "150000", "76000", "Metal", "Double Brick", 200.0])
writer.writerow(["151", "-34.25", "150000", "76000", "Metal", "Brick Veneer", 200.0])
fd.close()
# Create a csv file
self.csv_fileII = tempfile.mktemp(".csv")
fd = open(self.csv_fileII, "wb")
writer = csv.writer(fd)
writer.writerow(
["LONGITUDE", "LATITUDE", STR_VALUE_LABEL, CONT_VALUE_LABEL, "ROOF_TYPE", WALL_TYPE_LABEL, SHORE_DIST_LABEL]
)
writer.writerow(["151.5", "-34", "199770", "130000", "Metal", "Timber", 20.0])
writer.writerow(["151", "-34.5", "150000", "76000", "Metal", "Double Brick", 200.0])
writer.writerow(["151", "-34.25", "150000", "76000", "Metal", "Brick Veneer", 200.0])
fd.close()
def test_inundation_damage_list(self):
# create mesh
mesh_file = tempfile.mktemp(".tsh")
points = [[0.0, 0.0], [6.0, 0.0], [6.0, 6.0], [0.0, 6.0]]
m = Mesh()
m.add_vertices(points)
m.auto_segment()
m.generate_mesh(verbose=False)
m.export_mesh_file(mesh_file)
# Create shallow water domain
domain = Domain(mesh_file)
os.remove(mesh_file)
domain.default_order = 2
# Set some field values
domain.set_quantity("elevation", elevation_function)
domain.set_quantity("friction", 0.03)
domain.set_quantity("xmomentum", 22.0)
domain.set_quantity("ymomentum", 55.0)
######################
# Boundary conditions
B = Transmissive_boundary(domain)
domain.set_boundary({"exterior": B})
# This call mangles the stage values.
domain.distribute_to_vertices_and_edges()
domain.set_quantity("stage", 0.3)
# sww_file = tempfile.mktemp("")
domain.set_name("datatest" + str(time.time()))
domain.format = "sww"
domain.smooth = True
domain.reduction = mean
sww = SWW_file(domain)
sww.store_connectivity()
sww.store_timestep()
domain.set_quantity("stage", -0.3)
domain.time = 2.0
sww.store_timestep()
# Create a csv file
csv_file = tempfile.mktemp(".csv")
fd = open(csv_file, "wb")
writer = csv.writer(fd)
writer.writerow(["x", "y", STR_VALUE_LABEL, CONT_VALUE_LABEL, "ROOF_TYPE", WALL_TYPE_LABEL, SHORE_DIST_LABEL])
writer.writerow([5.5, 0.5, "10", "130000", "Metal", "Timber", 20])
writer.writerow([4.5, 1.0, "150", "76000", "Metal", "Double Brick", 20])
writer.writerow([0.1, 1.5, "100", "76000", "Metal", "Brick Veneer", 300])
writer.writerow([6.1, 1.5, "100", "76000", "Metal", "Brick Veneer", 300])
fd.close()
extension = ".csv"
csv_fileII = tempfile.mktemp(extension)
fd = open(csv_fileII, "wb")
writer = csv.writer(fd)
writer.writerow(["x", "y", STR_VALUE_LABEL, CONT_VALUE_LABEL, "ROOF_TYPE", WALL_TYPE_LABEL, SHORE_DIST_LABEL])
writer.writerow([5.5, 0.5, "10", "130000", "Metal", "Timber", 20])
writer.writerow([4.5, 1.0, "150", "76000", "Metal", "Double Brick", 20])
writer.writerow([0.1, 1.5, "100", "76000", "Metal", "Brick Veneer", 300])
writer.writerow([6.1, 1.5, "100", "76000", "Metal", "Brick Veneer", 300])
fd.close()
sww_file = domain.get_name() + "." + domain.format
# print "sww_file",sww_file
marker = "_gosh"
inundation_damage(sww_file, [csv_file, csv_fileII], exposure_file_out_marker=marker, verbose=False)
# Test one file
csv_handle = Exposure(csv_file[:-4] + marker + extension)
struct_loss = csv_handle.get_column(EventDamageModel.STRUCT_LOSS_TITLE)
# print "struct_loss",struct_loss
struct_loss = [float(x) for x in struct_loss]
# pprint(struct_loss)
assert num.allclose(struct_loss, [10.0, 150.0, 66.55333347876866, 0.0])
depth = csv_handle.get_column(EventDamageModel.MAX_DEPTH_TITLE)
# print "depth",depth
depth = [float(x) for x in depth]
assert num.allclose(depth, [3.000000011920929, 2.9166666785875957, 2.2666666785875957, -0.3])
# Test another file
csv_handle = Exposure(csv_fileII[:-4] + marker + extension)
struct_loss = csv_handle.get_column(EventDamageModel.STRUCT_LOSS_TITLE)
# print "struct_loss",struct_loss
struct_loss = [float(x) for x in struct_loss]
# pprint(struct_loss)
assert num.allclose(struct_loss, [10.0, 150.0, 66.553333478768664, 0.0])
depth = csv_handle.get_column(EventDamageModel.MAX_DEPTH_TITLE)
# print "depth",depth
depth = [float(x) for x in depth]
assert num.allclose(depth, [3.000000011920929, 2.9166666785875957, 2.2666666785875957, -0.3])
os.remove(sww.filename)
os.remove(csv_file)
os.remove(csv_fileII)
def setUp(self):
#print "****set up****"
# Create an sww file
# Set up an sww that has a geo ref.
# have it cover an area in Australia. 'gong maybe
#Don't have many triangles though!
#Site Name: GDA-MGA: (UTM with GRS80 ellipsoid)
#Zone: 56
#Easting: 222908.705 Northing: 6233785.284
#Latitude: -34 0 ' 0.00000 '' Longitude: 150 0 ' 0.00000 ''
#Grid Convergence: -1 40 ' 43.13 '' Point Scale: 1.00054660
#geo-ref
#Zone: 56
#Easting: 220000 Northing: 6230000
#have a big area covered.
mesh_file = tempfile.mktemp(".tsh")
points_lat_long = [[-33,152],[-35,152],[-35,150],[-33,150]]
spat = Geospatial_data(data_points=points_lat_long,
points_are_lats_longs=True)
points_ab = spat.get_data_points( absolute = True)
geo = Geo_reference(56,400000,6000000)
spat.set_geo_reference(geo)
m = Mesh()
m.add_vertices(spat)
m.auto_segment()
m.generate_mesh(verbose=False)
m.export_mesh_file(mesh_file)
#Create shallow water domain
domain = Domain(mesh_file)
os.remove(mesh_file)
domain.default_order=2
#Set some field values
#domain.set_quantity('stage', 1.0)
domain.set_quantity('elevation', -0.5)
domain.set_quantity('friction', 0.03)
######################
# Boundary conditions
B = Transmissive_boundary(domain)
domain.set_boundary( {'exterior': B})
######################
#Initial condition - with jumps
bed = domain.quantities['elevation'].vertex_values
stage = num.zeros(bed.shape, num.float)
h = 0.3
for i in range(stage.shape[0]):
if i % 2 == 0:
stage[i,:] = bed[i,:] + h
else:
stage[i,:] = bed[i,:]
domain.set_quantity('stage', stage)
domain.set_quantity('xmomentum', stage*22.0)
domain.set_quantity('ymomentum', stage*55.0)
domain.distribute_to_vertices_and_edges()
self.domain = domain
C = domain.get_vertex_coordinates()
self.X = C[:,0:6:2].copy()
self.Y = C[:,1:6:2].copy()
self.F = bed
#sww_file = tempfile.mktemp("")
self.domain.set_name('tid_P0')
self.domain.format = 'sww'
self.domain.smooth = True
self.domain.reduction = mean
sww = SWW_file(self.domain)
sww.store_connectivity()
sww.store_timestep()
self.domain.time = 2.
sww.store_timestep()
self.sww = sww # so it can be deleted
#Create another sww file
mesh_file = tempfile.mktemp(".tsh")
points_lat_long = [[-35,152],[-36,152],[-36,150],[-35,150]]
spat = Geospatial_data(data_points=points_lat_long,
points_are_lats_longs=True)
points_ab = spat.get_data_points( absolute = True)
geo = Geo_reference(56,400000,6000000)
spat.set_geo_reference(geo)
m = Mesh()
m.add_vertices(spat)
m.auto_segment()
m.generate_mesh(verbose=False)
m.export_mesh_file(mesh_file)
#Create shallow water domain
domain = Domain(mesh_file)
os.remove(mesh_file)
domain.default_order=2
#Set some field values
#domain.set_quantity('stage', 1.0)
domain.set_quantity('elevation', -40)
domain.set_quantity('friction', 0.03)
######################
# Boundary conditions
B = Transmissive_boundary(domain)
domain.set_boundary( {'exterior': B})
######################
#Initial condition - with jumps
bed = domain.quantities['elevation'].vertex_values
stage = num.zeros(bed.shape, num.float)
h = 30.
for i in range(stage.shape[0]):
if i % 2 == 0:
stage[i,:] = bed[i,:] + h
else:
stage[i,:] = bed[i,:]
domain.set_quantity('stage', stage)
domain.set_quantity('xmomentum', stage*22.0)
domain.set_quantity('ymomentum', stage*55.0)
domain.distribute_to_vertices_and_edges()
self.domain2 = domain
C = domain.get_vertex_coordinates()
self.X2 = C[:,0:6:2].copy()
self.Y2 = C[:,1:6:2].copy()
self.F2 = bed
#sww_file = tempfile.mktemp("")
domain.set_name('tid_P1')
domain.format = 'sww'
domain.smooth = True
domain.reduction = mean
sww = SWW_file(domain)
sww.store_connectivity()
sww.store_timestep()
domain.time = 2.
sww.store_timestep()
self.swwII = sww # so it can be deleted
# print "sww.filename", sww.filename
#Create a csv file
self.csv_file = tempfile.mktemp(".csv")
fd = open(self.csv_file,'wb')
writer = csv.writer(fd)
writer.writerow(['LONGITUDE','LATITUDE',STR_VALUE_LABEL,CONT_VALUE_LABEL,'ROOF_TYPE',WALL_TYPE_LABEL, SHORE_DIST_LABEL])
writer.writerow(['151.5','-34','199770','130000','Metal','Timber',20.])
writer.writerow(['151','-34.5','150000','76000','Metal','Double Brick',200.])
writer.writerow(['151','-34.25','150000','76000','Metal','Brick Veneer',200.])
fd.close()
#Create a csv file
self.csv_fileII = tempfile.mktemp(".csv")
fd = open(self.csv_fileII,'wb')
writer = csv.writer(fd)
writer.writerow(['LONGITUDE','LATITUDE',STR_VALUE_LABEL,CONT_VALUE_LABEL,'ROOF_TYPE',WALL_TYPE_LABEL, SHORE_DIST_LABEL])
writer.writerow(['151.5','-34','199770','130000','Metal','Timber',20.])
writer.writerow(['151','-34.5','150000','76000','Metal','Double Brick',200.])
writer.writerow(['151','-34.25','150000','76000','Metal','Brick Veneer',200.])
fd.close()
def test_inundation_damage_list(self):
# create mesh
mesh_file = tempfile.mktemp(".tsh")
points = [[0.0,0.0],[6.0,0.0],[6.0,6.0],[0.0,6.0]]
m = Mesh()
m.add_vertices(points)
m.auto_segment()
m.generate_mesh(verbose=False)
m.export_mesh_file(mesh_file)
#Create shallow water domain
domain = Domain(mesh_file)
os.remove(mesh_file)
domain.default_order=2
#Set some field values
domain.set_quantity('elevation', elevation_function)
domain.set_quantity('friction', 0.03)
domain.set_quantity('xmomentum', 22.0)
domain.set_quantity('ymomentum', 55.0)
######################
# Boundary conditions
B = Transmissive_boundary(domain)
domain.set_boundary( {'exterior': B})
# This call mangles the stage values.
domain.distribute_to_vertices_and_edges()
domain.set_quantity('stage', 0.3)
#sww_file = tempfile.mktemp("")
domain.set_name('datatest' + str(time.time()))
domain.format = 'sww'
domain.smooth = True
domain.reduction = mean
sww = SWW_file(domain)
sww.store_connectivity()
sww.store_timestep()
domain.set_quantity('stage', -0.3)
domain.time = 2.
sww.store_timestep()
#Create a csv file
csv_file = tempfile.mktemp(".csv")
fd = open(csv_file,'wb')
writer = csv.writer(fd)
writer.writerow(['x','y',STR_VALUE_LABEL,CONT_VALUE_LABEL,'ROOF_TYPE',WALL_TYPE_LABEL, SHORE_DIST_LABEL])
writer.writerow([5.5,0.5,'10','130000','Metal','Timber',20])
writer.writerow([4.5,1.0,'150','76000','Metal','Double Brick',20])
writer.writerow([0.1,1.5,'100','76000','Metal','Brick Veneer',300])
writer.writerow([6.1,1.5,'100','76000','Metal','Brick Veneer',300])
fd.close()
extension = ".csv"
csv_fileII = tempfile.mktemp(extension)
fd = open(csv_fileII,'wb')
writer = csv.writer(fd)
writer.writerow(['x','y',STR_VALUE_LABEL,CONT_VALUE_LABEL,'ROOF_TYPE',WALL_TYPE_LABEL, SHORE_DIST_LABEL])
writer.writerow([5.5,0.5,'10','130000','Metal','Timber',20])
writer.writerow([4.5,1.0,'150','76000','Metal','Double Brick',20])
writer.writerow([0.1,1.5,'100','76000','Metal','Brick Veneer',300])
writer.writerow([6.1,1.5,'100','76000','Metal','Brick Veneer',300])
fd.close()
sww_file = domain.get_name() + "." + domain.format
#print "sww_file",sww_file
marker='_gosh'
inundation_damage(sww_file, [csv_file, csv_fileII],
exposure_file_out_marker=marker,
verbose=False)
# Test one file
csv_handle = Exposure(csv_file[:-4]+marker+extension)
struct_loss = csv_handle.get_column(EventDamageModel.STRUCT_LOSS_TITLE)
#print "struct_loss",struct_loss
struct_loss = [float(x) for x in struct_loss]
#pprint(struct_loss)
assert num.allclose(struct_loss,[10.0, 150.0, 66.55333347876866, 0.0])
depth = csv_handle.get_column(EventDamageModel.MAX_DEPTH_TITLE)
#print "depth",depth
depth = [float(x) for x in depth]
assert num.allclose(depth, [3.000000011920929, 2.9166666785875957, 2.2666666785875957, -0.3])
# Test another file
csv_handle = Exposure(csv_fileII[:-4]+marker+extension)
struct_loss = csv_handle.get_column(EventDamageModel.STRUCT_LOSS_TITLE)
#print "struct_loss",struct_loss
struct_loss = [float(x) for x in struct_loss]
#pprint(struct_loss)
assert num.allclose(struct_loss, [10.0, 150.0, 66.553333478768664, 0.0])
depth = csv_handle.get_column(EventDamageModel.MAX_DEPTH_TITLE)
#print "depth",depth
depth = [float(x) for x in depth]
assert num.allclose(depth,[3.000000011920929, 2.9166666785875957, 2.2666666785875957, -0.3])
os.remove(sww.filename)
os.remove(csv_file)
os.remove(csv_fileII)
def test_import_ungenerate_file_different_region_tags(self):
fileName = tempfile.mktemp(".txt")
file = open(fileName,"w")
file.write(" 1 ?? ??\n\
10.0 10.0\n\
11.0 10.0\n\
11.0 11.0\n\
10.0 11.0\n\
10.0 10.0\n\
END\n\
2 ?? ??\n\
20.0 20.0\n\
20.0 30.0\n\
30.0 30.0\n\
END\n\
END\n")
file.close()
a = Vertex (0.0, 0.0) #, attributes = [1.1])
b = Vertex (0.0, 40.0) #, attributes = [1.2])
c = Vertex (40.0,40.0) #, attributes = [1.3])
d = Vertex (40.0,0.0) #, attributes = [1.4])
s1 = Segment(a,b)
s2 = Segment(b,c)
s3 = Segment(c,d)
s4 = Segment(d,a)
m = Mesh(userVertices=[a,b,c,d], userSegments=[s1,s2,s3,s4])
dict = load_ungenerate(fileName)
#os.remove(fileName)
tag = "DSG"
Segment.set_default_tag(tag)
m.addVertsSegs(dict)
self.assertTrue(len(m.userSegments) ==11,
'Wrong segment list length.')
self.assertTrue(len(m.userVertices) == 11,
'Wrong vertex list length.')
# Test the method
a = Vertex (0.0, 0.0) #, attributes = [1.1])
b = Vertex (0.0, 40.0) #, attributes = [1.2])
c = Vertex (40.0,40.0) #, attributes = [1.3])
d = Vertex (40.0,0.0) #, attributes = [1.4])
s1 = Segment(a,b)
s2 = Segment(b,c)
s3 = Segment(c,d)
s4 = Segment(d,a)
m = Mesh(userVertices=[a,b,c,d], userSegments=[s1,s2,s3,s4])
tag = "DSG"
initial_tag = "PIG"
Segment.set_default_tag(initial_tag)
m.import_ungenerate_file(fileName, tag=tag, region_tag=["swamp","coastalp"])
os.remove(fileName)
self.assertTrue(Segment.get_default_tag() == initial_tag,
'Wrong segment list length.')
m.export_mesh_file("swamp.tsh")
#print "m.userSegments",m.userSegments
self.assertTrue(len(m.userSegments) ==11,
'Wrong segment list length.')
self.assertTrue(len(m.userVertices) == 11,
'Wrong vertex list length.')
self.assertTrue(len(m.regions) == 2,
'Wrong regions list length.')
self.assertTrue(m.regions[0].getTag() == "swamp",
'Wrong regions tag.')
self.assertTrue(m.regions[1].getTag() == "coastalp",
'Wrong regions 1 tag.')
# have to reset this , since it's a class attribute
Segment.set_default_tag("")
def test_import_ungenerate_file_different_region_tags(self):
fileName = tempfile.mktemp(".txt")
file = open(fileName, "w")
file.write(" 1 ?? ??\n\
10.0 10.0\n\
11.0 10.0\n\
11.0 11.0\n\
10.0 11.0\n\
10.0 10.0\n\
END\n\
2 ?? ??\n\
20.0 20.0\n\
20.0 30.0\n\
30.0 30.0\n\
END\n\
END\n")
file.close()
a = Vertex(0.0, 0.0) #, attributes = [1.1])
b = Vertex(0.0, 40.0) #, attributes = [1.2])
c = Vertex(40.0, 40.0) #, attributes = [1.3])
d = Vertex(40.0, 0.0) #, attributes = [1.4])
s1 = Segment(a, b)
s2 = Segment(b, c)
s3 = Segment(c, d)
s4 = Segment(d, a)
m = Mesh(userVertices=[a, b, c, d], userSegments=[s1, s2, s3, s4])
dict = load_ungenerate(fileName)
#os.remove(fileName)
tag = "DSG"
Segment.set_default_tag(tag)
m.addVertsSegs(dict)
self.assertTrue(
len(m.userSegments) == 11, 'Wrong segment list length.')
self.assertTrue(len(m.userVertices) == 11, 'Wrong vertex list length.')
# Test the method
a = Vertex(0.0, 0.0) #, attributes = [1.1])
b = Vertex(0.0, 40.0) #, attributes = [1.2])
c = Vertex(40.0, 40.0) #, attributes = [1.3])
d = Vertex(40.0, 0.0) #, attributes = [1.4])
s1 = Segment(a, b)
s2 = Segment(b, c)
s3 = Segment(c, d)
s4 = Segment(d, a)
m = Mesh(userVertices=[a, b, c, d], userSegments=[s1, s2, s3, s4])
tag = "DSG"
initial_tag = "PIG"
Segment.set_default_tag(initial_tag)
m.import_ungenerate_file(fileName,
tag=tag,
region_tag=["swamp", "coastalp"])
os.remove(fileName)
self.assertTrue(Segment.get_default_tag() == initial_tag,
'Wrong segment list length.')
m.export_mesh_file("swamp.tsh")
#print "m.userSegments",m.userSegments
self.assertTrue(
len(m.userSegments) == 11, 'Wrong segment list length.')
self.assertTrue(len(m.userVertices) == 11, 'Wrong vertex list length.')
self.assertTrue(len(m.regions) == 2, 'Wrong regions list length.')
self.assertTrue(m.regions[0].getTag() == "swamp", 'Wrong regions tag.')
self.assertTrue(m.regions[1].getTag() == "coastalp",
'Wrong regions 1 tag.')
# have to reset this , since it's a class attribute
Segment.set_default_tag("")
