OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

Use updated version of opm-common as submodule

Browse Source 
* Adjustments to build system for opm-common
* Add opm-common as submodule
* Disable use of unity build for opm-common
This commit is contained in:
Magne Sjaastad
2022-07-07 16:42:06 +02:00
parent d5269abc6e
commit 7a0bfd4917
2184 changed files with 11860 additions and 302420 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitmodules vendored
View File

@@ -10,3 +10,6 @@
[submodule "ThirdParty/qtadvanceddocking"]
path = ThirdParty/qtadvanceddocking
url = https://github.com/CeetronSolutions/qtadvanceddocking.git
[submodule "ThirdParty/custom-opm-common/opm-common"]
path = ThirdParty/custom-opm-common/opm-common
url = https://github.com/CeetronSolutions/opm-common

59
ApplicationLibCode/FileInterface/RifHdf5SummaryExporter.cpp
View File

@@ -23,8 +23,13 @@
#include "RiaStdStringTools.h"
#include "RifHdf5Exporter.h"
#include "RifOpmCommonSummary.h"
#include "RifSummaryReaderInterface.h"
#ifdef _MSC_VER
// Disable warning from external library to make sure treat warnings as error works
#pragma warning( disable : 4267 )
#endif
#include "opm/common/utility/FileSystem.hpp"
#include "opm/common/utility/TimeService.hpp"
#include "opm/io/eclipse/ESmry.hpp"
@@ -76,7 +81,7 @@ bool RifHdf5SummaryExporter::ensureHdf5FileIsCreated( const std::string& smspecF
const std::string& h5FileName,
size_t& hdfFilesCreatedCount )
{
if ( !Opm::filesystem::exists( smspecFileName ) ) return false;
if ( !std::filesystem::exists( smspecFileName ) ) return false;
{
// Check if we have write permission in the folder
@@ -88,7 +93,7 @@ bool RifHdf5SummaryExporter::ensureHdf5FileIsCreated( const std::string& smspecF
bool exportIsRequired = false;
{
bool h5FileExists = Opm::filesystem::exists( h5FileName );
bool h5FileExists = std::filesystem::exists( h5FileName );
if ( !h5FileExists )
{
exportIsRequired = true;
@@ -107,7 +112,7 @@ bool RifHdf5SummaryExporter::ensureHdf5FileIsCreated( const std::string& smspecF
// Read all data summary data before starting export to HDF. Loading one and one summary vector causes huge
// performance penalty
sourceSummaryData.LoadData();
sourceSummaryData.loadData();
#pragma omp critical( critical_section_HDF5_export )
{
@@ -194,53 +199,47 @@ bool RifHdf5SummaryExporter::writeGeneralSection( RifHdf5Exporter& exporter, Opm
//--------------------------------------------------------------------------------------------------
bool RifHdf5SummaryExporter::writeSummaryVectors( RifHdf5Exporter& exporter, Opm::EclIO::ESmry& sourceSummaryData )
{
using SumNodeVector = std::vector<Opm::EclIO::SummaryNode>;
size_t valueCount = sourceSummaryData.numberOfTimeSteps();
if ( valueCount == 0 ) return false;
const std::string datasetName( "values" );
const SumNodeVector& summaryNodeList = sourceSummaryData.summaryNodeList();
auto summaryVectorsGroup = exporter.createGroup( nullptr, "summary_vectors" );
std::map<std::string, std::vector<size_t>> mapKeywordToSummaryNodeIndex;
for ( size_t i = 0; i < summaryNodeList.size(); i++ )
std::map<std::string, std::vector<RifEclipseSummaryAddress>> mapVectorNameToSummaryAddresses;
auto [addresses, addressToKeywordMap] =
RifOpmCommonSummaryTools::buildAddressesAndKeywordMap( sourceSummaryData.keywordList() );
for ( const auto& adr : addresses )
{
const auto summaryNode = summaryNodeList[i];
const std::string keyword = summaryNode.keyword;
auto vectorName = adr.vectorName();
if ( mapKeywordToSummaryNodeIndex.find( keyword ) == mapKeywordToSummaryNodeIndex.end() )
if ( mapVectorNameToSummaryAddresses.find( vectorName ) == mapVectorNameToSummaryAddresses.end() )
{
mapKeywordToSummaryNodeIndex[keyword] = std::vector<size_t>();
mapVectorNameToSummaryAddresses[vectorName] = {};
}
auto it = mapKeywordToSummaryNodeIndex.find( keyword );
if ( it != mapKeywordToSummaryNodeIndex.end() )
auto it = mapVectorNameToSummaryAddresses.find( vectorName );
if ( it != mapVectorNameToSummaryAddresses.end() )
{
it->second.push_back( i );
it->second.push_back( adr );
}
}
auto summaryVectorsGroup = exporter.createGroup( nullptr, "summary_vectors" );
std::set<std::string> exportErrorKeywords;
for ( const auto& nodesForKeyword : mapKeywordToSummaryNodeIndex )
for ( const auto& [vectorName, addresses] : mapVectorNameToSummaryAddresses )
{
std::string keyword = nodesForKeyword.first;
auto keywordGroup = exporter.createGroup( &summaryVectorsGroup, vectorName );
auto keywordGroup = exporter.createGroup( &summaryVectorsGroup, keyword );
for ( auto nodeIndex : nodesForKeyword.second )
for ( const auto& address : addresses )
{
const auto& summaryNode = summaryNodeList[nodeIndex];
auto smspecKeywordIndex = summaryNode.smspecKeywordIndex;
auto keyword = addressToKeywordMap[address];
auto smspecKeywordIndex = sourceSummaryData.getSmspecIndexForKeyword( keyword );
const QString& smspecKeywordText = QString( "%1" ).arg( smspecKeywordIndex );
try
{
const std::vector<float>& values = sourceSummaryData.get( summaryNode );
const std::vector<float>& values = sourceSummaryData.get( keyword );
auto dataValuesGroup = exporter.createGroup( &keywordGroup, smspecKeywordText.toStdString() );
exporter.writeDataset( dataValuesGroup, datasetName, values );
@@ -278,10 +277,10 @@ bool RifHdf5SummaryExporter::isFirstOlderThanSecond( const std::string& firstFil
{
// Use Opm namespace to make sure the code compiles on older compilers
if ( !Opm::filesystem::exists( firstFileName ) || !Opm::filesystem::exists( secondFileName ) ) return false;
if ( !std::filesystem::exists( firstFileName ) || !std::filesystem::exists( secondFileName ) ) return false;
auto timeA = Opm::filesystem::last_write_time( firstFileName );
auto timeB = Opm::filesystem::last_write_time( secondFileName );
auto timeA = std::filesystem::last_write_time( firstFileName );
auto timeB = std::filesystem::last_write_time( secondFileName );
return ( timeA < timeB );
}

128
ApplicationLibCode/FileInterface/RifOpmCommonSummary.cpp
View File

@@ -21,6 +21,10 @@
#include "RiaLogging.h"
#include "RiaStdStringTools.h"
#ifdef _MSC_VER
// Disable warning from external library to make sure treat warnings as error works
#pragma warning( disable : 4267 )
#endif
#include "opm/io/eclipse/ESmry.hpp"
#include "opm/io/eclipse/ExtESmry.hpp"
@@ -209,7 +213,7 @@ void RifOpmCommonEclipseSummary::buildMetaData()
m_timeSteps.push_back( timeAsTimeT );
}
auto [addresses, addressMap] = RifOpmCommonSummaryTools::buildMetaDataKeyword( keywords );
auto [addresses, addressMap] = RifOpmCommonSummaryTools::buildAddressesAndKeywordMap( keywords );
m_allResultAddresses = addresses;
m_summaryAddressToKeywordMap = addressMap;
@@ -276,129 +280,53 @@ QString RifOpmCommonEclipseSummary::enhancedSummaryFilename( const QString& head
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifOpmCommonSummaryTools::createAddressFromSummaryNode( const Opm::EclIO::SummaryNode& summaryNode,
const Opm::EclIO::ESmry* summaryFile )
std::tuple<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress, size_t>, std::map<RifEclipseSummaryAddress, std::string>>
RifOpmCommonSummaryTools::buildAddressesSmspecAndKeywordMap( const Opm::EclIO::ESmry* summaryFile )
{
int i = -1;
int j = -1;
int k = -1;
switch ( summaryNode.category )
{
case Opm::EclIO::SummaryNode::Category::Aquifer:
return RifEclipseSummaryAddress::aquiferAddress( summaryNode.keyword, summaryNode.number );
break;
case Opm::EclIO::SummaryNode::Category::Well:
return RifEclipseSummaryAddress::wellAddress( summaryNode.keyword, summaryNode.wgname );
break;
case Opm::EclIO::SummaryNode::Category::Group:
return RifEclipseSummaryAddress::groupAddress( summaryNode.keyword, summaryNode.wgname );
break;
case Opm::EclIO::SummaryNode::Category::Field:
return RifEclipseSummaryAddress::fieldAddress( summaryNode.keyword );
break;
case Opm::EclIO::SummaryNode::Category::Region:
{
if ( summaryNode.isRegionToRegion() )
{
auto [r1, r2] = summaryNode.regionToRegionNumbers();
return RifEclipseSummaryAddress::regionToRegionAddress( summaryNode.keyword, r1, r2 );
}
return RifEclipseSummaryAddress::regionAddress( summaryNode.keyword, summaryNode.number );
}
break;
case Opm::EclIO::SummaryNode::Category::Block:
summaryFile->ijk_from_global_index( summaryNode.number, i, j, k );
return RifEclipseSummaryAddress::blockAddress( summaryNode.keyword, i, j, k );
break;
case Opm::EclIO::SummaryNode::Category::Connection:
summaryFile->ijk_from_global_index( summaryNode.number, i, j, k );
return RifEclipseSummaryAddress::wellCompletionAddress( summaryNode.keyword, summaryNode.wgname, i, j, k );
break;
case Opm::EclIO::SummaryNode::Category::Segment:
return RifEclipseSummaryAddress::wellSegmentAddress( summaryNode.keyword, summaryNode.wgname, summaryNode.number );
break;
case Opm::EclIO::SummaryNode::Category::Miscellaneous:
return RifEclipseSummaryAddress::miscAddress( summaryNode.keyword );
break;
default:
break;
case Opm::EclIO::SummaryNode::Category::Node:
// The vector "GPR" is defined as Node
// The behavior in libecl is to use the category Group
// https://github.com/OPM/ResInsight/issues/7838
return RifEclipseSummaryAddress::groupAddress( summaryNode.keyword, summaryNode.wgname );
break;
case Opm::EclIO::SummaryNode::Category::Network:
return RifEclipseSummaryAddress::networkAddress( summaryNode.keyword );
break;
case Opm::EclIO::SummaryNode::Category::Well_Lgr:
return RifEclipseSummaryAddress::wellLgrAddress( summaryNode.keyword, summaryNode.lgrname, summaryNode.wgname );
break;
case Opm::EclIO::SummaryNode::Category::Block_Lgr:
return RifEclipseSummaryAddress::blockLgrAddress( summaryNode.keyword,
summaryNode.lgrname,
summaryNode.lgri,
summaryNode.lgrj,
summaryNode.lgrk );
break;
case Opm::EclIO::SummaryNode::Category::Connection_Lgr:
return RifEclipseSummaryAddress::wellCompletionLgrAddress( summaryNode.keyword,
summaryNode.lgrname,
summaryNode.wgname,
summaryNode.lgri,
summaryNode.lgrj,
summaryNode.lgrk );
break;
}
return RifEclipseSummaryAddress();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress, size_t>>
RifOpmCommonSummaryTools::buildMetaData( const Opm::EclIO::ESmry* summaryFile )
{
std::set<RifEclipseSummaryAddress> addresses;
std::map<RifEclipseSummaryAddress, size_t> addressToNodeIndexMap;
std::set<RifEclipseSummaryAddress> addresses;
std::map<RifEclipseSummaryAddress, size_t> addressToSmspecIndexMap;
std::map<RifEclipseSummaryAddress, std::string> addressToKeywordMap;
if ( summaryFile )
{
auto nodes = summaryFile->summaryNodeList();
for ( size_t i = 0; i < nodes.size(); i++ )
auto keywords = summaryFile->keywordList();
for ( const auto& keyword : keywords )
{
auto summaryNode = nodes[i];
auto eclAdr = createAddressFromSummaryNode( summaryNode, summaryFile );
auto eclAdr = RifEclipseSummaryAddress::fromEclipseTextAddress( keyword );
if ( !eclAdr.isValid() )
{
// If a category is not found, use the MISC category
eclAdr = RifEclipseSummaryAddress::miscAddress( keyword );
}
if ( eclAdr.isValid() )
{
addresses.insert( eclAdr );
addressToNodeIndexMap[eclAdr] = i;
size_t smspecIndex = summaryFile->getSmspecIndexForKeyword( keyword );
addressToSmspecIndexMap[eclAdr] = smspecIndex;
addressToKeywordMap[eclAdr] = keyword;
}
}
}
return { addresses, addressToNodeIndexMap };
return { addresses, addressToSmspecIndexMap, addressToKeywordMap };
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress, std::string>>
RifOpmCommonSummaryTools::buildMetaDataKeyword( const std::vector<std::string>& keywords )
RifOpmCommonSummaryTools::buildAddressesAndKeywordMap( const std::vector<std::string>& keywords )
{
std::set<RifEclipseSummaryAddress> addresses;
std::map<RifEclipseSummaryAddress, std::string> addressToNodeIndexMap;
std::map<RifEclipseSummaryAddress, std::string> addressToKeywordMap;
std::vector<std::string> invalidKeywords;
#pragma omp parallel
{
std::set<RifEclipseSummaryAddress> threadAddresses;
std::map<RifEclipseSummaryAddress, std::string> threadAddressToNodeIndexMap;
std::map<RifEclipseSummaryAddress, std::string> threadAddressToKeywordMap;
std::vector<std::string> threadInvalidKeywords;
#pragma omp for
@@ -418,14 +346,14 @@ std::pair<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress,
if ( eclAdr.isValid() )
{
threadAddresses.insert( eclAdr );
threadAddressToNodeIndexMap[eclAdr] = keyword;
threadAddressToKeywordMap[eclAdr] = keyword;
}
}
#pragma omp critical
{
addresses.insert( threadAddresses.begin(), threadAddresses.end() );
addressToNodeIndexMap.insert( threadAddressToNodeIndexMap.begin(), threadAddressToNodeIndexMap.end() );
addressToKeywordMap.insert( threadAddressToKeywordMap.begin(), threadAddressToKeywordMap.end() );
invalidKeywords.insert( invalidKeywords.end(), threadInvalidKeywords.begin(), threadInvalidKeywords.end() );
}
@@ -439,5 +367,5 @@ std::pair<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress,
*/
}
return { addresses, addressToNodeIndexMap };
return { addresses, addressToKeywordMap };
}

13
ApplicationLibCode/FileInterface/RifOpmCommonSummary.h
View File

@@ -30,6 +30,7 @@
#include <memory>
#include <set>
#include <string>
#include <tuple>
#include <vector>
namespace Opm
@@ -38,7 +39,6 @@ namespace EclIO
{
class ESmry;
class ExtESmry;
struct SummaryNode;
} // namespace EclIO
} // namespace Opm
@@ -47,14 +47,13 @@ class RiaThreadSafeLogger;
class RifOpmCommonSummaryTools
{
public:
static RifEclipseSummaryAddress createAddressFromSummaryNode( const Opm::EclIO::SummaryNode& summaryNode,
const Opm::EclIO::ESmry* summaryFile );
static std::pair<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress, size_t>>
buildMetaData( const Opm::EclIO::ESmry* summaryFile );
static std::tuple<std::set<RifEclipseSummaryAddress>,
std::map<RifEclipseSummaryAddress, size_t>,
std::map<RifEclipseSummaryAddress, std::string>>
buildAddressesSmspecAndKeywordMap( const Opm::EclIO::ESmry* summaryFile );
static std::pair<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress, std::string>>
buildMetaDataKeyword( const std::vector<std::string>& keywords );
buildAddressesAndKeywordMap( const std::vector<std::string>& keywords );
};
//==================================================================================================

40
ApplicationLibCode/FileInterface/RifOpmHdf5Summary.cpp
View File

@@ -24,6 +24,10 @@
#include "RifHdf5SummaryReader.h"
#include "RifOpmCommonSummary.h"
#ifdef _MSC_VER
// Disable warning from external library to make sure treat warnings as error works
#pragma warning( disable : 4267 )
#endif
#include "opm/io/eclipse/ESmry.hpp"
#include <QFileInfo>
@@ -95,18 +99,18 @@ bool RifOpmHdf5Summary::values( const RifEclipseSummaryAddress& resultAddress, s
{
if ( m_eSmry && m_hdf5Reader )
{
auto it = m_adrToSummaryNodeIndex.find( resultAddress );
if ( it != m_adrToSummaryNodeIndex.end() )
auto it = m_adrToSmspecIndices.find( resultAddress );
if ( it != m_adrToSmspecIndices.end() )
{
size_t index = it->second;
auto node = m_eSmry->summaryNodeList()[index];
int smspecIndex = static_cast<int>( node.smspecKeywordIndex );
const auto& vectorName = resultAddress.vectorName();
size_t smspecIndex = it->second;
*values = m_hdf5Reader->values( vectorName, smspecIndex );
if ( smspecIndex != std::numeric_limits<size_t>::max() )
{
*values = m_hdf5Reader->values( vectorName, static_cast<int>( smspecIndex ) );
return true;
return true;
}
}
}
@@ -120,13 +124,12 @@ std::string RifOpmHdf5Summary::unitName( const RifEclipseSummaryAddress& resultA
{
if ( m_eSmry )
{
auto it = m_adrToSummaryNodeIndex.find( resultAddress );
if ( it != m_adrToSummaryNodeIndex.end() )
auto it = m_summaryAddressToKeywordMap.find( resultAddress );
if ( it != m_summaryAddressToKeywordMap.end() )
{
auto index = it->second;
auto node = m_eSmry->summaryNodeList()[index];
auto keyword = it->second;
auto stringFromFileReader = m_eSmry->get_unit( keyword );
auto stringFromFileReader = m_eSmry->get_unit( node );
return RiaStdStringTools::trimString( stringFromFileReader );
}
}
@@ -167,10 +170,13 @@ void RifOpmHdf5Summary::buildMetaData()
}
}
auto [addresses, addressMap] = RifOpmCommonSummaryTools::buildMetaData( m_eSmry.get() );
m_allResultAddresses = addresses;
m_adrToSummaryNodeIndex = addressMap;
{
auto [addresses, smspecIndices, addressToKeywordMap] =
RifOpmCommonSummaryTools::buildAddressesSmspecAndKeywordMap( m_eSmry.get() );
m_allResultAddresses = addresses;
m_adrToSmspecIndices = smspecIndices;
m_summaryAddressToKeywordMap = addressToKeywordMap;
}
}
}

7
ApplicationLibCode/FileInterface/RifOpmHdf5Summary.h
View File

@@ -66,9 +66,10 @@ private:
bool openESmryFile( const QString& headerFileName, bool includeRestartFiles, RiaThreadSafeLogger* threadSafeLogger );
private:
std::unique_ptr<Opm::EclIO::ESmry> m_eSmry;
std::map<RifEclipseSummaryAddress, size_t> m_adrToSummaryNodeIndex;
std::vector<time_t> m_timeSteps;
std::unique_ptr<Opm::EclIO::ESmry> m_eSmry;
std::map<RifEclipseSummaryAddress, std::string> m_summaryAddressToKeywordMap;
std::map<RifEclipseSummaryAddress, size_t> m_adrToSmspecIndices;
std::vector<time_t> m_timeSteps;
std::unique_ptr<RifHdf5SummaryReader> m_hdf5Reader;
};

9
ApplicationLibCode/FileInterface/RifProjectSummaryDataWriter.cpp
View File

@@ -20,12 +20,17 @@
#include "RifSummaryReaderInterface.h"
#include "cafAssert.h"
#ifdef _MSC_VER
// Disable warning from external library to make sure treat warnings as error works
#pragma warning( disable : 4267 )
#endif
#include "opm/common/utility/TimeService.hpp"
#include "opm/io/eclipse/EclOutput.hpp"
#include "opm/io/eclipse/ExtESmry.hpp"
#include "cafAssert.h"
#include <numeric>
//--------------------------------------------------------------------------------------------------

24
ApplicationLibCode/ProjectDataModel/RimVfpPlot.cpp
View File

@@ -883,11 +883,11 @@ RimVfpDefines::FlowingPhaseType RimVfpPlot::getFlowingPhaseType( const Opm::VFPP
{
switch ( table.getFloType() )
{
case Opm::VFPProdTable::FLO_OIL:
case Opm::VFPProdTable::FLO_TYPE::FLO_OIL:
return RimVfpDefines::FlowingPhaseType::OIL;
case Opm::VFPProdTable::FLO_GAS:
case Opm::VFPProdTable::FLO_TYPE::FLO_GAS:
return RimVfpDefines::FlowingPhaseType::GAS;
case Opm::VFPProdTable::FLO_LIQ:
case Opm::VFPProdTable::FLO_TYPE::FLO_LIQ:
return RimVfpDefines::FlowingPhaseType::LIQUID;
default:
return RimVfpDefines::FlowingPhaseType::INVALID;
@@ -901,11 +901,11 @@ RimVfpDefines::FlowingPhaseType RimVfpPlot::getFlowingPhaseType( const Opm::VFPI
{
switch ( table.getFloType() )
{
case Opm::VFPInjTable::FLO_OIL:
case Opm::VFPInjTable::FLO_TYPE::FLO_OIL:
return RimVfpDefines::FlowingPhaseType::OIL;
case Opm::VFPInjTable::FLO_GAS:
case Opm::VFPInjTable::FLO_TYPE::FLO_GAS:
return RimVfpDefines::FlowingPhaseType::GAS;
case Opm::VFPInjTable::FLO_WAT:
case Opm::VFPInjTable::FLO_TYPE::FLO_WAT:
return RimVfpDefines::FlowingPhaseType::WATER;
default:
return RimVfpDefines::FlowingPhaseType::INVALID;
@@ -919,11 +919,11 @@ RimVfpDefines::FlowingGasFractionType RimVfpPlot::getFlowingGasFractionType( con
{
switch ( table.getGFRType() )
{
case Opm::VFPProdTable::GFR_GOR:
case Opm::VFPProdTable::GFR_TYPE::GFR_GOR:
return RimVfpDefines::FlowingGasFractionType::GOR;
case Opm::VFPProdTable::GFR_GLR:
case Opm::VFPProdTable::GFR_TYPE::GFR_GLR:
return RimVfpDefines::FlowingGasFractionType::GLR;
case Opm::VFPProdTable::GFR_OGR:
case Opm::VFPProdTable::GFR_TYPE::GFR_OGR:
return RimVfpDefines::FlowingGasFractionType::OGR;
default:
return RimVfpDefines::FlowingGasFractionType::INVALID;
@@ -937,11 +937,11 @@ RimVfpDefines::FlowingWaterFractionType RimVfpPlot::getFlowingWaterFractionType(
{
switch ( table.getWFRType() )
{
case Opm::VFPProdTable::WFR_WOR:
case Opm::VFPProdTable::WFR_TYPE::WFR_WOR:
return RimVfpDefines::FlowingWaterFractionType::WOR;
case Opm::VFPProdTable::WFR_WCT:
case Opm::VFPProdTable::WFR_TYPE::WFR_WCT:
return RimVfpDefines::FlowingWaterFractionType::WCT;
case Opm::VFPProdTable::WFR_WGR:
case Opm::VFPProdTable::WFR_TYPE::WFR_WGR:
return RimVfpDefines::FlowingWaterFractionType::WGR;
default:
return RimVfpDefines::FlowingWaterFractionType::INVALID;

4
ApplicationLibCode/ProjectDataModel/RimVfpPlot.h
View File

@@ -26,8 +26,8 @@
#include <QPointer>
#include "opm/parser/eclipse/EclipseState/Schedule/VFPInjTable.hpp"
#include "opm/parser/eclipse/EclipseState/Schedule/VFPProdTable.hpp"
#include "opm/input/eclipse/Schedule/VFPInjTable.hpp"
#include "opm/input/eclipse/Schedule/VFPProdTable.hpp"
class RiuPlotWidget;
class VfpPlotData;

26
ApplicationLibCode/ProjectDataModel/RimVfpTableExtractor.cpp
View File

@@ -21,8 +21,9 @@
#include "cafPdmUiItem.h"
#include "cafUtils.h"
#include "opm/parser/eclipse/Parser/Parser.hpp"
#include "opm/parser/eclipse/Parser/ParserKeywords/V.hpp"
#include "opm/input/eclipse/Deck/Deck.hpp"
#include "opm/input/eclipse/Parser/Parser.hpp"
#include "opm/input/eclipse/Parser/ParserKeywords/V.hpp"
//--------------------------------------------------------------------------------------------------
///
@@ -33,8 +34,14 @@ std::vector<Opm::VFPInjTable> RimVfpTableExtractor::extractVfpInjectionTables( c
try
{
Opm::Parser parser;
auto deck = parser.parseFile( filename );
Opm::Parser parser( false );
const ::Opm::ParserKeywords::VFPINJ kw1;
const ::Opm::ParserKeywords::VFPIDIMS kw2;
parser.addParserKeyword( kw1 );
parser.addParserKeyword( kw2 );
auto deck = parser.parseFile( filename );
std::string myKeyword = "VFPINJ";
auto keywordList = deck.getKeywordList( myKeyword );
@@ -75,8 +82,12 @@ std::vector<Opm::VFPProdTable> RimVfpTableExtractor::extractVfpProductionTables(
try
{
Opm::Parser parser;
auto deck = parser.parseFile( filename );
Opm::Parser parser( false );
const ::Opm::ParserKeywords::VFPPROD kw1;
parser.addParserKeyword( kw1 );
auto deck = parser.parseFile( filename );
std::string myKeyword = "VFPPROD";
auto keywordList = deck.getKeywordList( myKeyword );
@@ -97,7 +108,8 @@ std::vector<Opm::VFPProdTable> RimVfpTableExtractor::extractVfpProductionTables(
}
}
Opm::VFPProdTable table( *kw, unitSystem );
bool gaslift_opt_active = false;
Opm::VFPProdTable table( *kw, gaslift_opt_active, unitSystem );
tables.push_back( table );
}
}

4
ApplicationLibCode/ProjectDataModel/RimVfpTableExtractor.h
View File

@@ -21,8 +21,8 @@
#include <string>
#include <vector>
#include "opm/parser/eclipse/EclipseState/Schedule/VFPInjTable.hpp"
#include "opm/parser/eclipse/EclipseState/Schedule/VFPProdTable.hpp"
#include "opm/input/eclipse/Schedule/VFPInjTable.hpp"
#include "opm/input/eclipse/Schedule/VFPProdTable.hpp"
//--------------------------------------------------------------------------------------------------
///

7
ApplicationLibCode/UnitTests/HDF5FileReader-Test.cpp
View File

@@ -10,6 +10,10 @@
#include <iostream>
#ifdef _MSC_VER
// Disable warning from external library to make sure treat warnings as error works
#pragma warning( disable : 4267 )
#endif
#include "opm/io/eclipse/ESmry.hpp"
static const QString H5_TEST_DATA_DIRECTORY = QString( "%1/h5-file/" ).arg( TEST_DATA_DIR );
@@ -122,8 +126,7 @@ TEST( DISABLED_HDFTests, ReadOpmSummaryDataListContent )
for ( size_t i = 0; i < nodes.size(); i++ )
{
Opm::EclIO::SummaryNode n = nodes[i];
std::cout << n.keyword << " number: " << n.number << " msjNumber: " << n.smspecKeywordIndex << " "
<< n.unique_key() << "\n";
std::cout << n.keyword << " number: " << n.number << " msjNumber: " << n.unique_key() << "\n";
}
}

5
ApplicationLibCode/UnitTests/HDF5FileWriter-Test.cpp
View File

@@ -13,6 +13,11 @@
#include <iostream>
#include "RifHdf5SummaryExporter.h"
#ifdef _MSC_VER
// Disable warning from external library to make sure treat warnings as error works
#pragma warning( disable : 4267 )
#endif
#include "opm/io/eclipse/ESmry.hpp"
#include <numeric>

4
ApplicationLibCode/UnitTests/opm-summary-Test.cpp
View File

@@ -6,6 +6,10 @@
#include "RifOpmCommonSummary.h"
#include "RifReaderOpmRft.h"
#ifdef _MSC_VER
// Disable warning from external library to make sure treat warnings as error works
#pragma warning( disable : 4267 )
#endif
#include "opm/io/eclipse/ERft.hpp"
#include "opm/io/eclipse/ESmry.hpp"
#include "opm/io/eclipse/ExtESmry.hpp"

4
CMakeLists.txt
View File

@@ -513,8 +513,8 @@ if(RESINSIGHT_ENABLE_UNITY_BUILD)
set_property(TARGET qwt PROPERTY UNITY_BUILD true)
message("Cmake Unity build is enabled on : custom-opm-flowdiagnostics")
set_property(TARGET custom-opm-flowdiagnostics PROPERTY UNITY_BUILD true)
message("Cmake Unity build is enabled on : custom-opm-common")
set_property(TARGET custom-opm-common PROPERTY UNITY_BUILD true)
# message("Cmake Unity build is enabled on : custom-opm-common")
# set_property(TARGET custom-opm-common PROPERTY UNITY_BUILD true)
message("Cmake Unity build is enabled on : qtadvanceddocking")
set_property(TARGET qtadvanceddocking PROPERTY UNITY_BUILD true)
endif()

11
ThirdParty/custom-opm-common/CMakeLists.txt vendored
View File

@@ -42,9 +42,7 @@ set(ENABLE_ECL_INPUT true)
#set(ENABLE_ECL_OUTPUT true)
# TODO: opm-parser should hold a cmake file with source code files only
#include(opm-parser/CMakeLists_files.cmake)
include ( CMakeLists_files.cmake )
include(opm-common/CMakeLists_files.cmake)
set(opm_parser_source_files_short_path
${MAIN_SOURCE_FILES}
@@ -95,6 +93,13 @@ add_library(${PROJECT_NAME}
# Required for use of RstHeader::restart_info
opm-common/src/opm/io/eclipse/rst/header.cpp
# 2022.06 additional includes
opm-common/src/opm/io/eclipse/rst/aquifer.cpp
opm-common/src/opm/io/eclipse/ERst.cpp
opm-common/src/opm/io/eclipse/RestartFileView.cpp
opm-common/cross-platform/windows/Substitutes.cpp
)
if(RESINSIGHT_ENABLE_UNITY_BUILD)

26
ThirdParty/custom-opm-common/custom-opm-parser-tests/opm-parser-BasicTest.cpp vendored
View File

@@ -2,9 +2,14 @@
#include <string>
#include "gtest/gtest.h"
#include "opm/parser/eclipse/Parser/Parser.hpp"
#include "opm/parser/eclipse/EclipseState/Schedule/VFPInjTable.hpp"
#include "opm/parser/eclipse/EclipseState/Schedule/VFPProdTable.hpp"
#include "opm/input/eclipse/Parser/ParseContext.hpp"
#include "opm/input/eclipse/Parser/ParseContext.hpp"
#include "opm/input/eclipse/Schedule/VFPInjTable.hpp"
#include "opm/input/eclipse/Schedule/VFPProdTable.hpp"
#include "opm/input/eclipse/Parser/Parser.hpp"
#include "opm/input/eclipse/Deck/Deck.hpp"
#include <opm/input/eclipse/Parser/ParserKeywords/V.hpp>
#include "OpmTestDataDirectory.h"
@@ -18,7 +23,10 @@ TEST(OpmParserTest, ReadFromFile)
ParseContext parseContext;
{
Parser parser;
Parser parser(false);
const ::Opm::ParserKeywords::VFPPROD kw1;
parser.addParserKeyword(kw1);
std::stringstream ss;
ss << TEST_DATA_DIR << "/B1BH.Ecl";
@@ -36,12 +44,18 @@ TEST(OpmParserTest, ReadFromFile)
{
auto name = kw->name();
VFPProdTable table(*kw, unitSystem);
bool gaslift_opt_active = false;
VFPProdTable table(*kw, gaslift_opt_active, unitSystem);
std::cout << table.getDatumDepth() << std::endl;
}
}
{
Parser parser;
Parser parser(false);
const ::Opm::ParserKeywords::VFPINJ kw1;
const ::Opm::ParserKeywords::VFPIDIMS kw2;
parser.addParserKeyword(kw1);
parser.addParserKeyword(kw2);
std::stringstream ss;
ss << TEST_DATA_DIR << "/C1H.Ecl";

2271
ThirdParty/custom-opm-common/generated-opm-common/ParserInit.cpp vendored
View File

File diff suppressed because it is too large Load Diff

301
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/A.cpp vendored
View File

@@ -1,18 +1,17 @@
#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/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/parser/eclipse/Parser/ParserKeywords/A.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/A.hpp>
namespace Opm {
namespace ParserKeywords {
ACTDIMS::ACTDIMS( ) : ParserKeyword("ACTDIMS")
{
setFixedSize( (size_t) 1);
ACTDIMS::ACTDIMS() : ParserKeyword("ACTDIMS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("ACTDIMS");
@@ -52,9 +51,7 @@ const std::string ACTDIMS::MAX_ACTION_COND::itemName = "MAX_ACTION_COND";
const int ACTDIMS::MAX_ACTION_COND::defaultValue = 3;
ACTION::ACTION( ) : ParserKeyword("ACTION")
{
setFixedSize( (size_t) 1);
ACTION::ACTION() : ParserKeyword("ACTION", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("ACTION");
@@ -86,9 +83,7 @@ const std::string ACTION::OPERATOR::itemName = "OPERATOR";
const std::string ACTION::TRIGGER_VALUE::itemName = "TRIGGER_VALUE";
ACTIONG::ACTIONG( ) : ParserKeyword("ACTIONG")
{
setFixedSize( (size_t) 1);
ACTIONG::ACTIONG() : ParserKeyword("ACTIONG", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("ACTIONG");
@@ -136,12 +131,10 @@ const std::string ACTIONG::TRIGGER_VALUE::itemName = "TRIGGER_VALUE";
const std::string ACTIONG::REPETITIONS::itemName = "REPETITIONS";
const int ACTIONG::REPETITIONS::defaultValue = 1;
const std::string ACTIONG::INCREMENT::itemName = "INCREMENT";
const double ACTIONG::INCREMENT::defaultValue = 0.000000;
const double ACTIONG::INCREMENT::defaultValue = 0;
ACTIONR::ACTIONR( ) : ParserKeyword("ACTIONR")
{
setFixedSize( (size_t) 1);
ACTIONR::ACTIONR() : ParserKeyword("ACTIONR", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("ACTIONR");
@@ -194,12 +187,10 @@ const std::string ACTIONR::TRIGGER_VALUE::itemName = "TRIGGER_VALUE";
const std::string ACTIONR::REPETITIONS::itemName = "REPETITIONS";
const int ACTIONR::REPETITIONS::defaultValue = 1;
const std::string ACTIONR::INCREMENT::itemName = "INCREMENT";
const double ACTIONR::INCREMENT::defaultValue = 0.000000;
const double ACTIONR::INCREMENT::defaultValue = 0;
ACTIONS::ACTIONS( ) : ParserKeyword("ACTIONS")
{
setFixedSize( (size_t) 1);
ACTIONS::ACTIONS() : ParserKeyword("ACTIONS", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("ACTIONS");
@@ -252,12 +243,10 @@ const std::string ACTIONS::TRIGGER_VALUE::itemName = "TRIGGER_VALUE";
const std::string ACTIONS::REPETITIONS::itemName = "REPETITIONS";
const int ACTIONS::REPETITIONS::defaultValue = 1;
const std::string ACTIONS::INCREMENT::itemName = "INCREMENT";
const double ACTIONS::INCREMENT::defaultValue = 0.000000;
const double ACTIONS::INCREMENT::defaultValue = 0;
ACTIONW::ACTIONW( ) : ParserKeyword("ACTIONW")
{
setFixedSize( (size_t) 1);
ACTIONW::ACTIONW() : ParserKeyword("ACTIONW", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("ACTIONW");
@@ -305,12 +294,10 @@ const std::string ACTIONW::TRIGGER_VALUE::itemName = "TRIGGER_VALUE";
const std::string ACTIONW::REPETITIONS::itemName = "REPETITIONS";
const int ACTIONW::REPETITIONS::defaultValue = 1;
const std::string ACTIONW::INCREMENT::itemName = "INCREMENT";
const double ACTIONW::INCREMENT::defaultValue = 0.000000;
const double ACTIONW::INCREMENT::defaultValue = 0;
ACTIONX::ACTIONX( ) : ParserKeyword("ACTIONX")
{
setSizeType(SLASH_TERMINATED);
ACTIONX::ACTIONX() : ParserKeyword("ACTIONX", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("ACTIONX");
@@ -348,13 +335,11 @@ const std::string ACTIONX::NAME::itemName = "NAME";
const std::string ACTIONX::NUM::itemName = "NUM";
const int ACTIONX::NUM::defaultValue = 1;
const std::string ACTIONX::MIN_WAIT::itemName = "MIN_WAIT";
const double ACTIONX::MIN_WAIT::defaultValue = 0.000000;
const double ACTIONX::MIN_WAIT::defaultValue = 0;
const std::string ACTIONX::CONDITION::itemName = "CONDITION";
ACTNUM::ACTNUM( ) : ParserKeyword("ACTNUM")
{
setFixedSize( (size_t) 1);
ACTNUM::ACTNUM() : ParserKeyword("ACTNUM", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("ACTNUM");
@@ -372,9 +357,7 @@ const std::string ACTNUM::keywordName = "ACTNUM";
const std::string ACTNUM::data::itemName = "data";
ACTPARAM::ACTPARAM( ) : ParserKeyword("ACTPARAM")
{
setFixedSize( (size_t) 1);
ACTPARAM::ACTPARAM() : ParserKeyword("ACTPARAM", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("ACTPARAM");
@@ -394,11 +377,9 @@ const std::string ACTPARAM::data::itemName = "data";
const double ACTPARAM::data::defaultValue = 0.000100;
ADD::ADD( ) : ParserKeyword("ADD")
{
setSizeType(SLASH_TERMINATED);
addValidSectionName("EDIT");
ADD::ADD() : ParserKeyword("ADD", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
addValidSectionName("EDIT");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("SOLUTION");
@@ -452,11 +433,9 @@ const std::string ADD::K1::itemName = "K1";
const std::string ADD::K2::itemName = "K2";
ADDREG::ADDREG( ) : ParserKeyword("ADDREG")
{
setSizeType(SLASH_TERMINATED);
addValidSectionName("EDIT");
ADDREG::ADDREG() : ParserKeyword("ADDREG", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
addValidSectionName("EDIT");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("SOLUTION");
@@ -492,15 +471,13 @@ ADDREG::ADDREG( ) : ParserKeyword("ADDREG")
const std::string ADDREG::keywordName = "ADDREG";
const std::string ADDREG::ARRAY::itemName = "ARRAY";
const std::string ADDREG::SHIFT::itemName = "SHIFT";
const double ADDREG::SHIFT::defaultValue = 0.000000;
const double ADDREG::SHIFT::defaultValue = 0;
const std::string ADDREG::REGION_NUMBER::itemName = "REGION_NUMBER";
const std::string ADDREG::REGION_NAME::itemName = "REGION_NAME";
const std::string ADDREG::REGION_NAME::defaultValue = "M";
ADDZCORN::ADDZCORN( ) : ParserKeyword("ADDZCORN")
{
setSizeType(SLASH_TERMINATED);
ADDZCORN::ADDZCORN() : ParserKeyword("ADDZCORN", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("ADDZCORN");
@@ -573,10 +550,7 @@ const std::string ADDZCORN::JY2A::itemName = "JY2A";
const std::string ADDZCORN::ACTION::itemName = "ACTION";
ADSALNOD::ADSALNOD( ) : ParserKeyword("ADSALNOD")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
ADSALNOD::ADSALNOD() : ParserKeyword("ADSALNOD", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ADSALNOD");
@@ -595,10 +569,7 @@ const std::string ADSALNOD::keywordName = "ADSALNOD";
const std::string ADSALNOD::DATA::itemName = "DATA";
ADSORP::ADSORP( ) : ParserKeyword("ADSORP")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",1);
ADSORP::ADSORP() : ParserKeyword("ADSORP", KeywordSize("TABDIMS", "NTSFUN", false, 1)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ADSORP");
@@ -662,9 +633,7 @@ const double ADSORP::N::defaultValue = 0.500000;
const std::string ADSORP::K_REF::itemName = "K_REF";
AITS::AITS( ) : ParserKeyword("AITS")
{
setFixedSize( (size_t) 0);
AITS::AITS() : ParserKeyword("AITS", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
clearDeckNames();
@@ -673,9 +642,7 @@ AITS::AITS( ) : ParserKeyword("AITS")
const std::string AITS::keywordName = "AITS";
AITSOFF::AITSOFF( ) : ParserKeyword("AITSOFF")
{
setFixedSize( (size_t) 0);
AITSOFF::AITSOFF() : ParserKeyword("AITSOFF", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
clearDeckNames();
@@ -684,10 +651,7 @@ AITSOFF::AITSOFF( ) : ParserKeyword("AITSOFF")
const std::string AITSOFF::keywordName = "AITSOFF";
ALKADS::ALKADS( ) : ParserKeyword("ALKADS")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
ALKADS::ALKADS() : ParserKeyword("ALKADS", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ALKADS");
@@ -707,9 +671,7 @@ const std::string ALKADS::keywordName = "ALKADS";
const std::string ALKADS::DATA::itemName = "DATA";
ALKALINE::ALKALINE( ) : ParserKeyword("ALKALINE")
{
setFixedSize( (size_t) 0);
ALKALINE::ALKALINE() : ParserKeyword("ALKALINE", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("ALKALINE");
@@ -717,10 +679,7 @@ ALKALINE::ALKALINE( ) : ParserKeyword("ALKALINE")
const std::string ALKALINE::keywordName = "ALKALINE";
ALKROCK::ALKROCK( ) : ParserKeyword("ALKROCK")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
ALKROCK::ALKROCK() : ParserKeyword("ALKROCK", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ALKROCK");
@@ -737,9 +696,7 @@ const std::string ALKROCK::keywordName = "ALKROCK";
const std::string ALKROCK::ROCK_ADS_INDEX::itemName = "ROCK_ADS_INDEX";
ALL::ALL( ) : ParserKeyword("ALL")
{
setFixedSize( (size_t) 0);
ALL::ALL() : ParserKeyword("ALL", KeywordSize(0, false)) {
addValidSectionName("SUMMARY");
clearDeckNames();
addDeckName("ALL");
@@ -747,10 +704,7 @@ ALL::ALL( ) : ParserKeyword("ALL")
const std::string ALL::keywordName = "ALL";
ALPOLADS::ALPOLADS( ) : ParserKeyword("ALPOLADS")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
ALPOLADS::ALPOLADS() : ParserKeyword("ALPOLADS", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ALPOLADS");
@@ -770,10 +724,7 @@ const std::string ALPOLADS::keywordName = "ALPOLADS";
const std::string ALPOLADS::DATA::itemName = "DATA";
ALSURFAD::ALSURFAD( ) : ParserKeyword("ALSURFAD")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
ALSURFAD::ALSURFAD() : ParserKeyword("ALSURFAD", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ALSURFAD");
@@ -793,10 +744,7 @@ const std::string ALSURFAD::keywordName = "ALSURFAD";
const std::string ALSURFAD::DATA::itemName = "DATA";
ALSURFST::ALSURFST( ) : ParserKeyword("ALSURFST")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTPVT",0);
ALSURFST::ALSURFST() : ParserKeyword("ALSURFST", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ALSURFST");
@@ -816,9 +764,7 @@ const std::string ALSURFST::keywordName = "ALSURFST";
const std::string ALSURFST::DATA::itemName = "DATA";
AMALGAM::AMALGAM( ) : ParserKeyword("AMALGAM")
{
setSizeType(SLASH_TERMINATED);
AMALGAM::AMALGAM() : ParserKeyword("AMALGAM", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("AMALGAM");
@@ -836,9 +782,7 @@ const std::string AMALGAM::keywordName = "AMALGAM";
const std::string AMALGAM::LGR_GROUPS::itemName = "LGR_GROUPS";
API::API( ) : ParserKeyword("API")
{
setFixedSize( (size_t) 0);
API::API() : ParserKeyword("API", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("API");
@@ -846,9 +790,7 @@ API::API( ) : ParserKeyword("API")
const std::string API::keywordName = "API";
APIGROUP::APIGROUP( ) : ParserKeyword("APIGROUP")
{
setFixedSize( (size_t) 1);
APIGROUP::APIGROUP() : ParserKeyword("APIGROUP", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("APIGROUP");
@@ -867,9 +809,7 @@ const std::string APIGROUP::MAX_OIL_PVT_GROUP_COUNT::itemName = "MAX_OIL_PVT_GRO
const int APIGROUP::MAX_OIL_PVT_GROUP_COUNT::defaultValue = 1;
APILIM::APILIM( ) : ParserKeyword("APILIM")
{
setFixedSize( (size_t) 1);
APILIM::APILIM() : ParserKeyword("APILIM", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("APILIM");
@@ -912,13 +852,10 @@ const std::string APILIM::NUM_ROWS::itemName = "NUM_ROWS";
const int APILIM::NUM_ROWS::defaultValue = 10;
APIVID::APIVID( ) : ParserKeyword("APIVID")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("EQLDIMS","NTEQUL",0);
APIVD::APIVD() : ParserKeyword("APIVD", KeywordSize("EQLDIMS", "NTEQUL", false, 0)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("APIVID");
addDeckName("APIVD");
{
ParserRecord record;
{
@@ -931,13 +868,11 @@ APIVID::APIVID( ) : ParserKeyword("APIVID")
addRecord( record );
}
}
const std::string APIVID::keywordName = "APIVID";
const std::string APIVID::DATA::itemName = "DATA";
const std::string APIVD::keywordName = "APIVD";
const std::string APIVD::DATA::itemName = "DATA";
AQANCONL::AQANCONL( ) : ParserKeyword("AQANCONL")
{
setSizeType(SLASH_TERMINATED);
AQANCONL::AQANCONL() : ParserKeyword("AQANCONL", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("AQANCONL");
@@ -1013,9 +948,7 @@ const double AQANCONL::AQUIFER_INFLUX_MULT::defaultValue = 1.000000;
const std::string AQANCONL::ALLOW::itemName = "ALLOW";
AQANNC::AQANNC( ) : ParserKeyword("AQANNC")
{
setSizeType(SLASH_TERMINATED);
AQANNC::AQANNC() : ParserKeyword("AQANNC", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("AQANNC");
@@ -1052,12 +985,10 @@ const std::string AQANNC::IX::itemName = "IX";
const std::string AQANNC::IY::itemName = "IY";
const std::string AQANNC::IZ::itemName = "IZ";
const std::string AQANNC::AREA::itemName = "AREA";
const double AQANNC::AREA::defaultValue = 0.000000;
const double AQANNC::AREA::defaultValue = 0;
AQANTRC::AQANTRC( ) : ParserKeyword("AQANTRC")
{
setSizeType(SLASH_TERMINATED);
AQANTRC::AQANTRC() : ParserKeyword("AQANTRC", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("AQANTRC");
@@ -1084,9 +1015,7 @@ const std::string AQANTRC::TRACER::itemName = "TRACER";
const std::string AQANTRC::VALUE::itemName = "VALUE";
AQUALIST::AQUALIST( ) : ParserKeyword("AQUALIST")
{
setSizeType(SLASH_TERMINATED);
AQUALIST::AQUALIST() : ParserKeyword("AQUALIST", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("AQUALIST");
@@ -1109,9 +1038,7 @@ const std::string AQUALIST::AQUIFER_LIST::itemName = "AQUIFER_LIST";
const std::string AQUALIST::LIST::itemName = "LIST";
AQUANCON::AQUANCON( ) : ParserKeyword("AQUANCON")
{
setSizeType(SLASH_TERMINATED);
AQUANCON::AQUANCON() : ParserKeyword("AQUANCON", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
addValidSectionName("SOLUTION");
clearDeckNames();
@@ -1185,11 +1112,9 @@ const std::string AQUANCON::CONNECT_ADJOINING_ACTIVE_CELL::itemName = "CONNECT_A
const std::string AQUANCON::CONNECT_ADJOINING_ACTIVE_CELL::defaultValue = "NO";
AQUCHGAS::AQUCHGAS( ) : ParserKeyword("AQUCHGAS")
{
setSizeType(SLASH_TERMINATED);
addValidSectionName("SCHEDULE");
AQUCHGAS::AQUCHGAS() : ParserKeyword("AQUCHGAS", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("AQUCHGAS");
{
@@ -1236,11 +1161,9 @@ const int AQUCHGAS::TABLE_NUM::defaultValue = 1;
const std::string AQUCHGAS::TEMPERATURE::itemName = "TEMPERATURE";
AQUCHWAT::AQUCHWAT( ) : ParserKeyword("AQUCHWAT")
{
setSizeType(SLASH_TERMINATED);
addValidSectionName("SCHEDULE");
AQUCHWAT::AQUCHWAT() : ParserKeyword("AQUCHWAT", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("AQUCHWAT");
{
@@ -1350,9 +1273,7 @@ const int AQUCHWAT::IMPORT_MAX_MIN_FLOW_RATE::defaultValue = 0;
const std::string AQUCHWAT::TEMPERATURE::itemName = "TEMPERATURE";
AQUCON::AQUCON( ) : ParserKeyword("AQUCON")
{
setSizeType(SLASH_TERMINATED);
AQUCON::AQUCON() : ParserKeyword("AQUCON", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("AQUCON");
@@ -1392,22 +1313,27 @@ AQUCON::AQUCON( ) : ParserKeyword("AQUCON")
}
{
ParserItem item("TRANS_MULT", ParserItem::itype::DOUBLE);
item.setDefault( double(1.000000) );
record.addItem(item);
}
{
ParserItem item("TRANS_OPTION", ParserItem::itype::INT);
item.setDefault( 0 );
record.addItem(item);
}
{
ParserItem item("ALLOW_INTERNAL_CELLS", ParserItem::itype::STRING);
item.setDefault( std::string("NO") );
record.addItem(item);
}
{
ParserItem item("VEFRAC", ParserItem::itype::DOUBLE);
item.setDefault( double(1.000000) );
record.addItem(item);
}
{
ParserItem item("VEFRACP", ParserItem::itype::DOUBLE);
item.setDefault( double(1.000000) );
record.addItem(item);
}
addRecord( record );
@@ -1423,19 +1349,25 @@ const std::string AQUCON::K1::itemName = "K1";
const std::string AQUCON::K2::itemName = "K2";
const std::string AQUCON::CONNECT_FACE::itemName = "CONNECT_FACE";
const std::string AQUCON::TRANS_MULT::itemName = "TRANS_MULT";
const double AQUCON::TRANS_MULT::defaultValue = 1.000000;
const std::string AQUCON::TRANS_OPTION::itemName = "TRANS_OPTION";
const int AQUCON::TRANS_OPTION::defaultValue = 0;
const std::string AQUCON::ALLOW_INTERNAL_CELLS::itemName = "ALLOW_INTERNAL_CELLS";
const std::string AQUCON::ALLOW_INTERNAL_CELLS::defaultValue = "NO";
const std::string AQUCON::VEFRAC::itemName = "VEFRAC";
const double AQUCON::VEFRAC::defaultValue = 1.000000;
const std::string AQUCON::VEFRACP::itemName = "VEFRACP";
const double AQUCON::VEFRACP::defaultValue = 1.000000;
AQUCT::AQUCT( ) : ParserKeyword("AQUCT")
{
setSizeType(SLASH_TERMINATED);
addValidSectionName("GRID");
AQUCT::AQUCT() : ParserKeyword("AQUCT", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("PROPS");
addValidSectionName("SCHEDULE");
addValidSectionName("GRID");
addValidSectionName("SOLUTION");
addValidSectionName("SCHEDULE");
setRequiredKeywords({
"AQUDIMS",
});
clearDeckNames();
addDeckName("AQUCT");
{
@@ -1527,13 +1459,11 @@ const int AQUCT::TABLE_NUM_WATER_PRESS::defaultValue = 1;
const std::string AQUCT::TABLE_NUM_INFLUENCE_FN::itemName = "TABLE_NUM_INFLUENCE_FN";
const int AQUCT::TABLE_NUM_INFLUENCE_FN::defaultValue = 1;
const std::string AQUCT::INI_SALT::itemName = "INI_SALT";
const double AQUCT::INI_SALT::defaultValue = 0.000000;
const double AQUCT::INI_SALT::defaultValue = 0;
const std::string AQUCT::TEMP_AQUIFER::itemName = "TEMP_AQUIFER";
AQUCWFAC::AQUCWFAC( ) : ParserKeyword("AQUCWFAC")
{
setSizeType(SLASH_TERMINATED);
AQUCWFAC::AQUCWFAC() : ParserKeyword("AQUCWFAC", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("AQUCWFAC");
@@ -1556,14 +1486,12 @@ AQUCWFAC::AQUCWFAC( ) : ParserKeyword("AQUCWFAC")
}
const std::string AQUCWFAC::keywordName = "AQUCWFAC";
const std::string AQUCWFAC::ADD_TO_DEPTH::itemName = "ADD_TO_DEPTH";
const double AQUCWFAC::ADD_TO_DEPTH::defaultValue = 0.000000;
const double AQUCWFAC::ADD_TO_DEPTH::defaultValue = 0;
const std::string AQUCWFAC::MULTIPLY::itemName = "MULTIPLY";
const double AQUCWFAC::MULTIPLY::defaultValue = 1.000000;
AQUDIMS::AQUDIMS( ) : ParserKeyword("AQUDIMS")
{
setFixedSize( (size_t) 1);
AQUDIMS::AQUDIMS() : ParserKeyword("AQUDIMS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("AQUDIMS");
@@ -1631,10 +1559,7 @@ const std::string AQUDIMS::MXAAQL::itemName = "MXAAQL";
const int AQUDIMS::MXAAQL::defaultValue = 0;
AQUFET::AQUFET( ) : ParserKeyword("AQUFET")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("AQUDIMS","NANAQU",0);
AQUFET::AQUFET() : ParserKeyword("AQUFET", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("AQUFET");
@@ -1721,14 +1646,12 @@ const std::string AQUFET::LOWER_K::itemName = "LOWER_K";
const std::string AQUFET::UPPER_K::itemName = "UPPER_K";
const std::string AQUFET::FACE_INDX::itemName = "FACE_INDX";
const std::string AQUFET::SC_0::itemName = "SC_0";
const double AQUFET::SC_0::defaultValue = 0.000000;
const double AQUFET::SC_0::defaultValue = 0;
AQUFETP::AQUFETP( ) : ParserKeyword("AQUFETP")
{
setSizeType(SLASH_TERMINATED);
addValidSectionName("SCHEDULE");
AQUFETP::AQUFETP() : ParserKeyword("AQUFETP", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("AQUFETP");
{
@@ -1791,16 +1714,13 @@ const std::string AQUFETP::PI::itemName = "PI";
const std::string AQUFETP::TABLE_NUM_WATER_PRESS::itemName = "TABLE_NUM_WATER_PRESS";
const int AQUFETP::TABLE_NUM_WATER_PRESS::defaultValue = 1;
const std::string AQUFETP::SALINITY::itemName = "SALINITY";
const double AQUFETP::SALINITY::defaultValue = 0.000000;
const double AQUFETP::SALINITY::defaultValue = 0;
const std::string AQUFETP::TEMP::itemName = "TEMP";
AQUFLUX::AQUFLUX( ) : ParserKeyword("AQUFLUX")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("AQUDIMS","NANAQU",0);
addValidSectionName("SCHEDULE");
AQUFLUX::AQUFLUX() : ParserKeyword("AQUFLUX", KeywordSize("AQUDIMS", "NANAQU", false, 0)) {
addValidSectionName("SOLUTION");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("AQUFLUX");
{
@@ -1837,22 +1757,20 @@ const std::string AQUFLUX::keywordName = "AQUFLUX";
const std::string AQUFLUX::AQUIFER_ID::itemName = "AQUIFER_ID";
const std::string AQUFLUX::DAT_DEPTH::itemName = "DAT_DEPTH";
const std::string AQUFLUX::SC_0::itemName = "SC_0";
const double AQUFLUX::SC_0::defaultValue = 0.000000;
const double AQUFLUX::SC_0::defaultValue = 0;
const std::string AQUFLUX::TEMP::itemName = "TEMP";
const std::string AQUFLUX::PRESSURE::itemName = "PRESSURE";
AQUIFER_PROBE_ANALYTIC::AQUIFER_PROBE_ANALYTIC( ) : ParserKeyword("AQUIFER_PROBE_ANALYTIC")
{
setFixedSize( (size_t) 1);
AQUIFER_PROBE_ANALYTIC::AQUIFER_PROBE_ANALYTIC() : ParserKeyword("AQUIFER_PROBE_ANALYTIC", KeywordSize(1, false)) {
addValidSectionName("SUMMARY");
clearDeckNames();
addDeckName("AAQP");
addDeckName("AAQPD");
addDeckName("AAQR");
addDeckName("AAQRG");
addDeckName("AAQT");
addDeckName("AAQTD");
addDeckName("AAQRG");
addDeckName("AAQTG");
setMatchRegex("AA.+");
{
@@ -1869,9 +1787,25 @@ const std::string AQUIFER_PROBE_ANALYTIC::keywordName = "AQUIFER_PROBE_ANALYTIC"
const std::string AQUIFER_PROBE_ANALYTIC::data::itemName = "data";
AQUIFER_PROBE_NUMERIC::AQUIFER_PROBE_NUMERIC( ) : ParserKeyword("AQUIFER_PROBE_NUMERIC")
{
setFixedSize( (size_t) 1);
AQUIFER_PROBE_ANALYTIC_NAMED::AQUIFER_PROBE_ANALYTIC_NAMED() : ParserKeyword("AQUIFER_PROBE_ANALYTIC_NAMED", KeywordSize(1, false)) {
addValidSectionName("SUMMARY");
clearDeckNames();
setMatchRegex("AL.+");
{
ParserRecord record;
{
ParserItem item("data", ParserItem::itype::STRING);
item.setSizeType(ParserItem::item_size::ALL);
record.addDataItem(item);
}
addDataRecord( record );
}
}
const std::string AQUIFER_PROBE_ANALYTIC_NAMED::keywordName = "AQUIFER_PROBE_ANALYTIC_NAMED";
const std::string AQUIFER_PROBE_ANALYTIC_NAMED::data::itemName = "data";
AQUIFER_PROBE_NUMERIC::AQUIFER_PROBE_NUMERIC() : ParserKeyword("AQUIFER_PROBE_NUMERIC", KeywordSize(1, false)) {
addValidSectionName("SUMMARY");
clearDeckNames();
addDeckName("ANQP");
@@ -1892,9 +1826,7 @@ const std::string AQUIFER_PROBE_NUMERIC::keywordName = "AQUIFER_PROBE_NUMERIC";
const std::string AQUIFER_PROBE_NUMERIC::data::itemName = "data";
AQUNNC::AQUNNC( ) : ParserKeyword("AQUNNC")
{
setSizeType(SLASH_TERMINATED);
AQUNNC::AQUNNC() : ParserKeyword("AQUNNC", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("AQUNNC");
@@ -1975,7 +1907,7 @@ const std::string AQUNNC::JX::itemName = "JX";
const std::string AQUNNC::JY::itemName = "JY";
const std::string AQUNNC::JZ::itemName = "JZ";
const std::string AQUNNC::TRAN::itemName = "TRAN";
const double AQUNNC::TRAN::defaultValue = 0.000000;
const double AQUNNC::TRAN::defaultValue = 0;
const std::string AQUNNC::IST1::itemName = "IST1";
const std::string AQUNNC::IST2::itemName = "IST2";
const std::string AQUNNC::IPT1::itemName = "IPT1";
@@ -1985,9 +1917,7 @@ const std::string AQUNNC::ZF2::itemName = "ZF2";
const std::string AQUNNC::DIFF::itemName = "DIFF";
AQUNUM::AQUNUM( ) : ParserKeyword("AQUNUM")
{
setSizeType(SLASH_TERMINATED);
AQUNUM::AQUNUM() : ParserKeyword("AQUNUM", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("AQUNUM");
@@ -2065,10 +1995,7 @@ const std::string AQUNUM::PVT_TABLE_NUM::itemName = "PVT_TABLE_NUM";
const std::string AQUNUM::SAT_TABLE_NUM::itemName = "SAT_TABLE_NUM";
AQUTAB::AQUTAB( ) : ParserKeyword("AQUTAB")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("AQUDIMS","NIFTBL",-1);
AQUTAB::AQUTAB() : ParserKeyword("AQUTAB", KeywordSize("AQUDIMS", "NIFTBL", false, -1)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("AQUTAB");
@@ -2088,9 +2015,7 @@ const std::string AQUTAB::keywordName = "AQUTAB";
const std::string AQUTAB::DATA::itemName = "DATA";
AUTOCOAR::AUTOCOAR( ) : ParserKeyword("AUTOCOAR")
{
setSizeType(SLASH_TERMINATED);
AUTOCOAR::AUTOCOAR() : ParserKeyword("AUTOCOAR", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("AUTOCOAR");
@@ -2147,9 +2072,7 @@ const std::string AUTOCOAR::NY::itemName = "NY";
const std::string AUTOCOAR::NZ::itemName = "NZ";
AUTOREF::AUTOREF( ) : ParserKeyword("AUTOREF")
{
setSizeType(SLASH_TERMINATED);
AUTOREF::AUTOREF() : ParserKeyword("AUTOREF", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("AUTOREF");
@@ -2186,7 +2109,7 @@ const int AUTOREF::NY::defaultValue = 1;
const std::string AUTOREF::NZ::itemName = "NZ";
const int AUTOREF::NZ::defaultValue = 1;
const std::string AUTOREF::OPTION_TRANS_MULT::itemName = "OPTION_TRANS_MULT";
const double AUTOREF::OPTION_TRANS_MULT::defaultValue = 0.000000;
const double AUTOREF::OPTION_TRANS_MULT::defaultValue = 0;
}

329
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/B.cpp vendored
View File

@@ -1,18 +1,17 @@
#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/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/parser/eclipse/Parser/ParserKeywords/B.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/B.hpp>
namespace Opm {
namespace ParserKeywords {
BC::BC( ) : ParserKeyword("BC")
{
setSizeType(SLASH_TERMINATED);
BC::BC() : ParserKeyword("BC", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("BC");
@@ -76,13 +75,10 @@ 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;
const double BC::RATE::defaultValue = 0;
BDENSITY::BDENSITY( ) : ParserKeyword("BDENSITY")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTPVT",0);
BDENSITY::BDENSITY() : ParserKeyword("BDENSITY", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("BDENSITY");
@@ -101,10 +97,7 @@ 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);
BGGI::BGGI() : ParserKeyword("BGGI", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("BGGI");
@@ -129,9 +122,7 @@ const std::string BGGI::GAS_PRESSURE::itemName = "GAS_PRESSURE";
const std::string BGGI::DATA::itemName = "DATA";
BIGMODEL::BIGMODEL( ) : ParserKeyword("BIGMODEL")
{
setFixedSize( (size_t) 0);
BIGMODEL::BIGMODEL() : ParserKeyword("BIGMODEL", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("BIGMODEL");
@@ -139,9 +130,7 @@ BIGMODEL::BIGMODEL( ) : ParserKeyword("BIGMODEL")
const std::string BIGMODEL::keywordName = "BIGMODEL";
BLACKOIL::BLACKOIL( ) : ParserKeyword("BLACKOIL")
{
setFixedSize( (size_t) 0);
BLACKOIL::BLACKOIL() : ParserKeyword("BLACKOIL", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("BLACKOIL");
@@ -149,136 +138,137 @@ BLACKOIL::BLACKOIL( ) : ParserKeyword("BLACKOIL")
const std::string BLACKOIL::keywordName = "BLACKOIL";
BLOCK_PROBE::BLOCK_PROBE( ) : ParserKeyword("BLOCK_PROBE")
{
setSizeType(SLASH_TERMINATED);
BLOCK_PROBE::BLOCK_PROBE() : ParserKeyword("BLOCK_PROBE", KeywordSize(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("BVELWK");
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("BSOIL");
addDeckName("BOSAT");
addDeckName("BGIP");
addDeckName("BVOIL");
addDeckName("BGKR");
addDeckName("BOIP");
addDeckName("BOIPL");
addDeckName("BGPR");
addDeckName("BSCN_X");
addDeckName("BGIPG");
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("BOIPG");
addDeckName("BWVIS");
addDeckName("BRSSAT");
addDeckName("BRTM");
addDeckName("BPPO");
addDeckName("BPDEW");
addDeckName("BDENO");
addDeckName("BVELOJ");
addDeckName("BODEN");
addDeckName("BVELWI");
addDeckName("BFLOOI");
addDeckName("BGDEN");
addDeckName("BVELWJ");
addDeckName("BFLOOJ");
addDeckName("BFLOWI");
addDeckName("LBHDF_X");
addDeckName("BVELOI");
addDeckName("BVELOK");
addDeckName("BPPC");
addDeckName("BTRADCAT");
addDeckName("BFLOGK");
addDeckName("BWSAT");
addDeckName("BSWAT");
addDeckName("BGSAT");
addDeckName("BPR");
addDeckName("BWIP");
addDeckName("BEWV_SAL");
addDeckName("BPPW");
addDeckName("BWKR");
addDeckName("BVWAT");
addDeckName("BDENW");
addDeckName("BKRO");
addDeckName("BVELGJ");
addDeckName("BWDEN");
addDeckName("BSGAS");
addDeckName("BGIPL");
addDeckName("BPPG");
addDeckName("BKROG");
addDeckName("BVGAS");
addDeckName("BGVIS");
addDeckName("BDENG");
addDeckName("BFLOGI");
addDeckName("BKRG");
addDeckName("BFLOGJ");
addDeckName("BPBUB");
addDeckName("BVELGI");
addDeckName("BRS");
addDeckName("BVELGK");
addDeckName("BWPR");
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("BOKR");
addDeckName("BKROW");
addDeckName("BKRW");
addDeckName("BWPC");
addDeckName("BWPR");
addDeckName("BWPV");
addDeckName("BWSAT");
addDeckName("BGPC");
addDeckName("BGTRP");
addDeckName("BGTPD");
addDeckName("BOPV");
addDeckName("BGSHY");
addDeckName("BGSTRP");
addDeckName("BWSHY");
addDeckName("BWSMA");
addDeckName("BWVIS");
addDeckName("LBCTRA_X");
addDeckName("LBHDF_X");
addDeckName("LBHD_X");
addDeckName("BHD");
addDeckName("BHDF");
addDeckName("BPR_X");
addDeckName("BHD_X");
addDeckName("BHDF_X");
addDeckName("BCTRA_X");
addDeckName("LBPR_X");
addDeckName("LBHD_X");
addDeckName("LBSCN_X");
addDeckName("LBCTRA_X");
addDeckName("BRPV");
addDeckName("BWPV");
addDeckName("BGPV");
addDeckName("BHPV");
addDeckName("BRTM");
addDeckName("BPORVMOD");
addDeckName("BPERMMOD");
addDeckName("BSCN");
addDeckName("BAPI");
addDeckName("BSIP");
addDeckName("BCAD");
addDeckName("BTCNFANI");
addDeckName("BTCNFCAT");
addDeckName("BTCASUR");
addDeckName("BTSADCAT");
addDeckName("BESALSUR");
addDeckName("BESALPLY");
addDeckName("BTCNFHEA");
addDeckName("BTIPTHEA");
addDeckName("BCGC");
addDeckName("BCSC");
addDeckName("BTCNFFOA");
addDeckName("BTCNMFOA");
addDeckName("BTIPTFOA");
addDeckName("BTADSFOA");
addDeckName("BTDCYFOA");
addDeckName("BTMOBFOA");
addDeckName("BTHLFFOA");
addDeckName("BGI");
addDeckName("BNSAT");
addDeckName("BNIP");
addDeckName("BNKR");
addDeckName("BTPADALK");
addDeckName("BTCNFSUR");
addDeckName("BTIPTSUR");
addDeckName("BTADSUR");
addDeckName("BTSTSUR");
addDeckName("BEWV_SUR");
addDeckName("BTCNFALK");
addDeckName("BTADSALK");
addDeckName("BTSTMALK");
addDeckName("BTSADALK");
setMatchRegex("BU.+|BTIPF.+|BTIPS.+|BTCNF.+|BTCNS.+|BTCN[1-9][0-9]*.+|BTIPT.+|BTIPF.+|BTIPS.+|BTIP[1-9][0-9]*.+|BTADS.+|BTDCY");
{
ParserRecord record;
@@ -303,9 +293,7 @@ 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);
BLOCK_PROBE300::BLOCK_PROBE300() : ParserKeyword("BLOCK_PROBE300", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SUMMARY");
clearDeckNames();
addDeckName("BTEMP");
@@ -332,10 +320,7 @@ 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);
BOGI::BOGI() : ParserKeyword("BOGI", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("BOGI");
@@ -360,14 +345,12 @@ 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");
BOUNDARY::BOUNDARY() : ParserKeyword("BOUNDARY", KeywordSize(1, false)) {
addValidSectionName("GRID");
addValidSectionName("EDIT");
addValidSectionName("REGIONS");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("BOUNDARY");
{
@@ -422,15 +405,13 @@ 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);
BOX::BOX() : ParserKeyword("BOX", KeywordSize(1, false)) {
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("BOX");
{
@@ -471,9 +452,7 @@ const std::string BOX::K1::itemName = "K1";
const std::string BOX::K2::itemName = "K2";
BPARA::BPARA( ) : ParserKeyword("BPARA")
{
setFixedSize( (size_t) 0);
BPARA::BPARA() : ParserKeyword("BPARA", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("BPARA");
@@ -481,9 +460,7 @@ BPARA::BPARA( ) : ParserKeyword("BPARA")
const std::string BPARA::keywordName = "BPARA";
BPIDIMS::BPIDIMS( ) : ParserKeyword("BPIDIMS")
{
setFixedSize( (size_t) 1);
BPIDIMS::BPIDIMS() : ParserKeyword("BPIDIMS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("BPIDIMS");
@@ -509,9 +486,7 @@ const std::string BPIDIMS::MXNLBI::itemName = "MXNLBI";
const int BPIDIMS::MXNLBI::defaultValue = 1;
BRANPROP::BRANPROP( ) : ParserKeyword("BRANPROP")
{
setSizeType(SLASH_TERMINATED);
BRANPROP::BRANPROP() : ParserKeyword("BRANPROP", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("BRANPROP");
@@ -547,24 +522,30 @@ 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 double BRANPROP::ALQ::defaultValue = 0;
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);
BRINE::BRINE() : ParserKeyword("BRINE", KeywordSize(0, 1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("BRINE");
{
ParserRecord record;
{
ParserItem item("SALTS", ParserItem::itype::STRING);
item.setSizeType(ParserItem::item_size::ALL);
record.addItem(item);
}
addRecord( record );
}
}
const std::string BRINE::keywordName = "BRINE";
const std::string BRINE::SALTS::itemName = "SALTS";
BTOBALFA::BTOBALFA( ) : ParserKeyword("BTOBALFA")
{
setFixedSize( (size_t) 1);
BTOBALFA::BTOBALFA() : ParserKeyword("BTOBALFA", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("BTOBALFA");
@@ -582,9 +563,7 @@ const std::string BTOBALFA::keywordName = "BTOBALFA";
const std::string BTOBALFA::VALUE::itemName = "VALUE";
BTOBALFV::BTOBALFV( ) : ParserKeyword("BTOBALFV")
{
setFixedSize( (size_t) 1);
BTOBALFV::BTOBALFV() : ParserKeyword("BTOBALFV", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("BTOBALFV");

448
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/C.cpp vendored
View File

@@ -1,18 +1,17 @@
#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/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/parser/eclipse/Parser/ParserKeywords/C.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/C.hpp>
namespace Opm {
namespace ParserKeywords {
CALTRAC::CALTRAC( ) : ParserKeyword("CALTRAC")
{
setFixedSize( (size_t) 1);
CALTRAC::CALTRAC() : ParserKeyword("CALTRAC", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("CALTRAC");
@@ -29,9 +28,7 @@ const std::string CALTRAC::keywordName = "CALTRAC";
const std::string CALTRAC::IX1::itemName = "IX1";
CARFIN::CARFIN( ) : ParserKeyword("CARFIN")
{
setFixedSize( (size_t) 1);
CARFIN::CARFIN() : ParserKeyword("CARFIN", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("CARFIN");
@@ -105,9 +102,7 @@ const std::string CARFIN::PARENT::itemName = "PARENT";
const std::string CARFIN::PARENT::defaultValue = "GLOBAL";
CART::CART( ) : ParserKeyword("CART")
{
setFixedSize( (size_t) 0);
CART::CART() : ParserKeyword("CART", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("CART");
@@ -115,9 +110,7 @@ CART::CART( ) : ParserKeyword("CART")
const std::string CART::keywordName = "CART";
CBMOPTS::CBMOPTS( ) : ParserKeyword("CBMOPTS")
{
setFixedSize( (size_t) 1);
CBMOPTS::CBMOPTS() : ParserKeyword("CBMOPTS", KeywordSize(1, false)) {
addValidSectionName("SRUNSPEC");
clearDeckNames();
addDeckName("CBMOPTS");
@@ -189,12 +182,10 @@ const std::string CBMOPTS::APPLICATION::defaultValue = "PMPVK";
const std::string CBMOPTS::PRESSURE_CHOP::itemName = "PRESSURE_CHOP";
const std::string CBMOPTS::PRESSURE_CHOP::defaultValue = "NOPMPCHP";
const std::string CBMOPTS::MIN_PORE_VOLUME::itemName = "MIN_PORE_VOLUME";
const double CBMOPTS::MIN_PORE_VOLUME::defaultValue = 0.000005;
const double CBMOPTS::MIN_PORE_VOLUME::defaultValue = 5e-06;
CECON::CECON( ) : ParserKeyword("CECON")
{
setSizeType(SLASH_TERMINATED);
CECON::CECON() : ParserKeyword("CECON", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("CECON");
@@ -278,11 +269,11 @@ const int CECON::K1::defaultValue = 0;
const std::string CECON::K2::itemName = "K2";
const int CECON::K2::defaultValue = 0;
const std::string CECON::MAX_WCUT::itemName = "MAX_WCUT";
const double CECON::MAX_WCUT::defaultValue = 0.000000;
const double CECON::MAX_WCUT::defaultValue = 0;
const std::string CECON::MAX_GOR::itemName = "MAX_GOR";
const double CECON::MAX_GOR::defaultValue = 0.000000;
const double CECON::MAX_GOR::defaultValue = 0;
const std::string CECON::MAX_WGR::itemName = "MAX_WGR";
const double CECON::MAX_WGR::defaultValue = 0.000000;
const double CECON::MAX_WGR::defaultValue = 0;
const std::string CECON::WORKOVER_PROCEDURE::itemName = "WORKOVER_PROCEDURE";
const std::string CECON::WORKOVER_PROCEDURE::defaultValue = "CON";
const std::string CECON::CHECK_STOPPED::itemName = "CHECK_STOPPED";
@@ -295,9 +286,7 @@ const std::string CECON::FOLLOW_ON_WELL::itemName = "FOLLOW_ON_WELL";
const std::string CECON::FOLLOW_ON_WELL::defaultValue = "";
CECONT::CECONT( ) : ParserKeyword("CECONT")
{
setSizeType(DOUBLE_SLASH_TERMINATED);
CECONT::CECONT() : ParserKeyword("CECONT", KeywordSize(DOUBLE_SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("CECONT");
@@ -408,9 +397,7 @@ const std::string CECONT::MAX_SOL_TRACER_CONC::itemName = "MAX_SOL_TRACER_CONC";
const double CECONT::MAX_SOL_TRACER_CONC::defaultValue = 99999999999999996973312221251036165947450327545502362648241750950346848435554075534196338404706251868027512415973882408182135734368278484639385041047239877871023591066789981811181813306167128854888448.000000;
CIRCLE::CIRCLE( ) : ParserKeyword("CIRCLE")
{
setFixedSize( (size_t) 0);
CIRCLE::CIRCLE() : ParserKeyword("CIRCLE", KeywordSize(0, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("CIRCLE");
@@ -418,9 +405,23 @@ CIRCLE::CIRCLE( ) : ParserKeyword("CIRCLE")
const std::string CIRCLE::keywordName = "CIRCLE";
COAL::COAL( ) : ParserKeyword("COAL")
{
setFixedSize( (size_t) 0);
CO2STOR::CO2STOR() : ParserKeyword("CO2STOR", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("CO2STOR");
}
const std::string CO2STOR::keywordName = "CO2STOR";
CO2STORE::CO2STORE() : ParserKeyword("CO2STORE", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("CO2STORE");
}
const std::string CO2STORE::keywordName = "CO2STORE";
COAL::COAL() : ParserKeyword("COAL", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("COAL");
@@ -428,10 +429,7 @@ COAL::COAL( ) : ParserKeyword("COAL")
const std::string COAL::keywordName = "COAL";
COALADS::COALADS( ) : ParserKeyword("COALADS")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("REGDIMS","NTCREG",0);
COALADS::COALADS() : ParserKeyword("COALADS", KeywordSize("REGDIMS", "NTCREG", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("COALADS");
@@ -452,9 +450,7 @@ const std::string COALADS::keywordName = "COALADS";
const std::string COALADS::DATA::itemName = "DATA";
COALNUM::COALNUM( ) : ParserKeyword("COALNUM")
{
setFixedSize( (size_t) 1);
COALNUM::COALNUM() : ParserKeyword("COALNUM", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("COALNUM");
@@ -472,10 +468,7 @@ const std::string COALNUM::keywordName = "COALNUM";
const std::string COALNUM::data::itemName = "data";
COALPP::COALPP( ) : ParserKeyword("COALPP")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("REGDIMS","NTCREG",0);
COALPP::COALPP() : ParserKeyword("COALPP", KeywordSize("REGDIMS", "NTCREG", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("COALPP");
@@ -496,9 +489,7 @@ const std::string COALPP::keywordName = "COALPP";
const std::string COALPP::DATA::itemName = "DATA";
COARSEN::COARSEN( ) : ParserKeyword("COARSEN")
{
setFixedSize( (size_t) 1);
COARSEN::COARSEN() : ParserKeyword("COARSEN", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("COARSEN");
@@ -555,9 +546,7 @@ const std::string COARSEN::NY::itemName = "NY";
const std::string COARSEN::NZ::itemName = "NZ";
COLLAPSE::COLLAPSE( ) : ParserKeyword("COLLAPSE")
{
setSizeType(SLASH_TERMINATED);
COLLAPSE::COLLAPSE() : ParserKeyword("COLLAPSE", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("COLLAPSE");
@@ -576,17 +565,15 @@ const std::string COLLAPSE::VALUE::itemName = "VALUE";
const int COLLAPSE::VALUE::defaultValue = 1;
COLUMNS::COLUMNS( ) : ParserKeyword("COLUMNS")
{
setFixedSize( (size_t) 1);
COLUMNS::COLUMNS() : ParserKeyword("COLUMNS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SUMMARY");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COLUMNS");
{
@@ -611,9 +598,7 @@ const std::string COLUMNS::RIGHT_MARGIN::itemName = "RIGHT_MARGIN";
const int COLUMNS::RIGHT_MARGIN::defaultValue = 132;
COMPDAT::COMPDAT( ) : ParserKeyword("COMPDAT")
{
setSizeType(SLASH_TERMINATED);
COMPDAT::COMPDAT() : ParserKeyword("COMPDAT", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPDAT");
@@ -708,20 +693,18 @@ const std::string COMPDAT::DIAMETER::itemName = "DIAMETER";
const std::string COMPDAT::Kh::itemName = "Kh";
const double COMPDAT::Kh::defaultValue = -1.000000;
const std::string COMPDAT::SKIN::itemName = "SKIN";
const double COMPDAT::SKIN::defaultValue = 0.000000;
const double COMPDAT::SKIN::defaultValue = 0;
const std::string COMPDAT::D_FACTOR::itemName = "D_FACTOR";
const std::string COMPDAT::DIR::itemName = "DIR";
const std::string COMPDAT::DIR::defaultValue = "Z";
const std::string COMPDAT::PR::itemName = "PR";
COMPDATX::COMPDATX( ) : ParserKeyword("COMPDATX")
{
setSizeType(SLASH_TERMINATED);
COMPDATX::COMPDATX() : ParserKeyword("COMPDATX", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPDATL");
addDeckName("COMPDATM");
addDeckName("COMPDATL");
{
ParserRecord record;
{
@@ -818,16 +801,14 @@ const std::string COMPDATX::DIAMETER::itemName = "DIAMETER";
const std::string COMPDATX::Kh::itemName = "Kh";
const double COMPDATX::Kh::defaultValue = -1.000000;
const std::string COMPDATX::SKIN::itemName = "SKIN";
const double COMPDATX::SKIN::defaultValue = 0.000000;
const double COMPDATX::SKIN::defaultValue = 0;
const std::string COMPDATX::D_FACTOR::itemName = "D_FACTOR";
const std::string COMPDATX::DIR::itemName = "DIR";
const std::string COMPDATX::DIR::defaultValue = "Z";
const std::string COMPDATX::PR::itemName = "PR";
COMPFLSH::COMPFLSH( ) : ParserKeyword("COMPFLSH")
{
setSizeType(SLASH_TERMINATED);
COMPFLSH::COMPFLSH() : ParserKeyword("COMPFLSH", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPFLSH");
@@ -895,9 +876,7 @@ const std::string COMPFLSH::FLASH_PVTNUM::itemName = "FLASH_PVTNUM";
const int COMPFLSH::FLASH_PVTNUM::defaultValue = 0;
COMPIMB::COMPIMB( ) : ParserKeyword("COMPIMB")
{
setSizeType(SLASH_TERMINATED);
COMPIMB::COMPIMB() : ParserKeyword("COMPIMB", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPIMB");
@@ -945,9 +924,7 @@ const std::string COMPIMB::SAT_TABLE::itemName = "SAT_TABLE";
const int COMPIMB::SAT_TABLE::defaultValue = 0;
COMPINJK::COMPINJK( ) : ParserKeyword("COMPINJK")
{
setSizeType(SLASH_TERMINATED);
COMPINJK::COMPINJK() : ParserKeyword("COMPINJK", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPINJK");
@@ -997,12 +974,10 @@ const int COMPINJK::K_UPPER::defaultValue = 0;
const std::string COMPINJK::K_LOWER::itemName = "K_LOWER";
const int COMPINJK::K_LOWER::defaultValue = 0;
const std::string COMPINJK::REL_PERM::itemName = "REL_PERM";
const double COMPINJK::REL_PERM::defaultValue = 0.000000;
const double COMPINJK::REL_PERM::defaultValue = 0;
COMPLMPL::COMPLMPL( ) : ParserKeyword("COMPLMPL")
{
setSizeType(SLASH_TERMINATED);
COMPLMPL::COMPLMPL() : ParserKeyword("COMPLMPL", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPLMPL");
@@ -1059,9 +1034,7 @@ const int COMPLMPL::LOWER_K::defaultValue = 0;
const std::string COMPLMPL::COMPLETION_NUMBER::itemName = "COMPLETION_NUMBER";
COMPLUMP::COMPLUMP( ) : ParserKeyword("COMPLUMP")
{
setSizeType(SLASH_TERMINATED);
COMPLUMP::COMPLUMP() : ParserKeyword("COMPLUMP", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPLUMP");
@@ -1073,18 +1046,22 @@ COMPLUMP::COMPLUMP( ) : ParserKeyword("COMPLUMP")
}
{
ParserItem item("I", ParserItem::itype::INT);
item.setDefault( 0 );
record.addItem(item);
}
{
ParserItem item("J", ParserItem::itype::INT);
item.setDefault( 0 );
record.addItem(item);
}
{
ParserItem item("K1", ParserItem::itype::INT);
item.setDefault( 0 );
record.addItem(item);
}
{
ParserItem item("K2", ParserItem::itype::INT);
item.setDefault( 0 );
record.addItem(item);
}
{
@@ -1097,15 +1074,17 @@ COMPLUMP::COMPLUMP( ) : ParserKeyword("COMPLUMP")
const std::string COMPLUMP::keywordName = "COMPLUMP";
const std::string COMPLUMP::WELL::itemName = "WELL";
const std::string COMPLUMP::I::itemName = "I";
const int COMPLUMP::I::defaultValue = 0;
const std::string COMPLUMP::J::itemName = "J";
const int COMPLUMP::J::defaultValue = 0;
const std::string COMPLUMP::K1::itemName = "K1";
const int COMPLUMP::K1::defaultValue = 0;
const std::string COMPLUMP::K2::itemName = "K2";
const int COMPLUMP::K2::defaultValue = 0;
const std::string COMPLUMP::N::itemName = "N";
COMPOFF::COMPOFF( ) : ParserKeyword("COMPOFF")
{
setFixedSize( (size_t) 0);
COMPOFF::COMPOFF() : ParserKeyword("COMPOFF", KeywordSize(0, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPOFF");
@@ -1113,9 +1092,7 @@ COMPOFF::COMPOFF( ) : ParserKeyword("COMPOFF")
const std::string COMPOFF::keywordName = "COMPOFF";
COMPORD::COMPORD( ) : ParserKeyword("COMPORD")
{
setSizeType(SLASH_TERMINATED);
COMPORD::COMPORD() : ParserKeyword("COMPORD", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPORD");
@@ -1139,9 +1116,7 @@ const std::string COMPORD::ORDER_TYPE::itemName = "ORDER_TYPE";
const std::string COMPORD::ORDER_TYPE::defaultValue = "TRACK";
COMPRIV::COMPRIV( ) : ParserKeyword("COMPRIV")
{
setSizeType(SLASH_TERMINATED);
COMPRIV::COMPRIV() : ParserKeyword("COMPRIV", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPRIV");
@@ -1173,9 +1148,7 @@ const std::string COMPRIV::J::itemName = "J";
const std::string COMPRIV::K::itemName = "K";
COMPRP::COMPRP( ) : ParserKeyword("COMPRP")
{
setSizeType(SLASH_TERMINATED);
COMPRP::COMPRP() : ParserKeyword("COMPRP", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPRP");
@@ -1249,9 +1222,7 @@ const std::string COMPRP::SGMIN::itemName = "SGMIN";
const std::string COMPRP::SGMAX::itemName = "SGMAX";
COMPRPL::COMPRPL( ) : ParserKeyword("COMPRPL")
{
setSizeType(SLASH_TERMINATED);
COMPRPL::COMPRPL() : ParserKeyword("COMPRPL", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPRPL");
@@ -1330,9 +1301,7 @@ const std::string COMPRPL::SGMIN::itemName = "SGMIN";
const std::string COMPRPL::SGMAX::itemName = "SGMAX";
COMPS::COMPS( ) : ParserKeyword("COMPS")
{
setFixedSize( (size_t) 1);
COMPS::COMPS() : ParserKeyword("COMPS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("COMPS");
@@ -1349,9 +1318,7 @@ const std::string COMPS::keywordName = "COMPS";
const std::string COMPS::NUM_COMPS::itemName = "NUM_COMPS";
COMPSEGL::COMPSEGL( ) : ParserKeyword("COMPSEGL")
{
setSizeType(SLASH_TERMINATED);
COMPSEGL::COMPSEGL() : ParserKeyword("COMPSEGL", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPSEGL");
@@ -1433,14 +1400,12 @@ const std::string COMPSEGL::DISTANCE_END::itemName = "DISTANCE_END";
const std::string COMPSEGL::DIRECTION::itemName = "DIRECTION";
const std::string COMPSEGL::END_IJK::itemName = "END_IJK";
const std::string COMPSEGL::CENTER_DEPTH::itemName = "CENTER_DEPTH";
const double COMPSEGL::CENTER_DEPTH::defaultValue = 0.000000;
const double COMPSEGL::CENTER_DEPTH::defaultValue = 0;
const std::string COMPSEGL::THERMAL_LENGTH::itemName = "THERMAL_LENGTH";
const std::string COMPSEGL::SEGMENT_NUMBER::itemName = "SEGMENT_NUMBER";
COMPSEGS::COMPSEGS( ) : ParserKeyword("COMPSEGS")
{
setSizeType(SLASH_TERMINATED);
COMPSEGS::COMPSEGS() : ParserKeyword("COMPSEGS", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPSEGS");
@@ -1517,14 +1482,12 @@ const std::string COMPSEGS::DISTANCE_END::itemName = "DISTANCE_END";
const std::string COMPSEGS::DIRECTION::itemName = "DIRECTION";
const std::string COMPSEGS::END_IJK::itemName = "END_IJK";
const std::string COMPSEGS::CENTER_DEPTH::itemName = "CENTER_DEPTH";
const double COMPSEGS::CENTER_DEPTH::defaultValue = 0.000000;
const double COMPSEGS::CENTER_DEPTH::defaultValue = 0;
const std::string COMPSEGS::THERMAL_LENGTH::itemName = "THERMAL_LENGTH";
const std::string COMPSEGS::SEGMENT_NUMBER::itemName = "SEGMENT_NUMBER";
COMPVE::COMPVE( ) : ParserKeyword("COMPVE")
{
setSizeType(SLASH_TERMINATED);
COMPVE::COMPVE() : ParserKeyword("COMPVE", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPVE");
@@ -1613,14 +1576,12 @@ const std::string COMPVE::DBOT::itemName = "DBOT";
const std::string COMPVE::FLAG::itemName = "FLAG";
const std::string COMPVE::FLAG::defaultValue = "NO";
const std::string COMPVE::S_D::itemName = "S_D";
const double COMPVE::S_D::defaultValue = 0.000000;
const double COMPVE::S_D::defaultValue = 0;
const std::string COMPVE::GTOP::itemName = "GTOP";
const std::string COMPVE::GBOT::itemName = "GBOT";
COMPVEL::COMPVEL( ) : ParserKeyword("COMPVEL")
{
setSizeType(SLASH_TERMINATED);
COMPVEL::COMPVEL() : ParserKeyword("COMPVEL", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("COMPVEL");
@@ -1714,129 +1675,128 @@ const std::string COMPVEL::DBOT::itemName = "DBOT";
const std::string COMPVEL::FLAG::itemName = "FLAG";
const std::string COMPVEL::FLAG::defaultValue = "NO";
const std::string COMPVEL::S_D::itemName = "S_D";
const double COMPVEL::S_D::defaultValue = 0.000000;
const double COMPVEL::S_D::defaultValue = 0;
const std::string COMPVEL::GTOP::itemName = "GTOP";
const std::string COMPVEL::GBOT::itemName = "GBOT";
CONNECTION_PROBE::CONNECTION_PROBE( ) : ParserKeyword("CONNECTION_PROBE")
{
setSizeType(SLASH_TERMINATED);
CONNECTION_PROBE::CONNECTION_PROBE() : ParserKeyword("CONNECTION_PROBE", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SUMMARY");
clearDeckNames();
addDeckName("CAPI");
addDeckName("CCFR");
addDeckName("CCIC");
addDeckName("CCIR");
addDeckName("CCIT");
addDeckName("CCPC");
addDeckName("CCPT");
addDeckName("CDBF");
addDeckName("CDFAC");
addDeckName("CDSF");
addDeckName("CDSM");
addDeckName("CDSML");
addDeckName("CGFR");
addDeckName("CGFRF");
addDeckName("CGFRL");
addDeckName("CGFRS");
addDeckName("CGFRU");
addDeckName("COPT");
addDeckName("COPRL");
addDeckName("COFR");
addDeckName("CGPRL");
addDeckName("COFRF");
addDeckName("CVPT");
addDeckName("CGIR");
addDeckName("CGIRL");
addDeckName("COFRS");
addDeckName("CWPTL");
addDeckName("CWFRL");
addDeckName("COPR");
addDeckName("COFRL");
addDeckName("CGPR");
addDeckName("CVPR");
addDeckName("CDSML");
addDeckName("CGIT");
addDeckName("COFRU");
addDeckName("COPTL");
addDeckName("COPTF");
addDeckName("CWCT");
addDeckName("COPTS");
addDeckName("CLFRL");
addDeckName("COIT");
addDeckName("CWFRU");
addDeckName("COITL");
addDeckName("COPP");
addDeckName("COPI");
addDeckName("CWPT");
addDeckName("CWFR");
addDeckName("CWPRL");
addDeckName("CWPR");
addDeckName("CWIR");
addDeckName("CWIT");
addDeckName("CWIRL");
addDeckName("CWITL");
addDeckName("CSIC");
addDeckName("CWPP");
addDeckName("CWPI");
addDeckName("CGFR");
addDeckName("CVITL");
addDeckName("CGFRF");
addDeckName("CGPP");
addDeckName("CVFRL");
addDeckName("WGIRL");
addDeckName("CGFRS");
addDeckName("CGFRL");
addDeckName("CDSM");
addDeckName("CGFRU");
addDeckName("CTITALK");
addDeckName("CGPT");
addDeckName("CGPTL");
addDeckName("CGPTF");
addDeckName("CGPTS");
addDeckName("CCIR");
addDeckName("CTPTSUR");
addDeckName("CVPTL");
addDeckName("CGIRL");
addDeckName("CGQ");
addDeckName("CGITL");
addDeckName("CGLR");
addDeckName("CGLRL");
addDeckName("WGITL");
addDeckName("CGPI");
addDeckName("CDBF");
addDeckName("CLFR");
addDeckName("CLPT");
addDeckName("CCIT");
addDeckName("CAPI");
addDeckName("CLPTL");
addDeckName("CVFR");
addDeckName("CVIRL");
addDeckName("CVIR");
addDeckName("CVIT");
addDeckName("LCGFRU");
addDeckName("CWCTL");
addDeckName("CGOR");
addDeckName("CGORL");
addDeckName("CGPI");
addDeckName("CGPP");
addDeckName("CGPR");
addDeckName("CGPRL");
addDeckName("CGPT");
addDeckName("CGPTF");
addDeckName("CGPTL");
addDeckName("CGPTS");
addDeckName("CGQ");
addDeckName("CLFR");
addDeckName("CLFRL");
addDeckName("CLPT");
addDeckName("CLPTL");
addDeckName("CNFR");
addDeckName("CNIT");
addDeckName("CNPT");
addDeckName("COFR");
addDeckName("COFRF");
addDeckName("COFRL");
addDeckName("COFRS");
addDeckName("COFRU");
addDeckName("COGR");
addDeckName("COGRL");
addDeckName("COIT");
addDeckName("COITL");
addDeckName("COPI");
addDeckName("COPP");
addDeckName("COPR");
addDeckName("COPRL");
addDeckName("COPT");
addDeckName("COPTF");
addDeckName("COPTL");
addDeckName("COPTS");
addDeckName("CWGR");
addDeckName("CWGRL");
addDeckName("CSPR");
addDeckName("CGLR");
addDeckName("CSFR");
addDeckName("CGLRL");
addDeckName("CPI");
addDeckName("CPRL");
addDeckName("CSFR");
addDeckName("CSIC");
addDeckName("CTFAC");
addDeckName("CDSF");
addDeckName("CDFAC");
addDeckName("CSPT");
addDeckName("CSIR");
addDeckName("CSIT");
addDeckName("CSPC");
addDeckName("CSPR");
addDeckName("CSPT");
addDeckName("CTFAC");
addDeckName("CTFRALK");
addDeckName("CTFRANI");
addDeckName("CTFRCAT");
addDeckName("CTFRFOA");
addDeckName("CTFRSUR");
addDeckName("CTITALK");
addDeckName("CTITANI");
addDeckName("CTITCAT");
addDeckName("CTITFOA");
addDeckName("CTITSUR");
addDeckName("CTPTALK");
addDeckName("CTPTANI");
addDeckName("CTITANI");
addDeckName("CTFRCAT");
addDeckName("CTPTCAT");
addDeckName("CTITCAT");
addDeckName("CTFRFOA");
addDeckName("CTPTFOA");
addDeckName("CTPTSUR");
addDeckName("CVFR");
addDeckName("CVFRL");
addDeckName("CVIR");
addDeckName("CVIRL");
addDeckName("CVIT");
addDeckName("CVITL");
addDeckName("CVPT");
addDeckName("CVPTL");
addDeckName("CWCT");
addDeckName("CWCTL");
addDeckName("CWFR");
addDeckName("CWFRL");
addDeckName("CWFRU");
addDeckName("CWGR");
addDeckName("CWGRL");
addDeckName("CWIR");
addDeckName("CWIRL");
addDeckName("CWIT");
addDeckName("CWITL");
addDeckName("CWPI");
addDeckName("CWPP");
addDeckName("CWPR");
addDeckName("CWPRL");
addDeckName("CWPT");
addDeckName("CWPTL");
addDeckName("LCGFRU");
addDeckName("CTITFOA");
addDeckName("CCFR");
addDeckName("CCPC");
addDeckName("CCPT");
addDeckName("CCIC");
addDeckName("CNFR");
addDeckName("CNPT");
addDeckName("CNIT");
addDeckName("CTFRSUR");
addDeckName("CTITSUR");
addDeckName("CTFRALK");
addDeckName("CTPTALK");
addDeckName("LCOFRU");
addDeckName("LCWFRU");
addDeckName("WGIRL");
addDeckName("WGITL");
setMatchRegex("CU.+|CTFR.+|CTPR.+|CTPT.+|CTPC.+|CTIR.+|CTIT.+|CTIC.+|CTFR.+|CTPR.+|CTPT.+|CTPC.+|CTIR.+|CTIT.+|CTIC.+|CTIRF.+|CTIRS.+|CTPRF.+|CTPRS.+|CTITF.+|CTITS.+|CTPTF.+|CTPTS.+|CTICF.+|CTICS.+|CTPCF.+|CTPCS");
{
ParserRecord record;
@@ -1866,10 +1826,11 @@ const std::string CONNECTION_PROBE::J::itemName = "J";
const std::string CONNECTION_PROBE::K::itemName = "K";
COORD::COORD( ) : ParserKeyword("COORD")
{
setFixedSize( (size_t) 1);
COORD::COORD() : ParserKeyword("COORD", KeywordSize(1, false)) {
addValidSectionName("GRID");
setProhibitedKeywords({
"GDFILE",
});
clearDeckNames();
addDeckName("COORD");
{
@@ -1887,10 +1848,7 @@ const std::string COORD::keywordName = "COORD";
const std::string COORD::data::itemName = "data";
COORDSYS::COORDSYS( ) : ParserKeyword("COORDSYS")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("NUMRES","num",0);
COORDSYS::COORDSYS() : ParserKeyword("COORDSYS", KeywordSize("NUMRES", "num", false, 0)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("COORDSYS");
@@ -1940,12 +1898,10 @@ const std::string COORDSYS::R2::itemName = "R2";
const int COORDSYS::R2::defaultValue = 0;
COPY::COPY( ) : ParserKeyword("COPY")
{
setSizeType(SLASH_TERMINATED);
COPY::COPY() : ParserKeyword("COPY", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("SOLUTION");
clearDeckNames();
@@ -1998,11 +1954,9 @@ const std::string COPY::K1::itemName = "K1";
const std::string COPY::K2::itemName = "K2";
COPYBOX::COPYBOX( ) : ParserKeyword("COPYBOX")
{
setSizeType(SLASH_TERMINATED);
addValidSectionName("GRID");
COPYBOX::COPYBOX() : ParserKeyword("COPYBOX", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("PROPS");
addValidSectionName("GRID");
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("COPYBOX");
@@ -2079,12 +2033,10 @@ const std::string COPYBOX::KY1D::itemName = "KY1D";
const std::string COPYBOX::KY2D::itemName = "KY2D";
COPYREG::COPYREG( ) : ParserKeyword("COPYREG")
{
setSizeType(SLASH_TERMINATED);
COPYREG::COPYREG() : ParserKeyword("COPYREG", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("SOLUTION");
clearDeckNames();
@@ -2123,9 +2075,7 @@ const std::string COPYREG::REGION_NAME::itemName = "REGION_NAME";
const std::string COPYREG::REGION_NAME::defaultValue = "M";
CPIFACT::CPIFACT( ) : ParserKeyword("CPIFACT")
{
setSizeType(SLASH_TERMINATED);
CPIFACT::CPIFACT() : ParserKeyword("CPIFACT", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("CPIFACT");
@@ -2172,9 +2122,7 @@ const std::string CPIFACT::C1::itemName = "C1";
const std::string CPIFACT::C2::itemName = "C2";
CPIFACTL::CPIFACTL( ) : ParserKeyword("CPIFACTL")
{
setSizeType(SLASH_TERMINATED);
CPIFACTL::CPIFACTL() : ParserKeyword("CPIFACTL", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("CPIFACTL");
@@ -2226,9 +2174,7 @@ const std::string CPIFACTL::C1::itemName = "C1";
const std::string CPIFACTL::C2::itemName = "C2";
CPR::CPR( ) : ParserKeyword("CPR")
{
setSizeType(SLASH_TERMINATED);
CPR::CPR() : ParserKeyword("CPR", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("RUNSPEC");
addValidSectionName("SUMMARY");
clearDeckNames();
@@ -2261,10 +2207,7 @@ const std::string CPR::J::itemName = "J";
const std::string CPR::K::itemName = "K";
CREF::CREF( ) : ParserKeyword("CREF")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NUM_STATE_EQ",0);
CREF::CREF() : ParserKeyword("CREF", KeywordSize("TABDIMS", "NUM_STATE_EQ", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("CREF");
@@ -2283,10 +2226,7 @@ const std::string CREF::keywordName = "CREF";
const std::string CREF::COMPRESSIBILITY::itemName = "COMPRESSIBILITY";
CREFS::CREFS( ) : ParserKeyword("CREFS")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NUM_STATE_EQ",0);
CREFS::CREFS() : ParserKeyword("CREFS", KeywordSize("TABDIMS", "NUM_STATE_EQ", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("CREFS");
@@ -2305,9 +2245,7 @@ const std::string CREFS::keywordName = "CREFS";
const std::string CREFS::COMPRESSIBILITY::itemName = "COMPRESSIBILITY";
CRITPERM::CRITPERM( ) : ParserKeyword("CRITPERM")
{
setFixedSize( (size_t) 1);
CRITPERM::CRITPERM() : ParserKeyword("CRITPERM", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("CRITPERM");
@@ -2325,9 +2263,7 @@ const std::string CRITPERM::keywordName = "CRITPERM";
const std::string CRITPERM::VALUE::itemName = "VALUE";
CSKIN::CSKIN( ) : ParserKeyword("CSKIN")
{
setSizeType(SLASH_TERMINATED);
CSKIN::CSKIN() : ParserKeyword("CSKIN", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("CSKIN");
@@ -2377,7 +2313,7 @@ const int CSKIN::K_UPPER::defaultValue = 0;
const std::string CSKIN::K_LOWER::itemName = "K_LOWER";
const int CSKIN::K_LOWER::defaultValue = 0;
const std::string CSKIN::CONNECTION_SKIN_FACTOR::itemName = "CONNECTION_SKIN_FACTOR";
const double CSKIN::CONNECTION_SKIN_FACTOR::defaultValue = 0.000000;
const double CSKIN::CONNECTION_SKIN_FACTOR::defaultValue = 0;
}

391
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/D.cpp vendored
View File

@@ -1,18 +1,17 @@
#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/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/parser/eclipse/Parser/ParserKeywords/D.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/D.hpp>
namespace Opm {
namespace ParserKeywords {
DATE::DATE( ) : ParserKeyword("DATE")
{
setFixedSize( (size_t) 0);
DATE::DATE() : ParserKeyword("DATE", KeywordSize(0, false)) {
addValidSectionName("SUMMARY");
clearDeckNames();
addDeckName("DATE");
@@ -20,9 +19,7 @@ DATE::DATE( ) : ParserKeyword("DATE")
const std::string DATE::keywordName = "DATE";
DATES::DATES( ) : ParserKeyword("DATES")
{
setSizeType(SLASH_TERMINATED);
DATES::DATES() : ParserKeyword("DATES", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("DATES");
@@ -56,9 +53,7 @@ const std::string DATES::TIME::itemName = "TIME";
const std::string DATES::TIME::defaultValue = "00:00:00.000";
DATUM::DATUM( ) : ParserKeyword("DATUM")
{
setFixedSize( (size_t) 1);
DATUM::DATUM() : ParserKeyword("DATUM", KeywordSize(1, false)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("DATUM");
@@ -76,9 +71,7 @@ const std::string DATUM::keywordName = "DATUM";
const std::string DATUM::DEPTH::itemName = "DEPTH";
DATUMR::DATUMR( ) : ParserKeyword("DATUMR")
{
setFixedSize( (size_t) 1);
DATUMR::DATUMR() : ParserKeyword("DATUMR", KeywordSize(1, false)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("DATUMR");
@@ -97,9 +90,7 @@ const std::string DATUMR::keywordName = "DATUMR";
const std::string DATUMR::data::itemName = "data";
DATUMRX::DATUMRX( ) : ParserKeyword("DATUMRX")
{
setSizeType(SLASH_TERMINATED);
DATUMRX::DATUMRX() : ParserKeyword("DATUMRX", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("DATUMRX");
@@ -122,9 +113,7 @@ const std::string DATUMRX::REGION_FAMILY::itemName = "REGION_FAMILY";
const std::string DATUMRX::DEPTH::itemName = "DEPTH";
DCQDEFN::DCQDEFN( ) : ParserKeyword("DCQDEFN")
{
setFixedSize( (size_t) 1);
DCQDEFN::DCQDEFN() : ParserKeyword("DCQDEFN", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("DCQDEFN");
@@ -143,17 +132,15 @@ const std::string DCQDEFN::QUANTITY::itemName = "QUANTITY";
const std::string DCQDEFN::QUANTITY::defaultValue = "GAS";
DEBUG_::DEBUG_( ) : ParserKeyword("DEBUG_")
{
setFixedSize( (size_t) 1);
addValidSectionName("EDIT");
DEBUG_::DEBUG_() : ParserKeyword("DEBUG_", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("GRID");
addValidSectionName("EDIT");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SUMMARY");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("DEBUG");
{
@@ -773,9 +760,7 @@ const std::string DEBUG_::Item87::itemName = "Item87";
const int DEBUG_::Item87::defaultValue = 0;
DELAYACT::DELAYACT( ) : ParserKeyword("DELAYACT")
{
setFixedSize( (size_t) 1);
DELAYACT::DELAYACT() : ParserKeyword("DELAYACT", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("DELAYACT");
@@ -815,13 +800,10 @@ const std::string DELAYACT::DELAY::itemName = "DELAY";
const std::string DELAYACT::NUM_TIMES::itemName = "NUM_TIMES";
const int DELAYACT::NUM_TIMES::defaultValue = 1;
const std::string DELAYACT::INCREMENT::itemName = "INCREMENT";
const double DELAYACT::INCREMENT::defaultValue = 0.000000;
const double DELAYACT::INCREMENT::defaultValue = 0;
DENSITY::DENSITY( ) : ParserKeyword("DENSITY")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTPVT",0);
DENSITY::DENSITY() : ParserKeyword("DENSITY", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("DENSITY");
@@ -857,9 +839,7 @@ const std::string DENSITY::GAS::itemName = "GAS";
const double DENSITY::GAS::defaultValue = 1.000000;
DEPTH::DEPTH( ) : ParserKeyword("DEPTH")
{
setFixedSize( (size_t) 1);
DEPTH::DEPTH() : ParserKeyword("DEPTH", KeywordSize(1, false)) {
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("DEPTH");
@@ -877,10 +857,7 @@ const std::string DEPTH::keywordName = "DEPTH";
const std::string DEPTH::data::itemName = "data";
DEPTHTAB::DEPTHTAB( ) : ParserKeyword("DEPTHTAB")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("RIVRDIMS","NMDEPT",0);
DEPTHTAB::DEPTHTAB() : ParserKeyword("DEPTHTAB", KeywordSize("RIVRDIMS", "NMDEPT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("DEPTHTAB");
@@ -898,9 +875,7 @@ const std::string DEPTHTAB::keywordName = "DEPTHTAB";
const std::string DEPTHTAB::DATA::itemName = "DATA";
DEPTHZ::DEPTHZ( ) : ParserKeyword("DEPTHZ")
{
setFixedSize( (size_t) 1);
DEPTHZ::DEPTHZ() : ParserKeyword("DEPTHZ", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DEPTHZ");
@@ -919,9 +894,7 @@ const std::string DEPTHZ::keywordName = "DEPTHZ";
const std::string DEPTHZ::data::itemName = "data";
DIAGDISP::DIAGDISP( ) : ParserKeyword("DIAGDISP")
{
setFixedSize( (size_t) 0);
DIAGDISP::DIAGDISP() : ParserKeyword("DIAGDISP", KeywordSize(0, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("DIAGDISP");
@@ -929,12 +902,14 @@ DIAGDISP::DIAGDISP( ) : ParserKeyword("DIAGDISP")
const std::string DIAGDISP::keywordName = "DIAGDISP";
DIFF::DIFF( ) : ParserKeyword("DIFF")
{
setFixedSize( (size_t) 1);
DIFF::DIFF() : ParserKeyword("DIFF", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DIFF");
addDeckName("DIFFMR-");
addDeckName("DIFFMZ-");
addDeckName("DIFFMTH-");
addDeckName("DIFFMX-");
addDeckName("DIFFMY-");
{
ParserRecord record;
{
@@ -952,10 +927,7 @@ const std::string DIFF::data::itemName = "data";
const double DIFF::data::defaultValue = 1.000000;
DIFFC::DIFFC( ) : ParserKeyword("DIFFC")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTPVT",0);
DIFFC::DIFFC() : ParserKeyword("DIFFC", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("DIFFC");
@@ -963,10 +935,12 @@ DIFFC::DIFFC( ) : ParserKeyword("DIFFC")
ParserRecord record;
{
ParserItem item("OIL_MOL_WEIGHT", ParserItem::itype::DOUBLE);
item.push_backDimension("1");
record.addItem(item);
}
{
ParserItem item("GAS_MOL_WEIGHT", ParserItem::itype::DOUBLE);
item.push_backDimension("1");
record.addItem(item);
}
{
@@ -991,11 +965,13 @@ DIFFC::DIFFC( ) : ParserKeyword("DIFFC")
}
{
ParserItem item("GAS_OIL_CROSS_DIFF_COEFF", ParserItem::itype::DOUBLE);
item.setDefault( double(0) );
item.push_backDimension("Length*Length/Time");
record.addItem(item);
}
{
ParserItem item("OIL_OIL_CROSS_DIFF_COEFF", ParserItem::itype::DOUBLE);
item.setDefault( double(0) );
item.push_backDimension("Length*Length/Time");
record.addItem(item);
}
@@ -1010,13 +986,12 @@ const std::string DIFFC::OIL_GAS_DIFF_COEFF::itemName = "OIL_GAS_DIFF_COEFF";
const std::string DIFFC::GAS_OIL_DIFF_COEFF::itemName = "GAS_OIL_DIFF_COEFF";
const std::string DIFFC::OIL_OIL_DIFF_COEFF::itemName = "OIL_OIL_DIFF_COEFF";
const std::string DIFFC::GAS_OIL_CROSS_DIFF_COEFF::itemName = "GAS_OIL_CROSS_DIFF_COEFF";
const double DIFFC::GAS_OIL_CROSS_DIFF_COEFF::defaultValue = 0;
const std::string DIFFC::OIL_OIL_CROSS_DIFF_COEFF::itemName = "OIL_OIL_CROSS_DIFF_COEFF";
const double DIFFC::OIL_OIL_CROSS_DIFF_COEFF::defaultValue = 0;
DIFFCOAL::DIFFCOAL( ) : ParserKeyword("DIFFCOAL")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("REGDIMS","NTCREG",0);
DIFFCOAL::DIFFCOAL() : ParserKeyword("DIFFCOAL", KeywordSize("REGDIMS", "NTCREG", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("DIFFCOAL");
@@ -1048,9 +1023,7 @@ const double DIFFCOAL::RE_ADSORB_FRACTION::defaultValue = 1.000000;
const std::string DIFFCOAL::SOL_DIFF_COEFF::itemName = "SOL_DIFF_COEFF";
DIFFDP::DIFFDP( ) : ParserKeyword("DIFFDP")
{
setFixedSize( (size_t) 0);
DIFFDP::DIFFDP() : ParserKeyword("DIFFDP", KeywordSize(0, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("DIFFDP");
@@ -1058,9 +1031,7 @@ DIFFDP::DIFFDP( ) : ParserKeyword("DIFFDP")
const std::string DIFFDP::keywordName = "DIFFDP";
DIFFMMF::DIFFMMF( ) : ParserKeyword("DIFFMMF")
{
setFixedSize( (size_t) 1);
DIFFMMF::DIFFMMF() : ParserKeyword("DIFFMMF", KeywordSize(1, false)) {
addValidSectionName("GRID");
addValidSectionName("SCHEDULE");
clearDeckNames();
@@ -1082,9 +1053,7 @@ const std::string DIFFMMF::data::itemName = "data";
const double DIFFMMF::data::defaultValue = 1.000000;
DIFFMR::DIFFMR( ) : ParserKeyword("DIFFMR")
{
setFixedSize( (size_t) 1);
DIFFMR::DIFFMR() : ParserKeyword("DIFFMR", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DIFFMR");
@@ -1105,9 +1074,7 @@ const std::string DIFFMR::data::itemName = "data";
const double DIFFMR::data::defaultValue = 1.000000;
DIFFMTHT::DIFFMTHT( ) : ParserKeyword("DIFFMTHT")
{
setFixedSize( (size_t) 1);
DIFFMTHT::DIFFMTHT() : ParserKeyword("DIFFMTHT", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DIFFMTHT");
@@ -1128,9 +1095,7 @@ const std::string DIFFMTHT::data::itemName = "data";
const double DIFFMTHT::data::defaultValue = 1.000000;
DIFFMX::DIFFMX( ) : ParserKeyword("DIFFMX")
{
setFixedSize( (size_t) 1);
DIFFMX::DIFFMX() : ParserKeyword("DIFFMX", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DIFFMX");
@@ -1151,9 +1116,7 @@ const std::string DIFFMX::data::itemName = "data";
const double DIFFMX::data::defaultValue = 1.000000;
DIFFMY::DIFFMY( ) : ParserKeyword("DIFFMY")
{
setFixedSize( (size_t) 1);
DIFFMY::DIFFMY() : ParserKeyword("DIFFMY", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DIFFMY");
@@ -1174,9 +1137,7 @@ const std::string DIFFMY::data::itemName = "data";
const double DIFFMY::data::defaultValue = 1.000000;
DIFFMZ::DIFFMZ( ) : ParserKeyword("DIFFMZ")
{
setFixedSize( (size_t) 1);
DIFFMZ::DIFFMZ() : ParserKeyword("DIFFMZ", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DIFFMZ");
@@ -1197,9 +1158,7 @@ const std::string DIFFMZ::data::itemName = "data";
const double DIFFMZ::data::defaultValue = 1.000000;
DIFFR::DIFFR( ) : ParserKeyword("DIFFR")
{
setFixedSize( (size_t) 1);
DIFFR::DIFFR() : ParserKeyword("DIFFR", KeywordSize(1, false)) {
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("DIFFR");
@@ -1218,9 +1177,7 @@ const std::string DIFFR::keywordName = "DIFFR";
const std::string DIFFR::data::itemName = "data";
DIFFTHT::DIFFTHT( ) : ParserKeyword("DIFFTHT")
{
setFixedSize( (size_t) 1);
DIFFTHT::DIFFTHT() : ParserKeyword("DIFFTHT", KeywordSize(1, false)) {
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("DIFFTHT");
@@ -1239,9 +1196,7 @@ const std::string DIFFTHT::keywordName = "DIFFTHT";
const std::string DIFFTHT::data::itemName = "data";
DIFFUSE::DIFFUSE( ) : ParserKeyword("DIFFUSE")
{
setFixedSize( (size_t) 0);
DIFFUSE::DIFFUSE() : ParserKeyword("DIFFUSE", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("DIFFUSE");
@@ -1249,9 +1204,7 @@ DIFFUSE::DIFFUSE( ) : ParserKeyword("DIFFUSE")
const std::string DIFFUSE::keywordName = "DIFFUSE";
DIFFX::DIFFX( ) : ParserKeyword("DIFFX")
{
setFixedSize( (size_t) 1);
DIFFX::DIFFX() : ParserKeyword("DIFFX", KeywordSize(1, false)) {
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("DIFFX");
@@ -1270,9 +1223,7 @@ const std::string DIFFX::keywordName = "DIFFX";
const std::string DIFFX::data::itemName = "data";
DIFFY::DIFFY( ) : ParserKeyword("DIFFY")
{
setFixedSize( (size_t) 1);
DIFFY::DIFFY() : ParserKeyword("DIFFY", KeywordSize(1, false)) {
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("DIFFY");
@@ -1291,9 +1242,7 @@ const std::string DIFFY::keywordName = "DIFFY";
const std::string DIFFY::data::itemName = "data";
DIFFZ::DIFFZ( ) : ParserKeyword("DIFFZ")
{
setFixedSize( (size_t) 1);
DIFFZ::DIFFZ() : ParserKeyword("DIFFZ", KeywordSize(1, false)) {
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("DIFFZ");
@@ -1312,9 +1261,7 @@ const std::string DIFFZ::keywordName = "DIFFZ";
const std::string DIFFZ::data::itemName = "data";
DIMENS::DIMENS( ) : ParserKeyword("DIMENS")
{
setFixedSize( (size_t) 1);
DIMENS::DIMENS() : ParserKeyword("DIMENS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("DIMENS");
@@ -1341,9 +1288,7 @@ const std::string DIMENS::NY::itemName = "NY";
const std::string DIMENS::NZ::itemName = "NZ";
DIMPES::DIMPES( ) : ParserKeyword("DIMPES")
{
setFixedSize( (size_t) 1);
DIMPES::DIMPES() : ParserKeyword("DIMPES", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("DIMPES");
@@ -1379,9 +1324,7 @@ const std::string DIMPES::DPMAX::itemName = "DPMAX";
const double DIMPES::DPMAX::defaultValue = 13.790000;
DIMPLICT::DIMPLICT( ) : ParserKeyword("DIMPLICT")
{
setFixedSize( (size_t) 0);
DIMPLICT::DIMPLICT() : ParserKeyword("DIMPLICT", KeywordSize(0, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("DIMPLICT");
@@ -1389,9 +1332,7 @@ DIMPLICT::DIMPLICT( ) : ParserKeyword("DIMPLICT")
const std::string DIMPLICT::keywordName = "DIMPLICT";
DISGAS::DISGAS( ) : ParserKeyword("DISGAS")
{
setFixedSize( (size_t) 0);
DISGAS::DISGAS() : ParserKeyword("DISGAS", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("DISGAS");
@@ -1399,9 +1340,7 @@ DISGAS::DISGAS( ) : ParserKeyword("DISGAS")
const std::string DISGAS::keywordName = "DISGAS";
DISPDIMS::DISPDIMS( ) : ParserKeyword("DISPDIMS")
{
setFixedSize( (size_t) 1);
DISPDIMS::DISPDIMS() : ParserKeyword("DISPDIMS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("DISPDIMS");
@@ -1434,11 +1373,7 @@ const std::string DISPDIMS::MAX_CONCENTRATION_NODES::itemName = "MAX_CONCENTRATI
const int DISPDIMS::MAX_CONCENTRATION_NODES::defaultValue = 1;
DISPERSE::DISPERSE( ) : ParserKeyword("DISPERSE")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("DISPDIMS","MXDIST",0);
setTableCollection( true );
DISPERSE::DISPERSE() : ParserKeyword("DISPERSE", KeywordSize("DISPDIMS", "MXDIST", true, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("DISPERSE");
@@ -1464,9 +1399,7 @@ const std::string DISPERSE::VELOCITY::itemName = "VELOCITY";
const std::string DISPERSE::DATA::itemName = "DATA";
DOMAINS::DOMAINS( ) : ParserKeyword("DOMAINS")
{
setFixedSize( (size_t) 1);
DOMAINS::DOMAINS() : ParserKeyword("DOMAINS", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DOMAINS");
@@ -1485,9 +1418,7 @@ const std::string DOMAINS::keywordName = "DOMAINS";
const std::string DOMAINS::data::itemName = "data";
DPGRID::DPGRID( ) : ParserKeyword("DPGRID")
{
setFixedSize( (size_t) 0);
DPGRID::DPGRID() : ParserKeyword("DPGRID", KeywordSize(0, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DPGRID");
@@ -1495,10 +1426,7 @@ DPGRID::DPGRID( ) : ParserKeyword("DPGRID")
const std::string DPGRID::keywordName = "DPGRID";
DPKRMOD::DPKRMOD( ) : ParserKeyword("DPKRMOD")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
DPKRMOD::DPKRMOD() : ParserKeyword("DPKRMOD", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("DPKRMOD");
@@ -1526,16 +1454,14 @@ DPKRMOD::DPKRMOD( ) : ParserKeyword("DPKRMOD")
}
const std::string DPKRMOD::keywordName = "DPKRMOD";
const std::string DPKRMOD::MOD_OIL_WAT_PERM::itemName = "MOD_OIL_WAT_PERM";
const double DPKRMOD::MOD_OIL_WAT_PERM::defaultValue = 0.000000;
const double DPKRMOD::MOD_OIL_WAT_PERM::defaultValue = 0;
const std::string DPKRMOD::MOD_OIL_GAS_PERM::itemName = "MOD_OIL_GAS_PERM";
const double DPKRMOD::MOD_OIL_GAS_PERM::defaultValue = 0.000000;
const double DPKRMOD::MOD_OIL_GAS_PERM::defaultValue = 0;
const std::string DPKRMOD::SCALE_PERM_FRACTURE::itemName = "SCALE_PERM_FRACTURE";
const std::string DPKRMOD::SCALE_PERM_FRACTURE::defaultValue = "YES";
DPNUM::DPNUM( ) : ParserKeyword("DPNUM")
{
setFixedSize( (size_t) 1);
DPNUM::DPNUM() : ParserKeyword("DPNUM", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DPNUM");
@@ -1553,9 +1479,7 @@ const std::string DPNUM::keywordName = "DPNUM";
const std::string DPNUM::VALUE::itemName = "VALUE";
DR::DR( ) : ParserKeyword("DR")
{
setFixedSize( (size_t) 1);
DR::DR() : ParserKeyword("DR", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DR");
@@ -1574,10 +1498,7 @@ const std::string DR::keywordName = "DR";
const std::string DR::data::itemName = "data";
DREF::DREF( ) : ParserKeyword("DREF")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NUM_STATE_EQ",0);
DREF::DREF() : ParserKeyword("DREF", KeywordSize("TABDIMS", "NUM_STATE_EQ", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("DREF");
@@ -1596,10 +1517,7 @@ const std::string DREF::keywordName = "DREF";
const std::string DREF::DENSITY::itemName = "DENSITY";
DREFS::DREFS( ) : ParserKeyword("DREFS")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NUM_STATE_EQ",0);
DREFS::DREFS() : ParserKeyword("DREFS", KeywordSize("TABDIMS", "NUM_STATE_EQ", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("DREFS");
@@ -1618,9 +1536,7 @@ const std::string DREFS::keywordName = "DREFS";
const std::string DREFS::DENSITY::itemName = "DENSITY";
DRILPRI::DRILPRI( ) : ParserKeyword("DRILPRI")
{
setFixedSize( (size_t) 1);
DRILPRI::DRILPRI() : ParserKeyword("DRILPRI", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("DRILPRI");
@@ -1688,32 +1604,30 @@ DRILPRI::DRILPRI( ) : ParserKeyword("DRILPRI")
}
const std::string DRILPRI::keywordName = "DRILPRI";
const std::string DRILPRI::INTERVAL::itemName = "INTERVAL";
const double DRILPRI::INTERVAL::defaultValue = 0.000000;
const double DRILPRI::INTERVAL::defaultValue = 0;
const std::string DRILPRI::A::itemName = "A";
const double DRILPRI::A::defaultValue = 0.000000;
const double DRILPRI::A::defaultValue = 0;
const std::string DRILPRI::B::itemName = "B";
const double DRILPRI::B::defaultValue = 0.000000;
const double DRILPRI::B::defaultValue = 0;
const std::string DRILPRI::C::itemName = "C";
const double DRILPRI::C::defaultValue = 0.000000;
const double DRILPRI::C::defaultValue = 0;
const std::string DRILPRI::D::itemName = "D";
const double DRILPRI::D::defaultValue = 0.000000;
const double DRILPRI::D::defaultValue = 0;
const std::string DRILPRI::E::itemName = "E";
const double DRILPRI::E::defaultValue = 0.000000;
const double DRILPRI::E::defaultValue = 0;
const std::string DRILPRI::F::itemName = "F";
const double DRILPRI::F::defaultValue = 0.000000;
const double DRILPRI::F::defaultValue = 0;
const std::string DRILPRI::G::itemName = "G";
const double DRILPRI::G::defaultValue = 0.000000;
const double DRILPRI::G::defaultValue = 0;
const std::string DRILPRI::H::itemName = "H";
const double DRILPRI::H::defaultValue = 0.000000;
const double DRILPRI::H::defaultValue = 0;
const std::string DRILPRI::LOOK_AHEAD::itemName = "LOOK_AHEAD";
const double DRILPRI::LOOK_AHEAD::defaultValue = 0.000000;
const double DRILPRI::LOOK_AHEAD::defaultValue = 0;
const std::string DRILPRI::CALCULATION::itemName = "CALCULATION";
const std::string DRILPRI::CALCULATION::defaultValue = "SINGLE";
DRSDT::DRSDT( ) : ParserKeyword("DRSDT")
{
setFixedSize( (size_t) 1);
DRSDT::DRSDT() : ParserKeyword("DRSDT", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("DRSDT");
@@ -1725,7 +1639,7 @@ DRSDT::DRSDT( ) : ParserKeyword("DRSDT")
record.addItem(item);
}
{
ParserItem item("Option", ParserItem::itype::STRING);
ParserItem item("OPTION", ParserItem::itype::STRING);
item.setDefault( std::string("ALL") );
record.addItem(item);
}
@@ -1734,14 +1648,36 @@ DRSDT::DRSDT( ) : ParserKeyword("DRSDT")
}
const std::string DRSDT::keywordName = "DRSDT";
const std::string DRSDT::DRSDT_MAX::itemName = "DRSDT_MAX";
const std::string DRSDT::Option::itemName = "Option";
const std::string DRSDT::Option::defaultValue = "ALL";
const std::string DRSDT::OPTION::itemName = "OPTION";
const std::string DRSDT::OPTION::defaultValue = "ALL";
DRSDTR::DRSDTR( ) : ParserKeyword("DRSDTR")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTPVT",0);
DRSDTCON::DRSDTCON() : ParserKeyword("DRSDTCON", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("DRSDTCON");
{
ParserRecord record;
{
ParserItem item("DRSDT_MAX", ParserItem::itype::DOUBLE);
item.push_backDimension("1");
record.addItem(item);
}
{
ParserItem item("OPTION", ParserItem::itype::STRING);
item.setDefault( std::string("ALL") );
record.addItem(item);
}
addRecord( record );
}
}
const std::string DRSDTCON::keywordName = "DRSDTCON";
const std::string DRSDTCON::DRSDT_MAX::itemName = "DRSDT_MAX";
const std::string DRSDTCON::OPTION::itemName = "OPTION";
const std::string DRSDTCON::OPTION::defaultValue = "ALL";
DRSDTR::DRSDTR() : ParserKeyword("DRSDTR", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("DRSDTR");
@@ -1753,7 +1689,7 @@ DRSDTR::DRSDTR( ) : ParserKeyword("DRSDTR")
record.addItem(item);
}
{
ParserItem item("Option", ParserItem::itype::STRING);
ParserItem item("OPTION", ParserItem::itype::STRING);
item.setDefault( std::string("ALL") );
record.addItem(item);
}
@@ -1762,13 +1698,11 @@ DRSDTR::DRSDTR( ) : ParserKeyword("DRSDTR")
}
const std::string DRSDTR::keywordName = "DRSDTR";
const std::string DRSDTR::DRSDT_MAX::itemName = "DRSDT_MAX";
const std::string DRSDTR::Option::itemName = "Option";
const std::string DRSDTR::Option::defaultValue = "ALL";
const std::string DRSDTR::OPTION::itemName = "OPTION";
const std::string DRSDTR::OPTION::defaultValue = "ALL";
DRV::DRV( ) : ParserKeyword("DRV")
{
setFixedSize( (size_t) 1);
DRV::DRV() : ParserKeyword("DRV", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DRV");
@@ -1787,9 +1721,7 @@ const std::string DRV::keywordName = "DRV";
const std::string DRV::data::itemName = "data";
DRVDT::DRVDT( ) : ParserKeyword("DRVDT")
{
setFixedSize( (size_t) 1);
DRVDT::DRVDT() : ParserKeyword("DRVDT", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("DRVDT");
@@ -1807,10 +1739,7 @@ const std::string DRVDT::keywordName = "DRVDT";
const std::string DRVDT::DRVDT_MAX::itemName = "DRVDT_MAX";
DRVDTR::DRVDTR( ) : ParserKeyword("DRVDTR")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTPVT",0);
DRVDTR::DRVDTR() : ParserKeyword("DRVDTR", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("DRVDTR");
@@ -1828,9 +1757,7 @@ const std::string DRVDTR::keywordName = "DRVDTR";
const std::string DRVDTR::DRVDT_MAX::itemName = "DRVDT_MAX";
DSPDEINT::DSPDEINT( ) : ParserKeyword("DSPDEINT")
{
setFixedSize( (size_t) 0);
DSPDEINT::DSPDEINT() : ParserKeyword("DSPDEINT", KeywordSize(0, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("DSPDEINT");
@@ -1838,9 +1765,7 @@ DSPDEINT::DSPDEINT( ) : ParserKeyword("DSPDEINT")
const std::string DSPDEINT::keywordName = "DSPDEINT";
DTHETA::DTHETA( ) : ParserKeyword("DTHETA")
{
setFixedSize( (size_t) 1);
DTHETA::DTHETA() : ParserKeyword("DTHETA", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DTHETA");
@@ -1859,9 +1784,7 @@ const std::string DTHETA::keywordName = "DTHETA";
const std::string DTHETA::data::itemName = "data";
DTHETAV::DTHETAV( ) : ParserKeyword("DTHETAV")
{
setFixedSize( (size_t) 1);
DTHETAV::DTHETAV() : ParserKeyword("DTHETAV", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DTHETAV");
@@ -1880,9 +1803,7 @@ const std::string DTHETAV::keywordName = "DTHETAV";
const std::string DTHETAV::data::itemName = "data";
DUALPERM::DUALPERM( ) : ParserKeyword("DUALPERM")
{
setFixedSize( (size_t) 0);
DUALPERM::DUALPERM() : ParserKeyword("DUALPERM", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("DUALPERM");
@@ -1890,9 +1811,7 @@ DUALPERM::DUALPERM( ) : ParserKeyword("DUALPERM")
const std::string DUALPERM::keywordName = "DUALPERM";
DUALPORO::DUALPORO( ) : ParserKeyword("DUALPORO")
{
setFixedSize( (size_t) 0);
DUALPORO::DUALPORO() : ParserKeyword("DUALPORO", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("DUALPORO");
@@ -1900,9 +1819,7 @@ DUALPORO::DUALPORO( ) : ParserKeyword("DUALPORO")
const std::string DUALPORO::keywordName = "DUALPORO";
DUMPCUPL::DUMPCUPL( ) : ParserKeyword("DUMPCUPL")
{
setFixedSize( (size_t) 1);
DUMPCUPL::DUMPCUPL() : ParserKeyword("DUMPCUPL", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("DUMPCUPL");
@@ -1919,9 +1836,7 @@ const std::string DUMPCUPL::keywordName = "DUMPCUPL";
const std::string DUMPCUPL::VALUE::itemName = "VALUE";
DUMPFLUX::DUMPFLUX( ) : ParserKeyword("DUMPFLUX")
{
setFixedSize( (size_t) 0);
DUMPFLUX::DUMPFLUX() : ParserKeyword("DUMPFLUX", KeywordSize(0, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DUMPFLUX");
@@ -1929,10 +1844,11 @@ DUMPFLUX::DUMPFLUX( ) : ParserKeyword("DUMPFLUX")
const std::string DUMPFLUX::keywordName = "DUMPFLUX";
DX::DX( ) : ParserKeyword("DX")
{
setFixedSize( (size_t) 1);
DX::DX() : ParserKeyword("DX", KeywordSize(1, false)) {
addValidSectionName("GRID");
setProhibitedKeywords({
"DXV",
});
clearDeckNames();
addDeckName("DX");
{
@@ -1950,10 +1866,11 @@ const std::string DX::keywordName = "DX";
const std::string DX::data::itemName = "data";
DXV::DXV( ) : ParserKeyword("DXV")
{
setFixedSize( (size_t) 1);
DXV::DXV() : ParserKeyword("DXV", KeywordSize(1, false)) {
addValidSectionName("GRID");
setProhibitedKeywords({
"DX",
});
clearDeckNames();
addDeckName("DXV");
{
@@ -1971,10 +1888,11 @@ const std::string DXV::keywordName = "DXV";
const std::string DXV::data::itemName = "data";
DY::DY( ) : ParserKeyword("DY")
{
setFixedSize( (size_t) 1);
DY::DY() : ParserKeyword("DY", KeywordSize(1, false)) {
addValidSectionName("GRID");
setProhibitedKeywords({
"DYV",
});
clearDeckNames();
addDeckName("DY");
{
@@ -1992,11 +1910,9 @@ const std::string DY::keywordName = "DY";
const std::string DY::data::itemName = "data";
DYNAMICR::DYNAMICR( ) : ParserKeyword("DYNAMICR")
{
setSizeType(FIXED_CODE);
addValidSectionName("SCHEDULE");
DYNAMICR::DYNAMICR() : ParserKeyword("DYNAMICR", KeywordSize(1, true)) {
addValidSectionName("SOLUTION");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("DYNAMICR");
setCodeEnd("ENDDYN");
@@ -2014,9 +1930,7 @@ const std::string DYNAMICR::keywordName = "DYNAMICR";
const std::string DYNAMICR::code::itemName = "code";
DYNRDIMS::DYNRDIMS( ) : ParserKeyword("DYNRDIMS")
{
setFixedSize( (size_t) 1);
DYNRDIMS::DYNRDIMS() : ParserKeyword("DYNRDIMS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("DYNRDIMS");
@@ -2049,10 +1963,11 @@ const std::string DYNRDIMS::MXDYNR::itemName = "MXDYNR";
const int DYNRDIMS::MXDYNR::defaultValue = 0;
DYV::DYV( ) : ParserKeyword("DYV")
{
setFixedSize( (size_t) 1);
DYV::DYV() : ParserKeyword("DYV", KeywordSize(1, false)) {
addValidSectionName("GRID");
setProhibitedKeywords({
"DY",
});
clearDeckNames();
addDeckName("DYV");
{
@@ -2070,9 +1985,7 @@ const std::string DYV::keywordName = "DYV";
const std::string DYV::data::itemName = "data";
DZ::DZ( ) : ParserKeyword("DZ")
{
setFixedSize( (size_t) 1);
DZ::DZ() : ParserKeyword("DZ", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DZ");
@@ -2091,9 +2004,7 @@ const std::string DZ::keywordName = "DZ";
const std::string DZ::data::itemName = "data";
DZMATRIX::DZMATRIX( ) : ParserKeyword("DZMATRIX")
{
setFixedSize( (size_t) 1);
DZMATRIX::DZMATRIX() : ParserKeyword("DZMATRIX", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DZMATRIX");
@@ -2111,12 +2022,10 @@ DZMATRIX::DZMATRIX( ) : ParserKeyword("DZMATRIX")
}
const std::string DZMATRIX::keywordName = "DZMATRIX";
const std::string DZMATRIX::data::itemName = "data";
const double DZMATRIX::data::defaultValue = 0.000000;
const double DZMATRIX::data::defaultValue = 0;
DZMTRX::DZMTRX( ) : ParserKeyword("DZMTRX")
{
setFixedSize( (size_t) 1);
DZMTRX::DZMTRX() : ParserKeyword("DZMTRX", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DZMTRX");
@@ -2134,12 +2043,10 @@ DZMTRX::DZMTRX( ) : ParserKeyword("DZMTRX")
}
const std::string DZMTRX::keywordName = "DZMTRX";
const std::string DZMTRX::data::itemName = "data";
const double DZMTRX::data::defaultValue = 0.000000;
const double DZMTRX::data::defaultValue = 0;
DZMTRXV::DZMTRXV( ) : ParserKeyword("DZMTRXV")
{
setFixedSize( (size_t) 1);
DZMTRXV::DZMTRXV() : ParserKeyword("DZMTRXV", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DZMTRXV");
@@ -2157,12 +2064,10 @@ DZMTRXV::DZMTRXV( ) : ParserKeyword("DZMTRXV")
}
const std::string DZMTRXV::keywordName = "DZMTRXV";
const std::string DZMTRXV::data::itemName = "data";
const double DZMTRXV::data::defaultValue = 0.000000;
const double DZMTRXV::data::defaultValue = 0;
DZNET::DZNET( ) : ParserKeyword("DZNET")
{
setFixedSize( (size_t) 1);
DZNET::DZNET() : ParserKeyword("DZNET", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DZNET");
@@ -2181,9 +2086,7 @@ const std::string DZNET::keywordName = "DZNET";
const std::string DZNET::data::itemName = "data";
DZV::DZV( ) : ParserKeyword("DZV")
{
setFixedSize( (size_t) 1);
DZV::DZV() : ParserKeyword("DZV", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("DZV");

591
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/E.cpp vendored
View File

@@ -1,35 +1,32 @@
#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/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/parser/eclipse/Parser/ParserKeywords/E.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/E.hpp>
namespace Opm {
namespace ParserKeywords {
ECHO::ECHO( ) : ParserKeyword("ECHO")
{
setFixedSize( (size_t) 0);
ECHO::ECHO() : ParserKeyword("ECHO", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SUMMARY");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("ECHO");
}
const std::string ECHO::keywordName = "ECHO";
ECLMC::ECLMC( ) : ParserKeyword("ECLMC")
{
setFixedSize( (size_t) 0);
ECLMC::ECLMC() : ParserKeyword("ECLMC", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("ECLMC");
@@ -37,18 +34,14 @@ ECLMC::ECLMC( ) : ParserKeyword("ECLMC")
const std::string ECLMC::keywordName = "ECLMC";
EDIT::EDIT( ) : ParserKeyword("EDIT")
{
setFixedSize( (size_t) 0);
EDIT::EDIT() : ParserKeyword("EDIT", KeywordSize(0, false)) {
clearDeckNames();
addDeckName("EDIT");
}
const std::string EDIT::keywordName = "EDIT";
EDITNNC::EDITNNC( ) : ParserKeyword("EDITNNC")
{
setSizeType(SLASH_TERMINATED);
EDITNNC::EDITNNC() : ParserKeyword("EDITNNC", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("EDITNNC");
@@ -130,9 +123,7 @@ const std::string EDITNNC::FACE_FLOW21::itemName = "FACE_FLOW21";
const std::string EDITNNC::DIFFM::itemName = "DIFFM";
EDITNNCR::EDITNNCR( ) : ParserKeyword("EDITNNCR")
{
setSizeType(SLASH_TERMINATED);
EDITNNCR::EDITNNCR() : ParserKeyword("EDITNNCR", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("EDITNNCR");
@@ -215,9 +206,7 @@ const std::string EDITNNCR::FACE_FLOW21::itemName = "FACE_FLOW21";
const std::string EDITNNCR::DIFF::itemName = "DIFF";
EHYSTR::EHYSTR( ) : ParserKeyword("EHYSTR")
{
setFixedSize( (size_t) 1);
EHYSTR::EHYSTR() : ParserKeyword("EHYSTR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("EHYSTR");
@@ -283,6 +272,11 @@ EHYSTR::EHYSTR( ) : ParserKeyword("EHYSTR")
item.setDefault( double(0) );
record.addItem(item);
}
{
ParserItem item("FLAG_SOMETHING", ParserItem::itype::INT);
item.setDefault( 0 );
record.addItem(item);
}
addRecord( record );
}
}
@@ -310,13 +304,12 @@ const std::string EHYSTR::baker_flag_gas::defaultValue = "NO";
const std::string EHYSTR::baker_flag_water::itemName = "baker_flag_water";
const std::string EHYSTR::baker_flag_water::defaultValue = "NO";
const std::string EHYSTR::threshold_saturation::itemName = "threshold_saturation";
const double EHYSTR::threshold_saturation::defaultValue = 0.000000;
const double EHYSTR::threshold_saturation::defaultValue = 0;
const std::string EHYSTR::FLAG_SOMETHING::itemName = "FLAG_SOMETHING";
const int EHYSTR::FLAG_SOMETHING::defaultValue = 0;
EHYSTRR::EHYSTRR( ) : ParserKeyword("EHYSTRR")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
EHYSTRR::EHYSTRR() : ParserKeyword("EHYSTRR", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("EHYSTRR");
@@ -349,26 +342,22 @@ const std::string EHYSTRR::mod_param_non_wet_phase_sat::itemName = "mod_param_no
const double EHYSTRR::mod_param_non_wet_phase_sat::defaultValue = 0.100000;
END::END( ) : ParserKeyword("END")
{
setFixedSize( (size_t) 0);
addValidSectionName("EDIT");
END::END() : ParserKeyword("END", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("GRID");
addValidSectionName("EDIT");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SUMMARY");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("END");
}
const std::string END::keywordName = "END";
ENDACTIO::ENDACTIO( ) : ParserKeyword("ENDACTIO")
{
setFixedSize( (size_t) 0);
ENDACTIO::ENDACTIO() : ParserKeyword("ENDACTIO", KeywordSize(0, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("ENDACTIO");
@@ -376,67 +365,57 @@ ENDACTIO::ENDACTIO( ) : ParserKeyword("ENDACTIO")
const std::string ENDACTIO::keywordName = "ENDACTIO";
ENDBOX::ENDBOX( ) : ParserKeyword("ENDBOX")
{
setFixedSize( (size_t) 0);
ENDBOX::ENDBOX() : ParserKeyword("ENDBOX", KeywordSize(0, false)) {
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("ENDBOX");
}
const std::string ENDBOX::keywordName = "ENDBOX";
ENDDYN::ENDDYN( ) : ParserKeyword("ENDDYN")
{
setFixedSize( (size_t) 0);
addValidSectionName("SCHEDULE");
ENDDYN::ENDDYN() : ParserKeyword("ENDDYN", KeywordSize(0, false)) {
addValidSectionName("SOLUTION");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("ENDDYN");
}
const std::string ENDDYN::keywordName = "ENDDYN";
ENDFIN::ENDFIN( ) : ParserKeyword("ENDFIN")
{
setFixedSize( (size_t) 0);
ENDFIN::ENDFIN() : ParserKeyword("ENDFIN", KeywordSize(0, false)) {
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("ENDFIN");
}
const std::string ENDFIN::keywordName = "ENDFIN";
ENDINC::ENDINC( ) : ParserKeyword("ENDINC")
{
setFixedSize( (size_t) 0);
ENDINC::ENDINC() : ParserKeyword("ENDINC", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SUMMARY");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("ENDINC");
}
const std::string ENDINC::keywordName = "ENDINC";
ENDNUM::ENDNUM( ) : ParserKeyword("ENDNUM")
{
setFixedSize( (size_t) 1);
ENDNUM::ENDNUM() : ParserKeyword("ENDNUM", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("ENDNUM");
@@ -454,202 +433,200 @@ const std::string ENDNUM::keywordName = "ENDNUM";
const std::string ENDNUM::data::itemName = "data";
ENDPOINT_SPECIFIERS::ENDPOINT_SPECIFIERS( ) : ParserKeyword("ENDPOINT_SPECIFIERS")
{
setFixedSize( (size_t) 1);
ENDPOINT_SPECIFIERS::ENDPOINT_SPECIFIERS() : ParserKeyword("ENDPOINT_SPECIFIERS", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("IKRG");
addDeckName("IKRGR");
addDeckName("IKRGRX");
addDeckName("IKRGRX-");
addDeckName("IKRGRY");
addDeckName("IKRGRY-");
addDeckName("IKRGRZ");
addDeckName("IKRGRZ-");
addDeckName("IKRGX");
addDeckName("IKRGX-");
addDeckName("IKRGY");
addDeckName("IKRGY-");
addDeckName("IKRGZ");
addDeckName("IKRGZ-");
addDeckName("IKRO");
addDeckName("IKRORG");
addDeckName("IKRORGX");
addDeckName("IKRORGX-");
addDeckName("IKRORGY");
addDeckName("IKRORGY-");
addDeckName("IKRORGZ");
addDeckName("IKRORGZ-");
addDeckName("IKRORW");
addDeckName("IKRORWX");
addDeckName("IKRORWX-");
addDeckName("IKRORWY");
addDeckName("IKRORWY-");
addDeckName("IKRORWZ");
addDeckName("IKRORWZ-");
addDeckName("IKROX-");
addDeckName("IKROY-");
addDeckName("IKROZ-");
addDeckName("IKRW");
addDeckName("IKRWR");
addDeckName("IKRWRX");
addDeckName("IKRWRX-");
addDeckName("IKRWRY");
addDeckName("IKRWRY-");
addDeckName("IKRWRZ");
addDeckName("IKRWRZ-");
addDeckName("IKRWX");
addDeckName("IKRWX-");
addDeckName("IKRWY");
addDeckName("IKRWY-");
addDeckName("IKRWZ");
addDeckName("IKRWZ-");
addDeckName("ISGCR");
addDeckName("ISGCRX");
addDeckName("ISGCRX-");
addDeckName("ISGCRY");
addDeckName("ISGCRY-");
addDeckName("ISGCRZ");
addDeckName("ISGCRZ-");
addDeckName("ISGU");
addDeckName("ISGUX");
addDeckName("ISGUX-");
addDeckName("ISGUY");
addDeckName("ISGUY-");
addDeckName("ISGUZ");
addDeckName("ISGUZ-");
addDeckName("ISOGCR");
addDeckName("ISOGCRX");
addDeckName("ISOGCRX-");
addDeckName("ISOGCRY");
addDeckName("ISOGCRY-");
addDeckName("ISOGCRZ");
addDeckName("ISOGCRZ-");
addDeckName("ISOWCR");
addDeckName("ISOWCRX");
addDeckName("ISOWCRX-");
addDeckName("ISOWCRY");
addDeckName("ISOWCRY-");
addDeckName("ISOWCRZ");
addDeckName("ISOWCRZ-");
addDeckName("ISWCR");
addDeckName("ISWCRX");
addDeckName("ISWCRX-");
addDeckName("ISWCRZ");
addDeckName("ISWCRZ-");
addDeckName("ISWL");
addDeckName("ISWLX");
addDeckName("ISWLX-");
addDeckName("ISWLY");
addDeckName("ISWLY-");
addDeckName("ISWLZ");
addDeckName("ISWLZ-");
addDeckName("ISWU");
addDeckName("ISWUX");
addDeckName("ISWUX-");
addDeckName("ISWUY");
addDeckName("ISWUY-");
addDeckName("ISWUZ");
addDeckName("ISWUZ-");
addDeckName("KRG");
addDeckName("KRGR");
addDeckName("KRGRX");
addDeckName("KRGRX-");
addDeckName("KRGRY");
addDeckName("KRGRY-");
addDeckName("KRGRZ");
addDeckName("KRGRZ-");
addDeckName("KRGX");
addDeckName("KRGX-");
addDeckName("KRGY");
addDeckName("KRGY-");
addDeckName("KRGZ");
addDeckName("KRGZ-");
addDeckName("KRO");
addDeckName("KRORG");
addDeckName("KRORGX");
addDeckName("KRORGX-");
addDeckName("KRORGY");
addDeckName("KRORGY-");
addDeckName("KRORGZ");
addDeckName("KRORGZ-");
addDeckName("KRGR");
addDeckName("IKRGRZ-");
addDeckName("KRGZ");
addDeckName("IKRGX-");
addDeckName("ISOWCRX-");
addDeckName("KRG");
addDeckName("IKRORWY-");
addDeckName("SWCRZ-");
addDeckName("KRGX");
addDeckName("KRGY");
addDeckName("IKRO");
addDeckName("KRORG");
addDeckName("KRGX-");
addDeckName("KRGY-");
addDeckName("SWLX");
addDeckName("KRGZ-");
addDeckName("KRGRX");
addDeckName("KRGRY");
addDeckName("IKROX-");
addDeckName("KRO");
addDeckName("KRORGX-");
addDeckName("KRGRZ");
addDeckName("KRGRX-");
addDeckName("KRGRY-");
addDeckName("IKRORGY");
addDeckName("SOWCRY");
addDeckName("KRGRZ-");
addDeckName("IKRGRY-");
addDeckName("IKRG");
addDeckName("ISOWCR");
addDeckName("IKRORWX-");
addDeckName("IKRGX");
addDeckName("ISOWCRX");
addDeckName("KRORWX-");
addDeckName("IKRGY");
addDeckName("ISOWCRY");
addDeckName("IKRGZ");
addDeckName("ISOWCRZ");
addDeckName("IKRGY-");
addDeckName("ISOWCRY-");
addDeckName("IKRGZ-");
addDeckName("ISWUX");
addDeckName("ISOWCRZ-");
addDeckName("KRORWZ");
addDeckName("IKRGR");
addDeckName("IKRORWZ-");
addDeckName("SWCRY-");
addDeckName("IKRGRX");
addDeckName("IKRGRY");
addDeckName("ISGUY-");
addDeckName("IKRGRZ");
addDeckName("IKRORGX");
addDeckName("SOWCRX");
addDeckName("IKRGRX-");
addDeckName("KROX");
addDeckName("KROY");
addDeckName("KROZ");
addDeckName("KROX-");
addDeckName("ISOGCR");
addDeckName("IKRORWX");
addDeckName("KROY-");
addDeckName("KROZ-");
addDeckName("KRORW");
addDeckName("KRORWX");
addDeckName("KRORWX-");
addDeckName("KRORWY");
addDeckName("KRORWY-");
addDeckName("KRORWZ");
addDeckName("KRORWZ-");
addDeckName("KROX");
addDeckName("KROX-");
addDeckName("KROY");
addDeckName("KROY-");
addDeckName("KROZ");
addDeckName("KROZ-");
addDeckName("KRORGX");
addDeckName("KRORGZ");
addDeckName("SOGCRZ-");
addDeckName("IKROY-");
addDeckName("KRORGY-");
addDeckName("IKROZ-");
addDeckName("KRORGZ-");
addDeckName("IKRORW");
addDeckName("IKRORWY");
addDeckName("KRWZ-");
addDeckName("SWCRZ");
addDeckName("IKRORWZ");
addDeckName("SOGCR");
addDeckName("SWCRY");
addDeckName("IKRORG");
addDeckName("SOWCR");
addDeckName("IKRORGZ");
addDeckName("SOWCRZ");
addDeckName("IKRORGX-");
addDeckName("SOWCRX-");
addDeckName("IKRORGY-");
addDeckName("SOWCRY-");
addDeckName("IKRORGZ-");
addDeckName("SOWCRZ-");
addDeckName("KRW");
addDeckName("KRWX");
addDeckName("KRWY");
addDeckName("KRWZ");
addDeckName("KRWX-");
addDeckName("KRWY-");
addDeckName("KRWR");
addDeckName("KRWRX");
addDeckName("KRWRX-");
addDeckName("KRWRY");
addDeckName("KRWRY-");
addDeckName("KRWRZ");
addDeckName("KRWRX-");
addDeckName("KRWRY-");
addDeckName("KRWRZ-");
addDeckName("KRWX");
addDeckName("KRWX-");
addDeckName("KRWY");
addDeckName("KRWY-");
addDeckName("KRWZ");
addDeckName("KRWZ-");
addDeckName("SGCR");
addDeckName("SGCRX");
addDeckName("SGCRX-");
addDeckName("SGCRY");
addDeckName("SGCRY-");
addDeckName("SGCRZ");
addDeckName("SGCRZ-");
addDeckName("SGU");
addDeckName("SGUX");
addDeckName("SGUX-");
addDeckName("SGUY");
addDeckName("SGUY-");
addDeckName("SGUZ");
addDeckName("SGUZ-");
addDeckName("SOGCR");
addDeckName("SOGCRX");
addDeckName("SOGCRX-");
addDeckName("SOGCRY");
addDeckName("SOGCRY-");
addDeckName("SOGCRZ");
addDeckName("SOGCRZ-");
addDeckName("SOWCR");
addDeckName("SOWCRX");
addDeckName("SOWCRX-");
addDeckName("SOWCRY");
addDeckName("SOWCRY-");
addDeckName("SOWCRZ");
addDeckName("SOWCRZ-");
addDeckName("SWCR");
addDeckName("SWCRX");
addDeckName("SWCRX-");
addDeckName("SWCRY");
addDeckName("SWCRY-");
addDeckName("SWCRZ");
addDeckName("SWCRZ-");
addDeckName("IKRW");
addDeckName("ISGCRZ-");
addDeckName("IKRWX");
addDeckName("IKRWY");
addDeckName("IKRWZ");
addDeckName("IKRWX-");
addDeckName("IKRWY-");
addDeckName("IKRWZ-");
addDeckName("IKRWR");
addDeckName("IKRWRX");
addDeckName("IKRWRY");
addDeckName("IKRWRZ");
addDeckName("IKRWRX-");
addDeckName("IKRWRY-");
addDeckName("IKRWRZ-");
addDeckName("SWL");
addDeckName("SWLX");
addDeckName("SWLZ");
addDeckName("ISWL");
addDeckName("SWLX-");
addDeckName("ISWLX");
addDeckName("ISWLX-");
addDeckName("SWLY");
addDeckName("SWLY-");
addDeckName("SWLZ");
addDeckName("ISWCRZ");
addDeckName("ISWLY");
addDeckName("ISWLY-");
addDeckName("SWLZ-");
addDeckName("ISWLZ");
addDeckName("ISWLZ-");
addDeckName("SGU");
addDeckName("ISGU");
addDeckName("SGUX");
addDeckName("SGUX-");
addDeckName("ISGUX");
addDeckName("ISGUX-");
addDeckName("SGUY");
addDeckName("SGUY-");
addDeckName("SGCRZ");
addDeckName("ISGUY");
addDeckName("SGUZ");
addDeckName("ISWUZ-");
addDeckName("SGUZ-");
addDeckName("ISGUZ");
addDeckName("ISGUZ-");
addDeckName("SWU");
addDeckName("ISWU");
addDeckName("SWUX");
addDeckName("SWUX-");
addDeckName("ISWUX-");
addDeckName("SWUY");
addDeckName("SWUY-");
addDeckName("ISWUY");
addDeckName("ISWUY-");
addDeckName("SWUZ");
addDeckName("SWUZ-");
addDeckName("ISWUZ");
addDeckName("SGCR");
addDeckName("ISGCR");
addDeckName("SGCRX");
addDeckName("SGCRX-");
addDeckName("ISGCRX");
addDeckName("ISGCRX-");
addDeckName("SGCRY");
addDeckName("SGCRY-");
addDeckName("ISGCRY");
addDeckName("ISGCRY-");
addDeckName("SGCRZ-");
addDeckName("ISGCRZ");
addDeckName("SOGCRX");
addDeckName("SOGCRX-");
addDeckName("ISOGCRX");
addDeckName("ISOGCRX-");
addDeckName("SOGCRY");
addDeckName("SOGCRY-");
addDeckName("ISOGCRY");
addDeckName("ISOGCRY-");
addDeckName("SOGCRZ");
addDeckName("ISOGCRZ");
addDeckName("ISOGCRZ-");
addDeckName("SWCR");
addDeckName("ISWCR");
addDeckName("SWCRX");
addDeckName("SWCRX-");
addDeckName("ISWCRX");
addDeckName("ISWCRX-");
addDeckName("ISWCRZ-");
{
ParserRecord record;
{
@@ -665,9 +642,7 @@ const std::string ENDPOINT_SPECIFIERS::keywordName = "ENDPOINT_SPECIFIERS";
const std::string ENDPOINT_SPECIFIERS::data::itemName = "data";
ENDSCALE::ENDSCALE( ) : ParserKeyword("ENDSCALE")
{
setFixedSize( (size_t) 1);
ENDSCALE::ENDSCALE() : ParserKeyword("ENDSCALE", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("ENDSCALE");
@@ -684,12 +659,12 @@ ENDSCALE::ENDSCALE( ) : ParserKeyword("ENDSCALE")
record.addItem(item);
}
{
ParserItem item("NUM_TABLES", ParserItem::itype::INT);
ParserItem item("NTENDP", ParserItem::itype::INT);
item.setDefault( 1 );
record.addItem(item);
}
{
ParserItem item("NUM_NODES", ParserItem::itype::INT);
ParserItem item("NSENDP", ParserItem::itype::INT);
item.setDefault( 20 );
record.addItem(item);
}
@@ -706,35 +681,30 @@ const std::string ENDSCALE::DIRECT::itemName = "DIRECT";
const std::string ENDSCALE::DIRECT::defaultValue = "NODIR";
const std::string ENDSCALE::IRREVERS::itemName = "IRREVERS";
const std::string ENDSCALE::IRREVERS::defaultValue = "REVERS";
const std::string ENDSCALE::NUM_TABLES::itemName = "NUM_TABLES";
const int ENDSCALE::NUM_TABLES::defaultValue = 1;
const std::string ENDSCALE::NUM_NODES::itemName = "NUM_NODES";
const int ENDSCALE::NUM_NODES::defaultValue = 20;
const std::string ENDSCALE::NTENDP::itemName = "NTENDP";
const int ENDSCALE::NTENDP::defaultValue = 1;
const std::string ENDSCALE::NSENDP::itemName = "NSENDP";
const int ENDSCALE::NSENDP::defaultValue = 20;
const std::string ENDSCALE::COMB_MODE::itemName = "COMB_MODE";
const int ENDSCALE::COMB_MODE::defaultValue = 0;
ENDSKIP::ENDSKIP( ) : ParserKeyword("ENDSKIP")
{
setFixedSize( (size_t) 0);
addValidSectionName("EDIT");
ENDSKIP::ENDSKIP() : ParserKeyword("ENDSKIP", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("GRID");
addValidSectionName("EDIT");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SUMMARY");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("ENDSKIP");
}
const std::string ENDSKIP::keywordName = "ENDSKIP";
ENKRVD::ENKRVD( ) : ParserKeyword("ENKRVD")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("ENDSCALE","NUM_TABLES",0);
ENKRVD::ENKRVD() : ParserKeyword("ENKRVD", KeywordSize("ENDSCALE", "NTENDP", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ENKRVD");
@@ -762,10 +732,7 @@ const std::string ENKRVD::DATA::itemName = "DATA";
const double ENKRVD::DATA::defaultValue = -1.000000;
ENPCVD::ENPCVD( ) : ParserKeyword("ENPCVD")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("ENDSCALE","NUM_TABLES",0);
ENPCVD::ENPCVD() : ParserKeyword("ENPCVD", KeywordSize("ENDSCALE", "NTENDP", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ENPCVD");
@@ -788,10 +755,7 @@ const std::string ENPCVD::DATA::itemName = "DATA";
const double ENPCVD::DATA::defaultValue = -1.000000;
ENPTVD::ENPTVD( ) : ParserKeyword("ENPTVD")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("ENDSCALE","NUM_TABLES",0);
ENPTVD::ENPTVD() : ParserKeyword("ENPTVD", KeywordSize("ENDSCALE", "NTENDP", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ENPTVD");
@@ -820,10 +784,7 @@ const std::string ENPTVD::DATA::itemName = "DATA";
const double ENPTVD::DATA::defaultValue = -1.000000;
ENSPCVD::ENSPCVD( ) : ParserKeyword("ENSPCVD")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("ENDSCALE","NUM_TABLES",0);
ENSPCVD::ENSPCVD() : ParserKeyword("ENSPCVD", KeywordSize("ENDSCALE", "NTENDP", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ENSPCVD");
@@ -846,9 +807,7 @@ const std::string ENSPCVD::DATA::itemName = "DATA";
const double ENSPCVD::DATA::defaultValue = -1.000000;
EPSDBGS::EPSDBGS( ) : ParserKeyword("EPSDBGS")
{
setSizeType(SLASH_TERMINATED);
EPSDBGS::EPSDBGS() : ParserKeyword("EPSDBGS", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("PROPS");
addValidSectionName("SCHEDULE");
clearDeckNames();
@@ -916,9 +875,7 @@ const std::string EPSDBGS::GRID_NAME::itemName = "GRID_NAME";
const std::string EPSDBGS::GRID_NAME::defaultValue = "";
EPSDEBUG::EPSDEBUG( ) : ParserKeyword("EPSDEBUG")
{
setFixedSize( (size_t) 1);
EPSDEBUG::EPSDEBUG() : ParserKeyword("EPSDEBUG", KeywordSize(1, false)) {
addValidSectionName("PROPS");
addValidSectionName("SCHEDULE");
clearDeckNames();
@@ -982,9 +939,7 @@ const std::string EPSDEBUG::CHECK_DRAIN_HYST::itemName = "CHECK_DRAIN_HYST";
const int EPSDEBUG::CHECK_DRAIN_HYST::defaultValue = 0;
EQLDIMS::EQLDIMS( ) : ParserKeyword("EQLDIMS")
{
setFixedSize( (size_t) 1);
EQLDIMS::EQLDIMS() : ParserKeyword("EQLDIMS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("EQLDIMS");
@@ -1031,9 +986,7 @@ const std::string EQLDIMS::NSTRVD::itemName = "NSTRVD";
const int EQLDIMS::NSTRVD::defaultValue = 20;
EQLNUM::EQLNUM( ) : ParserKeyword("EQLNUM")
{
setFixedSize( (size_t) 1);
EQLNUM::EQLNUM() : ParserKeyword("EQLNUM", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("EQLNUM");
@@ -1051,9 +1004,7 @@ const std::string EQLNUM::keywordName = "EQLNUM";
const std::string EQLNUM::data::itemName = "data";
EQLOPTS::EQLOPTS( ) : ParserKeyword("EQLOPTS")
{
setFixedSize( (size_t) 1);
EQLOPTS::EQLOPTS() : ParserKeyword("EQLOPTS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("EQLOPTS");
@@ -1085,9 +1036,7 @@ const std::string EQLOPTS::OPTION3::itemName = "OPTION3";
const std::string EQLOPTS::OPTION4::itemName = "OPTION4";
EQLZCORN::EQLZCORN( ) : ParserKeyword("EQLZCORN")
{
setSizeType(SLASH_TERMINATED);
EQLZCORN::EQLZCORN() : ParserKeyword("EQLZCORN", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("EQLZCORN");
@@ -1162,12 +1111,10 @@ const std::string EQLZCORN::ACTION_REQ::itemName = "ACTION_REQ";
const std::string EQLZCORN::ACTION_REQ::defaultValue = "TOP";
EQUALREG::EQUALREG( ) : ParserKeyword("EQUALREG")
{
setSizeType(SLASH_TERMINATED);
EQUALREG::EQUALREG() : ParserKeyword("EQUALREG", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("SOLUTION");
clearDeckNames();
@@ -1202,17 +1149,15 @@ EQUALREG::EQUALREG( ) : ParserKeyword("EQUALREG")
const std::string EQUALREG::keywordName = "EQUALREG";
const std::string EQUALREG::ARRAY::itemName = "ARRAY";
const std::string EQUALREG::VALUE::itemName = "VALUE";
const double EQUALREG::VALUE::defaultValue = 0.000000;
const double EQUALREG::VALUE::defaultValue = 0;
const std::string EQUALREG::REGION_NUMBER::itemName = "REGION_NUMBER";
const std::string EQUALREG::REGION_NAME::itemName = "REGION_NAME";
const std::string EQUALREG::REGION_NAME::defaultValue = "M";
EQUALS::EQUALS( ) : ParserKeyword("EQUALS")
{
setSizeType(SLASH_TERMINATED);
addValidSectionName("EDIT");
EQUALS::EQUALS() : ParserKeyword("EQUALS", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
addValidSectionName("EDIT");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("SOLUTION");
@@ -1266,10 +1211,7 @@ const std::string EQUALS::K1::itemName = "K1";
const std::string EQUALS::K2::itemName = "K2";
EQUIL::EQUIL( ) : ParserKeyword("EQUIL")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("EQLDIMS","NTEQUL",0);
EQUIL::EQUIL() : ParserKeyword("EQUIL", KeywordSize("EQLDIMS", "NTEQUL", false, 0)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("EQUIL");
@@ -1326,33 +1268,40 @@ EQUIL::EQUIL( ) : ParserKeyword("EQUIL")
item.setDefault( -5 );
record.addItem(item);
}
{
ParserItem item("EQLOPT04", ParserItem::itype::INT);
record.addItem(item);
}
{
ParserItem item("EQLOPT5", ParserItem::itype::INT);
record.addItem(item);
}
addRecord( record );
}
}
const std::string EQUIL::keywordName = "EQUIL";
const std::string EQUIL::DATUM_DEPTH::itemName = "DATUM_DEPTH";
const double EQUIL::DATUM_DEPTH::defaultValue = 0.000000;
const double EQUIL::DATUM_DEPTH::defaultValue = 0;
const std::string EQUIL::DATUM_PRESSURE::itemName = "DATUM_PRESSURE";
const std::string EQUIL::OWC::itemName = "OWC";
const double EQUIL::OWC::defaultValue = 0.000000;
const double EQUIL::OWC::defaultValue = 0;
const std::string EQUIL::PC_OWC::itemName = "PC_OWC";
const double EQUIL::PC_OWC::defaultValue = 0.000000;
const double EQUIL::PC_OWC::defaultValue = 0;
const std::string EQUIL::GOC::itemName = "GOC";
const double EQUIL::GOC::defaultValue = 0.000000;
const double EQUIL::GOC::defaultValue = 0;
const std::string EQUIL::PC_GOC::itemName = "PC_GOC";
const double EQUIL::PC_GOC::defaultValue = 0.000000;
const double EQUIL::PC_GOC::defaultValue = 0;
const std::string EQUIL::BLACK_OIL_INIT::itemName = "BLACK_OIL_INIT";
const int EQUIL::BLACK_OIL_INIT::defaultValue = 0;
const std::string EQUIL::BLACK_OIL_INIT_WG::itemName = "BLACK_OIL_INIT_WG";
const int EQUIL::BLACK_OIL_INIT_WG::defaultValue = 0;
const std::string EQUIL::OIP_INIT::itemName = "OIP_INIT";
const int EQUIL::OIP_INIT::defaultValue = -5;
const std::string EQUIL::EQLOPT04::itemName = "EQLOPT04";
const std::string EQUIL::EQLOPT5::itemName = "EQLOPT5";
ESSNODE::ESSNODE( ) : ParserKeyword("ESSNODE")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTPVT",0);
ESSNODE::ESSNODE() : ParserKeyword("ESSNODE", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ESSNODE");
@@ -1371,9 +1320,7 @@ const std::string ESSNODE::keywordName = "ESSNODE";
const std::string ESSNODE::DATA::itemName = "DATA";
EXCAVATE::EXCAVATE( ) : ParserKeyword("EXCAVATE")
{
setFixedSize( (size_t) 1);
EXCAVATE::EXCAVATE() : ParserKeyword("EXCAVATE", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("EXCAVATE");
@@ -1391,9 +1338,7 @@ const std::string EXCAVATE::keywordName = "EXCAVATE";
const std::string EXCAVATE::DATA::itemName = "DATA";
EXCEL::EXCEL( ) : ParserKeyword("EXCEL")
{
setFixedSize( (size_t) 0);
EXCEL::EXCEL() : ParserKeyword("EXCEL", KeywordSize(0, false)) {
addValidSectionName("SUMMARY");
clearDeckNames();
addDeckName("EXCEL");
@@ -1401,9 +1346,7 @@ EXCEL::EXCEL( ) : ParserKeyword("EXCEL")
const std::string EXCEL::keywordName = "EXCEL";
EXIT::EXIT( ) : ParserKeyword("EXIT")
{
setFixedSize( (size_t) 1);
EXIT::EXIT() : ParserKeyword("EXIT", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("EXIT");
@@ -1422,9 +1365,7 @@ const std::string EXIT::STATUS_CODE::itemName = "STATUS_CODE";
const int EXIT::STATUS_CODE::defaultValue = 0;
EXTFIN::EXTFIN( ) : ParserKeyword("EXTFIN")
{
setFixedSize( (size_t) 1);
EXTFIN::EXTFIN() : ParserKeyword("EXTFIN", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("EXTFIN");
@@ -1486,9 +1427,7 @@ const std::string EXTFIN::NUMCON::itemName = "NUMCON";
const std::string EXTFIN::NWMAX::itemName = "NWMAX";
EXTHOST::EXTHOST( ) : ParserKeyword("EXTHOST")
{
setFixedSize( (size_t) 1);
EXTHOST::EXTHOST() : ParserKeyword("EXTHOST", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("EXTHOST");
@@ -1506,17 +1445,15 @@ const std::string EXTHOST::keywordName = "EXTHOST";
const std::string EXTHOST::data::itemName = "data";
EXTRAPMS::EXTRAPMS( ) : ParserKeyword("EXTRAPMS")
{
setFixedSize( (size_t) 1);
addValidSectionName("EDIT");
EXTRAPMS::EXTRAPMS() : ParserKeyword("EXTRAPMS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("REGIONS");
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SUMMARY");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("EXTRAPMS");
{
@@ -1534,9 +1471,7 @@ const std::string EXTRAPMS::LEVEL::itemName = "LEVEL";
const int EXTRAPMS::LEVEL::defaultValue = 0;
EXTREPGL::EXTREPGL( ) : ParserKeyword("EXTREPGL")
{
setFixedSize( (size_t) 1);
EXTREPGL::EXTREPGL() : ParserKeyword("EXTREPGL", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("EXTREPGL");

682
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/F.cpp vendored
View File

@@ -1,18 +1,17 @@
#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/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/parser/eclipse/Parser/ParserKeywords/F.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/F.hpp>
namespace Opm {
namespace ParserKeywords {
FAULTDIM::FAULTDIM( ) : ParserKeyword("FAULTDIM")
{
setFixedSize( (size_t) 1);
FAULTDIM::FAULTDIM() : ParserKeyword("FAULTDIM", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("FAULTDIM");
@@ -31,9 +30,7 @@ const std::string FAULTDIM::MFSEGS::itemName = "MFSEGS";
const int FAULTDIM::MFSEGS::defaultValue = 0;
FAULTS::FAULTS( ) : ParserKeyword("FAULTS")
{
setSizeType(SLASH_TERMINATED);
FAULTS::FAULTS() : ParserKeyword("FAULTS", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("FAULTS");
@@ -85,9 +82,7 @@ const std::string FAULTS::IZ2::itemName = "IZ2";
const std::string FAULTS::FACE::itemName = "FACE";
FBHPDEF::FBHPDEF( ) : ParserKeyword("FBHPDEF")
{
setFixedSize( (size_t) 1);
FBHPDEF::FBHPDEF() : ParserKeyword("FBHPDEF", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("FBHPDEF");
@@ -111,10 +106,7 @@ const std::string FBHPDEF::TARGET_BHP::itemName = "TARGET_BHP";
const std::string FBHPDEF::LIMIT_BHP::itemName = "LIMIT_BHP";
FHERCHBL::FHERCHBL( ) : ParserKeyword("FHERCHBL")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("NNEWTF","NTHRBL",0);
FHERCHBL::FHERCHBL() : ParserKeyword("FHERCHBL", KeywordSize("NNEWTF", "NTHRBL", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("FHERCHBL");
@@ -136,9 +128,7 @@ const std::string FHERCHBL::keywordName = "FHERCHBL";
const std::string FHERCHBL::DATA::itemName = "DATA";
FIELD::FIELD( ) : ParserKeyword("FIELD")
{
setFixedSize( (size_t) 0);
FIELD::FIELD() : ParserKeyword("FIELD", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("FIELD");
@@ -146,285 +136,286 @@ FIELD::FIELD( ) : ParserKeyword("FIELD")
const std::string FIELD::keywordName = "FIELD";
FIELD_PROBE::FIELD_PROBE( ) : ParserKeyword("FIELD_PROBE")
{
setFixedSize( (size_t) 0);
FIELD_PROBE::FIELD_PROBE() : ParserKeyword("FIELD_PROBE", KeywordSize(0, false)) {
addValidSectionName("SUMMARY");
clearDeckNames();
addDeckName("FAPI");
addDeckName("FAQR");
addDeckName("FAQRG");
addDeckName("FAQT");
addDeckName("FAQTG");
addDeckName("FCAD");
addDeckName("FCGC");
addDeckName("FCIC");
addDeckName("FCIP");
addDeckName("FCIR");
addDeckName("FCIT");
addDeckName("FCPC");
addDeckName("FCPR");
addDeckName("FCPT");
addDeckName("FORFF");
addDeckName("FOPR");
addDeckName("FCSC");
addDeckName("FEPR");
addDeckName("FEPT");
addDeckName("FGCR");
addDeckName("FGCT");
addDeckName("FGDC");
addDeckName("FGDCQ");
addDeckName("FGDEN");
addDeckName("FGIMR");
addDeckName("FGIMT");
addDeckName("FGIP");
addDeckName("FGIPG");
addDeckName("FGIPL");
addDeckName("FGIR");
addDeckName("FGIRH");
addDeckName("FGIRT");
addDeckName("FGIT");
addDeckName("FGITH");
addDeckName("FGLIR");
addDeckName("FGLR");
addDeckName("FGLRH");
addDeckName("FGOR");
addDeckName("FGORH");
addDeckName("FGPI");
addDeckName("FGPI2");
addDeckName("FGPP");
addDeckName("FGPP2");
addDeckName("FGPPF");
addDeckName("FGPPF2");
addDeckName("FGPPS");
addDeckName("FGPPS2");
addDeckName("FGPR");
addDeckName("FGPRF");
addDeckName("FGPRH");
addDeckName("FGPRS");
addDeckName("FGPRT");
addDeckName("FGPT");
addDeckName("FOPRH");
addDeckName("FOPTF");
addDeckName("FSPR");
addDeckName("FGPTF");
addDeckName("FGIMT");
addDeckName("FGPP2");
addDeckName("FGLRH");
addDeckName("FOPRT");
addDeckName("FGPRF");
addDeckName("FOPT");
addDeckName("FOPRF");
addDeckName("FMWPL");
addDeckName("FGST");
addDeckName("FOPRS");
addDeckName("FOPI2");
addDeckName("FOPI");
addDeckName("FGPP");
addDeckName("FOPTH");
addDeckName("FGIRT");
addDeckName("FCIP");
addDeckName("FOPTS");
addDeckName("FOIR");
addDeckName("FCIT");
addDeckName("FOIRH");
addDeckName("FOIRT");
addDeckName("FWIT");
addDeckName("FOIT");
addDeckName("FGPRS");
addDeckName("FWPI2");
addDeckName("FOITH");
addDeckName("FOPP");
addDeckName("FWPRT");
addDeckName("FOPP2");
addDeckName("FWPRH");
addDeckName("FMWPO");
addDeckName("FWPR");
addDeckName("FWPT");
addDeckName("FCIC");
addDeckName("FWPTH");
addDeckName("FWIR");
addDeckName("FGSR");
addDeckName("FWIRH");
addDeckName("FWIRT");
addDeckName("FWITH");
addDeckName("FSPT");
addDeckName("FGIMR");
addDeckName("FWPP");
addDeckName("FWPP2");
addDeckName("FORFE");
addDeckName("FGPI2");
addDeckName("FMWPT");
addDeckName("FWPI");
addDeckName("FGPI");
addDeckName("FWPIR");
addDeckName("FGPPF");
addDeckName("FGPR");
addDeckName("FGPRH");
addDeckName("FGPRT");
addDeckName("FGSAT");
addDeckName("FGPT");
addDeckName("FGPTH");
addDeckName("FGPTS");
addDeckName("FGPV");
addDeckName("FGQ");
addDeckName("FGSAT");
addDeckName("FGSPR");
addDeckName("FGSR");
addDeckName("FGSRL");
addDeckName("FGSRU");
addDeckName("FGSSP");
addDeckName("FGST");
addDeckName("FGSTP");
addDeckName("FGVIS");
addDeckName("FHPV");
addDeckName("FJPR");
addDeckName("FGIR");
addDeckName("FMWIA");
addDeckName("FSGR");
addDeckName("FGCR");
addDeckName("FGIRH");
addDeckName("FGPPS2");
addDeckName("FGIT");
addDeckName("FOSRL");
addDeckName("FGITH");
addDeckName("FGPPS");
addDeckName("FGPPF2");
addDeckName("FMWIG");
addDeckName("FSGT");
addDeckName("FGCT");
addDeckName("FJPRH");
addDeckName("FJPRT");
addDeckName("FJPT");
addDeckName("FJPTH");
addDeckName("FGLIR");
addDeckName("FGQ");
addDeckName("FLPR");
addDeckName("FTICHEA");
addDeckName("FSIP");
addDeckName("FLPRH");
addDeckName("FLPRT");
addDeckName("FLPT");
addDeckName("FLPTH");
addDeckName("FMCTG");
addDeckName("FMCTP");
addDeckName("FMCTW");
addDeckName("FMIR");
addDeckName("FMIT");
addDeckName("FMPR");
addDeckName("FMPT");
addDeckName("FMWDR");
addDeckName("FMWDT");
addDeckName("FMWIA");
addDeckName("FMWIG");
addDeckName("FMWIN");
addDeckName("FMWIP");
addDeckName("FMWIS");
addDeckName("FMWIT");
addDeckName("FMWIU");
addDeckName("FMWIV");
addDeckName("FMWPA");
addDeckName("FMWPG");
addDeckName("FMWPL");
addDeckName("FMWPO");
addDeckName("FMWPP");
addDeckName("FMWPR");
addDeckName("FMWPS");
addDeckName("FMWPT");
addDeckName("FMWPU");
addDeckName("FMWPV");
addDeckName("FMWWO");
addDeckName("FMWWT");
addDeckName("FNIP");
addDeckName("FNIR");
addDeckName("FNIT");
addDeckName("FNPR");
addDeckName("FNPT");
addDeckName("FNQR");
addDeckName("FNQT");
addDeckName("FODEN");
addDeckName("FOE");
addDeckName("FOEIG");
addDeckName("FOEIW");
addDeckName("FOEW");
addDeckName("FOEWG");
addDeckName("FOEWW");
addDeckName("FOGR");
addDeckName("FOGRH");
addDeckName("FOIP");
addDeckName("FOIPG");
addDeckName("FOIPL");
addDeckName("FOIR");
addDeckName("FOIRH");
addDeckName("FOIRT");
addDeckName("FOIT");
addDeckName("FOITH");
addDeckName("FOPI");
addDeckName("FOPI2");
addDeckName("FOPP");
addDeckName("FOPP2");
addDeckName("FOPR");
addDeckName("FOPRF");
addDeckName("FOPRH");
addDeckName("FOPRS");
addDeckName("FOPRT");
addDeckName("FOPT");
addDeckName("FOPTF");
addDeckName("FOPTH");
addDeckName("FOPTS");
addDeckName("FOPV");
addDeckName("FORFE");
addDeckName("FORFF");
addDeckName("FORFG");
addDeckName("FORFR");
addDeckName("FORFS");
addDeckName("FORFW");
addDeckName("FORFX");
addDeckName("FORFY");
addDeckName("FORME");
addDeckName("FORMF");
addDeckName("FORMG");
addDeckName("FORMR");
addDeckName("FORMS");
addDeckName("FORMW");
addDeckName("FORMX");
addDeckName("FORMY");
addDeckName("FOSAT");
addDeckName("FOSPR");
addDeckName("FOSRL");
addDeckName("FOSRU");
addDeckName("FOSSP");
addDeckName("FOSTP");
addDeckName("FOVIS");
addDeckName("FPPC");
addDeckName("FPPG");
addDeckName("FPPO");
addDeckName("FPPW");
addDeckName("FPR");
addDeckName("FPRGZ");
addDeckName("FPRH");
addDeckName("FPRP");
addDeckName("FRPV");
addDeckName("FRS");
addDeckName("FRTM");
addDeckName("FRV");
addDeckName("FSGR");
addDeckName("FSGT");
addDeckName("FSIC");
addDeckName("FSIP");
addDeckName("FSIR");
addDeckName("FSIT");
addDeckName("FSPC");
addDeckName("FSPR");
addDeckName("FSPT");
addDeckName("FTADSFOA");
addDeckName("FTADSUR");
addDeckName("FTDCYFOA");
addDeckName("FTICHEA");
addDeckName("FTIPTFOA");
addDeckName("FTIPTHEA");
addDeckName("FTIPTSUR");
addDeckName("FTIRALK");
addDeckName("FTIRANI");
addDeckName("FTIRCAT");
addDeckName("FTIRFOA");
addDeckName("FTIRHEA");
addDeckName("FTIRSUR");
addDeckName("FTITALK");
addDeckName("FTITANI");
addDeckName("FTITCAT");
addDeckName("FTITFOA");
addDeckName("FTITHEA");
addDeckName("FTITSUR");
addDeckName("FTMOBFOA");
addDeckName("FTPCHEA");
addDeckName("FTPRALK");
addDeckName("FTPRANI");
addDeckName("FTPRCAT");
addDeckName("FTPRFOA");
addDeckName("FTPRHEA");
addDeckName("FTPRSUR");
addDeckName("FTPTALK");
addDeckName("FTPTANI");
addDeckName("FTPTCAT");
addDeckName("FTPTFOA");
addDeckName("FTPTHEA");
addDeckName("FTPTSUR");
addDeckName("FLPTH");
addDeckName("FJPR");
addDeckName("FJPRT");
addDeckName("FJPT");
addDeckName("FEIR");
addDeckName("FJPTH");
addDeckName("FVPR");
addDeckName("FVPRT");
addDeckName("FGDEN");
addDeckName("FVPT");
addDeckName("FVIR");
addDeckName("FVIRT");
addDeckName("FVIT");
addDeckName("FVPR");
addDeckName("FVPRT");
addDeckName("FVPT");
addDeckName("FWCT");
addDeckName("FORFG");
addDeckName("FWCTH");
addDeckName("FWDEN");
addDeckName("FGOR");
addDeckName("FGORH");
addDeckName("FOGR");
addDeckName("FORMX");
addDeckName("FOGRH");
addDeckName("FWGR");
addDeckName("FWGRH");
addDeckName("FWIP");
addDeckName("FWIR");
addDeckName("FWIRH");
addDeckName("FWIRT");
addDeckName("FWIT");
addDeckName("FWITH");
addDeckName("FWPI");
addDeckName("FWPI2");
addDeckName("FWPIR");
addDeckName("FWPP");
addDeckName("FWPP2");
addDeckName("FWPR");
addDeckName("FWPRH");
addDeckName("FWPRT");
addDeckName("FWPT");
addDeckName("FWPTH");
addDeckName("FWPV");
addDeckName("FWSAT");
addDeckName("FMPT");
addDeckName("FGLR");
addDeckName("FPRP");
addDeckName("FMCTP");
addDeckName("FMCTW");
addDeckName("FOVIS");
addDeckName("FMCTG");
addDeckName("FMWPR");
addDeckName("FMWPA");
addDeckName("FMWPU");
addDeckName("FMWPG");
addDeckName("FMWPS");
addDeckName("FMWPV");
addDeckName("FMWPP");
addDeckName("FMWIT");
addDeckName("FMWIN");
addDeckName("FMWIU");
addDeckName("FMWIS");
addDeckName("FMWIV");
addDeckName("FMWIP");
addDeckName("FMWDR");
addDeckName("FMWDT");
addDeckName("FMWWO");
addDeckName("FMWWT");
addDeckName("FEPR");
addDeckName("FTITSUR");
addDeckName("FEPT");
addDeckName("FGSPR");
addDeckName("FGSRL");
addDeckName("FGSRU");
addDeckName("FGSSP");
addDeckName("FMIR");
addDeckName("FGSTP");
addDeckName("FOSPR");
addDeckName("FOSRU");
addDeckName("FOSSP");
addDeckName("FOSTP");
addDeckName("FWSPR");
addDeckName("FTPTCAT");
addDeckName("FWSRL");
addDeckName("FWSRU");
addDeckName("FWSSP");
addDeckName("FWSTP");
addDeckName("FOSAT");
addDeckName("FOIP");
addDeckName("FOIPR");
addDeckName("FOIPL");
addDeckName("FOIPG");
addDeckName("FPPO");
addDeckName("FMIT");
addDeckName("FODEN");
addDeckName("FWSAT");
addDeckName("FWIP");
addDeckName("FWIPR");
addDeckName("FPPW");
addDeckName("FORMS");
addDeckName("FWVIS");
addDeckName("FWDEN");
addDeckName("FGIP");
addDeckName("FGIPR");
addDeckName("FGIPL");
addDeckName("FGIPG");
addDeckName("FPPG");
addDeckName("FGVIS");
addDeckName("FCAD");
addDeckName("FPR");
addDeckName("FPRH");
addDeckName("FPRGZ");
addDeckName("FRS");
addDeckName("FSIR");
addDeckName("FRV");
addDeckName("FPPC");
addDeckName("FRPV");
addDeckName("FOPV");
addDeckName("FWPV");
addDeckName("FGPV");
addDeckName("FHPV");
addDeckName("FRTM");
addDeckName("FOE");
addDeckName("FOEW");
addDeckName("FAPI");
addDeckName("FOEWW");
addDeckName("FOEIG");
addDeckName("FOEWG");
addDeckName("FTPTALK");
addDeckName("FORMR");
addDeckName("FORMW");
addDeckName("FNIT");
addDeckName("FORMG");
addDeckName("FORME");
addDeckName("FORMF");
addDeckName("FORMY");
addDeckName("FORFR");
addDeckName("FORFW");
addDeckName("FORFS");
addDeckName("FORFX");
addDeckName("FORFY");
addDeckName("FAQR");
addDeckName("FAQT");
addDeckName("FAQRG");
addDeckName("FAQTG");
addDeckName("FNQR");
addDeckName("FNQT");
addDeckName("FSIT");
addDeckName("FSPC");
addDeckName("FSIC");
addDeckName("FTPRANI");
addDeckName("FTPTANI");
addDeckName("FTIRANI");
addDeckName("FTITANI");
addDeckName("FTPTSUR");
addDeckName("FTPRCAT");
addDeckName("FTIRCAT");
addDeckName("FTITCAT");
addDeckName("FTPCHEA");
addDeckName("FTPRHEA");
addDeckName("FTPTHEA");
addDeckName("FTIRHEA");
addDeckName("FTITHEA");
addDeckName("FTIPTHEA");
addDeckName("FMPR");
addDeckName("FCGC");
addDeckName("FTPRFOA");
addDeckName("FTPTFOA");
addDeckName("FTIRFOA");
addDeckName("FTITFOA");
addDeckName("FNIP");
addDeckName("FTIPTFOA");
addDeckName("FTADSFOA");
addDeckName("FTDCYFOA");
addDeckName("FTMOBFOA");
addDeckName("FGDC");
addDeckName("FGDCQ");
addDeckName("FEIT");
addDeckName("FCPR");
addDeckName("FCPC");
addDeckName("FCPT");
addDeckName("FCIR");
addDeckName("PSSPR");
addDeckName("PSSSC");
addDeckName("PSSSG");
addDeckName("PSSSO");
addDeckName("PSSSW");
addDeckName("PSSSG");
addDeckName("PSSSC");
addDeckName("FNPR");
addDeckName("FNPT");
addDeckName("FNIR");
addDeckName("FTPRSUR");
addDeckName("FTIRALK");
addDeckName("FTIRSUR");
addDeckName("FTIPTSUR");
addDeckName("FTADSUR");
addDeckName("FTPRALK");
addDeckName("FTITALK");
setMatchRegex("FU.+|FTPR.+|FTPT.+|FTPC.+|FTIR.+|FTIT.+|FTIC.+|FTIPT.+|FTIPF.+|FTIPS|FTIP[1-9][0-9]*.+|FTPR.+|FTPT.+|FTPC.+|FTIR.+|FTIT.+|FTIC.+|FTADS.+|FTDCY.+|FTIRF.+|FTIRS.+|FTPRF.+|FTPRS.+|FTITF.+|FTITS.+|FTPTF.+|FTPTS.+|FTICF.+|FTICS.+|FTPCF.+|FTPCS.+");
}
const std::string FIELD_PROBE::keywordName = "FIELD_PROBE";
FILEUNIT::FILEUNIT( ) : ParserKeyword("FILEUNIT")
{
setFixedSize( (size_t) 1);
addValidSectionName("EDIT");
FILEUNIT::FILEUNIT() : ParserKeyword("FILEUNIT", KeywordSize(1, false)) {
addValidSectionName("GRID");
addValidSectionName("EDIT");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("FILEUNIT");
{
@@ -440,9 +431,7 @@ const std::string FILEUNIT::keywordName = "FILEUNIT";
const std::string FILEUNIT::FILE_UNIT_SYSTEM::itemName = "FILE_UNIT_SYSTEM";
FILLEPS::FILLEPS( ) : ParserKeyword("FILLEPS")
{
setFixedSize( (size_t) 0);
FILLEPS::FILLEPS() : ParserKeyword("FILLEPS", KeywordSize(0, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("FILLEPS");
@@ -450,9 +439,7 @@ FILLEPS::FILLEPS( ) : ParserKeyword("FILLEPS")
const std::string FILLEPS::keywordName = "FILLEPS";
FIPNUM::FIPNUM( ) : ParserKeyword("FIPNUM")
{
setFixedSize( (size_t) 1);
FIPNUM::FIPNUM() : ParserKeyword("FIPNUM", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("FIPNUM");
@@ -470,9 +457,7 @@ const std::string FIPNUM::keywordName = "FIPNUM";
const std::string FIPNUM::data::itemName = "data";
FIPOWG::FIPOWG( ) : ParserKeyword("FIPOWG")
{
setFixedSize( (size_t) 0);
FIPOWG::FIPOWG() : ParserKeyword("FIPOWG", KeywordSize(0, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("FIPOWG");
@@ -480,9 +465,7 @@ FIPOWG::FIPOWG( ) : ParserKeyword("FIPOWG")
const std::string FIPOWG::keywordName = "FIPOWG";
FIPSEP::FIPSEP( ) : ParserKeyword("FIPSEP")
{
setSizeType(SLASH_TERMINATED);
FIPSEP::FIPSEP() : ParserKeyword("FIPSEP", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("FIPSEP");
@@ -565,9 +548,7 @@ const std::string FIPSEP::DENSITY_EVAL_GAS_TEMP::itemName = "DENSITY_EVAL_GAS_TE
const std::string FIPSEP::DENSITY_EVAL_PRESSURE_TEMP::itemName = "DENSITY_EVAL_PRESSURE_TEMP";
FIP_PROBE::FIP_PROBE( ) : ParserKeyword("FIP_PROBE")
{
setFixedSize( (size_t) 1);
FIP_PROBE::FIP_PROBE() : ParserKeyword("FIP_PROBE", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
setMatchRegex("FIP.+");
@@ -585,9 +566,7 @@ const std::string FIP_PROBE::keywordName = "FIP_PROBE";
const std::string FIP_PROBE::data::itemName = "data";
FLUXNUM::FLUXNUM( ) : ParserKeyword("FLUXNUM")
{
setFixedSize( (size_t) 1);
FLUXNUM::FLUXNUM() : ParserKeyword("FLUXNUM", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("FLUXNUM");
@@ -605,9 +584,7 @@ const std::string FLUXNUM::keywordName = "FLUXNUM";
const std::string FLUXNUM::data::itemName = "data";
FLUXREG::FLUXREG( ) : ParserKeyword("FLUXREG")
{
setFixedSize( (size_t) 1);
FLUXREG::FLUXREG() : ParserKeyword("FLUXREG", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("FLUXREG");
@@ -625,19 +602,24 @@ const std::string FLUXREG::keywordName = "FLUXREG";
const std::string FLUXREG::data::itemName = "data";
FLUXTYPE::FLUXTYPE( ) : ParserKeyword("FLUXTYPE")
{
setFixedSize( (size_t) 1);
FLUXTYPE::FLUXTYPE() : ParserKeyword("FLUXTYPE", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("FLUXTYPE");
{
ParserRecord record;
{
ParserItem item("BC_TYPE", ParserItem::itype::STRING);
record.addItem(item);
}
addRecord( record );
}
}
const std::string FLUXTYPE::keywordName = "FLUXTYPE";
const std::string FLUXTYPE::BC_TYPE::itemName = "BC_TYPE";
FMTHMD::FMTHMD( ) : ParserKeyword("FMTHMD")
{
setFixedSize( (size_t) 0);
FMTHMD::FMTHMD() : ParserKeyword("FMTHMD", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("FMTHMD");
@@ -645,9 +627,7 @@ FMTHMD::FMTHMD( ) : ParserKeyword("FMTHMD")
const std::string FMTHMD::keywordName = "FMTHMD";
FMTIN::FMTIN( ) : ParserKeyword("FMTIN")
{
setFixedSize( (size_t) 0);
FMTIN::FMTIN() : ParserKeyword("FMTIN", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("FMTIN");
@@ -655,9 +635,7 @@ FMTIN::FMTIN( ) : ParserKeyword("FMTIN")
const std::string FMTIN::keywordName = "FMTIN";
FMTOUT::FMTOUT( ) : ParserKeyword("FMTOUT")
{
setFixedSize( (size_t) 0);
FMTOUT::FMTOUT() : ParserKeyword("FMTOUT", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("FMTOUT");
@@ -665,9 +643,7 @@ FMTOUT::FMTOUT( ) : ParserKeyword("FMTOUT")
const std::string FMTOUT::keywordName = "FMTOUT";
FMWSET::FMWSET( ) : ParserKeyword("FMWSET")
{
setFixedSize( (size_t) 0);
FMWSET::FMWSET() : ParserKeyword("FMWSET", KeywordSize(0, false)) {
addValidSectionName("SUMMARY");
clearDeckNames();
addDeckName("FMWSET");
@@ -675,9 +651,7 @@ FMWSET::FMWSET( ) : ParserKeyword("FMWSET")
const std::string FMWSET::keywordName = "FMWSET";
FOAM::FOAM( ) : ParserKeyword("FOAM")
{
setFixedSize( (size_t) 0);
FOAM::FOAM() : ParserKeyword("FOAM", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("FOAM");
@@ -685,10 +659,7 @@ FOAM::FOAM( ) : ParserKeyword("FOAM")
const std::string FOAM::keywordName = "FOAM";
FOAMADS::FOAMADS( ) : ParserKeyword("FOAMADS")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
FOAMADS::FOAMADS() : ParserKeyword("FOAMADS", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("FOAMADS");
@@ -708,10 +679,7 @@ const std::string FOAMADS::keywordName = "FOAMADS";
const std::string FOAMADS::DATA::itemName = "DATA";
FOAMDCYO::FOAMDCYO( ) : ParserKeyword("FOAMDCYO")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
FOAMDCYO::FOAMDCYO() : ParserKeyword("FOAMDCYO", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("FOAMDCYO");
@@ -731,10 +699,7 @@ const std::string FOAMDCYO::keywordName = "FOAMDCYO";
const std::string FOAMDCYO::DATA::itemName = "DATA";
FOAMDCYW::FOAMDCYW( ) : ParserKeyword("FOAMDCYW")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
FOAMDCYW::FOAMDCYW() : ParserKeyword("FOAMDCYW", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("FOAMDCYW");
@@ -754,17 +719,14 @@ const std::string FOAMDCYW::keywordName = "FOAMDCYW";
const std::string FOAMDCYW::DATA::itemName = "DATA";
FOAMFCN::FOAMFCN( ) : ParserKeyword("FOAMFCN")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
FOAMFCN::FOAMFCN() : ParserKeyword("FOAMFCN", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("FOAMFCN");
{
ParserRecord record;
{
ParserItem item("CAPILLARY_NUMBER", ParserItem::itype::INT);
ParserItem item("CAPILLARY_NUMBER", ParserItem::itype::DOUBLE);
record.addItem(item);
}
{
@@ -782,10 +744,7 @@ const std::string FOAMFCN::EXP::itemName = "EXP";
const double FOAMFCN::EXP::defaultValue = 1.000000;
FOAMFRM::FOAMFRM( ) : ParserKeyword("FOAMFRM")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
FOAMFRM::FOAMFRM() : ParserKeyword("FOAMFRM", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("FOAMFRM");
@@ -804,11 +763,11 @@ const std::string FOAMFRM::keywordName = "FOAMFRM";
const std::string FOAMFRM::DATA::itemName = "DATA";
FOAMFSC::FOAMFSC( ) : ParserKeyword("FOAMFSC")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
FOAMFSC::FOAMFSC() : ParserKeyword("FOAMFSC", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
setRequiredKeywords({
"FOAMROCK",
});
clearDeckNames();
addDeckName("FOAMFSC");
{
@@ -830,6 +789,12 @@ FOAMFSC::FOAMFSC( ) : ParserKeyword("FOAMFSC")
item.push_backDimension("FoamSurfactantConcentration");
record.addItem(item);
}
{
ParserItem item("MIN_WAT_SAT", ParserItem::itype::DOUBLE);
item.setDefault( double(1e-06) );
item.push_backDimension("1");
record.addItem(item);
}
addRecord( record );
}
}
@@ -838,13 +803,12 @@ const std::string FOAMFSC::REF_SURF_CONC::itemName = "REF_SURF_CONC";
const std::string FOAMFSC::EXPONENT::itemName = "EXPONENT";
const double FOAMFSC::EXPONENT::defaultValue = 1.000000;
const std::string FOAMFSC::MIN_SURF_CONC::itemName = "MIN_SURF_CONC";
const double FOAMFSC::MIN_SURF_CONC::defaultValue = 0.000000;
const double FOAMFSC::MIN_SURF_CONC::defaultValue = 1e-20;
const std::string FOAMFSC::MIN_WAT_SAT::itemName = "MIN_WAT_SAT";
const double FOAMFSC::MIN_WAT_SAT::defaultValue = 1e-06;
FOAMFSO::FOAMFSO( ) : ParserKeyword("FOAMFSO")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
FOAMFSO::FOAMFSO() : ParserKeyword("FOAMFSO", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("FOAMFSO");
@@ -864,10 +828,7 @@ const std::string FOAMFSO::keywordName = "FOAMFSO";
const std::string FOAMFSO::DATA::itemName = "DATA";
FOAMFST::FOAMFST( ) : ParserKeyword("FOAMFST")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
FOAMFST::FOAMFST() : ParserKeyword("FOAMFST", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("FOAMFST");
@@ -887,10 +848,7 @@ const std::string FOAMFST::keywordName = "FOAMFST";
const std::string FOAMFST::DATA::itemName = "DATA";
FOAMFSW::FOAMFSW( ) : ParserKeyword("FOAMFSW")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
FOAMFSW::FOAMFSW() : ParserKeyword("FOAMFSW", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("FOAMFSW");
@@ -910,10 +868,7 @@ const std::string FOAMFSW::keywordName = "FOAMFSW";
const std::string FOAMFSW::DATA::itemName = "DATA";
FOAMMOB::FOAMMOB( ) : ParserKeyword("FOAMMOB")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTPVT",0);
FOAMMOB::FOAMMOB() : ParserKeyword("FOAMMOB", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("FOAMMOB");
@@ -933,10 +888,7 @@ const std::string FOAMMOB::keywordName = "FOAMMOB";
const std::string FOAMMOB::DATA::itemName = "DATA";
FOAMMOBP::FOAMMOBP( ) : ParserKeyword("FOAMMOBP")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTPVT",0);
FOAMMOBP::FOAMMOBP() : ParserKeyword("FOAMMOBP", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("FOAMMOBP");
@@ -956,10 +908,7 @@ const std::string FOAMMOBP::keywordName = "FOAMMOBP";
const std::string FOAMMOBP::DATA::itemName = "DATA";
FOAMMOBS::FOAMMOBS( ) : ParserKeyword("FOAMMOBS")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTPVT",0);
FOAMMOBS::FOAMMOBS() : ParserKeyword("FOAMMOBS", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("FOAMMOBS");
@@ -979,9 +928,7 @@ const std::string FOAMMOBS::keywordName = "FOAMMOBS";
const std::string FOAMMOBS::DATA::itemName = "DATA";
FOAMOPTS::FOAMOPTS( ) : ParserKeyword("FOAMOPTS")
{
setFixedSize( (size_t) 1);
FOAMOPTS::FOAMOPTS() : ParserKeyword("FOAMOPTS", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("FOAMOPTS");
@@ -994,6 +941,7 @@ FOAMOPTS::FOAMOPTS( ) : ParserKeyword("FOAMOPTS")
}
{
ParserItem item("MODEL", ParserItem::itype::STRING);
item.setDefault( std::string("TAB") );
record.addItem(item);
}
addRecord( record );
@@ -1003,12 +951,10 @@ const std::string FOAMOPTS::keywordName = "FOAMOPTS";
const std::string FOAMOPTS::TRANSPORT_PHASE::itemName = "TRANSPORT_PHASE";
const std::string FOAMOPTS::TRANSPORT_PHASE::defaultValue = "GAS";
const std::string FOAMOPTS::MODEL::itemName = "MODEL";
const std::string FOAMOPTS::MODEL::defaultValue = "TAB";
FOAMROCK::FOAMROCK( ) : ParserKeyword("FOAMROCK")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
FOAMROCK::FOAMROCK() : ParserKeyword("FOAMROCK", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("FOAMROCK");
@@ -1033,17 +979,15 @@ const int FOAMROCK::ADSORPTION_INDEX::defaultValue = 1;
const std::string FOAMROCK::ROCK_DENSITY::itemName = "ROCK_DENSITY";
FORMFEED::FORMFEED( ) : ParserKeyword("FORMFEED")
{
setFixedSize( (size_t) 1);
addValidSectionName("EDIT");
FORMFEED::FORMFEED() : ParserKeyword("FORMFEED", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("GRID");
addValidSectionName("EDIT");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SUMMARY");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("FORMFEED");
{
@@ -1061,9 +1005,7 @@ const std::string FORMFEED::VALUE::itemName = "VALUE";
const int FORMFEED::VALUE::defaultValue = 1;
FRICTION::FRICTION( ) : ParserKeyword("FRICTION")
{
setFixedSize( (size_t) 1);
FRICTION::FRICTION() : ParserKeyword("FRICTION", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("FRICTION");
@@ -1089,9 +1031,7 @@ const std::string FRICTION::NWFRIB::itemName = "NWFRIB";
const int FRICTION::NWFRIB::defaultValue = 1;
FULLIMP::FULLIMP( ) : ParserKeyword("FULLIMP")
{
setFixedSize( (size_t) 0);
FULLIMP::FULLIMP() : ParserKeyword("FULLIMP", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("FULLIMP");

992
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/G.cpp vendored
View File

File diff suppressed because it is too large Load Diff

235
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/H.cpp vendored
View File

@@ -1,18 +1,17 @@
#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/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/parser/eclipse/Parser/ParserKeywords/H.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/H.hpp>
namespace Opm {
namespace ParserKeywords {
HALFTRAN::HALFTRAN( ) : ParserKeyword("HALFTRAN")
{
setFixedSize( (size_t) 0);
HALFTRAN::HALFTRAN() : ParserKeyword("HALFTRAN", KeywordSize(0, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("HALFTRAN");
@@ -20,13 +19,15 @@ HALFTRAN::HALFTRAN( ) : ParserKeyword("HALFTRAN")
const std::string HALFTRAN::keywordName = "HALFTRAN";
HAxxxxxx::HAxxxxxx( ) : ParserKeyword("HAxxxxxx")
{
setFixedSize( (size_t) 1);
HAxxxxxx::HAxxxxxx() : ParserKeyword("HAxxxxxx", KeywordSize(1, false)) {
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("HAxxxxxx");
addDeckName("HASOGCR");
addDeckName("HASOWCR");
addDeckName("HASWL");
addDeckName("HASGLPC");
addDeckName("HASWLPC");
{
ParserRecord record;
{
@@ -42,9 +43,7 @@ const std::string HAxxxxxx::keywordName = "HAxxxxxx";
const std::string HAxxxxxx::data::itemName = "data";
HBNUM::HBNUM( ) : ParserKeyword("HBNUM")
{
setFixedSize( (size_t) 1);
HBNUM::HBNUM() : ParserKeyword("HBNUM", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("HBNUM");
@@ -62,10 +61,7 @@ const std::string HBNUM::keywordName = "HBNUM";
const std::string HBNUM::data::itemName = "data";
HDISP::HDISP( ) : ParserKeyword("HDISP")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTPVT",0);
HDISP::HDISP() : ParserKeyword("HDISP", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HDISP");
@@ -85,9 +81,7 @@ const std::string HDISP::keywordName = "HDISP";
const std::string HDISP::DATA::itemName = "DATA";
HEATCR::HEATCR( ) : ParserKeyword("HEATCR")
{
setFixedSize( (size_t) 1);
HEATCR::HEATCR() : ParserKeyword("HEATCR", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("HEATCR");
@@ -106,9 +100,7 @@ const std::string HEATCR::keywordName = "HEATCR";
const std::string HEATCR::data::itemName = "data";
HEATCRT::HEATCRT( ) : ParserKeyword("HEATCRT")
{
setFixedSize( (size_t) 1);
HEATCRT::HEATCRT() : ParserKeyword("HEATCRT", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("HEATCRT");
@@ -127,9 +119,7 @@ const std::string HEATCRT::keywordName = "HEATCRT";
const std::string HEATCRT::data::itemName = "data";
HMAQUCT::HMAQUCT( ) : ParserKeyword("HMAQUCT")
{
setSizeType(SLASH_TERMINATED);
HMAQUCT::HMAQUCT() : ParserKeyword("HMAQUCT", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("HMAQUCT");
@@ -167,9 +157,7 @@ const std::string HMAQUCT::DERIVATIES_RESP_AQUIFER_DEPTH::itemName = "DERIVATIES
const std::string HMAQUCT::DERIVATIES_RESP_AQUIFER_DEPTH::defaultValue = "NO";
HMAQUFET::HMAQUFET( ) : ParserKeyword("HMAQUFET")
{
setSizeType(SLASH_TERMINATED);
HMAQUFET::HMAQUFET() : ParserKeyword("HMAQUFET", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("HMAQUFET");
@@ -207,9 +195,7 @@ const std::string HMAQUFET::DERIVATIES_RESP_AQUIFER_DEPTH::itemName = "DERIVATIE
const std::string HMAQUFET::DERIVATIES_RESP_AQUIFER_DEPTH::defaultValue = "NO";
HMAQUNUM::HMAQUNUM( ) : ParserKeyword("HMAQUNUM")
{
setSizeType(SLASH_TERMINATED);
HMAQUNUM::HMAQUNUM() : ParserKeyword("HMAQUNUM", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("HMAQUNUM");
@@ -245,9 +231,7 @@ const std::string HMAQUNUM::DERIVATIES_RESP_AQUIFER_GRID_CON_TRANS::itemName = "
const std::string HMAQUNUM::DERIVATIES_RESP_AQUIFER_GRID_CON_TRANS::defaultValue = "NO";
HMDIMS::HMDIMS( ) : ParserKeyword("HMDIMS")
{
setFixedSize( (size_t) 1);
HMDIMS::HMDIMS() : ParserKeyword("HMDIMS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("HMDIMS");
@@ -322,9 +306,7 @@ const std::string HMDIMS::MAX_WELL_CONN_PARAMS::itemName = "MAX_WELL_CONN_PARAMS
const int HMDIMS::MAX_WELL_CONN_PARAMS::defaultValue = 0;
HMFAULTS::HMFAULTS( ) : ParserKeyword("HMFAULTS")
{
setSizeType(SLASH_TERMINATED);
HMFAULTS::HMFAULTS() : ParserKeyword("HMFAULTS", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("HMFAULTS");
@@ -341,9 +323,7 @@ const std::string HMFAULTS::keywordName = "HMFAULTS";
const std::string HMFAULTS::FAULT_SEGMENT::itemName = "FAULT_SEGMENT";
HMMLAQUN::HMMLAQUN( ) : ParserKeyword("HMMLAQUN")
{
setSizeType(SLASH_TERMINATED);
HMMLAQUN::HMMLAQUN() : ParserKeyword("HMMLAQUN", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("HMMLAQUN");
@@ -384,9 +364,7 @@ const std::string HMMLAQUN::AQUIFER_GRID_CONN_MULT::itemName = "AQUIFER_GRID_CON
const double HMMLAQUN::AQUIFER_GRID_CONN_MULT::defaultValue = 1.000000;
HMMLCTAQ::HMMLCTAQ( ) : ParserKeyword("HMMLCTAQ")
{
setSizeType(SLASH_TERMINATED);
HMMLCTAQ::HMMLCTAQ() : ParserKeyword("HMMLCTAQ", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("HMMLCTAQ");
@@ -427,9 +405,7 @@ const std::string HMMLCTAQ::AQUIFER_DEPTH_MULT::itemName = "AQUIFER_DEPTH_MULT";
const double HMMLCTAQ::AQUIFER_DEPTH_MULT::defaultValue = 1.000000;
HMMLFTAQ::HMMLFTAQ( ) : ParserKeyword("HMMLFTAQ")
{
setSizeType(SLASH_TERMINATED);
HMMLFTAQ::HMMLFTAQ() : ParserKeyword("HMMLFTAQ", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("HMMLFTAQ");
@@ -470,9 +446,7 @@ const std::string HMMLFTAQ::AQUIFER_DEPTH_MULT::itemName = "AQUIFER_DEPTH_MULT";
const double HMMLFTAQ::AQUIFER_DEPTH_MULT::defaultValue = 1.000000;
HMMLTWCN::HMMLTWCN( ) : ParserKeyword("HMMLTWCN")
{
setSizeType(SLASH_TERMINATED);
HMMLTWCN::HMMLTWCN() : ParserKeyword("HMMLTWCN", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("HMMLTWCN");
@@ -527,9 +501,7 @@ const std::string HMMLTWCN::SKIN::itemName = "SKIN";
const double HMMLTWCN::SKIN::defaultValue = 1.000000;
HMMULTFT::HMMULTFT( ) : ParserKeyword("HMMULTFT")
{
setSizeType(SLASH_TERMINATED);
HMMULTFT::HMMULTFT() : ParserKeyword("HMMULTFT", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("HMMULTFT");
@@ -562,9 +534,7 @@ const std::string HMMULTFT::DIFF_MULT::itemName = "DIFF_MULT";
const double HMMULTFT::DIFF_MULT::defaultValue = 1.000000;
HMMULTSG::HMMULTSG( ) : ParserKeyword("HMMULTSG")
{
setFixedSize( (size_t) 1);
HMMULTSG::HMMULTSG() : ParserKeyword("HMMULTSG", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("HMMULTSG");
@@ -583,13 +553,16 @@ const std::string HMMULTSG::keywordName = "HMMULTSG";
const std::string HMMULTSG::data::itemName = "data";
HMMULTxx::HMMULTxx( ) : ParserKeyword("HMMULTxx")
{
setFixedSize( (size_t) 1);
HMMULTxx::HMMULTxx() : ParserKeyword("HMMULTxx", KeywordSize(1, false)) {
addValidSectionName("EDIT");
addValidSectionName("GRID");
clearDeckNames();
addDeckName("HMMULTxx");
addDeckName("HMMULTX");
addDeckName("HMMULTY");
addDeckName("HMMULTR");
addDeckName("HMMULTZ");
addDeckName("HMMULTPV");
addDeckName("HMMULTTH");
{
ParserRecord record;
{
@@ -605,9 +578,7 @@ const std::string HMMULTxx::keywordName = "HMMULTxx";
const std::string HMMULTxx::data::itemName = "data";
HMPROPS::HMPROPS( ) : ParserKeyword("HMPROPS")
{
setFixedSize( (size_t) 0);
HMPROPS::HMPROPS() : ParserKeyword("HMPROPS", KeywordSize(0, false)) {
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
clearDeckNames();
@@ -616,9 +587,7 @@ HMPROPS::HMPROPS( ) : ParserKeyword("HMPROPS")
const std::string HMPROPS::keywordName = "HMPROPS";
HMROCK::HMROCK( ) : ParserKeyword("HMROCK")
{
setSizeType(SLASH_TERMINATED);
HMROCK::HMROCK() : ParserKeyword("HMROCK", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HMROCK");
@@ -642,9 +611,7 @@ const std::string HMROCK::CALCULATE_GRADIENTS::itemName = "CALCULATE_GRADIENTS";
const int HMROCK::CALCULATE_GRADIENTS::defaultValue = 0;
HMROCKT::HMROCKT( ) : ParserKeyword("HMROCKT")
{
setSizeType(SLASH_TERMINATED);
HMROCKT::HMROCKT() : ParserKeyword("HMROCKT", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HMROCKT");
@@ -671,10 +638,7 @@ const std::string HMROCKT::CALCULATE_GRADIENTS_1::itemName = "CALCULATE_GRADIENT
const std::string HMROCKT::CALCULATE_GRADIENTS_2::itemName = "CALCULATE_GRADIENTS_2";
HMRREF::HMRREF( ) : ParserKeyword("HMRREF")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("ROCKCOMP","NTROCC",0);
HMRREF::HMRREF() : ParserKeyword("HMRREF", KeywordSize("ROCKCOMP", "NTROCC", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HMRREF");
@@ -698,9 +662,7 @@ const std::string HMRREF::P_REF::itemName = "P_REF";
const std::string HMRREF::P_DIM::itemName = "P_DIM";
HMWELCON::HMWELCON( ) : ParserKeyword("HMWELCON")
{
setSizeType(SLASH_TERMINATED);
HMWELCON::HMWELCON() : ParserKeyword("HMWELCON", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("HMWELCON");
@@ -753,9 +715,7 @@ const std::string HMWELCON::REQ_SKIN_FACTOR_GRAD::itemName = "REQ_SKIN_FACTOR_GR
const std::string HMWELCON::REQ_SKIN_FACTOR_GRAD::defaultValue = "NO";
HMWPIMLT::HMWPIMLT( ) : ParserKeyword("HMWPIMLT")
{
setSizeType(SLASH_TERMINATED);
HMWPIMLT::HMWPIMLT() : ParserKeyword("HMWPIMLT", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("HMWPIMLT");
@@ -772,12 +732,33 @@ const std::string HMWPIMLT::keywordName = "HMWPIMLT";
const std::string HMWPIMLT::WELL::itemName = "WELL";
HMxxxxxx::HMxxxxxx( ) : ParserKeyword("HMxxxxxx")
{
setFixedSize( (size_t) 1);
HMxxxxxx::HMxxxxxx() : ParserKeyword("HMxxxxxx", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("HMxxxxxx");
addDeckName("HMTRNXY");
addDeckName("HMSWCR");
addDeckName("HMTRANX");
addDeckName("HMTRANY");
addDeckName("HMPERMY");
addDeckName("HMTRANZ");
addDeckName("HMPORVM");
addDeckName("HMSIGMA");
addDeckName("HMPERMX");
addDeckName("HMSOGCR");
addDeckName("HMKRO");
addDeckName("HMPRMXY");
addDeckName("HMPCW");
addDeckName("HMPERMZ");
addDeckName("HMSGCR");
addDeckName("HMSOWCR");
addDeckName("HMSWL");
addDeckName("HMKRW");
addDeckName("HMKRG");
addDeckName("HMKRWR");
addDeckName("HMKRGR");
addDeckName("HMKRORW");
addDeckName("HMKRORG");
addDeckName("HMPCG");
{
ParserRecord record;
{
@@ -792,9 +773,7 @@ const std::string HMxxxxxx::keywordName = "HMxxxxxx";
const std::string HMxxxxxx::data::itemName = "data";
HRFIN::HRFIN( ) : ParserKeyword("HRFIN")
{
setFixedSize( (size_t) 1);
HRFIN::HRFIN() : ParserKeyword("HRFIN", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("HRFIN");
@@ -813,9 +792,7 @@ const std::string HRFIN::keywordName = "HRFIN";
const std::string HRFIN::data::itemName = "data";
HWKRO::HWKRO( ) : ParserKeyword("HWKRO")
{
setFixedSize( (size_t) 1);
HWKRO::HWKRO() : ParserKeyword("HWKRO", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HWKRO");
@@ -834,9 +811,7 @@ const std::string HWKRO::keywordName = "HWKRO";
const std::string HWKRO::data::itemName = "data";
HWKRORG::HWKRORG( ) : ParserKeyword("HWKRORG")
{
setFixedSize( (size_t) 1);
HWKRORG::HWKRORG() : ParserKeyword("HWKRORG", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HWKRORG");
@@ -855,9 +830,7 @@ const std::string HWKRORG::keywordName = "HWKRORG";
const std::string HWKRORG::data::itemName = "data";
HWKRORW::HWKRORW( ) : ParserKeyword("HWKRORW")
{
setFixedSize( (size_t) 1);
HWKRORW::HWKRORW() : ParserKeyword("HWKRORW", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HWKRORW");
@@ -876,9 +849,7 @@ const std::string HWKRORW::keywordName = "HWKRORW";
const std::string HWKRORW::data::itemName = "data";
HWKRW::HWKRW( ) : ParserKeyword("HWKRW")
{
setFixedSize( (size_t) 1);
HWKRW::HWKRW() : ParserKeyword("HWKRW", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HWKRW");
@@ -897,9 +868,7 @@ const std::string HWKRW::keywordName = "HWKRW";
const std::string HWKRW::data::itemName = "data";
HWKRWR::HWKRWR( ) : ParserKeyword("HWKRWR")
{
setFixedSize( (size_t) 1);
HWKRWR::HWKRWR() : ParserKeyword("HWKRWR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HWKRWR");
@@ -918,9 +887,7 @@ const std::string HWKRWR::keywordName = "HWKRWR";
const std::string HWKRWR::data::itemName = "data";
HWPCW::HWPCW( ) : ParserKeyword("HWPCW")
{
setFixedSize( (size_t) 1);
HWPCW::HWPCW() : ParserKeyword("HWPCW", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HWPCW");
@@ -939,9 +906,7 @@ const std::string HWPCW::keywordName = "HWPCW";
const std::string HWPCW::data::itemName = "data";
HWSNUM::HWSNUM( ) : ParserKeyword("HWSNUM")
{
setFixedSize( (size_t) 1);
HWSNUM::HWSNUM() : ParserKeyword("HWSNUM", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("HWSNUM");
@@ -959,9 +924,7 @@ const std::string HWSNUM::keywordName = "HWSNUM";
const std::string HWSNUM::data::itemName = "data";
HWSOGCR::HWSOGCR( ) : ParserKeyword("HWSOGCR")
{
setFixedSize( (size_t) 1);
HWSOGCR::HWSOGCR() : ParserKeyword("HWSOGCR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HWSOGCR");
@@ -980,9 +943,7 @@ const std::string HWSOGCR::keywordName = "HWSOGCR";
const std::string HWSOGCR::data::itemName = "data";
HWSOWCR::HWSOWCR( ) : ParserKeyword("HWSOWCR")
{
setFixedSize( (size_t) 1);
HWSOWCR::HWSOWCR() : ParserKeyword("HWSOWCR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HWSOWCR");
@@ -1001,9 +962,7 @@ const std::string HWSOWCR::keywordName = "HWSOWCR";
const std::string HWSOWCR::data::itemName = "data";
HWSWCR::HWSWCR( ) : ParserKeyword("HWSWCR")
{
setFixedSize( (size_t) 1);
HWSWCR::HWSWCR() : ParserKeyword("HWSWCR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HWSWCR");
@@ -1022,9 +981,7 @@ const std::string HWSWCR::keywordName = "HWSWCR";
const std::string HWSWCR::data::itemName = "data";
HWSWL::HWSWL( ) : ParserKeyword("HWSWL")
{
setFixedSize( (size_t) 1);
HWSWL::HWSWL() : ParserKeyword("HWSWL", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HWSWL");
@@ -1043,9 +1000,7 @@ const std::string HWSWL::keywordName = "HWSWL";
const std::string HWSWL::data::itemName = "data";
HWSWLPC::HWSWLPC( ) : ParserKeyword("HWSWLPC")
{
setFixedSize( (size_t) 1);
HWSWLPC::HWSWLPC() : ParserKeyword("HWSWLPC", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HWSWLPC");
@@ -1064,9 +1019,7 @@ const std::string HWSWLPC::keywordName = "HWSWLPC";
const std::string HWSWLPC::data::itemName = "data";
HWSWU::HWSWU( ) : ParserKeyword("HWSWU")
{
setFixedSize( (size_t) 1);
HWSWU::HWSWU() : ParserKeyword("HWSWU", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HWSWU");
@@ -1085,9 +1038,7 @@ const std::string HWSWU::keywordName = "HWSWU";
const std::string HWSWU::data::itemName = "data";
HXFIN::HXFIN( ) : ParserKeyword("HXFIN")
{
setFixedSize( (size_t) 1);
HXFIN::HXFIN() : ParserKeyword("HXFIN", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("HXFIN");
@@ -1106,9 +1057,7 @@ const std::string HXFIN::keywordName = "HXFIN";
const std::string HXFIN::data::itemName = "data";
HYDRHEAD::HYDRHEAD( ) : ParserKeyword("HYDRHEAD")
{
setFixedSize( (size_t) 1);
HYDRHEAD::HYDRHEAD() : ParserKeyword("HYDRHEAD", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HYDRHEAD");
@@ -1139,9 +1088,7 @@ const std::string HYDRHEAD::REMOVE_DEPTH_TERMS::itemName = "REMOVE_DEPTH_TERMS";
const std::string HYDRHEAD::REMOVE_DEPTH_TERMS::defaultValue = "NO";
HYFIN::HYFIN( ) : ParserKeyword("HYFIN")
{
setFixedSize( (size_t) 1);
HYFIN::HYFIN() : ParserKeyword("HYFIN", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("HYFIN");
@@ -1160,9 +1107,7 @@ const std::string HYFIN::keywordName = "HYFIN";
const std::string HYFIN::data::itemName = "data";
HYMOBGDR::HYMOBGDR( ) : ParserKeyword("HYMOBGDR")
{
setFixedSize( (size_t) 0);
HYMOBGDR::HYMOBGDR() : ParserKeyword("HYMOBGDR", KeywordSize(0, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HYMOBGDR");
@@ -1170,9 +1115,7 @@ HYMOBGDR::HYMOBGDR( ) : ParserKeyword("HYMOBGDR")
const std::string HYMOBGDR::keywordName = "HYMOBGDR";
HYST::HYST( ) : ParserKeyword("HYST")
{
setFixedSize( (size_t) 0);
HYST::HYST() : ParserKeyword("HYST", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("HYST");
@@ -1180,9 +1123,7 @@ HYST::HYST( ) : ParserKeyword("HYST")
const std::string HYST::keywordName = "HYST";
HYSTCHCK::HYSTCHCK( ) : ParserKeyword("HYSTCHCK")
{
setFixedSize( (size_t) 1);
HYSTCHCK::HYSTCHCK() : ParserKeyword("HYSTCHCK", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("HYSTCHCK");
@@ -1194,9 +1135,7 @@ HYSTCHCK::HYSTCHCK( ) : ParserKeyword("HYSTCHCK")
const std::string HYSTCHCK::keywordName = "HYSTCHCK";
HZFIN::HZFIN( ) : ParserKeyword("HZFIN")
{
setFixedSize( (size_t) 1);
HZFIN::HZFIN() : ParserKeyword("HZFIN", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("HZFIN");

159
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/I.cpp vendored
View File

@@ -1,18 +1,17 @@
#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/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/parser/eclipse/Parser/ParserKeywords/I.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/I.hpp>
namespace Opm {
namespace ParserKeywords {
IHOST::IHOST( ) : ParserKeyword("IHOST")
{
setSizeType(SLASH_TERMINATED);
IHOST::IHOST() : ParserKeyword("IHOST", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("IHOST");
@@ -36,9 +35,7 @@ const std::string IHOST::PROCESS::itemName = "PROCESS";
const int IHOST::PROCESS::defaultValue = 0;
IMBNUM::IMBNUM( ) : ParserKeyword("IMBNUM")
{
setFixedSize( (size_t) 1);
IMBNUM::IMBNUM() : ParserKeyword("IMBNUM", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("IMBNUM");
@@ -56,9 +53,7 @@ const std::string IMBNUM::keywordName = "IMBNUM";
const std::string IMBNUM::data::itemName = "data";
IMBNUMMF::IMBNUMMF( ) : ParserKeyword("IMBNUMMF")
{
setFixedSize( (size_t) 1);
IMBNUMMF::IMBNUMMF() : ParserKeyword("IMBNUMMF", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("IMBNUMMF");
@@ -76,10 +71,7 @@ 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);
IMKRVD::IMKRVD() : ParserKeyword("IMKRVD", KeywordSize("ENDSCALE", "NTENDP", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("IMKRVD");
@@ -105,10 +97,7 @@ 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);
IMPCVD::IMPCVD() : ParserKeyword("IMPCVD", KeywordSize("ENDSCALE", "NTENDP", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("IMPCVD");
@@ -129,9 +118,7 @@ const std::string IMPCVD::keywordName = "IMPCVD";
const std::string IMPCVD::DATA::itemName = "DATA";
IMPES::IMPES( ) : ParserKeyword("IMPES")
{
setFixedSize( (size_t) 0);
IMPES::IMPES() : ParserKeyword("IMPES", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("IMPES");
@@ -139,9 +126,7 @@ IMPES::IMPES( ) : ParserKeyword("IMPES")
const std::string IMPES::keywordName = "IMPES";
IMPLICIT::IMPLICIT( ) : ParserKeyword("IMPLICIT")
{
setFixedSize( (size_t) 0);
IMPLICIT::IMPLICIT() : ParserKeyword("IMPLICIT", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("IMPLICIT");
@@ -149,11 +134,9 @@ IMPLICIT::IMPLICIT( ) : ParserKeyword("IMPLICIT")
const std::string IMPLICIT::keywordName = "IMPLICIT";
IMPORT::IMPORT( ) : ParserKeyword("IMPORT")
{
setFixedSize( (size_t) 1);
addValidSectionName("EDIT");
IMPORT::IMPORT() : ParserKeyword("IMPORT", KeywordSize(1, false)) {
addValidSectionName("GRID");
addValidSectionName("EDIT");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("SOLUTION");
@@ -179,10 +162,7 @@ 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);
IMPTVD::IMPTVD() : ParserKeyword("IMPTVD", KeywordSize("ENDSCALE", "NTENDP", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("IMPTVD");
@@ -209,10 +189,7 @@ 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);
IMSPCVD::IMSPCVD() : ParserKeyword("IMSPCVD", KeywordSize("ENDSCALE", "NTENDP", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("IMSPCVD");
@@ -233,17 +210,15 @@ const std::string IMSPCVD::keywordName = "IMSPCVD";
const std::string IMSPCVD::DATA::itemName = "DATA";
INCLUDE::INCLUDE( ) : ParserKeyword("INCLUDE")
{
setFixedSize( (size_t) 1);
INCLUDE::INCLUDE() : ParserKeyword("INCLUDE", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SUMMARY");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("INCLUDE");
{
@@ -259,9 +234,7 @@ const std::string INCLUDE::keywordName = "INCLUDE";
const std::string INCLUDE::IncludeFile::itemName = "IncludeFile";
INIT::INIT( ) : ParserKeyword("INIT")
{
setFixedSize( (size_t) 0);
INIT::INIT() : ParserKeyword("INIT", KeywordSize(0, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("INIT");
@@ -269,9 +242,7 @@ INIT::INIT( ) : ParserKeyword("INIT")
const std::string INIT::keywordName = "INIT";
INRAD::INRAD( ) : ParserKeyword("INRAD")
{
setFixedSize( (size_t) 1);
INRAD::INRAD() : ParserKeyword("INRAD", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("INRAD");
@@ -289,9 +260,7 @@ const std::string INRAD::keywordName = "INRAD";
const std::string INRAD::RADIUS::itemName = "RADIUS";
INSPEC::INSPEC( ) : ParserKeyword("INSPEC")
{
setFixedSize( (size_t) 0);
INSPEC::INSPEC() : ParserKeyword("INSPEC", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("INSPEC");
@@ -299,9 +268,7 @@ INSPEC::INSPEC( ) : ParserKeyword("INSPEC")
const std::string INSPEC::keywordName = "INSPEC";
INTPC::INTPC( ) : ParserKeyword("INTPC")
{
setFixedSize( (size_t) 1);
INTPC::INTPC() : ParserKeyword("INTPC", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("INTPC");
@@ -320,9 +287,7 @@ const std::string INTPC::PHASE::itemName = "PHASE";
const std::string INTPC::PHASE::defaultValue = "BOTH";
IONROCK::IONROCK( ) : ParserKeyword("IONROCK")
{
setFixedSize( (size_t) 1);
IONROCK::IONROCK() : ParserKeyword("IONROCK", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("IONROCK");
@@ -340,10 +305,7 @@ 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);
IONXROCK::IONXROCK() : ParserKeyword("IONXROCK", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("IONXROCK");
@@ -359,13 +321,10 @@ IONXROCK::IONXROCK( ) : ParserKeyword("IONXROCK")
}
const std::string IONXROCK::keywordName = "IONXROCK";
const std::string IONXROCK::VALUE::itemName = "VALUE";
const double IONXROCK::VALUE::defaultValue = 0.000000;
const double IONXROCK::VALUE::defaultValue = 0;
IONXSURF::IONXSURF( ) : ParserKeyword("IONXSURF")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
IONXSURF::IONXSURF() : ParserKeyword("IONXSURF", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("IONXSURF");
@@ -386,13 +345,14 @@ IONXSURF::IONXSURF( ) : ParserKeyword("IONXSURF")
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;
const double IONXSURF::ION_EXCH_CONST::defaultValue = 0;
IPCG::IPCG( ) : ParserKeyword("IPCG")
{
setFixedSize( (size_t) 1);
IPCG::IPCG() : ParserKeyword("IPCG", KeywordSize(1, false)) {
addValidSectionName("PROPS");
setRequiredKeywords({
"ENDSCALE",
});
clearDeckNames();
addDeckName("IPCG");
{
@@ -410,10 +370,11 @@ const std::string IPCG::keywordName = "IPCG";
const std::string IPCG::data::itemName = "data";
IPCW::IPCW( ) : ParserKeyword("IPCW")
{
setFixedSize( (size_t) 1);
IPCW::IPCW() : ParserKeyword("IPCW", KeywordSize(1, false)) {
addValidSectionName("PROPS");
setRequiredKeywords({
"ENDSCALE",
});
clearDeckNames();
addDeckName("IPCW");
{
@@ -431,9 +392,7 @@ const std::string IPCW::keywordName = "IPCW";
const std::string IPCW::data::itemName = "data";
ISGCR::ISGCR( ) : ParserKeyword("ISGCR")
{
setFixedSize( (size_t) 1);
ISGCR::ISGCR() : ParserKeyword("ISGCR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ISGCR");
@@ -452,9 +411,7 @@ const std::string ISGCR::keywordName = "ISGCR";
const std::string ISGCR::data::itemName = "data";
ISGL::ISGL( ) : ParserKeyword("ISGL")
{
setFixedSize( (size_t) 1);
ISGL::ISGL() : ParserKeyword("ISGL", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ISGL");
@@ -473,9 +430,7 @@ const std::string ISGL::keywordName = "ISGL";
const std::string ISGL::data::itemName = "data";
ISGLPC::ISGLPC( ) : ParserKeyword("ISGLPC")
{
setFixedSize( (size_t) 1);
ISGLPC::ISGLPC() : ParserKeyword("ISGLPC", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ISGLPC");
@@ -494,9 +449,7 @@ const std::string ISGLPC::keywordName = "ISGLPC";
const std::string ISGLPC::data::itemName = "data";
ISGU::ISGU( ) : ParserKeyword("ISGU")
{
setFixedSize( (size_t) 1);
ISGU::ISGU() : ParserKeyword("ISGU", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ISGU");
@@ -515,9 +468,7 @@ const std::string ISGU::keywordName = "ISGU";
const std::string ISGU::data::itemName = "data";
ISOGCR::ISOGCR( ) : ParserKeyword("ISOGCR")
{
setFixedSize( (size_t) 1);
ISOGCR::ISOGCR() : ParserKeyword("ISOGCR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ISOGCR");
@@ -536,9 +487,7 @@ const std::string ISOGCR::keywordName = "ISOGCR";
const std::string ISOGCR::data::itemName = "data";
ISOLNUM::ISOLNUM( ) : ParserKeyword("ISOLNUM")
{
setFixedSize( (size_t) 1);
ISOLNUM::ISOLNUM() : ParserKeyword("ISOLNUM", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("ISOLNUM");
@@ -556,9 +505,7 @@ const std::string ISOLNUM::keywordName = "ISOLNUM";
const std::string ISOLNUM::data::itemName = "data";
ISOWCR::ISOWCR( ) : ParserKeyword("ISOWCR")
{
setFixedSize( (size_t) 1);
ISOWCR::ISOWCR() : ParserKeyword("ISOWCR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ISOWCR");
@@ -577,9 +524,7 @@ const std::string ISOWCR::keywordName = "ISOWCR";
const std::string ISOWCR::data::itemName = "data";
ISWCR::ISWCR( ) : ParserKeyword("ISWCR")
{
setFixedSize( (size_t) 1);
ISWCR::ISWCR() : ParserKeyword("ISWCR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ISWCR");
@@ -598,9 +543,7 @@ const std::string ISWCR::keywordName = "ISWCR";
const std::string ISWCR::data::itemName = "data";
ISWL::ISWL( ) : ParserKeyword("ISWL")
{
setFixedSize( (size_t) 1);
ISWL::ISWL() : ParserKeyword("ISWL", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ISWL");
@@ -619,9 +562,7 @@ const std::string ISWL::keywordName = "ISWL";
const std::string ISWL::data::itemName = "data";
ISWLPC::ISWLPC( ) : ParserKeyword("ISWLPC")
{
setFixedSize( (size_t) 1);
ISWLPC::ISWLPC() : ParserKeyword("ISWLPC", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ISWLPC");
@@ -640,9 +581,7 @@ const std::string ISWLPC::keywordName = "ISWLPC";
const std::string ISWLPC::data::itemName = "data";
ISWU::ISWU( ) : ParserKeyword("ISWU")
{
setFixedSize( (size_t) 1);
ISWU::ISWU() : ParserKeyword("ISWU", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ISWU");

26
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/J.cpp vendored
View File

@@ -1,19 +1,21 @@
#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/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/parser/eclipse/Parser/ParserKeywords/J.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/J.hpp>
namespace Opm {
namespace ParserKeywords {
JFUNC::JFUNC( ) : ParserKeyword("JFUNC")
{
setFixedSize( (size_t) 1);
JFUNC::JFUNC() : ParserKeyword("JFUNC", KeywordSize(1, false)) {
addValidSectionName("GRID");
setRequiredKeywords({
"ENDSCALE",
});
clearDeckNames();
addDeckName("JFUNC");
{
@@ -68,11 +70,11 @@ 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);
JFUNCR::JFUNCR() : ParserKeyword("JFUNCR", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("GRID");
setRequiredKeywords({
"ENDSCALE",
});
clearDeckNames();
addDeckName("JFUNCR");
{

30
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/K.cpp vendored
View File

@@ -1,21 +1,29 @@
#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/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/parser/eclipse/Parser/ParserKeywords/K.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/K.hpp>
namespace Opm {
namespace ParserKeywords {
KRNUM::KRNUM( ) : ParserKeyword("KRNUM")
{
setFixedSize( (size_t) 1);
KRNUM::KRNUM() : ParserKeyword("KRNUM", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("KRNUM");
addDeckName("KRNUMX");
addDeckName("KRNUMX-");
addDeckName("KRNUMY");
addDeckName("KRNUMY-");
addDeckName("KRNUMR");
addDeckName("KRNUMZ");
addDeckName("KRNUMR-");
addDeckName("KRNUMZ-");
addDeckName("KRNUMT");
addDeckName("KRNUMT-");
{
ParserRecord record;
{
@@ -30,9 +38,7 @@ const std::string KRNUM::keywordName = "KRNUM";
const std::string KRNUM::data::itemName = "data";
KRNUMMF::KRNUMMF( ) : ParserKeyword("KRNUMMF")
{
setFixedSize( (size_t) 1);
KRNUMMF::KRNUMMF() : ParserKeyword("KRNUMMF", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("KRNUMMF");

257
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/L.cpp vendored
View File

@@ -1,18 +1,17 @@
#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/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/parser/eclipse/Parser/ParserKeywords/L.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/L.hpp>
namespace Opm {
namespace ParserKeywords {
LAB::LAB( ) : ParserKeyword("LAB")
{
setFixedSize( (size_t) 0);
LAB::LAB() : ParserKeyword("LAB", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("LAB");
@@ -20,9 +19,7 @@ LAB::LAB( ) : ParserKeyword("LAB")
const std::string LAB::keywordName = "LAB";
LANGMPL::LANGMPL( ) : ParserKeyword("LANGMPL")
{
setFixedSize( (size_t) 1);
LANGMPL::LANGMPL() : ParserKeyword("LANGMPL", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LANGMPL");
@@ -41,10 +38,7 @@ const std::string LANGMPL::keywordName = "LANGMPL";
const std::string LANGMPL::data::itemName = "data";
LANGMUIR::LANGMUIR( ) : ParserKeyword("LANGMUIR")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("REGDIMS","NTCREG",0);
LANGMUIR::LANGMUIR() : ParserKeyword("LANGMUIR", KeywordSize("REGDIMS", "NTCREG", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LANGMUIR");
@@ -65,10 +59,7 @@ const std::string LANGMUIR::keywordName = "LANGMUIR";
const std::string LANGMUIR::DATA::itemName = "DATA";
LANGSOLV::LANGSOLV( ) : ParserKeyword("LANGSOLV")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("REGDIMS","NTCREG",0);
LANGSOLV::LANGSOLV() : ParserKeyword("LANGSOLV", KeywordSize("REGDIMS", "NTCREG", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LANGSOLV");
@@ -88,9 +79,7 @@ const std::string LANGSOLV::keywordName = "LANGSOLV";
const std::string LANGSOLV::DATA::itemName = "DATA";
LCUNIT::LCUNIT( ) : ParserKeyword("LCUNIT")
{
setFixedSize( (size_t) 1);
LCUNIT::LCUNIT() : ParserKeyword("LCUNIT", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LCUNIT");
@@ -109,9 +98,7 @@ const std::string LCUNIT::UNIT::itemName = "UNIT";
const std::string LCUNIT::UNIT::defaultValue = "UNIT";
LGR::LGR( ) : ParserKeyword("LGR")
{
setFixedSize( (size_t) 1);
LGR::LGR() : ParserKeyword("LGR", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("LGR");
@@ -179,21 +166,17 @@ const std::string LGR::NCHCOR::itemName = "NCHCOR";
const int LGR::NCHCOR::defaultValue = 0;
LGRCOPY::LGRCOPY( ) : ParserKeyword("LGRCOPY")
{
setFixedSize( (size_t) 0);
LGRCOPY::LGRCOPY() : ParserKeyword("LGRCOPY", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("LGRCOPY");
}
const std::string LGRCOPY::keywordName = "LGRCOPY";
LGRFREE::LGRFREE( ) : ParserKeyword("LGRFREE")
{
setSizeType(SLASH_TERMINATED);
LGRFREE::LGRFREE() : ParserKeyword("LGRFREE", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("LGRFREE");
@@ -210,9 +193,7 @@ const std::string LGRFREE::keywordName = "LGRFREE";
const std::string LGRFREE::LOCAL_GRID_REFINMENT::itemName = "LOCAL_GRID_REFINMENT";
LGRLOCK::LGRLOCK( ) : ParserKeyword("LGRLOCK")
{
setSizeType(SLASH_TERMINATED);
LGRLOCK::LGRLOCK() : ParserKeyword("LGRLOCK", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("LGRLOCK");
@@ -229,9 +210,7 @@ const std::string LGRLOCK::keywordName = "LGRLOCK";
const std::string LGRLOCK::LOCAL_GRID_REFINMENT::itemName = "LOCAL_GRID_REFINMENT";
LGROFF::LGROFF( ) : ParserKeyword("LGROFF")
{
setFixedSize( (size_t) 1);
LGROFF::LGROFF() : ParserKeyword("LGROFF", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("LGROFF");
@@ -255,9 +234,7 @@ const std::string LGROFF::ACTIVE_WELLS::itemName = "ACTIVE_WELLS";
const int LGROFF::ACTIVE_WELLS::defaultValue = 0;
LGRON::LGRON( ) : ParserKeyword("LGRON")
{
setFixedSize( (size_t) 1);
LGRON::LGRON() : ParserKeyword("LGRON", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("LGRON");
@@ -281,12 +258,10 @@ const std::string LGRON::ACTIVE_WELLS::itemName = "ACTIVE_WELLS";
const int LGRON::ACTIVE_WELLS::defaultValue = 0;
LICENSE::LICENSE( ) : ParserKeyword("LICENSE")
{
setSizeType(SLASH_TERMINATED);
LICENSES::LICENSES() : ParserKeyword("LICENSES", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("LICENSE");
addDeckName("LICENSES");
{
ParserRecord record;
{
@@ -296,13 +271,11 @@ LICENSE::LICENSE( ) : ParserKeyword("LICENSE")
addRecord( record );
}
}
const std::string LICENSE::keywordName = "LICENSE";
const std::string LICENSE::FEATURE::itemName = "FEATURE";
const std::string LICENSES::keywordName = "LICENSES";
const std::string LICENSES::FEATURE::itemName = "FEATURE";
LIFTOPT::LIFTOPT( ) : ParserKeyword("LIFTOPT")
{
setFixedSize( (size_t) 1);
LIFTOPT::LIFTOPT() : ParserKeyword("LIFTOPT", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("LIFTOPT");
@@ -310,19 +283,22 @@ LIFTOPT::LIFTOPT( ) : ParserKeyword("LIFTOPT")
ParserRecord record;
{
ParserItem item("INCREMENT_SIZE", ParserItem::itype::DOUBLE);
item.push_backDimension("GasSurfaceVolume/Time");
record.addItem(item);
}
{
ParserItem item("MIN_ECONOMIC_GRADIENT", ParserItem::itype::DOUBLE);
item.push_backDimension("LiquidSurfaceVolume/GasSurfaceVolume");
record.addItem(item);
}
{
ParserItem item("MIN_INTERVAL_BETWEEN_GAS_LIFT_OPTIMIZATIONS", ParserItem::itype::DOUBLE);
item.setDefault( double(0) );
item.push_backDimension("Time");
record.addItem(item);
}
{
ParserItem item("OPTIMISE_GAS_LIFT", ParserItem::itype::STRING);
ParserItem item("OPTIMISE_ALL_ITERATIONS", ParserItem::itype::STRING);
item.setDefault( std::string("YES") );
record.addItem(item);
}
@@ -333,14 +309,12 @@ const std::string LIFTOPT::keywordName = "LIFTOPT";
const std::string LIFTOPT::INCREMENT_SIZE::itemName = "INCREMENT_SIZE";
const std::string LIFTOPT::MIN_ECONOMIC_GRADIENT::itemName = "MIN_ECONOMIC_GRADIENT";
const std::string LIFTOPT::MIN_INTERVAL_BETWEEN_GAS_LIFT_OPTIMIZATIONS::itemName = "MIN_INTERVAL_BETWEEN_GAS_LIFT_OPTIMIZATIONS";
const double LIFTOPT::MIN_INTERVAL_BETWEEN_GAS_LIFT_OPTIMIZATIONS::defaultValue = 0.000000;
const std::string LIFTOPT::OPTIMISE_GAS_LIFT::itemName = "OPTIMISE_GAS_LIFT";
const std::string LIFTOPT::OPTIMISE_GAS_LIFT::defaultValue = "YES";
const double LIFTOPT::MIN_INTERVAL_BETWEEN_GAS_LIFT_OPTIMIZATIONS::defaultValue = 0;
const std::string LIFTOPT::OPTIMISE_ALL_ITERATIONS::itemName = "OPTIMISE_ALL_ITERATIONS";
const std::string LIFTOPT::OPTIMISE_ALL_ITERATIONS::defaultValue = "YES";
LINCOM::LINCOM( ) : ParserKeyword("LINCOM")
{
setFixedSize( (size_t) 1);
LINCOM::LINCOM() : ParserKeyword("LINCOM", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("LINCOM");
@@ -366,16 +340,14 @@ LINCOM::LINCOM( ) : ParserKeyword("LINCOM")
}
const std::string LINCOM::keywordName = "LINCOM";
const std::string LINCOM::ALPHA::itemName = "ALPHA";
const UDAValue LINCOM::ALPHA::defaultValue = UDAValue(0.000000);
const UDAValue LINCOM::ALPHA::defaultValue = UDAValue(0);
const std::string LINCOM::BETA::itemName = "BETA";
const UDAValue LINCOM::BETA::defaultValue = UDAValue(0.000000);
const UDAValue LINCOM::BETA::defaultValue = UDAValue(0);
const std::string LINCOM::GAMMA::itemName = "GAMMA";
const UDAValue LINCOM::GAMMA::defaultValue = UDAValue(0.000000);
const UDAValue LINCOM::GAMMA::defaultValue = UDAValue(0);
LINKPERM::LINKPERM( ) : ParserKeyword("LINKPERM")
{
setFixedSize( (size_t) 1);
LINKPERM::LINKPERM() : ParserKeyword("LINKPERM", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("LINKPERM");
@@ -393,9 +365,7 @@ const std::string LINKPERM::keywordName = "LINKPERM";
const std::string LINKPERM::data::itemName = "data";
LIVEOIL::LIVEOIL( ) : ParserKeyword("LIVEOIL")
{
setFixedSize( (size_t) 0);
LIVEOIL::LIVEOIL() : ParserKeyword("LIVEOIL", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("LIVEOIL");
@@ -403,9 +373,7 @@ LIVEOIL::LIVEOIL( ) : ParserKeyword("LIVEOIL")
const std::string LIVEOIL::keywordName = "LIVEOIL";
LKRO::LKRO( ) : ParserKeyword("LKRO")
{
setFixedSize( (size_t) 1);
LKRO::LKRO() : ParserKeyword("LKRO", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LKRO");
@@ -424,9 +392,7 @@ const std::string LKRO::keywordName = "LKRO";
const std::string LKRO::data::itemName = "data";
LKRORG::LKRORG( ) : ParserKeyword("LKRORG")
{
setFixedSize( (size_t) 1);
LKRORG::LKRORG() : ParserKeyword("LKRORG", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LKRORG");
@@ -445,9 +411,7 @@ const std::string LKRORG::keywordName = "LKRORG";
const std::string LKRORG::data::itemName = "data";
LKRORW::LKRORW( ) : ParserKeyword("LKRORW")
{
setFixedSize( (size_t) 1);
LKRORW::LKRORW() : ParserKeyword("LKRORW", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LKRORW");
@@ -466,9 +430,7 @@ const std::string LKRORW::keywordName = "LKRORW";
const std::string LKRORW::data::itemName = "data";
LKRW::LKRW( ) : ParserKeyword("LKRW")
{
setFixedSize( (size_t) 1);
LKRW::LKRW() : ParserKeyword("LKRW", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LKRW");
@@ -487,9 +449,7 @@ const std::string LKRW::keywordName = "LKRW";
const std::string LKRW::data::itemName = "data";
LKRWR::LKRWR( ) : ParserKeyword("LKRWR")
{
setFixedSize( (size_t) 1);
LKRWR::LKRWR() : ParserKeyword("LKRWR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LKRWR");
@@ -508,9 +468,7 @@ const std::string LKRWR::keywordName = "LKRWR";
const std::string LKRWR::data::itemName = "data";
LOAD::LOAD( ) : ParserKeyword("LOAD")
{
setFixedSize( (size_t) 1);
LOAD::LOAD() : ParserKeyword("LOAD", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("LOAD");
@@ -553,9 +511,7 @@ const std::string LOAD::REQUEST_SAVE_OUTPUT::itemName = "REQUEST_SAVE_OUTPUT";
const std::string LOAD::REQUEST_SAVE_OUTPUT::defaultValue = "NO";
LOWSALT::LOWSALT( ) : ParserKeyword("LOWSALT")
{
setFixedSize( (size_t) 0);
LOWSALT::LOWSALT() : ParserKeyword("LOWSALT", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("LOWSALT");
@@ -563,9 +519,7 @@ LOWSALT::LOWSALT( ) : ParserKeyword("LOWSALT")
const std::string LOWSALT::keywordName = "LOWSALT";
LPCW::LPCW( ) : ParserKeyword("LPCW")
{
setFixedSize( (size_t) 1);
LPCW::LPCW() : ParserKeyword("LPCW", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LPCW");
@@ -584,10 +538,7 @@ const std::string LPCW::keywordName = "LPCW";
const std::string LPCW::data::itemName = "data";
LSALTFNC::LSALTFNC( ) : ParserKeyword("LSALTFNC")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
LSALTFNC::LSALTFNC() : ParserKeyword("LSALTFNC", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LSALTFNC");
@@ -608,9 +559,7 @@ const std::string LSALTFNC::keywordName = "LSALTFNC";
const std::string LSALTFNC::DATA::itemName = "DATA";
LSLTWNUM::LSLTWNUM( ) : ParserKeyword("LSLTWNUM")
{
setFixedSize( (size_t) 1);
LSLTWNUM::LSLTWNUM() : ParserKeyword("LSLTWNUM", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("LSLTWNUM");
@@ -628,9 +577,7 @@ const std::string LSLTWNUM::keywordName = "LSLTWNUM";
const std::string LSLTWNUM::data::itemName = "data";
LSNUM::LSNUM( ) : ParserKeyword("LSNUM")
{
setFixedSize( (size_t) 1);
LSNUM::LSNUM() : ParserKeyword("LSNUM", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("LSNUM");
@@ -648,9 +595,7 @@ const std::string LSNUM::keywordName = "LSNUM";
const std::string LSNUM::data::itemName = "data";
LSOGCR::LSOGCR( ) : ParserKeyword("LSOGCR")
{
setFixedSize( (size_t) 1);
LSOGCR::LSOGCR() : ParserKeyword("LSOGCR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LSOGCR");
@@ -669,9 +614,7 @@ const std::string LSOGCR::keywordName = "LSOGCR";
const std::string LSOGCR::data::itemName = "data";
LSOWCR::LSOWCR( ) : ParserKeyword("LSOWCR")
{
setFixedSize( (size_t) 1);
LSOWCR::LSOWCR() : ParserKeyword("LSOWCR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LSOWCR");
@@ -690,9 +633,7 @@ const std::string LSOWCR::keywordName = "LSOWCR";
const std::string LSOWCR::data::itemName = "data";
LSWCR::LSWCR( ) : ParserKeyword("LSWCR")
{
setFixedSize( (size_t) 1);
LSWCR::LSWCR() : ParserKeyword("LSWCR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LSWCR");
@@ -711,9 +652,7 @@ const std::string LSWCR::keywordName = "LSWCR";
const std::string LSWCR::data::itemName = "data";
LSWL::LSWL( ) : ParserKeyword("LSWL")
{
setFixedSize( (size_t) 1);
LSWL::LSWL() : ParserKeyword("LSWL", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LSWL");
@@ -732,9 +671,7 @@ const std::string LSWL::keywordName = "LSWL";
const std::string LSWL::data::itemName = "data";
LSWLPC::LSWLPC( ) : ParserKeyword("LSWLPC")
{
setFixedSize( (size_t) 1);
LSWLPC::LSWLPC() : ParserKeyword("LSWLPC", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LSWLPC");
@@ -753,9 +690,7 @@ const std::string LSWLPC::keywordName = "LSWLPC";
const std::string LSWLPC::data::itemName = "data";
LSWU::LSWU( ) : ParserKeyword("LSWU")
{
setFixedSize( (size_t) 1);
LSWU::LSWU() : ParserKeyword("LSWU", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LSWU");
@@ -774,9 +709,7 @@ const std::string LSWU::keywordName = "LSWU";
const std::string LSWU::data::itemName = "data";
LTOSIGMA::LTOSIGMA( ) : ParserKeyword("LTOSIGMA")
{
setFixedSize( (size_t) 1);
LTOSIGMA::LTOSIGMA() : ParserKeyword("LTOSIGMA", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("LTOSIGMA");
@@ -822,14 +755,12 @@ const double LTOSIGMA::FY::defaultValue = 4.000000;
const std::string LTOSIGMA::FZ::itemName = "FZ";
const double LTOSIGMA::FZ::defaultValue = 4.000000;
const std::string LTOSIGMA::FGD::itemName = "FGD";
const double LTOSIGMA::FGD::defaultValue = 0.000000;
const double LTOSIGMA::FGD::defaultValue = 0;
const std::string LTOSIGMA::OPTION::itemName = "OPTION";
const std::string LTOSIGMA::OPTION::defaultValue = "XONLY";
LWKRO::LWKRO( ) : ParserKeyword("LWKRO")
{
setFixedSize( (size_t) 1);
LWKRO::LWKRO() : ParserKeyword("LWKRO", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LWKRO");
@@ -848,9 +779,7 @@ const std::string LWKRO::keywordName = "LWKRO";
const std::string LWKRO::data::itemName = "data";
LWKRORG::LWKRORG( ) : ParserKeyword("LWKRORG")
{
setFixedSize( (size_t) 1);
LWKRORG::LWKRORG() : ParserKeyword("LWKRORG", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LWKRORG");
@@ -869,9 +798,7 @@ const std::string LWKRORG::keywordName = "LWKRORG";
const std::string LWKRORG::data::itemName = "data";
LWKRORW::LWKRORW( ) : ParserKeyword("LWKRORW")
{
setFixedSize( (size_t) 1);
LWKRORW::LWKRORW() : ParserKeyword("LWKRORW", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LWKRORW");
@@ -890,9 +817,7 @@ const std::string LWKRORW::keywordName = "LWKRORW";
const std::string LWKRORW::data::itemName = "data";
LWKRW::LWKRW( ) : ParserKeyword("LWKRW")
{
setFixedSize( (size_t) 1);
LWKRW::LWKRW() : ParserKeyword("LWKRW", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LWKRW");
@@ -911,9 +836,7 @@ const std::string LWKRW::keywordName = "LWKRW";
const std::string LWKRW::data::itemName = "data";
LWKRWR::LWKRWR( ) : ParserKeyword("LWKRWR")
{
setFixedSize( (size_t) 1);
LWKRWR::LWKRWR() : ParserKeyword("LWKRWR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LWKRWR");
@@ -932,9 +855,7 @@ const std::string LWKRWR::keywordName = "LWKRWR";
const std::string LWKRWR::data::itemName = "data";
LWPCW::LWPCW( ) : ParserKeyword("LWPCW")
{
setFixedSize( (size_t) 1);
LWPCW::LWPCW() : ParserKeyword("LWPCW", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LWPCW");
@@ -953,9 +874,7 @@ const std::string LWPCW::keywordName = "LWPCW";
const std::string LWPCW::data::itemName = "data";
LWSLTNUM::LWSLTNUM( ) : ParserKeyword("LWSLTNUM")
{
setFixedSize( (size_t) 1);
LWSLTNUM::LWSLTNUM() : ParserKeyword("LWSLTNUM", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("LWSLTNUM");
@@ -973,9 +892,7 @@ const std::string LWSLTNUM::keywordName = "LWSLTNUM";
const std::string LWSLTNUM::data::itemName = "data";
LWSNUM::LWSNUM( ) : ParserKeyword("LWSNUM")
{
setFixedSize( (size_t) 1);
LWSNUM::LWSNUM() : ParserKeyword("LWSNUM", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("LWSNUM");
@@ -993,9 +910,7 @@ const std::string LWSNUM::keywordName = "LWSNUM";
const std::string LWSNUM::data::itemName = "data";
LWSOGCR::LWSOGCR( ) : ParserKeyword("LWSOGCR")
{
setFixedSize( (size_t) 1);
LWSOGCR::LWSOGCR() : ParserKeyword("LWSOGCR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LWSOGCR");
@@ -1014,9 +929,7 @@ const std::string LWSOGCR::keywordName = "LWSOGCR";
const std::string LWSOGCR::data::itemName = "data";
LWSOWCR::LWSOWCR( ) : ParserKeyword("LWSOWCR")
{
setFixedSize( (size_t) 1);
LWSOWCR::LWSOWCR() : ParserKeyword("LWSOWCR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LWSOWCR");
@@ -1035,9 +948,7 @@ const std::string LWSOWCR::keywordName = "LWSOWCR";
const std::string LWSOWCR::data::itemName = "data";
LWSWCR::LWSWCR( ) : ParserKeyword("LWSWCR")
{
setFixedSize( (size_t) 1);
LWSWCR::LWSWCR() : ParserKeyword("LWSWCR", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LWSWCR");
@@ -1056,9 +967,7 @@ const std::string LWSWCR::keywordName = "LWSWCR";
const std::string LWSWCR::data::itemName = "data";
LWSWL::LWSWL( ) : ParserKeyword("LWSWL")
{
setFixedSize( (size_t) 1);
LWSWL::LWSWL() : ParserKeyword("LWSWL", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LWSWL");
@@ -1077,9 +986,7 @@ const std::string LWSWL::keywordName = "LWSWL";
const std::string LWSWL::data::itemName = "data";
LWSWLPC::LWSWLPC( ) : ParserKeyword("LWSWLPC")
{
setFixedSize( (size_t) 1);
LWSWLPC::LWSWLPC() : ParserKeyword("LWSWLPC", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LWSWLPC");
@@ -1098,9 +1005,7 @@ const std::string LWSWLPC::keywordName = "LWSWLPC";
const std::string LWSWLPC::data::itemName = "data";
LWSWU::LWSWU( ) : ParserKeyword("LWSWU")
{
setFixedSize( (size_t) 1);
LWSWU::LWSWU() : ParserKeyword("LWSWU", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("LWSWU");
@@ -1119,9 +1024,7 @@ const std::string LWSWU::keywordName = "LWSWU";
const std::string LWSWU::data::itemName = "data";
LX::LX( ) : ParserKeyword("LX")
{
setFixedSize( (size_t) 1);
LX::LX() : ParserKeyword("LX", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("LX");
@@ -1140,9 +1043,7 @@ const std::string LX::keywordName = "LX";
const std::string LX::data::itemName = "data";
LXFIN::LXFIN( ) : ParserKeyword("LXFIN")
{
setFixedSize( (size_t) 1);
LXFIN::LXFIN() : ParserKeyword("LXFIN", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("LXFIN");
@@ -1165,9 +1066,7 @@ const std::string LXFIN::CELL_THICKNESS::itemName = "CELL_THICKNESS";
const std::string LXFIN::SIZE_OPTION::itemName = "SIZE_OPTION";
LY::LY( ) : ParserKeyword("LY")
{
setFixedSize( (size_t) 1);
LY::LY() : ParserKeyword("LY", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("LY");
@@ -1186,9 +1085,7 @@ const std::string LY::keywordName = "LY";
const std::string LY::data::itemName = "data";
LYFIN::LYFIN( ) : ParserKeyword("LYFIN")
{
setFixedSize( (size_t) 1);
LYFIN::LYFIN() : ParserKeyword("LYFIN", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("LYFIN");
@@ -1211,9 +1108,7 @@ const std::string LYFIN::CELL_THICKNESS::itemName = "CELL_THICKNESS";
const std::string LYFIN::SIZE_OPTION::itemName = "SIZE_OPTION";
LZ::LZ( ) : ParserKeyword("LZ")
{
setFixedSize( (size_t) 1);
LZ::LZ() : ParserKeyword("LZ", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("LZ");
@@ -1232,9 +1127,7 @@ const std::string LZ::keywordName = "LZ";
const std::string LZ::data::itemName = "data";
LZFIN::LZFIN( ) : ParserKeyword("LZFIN")
{
setFixedSize( (size_t) 1);
LZFIN::LZFIN() : ParserKeyword("LZFIN", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("LZFIN");

487
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/M.cpp vendored
View File

@@ -1,68 +1,36 @@
#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/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/parser/eclipse/Parser/ParserKeywords/M.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/M.hpp>
namespace Opm {
namespace ParserKeywords {
MAPAXES::MAPAXES( ) : ParserKeyword("MAPAXES")
{
setFixedSize( (size_t) 1);
MAPAXES::MAPAXES() : ParserKeyword("MAPAXES", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("MAPAXES");
{
ParserRecord record;
{
ParserItem item("X1", ParserItem::itype::DOUBLE);
ParserItem item("data", ParserItem::itype::DOUBLE);
item.setSizeType(ParserItem::item_size::ALL);
item.push_backDimension("Length");
record.addItem(item);
record.addDataItem(item);
}
{
ParserItem item("Y1", ParserItem::itype::DOUBLE);
item.push_backDimension("Length");
record.addItem(item);
}
{
ParserItem item("X2", ParserItem::itype::DOUBLE);
item.push_backDimension("Length");
record.addItem(item);
}
{
ParserItem item("Y2", ParserItem::itype::DOUBLE);
item.push_backDimension("Length");
record.addItem(item);
}
{
ParserItem item("X3", ParserItem::itype::DOUBLE);
item.push_backDimension("Length");
record.addItem(item);
}
{
ParserItem item("Y3", ParserItem::itype::DOUBLE);
item.push_backDimension("Length");
record.addItem(item);
}
addRecord( record );
addDataRecord( record );
}
}
const std::string MAPAXES::keywordName = "MAPAXES";
const std::string MAPAXES::X1::itemName = "X1";
const std::string MAPAXES::Y1::itemName = "Y1";
const std::string MAPAXES::X2::itemName = "X2";
const std::string MAPAXES::Y2::itemName = "Y2";
const std::string MAPAXES::X3::itemName = "X3";
const std::string MAPAXES::Y3::itemName = "Y3";
const std::string MAPAXES::data::itemName = "data";
MAPUNITS::MAPUNITS( ) : ParserKeyword("MAPUNITS")
{
setFixedSize( (size_t) 1);
MAPUNITS::MAPUNITS() : ParserKeyword("MAPUNITS", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("MAPUNITS");
@@ -81,9 +49,7 @@ const std::string MAPUNITS::UNIT::itemName = "UNIT";
const std::string MAPUNITS::UNIT::defaultValue = "METRES";
MASSFLOW::MASSFLOW( ) : ParserKeyword("MASSFLOW")
{
setSizeType(SLASH_TERMINATED);
MASSFLOW::MASSFLOW() : ParserKeyword("MASSFLOW", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("MASSFLOW");
@@ -101,9 +67,7 @@ const std::string MASSFLOW::keywordName = "MASSFLOW";
const std::string MASSFLOW::WORD::itemName = "WORD";
MATCORR::MATCORR( ) : ParserKeyword("MATCORR")
{
setFixedSize( (size_t) 1);
MATCORR::MATCORR() : ParserKeyword("MATCORR", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("MATCORR");
@@ -135,14 +99,12 @@ const int MATCORR::NEWTON_IT_NUM::defaultValue = 12;
const std::string MATCORR::NON_LIN_CONV_ERR::itemName = "NON_LIN_CONV_ERR";
const double MATCORR::NON_LIN_CONV_ERR::defaultValue = 0.010000;
const std::string MATCORR::MATERIAL_BALANCE_ERR::itemName = "MATERIAL_BALANCE_ERR";
const double MATCORR::MATERIAL_BALANCE_ERR::defaultValue = 0.000001;
const double MATCORR::MATERIAL_BALANCE_ERR::defaultValue = 1e-06;
MAXVALUE::MAXVALUE( ) : ParserKeyword("MAXVALUE")
{
setSizeType(SLASH_TERMINATED);
addValidSectionName("EDIT");
MAXVALUE::MAXVALUE() : ParserKeyword("MAXVALUE", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
addValidSectionName("EDIT");
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("MAXVALUE");
@@ -194,9 +156,7 @@ const std::string MAXVALUE::K1::itemName = "K1";
const std::string MAXVALUE::K2::itemName = "K2";
MEMORY::MEMORY( ) : ParserKeyword("MEMORY")
{
setFixedSize( (size_t) 1);
MEMORY::MEMORY() : ParserKeyword("MEMORY", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("MEMORY");
@@ -218,17 +178,15 @@ const std::string MEMORY::UNUSED::itemName = "UNUSED";
const std::string MEMORY::THOUSANDS_CHAR8::itemName = "THOUSANDS_CHAR8";
MESSAGE::MESSAGE( ) : ParserKeyword("MESSAGE")
{
setFixedSize( (size_t) 1);
MESSAGE::MESSAGE() : ParserKeyword("MESSAGE", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SUMMARY");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("MESSAGE");
{
@@ -245,17 +203,15 @@ const std::string MESSAGE::keywordName = "MESSAGE";
const std::string MESSAGE::MessageText::itemName = "MessageText";
MESSAGES::MESSAGES( ) : ParserKeyword("MESSAGES")
{
setFixedSize( (size_t) 1);
MESSAGES::MESSAGES() : ParserKeyword("MESSAGES", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SUMMARY");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("MESSAGES");
{
@@ -357,9 +313,7 @@ const std::string MESSAGES::GROUP_PRINT_LIMIT::itemName = "GROUP_PRINT_LIMIT";
const int MESSAGES::GROUP_PRINT_LIMIT::defaultValue = 10;
MESSOPTS::MESSOPTS( ) : ParserKeyword("MESSOPTS")
{
setFixedSize( (size_t) 1);
MESSOPTS::MESSOPTS() : ParserKeyword("MESSOPTS", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("MESSOPTS");
@@ -381,9 +335,7 @@ const std::string MESSOPTS::MNEMONIC::itemName = "MNEMONIC";
const std::string MESSOPTS::SEVERITY::itemName = "SEVERITY";
MESSSRVC::MESSSRVC( ) : ParserKeyword("MESSSRVC")
{
setFixedSize( (size_t) 1);
MESSSRVC::MESSSRVC() : ParserKeyword("MESSSRVC", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("MESSSRVC");
@@ -402,9 +354,7 @@ const std::string MESSSRVC::PRODUCE_MESSAGE::itemName = "PRODUCE_MESSAGE";
const std::string MESSSRVC::PRODUCE_MESSAGE::defaultValue = "ON";
METRIC::METRIC( ) : ParserKeyword("METRIC")
{
setFixedSize( (size_t) 0);
METRIC::METRIC() : ParserKeyword("METRIC", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("METRIC");
@@ -412,9 +362,158 @@ METRIC::METRIC( ) : ParserKeyword("METRIC")
const std::string METRIC::keywordName = "METRIC";
MINNNCT::MINNNCT( ) : ParserKeyword("MINNNCT")
{
setFixedSize( (size_t) 1);
MICP::MICP() : ParserKeyword("MICP", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("MICP");
}
const std::string MICP::keywordName = "MICP";
MICPPARA::MICPPARA() : ParserKeyword("MICPPARA", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("MICPPARA");
{
ParserRecord record;
{
ParserItem item("DENSITY_BIOFILM", ParserItem::itype::DOUBLE);
item.setDefault( double(35.000000) );
item.push_backDimension("Density");
record.addItem(item);
}
{
ParserItem item("DENSITY_CALCITE", ParserItem::itype::DOUBLE);
item.setDefault( double(2710.000000) );
item.push_backDimension("Density");
record.addItem(item);
}
{
ParserItem item("DETACHMENT_RATE", ParserItem::itype::DOUBLE);
item.setDefault( double(2.6e-10) );
item.push_backDimension("Length/Viscosity");
record.addItem(item);
}
{
ParserItem item("CRITICAL_POROSITY", ParserItem::itype::DOUBLE);
item.setDefault( double(0.100000) );
record.addItem(item);
}
{
ParserItem item("FITTING_FACTOR", ParserItem::itype::DOUBLE);
item.setDefault( double(3.000000) );
record.addItem(item);
}
{
ParserItem item("HALF_VELOCITY_OXYGEN", ParserItem::itype::DOUBLE);
item.setDefault( double(2e-05) );
item.push_backDimension("Density");
record.addItem(item);
}
{
ParserItem item("HALF_VELOCITY_UREA", ParserItem::itype::DOUBLE);
item.setDefault( double(21.300000) );
item.push_backDimension("Density");
record.addItem(item);
}
{
ParserItem item("MAXIMUM_GROWTH_RATE", ParserItem::itype::DOUBLE);
item.setDefault( double(4.17e-05) );
item.push_backDimension("1/Time");
record.addItem(item);
}
{
ParserItem item("MAXIMUM_OXYGEN_CONCENTRATION", ParserItem::itype::DOUBLE);
item.setDefault( double(0.040000) );
item.push_backDimension("Density");
record.addItem(item);
}
{
ParserItem item("MAXIMUM_UREA_CONCENTRATION", ParserItem::itype::DOUBLE);
item.setDefault( double(60.000000) );
item.push_backDimension("Density");
record.addItem(item);
}
{
ParserItem item("MAXIMUM_UREA_UTILIZATION", ParserItem::itype::DOUBLE);
item.setDefault( double(0.016100) );
item.push_backDimension("1/Time");
record.addItem(item);
}
{
ParserItem item("MICROBIAL_ATTACHMENT_RATE", ParserItem::itype::DOUBLE);
item.setDefault( double(8.51e-07) );
item.push_backDimension("1/Time");
record.addItem(item);
}
{
ParserItem item("MICROBIAL_DEATH_RATE", ParserItem::itype::DOUBLE);
item.setDefault( double(3.18e-07) );
item.push_backDimension("1/Time");
record.addItem(item);
}
{
ParserItem item("MINIMUM_PERMEABILITY", ParserItem::itype::DOUBLE);
item.setDefault( double(1e-20) );
item.push_backDimension("Permeability");
record.addItem(item);
}
{
ParserItem item("OXYGEN_CONSUMPTION_FACTOR", ParserItem::itype::DOUBLE);
item.setDefault( double(0.500000) );
record.addItem(item);
}
{
ParserItem item("TOLERANCE_BEFORE_CLOGGING", ParserItem::itype::DOUBLE);
item.setDefault( double(0.000100) );
record.addItem(item);
}
{
ParserItem item("YIELD_GROWTH_COEFFICIENT", ParserItem::itype::DOUBLE);
item.setDefault( double(0.500000) );
record.addItem(item);
}
addRecord( record );
}
}
const std::string MICPPARA::keywordName = "MICPPARA";
const std::string MICPPARA::DENSITY_BIOFILM::itemName = "DENSITY_BIOFILM";
const double MICPPARA::DENSITY_BIOFILM::defaultValue = 35.000000;
const std::string MICPPARA::DENSITY_CALCITE::itemName = "DENSITY_CALCITE";
const double MICPPARA::DENSITY_CALCITE::defaultValue = 2710.000000;
const std::string MICPPARA::DETACHMENT_RATE::itemName = "DETACHMENT_RATE";
const double MICPPARA::DETACHMENT_RATE::defaultValue = 2.6e-10;
const std::string MICPPARA::CRITICAL_POROSITY::itemName = "CRITICAL_POROSITY";
const double MICPPARA::CRITICAL_POROSITY::defaultValue = 0.100000;
const std::string MICPPARA::FITTING_FACTOR::itemName = "FITTING_FACTOR";
const double MICPPARA::FITTING_FACTOR::defaultValue = 3.000000;
const std::string MICPPARA::HALF_VELOCITY_OXYGEN::itemName = "HALF_VELOCITY_OXYGEN";
const double MICPPARA::HALF_VELOCITY_OXYGEN::defaultValue = 2e-05;
const std::string MICPPARA::HALF_VELOCITY_UREA::itemName = "HALF_VELOCITY_UREA";
const double MICPPARA::HALF_VELOCITY_UREA::defaultValue = 21.300000;
const std::string MICPPARA::MAXIMUM_GROWTH_RATE::itemName = "MAXIMUM_GROWTH_RATE";
const double MICPPARA::MAXIMUM_GROWTH_RATE::defaultValue = 4.17e-05;
const std::string MICPPARA::MAXIMUM_OXYGEN_CONCENTRATION::itemName = "MAXIMUM_OXYGEN_CONCENTRATION";
const double MICPPARA::MAXIMUM_OXYGEN_CONCENTRATION::defaultValue = 0.040000;
const std::string MICPPARA::MAXIMUM_UREA_CONCENTRATION::itemName = "MAXIMUM_UREA_CONCENTRATION";
const double MICPPARA::MAXIMUM_UREA_CONCENTRATION::defaultValue = 60.000000;
const std::string MICPPARA::MAXIMUM_UREA_UTILIZATION::itemName = "MAXIMUM_UREA_UTILIZATION";
const double MICPPARA::MAXIMUM_UREA_UTILIZATION::defaultValue = 0.016100;
const std::string MICPPARA::MICROBIAL_ATTACHMENT_RATE::itemName = "MICROBIAL_ATTACHMENT_RATE";
const double MICPPARA::MICROBIAL_ATTACHMENT_RATE::defaultValue = 8.51e-07;
const std::string MICPPARA::MICROBIAL_DEATH_RATE::itemName = "MICROBIAL_DEATH_RATE";
const double MICPPARA::MICROBIAL_DEATH_RATE::defaultValue = 3.18e-07;
const std::string MICPPARA::MINIMUM_PERMEABILITY::itemName = "MINIMUM_PERMEABILITY";
const double MICPPARA::MINIMUM_PERMEABILITY::defaultValue = 1e-20;
const std::string MICPPARA::OXYGEN_CONSUMPTION_FACTOR::itemName = "OXYGEN_CONSUMPTION_FACTOR";
const double MICPPARA::OXYGEN_CONSUMPTION_FACTOR::defaultValue = 0.500000;
const std::string MICPPARA::TOLERANCE_BEFORE_CLOGGING::itemName = "TOLERANCE_BEFORE_CLOGGING";
const double MICPPARA::TOLERANCE_BEFORE_CLOGGING::defaultValue = 0.000100;
const std::string MICPPARA::YIELD_GROWTH_COEFFICIENT::itemName = "YIELD_GROWTH_COEFFICIENT";
const double MICPPARA::YIELD_GROWTH_COEFFICIENT::defaultValue = 0.500000;
MINNNCT::MINNNCT() : ParserKeyword("MINNNCT", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("MINNNCT");
@@ -443,16 +542,33 @@ MINNNCT::MINNNCT( ) : ParserKeyword("MINNNCT")
}
const std::string MINNNCT::keywordName = "MINNNCT";
const std::string MINNNCT::CUTOFF_TRANSMISSIBILITY::itemName = "CUTOFF_TRANSMISSIBILITY";
const double MINNNCT::CUTOFF_TRANSMISSIBILITY::defaultValue = 0.000000;
const double MINNNCT::CUTOFF_TRANSMISSIBILITY::defaultValue = 0;
const std::string MINNNCT::DIFFUSIVITY::itemName = "DIFFUSIVITY";
const double MINNNCT::DIFFUSIVITY::defaultValue = 0.000000;
const double MINNNCT::DIFFUSIVITY::defaultValue = 0;
const std::string MINNNCT::CUTOFF_THERMAL_TRANSMISSIBILITY::itemName = "CUTOFF_THERMAL_TRANSMISSIBILITY";
const double MINNNCT::CUTOFF_THERMAL_TRANSMISSIBILITY::defaultValue = 0.000000;
const double MINNNCT::CUTOFF_THERMAL_TRANSMISSIBILITY::defaultValue = 0;
MINPORV::MINPORV( ) : ParserKeyword("MINPORV")
{
setFixedSize( (size_t) 1);
MINNPCOL::MINNPCOL() : ParserKeyword("MINNPCOL", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("MINNPCOL");
{
ParserRecord record;
{
ParserItem item("VALUE", ParserItem::itype::INT);
item.setDefault( 6 );
record.addItem(item);
}
addRecord( record );
}
}
const std::string MINNPCOL::keywordName = "MINNPCOL";
const std::string MINNPCOL::VALUE::itemName = "VALUE";
const int MINNPCOL::VALUE::defaultValue = 6;
MINPORV::MINPORV() : ParserKeyword("MINPORV", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("MINPORV");
@@ -469,12 +585,10 @@ MINPORV::MINPORV( ) : ParserKeyword("MINPORV")
}
const std::string MINPORV::keywordName = "MINPORV";
const std::string MINPORV::MIN_PORE_VOL::itemName = "MIN_PORE_VOL";
const double MINPORV::MIN_PORE_VOL::defaultValue = 0.000001;
const double MINPORV::MIN_PORE_VOL::defaultValue = 1e-06;
MINPV::MINPV( ) : ParserKeyword("MINPV")
{
setFixedSize( (size_t) 1);
MINPV::MINPV() : ParserKeyword("MINPV", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("MINPV");
@@ -491,12 +605,10 @@ MINPV::MINPV( ) : ParserKeyword("MINPV")
}
const std::string MINPV::keywordName = "MINPV";
const std::string MINPV::VALUE::itemName = "VALUE";
const double MINPV::VALUE::defaultValue = 0.000001;
const double MINPV::VALUE::defaultValue = 1e-06;
MINPVFIL::MINPVFIL( ) : ParserKeyword("MINPVFIL")
{
setFixedSize( (size_t) 1);
MINPVFIL::MINPVFIL() : ParserKeyword("MINPVFIL", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("MINPVFIL");
@@ -513,12 +625,10 @@ MINPVFIL::MINPVFIL( ) : ParserKeyword("MINPVFIL")
}
const std::string MINPVFIL::keywordName = "MINPVFIL";
const std::string MINPVFIL::VALUE::itemName = "VALUE";
const double MINPVFIL::VALUE::defaultValue = 0.000001;
const double MINPVFIL::VALUE::defaultValue = 1e-06;
MINPVV::MINPVV( ) : ParserKeyword("MINPVV")
{
setFixedSize( (size_t) 1);
MINPVV::MINPVV() : ParserKeyword("MINPVV", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("MINPVV");
@@ -536,14 +646,12 @@ MINPVV::MINPVV( ) : ParserKeyword("MINPVV")
}
const std::string MINPVV::keywordName = "MINPVV";
const std::string MINPVV::data::itemName = "data";
const double MINPVV::data::defaultValue = 0.000001;
const double MINPVV::data::defaultValue = 1e-06;
MINVALUE::MINVALUE( ) : ParserKeyword("MINVALUE")
{
setSizeType(SLASH_TERMINATED);
addValidSectionName("EDIT");
MINVALUE::MINVALUE() : ParserKeyword("MINVALUE", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
addValidSectionName("EDIT");
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("MINVALUE");
@@ -595,10 +703,7 @@ const std::string MINVALUE::K1::itemName = "K1";
const std::string MINVALUE::K2::itemName = "K2";
MISC::MISC( ) : ParserKeyword("MISC")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("MISCIBLE","NTMISC",0);
MISC::MISC() : ParserKeyword("MISC", KeywordSize("MISCIBLE", "NTMISC", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("MISC");
@@ -618,9 +723,7 @@ const std::string MISC::keywordName = "MISC";
const std::string MISC::DATA::itemName = "DATA";
MISCIBLE::MISCIBLE( ) : ParserKeyword("MISCIBLE")
{
setFixedSize( (size_t) 1);
MISCIBLE::MISCIBLE() : ParserKeyword("MISCIBLE", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("MISCIBLE");
@@ -653,9 +756,7 @@ const std::string MISCIBLE::TWOPOINT::itemName = "TWOPOINT";
const std::string MISCIBLE::TWOPOINT::defaultValue = "NONE";
MISCNUM::MISCNUM( ) : ParserKeyword("MISCNUM")
{
setFixedSize( (size_t) 1);
MISCNUM::MISCNUM() : ParserKeyword("MISCNUM", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
addDeckName("MISCNUM");
@@ -673,9 +774,7 @@ const std::string MISCNUM::keywordName = "MISCNUM";
const std::string MISCNUM::data::itemName = "data";
MLANG::MLANG( ) : ParserKeyword("MLANG")
{
setFixedSize( (size_t) 1);
MLANG::MLANG() : ParserKeyword("MLANG", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("MLANG");
@@ -694,9 +793,7 @@ const std::string MLANG::keywordName = "MLANG";
const std::string MLANG::data::itemName = "data";
MLANGSLV::MLANGSLV( ) : ParserKeyword("MLANGSLV")
{
setFixedSize( (size_t) 1);
MLANGSLV::MLANGSLV() : ParserKeyword("MLANGSLV", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("MLANGSLV");
@@ -715,9 +812,7 @@ const std::string MLANGSLV::keywordName = "MLANGSLV";
const std::string MLANGSLV::data::itemName = "data";
MONITOR::MONITOR( ) : ParserKeyword("MONITOR")
{
setFixedSize( (size_t) 0);
MONITOR::MONITOR() : ParserKeyword("MONITOR", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("SUMMARY");
clearDeckNames();
@@ -726,9 +821,7 @@ MONITOR::MONITOR( ) : ParserKeyword("MONITOR")
const std::string MONITOR::keywordName = "MONITOR";
MPFANUM::MPFANUM( ) : ParserKeyword("MPFANUM")
{
setFixedSize( (size_t) 1);
MPFANUM::MPFANUM() : ParserKeyword("MPFANUM", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("MPFANUM");
@@ -746,9 +839,7 @@ const std::string MPFANUM::keywordName = "MPFANUM";
const std::string MPFANUM::data::itemName = "data";
MPFNNC::MPFNNC( ) : ParserKeyword("MPFNNC")
{
setSizeType(DOUBLE_SLASH_TERMINATED);
MPFNNC::MPFNNC() : ParserKeyword("MPFNNC", KeywordSize(DOUBLE_SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("MPFNNC");
@@ -822,10 +913,7 @@ const std::string MPFNNC::KZ::itemName = "KZ";
const std::string MPFNNC::TRANS::itemName = "TRANS";
MSFN::MSFN( ) : ParserKeyword("MSFN")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
MSFN::MSFN() : ParserKeyword("MSFN", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("MSFN");
@@ -846,9 +934,7 @@ const std::string MSFN::keywordName = "MSFN";
const std::string MSFN::DATA::itemName = "DATA";
MSGFILE::MSGFILE( ) : ParserKeyword("MSGFILE")
{
setFixedSize( (size_t) 1);
MSGFILE::MSGFILE() : ParserKeyword("MSGFILE", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("MSGFILE");
@@ -865,9 +951,23 @@ const std::string MSGFILE::keywordName = "MSGFILE";
const std::string MSGFILE::ENABLE_FLAG::itemName = "ENABLE_FLAG";
MULSGGD::MULSGGD( ) : ParserKeyword("MULSGGD")
{
setFixedSize( (size_t) 1);
MSUM_PROBE::MSUM_PROBE() : ParserKeyword("MSUM_PROBE", KeywordSize(0, false)) {
addValidSectionName("SUMMARY");
clearDeckNames();
addDeckName("MSUMLINP");
addDeckName("MSUMLINS");
addDeckName("MSUMCOMM");
addDeckName("MSUMBUG");
addDeckName("MSUMERR");
addDeckName("MSUMMESS");
addDeckName("MSUMNEWT");
addDeckName("MSUMPROB");
addDeckName("MSUMWARN");
}
const std::string MSUM_PROBE::keywordName = "MSUM_PROBE";
MULSGGD::MULSGGD() : ParserKeyword("MULSGGD", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("MULSGGD");
@@ -886,9 +986,7 @@ const std::string MULSGGD::keywordName = "MULSGGD";
const std::string MULSGGD::data::itemName = "data";
MULSGGDV::MULSGGDV( ) : ParserKeyword("MULSGGDV")
{
setFixedSize( (size_t) 1);
MULSGGDV::MULSGGDV() : ParserKeyword("MULSGGDV", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("MULSGGDV");
@@ -907,9 +1005,7 @@ const std::string MULSGGDV::keywordName = "MULSGGDV";
const std::string MULSGGDV::data::itemName = "data";
MULTFLT::MULTFLT( ) : ParserKeyword("MULTFLT")
{
setSizeType(SLASH_TERMINATED);
MULTFLT::MULTFLT() : ParserKeyword("MULTFLT", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("SCHEDULE");
@@ -933,9 +1029,7 @@ const std::string MULTFLT::fault::itemName = "fault";
const std::string MULTFLT::factor::itemName = "factor";
MULTIN::MULTIN( ) : ParserKeyword("MULTIN")
{
setFixedSize( (size_t) 0);
MULTIN::MULTIN() : ParserKeyword("MULTIN", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("MULTIN");
@@ -943,12 +1037,10 @@ MULTIN::MULTIN( ) : ParserKeyword("MULTIN")
const std::string MULTIN::keywordName = "MULTIN";
MULTIPLY::MULTIPLY( ) : ParserKeyword("MULTIPLY")
{
setSizeType(SLASH_TERMINATED);
MULTIPLY::MULTIPLY() : ParserKeyword("MULTIPLY", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("SOLUTION");
clearDeckNames();
@@ -1002,12 +1094,10 @@ const std::string MULTIPLY::K1::itemName = "K1";
const std::string MULTIPLY::K2::itemName = "K2";
MULTIREG::MULTIREG( ) : ParserKeyword("MULTIREG")
{
setSizeType(SLASH_TERMINATED);
MULTIREG::MULTIREG() : ParserKeyword("MULTIREG", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("SOLUTION");
clearDeckNames();
@@ -1042,15 +1132,13 @@ MULTIREG::MULTIREG( ) : ParserKeyword("MULTIREG")
const std::string MULTIREG::keywordName = "MULTIREG";
const std::string MULTIREG::ARRAY::itemName = "ARRAY";
const std::string MULTIREG::FACTOR::itemName = "FACTOR";
const double MULTIREG::FACTOR::defaultValue = 0.000000;
const double MULTIREG::FACTOR::defaultValue = 0;
const std::string MULTIREG::REGION_NUMBER::itemName = "REGION_NUMBER";
const std::string MULTIREG::REGION_NAME::itemName = "REGION_NAME";
const std::string MULTIREG::REGION_NAME::defaultValue = "M";
MULTNUM::MULTNUM( ) : ParserKeyword("MULTNUM")
{
setFixedSize( (size_t) 1);
MULTNUM::MULTNUM() : ParserKeyword("MULTNUM", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("MULTNUM");
@@ -1068,9 +1156,7 @@ const std::string MULTNUM::keywordName = "MULTNUM";
const std::string MULTNUM::data::itemName = "data";
MULTOUT::MULTOUT( ) : ParserKeyword("MULTOUT")
{
setFixedSize( (size_t) 0);
MULTOUT::MULTOUT() : ParserKeyword("MULTOUT", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("MULTOUT");
@@ -1078,9 +1164,7 @@ MULTOUT::MULTOUT( ) : ParserKeyword("MULTOUT")
const std::string MULTOUT::keywordName = "MULTOUT";
MULTOUTS::MULTOUTS( ) : ParserKeyword("MULTOUTS")
{
setFixedSize( (size_t) 0);
MULTOUTS::MULTOUTS() : ParserKeyword("MULTOUTS", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("MULTOUTS");
@@ -1088,9 +1172,7 @@ MULTOUTS::MULTOUTS( ) : ParserKeyword("MULTOUTS")
const std::string MULTOUTS::keywordName = "MULTOUTS";
MULTPV::MULTPV( ) : ParserKeyword("MULTPV")
{
setFixedSize( (size_t) 1);
MULTPV::MULTPV() : ParserKeyword("MULTPV", KeywordSize(1, false)) {
addValidSectionName("EDIT");
addValidSectionName("GRID");
clearDeckNames();
@@ -1110,9 +1192,7 @@ const std::string MULTPV::keywordName = "MULTPV";
const std::string MULTPV::data::itemName = "data";
MULTREAL::MULTREAL( ) : ParserKeyword("MULTREAL")
{
setFixedSize( (size_t) 1);
MULTREAL::MULTREAL() : ParserKeyword("MULTREAL", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("MULTREAL");
@@ -1136,11 +1216,9 @@ const std::string MULTREAL::STANDARD_LICENCE::itemName = "STANDARD_LICENCE";
const std::string MULTREAL::STANDARD_LICENCE::defaultValue = "YES";
MULTREGD::MULTREGD( ) : ParserKeyword("MULTREGD")
{
setSizeType(SLASH_TERMINATED);
addValidSectionName("EDIT");
MULTREGD::MULTREGD() : ParserKeyword("MULTREGD", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("MULTREGD");
{
@@ -1188,11 +1266,9 @@ const std::string MULTREGD::CHOICE::itemName = "CHOICE";
const std::string MULTREGD::CHOICE::defaultValue = "M";
MULTREGH::MULTREGH( ) : ParserKeyword("MULTREGH")
{
setSizeType(SLASH_TERMINATED);
addValidSectionName("EDIT");
MULTREGH::MULTREGH() : ParserKeyword("MULTREGH", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("MULTREGH");
{
@@ -1240,11 +1316,9 @@ const std::string MULTREGH::CHOICE::itemName = "CHOICE";
const std::string MULTREGH::CHOICE::defaultValue = "M";
MULTREGP::MULTREGP( ) : ParserKeyword("MULTREGP")
{
setSizeType(SLASH_TERMINATED);
addValidSectionName("EDIT");
MULTREGP::MULTREGP() : ParserKeyword("MULTREGP", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("MULTREGP");
{
@@ -1272,11 +1346,9 @@ const std::string MULTREGP::REGION_TYPE::itemName = "REGION_TYPE";
const std::string MULTREGP::REGION_TYPE::defaultValue = "M";
MULTREGT::MULTREGT( ) : ParserKeyword("MULTREGT")
{
setSizeType(SLASH_TERMINATED);
addValidSectionName("EDIT");
MULTREGT::MULTREGT() : ParserKeyword("MULTREGT", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
addValidSectionName("EDIT");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("MULTREGT");
@@ -1324,9 +1396,7 @@ const std::string MULTREGT::REGION_DEF::itemName = "REGION_DEF";
const std::string MULTREGT::REGION_DEF::defaultValue = "M";
MULTSIG::MULTSIG( ) : ParserKeyword("MULTSIG")
{
setFixedSize( (size_t) 1);
MULTSIG::MULTSIG() : ParserKeyword("MULTSIG", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("MULTSIG");
@@ -1344,9 +1414,7 @@ const std::string MULTSIG::keywordName = "MULTSIG";
const std::string MULTSIG::VALUE::itemName = "VALUE";
MULTSIGV::MULTSIGV( ) : ParserKeyword("MULTSIGV")
{
setFixedSize( (size_t) 1);
MULTSIGV::MULTSIGV() : ParserKeyword("MULTSIGV", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("MULTSIGV");
@@ -1365,20 +1433,19 @@ const std::string MULTSIGV::keywordName = "MULTSIGV";
const std::string MULTSIGV::data::itemName = "data";
MULT_XYZ::MULT_XYZ( ) : ParserKeyword("MULT_XYZ")
{
setFixedSize( (size_t) 1);
addValidSectionName("EDIT");
MULT_XYZ::MULT_XYZ() : ParserKeyword("MULT_XYZ", KeywordSize(1, false)) {
addValidSectionName("GRID");
addValidSectionName("EDIT");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("MULTY-");
addDeckName("MULTX");
addDeckName("MULTTHT");
addDeckName("MULTX-");
addDeckName("MULTTHT-");
addDeckName("MULTR");
addDeckName("MULTR-");
addDeckName("MULTTHT");
addDeckName("MULTTHT-");
addDeckName("MULTX");
addDeckName("MULTX-");
addDeckName("MULTY");
addDeckName("MULTY-");
addDeckName("MULTZ");
addDeckName("MULTZ-");
{
@@ -1396,10 +1463,7 @@ const std::string MULT_XYZ::keywordName = "MULT_XYZ";
const std::string MULT_XYZ::data::itemName = "data";
MW::MW( ) : ParserKeyword("MW")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NUM_STATE_EQ",0);
MW::MW() : ParserKeyword("MW", KeywordSize("TABDIMS", "NUM_STATE_EQ", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("MW");
@@ -1417,10 +1481,7 @@ const std::string MW::keywordName = "MW";
const std::string MW::MOLAR_WEIGHT::itemName = "MOLAR_WEIGHT";
MWS::MWS( ) : ParserKeyword("MWS")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NUM_STATE_EQ",0);
MWS::MWS() : ParserKeyword("MWS", KeywordSize("TABDIMS", "NUM_STATE_EQ", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("MWS");

283
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/N.cpp vendored
View File

@@ -1,18 +1,17 @@
#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/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/parser/eclipse/Parser/ParserKeywords/N.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/N.hpp>
namespace Opm {
namespace ParserKeywords {
NARROW::NARROW( ) : ParserKeyword("NARROW")
{
setFixedSize( (size_t) 0);
NARROW::NARROW() : ParserKeyword("NARROW", KeywordSize(0, false)) {
addValidSectionName("SUMMARY");
clearDeckNames();
addDeckName("NARROW");
@@ -20,9 +19,7 @@ NARROW::NARROW( ) : ParserKeyword("NARROW")
const std::string NARROW::keywordName = "NARROW";
NCONSUMP::NCONSUMP( ) : ParserKeyword("NCONSUMP")
{
setSizeType(SLASH_TERMINATED);
NCONSUMP::NCONSUMP() : ParserKeyword("NCONSUMP", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("NCONSUMP");
@@ -48,13 +45,11 @@ NCONSUMP::NCONSUMP( ) : ParserKeyword("NCONSUMP")
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.000000;
const double NCONSUMP::GAS_CONSUMPTION_RATE::defaultValue = 0;
const std::string NCONSUMP::REMOVAL_GROUP::itemName = "REMOVAL_GROUP";
NEFAC::NEFAC( ) : ParserKeyword("NEFAC")
{
setSizeType(SLASH_TERMINATED);
NEFAC::NEFAC() : ParserKeyword("NEFAC", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("NEFAC");
@@ -79,11 +74,9 @@ const std::string NEFAC::EFF_FACTOR::itemName = "EFF_FACTOR";
const double NEFAC::EFF_FACTOR::defaultValue = 1.000000;
NETBALAN::NETBALAN( ) : ParserKeyword("NETBALAN")
{
setFixedSize( (size_t) 1);
addValidSectionName("SCHEDULE");
NETBALAN::NETBALAN() : ParserKeyword("NETBALAN", KeywordSize(1, false)) {
addValidSectionName("SPECIAL");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("NETBALAN");
{
@@ -91,11 +84,13 @@ NETBALAN::NETBALAN( ) : ParserKeyword("NETBALAN")
{
ParserItem item("TIME_INTERVAL", ParserItem::itype::DOUBLE);
item.setDefault( double(0) );
item.push_backDimension("Time");
record.addItem(item);
}
{
ParserItem item("PRESSURE_CONVERGENCE_LIMT", ParserItem::itype::DOUBLE);
item.setDefault( double(1e-05) );
ParserItem item("PRESSURE_CONVERGENCE_LIMIT", ParserItem::itype::DOUBLE);
item.setDefault( double(0.100000) );
item.push_backDimension("Pressure");
record.addItem(item);
}
{
@@ -116,15 +111,18 @@ NETBALAN::NETBALAN( ) : ParserKeyword("NETBALAN")
{
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 );
@@ -132,9 +130,9 @@ NETBALAN::NETBALAN( ) : ParserKeyword("NETBALAN")
}
const std::string NETBALAN::keywordName = "NETBALAN";
const std::string NETBALAN::TIME_INTERVAL::itemName = "TIME_INTERVAL";
const double NETBALAN::TIME_INTERVAL::defaultValue = 0.000000;
const std::string NETBALAN::PRESSURE_CONVERGENCE_LIMT::itemName = "PRESSURE_CONVERGENCE_LIMT";
const double NETBALAN::PRESSURE_CONVERGENCE_LIMT::defaultValue = 0.000010;
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";
@@ -148,9 +146,7 @@ const double NETBALAN::MAX_BALANCE_ERROR::defaultValue = 100000000000000000000.0
const std::string NETBALAN::MIN_TIME_STEP::itemName = "MIN_TIME_STEP";
NETCOMPA::NETCOMPA( ) : ParserKeyword("NETCOMPA")
{
setSizeType(SLASH_TERMINATED);
NETCOMPA::NETCOMPA() : ParserKeyword("NETCOMPA", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("NETCOMPA");
@@ -224,9 +220,9 @@ 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.000000;
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.000000;
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";
@@ -235,9 +231,7 @@ 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")
{
setFixedSize( (size_t) 1);
NETWORK::NETWORK() : ParserKeyword("NETWORK", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("NETWORK");
@@ -266,9 +260,7 @@ const std::string NETWORK::NBCMAX::itemName = "NBCMAX";
const int NETWORK::NBCMAX::defaultValue = 20;
NEWTRAN::NEWTRAN( ) : ParserKeyword("NEWTRAN")
{
setFixedSize( (size_t) 0);
NEWTRAN::NEWTRAN() : ParserKeyword("NEWTRAN", KeywordSize(0, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("NEWTRAN");
@@ -276,38 +268,10 @@ NEWTRAN::NEWTRAN( ) : ParserKeyword("NEWTRAN")
const std::string NEWTRAN::keywordName = "NEWTRAN";
NEXT::NEXT( ) : ParserKeyword("NEXT")
{
setFixedSize( (size_t) 1);
NEXTSTEP::NEXTSTEP() : ParserKeyword("NEXTSTEP", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("NEXT");
{
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 NEXT::keywordName = "NEXT";
const std::string NEXT::MAX_STEP::itemName = "MAX_STEP";
const std::string NEXT::APPLY_TO_ALL::itemName = "APPLY_TO_ALL";
const std::string NEXT::APPLY_TO_ALL::defaultValue = "NO";
NEXTSTEP::NEXTSTEP( ) : ParserKeyword("NEXTSTEP")
{
setFixedSize( (size_t) 1);
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("NEXTSTEP");
{
ParserRecord record;
@@ -330,9 +294,7 @@ const std::string NEXTSTEP::APPLY_TO_ALL::itemName = "APPLY_TO_ALL";
const std::string NEXTSTEP::APPLY_TO_ALL::defaultValue = "NO";
NEXTSTPL::NEXTSTPL( ) : ParserKeyword("NEXTSTPL")
{
setFixedSize( (size_t) 1);
NEXTSTPL::NEXTSTPL() : ParserKeyword("NEXTSTPL", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("NEXTSTPL");
@@ -357,9 +319,7 @@ const std::string NEXTSTPL::APPLY_TO_ALL::itemName = "APPLY_TO_ALL";
const std::string NEXTSTPL::APPLY_TO_ALL::defaultValue = "NO";
NINENUM::NINENUM( ) : ParserKeyword("NINENUM")
{
setFixedSize( (size_t) 1);
NINENUM::NINENUM() : ParserKeyword("NINENUM", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("NINENUM");
@@ -377,9 +337,7 @@ const std::string NINENUM::keywordName = "NINENUM";
const std::string NINENUM::data::itemName = "data";
NINEPOIN::NINEPOIN( ) : ParserKeyword("NINEPOIN")
{
setFixedSize( (size_t) 0);
NINEPOIN::NINEPOIN() : ParserKeyword("NINEPOIN", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("NINEPOIN");
@@ -387,9 +345,7 @@ NINEPOIN::NINEPOIN( ) : ParserKeyword("NINEPOIN")
const std::string NINEPOIN::keywordName = "NINEPOIN";
NMATOPTS::NMATOPTS( ) : ParserKeyword("NMATOPTS")
{
setFixedSize( (size_t) 1);
NMATOPTS::NMATOPTS() : ParserKeyword("NMATOPTS", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("NMATOPTS");
@@ -423,9 +379,7 @@ const std::string NMATOPTS::METHOD::itemName = "METHOD";
const std::string NMATOPTS::METHOD::defaultValue = "FPORV";
NMATRIX::NMATRIX( ) : ParserKeyword("NMATRIX")
{
setFixedSize( (size_t) 1);
NMATRIX::NMATRIX() : ParserKeyword("NMATRIX", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("NMATRIX");
@@ -442,9 +396,15 @@ const std::string NMATRIX::keywordName = "NMATRIX";
const std::string NMATRIX::NUM_SUB_CELLS::itemName = "NUM_SUB_CELLS";
NNC::NNC( ) : ParserKeyword("NNC")
{
setSizeType(SLASH_TERMINATED);
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");
@@ -481,15 +441,13 @@ NNC::NNC( ) : ParserKeyword("NNC")
record.addItem(item);
}
{
ParserItem item("SIM_DEPENDENT1", ParserItem::itype::DOUBLE);
item.setDefault( double(0) );
item.push_backDimension("ContextDependent");
ParserItem item("IST1", ParserItem::itype::INT);
item.setDefault( 0 );
record.addItem(item);
}
{
ParserItem item("SIM_DEPENDENT2", ParserItem::itype::DOUBLE);
item.setDefault( double(0) );
item.push_backDimension("ContextDependent");
ParserItem item("IST2", ParserItem::itype::INT);
item.setDefault( 0 );
record.addItem(item);
}
{
@@ -546,11 +504,11 @@ 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.000000;
const std::string NNC::SIM_DEPENDENT1::itemName = "SIM_DEPENDENT1";
const double NNC::SIM_DEPENDENT1::defaultValue = 0.000000;
const std::string NNC::SIM_DEPENDENT2::itemName = "SIM_DEPENDENT2";
const double NNC::SIM_DEPENDENT2::defaultValue = 0.000000;
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";
@@ -560,18 +518,16 @@ 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.000000;
const double NNC::DIFFUSIVITY::defaultValue = 0;
const std::string NNC::SIM_DEPENDENT3::itemName = "SIM_DEPENDENT3";
const double NNC::SIM_DEPENDENT3::defaultValue = 0.000000;
const double NNC::SIM_DEPENDENT3::defaultValue = 0;
const std::string NNC::VDFLOW_AREA::itemName = "VDFLOW_AREA";
const double NNC::VDFLOW_AREA::defaultValue = 0.000000;
const double NNC::VDFLOW_AREA::defaultValue = 0;
const std::string NNC::VDFLOW_PERM::itemName = "VDFLOW_PERM";
const double NNC::VDFLOW_PERM::defaultValue = 0.000000;
const double NNC::VDFLOW_PERM::defaultValue = 0;
NNEWTF::NNEWTF( ) : ParserKeyword("NNEWTF")
{
setFixedSize( (size_t) 1);
NNEWTF::NNEWTF() : ParserKeyword("NNEWTF", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("NNEWTF");
@@ -593,9 +549,7 @@ const std::string NNEWTF::NTHRBL::itemName = "NTHRBL";
const std::string NNEWTF::NLNHBL::itemName = "NLNHBL";
NOCASC::NOCASC( ) : ParserKeyword("NOCASC")
{
setFixedSize( (size_t) 0);
NOCASC::NOCASC() : ParserKeyword("NOCASC", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("NOCASC");
@@ -603,9 +557,7 @@ NOCASC::NOCASC( ) : ParserKeyword("NOCASC")
const std::string NOCASC::keywordName = "NOCASC";
NODEPROP::NODEPROP( ) : ParserKeyword("NODEPROP")
{
setSizeType(SLASH_TERMINATED);
NODEPROP::NODEPROP() : ParserKeyword("NODEPROP", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("NODEPROP");
@@ -625,6 +577,11 @@ NODEPROP::NODEPROP( ) : ParserKeyword("NODEPROP")
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);
@@ -635,7 +592,6 @@ NODEPROP::NODEPROP( ) : ParserKeyword("NODEPROP")
}
{
ParserItem item("NETWORK_VALUE_TYPE", ParserItem::itype::STRING);
item.setDefault( std::string("PROD") );
record.addItem(item);
}
addRecord( record );
@@ -646,43 +602,38 @@ 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";
const std::string NODEPROP::NETWORK_VALUE_TYPE::defaultValue = "PROD";
NODPPM::NODPPM( ) : ParserKeyword("NODPPM")
{
setFixedSize( (size_t) 0);
addValidSectionName("GRID");
NODPPM::NODPPM() : ParserKeyword("NODPPM", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("GRID");
clearDeckNames();
addDeckName("NODPPM");
}
const std::string NODPPM::keywordName = "NODPPM";
NOECHO::NOECHO( ) : ParserKeyword("NOECHO")
{
setFixedSize( (size_t) 0);
NOECHO::NOECHO() : ParserKeyword("NOECHO", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("PROPS");
addValidSectionName("EDIT");
addValidSectionName("GRID");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SUMMARY");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("NOECHO");
}
const std::string NOECHO::keywordName = "NOECHO";
NOGGF::NOGGF( ) : ParserKeyword("NOGGF")
{
setFixedSize( (size_t) 0);
NOGGF::NOGGF() : ParserKeyword("NOGGF", KeywordSize(0, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("NOGGF");
@@ -690,9 +641,7 @@ NOGGF::NOGGF( ) : ParserKeyword("NOGGF")
const std::string NOGGF::keywordName = "NOGGF";
NOGRAV::NOGRAV( ) : ParserKeyword("NOGRAV")
{
setFixedSize( (size_t) 0);
NOGRAV::NOGRAV() : ParserKeyword("NOGRAV", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("NOGRAV");
@@ -700,11 +649,9 @@ NOGRAV::NOGRAV( ) : ParserKeyword("NOGRAV")
const std::string NOGRAV::keywordName = "NOGRAV";
NOHMD::NOHMD( ) : ParserKeyword("NOHMD")
{
setFixedSize( (size_t) 1);
addValidSectionName("SCHEDULE");
NOHMD::NOHMD() : ParserKeyword("NOHMD", KeywordSize(1, false)) {
addValidSectionName("SOLUTION");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("NOHMD");
{
@@ -721,11 +668,9 @@ const std::string NOHMD::keywordName = "NOHMD";
const std::string NOHMD::GRAD_PARAMS::itemName = "GRAD_PARAMS";
NOHMO::NOHMO( ) : ParserKeyword("NOHMO")
{
setFixedSize( (size_t) 1);
addValidSectionName("SCHEDULE");
NOHMO::NOHMO() : ParserKeyword("NOHMO", KeywordSize(1, false)) {
addValidSectionName("SOLUTION");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("NOHMO");
{
@@ -742,9 +687,7 @@ const std::string NOHMO::keywordName = "NOHMO";
const std::string NOHMO::GRAD_PARAMS::itemName = "GRAD_PARAMS";
NOHYST::NOHYST( ) : ParserKeyword("NOHYST")
{
setFixedSize( (size_t) 0);
NOHYST::NOHYST() : ParserKeyword("NOHYST", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("NOHYST");
@@ -752,9 +695,7 @@ NOHYST::NOHYST( ) : ParserKeyword("NOHYST")
const std::string NOHYST::keywordName = "NOHYST";
NOINSPEC::NOINSPEC( ) : ParserKeyword("NOINSPEC")
{
setFixedSize( (size_t) 0);
NOINSPEC::NOINSPEC() : ParserKeyword("NOINSPEC", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("NOINSPEC");
@@ -762,9 +703,7 @@ NOINSPEC::NOINSPEC( ) : ParserKeyword("NOINSPEC")
const std::string NOINSPEC::keywordName = "NOINSPEC";
NOMONITO::NOMONITO( ) : ParserKeyword("NOMONITO")
{
setFixedSize( (size_t) 0);
NOMONITO::NOMONITO() : ParserKeyword("NOMONITO", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("SUMMARY");
clearDeckNames();
@@ -773,9 +712,7 @@ NOMONITO::NOMONITO( ) : ParserKeyword("NOMONITO")
const std::string NOMONITO::keywordName = "NOMONITO";
NONNC::NONNC( ) : ParserKeyword("NONNC")
{
setFixedSize( (size_t) 0);
NONNC::NONNC() : ParserKeyword("NONNC", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("NONNC");
@@ -783,9 +720,7 @@ NONNC::NONNC( ) : ParserKeyword("NONNC")
const std::string NONNC::keywordName = "NONNC";
NORSSPEC::NORSSPEC( ) : ParserKeyword("NORSSPEC")
{
setFixedSize( (size_t) 0);
NORSSPEC::NORSSPEC() : ParserKeyword("NORSSPEC", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("NORSSPEC");
@@ -793,9 +728,7 @@ NORSSPEC::NORSSPEC( ) : ParserKeyword("NORSSPEC")
const std::string NORSSPEC::keywordName = "NORSSPEC";
NOSIM::NOSIM( ) : ParserKeyword("NOSIM")
{
setFixedSize( (size_t) 0);
NOSIM::NOSIM() : ParserKeyword("NOSIM", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
clearDeckNames();
@@ -804,26 +737,22 @@ NOSIM::NOSIM( ) : ParserKeyword("NOSIM")
const std::string NOSIM::keywordName = "NOSIM";
NOWARN::NOWARN( ) : ParserKeyword("NOWARN")
{
setFixedSize( (size_t) 0);
addValidSectionName("EDIT");
NOWARN::NOWARN() : ParserKeyword("NOWARN", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("GRID");
addValidSectionName("EDIT");
addValidSectionName("PROPS");
addValidSectionName("REGIONS");
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
addValidSectionName("SOLUTION");
addValidSectionName("SUMMARY");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("NOWARN");
}
const std::string NOWARN::keywordName = "NOWARN";
NOWARNEP::NOWARNEP( ) : ParserKeyword("NOWARNEP")
{
setFixedSize( (size_t) 0);
NOWARNEP::NOWARNEP() : ParserKeyword("NOWARNEP", KeywordSize(0, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("NOWARNEP");
@@ -831,9 +760,7 @@ NOWARNEP::NOWARNEP( ) : ParserKeyword("NOWARNEP")
const std::string NOWARNEP::keywordName = "NOWARNEP";
NRSOUT::NRSOUT( ) : ParserKeyword("NRSOUT")
{
setFixedSize( (size_t) 1);
NRSOUT::NRSOUT() : ParserKeyword("NRSOUT", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("NRSOUT");
@@ -852,9 +779,7 @@ const std::string NRSOUT::MAX_NUM::itemName = "MAX_NUM";
const int NRSOUT::MAX_NUM::defaultValue = 3600;
NSTACK::NSTACK( ) : ParserKeyword("NSTACK")
{
setFixedSize( (size_t) 1);
NSTACK::NSTACK() : ParserKeyword("NSTACK", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
clearDeckNames();
@@ -874,9 +799,7 @@ const std::string NSTACK::LINEAR_SOLVER_SIZE::itemName = "LINEAR_SOLVER_SIZE";
const int NSTACK::LINEAR_SOLVER_SIZE::defaultValue = 10;
NTG::NTG( ) : ParserKeyword("NTG")
{
setFixedSize( (size_t) 1);
NTG::NTG() : ParserKeyword("NTG", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("NTG");
@@ -895,9 +818,7 @@ const std::string NTG::keywordName = "NTG";
const std::string NTG::data::itemName = "data";
NUMRES::NUMRES( ) : ParserKeyword("NUMRES")
{
setFixedSize( (size_t) 1);
NUMRES::NUMRES() : ParserKeyword("NUMRES", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("NUMRES");
@@ -916,9 +837,7 @@ const std::string NUMRES::num::itemName = "num";
const int NUMRES::num::defaultValue = 1;
NUPCOL::NUPCOL( ) : ParserKeyword("NUPCOL")
{
setFixedSize( (size_t) 1);
NUPCOL::NUPCOL() : ParserKeyword("NUPCOL", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
addValidSectionName("SCHEDULE");
clearDeckNames();
@@ -938,9 +857,7 @@ const std::string NUPCOL::NUM_ITER::itemName = "NUM_ITER";
const int NUPCOL::NUM_ITER::defaultValue = 12;
NWATREM::NWATREM( ) : ParserKeyword("NWATREM")
{
setSizeType(SLASH_TERMINATED);
NWATREM::NWATREM() : ParserKeyword("NWATREM", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("NWATREM");
@@ -973,9 +890,7 @@ const std::string NWATREM::MAX_FRAC_REMOVAL::itemName = "MAX_FRAC_REMOVAL";
const double NWATREM::MAX_FRAC_REMOVAL::defaultValue = 1.000000;
NXFIN::NXFIN( ) : ParserKeyword("NXFIN")
{
setFixedSize( (size_t) 1);
NXFIN::NXFIN() : ParserKeyword("NXFIN", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("NXFIN");
@@ -993,9 +908,7 @@ const std::string NXFIN::keywordName = "NXFIN";
const std::string NXFIN::data::itemName = "data";
NYFIN::NYFIN( ) : ParserKeyword("NYFIN")
{
setFixedSize( (size_t) 1);
NYFIN::NYFIN() : ParserKeyword("NYFIN", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("NYFIN");
@@ -1013,9 +926,7 @@ const std::string NYFIN::keywordName = "NYFIN";
const std::string NYFIN::data::itemName = "data";
NZFIN::NZFIN( ) : ParserKeyword("NZFIN")
{
setFixedSize( (size_t) 1);
NZFIN::NZFIN() : ParserKeyword("NZFIN", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("NZFIN");

1002
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/O.cpp vendored
View File

File diff suppressed because it is too large Load Diff

611
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/P.cpp vendored
View File

File diff suppressed because it is too large Load Diff

24
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/Q.cpp vendored
View File

@@ -1,18 +1,17 @@
#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/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/parser/eclipse/Parser/ParserKeywords/Q.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/Q.hpp>
namespace Opm {
namespace ParserKeywords {
QDRILL::QDRILL( ) : ParserKeyword("QDRILL")
{
setFixedSize( (size_t) 1);
QDRILL::QDRILL() : ParserKeyword("QDRILL", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("QDRILL");
@@ -30,10 +29,7 @@ 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);
QHRATING::QHRATING() : ParserKeyword("QHRATING", KeywordSize("RIVRDIMS", "NRATTA", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("QHRATING");
@@ -53,9 +49,7 @@ const std::string QHRATING::keywordName = "QHRATING";
const std::string QHRATING::DATA::itemName = "DATA";
QMOBIL::QMOBIL( ) : ParserKeyword("QMOBIL")
{
setFixedSize( (size_t) 1);
QMOBIL::QMOBIL() : ParserKeyword("QMOBIL", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("QMOBIL");

686
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/R.cpp vendored
View File

File diff suppressed because it is too large Load Diff

1284
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/S.cpp vendored
View File

File diff suppressed because it is too large Load Diff

323
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/T.cpp vendored
View File

@@ -1,18 +1,17 @@
#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/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/parser/eclipse/Parser/ParserKeywords/T.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/T.hpp>
namespace Opm {
namespace ParserKeywords {
TABDIMS::TABDIMS( ) : ParserKeyword("TABDIMS")
{
setFixedSize( (size_t) 1);
TABDIMS::TABDIMS() : ParserKeyword("TABDIMS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("TABDIMS");
@@ -50,6 +49,7 @@ TABDIMS::TABDIMS( ) : ParserKeyword("TABDIMS")
}
{
ParserItem item("MAX_RV_NODES", ParserItem::itype::INT);
item.setDefault( 20 );
record.addItem(item);
}
{
@@ -57,11 +57,6 @@ TABDIMS::TABDIMS( ) : ParserKeyword("TABDIMS")
item.setDefault( 1 );
record.addItem(item);
}
{
ParserItem item("NUM_STATE_EQ", ParserItem::itype::INT);
item.setDefault( 1 );
record.addItem(item);
}
{
ParserItem item("NUM_EOS_RES", ParserItem::itype::INT);
item.setDefault( 1 );
@@ -69,6 +64,7 @@ TABDIMS::TABDIMS( ) : ParserKeyword("TABDIMS")
}
{
ParserItem item("NUM_EOS_SURFACE", ParserItem::itype::INT);
item.setDefault( 1 );
record.addItem(item);
}
{
@@ -159,13 +155,13 @@ const int TABDIMS::NTFIP::defaultValue = 1;
const std::string TABDIMS::NRPVT::itemName = "NRPVT";
const int TABDIMS::NRPVT::defaultValue = 20;
const std::string TABDIMS::MAX_RV_NODES::itemName = "MAX_RV_NODES";
const int TABDIMS::MAX_RV_NODES::defaultValue = 20;
const std::string TABDIMS::NTENDP::itemName = "NTENDP";
const int TABDIMS::NTENDP::defaultValue = 1;
const std::string TABDIMS::NUM_STATE_EQ::itemName = "NUM_STATE_EQ";
const int TABDIMS::NUM_STATE_EQ::defaultValue = 1;
const std::string TABDIMS::NUM_EOS_RES::itemName = "NUM_EOS_RES";
const int TABDIMS::NUM_EOS_RES::defaultValue = 1;
const std::string TABDIMS::NUM_EOS_SURFACE::itemName = "NUM_EOS_SURFACE";
const int TABDIMS::NUM_EOS_SURFACE::defaultValue = 1;
const std::string TABDIMS::MAX_FLUX_REGIONS::itemName = "MAX_FLUX_REGIONS";
const int TABDIMS::MAX_FLUX_REGIONS::defaultValue = 10;
const std::string TABDIMS::MAX_THERMAL_REGIONS::itemName = "MAX_THERMAL_REGIONS";
@@ -194,9 +190,7 @@ const int TABDIMS::NUM_KVALUE_TABLES::defaultValue = 0;
const std::string TABDIMS::RESERVED::itemName = "RESERVED";
TBLK::TBLK( ) : ParserKeyword("TBLK")
{
setFixedSize( (size_t) 1);
TBLK::TBLK() : ParserKeyword("TBLK", KeywordSize(1, false)) {
addValidSectionName("SOLUTION");
clearDeckNames();
setMatchRegex("TBLK(F|S).{1,3}");
@@ -214,9 +208,7 @@ const std::string TBLK::keywordName = "TBLK";
const std::string TBLK::data::itemName = "data";
TEMP::TEMP( ) : ParserKeyword("TEMP")
{
setFixedSize( (size_t) 0);
TEMP::TEMP() : ParserKeyword("TEMP", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("TEMP");
@@ -224,9 +216,7 @@ TEMP::TEMP( ) : ParserKeyword("TEMP")
const std::string TEMP::keywordName = "TEMP";
TEMPI::TEMPI( ) : ParserKeyword("TEMPI")
{
setFixedSize( (size_t) 1);
TEMPI::TEMPI() : ParserKeyword("TEMPI", KeywordSize(1, false)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("TEMPI");
@@ -245,10 +235,7 @@ const std::string TEMPI::keywordName = "TEMPI";
const std::string TEMPI::data::itemName = "data";
TEMPNODE::TEMPNODE( ) : ParserKeyword("TEMPNODE")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NPPVT",0);
TEMPNODE::TEMPNODE() : ParserKeyword("TEMPNODE", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TEMPNODE");
@@ -266,9 +253,7 @@ const std::string TEMPNODE::keywordName = "TEMPNODE";
const std::string TEMPNODE::TABLE_DATA::itemName = "TABLE_DATA";
TEMPTVD::TEMPTVD( ) : ParserKeyword("TEMPTVD")
{
setFixedSize( (size_t) 0);
TEMPTVD::TEMPTVD() : ParserKeyword("TEMPTVD", KeywordSize(0, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TEMPTVD");
@@ -276,12 +261,12 @@ TEMPTVD::TEMPTVD( ) : ParserKeyword("TEMPTVD")
const std::string TEMPTVD::keywordName = "TEMPTVD";
TEMPVD::TEMPVD( ) : ParserKeyword("TEMPVD")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("EQLDIMS","NTEQUL",0);
TEMPVD::TEMPVD() : ParserKeyword("TEMPVD", KeywordSize("EQLDIMS", "NTEQUL", false, 0)) {
addValidSectionName("PROPS");
addValidSectionName("SOLUTION");
setProhibitedKeywords({
"RTEMPVD",
});
clearDeckNames();
addDeckName("TEMPVD");
{
@@ -300,9 +285,7 @@ const std::string TEMPVD::keywordName = "TEMPVD";
const std::string TEMPVD::DATA::itemName = "DATA";
THCGAS::THCGAS( ) : ParserKeyword("THCGAS")
{
setFixedSize( (size_t) 1);
THCGAS::THCGAS() : ParserKeyword("THCGAS", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("THCGAS");
@@ -321,9 +304,7 @@ const std::string THCGAS::keywordName = "THCGAS";
const std::string THCGAS::data::itemName = "data";
THCOIL::THCOIL( ) : ParserKeyword("THCOIL")
{
setFixedSize( (size_t) 1);
THCOIL::THCOIL() : ParserKeyword("THCOIL", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("THCOIL");
@@ -342,9 +323,7 @@ const std::string THCOIL::keywordName = "THCOIL";
const std::string THCOIL::data::itemName = "data";
THCONR::THCONR( ) : ParserKeyword("THCONR")
{
setFixedSize( (size_t) 1);
THCONR::THCONR() : ParserKeyword("THCONR", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("THCONR");
@@ -363,9 +342,7 @@ const std::string THCONR::keywordName = "THCONR";
const std::string THCONR::data::itemName = "data";
THCONSF::THCONSF( ) : ParserKeyword("THCONSF")
{
setFixedSize( (size_t) 1);
THCONSF::THCONSF() : ParserKeyword("THCONSF", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("THCONSF");
@@ -384,9 +361,7 @@ const std::string THCONSF::keywordName = "THCONSF";
const std::string THCONSF::data::itemName = "data";
THCROCK::THCROCK( ) : ParserKeyword("THCROCK")
{
setFixedSize( (size_t) 1);
THCROCK::THCROCK() : ParserKeyword("THCROCK", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("THCROCK");
@@ -405,9 +380,7 @@ const std::string THCROCK::keywordName = "THCROCK";
const std::string THCROCK::data::itemName = "data";
THCWATER::THCWATER( ) : ParserKeyword("THCWATER")
{
setFixedSize( (size_t) 1);
THCWATER::THCWATER() : ParserKeyword("THCWATER", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("THCWATER");
@@ -426,9 +399,7 @@ const std::string THCWATER::keywordName = "THCWATER";
const std::string THCWATER::data::itemName = "data";
THERMAL::THERMAL( ) : ParserKeyword("THERMAL")
{
setFixedSize( (size_t) 0);
THERMAL::THERMAL() : ParserKeyword("THERMAL", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("THERMAL");
@@ -436,9 +407,7 @@ THERMAL::THERMAL( ) : ParserKeyword("THERMAL")
const std::string THERMAL::keywordName = "THERMAL";
THPRES::THPRES( ) : ParserKeyword("THPRES")
{
setSizeType(SLASH_TERMINATED);
THPRES::THPRES() : ParserKeyword("THPRES", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("THPRES");
@@ -466,9 +435,7 @@ const std::string THPRES::REGION2::itemName = "REGION2";
const std::string THPRES::VALUE::itemName = "VALUE";
THPRESFT::THPRESFT( ) : ParserKeyword("THPRESFT")
{
setSizeType(SLASH_TERMINATED);
THPRESFT::THPRESFT() : ParserKeyword("THPRESFT", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("THPRESFT");
@@ -491,12 +458,27 @@ const std::string THPRESFT::FAULT_NAME::itemName = "FAULT_NAME";
const std::string THPRESFT::VALUE::itemName = "VALUE";
TIGHTEN::TIGHTEN( ) : ParserKeyword("TIGHTEN")
{
setFixedSize( (size_t) 1);
TIGHTEN::TIGHTEN() : ParserKeyword("TIGHTEN", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("TIGHTEN");
{
ParserRecord record;
{
ParserItem item("FACTOR", ParserItem::itype::DOUBLE);
record.addItem(item);
}
addRecord( record );
}
}
const std::string TIGHTEN::keywordName = "TIGHTEN";
const std::string TIGHTEN::FACTOR::itemName = "FACTOR";
TIGHTENP::TIGHTENP() : ParserKeyword("TIGHTENP", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("TIGHTENP");
{
ParserRecord record;
{
@@ -518,16 +500,14 @@ TIGHTEN::TIGHTEN( ) : ParserKeyword("TIGHTEN")
addRecord( record );
}
}
const std::string TIGHTEN::keywordName = "TIGHTEN";
const std::string TIGHTEN::LINEAR_FACTOR::itemName = "LINEAR_FACTOR";
const std::string TIGHTEN::MAX_LINEAR::itemName = "MAX_LINEAR";
const std::string TIGHTEN::NONLINEAR_FACTOR::itemName = "NONLINEAR_FACTOR";
const std::string TIGHTEN::MAX_NONLINEAR::itemName = "MAX_NONLINEAR";
const std::string TIGHTENP::keywordName = "TIGHTENP";
const std::string TIGHTENP::LINEAR_FACTOR::itemName = "LINEAR_FACTOR";
const std::string TIGHTENP::MAX_LINEAR::itemName = "MAX_LINEAR";
const std::string TIGHTENP::NONLINEAR_FACTOR::itemName = "NONLINEAR_FACTOR";
const std::string TIGHTENP::MAX_NONLINEAR::itemName = "MAX_NONLINEAR";
TIME::TIME( ) : ParserKeyword("TIME")
{
setFixedSize( (size_t) 1);
TIME::TIME() : ParserKeyword("TIME", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("TIME");
@@ -546,9 +526,7 @@ const std::string TIME::keywordName = "TIME";
const std::string TIME::step_list::itemName = "step_list";
TITLE::TITLE( ) : ParserKeyword("TITLE")
{
setFixedSize( (size_t) 1);
TITLE::TITLE() : ParserKeyword("TITLE", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("TITLE");
@@ -566,10 +544,7 @@ const std::string TITLE::keywordName = "TITLE";
const std::string TITLE::TitleText::itemName = "TitleText";
TLMIXPAR::TLMIXPAR( ) : ParserKeyword("TLMIXPAR")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("MISCIBLE","NTMISC",0);
TLMIXPAR::TLMIXPAR() : ParserKeyword("TLMIXPAR", KeywordSize("MISCIBLE", "NTMISC", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TLMIXPAR");
@@ -593,10 +568,7 @@ const std::string TLMIXPAR::TL_VISCOSITY_PARAMETER::itemName = "TL_VISCOSITY_PAR
const std::string TLMIXPAR::TL_DENSITY_PARAMETER::itemName = "TL_DENSITY_PARAMETER";
TLPMIXPA::TLPMIXPA( ) : ParserKeyword("TLPMIXPA")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("MISCIBLE","NTMISC",0);
TLPMIXPA::TLPMIXPA() : ParserKeyword("TLPMIXPA", KeywordSize("MISCIBLE", "NTMISC", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TLPMIXPA");
@@ -616,9 +588,7 @@ const std::string TLPMIXPA::keywordName = "TLPMIXPA";
const std::string TLPMIXPA::DATA::itemName = "DATA";
TNUM::TNUM( ) : ParserKeyword("TNUM")
{
setFixedSize( (size_t) 1);
TNUM::TNUM() : ParserKeyword("TNUM", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
setMatchRegex("TNUM(F|S).{1,3}");
@@ -636,9 +606,7 @@ const std::string TNUM::keywordName = "TNUM";
const std::string TNUM::data::itemName = "data";
TOLCRIT::TOLCRIT( ) : ParserKeyword("TOLCRIT")
{
setFixedSize( (size_t) 1);
TOLCRIT::TOLCRIT() : ParserKeyword("TOLCRIT", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TOLCRIT");
@@ -655,12 +623,10 @@ TOLCRIT::TOLCRIT( ) : ParserKeyword("TOLCRIT")
}
const std::string TOLCRIT::keywordName = "TOLCRIT";
const std::string TOLCRIT::VALUE::itemName = "VALUE";
const double TOLCRIT::VALUE::defaultValue = 0.000001;
const double TOLCRIT::VALUE::defaultValue = 1e-06;
TOPS::TOPS( ) : ParserKeyword("TOPS")
{
setFixedSize( (size_t) 1);
TOPS::TOPS() : ParserKeyword("TOPS", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("TOPS");
@@ -679,10 +645,7 @@ const std::string TOPS::keywordName = "TOPS";
const std::string TOPS::data::itemName = "data";
TPAMEPS::TPAMEPS( ) : ParserKeyword("TPAMEPS")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("REGDIMS","NTCREG",0);
TPAMEPS::TPAMEPS() : ParserKeyword("TPAMEPS", KeywordSize("REGDIMS", "NTCREG", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TPAMEPS");
@@ -700,9 +663,25 @@ const std::string TPAMEPS::keywordName = "TPAMEPS";
const std::string TPAMEPS::DATA::itemName = "DATA";
TRACER::TRACER( ) : ParserKeyword("TRACER")
{
setSizeType(SLASH_TERMINATED);
TPAMEPSS::TPAMEPSS() : ParserKeyword("TPAMEPSS", KeywordSize("REGDIMS", "NTCREG", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TPAMEPSS");
{
ParserRecord record;
{
ParserItem item("DATA", ParserItem::itype::DOUBLE);
item.setSizeType(ParserItem::item_size::ALL);
record.addItem(item);
}
addRecord( record );
}
}
const std::string TPAMEPSS::keywordName = "TPAMEPSS";
const std::string TPAMEPSS::DATA::itemName = "DATA";
TRACER::TRACER() : ParserKeyword("TRACER", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TRACER");
@@ -744,10 +723,11 @@ const std::string TRACER::NUM_PART_TABLE::itemName = "NUM_PART_TABLE";
const std::string TRACER::ADSORB_PHASE::itemName = "ADSORB_PHASE";
TRACERKM::TRACERKM( ) : ParserKeyword("TRACERKM")
{
setSizeType(UNKNOWN);
TRACERKM::TRACERKM() : ParserKeyword("TRACERKM", KeywordSize("PARTTRAC", "NKPTMX", false, 2)) {
addValidSectionName("PROPS");
setRequiredKeywords({
"PARTTRAC",
});
clearDeckNames();
addDeckName("TRACERKM");
{
@@ -790,10 +770,7 @@ const std::string TRACERKM::PHASES::itemName = "PHASES";
const std::string TRACERKM::TABLE::itemName = "TABLE";
TRACERKP::TRACERKP( ) : ParserKeyword("TRACERKP")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("PARTTRAC","NKPTMX",0);
TRACERKP::TRACERKP() : ParserKeyword("TRACERKP", KeywordSize("PARTTRAC", "NKPTMX", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TRACERKP");
@@ -813,9 +790,7 @@ const std::string TRACERKP::keywordName = "TRACERKP";
const std::string TRACERKP::TABLE::itemName = "TABLE";
TRACERS::TRACERS( ) : ParserKeyword("TRACERS")
{
setFixedSize( (size_t) 1);
TRACERS::TRACERS() : ParserKeyword("TRACERS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("TRACERS");
@@ -907,9 +882,7 @@ const std::string TRACERS::NTIGHTFACTORS::itemName = "NTIGHTFACTORS";
const int TRACERS::NTIGHTFACTORS::defaultValue = 0;
TRACITVD::TRACITVD( ) : ParserKeyword("TRACITVD")
{
setFixedSize( (size_t) 1);
TRACITVD::TRACITVD() : ParserKeyword("TRACITVD", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TRACITVD");
@@ -935,9 +908,7 @@ const std::string TRACITVD::BOTH_TIMESTEP::itemName = "BOTH_TIMESTEP";
const std::string TRACITVD::BOTH_TIMESTEP::defaultValue = "YES";
TRACTVD::TRACTVD( ) : ParserKeyword("TRACTVD")
{
setFixedSize( (size_t) 0);
TRACTVD::TRACTVD() : ParserKeyword("TRACTVD", KeywordSize(0, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TRACTVD");
@@ -945,10 +916,7 @@ TRACTVD::TRACTVD( ) : ParserKeyword("TRACTVD")
const std::string TRACTVD::keywordName = "TRACTVD";
TRADS::TRADS( ) : ParserKeyword("TRADS")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
TRADS::TRADS() : ParserKeyword("TRADS", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TRADS");
@@ -966,9 +934,7 @@ const std::string TRADS::keywordName = "TRADS";
const std::string TRADS::DATA::itemName = "DATA";
TRANGL::TRANGL( ) : ParserKeyword("TRANGL")
{
setSizeType(SLASH_TERMINATED);
TRANGL::TRANGL() : ParserKeyword("TRANGL", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("TRANGL");
@@ -1016,9 +982,7 @@ const std::string TRANGL::KG::itemName = "KG";
const std::string TRANGL::TRAN::itemName = "TRAN";
TRANR::TRANR( ) : ParserKeyword("TRANR")
{
setFixedSize( (size_t) 1);
TRANR::TRANR() : ParserKeyword("TRANR", KeywordSize(1, false)) {
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("TRANR");
@@ -1037,9 +1001,7 @@ const std::string TRANR::keywordName = "TRANR";
const std::string TRANR::data::itemName = "data";
TRANTHT::TRANTHT( ) : ParserKeyword("TRANTHT")
{
setFixedSize( (size_t) 1);
TRANTHT::TRANTHT() : ParserKeyword("TRANTHT", KeywordSize(1, false)) {
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("TRANTHT");
@@ -1058,9 +1020,7 @@ const std::string TRANTHT::keywordName = "TRANTHT";
const std::string TRANTHT::data::itemName = "data";
TRANX::TRANX( ) : ParserKeyword("TRANX")
{
setFixedSize( (size_t) 1);
TRANX::TRANX() : ParserKeyword("TRANX", KeywordSize(1, false)) {
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("TRANX");
@@ -1079,9 +1039,7 @@ const std::string TRANX::keywordName = "TRANX";
const std::string TRANX::data::itemName = "data";
TRANY::TRANY( ) : ParserKeyword("TRANY")
{
setFixedSize( (size_t) 1);
TRANY::TRANY() : ParserKeyword("TRANY", KeywordSize(1, false)) {
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("TRANY");
@@ -1100,9 +1058,7 @@ const std::string TRANY::keywordName = "TRANY";
const std::string TRANY::data::itemName = "data";
TRANZ::TRANZ( ) : ParserKeyword("TRANZ")
{
setFixedSize( (size_t) 1);
TRANZ::TRANZ() : ParserKeyword("TRANZ", KeywordSize(1, false)) {
addValidSectionName("EDIT");
clearDeckNames();
addDeckName("TRANZ");
@@ -1121,10 +1077,7 @@ const std::string TRANZ::keywordName = "TRANZ";
const std::string TRANZ::data::itemName = "data";
TRDCY::TRDCY( ) : ParserKeyword("TRDCY")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTPVT",0);
TRDCY::TRDCY() : ParserKeyword("TRDCY", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
setMatchRegex("TRDCY.+");
@@ -1144,10 +1097,7 @@ const std::string TRDCY::HALF_TIME::itemName = "HALF_TIME";
const double TRDCY::HALF_TIME::defaultValue = 100000000000000000000.000000;
TRDIF::TRDIF( ) : ParserKeyword("TRDIF")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTPVT",0);
TRDIF::TRDIF() : ParserKeyword("TRDIF", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
setMatchRegex("TRDIF.+");
@@ -1167,10 +1117,7 @@ const std::string TRDIF::HALF_TIME::itemName = "HALF_TIME";
const double TRDIF::HALF_TIME::defaultValue = 100000000000000000000.000000;
TRDIS::TRDIS( ) : ParserKeyword("TRDIS")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTPVT",0);
TRDIS::TRDIS() : ParserKeyword("TRDIS", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
setMatchRegex("TRDIS.+");
@@ -1227,10 +1174,7 @@ const std::string TRDIS::D8TABLE::itemName = "D8TABLE";
const std::string TRDIS::D9TABLE::itemName = "D9TABLE";
TREF::TREF( ) : ParserKeyword("TREF")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NUM_STATE_EQ",0);
TREF::TREF() : ParserKeyword("TREF", KeywordSize("TABDIMS", "NUM_STATE_EQ", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TREF");
@@ -1249,10 +1193,7 @@ const std::string TREF::keywordName = "TREF";
const std::string TREF::TEMPERATURE::itemName = "TEMPERATURE";
TREFS::TREFS( ) : ParserKeyword("TREFS")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NUM_STATE_EQ",0);
TREFS::TREFS() : ParserKeyword("TREFS", KeywordSize("TABDIMS", "NUM_STATE_EQ", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TREFS");
@@ -1271,9 +1212,7 @@ const std::string TREFS::keywordName = "TREFS";
const std::string TREFS::TEMPERATURE::itemName = "TEMPERATURE";
TRKPF::TRKPF( ) : ParserKeyword("TRKPF")
{
setFixedSize( (size_t) 1);
TRKPF::TRKPF() : ParserKeyword("TRKPF", KeywordSize(1, false)) {
addValidSectionName("REGIONS");
clearDeckNames();
setMatchRegex("TRKPF.+");
@@ -1291,9 +1230,7 @@ const std::string TRKPF::keywordName = "TRKPF";
const std::string TRKPF::data::itemName = "data";
TRNHD::TRNHD( ) : ParserKeyword("TRNHD")
{
setFixedSize( (size_t) 0);
TRNHD::TRNHD() : ParserKeyword("TRNHD", KeywordSize(0, false)) {
addValidSectionName("PROPS");
clearDeckNames();
setMatchRegex("TRNHD.+");
@@ -1301,9 +1238,7 @@ TRNHD::TRNHD( ) : ParserKeyword("TRNHD")
const std::string TRNHD::keywordName = "TRNHD";
TRPLPORO::TRPLPORO( ) : ParserKeyword("TRPLPORO")
{
setSizeType(SLASH_TERMINATED);
TRPLPORO::TRPLPORO() : ParserKeyword("TRPLPORO", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("TRPLPORO");
@@ -1320,10 +1255,7 @@ const std::string TRPLPORO::keywordName = "TRPLPORO";
const std::string TRPLPORO::NUM_MATRIX::itemName = "NUM_MATRIX";
TRROCK::TRROCK( ) : ParserKeyword("TRROCK")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTSFUN",0);
TRROCK::TRROCK() : ParserKeyword("TRROCK", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TRROCK");
@@ -1353,9 +1285,7 @@ const std::string TRROCK::INIT_MODEL::itemName = "INIT_MODEL";
const int TRROCK::INIT_MODEL::defaultValue = 1;
TSTEP::TSTEP( ) : ParserKeyword("TSTEP")
{
setFixedSize( (size_t) 1);
TSTEP::TSTEP() : ParserKeyword("TSTEP", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("TSTEP");
@@ -1374,9 +1304,7 @@ const std::string TSTEP::keywordName = "TSTEP";
const std::string TSTEP::step_list::itemName = "step_list";
TUNING::TUNING( ) : ParserKeyword("TUNING")
{
setFixedSize( (size_t) 3);
TUNING::TUNING() : ParserKeyword("TUNING", KeywordSize(3, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("TUNING");
@@ -1588,7 +1516,7 @@ const double TUNING::TRGTTE::defaultValue = 0.100000;
const std::string TUNING::TRGCNV::itemName = "TRGCNV";
const double TUNING::TRGCNV::defaultValue = 0.001000;
const std::string TUNING::TRGMBE::itemName = "TRGMBE";
const double TUNING::TRGMBE::defaultValue = 0.000000;
const double TUNING::TRGMBE::defaultValue = 1e-07;
const std::string TUNING::TRGLCV::itemName = "TRGLCV";
const double TUNING::TRGLCV::defaultValue = 0.000100;
const std::string TUNING::XXXTTE::itemName = "XXXTTE";
@@ -1596,7 +1524,7 @@ const double TUNING::XXXTTE::defaultValue = 10.000000;
const std::string TUNING::XXXCNV::itemName = "XXXCNV";
const double TUNING::XXXCNV::defaultValue = 0.010000;
const std::string TUNING::XXXMBE::itemName = "XXXMBE";
const double TUNING::XXXMBE::defaultValue = 0.000001;
const double TUNING::XXXMBE::defaultValue = 1e-06;
const std::string TUNING::XXXLCV::itemName = "XXXLCV";
const double TUNING::XXXLCV::defaultValue = 0.001000;
const std::string TUNING::XXXWFL::itemName = "XXXWFL";
@@ -1629,9 +1557,7 @@ const double TUNING::TRGDPR::defaultValue = 1000000.000000;
const std::string TUNING::XXXDPR::itemName = "XXXDPR";
TUNINGDP::TUNINGDP( ) : ParserKeyword("TUNINGDP")
{
setFixedSize( (size_t) 1);
TUNINGDP::TUNINGDP() : ParserKeyword("TUNINGDP", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("TUNINGDP");
@@ -1663,9 +1589,7 @@ const std::string TUNINGDP::TRGDDP::itemName = "TRGDDP";
const std::string TUNINGDP::TRGDDS::itemName = "TRGDDS";
TUNINGH::TUNINGH( ) : ParserKeyword("TUNINGH")
{
setFixedSize( (size_t) 1);
TUNINGH::TUNINGH() : ParserKeyword("TUNINGH", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("TUNINGH");
@@ -1705,16 +1629,14 @@ const double TUNINGH::GRGLCV::defaultValue = 0.000100;
const std::string TUNINGH::GXXLCV::itemName = "GXXLCV";
const double TUNINGH::GXXLCV::defaultValue = 0.001000;
const std::string TUNINGH::GMSLCV::itemName = "GMSLCV";
const double TUNINGH::GMSLCV::defaultValue = 0.000000;
const double TUNINGH::GMSLCV::defaultValue = 1e-20;
const std::string TUNINGH::LGTMIN::itemName = "LGTMIN";
const int TUNINGH::LGTMIN::defaultValue = 1;
const std::string TUNINGH::LGTMAX::itemName = "LGTMAX";
const int TUNINGH::LGTMAX::defaultValue = 25;
TUNINGL::TUNINGL( ) : ParserKeyword("TUNINGL")
{
setFixedSize( (size_t) 3);
TUNINGL::TUNINGL() : ParserKeyword("TUNINGL", KeywordSize(3, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("TUNINGL");
@@ -1926,7 +1848,7 @@ const double TUNINGL::TRGTTE::defaultValue = 0.100000;
const std::string TUNINGL::TRGCNV::itemName = "TRGCNV";
const double TUNINGL::TRGCNV::defaultValue = 0.001000;
const std::string TUNINGL::TRGMBE::itemName = "TRGMBE";
const double TUNINGL::TRGMBE::defaultValue = 0.000000;
const double TUNINGL::TRGMBE::defaultValue = 1e-07;
const std::string TUNINGL::TRGLCV::itemName = "TRGLCV";
const double TUNINGL::TRGLCV::defaultValue = 0.000100;
const std::string TUNINGL::XXXTTE::itemName = "XXXTTE";
@@ -1934,7 +1856,7 @@ const double TUNINGL::XXXTTE::defaultValue = 10.000000;
const std::string TUNINGL::XXXCNV::itemName = "XXXCNV";
const double TUNINGL::XXXCNV::defaultValue = 0.010000;
const std::string TUNINGL::XXXMBE::itemName = "XXXMBE";
const double TUNINGL::XXXMBE::defaultValue = 0.000001;
const double TUNINGL::XXXMBE::defaultValue = 1e-06;
const std::string TUNINGL::XXXLCV::itemName = "XXXLCV";
const double TUNINGL::XXXLCV::defaultValue = 0.001000;
const std::string TUNINGL::XXXWFL::itemName = "XXXWFL";
@@ -1967,9 +1889,7 @@ const double TUNINGL::TRGDPR::defaultValue = 1000000.000000;
const std::string TUNINGL::XXXDPR::itemName = "XXXDPR";
TUNINGS::TUNINGS( ) : ParserKeyword("TUNINGS")
{
setFixedSize( (size_t) 4);
TUNINGS::TUNINGS() : ParserKeyword("TUNINGS", KeywordSize(4, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("TUNINGS");
@@ -2190,7 +2110,7 @@ const double TUNINGS::TRGTTE::defaultValue = 0.100000;
const std::string TUNINGS::TRGCNV::itemName = "TRGCNV";
const double TUNINGS::TRGCNV::defaultValue = 0.001000;
const std::string TUNINGS::TRGMBE::itemName = "TRGMBE";
const double TUNINGS::TRGMBE::defaultValue = 0.000000;
const double TUNINGS::TRGMBE::defaultValue = 1e-07;
const std::string TUNINGS::TRGLCV::itemName = "TRGLCV";
const double TUNINGS::TRGLCV::defaultValue = 0.000100;
const std::string TUNINGS::XXXTTE::itemName = "XXXTTE";
@@ -2198,7 +2118,7 @@ const double TUNINGS::XXXTTE::defaultValue = 10.000000;
const std::string TUNINGS::XXXCNV::itemName = "XXXCNV";
const double TUNINGS::XXXCNV::defaultValue = 0.010000;
const std::string TUNINGS::XXXMBE::itemName = "XXXMBE";
const double TUNINGS::XXXMBE::defaultValue = 0.000001;
const double TUNINGS::XXXMBE::defaultValue = 1e-06;
const std::string TUNINGS::XXXLCV::itemName = "XXXLCV";
const double TUNINGS::XXXLCV::defaultValue = 0.001000;
const std::string TUNINGS::XXXWFL::itemName = "XXXWFL";
@@ -2231,10 +2151,7 @@ const double TUNINGS::TRGDPR::defaultValue = 1000000.000000;
const std::string TUNINGS::XXXDPR::itemName = "XXXDPR";
TVDP::TVDP( ) : ParserKeyword("TVDP")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("EQLDIMS","NTTRVD",0);
TVDP::TVDP() : ParserKeyword("TVDP", KeywordSize("EQLDIMS", "NTTRVD", false, 0)) {
addValidSectionName("SOLUTION");
clearDeckNames();
setMatchRegex("TVDP.+");
@@ -2254,9 +2171,7 @@ const std::string TVDP::keywordName = "TVDP";
const std::string TVDP::DATA::itemName = "DATA";
TZONE::TZONE( ) : ParserKeyword("TZONE")
{
setFixedSize( (size_t) 1);
TZONE::TZONE() : ParserKeyword("TZONE", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("TZONE");

69
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/U.cpp vendored
View File

@@ -1,18 +1,17 @@
#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/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/parser/eclipse/Parser/ParserKeywords/U.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/U.hpp>
namespace Opm {
namespace ParserKeywords {
UDADIMS::UDADIMS( ) : ParserKeyword("UDADIMS")
{
setFixedSize( (size_t) 1);
UDADIMS::UDADIMS() : ParserKeyword("UDADIMS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("UDADIMS");
@@ -45,9 +44,7 @@ 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);
UDQ::UDQ() : ParserKeyword("UDQ", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("UDQ");
@@ -75,9 +72,7 @@ const std::string UDQ::QUANTITY::itemName = "QUANTITY";
const std::string UDQ::DATA::itemName = "DATA";
UDQDIMS::UDQDIMS( ) : ParserKeyword("UDQDIMS")
{
setFixedSize( (size_t) 1);
UDQDIMS::UDQDIMS() : ParserKeyword("UDQDIMS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("UDQDIMS");
@@ -166,9 +161,7 @@ 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);
UDQPARAM::UDQPARAM() : ParserKeyword("UDQPARAM", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("UDQPARAM");
@@ -203,14 +196,12 @@ 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 double UDQPARAM::UNDEFINED_VALUE::defaultValue = 0;
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);
UDT::UDT() : ParserKeyword("UDT", KeywordSize(0, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("UDT");
@@ -218,9 +209,7 @@ UDT::UDT( ) : ParserKeyword("UDT")
const std::string UDT::keywordName = "UDT";
UDTDIMS::UDTDIMS( ) : ParserKeyword("UDTDIMS")
{
setFixedSize( (size_t) 1);
UDTDIMS::UDTDIMS() : ParserKeyword("UDTDIMS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("UDTDIMS");
@@ -260,9 +249,7 @@ const std::string UDTDIMS::MAX_DIMENSIONS::itemName = "MAX_DIMENSIONS";
const int UDTDIMS::MAX_DIMENSIONS::defaultValue = 0;
UNCODHMD::UNCODHMD( ) : ParserKeyword("UNCODHMD")
{
setFixedSize( (size_t) 0);
UNCODHMD::UNCODHMD() : ParserKeyword("UNCODHMD", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("UNCODHMD");
@@ -270,9 +257,7 @@ UNCODHMD::UNCODHMD( ) : ParserKeyword("UNCODHMD")
const std::string UNCODHMD::keywordName = "UNCODHMD";
UNIFIN::UNIFIN( ) : ParserKeyword("UNIFIN")
{
setFixedSize( (size_t) 0);
UNIFIN::UNIFIN() : ParserKeyword("UNIFIN", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("UNIFIN");
@@ -280,9 +265,7 @@ UNIFIN::UNIFIN( ) : ParserKeyword("UNIFIN")
const std::string UNIFIN::keywordName = "UNIFIN";
UNIFOUT::UNIFOUT( ) : ParserKeyword("UNIFOUT")
{
setFixedSize( (size_t) 0);
UNIFOUT::UNIFOUT() : ParserKeyword("UNIFOUT", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("UNIFOUT");
@@ -290,9 +273,7 @@ UNIFOUT::UNIFOUT( ) : ParserKeyword("UNIFOUT")
const std::string UNIFOUT::keywordName = "UNIFOUT";
UNIFOUTS::UNIFOUTS( ) : ParserKeyword("UNIFOUTS")
{
setFixedSize( (size_t) 0);
UNIFOUTS::UNIFOUTS() : ParserKeyword("UNIFOUTS", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("UNIFOUTS");
@@ -300,9 +281,7 @@ UNIFOUTS::UNIFOUTS( ) : ParserKeyword("UNIFOUTS")
const std::string UNIFOUTS::keywordName = "UNIFOUTS";
UNIFSAVE::UNIFSAVE( ) : ParserKeyword("UNIFSAVE")
{
setFixedSize( (size_t) 0);
UNIFSAVE::UNIFSAVE() : ParserKeyword("UNIFSAVE", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("UNIFSAVE");
@@ -310,9 +289,7 @@ UNIFSAVE::UNIFSAVE( ) : ParserKeyword("UNIFSAVE")
const std::string UNIFSAVE::keywordName = "UNIFSAVE";
USECUPL::USECUPL( ) : ParserKeyword("USECUPL")
{
setSizeType(SLASH_TERMINATED);
USECUPL::USECUPL() : ParserKeyword("USECUPL", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("USECUPL");
@@ -334,9 +311,7 @@ const std::string USECUPL::BASE::itemName = "BASE";
const std::string USECUPL::FMT::itemName = "FMT";
USEFLUX::USEFLUX( ) : ParserKeyword("USEFLUX")
{
setFixedSize( (size_t) 0);
USEFLUX::USEFLUX() : ParserKeyword("USEFLUX", KeywordSize(0, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("USEFLUX");
@@ -344,9 +319,7 @@ USEFLUX::USEFLUX( ) : ParserKeyword("USEFLUX")
const std::string USEFLUX::keywordName = "USEFLUX";
USENOFLO::USENOFLO( ) : ParserKeyword("USENOFLO")
{
setFixedSize( (size_t) 0);
USENOFLO::USENOFLO() : ParserKeyword("USENOFLO", KeywordSize(0, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("USENOFLO");

117
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/V.cpp vendored
View File

@@ -1,18 +1,17 @@
#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/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/parser/eclipse/Parser/ParserKeywords/V.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/V.hpp>
namespace Opm {
namespace ParserKeywords {
VAPOIL::VAPOIL( ) : ParserKeyword("VAPOIL")
{
setFixedSize( (size_t) 0);
VAPOIL::VAPOIL() : ParserKeyword("VAPOIL", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("VAPOIL");
@@ -20,11 +19,9 @@ VAPOIL::VAPOIL( ) : ParserKeyword("VAPOIL")
const std::string VAPOIL::keywordName = "VAPOIL";
VAPPARS::VAPPARS( ) : ParserKeyword("VAPPARS")
{
setFixedSize( (size_t) 1);
addValidSectionName("SCHEDULE");
VAPPARS::VAPPARS() : ParserKeyword("VAPPARS", KeywordSize(1, false)) {
addValidSectionName("SOLUTION");
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("VAPPARS");
{
@@ -45,9 +42,7 @@ 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);
VAPWAT::VAPWAT() : ParserKeyword("VAPWAT", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("VAPWAT");
@@ -55,9 +50,7 @@ VAPWAT::VAPWAT( ) : ParserKeyword("VAPWAT")
const std::string VAPWAT::keywordName = "VAPWAT";
VDFLOW::VDFLOW( ) : ParserKeyword("VDFLOW")
{
setFixedSize( (size_t) 1);
VDFLOW::VDFLOW() : ParserKeyword("VDFLOW", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("VDFLOW");
@@ -74,10 +67,7 @@ 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);
VDFLOWR::VDFLOWR() : ParserKeyword("VDFLOWR", KeywordSize("TABDIMS", "NTSFUN", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("VDFLOWR");
@@ -94,9 +84,7 @@ const std::string VDFLOWR::keywordName = "VDFLOWR";
const std::string VDFLOWR::BETA::itemName = "BETA";
VE::VE( ) : ParserKeyword("VE")
{
setFixedSize( (size_t) 1);
VE::VE() : ParserKeyword("VE", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("VE");
@@ -115,9 +103,7 @@ 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);
VEDEBUG::VEDEBUG() : ParserKeyword("VEDEBUG", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("VEDEBUG");
@@ -173,9 +159,7 @@ const std::string VEDEBUG::LGR::itemName = "LGR";
const std::string VEDEBUG::LGR::defaultValue = " ";
VEFIN::VEFIN( ) : ParserKeyword("VEFIN")
{
setFixedSize( (size_t) 1);
VEFIN::VEFIN() : ParserKeyword("VEFIN", KeywordSize(1, false)) {
addValidSectionName("GRID");
clearDeckNames();
addDeckName("VEFIN");
@@ -201,9 +185,7 @@ const std::string VEFIN::NVEPT::itemName = "NVEPT";
const int VEFIN::NVEPT::defaultValue = 0;
VEFRAC::VEFRAC( ) : ParserKeyword("VEFRAC")
{
setFixedSize( (size_t) 1);
VEFRAC::VEFRAC() : ParserKeyword("VEFRAC", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("VEFRAC");
@@ -222,9 +204,7 @@ const std::string VEFRAC::FRAC::itemName = "FRAC";
const double VEFRAC::FRAC::defaultValue = 10.000000;
VEFRACP::VEFRACP( ) : ParserKeyword("VEFRACP")
{
setFixedSize( (size_t) 1);
VEFRACP::VEFRACP() : ParserKeyword("VEFRACP", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("VEFRACP");
@@ -243,9 +223,7 @@ const std::string VEFRACP::FRAC::itemName = "FRAC";
const double VEFRACP::FRAC::defaultValue = 1.000000;
VEFRACPV::VEFRACPV( ) : ParserKeyword("VEFRACPV")
{
setFixedSize( (size_t) 1);
VEFRACPV::VEFRACPV() : ParserKeyword("VEFRACPV", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("VEFRACPV");
@@ -263,9 +241,7 @@ const std::string VEFRACPV::keywordName = "VEFRACPV";
const std::string VEFRACPV::data::itemName = "data";
VEFRACV::VEFRACV( ) : ParserKeyword("VEFRACV")
{
setFixedSize( (size_t) 1);
VEFRACV::VEFRACV() : ParserKeyword("VEFRACV", KeywordSize(1, false)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("VEFRACV");
@@ -283,9 +259,7 @@ const std::string VEFRACV::keywordName = "VEFRACV";
const std::string VEFRACV::data::itemName = "data";
VFPCHK::VFPCHK( ) : ParserKeyword("VFPCHK")
{
setFixedSize( (size_t) 1);
VFPCHK::VFPCHK() : ParserKeyword("VFPCHK", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("VFPCHK");
@@ -305,9 +279,7 @@ 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);
VFPIDIMS::VFPIDIMS() : ParserKeyword("VFPIDIMS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("VFPIDIMS");
@@ -340,9 +312,7 @@ 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);
VFPINJ::VFPINJ() : ParserKeyword("VFPINJ", KeywordSize(UNKNOWN)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("VFPINJ");
@@ -424,9 +394,7 @@ const std::string VFPINJ::THP_INDEX::itemName = "THP_INDEX";
const std::string VFPINJ::VALUES::itemName = "VALUES";
VFPPDIMS::VFPPDIMS( ) : ParserKeyword("VFPPDIMS")
{
setFixedSize( (size_t) 1);
VFPPDIMS::VFPPDIMS() : ParserKeyword("VFPPDIMS", KeywordSize(1, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("VFPPDIMS");
@@ -480,9 +448,7 @@ 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);
VFPPROD::VFPPROD() : ParserKeyword("VFPPROD", KeywordSize(UNKNOWN)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("VFPPROD");
@@ -624,9 +590,7 @@ const std::string VFPPROD::ALQ_INDEX::itemName = "ALQ_INDEX";
const std::string VFPPROD::VALUES::itemName = "VALUES";
VFPTABL::VFPTABL( ) : ParserKeyword("VFPTABL")
{
setFixedSize( (size_t) 1);
VFPTABL::VFPTABL() : ParserKeyword("VFPTABL", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("VFPTABL");
@@ -643,9 +607,7 @@ const std::string VFPTABL::keywordName = "VFPTABL";
const std::string VFPTABL::METHOD::itemName = "METHOD";
VISAGE::VISAGE( ) : ParserKeyword("VISAGE")
{
setFixedSize( (size_t) 0);
VISAGE::VISAGE() : ParserKeyword("VISAGE", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("VISAGE");
@@ -653,9 +615,7 @@ VISAGE::VISAGE( ) : ParserKeyword("VISAGE")
const std::string VISAGE::keywordName = "VISAGE";
VISCD::VISCD( ) : ParserKeyword("VISCD")
{
setFixedSize( (size_t) 0);
VISCD::VISCD() : ParserKeyword("VISCD", KeywordSize(0, false)) {
addValidSectionName("RUNSPEC");
clearDeckNames();
addDeckName("VISCD");
@@ -663,10 +623,7 @@ VISCD::VISCD( ) : ParserKeyword("VISCD")
const std::string VISCD::keywordName = "VISCD";
VISCREF::VISCREF( ) : ParserKeyword("VISCREF")
{
setSizeType(OTHER_KEYWORD_IN_DECK);
initSizeKeyword("TABDIMS","NTPVT",0);
VISCREF::VISCREF() : ParserKeyword("VISCREF", KeywordSize("TABDIMS", "NTPVT", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("VISCREF");
@@ -682,17 +639,21 @@ VISCREF::VISCREF( ) : ParserKeyword("VISCREF")
item.push_backDimension("GasDissolutionFactor");
record.addItem(item);
}
{
ParserItem item("API_GRAVITY", ParserItem::itype::DOUBLE);
item.push_backDimension("1");
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";
const std::string VISCREF::API_GRAVITY::itemName = "API_GRAVITY";
VISDATES::VISDATES( ) : ParserKeyword("VISDATES")
{
setSizeType(SLASH_TERMINATED);
VISDATES::VISDATES() : ParserKeyword("VISDATES", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("VISDATES");
@@ -726,9 +687,7 @@ const std::string VISDATES::TIMESTAMP::itemName = "TIMESTAMP";
const std::string VISDATES::TIMESTAMP::defaultValue = "00:00:00";
VISOPTS::VISOPTS( ) : ParserKeyword("VISOPTS")
{
setSizeType(SLASH_TERMINATED);
VISOPTS::VISOPTS() : ParserKeyword("VISOPTS", KeywordSize(SLASH_TERMINATED)) {
addValidSectionName("SOLUTION");
clearDeckNames();
addDeckName("VISOPTS");
@@ -790,8 +749,8 @@ const std::string VISOPTS::RETAIN_RESTART_FREQUENCY::itemName = "RETAIN_RESTART_
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";
const std::string VISOPTS::msvc_prefix_ERROR::itemName = "ERROR";
const std::string VISOPTS::msvc_prefix_ERROR::defaultValue = "ERROR";
}

1357
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/W.cpp vendored
View File

File diff suppressed because it is too large Load Diff

11
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/X.cpp vendored
View File

@@ -1,13 +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/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/parser/eclipse/Parser/ParserKeywords/X.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/X.hpp>
namespace Opm {
namespace ParserKeywords {
}

11
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/Y.cpp vendored
View File

@@ -1,13 +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/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/parser/eclipse/Parser/ParserKeywords/Y.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/Y.hpp>
namespace Opm {
namespace ParserKeywords {
}

46
ThirdParty/custom-opm-common/generated-opm-common/ParserKeywords/Z.cpp vendored
View File

@@ -1,19 +1,21 @@
#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/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/parser/eclipse/Parser/ParserKeywords/Z.hpp>
#include <opm/input/eclipse/Parser/ParserKeywords/Z.hpp>
namespace Opm {
namespace ParserKeywords {
ZCORN::ZCORN( ) : ParserKeyword("ZCORN")
{
setFixedSize( (size_t) 1);
ZCORN::ZCORN() : ParserKeyword("ZCORN", KeywordSize(1, false)) {
addValidSectionName("GRID");
setProhibitedKeywords({
"GDFILE",
});
clearDeckNames();
addDeckName("ZCORN");
{
@@ -31,10 +33,7 @@ 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);
ZFACT1::ZFACT1() : ParserKeyword("ZFACT1", KeywordSize("TABDIMS", "NUM_STATE_EQ", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ZFACT1");
@@ -53,10 +52,7 @@ 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);
ZFACT1S::ZFACT1S() : ParserKeyword("ZFACT1S", KeywordSize("TABDIMS", "NUM_STATE_EQ", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ZFACT1S");
@@ -75,10 +71,7 @@ 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);
ZFACTOR::ZFACTOR() : ParserKeyword("ZFACTOR", KeywordSize("TABDIMS", "NUM_STATE_EQ", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ZFACTOR");
@@ -97,10 +90,7 @@ 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);
ZFACTORS::ZFACTORS() : ParserKeyword("ZFACTORS", KeywordSize("TABDIMS", "NUM_STATE_EQ", false, 0)) {
addValidSectionName("PROPS");
clearDeckNames();
addDeckName("ZFACTORS");
@@ -119,9 +109,7 @@ const std::string ZFACTORS::keywordName = "ZFACTORS";
const std::string ZFACTORS::Z0::itemName = "Z0";
ZIPP2OFF::ZIPP2OFF( ) : ParserKeyword("ZIPP2OFF")
{
setFixedSize( (size_t) 0);
ZIPP2OFF::ZIPP2OFF() : ParserKeyword("ZIPP2OFF", KeywordSize(0, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("ZIPP2OFF");
@@ -129,9 +117,7 @@ ZIPP2OFF::ZIPP2OFF( ) : ParserKeyword("ZIPP2OFF")
const std::string ZIPP2OFF::keywordName = "ZIPP2OFF";
ZIPPY2::ZIPPY2( ) : ParserKeyword("ZIPPY2")
{
setFixedSize( (size_t) 1);
ZIPPY2::ZIPPY2() : ParserKeyword("ZIPPY2", KeywordSize(1, false)) {
addValidSectionName("SCHEDULE");
clearDeckNames();
addDeckName("ZIPPY2");

24
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/A.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/A.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_A_HPP
#define PARSER_KEYWORDS_A_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
@@ -689,9 +689,9 @@ namespace ParserKeywords {
class APIVID : public ParserKeyword {
class APIVD : public ParserKeyword {
public:
APIVID();
APIVD();
static const std::string keywordName;
class DATA {
@@ -1090,26 +1090,31 @@ namespace ParserKeywords {
class TRANS_MULT {
public:
static const std::string itemName;
static const double defaultValue;
};
class TRANS_OPTION {
public:
static const std::string itemName;
static const int defaultValue;
};
class ALLOW_INTERNAL_CELLS {
public:
static const std::string itemName;
static const std::string defaultValue;
};
class VEFRAC {
public:
static const std::string itemName;
static const double defaultValue;
};
class VEFRACP {
public:
static const std::string itemName;
static const double defaultValue;
};
};
@@ -1450,6 +1455,19 @@ namespace ParserKeywords {
class AQUIFER_PROBE_ANALYTIC_NAMED : public ParserKeyword {
public:
AQUIFER_PROBE_ANALYTIC_NAMED();
static const std::string keywordName;
class data {
public:
static const std::string itemName;
};
};
class AQUIFER_PROBE_NUMERIC : public ParserKeyword {
public:
AQUIFER_PROBE_NUMERIC();

7
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/B.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/B.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_B_HPP
#define PARSER_KEYWORDS_B_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
@@ -330,6 +330,11 @@ namespace ParserKeywords {
public:
BRINE();
static const std::string keywordName;
class SALTS {
public:
static const std::string itemName;
};
};

3415
ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/Builtin.hpp vendored Normal file
View File

File diff suppressed because it is too large Load Diff

22
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/C.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/C.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_C_HPP
#define PARSER_KEYWORDS_C_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
@@ -339,6 +339,22 @@ namespace ParserKeywords {
class CO2STOR : public ParserKeyword {
public:
CO2STOR();
static const std::string keywordName;
};
class CO2STORE : public ParserKeyword {
public:
CO2STORE();
static const std::string keywordName;
};
class COAL : public ParserKeyword {
public:
COAL();
@@ -848,21 +864,25 @@ namespace ParserKeywords {
class I {
public:
static const std::string itemName;
static const int defaultValue;
};
class J {
public:
static const std::string itemName;
static const int defaultValue;
};
class K1 {
public:
static const std::string itemName;
static const int defaultValue;
};
class K2 {
public:
static const std::string itemName;
static const int defaultValue;
};
class N {

27
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/D.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/D.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_D_HPP
#define PARSER_KEYWORDS_D_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
@@ -789,11 +789,13 @@ namespace ParserKeywords {
class GAS_OIL_CROSS_DIFF_COEFF {
public:
static const std::string itemName;
static const double defaultValue;
};
class OIL_OIL_CROSS_DIFF_COEFF {
public:
static const std::string itemName;
static const double defaultValue;
};
};
@@ -1280,7 +1282,26 @@ namespace ParserKeywords {
static const std::string itemName;
};
class Option {
class OPTION {
public:
static const std::string itemName;
static const std::string defaultValue;
};
};
class DRSDTCON : public ParserKeyword {
public:
DRSDTCON();
static const std::string keywordName;
class DRSDT_MAX {
public:
static const std::string itemName;
};
class OPTION {
public:
static const std::string itemName;
static const std::string defaultValue;
@@ -1299,7 +1320,7 @@ namespace ParserKeywords {
static const std::string itemName;
};
class Option {
class OPTION {
public:
static const std::string itemName;
static const std::string defaultValue;

22
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/E.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/E.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_E_HPP
#define PARSER_KEYWORDS_E_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
@@ -260,6 +260,12 @@ namespace ParserKeywords {
static const std::string itemName;
static const double defaultValue;
};
class FLAG_SOMETHING {
public:
static const std::string itemName;
static const int defaultValue;
};
};
@@ -381,13 +387,13 @@ namespace ParserKeywords {
static const std::string defaultValue;
};
class NUM_TABLES {
class NTENDP {
public:
static const std::string itemName;
static const int defaultValue;
};
class NUM_NODES {
class NSENDP {
public:
static const std::string itemName;
static const int defaultValue;
@@ -861,6 +867,16 @@ namespace ParserKeywords {
static const std::string itemName;
static const int defaultValue;
};
class EQLOPT04 {
public:
static const std::string itemName;
};
class EQLOPT5 {
public:
static const std::string itemName;
};
};

14
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/F.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/F.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_F_HPP
#define PARSER_KEYWORDS_F_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
@@ -267,6 +267,11 @@ namespace ParserKeywords {
public:
FLUXTYPE();
static const std::string keywordName;
class BC_TYPE {
public:
static const std::string itemName;
};
};
@@ -403,6 +408,12 @@ namespace ParserKeywords {
static const std::string itemName;
static const double defaultValue;
};
class MIN_WAT_SAT {
public:
static const std::string itemName;
static const double defaultValue;
};
};
@@ -499,6 +510,7 @@ namespace ParserKeywords {
class MODEL {
public:
static const std::string itemName;
static const std::string defaultValue;
};
};

44
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/G.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/G.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_G_HPP
#define PARSER_KEYWORDS_G_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
@@ -291,6 +291,26 @@ namespace ParserKeywords {
class GASJT : public ParserKeyword {
public:
GASJT();
static const std::string keywordName;
class PREF {
public:
static const std::string itemName;
static const double defaultValue;
};
class JOULE_THOMSON_COEFFICIENT {
public:
static const std::string itemName;
static const double defaultValue;
};
};
class GASMONTH : public ParserKeyword {
public:
GASMONTH();
@@ -588,19 +608,19 @@ namespace ParserKeywords {
static const UDAValue defaultValue;
};
class FREE {
class RESPOND_TO_PARENT {
public:
static const std::string itemName;
static const std::string defaultValue;
};
class GUIDE_FRACTION {
class GUIDE_RATE {
public:
static const std::string itemName;
static const double defaultValue;
};
class GUIDE_DEF {
class GUIDE_RATE_DEF {
public:
static const std::string itemName;
};
@@ -751,25 +771,21 @@ namespace ParserKeywords {
class OIL_TARGET {
public:
static const std::string itemName;
static const UDAValue defaultValue;
};
class WATER_TARGET {
public:
static const std::string itemName;
static const UDAValue defaultValue;
};
class GAS_TARGET {
public:
static const std::string itemName;
static const UDAValue defaultValue;
};
class LIQUID_TARGET {
public:
static const std::string itemName;
static const UDAValue defaultValue;
};
class EXCEED_PROC {
@@ -812,7 +828,6 @@ namespace ParserKeywords {
class RESERVOIR_FLUID_TARGET {
public:
static const std::string itemName;
static const double defaultValue;
};
class RESERVOIR_VOLUME_BALANCE {
@@ -902,11 +917,13 @@ namespace ParserKeywords {
class GAS_CONSUMP_RATE {
public:
static const std::string itemName;
static const UDAValue defaultValue;
};
class GAS_IMPORT_RATE {
public:
static const std::string itemName;
static const UDAValue defaultValue;
};
class NETWORK_NODE {
@@ -1647,6 +1664,7 @@ namespace ParserKeywords {
class FIP_FAMILY {
public:
static const std::string itemName;
static const std::string defaultValue;
};
class PRESSURE_TARGET {
@@ -2069,24 +2087,24 @@ namespace ParserKeywords {
GRUPRIG();
static const std::string keywordName;
class GROUP_NAME {
class GROUP {
public:
static const std::string itemName;
};
class WORKRIGNUM {
class WORKOVER_RIG_NUM {
public:
static const std::string itemName;
static const int defaultValue;
};
class DRILRIGNUM {
class DRILLING_RIG_NUM {
public:
static const std::string itemName;
static const int defaultValue;
};
class ADD {
class ADD_OR_REMOVE {
public:
static const std::string itemName;
static const std::string defaultValue;

2
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/H.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/H.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_H_HPP
#define PARSER_KEYWORDS_H_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {

2
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/I.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/I.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_I_HPP
#define PARSER_KEYWORDS_I_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {

2
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/J.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/J.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_J_HPP
#define PARSER_KEYWORDS_J_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {

2
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/K.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/K.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_K_HPP
#define PARSER_KEYWORDS_K_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {

8
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/L.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/L.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_L_HPP
#define PARSER_KEYWORDS_L_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
@@ -193,9 +193,9 @@ namespace ParserKeywords {
class LICENSE : public ParserKeyword {
class LICENSES : public ParserKeyword {
public:
LICENSE();
LICENSES();
static const std::string keywordName;
class FEATURE {
@@ -227,7 +227,7 @@ namespace ParserKeywords {
static const double defaultValue;
};
class OPTIMISE_GAS_LIFT {
class OPTIMISE_ALL_ITERATIONS {
public:
static const std::string itemName;
static const std::string defaultValue;

169
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/M.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/M.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_M_HPP
#define PARSER_KEYWORDS_M_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
@@ -9,32 +9,7 @@ namespace ParserKeywords {
MAPAXES();
static const std::string keywordName;
class X1 {
public:
static const std::string itemName;
};
class Y1 {
public:
static const std::string itemName;
};
class X2 {
public:
static const std::string itemName;
};
class Y2 {
public:
static const std::string itemName;
};
class X3 {
public:
static const std::string itemName;
};
class Y3 {
class data {
public:
static const std::string itemName;
};
@@ -300,6 +275,124 @@ namespace ParserKeywords {
class MICP : public ParserKeyword {
public:
MICP();
static const std::string keywordName;
};
class MICPPARA : public ParserKeyword {
public:
MICPPARA();
static const std::string keywordName;
class DENSITY_BIOFILM {
public:
static const std::string itemName;
static const double defaultValue;
};
class DENSITY_CALCITE {
public:
static const std::string itemName;
static const double defaultValue;
};
class DETACHMENT_RATE {
public:
static const std::string itemName;
static const double defaultValue;
};
class CRITICAL_POROSITY {
public:
static const std::string itemName;
static const double defaultValue;
};
class FITTING_FACTOR {
public:
static const std::string itemName;
static const double defaultValue;
};
class HALF_VELOCITY_OXYGEN {
public:
static const std::string itemName;
static const double defaultValue;
};
class HALF_VELOCITY_UREA {
public:
static const std::string itemName;
static const double defaultValue;
};
class MAXIMUM_GROWTH_RATE {
public:
static const std::string itemName;
static const double defaultValue;
};
class MAXIMUM_OXYGEN_CONCENTRATION {
public:
static const std::string itemName;
static const double defaultValue;
};
class MAXIMUM_UREA_CONCENTRATION {
public:
static const std::string itemName;
static const double defaultValue;
};
class MAXIMUM_UREA_UTILIZATION {
public:
static const std::string itemName;
static const double defaultValue;
};
class MICROBIAL_ATTACHMENT_RATE {
public:
static const std::string itemName;
static const double defaultValue;
};
class MICROBIAL_DEATH_RATE {
public:
static const std::string itemName;
static const double defaultValue;
};
class MINIMUM_PERMEABILITY {
public:
static const std::string itemName;
static const double defaultValue;
};
class OXYGEN_CONSUMPTION_FACTOR {
public:
static const std::string itemName;
static const double defaultValue;
};
class TOLERANCE_BEFORE_CLOGGING {
public:
static const std::string itemName;
static const double defaultValue;
};
class YIELD_GROWTH_COEFFICIENT {
public:
static const std::string itemName;
static const double defaultValue;
};
};
class MINNNCT : public ParserKeyword {
public:
MINNNCT();
@@ -326,6 +419,20 @@ namespace ParserKeywords {
class MINNPCOL : public ParserKeyword {
public:
MINNPCOL();
static const std::string keywordName;
class VALUE {
public:
static const std::string itemName;
static const int defaultValue;
};
};
class MINPORV : public ParserKeyword {
public:
MINPORV();
@@ -618,6 +725,14 @@ namespace ParserKeywords {
class MSUM_PROBE : public ParserKeyword {
public:
MSUM_PROBE();
static const std::string keywordName;
};
class MULSGGD : public ParserKeyword {
public:
MULSGGD();

46
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/N.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/N.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_N_HPP
#define PARSER_KEYWORDS_N_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
@@ -66,7 +66,7 @@ namespace ParserKeywords {
static const double defaultValue;
};
class PRESSURE_CONVERGENCE_LIMT {
class PRESSURE_CONVERGENCE_LIMIT {
public:
static const std::string itemName;
static const double defaultValue;
@@ -216,25 +216,6 @@ namespace ParserKeywords {
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();
@@ -333,6 +314,14 @@ namespace ParserKeywords {
class NMESSAGE : public ParserKeyword {
public:
NMESSAGE();
static const std::string keywordName;
};
class NNC : public ParserKeyword {
public:
NNC();
@@ -374,16 +363,16 @@ namespace ParserKeywords {
static const double defaultValue;
};
class SIM_DEPENDENT1 {
class IST1 {
public:
static const std::string itemName;
static const double defaultValue;
static const int defaultValue;
};
class SIM_DEPENDENT2 {
class IST2 {
public:
static const std::string itemName;
static const double defaultValue;
static const int defaultValue;
};
class PRESSURE_TABLE1 {
@@ -484,6 +473,12 @@ namespace ParserKeywords {
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;
@@ -497,7 +492,6 @@ namespace ParserKeywords {
class NETWORK_VALUE_TYPE {
public:
static const std::string itemName;
static const std::string defaultValue;
};
};

756
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/O.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/O.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_O_HPP
#define PARSER_KEYWORDS_O_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
@@ -98,6 +98,26 @@ namespace ParserKeywords {
class OILJT : public ParserKeyword {
public:
OILJT();
static const std::string keywordName;
class PREF {
public:
static const std::string itemName;
static const double defaultValue;
};
class JOULE_THOMSON_COEFFICIENT {
public:
static const std::string itemName;
static const double defaultValue;
};
};
class OILMW : public ParserKeyword {
public:
OILMW();
@@ -223,7 +243,7 @@ namespace ParserKeywords {
OPERATER();
static const std::string keywordName;
class RESULT_ARRAY {
class TARGET_ARRAY {
public:
static const std::string itemName;
};
@@ -1463,6 +1483,738 @@ namespace ParserKeywords {
static const std::string itemName;
static const int defaultValue;
};
class ITEM198 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM199 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM200 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM201 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM202 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM203 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM204 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM205 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM206 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM207 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM208 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM209 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM210 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM211 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM212 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM213 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM214 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM215 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM216 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM217 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM218 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM219 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM220 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM221 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM222 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM223 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM224 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM225 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM226 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM227 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM228 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM229 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM230 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM231 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM232 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM233 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM234 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM235 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM236 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM237 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM238 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM239 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM240 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM241 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM242 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM243 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM244 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM245 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM246 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM247 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM248 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM249 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM250 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM251 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM252 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM253 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM254 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM255 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM256 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM257 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM258 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM259 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM260 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM261 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM262 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM263 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM264 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM265 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM266 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM267 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM268 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM269 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM270 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM271 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM272 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM273 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM274 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM275 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM276 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM277 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM278 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM279 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM280 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM281 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM282 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM283 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM284 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM285 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM286 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM287 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM288 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM289 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM290 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM291 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM292 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM293 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM294 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM295 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM296 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM297 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM298 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM299 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM300 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM301 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM302 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM303 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM304 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM305 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM306 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM307 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM308 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM309 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM310 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM311 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM312 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM313 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM314 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM315 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM316 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM317 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM318 {
public:
static const std::string itemName;
static const int defaultValue;
};
class ITEM319 {
public:
static const std::string itemName;
static const int defaultValue;
};
};

34
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/P.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/P.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_P_HPP
#define PARSER_KEYWORDS_P_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
@@ -417,12 +417,7 @@ namespace ParserKeywords {
PERMFACT();
static const std::string keywordName;
class POROSITY {
public:
static const std::string itemName;
};
class PERMFACTMULT {
class DATA {
public:
static const std::string itemName;
};
@@ -1099,12 +1094,7 @@ namespace ParserKeywords {
PLYSHEAR();
static const std::string keywordName;
class WATER_VELOCITY {
public:
static const std::string itemName;
};
class VRF {
class DATA {
public:
static const std::string itemName;
};
@@ -1873,6 +1863,24 @@ namespace ParserKeywords {
class PVTSOL : public ParserKeyword {
public:
PVTSOL();
static const std::string keywordName;
class ZCO2 {
public:
static const std::string itemName;
};
class DATA {
public:
static const std::string itemName;
};
};
class PVTW : public ParserKeyword {
public:
PVTW();

2
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/Q.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/Q.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_Q_HPP
#define PARSER_KEYWORDS_Q_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {

131
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/R.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/R.hpp vendored
View File

@@ -1,9 +1,86 @@
#ifndef PARSER_KEYWORDS_R_HPP
#define PARSER_KEYWORDS_R_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
class RADFIN : public ParserKeyword {
public:
RADFIN();
static const std::string keywordName;
class NAME {
public:
static const std::string itemName;
};
class I {
public:
static const std::string itemName;
};
class J {
public:
static const std::string itemName;
};
class K1 {
public:
static const std::string itemName;
};
class K2 {
public:
static const std::string itemName;
};
class NR {
public:
static const std::string itemName;
};
class NTHETA {
public:
static const std::string itemName;
};
class NZ {
public:
static const std::string itemName;
};
class NWMAX {
public:
static const std::string itemName;
static const int defaultValue;
};
class INNER_RADIUS {
public:
static const std::string itemName;
static const double defaultValue;
};
class OUTER_RADIUS {
public:
static const std::string itemName;
};
class MINIMUM_RADIUS_REFINEMENT {
public:
static const std::string itemName;
static const double defaultValue;
};
class PARENT_LGR {
public:
static const std::string itemName;
static const std::string defaultValue;
};
};
class RADFIN4 : public ParserKeyword {
public:
RADFIN4();
@@ -395,6 +472,24 @@ namespace ParserKeywords {
class REGION2REGION_PROBE_E300 : public ParserKeyword {
public:
REGION2REGION_PROBE_E300();
static const std::string keywordName;
class REGION1 {
public:
static const std::string itemName;
};
class REGION2 {
public:
static const std::string itemName;
};
};
class REGIONS : public ParserKeyword {
public:
REGIONS();
@@ -826,6 +921,17 @@ namespace ParserKeywords {
static const std::string itemName;
static const std::string defaultValue;
};
class PORTXROP {
public:
static const std::string itemName;
};
class CARKZEXP {
public:
static const std::string itemName;
static const double defaultValue;
};
};
@@ -1499,21 +1605,24 @@ namespace ParserKeywords {
class RVW : public ParserKeyword {
public:
RVW();
static const std::string keywordName;
class data {
public:
static const std::string itemName;
};
};
class RWGSALT : public ParserKeyword {
public:
RWGSALT();
static const std::string keywordName;
class RESERVOIR_PRESSURE {
public:
static const std::string itemName;
};
class SALT_CONCENTRATION {
public:
static const std::string itemName;
};
class DATA {
public:
static const std::string itemName;

449
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/S.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/S.hpp vendored
View File

@@ -1,9 +1,23 @@
#ifndef PARSER_KEYWORDS_S_HPP
#define PARSER_KEYWORDS_S_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
class SALINITY : public ParserKeyword {
public:
SALINITY();
static const std::string keywordName;
class MOLALITY {
public:
static const std::string itemName;
static const double defaultValue;
};
};
class SALT : public ParserKeyword {
public:
SALT();
@@ -30,6 +44,19 @@ namespace ParserKeywords {
class SALTP : public ParserKeyword {
public:
SALTP();
static const std::string keywordName;
class SALT_SATURATION {
public:
static const std::string itemName;
};
};
class SALTPVD : public ParserKeyword {
public:
SALTPVD();
@@ -61,7 +88,7 @@ namespace ParserKeywords {
SALTSOL();
static const std::string keywordName;
class data {
class DATA {
public:
static const std::string itemName;
};
@@ -140,6 +167,32 @@ namespace ParserKeywords {
class SBIOF : public ParserKeyword {
public:
SBIOF();
static const std::string keywordName;
class data {
public:
static const std::string itemName;
};
};
class SCALC : public ParserKeyword {
public:
SCALC();
static const std::string keywordName;
class data {
public:
static const std::string itemName;
};
};
class SCALECRS : public ParserKeyword {
public:
SCALECRS();
@@ -196,43 +249,9 @@ namespace ParserKeywords {
class SCDPTAB : public ParserKeyword {
class SCDPDIMS : public ParserKeyword {
public:
SCDPTAB();
static const std::string keywordName;
class DATA {
public:
static const std::string itemName;
};
};
class SCDPTRAC : public ParserKeyword {
public:
SCDPTRAC();
static const std::string keywordName;
class TRACER {
public:
static const std::string itemName;
};
};
class SCHEDULE : public ParserKeyword {
public:
SCHEDULE();
static const std::string keywordName;
};
class SCPDIMS : public ParserKeyword {
public:
SCPDIMS();
SCDPDIMS();
static const std::string keywordName;
class NTSCDP {
@@ -280,6 +299,40 @@ namespace ParserKeywords {
class SCDPTAB : public ParserKeyword {
public:
SCDPTAB();
static const std::string keywordName;
class DATA {
public:
static const std::string itemName;
};
};
class SCDPTRAC : public ParserKeyword {
public:
SCDPTRAC();
static const std::string keywordName;
class TRACER {
public:
static const std::string itemName;
};
};
class SCHEDULE : public ParserKeyword {
public:
SCHEDULE();
static const std::string keywordName;
};
class SCVD : public ParserKeyword {
public:
SCVD();
@@ -483,6 +536,116 @@ namespace ParserKeywords {
class SGOFLET : public ParserKeyword {
public:
SGOFLET();
static const std::string keywordName;
class SG_0 {
public:
static const std::string itemName;
static const double defaultValue;
};
class SG_CRITICAL {
public:
static const std::string itemName;
static const double defaultValue;
};
class L_GAS {
public:
static const std::string itemName;
static const double defaultValue;
};
class E_GAS {
public:
static const std::string itemName;
static const double defaultValue;
};
class T_GAS {
public:
static const std::string itemName;
static const double defaultValue;
};
class KRT_GAS {
public:
static const std::string itemName;
static const double defaultValue;
};
class SO_0 {
public:
static const std::string itemName;
static const double defaultValue;
};
class SO_CRITICAL {
public:
static const std::string itemName;
static const double defaultValue;
};
class L_OIL {
public:
static const std::string itemName;
static const double defaultValue;
};
class E_OIL {
public:
static const std::string itemName;
static const double defaultValue;
};
class T_OIL {
public:
static const std::string itemName;
static const double defaultValue;
};
class KRT_OIL {
public:
static const std::string itemName;
static const double defaultValue;
};
class L_PC {
public:
static const std::string itemName;
static const double defaultValue;
};
class E_PC {
public:
static const std::string itemName;
static const double defaultValue;
};
class T_PC {
public:
static const std::string itemName;
static const double defaultValue;
};
class PCIR {
public:
static const std::string itemName;
static const double defaultValue;
};
class PCT {
public:
static const std::string itemName;
static const double defaultValue;
};
};
class SGU : public ParserKeyword {
public:
SGU();
@@ -787,6 +950,19 @@ namespace ParserKeywords {
class SMICR : public ParserKeyword {
public:
SMICR();
static const std::string keywordName;
class data {
public:
static const std::string itemName;
};
};
class SMRYDIMS : public ParserKeyword {
public:
SMRYDIMS();
@@ -884,7 +1060,7 @@ namespace ParserKeywords {
SOF32D();
static const std::string keywordName;
class SOIL {
class SWAT {
public:
static const std::string itemName;
};
@@ -894,7 +1070,7 @@ namespace ParserKeywords {
static const std::string itemName;
};
class KRW {
class KRO {
public:
static const std::string itemName;
};
@@ -1061,6 +1237,19 @@ namespace ParserKeywords {
class SOXYG : public ParserKeyword {
public:
SOXYG();
static const std::string keywordName;
class data {
public:
static const std::string itemName;
};
};
class SPECGRID : public ParserKeyword {
public:
SPECGRID();
@@ -1125,6 +1314,14 @@ namespace ParserKeywords {
class SPIDER : public ParserKeyword {
public:
SPIDER();
static const std::string keywordName;
};
class SPOLY : public ParserKeyword {
public:
SPOLY();
@@ -1229,6 +1426,19 @@ namespace ParserKeywords {
class SSWCR : public ParserKeyword {
public:
SSWCR();
static const std::string keywordName;
class data {
public:
static const std::string itemName;
};
};
class SSWL : public ParserKeyword {
public:
SSWL();
@@ -1420,6 +1630,19 @@ namespace ParserKeywords {
class SUREA : public ParserKeyword {
public:
SUREA();
static const std::string keywordName;
class data {
public:
static const std::string itemName;
};
};
class SURF : public ParserKeyword {
public:
SURF();
@@ -1475,6 +1698,19 @@ namespace ParserKeywords {
class SURFCAPD : public ParserKeyword {
public:
SURFCAPD();
static const std::string keywordName;
class DATA {
public:
static const std::string itemName;
};
};
class SURFESAL : public ParserKeyword {
public:
SURFESAL();
@@ -1630,6 +1866,29 @@ namespace ParserKeywords {
class SWF32D : public ParserKeyword {
public:
SWF32D();
static const std::string keywordName;
class SOIL {
public:
static const std::string itemName;
};
class SGAS {
public:
static const std::string itemName;
};
class KRW {
public:
static const std::string itemName;
};
};
class SWFN : public ParserKeyword {
public:
SWFN();
@@ -1810,6 +2069,116 @@ namespace ParserKeywords {
class SWOFLET : public ParserKeyword {
public:
SWOFLET();
static const std::string keywordName;
class SW_RESIDUAL {
public:
static const std::string itemName;
static const double defaultValue;
};
class SW_CRITICAL {
public:
static const std::string itemName;
static const double defaultValue;
};
class L_WATER {
public:
static const std::string itemName;
static const double defaultValue;
};
class E_WATER {
public:
static const std::string itemName;
static const double defaultValue;
};
class T_WATER {
public:
static const std::string itemName;
static const double defaultValue;
};
class KRT_WATER {
public:
static const std::string itemName;
static const double defaultValue;
};
class SO_RESIDUAL {
public:
static const std::string itemName;
static const double defaultValue;
};
class SO_CRITICAL {
public:
static const std::string itemName;
static const double defaultValue;
};
class L_OIL {
public:
static const std::string itemName;
static const double defaultValue;
};
class E_OIL {
public:
static const std::string itemName;
static const double defaultValue;
};
class T_OIL {
public:
static const std::string itemName;
static const double defaultValue;
};
class KRT_OIL {
public:
static const std::string itemName;
static const double defaultValue;
};
class L_PC {
public:
static const std::string itemName;
static const double defaultValue;
};
class E_PC {
public:
static const std::string itemName;
static const double defaultValue;
};
class T_PC {
public:
static const std::string itemName;
static const double defaultValue;
};
class PCIR {
public:
static const std::string itemName;
static const double defaultValue;
};
class PCT {
public:
static const std::string itemName;
static const double defaultValue;
};
};
class SWU : public ParserKeyword {
public:
SWU();

36
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/T.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/T.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_T_HPP
#define PARSER_KEYWORDS_T_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
@@ -46,17 +46,12 @@ namespace ParserKeywords {
};
class MAX_RV_NODES {
public:
static const std::string itemName;
};
class NTENDP {
public:
static const std::string itemName;
static const int defaultValue;
};
class NUM_STATE_EQ {
class NTENDP {
public:
static const std::string itemName;
static const int defaultValue;
@@ -71,6 +66,7 @@ namespace ParserKeywords {
class NUM_EOS_SURFACE {
public:
static const std::string itemName;
static const int defaultValue;
};
class MAX_FLUX_REGIONS {
@@ -362,6 +358,19 @@ namespace ParserKeywords {
TIGHTEN();
static const std::string keywordName;
class FACTOR {
public:
static const std::string itemName;
};
};
class TIGHTENP : public ParserKeyword {
public:
TIGHTENP();
static const std::string keywordName;
class LINEAR_FACTOR {
public:
static const std::string itemName;
@@ -495,6 +504,19 @@ namespace ParserKeywords {
class TPAMEPSS : public ParserKeyword {
public:
TPAMEPSS();
static const std::string keywordName;
class DATA {
public:
static const std::string itemName;
};
};
class TRACER : public ParserKeyword {
public:
TRACER();

2
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/U.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/U.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_U_HPP
#define PARSER_KEYWORDS_U_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {

9
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/V.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/V.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_V_HPP
#define PARSER_KEYWORDS_V_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
@@ -494,6 +494,11 @@ namespace ParserKeywords {
public:
static const std::string itemName;
};
class API_GRAVITY {
public:
static const std::string itemName;
};
};
@@ -573,7 +578,7 @@ namespace ParserKeywords {
static const std::string defaultValue;
};
class ERROR {
class msvc_prefix_ERROR {
public:
static const std::string itemName;
static const std::string defaultValue;

181
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/W.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/W.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_W_HPP
#define PARSER_KEYWORDS_W_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {
@@ -170,6 +170,26 @@ namespace ParserKeywords {
class WATJT : public ParserKeyword {
public:
WATJT();
static const std::string keywordName;
class PREF {
public:
static const std::string itemName;
static const double defaultValue;
};
class JOULE_THOMSON_COEFFICIENT {
public:
static const std::string itemName;
static const double defaultValue;
};
};
class WATVISCT : public ParserKeyword {
public:
WATVISCT();
@@ -325,10 +345,10 @@ namespace ParserKeywords {
static const int defaultValue;
};
class LIFT {
class ALQ {
public:
static const std::string itemName;
static const double defaultValue;
static const UDAValue defaultValue;
};
class THP {
@@ -343,7 +363,13 @@ namespace ParserKeywords {
static const UDAValue defaultValue;
};
class NGLRAT {
class WGASRAT_HIS {
public:
static const std::string itemName;
static const double defaultValue;
};
class NGLRAT_HIS {
public:
static const std::string itemName;
static const double defaultValue;
@@ -680,7 +706,7 @@ namespace ParserKeywords {
class ALQ {
public:
static const std::string itemName;
static const double defaultValue;
static const UDAValue defaultValue;
};
class E300_ITEM13 {
@@ -746,6 +772,11 @@ namespace ParserKeywords {
static const std::string itemName;
};
class GLR_LIMIT {
public:
static const std::string itemName;
};
class WGR_LIMIT {
public:
static const std::string itemName;
@@ -1348,6 +1379,12 @@ namespace ParserKeywords {
static const std::string itemName;
static const int defaultValue;
};
class MAX_GPP_ROWS {
public:
static const std::string itemName;
static const int defaultValue;
};
};
@@ -2505,6 +2542,34 @@ namespace ParserKeywords {
class WMICP : public ParserKeyword {
public:
WMICP();
static const std::string keywordName;
class WELL {
public:
static const std::string itemName;
};
class MICROBIAL_CONCENTRATION {
public:
static const std::string itemName;
};
class OXYGEN_CONCENTRATION {
public:
static const std::string itemName;
};
class UREA_CONCENTRATION {
public:
static const std::string itemName;
};
};
class WNETCTRL : public ParserKeyword {
public:
WNETCTRL();
@@ -2580,13 +2645,13 @@ namespace ParserKeywords {
WPAVE();
static const std::string keywordName;
class WEIGTH_FACTOR1 {
class F1 {
public:
static const std::string itemName;
static const double defaultValue;
};
class WEIGTH_FACTOR2 {
class F2 {
public:
static const std::string itemName;
static const double defaultValue;
@@ -2612,7 +2677,7 @@ namespace ParserKeywords {
WPAVEDEP();
static const std::string keywordName;
class WELLNAME {
class WELL {
public:
static const std::string itemName;
};
@@ -2620,7 +2685,6 @@ namespace ParserKeywords {
class REFDEPTH {
public:
static const std::string itemName;
static const double defaultValue;
};
};
@@ -3113,64 +3177,61 @@ namespace ParserKeywords {
class SEGMENT1 {
public:
static const std::string itemName;
static const int defaultValue;
};
class SEGMENT2 {
public:
static const std::string itemName;
static const int defaultValue;
};
class AICD_STRENGTH {
class STRENGTH {
public:
static const std::string itemName;
};
class LENGTH {
public:
static const std::string itemName;
static const double defaultValue;
};
class ICD_LENGTH {
class DENSITY_CALI {
public:
static const std::string itemName;
static const double defaultValue;
};
class RHO {
class VISCOSITY_CALI {
public:
static const std::string itemName;
static const double defaultValue;
};
class VISCOSITY {
class CRITICAL_VALUE {
public:
static const std::string itemName;
static const double defaultValue;
};
class WATER_LIMIT {
class WIDTH_TRANS {
public:
static const std::string itemName;
static const double defaultValue;
};
class TRANSITION_WIDTH {
class MAX_VISC_RATIO {
public:
static const std::string itemName;
static const double defaultValue;
};
class MAX_SOMETHING {
public:
static const std::string itemName;
static const double defaultValue;
};
class SCALING_METHOD {
class METHOD_SCALING_FACTOR {
public:
static const std::string itemName;
static const int defaultValue;
};
class MAX_QICD {
class MAX_ABS_RATE {
public:
static const std::string itemName;
};
@@ -3185,7 +3246,7 @@ namespace ParserKeywords {
static const std::string itemName;
};
class ICD_FLAG {
class STATUS {
public:
static const std::string itemName;
static const std::string defaultValue;
@@ -3209,7 +3270,7 @@ namespace ParserKeywords {
static const double defaultValue;
};
class OIL_VSIC_FRACTION {
class OIL_VISC_FRACTION {
public:
static const std::string itemName;
static const double defaultValue;
@@ -3903,12 +3964,12 @@ namespace ParserKeywords {
static const std::string itemName;
};
class SEG1 {
class SEGMENT1 {
public:
static const std::string itemName;
};
class SEG2 {
class SEGMENT2 {
public:
static const std::string itemName;
};
@@ -4040,10 +4101,50 @@ namespace ParserKeywords {
static const std::string itemName;
};
class SURFACT {
class SEGMENT1 {
public:
static const std::string itemName;
};
class SEGMENT2 {
public:
static const std::string itemName;
};
class VFP {
public:
static const std::string itemName;
static const int defaultValue;
};
class VFP_COMPONENTS {
public:
static const std::string itemName;
static const std::string defaultValue;
};
class VFP_OUTLIER {
public:
static const std::string itemName;
};
class DP_SCALING {
public:
static const std::string itemName;
static const std::string defaultValue;
};
class ALQ_VALUE {
public:
static const std::string itemName;
static const double defaultValue;
};
class STATUS {
public:
static const std::string itemName;
static const std::string defaultValue;
};
};
@@ -4148,6 +4249,24 @@ namespace ParserKeywords {
class WSURFACT : public ParserKeyword {
public:
WSURFACT();
static const std::string keywordName;
class WELL {
public:
static const std::string itemName;
};
class SURFACT {
public:
static const std::string itemName;
};
};
class WTADD : public ParserKeyword {
public:
WTADD();
@@ -4434,7 +4553,7 @@ namespace ParserKeywords {
static const std::string defaultValue;
};
class WELL_CONNECTION {
class CONNECTION {
public:
static const std::string itemName;
static const std::string defaultValue;

2
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/X.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/X.hpp vendored
View File

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

2
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/Y.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/Y.hpp vendored
View File

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

2
ThirdParty/custom-opm-common/generated-opm-common/include/opm/parser/eclipse/Parser/ParserKeywords/Z.hpp → ThirdParty/custom-opm-common/generated-opm-common/include/opm/input/eclipse/Parser/ParserKeywords/Z.hpp vendored
View File

@@ -1,6 +1,6 @@
#ifndef PARSER_KEYWORDS_Z_HPP
#define PARSER_KEYWORDS_Z_HPP
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/input/eclipse/Parser/ParserKeyword.hpp>
namespace Opm {
namespace ParserKeywords {

1
ThirdParty/custom-opm-common/opm-common vendored Submodule

Submodule ThirdParty/custom-opm-common/opm-common added at 212cc35c43

20
ThirdParty/custom-opm-common/opm-common/.clang-format vendored
View File

@@ -1,20 +0,0 @@
{
BasedOnStyle: WebKit,
AlignAfterOpenBracket: AlwaysBreak,
AlignConsecutiveAssignments: false,
AlignConsecutiveDeclarations: false,
AlignAfterOpenBracket: Align,
AllowShortBlocksOnASingleLine: false,
AllowShortFunctionsOnASingleLine: None,
AlwaysBreakAfterReturnType: TopLevelDefinitions,
AlwaysBreakTemplateDeclarations: Yes,
BinPackArguments: false,
BinPackParameters: false,
BreakBeforeBraces: Linux,
BreakConstructorInitializers: BeforeComma,
ColumnLimit: 120,
Cpp11BracedListStyle: true,
FixNamespaceComments: true,
MaxEmptyLinesToKeep: 5,
NamespaceIndentation: Inner,
}

75
ThirdParty/custom-opm-common/opm-common/.gitignore vendored
View File

@@ -1,75 +0,0 @@
# editor backup files
*~
.\#*
\#*\#
.\#*\#
# compiler output
*.o
*.mod
# libtool compatible files
*.lo
*.la
# Eclipse project settings
.cproject
.project
.settings/*
# QtCreator project settings
CMakeLists.txt.user*
# in-tree build with CMake
CMakeCache.txt
CMakeFiles/
cmake_install.cmake
config.h
opm-core-config.cmake
opm-core-config-version.cmake
opm-core-install.cmake
Makefile
bin/
lib/
Doxyfile
Documentation/html
dune.module
*.pc
install_manifest.txt
# testing framework
CTestTestfile.cmake
DartConfiguration.tcl
Testing/
# Build directory in source.
build/
gmon.out
log.log
build
install
.cproject
.project
/testdata/statoil
.idea
/Debug/
# Compiled Dynamic libraries
*.so
*.dylib
# Compiled Static libraries
*.lai
*.la
*.a
# Mac OS X debug info
*.dSYM
# emacs directory setting:
.dir-locals.el
*.pyc
*.eggs
*.egg-info

0
ThirdParty/custom-opm-common/opm-common/.gitmodules vendored
View File

368
ThirdParty/custom-opm-common/opm-common/CMakeLists.txt vendored
View File

@@ -1,368 +0,0 @@
project(opm-common C CXX)
cmake_minimum_required (VERSION 2.8)
option(SIBLING_SEARCH "Search for other modules in sibling directories?" ON)
list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/Modules)
set(OPM_MACROS_ROOT ${PROJECT_SOURCE_DIR})
option(BUILD_TEST_FRAMEWORK "Create test framework?" ON)
option(ENABLE_ECL_INPUT "Enable eclipse input support?" ON)
option(ENABLE_ECL_OUTPUT "Enable eclipse output support?" ON)
option(ENABLE_MOCKSIM "Build the mock simulator for io testing" ON)
option(OPM_ENABLE_PYTHON "Enable python bindings?" OFF)
option(OPM_INSTALL_PYTHON "Enable python bindings?" OFF)
option(OPM_ENABLE_EMBEDDED_PYTHON "Enable python bindings?" OFF)
# Output implies input
if(ENABLE_ECL_OUTPUT)
set(ENABLE_ECL_INPUT ON)
endif()
# And likewise, no input means no output
if(NOT ENABLE_ECL_INPUT)
set(ENABLE_ECL_OUTPUT OFF)
endif()
# not the same location as most of the other projects; this hook overrides
macro (dir_hook)
endmacro (dir_hook)
# We need to define this variable in the installed cmake config file.
set(OPM_PROJECT_EXTRA_CODE_INSTALLED "#ENABLE_ECL_INPUT is needed by opm-common-prereq.cmake
set(ENABLE_ECL_INPUT ${ENABLE_ECL_INPUT})
set(OPM_MACROS_ROOT ${CMAKE_INSTALL_PREFIX}/share/opm)
list(APPEND CMAKE_MODULE_PATH \${OPM_MACROS_ROOT}/cmake/Modules)
include(OpmPackage) #Make macros availabe after find_package(opm-common)")
set(OPM_PROJECT_EXTRA_CODE_INTREE "#ENABLE_ECL_INPUT is needed by opm-common-prereq.cmake
set(ENABLE_ECL_INPUT ${ENABLE_ECL_INPUT})
set(OPM_MACROS_ROOT ${OPM_MACROS_ROOT})
list(APPEND CMAKE_MODULE_PATH \${OPM_MACROS_ROOT}/cmake/Modules)
include(OpmPackage) #Make macros availabe after find_package(opm-common)")
if(ENABLE_ECL_OUTPUT)
set(OPM_PROJECT_EXTRA_CODE_INSTALLED "${OPM_PROJECT_EXTRA_CODE_INSTALLED}
set(COMPARE_ECL_COMMAND ${CMAKE_INSTALL_PREFIX}/bin${${name}_VER_DIR}/compareECL)
set(OPM_PACK_COMMAND ${CMAKE_INSTALL_PREFIX}/bin${${name}_VER_DIR}/opmpack)")
set(OPM_PROJECT_EXTRA_CODE_INTREE "${OPM_PROJECT_EXTRA_CODE_INTREE}
set(COMPARE_ECL_COMMAND ${PROJECT_BINARY_DIR}/bin/compareECL)
set(OPM_PACK_COMMAND ${PROJECT_BINARY_DIR}/bin/opmpack)")
endif()
# project information is in dune.module. Read this file and set variables.
# we cannot generate dune.module since it is read by dunecontrol before
# the build starts, so it makes sense to keep the data there then.
include (OpmInit)
OpmSetPolicies()
# Look for the opm-tests repository; if found the variable
# HAVE_OPM_TESTS will be set to true.
include(Findopm-tests)
# list of prerequisites for this particular project; this is in a
# separate file (in cmake/Modules sub-directory) because it is shared
# with the find module
include (${project}-prereqs)
# read the list of components from this file (in the project directory);
# it should set various lists with the names of the files to include
include (CMakeLists_files.cmake)
macro (config_hook)
if(ENABLE_ECL_INPUT)
if(NOT cjson_FOUND)
list(APPEND EXTRA_INCLUDES ${PROJECT_SOURCE_DIR}/external/cjson)
endif()
# For this project
include_directories(${EXTRA_INCLUDES} ${PROJECT_BINARY_DIR}/include)
# For downstreams
list(APPEND EXTRA_INCLUDES ${PROJECT_BINARY_DIR}/include)
set(OPM_PROJECT_EXTRA_CODE_INTREE "${OPM_PROJECT_EXTRA_CODE_INTREE}
list(APPEND opm-common_INCLUDE_DIRS ${EXTRA_INCLUDES})")
if(ENABLE_ECL_INPUT)
set(OPM_PROJECT_EXTRA_CODE_INTREE "${OPM_PROJECT_EXTRA_CODE_INTREE}
set(HAVE_ECL_INPUT 1)")
set(OPM_PROJECT_EXTRA_CODE_INSTALLED "${OPM_PROJECT_EXTRA_CODE_INSTALLED}
set(HAVE_ECL_INPUT 1)")
endif()
if(ENABLE_ECL_OUTPUT)
set(OPM_PROJECT_EXTRA_CODE_INTREE "${OPM_PROJECT_EXTRA_CODE_INTREE}
set(HAVE_ECL_OUTPUT 1)")
set(OPM_PROJECT_EXTRA_CODE_INSTALLED "${OPM_PROJECT_EXTRA_CODE_INSTALLED}
set(HAVE_ECL_OUTPUT 1)")
endif()
# Configure boost targets for old cmake
include(cmake/Modules/BoostTargets.cmake)
if (HAVE_DYNAMIC_BOOST_TEST)
set_target_properties(Boost::unit_test_framework PROPERTIES INTERFACE_COMPILE_DEFINITIONS BOOST_TEST_DYN_LINK=1)
endif()
endif()
endmacro (config_hook)
macro (prereqs_hook)
endmacro (prereqs_hook)
macro (sources_hook)
if(ENABLE_ECL_INPUT)
# Keyword generation
include(GenerateKeywords.cmake)
# Append generated sources
list(INSERT opm-common_SOURCES 0 ${PROJECT_BINARY_DIR}/ParserInit.cpp)
foreach (name A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)
list(INSERT opm-common_SOURCES 0 ${PROJECT_BINARY_DIR}/ParserKeywords/${name}.cpp)
endforeach()
endif()
#set_source_files_properties(src/opm/parser/eclipse/Python/Python.cpp
# PROPERTIES COMPILE_FLAGS -Wno-shadow)
endmacro (sources_hook)
macro (fortran_hook)
endmacro (fortran_hook)
macro (files_hook)
endmacro (files_hook)
macro (tests_hook)
if(ENABLE_ECL_INPUT)
include(ExtraTests.cmake)
endif()
endmacro (tests_hook)
macro (install_hook)
install(DIRECTORY ${PROJECT_BINARY_DIR}/include/
DESTINATION include
PATTERN *.hpp)
endmacro (install_hook)
# If opm-common is configured to embed the python interpreter we must make sure
# that all downstream modules link libpython transitively. Due to the required
# integration with Python+cmake machinery provided by pybind11 this is done by
# manually adding to the opm-common_LIBRARIES variable here, and not in the
# OpmnLibMain function. Here only the library dependency is implemented, the
# bulk of the python configuration is further down in the file.
if (OPM_ENABLE_PYTHON)
find_package(PythonInterp REQUIRED)
if (OPM_ENABLE_EMBEDDED_PYTHON)
find_package(PythonLibs REQUIRED)
list(APPEND opm-common_LIBRARIES ${PYTHON_LIBRARY})
endif()
endif()
# all setup common to the OPM library modules is done here
include (OpmLibMain)
if (ENABLE_MOCKSIM)
add_library(mocksim
msim/src/msim.cpp)
target_link_libraries(mocksim opmcommon)
target_include_directories(mocksim PUBLIC msim/include)
add_executable(msim examples/msim.cpp)
target_link_libraries(msim mocksim)
if (Boost_UNIT_TEST_FRAMEWORK_FOUND)
set(_libs mocksim opmcommon
${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
foreach( test test_msim test_msim_ACTIONX test_msim_EXIT)
opm_add_test(${test} SOURCES tests/msim/${test}.cpp
LIBRARIES ${_libs}
WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/tests
CONDITION ${HAVE_ECL_INPUT})
endforeach()
endif()
endif()
# Build the compare utilities
if(ENABLE_ECL_INPUT)
#add_executable(compareECL
# test_util/EclFilesComparator.cpp
# test_util/EclRegressionTest.cpp
# test_util/compareECL.cpp
# )
#add_executable(convertECL
# test_util/convertECL.cpp
# )
#add_executable(summary
# test_util/summary.cpp
# )
#add_executable(test_esmry_lod
# test_util/test_esmry_lod.cpp
# )
#foreach(target compareECL convertECL summary test_esmry_lod)
# target_link_libraries(${target} opmcommon)
# install(TARGETS ${target} DESTINATION bin)
#endforeach()
# Add the tests
set(_libs opmcommon
${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
opm_add_test(test_EclFilesComparator
CONDITION
ENABLE_ECL_INPUT AND Boost_UNIT_TEST_FRAMEWORK_FOUND
SOURCES
tests/test_EclFilesComparator.cpp
test_util/EclFilesComparator.cpp
LIBRARIES
${_libs}
WORKING_DIRECTORY
${PROJECT_BINARY_DIR}/tests
)
opm_add_test(test_EclRegressionTest
CONDITION
ENABLE_ECL_INPUT AND Boost_UNIT_TEST_FRAMEWORK_FOUND
SOURCES
tests/test_EclRegressionTest.cpp
test_util/EclFilesComparator.cpp
test_util/EclRegressionTest.cpp
LIBRARIES
${_libs}
WORKING_DIRECTORY
${PROJECT_BINARY_DIR}/tests
)
foreach(test test_EclIO test_EGrid test_ERft test_ERst test_ESmry)
opm_add_test(${test} CONDITION ENABLE_ECL_INPUT AND Boost_UNIT_TEST_FRAMEWORK_FOUND
LIBRARIES ${_libs}
WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/tests)
endforeach()
endif()
# Install build system files
install(DIRECTORY cmake DESTINATION share/opm)
# Install tab completion skeleton
install(FILES etc/opm_bash_completion.sh.in DESTINATION share/opm/etc)
if (OPM_ENABLE_PYTHON)
# -------------------------------------------------------------------------
# 1: Wrap C++ functionality in Python
if (EXISTS "/etc/debian_version")
set(PYTHON_PACKAGE_PATH "dist-packages")
else()
set(PYTHON_PACKAGE_PATH "site-packages")
endif()
set(PYTHON_INSTALL_PREFIX "lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/${PYTHON_PACKAGE_PATH}" CACHE STRING "Subdirectory to install Python modules in")
make_directory(${PROJECT_BINARY_DIR}/python)
get_target_property(_opmcommon_include_dirs opmcommon INCLUDE_DIRECTORIES)
list(APPEND _opmcommon_include_dirs ${_ecl_include_dirs})
string(REPLACE ";" ":" _setup_include_dirs "${_opmcommon_include_dirs}")
if (CMAKE_PREFIX_PATH)
set(_opmcommon_lib_dirs ${PROJECT_BINARY_DIR}/lib ${CMAKE_PREFIX_PATH}/${CMAKE_INSTALL_LIBDIR})
else()
set(_opmcommon_lib_dirs ${PROJECT_BINARY_DIR}/lib)
endif()
string(REPLACE ";" ":" _setup_lib_dirs "${_opmcommon_lib_dirs}")
if (USE_RUNPATH)
set (_python_rpath_list)
if (CMAKE_PREFIX_PATH)
foreach(path ${CMAKE_PREFIX_PATH})
list(APPEND _python_rpath_list "${path}/${CMAKE_INSTALL_LIBDIR}")
endforeach()
endif()
if (BUILD_SHARED_LIBS)
list(APPEND _python_rpath_list "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
endif()
if (_python_rpath_list)
string(REPLACE ";" ":" _rpath "${_python_rpath_list}")
set( _rpath_arg "--rpath=${_rpath}")
else()
set(_rpath_arg "")
endif()
else()
set( _rpath_arg "")
endif()
execute_process(COMMAND ${PYTHON_EXECUTABLE} target_name.py
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/python
OUTPUT_VARIABLE python_lib_target)
add_custom_target(copy_python ALL
COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/python/install.py ${PROJECT_SOURCE_DIR}/python ${PROJECT_BINARY_DIR} 0)
add_custom_command(OUTPUT python/python/opm/${python_lib_target}
DEPENDS ${PYTHON_CXX_DEPENDS}
DEPENDS copy_python
COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_BINARY_DIR}/python/setup.py
build
build_ext
--build-lib=${PROJECT_BINARY_DIR}/python/python/opm
--library-dirs=${_setup_lib_dirs}
${_rpath_arg}
--include-dirs=${_setup_include_dirs}
WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/python
COMMENT "Building python bindings")
add_custom_target(opmcommon_python ALL DEPENDS python/python/opm/${python_lib_target})
add_dependencies(opmcommon_python opmcommon)
# The install target is based on manually copying the python file tree to the
# installation area with a small installation script 'install.py'. Would have
# preferred to use standard setup.py install, but the setup.py based solution
# refuses to install to a location which the current python executable can not
# load from, and the use of eggs in the setup.py based installation makes
# debugging quite difficult.
#
# Since the installation of Python code is nonstandard it is protected by an
# extra cmake switch, OPM_INSTALL_PYTHON. If you prefer you can still invoke
# setup.py install manually - optionally with the generated script
# setup-install.sh - and completely bypass cmake in the installation phase.
if (OPM_INSTALL_PYTHON)
install( CODE "execute_process(COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_BINARY_DIR}/python/install.py ${PROJECT_BINARY_DIR}/python/python/opm ${DEST_PREFIX}${CMAKE_INSTALL_PREFIX}/${PYTHON_INSTALL_PREFIX} 1)")
endif()
# Observe that if the opmcommon library has been built as a shared library the
# python library opmcommon_python will in general not find it runtime while
# testing.
add_test(NAME python_tests
WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/python
COMMAND ${CMAKE_COMMAND} -E env LD_LIBRARY_PATH=${PROJECT_BINARY_DIR}/lib ${PYTHON_EXECUTABLE} setup.py build_ext --dry-run --build-lib ${PROJECT_BINARY_DIR}/python/python/opm test
)
set_target_properties(opmcommon PROPERTIES POSITION_INDEPENDENT_CODE ON)
set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES ${PROJECT_BINARY_DIR}/python/python)
# -------------------------------------------------------------------------
# Let cmake configure some small shell scripts which can be used to simplify
# building, testing and installation of the Python extensions.
configure_file(python/setup-build.sh.in tmp/setup-build.sh)
file( COPY ${PROJECT_BINARY_DIR}/tmp/setup-build.sh
DESTINATION ${PROJECT_BINARY_DIR}
FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE )
configure_file(python/setup-test.sh.in tmp/setup-test.sh)
file( COPY ${PROJECT_BINARY_DIR}/tmp/setup-test.sh
DESTINATION ${PROJECT_BINARY_DIR}
FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE )
configure_file(python/setup-install.sh.in tmp/setup-install.sh)
file( COPY ${PROJECT_BINARY_DIR}/tmp/setup-install.sh
DESTINATION ${PROJECT_BINARY_DIR}
FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE )
configure_file(python/enable-python.sh.in enable-python.sh)
# -------------------------------------------------------------------------
# 2: Embed the Python interpreter for keywords like PYACTION and PYINPUT
if (OPM_ENABLE_EMBEDDED_PYTHON)
add_subdirectory(python/pybind11)
target_include_directories(opmcommon SYSTEM PRIVATE "python/pybind11/include;${PYTHON_INCLUDE_DIRS}")
target_link_libraries(opmcommon PUBLIC ${PYTHON_LIBRARY})
add_definitions(-DEMBEDDED_PYTHON)
endif()
endif()

815
ThirdParty/custom-opm-common/opm-common/CMakeLists_files.cmake vendored
View File

@@ -1,815 +0,0 @@
# This file sets up five lists:
# MAIN_SOURCE_FILES List of compilation units which will be included in
# the library. If it isn't on this list, it won't be
# part of the library. Please try to keep it sorted to
# maintain sanity.
#
# TEST_SOURCE_FILES List of programs that will be run as unit tests.
#
# TEST_DATA_FILES Files from the source three that should be made
# available in the corresponding location in the build
# tree in order to run tests there.
#
# EXAMPLE_SOURCE_FILES Other programs that will be compiled as part of the
# build, but which is not part of the library nor is
# run as tests.
#
# PUBLIC_HEADER_FILES List of public header files that should be
# distributed together with the library. The source
# files can of course include other files than these;
# you should only add to this list if the *user* of
# the library needs it.
#
# CROSS_COMPILE_FILES List of header files providing substitutes for
# functions exclusively available on Linux build
# systems.
list (APPEND MAIN_SOURCE_FILES
src/opm/common/data/SimulationDataContainer.cpp
src/opm/common/OpmLog/CounterLog.cpp
src/opm/common/OpmLog/EclipsePRTLog.cpp
src/opm/common/OpmLog/LogBackend.cpp
src/opm/common/OpmLog/Logger.cpp
src/opm/common/OpmLog/LogUtil.cpp
src/opm/common/OpmLog/OpmLog.cpp
src/opm/common/OpmLog/StreamLog.cpp
src/opm/common/OpmLog/TimerLog.cpp
src/opm/common/utility/ActiveGridCells.cpp
src/opm/common/utility/FileSystem.cpp
src/opm/common/utility/numeric/MonotCubicInterpolator.cpp
src/opm/common/utility/parameters/Parameter.cpp
src/opm/common/utility/parameters/ParameterGroup.cpp
src/opm/common/utility/parameters/ParameterTools.cpp
src/opm/common/utility/numeric/calculateCellVol.cpp
src/opm/common/utility/TimeService.cpp
)
if(ENABLE_ECL_INPUT)
list(APPEND MAIN_SOURCE_FILES
src/opm/io/eclipse/SummaryNode.cpp
src/opm/json/JsonObject.cpp
src/opm/parser/eclipse/Deck/Deck.cpp
src/opm/parser/eclipse/Deck/DeckItem.cpp
src/opm/parser/eclipse/Deck/DeckValue.cpp
src/opm/parser/eclipse/Deck/DeckKeyword.cpp
src/opm/parser/eclipse/Deck/DeckRecord.cpp
src/opm/parser/eclipse/Deck/DeckOutput.cpp
src/opm/parser/eclipse/Deck/DeckSection.cpp
src/opm/parser/eclipse/Deck/UDAValue.cpp
src/opm/parser/eclipse/Python/Python.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Action/PyAction.cpp
src/opm/parser/eclipse/EclipseState/AquiferConfig.cpp
src/opm/parser/eclipse/EclipseState/AquiferCT.cpp
src/opm/parser/eclipse/EclipseState/Aquifetp.cpp
src/opm/parser/eclipse/EclipseState/Aquancon.cpp
src/opm/parser/eclipse/EclipseState/checkDeck.cpp
src/opm/parser/eclipse/EclipseState/EclipseConfig.cpp
src/opm/parser/eclipse/EclipseState/EclipseState.cpp
src/opm/parser/eclipse/EclipseState/EndpointScaling.cpp
src/opm/parser/eclipse/EclipseState/Edit/EDITNNC.cpp
src/opm/parser/eclipse/EclipseState/Grid/FieldProps.cpp
src/opm/parser/eclipse/EclipseState/Grid/FieldPropsManager.cpp
src/opm/parser/eclipse/EclipseState/Grid/Box.cpp
src/opm/parser/eclipse/EclipseState/Grid/BoxManager.cpp
src/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.cpp
src/opm/parser/eclipse/EclipseState/Grid/FaceDir.cpp
src/opm/parser/eclipse/EclipseState/Grid/FaultCollection.cpp
src/opm/parser/eclipse/EclipseState/Grid/Fault.cpp
src/opm/parser/eclipse/EclipseState/Grid/FaultFace.cpp
src/opm/parser/eclipse/EclipseState/Grid/GridDims.cpp
src/opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.cpp
src/opm/parser/eclipse/EclipseState/Grid/NNC.cpp
src/opm/parser/eclipse/EclipseState/Grid/Operate.cpp
src/opm/parser/eclipse/EclipseState/Grid/PinchMode.cpp
src/opm/parser/eclipse/EclipseState/Grid/SatfuncPropertyInitializers.cpp
src/opm/parser/eclipse/EclipseState/Grid/setKeywordBox.cpp
src/opm/parser/eclipse/EclipseState/Grid/TransMult.cpp
src/opm/parser/eclipse/EclipseState/InitConfig/Equil.cpp
src/opm/parser/eclipse/EclipseState/InitConfig/FoamConfig.cpp
src/opm/parser/eclipse/EclipseState/InitConfig/InitConfig.cpp
src/opm/parser/eclipse/EclipseState/IOConfig/IOConfig.cpp
src/opm/parser/eclipse/EclipseState/IOConfig/RestartConfig.cpp
src/opm/parser/eclipse/EclipseState/Runspec.cpp
src/opm/parser/eclipse/EclipseState/TracerConfig.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionAST.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionContext.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionResult.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Action/Actdims.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Action/Actions.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionParser.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionValue.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Action/ASTNode.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Action/Condition.cpp
src/opm/parser/eclipse/EclipseState/Schedule/ArrayDimChecker.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Events.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Group/Group.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Group/GuideRate.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Group/GuideRateConfig.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Group/GuideRateModel.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Group/GConSale.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Group/GConSump.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Group/GTNode.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/injection.cpp
src/opm/parser/eclipse/EclipseState/Schedule/MessageLimits.cpp
src/opm/parser/eclipse/EclipseState/Schedule/MSW/icd.cpp
src/opm/parser/eclipse/EclipseState/Schedule/MSW/Compsegs.cpp
src/opm/parser/eclipse/EclipseState/Schedule/MSW/Segment.cpp
src/opm/parser/eclipse/EclipseState/Schedule/MSW/WellSegments.cpp
src/opm/parser/eclipse/EclipseState/Schedule/MSW/updatingConnectionsWithSegments.cpp
src/opm/parser/eclipse/EclipseState/Schedule/MSW/SpiralICD.cpp
src/opm/parser/eclipse/EclipseState/Schedule/MSW/Valve.cpp
src/opm/parser/eclipse/EclipseState/Schedule/OilVaporizationProperties.cpp
src/opm/parser/eclipse/EclipseState/Schedule/RFTConfig.cpp
src/opm/parser/eclipse/EclipseState/Schedule/RPTConfig.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp
src/opm/parser/eclipse/EclipseState/Schedule/ScheduleTypes.cpp
src/opm/parser/eclipse/EclipseState/Schedule/SummaryState.cpp
src/opm/parser/eclipse/EclipseState/Schedule/TimeMap.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/Connection.cpp
src/opm/parser/eclipse/EclipseState/Schedule/eval_uda.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/Well.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/WellConnections.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/WList.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/WListManager.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/WellEconProductionLimits.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/WellFoamProperties.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/WellInjectionProperties.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/WellPolymerProperties.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/WellBrineProperties.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/WellTracerProperties.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/WellProductionProperties.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/WellTestConfig.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/WellTestState.cpp
src/opm/parser/eclipse/EclipseState/SimulationConfig/BCConfig.cpp
src/opm/parser/eclipse/EclipseState/SimulationConfig/RockConfig.cpp
src/opm/parser/eclipse/EclipseState/SimulationConfig/SimulationConfig.cpp
src/opm/parser/eclipse/EclipseState/SimulationConfig/ThresholdPressure.cpp
src/opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.cpp
src/opm/parser/eclipse/EclipseState/Tables/ColumnSchema.cpp
src/opm/parser/eclipse/EclipseState/Tables/DenT.cpp
src/opm/parser/eclipse/EclipseState/Tables/JFunc.cpp
src/opm/parser/eclipse/EclipseState/Tables/PvtxTable.cpp
src/opm/parser/eclipse/EclipseState/Tables/SimpleTable.cpp
src/opm/parser/eclipse/EclipseState/Tables/PolyInjTables.cpp
src/opm/parser/eclipse/EclipseState/Tables/StandardCond.cpp
src/opm/parser/eclipse/EclipseState/Tables/TableColumn.cpp
src/opm/parser/eclipse/EclipseState/Tables/TableContainer.cpp
src/opm/parser/eclipse/EclipseState/Tables/TableIndex.cpp
src/opm/parser/eclipse/EclipseState/Tables/TableManager.cpp
src/opm/parser/eclipse/EclipseState/Tables/TableSchema.cpp
src/opm/parser/eclipse/EclipseState/Tables/Tables.cpp
src/opm/parser/eclipse/EclipseState/Tables/Rock2dTable.cpp
src/opm/parser/eclipse/EclipseState/Tables/Rock2dtrTable.cpp
src/opm/parser/eclipse/EclipseState/Tables/PvtwsaltTable.cpp
src/opm/parser/eclipse/EclipseState/Tables/BrineDensityTable.cpp
src/opm/parser/eclipse/EclipseState/Tables/SolventDensityTable.cpp
src/opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQASTNode.cpp
src/opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQParams.cpp
src/opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQParser.cpp
src/opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQSet.cpp
src/opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQActive.cpp
src/opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQAssign.cpp
src/opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQDefine.cpp
src/opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQEnums.cpp
src/opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQConfig.cpp
src/opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQContext.cpp
src/opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQFunction.cpp
src/opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQFunctionTable.cpp
src/opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQInput.cpp
src/opm/parser/eclipse/EclipseState/Schedule/VFPInjTable.cpp
src/opm/parser/eclipse/EclipseState/Schedule/VFPProdTable.cpp
src/opm/parser/eclipse/Parser/ErrorGuard.cpp
src/opm/parser/eclipse/Parser/ParseContext.cpp
src/opm/parser/eclipse/Parser/Parser.cpp
src/opm/parser/eclipse/Parser/ParserEnums.cpp
src/opm/parser/eclipse/Parser/ParserItem.cpp
src/opm/parser/eclipse/Parser/ParserKeyword.cpp
src/opm/parser/eclipse/Parser/ParserRecord.cpp
src/opm/parser/eclipse/Parser/raw/RawKeyword.cpp
src/opm/parser/eclipse/Parser/raw/RawRecord.cpp
src/opm/parser/eclipse/Parser/raw/StarToken.cpp
src/opm/parser/eclipse/Units/Dimension.cpp
src/opm/parser/eclipse/Units/UnitSystem.cpp
src/opm/parser/eclipse/Utility/Functional.cpp
src/opm/parser/eclipse/Utility/Stringview.cpp
)
# This list is only used to register a CMake dependency between the the python
# extension and the corresponding C++ wrapper files. The cpp files actually
# listed here are repeated in the actual definition of the extension in the
# setup.py file.
list( APPEND PYTHON_CXX_SOURCE_FILES
python/cxx/connection.cpp
python/cxx/converters.cpp
python/cxx/deck.cpp
python/cxx/deck_keyword.cpp
python/cxx/eclipse_io.cpp
python/cxx/field_props.cpp
python/cxx/eclipse_config.cpp
python/cxx/eclipse_grid.cpp
python/cxx/eclipse_state.cpp
python/cxx/export.cpp
python/cxx/group.cpp
python/cxx/log.cpp
python/cxx/parsecontext.cpp
python/cxx/parser.cpp
python/cxx/schedule.cpp
python/cxx/summary_state.cpp
python/cxx/table_manager.cpp
python/cxx/unit_system.cpp
python/cxx/well.cpp
)
if (OPM_ENABLE_EMBEDDED_PYTHON)
set_source_files_properties(${PYTHON_CXX_SOURCE_FILES} PROPERTIES COMPILE_FLAGS -Wno-shadow)
set_source_files_properties(src/opm/parser/eclipse/Python/PythonInterp.cpp PROPERTIES COMPILE_FLAGS -Wno-shadow)
set_source_files_properties(src/opm/parser/eclipse/EclipseState/Schedule/Action/PyAction.cpp PROPERTIES COMPILE_FLAGS -Wno-shadow)
list( APPEND MAIN_SOURCE_FILES
src/opm/parser/eclipse/Python/PythonInterp.cpp
src/opm/parser/eclipse/Python/PyRunModule.cpp
${PYTHON_CXX_SOURCE_FILES})
endif()
list( APPEND PYTHON_CXX_DEPENDS ${PYTHON_CXX_SOURCE_FILES}
python/cxx/converters.hpp
python/cxx/export.hpp)
if(NOT cjson_FOUND)
list(APPEND MAIN_SOURCE_FILES external/cjson/cJSON.c)
endif()
endif()
if(ENABLE_ECL_OUTPUT)
list( APPEND MAIN_SOURCE_FILES
src/opm/io/eclipse/EclFile.cpp
src/opm/io/eclipse/EclOutput.cpp
src/opm/io/eclipse/EclUtil.cpp
src/opm/io/eclipse/EGrid.cpp
src/opm/io/eclipse/ERft.cpp
src/opm/io/eclipse/ERst.cpp
src/opm/io/eclipse/ERsm.cpp
src/opm/io/eclipse/ESmry.cpp
src/opm/io/eclipse/ESmry_write_rsm.cpp
src/opm/io/eclipse/OutputStream.cpp
src/opm/io/eclipse/SummaryNode.cpp
src/opm/io/eclipse/rst/connection.cpp
src/opm/io/eclipse/rst/group.cpp
src/opm/io/eclipse/rst/header.cpp
src/opm/io/eclipse/rst/segment.cpp
src/opm/io/eclipse/rst/state.cpp
src/opm/io/eclipse/rst/well.cpp
src/opm/output/eclipse/AggregateActionxData.cpp
src/opm/output/eclipse/AggregateConnectionData.cpp
src/opm/output/eclipse/AggregateGroupData.cpp
src/opm/output/eclipse/AggregateMSWData.cpp
src/opm/output/eclipse/AggregateUDQData.cpp
src/opm/output/eclipse/AggregateWellData.cpp
src/opm/output/eclipse/CreateActionxDims.cpp
src/opm/output/eclipse/CreateDoubHead.cpp
src/opm/output/eclipse/CreateInteHead.cpp
src/opm/output/eclipse/CreateLogiHead.cpp
src/opm/output/eclipse/CreateUdqDims.cpp
src/opm/output/eclipse/DoubHEAD.cpp
src/opm/output/eclipse/EclipseGridInspector.cpp
src/opm/output/eclipse/EclipseIO.cpp
src/opm/output/eclipse/InteHEAD.cpp
src/opm/output/eclipse/LinearisedOutputTable.cpp
src/opm/output/eclipse/LoadRestart.cpp
src/opm/output/eclipse/LogiHEAD.cpp
src/opm/output/eclipse/RestartIO.cpp
src/opm/output/eclipse/Summary.cpp
src/opm/output/eclipse/Tables.cpp
src/opm/output/eclipse/RegionCache.cpp
src/opm/output/eclipse/RestartValue.cpp
src/opm/output/eclipse/WriteInit.cpp
src/opm/output/eclipse/WriteRFT.cpp
src/opm/output/eclipse/WriteRPT.cpp
src/opm/output/eclipse/report/WELSPECS.cpp
src/opm/output/data/Solution.cpp
)
endif()
list (APPEND TEST_SOURCE_FILES
tests/test_ActiveGridCells.cpp
tests/test_calculateCellVol.cpp
tests/test_cmp.cpp
tests/test_cubic.cpp
tests/test_messagelimiter.cpp
tests/test_nonuniformtablelinear.cpp
tests/test_OpmLog.cpp
tests/test_param.cpp
tests/test_RootFinders.cpp
tests/test_SimulationDataContainer.cpp
tests/test_sparsevector.cpp
tests/test_uniformtablelinear.cpp
)
if(ENABLE_ECL_INPUT)
list(APPEND TEST_SOURCE_FILES
tests/rst_test.cpp
tests/test_ERsm.cpp
tests/parser/ACTIONX.cpp
tests/parser/ADDREGTests.cpp
tests/parser/AquiferTests.cpp
tests/parser/BoxTests.cpp
tests/parser/ColumnSchemaTests.cpp
tests/parser/ConnectionTests.cpp
tests/parser/COMPSEGUnits.cpp
tests/parser/CopyRegTests.cpp
tests/parser/DeckValueTests.cpp
tests/parser/DeckTests.cpp
tests/parser/DynamicStateTests.cpp
tests/parser/DynamicVectorTests.cpp
tests/parser/EclipseGridTests.cpp
tests/parser/EmbeddedPython.cpp
tests/parser/EqualRegTests.cpp
tests/parser/EventTests.cpp
tests/parser/FaceDirTests.cpp
tests/parser/FaultTests.cpp
tests/parser/FieldPropsTests.cpp
tests/parser/FoamTests.cpp
tests/parser/FunctionalTests.cpp
tests/parser/GeomodifierTests.cpp
tests/parser/GroupTests.cpp
tests/parser/InitConfigTest.cpp
tests/parser/IOConfigTests.cpp
tests/parser/MessageLimitTests.cpp
tests/parser/MultiRegTests.cpp
tests/parser/MultisegmentWellTests.cpp
tests/parser/MULTREGTScannerTests.cpp
tests/parser/OrderedMapTests.cpp
tests/parser/ParseContextTests.cpp
tests/parser/ParseContext_EXIT1.cpp
tests/parser/ParseDATAWithDefault.cpp
tests/parser/PYACTION.cpp
tests/parser/RawKeywordTests.cpp
tests/parser/test_ReportConfig.cpp
tests/parser/ResinsightTest.cpp
tests/parser/RestartConfigTests.cpp
tests/parser/RFTConfigTests.cpp
tests/parser/RockTableTests.cpp
tests/parser/RunspecTests.cpp
tests/parser/SaltTableTests.cpp
tests/parser/ScheduleRestartTests.cpp
tests/parser/ScheduleTests.cpp
tests/parser/SectionTests.cpp
tests/parser/SimpleTableTests.cpp
tests/parser/SimulationConfigTest.cpp
tests/parser/StarTokenTests.cpp
tests/parser/StringTests.cpp
tests/parser/SummaryConfigTests.cpp
tests/parser/TabdimsTests.cpp
tests/parser/TableColumnTests.cpp
tests/parser/TableContainerTests.cpp
tests/parser/TableManagerTests.cpp
tests/parser/TableSchemaTests.cpp
tests/parser/ThresholdPressureTest.cpp
tests/parser/TimeMapTest.cpp
tests/parser/TracerTests.cpp
tests/parser/TransMultTests.cpp
tests/parser/TuningTests.cpp
tests/parser/UDQTests.cpp
tests/parser/UnitTests.cpp
tests/parser/ValueTests.cpp
tests/parser/WellSolventTests.cpp
tests/parser/WellTracerTests.cpp
tests/parser/WellTests.cpp
tests/parser/WLIST.cpp
tests/parser/WTEST.cpp)
endif()
if(ENABLE_ECL_OUTPUT)
list (APPEND TEST_SOURCE_FILES
tests/test_AggregateActionxData.cpp
tests/test_AggregateWellData.cpp
tests/test_AggregateGroupData.cpp
tests/test_AggregateMSWData.cpp
tests/test_AggregateConnectionData.cpp
tests/test_AggregateUDQData.cpp
tests/test_ArrayDimChecker.cpp
tests/test_EclipseIO.cpp
tests/test_DoubHEAD.cpp
tests/test_InteHEAD.cpp
tests/test_LinearisedOutputTable.cpp
tests/test_LogiHEAD.cpp
tests/test_OutputStream.cpp
tests/test_regionCache.cpp
tests/test_PaddedOutputString.cpp
tests/test_Restart.cpp
tests/test_RFT.cpp
tests/test_rst.cpp
tests/test_Solution.cpp
tests/test_Summary.cpp
tests/test_Summary_Group.cpp
tests/test_Tables.cpp
tests/test_Wells.cpp
tests/test_WindowedArray.cpp
tests/test_restartwellinfo.cpp
)
endif()
list (APPEND TEST_DATA_FILES
tests/testdata.param
)
if(ENABLE_ECL_OUTPUT)
list (APPEND TEST_DATA_FILES
tests/expect-wdims.chldg.err.out
tests/expect-wdims.err.out
tests/BASE_SIM.DATA
tests/BASE_SIM_THPRES.DATA
tests/RESTART_SIM.DATA
tests/summary_deck.DATA
tests/group_group.DATA
tests/testblackoilstate3.DATA
tests/testrft.DATA
tests/table_deck.DATA
tests/summary_deck_non_constant_porosity.DATA
tests/SUMMARY_EFF_FAC.DATA
tests/SPE1CASE1.DATA
tests/SPE1CASE1.SMSPEC
tests/SPE1CASE1A.SMSPEC
tests/SPE9_CP_PACKED.DATA
tests/SOFR_TEST.DATA
tests/UDQ_TEST_WCONPROD_IUAD-2.DATA
tests/UDQ_ACTIONX_TEST1.DATA
tests/UDQ_ACTIONX_TEST1_U.DATA
tests/include_example_pvt.txt
tests/include_example_summary.txt
tests/include_sgof.txt
tests/include_swof.txt
tests/include_grid_3x5x4.grdecl
tests/SPE1CASE2.DATA
tests/SPE1CASE2_RESTART.DATA
tests/SPE1CASE2.X0060
tests/PYACTION.DATA
tests/act1.py
tests/MSW.DATA
tests/EXIT_TEST.DATA
tests/action_syntax_error.py
tests/action_missing_run.py
tests/EMBEDDED_PYTHON.DATA
tests/wclose.py
tests/msim/MSIM_PYACTION.DATA
tests/msim/action1.py
tests/msim/action2.py
)
endif()
list (APPEND EXAMPLE_SOURCE_FILES
)
if(ENABLE_ECL_INPUT)
list (APPEND TEST_DATA_FILES
tests/ECLFILE.INIT
tests/ECLFILE.FINIT
tests/SPE1CASE1.EGRID
tests/SPE1CASE1.RFT
tests/SPE1_TESTCASE.UNRST
tests/SPE1_TESTCASE.FUNRST
tests/SPE1_TESTCASE.F0025
tests/SPE1_TESTCASE.X0025
tests/SPE1CASE1.UNSMRY
tests/SPE1CASE1A.UNSMRY
tests/SPE1CASE1_RST60.SMSPEC
tests/SPE1CASE1_RST60.UNSMRY
tests/MODEL2_RESTART.DATA
tests/restart/MODEL2.UNRST
)
list (APPEND EXAMPLE_SOURCE_FILES
#examples/opmi.cpp
#examples/opmpack.cpp
#examples/opmhash.cpp
)
endif()
# programs listed here will not only be compiled, but also marked for
# installation
list (APPEND PROGRAM_SOURCE_FILES
)
if(ENABLE_ECL_INPUT)
list (APPEND PROGRAM_SOURCE_FILES
examples/opmi.cpp
examples/opmpack.cpp
examples/opmhash.cpp
)
endif()
list( APPEND PUBLIC_HEADER_FILES
opm/common/ErrorMacros.hpp
opm/common/Exceptions.hpp
opm/common/data/SimulationDataContainer.hpp
opm/common/OpmLog/CounterLog.hpp
opm/common/OpmLog/EclipsePRTLog.hpp
opm/common/OpmLog/LogBackend.hpp
opm/common/OpmLog/Logger.hpp
opm/common/OpmLog/LogUtil.hpp
opm/common/OpmLog/MessageFormatter.hpp
opm/common/OpmLog/MessageLimiter.hpp
opm/common/OpmLog/Location.hpp
opm/common/OpmLog/OpmLog.hpp
opm/common/OpmLog/StreamLog.hpp
opm/common/OpmLog/TimerLog.hpp
opm/common/utility/ActiveGridCells.hpp
opm/common/utility/FileSystem.hpp
opm/common/utility/numeric/cmp.hpp
opm/common/utility/platform_dependent/disable_warnings.h
opm/common/utility/platform_dependent/reenable_warnings.h
opm/common/utility/numeric/blas_lapack.h
opm/common/utility/numeric/buildUniformMonotoneTable.hpp
opm/common/utility/numeric/linearInterpolation.hpp
opm/common/utility/numeric/MonotCubicInterpolator.hpp
opm/common/utility/numeric/NonuniformTableLinear.hpp
opm/common/utility/numeric/RootFinders.hpp
opm/common/utility/numeric/SparseVector.hpp
opm/common/utility/numeric/UniformTableLinear.hpp
opm/common/utility/parameters/ParameterGroup.hpp
opm/common/utility/parameters/ParameterGroup_impl.hpp
opm/common/utility/parameters/Parameter.hpp
opm/common/utility/parameters/ParameterMapItem.hpp
opm/common/utility/parameters/ParameterRequirement.hpp
opm/common/utility/parameters/ParameterStrings.hpp
opm/common/utility/parameters/ParameterTools.hpp
opm/common/utility/numeric/calculateCellVol.hpp
opm/common/utility/String.hpp
opm/common/utility/TimeService.hpp
)
if(ENABLE_ECL_INPUT)
list(APPEND PUBLIC_HEADER_FILES
opm/io/eclipse/SummaryNode.hpp
opm/json/JsonObject.hpp
opm/parser/eclipse/Utility/Stringview.hpp
opm/parser/eclipse/Utility/Functional.hpp
opm/parser/eclipse/Utility/Typetools.hpp
opm/parser/eclipse/Generator/KeywordGenerator.hpp
opm/parser/eclipse/Generator/KeywordLoader.hpp
opm/parser/eclipse/Units/UnitSystem.hpp
opm/parser/eclipse/Units/Units.hpp
opm/parser/eclipse/Units/Dimension.hpp
opm/parser/eclipse/Parser/ErrorGuard.hpp
opm/parser/eclipse/Parser/ParserItem.hpp
opm/parser/eclipse/Parser/Parser.hpp
opm/parser/eclipse/Parser/ParserRecord.hpp
opm/parser/eclipse/Parser/ParserKeyword.hpp
opm/parser/eclipse/Parser/InputErrorAction.hpp
opm/parser/eclipse/Parser/ParserEnums.hpp
opm/parser/eclipse/Parser/ParseContext.hpp
opm/parser/eclipse/Parser/ParserConst.hpp
opm/parser/eclipse/EclipseState/InitConfig/InitConfig.hpp
opm/parser/eclipse/EclipseState/InitConfig/Equil.hpp
opm/parser/eclipse/EclipseState/InitConfig/FoamConfig.hpp
opm/parser/eclipse/EclipseState/Util/Value.hpp
opm/parser/eclipse/EclipseState/Util/IOrderSet.hpp
opm/parser/eclipse/EclipseState/Util/OrderedMap.hpp
opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp
opm/parser/eclipse/EclipseState/Edit/EDITNNC.hpp
opm/parser/eclipse/EclipseState/Grid/GridDims.hpp
opm/parser/eclipse/EclipseState/Grid/TransMult.hpp
opm/parser/eclipse/EclipseState/Grid/PinchMode.hpp
opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.hpp
opm/parser/eclipse/EclipseState/Grid/FaultCollection.hpp
opm/parser/eclipse/EclipseState/Grid/SatfuncPropertyInitializers.hpp
opm/parser/eclipse/EclipseState/Grid/Fault.hpp
opm/parser/eclipse/EclipseState/Grid/Box.hpp
opm/parser/eclipse/EclipseState/Grid/FieldPropsManager.hpp
opm/parser/eclipse/EclipseState/Grid/FaultFace.hpp
opm/parser/eclipse/EclipseState/Grid/NNC.hpp
opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp
opm/parser/eclipse/EclipseState/Grid/BoxManager.hpp
opm/parser/eclipse/EclipseState/Grid/FaceDir.hpp
opm/parser/eclipse/EclipseState/Grid/MinpvMode.hpp
opm/parser/eclipse/EclipseState/EndpointScaling.hpp
opm/parser/eclipse/EclipseState/TracerConfig.hpp
opm/parser/eclipse/EclipseState/Tables/DenT.hpp
opm/parser/eclipse/EclipseState/Tables/SimpleTable.hpp
opm/parser/eclipse/EclipseState/Tables/StandardCond.hpp
opm/parser/eclipse/EclipseState/Tables/PolyInjTable.hpp
opm/parser/eclipse/EclipseState/Tables/PdvdTable.hpp
opm/parser/eclipse/EclipseState/Tables/TlpmixpaTable.hpp
opm/parser/eclipse/EclipseState/Tables/PvdgTable.hpp
opm/parser/eclipse/EclipseState/Tables/MsfnTable.hpp
opm/parser/eclipse/EclipseState/Tables/GasvisctTable.hpp
opm/parser/eclipse/EclipseState/Tables/Regdims.hpp
opm/parser/eclipse/EclipseState/Tables/Eqldims.hpp
opm/parser/eclipse/EclipseState/Tables/SpecrockTable.hpp
opm/parser/eclipse/EclipseState/Tables/PvtwsaltTable.hpp
opm/parser/eclipse/EclipseState/Tables/BrineDensityTable.hpp
opm/parser/eclipse/EclipseState/Tables/SolventDensityTable.hpp
opm/parser/eclipse/EclipseState/Tables/SaltvdTable.hpp
opm/parser/eclipse/EclipseState/Tables/PlydhflfTable.hpp
opm/parser/eclipse/EclipseState/Tables/PlymwinjTable.hpp
opm/parser/eclipse/EclipseState/Tables/PlyshlogTable.hpp
opm/parser/eclipse/EclipseState/Tables/RsvdTable.hpp
opm/parser/eclipse/EclipseState/Tables/SkprwatTable.hpp
opm/parser/eclipse/EclipseState/Tables/SkprpolyTable.hpp
opm/parser/eclipse/EclipseState/Tables/SpecheatTable.hpp
opm/parser/eclipse/EclipseState/Tables/SgcwmisTable.hpp
opm/parser/eclipse/EclipseState/Tables/Sof2Table.hpp
opm/parser/eclipse/EclipseState/Tables/TableManager.hpp
opm/parser/eclipse/EclipseState/Tables/SwfnTable.hpp
opm/parser/eclipse/EclipseState/Tables/EnptvdTable.hpp
opm/parser/eclipse/EclipseState/Tables/SwofTable.hpp
opm/parser/eclipse/EclipseState/Tables/FlatTable.hpp
opm/parser/eclipse/EclipseState/Tables/Aqudims.hpp
opm/parser/eclipse/EclipseState/Tables/JFunc.hpp
opm/parser/eclipse/EclipseState/Tables/TableIndex.hpp
opm/parser/eclipse/EclipseState/Tables/PvtgTable.hpp
opm/parser/eclipse/EclipseState/Tables/Tabdims.hpp
opm/parser/eclipse/EclipseState/Tables/TableSchema.hpp
opm/parser/eclipse/EclipseState/Tables/RocktabTable.hpp
opm/parser/eclipse/EclipseState/Tables/EnkrvdTable.hpp
opm/parser/eclipse/EclipseState/Tables/PlyrockTable.hpp
opm/parser/eclipse/EclipseState/Tables/PvtxTable.hpp
opm/parser/eclipse/EclipseState/Tables/WatvisctTable.hpp
opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp
opm/parser/eclipse/EclipseState/Tables/RvvdTable.hpp
opm/parser/eclipse/EclipseState/Tables/TableContainer.hpp
opm/parser/eclipse/EclipseState/Tables/AqutabTable.hpp
opm/parser/eclipse/EclipseState/Tables/PlyadsTable.hpp
opm/parser/eclipse/EclipseState/Tables/FoamadsTable.hpp
opm/parser/eclipse/EclipseState/Tables/FoammobTable.hpp
opm/parser/eclipse/EclipseState/Tables/PbvdTable.hpp
opm/parser/eclipse/EclipseState/Tables/SorwmisTable.hpp
opm/parser/eclipse/EclipseState/Tables/PlymaxTable.hpp
opm/parser/eclipse/EclipseState/Tables/PlyviscTable.hpp
opm/parser/eclipse/EclipseState/Tables/TableColumn.hpp
opm/parser/eclipse/EclipseState/Tables/SsfnTable.hpp
opm/parser/eclipse/EclipseState/Tables/PvdoTable.hpp
opm/parser/eclipse/EclipseState/Tables/OilvisctTable.hpp
opm/parser/eclipse/EclipseState/Tables/SgfnTable.hpp
opm/parser/eclipse/EclipseState/Tables/MiscTable.hpp
opm/parser/eclipse/EclipseState/Tables/SgwfnTable.hpp
opm/parser/eclipse/EclipseState/Tables/PvdsTable.hpp
opm/parser/eclipse/EclipseState/Tables/PvtoTable.hpp
opm/parser/eclipse/EclipseState/Tables/Rock2dTable.hpp
opm/parser/eclipse/EclipseState/Tables/Rock2dtrTable.hpp
opm/parser/eclipse/EclipseState/Tables/RockwnodTable.hpp
opm/parser/eclipse/EclipseState/Tables/OverburdTable.hpp
opm/parser/eclipse/EclipseState/Tables/ColumnSchema.hpp
opm/parser/eclipse/EclipseState/Tables/PmiscTable.hpp
opm/parser/eclipse/EclipseState/Tables/RtempvdTable.hpp
opm/parser/eclipse/EclipseState/Tables/SlgofTable.hpp
opm/parser/eclipse/EclipseState/Tables/ImptvdTable.hpp
opm/parser/eclipse/EclipseState/Tables/ImkrvdTable.hpp
opm/parser/eclipse/EclipseState/Tables/Sof3Table.hpp
opm/parser/eclipse/EclipseState/Tables/SgofTable.hpp
opm/parser/eclipse/EclipseState/Tables/TracerVdTable.hpp
opm/parser/eclipse/EclipseState/EclipseState.hpp
opm/parser/eclipse/EclipseState/EclipseConfig.hpp
opm/parser/eclipse/EclipseState/Aquancon.hpp
opm/parser/eclipse/EclipseState/AquiferConfig.hpp
opm/parser/eclipse/EclipseState/AquiferCT.hpp
opm/parser/eclipse/EclipseState/Aquifetp.hpp
opm/parser/eclipse/EclipseState/Schedule/Action/ActionAST.hpp
opm/parser/eclipse/EclipseState/Schedule/Action/ActionContext.hpp
opm/parser/eclipse/EclipseState/Schedule/Action/ActionResult.hpp
opm/parser/eclipse/EclipseState/Schedule/Action/ActionValue.hpp
opm/parser/eclipse/EclipseState/Schedule/Action/Actdims.hpp
opm/parser/eclipse/EclipseState/Schedule/Action/Actions.hpp
opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.hpp
opm/parser/eclipse/EclipseState/Schedule/Action/Condition.hpp
opm/parser/eclipse/EclipseState/Schedule/Action/ASTNode.hpp
opm/parser/eclipse/EclipseState/Schedule/Action/PyAction.hpp
opm/parser/eclipse/EclipseState/Schedule/ArrayDimChecker.hpp
opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp
opm/parser/eclipse/EclipseState/Schedule/VFPInjTable.hpp
opm/parser/eclipse/EclipseState/Schedule/VFPProdTable.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/Connection.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/ProductionControls.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/InjectionControls.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/WList.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/WListManager.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/WellEconProductionLimits.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/WellFoamProperties.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/WellBrineProperties.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/WellInjectionProperties.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/WellPolymerProperties.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/WellProductionProperties.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/WellTracerProperties.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/WellTestConfig.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/WellTestState.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/WellConnections.hpp
opm/parser/eclipse/EclipseState/Schedule/DynamicVector.hpp
opm/parser/eclipse/EclipseState/Schedule/SummaryState.hpp
opm/parser/eclipse/EclipseState/Schedule/RFTConfig.hpp
opm/parser/eclipse/EclipseState/Schedule/RPTConfig.hpp
opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp
opm/parser/eclipse/EclipseState/Schedule/ScheduleTypes.hpp
opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp
opm/parser/eclipse/EclipseState/Schedule/Group/GTNode.hpp
opm/parser/eclipse/EclipseState/Schedule/Group/Group.hpp
opm/parser/eclipse/EclipseState/Schedule/Group/GuideRate.hpp
opm/parser/eclipse/EclipseState/Schedule/Group/GConSale.hpp
opm/parser/eclipse/EclipseState/Schedule/Group/GConSump.hpp
opm/parser/eclipse/EclipseState/Schedule/Group/GuideRateConfig.hpp
opm/parser/eclipse/EclipseState/Schedule/Group/GuideRateModel.hpp
opm/parser/eclipse/EclipseState/Schedule/MessageLimits.hpp
opm/parser/eclipse/EclipseState/Schedule/Events.hpp
opm/parser/eclipse/EclipseState/Schedule/OilVaporizationProperties.hpp
opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp
opm/parser/eclipse/EclipseState/Schedule/MSW/icd.hpp
opm/parser/eclipse/EclipseState/Schedule/MSW/Segment.hpp
opm/parser/eclipse/EclipseState/Schedule/MSW/Segment.hpp
opm/parser/eclipse/EclipseState/Schedule/MSW/WellSegments.hpp
opm/parser/eclipse/EclipseState/Schedule/MSW/updatingConnectionsWithSegments.hpp
opm/parser/eclipse/EclipseState/Schedule/MSW/SpiralICD.hpp
opm/parser/eclipse/EclipseState/SimulationConfig/ThresholdPressure.hpp
opm/parser/eclipse/EclipseState/SimulationConfig/BCConfig.hpp
opm/parser/eclipse/EclipseState/SimulationConfig/RockConfig.hpp
opm/parser/eclipse/EclipseState/SimulationConfig/SimulationConfig.hpp
opm/parser/eclipse/EclipseState/Schedule/MSW/Valve.hpp
opm/parser/eclipse/EclipseState/IOConfig/RestartConfig.hpp
opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp
opm/parser/eclipse/EclipseState/checkDeck.hpp
opm/parser/eclipse/EclipseState/Runspec.hpp
opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQAssign.hpp
opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQASTNode.hpp
opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQDefine.hpp
opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQContext.hpp
opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQConfig.hpp
opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQEnums.hpp
opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQParams.hpp
opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQInput.hpp
opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQActive.hpp
opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQSet.hpp
opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQFunction.hpp
opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQFunctionTable.hpp
opm/parser/eclipse/Deck/DeckItem.hpp
opm/parser/eclipse/Deck/Deck.hpp
opm/parser/eclipse/Deck/DeckSection.hpp
opm/parser/eclipse/Deck/DeckOutput.hpp
opm/parser/eclipse/Deck/DeckValue.hpp
opm/parser/eclipse/Deck/DeckKeyword.hpp
opm/parser/eclipse/Deck/DeckRecord.hpp
opm/parser/eclipse/Deck/UDAValue.hpp
opm/parser/eclipse/Deck/value_status.hpp
opm/parser/eclipse/Python/Python.hpp)
endif()
if(ENABLE_ECL_OUTPUT)
list(APPEND PUBLIC_HEADER_FILES
opm/io/eclipse/EclFile.hpp
opm/io/eclipse/EclIOdata.hpp
opm/io/eclipse/EclOutput.hpp
opm/io/eclipse/EclUtil.hpp
opm/io/eclipse/EGrid.hpp
opm/io/eclipse/ERft.hpp
opm/io/eclipse/ERst.hpp
opm/io/eclipse/ERsm.hpp
opm/io/eclipse/ESmry.hpp
opm/io/eclipse/PaddedOutputString.hpp
opm/io/eclipse/OutputStream.hpp
opm/io/eclipse/SummaryNode.hpp
opm/io/eclipse/rst/connection.hpp
opm/io/eclipse/rst/group.hpp
opm/io/eclipse/rst/header.hpp
opm/io/eclipse/rst/segment.hpp
opm/io/eclipse/rst/state.hpp
opm/io/eclipse/rst/well.hpp
opm/output/data/Aquifer.hpp
opm/output/data/Cells.hpp
opm/output/data/Solution.hpp
opm/output/data/Wells.hpp
opm/output/data/Groups.hpp
opm/output/eclipse/VectorItems/aquifer.hpp
opm/output/eclipse/VectorItems/connection.hpp
opm/output/eclipse/VectorItems/group.hpp
opm/output/eclipse/VectorItems/intehead.hpp
opm/output/eclipse/VectorItems/logihead.hpp
opm/output/eclipse/VectorItems/msw.hpp
opm/output/eclipse/VectorItems/tabdims.hpp
opm/output/eclipse/VectorItems/well.hpp
opm/output/eclipse/AggregateActionxData.hpp
opm/output/eclipse/AggregateGroupData.hpp
opm/output/eclipse/AggregateConnectionData.hpp
opm/output/eclipse/AggregateMSWData.hpp
opm/output/eclipse/AggregateUDQData.hpp
opm/output/eclipse/AggregateWellData.hpp
opm/output/eclipse/DoubHEAD.hpp
opm/output/eclipse/EclipseGridInspector.hpp
opm/output/eclipse/EclipseIO.hpp
opm/output/eclipse/EclipseIOUtil.hpp
opm/output/eclipse/InteHEAD.hpp
opm/output/eclipse/LinearisedOutputTable.hpp
opm/output/eclipse/LogiHEAD.hpp
opm/output/eclipse/RegionCache.hpp
opm/output/eclipse/RestartIO.hpp
opm/output/eclipse/RestartValue.hpp
opm/output/eclipse/Summary.hpp
opm/output/eclipse/Tables.hpp
opm/output/eclipse/WindowedArray.hpp
opm/output/eclipse/WriteInit.hpp
opm/output/eclipse/WriteRFT.hpp
opm/output/eclipse/WriteRPT.hpp
opm/output/eclipse/WriteRestartHelpers.hpp
opm/output/OutputWriter.hpp
)
endif()
if(ENABLE_ECL_INPUT OR ENABLE_ECL_OUTPUT)
list(APPEND TEST_SOURCE_FILES
tests/test_SummaryNode.cpp
)
endif()
if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
list( APPEND PUBLIC_HEADER_FILES
cross-platform/windows/Substitutes.hpp
)
endif()

24
ThirdParty/custom-opm-common/opm-common/CopyHeaders.cmake vendored
View File

@@ -1,24 +0,0 @@
execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
${BASE_DIR}/tmp_gen/ParserInit.cpp
${BASE_DIR}/ParserInit.cpp)
execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
${BASE_DIR}/tmp_gen/TestKeywords.cpp
${BASE_DIR}/TestKeywords.cpp)
file(GLOB HDRS ${BASE_DIR}/tmp_gen/include/opm/parser/eclipse/Parser/ParserKeywords/*.hpp)
foreach(HDR ${HDRS})
file(RELATIVE_PATH hdr ${BASE_DIR}/tmp_gen/include/opm/parser/eclipse/Parser/ParserKeywords ${HDR})
execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
${HDR}
${BASE_DIR}/include/opm/parser/eclipse/Parser/ParserKeywords/${hdr})
endforeach()
foreach (name A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)
execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
${BASE_DIR}/tmp_gen/ParserKeywords/${name}.cpp
${BASE_DIR}/ParserKeywords/${name}.cpp)
endforeach()

127
ThirdParty/custom-opm-common/opm-common/ExtraTests.cmake vendored
View File

@@ -1,127 +0,0 @@
# Libs to link tests against
set(TEST_LIBS opmcommon Boost::unit_test_framework)
set(EXTRA_TESTS)
if (Boost_UNIT_TEST_FRAMEWORK_FOUND)
# Generated source, needs to be here
opm_add_test(InlineKeywordTest
EXE_NAME TestKeywords
SOURCES ${PROJECT_BINARY_DIR}/TestKeywords.cpp
LIBRARIES ${TEST_LIBS})
list(APPEND EXTRA_TESTS TestKeywords)
# Extra compile definitions and extra parameters
include(cmake/Modules/CheckCaseSensitiveFileSystem.cmake)
set(_testdir ${PROJECT_SOURCE_DIR}/tests/parser/data)
opm_add_test(ParserTests
SOURCES tests/parser/ParserTests.cpp
LIBRARIES ${TEST_LIBS}
TEST_ARGS ${_testdir}/)
list(APPEND EXTRA_TESTS ParserTests)
opm_add_test(ParserIncludeTests
SOURCES tests/parser/ParserIncludeTests.cpp
LIBRARIES ${TEST_LIBS}
TEST_ARGS ${_testdir}/parser/)
target_compile_definitions(ParserIncludeTests PRIVATE
-DHAVE_CASE_SENSITIVE_FILESYSTEM=${HAVE_CASE_SENSITIVE_FILESYSTEM})
list(APPEND EXTRA_TESTS ParserIncludeTests)
opm_add_test(PvtxTableTests
SOURCES tests/parser/PvtxTableTests.cpp
LIBRARIES ${TEST_LIBS}
TEST_ARGS ${_testdir}/integration_tests/)
list(APPEND EXTRA_TESTS PvtxTableTests)
opm_add_test(EclipseStateTests
SOURCES tests/parser/EclipseStateTests.cpp
LIBRARIES ${TEST_LIBS}
TEST_ARGS ${_testdir}/integration_tests/)
list(APPEND EXTRA_TESTS EclipseStateTests)
foreach (test BoxTest
CheckDeckValidity
EclipseGridCreateFromDeck
EDITNNCTests
IncludeTest
IntegrationTests
IOConfigIntegrationTest
NNCTests
ParseKEYWORD
Polymer
ScheduleCreateFromDeck
TransMultIntegrationTests)
opm_add_test(${test}
SOURCES tests/parser/integration/${test}.cpp
LIBRARIES ${TEST_LIBS}
TEST_ARGS ${_testdir}/integration_tests/)
list(APPEND EXTRA_TESTS ${test})
endforeach ()
opm_add_test( rst_spe1
SOURCES tests/rst_test.cpp
LIBRARIES ${TEST_LIBS}
TEST_ARGS tests/SPE1CASE2.DATA tests/SPE1CASE2_RESTART.DATA )
opm_add_test( rst_msw
SOURCES tests/rst_test.cpp
LIBRARIES ${TEST_LIBS}
TEST_ARGS tests/MSW.DATA tests/MSW_RESTART.DATA )
# opm-tests dependent tests
if(HAVE_OPM_TESTS)
opm_add_test(parse_write ONLY_COMPILE
SOURCES tests/parser/integration/parse_write.cpp
LIBRARIES ${TEST_LIBS})
list(APPEND EXTRA_TESTS parse_write)
foreach (deck ${OPM_TESTS_ROOT}/norne/NORNE_ATW2013.DATA
${OPM_TESTS_ROOT}/spe1_solvent/SPE1CASE2_SOLVENT.DATA
${OPM_TESTS_ROOT}/spe9_solvent/SPE9_CP_SOLVENT_CO2.DATA
${OPM_TESTS_ROOT}/spe5/SPE5CASE1.DATA
${OPM_TESTS_ROOT}/polymer_simple2D/2D_THREEPHASE_POLY_HETER.DATA
${OPM_TESTS_ROOT}/spe1/SPE1CASE1.DATA
${OPM_TESTS_ROOT}/spe1/SPE1CASE2.DATA
${OPM_TESTS_ROOT}/spe1/SPE1CASE2_FAMII.DATA
${OPM_TESTS_ROOT}/spe1/SPE1CASE2_SLGOF.DATA
${OPM_TESTS_ROOT}/spe3/SPE3CASE1.DATA
${OPM_TESTS_ROOT}/spe3/SPE3CASE2.DATA
${OPM_TESTS_ROOT}/spe9/SPE9_CP.DATA
${OPM_TESTS_ROOT}/spe9/SPE9_CP_GROUP.DATA
${OPM_TESTS_ROOT}/spe9/SPE9_CP_SHORT.DATA
${OPM_TESTS_ROOT}/spe9/SPE9_CP_SHORT_RESTART.DATA
${OPM_TESTS_ROOT}/spe9/SPE9.DATA
${OPM_TESTS_ROOT}/spe10model1/SPE10_MODEL1.DATA
${OPM_TESTS_ROOT}/spe10model2/SPE10_MODEL2.DATA
${OPM_TESTS_ROOT}/msw_2d_h/2D_H__.DATA
${OPM_TESTS_ROOT}/model2/0_BASE_MODEL2.DATA
${OPM_TESTS_ROOT}/model2/1_MULTREGT_MODEL2.DATA
${OPM_TESTS_ROOT}/model2/2_MULTXYZ_MODEL2.DATA
${OPM_TESTS_ROOT}/model2/3_MULTFLT_MODEL2.DATA
${OPM_TESTS_ROOT}/model2/4_MINPVV_MODEL2.DATA
${OPM_TESTS_ROOT}/model2/5_SWATINIT_MODEL2.DATA
${OPM_TESTS_ROOT}/model2/6_ENDSCALE_MODEL2.DATA
${OPM_TESTS_ROOT}/model2/7_HYSTERESIS_MODEL2.DATA
${OPM_TESTS_ROOT}/model2/8_MULTIPLY_TRANXYZ_MODEL2.DATA
${OPM_TESTS_ROOT}/model2/9_EDITNNC_MODEL2.DATA)
get_filename_component(test_name ${deck} NAME_WE)
opm_add_test(${test_name} NO_COMPILE
EXE_NAME parse_write
TEST_ARGS ${deck})
endforeach()
opm_add_test("SPE9_CP_GROUP2" NO_COMPILE EXE_NAME parse_write TEST_ARGS "${OPM_TESTS_ROOT}/spe9group/SPE9_CP_GROUP.DATA")
set_property(TEST NORNE_ATW2013
PROPERTY ENVIRONMENT "OPM_ERRORS_IGNORE=PARSE_RANDOM_SLASH")
endif()
# JSON tests
opm_add_test(jsonTests
SOURCES tests/json/jsonTests.cpp
LIBRARIES ${TEST_LIBS}
TEST_ARGS ${PROJECT_SOURCE_DIR}/tests/json/example1.json)
list(APPEND EXTRA_TESTS jsonTests)
endif()

119
ThirdParty/custom-opm-common/opm-common/GenerateKeywords.cmake vendored
View File

@@ -1,119 +0,0 @@
set(genkw_SOURCES src/opm/json/JsonObject.cpp
src/opm/parser/eclipse/Parser/createDefaultKeywordList.cpp
src/opm/parser/eclipse/Deck/UDAValue.cpp
src/opm/parser/eclipse/Deck/DeckValue.cpp
src/opm/parser/eclipse/Deck/Deck.cpp
src/opm/parser/eclipse/Deck/DeckItem.cpp
src/opm/parser/eclipse/Deck/DeckKeyword.cpp
src/opm/parser/eclipse/Deck/DeckRecord.cpp
src/opm/parser/eclipse/Deck/DeckOutput.cpp
src/opm/parser/eclipse/Generator/KeywordGenerator.cpp
src/opm/parser/eclipse/Generator/KeywordLoader.cpp
src/opm/parser/eclipse/Parser/ErrorGuard.cpp
src/opm/parser/eclipse/Parser/ParseContext.cpp
src/opm/parser/eclipse/Parser/ParserEnums.cpp
src/opm/parser/eclipse/Parser/ParserItem.cpp
src/opm/parser/eclipse/Parser/ParserKeyword.cpp
src/opm/parser/eclipse/Parser/ParserRecord.cpp
src/opm/parser/eclipse/Parser/raw/RawKeyword.cpp
src/opm/parser/eclipse/Parser/raw/RawRecord.cpp
src/opm/parser/eclipse/Parser/raw/StarToken.cpp
src/opm/parser/eclipse/Units/Dimension.cpp
src/opm/parser/eclipse/Units/UnitSystem.cpp
src/opm/parser/eclipse/Utility/Stringview.cpp
src/opm/common/OpmLog/OpmLog.cpp
src/opm/common/OpmLog/Logger.cpp
src/opm/common/OpmLog/StreamLog.cpp
src/opm/common/OpmLog/LogBackend.cpp
src/opm/common/OpmLog/LogUtil.cpp
)
if(NOT cjson_FOUND)
list(APPEND genkw_SOURCES external/cjson/cJSON.c)
endif()
add_executable(genkw ${genkw_SOURCES})
target_link_libraries(genkw ${opm-common_LIBRARIES})
# Add dependency of Shlwapi.lib for Windows platforms
if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
target_link_libraries(genkw "Shlwapi.lib")
endif()
# Generate keyword list
include(src/opm/parser/eclipse/share/keywords/keyword_list.cmake)
string(REGEX REPLACE "([^;]+)" "${PROJECT_SOURCE_DIR}/src/opm/parser/eclipse/share/keywords/\\1" keyword_files "${keywords}")
configure_file(src/opm/parser/eclipse/keyword_list.argv.in keyword_list.argv)
# Generate keyword source
add_custom_command( OUTPUT
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/A.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/B.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/C.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/D.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/E.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/F.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/G.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/H.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/I.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/J.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/K.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/L.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/M.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/N.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/O.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/P.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/Q.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/R.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/S.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/T.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/U.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/V.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/W.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/X.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/Y.cpp
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/Z.cpp
${PROJECT_BINARY_DIR}/tmp_gen/TestKeywords.cpp
COMMAND genkw keyword_list.argv
${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords
${PROJECT_BINARY_DIR}/tmp_gen/ParserInit.cpp
${PROJECT_BINARY_DIR}/tmp_gen/include/
opm/parser/eclipse/Parser/ParserKeywords
${PROJECT_BINARY_DIR}/tmp_gen/TestKeywords.cpp
DEPENDS genkw ${keyword_files} src/opm/parser/eclipse/share/keywords/keyword_list.cmake
)
# To avoid some rebuilds
add_custom_command(OUTPUT
${PROJECT_BINARY_DIR}/ParserKeywords/A.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/B.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/C.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/D.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/E.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/F.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/G.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/H.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/I.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/J.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/K.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/L.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/M.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/N.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/O.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/P.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/Q.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/R.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/S.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/T.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/U.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/V.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/W.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/X.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/Y.cpp
${PROJECT_BINARY_DIR}/ParserKeywords/Z.cpp
${PROJECT_BINARY_DIR}/TestKeywords.cpp
${PROJECT_BINARY_DIR}/ParserInit.cpp
DEPENDS ${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords/A.cpp
COMMAND ${CMAKE_COMMAND} -DBASE_DIR=${PROJECT_BINARY_DIR}
-P ${PROJECT_SOURCE_DIR}/CopyHeaders.cmake)

675
ThirdParty/custom-opm-common/opm-common/LICENSE vendored
View File

@@ -1,675 +0,0 @@
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
{one line to give the program's name and a brief idea of what it does.}
Copyright (C) {year} {name of author}
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
{project} Copyright (C) {year} {fullname}
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.

3
ThirdParty/custom-opm-common/opm-common/README.md vendored
View File

@@ -1,3 +0,0 @@
# opm-common
Contains common components used throughout all of OPM,
in particular CMake modules for the build system.

63
ThirdParty/custom-opm-common/opm-common/changelog.md vendored
View File

@@ -1,63 +0,0 @@
# Changelog
A short month-by-month synopsis of change highlights. Most bugfixes won't make
it in here, only the bigger features and interface changes.
# Important changes between release 2019.04 and 2019.10
* opm-common and the rest of OPM does not use libecl anymore and
supports reading and writing Eclipse files directly
* Improved Eclipse compatible restart, support for unified and non unified
files, and formatted and unformatted files
* Support for reading and checking various additional keywords was introduced (those
starting with A - M, R, T, V, W, Z).
* ACTIONX support implemented
* NUPCOL support implemented
* UDA, UDQ support implemented
* Implemented writing saturation function scaled end-point arrays (e.g., SWL, SGU,
SOWCR, KRORW, PCG) to INIT file
* Fixes concerning interaction of WELOPEN and WCON* with WECON and
WTEST
* Added support for FOAM keywords (FOAMMOB, FOAMROCK, WFOAM)
* Refactored and reimplemented Well representation in deck
# 2016.12
* ZCORN adjustments improved, considers cell-cell relations
* Slightly more robust compilation - won't crash if locales are broken
* Accessing the PVTW table has a richer interface
* FAULTS face direction accepts X+, I+, Y+, J+, Z+ and K+
* WELOPEN can be controlled with completion numbers (last two parameters)
* COMPLUMP is now supported
* Don't crash on aquifer keywords
* GMWSET and FMWSET are expanded properly
* Don't crash on DEBUG
* Read support for COORDSYS, GRUPRIG, LGR, PRORDER, TRACERS, TUNINGDP,
WDFACCOR, WEFAC, and WORKLIM, no longer crashes.
* RS and RV support.
* Support for DENSITY, PVTW, and ROCK tables
* JFUNC is understood and exposed
# 2016.11
* A new class, Runspec, for the RUNSPEC section, has been introduced
* Nodes in the FIELD group are no longer added to the Summary config
* WCONHIST only adds phases present in the deck
* cJSON can now be installed externally
* DeckItem and ParserItem internals refactored
* Build time reduced by only giving necessary source files to the json compiler
* Support for OPERATE, WSEGITER and GCONPROD
* Internal shared_ptrs removed from Schedule and children; interface updated
* Schedule is now copyable with regular C++ copy semantics - no internal refs
* Well head I/J is now time step dependent
* Well reference depth is time step dependent
* Some ZCORN issues fixed
* gas/oil and oil/gas ratio unit fixed for FIELD units
# 2016.10
* Significant improvements in overall parser performance
* shared_ptr has largely been removed from all public interfaces
* JFUNC keyword can be parsed
* Boolean conversions are explicit
* The Units.hpp header from core is moved here, replacing ConversionFactors
* The ConstPtr and Ptr shared pointer aliases are removed
* UnitSystem, Eclipse3DProperties, and OilVaporizationProperties are default
constructible

102
ThirdParty/custom-opm-common/opm-common/cmake/Modules/AddOptions.cmake vendored
View File

@@ -1,102 +0,0 @@
# - Add options without repeating them on the command line
#
# Synopsis:
#
# add_options (lang build opts)
#
# where:
#
# lang Name of the language whose compiler should receive the
# options, e.g. CXX. If a comma-separated list is received
# then the option is added for all those languages. Use the
# special value ALL_LANGUAGES for these languages: CXX, C
# and Fortran
#
# build Kind of build to which this options should apply,
# such as DEBUG and RELEASE. This can also be a comma-
# separated list. Use the special value ALL_BUILDS to apply
# to all builds.
#
# opts List of options to add. Each should be quoted.
#
# Example:
#
# add_options (CXX RELEASE "-O3" "-DNDEBUG" "-Wall")
function (add_options langs builds)
# special handling of empty language specification
if ("${langs}" STREQUAL "ALL_LANGUAGES")
set (langs CXX C Fortran)
endif ("${langs}" STREQUAL "ALL_LANGUAGES")
foreach (lang IN LISTS langs)
# prepend underscore if necessary
foreach (build IN LISTS builds)
if (NOT ("${build}" STREQUAL "ALL_BUILDS"))
set (_bld "_${build}")
string (TOUPPER "${_bld}" _bld)
else (NOT ("${build}" STREQUAL "ALL_BUILDS"))
set (_bld "")
endif (NOT ("${build}" STREQUAL "ALL_BUILDS"))
# if we want everything in the "global" flag, then simply
# ignore the build type here and go add everything to that one
if (CMAKE_NOT_USING_CONFIG_FLAGS)
set (_bld "")
endif ()
foreach (_opt IN LISTS ARGN)
set (_var "CMAKE_${lang}_FLAGS${_bld}")
#message (STATUS "Adding \"${_opt}\" to \${${_var}}")
# remove it first
string (REPLACE "${_opt}" "" _without "${${_var}}")
string (STRIP "${_without}" _without)
# we need to strip this one as well, so they are comparable
string (STRIP "${${_var}}" _stripped)
# if it wasn't there, then add it at the end
if ("${_without}" STREQUAL "${_stripped}")
# don't add any extra spaces if no options yet are set
if (NOT ${_stripped} STREQUAL "")
set (${_var} "${_stripped} ${_opt}")
else (NOT ${_stripped} STREQUAL "")
set (${_var} "${_opt}")
endif (NOT ${_stripped} STREQUAL "")
set (${_var} "${${_var}}" PARENT_SCOPE)
endif ("${_without}" STREQUAL "${_stripped}")
endforeach (_opt)
endforeach (build)
endforeach (lang)
endfunction (add_options lang build)
# set varname to flag unless user has specified something that matches regex
function (set_default_option lang varname flag regex)
# lang is either C, CXX or Fortran
if ("${lang}" STREQUAL "Fortran")
set (letter "F")
else ()
set (letter "${lang}")
endif ()
string (TOUPPER "${CMAKE_BUILD_TYPE}" _build)
if ((NOT ("$ENV{${letter}FLAGS}" MATCHES "${regex}"))
AND (NOT ("${CMAKE_${lang}_FLAGS}" MATCHES "${regex}"))
AND (NOT ("${CMAKE_${lang}_FLAGS_${_build}}" MATCHES "${regex}")))
set (${varname} ${flag} PARENT_SCOPE)
else ()
set (${varname} PARENT_SCOPE)
endif ()
endfunction (set_default_option)
# clear default options as a proxy for not using any default options
# at all. there is one *huge* problem with this: CMake runs the platform
# initialization before executing any line at all in the project and
# there seems to be no way to disable that behaviour, so we cannot really
# distinguish between a platform default and something that the user has
# passed on the command line. the best thing we can do is to all user-
# defined setting if they are something other than the platform default.
macro (no_default_options)
foreach (lang IN ITEMS C CXX Fortran)
foreach (build IN ITEMS DEBUG RELEASE MINSIZEREL RELWITHDEBINFO)
if ("${CMAKE_${lang}_FLAGS_${build}}" STREQUAL "${CMAKE_${lang}_FLAGS_${build}_INIT}")
# for some strange reason we cannot clear this flag, only set it to empty
set (CMAKE_${lang}_FLAGS_${build} "")
endif ()
endforeach (build)
endforeach (lang)
endmacro (no_default_options)

49
ThirdParty/custom-opm-common/opm-common/cmake/Modules/BoostTargets.cmake vendored
View File

@@ -1,49 +0,0 @@
# make targets for boost if find module did not do the job
if(NOT TARGET Boost::system)
add_library(Boost::system UNKNOWN IMPORTED)
set_target_properties(Boost::system PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
IMPORTED_LOCATION "${Boost_SYSTEM_LIBRARY}"
IMPORTED_LOCATION_DEBUG "${Boost_SYSTEM_LIBRARY_DEBUG}"
IMPORTED_LOCATION_RELEASE "${Boost_SYSTEM_LIBRARY_RELEASE}"
)
endif()
if(NOT TARGET Boost::filesystem)
add_library(Boost::filesystem UNKNOWN IMPORTED)
set_target_properties(Boost::filesystem PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
INTERFACE_COMPILE_DEFINITIONS BOOST_FILESYSTEM_VERSION=3
INTERFACE_LINK_LIBRARIES "${boost_system}"
IMPORTED_LOCATION "${Boost_FILESYSTEM_LIBRARY}"
IMPORTED_LOCATION_DEBUG "${Boost_FILESYSTEM_LIBRARY_DEBUG}"
IMPORTED_LOCATION_RELEASE "${Boost_FILESYSTEM_LIBRARY_RELEASE}"
)
endif()
if(NOT TARGET Boost::regex)
add_library(Boost::regex UNKNOWN IMPORTED)
set_target_properties(Boost::regex PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
INTERFACE_LINK_LIBRARIES "${boost_system}"
IMPORTED_LOCATION "${Boost_REGEX_LIBRARY}"
IMPORTED_LOCATION_DEBUG "${Boost_REGEX_LIBRARY_DEBUG}"
IMPORTED_LOCATION_RELEASE "${Boost_REGEX_LIBRARY_RELEASE}"
)
endif()
if(NOT TARGET Boost::unit_test_framework)
add_library(Boost::unit_test_framework UNKNOWN IMPORTED)
set_target_properties(Boost::unit_test_framework PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
INTERFACE_LINK_LIBRARIES "${boost_system}"
IMPORTED_LOCATION "${Boost_UNIT_TEST_FRAMEWORK_LIBRARY}"
IMPORTED_LOCATION_DEBUG "${Boost_UNIT_TEST_FRAMEWORK_LIBRARY_DEBUG}"
IMPORTED_LOCATION_RELEASE "${Boost_UNIT_TEST_FRAMEWORK_LIBRARY_RELEASE}"
)
endif()

29
ThirdParty/custom-opm-common/opm-common/cmake/Modules/CheckCaseSensitiveFileSystem.cmake vendored
View File

@@ -1,29 +0,0 @@
#
# Module to check whether the file system is case sensitive or not
#
# Sets the following variable:
#
# HAVE_CASE_SENSITIVE_FILESYSTEM True if the file system honors the case of files
message(STATUS "Checking whether the file system is case-sensitive")
# create a file containing uppercase characters
file(WRITE "${CMAKE_BINARY_DIR}/UPPER" "Foo")
# check if the all-lowercase file with the same name can be opened
set(FooContents "")
if (EXISTS "${CMAKE_BINARY_DIR}/upper")
file(READ "${CMAKE_BINARY_DIR}/upper" FooContents)
endif()
# remove the file again in order not to have it dangling around...
file(REMOVE "${CMAKE_BINARY_DIR}/UPPER")
# check the contents of the file opened with lower-case. If it is
# empty, the file system is case sensitive.
if ("${FooContents}" STREQUAL "Foo")
message(STATUS "File system is not case-sensitive")
set(HAVE_CASE_SENSITIVE_FILESYSTEM 0)
else()
message(STATUS "File system is case-sensitive")
set(HAVE_CASE_SENSITIVE_FILESYSTEM 1)
endif()

120
ThirdParty/custom-opm-common/opm-common/cmake/Modules/ConfigVars.cmake vendored
View File

@@ -1,120 +0,0 @@
# - Create config.h based on a list of variables
#
# Synopsis:
# configure_vars (FILE syntax filename verb varlist)
# where
# syntax CXX or CMAKE, depending on target
# filename Full path (including name) of config.h
# verb WRITE or APPEND if truncating or not
# varlist List of variable names that has been defined
#
# In addition, this function will define HAVE_CONFIG_H for the
# following compilations, (only) if the filename is "config.h".
#
# Example:
# list (APPEND FOO_CONFIG_VARS
# "/* bar library */"
# "HAVE_BAR"
# "HAVE_BAR_VERSION_2"
# )
# configure_vars (
# FILE CXX ${PROJECT_BINARY_DIR}/config.h
# WRITE ${FOO_CONFIG_VARS}
# )
# Copyright (C) 2012 Uni Research AS
# This file is licensed under the GNU General Public License v3.0
function (configure_vars obj syntax filename verb)
# this is just to make the syntax look like the build-in commands
if (NOT ("X Y Z ${obj}" STREQUAL "X Y Z FILE" AND
(("${verb}" STREQUAL "WRITE") OR ("${verb}" STREQUAL "APPEND"))))
message (FATAL_ERROR "Syntax error in argument list")
endif ()
if (NOT (("${syntax}" STREQUAL "CXX") OR ("${syntax}" STREQUAL "CMAKE")))
message (FATAL_ERROR "Invalid target syntax \"${syntax}\"")
endif (NOT (("${syntax}" STREQUAL "CXX") OR ("${syntax}" STREQUAL "CMAKE")))
# truncate the file if the verb was "WRITE"
if (verb STREQUAL "WRITE")
file (WRITE "${filename}" "")
endif (verb STREQUAL "WRITE")
# whenever we use this, we also signal to the header files that we
# have "config.h". add this before any other files (known till now)
# to avoid confusion from other configuration files.
get_filename_component (_config_path "${filename}" PATH)
get_filename_component (_config_file "${filename}" NAME)
if ("${_config_file}" MATCHES "config\\.h(\\..+)?")
add_definitions (-DHAVE_CONFIG_H=1)
include_directories (BEFORE "${_config_path}")
endif ("${_config_file}" MATCHES "config\\.h(\\..+)?")
# only write the current value of each variable once
set (_args ${ARGN})
if (_args)
list (REMOVE_DUPLICATES _args)
endif (_args)
# process each variable
set (_prev_verbatim TRUE)
foreach (_var IN LISTS _args)
# massage the name to remove source code formatting
string (REGEX REPLACE "^[\\n\\t\\ ]+" "" _var "${_var}")
string (REGEX REPLACE "[\\n\\t\\ ]+$" "" _var "${_var}")
# if the name of a variable has the syntax of a comments, write it
# verbatim to the file; this can be used to create headings
if ("X Y Z ${_var}" MATCHES "^X Y Z /[/*]")
if (NOT _prev_verbatim)
file (APPEND "${filename}" "\n")
endif (NOT _prev_verbatim)
file (APPEND "${filename}" "${_var}\n")
set (_prev_verbatim TRUE)
else ()
# write a CMake statements that warns if the value has changed
if ("${syntax}" STREQUAL "CMAKE")
set (_db "\${") # to avoid parsing problems
# special case: if we have a truth variable HAVE_ and this is
# either just defined (as is), or set to 1 explicitly, then both
# of these count as "true", so put in a check that also accepts
# both of these values.
if (("${_var}" MATCHES "^HAVE_.*") AND
(("${${_var}}" STREQUAL "") OR ("${${_var}}" STREQUAL "1")))
set (_cond "(\"${_db}${_var}}\" STREQUAL \"\") OR (\"${_db}${_var}}\" STREQUAL \"1\")")
else ()
set (_cond "\"${_db}${_var}}\" STREQUAL \"${${_var}}\"")
endif ()
file (APPEND "${filename}" "if (DEFINED ${_var} AND NOT (${_cond}))\n")
file (APPEND "${filename}" "\tmessage (WARNING \"Incompatible value \\\"${_db}${_var}}\\\" of variable \\\"${_var}\\\"\")\n")
file (APPEND "${filename}" "endif ()\n")
endif ()
# check for empty variable; variables that are explicitly set to false
# is not included in this clause
if ((NOT DEFINED ${_var}) OR ("${${_var}}" STREQUAL ""))
if ("${syntax}" STREQUAL "CMAKE")
file (APPEND "${filename}" "set (${_var})\n")
else ("${syntax}" STREQUAL "CMAKE")
file (APPEND "${filename}" "/* #undef ${_var} */\n")
endif ("${syntax}" STREQUAL "CMAKE")
else ((NOT DEFINED ${_var}) OR ("${${_var}}" STREQUAL ""))
# write to file using the correct syntax
if ("${syntax}" STREQUAL "CMAKE")
# escape backslash and double quote characters
string (REPLACE "\\" "\\\\" _quoted "${${_var}}")
string (REPLACE "\"" "\\\"" _quoted "${_quoted}")
file (APPEND "${filename}" "set (${_var} \"${_quoted}\")\n")
else ("${syntax}" STREQUAL "CMAKE")
file (APPEND "${filename}" "#define ${_var} ${${_var}}\n")
endif ("${syntax}" STREQUAL "CMAKE")
endif ((NOT DEFINED ${_var}) OR ("${${_var}}" STREQUAL ""))
set (_prev_verbatim FALSE)
endif ()
endforeach(_var)
endfunction (configure_vars obj syntax filename verb)

38
ThirdParty/custom-opm-common/opm-common/cmake/Modules/Duplicates.cmake vendored
View File

@@ -1,38 +0,0 @@
# - Remove duplicate library declarations
#
# Synopsis:
#
# remove_duplicate_libraries (module)
#
# where
# module Name of the module whose libraries should be pruned
# Copyright (C) 2013 Uni Research AS
# This file is licensed under the GNU General Public License v3.0
# libraries should always be trimmed from the beginning, so that also
# missing functions in those later in the list will be resolved
macro (remove_duplicate_libraries module)
if (DEFINED ${module}_LIBRARIES)
list (REVERSE ${module}_LIBRARIES)
list (REMOVE_DUPLICATES ${module}_LIBRARIES)
list (REVERSE ${module}_LIBRARIES)
endif (DEFINED ${module}_LIBRARIES)
endmacro (remove_duplicate_libraries module)
# headers can be trimmed from the end, since adding a directory to
# the list is an idempotent action
macro (remove_duplicate_var module suffix)
if (DEFINED ${module}_${suffix})
list (REMOVE_DUPLICATES ${module}_${suffix})
endif (DEFINED ${module}_${suffix})
endmacro (remove_duplicate_var module suffix)
# fix up both headers and libraries, in case two dependencies have
# included the same second-level library independently
macro (remove_dup_deps module)
remove_duplicate_var (${module} INCLUDE_DIRS)
remove_duplicate_var (${module} LINKER_FLAGS)
remove_duplicate_var (${module} CONFIG_VARS)
remove_duplicate_libraries (${module})
endmacro (remove_dup_deps module)

46
ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindAlberta.cmake vendored
View File

@@ -1,46 +0,0 @@
find_library(ALBERTA_LTDL_LIB
NAMES ltdl
PATH_SUFFIXES lib lib32 lib64
)
find_path(ALBERTA_INCLUDE_DIR
NAMES alberta/alberta.h
PATHS ${ALBERTA_ROOT}
PATH_SUFFIXES alberta include NO_DEFAULT_PATH
DOC "Include path of Alberta")
find_path(ALBERTA_INCLUDE_DIR
NAMES
alberta/alberta.h
PATHS /usr/local /opt
PATH_SUFFIXES alberta)
#look for libraries
find_library(ALBERTA_UTIL_LIB
NAMES alberta_util alberta_utilities
PATHS ${ALBERTA_ROOT}
PATH_SUFFIXES lib lib32 lib64
NO_DEFAULT_PATH)
find_library(ALBERTA_UTIL_LIB
NAMES alberta_util alberta_utilities
PATH_SUFFIXES lib lib32 lib64)
foreach(dim RANGE 1 9)
find_library(ALBERTA_${dim}D_LIB alberta_${dim}d
PATHS ${ALBERTA_ROOT}
PATH_SUFFIXES lib lib32 lib64
Cache FILEPATH DOC "Alberta lib for ${dim}D" NO_DEFAULT_PATH)
find_library(ALBERTA_${dim}D_LIB alberta_${dim}d PATH_SUFFIXES lib lib32 lib64)
if(ALBERTA_${dim}D_LIB)
set(ALBERTA_LIBRARIES ${ALBERTA_LIBRARIES} ${ALBERTA_${dim}D_LIB})
endif()
endforeach(dim RANGE 1 9)
if(ALBERTA_LIBRARIES AND ALBERTA_INCLUDE_DIR)
set(ALBERTA_INCLUDE_DIRS ${ALBERTA_INCLUDE_DIR})
set(ALBERTA_LIBRARIES ${ALBERTA_LIBRARIES} ${ALBERTA_UTIL_LIB} ${ALBERTA_LTDL_LIB})
set(ALBERTA_FOUND ON)
set(Alberta_FOUND ON)
set(HAVE_ALBERTA 1)
set(DUNE_ALBERTA_VERSION 0x300)
else()
set(ALBERTA_FOUND OFF)
set(Alberta_FOUND OFF)
endif()

25
ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindC99.cmake vendored
View File

@@ -1,25 +0,0 @@
# - Module that checks for supported C99 features.
# macro to only add option once
include (AddOptions)
# try to use compiler flag -std=c99
set (C_STD99_FLAGS "-std=c99")
# incidently, the C++ test is so simple that it can be used to compile C as well
include (CheckCCompilerFlag)
check_c_compiler_flag (${C_STD99_FLAGS} HAVE_C99)
# add option if we are capable
if (HAVE_C99)
add_options (C ALL_BUILDS "${C_STD99_FLAGS}")
else (HAVE_C99)
set (C_STD99_FLAGS)
endif (HAVE_C99)
# handle quiet and required
include (FindPackageHandleStandardArgs)
find_package_handle_standard_args (C99
DEFAULT_MSG
C_STD99_FLAGS
)

11
ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindClangCheck.cmake vendored
View File

@@ -1,11 +0,0 @@
# Find clang-check.
#
# This module defines:
# CLANGCHECK_PROGRAM, the clang-check executable.
# CLANGHCECK_FOUND, If false, do not try to use cppcheck.
#
find_program(CLANGCHECK_PROGRAM NAMES clang-check clang-check-3.8)
find_package_handle_standard_args(ClangCheck DEFAULT_MSG CLANGCHECK_PROGRAM)
mark_as_advanced(CLANGCHECK_PROGRAM)

11
ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindCppCheck.cmake vendored
View File

@@ -1,11 +0,0 @@
# Find CppCheck.
#
# This module defines:
# CPPCHECK_PROGRAM, the cppcheck executable.
# CPPCHECK_FOUND, If false, do not try to use cppcheck.
#
find_program(CPPCHECK_PROGRAM NAMES cppcheck)
find_package_handle_standard_args(CppCheck DEFAULT_MSG CPPCHECK_PROGRAM)
mark_as_advanced(CPPCHECK_PROGRAM)

49
ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindCwrap.cmake vendored
View File

@@ -1,49 +0,0 @@
# Find the Python wrappers for module cwrap from ert
#
# Set the cache variable CWRAP_PYTHON_PATH to the install location of the root
# ert package.
find_package(PythonInterp)
if(PYTHONINTERP_FOUND)
# We try to find the cwrap Python distribution. This is done by running Python
# code which tries to 'import cwrap' and prints out the path to the module if
# the import succeeds.
#
# The normal Python import machinery is employed, so if you have installed cwrap
# python in a default location, or alternatively set the PYTHONPATH variable the
# cwrap Python distribution will eventually be found there, independently of the
# alternatives which are tested with the ${PATH_LIST} variable.
if (EXISTS "/etc/debian_version")
set( PYTHON_PACKAGE_PATH "dist-packages")
else()
set( PYTHON_PACKAGE_PATH "site-packages")
endif()
set(PYTHON_INSTALL_PREFIX "lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/${PYTHON_PACKAGE_PATH}" CACHE STRING "Subdirectory to install Python modules in")
set(PATH_LIST)
if (ERT_ROOT)
list(APPEND PATH_LIST ${ERT_ROOT})
endif()
list(APPEND PATH_LIST ${CMAKE_PREFIX_PATH})
# Add various popular sibling alternatives.
list(APPEND PATH_LIST "${PROJECT_SOURCE_DIR}/../ert/build"
"${PROJECT_BINARY_DIR}/../ert-build")
foreach( PATH ${PATH_LIST})
set( python_code "import sys; sys.path.insert(0 , '${PATH}/${PYTHON_INSTALL_PREFIX}'); import os.path; import inspect; import cwrap; print os.path.dirname(os.path.dirname(inspect.getfile(cwrap)))")
execute_process( COMMAND ${PYTHON_EXECUTABLE} -c "${python_code}"
RESULT_VARIABLE import_result
OUTPUT_VARIABLE stdout_output
ERROR_VARIABLE stderr_output
OUTPUT_STRIP_TRAILING_WHITESPACE )
if (${import_result} EQUAL 0)
set( CWRAP_PYTHON_PATH ${stdout_output} CACHE PATH "Python path for cwrap" )
break()
endif()
endforeach()
endif()
find_package_handle_standard_args("Cwrap" DEFAULT_MSG CWRAP_PYTHON_PATH)

23
ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindCxaDemangle.cmake vendored
View File

@@ -1,23 +0,0 @@
# Module that checks whether the compiler supports the
# abi::__cxa_demangle function required to
# make the type names returned by typeid() human-readable
#
# Sets the following variable:
# HAVE_CXA_DEMANGLE
#
# perform tests
include(CheckCXXSourceCompiles)
CHECK_CXX_SOURCE_COMPILES("#include <cxxabi.h>
int main(void){
int foobar = 0;
const char *foo = typeid(foobar).name();
int status;
char *demangled = abi::__cxa_demangle( foo, 0, 0, &status );
}" HAVE_CXA_DEMANGLE)
include (FindPackageHandleStandardArgs)
# prevent useless message from being displayed
set (FIND_PACKAGE_MESSAGE_DETAILS_CxaDemangle "[1][v()]"
CACHE INTERNAL "Details about finding CxaDemangle")
find_package_handle_standard_args (CxaDemangle DEFAULT_MSG HAVE_CXA_DEMANGLE)

125
ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindEigen3.cmake vendored
View File

@@ -1,125 +0,0 @@
# - Try to find Eigen3 lib
#
# This module supports requiring a minimum version, e.g. you can do
# find_package(Eigen3 3.1.2)
# to require version 3.1.2 or newer of Eigen3.
#
# Once done this will define
#
# EIGEN3_FOUND - system has eigen lib with correct version
# EIGEN3_INCLUDE_DIR - the eigen include directory
# EIGEN3_VERSION - eigen version
# Copyright (c) 2006, 2007 Montel Laurent, <montel@kde.org>
# Copyright (c) 2008, 2009 Gael Guennebaud, <g.gael@free.fr>
# Copyright (c) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
# Redistribution and use is allowed according to the terms of the 2-clause BSD license.
if(NOT Eigen3_FIND_VERSION)
if(NOT Eigen3_FIND_VERSION_MAJOR)
set(Eigen3_FIND_VERSION_MAJOR 2)
endif(NOT Eigen3_FIND_VERSION_MAJOR)
if(NOT Eigen3_FIND_VERSION_MINOR)
set(Eigen3_FIND_VERSION_MINOR 91)
endif(NOT Eigen3_FIND_VERSION_MINOR)
if(NOT Eigen3_FIND_VERSION_PATCH)
set(Eigen3_FIND_VERSION_PATCH 0)
endif(NOT Eigen3_FIND_VERSION_PATCH)
set(Eigen3_FIND_VERSION "${Eigen3_FIND_VERSION_MAJOR}.${Eigen3_FIND_VERSION_MINOR}.${Eigen3_FIND_VERSION_PATCH}")
endif(NOT Eigen3_FIND_VERSION)
macro(_eigen3_check_version)
file(READ "${EIGEN3_INCLUDE_DIR}/Eigen/src/Core/util/Macros.h" _eigen3_version_header)
string(REGEX MATCH "define[ \t]+EIGEN_WORLD_VERSION[ \t]+([0-9]+)" _eigen3_world_version_match "${_eigen3_version_header}")
set(EIGEN3_WORLD_VERSION "${CMAKE_MATCH_1}")
string(REGEX MATCH "define[ \t]+EIGEN_MAJOR_VERSION[ \t]+([0-9]+)" _eigen3_major_version_match "${_eigen3_version_header}")
set(EIGEN3_MAJOR_VERSION "${CMAKE_MATCH_1}")
string(REGEX MATCH "define[ \t]+EIGEN_MINOR_VERSION[ \t]+([0-9]+)" _eigen3_minor_version_match "${_eigen3_version_header}")
set(EIGEN3_MINOR_VERSION "${CMAKE_MATCH_1}")
set(EIGEN3_VERSION ${EIGEN3_WORLD_VERSION}.${EIGEN3_MAJOR_VERSION}.${EIGEN3_MINOR_VERSION})
if(${EIGEN3_VERSION} VERSION_LESS ${Eigen3_FIND_VERSION})
set(EIGEN3_VERSION_OK FALSE)
else(${EIGEN3_VERSION} VERSION_LESS ${Eigen3_FIND_VERSION})
set(EIGEN3_VERSION_OK TRUE)
endif(${EIGEN3_VERSION} VERSION_LESS ${Eigen3_FIND_VERSION})
if(NOT EIGEN3_VERSION_OK)
message(STATUS "Eigen3 version ${EIGEN3_VERSION} found in ${EIGEN3_INCLUDE_DIR}, "
"but at least version ${Eigen3_FIND_VERSION} is required")
endif(NOT EIGEN3_VERSION_OK)
endmacro(_eigen3_check_version)
# only probe if we haven't a path in our cache
if (NOT EIGEN3_INCLUDE_DIR)
# allow Eigen3_ROOT to be used in addition to EIGEN3_ROOT
if (Eigen3_ROOT)
set (EIGEN3_ROOT "${Eigen3_ROOT}")
endif (Eigen3_ROOT)
# if the _ROOT is specified, then look *only* there; don't allow any
# other version to be swapped in to substitute; if not specified, then
# go search usual locations
if (EIGEN3_ROOT)
# if we are given the path to a "build" tree (meaning somewhere Eigen3
# has been configured), then use the eigen3.pc file to figure out the
# name of the *real* root directory
if (EXISTS "${EIGEN3_ROOT}/CMakeCache.txt")
# get the cache entry that tells use the source tree location
set (_regex "Eigen_SOURCE_DIR:STATIC=\(.*\)")
file (STRINGS
"${EIGEN3_ROOT}/CMakeCache.txt"
EIGEN3_SOURCE_TREE
REGEX "${_regex}"
)
# trim away the key definition, be left with the value
if (EIGEN3_SOURCE_TREE)
string (REGEX REPLACE
"${_regex}"
"\\1"
EIGEN3_SOURCE_TREE
"${EIGEN3_SOURCE_TREE}"
)
# if something doesn't look as expected, abort and search in _ROOT
else ()
set (EIGEN3_SOURCE_TREE "${EIGEN3_ROOT}")
endif ()
else ()
set (EIGEN3_SOURCE_TREE "${EIGEN3_ROOT}")
endif ()
find_path (EIGEN3_INCLUDE_DIR
NAMES signature_of_eigen3_matrix_library
PATHS ${EIGEN3_SOURCE_TREE}
PATH_SUFFIXES eigen3 include/eigen3 eigen include/eigen
NO_DEFAULT_PATH
)
else (EIGEN3_ROOT)
# assume that if there is a sibling directory to our project which
# is called eigen3, there is a newer version located there, or that
# it may have been checked out next to the build directory
find_path(EIGEN3_INCLUDE_DIR
NAMES signature_of_eigen3_matrix_library
HINTS ${CMAKE_SOURCE_DIR}/../
${PROJECT_SOURCE_DIR}/../
${CMAKE_INSTALL_PREFIX}/include
${KDE4_INCLUDE_DIR}
PATH_SUFFIXES eigen3 eigen
)
endif (EIGEN3_ROOT)
endif (NOT EIGEN3_INCLUDE_DIR)
if(EIGEN3_INCLUDE_DIR)
_eigen3_check_version()
endif(EIGEN3_INCLUDE_DIR)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Eigen3 DEFAULT_MSG EIGEN3_INCLUDE_DIR EIGEN3_VERSION_OK)
mark_as_advanced(EIGEN3_INCLUDE_DIR)

49
ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindMETIS.cmake vendored
View File

@@ -1,49 +0,0 @@
# -*-cmake-*-
#
# Try to find the libMETIS graph partioning library
#
# Once done, this will define:
#
# METIS_FOUND - system has the libMETIS graph partioning library
# HAVE_METIS - like METIS_FOUND, but for the inclusion in config.h
# METIS_INCLUDE_DIRS - incude paths to use libMETIS
# METIS_LIBRARIES - Link these to use libMETIS
set(METIS_SEARCH_PATH "/usr" "/usr/local" "/opt" "/opt/local")
set(METIS_NO_DEFAULT_PATH "")
if(METIS_ROOT)
set(METIS_SEARCH_PATH "${METIS_ROOT}")
set(METIS_NO_DEFAULT_PATH "NO_DEFAULT_PATH")
endif()
# search for files which implements this module
find_path (METIS_INCLUDE_DIRS
NAMES "metis.h"
PATHS ${METIS_SEARCH_PATH}
PATH_SUFFIXES "include" "METISLib" "include/metis"
${METIS_NO_DEFAULT_PATH})
# only search in architecture-relevant directory
if (CMAKE_SIZEOF_VOID_P)
math (EXPR _BITS "8 * ${CMAKE_SIZEOF_VOID_P}")
endif (CMAKE_SIZEOF_VOID_P)
find_library(METIS_LIBRARIES
NAMES "metis"
PATHS ${METIS_SEARCH_PATH}
PATH_SUFFIXES "lib/.libs" "lib" "lib${_BITS}" "lib/${CMAKE_LIBRARY_ARCHITECTURE}"
${METIS_NO_DEFAULT_PATH})
set (METIS_FOUND FALSE)
if (METIS_INCLUDE_DIRS OR METIS_LIBRARIES)
set(METIS_FOUND TRUE)
set(HAVE_METIS TRUE)
endif()
# print a message to indicate status of this package
include (FindPackageHandleStandardArgs)
find_package_handle_standard_args(METIS
DEFAULT_MSG
METIS_LIBRARIES
METIS_INCLUDE_DIRS
)

166
ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindPETSc.cmake vendored
View File

@@ -1,166 +0,0 @@
# - Try to find Petsc lib
#
# This module supports requiring a minimum version, e.g. you can do
# find_package(Petsc)
#
# Once done this will define
#
# PETSC_FOUND - system has Petsc lib with correct version
# PETSC_INCLUDE_DIRS - the Petsc include directory
# PETSC_LIBRARIES - the Petsc library.
# Copyright (c) 2006, 2007 Montel Laurent, <montel@kde.org>
# Copyright (c) 2008, 2009 Gael Guennebaud, <g.gael@free.fr>
# Copyright (c) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
# Redistribution and use is allowed according to the terms of the 2-clause BSD license.
# find out the size of a pointer. this is required to only search for
# libraries in the directories relevant for the architecture
if(NOT USE_PETSC)
return()
endif()
if (CMAKE_SIZEOF_VOID_P)
math (EXPR _BITS "8 * ${CMAKE_SIZEOF_VOID_P}")
endif (CMAKE_SIZEOF_VOID_P)
# if PETSC_ROOT is set, then this is the only place searched for petsc headers
# and includes
set(_no_default_path "")
if(PETSC_ROOT)
set (_no_default_path "NO_DEFAULT_PATH")
endif()
# look for a system-wide BLAS library
set(PETSC_BLAS_LIBRARY "")
find_package(BLAS QUIET)
list(APPEND PETSC_BLAS_LIBRARY "${BLAS_LIBRARIES}")
# if BLAS wasn't found, look for it in PETSC_ROOT. Won't search if
# PETSC_BLAS_LIBRARY is set.
find_library(PETSC_BLAS_LIBRARY
NAME "blas"
PATH ${PETSC_ROOT}
PATH_SUFFIXES "lib" "lib${_BITS}" "lib/${CMAKE_LIBRARY_ARCHITECTURE}"
${_no_default_path}
)
# print message if there was still no blas found!
if(NOT BLAS_FOUND AND NOT PETSC_BLAS_LIBRARY)
message(STATUS "BLAS not found but required for PETSc")
return()
endif()
set(PETSC_LAPACK_LIBRARY "")
find_package(LAPACK QUIET)
list(APPEND PETSC_LAPACK_LIBRARY "${LAPACK_LIBRARIES}")
# if LAPACK wasn't found, look for it in PETSC_ROOT
find_library(PETSC_LAPACK_LIBRARY
NAME "lapack"
PATH ${PETSC_ROOT}
PATH_SUFFIXES "lib" "lib${_BITS}" "lib/${CMAKE_LIBRARY_ARCHITECTURE}"
${_no_default_path}
)
# print message if there was still no blas found!
if(NOT LAPACK_FOUND AND NOT PETSC_LAPACK_LIBRARY)
message(STATUS "LAPACK not found but required for PETSc")
return()
endif()
find_package(X11 QUIET)
if (X11_FOUND)
list(APPEND PETSC_X11_LIBRARY "${X11_LIBRARIES}")
endif()
# these variables must exist. Since not finding MPI, both the header and the
# object file , may not be an error, we want the option of concatenating the
# empty variable onto the PETSC_LIBRARIES/INCLUDE_DIRS lists
set(PETSC_MPI_LIBRARY "")
set(PETSC_MPI_INCLUDE_DIRS "")
find_package(MPI)
if(MPI_FOUND)
list(APPEND PETSC_MPI_LIBRARY "${MPI_LIBRARIES}")
set(PETSC_MPI_INCLUDE_DIRS ${MPI_INCLUDE_PATH})
else(MPI_FOUND)
# if a system MPI wasn't found, look for PETSc's serial implementation. This
# won't be available if PETSc was compiled with --with-mpi=0, so not finding
# this won't be an error. This only needs to find the header, as the MPI
# implementation should be already be compiled into PETSc.
message(STATUS "Could not find a system provided MPI. Searching for PETSc provided mpiuni fallback implementation.")
find_path(PETSC_MPI_INCLUDE_DIRS
NAMES "mpi.h"
PATHS ${PETSC_ROOT}/include
PATH_SUFFIXES "mpiuni"
${_no_default_path}
)
endif(MPI_FOUND)
if(NOT PETSC_MPI_INCLUDE_DIRS)
message(WARNING "Could not find any MPI implementation. If PETSc is compiled with --with-mpi=0 this is ok. Otherwise you will get linker errors or (possibly subtle) runtime errors. Continuing.")
if(NOT USE_MPI)
message("To build with MPI support, pass -DUSE_MPI=ON to CMake.")
endif(NOT USE_MPI)
endif(NOT PETSC_MPI_INCLUDE_DIRS)
# only probe if we haven't a path in our cache
if (Petsc_ROOT)
set (PETSC_ROOT "${Petsc_ROOT}")
endif (Petsc_ROOT)
find_package(PkgConfig)
if(PKG_CONFIG_FOUND)
set(OLD_PKG $ENV{PKG_CONFIG_PATH})
set(ENV{PKG_CONFIG_PATH} $ENV{PETSC_DIR}/$ENV{PETSC_ARCH}/lib/pkgconfig)
pkg_check_modules(PETSC PETSc>=3.4.0)
set(ENV{PKG_CONFIG_PATH} ${OLD_PKG})
set(PETSC_LIBRARIES ${PETSC_STATIC_LDFLAGS})
set(PETSC_LIBRARY ${PETSC_LIBRARIES})
set(PETSC_INCLUDE_DIR ${PETSC_INCLUDE_DIRS})
endif()
if(NOT PETSC_FOUND)
find_path (PETSC_NORMAL_INCLUDE_DIR
NAMES "petsc.h"
PATHS ${PETSC_ROOT}
PATH_SUFFIXES "include" "petsc"
${_no_default_path}
)
list(APPEND PETSC_INCLUDE_DIR ${PETSC_NORMAL_INCLUDE_DIR})
# look for actual Petsc library
find_library(PETSC_LIBRARY
NAMES "petsc-3.4.3" "petsc-3.4.4" "petsc"
PATHS ${PETSC_ROOT}
PATH_SUFFIXES "lib" "lib${_BITS}" "lib/${CMAKE_LIBRARY_ARCHITECTURE}"
${_no_default_path}
)
endif()
if(NOT PETSC_LIBRARY)
message(STATUS "Could not find the PETSc library")
return()
endif()
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Petsc DEFAULT_MSG PETSC_INCLUDE_DIR PETSC_LIBRARY)
mark_as_advanced(PETSC_INCLUDE_DIR PETSC_LIBRARY)
# if both headers and library are found, store results
if(PETSC_FOUND)
set(PETSC_INCLUDE_DIRS ${PETSC_INCLUDE_DIR})
list(APPEND PETSC_INCLUDE_DIRS ${PETSC_MPI_INCLUDE_DIRS})
set(PETSC_LIBRARIES ${PETSC_LIBRARY})
list(APPEND PETSC_LIBRARIES ${PETSC_BLAS_LIBRARY})
list(APPEND PETSC_LIBRARIES ${PETSC_LAPACK_LIBRARY})
list(APPEND PETSC_LIBRARIES ${PETSC_X11_LIBRARY})
list(APPEND PETSC_LIBRARIES ${PETSC_MPI_LIBRARY})
endif()

80
ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindPTScotch.cmake vendored
View File

@@ -1,80 +0,0 @@
# Module that checks whether PT-Scotch is available.
#
# Accepts the following variables:
#
# PTSCOTCH_ROOT: Prefix where PT-Scotch is installed.
# PTSCOTCH_SUFFIX: Scotch might be compiled using different
# integer sizes (int32, int32, long). When
# this is is set the headers and libaries
# are search under the suffix
# include/scotch-${PTSCOTCH_SUFFIX, and
# lib/scotch-${PTSCOTCH_SUFFIX}, respectively.
# Sets the following variables:
# PTSCOTCH_INCLUDE_DIRS: All include directories needed to compile PT-Scotch programs.
# PTSCOTCH_LIBRARIES: Alle libraries needed to link PT-Scotch programs.
# PTSCOTCH_FOUND: True if PT-Scotch was found.
#
# Provides the following macros:
#
# find_package(PTScotch)
find_package(MPI)
macro(_search_pt_lib libvar libname doc)
find_library(${libvar} ${libname}
PATHS ${PTSCOTCH_ROOT} ${PTSCOTCH_ROOT}/lib PATH_SUFFIXES ${PATH_SUFFIXES}
NO_DEFAULT_PATH
DOC "${doc}")
find_library(${libvar} ${libname})
endmacro(_search_pt_lib)
if(PTSCOTCH_SUFFIX)
set(PATH_SUFFIXES "scotch-${PTSCOTCH_SUFFIX}")
else(PTSCOTCH_SUFFIX)
set(PATH_SUFFIXES "scotch")
endif(PTSCOTCH_SUFFIX)
include(CMakePushCheckState)
cmake_push_check_state() # Save variables
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${MPI_DUNE_INCLUDE_PATH})
set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${MPI_DUNE_COMPILE_FLAGS}")
find_path(PTSCOTCH_INCLUDE_DIR ptscotch.h
PATHS ${PTSCOTCH_ROOT} ${PTSCOTCH_ROOT}/include
PATH_SUFFIXES ${PATH_SUFFIXES}
NO_DEFAULT_PATH
DOC "Include directory of PT-Scotch")
find_path(PTSCOTCH_INCLUDE_DIR ptscotch.h
PATH_SUFFIXES ${PATH_SUFFIXES})
_search_pt_lib(SCOTCH_LIBRARY scotch "The main Scotch library.")
_search_pt_lib(PTSCOTCH_LIBRARY ptscotch "The main PT-Scotch library.")
_search_pt_lib(PTSCOTCHERR_LIBRARY ptscotcherr "The PT-Scotch error library.")
# behave like a CMake module is supposed to behave
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(
"PTScotch"
DEFAULT_MSG
PTSCOTCH_INCLUDE_DIR
SCOTCH_LIBRARY
PTSCOTCH_LIBRARY
PTSCOTCHERR_LIBRARY
)
#restore old values
cmake_pop_check_state()
if(PTSCOTCH_FOUND)
set(PTSCOTCH_INCLUDE_DIRS ${PTSCOTCH_INCLUDE_DIR})
set(PTSCOTCH_LIBRARIES ${SCOTCH_LIBRARY} ${PTSCOTCH_LIBRARY} ${PTSCOTCHERR_LIBRARY} ${MPI_DUNE_LIBRARIES}
CACHE FILEPATH "All libraries needed to link programs using PT-Scotch")
set(PTSCOCH_LINK_FLAGS "${DUNE_MPI_LINK_FLAGS}"
CACHE STRING "PT-Scotch link flags")
set(HAVE_PTSCOTCH 1)
# log result
file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
"Determing location of PT-Scotch succeded:\n"
"Include directory: ${PTSCOTCH_INCLUDE_DIRS}\n"
"Library directory: ${PTSCOTCH_LIBRARIES}\n\n")
endif(PTSCOTCH_FOUND)
mark_as_advanced(PTSCOTCH_INCLUDE_DIRS PTSCOTCH_LIBRARIES HAVE_PTSCOTCH)

97
ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindParMETIS.cmake vendored
View File

@@ -1,97 +0,0 @@
# Module that checks whether ParMETIS or the ParMETIS interface of PT-Scotch
# is available.
#
# Accepts the following variables:
#
# PARMETIS_ROOT: Prefix where ParMETIS is installed.
# PARMETIS_SUFFIX: Scotch might be compiled using different
# integer sizes (int32, int32, long). When
# this is is set the headers and libaries
# are search under the suffix
# include/parmetis-${PARMETIS_SUFFIX}, and
# lib/parmetis-${PARMETIS_SUFFIX}, respectively.
# Sets the following variables:
# PARMETIS_INCLUDE_DIRS: All include directories needed to compile ParMETIS programs.
# PARMETIS_LIBRARIES: Alle libraries needed to link ParMETIS programs.
# PARMETIS_FOUND: True if ParMETIS was found.
#
# Provides the following macros:
#
# find_package(ParMETIS)
find_package(MPI)
if(MPI_C_FOUND)
macro(_search_parmetis_lib libvar libname doc)
find_library(${libvar} ${libname}
PATHS ${PARMETIS_ROOT} ${PARMETIS_ROOT}/lib PATH_SUFFIXES ${PATH_SUFFIXES}
NO_DEFAULT_PATH
DOC "${doc}")
find_library(${libvar} ${libname})
endmacro(_search_parmetis_lib)
if(PARMETIS_SUFFIX)
set(PATH_SUFFIXES "-${PARMETIS_SUFFIX}")
else(PARMETIS_SUFFIX)
set(PATH_SUFFIXES "")
endif(PARMETIS_SUFFIX)
include(CMakePushCheckState)
cmake_push_check_state() # Save variables
find_path(PARMETIS_INCLUDE_DIR parmetis.h
PATHS ${PARMETIS_ROOT} ${PARMETIS_ROOT}/include
PATH_SUFFIXES parmetis${PATH_SUFFIXES}
NO_DEFAULT_PATH
DOC "Include directory of ParMETIS")
find_path(PARMETIS_INCLUDE_DIR parmetis.h
PATH_SUFFIXES parmetis${PATH_SUFFIXES})
# find the serial version of METIS
find_package(METIS)
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${MPI_C_INCLUDE_PATH} )
if(PARMETIS_INCLUDE_DIR)
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${PARMETIS_INCLUDE_DIR})
if(METIS_INCLUDE_DIRS)
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${METIS_INCLUDE_DIRS})
endif()
endif()
set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${MPI_C_COMPILE_FLAGS}")
include(CheckIncludeFile)
check_include_file(parmetis.h PARMETIS_FOUND)
_search_parmetis_lib(PARMETIS_LIBRARY parmetis "The main ParMETIS library.")
# behave like a CMake module is supposed to behave
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(
"ParMETIS"
DEFAULT_MSG
PARMETIS_INCLUDE_DIR
PARMETIS_LIBRARY
METIS_LIBRARIES
PARMETIS_FOUND
METIS_FOUND
)
#restore old values
cmake_pop_check_state()
if(PARMETIS_FOUND)
set(PARMETIS_INCLUDE_DIRS ${PARMETIS_INCLUDE_DIR})
set(PARMETIS_LIBRARIES ${PARMETIS_LIBRARY} ${METIS_LIBRARIES} ${MPI_C_LIBRARIES}
CACHE FILEPATH "All libraries needed to link programs using ParMETIS")
set(PARMETIS_LINK_FLAGS "${DUNE_C_LINK_FLAGS}"
CACHE STRING "ParMETIS link flags")
set(HAVE_PARMETIS 1)
# log result
file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
"Determining location of ParMETIS succeded:\n"
"Include directory: ${PARMETIS_INCLUDE_DIRS}\n"
"Library directory: ${PARMETIS_LIBRARIES}\n\n")
endif(PARMETIS_FOUND)
mark_as_advanced(PARMETIS_INCLUDE_DIRS PARMETIS_LIBRARIES HAVE_PARMETIS)
else(MPI_C_FOUND)
message(WARNING "MPI not found ==> ParMETIS disabled! Plase make sure -DUSE_MPI=ON was set if you need ParMETIS.")
endif(MPI_C_FOUND)

49
ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindQuadmath.cmake vendored
View File

@@ -1,49 +0,0 @@
# Module that checks whether the compiler supports the
# quadruple precision floating point math
#
# Sets the following variables:
# HAVE_QUAD
# QUADMATH_LIBRARIES
#
# perform tests
include(CheckCSourceCompiles)
include(CheckCXXSourceCompiles)
include(CMakePushCheckState)
include(CheckCXXCompilerFlag)
if(NOT DEFINED USE_QUADMATH OR USE_QUADMATH)
if(NOT DEFINED HAVE_EXTENDED_NUMERIC_LITERALS)
check_cxx_compiler_flag("-Werror -fext-numeric-literals" HAVE_EXTENDED_NUMERIC_LITERALS)
endif()
if (HAVE_EXTENDED_NUMERIC_LITERALS)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fext-numeric-literals")
endif()
cmake_push_check_state(RESET)
list(APPEND CMAKE_REQUIRED_LIBRARIES "quadmath")
CHECK_CXX_SOURCE_COMPILES("
#include <quadmath.h>
int main(void){
__float128 foo = sqrtq(123.456);
foo = FLT128_MIN;
}" QUADMATH_FOUND)
cmake_pop_check_state()
if (QUADMATH_FOUND)
set(QUADMATH_LIBRARIES "quadmath")
set(HAVE_QUAD "${QUADMATH_FOUND}")
endif()
endif()
if (USE_QUADMATH AND NOT QUADMATH_FOUND)
message(FATAL_ERROR "Quadruple precision math support was explicitly requested but is unavailable!")
endif()
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Quadmath
DEFAULT_MSG
QUADMATH_LIBRARIES
HAVE_QUAD
)

Some files were not shown because too many files have changed in this diff Show More