finalizeSaltTables

CMakeLists_files.cmake

@@ -162,6 +162,7 @@ if(ENABLE_ECL_INPUT)
     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/RwgsaltTable.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
@@ -594,8 +595,11 @@ if(ENABLE_ECL_INPUT)
        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/PermfactTable.hpp
+       opm/parser/eclipse/EclipseState/Tables/RwgsaltTable.hpp
        opm/parser/eclipse/EclipseState/Tables/SaltvdTable.hpp
+       opm/parser/eclipse/EclipseState/Tables/SaltpvdTable.hpp
+       opm/parser/eclipse/EclipseState/Tables/SolventDensityTable.hpp
        opm/parser/eclipse/EclipseState/Tables/PlydhflfTable.hpp
        opm/parser/eclipse/EclipseState/Tables/PlymwinjTable.hpp
        opm/parser/eclipse/EclipseState/Tables/PlyshlogTable.hpp
@@ -614,6 +618,8 @@ if(ENABLE_ECL_INPUT)
        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/PvtgwTable.hpp
+       opm/parser/eclipse/EclipseState/Tables/PvtgwoTable.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/Runspec.hpp

@@ -40,11 +40,12 @@ enum class Phase {
     ENERGY  = 5,
     POLYMW  = 6,
     FOAM  = 7,
-    BRINE = 8
+    BRINE = 8,
+    PRECSALT = 9
     // If you add more entries to this enum, remember to update NUM_PHASES_IN_ENUM below.
 };
 
-constexpr int NUM_PHASES_IN_ENUM = static_cast<int>(Phase::BRINE) + 1;  // Used to get correct size of the bitset in class Phases.
+constexpr int NUM_PHASES_IN_ENUM = static_cast<int>(Phase::PRECSALT) + 1;  // Used to get correct size of the bitset in class Phases.
 
 Phase get_phase( const std::string& );
 std::ostream& operator<<( std::ostream&, const Phase& );
@@ -53,7 +54,7 @@ class Phases {
     public:
         Phases() noexcept = default;
         Phases( bool oil, bool gas, bool wat, bool solvent = false, bool polymer = false, bool energy = false,
-                bool polymw = false, bool foam = false, bool brine = false ) noexcept;
+                bool polymw = false, bool foam = false, bool brine = false, bool precsalt = false ) noexcept;
 
         static Phases serializeObject();
 

opm/parser/eclipse/EclipseState/Tables/PermfactTable.hpp

