def init_geometry(self): """ Compile a grid with simple polygon cells from the boundaries in bounds_shp """ g = unstructured_grid.UnstructuredGrid() for geo in self.bounds['geom']: pnts = np.array(geo) A = pnts[:-1] B = pnts[1:] for a, b in zip(A, B): na = g.add_or_find_node(x=a) nb = g.add_or_find_node(x=b) try: j = g.add_edge(nodes=[na, nb]) except g.GridException: pass cycles = g.find_cycles(max_cycle_len=g.Nnodes()) polys = [geometry.Polygon(g.nodes['x'][cycle]) for cycle in cycles] gc = unstructured_grid.UnstructuredGrid( max_sides=max([len(cyc) for cyc in cycles])) gc.copy_from_grid(g) for cyc in cycles: gc.add_cell(nodes=cyc) self.g = gc
def set_grid(self): g = ugrid.UnstructuredGrid(max_sides=4) g.add_rectilinear([0, 0], [self.L, self.W], self.nx, self.ny) g.orient_edges() g.add_cell_field('cell_z_bed', self.z_bed(g.cells_center())) super(TwoCell, self).set_grid(g)
def __init__(self,**kw): super().__init__(**kw) self.set_run_dir(self.run_dir,mode='pristine') g=unstructured_grid.UnstructuredGrid(max_sides=4) g.add_rectilinear([0,0], [self.L,self.W], nx=1+self.Lcells,ny=1+self.Wcells) node_z_bed=-2*np.ones(g.Nnodes()) # node_z_bed=-2 + ((m_gate5.grid.nodes['x'][:,0] - 50) / 50).clip(0) g.add_node_field('node_z_bed',node_z_bed) super().__init__(grid=g, run_start=np.datetime64("2010-01-01 00:00"), run_stop =np.datetime64("2010-01-02 00:00"), **kw) self.set_bcs() self.add_monitor_sections( [ dict(geom=geometry.LineString([[50,0],[50,20]]), name='at_gate'), dict(geom=geometry.LineString([[80,0],[80,20]]), name='downstream') ] ) self.mdu['geometry','kmx']=self.n_layers self.mdu['geometry','Layertype']=2 # 1: sigma, 2: z, 3: read pliz file # Turn on salinity: self.mdu['physics','salinity']=1 # Will come back to implement a 3D IC self.mdu['physics','InitialSalinity']=15 self.mdu['physics','Idensform']=2 # Decrease imposed mixing to simplify tests self.mdu['physics','Vicouv']=0.0 # Uniform horizontal eddy viscosity (m2/s) self.mdu['physics','Dicouv']=0.0 # eddy diffusivity (m2/s) self.mdu['physics','Vicoww']= 1e-6 # Uniform vertical eddy viscosity (m2/s) self.mdu['physics','Dicoww']= 1e-6 # Uniform vertical eddy diffusivity (m2/s)
def make_2D_grid_Cartesian(self, L, nwide=3, show_grid=False): """ Setup unstructured grid for channel n cells wide Grid is Cartesian with edge length = self.dx """ nlong = int(L / self.dx) ncells = nlong * nwide npoints = (nlong + 1) * (nwide + 1) nedges = nwide * (nlong + 1) + (nwide + 1) * nlong points = np.zeros((npoints, 2), np.float64) cells = -1 * np.ones((ncells, 4), np.int32) # cell nodes edges = -1 * np.ones((nedges, 2), np.int32) # edge nodes ipt = 0 for i in range(nlong + 1): x = self.dx * i for j in range(nwide + 1): y = self.dx * j points[ipt, 0] = x points[ipt, 1] = y ipt += 1 icell = 0 for i in range(nlong): for j in range(nwide): i1 = icell + i i2 = i1 + 1 i3 = icell + nwide + i + 1 i4 = i3 + 1 cells[icell, :] = [i3, i4, i2, i1] icell += 1 iedge = 0 for i in range(nlong): for j in range(nwide): icell = i * nwide + j i1 = icell + i i2 = i1 + 1 i3 = icell + nwide + i + 1 i4 = i3 + 1 if j == 0: edges[iedge, :] = [i1, i3] # bottom iedge += 1 edges[iedge, :] = [i1, i2] # left iedge += 1 edges[iedge, :] = [i2, i4] # top iedge += 1 i = nlong - 1 # last column right edges for j in range(nwide): icell = i * nwide + j i3 = icell + nwide + i + 1 i4 = i3 + 1 edges[iedge, :] = [i3, i4] # top iedge += 1 self.grd = ugrid.UnstructuredGrid(edges=edges, points=points, cells=cells, max_sides=4) if show_grid: self.grd.plot_edges() plt.show() return
def __init__(self, **kw): self.set_run_dir(self.run_dir, mode='pristine') g = unstructured_grid.UnstructuredGrid(max_sides=4) # Sort of Pescadero Lagoon-ish g.add_rectilinear([0, 0], [600, 100], nx=60, ny=5) node_z_bed = -0.5 * np.ones(g.Nnodes()) g.add_node_field('node_z_bed', node_z_bed) super().__init__(grid=g, run_start=np.datetime64("2010-01-01 00:00"), run_stop=np.datetime64("2010-01-03 00:00"), **kw) self.set_bcs() self.config_layers() self.mdu['output', 'MapFormat'] = 4 # ugrid # Turn on salinity: self.mdu['physics', 'salinity'] = 1 self.mdu['physics', 'temperature'] = 0 self.mdu['physics', 'InitialSalinity'] = 15 self.mdu['physics', 'Idensform'] = 2 self.add_monitor_points([ dict(geom=geometry.Point([10, 50]), name='flow_end'), dict(geom=geometry.Point([10, 50]), name='stage_end') ])
def __init__(self, **kw): super().__init__(run_start=np.datetime64("2010-01-01 00:00"), run_stop=np.datetime64("2010-01-05 00:00"), **kw) self.set_run_dir(self.run_dir, mode='pristine') g = unstructured_grid.UnstructuredGrid(max_sides=4) # Sort of Pescadero Lagoon-ish g.add_rectilinear([0, 0], [600, 100], nx=30, ny=5) # Sloping bed to better understand uplift. # node_z_bed=-0.5*np.ones(g.Nnodes()) # slopes from 0.5 at x=0 to -0.5 at x=600 node_z_bed = 0.5 - 1.0 * g.nodes['x'][:, 0] / 600. g.add_node_field('node_z_bed', node_z_bed) self.set_grid(g) self.set_bcs() self.mdu['geometry', 'BedLevType'] = 4 self.config_layers() self.mdu['output', 'MapFormat'] = 4 # ugrid # Turn on salinity: self.mdu['physics', 'salinity'] = 0 self.mdu['physics', 'temperature'] = 0 self.mdu['physics', 'InitialSalinity'] = 15 self.mdu['physics', 'Idensform'] = 2 self.add_monitor_points([ dict(geom=geometry.Point([10, 50]), name='flow_end'), dict(geom=geometry.Point([10, 50]), name='stage_end') ])
def thacker_grid(): thacker_2d_fn='thacker2d-%g.nc'%R if not os.path.exists(thacker_2d_fn): # Generate a radial grid g=unstructured_grid.UnstructuredGrid(max_sides=4) # Add guide rings scale=R/20.0 # nominal edge length nspoke0=4*8 g.add_quad_ring(0*scale,1*scale,nrows=2,nspokes=nspoke0//4,sides=3,stagger0=0.75) g.add_quad_ring(1*scale,2*scale,nrows='stitch',nspokes=nspoke0//4,stagger0=0.25) g.add_quad_ring(2*scale,3*scale,nrows=2,nspokes=nspoke0/2,sides=3,stagger0=0.5) g.add_quad_ring(3*scale,4*scale,nrows='stitch',nspokes=nspoke0/2) # row of quads g.add_quad_ring(4*scale,5*scale,nrows=2,nspokes=nspoke0) # row of quads g.add_quad_ring(5*scale,6*scale,nrows='stitch',nspokes=nspoke0) g.add_quad_ring(6*scale,10*scale,5,2*nspoke0) g.add_quad_ring(10*scale,11*scale,'stitch',2*nspoke0) g.add_quad_ring(11*scale,20*scale,11,4*nspoke0) g.make_cells_from_edges() g.edge_to_cells(recalc=True) g.renumber() g.write_ugrid(thacker_2d_fn,overwrite=True) g=unstructured_grid.UnstructuredGrid.read_ugrid(thacker_2d_fn) return g
def set_grid(self): g = ugrid.UnstructuredGrid(max_sides=4) g.add_rectilinear([-self.L / 2, 0], [self.L / 2, self.W], self.nx + 1, self.ny) g.orient_edges() super(SubgridThacker1D, self).set_grid(g)
def test_sed_mpi(): model=base_model() g=unstructured_grid.UnstructuredGrid(max_sides=4) g.add_rectilinear([0,0],[1000,100],101,11) g.add_cell_field('depth',-6*np.ones(g.Ncells())) model.set_grid(g) model.num_procs=4 model.config['dt']=3. # slow down the settling velocities to get some advection mixed in model.config['Ws01']= 0.0001 # constant settling velocity for fraction No.1 (m/s) model.config['Ws02']= 0.0005 # constant settling velocity for fraction No.2 model.config['Ws03']=-0.0005 # constant settling velocity for fraction No.3 geom=np.array([ [1000,0], [1000,100]]) Q_bc=sun_driver.FlowBC(name="Q_bc", geom=geom, Q=100.0) model.add_bcs( [Q_bc, sun_driver.ScalarBC(parent=Q_bc,scalar="S",value=2), sun_driver.ScalarBC(parent=Q_bc,scalar="T",value=0)] ) point_bc=sun_driver.SourceSinkBC(name="bedPoint", geom=np.array([500,20]), Q=10) model.add_bcs( [point_bc, sun_driver.ScalarBC(parent=point_bc,scalar="S",value=3), sun_driver.ScalarBC(parent=point_bc,scalar="T",value=3)] ) model.write() # leave some dry layers at the surface model.ic_ds.eta.values[:]=model.bcs[0].z model.ic_ds.salt.values[:]=1.0 model.ic_ds.temp.values[:]=1.0 model.write_ic_ds() for sed_idx in range(3): name="sed%d"%(sed_idx+1) model.bc_ds['boundary_'+name]=model.bc_ds['boundary_S'].copy() model.bc_ds[name]=model.bc_ds['S'].copy() model.bc_ds['point_'+name]=model.bc_ds['point_S'].copy() model.bc_ds['boundary_'+name].values[:]=sed_idx*1.0 model.bc_ds[name].values[:]=0.0 model.bc_ds['point_'+name].values[:]=sed_idx*2.0 model.write_bc_ds() model.partition() model.sun_verbose_flag='-v' model.run_simulation() return model
def init(): # inserting a constraint dt = unstructured_grid.UnstructuredGrid() cdt = cdt_class(dt) pnts = [[0, 0], [5, 0], [10, 0], [5, 5], [3, 0], [6, 2], [12, 4]] for pnt in pnts: dt.add_node(x=pnt) return dt, cdt
def test_flip1_cgal(): plot = False g = unstructured_grid.UnstructuredGrid() cdt = shadow_cdt.ShadowCGALCDT(g) pnts = [[0, 0], [8, 0], [10, 5], [5, 5], [3, 0]] [g.add_node(x=pnt) for pnt in pnts]
def set_grid(self): g = ugrid.UnstructuredGrid(max_sides=4) g.add_rectilinear([0, 0], [self.L, self.W], self.nx, self.ny) g.orient_edges() g.add_node_field('node_z_bed', self.z_bed(g.nodes['x'])) g.add_cell_field('cell_z_bed', self.z_bed(g.cells_center())) super(SwampyBump1D, self).set_grid(g)
def test_duplicate_edge(): ug=unstructured_grid.UnstructuredGrid(max_sides=4) n1=ug.add_node(x=[0,0]) n2=ug.add_node(x=[1,0]) j1=ug.add_edge(nodes=[n1,n2]) with assert_raises(unstructured_grid.GridException) as cm: j2=ug.add_edge(nodes=[n2,n1])
def base_grid(): g = ugrid.UnstructuredGrid(max_sides=4) g.add_rectilinear([0, 0], [L, W], nx, ny) # z=0 along lower edge, and 10 on the upper edge. # node_depths=-g.nodes['x'][:,1]/10. node_depths = dem(g.nodes['x']) g.add_node_field('depth', node_depths) return g
def import_ras_geometry(self, hdf_fname, twod_area_name, max_cell_faces, show_grid=False): h = h5py.File(hdf_fname, 'r') points_xy = h['Geometry/2D Flow Areas/' + twod_area_name + '/FacePoints Coordinate'] npoints = len(points_xy) points = np.zeros((npoints, 2), np.float64) for n in range(npoints): points[n, 0] = points_xy[n][0] points[n, 1] = points_xy[n][1] edge_nodes = h['Geometry/2D Flow Areas/' + twod_area_name + '/Faces FacePoint Indexes'] nedges = len(edge_nodes) edges = -1 * np.ones((nedges, 2), dtype=int) for j in range(nedges): edges[j][0] = edge_nodes[j][0] edges[j][1] = edge_nodes[j][1] cell_nodes = h['Geometry/2D Flow Areas/' + twod_area_name + '/Cells FacePoint Indexes'] for i in range(len(cell_nodes)): if cell_nodes[i][ 2] < 0: # first ghost cell (which are sorted to end of list) break ncells = i # don't count ghost cells cells = -1 * np.ones((ncells, max_cell_faces), dtype=int) for i in range(ncells): for k in range(max_cell_faces): cells[i][k] = cell_nodes[i][k] cell_center_xy = h['Geometry/2D Flow Areas/' + twod_area_name + '/Cells Center Coordinate'] self.ras_xf = np.array([cell_center_xy[i][0] for i in range(ncells)]) self.ras_yf = np.array([cell_center_xy[i][1] for i in range(ncells)]) self.grd = ugrid.UnstructuredGrid(edges=edges, points=points, cells=cells, max_sides=max_cell_faces) if show_grid: self.grd.plot_edges() ax = plt.gca() ax.plot(self.ras_xf, self.ras_yf, 'rs', ms=3, mfc='none') plt.show() return
def test_triangle_from_scratch(): ug=unstructured_grid.UnstructuredGrid(max_sides=4) n1=ug.add_node(x=[0,0]) n2=ug.add_node(x=[1,0]) n3=ug.add_node(x=[1,1]) j1=ug.add_edge(nodes=[n1,n2]) j2=ug.add_edge(nodes=[n2,n3]) j3=ug.add_edge(nodes=[n3,n1]) c1=ug.toggle_cell_at_point([0.2,0.2])
def test_point_source_1d(): """ Create a 1D water column, with a point source at the bed. Verifies that all cells with valid thickness (dzz>0.001m) have near unity salinity. """ g=unstructured_grid.UnstructuredGrid(max_sides=4) g.add_rectilinear([0,0],[10,10],2,2) g.add_cell_field('depth',-6*np.ones(g.Ncells())) model=sun_driver.SuntansModel() model.load_template('point_source_test.dat') model.set_grid(g) model.run_start=np.datetime64("2018-01-01 00:00") model.run_stop =np.datetime64("2018-01-01 10:00") source=sun_driver.SourceSinkBC(name='inflow',geom=np.array([5,5]), z=-10,Q=1.0) model.add_bcs(source) model.add_bcs( [sun_driver.ScalarBC(parent=source,scalar="S",value=1), sun_driver.ScalarBC(parent=source,scalar="T",value=1)] ) model.set_run_dir('rundata_point_1d', mode='pristine') model.projection='EPSG:26910' model.config['dt']=2.5 model.config['ntout']=1 model.config['Cmax']=30 model.config['Nkmax']=10 model.config['stairstep']=0 model.config['mergeArrays']=0 model.write() model.ic_ds.eta.values[:]=-5.999 model.ic_ds.salt.values[:]=1.0 model.ic_ds.temp.values[:]=1.0 model.write_ic_ds() model.partition() model.sun_verbose_flag='-v' model.run_simulation() ds=xr.open_dataset(model.map_outputs()[0]) dzz=ds.dzz.values dzz_thresh=0.001 salt=ds.salt.values salt_errors=salt[dzz>=dzz_thresh] - 1.0 assert np.max( np.abs(salt_errors) )<0.001
def test_pickle(): ug=unstructured_grid.UnstructuredGrid(max_sides=4) def cb(*a,**k): pass ug.subscribe_after('add_node',cb) chk=ug.checkpoint() n1=ug.add_node(x=[0,0]) n2=ug.add_node(x=[1,0]) j1=ug.add_edge(nodes=[n1,n2]) ug.write_pickle('blah.pkl') ug2=unstructured_grid.UnstructuredGrid.from_pickle('blah.pkl')
def test_constraints_dim1_cgal(): g = unstructured_grid.UnstructuredGrid() cdt = shadow_cdt.ShadowCGALCDT(g) pnts = [[0, 0], [5, 0], [10, 0]] nodes = [g.add_node(x=pnt) for pnt in pnts] j0 = g.add_edge(nodes=[nodes[0], nodes[1]]) j1 = g.add_edge(nodes=[nodes[1], nodes[2]]) g.delete_edge(j0) g.delete_edge(j1) try: g.add_edge(nodes=[nodes[0], nodes[2]]) assert False except cdt.ConstraintCollinearNode: pass #
def process_quad_patch(name, M=None): center_idx = np.nonzero(centerlines['name'] == name)[0][0] centerline = centerlines['geom'][center_idx] if M is None: M = centerlines['rows'][center_idx] bound = bounds['geom'][bounds['name'] == name][0] center = linestring_utils.resample_linearring(np.array(centerline), scale, closed_ring=0) g = unstructured_grid.UnstructuredGrid(max_sides=6) # Smooth the exterior ext_points = np.array(bound.exterior) ext_points = linestring_utils.resample_linearring(ext_points, scale, closed_ring=True) from stompy import filters ext_points[:, 0] = filters.lowpass_fir(ext_points[:, 0], 3) ext_points[:, 1] = filters.lowpass_fir(ext_points[:, 1], 3) smooth_bound = geometry.Polygon(ext_points) L = smooth_bound.exterior.length def profile(x, s, perp): probe_left = geometry.LineString([x, x + L * perp]) probe_right = geometry.LineString([x, x - L * perp]) left_cross = smooth_bound.exterior.intersection(probe_left) right_cross = smooth_bound.exterior.intersection(probe_right) assert left_cross.type == 'Point', "Fix this for multiple intersections" assert right_cross.type == 'Point', "Fix this for multiple intersections" pnt_left = np.array(left_cross) pnt_right = np.array(right_cross) d_left = utils.dist(x, pnt_left) d_right = utils.dist(x, pnt_right) return np.interp(np.linspace(-1, 1, M), [-1, 0, 1], [-d_right, 0, d_left]) g.add_rectilinear_on_line(center, profile) g.renumber() return g
def test_quad_from_scratch(): ug=unstructured_grid.UnstructuredGrid(max_sides=4) n1=ug.add_node(x=[0,0]) n2=ug.add_node(x=[1,0]) n3=ug.add_node(x=[1,1]) n4=ug.add_node(x=[0,1]) j1=ug.add_edge(nodes=[n1,n2]) j2=ug.add_edge(nodes=[n2,n3]) j3=ug.add_edge(nodes=[n3,n4]) j4=ug.add_edge(nodes=[n4,n1]) c1=ug.toggle_cell_at_point([0.2,0.2]) # and remove it.. ug.toggle_cell_at_point([0.2,0.2])
def test_remove_constraint_cgal(): g = unstructured_grid.UnstructuredGrid() cdt = shadow_cdt.ShadowCGALCDT(g) # inserting a constraint pnts = [[0, 0], [5, 0], [10, 0], [5, 5], [3, 0], [6, 2], [12, 4]] nodes = [g.add_node(x=pnt) for pnt in pnts] j0 = g.add_edge(nodes=[nodes[4], nodes[6]]) nodes.append(g.add_node(x=[7, 0.5])) g.delete_edge(j0) j1 = g.add_edge(nodes=[nodes[2], nodes[3]]) j2 = g.add_edge(nodes=[nodes[4], nodes[7]]) g.delete_edge(j1) g.delete_edge(j2)
def test_fuzz1_cgal(): plot = False # Fuzzing, regular x = np.arange(5) y = np.arange(5) X, Y = np.meshgrid(x, y) xys = np.array([X.ravel(), Y.ravel()]).T if plot: plt.figure(1).clf() fig, ax = plt.subplots(num=1) ax.plot(xys[:, 0], xys[:, 1], 'go', alpha=0.4) ax.axis([-1, 5, -1, 5]) idxs = np.zeros(len(xys), 'i8') - 1 g = unstructured_grid.UnstructuredGrid() cdt = shadow_cdt.ShadowCGALCDT(g) # definitely slows down as the number of nodes gets larger. # starting off with <1s per 100 operations, later more like 2s for repeat in range(1): print "Repeat: ", repeat for step in range(1000): if step % 200 == 0: print " step: ", step toggle = np.random.randint(len(idxs)) if idxs[toggle] < 0: idxs[toggle] = g.add_node(x=xys[toggle]) else: g.delete_node(idxs[toggle]) idxs[toggle] = -1 if plot: del ax.lines[1:] ax.texts = [] ax.collections = [] dt.plot_nodes(labeler=lambda n, nrec: str(n)) dt.plot_edges(alpha=0.5, lw=2) dt.plot_cells(lw=7, facecolor='#ddddff', edgecolor='w', zorder=-5) plt.draw()
def run_node_insertion(cdt_class): g = unstructured_grid.UnstructuredGrid() cdt = cdt_class(g) pnts = [[0, 0], [5, 0], [10, 0], [5, 5]] nA = g.add_node(x=pnts[0]) # This tests insert into empty g.add_node(x=pnts[1]) # adjacent_vertex g.add_node(x=pnts[2]) # adjacent_vertex g.add_node(x=pnts[3]) # adjacent_edge g.add_node(x=[3, 0]) # colinear g.add_node(x=[6, 2]) # into cell interior nB = g.add_node(x=[12, 4]) # collinear cell interior return g, cdt # helps with debugging
def base_model(force=True, num_procs=1, run_dir='run-dfm-test'): if not force and dflow_model.DFlowModel.run_completed(run_dir): model = dflow_model.DFlowModel.load(run_dir) return model g = unstructured_grid.UnstructuredGrid(max_sides=4) ret = g.add_rectilinear([0, 0], [500, 500], 50, 50) # sloping N-S from -3 at y=0 to +2 at y=500 g.add_node_field('depth', -3 + g.nodes['x'][:, 1] / 100) model = dflow_model.DFlowModel() model.load_template('dflow-template.mdu') model.set_grid(g) model.num_procs = num_procs model.set_run_dir(run_dir, mode='pristine') model.run_start = np.datetime64("2018-01-01 00:00") model.run_stop = np.datetime64("2018-01-03 00:00") dt = np.timedelta64(300, 's') t = np.arange(model.run_start - 20 * dt, model.run_stop + 20 * dt, dt) # 4h period periodic_Q = 50 * np.sin( (t - t[0]) / np.timedelta64(1, 's') * 2 * np.pi / (4 * 3600.)) Q = xr.DataArray(periodic_Q, dims=['time'], coords={'time': t}) inflow = dflow_model.FlowBC(name='inflow', geom=np.array([[0, 0], [0, 500]]), Q=Q) model.add_bcs(inflow) model.projection = 'EPSG:26910' model.mdu['geometry', 'WaterLevIni'] = 0.0 model.mdu['output', 'WaqInterval'] = 1800 model.mdu['output', 'MapInterval'] = 1800 model.write() if not model.is_completed(): model.partition() model.run_model() return model
def build_net(self): """ Build a pseudo grid that has edges for neighbors (like a dual, but including a larger neighborhood. """ self.t_dual = self.g # transit time network self.t_net = unstructured_grid.UnstructuredGrid(extra_node_fields=[ ('value', np.float64), ('dual_cell', np.int32), ('hydro_cell', np.int32) ], extra_edge_fields=[ ('Td', np.float64) ]) self.dual_to_net_node = {} # speed up the reverse lookup cc = g.cells_center() for c in np.nonzero(self.g.cell_clip_mask(self.clip))[0]: n = self.t_net.add_node(x=cc[c], value=np.nan, dual_cell=c, hydro_cell=c) self.dual_to_net_node[c] = n # Create the neighborhood connectivity for n in range(self.t_net.Nnodes()): c = self.t_net.nodes['dual_cell'][n] # use nodes to get the neighborhood of cells c_nodes = self.g.cell_to_nodes(c) c_cells = [] for c_node in c_nodes: c_cells += list(self.g.node_to_cells(c_node)) c_cells = set(c_cells) for cnbr in c_cells: if (cnbr == c) or (cnbr not in self.dual_to_net_node): # if we clipped the original, this will have a few # hits outside the clip, which we ignore. continue try: self.t_net.add_edge(nodes=[n, self.dual_to_net_node[cnbr]]) except self.t_net.GridException: pass # b/c the edge is already there - great.
def make_1D_grid_Cartesian_non_orthog(self, L, show_grid=False): """ Setup unstructured grid for channel 1 cell wide Grid is Cartesian with edge length = self.dx but then has random displacement of nodes to create non-orothgonality """ ncells = int(L / self.dx) npoints = 2 * ncells + 2 nedges = 3 * ncells + 1 points = np.zeros((npoints, 2), np.float64) # in future if only 3 edges, node4 will have value -1 cells = -1 * np.ones((ncells, 4), np.int32) # cell nodes edges = -1 * np.ones((nedges, 2), np.int32) # edge nodes max_displacement = 0.4 for i in range(ncells + 1): # set node x,y etc. disp = 2 * max_displacement * random.random() - max_displacement points[2 * i, 0] = self.dx * i + disp disp = 2 * max_displacement * random.random() - max_displacement points[2 * i, 1] = 0.0 + disp disp = 2 * max_displacement * random.random() - max_displacement points[2 * i + 1, 0] = self.dx * i + disp disp = 2 * max_displacement * random.random() - max_displacement points[2 * i + 1, 1] = self.dx + disp if i < ncells: cells[i, :] = [2 * (i + 1), 2 * (i + 1) + 1, 2 * i + 1, 2 * i] # bottom of cell edges[3 * i, :] = [2 * (i + 1), 2 * i] # left of cell edges[3 * i + 1, :] = [2 * i, 2 * i + 1] # top of cell edges[3 * i + 2, :] = [2 * i + 1, 2 * (i + 1) + 1] # far right hand edge edges[3 * ncells, :] = [2 * ncells, 2 * ncells + 1] self.grd = ugrid.UnstructuredGrid(edges=edges, points=points, cells=cells, max_sides=4) if show_grid: self.grd.plot_edges() plt.show() return
def make_sector_grid(self): g=unstructured_grid.UnstructuredGrid(max_sides=4) g.add_rectilinear([-R,-1], [R,1], nx=2*self.sector_grid_N-1, ny=2) sector_angle=2*np.pi / 128 n=g.select_nodes_nearest([0,1]) # will delete this n2=g.select_nodes_nearest([0,-1]) # and make triangles with this nbrs=g.node_to_nodes(n) g.delete_node_cascade(n) for nbr in nbrs: if nbr!=n2: g.add_edge(nodes=[nbr,n2]) g.nodes['x'][:,1] = g.nodes['x'][:,1] * g.nodes['x'][:,0]*np.sin(sector_angle/2) g.make_cells_from_edges() g.renumber() g.edge_to_cells(recalc=True) g.cells_center(refresh=True) return g
def make_1D_grid_equilat_tri(self, L, show_grid=False): """ Setup unstructured grid for channel of equilateral triangles Edge length = self.dx """ n = int(L / self.dx) ncells = 2 * n npoints = 2 * n + 2 nedges = 4 * n + 1 points = np.zeros((npoints, 2), np.float64) # in future if only 3 edges, node4 will have value -1 cells = -1 * np.ones((ncells, 3), np.int32) # cell nodes edges = -1 * np.ones((nedges, 2), np.int32) # edge nodes for i in range(n + 1): # set node x,y etc. points[2 * i, 0] = self.dx * i points[2 * i, 1] = 0.0 points[2 * i + 1, 0] = self.dx * i + 0.5 * self.dx points[2 * i + 1, 1] = self.dx * np.sqrt(3.) / 2. if i < n: cells[2 * i, :] = [2 * (i + 1), 2 * i + 1, 2 * i] cells[2 * i + 1, :] = [2 * (i + 1) + 1, 2 * i + 1, 2 * (i + 1)] # bottom of cell edges[4 * i, :] = [2 * (i + 1), 2 * i] # left of cell edges[4 * i + 1, :] = [2 * i, 2 * i + 1] # top of cell edges[4 * i + 2, :] = [2 * i + 1, 2 * (i + 1) + 1] # diag of cell edges[4 * i + 3, :] = [2 * (i + 1), 2 * i + 1] # far right hand edge edges[4 * n, :] = [npoints - 1, npoints - 2] self.grd = ugrid.UnstructuredGrid(edges=edges, points=points, cells=cells, max_sides=3) if show_grid: self.grd.plot_edges() plt.show() return
def test_undo_00(): ug=unstructured_grid.UnstructuredGrid() n1=ug.add_node(x=[0,0]) n2=ug.add_node(x=[0,1]) n3=ug.add_node(x=[0.67,0.5]) e1=ug.add_edge(nodes=[n1,n2]) e2=ug.add_edge(nodes=[n1,n3]) cp=ug.checkpoint() e3=ug.add_edge(nodes=[n2,n3]) c0=ug.add_cell(nodes=[n1,n2,n3]) assert ug.Ncells()==1 assert ug.Nedges()==3 assert ug.Nnodes()==3 ug.revert(cp) assert ug.Ncells()==0 assert ug.Nedges()==2 assert ug.Nnodes()==3