Merge pull request #6993 from OPM/msj-opm-common

VFP table support using opm-common

ApplicationCode/CMakeLists.txt

@@ -443,7 +443,12 @@ set(UNITY_EXCLUDE_FILES
     # forever is used as variable name, and this symbol is defined by Qt and
     # used in precompiled headers
     ${ResInsight_SOURCE_DIR}/ThirdParty/gtest/gtest-all.cc
-    qrc_cafAnimControl.cpp qrc_ResInsight.cpp qrc_cafCommandFeatures.cpp)
+    qrc_cafAnimControl.cpp
+    qrc_ResInsight.cpp
+    qrc_cafCommandFeatures.cpp
+    # Exclude files including opm-common
+    ProjectDataModel/RimVfpTableExtractor.cpp
+    ProjectDataModel/RimVfpPlot.cpp)
 
 if(RESINSIGHT_ENABLE_UNITY_BUILD)
   foreach(fileToExclude ${UNITY_EXCLUDE_FILES})

ApplicationCode/Commands/CMakeLists.txt

@@ -55,8 +55,10 @@ add_library(
   ${COMMAND_MOC_SOURCE_FILES})
 
 target_include_directories(
-  ${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}
-                         ${CMAKE_SOURCE_DIR}/ThirdParty)
+  ${PROJECT_NAME}
+  PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/ThirdParty
+         ${CMAKE_SOURCE_DIR}/ThirdParty/custom-opm-common/generated-opm-common
+         ${CMAKE_SOURCE_DIR}/ThirdParty/custom-opm-common/opm-common)
 
 # Before cmake 3.12 OBJECT libraries could not use the target_link_libraries
 # command, So we need to set the POSITION_INDEPENDENT_CODE option  manually

ApplicationCode/Commands/CMakeLists_files.cmake

@@ -92,6 +92,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RicExportStimPlanModelToFileFeature.h
 ${CMAKE_CURRENT_LIST_DIR}/RicStackSelectedCurvesFeature.h
 ${CMAKE_CURRENT_LIST_DIR}/RicUnstackSelectedCurvesFeature.h
 ${CMAKE_CURRENT_LIST_DIR}/RicThemeColorEditorFeature.h
+${CMAKE_CURRENT_LIST_DIR}/RicNewVfpPlotFeature.h
 )
 
 
@@ -188,6 +189,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RicExportStimPlanModelToFileFeature.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicStackSelectedCurvesFeature.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicUnstackSelectedCurvesFeature.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicThemeColorEditorFeature.cpp
+${CMAKE_CURRENT_LIST_DIR}/RicNewVfpPlotFeature.cpp
 )
 
 

ApplicationCode/Commands/RicNewVfpPlotFeature.cpp

