
#include <opm/input/eclipse/Deck/UDAValue.hpp>
#include <opm/input/eclipse/Parser/ParserItem.hpp>
#include <opm/input/eclipse/Parser/ParserRecord.hpp>
#include <opm/input/eclipse/Parser/Parser.hpp>





#include <opm/input/eclipse/Parser/ParserKeywords/N.hpp>
namespace Opm {
namespace ParserKeywords {
NARROW::NARROW() : ParserKeyword("NARROW", KeywordSize(0, false)) {
  addValidSectionName("SUMMARY");
  clearDeckNames();
  addDeckName("NARROW");
}
const std::string NARROW::keywordName = "NARROW";


NCONSUMP::NCONSUMP() : ParserKeyword("NCONSUMP", KeywordSize(SLASH_TERMINATED)) {
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NCONSUMP");
  {
     ParserRecord record;
     {
        ParserItem item("NODE", ParserItem::itype::STRING);
        record.addItem(item);
     }
     {
        ParserItem item("GAS_CONSUMPTION_RATE", ParserItem::itype::DOUBLE);
        item.setDefault( double(0) );
        item.push_backDimension("GasSurfaceVolume/Time");
        record.addItem(item);
     }
     {
        ParserItem item("REMOVAL_GROUP", ParserItem::itype::STRING);
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NCONSUMP::keywordName = "NCONSUMP";
const std::string NCONSUMP::NODE::itemName = "NODE";
const std::string NCONSUMP::GAS_CONSUMPTION_RATE::itemName = "GAS_CONSUMPTION_RATE";
const double NCONSUMP::GAS_CONSUMPTION_RATE::defaultValue = 0;
const std::string NCONSUMP::REMOVAL_GROUP::itemName = "REMOVAL_GROUP";


NEFAC::NEFAC() : ParserKeyword("NEFAC", KeywordSize(SLASH_TERMINATED)) {
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NEFAC");
  {
     ParserRecord record;
     {
        ParserItem item("NODE", ParserItem::itype::STRING);
        record.addItem(item);
     }
     {
        ParserItem item("EFF_FACTOR", ParserItem::itype::DOUBLE);
        item.setDefault( double(1.000000) );
        item.push_backDimension("1");
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NEFAC::keywordName = "NEFAC";
const std::string NEFAC::NODE::itemName = "NODE";
const std::string NEFAC::EFF_FACTOR::itemName = "EFF_FACTOR";
const double NEFAC::EFF_FACTOR::defaultValue = 1.000000;


NETBALAN::NETBALAN() : ParserKeyword("NETBALAN", KeywordSize(1, false)) {
  addValidSectionName("SPECIAL");
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NETBALAN");
  {
     ParserRecord record;
     {
        ParserItem item("TIME_INTERVAL", ParserItem::itype::DOUBLE);
        item.setDefault( double(0) );
        item.push_backDimension("Time");
        record.addItem(item);
     }
     {
        ParserItem item("PRESSURE_CONVERGENCE_LIMIT", ParserItem::itype::DOUBLE);
        item.setDefault( double(0.100000) );
        item.push_backDimension("Pressure");
        record.addItem(item);
     }
     {
        ParserItem item("MAX_ITER", ParserItem::itype::INT);
        item.setDefault( 10 );
        record.addItem(item);
     }
     {
        ParserItem item("THP_CONVERGENCE_LIMIT", ParserItem::itype::DOUBLE);
        item.setDefault( double(0.010000) );
        record.addItem(item);
     }
     {
        ParserItem item("MAX_ITER_THP", ParserItem::itype::INT);
        item.setDefault( 10 );
        record.addItem(item);
     }
     {
        ParserItem item("TARGET_BALANCE_ERROR", ParserItem::itype::DOUBLE);
        item.setDefault( double(100000000000000000000.000000) );
        item.push_backDimension("Pressure");
        record.addItem(item);
     }
     {
        ParserItem item("MAX_BALANCE_ERROR", ParserItem::itype::DOUBLE);
        item.setDefault( double(100000000000000000000.000000) );
        item.push_backDimension("Pressure");
        record.addItem(item);
     }
     {
        ParserItem item("MIN_TIME_STEP", ParserItem::itype::DOUBLE);
        item.push_backDimension("Time");
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NETBALAN::keywordName = "NETBALAN";
const std::string NETBALAN::TIME_INTERVAL::itemName = "TIME_INTERVAL";
const double NETBALAN::TIME_INTERVAL::defaultValue = 0;
const std::string NETBALAN::PRESSURE_CONVERGENCE_LIMIT::itemName = "PRESSURE_CONVERGENCE_LIMIT";
const double NETBALAN::PRESSURE_CONVERGENCE_LIMIT::defaultValue = 0.100000;
const std::string NETBALAN::MAX_ITER::itemName = "MAX_ITER";
const int NETBALAN::MAX_ITER::defaultValue = 10;
const std::string NETBALAN::THP_CONVERGENCE_LIMIT::itemName = "THP_CONVERGENCE_LIMIT";
const double NETBALAN::THP_CONVERGENCE_LIMIT::defaultValue = 0.010000;
const std::string NETBALAN::MAX_ITER_THP::itemName = "MAX_ITER_THP";
const int NETBALAN::MAX_ITER_THP::defaultValue = 10;
const std::string NETBALAN::TARGET_BALANCE_ERROR::itemName = "TARGET_BALANCE_ERROR";
const double NETBALAN::TARGET_BALANCE_ERROR::defaultValue = 100000000000000000000.000000;
const std::string NETBALAN::MAX_BALANCE_ERROR::itemName = "MAX_BALANCE_ERROR";
const double NETBALAN::MAX_BALANCE_ERROR::defaultValue = 100000000000000000000.000000;
const std::string NETBALAN::MIN_TIME_STEP::itemName = "MIN_TIME_STEP";


NETCOMPA::NETCOMPA() : ParserKeyword("NETCOMPA", KeywordSize(SLASH_TERMINATED)) {
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NETCOMPA");
  {
     ParserRecord record;
     {
        ParserItem item("INLET", ParserItem::itype::STRING);
        record.addItem(item);
     }
     {
        ParserItem item("OUTLET", ParserItem::itype::STRING);
        record.addItem(item);
     }
     {
        ParserItem item("GROUP", ParserItem::itype::STRING);
        item.setDefault( std::string("") );
        record.addItem(item);
     }
     {
        ParserItem item("PHASE", ParserItem::itype::STRING);
        item.setDefault( std::string("GAS") );
        record.addItem(item);
     }
     {
        ParserItem item("VFT_TABLE_NUM", ParserItem::itype::INT);
        item.setDefault( 0 );
        record.addItem(item);
     }
     {
        ParserItem item("ALQ", ParserItem::itype::DOUBLE);
        item.setDefault( double(0) );
        record.addItem(item);
     }
     {
        ParserItem item("GAS_CONSUMPTION_RATE", ParserItem::itype::DOUBLE);
        item.setDefault( double(0) );
        item.push_backDimension("GasSurfaceVolume/Time");
        record.addItem(item);
     }
     {
        ParserItem item("EXTRACTION_GROUP", ParserItem::itype::STRING);
        item.setDefault( std::string("") );
        record.addItem(item);
     }
     {
        ParserItem item("COMPRESSOR_TYPE", ParserItem::itype::STRING);
        record.addItem(item);
     }
     {
        ParserItem item("NUM_COMPRESSION_LEVELS", ParserItem::itype::INT);
        record.addItem(item);
     }
     {
        ParserItem item("ALQ_LEVEL1", ParserItem::itype::DOUBLE);
        record.addItem(item);
     }
     {
        ParserItem item("COMP_SWITCH_SEQ_NUM", ParserItem::itype::INT);
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NETCOMPA::keywordName = "NETCOMPA";
const std::string NETCOMPA::INLET::itemName = "INLET";
const std::string NETCOMPA::OUTLET::itemName = "OUTLET";
const std::string NETCOMPA::GROUP::itemName = "GROUP";
const std::string NETCOMPA::GROUP::defaultValue = "";
const std::string NETCOMPA::PHASE::itemName = "PHASE";
const std::string NETCOMPA::PHASE::defaultValue = "GAS";
const std::string NETCOMPA::VFT_TABLE_NUM::itemName = "VFT_TABLE_NUM";
const int NETCOMPA::VFT_TABLE_NUM::defaultValue = 0;
const std::string NETCOMPA::ALQ::itemName = "ALQ";
const double NETCOMPA::ALQ::defaultValue = 0;
const std::string NETCOMPA::GAS_CONSUMPTION_RATE::itemName = "GAS_CONSUMPTION_RATE";
const double NETCOMPA::GAS_CONSUMPTION_RATE::defaultValue = 0;
const std::string NETCOMPA::EXTRACTION_GROUP::itemName = "EXTRACTION_GROUP";
const std::string NETCOMPA::EXTRACTION_GROUP::defaultValue = "";
const std::string NETCOMPA::COMPRESSOR_TYPE::itemName = "COMPRESSOR_TYPE";
const std::string NETCOMPA::NUM_COMPRESSION_LEVELS::itemName = "NUM_COMPRESSION_LEVELS";
const std::string NETCOMPA::ALQ_LEVEL1::itemName = "ALQ_LEVEL1";
const std::string NETCOMPA::COMP_SWITCH_SEQ_NUM::itemName = "COMP_SWITCH_SEQ_NUM";


NETWORK::NETWORK() : ParserKeyword("NETWORK", KeywordSize(1, false)) {
  addValidSectionName("RUNSPEC");
  clearDeckNames();
  addDeckName("NETWORK");
  {
     ParserRecord record;
     {
        ParserItem item("NODMAX", ParserItem::itype::INT);
        record.addItem(item);
     }
     {
        ParserItem item("NBRMAX", ParserItem::itype::INT);
        record.addItem(item);
     }
     {
        ParserItem item("NBCMAX", ParserItem::itype::INT);
        item.setDefault( 20 );
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NETWORK::keywordName = "NETWORK";
const std::string NETWORK::NODMAX::itemName = "NODMAX";
const std::string NETWORK::NBRMAX::itemName = "NBRMAX";
const std::string NETWORK::NBCMAX::itemName = "NBCMAX";
const int NETWORK::NBCMAX::defaultValue = 20;


NEWTRAN::NEWTRAN() : ParserKeyword("NEWTRAN", KeywordSize(0, false)) {
  addValidSectionName("GRID");
  clearDeckNames();
  addDeckName("NEWTRAN");
}
const std::string NEWTRAN::keywordName = "NEWTRAN";


NEXTSTEP::NEXTSTEP() : ParserKeyword("NEXTSTEP", KeywordSize(1, false)) {
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NEXT");
  addDeckName("NEXTSTEP");
  {
     ParserRecord record;
     {
        ParserItem item("MAX_STEP", ParserItem::itype::DOUBLE);
        item.push_backDimension("Time");
        record.addItem(item);
     }
     {
        ParserItem item("APPLY_TO_ALL", ParserItem::itype::STRING);
        item.setDefault( std::string("NO") );
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NEXTSTEP::keywordName = "NEXTSTEP";
const std::string NEXTSTEP::MAX_STEP::itemName = "MAX_STEP";
const std::string NEXTSTEP::APPLY_TO_ALL::itemName = "APPLY_TO_ALL";
const std::string NEXTSTEP::APPLY_TO_ALL::defaultValue = "NO";


NEXTSTPL::NEXTSTPL() : ParserKeyword("NEXTSTPL", KeywordSize(1, false)) {
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NEXTSTPL");
  {
     ParserRecord record;
     {
        ParserItem item("MAX_LENGTH", ParserItem::itype::DOUBLE);
        item.push_backDimension("Time");
        record.addItem(item);
     }
     {
        ParserItem item("APPLY_TO_ALL", ParserItem::itype::STRING);
        item.setDefault( std::string("NO") );
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NEXTSTPL::keywordName = "NEXTSTPL";
const std::string NEXTSTPL::MAX_LENGTH::itemName = "MAX_LENGTH";
const std::string NEXTSTPL::APPLY_TO_ALL::itemName = "APPLY_TO_ALL";
const std::string NEXTSTPL::APPLY_TO_ALL::defaultValue = "NO";


NINENUM::NINENUM() : ParserKeyword("NINENUM", KeywordSize(1, false)) {
  addValidSectionName("GRID");
  clearDeckNames();
  addDeckName("NINENUM");
  {
     ParserRecord record;
     {
        ParserItem item("data", ParserItem::itype::INT);
        item.setSizeType(ParserItem::item_size::ALL);
        record.addDataItem(item);
     }
     addDataRecord( record );
  }
}
const std::string NINENUM::keywordName = "NINENUM";
const std::string NINENUM::data::itemName = "data";


NINEPOIN::NINEPOIN() : ParserKeyword("NINEPOIN", KeywordSize(0, false)) {
  addValidSectionName("RUNSPEC");
  clearDeckNames();
  addDeckName("NINEPOIN");
}
const std::string NINEPOIN::keywordName = "NINEPOIN";


NMATOPTS::NMATOPTS() : ParserKeyword("NMATOPTS", KeywordSize(1, false)) {
  addValidSectionName("GRID");
  clearDeckNames();
  addDeckName("NMATOPTS");
  {
     ParserRecord record;
     {
        ParserItem item("GEOMETRY", ParserItem::itype::STRING);
        item.setDefault( std::string("LINEAR") );
        record.addItem(item);
     }
     {
        ParserItem item("FRACTION_PORE_VOL", ParserItem::itype::DOUBLE);
        item.setDefault( double(0.100000) );
        item.push_backDimension("1");
        record.addItem(item);
     }
     {
        ParserItem item("METHOD", ParserItem::itype::STRING);
        item.setDefault( std::string("FPORV") );
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NMATOPTS::keywordName = "NMATOPTS";
const std::string NMATOPTS::GEOMETRY::itemName = "GEOMETRY";
const std::string NMATOPTS::GEOMETRY::defaultValue = "LINEAR";
const std::string NMATOPTS::FRACTION_PORE_VOL::itemName = "FRACTION_PORE_VOL";
const double NMATOPTS::FRACTION_PORE_VOL::defaultValue = 0.100000;
const std::string NMATOPTS::METHOD::itemName = "METHOD";
const std::string NMATOPTS::METHOD::defaultValue = "FPORV";


NMATRIX::NMATRIX() : ParserKeyword("NMATRIX", KeywordSize(1, false)) {
  addValidSectionName("RUNSPEC");
  clearDeckNames();
  addDeckName("NMATRIX");
  {
     ParserRecord record;
     {
        ParserItem item("NUM_SUB_CELLS", ParserItem::itype::INT);
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NMATRIX::keywordName = "NMATRIX";
const std::string NMATRIX::NUM_SUB_CELLS::itemName = "NUM_SUB_CELLS";


NMESSAGE::NMESSAGE() : ParserKeyword("NMESSAGE", KeywordSize(0, false)) {
  addValidSectionName("SUMMARY");
  clearDeckNames();
  addDeckName("NMESSAGE");
}
const std::string NMESSAGE::keywordName = "NMESSAGE";


NNC::NNC() : ParserKeyword("NNC", KeywordSize(SLASH_TERMINATED)) {
  addValidSectionName("GRID");
  clearDeckNames();
  addDeckName("NNC");
  {
     ParserRecord record;
     {
        ParserItem item("I1", ParserItem::itype::INT);
        record.addItem(item);
     }
     {
        ParserItem item("J1", ParserItem::itype::INT);
        record.addItem(item);
     }
     {
        ParserItem item("K1", ParserItem::itype::INT);
        record.addItem(item);
     }
     {
        ParserItem item("I2", ParserItem::itype::INT);
        record.addItem(item);
     }
     {
        ParserItem item("J2", ParserItem::itype::INT);
        record.addItem(item);
     }
     {
        ParserItem item("K2", ParserItem::itype::INT);
        record.addItem(item);
     }
     {
        ParserItem item("TRAN", ParserItem::itype::DOUBLE);
        item.setDefault( double(0) );
        item.push_backDimension("Transmissibility");
        record.addItem(item);
     }
     {
        ParserItem item("IST1", ParserItem::itype::INT);
        item.setDefault( 0 );
        record.addItem(item);
     }
     {
        ParserItem item("IST2", ParserItem::itype::INT);
        item.setDefault( 0 );
        record.addItem(item);
     }
     {
        ParserItem item("PRESSURE_TABLE1", ParserItem::itype::INT);
        item.setDefault( 0 );
        record.addItem(item);
     }
     {
        ParserItem item("PRESSURE_TABLE2", ParserItem::itype::INT);
        item.setDefault( 0 );
        record.addItem(item);
     }
     {
        ParserItem item("VE_FACE1", ParserItem::itype::STRING);
        item.setDefault( std::string("") );
        record.addItem(item);
     }
     {
        ParserItem item("VE_FACE2", ParserItem::itype::STRING);
        item.setDefault( std::string("") );
        record.addItem(item);
     }
     {
        ParserItem item("DIFFUSIVITY", ParserItem::itype::DOUBLE);
        item.setDefault( double(0) );
        record.addItem(item);
     }
     {
        ParserItem item("SIM_DEPENDENT3", ParserItem::itype::DOUBLE);
        item.setDefault( double(0) );
        item.push_backDimension("ContextDependent");
        record.addItem(item);
     }
     {
        ParserItem item("VDFLOW_AREA", ParserItem::itype::DOUBLE);
        item.setDefault( double(0) );
        item.push_backDimension("Length*Length");
        record.addItem(item);
     }
     {
        ParserItem item("VDFLOW_PERM", ParserItem::itype::DOUBLE);
        item.setDefault( double(0) );
        item.push_backDimension("Permeability");
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NNC::keywordName = "NNC";
const std::string NNC::I1::itemName = "I1";
const std::string NNC::J1::itemName = "J1";
const std::string NNC::K1::itemName = "K1";
const std::string NNC::I2::itemName = "I2";
const std::string NNC::J2::itemName = "J2";
const std::string NNC::K2::itemName = "K2";
const std::string NNC::TRAN::itemName = "TRAN";
const double NNC::TRAN::defaultValue = 0;
const std::string NNC::IST1::itemName = "IST1";
const int NNC::IST1::defaultValue = 0;
const std::string NNC::IST2::itemName = "IST2";
const int NNC::IST2::defaultValue = 0;
const std::string NNC::PRESSURE_TABLE1::itemName = "PRESSURE_TABLE1";
const int NNC::PRESSURE_TABLE1::defaultValue = 0;
const std::string NNC::PRESSURE_TABLE2::itemName = "PRESSURE_TABLE2";
const int NNC::PRESSURE_TABLE2::defaultValue = 0;
const std::string NNC::VE_FACE1::itemName = "VE_FACE1";
const std::string NNC::VE_FACE1::defaultValue = "";
const std::string NNC::VE_FACE2::itemName = "VE_FACE2";
const std::string NNC::VE_FACE2::defaultValue = "";
const std::string NNC::DIFFUSIVITY::itemName = "DIFFUSIVITY";
const double NNC::DIFFUSIVITY::defaultValue = 0;
const std::string NNC::SIM_DEPENDENT3::itemName = "SIM_DEPENDENT3";
const double NNC::SIM_DEPENDENT3::defaultValue = 0;
const std::string NNC::VDFLOW_AREA::itemName = "VDFLOW_AREA";
const double NNC::VDFLOW_AREA::defaultValue = 0;
const std::string NNC::VDFLOW_PERM::itemName = "VDFLOW_PERM";
const double NNC::VDFLOW_PERM::defaultValue = 0;


NNEWTF::NNEWTF() : ParserKeyword("NNEWTF", KeywordSize(1, false)) {
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NNEWTF");
  {
     ParserRecord record;
     {
        ParserItem item("NTHRBL", ParserItem::itype::INT);
        record.addItem(item);
     }
     {
        ParserItem item("NLNHBL", ParserItem::itype::INT);
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NNEWTF::keywordName = "NNEWTF";
const std::string NNEWTF::NTHRBL::itemName = "NTHRBL";
const std::string NNEWTF::NLNHBL::itemName = "NLNHBL";


NOCASC::NOCASC() : ParserKeyword("NOCASC", KeywordSize(0, false)) {
  addValidSectionName("RUNSPEC");
  clearDeckNames();
  addDeckName("NOCASC");
}
const std::string NOCASC::keywordName = "NOCASC";


NODEPROP::NODEPROP() : ParserKeyword("NODEPROP", KeywordSize(SLASH_TERMINATED)) {
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NODEPROP");
  {
     ParserRecord record;
     {
        ParserItem item("NAME", ParserItem::itype::STRING);
        record.addItem(item);
     }
     {
        ParserItem item("PRESSURE", ParserItem::itype::DOUBLE);
        item.push_backDimension("Pressure");
        record.addItem(item);
     }
     {
        ParserItem item("AS_CHOKE", ParserItem::itype::STRING);
        item.setDefault( std::string("NO") );
        record.addItem(item);
     }
     {
        ParserItem item("ADD_GAS_LIFT_GAS", ParserItem::itype::STRING);
        item.setDefault( std::string("NO") );
        record.addItem(item);
     }
     {
        ParserItem item("CHOKE_GROUP", ParserItem::itype::STRING);
        record.addItem(item);
     }
     {
        ParserItem item("SOURCE_SINK_GROUP", ParserItem::itype::STRING);
        record.addItem(item);
     }
     {
        ParserItem item("NETWORK_VALUE_TYPE", ParserItem::itype::STRING);
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NODEPROP::keywordName = "NODEPROP";
const std::string NODEPROP::NAME::itemName = "NAME";
const std::string NODEPROP::PRESSURE::itemName = "PRESSURE";
const std::string NODEPROP::AS_CHOKE::itemName = "AS_CHOKE";
const std::string NODEPROP::AS_CHOKE::defaultValue = "NO";
const std::string NODEPROP::ADD_GAS_LIFT_GAS::itemName = "ADD_GAS_LIFT_GAS";
const std::string NODEPROP::ADD_GAS_LIFT_GAS::defaultValue = "NO";
const std::string NODEPROP::CHOKE_GROUP::itemName = "CHOKE_GROUP";
const std::string NODEPROP::SOURCE_SINK_GROUP::itemName = "SOURCE_SINK_GROUP";
const std::string NODEPROP::NETWORK_VALUE_TYPE::itemName = "NETWORK_VALUE_TYPE";


NODPPM::NODPPM() : ParserKeyword("NODPPM", KeywordSize(0, false)) {
  addValidSectionName("RUNSPEC");
  addValidSectionName("GRID");
  clearDeckNames();
  addDeckName("NODPPM");
}
const std::string NODPPM::keywordName = "NODPPM";


NOECHO::NOECHO() : ParserKeyword("NOECHO", KeywordSize(0, false)) {
  addValidSectionName("RUNSPEC");
  addValidSectionName("PROPS");
  addValidSectionName("EDIT");
  addValidSectionName("GRID");
  addValidSectionName("REGIONS");
  addValidSectionName("SOLUTION");
  addValidSectionName("SUMMARY");
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NOECHO");
}
const std::string NOECHO::keywordName = "NOECHO";


NOGGF::NOGGF() : ParserKeyword("NOGGF", KeywordSize(0, false)) {
  addValidSectionName("GRID");
  clearDeckNames();
  addDeckName("NOGGF");
}
const std::string NOGGF::keywordName = "NOGGF";


NOGRAV::NOGRAV() : ParserKeyword("NOGRAV", KeywordSize(0, false)) {
  addValidSectionName("RUNSPEC");
  clearDeckNames();
  addDeckName("NOGRAV");
}
const std::string NOGRAV::keywordName = "NOGRAV";


NOHMD::NOHMD() : ParserKeyword("NOHMD", KeywordSize(1, false)) {
  addValidSectionName("SOLUTION");
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NOHMD");
  {
     ParserRecord record;
     {
        ParserItem item("GRAD_PARAMS", ParserItem::itype::STRING);
        item.setSizeType(ParserItem::item_size::ALL);
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NOHMD::keywordName = "NOHMD";
const std::string NOHMD::GRAD_PARAMS::itemName = "GRAD_PARAMS";


NOHMO::NOHMO() : ParserKeyword("NOHMO", KeywordSize(1, false)) {
  addValidSectionName("SOLUTION");
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NOHMO");
  {
     ParserRecord record;
     {
        ParserItem item("GRAD_PARAMS", ParserItem::itype::STRING);
        item.setSizeType(ParserItem::item_size::ALL);
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NOHMO::keywordName = "NOHMO";
const std::string NOHMO::GRAD_PARAMS::itemName = "GRAD_PARAMS";


NOHYST::NOHYST() : ParserKeyword("NOHYST", KeywordSize(0, false)) {
  addValidSectionName("RUNSPEC");
  clearDeckNames();
  addDeckName("NOHYST");
}
const std::string NOHYST::keywordName = "NOHYST";


NOINSPEC::NOINSPEC() : ParserKeyword("NOINSPEC", KeywordSize(0, false)) {
  addValidSectionName("RUNSPEC");
  clearDeckNames();
  addDeckName("NOINSPEC");
}
const std::string NOINSPEC::keywordName = "NOINSPEC";


NOMONITO::NOMONITO() : ParserKeyword("NOMONITO", KeywordSize(0, false)) {
  addValidSectionName("RUNSPEC");
  addValidSectionName("SUMMARY");
  clearDeckNames();
  addDeckName("NOMONITO");
}
const std::string NOMONITO::keywordName = "NOMONITO";


NONNC::NONNC() : ParserKeyword("NONNC", KeywordSize(0, false)) {
  addValidSectionName("RUNSPEC");
  clearDeckNames();
  addDeckName("NONNC");
}
const std::string NONNC::keywordName = "NONNC";


NORSSPEC::NORSSPEC() : ParserKeyword("NORSSPEC", KeywordSize(0, false)) {
  addValidSectionName("RUNSPEC");
  clearDeckNames();
  addDeckName("NORSSPEC");
}
const std::string NORSSPEC::keywordName = "NORSSPEC";


NOSIM::NOSIM() : ParserKeyword("NOSIM", KeywordSize(0, false)) {
  addValidSectionName("RUNSPEC");
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NOSIM");
}
const std::string NOSIM::keywordName = "NOSIM";


NOWARN::NOWARN() : ParserKeyword("NOWARN", KeywordSize(0, false)) {
  addValidSectionName("RUNSPEC");
  addValidSectionName("GRID");
  addValidSectionName("EDIT");
  addValidSectionName("PROPS");
  addValidSectionName("REGIONS");
  addValidSectionName("SOLUTION");
  addValidSectionName("SUMMARY");
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NOWARN");
}
const std::string NOWARN::keywordName = "NOWARN";


NOWARNEP::NOWARNEP() : ParserKeyword("NOWARNEP", KeywordSize(0, false)) {
  addValidSectionName("PROPS");
  clearDeckNames();
  addDeckName("NOWARNEP");
}
const std::string NOWARNEP::keywordName = "NOWARNEP";


NRSOUT::NRSOUT() : ParserKeyword("NRSOUT", KeywordSize(1, false)) {
  addValidSectionName("RUNSPEC");
  clearDeckNames();
  addDeckName("NRSOUT");
  {
     ParserRecord record;
     {
        ParserItem item("MAX_NUM", ParserItem::itype::INT);
        item.setDefault( 3600 );
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NRSOUT::keywordName = "NRSOUT";
const std::string NRSOUT::MAX_NUM::itemName = "MAX_NUM";
const int NRSOUT::MAX_NUM::defaultValue = 3600;


NSTACK::NSTACK() : ParserKeyword("NSTACK", KeywordSize(1, false)) {
  addValidSectionName("RUNSPEC");
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NSTACK");
  {
     ParserRecord record;
     {
        ParserItem item("LINEAR_SOLVER_SIZE", ParserItem::itype::INT);
        item.setDefault( 10 );
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NSTACK::keywordName = "NSTACK";
const std::string NSTACK::LINEAR_SOLVER_SIZE::itemName = "LINEAR_SOLVER_SIZE";
const int NSTACK::LINEAR_SOLVER_SIZE::defaultValue = 10;


NTG::NTG() : ParserKeyword("NTG", KeywordSize(1, false)) {
  addValidSectionName("GRID");
  clearDeckNames();
  addDeckName("NTG");
  {
     ParserRecord record;
     {
        ParserItem item("data", ParserItem::itype::DOUBLE);
        item.setSizeType(ParserItem::item_size::ALL);
        item.push_backDimension("1");
        record.addDataItem(item);
     }
     addDataRecord( record );
  }
}
const std::string NTG::keywordName = "NTG";
const std::string NTG::data::itemName = "data";


NUMRES::NUMRES() : ParserKeyword("NUMRES", KeywordSize(1, false)) {
  addValidSectionName("RUNSPEC");
  clearDeckNames();
  addDeckName("NUMRES");
  {
     ParserRecord record;
     {
        ParserItem item("num", ParserItem::itype::INT);
        item.setDefault( 1 );
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NUMRES::keywordName = "NUMRES";
const std::string NUMRES::num::itemName = "num";
const int NUMRES::num::defaultValue = 1;


NUPCOL::NUPCOL() : ParserKeyword("NUPCOL", KeywordSize(1, false)) {
  addValidSectionName("RUNSPEC");
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NUPCOL");
  {
     ParserRecord record;
     {
        ParserItem item("NUM_ITER", ParserItem::itype::INT);
        item.setDefault( 12 );
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NUPCOL::keywordName = "NUPCOL";
const std::string NUPCOL::NUM_ITER::itemName = "NUM_ITER";
const int NUPCOL::NUM_ITER::defaultValue = 12;


NWATREM::NWATREM() : ParserKeyword("NWATREM", KeywordSize(SLASH_TERMINATED)) {
  addValidSectionName("SCHEDULE");
  clearDeckNames();
  addDeckName("NWATREM");
  {
     ParserRecord record;
     {
        ParserItem item("NODE", ParserItem::itype::STRING);
        record.addItem(item);
     }
     {
        ParserItem item("WAX_RATE", ParserItem::itype::DOUBLE);
        item.setDefault( double(10000000000000000159028911097599180468360808563945281389781327557747838772170381060813469985856815104.000000) );
        item.push_backDimension("LiquidSurfaceVolume/Time");
        record.addItem(item);
     }
     {
        ParserItem item("MAX_FRAC_REMOVAL", ParserItem::itype::DOUBLE);
        item.setDefault( double(1.000000) );
        item.push_backDimension("1");
        record.addItem(item);
     }
     addRecord( record );
  }
}
const std::string NWATREM::keywordName = "NWATREM";
const std::string NWATREM::NODE::itemName = "NODE";
const std::string NWATREM::WAX_RATE::itemName = "WAX_RATE";
const double NWATREM::WAX_RATE::defaultValue = 10000000000000000159028911097599180468360808563945281389781327557747838772170381060813469985856815104.000000;
const std::string NWATREM::MAX_FRAC_REMOVAL::itemName = "MAX_FRAC_REMOVAL";
const double NWATREM::MAX_FRAC_REMOVAL::defaultValue = 1.000000;


NXFIN::NXFIN() : ParserKeyword("NXFIN", KeywordSize(1, false)) {
  addValidSectionName("GRID");
  clearDeckNames();
  addDeckName("NXFIN");
  {
     ParserRecord record;
     {
        ParserItem item("data", ParserItem::itype::INT);
        item.setSizeType(ParserItem::item_size::ALL);
        record.addDataItem(item);
     }
     addDataRecord( record );
  }
}
const std::string NXFIN::keywordName = "NXFIN";
const std::string NXFIN::data::itemName = "data";


NYFIN::NYFIN() : ParserKeyword("NYFIN", KeywordSize(1, false)) {
  addValidSectionName("GRID");
  clearDeckNames();
  addDeckName("NYFIN");
  {
     ParserRecord record;
     {
        ParserItem item("data", ParserItem::itype::INT);
        item.setSizeType(ParserItem::item_size::ALL);
        record.addDataItem(item);
     }
     addDataRecord( record );
  }
}
const std::string NYFIN::keywordName = "NYFIN";
const std::string NYFIN::data::itemName = "data";


NZFIN::NZFIN() : ParserKeyword("NZFIN", KeywordSize(1, false)) {
  addValidSectionName("GRID");
  clearDeckNames();
  addDeckName("NZFIN");
  {
     ParserRecord record;
     {
        ParserItem item("data", ParserItem::itype::INT);
        item.setSizeType(ParserItem::item_size::ALL);
        record.addDataItem(item);
     }
     addDataRecord( record );
  }
}
const std::string NZFIN::keywordName = "NZFIN";
const std::string NZFIN::data::itemName = "data";


}
}
