def _import_ecl_output_v2_init(self, pfile, names, grid, strict):
"""Import INIT parameters"""
# scan valid keywords
kwlist = utils.scan_keywords(pfile,
fformat="xecl",
maxkeys=100000,
dataframe=True,
dates=True)
validnames = list()
nact = grid.nactive
ntot = grid.ntotal
if grid.dualporo:
nact *= 2
ntot *= 2
# get a list of valid property names
for kw in list(kwlist.itertuples(index=False, name=None)):
kwname, _, nlen, _, _ = kw
if nlen in (nact, ntot) and kwname not in validnames:
validnames.append(kwname)
if names == "all":
usenames = deepcopy(validnames)
else:
usenames = list(names)
for name in usenames:
if name not in validnames:
if strict:
msg = f"Requested keyword {name} is not in INIT file, but will try,"
msg += f"valid entries are {validnames}"
logger.warning(msg)
raise ValueError(msg)
else:
msg = f"Requested keyword {name} is not in INIT file."
msg += "Will skip trying to read due to keyword <strict> settings."
logger.warning(msg)
continue
prop = GridProperty()
# use a private GridProperty function, since filehandle
_gridprop_import_eclrun.import_eclbinary(
prop,
pfile,
name=name,
grid=grid,
etype=1,
_kwlist=kwlist,
)
self._names.append(name)
self._props.append(prop)
self._ncol = grid.ncol
self._nrow = grid.nrow
self._nlay = grid.nlay
def import_ecl_output(props,
pfile,
names=None,
dates=None,
grid=None,
namestyle=0): # pylint: disable=too-many-locals, too-many-branches, too-many-statements
logger.debug("'namestyle' is %s (not in use)", namestyle)
if not grid:
raise ValueError("Grid Geometry object is missing")
if not names:
raise ValueError("Name list is empty (None)")
local_fhandle = False
fhandle = pfile
if not isinstance(pfile, xtgeo._XTGeoCFile):
pfile = xtgeo._XTGeoCFile(pfile)
fhandle = pfile.fhandle
local_fhandle = True
# scan valid keywords
kwlist = utils.scan_keywords(fhandle,
fformat="xecl",
maxkeys=100000,
dataframe=True,
dates=True)
kwxlist = list(kwlist.itertuples(index=False, name=None))
usenames = list()
if names == "all":
nact = grid.nactive
ntot = grid.ntotal
for kw in kwxlist:
kwname, _tmp1, nlen, _bs, _date = kw
if nlen in (nact, ntot):
usenames.append(kwname)
else:
usenames = list(names)
logger.info("NAMES are %s", usenames)
lookfornames = list(set(usenames))
possiblekw = []
for name in lookfornames:
namefound = False
for kwitem in kwxlist:
possiblekw.append(kwitem[0])
if name == kwitem[0]:
namefound = True
if not namefound:
if name in ("SOIL", "SGAS", "SWAT"):
pass # check for sat's later; may be derived based on fluid system
else:
raise ValueError(
"Keyword {} not found. Possible list: {}".format(
name, possiblekw))
# check valid dates, and remove invalid entries (allowing that user
# can be a bit sloppy on DATES)
validdates = [None]
if dates:
dlist = utils.scan_dates(fhandle)
validdates = []
alldates = []
for date in dates:
for ditem in dlist:
alldates.append(str(ditem[1]))
if str(date) == str(ditem[1]):
validdates.append(date)
if not validdates:
msg = "No valid dates given (dates: {} vs {})".format(
dates, alldates)
xtg.error(msg)
raise ValueError(msg)
if len(dates) > len(validdates):
invalidddates = list(set(dates).difference(validdates))
msg = ("In file {}: Some dates not found: {}, but will continue "
"with dates: {}".format(pfile, invalidddates, validdates))
xtg.warn(msg)
# raise DateNotFoundError(msg)
use2names = list(usenames) # to make copy
logger.info("Use names: %s", use2names)
logger.info("Valid dates: %s", validdates)
# now import each property
firstproperty = True
for date in validdates:
# xprop = dict()
# soil_ok = False
for name in use2names:
logger.info("Get %s", name)
if date is None:
date = None
propname = name
etype = 1
else:
propname = name + "_" + str(date)
etype = 5
prop = GridProperty()
# use a private GridProperty function here, for convinience
# (since filehandle)
_gridprop_import_eclrun.import_eclbinary(
prop,
fhandle,
name=name,
date=date,
grid=grid,
etype=etype,
_kwlist=kwlist,
)
if firstproperty:
ncol = prop.ncol
nrow = prop.nrow
nlay = prop.nlay
firstproperty = False
logger.info("Appended property %s", propname)
props._names.append(propname)
props._props.append(prop)
props._ncol = ncol
props._nrow = nrow
props._nlay = nlay
if validdates[0] != 0:
props._dates = validdates
if local_fhandle:
pfile.close()
def _import_ecl_output_v2_rsta(self, pfile, names, dates, grid, strictkeycomb,
strictdate, namestyle):
"""Import RESTART parameters"""
if isinstance(dates, list):
# dates may come on form 2020-12-22 or 20201222; process all to latter fmt
dates = [str(thedate).replace("-", "") for thedate in dates]
# scan valid keywords with dates
kwlist = utils.scan_keywords(pfile,
fformat="xecl",
maxkeys=100000,
dataframe=True,
dates=True)
validnamedatepairs, validdates = _process_valid_namesdates(kwlist, grid)
# allow sloppy dates, i.e. remove invalid date entries
if isinstance(dates, list) and strictdate is False:
dates = _process_sloppydates(dates, validdates)
usenamedatepairs = list()
if names == "all" and dates == "all":
usenamedatepairs = deepcopy(validnamedatepairs)
usedates = dates
else:
if names == "all" and dates != "all":
usenames = [namedate[0] for namedate in validnamedatepairs]
usedates = dates
elif names != "all" and dates == "all":
usedates = [namedate[1] for namedate in validnamedatepairs]
usenames = names
else:
usedates = dates
usenames = names
for name in usenames:
for date in usedates:
usenamedatepairs.append((name, date))
# Do the actual import
for namedate in usenamedatepairs:
name, date = namedate
skipentry = False
if name not in ("SGAS", "SOIL",
"SWAT") and namedate not in validnamedatepairs:
# saturation keywords are a mess in Eclipse and friends; check later
if strictkeycomb:
msg = f"Keyword data combo {name} {date} is not in RESTART file."
msg += f"Possible entries are: {validnamedatepairs}"
msg += "Will still try to import..."
logger.warning(msg)
else:
msg = f"Keyword data combo {name} {date} is not in RESTART file."
msg += f"Possible entries are: {validnamedatepairs}"
msg += "Will skip attempt to import and just continue..."
logger.warning(msg)
skipentry = True
if skipentry:
continue
prop = GridProperty()
usename = name + "_" + str(date)
if namestyle == 1:
sdate = str(date)
usename = name + "--" + sdate[0:4] + "_" + sdate[
4:6] + "_" + sdate[6:8]
# use a private GridProperty function, since filehandle
_gridprop_import_eclrun.import_eclbinary(
prop,
pfile,
name=name,
date=date,
grid=grid,
etype=5,
_kwlist=kwlist,
)
self._names.append(usename)
self._props.append(prop)
self._dates.append(date)
self._ncol = grid.ncol
self._nrow = grid.nrow
self._nlay = grid.nlay