Merge pull request #2244 from akva2/noecl_flush

More MPI serialization support
2026-07-30 02:37:57 -05:00 · 2019-12-19 10:25:33 +01:00
parent 2511121a84 5b5dddd64c
commit 527ee4faa8
3 changed files with 398 additions and 1 deletions
@@ -33,16 +33,24 @@
 #include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
 #include <opm/parser/eclipse/EclipseState/SimulationConfig/SimulationConfig.hpp>
 #include <opm/parser/eclipse/EclipseState/SimulationConfig/ThresholdPressure.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/Aqudims.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/ColumnSchema.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/Eqldims.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/FlatTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/JFunc.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/PlymwinjTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/PolyInjTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/PvtgTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/PvtoTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/Regdims.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/Rock2dTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/Rock2dtrTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/SimpleTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/SkprpolyTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/SkprwatTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/TableColumn.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/TableContainer.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/TableManager.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/TableSchema.hpp>
 #include <dune/common/parallel/mpitraits.hh>

@@ -205,17 +213,21 @@ std::size_t packSize(const std::unordered_map<T1,T2,H,P,A>& data, Dune::MPIHelpe
 }

 HANDLE_AS_POD(Actdims)
+HANDLE_AS_POD(Aqudims)
 HANDLE_AS_POD(data::Connection)
 HANDLE_AS_POD(data::Rates)
 HANDLE_AS_POD(data::Segment)
 HANDLE_AS_POD(DENSITYRecord)
 HANDLE_AS_POD(EclHysterConfig)
+HANDLE_AS_POD(Eqldims)
 HANDLE_AS_POD(EquilRecord)
 HANDLE_AS_POD(FoamData)
 HANDLE_AS_POD(JFunc)
-HANDLE_AS_POD(RestartSchedule)
 HANDLE_AS_POD(PVTWRecord)
 HANDLE_AS_POD(PVCDORecord)
+HANDLE_AS_POD(Regdims)
+HANDLE_AS_POD(RestartSchedule)
+HANDLE_AS_POD(ROCKRecord)
 HANDLE_AS_POD(Tabdims)
 HANDLE_AS_POD(TimeMap::StepData)
 HANDLE_AS_POD(VISCREFRecord)
@@ -477,6 +489,63 @@ std::size_t packSize(const WatdentTable& data, Dune::MPIHelper::MPICommunicator
    return packSize(static_cast<const std::vector<WATDENTRecord>&>(data), comm);
 }

+std::size_t packSize(const PolyInjTable& data, Dune::MPIHelper::MPICommunicator comm)
+{
+    return packSize(data.getThroughputs(), comm) +
+           packSize(data.getVelocities(), comm) +
+           packSize(data.getTableNumber(), comm) +
+           packSize(data.getTableData(), comm);
+}
+
+std::size_t packSize(const PlymwinjTable& data, Dune::MPIHelper::MPICommunicator comm)
+{
+    return packSize(static_cast<const PolyInjTable&>(data), comm);
+}
+
+std::size_t packSize(const SkprpolyTable& data, Dune::MPIHelper::MPICommunicator comm)
+{
+    return packSize(static_cast<const PolyInjTable&>(data), comm) +
+           packSize(data.referenceConcentration(), comm);
+}
+
+std::size_t packSize(const SkprwatTable& data, Dune::MPIHelper::MPICommunicator comm)
+{
+    return packSize(static_cast<const PolyInjTable&>(data), comm);
+}
+
+std::size_t packSize(const RockTable& data, Dune::MPIHelper::MPICommunicator comm)
+{
+    return packSize(static_cast<const std::vector<ROCKRecord>&>(data), comm);
+}
+
+std::size_t packSize(const TableManager& data, Dune::MPIHelper::MPICommunicator comm)
+{
+    return packSize(data.getSimpleTables(), comm) +
+           packSize(data.getPvtgTables(), comm) +
+           packSize(data.getPvtoTables(), comm) +
+           packSize(data.getRock2dTables(), comm) +
+           packSize(data.getRock2dtrTables(), comm) +
+           packSize(data.getPvtwTable(), comm) +
+           packSize(data.getPvcdoTable(), comm) +
+           packSize(data.getDensityTable(), comm) +
+           packSize(data.getRockTable(), comm) +
+           packSize(data.getViscrefTable(), comm) +
+           packSize(data.getWatdentTable(), comm) +
+           packSize(data.getPlymwinjTables(), comm) +
+           packSize(data.getSkprwatTables(), comm) +
+           packSize(data.getSkprpolyTables(), comm) +
+           packSize(data.getTabdims(), comm) +
+           packSize(data.getRegdims(), comm) +
+           packSize(data.getEqldims(), comm) +
+           packSize(data.getAqudims(), comm) +
+           packSize(data.useImptvd(), comm) +
+           packSize(data.useEnptvd(), comm) +
+           packSize(data.useEqlnum(), comm) +
+           packSize(data.useJFunc(), comm) +
+           (data.useJFunc() ? packSize(data.getJFunc(), comm) : 0) +
+           packSize(data.rtemp(), comm);
+}
+
 ////// pack routines

 template<class T>
