mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-25 18:55:39 -06:00
614bb147f2
* Adjustments to build system for opm-common * Add opm-common as submodule * Disable use of unity build for opm-common
332 lines
10 KiB
C++
332 lines
10 KiB
C++
|
|
#include <opm/input/eclipse/Deck/UDAValue.hpp>
|
|
#include <opm/input/eclipse/Parser/ParserItem.hpp>
|
|
#include <opm/input/eclipse/Parser/ParserRecord.hpp>
|
|
#include <opm/input/eclipse/Parser/Parser.hpp>
|
|
|
|
|
|
|
|
|
|
|
|
#include <opm/input/eclipse/Parser/ParserKeywords/U.hpp>
|
|
namespace Opm {
|
|
namespace ParserKeywords {
|
|
UDADIMS::UDADIMS() : ParserKeyword("UDADIMS", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("UDADIMS");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("NUM_UDQ_REPLACE", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("IGNORED", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TOTAL_UDQ_UNIQUE", ParserItem::itype::INT);
|
|
item.setDefault( 100 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string UDADIMS::keywordName = "UDADIMS";
|
|
const std::string UDADIMS::NUM_UDQ_REPLACE::itemName = "NUM_UDQ_REPLACE";
|
|
const int UDADIMS::NUM_UDQ_REPLACE::defaultValue = 0;
|
|
const std::string UDADIMS::IGNORED::itemName = "IGNORED";
|
|
const int UDADIMS::IGNORED::defaultValue = 0;
|
|
const std::string UDADIMS::TOTAL_UDQ_UNIQUE::itemName = "TOTAL_UDQ_UNIQUE";
|
|
const int UDADIMS::TOTAL_UDQ_UNIQUE::defaultValue = 100;
|
|
|
|
|
|
UDQ::UDQ() : ParserKeyword("UDQ", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("UDQ");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("ACTION", ParserItem::itype::RAW_STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("QUANTITY", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DATA", ParserItem::itype::RAW_STRING);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string UDQ::keywordName = "UDQ";
|
|
const std::string UDQ::ACTION::itemName = "ACTION";
|
|
const std::string UDQ::QUANTITY::itemName = "QUANTITY";
|
|
const std::string UDQ::DATA::itemName = "DATA";
|
|
|
|
|
|
UDQDIMS::UDQDIMS() : ParserKeyword("UDQDIMS", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("UDQDIMS");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("MAX_FUNCTIONS", ParserItem::itype::INT);
|
|
item.setDefault( 16 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_ITEMS", ParserItem::itype::INT);
|
|
item.setDefault( 16 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_CONNECTIONS", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_FIELDS", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_GROUP", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_REGION", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_SEGMENT", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_WELL", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_AQUIFER", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_BLOCK", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("RESTART_NEW_SEED", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("N") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string UDQDIMS::keywordName = "UDQDIMS";
|
|
const std::string UDQDIMS::MAX_FUNCTIONS::itemName = "MAX_FUNCTIONS";
|
|
const int UDQDIMS::MAX_FUNCTIONS::defaultValue = 16;
|
|
const std::string UDQDIMS::MAX_ITEMS::itemName = "MAX_ITEMS";
|
|
const int UDQDIMS::MAX_ITEMS::defaultValue = 16;
|
|
const std::string UDQDIMS::MAX_CONNECTIONS::itemName = "MAX_CONNECTIONS";
|
|
const int UDQDIMS::MAX_CONNECTIONS::defaultValue = 0;
|
|
const std::string UDQDIMS::MAX_FIELDS::itemName = "MAX_FIELDS";
|
|
const int UDQDIMS::MAX_FIELDS::defaultValue = 0;
|
|
const std::string UDQDIMS::MAX_GROUP::itemName = "MAX_GROUP";
|
|
const int UDQDIMS::MAX_GROUP::defaultValue = 0;
|
|
const std::string UDQDIMS::MAX_REGION::itemName = "MAX_REGION";
|
|
const int UDQDIMS::MAX_REGION::defaultValue = 0;
|
|
const std::string UDQDIMS::MAX_SEGMENT::itemName = "MAX_SEGMENT";
|
|
const int UDQDIMS::MAX_SEGMENT::defaultValue = 0;
|
|
const std::string UDQDIMS::MAX_WELL::itemName = "MAX_WELL";
|
|
const int UDQDIMS::MAX_WELL::defaultValue = 0;
|
|
const std::string UDQDIMS::MAX_AQUIFER::itemName = "MAX_AQUIFER";
|
|
const int UDQDIMS::MAX_AQUIFER::defaultValue = 0;
|
|
const std::string UDQDIMS::MAX_BLOCK::itemName = "MAX_BLOCK";
|
|
const int UDQDIMS::MAX_BLOCK::defaultValue = 0;
|
|
const std::string UDQDIMS::RESTART_NEW_SEED::itemName = "RESTART_NEW_SEED";
|
|
const std::string UDQDIMS::RESTART_NEW_SEED::defaultValue = "N";
|
|
|
|
|
|
UDQPARAM::UDQPARAM() : ParserKeyword("UDQPARAM", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("UDQPARAM");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("RANDOM_SEED", ParserItem::itype::INT);
|
|
item.setDefault( 1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("RANGE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(100000000000000000000.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("UNDEFINED_VALUE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CMP_EPSILON", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.000100) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string UDQPARAM::keywordName = "UDQPARAM";
|
|
const std::string UDQPARAM::RANDOM_SEED::itemName = "RANDOM_SEED";
|
|
const int UDQPARAM::RANDOM_SEED::defaultValue = 1;
|
|
const std::string UDQPARAM::RANGE::itemName = "RANGE";
|
|
const double UDQPARAM::RANGE::defaultValue = 100000000000000000000.000000;
|
|
const std::string UDQPARAM::UNDEFINED_VALUE::itemName = "UNDEFINED_VALUE";
|
|
const double UDQPARAM::UNDEFINED_VALUE::defaultValue = 0;
|
|
const std::string UDQPARAM::CMP_EPSILON::itemName = "CMP_EPSILON";
|
|
const double UDQPARAM::CMP_EPSILON::defaultValue = 0.000100;
|
|
|
|
|
|
UDT::UDT() : ParserKeyword("UDT", KeywordSize(0, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("UDT");
|
|
}
|
|
const std::string UDT::keywordName = "UDT";
|
|
|
|
|
|
UDTDIMS::UDTDIMS() : ParserKeyword("UDTDIMS", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("UDTDIMS");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("MAX_TABLES", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_ROWS", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_INTERPOLATION_POINTS", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_DIMENSIONS", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string UDTDIMS::keywordName = "UDTDIMS";
|
|
const std::string UDTDIMS::MAX_TABLES::itemName = "MAX_TABLES";
|
|
const int UDTDIMS::MAX_TABLES::defaultValue = 0;
|
|
const std::string UDTDIMS::MAX_ROWS::itemName = "MAX_ROWS";
|
|
const int UDTDIMS::MAX_ROWS::defaultValue = 0;
|
|
const std::string UDTDIMS::MAX_INTERPOLATION_POINTS::itemName = "MAX_INTERPOLATION_POINTS";
|
|
const int UDTDIMS::MAX_INTERPOLATION_POINTS::defaultValue = 0;
|
|
const std::string UDTDIMS::MAX_DIMENSIONS::itemName = "MAX_DIMENSIONS";
|
|
const int UDTDIMS::MAX_DIMENSIONS::defaultValue = 0;
|
|
|
|
|
|
UNCODHMD::UNCODHMD() : ParserKeyword("UNCODHMD", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("UNCODHMD");
|
|
}
|
|
const std::string UNCODHMD::keywordName = "UNCODHMD";
|
|
|
|
|
|
UNIFIN::UNIFIN() : ParserKeyword("UNIFIN", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("UNIFIN");
|
|
}
|
|
const std::string UNIFIN::keywordName = "UNIFIN";
|
|
|
|
|
|
UNIFOUT::UNIFOUT() : ParserKeyword("UNIFOUT", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("UNIFOUT");
|
|
}
|
|
const std::string UNIFOUT::keywordName = "UNIFOUT";
|
|
|
|
|
|
UNIFOUTS::UNIFOUTS() : ParserKeyword("UNIFOUTS", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("UNIFOUTS");
|
|
}
|
|
const std::string UNIFOUTS::keywordName = "UNIFOUTS";
|
|
|
|
|
|
UNIFSAVE::UNIFSAVE() : ParserKeyword("UNIFSAVE", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("UNIFSAVE");
|
|
}
|
|
const std::string UNIFSAVE::keywordName = "UNIFSAVE";
|
|
|
|
|
|
USECUPL::USECUPL() : ParserKeyword("USECUPL", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("USECUPL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("BASE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FMT", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string USECUPL::keywordName = "USECUPL";
|
|
const std::string USECUPL::BASE::itemName = "BASE";
|
|
const std::string USECUPL::FMT::itemName = "FMT";
|
|
|
|
|
|
USEFLUX::USEFLUX() : ParserKeyword("USEFLUX", KeywordSize(0, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("USEFLUX");
|
|
}
|
|
const std::string USEFLUX::keywordName = "USEFLUX";
|
|
|
|
|
|
USENOFLO::USENOFLO() : ParserKeyword("USENOFLO", KeywordSize(0, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("USENOFLO");
|
|
}
|
|
const std::string USENOFLO::keywordName = "USENOFLO";
|
|
|
|
|
|
}
|
|
}
|