mirror of
https://github.com/OPM/ResInsight.git
synced 2025-01-20 21:43:20 -06:00
7a0bfd4917
* Adjustments to build system for opm-common * Add opm-common as submodule * Disable use of unity build for opm-common
1504 lines
46 KiB
C++
1504 lines
46 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/M.hpp>
|
|
namespace Opm {
|
|
namespace ParserKeywords {
|
|
MAPAXES::MAPAXES() : ParserKeyword("MAPAXES", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("MAPAXES");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("data", ParserItem::itype::DOUBLE);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
item.push_backDimension("Length");
|
|
record.addDataItem(item);
|
|
}
|
|
addDataRecord( record );
|
|
}
|
|
}
|
|
const std::string MAPAXES::keywordName = "MAPAXES";
|
|
const std::string MAPAXES::data::itemName = "data";
|
|
|
|
|
|
MAPUNITS::MAPUNITS() : ParserKeyword("MAPUNITS", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("MAPUNITS");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("UNIT", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("METRES") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MAPUNITS::keywordName = "MAPUNITS";
|
|
const std::string MAPUNITS::UNIT::itemName = "UNIT";
|
|
const std::string MAPUNITS::UNIT::defaultValue = "METRES";
|
|
|
|
|
|
MASSFLOW::MASSFLOW() : ParserKeyword("MASSFLOW", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("PROPS");
|
|
clearDeckNames();
|
|
addDeckName("MASSFLOW");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WORD", ParserItem::itype::STRING);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MASSFLOW::keywordName = "MASSFLOW";
|
|
const std::string MASSFLOW::WORD::itemName = "WORD";
|
|
|
|
|
|
MATCORR::MATCORR() : ParserKeyword("MATCORR", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("MATCORR");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("NEWTON_IT_NUM", ParserItem::itype::INT);
|
|
item.setDefault( 12 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NON_LIN_CONV_ERR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.010000) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MATERIAL_BALANCE_ERR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1e-06) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MATCORR::keywordName = "MATCORR";
|
|
const std::string MATCORR::NEWTON_IT_NUM::itemName = "NEWTON_IT_NUM";
|
|
const int MATCORR::NEWTON_IT_NUM::defaultValue = 12;
|
|
const std::string MATCORR::NON_LIN_CONV_ERR::itemName = "NON_LIN_CONV_ERR";
|
|
const double MATCORR::NON_LIN_CONV_ERR::defaultValue = 0.010000;
|
|
const std::string MATCORR::MATERIAL_BALANCE_ERR::itemName = "MATERIAL_BALANCE_ERR";
|
|
const double MATCORR::MATERIAL_BALANCE_ERR::defaultValue = 1e-06;
|
|
|
|
|
|
MAXVALUE::MAXVALUE() : ParserKeyword("MAXVALUE", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("GRID");
|
|
addValidSectionName("EDIT");
|
|
addValidSectionName("PROPS");
|
|
clearDeckNames();
|
|
addDeckName("MAXVALUE");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("field", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("value", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MAXVALUE::keywordName = "MAXVALUE";
|
|
const std::string MAXVALUE::field::itemName = "field";
|
|
const std::string MAXVALUE::value::itemName = "value";
|
|
const std::string MAXVALUE::I1::itemName = "I1";
|
|
const std::string MAXVALUE::I2::itemName = "I2";
|
|
const std::string MAXVALUE::J1::itemName = "J1";
|
|
const std::string MAXVALUE::J2::itemName = "J2";
|
|
const std::string MAXVALUE::K1::itemName = "K1";
|
|
const std::string MAXVALUE::K2::itemName = "K2";
|
|
|
|
|
|
MEMORY::MEMORY() : ParserKeyword("MEMORY", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("MEMORY");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("UNUSED", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("THOUSANDS_CHAR8", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MEMORY::keywordName = "MEMORY";
|
|
const std::string MEMORY::UNUSED::itemName = "UNUSED";
|
|
const std::string MEMORY::THOUSANDS_CHAR8::itemName = "THOUSANDS_CHAR8";
|
|
|
|
|
|
MESSAGE::MESSAGE() : ParserKeyword("MESSAGE", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
addValidSectionName("PROPS");
|
|
addValidSectionName("EDIT");
|
|
addValidSectionName("GRID");
|
|
addValidSectionName("REGIONS");
|
|
addValidSectionName("SOLUTION");
|
|
addValidSectionName("SUMMARY");
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("MESSAGE");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("MessageText", ParserItem::itype::STRING);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MESSAGE::keywordName = "MESSAGE";
|
|
const std::string MESSAGE::MessageText::itemName = "MessageText";
|
|
|
|
|
|
MESSAGES::MESSAGES() : ParserKeyword("MESSAGES", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
addValidSectionName("PROPS");
|
|
addValidSectionName("EDIT");
|
|
addValidSectionName("GRID");
|
|
addValidSectionName("REGIONS");
|
|
addValidSectionName("SOLUTION");
|
|
addValidSectionName("SUMMARY");
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("MESSAGES");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("MESSAGE_PRINT_LIMIT", ParserItem::itype::INT);
|
|
item.setDefault( 1000000 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("COMMENT_PRINT_LIMIT", ParserItem::itype::INT);
|
|
item.setDefault( 1000000 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WARNING_PRINT_LIMIT", ParserItem::itype::INT);
|
|
item.setDefault( 10000 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PROBLEM_PRINT_LIMIT", ParserItem::itype::INT);
|
|
item.setDefault( 100 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ERROR_PRINT_LIMIT", ParserItem::itype::INT);
|
|
item.setDefault( 100 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("BUG_PRINT_LIMIT", ParserItem::itype::INT);
|
|
item.setDefault( 100 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MESSAGE_STOP_LIMIT", ParserItem::itype::INT);
|
|
item.setDefault( 1000000 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("COMMENT_STOP_LIMIT", ParserItem::itype::INT);
|
|
item.setDefault( 1000000 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WARNING_STOP_LIMIT", ParserItem::itype::INT);
|
|
item.setDefault( 10000 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PROBLEM_STOP_LIMIT", ParserItem::itype::INT);
|
|
item.setDefault( 100 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ERROR_STOP_LIMIT", ParserItem::itype::INT);
|
|
item.setDefault( 10 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("BUG_STOP_LIMIT", ParserItem::itype::INT);
|
|
item.setDefault( 1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GROUP_PRINT_LIMIT", ParserItem::itype::INT);
|
|
item.setDefault( 10 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MESSAGES::keywordName = "MESSAGES";
|
|
const std::string MESSAGES::MESSAGE_PRINT_LIMIT::itemName = "MESSAGE_PRINT_LIMIT";
|
|
const int MESSAGES::MESSAGE_PRINT_LIMIT::defaultValue = 1000000;
|
|
const std::string MESSAGES::COMMENT_PRINT_LIMIT::itemName = "COMMENT_PRINT_LIMIT";
|
|
const int MESSAGES::COMMENT_PRINT_LIMIT::defaultValue = 1000000;
|
|
const std::string MESSAGES::WARNING_PRINT_LIMIT::itemName = "WARNING_PRINT_LIMIT";
|
|
const int MESSAGES::WARNING_PRINT_LIMIT::defaultValue = 10000;
|
|
const std::string MESSAGES::PROBLEM_PRINT_LIMIT::itemName = "PROBLEM_PRINT_LIMIT";
|
|
const int MESSAGES::PROBLEM_PRINT_LIMIT::defaultValue = 100;
|
|
const std::string MESSAGES::ERROR_PRINT_LIMIT::itemName = "ERROR_PRINT_LIMIT";
|
|
const int MESSAGES::ERROR_PRINT_LIMIT::defaultValue = 100;
|
|
const std::string MESSAGES::BUG_PRINT_LIMIT::itemName = "BUG_PRINT_LIMIT";
|
|
const int MESSAGES::BUG_PRINT_LIMIT::defaultValue = 100;
|
|
const std::string MESSAGES::MESSAGE_STOP_LIMIT::itemName = "MESSAGE_STOP_LIMIT";
|
|
const int MESSAGES::MESSAGE_STOP_LIMIT::defaultValue = 1000000;
|
|
const std::string MESSAGES::COMMENT_STOP_LIMIT::itemName = "COMMENT_STOP_LIMIT";
|
|
const int MESSAGES::COMMENT_STOP_LIMIT::defaultValue = 1000000;
|
|
const std::string MESSAGES::WARNING_STOP_LIMIT::itemName = "WARNING_STOP_LIMIT";
|
|
const int MESSAGES::WARNING_STOP_LIMIT::defaultValue = 10000;
|
|
const std::string MESSAGES::PROBLEM_STOP_LIMIT::itemName = "PROBLEM_STOP_LIMIT";
|
|
const int MESSAGES::PROBLEM_STOP_LIMIT::defaultValue = 100;
|
|
const std::string MESSAGES::ERROR_STOP_LIMIT::itemName = "ERROR_STOP_LIMIT";
|
|
const int MESSAGES::ERROR_STOP_LIMIT::defaultValue = 10;
|
|
const std::string MESSAGES::BUG_STOP_LIMIT::itemName = "BUG_STOP_LIMIT";
|
|
const int MESSAGES::BUG_STOP_LIMIT::defaultValue = 1;
|
|
const std::string MESSAGES::GROUP_PRINT_LIMIT::itemName = "GROUP_PRINT_LIMIT";
|
|
const int MESSAGES::GROUP_PRINT_LIMIT::defaultValue = 10;
|
|
|
|
|
|
MESSOPTS::MESSOPTS() : ParserKeyword("MESSOPTS", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("MESSOPTS");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("MNEMONIC", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEVERITY", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MESSOPTS::keywordName = "MESSOPTS";
|
|
const std::string MESSOPTS::MNEMONIC::itemName = "MNEMONIC";
|
|
const std::string MESSOPTS::SEVERITY::itemName = "SEVERITY";
|
|
|
|
|
|
MESSSRVC::MESSSRVC() : ParserKeyword("MESSSRVC", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("MESSSRVC");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("PRODUCE_MESSAGE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("ON") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MESSSRVC::keywordName = "MESSSRVC";
|
|
const std::string MESSSRVC::PRODUCE_MESSAGE::itemName = "PRODUCE_MESSAGE";
|
|
const std::string MESSSRVC::PRODUCE_MESSAGE::defaultValue = "ON";
|
|
|
|
|
|
METRIC::METRIC() : ParserKeyword("METRIC", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("METRIC");
|
|
}
|
|
const std::string METRIC::keywordName = "METRIC";
|
|
|
|
|
|
MICP::MICP() : ParserKeyword("MICP", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("MICP");
|
|
}
|
|
const std::string MICP::keywordName = "MICP";
|
|
|
|
|
|
MICPPARA::MICPPARA() : ParserKeyword("MICPPARA", KeywordSize(1, false)) {
|
|
addValidSectionName("PROPS");
|
|
clearDeckNames();
|
|
addDeckName("MICPPARA");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("DENSITY_BIOFILM", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(35.000000) );
|
|
item.push_backDimension("Density");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DENSITY_CALCITE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(2710.000000) );
|
|
item.push_backDimension("Density");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DETACHMENT_RATE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(2.6e-10) );
|
|
item.push_backDimension("Length/Viscosity");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CRITICAL_POROSITY", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.100000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FITTING_FACTOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(3.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("HALF_VELOCITY_OXYGEN", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(2e-05) );
|
|
item.push_backDimension("Density");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("HALF_VELOCITY_UREA", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(21.300000) );
|
|
item.push_backDimension("Density");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAXIMUM_GROWTH_RATE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(4.17e-05) );
|
|
item.push_backDimension("1/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAXIMUM_OXYGEN_CONCENTRATION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.040000) );
|
|
item.push_backDimension("Density");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAXIMUM_UREA_CONCENTRATION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(60.000000) );
|
|
item.push_backDimension("Density");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAXIMUM_UREA_UTILIZATION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.016100) );
|
|
item.push_backDimension("1/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MICROBIAL_ATTACHMENT_RATE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(8.51e-07) );
|
|
item.push_backDimension("1/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MICROBIAL_DEATH_RATE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(3.18e-07) );
|
|
item.push_backDimension("1/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MINIMUM_PERMEABILITY", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1e-20) );
|
|
item.push_backDimension("Permeability");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("OXYGEN_CONSUMPTION_FACTOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.500000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TOLERANCE_BEFORE_CLOGGING", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.000100) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("YIELD_GROWTH_COEFFICIENT", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.500000) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MICPPARA::keywordName = "MICPPARA";
|
|
const std::string MICPPARA::DENSITY_BIOFILM::itemName = "DENSITY_BIOFILM";
|
|
const double MICPPARA::DENSITY_BIOFILM::defaultValue = 35.000000;
|
|
const std::string MICPPARA::DENSITY_CALCITE::itemName = "DENSITY_CALCITE";
|
|
const double MICPPARA::DENSITY_CALCITE::defaultValue = 2710.000000;
|
|
const std::string MICPPARA::DETACHMENT_RATE::itemName = "DETACHMENT_RATE";
|
|
const double MICPPARA::DETACHMENT_RATE::defaultValue = 2.6e-10;
|
|
const std::string MICPPARA::CRITICAL_POROSITY::itemName = "CRITICAL_POROSITY";
|
|
const double MICPPARA::CRITICAL_POROSITY::defaultValue = 0.100000;
|
|
const std::string MICPPARA::FITTING_FACTOR::itemName = "FITTING_FACTOR";
|
|
const double MICPPARA::FITTING_FACTOR::defaultValue = 3.000000;
|
|
const std::string MICPPARA::HALF_VELOCITY_OXYGEN::itemName = "HALF_VELOCITY_OXYGEN";
|
|
const double MICPPARA::HALF_VELOCITY_OXYGEN::defaultValue = 2e-05;
|
|
const std::string MICPPARA::HALF_VELOCITY_UREA::itemName = "HALF_VELOCITY_UREA";
|
|
const double MICPPARA::HALF_VELOCITY_UREA::defaultValue = 21.300000;
|
|
const std::string MICPPARA::MAXIMUM_GROWTH_RATE::itemName = "MAXIMUM_GROWTH_RATE";
|
|
const double MICPPARA::MAXIMUM_GROWTH_RATE::defaultValue = 4.17e-05;
|
|
const std::string MICPPARA::MAXIMUM_OXYGEN_CONCENTRATION::itemName = "MAXIMUM_OXYGEN_CONCENTRATION";
|
|
const double MICPPARA::MAXIMUM_OXYGEN_CONCENTRATION::defaultValue = 0.040000;
|
|
const std::string MICPPARA::MAXIMUM_UREA_CONCENTRATION::itemName = "MAXIMUM_UREA_CONCENTRATION";
|
|
const double MICPPARA::MAXIMUM_UREA_CONCENTRATION::defaultValue = 60.000000;
|
|
const std::string MICPPARA::MAXIMUM_UREA_UTILIZATION::itemName = "MAXIMUM_UREA_UTILIZATION";
|
|
const double MICPPARA::MAXIMUM_UREA_UTILIZATION::defaultValue = 0.016100;
|
|
const std::string MICPPARA::MICROBIAL_ATTACHMENT_RATE::itemName = "MICROBIAL_ATTACHMENT_RATE";
|
|
const double MICPPARA::MICROBIAL_ATTACHMENT_RATE::defaultValue = 8.51e-07;
|
|
const std::string MICPPARA::MICROBIAL_DEATH_RATE::itemName = "MICROBIAL_DEATH_RATE";
|
|
const double MICPPARA::MICROBIAL_DEATH_RATE::defaultValue = 3.18e-07;
|
|
const std::string MICPPARA::MINIMUM_PERMEABILITY::itemName = "MINIMUM_PERMEABILITY";
|
|
const double MICPPARA::MINIMUM_PERMEABILITY::defaultValue = 1e-20;
|
|
const std::string MICPPARA::OXYGEN_CONSUMPTION_FACTOR::itemName = "OXYGEN_CONSUMPTION_FACTOR";
|
|
const double MICPPARA::OXYGEN_CONSUMPTION_FACTOR::defaultValue = 0.500000;
|
|
const std::string MICPPARA::TOLERANCE_BEFORE_CLOGGING::itemName = "TOLERANCE_BEFORE_CLOGGING";
|
|
const double MICPPARA::TOLERANCE_BEFORE_CLOGGING::defaultValue = 0.000100;
|
|
const std::string MICPPARA::YIELD_GROWTH_COEFFICIENT::itemName = "YIELD_GROWTH_COEFFICIENT";
|
|
const double MICPPARA::YIELD_GROWTH_COEFFICIENT::defaultValue = 0.500000;
|
|
|
|
|
|
MINNNCT::MINNNCT() : ParserKeyword("MINNNCT", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("MINNNCT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("CUTOFF_TRANSMISSIBILITY", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Transmissibility");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DIFFUSIVITY", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CUTOFF_THERMAL_TRANSMISSIBILITY", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Energy/AbsoluteTemperature*Time");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MINNNCT::keywordName = "MINNNCT";
|
|
const std::string MINNNCT::CUTOFF_TRANSMISSIBILITY::itemName = "CUTOFF_TRANSMISSIBILITY";
|
|
const double MINNNCT::CUTOFF_TRANSMISSIBILITY::defaultValue = 0;
|
|
const std::string MINNNCT::DIFFUSIVITY::itemName = "DIFFUSIVITY";
|
|
const double MINNNCT::DIFFUSIVITY::defaultValue = 0;
|
|
const std::string MINNNCT::CUTOFF_THERMAL_TRANSMISSIBILITY::itemName = "CUTOFF_THERMAL_TRANSMISSIBILITY";
|
|
const double MINNNCT::CUTOFF_THERMAL_TRANSMISSIBILITY::defaultValue = 0;
|
|
|
|
|
|
MINNPCOL::MINNPCOL() : ParserKeyword("MINNPCOL", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("MINNPCOL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("VALUE", ParserItem::itype::INT);
|
|
item.setDefault( 6 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MINNPCOL::keywordName = "MINNPCOL";
|
|
const std::string MINNPCOL::VALUE::itemName = "VALUE";
|
|
const int MINNPCOL::VALUE::defaultValue = 6;
|
|
|
|
|
|
MINPORV::MINPORV() : ParserKeyword("MINPORV", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("MINPORV");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("MIN_PORE_VOL", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1e-06) );
|
|
item.push_backDimension("ReservoirVolume");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MINPORV::keywordName = "MINPORV";
|
|
const std::string MINPORV::MIN_PORE_VOL::itemName = "MIN_PORE_VOL";
|
|
const double MINPORV::MIN_PORE_VOL::defaultValue = 1e-06;
|
|
|
|
|
|
MINPV::MINPV() : ParserKeyword("MINPV", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("MINPV");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("VALUE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1e-06) );
|
|
item.push_backDimension("ReservoirVolume");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MINPV::keywordName = "MINPV";
|
|
const std::string MINPV::VALUE::itemName = "VALUE";
|
|
const double MINPV::VALUE::defaultValue = 1e-06;
|
|
|
|
|
|
MINPVFIL::MINPVFIL() : ParserKeyword("MINPVFIL", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("MINPVFIL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("VALUE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1e-06) );
|
|
item.push_backDimension("ReservoirVolume");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MINPVFIL::keywordName = "MINPVFIL";
|
|
const std::string MINPVFIL::VALUE::itemName = "VALUE";
|
|
const double MINPVFIL::VALUE::defaultValue = 1e-06;
|
|
|
|
|
|
MINPVV::MINPVV() : ParserKeyword("MINPVV", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("MINPVV");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("data", ParserItem::itype::DOUBLE);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
item.setDefault( double(1e-06) );
|
|
item.push_backDimension("ReservoirVolume");
|
|
record.addDataItem(item);
|
|
}
|
|
addDataRecord( record );
|
|
}
|
|
}
|
|
const std::string MINPVV::keywordName = "MINPVV";
|
|
const std::string MINPVV::data::itemName = "data";
|
|
const double MINPVV::data::defaultValue = 1e-06;
|
|
|
|
|
|
MINVALUE::MINVALUE() : ParserKeyword("MINVALUE", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("GRID");
|
|
addValidSectionName("EDIT");
|
|
addValidSectionName("PROPS");
|
|
clearDeckNames();
|
|
addDeckName("MINVALUE");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("field", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("value", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MINVALUE::keywordName = "MINVALUE";
|
|
const std::string MINVALUE::field::itemName = "field";
|
|
const std::string MINVALUE::value::itemName = "value";
|
|
const std::string MINVALUE::I1::itemName = "I1";
|
|
const std::string MINVALUE::I2::itemName = "I2";
|
|
const std::string MINVALUE::J1::itemName = "J1";
|
|
const std::string MINVALUE::J2::itemName = "J2";
|
|
const std::string MINVALUE::K1::itemName = "K1";
|
|
const std::string MINVALUE::K2::itemName = "K2";
|
|
|
|
|
|
MISC::MISC() : ParserKeyword("MISC", KeywordSize("MISCIBLE", "NTMISC", false, 0)) {
|
|
addValidSectionName("PROPS");
|
|
clearDeckNames();
|
|
addDeckName("MISC");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("DATA", ParserItem::itype::DOUBLE);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
item.push_backDimension("1");
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MISC::keywordName = "MISC";
|
|
const std::string MISC::DATA::itemName = "DATA";
|
|
|
|
|
|
MISCIBLE::MISCIBLE() : ParserKeyword("MISCIBLE", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("MISCIBLE");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("NTMISC", ParserItem::itype::INT);
|
|
item.setDefault( 1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NSMISC", ParserItem::itype::INT);
|
|
item.setDefault( 20 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TWOPOINT", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NONE") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MISCIBLE::keywordName = "MISCIBLE";
|
|
const std::string MISCIBLE::NTMISC::itemName = "NTMISC";
|
|
const int MISCIBLE::NTMISC::defaultValue = 1;
|
|
const std::string MISCIBLE::NSMISC::itemName = "NSMISC";
|
|
const int MISCIBLE::NSMISC::defaultValue = 20;
|
|
const std::string MISCIBLE::TWOPOINT::itemName = "TWOPOINT";
|
|
const std::string MISCIBLE::TWOPOINT::defaultValue = "NONE";
|
|
|
|
|
|
MISCNUM::MISCNUM() : ParserKeyword("MISCNUM", KeywordSize(1, false)) {
|
|
addValidSectionName("REGIONS");
|
|
clearDeckNames();
|
|
addDeckName("MISCNUM");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("data", ParserItem::itype::INT);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addDataItem(item);
|
|
}
|
|
addDataRecord( record );
|
|
}
|
|
}
|
|
const std::string MISCNUM::keywordName = "MISCNUM";
|
|
const std::string MISCNUM::data::itemName = "data";
|
|
|
|
|
|
MLANG::MLANG() : ParserKeyword("MLANG", KeywordSize(1, false)) {
|
|
addValidSectionName("PROPS");
|
|
clearDeckNames();
|
|
addDeckName("MLANG");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("data", ParserItem::itype::DOUBLE);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
item.push_backDimension("GasSurfaceVolume/Length*Length*Length");
|
|
record.addDataItem(item);
|
|
}
|
|
addDataRecord( record );
|
|
}
|
|
}
|
|
const std::string MLANG::keywordName = "MLANG";
|
|
const std::string MLANG::data::itemName = "data";
|
|
|
|
|
|
MLANGSLV::MLANGSLV() : ParserKeyword("MLANGSLV", KeywordSize(1, false)) {
|
|
addValidSectionName("PROPS");
|
|
clearDeckNames();
|
|
addDeckName("MLANGSLV");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("data", ParserItem::itype::DOUBLE);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
item.push_backDimension("GasSurfaceVolume/Length*Length*Length");
|
|
record.addDataItem(item);
|
|
}
|
|
addDataRecord( record );
|
|
}
|
|
}
|
|
const std::string MLANGSLV::keywordName = "MLANGSLV";
|
|
const std::string MLANGSLV::data::itemName = "data";
|
|
|
|
|
|
MONITOR::MONITOR() : ParserKeyword("MONITOR", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
addValidSectionName("SUMMARY");
|
|
clearDeckNames();
|
|
addDeckName("MONITOR");
|
|
}
|
|
const std::string MONITOR::keywordName = "MONITOR";
|
|
|
|
|
|
MPFANUM::MPFANUM() : ParserKeyword("MPFANUM", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("MPFANUM");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("data", ParserItem::itype::INT);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addDataItem(item);
|
|
}
|
|
addDataRecord( record );
|
|
}
|
|
}
|
|
const std::string MPFANUM::keywordName = "MPFANUM";
|
|
const std::string MPFANUM::data::itemName = "data";
|
|
|
|
|
|
MPFNNC::MPFNNC() : ParserKeyword("MPFNNC", KeywordSize(DOUBLE_SLASH_TERMINATED)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("MPFNNC");
|
|
setDoubleRecordsKeyword(true);
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("IX", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("IY", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("IZ", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("JX", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("JY", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("JZ", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TRANP", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Transmissibility");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("KX", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("KY", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("KZ", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TRANS", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Transmissibility");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MPFNNC::keywordName = "MPFNNC";
|
|
const std::string MPFNNC::IX::itemName = "IX";
|
|
const std::string MPFNNC::IY::itemName = "IY";
|
|
const std::string MPFNNC::IZ::itemName = "IZ";
|
|
const std::string MPFNNC::JX::itemName = "JX";
|
|
const std::string MPFNNC::JY::itemName = "JY";
|
|
const std::string MPFNNC::JZ::itemName = "JZ";
|
|
const std::string MPFNNC::TRANP::itemName = "TRANP";
|
|
const std::string MPFNNC::KX::itemName = "KX";
|
|
const std::string MPFNNC::KY::itemName = "KY";
|
|
const std::string MPFNNC::KZ::itemName = "KZ";
|
|
const std::string MPFNNC::TRANS::itemName = "TRANS";
|
|
|
|
|
|
MSFN::MSFN() : ParserKeyword("MSFN", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
|
|
addValidSectionName("PROPS");
|
|
clearDeckNames();
|
|
addDeckName("MSFN");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("DATA", ParserItem::itype::DOUBLE);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
item.push_backDimension("1");
|
|
item.push_backDimension("1");
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MSFN::keywordName = "MSFN";
|
|
const std::string MSFN::DATA::itemName = "DATA";
|
|
|
|
|
|
MSGFILE::MSGFILE() : ParserKeyword("MSGFILE", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("MSGFILE");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("ENABLE_FLAG", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MSGFILE::keywordName = "MSGFILE";
|
|
const std::string MSGFILE::ENABLE_FLAG::itemName = "ENABLE_FLAG";
|
|
|
|
|
|
MSUM_PROBE::MSUM_PROBE() : ParserKeyword("MSUM_PROBE", KeywordSize(0, false)) {
|
|
addValidSectionName("SUMMARY");
|
|
clearDeckNames();
|
|
addDeckName("MSUMLINP");
|
|
addDeckName("MSUMLINS");
|
|
addDeckName("MSUMCOMM");
|
|
addDeckName("MSUMBUG");
|
|
addDeckName("MSUMERR");
|
|
addDeckName("MSUMMESS");
|
|
addDeckName("MSUMNEWT");
|
|
addDeckName("MSUMPROB");
|
|
addDeckName("MSUMWARN");
|
|
}
|
|
const std::string MSUM_PROBE::keywordName = "MSUM_PROBE";
|
|
|
|
|
|
MULSGGD::MULSGGD() : ParserKeyword("MULSGGD", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("MULSGGD");
|
|
{
|
|
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 MULSGGD::keywordName = "MULSGGD";
|
|
const std::string MULSGGD::data::itemName = "data";
|
|
|
|
|
|
MULSGGDV::MULSGGDV() : ParserKeyword("MULSGGDV", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("MULSGGDV");
|
|
{
|
|
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 MULSGGDV::keywordName = "MULSGGDV";
|
|
const std::string MULSGGDV::data::itemName = "data";
|
|
|
|
|
|
MULTFLT::MULTFLT() : ParserKeyword("MULTFLT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("EDIT");
|
|
addValidSectionName("GRID");
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("MULTFLT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("fault", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("factor", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MULTFLT::keywordName = "MULTFLT";
|
|
const std::string MULTFLT::fault::itemName = "fault";
|
|
const std::string MULTFLT::factor::itemName = "factor";
|
|
|
|
|
|
MULTIN::MULTIN() : ParserKeyword("MULTIN", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("MULTIN");
|
|
}
|
|
const std::string MULTIN::keywordName = "MULTIN";
|
|
|
|
|
|
MULTIPLY::MULTIPLY() : ParserKeyword("MULTIPLY", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("PROPS");
|
|
addValidSectionName("EDIT");
|
|
addValidSectionName("GRID");
|
|
addValidSectionName("REGIONS");
|
|
addValidSectionName("SOLUTION");
|
|
clearDeckNames();
|
|
addDeckName("MULTIPLY");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("field", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("factor", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MULTIPLY::keywordName = "MULTIPLY";
|
|
const std::string MULTIPLY::field::itemName = "field";
|
|
const std::string MULTIPLY::factor::itemName = "factor";
|
|
const std::string MULTIPLY::I1::itemName = "I1";
|
|
const std::string MULTIPLY::I2::itemName = "I2";
|
|
const std::string MULTIPLY::J1::itemName = "J1";
|
|
const std::string MULTIPLY::J2::itemName = "J2";
|
|
const std::string MULTIPLY::K1::itemName = "K1";
|
|
const std::string MULTIPLY::K2::itemName = "K2";
|
|
|
|
|
|
MULTIREG::MULTIREG() : ParserKeyword("MULTIREG", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("PROPS");
|
|
addValidSectionName("EDIT");
|
|
addValidSectionName("GRID");
|
|
addValidSectionName("REGIONS");
|
|
addValidSectionName("SOLUTION");
|
|
clearDeckNames();
|
|
addDeckName("MULTIREG");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("ARRAY", ParserItem::itype::STRING);
|
|
item.setDescription("The 3D array we will update");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FACTOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.setDescription("The value we will multiply with");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("REGION_NUMBER", ParserItem::itype::INT);
|
|
item.setDescription("The region number we are interested in");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("REGION_NAME", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("M") );
|
|
item.setDescription("The name of the region we are interested in");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MULTIREG::keywordName = "MULTIREG";
|
|
const std::string MULTIREG::ARRAY::itemName = "ARRAY";
|
|
const std::string MULTIREG::FACTOR::itemName = "FACTOR";
|
|
const double MULTIREG::FACTOR::defaultValue = 0;
|
|
const std::string MULTIREG::REGION_NUMBER::itemName = "REGION_NUMBER";
|
|
const std::string MULTIREG::REGION_NAME::itemName = "REGION_NAME";
|
|
const std::string MULTIREG::REGION_NAME::defaultValue = "M";
|
|
|
|
|
|
MULTNUM::MULTNUM() : ParserKeyword("MULTNUM", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("MULTNUM");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("data", ParserItem::itype::INT);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addDataItem(item);
|
|
}
|
|
addDataRecord( record );
|
|
}
|
|
}
|
|
const std::string MULTNUM::keywordName = "MULTNUM";
|
|
const std::string MULTNUM::data::itemName = "data";
|
|
|
|
|
|
MULTOUT::MULTOUT() : ParserKeyword("MULTOUT", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("MULTOUT");
|
|
}
|
|
const std::string MULTOUT::keywordName = "MULTOUT";
|
|
|
|
|
|
MULTOUTS::MULTOUTS() : ParserKeyword("MULTOUTS", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("MULTOUTS");
|
|
}
|
|
const std::string MULTOUTS::keywordName = "MULTOUTS";
|
|
|
|
|
|
MULTPV::MULTPV() : ParserKeyword("MULTPV", KeywordSize(1, false)) {
|
|
addValidSectionName("EDIT");
|
|
addValidSectionName("GRID");
|
|
clearDeckNames();
|
|
addDeckName("MULTPV");
|
|
{
|
|
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 MULTPV::keywordName = "MULTPV";
|
|
const std::string MULTPV::data::itemName = "data";
|
|
|
|
|
|
MULTREAL::MULTREAL() : ParserKeyword("MULTREAL", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("MULTREAL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("SESSION_SPEC", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STANDARD_LICENCE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("YES") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MULTREAL::keywordName = "MULTREAL";
|
|
const std::string MULTREAL::SESSION_SPEC::itemName = "SESSION_SPEC";
|
|
const std::string MULTREAL::STANDARD_LICENCE::itemName = "STANDARD_LICENCE";
|
|
const std::string MULTREAL::STANDARD_LICENCE::defaultValue = "YES";
|
|
|
|
|
|
MULTREGD::MULTREGD() : ParserKeyword("MULTREGD", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("GRID");
|
|
addValidSectionName("EDIT");
|
|
clearDeckNames();
|
|
addDeckName("MULTREGD");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("FROM_REGION", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TO_REGION", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MULTIPLIER", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DIRECTION", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("XYZ") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FLAG", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("ALL") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CHOICE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("M") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MULTREGD::keywordName = "MULTREGD";
|
|
const std::string MULTREGD::FROM_REGION::itemName = "FROM_REGION";
|
|
const std::string MULTREGD::TO_REGION::itemName = "TO_REGION";
|
|
const std::string MULTREGD::MULTIPLIER::itemName = "MULTIPLIER";
|
|
const std::string MULTREGD::DIRECTION::itemName = "DIRECTION";
|
|
const std::string MULTREGD::DIRECTION::defaultValue = "XYZ";
|
|
const std::string MULTREGD::FLAG::itemName = "FLAG";
|
|
const std::string MULTREGD::FLAG::defaultValue = "ALL";
|
|
const std::string MULTREGD::CHOICE::itemName = "CHOICE";
|
|
const std::string MULTREGD::CHOICE::defaultValue = "M";
|
|
|
|
|
|
MULTREGH::MULTREGH() : ParserKeyword("MULTREGH", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("GRID");
|
|
addValidSectionName("EDIT");
|
|
clearDeckNames();
|
|
addDeckName("MULTREGH");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("FROM_REGION", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TO_REGION", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MULTIPLIER", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DIRECTION", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("XYZ") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FLAG", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("ALL") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CHOICE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("M") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MULTREGH::keywordName = "MULTREGH";
|
|
const std::string MULTREGH::FROM_REGION::itemName = "FROM_REGION";
|
|
const std::string MULTREGH::TO_REGION::itemName = "TO_REGION";
|
|
const std::string MULTREGH::MULTIPLIER::itemName = "MULTIPLIER";
|
|
const std::string MULTREGH::DIRECTION::itemName = "DIRECTION";
|
|
const std::string MULTREGH::DIRECTION::defaultValue = "XYZ";
|
|
const std::string MULTREGH::FLAG::itemName = "FLAG";
|
|
const std::string MULTREGH::FLAG::defaultValue = "ALL";
|
|
const std::string MULTREGH::CHOICE::itemName = "CHOICE";
|
|
const std::string MULTREGH::CHOICE::defaultValue = "M";
|
|
|
|
|
|
MULTREGP::MULTREGP() : ParserKeyword("MULTREGP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("GRID");
|
|
addValidSectionName("EDIT");
|
|
clearDeckNames();
|
|
addDeckName("MULTREGP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("REGION", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MULTIPLIER", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("REGION_TYPE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("M") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MULTREGP::keywordName = "MULTREGP";
|
|
const std::string MULTREGP::REGION::itemName = "REGION";
|
|
const std::string MULTREGP::MULTIPLIER::itemName = "MULTIPLIER";
|
|
const std::string MULTREGP::REGION_TYPE::itemName = "REGION_TYPE";
|
|
const std::string MULTREGP::REGION_TYPE::defaultValue = "M";
|
|
|
|
|
|
MULTREGT::MULTREGT() : ParserKeyword("MULTREGT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("GRID");
|
|
addValidSectionName("EDIT");
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("MULTREGT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("SRC_REGION", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TARGET_REGION", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TRAN_MULT", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DIRECTIONS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("XYZ") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NNC_MULT", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("ALL") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("REGION_DEF", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("M") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MULTREGT::keywordName = "MULTREGT";
|
|
const std::string MULTREGT::SRC_REGION::itemName = "SRC_REGION";
|
|
const std::string MULTREGT::TARGET_REGION::itemName = "TARGET_REGION";
|
|
const std::string MULTREGT::TRAN_MULT::itemName = "TRAN_MULT";
|
|
const std::string MULTREGT::DIRECTIONS::itemName = "DIRECTIONS";
|
|
const std::string MULTREGT::DIRECTIONS::defaultValue = "XYZ";
|
|
const std::string MULTREGT::NNC_MULT::itemName = "NNC_MULT";
|
|
const std::string MULTREGT::NNC_MULT::defaultValue = "ALL";
|
|
const std::string MULTREGT::REGION_DEF::itemName = "REGION_DEF";
|
|
const std::string MULTREGT::REGION_DEF::defaultValue = "M";
|
|
|
|
|
|
MULTSIG::MULTSIG() : ParserKeyword("MULTSIG", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("MULTSIG");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("VALUE", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MULTSIG::keywordName = "MULTSIG";
|
|
const std::string MULTSIG::VALUE::itemName = "VALUE";
|
|
|
|
|
|
MULTSIGV::MULTSIGV() : ParserKeyword("MULTSIGV", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("MULTSIGV");
|
|
{
|
|
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 MULTSIGV::keywordName = "MULTSIGV";
|
|
const std::string MULTSIGV::data::itemName = "data";
|
|
|
|
|
|
MULT_XYZ::MULT_XYZ() : ParserKeyword("MULT_XYZ", KeywordSize(1, false)) {
|
|
addValidSectionName("GRID");
|
|
addValidSectionName("EDIT");
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("MULTY-");
|
|
addDeckName("MULTX");
|
|
addDeckName("MULTTHT");
|
|
addDeckName("MULTX-");
|
|
addDeckName("MULTTHT-");
|
|
addDeckName("MULTR");
|
|
addDeckName("MULTR-");
|
|
addDeckName("MULTY");
|
|
addDeckName("MULTZ");
|
|
addDeckName("MULTZ-");
|
|
{
|
|
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 MULT_XYZ::keywordName = "MULT_XYZ";
|
|
const std::string MULT_XYZ::data::itemName = "data";
|
|
|
|
|
|
MW::MW() : ParserKeyword("MW", KeywordSize("TABDIMS", "NUM_STATE_EQ", false, 0)) {
|
|
addValidSectionName("PROPS");
|
|
clearDeckNames();
|
|
addDeckName("MW");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("MOLAR_WEIGHT", ParserItem::itype::DOUBLE);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MW::keywordName = "MW";
|
|
const std::string MW::MOLAR_WEIGHT::itemName = "MOLAR_WEIGHT";
|
|
|
|
|
|
MWS::MWS() : ParserKeyword("MWS", KeywordSize("TABDIMS", "NUM_STATE_EQ", false, 0)) {
|
|
addValidSectionName("PROPS");
|
|
clearDeckNames();
|
|
addDeckName("MWS");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("MOLAR_WEIGHT", ParserItem::itype::DOUBLE);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string MWS::keywordName = "MWS";
|
|
const std::string MWS::MOLAR_WEIGHT::itemName = "MOLAR_WEIGHT";
|
|
|
|
|
|
}
|
|
}
|