def delete_carray(self, carray):
"""Delete carray SWIG C pointer, return carray as None"""
logger.debug("Enter delete carray values method for %d", id(self))
if carray is None:
return None
if "int" in str(carray):
_cxtgeo.delete_intarray(carray)
carray = None
elif "float" in str(carray):
_cxtgeo.delete_floatarray(carray)
carray = None
elif "double" in str(carray):
_cxtgeo.delete_doublearray(carray)
carray = None
else:
raise RuntimeError("BUG?")
return carray
def _make_ijk_from_grid_v1(self, grid, grid_id=""):
"""
Getting IJK from a grid and make as well logs.
This is the first version, using _cxtgeo.grd3d_well_ijk from C
"""
logger.info("Using algorithm 1 in %s", __name__)
wxarr = self.get_carray("X_UTME")
wyarr = self.get_carray("Y_UTMN")
wzarr = self.get_carray("Z_TVDSS")
nlen = self.nrow
wivec = _cxtgeo.new_intarray(nlen)
wjvec = _cxtgeo.new_intarray(nlen)
wkvec = _cxtgeo.new_intarray(nlen)
onelayergrid = grid.copy()
onelayergrid.reduce_to_one_layer()
cstatus = _cxtgeo.grd3d_well_ijk(
grid.ncol,
grid.nrow,
grid.nlay,
grid._coordsv,
grid._zcornsv,
grid._actnumsv,
onelayergrid._zcornsv,
onelayergrid._actnumsv,
self.nrow,
wxarr,
wyarr,
wzarr,
wivec,
wjvec,
wkvec,
0,
)
if cstatus != 0:
raise RuntimeError("Error from C routine, code is {}".format(cstatus))
indarray = _cxtgeo.swig_carr_to_numpy_i1d(nlen, wivec).astype("float")
jndarray = _cxtgeo.swig_carr_to_numpy_i1d(nlen, wjvec).astype("float")
kndarray = _cxtgeo.swig_carr_to_numpy_i1d(nlen, wkvec).astype("float")
indarray[indarray == 0] = np.nan
jndarray[jndarray == 0] = np.nan
kndarray[kndarray == 0] = np.nan
icellname = "ICELL" + grid_id
jcellname = "JCELL" + grid_id
kcellname = "KCELL" + grid_id
self._df[icellname] = indarray
self._df[jcellname] = jndarray
self._df[kcellname] = kndarray
for cellname in [icellname, jcellname, kcellname]:
self._wlogtype[cellname] = "DISC"
self._wlogrecord[icellname] = {
ncel: str(ncel)
for ncel in range(1, grid.ncol + 1)
}
self._wlogrecord[jcellname] = {
ncel: str(ncel)
for ncel in range(1, grid.nrow + 1)
}
self._wlogrecord[kcellname] = {
ncel: str(ncel)
for ncel in range(1, grid.nlay + 1)
}
_cxtgeo.delete_intarray(wivec)
_cxtgeo.delete_intarray(wjvec)
_cxtgeo.delete_intarray(wkvec)
_cxtgeo.delete_doublearray(wxarr)
_cxtgeo.delete_doublearray(wyarr)
_cxtgeo.delete_doublearray(wzarr)
del onelayergrid
def geometrics(self):
"""Compute some well geometrical arrays MD, INCL, AZI, as logs.
These are kind of quasi measurements hence the logs will named
with a Q in front as Q_MDEPTH, Q_INCL, and Q_AZI.
These logs will be added to the dataframe. If the mdlogname
attribute does not exist in advance, it will be set to 'Q_MDEPTH'.
Returns:
False if geometrics cannot be computed
"""
if self._df.size < 3:
logger.warning(
"Cannot compute geometrics for %s. Too few "
"trajectory points",
self.name,
)
return False
# extract numpies from XYZ trajetory logs
ptr_xv = self.get_carray("X_UTME")
ptr_yv = self.get_carray("Y_UTMN")
ptr_zv = self.get_carray("Z_TVDSS")
# get number of rows in pandas
nlen = self.nrow
ptr_md = _cxtgeo.new_doublearray(nlen)
ptr_incl = _cxtgeo.new_doublearray(nlen)
ptr_az = _cxtgeo.new_doublearray(nlen)
ier = _cxtgeo.well_geometrics(
nlen,
ptr_xv,
ptr_yv,
ptr_zv,
ptr_md,
ptr_incl,
ptr_az,
0,
)
if ier != 0:
sys.exit(-9)
dnumpy = self._convert_carr_double_np(ptr_md)
self._df["Q_MDEPTH"] = pd.Series(dnumpy, index=self._df.index)
dnumpy = self._convert_carr_double_np(ptr_incl)
self._df["Q_INCL"] = pd.Series(dnumpy, index=self._df.index)
dnumpy = self._convert_carr_double_np(ptr_az)
self._df["Q_AZI"] = pd.Series(dnumpy, index=self._df.index)
if not self._mdlogname:
self._mdlogname = "Q_MDEPTH"
# delete tmp pointers
_cxtgeo.delete_doublearray(ptr_xv)
_cxtgeo.delete_doublearray(ptr_yv)
_cxtgeo.delete_doublearray(ptr_zv)
_cxtgeo.delete_doublearray(ptr_md)
_cxtgeo.delete_doublearray(ptr_incl)
_cxtgeo.delete_doublearray(ptr_az)
return True
def _convert_to_xtgeo_grid(self, rox, roxgrid, corners):
"""Convert from RMS API to XTGeo API"""
# pylint: disable=too-many-statements
logger.info("Converting to XTGeo internals...")
logger.info("Call the ROXAPI grid indexer")
indexer = roxgrid.grid_indexer
ncol, nrow, nlay = indexer.dimensions
ntot = ncol * nrow * nlay
# update other attributes
self._ncol = ncol
self._nrow = nrow
self._nlay = nlay
if corners is None:
logger.info("Asked for dimensions_only: No geometry read!")
return
logger.info("Get active cells")
mybuffer = np.ndarray(indexer.dimensions, dtype=np.int32)
mybuffer.fill(0)
logger.info("Get cell numbers")
cellno = indexer.get_cell_numbers_in_range((0, 0, 0), indexer.dimensions)
logger.info("Reorder...")
ijk = indexer.get_indices(cellno)
iind = ijk[:, 0]
jind = ijk[:, 1]
kind = ijk[:, 2]
pvalues = np.ones(len(cellno))
pvalues[cellno] = 1
mybuffer[iind, jind, kind] = pvalues[cellno]
actnum = mybuffer
if rox.version_required("1.3"):
logger.info("Handedness (new) %s", indexer.ijk_handedness)
else:
logger.info("Handedness (old) %s", indexer.handedness)
corners = corners.ravel(order="K")
actnum = actnum.ravel(order="K")
logger.info("Convert to C pointers...")
nnum = ncol * nrow * nlay * 24
ccorners = _cxtgeo.new_doublearray(nnum)
ntot = ncol * nrow * nlay
cactnum = _cxtgeo.new_intarray(ntot)
ncoord = (ncol + 1) * (nrow + 1) * 2 * 3
nzcorn = ncol * nrow * (nlay + 1) * 4
self._p_coord_v = _cxtgeo.new_doublearray(ncoord)
self._p_zcorn_v = _cxtgeo.new_doublearray(nzcorn)
self._p_actnum_v = _cxtgeo.new_intarray(ntot)
_cxtgeo.swig_numpy_to_carr_1d(corners, ccorners)
_cxtgeo.swig_numpy_to_carr_i1d(actnum, cactnum)
# next task is to convert geometry to cxtgeo internal format
logger.info("Run XTGeo C code...")
_cxtgeo.grd3d_conv_roxapi_grid(
ncol,
nrow,
nlay,
ntot,
cactnum,
ccorners,
self._p_coord_v,
self._p_zcorn_v,
self._p_actnum_v,
XTGDEBUG,
)
logger.info("Run XTGeo C code... done")
_cxtgeo.delete_doublearray(ccorners)
_cxtgeo.delete_intarray(cactnum)
logger.info("Converting to XTGeo internals... done")
# subgrids
if len(indexer.zonation) > 1:
logger.debug("Zonation length (N subzones) is %s",
len(indexer.zonation))
subz = OrderedDict()
for inum, zrange in indexer.zonation.items():
logger.debug("inum: %s, zrange: %s", inum, zrange)
zname = roxgrid.zone_names[inum]
logger.debug("zname is: %s", zname)
zra = [nn + 1 for ira in zrange for nn in ira] # nested lists
subz[zname] = zra
self.subgrids = subz