Merge pull request #387 from akva2/noecl_flush_matman

MPI serialization support for MaterialLawManager

opm/material/fluidmatrixinteractions/EclEpsConfig.hpp

@@ -222,6 +222,41 @@ public:
     }
 #endif
 
+    template<class Serializer>
+    std::size_t packSize(Serializer& serializer) const
+    {
+        return serializer.packSize(enableSatScaling_) +
+               serializer.packSize(enableThreePointKrSatScaling_) +
+               serializer.packSize(enablePcScaling_) +
+               serializer.packSize(enableLeverettScaling_) +
+               serializer.packSize(enableKrwScaling_) +
+               serializer.packSize(enableKrnScaling_);
+    }
+
+    template<class Serializer>
+    void pack(std::vector<char>& buffer, int& position,
+              Serializer& serializer) const
+    {
+        serializer.pack(enableSatScaling_, buffer, position);
+        serializer.pack(enableThreePointKrSatScaling_, buffer, position);
+        serializer.pack(enablePcScaling_, buffer, position);
+        serializer.pack(enableLeverettScaling_, buffer, position);
+        serializer.pack(enableKrwScaling_, buffer, position);
+        serializer.pack(enableKrnScaling_, buffer, position);
+    }
+
+    template<class Serializer>
+    void unpack(std::vector<char>& buffer, int& position,
+              Serializer& serializer)
+    {
+        serializer.unpack(enableSatScaling_, buffer, position);
+        serializer.unpack(enableThreePointKrSatScaling_, buffer, position);
+        serializer.unpack(enablePcScaling_, buffer, position);
+        serializer.unpack(enableLeverettScaling_, buffer, position);
+        serializer.unpack(enableKrwScaling_, buffer, position);
+        serializer.unpack(enableKrnScaling_, buffer, position);
+    }
+
 private:
     // enable scaling of the input saturations (i.e., rescale the x-Axis)
     bool enableSatScaling_;

opm/material/fluidmatrixinteractions/EclEpsScalingPoints.hpp

@@ -100,6 +100,31 @@ struct EclEpsScalingPointsInfo
     Scalar maxKrog; // maximum relative permability of oil in the gas-oil system
     Scalar maxKrg; // maximum relative permability of gas
 
+    bool operator==(const EclEpsScalingPointsInfo<Scalar>& data) const
+    {
+        return Swl == data.Swl &&
+               Sgl == data.Sgl &&
+               Sowl == data.Sowl &&
+               Sogl == data.Sogl &&
+               krCriticalEps == data.krCriticalEps &&
+               Swcr == data.Swcr &&
+               Sgcr == data.Sgcr &&
+               Sowcr == data.Sowcr &&
+               Sogcr == data.Sogcr &&
+               Swu == data.Swu &&
+               Sgu == data.Sgu &&
+               Sowu == data.Sowu &&
+               Sogu == data.Sogu &&
+               maxPcow == data.maxPcow &&
+               maxPcgo == data.maxPcgo &&
+               pcowLeverettFactor == data.pcowLeverettFactor &&
+               pcgoLeverettFactor == data.pcgoLeverettFactor &&
+               maxKrw == data.maxKrw &&
+               maxKrow == data.maxKrow &&
+               maxKrog == data.maxKrog &&
+               maxKrg == data.maxKrg;
+    }
+
     void print() const
     {
         std::cout << "    Swl: " << Swl << "\n"

opm/material/fluidmatrixinteractions/EclHysteresisConfig.hpp

@@ -172,6 +172,32 @@ public:
     }
 #endif
 
