def create_a_rain_operator(domain, base_filename): polygon = read_polygon(join(rain_polygon_dir, base_filename+'.csv')) rate = file_function(join(rain_rate_dir, base_filename+'.tms'), quantities=['rate']) return Rate_operator(domain, rate=rate, factor=1.0e-3, \ polygon = polygon)
def finalstats(domain, initialdomain, outfile='outstats.csv'): acrossthebreach=anuga.read_polygon('JezeroData/jezerobreachpoly.csv',closed=False) crossspacing=160 breacherosion=0 areasum=0 for y in acrossthebreach: ybreacherosion=domain.get_quantity('elevation').get_values(interpolation_points=[y], location='centroids')-initialdomain.get_quantity('elevation').get_values(interpolation_points=[y], location='centroids') if ybreacherosion<0: areasum=areasum+float(ybreacherosion)*crossspacing #rectangular integration :) if ybreacherosion<breacherosion: breacherosion=float(ybreacherosion) areasum=-areasum #because negative areas seem weird elevdiff=domain.quantities['elevation'].centroid_values-initialdomain.quantities['elevation'].centroid_values #negative values are eroded, positive values are deposited finalremovedvolume=-np.sum(elevdiff[elevdiff<0]*domain.areas[elevdiff<0]) transportedmask=domain.get_centroid_coordinates(absolute=True)[:,0]>54300 heights=(domain.quantities['stage'].centroid_values-domain.quantities['elevation'].centroid_values) transportedvolume=(np.where(heights>0,heights,0)*domain.areas)[transportedmask].sum() print 'Breach Erosion Depth (m): '+str(-breacherosion) print 'Cross-sectional Area (m^2): '+str(areasum) print 'Outlet volume (m^3): '+str(finalremovedvolume) print 'Drained volume (m^3):' +str(transportedvolume) with open(outfile, 'a') as the_file: the_file.write(domain.get_name()+','+str(-breacherosion)+','+str(areasum)+','+str(finalremovedvolume)+','+str(transportedvolume)+'\n')
def read_polygon_list(poly_list): # Alternative to read_polygon_dir -- allows us to control order of polygons from anuga import read_polygon result = [] for i in range(len(poly_list)): result.append((read_polygon(poly_list[i][0]) , poly_list[i][1])) return result
def read_polygon_list(poly_list): # Alternative to read_polygon_dir -- allows us to control order of polygons from anuga import read_polygon result = [] for i in range(len(poly_list)): result.append((read_polygon(poly_list[i][0]), poly_list[i][1])) return result
def CreateDomain(topo_in, bound_in, datadir, inlet_btag, outlet_btag, res, parlist): # Import Channel topography DEM # Create DEM from asc data anuga.asc2dem(topo_in + '.asc', use_cache=False, verbose=True) # Create DEM from asc data anuga.dem2pts(topo_in + '.dem', use_cache=False, verbose=True) # Define boundaries for mesh # Read in coordinate file bounding_polygon = anuga.read_polygon(bound_in + '.csv') print(inlet_btag) #Determine tag to assign as reflective exterior for i in numpy.arange(1, 4): print(i) if int(i) == int(inlet_btag): print(str(inlet_btag) + ' already taken') else: print(str(i) + ' used as exterior tag') break # Create mesh with bounding polygon domain = anuga.create_domain_from_regions(bounding_polygon, boundary_tags={ 'inlet': [inlet_btag], 'exterior': [i], 'outlet': [outlet_btag] }, maximum_triangle_area=res, mesh_filename=parlist + '.msh', use_cache=False, verbose=True) # Name domain and decide where to save domain.set_name(parlist) domain.set_datadir('.') return domain
if verbose: print(domain.get_extent(absolute=True)) #------------------------------------------------------------------------------ # Setup initial conditions #------------------------------------------------------------------------------ domain.set_quantity('stage', 0.0) # Friction -- 2 options variable_friction = True if not variable_friction: # Constant friction domain.set_quantity('friction', 0.02) else: # Set friction to 0.02 on roads, 0.04 elsewhere road_polygon = anuga.read_polygon('Road/RoadPolygon.csv') friction_function = qs.composite_quantity_setting_function( [[road_polygon, 0.02], ['All', 0.04]], domain) domain.set_quantity('friction', friction_function) # Elevation if houses_as_holes: domain.set_quantity('elevation', filename='topography1.pts', use_cache=use_cache, verbose=verbose) else: domain.set_quantity('elevation', filename='topography1.pts', use_cache=use_cache,
#Save Parameter List as Pkl fname = identifier + '_par.pkl' pickle_out = open(fname, "wb") pickle.dump(Parameters, pickle_out) # Import Channel topography DEM # Create DEM from asc data anuga.asc2dem(topo_in + '.asc', use_cache=False, verbose=True) # Create DEM from asc data anuga.dem2pts(topo_in + '.dem', use_cache=False, verbose=True) # Define boundaries for mesh # Read in coordinate file bounding_polygon = anuga.read_polygon(bound_in + '.csv') # Create mesh with bounding polygon domain = anuga.create_domain_from_regions(bounding_polygon, boundary_tags={ 'inlet': [inlet_btag], 'exterior': [ref_btag], 'outlet': [outlet_btag] }, maximum_triangle_area=res, mesh_filename=identifier + '.msh', use_cache=False, verbose=True) # Name domain and decide where to save domain.set_name(identifier) domain.set_datadir('.')
rain.data_max_in_period = np.max(rain.data_accumulated) rain.radar_dir = None l0 = [5100.0, 100000.0] l1 = [5100.0, 103900.0] l2 = [3400., 103400.] l3 = [6000., 103400.] locations = [l0,l1,l2,l3] else: pass print rain.radar_dir try: p2 = anuga.read_polygon(Catchment_file) print 'Catchment File' print Catchment_file #print p2 except: p2 = None pass try: p3 = anuga.read_polygon(State_boundary_file) print 'State_boundary_file' print State_boundary_file #print p3 except: p3 = None pass
ascii_grid_filenames = [] point_filenames = ['etopo4min_corrected.txt', 'etopo1minNan.txt', 'bathy_utmNan.txt'] verbose= True # Filename for locations where timeseries are to be produced #gauge_filename = 'gauges.csv' #------------------------------------------------------------------------------ # Domain definitions #------------------------------------------------------------------------------ # bounding polygon for study area bounding_polygon = anuga.read_polygon('polygons/bounding_n.csv') A = anuga.polygon_area(bounding_polygon) / 1000000.0 print ('Area of bounding polygon = %.2f km^2' % A) #------------------------------------------------------------------------------ # Interior region definitions #------------------------------------------------------------------------------ # Read interior polygons #poly_1min = anuga.read_polygon('polygons/bounding_1min.csv') poly_level1 = anuga.read_polygon('polygons/polygon_new1.csv') poly_level2 = anuga.read_polygon('polygons/bounding_gps.csv') poly_level3 = anuga.read_polygon('polygons/bounding_inundation.csv') # Optionally plot points making up these polygons #plot_polygons([bounding_polygon, poly_level1, poly_level2,poly_level3],figname="plot_polyl.png")
# Convert an elevation raster into a point file anuga.asc2dem('topo.asc', use_cache = False, verbose = True) anuga.dem2pts('topo.dem', use_cache = False, verbose = True) """ Include the process-specific quantities when creating the domain """ evolved_quantities = ['stage', 'xmomentum', 'ymomentum', 'concentration'] other_quantities=['elevation', 'friction', 'height', 'xvelocity', \ 'yvelocity', 'x', 'y', 'vegetation', 'diffusivity'] # import bounding polygon text file, set boundary tags bounding_polygon = anuga.read_polygon('outline.csv') boundary_tags = {'bottom':[0], 'side1':[1], 'side2':[2], 'top':[3], 'side3':[4], 'side4':[5]} """ Create the domain with operator-specific function (accepts quantities) """ domain = create_domain_from_regions_sed(bounding_polygon, boundary_tags = boundary_tags, maximum_triangle_area = 200, mesh_filename = 'topo.msh', interior_regions = {},
import numpy as np import matplotlib.pyplot as plt from matplotlib import rc import os import anuga import anuga_tools.animate as animate rc('animation', html='jshtml') cwd = os.getcwd() data_dir = cwd + '/data/york' # Polygon defining broad area of interest bounding_polygon = anuga.read_polygon(os.path.join(data_dir, 'extent.csv')) # Polygon defining particular area of interest york_polygon = anuga.read_polygon(os.path.join(data_dir, 'york_selection.csv')) # Elevation Data topography_file = os.path.join(data_dir, 'se6051_dtm_1m.asc') # Resolution for most of the mesh base_resolution = 100.0 # m^2 # Resolution in particular area of interest york_resolution = 50.0 # m^2 interior_regions = [[york_polygon, york_resolution]] ##
#-------------------------------------------------------------------------- log.critical('Create computational domain') else: print 'Hello from processor ', myid barrier() # Read in boundary from ordered sts file event_sts = anuga.create_sts_boundary(project.event_sts) # Reading the landward defined points, this incorporates the original clipping # polygon minus the 100m contour landward_boundary = anuga.read_polygon(project.landward_boundary) # Combine sts polyline with landward points bounding_polygon_sts = event_sts + landward_boundary # Number of boundary segments num_ocean_segments = len(event_sts) - 1 # Number of landward_boundary points num_land_points = anuga.file_length(project.landward_boundary) #====================================== # Create sequential domain #====================================== if(myid==0): # Boundary tags refer to project.landward_boundary
import sys import anuga from anuga import distribute, myid, numprocs, finalize #------------------------------------------------------------------------------ # Do the domain creation on processor 0 #------------------------------------------------------------------------------ if myid == 0: # Create DEM from asc data anuga.asc2dem('11_fbe_c.asc', use_cache=False, verbose=True) # Create DEM from asc data anuga.dem2pts('11_fbe_c.dem', use_cache=False, verbose=True) bounding_polygon = anuga.read_polygon('channel.csv') domain = anuga.create_domain_from_regions(bounding_polygon, boundary_tags={'exterior': [1]}, maximum_triangle_area=1, mesh_filename='11f.msh', use_cache=False, verbose=True) #Name domain domain.set_name('11_fbe_c') domain.set_datadir('.') #Set quantities for domain, set dry bed domain.set_quantity('elevation', filename='11_fbe_c.pts') domain.set_quantity('friction', 0.040)
scenario = 'fixed_wave' # Wave applied at the boundary #scenario = 'slide' # Slide wave form applied inside the domain #------------------------------------------------------------------------------ # Filenames #------------------------------------------------------------------------------ name_stem = 'fixed_topobathy_clip' meshname = name_stem + '.msh' # Filename for tide gauges locations gauge_filename = 'gauges_.csv' #------------------------------------------------------------------------------ # Domain definitions #------------------------------------------------------------------------------ # bounding polygon for study area bounding_polygon = anuga.read_polygon('study_area_clip.csv') A = anuga.polygon_area(bounding_polygon) / 1000000.0 print 'Area of bounding polygon = %.2f km^2' % A #------------------------------------------------------------------------------ # Interior region definitions (to create different resolution triangular mesh) #------------------------------------------------------------------------------ # Read interior polygons # poly_extent0 = anuga.read_polygon('extent_pwrj01.csv') # poly_extent1 = anuga.read_polygon('extent_pwrj02.csv') poly_extent1 = anuga.read_polygon('extent_base.csv') poly_extent2 = anuga.read_polygon('extent_b_e_clip.csv') poly_extent3 = anuga.read_polygon('extent_b_w_clip.csv') poly_extent4 = anuga.read_polygon('extent_crop_ne_clip.csv') poly_extent5 = anuga.read_polygon('extent_crop_nw_clip.csv') poly_extent6 = anuga.read_polygon('extent_crop_se_clip.csv')
def run_model(): """Run a tsunami simulation for a scenario.""" # Read in boundary from ordered sts file event_sts = anuga.create_sts_boundary(project.event_sts) # Reading the landward defined points, this incorporates the original # clipping polygon minus the 100m contour landward_boundary = anuga.read_polygon(project.landward_boundary_file, do_complex_check=False) # Combine sts polyline with landward points bounding_polygon_sts = event_sts + landward_boundary # Number of boundary segments num_ocean_segments = len(event_sts) - 1 # Number of landward_boundary points num_land_points = anuga.file_length(project.landward_boundary_file) # Boundary tags refer to project.landward_boundary_file # 4 points equals 5 segments start at N boundary_tags={'back': range(num_ocean_segments+1, num_ocean_segments+num_land_points), 'side': [num_ocean_segments, num_ocean_segments+num_land_points], 'ocean': range(num_ocean_segments)} # Build mesh and domain log.debug('bounding_polygon_sts=%s' % str(bounding_polygon_sts)) log.debug('boundary_tags=%s' % str(boundary_tags)) log.debug('project.bounding_maxarea=%s' % str(project.bounding_maxarea)) log.debug('project.interior_regions=%s' % str(project.interior_regions)) log.debug('project.mesh_file=%s' % str(project.mesh_file)) domain = anuga.create_domain_from_regions(bounding_polygon_sts, boundary_tags=boundary_tags, maximum_triangle_area=project.bounding_maxarea, interior_regions=project.interior_regions, mesh_filename=project.mesh_file, use_cache=False, verbose=False) domain.geo_reference.zone = project.zone_number log.info('\n%s' % domain.statistics()) domain.set_name(project.scenario) domain.set_datadir(project.output_folder) domain.set_minimum_storable_height(0.01) # Don't store depth less than 1cm # set overall friction before setting in interior regions domain.set_quantity('friction', project.friction) # set friction in interior regions, if any defined friction_list = [] for (irtype, filename, friction) in project.interior_regions_list: if irtype.lower() == 'friction': friction_list.append([filename, friction]) if friction_list: log.debug('friction_list=%s' % str(friction_list)) poly_friction = [] for (fname, friction) in friction_list: full_fname = os.path.join(project.polygons_folder, fname) log.debug('Reading friction polygon: %s' % full_fname) poly = anuga.read_polygon(full_fname) poly_friction.append((poly, friction)) log.debug('poly=%s' % str(poly)) domain.set_quantity('friction', anuga.Polygon_function(poly_friction, default=project.friction, geo_reference=domain.geo_reference)) # Set the initial stage in the offcoast region only if project.land_initial_conditions: IC = anuga.Polygon_function(project.land_initial_conditions, default=project.initial_tide, geo_reference=domain.geo_reference) else: IC = project.initial_tide domain.set_quantity('stage', IC, use_cache=True, verbose=False) domain.set_quantity('elevation', filename=project.combined_elevation_file, use_cache=True, verbose=False, alpha=project.alpha) # Setup boundary conditions log.debug('Set boundary - available tags: %s' % domain.get_boundary_tags()) Br = anuga.Reflective_boundary(domain) Bt = anuga.Transmissive_stage_zero_momentum_boundary(domain) Bd = anuga.Dirichlet_boundary([project.initial_tide, 0, 0]) Bf = anuga.Field_boundary(project.event_sts+'.sts', domain, mean_stage=project.initial_tide, time_thinning=1, ## NICK debug default_boundary=anuga.Dirichlet_boundary([0, 0, 0]), default_boundary=Bt, boundary_polygon=bounding_polygon_sts, use_cache=True, verbose=False) domain.set_boundary({'back': Br, 'side': Bt, 'ocean': Bf}) # Evolve system through time t0 = time.time() for t in domain.evolve(yieldstep=project.yieldstep, finaltime=project.finaltime, skip_initial_step=False): log.info('\n%s' % domain.timestepping_statistics()) log.info('\n%s' % domain.boundary_statistics(tags='ocean')) log.info('Simulation took %.2f seconds' % (time.time()-t0))
#scenario = 'slide' # Slide wave form applied inside the domain #------------------------------------------------------------------------------ # Filenames #------------------------------------------------------------------------------ name_stem = 'cairns' meshname = name_stem + '.msh' # Filename for locations where timeseries are to be produced gauge_filename = 'gauges.csv' #------------------------------------------------------------------------------ # Domain definitions #------------------------------------------------------------------------------ # bounding polygon for study area bounding_polygon = anuga.read_polygon('extent.csv') A = anuga.polygon_area(bounding_polygon) / 1000000.0 print('Area of bounding polygon = %.2f km^2' % A) #------------------------------------------------------------------------------ # Interior region definitions #------------------------------------------------------------------------------ # Read interior polygons poly_cairns = anuga.read_polygon('cairns.csv') poly_island0 = anuga.read_polygon('islands.csv') poly_island1 = anuga.read_polygon('islands1.csv') poly_island2 = anuga.read_polygon('islands2.csv') poly_island3 = anuga.read_polygon('islands3.csv') poly_shallow = anuga.read_polygon('shallow.csv')
# Setup Functions #=============================================================================== # Convert an elevation raster into a point file anuga.asc2dem('topo.asc', use_cache=False, verbose=True) anuga.dem2pts('topo.dem', use_cache=False, verbose=True) """ Include the process-specific quantities when creating the domain """ evolved_quantities = ['stage', 'xmomentum', 'ymomentum', 'concentration'] other_quantities=['elevation', 'friction', 'height', 'xvelocity', \ 'yvelocity', 'x', 'y', 'vegetation', 'diffusivity'] # import bounding polygon text file, set boundary tags bounding_polygon = anuga.read_polygon('outline.csv') boundary_tags = { 'bottom': [0], 'side1': [1], 'side2': [2], 'top': [3], 'side3': [4], 'side4': [5] } """ Create the domain with operator-specific function (accepts quantities) """ domain = create_domain_from_regions_sed(bounding_polygon, boundary_tags=boundary_tags, maximum_triangle_area=200, mesh_filename='topo.msh',
def main(): try: try: usage = "usage: jezero.py -1*initialstage-in-m \n Note that -2260 flows but barely does anything. So range for jezero is ~2260 to 2200. \n" parser = optparse.OptionParser(usage=usage) (options, inargs) = parser.parse_args() if not inargs: parser.error("need parameters") jezerostage = -1.0 * float(inargs[0]) # Before doing anything else, set gravity to Mars anuga.g = gravity #domain parameters poly_highres = anuga.read_polygon('JezeroData/PolyHi.csv') poly_bound = anuga.read_polygon( 'JezeroData/PolyBoundBiggerPts.csv') base_scale = 25600 #160 m #HIRES REGION lowres = 10000 * base_scale # 10 km boundary_tags = {'exterior': [0]} # Define list of interior regions with associated resolutions interior_regions = [[poly_highres, base_scale]] meshname = 'JezeroData/jezero.msh' mesh = anuga.create_mesh_from_regions( poly_bound, boundary_tags=boundary_tags, maximum_triangle_area=lowres, interior_regions=interior_regions, verbose=True, filename=meshname, fail_if_polygons_outside=False) evolved_quantities = [ 'stage', 'xmomentum', 'ymomentum', 'concentration', 'sedvolx', 'sedvoly' ] domain = anuga.Domain(meshname, use_cache=False, evolved_quantities=evolved_quantities) domain.g = anuga.g # make sure the domain inherits the package's gravity. domain.set_quantity("elevation", filename="JezeroData/jbigger.pts", use_cache=False, verbose=True) domain.smooth = True name = "jezero" + str(jezerostage) + "_" + str( grainD * 1000.0) + "mm" domain.set_name(name) # Choose between DE0 (less accurate), DE1 (more accurate, slower), DE2 (even more accurate, slower still) domain.set_flow_algorithm('DE0') domain.set_CFL(cfl=1.0) domain.set_minimum_allowed_height( 0.01 ) #raise the default minimum depth from 1 mm to 1 cm to speed the simulation (for computation) domain.set_minimum_storable_height( 0.01 ) #raise the default minimum depth from 1 mm to 1 cm to speed the simulation (for storage/visualization) domain.set_maximum_allowed_speed( 1.0 ) #maximum particle speed that is allowed in water shallower than minimum_allowed_height (back of the envelope suggests 1m/s should be below tau_crit) np.seterr(invalid='ignore') voltotal = np.sum(domain.quantities['elevation'].centroid_values * domain.areas) domain.set_quantity('concentration', 0.00) # Start with no esd domain.set_quantity( 'friction', constantn ) # Constant Manning friction. Only used to initialize domain (calculated every time step). domain.set_quantity('stage', -10000.0) stagepolygon = anuga.read_polygon('JezeroData/stage.csv') domain.set_quantity('stage', jezerostage, polygon=stagepolygon) domain.set_quantities_to_be_stored({ 'stage': 2, 'xmomentum': 2, 'ymomentum': 2, 'elevation': 2 }) np.seterr(invalid='warn') Br = anuga.Reflective_boundary(domain) domain.set_boundary({'exterior': Br}) # fixed_inflow = anuga.Inlet_operator(domain, stagepolygon, Q=1000.0) operatezero = suspendedtransport_operator(domain) operateone = bedloadtransport_operator(domain) operatetwo = friction_operator(domain) operatethree = AoR_operator(domain) breachpoint = [[19080.340, 1097556.781]] initialdomain = copy.deepcopy(domain) initial = domain.get_quantity('elevation').get_values( interpolation_points=breachpoint, location='centroids') print str(initial) ystep = 300.0 ftime = 86400.0 * 5.0 polyline = [[40000, 1090000], [15000, 1120000]] count = 0 for t in domain.evolve(yieldstep=ystep, finaltime=ftime): print domain.timestepping_statistics() print 'xmom:' + str( domain.get_quantity('xmomentum').get_values( interpolation_points=breachpoint, location='centroids')) breacherosion = domain.get_quantity('elevation').get_values( interpolation_points=breachpoint, location='centroids') - initial print 'erosion: ' + str(breacherosion) volcurr = np.sum( domain.quantities['elevation'].centroid_values * domain.areas) volsed = np.sum( domain.quantities['concentration'].centroid_values * domain.quantities['height'].centroid_values * domain.areas) conservation = (volcurr + volsed - voltotal) / voltotal print 'conservation: ' + '{:.8%}'.format(conservation) count = count + 1 time, Q = anuga.get_flow_through_cross_section( name + '.sww', polyline) print Q initname = "initial_" + name + ".asc" finname = "final_" + name + ".asc" fluxname = "flux_" + name + ".txt" np.savetxt(fluxname, Q) anuga.sww2dem(name + '.sww', initname, reduction=0) anuga.sww2dem(name + '.sww', finname, reduction=(count - 1)) finalstats(domain, initialdomain) np.save('XconcC.npy', domain.quantities['concentration'].centroid_values) np.save('XelevC.npy', domain.quantities['elevation'].centroid_values) np.save('XxmC.npy', domain.quantities['xmomentum'].centroid_values) np.save('XymC.npy', domain.quantities['ymomentum'].centroid_values) np.save('XstageC.npy', domain.quantities['stage'].centroid_values) np.save('XconcV.npy', domain.quantities['concentration'].vertex_values) np.save('XelevV.npy', domain.quantities['elevation'].vertex_values) np.save('XxmV.npy', domain.quantities['xmomentum'].vertex_values) np.save('XymV.npy', domain.quantities['ymomentum'].vertex_values) np.save('XstageV.npy', domain.quantities['stage'].vertex_values) except optparse.OptionError, msg: raise Usage(msg) except Usage, err: print >> sys.stderr, err.msg # print >>sys.stderr, "for help use --help" return 2
else: output_run = receive(0) if(earthquake_type=='synthetic_slip'): # Location to save output synthetic earthqake files slip_output=output_run + '/' + synthetic_slip_dirname + '/' # Location to store the '.pts' file which is written prior to mesh generation meshname = output_run + '/' + name_stem + '.msh' #------------------------------------------------------------------------------ # Domain definitions #------------------------------------------------------------------------------ # Use these very large zones as a boundary condition buffer. bounding_polygon=anuga.read_polygon('INPUT_DATA/buffer_0.csv') bounding_polygon_inner=anuga.read_polygon('INPUT_DATA/buffer_box.csv') bounding_polygon_1 = anuga.read_polygon('INPUT_DATA/main_extent.csv') # Site specific regions if(detailed_region=='idealTsunami'): pass else: err_mess='detailed_region not recognized' raise sys.exit(err_mess) # Define resolutions (max area per triangle) for each polygon #default_res = 400000*400000*0.5 # 400km triangles -- indended to be very very diffusive, to avoid boundary reflections low_res_0=400000*400000*0.5 # 40km triangles -- intended to be very diffusive, avoid boundary reflections low_res_1=40000*40000*0.5 # 40km triangles -- intended to be very diffusive, avoid boundary reflections default_res_1 = 3000*3000*0.5 # Decent 'deep-water' resolution interior_1_res=1000*1000*0.5 # Intermediate depth water resolution.
if verbose: print domain.get_extent(absolute=True) #------------------------------------------------------------------------------ # Setup initial conditions #------------------------------------------------------------------------------ domain.set_quantity('stage', 0.0) # Friction -- 2 options variable_friction = True if not variable_friction: # Constant friction domain.set_quantity('friction', 0.02) else: # Set friction to 0.02 on roads, 0.04 elsewhere road_polygon = anuga.read_polygon('Road/RoadPolygon.csv') friction_function = qs.composite_quantity_setting_function( [ [road_polygon, 0.02], ['All', 0.04] ], domain) domain.set_quantity('friction', friction_function) # Elevation if houses_as_holes: domain.set_quantity('elevation', filename='topography1.pts', use_cache=use_cache, verbose=verbose) else: domain.set_quantity('elevation', filename='topography1.pts', use_cache=use_cache, verbose=verbose, location='vertices')
import numpy cache = False verbose = True # Define Scenario # the final goal is to define a rainfall scenario # Here, in order to test, we follow the example to first have a fixed wave scenario scenario = 'fixed_wave' name_stem = 'aw_small' meshname = name_stem + '.msh' gage_file_name = 'aw_small_gauges.csv' # bounding polygon for study area bounding_polygon = anuga.read_polygon('aw_small_extent.csv') A = anuga.polygon_area(bounding_polygon) / 1000000.0 print 'Area of bounding polygon = %.2f km^2' % A # Read interior polygons poly_river = anuga.read_polygon('aw_small_river.csv') # the greater the base_scale is the less the triangle it will be divided into just_fitting = False base_scale = 5000 background_res = 10 * base_scale river_res = base_scale city_res = base_scale interior_regions = [[poly_river, river_res]]
def run_model(): """Run a tsunami simulation for a scenario.""" log.info('@'*90) log.info('@ Running simulation') log.info('@'*90) # Read in boundary from ordered sts file event_sts = anuga.create_sts_boundary(project.event_sts) # Reading the landward defined points, this incorporates the original # clipping polygon minus the 100m contour landward_boundary = anuga.read_polygon(project.landward_boundary) # Combine sts polyline with landward points bounding_polygon_sts = event_sts + landward_boundary # Number of boundary segments num_ocean_segments = len(event_sts) - 1 # Number of landward_boundary points num_land_points = anuga.file_length(project.landward_boundary) # Boundary tags refer to project.landward_boundary # 4 points equals 5 segments start at N boundary_tags={'back': range(num_ocean_segments+1, num_ocean_segments+num_land_points), 'side': [num_ocean_segments, num_ocean_segments+num_land_points], 'ocean': range(num_ocean_segments)} # Build mesh and domain log.debug('bounding_polygon_sts=%s' % str(bounding_polygon_sts)) log.debug('boundary_tags=%s' % str(boundary_tags)) log.debug('project.bounding_maxarea=%s' % str(project.bounding_maxarea)) log.debug('project.interior_regions=%s' % str(project.interior_regions)) log.debug('project.meshes=%s' % str(project.meshes)) domain = anuga.create_domain_from_regions(bounding_polygon_sts, boundary_tags=boundary_tags, maximum_triangle_area=project.bounding_maxarea, interior_regions=project.interior_regions, mesh_filename=project.meshes, use_cache=False, verbose=False) domain.geo_reference.zone = project.zone log.info('\n%s' % domain.statistics()) domain.set_name(project.scenario_name) domain.set_datadir(project.output_folder) domain.set_minimum_storable_height(0.01) # Don't store depth less than 1cm # Set the initial stage in the offcoast region only if project.land_initial_conditions: IC = anuga.Polygon_function(project.land_initial_conditions, default=project.tide, geo_reference=domain.geo_reference) else: IC = project.tide domain.set_quantity('stage', IC, use_cache=True, verbose=False) domain.set_quantity('friction', project.friction) domain.set_quantity('elevation', filename=project.combined_elevation_filestem+'.pts', use_cache=True, verbose=False, alpha=project.alpha) # Setup boundary conditions log.debug('Set boundary - available tags: %s' % domain.get_boundary_tags()) Br = anuga.Reflective_boundary(domain) Bt = anuga.Transmissive_stage_zero_momentum_boundary(domain) Bd = anuga.Dirichlet_boundary([project.tide, 0, 0]) Bf = anuga.Field_boundary(project.event_sts+'.sts', domain, mean_stage=project.tide, time_thinning=1, default_boundary=anuga.Dirichlet_boundary([0, 0, 0]), boundary_polygon=bounding_polygon_sts, use_cache=True, verbose=False) domain.set_boundary({'back': Br, 'side': Bt, 'ocean': Bf}) # Evolve system through time t0 = time.time() for t in domain.evolve(yieldstep=project.yieldstep, finaltime=project.finaltime, skip_initial_step=False): log.info('\n%s' % domain.timestepping_statistics()) log.info('\n%s' % domain.boundary_statistics(tags='ocean')) log.info('Simulation took %.2f seconds' % (time.time()-t0))
scenario = 'fixed_wave' # Wave applied at the boundary #scenario = 'slide' # Slide wave form applied inside the domain #------------------------------------------------------------------------------ # Filenames #------------------------------------------------------------------------------ name_stem = 'fixed_topobathy' meshname = name_stem + '.msh' # Filename for tide gauges locations gauge_filename = 'gauges_.csv' #------------------------------------------------------------------------------ # Domain definitions #------------------------------------------------------------------------------ # bounding polygon for study area bounding_polygon = anuga.read_polygon('study_area3.csv') A = anuga.polygon_area(bounding_polygon) / 1000000.0 print 'Area of bounding polygon = %.2f km^2' % A #------------------------------------------------------------------------------ # Interior region definitions (to create different resolution triangular mesh) #------------------------------------------------------------------------------ # Read interior polygons poly_extent1 = anuga.read_polygon('extent_pwrj02.csv') poly_extent2 = anuga.read_polygon('extent_b_e.csv') poly_extent3 = anuga.read_polygon('extent_b_w.csv') poly_extent4 = anuga.read_polygon('extent_c_n_e.csv') poly_extent5 = anuga.read_polygon('extent_c_n_w.csv') poly_extent6 = anuga.read_polygon('extent_c_s_e.csv') poly_extent7 = anuga.read_polygon('extent_c_s_w.csv')
meshname = 'model/terrain.tsh' #------------------------------------------------------------------------------ # CREATING MESH #------------------------------------------------------------------------------ riverWall_csv_files = glob.glob( 'model/wall/*.csv') # Make a list of the csv files in BREAKLINES (riverWalls, riverWall_parameters) = su.readListOfRiverWalls(riverWall_csv_files) CatchmentDictionary = { 'model/kerb/kerb1.csv': 0.01, 'model/kerb/kerb2.csv': 0.01 } bounding_polygon = anuga.read_polygon('model/domain.csv') interior_regions = anuga.read_polygon_dir(CatchmentDictionary, 'model/kerb') import numpy as num b_polygon = num.array(bounding_polygon) print(b_polygon) import matplotlib.pyplot as plt plt.figure() plt.plot(b_polygon[:, 0], b_polygon[:, 1]) for i, v in enumerate(b_polygon): plt.annotate(str(v), xy=v, xytext=(-7, 7), textcoords='offset points') plt.pause(0.01) create_mesh_from_regions( bounding_polygon,
#scenario = 'slide' # Slide wave form applied inside the domain #------------------------------------------------------------------------------ # Filenames #------------------------------------------------------------------------------ name_stem = cairns_dir+'cairns' meshname = name_stem + '.msh' # Filename for locations where timeseries are to be produced gauge_filename = cairns_dir + 'gauges.csv' #------------------------------------------------------------------------------ # Domain definitions #------------------------------------------------------------------------------ # bounding polygon for study area bounding_polygon = anuga.read_polygon(cairns_dir+'extent.csv') A = anuga.polygon_area(bounding_polygon) / 1000000.0 if __name__ == '_main_': print 'Area of bounding polygon = %.2f km^2' % A #------------------------------------------------------------------------------ # Interior region definitions #------------------------------------------------------------------------------ # Read interior polygons poly_cairns = anuga.read_polygon(cairns_dir+'cairns.csv') poly_island0 = anuga.read_polygon(cairns_dir+'islands.csv') poly_island1 = anuga.read_polygon(cairns_dir+'islands1.csv') poly_island2 = anuga.read_polygon(cairns_dir+'islands2.csv') poly_island3 = anuga.read_polygon(cairns_dir+'islands3.csv') poly_shallow = anuga.read_polygon(cairns_dir+'shallow.csv')
def setup_model(): """Perform sanity checks. The checks here can be simpler than for full-blown ANUGA as the directory structure is automatically generated. """ # flag - we check many things and then don't proceed if anything wrong sanity_error = False # checked at bottom of this file ##### # check directory Structure ##### if not os.path.exists(project.home): log.error("Sorry, data directory '%s' doesn't exist" % project.home) sanity_error = True if not os.path.exists(project.muxhome): log.error("Sorry, MUX directory '%s' doesn't exist" % project.muxhome) sanity_error = True if not os.path.exists(project.anuga_folder): log.error("Sorry, ANUGA directory '%s' doesn't exist" % project.anuga_folder) sanity_error = True if not os.path.exists(project.topographies_folder): log.error("Sorry, topo directory '%s' doesn't exist" % project.topographies_folder) sanity_error = True if not os.path.exists(project.polygons_folder): log.error("Sorry, polygon directory '%s' doesn't exist" % project.polygons_folder) sanity_error = True if not os.path.exists(project.boundaries_folder): log.error("Sorry, boundaries directory '%s' doesn't exist" % project.boundaries_folder) sanity_error = True if not os.path.exists(project.output_folder): log.error("Sorry, outputs directory '%s' doesn't exist" % project.output_folder) sanity_error = True if not os.path.exists(project.gauges_folder): log.error("Sorry, gauges directory '%s' doesn't exist" % project.gauges_folder) sanity_error = True if not os.path.exists(project.meshes_folder): log.error("Sorry, meshes directory '%s' doesn't exist" % project.meshes_folder) sanity_error = True if not os.path.exists(project.mux_data_folder): log.error("Sorry, mux data directory '%s' doesn't exist" % project.mux_data_folder) sanity_error = True # generate the event.lst file for the event get_multimux(project.event, project.multimux_folder, project.mux_input) # if multi_mux is True, check if multi-mux file exists if project.multi_mux: if not os.path.exists(project.mux_input): log.error("Sorry, MUX input file '%s' doesn't exist" % project.mux_input) sanity_error = True if not os.path.exists(project.event_folder): log.error("Sorry, you must generate event %s with EventSelection." % project.event) sanity_error = True ##### # determine type of run, set some parameters depending on type ##### if project.setup == 'trial': project.scale_factor = 100 project.time_thinning = 96 project.yieldstep = 240 elif project.setup == 'basic': project.scale_factor = 4 project.time_thinning = 12 project.yieldstep = 120 elif project.setup == 'final': project.scale_factor = 1 project.time_thinning = 4 project.yieldstep = 60 else: log.error("Sorry, you must set the 'setup' variable to one of:" ' trial - coarsest mesh, fast\n' ' basic - coarse mesh\n' ' final - fine mesh, slowest\n' '\n' "'setup' was set to '%s'" % project.setup) sanity_error = True ##### # check for errors detected above. ##### if sanity_error: msg = 'You must fix the above errors before continuing.' raise Exception(msg) ##### # Reading polygons and creating interior regions ##### # # Create list of land polygons with initial conditions # project.land_initial_conditions = [] # for (filename, MSL) in project.land_initial_conditions_filename: # polygon = anuga.read_polygon(os.path.join(project.polygons_folder, # filename)) # project.land_initial_conditions.append([polygon, MSL]) # Create list of interior polygons with scaling factor project.interior_regions = [] for (filename, maxarea) in project.interior_regions_data: polygon = anuga.read_polygon(os.path.join(project.polygons_folder, filename)) project.interior_regions.append([polygon, maxarea*project.scale_factor]) # Initial bounding polygon for data clipping project.bounding_polygon = anuga.read_polygon(os.path.join( project.polygons_folder, project.bounding_polygon)) project.bounding_maxarea = project.bounding_polygon_maxarea \ * project.scale_factor # Estimate the number of triangles log.debug('number_mesh_triangles(%s, %s, %s)' % (str(project.interior_regions), str(project.bounding_polygon), str(project.bounding_maxarea))) triangle_min = number_mesh_triangles(project.interior_regions, project.bounding_polygon, project.bounding_maxarea) log.info('minimum estimated number of triangles=%d' % triangle_min)
# resolutions (maximal area of per triangle) for each polygon #-------------------------------------------------------------------------- log.critical('Create computational domain') else: print 'Hello from processor ', myid barrier() # Read in boundary from ordered sts file event_sts = anuga.create_sts_boundary(project.event_sts) # Reading the landward defined points, this incorporates the original clipping # polygon minus the 100m contour landward_boundary = anuga.read_polygon(project.landward_boundary) # Combine sts polyline with landward points bounding_polygon_sts = event_sts + landward_boundary # Number of boundary segments num_ocean_segments = len(event_sts) - 1 # Number of landward_boundary points num_land_points = anuga.file_length(project.landward_boundary) #====================================== # Create sequential domain #====================================== if (myid == 0): # Boundary tags refer to project.landward_boundary # 4 points equals 5 segments start at N
# Filenames #------------------------------------------------------------------------------ name_stem = scenario_name = '${name_stem}' event_number = 'T' + str(periodT) rp = 10000 meshname = name_stem + '.msh' # Filename for locations where timeseries are to be produced gauge_filename = 'gauges_busselton.csv' #------------------------------------------------------------------------------ # Domain definitions #------------------------------------------------------------------------------ # bounding polygon for study area bounding_polygon = anuga.read_polygon('busselton_extent_edit.csv') A = anuga.polygon_area(bounding_polygon) / 1000000.0 print 'Area of bounding polygon = %.2f km^2' % A #------------------------------------------------------------------------------ # Interior region definitions #------------------------------------------------------------------------------ # Read interior polygons poly_1 = anuga.read_polygon('busselton_1km.csv') poly_2 = anuga.read_polygon('bunbury_1km_extend.csv') poly_3 = anuga.read_polygon('busselton_20m.csv') #poly_island2 = anuga.read_polygon('islands2.csv') #poly_island3 = anuga.read_polygon('islands3.csv') #poly_shallow = anuga.read_polygon('shallow.csv')
#from culverts import * #------------------------------------------------------------------------------ # Preparation of topographic data # Convert ASC 2 DEM 2 PTS using source data and store result in source data #------------------------------------------------------------------------------ # Create DEM from asc data anuga.asc2dem(project.tmppath + 'dtm_utm.mean.asc', use_cache=False, verbose=verbose) # Create pts file for onshore DEM anuga.dem2pts(project.tmppath + 'dtm_utm.mean.dem', use_cache=False, verbose=verbose) bounding_polygon = anuga.read_polygon(project.configpath + 'extent.csv') #------------------------------------------------------------------------------ # Prepare breaklines # #------------------------------------------------------------------------------ conn_params = "host=titania dbname=research user=geodan" conn = psycopg2.connect(conn_params) cur = conn.cursor() breaklines = [] querystring = """ WITH extent AS ( SELECT ST_Transform(ST_SetSrid(ST_MakeEnvelope(%s),32631),28992) as geom ) ,transformed As(
rain.rain_max_in_period = np.max(rain.precip_total) rain.radar_dir = None l0 = [5100.0, 100000.0] l1 = [5100.0, 103900.0] l2 = [3400., 103400.] l3 = [6000., 103400.] locations = [l0,l1,l2,l3] else: pass print(rain.radar_dir) try: p2 = anuga.read_polygon(Catchment_file) print('Catchment File') print(Catchment_file) #print p2 except: p2 = None pass try: p3 = anuga.read_polygon(State_boundary_file) print('State_boundary_file') print(State_boundary_file) #print p3 except: p3 = None pass
use_cache=False, verbose=True) # Create DEM from asc data anuga.dem2pts('11_fbe_c.dem', use_cache=False, verbose=True) # Create roughness raster from asc data #anuga.asc2dem('11_man_c.asc', use_cache=False, verbose=True) # Create roughness raster from asc data #anuga.dem2pts('11_man_c.dem', use_cache=False, # verbose=True) # In[3]: bounding_polygon = anuga.read_polygon('extent.csv') domain = anuga.create_domain_from_regions(bounding_polygon, boundary_tags={ 'top': [0], 'right': [1], 'bottom': [2], 'left': [3] }, maximum_triangle_area=1, mesh_filename='11f.msh', use_cache=False, verbose=True) #domain = anuga.Domain(points, vertices, boundary) domain.set_name('11_fbe_c') domain.set_datadir('.')