mirror of
https://github.com/OPM/ResInsight.git
synced 2025-01-05 21:53:27 -06:00
7a0bfd4917
* Adjustments to build system for opm-common * Add opm-common as submodule * Disable use of unity build for opm-common
949 lines
29 KiB
C++
949 lines
29 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/N.hpp>
|
|
namespace Opm {
|
|
namespace ParserKeywords {
|
|
NARROW::NARROW() : ParserKeyword("NARROW", KeywordSize(0, false)) {
|
|
addValidSectionName("SUMMARY");
|
|
clearDeckNames();
|
|
addDeckName("NARROW");
|
|
}
|
|
const std::string NARROW::keywordName = "NARROW";
|
|
|
|
|
|
NCONSUMP::NCONSUMP() : ParserKeyword("NCONSUMP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NCONSUMP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("NODE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GAS_CONSUMPTION_RATE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("GasSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("REMOVAL_GROUP", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NCONSUMP::keywordName = "NCONSUMP";
|
|
const std::string NCONSUMP::NODE::itemName = "NODE";
|
|
const std::string NCONSUMP::GAS_CONSUMPTION_RATE::itemName = "GAS_CONSUMPTION_RATE";
|
|
const double NCONSUMP::GAS_CONSUMPTION_RATE::defaultValue = 0;
|
|
const std::string NCONSUMP::REMOVAL_GROUP::itemName = "REMOVAL_GROUP";
|
|
|
|
|
|
NEFAC::NEFAC() : ParserKeyword("NEFAC", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NEFAC");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("NODE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("EFF_FACTOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NEFAC::keywordName = "NEFAC";
|
|
const std::string NEFAC::NODE::itemName = "NODE";
|
|
const std::string NEFAC::EFF_FACTOR::itemName = "EFF_FACTOR";
|
|
const double NEFAC::EFF_FACTOR::defaultValue = 1.000000;
|
|
|
|
|
|
NETBALAN::NETBALAN() : ParserKeyword("NETBALAN", KeywordSize(1, false)) {
|
|
addValidSectionName("SPECIAL");
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NETBALAN");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("TIME_INTERVAL", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PRESSURE_CONVERGENCE_LIMIT", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.100000) );
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_ITER", ParserItem::itype::INT);
|
|
item.setDefault( 10 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("THP_CONVERGENCE_LIMIT", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.010000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_ITER_THP", ParserItem::itype::INT);
|
|
item.setDefault( 10 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TARGET_BALANCE_ERROR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(100000000000000000000.000000) );
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_BALANCE_ERROR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(100000000000000000000.000000) );
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MIN_TIME_STEP", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Time");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NETBALAN::keywordName = "NETBALAN";
|
|
const std::string NETBALAN::TIME_INTERVAL::itemName = "TIME_INTERVAL";
|
|
const double NETBALAN::TIME_INTERVAL::defaultValue = 0;
|
|
const std::string NETBALAN::PRESSURE_CONVERGENCE_LIMIT::itemName = "PRESSURE_CONVERGENCE_LIMIT";
|
|
const double NETBALAN::PRESSURE_CONVERGENCE_LIMIT::defaultValue = 0.100000;
|
|
const std::string NETBALAN::MAX_ITER::itemName = "MAX_ITER";
|
|
const int NETBALAN::MAX_ITER::defaultValue = 10;
|
|
const std::string NETBALAN::THP_CONVERGENCE_LIMIT::itemName = "THP_CONVERGENCE_LIMIT";
|
|
const double NETBALAN::THP_CONVERGENCE_LIMIT::defaultValue = 0.010000;
|
|
const std::string NETBALAN::MAX_ITER_THP::itemName = "MAX_ITER_THP";
|
|
const int NETBALAN::MAX_ITER_THP::defaultValue = 10;
|
|
const std::string NETBALAN::TARGET_BALANCE_ERROR::itemName = "TARGET_BALANCE_ERROR";
|
|
const double NETBALAN::TARGET_BALANCE_ERROR::defaultValue = 100000000000000000000.000000;
|
|
const std::string NETBALAN::MAX_BALANCE_ERROR::itemName = "MAX_BALANCE_ERROR";
|
|
const double NETBALAN::MAX_BALANCE_ERROR::defaultValue = 100000000000000000000.000000;
|
|
const std::string NETBALAN::MIN_TIME_STEP::itemName = "MIN_TIME_STEP";
|
|
|
|
|
|
NETCOMPA::NETCOMPA() : ParserKeyword("NETCOMPA", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NETCOMPA");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("INLET", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("OUTLET", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GROUP", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PHASE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("GAS") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VFT_TABLE_NUM", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ALQ", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GAS_CONSUMPTION_RATE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("GasSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("EXTRACTION_GROUP", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("COMPRESSOR_TYPE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NUM_COMPRESSION_LEVELS", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ALQ_LEVEL1", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("COMP_SWITCH_SEQ_NUM", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NETCOMPA::keywordName = "NETCOMPA";
|
|
const std::string NETCOMPA::INLET::itemName = "INLET";
|
|
const std::string NETCOMPA::OUTLET::itemName = "OUTLET";
|
|
const std::string NETCOMPA::GROUP::itemName = "GROUP";
|
|
const std::string NETCOMPA::GROUP::defaultValue = "";
|
|
const std::string NETCOMPA::PHASE::itemName = "PHASE";
|
|
const std::string NETCOMPA::PHASE::defaultValue = "GAS";
|
|
const std::string NETCOMPA::VFT_TABLE_NUM::itemName = "VFT_TABLE_NUM";
|
|
const int NETCOMPA::VFT_TABLE_NUM::defaultValue = 0;
|
|
const std::string NETCOMPA::ALQ::itemName = "ALQ";
|
|
const double NETCOMPA::ALQ::defaultValue = 0;
|
|
const std::string NETCOMPA::GAS_CONSUMPTION_RATE::itemName = "GAS_CONSUMPTION_RATE";
|
|
const double NETCOMPA::GAS_CONSUMPTION_RATE::defaultValue = 0;
|
|
const std::string NETCOMPA::EXTRACTION_GROUP::itemName = "EXTRACTION_GROUP";
|
|
const std::string NETCOMPA::EXTRACTION_GROUP::defaultValue = "";
|
|
const std::string NETCOMPA::COMPRESSOR_TYPE::itemName = "COMPRESSOR_TYPE";
|
|
const std::string NETCOMPA::NUM_COMPRESSION_LEVELS::itemName = "NUM_COMPRESSION_LEVELS";
|
|
const std::string NETCOMPA::ALQ_LEVEL1::itemName = "ALQ_LEVEL1";
|
|
const std::string NETCOMPA::COMP_SWITCH_SEQ_NUM::itemName = "COMP_SWITCH_SEQ_NUM";
|
|
|
|
|
|
NETWORK::NETWORK() : ParserKeyword("NETWORK", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("NETWORK");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("NODMAX", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NBRMAX", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NBCMAX", ParserItem::itype::INT);
|
|
item.setDefault( 20 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NETWORK::keywordName = "NETWORK";
|
|
const std::string NETWORK::NODMAX::itemName = "NODMAX";
|
|
const std::string NETWORK::NBRMAX::itemName = "NBRMAX";
|
|
const std::string NETWORK::NBCMAX::itemName = "NBCMAX";
|
|
const int NETWORK::NBCMAX::defaultValue = 20;
|
|
|
|
|
|
NEWTRAN::NEWTRAN() : ParserKeyword("NEWTRAN", KeywordSize(0, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("NEWTRAN");
|
|
}
|
|
const std::string NEWTRAN::keywordName = "NEWTRAN";
|
|
|
|
|
|
NEXTSTEP::NEXTSTEP() : ParserKeyword("NEXTSTEP", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NEXT");
|
|
addDeckName("NEXTSTEP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("MAX_STEP", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("APPLY_TO_ALL", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NEXTSTEP::keywordName = "NEXTSTEP";
|
|
const std::string NEXTSTEP::MAX_STEP::itemName = "MAX_STEP";
|
|
const std::string NEXTSTEP::APPLY_TO_ALL::itemName = "APPLY_TO_ALL";
|
|
const std::string NEXTSTEP::APPLY_TO_ALL::defaultValue = "NO";
|
|
|
|
|
|
NEXTSTPL::NEXTSTPL() : ParserKeyword("NEXTSTPL", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NEXTSTPL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("MAX_LENGTH", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("APPLY_TO_ALL", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NEXTSTPL::keywordName = "NEXTSTPL";
|
|
const std::string NEXTSTPL::MAX_LENGTH::itemName = "MAX_LENGTH";
|
|
const std::string NEXTSTPL::APPLY_TO_ALL::itemName = "APPLY_TO_ALL";
|
|
const std::string NEXTSTPL::APPLY_TO_ALL::defaultValue = "NO";
|
|
|
|
|
|
NINENUM::NINENUM() : ParserKeyword("NINENUM", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("NINENUM");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("data", ParserItem::itype::INT);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addDataItem(item);
|
|
}
|
|
addDataRecord( record );
|
|
}
|
|
}
|
|
const std::string NINENUM::keywordName = "NINENUM";
|
|
const std::string NINENUM::data::itemName = "data";
|
|
|
|
|
|
NINEPOIN::NINEPOIN() : ParserKeyword("NINEPOIN", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("NINEPOIN");
|
|
}
|
|
const std::string NINEPOIN::keywordName = "NINEPOIN";
|
|
|
|
|
|
NMATOPTS::NMATOPTS() : ParserKeyword("NMATOPTS", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("NMATOPTS");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("GEOMETRY", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("LINEAR") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FRACTION_PORE_VOL", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.100000) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("METHOD", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("FPORV") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NMATOPTS::keywordName = "NMATOPTS";
|
|
const std::string NMATOPTS::GEOMETRY::itemName = "GEOMETRY";
|
|
const std::string NMATOPTS::GEOMETRY::defaultValue = "LINEAR";
|
|
const std::string NMATOPTS::FRACTION_PORE_VOL::itemName = "FRACTION_PORE_VOL";
|
|
const double NMATOPTS::FRACTION_PORE_VOL::defaultValue = 0.100000;
|
|
const std::string NMATOPTS::METHOD::itemName = "METHOD";
|
|
const std::string NMATOPTS::METHOD::defaultValue = "FPORV";
|
|
|
|
|
|
NMATRIX::NMATRIX() : ParserKeyword("NMATRIX", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("NMATRIX");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("NUM_SUB_CELLS", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NMATRIX::keywordName = "NMATRIX";
|
|
const std::string NMATRIX::NUM_SUB_CELLS::itemName = "NUM_SUB_CELLS";
|
|
|
|
|
|
NMESSAGE::NMESSAGE() : ParserKeyword("NMESSAGE", KeywordSize(0, false)) {
|
|
addValidSectionName("SUMMARY");
|
|
clearDeckNames();
|
|
addDeckName("NMESSAGE");
|
|
}
|
|
const std::string NMESSAGE::keywordName = "NMESSAGE";
|
|
|
|
|
|
NNC::NNC() : ParserKeyword("NNC", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("NNC");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("I1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TRAN", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Transmissibility");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("IST1", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("IST2", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PRESSURE_TABLE1", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PRESSURE_TABLE2", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VE_FACE1", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VE_FACE2", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DIFFUSIVITY", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SIM_DEPENDENT3", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("ContextDependent");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VDFLOW_AREA", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Length*Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VDFLOW_PERM", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Permeability");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NNC::keywordName = "NNC";
|
|
const std::string NNC::I1::itemName = "I1";
|
|
const std::string NNC::J1::itemName = "J1";
|
|
const std::string NNC::K1::itemName = "K1";
|
|
const std::string NNC::I2::itemName = "I2";
|
|
const std::string NNC::J2::itemName = "J2";
|
|
const std::string NNC::K2::itemName = "K2";
|
|
const std::string NNC::TRAN::itemName = "TRAN";
|
|
const double NNC::TRAN::defaultValue = 0;
|
|
const std::string NNC::IST1::itemName = "IST1";
|
|
const int NNC::IST1::defaultValue = 0;
|
|
const std::string NNC::IST2::itemName = "IST2";
|
|
const int NNC::IST2::defaultValue = 0;
|
|
const std::string NNC::PRESSURE_TABLE1::itemName = "PRESSURE_TABLE1";
|
|
const int NNC::PRESSURE_TABLE1::defaultValue = 0;
|
|
const std::string NNC::PRESSURE_TABLE2::itemName = "PRESSURE_TABLE2";
|
|
const int NNC::PRESSURE_TABLE2::defaultValue = 0;
|
|
const std::string NNC::VE_FACE1::itemName = "VE_FACE1";
|
|
const std::string NNC::VE_FACE1::defaultValue = "";
|
|
const std::string NNC::VE_FACE2::itemName = "VE_FACE2";
|
|
const std::string NNC::VE_FACE2::defaultValue = "";
|
|
const std::string NNC::DIFFUSIVITY::itemName = "DIFFUSIVITY";
|
|
const double NNC::DIFFUSIVITY::defaultValue = 0;
|
|
const std::string NNC::SIM_DEPENDENT3::itemName = "SIM_DEPENDENT3";
|
|
const double NNC::SIM_DEPENDENT3::defaultValue = 0;
|
|
const std::string NNC::VDFLOW_AREA::itemName = "VDFLOW_AREA";
|
|
const double NNC::VDFLOW_AREA::defaultValue = 0;
|
|
const std::string NNC::VDFLOW_PERM::itemName = "VDFLOW_PERM";
|
|
const double NNC::VDFLOW_PERM::defaultValue = 0;
|
|
|
|
|
|
NNEWTF::NNEWTF() : ParserKeyword("NNEWTF", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NNEWTF");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("NTHRBL", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NLNHBL", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NNEWTF::keywordName = "NNEWTF";
|
|
const std::string NNEWTF::NTHRBL::itemName = "NTHRBL";
|
|
const std::string NNEWTF::NLNHBL::itemName = "NLNHBL";
|
|
|
|
|
|
NOCASC::NOCASC() : ParserKeyword("NOCASC", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("NOCASC");
|
|
}
|
|
const std::string NOCASC::keywordName = "NOCASC";
|
|
|
|
|
|
NODEPROP::NODEPROP() : ParserKeyword("NODEPROP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NODEPROP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("NAME", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PRESSURE", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("AS_CHOKE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ADD_GAS_LIFT_GAS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CHOKE_GROUP", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SOURCE_SINK_GROUP", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NETWORK_VALUE_TYPE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NODEPROP::keywordName = "NODEPROP";
|
|
const std::string NODEPROP::NAME::itemName = "NAME";
|
|
const std::string NODEPROP::PRESSURE::itemName = "PRESSURE";
|
|
const std::string NODEPROP::AS_CHOKE::itemName = "AS_CHOKE";
|
|
const std::string NODEPROP::AS_CHOKE::defaultValue = "NO";
|
|
const std::string NODEPROP::ADD_GAS_LIFT_GAS::itemName = "ADD_GAS_LIFT_GAS";
|
|
const std::string NODEPROP::ADD_GAS_LIFT_GAS::defaultValue = "NO";
|
|
const std::string NODEPROP::CHOKE_GROUP::itemName = "CHOKE_GROUP";
|
|
const std::string NODEPROP::SOURCE_SINK_GROUP::itemName = "SOURCE_SINK_GROUP";
|
|
const std::string NODEPROP::NETWORK_VALUE_TYPE::itemName = "NETWORK_VALUE_TYPE";
|
|
|
|
|
|
NODPPM::NODPPM() : ParserKeyword("NODPPM", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("NODPPM");
|
|
}
|
|
const std::string NODPPM::keywordName = "NODPPM";
|
|
|
|
|
|
NOECHO::NOECHO() : ParserKeyword("NOECHO", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
addValidSectionName("PROPS");
|
|
addValidSectionName("EDIT");
|
|
addValidSectionName("GRID");
|
|
addValidSectionName("REGIONS");
|
|
addValidSectionName("SOLUTION");
|
|
addValidSectionName("SUMMARY");
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NOECHO");
|
|
}
|
|
const std::string NOECHO::keywordName = "NOECHO";
|
|
|
|
|
|
NOGGF::NOGGF() : ParserKeyword("NOGGF", KeywordSize(0, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("NOGGF");
|
|
}
|
|
const std::string NOGGF::keywordName = "NOGGF";
|
|
|
|
|
|
NOGRAV::NOGRAV() : ParserKeyword("NOGRAV", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("NOGRAV");
|
|
}
|
|
const std::string NOGRAV::keywordName = "NOGRAV";
|
|
|
|
|
|
NOHMD::NOHMD() : ParserKeyword("NOHMD", KeywordSize(1, false)) {
|
|
addValidSectionName("SOLUTION");
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NOHMD");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("GRAD_PARAMS", ParserItem::itype::STRING);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NOHMD::keywordName = "NOHMD";
|
|
const std::string NOHMD::GRAD_PARAMS::itemName = "GRAD_PARAMS";
|
|
|
|
|
|
NOHMO::NOHMO() : ParserKeyword("NOHMO", KeywordSize(1, false)) {
|
|
addValidSectionName("SOLUTION");
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NOHMO");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("GRAD_PARAMS", ParserItem::itype::STRING);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NOHMO::keywordName = "NOHMO";
|
|
const std::string NOHMO::GRAD_PARAMS::itemName = "GRAD_PARAMS";
|
|
|
|
|
|
NOHYST::NOHYST() : ParserKeyword("NOHYST", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("NOHYST");
|
|
}
|
|
const std::string NOHYST::keywordName = "NOHYST";
|
|
|
|
|
|
NOINSPEC::NOINSPEC() : ParserKeyword("NOINSPEC", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("NOINSPEC");
|
|
}
|
|
const std::string NOINSPEC::keywordName = "NOINSPEC";
|
|
|
|
|
|
NOMONITO::NOMONITO() : ParserKeyword("NOMONITO", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
addValidSectionName("SUMMARY");
|
|
clearDeckNames();
|
|
addDeckName("NOMONITO");
|
|
}
|
|
const std::string NOMONITO::keywordName = "NOMONITO";
|
|
|
|
|
|
NONNC::NONNC() : ParserKeyword("NONNC", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("NONNC");
|
|
}
|
|
const std::string NONNC::keywordName = "NONNC";
|
|
|
|
|
|
NORSSPEC::NORSSPEC() : ParserKeyword("NORSSPEC", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("NORSSPEC");
|
|
}
|
|
const std::string NORSSPEC::keywordName = "NORSSPEC";
|
|
|
|
|
|
NOSIM::NOSIM() : ParserKeyword("NOSIM", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NOSIM");
|
|
}
|
|
const std::string NOSIM::keywordName = "NOSIM";
|
|
|
|
|
|
NOWARN::NOWARN() : ParserKeyword("NOWARN", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
addValidSectionName("GRID");
|
|
addValidSectionName("EDIT");
|
|
addValidSectionName("PROPS");
|
|
addValidSectionName("REGIONS");
|
|
addValidSectionName("SOLUTION");
|
|
addValidSectionName("SUMMARY");
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NOWARN");
|
|
}
|
|
const std::string NOWARN::keywordName = "NOWARN";
|
|
|
|
|
|
NOWARNEP::NOWARNEP() : ParserKeyword("NOWARNEP", KeywordSize(0, false)) {
|
|
addValidSectionName("PROPS");
|
|
clearDeckNames();
|
|
addDeckName("NOWARNEP");
|
|
}
|
|
const std::string NOWARNEP::keywordName = "NOWARNEP";
|
|
|
|
|
|
NRSOUT::NRSOUT() : ParserKeyword("NRSOUT", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("NRSOUT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("MAX_NUM", ParserItem::itype::INT);
|
|
item.setDefault( 3600 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NRSOUT::keywordName = "NRSOUT";
|
|
const std::string NRSOUT::MAX_NUM::itemName = "MAX_NUM";
|
|
const int NRSOUT::MAX_NUM::defaultValue = 3600;
|
|
|
|
|
|
NSTACK::NSTACK() : ParserKeyword("NSTACK", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NSTACK");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("LINEAR_SOLVER_SIZE", ParserItem::itype::INT);
|
|
item.setDefault( 10 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NSTACK::keywordName = "NSTACK";
|
|
const std::string NSTACK::LINEAR_SOLVER_SIZE::itemName = "LINEAR_SOLVER_SIZE";
|
|
const int NSTACK::LINEAR_SOLVER_SIZE::defaultValue = 10;
|
|
|
|
|
|
NTG::NTG() : ParserKeyword("NTG", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("NTG");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("data", ParserItem::itype::DOUBLE);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
item.push_backDimension("1");
|
|
record.addDataItem(item);
|
|
}
|
|
addDataRecord( record );
|
|
}
|
|
}
|
|
const std::string NTG::keywordName = "NTG";
|
|
const std::string NTG::data::itemName = "data";
|
|
|
|
|
|
NUMRES::NUMRES() : ParserKeyword("NUMRES", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("NUMRES");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("num", ParserItem::itype::INT);
|
|
item.setDefault( 1 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NUMRES::keywordName = "NUMRES";
|
|
const std::string NUMRES::num::itemName = "num";
|
|
const int NUMRES::num::defaultValue = 1;
|
|
|
|
|
|
NUPCOL::NUPCOL() : ParserKeyword("NUPCOL", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NUPCOL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("NUM_ITER", ParserItem::itype::INT);
|
|
item.setDefault( 12 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NUPCOL::keywordName = "NUPCOL";
|
|
const std::string NUPCOL::NUM_ITER::itemName = "NUM_ITER";
|
|
const int NUPCOL::NUM_ITER::defaultValue = 12;
|
|
|
|
|
|
NWATREM::NWATREM() : ParserKeyword("NWATREM", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("NWATREM");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("NODE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WAX_RATE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(10000000000000000159028911097599180468360808563945281389781327557747838772170381060813469985856815104.000000) );
|
|
item.push_backDimension("LiquidSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_FRAC_REMOVAL", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string NWATREM::keywordName = "NWATREM";
|
|
const std::string NWATREM::NODE::itemName = "NODE";
|
|
const std::string NWATREM::WAX_RATE::itemName = "WAX_RATE";
|
|
const double NWATREM::WAX_RATE::defaultValue = 10000000000000000159028911097599180468360808563945281389781327557747838772170381060813469985856815104.000000;
|
|
const std::string NWATREM::MAX_FRAC_REMOVAL::itemName = "MAX_FRAC_REMOVAL";
|
|
const double NWATREM::MAX_FRAC_REMOVAL::defaultValue = 1.000000;
|
|
|
|
|
|
NXFIN::NXFIN() : ParserKeyword("NXFIN", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("NXFIN");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("data", ParserItem::itype::INT);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addDataItem(item);
|
|
}
|
|
addDataRecord( record );
|
|
}
|
|
}
|
|
const std::string NXFIN::keywordName = "NXFIN";
|
|
const std::string NXFIN::data::itemName = "data";
|
|
|
|
|
|
NYFIN::NYFIN() : ParserKeyword("NYFIN", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("NYFIN");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("data", ParserItem::itype::INT);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addDataItem(item);
|
|
}
|
|
addDataRecord( record );
|
|
}
|
|
}
|
|
const std::string NYFIN::keywordName = "NYFIN";
|
|
const std::string NYFIN::data::itemName = "data";
|
|
|
|
|
|
NZFIN::NZFIN() : ParserKeyword("NZFIN", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("NZFIN");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("data", ParserItem::itype::INT);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addDataItem(item);
|
|
}
|
|
addDataRecord( record );
|
|
}
|
|
}
|
|
const std::string NZFIN::keywordName = "NZFIN";
|
|
const std::string NZFIN::data::itemName = "data";
|
|
|
|
|
|
}
|
|
}
|