Adds the new interface to SinglePvtLivGas

opm/core/props/pvt/BlackoilPvtProperties.cpp

@@ -81,12 +81,12 @@ namespace Opm
         if (phase_usage_.phase_used[Liquid]) {
             if (deck.hasField("PVDO")) {
                 if (samples > 0) {
-                 //   props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtDeadSpline(deck.getPVDO().pvdo_, samples));
+                    props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtDeadSpline(deck.getPVDO().pvdo_, samples));
                 } else {
                     props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtDead(deck.getPVDO().pvdo_));
                 }
             } else if (deck.hasField("PVTO")) {
-                //props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtLiveOil(deck.getPVTO().pvto_));
+                props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtLiveOil(deck.getPVTO().pvto_));
             } else if (deck.hasField("PVCDO")) {
                 props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtConstCompr(deck.getPVCDO().pvcdo_));
             } else {
@@ -97,12 +97,12 @@ namespace Opm
         if (phase_usage_.phase_used[Vapour]) {
             if (deck.hasField("PVDG")) {
                 if (samples > 0) {
-                 //   props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtDeadSpline(deck.getPVDG().pvdg_, samples));
+                    props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtDeadSpline(deck.getPVDG().pvdg_, samples));
                 } else {
                     props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtDead(deck.getPVDG().pvdg_));
                 }
             } else if (deck.hasField("PVTG")) {
-               // props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtLiveGas(deck.getPVTG().pvtg_));
+                props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtLiveGas(deck.getPVTG().pvtg_));
             } else {
                 THROW("Input is missing PVDG or PVTG\n");
             }

opm/core/props/pvt/SinglePvtDead.hpp

@@ -49,12 +49,12 @@ namespace Opm
                         double* output_mu) const;
 
         /// Viscosity and its derivatives as a function of p and r.
-              virtual void mu(const int n,
-                                     const double* p,
-                                     const double* r,
-                                     double* output_mu,
-                                     double* output_dmudp,
-                                     double* output_dmudr) const;
+        virtual void mu(const int n,
+                        const double* p,
+                        const double* r,
+                        double* output_mu,
+                        double* output_dmudp,
+                        double* output_dmudr) const;
 
         /// Formation volume factor as a function of p and z.
         virtual void B(const int n,

opm/core/props/pvt/SinglePvtDeadSpline.cpp

@@ -52,7 +52,7 @@ namespace Opm
             B_inv[i] = 1.0 / pvd_table[region_number][1][i];
             visc[i]  = pvd_table[region_number][2][i];
         }
-        buildUniformMonotoneTable(press, B_inv, samples, one_over_B_);
+        buildUniformMonotoneTable(press, B_inv, samples, b_);
         buildUniformMonotoneTable(press, visc, samples, viscosity_);
 
         // Dumping the created tables.
@@ -81,6 +81,23 @@ namespace Opm
         }
     }
 
+    void SinglePvtDeadSpline::mu(const int n,
+                               const double* p,
+                               const double* /*r*/,
+                               double* output_mu,
+                               double* output_dmudp,
+                               double* output_dmudr) const
+        {
+    // #pragma omp parallel for
+
+            for (int i = 0; i < n; ++i) {
+                output_mu[i] = viscosity_(p[i]);
+                output_dmudp[i] = viscosity_.derivative(p[i]);
+            }
+            std::fill(output_dmudr, output_dmudr + n, 0.0);
+
+        }
+
     void SinglePvtDeadSpline::B(const int n,
                                 const double* p,
                                 const double* /*z*/,
@@ -88,7 +105,7 @@ namespace Opm
     {
 // #pragma omp parallel for
         for (int i = 0; i < n; ++i) {
-            output_B[i] = 1.0/one_over_B_(p[i]);
+            output_B[i] = 1.0/b_(p[i]);
         }
     }
 
@@ -102,10 +119,36 @@ namespace Opm
 // #pragma omp parallel for
         for (int i = 0; i < n; ++i) {
             double Bg = output_B[i];
-            output_dBdp[i] = -Bg*Bg*one_over_B_.derivative(p[i]);
+            output_dBdp[i] = -Bg*Bg*b_.derivative(p[i]);
         }
     }
 
