def geographic_xpts(self):
"""
Method to retranslate model coordinates to geometric
coordinates for plotting
Returns:
"""
if self.__geographic_xpts is None:
xypts = self.xpts.T
xypts = geometry.transform(xypts[0], xypts[1],
self.mg.xoffset,
self.mg.yoffset,
self.mg.angrot_radians)
if self.direction == "xy":
xdist = np.max(xypts[0]) - np.min(xypts[0])
ydist = np.max(xypts[1]) - np.min(xypts[1])
if xdist >= ydist:
xypts = np.append(xypts, np.array([xypts[0]]), axis=0)
else:
xypts = np.append(xypts, np.array([xypts[1]]), axis=0)
else:
xypts = np.append(xypts, np.array([xypts[0]]), axis=0)
self.__geographic_xpts = xypts.T
return self.__geographic_xpts
def __init__(self, ax=None, model=None, modelgrid=None,
line=None, extent=None, geographic_coords=False):
super(_StructuredCrossSection, self).__init__(ax=ax, model=model,
modelgrid=modelgrid,
geographic_coords=
geographic_coords)
if line is None:
s = 'line must be specified.'
raise Exception(s)
linekeys = [linekeys.lower() for linekeys in list(line.keys())]
if len(linekeys) != 1:
s = 'only row, column, or line can be specified in line dictionary.\n'
s += 'keys specified: '
for k in linekeys:
s += '{} '.format(k)
raise AssertionError(s)
if ax is None:
self.ax = plt.gca()
else:
self.ax = ax
onkey = list(line.keys())[0]
eps = 1.e-4
xedge, yedge = self.mg.xyedges
self.__geographic_xpts = None
# un-translate model grid into model coordinates
self.xcellcenters, self.ycellcenters = \
geometry.transform(self.mg.xcellcenters,
self.mg.ycellcenters,
self.mg.xoffset, self.mg.yoffset,
self.mg.angrot_radians, inverse=True)
if 'row' in linekeys:
self.direction = 'x'
ycenter = self.ycellcenters.T[0]
pts = [(xedge[0] + eps,
ycenter[int(line[onkey])] - eps),
(xedge[-1] - eps,
ycenter[int(line[onkey])] + eps)]
elif 'column' in linekeys:
self.direction = 'y'
xcenter = self.xcellcenters[0, :]
pts = [(xcenter[int(line[onkey])] + eps,
yedge[0] - eps),
(xcenter[int(line[onkey])] - eps,
yedge[-1] + eps)]
else:
self.direction = 'xy'
verts = line[onkey]
xp = []
yp = []
for [v1, v2] in verts:
xp.append(v1)
yp.append(v2)
xp, yp = self.mg.get_local_coords(xp, yp)
pts = [(xt, yt) for xt, yt in zip(xp, yp)]
# for now set offset to zero, since we do not have
# information on projection from the user
# convert pts list to numpy array
self.pts = np.array(pts)
# get points along the line
self.xpts = plotutil.line_intersect_grid(self.pts, self.mg.xyedges[0],
self.mg.xyedges[1])
if len(self.xpts) < 2:
s = 'cross-section cannot be created\n.'
s += ' less than 2 points intersect the model grid\n'
s += ' {} points intersect the grid.'.format(len(self.xpts))
raise Exception(s)
# set horizontal distance
d = []
for v in self.xpts:
d.append(v[2])
self.d = np.array(d)
self.idomain = self.mg.idomain
if self.mg.idomain is None:
self.idomain = np.ones((self.mg.nlay, self.mg.nrow,
self.mg.ncol), dtype=int)
self.ncb = 0
self.laycbd = []
if self.model is not None:
if self.model.laycbd is not None:
self.laycbd = self.model.laycbd
for l in self.laycbd:
if l > 0:
self.ncb += 1
self.active = np.ones((self.mg.nlay + self.ncb), dtype=np.int)
kon = 0
if len(self.laycbd) > 0:
for k in range(self.mg.nlay):
if self.laycbd[k] > 0:
kon += 1
self.active[kon] = 0
kon += 1
top = self.mg.top
botm = self.mg.botm
elev = [top.copy()]
for k in range(self.mg.nlay + self.ncb):
elev.append(botm[k, :, :])
self.elev = np.array(elev)
self.layer0 = 0
self.layer1 = self.mg.nlay + self.ncb + 1
zpts = []
for k in range(self.layer0, self.layer1):
zpts.append(plotutil.cell_value_points(self.xpts, self.mg.xyedges[0],
self.mg.xyedges[1],
self.elev[k, :, :]))
self.zpts = np.array(zpts)
xcentergrid, zcentergrid = self.get_centergrids(self.xpts, self.zpts)
self.xcentergrid = xcentergrid
self.zcentergrid = zcentergrid
geo_xcentergrid, _ = self.get_centergrids(self.geographic_xpts,
self.zpts)
self.geographic_xcentergrid = geo_xcentergrid
# Create cross-section extent
if extent is None:
self.extent = self.get_extent()
else:
self.extent = extent
# Set axis limits
self.ax.set_xlim(self.extent[0], self.extent[1])
self.ax.set_ylim(self.extent[2], self.extent[3])
return
def __init__(self, ax=None, model=None, modelgrid=None,
line=None, extent=None):
super(_StructuredCrossSection, self).__init__(ax=ax, model=model,
modelgrid=modelgrid)
if line is None:
s = 'line must be specified.'
raise Exception(s)
linekeys = [linekeys.lower() for linekeys in list(line.keys())]
if len(linekeys) != 1:
s = 'only row, column, or line can be specified in line dictionary.\n'
s += 'keys specified: '
for k in linekeys:
s += '{} '.format(k)
raise AssertionError(s)
if ax is None:
self.ax = plt.gca()
else:
self.ax = ax
onkey = list(line.keys())[0]
eps = 1.e-4
xedge, yedge = self.mg.xyedges
# un-translate model grid into model coordinates
self.xcellcenters, self.ycellcenters = \
geometry.transform(self.mg.xcellcenters,
self.mg.ycellcenters,
self.mg.xoffset, self.mg.yoffset,
self.mg.angrot_radians, inverse=True)
if 'row' in linekeys:
self.direction = 'x'
ycenter = self.ycellcenters.T[0]
pts = [(xedge[0] + eps,
ycenter[int(line[onkey])] - eps),
(xedge[-1] - eps,
ycenter[int(line[onkey])] + eps)]
elif 'column' in linekeys:
self.direction = 'y'
xcenter = self.xcellcenters[0, :]
pts = [(xcenter[int(line[onkey])] + eps,
yedge[0] - eps),
(xcenter[int(line[onkey])] - eps,
yedge[-1] + eps)]
else:
self.direction = 'xy'
verts = line[onkey]
xp = []
yp = []
for [v1, v2] in verts:
xp.append(v1)
yp.append(v2)
xp, yp = self.mg.get_local_coords(xp, yp)
pts = [(xt, yt) for xt, yt in zip(xp, yp)]
# convert pts list to numpy array
self.pts = np.array(pts)
# get points along the line
self.xpts = plotutil.line_intersect_grid(self.pts, self.mg.xyedges[0],
self.mg.xyedges[1])
if len(self.xpts) < 2:
s = 'cross-section cannot be created\n.'
s += ' less than 2 points intersect the model grid\n'
s += ' {} points intersect the grid.'.format(len(self.xpts))
raise Exception(s)
# set horizontal distance
d = []
for v in self.xpts:
d.append(v[2])
self.d = np.array(d)
self.idomain = self.mg.idomain
if self.mg.idomain is None:
self.idomain = np.ones((self.mg.nlay, self.mg.nrow,
self.mg.ncol), dtype=int)
self.ncb = 0
self.laycbd = []
if self.model is not None:
if self.model.laycbd is not None:
self.laycbd = self.model.laycbd
for l in self.laycbd:
if l > 0:
self.ncb += 1
self.active = np.ones((self.mg.nlay + self.ncb), dtype=np.int)
kon = 0
if len(self.laycbd) > 0:
for k in range(self.mg.nlay):
if self.laycbd[k] > 0:
kon += 1
self.active[kon] = 0
kon += 1
top = self.mg.top
botm = self.mg.botm
elev = [top.copy()]
for k in range(self.mg.nlay + self.ncb):
elev.append(botm[k, :, :])
self.elev = np.array(elev)
self.layer0 = 0
self.layer1 = self.mg.nlay + self.ncb + 1
zpts = []
for k in range(self.layer0, self.layer1):
zpts.append(plotutil.cell_value_points(self.xpts, self.mg.xyedges[0],
self.mg.xyedges[1],
self.elev[k, :, :]))
self.zpts = np.array(zpts)
xcentergrid = []
zcentergrid = []
nz = 0
if self.mg.nlay == 1:
for k in range(0, self.zpts.shape[0]):
nz += 1
nx = 0
for i in range(0, self.xpts.shape[0], 2):
try:
xp = 0.5 * (self.xpts[i][2] + self.xpts[i + 1][2])
zp = self.zpts[k, i]
xcentergrid.append(xp)
zcentergrid.append(zp)
nx += 1
except:
break
else:
for k in range(0, self.zpts.shape[0] - 1):
nz += 1
nx = 0
for i in range(0, self.xpts.shape[0], 2):
try:
xp = 0.5 * (self.xpts[i][2] + self.xpts[i + 1][2])
zp = 0.5 * (self.zpts[k, i] + self.zpts[k + 1, i + 1])
xcentergrid.append(xp)
zcentergrid.append(zp)
nx += 1
except:
break
self.xcentergrid = np.array(xcentergrid).reshape((nz, nx))
self.zcentergrid = np.array(zcentergrid).reshape((nz, nx))
# Create cross-section extent
if extent is None:
self.extent = self.get_extent()
else:
self.extent = extent
# Set axis limits
self.ax.set_xlim(self.extent[0], self.extent[1])
self.ax.set_ylim(self.extent[2], self.extent[3])
return
def __init__(self, ax=None, model=None, modelgrid=None,
line=None, extent=None, geographic_coords=False):
super(_VertexCrossSection, self).__init__(ax=ax, model=model,
modelgrid=modelgrid,
geographic_coords=
geographic_coords)
if line is None:
err_msg = 'line must be specified.'
raise Exception(err_msg)
linekeys = [linekeys.lower() for linekeys in list(line.keys())]
if len(linekeys) != 1:
err_msg = 'Either row, column, or line must be specified ' \
'in line dictionary.\nkeys specified: '
for k in linekeys:
err_msg += '{} '.format(k)
raise Exception(err_msg)
elif "line" not in linekeys:
err_msg = "only line can be specified in line dictionary " \
"for vertex Discretization"
raise AssertionError(err_msg)
onkey = linekeys[0]
if ax is None:
self.ax = plt.gca()
else:
self.ax = ax
self.direction = "xy"
# convert pts list to a numpy array
verts = line[onkey]
xp = []
yp = []
for [v1, v2] in verts:
xp.append(v1)
yp.append(v2)
# unrotate and untransform modelgrid into modflow coordinates!
xp, yp = geometry.transform(xp, yp,
self.mg.xoffset,
self.mg.yoffset,
self.mg.angrot_radians,
inverse=True)
self.xcellcenters, self.ycellcenters = \
geometry.transform(self.mg.xcellcenters,
self.mg.ycellcenters,
self.mg.xoffset, self.mg.yoffset,
self.mg.angrot_radians, inverse=True)
try:
self.xvertices, self.yvertices = \
geometry.transform(self.mg.xvertices,
self.mg.yvertices,
self.mg.xoffset, self.mg.yoffset,
self.mg.angrot_radians, inverse=True)
except ValueError:
# irregular shapes in vertex grid ie. squares and triangles
xverts, yverts = plotutil.UnstructuredPlotUtilities.\
irregular_shape_patch(self.mg.xvertices, self.mg.yvertices)
self.xvertices, self.yvertices = \
geometry.transform(xverts, yverts,
self.mg.xoffset,
self.mg.yoffset,
self.mg.angrot_radians, inverse=True)
pts = [(xt, yt) for xt, yt in zip(xp, yp)]
self.pts = np.array(pts)
# get points along the line
self.xypts = plotutil.UnstructuredPlotUtilities.\
line_intersect_grid(self.pts,
self.xvertices,
self.yvertices)
if len(self.xypts) < 2:
s = 'cross-section cannot be created\n.'
s += ' less than 2 points intersect the model grid\n'
s += ' {} points intersect the grid.'.format(len(self.xypts))
raise Exception(s)
if self.geographic_coords:
# transform back to geographic coordinates
xypts = {}
for nn, pt in self.xypts.items():
xp = [t[0] for t in pt]
yp = [t[1] for t in pt]
xp, yp = geometry.transform(xp, yp, self.mg.xoffset,
self.mg.yoffset,
self.mg.angrot_radians)
xypts[nn] = [(xt, yt) for xt, yt in zip(xp, yp)]
self.xypts = xypts
top = self.mg.top
top.shape = (1, -1)
botm = self.mg.botm
nlay = len(botm)
ncpl = self.mg.ncpl
elev = list(top.copy())
for k in range(nlay):
elev.append(botm[k, :])
self.elev = np.array(elev)
self.idomain = self.mg.idomain
if self.mg.idomain is None:
self.idomain = np.ones((nlay, ncpl), dtype=int)
# choose a projection direction based on maximum information
xpts = []
ypts = []
for nn, verts in self.xypts.items():
for v in verts:
xpts.append(v[0])
ypts.append(v[1])
if np.max(xpts) - np.min(xpts) > np.max(ypts) - np.min(ypts):
self.direction = "x"
else:
self.direction = "y"
# make vertex array based on projection direction
self.projpts = self.set_zpts(None)
# Create cross-section extent
if extent is None:
self.extent = self.get_extent()
else:
self.extent = extent
self.layer0 = None
self.layer1 = None
self.d = {i: (np.min(np.array(v).T[0]),
np.max(np.array(v).T[0])) for
i, v in sorted(self.projpts.items())}
self.xpts = None
self.active = None
self.ncb = None
self.laycbd = None
self.zpts = None
self.xcentergrid = None
self.zcentergrid = None
self.geographic_xcentergrid = None
self.geographic_xpts = None
# Set axis limits
self.ax.set_xlim(self.extent[0], self.extent[1])
self.ax.set_ylim(self.extent[2], self.extent[3])
def test_mg():
import flopy
from flopy.utils import geometry
Lx = 100.
Ly = 100.
nlay = 1
nrow = 51
ncol = 51
delr = Lx / ncol
delc = Ly / nrow
top = 0
botm = [-1]
ms = flopy.modflow.Modflow()
dis = flopy.modflow.ModflowDis(ms,
nlay=nlay,
nrow=nrow,
ncol=ncol,
delr=delr,
delc=delc,
top=top,
botm=botm)
bas = flopy.modflow.ModflowBas(ms, ifrefm=True)
# test instantiation of an empty basic Structured Grid
mg = flopy.discretization.StructuredGrid(dis.delc.array, dis.delr.array)
# test instantiation of Structured grid with offsets
mg = flopy.discretization.StructuredGrid(dis.delc.array,
dis.delr.array,
xoff=1,
yoff=1)
#txt = 'yul does not approximately equal 100 - ' + \
# '(xul, yul) = ({}, {})'.format( ms.sr.yul, ms.sr.yul)
assert abs(ms.modelgrid.extent[-1] - Ly) < 1e-3 #, txt
ms.modelgrid.set_coord_info(xoff=111, yoff=0)
assert ms.modelgrid.xoffset == 111
ms.modelgrid.set_coord_info()
xll, yll = 321., 123.
angrot = 20
ms.modelgrid = flopy.discretization.StructuredGrid(delc=ms.dis.delc.array,
delr=ms.dis.delr.array,
xoff=xll,
yoff=xll,
angrot=angrot,
lenuni=2)
# test that transform for arbitrary coordinates
# is working in same as transform for model grid
mg2 = flopy.discretization.StructuredGrid(delc=ms.dis.delc.array,
delr=ms.dis.delr.array,
lenuni=2)
x = mg2.xcellcenters[0]
y = mg2.ycellcenters[0]
mg2.set_coord_info(xoff=xll, yoff=yll, angrot=angrot)
xt, yt = geometry.transform(x, y, xll, yll, mg2.angrot_radians)
assert np.sum(xt - ms.modelgrid.xcellcenters[0]) < 1e-3
assert np.sum(yt - ms.modelgrid.ycellcenters[0]) < 1e-3
# test inverse transform
x0, y0 = 9.99, 2.49
x1, y1 = geometry.transform(x0, y0, xll, yll, angrot)
x2, y2 = geometry.transform(x1, y1, xll, yll, angrot, inverse=True)
assert np.abs(x2 - x0) < 1e-6
assert np.abs(y2 - y0) < 1e6
ms.start_datetime = "1-1-2016"
assert ms.start_datetime == "1-1-2016"
assert ms.dis.start_datetime == "1-1-2016"
ms.model_ws = tpth
ms.write_input()
ms1 = flopy.modflow.Modflow.load(ms.namefile, model_ws=ms.model_ws)
assert str(ms1.modelgrid) == str(ms.modelgrid)
assert ms1.start_datetime == ms.start_datetime
assert ms1.modelgrid.lenuni == ms.modelgrid.lenuni
def test_mg():
import flopy
from flopy.utils import geometry
Lx = 100.
Ly = 100.
nlay = 1
nrow = 51
ncol = 51
delr = Lx / ncol
delc = Ly / nrow
top = 0
botm = [-1]
ms = flopy.modflow.Modflow()
dis = flopy.modflow.ModflowDis(ms, nlay=nlay, nrow=nrow, ncol=ncol,
delr=delr, delc=delc, top=top, botm=botm)
bas = flopy.modflow.ModflowBas(ms, ifrefm=True)
# test instantiation of an empty basic Structured Grid
mg = flopy.discretization.StructuredGrid(dis.delc.array, dis.delr.array)
# test instantiation of Structured grid with offsets
mg = flopy.discretization.StructuredGrid(dis.delc.array, dis.delr.array,
xoff=1, yoff=1)
#txt = 'yul does not approximately equal 100 - ' + \
# '(xul, yul) = ({}, {})'.format( ms.sr.yul, ms.sr.yul)
assert abs(ms.modelgrid.extent[-1] - Ly) < 1e-3#, txt
ms.modelgrid.set_coord_info(xoff=111, yoff=0)
assert ms.modelgrid.xoffset == 111
ms.modelgrid.set_coord_info()
xll, yll = 321., 123.
angrot = 20
ms.modelgrid = flopy.discretization.StructuredGrid(delc=ms.dis.delc.array,
delr=ms.dis.delr.array,
xoff=xll, yoff=xll,
angrot=angrot,
lenuni=2)
# test that transform for arbitrary coordinates
# is working in same as transform for model grid
mg2 = flopy.discretization.StructuredGrid(delc=ms.dis.delc.array,
delr=ms.dis.delr.array,
lenuni=2)
x = mg2.xcellcenters[0]
y = mg2.ycellcenters[0]
mg2.set_coord_info(xoff=xll, yoff=yll, angrot=angrot)
xt, yt = geometry.transform(x, y, xll, yll, mg2.angrot_radians)
assert np.sum(xt - ms.modelgrid.xcellcenters[0]) < 1e-3
assert np.sum(yt - ms.modelgrid.ycellcenters[0]) < 1e-3
# test inverse transform
x0, y0 = 9.99, 2.49
x1, y1 = geometry.transform(x0, y0, xll, yll, angrot)
x2, y2 = geometry.transform(x1, y1, xll, yll, angrot, inverse=True)
assert np.abs(x2-x0) < 1e-6
assert np.abs(y2-y0) < 1e6
ms.start_datetime = "1-1-2016"
assert ms.start_datetime == "1-1-2016"
assert ms.dis.start_datetime == "1-1-2016"
ms.model_ws = tpth
ms.write_input()
ms1 = flopy.modflow.Modflow.load(ms.namefile, model_ws=ms.model_ws)
print(ms.modelgrid.lenuni)
print(ms1.modelgrid.lenuni)
assert str(ms1.modelgrid) == str(ms.modelgrid)
assert ms1.start_datetime == ms.start_datetime
assert ms1.modelgrid.lenuni == ms.modelgrid.lenuni