@@ -940,6 +1009,70 @@ void pack(const WatdentTable& data, std::vector<char>& buffer, int& position,
    pack(static_cast<const std::vector<WATDENTRecord>&>(data), buffer, position, comm);
 }

+void pack(const PolyInjTable& data, std::vector<char>& buffer, int& position,
+          Dune::MPIHelper::MPICommunicator comm)
+{
+    pack(data.getThroughputs(), buffer, position, comm);
+    pack(data.getVelocities(), buffer, position, comm);
+    pack(data.getTableNumber(), buffer, position, comm);
+    pack(data.getTableData(), buffer, position, comm);
+}
+
+void pack(const PlymwinjTable& data, std::vector<char>& buffer, int& position,
+          Dune::MPIHelper::MPICommunicator comm)
+{
+    pack(static_cast<const PolyInjTable&>(data), buffer, position, comm);
+}
+
+void pack(const SkprpolyTable& data, std::vector<char>& buffer, int& position,
+          Dune::MPIHelper::MPICommunicator comm)
+{
+    pack(static_cast<const PolyInjTable&>(data), buffer, position, comm);
+    pack(data.referenceConcentration(), buffer, position, comm);
+}
+
+void pack(const SkprwatTable& data, std::vector<char>& buffer, int& position,
+          Dune::MPIHelper::MPICommunicator comm)
+{
+    pack(static_cast<const PolyInjTable&>(data), buffer, position, comm);
+}
+
+void pack(const RockTable& data, std::vector<char>& buffer, int& position,
+          Dune::MPIHelper::MPICommunicator comm)
+{
+    pack(static_cast<const std::vector<ROCKRecord>&>(data), buffer, position, comm);
+}
+
+void pack(const TableManager& data, std::vector<char>& buffer, int& position,
+          Dune::MPIHelper::MPICommunicator comm)
+{
+    pack(data.getSimpleTables(), buffer, position, comm);
+    pack(data.getPvtgTables(), buffer, position, comm);
+    pack(data.getPvtoTables(), buffer, position, comm);
+    pack(data.getRock2dTables(), buffer, position, comm);
+    pack(data.getRock2dtrTables(), buffer, position, comm);
+    pack(data.getPvtwTable(), buffer, position, comm);
+    pack(data.getPvcdoTable(), buffer, position, comm);
+    pack(data.getDensityTable(), buffer, position, comm);
+    pack(data.getRockTable(), buffer, position, comm);
+    pack(data.getViscrefTable(), buffer, position, comm);
+    pack(data.getWatdentTable(), buffer, position, comm);
+    pack(data.getPlymwinjTables(), buffer, position, comm);
+    pack(data.getSkprwatTables(), buffer, position, comm);
+    pack(data.getSkprpolyTables(), buffer, position, comm);
+    pack(data.getTabdims(), buffer, position, comm);
+    pack(data.getRegdims(), buffer, position, comm);
+    pack(data.getEqldims(), buffer, position, comm);
+    pack(data.getAqudims(), buffer, position, comm);
+    pack(data.useImptvd(), buffer, position, comm);
+    pack(data.useEnptvd(), buffer, position, comm);
+    pack(data.useEqlnum(), buffer, position, comm);
+    pack(data.useJFunc(), buffer, position, comm);
+    if (data.useJFunc())
+        pack(data.getJFunc(), buffer, position, comm);
+    pack(data.rtemp(), buffer, position, comm);
+}
+
 /// unpack routines

 template<class T>