+    void SinglePvtDeadSpline::b(const int n,
+                              const double* p,
+                              const double* /*r*/,
+                              double* output_b,
+                              double* output_dbdp,
+                              double* output_dbdr) const
+
+        {
+    // #pragma omp parallel for
+            for (int i = 0; i < n; ++i) {
+                output_b[i] = b_(p[i]);
+                output_dbdp[i] = b_.derivative(p[i]);
+
+            }
+            std::fill(output_dbdr, output_dbdr + n, 0.0);
+
+        }
+
+    void SinglePvtDeadSpline::rbub(const int n,
+                             const double* /*p*/,
+                             double* output_rbub,
+                             double* output_drbubdp) const
+    {
+        std::fill(output_rbub, output_rbub + n, 0.0);
+        std::fill(output_drbubdp, output_drbubdp + n, 0.0);
+    }
 
     void SinglePvtDeadSpline::R(const int n,
                                 const double* /*p*/,

opm/core/props/pvt/SinglePvtDeadSpline.hpp

@@ -29,8 +29,10 @@ namespace Opm
 {
 
     /// Class for immiscible dead oil and dry gas.
-    /// For all the virtual methods, the following apply: p and z
-    /// are expected to be of size n and n*num_phases, respectively.
+    /// The PVT properties can either be given as a function of pressure (p) and surface volume (z)
+    /// or pressure (p) and gas resolution factor (r).
+    /// For all the virtual methods, the following apply: p, r and z
+    /// are expected to be of size n, size n and n*num_phases, respectively.
     /// Output arrays shall be of size n, and must be valid before
     /// calling the method.
     class SinglePvtDeadSpline : public SinglePvtInterface
@@ -47,6 +49,14 @@ namespace Opm
                         const double* z,
                         double* output_mu) const;
 
+        /// Viscosity and its derivatives as a function of p and r.
+        virtual void mu(const int n,
+                        const double* p,
+                        const double* r,
+                        double* output_mu,
+                        double* output_dmudp,
+                        double* output_dmudr) const;
+
         /// Formation volume factor as a function of p and z.
         virtual void B(const int n,
                        const double* p,
@@ -60,6 +70,20 @@ namespace Opm
                           double* output_B,
                           double* output_dBdp) const;
 
+        /// The inverse of the formation volume factor b = 1 / B, and its derivatives as a function of p and r.
+        virtual void b(const int n,
+                       const double* p,
+                       const double* r,
+                       double* output_b,
+                       double* output_dbdp,
+                       double* output_dbdr) const;
+
+        /// Gas resolution and its derivatives at bublepoint as a function of p.
+        virtual void rbub(const int n,
+                          const double* p,
+                          double* output_rbub,
+                          double* output_drbubdp) const;
+
         /// Solution factor as a function of p and z.
         virtual void R(const int n,
                        const double* p,
@@ -74,7 +98,7 @@ namespace Opm
                           double* output_dRdp) const;
     private:
         // PVT properties of dry gas or dead oil
-        UniformTableLinear<double> one_over_B_;
+        UniformTableLinear<double> b_;
         UniformTableLinear<double> viscosity_;
     };
 

opm/core/props/pvt/SinglePvtLiveGas.cpp

@@ -98,6 +98,17 @@ namespace Opm
         }
     }
 
+    /// Viscosity and its derivatives as a function of p and r.
+    void SinglePvtLiveGas::mu(const int n,
+                               const double* p,
+                               const double* r,
+                               double* output_mu,
+                               double* output_dmudp,
+                               double* output_dmudr) const
+    {
+        THROW("The new fluid interface not yet implemented");
+    }
+
 
     /// Formation volume factor as a function of p and z.
     void SinglePvtLiveGas::B(const int n,
@@ -126,6 +137,26 @@ namespace Opm
         }
     }
 
