RawKeywordPtr Parser::createRawKeyword(const DeckConstPtr deck, const std::string& filename , size_t lineNR , const std::string& keywordString, bool strictParsing) const {
if (hasKeyword(keywordString)) {
ParserKeywordConstPtr parserKeyword = m_parserKeywords.find(keywordString)->second;
ParserKeywordActionEnum action = parserKeyword->getAction();
if (action == THROW_EXCEPTION)
throw std::invalid_argument("Parsing terminated by fatal keyword: " + keywordString);
if (parserKeyword->getSizeType() == SLASH_TERMINATED)
return RawKeywordPtr(new RawKeyword(keywordString , filename , lineNR));
else {
size_t targetSize;
if (parserKeyword->hasFixedSize())
targetSize = parserKeyword->getFixedSize();
else {
const std::pair<std::string, std::string> sizeKeyword = parserKeyword->getSizeDefinitionPair();
DeckKeywordConstPtr sizeDefinitionKeyword = deck->getKeyword(sizeKeyword.first);
DeckItemConstPtr sizeDefinitionItem;
{
DeckRecordConstPtr record = sizeDefinitionKeyword->getRecord(0);
sizeDefinitionItem = record->getItem(sizeKeyword.second);
}
targetSize = sizeDefinitionItem->getInt(0);
}
return RawKeywordPtr(new RawKeyword(keywordString, filename , lineNR , targetSize , parserKeyword->isTableCollection()));
}
} else {
if (strictParsing) {
throw std::invalid_argument("Keyword " + keywordString + " not recognized ");
} else {
return RawKeywordPtr(new RawKeyword(keywordString, filename , lineNR , 0));
}
}
}
/// set the tables which specify the temperature dependence of the water viscosity
void initFromDeck(std::shared_ptr<const PvtInterface> isothermalPvt,
Opm::DeckConstPtr deck,
Opm::EclipseStateConstPtr eclipseState)
{
isothermalPvt_ = isothermalPvt;
watvisctTables_ = 0;
// stuff which we need to get from the PVTW keyword
Opm::DeckKeywordConstPtr pvtwKeyword = deck->getKeyword("PVTW");
int numRegions = pvtwKeyword->size();
pvtwRefPress_.resize(numRegions);
pvtwRefB_.resize(numRegions);
pvtwCompressibility_.resize(numRegions);
pvtwViscosity_.resize(numRegions);
pvtwViscosibility_.resize(numRegions);
for (int regionIdx = 0; regionIdx < numRegions; ++ regionIdx) {
Opm::DeckRecordConstPtr pvtwRecord = pvtwKeyword->getRecord(regionIdx);
pvtwRefPress_[regionIdx] = pvtwRecord->getItem("P_REF")->getSIDouble(0);
pvtwRefB_[regionIdx] = pvtwRecord->getItem("WATER_VOL_FACTOR")->getSIDouble(0);
pvtwViscosity_[regionIdx] = pvtwRecord->getItem("WATER_VISCOSITY")->getSIDouble(0);
pvtwViscosibility_[regionIdx] = pvtwRecord->getItem("WATER_VISCOSIBILITY")->getSIDouble(0);
}
// quantities required for the temperature dependence of the viscosity
// (basically we expect well-behaved VISCREF and WATVISCT keywords.)
if (deck->hasKeyword("VISCREF")) {
watvisctTables_ = &eclipseState->getWatvisctTables();
Opm::DeckKeywordConstPtr viscrefKeyword = deck->getKeyword("VISCREF");
assert(int(watvisctTables_->size()) == numRegions);
assert(int(viscrefKeyword->size()) == numRegions);
viscrefPress_.resize(numRegions);
for (int regionIdx = 0; regionIdx < numRegions; ++ regionIdx) {
Opm::DeckRecordConstPtr viscrefRecord = viscrefKeyword->getRecord(regionIdx);
viscrefPress_[regionIdx] = viscrefRecord->getItem("REFERENCE_PRESSURE")->getSIDouble(0);
}
}
// quantities required for the temperature dependence of the density
if (deck->hasKeyword("WATDENT")) {
DeckKeywordConstPtr watdentKeyword = deck->getKeyword("WATDENT");
assert(int(watdentKeyword->size()) == numRegions);
watdentRefTemp_.resize(numRegions);
watdentCT1_.resize(numRegions);
watdentCT2_.resize(numRegions);
for (int regionIdx = 0; regionIdx < numRegions; ++regionIdx) {
Opm::DeckRecordConstPtr watdentRecord = watdentKeyword->getRecord(regionIdx);
watdentRefTemp_[regionIdx] = watdentRecord->getItem("REFERENCE_TEMPERATURE")->getSIDouble(0);
watdentCT1_[regionIdx] = watdentRecord->getItem("EXPANSION_COEFF_LINEAR")->getSIDouble(0);
watdentCT2_[regionIdx] = watdentRecord->getItem("EXPANSION_COEFF_QUADRATIC")->getSIDouble(0);
}
}
}
void EclipseState::initTitle(DeckConstPtr deck){
if (deck->hasKeyword("TITLE")) {
DeckKeywordConstPtr titleKeyword = deck->getKeyword("TITLE");
DeckRecordConstPtr record = titleKeyword->getRecord(0);
DeckItemPtr item = record->getItem(0);
std::vector<std::string> itemValue = item->getStringData();
m_title = boost::algorithm::join(itemValue, " ");
}
}
void TimeMap::addFromDATESKeyword( DeckKeywordConstPtr DATESKeyword ) {
if (DATESKeyword->name() != "DATES")
throw std::invalid_argument("Method requires DATES keyword input.");
for (size_t recordIndex = 0; recordIndex < DATESKeyword->size(); recordIndex++) {
DeckRecordConstPtr record = DATESKeyword->getRecord( recordIndex );
boost::posix_time::ptime nextTime = TimeMap::timeFromEclipse( record );
addTime( nextTime );
}
}
void KeywordContainer::addKeyword(DeckKeywordConstPtr keyword) {
m_keywordList.push_back(keyword);
if (!hasKeyword(keyword->name())) {
m_keywordMap[keyword->name()] = std::vector<DeckKeywordConstPtr>();
}
{
std::vector<DeckKeywordConstPtr>& keywordList = m_keywordMap[keyword->name()];
keywordList.push_back(keyword);
}
}
/*!
* \brief Sets the pressure-dependent water viscosity and density
* using a table stemming from the Eclipse PVTW keyword.
*/
void setPvtw(int regionIdx, DeckKeywordConstPtr pvtwKeyword)
{
assert(static_cast<int>(pvtwKeyword->size()) >= regionIdx);
auto pvtwRecord = pvtwKeyword->getRecord(regionIdx);
waterReferencePressure_[regionIdx] =
pvtwRecord->getItem("P_REF")->getSIDouble(0);
waterReferenceFormationVolumeFactor_[regionIdx] =
pvtwRecord->getItem("WATER_VOL_FACTOR")->getSIDouble(0);
waterCompressibility_[regionIdx] =
pvtwRecord->getItem("WATER_COMPRESSIBILITY")->getSIDouble(0);
waterViscosity_[regionIdx] =
pvtwRecord->getItem("WATER_VISCOSITY")->getSIDouble(0);
waterViscosibility_[regionIdx] =
pvtwRecord->getItem("WATER_VISCOSIBILITY")->getSIDouble(0);
}
void TimeMap::addFromTSTEPKeyword( DeckKeywordConstPtr TSTEPKeyword ) {
if (TSTEPKeyword->name() != "TSTEP")
throw std::invalid_argument("Method requires TSTEP keyword input.");
{
DeckRecordConstPtr record = TSTEPKeyword->getRecord( 0 );
DeckItemConstPtr item = record->getItem( 0 );
for (size_t itemIndex = 0; itemIndex < item->size(); itemIndex++) {
double days = item->getRawDouble( itemIndex );
long int wholeSeconds = static_cast<long int>(days * 24*60*60);
long int milliSeconds = static_cast<long int>((days * 24*60*60 - wholeSeconds)*1000);
boost::posix_time::time_duration step =
boost::posix_time::seconds(wholeSeconds) +
boost::posix_time::milliseconds(milliSeconds);
addTStep( step );
}
}
}
// WTF?? we initialize a class for water from a keyword for oil?
void initFromPvcdo(DeckKeywordConstPtr pvcdoKeyword)
{
auto pvcdoRecord = pvcdoKeyword->getRecord(0);
ref_press_ = pvcdoRecord->getItem("P_REF")->getSIDouble(0);
ref_B_ = pvcdoRecord->getItem("OIL_VOL_FACTOR")->getSIDouble(0);
comp_ = pvcdoRecord->getItem("OIL_COMPRESSIBILITY")->getSIDouble(0);
viscosity_ = pvcdoRecord->getItem("OIL_VISCOSITY")->getSIDouble(0);
if (pvcdoRecord->getItem("OIL_VISCOSIBILITY")->getSIDouble(0) != 0.0) {
OPM_THROW(std::runtime_error, "MiscibilityWater does not support 'viscosibility'.");
}
}
std::map<std::string , std::vector< CompletionPtr> > Completion::completionsFromCOMPDATKeyword( DeckKeywordConstPtr compdatKeyword ) {
std::map<std::string , std::vector< CompletionPtr> > completionMapList;
for (size_t recordIndex = 0; recordIndex < compdatKeyword->size(); recordIndex++) {
std::pair<std::string , std::vector< CompletionPtr> > wellCompletionsPair = completionsFromCOMPDATRecord( compdatKeyword->getRecord( recordIndex ));
std::string well = wellCompletionsPair.first;
std::vector<CompletionPtr>& newCompletions = wellCompletionsPair.second;
if (completionMapList.find(well) == completionMapList.end())
completionMapList[well] = std::vector<CompletionPtr>();
{
std::vector<CompletionPtr>& currentCompletions = completionMapList.find(well)->second;
for (size_t ic = 0; ic < newCompletions.size(); ic++)
currentCompletions.push_back( newCompletions[ic] );
}
}
return completionMapList;
}
