diff --git a/CMakeLists_files.cmake b/CMakeLists_files.cmake
index b7c9af3c2..332a36f58 100644
--- a/CMakeLists_files.cmake
+++ b/CMakeLists_files.cmake
@@ -126,8 +126,8 @@ list (APPEND PUBLIC_HEADER_FILES
 	opm/autodiff/NewtonIterationBlackoilInterleaved.hpp
 	opm/autodiff/NewtonIterationBlackoilSimple.hpp
 	opm/autodiff/NewtonIterationUtilities.hpp
-	opm/autodiff/NewtonSolver.hpp
-	opm/autodiff/NewtonSolver_impl.hpp
+	opm/autodiff/NonlinearSolver.hpp
+	opm/autodiff/NonlinearSolver_impl.hpp
 	opm/autodiff/LinearisedBlackoilResidual.hpp
 	opm/autodiff/ParallelDebugOutput.hpp
 	opm/autodiff/RateConverter.hpp
diff --git a/opm/autodiff/NewtonSolver.hpp b/opm/autodiff/NonlinearSolver.hpp
similarity index 71%
rename from opm/autodiff/NewtonSolver.hpp
rename to opm/autodiff/NonlinearSolver.hpp
index dfdb89697..0b7ee7319 100644
--- a/opm/autodiff/NewtonSolver.hpp
+++ b/opm/autodiff/NonlinearSolver.hpp
@@ -18,8 +18,8 @@
   along with OPM.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef OPM_NEWTONSOLVER_HEADER_INCLUDED
-#define OPM_NEWTONSOLVER_HEADER_INCLUDED
+#ifndef OPM_NONLINEARSOLVER_HEADER_INCLUDED
+#define OPM_NONLINEARSOLVER_HEADER_INCLUDED
 
 #include <opm/autodiff/AutoDiffBlock.hpp>
 #include <opm/core/utility/parameters/ParameterGroup.hpp>
@@ -28,9 +28,10 @@
 namespace Opm {
 
 
-    /// A Newton solver class suitable for general fully-implicit models.
+    /// A nonlinear solver class suitable for general fully-implicit models,
+    /// as well as pressure, transport and sequential models.
     template <class PhysicalModel>
-    class NewtonSolver
+    class NonlinearSolver
     {
     public:
         // ---------  Types and enums  ---------
@@ -38,18 +39,18 @@ namespace Opm {
         typedef ADB::V V;
         typedef ADB::M M;
 
-        // The Newton relaxation scheme type
+        // Available relaxation scheme types.
         enum RelaxType { DAMPEN, SOR };
 
-        // Solver parameters controlling nonlinear Newton process.
+        // Solver parameters controlling nonlinear process.
         struct SolverParameters
         {
             enum RelaxType relax_type_;
             double         relax_max_;
             double         relax_increment_;
             double         relax_rel_tol_;
-            int            max_iter_; // max newton iterations
-            int            min_iter_; // min newton iterations
+            int            max_iter_; // max nonlinear iterations
+            int            min_iter_; // min nonlinear iterations
 
             explicit SolverParameters( const parameter::ParameterGroup& param );
             SolverParameters();
@@ -66,11 +67,11 @@ namespace Opm {
         /// Construct solver for a given model.
         ///
         /// The model is a std::unique_ptr because the object to which model points to is
-        /// not allowed to be deleted as long as the NewtonSolver object exists.
+        /// not allowed to be deleted as long as the NonlinearSolver object exists.
         ///
-        /// \param[in]      param   parameters controlling nonlinear Newton process
+        /// \param[in]      param   parameters controlling nonlinear process
         /// \param[in, out] model   physical simulation model.
-        explicit NewtonSolver(const SolverParameters& param,
+        explicit NonlinearSolver(const SolverParameters& param,
                               std::unique_ptr<PhysicalModel> model);
 
         /// Take a single forward step, after which the states will be modified
@@ -84,14 +85,14 @@ namespace Opm {
              ReservoirState& reservoir_state,
              WellState& well_state);
 
-        /// Number of Newton iterations used in all calls to step().
-        unsigned int newtonIterations() const;
+        /// Number of nonlinear solver iterations used in all calls to step().
+        unsigned int nonlinearIterations() const;
 
         /// Number of linear solver iterations used in all calls to step().
         unsigned int linearIterations() const;
 
-        /// Number of linear solver iterations used in the last call to step().
-        unsigned int newtonIterationsLastStep() const;
+        /// Number of nonlinear solver iterations used in the last call to step().
+        unsigned int nonlinearIterationsLastStep() const;
 
         /// Number of linear solver iterations used in the last call to step().
         unsigned int linearIterationsLastStep() const;
@@ -103,9 +104,9 @@ namespace Opm {
         // ---------  Data members  ---------
         SolverParameters param_;
         std::unique_ptr<PhysicalModel> model_;
-        unsigned int newtonIterations_;
+        unsigned int nonlinearIterations_;
         unsigned int linearIterations_;
-        unsigned int newtonIterationsLast_;
+        unsigned int nonlinearIterationsLast_;
         unsigned int linearIterationsLast_;
 
         // ---------  Private methods  ---------
@@ -115,13 +116,13 @@ namespace Opm {
         double relaxRelTol() const       { return param_.relax_rel_tol_; }
         double maxIter() const           { return param_.max_iter_; }
         double minIter() const           { return param_.min_iter_; }
-        void detectNewtonOscillations(const std::vector<std::vector<double>>& residual_history,
-                                      const int it, const double relaxRelTol,
-                                      bool& oscillate, bool& stagnate) const;
-        void stabilizeNewton(V& dx, V& dxOld, const double omega, const RelaxType relax_type) const;
+        void detectOscillations(const std::vector<std::vector<double>>& residual_history,
+                                const int it, const double relaxRelTol,
+                                bool& oscillate, bool& stagnate) const;
+        void stabilizeNonlinearUpdate(V& dx, V& dxOld, const double omega, const RelaxType relax_type) const;
     };
 } // namespace Opm
 
-#include "NewtonSolver_impl.hpp"
+#include "NonlinearSolver_impl.hpp"
 
-#endif // OPM_NEWTONSOLVER_HEADER_INCLUDED
+#endif // OPM_NONLINEARSOLVER_HEADER_INCLUDED
diff --git a/opm/autodiff/NewtonSolver_impl.hpp b/opm/autodiff/NonlinearSolver_impl.hpp
similarity index 76%
rename from opm/autodiff/NewtonSolver_impl.hpp
rename to opm/autodiff/NonlinearSolver_impl.hpp
index 095f7f8db..00b2e20ee 100644
--- a/opm/autodiff/NewtonSolver_impl.hpp
+++ b/opm/autodiff/NonlinearSolver_impl.hpp
@@ -20,31 +20,33 @@
   along with OPM.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef OPM_NEWTONSOLVER_IMPL_HEADER_INCLUDED
-#define OPM_NEWTONSOLVER_IMPL_HEADER_INCLUDED
+#ifndef OPM_NONLINEARSOLVER_IMPL_HEADER_INCLUDED
+#define OPM_NONLINEARSOLVER_IMPL_HEADER_INCLUDED
 
-#include <opm/autodiff/NewtonSolver.hpp>
+#include <opm/autodiff/NonlinearSolver.hpp>
 
 namespace Opm
 {
     template <class PhysicalModel>
-    NewtonSolver<PhysicalModel>::NewtonSolver(const SolverParameters& param,
-                                              std::unique_ptr<PhysicalModel> model)
+    NonlinearSolver<PhysicalModel>::NonlinearSolver(const SolverParameters& param,
+                                                    std::unique_ptr<PhysicalModel> model)
         : param_(param),
           model_(std::move(model)),
-          newtonIterations_(0),
-          linearIterations_(0)
+          nonlinearIterations_(0),
+          linearIterations_(0),
+          nonlinearIterationsLast_(0),
+          linearIterationsLast_(0)
     {
     }
 
     template <class PhysicalModel>
-    unsigned int NewtonSolver<PhysicalModel>::newtonIterations () const
+    unsigned int NonlinearSolver<PhysicalModel>::nonlinearIterations() const
     {
-        return newtonIterations_;
+        return nonlinearIterations_;
     }
 
     template <class PhysicalModel>
-    unsigned int NewtonSolver<PhysicalModel>::linearIterations () const
+    unsigned int NonlinearSolver<PhysicalModel>::linearIterations() const
     {
         return linearIterations_;
     }
@@ -56,9 +58,22 @@ namespace Opm
         return *model_;
     }
 
+    template <class PhysicalModel>
+    unsigned int NonlinearSolver<PhysicalModel>::nonlinearIterationsLastStep() const
+    {
+        return nonlinearIterationsLast_;
+    }
+
+    template <class PhysicalModel>
+    unsigned int NonlinearSolver<PhysicalModel>::linearIterationsLastStep() const
+    {
+        return linearIterationsLast_;
+    }
+
+
     template <class PhysicalModel>
     int
-    NewtonSolver<PhysicalModel>::
+    NonlinearSolver<PhysicalModel>::
     step(const double dt,
          ReservoirState& reservoir_state,
          WellState& well_state)
@@ -74,7 +89,7 @@ namespace Opm
         model_->assemble(reservoir_state, well_state, true);
         residual_norms_history.push_back(model_->computeResidualNorms());
 
-        // Set up for main Newton loop.
+        // Set up for main solver loop.
         double omega = 1.0;
         int iteration = 0;
         bool converged = model_->getConvergence(dt, iteration);
@@ -85,16 +100,16 @@ namespace Opm
         const enum RelaxType relaxtype = relaxType();
         int linIters = 0;
 
-        // ----------  Main Newton loop  ----------
+        // ----------  Main nonlinear solver loop  ----------
         while ( (!converged && (iteration < maxIter())) || (minIter() > iteration)) {
-            // Compute the Newton update to the primary variables.
+            // Compute the update to the primary variables.
             V dx = model_->solveJacobianSystem();
 
             // Store number of linear iterations used.
             linIters += model_->linearIterationsLastSolve();
 
-            // Stabilize the Newton update.
-            detectNewtonOscillations(residual_norms_history, iteration, relaxRelTol(), isOscillate, isStagnate);
+            // Stabilize the nonlinear update.
+            detectOscillations(residual_norms_history, iteration, relaxRelTol(), isOscillate, isStagnate);
             if (isOscillate) {
                 omega -= relaxIncrement();
                 omega = std::max(omega, relaxMax());
@@ -102,7 +117,7 @@ namespace Opm
                     std::cout << " Oscillating behavior detected: Relaxation set to " << omega << std::endl;
                 }
             }
-            stabilizeNewton(dx, dxOld, omega, relaxtype);
+            stabilizeNonlinearUpdate(dx, dxOld, omega, relaxtype);
 
             // Apply the update, the model may apply model-dependent
             // limitations and chopping of the update.
@@ -126,9 +141,9 @@ namespace Opm
         }
 
         linearIterations_ += linIters;
-        newtonIterations_ += iteration;
+        nonlinearIterations_ += iteration;
         linearIterationsLast_ = linIters;
-        newtonIterationsLast_ = iteration;
+        nonlinearIterationsLast_ = iteration;
 
         // Do model-specific post-step actions.
         model_->afterStep(dt, reservoir_state, well_state);
@@ -139,7 +154,7 @@ namespace Opm
 
 
     template <class PhysicalModel>
-    void NewtonSolver<PhysicalModel>::SolverParameters::
+    void NonlinearSolver<PhysicalModel>::SolverParameters::
     reset()
     {
         // default values for the solver parameters
@@ -152,7 +167,7 @@ namespace Opm
     }
 
     template <class PhysicalModel>
-    NewtonSolver<PhysicalModel>::SolverParameters::
+    NonlinearSolver<PhysicalModel>::SolverParameters::
     SolverParameters()
     {
         // set default values
@@ -160,7 +175,7 @@ namespace Opm
     }
 
     template <class PhysicalModel>
-    NewtonSolver<PhysicalModel>::SolverParameters::
+    NonlinearSolver<PhysicalModel>::SolverParameters::
     SolverParameters( const parameter::ParameterGroup& param )
     {
         // set default values
@@ -183,9 +198,9 @@ namespace Opm
 
     template <class PhysicalModel>
     void
-    NewtonSolver<PhysicalModel>::detectNewtonOscillations(const std::vector<std::vector<double>>& residual_history,
-                                                          const int it, const double relaxRelTol_arg,
-                                                          bool& oscillate, bool& stagnate) const
+    NonlinearSolver<PhysicalModel>::detectOscillations(const std::vector<std::vector<double>>& residual_history,
+                                                       const int it, const double relaxRelTol_arg,
+                                                       bool& oscillate, bool& stagnate) const
     {
         // The detection of oscillation in two primary variable results in the report of the detection
         // of oscillation for the solver.
@@ -220,8 +235,8 @@ namespace Opm
 
     template <class PhysicalModel>
     void
-    NewtonSolver<PhysicalModel>::stabilizeNewton(V& dx, V& dxOld, const double omega,
-                                                 const RelaxType relax_type) const
+    NonlinearSolver<PhysicalModel>::stabilizeNonlinearUpdate(V& dx, V& dxOld, const double omega,
+                                                             const RelaxType relax_type) const
     {
         // The dxOld is updated with dx.
         // If omega is equal to 1., no relaxtion will be appiled.
diff --git a/opm/autodiff/SimulatorBase.hpp b/opm/autodiff/SimulatorBase.hpp
index 80069e74c..5e22d9326 100644
--- a/opm/autodiff/SimulatorBase.hpp
+++ b/opm/autodiff/SimulatorBase.hpp
@@ -26,7 +26,6 @@
 #include <opm/common/ErrorMacros.hpp>
 
 #include <opm/autodiff/GeoProps.hpp>
-#include <opm/autodiff/NewtonSolver.hpp>
 #include <opm/autodiff/BlackoilModel.hpp>
 #include <opm/autodiff/BlackoilPropsAdInterface.hpp>
 #include <opm/autodiff/WellStateFullyImplicitBlackoil.hpp>
diff --git a/opm/autodiff/SimulatorBase_impl.hpp b/opm/autodiff/SimulatorBase_impl.hpp
index 3154f73ed..72be25bf5 100644
--- a/opm/autodiff/SimulatorBase_impl.hpp
+++ b/opm/autodiff/SimulatorBase_impl.hpp
@@ -106,7 +106,7 @@ namespace Opm
             output_writer_.restore( timer, state, prev_well_state, restorefilename, desiredRestoreStep );
         }
 
-        unsigned int totalNewtonIterations = 0;
+        unsigned int totalNonlinearIterations = 0;
         unsigned int totalLinearIterations = 0;
 
         // Main simulation loop.
@@ -167,8 +167,8 @@ namespace Opm
             // take time that was used to solve system for this reportStep
             solver_timer.stop();
 
-            // accumulate the number of Newton and Linear Iterations
-            totalNewtonIterations += solver->newtonIterations();
+            // accumulate the number of nonlinear and linear Iterations
+            totalNonlinearIterations += solver->nonlinearIterations();
             totalLinearIterations += solver->linearIterations();
 
             // Report timing.
@@ -201,7 +201,7 @@ namespace Opm
         report.pressure_time = stime;
         report.transport_time = 0.0;
         report.total_time = total_timer.secsSinceStart();
-        report.total_newton_iterations = totalNewtonIterations;
+        report.total_newton_iterations = totalNonlinearIterations;
         report.total_linear_iterations = totalLinearIterations;
         return report;
     }
diff --git a/opm/autodiff/SimulatorFullyImplicitBlackoil.hpp b/opm/autodiff/SimulatorFullyImplicitBlackoil.hpp
index dca177e5f..ef6080741 100644
--- a/opm/autodiff/SimulatorFullyImplicitBlackoil.hpp
+++ b/opm/autodiff/SimulatorFullyImplicitBlackoil.hpp
@@ -1,5 +1,5 @@
 /*
-  Copyright 2013 SINTEF ICT, Applied Mathematics.
+  Copyright 2013, 2015 SINTEF ICT, Applied Mathematics.
   Copyright 2015 Andreas Lauser
 
   This file is part of the Open Porous Media project (OPM).
@@ -21,9 +21,8 @@
 #ifndef OPM_SIMULATORFULLYIMPLICITBLACKOIL_HEADER_INCLUDED
 #define OPM_SIMULATORFULLYIMPLICITBLACKOIL_HEADER_INCLUDED
 
-#include "SimulatorBase.hpp"
-
-#include "NewtonSolver.hpp"
+#include <opm/autodiff/SimulatorBase.hpp>
+#include <opm/autodiff/NonlinearSolver.hpp>
 
 namespace Opm {
 
@@ -38,7 +37,7 @@ struct SimulatorTraits<SimulatorFullyImplicitBlackoil<GridT> >
     typedef BlackoilOutputWriter OutputWriter;
     typedef GridT Grid;
     typedef BlackoilModel<Grid> Model;
-    typedef NewtonSolver<Model> Solver;
+    typedef NonlinearSolver<Model> Solver;
 };
 
 /// a simulator for the blackoil model
diff --git a/opm/autodiff/SimulatorFullyImplicitBlackoilSolvent.hpp b/opm/autodiff/SimulatorFullyImplicitBlackoilSolvent.hpp
index 1919bdaf4..823e11485 100644
--- a/opm/autodiff/SimulatorFullyImplicitBlackoilSolvent.hpp
+++ b/opm/autodiff/SimulatorFullyImplicitBlackoilSolvent.hpp
@@ -32,7 +32,7 @@
 #include <opm/autodiff/BlackoilPropsAdInterface.hpp>
 #include <opm/autodiff/SolventPropsAdFromDeck.hpp>
 #include <opm/autodiff/RateConverter.hpp>
-#include <opm/autodiff/NewtonSolver.hpp>
+#include <opm/autodiff/NonlinearSolver.hpp>
 #include <opm/autodiff/WellStateFullyImplicitBlackoilSolvent.hpp>
 
 #include <opm/core/grid.h>
@@ -88,7 +88,7 @@ namespace Opm
         typedef BlackoilOutputWriter OutputWriter;
         typedef GridT Grid;
         typedef BlackoilSolventModel<Grid> Model;
-        typedef NewtonSolver<Model> Solver;
+        typedef NonlinearSolver<Model> Solver;
     };
 
     /// Class collecting all necessary components for a blackoil simulation with polymer