def _export_roff_discrete(self,
pfile,
name,
append=False,
last=True,
binary=True):
carray = _gridprop_lowlevel.update_carray(self, undef=-999)
ptr_idum = _cxtgeo.new_intpointer()
ptr_ddum = _cxtgeo.new_doublepointer()
# codes:
ptr_codes = _cxtgeo.new_intarray(256)
ncodes = self.ncodes
codenames = ""
logger.info("Keys: %s", self.codes.keys())
for inum, ckey in enumerate(sorted(self.codes.keys())):
if ckey is not None:
codenames += str(self.codes[ckey])
codenames += "|"
_cxtgeo.intarray_setitem(ptr_codes, inum, int(ckey))
else:
logger.warning("For some odd reason, None is a key. Check!")
mode = 0
if not binary:
mode = 1
if not append:
_cxtgeo.grd3d_export_roff_pstart(mode, self._ncol, self._nrow,
self._nlay, pfile, XTGDEBUG)
nsub = 0
isub_to_export = 0
_cxtgeo.grd3d_export_roff_prop(
mode,
self._ncol,
self._nrow,
self._nlay,
nsub,
isub_to_export,
ptr_idum,
name,
"int",
carray,
ptr_ddum,
ncodes,
codenames,
ptr_codes,
pfile,
XTGDEBUG,
)
if last:
_cxtgeo.grd3d_export_roff_end(mode, pfile, XTGDEBUG)
_gridprop_lowlevel.delete_carray(self, carray)
def get_randomline(
self,
fencespec,
prop,
zmin=None,
zmax=None,
zincrement=1.0,
hincrement=None,
atleast=5,
nextend=2,
):
logger.info("Enter get_randomline from Grid...")
_update_tmpvars(self)
if hincrement is None and isinstance(fencespec, xtgeo.Polygons):
logger.info("Estimate hincrement from Polygons instance...")
fencespec = _get_randomline_fence(self, fencespec, hincrement, atleast,
nextend)
logger.info("Estimate hincrement from Polygons instance... DONE")
logger.info("Get property...")
if isinstance(prop, str):
prop = self.get_prop_by_name(prop)
xcoords = fencespec[:, 0]
ycoords = fencespec[:, 1]
hcoords = fencespec[:, 3]
if zmin is None:
zmin = self._tmp["topd"].values.min()
if zmax is None:
zmax = self._tmp["basd"].values.max()
nzsam = int((zmax - zmin) / float(zincrement)) + 1
nsamples = xcoords.shape[0] * nzsam
logger.info("Running C routine to get randomline...")
_ier, values = _cxtgeo.grd3d_get_randomline(
xcoords, ycoords, zmin, zmax, nzsam, self._tmp["topd"].ncol,
self._tmp["topd"].nrow, self._tmp["topd"].xori, self._tmp["topd"].yori,
self._tmp["topd"].xinc, self._tmp["topd"].yinc,
self._tmp["topd"].rotation, self._tmp["topd"].yflip,
self._tmp["topi_carr"], self._tmp["topj_carr"], self._tmp["basi_carr"],
self._tmp["basj_carr"], self.ncol, self.nrow, self.nlay,
self._p_coord_v, self._p_zcorn_v, self._p_actnum_v,
gl.update_carray(prop), self._tmp["onegrid"]._p_zcorn_v,
self._tmp["onegrid"]._p_actnum_v, nsamples, 0, XTGDEBUG)
logger.info("Running C routine to get randomline... DONE")
values[values > xtgeo.UNDEF_LIMIT] = np.nan
arr = values.reshape((xcoords.shape[0], nzsam)).T
logger.info("Getting randomline... DONE")
return (hcoords[0], hcoords[-1], zmin, zmax, arr)
def export_grdecl(self, pfile, name, append=False, binary=False, dtype=None):
logger.info("Exporting %s to file %s, GRDECL format", name, pfile)
if dtype is None:
if self._isdiscrete:
dtype = "int32"
else:
dtype = "float32"
carray = _gridprop_lowlevel.update_carray(self, dtype=dtype)
iarr = _cxtgeo.new_intpointer()
farr = _cxtgeo.new_floatpointer()
darr = _cxtgeo.new_doublepointer()
if "double" in str(carray):
ptype = 3
darr = carray
elif "float" in str(carray):
ptype = 2
farr = carray
else:
ptype = 1
iarr = carray
mode = 0
if not binary:
mode = 1
appendmode = 0
if append:
appendmode = 1
_cxtgeo.grd3d_export_grdeclprop2(
self._ncol,
self._nrow,
self._nlay,
ptype,
iarr,
farr,
darr,
self.name,
pfile,
mode,
appendmode,
XTGDEBUG,
)
_gridprop_lowlevel.delete_carray(self, carray)
def slice_grid3d(self, grid, prop, zsurf=None, sbuffer=1):
"""Private function for the Grid3D slicing."""
if zsurf is not None:
other = zsurf
else:
logger.info('The current surface is copied as "other"')
other = self.copy()
if not self.compare_topology(other, strict=False):
raise RuntimeError("Topology of maps differ. Stop!")
zslice = other.copy()
nsurf = self.ncol * self.nrow
p_prop = _gridprop_lowlevel.update_carray(prop, discrete=False)
istat, updatedval = _cxtgeo.surf_slice_grd3d(
self.ncol,
self.nrow,
self.xori,
self.xinc,
self.yori,
self.yinc,
self.rotation,
self.yflip,
zslice.get_values1d(),
nsurf,
grid.ncol,
grid.nrow,
grid.nlay,
grid._p_coord_v,
grid._p_zcorn_v,
grid._p_actnum_v,
p_prop,
sbuffer,
0,
XTGDEBUG,
)
if istat != 0:
logger.warning("Problem, ISTAT = %s", istat)
self.set_values1d(updatedval)
return istat
def _export_roff_continuous(self,
pfile,
name,
append=False,
last=True,
binary=True):
carray = _gridprop_lowlevel.update_carray(self, undef=-999.0)
ptr_idum = _cxtgeo.new_intpointer()
mode = 0
if not binary:
mode = 1
if not append:
_cxtgeo.grd3d_export_roff_pstart(mode, self._ncol, self._nrow,
self._nlay, pfile, XTGDEBUG)
# now the actual data
nsub = 0
isub_to_export = 0
_cxtgeo.grd3d_export_roff_prop(
mode,
self._ncol,
self._nrow,
self._nlay,
nsub,
isub_to_export,
ptr_idum,
name,
"double",
ptr_idum,
carray,
0,
"",
ptr_idum,
pfile,
XTGDEBUG,
)
if last:
_cxtgeo.grd3d_export_roff_end(mode, pfile, XTGDEBUG)
_gridprop_lowlevel.delete_carray(self, carray)
def operation_polygons(self, poly, value, opname="add", inside=True):
"""A generic function for doing operations restricted to inside
or outside polygon(s).
"""
grid = self.geometry
if not isinstance(poly, xtgeo.xyz.Polygons):
raise ValueError("The poly input is not a Polygons instance")
# make a copy of the RegularSurface which is used a "filter" or "proxy"
# value will be 1 inside polygons, 0 outside. Undef cells are kept as is
proxy = self.copy()
proxy.values *= 0.0
cvals = gl.update_carray(proxy)
idgroups = poly.dataframe.groupby(poly.pname)
for id_, grp in idgroups:
xcor = grp[poly.xname].values
ycor = grp[poly.yname].values
ier = _cxtgeo.grd3d_setval_poly(
xcor,
ycor,
self.ncol,
self.nrow,
self.nlay,
grid._p_coord_v,
grid._p_zcorn_v,
grid._p_actnum_v,
cvals,
1,
0,
XTGDEBUG,
)
if ier == -9:
print("## Polygon no {} is not closed".format(id_ + 1))
gl.update_values_from_carray(proxy, cvals, np.float64, delete=True)
proxyv = proxy.values.astype(np.int8)
proxytarget = 1
if not inside:
proxytarget = 0
if opname == "add":
tmp = self.values.copy() + value
elif opname == "sub":
tmp = self.values.copy() - value
elif opname == "mul":
tmp = self.values.copy() * value
elif opname == "div":
# Dividing a map of zero is always a hazzle; try to obtain 0.0
# as result in these cases
if 0.0 in value:
xtg.warn("Dividing a surface with value or surface with zero "
"elements; may get unexpected results, try to "
"achieve zero values as result!")
with np.errstate(divide="ignore", invalid="ignore"):
this = np.ma.filled(self.values, fill_value=1.0)
that = np.ma.filled(value, fill_value=1.0)
mask = np.ma.getmaskarray(self.values)
tmp = np.true_divide(this, that)
tmp = np.where(np.isinf(tmp), 0, tmp)
tmp = np.nan_to_num(tmp)
tmp = np.ma.array(tmp, mask=mask)
elif opname == "set":
tmp = self.values.copy() * 0 + value
self.values[proxyv == proxytarget] = tmp[proxyv == proxytarget]
del tmp
def make_hybridgrid(grid, **kwargs):
"""Make hybrid grid.
It changes the grid geometry status of the object.
Input:
grid (object): A grid object
TODO region (object): A region parameter (property object)
etc...
"""
nhdiv = kwargs.get("nhdiv")
toplevel = kwargs.get("toplevel")
bottomlevel = kwargs.get("bottomlevel")
region = kwargs.get("region", None)
region_number = kwargs.get("region_number", None)
logger.debug("nhdiv: %s", nhdiv)
logger.debug("toplevel: %s", toplevel)
logger.debug("bottomlevel: %s", bottomlevel)
logger.debug("region: %s", region)
logger.debug("region_number: %s", region_number)
xtg_verbose_level = xtg.syslevel
newnlay = grid.nlay * 2 + nhdiv
hyb_num_act = _cxtgeo.new_intpointer()
hyb_p_zcorn_v = _cxtgeo.new_doublearray(grid.ncol * grid.nrow *
(newnlay + 1) * 4)
hyb_p_actnum_v = _cxtgeo.new_intarray(grid.ncol * grid.nrow * newnlay)
if region is None:
_cxtgeo.grd3d_convert_hybrid(
grid.ncol,
grid.nrow,
grid.nlay,
grid._p_coord_v,
grid._p_zcorn_v,
grid._p_actnum_v,
newnlay,
hyb_p_zcorn_v,
hyb_p_actnum_v,
hyb_num_act,
toplevel,
bottomlevel,
nhdiv,
xtg_verbose_level,
)
else:
region.discrete_to_continuous()
carray_reg = _gridprop_lowlevel.update_carray(region)
_cxtgeo.grd3d_convert_hybrid2(
grid.ncol,
grid.nrow,
grid.nlay,
grid._p_coord_v,
grid._p_zcorn_v,
grid._p_actnum_v,
newnlay,
hyb_p_zcorn_v,
hyb_p_actnum_v,
hyb_num_act,
toplevel,
bottomlevel,
nhdiv,
carray_reg,
region_number,
xtg_verbose_level,
)
_gridprop_lowlevel.delete_carray(region, carray_reg)
grid._nlay = newnlay
grid._p_zcorn_v = hyb_p_zcorn_v
grid._p_actnum_v = hyb_p_actnum_v
return grid
