def trigrid(self): cells = self.nc.variables['nv'][:].T - 1 points = self.points.copy() g = trigrid.TriGrid(points=points, cells=cells) areas = g.areas() sel = np.nonzero(areas < 0)[0] cells[sel, :] = cells[sel, ::-1] # make a clean one with the new cells g = trigrid.TriGrid(points=points, cells=cells) g.make_edges_from_cells() return g
def to_trigrid(self,mesh_name=None,skip_edges=False): nc = self.nc mesh_name = mesh_name or self.mesh_name mesh = nc.variables[mesh_name] node_x_name,node_y_name = mesh.node_coordinates.split() node_xy = np.array( [nc.variables[node_x_name][...], nc.variables[node_y_name][...]]).T faces = nc.variables[mesh.face_node_connectivity][...] edges = nc.variables[mesh.edge_node_connectivity][...] # [N,2] g = trigrid.TriGrid(points=node_xy,cells=faces,edges=edges) if not skip_edges: # g.make_edges_from_cells() # this completely recreates the edges # instead, we need to discern the edge-cell connectivity from the # supplied edges pass return g
if __name__ == '__main__': pc = PolarisCruise(juliandate=2008232) zlf = pc.z_level_field() # and plot the new data: clf() subplot(211) zlf.plot_transect() subplot(212) import trigrid g = trigrid.TriGrid( suntans_path= '/home/rusty/classes/research/suntans/runs/long-delta-250m/rundata') g.plot(all_cells=0) zlf.plot_surface() print("Extrapolated value: ", zlf.extrapolate(550000, 4.2e6, 0)) # # For reference, here are recent cruises that include the Bay Bridge # Date Julian Date # 9/8/2004 2004252 # 9/14/2004 2004258 # 11/3/2004 2004308 # 12/14/2004 2004349 # 12/7/2005 2005341 # 11/22/2005 2005326 # 10/12/2005 2005285
from sunboundary import modifyBCmarker import trigrid import numpy as np import matplotlib.pyplot as plt inpath = 'C:/Projects/GOMGalveston/MODELLING/GalvestonCoarseFinal/rundata/' outpath = 'C:/Projects/GOMGalveston/MODELLING/GalvestonCoarseFinal/grid2' g = trigrid.TriGrid(suntans_path=inpath) for j in np.nonzero(g.edges[:, 2] == 3)[0]: g.delete_edge(j) g.renumber() g.plot() # matplotlib plot of the edges to see if it did the right thing g.write_suntans(outpath)
class Tom(object): scale_shps = None tele_scale_shps = None # NB: this is adjusted by scale_factor before being handed to ApolloniusGraph effective_tele_rate = 1.1 boundary_shp = None plot_interval = None checkpoint_interval = None smooth = 1 resume_checkpoint_fn = None verbosity = 1 dry_run = 0 optimize = None interior_shps = None output_shp = None slide_interior = 1 scale_factor = 1.0 scale_ratio_for_cutoff = 1.0 # These are not currently mutable from the command line # but could be. checkpoint_fn = "checkpoint.pav" plot_fn = "partial-grid.pdf" boundary_poly_shp = "processed-boundary.shp" smoothed_poly_shp = "smoothed-shoreline.shp" linestring_join_tolerance = 1.0 scale_shp_field_name = 'scale' density_map = None # non-customizable instance variables original_boundary_geo = None def __init__(self): self.scale_shps = [] self.tele_scale_shps = [] def usage(self): print "tom.py -h # show this help message " print " -b boundary.shp # boundary shapefile " print " -i interior.shp # interior paving guides " print " --slide-interior # Allow nodes on interior lines to slide [default]" print " --rigid-interior # Force nodes on interior lines to stay put" print " -s scale.shp # scale shapefile " if field.has_apollonius: print " -a telescoping_scale.shp # auto telescoping scale shapefile" print " -t N.NN # telescoping rate - defaults to 1.1" else: print " [DISABLED] -a telescoping_scale.shp" print " -f N.NN # factor for adjusting scale globally" print " -C N.NN # smoothing: min number of cells across a channel" print " -p N # output interval for plots " print " -c N # checkpoint interval " print " -d # disable smoothing " print " -o # enable optimization " print " -r checkpoint.pav # resume from a checkpoint " print " -v N # set verbosity level N" print " -n # ready the shoreline, but don't mesh it" print " -m x1,y1,x2,y2,dx,dy # output raster of scale field" print " -g output.shp # output shapefile of grid" print " boundary.shp: " print " A shapefile containing either lines or a single polygon. If " print " lines, they must join together within a tolerance of 1.0 units" print " scale.shp:" print " A shapefile containing points with a field 'scale', which gives" print " the desired length of the edges in a region." print " If the CGAL-python library is available, multiple shapefiles can " print " be specified, including LineString layers." print " interior.shp:" print " A shapefile containg line segments which will be used to guide the orientation of cells" print " output interval N: " print " Every N steps of the algorithm create a PDF of the grid so far" print " checkpoint interval N:" print " Every N steps of the algorithm make a backup of the grid and all" print " intermediate information" print " resume from checkpoint" print " Loads a previously saved checkpoint file and will continue where it" print " left off." print " verbosity level N:" print " Defaults to 1, which prints step numbers." print " 0: almost silent" print " 1: ~1 line per step" print " 2: ~30 lines per step" print " 3: ~100 lines per step and will try to plot intermediate stages" print " raster of scale field: the given region will be rasterized and output to scale-raster.tif" def run(self, argv): try: opts, rest = getopt.getopt(argv[1:], 'hb:s:a:t:i:c:r:dv:np:om:i:f:g:C:', ['slide-interior', 'rigid-interior']) except getopt.GetoptError, e: print e print "-" * 80 self.usage() exit(1) for opt, val in opts: if opt == '-h': self.usage() exit(1) elif opt == '-s': self.scale_shps.append(val) elif opt == '-a': self.tele_scale_shps.append(val) elif opt == '-t': self.effective_tele_rate = float(val) elif opt == '-f': self.scale_factor = float(val) elif opt == '-b': self.boundary_shp = val elif opt == '-p': self.plot_interval = int(val) elif opt == '-c': self.checkpoint_interval = int(val) elif opt == '-C': self.scale_ratio_for_cutoff = float(val) elif opt == '-r': self.resume_checkpoint_fn = val elif opt == '-d': self.smooth = 0 elif opt == '-v': self.verbosity = int(val) elif opt == '-n': self.dry_run = 1 elif opt == '-o': self.optimize = 1 elif opt == '-m': self.density_map = val elif opt == '-i': if not self.interior_shps: self.interior_shps = [] self.interior_shps.append(val) elif opt == '-g': self.output_shp = val elif opt == '--slide-interior': self.slide_interior = 1 elif opt == '--rigid-interior': self.slide_interior = 0 self.check_parameters() log_fp = open('tom.log', 'wt') log_fp.write("TOM log:\n") log_fp.write(" ".join(argv)) log_fp.close() if not self.resume_checkpoint_fn: bound_args = self.prepare_boundary() density_args = self.prepare_density() args = {} args.update(bound_args) args.update(density_args) args['slide_internal_guides'] = self.slide_interior # Wait until after smoothing to add degenerate interior lines # args.update(self.prepare_interiors()) self.p = paver.Paving(**args) self.p.verbose = self.verbosity self.p.scale_ratio_for_cutoff = self.scale_ratio_for_cutoff if self.smooth: self.p.smooth() # and write out the smoothed shoreline wkb2shp.wkb2shp(self.smoothed_poly_shp, [self.p.poly], overwrite=True) int_args = self.prepare_interiors() if int_args.has_key('degenerates'): for degen in int_args['degenerates']: self.p.clip_and_add_degenerate_ring(degen) else: self.p = paver.Paving.load_complete(self.resume_checkpoint_fn) self.p.verbose = self.verbosity if self.dry_run: print "dry run..." elif self.density_map: f = self.p.density x1, y1, x2, y2, dx, dy = map(float, self.density_map.split(',')) bounds = np.array([[x1, y1], [x2, y2]]) rasterized = f.to_grid(dx=dx, dy=dy, bounds=bounds) rasterized.write_gdal("scale-raster.tif") else: starting_step = self.p.step self.create_grid() if (not os.path.exists('final.pav') ) or self.p.step > starting_step: self.p.write_complete('final.pav') if (not os.path.exists('final.pdf') ) or self.p.step > starting_step: self.plot_intermediate(fn='final.pdf', color_by_step=False) # write grid as shapefile if self.output_shp: print "Writing shapefile with %d features (edgse)" % ( self.p.Nedges()) self.p.write_shp(self.output_shp, only_boundaries=0, overwrite=1) # by reading the suntans grid output back in, we should get boundary edges # marked as 1 - self.p probably doesn't have these markers g = trigrid.TriGrid(suntans_path='.') g.write_shp('trigrid_write.shp', only_boundaries=0, overwrite=1) if self.optimize: self.run_optimization() self.p.write_complete('post-optimize.pav') self.plot_intermediate(fn='post-optimize.pdf')
areas[i] = dA * sum(wet) vols[i] = (dA * (depths[i] - xyz.F[wet])).sum() print "%g: %g %g" % (depths[i], areas[i], vols[i]) if 0: clf() subplot(2, 1, 1) plot(depths, areas) subplot(2, 1, 2) plot(depths, vols) # load the false deltas: import trigrid delta1grid = trigrid.TriGrid( sms_fname='/home/rusty/classes/research/meshing/delta_1.grd') delta2grid = trigrid.TriGrid( sms_fname='/home/rusty/classes/research/meshing/delta_2.grd') dpoints = [] delevs = [] total_false_area = abs(delta1grid.areas()).sum() + abs( delta2grid.areas()).sum() depth_factor = areas[-1] / total_false_area print "Multiplying depths by: ", depth_factor for dgrid in [delta1grid, delta2grid]: # they're tilings, but go ahead and take the mean area: dA = abs(dgrid.areas()).mean() # the area of one triangle
def depths_onto_grid(grid_dir,depth_field_thunk,output_dir=None,do_plot=False): gridpath = grid_dir output_dir = output_dir or grid_dir g = trigrid.TriGrid(suntans_path=gridpath) depth_field = depth_field_thunk() bathy_offset = sunreader.read_bathymetry_offset() vc = g.vcenters() elevations = depth_field(vc) depths = bathy_offset - elevations # combine to one array: xyz = concatenate( (vc,depths[:,newaxis]), axis=1) savetxt(os.path.join(output_dir,'depth.dat'),xyz) # try putting depths on edges, then back-calculate cell depths: edgedepths = zeros( (g.Nedges(),3), float64) edgedepths[:,:2] = g.edge_centers() for j in range(g.Nedges()): if j % 1000==0: print "%d/%d"%(j,g.Nedges()) edgedepths[j,2] = bathy_offset - depth_field.value_on_edge(g.points[g.edges[j,:2]]) savetxt(os.path.join(output_dir,'edgedepth.dat'),edgedepths) # and write a new cell depths file which takes its depth from the edges. celldepths = xyz.copy() for i in range(g.Ncells()): jlist = g.cell2edges(i) celldepths[i,2] = edgedepths[jlist,2].max() savetxt(os.path.join(output_dir,'depth-fromedges.dat'),celldepths) delta = celldepths[:,2] - xyz[:,2] if do_plot: if 1: depths = celldepths lognorm = colors.LogNorm(vmin=max(1.0,nanmin(depths[:,2])), vmax=nanmax( depths[:,2] ) ) # cmap = gmtcm("BkBlAqGrYeOrReViWh200") cmap = load_gradient("oc-sst.cpt") figure(figsize=(100,100)) ax = axes([0,0,1,1]) ax.set_axis_bgcolor('gray') coll = g.plot_scalar(depths[:,2]) coll.norm = lognorm coll.set_cmap(cmap) ax.xaxis.set_visible(0) ax.yaxis.set_visible(0) cax = axes([0.87,0.2,0.03,0.6]) cbar = colorbar(coll,cax=cax) if 1: ticks = [2,5,10,20,50,100,200,500] cbar.set_ticks(ticks) cbar.set_ticklabels(ticks) ax.axis('equal') savefig(os.path.join(output_dir,'grid_and_bathy.pdf'))