def read_ugrid(self, path):
"""
Read Ugrid from netcdf and return dflowfm cstructure with grid
"""
ncfile = netCDF4.Dataset(path)
# Read mesh1d
mesh1d = meshgeom(meshgeomdim())
read_dimensions(mesh1d.meshgeomdim, '1d', ncfile)
read_values(mesh1d, '1d', ncfile)
schematised, branches = mesh1d.process_1d_network()
self.network.mesh1d.add_from_other(mesh1d)
# Add branches
for idx, geometry in branches.items():
self.network.branches.at[idx, 'geometry'] = geometry
for idx, geometry in schematised.items():
self.network.schematised.at[idx, 'geometry'] = geometry
# Read mesh2d
mesh2d = meshgeom(meshgeomdim())
read_dimensions(mesh2d.meshgeomdim, '2d', ncfile)
read_values(mesh2d, '2d', ncfile)
self.network.mesh2d.add_from_other(mesh2d)
# Read links1d2d
links_1dnode, links_2dface = read_links(ncfile)
self.network.links1d2d.nodes1d.extend(links_1dnode)
self.network.links1d2d.faces2d.extend(links_2dface)
ncfile.close()
def __init__(self):
self.fill_value_z = -999.0
self.missing_z_value = None
self.meshgeomdim = meshgeomdim(pointer(c_char()), 2, 0, 0, 0, 0, -1,
-1, -1, -1, -1, 0)
self.meshgeom = meshgeom(self.meshgeomdim)
def _find_cells(geometries, maxnumfacenodes=None):
"""
Determine what the cells are in a grid.
"""
dimensions = geometries.meshgeomdim
wrapperGridgeom = CDLL(
os.path.join(os.path.dirname(__file__), '..', 'lib',
'gridgeom.dll'))
ierr = wrapperGridgeom.ggeo_deallocate()
assert ierr == 0
start_index = c_int(1)
meshdimout = meshgeomdim()
meshout = meshgeom(meshdimout)
ierr = wrapperGridgeom.ggeo_find_cells(byref(dimensions),
byref(geometries),
byref(meshdimout),
byref(meshout),
byref(start_index))
assert ierr == 0
dimensions.numface = meshdimout.numface
if maxnumfacenodes is None:
dimensions.maxnumfacenodes = meshdimout.maxnumfacenodes
else:
dimensions.maxnumfacenodes = maxnumfacenodes
# Allocate
for mesh in [geometries, meshout]:
for var in ['facex', 'facey', 'face_nodes']:
mesh.allocate(var)
ierr = wrapperGridgeom.ggeo_find_cells(byref(dimensions),
byref(geometries),
byref(meshdimout),
byref(meshout),
byref(start_index))
assert ierr == 0
# Copy content to self meshgeom
for var in ['facex', 'facey', 'face_nodes']:
# Create array of allocated size. In case of deviating maxnumfacenodes
if (maxnumfacenodes is not None) and (var == 'face_nodes'):
# Create an empty integer. Empty values should only be present in the integer arrays
arr = np.full(geometries.get_dimensions(var), -999, dtype=int)
# Get array
arr[:, :meshout.meshgeomdim.
maxnumfacenodes] = meshout.get_values(var, as_array=True)
# Set array
geometries.set_values(var, arr.ravel())
else:
# Set array
geometries.set_values(var, meshout.get_values(var))
ierr = wrapperGridgeom.ggeo_deallocate()
def _find_cells(geometries):
"""
Determine what the cells are in a grid.
"""
dimensions = geometries.meshgeomdim
wrapperGridgeom = CDLL(os.path.join(os.path.dirname(__file__), '..', 'lib', 'gridgeom.dll'))
ierr = wrapperGridgeom.ggeo_deallocate()
assert ierr == 0
start_index = c_int(1)
meshdimout = meshgeomdim()
meshout = meshgeom(meshdimout)
ierr = wrapperGridgeom.ggeo_find_cells(
byref(dimensions),
byref(geometries),
byref(meshdimout),
byref(meshout),
byref(start_index)
)
assert ierr == 0
dimensions.numface = meshdimout.numface
dimensions.maxnumfacenodes = meshdimout.maxnumfacenodes
# Allocate
for mesh in [geometries, meshout]:
for var in ['facex', 'facey', 'face_nodes']:
mesh.allocate(var)
ierr = wrapperGridgeom.ggeo_find_cells(
byref(dimensions),
byref(geometries),
byref(meshdimout),
byref(meshout),
byref(start_index)
)
assert ierr == 0
# Copy content to self meshgeom
for var in ['facex', 'facey', 'face_nodes']:
geometries.set_values(var, meshout.get_values(var))
ierr = wrapperGridgeom.ggeo_deallocate()
def generate_grid(self, x0, y0, dx, dy, ncols, nrows, clipgeo=None, rotation=0):
"""
Generate rectangular grid based on the origin (x0, y0) the cell sizes (dx, dy),
the number of columns and rows (ncols, nrows) and a rotation in degrees (default=0)
A geometry (clipgeo) can be given to clip the grid.
"""
# Generate x and y spacing
x = np.linspace(x0, x0 + dx * (ncols), ncols+1)
y = np.linspace(y0, y0 + dy * (nrows), nrows+1)
# Get nodes
xnodes, ynodes = np.meshgrid(x, y)
# Rotate
if rotation != 0:
self.rotated = True
xnodes, ynodes = geometry.rotate_coordinates((x0, y0), np.radians(rotation), xnodes, ynodes)
# Get nodes as list
nodes = {crd: i+1 for i, crd in enumerate(zip(xnodes.ravel(), ynodes.ravel()))}
# Create segments
segments = list(zip(
zip(*np.c_[xnodes[:, :-1].ravel(), ynodes[:, :-1].ravel()].T),
zip(*np.c_[xnodes[:, 1:].ravel(), ynodes[:, 1:].ravel()].T)
))
segments += list(zip(
zip(*np.c_[xnodes[1:, :].ravel(), ynodes[1:, :].ravel()].T),
zip(*np.c_[xnodes[:-1, :].ravel(), ynodes[:-1, :].ravel()].T)
))
# Get links
edge_nodes = np.asarray([(nodes[s[0]], nodes[s[1]]) for s in segments])
# Rvael the nodes
xnodes = xnodes.ravel()
ynodes = ynodes.ravel()
# Add to mesh
dimensions = meshgeomdim()
dimensions.dim = 2
geometries = meshgeom(dimensions)
# Clip
if clipgeo is not None:
xnodes, ynodes, edge_nodes = self.clip_nodes(xnodes, ynodes, edge_nodes, clipgeo)
# Update dimensions
dimensions.numnode = len(xnodes)
dimensions.numedge = len(edge_nodes)
# Add nodes and links
geometries.set_values('nodex', xnodes)
geometries.set_values('nodey', ynodes)
geometries.set_values('edge_nodes', np.ravel(edge_nodes).tolist())
# Determine what the cells are
self._find_cells(geometries)
# Clip
if clipgeo is not None:
# Clean nodes, this function deletes nodes based on no longer existing cells
face_nodes = geometries.get_values('face_nodes', as_array=True)
cleaned = self.clean_nodes(xnodes, ynodes, edge_nodes, face_nodes)
# If cleaning leaves no whole cells, return None
if cleaned is None:
return None
# Else, get the arguments from the returned tuple
else:
xnodes, ynodes, edge_nodes, face_nodes = cleaned
# Update dimensions
dimensions.numnode = len(xnodes)
dimensions.numedge = len(edge_nodes)
dimensions.maxnumfacenodes = 4
# Add nodes and links
geometries.set_values('nodex', xnodes)
geometries.set_values('nodey', ynodes)
geometries.set_values('edge_nodes', np.ravel(edge_nodes).tolist())
geometries.set_values('face_nodes', np.ravel(face_nodes).tolist())
# Add to mesh
self.meshgeom.add_from_other(geometries)