@@ -1524,6 +1657,109 @@ void unpack(WatdentTable& data, std::vector<char>& buffer, int& position,
    data = WatdentTable(pdata);
 }

+void unpack(PolyInjTable& data, std::vector<char>& buffer, int& position,
+            Dune::MPIHelper::MPICommunicator comm)
+{
+    std::vector<double> throughputs, velocities;
+    int tableNumber;
+    std::vector<std::vector<double>> tableData;
+    unpack(throughputs, buffer, position, comm);
+    unpack(velocities, buffer, position, comm);
+    unpack(tableNumber, buffer, position, comm);
+    unpack(tableData, buffer, position, comm);
+    data = PolyInjTable(throughputs, velocities, tableNumber, tableData);
+}
+
+void unpack(PlymwinjTable& data, std::vector<char>& buffer, int& position,
+            Dune::MPIHelper::MPICommunicator comm)
+{
+    unpack(static_cast<PolyInjTable&>(data), buffer, position, comm);
+}
+
+void unpack(SkprpolyTable& data, std::vector<char>& buffer, int& position,
+            Dune::MPIHelper::MPICommunicator comm)
+{
+    unpack(static_cast<PolyInjTable&>(data), buffer, position, comm);
+    double refConcentration;
+    unpack(refConcentration, buffer, position, comm);
+    data.setReferenceConcentration(refConcentration);
+}
+
+void unpack(SkprwatTable& data, std::vector<char>& buffer, int& position,
+            Dune::MPIHelper::MPICommunicator comm)
+{
+    unpack(static_cast<PolyInjTable&>(data), buffer, position, comm);
+}
+
+void unpack(RockTable& data, std::vector<char>& buffer, int& position,
+            Dune::MPIHelper::MPICommunicator comm)
+{
+    std::vector<ROCKRecord> pdata;
+    unpack(pdata, buffer, position, comm);
+    data = RockTable(pdata);
+}
+
+void unpack(TableManager& data, std::vector<char>& buffer, int& position,
+          Dune::MPIHelper::MPICommunicator comm)
+{
+    std::map<std::string, TableContainer> simpleTables;
+    std::vector<PvtgTable> pvtgTables;
+    std::vector<PvtoTable> pvtoTables;
+    std::vector<Rock2dTable> rock2dTables;
+    std::vector<Rock2dtrTable> rock2dtrTables;
+    PvtwTable pvtwTable;
+    PvcdoTable pvcdoTable;
+    DensityTable densityTable;
+    RockTable rockTable;
+    ViscrefTable viscrefTable;
+    WatdentTable watdentTable;
+    std::map<int, PlymwinjTable> plymwinjTables;
+    std::map<int, SkprwatTable> skprwatTables;
+    std::map<int, SkprpolyTable> skprpolyTables;
+    Tabdims tabdims;
+    Regdims regdims;
+    Eqldims eqldims;
+    Aqudims aqudims;
+    bool hasImptvd;
+    bool hasEntpvd;
+    bool hasEqlnum;
+    std::shared_ptr<JFunc> jfunc;
+    double rtemp;
+    unpack(simpleTables, buffer, position, comm);
+    unpack(pvtgTables, buffer, position, comm);
+    unpack(pvtoTables, buffer, position, comm);
+    unpack(rock2dTables, buffer, position, comm);
+    unpack(rock2dtrTables, buffer, position, comm);
+    unpack(pvtwTable, buffer, position, comm);
+    unpack(pvcdoTable, buffer, position, comm);
+    unpack(densityTable, buffer, position, comm);
+    unpack(rockTable, buffer, position, comm);
+    unpack(viscrefTable, buffer, position, comm);
+    unpack(watdentTable, buffer, position, comm);
+    unpack(plymwinjTables, buffer, position, comm);
+    unpack(skprwatTables, buffer, position, comm);
+    unpack(skprpolyTables, buffer, position, comm);
+    unpack(tabdims, buffer, position, comm);
+    unpack(regdims, buffer, position, comm);
+    unpack(eqldims, buffer, position, comm);
+    unpack(aqudims, buffer, position, comm);
+    unpack(hasImptvd, buffer, position, comm);
+    unpack(hasEntpvd, buffer, position, comm);
+    unpack(hasEqlnum, buffer, position, comm);
+    bool hasJf;
+    unpack(hasJf, buffer, position, comm);
+    if (hasJf) {
+        jfunc = std::make_shared<JFunc>();
+        unpack(*jfunc, buffer, position, comm);
+    }
+    unpack(rtemp, buffer, position, comm);
+    data = TableManager(simpleTables, pvtgTables, pvtoTables, rock2dTables,
+                        rock2dtrTables, pvtwTable, pvcdoTable, densityTable,
+                        rockTable, viscrefTable, watdentTable, plymwinjTables,
+                        skprwatTables, skprpolyTables, tabdims, regdims, eqldims,
+                        aqudims, hasImptvd, hasEntpvd, hasEqlnum, jfunc, rtemp);
+}
+
 } // end namespace Mpi
 RestartValue loadParallelRestart(const EclipseIO* eclIO, SummaryState& summaryState,
                                 const std::vector<Opm::RestartKey>& solutionKeys,
@@ -40,10 +40,12 @@ namespace Opm
 {

 class Actdims;
+class Aqudims;
 class ColumnSchema;
 class DENSITYRecord;
 class DensityTable;
 class EclHysterConfig;
+class Eqldims;
 class EDITNNC;
 class EndpointScaling;
 class Equil;
@@ -56,22 +58,30 @@ class JFunc;
 class NNC;
 struct NNCdata;
 class Phases;
+class PlymwinjTable;
+class PolyInjTable;
 class PVCDORecord;
 class PvcdoTable;
 class PvtgTable;
 class PvtoTable;
 class PVTWRecord;
 class PvtwTable;
+class Regdims;
 class RestartConfig;
 class RestartSchedule;
+class ROCKRecord;
+class RockTable;
 class Rock2dTable;
 class Rock2dtrTable;
 class Runspec;
 class SimulationConfig;
 class SimpleTable;
+class SkprpolyTable;
+class SkprwatTable;
 class Tabdims;
 class TableColumn;
 class TableContainer;
+class TableManager;
 class TableSchema;
 class ThresholdPressure;
 class UDQParams;
@@ -257,6 +267,7 @@ void unpack(char* str, std::size_t length, std::vector<char>& buffer, int& posit
              Dune::MPIHelper::MPICommunicator comm);

 ADD_PACK_PROTOTYPES(Actdims)
+ADD_PACK_PROTOTYPES(Aqudims)
 ADD_PACK_PROTOTYPES(ColumnSchema)
 ADD_PACK_PROTOTYPES(data::CellData)
 ADD_PACK_PROTOTYPES(data::Connection)
@@ -274,31 +285,40 @@ ADD_PACK_PROTOTYPES(EquilRecord)
 ADD_PACK_PROTOTYPES(FoamConfig)
 ADD_PACK_PROTOTYPES(FoamData)
 ADD_PACK_PROTOTYPES(EclHysterConfig)
+ADD_PACK_PROTOTYPES(Eqldims)
 ADD_PACK_PROTOTYPES(InitConfig)
 ADD_PACK_PROTOTYPES(IOConfig)
 ADD_PACK_PROTOTYPES(JFunc)
 ADD_PACK_PROTOTYPES(NNC)
 ADD_PACK_PROTOTYPES(NNCdata)
 ADD_PACK_PROTOTYPES(Phases)
+ADD_PACK_PROTOTYPES(PlymwinjTable)
+ADD_PACK_PROTOTYPES(PolyInjTable)
 ADD_PACK_PROTOTYPES(PVCDORecord)
 ADD_PACK_PROTOTYPES(PvcdoTable)
 ADD_PACK_PROTOTYPES(PvtgTable)
 ADD_PACK_PROTOTYPES(PvtoTable)
 ADD_PACK_PROTOTYPES(PVTWRecord)
 ADD_PACK_PROTOTYPES(PvtwTable)
+ADD_PACK_PROTOTYPES(Regdims)
 ADD_PACK_PROTOTYPES(RestartConfig)
 ADD_PACK_PROTOTYPES(RestartKey)
 ADD_PACK_PROTOTYPES(RestartSchedule)
 ADD_PACK_PROTOTYPES(RestartValue)
+ADD_PACK_PROTOTYPES(ROCKRecord)
+ADD_PACK_PROTOTYPES(RockTable)
 ADD_PACK_PROTOTYPES(Rock2dTable)
 ADD_PACK_PROTOTYPES(Rock2dtrTable)
 ADD_PACK_PROTOTYPES(Runspec)
 ADD_PACK_PROTOTYPES(std::string)
 ADD_PACK_PROTOTYPES(SimulationConfig)
 ADD_PACK_PROTOTYPES(SimpleTable)
+ADD_PACK_PROTOTYPES(SkprpolyTable)
+ADD_PACK_PROTOTYPES(SkprwatTable)
 ADD_PACK_PROTOTYPES(Tabdims)
 ADD_PACK_PROTOTYPES(TableColumn)
 ADD_PACK_PROTOTYPES(TableContainer)
+ADD_PACK_PROTOTYPES(TableManager)
 ADD_PACK_PROTOTYPES(TableSchema)
 ADD_PACK_PROTOTYPES(ThresholdPressure)
 ADD_PACK_PROTOTYPES(TimeMap)
@@ -36,17 +36,24 @@
 #include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
 #include <opm/parser/eclipse/EclipseState/SimulationConfig/SimulationConfig.hpp>
 #include <opm/parser/eclipse/EclipseState/SimulationConfig/ThresholdPressure.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/Aqudims.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/ColumnSchema.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/Eqldims.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/FlatTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/JFunc.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/PlymwinjTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/PvtgTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/PvtoTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/Regdims.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/Rock2dTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/Rock2dtrTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/SimpleTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/SkprpolyTable.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/SkprwatTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/Tabdims.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/TableColumn.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/TableContainer.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/TableManager.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/TableSchema.hpp>
 #include <opm/output/eclipse/RestartValue.hpp>

@@ -203,6 +210,16 @@ Opm::PvtoTable getPvtoTable()
 }


+Opm::TableContainer getTableContainer()
+{
+    Opm::OrderedMap<std::string, Opm::TableColumn> data;
+    data.insert({"test3", getTableColumn()});
+    Opm::SimpleTable tab1(getTableSchema(), data, true);
+    Opm::TableContainer result(2);
+    result.addTable(0, std::make_shared<const Opm::SimpleTable>(tab1));
+    result.addTable(1, std::make_shared<const Opm::SimpleTable>(tab1));
+    return result;
+}
 #endif


@@ -827,6 +844,130 @@ BOOST_AUTO_TEST_CASE(WatdentTable)
 }


