Modified TransportSolverTwophaseInterface::solve(), general cleanup.

Move output arguments last in argument list.

opm/core/simulator/SimulatorIncompTwophase.cpp

@@ -556,8 +556,8 @@ namespace Opm
                 tsolver_->solve(&transport_src[0],
                                 &porevol[0],
                                 stepsize,
-                               state,
+                                well_state,
-                               well_state);
+                                state);
 
                 double substep_injected[2] = { 0.0 };
                 double substep_produced[2] = { 0.0 };

opm/core/transport/TransportSolverTwophaseImplicit.cpp

@@ -30,7 +30,9 @@
 #include <opm/core/transport/TransportSolverTwophaseImplicit.hpp>
 #include <opm/core/simulator/TwophaseState.hpp>
 #include <opm/core/utility/miscUtilities.hpp>
-namespace Opm{
+
+namespace Opm
+{
 
     TransportSolverTwophaseImplicit::TransportSolverTwophaseImplicit(
             const Opm::WellsManager& wells,
@@ -48,22 +50,30 @@ namespace Opm{
           wells_(wells)
     {
         tsrc_ = create_transport_source(2, 2);
-        //linsolver_(param),
-        //src_(num_cells, 0.0);
     }
 
+    TransportSolverTwophaseImplicit::~TransportSolverTwophaseImplicit()
+    {
+        destroy_transport_source(tsrc_);
+    }
+
+    /// Solve for saturation at next timestep.
+    /// \param[in]      porevolume   Array of pore volumes.
+    /// \param[in]      source       Transport source term.
+    /// \param[in]      dt           Time step.
+    /// \param[in]      wstate       Well state.
+    /// \param[in, out] state        Reservoir state. Saturation will be modified.
     void TransportSolverTwophaseImplicit::solve(const double* porevolume,
                                                 const double* source,
                                                 const double dt,
-                                                TwophaseState& state,
+                                                const WellState& well_state,
-                                                const WellState& well_state)
+                                                TwophaseState& state)
     {
         std::vector<double> porevol;
         if (rock_comp_.isActive()) {
             computePorevolume(grid_, props_.porosity(), rock_comp_, state.pressure(), porevol);
         }
         std::vector<double> src(grid_.number_of_cells, 0.0);
-        //Opm::wellsToSrc(*wells->c_wells(), num_cells, src);
         Opm::computeTransportSource(grid_, src, state.faceflux(), 1.0,
                                     wells_.c_wells(), well_state.perfRates(), src);
         double ssrc[]   = { 1.0, 0.0 };
@@ -77,10 +87,9 @@ namespace Opm{
                 append_transport_source(cell, 2, 0, src[cell], ssink, zdummy, tsrc_);
             }
         }
-        // Boundary conditions.
         Opm::ImplicitTransportDetails::NRReport  rpt;
         tsolver_.solve(grid_, tsrc_, dt, ctrl_, state, linsolver_, rpt);
         std::cout << rpt;
-
     }
-}
+
+} // namespace Opm

opm/core/transport/TransportSolverTwophaseImplicit.hpp

@@ -20,7 +20,7 @@
 
 #ifndef OPM_TRANSPORTSOLVERTWOPHASEIMPLICIT_HEADER_INCLUDED
 #define OPM_TRANSPORTSOLVERTWOPHASEIMPLICIT_HEADER_INCLUDED
-#include <vector>
+
 #include <opm/core/utility/parameters/ParameterGroup.hpp>
 #include <opm/core/transport/TransportSolverTwophaseInterface.hpp>
 #include <opm/core/props/IncompPropertiesInterface.hpp>
@@ -38,13 +38,20 @@
 #include <opm/core/transport/JacobianSystem.hpp>
 #include <opm/core/transport/CSRMatrixBlockAssembler.hpp>
 #include <opm/core/transport/SinglePointUpwindTwoPhase.hpp>
-#include <boost/scoped_ptr.hpp>
 
 #include <opm/core/props/rock/RockCompressibility.hpp>
 #include <opm/core/wells/WellsManager.hpp>
 #include <opm/core/simulator/WellState.hpp>
