def concept_ungenerateIII(self): from anuga import Domain, Reflective_boundary, \ Dirichlet_boundary from anuga.pmesh.mesh_interface import create_mesh_from_regions # These are the absolute values polygon = [[0,0], [100,0], [100,100], [0,100]] boundary_tags = {'wall': [0,1,3], 'wave': [2]} inner1_polygon = [[10,10], [20,10], [20,20], [10,20]] inner2_polygon = [[30,30], [40,30], [40,40], [30,40]] max_area = 1 interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] m = create_mesh_from_regions(polygon, boundary_tags, max_area, interior_regions=interior_regions) fileName = tempfile.mktemp('.txt') file = open(fileName, 'w') file.write(' 1 ?? ??\n\ 90.0 90.0\n\ 81.0 90.0\n\ 81.0 81.0\n\ 90.0 81.0\n\ 90.0 90.0\n\ END\n\ 2 ?? ??\n\ 10.0 80.0\n\ 10.0 90.0\n\ 20.0 90.0\n\ 10.0 80.0\n\ END\n\ END\n') file.close() m.import_ungenerate_file(fileName) os.remove(fileName) m.generate_mesh(maximum_triangle_area=max_area, verbose=False) mesh_filename = 'mesh.tsh' m.export_mesh_file(mesh_filename) domain = Domain(mesh_filename, use_cache=False) Br = Reflective_boundary(domain) Bd = Dirichlet_boundary([3, 0, 0]) domain.set_boundary({'wall': Br, 'wave': Bd}) yieldstep = 0.1 finaltime = 10 for t in domain.evolve(yieldstep, finaltime): domain.write_time()
def concept_ungenerateIII(self): from anuga import Domain, Reflective_boundary, \ Dirichlet_boundary from anuga.pmesh.mesh_interface import create_mesh_from_regions # These are the absolute values polygon = [[0, 0], [100, 0], [100, 100], [0, 100]] boundary_tags = {'wall': [0, 1, 3], 'wave': [2]} inner1_polygon = [[10, 10], [20, 10], [20, 20], [10, 20]] inner2_polygon = [[30, 30], [40, 30], [40, 40], [30, 40]] max_area = 1 interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] m = create_mesh_from_regions(polygon, boundary_tags, max_area, interior_regions=interior_regions) fileName = tempfile.mktemp('.txt') file = open(fileName, 'w') file.write(' 1 ?? ??\n\ 90.0 90.0\n\ 81.0 90.0\n\ 81.0 81.0\n\ 90.0 81.0\n\ 90.0 90.0\n\ END\n\ 2 ?? ??\n\ 10.0 80.0\n\ 10.0 90.0\n\ 20.0 90.0\n\ 10.0 80.0\n\ END\n\ END\n') file.close() m.import_ungenerate_file(fileName) os.remove(fileName) m.generate_mesh(maximum_triangle_area=max_area, verbose=False) mesh_filename = 'mesh.tsh' m.export_mesh_file(mesh_filename) domain = Domain(mesh_filename, use_cache=False) Br = Reflective_boundary(domain) Bd = Dirichlet_boundary([3, 0, 0]) domain.set_boundary({'wall': Br, 'wave': Bd}) yieldstep = 0.1 finaltime = 10 for t in domain.evolve(yieldstep, finaltime): domain.write_time()
##vis.start() #=============================================================================== if myid == 0: #------------------------------------------------------------------------------ # Produce a documentation of parameters #------------------------------------------------------------------------------ parameter_file=open('parameters.tex', 'w') parameter_file.write('\\begin{verbatim}\n') from pprint import pprint pprint(domain.get_algorithm_parameters(),parameter_file,indent=4) parameter_file.write('\\end{verbatim}\n') parameter_file.close() #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ for t in domain.evolve(yieldstep = 1000., finaltime = 30000.): #print domain.timestepping_statistics(track_speeds=True) if myid == 0 and verbose: print domain.timestepping_statistics() #vis.update() domain.sww_merge(delete_old=True) finalize()
#---------------------------------------------- # Associate boundary tags with boundary objects #---------------------------------------------- domain.set_boundary({'left': Br, 'right': Bd, 'top': Br, 'bottom': Br}) #------------------------------ #Evolve the system through time #------------------------------ #xwrite=open("xvel.out","wb") #ywrite=open("yvel.out","wb") ## Set print options to be compatible with file writing via the 'print' statement #numpy.set_printoptions(threshold=numpy.nan, linewidth=numpy.nan) #------------------------------------------------------------------------------ # Produce a documentation of parameters #------------------------------------------------------------------------------ if myid == 0: parameter_file = open('parameters.tex', 'w') parameter_file.write('\\begin{verbatim}\n') from pprint import pprint pprint(domain.get_algorithm_parameters(), parameter_file, indent=4) parameter_file.write('\\end{verbatim}\n') parameter_file.close() for t in domain.evolve(yieldstep=0.2, finaltime=30.0): if myid == 0 and verbose: print(domain.timestepping_statistics()) domain.sww_merge(delete_old=True) finalize()
def sequential_time_varying_file_boundary_sts(self): """sequential_ltest_time_varying_file_boundary_sts_sequential(self): Read correct points from ordering file and apply sts to boundary. The boundary is time varying. FIXME add to test_urs2sts. """ lat_long_points=[[6.01,97.0],[6.02,97.0],[6.05,96.9],[6.0,97.0]] bounding_polygon=[[6.0,97.0],[6.01,97.0],[6.02,97.0], [6.02,97.02],[6.00,97.02]] tide = 3.0 time_step_count = 65 time_step = 2. n=len(lat_long_points) first_tstep=num.ones(n,num.int) last_tstep=(time_step_count)*num.ones(n,num.int) finaltime=num.float(time_step*(time_step_count-1)) yieldstep=num.float(time_step) gauge_depth=20*num.ones(n,num.float) ha=2*num.ones((n,time_step_count),num.float) ua=10*num.ones((n,time_step_count),num.float) va=-10*num.ones((n,time_step_count),num.float) times=num.arange(0., num.float(time_step_count*time_step), time_step) for i in range(n): #ha[i]+=num.sin(times) ha[i]+=times/finaltime sts_file="test" if myid==0: base_name, files = self.write_mux2(lat_long_points, time_step_count, time_step, first_tstep, last_tstep, depth=gauge_depth, ha=ha, ua=ua, va=va) # base name will not exist, but 3 other files are created # Write order file file_handle, order_base_name = tempfile.mkstemp("") os.close(file_handle) os.remove(order_base_name) d="," order_file=order_base_name+'order.txt' fid=open(order_file,'w') # Write Header header='index, longitude, latitude\n' fid.write(header) indices=[3,0,1] for i in indices: line=str(i)+d+str(lat_long_points[i][1])+d+\ str(lat_long_points[i][0])+"\n" fid.write(line) fid.close() urs2sts(base_name, basename_out=sts_file, ordering_filename=order_file, mean_stage=tide, verbose=verbose) self.delete_mux(files) assert(os.access(sts_file+'.sts', os.F_OK)) os.remove(order_file) barrier() boundary_polygon = create_sts_boundary(sts_file) # Append the remaining part of the boundary polygon to be defined by # the user bounding_polygon_utm=[] for point in bounding_polygon: zone,easting,northing=redfearn(point[0],point[1]) bounding_polygon_utm.append([easting,northing]) boundary_polygon.append(bounding_polygon_utm[3]) boundary_polygon.append(bounding_polygon_utm[4]) assert num.allclose(bounding_polygon_utm,boundary_polygon) extent_res=1000000 meshname = 'urs_test_mesh' + '.tsh' interior_regions=None boundary_tags={'ocean': [0,1], 'otherocean': [2,3,4]} # have to change boundary tags from last example because now bounding # polygon starts in different place. if myid==0: create_mesh_from_regions(boundary_polygon, boundary_tags=boundary_tags, maximum_triangle_area=extent_res, filename=meshname, interior_regions=interior_regions, verbose=verbose) barrier() domain_fbound = Domain(meshname) domain_fbound.set_quantities_to_be_stored(None) domain_fbound.set_quantity('stage', tide) if verbose: print "Creating file boundary condition" Bf = File_boundary(sts_file+'.sts', domain_fbound, boundary_polygon=boundary_polygon) Br = Reflective_boundary(domain_fbound) domain_fbound.set_boundary({'ocean': Bf,'otherocean': Br}) temp_fbound=num.zeros(int(finaltime/yieldstep)+1,num.float) if verbose: print "Evolving domain with file boundary condition" for i, t in enumerate(domain_fbound.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step = False)): temp_fbound[i]=domain_fbound.quantities['stage'].centroid_values[2] if verbose: domain_fbound.write_time() domain_drchlt = Domain(meshname) domain_drchlt.set_quantities_to_be_stored(None) domain_drchlt.set_starttime(time_step) domain_drchlt.set_quantity('stage', tide) Br = Reflective_boundary(domain_drchlt) #Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide]) Bd = Time_boundary(domain=domain_drchlt, f=lambda t: [2.0+t/finaltime+tide,220.+10.*tide+10.*t/finaltime,-220.-10.*tide-10.*t/finaltime]) #Bd = Time_boundary(domain=domain_drchlt,f=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)]) domain_drchlt.set_boundary({'ocean': Bd,'otherocean': Br}) temp_drchlt=num.zeros(int(finaltime/yieldstep)+1,num.float) for i, t in enumerate(domain_drchlt.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step = False)): temp_drchlt[i]=domain_drchlt.quantities['stage'].centroid_values[2] #domain_drchlt.write_time() #print domain_fbound.quantities['stage'].vertex_values #print domain_drchlt.quantities['stage'].vertex_values assert num.allclose(temp_fbound,temp_drchlt),temp_fbound-temp_drchlt assert num.allclose(domain_fbound.quantities['stage'].vertex_values, domain_drchlt.quantities['stage'].vertex_values) assert num.allclose(domain_fbound.quantities['xmomentum'].vertex_values, domain_drchlt.quantities['xmomentum'].vertex_values) assert num.allclose(domain_fbound.quantities['ymomentum'].vertex_values, domain_drchlt.quantities['ymomentum'].vertex_values) if not sys.platform == 'win32': if myid==0: os.remove(sts_file+'.sts') if myid==0: os.remove(meshname)
#------------------------------------------------------------------------------ # Produce a documentation of parameters #------------------------------------------------------------------------------ if myid == 0: parameter_file = open('parameters.tex', 'w') parameter_file.write('\\begin{verbatim}\n') from pprint import pprint pprint(domain.get_algorithm_parameters(), parameter_file, indent=4) parameter_file.write('\\end{verbatim}\n') parameter_file.close() #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ for t in domain.evolve(yieldstep=10.0, finaltime=3000.0): if myid == 0 and verbose: print domain.timestepping_statistics() #print (stage-elev).get_integral() #print (domain.areas*(domain.quantities['stage'].centroid_values - domain.quantities['elevation'].centroid_values)).sum() #s3 = domain.get_flow_through_cross_section([[30., 0.0], [30., 100.]]) #s4 = domain.get_flow_through_cross_section([[32., 0.0], [32., 100.]]) #s5 = domain.get_flow_through_cross_section([[34., 0.0], [34., 100.]]) #s2 = domain.get_flow_through_cross_section([[45., 0.0], [45., 100.]]) #s1 = domain.get_flow_through_cross_section([[53., 0.0], [53., 100.]]) #s0 = domain.get_flow_through_cross_section([[60., 0.0], [60., 100.]]) #print 'Xsectional flow:', s0, s1, s2, s3, s4, s5 domain.sww_merge(delete_old=True) finalize()
# create parallel domain #=================================================================================== domain = distribute(domain) #----------------------------------------------------------------------------- # Setup boundary conditions #------------------------------------------------------------------------------ Br = anuga.Reflective_boundary(domain) # Solid reflective wall Bt = anuga.Transmissive_boundary(domain) # Continue all values on boundary Bd = anuga.Dirichlet_boundary([1, 0., 0.]) # Constant boundary values # Associate boundary tags with boundary objects domain.set_boundary({'left': Bt, 'right': Bt, 'top': Br, 'bottom': Br}) #------------------------------------------------------------------------- # Produce a documentation of parameters #------------------------------------------------------------------------- from anuga.validation_utilities import save_parameters_tex save_parameters_tex(domain) #=================================================================================== # Evolve system through time #=================================================================================== for t in domain.evolve(yieldstep=0.5, finaltime=50.): if myid == 0 and verbose: print domain.timestepping_statistics() domain.sww_merge(delete_old=True) finalize()
return [wO, pO, 0.0] # dimensional Br = anuga.Reflective_boundary(domain) # Solid reflective wall Bt = anuga.Transmissive_boundary(domain) # Continue all values on boundary #Bd = anuga.Dirichlet_boundary([1,0.,0.]) # Constant boundary values BTime = anuga.Time_boundary(domain,f_CG) # Associate boundary tags with boundary objects domain.set_boundary({'left': BTime, 'right': Bt, 'top': Br, 'bottom': Br}) #------------------------------------------------------------------------------ # Produce a documentation of parameters #------------------------------------------------------------------------------ if myid == 0: parameter_file=open('parameters.tex', 'w') parameter_file.write('\\begin{verbatim}\n') from pprint import pprint pprint(domain.get_algorithm_parameters(),parameter_file,indent=4) parameter_file.write('\\end{verbatim}\n') parameter_file.close() #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ for t in domain.evolve(yieldstep = Tp/48., finaltime = 7000.): if myid == 0 and verbose: print domain.timestepping_statistics() domain.sww_merge(delete_old=True) finalize()
domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br}) #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ polygon1 = [ [10.0, 0.0], [11.0, 0.0], [11.0, 5.0], [10.0, 5.0] ] polygon2 = [ [12.0, 2.0], [13.0, 2.0], [13.0, 3.0], [12.0, 3.0] ] from anuga.operators.rate_operators import Rate_operator op1 = Rate_operator(domain, rate=lambda t: 10.0 if (t>=0.0) else 0.0, polygon=polygon2) op2 = Rate_operator(domain, rate=lambda t: 10.0 if (t>=0.0) else 0.0, radius=0.5, center=(10.0, 3.0)) domain.set_starttime(-0.1) for t in domain.evolve(yieldstep=0.01, finaltime=0.0): domain.print_timestepping_statistics() domain.print_operator_timestepping_statistics() stage = domain.get_quantity('stage') elev = domain.get_quantity('elevation') height = stage - elev print 'integral = ', height.get_integral() for t in domain.evolve(yieldstep=0.1, duration=5.0): domain.print_timestepping_statistics() domain.print_operator_timestepping_statistics()
def start_sim(run_id, Runs, scenario_name, Scenario, session, **kwargs): yieldstep = kwargs['yieldstep'] finaltime = kwargs['finaltime'] logger = logging.getLogger(run_id) max_triangle_area = kwargs['max_triangle_area'] logger.info('Starting hydrata_project') if run_id == 'local_run': base_dir = os.getcwd() else: base_dir = os.getcwd() + '/base_dir/%s/' % run_id outname = run_id meshname = base_dir + 'outputs/' + run_id + '.msh' def get_filename(data_type, file_type): files = os.listdir('%sinputs/%s' % (base_dir, data_type)) filename = '%sinputs/%s/%s' % ( base_dir, data_type, [f for f in files if f[-4:] == file_type][0]) return filename boundary_data_filename = get_filename('boundary_data', '.shp') elevation_data_filename = get_filename('elevation_data', '.tif') try: structures_filename = get_filename('structures', '.shp') except OSError as e: structures_filename = None try: rain_data_filename = get_filename('rain_data', '.shp') except OSError as e: rain_data_filename = None try: inflow_data_filename = get_filename('inflow_data', '.shp') except OSError as e: inflow_data_filename = None try: friction_data_filename = get_filename('friction_data', '.shp') except OSError as e: friction_data_filename = None logger.info('boundary_data_filename: %s' % boundary_data_filename) logger.info('structures_filename: %s' % structures_filename) logger.info('rain_data_filename: %s' % rain_data_filename) logger.info('inflow_data_filename: %s' % inflow_data_filename) logger.info('friction_data_filename: %s' % friction_data_filename) logger.info('elevation_data_filename: %s' % elevation_data_filename) # create a list of project files vector_filenames = [ boundary_data_filename, structures_filename, rain_data_filename, inflow_data_filename, friction_data_filename ] # set the projection system for ANUGA calculations from the geotiff elevation data elevation_data_gdal = gdal.Open(elevation_data_filename) project_spatial_ref = osr.SpatialReference() project_spatial_ref.ImportFromWkt(elevation_data_gdal.GetProjectionRef()) project_spatial_ref_epsg_code = int( project_spatial_ref.GetAttrValue("AUTHORITY", 1)) # check the spatial reference system of the project files matches that of the calculation for filename in vector_filenames: if filename: prj_text = open(filename[:-4] + '.prj').read() srs = osr.SpatialReference() srs.ImportFromESRI([prj_text]) srs.AutoIdentifyEPSG() logger.info('filename is: %s' % filename) logger.info('EPSG is: %s' % srs.GetAuthorityCode(None)) if str(srs.GetAuthorityCode(None)) != str( project_spatial_ref_epsg_code): logger.warning('warning spatial refs are not maching: %s, %s' % (srs.GetAuthorityCode(None), project_spatial_ref_epsg_code)) logger.info('Setting up structures...') if structures_filename: structures = [] logger.info('processing structures from :%s' % structures_filename) ogr_shapefile = ogr.Open(structures_filename) ogr_layer = ogr_shapefile.GetLayer(0) ogr_layer_feature = ogr_layer.GetNextFeature() while ogr_layer_feature: structure = json.loads(ogr_layer_feature.GetGeometryRef(). ExportToJson())['coordinates'][0] structures.append(structure) ogr_layer_feature = None ogr_layer_feature = ogr_layer.GetNextFeature() logger.info('structures: %s' % structures) else: logger.warning('warning: no structures found.') structures = None logger.info('Setting up friction...') frictions = [] if friction_data_filename: logger.info('processing frictions from :%s' % friction_data_filename) ogr_shapefile = ogr.Open(friction_data_filename) ogr_layer = ogr_shapefile.GetLayer(0) ogr_layer_feature = ogr_layer.GetNextFeature() while ogr_layer_feature: friction_poly = json.loads(ogr_layer_feature.GetGeometryRef(). ExportToJson())['coordinates'][0] friction_value = float(ogr_layer_feature.GetField('mannings')) friction_couple = [friction_poly, friction_value] frictions.append(friction_couple) ogr_layer_feature = None ogr_layer_feature = ogr_layer.GetNextFeature() frictions.append(['All', 0.04]) logger.info('frictions: %s' % frictions) else: frictions.append(['All', 0.04]) logger.info('warning: no frictions found.') logger.info('Setting up boundary conditions...') ogr_shapefile = ogr.Open(boundary_data_filename) ogr_layer = ogr_shapefile.GetLayer(0) ogr_layer_definition = ogr_layer.GetLayerDefn() logger.info('ogr_layer_definition.GetGeomType: %s' % ogr_layer_definition.GetGeomType()) boundary_tag_index = 0 bdy_tags = {} bdy = {} ogr_layer_feature = ogr_layer.GetNextFeature() while ogr_layer_feature: boundary_tag_key = ogr_layer_feature.GetField('bdy_tag_k') boundary_tag_value = ogr_layer_feature.GetField('bdy_tag_v') bdy_tags[boundary_tag_key] = [ boundary_tag_index * 2, boundary_tag_index * 2 + 1 ] bdy[boundary_tag_key] = boundary_tag_value geom = ogr_layer_feature.GetGeometryRef().GetPoints() ogr_layer_feature = None ogr_layer_feature = ogr_layer.GetNextFeature() boundary_tag_index = boundary_tag_index + 1 logger.info('bdy_tags: %s' % bdy_tags) logger.info('bdy: %s' % bdy) boundary_data = su.read_polygon(boundary_data_filename) create_mesh_from_regions(boundary_data, boundary_tags=bdy_tags, maximum_triangle_area=max_triangle_area, interior_regions=None, interior_holes=structures, filename=meshname, use_cache=False, verbose=True) domain = Domain(meshname, use_cache=False, verbose=True) domain.set_name(outname) domain.set_datadir(base_dir + '/outputs') logger.info(domain.statistics()) poly_fun_pairs = [['Extent', elevation_data_filename.encode("utf-8")]] topography_function = qs.composite_quantity_setting_function( poly_fun_pairs, domain, nan_treatment='exception', ) friction_function = qs.composite_quantity_setting_function( frictions, domain) domain.set_quantity('friction', friction_function, verbose=True) domain.set_quantity('stage', 0.0) domain.set_quantity('elevation', topography_function, verbose=True, alpha=0.99) domain.set_minimum_storable_height(0.005) logger.info('Applying rainfall...') if rain_data_filename: ogr_shapefile = ogr.Open(rain_data_filename) ogr_layer = ogr_shapefile.GetLayer(0) rainfall = 0 ogr_layer_feature = ogr_layer.GetNextFeature() while ogr_layer_feature: rainfall = float(ogr_layer_feature.GetField('rate_mm_hr')) polygon = su.read_polygon(rain_data_filename) logger.info("applying Polygonal_rate_operator with rate, polygon:") logger.info(rainfall) logger.info(polygon) Polygonal_rate_operator(domain, rate=rainfall, factor=1.0e-6, polygon=polygon, default_rate=0.0) ogr_layer_feature = None ogr_layer_feature = ogr_layer.GetNextFeature() logger.info('Applying surface inflows...') if inflow_data_filename: ogr_shapefile = ogr.Open(inflow_data_filename) ogr_layer = ogr_shapefile.GetLayer(0) ogr_layer_definition = ogr_layer.GetLayerDefn() ogr_layer_feature = ogr_layer.GetNextFeature() while ogr_layer_feature: in_fixed = float(ogr_layer_feature.GetField('in_fixed')) line = ogr_layer_feature.GetGeometryRef().GetPoints() logger.info("applying Inlet_operator with line, in_fixed:") logger.info(line) logger.info(in_fixed) Inlet_operator(domain, line, in_fixed, verbose=False) ogr_layer_feature = None ogr_layer_feature = ogr_layer.GetNextFeature() logger.info('Applying Boundary Conditions...') logger.info('Available boundary tags: %s' % domain.get_boundary_tags()) Br = anuga.Reflective_boundary(domain) Bd = anuga.Dirichlet_boundary([0.0, 0.0, 0.0]) Bt = anuga.Transmissive_boundary(domain) for key, value in bdy.iteritems(): if value == 'Br': bdy[key] = Br elif value == 'Bd': bdy[key] = Bd elif value == 'Bt': bdy[key] = Bt else: logger.info( 'No matching boundary condition exists - please check your shapefile attributes in: %s' % boundary_data_filename) # set a default value for exterior & interior boundary if it is not already set try: bdy['exterior'] except KeyError: bdy['exterior'] = Br try: bdy['interior'] except KeyError: bdy['interior'] = Br logger.info('bdy: %s' % bdy) domain.set_boundary(bdy) domain = distribute(domain) logger.info('Beginning evolve phase...') for t in domain.evolve(yieldstep, finaltime): domain.write_time() print domain.timestepping_statistics() logger.info(domain.timestepping_statistics(track_speeds=True)) percentage_complete = round(domain.time / domain.finaltime, 3) * 100 logger.info('%s percent complete' % percentage_complete) if run_id != 'local_run': write_percentage_complete(run_id, Runs, scenario_name, Scenario, session, percentage_complete) domain.sww_merge(delete_old=True) barrier() finalize() sww_file = base_dir + '/outputs/' + run_id + '.sww' sww_file = sww_file.encode( 'utf-8', 'ignore') # sometimes run_id gets turned to a unicode object by celery util.Make_Geotif(swwFile=sww_file, output_quantities=['depth', 'velocity'], myTimeStep='max', CellSize=max_triangle_area, lower_left=None, upper_right=None, EPSG_CODE=project_spatial_ref_epsg_code, proj4string=None, velocity_extrapolation=True, min_allowed_height=1.0e-05, output_dir=(base_dir + '/outputs/'), bounding_polygon=boundary_data, internal_holes=structures, verbose=False, k_nearest_neighbours=3, creation_options=[]) logger.info("Done. Nice work.")
superlink = SuperLink(superlinks, superjunctions, internal_links=20) surface_elev = np.array([12.4, 12.2]) - 0.01 input_velocity = 1 dt = 1 # yield step ft = 4000 # final timestep H_js = [] losses = [] Q_iks = [] Q_uks = [] Q_dks = [] for t in domain.evolve(yieldstep=dt, finaltime=ft): print('\n') domain.print_timestepping_statistics() anuga_depths = np.array([ inlet1_anuga_inlet_op.inlet.get_average_depth(), outlet_anuga_inlet_op.inlet.get_average_depth() ]) # Compute inflow/outflow to sewer C_o = 0.67 A_o = 2 * np.pi Q_in = C_o * A_o * np.sign(anuga_depths - (superlink.H_j - superlink._z_inv_j)) * np.sqrt( np.abs(anuga_depths - (superlink.H_j - superlink._z_inv_j)))
def parallel_time_varying_file_boundary_sts(self): """ parallel_test_time_varying_file_boundary_sts_sequential(self): Read correct points from ordering file and apply sts to boundary. The boundary is time varying. Compares sequential result with distributed result found using anuga_parallel """ #------------------------------------------------------------ # Define test variables #------------------------------------------------------------ lat_long_points = [[6.01, 97.0], [6.02, 97.0], [6.05, 96.9], [6.0, 97.0]] bounding_polygon = [[6.0, 97.0], [6.01, 97.0], [6.02, 97.0], [6.02, 97.02], [6.00, 97.02]] tide = 3.0 time_step_count = 65 time_step = 2 n = len(lat_long_points) first_tstep = num.ones(n, num.int) last_tstep = (time_step_count) * num.ones(n, num.int) finaltime = num.float(time_step * (time_step_count - 1)) yieldstep = num.float(time_step) gauge_depth = 20 * num.ones(n, num.float) ha = 2 * num.ones((n, time_step_count), num.float) ua = 10 * num.ones((n, time_step_count), num.float) va = -10 * num.ones((n, time_step_count), num.float) times = num.arange(0, time_step_count * time_step, time_step) for i in range(n): #ha[i]+=num.sin(times) ha[i] += times / finaltime #------------------------------------------------------------ # Write mux data to file then convert to sts format #------------------------------------------------------------ sts_file = "test" if myid == 0: base_name, files = self.write_mux2(lat_long_points, time_step_count, time_step, first_tstep, last_tstep, depth=gauge_depth, ha=ha, ua=ua, va=va) # base name will not exist, but 3 other files are created # Write order file file_handle, order_base_name = tempfile.mkstemp("") os.close(file_handle) os.remove(order_base_name) d = "," order_file = order_base_name + 'order.txt' fid = open(order_file, 'w') # Write Header header = 'index, longitude, latitude\n' fid.write(header) indices = [3, 0, 1] for i in indices: line=str(i)+d+str(lat_long_points[i][1])+d+\ str(lat_long_points[i][0])+"\n" fid.write(line) fid.close() urs2sts(base_name, basename_out=sts_file, ordering_filename=order_file, mean_stage=tide, verbose=verbose) self.delete_mux(files) assert (os.access(sts_file + '.sts', os.F_OK)) os.remove(order_file) barrier() #------------------------------------------------------------ # Define boundary_polygon on each processor. This polygon defines the # urs boundary and lies on a portion of the bounding_polygon #------------------------------------------------------------ boundary_polygon = create_sts_boundary(sts_file) # Append the remaining part of the boundary polygon to be defined by # the user bounding_polygon_utm = [] for point in bounding_polygon: zone, easting, northing = redfearn(point[0], point[1]) bounding_polygon_utm.append([easting, northing]) boundary_polygon.append(bounding_polygon_utm[3]) boundary_polygon.append(bounding_polygon_utm[4]) assert num.allclose(bounding_polygon_utm, boundary_polygon) extent_res = 10000 meshname = 'urs_test_mesh' + '.tsh' interior_regions = None boundary_tags = {'ocean': [0, 1], 'otherocean': [2, 3, 4]} #------------------------------------------------------------ # Create mesh on the master processor and store in file. This file # is read in by each slave processor when needed #------------------------------------------------------------ if myid == 0: create_mesh_from_regions(boundary_polygon, boundary_tags=boundary_tags, maximum_triangle_area=extent_res, filename=meshname, interior_regions=interior_regions, verbose=verbose) # barrier() domain_fbound = Domain(meshname) domain_fbound.set_quantities_to_be_stored(None) domain_fbound.set_quantity('stage', tide) # print domain_fbound.mesh.get_boundary_polygon() else: domain_fbound = None barrier() if (verbose and myid == 0): print 'DISTRIBUTING PARALLEL DOMAIN' domain_fbound = distribute(domain_fbound) #-------------------------------------------------------------------- # Find which sub_domain in which the interpolation points are located # # Sometimes the interpolation points sit exactly # between two centroids, so in the parallel run we # reset the interpolation points to the centroids # found in the sequential run #-------------------------------------------------------------------- interpolation_points = [[279000, 664000], [280250, 664130], [279280, 665400], [280500, 665000]] interpolation_points = num.array(interpolation_points) #if myid==0: # import pylab as P # boundary_polygon=num.array(boundary_polygon) # P.plot(boundary_polygon[:,0],boundary_polygon[:,1]) # P.plot(interpolation_points[:,0],interpolation_points[:,1],'ko') # P.show() fbound_gauge_values = [] fbound_proc_tri_ids = [] for i, point in enumerate(interpolation_points): fbound_gauge_values.append([]) # Empty list for timeseries try: k = domain_fbound.get_triangle_containing_point(point) if domain_fbound.tri_full_flag[k] == 1: fbound_proc_tri_ids.append(k) else: fbound_proc_tri_ids.append(-1) except: fbound_proc_tri_ids.append(-2) if verbose: print 'P%d has points = %s' % (myid, fbound_proc_tri_ids) #------------------------------------------------------------ # Set boundary conditions #------------------------------------------------------------ Bf = File_boundary(sts_file + '.sts', domain_fbound, boundary_polygon=boundary_polygon) Br = Reflective_boundary(domain_fbound) domain_fbound.set_boundary({'ocean': Bf, 'otherocean': Br}) #------------------------------------------------------------ # Evolve the domain on each processor #------------------------------------------------------------ for i, t in enumerate( domain_fbound.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step=False)): stage = domain_fbound.get_quantity('stage') for i in range(4): if fbound_proc_tri_ids[i] > -1: fbound_gauge_values[i].append( stage.centroid_values[fbound_proc_tri_ids[i]]) #------------------------------------------------------------ # Create domain to be run sequntially on each processor #------------------------------------------------------------ domain_drchlt = Domain(meshname) domain_drchlt.set_quantities_to_be_stored(None) domain_drchlt.set_starttime(time_step) domain_drchlt.set_quantity('stage', tide) Br = Reflective_boundary(domain_drchlt) #Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide]) Bd = Time_boundary( domain=domain_drchlt, function=lambda t: [ 2.0 + t / finaltime + tide, 220. + 10. * tide + 10. * t / finaltime, -220. - 10. * tide - 10. * t / finaltime ]) #Bd = Time_boundary(domain=domain_drchlt,function=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)]) domain_drchlt.set_boundary({'ocean': Bd, 'otherocean': Br}) drchlt_gauge_values = [] drchlt_proc_tri_ids = [] for i, point in enumerate(interpolation_points): drchlt_gauge_values.append([]) # Empty list for timeseries try: k = domain_drchlt.get_triangle_containing_point(point) if domain_drchlt.tri_full_flag[k] == 1: drchlt_proc_tri_ids.append(k) else: drchlt_proc_tri_ids.append(-1) except: drchlt_proc_tri_ids.append(-2) if verbose: print 'P%d has points = %s' % (myid, drchlt_proc_tri_ids) #------------------------------------------------------------ # Evolve entire domain on each processor #------------------------------------------------------------ for i, t in enumerate( domain_drchlt.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step=False)): stage = domain_drchlt.get_quantity('stage') for i in range(4): drchlt_gauge_values[i].append( stage.centroid_values[drchlt_proc_tri_ids[i]]) #------------------------------------------------------------ # Compare sequential values with parallel values #------------------------------------------------------------ barrier() success = True for i in range(4): if fbound_proc_tri_ids[i] > -1: fbound_gauge_values[i] = num.array(fbound_gauge_values[i]) drchlt_gauge_values[i] = num.array(drchlt_gauge_values[i]) #print i,fbound_gauge_values[i][4] #print i,drchlt_gauge_values[i][4] success = success and num.allclose(fbound_gauge_values[i], drchlt_gauge_values[i]) assert success #, (fbound_gauge_values[i]-drchlt_gauge_values[i]) #assert_(success) if not sys.platform == 'win32': if myid == 0: os.remove(sts_file + '.sts') if myid == 0: os.remove(meshname)
def sequential_time_varying_file_boundary_sts(self): """sequential_ltest_time_varying_file_boundary_sts_sequential(self): Read correct points from ordering file and apply sts to boundary. The boundary is time varying. FIXME add to test_urs2sts. """ lat_long_points = [[6.01, 97.0], [6.02, 97.0], [6.05, 96.9], [6.0, 97.0]] bounding_polygon = [[6.0, 97.0], [6.01, 97.0], [6.02, 97.0], [6.02, 97.02], [6.00, 97.02]] tide = 3.0 time_step_count = 65 time_step = 2. n = len(lat_long_points) first_tstep = num.ones(n, num.int) last_tstep = (time_step_count) * num.ones(n, num.int) finaltime = num.float(time_step * (time_step_count - 1)) yieldstep = num.float(time_step) gauge_depth = 20 * num.ones(n, num.float) ha = 2 * num.ones((n, time_step_count), num.float) ua = 10 * num.ones((n, time_step_count), num.float) va = -10 * num.ones((n, time_step_count), num.float) times = num.arange(0., num.float(time_step_count * time_step), time_step) for i in range(n): #ha[i]+=num.sin(times) ha[i] += times / finaltime sts_file = "test" if myid == 0: base_name, files = self.write_mux2(lat_long_points, time_step_count, time_step, first_tstep, last_tstep, depth=gauge_depth, ha=ha, ua=ua, va=va) # base name will not exist, but 3 other files are created # Write order file file_handle, order_base_name = tempfile.mkstemp("") os.close(file_handle) os.remove(order_base_name) d = "," order_file = order_base_name + 'order.txt' fid = open(order_file, 'w') # Write Header header = 'index, longitude, latitude\n' fid.write(header) indices = [3, 0, 1] for i in indices: line=str(i)+d+str(lat_long_points[i][1])+d+\ str(lat_long_points[i][0])+"\n" fid.write(line) fid.close() urs2sts(base_name, basename_out=sts_file, ordering_filename=order_file, mean_stage=tide, verbose=verbose) self.delete_mux(files) assert (os.access(sts_file + '.sts', os.F_OK)) os.remove(order_file) barrier() boundary_polygon = create_sts_boundary(sts_file) # Append the remaining part of the boundary polygon to be defined by # the user bounding_polygon_utm = [] for point in bounding_polygon: zone, easting, northing = redfearn(point[0], point[1]) bounding_polygon_utm.append([easting, northing]) boundary_polygon.append(bounding_polygon_utm[3]) boundary_polygon.append(bounding_polygon_utm[4]) assert num.allclose(bounding_polygon_utm, boundary_polygon) extent_res = 1000000 meshname = 'urs_test_mesh' + '.tsh' interior_regions = None boundary_tags = {'ocean': [0, 1], 'otherocean': [2, 3, 4]} # have to change boundary tags from last example because now bounding # polygon starts in different place. if myid == 0: create_mesh_from_regions(boundary_polygon, boundary_tags=boundary_tags, maximum_triangle_area=extent_res, filename=meshname, interior_regions=interior_regions, verbose=verbose) barrier() domain_fbound = Domain(meshname) domain_fbound.set_quantities_to_be_stored(None) domain_fbound.set_quantity('stage', tide) if verbose: print "Creating file boundary condition" Bf = File_boundary(sts_file + '.sts', domain_fbound, boundary_polygon=boundary_polygon) Br = Reflective_boundary(domain_fbound) domain_fbound.set_boundary({'ocean': Bf, 'otherocean': Br}) temp_fbound = num.zeros(int(finaltime / yieldstep) + 1, num.float) if verbose: print "Evolving domain with file boundary condition" for i, t in enumerate( domain_fbound.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step=False)): temp_fbound[i] = domain_fbound.quantities['stage'].centroid_values[ 2] if verbose: domain_fbound.write_time() domain_drchlt = Domain(meshname) domain_drchlt.set_quantities_to_be_stored(None) domain_drchlt.set_starttime(time_step) domain_drchlt.set_quantity('stage', tide) Br = Reflective_boundary(domain_drchlt) #Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide]) Bd = Time_boundary( domain=domain_drchlt, f=lambda t: [ 2.0 + t / finaltime + tide, 220. + 10. * tide + 10. * t / finaltime, -220. - 10. * tide - 10. * t / finaltime ]) #Bd = Time_boundary(domain=domain_drchlt,f=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)]) domain_drchlt.set_boundary({'ocean': Bd, 'otherocean': Br}) temp_drchlt = num.zeros(int(finaltime / yieldstep) + 1, num.float) for i, t in enumerate( domain_drchlt.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step=False)): temp_drchlt[i] = domain_drchlt.quantities['stage'].centroid_values[ 2] #domain_drchlt.write_time() #print domain_fbound.quantities['stage'].vertex_values #print domain_drchlt.quantities['stage'].vertex_values assert num.allclose(temp_fbound, temp_drchlt), temp_fbound - temp_drchlt assert num.allclose(domain_fbound.quantities['stage'].vertex_values, domain_drchlt.quantities['stage'].vertex_values) assert num.allclose( domain_fbound.quantities['xmomentum'].vertex_values, domain_drchlt.quantities['xmomentum'].vertex_values) assert num.allclose( domain_fbound.quantities['ymomentum'].vertex_values, domain_drchlt.quantities['ymomentum'].vertex_values) if not sys.platform == 'win32': if myid == 0: os.remove(sts_file + '.sts') if myid == 0: os.remove(meshname)
# Setup boundary conditions #------------------------------------------------------------------------------ Bt = anuga.Transmissive_boundary(domain) BdIN = anuga.Dirichlet_boundary([dana, fluxin, 0.0]) #BdOUT = anuga.Dirichlet_boundary([dana-10., fluxin, 0.0]) Br = anuga.Reflective_boundary(domain) # Solid reflective wall domain.set_boundary({'left': BdIN, 'right': Bt, 'top': Br, 'bottom': Br}) #------------------------------------------------------------------------------ # Produce a documentation of parameters #------------------------------------------------------------------------------ if myid == 0: parameter_file=open('parameters.tex', 'w') parameter_file.write('\\begin{verbatim}\n') from pprint import pprint pprint(domain.get_algorithm_parameters(),parameter_file,indent=4) parameter_file.write('\\end{verbatim}\n') parameter_file.close() #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ for t in domain.evolve(yieldstep=2.0, finaltime=200.0): if myid ==0 and verbose: print domain.timestepping_statistics() domain.sww_merge(delete_old=True) finalize()
# Setup boundary conditions #------------------------------------------------------------------------------ from math import sin, pi, exp Br = anuga.Reflective_boundary(domain) # Solid reflective wall Bt = anuga.Transmissive_boundary(domain) # Continue all values on boundary Bd = anuga.Dirichlet_boundary([1,0.,0.]) # Constant boundary values # Associate boundary tags with boundary objects domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br}) #------------------------------------------------------------------------- # Produce a documentation of parameters #------------------------------------------------------------------------- from anuga.validation_utilities import save_parameters_tex save_parameters_tex(domain) #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ for t in domain.evolve(yieldstep = 0.05, finaltime = 3.0): if myid == 0 and verbose: print domain.timestepping_statistics() domain.sww_merge(delete_old=True) finalize()
#------------------------------------------------------------------------------ # APPLY FLOW #------------------------------------------------------------------------------ line = [[296669.258, 6179974.191], [296677.321, 6179976.449]] anuga.parallel.Inlet_operator(domain, line, 1.0) #------------------------------------------------------------------------------ # SETUP BOUNDARY CONDITIONS #------------------------------------------------------------------------------ print('Available boundary tags', domain.get_boundary_tags()) Br = anuga.Reflective_boundary(domain) Bd = anuga.Dirichlet_boundary([0, 0, 0]) domain.set_boundary({'west': Bd, 'south': Br, 'north': Bd, 'east': Bd}) #------------------------------------------------------------------------------ # EVOLVE SYSTEM THROUGH TIME #------------------------------------------------------------------------------ import time t0 = time.time() for t in domain.evolve(yieldstep=1, finaltime=4000): print(domain.timestepping_statistics()) print(domain.boundary_statistics(quantities='stage')) print('Finished')
# type, area, length, orifice_coeff, free_weir_coeff, submerged_weir_coeff nodes[0].create_opening(4, 1.0, 1.0, 0.6, 1.6, 1.0) nodes[0].coupling_area = 1.0 # TODO: setup the outlet node nodes[1].create_opening(4, 1.0, 1.0, 0.6, 1.6, 1.0) print("node1_is_open?:",nodes[1].is_coupled) flow = 1.0 stop_release_water_time = 2 # the time for stopping releasing the water domain.set_name("anuga_swmm") for t in domain.evolve(yieldstep=1.0, finaltime=60.0): print("\n") #print(f"coupling step: {t}") domain.print_timestepping_statistics() if t < stop_release_water_time: # assume we need to release the water into the domain for first two seconds pass #op_inlet.set_rate(flow) else: # set the overland_depth # TODO: set up the overland depth, modify this function print("total volume: ",domain.get_water_volume()) volumes = sim.coupling_step(1.0) print(volumes)
region1 = Region(domain,radius = 1.0, center = (10.0, 3.0)) if isinstance(region1, Region): op2.region = region1 else: op2.region = Region(domain, poly=region1, expand_polygon=True) if isinstance(polygon1, Region): op1.region = polygon1 else: op1.region = Region(domain, poly=polygon1, expand_polygon=True) from self_try import get_circumference_indices polygon11 = [ [10.0, 0.2], [11.0, 0.2], [11.0, 4.8], [10.0, 4.8] ] for t in domain.evolve(yieldstep=0.3, finaltime=1.0): print("domain.parallel:", domain.parallel) op2.set_rate(dyn_t(t)) op1.set_rate(dyn_t(t)) domain.print_timestepping_statistics() domain.print_operator_timestepping_statistics() stage = domain.get_quantity('stage') elev = domain.get_quantity('elevation') height = stage - elev #print ('integral = ', height.get_integral()) #print("st",stage) #print("stages",op2.stage_c[:].take([op2.region.indices]))# num is the specific triangle indice print("stages_length",len(op2.stage_c[:].take([op2.region.indices])[0])) print("stages_length111", len(op1.stage_c[:].take([op1.region.indices])[0]))
factor = 1e-3 op3 = Rate_operator(domain, rate = rain, factor=factor) Q3 = numpy.sum(op3.get_spatial_rate()*domain.areas)*factor #op3() #domain.fractional_step_operators.remove(op3) #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ accum = 0.0 yieldstep = 0.1 finaltime = 5.0 for t in domain.evolve(yieldstep=yieldstep, finaltime=finaltime): domain.print_timestepping_statistics() domain.print_operator_timestepping_statistics() stage = domain.get_quantity('stage') elev = domain.get_quantity('elevation') height = stage - elev print indent + 'Integral = ', height.get_integral() print indent + 'Exact accumultion = ', accum dd = max(min(yieldstep,4.0-t),0.0) accum += (Q1+Q2)*yieldstep + dd*Q3
Br = anuga.Reflective_boundary(domain) # Solid reflective wall Bt = anuga.Transmissive_boundary(domain) # Continue all values on boundary #Bd = anuga.Dirichlet_boundary([1,0.,0.]) # Constant boundary values #BTime = anuga.Transmissive_n_momentum_zero_t_momentum_set_stage_boundary(domain, f_CG) BTime = anuga.Time_boundary(domain, f_CG) # Associate boundary tags with boundary objects domain.set_boundary({'left': BTime, 'right': Bt, 'top': Br, 'bottom': Br}) #------------------------------------------------------------------------------ # Produce a documentation of parameters #------------------------------------------------------------------------------ if myid == 0: parameter_file = open('parameters.tex', 'w') parameter_file.write('\\begin{verbatim}\n') from pprint import pprint pprint(domain.get_algorithm_parameters(), parameter_file, indent=4) parameter_file.write('\\end{verbatim}\n') parameter_file.close() #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ for t in domain.evolve(yieldstep=Tp / 48., finaltime=30 * Tp): if myid == 0 and verbose: print(domain.timestepping_statistics()) domain.sww_merge(delete_old=True) finalize()
Bw5 = anuga.Flather_external_stage_zero_velocity_boundary(domain, zero_fun) # Associate boundary tags with boundary objects domain.set_boundary({'left': Bw2, 'right': Bw5, 'top': Br, 'bottom': Br}) #------------------------------------------------------------------------------ # Produce a documentation of parameters #------------------------------------------------------------------------------ if myid == 0: parameter_file=open('parameters.tex', 'w') parameter_file.write('\\begin{verbatim}\n') from pprint import pprint pprint(domain.get_algorithm_parameters(),parameter_file,indent=4) parameter_file.write('\\end{verbatim}\n') parameter_file.close() #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ for t in domain.evolve(yieldstep = 10, finaltime = 2e4): domain.write_time() if interactive_visualisation: vis.update() domain.sww_merge(delete_old=True) finalize()
#------------------------------------------------------------------------------ # Setup operators #------------------------------------------------------------------------------ from anuga.operators.vegetation_operator import Vegetation_operator veg_op = Vegetation_operator(domain) Quantity(domain, name='veg_diameter', register=True) domain.set_quantity('veg_diameter', 0.00064) Quantity(domain, name='veg_spacing', register=True) domain.set_quantity('veg_spacing', 0.15) #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ for t in domain.evolve(yieldstep = 1, finaltime = 30.0): domain.print_timestepping_statistics()
# Associate boundary tags with boundary objects domain.set_boundary({'left': Bd, 'right': Bd, 'top': Br, 'bottom': Br}) #------------------------------------------------------------------------------ # Produce a documentation of parameters #------------------------------------------------------------------------------ if myid == 0: parameter_file=open('parameters.tex', 'w') parameter_file.write('\\begin{verbatim}\n') from pprint import pprint pprint(domain.get_algorithm_parameters(),parameter_file,indent=4) parameter_file.write('\\end{verbatim}\n') parameter_file.close() #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ for t in domain.evolve(yieldstep = 1.0, finaltime = 20.): #print domain.timestepping_statistics(track_speeds=True) if myid == 0 and verbose: print domain.timestepping_statistics() domain.sww_merge(delete_old=True) finalize()
def concept_ungenerateII(self): from anuga import Domain, Reflective_boundary, Dirichlet_boundary x=0 y=0 mesh_geo = geo_reference=Geo_reference(56, x, y) # These are the absolute values polygon_absolute = [[0,0], [100,0], [100,100], [0,100]] x_p = -10 y_p = -40 geo_ref_poly = Geo_reference(56, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = {'wall': [0,1,3], 'wave': [2]} inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]] inner1_polygon = geo_ref_poly.\ change_points_geo_ref(inner1_polygon_absolute) inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]] inner2_polygon = geo_ref_poly.\ change_points_geo_ref(inner2_polygon_absolute) max_area = 1 interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] m = create_mesh_from_regions(polygon, boundary_tags, max_area, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo) m.export_mesh_file('a_test_mesh_iknterface.tsh') fileName = tempfile.mktemp('.txt') file = open(fileName, 'w') file.write(' 1 ?? ??\n\ 90.0 90.0\n\ 81.0 90.0\n\ 81.0 81.0\n\ 90.0 81.0\n\ 90.0 90.0\n\ END\n\ 2 ?? ??\n\ 10.0 80.0\n\ 10.0 90.0\n\ 20.0 90.0\n\ 10.0 80.0\n\ END\n\ END\n') file.close() m.import_ungenerate_file(fileName) #, tag='wall') os.remove(fileName) m.generate_mesh(maximum_triangle_area=max_area, verbose=False) mesh_filename = 'bento_b.tsh' m.export_mesh_file(mesh_filename) domain = Domain(mesh_filename, use_cache = False) Br = Reflective_boundary(domain) Bd = Dirichlet_boundary([3, 0, 0]) domain.set_boundary({'wall': Br, 'wave': Bd}) yieldstep = 0.1 finaltime = 10 for t in domain.evolve(yieldstep, finaltime): domain.write_time()
Bt = anuga.Transmissive_boundary(domain) # Continue all values on boundary BdL = anuga.Dirichlet_boundary([0.41373588752426715, 0.18, 0.]) # Constant boundary values BdR = anuga.Dirichlet_boundary([0.33, 0.18, 0.]) # Constant boundary values # Associate boundary tags with boundary objects domain.set_boundary({'left': BdL, 'right': BdR, 'top': Br, 'bottom': Br}) #------------------------------------------------------------------------------ # Produce a documentation of parameters #------------------------------------------------------------------------------ if myid == 0: parameter_file = open('parameters.tex', 'w') parameter_file.write('\\begin{verbatim}\n') from pprint import pprint pprint(domain.get_algorithm_parameters(), parameter_file, indent=4) parameter_file.write('\\end{verbatim}\n') parameter_file.close() #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ for t in domain.evolve(yieldstep=1.0, finaltime=100.): #print(domain.timestepping_statistics(track_speeds=True)) if myid == 0 and verbose: print(domain.timestepping_statistics()) #vis.update() domain.sww_merge(delete_old=True) finalize()
vtk_visualiser = True if vtk_visualiser: from anuga.visualiser import RealtimeVisualiser vis = RealtimeVisualiser(domain) vis.render_quantity_height("height",dynamic=True) #vis.render_quantity_height("stage", zScale =1.0, dynamic=True) vis.colour_height_quantity('stage', (0.0, 0.0, 1.0)) vis.start() #=============================================================================== #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ i = 0 for t in domain.evolve(yieldstep = 0.01, finaltime = 0.25): #print domain.timestepping_statistics(track_speeds=True) print domain.timestepping_statistics() if vtk_visualiser: vis.update() fileName = 'stage_%03d' % i + '.vtk' i = i+1 vis.store_height_quantity('height',fileName) #test against know data if vtk_visualiser: vis.evolveFinished()
#Bd = anuga.Dirichlet_boundary([1,0.,0.]) # Constant boundary values # Associate boundary tags with boundary objects domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br}) #------------------------------------------------------------------------------ # Produce a documentation of parameters #------------------------------------------------------------------------------ if myid == 0: parameter_file = open('parameters.tex', 'w') parameter_file.write('\\begin{verbatim}\n') from pprint import pprint pprint(domain.get_algorithm_parameters(), parameter_file, indent=4) parameter_file.write('\\end{verbatim}\n') parameter_file.close() #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ import time t0 = time.time() for t in domain.evolve(yieldstep=0.1, finaltime=5.0): #print(domain.timestepping_statistics(track_speeds=True)) if myid == 0 and verbose: print(domain.timestepping_statistics()) #vis.update() if myid == 0 and verbose: print('That took %s sec' % str(time.time() - t0)) domain.sww_merge(delete_old=True) finalize()
def concept_ungenerateII(self): from anuga import Domain, Reflective_boundary, Dirichlet_boundary x = 0 y = 0 mesh_geo = geo_reference = Geo_reference(56, x, y) # These are the absolute values polygon_absolute = [[0, 0], [100, 0], [100, 100], [0, 100]] x_p = -10 y_p = -40 geo_ref_poly = Geo_reference(56, x_p, y_p) polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute) boundary_tags = {'wall': [0, 1, 3], 'wave': [2]} inner1_polygon_absolute = [[10, 10], [20, 10], [20, 20], [10, 20]] inner1_polygon = geo_ref_poly.\ change_points_geo_ref(inner1_polygon_absolute) inner2_polygon_absolute = [[30, 30], [40, 30], [40, 40], [30, 40]] inner2_polygon = geo_ref_poly.\ change_points_geo_ref(inner2_polygon_absolute) max_area = 1 interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)] m = create_mesh_from_regions(polygon, boundary_tags, max_area, interior_regions=interior_regions, poly_geo_reference=geo_ref_poly, mesh_geo_reference=mesh_geo) m.export_mesh_file('a_test_mesh_iknterface.tsh') fileName = tempfile.mktemp('.txt') file = open(fileName, 'w') file.write(' 1 ?? ??\n\ 90.0 90.0\n\ 81.0 90.0\n\ 81.0 81.0\n\ 90.0 81.0\n\ 90.0 90.0\n\ END\n\ 2 ?? ??\n\ 10.0 80.0\n\ 10.0 90.0\n\ 20.0 90.0\n\ 10.0 80.0\n\ END\n\ END\n') file.close() m.import_ungenerate_file(fileName) #, tag='wall') os.remove(fileName) m.generate_mesh(maximum_triangle_area=max_area, verbose=False) mesh_filename = 'bento_b.tsh' m.export_mesh_file(mesh_filename) domain = Domain(mesh_filename, use_cache=False) Br = Reflective_boundary(domain) Bd = Dirichlet_boundary([3, 0, 0]) domain.set_boundary({'wall': Br, 'wave': Bd}) yieldstep = 0.1 finaltime = 10 for t in domain.evolve(yieldstep, finaltime): domain.write_time()
def test_runup_sinusoid(self): """ Run a version of the validation test runup_sinusoid to ensure limiting solution has small velocity """ points, vertices, boundary = anuga.rectangular_cross(20,20, len1=1., len2=1.) domain=Domain(points,vertices,boundary) # Create Domain domain.set_flow_algorithm('DE0') domain.set_name('runup_sinusoid_v2') # Output to file runup.sww domain.set_datadir('.') # Use current folder domain.set_quantities_to_be_stored({'stage': 2, 'xmomentum': 2, 'ymomentum': 2, 'elevation': 1}) #domain.set_store_vertices_uniquely(True) #------------------ # Define topography #------------------ scale_me=1.0 def topography(x,y): return (-x/2.0 +0.05*num.sin((x+y)*50.0))*scale_me def stagefun(x,y): stge=-0.2*scale_me #+0.01*(x>0.9) return stge domain.set_quantity('elevation',topography) # Use function for elevation domain.get_quantity('elevation').smooth_vertex_values() domain.set_quantity('friction',0.03) # Constant friction domain.set_quantity('stage', stagefun) # Constant negative initial stage domain.get_quantity('stage').smooth_vertex_values() #-------------------------- # Setup boundary conditions #-------------------------- Br=anuga.Reflective_boundary(domain) # Solid reflective wall Bd=anuga.Dirichlet_boundary([-0.1*scale_me,0.,0.]) # Constant boundary values -- not used in this example #---------------------------------------------- # Associate boundary tags with boundary objects #---------------------------------------------- domain.set_boundary({'left': Br, 'right': Bd, 'top': Br, 'bottom':Br}) #------------------------------ #Evolve the system through time #------------------------------ for t in domain.evolve(yieldstep=7.0,finaltime=7.0): #print domain.timestepping_statistics() xx = domain.quantities['xmomentum'].centroid_values yy = domain.quantities['ymomentum'].centroid_values dd = domain.quantities['stage'].centroid_values - domain.quantities['elevation'].centroid_values #dd_raw=1.0*dd dd = (dd)*(dd>1.0e-03)+1.0e-03 vv = ( (xx/dd)**2 + (yy/dd)**2)**0.5 vv = vv*(dd>1.0e-03) #print 'Peak velocity is: ', vv.max(), vv.argmax() #print 'Volume is', sum(dd_raw*domain.areas) #print vv.max() assert num.all(vv<1.01e-01)
def parallel_time_varying_file_boundary_sts(self): """ parallel_test_time_varying_file_boundary_sts_sequential(self): Read correct points from ordering file and apply sts to boundary. The boundary is time varying. Compares sequential result with distributed result found using anuga_parallel """ #------------------------------------------------------------ # Define test variables #------------------------------------------------------------ lat_long_points=[[6.01,97.0],[6.02,97.0],[6.05,96.9],[6.0,97.0]] bounding_polygon=[[6.0,97.0],[6.01,97.0],[6.02,97.0], [6.02,97.02],[6.00,97.02]] tide = 3.0 time_step_count = 65 time_step = 2 n=len(lat_long_points) first_tstep=num.ones(n,num.int) last_tstep=(time_step_count)*num.ones(n,num.int) finaltime=num.float(time_step*(time_step_count-1)) yieldstep=num.float(time_step) gauge_depth=20*num.ones(n,num.float) ha=2*num.ones((n,time_step_count),num.float) ua=10*num.ones((n,time_step_count),num.float) va=-10*num.ones((n,time_step_count),num.float) times=num.arange(0, time_step_count*time_step, time_step) for i in range(n): #ha[i]+=num.sin(times) ha[i]+=times/finaltime #------------------------------------------------------------ # Write mux data to file then convert to sts format #------------------------------------------------------------ sts_file="test" if myid==0: base_name, files = self.write_mux2(lat_long_points, time_step_count, time_step, first_tstep, last_tstep, depth=gauge_depth, ha=ha, ua=ua, va=va) # base name will not exist, but 3 other files are created # Write order file file_handle, order_base_name = tempfile.mkstemp("") os.close(file_handle) os.remove(order_base_name) d="," order_file=order_base_name+'order.txt' fid=open(order_file,'w') # Write Header header='index, longitude, latitude\n' fid.write(header) indices=[3,0,1] for i in indices: line=str(i)+d+str(lat_long_points[i][1])+d+\ str(lat_long_points[i][0])+"\n" fid.write(line) fid.close() urs2sts(base_name, basename_out=sts_file, ordering_filename=order_file, mean_stage=tide, verbose=verbose) self.delete_mux(files) assert(os.access(sts_file+'.sts', os.F_OK)) os.remove(order_file) barrier() #------------------------------------------------------------ # Define boundary_polygon on each processor. This polygon defines the # urs boundary and lies on a portion of the bounding_polygon #------------------------------------------------------------ boundary_polygon = create_sts_boundary(sts_file) # Append the remaining part of the boundary polygon to be defined by # the user bounding_polygon_utm=[] for point in bounding_polygon: zone,easting,northing=redfearn(point[0],point[1]) bounding_polygon_utm.append([easting,northing]) boundary_polygon.append(bounding_polygon_utm[3]) boundary_polygon.append(bounding_polygon_utm[4]) assert num.allclose(bounding_polygon_utm,boundary_polygon) extent_res=10000 meshname = 'urs_test_mesh' + '.tsh' interior_regions=None boundary_tags={'ocean': [0,1], 'otherocean': [2,3,4]} #------------------------------------------------------------ # Create mesh on the master processor and store in file. This file # is read in by each slave processor when needed #------------------------------------------------------------ if myid==0: create_mesh_from_regions(boundary_polygon, boundary_tags=boundary_tags, maximum_triangle_area=extent_res, filename=meshname, interior_regions=interior_regions, verbose=verbose) # barrier() domain_fbound = Domain(meshname) domain_fbound.set_quantities_to_be_stored(None) domain_fbound.set_quantity('stage', tide) # print domain_fbound.mesh.get_boundary_polygon() else: domain_fbound=None barrier() if ( verbose and myid == 0 ): print 'DISTRIBUTING PARALLEL DOMAIN' domain_fbound = distribute(domain_fbound) #-------------------------------------------------------------------- # Find which sub_domain in which the interpolation points are located # # Sometimes the interpolation points sit exactly # between two centroids, so in the parallel run we # reset the interpolation points to the centroids # found in the sequential run #-------------------------------------------------------------------- interpolation_points = [[279000,664000], [280250,664130], [279280,665400], [280500,665000]] interpolation_points=num.array(interpolation_points) #if myid==0: # import pylab as P # boundary_polygon=num.array(boundary_polygon) # P.plot(boundary_polygon[:,0],boundary_polygon[:,1]) # P.plot(interpolation_points[:,0],interpolation_points[:,1],'ko') # P.show() fbound_gauge_values = [] fbound_proc_tri_ids = [] for i, point in enumerate(interpolation_points): fbound_gauge_values.append([]) # Empty list for timeseries try: k = domain_fbound.get_triangle_containing_point(point) if domain_fbound.tri_full_flag[k] == 1: fbound_proc_tri_ids.append(k) else: fbound_proc_tri_ids.append(-1) except: fbound_proc_tri_ids.append(-2) if verbose: print 'P%d has points = %s' %(myid, fbound_proc_tri_ids) #------------------------------------------------------------ # Set boundary conditions #------------------------------------------------------------ Bf = File_boundary(sts_file+'.sts', domain_fbound, boundary_polygon=boundary_polygon) Br = Reflective_boundary(domain_fbound) domain_fbound.set_boundary({'ocean': Bf,'otherocean': Br}) #------------------------------------------------------------ # Evolve the domain on each processor #------------------------------------------------------------ for i, t in enumerate(domain_fbound.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step = False)): stage = domain_fbound.get_quantity('stage') for i in range(4): if fbound_proc_tri_ids[i] > -1: fbound_gauge_values[i].append(stage.centroid_values[fbound_proc_tri_ids[i]]) #------------------------------------------------------------ # Create domain to be run sequntially on each processor #------------------------------------------------------------ domain_drchlt = Domain(meshname) domain_drchlt.set_quantities_to_be_stored(None) domain_drchlt.set_starttime(time_step) domain_drchlt.set_quantity('stage', tide) Br = Reflective_boundary(domain_drchlt) #Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide]) Bd = Time_boundary(domain=domain_drchlt, function=lambda t: [2.0+t/finaltime+tide,220.+10.*tide+10.*t/finaltime,-220.-10.*tide-10.*t/finaltime]) #Bd = Time_boundary(domain=domain_drchlt,function=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)]) domain_drchlt.set_boundary({'ocean': Bd,'otherocean': Br}) drchlt_gauge_values = [] drchlt_proc_tri_ids = [] for i, point in enumerate(interpolation_points): drchlt_gauge_values.append([]) # Empty list for timeseries try: k = domain_drchlt.get_triangle_containing_point(point) if domain_drchlt.tri_full_flag[k] == 1: drchlt_proc_tri_ids.append(k) else: drchlt_proc_tri_ids.append(-1) except: drchlt_proc_tri_ids.append(-2) if verbose: print 'P%d has points = %s' %(myid, drchlt_proc_tri_ids) #------------------------------------------------------------ # Evolve entire domain on each processor #------------------------------------------------------------ for i, t in enumerate(domain_drchlt.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step = False)): stage = domain_drchlt.get_quantity('stage') for i in range(4): drchlt_gauge_values[i].append(stage.centroid_values[drchlt_proc_tri_ids[i]]) #------------------------------------------------------------ # Compare sequential values with parallel values #------------------------------------------------------------ barrier() success = True for i in range(4): if fbound_proc_tri_ids[i] > -1: fbound_gauge_values[i]=num.array(fbound_gauge_values[i]) drchlt_gauge_values[i]=num.array(drchlt_gauge_values[i]) #print i,fbound_gauge_values[i][4] #print i,drchlt_gauge_values[i][4] success = success and num.allclose(fbound_gauge_values[i], drchlt_gauge_values[i]) assert success#, (fbound_gauge_values[i]-drchlt_gauge_values[i]) #assert_(success) if not sys.platform == 'win32': if myid==0: os.remove(sts_file+'.sts') if myid==0: os.remove(meshname)
#------------------------------------------------------------------------------ # Produce a documentation of parameters #------------------------------------------------------------------------------ if myid == 0: parameter_file=open('parameters.tex', 'w') parameter_file.write('\\begin{verbatim}\n') from pprint import pprint pprint(domain.get_algorithm_parameters(),parameter_file,indent=4) parameter_file.write('\\end{verbatim}\n') parameter_file.close() #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ for t in domain.evolve(yieldstep = 0.1, finaltime = 5.): #print domain.timestepping_statistics(track_speeds=True) if myid == 0: print domain.timestepping_statistics() domain.sww_merge(delete_old=True) finalize() #
# Inflow boundary -- use discharge inflow, and reflective wall (so we can control the discharge) line = [[0., 0.], [0., W]] Qin = 1.0 * W Inlet_operator(domain, line, Qin) # Associate boundary tags with boundary objects domain.set_boundary({'left': Br, 'right': Bd_out, 'top': Br, 'bottom': Br}) #------------------------------------------------------------------------------ # Produce a documentation of parameters #------------------------------------------------------------------------------ if myid == 0: parameter_file = open('parameters.tex', 'w') parameter_file.write('\\begin{verbatim}\n') from pprint import pprint pprint(domain.get_algorithm_parameters(), parameter_file, indent=4) parameter_file.write('\\end{verbatim}\n') parameter_file.close() #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ for t in domain.evolve(yieldstep=2.0, finaltime=200.): #print(domain.timestepping_statistics(track_speeds=True)) if myid == 0 and verbose: print(domain.timestepping_statistics()) domain.sww_merge(delete_old=True) finalize()
from anuga.operators.vegetation_operator import Vegetation_operator # create operator op1 = Vegetation_operator(domain) # op1.set_inflow_concentration(0.02) alpha = 0.4 Quantity(domain, name='veg_diameter', register=True) domain.set_quantity('veg_diameter', 0.00064) Quantity(domain, name='veg_spacing', register=True) domain.set_quantity('veg_spacing', 0.15) #------------------------------------------------------------------------------ # Evolve system through time #------------------------------------------------------------------------------ for t in domain.evolve(yieldstep=0.5, finaltime=30.): domain.print_timestepping_statistics() #domain.print_operator_timestepping_statistics()
Bi = Dirichlet_boundary([0.5, 0, 0]) # Inflow Br = Reflective_boundary(domain) # Solid reflective wall Bo = Dirichlet_boundary([-5, 0, 0]) # Outflow domain.set_boundary({'left': Bi, 'right': Bo, 'top': Br, 'bottom': Br}) #------------------------------------------------------------------------------- # Setup erosion operator in the middle of dam #------------------------------------------------------------------------------- polygon1 = [ [12., 0.0], [13., 0.0], [13., 5.0], [12., 5.0] ] op1 = My_polygon_erosion_operator(domain, threshold=0.0, base=-0.1, polygon=polygon1) #------------------------------------------------------------------------------- # Evolve system through time #------------------------------------------------------------------------------- for t in domain.evolve(yieldstep=0.2, finaltime=60.0): domain.print_timestepping_statistics() domain.print_operator_timestepping_statistics()