+    template<class Serializer>
+    std::size_t packSize(Serializer& serializer) const
+    {
+        return serializer.packSize(enableHysteresis_) +
+               serializer.packSize(pcHysteresisModel_) +
+               serializer.packSize(krHysteresisModel_);
+    }
+
+    template<class Serializer>
+    void pack(std::vector<char>& buffer, int& position,
+              Serializer& serializer) const
+    {
+        serializer.pack(enableHysteresis_, buffer, position);
+        serializer.pack(pcHysteresisModel_, buffer, position);
+        serializer.pack(krHysteresisModel_, buffer, position);
+    }
+
+    template<class Serializer>
+    void unpack(std::vector<char>& buffer, int& position,
+                Serializer& serializer)
+    {
+        serializer.unpack(enableHysteresis_, buffer, position);
+        serializer.unpack(pcHysteresisModel_, buffer, position);
+        serializer.unpack(krHysteresisModel_, buffer, position);
+    }
+
 private:
     // enable hysteresis at all
     bool enableHysteresis_;

opm/material/fluidmatrixinteractions/EclMaterialLawManager.hpp

@@ -617,6 +617,64 @@ public:
     std::shared_ptr<EclEpsScalingPointsInfo<Scalar> >& oilWaterScaledEpsInfoDrainagePointerReferenceHack(unsigned elemIdx)
     { return oilWaterScaledEpsInfoDrainage_[elemIdx]; }
 
+    template<class Serializer>
+    std::size_t packSize(Serializer& serializer) const
+    {
+        return serializer.packSize(enableEndPointScaling_) +
+               hysteresisConfig_->packSize(serializer) +
+               oilWaterEclEpsConfig_->packSize(serializer) +
+               serializer.packSize(unscaledEpsInfo_) +
+               serializer.packSize(threePhaseApproach_) +
+               serializer.packSize(twoPhaseApproach_) +
+               gasOilConfig->packSize(serializer) +
+               oilWaterConfig->packSize(serializer) +
+               serializer.packSize(stoneEtas) +
+               serializer.packSize(hasGas) +
+               serializer.packSize(hasOil) +
+               serializer.packSize(hasWater);
+    }
+
+    template<class Serializer>
+    void pack(std::vector<char>& buffer, int& position,
+               Serializer& serializer) const
+    {
+        serializer.pack(enableEndPointScaling_, buffer, position);
+        hysteresisConfig_->pack(buffer, position, serializer);
+        oilWaterEclEpsConfig_->pack(buffer, position, serializer);
+        serializer.pack(unscaledEpsInfo_, buffer, position);
+        serializer.pack(threePhaseApproach_, buffer, position);
+        serializer.pack(twoPhaseApproach_, buffer, position);
+        gasOilConfig->pack(buffer, position, serializer);
+        oilWaterConfig->pack(buffer, position, serializer);
+        serializer.pack(stoneEtas, buffer, position);
+        serializer.pack(hasGas, buffer, position);
+        serializer.pack(hasOil, buffer, position);
+        serializer.pack(hasWater, buffer, position);
+    }
+
+    template<class Serializer>
+    void unpack(std::vector<char>& buffer, int& position,
+                Serializer& serializer)
+    {
+        oilWaterEclEpsConfig_ = std::make_shared<Opm::EclEpsConfig>();
+        hysteresisConfig_ = std::make_shared<Opm::EclHysteresisConfig>();
+        gasOilConfig = std::make_shared<Opm::EclEpsConfig>();
+        oilWaterConfig = std::make_shared<Opm::EclEpsConfig>();
+
+        serializer.unpack(enableEndPointScaling_, buffer, position);
+        hysteresisConfig_->unpack(buffer, position, serializer);
+        oilWaterEclEpsConfig_->unpack(buffer, position, serializer);
+        serializer.unpack(unscaledEpsInfo_, buffer, position);
+        serializer.unpack(threePhaseApproach_, buffer, position);
+        serializer.unpack(twoPhaseApproach_, buffer, position);
+        gasOilConfig->unpack(buffer, position, serializer);
+        oilWaterConfig->unpack(buffer, position, serializer);
+        serializer.unpack(stoneEtas, buffer, position);
+        serializer.unpack(hasGas, buffer, position);
+        serializer.unpack(hasOil, buffer, position);
+        serializer.unpack(hasWater, buffer, position);
+    }
+
 private:
     void readGlobalEpsOptions_(const Opm::Deck& deck, const Opm::EclipseState& eclState)
     {