Added directory for generated content from OPM-common, filled with the parser keywords.

ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/B.cpp

@@ -0,0 +1,607 @@
+#include <opm/parser/eclipse/Deck/UDAValue.hpp>
+#include <opm/parser/eclipse/Parser/ParserItem.hpp>
+#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
+#include <opm/parser/eclipse/Parser/Parser.hpp>
+
+
+
+
+
+#include <opm/parser/eclipse/Parser/ParserKeywords/B.hpp>
+namespace Opm {
+namespace ParserKeywords {
+BC::BC( ) : ParserKeyword("BC")
+{
+  setSizeType(SLASH_TERMINATED);
+  addValidSectionName("SOLUTION");
+  clearDeckNames();
+  addDeckName("BC");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("I1", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("I2", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("J1", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("J2", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("K1", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("K2", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("TYPE", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("DIRECTION", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("COMPONENT", ParserItem::itype::STRING);
+        item.setDefault( std::string("NONE") );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("RATE", ParserItem::itype::DOUBLE);
+        item.setDefault( double(0) );
+        item.push_backDimension("Mass/Time*Length*Length");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string BC::keywordName = "BC";
+const std::string BC::I1::itemName = "I1";
+const std::string BC::I2::itemName = "I2";
+const std::string BC::J1::itemName = "J1";
+const std::string BC::J2::itemName = "J2";
+const std::string BC::K1::itemName = "K1";
+const std::string BC::K2::itemName = "K2";
+const std::string BC::TYPE::itemName = "TYPE";
+const std::string BC::DIRECTION::itemName = "DIRECTION";
+const std::string BC::COMPONENT::itemName = "COMPONENT";
+const std::string BC::COMPONENT::defaultValue = "NONE";
+const std::string BC::RATE::itemName = "RATE";
+const double BC::RATE::defaultValue = 0.000000;
+
+
+BDENSITY::BDENSITY( ) : ParserKeyword("BDENSITY")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("TABDIMS","NTPVT",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("BDENSITY");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("BRINE_DENSITY", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("Density");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string BDENSITY::keywordName = "BDENSITY";
+const std::string BDENSITY::BRINE_DENSITY::itemName = "BRINE_DENSITY";
+
+
+BGGI::BGGI( ) : ParserKeyword("BGGI")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("TABDIMS","NTPVT",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("BGGI");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("GAS_PRESSURE", ParserItem::itype::DOUBLE);
+        item.push_backDimension("Pressure");
+        record.addItem(item);
+     }
+     {
+        ParserItem item("DATA", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string BGGI::keywordName = "BGGI";
+const std::string BGGI::GAS_PRESSURE::itemName = "GAS_PRESSURE";
+const std::string BGGI::DATA::itemName = "DATA";
+
+
+BIGMODEL::BIGMODEL( ) : ParserKeyword("BIGMODEL")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("BIGMODEL");
+}
+const std::string BIGMODEL::keywordName = "BIGMODEL";
+
+
+BLACKOIL::BLACKOIL( ) : ParserKeyword("BLACKOIL")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("BLACKOIL");
+}
+const std::string BLACKOIL::keywordName = "BLACKOIL";
+
+
+BLOCK_PROBE::BLOCK_PROBE( ) : ParserKeyword("BLOCK_PROBE")
+{
+  setSizeType(SLASH_TERMINATED);
+  addValidSectionName("SUMMARY");
+  clearDeckNames();
+  addDeckName("BAPI");
+  addDeckName("BCGC");
+  addDeckName("BCSC");
+  addDeckName("BCTRA_X");
+  addDeckName("BDENG");
+  addDeckName("BDENO");
+  addDeckName("BDENW");
+  addDeckName("BESALPLY");
+  addDeckName("BESALSUR");
+  addDeckName("BEWV_SAL");
+  addDeckName("BEWV_SUR");
+  addDeckName("BFLOGI");
+  addDeckName("BFLOGJ");
+  addDeckName("BFLOGK");
+  addDeckName("BFLOOI");
+  addDeckName("BFLOOJ");
+  addDeckName("BFLOOK");
+  addDeckName("BFLOWI");
+  addDeckName("BGDEN");
+  addDeckName("BGI");
+  addDeckName("BGIP");
+  addDeckName("BGIPG");
+  addDeckName("BGIPL");
+  addDeckName("BGKR");
+  addDeckName("BGPC");
+  addDeckName("BGPR");
+  addDeckName("BGPV");
+  addDeckName("BGSAT");
+  addDeckName("BGSHY");
+  addDeckName("BGSTRP");
+  addDeckName("BGTPD");
+  addDeckName("BGTRP");
+  addDeckName("BGVIS");
+  addDeckName("BHD");
+  addDeckName("BHDF");
+  addDeckName("BHDF_X");
+  addDeckName("BHD_X");
+  addDeckName("BHPV");
+  addDeckName("BKRG");
+  addDeckName("BKRO");
+  addDeckName("BKRW");
+  addDeckName("BNIP");
+  addDeckName("BNKR");
+  addDeckName("BNSAT");
+  addDeckName("BODEN");
+  addDeckName("BOIP");
+  addDeckName("BOIPG");
+  addDeckName("BOIPL");
+  addDeckName("BOKR");
+  addDeckName("BOPV");
+  addDeckName("BOSAT");
+  addDeckName("BOVIS");
+  addDeckName("BPBUB");
+  addDeckName("BPDEW");
+  addDeckName("BPERMMOD");
+  addDeckName("BPORVMOD");
+  addDeckName("BPPC");
+  addDeckName("BPPG");
+  addDeckName("BPPO");
+  addDeckName("BPPW");
+  addDeckName("BPR");
+  addDeckName("BPR_X");
+  addDeckName("BRPV");
+  addDeckName("BRS");
+  addDeckName("BRSSAT");
+  addDeckName("BRTM");
+  addDeckName("BRV");
+  addDeckName("BRVSAT");
+  addDeckName("BSCN");
+  addDeckName("BSCN_X");
+  addDeckName("BSGAS");
+  addDeckName("BSIP");
+  addDeckName("BSOIL");
+  addDeckName("BSTATE");
+  addDeckName("BSWAT");
+  addDeckName("BTADSALK");
+  addDeckName("BTADSFOA");
+  addDeckName("BTADSUR");
+  addDeckName("BTCASUR");
+  addDeckName("BTCNFALK");
+  addDeckName("BTCNFANI");
+  addDeckName("BTCNFCAT");
+  addDeckName("BTCNFFOA");
+  addDeckName("BTCNFHEA");
+  addDeckName("BTCNFSUR");
+  addDeckName("BTCNMFOA");
+  addDeckName("BTDCYFOA");
+  addDeckName("BTHLFFOA");
+  addDeckName("BTIPTFOA");
+  addDeckName("BTIPTHEA");
+  addDeckName("BTIPTSUR");
+  addDeckName("BTMOBFOA");
+  addDeckName("BTPADALK");
+  addDeckName("BTRADCAT");
+  addDeckName("BTSADALK");
+  addDeckName("BTSADCAT");
+  addDeckName("BTSTMALK");
+  addDeckName("BTSTSUR");
+  addDeckName("BVELGI");
+  addDeckName("BVELGJ");
+  addDeckName("BVELGK");
+  addDeckName("BVELOI");
+  addDeckName("BVELOJ");
+  addDeckName("BVELOK");
+  addDeckName("BVELWI");
+  addDeckName("BVELWJ");
+  addDeckName("BVELWK");
+  addDeckName("BVGAS");
+  addDeckName("BVOIL");
+  addDeckName("BVWAT");
+  addDeckName("BWDEN");
+  addDeckName("BWIP");
+  addDeckName("BWKR");
+  addDeckName("BWPC");
+  addDeckName("BWPR");
+  addDeckName("BWPV");
+  addDeckName("BWSAT");
+  addDeckName("BWSHY");
+  addDeckName("BWSMA");
+  addDeckName("BWVIS");
+  addDeckName("LBCTRA_X");
+  addDeckName("LBHDF_X");
+  addDeckName("LBHD_X");
+  addDeckName("LBPR_X");
+  addDeckName("LBSCN_X");
+  setMatchRegex("BU.+|BTIPF.+|BTIPS.+|BTCNF.+|BTCNS.+|BTCN[1-9][0-9]*.+|BTIPT.+|BTIPF.+|BTIPS.+|BTIP[1-9][0-9]*.+|BTADS.+|BTDCY");
+  {
+     ParserRecord record;
+     {
+        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);
+     }
+     addRecord( record );
+  }
+}
+const std::string BLOCK_PROBE::keywordName = "BLOCK_PROBE";
+const std::string BLOCK_PROBE::I::itemName = "I";
+const std::string BLOCK_PROBE::J::itemName = "J";
+const std::string BLOCK_PROBE::K::itemName = "K";
+
+
+BLOCK_PROBE300::BLOCK_PROBE300( ) : ParserKeyword("BLOCK_PROBE300")
+{
+  setSizeType(SLASH_TERMINATED);
+  addValidSectionName("SUMMARY");
+  clearDeckNames();
+  addDeckName("BTEMP");
+  {
+     ParserRecord record;
+     {
+        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);
+     }
+     addRecord( record );
+  }
+}
+const std::string BLOCK_PROBE300::keywordName = "BLOCK_PROBE300";
+const std::string BLOCK_PROBE300::I::itemName = "I";
+const std::string BLOCK_PROBE300::J::itemName = "J";
+const std::string BLOCK_PROBE300::K::itemName = "K";
+
+
+BOGI::BOGI( ) : ParserKeyword("BOGI")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("TABDIMS","NTPVT",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("BOGI");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("OIL_PRESSURE", ParserItem::itype::DOUBLE);
+        item.push_backDimension("Pressure");
+        record.addItem(item);
+     }
+     {
+        ParserItem item("DATA", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string BOGI::keywordName = "BOGI";
+const std::string BOGI::OIL_PRESSURE::itemName = "OIL_PRESSURE";
+const std::string BOGI::DATA::itemName = "DATA";
+
+
+BOUNDARY::BOUNDARY( ) : ParserKeyword("BOUNDARY")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("EDIT");
+  addValidSectionName("GRID");
+  addValidSectionName("REGIONS");
+  addValidSectionName("SCHEDULE");
+  addValidSectionName("SOLUTION");
+  clearDeckNames();
+  addDeckName("BOUNDARY");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("IX1", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("IX2", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("JY1", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("JY2", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("KZ1", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("KZ2", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("ORIENTATION_INDEX", ParserItem::itype::INT);
+        item.setDefault( 1 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("DUAL_PORO_FLAG", ParserItem::itype::STRING);
+        item.setDefault( std::string("BOTH") );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string BOUNDARY::keywordName = "BOUNDARY";
+const std::string BOUNDARY::IX1::itemName = "IX1";
+const std::string BOUNDARY::IX2::itemName = "IX2";
+const std::string BOUNDARY::JY1::itemName = "JY1";
+const std::string BOUNDARY::JY2::itemName = "JY2";
+const std::string BOUNDARY::KZ1::itemName = "KZ1";
+const std::string BOUNDARY::KZ2::itemName = "KZ2";
+const std::string BOUNDARY::ORIENTATION_INDEX::itemName = "ORIENTATION_INDEX";
+const int BOUNDARY::ORIENTATION_INDEX::defaultValue = 1;
+const std::string BOUNDARY::DUAL_PORO_FLAG::itemName = "DUAL_PORO_FLAG";
+const std::string BOUNDARY::DUAL_PORO_FLAG::defaultValue = "BOTH";
+
+
+BOX::BOX( ) : ParserKeyword("BOX")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("EDIT");
+  addValidSectionName("GRID");
+  addValidSectionName("PROPS");
+  addValidSectionName("REGIONS");
+  addValidSectionName("SCHEDULE");
+  addValidSectionName("SOLUTION");
+  clearDeckNames();
+  addDeckName("BOX");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("I1", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("I2", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("J1", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("J2", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("K1", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("K2", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string BOX::keywordName = "BOX";
+const std::string BOX::I1::itemName = "I1";
+const std::string BOX::I2::itemName = "I2";
+const std::string BOX::J1::itemName = "J1";
+const std::string BOX::J2::itemName = "J2";
+const std::string BOX::K1::itemName = "K1";
+const std::string BOX::K2::itemName = "K2";
+
+
+BPARA::BPARA( ) : ParserKeyword("BPARA")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("BPARA");
+}
+const std::string BPARA::keywordName = "BPARA";
+
+
+BPIDIMS::BPIDIMS( ) : ParserKeyword("BPIDIMS")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("BPIDIMS");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("MXNBIP", ParserItem::itype::INT);
+        item.setDefault( 10 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MXNLBI", ParserItem::itype::INT);
+        item.setDefault( 1 );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string BPIDIMS::keywordName = "BPIDIMS";
+const std::string BPIDIMS::MXNBIP::itemName = "MXNBIP";
+const int BPIDIMS::MXNBIP::defaultValue = 10;
+const std::string BPIDIMS::MXNLBI::itemName = "MXNLBI";
+const int BPIDIMS::MXNLBI::defaultValue = 1;
+
+
+BRANPROP::BRANPROP( ) : ParserKeyword("BRANPROP")
+{
+  setSizeType(SLASH_TERMINATED);
+  addValidSectionName("SCHEDULE");
+  clearDeckNames();
+  addDeckName("BRANPROP");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("DOWNTREE_NODE", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("UPTREE_NODE", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("VFP_TABLE", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("ALQ", ParserItem::itype::DOUBLE);
+        item.setDefault( double(0) );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("ALQ_SURFACE_DENSITY", ParserItem::itype::STRING);
+        item.setDefault( std::string("NONE") );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string BRANPROP::keywordName = "BRANPROP";
+const std::string BRANPROP::DOWNTREE_NODE::itemName = "DOWNTREE_NODE";
+const std::string BRANPROP::UPTREE_NODE::itemName = "UPTREE_NODE";
+const std::string BRANPROP::VFP_TABLE::itemName = "VFP_TABLE";
+const std::string BRANPROP::ALQ::itemName = "ALQ";
+const double BRANPROP::ALQ::defaultValue = 0.000000;
+const std::string BRANPROP::ALQ_SURFACE_DENSITY::itemName = "ALQ_SURFACE_DENSITY";
+const std::string BRANPROP::ALQ_SURFACE_DENSITY::defaultValue = "NONE";
+
+
+BRINE::BRINE( ) : ParserKeyword("BRINE")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("BRINE");
+}
+const std::string BRINE::keywordName = "BRINE";
+
+
+BTOBALFA::BTOBALFA( ) : ParserKeyword("BTOBALFA")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("GRID");
+  clearDeckNames();
+  addDeckName("BTOBALFA");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("VALUE", ParserItem::itype::DOUBLE);
+        item.push_backDimension("1");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string BTOBALFA::keywordName = "BTOBALFA";
+const std::string BTOBALFA::VALUE::itemName = "VALUE";
+
+
+BTOBALFV::BTOBALFV( ) : ParserKeyword("BTOBALFV")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("GRID");
+  clearDeckNames();
+  addDeckName("BTOBALFV");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string BTOBALFV::keywordName = "BTOBALFV";
+const std::string BTOBALFV::data::itemName = "data";
+
+
+}
+}

ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/I.cpp

@@ -0,0 +1,665 @@
+#include <opm/parser/eclipse/Deck/UDAValue.hpp>
+#include <opm/parser/eclipse/Parser/ParserItem.hpp>
+#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
+#include <opm/parser/eclipse/Parser/Parser.hpp>
+
+
+
+
+
+#include <opm/parser/eclipse/Parser/ParserKeywords/I.hpp>
+namespace Opm {
+namespace ParserKeywords {
+IHOST::IHOST( ) : ParserKeyword("IHOST")
+{
+  setSizeType(SLASH_TERMINATED);
+  addValidSectionName("GRID");
+  clearDeckNames();
+  addDeckName("IHOST");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("LGR", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("PROCESS", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string IHOST::keywordName = "IHOST";
+const std::string IHOST::LGR::itemName = "LGR";
+const std::string IHOST::PROCESS::itemName = "PROCESS";
+const int IHOST::PROCESS::defaultValue = 0;
+
+
+IMBNUM::IMBNUM( ) : ParserKeyword("IMBNUM")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("REGIONS");
+  clearDeckNames();
+  addDeckName("IMBNUM");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::INT);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string IMBNUM::keywordName = "IMBNUM";
+const std::string IMBNUM::data::itemName = "data";
+
+
+IMBNUMMF::IMBNUMMF( ) : ParserKeyword("IMBNUMMF")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("REGIONS");
+  clearDeckNames();
+  addDeckName("IMBNUMMF");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::INT);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string IMBNUMMF::keywordName = "IMBNUMMF";
+const std::string IMBNUMMF::data::itemName = "data";
+
+
+IMKRVD::IMKRVD( ) : ParserKeyword("IMKRVD")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("ENDSCALE","NUM_TABLES",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("IMKRVD");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("DATA", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("Length");
+        item.push_backDimension("1");
+        item.push_backDimension("1");
+        item.push_backDimension("1");
+        item.push_backDimension("1");
+        item.push_backDimension("1");
+        item.push_backDimension("1");
+        item.push_backDimension("1");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string IMKRVD::keywordName = "IMKRVD";
+const std::string IMKRVD::DATA::itemName = "DATA";
+
+
+IMPCVD::IMPCVD( ) : ParserKeyword("IMPCVD")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("ENDSCALE","NTENDP",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("IMPCVD");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("DATA", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("Length");
+        item.push_backDimension("Pressure");
+        item.push_backDimension("Pressure");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string IMPCVD::keywordName = "IMPCVD";
+const std::string IMPCVD::DATA::itemName = "DATA";
+
+
+IMPES::IMPES( ) : ParserKeyword("IMPES")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("IMPES");
+}
+const std::string IMPES::keywordName = "IMPES";
+
+
+IMPLICIT::IMPLICIT( ) : ParserKeyword("IMPLICIT")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("IMPLICIT");
+}
+const std::string IMPLICIT::keywordName = "IMPLICIT";
+
+
+IMPORT::IMPORT( ) : ParserKeyword("IMPORT")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("EDIT");
+  addValidSectionName("GRID");
+  addValidSectionName("PROPS");
+  addValidSectionName("REGIONS");
+  addValidSectionName("SOLUTION");
+  clearDeckNames();
+  addDeckName("IMPORT");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("FILE", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("FORMATTED", ParserItem::itype::STRING);
+        item.setDefault( std::string("UNFORMATTED") );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string IMPORT::keywordName = "IMPORT";
+const std::string IMPORT::FILE::itemName = "FILE";
+const std::string IMPORT::FORMATTED::itemName = "FORMATTED";
+const std::string IMPORT::FORMATTED::defaultValue = "UNFORMATTED";
+
+
+IMPTVD::IMPTVD( ) : ParserKeyword("IMPTVD")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("ENDSCALE","NUM_TABLES",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("IMPTVD");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("DATA", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("Length");
+        item.push_backDimension("1");
+        item.push_backDimension("1");
+        item.push_backDimension("1");
+        item.push_backDimension("1");
+        item.push_backDimension("1");
+        item.push_backDimension("1");
+        item.push_backDimension("1");
+        item.push_backDimension("1");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string IMPTVD::keywordName = "IMPTVD";
+const std::string IMPTVD::DATA::itemName = "DATA";
+
+
+IMSPCVD::IMSPCVD( ) : ParserKeyword("IMSPCVD")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("ENDSCALE","NTENDP",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("IMSPCVD");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("DATA", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("Length");
+        item.push_backDimension("1");
+        item.push_backDimension("1");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string IMSPCVD::keywordName = "IMSPCVD";
+const std::string IMSPCVD::DATA::itemName = "DATA";
+
+
+INCLUDE::INCLUDE( ) : ParserKeyword("INCLUDE")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("EDIT");
+  addValidSectionName("GRID");
+  addValidSectionName("PROPS");
+  addValidSectionName("REGIONS");
+  addValidSectionName("RUNSPEC");
+  addValidSectionName("SCHEDULE");
+  addValidSectionName("SOLUTION");
+  addValidSectionName("SUMMARY");
+  clearDeckNames();
+  addDeckName("INCLUDE");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("IncludeFile", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string INCLUDE::keywordName = "INCLUDE";
+const std::string INCLUDE::IncludeFile::itemName = "IncludeFile";
+
+
+INIT::INIT( ) : ParserKeyword("INIT")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("GRID");
+  clearDeckNames();
+  addDeckName("INIT");
+}
+const std::string INIT::keywordName = "INIT";
+
+
+INRAD::INRAD( ) : ParserKeyword("INRAD")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("GRID");
+  clearDeckNames();
+  addDeckName("INRAD");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("RADIUS", ParserItem::itype::DOUBLE);
+        item.push_backDimension("Length");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string INRAD::keywordName = "INRAD";
+const std::string INRAD::RADIUS::itemName = "RADIUS";
+
+
+INSPEC::INSPEC( ) : ParserKeyword("INSPEC")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("INSPEC");
+}
+const std::string INSPEC::keywordName = "INSPEC";
+
+
+INTPC::INTPC( ) : ParserKeyword("INTPC")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("INTPC");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("PHASE", ParserItem::itype::STRING);
+        item.setDefault( std::string("BOTH") );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string INTPC::keywordName = "INTPC";
+const std::string INTPC::PHASE::itemName = "PHASE";
+const std::string INTPC::PHASE::defaultValue = "BOTH";
+
+
+IONROCK::IONROCK( ) : ParserKeyword("IONROCK")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("GRID");
+  clearDeckNames();
+  addDeckName("IONROCK");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string IONROCK::keywordName = "IONROCK";
+const std::string IONROCK::data::itemName = "data";
+
+
+IONXROCK::IONXROCK( ) : ParserKeyword("IONXROCK")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("TABDIMS","NTSFUN",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("IONXROCK");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("VALUE", ParserItem::itype::DOUBLE);
+        item.setDefault( double(0) );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string IONXROCK::keywordName = "IONXROCK";
+const std::string IONXROCK::VALUE::itemName = "VALUE";
+const double IONXROCK::VALUE::defaultValue = 0.000000;
+
+
+IONXSURF::IONXSURF( ) : ParserKeyword("IONXSURF")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("TABDIMS","NTSFUN",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("IONXSURF");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("MOLECULAR_WEIGHT", ParserItem::itype::DOUBLE);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("ION_EXCH_CONST", ParserItem::itype::DOUBLE);
+        item.setDefault( double(0) );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string IONXSURF::keywordName = "IONXSURF";
+const std::string IONXSURF::MOLECULAR_WEIGHT::itemName = "MOLECULAR_WEIGHT";
+const std::string IONXSURF::ION_EXCH_CONST::itemName = "ION_EXCH_CONST";
+const double IONXSURF::ION_EXCH_CONST::defaultValue = 0.000000;
+
+
+IPCG::IPCG( ) : ParserKeyword("IPCG")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("IPCG");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("Pressure");
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string IPCG::keywordName = "IPCG";
+const std::string IPCG::data::itemName = "data";
+
+
+IPCW::IPCW( ) : ParserKeyword("IPCW")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("IPCW");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("Pressure");
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string IPCW::keywordName = "IPCW";
+const std::string IPCW::data::itemName = "data";
+
+
+ISGCR::ISGCR( ) : ParserKeyword("ISGCR")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("ISGCR");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string ISGCR::keywordName = "ISGCR";
+const std::string ISGCR::data::itemName = "data";
+
+
+ISGL::ISGL( ) : ParserKeyword("ISGL")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("ISGL");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string ISGL::keywordName = "ISGL";
+const std::string ISGL::data::itemName = "data";
+
+
+ISGLPC::ISGLPC( ) : ParserKeyword("ISGLPC")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("ISGLPC");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string ISGLPC::keywordName = "ISGLPC";
+const std::string ISGLPC::data::itemName = "data";
+
+
+ISGU::ISGU( ) : ParserKeyword("ISGU")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("ISGU");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string ISGU::keywordName = "ISGU";
+const std::string ISGU::data::itemName = "data";
+
+
+ISOGCR::ISOGCR( ) : ParserKeyword("ISOGCR")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("ISOGCR");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string ISOGCR::keywordName = "ISOGCR";
+const std::string ISOGCR::data::itemName = "data";
+
+
+ISOLNUM::ISOLNUM( ) : ParserKeyword("ISOLNUM")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("GRID");
+  clearDeckNames();
+  addDeckName("ISOLNUM");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::INT);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string ISOLNUM::keywordName = "ISOLNUM";
+const std::string ISOLNUM::data::itemName = "data";
+
+
+ISOWCR::ISOWCR( ) : ParserKeyword("ISOWCR")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("ISOWCR");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string ISOWCR::keywordName = "ISOWCR";
+const std::string ISOWCR::data::itemName = "data";
+
+
+ISWCR::ISWCR( ) : ParserKeyword("ISWCR")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("ISWCR");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string ISWCR::keywordName = "ISWCR";
+const std::string ISWCR::data::itemName = "data";
+
+
+ISWL::ISWL( ) : ParserKeyword("ISWL")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("ISWL");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string ISWL::keywordName = "ISWL";
+const std::string ISWL::data::itemName = "data";
+
+
+ISWLPC::ISWLPC( ) : ParserKeyword("ISWLPC")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("ISWLPC");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string ISWLPC::keywordName = "ISWLPC";
+const std::string ISWLPC::data::itemName = "data";
+
+
+ISWU::ISWU( ) : ParserKeyword("ISWU")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("ISWU");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string ISWU::keywordName = "ISWU";
+const std::string ISWU::data::itemName = "data";
+
+
+}
+}

ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/J.cpp

@@ -0,0 +1,127 @@
+#include <opm/parser/eclipse/Deck/UDAValue.hpp>
+#include <opm/parser/eclipse/Parser/ParserItem.hpp>
+#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
+#include <opm/parser/eclipse/Parser/Parser.hpp>
+
+
+
+
+
+#include <opm/parser/eclipse/Parser/ParserKeywords/J.hpp>
+namespace Opm {
+namespace ParserKeywords {
+JFUNC::JFUNC( ) : ParserKeyword("JFUNC")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("GRID");
+  clearDeckNames();
+  addDeckName("JFUNC");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("FLAG", ParserItem::itype::STRING);
+        item.setDefault( std::string("BOTH") );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("OW_SURFACE_TENSION", ParserItem::itype::DOUBLE);
+        item.setDefault( double(-1.000000) );
+        item.push_backDimension("SurfaceTension");
+        record.addItem(item);
+     }
+     {
+        ParserItem item("GO_SURFACE_TENSION", ParserItem::itype::DOUBLE);
+        item.setDefault( double(-1.000000) );
+        item.push_backDimension("SurfaceTension");
+        record.addItem(item);
+     }
+     {
+        ParserItem item("ALPHA_FACTOR", ParserItem::itype::DOUBLE);
+        item.setDefault( double(0.500000) );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("BETA_FACTOR", ParserItem::itype::DOUBLE);
+        item.setDefault( double(0.500000) );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("DIRECTION", ParserItem::itype::STRING);
+        item.setDefault( std::string("XY") );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string JFUNC::keywordName = "JFUNC";
+const std::string JFUNC::FLAG::itemName = "FLAG";
+const std::string JFUNC::FLAG::defaultValue = "BOTH";
+const std::string JFUNC::OW_SURFACE_TENSION::itemName = "OW_SURFACE_TENSION";
+const double JFUNC::OW_SURFACE_TENSION::defaultValue = -1.000000;
+const std::string JFUNC::GO_SURFACE_TENSION::itemName = "GO_SURFACE_TENSION";
+const double JFUNC::GO_SURFACE_TENSION::defaultValue = -1.000000;
+const std::string JFUNC::ALPHA_FACTOR::itemName = "ALPHA_FACTOR";
+const double JFUNC::ALPHA_FACTOR::defaultValue = 0.500000;
+const std::string JFUNC::BETA_FACTOR::itemName = "BETA_FACTOR";
+const double JFUNC::BETA_FACTOR::defaultValue = 0.500000;
+const std::string JFUNC::DIRECTION::itemName = "DIRECTION";
+const std::string JFUNC::DIRECTION::defaultValue = "XY";
+
+
+JFUNCR::JFUNCR( ) : ParserKeyword("JFUNCR")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("TABDIMS","NTSFUN",0);
+  addValidSectionName("GRID");
+  clearDeckNames();
+  addDeckName("JFUNCR");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("J_FUNCTION", ParserItem::itype::STRING);
+        item.setDefault( std::string("BOTH") );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("OIL_WAT_SURF_TENSTION", ParserItem::itype::DOUBLE);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("OIL_GAS_SURF_TENSTION", ParserItem::itype::DOUBLE);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("POROSITY_POWER", ParserItem::itype::DOUBLE);
+        item.setDefault( double(0.500000) );
+        item.push_backDimension("1");
+        record.addItem(item);
+     }
+     {
+        ParserItem item("PERMEABILITY_POWER", ParserItem::itype::DOUBLE);
+        item.setDefault( double(0.500000) );
+        item.push_backDimension("1");
+        record.addItem(item);
+     }
+     {
+        ParserItem item("PERM_DIRECTION", ParserItem::itype::STRING);
+        item.setDefault( std::string("XY") );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string JFUNCR::keywordName = "JFUNCR";
+const std::string JFUNCR::J_FUNCTION::itemName = "J_FUNCTION";
+const std::string JFUNCR::J_FUNCTION::defaultValue = "BOTH";
+const std::string JFUNCR::OIL_WAT_SURF_TENSTION::itemName = "OIL_WAT_SURF_TENSTION";
+const std::string JFUNCR::OIL_GAS_SURF_TENSTION::itemName = "OIL_GAS_SURF_TENSTION";
+const std::string JFUNCR::POROSITY_POWER::itemName = "POROSITY_POWER";
+const double JFUNCR::POROSITY_POWER::defaultValue = 0.500000;
+const std::string JFUNCR::PERMEABILITY_POWER::itemName = "PERMEABILITY_POWER";
+const double JFUNCR::PERMEABILITY_POWER::defaultValue = 0.500000;
+const std::string JFUNCR::PERM_DIRECTION::itemName = "PERM_DIRECTION";
+const std::string JFUNCR::PERM_DIRECTION::defaultValue = "XY";
+
+
+}
+}

ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/K.cpp

@@ -0,0 +1,54 @@
+#include <opm/parser/eclipse/Deck/UDAValue.hpp>
+#include <opm/parser/eclipse/Parser/ParserItem.hpp>
+#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
+#include <opm/parser/eclipse/Parser/Parser.hpp>
+
+
+
+
+
+#include <opm/parser/eclipse/Parser/ParserKeywords/K.hpp>
+namespace Opm {
+namespace ParserKeywords {
+KRNUM::KRNUM( ) : ParserKeyword("KRNUM")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("REGIONS");
+  clearDeckNames();
+  addDeckName("KRNUM");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::INT);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string KRNUM::keywordName = "KRNUM";
+const std::string KRNUM::data::itemName = "data";
+
+
+KRNUMMF::KRNUMMF( ) : ParserKeyword("KRNUMMF")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("REGIONS");
+  clearDeckNames();
+  addDeckName("KRNUMMF");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::INT);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string KRNUMMF::keywordName = "KRNUMMF";
+const std::string KRNUMMF::data::itemName = "data";
+
+
+}
+}

ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/Q.cpp

@@ -0,0 +1,76 @@
+#include <opm/parser/eclipse/Deck/UDAValue.hpp>
+#include <opm/parser/eclipse/Parser/ParserItem.hpp>
+#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
+#include <opm/parser/eclipse/Parser/Parser.hpp>
+
+
+
+
+
+#include <opm/parser/eclipse/Parser/ParserKeywords/Q.hpp>
+namespace Opm {
+namespace ParserKeywords {
+QDRILL::QDRILL( ) : ParserKeyword("QDRILL")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("SCHEDULE");
+  clearDeckNames();
+  addDeckName("QDRILL");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("WELL_NAME", ParserItem::itype::STRING);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string QDRILL::keywordName = "QDRILL";
+const std::string QDRILL::WELL_NAME::itemName = "WELL_NAME";
+
+
+QHRATING::QHRATING( ) : ParserKeyword("QHRATING")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("RIVRDIMS","NRATTA",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("QHRATING");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("DATA", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("Length*Length*Length/Time");
+        item.push_backDimension("Length");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string QHRATING::keywordName = "QHRATING";
+const std::string QHRATING::DATA::itemName = "DATA";
+
+
+QMOBIL::QMOBIL( ) : ParserKeyword("QMOBIL")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("GRID");
+  clearDeckNames();
+  addDeckName("QMOBIL");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("MOBILE_END_POINT_CORRECTION", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string QMOBIL::keywordName = "QMOBIL";
+const std::string QMOBIL::MOBILE_END_POINT_CORRECTION::itemName = "MOBILE_END_POINT_CORRECTION";
+
+
+}
+}

ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/U.cpp

@@ -0,0 +1,358 @@
+#include <opm/parser/eclipse/Deck/UDAValue.hpp>
+#include <opm/parser/eclipse/Parser/ParserItem.hpp>
+#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
+#include <opm/parser/eclipse/Parser/Parser.hpp>
+
+
+
+
+
+#include <opm/parser/eclipse/Parser/ParserKeywords/U.hpp>
+namespace Opm {
+namespace ParserKeywords {
+UDADIMS::UDADIMS( ) : ParserKeyword("UDADIMS")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("UDADIMS");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("NUM_UDQ_REPLACE", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("IGNORED", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("TOTAL_UDQ_UNIQUE", ParserItem::itype::INT);
+        item.setDefault( 100 );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string UDADIMS::keywordName = "UDADIMS";
+const std::string UDADIMS::NUM_UDQ_REPLACE::itemName = "NUM_UDQ_REPLACE";
+const int UDADIMS::NUM_UDQ_REPLACE::defaultValue = 0;
+const std::string UDADIMS::IGNORED::itemName = "IGNORED";
+const int UDADIMS::IGNORED::defaultValue = 0;
+const std::string UDADIMS::TOTAL_UDQ_UNIQUE::itemName = "TOTAL_UDQ_UNIQUE";
+const int UDADIMS::TOTAL_UDQ_UNIQUE::defaultValue = 100;
+
+
+UDQ::UDQ( ) : ParserKeyword("UDQ")
+{
+  setSizeType(SLASH_TERMINATED);
+  addValidSectionName("SCHEDULE");
+  clearDeckNames();
+  addDeckName("UDQ");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("ACTION", ParserItem::itype::RAW_STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("QUANTITY", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("DATA", ParserItem::itype::RAW_STRING);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string UDQ::keywordName = "UDQ";
+const std::string UDQ::ACTION::itemName = "ACTION";
+const std::string UDQ::QUANTITY::itemName = "QUANTITY";
+const std::string UDQ::DATA::itemName = "DATA";
+
+
+UDQDIMS::UDQDIMS( ) : ParserKeyword("UDQDIMS")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("UDQDIMS");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("MAX_FUNCTIONS", ParserItem::itype::INT);
+        item.setDefault( 16 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_ITEMS", ParserItem::itype::INT);
+        item.setDefault( 16 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_CONNECTIONS", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_FIELDS", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_GROUP", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_REGION", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_SEGMENT", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_WELL", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_AQUIFER", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_BLOCK", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("RESTART_NEW_SEED", ParserItem::itype::STRING);
+        item.setDefault( std::string("N") );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string UDQDIMS::keywordName = "UDQDIMS";
+const std::string UDQDIMS::MAX_FUNCTIONS::itemName = "MAX_FUNCTIONS";
+const int UDQDIMS::MAX_FUNCTIONS::defaultValue = 16;
+const std::string UDQDIMS::MAX_ITEMS::itemName = "MAX_ITEMS";
+const int UDQDIMS::MAX_ITEMS::defaultValue = 16;
+const std::string UDQDIMS::MAX_CONNECTIONS::itemName = "MAX_CONNECTIONS";
+const int UDQDIMS::MAX_CONNECTIONS::defaultValue = 0;
+const std::string UDQDIMS::MAX_FIELDS::itemName = "MAX_FIELDS";
+const int UDQDIMS::MAX_FIELDS::defaultValue = 0;
+const std::string UDQDIMS::MAX_GROUP::itemName = "MAX_GROUP";
+const int UDQDIMS::MAX_GROUP::defaultValue = 0;
+const std::string UDQDIMS::MAX_REGION::itemName = "MAX_REGION";
+const int UDQDIMS::MAX_REGION::defaultValue = 0;
+const std::string UDQDIMS::MAX_SEGMENT::itemName = "MAX_SEGMENT";
+const int UDQDIMS::MAX_SEGMENT::defaultValue = 0;
+const std::string UDQDIMS::MAX_WELL::itemName = "MAX_WELL";
+const int UDQDIMS::MAX_WELL::defaultValue = 0;
+const std::string UDQDIMS::MAX_AQUIFER::itemName = "MAX_AQUIFER";
+const int UDQDIMS::MAX_AQUIFER::defaultValue = 0;
+const std::string UDQDIMS::MAX_BLOCK::itemName = "MAX_BLOCK";
+const int UDQDIMS::MAX_BLOCK::defaultValue = 0;
+const std::string UDQDIMS::RESTART_NEW_SEED::itemName = "RESTART_NEW_SEED";
+const std::string UDQDIMS::RESTART_NEW_SEED::defaultValue = "N";
+
+
+UDQPARAM::UDQPARAM( ) : ParserKeyword("UDQPARAM")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("UDQPARAM");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("RANDOM_SEED", ParserItem::itype::INT);
+        item.setDefault( 1 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("RANGE", ParserItem::itype::DOUBLE);
+        item.setDefault( double(100000000000000000000.000000) );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("UNDEFINED_VALUE", ParserItem::itype::DOUBLE);
+        item.setDefault( double(0) );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("CMP_EPSILON", ParserItem::itype::DOUBLE);
+        item.setDefault( double(0.000100) );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string UDQPARAM::keywordName = "UDQPARAM";
+const std::string UDQPARAM::RANDOM_SEED::itemName = "RANDOM_SEED";
+const int UDQPARAM::RANDOM_SEED::defaultValue = 1;
+const std::string UDQPARAM::RANGE::itemName = "RANGE";
+const double UDQPARAM::RANGE::defaultValue = 100000000000000000000.000000;
+const std::string UDQPARAM::UNDEFINED_VALUE::itemName = "UNDEFINED_VALUE";
+const double UDQPARAM::UNDEFINED_VALUE::defaultValue = 0.000000;
+const std::string UDQPARAM::CMP_EPSILON::itemName = "CMP_EPSILON";
+const double UDQPARAM::CMP_EPSILON::defaultValue = 0.000100;
+
+
+UDT::UDT( ) : ParserKeyword("UDT")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("SCHEDULE");
+  clearDeckNames();
+  addDeckName("UDT");
+}
+const std::string UDT::keywordName = "UDT";
+
+
+UDTDIMS::UDTDIMS( ) : ParserKeyword("UDTDIMS")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("UDTDIMS");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("MAX_TABLES", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_ROWS", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_INTERPOLATION_POINTS", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_DIMENSIONS", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string UDTDIMS::keywordName = "UDTDIMS";
+const std::string UDTDIMS::MAX_TABLES::itemName = "MAX_TABLES";
+const int UDTDIMS::MAX_TABLES::defaultValue = 0;
+const std::string UDTDIMS::MAX_ROWS::itemName = "MAX_ROWS";
+const int UDTDIMS::MAX_ROWS::defaultValue = 0;
+const std::string UDTDIMS::MAX_INTERPOLATION_POINTS::itemName = "MAX_INTERPOLATION_POINTS";
+const int UDTDIMS::MAX_INTERPOLATION_POINTS::defaultValue = 0;
+const std::string UDTDIMS::MAX_DIMENSIONS::itemName = "MAX_DIMENSIONS";
+const int UDTDIMS::MAX_DIMENSIONS::defaultValue = 0;
+
+
+UNCODHMD::UNCODHMD( ) : ParserKeyword("UNCODHMD")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("UNCODHMD");
+}
+const std::string UNCODHMD::keywordName = "UNCODHMD";
+
+
+UNIFIN::UNIFIN( ) : ParserKeyword("UNIFIN")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("UNIFIN");
+}
+const std::string UNIFIN::keywordName = "UNIFIN";
+
+
+UNIFOUT::UNIFOUT( ) : ParserKeyword("UNIFOUT")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("UNIFOUT");
+}
+const std::string UNIFOUT::keywordName = "UNIFOUT";
+
+
+UNIFOUTS::UNIFOUTS( ) : ParserKeyword("UNIFOUTS")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("UNIFOUTS");
+}
+const std::string UNIFOUTS::keywordName = "UNIFOUTS";
+
+
+UNIFSAVE::UNIFSAVE( ) : ParserKeyword("UNIFSAVE")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("UNIFSAVE");
+}
+const std::string UNIFSAVE::keywordName = "UNIFSAVE";
+
+
+USECUPL::USECUPL( ) : ParserKeyword("USECUPL")
+{
+  setSizeType(SLASH_TERMINATED);
+  addValidSectionName("SCHEDULE");
+  clearDeckNames();
+  addDeckName("USECUPL");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("BASE", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("FMT", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string USECUPL::keywordName = "USECUPL";
+const std::string USECUPL::BASE::itemName = "BASE";
+const std::string USECUPL::FMT::itemName = "FMT";
+
+
+USEFLUX::USEFLUX( ) : ParserKeyword("USEFLUX")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("GRID");
+  clearDeckNames();
+  addDeckName("USEFLUX");
+}
+const std::string USEFLUX::keywordName = "USEFLUX";
+
+
+USENOFLO::USENOFLO( ) : ParserKeyword("USENOFLO")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("GRID");
+  clearDeckNames();
+  addDeckName("USENOFLO");
+}
+const std::string USENOFLO::keywordName = "USENOFLO";
+
+
+}
+}

ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/V.cpp

@@ -0,0 +1,798 @@
+#include <opm/parser/eclipse/Deck/UDAValue.hpp>
+#include <opm/parser/eclipse/Parser/ParserItem.hpp>
+#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
+#include <opm/parser/eclipse/Parser/Parser.hpp>
+
+
+
+
+
+#include <opm/parser/eclipse/Parser/ParserKeywords/V.hpp>
+namespace Opm {
+namespace ParserKeywords {
+VAPOIL::VAPOIL( ) : ParserKeyword("VAPOIL")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("VAPOIL");
+}
+const std::string VAPOIL::keywordName = "VAPOIL";
+
+
+VAPPARS::VAPPARS( ) : ParserKeyword("VAPPARS")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("SCHEDULE");
+  addValidSectionName("SOLUTION");
+  clearDeckNames();
+  addDeckName("VAPPARS");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("OIL_VAP_PROPENSITY", ParserItem::itype::DOUBLE);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("OIL_DENSITY_PROPENSITY", ParserItem::itype::DOUBLE);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VAPPARS::keywordName = "VAPPARS";
+const std::string VAPPARS::OIL_VAP_PROPENSITY::itemName = "OIL_VAP_PROPENSITY";
+const std::string VAPPARS::OIL_DENSITY_PROPENSITY::itemName = "OIL_DENSITY_PROPENSITY";
+
+
+VAPWAT::VAPWAT( ) : ParserKeyword("VAPWAT")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("VAPWAT");
+}
+const std::string VAPWAT::keywordName = "VAPWAT";
+
+
+VDFLOW::VDFLOW( ) : ParserKeyword("VDFLOW")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("VDFLOW");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("BETA", ParserItem::itype::DOUBLE);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VDFLOW::keywordName = "VDFLOW";
+const std::string VDFLOW::BETA::itemName = "BETA";
+
+
+VDFLOWR::VDFLOWR( ) : ParserKeyword("VDFLOWR")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("TABDIMS","NTSFUN",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("VDFLOWR");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("BETA", ParserItem::itype::DOUBLE);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VDFLOWR::keywordName = "VDFLOWR";
+const std::string VDFLOWR::BETA::itemName = "BETA";
+
+
+VE::VE( ) : ParserKeyword("VE")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("VE");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("MODEL_TYPE", ParserItem::itype::STRING);
+        item.setDefault( std::string("NOCOMP") );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VE::keywordName = "VE";
+const std::string VE::MODEL_TYPE::itemName = "MODEL_TYPE";
+const std::string VE::MODEL_TYPE::defaultValue = "NOCOMP";
+
+
+VEDEBUG::VEDEBUG( ) : ParserKeyword("VEDEBUG")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("GRID");
+  clearDeckNames();
+  addDeckName("VEDEBUG");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("I1", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("I2", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("J1", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("J2", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("K1", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("K2", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("DEBUG_LEVEL", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("LGR", ParserItem::itype::STRING);
+        item.setDefault( std::string(" ") );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VEDEBUG::keywordName = "VEDEBUG";
+const std::string VEDEBUG::I1::itemName = "I1";
+const std::string VEDEBUG::I2::itemName = "I2";
+const std::string VEDEBUG::J1::itemName = "J1";
+const std::string VEDEBUG::J2::itemName = "J2";
+const std::string VEDEBUG::K1::itemName = "K1";
+const std::string VEDEBUG::K2::itemName = "K2";
+const std::string VEDEBUG::DEBUG_LEVEL::itemName = "DEBUG_LEVEL";
+const int VEDEBUG::DEBUG_LEVEL::defaultValue = 0;
+const std::string VEDEBUG::LGR::itemName = "LGR";
+const std::string VEDEBUG::LGR::defaultValue = " ";
+
+
+VEFIN::VEFIN( ) : ParserKeyword("VEFIN")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("GRID");
+  clearDeckNames();
+  addDeckName("VEFIN");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("VE", ParserItem::itype::STRING);
+        item.setDefault( std::string("NO") );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("NVEPT", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VEFIN::keywordName = "VEFIN";
+const std::string VEFIN::VE::itemName = "VE";
+const std::string VEFIN::VE::defaultValue = "NO";
+const std::string VEFIN::NVEPT::itemName = "NVEPT";
+const int VEFIN::NVEPT::defaultValue = 0;
+
+
+VEFRAC::VEFRAC( ) : ParserKeyword("VEFRAC")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("VEFRAC");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("FRAC", ParserItem::itype::DOUBLE);
+        item.setDefault( double(10.000000) );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VEFRAC::keywordName = "VEFRAC";
+const std::string VEFRAC::FRAC::itemName = "FRAC";
+const double VEFRAC::FRAC::defaultValue = 10.000000;
+
+
+VEFRACP::VEFRACP( ) : ParserKeyword("VEFRACP")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("VEFRACP");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("FRAC", ParserItem::itype::DOUBLE);
+        item.setDefault( double(1.000000) );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VEFRACP::keywordName = "VEFRACP";
+const std::string VEFRACP::FRAC::itemName = "FRAC";
+const double VEFRACP::FRAC::defaultValue = 1.000000;
+
+
+VEFRACPV::VEFRACPV( ) : ParserKeyword("VEFRACPV")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("VEFRACPV");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string VEFRACPV::keywordName = "VEFRACPV";
+const std::string VEFRACPV::data::itemName = "data";
+
+
+VEFRACV::VEFRACV( ) : ParserKeyword("VEFRACV")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("VEFRACV");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string VEFRACV::keywordName = "VEFRACV";
+const std::string VEFRACV::data::itemName = "data";
+
+
+VFPCHK::VFPCHK( ) : ParserKeyword("VFPCHK")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("SCHEDULE");
+  clearDeckNames();
+  addDeckName("VFPCHK");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("BHP_LIMIT", ParserItem::itype::DOUBLE);
+        item.setDefault( double(10000000000.000000) );
+        item.push_backDimension("Pressure");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VFPCHK::keywordName = "VFPCHK";
+const std::string VFPCHK::BHP_LIMIT::itemName = "BHP_LIMIT";
+const double VFPCHK::BHP_LIMIT::defaultValue = 10000000000.000000;
+
+
+VFPIDIMS::VFPIDIMS( ) : ParserKeyword("VFPIDIMS")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("VFPIDIMS");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("MAX_FLOW_TABLE", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_THP_TABLE", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_INJ_VFP_TABLE", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VFPIDIMS::keywordName = "VFPIDIMS";
+const std::string VFPIDIMS::MAX_FLOW_TABLE::itemName = "MAX_FLOW_TABLE";
+const int VFPIDIMS::MAX_FLOW_TABLE::defaultValue = 0;
+const std::string VFPIDIMS::MAX_THP_TABLE::itemName = "MAX_THP_TABLE";
+const int VFPIDIMS::MAX_THP_TABLE::defaultValue = 0;
+const std::string VFPIDIMS::MAX_INJ_VFP_TABLE::itemName = "MAX_INJ_VFP_TABLE";
+const int VFPIDIMS::MAX_INJ_VFP_TABLE::defaultValue = 0;
+
+
+VFPINJ::VFPINJ( ) : ParserKeyword("VFPINJ")
+{
+  setSizeType(UNKNOWN);
+  addValidSectionName("SCHEDULE");
+  clearDeckNames();
+  addDeckName("VFPINJ");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("TABLE", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("DATUM_DEPTH", ParserItem::itype::DOUBLE);
+        item.push_backDimension("Length");
+        record.addItem(item);
+     }
+     {
+        ParserItem item("RATE_TYPE", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("PRESSURE_DEF", ParserItem::itype::STRING);
+        item.setDefault( std::string("THP") );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("UNITS", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("BODY_DEF", ParserItem::itype::STRING);
+        item.setDefault( std::string("BHP") );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+  {
+     ParserRecord record;
+     {
+        ParserItem item("FLOW_VALUES", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+  {
+     ParserRecord record;
+     {
+        ParserItem item("THP_VALUES", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+  {
+     ParserRecord record;
+     {
+        ParserItem item("THP_INDEX", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("VALUES", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VFPINJ::keywordName = "VFPINJ";
+const std::string VFPINJ::TABLE::itemName = "TABLE";
+const std::string VFPINJ::DATUM_DEPTH::itemName = "DATUM_DEPTH";
+const std::string VFPINJ::RATE_TYPE::itemName = "RATE_TYPE";
+const std::string VFPINJ::PRESSURE_DEF::itemName = "PRESSURE_DEF";
+const std::string VFPINJ::PRESSURE_DEF::defaultValue = "THP";
+const std::string VFPINJ::UNITS::itemName = "UNITS";
+const std::string VFPINJ::BODY_DEF::itemName = "BODY_DEF";
+const std::string VFPINJ::BODY_DEF::defaultValue = "BHP";
+const std::string VFPINJ::FLOW_VALUES::itemName = "FLOW_VALUES";
+const std::string VFPINJ::THP_VALUES::itemName = "THP_VALUES";
+const std::string VFPINJ::THP_INDEX::itemName = "THP_INDEX";
+const std::string VFPINJ::VALUES::itemName = "VALUES";
+
+
+VFPPDIMS::VFPPDIMS( ) : ParserKeyword("VFPPDIMS")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("VFPPDIMS");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("MAX_FLOW_TABLE", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_THP_TABLE", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_WCT_TABLE", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_GCT_TABLE", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_ALQ_TABLE", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MAX_PROD_VFP_TABLE", ParserItem::itype::INT);
+        item.setDefault( 0 );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VFPPDIMS::keywordName = "VFPPDIMS";
+const std::string VFPPDIMS::MAX_FLOW_TABLE::itemName = "MAX_FLOW_TABLE";
+const int VFPPDIMS::MAX_FLOW_TABLE::defaultValue = 0;
+const std::string VFPPDIMS::MAX_THP_TABLE::itemName = "MAX_THP_TABLE";
+const int VFPPDIMS::MAX_THP_TABLE::defaultValue = 0;
+const std::string VFPPDIMS::MAX_WCT_TABLE::itemName = "MAX_WCT_TABLE";
+const int VFPPDIMS::MAX_WCT_TABLE::defaultValue = 0;
+const std::string VFPPDIMS::MAX_GCT_TABLE::itemName = "MAX_GCT_TABLE";
+const int VFPPDIMS::MAX_GCT_TABLE::defaultValue = 0;
+const std::string VFPPDIMS::MAX_ALQ_TABLE::itemName = "MAX_ALQ_TABLE";
+const int VFPPDIMS::MAX_ALQ_TABLE::defaultValue = 0;
+const std::string VFPPDIMS::MAX_PROD_VFP_TABLE::itemName = "MAX_PROD_VFP_TABLE";
+const int VFPPDIMS::MAX_PROD_VFP_TABLE::defaultValue = 0;
+
+
+VFPPROD::VFPPROD( ) : ParserKeyword("VFPPROD")
+{
+  setSizeType(UNKNOWN);
+  addValidSectionName("SCHEDULE");
+  clearDeckNames();
+  addDeckName("VFPPROD");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("TABLE", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("DATUM_DEPTH", ParserItem::itype::DOUBLE);
+        item.push_backDimension("Length");
+        record.addItem(item);
+     }
+     {
+        ParserItem item("RATE_TYPE", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("WFR", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("GFR", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("PRESSURE_DEF", ParserItem::itype::STRING);
+        item.setDefault( std::string("THP") );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("ALQ_DEF", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("UNITS", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("BODY_DEF", ParserItem::itype::STRING);
+        item.setDefault( std::string("BHP") );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+  {
+     ParserRecord record;
+     {
+        ParserItem item("FLOW_VALUES", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+  {
+     ParserRecord record;
+     {
+        ParserItem item("THP_VALUES", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+  {
+     ParserRecord record;
+     {
+        ParserItem item("WFR_VALUES", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+  {
+     ParserRecord record;
+     {
+        ParserItem item("GFR_VALUES", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+  {
+     ParserRecord record;
+     {
+        ParserItem item("ALQ_VALUES", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+  {
+     ParserRecord record;
+     {
+        ParserItem item("THP_INDEX", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("WFR_INDEX", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("GFR_INDEX", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("ALQ_INDEX", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("VALUES", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VFPPROD::keywordName = "VFPPROD";
+const std::string VFPPROD::TABLE::itemName = "TABLE";
+const std::string VFPPROD::DATUM_DEPTH::itemName = "DATUM_DEPTH";
+const std::string VFPPROD::RATE_TYPE::itemName = "RATE_TYPE";
+const std::string VFPPROD::WFR::itemName = "WFR";
+const std::string VFPPROD::GFR::itemName = "GFR";
+const std::string VFPPROD::PRESSURE_DEF::itemName = "PRESSURE_DEF";
+const std::string VFPPROD::PRESSURE_DEF::defaultValue = "THP";
+const std::string VFPPROD::ALQ_DEF::itemName = "ALQ_DEF";
+const std::string VFPPROD::UNITS::itemName = "UNITS";
+const std::string VFPPROD::BODY_DEF::itemName = "BODY_DEF";
+const std::string VFPPROD::BODY_DEF::defaultValue = "BHP";
+const std::string VFPPROD::FLOW_VALUES::itemName = "FLOW_VALUES";
+const std::string VFPPROD::THP_VALUES::itemName = "THP_VALUES";
+const std::string VFPPROD::WFR_VALUES::itemName = "WFR_VALUES";
+const std::string VFPPROD::GFR_VALUES::itemName = "GFR_VALUES";
+const std::string VFPPROD::ALQ_VALUES::itemName = "ALQ_VALUES";
+const std::string VFPPROD::THP_INDEX::itemName = "THP_INDEX";
+const std::string VFPPROD::WFR_INDEX::itemName = "WFR_INDEX";
+const std::string VFPPROD::GFR_INDEX::itemName = "GFR_INDEX";
+const std::string VFPPROD::ALQ_INDEX::itemName = "ALQ_INDEX";
+const std::string VFPPROD::VALUES::itemName = "VALUES";
+
+
+VFPTABL::VFPTABL( ) : ParserKeyword("VFPTABL")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("SCHEDULE");
+  clearDeckNames();
+  addDeckName("VFPTABL");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("METHOD", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VFPTABL::keywordName = "VFPTABL";
+const std::string VFPTABL::METHOD::itemName = "METHOD";
+
+
+VISAGE::VISAGE( ) : ParserKeyword("VISAGE")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("VISAGE");
+}
+const std::string VISAGE::keywordName = "VISAGE";
+
+
+VISCD::VISCD( ) : ParserKeyword("VISCD")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("RUNSPEC");
+  clearDeckNames();
+  addDeckName("VISCD");
+}
+const std::string VISCD::keywordName = "VISCD";
+
+
+VISCREF::VISCREF( ) : ParserKeyword("VISCREF")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("TABDIMS","NTPVT",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("VISCREF");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("REFERENCE_PRESSURE", ParserItem::itype::DOUBLE);
+        item.push_backDimension("Pressure");
+        record.addItem(item);
+     }
+     {
+        ParserItem item("REFERENCE_RS", ParserItem::itype::DOUBLE);
+        item.push_backDimension("GasDissolutionFactor");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VISCREF::keywordName = "VISCREF";
+const std::string VISCREF::REFERENCE_PRESSURE::itemName = "REFERENCE_PRESSURE";
+const std::string VISCREF::REFERENCE_RS::itemName = "REFERENCE_RS";
+
+
+VISDATES::VISDATES( ) : ParserKeyword("VISDATES")
+{
+  setSizeType(SLASH_TERMINATED);
+  addValidSectionName("SCHEDULE");
+  clearDeckNames();
+  addDeckName("VISDATES");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("DAY", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("MONTH", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("YEAR", ParserItem::itype::INT);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("TIMESTAMP", ParserItem::itype::STRING);
+        item.setDefault( std::string("00:00:00") );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VISDATES::keywordName = "VISDATES";
+const std::string VISDATES::DAY::itemName = "DAY";
+const std::string VISDATES::MONTH::itemName = "MONTH";
+const std::string VISDATES::YEAR::itemName = "YEAR";
+const std::string VISDATES::TIMESTAMP::itemName = "TIMESTAMP";
+const std::string VISDATES::TIMESTAMP::defaultValue = "00:00:00";
+
+
+VISOPTS::VISOPTS( ) : ParserKeyword("VISOPTS")
+{
+  setSizeType(SLASH_TERMINATED);
+  addValidSectionName("SOLUTION");
+  clearDeckNames();
+  addDeckName("VISOPTS");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("INIT_RUN", ParserItem::itype::STRING);
+        item.setDefault( std::string("NO") );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("EXIT", ParserItem::itype::STRING);
+        item.setDefault( std::string("NO") );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("ACTIVE", ParserItem::itype::STRING);
+        item.setDefault( std::string("NO") );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("REL_TOL", ParserItem::itype::DOUBLE);
+        item.setDefault( double(0.050000) );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("UNUSED", ParserItem::itype::STRING);
+        record.addItem(item);
+     }
+     {
+        ParserItem item("RETAIN_RESTART_FREQUENCY", ParserItem::itype::STRING);
+        item.setDefault( std::string("NO") );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("RETAIN_RESTART_CONTENT", ParserItem::itype::STRING);
+        item.setDefault( std::string("NO") );
+        record.addItem(item);
+     }
+     {
+        ParserItem item("ERROR", ParserItem::itype::STRING);
+        item.setDefault( std::string("ERROR") );
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string VISOPTS::keywordName = "VISOPTS";
+const std::string VISOPTS::INIT_RUN::itemName = "INIT_RUN";
+const std::string VISOPTS::INIT_RUN::defaultValue = "NO";
+const std::string VISOPTS::EXIT::itemName = "EXIT";
+const std::string VISOPTS::EXIT::defaultValue = "NO";
+const std::string VISOPTS::ACTIVE::itemName = "ACTIVE";
+const std::string VISOPTS::ACTIVE::defaultValue = "NO";
+const std::string VISOPTS::REL_TOL::itemName = "REL_TOL";
+const double VISOPTS::REL_TOL::defaultValue = 0.050000;
+const std::string VISOPTS::UNUSED::itemName = "UNUSED";
+const std::string VISOPTS::RETAIN_RESTART_FREQUENCY::itemName = "RETAIN_RESTART_FREQUENCY";
+const std::string VISOPTS::RETAIN_RESTART_FREQUENCY::defaultValue = "NO";
+const std::string VISOPTS::RETAIN_RESTART_CONTENT::itemName = "RETAIN_RESTART_CONTENT";
+const std::string VISOPTS::RETAIN_RESTART_CONTENT::defaultValue = "NO";
+const std::string VISOPTS::ERROR::itemName = "ERROR";
+const std::string VISOPTS::ERROR::defaultValue = "ERROR";
+
+
+}
+}

ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/X.cpp

@@ -0,0 +1,14 @@
+#include <opm/parser/eclipse/Deck/UDAValue.hpp>
+#include <opm/parser/eclipse/Parser/ParserItem.hpp>
+#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
+#include <opm/parser/eclipse/Parser/Parser.hpp>
+
+
+
+
+
+#include <opm/parser/eclipse/Parser/ParserKeywords/X.hpp>
+namespace Opm {
+namespace ParserKeywords {
+}
+}

ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/Y.cpp

@@ -0,0 +1,14 @@
+#include <opm/parser/eclipse/Deck/UDAValue.hpp>
+#include <opm/parser/eclipse/Parser/ParserItem.hpp>
+#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
+#include <opm/parser/eclipse/Parser/Parser.hpp>
+
+
+
+
+
+#include <opm/parser/eclipse/Parser/ParserKeywords/Y.hpp>
+namespace Opm {
+namespace ParserKeywords {
+}
+}

ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/Z.cpp

@@ -0,0 +1,153 @@
+#include <opm/parser/eclipse/Deck/UDAValue.hpp>
+#include <opm/parser/eclipse/Parser/ParserItem.hpp>
+#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
+#include <opm/parser/eclipse/Parser/Parser.hpp>
+
+
+
+
+
+#include <opm/parser/eclipse/Parser/ParserKeywords/Z.hpp>
+namespace Opm {
+namespace ParserKeywords {
+ZCORN::ZCORN( ) : ParserKeyword("ZCORN")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("GRID");
+  clearDeckNames();
+  addDeckName("ZCORN");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("data", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("Length");
+        record.addDataItem(item);
+     }
+     addDataRecord( record );
+  }
+}
+const std::string ZCORN::keywordName = "ZCORN";
+const std::string ZCORN::data::itemName = "data";
+
+
+ZFACT1::ZFACT1( ) : ParserKeyword("ZFACT1")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("TABDIMS","NUM_STATE_EQ",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("ZFACT1");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("Z0", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string ZFACT1::keywordName = "ZFACT1";
+const std::string ZFACT1::Z0::itemName = "Z0";
+
+
+ZFACT1S::ZFACT1S( ) : ParserKeyword("ZFACT1S")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("TABDIMS","NUM_STATE_EQ",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("ZFACT1S");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("Z0", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string ZFACT1S::keywordName = "ZFACT1S";
+const std::string ZFACT1S::Z0::itemName = "Z0";
+
+
+ZFACTOR::ZFACTOR( ) : ParserKeyword("ZFACTOR")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("TABDIMS","NUM_STATE_EQ",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("ZFACTOR");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("Z0", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string ZFACTOR::keywordName = "ZFACTOR";
+const std::string ZFACTOR::Z0::itemName = "Z0";
+
+
+ZFACTORS::ZFACTORS( ) : ParserKeyword("ZFACTORS")
+{
+  setSizeType(OTHER_KEYWORD_IN_DECK);
+  initSizeKeyword("TABDIMS","NUM_STATE_EQ",0);
+  addValidSectionName("PROPS");
+  clearDeckNames();
+  addDeckName("ZFACTORS");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("Z0", ParserItem::itype::DOUBLE);
+        item.setSizeType(ParserItem::item_size::ALL);
+        item.push_backDimension("1");
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string ZFACTORS::keywordName = "ZFACTORS";
+const std::string ZFACTORS::Z0::itemName = "Z0";
+
+
+ZIPP2OFF::ZIPP2OFF( ) : ParserKeyword("ZIPP2OFF")
+{
+  setFixedSize( (size_t) 0);
+  addValidSectionName("SCHEDULE");
+  clearDeckNames();
+  addDeckName("ZIPP2OFF");
+}
+const std::string ZIPP2OFF::keywordName = "ZIPP2OFF";
+
+
+ZIPPY2::ZIPPY2( ) : ParserKeyword("ZIPPY2")
+{
+  setFixedSize( (size_t) 1);
+  addValidSectionName("SCHEDULE");
+  clearDeckNames();
+  addDeckName("ZIPPY2");
+  {
+     ParserRecord record;
+     {
+        ParserItem item("SETTINGS", ParserItem::itype::STRING);
+        item.setSizeType(ParserItem::item_size::ALL);
+        record.addItem(item);
+     }
+     addRecord( record );
+  }
+}
+const std::string ZIPPY2::keywordName = "ZIPPY2";
+const std::string ZIPPY2::SETTINGS::itemName = "SETTINGS";
+
+
+}
+}

ThirdParty/custom-opm-common/generated-opm-common/config.h

@@ -0,0 +1,2 @@
+#define HAVE_OPENMP 1
+#define HAVE_DYNAMIC_BOOST_TEST 0

ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/B.hpp

@@ -0,0 +1,365 @@
+#ifndef PARSER_KEYWORDS_B_HPP
+#define PARSER_KEYWORDS_B_HPP
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
+namespace Opm {
+namespace ParserKeywords {
+
+   class BC : public ParserKeyword {
+   public:
+       BC();
+       static const std::string keywordName;
+
+       class I1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class I2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class J1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class J2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class K1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class K2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class TYPE {
+       public:
+           static const std::string itemName;
+       };
+
+       class DIRECTION {
+       public:
+           static const std::string itemName;
+       };
+
+       class COMPONENT {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class RATE {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class BDENSITY : public ParserKeyword {
+   public:
+       BDENSITY();
+       static const std::string keywordName;
+
+       class BRINE_DENSITY {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class BGGI : public ParserKeyword {
+   public:
+       BGGI();
+       static const std::string keywordName;
+
+       class GAS_PRESSURE {
+       public:
+           static const std::string itemName;
+       };
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class BIGMODEL : public ParserKeyword {
+   public:
+       BIGMODEL();
+       static const std::string keywordName;
+   };
+
+
+
+   class BLACKOIL : public ParserKeyword {
+   public:
+       BLACKOIL();
+       static const std::string keywordName;
+   };
+
+
+
+   class BLOCK_PROBE : public ParserKeyword {
+   public:
+       BLOCK_PROBE();
+       static const std::string keywordName;
+
+       class I {
+       public:
+           static const std::string itemName;
+       };
+
+       class J {
+       public:
+           static const std::string itemName;
+       };
+
+       class K {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class BLOCK_PROBE300 : public ParserKeyword {
+   public:
+       BLOCK_PROBE300();
+       static const std::string keywordName;
+
+       class I {
+       public:
+           static const std::string itemName;
+       };
+
+       class J {
+       public:
+           static const std::string itemName;
+       };
+
+       class K {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class BOGI : public ParserKeyword {
+   public:
+       BOGI();
+       static const std::string keywordName;
+
+       class OIL_PRESSURE {
+       public:
+           static const std::string itemName;
+       };
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class BOUNDARY : public ParserKeyword {
+   public:
+       BOUNDARY();
+       static const std::string keywordName;
+
+       class IX1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class IX2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class JY1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class JY2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class KZ1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class KZ2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class ORIENTATION_INDEX {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class DUAL_PORO_FLAG {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class BOX : public ParserKeyword {
+   public:
+       BOX();
+       static const std::string keywordName;
+
+       class I1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class I2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class J1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class J2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class K1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class K2 {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class BPARA : public ParserKeyword {
+   public:
+       BPARA();
+       static const std::string keywordName;
+   };
+
+
+
+   class BPIDIMS : public ParserKeyword {
+   public:
+       BPIDIMS();
+       static const std::string keywordName;
+
+       class MXNBIP {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MXNLBI {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class BRANPROP : public ParserKeyword {
+   public:
+       BRANPROP();
+       static const std::string keywordName;
+
+       class DOWNTREE_NODE {
+       public:
+           static const std::string itemName;
+       };
+
+       class UPTREE_NODE {
+       public:
+           static const std::string itemName;
+       };
+
+       class VFP_TABLE {
+       public:
+           static const std::string itemName;
+       };
+
+       class ALQ {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class ALQ_SURFACE_DENSITY {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class BRINE : public ParserKeyword {
+   public:
+       BRINE();
+       static const std::string keywordName;
+   };
+
+
+
+   class BTOBALFA : public ParserKeyword {
+   public:
+       BTOBALFA();
+       static const std::string keywordName;
+
+       class VALUE {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class BTOBALFV : public ParserKeyword {
+   public:
+       BTOBALFV();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+}
+}
+#endif

ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/F.hpp

@@ -0,0 +1,570 @@
+#ifndef PARSER_KEYWORDS_F_HPP
+#define PARSER_KEYWORDS_F_HPP
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
+namespace Opm {
+namespace ParserKeywords {
+
+   class FAULTDIM : public ParserKeyword {
+   public:
+       FAULTDIM();
+       static const std::string keywordName;
+
+       class MFSEGS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class FAULTS : public ParserKeyword {
+   public:
+       FAULTS();
+       static const std::string keywordName;
+
+       class NAME {
+       public:
+           static const std::string itemName;
+       };
+
+       class IX1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class IX2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class IY1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class IY2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class IZ1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class IZ2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class FACE {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FBHPDEF : public ParserKeyword {
+   public:
+       FBHPDEF();
+       static const std::string keywordName;
+
+       class TARGET_BHP {
+       public:
+           static const std::string itemName;
+       };
+
+       class LIMIT_BHP {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FHERCHBL : public ParserKeyword {
+   public:
+       FHERCHBL();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FIELD : public ParserKeyword {
+   public:
+       FIELD();
+       static const std::string keywordName;
+   };
+
+
+
+   class FIELD_PROBE : public ParserKeyword {
+   public:
+       FIELD_PROBE();
+       static const std::string keywordName;
+   };
+
+
+
+   class FILEUNIT : public ParserKeyword {
+   public:
+       FILEUNIT();
+       static const std::string keywordName;
+
+       class FILE_UNIT_SYSTEM {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FILLEPS : public ParserKeyword {
+   public:
+       FILLEPS();
+       static const std::string keywordName;
+   };
+
+
+
+   class FIPNUM : public ParserKeyword {
+   public:
+       FIPNUM();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FIPOWG : public ParserKeyword {
+   public:
+       FIPOWG();
+       static const std::string keywordName;
+   };
+
+
+
+   class FIPSEP : public ParserKeyword {
+   public:
+       FIPSEP();
+       static const std::string keywordName;
+
+       class FLUID_IN_PLACE_REGION {
+       public:
+           static const std::string itemName;
+       };
+
+       class STAGE_INDEX {
+       public:
+           static const std::string itemName;
+       };
+
+       class STAGE_TEMPERATURE {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class STAGE_PRESSURE {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class DESTINATION_OUPUT {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class DESTINATION_STAGE {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class K_VAL_TABLE_NUM {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class GAS_PLANT_TABLE_NUM {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class SURF_EQ_STATE_NUM {
+       public:
+           static const std::string itemName;
+       };
+
+       class DENSITY_EVAL_GAS_TEMP {
+       public:
+           static const std::string itemName;
+       };
+
+       class DENSITY_EVAL_PRESSURE_TEMP {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FIP_PROBE : public ParserKeyword {
+   public:
+       FIP_PROBE();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FLUXNUM : public ParserKeyword {
+   public:
+       FLUXNUM();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FLUXREG : public ParserKeyword {
+   public:
+       FLUXREG();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FLUXTYPE : public ParserKeyword {
+   public:
+       FLUXTYPE();
+       static const std::string keywordName;
+   };
+
+
+
+   class FMTHMD : public ParserKeyword {
+   public:
+       FMTHMD();
+       static const std::string keywordName;
+   };
+
+
+
+   class FMTIN : public ParserKeyword {
+   public:
+       FMTIN();
+       static const std::string keywordName;
+   };
+
+
+
+   class FMTOUT : public ParserKeyword {
+   public:
+       FMTOUT();
+       static const std::string keywordName;
+   };
+
+
+
+   class FMWSET : public ParserKeyword {
+   public:
+       FMWSET();
+       static const std::string keywordName;
+   };
+
+
+
+   class FOAM : public ParserKeyword {
+   public:
+       FOAM();
+       static const std::string keywordName;
+   };
+
+
+
+   class FOAMADS : public ParserKeyword {
+   public:
+       FOAMADS();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FOAMDCYO : public ParserKeyword {
+   public:
+       FOAMDCYO();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FOAMDCYW : public ParserKeyword {
+   public:
+       FOAMDCYW();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FOAMFCN : public ParserKeyword {
+   public:
+       FOAMFCN();
+       static const std::string keywordName;
+
+       class CAPILLARY_NUMBER {
+       public:
+           static const std::string itemName;
+       };
+
+       class EXP {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class FOAMFRM : public ParserKeyword {
+   public:
+       FOAMFRM();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FOAMFSC : public ParserKeyword {
+   public:
+       FOAMFSC();
+       static const std::string keywordName;
+
+       class REF_SURF_CONC {
+       public:
+           static const std::string itemName;
+       };
+
+       class EXPONENT {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class MIN_SURF_CONC {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class FOAMFSO : public ParserKeyword {
+   public:
+       FOAMFSO();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FOAMFST : public ParserKeyword {
+   public:
+       FOAMFST();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FOAMFSW : public ParserKeyword {
+   public:
+       FOAMFSW();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FOAMMOB : public ParserKeyword {
+   public:
+       FOAMMOB();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FOAMMOBP : public ParserKeyword {
+   public:
+       FOAMMOBP();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FOAMMOBS : public ParserKeyword {
+   public:
+       FOAMMOBS();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FOAMOPTS : public ParserKeyword {
+   public:
+       FOAMOPTS();
+       static const std::string keywordName;
+
+       class TRANSPORT_PHASE {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class MODEL {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FOAMROCK : public ParserKeyword {
+   public:
+       FOAMROCK();
+       static const std::string keywordName;
+
+       class ADSORPTION_INDEX {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class ROCK_DENSITY {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class FORMFEED : public ParserKeyword {
+   public:
+       FORMFEED();
+       static const std::string keywordName;
+
+       class VALUE {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class FRICTION : public ParserKeyword {
+   public:
+       FRICTION();
+       static const std::string keywordName;
+
+       class NWFRIC {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class NWFRIB {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class FULLIMP : public ParserKeyword {
+   public:
+       FULLIMP();
+       static const std::string keywordName;
+   };
+
+
+
+}
+}
+#endif

ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/H.hpp

@@ -0,0 +1,848 @@
+#ifndef PARSER_KEYWORDS_H_HPP
+#define PARSER_KEYWORDS_H_HPP
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
+namespace Opm {
+namespace ParserKeywords {
+
+   class HALFTRAN : public ParserKeyword {
+   public:
+       HALFTRAN();
+       static const std::string keywordName;
+   };
+
+
+
+   class HAxxxxxx : public ParserKeyword {
+   public:
+       HAxxxxxx();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HBNUM : public ParserKeyword {
+   public:
+       HBNUM();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HDISP : public ParserKeyword {
+   public:
+       HDISP();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HEATCR : public ParserKeyword {
+   public:
+       HEATCR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HEATCRT : public ParserKeyword {
+   public:
+       HEATCRT();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HMAQUCT : public ParserKeyword {
+   public:
+       HMAQUCT();
+       static const std::string keywordName;
+
+       class AQUIFER_ID {
+       public:
+           static const std::string itemName;
+       };
+
+       class DERIVATIES_RESP_PERM_MULT {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class DERIVATIES_RESP_OPEN_ANGLE_MULT {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class DERIVATIES_RESP_AQUIFER_DEPTH {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class HMAQUFET : public ParserKeyword {
+   public:
+       HMAQUFET();
+       static const std::string keywordName;
+
+       class AQUIFER_ID {
+       public:
+           static const std::string itemName;
+       };
+
+       class DERIVATIES_RESP_WAT_VOL_MULT {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class DERIVATIES_RESP_AQUIFER_PROD_INDEX_MULT {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class DERIVATIES_RESP_AQUIFER_DEPTH {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class HMAQUNUM : public ParserKeyword {
+   public:
+       HMAQUNUM();
+       static const std::string keywordName;
+
+       class AQUIFER_ID {
+       public:
+           static const std::string itemName;
+       };
+
+       class DERIVATIES_RESP_PORE_VOL_MULT {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class DERIVATIES_RESP_AQUIFER_PERM_MULT {
+       public:
+           static const std::string itemName;
+       };
+
+       class DERIVATIES_RESP_AQUIFER_GRID_CON_TRANS {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class HMDIMS : public ParserKeyword {
+   public:
+       HMDIMS();
+       static const std::string keywordName;
+
+       class MAX_GRAD_REGIONS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_SUB_REGIONS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_GRADS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_FAULTS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_AQUIFER_PARAMS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_WELL_PARAMS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class UNUSED {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_ROCK_GRAD_PARAMS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_WELL_CONN_PARAMS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class HMFAULTS : public ParserKeyword {
+   public:
+       HMFAULTS();
+       static const std::string keywordName;
+
+       class FAULT_SEGMENT {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HMMLAQUN : public ParserKeyword {
+   public:
+       HMMLAQUN();
+       static const std::string keywordName;
+
+       class AQUIFER_ID {
+       public:
+           static const std::string itemName;
+       };
+
+       class AQUIFER_PORE_VOL_MULT {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class AQUIFER_PORE_PERM_MULT {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class AQUIFER_GRID_CONN_MULT {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class HMMLCTAQ : public ParserKeyword {
+   public:
+       HMMLCTAQ();
+       static const std::string keywordName;
+
+       class AQUIFER_ID {
+       public:
+           static const std::string itemName;
+       };
+
+       class AQUIFER_PERM_MULT {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class AQUIFER_ANGLE_MULT {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class AQUIFER_DEPTH_MULT {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class HMMLFTAQ : public ParserKeyword {
+   public:
+       HMMLFTAQ();
+       static const std::string keywordName;
+
+       class AQUIFER_ID {
+       public:
+           static const std::string itemName;
+       };
+
+       class AQUIFER_WAT_VOL_MULT {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class AQUIFER_PROD_INDEX_MULT {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class AQUIFER_DEPTH_MULT {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class HMMLTWCN : public ParserKeyword {
+   public:
+       HMMLTWCN();
+       static const std::string keywordName;
+
+       class WELL {
+       public:
+           static const std::string itemName;
+       };
+
+       class GRID {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class I {
+       public:
+           static const std::string itemName;
+       };
+
+       class J {
+       public:
+           static const std::string itemName;
+       };
+
+       class K {
+       public:
+           static const std::string itemName;
+       };
+
+       class CTF {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class SKIN {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class HMMULTFT : public ParserKeyword {
+   public:
+       HMMULTFT();
+       static const std::string keywordName;
+
+       class FAULT {
+       public:
+           static const std::string itemName;
+       };
+
+       class TRANS_MULT {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class DIFF_MULT {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class HMMULTSG : public ParserKeyword {
+   public:
+       HMMULTSG();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HMMULTxx : public ParserKeyword {
+   public:
+       HMMULTxx();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HMPROPS : public ParserKeyword {
+   public:
+       HMPROPS();
+       static const std::string keywordName;
+   };
+
+
+
+   class HMROCK : public ParserKeyword {
+   public:
+       HMROCK();
+       static const std::string keywordName;
+
+       class TABLE_NUMBER {
+       public:
+           static const std::string itemName;
+       };
+
+       class CALCULATE_GRADIENTS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class HMROCKT : public ParserKeyword {
+   public:
+       HMROCKT();
+       static const std::string keywordName;
+
+       class TABLE_NUMBER {
+       public:
+           static const std::string itemName;
+       };
+
+       class CALCULATE_GRADIENTS_1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class CALCULATE_GRADIENTS_2 {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HMRREF : public ParserKeyword {
+   public:
+       HMRREF();
+       static const std::string keywordName;
+
+       class P_REF {
+       public:
+           static const std::string itemName;
+       };
+
+       class P_DIM {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HMWELCON : public ParserKeyword {
+   public:
+       HMWELCON();
+       static const std::string keywordName;
+
+       class WELL {
+       public:
+           static const std::string itemName;
+       };
+
+       class GRID {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class I {
+       public:
+           static const std::string itemName;
+       };
+
+       class J {
+       public:
+           static const std::string itemName;
+       };
+
+       class K {
+       public:
+           static const std::string itemName;
+       };
+
+       class REQ_TRANS_FACTOR_GRAD {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class REQ_SKIN_FACTOR_GRAD {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class HMWPIMLT : public ParserKeyword {
+   public:
+       HMWPIMLT();
+       static const std::string keywordName;
+
+       class WELL {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HMxxxxxx : public ParserKeyword {
+   public:
+       HMxxxxxx();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HRFIN : public ParserKeyword {
+   public:
+       HRFIN();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HWKRO : public ParserKeyword {
+   public:
+       HWKRO();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HWKRORG : public ParserKeyword {
+   public:
+       HWKRORG();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HWKRORW : public ParserKeyword {
+   public:
+       HWKRORW();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HWKRW : public ParserKeyword {
+   public:
+       HWKRW();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HWKRWR : public ParserKeyword {
+   public:
+       HWKRWR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HWPCW : public ParserKeyword {
+   public:
+       HWPCW();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HWSNUM : public ParserKeyword {
+   public:
+       HWSNUM();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HWSOGCR : public ParserKeyword {
+   public:
+       HWSOGCR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HWSOWCR : public ParserKeyword {
+   public:
+       HWSOWCR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HWSWCR : public ParserKeyword {
+   public:
+       HWSWCR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HWSWL : public ParserKeyword {
+   public:
+       HWSWL();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HWSWLPC : public ParserKeyword {
+   public:
+       HWSWLPC();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HWSWU : public ParserKeyword {
+   public:
+       HWSWU();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HXFIN : public ParserKeyword {
+   public:
+       HXFIN();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HYDRHEAD : public ParserKeyword {
+   public:
+       HYDRHEAD();
+       static const std::string keywordName;
+
+       class REF_DEPTH {
+       public:
+           static const std::string itemName;
+       };
+
+       class FRESHWATER_DENSITY {
+       public:
+           static const std::string itemName;
+       };
+
+       class REMOVE_DEPTH_TERMS {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class HYFIN : public ParserKeyword {
+   public:
+       HYFIN();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class HYMOBGDR : public ParserKeyword {
+   public:
+       HYMOBGDR();
+       static const std::string keywordName;
+   };
+
+
+
+   class HYST : public ParserKeyword {
+   public:
+       HYST();
+       static const std::string keywordName;
+   };
+
+
+
+   class HYSTCHCK : public ParserKeyword {
+   public:
+       HYSTCHCK();
+       static const std::string keywordName;
+   };
+
+
+
+   class HZFIN : public ParserKeyword {
+   public:
+       HZFIN();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+}
+}
+#endif

ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/I.hpp

@@ -0,0 +1,412 @@
+#ifndef PARSER_KEYWORDS_I_HPP
+#define PARSER_KEYWORDS_I_HPP
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
+namespace Opm {
+namespace ParserKeywords {
+
+   class IHOST : public ParserKeyword {
+   public:
+       IHOST();
+       static const std::string keywordName;
+
+       class LGR {
+       public:
+           static const std::string itemName;
+       };
+
+       class PROCESS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class IMBNUM : public ParserKeyword {
+   public:
+       IMBNUM();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class IMBNUMMF : public ParserKeyword {
+   public:
+       IMBNUMMF();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class IMKRVD : public ParserKeyword {
+   public:
+       IMKRVD();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class IMPCVD : public ParserKeyword {
+   public:
+       IMPCVD();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class IMPES : public ParserKeyword {
+   public:
+       IMPES();
+       static const std::string keywordName;
+   };
+
+
+
+   class IMPLICIT : public ParserKeyword {
+   public:
+       IMPLICIT();
+       static const std::string keywordName;
+   };
+
+
+
+   class IMPORT : public ParserKeyword {
+   public:
+       IMPORT();
+       static const std::string keywordName;
+
+       class FILE {
+       public:
+           static const std::string itemName;
+       };
+
+       class FORMATTED {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class IMPTVD : public ParserKeyword {
+   public:
+       IMPTVD();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class IMSPCVD : public ParserKeyword {
+   public:
+       IMSPCVD();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class INCLUDE : public ParserKeyword {
+   public:
+       INCLUDE();
+       static const std::string keywordName;
+
+       class IncludeFile {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class INIT : public ParserKeyword {
+   public:
+       INIT();
+       static const std::string keywordName;
+   };
+
+
+
+   class INRAD : public ParserKeyword {
+   public:
+       INRAD();
+       static const std::string keywordName;
+
+       class RADIUS {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class INSPEC : public ParserKeyword {
+   public:
+       INSPEC();
+       static const std::string keywordName;
+   };
+
+
+
+   class INTPC : public ParserKeyword {
+   public:
+       INTPC();
+       static const std::string keywordName;
+
+       class PHASE {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class IONROCK : public ParserKeyword {
+   public:
+       IONROCK();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class IONXROCK : public ParserKeyword {
+   public:
+       IONXROCK();
+       static const std::string keywordName;
+
+       class VALUE {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class IONXSURF : public ParserKeyword {
+   public:
+       IONXSURF();
+       static const std::string keywordName;
+
+       class MOLECULAR_WEIGHT {
+       public:
+           static const std::string itemName;
+       };
+
+       class ION_EXCH_CONST {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class IPCG : public ParserKeyword {
+   public:
+       IPCG();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class IPCW : public ParserKeyword {
+   public:
+       IPCW();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ISGCR : public ParserKeyword {
+   public:
+       ISGCR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ISGL : public ParserKeyword {
+   public:
+       ISGL();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ISGLPC : public ParserKeyword {
+   public:
+       ISGLPC();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ISGU : public ParserKeyword {
+   public:
+       ISGU();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ISOGCR : public ParserKeyword {
+   public:
+       ISOGCR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ISOLNUM : public ParserKeyword {
+   public:
+       ISOLNUM();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ISOWCR : public ParserKeyword {
+   public:
+       ISOWCR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ISWCR : public ParserKeyword {
+   public:
+       ISWCR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ISWL : public ParserKeyword {
+   public:
+       ISWL();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ISWLPC : public ParserKeyword {
+   public:
+       ISWLPC();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ISWU : public ParserKeyword {
+   public:
+       ISWU();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+}
+}
+#endif

ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/J.hpp

@@ -0,0 +1,95 @@
+#ifndef PARSER_KEYWORDS_J_HPP
+#define PARSER_KEYWORDS_J_HPP
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
+namespace Opm {
+namespace ParserKeywords {
+
+   class JFUNC : public ParserKeyword {
+   public:
+       JFUNC();
+       static const std::string keywordName;
+
+       class FLAG {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class OW_SURFACE_TENSION {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class GO_SURFACE_TENSION {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class ALPHA_FACTOR {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class BETA_FACTOR {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class DIRECTION {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class JFUNCR : public ParserKeyword {
+   public:
+       JFUNCR();
+       static const std::string keywordName;
+
+       class J_FUNCTION {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class OIL_WAT_SURF_TENSTION {
+       public:
+           static const std::string itemName;
+       };
+
+       class OIL_GAS_SURF_TENSTION {
+       public:
+           static const std::string itemName;
+       };
+
+       class POROSITY_POWER {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class PERMEABILITY_POWER {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class PERM_DIRECTION {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+}
+}
+#endif

ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/K.hpp

@@ -0,0 +1,35 @@
+#ifndef PARSER_KEYWORDS_K_HPP
+#define PARSER_KEYWORDS_K_HPP
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
+namespace Opm {
+namespace ParserKeywords {
+
+   class KRNUM : public ParserKeyword {
+   public:
+       KRNUM();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class KRNUMMF : public ParserKeyword {
+   public:
+       KRNUMMF();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+}
+}
+#endif

ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/L.hpp

@@ -0,0 +1,840 @@
+#ifndef PARSER_KEYWORDS_L_HPP
+#define PARSER_KEYWORDS_L_HPP
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
+namespace Opm {
+namespace ParserKeywords {
+
+   class LAB : public ParserKeyword {
+   public:
+       LAB();
+       static const std::string keywordName;
+   };
+
+
+
+   class LANGMPL : public ParserKeyword {
+   public:
+       LANGMPL();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LANGMUIR : public ParserKeyword {
+   public:
+       LANGMUIR();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LANGSOLV : public ParserKeyword {
+   public:
+       LANGSOLV();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LCUNIT : public ParserKeyword {
+   public:
+       LCUNIT();
+       static const std::string keywordName;
+
+       class UNIT {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class LGR : public ParserKeyword {
+   public:
+       LGR();
+       static const std::string keywordName;
+
+       class MAXLGR {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAXCLS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MCOARS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAMALG {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MXLALG {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class LSTACK {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class INTERP {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class NCHCOR {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class LGRCOPY : public ParserKeyword {
+   public:
+       LGRCOPY();
+       static const std::string keywordName;
+   };
+
+
+
+   class LGRFREE : public ParserKeyword {
+   public:
+       LGRFREE();
+       static const std::string keywordName;
+
+       class LOCAL_GRID_REFINMENT {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LGRLOCK : public ParserKeyword {
+   public:
+       LGRLOCK();
+       static const std::string keywordName;
+
+       class LOCAL_GRID_REFINMENT {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LGROFF : public ParserKeyword {
+   public:
+       LGROFF();
+       static const std::string keywordName;
+
+       class LOCAL_GRID_REFINMENT {
+       public:
+           static const std::string itemName;
+       };
+
+       class ACTIVE_WELLS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class LGRON : public ParserKeyword {
+   public:
+       LGRON();
+       static const std::string keywordName;
+
+       class LOCAL_GRID_REFINMENT {
+       public:
+           static const std::string itemName;
+       };
+
+       class ACTIVE_WELLS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class LICENSE : public ParserKeyword {
+   public:
+       LICENSE();
+       static const std::string keywordName;
+
+       class FEATURE {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LIFTOPT : public ParserKeyword {
+   public:
+       LIFTOPT();
+       static const std::string keywordName;
+
+       class INCREMENT_SIZE {
+       public:
+           static const std::string itemName;
+       };
+
+       class MIN_ECONOMIC_GRADIENT {
+       public:
+           static const std::string itemName;
+       };
+
+       class MIN_INTERVAL_BETWEEN_GAS_LIFT_OPTIMIZATIONS {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class OPTIMISE_GAS_LIFT {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class LINCOM : public ParserKeyword {
+   public:
+       LINCOM();
+       static const std::string keywordName;
+
+       class ALPHA {
+       public:
+           static const std::string itemName;
+           static const UDAValue defaultValue;
+       };
+
+       class BETA {
+       public:
+           static const std::string itemName;
+           static const UDAValue defaultValue;
+       };
+
+       class GAMMA {
+       public:
+           static const std::string itemName;
+           static const UDAValue defaultValue;
+       };
+   };
+
+
+
+   class LINKPERM : public ParserKeyword {
+   public:
+       LINKPERM();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LIVEOIL : public ParserKeyword {
+   public:
+       LIVEOIL();
+       static const std::string keywordName;
+   };
+
+
+
+   class LKRO : public ParserKeyword {
+   public:
+       LKRO();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LKRORG : public ParserKeyword {
+   public:
+       LKRORG();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LKRORW : public ParserKeyword {
+   public:
+       LKRORW();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LKRW : public ParserKeyword {
+   public:
+       LKRW();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LKRWR : public ParserKeyword {
+   public:
+       LKRWR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LOAD : public ParserKeyword {
+   public:
+       LOAD();
+       static const std::string keywordName;
+
+       class FILE {
+       public:
+           static const std::string itemName;
+       };
+
+       class REPORT_STEP {
+       public:
+           static const std::string itemName;
+       };
+
+       class NOSIM {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class FORMATTED {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class REQUEST_SAVE_OUTPUT {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class LOWSALT : public ParserKeyword {
+   public:
+       LOWSALT();
+       static const std::string keywordName;
+   };
+
+
+
+   class LPCW : public ParserKeyword {
+   public:
+       LPCW();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LSALTFNC : public ParserKeyword {
+   public:
+       LSALTFNC();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LSLTWNUM : public ParserKeyword {
+   public:
+       LSLTWNUM();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LSNUM : public ParserKeyword {
+   public:
+       LSNUM();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LSOGCR : public ParserKeyword {
+   public:
+       LSOGCR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LSOWCR : public ParserKeyword {
+   public:
+       LSOWCR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LSWCR : public ParserKeyword {
+   public:
+       LSWCR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LSWL : public ParserKeyword {
+   public:
+       LSWL();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LSWLPC : public ParserKeyword {
+   public:
+       LSWLPC();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LSWU : public ParserKeyword {
+   public:
+       LSWU();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LTOSIGMA : public ParserKeyword {
+   public:
+       LTOSIGMA();
+       static const std::string keywordName;
+
+       class FX {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class FY {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class FZ {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class FGD {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class OPTION {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class LWKRO : public ParserKeyword {
+   public:
+       LWKRO();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LWKRORG : public ParserKeyword {
+   public:
+       LWKRORG();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LWKRORW : public ParserKeyword {
+   public:
+       LWKRORW();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LWKRW : public ParserKeyword {
+   public:
+       LWKRW();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LWKRWR : public ParserKeyword {
+   public:
+       LWKRWR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LWPCW : public ParserKeyword {
+   public:
+       LWPCW();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LWSLTNUM : public ParserKeyword {
+   public:
+       LWSLTNUM();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LWSNUM : public ParserKeyword {
+   public:
+       LWSNUM();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LWSOGCR : public ParserKeyword {
+   public:
+       LWSOGCR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LWSOWCR : public ParserKeyword {
+   public:
+       LWSOWCR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LWSWCR : public ParserKeyword {
+   public:
+       LWSWCR();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LWSWL : public ParserKeyword {
+   public:
+       LWSWL();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LWSWLPC : public ParserKeyword {
+   public:
+       LWSWLPC();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LWSWU : public ParserKeyword {
+   public:
+       LWSWU();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LX : public ParserKeyword {
+   public:
+       LX();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LXFIN : public ParserKeyword {
+   public:
+       LXFIN();
+       static const std::string keywordName;
+
+       class CELL_THICKNESS {
+       public:
+           static const std::string itemName;
+       };
+
+       class SIZE_OPTION {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LY : public ParserKeyword {
+   public:
+       LY();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LYFIN : public ParserKeyword {
+   public:
+       LYFIN();
+       static const std::string keywordName;
+
+       class CELL_THICKNESS {
+       public:
+           static const std::string itemName;
+       };
+
+       class SIZE_OPTION {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LZ : public ParserKeyword {
+   public:
+       LZ();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class LZFIN : public ParserKeyword {
+   public:
+       LZFIN();
+       static const std::string keywordName;
+
+       class CELL_THICKNESS {
+       public:
+           static const std::string itemName;
+       };
+
+       class SIZE_OPTION {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+}
+}
+#endif

ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/N.hpp

@@ -0,0 +1,769 @@
+#ifndef PARSER_KEYWORDS_N_HPP
+#define PARSER_KEYWORDS_N_HPP
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
+namespace Opm {
+namespace ParserKeywords {
+
+   class NARROW : public ParserKeyword {
+   public:
+       NARROW();
+       static const std::string keywordName;
+   };
+
+
+
+   class NCONSUMP : public ParserKeyword {
+   public:
+       NCONSUMP();
+       static const std::string keywordName;
+
+       class NODE {
+       public:
+           static const std::string itemName;
+       };
+
+       class GAS_CONSUMPTION_RATE {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class REMOVAL_GROUP {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class NEFAC : public ParserKeyword {
+   public:
+       NEFAC();
+       static const std::string keywordName;
+
+       class NODE {
+       public:
+           static const std::string itemName;
+       };
+
+       class EFF_FACTOR {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class NETBALAN : public ParserKeyword {
+   public:
+       NETBALAN();
+       static const std::string keywordName;
+
+       class TIME_INTERVAL {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class PRESSURE_CONVERGENCE_LIMT {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class MAX_ITER {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class THP_CONVERGENCE_LIMIT {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class MAX_ITER_THP {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class TARGET_BALANCE_ERROR {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class MAX_BALANCE_ERROR {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class MIN_TIME_STEP {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class NETCOMPA : public ParserKeyword {
+   public:
+       NETCOMPA();
+       static const std::string keywordName;
+
+       class INLET {
+       public:
+           static const std::string itemName;
+       };
+
+       class OUTLET {
+       public:
+           static const std::string itemName;
+       };
+
+       class GROUP {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class PHASE {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class VFT_TABLE_NUM {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class ALQ {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class GAS_CONSUMPTION_RATE {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class EXTRACTION_GROUP {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class COMPRESSOR_TYPE {
+       public:
+           static const std::string itemName;
+       };
+
+       class NUM_COMPRESSION_LEVELS {
+       public:
+           static const std::string itemName;
+       };
+
+       class ALQ_LEVEL1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class COMP_SWITCH_SEQ_NUM {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class NETWORK : public ParserKeyword {
+   public:
+       NETWORK();
+       static const std::string keywordName;
+
+       class NODMAX {
+       public:
+           static const std::string itemName;
+       };
+
+       class NBRMAX {
+       public:
+           static const std::string itemName;
+       };
+
+       class NBCMAX {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class NEWTRAN : public ParserKeyword {
+   public:
+       NEWTRAN();
+       static const std::string keywordName;
+   };
+
+
+
+   class NEXT : public ParserKeyword {
+   public:
+       NEXT();
+       static const std::string keywordName;
+
+       class MAX_STEP {
+       public:
+           static const std::string itemName;
+       };
+
+       class APPLY_TO_ALL {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class NEXTSTEP : public ParserKeyword {
+   public:
+       NEXTSTEP();
+       static const std::string keywordName;
+
+       class MAX_STEP {
+       public:
+           static const std::string itemName;
+       };
+
+       class APPLY_TO_ALL {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class NEXTSTPL : public ParserKeyword {
+   public:
+       NEXTSTPL();
+       static const std::string keywordName;
+
+       class MAX_LENGTH {
+       public:
+           static const std::string itemName;
+       };
+
+       class APPLY_TO_ALL {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class NINENUM : public ParserKeyword {
+   public:
+       NINENUM();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class NINEPOIN : public ParserKeyword {
+   public:
+       NINEPOIN();
+       static const std::string keywordName;
+   };
+
+
+
+   class NMATOPTS : public ParserKeyword {
+   public:
+       NMATOPTS();
+       static const std::string keywordName;
+
+       class GEOMETRY {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class FRACTION_PORE_VOL {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class METHOD {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class NMATRIX : public ParserKeyword {
+   public:
+       NMATRIX();
+       static const std::string keywordName;
+
+       class NUM_SUB_CELLS {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class NNC : public ParserKeyword {
+   public:
+       NNC();
+       static const std::string keywordName;
+
+       class I1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class J1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class K1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class I2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class J2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class K2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class TRAN {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class SIM_DEPENDENT1 {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class SIM_DEPENDENT2 {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class PRESSURE_TABLE1 {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class PRESSURE_TABLE2 {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class VE_FACE1 {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class VE_FACE2 {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class DIFFUSIVITY {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class SIM_DEPENDENT3 {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class VDFLOW_AREA {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class VDFLOW_PERM {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class NNEWTF : public ParserKeyword {
+   public:
+       NNEWTF();
+       static const std::string keywordName;
+
+       class NTHRBL {
+       public:
+           static const std::string itemName;
+       };
+
+       class NLNHBL {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class NOCASC : public ParserKeyword {
+   public:
+       NOCASC();
+       static const std::string keywordName;
+   };
+
+
+
+   class NODEPROP : public ParserKeyword {
+   public:
+       NODEPROP();
+       static const std::string keywordName;
+
+       class NAME {
+       public:
+           static const std::string itemName;
+       };
+
+       class PRESSURE {
+       public:
+           static const std::string itemName;
+       };
+
+       class AS_CHOKE {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class ADD_GAS_LIFT_GAS {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class CHOKE_GROUP {
+       public:
+           static const std::string itemName;
+       };
+
+       class SOURCE_SINK_GROUP {
+       public:
+           static const std::string itemName;
+       };
+
+       class NETWORK_VALUE_TYPE {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class NODPPM : public ParserKeyword {
+   public:
+       NODPPM();
+       static const std::string keywordName;
+   };
+
+
+
+   class NOECHO : public ParserKeyword {
+   public:
+       NOECHO();
+       static const std::string keywordName;
+   };
+
+
+
+   class NOGGF : public ParserKeyword {
+   public:
+       NOGGF();
+       static const std::string keywordName;
+   };
+
+
+
+   class NOGRAV : public ParserKeyword {
+   public:
+       NOGRAV();
+       static const std::string keywordName;
+   };
+
+
+
+   class NOHMD : public ParserKeyword {
+   public:
+       NOHMD();
+       static const std::string keywordName;
+
+       class GRAD_PARAMS {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class NOHMO : public ParserKeyword {
+   public:
+       NOHMO();
+       static const std::string keywordName;
+
+       class GRAD_PARAMS {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class NOHYST : public ParserKeyword {
+   public:
+       NOHYST();
+       static const std::string keywordName;
+   };
+
+
+
+   class NOINSPEC : public ParserKeyword {
+   public:
+       NOINSPEC();
+       static const std::string keywordName;
+   };
+
+
+
+   class NOMONITO : public ParserKeyword {
+   public:
+       NOMONITO();
+       static const std::string keywordName;
+   };
+
+
+
+   class NONNC : public ParserKeyword {
+   public:
+       NONNC();
+       static const std::string keywordName;
+   };
+
+
+
+   class NORSSPEC : public ParserKeyword {
+   public:
+       NORSSPEC();
+       static const std::string keywordName;
+   };
+
+
+
+   class NOSIM : public ParserKeyword {
+   public:
+       NOSIM();
+       static const std::string keywordName;
+   };
+
+
+
+   class NOWARN : public ParserKeyword {
+   public:
+       NOWARN();
+       static const std::string keywordName;
+   };
+
+
+
+   class NOWARNEP : public ParserKeyword {
+   public:
+       NOWARNEP();
+       static const std::string keywordName;
+   };
+
+
+
+   class NRSOUT : public ParserKeyword {
+   public:
+       NRSOUT();
+       static const std::string keywordName;
+
+       class MAX_NUM {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class NSTACK : public ParserKeyword {
+   public:
+       NSTACK();
+       static const std::string keywordName;
+
+       class LINEAR_SOLVER_SIZE {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class NTG : public ParserKeyword {
+   public:
+       NTG();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class NUMRES : public ParserKeyword {
+   public:
+       NUMRES();
+       static const std::string keywordName;
+
+       class num {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class NUPCOL : public ParserKeyword {
+   public:
+       NUPCOL();
+       static const std::string keywordName;
+
+       class NUM_ITER {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class NWATREM : public ParserKeyword {
+   public:
+       NWATREM();
+       static const std::string keywordName;
+
+       class NODE {
+       public:
+           static const std::string itemName;
+       };
+
+       class WAX_RATE {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class MAX_FRAC_REMOVAL {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class NXFIN : public ParserKeyword {
+   public:
+       NXFIN();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class NYFIN : public ParserKeyword {
+   public:
+       NYFIN();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class NZFIN : public ParserKeyword {
+   public:
+       NZFIN();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+}
+}
+#endif

ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/Q.hpp

@@ -0,0 +1,48 @@
+#ifndef PARSER_KEYWORDS_Q_HPP
+#define PARSER_KEYWORDS_Q_HPP
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
+namespace Opm {
+namespace ParserKeywords {
+
+   class QDRILL : public ParserKeyword {
+   public:
+       QDRILL();
+       static const std::string keywordName;
+
+       class WELL_NAME {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class QHRATING : public ParserKeyword {
+   public:
+       QHRATING();
+       static const std::string keywordName;
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class QMOBIL : public ParserKeyword {
+   public:
+       QMOBIL();
+       static const std::string keywordName;
+
+       class MOBILE_END_POINT_CORRECTION {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+}
+}
+#endif

ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/U.hpp

@@ -0,0 +1,278 @@
+#ifndef PARSER_KEYWORDS_U_HPP
+#define PARSER_KEYWORDS_U_HPP
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
+namespace Opm {
+namespace ParserKeywords {
+
+   class UDADIMS : public ParserKeyword {
+   public:
+       UDADIMS();
+       static const std::string keywordName;
+
+       class NUM_UDQ_REPLACE {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class IGNORED {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class TOTAL_UDQ_UNIQUE {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class UDQ : public ParserKeyword {
+   public:
+       UDQ();
+       static const std::string keywordName;
+
+       class ACTION {
+       public:
+           static const std::string itemName;
+       };
+
+       class QUANTITY {
+       public:
+           static const std::string itemName;
+       };
+
+       class DATA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class UDQDIMS : public ParserKeyword {
+   public:
+       UDQDIMS();
+       static const std::string keywordName;
+
+       class MAX_FUNCTIONS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_ITEMS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_CONNECTIONS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_FIELDS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_GROUP {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_REGION {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_SEGMENT {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_WELL {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_AQUIFER {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_BLOCK {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class RESTART_NEW_SEED {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class UDQPARAM : public ParserKeyword {
+   public:
+       UDQPARAM();
+       static const std::string keywordName;
+
+       class RANDOM_SEED {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class RANGE {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class UNDEFINED_VALUE {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class CMP_EPSILON {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class UDT : public ParserKeyword {
+   public:
+       UDT();
+       static const std::string keywordName;
+   };
+
+
+
+   class UDTDIMS : public ParserKeyword {
+   public:
+       UDTDIMS();
+       static const std::string keywordName;
+
+       class MAX_TABLES {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_ROWS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_INTERPOLATION_POINTS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_DIMENSIONS {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class UNCODHMD : public ParserKeyword {
+   public:
+       UNCODHMD();
+       static const std::string keywordName;
+   };
+
+
+
+   class UNIFIN : public ParserKeyword {
+   public:
+       UNIFIN();
+       static const std::string keywordName;
+   };
+
+
+
+   class UNIFOUT : public ParserKeyword {
+   public:
+       UNIFOUT();
+       static const std::string keywordName;
+   };
+
+
+
+   class UNIFOUTS : public ParserKeyword {
+   public:
+       UNIFOUTS();
+       static const std::string keywordName;
+   };
+
+
+
+   class UNIFSAVE : public ParserKeyword {
+   public:
+       UNIFSAVE();
+       static const std::string keywordName;
+   };
+
+
+
+   class USECUPL : public ParserKeyword {
+   public:
+       USECUPL();
+       static const std::string keywordName;
+
+       class BASE {
+       public:
+           static const std::string itemName;
+       };
+
+       class FMT {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class USEFLUX : public ParserKeyword {
+   public:
+       USEFLUX();
+       static const std::string keywordName;
+   };
+
+
+
+   class USENOFLO : public ParserKeyword {
+   public:
+       USENOFLO();
+       static const std::string keywordName;
+   };
+
+
+
+}
+}
+#endif

ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/V.hpp

@@ -0,0 +1,587 @@
+#ifndef PARSER_KEYWORDS_V_HPP
+#define PARSER_KEYWORDS_V_HPP
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
+namespace Opm {
+namespace ParserKeywords {
+
+   class VAPOIL : public ParserKeyword {
+   public:
+       VAPOIL();
+       static const std::string keywordName;
+   };
+
+
+
+   class VAPPARS : public ParserKeyword {
+   public:
+       VAPPARS();
+       static const std::string keywordName;
+
+       class OIL_VAP_PROPENSITY {
+       public:
+           static const std::string itemName;
+       };
+
+       class OIL_DENSITY_PROPENSITY {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class VAPWAT : public ParserKeyword {
+   public:
+       VAPWAT();
+       static const std::string keywordName;
+   };
+
+
+
+   class VDFLOW : public ParserKeyword {
+   public:
+       VDFLOW();
+       static const std::string keywordName;
+
+       class BETA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class VDFLOWR : public ParserKeyword {
+   public:
+       VDFLOWR();
+       static const std::string keywordName;
+
+       class BETA {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class VE : public ParserKeyword {
+   public:
+       VE();
+       static const std::string keywordName;
+
+       class MODEL_TYPE {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class VEDEBUG : public ParserKeyword {
+   public:
+       VEDEBUG();
+       static const std::string keywordName;
+
+       class I1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class I2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class J1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class J2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class K1 {
+       public:
+           static const std::string itemName;
+       };
+
+       class K2 {
+       public:
+           static const std::string itemName;
+       };
+
+       class DEBUG_LEVEL {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class LGR {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class VEFIN : public ParserKeyword {
+   public:
+       VEFIN();
+       static const std::string keywordName;
+
+       class VE {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class NVEPT {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class VEFRAC : public ParserKeyword {
+   public:
+       VEFRAC();
+       static const std::string keywordName;
+
+       class FRAC {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class VEFRACP : public ParserKeyword {
+   public:
+       VEFRACP();
+       static const std::string keywordName;
+
+       class FRAC {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class VEFRACPV : public ParserKeyword {
+   public:
+       VEFRACPV();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class VEFRACV : public ParserKeyword {
+   public:
+       VEFRACV();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class VFPCHK : public ParserKeyword {
+   public:
+       VFPCHK();
+       static const std::string keywordName;
+
+       class BHP_LIMIT {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+   };
+
+
+
+   class VFPIDIMS : public ParserKeyword {
+   public:
+       VFPIDIMS();
+       static const std::string keywordName;
+
+       class MAX_FLOW_TABLE {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_THP_TABLE {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_INJ_VFP_TABLE {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class VFPINJ : public ParserKeyword {
+   public:
+       VFPINJ();
+       static const std::string keywordName;
+
+       class TABLE {
+       public:
+           static const std::string itemName;
+       };
+
+       class DATUM_DEPTH {
+       public:
+           static const std::string itemName;
+       };
+
+       class RATE_TYPE {
+       public:
+           static const std::string itemName;
+       };
+
+       class PRESSURE_DEF {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class UNITS {
+       public:
+           static const std::string itemName;
+       };
+
+       class BODY_DEF {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class FLOW_VALUES {
+       public:
+           static const std::string itemName;
+       };
+
+       class THP_VALUES {
+       public:
+           static const std::string itemName;
+       };
+
+       class THP_INDEX {
+       public:
+           static const std::string itemName;
+       };
+
+       class VALUES {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class VFPPDIMS : public ParserKeyword {
+   public:
+       VFPPDIMS();
+       static const std::string keywordName;
+
+       class MAX_FLOW_TABLE {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_THP_TABLE {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_WCT_TABLE {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_GCT_TABLE {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_ALQ_TABLE {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+
+       class MAX_PROD_VFP_TABLE {
+       public:
+           static const std::string itemName;
+           static const int defaultValue;
+       };
+   };
+
+
+
+   class VFPPROD : public ParserKeyword {
+   public:
+       VFPPROD();
+       static const std::string keywordName;
+
+       class TABLE {
+       public:
+           static const std::string itemName;
+       };
+
+       class DATUM_DEPTH {
+       public:
+           static const std::string itemName;
+       };
+
+       class RATE_TYPE {
+       public:
+           static const std::string itemName;
+       };
+
+       class WFR {
+       public:
+           static const std::string itemName;
+       };
+
+       class GFR {
+       public:
+           static const std::string itemName;
+       };
+
+       class PRESSURE_DEF {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class ALQ_DEF {
+       public:
+           static const std::string itemName;
+       };
+
+       class UNITS {
+       public:
+           static const std::string itemName;
+       };
+
+       class BODY_DEF {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class FLOW_VALUES {
+       public:
+           static const std::string itemName;
+       };
+
+       class THP_VALUES {
+       public:
+           static const std::string itemName;
+       };
+
+       class WFR_VALUES {
+       public:
+           static const std::string itemName;
+       };
+
+       class GFR_VALUES {
+       public:
+           static const std::string itemName;
+       };
+
+       class ALQ_VALUES {
+       public:
+           static const std::string itemName;
+       };
+
+       class THP_INDEX {
+       public:
+           static const std::string itemName;
+       };
+
+       class WFR_INDEX {
+       public:
+           static const std::string itemName;
+       };
+
+       class GFR_INDEX {
+       public:
+           static const std::string itemName;
+       };
+
+       class ALQ_INDEX {
+       public:
+           static const std::string itemName;
+       };
+
+       class VALUES {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class VFPTABL : public ParserKeyword {
+   public:
+       VFPTABL();
+       static const std::string keywordName;
+
+       class METHOD {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class VISAGE : public ParserKeyword {
+   public:
+       VISAGE();
+       static const std::string keywordName;
+   };
+
+
+
+   class VISCD : public ParserKeyword {
+   public:
+       VISCD();
+       static const std::string keywordName;
+   };
+
+
+
+   class VISCREF : public ParserKeyword {
+   public:
+       VISCREF();
+       static const std::string keywordName;
+
+       class REFERENCE_PRESSURE {
+       public:
+           static const std::string itemName;
+       };
+
+       class REFERENCE_RS {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class VISDATES : public ParserKeyword {
+   public:
+       VISDATES();
+       static const std::string keywordName;
+
+       class DAY {
+       public:
+           static const std::string itemName;
+       };
+
+       class MONTH {
+       public:
+           static const std::string itemName;
+       };
+
+       class YEAR {
+       public:
+           static const std::string itemName;
+       };
+
+       class TIMESTAMP {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+   class VISOPTS : public ParserKeyword {
+   public:
+       VISOPTS();
+       static const std::string keywordName;
+
+       class INIT_RUN {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class EXIT {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class ACTIVE {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class REL_TOL {
+       public:
+           static const std::string itemName;
+           static const double defaultValue;
+       };
+
+       class UNUSED {
+       public:
+           static const std::string itemName;
+       };
+
+       class RETAIN_RESTART_FREQUENCY {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class RETAIN_RESTART_CONTENT {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+
+       class ERROR {
+       public:
+           static const std::string itemName;
+           static const std::string defaultValue;
+       };
+   };
+
+
+
+}
+}
+#endif

ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/X.hpp

@@ -0,0 +1,9 @@
+#ifndef PARSER_KEYWORDS_X_HPP
+#define PARSER_KEYWORDS_X_HPP
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
+namespace Opm {
+namespace ParserKeywords {
+
+}
+}
+#endif

ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/Y.hpp

@@ -0,0 +1,9 @@
+#ifndef PARSER_KEYWORDS_Y_HPP
+#define PARSER_KEYWORDS_Y_HPP
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
+namespace Opm {
+namespace ParserKeywords {
+
+}
+}
+#endif

ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/Z.hpp

@@ -0,0 +1,95 @@
+#ifndef PARSER_KEYWORDS_Z_HPP
+#define PARSER_KEYWORDS_Z_HPP
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
+namespace Opm {
+namespace ParserKeywords {
+
+   class ZCORN : public ParserKeyword {
+   public:
+       ZCORN();
+       static const std::string keywordName;
+
+       class data {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ZFACT1 : public ParserKeyword {
+   public:
+       ZFACT1();
+       static const std::string keywordName;
+
+       class Z0 {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ZFACT1S : public ParserKeyword {
+   public:
+       ZFACT1S();
+       static const std::string keywordName;
+
+       class Z0 {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ZFACTOR : public ParserKeyword {
+   public:
+       ZFACTOR();
+       static const std::string keywordName;
+
+       class Z0 {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ZFACTORS : public ParserKeyword {
+   public:
+       ZFACTORS();
+       static const std::string keywordName;
+
+       class Z0 {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+   class ZIPP2OFF : public ParserKeyword {
+   public:
+       ZIPP2OFF();
+       static const std::string keywordName;
+   };
+
+
+
+   class ZIPPY2 : public ParserKeyword {
+   public:
+       ZIPPY2();
+       static const std::string keywordName;
+
+       class SETTINGS {
+       public:
+           static const std::string itemName;
+       };
+   };
+
+
+
+}
+}
+#endif