+    /// The inverse of the formation volume factor b = 1 / B, and its derivatives as a function of p and r.
+    void SinglePvtLiveGas::b(const int n,
+                          const double* p,
+                          const double* r,
+                          double* output_b,
+                          double* output_dbdp,
+                          double* output_dbdr) const
+
+    {
+        THROW("The new fluid interface not yet implemented");
+    }
+
+    /// Gas resolution and its derivatives at bublepoint as a function of p.
+    void SinglePvtLiveGas::rbub(const int n,
+                             const double* p,
+                             double* output_rbub,
+                             double* output_drbubdp) const
+    {
+        THROW("The new fluid interface not yet implemented");
+    }
 
     /// Solution factor as a function of p and z.
     void SinglePvtLiveGas::R(const int n,

opm/core/props/pvt/SinglePvtLiveGas.hpp

@@ -26,8 +26,10 @@
 namespace Opm
 {
     /// Class for miscible wet gas (with vaporized oil in vapour phase).
-    /// For all the virtual methods, the following apply: p and z
-    /// are expected to be of size n and n*num_phases, respectively.
+    /// The PVT properties can either be given as a function of pressure (p) and surface volume (z)
+    /// or pressure (p) and gas resolution factor (r).
+    /// For all the virtual methods, the following apply: p, r and z
+    /// are expected to be of size n, size n and n*num_phases, respectively.
     /// Output arrays shall be of size n, and must be valid before
     /// calling the method.
     class SinglePvtLiveGas : public SinglePvtInterface
@@ -44,6 +46,14 @@ namespace Opm
                         const double* z,
                         double* output_mu) const;
 
+        /// Viscosity and its derivatives as a function of p and r.
+        virtual void mu(const int n,
+                        const double* p,
+                        const double* r,
+                        double* output_mu,
+                        double* output_dmudp,
+                        double* output_dmudr) const;
+
         /// Formation volume factor as a function of p and z.
         virtual void B(const int n,
                        const double* p,
@@ -57,6 +67,22 @@ namespace Opm
                           double* output_B,
                           double* output_dBdp) const;
 
+        /// The inverse of the formation volume factor b = 1 / B, and its derivatives as a function of p and r.
+        virtual void b(const int n,
+                       const double* p,
+                       const double* r,
+                       double* output_b,
+                       double* output_dbdp,
+                       double* output_dbdr) const;
+
+
+
+        /// Gas resolution and its derivatives at bublepoint as a function of p.
+        virtual void rbub(const int n,
+                          const double* p,
+                          double* output_rbub,
+                          double* output_drbubdp) const;
+
         /// Solution factor as a function of p and z.
         virtual void R(const int n,
                        const double* p,

opm/core/props/pvt/SinglePvtLiveOil.cpp

@@ -175,6 +175,23 @@ namespace Opm
         }
     }
 
+    /// Viscosity and its derivatives as a function of p and r.
+    void SinglePvtLiveOil::mu(const int n,
+                               const double* p,
+                               const double* r,
+                               double* output_mu,
+                               double* output_dmudp,
+                               double* output_dmudr) const
+    {
+        // #pragma omp parallel for
+                for (int i = 0; i < n; ++i) {
+                    output_mu[i] = miscible_oil(p[i], r[i], 2, 0);
+                    output_dmudp[i] = miscible_oil(p[i], r[i], 2, 1);
+                    output_dmudr[i] = miscible_oil(p[i], r[i], 2, 2);
+
+                }
+    }
+
 
     /// Formation volume factor as a function of p and z.
     void SinglePvtLiveOil::B(const int n,
@@ -203,6 +220,37 @@ namespace Opm
         }
     }
 
+    void SinglePvtLiveOil::b(const int n,
+                          const double* p,
+                          const double* r,
+                          double* output_b,
+                          double* output_dbdp,
+                          double* output_dbdr) const
+
+    {
+        // #pragma omp parallel for
+                for (int i = 0; i < n; ++i) {
+                    output_b[i] = miscible_oil(p[i], r[i], 1, 0);
+                    output_dbdp[i] = miscible_oil(p[i], r[i], 1, 1);
+                    output_dbdr[i] = miscible_oil(p[i], r[i], 1, 2);
+
+                }
+    }
+
+    void SinglePvtLiveOil::rbub(const int n,
+                             const double* p,
+                             double* output_rbub,
+                             double* output_drbubdp) const
+    {
+
+        for (int i = 0; i < n; ++i) {
+            output_rbub[i] = linearInterpolation(saturated_oil_table_[0],
+                    saturated_oil_table_[3],p[i]);
+            output_drbubdp[i] = linearInterpolationDerivative(saturated_oil_table_[0],
+                    saturated_oil_table_[3],p[i]);
+
+        }
+    }
 
     /// Solution factor as a function of p and z.
     void SinglePvtLiveOil::R(const int n,
@@ -347,4 +395,84 @@ namespace Opm
         }
     }
 
