const std::vector<DeckKeywordConstPtr>& KeywordContainer::getKeywordList(const std::string& keyword) const {
if (hasKeyword(keyword)) {
const std::vector<DeckKeywordConstPtr>& keywordList = m_keywordMap.find(keyword)->second;
return keywordList;
} else
throw std::invalid_argument("Keyword: " + keyword + " is not found in the container");
}
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));
}
}
}
ParserKeywordConstPtr Parser::getKeyword(const std::string& keyword) const {
if (hasKeyword(keyword)) {
return m_parserKeywords.at(keyword);
}
else
throw std::invalid_argument("Keyword: " + keyword + " does not exist");
}
bool GridProperties<T>::addKeyword(const std::string& keywordName) {
if (!supportsKeyword( keywordName ))
throw std::invalid_argument("The keyword: " + keywordName + " is not supported in this container");
if (hasKeyword(keywordName))
return false;
else {
const std::string kw = normalize(keywordName);
// if the property was already added auto generated, we just need to make it
// non-auto generated
if (m_autoGeneratedProperties.count(kw)) {
OpmLog::warning("The keyword "+kw+" has been used to calculate the "
"defaults of another keyword before the first time it was "
"explicitly mentioned in the deck. Maybe you need to change "
"the ordering of your keywords (move "+kw+" to the front?).");
m_autoGeneratedProperties.erase(m_autoGeneratedProperties.find(kw));
return true;
}
if (isFipxxx<T>(kw))
m_supportedKeywords.emplace(kw, SupportedKeywordInfo( kw , 1, "1" ));
insertKeyword( m_supportedKeywords.at( kw ) );
return true;
}
}
// parse a STATA command
DwUseOptions* DwUseOptionParser::Parse(vector<string> words) {
// there are 10 keywords we expect to see
string keys[] = {"variables", "if", "using", "limit",
"nulldata", "lowercase", "uppercase",
"label_variable", "label_values",
"username", "password", "database"};
size_t nkeys(sizeof(keys) / sizeof(string));
// create parser that accepts these keywords
OptionParser* parser = new OptionParser( set<string>(keys, keys + nkeys) );
// prepare another vector where we can search
// see if we have a using anywhere, if we do, the first part is the varlist, if not it is the tablename
bool hasUsing = hasKeyword(words, "using");
// if it contains using somewhere we can start with variables (if missing it will be an empty string, if the list is there it will be expected)
if( !hasUsing )
words.insert(words.begin(), "using");
else if( lowerCase(words[0]) != "if" && lowerCase(words[0]) != "using" )
words.insert(words.begin(), "variables");
// parse the options
map<string,string> options = parser->Parse( words );
delete parser;
// create a meaningful options object
DwUseOptions* useOptions = new DwUseOptions( options );
return useOptions;
}
size_t KeywordContainer::numKeywords(const std::string& keyword) const{
if (hasKeyword(keyword)) {
const std::vector<DeckKeywordConstPtr>& keywordList = getKeywordList( keyword );
return keywordList.size();
} else
return 0;
}
bool addKeyword(const std::string& keywordName) {
if (!supportsKeyword( keywordName ))
throw std::invalid_argument("The keyword: " + keywordName + " is not supported in this container");
if (hasKeyword(keywordName))
return false;
else {
// if the property was already added auto generated, we just need to make it
// non-auto generated
if (m_autoGeneratedProperties_.count(keywordName)) {
OpmLog::addMessage(Log::MessageType::Warning,
"The keyword "+keywordName+" has been used to calculate the "
"defaults of another keyword before the first time it was "
"explicitly mentioned in the deck. Maybe you need to change "
"the ordering of your keywords (move "+keywordName+" to the "
"front?).");
m_autoGeneratedProperties_.erase(m_autoGeneratedProperties_.find(keywordName));
return true;
}
auto supportedKeyword = m_supportedKeywords.at( keywordName );
int nx = m_eclipseGrid->getNX();
int ny = m_eclipseGrid->getNY();
int nz = m_eclipseGrid->getNZ();
std::shared_ptr<GridProperty<T> > newProperty(new GridProperty<T>(nx , ny , nz , supportedKeyword));
m_properties.insert( std::pair<std::string , std::shared_ptr<GridProperty<T> > > ( keywordName , newProperty ));
m_property_list.push_back( newProperty );
return true;
}
}
GridProperty<T>& GridProperties<T>::getKeyword(const std::string& keyword) {
const std::string kw = normalize(keyword);
if (!hasKeyword(kw))
addAutoGeneratedKeyword_(kw);
return m_properties.at( kw );
}
std::shared_ptr<GridProperty<T> > getInitializedKeyword(const std::string& keyword) const {
if (hasKeyword(keyword))
return m_properties.at( keyword );
else {
if (supportsKeyword(keyword))
throw std::invalid_argument("Keyword: " + keyword + " is supported - but not initialized.");
else
throw std::invalid_argument("Keyword: " + keyword + " is not supported.");
}
}
void GridProperties<T>::handleMINVALUERecord( const DeckRecord& record, BoxManager& boxManager) {
const std::string& field = record.getItem("field").get< std::string >(0);
if (hasKeyword( field )) {
GridProperty<T>& property = getKeyword( field );
T value = convertInputValue( property, record.getItem("value").get< double >(0) );
setKeywordBox(record, boxManager);
property.minvalue( value , boxManager.getActiveBox() );
} else
throw std::invalid_argument("Fatal error processing MINVALUE keyword. Tried to limit not defined keyword " + field);
}
void KeywordLoader::addKeyword(std::shared_ptr<ParserKeyword> keyword , const std::string& jsonFile) {
const std::string& name = keyword->getName();
if (hasKeyword(name)) {
m_keywords[name] = keyword;
m_jsonFile[name] = jsonFile;
} else {
m_keywords.insert( std::pair<std::string , std::shared_ptr<ParserKeyword> > (name , keyword) );
m_jsonFile.insert( std::pair<std::string , std::string> ( name , jsonFile));
}
}
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);
}
}
void GridProperties<T>::assertKeyword(const std::string& keyword) const {
const std::string kw = normalize(keyword);
if ( !( hasKeyword( kw ) || isDefaultInitializable( kw ) || isFipxxx<T>( kw ) ) )
throw std::invalid_argument("Keyword: " + keyword +
" is not yet defined and could not be default initialized");
if (m_properties.count( kw ) == 0)
addAutoGeneratedKeyword_(kw);
GridProperty<T>& property = m_properties.at( kw );
property.runPostProcessor( );
}
void GridProperties<T>::handleCOPYRecord( const DeckRecord& record, BoxManager& boxManager) {
const std::string& srcField = record.getItem("src").get< std::string >(0);
const std::string& targetField = record.getItem("target").get< std::string >(0);
if (hasKeyword( srcField )) {
setKeywordBox(record, boxManager);
copyKeyword( srcField , targetField , boxManager.getActiveBox() );
} else {
if (!supportsKeyword( srcField))
throw std::invalid_argument("Fatal error processing COPY keyword."
" Tried to copy from not defined keyword " + srcField);
}
}
const std::vector< const DeckKeyword* > DeckView::getKeywordList( const std::string& keyword ) const {
if( !hasKeyword( keyword ) ) return {};
const auto& indices = this->offsets( keyword );
std::vector< const DeckKeyword* > ret;
ret.reserve( indices.size() );
for( size_t i : indices )
ret.push_back( &this->getKeyword( i ) );
return ret;
}
void Parser::parseFile(DeckPtr deck, const boost::filesystem::path& file, const boost::filesystem::path& rootPath, bool parseStrict) const {
bool verbose = false;
std::ifstream inputstream;
size_t lineNR = 0;
inputstream.open(file.string().c_str());
if (inputstream) {
RawKeywordPtr rawKeyword;
while (tryParseKeyword(deck, file.string() , lineNR , inputstream, rawKeyword, parseStrict)) {
if (rawKeyword->getKeywordName() == Opm::RawConsts::include) {
RawRecordConstPtr firstRecord = rawKeyword->getRecord(0);
std::string includeFileString = firstRecord->getItem(0);
boost::filesystem::path includeFile(includeFileString);
if (includeFile.is_relative())
includeFile = rootPath / includeFile;
if (verbose)
std::cout << rawKeyword->getKeywordName() << " " << includeFile << std::endl;
parseFile(deck, includeFile, rootPath , parseStrict);
} else {
if (verbose)
std::cout << rawKeyword->getKeywordName() << std::endl;
if (hasKeyword(rawKeyword->getKeywordName())) {
ParserKeywordConstPtr parserKeyword = m_parserKeywords.at(rawKeyword->getKeywordName());
ParserKeywordActionEnum action = parserKeyword->getAction();
if (action == INTERNALIZE) {
DeckKeywordConstPtr deckKeyword = parserKeyword->parse(rawKeyword);
deck->addKeyword(deckKeyword);
} else if (action == IGNORE_WARNING)
deck->addWarning( "The keyword " + rawKeyword->getKeywordName() + " is ignored - this might potentially affect the results" , file.string() , rawKeyword->getLineNR());
} else {
DeckKeywordConstPtr deckKeyword(new DeckKeyword(rawKeyword->getKeywordName(), false));
deck->addKeyword(deckKeyword);
deck->addWarning( "The keyword " + rawKeyword->getKeywordName() + " is not recognized" , file.string() , lineNR);
}
}
rawKeyword.reset();
}
inputstream.close();
} else
throw std::invalid_argument("Failed to open file: " + file.string());
}
void Deck::initUnitSystem() const {
/*
* The unit systems are lazily created as their exact value depend on
* input values of the deck, but in a constructed deck this can be
* considered constant (and in fact, if the deck is obtained through
* ParseFromString/File, this these values set before the Deck is
* available). The unit systems are needed from const contexts though,
* but might not have been generated at that time. Generation is done
* in this method, but it has to be callable from const'd this, and are
* marked mutable.
*/
this->defaultUnits = std::unique_ptr< UnitSystem >( UnitSystem::newMETRIC() );
if (hasKeyword("FIELD"))
this->activeUnits = std::unique_ptr< UnitSystem >( UnitSystem::newFIELD() );
else
this->activeUnits = std::unique_ptr< UnitSystem >( UnitSystem::newMETRIC() );
}
void GridProperties<T>::handleCOPYREGRecord( const DeckRecord& record, const GridProperty<int>& regionProperty ) {
const std::string& srcArray = record.getItem("ARRAY").get< std::string >(0);
const std::string& targetArray = record.getItem("TARGET_ARRAY").get< std::string >(0);
if (!supportsKeyword( targetArray))
throw std::invalid_argument("Fatal error processing COPYREG record - invalid/undefined keyword: " + targetArray);
if (!hasKeyword( srcArray ))
throw std::invalid_argument("Fatal error processing COPYREG record - invalid/undefined keyword: " + srcArray);
{
int regionValue = record.getItem("REGION_NUMBER").get< int >(0);
std::vector<bool> mask;
GridProperty<T>& targetProperty = getOrCreateProperty( targetArray );
GridProperty<T>& srcProperty = getKeyword( srcArray );
regionProperty.initMask( regionValue , mask);
targetProperty.maskedCopy( srcProperty , mask );
}
}
bool hasKeyword() const {
return hasKeyword( Keyword::keywordName );
}
const std::vector< size_t >& DeckView::offsets( const std::string& keyword ) const {
if( !hasKeyword( keyword ) ) return empty_indices;
return this->keywordMap.find( keyword )->second;
}
void CompositeFood::addKeyword(string keyword) {
if(hasKeyword(keyword)==false)
keywords.push_back(keyword);
}
GridProperty<T>& GridProperties<T>::getOrCreateProperty(const std::string& name) {
if (!hasKeyword(name))
addKeyword(name);
return getKeyword(name);
}
std::shared_ptr<GridProperty<T> > getKeyword(const std::string& keyword) const {
if (!hasKeyword(keyword))
addAutoGeneratedKeyword_(keyword);
return m_properties.at( keyword );
}
