def test_unequal_lines(self): test_path = aust.get_pathname_from_package('anuga.lib.tests') in_file = os.path.join(test_path, 'test1.asc') expected_file = os.path.join(test_path, 'test1_bad_num_lines.asc') self.assertRaises(RuntimeError, MaxAsc, 'test.out.asc', [in_file, expected_file])
def setUp(self): path = get_pathname_from_package('anuga.structures') self.input_hecras_file = os.path.join(path, 'tests', 'data', 'hecras_bridge_table.csv') return
def test_different_input2(self): test_path = aust.get_pathname_from_package('anuga.lib.tests') in_file = os.path.join(test_path, 'test1.asc') in_file2 = os.path.join(test_path, 'test2.asc') expected_file = os.path.join(test_path, 'test2.expected.asc') MaxAsc('test2.out.asc', [in_file, in_file2]) self.assertTrue(FilesEqual('test2.out.asc', expected_file))
def test_inlet_variable_Q(self): """test_inlet_Q This tests that the inlet operator adds the correct amount of water """ stage_0 = 11.0 stage_1 = 10.0 elevation_0 = 10.0 elevation_1 = 10.0 domain_length = 200.0 domain_width = 200.0 domain = self._create_domain(d_length=domain_length, d_width=domain_width, dx=10.0, dy=10.0, elevation_0=elevation_0, elevation_1=elevation_1, stage_0=stage_0, stage_1=stage_1) vol0 = domain.compute_total_volume() finaltime = 3.0 #Make sure we are inthe right directory to find the #time series data for the inlets import os path = get_pathname_from_package('anuga.structures') filename1 = os.path.join(path, 'tests', 'data', 'inlet_operator_test1.tms') filename2 = os.path.join(path, 'tests', 'data', 'inlet_operator_test2.tms') line1 = [[95.0, 10.0], [105.0, 10.0]] Q1 = file_function(filename=filename1, quantities=['hydrograph']) line2 = [[10.0, 90.0], [20.0, 90.0]] Q2 = file_function(filename=filename2, quantities=['hydrograph']) Inlet_operator(domain, line1, Q1) Inlet_operator(domain, line2, Q2) for t in domain.evolve(yieldstep=1.0, finaltime=finaltime): #domain.write_time() #print domain.volumetric_balance_statistics() pass vol1 = domain.compute_total_volume() #print vol1-vol0 assert numpy.allclose(13.5, vol1 - vol0, rtol=1.0e-8) assert numpy.allclose(vol1 - vol0, domain.fractional_step_volume_integral, rtol=1.0e-8)
def test_inlet_variable_Q(self): """test_inlet_Q This tests that the inlet operator adds the correct amount of water """ stage_0 = 11.0 stage_1 = 10.0 elevation_0 = 10.0 elevation_1 = 10.0 domain_length = 200.0 domain_width = 200.0 domain = self._create_domain(d_length=domain_length, d_width=domain_width, dx = 10.0, dy = 10.0, elevation_0 = elevation_0, elevation_1 = elevation_1, stage_0 = stage_0, stage_1 = stage_1) vol0 = domain.compute_total_volume() finaltime = 3.0 #Make sure we are inthe right directory to find the #time series data for the inlets import os path = get_pathname_from_package('anuga.structures') filename1 = os.path.join(path, 'tests', 'data', 'inlet_operator_test1.tms') filename2 = os.path.join(path, 'tests', 'data', 'inlet_operator_test2.tms') line1 = [[95.0, 10.0], [105.0, 10.0]] Q1 = file_function(filename=filename1, quantities=['hydrograph']) line2 = [[10.0, 90.0], [20.0, 90.0]] Q2 = file_function(filename=filename2, quantities=['hydrograph']) Inlet_operator(domain, line1, Q1) Inlet_operator(domain, line2, Q2) for t in domain.evolve(yieldstep = 1.0, finaltime = finaltime): #domain.write_time() #print domain.volumetric_balance_statistics() pass vol1 = domain.compute_total_volume() #print vol1-vol0 assert numpy.allclose(13.5, vol1-vol0, rtol=1.0e-8) assert numpy.allclose(vol1-vol0, domain.fractional_step_volume_integral, rtol=1.0e-8)
def test_csv2polygons_with_clipping(self): """test_csv2polygons with optional clipping """ #FIXME(Ole): Not Done!! path = get_pathname_from_package('anuga.shallow_water') testfile = os.path.join(path, 'tests', 'data', 'polygon_values_example.csv') polygons, values = load_csv_as_polygons(testfile, value_name='floors', clipping_polygons=None) assert len(polygons) == 7, 'Must have seven polygons' assert len(values) == 7, 'Must have seven values' # Known floor values floors = {'1': 2, '2': 0, '3': 1, '4': 2, '5': 0, '8': 1, '9': 1} # Known polygon values known_polys = { '1': [[422681.61, 871117.55], [422691.02, 871117.60], [422690.87, 871084.23], [422649.36, 871081.85], [422649.36, 871080.39], [422631.86, 871079.50], [422631.72, 871086.75], [422636.75, 871087.20], [422636.75, 871091.50], [422649.66, 871092.09], [422649.83, 871084.91], [422652.94, 871084.90], [422652.84, 871092.39], [422681.83, 871093.73], [422681.61, 871117.55]], '2': [[422664.22, 870785.46], [422672.48, 870780.14], [422668.17, 870772.62], [422660.35, 870777.17], [422664.22, 870785.46]], '3': [[422661.30, 871215.06], [422667.50, 871215.70], [422668.30, 871204.86], [422662.21, 871204.33], [422661.30, 871215.06]], '4': [[422473.44, 871191.22], [422478.33, 871192.26], [422479.52, 871186.03], [422474.78, 871185.14], [422473.44, 871191.22]], '5': [[422369.69, 871049.29], [422378.63, 871053.58], [422383.91, 871044.51], [422374.97, 871040.32], [422369.69, 871049.29]], '8': [[422730.56, 871203.13], [422734.10, 871204.90], [422735.26, 871202.18], [422731.87, 871200.58], [422730.56, 871203.13]], '9': [[422659.85, 871213.80], [422660.91, 871210.97], [422655.42, 871208.85], [422654.36, 871211.68], [422659.85, 871213.80]] } for id in ['1', '2', '3', '4', '5', '8', '9']: assert id in list(polygons.keys()) assert id in list(values.keys()) assert int(values[id]) == int(floors[id]) assert len(polygons[id]) == len(known_polys[id]) assert num.allclose(polygons[id], known_polys[id])
def test_run_via_commandline(self): """ Make sure that the python file functions as a command-line tool. """ # Look for script in same dir as this unit test. path = os.path.dirname( os.path.realpath( __file__ ) ) path = get_pathname_from_package( 'anuga.file_conversion' ) cmd = 'python ' + os.path.join( path, 'csv2sts.py') + ' --latitude ' cmd += '%s --lon %s %s %s' % (str(lat), str(lon), testfile_csv, sts_out) os.system(cmd) self._check_generated_sts()
def test_against_octave_code(self): # This test runs a test case from # DENYS DUTYKH , DIMITRIOS MITSOTAKIS, XAVIER GARDEIL, AND FREDERIC DIAS # ON THE USE OF THE FINITE FAULT SOLUTION FOR TSUNAMI # GENERATION PROBLEMS # The copy I have seems to be a pre-print, not sure of the journal # We compare the results of our code with another code written purely in matlab # This code is by 'Francois Beauducel', and was obtained from matlab central (July 2012) # See: http://www.mathworks.com/matlabcentral/fileexchange/25982 slip = 2.5 rake = 95. dis1 = slip * numpy.cos(rake / 180. * numpy.pi) dis2 = slip * numpy.sin(rake / 180. * numpy.pi) strike = 289. dip = 10. length = 80.9 width = 40.0 focal_depth = 20. depth = focal_depth + width / 2.0 * numpy.sin( dip / 180. * numpy.pi) # T source = numpy.array( [0., 0., depth, strike, dip, length, width, dis1, dis2, 0.0]) tsunami_fun = okada_tsunami.earthquake_source(source=source, verbose=False) # Make a grid mygrid = numpy.lib.index_tricks.nd_grid() grid_width = 400000 n = 101 grid2 = mygrid[0:grid_width:(n * 1j), 0:grid_width:(n * 1j)] # Centre grid x = (grid2[0, :, :].reshape((n * n)) - grid_width / 2.) y = (grid2[1, :, :].reshape((n * n)) - grid_width / 2.) eq_source = tsunami_fun(x, y) ## Now read the same event from an octave code, which is completely ## independent of this one (i.e. they don't call okada's fortran) path = get_pathname_from_package('anuga.tsunami_source') octave = numpy.genfromtxt(path + sep + 'tests' + sep + 'okada_tsunami_octave_95.txt') octave_asvec = numpy.transpose(octave).reshape((1, 101 * 101)) # Estimate the differences between the 2 codes assert (abs(octave_asvec - eq_source)).max() < 1.0e-04
def test_nonstandard_meridian(self): """test_nonstandard_meridian This test will verify that redfearn can be used to project points using an arbitrary central meridian. """ # The file projection_test_points.csv contains 10 points # which straddle the boundary between UTM zones 53 and 54. # They have been projected using a central meridian of 137.5 # degrees (the boundary is 138 so it is pretty much right # in the middle of zones 53 and 54). path = get_pathname_from_package('anuga.coordinate_transforms') datafile = join(path, 'tests', 'data', 'projection_test_points.csv') fid = open(datafile) for line in fid.readlines()[1:]: fields = line.strip().split(',') lon = float(fields[1]) lat = float(fields[2]) x = float(fields[3]) y = float(fields[4]) zone, easting, northing = redfearn(lat, lon, central_meridian=137.5, scale_factor=0.9996) assert zone == -1 # Indicates non UTM projection assert num.allclose(x, easting) assert num.allclose(y, northing) # Test that zone and meridian can't both be specified try: zone, easting, northing = redfearn(lat, lon, zone=50, central_meridian=137.5) except: pass else: msg = 'Should have raised exception' raise Exception, msg
def test_against_octave_code(self): # This test runs a test case from # DENYS DUTYKH , DIMITRIOS MITSOTAKIS, XAVIER GARDEIL, AND FREDERIC DIAS # ON THE USE OF THE FINITE FAULT SOLUTION FOR TSUNAMI # GENERATION PROBLEMS # The copy I have seems to be a pre-print, not sure of the journal # We compare the results of our code with another code written purely in matlab # This code is by 'Francois Beauducel', and was obtained from matlab central (July 2012) # See: http://www.mathworks.com/matlabcentral/fileexchange/25982 slip = 2.5 rake = 95.0 dis1 = slip * numpy.cos(rake / 180.0 * numpy.pi) dis2 = slip * numpy.sin(rake / 180.0 * numpy.pi) strike = 289.0 dip = 10.0 length = 80.9 width = 40.0 focal_depth = 20.0 depth = focal_depth + width / 2.0 * numpy.sin(dip / 180.0 * numpy.pi) # T source = numpy.array([0.0, 0.0, depth, strike, dip, length, width, dis1, dis2, 0.0]) tsunami_fun = okada_tsunami.earthquake_source(source=source, verbose=False) # Make a grid mygrid = numpy.lib.index_tricks.nd_grid() grid_width = 400000 n = 101 grid2 = mygrid[0 : grid_width : (n * 1j), 0 : grid_width : (n * 1j)] # Centre grid x = grid2[0, :, :].reshape((n * n)) - grid_width / 2.0 y = grid2[1, :, :].reshape((n * n)) - grid_width / 2.0 eq_source = tsunami_fun(x, y) ## Now read the same event from an octave code, which is completely ## independent of this one (i.e. they don't call okada's fortran) path = get_pathname_from_package("anuga.tsunami_source") octave = numpy.genfromtxt(path + sep + "tests" + sep + "okada_tsunami_octave_95.txt") octave_asvec = numpy.transpose(octave).reshape((1, 101 * 101)) # Estimate the differences between the 2 codes assert (abs(octave_asvec - eq_source)).max() < 1.0e-04
def test_csv2building_polygons(self): """test_csv2building_polygons """ path = get_pathname_from_package('anuga.shallow_water') testfile = os.path.join(path, 'tests', 'data', 'polygon_values_example.csv') polygons, values = load_csv_as_building_polygons(testfile, floor_height=3) assert len(polygons) == 7, 'Must have seven polygons' assert len(values) == 7, 'Must have seven values' # Known floor values floors = {'1': 6, '2': 0, '3': 3, '4': 6, '5': 0, '8': 3, '9': 3} for id in ['1', '2', '3', '4', '5' ,'8' ,'9']: assert id in polygons.keys() assert id in values.keys() assert float(values[id]) == float(floors[id])
def test_nonstandard_meridian_coinciding_with_native(self): """test_nonstandard_meridian_coinciding_with_native This test will verify that redfearn can be used to project points using an arbitrary central meridian that happens to coincide with the standard meridian at the center of a UTM zone. This is a preliminary test before testing this functionality with a truly arbitrary non-standard meridian. """ # The file projection_test_points_z53.csv contains 10 points # which straddle the boundary between UTM zones 53 and 54. # They have been projected to zone 53 irrespective of where they # belong. path = get_pathname_from_package('anuga.coordinate_transforms') for forced_zone in [53, 54]: datafile = join(path, 'tests', 'data', 'projection_test_points_z%d.csv' % forced_zone) fid = open(datafile) for line in fid.readlines()[1:]: fields = line.strip().split(',') lon = float(fields[1]) lat = float(fields[2]) x = float(fields[3]) y = float(fields[4]) zone, easting, northing = redfearn(lat, lon, zone=forced_zone) # Check calculation assert zone == forced_zone assert num.allclose(x, easting) assert num.allclose(y, northing)
import numpy as num #from parallel_inlet_operator import Parallel_Inlet_operator from anuga.parallel import distribute, myid, numprocs, finalize from anuga.geometry.polygon import inside_polygon, is_inside_polygon, line_intersect #from parallel_operator_factory import Inlet_operator, Boyd_box_operator from anuga.utilities import parallel_abstraction as pypar import random """test_that_culvert_runs_rating This test exercises the culvert and checks values outside rating curve are dealt with """ verbose = False path = get_pathname_from_package('anuga.culvert_flows') length = 40. width = 15. dx = dy = 0.5 # Resolution: Length of subdivisions on both axes #---------------------------------------------------------------------- # Setup initial conditions #---------------------------------------------------------------------- def topography(x, y): """Set up a weir A culvert will connect either side
def test_predicted_boyd_flow(self): """test_predicted_boyd_flow Test that flows predicted by the boyd method are consistent with what what is calculated in engineering codes. The data was supplied by Petar Milevski """ # FIXME(Ole) this is nowhere near finished path = get_pathname_from_package('anuga.culvert_flows') length = 12. width = 5. dx = dy = 0.5 # Resolution: Length of subdivisions on both axes points, vertices, boundary = rectangular_cross(int(length / dx), int(width / dy), len1=length, len2=width) domain = anuga.Domain(points, vertices, boundary) domain.set_name('test_culvert') # Output name domain.set_default_order(2) #---------------------------------------------------------------------- # Setup initial conditions #---------------------------------------------------------------------- def topography(x, y): # General Slope of Topography z = -x / 10 return z domain.set_quantity('elevation', topography) domain.set_quantity('friction', 0.01) # Constant friction domain.set_quantity('stage', expression='elevation') Q0 = domain.get_quantity('stage') Q1 = Quantity(domain) # Add depths to stage head_water_depth = 0.169 tail_water_depth = 0.089 inlet_poly = [[0, 0], [6, 0], [6, 5], [0, 5]] outlet_poly = [[6, 0], [12, 0], [12, 5], [6, 5]] Q1.set_values( Polygon_function([(inlet_poly, head_water_depth), (outlet_poly, tail_water_depth)])) domain.set_quantity('stage', Q0 + Q1) culvert = Culvert_flow(domain, label='Test culvert', description='4 m test culvert', end_point0=[4.0, 2.5], end_point1=[8.0, 2.5], width=1.20, height=0.75, culvert_routine=boyd_generalised_culvert_model, number_of_barrels=1, verbose=False) domain.forcing_terms.append(culvert) # Call culvert(domain)
def test_csv2polygons_with_clipping(self): """test_csv2polygons with optional clipping """ #FIXME(Ole): Not Done!! path = get_pathname_from_package('anuga.shallow_water') testfile = os.path.join(path, 'tests', 'data', 'polygon_values_example.csv') polygons, values = load_csv_as_polygons(testfile, value_name='floors', clipping_polygons=None) assert len(polygons) == 7, 'Must have seven polygons' assert len(values) == 7, 'Must have seven values' # Known floor values floors = {'1': 2, '2': 0, '3': 1, '4': 2, '5': 0, '8': 1, '9': 1} # Known polygon values known_polys = {'1': [[422681.61,871117.55], [422691.02,871117.60], [422690.87,871084.23], [422649.36,871081.85], [422649.36,871080.39], [422631.86,871079.50], [422631.72,871086.75], [422636.75,871087.20], [422636.75,871091.50], [422649.66,871092.09], [422649.83,871084.91], [422652.94,871084.90], [422652.84,871092.39], [422681.83,871093.73], [422681.61,871117.55]], '2': [[422664.22,870785.46], [422672.48,870780.14], [422668.17,870772.62], [422660.35,870777.17], [422664.22,870785.46]], '3': [[422661.30,871215.06], [422667.50,871215.70], [422668.30,871204.86], [422662.21,871204.33], [422661.30,871215.06]], '4': [[422473.44,871191.22], [422478.33,871192.26], [422479.52,871186.03], [422474.78,871185.14], [422473.44,871191.22]], '5': [[422369.69,871049.29], [422378.63,871053.58], [422383.91,871044.51], [422374.97,871040.32], [422369.69,871049.29]], '8': [[422730.56,871203.13], [422734.10,871204.90], [422735.26,871202.18], [422731.87,871200.58], [422730.56,871203.13]], '9': [[422659.85,871213.80], [422660.91,871210.97], [422655.42,871208.85], [422654.36,871211.68], [422659.85,871213.80]] } for id in ['1', '2', '3', '4', '5' ,'8' ,'9']: assert id in polygons.keys() assert id in values.keys() assert int(values[id]) == int(floors[id]) assert len(polygons[id]) == len(known_polys[id]) assert num.allclose(polygons[id], known_polys[id])
def test_same_input_equals_outputN(self): test_path = aust.get_pathname_from_package('anuga.lib.tests') in_file = os.path.join(test_path, 'test1.asc') MaxAsc('test1.out.asc', [in_file] * 30) self.assertTrue(FilesEqual('test1.out.asc', in_file))
from anuga.structures.boyd_box_operator import Boyd_box_operator from anuga.structures.inlet_operator import Inlet_operator #from anuga.culvert_flows.culvert_routines import boyd_generalised_culvert_model from math import pi, pow, sqrt import numpy as num """test_that_culvert_runs_rating This test exercises the culvert and checks values outside rating curve are dealt with """ path = get_pathname_from_package('anuga.culvert_flows') length = 40. width = 15. dx = dy = 0.5 # Resolution: Length of subdivisions on both axes points, vertices, boundary = rectangular_cross(int(length / dx), int(width / dy), len1=length, len2=width) domain = anuga.Domain(points, vertices, boundary) domain.set_name('Test_gate_operator') # Output name domain.set_default_order(2) #domain.set_beta(1.5)
def test_predicted_boyd_flow(self): """test_predicted_boyd_flow Test that flows predicted by the boyd method are consistent with what what is calculated in engineering codes. The data was supplied by Petar Milevski """ # FIXME(Ole) this is nowhere near finished path = get_pathname_from_package('anuga.culvert_flows') length = 12. width = 5. dx = dy = 0.5 # Resolution: Length of subdivisions on both axes points, vertices, boundary = rectangular_cross(int(length/dx), int(width/dy), len1=length, len2=width) domain = anuga.Domain(points, vertices, boundary) domain.set_name('test_culvert') # Output name domain.set_default_order(2) #---------------------------------------------------------------------- # Setup initial conditions #---------------------------------------------------------------------- def topography(x, y): # General Slope of Topography z=-x/10 return z domain.set_quantity('elevation', topography) domain.set_quantity('friction', 0.01) # Constant friction domain.set_quantity('stage', expression='elevation') Q0 = domain.get_quantity('stage') Q1 = Quantity(domain) # Add depths to stage head_water_depth = 0.169 tail_water_depth = 0.089 inlet_poly = [[0,0], [6,0], [6,5], [0,5]] outlet_poly = [[6,0], [12,0], [12,5], [6,5]] Q1.set_values(Polygon_function([(inlet_poly, head_water_depth), (outlet_poly, tail_water_depth)])) domain.set_quantity('stage', Q0 + Q1) culvert = Culvert_flow(domain, label='Test culvert', description='4 m test culvert', end_point0=[4.0, 2.5], end_point1=[8.0, 2.5], width=1.20, height=0.75, culvert_routine=boyd_generalised_culvert_model, number_of_barrels=1, verbose=False) domain.forcing_terms.append(culvert) # Call culvert(domain)
def OBSOLETE_XXXtest_that_culvert_rating_limits_flow_in_shallow_inlet_condition(self): """test_that_culvert_rating_limits_flow_in_shallow_inlet_condition Test that culvert on a sloping dry bed limits flows when very little water is present at inlet This one is using the rating curve variant """ path = get_pathname_from_package('anuga.culvert_flows') length = 40. width = 5. dx = dy = 1 # Resolution: Length of subdivisions on both axes points, vertices, boundary = rectangular_cross(int(length/dx), int(width/dy), len1=length, len2=width) domain = anuga.Domain(points, vertices, boundary) domain.set_name('Test_culvert_shallow') # Output name domain.set_default_order(2) #---------------------------------------------------------------------- # Setup initial conditions #---------------------------------------------------------------------- def topography(x, y): """Set up a weir A culvert will connect either side """ # General Slope of Topography z=-x/1000 N = len(x) for i in range(N): # Sloping Embankment Across Channel if 5.0 < x[i] < 10.1: # Cut Out Segment for Culvert face if 1.0+(x[i]-5.0)/5.0 < y[i] < 4.0 - (x[i]-5.0)/5.0: z[i]=z[i] else: z[i] += 0.5*(x[i] -5.0) # Sloping Segment U/S Face if 10.0 < x[i] < 12.1: z[i] += 2.5 # Flat Crest of Embankment if 12.0 < x[i] < 14.5: # Cut Out Segment for Culvert face if 2.0-(x[i]-12.0)/2.5 < y[i] < 3.0 + (x[i]-12.0)/2.5: z[i]=z[i] else: z[i] += 2.5-1.0*(x[i] -12.0) # Sloping D/S Face return z domain.set_quantity('elevation', topography) domain.set_quantity('friction', 0.01) # Constant friction domain.set_quantity('stage', expression='elevation + 0.1') # Shallow initial condition # Boyd culvert culvert = Culvert_flow(domain, label='Culvert No. 1', description='This culvert is a test unit 1.2m Wide by 0.75m High', end_point0=[9.0, 2.5], end_point1=[13.0, 2.5], width=1.20, height=0.75, culvert_routine=boyd_generalised_culvert_model, number_of_barrels=1, update_interval=2, verbose=False) # Rating curve #filename = os.path.join(path, 'example_rating_curve.csv') #culvert = Culvert_flow(domain, # culvert_description_filename=filename, # end_point0=[9.0, 2.5], # end_point1=[13.0, 2.5], # trigger_depth=0.01, # verbose=False) domain.forcing_terms.append(culvert) #----------------------------------------------------------------------- # Setup boundary conditions #----------------------------------------------------------------------- # Inflow based on Flow Depth and Approaching Momentum Br = anuga.Reflective_boundary(domain) # Solid reflective wall domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br}) #----------------------------------------------------------------------- # Evolve system through time #----------------------------------------------------------------------- print 'depth', 0.1 ref_volume = domain.get_quantity('stage').get_integral() for t in domain.evolve(yieldstep = 0.1, finaltime = 25): new_volume = domain.get_quantity('stage').get_integral() msg = ('Total volume has changed: Is %.8f m^3 should have been %.8f m^3' % (new_volume, ref_volume)) assert num.allclose(new_volume, ref_volume, rtol=1.0e-10), msg return # Now try this again for a depth of 10 cm and for a range of other depths for depth in [0.1, 0.2, 0.5, 1.0]: print 'depth', depth domain.set_time(0.0) domain.set_quantity('elevation', topography) domain.set_quantity('friction', 0.01) # Constant friction domain.set_quantity('stage', expression='elevation + %f' % depth) ref_volume = domain.get_quantity('stage').get_integral() for t in domain.evolve(yieldstep = 0.1, finaltime = 25): new_volume = domain.get_quantity('stage').get_integral() msg = 'Total volume has changed: Is %.8f m^3 should have been %.8f m^3'\ % (new_volume, ref_volume) assert num.allclose(new_volume, ref_volume, rtol=1.0e-10), msg
z[i] += 0.5 * (x[i] - 5.0) # Sloping Segment U/S Face if 10.0 < x[i] < 12.1: z[i] += 2.5 # Flat Crest of Embankment if 12.0 < x[i] < 14.5: # Cut Out Segment for Culvert face if 2.0 - (x[i] - 12.0) / 2.5 < y[i] < 3.0 + (x[i] - 12.0) / 2.5: z[i] = z[i] else: z[i] += 2.5 - 1.0 * (x[i] - 12.0) # Sloping D/S Face return z #filename=os.path.join(path, 'example_rating_curve.csv') mod_path = get_pathname_from_package('anuga.parallel') line0 = [[10.0, 10.0], [30.0, 10.0]] #line0 = [[29.0, 10.0], [30.0, 10.0]] line1 = [[0.0, 10.0], [0.0, 15.0]] Q0 = file_function(os.path.join(mod_path, 'data', 'test_hydrograph.tms'), quantities=['hydrograph']) Q1 = 5.0 samples = 50 def run_simulation(parallel=False, control_data=None, test_points=None, verbose=False): success = True
from anuga import Time_boundary from anuga import Transmissive_boundary from anuga import Transmissive_n_momentum_zero_t_momentum_set_stage_boundary from anuga import rectangular_cross from anuga import create_domain_from_file from anuga import distribute, myid, numprocs, finalize, barrier from anuga.utilities.system_tools import get_pathname_from_package #-------------------------------------------------------------------------- # Setup parameters #-------------------------------------------------------------------------- DATA_DIR = get_pathname_from_package('anuga.parallel') mesh_filename = anuga.join(DATA_DIR, "data/merimbula_10785_1.tsh") x0 = 756000.0 x1 = 756500.0 yieldstep = 10 finaltime = 100 #mesh_filename = anuga.join(DATA_DIR,"data/merimbula_17156.tsh") ; x0 = 756000.0 ; x1 = 756500.0; yieldstep = 50; finaltime = 500 #mesh_filename = anuga.join(DATA_DIR,"data/merimbula_43200_1.tsh") ; x0 = 756000.0 ; x1 = 756500.0; yieldstep = 50; finaltime = 500 #mesh_filename = anuga.join(DATA_DIR,"data/test-100.tsh") ; x0 = 200.0 ; x1 = 300.0; yieldstep = 1; finaltime = 10 #mesh_filename = anuga.join(DATA_DIR,"data/test-20.tsh") ; x0 = 250.0 ; x1 = 350.0; yieldstep = 1; finaltime = 50 verbose = False #--------------------------------------------------------------------------
#from parallel_inlet_operator import Parallel_Inlet_operator from anuga.parallel import distribute, myid, numprocs, finalize from anuga.geometry.polygon import inside_polygon, is_inside_polygon, line_intersect #from parallel_operator_factory import Inlet_operator, Boyd_box_operator import pypar import random """test_that_culvert_runs_rating This test exercises the culvert and checks values outside rating curve are dealt with """ verbose = False path = get_pathname_from_package('anuga.culvert_flows') length = 40. width = 15. dx = dy = 0.5 # Resolution: Length of subdivisions on both axes #---------------------------------------------------------------------- # Setup initial conditions #---------------------------------------------------------------------- def topography(x, y): """Set up a weir A culvert will connect either side """
def test_Okada_func(self): from os import sep, getenv import sys from anuga.abstract_2d_finite_volumes.mesh_factory \ import rectangular_cross from anuga.abstract_2d_finite_volumes.quantity import Quantity from anuga.utilities.system_tools import get_pathname_from_package """ Pick the test you want to do; T= 0 test a point source, T= 1 test single rectangular source, T= 2 test multiple rectangular sources """ # Get path where this test is run path = get_pathname_from_package('anuga.tsunami_source') # Choose what test to proceed T = 1 if T == 0: # Fortran output file filename = path + sep + 'tests' + sep + 'data' + sep + 'fullokada_SP.txt' # Initial condition of earthquake for multiple source x0 = 7000.0 y0 = 10000.0 length = 0 width = 0 strike = 0.0 depth = 15.0 slip = 10.0 dip = 15.0 rake = 90.0 ns = 1 NSMAX = 1 elif T == 1: # Fortran output file filename = path + sep + 'tests' + sep + 'data' + sep + 'fullokada_SS.txt' # Initial condition of earthquake for multiple source x0 = 7000.0 y0 = 10000.0 length = 10.0 width = 6.0 strike = 0.0 depth = 15.0 slip = 10.0 dip = 15.0 rake = 90.0 ns = 1 NSMAX = 1 elif T == 2: # Fortran output file filename = path + sep + 'tests' + sep + 'data' + sep + 'fullokada_MS.txt' # Initial condition of earthquake for multiple source x0 = [7000.0, 10000.0] y0 = [10000.0, 7000.0] length = [10.0, 10.0] width = [6.0, 6.0] strike = [0.0, 0.0] depth = [15.0, 15.0] slip = [10.0, 10.0] dip = [15.0, 15.0] rake = [90.0, 90.0] ns = 2 NSMAX = 2 # Get output file from original okada fortran script. # Vertical displacement is listed under tmp. polyline_file = open(filename, 'r') lines = polyline_file.readlines() polyline_file.close() tmp = [] stage = [] for line in lines[0:]: field = line.split(' ') z = float(field[2]) tmp.append(z) #create domain dx = dy = 4000 l = 100000 w = 100000 #create topography def topography(x, y): el = -1000 return el #print int(l/dx) #print int(w/dy) points, vertices, boundary = rectangular_cross(int(old_div(l, dx)), int(old_div(w, dy)), len1=l, len2=w) domain = Domain(points, vertices, boundary) domain.set_name('test') domain.set_quantity('elevation', topography) #create variable with elevation data to implement in okada zrec0 = Quantity(domain) zrec0.set_values(0.0) zrec = zrec0.get_vertex_values(xy=True) # call okada Ts= Okada_func(ns=ns, NSMAX=NSMAX,length=length, width=width, dip=dip, \ x0=x0, y0=y0, strike=strike, depth=depth, \ slip=slip, rake=rake,zrec=zrec) #create a variable to store vertical displacement throughout the domain tsunami = Quantity(domain) tsunami.set_values(Ts) # get vertical displacement at each point of the domain respecting # original script's order interpolation_points = [] k = 0.0 for i in range(0, 6): for j in range(0, 6): p = j * 4000 Yt = p Xt = k interpolation_points.append([Xt, Yt]) k = k + 4000 Z = tsunami.get_values(interpolation_points=interpolation_points, location='edges') stage = -Z # FIXME(Ole): Why the sign flip? # Displacement in fortran code is looking downward #print tmp #print 'hello',stage assert num.allclose(stage, tmp, atol=1.e-3)
from anuga import Transmissive_boundary from anuga import Transmissive_n_momentum_zero_t_momentum_set_stage_boundary from anuga import rectangular_cross from anuga import create_domain_from_file from anuga import distribute, myid, numprocs, finalize, barrier from anuga.utilities.system_tools import get_pathname_from_package #-------------------------------------------------------------------------- # Setup parameters #-------------------------------------------------------------------------- DATA_DIR = get_pathname_from_package('anuga.parallel') mesh_filename = anuga.join(DATA_DIR,"data/merimbula_10785_1.tsh") ; x0 = 756000.0 ; x1 = 756500.0; yieldstep = 10; finaltime = 100 #mesh_filename = anuga.join(DATA_DIR,"data/merimbula_17156.tsh") ; x0 = 756000.0 ; x1 = 756500.0; yieldstep = 50; finaltime = 500 #mesh_filename = anuga.join(DATA_DIR,"data/merimbula_43200_1.tsh") ; x0 = 756000.0 ; x1 = 756500.0; yieldstep = 50; finaltime = 500 #mesh_filename = anuga.join(DATA_DIR,"data/test-100.tsh") ; x0 = 200.0 ; x1 = 300.0; yieldstep = 1; finaltime = 10 #mesh_filename = anuga.join(DATA_DIR,"data/test-20.tsh") ; x0 = 250.0 ; x1 = 350.0; yieldstep = 1; finaltime = 50 verbose = False #-------------------------------------------------------------------------- # Setup procedures #-------------------------------------------------------------------------- class Set_Stage: """Set an initial condition with constant water height, for x0<x<x1 """
def test_that_culvert_runs_rating(self): """test_that_culvert_runs_rating This test exercises the culvert and checks values outside rating curve are dealt with """ path = get_pathname_from_package('anuga.culvert_flows') path = os.path.join(path, 'tests', 'data') length = 40. width = 5. dx = dy = 1 # Resolution: Length of subdivisions on both axes points, vertices, boundary = rectangular_cross(int(length/dx), int(width/dy), len1=length, len2=width) domain = anuga.Domain(points, vertices, boundary) domain.set_name('Test_culvert') # Output name domain.set_default_order(2) #---------------------------------------------------------------------- # Setup initial conditions #---------------------------------------------------------------------- def topography(x, y): """Set up a weir A culvert will connect either side """ # General Slope of Topography z=-x/1000 N = len(x) for i in range(N): # Sloping Embankment Across Channel if 5.0 < x[i] < 10.1: # Cut Out Segment for Culvert face if 1.0+(x[i]-5.0)/5.0 < y[i] < 4.0 - (x[i]-5.0)/5.0: z[i]=z[i] else: z[i] += 0.5*(x[i] -5.0) # Sloping Segment U/S Face if 10.0 < x[i] < 12.1: z[i] += 2.5 # Flat Crest of Embankment if 12.0 < x[i] < 14.5: # Cut Out Segment for Culvert face if 2.0-(x[i]-12.0)/2.5 < y[i] < 3.0 + (x[i]-12.0)/2.5: z[i]=z[i] else: z[i] += 2.5-1.0*(x[i] -12.0) # Sloping D/S Face return z domain.set_quantity('elevation', topography) domain.set_quantity('friction', 0.01) # Constant friction domain.set_quantity('stage', expression='elevation') # Dry initial condition filename=os.path.join(path, 'example_rating_curve.csv') culvert = Culvert_flow(domain, culvert_description_filename=filename, end_point0=[9.0, 2.5], end_point1=[13.0, 2.5], width=1.00, use_velocity_head=True, verbose=False) domain.forcing_terms.append(culvert) #----------------------------------------------------------------------- # Setup boundary conditions #----------------------------------------------------------------------- # Inflow based on Flow Depth and Approaching Momentum Bi = anuga.Dirichlet_boundary([0.0, 0.0, 0.0]) Br = anuga.Reflective_boundary(domain) # Solid reflective wall Bo = anuga.Dirichlet_boundary([-5, 0, 0]) # Outflow # Upstream and downstream conditions that will exceed the rating curve # I.e produce delta_h outside the range [0, 10] specified in the the # file example_rating_curve.csv Btus = anuga.Time_boundary(domain, \ lambda t: [100*num.sin(2*pi*(t-4)/10), 0.0, 0.0]) Btds = anuga.Time_boundary(domain, \ lambda t: [-5*(num.cos(2*pi*(t-4)/20)), 0.0, 0.0]) domain.set_boundary({'left': Btus, 'right': Btds, 'top': Br, 'bottom': Br}) #----------------------------------------------------------------------- # Evolve system through time #----------------------------------------------------------------------- min_delta_w = sys.maxint max_delta_w = -min_delta_w for t in domain.evolve(yieldstep = 1, finaltime = 25): delta_w = culvert.inlet.stage - culvert.outlet.stage if delta_w > max_delta_w: max_delta_w = delta_w if delta_w < min_delta_w: min_delta_w = delta_w pass # Check that extreme values in rating curve have been exceeded # so that we know that condition has been exercised assert min_delta_w < 0 assert max_delta_w > 10 os.remove('Test_culvert.sww')
from anuga import Dirichlet_boundary from anuga import Time_boundary from anuga import Transmissive_boundary from anuga import rectangular_cross from anuga import create_domain_from_file from anuga import distribute, myid, numprocs, finalize #-------------------------------------------------------------------------- # Setup parameters #-------------------------------------------------------------------------- mod_path = get_pathname_from_package('anuga.parallel') mesh_filename = os.path.join(mod_path,'data','merimbula_10785_1.tsh') #mesh_filename = os.path.join('..','data','test-100.tsh') yieldstep = 1 finaltime = 1 quantity = 'stage' nprocs = 2 verbose = False #-------------------------------------------------------------------------- # Setup procedures #-------------------------------------------------------------------------- class Set_Stage: """Set an initial condition with constant water height, for x<x0 """
def test_that_culvert_dry_bed_boyd_does_not_produce_flow(self): """test_that_culvert_in_dry_bed_boyd_does_not_produce_flow(self): Test that culvert on a sloping dry bed doesn't produce flows although there will be a 'pressure' head due to delta_w > 0 This one is using the 'Boyd' variant """ path = get_pathname_from_package('anuga.culvert_flows') length = 40. width = 5. dx = dy = 1 # Resolution: Length of subdivisions on both axes points, vertices, boundary = rectangular_cross(int(length/dx), int(width/dy), len1=length, len2=width) domain = anuga.Domain(points, vertices, boundary) domain.set_name('Test_culvert_dry') # Output name domain.set_default_order(2) #---------------------------------------------------------------------- # Setup initial conditions #---------------------------------------------------------------------- def topography(x, y): """Set up a weir A culvert will connect either side """ # General Slope of Topography z=-x/1000 N = len(x) for i in range(N): # Sloping Embankment Across Channel if 5.0 < x[i] < 10.1: # Cut Out Segment for Culvert face if 1.0+(x[i]-5.0)/5.0 < y[i] < 4.0 - (x[i]-5.0)/5.0: z[i]=z[i] else: z[i] += 0.5*(x[i] -5.0) # Sloping Segment U/S Face if 10.0 < x[i] < 12.1: z[i] += 2.5 # Flat Crest of Embankment if 12.0 < x[i] < 14.5: # Cut Out Segment for Culvert face if 2.0-(x[i]-12.0)/2.5 < y[i] < 3.0 + (x[i]-12.0)/2.5: z[i]=z[i] else: z[i] += 2.5-1.0*(x[i] -12.0) # Sloping D/S Face return z domain.set_quantity('elevation', topography) domain.set_quantity('friction', 0.01) # Constant friction domain.set_quantity('stage', expression='elevation') # Dry initial condition filename = os.path.join(path, 'example_rating_curve.csv') culvert = Culvert_flow(domain, label='Culvert No. 1', description='This culvert is a test unit 1.2m Wide by 0.75m High', end_point0=[9.0, 2.5], end_point1=[13.0, 2.5], width=1.20, height=0.75, culvert_routine=boyd_generalised_culvert_model, number_of_barrels=1, update_interval=2, verbose=False) domain.forcing_terms.append(culvert) #----------------------------------------------------------------------- # Setup boundary conditions #----------------------------------------------------------------------- # Inflow based on Flow Depth and Approaching Momentum Br = anuga.Reflective_boundary(domain) # Solid reflective wall domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br}) #----------------------------------------------------------------------- # Evolve system through time #----------------------------------------------------------------------- ref_volume = domain.get_quantity('stage').get_integral() for t in domain.evolve(yieldstep = 1, finaltime = 25): new_volume = domain.get_quantity('stage').get_integral() msg = 'Total volume has changed' assert num.allclose(new_volume, ref_volume, rtol=1.0e-10), msg pass
from math import pi, pow, sqrt import numpy as num """test_that_culvert_runs_rating This test exercises the culvert and checks values outside rating curve are dealt with """ path = get_pathname_from_package('anuga.culvert_flows') length = 40. width = 15. dx = dy = 0.5 # Resolution: Length of subdivisions on both axes points, vertices, boundary = rectangular_cross(int(length/dx), int(width/dy), len1=length, len2=width) domain = anuga.Domain(points, vertices, boundary) domain.set_name('run_gate_operator') # Output name domain.set_default_order(2) #domain.set_beta(1.5)
def test_earthquake_tsunami(self): from os import sep, getenv import sys from anuga.abstract_2d_finite_volumes.mesh_factory \ import rectangular_cross from anuga.abstract_2d_finite_volumes.quantity import Quantity from anuga.utilities.system_tools import get_pathname_from_package """ Pick the test you want to do; T= 0 test a point source, T= 1 test single rectangular source, T= 2 test multiple rectangular sources """ # Get path where this test is run path= get_pathname_from_package('anuga.tsunami_source') # Choose what test to proceed T=1 if T==0: # Fortran output file filename = path+sep+'tests'+sep+'data'+sep+'fullokada_SP.txt' # Initial condition of earthquake for multiple source x0 = 7000.0 y0 = 10000.0 length = 0 width =0 strike = 0.0 depth = 15.0 slip = 10.0 dip =15.0 rake =90.0 ns=1 NSMAX=1 elif T==1: # Fortran output file filename = path+sep+'tests'+sep+'data'+sep+'fullokada_SS.txt' # Initial condition of earthquake for multiple source x0 = 7000.0 y0 = 10000.0 length = 10.0 width =6.0 strike = 0.0 depth = 15.0 slip = 10.0 dip =15.0 rake =90.0 ns=1 NSMAX=1 elif T==2: # Fortran output file filename = path+sep+'tests'+sep+'data'+sep+'fullokada_MS.txt' # Initial condition of earthquake for multiple source x0 = [7000.0,10000.0] y0 = [10000.0,7000.0] length = [10.0,10.0] width =[6.0,6.0] strike = [0.0,0.0] depth = [15.0,15.0] slip = [10.0,10.0] dip = [15.0,15.0] rake = [90.0,90.0] ns=2 NSMAX=2 # Get output file from original okada fortran script. # Vertical displacement is listed under tmp. polyline_file=open(filename,'r') lines=polyline_file.readlines() polyline_file.close() tmp=[] stage=[] for line in lines [0:]: field = line.split(' ') z=float(field[2]) tmp.append(z) # Create domain dx = dy = 4000 l=20000 w=20000 # Create topography def topography(x,y): el=-1000 return el points, vertices, boundary = rectangular_cross(int(l/dx), int(w/dy), len1=l, len2=w) domain = Domain(points, vertices, boundary) domain.set_name('test') domain.set_quantity('elevation',topography) Ts = earthquake_tsunami(ns=ns,NSMAX=NSMAX,length=length, width=width, strike=strike,\ depth=depth,dip=dip, xi=x0, yi=y0,z0=0, slip=slip, rake=rake,\ domain=domain, verbose=False) # Create a variable to store vertical displacement throughout the domain tsunami = Quantity(domain) tsunami.set_values(Ts) interpolation_points=[] #k=0.0 #for i in range(0,6): # for j in range(0,6): # p=j*4000 # Yt=p # Xt=k # Z=tsunami.get_values(interpolation_points=[[Xt,Yt]] # ,location='edges') # stage.append(-Z[0]) # k=k+4000 # #assert allclose(stage,tmp,atol=1.e-3) # Here's a faster way - try that in the first test interpolation_points=[] k=0.0 for i in range(0,6): for j in range(0,6): p=j*4000 Yt=p Xt=k interpolation_points.append([Xt, Yt]) k=k+4000 Z=tsunami.get_values(interpolation_points=interpolation_points, location='edges') stage = -Z # FIXME(Ole): Why the sign flip? # Displacement in fortran code is looking downward #print 'c est fini' #print tmp #print 'hello',stage assert num.allclose(stage,tmp,atol=1.e-3)
def test_that_culvert_runs_rating(self): """test_that_culvert_runs_rating This test exercises the culvert and checks values outside rating curve are dealt with """ path = get_pathname_from_package('anuga.culvert_flows') path = os.path.join(path, 'tests', 'data') length = 40. width = 5. dx = dy = 1 # Resolution: Length of subdivisions on both axes points, vertices, boundary = rectangular_cross(int(length / dx), int(width / dy), len1=length, len2=width) domain = anuga.Domain(points, vertices, boundary) domain.set_name('Test_culvert') # Output name domain.set_default_order(2) #---------------------------------------------------------------------- # Setup initial conditions #---------------------------------------------------------------------- def topography(x, y): """Set up a weir A culvert will connect either side """ # General Slope of Topography z = -x / 1000 N = len(x) for i in range(N): # Sloping Embankment Across Channel if 5.0 < x[i] < 10.1: # Cut Out Segment for Culvert face if 1.0 + (x[i] - 5.0) / 5.0 < y[i] < 4.0 - (x[i] - 5.0) / 5.0: z[i] = z[i] else: z[i] += 0.5 * (x[i] - 5.0) # Sloping Segment U/S Face if 10.0 < x[i] < 12.1: z[i] += 2.5 # Flat Crest of Embankment if 12.0 < x[i] < 14.5: # Cut Out Segment for Culvert face if 2.0 - (x[i] - 12.0) / 2.5 < y[i] < 3.0 + (x[i] - 12.0) / 2.5: z[i] = z[i] else: z[i] += 2.5 - 1.0 * (x[i] - 12.0) # Sloping D/S Face return z domain.set_quantity('elevation', topography) domain.set_quantity('friction', 0.01) # Constant friction domain.set_quantity('stage', expression='elevation') # Dry initial condition filename = os.path.join(path, 'example_rating_curve.csv') culvert = Culvert_flow(domain, culvert_description_filename=filename, end_point0=[9.0, 2.5], end_point1=[13.0, 2.5], width=1.00, use_velocity_head=True, verbose=False) domain.forcing_terms.append(culvert) #----------------------------------------------------------------------- # Setup boundary conditions #----------------------------------------------------------------------- # Inflow based on Flow Depth and Approaching Momentum Bi = anuga.Dirichlet_boundary([0.0, 0.0, 0.0]) Br = anuga.Reflective_boundary(domain) # Solid reflective wall Bo = anuga.Dirichlet_boundary([-5, 0, 0]) # Outflow # Upstream and downstream conditions that will exceed the rating curve # I.e produce delta_h outside the range [0, 10] specified in the the # file example_rating_curve.csv Btus = anuga.Time_boundary( domain, lambda t: [100 * num.sin(2 * pi * (t - 4) / 10), 0.0, 0.0]) Btds = anuga.Time_boundary( domain, lambda t: [-5 * (num.cos(2 * pi * (t - 4) / 20)), 0.0, 0.0]) domain.set_boundary({ 'left': Btus, 'right': Btds, 'top': Br, 'bottom': Br }) #----------------------------------------------------------------------- # Evolve system through time #----------------------------------------------------------------------- min_delta_w = sys.maxint max_delta_w = -min_delta_w for t in domain.evolve(yieldstep=1, finaltime=25): delta_w = culvert.inlet.stage - culvert.outlet.stage if delta_w > max_delta_w: max_delta_w = delta_w if delta_w < min_delta_w: min_delta_w = delta_w pass # Check that extreme values in rating curve have been exceeded # so that we know that condition has been exercised assert min_delta_w < 0 assert max_delta_w > 10 os.remove('Test_culvert.sww')
def OBSOLETE_XXXtest_that_culvert_rating_limits_flow_in_shallow_inlet_condition( self): """test_that_culvert_rating_limits_flow_in_shallow_inlet_condition Test that culvert on a sloping dry bed limits flows when very little water is present at inlet This one is using the rating curve variant """ path = get_pathname_from_package('anuga.culvert_flows') length = 40. width = 5. dx = dy = 1 # Resolution: Length of subdivisions on both axes points, vertices, boundary = rectangular_cross(int(length / dx), int(width / dy), len1=length, len2=width) domain = anuga.Domain(points, vertices, boundary) domain.set_name('Test_culvert_shallow') # Output name domain.set_default_order(2) #---------------------------------------------------------------------- # Setup initial conditions #---------------------------------------------------------------------- def topography(x, y): """Set up a weir A culvert will connect either side """ # General Slope of Topography z = -x / 1000 N = len(x) for i in range(N): # Sloping Embankment Across Channel if 5.0 < x[i] < 10.1: # Cut Out Segment for Culvert face if 1.0 + (x[i] - 5.0) / 5.0 < y[i] < 4.0 - (x[i] - 5.0) / 5.0: z[i] = z[i] else: z[i] += 0.5 * (x[i] - 5.0) # Sloping Segment U/S Face if 10.0 < x[i] < 12.1: z[i] += 2.5 # Flat Crest of Embankment if 12.0 < x[i] < 14.5: # Cut Out Segment for Culvert face if 2.0 - (x[i] - 12.0) / 2.5 < y[i] < 3.0 + (x[i] - 12.0) / 2.5: z[i] = z[i] else: z[i] += 2.5 - 1.0 * (x[i] - 12.0) # Sloping D/S Face return z domain.set_quantity('elevation', topography) domain.set_quantity('friction', 0.01) # Constant friction domain.set_quantity( 'stage', expression='elevation + 0.1') # Shallow initial condition # Boyd culvert culvert = Culvert_flow( domain, label='Culvert No. 1', description='This culvert is a test unit 1.2m Wide by 0.75m High', end_point0=[9.0, 2.5], end_point1=[13.0, 2.5], width=1.20, height=0.75, culvert_routine=boyd_generalised_culvert_model, number_of_barrels=1, update_interval=2, verbose=False) # Rating curve #filename = os.path.join(path, 'example_rating_curve.csv') #culvert = Culvert_flow(domain, # culvert_description_filename=filename, # end_point0=[9.0, 2.5], # end_point1=[13.0, 2.5], # trigger_depth=0.01, # verbose=False) domain.forcing_terms.append(culvert) #----------------------------------------------------------------------- # Setup boundary conditions #----------------------------------------------------------------------- # Inflow based on Flow Depth and Approaching Momentum Br = anuga.Reflective_boundary(domain) # Solid reflective wall domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br}) #----------------------------------------------------------------------- # Evolve system through time #----------------------------------------------------------------------- print 'depth', 0.1 ref_volume = domain.get_quantity('stage').get_integral() for t in domain.evolve(yieldstep=0.1, finaltime=25): new_volume = domain.get_quantity('stage').get_integral() msg = ( 'Total volume has changed: Is %.8f m^3 should have been %.8f m^3' % (new_volume, ref_volume)) assert num.allclose(new_volume, ref_volume, rtol=1.0e-10), msg return # Now try this again for a depth of 10 cm and for a range of other depths for depth in [0.1, 0.2, 0.5, 1.0]: print 'depth', depth domain.set_time(0.0) domain.set_quantity('elevation', topography) domain.set_quantity('friction', 0.01) # Constant friction domain.set_quantity('stage', expression='elevation + %f' % depth) ref_volume = domain.get_quantity('stage').get_integral() for t in domain.evolve(yieldstep=0.1, finaltime=25): new_volume = domain.get_quantity('stage').get_integral() msg = 'Total volume has changed: Is %.8f m^3 should have been %.8f m^3'\ % (new_volume, ref_volume) assert num.allclose(new_volume, ref_volume, rtol=1.0e-10), msg
def test_that_culvert_dry_bed_boyd_does_not_produce_flow(self): """test_that_culvert_in_dry_bed_boyd_does_not_produce_flow(self): Test that culvert on a sloping dry bed doesn't produce flows although there will be a 'pressure' head due to delta_w > 0 This one is using the 'Boyd' variant """ path = get_pathname_from_package('anuga.culvert_flows') length = 40. width = 5. dx = dy = 1 # Resolution: Length of subdivisions on both axes points, vertices, boundary = rectangular_cross(int(length / dx), int(width / dy), len1=length, len2=width) domain = anuga.Domain(points, vertices, boundary) domain.set_name('Test_culvert_dry') # Output name domain.set_default_order(2) #---------------------------------------------------------------------- # Setup initial conditions #---------------------------------------------------------------------- def topography(x, y): """Set up a weir A culvert will connect either side """ # General Slope of Topography z = -x / 1000 N = len(x) for i in range(N): # Sloping Embankment Across Channel if 5.0 < x[i] < 10.1: # Cut Out Segment for Culvert face if 1.0 + (x[i] - 5.0) / 5.0 < y[i] < 4.0 - (x[i] - 5.0) / 5.0: z[i] = z[i] else: z[i] += 0.5 * (x[i] - 5.0) # Sloping Segment U/S Face if 10.0 < x[i] < 12.1: z[i] += 2.5 # Flat Crest of Embankment if 12.0 < x[i] < 14.5: # Cut Out Segment for Culvert face if 2.0 - (x[i] - 12.0) / 2.5 < y[i] < 3.0 + (x[i] - 12.0) / 2.5: z[i] = z[i] else: z[i] += 2.5 - 1.0 * (x[i] - 12.0) # Sloping D/S Face return z domain.set_quantity('elevation', topography) domain.set_quantity('friction', 0.01) # Constant friction domain.set_quantity('stage', expression='elevation') # Dry initial condition filename = os.path.join(path, 'example_rating_curve.csv') culvert = Culvert_flow( domain, label='Culvert No. 1', description='This culvert is a test unit 1.2m Wide by 0.75m High', end_point0=[9.0, 2.5], end_point1=[13.0, 2.5], width=1.20, height=0.75, culvert_routine=boyd_generalised_culvert_model, number_of_barrels=1, update_interval=2, verbose=False) domain.forcing_terms.append(culvert) #----------------------------------------------------------------------- # Setup boundary conditions #----------------------------------------------------------------------- # Inflow based on Flow Depth and Approaching Momentum Br = anuga.Reflective_boundary(domain) # Solid reflective wall domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br}) #----------------------------------------------------------------------- # Evolve system through time #----------------------------------------------------------------------- ref_volume = domain.get_quantity('stage').get_integral() for t in domain.evolve(yieldstep=1, finaltime=25): new_volume = domain.get_quantity('stage').get_integral() msg = 'Total volume has changed' assert num.allclose(new_volume, ref_volume, rtol=1.0e-10), msg pass