-namespace Opm{
+
-    // implicite transprot solver
+#include <boost/scoped_ptr.hpp>
+#include <vector>
+
+
+
+namespace Opm
+{
+
+    // Implicit transport solver using Newton-Raphson.
     class TransportSolverTwophaseImplicit : public TransportSolverTwophaseInterface
     {
     public:
@@ -53,8 +60,7 @@ namespace Opm{
         /// \param[in] props     Rock and fluid properties.
         /// \param[in] tol       Tolerance used in the solver.
         /// \param[in] maxit     Maximum number of non-linear iterations used.
-        TransportSolverTwophaseImplicit(
+        TransportSolverTwophaseImplicit(const Opm::WellsManager& wells,
-                const Opm::WellsManager& wells,
                                         const Opm::RockCompressibility& rock_comp,
                                         const ImplicitTransportDetails::NRControl& ctrl,
                                         SinglePointUpwindTwoPhase<Opm::SimpleFluid2pWrappingProps>& model,
@@ -62,33 +68,30 @@ namespace Opm{
                                         const Opm::IncompPropertiesInterface& props,
                                         const parameter::ParameterGroup& param);
 
-        ~TransportSolverTwophaseImplicit(){
+        virtual ~TransportSolverTwophaseImplicit();
-           destroy_transport_source(tsrc_);
-        }
 
         /// Solve for saturation at next timestep.
-        /// \param[in] darcyflux         Array of signed face fluxes.
         /// \param[in]      porevolume   Array of pore volumes.
         /// \param[in]      source       Transport source term.
         /// \param[in]      dt           Time step.
-        /// \param[in, out] saturation   Phase saturations.
+        /// \param[in]      wstate       Well state.
-        void solve(const double* porevolume,
+        /// \param[in, out] state        Reservoir state. Saturation will be modified.
+        virtual void solve(const double* porevolume,
                            const double* source,
                            const double dt,
-                   Opm::TwophaseState& state,
+                           const Opm::WellState& well_state,
-                   const Opm::WellState& well_state);
+                           Opm::TwophaseState& state);
 
     private:
+        // Disallow copying and assignment.
         TransportSolverTwophaseImplicit(const TransportSolverTwophaseImplicit&);
         TransportSolverTwophaseImplicit& operator=(const TransportSolverTwophaseImplicit&);
+
+        // Defining types for the underlying transport solver.
         typedef Opm::SimpleFluid2pWrappingProps TwophaseFluid;
         typedef Opm::SinglePointUpwindTwoPhase<TwophaseFluid> TransportModel;
-
-        //using namespace ImplicitTransportDefault;
-
         typedef ImplicitTransportDefault::NewtonVectorCollection< ::std::vector<double> >      NVecColl;
         typedef ImplicitTransportDefault::JacobianSystem        < struct CSRMatrix, NVecColl > JacSys;
-
         template <class Vector>
         class MaxNorm {
         public:
@@ -97,7 +100,6 @@ namespace Opm{
                 return ImplicitTransportDefault::AccumulationNorm <Vector, ImplicitTransportDefault::MaxAbs>::norm(v);
             }
         };
-
         typedef Opm::ImplicitTransport<TransportModel,
                                        JacSys        ,
                                        MaxNorm       ,
@@ -105,7 +107,8 @@ namespace Opm{
                                        ImplicitTransportDefault::VectorZero    ,
                                        ImplicitTransportDefault::MatrixZero    ,
                                        ImplicitTransportDefault::VectorAssign  > TransportSolver;
-        //Opm::LinearSolverFactory
+
+        // Data members.
         Opm::ImplicitTransportLinAlgSupport::CSRMatrixUmfpackSolver linsolver_;
         TransportSolver tsolver_;
         const UnstructuredGrid& grid_;
@@ -113,9 +116,9 @@ namespace Opm{
         const Opm::IncompPropertiesInterface& props_;
         const Opm::RockCompressibility& rock_comp_;
         const Opm::WellsManager& wells_;
-
         TransportSource* tsrc_;
-
     };
-}
+
+} // namespace Opm
+
 #endif // OPM_TRANSPORTSOLVERTWOPHASEIMPLICIT_HEADER_INCLUDED

opm/core/transport/TransportSolverTwophaseInterface.hpp

@@ -37,13 +37,13 @@ namespace Opm
         /// \param[in]      porevolume   Array of pore volumes.
         /// \param[in]      source       Transport source term.
         /// \param[in]      dt           Time step.
-        /// \param[in, out] state        Reservoir state. Saturation will be modified.
         /// \param[in]      wstate       Well state.
+        /// \param[in, out] state        Reservoir state. Saturation will be modified.
         virtual void solve(const double* porevolume,
                            const double* source,
                            const double dt,
-                           TwophaseState& state,
+                           const WellState& wstate,
-                           const WellState& wstate) = 0;
+                           TwophaseState& state) = 0;
     };
 
 }