+BOOST_AUTO_TEST_CASE(PlymwinjTable)
+{
+#if HAVE_MPI
+    Opm::PlymwinjTable val1({1.0}, {2.0}, 1, {{1.0}, {2.0}});
+    auto val2 = PackUnpack(val1);
+    BOOST_CHECK(std::get<1>(val2) == std::get<2>(val2));
+    BOOST_CHECK(val1 == std::get<0>(val2));
+#endif
+}
+
+
+BOOST_AUTO_TEST_CASE(SkprpolyTable)
+{
+#if HAVE_MPI
+    Opm::SkprpolyTable val1({1.0}, {2.0}, 1, {{1.0}, {2.0}}, 3.0);
+    auto val2 = PackUnpack(val1);
+    BOOST_CHECK(std::get<1>(val2) == std::get<2>(val2));
+    BOOST_CHECK(val1 == std::get<0>(val2));
+#endif
+}
+
+
+BOOST_AUTO_TEST_CASE(SkprwatTable)
+{
+#if HAVE_MPI
+    Opm::SkprwatTable val1({1.0}, {2.0}, 1, {{1.0}, {2.0}});
+    auto val2 = PackUnpack(val1);
+    BOOST_CHECK(std::get<1>(val2) == std::get<2>(val2));
+    BOOST_CHECK(val1 == std::get<0>(val2));
+#endif
+}
+
+
+BOOST_AUTO_TEST_CASE(Regdims)
+{
+#if HAVE_MPI
+    Opm::Regdims val1(1,2,3,4,5);
+    auto val2 = PackUnpack(val1);
+    BOOST_CHECK(std::get<1>(val2) == std::get<2>(val2));
+    BOOST_CHECK(val1 == std::get<0>(val2));
+#endif
+}
+
+
+BOOST_AUTO_TEST_CASE(Eqldims)
+{
+#if HAVE_MPI
+    Opm::Eqldims val1(1,2,3,4,5);
+    auto val2 = PackUnpack(val1);
+    BOOST_CHECK(std::get<1>(val2) == std::get<2>(val2));
+    BOOST_CHECK(val1 == std::get<0>(val2));
+#endif
+}
+
+
+BOOST_AUTO_TEST_CASE(Aqudims)
+{
+#if HAVE_MPI
+    Opm::Aqudims val1(1,2,3,4,5,6,7,8);
+    auto val2 = PackUnpack(val1);
+    BOOST_CHECK(std::get<1>(val2) == std::get<2>(val2));
+    BOOST_CHECK(val1 == std::get<0>(val2));
+#endif
+}
+
+
+BOOST_AUTO_TEST_CASE(ROCKRecord)
+{
+#if HAVE_MPI
+    Opm::ROCKRecord val1{1.0,2.0};
+    auto val2 = PackUnpack(val1);
+    BOOST_CHECK(std::get<1>(val2) == std::get<2>(val2));
+    BOOST_CHECK(val1 == std::get<0>(val2));
+#endif
+}
+
+
+BOOST_AUTO_TEST_CASE(RockTable)
+{
+#if HAVE_MPI
+    Opm::RockTable val1({Opm::ROCKRecord{1.0,2.0}});
+    auto val2 = PackUnpack(val1);
+    BOOST_CHECK(std::get<1>(val2) == std::get<2>(val2));
+    BOOST_CHECK(val1 == std::get<0>(val2));
+#endif
+}
+
+
+BOOST_AUTO_TEST_CASE(TableManager)
+{
+#if HAVE_MPI
+    auto jfunc = std::make_shared<Opm::JFunc>(Opm::JFunc::Flag::BOTH,
+                                              1.0, 2.0, 3.0, 4.0,
+                                              Opm::JFunc::Direction::XY);
+    Opm::TableManager val1({{"test", getTableContainer()}},
+                           {getPvtgTable()},
+                           {getPvtoTable()},
+                           {Opm::Rock2dTable({{1.0,2.0},{3.0,4.0}}, {1.0, 2.0, 3.0})},
+                           {Opm::Rock2dtrTable({{1.0,2.0},{3.0,4.0}}, {1.0, 2.0, 3.0})},
+                           Opm::PvtwTable({Opm::PVTWRecord{1.0, 2.0, 3.0, 4.0, 5.0}}),
+                           Opm::PvcdoTable({Opm::PVCDORecord{1.0, 2.0, 3.0, 4.0, 5.0}}),
+                           Opm::DensityTable({Opm::DENSITYRecord{1.0, 2.0, 3.0}}),
+                           Opm::RockTable({Opm::ROCKRecord{1.0,2.0}}),
+                           Opm::ViscrefTable({Opm::VISCREFRecord{1.0, 2.0}}),
+                           Opm::WatdentTable({Opm::WATDENTRecord{1.0, 2.0, 3.0}}),
+                           {{1, Opm::PlymwinjTable({1.0}, {2.0}, 1, {{1.0}, {2.0}})}},
+                           {{2, Opm::SkprwatTable({1.0}, {2.0}, 1, {{1.0}, {2.0}})}},
+                           {{3, Opm::SkprpolyTable({1.0}, {2.0}, 1, {{1.0}, {2.0}}, 3.0)}},
+                           Opm::Tabdims(1,2,3,4,5,6),
+                           Opm::Regdims(1,2,3,4,5),
+                           Opm::Eqldims(1,2,3,4,5),
+                           Opm::Aqudims(1,2,3,4,5,6,7,8),
+                           true,
+                           true,
+                           true,
+                           jfunc,
+                           1.0);
+    auto val2 = PackUnpack(val1);
+    BOOST_CHECK(std::get<1>(val2) == std::get<2>(val2));
+    BOOST_CHECK(val1 == std::get<0>(val2));
+#endif
+}
+
+
 bool init_unit_test_func()
 {
    return true;