+    double SinglePvtLiveOil::miscible_oil(const double press,
+                                          const double r,
+                                          const int item,
+                                          const int deriv) const
+    {
+        int section;
+        double Rval = linearInterpolation(saturated_oil_table_[0],
+                                                saturated_oil_table_[3],
+                                                press, section);
+        // derivative with respect to frist component (pressure)
+        if (deriv == 1) {
+            if (Rval < r ) {  // Saturated case
+                return linearInterpolationDerivative(saturated_oil_table_[0],
+                                                saturated_oil_table_[item],
+                                                press);
+            } else {  // Undersaturated case
+                int is = tableIndex(saturated_oil_table_[3], r);
+                double w = (r - saturated_oil_table_[3][is]) /
+                    (saturated_oil_table_[3][is+1] - saturated_oil_table_[3][is]);
+                ASSERT(undersat_oil_tables_[is][0].size() >= 2);
+                ASSERT(undersat_oil_tables_[is+1][0].size() >= 2);
+                double val1 =
+                    linearInterpolationDerivative(undersat_oil_tables_[is][0],
+                                             undersat_oil_tables_[is][item],
+                                             press);
+                double val2 =
+                    linearInterpolationDerivative(undersat_oil_tables_[is+1][0],
+                                             undersat_oil_tables_[is+1][item],
+                                             press);
+                double val = val1 + w*(val2 - val1);
+                return val;
+            }
+            // derivative with respect to second component (r)
+        } else if (deriv == 2)  {
+            if (Rval < r ) {  // Saturated case
+                return 0;
+            } else {  // Undersaturated case
+                int is = tableIndex(saturated_oil_table_[3], r);
+                ASSERT(undersat_oil_tables_[is][0].size() >= 2);
+                ASSERT(undersat_oil_tables_[is+1][0].size() >= 2);
+                double val1 =
+                    linearInterpolation(undersat_oil_tables_[is][0],
+                                              undersat_oil_tables_[is][item],
+                                              press);
+                double val2 =
+                    linearInterpolation(undersat_oil_tables_[is+1][0],
+                                              undersat_oil_tables_[is+1][item],
+                                              press);
+
+                double val = (val2 - val1)/(saturated_oil_table_[3][is+1]-saturated_oil_table_[3][is]);
+                return val;
+            }
+
+
+            }    else {
+            if (Rval < r ) {  // Saturated case
+                return linearInterpolation(saturated_oil_table_[0],
+                                                 saturated_oil_table_[item],
+                                                 press);
+            } else {  // Undersaturated case
+                // Interpolate between table sections
+                int is = tableIndex(saturated_oil_table_[3], r);
+                double w = (r - saturated_oil_table_[3][is]) /
+                    (saturated_oil_table_[3][is+1] - saturated_oil_table_[3][is]);
+                ASSERT(undersat_oil_tables_[is][0].size() >= 2);
+                ASSERT(undersat_oil_tables_[is+1][0].size() >= 2);
+                double val1 =
+                    linearInterpolation(undersat_oil_tables_[is][0],
+                                              undersat_oil_tables_[is][item],
+                                              press);
+                double val2 =
+                    linearInterpolation(undersat_oil_tables_[is+1][0],
+                                              undersat_oil_tables_[is+1][item],
+                                              press);
+                double val = val1 + w*(val2 - val1);
+                return val;
+            }
+        }
+    }
+
 } // namespace Opm

opm/core/props/pvt/SinglePvtLiveOil.hpp

@@ -27,8 +27,10 @@
 namespace Opm
 {
     /// Class for miscible live oil (with dissolved gas in liquid phase).
-    /// For all the virtual methods, the following apply: p and z
-    /// are expected to be of size n and n*num_phases, respectively.
+    /// The PVT properties can either be given as a function of pressure (p) and surface volume (z)
+    /// or pressure (p) and gas resolution factor (r).
+    /// For all the virtual methods, the following apply: p, r and z
+    /// are expected to be of size n, size n and n*num_phases, respectively.
     /// Output arrays shall be of size n, and must be valid before
     /// calling the method.
     class SinglePvtLiveOil : public SinglePvtInterface
@@ -45,6 +47,14 @@ namespace Opm
                         const double* z,
                         double* output_mu) const;
 
+        /// Viscosity and its derivatives as a function of p and r.
+        virtual void mu(const int n,
+                        const double* p,
+                        const double* r,
+                        double* output_mu,
+                        double* output_dmudp,
+                        double* output_dmudr) const;
+
         /// Formation volume factor as a function of p and z.
         virtual void B(const int n,
                        const double* p,
@@ -58,6 +68,20 @@ namespace Opm
                           double* output_B,
                           double* output_dBdp) const;
 
+        /// The inverse of the formation volume factor b = 1 / B, and its derivatives as a function of p and r.
+        virtual void b(const int n,
+                       const double* p,
+                       const double* r,
+                       double* output_b,
+                       double* output_dbdp,
+                       double* output_dbdr) const;
+
+        /// Gas resolution and its derivatives at bublepoint as a function of p.
+        virtual void rbub(const int n,
+                          const double* p,
+                          double* output_rbub,
+                          double* output_drbubdp) const;
+
         /// Solution factor as a function of p and z.
         virtual void R(const int n,
                        const double* p,
@@ -83,6 +107,11 @@ namespace Opm
                             const int item,
                             const bool deriv = false) const;
 
+        double miscible_oil(const double press,
+                            const double r,
+                            const int item,
+                            const int deriv = 0) const;
+
         // PVT properties of live oil (with dissolved gas)
         std::vector<std::vector<double> > saturated_oil_table_;
         std::vector<std::vector<std::vector<double> > > undersat_oil_tables_;