def __init__(self, filename, make_directories=True, output_log=None): """Parse the input data then process it for ANUGA @param filename = configuration file (xls) @param make_directories Create output directories for simulation @param output_log filename to redirect stdout (inside output directories) """ # Get the 'raw' data ProjectData.__init__(self, filename) # Create a unique output directory, and redirect stdout there self.define_output_directory_and_redirect_stdout( make_directories=make_directories, output_log=output_log) # Read files / pre-process self.process_project_data() if make_directories: # Make other required directories, copy code files, etc self.setup_directory_structure() # Export spatial data to some text self.export_spatial_data_as_text() barrier()
def print_operator_inputs(domain): """ Utility for printing discharge information for some operators """ # Shorthand notation operators = domain.fractional_step_operators # Rainfall first if myid == 0: for i in range(len(operators)): if hasattr(operators[i], 'rate'): print ' Operator ' + operators[i].label + \ ' rate = ' + str(operators[i].rate(domain.time)) barrier() # Inlets for i in range(len(operators)): if hasattr(operators[i], 'applied_Q'): print ' Operator ' + operators[i].label + \ ' Q = ' + str(operators[i].applied_Q) barrier() if myid == 0: print ' ' return
def print_velocity_statistics(domain, max_quantities): """ Utility for printing velocity stats in the evolve loop """ # Print velocity statistics for i in range(numprocs): if myid == i: # Peak speed info xx = domain.quantities['xmomentum'].centroid_values yy = domain.quantities['ymomentum'].centroid_values dd = domain.quantities['stage'].centroid_values \ - domain.quantities['elevation'].centroid_values dd = dd * (dd > 1.0e-03) + 1.0e-03 * (dd <= 1.0e-03) vv = 1 / dd * (xx ** 2 + yy ** 2) ** 0.5 vv = vv * (dd > 1.0e-03) print ' Processor ', myid print ' @ Peak velocity is: ', vv.max(), vv.argmax() print ' &- MaxSpeedHistory: ', \ max_quantities.max_speed.max() print ' %- FUF: ', domain.flux_update_frequency.mean() else: pass barrier() # Make a newline if myid == 0: print '' return
def define_output_directory_and_redirect_stdout(self, make_directories=True, output_log=None): """Make the main output directory, and redirect stdout to a file there @param output_log Name of file (stored inside the output directory) which will hold stdout """ if myid == 0: runtime = time.strftime('%Y%m%d_%H%M%S', time.localtime()) for i in range(1, numprocs): send(runtime, i) else: runtime = receive(0) barrier() self.output_dir = self.output_basedir + 'RUN_' + str(runtime) +\ '_' + self.scenario if ((make_directories) and (myid == 0)): try: os.mkdir(self.output_basedir) except: pass # Make the output directory try: os.mkdir(self.output_dir) except: pass print 'OUTPUT_DIRECTORY: ' + str(self.output_dir) # Send stdout to a file inside the output directory if output_log is not None: if make_directories: stdout_file = self.output_dir + '/' + output_log else: stdout_file = output_log if myid == 0: print 'Redirecting output now to ' + stdout_file sys.stdout = Logger(stdout_file) barrier() if myid != 0: sys.stdout = Logger(stdout_file) return
'chan_in': [6], 'bottom2': [7] }, maximum_triangle_area = 1.0e+06, #0.5*l0*l0, minimum_triangle_angle = 28.0, filename = 'channel_floodplain1.msh', interior_regions = [ ], breaklines=breakLines.values(), regionPtArea=regionPtAreas, verbose=True) domain=anuga.create_domain_from_file('channel_floodplain1.msh') domain.set_name('channel_floodplain1') # Output name domain.set_flow_algorithm(alg) else: domain=None barrier() domain=distribute(domain) barrier() domain.set_store_vertices_uniquely(True) #------------------------------------------------------------------------------ # # Setup initial conditions # #------------------------------------------------------------------------------ # Function for topography def topography(x, y): # Longitudinally sloping floodplain with channel in centre elev1= -y*floodplain_slope - chan_bankfull_depth*\
'bottom2': [7] }, maximum_triangle_area=1.0e+06, #0.5*l0*l0, minimum_triangle_angle=28.0, filename='channel_floodplain1.msh', interior_regions=[], breaklines=breakLines.values(), regionPtArea=regionPtAreas, verbose=True) domain = anuga.create_domain_from_file('channel_floodplain1.msh') domain.set_name('channel_floodplain1') # Output name domain.set_flow_algorithm(alg) else: domain = None barrier() domain = distribute(domain) barrier() domain.set_store_vertices_uniquely(True) #------------------------------------------------------------------------------ # # Setup initial conditions # #------------------------------------------------------------------------------ # Function for topography def topography(x, y): # Longitudinally sloping floodplain with channel in centre
def setup_mesh(project, setup_initial_conditions=None): """ Code to make the mesh (initial domain) The geometry is made on processor 0, then dumped and reloaded This reduces the memory demands INPUT: project == the project module OUTPUT: domain """ if myid == 0: if verbose: print "Hello from processor ", myid # # HERE, WE MAKE/PARTITION/READ THE MESH # This can lead to memory savings in parallel runs # (possibly because of limitations of python memory management) # # Let's see if we have already pickled this domain pickle_name = "domain" + "_P%g_%g.pickle" % (1, 0) pickle_name = join(project.partition_dir, pickle_name) if os.path.exists(pickle_name): if verbose: print "Saved domain seems to already exist" else: if verbose: print "CREATING PARTITIONED DOMAIN" domain = build_mesh(project) if setup_initial_conditions is not None: # Set the initial conditions in serial setup_initial_conditions.setup_initial_conditions(domain, project) # If pypar is not available don't use sequential_distribute stuff # (it will fail) if pypar_available: if verbose: print "Saving Domain" sequential_distribute_dump(domain, 1, partition_dir=project.partition_dir, verbose=verbose) # If pypar is not available don't use sequential_distribute stuff (it # will fail) if pypar_available: # Now partition the domain par_pickle_name = "domain" + "_P%g_%g.pickle" % (numprocs, 0) par_pickle_name = join(project.partition_dir, par_pickle_name) if os.path.exists(par_pickle_name): if verbose: print "Saved partitioned domain seems to already exist" else: if verbose: print "Load in saved sequential pickled domain" domain = sequential_distribute_load_pickle_file(pickle_name, np=1, verbose=verbose) if verbose: print "Dump partitioned domains" sequential_distribute_dump(domain, numprocs, partition_dir=project.partition_dir, verbose=verbose) # This can reduce the memory demands if the domain was made above # Even better to have an existing partition (i.e. stop here and # rerun) domain = None gc.collect() else: domain = None if verbose: print "Hello from processor ", myid barrier() # print 'Distributing domain' # domain=distribute(domain) # barrier() # If pypar is not available don't use sequential_distribute stuff (it will # fail) if pypar_available: if myid == 0: print "LOADING PARTITIONED DOMAIN" domain = sequential_distribute_load(filename=join(project.partition_dir, "domain"), verbose=verbose) # ######################################################################### # Set output directories # ######################################################################### domain.set_name(project.scenario) # Name of sww file domain.set_datadir(project.output_dir) # Store sww output here # Needs more changes for this to work # domain.set_checkpointing(checkpoint_time=project.checkpoint_time) # ######################################################################### # Miscellanious numerics # ######################################################################### domain.set_flow_algorithm(project.flow_algorithm) # Force zero beta values [hopefully integrated into source] # print 'Warning: Forcing everything to first order' # domain.beta_w=0. # domain.beta_uh=0. # domain.beta_vh=0. # domain.beta_w_dry=0. # domain.beta_uh_dry=0. # domain.beta_vh_dry=0. # Adjust velocity computation for max quantities # domain.velocity_protection=1.0e-05 # Adjust CFL # domain.set_CFL(0.9) # Optionally store vertex values uniquely (large file sizes!) domain.set_store_vertices_uniquely(project.store_vertices_uniquely) if project.use_local_extrapolation_and_flux_updating: domain.set_local_extrapolation_and_flux_updating() if project.store_elevation_every_timestep: domain.quantities_to_be_stored["elevation"] = 2 else: domain.quantities_to_be_stored["elevation"] = 1 return domain
def sequential_time_varying_file_boundary_sts(self): """sequential_ltest_time_varying_file_boundary_sts_sequential(self): Read correct points from ordering file and apply sts to boundary. The boundary is time varying. FIXME add to test_urs2sts. """ lat_long_points = [[6.01, 97.0], [6.02, 97.0], [6.05, 96.9], [6.0, 97.0]] bounding_polygon = [[6.0, 97.0], [6.01, 97.0], [6.02, 97.0], [6.02, 97.02], [6.00, 97.02]] tide = 3.0 time_step_count = 65 time_step = 2. n = len(lat_long_points) first_tstep = num.ones(n, num.int) last_tstep = (time_step_count) * num.ones(n, num.int) finaltime = num.float(time_step * (time_step_count - 1)) yieldstep = num.float(time_step) gauge_depth = 20 * num.ones(n, num.float) ha = 2 * num.ones((n, time_step_count), num.float) ua = 10 * num.ones((n, time_step_count), num.float) va = -10 * num.ones((n, time_step_count), num.float) times = num.arange(0., num.float(time_step_count * time_step), time_step) for i in range(n): #ha[i]+=num.sin(times) ha[i] += times / finaltime sts_file = "test" if myid == 0: base_name, files = self.write_mux2(lat_long_points, time_step_count, time_step, first_tstep, last_tstep, depth=gauge_depth, ha=ha, ua=ua, va=va) # base name will not exist, but 3 other files are created # Write order file file_handle, order_base_name = tempfile.mkstemp("") os.close(file_handle) os.remove(order_base_name) d = "," order_file = order_base_name + 'order.txt' fid = open(order_file, 'w') # Write Header header = 'index, longitude, latitude\n' fid.write(header) indices = [3, 0, 1] for i in indices: line=str(i)+d+str(lat_long_points[i][1])+d+\ str(lat_long_points[i][0])+"\n" fid.write(line) fid.close() urs2sts(base_name, basename_out=sts_file, ordering_filename=order_file, mean_stage=tide, verbose=verbose) self.delete_mux(files) assert (os.access(sts_file + '.sts', os.F_OK)) os.remove(order_file) barrier() boundary_polygon = create_sts_boundary(sts_file) # Append the remaining part of the boundary polygon to be defined by # the user bounding_polygon_utm = [] for point in bounding_polygon: zone, easting, northing = redfearn(point[0], point[1]) bounding_polygon_utm.append([easting, northing]) boundary_polygon.append(bounding_polygon_utm[3]) boundary_polygon.append(bounding_polygon_utm[4]) assert num.allclose(bounding_polygon_utm, boundary_polygon) extent_res = 1000000 meshname = 'urs_test_mesh' + '.tsh' interior_regions = None boundary_tags = {'ocean': [0, 1], 'otherocean': [2, 3, 4]} # have to change boundary tags from last example because now bounding # polygon starts in different place. if myid == 0: create_mesh_from_regions(boundary_polygon, boundary_tags=boundary_tags, maximum_triangle_area=extent_res, filename=meshname, interior_regions=interior_regions, verbose=verbose) barrier() domain_fbound = Domain(meshname) domain_fbound.set_quantities_to_be_stored(None) domain_fbound.set_quantity('stage', tide) if verbose: print "Creating file boundary condition" Bf = File_boundary(sts_file + '.sts', domain_fbound, boundary_polygon=boundary_polygon) Br = Reflective_boundary(domain_fbound) domain_fbound.set_boundary({'ocean': Bf, 'otherocean': Br}) temp_fbound = num.zeros(int(finaltime / yieldstep) + 1, num.float) if verbose: print "Evolving domain with file boundary condition" for i, t in enumerate( domain_fbound.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step=False)): temp_fbound[i] = domain_fbound.quantities['stage'].centroid_values[ 2] if verbose: domain_fbound.write_time() domain_drchlt = Domain(meshname) domain_drchlt.set_quantities_to_be_stored(None) domain_drchlt.set_starttime(time_step) domain_drchlt.set_quantity('stage', tide) Br = Reflective_boundary(domain_drchlt) #Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide]) Bd = Time_boundary( domain=domain_drchlt, f=lambda t: [ 2.0 + t / finaltime + tide, 220. + 10. * tide + 10. * t / finaltime, -220. - 10. * tide - 10. * t / finaltime ]) #Bd = Time_boundary(domain=domain_drchlt,f=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)]) domain_drchlt.set_boundary({'ocean': Bd, 'otherocean': Br}) temp_drchlt = num.zeros(int(finaltime / yieldstep) + 1, num.float) for i, t in enumerate( domain_drchlt.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step=False)): temp_drchlt[i] = domain_drchlt.quantities['stage'].centroid_values[ 2] #domain_drchlt.write_time() #print domain_fbound.quantities['stage'].vertex_values #print domain_drchlt.quantities['stage'].vertex_values assert num.allclose(temp_fbound, temp_drchlt), temp_fbound - temp_drchlt assert num.allclose(domain_fbound.quantities['stage'].vertex_values, domain_drchlt.quantities['stage'].vertex_values) assert num.allclose( domain_fbound.quantities['xmomentum'].vertex_values, domain_drchlt.quantities['xmomentum'].vertex_values) assert num.allclose( domain_fbound.quantities['ymomentum'].vertex_values, domain_drchlt.quantities['ymomentum'].vertex_values) if not sys.platform == 'win32': if myid == 0: os.remove(sts_file + '.sts') if myid == 0: os.remove(meshname)
def parallel_time_varying_file_boundary_sts(self): """ parallel_test_time_varying_file_boundary_sts_sequential(self): Read correct points from ordering file and apply sts to boundary. The boundary is time varying. Compares sequential result with distributed result found using anuga_parallel """ #------------------------------------------------------------ # Define test variables #------------------------------------------------------------ lat_long_points = [[6.01, 97.0], [6.02, 97.0], [6.05, 96.9], [6.0, 97.0]] bounding_polygon = [[6.0, 97.0], [6.01, 97.0], [6.02, 97.0], [6.02, 97.02], [6.00, 97.02]] tide = 3.0 time_step_count = 65 time_step = 2 n = len(lat_long_points) first_tstep = num.ones(n, num.int) last_tstep = (time_step_count) * num.ones(n, num.int) finaltime = num.float(time_step * (time_step_count - 1)) yieldstep = num.float(time_step) gauge_depth = 20 * num.ones(n, num.float) ha = 2 * num.ones((n, time_step_count), num.float) ua = 10 * num.ones((n, time_step_count), num.float) va = -10 * num.ones((n, time_step_count), num.float) times = num.arange(0, time_step_count * time_step, time_step) for i in range(n): #ha[i]+=num.sin(times) ha[i] += times / finaltime #------------------------------------------------------------ # Write mux data to file then convert to sts format #------------------------------------------------------------ sts_file = "test" if myid == 0: base_name, files = self.write_mux2(lat_long_points, time_step_count, time_step, first_tstep, last_tstep, depth=gauge_depth, ha=ha, ua=ua, va=va) # base name will not exist, but 3 other files are created # Write order file file_handle, order_base_name = tempfile.mkstemp("") os.close(file_handle) os.remove(order_base_name) d = "," order_file = order_base_name + 'order.txt' fid = open(order_file, 'w') # Write Header header = 'index, longitude, latitude\n' fid.write(header) indices = [3, 0, 1] for i in indices: line=str(i)+d+str(lat_long_points[i][1])+d+\ str(lat_long_points[i][0])+"\n" fid.write(line) fid.close() urs2sts(base_name, basename_out=sts_file, ordering_filename=order_file, mean_stage=tide, verbose=verbose) self.delete_mux(files) assert (os.access(sts_file + '.sts', os.F_OK)) os.remove(order_file) barrier() #------------------------------------------------------------ # Define boundary_polygon on each processor. This polygon defines the # urs boundary and lies on a portion of the bounding_polygon #------------------------------------------------------------ boundary_polygon = create_sts_boundary(sts_file) # Append the remaining part of the boundary polygon to be defined by # the user bounding_polygon_utm = [] for point in bounding_polygon: zone, easting, northing = redfearn(point[0], point[1]) bounding_polygon_utm.append([easting, northing]) boundary_polygon.append(bounding_polygon_utm[3]) boundary_polygon.append(bounding_polygon_utm[4]) assert num.allclose(bounding_polygon_utm, boundary_polygon) extent_res = 10000 meshname = 'urs_test_mesh' + '.tsh' interior_regions = None boundary_tags = {'ocean': [0, 1], 'otherocean': [2, 3, 4]} #------------------------------------------------------------ # Create mesh on the master processor and store in file. This file # is read in by each slave processor when needed #------------------------------------------------------------ if myid == 0: create_mesh_from_regions(boundary_polygon, boundary_tags=boundary_tags, maximum_triangle_area=extent_res, filename=meshname, interior_regions=interior_regions, verbose=verbose) # barrier() domain_fbound = Domain(meshname) domain_fbound.set_quantities_to_be_stored(None) domain_fbound.set_quantity('stage', tide) # print domain_fbound.mesh.get_boundary_polygon() else: domain_fbound = None barrier() if (verbose and myid == 0): print 'DISTRIBUTING PARALLEL DOMAIN' domain_fbound = distribute(domain_fbound) #-------------------------------------------------------------------- # Find which sub_domain in which the interpolation points are located # # Sometimes the interpolation points sit exactly # between two centroids, so in the parallel run we # reset the interpolation points to the centroids # found in the sequential run #-------------------------------------------------------------------- interpolation_points = [[279000, 664000], [280250, 664130], [279280, 665400], [280500, 665000]] interpolation_points = num.array(interpolation_points) #if myid==0: # import pylab as P # boundary_polygon=num.array(boundary_polygon) # P.plot(boundary_polygon[:,0],boundary_polygon[:,1]) # P.plot(interpolation_points[:,0],interpolation_points[:,1],'ko') # P.show() fbound_gauge_values = [] fbound_proc_tri_ids = [] for i, point in enumerate(interpolation_points): fbound_gauge_values.append([]) # Empty list for timeseries try: k = domain_fbound.get_triangle_containing_point(point) if domain_fbound.tri_full_flag[k] == 1: fbound_proc_tri_ids.append(k) else: fbound_proc_tri_ids.append(-1) except: fbound_proc_tri_ids.append(-2) if verbose: print 'P%d has points = %s' % (myid, fbound_proc_tri_ids) #------------------------------------------------------------ # Set boundary conditions #------------------------------------------------------------ Bf = File_boundary(sts_file + '.sts', domain_fbound, boundary_polygon=boundary_polygon) Br = Reflective_boundary(domain_fbound) domain_fbound.set_boundary({'ocean': Bf, 'otherocean': Br}) #------------------------------------------------------------ # Evolve the domain on each processor #------------------------------------------------------------ for i, t in enumerate( domain_fbound.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step=False)): stage = domain_fbound.get_quantity('stage') for i in range(4): if fbound_proc_tri_ids[i] > -1: fbound_gauge_values[i].append( stage.centroid_values[fbound_proc_tri_ids[i]]) #------------------------------------------------------------ # Create domain to be run sequntially on each processor #------------------------------------------------------------ domain_drchlt = Domain(meshname) domain_drchlt.set_quantities_to_be_stored(None) domain_drchlt.set_starttime(time_step) domain_drchlt.set_quantity('stage', tide) Br = Reflective_boundary(domain_drchlt) #Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide]) Bd = Time_boundary( domain=domain_drchlt, function=lambda t: [ 2.0 + t / finaltime + tide, 220. + 10. * tide + 10. * t / finaltime, -220. - 10. * tide - 10. * t / finaltime ]) #Bd = Time_boundary(domain=domain_drchlt,function=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)]) domain_drchlt.set_boundary({'ocean': Bd, 'otherocean': Br}) drchlt_gauge_values = [] drchlt_proc_tri_ids = [] for i, point in enumerate(interpolation_points): drchlt_gauge_values.append([]) # Empty list for timeseries try: k = domain_drchlt.get_triangle_containing_point(point) if domain_drchlt.tri_full_flag[k] == 1: drchlt_proc_tri_ids.append(k) else: drchlt_proc_tri_ids.append(-1) except: drchlt_proc_tri_ids.append(-2) if verbose: print 'P%d has points = %s' % (myid, drchlt_proc_tri_ids) #------------------------------------------------------------ # Evolve entire domain on each processor #------------------------------------------------------------ for i, t in enumerate( domain_drchlt.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step=False)): stage = domain_drchlt.get_quantity('stage') for i in range(4): drchlt_gauge_values[i].append( stage.centroid_values[drchlt_proc_tri_ids[i]]) #------------------------------------------------------------ # Compare sequential values with parallel values #------------------------------------------------------------ barrier() success = True for i in range(4): if fbound_proc_tri_ids[i] > -1: fbound_gauge_values[i] = num.array(fbound_gauge_values[i]) drchlt_gauge_values[i] = num.array(drchlt_gauge_values[i]) #print i,fbound_gauge_values[i][4] #print i,drchlt_gauge_values[i][4] success = success and num.allclose(fbound_gauge_values[i], drchlt_gauge_values[i]) assert success #, (fbound_gauge_values[i]-drchlt_gauge_values[i]) #assert_(success) if not sys.platform == 'win32': if myid == 0: os.remove(sts_file + '.sts') if myid == 0: os.remove(meshname)
def distibute_three_processors(): """ Do a parallel test of distributing a rectangle onto 3 processors """ # FIXME: Need to update expected values on macos if sys.platform == 'darwin': return import pypar myid = pypar.rank() numprocs = pypar.size() if not numprocs == 3: return #print numprocs barrier() if myid == 0: points, vertices, boundary = rectangular_cross(2,2) domain = Domain(points, vertices, boundary) domain.set_quantity('elevation', topography) # Use function for elevation domain.set_quantity('friction', 0.0) # Constant friction domain.set_quantity('stage', expression='elevation') # Dry initial stage domain.set_quantity('xmomentum', expression='friction + 2.0') # domain.set_quantity('ymomentum', ycoord) # #---------------------------------------------------------------------------------- # Test pmesh_divide_metis #---------------------------------------------------------------------------------- nodes, triangles, boundary, triangles_per_proc, quantities = pmesh_divide_metis(domain,numprocs) assert_(num.allclose(nodes,points)) true_vertices = [[0, 9, 1], [3, 9, 0], [4, 9, 3], [1, 9, 4], [1, 10, 2], [4, 10, 1], [5, 10, 4], [2, 10, 5], [3, 11, 4], [6, 11, 3], [7, 11, 6], [4, 11, 7], [4, 12, 5], [7, 12, 4], [8, 12, 7], [5, 12, 8]] true_triangles = [[4, 9, 3], [4, 12, 5], [7, 12, 4], [8, 12, 7], [5, 12, 8], [0, 9, 1], [1, 9, 4], [1, 10, 2], [4, 10, 1], [5, 10, 4], [2, 10, 5], [3, 9, 0], [3, 11, 4], [6, 11, 3], [7, 11, 6], [4, 11, 7]] assert_(num.allclose(vertices,true_vertices)) assert_(num.allclose(triangles,true_triangles)) assert_(num.allclose(triangles_per_proc,[5,6,5])) #---------------------------------------------------------------------------------- # Test build_submesh #---------------------------------------------------------------------------------- submesh = build_submesh(nodes, triangles, boundary, quantities, triangles_per_proc) assert_(num.allclose(submesh['full_nodes'][0],[[3.0, 0.5, 0.0], [4.0, 0.5, 0.5], [5.0, 0.5, 1.0], [7.0, 1.0, 0.5], [8.0, 1.0, 1.0], [9.0, 0.25, 0.25], [12.0, 0.75, 0.75]])) assert_(num.allclose(submesh['full_nodes'][1],[[0.0, 0.0, 0.0], [1.0, 0.0, 0.5], [2.0, 0.0, 1.0], [4.0, 0.5, 0.5], [5.0, 0.5, 1.0], [9.0, 0.25, 0.25], [10.0, 0.25, 0.75]])) assert_(num.allclose(submesh['full_nodes'][2],[[0.0, 0.0, 0.0], [3.0, 0.5, 0.0], [4.0, 0.5, 0.5], [6.0, 1.0, 0.0], [7.0, 1.0, 0.5], [9.0, 0.25, 0.25], [11.0, 0.75, 0.25]])) assert_(num.allclose(submesh['ghost_nodes'][0],[[0.0, 0.0, 0.0], [1.0, 0.0, 0.5], [2.0, 0.0, 1.0], [6.0, 1.0, 0.0], [10.0, 0.25, 0.75], [11.0, 0.75, 0.25]])) assert_(num.allclose(submesh['ghost_nodes'][1],[[3.0, 0.5, 0.0], [7.0, 1.0, 0.5], [8.0, 1.0, 1.0], [11.0, 0.75, 0.25], [12.0, 0.75, 0.75]])) assert_(num.allclose(submesh['ghost_nodes'][2],[[1.0, 0.0, 0.5], [5.0, 0.5, 1.0], [8.0, 1.0, 1.0], [12.0, 0.75, 0.75]])) true_full_triangles = [num.array([[ 4, 9, 3], [ 4, 12, 5], [ 7, 12, 4], [ 8, 12, 7], [ 5, 12, 8]]), num.array([[ 0, 9, 1], [ 1, 9, 4], [ 1, 10, 2], [ 4, 10, 1], [ 5, 10, 4], [ 2, 10, 5]]), num.array([[ 3, 9, 0], [ 3, 11, 4], [ 6, 11, 3], [ 7, 11, 6], [ 4, 11, 7]])] assert_(num.allclose(submesh['full_triangles'][0],true_full_triangles[0])) assert_(num.allclose(submesh['full_triangles'][1],true_full_triangles[1])) assert_(num.allclose(submesh['full_triangles'][2],true_full_triangles[2])) true_ghost_triangles = [num.array([[ 5, 0, 9, 1], [ 6, 1, 9, 4], [ 8, 4, 10, 1], [ 9, 5, 10, 4], [10, 2, 10, 5], [11, 3, 9, 0], [12, 3, 11, 4], [13, 6, 11, 3], [14, 7, 11, 6], [15, 4, 11, 7]]), num.array([[ 0, 4, 9, 3], [ 1, 4, 12, 5], [ 2, 7, 12, 4], [ 4, 5, 12, 8], [11, 3, 9, 0], [12, 3, 11, 4]]), num.array([[ 0, 4, 9, 3], [ 1, 4, 12, 5], [ 2, 7, 12, 4], [ 3, 8, 12, 7], [ 5, 0, 9, 1], [ 6, 1, 9, 4]])] assert_(num.allclose(submesh['ghost_triangles'][0],true_ghost_triangles[0])) assert_(num.allclose(submesh['ghost_triangles'][1],true_ghost_triangles[1])) assert_(num.allclose(submesh['ghost_triangles'][2],true_ghost_triangles[2])) true_full_commun = [{0: [1, 2], 1: [1, 2], 2: [1, 2], 3: [2], 4: [1]}, {5: [0, 2], 6: [0, 2], 7: [], 8: [0], 9: [0], 10: [0]}, {11: [0, 1], 12: [0, 1], 13: [0], 14: [0], 15: [0]}] assert_(true_full_commun == submesh['full_commun']) true_ghost_commun = [num.array([[ 5, 1], [ 6, 1], [ 8, 1], [ 9, 1], [10, 1], [11, 2], [12, 2], [13, 2], [14, 2], [15, 2]]), num.array([[ 0, 0], [ 1, 0], [ 2, 0], [ 4, 0], [11, 2], [12, 2]]), num.array([[0, 0], [1, 0], [2, 0], [3, 0], [5, 1], [6, 1]])] assert_(num.allclose(submesh['ghost_commun'][0],true_ghost_commun[0])) assert_(num.allclose(submesh['ghost_commun'][1],true_ghost_commun[1])) assert_(num.allclose(submesh['ghost_commun'][2],true_ghost_commun[2])) barrier() #-------------------------------- # Now do the comunnication part #-------------------------------- if myid == 0: #---------------------------------------------------------------------------------- # Test send_submesh #---------------------------------------------------------------------------------- for p in range(1, numprocs): send_submesh(submesh, triangles_per_proc, p, verbose=False) #---------------------------------------------------------------------------------- # Test extract_submesh #---------------------------------------------------------------------------------- points, vertices, boundary, quantities, \ ghost_recv_dict, full_send_dict, tri_map, node_map, tri_l2g, node_l2g, \ ghost_layer_width =\ extract_submesh(submesh, triangles_per_proc) true_points = [[0.5, 0.0], [0.5, 0.5], [0.5, 1.0], [1.0, 0.5], [1.0, 1.0], [0.25, 0.25], [0.75, 0.75], [0.0, 0.0], [0.0, 0.5], [0.0, 1.0], [1.0, 0.0], [0.25, 0.75], [0.75, 0.25]] true_vertices = [[1, 5, 0], [1, 6, 2], [3, 6, 1], [4, 6, 3], [2, 6, 4], [7, 5, 8], [8, 5, 1], [1, 11, 8], [2, 11, 1], [9, 11, 2], [0, 5, 7], [0, 12, 1], [10, 12, 0], [3, 12, 10], [1, 12, 3]] true_ghost_recv = {1: [num.array([5, 6, 7, 8, 9]), num.array([ 5, 6, 8, 9, 10])], 2: [num.array([10, 11, 12, 13, 14]), num.array([11, 12, 13, 14, 15])]} true_full_send = {1: [num.array([0, 1, 2, 4]), num.array([0, 1, 2, 4])], 2: [num.array([0, 1, 2, 3]), num.array([0, 1, 2, 3])]} assert_(num.allclose(ghost_layer_width, 2)) assert_(num.allclose(points, true_points)) assert_(num.allclose(vertices, true_vertices)) assert_(num.allclose(ghost_recv_dict[1],true_ghost_recv[1])) assert_(num.allclose(ghost_recv_dict[2],true_ghost_recv[2])) assert_(num.allclose(full_send_dict[1],true_full_send[1])) assert_(num.allclose(full_send_dict[2],true_full_send[2])) #print triangles_per_proc else: #---------------------------------------------------------------------------------- # Test rec_submesh #---------------------------------------------------------------------------------- points, vertices, boundary, quantities, \ ghost_recv_dict, full_send_dict, \ no_full_nodes, no_full_trigs, tri_map, node_map, tri_l2g, node_l2g, \ ghost_layer_width = \ rec_submesh(0, verbose=False) if myid == 1: true_points = [[0.0, 0.0], [0.0, 0.5], [0.0, 1.0], [0.5, 0.5], [0.5, 1.0], [0.25, 0.25], [0.25, 0.75], [0.5, 0.0], [1.0, 0.5], [1.0, 1.0], [0.75, 0.25], [0.75, 0.75]] true_vertices = [[0, 5, 1], [1, 5, 3], [1, 6, 2], [3, 6, 1], [4, 6, 3], [2, 6, 4], [3, 5, 7], [3, 11, 4], [8, 11, 3], [4, 11, 9], [7, 5, 0], [7, 10, 3]] true_ghost_recv = {0: [num.array([6, 7, 8, 9]), num.array([0, 1, 2, 4])], 2: [num.array([10, 11]), num.array([11, 12])]} true_full_send = {0: [num.array([0, 1, 3, 4, 5]), num.array([ 5, 6, 8, 9, 10])], 2: [num.array([0, 1]), num.array([5, 6])]} true_tri_map = num.array([ 6, 7, 8, -1, 9, 0, 1, 2, 3, 4, 5, 10, 11]) true_node_map = num.array([ 0, 1, 2, 7, 3, 4, -1, 8, 9, 5, 6, 10, 11]) assert_(num.allclose(ghost_layer_width, 2)) assert_(num.allclose(tri_map, true_tri_map)) assert_(num.allclose(node_map, true_node_map)) assert_(num.allclose(points, true_points)) assert_(num.allclose(vertices, true_vertices)) assert_(num.allclose(ghost_recv_dict[0],true_ghost_recv[0])) assert_(num.allclose(ghost_recv_dict[2],true_ghost_recv[2])) assert_(num.allclose(full_send_dict[0],true_full_send[0])) assert_(num.allclose(full_send_dict[2],true_full_send[2])) if myid == 2: true_points = [[0.0, 0.0], [0.5, 0.0], [0.5, 0.5], [1.0, 0.0], [1.0, 0.5], [0.25, 0.25], [0.75, 0.25], [0.0, 0.5], [0.5, 1.0], [1.0, 1.0], [0.75, 0.75]] true_vertices = [[1, 5, 0], [1, 6, 2], [3, 6, 1], [4, 6, 3], [2, 6, 4], [2, 5, 1], [2, 10, 8], [4, 10, 2], [9, 10, 4], [0, 5, 7], [7, 5, 2]] true_ghost_recv = {0: [num.array([5, 6, 7, 8]), num.array([0, 1, 2, 3])], 1: [num.array([ 9, 10]), num.array([5, 6])]} true_full_send = {0: [num.array([0, 1, 2, 3, 4]), num.array([11, 12, 13, 14, 15])], 1: [num.array([0, 1]), num.array([11, 12])]} true_tri_map = num.array([5, 6, 7, 8, -1, 9, 10, -1, -1, -1, -1, 0, 1, 2, 3, 4, -1]) true_node_map = num.array([ 0, 7, -1, 1, 2, 8 , 3, 4, 9, 5, -1, 6, 10]) assert_(num.allclose(ghost_layer_width, 2)) assert_(num.allclose(tri_map, true_tri_map)) assert_(num.allclose(node_map, true_node_map)) assert_(num.allclose(points, true_points)) assert_(num.allclose(vertices, true_vertices)) assert_(num.allclose(ghost_recv_dict[0],true_ghost_recv[0])) assert_(num.allclose(ghost_recv_dict[1],true_ghost_recv[1])) assert_(num.allclose(full_send_dict[0],true_full_send[0])) assert_(num.allclose(full_send_dict[1],true_full_send[1]))
def sequential_time_varying_file_boundary_sts(self): """sequential_ltest_time_varying_file_boundary_sts_sequential(self): Read correct points from ordering file and apply sts to boundary. The boundary is time varying. FIXME add to test_urs2sts. """ lat_long_points=[[6.01,97.0],[6.02,97.0],[6.05,96.9],[6.0,97.0]] bounding_polygon=[[6.0,97.0],[6.01,97.0],[6.02,97.0], [6.02,97.02],[6.00,97.02]] tide = 3.0 time_step_count = 65 time_step = 2. n=len(lat_long_points) first_tstep=num.ones(n,num.int) last_tstep=(time_step_count)*num.ones(n,num.int) finaltime=num.float(time_step*(time_step_count-1)) yieldstep=num.float(time_step) gauge_depth=20*num.ones(n,num.float) ha=2*num.ones((n,time_step_count),num.float) ua=10*num.ones((n,time_step_count),num.float) va=-10*num.ones((n,time_step_count),num.float) times=num.arange(0., num.float(time_step_count*time_step), time_step) for i in range(n): #ha[i]+=num.sin(times) ha[i]+=times/finaltime sts_file="test" if myid==0: base_name, files = self.write_mux2(lat_long_points, time_step_count, time_step, first_tstep, last_tstep, depth=gauge_depth, ha=ha, ua=ua, va=va) # base name will not exist, but 3 other files are created # Write order file file_handle, order_base_name = tempfile.mkstemp("") os.close(file_handle) os.remove(order_base_name) d="," order_file=order_base_name+'order.txt' fid=open(order_file,'w') # Write Header header='index, longitude, latitude\n' fid.write(header) indices=[3,0,1] for i in indices: line=str(i)+d+str(lat_long_points[i][1])+d+\ str(lat_long_points[i][0])+"\n" fid.write(line) fid.close() urs2sts(base_name, basename_out=sts_file, ordering_filename=order_file, mean_stage=tide, verbose=verbose) self.delete_mux(files) assert(os.access(sts_file+'.sts', os.F_OK)) os.remove(order_file) barrier() boundary_polygon = create_sts_boundary(sts_file) # Append the remaining part of the boundary polygon to be defined by # the user bounding_polygon_utm=[] for point in bounding_polygon: zone,easting,northing=redfearn(point[0],point[1]) bounding_polygon_utm.append([easting,northing]) boundary_polygon.append(bounding_polygon_utm[3]) boundary_polygon.append(bounding_polygon_utm[4]) assert num.allclose(bounding_polygon_utm,boundary_polygon) extent_res=1000000 meshname = 'urs_test_mesh' + '.tsh' interior_regions=None boundary_tags={'ocean': [0,1], 'otherocean': [2,3,4]} # have to change boundary tags from last example because now bounding # polygon starts in different place. if myid==0: create_mesh_from_regions(boundary_polygon, boundary_tags=boundary_tags, maximum_triangle_area=extent_res, filename=meshname, interior_regions=interior_regions, verbose=verbose) barrier() domain_fbound = Domain(meshname) domain_fbound.set_quantities_to_be_stored(None) domain_fbound.set_quantity('stage', tide) if verbose: print "Creating file boundary condition" Bf = File_boundary(sts_file+'.sts', domain_fbound, boundary_polygon=boundary_polygon) Br = Reflective_boundary(domain_fbound) domain_fbound.set_boundary({'ocean': Bf,'otherocean': Br}) temp_fbound=num.zeros(int(finaltime/yieldstep)+1,num.float) if verbose: print "Evolving domain with file boundary condition" for i, t in enumerate(domain_fbound.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step = False)): temp_fbound[i]=domain_fbound.quantities['stage'].centroid_values[2] if verbose: domain_fbound.write_time() domain_drchlt = Domain(meshname) domain_drchlt.set_quantities_to_be_stored(None) domain_drchlt.set_starttime(time_step) domain_drchlt.set_quantity('stage', tide) Br = Reflective_boundary(domain_drchlt) #Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide]) Bd = Time_boundary(domain=domain_drchlt, f=lambda t: [2.0+t/finaltime+tide,220.+10.*tide+10.*t/finaltime,-220.-10.*tide-10.*t/finaltime]) #Bd = Time_boundary(domain=domain_drchlt,f=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)]) domain_drchlt.set_boundary({'ocean': Bd,'otherocean': Br}) temp_drchlt=num.zeros(int(finaltime/yieldstep)+1,num.float) for i, t in enumerate(domain_drchlt.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step = False)): temp_drchlt[i]=domain_drchlt.quantities['stage'].centroid_values[2] #domain_drchlt.write_time() #print domain_fbound.quantities['stage'].vertex_values #print domain_drchlt.quantities['stage'].vertex_values assert num.allclose(temp_fbound,temp_drchlt),temp_fbound-temp_drchlt assert num.allclose(domain_fbound.quantities['stage'].vertex_values, domain_drchlt.quantities['stage'].vertex_values) assert num.allclose(domain_fbound.quantities['xmomentum'].vertex_values, domain_drchlt.quantities['xmomentum'].vertex_values) assert num.allclose(domain_fbound.quantities['ymomentum'].vertex_values, domain_drchlt.quantities['ymomentum'].vertex_values) if not sys.platform == 'win32': if myid==0: os.remove(sts_file+'.sts') if myid==0: os.remove(meshname)
def parallel_time_varying_file_boundary_sts(self): """ parallel_test_time_varying_file_boundary_sts_sequential(self): Read correct points from ordering file and apply sts to boundary. The boundary is time varying. Compares sequential result with distributed result found using anuga_parallel """ #------------------------------------------------------------ # Define test variables #------------------------------------------------------------ lat_long_points=[[6.01,97.0],[6.02,97.0],[6.05,96.9],[6.0,97.0]] bounding_polygon=[[6.0,97.0],[6.01,97.0],[6.02,97.0], [6.02,97.02],[6.00,97.02]] tide = 3.0 time_step_count = 65 time_step = 2 n=len(lat_long_points) first_tstep=num.ones(n,num.int) last_tstep=(time_step_count)*num.ones(n,num.int) finaltime=num.float(time_step*(time_step_count-1)) yieldstep=num.float(time_step) gauge_depth=20*num.ones(n,num.float) ha=2*num.ones((n,time_step_count),num.float) ua=10*num.ones((n,time_step_count),num.float) va=-10*num.ones((n,time_step_count),num.float) times=num.arange(0, time_step_count*time_step, time_step) for i in range(n): #ha[i]+=num.sin(times) ha[i]+=times/finaltime #------------------------------------------------------------ # Write mux data to file then convert to sts format #------------------------------------------------------------ sts_file="test" if myid==0: base_name, files = self.write_mux2(lat_long_points, time_step_count, time_step, first_tstep, last_tstep, depth=gauge_depth, ha=ha, ua=ua, va=va) # base name will not exist, but 3 other files are created # Write order file file_handle, order_base_name = tempfile.mkstemp("") os.close(file_handle) os.remove(order_base_name) d="," order_file=order_base_name+'order.txt' fid=open(order_file,'w') # Write Header header='index, longitude, latitude\n' fid.write(header) indices=[3,0,1] for i in indices: line=str(i)+d+str(lat_long_points[i][1])+d+\ str(lat_long_points[i][0])+"\n" fid.write(line) fid.close() urs2sts(base_name, basename_out=sts_file, ordering_filename=order_file, mean_stage=tide, verbose=verbose) self.delete_mux(files) assert(os.access(sts_file+'.sts', os.F_OK)) os.remove(order_file) barrier() #------------------------------------------------------------ # Define boundary_polygon on each processor. This polygon defines the # urs boundary and lies on a portion of the bounding_polygon #------------------------------------------------------------ boundary_polygon = create_sts_boundary(sts_file) # Append the remaining part of the boundary polygon to be defined by # the user bounding_polygon_utm=[] for point in bounding_polygon: zone,easting,northing=redfearn(point[0],point[1]) bounding_polygon_utm.append([easting,northing]) boundary_polygon.append(bounding_polygon_utm[3]) boundary_polygon.append(bounding_polygon_utm[4]) assert num.allclose(bounding_polygon_utm,boundary_polygon) extent_res=10000 meshname = 'urs_test_mesh' + '.tsh' interior_regions=None boundary_tags={'ocean': [0,1], 'otherocean': [2,3,4]} #------------------------------------------------------------ # Create mesh on the master processor and store in file. This file # is read in by each slave processor when needed #------------------------------------------------------------ if myid==0: create_mesh_from_regions(boundary_polygon, boundary_tags=boundary_tags, maximum_triangle_area=extent_res, filename=meshname, interior_regions=interior_regions, verbose=verbose) # barrier() domain_fbound = Domain(meshname) domain_fbound.set_quantities_to_be_stored(None) domain_fbound.set_quantity('stage', tide) # print domain_fbound.mesh.get_boundary_polygon() else: domain_fbound=None barrier() if ( verbose and myid == 0 ): print 'DISTRIBUTING PARALLEL DOMAIN' domain_fbound = distribute(domain_fbound) #-------------------------------------------------------------------- # Find which sub_domain in which the interpolation points are located # # Sometimes the interpolation points sit exactly # between two centroids, so in the parallel run we # reset the interpolation points to the centroids # found in the sequential run #-------------------------------------------------------------------- interpolation_points = [[279000,664000], [280250,664130], [279280,665400], [280500,665000]] interpolation_points=num.array(interpolation_points) #if myid==0: # import pylab as P # boundary_polygon=num.array(boundary_polygon) # P.plot(boundary_polygon[:,0],boundary_polygon[:,1]) # P.plot(interpolation_points[:,0],interpolation_points[:,1],'ko') # P.show() fbound_gauge_values = [] fbound_proc_tri_ids = [] for i, point in enumerate(interpolation_points): fbound_gauge_values.append([]) # Empty list for timeseries try: k = domain_fbound.get_triangle_containing_point(point) if domain_fbound.tri_full_flag[k] == 1: fbound_proc_tri_ids.append(k) else: fbound_proc_tri_ids.append(-1) except: fbound_proc_tri_ids.append(-2) if verbose: print 'P%d has points = %s' %(myid, fbound_proc_tri_ids) #------------------------------------------------------------ # Set boundary conditions #------------------------------------------------------------ Bf = File_boundary(sts_file+'.sts', domain_fbound, boundary_polygon=boundary_polygon) Br = Reflective_boundary(domain_fbound) domain_fbound.set_boundary({'ocean': Bf,'otherocean': Br}) #------------------------------------------------------------ # Evolve the domain on each processor #------------------------------------------------------------ for i, t in enumerate(domain_fbound.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step = False)): stage = domain_fbound.get_quantity('stage') for i in range(4): if fbound_proc_tri_ids[i] > -1: fbound_gauge_values[i].append(stage.centroid_values[fbound_proc_tri_ids[i]]) #------------------------------------------------------------ # Create domain to be run sequntially on each processor #------------------------------------------------------------ domain_drchlt = Domain(meshname) domain_drchlt.set_quantities_to_be_stored(None) domain_drchlt.set_starttime(time_step) domain_drchlt.set_quantity('stage', tide) Br = Reflective_boundary(domain_drchlt) #Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide]) Bd = Time_boundary(domain=domain_drchlt, function=lambda t: [2.0+t/finaltime+tide,220.+10.*tide+10.*t/finaltime,-220.-10.*tide-10.*t/finaltime]) #Bd = Time_boundary(domain=domain_drchlt,function=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)]) domain_drchlt.set_boundary({'ocean': Bd,'otherocean': Br}) drchlt_gauge_values = [] drchlt_proc_tri_ids = [] for i, point in enumerate(interpolation_points): drchlt_gauge_values.append([]) # Empty list for timeseries try: k = domain_drchlt.get_triangle_containing_point(point) if domain_drchlt.tri_full_flag[k] == 1: drchlt_proc_tri_ids.append(k) else: drchlt_proc_tri_ids.append(-1) except: drchlt_proc_tri_ids.append(-2) if verbose: print 'P%d has points = %s' %(myid, drchlt_proc_tri_ids) #------------------------------------------------------------ # Evolve entire domain on each processor #------------------------------------------------------------ for i, t in enumerate(domain_drchlt.evolve(yieldstep=yieldstep, finaltime=finaltime, skip_initial_step = False)): stage = domain_drchlt.get_quantity('stage') for i in range(4): drchlt_gauge_values[i].append(stage.centroid_values[drchlt_proc_tri_ids[i]]) #------------------------------------------------------------ # Compare sequential values with parallel values #------------------------------------------------------------ barrier() success = True for i in range(4): if fbound_proc_tri_ids[i] > -1: fbound_gauge_values[i]=num.array(fbound_gauge_values[i]) drchlt_gauge_values[i]=num.array(drchlt_gauge_values[i]) #print i,fbound_gauge_values[i][4] #print i,drchlt_gauge_values[i][4] success = success and num.allclose(fbound_gauge_values[i], drchlt_gauge_values[i]) assert success#, (fbound_gauge_values[i]-drchlt_gauge_values[i]) #assert_(success) if not sys.platform == 'win32': if myid==0: os.remove(sts_file+'.sts') if myid==0: os.remove(meshname)
def setup_mesh(project, setup_initial_conditions=None): """ Code to make the mesh (initial domain) The geometry is made on processor 0, then dumped and reloaded This reduces the memory demands INPUT: project == the project module OUTPUT: domain """ if myid == 0: if verbose: print 'Hello from processor ', myid # # HERE, WE MAKE/PARTITION/READ THE MESH # This can lead to memory savings in parallel runs # (possibly because of limitations of python memory management) # # Let's see if we have already pickled this domain pickle_name = 'domain' + '_P%g_%g.pickle' % (1, 0) pickle_name = join(project.partition_dir, pickle_name) if os.path.exists(pickle_name): if verbose: print 'Saved domain seems to already exist' else: if verbose: print 'CREATING PARTITIONED DOMAIN' domain = build_mesh(project) if setup_initial_conditions is not None: # Set the initial conditions in serial setup_initial_conditions.setup_initial_conditions( domain, project) # If pypar is not available don't use sequential_distribute stuff # (it will fail) if pypar_available: if verbose: print 'Saving Domain' sequential_distribute_dump(domain, 1, partition_dir=project.partition_dir, verbose=verbose) # If pypar is not available don't use sequential_distribute stuff (it # will fail) if pypar_available: # Now partition the domain par_pickle_name = 'domain' + '_P%g_%g.pickle' % (numprocs, 0) par_pickle_name = join(project.partition_dir, par_pickle_name) if os.path.exists(par_pickle_name): if verbose: print 'Saved partitioned domain seems to already exist' else: if verbose: print 'Load in saved sequential pickled domain' domain = \ sequential_distribute_load_pickle_file( pickle_name, np=1, verbose=verbose) if verbose: print 'Dump partitioned domains' sequential_distribute_dump(domain, numprocs, partition_dir=project.partition_dir, verbose=verbose) # This can reduce the memory demands if the domain was made above # Even better to have an existing partition (i.e. stop here and # rerun) domain = None gc.collect() else: domain = None if verbose: print 'Hello from processor ', myid barrier() # print 'Distributing domain' # domain=distribute(domain) # barrier() # If pypar is not available don't use sequential_distribute stuff (it will # fail) if pypar_available: if myid == 0: print 'LOADING PARTITIONED DOMAIN' domain = \ sequential_distribute_load( filename=join(project.partition_dir, 'domain'), verbose=verbose) # ######################################################################### # Set output directories # ######################################################################### domain.set_name(project.scenario) # Name of sww file domain.set_datadir(project.output_dir) # Store sww output here # Needs more changes for this to work # domain.set_checkpointing(checkpoint_time=project.checkpoint_time) # ######################################################################### # Miscellanious numerics # ######################################################################### domain.set_flow_algorithm(project.flow_algorithm) # Force zero beta values [hopefully integrated into source] # print 'Warning: Forcing everything to first order' # domain.beta_w=0. # domain.beta_uh=0. # domain.beta_vh=0. # domain.beta_w_dry=0. # domain.beta_uh_dry=0. # domain.beta_vh_dry=0. # Adjust velocity computation for max quantities # domain.velocity_protection=1.0e-05 # Adjust CFL # domain.set_CFL(0.9) # Optionally store vertex values uniquely (large file sizes!) domain.set_store_vertices_uniquely(project.store_vertices_uniquely) if project.use_local_extrapolation_and_flux_updating: domain.set_local_extrapolation_and_flux_updating() if project.store_elevation_every_timestep: domain.quantities_to_be_stored['elevation'] = 2 else: domain.quantities_to_be_stored['elevation'] = 1 return domain