@@ -0,0 +1,38 @@
+/*
+  Copyright (C) 2020 by Equinor.
+  Copyright (C) 2020 by TNO.
+
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM 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.
+
+  OPM 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 OPM.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef OPM_PARSER_PERMFACT_TABLE_HPP
+#define OPM_PARSER_PERMFACT_TABLE_HPP
+
+#include "SimpleTable.hpp"
+
+namespace Opm {
+
+    class DeckItem;
+
+    class PermfactTable : public SimpleTable {
+    public:
+        PermfactTable( const DeckItem& item );
+
+        const TableColumn& getPorosityChangeColumn() const;
+        const TableColumn& getPermeabilityMultiplierColumn() const;
+    };
+}
+
+#endif

opm/parser/eclipse/EclipseState/Tables/PvtgwTable.hpp

@@ -0,0 +1,40 @@
+/*
+  Copyright (C) 2020 by Equinor
+  Copyright (C) 2020 by TNO
+
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM 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.
+
+  OPM 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 OPM.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef OPM_PARSER_PVTGW_TABLE_HPP
+#define	OPM_PARSER_PVTGW_TABLE_HPP
+
+#include <opm/parser/eclipse/EclipseState/Tables/PvtxTable.hpp>
+
+namespace Opm {
+
+    class DeckKeyword;
+
+    class PvtgwTable : public PvtxTable {
+    public:
+        PvtgwTable() = default;
+        PvtgwTable( const DeckKeyword& keyword, size_t tableIdx);
+        
+        static PvtgwTable serializeObject();
+
+        bool operator==(const PvtgwTable& data) const;
+    };
+}
+
+#endif

opm/parser/eclipse/EclipseState/Tables/PvtgwoTable.hpp

@@ -0,0 +1,40 @@
+/*
+  Copyright (C) 2020 by Equinor
+  Copyright (C) 2020 by TNO
+
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM 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.
+
+  OPM 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 OPM.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef OPM_PARSER_PVTGWO_TABLE_HPP
+#define	OPM_PARSER_PVTGWO_TABLE_HPP
+
+#include <opm/parser/eclipse/EclipseState/Tables/PvtxTable.hpp>
+
+namespace Opm {
+
+    class DeckKeyword;
+
+    class PvtgwoTable : public PvtxTable {
+    public:
+        PvtgwoTable() = default;
+        PvtgwoTable( const DeckKeyword& keyword, size_t tableIdx);
+
+        static PvtgwoTable serializeObject();
+
+        bool operator==(const PvtgwoTable& data) const;
+    };
+}
+
+#endif

opm/parser/eclipse/EclipseState/Tables/RwgsaltTable.hpp

@@ -0,0 +1,58 @@
+/*
+  Copyright (C) 2020 by Equinor
+  Copyright (C) 2020 by TNO
+
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM 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.
+
+  OPM 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 OPM.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef OPM_PARSER_RWGSALT_TABLE_HPP
+#define	OPM_PARSER_RWGSALT_TABLE_HPP
+
+#include <vector>
+
+namespace Opm {
+
+    class DeckKeyword;
+
+    class RwgsaltTable {
+    public:
+        RwgsaltTable();
+
+        static RwgsaltTable serializeObject();
+
+        void init(const Opm::DeckRecord& record1);
+        size_t size() const;
+        std::vector<double> getPressureColumn() const;
+        std::vector<double> getSaltConcentrationColumn() const;
+        std::vector<double> getVaporizedWaterGasRatioColumn() const;
+        const std::vector<double>& getTableValues() const;
+
+        bool operator==(const RwgsaltTable& data) const;
+
+        template<class Serializer>
+        void serializeOp(Serializer& serializer)
+        {
+            serializer(m_tableValues);
+        }
+
+    protected:
+
+        std::vector <double> m_tableValues;
+
+    };
+
+}
+
+#endif

opm/parser/eclipse/EclipseState/Tables/SaltpvdTable.hpp

@@ -0,0 +1,38 @@
+/*
+  Copyright (C) 2020 by Equinor.
+  Copyright (C) 2020 by TNO.
+
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM 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.
+
+  OPM 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 OPM.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef OPM_PARSER_SALTPVD_TABLE_HPP
+#define OPM_PARSER_SALTPVD_TABLE_HPP
+
+#include "SimpleTable.hpp"
+
+namespace Opm {
+
+    class DeckItem;
+
+    class SaltpvdTable : public SimpleTable {
+    public:
+        SaltpvdTable( const DeckItem& item );
+
+        const TableColumn& getDepthColumn() const;
+        const TableColumn& getSaltpColumn() const;
+    };
+}
+
+#endif

opm/parser/eclipse/EclipseState/Tables/TableManager.hpp

@@ -33,12 +33,15 @@
 
 #include <opm/parser/eclipse/EclipseState/Tables/DenT.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/PvtgTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/PvtgwTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/PvtgwoTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/PvtoTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/RocktabTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/Rock2dTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/Rock2dtrTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/PlyshlogTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/PvtwsaltTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/RwgsaltTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/BrineDensityTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/SolventDensityTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/StandardCond.hpp>
@@ -97,6 +100,8 @@ namespace Opm {
         const TableContainer& getPbvdTables() const;
         const TableContainer& getPdvdTables() const;
         const TableContainer& getSaltvdTables() const;
+        const TableContainer& getSaltpvdTables() const;
+        const TableContainer& getPermfactTables() const;
         const TableContainer& getEnkrvdTables() const;
         const TableContainer& getEnptvdTables() const;
         const TableContainer& getImkrvdTables() const;
@@ -131,6 +136,8 @@ namespace Opm {
         const JFunc& getJFunc() const;
 
         const std::vector<PvtgTable>& getPvtgTables() const;
+        const std::vector<PvtgwTable>& getPvtgwTables() const;
+        const std::vector<PvtgwoTable>& getPvtgwoTables() const;
         const std::vector<PvtoTable>& getPvtoTables() const;
         const std::vector<Rock2dTable>& getRock2dTables() const;
         const std::vector<Rock2dtrTable>& getRock2dtrTables() const;
@@ -144,6 +151,7 @@ namespace Opm {
         std::size_t gas_comp_index() const;
         const PvtwTable& getPvtwTable() const;
         const std::vector<PvtwsaltTable>& getPvtwSaltTables() const;
+        const std::vector<RwgsaltTable>& getRwgSaltTables() const;
         const std::vector<BrineDensityTable>& getBrineDensityTables() const;
         const std::vector<SolventDensityTable>& getSolventDensityTables() const;
 
@@ -192,6 +200,8 @@ namespace Opm {
             serializer(split.rockMax);
             serializer.map(split.rockMap);
             serializer.vector(m_pvtgTables);
+            serializer.vector(m_pvtgwTables);
+            serializer.vector(m_pvtgwoTables);
             serializer.vector(m_pvtoTables);
             serializer.vector(m_rock2dTables);
             serializer.vector(m_rock2dtrTables);
@@ -207,6 +217,7 @@ namespace Opm {
             m_viscrefTable.serializeOp(serializer);
             m_watdentTable.serializeOp(serializer);
             serializer.vector(m_pvtwsaltTables);
+            serializer.vector(m_rwgsaltTables);
             serializer.vector(m_bdensityTables);
             serializer.vector(m_sdensityTables);
             serializer.map(m_plymwinjTables);
@@ -320,6 +331,23 @@ namespace Opm {
             assert(regionIdx == numTables);
         }
 
+        template <class TableType>
+        void initRwgsaltTables(const Deck& deck,  std::vector<TableType>& rwgtables ) {
+
+            size_t numTables = m_tabdims.getNumPVTTables();
+            rwgtables.resize(numTables);
+
+            const auto& keyword = deck.getKeyword("RWGSALT");
+            size_t numEntries = keyword.size();
+            size_t regionIdx = 0;
+            for (unsigned lineIdx = 0; lineIdx < numEntries; lineIdx += 2) {
+                rwgtables[regionIdx].init(keyword.getRecord(lineIdx+1));
+                ++regionIdx;
+            }
+            assert(regionIdx == numTables);
+        }
+
+
         template <class TableType>
         void initBrineTables(const Deck& deck,  std::vector<TableType>& brinetables ) {
 
@@ -464,6 +492,8 @@ namespace Opm {
 
         std::map<std::string , TableContainer> m_simpleTables;
         std::vector<PvtgTable> m_pvtgTables;
+        std::vector<PvtgwTable> m_pvtgwTables;
+        std::vector<PvtgwoTable> m_pvtgwoTables;
         std::vector<PvtoTable> m_pvtoTables;
         std::vector<Rock2dTable> m_rock2dTables;
         std::vector<Rock2dtrTable> m_rock2dtrTables;
@@ -479,6 +509,7 @@ namespace Opm {
         ViscrefTable m_viscrefTable;
         WatdentTable m_watdentTable;
         std::vector<PvtwsaltTable> m_pvtwsaltTables;
+        std::vector<RwgsaltTable> m_rwgsaltTables;
         std::vector<BrineDensityTable> m_bdensityTables;
         std::vector<SolventDensityTable> m_sdensityTables;
         std::map<int, PlymwinjTable> m_plymwinjTables;

src/opm/parser/eclipse/EclipseState/Runspec.cpp

@@ -38,6 +38,7 @@ Phase get_phase( const std::string& str ) {
     if( str == "POLYMW" ) return Phase::POLYMW;
     if( str == "FOAM" ) return Phase::FOAM;
     if( str == "BRINE" ) return Phase::BRINE;
+    if( str == "PRECSALT" ) return Phase::PRECSALT;
 
     throw std::invalid_argument( "Unknown phase '" + str + "'" );
 }
@@ -53,6 +54,7 @@ std::ostream& operator<<( std::ostream& stream, const Phase& p ) {
         case Phase::POLYMW:  return stream << "POLYMW";
         case Phase::FOAM:    return stream << "FOAM";
         case Phase::BRINE:   return stream << "BRINE";
+        case Phase::PRECSALT:   return stream << "PRECSALT";
 
     }
 
@@ -61,7 +63,7 @@ std::ostream& operator<<( std::ostream& stream, const Phase& p ) {
 
 using un = std::underlying_type< Phase >::type;
 
-Phases::Phases( bool oil, bool gas, bool wat, bool sol, bool pol, bool energy, bool polymw, bool foam, bool brine) noexcept :
+Phases::Phases( bool oil, bool gas, bool wat, bool sol, bool pol, bool energy, bool polymw, bool foam, bool brine, bool precsalt) noexcept :
     bits( (oil ? (1 << static_cast< un >( Phase::OIL ) )     : 0) |
           (gas ? (1 << static_cast< un >( Phase::GAS ) )     : 0) |
           (wat ? (1 << static_cast< un >( Phase::WATER ) )   : 0) |
@@ -70,7 +72,8 @@ Phases::Phases( bool oil, bool gas, bool wat, bool sol, bool pol, bool energy, b
           (energy ? (1 << static_cast< un >( Phase::ENERGY ) ) : 0) |
           (polymw ? (1 << static_cast< un >( Phase::POLYMW ) ) : 0) |
           (foam ? (1 << static_cast< un >( Phase::FOAM ) ) : 0) |
-          (brine ? (1 << static_cast< un >( Phase::BRINE ) ) : 0) )
+          (brine ? (1 << static_cast< un >( Phase::BRINE ) ) : 0) |
+          (precsalt ? (1 << static_cast< un >( Phase::PRECSALT ) ) : 0) )
 
 {}
 
@@ -303,7 +306,8 @@ Runspec::Runspec( const Deck& deck ) :
                            deck.hasKeyword( "THERMAL" ),
                            deck.hasKeyword( "POLYMW"  ),
                            deck.hasKeyword( "FOAM" ),
-                           deck.hasKeyword( "BRINE" ) ) ),
+                           deck.hasKeyword( "BRINE" ),
+                           deck.hasKeyword( "PRECSALT" ) ) ),
     m_tabdims( deck ),
     endscale( deck ),
     welldims( deck ),

src/opm/parser/eclipse/EclipseState/Tables/RwgsaltTable.cpp

@@ -0,0 +1,99 @@
+/*
+  Copyright (C) 2020 by Equinor
+  Copyright (C) 2020 by TNO
+
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM 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.
+
+  OPM 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 OPM.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <vector>
+#include <opm/parser/eclipse/Deck/DeckItem.hpp>
+#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
+#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/RwgsaltTable.hpp>
+
+namespace Opm {
+
+        static const size_t numEntries = 3;
+        RwgsaltTable::RwgsaltTable()
+        {
+        }
+
+        RwgsaltTable RwgsaltTable::serializeObject()
+        {
+            RwgsaltTable result;
+            result.m_tableValues = {1.0, 2.0, 3.0};
+
+            return result;
+        }
+
+        void RwgsaltTable::init(const Opm::DeckRecord& record1)
+        {
+            m_tableValues = record1.getItem("DATA").getSIDoubleData();
+        }
+
+        size_t RwgsaltTable::size() const
+        {
+            return m_tableValues.size()/numEntries;
+        }
+
+        const std::vector<double>& RwgsaltTable::getTableValues() const
+        {
+            return m_tableValues;
+        }
+
+        std::vector<double> RwgsaltTable::getPressureColumn() const
+        {
+            size_t tableindex = 0;
+            std::vector<double> pressure(this->size());
+            for(size_t i=0; i<this->size(); ++i){
+                pressure[i] = m_tableValues[tableindex];
+                tableindex = tableindex+numEntries;
+            }
+            return pressure;
+
+        }
+
+        std::vector<double> RwgsaltTable::getSaltConcentrationColumn() const
+        {
+            size_t tableindex = 0;
+            std::vector<double> saltConc(this->size());
+            for(size_t i=0; i<this->size(); ++i){
+                saltConc[i] = m_tableValues[tableindex];
+                tableindex = tableindex+numEntries;
+            }
+            return saltConc;
+
+        }
+
+        std::vector<double> RwgsaltTable::getVaporizedWaterGasRatioColumn() const
+        {
+            size_t tableindex = 1;
+            std::vector<double> vaporizedwatergasratio(this->size());
+            for(size_t i=0; i<this->size(); ++i){
+                vaporizedwatergasratio[i] = m_tableValues[tableindex];
+                tableindex = tableindex+numEntries;
+            }
+            return vaporizedwatergasratio;
+
+        }       
+
+        bool RwgsaltTable::operator==(const RwgsaltTable& data) const
+        {
+            return m_tableValues == data.m_tableValues;
+        }
+
+}
+

src/opm/parser/eclipse/EclipseState/Tables/TableManager.cpp

@@ -66,7 +66,9 @@
 #include <opm/parser/eclipse/EclipseState/Tables/PdvdTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/RtempvdTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/RvvdTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/PermfactTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/SaltvdTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/SaltpvdTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/SgcwmisTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/SgfnTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/SgofTable.hpp>
@@ -113,6 +115,8 @@ namespace Opm {
         initDims( deck );
         initSimpleTables( deck );
         initFullTables(deck, "PVTG", m_pvtgTables);
+        initFullTables(deck, "PVTGW", m_pvtgwTables);
+        initFullTables(deck, "PVTGWO", m_pvtgwoTables);
         initFullTables(deck, "PVTO", m_pvtoTables);
 
         if( deck.hasKeyword( "PVTW" ) )
@@ -147,6 +151,9 @@ namespace Opm {
         if ( deck.hasKeyword( "PVTWSALT") )
             initPvtwsaltTables(deck, m_pvtwsaltTables );
 
+        if ( deck.hasKeyword( "RWGSALT") )
+            initRwgsaltTables(deck, m_rwgsaltTables );
+
         if ( deck.hasKeyword( "BDENSITY") )
             initBrineTables(deck, m_bdensityTables );
 
@@ -198,6 +205,8 @@ namespace Opm {
     TableManager& TableManager::operator=(const TableManager& data) {
         m_simpleTables = data.m_simpleTables;
         m_pvtgTables = data.m_pvtgTables;
+        m_pvtgwTables = data.m_pvtgwTables;
+        m_pvtgwoTables = data.m_pvtgwoTables;
         m_pvtoTables = data.m_pvtoTables;
         m_rock2dTables = data.m_rock2dTables;
         m_rock2dtrTables = data.m_rock2dtrTables;
@@ -212,6 +221,7 @@ namespace Opm {
         m_viscrefTable = data.m_viscrefTable;
         m_watdentTable = data.m_watdentTable;
         m_pvtwsaltTables = data.m_pvtwsaltTables;
+        m_rwgsaltTables = data.m_rwgsaltTables;
         m_bdensityTables = data.m_bdensityTables;
         m_sdensityTables = data.m_sdensityTables;
         m_plymwinjTables = data.m_plymwinjTables;
@@ -242,6 +252,8 @@ namespace Opm {
         TableManager result;
         result.m_simpleTables = {{"test", TableContainer::serializeObject()}};
         result.m_pvtgTables = {PvtgTable::serializeObject()};
+        result.m_pvtgwTables = {PvtgwTable::serializeObject()};
+        result.m_pvtgwoTables = {PvtgwoTable::serializeObject()};
         result.m_pvtoTables = {PvtoTable::serializeObject()};
         result.m_rock2dTables = {Rock2dTable::serializeObject()};
         result.m_rock2dtrTables = {Rock2dtrTable::serializeObject()};
@@ -257,6 +269,7 @@ namespace Opm {
         result.m_viscrefTable = ViscrefTable::serializeObject();
         result.m_watdentTable = WatdentTable::serializeObject();
         result.m_pvtwsaltTables = {PvtwsaltTable::serializeObject()};
+        result.m_rwgsaltTables = {RwgsaltTable::serializeObject()};
         result.m_bdensityTables = {BrineDensityTable::serializeObject()};
         result.m_sdensityTables = {SolventDensityTable::serializeObject()};
         result.m_plymwinjTables = {{1, Opm::PlymwinjTable::serializeObject()}};
@@ -399,6 +412,8 @@ namespace Opm {
         addTables( "PBVD", m_eqldims.getNumEquilRegions());
         addTables( "PDVD", m_eqldims.getNumEquilRegions());
         addTables( "SALTVD", m_eqldims.getNumEquilRegions());
+        addTables( "SALTPVD", m_eqldims.getNumEquilRegions());
+        addTables( "PERMFACT", m_eqldims.getNumEquilRegions());
 
         addTables( "AQUTAB", m_aqudims.getNumInfluenceTablesCT());
         {
@@ -462,6 +477,8 @@ namespace Opm {
         initSimpleTableContainer<PbvdTable>(deck, "PBVD" , m_eqldims.getNumEquilRegions());
         initSimpleTableContainer<PdvdTable>(deck, "PDVD" , m_eqldims.getNumEquilRegions());
         initSimpleTableContainer<SaltvdTable>(deck, "SALTVD" , m_eqldims.getNumEquilRegions());
+        initSimpleTableContainer<SaltvdTable>(deck, "SALTRVD" , m_eqldims.getNumEquilRegions());
+        initSimpleTableContainer<SaltvdTable>(deck, "PERMFACT" , m_eqldims.getNumEquilRegions());
         initSimpleTableContainer<AqutabTable>(deck, "AQUTAB" , m_aqudims.getNumInfluenceTablesCT());
         {
             size_t numEndScaleTables = ParserKeywords::ENDSCALE::NUM_TABLES::defaultValue;
@@ -846,6 +863,14 @@ namespace Opm {
         return getTables("SALTVD");
     }
 
+    const TableContainer& TableManager::getSaltpvdTables() const {
+        return getTables("SALTPVD");
+    }
+
+    const TableContainer& TableManager::getPermfactTables() const {
+        return getTables("PERMFACT");
+    }
+
     const TableContainer& TableManager::getEnkrvdTables() const {
         return getTables("ENKRVD");
     }
@@ -944,6 +969,14 @@ namespace Opm {
         return m_pvtgTables;
     }
 
+    const std::vector<PvtgwTable>& TableManager::getPvtgwTables() const {
+        return m_pvtgwTables;
+    }
+
+    const std::vector<PvtgwoTable>& TableManager::getPvtgwoTables() const {
+        return m_pvtgwoTables;
+    }
+
     const std::vector<PvtoTable>& TableManager::getPvtoTables() const {
         return m_pvtoTables;
     }
@@ -972,6 +1005,10 @@ namespace Opm {
         return this->m_pvtwsaltTables;
     }
 
+    const std::vector<RwgsaltTable>& TableManager::getRwgSaltTables() const {
+        return this->m_rwgsaltTables;
+    }
+
     const std::vector<BrineDensityTable>& TableManager::getBrineDensityTables() const {
         return this->m_bdensityTables;
     }
@@ -1111,6 +1148,8 @@ namespace Opm {
 
         return m_simpleTables == data.m_simpleTables &&
                m_pvtgTables == data.m_pvtgTables &&
+               m_pvtgwTables == data.m_pvtgwTables &&
+               m_pvtgwoTables == data.m_pvtgwoTables &&
                m_pvtoTables == data.m_pvtoTables &&
                m_rock2dTables == data.m_rock2dTables &&
                m_rock2dtrTables == data.m_rock2dtrTables &&
@@ -1125,6 +1164,7 @@ namespace Opm {
                m_viscrefTable == data.m_viscrefTable &&
                m_watdentTable == data.m_watdentTable &&
                m_pvtwsaltTables == data.m_pvtwsaltTables &&
+               m_rwgsaltTables == data.m_rwgsaltTables &&
                m_bdensityTables == data.m_bdensityTables &&
                m_sdensityTables == data.m_sdensityTables &&
                m_plymwinjTables == data.m_plymwinjTables &&

src/opm/parser/eclipse/EclipseState/Tables/Tables.cpp

@@ -52,6 +52,8 @@
 #include <opm/parser/eclipse/EclipseState/Tables/PvdoTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/PvdsTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/PvtgTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/PvtgwTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/PvtgwoTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/PvtoTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/RocktabTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/RockwnodTable.hpp>
@@ -61,7 +63,9 @@
 #include <opm/parser/eclipse/EclipseState/Tables/RvvdTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/PbvdTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/PdvdTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/PermfactTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/SaltvdTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/SaltpvdTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/SgcwmisTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/SgfnTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/SgofTable.hpp>
@@ -108,6 +112,60 @@ bool PvtgTable::operator==(const PvtgTable& data) const {
     return static_cast<const PvtxTable&>(*this) == static_cast<const PvtxTable&>(data);
 }
 
+PvtgwTable::PvtgwTable( const DeckKeyword& keyword, size_t tableIdx ) :
+    PvtxTable("P") {
+
+        m_underSaturatedSchema.addColumn( ColumnSchema( "RW"  , Table::STRICTLY_DECREASING , Table::DEFAULT_NONE ));
+        m_underSaturatedSchema.addColumn( ColumnSchema( "BG"  , Table::RANDOM , Table::DEFAULT_LINEAR ));
+        m_underSaturatedSchema.addColumn( ColumnSchema( "MUG" , Table::RANDOM , Table::DEFAULT_LINEAR ));
+
+        m_saturatedSchema.addColumn( ColumnSchema( "PG"  , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ));
+        m_saturatedSchema.addColumn( ColumnSchema( "RW"  , Table::RANDOM , Table::DEFAULT_NONE ));
+        m_saturatedSchema.addColumn( ColumnSchema( "BG"  , Table::RANDOM , Table::DEFAULT_LINEAR ));
+        m_saturatedSchema.addColumn( ColumnSchema( "MUG" , Table::RANDOM , Table::DEFAULT_LINEAR ));
+
+        PvtxTable::init(keyword, tableIdx);
+    }
+
+PvtgwTable PvtgwTable::serializeObject() {
+    PvtgwTable result;
+    static_cast<PvtxTable&>(result) = PvtxTable::serializeObject();
+
+    return result;
+}
+
+bool PvtgwTable::operator==(const PvtgwTable& data) const {
+    return static_cast<const PvtxTable&>(*this) == static_cast<const PvtxTable&>(data);
+}
+
+PvtgwoTable::PvtgwoTable( const DeckKeyword& keyword, size_t tableIdx ) :
+    PvtxTable("P") {
+
+        m_underSaturatedSchema.addColumn( ColumnSchema( "RV"  , Table::STRICTLY_DECREASING , Table::DEFAULT_NONE ));
+        m_underSaturatedSchema.addColumn( ColumnSchema( "RW"  , Table::STRICTLY_DECREASING , Table::DEFAULT_NONE ));
+        m_underSaturatedSchema.addColumn( ColumnSchema( "BG"  , Table::RANDOM , Table::DEFAULT_LINEAR ));
+        m_underSaturatedSchema.addColumn( ColumnSchema( "MUG" , Table::RANDOM , Table::DEFAULT_LINEAR ));
+
+        m_saturatedSchema.addColumn( ColumnSchema( "PG"  , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ));
+        m_saturatedSchema.addColumn( ColumnSchema( "RV"  , Table::RANDOM , Table::DEFAULT_NONE ));
+        m_saturatedSchema.addColumn( ColumnSchema( "RW"  , Table::RANDOM , Table::DEFAULT_NONE ));
+        m_saturatedSchema.addColumn( ColumnSchema( "BG"  , Table::RANDOM , Table::DEFAULT_LINEAR ));
+        m_saturatedSchema.addColumn( ColumnSchema( "MUG" , Table::RANDOM , Table::DEFAULT_LINEAR ));
+
+        PvtxTable::init(keyword, tableIdx);
+    }
+
+PvtgwoTable PvtgwoTable::serializeObject() {
+    PvtgwoTable result;
+    static_cast<PvtxTable&>(result) = PvtxTable::serializeObject();
+
+    return result;
+}
+
+bool PvtgwoTable::operator==(const PvtgwoTable& data) const {
+    return static_cast<const PvtxTable&>(*this) == static_cast<const PvtxTable&>(data);
+}
+
 PvtoTable::PvtoTable( const DeckKeyword& keyword, size_t tableIdx) :
     PvtxTable("RS") {
         m_underSaturatedSchema.addColumn( ColumnSchema( "P"  , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ));
@@ -943,6 +1001,37 @@ const TableColumn& SaltvdTable::getSaltColumn() const {
     return SimpleTable::getColumn(1); 
 }
 
+SaltpvdTable::SaltpvdTable( const DeckItem& item ) {
+    m_schema.addColumn( ColumnSchema( "DEPTH" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ));
+    m_schema.addColumn( ColumnSchema( "SALTP" , Table::RANDOM , Table::DEFAULT_NONE ));
+
+    SimpleTable::init(item);
+}
+
+const TableColumn& SaltpvdTable::getDepthColumn() const {
+    return SimpleTable::getColumn(0);
+}
+
+const TableColumn& SaltpvdTable::getSaltpColumn() const {
+    return SimpleTable::getColumn(1); 
+}
+
+PermfactTable::PermfactTable( const DeckItem& item ) {
+    m_schema.addColumn( ColumnSchema( "POROSITYCHANGE" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ));
+    m_schema.addColumn( ColumnSchema( "PERMEABILIYMULTIPLIER" , Table::RANDOM , Table::DEFAULT_NONE ));
+
+    SimpleTable::init(item);
+}
+
+const TableColumn& PermfactTable::getPorosityChangeColumn() const {
+    return SimpleTable::getColumn(0);
+}
+
+const TableColumn& PermfactTable::getPermeabilityMultiplierColumn() const {
+    return SimpleTable::getColumn(1); 
+}
+
+
 AqutabTable::AqutabTable( const DeckItem& item ) {
     m_schema.addColumn( ColumnSchema( "TD" ,  Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ) );
     m_schema.addColumn( ColumnSchema( "PD"    ,  Table::RANDOM , Table::DEFAULT_LINEAR ) );

tests/parser/SaltTableTests.cpp

@@ -29,7 +29,10 @@
 // generic table classes
 #include <opm/parser/eclipse/EclipseState/Tables/SimpleTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/PvtwsaltTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/RwgsaltTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/SaltvdTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/SaltpvdTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/PermfactTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/TableManager.hpp>
 
 // keyword specific table classes
@@ -53,26 +56,40 @@ BOOST_AUTO_TEST_CASE( Brine ) {
         "1 1/\n"
         "\n"
         "PVTWSALT\n"
-        " 1000/\n"
+        " 1000 0.0/\n"
         " 0 1 2 3 4 \n"
         " 10 11 12 13 14/\n"
-        " \n"
+        "\n"  
+        "RWGSALT\n"
+        " 300 0.0 0.00013/ \n"
+        " 600 0.5 0.000132/ \n"
+        "/ \n"  
+        "PERMFACT\n"
+        "0 0 \n"
+        "0.5 0.5 \n"
+        "1 1 \n"
+        "1.5 1.5/\n"
+        "\n"
         "BDENSITY\n"
         " 1000 1050 /\n"
         "\n"
         "EQLDIMS\n"
         "1 /\n"
         "\n"
-    "SALTVD\n"
-    "500 0\n"
-    "550 50/\n";
+        "SALTVD\n"
+        "500 0\n"
+        "550 50/\n"
+        "\n"
+        "SALTPVD\n"
+        "500 0\n"
+        "550 0.5/\n";
 
     Opm::Parser parser;
     auto deck = parser.parseString(deckData);
 
     Opm::TableManager tables(deck);
     const auto& PvtwsaltTables = tables.getPvtwSaltTables( );
-    BOOST_CHECK_EQUAL( 1 , PvtwsaltTables.size() );
+    BOOST_CHECK_EQUAL(1 , PvtwsaltTables.size() );
     BOOST_CHECK_EQUAL(2, PvtwsaltTables[0].size());
 
     const auto& PvtwsaltTable1 = PvtwsaltTables[0];
@@ -89,6 +106,21 @@ BOOST_AUTO_TEST_CASE( Brine ) {
     BOOST_CHECK_CLOSE (PvtwsaltTable1.getViscosityColumn()[1], 13*0.001, 1e-5);
 
     BOOST_CHECK_CLOSE (PvtwsaltTable1.getReferencePressureValue(), 1000*1e5, 1e-5);
+ 
+    const auto& RwgsaltTables = tables.getRwgSaltTables( );
+    BOOST_CHECK_EQUAL(2 , RwgsaltTables.size() );
+    BOOST_CHECK_EQUAL(3, RwgsaltTables[0].size());
+
+    const auto& RwgsaltTable1 = RwgsaltTables[0];
+
+     BOOST_CHECK_EQUAL (RwgsaltTable1.getPressureColumn().size(), 2);
+    BOOST_CHECK_CLOSE (RwgsaltTable1.getPressureColumn()[1], 600, 1e-5);
+
+    BOOST_CHECK_EQUAL (RwgsaltTable1.getSaltConcentrationColumn().size(), 2);
+    BOOST_CHECK_CLOSE (RwgsaltTable1.getSaltConcentrationColumn()[1], 0.5, 1e-5);
+
+    BOOST_CHECK_EQUAL (RwgsaltTable1.getVaporizedWaterGasRatioColumn().size(), 2);
+    BOOST_CHECK_CLOSE (RwgsaltTable1.getVaporizedWaterGasRatioColumn()[0], 0.00013, 1e-5); 
 
     const auto& BdensityTables = tables.getBrineDensityTables( );
     const auto& BdensityTable1 = BdensityTables[0];
@@ -100,9 +132,21 @@ BOOST_AUTO_TEST_CASE( Brine ) {
     const Opm::TableContainer& saltvdTables = tables.getSaltvdTables();
     const auto& saltvdTable = saltvdTables.getTable<Opm::SaltvdTable>(0);
 
-    BOOST_CHECK_EQUAL(saltvdTable.getDepthColumn() .size(), 2);
+    BOOST_CHECK_EQUAL(saltvdTable.getDepthColumn().size(), 2);
     BOOST_CHECK_CLOSE (saltvdTable.getSaltColumn() [1],50, 1e-5);
 
+    const Opm::TableContainer& saltpvdTables = tables.getSaltpvdTables();
+    const auto& saltpvdTable = saltpvdTables.getTable<Opm::SaltpvdTable>(0);
+
+    BOOST_CHECK_EQUAL(saltpvdTable.getDepthColumn().size(), 2);
+    BOOST_CHECK_CLOSE(saltpvdTable.getSaltpColumn() [1],0.5, 1e-5);
+
+    const Opm::TableContainer& permfactTables = tables.getPermfactTables();
+    const auto& permfactTable = permfactTables.getTable<Opm::PermfactTable>(0);
+
+    BOOST_CHECK_EQUAL(permfactTable.getPorosityChangeColumn().size(), 4);
+    BOOST_CHECK_CLOSE(permfactTable.getPermeabilityMultiplierColumn() [1],1.5, 1e-5);
+
 
 }