Implemented FluidMatrixInteractionBlackoil init(), kr() and a test prog.

dune/porsol/common/UniformTableLinear.hpp

@@ -46,7 +46,7 @@ namespace Dune {
 	    /// @brief Default constructor.
 	    UniformTableLinear();
 
-	    /// @brief Useful constructor.
+	    /// @brief Construct from vector of y-values.
 	    /// @param xmin the x value corresponding to the first y value.
 	    /// @param xmax the x value corresponding to the last y value.
 	    /// @param y_values vector of range values.
@@ -54,6 +54,16 @@ namespace Dune {
                                double xmax,
                                const std::vector<T>& y_values);
 
+	    /// @brief Construct from array of y-values.
+	    /// @param xmin the x value corresponding to the first y value.
+	    /// @param xmax the x value corresponding to the last y value.
+	    /// @param y_values array of range values.
+            /// @param num_y_values the number of values in y_values.
+	    UniformTableLinear(double xmin,
+                               double xmax,
+                               const T* y_values,
+                               int num_y_values);
+
 	    /// @brief Get the domain.
 	    /// @return the domain as a pair of doubles.
 	    std::pair<double, double> domain();
@@ -122,6 +132,22 @@ namespace Dune {
             xdelta_ = (xmax - xmin)/(y_values.size() - 1);
 	}
 
+	template<typename T>
+	inline
+	UniformTableLinear<T>
+	::UniformTableLinear(double xmin,
+                             double xmax,
+                             const T* y_values,
+                             int num_y_values)
+	    : xmin_(xmin), xmax_(xmax),
+              y_values_(y_values, y_values + num_y_values),
+	      left_(ClosestValue), right_(ClosestValue)
+	{
+            ASSERT(xmax > xmin);
+            ASSERT(y_values_.size() > 1);
+            xdelta_ = (xmax - xmin)/(y_values_.size() - 1);
+	}
+
 	template<typename T>
 	inline std::pair<double, double>
 	UniformTableLinear<T>

dune/porsol/common/buildUniformMonotoneTable.hpp

@@ -0,0 +1,52 @@
+/*
+  Copyright 2010 SINTEF ICT, Applied Mathematics.
+
+  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_BUILDUNIFORMMONOTONETABLE_HEADER_INCLUDED
+#define OPM_BUILDUNIFORMMONOTONETABLE_HEADER_INCLUDED
+
+#include <dune/common/MonotCubicInterpolator.hpp>
+#include <dune/porsol/common/UniformTableLinear.hpp>
+
+namespace Dune {
+    namespace utils {
+
+        template <typename T>
+        void buildUniformMonotoneTable(const std::vector<double>& xv,
+                                       const std::vector<T>& yv,
+                                       const int samples,
+                                       UniformTableLinear<T>& table)
+        {
+            MonotCubicInterpolator interp(xv, yv);
+            std::vector<T> uniform_yv(samples);
+            double xmin = xv[0];
+            double xmax = xv.back();
+            for (int i = 0; i < samples; ++i) {
+                double w = double(i)/double(samples - 1);
+                double x = (1.0 - w)*xmin + w*xmax;
+                uniform_yv[i] = interp(x);
+            }
+            table = UniformTableLinear<T>(xmin, xmax, uniform_yv);
+        }
+
+    } // namespace utils
+} // namespace Dune
+
+
+
+#endif // OPM_BUILDUNIFORMMONOTONETABLE_HEADER_INCLUDED