def test_create_mesh_from_regions_check_segs(self):
'''Test that create_mesh_from_regions fails
when an interior region is outside bounding polygon.
'''
# These are the absolute values
min_x = 10
min_y = 88
polygon = [[min_x,min_y], [1000,100], [1000,1000], [100,1000]]
boundary_tags = {'walls': [0,1,3], 'bom': [2]}
# This one is inside bounding polygon - should pass
inner_polygon = [[800,400], [900,500], [800,600]]
interior_regions = [(inner_polygon, 5)]
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions)
boundary_tags = {'walls': [0,1,3,4], 'bom': [2]}
try:
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions)
except:
pass
else:
msg = 'Segment out of bounds not caught '
raise Exception, msg
def test_create_mesh_from_regions5(self):
file_name = tempfile.mktemp('.tsh')
# These are the absolute values
density_outer = 10000000
min_outer = 0
max_outer = 1000
polygon_outer = [[min_outer,min_outer], [max_outer,min_outer],
[max_outer,max_outer], [min_outer,max_outer]]
density_inner1 = 1000
inner_buffer = 100
min_inner1 = min_outer + inner_buffer
max_inner1 = max_outer - inner_buffer
inner1_polygon = [[min_inner1,min_inner1], [max_inner1,min_inner1],
[max_inner1,max_inner1], [min_inner1,max_inner1]]
boundary_tags = {'walls': [0,1], 'bom': [2,3]}
interior_regions = [(inner1_polygon, density_inner1)]
create_mesh_from_regions(polygon_outer,
boundary_tags,
density_outer,
interior_regions=interior_regions,
filename=file_name,
verbose=False)
m = importMeshFromFile(file_name)
self.assertTrue(len(m.getTriangulation()) <= 2000,
'Test mesh interface failed!')
self.assertTrue(len(m.getTriangulation()) >= 900,
'Test mesh interface failed!')
os.remove(file_name)
def test_slide_tsunami_domain(self):
if anuga_installed:
pass
else:
print 'Note: test_slide_tsunami_domain not tested as ANUGA '\
'is not installed'
return
length = 600.0
dep = 150.0
th = 9.0
thk = 15.0
wid = 340.0
kappa = 3.0
kappad = 0.8
x0 = 100000.
y0 = x0
from anuga.pmesh.mesh_interface import create_mesh_from_regions
polygon = [[0,0],[200000,0],[200000,200000],[0,200000]]
create_mesh_from_regions(polygon,
{'e0': [0], 'e1': [1], 'e2': [2], 'e3': [3]},
maximum_triangle_area=5000000000,
filename='test.msh',
verbose = False)
domain = Domain('test.msh', use_cache = True, verbose = False)
slide = slide_tsunami(length, dep, th, x0, y0, \
wid, thk, kappa, kappad, \
domain=domain,verbose=False)
domain.set_quantity('stage', slide)
stage = domain.get_quantity('stage')
w = stage.get_values()
## check = [[-0.0 -0.0 -0.0],
## [-.189709745 -517.877716 -0.0],
## [-0.0 -0.0 -2.7695931e-08],
## [-0.0 -2.7695931e-08 -1.897097e-01]
## [-0.0 -517.877716 -0.0],
## [-0.0 -0.0 -0.0],
## [-0.0 -0.0 -0.0],
## [-0.0 -0.0 -0.0]]
assert num.allclose(num.min(w), -517.877771593)
assert num.allclose(num.max(w), 0.0)
assert num.allclose(slide.a3D, 518.38797486)
def test_create_mesh_with_segments_out_of_bounds(self):
"""Test that create_mesh_from_regions fails when a segment is out of bounds.
"""
# These are the absolute values
min_x = 10
min_y = 88
polygon = [[min_x,min_y],[1000,100],[1000,1000],[100,1000]]
boundary_tags = {'walls': [0,1], 'bom':[2,3], 'out': [5]}
# This one is inside bounding polygon - should pass
inner_polygon = [[800,400],[900,500],[800,600]]
interior_regions = [(inner_polygon, 5)]
try:
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions)
except:
pass
else:
msg = 'Tags are listed repeatedly, but create mesh from regions '
msg += 'does not cause an Exception to be raised'
raise Exception, msg
def test_create_mesh_with_interior_holes_and_tags(self):
# These are the absolute values
polygon = [[100,100], [1000,100], [1000,1000], [100,1000]]
interior_poly1 = [[101,101],[200,200], [101,200]]
interior_poly2 = [[300,300],[500,500], [400,200]]
boundary_tags = {'walls': [0,1], 'bom': [2,3]}
# This should work with one hole
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_holes=[interior_poly1],
hole_tags=[{'edge0' : [0], 'edge1': [1], 'edge2': [2]}])
self.assertTrue(len(m.getUserSegments()) == 7, 'FAILED!')
self.assertTrue(len(m.userVertices) == 7, 'FAILED!')
m.generate_mesh()
tags_list = m.getMeshSegmentTags()
assert len([x for x in tags_list if x == 'edge0']) == 7
assert len([x for x in tags_list if x == 'edge1']) == 6
assert len([x for x in tags_list if x == 'edge2']) == 54
def create_mesh(elevation_in_mesh=False, verbose=False):
# Prepare time boundary
prepare_timeboundary(project.boundary_filename, verbose)
meshname = project.mesh_filename + '.msh'
m = create_mesh_from_regions(bounding_polygon,
boundary_tags={'wall': [0, 1, 3],
'wave': [2]},
maximum_triangle_area=0.1*base_resolution,
interior_regions=interior_regions,
filename=project.mesh_filename,
use_cache=False,
verbose=verbose)
if elevation_in_mesh is True:
from anuga.fit_interpolate.fit import fit_to_mesh_file
if verbose: print 'Reading xya from zip'
import zipfile as zf
zf.ZipFile(project.bathymetry_filename_stem+'.zip').\
extract(project.bathymetry_filename_stem+'.xya')
if verbose: print 'Reading pts from xya'
anuga.xya2pts(project.bathymetry_filename_stem+'.xya',\
verbose = verbose)
fit_to_mesh_file(project.mesh_filename, project.bathymetry_filename,
project.mesh_filename, verbose = verbose)
def _create_domain_from_regions_sed(bounding_polygon,
boundary_tags,
maximum_triangle_area=None,
mesh_filename=None,
interior_regions=None,
interior_holes=None,
hole_tags=None,
poly_geo_reference=None,
mesh_geo_reference=None,
minimum_triangle_angle=28.0,
conserved_quantities=None,
evolved_quantities=None,
other_quantities=None,
fail_if_polygons_outside=True,
verbose=True):
"""_create_domain_from_regions_sed - internal function.
See create_domain_from_regions in anuga/__init__.py for documentation.
"""
from anuga.pmesh.mesh_interface import create_mesh_from_regions
create_mesh_from_regions(bounding_polygon,
boundary_tags,
maximum_triangle_area=maximum_triangle_area,
interior_regions=interior_regions,
filename=mesh_filename,
interior_holes=interior_holes,
hole_tags=hole_tags,
poly_geo_reference=poly_geo_reference,
mesh_geo_reference=mesh_geo_reference,
minimum_triangle_angle=minimum_triangle_angle,
fail_if_polygons_outside=fail_if_polygons_outside,
use_cache=False,
verbose=verbose)
domain = Domain(mesh_filename,
conserved_quantities=conserved_quantities,
evolved_quantities=evolved_quantities,
other_quantities=other_quantities,
use_cache=False,
verbose=verbose)
return domain
def test_create_mesh_from_regions7(self):
file_name = tempfile.mktemp('.tsh')
# These are the absolute values
density_outer = 1001
min_outer = 0
max_outer = 1000
polygon_outer = [[min_outer,min_outer], [max_outer,min_outer],
[max_outer,max_outer], [min_outer,max_outer]]
delta = 10
density_inner1 = 100000000
min_inner1 = min_outer + delta
max_inner1 = max_outer - delta
inner1_polygon = [[min_inner1,min_inner1], [max_inner1,min_inner1],
[max_inner1,max_inner1], [min_inner1,max_inner1]]
density_inner2 = 1000
min_inner2 = min_outer + 2*delta
max_inner2 = max_outer - 2*delta
inner2_polygon = [[min_inner2,min_inner2], [max_inner2,min_inner2],
[max_inner2,max_inner2], [min_inner2,max_inner2]]
boundary_tags = {'walls': [0,1], 'bom': [2,3]}
# Note the list order is important
# The last region added will be the region triangle uses,
# if two regions points are in the same bounded area.
interior_regions = [(inner2_polygon, density_inner2),
(inner1_polygon, density_inner1)]
create_mesh_from_regions(polygon_outer,
boundary_tags,
density_outer,
interior_regions=interior_regions,
filename=file_name,
verbose=False)
m = importMeshFromFile(file_name)
self.assertTrue(len(m.getTriangulation()) <= 3000,
'Test mesh interface failed!')
self.assertTrue(len(m.getTriangulation()) >= 2000,
'Test mesh interface failed!')
os.remove(file_name)
def concept_create_mesh_from_regions_with_ungenerate(self):
x=0
y=0
mesh_geo = geo_reference=Geo_reference(56, x, y)
# These are the absolute values
polygon_absolute = [[0,0], [100,0], [100,100], [0,100]]
x_p = -10
y_p = -40
geo_ref_poly = Geo_reference(56, x_p, y_p)
polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
boundary_tags = {'walls': [0,1], 'bom': [2]}
inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]]
inner1_polygon = geo_ref_poly.\
change_points_geo_ref(inner1_polygon_absolute)
inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]]
inner2_polygon = geo_ref_poly.\
change_points_geo_ref(inner2_polygon_absolute)
max_area = 10000000
interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
m = create_mesh_from_regions(polygon,
boundary_tags,
max_area,
interior_regions=interior_regions,
poly_geo_reference=geo_ref_poly,
mesh_geo_reference=mesh_geo)
m.export_mesh_file('a_test_mesh_iknterface.tsh')
fileName = tempfile.mktemp('.txt')
file = open(fileName, 'w')
file.write(' 1 ?? ??\n\
90.0 90.0\n\
81.0 90.0\n\
81.0 81.0\n\
90.0 81.0\n\
90.0 90.0\n\
END\n\
2 ?? ??\n\
10.0 80.0\n\
10.0 90.0\n\
20.0 90.0\n\
10.0 80.0\n\
END\n\
END\n')
file.close()
m.import_ungenerate_file(fileName, tag='wall')
os.remove(fileName)
m.generate_mesh(maximum_triangle_area=max_area, verbose=False)
m.export_mesh_file('b_test_mesh_iknterface.tsh')
def _create_domain_from_regions(bounding_polygon,
boundary_tags,
maximum_triangle_area=None,
mesh_filename=None,
interior_regions=None,
interior_holes=None,
hole_tags=None,
poly_geo_reference=None,
mesh_geo_reference=None,
breaklines=None,
regionPtArea=None,
minimum_triangle_angle=28.0,
fail_if_polygons_outside=True,
verbose=True):
"""_create_domain_from_regions - internal function.
See create_domain_from_regions for documentation.
"""
#from anuga.shallow_water.shallow_water_domain import Domain
from anuga.pmesh.mesh_interface import create_mesh_from_regions
create_mesh_from_regions(bounding_polygon,
boundary_tags,
maximum_triangle_area=maximum_triangle_area,
interior_regions=interior_regions,
filename=mesh_filename,
interior_holes=interior_holes,
hole_tags=hole_tags,
poly_geo_reference=poly_geo_reference,
mesh_geo_reference=mesh_geo_reference,
breaklines=breaklines,
regionPtArea=regionPtArea,
minimum_triangle_angle=minimum_triangle_angle,
fail_if_polygons_outside=fail_if_polygons_outside,
use_cache=False,
verbose=verbose)
domain = Domain(mesh_filename, use_cache=False, verbose=verbose)
return domain
def _create_domain_from_regions(bounding_polygon,
boundary_tags,
maximum_triangle_area=None,
mesh_filename=None,
interior_regions=None,
interior_holes=None,
hole_tags=None,
poly_geo_reference=None,
mesh_geo_reference=None,
breaklines=None,
regionPtArea=None,
minimum_triangle_angle=28.0,
fail_if_polygons_outside=True,
verbose=True):
"""_create_domain_from_regions - internal function.
See create_domain_from_regions for documentation.
"""
#from anuga.shallow_water.shallow_water_domain import Domain
from anuga.pmesh.mesh_interface import create_mesh_from_regions
create_mesh_from_regions(bounding_polygon,
boundary_tags,
maximum_triangle_area=maximum_triangle_area,
interior_regions=interior_regions,
filename=mesh_filename,
interior_holes=interior_holes,
hole_tags=hole_tags,
poly_geo_reference=poly_geo_reference,
mesh_geo_reference=mesh_geo_reference,
breaklines=breaklines,
regionPtArea=regionPtArea,
minimum_triangle_angle=minimum_triangle_angle,
fail_if_polygons_outside=fail_if_polygons_outside,
use_cache=False,
verbose=verbose)
domain = Domain(mesh_filename, use_cache=False, verbose=verbose)
return domain
def test_create_mesh_from_regions6(self):
file_name = tempfile.mktemp('.tsh')
# These are the absolute values
density_outer = 1000
min_outer = 0
max_outer = 1000
polygon_outer = [[min_outer, min_outer], [max_outer, min_outer],
[max_outer, max_outer], [min_outer, max_outer]]
delta = 10
density_inner1 = 1000
min_inner1 = min_outer + delta
max_inner1 = max_outer - delta
inner1_polygon = [[min_inner1, min_inner1], [max_inner1, min_inner1],
[max_inner1, max_inner1], [min_inner1, max_inner1]]
density_inner2 = 10000000
min_inner2 = min_outer + 2 * delta
max_inner2 = max_outer - 2 * delta
inner2_polygon = [[min_inner2, min_inner2], [max_inner2, min_inner2],
[max_inner2, max_inner2], [min_inner2, max_inner2]]
boundary_tags = {'walls': [0, 1], 'bom': [2, 3]}
interior_regions = [(inner1_polygon, density_inner1),
(inner2_polygon, density_inner2)]
create_mesh_from_regions(polygon_outer,
boundary_tags,
density_outer,
interior_regions=interior_regions,
filename=file_name,
verbose=False)
m = importMeshFromFile(file_name)
self.assertTrue(
len(m.getTriangulation()) <= 2000, 'Test mesh interface failed!')
self.assertTrue(
len(m.getTriangulation()) >= 900, 'Test mesh interface failed!')
os.remove(file_name)
def concept_ungenerateIII(self):
from anuga import Domain, Reflective_boundary, \
Dirichlet_boundary
from anuga.pmesh.mesh_interface import create_mesh_from_regions
# These are the absolute values
polygon = [[0, 0], [100, 0], [100, 100], [0, 100]]
boundary_tags = {'wall': [0, 1, 3], 'wave': [2]}
inner1_polygon = [[10, 10], [20, 10], [20, 20], [10, 20]]
inner2_polygon = [[30, 30], [40, 30], [40, 40], [30, 40]]
max_area = 1
interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
m = create_mesh_from_regions(polygon,
boundary_tags,
max_area,
interior_regions=interior_regions)
fileName = tempfile.mktemp('.txt')
file = open(fileName, 'w')
file.write(' 1 ?? ??\n\
90.0 90.0\n\
81.0 90.0\n\
81.0 81.0\n\
90.0 81.0\n\
90.0 90.0\n\
END\n\
2 ?? ??\n\
10.0 80.0\n\
10.0 90.0\n\
20.0 90.0\n\
10.0 80.0\n\
END\n\
END\n')
file.close()
m.import_ungenerate_file(fileName)
os.remove(fileName)
m.generate_mesh(maximum_triangle_area=max_area, verbose=False)
mesh_filename = 'mesh.tsh'
m.export_mesh_file(mesh_filename)
domain = Domain(mesh_filename, use_cache=False)
Br = Reflective_boundary(domain)
Bd = Dirichlet_boundary([3, 0, 0])
domain.set_boundary({'wall': Br, 'wave': Bd})
yieldstep = 0.1
finaltime = 10
for t in domain.evolve(yieldstep, finaltime):
domain.write_time()
def concept_ungenerateIII(self):
from anuga import Domain, Reflective_boundary, \
Dirichlet_boundary
from anuga.pmesh.mesh_interface import create_mesh_from_regions
# These are the absolute values
polygon = [[0,0], [100,0], [100,100], [0,100]]
boundary_tags = {'wall': [0,1,3], 'wave': [2]}
inner1_polygon = [[10,10], [20,10], [20,20], [10,20]]
inner2_polygon = [[30,30], [40,30], [40,40], [30,40]]
max_area = 1
interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
m = create_mesh_from_regions(polygon,
boundary_tags,
max_area,
interior_regions=interior_regions)
fileName = tempfile.mktemp('.txt')
file = open(fileName, 'w')
file.write(' 1 ?? ??\n\
90.0 90.0\n\
81.0 90.0\n\
81.0 81.0\n\
90.0 81.0\n\
90.0 90.0\n\
END\n\
2 ?? ??\n\
10.0 80.0\n\
10.0 90.0\n\
20.0 90.0\n\
10.0 80.0\n\
END\n\
END\n')
file.close()
m.import_ungenerate_file(fileName)
os.remove(fileName)
m.generate_mesh(maximum_triangle_area=max_area, verbose=False)
mesh_filename = 'mesh.tsh'
m.export_mesh_file(mesh_filename)
domain = Domain(mesh_filename, use_cache=False)
Br = Reflective_boundary(domain)
Bd = Dirichlet_boundary([3, 0, 0])
domain.set_boundary({'wall': Br, 'wave': Bd})
yieldstep = 0.1
finaltime = 10
for t in domain.evolve(yieldstep, finaltime):
domain.write_time()
def FIXMEtest_create_mesh_with_multiply_tagged_segments(self):
'''Test that create_mesh_from_regions fails when
segments are listed repeatedly in boundary_tags.
'''
# These are the absolute values
min_x = 10
min_y = 88
polygon = [[min_x, min_y], [1000, 100], [1000, 1000], [100, 1000]]
boundary_tags = {'walls': [0, 1], 'bom': [1, 2]}
# This one is inside bounding polygon - should pass
inner_polygon = [[800, 400], [900, 500], [800, 600]]
interior_regions = [(inner_polygon, 5)]
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions,
verbose=False)
# This one sticks outside bounding polygon - should fail
inner_polygon = [[800, 400], [900, 500], [800, 600]]
interior_regions = [(inner_polygon, 5)]
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions)
try:
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions)
except:
pass
else:
msg = 'Tags are listed repeatedly, but create mesh from regions '
msg += 'does not cause an Exception to be raised'
raise_(Exception, msg)
def FIXMEtest_create_mesh_with_multiply_tagged_segments(self):
'''Test that create_mesh_from_regions fails when
segments are listed repeatedly in boundary_tags.
'''
# These are the absolute values
min_x = 10
min_y = 88
polygon = [[min_x,min_y], [1000,100], [1000,1000], [100,1000]]
boundary_tags = {'walls': [0,1], 'bom': [1,2]}
# This one is inside bounding polygon - should pass
inner_polygon = [[800,400], [900,500], [800,600]]
interior_regions = [(inner_polygon, 5)]
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions,
verbose=False)
# This one sticks outside bounding polygon - should fail
inner_polygon = [[800,400], [900,500], [800,600]]
interior_regions = [(inner_polygon, 5)]
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions)
try:
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions)
except:
pass
else:
msg = 'Tags are listed repeatedly, but create mesh from regions '
msg += 'does not cause an Exception to be raised'
raise Exception, msg
def test_create_mesh_from_regions_interior_regions(self):
'''Test that create_mesh_from_regions fails when an interior
region is outside bounding polygon.
'''
# These are the absolute values
min_x = 10
min_y = 88
polygon = [[min_x, min_y], [1000, 100], [1000, 1000], [100, 1000]]
boundary_tags = {'walls': [0, 1], 'bom': [2, 3]}
# This one is inside bounding polygon - should pass
inner_polygon = [[800, 400], [900, 500], [800, 600]]
interior_regions = [(inner_polygon, 5)]
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions)
# This one sticks outside bounding polygon - should fail
inner_polygon = [[800, 400], [900, 500], [800, 600], [200, 995]]
inner_polygon1 = [[800, 400], [1100, 500], [800, 600]]
interior_regions = [[inner_polygon, 50], [inner_polygon1, 50]]
try:
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions,
verbose=False)
except:
pass
else:
msg = 'Interior polygon sticking outside bounding polygon should '
msg += 'cause an Exception to be raised'
raise_(Exception, msg)
def test_create_mesh_from_regions_interior_regions(self):
'''Test that create_mesh_from_regions fails when an interior
region is outside bounding polygon.
'''
# These are the absolute values
min_x = 10
min_y = 88
polygon = [[min_x,min_y], [1000,100], [1000,1000], [100,1000]]
boundary_tags = {'walls': [0,1], 'bom': [2,3]}
# This one is inside bounding polygon - should pass
inner_polygon = [[800,400], [900,500], [800,600]]
interior_regions = [(inner_polygon, 5)]
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions)
# This one sticks outside bounding polygon - should fail
inner_polygon = [[800,400], [900,500], [800,600], [200, 995]]
inner_polygon1 = [[800,400], [1100,500], [800,600]]
interior_regions = [[inner_polygon, 50], [inner_polygon1, 50]]
try:
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions,
verbose=False)
except:
pass
else:
msg = 'Interior polygon sticking outside bounding polygon should '
msg += 'cause an Exception to be raised'
raise Exception, msg
def test_create_mesh_with_breaklines(self):
# These are the absolute values
polygon = [[100,100], [1000,100], [1000,1000], [100,1000]]
boundary_tags = {'walls': [0,1], 'bom': [2,3]}
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
breaklines=[[[50,50],[2000,2000]]])
self.assertTrue(len(m.regions) == 1, 'FAILED!')
segs = m.getUserSegments()
self.assertTrue(len(segs) == 5, 'FAILED!')
self.assertTrue(len(m.userVertices) == 6, 'FAILED!')
def test_create_mesh_with_breaklines(self):
# These are the absolute values
polygon = [[100, 100], [1000, 100], [1000, 1000], [100, 1000]]
boundary_tags = {'walls': [0, 1], 'bom': [2, 3]}
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
breaklines=[[[50, 50], [2000, 2000]]])
self.assertTrue(len(m.regions) == 1, 'FAILED!')
segs = m.getUserSegments()
self.assertTrue(len(segs) == 5, 'FAILED!')
self.assertTrue(len(m.userVertices) == 6, 'FAILED!')
def test_create_mesh_from_regions2(self):
# These are the absolute values
min_x = -10
min_y = -88
polygon_absolute = [[min_x, min_y], [1000, 100], [1000, 1000],
[100, 1000]]
x_p = -10
y_p = -40
zone = 808
geo_ref_poly = Geo_reference(zone, x_p, y_p)
polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
boundary_tags = {'walls': [0, 1], 'bom': [2, 3]}
inner1_polygon_absolute = [[10, 10], [20, 10], [20, 20], [10, 20]]
inner1_polygon = geo_ref_poly.\
change_points_geo_ref(inner1_polygon_absolute)
inner2_polygon_absolute = [[30, 30], [40, 30], [40, 40], [30, 40]]
inner2_polygon = geo_ref_poly.\
change_points_geo_ref(inner2_polygon_absolute)
interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions,
poly_geo_reference=geo_ref_poly)
# Test the mesh instance
self.assertTrue(len(m.regions) == 3, 'FAILED!')
segs = m.getUserSegments()
self.assertTrue(len(segs) == 12, 'FAILED!')
self.assertTrue(len(m.userVertices) == 12, 'FAILED!')
self.assertTrue(segs[0].tag == 'walls', 'FAILED!')
self.assertTrue(segs[1].tag == 'walls', 'FAILED!')
self.assertTrue(segs[2].tag == 'bom', 'FAILED!')
self.assertTrue(segs[3].tag == 'bom', 'FAILED!')
self.assertTrue(m.geo_reference.get_zone() == zone, 'FAILED!')
self.assertTrue(m.geo_reference.get_xllcorner() == min_x, 'FAILED!')
self.assertTrue(m.geo_reference.get_yllcorner() == min_y, 'FAILED!')
def test_create_mesh_from_regions2(self):
# These are the absolute values
min_x = -10
min_y = -88
polygon_absolute = [[min_x,min_y], [1000,100], [1000,1000], [100,1000]]
x_p = -10
y_p = -40
zone = 808
geo_ref_poly = Geo_reference(zone, x_p, y_p)
polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
boundary_tags = {'walls': [0,1], 'bom': [2,3]}
inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]]
inner1_polygon = geo_ref_poly.\
change_points_geo_ref(inner1_polygon_absolute)
inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]]
inner2_polygon = geo_ref_poly.\
change_points_geo_ref(inner2_polygon_absolute)
interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions,
poly_geo_reference=geo_ref_poly)
# Test the mesh instance
self.assertTrue(len(m.regions)==3, 'FAILED!')
segs = m.getUserSegments()
self.assertTrue(len(segs)==12, 'FAILED!')
self.assertTrue(len(m.userVertices)==12, 'FAILED!')
self.assertTrue(segs[0].tag=='walls', 'FAILED!')
self.assertTrue(segs[1].tag=='walls', 'FAILED!')
self.assertTrue(segs[2].tag=='bom', 'FAILED!')
self.assertTrue(segs[3].tag=='bom', 'FAILED!')
self.assertTrue(m.geo_reference.get_zone()==zone, 'FAILED!')
self.assertTrue(m.geo_reference.get_xllcorner()==min_x, 'FAILED!')
self.assertTrue(m.geo_reference.get_yllcorner()==min_y, 'FAILED!')
def test_create_mesh_from_regions_with_duplicate_verts(self):
# These are the absolute values
polygon_absolute = [[0.0, 0.0], [0, 4.0], [4.0, 4.0], [4.0, 0.0],
[4.0, 0.0]]
x_p = -10
y_p = -40
zone = 808
geo_ref_poly = Geo_reference(zone, x_p, y_p)
polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
boundary_tags = {
'50': [0],
'40': [1],
'30': [2],
'no where seg': [3],
'20': [4]
}
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
poly_geo_reference=geo_ref_poly,
verbose=False)
fileName = 'badmesh.tsh'
def test_create_mesh_from_regions_with_duplicate_verts(self):
# These are the absolute values
polygon_absolute = [[0.0, 0.0],
[0, 4.0],
[4.0, 4.0],
[4.0, 0.0],
[4.0, 0.0]]
x_p = -10
y_p = -40
zone = 808
geo_ref_poly = Geo_reference(zone, x_p, y_p)
polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
boundary_tags = {'50': [0],
'40': [1],
'30': [2],
'no where seg': [3],
'20': [4]}
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
poly_geo_reference=geo_ref_poly,
verbose=False)
fileName = 'badmesh.tsh'
def test_create_mesh_from_regions_interior_regions1(self):
'''Test that create_mesh_from_regions fails
when an interior region is outside bounding polygon.
'''
# These are the values
d0 = [310000, 7690000]
d1 = [280000, 7690000]
d2 = [270000, 7645000]
d3 = [240000, 7625000]
d4 = [270000, 7580000]
d5 = [300000, 7590000]
d6 = [340000, 7610000]
poly_all = [d0, d1, d2, d3, d4, d5, d6]
i0 = [304000, 7607000]
i1 = [302000, 7605000]
i2 = [304000, 7603000]
i3 = [307000, 7602000]
i4 = [309000, 7603000]
# i4 = [310000, 7580000]
i5 = [307000, 7606000]
poly_onslow = [i0, i1, i2, i3, i4, i5]
# Thevenard Island
j0 = [294000, 7629000]
j1 = [285000, 7625000]
j2 = [294000, 7621000]
j3 = [299000, 7625000]
poly_thevenard = [j0, j1, j2, j3]
# med res around onslow
l0 = [300000, 7610000]
l1 = [285000, 7600000]
l2 = [300000, 7597500]
l3 = [310000, 7770000] # this one is outside
# l3 = [310000, 7630000] # this one is NOT outside
l4 = [315000, 7610000]
poly_coast = [l0, l1, l2, l3, l4]
# general coast and local area to onslow region
m0 = [270000, 7581000]
m1 = [300000, 7591000]
m2 = [339000, 7610000]
m3 = [330000, 7630000]
m4 = [290000, 7640000]
m5 = [260000, 7600000]
poly_region = [m0, m1, m2, m3, m4, m5]
# This one sticks outside bounding polygon - should fail
interior_regions = [[poly_onslow, 50000], [poly_region, 50000],
[poly_coast, 100000], [poly_thevenard, 100000]]
boundary_tags = {'walls': [0,1], 'bom': [2]}
try:
m = create_mesh_from_regions(poly_all,
boundary_tags,
10000000,
interior_regions=interior_regions,
verbose=False)
except:
pass
else:
msg = 'Interior polygon sticking outside bounding polygon should '
msg += 'cause an Exception to be raised'
raise Exception, msg
def test_create_mesh_from_regions(self):
x = -500
y = -1000
mesh_geo = geo_reference = Geo_reference(56, x, y)
# These are the absolute values
polygon_absolute = [[0, 0], [100, 0], [100, 100], [0, 100]]
x_p = -10
y_p = -40
geo_ref_poly = Geo_reference(56, x_p, y_p)
polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
boundary_tags = {'walls': [0, 1], 'bom': [2, 3]}
inner1_polygon_absolute = [[10, 10], [20, 10], [20, 20], [10, 20]]
inner1_polygon = geo_ref_poly.\
change_points_geo_ref(inner1_polygon_absolute)
inner2_polygon_absolute = [[30, 30], [40, 30], [40, 40], [30, 40]]
inner2_polygon = geo_ref_poly.\
change_points_geo_ref(inner2_polygon_absolute)
interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions,
poly_geo_reference=geo_ref_poly,
mesh_geo_reference=mesh_geo)
# Test the mesh instance
self.assertTrue(len(m.regions) == 3, 'FAILED!')
segs = m.getUserSegments()
self.assertTrue(len(segs) == 12, 'FAILED!')
self.assertTrue(len(m.userVertices) == 12, 'FAILED!')
self.assertTrue(segs[0].tag == 'walls', 'FAILED!')
self.assertTrue(segs[1].tag == 'walls', 'FAILED!')
self.assertTrue(segs[2].tag == 'bom', 'FAILED!')
self.assertTrue(segs[3].tag == 'bom', 'FAILED!')
# Assuming the order of the region points is known.
# (This isn't true, if you consider create_mesh_from_regions
# a black box)
poly_point = m.getRegions()[0]
# poly_point values are relative to the mesh geo-ref
# make them absolute
msg = ('Expected point (%s,%s) to be inside polygon %s' %
(str(poly_point.x + x), str(poly_point.y + y),
str(polygon_absolute)))
self.assertTrue(
is_inside_polygon([poly_point.x + x, poly_point.y + y],
polygon_absolute,
closed=False), msg)
# Assuming the order of the region points is known.
# (This isn't true, if you consider create_mesh_from_regions
# a black box)
poly_point = m.getRegions()[1]
# poly_point values are relative to the mesh geo-ref
# make them absolute
self.assertTrue(
is_inside_polygon([poly_point.x + x, poly_point.y + y],
inner1_polygon_absolute,
closed=False), 'FAILED!')
# Assuming the order of the region points is known.
# (This isn't true, if you consider create_mesh_from_regions
# a black box)
poly_point = m.getRegions()[2]
# poly_point values are relative to the mesh geo-ref
# make them absolute
self.assertTrue(
is_inside_polygon([poly_point.x + x, poly_point.y + y],
inner2_polygon_absolute,
closed=False), 'FAILED!')
def test_create_mesh_from_regions_with_caching(self):
x = -500
y = -1000
mesh_geo = geo_reference = Geo_reference(56, x, y)
# These are the absolute values
polygon_absolute = [[0, 0], [100, 0], [100, 100], [0, 100]]
x_p = -10
y_p = -40
geo_ref_poly = Geo_reference(56, x_p, y_p)
polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
boundary_tags = {'walls': [0, 1], 'bom': [2, 3]}
inner1_polygon_absolute = [[10, 10], [20, 10], [20, 20], [10, 20]]
inner1_polygon = geo_ref_poly.\
change_points_geo_ref(inner1_polygon_absolute)
inner2_polygon_absolute = [[30, 30], [40, 30], [40, 40], [30, 40]]
inner2_polygon = geo_ref_poly.\
change_points_geo_ref(inner2_polygon_absolute)
interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
interior_holes = None
# Clear cache first
from anuga.caching import cache
cache(_create_mesh_from_regions, (polygon, boundary_tags), {
'minimum_triangle_angle': 28.0,
'maximum_triangle_area': 10000000,
'interior_regions': interior_regions,
'interior_holes': interior_holes,
'poly_geo_reference': geo_ref_poly,
'mesh_geo_reference': mesh_geo,
'verbose': False
},
verbose=False,
clear=1)
m = create_mesh_from_regions(polygon,
boundary_tags,
maximum_triangle_area=10000000,
interior_regions=interior_regions,
poly_geo_reference=geo_ref_poly,
mesh_geo_reference=mesh_geo,
verbose=False,
use_cache=True)
# Test the mesh instance
self.assertTrue(len(m.regions) == 3, 'FAILED!')
segs = m.getUserSegments()
self.assertTrue(len(segs) == 12, 'FAILED!')
self.assertTrue(len(m.userVertices) == 12, 'FAILED!')
self.assertTrue(segs[0].tag == 'walls', 'FAILED!')
self.assertTrue(segs[1].tag == 'walls', 'FAILED!')
self.assertTrue(segs[2].tag == 'bom', 'FAILED!')
self.assertTrue(segs[3].tag == 'bom', 'FAILED!')
# Assuming the order of the region points is known.
# (This isn't true, if you consider create_mesh_from_regions
# a black box)
poly_point = m.getRegions()[0]
# poly_point values are relative to the mesh geo-ref
# make them absolute
self.assertTrue(
is_inside_polygon([poly_point.x + x, poly_point.y + y],
polygon_absolute,
closed=False), 'FAILED!')
# Assuming the order of the region points is known.
# (This isn't true, if you consider create_mesh_from_regions
# a black box)
poly_point = m.getRegions()[1]
# poly_point values are relative to the mesh geo-ref
# make them absolute
self.assertTrue(
is_inside_polygon([poly_point.x + x, poly_point.y + y],
inner1_polygon_absolute,
closed=False), 'FAILED!')
# Assuming the order of the region points is known.
# (This isn't true, if you consider create_mesh_from_regions
# a black box)
poly_point = m.getRegions()[2]
# poly_point values are relative to the mesh geo-ref
# make them absolute
self.assertTrue(
is_inside_polygon([poly_point.x + x, poly_point.y + y],
inner2_polygon_absolute,
closed=False), 'FAILED!')
# Now create m using cached values
m_cache = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions,
poly_geo_reference=geo_ref_poly,
mesh_geo_reference=mesh_geo,
verbose=False,
use_cache=True)
# Create a scenario outline.
polygon = [[0,0],[100,0],[100,100],[0,100]]
boundary_tags = {'wall':[0,1,3],'wave':[2]}
inner1_polygon = [[10,10],[20,10],[20,20],[10,20]]
inner2_polygon = [[30,30],[40,30],[40,40],[30,40]]
max_area = 1
interior_regions = [(inner1_polygon, 5),(inner2_polygon, 10)]
m = create_mesh_from_regions(polygon,
boundary_tags,
max_area,
interior_regions=interior_regions)
# Create an ungenerate file
fileName = tempfile.mktemp(".txt")
file = open(fileName,"w")
file.write(" 1 ?? ??\n\
90.0 90.0\n\
81.0 90.0\n\
81.0 81.0\n\
90.0 81.0\n\
90.0 90.0\n\
END\n\
2 ?? ??\n\
10.0 80.0\n\
10.0 90.0\n\
def concept_ungenerateII(self):
from anuga import Domain, Reflective_boundary, Dirichlet_boundary
x = 0
y = 0
mesh_geo = geo_reference = Geo_reference(56, x, y)
# These are the absolute values
polygon_absolute = [[0, 0], [100, 0], [100, 100], [0, 100]]
x_p = -10
y_p = -40
geo_ref_poly = Geo_reference(56, x_p, y_p)
polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
boundary_tags = {'wall': [0, 1, 3], 'wave': [2]}
inner1_polygon_absolute = [[10, 10], [20, 10], [20, 20], [10, 20]]
inner1_polygon = geo_ref_poly.\
change_points_geo_ref(inner1_polygon_absolute)
inner2_polygon_absolute = [[30, 30], [40, 30], [40, 40], [30, 40]]
inner2_polygon = geo_ref_poly.\
change_points_geo_ref(inner2_polygon_absolute)
max_area = 1
interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
m = create_mesh_from_regions(polygon,
boundary_tags,
max_area,
interior_regions=interior_regions,
poly_geo_reference=geo_ref_poly,
mesh_geo_reference=mesh_geo)
m.export_mesh_file('a_test_mesh_iknterface.tsh')
fileName = tempfile.mktemp('.txt')
file = open(fileName, 'w')
file.write(' 1 ?? ??\n\
90.0 90.0\n\
81.0 90.0\n\
81.0 81.0\n\
90.0 81.0\n\
90.0 90.0\n\
END\n\
2 ?? ??\n\
10.0 80.0\n\
10.0 90.0\n\
20.0 90.0\n\
10.0 80.0\n\
END\n\
END\n')
file.close()
m.import_ungenerate_file(fileName) #, tag='wall')
os.remove(fileName)
m.generate_mesh(maximum_triangle_area=max_area, verbose=False)
mesh_filename = 'bento_b.tsh'
m.export_mesh_file(mesh_filename)
domain = Domain(mesh_filename, use_cache=False)
Br = Reflective_boundary(domain)
Bd = Dirichlet_boundary([3, 0, 0])
domain.set_boundary({'wall': Br, 'wave': Bd})
yieldstep = 0.1
finaltime = 10
for t in domain.evolve(yieldstep, finaltime):
domain.write_time()
def concept_ungenerateII(self):
from anuga import Domain, Reflective_boundary, Dirichlet_boundary
x=0
y=0
mesh_geo = geo_reference=Geo_reference(56, x, y)
# These are the absolute values
polygon_absolute = [[0,0], [100,0], [100,100], [0,100]]
x_p = -10
y_p = -40
geo_ref_poly = Geo_reference(56, x_p, y_p)
polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
boundary_tags = {'wall': [0,1,3], 'wave': [2]}
inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]]
inner1_polygon = geo_ref_poly.\
change_points_geo_ref(inner1_polygon_absolute)
inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]]
inner2_polygon = geo_ref_poly.\
change_points_geo_ref(inner2_polygon_absolute)
max_area = 1
interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
m = create_mesh_from_regions(polygon,
boundary_tags,
max_area,
interior_regions=interior_regions,
poly_geo_reference=geo_ref_poly,
mesh_geo_reference=mesh_geo)
m.export_mesh_file('a_test_mesh_iknterface.tsh')
fileName = tempfile.mktemp('.txt')
file = open(fileName, 'w')
file.write(' 1 ?? ??\n\
90.0 90.0\n\
81.0 90.0\n\
81.0 81.0\n\
90.0 81.0\n\
90.0 90.0\n\
END\n\
2 ?? ??\n\
10.0 80.0\n\
10.0 90.0\n\
20.0 90.0\n\
10.0 80.0\n\
END\n\
END\n')
file.close()
m.import_ungenerate_file(fileName) #, tag='wall')
os.remove(fileName)
m.generate_mesh(maximum_triangle_area=max_area, verbose=False)
mesh_filename = 'bento_b.tsh'
m.export_mesh_file(mesh_filename)
domain = Domain(mesh_filename, use_cache = False)
Br = Reflective_boundary(domain)
Bd = Dirichlet_boundary([3, 0, 0])
domain.set_boundary({'wall': Br, 'wave': Bd})
yieldstep = 0.1
finaltime = 10
for t in domain.evolve(yieldstep, finaltime):
domain.write_time()
def parallel_time_varying_file_boundary_sts(self):
""" parallel_test_time_varying_file_boundary_sts_sequential(self):
Read correct points from ordering file and apply sts to boundary.
The boundary is time varying. Compares sequential result with
distributed result found using anuga_parallel
"""
#------------------------------------------------------------
# Define test variables
#------------------------------------------------------------
lat_long_points = [[6.01, 97.0], [6.02, 97.0], [6.05, 96.9],
[6.0, 97.0]]
bounding_polygon = [[6.0, 97.0], [6.01, 97.0], [6.02, 97.0],
[6.02, 97.02], [6.00, 97.02]]
tide = 3.0
time_step_count = 65
time_step = 2
n = len(lat_long_points)
first_tstep = num.ones(n, num.int)
last_tstep = (time_step_count) * num.ones(n, num.int)
finaltime = num.float(time_step * (time_step_count - 1))
yieldstep = num.float(time_step)
gauge_depth = 20 * num.ones(n, num.float)
ha = 2 * num.ones((n, time_step_count), num.float)
ua = 10 * num.ones((n, time_step_count), num.float)
va = -10 * num.ones((n, time_step_count), num.float)
times = num.arange(0, time_step_count * time_step, time_step)
for i in range(n):
#ha[i]+=num.sin(times)
ha[i] += times / finaltime
#------------------------------------------------------------
# Write mux data to file then convert to sts format
#------------------------------------------------------------
sts_file = "test"
if myid == 0:
base_name, files = self.write_mux2(lat_long_points,
time_step_count,
time_step,
first_tstep,
last_tstep,
depth=gauge_depth,
ha=ha,
ua=ua,
va=va)
# base name will not exist, but 3 other files are created
# Write order file
file_handle, order_base_name = tempfile.mkstemp("")
os.close(file_handle)
os.remove(order_base_name)
d = ","
order_file = order_base_name + 'order.txt'
fid = open(order_file, 'w')
# Write Header
header = 'index, longitude, latitude\n'
fid.write(header)
indices = [3, 0, 1]
for i in indices:
line=str(i)+d+str(lat_long_points[i][1])+d+\
str(lat_long_points[i][0])+"\n"
fid.write(line)
fid.close()
urs2sts(base_name,
basename_out=sts_file,
ordering_filename=order_file,
mean_stage=tide,
verbose=verbose)
self.delete_mux(files)
assert (os.access(sts_file + '.sts', os.F_OK))
os.remove(order_file)
barrier()
#------------------------------------------------------------
# Define boundary_polygon on each processor. This polygon defines the
# urs boundary and lies on a portion of the bounding_polygon
#------------------------------------------------------------
boundary_polygon = create_sts_boundary(sts_file)
# Append the remaining part of the boundary polygon to be defined by
# the user
bounding_polygon_utm = []
for point in bounding_polygon:
zone, easting, northing = redfearn(point[0], point[1])
bounding_polygon_utm.append([easting, northing])
boundary_polygon.append(bounding_polygon_utm[3])
boundary_polygon.append(bounding_polygon_utm[4])
assert num.allclose(bounding_polygon_utm, boundary_polygon)
extent_res = 10000
meshname = 'urs_test_mesh' + '.tsh'
interior_regions = None
boundary_tags = {'ocean': [0, 1], 'otherocean': [2, 3, 4]}
#------------------------------------------------------------
# Create mesh on the master processor and store in file. This file
# is read in by each slave processor when needed
#------------------------------------------------------------
if myid == 0:
create_mesh_from_regions(boundary_polygon,
boundary_tags=boundary_tags,
maximum_triangle_area=extent_res,
filename=meshname,
interior_regions=interior_regions,
verbose=verbose)
# barrier()
domain_fbound = Domain(meshname)
domain_fbound.set_quantities_to_be_stored(None)
domain_fbound.set_quantity('stage', tide)
# print domain_fbound.mesh.get_boundary_polygon()
else:
domain_fbound = None
barrier()
if (verbose and myid == 0):
print 'DISTRIBUTING PARALLEL DOMAIN'
domain_fbound = distribute(domain_fbound)
#--------------------------------------------------------------------
# Find which sub_domain in which the interpolation points are located
#
# Sometimes the interpolation points sit exactly
# between two centroids, so in the parallel run we
# reset the interpolation points to the centroids
# found in the sequential run
#--------------------------------------------------------------------
interpolation_points = [[279000, 664000], [280250, 664130],
[279280, 665400], [280500, 665000]]
interpolation_points = num.array(interpolation_points)
#if myid==0:
# import pylab as P
# boundary_polygon=num.array(boundary_polygon)
# P.plot(boundary_polygon[:,0],boundary_polygon[:,1])
# P.plot(interpolation_points[:,0],interpolation_points[:,1],'ko')
# P.show()
fbound_gauge_values = []
fbound_proc_tri_ids = []
for i, point in enumerate(interpolation_points):
fbound_gauge_values.append([]) # Empty list for timeseries
try:
k = domain_fbound.get_triangle_containing_point(point)
if domain_fbound.tri_full_flag[k] == 1:
fbound_proc_tri_ids.append(k)
else:
fbound_proc_tri_ids.append(-1)
except:
fbound_proc_tri_ids.append(-2)
if verbose: print 'P%d has points = %s' % (myid, fbound_proc_tri_ids)
#------------------------------------------------------------
# Set boundary conditions
#------------------------------------------------------------
Bf = File_boundary(sts_file + '.sts',
domain_fbound,
boundary_polygon=boundary_polygon)
Br = Reflective_boundary(domain_fbound)
domain_fbound.set_boundary({'ocean': Bf, 'otherocean': Br})
#------------------------------------------------------------
# Evolve the domain on each processor
#------------------------------------------------------------
for i, t in enumerate(
domain_fbound.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step=False)):
stage = domain_fbound.get_quantity('stage')
for i in range(4):
if fbound_proc_tri_ids[i] > -1:
fbound_gauge_values[i].append(
stage.centroid_values[fbound_proc_tri_ids[i]])
#------------------------------------------------------------
# Create domain to be run sequntially on each processor
#------------------------------------------------------------
domain_drchlt = Domain(meshname)
domain_drchlt.set_quantities_to_be_stored(None)
domain_drchlt.set_starttime(time_step)
domain_drchlt.set_quantity('stage', tide)
Br = Reflective_boundary(domain_drchlt)
#Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide])
Bd = Time_boundary(
domain=domain_drchlt,
function=lambda t: [
2.0 + t / finaltime + tide, 220. + 10. * tide + 10. * t /
finaltime, -220. - 10. * tide - 10. * t / finaltime
])
#Bd = Time_boundary(domain=domain_drchlt,function=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)])
domain_drchlt.set_boundary({'ocean': Bd, 'otherocean': Br})
drchlt_gauge_values = []
drchlt_proc_tri_ids = []
for i, point in enumerate(interpolation_points):
drchlt_gauge_values.append([]) # Empty list for timeseries
try:
k = domain_drchlt.get_triangle_containing_point(point)
if domain_drchlt.tri_full_flag[k] == 1:
drchlt_proc_tri_ids.append(k)
else:
drchlt_proc_tri_ids.append(-1)
except:
drchlt_proc_tri_ids.append(-2)
if verbose: print 'P%d has points = %s' % (myid, drchlt_proc_tri_ids)
#------------------------------------------------------------
# Evolve entire domain on each processor
#------------------------------------------------------------
for i, t in enumerate(
domain_drchlt.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step=False)):
stage = domain_drchlt.get_quantity('stage')
for i in range(4):
drchlt_gauge_values[i].append(
stage.centroid_values[drchlt_proc_tri_ids[i]])
#------------------------------------------------------------
# Compare sequential values with parallel values
#------------------------------------------------------------
barrier()
success = True
for i in range(4):
if fbound_proc_tri_ids[i] > -1:
fbound_gauge_values[i] = num.array(fbound_gauge_values[i])
drchlt_gauge_values[i] = num.array(drchlt_gauge_values[i])
#print i,fbound_gauge_values[i][4]
#print i,drchlt_gauge_values[i][4]
success = success and num.allclose(fbound_gauge_values[i],
drchlt_gauge_values[i])
assert success #, (fbound_gauge_values[i]-drchlt_gauge_values[i])
#assert_(success)
if not sys.platform == 'win32':
if myid == 0: os.remove(sts_file + '.sts')
if myid == 0: os.remove(meshname)
def sequential_time_varying_file_boundary_sts(self):
"""sequential_ltest_time_varying_file_boundary_sts_sequential(self):
Read correct points from ordering file and apply sts to boundary. The boundary is time varying. FIXME add to test_urs2sts.
"""
lat_long_points = [[6.01, 97.0], [6.02, 97.0], [6.05, 96.9],
[6.0, 97.0]]
bounding_polygon = [[6.0, 97.0], [6.01, 97.0], [6.02, 97.0],
[6.02, 97.02], [6.00, 97.02]]
tide = 3.0
time_step_count = 65
time_step = 2.
n = len(lat_long_points)
first_tstep = num.ones(n, num.int)
last_tstep = (time_step_count) * num.ones(n, num.int)
finaltime = num.float(time_step * (time_step_count - 1))
yieldstep = num.float(time_step)
gauge_depth = 20 * num.ones(n, num.float)
ha = 2 * num.ones((n, time_step_count), num.float)
ua = 10 * num.ones((n, time_step_count), num.float)
va = -10 * num.ones((n, time_step_count), num.float)
times = num.arange(0., num.float(time_step_count * time_step),
time_step)
for i in range(n):
#ha[i]+=num.sin(times)
ha[i] += times / finaltime
sts_file = "test"
if myid == 0:
base_name, files = self.write_mux2(lat_long_points,
time_step_count,
time_step,
first_tstep,
last_tstep,
depth=gauge_depth,
ha=ha,
ua=ua,
va=va)
# base name will not exist, but 3 other files are created
# Write order file
file_handle, order_base_name = tempfile.mkstemp("")
os.close(file_handle)
os.remove(order_base_name)
d = ","
order_file = order_base_name + 'order.txt'
fid = open(order_file, 'w')
# Write Header
header = 'index, longitude, latitude\n'
fid.write(header)
indices = [3, 0, 1]
for i in indices:
line=str(i)+d+str(lat_long_points[i][1])+d+\
str(lat_long_points[i][0])+"\n"
fid.write(line)
fid.close()
urs2sts(base_name,
basename_out=sts_file,
ordering_filename=order_file,
mean_stage=tide,
verbose=verbose)
self.delete_mux(files)
assert (os.access(sts_file + '.sts', os.F_OK))
os.remove(order_file)
barrier()
boundary_polygon = create_sts_boundary(sts_file)
# Append the remaining part of the boundary polygon to be defined by
# the user
bounding_polygon_utm = []
for point in bounding_polygon:
zone, easting, northing = redfearn(point[0], point[1])
bounding_polygon_utm.append([easting, northing])
boundary_polygon.append(bounding_polygon_utm[3])
boundary_polygon.append(bounding_polygon_utm[4])
assert num.allclose(bounding_polygon_utm, boundary_polygon)
extent_res = 1000000
meshname = 'urs_test_mesh' + '.tsh'
interior_regions = None
boundary_tags = {'ocean': [0, 1], 'otherocean': [2, 3, 4]}
# have to change boundary tags from last example because now bounding
# polygon starts in different place.
if myid == 0:
create_mesh_from_regions(boundary_polygon,
boundary_tags=boundary_tags,
maximum_triangle_area=extent_res,
filename=meshname,
interior_regions=interior_regions,
verbose=verbose)
barrier()
domain_fbound = Domain(meshname)
domain_fbound.set_quantities_to_be_stored(None)
domain_fbound.set_quantity('stage', tide)
if verbose: print "Creating file boundary condition"
Bf = File_boundary(sts_file + '.sts',
domain_fbound,
boundary_polygon=boundary_polygon)
Br = Reflective_boundary(domain_fbound)
domain_fbound.set_boundary({'ocean': Bf, 'otherocean': Br})
temp_fbound = num.zeros(int(finaltime / yieldstep) + 1, num.float)
if verbose: print "Evolving domain with file boundary condition"
for i, t in enumerate(
domain_fbound.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step=False)):
temp_fbound[i] = domain_fbound.quantities['stage'].centroid_values[
2]
if verbose: domain_fbound.write_time()
domain_drchlt = Domain(meshname)
domain_drchlt.set_quantities_to_be_stored(None)
domain_drchlt.set_starttime(time_step)
domain_drchlt.set_quantity('stage', tide)
Br = Reflective_boundary(domain_drchlt)
#Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide])
Bd = Time_boundary(
domain=domain_drchlt,
f=lambda t: [
2.0 + t / finaltime + tide, 220. + 10. * tide + 10. * t /
finaltime, -220. - 10. * tide - 10. * t / finaltime
])
#Bd = Time_boundary(domain=domain_drchlt,f=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)])
domain_drchlt.set_boundary({'ocean': Bd, 'otherocean': Br})
temp_drchlt = num.zeros(int(finaltime / yieldstep) + 1, num.float)
for i, t in enumerate(
domain_drchlt.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step=False)):
temp_drchlt[i] = domain_drchlt.quantities['stage'].centroid_values[
2]
#domain_drchlt.write_time()
#print domain_fbound.quantities['stage'].vertex_values
#print domain_drchlt.quantities['stage'].vertex_values
assert num.allclose(temp_fbound,
temp_drchlt), temp_fbound - temp_drchlt
assert num.allclose(domain_fbound.quantities['stage'].vertex_values,
domain_drchlt.quantities['stage'].vertex_values)
assert num.allclose(
domain_fbound.quantities['xmomentum'].vertex_values,
domain_drchlt.quantities['xmomentum'].vertex_values)
assert num.allclose(
domain_fbound.quantities['ymomentum'].vertex_values,
domain_drchlt.quantities['ymomentum'].vertex_values)
if not sys.platform == 'win32':
if myid == 0: os.remove(sts_file + '.sts')
if myid == 0: os.remove(meshname)
def test_create_mesh_with_interior_holes(self):
# These are the absolute values
polygon = [[100,100], [1000,100], [1000,1000], [100,1000]]
interior_poly1 = [[101,101],[200,200], [101,200]]
interior_poly2 = [[300,300],[500,500], [400,200]]
boundary_tags = {'walls': [0,1], 'bom': [2,3]}
# This should work with one hole
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_holes=[interior_poly1])
self.assertTrue(len(m.getUserSegments()) == 7, 'FAILED!')
self.assertTrue(len(m.userVertices) == 7, 'FAILED!')
# This should work with two holes
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_holes=[interior_poly1, interior_poly2])
#print len(m.getUserSegments())
#print len(m.userVertices)
self.assertTrue(len(m.getUserSegments()) == 10, 'FAILED!')
self.assertTrue(len(m.userVertices) == 10, 'FAILED!')
#-------------------------------------
# Error testing
#-------------------------------------
# try passing just one polygon, not a list of polygons, should throw exception
try:
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_holes=interior_poly1)
except:
pass
else:
msg = 'Passing a single polygon should have raised an error '
raise Exception, msg
# interior polygon outside bounding polygon, should throw exception
interior_poly3 = [[50,50],[500,500], [400,200]]
try:
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_holes=[interior_poly3])
except:
pass
else:
msg = 'Passing a single polygon should have raised an error '
raise Exception, msg
def test_create_mesh_from_regions_interior_regions1(self):
'''Test that create_mesh_from_regions fails
when an interior region is outside bounding polygon.
'''
# These are the values
d0 = [310000, 7690000]
d1 = [280000, 7690000]
d2 = [270000, 7645000]
d3 = [240000, 7625000]
d4 = [270000, 7580000]
d5 = [300000, 7590000]
d6 = [340000, 7610000]
poly_all = [d0, d1, d2, d3, d4, d5, d6]
i0 = [304000, 7607000]
i1 = [302000, 7605000]
i2 = [304000, 7603000]
i3 = [307000, 7602000]
i4 = [309000, 7603000]
# i4 = [310000, 7580000]
i5 = [307000, 7606000]
poly_onslow = [i0, i1, i2, i3, i4, i5]
# Thevenard Island
j0 = [294000, 7629000]
j1 = [285000, 7625000]
j2 = [294000, 7621000]
j3 = [299000, 7625000]
poly_thevenard = [j0, j1, j2, j3]
# med res around onslow
l0 = [300000, 7610000]
l1 = [285000, 7600000]
l2 = [300000, 7597500]
l3 = [310000, 7770000] # this one is outside
# l3 = [310000, 7630000] # this one is NOT outside
l4 = [315000, 7610000]
poly_coast = [l0, l1, l2, l3, l4]
# general coast and local area to onslow region
m0 = [270000, 7581000]
m1 = [300000, 7591000]
m2 = [339000, 7610000]
m3 = [330000, 7630000]
m4 = [290000, 7640000]
m5 = [260000, 7600000]
poly_region = [m0, m1, m2, m3, m4, m5]
# This one sticks outside bounding polygon - should fail
interior_regions = [[poly_onslow, 50000], [poly_region, 50000],
[poly_coast, 100000], [poly_thevenard, 100000]]
boundary_tags = {'walls': [0, 1], 'bom': [2]}
try:
m = create_mesh_from_regions(poly_all,
boundary_tags,
10000000,
interior_regions=interior_regions,
verbose=False)
except:
pass
else:
msg = 'Interior polygon sticking outside bounding polygon should '
msg += 'cause an Exception to be raised'
raise_(Exception, msg)
def test_create_mesh_from_regions_with_caching(self):
x=-500
y=-1000
mesh_geo = geo_reference=Geo_reference(56, x, y)
# These are the absolute values
polygon_absolute = [[0,0], [100,0], [100,100], [0,100]]
x_p = -10
y_p = -40
geo_ref_poly = Geo_reference(56, x_p, y_p)
polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
boundary_tags = {'walls': [0,1], 'bom': [2,3]}
inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]]
inner1_polygon = geo_ref_poly.\
change_points_geo_ref(inner1_polygon_absolute)
inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]]
inner2_polygon = geo_ref_poly.\
change_points_geo_ref(inner2_polygon_absolute)
interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
interior_holes = None
# Clear cache first
from anuga.caching import cache
cache(_create_mesh_from_regions,
(polygon, boundary_tags),
{'minimum_triangle_angle': 28.0,
'maximum_triangle_area': 10000000,
'interior_regions': interior_regions,
'interior_holes': interior_holes,
'poly_geo_reference': geo_ref_poly,
'mesh_geo_reference': mesh_geo,
'verbose': False},
verbose=False,
clear=1)
m = create_mesh_from_regions(polygon,
boundary_tags,
maximum_triangle_area=10000000,
interior_regions=interior_regions,
poly_geo_reference=geo_ref_poly,
mesh_geo_reference=mesh_geo,
verbose=False,
use_cache=True)
# Test the mesh instance
self.assertTrue(len(m.regions)==3, 'FAILED!')
segs = m.getUserSegments()
self.assertTrue(len(segs)==12, 'FAILED!')
self.assertTrue(len(m.userVertices)==12, 'FAILED!')
self.assertTrue(segs[0].tag=='walls', 'FAILED!')
self.assertTrue(segs[1].tag=='walls', 'FAILED!')
self.assertTrue(segs[2].tag=='bom', 'FAILED!')
self.assertTrue(segs[3].tag=='bom', 'FAILED!')
# Assuming the order of the region points is known.
# (This isn't true, if you consider create_mesh_from_regions
# a black box)
poly_point = m.getRegions()[0]
# poly_point values are relative to the mesh geo-ref
# make them absolute
self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y],
polygon_absolute,
closed=False),
'FAILED!')
# Assuming the order of the region points is known.
# (This isn't true, if you consider create_mesh_from_regions
# a black box)
poly_point = m.getRegions()[1]
# poly_point values are relative to the mesh geo-ref
# make them absolute
self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y],
inner1_polygon_absolute,
closed=False),
'FAILED!')
# Assuming the order of the region points is known.
# (This isn't true, if you consider create_mesh_from_regions
# a black box)
poly_point = m.getRegions()[2]
# poly_point values are relative to the mesh geo-ref
# make them absolute
self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y],
inner2_polygon_absolute,
closed=False),
'FAILED!')
# Now create m using cached values
m_cache = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions,
poly_geo_reference=geo_ref_poly,
mesh_geo_reference=mesh_geo,
verbose=False,
use_cache=True)
def test_file_boundary_stsIV_sinewave_ordering(self):
"""test_file_boundary_stsIV_sinewave_ordering(self):
Read correct points from ordering file and apply sts to boundary
This one uses a sine wave and compares to time boundary
"""
lat_long_points=[[6.01, 97.0], [6.02, 97.0], [6.05, 96.9], [6.0, 97.0]]
bounding_polygon=[[6.0, 97.0], [6.01, 97.0], [6.02,97.0], \
[6.02,97.02], [6.00,97.02]]
tide = 0.35
time_step_count = 50
time_step = 0.1
times_ref = num.arange(0, time_step_count*time_step, time_step)
n=len(lat_long_points)
first_tstep=num.ones(n,num.int)
last_tstep=(time_step_count)*num.ones(n,num.int)
gauge_depth=20*num.ones(n,num.float)
ha1=num.ones((n,time_step_count),num.float)
ua1=3.*num.ones((n,time_step_count),num.float)
va1=2.*num.ones((n,time_step_count),num.float)
for i in range(n):
ha1[i]=num.sin(times_ref)
base_name, files = self.write_mux2(lat_long_points,
time_step_count, time_step,
first_tstep, last_tstep,
depth=gauge_depth,
ha=ha1,
ua=ua1,
va=va1)
# Write order file
file_handle, order_base_name = tempfile.mkstemp("")
os.close(file_handle)
os.remove(order_base_name)
d=","
order_file=order_base_name+'order.txt'
fid=open(order_file,'w')
# Write Header
header='index, longitude, latitude\n'
fid.write(header)
indices=[3,0,1]
for i in indices:
line=str(i)+d+str(lat_long_points[i][1])+d+\
str(lat_long_points[i][0])+"\n"
fid.write(line)
fid.close()
sts_file=base_name
urs2sts(base_name, basename_out=sts_file,
ordering_filename=order_file,
mean_stage=tide,
verbose=False)
self.delete_mux(files)
# Now read the sts file and check that values have been stored correctly.
fid = NetCDFFile(sts_file + '.sts')
# Check the time vector
times = fid.variables['time'][:]
#print times
# Check sts quantities
stage = fid.variables['stage'][:]
xmomentum = fid.variables['xmomentum'][:]
ymomentum = fid.variables['ymomentum'][:]
elevation = fid.variables['elevation'][:]
# Create beginnings of boundary polygon based on sts_boundary
boundary_polygon = create_sts_boundary(base_name)
os.remove(order_file)
# Append the remaining part of the boundary polygon to be defined by
# the user
bounding_polygon_utm=[]
for point in bounding_polygon:
zone,easting,northing=redfearn(point[0],point[1])
bounding_polygon_utm.append([easting,northing])
boundary_polygon.append(bounding_polygon_utm[3])
boundary_polygon.append(bounding_polygon_utm[4])
#print 'boundary_polygon', boundary_polygon
plot=False
if plot:
from pylab import plot,show,axis
boundary_polygon=ensure_numeric(boundary_polygon)
bounding_polygon_utm=ensure_numeric(bounding_polygon_utm)
#plot(lat_long_points[:,0],lat_long_points[:,1],'o')
plot(boundary_polygon[:,0], boundary_polygon[:,1])
plot(bounding_polygon_utm[:,0],bounding_polygon_utm[:,1])
show()
assert num.allclose(bounding_polygon_utm,boundary_polygon)
extent_res=1000000
meshname = 'urs_test_mesh' + '.tsh'
interior_regions=None
boundary_tags={'ocean': [0,1], 'otherocean': [2,3,4]}
# have to change boundary tags from last example because now bounding
# polygon starts in different place.
create_mesh_from_regions(boundary_polygon,
boundary_tags=boundary_tags,
maximum_triangle_area=extent_res,
filename=meshname,
interior_regions=interior_regions,
verbose=False)
domain_fbound = Domain(meshname)
domain_fbound.set_quantity('stage', tide)
Bf = File_boundary(sts_file+'.sts',
domain_fbound,
boundary_polygon=boundary_polygon)
Br = Reflective_boundary(domain_fbound)
domain_fbound.set_boundary({'ocean': Bf,'otherocean': Br})
finaltime=time_step*(time_step_count-1)
yieldstep=time_step
temp_fbound=num.zeros(int(finaltime/yieldstep)+1,num.float)
for i, t in enumerate(domain_fbound.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step=False)):
temp_fbound[i]=domain_fbound.quantities['stage'].centroid_values[2]
domain_time = Domain(meshname)
domain_time.set_quantity('stage', tide)
Br = Reflective_boundary(domain_time)
Bw = Time_boundary(domain=domain_time,
function=lambda t: [num.sin(t)+tide,3.*(20.+num.sin(t)+tide),2.*(20.+num.sin(t)+tide)])
domain_time.set_boundary({'ocean': Bw,'otherocean': Br})
temp_time=num.zeros(int(finaltime/yieldstep)+1,num.float)
domain_time.set_starttime(domain_fbound.get_starttime())
for i, t in enumerate(domain_time.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step=False)):
temp_time[i]=domain_time.quantities['stage'].centroid_values[2]
assert num.allclose(temp_fbound, temp_time)
assert num.allclose(domain_fbound.quantities['stage'].vertex_values,
domain_time.quantities['stage'].vertex_values)
assert num.allclose(domain_fbound.quantities['xmomentum'].vertex_values,
domain_time.quantities['xmomentum'].vertex_values)
assert num.allclose(domain_fbound.quantities['ymomentum'].vertex_values,
domain_time.quantities['ymomentum'].vertex_values)
try:
os.remove(sts_file+'.sts')
except:
# Windoze can't remove this file for some reason
pass
os.remove(meshname)
def sequential_time_varying_file_boundary_sts(self):
"""sequential_ltest_time_varying_file_boundary_sts_sequential(self):
Read correct points from ordering file and apply sts to boundary. The boundary is time varying. FIXME add to test_urs2sts.
"""
lat_long_points=[[6.01,97.0],[6.02,97.0],[6.05,96.9],[6.0,97.0]]
bounding_polygon=[[6.0,97.0],[6.01,97.0],[6.02,97.0],
[6.02,97.02],[6.00,97.02]]
tide = 3.0
time_step_count = 65
time_step = 2.
n=len(lat_long_points)
first_tstep=num.ones(n,num.int)
last_tstep=(time_step_count)*num.ones(n,num.int)
finaltime=num.float(time_step*(time_step_count-1))
yieldstep=num.float(time_step)
gauge_depth=20*num.ones(n,num.float)
ha=2*num.ones((n,time_step_count),num.float)
ua=10*num.ones((n,time_step_count),num.float)
va=-10*num.ones((n,time_step_count),num.float)
times=num.arange(0., num.float(time_step_count*time_step), time_step)
for i in range(n):
#ha[i]+=num.sin(times)
ha[i]+=times/finaltime
sts_file="test"
if myid==0:
base_name, files = self.write_mux2(lat_long_points,
time_step_count,
time_step,
first_tstep,
last_tstep,
depth=gauge_depth,
ha=ha,
ua=ua,
va=va)
# base name will not exist, but 3 other files are created
# Write order file
file_handle, order_base_name = tempfile.mkstemp("")
os.close(file_handle)
os.remove(order_base_name)
d=","
order_file=order_base_name+'order.txt'
fid=open(order_file,'w')
# Write Header
header='index, longitude, latitude\n'
fid.write(header)
indices=[3,0,1]
for i in indices:
line=str(i)+d+str(lat_long_points[i][1])+d+\
str(lat_long_points[i][0])+"\n"
fid.write(line)
fid.close()
urs2sts(base_name,
basename_out=sts_file,
ordering_filename=order_file,
mean_stage=tide,
verbose=verbose)
self.delete_mux(files)
assert(os.access(sts_file+'.sts', os.F_OK))
os.remove(order_file)
barrier()
boundary_polygon = create_sts_boundary(sts_file)
# Append the remaining part of the boundary polygon to be defined by
# the user
bounding_polygon_utm=[]
for point in bounding_polygon:
zone,easting,northing=redfearn(point[0],point[1])
bounding_polygon_utm.append([easting,northing])
boundary_polygon.append(bounding_polygon_utm[3])
boundary_polygon.append(bounding_polygon_utm[4])
assert num.allclose(bounding_polygon_utm,boundary_polygon)
extent_res=1000000
meshname = 'urs_test_mesh' + '.tsh'
interior_regions=None
boundary_tags={'ocean': [0,1], 'otherocean': [2,3,4]}
# have to change boundary tags from last example because now bounding
# polygon starts in different place.
if myid==0:
create_mesh_from_regions(boundary_polygon,
boundary_tags=boundary_tags,
maximum_triangle_area=extent_res,
filename=meshname,
interior_regions=interior_regions,
verbose=verbose)
barrier()
domain_fbound = Domain(meshname)
domain_fbound.set_quantities_to_be_stored(None)
domain_fbound.set_quantity('stage', tide)
if verbose: print "Creating file boundary condition"
Bf = File_boundary(sts_file+'.sts',
domain_fbound,
boundary_polygon=boundary_polygon)
Br = Reflective_boundary(domain_fbound)
domain_fbound.set_boundary({'ocean': Bf,'otherocean': Br})
temp_fbound=num.zeros(int(finaltime/yieldstep)+1,num.float)
if verbose: print "Evolving domain with file boundary condition"
for i, t in enumerate(domain_fbound.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step = False)):
temp_fbound[i]=domain_fbound.quantities['stage'].centroid_values[2]
if verbose: domain_fbound.write_time()
domain_drchlt = Domain(meshname)
domain_drchlt.set_quantities_to_be_stored(None)
domain_drchlt.set_starttime(time_step)
domain_drchlt.set_quantity('stage', tide)
Br = Reflective_boundary(domain_drchlt)
#Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide])
Bd = Time_boundary(domain=domain_drchlt, f=lambda t: [2.0+t/finaltime+tide,220.+10.*tide+10.*t/finaltime,-220.-10.*tide-10.*t/finaltime])
#Bd = Time_boundary(domain=domain_drchlt,f=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)])
domain_drchlt.set_boundary({'ocean': Bd,'otherocean': Br})
temp_drchlt=num.zeros(int(finaltime/yieldstep)+1,num.float)
for i, t in enumerate(domain_drchlt.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step = False)):
temp_drchlt[i]=domain_drchlt.quantities['stage'].centroid_values[2]
#domain_drchlt.write_time()
#print domain_fbound.quantities['stage'].vertex_values
#print domain_drchlt.quantities['stage'].vertex_values
assert num.allclose(temp_fbound,temp_drchlt),temp_fbound-temp_drchlt
assert num.allclose(domain_fbound.quantities['stage'].vertex_values,
domain_drchlt.quantities['stage'].vertex_values)
assert num.allclose(domain_fbound.quantities['xmomentum'].vertex_values,
domain_drchlt.quantities['xmomentum'].vertex_values)
assert num.allclose(domain_fbound.quantities['ymomentum'].vertex_values,
domain_drchlt.quantities['ymomentum'].vertex_values)
if not sys.platform == 'win32':
if myid==0: os.remove(sts_file+'.sts')
if myid==0: os.remove(meshname)
def parallel_time_varying_file_boundary_sts(self):
""" parallel_test_time_varying_file_boundary_sts_sequential(self):
Read correct points from ordering file and apply sts to boundary.
The boundary is time varying. Compares sequential result with
distributed result found using anuga_parallel
"""
#------------------------------------------------------------
# Define test variables
#------------------------------------------------------------
lat_long_points=[[6.01,97.0],[6.02,97.0],[6.05,96.9],[6.0,97.0]]
bounding_polygon=[[6.0,97.0],[6.01,97.0],[6.02,97.0],
[6.02,97.02],[6.00,97.02]]
tide = 3.0
time_step_count = 65
time_step = 2
n=len(lat_long_points)
first_tstep=num.ones(n,num.int)
last_tstep=(time_step_count)*num.ones(n,num.int)
finaltime=num.float(time_step*(time_step_count-1))
yieldstep=num.float(time_step)
gauge_depth=20*num.ones(n,num.float)
ha=2*num.ones((n,time_step_count),num.float)
ua=10*num.ones((n,time_step_count),num.float)
va=-10*num.ones((n,time_step_count),num.float)
times=num.arange(0, time_step_count*time_step, time_step)
for i in range(n):
#ha[i]+=num.sin(times)
ha[i]+=times/finaltime
#------------------------------------------------------------
# Write mux data to file then convert to sts format
#------------------------------------------------------------
sts_file="test"
if myid==0:
base_name, files = self.write_mux2(lat_long_points,
time_step_count,
time_step,
first_tstep,
last_tstep,
depth=gauge_depth,
ha=ha,
ua=ua,
va=va)
# base name will not exist, but 3 other files are created
# Write order file
file_handle, order_base_name = tempfile.mkstemp("")
os.close(file_handle)
os.remove(order_base_name)
d=","
order_file=order_base_name+'order.txt'
fid=open(order_file,'w')
# Write Header
header='index, longitude, latitude\n'
fid.write(header)
indices=[3,0,1]
for i in indices:
line=str(i)+d+str(lat_long_points[i][1])+d+\
str(lat_long_points[i][0])+"\n"
fid.write(line)
fid.close()
urs2sts(base_name,
basename_out=sts_file,
ordering_filename=order_file,
mean_stage=tide,
verbose=verbose)
self.delete_mux(files)
assert(os.access(sts_file+'.sts', os.F_OK))
os.remove(order_file)
barrier()
#------------------------------------------------------------
# Define boundary_polygon on each processor. This polygon defines the
# urs boundary and lies on a portion of the bounding_polygon
#------------------------------------------------------------
boundary_polygon = create_sts_boundary(sts_file)
# Append the remaining part of the boundary polygon to be defined by
# the user
bounding_polygon_utm=[]
for point in bounding_polygon:
zone,easting,northing=redfearn(point[0],point[1])
bounding_polygon_utm.append([easting,northing])
boundary_polygon.append(bounding_polygon_utm[3])
boundary_polygon.append(bounding_polygon_utm[4])
assert num.allclose(bounding_polygon_utm,boundary_polygon)
extent_res=10000
meshname = 'urs_test_mesh' + '.tsh'
interior_regions=None
boundary_tags={'ocean': [0,1], 'otherocean': [2,3,4]}
#------------------------------------------------------------
# Create mesh on the master processor and store in file. This file
# is read in by each slave processor when needed
#------------------------------------------------------------
if myid==0:
create_mesh_from_regions(boundary_polygon,
boundary_tags=boundary_tags,
maximum_triangle_area=extent_res,
filename=meshname,
interior_regions=interior_regions,
verbose=verbose)
# barrier()
domain_fbound = Domain(meshname)
domain_fbound.set_quantities_to_be_stored(None)
domain_fbound.set_quantity('stage', tide)
# print domain_fbound.mesh.get_boundary_polygon()
else:
domain_fbound=None
barrier()
if ( verbose and myid == 0 ):
print 'DISTRIBUTING PARALLEL DOMAIN'
domain_fbound = distribute(domain_fbound)
#--------------------------------------------------------------------
# Find which sub_domain in which the interpolation points are located
#
# Sometimes the interpolation points sit exactly
# between two centroids, so in the parallel run we
# reset the interpolation points to the centroids
# found in the sequential run
#--------------------------------------------------------------------
interpolation_points = [[279000,664000], [280250,664130],
[279280,665400], [280500,665000]]
interpolation_points=num.array(interpolation_points)
#if myid==0:
# import pylab as P
# boundary_polygon=num.array(boundary_polygon)
# P.plot(boundary_polygon[:,0],boundary_polygon[:,1])
# P.plot(interpolation_points[:,0],interpolation_points[:,1],'ko')
# P.show()
fbound_gauge_values = []
fbound_proc_tri_ids = []
for i, point in enumerate(interpolation_points):
fbound_gauge_values.append([]) # Empty list for timeseries
try:
k = domain_fbound.get_triangle_containing_point(point)
if domain_fbound.tri_full_flag[k] == 1:
fbound_proc_tri_ids.append(k)
else:
fbound_proc_tri_ids.append(-1)
except:
fbound_proc_tri_ids.append(-2)
if verbose: print 'P%d has points = %s' %(myid, fbound_proc_tri_ids)
#------------------------------------------------------------
# Set boundary conditions
#------------------------------------------------------------
Bf = File_boundary(sts_file+'.sts',
domain_fbound,
boundary_polygon=boundary_polygon)
Br = Reflective_boundary(domain_fbound)
domain_fbound.set_boundary({'ocean': Bf,'otherocean': Br})
#------------------------------------------------------------
# Evolve the domain on each processor
#------------------------------------------------------------
for i, t in enumerate(domain_fbound.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step = False)):
stage = domain_fbound.get_quantity('stage')
for i in range(4):
if fbound_proc_tri_ids[i] > -1:
fbound_gauge_values[i].append(stage.centroid_values[fbound_proc_tri_ids[i]])
#------------------------------------------------------------
# Create domain to be run sequntially on each processor
#------------------------------------------------------------
domain_drchlt = Domain(meshname)
domain_drchlt.set_quantities_to_be_stored(None)
domain_drchlt.set_starttime(time_step)
domain_drchlt.set_quantity('stage', tide)
Br = Reflective_boundary(domain_drchlt)
#Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide])
Bd = Time_boundary(domain=domain_drchlt, function=lambda t: [2.0+t/finaltime+tide,220.+10.*tide+10.*t/finaltime,-220.-10.*tide-10.*t/finaltime])
#Bd = Time_boundary(domain=domain_drchlt,function=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)])
domain_drchlt.set_boundary({'ocean': Bd,'otherocean': Br})
drchlt_gauge_values = []
drchlt_proc_tri_ids = []
for i, point in enumerate(interpolation_points):
drchlt_gauge_values.append([]) # Empty list for timeseries
try:
k = domain_drchlt.get_triangle_containing_point(point)
if domain_drchlt.tri_full_flag[k] == 1:
drchlt_proc_tri_ids.append(k)
else:
drchlt_proc_tri_ids.append(-1)
except:
drchlt_proc_tri_ids.append(-2)
if verbose: print 'P%d has points = %s' %(myid, drchlt_proc_tri_ids)
#------------------------------------------------------------
# Evolve entire domain on each processor
#------------------------------------------------------------
for i, t in enumerate(domain_drchlt.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step = False)):
stage = domain_drchlt.get_quantity('stage')
for i in range(4):
drchlt_gauge_values[i].append(stage.centroid_values[drchlt_proc_tri_ids[i]])
#------------------------------------------------------------
# Compare sequential values with parallel values
#------------------------------------------------------------
barrier()
success = True
for i in range(4):
if fbound_proc_tri_ids[i] > -1:
fbound_gauge_values[i]=num.array(fbound_gauge_values[i])
drchlt_gauge_values[i]=num.array(drchlt_gauge_values[i])
#print i,fbound_gauge_values[i][4]
#print i,drchlt_gauge_values[i][4]
success = success and num.allclose(fbound_gauge_values[i], drchlt_gauge_values[i])
assert success#, (fbound_gauge_values[i]-drchlt_gauge_values[i])
#assert_(success)
if not sys.platform == 'win32':
if myid==0: os.remove(sts_file+'.sts')
if myid==0: os.remove(meshname)
def test_create_mesh_from_regions(self):
x=-500
y=-1000
mesh_geo = geo_reference=Geo_reference(56, x, y)
# These are the absolute values
polygon_absolute = [[0,0], [100,0], [100,100], [0,100]]
x_p = -10
y_p = -40
geo_ref_poly = Geo_reference(56, x_p, y_p)
polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
boundary_tags = {'walls': [0,1], 'bom': [2,3]}
inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]]
inner1_polygon = geo_ref_poly.\
change_points_geo_ref(inner1_polygon_absolute)
inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]]
inner2_polygon = geo_ref_poly.\
change_points_geo_ref(inner2_polygon_absolute)
interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
m = create_mesh_from_regions(polygon,
boundary_tags,
10000000,
interior_regions=interior_regions,
poly_geo_reference=geo_ref_poly,
mesh_geo_reference=mesh_geo)
# Test the mesh instance
self.assertTrue(len(m.regions)==3, 'FAILED!')
segs = m.getUserSegments()
self.assertTrue(len(segs)==12, 'FAILED!')
self.assertTrue(len(m.userVertices)==12, 'FAILED!')
self.assertTrue(segs[0].tag=='walls', 'FAILED!')
self.assertTrue(segs[1].tag=='walls', 'FAILED!')
self.assertTrue(segs[2].tag=='bom', 'FAILED!')
self.assertTrue(segs[3].tag=='bom', 'FAILED!')
# Assuming the order of the region points is known.
# (This isn't true, if you consider create_mesh_from_regions
# a black box)
poly_point = m.getRegions()[0]
# poly_point values are relative to the mesh geo-ref
# make them absolute
msg = ('Expected point (%s,%s) to be inside polygon %s'
% (str(poly_point.x+x), str(poly_point.y+y),
str(polygon_absolute)))
self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y],
polygon_absolute, closed=False),
msg)
# Assuming the order of the region points is known.
# (This isn't true, if you consider create_mesh_from_regions
# a black box)
poly_point = m.getRegions()[1]
# poly_point values are relative to the mesh geo-ref
# make them absolute
self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y],
inner1_polygon_absolute,
closed=False),
'FAILED!')
# Assuming the order of the region points is known.
# (This isn't true, if you consider create_mesh_from_regions
# a black box)
poly_point = m.getRegions()[2]
# poly_point values are relative to the mesh geo-ref
# make them absolute
self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y],
inner2_polygon_absolute,
closed=False),
'FAILED!')
'side1':[1],
'side2':[2],
'top':[3],
'side3':[4],
'side4':[5]}
"""
Create the domain
"""
evolved_quantities = ['stage', 'xmomentum', 'ymomentum', 'concentration']
from anuga.pmesh.mesh_interface import create_mesh_from_regions
create_mesh_from_regions(bounding_polygon = bounding_polygon,
boundary_tags = boundary_tags,
maximum_triangle_area = 200,
filename = filename_root + '.msh')
domain = Domain(filename_root + '.msh', evolved_quantities = evolved_quantities)
#------------------------------------------------------------------------------
# Setup parameters of computational domain
#------------------------------------------------------------------------------
# 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_quantity('elevation',