@@ -0,0 +1,79 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2020  Equinor ASA
+//
+//  ResInsight 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.
+//
+//  ResInsight 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 at <http://www.gnu.org/licenses/gpl.html>
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RicNewVfpPlotFeature.h"
+
+#include "RiaApplication.h"
+
+#include "RimMainPlotCollection.h"
+#include "RimProject.h"
+#include "RimSimWellInView.h"
+#include "RimVfpPlot.h"
+#include "RimVfpPlotCollection.h"
+#include "RimWellLogPlot.h"
+#include "RimWellLogTrack.h"
+#include "RimWellPath.h"
+
+#include "RiuPlotMainWindowTools.h"
+
+#include "cafSelectionManagerTools.h"
+
+#include <QAction>
+
+#include <vector>
+
+CAF_CMD_SOURCE_INIT( RicNewVfpPlotFeature, "RicNewVfpPlotFeature" );
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RicNewVfpPlotFeature::isCommandEnabled()
+{
+    RimVfpPlotCollection* plotColl = caf::firstAncestorOfTypeFromSelectedObject<RimVfpPlotCollection*>();
+    return ( plotColl != nullptr );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RicNewVfpPlotFeature::onActionTriggered( bool isChecked )
+{
+    RimProject* proj = RiaApplication::instance()->project();
+
+    RimVfpPlotCollection* vfpPlotColl = proj->mainPlotCollection()->vfpPlotCollection();
+    if ( vfpPlotColl )
+    {
+        RimVfpPlot* vfpPlot = new RimVfpPlot();
+        vfpPlotColl->addPlot( vfpPlot );
+        vfpPlotColl->updateConnectedEditors();
+        vfpPlot->loadDataAndUpdate();
+
+        RiuPlotMainWindowTools::showPlotMainWindow();
+        RiuPlotMainWindowTools::selectAsCurrentItem( vfpPlot );
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RicNewVfpPlotFeature::setupActionLook( QAction* actionToSetup )
+{
+    actionToSetup->setText( "New VFP Plot" );
+    // TODO: add icon
+    // actionToSetup->setIcon( QIcon( ":/VerticalFlowPerformancePlot16x16.png" ) );
+}

ApplicationCode/Commands/RicNewVfpPlotFeature.h

@@ -0,0 +1,36 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2020  Equinor ASA
+//
+//  ResInsight 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.
+//
+//  ResInsight 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 at <http://www.gnu.org/licenses/gpl.html>
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "cafCmdFeature.h"
+
+//==================================================================================================
+///
+//==================================================================================================
+class RicNewVfpPlotFeature : public caf::CmdFeature
+{
+    CAF_CMD_HEADER_INIT;
+
+private:
+    bool isCommandEnabled() override;
+    void onActionTriggered( bool isChecked ) override;
+    void setupActionLook( QAction* actionToSetup ) override;
+
+    static QString selectedWellName();
+};

ApplicationCode/ProjectDataModel/CMakeLists_files.cmake

@@ -69,6 +69,8 @@ ${CMAKE_CURRENT_LIST_DIR}/RimMainPlotCollection.h
 ${CMAKE_CURRENT_LIST_DIR}/RimWellLogPlotCollection.h
 ${CMAKE_CURRENT_LIST_DIR}/RimRftPlotCollection.h
 ${CMAKE_CURRENT_LIST_DIR}/RimPltPlotCollection.h
+${CMAKE_CURRENT_LIST_DIR}/RimVfpPlotCollection.h
+${CMAKE_CURRENT_LIST_DIR}/RimVfpPlot.h
 ${CMAKE_CURRENT_LIST_DIR}/RimPlot.h
 ${CMAKE_CURRENT_LIST_DIR}/RimPlotWindow.h
 ${CMAKE_CURRENT_LIST_DIR}/RimMultiPlot.h
@@ -150,6 +152,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimColorLegendCollection.h
 ${CMAKE_CURRENT_LIST_DIR}/RimColorLegend.h
 ${CMAKE_CURRENT_LIST_DIR}/RimColorLegendItem.h
 ${CMAKE_CURRENT_LIST_DIR}/RimAbstractPlotCollection.h
+${CMAKE_CURRENT_LIST_DIR}/RimVfpTableExtractor.h
 )
 
 
@@ -224,6 +227,8 @@ ${CMAKE_CURRENT_LIST_DIR}/RimMainPlotCollection.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimWellLogPlotCollection.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimRftPlotCollection.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimPltPlotCollection.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimVfpPlotCollection.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimVfpPlot.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimPlot.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimPlotWindow.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimMultiPlot.cpp
@@ -303,6 +308,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimElementVectorResult.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimColorLegendCollection.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimColorLegend.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimColorLegendItem.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimVfpTableExtractor.cpp
 )
 
 list(APPEND CODE_HEADER_FILES

ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp

@@ -125,6 +125,7 @@
 #include "RimSurfaceCollection.h"
 #include "RimValveTemplate.h"
 #include "RimValveTemplateCollection.h"
+#include "RimVfpPlotCollection.h"
 #include "RimViewController.h"
 #include "RimViewLinker.h"
 #include "RimViewLinkerCollection.h"
@@ -534,6 +535,10 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
         {
             menuBuilder << "RicNewPltPlotFeature";
         }
+        else if ( dynamic_cast<RimVfpPlotCollection*>( firstUiItem ) )
+        {
+            menuBuilder << "RicNewVfpPlotFeature";
+        }
         else if ( dynamic_cast<RimSummaryPlotCollection*>( firstUiItem ) )
         {
             menuBuilder << "RicPasteSummaryPlotFeature";

ApplicationCode/ProjectDataModel/RimMainPlotCollection.cpp

@@ -35,6 +35,7 @@
 #include "RimSummaryAddress.h"
 #include "RimSummaryCrossPlotCollection.h"
 #include "RimSummaryPlotCollection.h"
+#include "RimVfpPlotCollection.h"
 #include "RimViewWindow.h"
 #include "RimWellLogPlot.h"
 #include "RimWellLogPlotCollection.h"
@@ -98,6 +99,9 @@ RimMainPlotCollection::RimMainPlotCollection()
     CAF_PDM_InitFieldNoDefault( &m_stimPlanModelPlotCollection, "StimPlanModelPlotCollection", "", "", "", "" );
     m_stimPlanModelPlotCollection.uiCapability()->setUiHidden( true );
 
+    CAF_PDM_InitFieldNoDefault( &m_vfpPlotCollection, "VfpPlotCollection", "", "", "", "" );
+    m_vfpPlotCollection.uiCapability()->setUiHidden( true );
+
     m_wellLogPlotCollection            = new RimWellLogPlotCollection();
     m_rftPlotCollection                = new RimRftPlotCollection();
     m_pltPlotCollection                = new RimPltPlotCollection();
@@ -110,6 +114,7 @@ RimMainPlotCollection::RimMainPlotCollection()
     m_analysisPlotCollection           = new RimAnalysisPlotCollection;
     m_correlationPlotCollection        = new RimCorrelationPlotCollection;
     m_stimPlanModelPlotCollection      = new RimStimPlanModelPlotCollection;
+    m_vfpPlotCollection                = new RimVfpPlotCollection();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -208,6 +213,14 @@ RimMultiPlotCollection* RimMainPlotCollection::multiPlotCollection()
     return m_multiPlotCollection();
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimVfpPlotCollection* RimMainPlotCollection::vfpPlotCollection()
+{
+    return m_vfpPlotCollection();
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -246,6 +259,7 @@ void RimMainPlotCollection::deleteAllContainedObjects()
     m_flowPlotCollection()->closeDefaultPlotWindowAndDeletePlots();
     m_saturationPressurePlotCollection()->deleteAllChildObjects();
     m_multiPlotCollection()->deleteAllChildObjects();
+    m_vfpPlotCollection()->deleteAllChildObjects();
     m_analysisPlotCollection()->deleteAllPlots();
     m_correlationPlotCollection()->deleteAllPlots();
     m_stimPlanModelPlotCollection()->deleteAllPlots();

ApplicationCode/ProjectDataModel/RimMainPlotCollection.h

@@ -41,6 +41,7 @@ class RimEclipseResultCase;
 class RimFlowPlotCollection;
 class RimSaturationPressurePlotCollection;
 class RimStimPlanModelPlotCollection;
+class RimVfpPlotCollection;
 
 //==================================================================================================
 ///
@@ -66,6 +67,7 @@ public:
     RimSaturationPressurePlotCollection* saturationPressurePlotCollection();
     RimMultiPlotCollection*              multiPlotCollection();
     RimStimPlanModelPlotCollection*      stimPlanModelPlotCollection();
+    RimVfpPlotCollection*                vfpPlotCollection();
 
     void deleteAllContainedObjects();
     void updateCurrentTimeStepInPlots();
@@ -93,6 +95,7 @@ private:
     caf::PdmChildField<RimSaturationPressurePlotCollection*> m_saturationPressurePlotCollection;
     caf::PdmChildField<RimMultiPlotCollection*>              m_multiPlotCollection;
     caf::PdmChildField<RimStimPlanModelPlotCollection*>      m_stimPlanModelPlotCollection;
+    caf::PdmChildField<RimVfpPlotCollection*>                m_vfpPlotCollection;
 
     caf::PdmField<bool> m_show;
 };

ApplicationCode/ProjectDataModel/RimProject.cpp

@@ -81,6 +81,7 @@
 #include "RimUserDefinedPolylinesAnnotation.h"
 #include "RimValveTemplate.h"
 #include "RimValveTemplateCollection.h"
+#include "RimVfpPlotCollection.h"
 #include "RimViewLinker.h"
 #include "RimViewLinkerCollection.h"
 #include "RimViewWindow.h"
@@ -1453,6 +1454,11 @@ void RimProject::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, Q
             {
                 itemCollection->add( mainPlotCollection->stimPlanModelPlotCollection() );
             }
+
+            if ( mainPlotCollection->vfpPlotCollection() )
+            {
+                itemCollection->add( mainPlotCollection->vfpPlotCollection() );
+            }
         }
 
         uiTreeOrdering.add( scriptCollection() );

ApplicationCode/ProjectDataModel/RimVfpPlot.cpp

@@ -0,0 +1,670 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2020- Equinor ASA
+//
+//  ResInsight 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.
+//
+//  ResInsight 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 at <http://www.gnu.org/licenses/gpl.html>
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RimVfpPlot.h"
+
+#include "RimEclipseResultCase.h"
+#include "RimFlowDiagSolution.h"
+#include "RimProject.h"
+#include "RimTools.h"
+#include "RimVfpTableExtractor.h"
+
+#include "RigEclipseCaseData.h"
+#include "RigTofWellDistributionCalculator.h"
+
+#include "RiaColorTools.h"
+
+#include "RiuQwtPlotWidget.h"
+
+#include "qwt_legend.h"
+#include "qwt_legend_label.h"
+#include "qwt_plot.h"
+#include "qwt_plot_curve.h"
+#include "qwt_symbol.h"
+
+#include <QGridLayout>
+#include <QTextBrowser>
+#include <QWidget>
+
+#include <array>
+
+#include "cvfDebugTimer.h"
+#include "cvfTrace.h"
+
+#include <QFileInfo>
+
+//==================================================================================================
+//
+//
+//
+//==================================================================================================
+
+CAF_PDM_SOURCE_INIT( RimVfpPlot, "VfpPlot" );
+
+namespace caf
+{
+template <>
+void caf::AppEnum<RimVfpPlot::TableType>::setUp()
+{
+    addItem( RimVfpPlot::TableType::INJECTION, "INJECTION", "Injection" );
+    addItem( RimVfpPlot::TableType::PRODUCTION, "PRODUCTION", "Production" );
+    setDefault( RimVfpPlot::TableType::INJECTION );
+}
+
+template <>
+void caf::AppEnum<RimVfpPlot::ProductionTableType>::setUp()
+{
+    addItem( RimVfpPlot::ProductionTableType::LIQUID_FLOW_RATE, "LIQUID_FLOW_RATE", "Liquid Flow Rate" );
+    addItem( RimVfpPlot::ProductionTableType::ARTIFICIAL_LIFT_QUANTITY, "ALQ", "Artificial Lift Quantity" );
+    addItem( RimVfpPlot::ProductionTableType::WATER_CUT, "WATER_CUT", "Water Cut" );
+    addItem( RimVfpPlot::ProductionTableType::GAS_LIQUID_RATIO, "GAS_LIQUID_RATIO", "Gas Liquid Ratio" );
+    setDefault( RimVfpPlot::ProductionTableType::LIQUID_FLOW_RATE );
+}
+} // namespace caf
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimVfpPlot::RimVfpPlot()
+{
+    // TODO: add icon
+    CAF_PDM_InitObject( "VFP Plot", "", "", "" );
+
+    CAF_PDM_InitFieldNoDefault( &m_case, "Case", "Case", "", "", "" );
+    CAF_PDM_InitField( &m_wellName, "WellName", QString( "None" ), "Well", "", "", "" );
+
+    caf::AppEnum<RimVfpPlot::TableType> defaultTableType = RimVfpPlot::TableType::INJECTION;
+    CAF_PDM_InitField( &m_tableType, "TableType", defaultTableType, "Table Type", "", "", "" );
+
+    caf::AppEnum<RimVfpPlot::ProductionTableType> defaultProductionTableType =
+        RimVfpPlot::ProductionTableType::LIQUID_FLOW_RATE;
+    CAF_PDM_InitField( &m_productionTableType,
+                       "ProductionTableType",
+                       defaultProductionTableType,
+                       "Production Table Type",
+                       "",
+                       "",
+                       "" );
+
+    m_showWindow      = false;
+    m_showPlotLegends = true;
+
+    setAsPlotMdiWindow();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimVfpPlot::~RimVfpPlot()
+{
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::setDataSourceParameters( RimEclipseResultCase* eclipseResultCase, QString targetWellName )
+{
+    m_case     = eclipseResultCase;
+    m_wellName = targetWellName;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RiuQwtPlotWidget* RimVfpPlot::viewer()
+{
+    return m_plotWidget;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::setAutoScaleXEnabled( bool /*enabled*/ )
+{
+    cvf::Trace::show( "RimVfpPlot::setAutoScaleXEnabled()" );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::setAutoScaleYEnabled( bool /*enabled*/ )
+{
+    cvf::Trace::show( "RimVfpPlot::setAutoScaleYEnabled()" );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::updateAxes()
+{
+    cvf::Trace::show( "RimVfpPlot::updateAxes()" );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::updateLegend()
+{
+    if ( !m_plotWidget )
+    {
+        return;
+    }
+
+    // Hide the legend when in multiplot mode, as the legend is handeled by the multi plot grid layout
+    bool doShowLegend = false;
+    if ( isMdiWindow() )
+    {
+        doShowLegend = m_showPlotLegends;
+    }
+
+    if ( doShowLegend )
+    {
+        QwtLegend* legend = new QwtLegend( m_plotWidget );
+        m_plotWidget->insertLegend( legend, QwtPlot::BottomLegend );
+    }
+    else
+    {
+        m_plotWidget->insertLegend( nullptr );
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::updateZoomInQwt()
+{
+    cvf::Trace::show( "RimVfpPlot::updateZoomInQwt()" );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::updateZoomFromQwt()
+{
+    cvf::Trace::show( "RimVfpPlot::updateZoomFromQwt()" );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+QString RimVfpPlot::asciiDataForPlotExport() const
+{
+    cvf::Trace::show( "RimVfpPlot::asciiDataForPlotExport()" );
+    return QString();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::reattachAllCurves()
+{
+    cvf::Trace::show( "RimVfpPlot::reattachAllCurves()" );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::detachAllCurves()
+{
+    cvf::Trace::show( "RimVfpPlot::detachAllCurves()" );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+caf::PdmObject* RimVfpPlot::findPdmObjectFromQwtCurve( const QwtPlotCurve* /*curve*/ ) const
+{
+    cvf::Trace::show( "RimVfpPlot::findPdmObjectFromQwtCurve()" );
+    return nullptr;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::onAxisSelected( int /*axis*/, bool /*toggle*/ )
+{
+    cvf::Trace::show( "RimVfpPlot::onAxisSelected()" );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+QString RimVfpPlot::description() const
+{
+    return uiName();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+QWidget* RimVfpPlot::viewWidget()
+{
+    cvf::Trace::show( "RimVfpPlot::viewWidget()" );
+    return m_plotWidget;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+QImage RimVfpPlot::snapshotWindowContent()
+{
+    cvf::Trace::show( "RimVfpPlot::snapshotWindowContent()" );
+
+    QImage image;
+
+    if ( m_plotWidget )
+    {
+        QPixmap pix = m_plotWidget->grab();
+        image       = pix.toImage();
+    }
+
+    return image;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::zoomAll()
+{
+    cvf::Trace::show( "RimVfpPlot::zoomAll()" );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::doRemoveFromCollection()
+{
+    cvf::Trace::show( "RimVfpPlot::doRemoveFromCollection()" );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RiuQwtPlotWidget* RimVfpPlot::doCreatePlotViewWidget( QWidget* mainWindowParent )
+{
+    cvf::Trace::show( "RimVfpPlot::createViewWidget()" );
+
+    // It seems we risk being called multiple times
+    if ( m_plotWidget )
+    {
+        return m_plotWidget;
+    }
+
+    m_plotWidget = new RiuQwtPlotWidget( this, mainWindowParent );
+
+    //    m_plotWidget->setAutoReplot( false );
+
+    updateLegend();
+    onLoadDataAndUpdate();
+
+    return m_plotWidget;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::deleteViewWidget()
+{
+    cvf::Trace::show( "RimVfpPlot::deleteViewWidget()" );
+
+    if ( m_plotWidget )
+    {
+        m_plotWidget->setParent( nullptr );
+        delete m_plotWidget;
+        m_plotWidget = nullptr;
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::onLoadDataAndUpdate()
+{
+    cvf::Trace::show( "RimVfpPlot::onLoadDataAndUpdate()" );
+    cvf::DebugTimer tim( "RimVfpPlot::onLoadDataAndUpdate()" );
+
+    if ( isMdiWindow() )
+    {
+        updateMdiWindowVisibility();
+    }
+    else
+    {
+        updateParentLayout();
+    }
+
+    if ( !m_plotWidget )
+    {
+        return;
+    }
+
+    m_plotWidget->detachItems( QwtPlotItem::Rtti_PlotCurve );
+
+    updateLegend();
+
+    QString phaseString = "N/A";
+    bool    isInjector  = m_tableType == RimVfpPlot::TableType::INJECTION;
+    if ( m_case && m_case->ensureReservoirCaseIsOpen() )
+    {
+        if ( isInjector )
+        {
+            std::set<std::string> wells            = { "F2H", "C1H", "C2H", "C3H", "C4AH", "C4H", "F1H", "F3H", "F4H" };
+            std::string           strippedWellName = QString( m_wellName() ).remove( "-" ).toStdString();
+
+            if ( wells.find( strippedWellName ) != wells.end() )
+            {
+                QString   gridFileName = m_case->gridFileName();
+                QFileInfo fi( gridFileName );
+
+                std::string filename = fi.canonicalPath().toStdString() + "/INCLUDE/VFP/" + strippedWellName + ".Ecl";
+                const std::vector<Opm::VFPInjTable> tables = RimVfpTableExtractor::extractVfpInjectionTables( filename );
+                populatePlotWidgetWithCurveData( m_plotWidget, tables );
+            }
+        }
+        else
+        {
+            std::set<std::string> wells = { "B1BH", "B2H", "B3H", "D1CH", "B4DH", "E1H", "D2H", "D3BH", "E3CH" };
+            std::string           strippedWellName = QString( m_wellName() ).remove( "-" ).toStdString();
+
+            if ( wells.find( strippedWellName ) != wells.end() )
+            {
+                QString   gridFileName = m_case->gridFileName();
+                QFileInfo fi( gridFileName );
+
+                std::string filename = fi.canonicalPath().toStdString() + "/INCLUDE/VFP/" + strippedWellName + ".Ecl";
+                const std::vector<Opm::VFPProdTable> tables = RimVfpTableExtractor::extractVfpProductionTables( filename );
+                populatePlotWidgetWithCurveData( m_plotWidget, tables, m_productionTableType() );
+            }
+        }
+    }
+
+    const QString plotTitleStr = QString( "%1 Vertical Flow Performance Plot" ).arg( m_wellName );
+    m_plotWidget->setTitle( plotTitleStr );
+
+    if ( isInjector )
+    {
+        m_plotWidget->setAxisTitleText( QwtPlot::xBottom, "Liquid Flow Rate [sm3/d]" );
+        m_plotWidget->setAxisTitleText( QwtPlot::yLeft, "Bottom Hole Pressure [Bar]" );
+    }
+    else
+    {
+        m_plotWidget->setAxisTitleText( QwtPlot::xBottom, "x axis (todo) [x axis unit]" );
+        m_plotWidget->setAxisTitleText( QwtPlot::yLeft, "y axis [y axis unit]" );
+    }
+
+    m_plotWidget->setAxisTitleEnabled( QwtPlot::xBottom, true );
+    m_plotWidget->setAxisTitleEnabled( QwtPlot::yLeft, true );
+
+    m_plotWidget->scheduleReplot();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::populatePlotWidgetWithCurveData( RiuQwtPlotWidget* plotWidget, const std::vector<Opm::VFPInjTable>& tables )
+{
+    cvf::Trace::show( "RimVfpPlot::populatePlotWidgetWithCurves()" );
+
+    plotWidget->detachItems( QwtPlotItem::Rtti_PlotCurve );
+    plotWidget->setAxisScale( QwtPlot::xBottom, 0, 1 );
+    plotWidget->setAxisScale( QwtPlot::yLeft, 0, 1 );
+    plotWidget->setAxisAutoScale( QwtPlot::xBottom, true );
+    plotWidget->setAxisAutoScale( QwtPlot::yLeft, true );
+
+    size_t numTables = tables.size();
+
+    for ( size_t i = 0; i < numTables; i++ )
+    {
+        const Opm::VFPInjTable table = tables[i];
+        std::cout << "Datum depth: " << table.getDatumDepth() << std::endl;
+        std::cout << "Table number: " << table.getTableNum() << std::endl;
+        std::cout << "Flow type: " << static_cast<int>( table.getFloType() ) << std::endl;
+        std::cout << "Flo axis: " << table.getFloAxis().size() << std::endl;
+        std::cout << "THP axis: " << table.getTHPAxis().size() << std::endl;
+
+        std::cout << "THP Axis:\n";
+        for ( size_t x = 0; x < table.getTHPAxis().size(); x++ )
+        {
+            std::cout << " " << table.getTHPAxis()[x];
+        }
+        std::cout << "\n";
+
+        for ( size_t y = 0; y < table.getFloAxis().size(); y++ )
+        {
+            for ( size_t x = 0; x < table.getTHPAxis().size(); x++ )
+            {
+                std::cout << " " << table( x, y );
+            }
+            std::cout << std::endl;
+        }
+
+        for ( size_t thp = 0; thp < table.getTHPAxis().size(); thp++ )
+        {
+            // Just create some dummy values for now
+            size_t              numValues = table.getFloAxis().size();
+            std::vector<double> xVals     = table.getFloAxis();
+            std::vector<double> yVals( numValues, 0.0 );
+            for ( size_t y = 0; y < numValues; y++ )
+            {
+                // Convert from Pascal to Bar
+                yVals[y] = table( thp, y ) / 100000.0;
+            }
+
+            cvf::Color3f cvfClr = cvf::Color3::BLUE;
+            QColor       qtClr  = RiaColorTools::toQColor( cvfClr );
+
+            QwtPlotCurve* curve = new QwtPlotCurve;
+            // Convert from Pascal to Bar
+            curve->setTitle( QString( "THP: %1 Bar" ).arg( table.getTHPAxis()[thp] / 100000.0 ) );
+            QwtSymbol* symbol = new QwtSymbol( QwtSymbol::Ellipse, QBrush( qtClr ), QPen( Qt::red, 2 ), QSize( 8, 8 ) );
+            curve->setSymbol( symbol );
+
+            curve->setSamples( xVals.data(), yVals.data(), numValues );
+            curve->attach( plotWidget );
+            curve->show();
+        }
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::populatePlotWidgetWithCurveData( RiuQwtPlotWidget*                     plotWidget,
+                                                  const std::vector<Opm::VFPProdTable>& tables,
+                                                  RimVfpPlot::ProductionTableType       productionTableType )
+{
+    cvf::Trace::show( "RimVfpPlot::populatePlotWidgetWithCurves()" );
+
+    plotWidget->detachItems( QwtPlotItem::Rtti_PlotCurve );
+    plotWidget->setAxisScale( QwtPlot::xBottom, 0, 1 );
+    plotWidget->setAxisScale( QwtPlot::yLeft, 0, 1 );
+    plotWidget->setAxisAutoScale( QwtPlot::xBottom, true );
+    plotWidget->setAxisAutoScale( QwtPlot::yLeft, true );
+
+    size_t numTables = tables.size();
+
+    for ( size_t i = 0; i < numTables; i++ )
+    {
+        const Opm::VFPProdTable table = tables[i];
+        std::cout << "Datum depth: " << table.getDatumDepth() << std::endl;
+        std::cout << "Table number: " << table.getTableNum() << std::endl;
+        std::cout << "Flow type: " << static_cast<int>( table.getFloType() ) << std::endl;
+        std::cout << "Flo axis: " << table.getFloAxis().size() << std::endl;
+        std::cout << "THP axis: " << table.getTHPAxis().size() << std::endl;
+        std::cout << "WFR axis: " << table.getWFRAxis().size() << std::endl;
+        std::cout << "GFR axis: " << table.getGFRAxis().size() << std::endl;
+        std::cout << "ALQ axis: " << table.getALQAxis().size() << std::endl;
+
+        std::cout << "THP Axis:\n";
+        for ( size_t x = 0; x < table.getTHPAxis().size(); x++ )
+        {
+            std::cout << " " << table.getTHPAxis()[x];
+        }
+        std::cout << "\n";
+
+        for ( size_t thp_idx = 0; thp_idx < table.getTHPAxis().size(); thp_idx++ )
+        {
+            size_t wfr_idx = table.getWFRAxis().size() - 1;
+            size_t gfr_idx = table.getGFRAxis().size() - 1;
+            size_t alq_idx = table.getALQAxis().size() - 1;
+            size_t flo_idx = table.getFloAxis().size() - 1;
+
+            std::vector<double> xVals;
+            if ( productionTableType == RimVfpPlot::ProductionTableType::WATER_CUT )
+            {
+                xVals = table.getWFRAxis();
+            }
+            else if ( productionTableType == RimVfpPlot::ProductionTableType::GAS_LIQUID_RATIO )
+            {
+                xVals = table.getGFRAxis();
+            }
+            else if ( productionTableType == RimVfpPlot::ProductionTableType::ARTIFICIAL_LIFT_QUANTITY )
+            {
+                xVals = table.getALQAxis();
+            }
+            else if ( productionTableType == RimVfpPlot::ProductionTableType::LIQUID_FLOW_RATE )
+            {
+                xVals = table.getFloAxis();
+            }
+
+            size_t              numValues = xVals.size();
+            std::vector<double> yVals( numValues, 0.0 );
+
+            for ( size_t y = 0; y < numValues; y++ )
+            {
+                if ( productionTableType == RimVfpPlot::ProductionTableType::WATER_CUT )
+                    wfr_idx = y;
+                else if ( productionTableType == RimVfpPlot::ProductionTableType::GAS_LIQUID_RATIO )
+                    gfr_idx = y;
+                else if ( productionTableType == RimVfpPlot::ProductionTableType::ARTIFICIAL_LIFT_QUANTITY )
+                    alq_idx = y;
+                else if ( productionTableType == RimVfpPlot::ProductionTableType::LIQUID_FLOW_RATE )
+                    flo_idx = y;
+
+                // Convert from Pascal to Bar
+                yVals[y] = table( thp_idx, wfr_idx, gfr_idx, alq_idx, flo_idx ) / 100000.0;
+            }
+
+            cvf::Color3f cvfClr = cvf::Color3::BLUE;
+            QColor       qtClr  = RiaColorTools::toQColor( cvfClr );
+
+            QwtPlotCurve* curve = new QwtPlotCurve;
+            // Convert from Pascal to Bar
+            curve->setTitle( QString( "THP: %1 Bar" ).arg( table.getTHPAxis()[thp_idx] / 100000.0 ) );
+            QwtSymbol* symbol = new QwtSymbol( QwtSymbol::Ellipse, QBrush( qtClr ), QPen( Qt::red, 2 ), QSize( 8, 8 ) );
+            curve->setSymbol( symbol );
+
+            curve->setSamples( xVals.data(), yVals.data(), numValues );
+            curve->attach( plotWidget );
+            curve->show();
+        }
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
+{
+    uiOrdering.add( &m_case );
+    uiOrdering.add( &m_wellName );
+    uiOrdering.add( &m_tableType );
+    uiOrdering.add( &m_productionTableType );
+    m_productionTableType.uiCapability()->setUiHidden( m_tableType != RimVfpPlot::TableType::PRODUCTION );
+
+    uiOrdering.skipRemainingFields( true );
+    // RimPlot::defineUiOrdering( uiConfigName, uiOrdering );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+QList<caf::PdmOptionItemInfo> RimVfpPlot::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions,
+                                                                 bool*                      useOptionsOnly )
+{
+    QList<caf::PdmOptionItemInfo> options = RimPlot::calculateValueOptions( fieldNeedingOptions, useOptionsOnly );
+
+    if ( fieldNeedingOptions == &m_case )
+    {
+        RimProject* ownerProj = nullptr;
+        firstAncestorOrThisOfType( ownerProj );
+        if ( ownerProj )
+        {
+            std::vector<RimEclipseResultCase*> caseArr;
+            ownerProj->descendantsIncludingThisOfType( caseArr );
+            for ( RimEclipseResultCase* c : caseArr )
+            {
+                options.push_back( caf::PdmOptionItemInfo( c->caseUserDescription(), c, true, c->uiIconProvider() ) );
+            }
+        }
+    }
+
+    else if ( fieldNeedingOptions == &m_wellName )
+    {
+        if ( m_case && m_case->eclipseCaseData() )
+        {
+            caf::IconProvider       simWellIcon( ":/Well.png" );
+            const std::set<QString> sortedWellNameSet = m_case->eclipseCaseData()->findSortedWellNames();
+            for ( const QString& name : sortedWellNameSet )
+            {
+                options.push_back( caf::PdmOptionItemInfo( name, name, true, simWellIcon ) );
+            }
+        }
+
+        if ( options.size() == 0 )
+        {
+            options.push_back( caf::PdmOptionItemInfo( "None", QVariant() ) );
+        }
+    }
+
+    return options;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
+{
+    RimPlot::fieldChangedByUi( changedField, oldValue, newValue );
+
+    if ( changedField == &m_case )
+    {
+        fixupDependentFieldsAfterCaseChange();
+    }
+
+    loadDataAndUpdate();
+    updateLayout();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlot::fixupDependentFieldsAfterCaseChange()
+{
+    QString newWellName;
+
+    if ( m_case )
+    {
+        const std::set<QString> sortedWellNameSet = m_case->eclipseCaseData()->findSortedWellNames();
+        if ( sortedWellNameSet.size() > 0 )
+        {
+            newWellName = *sortedWellNameSet.begin();
+        }
+    }
+
+    m_wellName = newWellName;
+}

ApplicationCode/ProjectDataModel/RimVfpPlot.h

@@ -0,0 +1,118 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2020- Equinor ASA
+//
+//  ResInsight 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.
+//
+//  ResInsight 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 at <http://www.gnu.org/licenses/gpl.html>
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "RimPlot.h"
+
+#include "cafPdmPtrField.h"
+
+#include <QPointer>
+
+#include "opm/parser/eclipse/EclipseState/Schedule/VFPInjTable.hpp"
+#include "opm/parser/eclipse/EclipseState/Schedule/VFPProdTable.hpp"
+
+class RimEclipseResultCase;
+class RimFlowDiagSolution;
+class RigTofWellDistributionCalculator;
+class RiuQwtPlotWidget;
+
+//--------------------------------------------------------------------------------------------------
+/// Vertical Flow Performance Plot
+//--------------------------------------------------------------------------------------------------
+class RimVfpPlot : public RimPlot
+{
+    CAF_PDM_HEADER_INIT;
+
+public:
+    enum class TableType
+    {
+        INJECTION,
+        PRODUCTION
+    };
+
+    enum class ProductionTableType
+    {
+        LIQUID_FLOW_RATE,
+        ARTIFICIAL_LIFT_QUANTITY,
+        WATER_CUT,
+        GAS_LIQUID_RATIO
+    };
+
+    RimVfpPlot();
+    ~RimVfpPlot() override;
+
+    void setDataSourceParameters( RimEclipseResultCase* eclipseResultCase, QString targetWellName );
+    // void setPlotOptions( bool groupSmallContributions, double smallContributionsRelativeThreshold, double maximumTof );
+
+    RiaDefines::PhaseType phase() const;
+
+    // RimPlot implementations
+    RiuQwtPlotWidget* viewer() override;
+    void              setAutoScaleXEnabled( bool enabled ) override;
+    void              setAutoScaleYEnabled( bool enabled ) override;
+    void              updateAxes() override;
+    void              updateLegend() override;
+    void              updateZoomInQwt() override;
+    void              updateZoomFromQwt() override;
+    QString           asciiDataForPlotExport() const override;
+    void              reattachAllCurves() override;
+    void              detachAllCurves() override;
+    caf::PdmObject*   findPdmObjectFromQwtCurve( const QwtPlotCurve* curve ) const override;
+    void              onAxisSelected( int axis, bool toggle ) override;
+
+    // RimPlotWindow implementations
+    QString description() const override;
+
+    // RimViewWindow implementations
+    QWidget* viewWidget() override;
+    QImage   snapshotWindowContent() override;
+    void     zoomAll() override;
+
+private:
+    // RimPlot implementations
+    void doRemoveFromCollection();
+
+    // RimViewWindow implementations
+    void deleteViewWidget() override;
+    void onLoadDataAndUpdate() override;
+
+private:
+    RiuQwtPlotWidget* doCreatePlotViewWidget( QWidget* mainWindowParent ) override;
+
+    void        fixupDependentFieldsAfterCaseChange();
+    static void populatePlotWidgetWithCurveData( RiuQwtPlotWidget* plotWidget, const std::vector<Opm::VFPInjTable>& tables );
+    static void populatePlotWidgetWithCurveData( RiuQwtPlotWidget*                     plotWidget,
+                                                 const std::vector<Opm::VFPProdTable>& tables,
+                                                 RimVfpPlot::ProductionTableType       productionTableType );
+
+    void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
+    void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
+
+    QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions,
+                                                         bool*                      useOptionsOnly ) override;
+
+private:
+    caf::PdmPtrField<RimEclipseResultCase*> m_case;
+    caf::PdmField<QString>                  m_wellName;
+
+    caf::PdmField<caf::AppEnum<RimVfpPlot::TableType>>           m_tableType;
+    caf::PdmField<caf::AppEnum<RimVfpPlot::ProductionTableType>> m_productionTableType;
+
+    QPointer<RiuQwtPlotWidget> m_plotWidget;
+};

ApplicationCode/ProjectDataModel/RimVfpPlotCollection.cpp

@@ -0,0 +1,74 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2020- Equinor ASA
+//
+//  ResInsight 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.
+//
+//  ResInsight 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 at <http://www.gnu.org/licenses/gpl.html>
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RimVfpPlotCollection.h"
+
+#include "RiaApplication.h"
+
+#include "RigCaseCellResultsData.h"
+#include "RigEclipseCaseData.h"
+#include "RigEclipseResultAddress.h"
+#include "RigEquil.h"
+
+#include "RimEclipseResultCase.h"
+#include "RimProject.h"
+#include "RimVfpPlot.h"
+
+CAF_PDM_SOURCE_INIT( RimVfpPlotCollection, "RimVfpPlotCollection" );
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimVfpPlotCollection::RimVfpPlotCollection()
+{
+    CAF_PDM_InitObject( "VFP Plots", ":/SummaryXPlotsLight16x16.png", "", "" );
+
+    CAF_PDM_InitFieldNoDefault( &m_vfpPlots, "VfpPlots", "Vertical Flow Performance Plots", "", "", "" );
+    m_vfpPlots.uiCapability()->setUiHidden( true );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimVfpPlotCollection::~RimVfpPlotCollection()
+{
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlotCollection::addPlot( RimVfpPlot* newPlot )
+{
+    m_vfpPlots.push_back( newPlot );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::vector<RimVfpPlot*> RimVfpPlotCollection::plots()
+{
+    return m_vfpPlots.childObjects();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimVfpPlotCollection::deleteAllChildObjects()
+{
+    m_vfpPlots.deleteAllChildObjects();
+}

ApplicationCode/ProjectDataModel/RimVfpPlotCollection.h

@@ -0,0 +1,43 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2020- Equinor ASA
+//
+//  ResInsight 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.
+//
+//  ResInsight 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 at <http://www.gnu.org/licenses/gpl.html>
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+#pragma once
+
+#include "cafPdmChildArrayField.h"
+#include "cafPdmObject.h"
+
+class RimVfpPlot;
+
+//==================================================================================================
+///
+///
+//==================================================================================================
+class RimVfpPlotCollection : public caf::PdmObject
+{
+    CAF_PDM_HEADER_INIT;
+
+public:
+    RimVfpPlotCollection();
+    ~RimVfpPlotCollection() override;
+
+    void                     addPlot( RimVfpPlot* newPlot );
+    std::vector<RimVfpPlot*> plots();
+    void                     deleteAllChildObjects();
+
+private:
+    caf::PdmChildArrayField<RimVfpPlot*> m_vfpPlots;
+};

ApplicationCode/ProjectDataModel/RimVfpTableExtractor.cpp

@@ -0,0 +1,93 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2020- Equinor ASA
+//
+//  ResInsight 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.
+//
+//  ResInsight 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 at <http://www.gnu.org/licenses/gpl.html>
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RimVfpTableExtractor.h"
+
+// #include "RiaApplication.h"
+
+// #include "RimCase.h"
+// #include "RimEclipseCase.h"
+// #include "RimGeoMechCase.h"
+// #include "RimOilField.h"
+// #include "RimProject.h"
+// #include "RimWellLogFile.h"
+// #include "RimWellPath.h"
+// #include "RimWellPathCollection.h"
+
+#include "cafPdmUiItem.h"
+#include "cafUtils.h"
+
+// #include <QDateTime>
+// #include <QDir>
+// #include <QFileInfo>
+
+// #include "opm/parser/eclipse/EclipseState/Schedule/VFPInjTable.hpp"
+// #include "opm/parser/eclipse/EclipseState/Schedule/VFPProdTable.hpp"
+#include "opm/parser/eclipse/Parser/Parser.hpp"
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::vector<Opm::VFPInjTable> RimVfpTableExtractor::extractVfpInjectionTables( const std::string& filename )
+{
+    std::vector<Opm::VFPInjTable> tables;
+
+    Opm::Parser parser;
+    auto        deck = parser.parseFile( filename );
+
+    std::string myKeyword   = "VFPINJ";
+    auto        keywordList = deck.getKeywordList( myKeyword );
+
+    Opm::UnitSystem unitSystem;
+
+    for ( auto kw : keywordList )
+    {
+        auto name = kw->name();
+
+        Opm::VFPInjTable table( *kw, unitSystem );
+        tables.push_back( table );
+    }
+
+    return tables;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::vector<Opm::VFPProdTable> RimVfpTableExtractor::extractVfpProductionTables( const std::string& filename )
+{
+    std::vector<Opm::VFPProdTable> tables;
+
+    Opm::Parser parser;
+    auto        deck = parser.parseFile( filename );
+
+    std::string myKeyword   = "VFPPROD";
+    auto        keywordList = deck.getKeywordList( myKeyword );
+
+    Opm::UnitSystem unitSystem;
+
+    for ( auto kw : keywordList )
+    {
+        auto name = kw->name();
+
+        Opm::VFPProdTable table( *kw, unitSystem );
+        tables.push_back( table );
+    }
+
+    return tables;
+}

ApplicationCode/ProjectDataModel/RimVfpTableExtractor.h

@@ -0,0 +1,35 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2020- Equinor ASA
+//
+//  ResInsight 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.
+//
+//  ResInsight 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 at <http://www.gnu.org/licenses/gpl.html>
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "opm/parser/eclipse/EclipseState/Schedule/VFPInjTable.hpp"
+#include "opm/parser/eclipse/EclipseState/Schedule/VFPProdTable.hpp"
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+class RimVfpTableExtractor
+{
+public:
+    static std::vector<Opm::VFPInjTable>  extractVfpInjectionTables( const std::string& filename );
+    static std::vector<Opm::VFPProdTable> extractVfpProductionTables( const std::string& filename );
+};

CMakeLists.txt

@@ -278,14 +278,18 @@ endif() # MSVC
 
 if (VCPKG_AUTO_INSTALL)
     vcpkg_install(boost-filesystem)
+    vcpkg_install(boost-spirit)
 endif()
 
 add_subdirectory(ThirdParty/custom-opm-flowdiagnostics)
 add_subdirectory(ThirdParty/custom-opm-flowdiag-app)
+add_subdirectory(ThirdParty/custom-opm-common)
+add_subdirectory(ThirdParty/custom-opm-common/custom-opm-parser-tests)
 
 list(APPEND OPM_LIBRARIES
     custom-opm-flowdiagnostics
     custom-opm-flowdiag-app
+    custom-opm-common
 )
 
 set_property(TARGET  
@@ -320,7 +324,10 @@ add_subdirectory(ThirdParty/qwt)
 if(RESINSIGHT_ENABLE_UNITY_BUILD)
     message("Cmake Unity build is enabled on : qwt")
     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)
 endif()
 
 list(APPEND THIRD_PARTY_LIBRARIES

ThirdParty/custom-opm-common/CMakeLists.txt

@@ -0,0 +1,118 @@
+cmake_minimum_required (VERSION 2.8)
+
+# -DBOOST_FILESYSTEM_VERSION=3 -DBOOST_TEST_DYN_LINK -DHAVE_CASE_SENSITIVE_FILESYSTEM=1 -DHAVE_REGEX=1 -DOPM_PARSER_DECK_API=1 -Wall -std=c++11 -fopenmp -Wall -g   -O0 -DDEBUG  -ggdb3
+ 
+ 
+# Languages and global compiler settings
+if(CMAKE_VERSION VERSION_LESS 3.8)
+  message(WARNING "CMake version does not support c++17, guessing -std=c++17")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
+else()
+  set(CMAKE_CXX_STANDARD 17)
+  set(CMAKE_CXX_STANDARD_REQUIRED ON)
+  set(CMAKE_CXX_EXTENSIONS OFF)
+endif()
+
+
+ if(MSVC)
+  add_definitions( "/wd4996 /wd4244 /wd4267" )
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
+endif(MSVC)
+
+project (custom-opm-common)
+
+
+include_directories(
+    opm-common
+    opm-common/external/cjson
+    generated-opm-common 
+    generated-opm-common/include
+)
+
+# Set defines to include requred files
+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 )
+
+set(opm_parser_source_files_short_path 
+	${MAIN_SOURCE_FILES}
+)
+
+foreach (file ${opm_parser_source_files_short_path} )
+    list(APPEND opm_parser_source_files_long_path "opm-common/${file}" )
+endforeach()
+
+set(opm_parser_source_files
+	${opm_parser_source_files_long_path}
+    ${opm_parser_generated_source_files} 
+) 
+
+# Append generated sources
+list(INSERT opm-common_SOURCES 0 generated-opm-common/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 generated-opm-common/ParserKeywords/${name}.cpp)
+endforeach()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9.0)
+    list(APPEND ADDITIONAL_LINK_LIBRARIES stdc++fs)
+  endif()
+endif()
+
+ if(MSVC)
+    list(APPEND opm-common_SOURCES opm-common/cross-platform/windows/Substitutes.cpp )
+endif(MSVC)
+
+add_library(${PROJECT_NAME} 
+    STATIC
+	${opm_parser_source_files_long_path}
+	${opm-common_SOURCES}
+
+    ## Missing files when only ENABLE_ECL_INPUT is defined
+    opm-common/src/opm/io/eclipse/EclFile.cpp
+    opm-common/src/opm/io/eclipse/EclOutput.cpp
+    opm-common/src/opm/io/eclipse/EclUtil.cpp
+    opm-common/src/opm/io/eclipse/EGrid.cpp
+
+    # Required for use of static function RstConnection::inverse_peaceman
+    opm-common/src/opm/io/eclipse/rst/connection.cpp
+
+    # Required for use of RstHeader::restart_info
+    opm-common/src/opm/io/eclipse/rst/header.cpp
+)
+
+if(RESINSIGHT_ENABLE_UNITY_BUILD)
+
+    set(UNITY_EXCLUDE_FILES
+    opm-common/src/opm/parser/eclipse/Deck/UDAValue.cpp
+    opm-common/src/opm/parser/eclipse/EclipseState/Schedule/Well/WellConnections.cpp
+    opm-common/src/opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQFunction.cpp
+    opm-common/src/opm/parser/eclipse/EclipseState/Schedule/Well/WListManager.cpp
+    opm-common/src/opm/parser/eclipse/EclipseState/Schedule/MSW/SpiralICD.cpp
+    opm-common/src/opm/io/eclipse/EclOutput.cpp
+    )
+
+    foreach(fileToExclude ${UNITY_EXCLUDE_FILES})
+      set_source_files_properties(${fileToExclude}
+                                PROPERTIES SKIP_UNITY_BUILD_INCLUSION TRUE)
+    endforeach(fileToExclude)
+endif()
+
+
+find_path(BOOST_SPIRIT_INCLUDE_DIRS "boost/spirit.hpp")
+
+target_link_libraries(custom-opm-common 
+  ${ADDITIONAL_LINK_LIBRARIES}
+)
+target_include_directories(custom-opm-common 
+  PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/opm-common
+    ${CMAKE_CURRENT_SOURCE_DIR}/generated-opm-common/include
+  PRIVATE
+    ${BOOST_SPIRIT_INCLUDE_DIRS}
+    
+)

ThirdParty/custom-opm-common/CMakeLists_files.cmake

@@ -0,0 +1,815 @@
+# 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()

ThirdParty/custom-opm-common/custom-opm-parser-tests/CMakeLists.txt

@@ -0,0 +1,59 @@
+cmake_minimum_required (VERSION 2.8)
+
+project ( opm-parser-tests )
+
+# Languages and global compiler settings
+if(CMAKE_VERSION VERSION_LESS 3.8)
+  message(WARNING "CMake version does not support c++17, guessing -std=c++17")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
+else()
+  set(CMAKE_CXX_STANDARD 17)
+  set(CMAKE_CXX_STANDARD_REQUIRED ON)
+  set(CMAKE_CXX_EXTENSIONS OFF)
+endif()
+
+if (MSVC AND (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 19.11))
+  # VS 2017 : Disable warnings from from gtest code, using deprecated code related to TR1 
+  add_definitions(-D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING)
+  message(STATUS "Add flag to disable warings from gtest -  _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING")
+endif()
+
+CONFIGURE_FILE( ${CMAKE_CURRENT_LIST_DIR}/OpmTestDataDirectory.h.cmake
+                ${CMAKE_BINARY_DIR}/Generated/OpmTestDataDirectory.h
+)
+
+include_directories (
+  ${CMAKE_CURRENT_SOURCE_DIR}/../..
+  ${CMAKE_BINARY_DIR}/Generated
+#    ${CMAKE_CURRENT_SOURCE_DIR}/../opm-parser
+    
+#	${CMAKE_CURRENT_SOURCE_DIR}/../../custom-opm-common/opm-common
+
+ #   ${ERT_INCLUDE_DIRS}
+    
+  #  ${Boost_INCLUDE_DIRS}
+)
+
+set( PROJECT_FILES
+
+	opm-parser_UnitTests.cpp 
+	../../gtest/gtest-all.cc
+
+	opm-parser-BasicTest.cpp 
+)
+
+# add the executable 
+add_executable (${PROJECT_NAME}
+	${PROJECT_FILES}
+)
+
+source_group("" FILES ${PROJECT_FILES})
+
+target_link_libraries ( ${PROJECT_NAME}
+    custom-opm-common
+)
+
+# Add dependency of Shlwapi.lib for Windows platforms
+if (MSVC)
+  target_link_libraries(${PROJECT_NAME} Shlwapi)
+endif()

ThirdParty/custom-opm-common/custom-opm-parser-tests/OpmTestDataDirectory.h.cmake

@@ -0,0 +1,3 @@
+// Test data directory used by unit tests
+
+#define TEST_DATA_DIR  "${CMAKE_CURRENT_LIST_DIR}/TestData"

ThirdParty/custom-opm-common/custom-opm-parser-tests/TestData/C1H.Ecl

@@ -0,0 +1,128 @@
+-- This reservoir simulation deck is made available under the Open Database
+-- License: http://opendatacommons.org/licenses/odbl/1.0/. Any rights in
+-- individual contents of the database are licensed under the Database Contents
+-- License: http://opendatacommons.org/licenses/dbcl/1.0/
+
+-- Copyright (C) 2015 Statoil
+
+--
+--         Generated by : Prosper 8.01 - License#:4163 - Nov 12 2004 18:40:47
+--         Generated on : 08 Sep 05  14:13
+--           Input File : Z:\Project\norne6\prod\gap\WI\C1H.OUT
+--          Output File : Z:\Project\norne6\prod\gap\WI\C1H.Ecl
+--
+--
+--                Fluid : Water
+--           PVT Method : Black Oil
+--    Equation Of State : 
+--            Separator : Single-Stage
+--            Emulsions : No
+--             Hydrates : Disable Warning
+--      Water Viscosity : Use Default Correlation
+--         Water Vapour : No Calculations
+--      Viscosity Model : Newtonian Fluid
+--
+--            Flow Type : Tubing
+--            Well Type : Water Injector
+--
+--      Artificial Lift : None
+--            Lift Type : 
+--
+--           Predicting : Pressure and Temperature (offshore)
+--    Temperature Model : Rough Approximation
+--                Range : Full System
+--
+--           Completion : Cased Hole
+--          Gravel Pack : No
+--
+--          Inflow Type : Single Branch
+--           Gas Coning : No
+--
+--              Company : Statoil
+--                Field : Norne
+--             Location : Nordland II
+--                 Well : C-1H
+--             Platform : Transocean Prospect
+--              Analyst : shlea
+--                 Date : 22 Mar 99  15:59
+--
+--
+--
+--  Surface Equipment Correlation :  Dukler Eaton Flannigan
+--      Vertical Lift Correlation :  Petroleum Experts 2
+--                    Rate Method :  User Selected
+--                      Rate Type :  Liquid Rates
+--                     First Node :    1            Xmas Tree      392.3 (m)
+--                      Last Node :    8               Casing       3043 (m)
+--
+--
+-- PROSPER Lift Curves For ECLIPSE Simulator    (Water - Water Injector Well)  (Units System  - METRIC)
+
+
+VFPINJ
+
+-- Table   Datum Depth   Rate Type
+-- -----   -----------   ---------
+      12       2718.07       'WAT' /
+
+
+-- 'WAT' units - SM3/DAY
+  500.0  1263.2  2026.3  2789.5  3552.6 
+ 4315.8  5078.9  5842.1  6605.3  7368.4 
+ 8131.6  8894.7  9657.9 10421.1 11184.2 
+11947.4 12710.5 13473.7 14236.8 15000.0 /
+
+-- 'THP' units - BARSA
+  21.01   63.24  105.46  147.68  189.90 
+ 232.12  274.35  316.57  358.79  401.01 /
+
+ 1  254.51  253.95  252.27  249.83  246.69 
+   242.88  238.42  233.32  227.59  221.22 
+   214.23  206.62  198.38  189.53  180.06 
+   169.97  159.26  147.95  136.00  123.46 
+/
+ 2  297.02  296.49  294.82  292.39  289.26 
+   285.47  281.01  275.92  270.20  263.84 
+   256.87  249.28  241.05  232.22  222.76 
+   212.70  202.01  190.71  178.79  166.27 
+/
+ 3  339.54  339.03  337.37  334.95  331.83 
+   328.05  323.60  318.52  312.82  306.47 
+   299.52  291.94  283.73  274.91  265.47 
+   255.43  244.75  233.48  221.58  209.09 
+/
+ 4  382.06  381.57  379.93  377.51  374.41 
+   370.63  366.19  361.13  355.44  349.10 
+   342.16  334.60  326.40  317.61  308.18 
+   298.16  287.50  276.26  264.37  251.90 
+/
+ 5  424.58  424.11  422.48  420.08  416.98 
+   413.22  408.78  403.73  398.06  391.73 
+   384.81  377.26  369.08  360.30  350.89 
+   340.89  330.25  319.03  307.16  294.72 
+/
+ 6  467.10  466.65  465.03  462.64  459.55 
+   455.80  451.37  446.34  440.68  434.36 
+   427.45  419.93  411.75  403.00  393.60 
+   383.62  373.00  361.80  349.96  337.54 
+/
+ 7  509.62  509.20  507.59  505.21  502.13 
+   498.39  493.97  488.95  483.30  476.99 
+   470.10  462.59  454.43  445.69  436.31 
+   426.35  415.75  404.57  392.75  380.36 
+/
+ 8  552.14  551.74  550.15  547.77  544.71 
+   540.98  536.56  531.56  525.92  519.62 
+   512.75  505.26  497.11  488.39  479.02 
+   469.09  458.50  447.35  435.55  423.18 
+/
+ 9  594.67  594.29  592.70  590.34  587.29 
+   583.57  579.16  574.17  568.55  562.25 
+   555.40  547.92  539.79  531.09  521.74 
+   511.82  501.25  490.13  478.34  466.01 
+/
+10  637.19  636.83  635.26  632.91  629.86 
+   626.16  621.76  616.78  611.17  604.89 
+   598.05  590.59  582.47  573.79  564.45 
+   554.56  544.01  532.91  521.14  508.83 
+/

ThirdParty/custom-opm-common/custom-opm-parser-tests/opm-parser-BasicTest.cpp

@@ -0,0 +1,71 @@
+
+#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 "OpmTestDataDirectory.h"
+
+using namespace Opm;
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+TEST(OpmParserTest, ReadFromFile)
+{
+    ParseContext parseContext;
+
+    {
+        Parser parser;
+
+        std::stringstream ss;
+        ss << TEST_DATA_DIR << "/B1BH.Ecl";
+        std::string testFile = ss.str();
+
+        auto deck = parser.parseFile(testFile);
+
+        std::string myKeyword = "VFPPROD";
+        auto keywordList = deck.getKeywordList(myKeyword);
+
+        UnitSystem unitSystem;
+
+    
+        for (auto kw : keywordList)
+        {
+            auto name = kw->name();
+    
+            VFPProdTable table(*kw, unitSystem);
+            std::cout << table.getDatumDepth() << std::endl;
+        }
+    }
+    {
+        Parser parser;
+
+        std::stringstream ss;
+        ss << TEST_DATA_DIR << "/C1H.Ecl";
+        std::string testFile = ss.str();
+
+        auto deck = parser.parseFile(testFile);
+
+        std::string myKeyword = "VFPINJ";
+        auto keywordList = deck.getKeywordList(myKeyword);
+
+        UnitSystem unitSystem;
+    
+        for (auto kw : keywordList)
+        {
+            auto name = kw->name();
+    
+            VFPInjTable table(*kw, unitSystem);
+            std::cout << table.getDatumDepth() << std::endl;
+        }
+    }
+
+
+}
+
+
+
+    

ThirdParty/custom-opm-common/custom-opm-parser-tests/opm-parser_UnitTests.cpp

@@ -0,0 +1,20 @@
+
+
+#include "gtest/gtest.h"
+#include <stdio.h>
+#include <iostream>
+#include <string>
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+int main(int argc, char **argv) 
+{
+    testing::InitGoogleTest(&argc, argv);
+    int result = RUN_ALL_TESTS();
+
+    char text[5];
+    std::cin.getline(text, 5);
+
+    return result;
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ThirdParty/custom-opm-common/opm-common/.clang-format

@@ -0,0 +1,20 @@
+{
+        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,
+}

ThirdParty/custom-opm-common/opm-common/.gitignore

@@ -0,0 +1,75 @@
+# 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

ThirdParty/custom-opm-common/opm-common/CMakeLists.txt

@@ -0,0 +1,368 @@
+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()

ThirdParty/custom-opm-common/opm-common/CMakeLists_files.cmake

@@ -0,0 +1,815 @@
+# 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()

ThirdParty/custom-opm-common/opm-common/CopyHeaders.cmake

@@ -0,0 +1,24 @@
+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()

ThirdParty/custom-opm-common/opm-common/ExtraTests.cmake

@@ -0,0 +1,127 @@
+# 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()

ThirdParty/custom-opm-common/opm-common/GenerateKeywords.cmake

@@ -0,0 +1,119 @@
+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)

ThirdParty/custom-opm-common/opm-common/LICENSE

@@ -0,0 +1,675 @@
+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>.
+

ThirdParty/custom-opm-common/opm-common/README.md

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

ThirdParty/custom-opm-common/opm-common/changelog.md

@@ -0,0 +1,63 @@
+# 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

ThirdParty/custom-opm-common/opm-common/cmake/Modules/AddOptions.cmake

@@ -0,0 +1,102 @@
+# - 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)

ThirdParty/custom-opm-common/opm-common/cmake/Modules/BoostTargets.cmake

@@ -0,0 +1,49 @@
+# 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()

ThirdParty/custom-opm-common/opm-common/cmake/Modules/CheckCaseSensitiveFileSystem.cmake

@@ -0,0 +1,29 @@
+#
+# 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()

ThirdParty/custom-opm-common/opm-common/cmake/Modules/ConfigVars.cmake

@@ -0,0 +1,120 @@
+# - 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)

ThirdParty/custom-opm-common/opm-common/cmake/Modules/Duplicates.cmake

@@ -0,0 +1,38 @@
+# - 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)

ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindAlberta.cmake

@@ -0,0 +1,46 @@
+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()

ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindC99.cmake

@@ -0,0 +1,25 @@
+# - 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
+  )

ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindClangCheck.cmake

@@ -0,0 +1,11 @@
+# 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)

ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindCppCheck.cmake

@@ -0,0 +1,11 @@
+# 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)

ThirdParty/custom-opm-common/opm-common/cmake/Modules/FindCwrap.cmake

@@ -0,0 +1,49 @@
+# 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)