mirror of
https://github.com/OPM/ResInsight.git
synced 2026-11-02 09:00:14 -06:00
Magne Sjaastad
a0a0919681
Update opm-common based on latest main branch Use branch https://github.com/CeetronSolutions/opm-common/tree/development-01 Update generated opm-common files
5978 lines
187 KiB
C++
5978 lines
187 KiB
C++
// Generated code. Please do not edit this file directly.
|
|
|
|
#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/W.hpp>
|
|
|
|
namespace Opm::ParserKeywords {
|
|
WAGHYSTR::WAGHYSTR() : ParserKeyword("WAGHYSTR", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
|
|
addValidSectionName("PROPS");
|
|
clearDeckNames();
|
|
addDeckName("WAGHYSTR");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("LANDS_PARAMETER", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SECONDARY_DRAINAGE_REDUCTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GAS_MODEL", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("YES") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("RES_OIL", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("YES") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WATER_MODEL", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("YES") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("IMB_LINEAR_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.100000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("THREEPHASE_SAT_LIMIT", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.001000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("RES_OIL_MOD_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WAGHYSTR::keywordName = "WAGHYSTR";
|
|
const std::string WAGHYSTR::LANDS_PARAMETER::itemName = "LANDS_PARAMETER";
|
|
const std::string WAGHYSTR::SECONDARY_DRAINAGE_REDUCTION::itemName = "SECONDARY_DRAINAGE_REDUCTION";
|
|
const std::string WAGHYSTR::GAS_MODEL::itemName = "GAS_MODEL";
|
|
const std::string WAGHYSTR::GAS_MODEL::defaultValue = "YES";
|
|
const std::string WAGHYSTR::RES_OIL::itemName = "RES_OIL";
|
|
const std::string WAGHYSTR::RES_OIL::defaultValue = "YES";
|
|
const std::string WAGHYSTR::WATER_MODEL::itemName = "WATER_MODEL";
|
|
const std::string WAGHYSTR::WATER_MODEL::defaultValue = "YES";
|
|
const std::string WAGHYSTR::IMB_LINEAR_FRACTION::itemName = "IMB_LINEAR_FRACTION";
|
|
const std::string WAGHYSTR::THREEPHASE_SAT_LIMIT::itemName = "THREEPHASE_SAT_LIMIT";
|
|
const std::string WAGHYSTR::RES_OIL_MOD_FRACTION::itemName = "RES_OIL_MOD_FRACTION";
|
|
|
|
|
|
WAITBAL::WAITBAL() : ParserKeyword("WAITBAL", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WAITBAL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WAIT_NETWORK_BALANCE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WAITBAL::keywordName = "WAITBAL";
|
|
const std::string WAITBAL::WAIT_NETWORK_BALANCE::itemName = "WAIT_NETWORK_BALANCE";
|
|
const std::string WAITBAL::WAIT_NETWORK_BALANCE::defaultValue = "NO";
|
|
|
|
|
|
WALKALIN::WALKALIN() : ParserKeyword("WALKALIN", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WALKALIN");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ALKALINE_CONCENTRAION", ParserItem::itype::UDA);
|
|
item.push_backDimension("Mass/LiquidSurfaceVolume");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WALKALIN::keywordName = "WALKALIN";
|
|
const std::string WALKALIN::WELL::itemName = "WELL";
|
|
const std::string WALKALIN::ALKALINE_CONCENTRAION::itemName = "ALKALINE_CONCENTRAION";
|
|
|
|
|
|
WALQCALC::WALQCALC() : ParserKeyword("WALQCALC", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WALQCALC");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ALQ_DEF", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NONE") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WALQCALC::keywordName = "WALQCALC";
|
|
const std::string WALQCALC::WELL::itemName = "WELL";
|
|
const std::string WALQCALC::ALQ_DEF::itemName = "ALQ_DEF";
|
|
const std::string WALQCALC::ALQ_DEF::defaultValue = "NONE";
|
|
|
|
|
|
WAPI::WAPI() : ParserKeyword("WAPI", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WAPI");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("API", ParserItem::itype::UDA);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WAPI::keywordName = "WAPI";
|
|
const std::string WAPI::WELL::itemName = "WELL";
|
|
const std::string WAPI::API::itemName = "API";
|
|
|
|
|
|
WARN::WARN() : ParserKeyword("WARN", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
addValidSectionName("GRID");
|
|
addValidSectionName("EDIT");
|
|
addValidSectionName("PROPS");
|
|
addValidSectionName("REGIONS");
|
|
addValidSectionName("SOLUTION");
|
|
addValidSectionName("SUMMARY");
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WARN");
|
|
}
|
|
const std::string WARN::keywordName = "WARN";
|
|
|
|
|
|
WATDENT::WATDENT() : ParserKeyword("WATDENT", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
|
|
addValidSectionName("PROPS");
|
|
clearDeckNames();
|
|
addDeckName("WATDENT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("REFERENCE_TEMPERATURE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(293.150000) );
|
|
item.push_backDimension("AbsoluteTemperature");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("EXPANSION_COEFF_LINEAR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.000300) );
|
|
item.push_backDimension("1/AbsoluteTemperature");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("EXPANSION_COEFF_QUADRATIC", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(3e-06) );
|
|
item.push_backDimension("1/AbsoluteTemperature*AbsoluteTemperature");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WATDENT::keywordName = "WATDENT";
|
|
const std::string WATDENT::REFERENCE_TEMPERATURE::itemName = "REFERENCE_TEMPERATURE";
|
|
const std::string WATDENT::EXPANSION_COEFF_LINEAR::itemName = "EXPANSION_COEFF_LINEAR";
|
|
const std::string WATDENT::EXPANSION_COEFF_QUADRATIC::itemName = "EXPANSION_COEFF_QUADRATIC";
|
|
|
|
|
|
WATER::WATER() : ParserKeyword("WATER", KeywordSize(0, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("WATER");
|
|
}
|
|
const std::string WATER::keywordName = "WATER";
|
|
|
|
|
|
WATJT::WATJT() : ParserKeyword("WATJT", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
|
|
addValidSectionName("PROPS");
|
|
clearDeckNames();
|
|
addDeckName("WATJT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("PREF", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.013200) );
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("JOULE_THOMSON_COEFFICIENT", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("AbsoluteTemperature/Pressure");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WATJT::keywordName = "WATJT";
|
|
const std::string WATJT::PREF::itemName = "PREF";
|
|
const std::string WATJT::JOULE_THOMSON_COEFFICIENT::itemName = "JOULE_THOMSON_COEFFICIENT";
|
|
|
|
|
|
WATVISCT::WATVISCT() : ParserKeyword("WATVISCT", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
|
|
addValidSectionName("PROPS");
|
|
clearDeckNames();
|
|
addDeckName("WATVISCT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("DATA", ParserItem::itype::DOUBLE);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
item.push_backDimension("Temperature");
|
|
item.push_backDimension("Viscosity");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WATVISCT::keywordName = "WATVISCT";
|
|
const std::string WATVISCT::DATA::itemName = "DATA";
|
|
|
|
|
|
WBHGLR::WBHGLR() : ParserKeyword("WBHGLR", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WBHGLR");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_GLR_CUTBACK", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(100000000000000000000.000000) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MIN_GLR_CUTBACK_REVERSE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(100000000000000000000.000000) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("RATE_CUTBACK_FACTOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PHASE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("RESV") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_GLR_ELIMIT", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(100000000000000000000.000000) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WORKOVER_ACTION", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NONE") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WORKOVER_REMOVE_CUTBACKS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WBHGLR::keywordName = "WBHGLR";
|
|
const std::string WBHGLR::WELL::itemName = "WELL";
|
|
const std::string WBHGLR::MAX_GLR_CUTBACK::itemName = "MAX_GLR_CUTBACK";
|
|
const std::string WBHGLR::MIN_GLR_CUTBACK_REVERSE::itemName = "MIN_GLR_CUTBACK_REVERSE";
|
|
const std::string WBHGLR::RATE_CUTBACK_FACTOR::itemName = "RATE_CUTBACK_FACTOR";
|
|
const std::string WBHGLR::PHASE::itemName = "PHASE";
|
|
const std::string WBHGLR::PHASE::defaultValue = "RESV";
|
|
const std::string WBHGLR::MAX_GLR_ELIMIT::itemName = "MAX_GLR_ELIMIT";
|
|
const std::string WBHGLR::WORKOVER_ACTION::itemName = "WORKOVER_ACTION";
|
|
const std::string WBHGLR::WORKOVER_ACTION::defaultValue = "NONE";
|
|
const std::string WBHGLR::WORKOVER_REMOVE_CUTBACKS::itemName = "WORKOVER_REMOVE_CUTBACKS";
|
|
const std::string WBHGLR::WORKOVER_REMOVE_CUTBACKS::defaultValue = "NO";
|
|
|
|
|
|
WBOREVOL::WBOREVOL() : ParserKeyword("WBOREVOL", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WBOREVOL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WELLBORE_VOL", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1e-05) );
|
|
item.push_backDimension("Length*Length*Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("START_BHP", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WBOREVOL::keywordName = "WBOREVOL";
|
|
const std::string WBOREVOL::WELL::itemName = "WELL";
|
|
const std::string WBOREVOL::WELLBORE_VOL::itemName = "WELLBORE_VOL";
|
|
const std::string WBOREVOL::START_BHP::itemName = "START_BHP";
|
|
|
|
|
|
WCALCVAL::WCALCVAL() : ParserKeyword("WCALCVAL", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WCALCVAL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CALORIFIC_GAS_VALUE", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Energy/GasSurfaceVolume");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WCALCVAL::keywordName = "WCALCVAL";
|
|
const std::string WCALCVAL::WELL::itemName = "WELL";
|
|
const std::string WCALCVAL::CALORIFIC_GAS_VALUE::itemName = "CALORIFIC_GAS_VALUE";
|
|
|
|
|
|
WCONHIST::WCONHIST() : ParserKeyword("WCONHIST", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WCONHIST");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STATUS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("OPEN") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CMODE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ORAT", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("LiquidSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WRAT", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("LiquidSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GRAT", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("GasSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VFP_TABLE", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ALQ", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("THP", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("BHP", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WGASRAT_HIS", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("GasSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NGLRAT_HIS", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("LiquidSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WCONHIST::keywordName = "WCONHIST";
|
|
const std::string WCONHIST::WELL::itemName = "WELL";
|
|
const std::string WCONHIST::STATUS::itemName = "STATUS";
|
|
const std::string WCONHIST::STATUS::defaultValue = "OPEN";
|
|
const std::string WCONHIST::CMODE::itemName = "CMODE";
|
|
const std::string WCONHIST::ORAT::itemName = "ORAT";
|
|
const UDAValue WCONHIST::ORAT::defaultValue = UDAValue(0);
|
|
const std::string WCONHIST::WRAT::itemName = "WRAT";
|
|
const UDAValue WCONHIST::WRAT::defaultValue = UDAValue(0);
|
|
const std::string WCONHIST::GRAT::itemName = "GRAT";
|
|
const UDAValue WCONHIST::GRAT::defaultValue = UDAValue(0);
|
|
const std::string WCONHIST::VFP_TABLE::itemName = "VFP_TABLE";
|
|
const std::string WCONHIST::ALQ::itemName = "ALQ";
|
|
const UDAValue WCONHIST::ALQ::defaultValue = UDAValue(0);
|
|
const std::string WCONHIST::THP::itemName = "THP";
|
|
const UDAValue WCONHIST::THP::defaultValue = UDAValue(0);
|
|
const std::string WCONHIST::BHP::itemName = "BHP";
|
|
const UDAValue WCONHIST::BHP::defaultValue = UDAValue(0);
|
|
const std::string WCONHIST::WGASRAT_HIS::itemName = "WGASRAT_HIS";
|
|
const std::string WCONHIST::NGLRAT_HIS::itemName = "NGLRAT_HIS";
|
|
|
|
|
|
WCONINJ::WCONINJ() : ParserKeyword("WCONINJ", KeywordSize(0, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WCONINJ");
|
|
}
|
|
const std::string WCONINJ::keywordName = "WCONINJ";
|
|
|
|
|
|
WCONINJE::WCONINJE() : ParserKeyword("WCONINJE", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WCONINJE");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TYPE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STATUS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("OPEN") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CMODE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("RATE", ParserItem::itype::UDA);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("RESV", ParserItem::itype::UDA);
|
|
item.push_backDimension("ReservoirVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("BHP", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(6895.000000) );
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("THP", ParserItem::itype::UDA);
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VFP_TABLE", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VAPOIL_C", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("OilDissolutionFactor");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GAS_STEAM_RATIO", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SURFACE_OIL_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SURFACE_WATER_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SURFACE_GAS_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("OIL_STEAM_RATIO", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WCONINJE::keywordName = "WCONINJE";
|
|
const std::string WCONINJE::WELL::itemName = "WELL";
|
|
const std::string WCONINJE::TYPE::itemName = "TYPE";
|
|
const std::string WCONINJE::STATUS::itemName = "STATUS";
|
|
const std::string WCONINJE::STATUS::defaultValue = "OPEN";
|
|
const std::string WCONINJE::CMODE::itemName = "CMODE";
|
|
const std::string WCONINJE::RATE::itemName = "RATE";
|
|
const std::string WCONINJE::RESV::itemName = "RESV";
|
|
const std::string WCONINJE::BHP::itemName = "BHP";
|
|
const UDAValue WCONINJE::BHP::defaultValue = UDAValue(6895.000000);
|
|
const std::string WCONINJE::THP::itemName = "THP";
|
|
const std::string WCONINJE::VFP_TABLE::itemName = "VFP_TABLE";
|
|
const std::string WCONINJE::VAPOIL_C::itemName = "VAPOIL_C";
|
|
const std::string WCONINJE::GAS_STEAM_RATIO::itemName = "GAS_STEAM_RATIO";
|
|
const std::string WCONINJE::SURFACE_OIL_FRACTION::itemName = "SURFACE_OIL_FRACTION";
|
|
const std::string WCONINJE::SURFACE_WATER_FRACTION::itemName = "SURFACE_WATER_FRACTION";
|
|
const std::string WCONINJE::SURFACE_GAS_FRACTION::itemName = "SURFACE_GAS_FRACTION";
|
|
const std::string WCONINJE::OIL_STEAM_RATIO::itemName = "OIL_STEAM_RATIO";
|
|
|
|
|
|
WCONINJH::WCONINJH() : ParserKeyword("WCONINJH", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WCONINJH");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TYPE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STATUS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("OPEN") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("RATE", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("ContextDependent");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("BHP", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("THP", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VFP_TABLE", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VAPOIL_C", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("OilDissolutionFactor");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SURFACE_OIL_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SURFACE_WATER_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SURFACE_GAS_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CMODE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("RATE") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WCONINJH::keywordName = "WCONINJH";
|
|
const std::string WCONINJH::WELL::itemName = "WELL";
|
|
const std::string WCONINJH::TYPE::itemName = "TYPE";
|
|
const std::string WCONINJH::STATUS::itemName = "STATUS";
|
|
const std::string WCONINJH::STATUS::defaultValue = "OPEN";
|
|
const std::string WCONINJH::RATE::itemName = "RATE";
|
|
const std::string WCONINJH::BHP::itemName = "BHP";
|
|
const std::string WCONINJH::THP::itemName = "THP";
|
|
const std::string WCONINJH::VFP_TABLE::itemName = "VFP_TABLE";
|
|
const std::string WCONINJH::VAPOIL_C::itemName = "VAPOIL_C";
|
|
const std::string WCONINJH::SURFACE_OIL_FRACTION::itemName = "SURFACE_OIL_FRACTION";
|
|
const std::string WCONINJH::SURFACE_WATER_FRACTION::itemName = "SURFACE_WATER_FRACTION";
|
|
const std::string WCONINJH::SURFACE_GAS_FRACTION::itemName = "SURFACE_GAS_FRACTION";
|
|
const std::string WCONINJH::CMODE::itemName = "CMODE";
|
|
const std::string WCONINJH::CMODE::defaultValue = "RATE";
|
|
|
|
|
|
WCONINJP::WCONINJP() : ParserKeyword("WCONINJP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WCONINJP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("PATTERN_WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("INJECTOR_TYPE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STATUS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("OPEN") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("BHP_MAX", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(6895.000000) );
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("THP_MAX", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VFP_TABLE", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VOIDAGE_TARGET_MULTIPLIER", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("OIL_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WATER_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GAS_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PROD_FRACTION", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FIPNUM_VALUE", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WCONINJP::keywordName = "WCONINJP";
|
|
const std::string WCONINJP::PATTERN_WELL::itemName = "PATTERN_WELL";
|
|
const std::string WCONINJP::INJECTOR_TYPE::itemName = "INJECTOR_TYPE";
|
|
const std::string WCONINJP::STATUS::itemName = "STATUS";
|
|
const std::string WCONINJP::STATUS::defaultValue = "OPEN";
|
|
const std::string WCONINJP::BHP_MAX::itemName = "BHP_MAX";
|
|
const std::string WCONINJP::THP_MAX::itemName = "THP_MAX";
|
|
const std::string WCONINJP::VFP_TABLE::itemName = "VFP_TABLE";
|
|
const std::string WCONINJP::VOIDAGE_TARGET_MULTIPLIER::itemName = "VOIDAGE_TARGET_MULTIPLIER";
|
|
const std::string WCONINJP::OIL_FRACTION::itemName = "OIL_FRACTION";
|
|
const std::string WCONINJP::WATER_FRACTION::itemName = "WATER_FRACTION";
|
|
const std::string WCONINJP::GAS_FRACTION::itemName = "GAS_FRACTION";
|
|
const std::string WCONINJP::WELL::itemName = "WELL";
|
|
const std::string WCONINJP::PROD_FRACTION::itemName = "PROD_FRACTION";
|
|
const std::string WCONINJP::FIPNUM_VALUE::itemName = "FIPNUM_VALUE";
|
|
|
|
|
|
WCONPROD::WCONPROD() : ParserKeyword("WCONPROD", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WCONPROD");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STATUS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("OPEN") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CMODE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ORAT", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("LiquidSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WRAT", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("LiquidSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GRAT", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("GasSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LRAT", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("LiquidSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("RESV", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("LiquidSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("BHP", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(1.013250) );
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("THP", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VFP_TABLE", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ALQ", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("E300_ITEM13", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("E300_ITEM14", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("E300_ITEM15", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("E300_ITEM16", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("E300_ITEM17", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("E300_ITEM18", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("E300_ITEM19", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("E300_ITEM20", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WCONPROD::keywordName = "WCONPROD";
|
|
const std::string WCONPROD::WELL::itemName = "WELL";
|
|
const std::string WCONPROD::STATUS::itemName = "STATUS";
|
|
const std::string WCONPROD::STATUS::defaultValue = "OPEN";
|
|
const std::string WCONPROD::CMODE::itemName = "CMODE";
|
|
const std::string WCONPROD::ORAT::itemName = "ORAT";
|
|
const UDAValue WCONPROD::ORAT::defaultValue = UDAValue(0);
|
|
const std::string WCONPROD::WRAT::itemName = "WRAT";
|
|
const UDAValue WCONPROD::WRAT::defaultValue = UDAValue(0);
|
|
const std::string WCONPROD::GRAT::itemName = "GRAT";
|
|
const UDAValue WCONPROD::GRAT::defaultValue = UDAValue(0);
|
|
const std::string WCONPROD::LRAT::itemName = "LRAT";
|
|
const UDAValue WCONPROD::LRAT::defaultValue = UDAValue(0);
|
|
const std::string WCONPROD::RESV::itemName = "RESV";
|
|
const UDAValue WCONPROD::RESV::defaultValue = UDAValue(0);
|
|
const std::string WCONPROD::BHP::itemName = "BHP";
|
|
const UDAValue WCONPROD::BHP::defaultValue = UDAValue(1.013250);
|
|
const std::string WCONPROD::THP::itemName = "THP";
|
|
const UDAValue WCONPROD::THP::defaultValue = UDAValue(0);
|
|
const std::string WCONPROD::VFP_TABLE::itemName = "VFP_TABLE";
|
|
const std::string WCONPROD::ALQ::itemName = "ALQ";
|
|
const UDAValue WCONPROD::ALQ::defaultValue = UDAValue(0);
|
|
const std::string WCONPROD::E300_ITEM13::itemName = "E300_ITEM13";
|
|
const std::string WCONPROD::E300_ITEM14::itemName = "E300_ITEM14";
|
|
const std::string WCONPROD::E300_ITEM15::itemName = "E300_ITEM15";
|
|
const std::string WCONPROD::E300_ITEM16::itemName = "E300_ITEM16";
|
|
const std::string WCONPROD::E300_ITEM17::itemName = "E300_ITEM17";
|
|
const std::string WCONPROD::E300_ITEM18::itemName = "E300_ITEM18";
|
|
const std::string WCONPROD::E300_ITEM19::itemName = "E300_ITEM19";
|
|
const std::string WCONPROD::E300_ITEM20::itemName = "E300_ITEM20";
|
|
|
|
|
|
WCUTBACK::WCUTBACK() : ParserKeyword("WCUTBACK", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WCUTBACK");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WCT_LIMIT", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("LiquidSurfaceVolume/LiquidSurfaceVolume");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GOR_LIMIT", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("GasDissolutionFactor");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GLR_LIMIT", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("GasDissolutionFactor");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WGR_LIMIT", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("OilDissolutionFactor");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("RATE_CUTBACK", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PHASE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PRESSURE_LIMIT", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PRESSURE_LIMIT_REVERSE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WCT_LIMIT_REVERSE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("LiquidSurfaceVolume/LiquidSurfaceVolume");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GOR_LIMIT_REVERSE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("GasDissolutionFactor");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GLR_LIMIT_REVERSE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("GasDissolutionFactor");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WGR_LIMIT_REVERSE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("OilDissolutionFactor");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WORKOVER_REMOVE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WCUTBACK::keywordName = "WCUTBACK";
|
|
const std::string WCUTBACK::WELL::itemName = "WELL";
|
|
const std::string WCUTBACK::WCT_LIMIT::itemName = "WCT_LIMIT";
|
|
const std::string WCUTBACK::GOR_LIMIT::itemName = "GOR_LIMIT";
|
|
const std::string WCUTBACK::GLR_LIMIT::itemName = "GLR_LIMIT";
|
|
const std::string WCUTBACK::WGR_LIMIT::itemName = "WGR_LIMIT";
|
|
const std::string WCUTBACK::RATE_CUTBACK::itemName = "RATE_CUTBACK";
|
|
const std::string WCUTBACK::PHASE::itemName = "PHASE";
|
|
const std::string WCUTBACK::PRESSURE_LIMIT::itemName = "PRESSURE_LIMIT";
|
|
const std::string WCUTBACK::PRESSURE_LIMIT_REVERSE::itemName = "PRESSURE_LIMIT_REVERSE";
|
|
const std::string WCUTBACK::WCT_LIMIT_REVERSE::itemName = "WCT_LIMIT_REVERSE";
|
|
const std::string WCUTBACK::GOR_LIMIT_REVERSE::itemName = "GOR_LIMIT_REVERSE";
|
|
const std::string WCUTBACK::GLR_LIMIT_REVERSE::itemName = "GLR_LIMIT_REVERSE";
|
|
const std::string WCUTBACK::WGR_LIMIT_REVERSE::itemName = "WGR_LIMIT_REVERSE";
|
|
const std::string WCUTBACK::WORKOVER_REMOVE::itemName = "WORKOVER_REMOVE";
|
|
const std::string WCUTBACK::WORKOVER_REMOVE::defaultValue = "NO";
|
|
|
|
|
|
WCUTBACT::WCUTBACT() : ParserKeyword("WCUTBACT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WCUTBACT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("RATE_CUTBACK", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PHASE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WORKOVER_REMOVE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WCUTBACT::keywordName = "WCUTBACT";
|
|
const std::string WCUTBACT::WELL::itemName = "WELL";
|
|
const std::string WCUTBACT::RATE_CUTBACK::itemName = "RATE_CUTBACK";
|
|
const std::string WCUTBACT::PHASE::itemName = "PHASE";
|
|
const std::string WCUTBACT::WORKOVER_REMOVE::itemName = "WORKOVER_REMOVE";
|
|
const std::string WCUTBACT::WORKOVER_REMOVE::defaultValue = "NO";
|
|
|
|
|
|
WCYCLE::WCYCLE() : ParserKeyword("WCYCLE", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WCYCLE");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ON_TIME", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("OFF_TIME", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("START_TIME", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_TIMESTEP", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CONTROLLED_TIMESTEP", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WCYCLE::keywordName = "WCYCLE";
|
|
const std::string WCYCLE::WELL::itemName = "WELL";
|
|
const std::string WCYCLE::ON_TIME::itemName = "ON_TIME";
|
|
const std::string WCYCLE::OFF_TIME::itemName = "OFF_TIME";
|
|
const std::string WCYCLE::START_TIME::itemName = "START_TIME";
|
|
const std::string WCYCLE::MAX_TIMESTEP::itemName = "MAX_TIMESTEP";
|
|
const std::string WCYCLE::CONTROLLED_TIMESTEP::itemName = "CONTROLLED_TIMESTEP";
|
|
const std::string WCYCLE::CONTROLLED_TIMESTEP::defaultValue = "NO";
|
|
|
|
|
|
WDFAC::WDFAC() : ParserKeyword("WDFAC", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WDFAC");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DFACTOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Time/GasSurfaceVolume");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WDFAC::keywordName = "WDFAC";
|
|
const std::string WDFAC::WELL::itemName = "WELL";
|
|
const std::string WDFAC::DFACTOR::itemName = "DFACTOR";
|
|
|
|
|
|
WDFACCOR::WDFACCOR() : ParserKeyword("WDFACCOR", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WDFACCOR");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELLNAME", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("A", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Viscosity*Time*Area/Permeability*GasSurfaceVolume");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("B", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("C", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WDFACCOR::keywordName = "WDFACCOR";
|
|
const std::string WDFACCOR::WELLNAME::itemName = "WELLNAME";
|
|
const std::string WDFACCOR::A::itemName = "A";
|
|
const std::string WDFACCOR::B::itemName = "B";
|
|
const std::string WDFACCOR::C::itemName = "C";
|
|
|
|
|
|
WDRILPRI::WDRILPRI() : ParserKeyword("WDRILPRI", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WDRILPRI");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PRIORITY", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(-1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DRILLING_UNIT", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WDRILPRI::keywordName = "WDRILPRI";
|
|
const std::string WDRILPRI::WELL::itemName = "WELL";
|
|
const std::string WDRILPRI::PRIORITY::itemName = "PRIORITY";
|
|
const std::string WDRILPRI::DRILLING_UNIT::itemName = "DRILLING_UNIT";
|
|
|
|
|
|
WDRILRES::WDRILRES() : ParserKeyword("WDRILRES", KeywordSize(0, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WDRILRES");
|
|
}
|
|
const std::string WDRILRES::keywordName = "WDRILRES";
|
|
|
|
|
|
WDRILTIM::WDRILTIM() : ParserKeyword("WDRILTIM", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WDRILTIM");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DRILL_TIME", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WORKOVER_CLOSE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("COMPARTMENT", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WDRILTIM::keywordName = "WDRILTIM";
|
|
const std::string WDRILTIM::WELL::itemName = "WELL";
|
|
const std::string WDRILTIM::DRILL_TIME::itemName = "DRILL_TIME";
|
|
const std::string WDRILTIM::WORKOVER_CLOSE::itemName = "WORKOVER_CLOSE";
|
|
const std::string WDRILTIM::COMPARTMENT::itemName = "COMPARTMENT";
|
|
|
|
|
|
WECON::WECON() : ParserKeyword("WECON", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WECON");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MIN_OIL_PRODUCTION", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("LiquidSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MIN_GAS_PRODUCTION", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("GasSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_WATER_CUT", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_GAS_OIL_RATIO", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("GasSurfaceVolume/LiquidSurfaceVolume");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_WATER_GAS_RATIO", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("LiquidSurfaceVolume/GasSurfaceVolume");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WORKOVER_RATIO_LIMIT", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NONE") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("END_RUN_FLAG", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FOLLOW_ON_WELL", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("'") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LIMITED_QUANTITY", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("RATE") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SECOND_MAX_WATER_CUT", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WORKOVER_SECOND_WATER_CUT_LIMIT", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_GAS_LIQUID_RATIO", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MIN_LIQUID_PRODCUTION_RATE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("LiquidSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_TEMP", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Temperature");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MIN_RES_FLUID_RATE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("ReservoirVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WECON::keywordName = "WECON";
|
|
const std::string WECON::WELL::itemName = "WELL";
|
|
const std::string WECON::MIN_OIL_PRODUCTION::itemName = "MIN_OIL_PRODUCTION";
|
|
const UDAValue WECON::MIN_OIL_PRODUCTION::defaultValue = UDAValue(0);
|
|
const std::string WECON::MIN_GAS_PRODUCTION::itemName = "MIN_GAS_PRODUCTION";
|
|
const UDAValue WECON::MIN_GAS_PRODUCTION::defaultValue = UDAValue(0);
|
|
const std::string WECON::MAX_WATER_CUT::itemName = "MAX_WATER_CUT";
|
|
const UDAValue WECON::MAX_WATER_CUT::defaultValue = UDAValue(0);
|
|
const std::string WECON::MAX_GAS_OIL_RATIO::itemName = "MAX_GAS_OIL_RATIO";
|
|
const UDAValue WECON::MAX_GAS_OIL_RATIO::defaultValue = UDAValue(0);
|
|
const std::string WECON::MAX_WATER_GAS_RATIO::itemName = "MAX_WATER_GAS_RATIO";
|
|
const UDAValue WECON::MAX_WATER_GAS_RATIO::defaultValue = UDAValue(0);
|
|
const std::string WECON::WORKOVER_RATIO_LIMIT::itemName = "WORKOVER_RATIO_LIMIT";
|
|
const std::string WECON::WORKOVER_RATIO_LIMIT::defaultValue = "NONE";
|
|
const std::string WECON::END_RUN_FLAG::itemName = "END_RUN_FLAG";
|
|
const std::string WECON::END_RUN_FLAG::defaultValue = "NO";
|
|
const std::string WECON::FOLLOW_ON_WELL::itemName = "FOLLOW_ON_WELL";
|
|
const std::string WECON::FOLLOW_ON_WELL::defaultValue = "'";
|
|
const std::string WECON::LIMITED_QUANTITY::itemName = "LIMITED_QUANTITY";
|
|
const std::string WECON::LIMITED_QUANTITY::defaultValue = "RATE";
|
|
const std::string WECON::SECOND_MAX_WATER_CUT::itemName = "SECOND_MAX_WATER_CUT";
|
|
const std::string WECON::WORKOVER_SECOND_WATER_CUT_LIMIT::itemName = "WORKOVER_SECOND_WATER_CUT_LIMIT";
|
|
const std::string WECON::MAX_GAS_LIQUID_RATIO::itemName = "MAX_GAS_LIQUID_RATIO";
|
|
const std::string WECON::MIN_LIQUID_PRODCUTION_RATE::itemName = "MIN_LIQUID_PRODCUTION_RATE";
|
|
const std::string WECON::MAX_TEMP::itemName = "MAX_TEMP";
|
|
const std::string WECON::MIN_RES_FLUID_RATE::itemName = "MIN_RES_FLUID_RATE";
|
|
|
|
|
|
WECONINJ::WECONINJ() : ParserKeyword("WECONINJ", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WECONINJ");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MIN_RATE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("QUANTITY", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("RATE") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WECONINJ::keywordName = "WECONINJ";
|
|
const std::string WECONINJ::WELL::itemName = "WELL";
|
|
const std::string WECONINJ::MIN_RATE::itemName = "MIN_RATE";
|
|
const std::string WECONINJ::QUANTITY::itemName = "QUANTITY";
|
|
const std::string WECONINJ::QUANTITY::defaultValue = "RATE";
|
|
|
|
|
|
WECONT::WECONT() : ParserKeyword("WECONT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WECONT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WORKOVER", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NONE") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("END_RUN_FLAG", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FOLLOW_ON_WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WECONT::keywordName = "WECONT";
|
|
const std::string WECONT::WELL::itemName = "WELL";
|
|
const std::string WECONT::WORKOVER::itemName = "WORKOVER";
|
|
const std::string WECONT::WORKOVER::defaultValue = "NONE";
|
|
const std::string WECONT::END_RUN_FLAG::itemName = "END_RUN_FLAG";
|
|
const std::string WECONT::END_RUN_FLAG::defaultValue = "NO";
|
|
const std::string WECONT::FOLLOW_ON_WELL::itemName = "FOLLOW_ON_WELL";
|
|
|
|
|
|
WEFAC::WEFAC() : ParserKeyword("WEFAC", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WEFAC");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELLNAME", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("EFFICIENCY_FACTOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("USE_WEFAC_IN_NETWORK", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("YES") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WEFAC::keywordName = "WEFAC";
|
|
const std::string WEFAC::WELLNAME::itemName = "WELLNAME";
|
|
const std::string WEFAC::EFFICIENCY_FACTOR::itemName = "EFFICIENCY_FACTOR";
|
|
const std::string WEFAC::USE_WEFAC_IN_NETWORK::itemName = "USE_WEFAC_IN_NETWORK";
|
|
const std::string WEFAC::USE_WEFAC_IN_NETWORK::defaultValue = "YES";
|
|
|
|
|
|
WELCNTL::WELCNTL() : ParserKeyword("WELCNTL", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELCNTL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CMODE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NEW_VALUE", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELCNTL::keywordName = "WELCNTL";
|
|
const std::string WELCNTL::WELL::itemName = "WELL";
|
|
const std::string WELCNTL::CMODE::itemName = "CMODE";
|
|
const std::string WELCNTL::NEW_VALUE::itemName = "NEW_VALUE";
|
|
|
|
|
|
WELDEBUG::WELDEBUG() : ParserKeyword("WELDEBUG", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELDEBUG");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DEBUG_FLAG", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELDEBUG::keywordName = "WELDEBUG";
|
|
const std::string WELDEBUG::WELL::itemName = "WELL";
|
|
const std::string WELDEBUG::DEBUG_FLAG::itemName = "DEBUG_FLAG";
|
|
|
|
|
|
WELDRAW::WELDRAW() : ParserKeyword("WELDRAW", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELDRAW");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_DRAW", ParserItem::itype::UDA);
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PHASE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("USE_LIMIT", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GRID_BLOCKS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("AVG") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELDRAW::keywordName = "WELDRAW";
|
|
const std::string WELDRAW::WELL::itemName = "WELL";
|
|
const std::string WELDRAW::MAX_DRAW::itemName = "MAX_DRAW";
|
|
const std::string WELDRAW::PHASE::itemName = "PHASE";
|
|
const std::string WELDRAW::USE_LIMIT::itemName = "USE_LIMIT";
|
|
const std::string WELDRAW::USE_LIMIT::defaultValue = "NO";
|
|
const std::string WELDRAW::GRID_BLOCKS::itemName = "GRID_BLOCKS";
|
|
const std::string WELDRAW::GRID_BLOCKS::defaultValue = "AVG";
|
|
|
|
|
|
WELEVNT::WELEVNT() : ParserKeyword("WELEVNT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELEVNT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WPWEM_VALUE", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELEVNT::keywordName = "WELEVNT";
|
|
const std::string WELEVNT::WELL::itemName = "WELL";
|
|
const std::string WELEVNT::WPWEM_VALUE::itemName = "WPWEM_VALUE";
|
|
|
|
|
|
WELLDIMS::WELLDIMS() : ParserKeyword("WELLDIMS", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("WELLDIMS");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("MAXWELLS", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAXCONN", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAXGROUPS", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_GROUPSIZE", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_STAGES", ParserItem::itype::INT);
|
|
item.setDefault( 5 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_STREAMS", ParserItem::itype::INT);
|
|
item.setDefault( 10 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_MIXTURES", ParserItem::itype::INT);
|
|
item.setDefault( 5 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_SEPARATORS", ParserItem::itype::INT);
|
|
item.setDefault( 4 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_MIXTURE_ITEMS", ParserItem::itype::INT);
|
|
item.setDefault( 3 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_COMPLETION_X", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_WELLIST_PR_WELL", ParserItem::itype::INT);
|
|
item.setDefault( 1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_DYNAMIC_WELLIST", ParserItem::itype::INT);
|
|
item.setDefault( 1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_SECONDARY_WELLS", ParserItem::itype::INT);
|
|
item.setDefault( 10 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_GPP_ROWS", ParserItem::itype::INT);
|
|
item.setDefault( 201 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELLDIMS::keywordName = "WELLDIMS";
|
|
const std::string WELLDIMS::MAXWELLS::itemName = "MAXWELLS";
|
|
const std::string WELLDIMS::MAXCONN::itemName = "MAXCONN";
|
|
const std::string WELLDIMS::MAXGROUPS::itemName = "MAXGROUPS";
|
|
const std::string WELLDIMS::MAX_GROUPSIZE::itemName = "MAX_GROUPSIZE";
|
|
const std::string WELLDIMS::MAX_STAGES::itemName = "MAX_STAGES";
|
|
const std::string WELLDIMS::MAX_STREAMS::itemName = "MAX_STREAMS";
|
|
const std::string WELLDIMS::MAX_MIXTURES::itemName = "MAX_MIXTURES";
|
|
const std::string WELLDIMS::MAX_SEPARATORS::itemName = "MAX_SEPARATORS";
|
|
const std::string WELLDIMS::MAX_MIXTURE_ITEMS::itemName = "MAX_MIXTURE_ITEMS";
|
|
const std::string WELLDIMS::MAX_COMPLETION_X::itemName = "MAX_COMPLETION_X";
|
|
const std::string WELLDIMS::MAX_WELLIST_PR_WELL::itemName = "MAX_WELLIST_PR_WELL";
|
|
const std::string WELLDIMS::MAX_DYNAMIC_WELLIST::itemName = "MAX_DYNAMIC_WELLIST";
|
|
const std::string WELLDIMS::MAX_SECONDARY_WELLS::itemName = "MAX_SECONDARY_WELLS";
|
|
const std::string WELLDIMS::MAX_GPP_ROWS::itemName = "MAX_GPP_ROWS";
|
|
|
|
|
|
WELLSTRE::WELLSTRE() : ParserKeyword("WELLSTRE", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELLSTRE");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("STREAM", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("COMPOSITIONS", ParserItem::itype::DOUBLE);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELLSTRE::keywordName = "WELLSTRE";
|
|
const std::string WELLSTRE::STREAM::itemName = "STREAM";
|
|
const std::string WELLSTRE::COMPOSITIONS::itemName = "COMPOSITIONS";
|
|
|
|
|
|
WELL_COMPLETION_PROBE::WELL_COMPLETION_PROBE() : ParserKeyword("WELL_COMPLETION_PROBE", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SUMMARY");
|
|
clearDeckNames();
|
|
addDeckName("WWPTL");
|
|
addDeckName("WWFRL");
|
|
addDeckName("WOPTL");
|
|
addDeckName("WOFRL");
|
|
addDeckName("WWPRL");
|
|
addDeckName("WOPRL");
|
|
addDeckName("WOITL");
|
|
addDeckName("WWIRL");
|
|
addDeckName("WWITL");
|
|
addDeckName("WGFRL");
|
|
addDeckName("WGPRL");
|
|
addDeckName("WGPTL");
|
|
addDeckName("WLFRL");
|
|
addDeckName("WWGRL");
|
|
addDeckName("WLPTL");
|
|
addDeckName("WVFRL");
|
|
addDeckName("WVIRL");
|
|
addDeckName("WVPTL");
|
|
addDeckName("WVITL");
|
|
addDeckName("WWCTL");
|
|
addDeckName("WGORL");
|
|
addDeckName("WOGRL");
|
|
addDeckName("WGLRL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("COMPLETION", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELL_COMPLETION_PROBE::keywordName = "WELL_COMPLETION_PROBE";
|
|
const std::string WELL_COMPLETION_PROBE::WELL::itemName = "WELL";
|
|
const std::string WELL_COMPLETION_PROBE::COMPLETION::itemName = "COMPLETION";
|
|
|
|
|
|
WELL_PROBE::WELL_PROBE() : ParserKeyword("WELL_PROBE", KeywordSize(1, false)) {
|
|
addValidSectionName("SUMMARY");
|
|
clearDeckNames();
|
|
addDeckName("WOPR");
|
|
addDeckName("WGPP");
|
|
addDeckName("WOPTF");
|
|
addDeckName("WOIGR");
|
|
addDeckName("WOPRH");
|
|
addDeckName("WOPT");
|
|
addDeckName("WWPRT");
|
|
addDeckName("WPIL");
|
|
addDeckName("WOPRT");
|
|
addDeckName("WOPTH");
|
|
addDeckName("WTIRSUR");
|
|
addDeckName("WPWE1");
|
|
addDeckName("WOPRF");
|
|
addDeckName("WGIT");
|
|
addDeckName("WOPRS");
|
|
addDeckName("WTPRCAT");
|
|
addDeckName("WBHPH");
|
|
addDeckName("WGIRH");
|
|
addDeckName("WOPTS");
|
|
addDeckName("WOIRH");
|
|
addDeckName("WOIR");
|
|
addDeckName("WPI9");
|
|
addDeckName("WGPGR");
|
|
addDeckName("WGIP2");
|
|
addDeckName("WTPTFOA");
|
|
addDeckName("WOIRT");
|
|
addDeckName("WWPI2");
|
|
addDeckName("WOIT");
|
|
addDeckName("WGIP");
|
|
addDeckName("WPIO");
|
|
addDeckName("WOITH");
|
|
addDeckName("WOPP");
|
|
addDeckName("WOPP2");
|
|
addDeckName("WTITS");
|
|
addDeckName("WOPI");
|
|
addDeckName("WOPI2");
|
|
addDeckName("WTPTSUR");
|
|
addDeckName("WBHPT");
|
|
addDeckName("WGIRT");
|
|
addDeckName("WPI1");
|
|
addDeckName("WWPI");
|
|
addDeckName("WWVIR");
|
|
addDeckName("WOPGR");
|
|
addDeckName("WWPR");
|
|
addDeckName("WWPRH");
|
|
addDeckName("WWIGR");
|
|
addDeckName("WPWE7");
|
|
addDeckName("WWPP2");
|
|
addDeckName("WWPT");
|
|
addDeckName("WTIRHEA");
|
|
addDeckName("WWPTH");
|
|
addDeckName("WWIRH");
|
|
addDeckName("WNPT");
|
|
addDeckName("WHDF");
|
|
addDeckName("WWIR");
|
|
addDeckName("WWIRT");
|
|
addDeckName("WNPR");
|
|
addDeckName("WMCTL");
|
|
addDeckName("WWIT");
|
|
addDeckName("WOGR");
|
|
addDeckName("WWITH");
|
|
addDeckName("WGPP2");
|
|
addDeckName("WWPP");
|
|
addDeckName("WTIC");
|
|
addDeckName("WWIP");
|
|
addDeckName("WGPPS");
|
|
addDeckName("WWPGR");
|
|
addDeckName("WLPR");
|
|
addDeckName("WWIP2");
|
|
addDeckName("WWPIR");
|
|
addDeckName("WGPR");
|
|
addDeckName("WTITFOA");
|
|
addDeckName("WSPT");
|
|
addDeckName("WGPRH");
|
|
addDeckName("WGPRT");
|
|
addDeckName("WGPRF");
|
|
addDeckName("WGPRS");
|
|
addDeckName("WGPI2");
|
|
addDeckName("WTITALK");
|
|
addDeckName("WGPT");
|
|
addDeckName("WGPTH");
|
|
addDeckName("WGPTF");
|
|
addDeckName("WGPTS");
|
|
addDeckName("WBHP");
|
|
addDeckName("WGIR");
|
|
addDeckName("WAPI");
|
|
addDeckName("WGITH");
|
|
addDeckName("WGPPS2");
|
|
addDeckName("WGPPF");
|
|
addDeckName("WGPPF2");
|
|
addDeckName("WGPI");
|
|
addDeckName("WGIGR");
|
|
addDeckName("WTIRS");
|
|
addDeckName("WGLIR");
|
|
addDeckName("WGQ");
|
|
addDeckName("WLPRH");
|
|
addDeckName("WLPRT");
|
|
addDeckName("WLPT");
|
|
addDeckName("WLPTH");
|
|
addDeckName("WTPRANI");
|
|
addDeckName("WJPR");
|
|
addDeckName("WJPRH");
|
|
addDeckName("WJPRT");
|
|
addDeckName("WJPT");
|
|
addDeckName("WJPTH");
|
|
addDeckName("WVPR");
|
|
addDeckName("WEIR");
|
|
addDeckName("WVPRT");
|
|
addDeckName("WVPT");
|
|
addDeckName("WVPGR");
|
|
addDeckName("WVIR");
|
|
addDeckName("WTITCAT");
|
|
addDeckName("WVIRT");
|
|
addDeckName("WVIT");
|
|
addDeckName("WWCT");
|
|
addDeckName("WWCTH");
|
|
addDeckName("WGOR");
|
|
addDeckName("WGORH");
|
|
addDeckName("WOGRH");
|
|
addDeckName("WWGR");
|
|
addDeckName("WWGRH");
|
|
addDeckName("WGLR");
|
|
addDeckName("WGPRFP");
|
|
addDeckName("WTIRCAT");
|
|
addDeckName("WGLRH");
|
|
addDeckName("WBGLR");
|
|
addDeckName("WTHP");
|
|
addDeckName("WTHPH");
|
|
addDeckName("WPI");
|
|
addDeckName("WBP");
|
|
addDeckName("WBP4");
|
|
addDeckName("WBP5");
|
|
addDeckName("WBP9");
|
|
addDeckName("WPI4");
|
|
addDeckName("WPI5");
|
|
addDeckName("WHD");
|
|
addDeckName("WSTAT");
|
|
addDeckName("WMCON");
|
|
addDeckName("WGVPR");
|
|
addDeckName("WTPTHEA");
|
|
addDeckName("WGVIR");
|
|
addDeckName("WEDC");
|
|
addDeckName("WEIT");
|
|
addDeckName("WEPR");
|
|
addDeckName("WEPT");
|
|
addDeckName("WEFF");
|
|
addDeckName("WEFFG");
|
|
addDeckName("WALQ");
|
|
addDeckName("WMVFP");
|
|
addDeckName("WTHT");
|
|
addDeckName("WMMW");
|
|
addDeckName("WPWE0");
|
|
addDeckName("WPWE2");
|
|
addDeckName("WPWE3");
|
|
addDeckName("WPWE4");
|
|
addDeckName("WPWE5");
|
|
addDeckName("WPWE6");
|
|
addDeckName("WPWEM");
|
|
addDeckName("WPIG");
|
|
addDeckName("WDRPR");
|
|
addDeckName("WSPR");
|
|
addDeckName("WSIR");
|
|
addDeckName("WSIT");
|
|
addDeckName("WSPC");
|
|
addDeckName("WSIC");
|
|
addDeckName("WTICF");
|
|
addDeckName("WTPTANI");
|
|
addDeckName("WTIRANI");
|
|
addDeckName("WTITANI");
|
|
addDeckName("WTPTCAT");
|
|
addDeckName("WTPCHEA");
|
|
addDeckName("WTICHEA");
|
|
addDeckName("WTPRHEA");
|
|
addDeckName("WTITHEA");
|
|
addDeckName("WTPR");
|
|
addDeckName("WTPRSUR");
|
|
addDeckName("WTPT");
|
|
addDeckName("WTPC");
|
|
addDeckName("WTIR");
|
|
addDeckName("WTIT");
|
|
addDeckName("WTIRF");
|
|
addDeckName("WTPRF");
|
|
addDeckName("WTPRS");
|
|
addDeckName("WTITF");
|
|
addDeckName("WTPTF");
|
|
addDeckName("WTPTS");
|
|
addDeckName("WTICS");
|
|
addDeckName("WTPCF");
|
|
addDeckName("WTPCS");
|
|
addDeckName("WMPR");
|
|
addDeckName("WMPT");
|
|
addDeckName("WMIR");
|
|
addDeckName("WMIT");
|
|
addDeckName("WPIW");
|
|
addDeckName("WTPRFOA");
|
|
addDeckName("WTIRFOA");
|
|
addDeckName("WGDC");
|
|
addDeckName("NGOPAS");
|
|
addDeckName("WTHPFP");
|
|
addDeckName("WBHPFP");
|
|
addDeckName("WOGLR");
|
|
addDeckName("WTPRALK");
|
|
addDeckName("WGCV");
|
|
addDeckName("WCPR");
|
|
addDeckName("WCPC");
|
|
addDeckName("WCPT");
|
|
addDeckName("WCIR");
|
|
addDeckName("WCIC");
|
|
addDeckName("WCIT");
|
|
addDeckName("WNIR");
|
|
addDeckName("WNIT");
|
|
addDeckName("WTITSUR");
|
|
addDeckName("WTPTALK");
|
|
addDeckName("WTIRALK");
|
|
setMatchRegex("WU.+|(WBHWC|WGFWC|WOFWC|WWFWC)[1-9][0-9]?|WTPR.+|WTPT.+|WTPC.+|WTIR.+|WTIT.+|WTIC.+");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELLS", ParserItem::itype::STRING);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELL_PROBE::keywordName = "WELL_PROBE";
|
|
const std::string WELL_PROBE::WELLS::itemName = "WELLS";
|
|
|
|
|
|
WELL_PROBE_COMP::WELL_PROBE_COMP() : ParserKeyword("WELL_PROBE_COMP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SUMMARY");
|
|
clearDeckNames();
|
|
addDeckName("WYMF");
|
|
addDeckName("WAMF");
|
|
addDeckName("WXMF");
|
|
addDeckName("WCOMR");
|
|
addDeckName("WCGMR");
|
|
addDeckName("WZMF");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELLS", ParserItem::itype::STRING);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("COMP_NUM", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELL_PROBE_COMP::keywordName = "WELL_PROBE_COMP";
|
|
const std::string WELL_PROBE_COMP::WELLS::itemName = "WELLS";
|
|
const std::string WELL_PROBE_COMP::COMP_NUM::itemName = "COMP_NUM";
|
|
|
|
|
|
WELL_PROBE_OPM::WELL_PROBE_OPM() : ParserKeyword("WELL_PROBE_OPM", KeywordSize(1, false)) {
|
|
addValidSectionName("SUMMARY");
|
|
clearDeckNames();
|
|
addDeckName("WAMIR");
|
|
addDeckName("WAMIT");
|
|
addDeckName("WMOPT");
|
|
addDeckName("WGMPT");
|
|
addDeckName("WAMPR");
|
|
addDeckName("WMOPR");
|
|
addDeckName("WGMPR");
|
|
addDeckName("WAMPT");
|
|
addDeckName("WINJFC");
|
|
addDeckName("WMOIR");
|
|
addDeckName("WGMIR");
|
|
addDeckName("WINJFVR");
|
|
addDeckName("WINJFVT");
|
|
addDeckName("WMOIT");
|
|
addDeckName("WGMIT");
|
|
addDeckName("WMMIR");
|
|
addDeckName("WMMIT");
|
|
addDeckName("WMUIR");
|
|
addDeckName("WMUIT");
|
|
addDeckName("WMMPR");
|
|
addDeckName("WMMPT");
|
|
addDeckName("WMUPR");
|
|
addDeckName("WMUPT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELLS", ParserItem::itype::STRING);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELL_PROBE_OPM::keywordName = "WELL_PROBE_OPM";
|
|
const std::string WELL_PROBE_OPM::WELLS::itemName = "WELLS";
|
|
|
|
|
|
WELMOVEL::WELMOVEL() : ParserKeyword("WELMOVEL", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELMOVEL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELLNAME", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LGRNAME", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WELLHEAD_I", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WELLHEAD_J", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELMOVEL::keywordName = "WELMOVEL";
|
|
const std::string WELMOVEL::WELLNAME::itemName = "WELLNAME";
|
|
const std::string WELMOVEL::LGRNAME::itemName = "LGRNAME";
|
|
const std::string WELMOVEL::WELLHEAD_I::itemName = "WELLHEAD_I";
|
|
const std::string WELMOVEL::WELLHEAD_J::itemName = "WELLHEAD_J";
|
|
|
|
|
|
WELOPEN::WELOPEN() : ParserKeyword("WELOPEN", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELOPEN");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STATUS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("OPEN") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("C1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("C2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELOPEN::keywordName = "WELOPEN";
|
|
const std::string WELOPEN::WELL::itemName = "WELL";
|
|
const std::string WELOPEN::STATUS::itemName = "STATUS";
|
|
const std::string WELOPEN::STATUS::defaultValue = "OPEN";
|
|
const std::string WELOPEN::I::itemName = "I";
|
|
const std::string WELOPEN::J::itemName = "J";
|
|
const std::string WELOPEN::K::itemName = "K";
|
|
const std::string WELOPEN::C1::itemName = "C1";
|
|
const std::string WELOPEN::C2::itemName = "C2";
|
|
|
|
|
|
WELOPENL::WELOPENL() : ParserKeyword("WELOPENL", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELOPENL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GRID", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STATUS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("OPEN") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("C1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("C2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELOPENL::keywordName = "WELOPENL";
|
|
const std::string WELOPENL::WELL::itemName = "WELL";
|
|
const std::string WELOPENL::GRID::itemName = "GRID";
|
|
const std::string WELOPENL::STATUS::itemName = "STATUS";
|
|
const std::string WELOPENL::STATUS::defaultValue = "OPEN";
|
|
const std::string WELOPENL::I::itemName = "I";
|
|
const std::string WELOPENL::J::itemName = "J";
|
|
const std::string WELOPENL::K::itemName = "K";
|
|
const std::string WELOPENL::C1::itemName = "C1";
|
|
const std::string WELOPENL::C2::itemName = "C2";
|
|
|
|
|
|
WELPI::WELPI() : ParserKeyword("WELPI", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELPI");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL_NAME", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STEADY_STATE_PRODUCTIVITY_OR_INJECTIVITY_INDEX_VALUE", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELPI::keywordName = "WELPI";
|
|
const std::string WELPI::WELL_NAME::itemName = "WELL_NAME";
|
|
const std::string WELPI::STEADY_STATE_PRODUCTIVITY_OR_INJECTIVITY_INDEX_VALUE::itemName = "STEADY_STATE_PRODUCTIVITY_OR_INJECTIVITY_INDEX_VALUE";
|
|
|
|
|
|
WELPRI::WELPRI() : ParserKeyword("WELPRI", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELPRI");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL_NAME", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PRI1", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SCALING1", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PRI2", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SCALING2", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELPRI::keywordName = "WELPRI";
|
|
const std::string WELPRI::WELL_NAME::itemName = "WELL_NAME";
|
|
const std::string WELPRI::PRI1::itemName = "PRI1";
|
|
const std::string WELPRI::SCALING1::itemName = "SCALING1";
|
|
const std::string WELPRI::PRI2::itemName = "PRI2";
|
|
const std::string WELPRI::SCALING2::itemName = "SCALING2";
|
|
|
|
|
|
WELSEGS::WELSEGS() : ParserKeyword("WELSEGS", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELSEGS");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TOP_DEPTH", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TOP_LENGTH", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WELLBORE_VOLUME", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1e-05) );
|
|
item.push_backDimension("Length*Length*Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("INFO_TYPE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PRESSURE_COMPONENTS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("HFA") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FLOW_MODEL", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("HO") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TOP_X", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TOP_Y", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("SEGMENT1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("BRANCH", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("JOIN_SEGMENT", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LENGTH", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DEPTH", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DIAMETER", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ROUGHNESS", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("AREA", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length*Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VOLUME", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length*Length*Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LENGTH_X", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LENGTH_Y", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELSEGS::keywordName = "WELSEGS";
|
|
const std::string WELSEGS::WELL::itemName = "WELL";
|
|
const std::string WELSEGS::TOP_DEPTH::itemName = "TOP_DEPTH";
|
|
const std::string WELSEGS::TOP_LENGTH::itemName = "TOP_LENGTH";
|
|
const std::string WELSEGS::WELLBORE_VOLUME::itemName = "WELLBORE_VOLUME";
|
|
const std::string WELSEGS::INFO_TYPE::itemName = "INFO_TYPE";
|
|
const std::string WELSEGS::PRESSURE_COMPONENTS::itemName = "PRESSURE_COMPONENTS";
|
|
const std::string WELSEGS::PRESSURE_COMPONENTS::defaultValue = "HFA";
|
|
const std::string WELSEGS::FLOW_MODEL::itemName = "FLOW_MODEL";
|
|
const std::string WELSEGS::FLOW_MODEL::defaultValue = "HO";
|
|
const std::string WELSEGS::TOP_X::itemName = "TOP_X";
|
|
const std::string WELSEGS::TOP_Y::itemName = "TOP_Y";
|
|
const std::string WELSEGS::SEGMENT1::itemName = "SEGMENT1";
|
|
const std::string WELSEGS::SEGMENT2::itemName = "SEGMENT2";
|
|
const std::string WELSEGS::BRANCH::itemName = "BRANCH";
|
|
const std::string WELSEGS::JOIN_SEGMENT::itemName = "JOIN_SEGMENT";
|
|
const std::string WELSEGS::LENGTH::itemName = "LENGTH";
|
|
const std::string WELSEGS::DEPTH::itemName = "DEPTH";
|
|
const std::string WELSEGS::DIAMETER::itemName = "DIAMETER";
|
|
const std::string WELSEGS::ROUGHNESS::itemName = "ROUGHNESS";
|
|
const std::string WELSEGS::AREA::itemName = "AREA";
|
|
const std::string WELSEGS::VOLUME::itemName = "VOLUME";
|
|
const std::string WELSEGS::LENGTH_X::itemName = "LENGTH_X";
|
|
const std::string WELSEGS::LENGTH_Y::itemName = "LENGTH_Y";
|
|
|
|
|
|
WELSOMIN::WELSOMIN() : ParserKeyword("WELSOMIN", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELSOMIN");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("SOMIN", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELSOMIN::keywordName = "WELSOMIN";
|
|
const std::string WELSOMIN::SOMIN::itemName = "SOMIN";
|
|
|
|
|
|
WELSPECL::WELSPECL() : ParserKeyword("WELSPECL", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELSPECL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GROUP", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LGR", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("HEAD_I", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("HEAD_J", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("REF_DEPTH", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PHASE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("D_RADIUS", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("INFLOW_EQ", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("STD") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("AUTO_SHUTIN", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("SHUT") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CROSSFLOW", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("YES") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("P_TABLE", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DENSITY_CALC", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("SEG") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FIP_REGION", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FRONTSIM1", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FRONTSIM2", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("well_model", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("STD") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("POLYMER_TABLE", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELSPECL::keywordName = "WELSPECL";
|
|
const std::string WELSPECL::WELL::itemName = "WELL";
|
|
const std::string WELSPECL::GROUP::itemName = "GROUP";
|
|
const std::string WELSPECL::LGR::itemName = "LGR";
|
|
const std::string WELSPECL::HEAD_I::itemName = "HEAD_I";
|
|
const std::string WELSPECL::HEAD_J::itemName = "HEAD_J";
|
|
const std::string WELSPECL::REF_DEPTH::itemName = "REF_DEPTH";
|
|
const std::string WELSPECL::PHASE::itemName = "PHASE";
|
|
const std::string WELSPECL::D_RADIUS::itemName = "D_RADIUS";
|
|
const std::string WELSPECL::INFLOW_EQ::itemName = "INFLOW_EQ";
|
|
const std::string WELSPECL::INFLOW_EQ::defaultValue = "STD";
|
|
const std::string WELSPECL::AUTO_SHUTIN::itemName = "AUTO_SHUTIN";
|
|
const std::string WELSPECL::AUTO_SHUTIN::defaultValue = "SHUT";
|
|
const std::string WELSPECL::CROSSFLOW::itemName = "CROSSFLOW";
|
|
const std::string WELSPECL::CROSSFLOW::defaultValue = "YES";
|
|
const std::string WELSPECL::P_TABLE::itemName = "P_TABLE";
|
|
const std::string WELSPECL::DENSITY_CALC::itemName = "DENSITY_CALC";
|
|
const std::string WELSPECL::DENSITY_CALC::defaultValue = "SEG";
|
|
const std::string WELSPECL::FIP_REGION::itemName = "FIP_REGION";
|
|
const std::string WELSPECL::FRONTSIM1::itemName = "FRONTSIM1";
|
|
const std::string WELSPECL::FRONTSIM2::itemName = "FRONTSIM2";
|
|
const std::string WELSPECL::well_model::itemName = "well_model";
|
|
const std::string WELSPECL::well_model::defaultValue = "STD";
|
|
const std::string WELSPECL::POLYMER_TABLE::itemName = "POLYMER_TABLE";
|
|
|
|
|
|
WELSPECS::WELSPECS() : ParserKeyword("WELSPECS", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELSPECS");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GROUP", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("HEAD_I", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("HEAD_J", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("REF_DEPTH", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PHASE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("D_RADIUS", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("INFLOW_EQ", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("STD") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("AUTO_SHUTIN", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("SHUT") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CROSSFLOW", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("YES") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("P_TABLE", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DENSITY_CALC", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("SEG") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FIP_REGION", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FRONTSIM1", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FRONTSIM2", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("well_model", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("STD") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("POLYMER_TABLE", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELSPECS::keywordName = "WELSPECS";
|
|
const std::string WELSPECS::WELL::itemName = "WELL";
|
|
const std::string WELSPECS::GROUP::itemName = "GROUP";
|
|
const std::string WELSPECS::HEAD_I::itemName = "HEAD_I";
|
|
const std::string WELSPECS::HEAD_J::itemName = "HEAD_J";
|
|
const std::string WELSPECS::REF_DEPTH::itemName = "REF_DEPTH";
|
|
const std::string WELSPECS::PHASE::itemName = "PHASE";
|
|
const std::string WELSPECS::D_RADIUS::itemName = "D_RADIUS";
|
|
const std::string WELSPECS::INFLOW_EQ::itemName = "INFLOW_EQ";
|
|
const std::string WELSPECS::INFLOW_EQ::defaultValue = "STD";
|
|
const std::string WELSPECS::AUTO_SHUTIN::itemName = "AUTO_SHUTIN";
|
|
const std::string WELSPECS::AUTO_SHUTIN::defaultValue = "SHUT";
|
|
const std::string WELSPECS::CROSSFLOW::itemName = "CROSSFLOW";
|
|
const std::string WELSPECS::CROSSFLOW::defaultValue = "YES";
|
|
const std::string WELSPECS::P_TABLE::itemName = "P_TABLE";
|
|
const std::string WELSPECS::DENSITY_CALC::itemName = "DENSITY_CALC";
|
|
const std::string WELSPECS::DENSITY_CALC::defaultValue = "SEG";
|
|
const std::string WELSPECS::FIP_REGION::itemName = "FIP_REGION";
|
|
const std::string WELSPECS::FRONTSIM1::itemName = "FRONTSIM1";
|
|
const std::string WELSPECS::FRONTSIM2::itemName = "FRONTSIM2";
|
|
const std::string WELSPECS::well_model::itemName = "well_model";
|
|
const std::string WELSPECS::well_model::defaultValue = "STD";
|
|
const std::string WELSPECS::POLYMER_TABLE::itemName = "POLYMER_TABLE";
|
|
|
|
|
|
WELTARG::WELTARG() : ParserKeyword("WELTARG", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELTARG");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CMODE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NEW_VALUE", ParserItem::itype::UDA);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELTARG::keywordName = "WELTARG";
|
|
const std::string WELTARG::WELL::itemName = "WELL";
|
|
const std::string WELTARG::CMODE::itemName = "CMODE";
|
|
const std::string WELTARG::NEW_VALUE::itemName = "NEW_VALUE";
|
|
|
|
|
|
WELTRAJ::WELTRAJ() : ParserKeyword("WELTRAJ", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WELTRAJ");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("BRANCH_NUMBER", ParserItem::itype::INT);
|
|
item.setDefault( 1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("X", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("Y", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TVD", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MD", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WELTRAJ::keywordName = "WELTRAJ";
|
|
const std::string WELTRAJ::WELL::itemName = "WELL";
|
|
const std::string WELTRAJ::BRANCH_NUMBER::itemName = "BRANCH_NUMBER";
|
|
const std::string WELTRAJ::X::itemName = "X";
|
|
const std::string WELTRAJ::Y::itemName = "Y";
|
|
const std::string WELTRAJ::TVD::itemName = "TVD";
|
|
const std::string WELTRAJ::MD::itemName = "MD";
|
|
|
|
|
|
WFOAM::WFOAM() : ParserKeyword("WFOAM", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WFOAM");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FOAM_CONCENTRATION", ParserItem::itype::UDA);
|
|
item.push_backDimension("FoamDensity");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WFOAM::keywordName = "WFOAM";
|
|
const std::string WFOAM::WELL::itemName = "WELL";
|
|
const std::string WFOAM::FOAM_CONCENTRATION::itemName = "FOAM_CONCENTRATION";
|
|
|
|
|
|
WFRICSEG::WFRICSEG() : ParserKeyword("WFRICSEG", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WFRICSEG");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TUBINGD", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ROUGHNESS", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FLOW_SCALING", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WFRICSEG::keywordName = "WFRICSEG";
|
|
const std::string WFRICSEG::WELL::itemName = "WELL";
|
|
const std::string WFRICSEG::TUBINGD::itemName = "TUBINGD";
|
|
const std::string WFRICSEG::ROUGHNESS::itemName = "ROUGHNESS";
|
|
const std::string WFRICSEG::FLOW_SCALING::itemName = "FLOW_SCALING";
|
|
|
|
|
|
WFRICSGL::WFRICSGL() : ParserKeyword("WFRICSGL", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WFRICSGL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TUBINGD", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ROUGHNESS", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FLOW_SCALING", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WFRICSGL::keywordName = "WFRICSGL";
|
|
const std::string WFRICSGL::WELL::itemName = "WELL";
|
|
const std::string WFRICSGL::TUBINGD::itemName = "TUBINGD";
|
|
const std::string WFRICSGL::ROUGHNESS::itemName = "ROUGHNESS";
|
|
const std::string WFRICSGL::FLOW_SCALING::itemName = "FLOW_SCALING";
|
|
|
|
|
|
WFRICTN::WFRICTN() : ParserKeyword("WFRICTN", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WFRICTN");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TUBINGD", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ROUGHNESS", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FLOW_SCALING", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WFRICTN::keywordName = "WFRICTN";
|
|
const std::string WFRICTN::WELL::itemName = "WELL";
|
|
const std::string WFRICTN::TUBINGD::itemName = "TUBINGD";
|
|
const std::string WFRICTN::ROUGHNESS::itemName = "ROUGHNESS";
|
|
const std::string WFRICTN::FLOW_SCALING::itemName = "FLOW_SCALING";
|
|
|
|
|
|
WFRICTNL::WFRICTNL() : ParserKeyword("WFRICTNL", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WFRICTNL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TUBINGD", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ROUGHNESS", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FLOW_SCALING", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WFRICTNL::keywordName = "WFRICTNL";
|
|
const std::string WFRICTNL::WELL::itemName = "WELL";
|
|
const std::string WFRICTNL::TUBINGD::itemName = "TUBINGD";
|
|
const std::string WFRICTNL::ROUGHNESS::itemName = "ROUGHNESS";
|
|
const std::string WFRICTNL::FLOW_SCALING::itemName = "FLOW_SCALING";
|
|
|
|
|
|
WGASPROD::WGASPROD() : ParserKeyword("WGASPROD", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WGASPROD");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL_NAME", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("INCREMENTAL_GAS_PRODUCTION_RATE", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_INCREMENTS", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WGASPROD::keywordName = "WGASPROD";
|
|
const std::string WGASPROD::WELL_NAME::itemName = "WELL_NAME";
|
|
const std::string WGASPROD::INCREMENTAL_GAS_PRODUCTION_RATE::itemName = "INCREMENTAL_GAS_PRODUCTION_RATE";
|
|
const std::string WGASPROD::MAX_INCREMENTS::itemName = "MAX_INCREMENTS";
|
|
|
|
|
|
WGORPEN::WGORPEN() : ParserKeyword("WGORPEN", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WGORPEN");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL_NAME", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("BASE_GOR", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_OIL_RATE", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("LiquidSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("AVG_GOR0", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WGORPEN::keywordName = "WGORPEN";
|
|
const std::string WGORPEN::WELL_NAME::itemName = "WELL_NAME";
|
|
const std::string WGORPEN::BASE_GOR::itemName = "BASE_GOR";
|
|
const std::string WGORPEN::MAX_OIL_RATE::itemName = "MAX_OIL_RATE";
|
|
const std::string WGORPEN::AVG_GOR0::itemName = "AVG_GOR0";
|
|
|
|
|
|
WGRUPCON::WGRUPCON() : ParserKeyword("WGRUPCON", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WGRUPCON");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GROUP_CONTROLLED", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("YES") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GUIDE_RATE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(-1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PHASE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SCALING_FACTOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WGRUPCON::keywordName = "WGRUPCON";
|
|
const std::string WGRUPCON::WELL::itemName = "WELL";
|
|
const std::string WGRUPCON::GROUP_CONTROLLED::itemName = "GROUP_CONTROLLED";
|
|
const std::string WGRUPCON::GROUP_CONTROLLED::defaultValue = "YES";
|
|
const std::string WGRUPCON::GUIDE_RATE::itemName = "GUIDE_RATE";
|
|
const std::string WGRUPCON::PHASE::itemName = "PHASE";
|
|
const std::string WGRUPCON::SCALING_FACTOR::itemName = "SCALING_FACTOR";
|
|
|
|
|
|
WH2NUM::WH2NUM() : ParserKeyword("WH2NUM", KeywordSize(1, false)) {
|
|
addValidSectionName("REGIONS");
|
|
clearDeckNames();
|
|
addDeckName("WH2NUM");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("data", ParserItem::itype::INT);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addDataItem(item);
|
|
}
|
|
addDataRecord( record );
|
|
}
|
|
}
|
|
const std::string WH2NUM::keywordName = "WH2NUM";
|
|
const std::string WH2NUM::data::itemName = "data";
|
|
|
|
|
|
WH3NUM::WH3NUM() : ParserKeyword("WH3NUM", KeywordSize(1, false)) {
|
|
addValidSectionName("REGIONS");
|
|
clearDeckNames();
|
|
addDeckName("WH3NUM");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("data", ParserItem::itype::INT);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addDataItem(item);
|
|
}
|
|
addDataRecord( record );
|
|
}
|
|
}
|
|
const std::string WH3NUM::keywordName = "WH3NUM";
|
|
const std::string WH3NUM::data::itemName = "data";
|
|
|
|
|
|
WHEDREFD::WHEDREFD() : ParserKeyword("WHEDREFD", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WHEDREFD");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DEPTH", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WHEDREFD::keywordName = "WHEDREFD";
|
|
const std::string WHEDREFD::WELL::itemName = "WELL";
|
|
const std::string WHEDREFD::DEPTH::itemName = "DEPTH";
|
|
|
|
|
|
WHISTCTL::WHISTCTL() : ParserKeyword("WHISTCTL", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WHISTCTL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("CMODE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NONE") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("BPH_TERMINATE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WHISTCTL::keywordName = "WHISTCTL";
|
|
const std::string WHISTCTL::CMODE::itemName = "CMODE";
|
|
const std::string WHISTCTL::CMODE::defaultValue = "NONE";
|
|
const std::string WHISTCTL::BPH_TERMINATE::itemName = "BPH_TERMINATE";
|
|
const std::string WHISTCTL::BPH_TERMINATE::defaultValue = "NO";
|
|
|
|
|
|
WHTEMP::WHTEMP() : ParserKeyword("WHTEMP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WHTEMP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VFP_TABLE", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("THP_TEMP", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Temperature");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WHTEMP::keywordName = "WHTEMP";
|
|
const std::string WHTEMP::WELL::itemName = "WELL";
|
|
const std::string WHTEMP::VFP_TABLE::itemName = "VFP_TABLE";
|
|
const std::string WHTEMP::THP_TEMP::itemName = "THP_TEMP";
|
|
|
|
|
|
WINJCLN::WINJCLN() : ParserKeyword("WINJCLN", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WINJCLN");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL_NAME", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FRAC_REMOVE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WINJCLN::keywordName = "WINJCLN";
|
|
const std::string WINJCLN::WELL_NAME::itemName = "WELL_NAME";
|
|
const std::string WINJCLN::FRAC_REMOVE::itemName = "FRAC_REMOVE";
|
|
const std::string WINJCLN::I::itemName = "I";
|
|
const std::string WINJCLN::J::itemName = "J";
|
|
const std::string WINJCLN::K::itemName = "K";
|
|
|
|
|
|
WINJDAM::WINJDAM() : ParserKeyword("WINJDAM", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WINJDAM");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL_NAME", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GEOMETRY", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FILTER_CAKE_PERM", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Permeability");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FILTER_CAKE_PORO", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.300000) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FILTER_CAKE_RADIUS", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FILTER_CAKE_AREA", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length*Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WINJDAM::keywordName = "WINJDAM";
|
|
const std::string WINJDAM::WELL_NAME::itemName = "WELL_NAME";
|
|
const std::string WINJDAM::GEOMETRY::itemName = "GEOMETRY";
|
|
const std::string WINJDAM::FILTER_CAKE_PERM::itemName = "FILTER_CAKE_PERM";
|
|
const std::string WINJDAM::FILTER_CAKE_PORO::itemName = "FILTER_CAKE_PORO";
|
|
const std::string WINJDAM::FILTER_CAKE_RADIUS::itemName = "FILTER_CAKE_RADIUS";
|
|
const std::string WINJDAM::FILTER_CAKE_AREA::itemName = "FILTER_CAKE_AREA";
|
|
const std::string WINJDAM::I::itemName = "I";
|
|
const std::string WINJDAM::J::itemName = "J";
|
|
const std::string WINJDAM::K::itemName = "K";
|
|
|
|
|
|
WINJFCNC::WINJFCNC() : ParserKeyword("WINJFCNC", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WINJFCNC");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VOL_CONCENTRATION", ParserItem::itype::UDA);
|
|
item.setDefault( UDAValue(0) );
|
|
item.push_backDimension("PPM");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WINJFCNC::keywordName = "WINJFCNC";
|
|
const std::string WINJFCNC::WELL::itemName = "WELL";
|
|
const std::string WINJFCNC::VOL_CONCENTRATION::itemName = "VOL_CONCENTRATION";
|
|
const UDAValue WINJFCNC::VOL_CONCENTRATION::defaultValue = UDAValue(0);
|
|
|
|
|
|
WINJGAS::WINJGAS() : ParserKeyword("WINJGAS", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WINJGAS");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FLUID", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("GRUP") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STREAM", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAKEUPGAS", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STAGE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WINJGAS::keywordName = "WINJGAS";
|
|
const std::string WINJGAS::WELL::itemName = "WELL";
|
|
const std::string WINJGAS::FLUID::itemName = "FLUID";
|
|
const std::string WINJGAS::FLUID::defaultValue = "GRUP";
|
|
const std::string WINJGAS::STREAM::itemName = "STREAM";
|
|
const std::string WINJGAS::MAKEUPGAS::itemName = "MAKEUPGAS";
|
|
const std::string WINJGAS::STAGE::itemName = "STAGE";
|
|
|
|
|
|
WINJMULT::WINJMULT() : ParserKeyword("WINJMULT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WINJMULT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL_NAME", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FRACTURING_PRESSURE", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MULTIPLIER_GRADIENT", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("1/Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MODE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("WREV") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WINJMULT::keywordName = "WINJMULT";
|
|
const std::string WINJMULT::WELL_NAME::itemName = "WELL_NAME";
|
|
const std::string WINJMULT::FRACTURING_PRESSURE::itemName = "FRACTURING_PRESSURE";
|
|
const std::string WINJMULT::MULTIPLIER_GRADIENT::itemName = "MULTIPLIER_GRADIENT";
|
|
const std::string WINJMULT::MODE::itemName = "MODE";
|
|
const std::string WINJMULT::MODE::defaultValue = "WREV";
|
|
const std::string WINJMULT::I::itemName = "I";
|
|
const std::string WINJMULT::J::itemName = "J";
|
|
const std::string WINJMULT::K::itemName = "K";
|
|
|
|
|
|
WINJTEMP::WINJTEMP() : ParserKeyword("WINJTEMP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WINJTEMP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STEAM_QUALITY", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TEMPERATURE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(15.560000) );
|
|
item.push_backDimension("Temperature");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PRESSURE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ENTHALPY", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Energy/Mass");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WINJTEMP::keywordName = "WINJTEMP";
|
|
const std::string WINJTEMP::WELL::itemName = "WELL";
|
|
const std::string WINJTEMP::STEAM_QUALITY::itemName = "STEAM_QUALITY";
|
|
const std::string WINJTEMP::TEMPERATURE::itemName = "TEMPERATURE";
|
|
const std::string WINJTEMP::PRESSURE::itemName = "PRESSURE";
|
|
const std::string WINJTEMP::ENTHALPY::itemName = "ENTHALPY";
|
|
|
|
|
|
WLIFT::WLIFT() : ParserKeyword("WLIFT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WLIFT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TRIGGER_LIMIT", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TRIGGRE_PHASE", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NEW_VFP_TABLE", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NEW_ALQ_VALUE", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NEW_WEFAC", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WWCT_LIMIT", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NEW_THP_LIMIT", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WGOR_LIMIT", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ALQ_SHIFT", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("THP_SHIFT", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WLIFT::keywordName = "WLIFT";
|
|
const std::string WLIFT::WELL::itemName = "WELL";
|
|
const std::string WLIFT::TRIGGER_LIMIT::itemName = "TRIGGER_LIMIT";
|
|
const std::string WLIFT::TRIGGRE_PHASE::itemName = "TRIGGRE_PHASE";
|
|
const std::string WLIFT::NEW_VFP_TABLE::itemName = "NEW_VFP_TABLE";
|
|
const std::string WLIFT::NEW_ALQ_VALUE::itemName = "NEW_ALQ_VALUE";
|
|
const std::string WLIFT::NEW_WEFAC::itemName = "NEW_WEFAC";
|
|
const std::string WLIFT::WWCT_LIMIT::itemName = "WWCT_LIMIT";
|
|
const std::string WLIFT::NEW_THP_LIMIT::itemName = "NEW_THP_LIMIT";
|
|
const std::string WLIFT::WGOR_LIMIT::itemName = "WGOR_LIMIT";
|
|
const std::string WLIFT::ALQ_SHIFT::itemName = "ALQ_SHIFT";
|
|
const std::string WLIFT::THP_SHIFT::itemName = "THP_SHIFT";
|
|
|
|
|
|
WLIFTOPT::WLIFTOPT() : ParserKeyword("WLIFTOPT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WLIFTOPT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("USE_OPTIMIZER", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_LIFT_GAS_RATE", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("GasSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WEIGHT_FACTOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MIN_LIFT_GAS_RATE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("GasSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DELTA_GAS_RATE_WEIGHT_FACTOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ALLOCATE_EXTRA_LIFT_GAS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WLIFTOPT::keywordName = "WLIFTOPT";
|
|
const std::string WLIFTOPT::WELL::itemName = "WELL";
|
|
const std::string WLIFTOPT::USE_OPTIMIZER::itemName = "USE_OPTIMIZER";
|
|
const std::string WLIFTOPT::MAX_LIFT_GAS_RATE::itemName = "MAX_LIFT_GAS_RATE";
|
|
const std::string WLIFTOPT::WEIGHT_FACTOR::itemName = "WEIGHT_FACTOR";
|
|
const std::string WLIFTOPT::MIN_LIFT_GAS_RATE::itemName = "MIN_LIFT_GAS_RATE";
|
|
const std::string WLIFTOPT::DELTA_GAS_RATE_WEIGHT_FACTOR::itemName = "DELTA_GAS_RATE_WEIGHT_FACTOR";
|
|
const std::string WLIFTOPT::ALLOCATE_EXTRA_LIFT_GAS::itemName = "ALLOCATE_EXTRA_LIFT_GAS";
|
|
const std::string WLIFTOPT::ALLOCATE_EXTRA_LIFT_GAS::defaultValue = "NO";
|
|
|
|
|
|
WLIMTOL::WLIMTOL() : ParserKeyword("WLIMTOL", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WLIMTOL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("TOLERANCE_FRACTION", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WLIMTOL::keywordName = "WLIMTOL";
|
|
const std::string WLIMTOL::TOLERANCE_FRACTION::itemName = "TOLERANCE_FRACTION";
|
|
|
|
|
|
WLIST::WLIST() : ParserKeyword("WLIST", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WLIST");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("NAME", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ACTION", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WELLS", ParserItem::itype::STRING);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WLIST::keywordName = "WLIST";
|
|
const std::string WLIST::NAME::itemName = "NAME";
|
|
const std::string WLIST::ACTION::itemName = "ACTION";
|
|
const std::string WLIST::WELLS::itemName = "WELLS";
|
|
|
|
|
|
WLISTARG::WLISTARG() : ParserKeyword("WLISTARG", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WLISTARG");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CONTROL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VALUES", ParserItem::itype::DOUBLE);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WLISTARG::keywordName = "WLISTARG";
|
|
const std::string WLISTARG::WELL::itemName = "WELL";
|
|
const std::string WLISTARG::CONTROL::itemName = "CONTROL";
|
|
const std::string WLISTARG::VALUES::itemName = "VALUES";
|
|
|
|
|
|
WLISTNAM::WLISTNAM() : ParserKeyword("WLISTNAM", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WLISTNAM");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("LIST_NAME", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WELLS", ParserItem::itype::STRING);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WLISTNAM::keywordName = "WLISTNAM";
|
|
const std::string WLISTNAM::LIST_NAME::itemName = "LIST_NAME";
|
|
const std::string WLISTNAM::WELLS::itemName = "WELLS";
|
|
|
|
|
|
WMICP::WMICP() : ParserKeyword("WMICP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WMICP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MICROBIAL_CONCENTRATION", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Density");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("OXYGEN_CONCENTRATION", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Density");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("UREA_CONCENTRATION", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Density");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WMICP::keywordName = "WMICP";
|
|
const std::string WMICP::WELL::itemName = "WELL";
|
|
const std::string WMICP::MICROBIAL_CONCENTRATION::itemName = "MICROBIAL_CONCENTRATION";
|
|
const std::string WMICP::OXYGEN_CONCENTRATION::itemName = "OXYGEN_CONCENTRATION";
|
|
const std::string WMICP::UREA_CONCENTRATION::itemName = "UREA_CONCENTRATION";
|
|
|
|
|
|
WNETCTRL::WNETCTRL() : ParserKeyword("WNETCTRL", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WNETCTRL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CONTROL", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("THP") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WNETCTRL::keywordName = "WNETCTRL";
|
|
const std::string WNETCTRL::WELL::itemName = "WELL";
|
|
const std::string WNETCTRL::CONTROL::itemName = "CONTROL";
|
|
const std::string WNETCTRL::CONTROL::defaultValue = "THP";
|
|
|
|
|
|
WNETDP::WNETDP() : ParserKeyword("WNETDP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WNETDP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DP", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WNETDP::keywordName = "WNETDP";
|
|
const std::string WNETDP::WELL::itemName = "WELL";
|
|
const std::string WNETDP::DP::itemName = "DP";
|
|
|
|
|
|
WORKLIM::WORKLIM() : ParserKeyword("WORKLIM", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WORKLIM");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("LIMIT", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WORKLIM::keywordName = "WORKLIM";
|
|
const std::string WORKLIM::LIMIT::itemName = "LIMIT";
|
|
|
|
|
|
WORKTHP::WORKTHP() : ParserKeyword("WORKTHP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WORKTHP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL_NAME", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WORK_OVER_PROCEDURE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NONE") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WORKTHP::keywordName = "WORKTHP";
|
|
const std::string WORKTHP::WELL_NAME::itemName = "WELL_NAME";
|
|
const std::string WORKTHP::WORK_OVER_PROCEDURE::itemName = "WORK_OVER_PROCEDURE";
|
|
const std::string WORKTHP::WORK_OVER_PROCEDURE::defaultValue = "NONE";
|
|
|
|
|
|
WPAVE::WPAVE() : ParserKeyword("WPAVE", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WPAVE");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("F1", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.500000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("F2", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DEPTH_CORRECTION", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("WELL") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CONNECTION", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("OPEN") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WPAVE::keywordName = "WPAVE";
|
|
const std::string WPAVE::F1::itemName = "F1";
|
|
const std::string WPAVE::F2::itemName = "F2";
|
|
const std::string WPAVE::DEPTH_CORRECTION::itemName = "DEPTH_CORRECTION";
|
|
const std::string WPAVE::DEPTH_CORRECTION::defaultValue = "WELL";
|
|
const std::string WPAVE::CONNECTION::itemName = "CONNECTION";
|
|
const std::string WPAVE::CONNECTION::defaultValue = "OPEN";
|
|
|
|
|
|
WPAVEDEP::WPAVEDEP() : ParserKeyword("WPAVEDEP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WPAVEDEP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("REFDEPTH", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WPAVEDEP::keywordName = "WPAVEDEP";
|
|
const std::string WPAVEDEP::WELL::itemName = "WELL";
|
|
const std::string WPAVEDEP::REFDEPTH::itemName = "REFDEPTH";
|
|
|
|
|
|
WPIMULT::WPIMULT() : ParserKeyword("WPIMULT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WPIMULT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WELLPI", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FIRST", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LAST", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WPIMULT::keywordName = "WPIMULT";
|
|
const std::string WPIMULT::WELL::itemName = "WELL";
|
|
const std::string WPIMULT::WELLPI::itemName = "WELLPI";
|
|
const std::string WPIMULT::I::itemName = "I";
|
|
const std::string WPIMULT::J::itemName = "J";
|
|
const std::string WPIMULT::K::itemName = "K";
|
|
const std::string WPIMULT::FIRST::itemName = "FIRST";
|
|
const std::string WPIMULT::LAST::itemName = "LAST";
|
|
|
|
|
|
WPIMULTL::WPIMULTL() : ParserKeyword("WPIMULTL", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WPIMULTL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WELLPI", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GRID", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FIRST", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LAST", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WPIMULTL::keywordName = "WPIMULTL";
|
|
const std::string WPIMULTL::WELL::itemName = "WELL";
|
|
const std::string WPIMULTL::WELLPI::itemName = "WELLPI";
|
|
const std::string WPIMULTL::GRID::itemName = "GRID";
|
|
const std::string WPIMULTL::GRID::defaultValue = "";
|
|
const std::string WPIMULTL::I::itemName = "I";
|
|
const std::string WPIMULTL::J::itemName = "J";
|
|
const std::string WPIMULTL::K::itemName = "K";
|
|
const std::string WPIMULTL::FIRST::itemName = "FIRST";
|
|
const std::string WPIMULTL::LAST::itemName = "LAST";
|
|
|
|
|
|
WPITAB::WPITAB() : ParserKeyword("WPITAB", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WPITAB");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PI", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WPITAB::keywordName = "WPITAB";
|
|
const std::string WPITAB::WELL::itemName = "WELL";
|
|
const std::string WPITAB::PI::itemName = "PI";
|
|
|
|
|
|
WPLUG::WPLUG() : ParserKeyword("WPLUG", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WPLUG");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LENGTH_TOP", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LENGTH_BOTTOM", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SOURCE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("WELL") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WPLUG::keywordName = "WPLUG";
|
|
const std::string WPLUG::WELL::itemName = "WELL";
|
|
const std::string WPLUG::LENGTH_TOP::itemName = "LENGTH_TOP";
|
|
const std::string WPLUG::LENGTH_BOTTOM::itemName = "LENGTH_BOTTOM";
|
|
const std::string WPLUG::SOURCE::itemName = "SOURCE";
|
|
const std::string WPLUG::SOURCE::defaultValue = "WELL";
|
|
|
|
|
|
WPMITAB::WPMITAB() : ParserKeyword("WPMITAB", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WPMITAB");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TABLE_NUMBER", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WPMITAB::keywordName = "WPMITAB";
|
|
const std::string WPMITAB::WELL::itemName = "WELL";
|
|
const std::string WPMITAB::TABLE_NUMBER::itemName = "TABLE_NUMBER";
|
|
|
|
|
|
WPOLYMER::WPOLYMER() : ParserKeyword("WPOLYMER", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WPOLYMER");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("POLYMER_CONCENTRATION", ParserItem::itype::UDA);
|
|
item.push_backDimension("PolymerDensity");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SALT_CONCENTRATION", ParserItem::itype::UDA);
|
|
item.push_backDimension("PolymerDensity");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GROUP_POLYMER_CONCENTRATION", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GROUP_SALT_CONCENTRATION", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WPOLYMER::keywordName = "WPOLYMER";
|
|
const std::string WPOLYMER::WELL::itemName = "WELL";
|
|
const std::string WPOLYMER::POLYMER_CONCENTRATION::itemName = "POLYMER_CONCENTRATION";
|
|
const std::string WPOLYMER::SALT_CONCENTRATION::itemName = "SALT_CONCENTRATION";
|
|
const std::string WPOLYMER::GROUP_POLYMER_CONCENTRATION::itemName = "GROUP_POLYMER_CONCENTRATION";
|
|
const std::string WPOLYMER::GROUP_SALT_CONCENTRATION::itemName = "GROUP_SALT_CONCENTRATION";
|
|
|
|
|
|
WPOLYRED::WPOLYRED() : ParserKeyword("WPOLYRED", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WPOLYRED");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("POLYMER_VISCOSITY_RED", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WPOLYRED::keywordName = "WPOLYRED";
|
|
const std::string WPOLYRED::WELL::itemName = "WELL";
|
|
const std::string WPOLYRED::POLYMER_VISCOSITY_RED::itemName = "POLYMER_VISCOSITY_RED";
|
|
|
|
|
|
WPOTCALC::WPOTCALC() : ParserKeyword("WPOTCALC", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("WPOTCALC");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("FORCE_CALC", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("YES") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("USE_SEGMENT_VOLUMES", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WPOTCALC::keywordName = "WPOTCALC";
|
|
const std::string WPOTCALC::FORCE_CALC::itemName = "FORCE_CALC";
|
|
const std::string WPOTCALC::FORCE_CALC::defaultValue = "YES";
|
|
const std::string WPOTCALC::USE_SEGMENT_VOLUMES::itemName = "USE_SEGMENT_VOLUMES";
|
|
const std::string WPOTCALC::USE_SEGMENT_VOLUMES::defaultValue = "NO";
|
|
|
|
|
|
WREGROUP::WREGROUP() : ParserKeyword("WREGROUP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WREGROUP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("QUANTITY", ParserItem::itype::STRING);
|
|
item.setDefault( std::string(" ") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GROUP_UPPER", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("UPPER_LIMIT", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(100000000000000000000.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GROUP_LOWER", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LOWER_LIMIT", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WREGROUP::keywordName = "WREGROUP";
|
|
const std::string WREGROUP::WELL::itemName = "WELL";
|
|
const std::string WREGROUP::QUANTITY::itemName = "QUANTITY";
|
|
const std::string WREGROUP::QUANTITY::defaultValue = " ";
|
|
const std::string WREGROUP::GROUP_UPPER::itemName = "GROUP_UPPER";
|
|
const std::string WREGROUP::UPPER_LIMIT::itemName = "UPPER_LIMIT";
|
|
const std::string WREGROUP::GROUP_LOWER::itemName = "GROUP_LOWER";
|
|
const std::string WREGROUP::LOWER_LIMIT::itemName = "LOWER_LIMIT";
|
|
|
|
|
|
WRFT::WRFT() : ParserKeyword("WRFT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WRFT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WRFT::keywordName = "WRFT";
|
|
const std::string WRFT::WELL::itemName = "WELL";
|
|
|
|
|
|
WRFTPLT::WRFTPLT() : ParserKeyword("WRFTPLT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WRFTPLT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("OUTPUT_RFT", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("OUTPUT_PLT", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("OUTPUT_SEGMENT", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WRFTPLT::keywordName = "WRFTPLT";
|
|
const std::string WRFTPLT::WELL::itemName = "WELL";
|
|
const std::string WRFTPLT::OUTPUT_RFT::itemName = "OUTPUT_RFT";
|
|
const std::string WRFTPLT::OUTPUT_RFT::defaultValue = "NO";
|
|
const std::string WRFTPLT::OUTPUT_PLT::itemName = "OUTPUT_PLT";
|
|
const std::string WRFTPLT::OUTPUT_PLT::defaultValue = "NO";
|
|
const std::string WRFTPLT::OUTPUT_SEGMENT::itemName = "OUTPUT_SEGMENT";
|
|
const std::string WRFTPLT::OUTPUT_SEGMENT::defaultValue = "NO";
|
|
|
|
|
|
WSALT::WSALT() : ParserKeyword("WSALT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSALT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CONCENTRATION", ParserItem::itype::UDA);
|
|
item.push_backDimension("Salinity");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSALT::keywordName = "WSALT";
|
|
const std::string WSALT::WELL::itemName = "WELL";
|
|
const std::string WSALT::CONCENTRATION::itemName = "CONCENTRATION";
|
|
|
|
|
|
WSCCLEAN::WSCCLEAN() : ParserKeyword("WSCCLEAN", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSCCLEAN");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SCALE_MULTIPLIER", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("C1", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("C2", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSCCLEAN::keywordName = "WSCCLEAN";
|
|
const std::string WSCCLEAN::WELL::itemName = "WELL";
|
|
const std::string WSCCLEAN::SCALE_MULTIPLIER::itemName = "SCALE_MULTIPLIER";
|
|
const std::string WSCCLEAN::I::itemName = "I";
|
|
const std::string WSCCLEAN::J::itemName = "J";
|
|
const std::string WSCCLEAN::K::itemName = "K";
|
|
const std::string WSCCLEAN::C1::itemName = "C1";
|
|
const std::string WSCCLEAN::C2::itemName = "C2";
|
|
|
|
|
|
WSCCLENL::WSCCLENL() : ParserKeyword("WSCCLENL", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSCCLENL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SCALE_MULTIPLIER", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LGR", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("C1", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("C2", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSCCLENL::keywordName = "WSCCLENL";
|
|
const std::string WSCCLENL::WELL::itemName = "WELL";
|
|
const std::string WSCCLENL::SCALE_MULTIPLIER::itemName = "SCALE_MULTIPLIER";
|
|
const std::string WSCCLENL::LGR::itemName = "LGR";
|
|
const std::string WSCCLENL::I::itemName = "I";
|
|
const std::string WSCCLENL::J::itemName = "J";
|
|
const std::string WSCCLENL::K::itemName = "K";
|
|
const std::string WSCCLENL::C1::itemName = "C1";
|
|
const std::string WSCCLENL::C2::itemName = "C2";
|
|
|
|
|
|
WSCTAB::WSCTAB() : ParserKeyword("WSCTAB", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSCTAB");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SCALE_DEPOSITION_TABLE", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SCALE_DAMAGE_TABLE", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("UNUSED", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SCALE_DISSOLUTION_TABLE", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSCTAB::keywordName = "WSCTAB";
|
|
const std::string WSCTAB::WELL::itemName = "WELL";
|
|
const std::string WSCTAB::SCALE_DEPOSITION_TABLE::itemName = "SCALE_DEPOSITION_TABLE";
|
|
const std::string WSCTAB::SCALE_DAMAGE_TABLE::itemName = "SCALE_DAMAGE_TABLE";
|
|
const std::string WSCTAB::UNUSED::itemName = "UNUSED";
|
|
const std::string WSCTAB::SCALE_DISSOLUTION_TABLE::itemName = "SCALE_DISSOLUTION_TABLE";
|
|
|
|
|
|
WSEED::WSEED() : ParserKeyword("WSEED", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEED");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("I", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("J", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NORMAL_X", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NORMAL_Y", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NORMAL_Z", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SIZE_Z", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.300000) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SIZE_H", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.300000) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WIDTH", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.000100) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEED::keywordName = "WSEED";
|
|
const std::string WSEED::WELL::itemName = "WELL";
|
|
const std::string WSEED::I::itemName = "I";
|
|
const std::string WSEED::J::itemName = "J";
|
|
const std::string WSEED::K::itemName = "K";
|
|
const std::string WSEED::NORMAL_X::itemName = "NORMAL_X";
|
|
const std::string WSEED::NORMAL_Y::itemName = "NORMAL_Y";
|
|
const std::string WSEED::NORMAL_Z::itemName = "NORMAL_Z";
|
|
const std::string WSEED::SIZE_Z::itemName = "SIZE_Z";
|
|
const std::string WSEED::SIZE_H::itemName = "SIZE_H";
|
|
const std::string WSEED::WIDTH::itemName = "WIDTH";
|
|
|
|
|
|
WSEGAICD::WSEGAICD() : ParserKeyword("WSEGAICD", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGAICD");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STRENGTH", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Pressure*Time*Time/GeometricVolume*GeometricVolume*Density");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LENGTH", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(12.000000) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DENSITY_CALI", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1000.250000) );
|
|
item.push_backDimension("Density");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VISCOSITY_CALI", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.450000) );
|
|
item.push_backDimension("Viscosity");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CRITICAL_VALUE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.500000) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WIDTH_TRANS", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.050000) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_VISC_RATIO", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(5.000000) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("METHOD_SCALING_FACTOR", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_ABS_RATE", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("GeometricVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FLOW_RATE_EXPONENT", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VISC_EXPONENT", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STATUS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("OPEN") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("OIL_FLOW_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WATER_FLOW_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GAS_FLOW_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("OIL_VISC_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WATER_VISC_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GAS_VISC_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGAICD::keywordName = "WSEGAICD";
|
|
const std::string WSEGAICD::WELL::itemName = "WELL";
|
|
const std::string WSEGAICD::SEGMENT1::itemName = "SEGMENT1";
|
|
const std::string WSEGAICD::SEGMENT2::itemName = "SEGMENT2";
|
|
const std::string WSEGAICD::STRENGTH::itemName = "STRENGTH";
|
|
const std::string WSEGAICD::LENGTH::itemName = "LENGTH";
|
|
const std::string WSEGAICD::DENSITY_CALI::itemName = "DENSITY_CALI";
|
|
const std::string WSEGAICD::VISCOSITY_CALI::itemName = "VISCOSITY_CALI";
|
|
const std::string WSEGAICD::CRITICAL_VALUE::itemName = "CRITICAL_VALUE";
|
|
const std::string WSEGAICD::WIDTH_TRANS::itemName = "WIDTH_TRANS";
|
|
const std::string WSEGAICD::MAX_VISC_RATIO::itemName = "MAX_VISC_RATIO";
|
|
const std::string WSEGAICD::METHOD_SCALING_FACTOR::itemName = "METHOD_SCALING_FACTOR";
|
|
const std::string WSEGAICD::MAX_ABS_RATE::itemName = "MAX_ABS_RATE";
|
|
const std::string WSEGAICD::FLOW_RATE_EXPONENT::itemName = "FLOW_RATE_EXPONENT";
|
|
const std::string WSEGAICD::VISC_EXPONENT::itemName = "VISC_EXPONENT";
|
|
const std::string WSEGAICD::STATUS::itemName = "STATUS";
|
|
const std::string WSEGAICD::STATUS::defaultValue = "OPEN";
|
|
const std::string WSEGAICD::OIL_FLOW_FRACTION::itemName = "OIL_FLOW_FRACTION";
|
|
const std::string WSEGAICD::WATER_FLOW_FRACTION::itemName = "WATER_FLOW_FRACTION";
|
|
const std::string WSEGAICD::GAS_FLOW_FRACTION::itemName = "GAS_FLOW_FRACTION";
|
|
const std::string WSEGAICD::OIL_VISC_FRACTION::itemName = "OIL_VISC_FRACTION";
|
|
const std::string WSEGAICD::WATER_VISC_FRACTION::itemName = "WATER_VISC_FRACTION";
|
|
const std::string WSEGAICD::GAS_VISC_FRACTION::itemName = "GAS_VISC_FRACTION";
|
|
|
|
|
|
WSEGDFIN::WSEGDFIN() : ParserKeyword("WSEGDFIN", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGDFIN");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("DATA", ParserItem::itype::DOUBLE);
|
|
item.setSizeType(ParserItem::item_size::ALL);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGDFIN::keywordName = "WSEGDFIN";
|
|
const std::string WSEGDFIN::DATA::itemName = "DATA";
|
|
|
|
|
|
WSEGDFMD::WSEGDFMD() : ParserKeyword("WSEGDFMD", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGDFMD");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("DRIFT_MODEL", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("ORIGINAL") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("INCLINATION_FACTOR", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("H-K") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GAS_EFFECT", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGDFMD::keywordName = "WSEGDFMD";
|
|
const std::string WSEGDFMD::DRIFT_MODEL::itemName = "DRIFT_MODEL";
|
|
const std::string WSEGDFMD::DRIFT_MODEL::defaultValue = "ORIGINAL";
|
|
const std::string WSEGDFMD::INCLINATION_FACTOR::itemName = "INCLINATION_FACTOR";
|
|
const std::string WSEGDFMD::INCLINATION_FACTOR::defaultValue = "H-K";
|
|
const std::string WSEGDFMD::GAS_EFFECT::itemName = "GAS_EFFECT";
|
|
const std::string WSEGDFMD::GAS_EFFECT::defaultValue = "NO";
|
|
|
|
|
|
WSEGDFPA::WSEGDFPA() : ParserKeyword("WSEGDFPA", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGDFPA");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("GAS_LIQUID_VD_FACTOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("A1", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("A2", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("C0_A", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.200000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("C0_B", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FV", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("OIL_WATER_VD_FACTOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(-1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("A", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("B1", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("B2", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("N", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGDFPA::keywordName = "WSEGDFPA";
|
|
const std::string WSEGDFPA::GAS_LIQUID_VD_FACTOR::itemName = "GAS_LIQUID_VD_FACTOR";
|
|
const std::string WSEGDFPA::A1::itemName = "A1";
|
|
const std::string WSEGDFPA::A2::itemName = "A2";
|
|
const std::string WSEGDFPA::C0_A::itemName = "C0_A";
|
|
const std::string WSEGDFPA::C0_B::itemName = "C0_B";
|
|
const std::string WSEGDFPA::FV::itemName = "FV";
|
|
const std::string WSEGDFPA::OIL_WATER_VD_FACTOR::itemName = "OIL_WATER_VD_FACTOR";
|
|
const std::string WSEGDFPA::A::itemName = "A";
|
|
const std::string WSEGDFPA::B1::itemName = "B1";
|
|
const std::string WSEGDFPA::B2::itemName = "B2";
|
|
const std::string WSEGDFPA::N::itemName = "N";
|
|
|
|
|
|
WSEGDIMS::WSEGDIMS() : ParserKeyword("WSEGDIMS", KeywordSize(1, false)) {
|
|
addValidSectionName("RUNSPEC");
|
|
clearDeckNames();
|
|
addDeckName("WSEGDIMS");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("NSWLMX", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NSEGMX", ParserItem::itype::INT);
|
|
item.setDefault( 1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NLBRMX", ParserItem::itype::INT);
|
|
item.setDefault( 1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NCRDMX", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGDIMS::keywordName = "WSEGDIMS";
|
|
const std::string WSEGDIMS::NSWLMX::itemName = "NSWLMX";
|
|
const std::string WSEGDIMS::NSEGMX::itemName = "NSEGMX";
|
|
const std::string WSEGDIMS::NLBRMX::itemName = "NLBRMX";
|
|
const std::string WSEGDIMS::NCRDMX::itemName = "NCRDMX";
|
|
|
|
|
|
WSEGEXSS::WSEGEXSS() : ParserKeyword("WSEGEXSS", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGEXSS");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TYPE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NONE") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GAS_IMPORT_RATE", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("GasSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("R", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("LiquidSurfaceVolume/Time*Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PEXT", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGEXSS::keywordName = "WSEGEXSS";
|
|
const std::string WSEGEXSS::WELL::itemName = "WELL";
|
|
const std::string WSEGEXSS::SEGMENT::itemName = "SEGMENT";
|
|
const std::string WSEGEXSS::TYPE::itemName = "TYPE";
|
|
const std::string WSEGEXSS::TYPE::defaultValue = "NONE";
|
|
const std::string WSEGEXSS::GAS_IMPORT_RATE::itemName = "GAS_IMPORT_RATE";
|
|
const std::string WSEGEXSS::R::itemName = "R";
|
|
const std::string WSEGEXSS::PEXT::itemName = "PEXT";
|
|
|
|
|
|
WSEGFLIM::WSEGFLIM() : ParserKeyword("WSEGFLIM", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGFLIM");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LIMITED_PHASE1", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NONE") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FLOW_LIMIT1", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("LiquidSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("A1", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LIMITED_PHASE2", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NONE") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FLOW_LIMIT2", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("LiquidSurfaceVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("A2", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STATUS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("OPEN") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGFLIM::keywordName = "WSEGFLIM";
|
|
const std::string WSEGFLIM::WELL::itemName = "WELL";
|
|
const std::string WSEGFLIM::SEGMENT1::itemName = "SEGMENT1";
|
|
const std::string WSEGFLIM::SEGMENT2::itemName = "SEGMENT2";
|
|
const std::string WSEGFLIM::LIMITED_PHASE1::itemName = "LIMITED_PHASE1";
|
|
const std::string WSEGFLIM::LIMITED_PHASE1::defaultValue = "NONE";
|
|
const std::string WSEGFLIM::FLOW_LIMIT1::itemName = "FLOW_LIMIT1";
|
|
const std::string WSEGFLIM::A1::itemName = "A1";
|
|
const std::string WSEGFLIM::LIMITED_PHASE2::itemName = "LIMITED_PHASE2";
|
|
const std::string WSEGFLIM::LIMITED_PHASE2::defaultValue = "NONE";
|
|
const std::string WSEGFLIM::FLOW_LIMIT2::itemName = "FLOW_LIMIT2";
|
|
const std::string WSEGFLIM::A2::itemName = "A2";
|
|
const std::string WSEGFLIM::STATUS::itemName = "STATUS";
|
|
const std::string WSEGFLIM::STATUS::defaultValue = "OPEN";
|
|
|
|
|
|
WSEGFMOD::WSEGFMOD() : ParserKeyword("WSEGFMOD", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGFMOD");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FLOW_MODEL", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("HO") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GAS_LIQUID_VD_FACTOR", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("A", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("B", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FV", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("B1", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("B2", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGFMOD::keywordName = "WSEGFMOD";
|
|
const std::string WSEGFMOD::WELL::itemName = "WELL";
|
|
const std::string WSEGFMOD::SEGMENT1::itemName = "SEGMENT1";
|
|
const std::string WSEGFMOD::SEGMENT2::itemName = "SEGMENT2";
|
|
const std::string WSEGFMOD::FLOW_MODEL::itemName = "FLOW_MODEL";
|
|
const std::string WSEGFMOD::FLOW_MODEL::defaultValue = "HO";
|
|
const std::string WSEGFMOD::GAS_LIQUID_VD_FACTOR::itemName = "GAS_LIQUID_VD_FACTOR";
|
|
const std::string WSEGFMOD::A::itemName = "A";
|
|
const std::string WSEGFMOD::B::itemName = "B";
|
|
const std::string WSEGFMOD::FV::itemName = "FV";
|
|
const std::string WSEGFMOD::B1::itemName = "B1";
|
|
const std::string WSEGFMOD::B2::itemName = "B2";
|
|
|
|
|
|
WSEGINIT::WSEGINIT() : ParserKeyword("WSEGINIT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGINIT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("P0", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("W0", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("G0", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("RS", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("RV", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("API", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("POLYMER", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Mass/ReservoirVolume");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("BRINE", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Mass/ReservoirVolume");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGINIT::keywordName = "WSEGINIT";
|
|
const std::string WSEGINIT::WELL::itemName = "WELL";
|
|
const std::string WSEGINIT::SEGMENT1::itemName = "SEGMENT1";
|
|
const std::string WSEGINIT::SEGMENT2::itemName = "SEGMENT2";
|
|
const std::string WSEGINIT::P0::itemName = "P0";
|
|
const std::string WSEGINIT::W0::itemName = "W0";
|
|
const std::string WSEGINIT::G0::itemName = "G0";
|
|
const std::string WSEGINIT::RS::itemName = "RS";
|
|
const std::string WSEGINIT::RV::itemName = "RV";
|
|
const std::string WSEGINIT::API::itemName = "API";
|
|
const std::string WSEGINIT::POLYMER::itemName = "POLYMER";
|
|
const std::string WSEGINIT::BRINE::itemName = "BRINE";
|
|
|
|
|
|
WSEGITER::WSEGITER() : ParserKeyword("WSEGITER", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGITER");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("MAX_WELL_ITERATIONS", ParserItem::itype::INT);
|
|
item.setDefault( 40 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_TIMES_REDUCED", ParserItem::itype::INT);
|
|
item.setDefault( 5 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("REDUCTION_FACTOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.300000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("INCREASING_FACTOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(2.000000) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGITER::keywordName = "WSEGITER";
|
|
const std::string WSEGITER::MAX_WELL_ITERATIONS::itemName = "MAX_WELL_ITERATIONS";
|
|
const std::string WSEGITER::MAX_TIMES_REDUCED::itemName = "MAX_TIMES_REDUCED";
|
|
const std::string WSEGITER::REDUCTION_FACTOR::itemName = "REDUCTION_FACTOR";
|
|
const std::string WSEGITER::INCREASING_FACTOR::itemName = "INCREASING_FACTOR";
|
|
|
|
|
|
WSEGLABY::WSEGLABY() : ParserKeyword("WSEGLABY", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGLABY");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NCONFIG", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CHANNELS", ParserItem::itype::INT);
|
|
item.setDefault( 2 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("A", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(6e-05) );
|
|
item.push_backDimension("Length*Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("L1", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.186300) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("L2", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.283200) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("D", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.006316) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("R", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1e-05) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GAMMA_INLET", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.350000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GAMMA_OUTLET", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.500000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GAMMA_LAB", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.500000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STATUS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("OPEN") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGLABY::keywordName = "WSEGLABY";
|
|
const std::string WSEGLABY::WELL::itemName = "WELL";
|
|
const std::string WSEGLABY::SEGMENT1::itemName = "SEGMENT1";
|
|
const std::string WSEGLABY::SEGMENT2::itemName = "SEGMENT2";
|
|
const std::string WSEGLABY::NCONFIG::itemName = "NCONFIG";
|
|
const std::string WSEGLABY::CHANNELS::itemName = "CHANNELS";
|
|
const std::string WSEGLABY::A::itemName = "A";
|
|
const std::string WSEGLABY::L1::itemName = "L1";
|
|
const std::string WSEGLABY::L2::itemName = "L2";
|
|
const std::string WSEGLABY::D::itemName = "D";
|
|
const std::string WSEGLABY::R::itemName = "R";
|
|
const std::string WSEGLABY::GAMMA_INLET::itemName = "GAMMA_INLET";
|
|
const std::string WSEGLABY::GAMMA_OUTLET::itemName = "GAMMA_OUTLET";
|
|
const std::string WSEGLABY::GAMMA_LAB::itemName = "GAMMA_LAB";
|
|
const std::string WSEGLABY::STATUS::itemName = "STATUS";
|
|
const std::string WSEGLABY::STATUS::defaultValue = "OPEN";
|
|
|
|
|
|
WSEGLINK::WSEGLINK() : ParserKeyword("WSEGLINK", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGLINK");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGLINK::keywordName = "WSEGLINK";
|
|
const std::string WSEGLINK::WELL::itemName = "WELL";
|
|
const std::string WSEGLINK::SEGMENT1::itemName = "SEGMENT1";
|
|
const std::string WSEGLINK::SEGMENT2::itemName = "SEGMENT2";
|
|
|
|
|
|
WSEGMULT::WSEGMULT() : ParserKeyword("WSEGMULT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGMULT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("A", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("B", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("C", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("D", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("E", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("GOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGMULT::keywordName = "WSEGMULT";
|
|
const std::string WSEGMULT::WELL::itemName = "WELL";
|
|
const std::string WSEGMULT::SEGMENT1::itemName = "SEGMENT1";
|
|
const std::string WSEGMULT::SEGMENT2::itemName = "SEGMENT2";
|
|
const std::string WSEGMULT::A::itemName = "A";
|
|
const std::string WSEGMULT::B::itemName = "B";
|
|
const std::string WSEGMULT::C::itemName = "C";
|
|
const std::string WSEGMULT::D::itemName = "D";
|
|
const std::string WSEGMULT::E::itemName = "E";
|
|
const std::string WSEGMULT::GOR::itemName = "GOR";
|
|
|
|
|
|
WSEGPROP::WSEGPROP() : ParserKeyword("WSEGPROP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGPROP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("D", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("R", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("A", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length*Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("V", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length*Length*Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PIPEA", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length*Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CV", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("K", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGPROP::keywordName = "WSEGPROP";
|
|
const std::string WSEGPROP::WELL::itemName = "WELL";
|
|
const std::string WSEGPROP::SEGMENT1::itemName = "SEGMENT1";
|
|
const std::string WSEGPROP::SEGMENT2::itemName = "SEGMENT2";
|
|
const std::string WSEGPROP::D::itemName = "D";
|
|
const std::string WSEGPROP::R::itemName = "R";
|
|
const std::string WSEGPROP::A::itemName = "A";
|
|
const std::string WSEGPROP::V::itemName = "V";
|
|
const std::string WSEGPROP::PIPEA::itemName = "PIPEA";
|
|
const std::string WSEGPROP::CV::itemName = "CV";
|
|
const std::string WSEGPROP::K::itemName = "K";
|
|
|
|
|
|
WSEGSEP::WSEGSEP() : ParserKeyword("WSEGSEP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGSEP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PHASE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NONE") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("EMAX", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("HOLDUP_FRACTION", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.010000) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGSEP::keywordName = "WSEGSEP";
|
|
const std::string WSEGSEP::WELL::itemName = "WELL";
|
|
const std::string WSEGSEP::SEGMENT1::itemName = "SEGMENT1";
|
|
const std::string WSEGSEP::SEGMENT2::itemName = "SEGMENT2";
|
|
const std::string WSEGSEP::PHASE::itemName = "PHASE";
|
|
const std::string WSEGSEP::PHASE::defaultValue = "NONE";
|
|
const std::string WSEGSEP::EMAX::itemName = "EMAX";
|
|
const std::string WSEGSEP::HOLDUP_FRACTION::itemName = "HOLDUP_FRACTION";
|
|
|
|
|
|
WSEGSICD::WSEGSICD() : ParserKeyword("WSEGSICD", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGSICD");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STRENGTH", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Pressure*Time*Time/GeometricVolume*GeometricVolume");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LENGTH", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(12.000000) );
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DENSITY_CALI", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1000.250000) );
|
|
item.push_backDimension("Density");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VISCOSITY_CALI", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.450000) );
|
|
item.push_backDimension("Viscosity");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CRITICAL_VALUE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.500000) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("WIDTH_TRANS", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.050000) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_VISC_RATIO", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(5.000000) );
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("METHOD_SCALING_FACTOR", ParserItem::itype::INT);
|
|
item.setDefault( -1 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_ABS_RATE", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("GeometricVolume/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STATUS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("OPEN") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGSICD::keywordName = "WSEGSICD";
|
|
const std::string WSEGSICD::WELL::itemName = "WELL";
|
|
const std::string WSEGSICD::SEGMENT1::itemName = "SEGMENT1";
|
|
const std::string WSEGSICD::SEGMENT2::itemName = "SEGMENT2";
|
|
const std::string WSEGSICD::STRENGTH::itemName = "STRENGTH";
|
|
const std::string WSEGSICD::LENGTH::itemName = "LENGTH";
|
|
const std::string WSEGSICD::DENSITY_CALI::itemName = "DENSITY_CALI";
|
|
const std::string WSEGSICD::VISCOSITY_CALI::itemName = "VISCOSITY_CALI";
|
|
const std::string WSEGSICD::CRITICAL_VALUE::itemName = "CRITICAL_VALUE";
|
|
const std::string WSEGSICD::WIDTH_TRANS::itemName = "WIDTH_TRANS";
|
|
const std::string WSEGSICD::MAX_VISC_RATIO::itemName = "MAX_VISC_RATIO";
|
|
const std::string WSEGSICD::METHOD_SCALING_FACTOR::itemName = "METHOD_SCALING_FACTOR";
|
|
const std::string WSEGSICD::MAX_ABS_RATE::itemName = "MAX_ABS_RATE";
|
|
const std::string WSEGSICD::STATUS::itemName = "STATUS";
|
|
const std::string WSEGSICD::STATUS::defaultValue = "OPEN";
|
|
|
|
|
|
WSEGSOLV::WSEGSOLV() : ParserKeyword("WSEGSOLV", KeywordSize(1, false)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGSOLV");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("USE_ITERATIVE_SOLVER", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_LINEAR_ITER", ParserItem::itype::INT);
|
|
item.setDefault( 30 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CONVERGENCE_TARGET", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1e-10) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PC_FILL", ParserItem::itype::INT);
|
|
item.setDefault( 2 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DROP_TOL", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("P_LIMIT", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1e-08) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LOOP_THRESHOLD", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(-1.000000) );
|
|
item.push_backDimension("Length*Length*Length/Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LOOP_MULTIPLIER", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(-1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGSOLV::keywordName = "WSEGSOLV";
|
|
const std::string WSEGSOLV::USE_ITERATIVE_SOLVER::itemName = "USE_ITERATIVE_SOLVER";
|
|
const std::string WSEGSOLV::USE_ITERATIVE_SOLVER::defaultValue = "NO";
|
|
const std::string WSEGSOLV::MAX_LINEAR_ITER::itemName = "MAX_LINEAR_ITER";
|
|
const std::string WSEGSOLV::CONVERGENCE_TARGET::itemName = "CONVERGENCE_TARGET";
|
|
const std::string WSEGSOLV::PC_FILL::itemName = "PC_FILL";
|
|
const std::string WSEGSOLV::DROP_TOL::itemName = "DROP_TOL";
|
|
const std::string WSEGSOLV::P_LIMIT::itemName = "P_LIMIT";
|
|
const std::string WSEGSOLV::LOOP_THRESHOLD::itemName = "LOOP_THRESHOLD";
|
|
const std::string WSEGSOLV::LOOP_MULTIPLIER::itemName = "LOOP_MULTIPLIER";
|
|
|
|
|
|
WSEGTABL::WSEGTABL() : ParserKeyword("WSEGTABL", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGTABL");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT1", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT2", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VFP", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VFP_COMPONENTS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("FH") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("VFP_OUTLIER", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DP_SCALING", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("LEN") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ALQ_VALUE", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STATUS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("OPEN") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGTABL::keywordName = "WSEGTABL";
|
|
const std::string WSEGTABL::WELL::itemName = "WELL";
|
|
const std::string WSEGTABL::SEGMENT1::itemName = "SEGMENT1";
|
|
const std::string WSEGTABL::SEGMENT2::itemName = "SEGMENT2";
|
|
const std::string WSEGTABL::VFP::itemName = "VFP";
|
|
const std::string WSEGTABL::VFP_COMPONENTS::itemName = "VFP_COMPONENTS";
|
|
const std::string WSEGTABL::VFP_COMPONENTS::defaultValue = "FH";
|
|
const std::string WSEGTABL::VFP_OUTLIER::itemName = "VFP_OUTLIER";
|
|
const std::string WSEGTABL::DP_SCALING::itemName = "DP_SCALING";
|
|
const std::string WSEGTABL::DP_SCALING::defaultValue = "LEN";
|
|
const std::string WSEGTABL::ALQ_VALUE::itemName = "ALQ_VALUE";
|
|
const std::string WSEGTABL::STATUS::itemName = "STATUS";
|
|
const std::string WSEGTABL::STATUS::defaultValue = "OPEN";
|
|
|
|
|
|
WSEGVALV::WSEGVALV() : ParserKeyword("WSEGVALV", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSEGVALV");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SEGMENT_NUMBER", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CV", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("AREA", ParserItem::itype::UDA);
|
|
item.push_backDimension("Length*Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("EXTRA_LENGTH", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PIPE_D", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("ROUGHNESS", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PIPE_A", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length*Length");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("STATUS", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("OPEN") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_A", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Length*Length");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSEGVALV::keywordName = "WSEGVALV";
|
|
const std::string WSEGVALV::WELL::itemName = "WELL";
|
|
const std::string WSEGVALV::SEGMENT_NUMBER::itemName = "SEGMENT_NUMBER";
|
|
const std::string WSEGVALV::CV::itemName = "CV";
|
|
const std::string WSEGVALV::AREA::itemName = "AREA";
|
|
const std::string WSEGVALV::EXTRA_LENGTH::itemName = "EXTRA_LENGTH";
|
|
const std::string WSEGVALV::PIPE_D::itemName = "PIPE_D";
|
|
const std::string WSEGVALV::ROUGHNESS::itemName = "ROUGHNESS";
|
|
const std::string WSEGVALV::PIPE_A::itemName = "PIPE_A";
|
|
const std::string WSEGVALV::STATUS::itemName = "STATUS";
|
|
const std::string WSEGVALV::STATUS::defaultValue = "OPEN";
|
|
const std::string WSEGVALV::MAX_A::itemName = "MAX_A";
|
|
|
|
|
|
WSF::WSF() : ParserKeyword("WSF", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
|
|
addValidSectionName("PROPS");
|
|
setProhibitedKeywords({
|
|
"SWOF",
|
|
"SWFN",
|
|
});
|
|
clearDeckNames();
|
|
addDeckName("WSF");
|
|
{
|
|
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 WSF::keywordName = "WSF";
|
|
const std::string WSF::DATA::itemName = "DATA";
|
|
|
|
|
|
WSKPTAB::WSKPTAB() : ParserKeyword("WSKPTAB", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSKPTAB");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TABLE_NUMBER_WATER", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TABLE_NUMBER_POLYMER", ParserItem::itype::INT);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSKPTAB::keywordName = "WSKPTAB";
|
|
const std::string WSKPTAB::WELL::itemName = "WELL";
|
|
const std::string WSKPTAB::TABLE_NUMBER_WATER::itemName = "TABLE_NUMBER_WATER";
|
|
const std::string WSKPTAB::TABLE_NUMBER_POLYMER::itemName = "TABLE_NUMBER_POLYMER";
|
|
|
|
|
|
WSOLVENT::WSOLVENT() : ParserKeyword("WSOLVENT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSOLVENT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SOLVENT_FRACTION", ParserItem::itype::UDA);
|
|
item.push_backDimension("1");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSOLVENT::keywordName = "WSOLVENT";
|
|
const std::string WSOLVENT::WELL::itemName = "WELL";
|
|
const std::string WSOLVENT::SOLVENT_FRACTION::itemName = "SOLVENT_FRACTION";
|
|
|
|
|
|
WSURFACT::WSURFACT() : ParserKeyword("WSURFACT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WSURFACT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SURFACT", ParserItem::itype::UDA);
|
|
item.push_backDimension("Mass/Length*Length*Length");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WSURFACT::keywordName = "WSURFACT";
|
|
const std::string WSURFACT::WELL::itemName = "WELL";
|
|
const std::string WSURFACT::SURFACT::itemName = "SURFACT";
|
|
|
|
|
|
WTADD::WTADD() : ParserKeyword("WTADD", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WTADD");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CONTROL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("SHIFT", ParserItem::itype::UDA);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NUM", ParserItem::itype::INT);
|
|
item.setDefault( 1 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WTADD::keywordName = "WTADD";
|
|
const std::string WTADD::WELL::itemName = "WELL";
|
|
const std::string WTADD::CONTROL::itemName = "CONTROL";
|
|
const std::string WTADD::SHIFT::itemName = "SHIFT";
|
|
const std::string WTADD::NUM::itemName = "NUM";
|
|
|
|
|
|
WTEMP::WTEMP() : ParserKeyword("WTEMP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WTEMP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TEMP", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Temperature");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WTEMP::keywordName = "WTEMP";
|
|
const std::string WTEMP::WELL::itemName = "WELL";
|
|
const std::string WTEMP::TEMP::itemName = "TEMP";
|
|
|
|
|
|
WTEMPQ::WTEMPQ() : ParserKeyword("WTEMPQ", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WTEMPQ");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LGR", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WTEMPQ::keywordName = "WTEMPQ";
|
|
const std::string WTEMPQ::WELL::itemName = "WELL";
|
|
const std::string WTEMPQ::LGR::itemName = "LGR";
|
|
|
|
|
|
WTEST::WTEST() : ParserKeyword("WTEST", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WTEST");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("INTERVAL", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Time");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("REASON", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TEST_NUM", ParserItem::itype::INT);
|
|
item.setDefault( 0 );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("START_TIME", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0) );
|
|
item.push_backDimension("Time");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WTEST::keywordName = "WTEST";
|
|
const std::string WTEST::WELL::itemName = "WELL";
|
|
const std::string WTEST::INTERVAL::itemName = "INTERVAL";
|
|
const std::string WTEST::REASON::itemName = "REASON";
|
|
const std::string WTEST::REASON::defaultValue = "";
|
|
const std::string WTEST::TEST_NUM::itemName = "TEST_NUM";
|
|
const std::string WTEST::START_TIME::itemName = "START_TIME";
|
|
|
|
|
|
WTHPMAX::WTHPMAX() : ParserKeyword("WTHPMAX", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WTHPMAX");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("MAX_THP_DESIGN_LIMIT", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CONTROL", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("ORAT") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CONTROL_LIMIT", ParserItem::itype::DOUBLE);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("THP_OPEN_LIMIT", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WTHPMAX::keywordName = "WTHPMAX";
|
|
const std::string WTHPMAX::WELL::itemName = "WELL";
|
|
const std::string WTHPMAX::MAX_THP_DESIGN_LIMIT::itemName = "MAX_THP_DESIGN_LIMIT";
|
|
const std::string WTHPMAX::CONTROL::itemName = "CONTROL";
|
|
const std::string WTHPMAX::CONTROL::defaultValue = "ORAT";
|
|
const std::string WTHPMAX::CONTROL_LIMIT::itemName = "CONTROL_LIMIT";
|
|
const std::string WTHPMAX::THP_OPEN_LIMIT::itemName = "THP_OPEN_LIMIT";
|
|
|
|
|
|
WTMULT::WTMULT() : ParserKeyword("WTMULT", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WTMULT");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CONTROL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("FACTOR", ParserItem::itype::UDA);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("NUM", ParserItem::itype::INT);
|
|
item.setDefault( 1 );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WTMULT::keywordName = "WTMULT";
|
|
const std::string WTMULT::WELL::itemName = "WELL";
|
|
const std::string WTMULT::CONTROL::itemName = "CONTROL";
|
|
const std::string WTMULT::FACTOR::itemName = "FACTOR";
|
|
const std::string WTMULT::NUM::itemName = "NUM";
|
|
|
|
|
|
WTRACER::WTRACER() : ParserKeyword("WTRACER", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WTRACER");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("TRACER", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CONCENTRATION", ParserItem::itype::UDA);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CUM_TRACER_FACTOR", ParserItem::itype::UDA);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PRODUCTION_GROUP", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WTRACER::keywordName = "WTRACER";
|
|
const std::string WTRACER::WELL::itemName = "WELL";
|
|
const std::string WTRACER::TRACER::itemName = "TRACER";
|
|
const std::string WTRACER::CONCENTRATION::itemName = "CONCENTRATION";
|
|
const std::string WTRACER::CUM_TRACER_FACTOR::itemName = "CUM_TRACER_FACTOR";
|
|
const std::string WTRACER::PRODUCTION_GROUP::itemName = "PRODUCTION_GROUP";
|
|
|
|
|
|
WVFPDP::WVFPDP() : ParserKeyword("WVFPDP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WVFPDP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DELTA_P", ParserItem::itype::DOUBLE);
|
|
item.push_backDimension("Pressure");
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("LOSS_SCALING_FACTOR", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(1.000000) );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WVFPDP::keywordName = "WVFPDP";
|
|
const std::string WVFPDP::WELL::itemName = "WELL";
|
|
const std::string WVFPDP::DELTA_P::itemName = "DELTA_P";
|
|
const std::string WVFPDP::LOSS_SCALING_FACTOR::itemName = "LOSS_SCALING_FACTOR";
|
|
|
|
|
|
WVFPEXP::WVFPEXP() : ParserKeyword("WVFPEXP", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WVFPEXP");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("EXPLICIT_IMPLICIT", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("IMP") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CLOSE", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("PREVENT_THP", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("NO") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("EXTRAPOLATION_CONTROL", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("WG") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WVFPEXP::keywordName = "WVFPEXP";
|
|
const std::string WVFPEXP::WELL::itemName = "WELL";
|
|
const std::string WVFPEXP::EXPLICIT_IMPLICIT::itemName = "EXPLICIT_IMPLICIT";
|
|
const std::string WVFPEXP::EXPLICIT_IMPLICIT::defaultValue = "IMP";
|
|
const std::string WVFPEXP::CLOSE::itemName = "CLOSE";
|
|
const std::string WVFPEXP::CLOSE::defaultValue = "NO";
|
|
const std::string WVFPEXP::PREVENT_THP::itemName = "PREVENT_THP";
|
|
const std::string WVFPEXP::PREVENT_THP::defaultValue = "NO";
|
|
const std::string WVFPEXP::EXTRAPOLATION_CONTROL::itemName = "EXTRAPOLATION_CONTROL";
|
|
const std::string WVFPEXP::EXTRAPOLATION_CONTROL::defaultValue = "WG";
|
|
|
|
|
|
WWPAVE::WWPAVE() : ParserKeyword("WWPAVE", KeywordSize(SLASH_TERMINATED)) {
|
|
addValidSectionName("SCHEDULE");
|
|
clearDeckNames();
|
|
addDeckName("WWPAVE");
|
|
{
|
|
ParserRecord record;
|
|
{
|
|
ParserItem item("WELL", ParserItem::itype::STRING);
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("F1", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.500000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("F2", ParserItem::itype::DOUBLE);
|
|
item.setDefault( double(0.500000) );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("DEPTH_CORRECTION", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("WELL") );
|
|
record.addItem(item);
|
|
}
|
|
{
|
|
ParserItem item("CONNECTION", ParserItem::itype::STRING);
|
|
item.setDefault( std::string("OPEN") );
|
|
record.addItem(item);
|
|
}
|
|
addRecord( record );
|
|
}
|
|
}
|
|
const std::string WWPAVE::keywordName = "WWPAVE";
|
|
const std::string WWPAVE::WELL::itemName = "WELL";
|
|
const std::string WWPAVE::F1::itemName = "F1";
|
|
const std::string WWPAVE::F2::itemName = "F2";
|
|
const std::string WWPAVE::DEPTH_CORRECTION::itemName = "DEPTH_CORRECTION";
|
|
const std::string WWPAVE::DEPTH_CORRECTION::defaultValue = "WELL";
|
|
const std::string WWPAVE::CONNECTION::itemName = "CONNECTION";
|
|
const std::string WWPAVE::CONNECTION::defaultValue = "OPEN";
|
|
|
|
|
|
} // namespace Opm::ParserKeywords
|