diff --git a/dumux/adaptive/initializationindicator.hh b/dumux/adaptive/initializationindicator.hh
index c073f9d2ff9abd970a01a2217dae5d3accd8da52..885def68414a3525c5fed00886f5103c9e6a189e 100644
--- a/dumux/adaptive/initializationindicator.hh
+++ b/dumux/adaptive/initializationindicator.hh
@@ -49,7 +49,7 @@ class GridAdaptInitializationIndicator
     using Element = typename GridView::Traits::template Codim<0>::Entity;
 
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
 
     static constexpr bool isBox = GetPropType<TypeTag, Properties::GridGeometry>::discMethod == DiscretizationMethod::box;
@@ -66,14 +66,14 @@ public:
      *       - Adaptive.RefineAtSource If to refine where source terms are specified (default: true)
      *       - Adaptive.BCRefinementThreshold The threshold above which fluxes are treated as non-zero (default: 1e-10)
      * \param problem The problem object
-     * \param fvGridGeometry The finite volume geometry of the grid
+     * \param gridGeometry The finite volume geometry of the grid
      * \param gridVariables The secondary variables on the grid
      */
     GridAdaptInitializationIndicator(std::shared_ptr<const Problem> problem,
-                                     std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+                                     std::shared_ptr<const GridGeometry> gridGeometry,
                                      std::shared_ptr<const GridVariables> gridVariables)
     : problem_(problem)
-    , fvGridGeometry_(fvGridGeometry)
+    , gridGeometry_(gridGeometry)
     , gridVariables_(gridVariables)
     , minLevel_(getParamFromGroup<int>(problem->paramGroup(), "Adaptive.MinLevel"))
     , maxLevel_(getParamFromGroup<int>(problem->paramGroup(), "Adaptive.MaxLevel"))
@@ -141,11 +141,11 @@ public:
     void calculate(const SolutionVector& sol)
     {
         //! prepare an indicator for refinement
-        indicatorVector_.assign(fvGridGeometry_->gridView().size(0), false);
+        indicatorVector_.assign(gridGeometry_->gridView().size(0), false);
 
-        for (const auto& element : elements(fvGridGeometry_->gridView()))
+        for (const auto& element : elements(gridGeometry_->gridView()))
         {
-            const auto eIdx = fvGridGeometry_->elementMapper().index(element);
+            const auto eIdx = gridGeometry_->elementMapper().index(element);
 
             //! refine any element being below the minimum level
             if (element.level() < minLevel_)
@@ -163,7 +163,7 @@ public:
                 continue;
 
             // get the fvGeometry and elementVolVars needed for the bc and source interfaces
-            auto fvGeometry = localView(*fvGridGeometry_);
+            auto fvGeometry = localView(*gridGeometry_);
             fvGeometry.bind(element);
 
             auto elemVolVars = localView(gridVariables_->curGridVolVars());
@@ -274,14 +274,14 @@ public:
      */
     int operator() (const Element& element) const
     {
-        if (indicatorVector_[fvGridGeometry_->elementMapper().index(element)])
+        if (indicatorVector_[gridGeometry_->elementMapper().index(element)])
             return 1;
         return 0;
     }
 
 private:
     std::shared_ptr<const Problem> problem_;               //!< The problem to be solved
-    std::shared_ptr<const FVGridGeometry> fvGridGeometry_; //!< The finite volume grid geometry
+    std::shared_ptr<const GridGeometry> gridGeometry_; //!< The finite volume grid geometry
     std::shared_ptr<const GridVariables> gridVariables_;   //!< The secondary variables on the grid
     std::vector<bool> indicatorVector_;                    //!< Indicator for BCs/sources
 
diff --git a/dumux/assembly/cclocalassembler.hh b/dumux/assembly/cclocalassembler.hh
index 633f8668b78b6eb10d078e396acfdd1e11c88b25..025f89feb66dc04e03f535ca9a5d475fe94b56eb 100644
--- a/dumux/assembly/cclocalassembler.hh
+++ b/dumux/assembly/cclocalassembler.hh
@@ -137,8 +137,8 @@ class CCLocalAssembler<TypeTag, Assembler, DiffMethod::numeric, /*implicit=*/tru
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using Element = typename GetPropType<TypeTag, Properties::GridView>::template Codim<0>::Entity;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
     using JacobianMatrix = GetPropType<TypeTag, Properties::JacobianMatrix>;
 
@@ -146,7 +146,7 @@ class CCLocalAssembler<TypeTag, Assembler, DiffMethod::numeric, /*implicit=*/tru
     enum { dim = GetPropType<TypeTag, Properties::GridView>::dimension };
 
     using FluxStencil = Dumux::FluxStencil<FVElementGeometry>;
-    static constexpr int maxElementStencilSize = FVGridGeometry::maxElementStencilSize;
+    static constexpr int maxElementStencilSize = GridGeometry::maxElementStencilSize;
     static constexpr bool enableGridFluxVarsCache = getPropValue<TypeTag, Properties::EnableGridFluxVariablesCache>();
 
 public:
@@ -170,13 +170,13 @@ public:
         // get some aliases for convenience
         const auto& element = this->element();
         const auto& fvGeometry = this->fvGeometry();
-        const auto& fvGridGeometry = this->assembler().gridGeometry();
+        const auto& gridGeometry = this->assembler().gridGeometry();
         auto&& curElemVolVars = this->curElemVolVars();
         auto&& elemFluxVarsCache = this->elemFluxVarsCache();
 
         // get stencil informations
-        const auto globalI = fvGridGeometry.elementMapper().index(element);
-        const auto& connectivityMap = fvGridGeometry.connectivityMap();
+        const auto globalI = gridGeometry.elementMapper().index(element);
+        const auto& connectivityMap = gridGeometry.connectivityMap();
         const auto numNeighbors = connectivityMap[globalI].size();
 
         // container to store the neighboring elements
@@ -203,7 +203,7 @@ public:
         unsigned int j = 1;
         for (const auto& dataJ : connectivityMap[globalI])
         {
-            neighborElements[j-1] = fvGridGeometry.element(dataJ.globalJ);
+            neighborElements[j-1] = gridGeometry.element(dataJ.globalJ);
             for (const auto scvfIdx : dataJ.scvfsJ)
                 origResiduals[j] += evalNeighborFlux(neighborElements[j-1], fvGeometry.scvf(scvfIdx));
 
@@ -221,7 +221,7 @@ public:
         const auto origVolVars = curVolVars;
 
         // element solution container to be deflected
-        auto elemSol = elementSolution(element, curSol, fvGridGeometry);
+        auto elemSol = elementSolution(element, curSol, gridGeometry);
 
         // derivatives in the neighbors with repect to the current elements
         // in index 0 we save the derivative of the element residual with respect to it's own dofs
@@ -349,11 +349,11 @@ public:
         // get some aliases for convenience
         const auto& element = this->element();
         const auto& fvGeometry = this->fvGeometry();
-        const auto& fvGridGeometry = this->assembler().gridGeometry();
+        const auto& gridGeometry = this->assembler().gridGeometry();
         auto&& curElemVolVars = this->curElemVolVars();
 
         // reference to the element's scv (needed later) and corresponding vol vars
-        const auto globalI = fvGridGeometry.elementMapper().index(element);
+        const auto globalI = gridGeometry.elementMapper().index(element);
         const auto& scv = fvGeometry.scv(globalI);
         auto& curVolVars = ParentType::getVolVarAccess(gridVariables.curGridVolVars(), curElemVolVars, scv);
 
@@ -364,7 +364,7 @@ public:
         const auto origVolVars = curVolVars;
 
         // element solution container to be deflected
-        auto elemSol = elementSolution(element, curSol, fvGridGeometry);
+        auto elemSol = elementSolution(element, curSol, gridGeometry);
 
         NumEqVector partialDeriv;
 
diff --git a/dumux/assembly/fvlocalresidual.hh b/dumux/assembly/fvlocalresidual.hh
index b933a7d7d07002b407391ab7b09eaeefc7595f49..22ed0e4e98e35b2c2095d5bf296489e5befdcf0a 100644
--- a/dumux/assembly/fvlocalresidual.hh
+++ b/dumux/assembly/fvlocalresidual.hh
@@ -50,7 +50,7 @@ class FVLocalResidual
     using Element = typename GridView::template Codim<0>::Entity;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
@@ -88,18 +88,18 @@ public:
      * \param problem The problem to solve
      * \param element The DUNE Codim<0> entity for which the storage
      *                term ought to be calculated
-     * \param fvGridGeometry The finite-volume grid geometry
+     * \param gridGeometry The finite-volume grid geometry
      * \param gridVariables The grid variables (volume and flux variables)
      * \param sol The solution vector
      */
     ElementResidualVector evalStorage(const Problem& problem,
                                       const Element &element,
-                                      const FVGridGeometry& fvGridGeometry,
+                                      const GridGeometry& gridGeometry,
                                       const GridVariables& gridVariables,
                                       const SolutionVector& sol) const
     {
         // make sure FVElementGeometry and volume variables are bound to the element
-        auto fvGeometry = localView(fvGridGeometry);
+        auto fvGeometry = localView(gridGeometry);
         fvGeometry.bind(element);
 
         auto elemVolVars = localView(gridVariables.curGridVolVars());
diff --git a/dumux/assembly/partialreassembler.hh b/dumux/assembly/partialreassembler.hh
index 9e986758b827e6f166c42ba33add94be371c1797..f164191967a0a49f7abccda5ded0a9f959483315 100644
--- a/dumux/assembly/partialreassembler.hh
+++ b/dumux/assembly/partialreassembler.hh
@@ -99,10 +99,10 @@ template<class Assembler>
 class PartialReassemblerEngine<Assembler, DiscretizationMethod::box>
 {
     using Scalar = typename Assembler::Scalar;
-    using FVGridGeometry = typename Assembler::GridGeometry;
+    using GridGeometry = typename Assembler::GridGeometry;
     using JacobianMatrix = typename Assembler::JacobianMatrix;
-    using VertexMapper = typename FVGridGeometry::VertexMapper;
-    static constexpr int dim = FVGridGeometry::GridView::dimension;
+    using VertexMapper = typename GridGeometry::VertexMapper;
+    static constexpr int dim = GridGeometry::GridView::dimension;
 
 public:
     PartialReassemblerEngine(const Assembler& assembler)
@@ -115,10 +115,10 @@ public:
                               const std::vector<Scalar>& distanceFromLastLinearization,
                               Scalar threshold)
     {
-        const auto& fvGridGeometry = assembler.gridGeometry();
-        const auto& gridView = fvGridGeometry.gridView();
-        const auto& elementMapper = fvGridGeometry.elementMapper();
-        const auto& vertexMapper = fvGridGeometry.vertexMapper();
+        const auto& gridGeometry = assembler.gridGeometry();
+        const auto& gridView = gridGeometry.gridView();
+        const auto& elementMapper = gridGeometry.elementMapper();
+        const auto& vertexMapper = gridGeometry.vertexMapper();
 
         // set all vertices to green
         vertexColor_.assign(vertexColor_.size(), EntityColor::green);
@@ -305,7 +305,7 @@ template<class Assembler>
 class PartialReassemblerEngine<Assembler, DiscretizationMethod::cctpfa>
 {
     using Scalar = typename Assembler::Scalar;
-    using FVGridGeometry = typename Assembler::GridGeometry;
+    using GridGeometry = typename Assembler::GridGeometry;
     using JacobianMatrix = typename Assembler::JacobianMatrix;
 
 public:
@@ -318,9 +318,9 @@ public:
                               const std::vector<Scalar>& distanceFromLastLinearization,
                               Scalar threshold)
     {
-        const auto& fvGridGeometry = assembler.gridGeometry();
-        const auto& gridView = fvGridGeometry.gridView();
-        const auto& elementMapper = fvGridGeometry.elementMapper();
+        const auto& gridGeometry = assembler.gridGeometry();
+        const auto& gridView = gridGeometry.gridView();
+        const auto& elementMapper = gridGeometry.elementMapper();
 
         // mark the red elements
         for (const auto& element : elements(gridView))
@@ -340,7 +340,7 @@ public:
         }
 
         // mark the neighbors also red
-        const auto& connectivityMap = fvGridGeometry.connectivityMap();
+        const auto& connectivityMap = gridGeometry.connectivityMap();
         for (unsigned eIdx = 0; eIdx < elementColor_.size(); ++eIdx)
         {
             if (elementColor_[eIdx] == EntityColor::red)
@@ -423,11 +423,11 @@ template<class Assembler>
 class PartialReassembler
 {
     using Scalar = typename Assembler::Scalar;
-    using FVGridGeometry = typename Assembler::GridGeometry;
+    using GridGeometry = typename Assembler::GridGeometry;
     using JacobianMatrix = typename Assembler::JacobianMatrix;
-    using VertexMapper = typename FVGridGeometry::VertexMapper;
+    using VertexMapper = typename GridGeometry::VertexMapper;
 
-    static constexpr DiscretizationMethod discMethod = FVGridGeometry::discMethod;
+    static constexpr DiscretizationMethod discMethod = GridGeometry::discMethod;
     using Engine = PartialReassemblerEngine<Assembler, discMethod>;
 
 public:
@@ -440,9 +440,9 @@ public:
     : engine_(assembler)
     , greenElems_(0)
     {
-        const auto& fvGridGeometry = assembler.gridGeometry();
-        totalElems_ = fvGridGeometry.elementMapper().size();
-        totalElems_ = fvGridGeometry.gridView().comm().sum(totalElems_);
+        const auto& gridGeometry = assembler.gridGeometry();
+        totalElems_ = gridGeometry.elementMapper().size();
+        totalElems_ = gridGeometry.gridView().comm().sum(totalElems_);
     }
 
     /*!
diff --git a/dumux/assembly/staggeredfvassembler.hh b/dumux/assembly/staggeredfvassembler.hh
index bcd7f3d7a75e4d905f688167ecc63b54f1ae7633..786b99a533fed2679c420768e77e9093d2c19147 100644
--- a/dumux/assembly/staggeredfvassembler.hh
+++ b/dumux/assembly/staggeredfvassembler.hh
@@ -101,12 +101,12 @@ public:
 
     //! The constructor for instationary problems
     StaggeredFVAssembler(std::shared_ptr<const Problem> problem,
-                         std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+                         std::shared_ptr<const GridGeometry> gridGeometry,
                          std::shared_ptr<GridVariables> gridVariables,
                          std::shared_ptr<const TimeLoop> timeLoop,
                          const SolutionVector& prevSol)
     : ParentType(std::make_tuple(problem, problem),
-                 std::make_tuple(fvGridGeometry->cellCenterFVGridGeometryPtr(), fvGridGeometry->faceFVGridGeometryPtr()),
+                 std::make_tuple(gridGeometry->cellCenterFVGridGeometryPtr(), gridGeometry->faceFVGridGeometryPtr()),
                  std::make_tuple(gridVariables->cellCenterGridVariablesPtr(), gridVariables->faceGridVariablesPtr()),
                  std::make_shared<CouplingManager>(),
                  timeLoop,
@@ -129,7 +129,7 @@ public:
     { return gridGeometry(); }
 
     const GridGeometry& gridGeometry() const
-    { return ParentType::gridGeometry(Dune::index_constant<0>()).actualfvGridGeometry(); }
+    { return ParentType::gridGeometry(Dune::index_constant<0>()).actualGridGeometry(); }
 
 };
 
diff --git a/dumux/common/fvproblem.hh b/dumux/common/fvproblem.hh
index b40f3337b15e32898c07ad25ec54832260967087..ad06c7aebfe33b792eb9d62af0a049b6b9bfdc64 100644
--- a/dumux/common/fvproblem.hh
+++ b/dumux/common/fvproblem.hh
@@ -50,9 +50,9 @@ class FVProblem
 {
     using Implementation = GetPropType<TypeTag, Properties::Problem>;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using Element = typename GridView::template Codim<0>::Entity;
@@ -72,8 +72,8 @@ class FVProblem
 
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
 
-    static constexpr bool isBox = FVGridGeometry::discMethod == DiscretizationMethod::box;
-    static constexpr bool isStaggered = FVGridGeometry::discMethod == DiscretizationMethod::staggered;
+    static constexpr bool isBox = GridGeometry::discMethod == DiscretizationMethod::box;
+    static constexpr bool isStaggered = GridGeometry::discMethod == DiscretizationMethod::staggered;
 
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
@@ -92,11 +92,11 @@ public:
 
     /*!
      * \brief Constructor
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param paramGroup The parameter group in which to look for runtime parameters first (default is "")
      */
-    FVProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup = "")
-    : fvGridGeometry_(fvGridGeometry)
+    FVProblem(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup = "")
+    : gridGeometry_(gridGeometry)
     , paramGroup_(paramGroup)
     {
         // set a default name for the problem
@@ -439,7 +439,7 @@ public:
     {
         NumEqVector source(0);
         auto scvIdx = scv.indexInElement();
-        auto key = std::make_pair(fvGridGeometry_->elementMapper().index(element), scvIdx);
+        auto key = std::make_pair(gridGeometry_->elementMapper().index(element), scvIdx);
         if (pointSourceMap_.count(key))
         {
             // call the solDependent function. Herein the user might fill/add values to the point sources
@@ -493,7 +493,7 @@ public:
         if (!sources.empty())
         {
             // calculate point source locations and save them in a map
-            PointSourceHelper::computePointSourceMap(*fvGridGeometry_,
+            PointSourceHelper::computePointSourceMap(*gridGeometry_,
                                                      sources,
                                                      pointSourceMap_);
         }
@@ -581,12 +581,12 @@ public:
 
     //! The finite volume grid geometry
     [[deprecated("Use gridGeometry() instead. fvGridGeometry() will be removed after 3.1!")]]
-    const FVGridGeometry& fvGridGeometry() const
+    const GridGeometry& fvGridGeometry() const
     { return gridGeometry(); }
 
     //! The finite volume grid geometry
-    const FVGridGeometry& gridGeometry() const
-    { return *fvGridGeometry_; }
+    const GridGeometry& gridGeometry() const
+    { return *gridGeometry_; }
 
     //! The parameter group in which to retrieve runtime parameters
     const std::string& paramGroup() const
@@ -607,8 +607,8 @@ private:
      */
     void applyInitialSolutionImpl_(SolutionVector& sol, /*isBox=*/std::true_type) const
     {
-        const auto numDofs = fvGridGeometry_->vertexMapper().size();
-        const auto numVert = fvGridGeometry_->gridView().size(dim);
+        const auto numDofs = gridGeometry_->vertexMapper().size();
+        const auto numVert = gridGeometry_->gridView().size(dim);
         sol.resize(numDofs);
 
         // if there are more dofs than vertices (enriched nodal dofs), we have to
@@ -616,11 +616,11 @@ private:
         if (numDofs != numVert)
         {
             std::vector<bool> dofVisited(numDofs, false);
-            for (const auto& element : elements(fvGridGeometry_->gridView()))
+            for (const auto& element : elements(gridGeometry_->gridView()))
             {
                 for (int i = 0; i < element.subEntities(dim); ++i)
                 {
-                    const auto dofIdxGlobal = fvGridGeometry_->vertexMapper().subIndex(element, i, dim);
+                    const auto dofIdxGlobal = gridGeometry_->vertexMapper().subIndex(element, i, dim);
 
                     // forward to implementation if value at dof is not set yet
                     if (!dofVisited[dofIdxGlobal])
@@ -635,9 +635,9 @@ private:
         // otherwise we directly loop over the vertices
         else
         {
-            for (const auto& vertex : vertices(fvGridGeometry_->gridView()))
+            for (const auto& vertex : vertices(gridGeometry_->gridView()))
             {
-                const auto dofIdxGlobal = fvGridGeometry_->vertexMapper().index(vertex);
+                const auto dofIdxGlobal = gridGeometry_->vertexMapper().index(vertex);
                 sol[dofIdxGlobal] = asImp_().initial(vertex);
             }
         }
@@ -648,16 +648,16 @@ private:
      */
     void applyInitialSolutionImpl_(SolutionVector& sol, /*isBox=*/std::false_type) const
     {
-        sol.resize(fvGridGeometry_->numDofs());
-        for (const auto& element : elements(fvGridGeometry_->gridView()))
+        sol.resize(gridGeometry_->numDofs());
+        for (const auto& element : elements(gridGeometry_->gridView()))
         {
-            const auto dofIdxGlobal = fvGridGeometry_->elementMapper().index(element);
+            const auto dofIdxGlobal = gridGeometry_->elementMapper().index(element);
             sol[dofIdxGlobal] = asImp_().initial(element);
         }
     }
 
     //! The finite volume grid geometry
-    std::shared_ptr<const FVGridGeometry> fvGridGeometry_;
+    std::shared_ptr<const GridGeometry> gridGeometry_;
 
     //! The parameter group in which to retrieve runtime parameters
     std::string paramGroup_;
diff --git a/dumux/common/pointsource.hh b/dumux/common/pointsource.hh
index 7123186fc48fb4071770cc3ad50e5930c2159b91..e7c7a9f093b1b28dfbdda811cb68ec6f6c3fdeba 100644
--- a/dumux/common/pointsource.hh
+++ b/dumux/common/pointsource.hh
@@ -276,14 +276,14 @@ class BoundingBoxTreePointSourceHelper
 {
 public:
     //! calculate a DOF index to point source map from given vector of point sources
-    template<class FVGridGeometry, class PointSource, class PointSourceMap>
-    static void computePointSourceMap(const FVGridGeometry& fvGridGeometry,
+    template<class GridGeometry, class PointSource, class PointSourceMap>
+    static void computePointSourceMap(const GridGeometry& gridGeometry,
                                       std::vector<PointSource>& sources,
                                       PointSourceMap& pointSourceMap)
     {
-        constexpr bool isBox = FVGridGeometry::discMethod == DiscretizationMethod::box;
+        constexpr bool isBox = GridGeometry::discMethod == DiscretizationMethod::box;
 
-        const auto& boundingBoxTree = fvGridGeometry.boundingBoxTree();
+        const auto& boundingBoxTree = gridGeometry.boundingBoxTree();
 
         for (auto&& source : sources)
         {
@@ -298,7 +298,7 @@ public:
                 {
                     // check in which subcontrolvolume(s) we are
                     const auto element = boundingBoxTree.entitySet().entity(eIdx);
-                    auto fvGeometry = localView(fvGridGeometry);
+                    auto fvGeometry = localView(gridGeometry);
                     fvGeometry.bindElement(element);
 
                     const auto globalPos = source.position();
diff --git a/dumux/common/staggeredfvproblem.hh b/dumux/common/staggeredfvproblem.hh
index 8ce229b555776715d50124238ce71f76274dd5ca..49eb564b6fc644dc3d15359f7f5d21d94707495b 100644
--- a/dumux/common/staggeredfvproblem.hh
+++ b/dumux/common/staggeredfvproblem.hh
@@ -55,8 +55,8 @@ class StaggeredFVProblem : public FVProblem<TypeTag>
     using ElementFaceVariables = typename GridFaceVariables::LocalView;
 
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
@@ -64,8 +64,8 @@ class StaggeredFVProblem : public FVProblem<TypeTag>
     using CoordScalar = typename GridView::ctype;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
-    static constexpr auto cellCenterIdx = FVGridGeometry::cellCenterIdx();
-    static constexpr auto faceIdx = FVGridGeometry::faceIdx();
+    static constexpr auto cellCenterIdx = GridGeometry::cellCenterIdx();
+    static constexpr auto faceIdx = GridGeometry::faceIdx();
 
     static constexpr auto numEqCellCenter = getPropValue<TypeTag, Properties::NumEqCellCenter>();
     static constexpr auto numEqFace = getPropValue<TypeTag, Properties::NumEqFace>();
@@ -73,11 +73,11 @@ class StaggeredFVProblem : public FVProblem<TypeTag>
 public:
     /*!
      * \brief Constructor
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param paramGroup The parameter group in which to look for runtime parameters first (default is "")
      */
-    StaggeredFVProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, paramGroup)
+    StaggeredFVProblem(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup = "")
+    : ParentType(gridGeometry, paramGroup)
     { }
 
     /*!
diff --git a/dumux/discretization/box/elementboundarytypes.hh b/dumux/discretization/box/elementboundarytypes.hh
index aff498420f1717bada74c75393d27f1925232fd0..ac9422771db7126316859f1ec704e91a5d807ddb 100644
--- a/dumux/discretization/box/elementboundarytypes.hh
+++ b/dumux/discretization/box/elementboundarytypes.hh
@@ -52,8 +52,8 @@ public:
                 const Element &element,
                 const FVElementGeometry &fvGeometry)
     {
-        using FVGridGeometry = typename FVElementGeometry::GridGeometry;
-        using GridView = typename FVGridGeometry::GridView;
+        using GridGeometry = typename FVElementGeometry::GridGeometry;
+        using GridView = typename GridGeometry::GridView;
 
         vertexBCTypes_.resize( element.subEntities(GridView::dimension) );
 
diff --git a/dumux/discretization/box/elementsolution.hh b/dumux/discretization/box/elementsolution.hh
index 68e3bc362832e64d0d1f9353032137469ed9c1ce..bc7b80051486bd0846167c166c3c75d2b0cbdb3e 100644
--- a/dumux/discretization/box/elementsolution.hh
+++ b/dumux/discretization/box/elementsolution.hh
@@ -37,8 +37,8 @@ namespace Dumux {
 template<class FVElementGeometry, class PV>
 class BoxElementSolution
 {
-    using FVGridGeometry = typename FVElementGeometry::GridGeometry;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename FVElementGeometry::GridGeometry;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
 
 public:
@@ -51,9 +51,9 @@ public:
     //! Constructor with element and solution and grid geometry
     template<class SolutionVector>
     BoxElementSolution(const Element& element, const SolutionVector& sol,
-                       const FVGridGeometry& fvGridGeometry)
+                       const GridGeometry& gridGeometry)
     {
-        update(element, sol, fvGridGeometry);
+        update(element, sol, gridGeometry);
     }
 
     //! Constructor with element and elemVolVars and fvGeometry
@@ -70,12 +70,12 @@ public:
     //! extract the element solution from the solution vector using a mapper
     template<class SolutionVector>
     void update(const Element& element, const SolutionVector& sol,
-                const FVGridGeometry& fvGridGeometry)
+                const GridGeometry& gridGeometry)
     {
         const auto numVert = element.subEntities(GridView::dimension);
         priVars_.resize(numVert);
         for (int vIdx = 0; vIdx < numVert; ++vIdx)
-            priVars_[vIdx] = sol[fvGridGeometry.vertexMapper().subIndex(element, vIdx, GridView::dimension)];
+            priVars_[vIdx] = sol[gridGeometry.vertexMapper().subIndex(element, vIdx, GridView::dimension)];
     }
 
     //! extract the element solution from the solution vector using a local fv geometry
@@ -111,15 +111,15 @@ private:
  * \ingroup BoxDiscretization
  * \brief  Make an element solution for box schemes
  */
-template<class Element, class SolutionVector, class FVGridGeometry>
-auto elementSolution(const Element& element, const SolutionVector& sol, const FVGridGeometry& gg)
--> std::enable_if_t<FVGridGeometry::discMethod == DiscretizationMethod::box,
-                    BoxElementSolution<typename FVGridGeometry::LocalView,
+template<class Element, class SolutionVector, class GridGeometry>
+auto elementSolution(const Element& element, const SolutionVector& sol, const GridGeometry& gg)
+-> std::enable_if_t<GridGeometry::discMethod == DiscretizationMethod::box,
+                    BoxElementSolution<typename GridGeometry::LocalView,
                                       std::decay_t<decltype(std::declval<SolutionVector>()[0])>>
                     >
 {
     using PrimaryVariables = std::decay_t<decltype(std::declval<SolutionVector>()[0])>;
-    return BoxElementSolution<typename FVGridGeometry::LocalView, PrimaryVariables>(element, sol, gg);
+    return BoxElementSolution<typename GridGeometry::LocalView, PrimaryVariables>(element, sol, gg);
 }
 
 /*!
diff --git a/dumux/discretization/box/fluxvariablescache.hh b/dumux/discretization/box/fluxvariablescache.hh
index 96ca21a14ca5c009901712b8c3f69e9684fbb86e..c4013217148729c664796f4b31161402c5477a3a 100644
--- a/dumux/discretization/box/fluxvariablescache.hh
+++ b/dumux/discretization/box/fluxvariablescache.hh
@@ -35,15 +35,15 @@ namespace Dumux {
  *        For the box scheme, this class does not contain any physics-/process-dependent
  *        data. It solely stores disretization-/grid-related data.
  */
-template< class Scalar, class FVGridGeometry >
+template< class Scalar, class GridGeometry >
 class BoxFluxVariablesCache
 {
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
 
     static const int dim = GridView::dimension;
     static const int dimWorld = GridView::dimensionworld;
diff --git a/dumux/discretization/box/fvelementgeometry.hh b/dumux/discretization/box/fvelementgeometry.hh
index eaae427ae9efcc13d8953df2608eae24a37bb411..fcdd9233f3467d189d6ba2b41ef92501c9e55ce0 100644
--- a/dumux/discretization/box/fvelementgeometry.hh
+++ b/dumux/discretization/box/fvelementgeometry.hh
@@ -150,7 +150,7 @@ public:
 
     //! The global finite volume geometry we are a restriction of
     [[deprecated ("Use gridGeometry() instead. fvGridGeometry() will be removed after 3.1!")]]
-    const FVGridGeometry& fvGridGeometry() const
+    const GridGeometry& fvGridGeometry() const
     { return gridGeometry(); }
     const GridGeometry& gridGeometry() const
     { return *gridGeometryPtr_; }
@@ -271,7 +271,7 @@ public:
 
     //! The global finite volume geometry we are a restriction of
     [[deprecated ("Use gridGeometry() instead. fvGridGeometry() will be removed after 3.1!")]]
-    const FVGridGeometry& fvGridGeometry() const
+    const GridGeometry& fvGridGeometry() const
     { return gridGeometry(); }
     const GridGeometry& gridGeometry() const
     { return *gridGeometryPtr_; }
diff --git a/dumux/discretization/box/fvgridgeometry.hh b/dumux/discretization/box/fvgridgeometry.hh
index 2e6cb065bf2857699e3f64e069376f5a5716775f..6c320b26060442ca80730ba9301a1e0c6ba08f4d 100644
--- a/dumux/discretization/box/fvgridgeometry.hh
+++ b/dumux/discretization/box/fvgridgeometry.hh
@@ -56,8 +56,8 @@ struct BoxDefaultGridGeometryTraits
     using SubControlVolume = BoxSubControlVolume<GridView>;
     using SubControlVolumeFace = BoxSubControlVolumeFace<GridView>;
 
-    template<class FVGridGeometry, bool enableCache>
-    using LocalView = BoxFVElementGeometry<FVGridGeometry, enableCache>;
+    template<class GridGeometry, bool enableCache>
+    using LocalView = BoxFVElementGeometry<GridGeometry, enableCache>;
 };
 
 /*!
diff --git a/dumux/discretization/box/gridfluxvariablescache.hh b/dumux/discretization/box/gridfluxvariablescache.hh
index e28010b95f368402161036b27a8c44f8b8336847..90d6079e80d3872e85af027c327196c87801b6c0 100644
--- a/dumux/discretization/box/gridfluxvariablescache.hh
+++ b/dumux/discretization/box/gridfluxvariablescache.hh
@@ -78,8 +78,8 @@ public:
 
     BoxGridFluxVariablesCache(const Problem& problem) : problemPtr_(&problem) {}
 
-    template<class FVGridGeometry, class GridVolumeVariables, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry,
+    template<class GridGeometry, class GridVolumeVariables, class SolutionVector>
+    void update(const GridGeometry& gridGeometry,
                 const GridVolumeVariables& gridVolVars,
                 const SolutionVector& sol,
                 bool forceUpdate = false)
@@ -87,12 +87,12 @@ public:
         // Here, we do not do anything unless it is a forced update
         if (forceUpdate)
         {
-            fluxVarsCache_.resize(fvGridGeometry.gridView().size(0));
-            for (const auto& element : elements(fvGridGeometry.gridView()))
+            fluxVarsCache_.resize(gridGeometry.gridView().size(0));
+            for (const auto& element : elements(gridGeometry.gridView()))
             {
-                auto eIdx = fvGridGeometry.elementMapper().index(element);
+                auto eIdx = gridGeometry.elementMapper().index(element);
                 // bind the geometries and volume variables to the element (all the elements in stencil)
-                auto fvGeometry = localView(fvGridGeometry);
+                auto fvGeometry = localView(gridGeometry);
                 fvGeometry.bind(element);
 
                 auto elemVolVars = localView(gridVolVars);
@@ -144,8 +144,8 @@ public:
 
     BoxGridFluxVariablesCache(const Problem& problem) : problemPtr_(&problem) {}
 
-    template<class FVGridGeometry, class GridVolumeVariables, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry,
+    template<class GridGeometry, class GridVolumeVariables, class SolutionVector>
+    void update(const GridGeometry& gridGeometry,
                 const GridVolumeVariables& gridVolVars,
                 const SolutionVector& sol,
                 bool forceUpdate = false) {}
diff --git a/dumux/discretization/box/gridvolumevariables.hh b/dumux/discretization/box/gridvolumevariables.hh
index 74bc2117ecf0ea188029b7ab13ec86e431c3cff1..9a54ece6e444b0860ea0e8c34f15d52f82d45225 100644
--- a/dumux/discretization/box/gridvolumevariables.hh
+++ b/dumux/discretization/box/gridvolumevariables.hh
@@ -74,19 +74,19 @@ public:
 
     BoxGridVolumeVariables(const Problem& problem) : problemPtr_(&problem) {}
 
-    template<class FVGridGeometry, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry, const SolutionVector& sol)
+    template<class GridGeometry, class SolutionVector>
+    void update(const GridGeometry& gridGeometry, const SolutionVector& sol)
     {
-        volumeVariables_.resize(fvGridGeometry.gridView().size(0));
-        for (const auto& element : elements(fvGridGeometry.gridView()))
+        volumeVariables_.resize(gridGeometry.gridView().size(0));
+        for (const auto& element : elements(gridGeometry.gridView()))
         {
-            auto eIdx = fvGridGeometry.elementMapper().index(element);
+            auto eIdx = gridGeometry.elementMapper().index(element);
 
-            auto fvGeometry = localView(fvGridGeometry);
+            auto fvGeometry = localView(gridGeometry);
             fvGeometry.bindElement(element);
 
             // get the element solution
-            auto elemSol = elementSolution(element, sol, fvGridGeometry);
+            auto elemSol = elementSolution(element, sol, gridGeometry);
 
             // update the volvars of the element
             volumeVariables_[eIdx].resize(fvGeometry.numScv());
@@ -139,8 +139,8 @@ public:
 
     BoxGridVolumeVariables(const Problem& problem) : problemPtr_(&problem) {}
 
-    template<class FVGridGeometry, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry, const SolutionVector& sol) {}
+    template<class GridGeometry, class SolutionVector>
+    void update(const GridGeometry& gridGeometry, const SolutionVector& sol) {}
 
     const Problem& problem() const
     { return *problemPtr_;}
diff --git a/dumux/discretization/box/scvftoscvboundarytypes.hh b/dumux/discretization/box/scvftoscvboundarytypes.hh
index b7f511c1cfb373bcf1523d65ee9df282aa13f019..569fb6c4f9e5e4f82b9f9ac031c99395cce3a2eb 100644
--- a/dumux/discretization/box/scvftoscvboundarytypes.hh
+++ b/dumux/discretization/box/scvftoscvboundarytypes.hh
@@ -46,16 +46,16 @@ public:
         // only do something for box
         if (discMethod == DiscretizationMethod::box)
         {
-            const auto& fvGridGeometry = problem.gridGeometry();
-            scvBoundaryTypes.resize(fvGridGeometry.vertexMapper().size());
+            const auto& gridGeometry = problem.gridGeometry();
+            scvBoundaryTypes.resize(gridGeometry.vertexMapper().size());
             // set all equations to Neumann by default
             for (std::size_t vIdx = 0; vIdx < scvBoundaryTypes.size(); vIdx++)
                 scvBoundaryTypes[vIdx].setAllNeumann();
 
-            for (const auto& element : elements(fvGridGeometry.gridView()))
+            for (const auto& element : elements(gridGeometry.gridView()))
             {
                 // iterate over the scvfs
-                auto fvGeometry = localView(fvGridGeometry);
+                auto fvGeometry = localView(gridGeometry);
                 fvGeometry.bindElement(element);
 
                 for (const auto& scvf : scvfs(fvGeometry))
diff --git a/dumux/discretization/cellcentered/connectivitymap.hh b/dumux/discretization/cellcentered/connectivitymap.hh
index 2e775c698ba817c3a1aa0d003d000ca5b9ffb3cd..707ba3f09e3939430fa1d73e4dc6664d6636fb0a 100644
--- a/dumux/discretization/cellcentered/connectivitymap.hh
+++ b/dumux/discretization/cellcentered/connectivitymap.hh
@@ -48,14 +48,14 @@ namespace Dumux {
  *        to compute these fluxes. The same holds for scvfs in the cells J, i.e. we need only those
  *        scvfs in the cells J in which the cell I is in the stencil.
  */
-template<class FVGridGeometry>
+template<class GridGeometry>
 class CCSimpleConnectivityMap
 {
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using GridView = typename FVGridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
     using GridIndexType = typename IndexTraits<GridView>::GridIndex;
     using FluxStencil = Dumux::FluxStencil<FVElementGeometry>;
-    static constexpr int maxElemStencilSize = FVGridGeometry::maxElementStencilSize;
+    static constexpr int maxElemStencilSize = GridGeometry::maxElementStencilSize;
 
     struct DataJ
     {
@@ -73,22 +73,22 @@ public:
     /*!
      * \brief Initialize the ConnectivityMap object.
      *
-     * \param fvGridGeometry The grid's finite volume geometry.
+     * \param gridGeometry The grid's finite volume geometry.
      */
-    void update(const FVGridGeometry& fvGridGeometry)
+    void update(const GridGeometry& gridGeometry)
     {
         map_.clear();
-        map_.resize(fvGridGeometry.gridView().size(0));
+        map_.resize(gridGeometry.gridView().size(0));
 
         // container to store for each element J the elements I which have J in their flux stencil
         Dune::ReservedVector<std::pair<GridIndexType, DataJ>, maxElemStencilSize> dataJForI;
 
-        for (const auto& element : elements(fvGridGeometry.gridView()))
+        for (const auto& element : elements(gridGeometry.gridView()))
         {
             // We are looking for the elements I, for which this element J is in the flux stencil
-            const auto globalJ = fvGridGeometry.elementMapper().index(element);
+            const auto globalJ = gridGeometry.elementMapper().index(element);
 
-            auto fvGeometry = localView(fvGridGeometry);
+            auto fvGeometry = localView(gridGeometry);
             fvGeometry.bindElement(element);
 
             // obtain the data of J in elements I
@@ -115,7 +115,7 @@ public:
                         if (dataJForI.size() > maxElemStencilSize - 1)
                             DUNE_THROW(Dune::InvalidStateException, "Maximum admissible stencil size (" << maxElemStencilSize-1
                                                                      << ") is surpassed (" << dataJForI.size() << "). "
-                                                                     << "Please adjust the FVGridGeometry traits accordingly!");
+                                                                     << "Please adjust the GridGeometry traits accordingly!");
 
                         dataJForI.push_back(std::make_pair(globalI, DataJ({globalJ, {scvf.index()}, {}})));
                     }
diff --git a/dumux/discretization/cellcentered/elementsolution.hh b/dumux/discretization/cellcentered/elementsolution.hh
index abf1a0bad7e484dbc64ba8e0bee005bee6f5efb5..5aabd0934e329694e58a65ba5ab512c42e05089d 100644
--- a/dumux/discretization/cellcentered/elementsolution.hh
+++ b/dumux/discretization/cellcentered/elementsolution.hh
@@ -38,8 +38,8 @@ namespace Dumux {
 template<class FVElementGeometry, class PV>
 class CCElementSolution
 {
-    using FVGridGeometry = typename FVElementGeometry::GridGeometry;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename FVElementGeometry::GridGeometry;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
 
 public:
@@ -52,8 +52,8 @@ public:
     //! Constructor with element, solution vector and grid geometry
     template<class SolutionVector>
     CCElementSolution(const Element& element, const SolutionVector& sol,
-                      const FVGridGeometry& fvGridGeometry)
-    : CCElementSolution(sol[fvGridGeometry.elementMapper().index(element)])
+                      const GridGeometry& gridGeometry)
+    : CCElementSolution(sol[gridGeometry.elementMapper().index(element)])
     {}
 
     //! Constructor with element, element volume variables and fv element geometry
@@ -76,9 +76,9 @@ public:
     //! extract the element solution from the solution vector using a mapper
     template<class SolutionVector>
     void update(const Element& element, const SolutionVector& sol,
-                const FVGridGeometry& fvGridGeometry)
+                const GridGeometry& gridGeometry)
     {
-        priVars_ = sol[fvGridGeometry.elementMapper().index(element)];
+        priVars_ = sol[gridGeometry.elementMapper().index(element)];
     }
 
     //! return the size of the element solution
@@ -109,16 +109,16 @@ private:
  * \ingroup CCDiscretization
  * \brief  Make an element solution for cell-centered schemes
  */
-template<class Element, class SolutionVector, class FVGridGeometry>
-auto elementSolution(const Element& element, const SolutionVector& sol, const FVGridGeometry& gg)
--> std::enable_if_t<FVGridGeometry::discMethod == DiscretizationMethod::cctpfa ||
-                    FVGridGeometry::discMethod == DiscretizationMethod::ccmpfa,
-                    CCElementSolution<typename FVGridGeometry::LocalView,
+template<class Element, class SolutionVector, class GridGeometry>
+auto elementSolution(const Element& element, const SolutionVector& sol, const GridGeometry& gg)
+-> std::enable_if_t<GridGeometry::discMethod == DiscretizationMethod::cctpfa ||
+                    GridGeometry::discMethod == DiscretizationMethod::ccmpfa,
+                    CCElementSolution<typename GridGeometry::LocalView,
                                       std::decay_t<decltype(std::declval<SolutionVector>()[0])>>
                     >
 {
     using PrimaryVariables = std::decay_t<decltype(std::declval<SolutionVector>()[0])>;
-    return CCElementSolution<typename FVGridGeometry::LocalView, PrimaryVariables>(element, sol, gg);
+    return CCElementSolution<typename GridGeometry::LocalView, PrimaryVariables>(element, sol, gg);
 }
 
 /*!
diff --git a/dumux/discretization/cellcentered/gridvolumevariables.hh b/dumux/discretization/cellcentered/gridvolumevariables.hh
index e1f69e70866f6b0d609089267e60789469dc6484..62897f109bf41e51ff3fb1d099ad3d47e6ea3906 100644
--- a/dumux/discretization/cellcentered/gridvolumevariables.hh
+++ b/dumux/discretization/cellcentered/gridvolumevariables.hh
@@ -64,20 +64,20 @@ public:
 
     CCGridVolumeVariables(const Problem& problem) : problemPtr_(&problem) {}
 
-    template<class FVGridGeometry, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry, const SolutionVector& sol)
+    template<class GridGeometry, class SolutionVector>
+    void update(const GridGeometry& gridGeometry, const SolutionVector& sol)
     {
-        const auto numScv = fvGridGeometry.numScv();
+        const auto numScv = gridGeometry.numScv();
         volumeVariables_.resize(numScv);
 
-        for (const auto& element : elements(fvGridGeometry.gridView()))
+        for (const auto& element : elements(gridGeometry.gridView()))
         {
-            auto fvGeometry = localView(fvGridGeometry);
+            auto fvGeometry = localView(gridGeometry);
             fvGeometry.bindElement(element);
 
             for (auto&& scv : scvs(fvGeometry))
             {
-                const auto elemSol = elementSolution(element, sol, fvGridGeometry);
+                const auto elemSol = elementSolution(element, sol, gridGeometry);
                 volumeVariables_[scv.dofIndex()].update(elemSol, problem(), element, scv);
             }
         }
@@ -136,8 +136,8 @@ public:
 
     CCGridVolumeVariables(const Problem& problem) : problemPtr_(&problem) {}
 
-    template<class FVGridGeometry, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry, const SolutionVector& sol) {}
+    template<class GridGeometry, class SolutionVector>
+    void update(const GridGeometry& gridGeometry, const SolutionVector& sol) {}
 
     //! The problem we are solving
     const Problem& problem() const
diff --git a/dumux/discretization/cellcentered/mpfa/connectivitymap.hh b/dumux/discretization/cellcentered/mpfa/connectivitymap.hh
index 8365acb2e63eb3ed856ef2885b8c9935ef7a8888..8fcab2ddb45dc4824b2d0d5f123fa01ef35878dd 100644
--- a/dumux/discretization/cellcentered/mpfa/connectivitymap.hh
+++ b/dumux/discretization/cellcentered/mpfa/connectivitymap.hh
@@ -33,12 +33,12 @@
 namespace Dumux {
 
 //! Forward declaration of method specific implementation of the assembly map
-template<class FVGridGeometry, MpfaMethods method>
+template<class GridGeometry, MpfaMethods method>
 class CCMpfaConnectivityMap;
 
 //! The o-method can use the simple (symmetric) assembly map
-template<class FVGridGeometry>
-class CCMpfaConnectivityMap<FVGridGeometry, MpfaMethods::oMethod> : public CCSimpleConnectivityMap<FVGridGeometry> {};
+template<class GridGeometry>
+class CCMpfaConnectivityMap<GridGeometry, MpfaMethods::oMethod> : public CCSimpleConnectivityMap<GridGeometry> {};
 } // end namespace Dumux
 
 #endif
diff --git a/dumux/discretization/cellcentered/mpfa/elementfluxvariablescache.hh b/dumux/discretization/cellcentered/mpfa/elementfluxvariablescache.hh
index 3c6940f60e3cf0775e3f154ac5d764dae1c87532..3c3485c53cb1d357f091f802b512d213d0d9f3d7 100644
--- a/dumux/discretization/cellcentered/mpfa/elementfluxvariablescache.hh
+++ b/dumux/discretization/cellcentered/mpfa/elementfluxvariablescache.hh
@@ -162,8 +162,8 @@ public:
         std::size_t numSecondaryIv; numSecondaryIv = 0;
         std::size_t numCaches;      numCaches = 0;
 
-        const auto& fvGridGeometry = fvGeometry.gridGeometry();
-        const auto& gridIvIndexSets = fvGridGeometry.gridInteractionVolumeIndexSets();
+        const auto& gridGeometry = fvGeometry.gridGeometry();
+        const auto& gridIvIndexSets = gridGeometry.gridInteractionVolumeIndexSets();
 
         // lambda to check if a scvf was handled already
         auto scvfHandled = [&] (auto idx)
@@ -191,21 +191,21 @@ public:
 
         // search for ivs at boundary vertices
         for (const auto& scvf : scvfs(fvGeometry))
-            fvGridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()) ?
+            gridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()) ?
                     handleScvf(scvf, gridIvIndexSets.secondaryIndexSet(scvf), true) :
                     handleScvf(scvf, gridIvIndexSets.primaryIndexSet(scvf),  false) ;
 
         // skip the rest if there are no boundary caches to be created
         if (numCaches > 0)
         {
-            const auto& assemblyMapI = fvGridGeometry.connectivityMap()[fvGridGeometry.elementMapper().index(element)];
+            const auto& assemblyMapI = gridGeometry.connectivityMap()[gridGeometry.elementMapper().index(element)];
 
             for (const auto& dataJ : assemblyMapI)
             {
                 for (const auto& scvfJIdx : dataJ.scvfsJ)
                 {
                     const auto& scvfJ = fvGeometry.scvf(scvfJIdx);
-                    if (fvGridGeometry.vertexUsesSecondaryInteractionVolume(scvfJ.vertexIndex()))
+                    if (gridGeometry.vertexUsesSecondaryInteractionVolume(scvfJ.vertexIndex()))
                         handleScvf(scvfJ, gridIvIndexSets.secondaryIndexSet(scvfJ), true);
                     else
                         handleScvf(scvfJ, gridIvIndexSets.primaryIndexSet(scvfJ), false);
@@ -320,9 +320,9 @@ private:
     template<class SubControlVolumeFace>
     bool isEmbeddedInBoundaryIV_(const SubControlVolumeFace& scvf) const
     {
-        const auto& fvGridGeometry = gridFluxVarsCachePtr_->problem().gridGeometry();
-        const auto& gridIvIndexSets = fvGridGeometry.gridInteractionVolumeIndexSets();
-        if (fvGridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()))
+        const auto& gridGeometry = gridFluxVarsCachePtr_->problem().gridGeometry();
+        const auto& gridIvIndexSets = gridGeometry.gridInteractionVolumeIndexSets();
+        if (gridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()))
             return gridIvIndexSets.secondaryIndexSet(scvf).nodalIndexSet().numBoundaryScvfs() > 0;
         else
             return gridIvIndexSets.primaryIndexSet(scvf).nodalIndexSet().numBoundaryScvfs() > 0;
@@ -397,10 +397,10 @@ public:
 
         // some references for convenience
         const auto& problem = gridFluxVarsCache().problem();
-        const auto& fvGridGeometry = fvGeometry.gridGeometry();
+        const auto& gridGeometry = fvGeometry.gridGeometry();
 
         // the assembly map of the given element
-        const auto& assemblyMapI = fvGridGeometry.connectivityMap()[fvGridGeometry.elementMapper().index(element)];
+        const auto& assemblyMapI = gridGeometry.connectivityMap()[gridGeometry.elementMapper().index(element)];
 
         // reserve memory for scvf index container
         unsigned int numNeighborScvfs = 0;
@@ -445,7 +445,7 @@ public:
 
         for (const auto& dataJ : assemblyMapI)
         {
-            const auto elementJ = fvGridGeometry.element(dataJ.globalJ);
+            const auto elementJ = gridGeometry.element(dataJ.globalJ);
             for (const auto scvfIdx : dataJ.scvfsJ)
             {
                 auto& scvfCache = fluxVarsCache_[i++];
@@ -485,8 +485,8 @@ public:
         if (FluxVariablesCacheFiller::isSolDependent)
         {
             const auto& problem = gridFluxVarsCache().problem();
-            const auto& fvGridGeometry = fvGeometry.gridGeometry();
-            const auto& assemblyMapI = fvGridGeometry.connectivityMap()[fvGridGeometry.elementMapper().index(element)];
+            const auto& gridGeometry = fvGeometry.gridGeometry();
+            const auto& assemblyMapI = gridGeometry.connectivityMap()[gridGeometry.elementMapper().index(element)];
 
             // helper class to fill flux variables caches
             FluxVariablesCacheFiller filler(problem);
@@ -506,7 +506,7 @@ public:
 
             for (const auto& dataJ : assemblyMapI)
             {
-                const auto elementJ = fvGridGeometry.element(dataJ.globalJ);
+                const auto elementJ = gridGeometry.element(dataJ.globalJ);
                 for (const auto scvfIdx : dataJ.scvfsJ)
                 {
                     auto& scvfCache = fluxVarsCache_[i++];
diff --git a/dumux/discretization/cellcentered/mpfa/elementvolumevariables.hh b/dumux/discretization/cellcentered/mpfa/elementvolumevariables.hh
index 8d3ba2f1968f7f32a81c06882774b35e8cf1c631..83b6b3a93acab074b3d263b98156c0c843a34969 100644
--- a/dumux/discretization/cellcentered/mpfa/elementvolumevariables.hh
+++ b/dumux/discretization/cellcentered/mpfa/elementvolumevariables.hh
@@ -48,13 +48,13 @@ namespace CCMpfa {
     template<class FVElementGeometry>
     std::size_t maxNumBoundaryVolVars(const FVElementGeometry& fvGeometry)
     {
-        const auto& fvGridGeometry = fvGeometry.gridGeometry();
-        const auto& gridIvIndexSets = fvGridGeometry.gridInteractionVolumeIndexSets();
+        const auto& gridGeometry = fvGeometry.gridGeometry();
+        const auto& gridIvIndexSets = gridGeometry.gridInteractionVolumeIndexSets();
 
         std::size_t numBoundaryVolVars = 0;
         for (const auto& scvf : scvfs(fvGeometry))
         {
-            if (!fvGridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()))
+            if (!gridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()))
                 numBoundaryVolVars += gridIvIndexSets.primaryIndexSet(scvf).nodalIndexSet().numBoundaryScvfs();
             else
                 numBoundaryVolVars += gridIvIndexSets.secondaryIndexSet(scvf).nodalIndexSet().numBoundaryScvfs();
@@ -138,12 +138,12 @@ namespace CCMpfa {
                             const typename FVElemGeom::GridGeometry::GridView::template Codim<0>::Entity& element,
                             const FVElemGeom& fvGeometry)
     {
-        const auto& fvGridGeometry = fvGeometry.gridGeometry();
+        const auto& gridGeometry = fvGeometry.gridGeometry();
 
         // treat the BCs inside the element
         if (fvGeometry.hasBoundaryScvf())
         {
-            const auto boundElemIdx = fvGridGeometry.elementMapper().index(element);
+            const auto boundElemIdx = gridGeometry.elementMapper().index(element);
             const auto& scvI = fvGeometry.scv(boundElemIdx);
 
             for (const auto& scvf : scvfs(fvGeometry))
@@ -168,10 +168,10 @@ namespace CCMpfa {
         }
 
         // Update boundary volume variables in the neighbors
-        const auto& gridIvIndexSets = fvGridGeometry.gridInteractionVolumeIndexSets();
+        const auto& gridIvIndexSets = gridGeometry.gridInteractionVolumeIndexSets();
         for (const auto& scvf : scvfs(fvGeometry))
         {
-            if (!fvGridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()))
+            if (!gridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()))
                 addBoundaryVolVarsAtNode( volVars, volVarIndices, problem, element, fvGeometry,
                                           gridIvIndexSets.primaryIndexSet(scvf).nodalIndexSet() );
             else
@@ -307,11 +307,11 @@ public:
         clear();
 
         const auto& problem = gridVolVars().problem();
-        const auto& fvGridGeometry = fvGeometry.gridGeometry();
+        const auto& gridGeometry = fvGeometry.gridGeometry();
 
         // stencil information
-        const auto globalI = fvGridGeometry.elementMapper().index(element);
-        const auto& assemblyMapI = fvGridGeometry.connectivityMap()[globalI];
+        const auto globalI = gridGeometry.elementMapper().index(element);
+        const auto& assemblyMapI = gridGeometry.connectivityMap()[globalI];
         const auto numVolVars = assemblyMapI.size() + 1;
 
         // resize local containers to the required size (for internal elements)
@@ -321,7 +321,7 @@ public:
 
         VolumeVariables volVars;
         const auto& scvI = fvGeometry.scv(globalI);
-        volVars.update(elementSolution(element, sol, fvGridGeometry),
+        volVars.update(elementSolution(element, sol, gridGeometry),
                        problem,
                        element,
                        scvI);
@@ -332,10 +332,10 @@ public:
         // Update the volume variables of the neighboring elements
         for (auto&& dataJ : assemblyMapI)
         {
-            const auto& elementJ = fvGridGeometry.element(dataJ.globalJ);
+            const auto& elementJ = gridGeometry.element(dataJ.globalJ);
             const auto& scvJ = fvGeometry.scv(dataJ.globalJ);
             VolumeVariables volVarsJ;
-            volVarsJ.update(elementSolution(elementJ, sol, fvGridGeometry),
+            volVarsJ.update(elementSolution(elementJ, sol, gridGeometry),
                             problem,
                             elementJ,
                             scvJ);
@@ -357,11 +357,11 @@ public:
         //     volVarIndices_.reserve(volVarIndices_.size() + additionalDofDependencies.size());
         //     for (auto globalJ : additionalDofDependencies)
         //     {
-        //         const auto& elementJ = fvGridGeometry.element(globalJ);
+        //         const auto& elementJ = gridGeometry.element(globalJ);
         //         const auto& scvJ = fvGeometry.scv(globalJ);
 
         //         VolumeVariables additionalVolVars;
-        //         additionalVolVars.update(elementSolution(elementJ, sol, fvGridGeometry),
+        //         additionalVolVars.update(elementSolution(elementJ, sol, gridGeometry),
         //                                  problem,
         //                                  elementJ,
         //                                  scvJ);
@@ -380,14 +380,14 @@ public:
     {
         clear();
 
-        const auto& fvGridGeometry = fvGeometry.gridGeometry();
-        auto eIdx = fvGridGeometry.elementMapper().index(element);
+        const auto& gridGeometry = fvGeometry.gridGeometry();
+        auto eIdx = gridGeometry.elementMapper().index(element);
         volumeVariables_.resize(1);
         volVarIndices_.resize(1);
 
         // update the volume variables of the element
         const auto& scv = fvGeometry.scv(eIdx);
-        volumeVariables_[0].update(elementSolution(element, sol, fvGridGeometry),
+        volumeVariables_[0].update(elementSolution(element, sol, gridGeometry),
                                    gridVolVars().problem(),
                                    element,
                                    scv);
diff --git a/dumux/discretization/cellcentered/mpfa/fvelementgeometry.hh b/dumux/discretization/cellcentered/mpfa/fvelementgeometry.hh
index 426d8a3ae23b1c09e00d50112024665284fe036c..7beedaa45f7095575e0bc2e81b4bfa2a7d061f08 100644
--- a/dumux/discretization/cellcentered/mpfa/fvelementgeometry.hh
+++ b/dumux/discretization/cellcentered/mpfa/fvelementgeometry.hh
@@ -154,7 +154,7 @@ public:
 
     //! The global finite volume geometry we are a restriction of
     [[deprecated("Use gridGeometry() instead. fvGridGeometry() will be removed after 3.1!")]]
-    const FVGridGeometry& fvGridGeometry() const
+    const GridGeometry& fvGridGeometry() const
     { return gridGeometry(); }
     const GridGeometry& gridGeometry() const
     { return *gridGeometryPtr_; }
@@ -316,7 +316,7 @@ public:
 
     //! The global finite volume geometry we are a restriction of
     [[deprecated("Use gridGeometry() instead. fvGridGeometry() will be removed after 3.1!")]]
-    const FVGridGeometry& fvGridGeometry() const
+    const GridGeometry& fvGridGeometry() const
     { return gridGeometry(); }
     const GridGeometry& gridGeometry() const
     { return *gridGeometryPtr_; }
diff --git a/dumux/discretization/cellcentered/mpfa/fvgridgeometrytraits.hh b/dumux/discretization/cellcentered/mpfa/fvgridgeometrytraits.hh
index 6e9b2aa53a5d609c22fd3ddbf5a453de30e6b747..ad4620916a12c16935239d831d9931e9eca0b07a 100644
--- a/dumux/discretization/cellcentered/mpfa/fvgridgeometrytraits.hh
+++ b/dumux/discretization/cellcentered/mpfa/fvgridgeometrytraits.hh
@@ -56,7 +56,7 @@ struct CCMpfaFVGridGeometryTraits : public DefaultMapperTraits<GV>
     //! We assume simplex grids where stencils can get quite large but the size is unknown
     static constexpr int maxElementStencilSize = int(GV::dimension) == 3 ? 150 :
                                                  (int(GV::dimension)<int(GV::dimensionworld) ? 45 : 20);
-    //! type definitions depending on the FVGridGeometry itself
+    //! type definitions depending on the GridGeometry itself
     template< class FVGridGeom >
     using MpfaHelper = CCMpfaHelper< FVGridGeom >;
     template< class FVGridGeom >
diff --git a/dumux/discretization/cellcentered/mpfa/gridfluxvariablescache.hh b/dumux/discretization/cellcentered/mpfa/gridfluxvariablescache.hh
index a0c3cbb396ee40741e3aa97dee73990645c55f69..0b1a77744d09b6834dc448e8c312801022f691a3 100644
--- a/dumux/discretization/cellcentered/mpfa/gridfluxvariablescache.hh
+++ b/dumux/discretization/cellcentered/mpfa/gridfluxvariablescache.hh
@@ -124,8 +124,8 @@ public:
     {}
 
     //! When global caching is enabled, precompute transmissibilities for all scv faces
-    template<class FVGridGeometry, class GridVolumeVariables, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry,
+    template<class GridGeometry, class GridVolumeVariables, class SolutionVector>
+    void update(const GridGeometry& gridGeometry,
                 const GridVolumeVariables& gridVolVars,
                 const SolutionVector& sol,
                 bool forceUpdate = false)
@@ -139,7 +139,7 @@ public:
             {
                 clear_();
 
-                const auto& gridIvIndexSets = fvGridGeometry.gridInteractionVolumeIndexSets();
+                const auto& gridIvIndexSets = gridGeometry.gridInteractionVolumeIndexSets();
                 const auto numPrimaryIvs = gridIvIndexSets.numPrimaryInteractionVolumes();
                 const auto numSecondaryIVs = gridIvIndexSets.numSecondaryInteractionVolumes();
                 ivDataStorage_.primaryInteractionVolumes.reserve(numPrimaryIvs);
@@ -148,7 +148,7 @@ public:
                 ivDataStorage_.secondaryDataHandles.reserve(numSecondaryIVs);
 
                 // reserve memory estimate for caches, interaction volumes and corresponding data
-                fluxVarsCache_.resize(fvGridGeometry.numScvf());
+                fluxVarsCache_.resize(gridGeometry.numScvf());
             }
 
             // instantiate helper class to fill the caches
@@ -158,9 +158,9 @@ public:
             for (auto& cache : fluxVarsCache_)
                 cache.setUpdateStatus(false);
 
-            for (const auto& element : elements(fvGridGeometry.gridView()))
+            for (const auto& element : elements(gridGeometry.gridView()))
             {
-                auto fvGeometry = localView(fvGridGeometry);
+                auto fvGeometry = localView(gridGeometry);
                 fvGeometry.bind(element);
 
                 auto elemVolVars = localView(gridVolVars);
@@ -169,7 +169,7 @@ public:
                 // Prepare all caches of the scvfs inside the corresponding interaction volume. Skip
                 // those ivs that are touching a boundary, we only store the data on interior ivs here.
                 for (const auto& scvf : scvfs(fvGeometry))
-                    if (!isEmbeddedInBoundaryIV_(scvf, fvGridGeometry) && !fluxVarsCache_[scvf.index()].isUpdated())
+                    if (!isEmbeddedInBoundaryIV_(scvf, gridGeometry) && !fluxVarsCache_[scvf.index()].isUpdated())
                         filler.fill(*this, fluxVarsCache_[scvf.index()], ivDataStorage_, element, fvGeometry, elemVolVars, scvf, forceUpdate);
             }
         }
@@ -184,8 +184,8 @@ public:
         // solution-dependent stuff into the caches
         if (FluxVariablesCacheFiller::isSolDependent)
         {
-            const auto& fvGridGeometry = fvGeometry.gridGeometry();
-            const auto& assemblyMapI = fvGridGeometry.connectivityMap()[fvGridGeometry.elementMapper().index(element)];
+            const auto& gridGeometry = fvGeometry.gridGeometry();
+            const auto& assemblyMapI = gridGeometry.connectivityMap()[gridGeometry.elementMapper().index(element)];
 
             // helper class to fill flux variables caches
             FluxVariablesCacheFiller filler(problem());
@@ -201,18 +201,18 @@ public:
             for (const auto& scvf : scvfs(fvGeometry))
             {
                 auto& scvfCache = fluxVarsCache_[scvf.index()];
-                if (!isEmbeddedInBoundaryIV_(scvf, fvGridGeometry) && !scvfCache.isUpdated())
+                if (!isEmbeddedInBoundaryIV_(scvf, gridGeometry) && !scvfCache.isUpdated())
                     filler.fill(*this, scvfCache, ivDataStorage_, element, fvGeometry, elemVolVars, scvf);
             }
 
             for (const auto& dataJ : assemblyMapI)
             {
-                const auto elementJ = fvGridGeometry.element(dataJ.globalJ);
+                const auto elementJ = gridGeometry.element(dataJ.globalJ);
                 for (const auto scvfIdx : dataJ.scvfsJ)
                 {
                     auto& scvfCache = fluxVarsCache_[scvfIdx];
                     const auto& scvf = fvGeometry.scvf(scvfIdx);
-                    if (!isEmbeddedInBoundaryIV_(scvf, fvGridGeometry) && !scvfCache.isUpdated())
+                    if (!isEmbeddedInBoundaryIV_(scvf, gridGeometry) && !scvfCache.isUpdated())
                         filler.fill(*this, scvfCache, ivDataStorage_, elementJ, fvGeometry, elemVolVars, scvf);
                 }
             }
@@ -254,11 +254,11 @@ public:
 
 private:
     //! returns true if an scvf is contained in an interaction volume that touches the boundary
-    template<class SubControlVolumeFace, class FVGridGeometry>
-    bool isEmbeddedInBoundaryIV_(const SubControlVolumeFace& scvf, const FVGridGeometry& fvGridGeometry) const
+    template<class SubControlVolumeFace, class GridGeometry>
+    bool isEmbeddedInBoundaryIV_(const SubControlVolumeFace& scvf, const GridGeometry& gridGeometry) const
     {
-        const auto& gridIvIndexSets = fvGridGeometry.gridInteractionVolumeIndexSets();
-        if (fvGridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()))
+        const auto& gridIvIndexSets = gridGeometry.gridInteractionVolumeIndexSets();
+        if (gridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()))
             return gridIvIndexSets.secondaryIndexSet(scvf).nodalIndexSet().numBoundaryScvfs() > 0;
         else
             return gridIvIndexSets.primaryIndexSet(scvf).nodalIndexSet().numBoundaryScvfs() > 0;
@@ -322,8 +322,8 @@ public:
     CCMpfaGridFluxVariablesCache(const Problem& problem) : problemPtr_(&problem) {}
 
     //! When global flux variables caching is disabled, we don't need to update the cache
-    template<class FVGridGeometry, class GridVolumeVariables, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry,
+    template<class GridGeometry, class GridVolumeVariables, class SolutionVector>
+    void update(const GridGeometry& gridGeometry,
                 const GridVolumeVariables& gridVolVars,
                 const SolutionVector& sol,
                 bool forceUpdate = false) {}
diff --git a/dumux/discretization/cellcentered/mpfa/gridinteractionvolumeindexsets.hh b/dumux/discretization/cellcentered/mpfa/gridinteractionvolumeindexsets.hh
index 5a90d9e4e5b439bedd4504363c6a41e275c3b314..81c5e4e96d9c0570f332c33bdc8750969f181d5d 100644
--- a/dumux/discretization/cellcentered/mpfa/gridinteractionvolumeindexsets.hh
+++ b/dumux/discretization/cellcentered/mpfa/gridinteractionvolumeindexsets.hh
@@ -47,7 +47,7 @@ class CCMpfaGridInteractionVolumeIndexSets
     using SecondaryIVIndexSet = typename SI::Traits::IndexSet;
 
 public:
-    using FVGridGeometry = FVG;
+    using GridGeometry = FVG;
     using PrimaryInteractionVolume = PI;
     using SecondaryInteractionVolume = SI;
 
@@ -57,10 +57,10 @@ public:
     /*!
      * \brief Construct all interaction volume index sets on the grid view
      *
-     * \param fvGridGeometry The finite volume geometry on the grid view
+     * \param gridGeometry The finite volume geometry on the grid view
      * \param dualGridIdSet The index sets of the dual grid on the grid view
      */
-    void update(FVGridGeometry& fvGridGeometry, DualGridIndexSet&& dualGridIdSet)
+    void update(GridGeometry& gridGeometry, DualGridIndexSet&& dualGridIdSet)
     {
         dualGridIndexSet_ = std::make_unique<DualGridIndexSet>(std::move(dualGridIdSet));
 
@@ -72,10 +72,10 @@ public:
         // find out how many primary & secondary interaction volumes are needed
         numPrimaryIV_ = 0;
         numSecondaryIV_ = 0;
-        for (const auto& vertex : vertices(fvGridGeometry.gridView()))
+        for (const auto& vertex : vertices(gridGeometry.gridView()))
         {
-            const auto vIdxGlobal = fvGridGeometry.vertexMapper().index(vertex);
-            if (!fvGridGeometry.vertexUsesSecondaryInteractionVolume(vIdxGlobal))
+            const auto vIdxGlobal = gridGeometry.vertexMapper().index(vertex);
+            if (!gridGeometry.vertexUsesSecondaryInteractionVolume(vIdxGlobal))
                 numPrimaryIV_ += PrimaryInteractionVolume::numIVAtVertex((*dualGridIndexSet_)[vIdxGlobal]);
             else
                 numSecondaryIV_ += SecondaryInteractionVolume::numIVAtVertex((*dualGridIndexSet_)[vIdxGlobal]);
@@ -84,22 +84,22 @@ public:
         // reserve memory
         primaryIVIndexSets_.reserve(numPrimaryIV_);
         secondaryIVIndexSets_.reserve(numSecondaryIV_);
-        scvfIndexMap_.resize(fvGridGeometry.numScvf());
+        scvfIndexMap_.resize(gridGeometry.numScvf());
 
         // create interaction volume index sets around each vertex
-        for (const auto& vertex : vertices(fvGridGeometry.gridView()))
+        for (const auto& vertex : vertices(gridGeometry.gridView()))
         {
-            const auto vIdxGlobal = fvGridGeometry.vertexMapper().index(vertex);
-            if (!fvGridGeometry.vertexUsesSecondaryInteractionVolume(vIdxGlobal))
+            const auto vIdxGlobal = gridGeometry.vertexMapper().index(vertex);
+            if (!gridGeometry.vertexUsesSecondaryInteractionVolume(vIdxGlobal))
                 PrimaryInteractionVolume::addIVIndexSets(primaryIVIndexSets_,
                                                          scvfIndexMap_,
                                                          (*dualGridIndexSet_)[vIdxGlobal],
-                                                         fvGridGeometry.flipScvfIndexSet());
+                                                         gridGeometry.flipScvfIndexSet());
             else
                 SecondaryInteractionVolume::addIVIndexSets(secondaryIVIndexSets_,
                                                            scvfIndexMap_,
                                                            (*dualGridIndexSet_)[vIdxGlobal],
-                                                           fvGridGeometry.flipScvfIndexSet());
+                                                           gridGeometry.flipScvfIndexSet());
         }
     }
 
diff --git a/dumux/discretization/cellcentered/mpfa/helper.hh b/dumux/discretization/cellcentered/mpfa/helper.hh
index 8181a30ab78af9b24fd7044904638b0aa23dd61a..4acc361fcb17b3a55dc4bb4369816ea9db1ea61d 100644
--- a/dumux/discretization/cellcentered/mpfa/helper.hh
+++ b/dumux/discretization/cellcentered/mpfa/helper.hh
@@ -39,23 +39,23 @@ namespace Dumux {
  * \ingroup CCMpfaDiscretization
  * \brief Dimension-specific helper class to get data required for mpfa scheme.
  */
-template<class FVGridGeometry, int dim, int dimWorld>
+template<class GridGeometry, int dim, int dimWorld>
 class MpfaDimensionHelper;
 
 /*!
  * \ingroup CCMpfaDiscretization
  * \brief  Dimension-specific mpfa helper class for dim == 2 & dimWorld == 2
  */
-template<class FVGridGeometry>
-class MpfaDimensionHelper<FVGridGeometry, /*dim*/2, /*dimWorld*/2>
+template<class GridGeometry>
+class MpfaDimensionHelper<GridGeometry, /*dim*/2, /*dimWorld*/2>
 {
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using CoordScalar = typename GridView::ctype;
     using Element = typename GridView::template Codim<0>::Entity;
 
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
     using ScvfCornerVector = typename SubControlVolumeFace::Traits::CornerStorage;
 
     // Container to store the positions of intersections required for scvf
@@ -199,11 +199,11 @@ public:
  * \brief  Dimension-specific mpfa helper class for dim == 2 & dimWorld == 2.
  *         Reuses some functionality of the specialization for dim = dimWorld = 2
  */
-template<class FVGridGeometry>
-class MpfaDimensionHelper<FVGridGeometry, /*dim*/2, /*dimWorld*/3>
-: public MpfaDimensionHelper<FVGridGeometry, 2, 2>
+template<class GridGeometry>
+class MpfaDimensionHelper<GridGeometry, /*dim*/2, /*dimWorld*/3>
+: public MpfaDimensionHelper<GridGeometry, 2, 2>
 {
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using CoordScalar = typename GridView::ctype;
 public:
 
@@ -260,14 +260,14 @@ public:
  * \brief   Dimension-specific mpfa helper class for dim == 3 & dimWorld == 3.
  *
  */
-template<class FVGridGeometry>
-class MpfaDimensionHelper<FVGridGeometry, /*dim*/3, /*dimWorld*/3>
+template<class GridGeometry>
+class MpfaDimensionHelper<GridGeometry, /*dim*/3, /*dimWorld*/3>
 {
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
     using ScvfCornerVector = typename SubControlVolumeFace::Traits::CornerStorage;
 
     // Be picky about the dimensions
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using CoordScalar = typename GridView::ctype;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
@@ -498,22 +498,22 @@ public:
  * \ingroup CCMpfaDiscretization
  * \brief Helper class to get the required information on an interaction volume.
  *
- * \tparam FVGridGeometry The finite volume grid geometry
+ * \tparam GridGeometry The finite volume grid geometry
  */
-template<class FVGridGeometry>
-class CCMpfaHelper : public MpfaDimensionHelper<FVGridGeometry,
-                                                FVGridGeometry::GridView::dimension,
-                                                FVGridGeometry::GridView::dimensionworld>
+template<class GridGeometry>
+class CCMpfaHelper : public MpfaDimensionHelper<GridGeometry,
+                                                GridGeometry::GridView::dimension,
+                                                GridGeometry::GridView::dimensionworld>
 {
-    using PrimaryInteractionVolume = typename FVGridGeometry::GridIVIndexSets::PrimaryInteractionVolume;
-    using SecondaryInteractionVolume = typename FVGridGeometry::GridIVIndexSets::SecondaryInteractionVolume;
+    using PrimaryInteractionVolume = typename GridGeometry::GridIVIndexSets::PrimaryInteractionVolume;
+    using SecondaryInteractionVolume = typename GridGeometry::GridIVIndexSets::SecondaryInteractionVolume;
 
-    using VertexMapper = typename FVGridGeometry::VertexMapper;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using VertexMapper = typename GridGeometry::VertexMapper;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using ScvfCornerVector = typename SubControlVolumeFace::Traits::CornerStorage;
 
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     static constexpr int dim = GridView::dimension;
 
     using Element = typename GridView::template Codim<0>::Entity;
diff --git a/dumux/discretization/cellcentered/mpfa/scvgradients.hh b/dumux/discretization/cellcentered/mpfa/scvgradients.hh
index dca568965edc6f3653a4f7158d14c79a5f1aa6f1..bb4f4c9ddcbae8c2408361d0f472a082d8bd2629 100644
--- a/dumux/discretization/cellcentered/mpfa/scvgradients.hh
+++ b/dumux/discretization/cellcentered/mpfa/scvgradients.hh
@@ -44,23 +44,23 @@ namespace Dumux {
 class CCMpfaScvGradients
 {
     //! Return type of the gradient computation function (pair of scv centers and corresponding gradients)
-    template<class FVGridGeometry, class Scalar>
-    using ResultPair = std::pair< std::vector<typename FVGridGeometry::SubControlVolume::GlobalPosition>,
-                                  std::vector<Dune::FieldVector<Scalar, FVGridGeometry::GridView::dimension>> >;
+    template<class GridGeometry, class Scalar>
+    using ResultPair = std::pair< std::vector<typename GridGeometry::SubControlVolume::GlobalPosition>,
+                                  std::vector<Dune::FieldVector<Scalar, GridGeometry::GridView::dimension>> >;
 
 public:
 
     /*!
      * \brief Computes the phase velocities in the scvs of the grid.
      *
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param gridVariables The variables living on the grid
      * \param x The vector containing the solution
      * \param phaseIdx The index of the fluid phase to be considered
      */
-    template<class FVGridGeometry, class GridVariables, class SolutionVector>
-    static ResultPair<FVGridGeometry, typename GridVariables::Scalar>
-    computeVelocities(const FVGridGeometry& fvGridGeometry,
+    template<class GridGeometry, class GridVariables, class SolutionVector>
+    static ResultPair<GridGeometry, typename GridVariables::Scalar>
+    computeVelocities(const GridGeometry& gridGeometry,
                       const GridVariables& gridVariables,
                       const SolutionVector& x,
                       unsigned int phaseIdx)
@@ -72,32 +72,32 @@ public:
             return vel;
         };
 
-        return computePressureGradients(fvGridGeometry, gridVariables, x, phaseIdx, gradToVelocity);
+        return computePressureGradients(gridGeometry, gridVariables, x, phaseIdx, gradToVelocity);
     }
 
     /*!
      * \brief Computes the pressure gradients in the scvs of the grid.
      *
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param gridVariables The variables living on the grid
      * \param x The vector containing the solution
      * \param phaseIdx The index of the fluid phase to be considered
      */
-    template<class FVGridGeometry, class GridVariables, class SolutionVector>
-    static ResultPair<FVGridGeometry, typename GridVariables::Scalar>
-    computePressureGradients(const FVGridGeometry& fvGridGeometry,
+    template<class GridGeometry, class GridVariables, class SolutionVector>
+    static ResultPair<GridGeometry, typename GridVariables::Scalar>
+    computePressureGradients(const GridGeometry& gridGeometry,
                              const GridVariables& gridVariables,
                              const SolutionVector& x,
                              unsigned int phaseIdx)
     {
         auto f = [] (const auto& grad, const auto& volVars) { return grad; };
-        return computePressureGradients(fvGridGeometry, gridVariables, x, phaseIdx, f);
+        return computePressureGradients(gridGeometry, gridVariables, x, phaseIdx, f);
     }
 
     /*!
      * \brief Computes the pressure gradients in the scvs of the grid.
      *
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param gridVariables The variables living on the grid
      * \param x The vector containing the solution
      * \param phaseIdx The index of the fluid phase to be considered
@@ -110,16 +110,16 @@ public:
      *          variables and returns the modified gradient. This can be
      *          used e.g. to turn the pressure gradients into velocities.
      */
-    template<class FVGridGeometry, class GridVariables, class SolutionVector, class F>
-    static ResultPair<FVGridGeometry, typename GridVariables::Scalar>
-    computePressureGradients(const FVGridGeometry& fvGridGeometry,
+    template<class GridGeometry, class GridVariables, class SolutionVector, class F>
+    static ResultPair<GridGeometry, typename GridVariables::Scalar>
+    computePressureGradients(const GridGeometry& gridGeometry,
                              const GridVariables& gridVariables,
                              const SolutionVector& x,
                              unsigned int phaseIdx,
                              F& f)
     {
         using ElemVolVars = typename GridVariables::GridVolumeVariables::LocalView;
-        using FVElementGeometry = typename FVGridGeometry::LocalView;
+        using FVElementGeometry = typename GridGeometry::LocalView;
 
         auto handleFunction = [&] (auto& result,
                                    const auto& handle,
@@ -138,7 +138,7 @@ public:
             }
         };
 
-        return computeGradients_(fvGridGeometry, gridVariables, x, handleFunction);
+        return computeGradients_(gridGeometry, gridVariables, x, handleFunction);
     }
 
 private:
@@ -146,23 +146,23 @@ private:
      * \brief Computes the gradients executing the provided function
      *        on an interaction volume / data handle pair.
      */
-    template<class FVGridGeometry, class GridVariables, class SolutionVector, class HandleFunction>
-    static ResultPair<FVGridGeometry, typename GridVariables::Scalar>
-    computeGradients_(const FVGridGeometry& fvGridGeometry,
+    template<class GridGeometry, class GridVariables, class SolutionVector, class HandleFunction>
+    static ResultPair<GridGeometry, typename GridVariables::Scalar>
+    computeGradients_(const GridGeometry& gridGeometry,
                       const GridVariables& gridVariables,
                       const SolutionVector& x,
                       const HandleFunction& handleFunction)
     {
-        using GridView = typename FVGridGeometry::GridView;
+        using GridView = typename GridGeometry::GridView;
         static constexpr int dim = GridView::dimension;
 
         // first, find out how many scvs live on this grid
         std::size_t numScvs = 0;
-        const auto& gridView = fvGridGeometry.gridView();
+        const auto& gridView = gridGeometry.gridView();
         for (const auto& element : elements(gridView))
             numScvs += element.subEntities(dim);
 
-        ResultPair<FVGridGeometry, typename GridVariables::Scalar> result;
+        ResultPair<GridGeometry, typename GridVariables::Scalar> result;
         result.first.reserve(numScvs);
         result.second.reserve(numScvs);
         std::vector<bool> vertexHandled(gridView.size(dim), false);
@@ -171,7 +171,7 @@ private:
         {
             bool allFinished = true;
             for (int i = 0; i < element.subEntities(dim); ++i)
-                if (!vertexHandled[fvGridGeometry.vertexMapper().subIndex(element, i, dim)])
+                if (!vertexHandled[gridGeometry.vertexMapper().subIndex(element, i, dim)])
                     allFinished = false;
 
             // bind views only if there is unfinished buisness
@@ -179,7 +179,7 @@ private:
                 continue;
 
             // compute gradients in all scvs of all interaction volumes in this element
-            auto fvGeometry = localView(fvGridGeometry);
+            auto fvGeometry = localView(gridGeometry);
             auto elemVolVars = localView(gridVariables.curGridVolVars());
             auto elemFluxVarsCache = localView(gridVariables.gridFluxVarsCache());
             fvGeometry.bind(element);
@@ -191,7 +191,7 @@ private:
                 if (vertexHandled[scvf.vertexIndex()])
                     continue;
 
-                if (fvGridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()))
+                if (gridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()))
                 {
                     const auto& iv = elemFluxVarsCache.secondaryInteractionVolume(scvf);
                     const auto& handle = elemFluxVarsCache.secondaryDataHandle(scvf);
diff --git a/dumux/discretization/cellcentered/tpfa/elementfluxvariablescache.hh b/dumux/discretization/cellcentered/tpfa/elementfluxvariablescache.hh
index b6686a5dd5825ad33980d6195f07777bd5857914..44afab9f1e837a71440c8a3b37b1b77798af6448 100644
--- a/dumux/discretization/cellcentered/tpfa/elementfluxvariablescache.hh
+++ b/dumux/discretization/cellcentered/tpfa/elementfluxvariablescache.hh
@@ -159,9 +159,9 @@ public:
               const ElementVolumeVariables& elemVolVars)
     {
         const auto& problem = gridFluxVarsCache().problem();
-        const auto& fvGridGeometry = fvGeometry.gridGeometry();
-        const auto globalI = fvGridGeometry.elementMapper().index(element);
-        const auto& connectivityMapI = fvGridGeometry.connectivityMap()[globalI];
+        const auto& gridGeometry = fvGeometry.gridGeometry();
+        const auto globalI = gridGeometry.elementMapper().index(element);
+        const auto& connectivityMapI = gridGeometry.connectivityMap()[globalI];
         const auto numNeighbors = connectivityMapI.size();
 
         // instantiate helper class to fill the caches
@@ -186,7 +186,7 @@ public:
         // add required data on the scv faces in the neighboring elements
         for (unsigned int localIdxJ = 0; localIdxJ < numNeighbors; ++localIdxJ)
         {
-            const auto elementJ = fvGridGeometry.element(connectivityMapI[localIdxJ].globalJ);
+            const auto elementJ = gridGeometry.element(connectivityMapI[localIdxJ].globalJ);
             for (auto scvfIdx : connectivityMapI[localIdxJ].scvfsJ)
             {
                 auto&& scvfJ = fvGeometry.scvf(scvfIdx);
diff --git a/dumux/discretization/cellcentered/tpfa/elementvolumevariables.hh b/dumux/discretization/cellcentered/tpfa/elementvolumevariables.hh
index 4344892d3f950554de3d9136876f2b97b70376ac..e10d37ac5cbae1cc063cf1378144a11a855f0be6 100644
--- a/dumux/discretization/cellcentered/tpfa/elementvolumevariables.hh
+++ b/dumux/discretization/cellcentered/tpfa/elementvolumevariables.hh
@@ -182,9 +182,9 @@ public:
         clear_();
 
         const auto& problem = gridVolVars().problem();
-        const auto& fvGridGeometry = fvGeometry.gridGeometry();
-        const auto globalI = fvGridGeometry.elementMapper().index(element);
-        const auto& connectivityMapI = fvGridGeometry.connectivityMap()[globalI];
+        const auto& gridGeometry = fvGeometry.gridGeometry();
+        const auto globalI = gridGeometry.elementMapper().index(element);
+        const auto& connectivityMapI = gridGeometry.connectivityMap()[globalI];
         const auto numDofs = connectivityMapI.size() + 1;
 
         // resize local containers to the required size (for internal elements)
@@ -194,7 +194,7 @@ public:
 
         // update the volume variables of the element at hand
         auto&& scvI = fvGeometry.scv(globalI);
-        volumeVariables_[localIdx].update(elementSolution(element, sol, fvGridGeometry),
+        volumeVariables_[localIdx].update(elementSolution(element, sol, gridGeometry),
                                           problem,
                                           element,
                                           scvI);
@@ -204,9 +204,9 @@ public:
         // Update the volume variables of the neighboring elements
         for (const auto& dataJ : connectivityMapI)
         {
-            const auto& elementJ = fvGridGeometry.element(dataJ.globalJ);
+            const auto& elementJ = gridGeometry.element(dataJ.globalJ);
             auto&& scvJ = fvGeometry.scv(dataJ.globalJ);
-            volumeVariables_[localIdx].update(elementSolution(elementJ, sol, fvGridGeometry),
+            volumeVariables_[localIdx].update(elementSolution(elementJ, sol, gridGeometry),
                                               problem,
                                               elementJ,
                                               scvJ);
@@ -250,10 +250,10 @@ public:
         //     volVarIndices_.resize(volVarIndices_.size() + additionalDofDependencies.size());
         //     for (auto globalJ : additionalDofDependencies)
         //     {
-        //         const auto& elementJ = fvGridGeometry.element(globalJ);
+        //         const auto& elementJ = gridGeometry.element(globalJ);
         //         auto&& scvJ = fvGeometry.scv(globalJ);
 
-        //         volumeVariables_[localIdx].update(elementSolution(elementJ, sol, fvGridGeometry),
+        //         volumeVariables_[localIdx].update(elementSolution(elementJ, sol, gridGeometry),
         //                                           problem,
         //                                           elementJ,
         //                                           scvJ);
diff --git a/dumux/discretization/cellcentered/tpfa/fvelementgeometry.hh b/dumux/discretization/cellcentered/tpfa/fvelementgeometry.hh
index 07798af3303373d043507069dff4ab5202ac99b0..155d9fe58005e7bdd76df23a2b89964d0f6b7ef8 100644
--- a/dumux/discretization/cellcentered/tpfa/fvelementgeometry.hh
+++ b/dumux/discretization/cellcentered/tpfa/fvelementgeometry.hh
@@ -159,7 +159,7 @@ public:
     const GridGeometry& gridGeometry() const
     { return *gridGeometryPtr_; }
     [[deprecated("Use gridGeometry() instead. fvGridGeometry() will be removed after 3.1!")]]
-    const FVGridGeometry& fvGridGeometry() const
+    const GridGeometry& fvGridGeometry() const
     { return gridGeometry(); }
 
     //! Returns whether one of the geometry's scvfs lies on a boundary
@@ -363,7 +363,7 @@ public:
     const GridGeometry& gridGeometry() const
     { return *gridGeometryPtr_; }
     [[deprecated("Use gridGeometry() instead. fvGridGeometry() will be removed after 3.1!")]]
-    const FVGridGeometry& fvGridGeometry() const
+    const GridGeometry& fvGridGeometry() const
     { return gridGeometry(); }
 
     //! Returns whether one of the geometry's scvfs lies on a boundary
diff --git a/dumux/discretization/cellcentered/tpfa/fvgridgeometry.hh b/dumux/discretization/cellcentered/tpfa/fvgridgeometry.hh
index 6e91c8b4f13c1aea2401d082df4506cec2c737d5..5ec25e498cf323a50836b90b28d226df01b30957 100644
--- a/dumux/discretization/cellcentered/tpfa/fvgridgeometry.hh
+++ b/dumux/discretization/cellcentered/tpfa/fvgridgeometry.hh
@@ -54,11 +54,11 @@ struct CCTpfaDefaultGridGeometryTraits
     using SubControlVolume = CCSubControlVolume<GridView>;
     using SubControlVolumeFace = CCTpfaSubControlVolumeFace<GridView>;
 
-    template<class FVGridGeometry>
-    using ConnectivityMap = CCSimpleConnectivityMap<FVGridGeometry>;
+    template<class GridGeometry>
+    using ConnectivityMap = CCSimpleConnectivityMap<GridGeometry>;
 
-    template<class FVGridGeometry, bool enableCache>
-    using LocalView = CCTpfaFVElementGeometry<FVGridGeometry, enableCache>;
+    template<class GridGeometry, bool enableCache>
+    using LocalView = CCTpfaFVElementGeometry<GridGeometry, enableCache>;
 
     //! State the maximum admissible number of neighbors per scvf
     //! Per default, we allow for 8 branches on network/surface grids, where
diff --git a/dumux/discretization/cellcentered/tpfa/gridfluxvariablescache.hh b/dumux/discretization/cellcentered/tpfa/gridfluxvariablescache.hh
index fce7d81ec35140812fe57027829d5cf7bfc16ea6..f368da20db8e14d537a5cb731c8addeb2e4b9a81 100644
--- a/dumux/discretization/cellcentered/tpfa/gridfluxvariablescache.hh
+++ b/dumux/discretization/cellcentered/tpfa/gridfluxvariablescache.hh
@@ -87,8 +87,8 @@ public:
     CCTpfaGridFluxVariablesCache(const Problem& problem) : problemPtr_(&problem) {}
 
     // When global caching is enabled, precompute transmissibilities and stencils for all the scv faces
-    template<class FVGridGeometry, class GridVolumeVariables, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry,
+    template<class GridGeometry, class GridVolumeVariables, class SolutionVector>
+    void update(const GridGeometry& gridGeometry,
                 const GridVolumeVariables& gridVolVars,
                 const SolutionVector& sol,
                 bool forceUpdate = false)
@@ -99,11 +99,11 @@ public:
             // instantiate helper class to fill the caches
             FluxVariablesCacheFiller filler(problem());
 
-            fluxVarsCache_.resize(fvGridGeometry.numScvf());
-            for (const auto& element : elements(fvGridGeometry.gridView()))
+            fluxVarsCache_.resize(gridGeometry.numScvf());
+            for (const auto& element : elements(gridGeometry.gridView()))
             {
                 // Prepare the geometries within the elements of the stencil
-                auto fvGeometry = localView(fvGridGeometry);
+                auto fvGeometry = localView(gridGeometry);
                 fvGeometry.bind(element);
 
                 auto elemVolVars = localView(gridVolVars);
@@ -194,8 +194,8 @@ public:
     CCTpfaGridFluxVariablesCache(const Problem& problem) : problemPtr_(&problem) {}
 
     //! When global flux variables caching is disabled, we don't need to update the cache
-    template<class FVGridGeometry, class GridVolumeVariables, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry,
+    template<class GridGeometry, class GridVolumeVariables, class SolutionVector>
+    void update(const GridGeometry& gridGeometry,
                 const GridVolumeVariables& gridVolVars,
                 const SolutionVector& sol,
                 bool forceUpdate = false) {}
diff --git a/dumux/discretization/evalgradients.hh b/dumux/discretization/evalgradients.hh
index 555dc8a350564f5bfff9afe8f2ef3266985221ad..e891f659574eea5f8ef3f156d986db97cb713449 100644
--- a/dumux/discretization/evalgradients.hh
+++ b/dumux/discretization/evalgradients.hh
@@ -42,7 +42,7 @@ namespace Dumux {
  *
  * \param element The element
  * \param geometry The element geometry
- * \param fvGridGeometry The finite volume grid geometry
+ * \param gridGeometry The finite volume grid geometry
  * \param elemSol The primary variables at the dofs of the element
  * \param globalPos The global position
  * \param ignoreState If true, the state of primary variables is ignored
@@ -54,7 +54,7 @@ namespace Dumux {
 template<class Element, class FVElementGeometry, class PrimaryVariables>
 auto evalGradients(const Element& element,
                    const typename Element::Geometry& geometry,
-                   const typename FVElementGeometry::GridGeometry& fvGridGeometry,
+                   const typename FVElementGeometry::GridGeometry& gridGeometry,
                    const BoxElementSolution<FVElementGeometry, PrimaryVariables>& elemSol,
                    const typename Element::Geometry::GlobalCoordinate& globalPos,
                    bool ignoreState = false)
@@ -68,7 +68,7 @@ auto evalGradients(const Element& element,
         using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
         // evaluate gradients using the local finite element basis
-        const auto& localBasis = fvGridGeometry.feCache().get(geometry.type()).localBasis();
+        const auto& localBasis = gridGeometry.feCache().get(geometry.type()).localBasis();
 
         // evaluate the shape function gradients at the scv center
         using ShapeJacobian = typename std::decay_t< decltype(localBasis) >::Traits::JacobianType;
@@ -114,7 +114,7 @@ auto evalGradients(const Element& element,
  *
  * \param element The element
  * \param geometry The element geometry
- * \param fvGridGeometry The finite volume grid geometry
+ * \param gridGeometry The finite volume grid geometry
  * \param elemSol The primary variables at the dofs of the element
  * \param globalPos The global position
  * \throws Dune::NotImplemented
@@ -127,7 +127,7 @@ template<class Element, class FVElementGeometry, class PrimaryVariables>
 Dune::FieldVector<typename Element::Geometry::GlobalCoordinate, PrimaryVariables::dimension>
 evalGradients(const Element& element,
               const typename Element::Geometry& geometry,
-              const typename FVElementGeometry::GridGeometry& fvGridGeometry,
+              const typename FVElementGeometry::GridGeometry& gridGeometry,
               const CCElementSolution<FVElementGeometry, PrimaryVariables>& elemSol,
               const typename Element::Geometry::GlobalCoordinate& globalPos)
 { DUNE_THROW(Dune::NotImplemented, "General gradient evaluation for cell-centered methods"); }
diff --git a/dumux/discretization/evalsolution.hh b/dumux/discretization/evalsolution.hh
index 56cc98e815035decca21a3e788659627ade55472..bfe27da98bc825968def22521e986c82d39cc7a3 100644
--- a/dumux/discretization/evalsolution.hh
+++ b/dumux/discretization/evalsolution.hh
@@ -86,7 +86,7 @@ auto minDistVertexSol(const Geometry& geometry, const typename Geometry::GlobalC
  * \return the interpolated primary variables
  * \param element The element
  * \param geometry The element geometry
- * \param fvGridGeometry The finite volume grid geometry
+ * \param gridGeometry The finite volume grid geometry
  * \param elemSol The primary variables at the dofs of the element
  * \param globalPos The global position
  * \param ignoreState If true, the state of primary variables is ignored
@@ -94,7 +94,7 @@ auto minDistVertexSol(const Geometry& geometry, const typename Geometry::GlobalC
 template<class Element, class FVElementGeometry, class PrimaryVariables>
 PrimaryVariables evalSolution(const Element& element,
                               const typename Element::Geometry& geometry,
-                              const typename FVElementGeometry::GridGeometry& fvGridGeometry,
+                              const typename FVElementGeometry::GridGeometry& gridGeometry,
                               const BoxElementSolution<FVElementGeometry, PrimaryVariables>& elemSol,
                               const typename Element::Geometry::GlobalCoordinate& globalPos,
                               bool ignoreState = false)
@@ -108,7 +108,7 @@ PrimaryVariables evalSolution(const Element& element,
         using Scalar = typename PrimaryVariables::value_type;
 
         // interpolate the solution
-        const auto& localBasis = fvGridGeometry.feCache().get(geometry.type()).localBasis();
+        const auto& localBasis = gridGeometry.feCache().get(geometry.type()).localBasis();
 
         // evaluate the shape functions at the scv center
         const auto localPos = geometry.local(globalPos);
@@ -150,7 +150,7 @@ PrimaryVariables evalSolution(const Element& element,
  * \ingroup Discretization
  * \brief Interpolates a given box element solution at a given global position.
  *
- * Overload of the above evalSolution() function without a given fvGridGeometry.
+ * Overload of the above evalSolution() function without a given gridGeometry.
  * The local basis is computed on the fly.
  *
  * \return the interpolated primary variables
@@ -228,7 +228,7 @@ PrimaryVariables evalSolution(const Element& element,
  * \return the primary variables (constant over the element)
  * \param element The element
  * \param geometry The element geometry
- * \param fvGridGeometry The finite volume grid geometry
+ * \param gridGeometry The finite volume grid geometry
  * \param elemSol The primary variables at the dofs of the element
  * \param globalPos The global position
  * \param ignoreState If true, the state of primary variables is ignored
@@ -236,7 +236,7 @@ PrimaryVariables evalSolution(const Element& element,
 template<class Element, class FVElementGeometry, class PrimaryVariables>
 PrimaryVariables evalSolution(const Element& element,
                               const typename Element::Geometry& geometry,
-                              const typename FVElementGeometry::GridGeometry& fvGridGeometry,
+                              const typename FVElementGeometry::GridGeometry& gridGeometry,
                               const CCElementSolution<FVElementGeometry, PrimaryVariables>& elemSol,
                               const typename Element::Geometry::GlobalCoordinate& globalPos,
                               bool ignoreState = false)
@@ -246,7 +246,7 @@ PrimaryVariables evalSolution(const Element& element,
 
 /*!
  * \brief Interpolates a given cell-centered element solution at a given global position.
- *        Overload of the above evalSolution() function without a given fvGridGeometry.
+ *        Overload of the above evalSolution() function without a given gridGeometry.
  *        For compatibility reasons with the box scheme.
  * \ingroup Discretization
  *
diff --git a/dumux/discretization/fluxstencil.hh b/dumux/discretization/fluxstencil.hh
index c892fef6da22a18847e5c06504db8b2bbf30777e..f671e143b3621aefc4d5eaa476a3afe8931b60fd 100644
--- a/dumux/discretization/fluxstencil.hh
+++ b/dumux/discretization/fluxstencil.hh
@@ -52,9 +52,9 @@ class FluxStencil;
 template<class FVElementGeometry>
 class FluxStencil<FVElementGeometry, DiscretizationMethod::cctpfa>
 {
-    using FVGridGeometry = typename FVElementGeometry::GridGeometry;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename FVElementGeometry::GridGeometry;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GridIndexType = typename IndexTraits<GridView>::GridIndex;
 
@@ -92,14 +92,14 @@ public:
 template<class FVElementGeometry>
 class FluxStencil<FVElementGeometry, DiscretizationMethod::ccmpfa>
 {
-    using FVGridGeometry = typename FVElementGeometry::GridGeometry;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename FVElementGeometry::GridGeometry;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GridIndexType = typename IndexTraits<GridView>::GridIndex;
 
     // Use the stencil type of the primary interaction volume
-    using NodalIndexSet = typename FVGridGeometry::GridIVIndexSets::DualGridIndexSet::NodalIndexSet;
+    using NodalIndexSet = typename GridGeometry::GridIVIndexSets::DualGridIndexSet::NodalIndexSet;
 
 public:
     //! We don't know yet how many faces couple to a neighboring element
@@ -113,13 +113,13 @@ public:
                                   const FVElementGeometry& fvGeometry,
                                   const SubControlVolumeFace& scvf)
     {
-        const auto& fvGridGeometry = fvGeometry.gridGeometry();
+        const auto& gridGeometry = fvGeometry.gridGeometry();
 
         // return the scv (element) indices in the interaction region
-        if (fvGridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()))
-            return fvGridGeometry.gridInteractionVolumeIndexSets().secondaryIndexSet(scvf).gridScvIndices();
+        if (gridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()))
+            return gridGeometry.gridInteractionVolumeIndexSets().secondaryIndexSet(scvf).gridScvIndices();
         else
-            return fvGridGeometry.gridInteractionVolumeIndexSets().primaryIndexSet(scvf).gridScvIndices();
+            return gridGeometry.gridInteractionVolumeIndexSets().primaryIndexSet(scvf).gridScvIndices();
     }
 };
 
diff --git a/dumux/discretization/fvgridvariables.hh b/dumux/discretization/fvgridvariables.hh
index 751bfff5a06e72109cf940486c0939070566bff4..3df3811fd115f33f8f00918b0e59189a9dea0207 100644
--- a/dumux/discretization/fvgridvariables.hh
+++ b/dumux/discretization/fvgridvariables.hh
@@ -61,8 +61,8 @@ public:
 
     template<class Problem>
     FVGridVariables(std::shared_ptr<Problem> problem,
-                    std::shared_ptr<const GridGeometry> fvGridGeometry)
-    : fvGridGeometry_(fvGridGeometry)
+                    std::shared_ptr<const GridGeometry> gridGeometry)
+    : gridGeometry_(gridGeometry)
     , curGridVolVars_(*problem)
     , prevGridVolVars_(*problem)
     , gridFluxVarsCache_(*problem)
@@ -73,10 +73,10 @@ public:
     void init(const SolutionVector& curSol)
     {
         // resize and update the volVars with the initial solution
-        curGridVolVars_.update(*fvGridGeometry_, curSol);
+        curGridVolVars_.update(*gridGeometry_, curSol);
 
         // update the flux variables caches (always force flux cache update on initialization)
-        gridFluxVarsCache_.update(*fvGridGeometry_, curGridVolVars_, curSol, true);
+        gridFluxVarsCache_.update(*gridGeometry_, curGridVolVars_, curSol, true);
 
         // set the volvars of the previous time step in case we have an instationary problem
         // note that this means some memory overhead in the case of enabled caching, however
@@ -99,10 +99,10 @@ public:
     void update(const SolutionVector& curSol, bool forceFluxCacheUpdate = false)
     {
         // resize and update the volVars with the initial solution
-        curGridVolVars_.update(*fvGridGeometry_, curSol);
+        curGridVolVars_.update(*gridGeometry_, curSol);
 
         // update the flux variables caches
-        gridFluxVarsCache_.update(*fvGridGeometry_, curGridVolVars_, curSol, forceFluxCacheUpdate);
+        gridFluxVarsCache_.update(*gridGeometry_, curGridVolVars_, curSol, forceFluxCacheUpdate);
     }
 
     //! update all variables after grid adaption
@@ -134,7 +134,7 @@ public:
         curGridVolVars_ = prevGridVolVars_;
 
         // update the flux variables caches
-        gridFluxVarsCache_.update(*fvGridGeometry_, curGridVolVars_, solution);
+        gridFluxVarsCache_.update(*gridGeometry_, curGridVolVars_, solution);
     }
 
     //! return the flux variables cache
@@ -168,11 +168,11 @@ public:
 
     //! return the finite volume grid geometry
     const GridGeometry& gridGeometry() const
-    { return *fvGridGeometry_; }
+    { return *gridGeometry_; }
 
 protected:
 
-    std::shared_ptr<const GridGeometry> fvGridGeometry_; //!< pointer to the constant grid geometry
+    std::shared_ptr<const GridGeometry> gridGeometry_; //!< pointer to the constant grid geometry
 
 private:
     GridVolumeVariables curGridVolVars_; //!< the current volume variables (primary and secondary variables)
diff --git a/dumux/discretization/localview.hh b/dumux/discretization/localview.hh
index d05420ee8d43f9e9aa3b36326c1cd76cbaebfd31..fc230e8b5d34c4ba876144e482f50e64c751b862 100644
--- a/dumux/discretization/localview.hh
+++ b/dumux/discretization/localview.hh
@@ -31,7 +31,7 @@ namespace Dumux {
  * \ingroup Discretization
  * \brief Free function to get the local view of a grid cache object
  * \note A local object is only functional after calling its bind/bindElement method.
- * \tparam GridCache the grid caching type (such as FVGridGeometry)
+ * \tparam GridCache the grid caching type (such as GridGeometry)
  * \param gridCache the grid caching object we want to localView from
  */
 template<class GridCache>
diff --git a/dumux/discretization/staggered/facesolution.hh b/dumux/discretization/staggered/facesolution.hh
index 29d3bad86ca5629f76b8d810f9378597d0447fa3..58aa36181e7dfb20a5441c4f7bc019ea5bd87cd9 100644
--- a/dumux/discretization/staggered/facesolution.hh
+++ b/dumux/discretization/staggered/facesolution.hh
@@ -42,13 +42,13 @@ class StaggeredFaceSolution
 
 public:
 
-    template<class SubControlVolumeFace, class FVGridGeometry>
+    template<class SubControlVolumeFace, class GridGeometry>
     StaggeredFaceSolution(const SubControlVolumeFace& scvf, const FaceSolutionVector& sol,
-                          const FVGridGeometry& fvGridGeometry)
+                          const GridGeometry& gridGeometry)
     {
 
-        const auto& connectivityMap = fvGridGeometry.connectivityMap();
-        const auto& stencil = connectivityMap(FVGridGeometry::faceIdx(), FVGridGeometry::faceIdx(), scvf.index());
+        const auto& connectivityMap = gridGeometry.connectivityMap();
+        const auto& stencil = connectivityMap(GridGeometry::faceIdx(), GridGeometry::faceIdx(), scvf.index());
 
         facePriVars_.reserve(stencil.size()+1);
         map_.reserve(stencil.size()+1);
diff --git a/dumux/discretization/staggered/freeflow/connectivitymap.hh b/dumux/discretization/staggered/freeflow/connectivitymap.hh
index 23981f35b36cb6562bf0438324ce082072da158f..c9a06874f9698f2768596a176af684b53f20b062 100644
--- a/dumux/discretization/staggered/freeflow/connectivitymap.hh
+++ b/dumux/discretization/staggered/freeflow/connectivitymap.hh
@@ -34,51 +34,51 @@ namespace Dumux {
  * \brief Stores the dof indices corresponding to the neighboring cell centers and faces
  *        that contribute to the derivative calculation. Specialization for the staggered free flow model.
  */
-template<class FVGridGeometry>
+template<class GridGeometry>
 class StaggeredFreeFlowConnectivityMap
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
 
     using Element = typename GridView::template Codim<0>::Entity;
     using GridIndexType = typename IndexTraits<GridView>::GridIndex;
 
-    using CellCenterIdxType = typename FVGridGeometry::DofTypeIndices::CellCenterIdx;
-    using FaceIdxType = typename FVGridGeometry::DofTypeIndices::FaceIdx;
+    using CellCenterIdxType = typename GridGeometry::DofTypeIndices::CellCenterIdx;
+    using FaceIdxType = typename GridGeometry::DofTypeIndices::FaceIdx;
 
     using SmallLocalIndex = typename IndexTraits<GridView>::SmallLocalIndex;
 
     using Stencil = std::vector<GridIndexType>;
     using Map = std::vector<Stencil>;
 
-    static constexpr SmallLocalIndex upwindSchemeOrder = FVGridGeometry::upwindSchemeOrder;
+    static constexpr SmallLocalIndex upwindSchemeOrder = GridGeometry::upwindSchemeOrder;
     static constexpr bool useHigherOrder = upwindSchemeOrder > 1;
 
 public:
 
     //! Update the map and prepare the stencils
-    void update(const FVGridGeometry& fvGridGeometry)
+    void update(const GridGeometry& gridGeometry)
     {
-        const auto numDofsCC = fvGridGeometry.gridView().size(0);
-        const auto numDofsFace = fvGridGeometry.gridView().size(1);
-        const auto numBoundaryFacets = fvGridGeometry.numBoundaryScvf();
+        const auto numDofsCC = gridGeometry.gridView().size(0);
+        const auto numDofsFace = gridGeometry.gridView().size(1);
+        const auto numBoundaryFacets = gridGeometry.numBoundaryScvf();
         cellCenterToCellCenterMap_.resize(numDofsCC);
         cellCenterToFaceMap_.resize(numDofsCC);
         faceToCellCenterMap_.resize(2*numDofsFace - numBoundaryFacets);
         faceToFaceMap_.resize(2*numDofsFace - numBoundaryFacets);
 
-        for(auto&& element: elements(fvGridGeometry.gridView()))
+        for(auto&& element: elements(gridGeometry.gridView()))
         {
             // restrict the FvGeometry locally and bind to the element
-            auto fvGeometry = localView(fvGridGeometry);
+            auto fvGeometry = localView(gridGeometry);
             fvGeometry.bindElement(element);
 
             // loop over sub control faces
             for (auto&& scvf : scvfs(fvGeometry))
             {
                 // handle the cell center dof stencils first
-                const auto dofIdxCellCenter = fvGridGeometry.elementMapper().index(element);
+                const auto dofIdxCellCenter = gridGeometry.elementMapper().index(element);
 
                 // the stencil for cell center dofs w.r.t. to other cell center dofs,
                 // includes all neighboring element indices
diff --git a/dumux/discretization/staggered/freeflow/elementvolumevariables.hh b/dumux/discretization/staggered/freeflow/elementvolumevariables.hh
index 7c57103a7ca525f983c17d294640e5696323ba05..67b0acd3fc82465cf77f51e1f6f106e2d18fba22 100644
--- a/dumux/discretization/staggered/freeflow/elementvolumevariables.hh
+++ b/dumux/discretization/staggered/freeflow/elementvolumevariables.hh
@@ -209,9 +209,9 @@ public:
         clear_();
 
         const auto& problem = gridVolVars().problem();
-        const auto& fvGridGeometry = fvGeometry.gridGeometry();
-        const auto globalI = fvGridGeometry.elementMapper().index(element);
-        const auto& map = fvGridGeometry.connectivityMap();
+        const auto& gridGeometry = fvGeometry.gridGeometry();
+        const auto globalI = gridGeometry.elementMapper().index(element);
+        const auto& map = gridGeometry.connectivityMap();
         constexpr auto cellCenterIdx = FVElementGeometry::GridGeometry::cellCenterIdx();
         const auto& connectivityMapI = map(cellCenterIdx, cellCenterIdx, globalI);
         const auto numDofs = connectivityMapI.size();
@@ -226,7 +226,7 @@ public:
         // Lambda to update the volume variables of the given index
         auto doVolVarUpdate = [&](int globalJ)
         {
-            const auto& elementJ = fvGridGeometry.element(globalJ);
+            const auto& elementJ = gridGeometry.element(globalJ);
             auto&& scvJ = fvGeometry.scv(globalJ);
             const auto elemSol = makeElementSolutionFromCellCenterPrivars<PrimaryVariables>(sol[globalJ]);
             volumeVariables_[localIdx].update(elemSol,
diff --git a/dumux/discretization/staggered/freeflow/fvgridgeometrytraits.hh b/dumux/discretization/staggered/freeflow/fvgridgeometrytraits.hh
index c9e88535066c1de09024b420d6427001c08d74ea..f321e56e2cdf2d90062b24ba68d5d80461525c2d 100644
--- a/dumux/discretization/staggered/freeflow/fvgridgeometrytraits.hh
+++ b/dumux/discretization/staggered/freeflow/fvgridgeometrytraits.hh
@@ -55,11 +55,11 @@ struct StaggeredFreeFlowDefaultFVGridGeometryTraits
         using FaceIdx = Dune::index_constant<1>;
     };
 
-    template<class FVGridGeometry>
-    using ConnectivityMap = StaggeredFreeFlowConnectivityMap<FVGridGeometry>;
+    template<class GridGeometry>
+    using ConnectivityMap = StaggeredFreeFlowConnectivityMap<GridGeometry>;
 
-    template<class FVGridGeometry, bool cachingEnabled>
-    using LocalView = StaggeredFVElementGeometry<FVGridGeometry, cachingEnabled>;
+    template<class GridGeometry, bool cachingEnabled>
+    using LocalView = StaggeredFVElementGeometry<GridGeometry, cachingEnabled>;
 };
 
 } //end namespace Dumux
diff --git a/dumux/discretization/staggered/freeflow/gridvolumevariables.hh b/dumux/discretization/staggered/freeflow/gridvolumevariables.hh
index 580dbae39d1c757f4b679cc423f808eb072e6a29..7170c40cd65878be68dcc7583b57c5a8a0f6c18b 100644
--- a/dumux/discretization/staggered/freeflow/gridvolumevariables.hh
+++ b/dumux/discretization/staggered/freeflow/gridvolumevariables.hh
@@ -159,15 +159,15 @@ public:
     StaggeredGridVolumeVariables(const Problem& problem) : problemPtr_(&problem) {}
 
     //! Update all volume variables
-    template<class FVGridGeometry, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry, const SolutionVector& sol)
+    template<class GridGeometry, class SolutionVector>
+    void update(const GridGeometry& gridGeometry, const SolutionVector& sol)
     {
-        auto numScv = fvGridGeometry.numScv();
+        auto numScv = gridGeometry.numScv();
         volumeVariables_.resize(numScv);
 
-        for (const auto& element : elements(fvGridGeometry.gridView()))
+        for (const auto& element : elements(gridGeometry.gridView()))
         {
-            auto fvGeometry = localView(fvGridGeometry);
+            auto fvGeometry = localView(gridGeometry);
             fvGeometry.bindElement(element);
 
             for (auto&& scv : scvs(fvGeometry))
@@ -176,7 +176,7 @@ public:
                 const auto& cellCenterPriVars = sol[scv.dofIndex()];
                 PrimaryVariables priVars = makePriVarsFromCellCenterPriVars<PrimaryVariables>(cellCenterPriVars);
 
-                auto elemSol = elementSolution<typename FVGridGeometry::LocalView>(std::move(priVars));
+                auto elemSol = elementSolution<typename GridGeometry::LocalView>(std::move(priVars));
                 volumeVariables_[scv.dofIndex()].update(elemSol, problem(), element, scv);
             }
         }
@@ -239,8 +239,8 @@ public:
 
     StaggeredGridVolumeVariables(const Problem& problem) : problemPtr_(&problem) {}
 
-    template<class FVGridGeometry, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry, const SolutionVector& sol) {}
+    template<class GridGeometry, class SolutionVector>
+    void update(const GridGeometry& gridGeometry, const SolutionVector& sol) {}
 
     const Problem& problem() const
     { return *problemPtr_;}
diff --git a/dumux/discretization/staggered/freeflow/velocityoutput.hh b/dumux/discretization/staggered/freeflow/velocityoutput.hh
index 1d4354093c70a595abbce99373c158cdd602f194..cb9b0e9a5c8c91350b59b0c9523d72b076a9236a 100644
--- a/dumux/discretization/staggered/freeflow/velocityoutput.hh
+++ b/dumux/discretization/staggered/freeflow/velocityoutput.hh
@@ -37,16 +37,16 @@ template<class GridVariables, class SolutionVector>
 class StaggeredFreeFlowVelocityOutput : public VelocityOutput<GridVariables>
 {
     using ParentType = VelocityOutput<GridVariables>;
-    using FVGridGeometry = typename GridVariables::GridGeometry;
+    using GridGeometry = typename GridVariables::GridGeometry;
     using Scalar = typename GridVariables::Scalar;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
     using GridVolumeVariables = typename GridVariables::GridVolumeVariables;
     using ElementVolumeVariables = typename GridVolumeVariables::LocalView;
     using ElementFluxVarsCache = typename GridVariables::GridFluxVariablesCache::LocalView;
     using VolumeVariables = typename GridVariables::VolumeVariables;
     using FluidSystem = typename VolumeVariables::FluidSystem;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     // TODO: should be possible to get this somehow
     using Problem = typename std::decay_t<decltype(std::declval<GridVolumeVariables>().problem())>;
     using Element = typename GridView::template Codim<0>::Entity;
diff --git a/dumux/discretization/staggered/fvelementgeometry.hh b/dumux/discretization/staggered/fvelementgeometry.hh
index f1e91e583002abf28648633f453005a890d82c98..b29bb9d435884293e8cd9e27b7f39716e3237d16 100644
--- a/dumux/discretization/staggered/fvelementgeometry.hh
+++ b/dumux/discretization/staggered/fvelementgeometry.hh
@@ -66,7 +66,7 @@ public:
     //! Needed for the multi-domain framework.
     template<class CellCenterOrFaceFVGridGeometry>
     StaggeredFVElementGeometry(const CellCenterOrFaceFVGridGeometry& gridGeometry)
-    : ParentType(gridGeometry.actualfvGridGeometry()) {}
+    : ParentType(gridGeometry.actualGridGeometry()) {}
 
     //! Get a sub control volume face with an element index and a local scvf index
     using ParentType::scvf;
@@ -105,7 +105,7 @@ public:
     //! Needed for the multi-domain framework.
     template<class CellCenterOrFaceFVGridGeometry>
     StaggeredFVElementGeometry(const CellCenterOrFaceFVGridGeometry& gridGeometry)
-    : gridGeometryPtr_(&gridGeometry.actualfvGridGeometry()) {}
+    : gridGeometryPtr_(&gridGeometry.actualGridGeometry()) {}
 
     //! Constructor
     StaggeredFVElementGeometry(const GridGeometry& gridGeometry)
diff --git a/dumux/discretization/staggered/fvgridgeometry.hh b/dumux/discretization/staggered/fvgridgeometry.hh
index ac8bc79ccbce2e4454a1105359df712adbab49ea..466b48f1ce122209028643a797e7414b342055ad 100644
--- a/dumux/discretization/staggered/fvgridgeometry.hh
+++ b/dumux/discretization/staggered/fvgridgeometry.hh
@@ -34,20 +34,20 @@ namespace Dumux {
 /*!
  * \ingroup StaggeredDiscretization
  * \brief Base class for cell center of face specific auxiliary FvGridGeometry classes.
- *        Provides a common interface and a pointer to the actual fvGridGeometry.
+ *        Provides a common interface and a pointer to the actual gridGeometry.
  */
-template<class ActualFVGridGeometry>
+template<class ActualGridGeometry>
 class GridGeometryView
 {
 public:
 
-    explicit GridGeometryView(const ActualFVGridGeometry* actualFVGridGeometry)
-    : fvGridGeometry_(actualFVGridGeometry) {}
+    explicit GridGeometryView(const ActualGridGeometry* actualGridGeometry)
+    : gridGeometry_(actualGridGeometry) {}
 
     //! export  the GridView type and the discretization method
-    using GridView = typename ActualFVGridGeometry::GridView;
+    using GridView = typename ActualGridGeometry::GridView;
     static constexpr DiscretizationMethod discMethod = DiscretizationMethod::staggered;
-    using LocalView = typename ActualFVGridGeometry::LocalView;
+    using LocalView = typename ActualGridGeometry::LocalView;
 
     /*!
      * \brief Returns true if this view if related to cell centered dofs
@@ -63,47 +63,54 @@ public:
      * \brief Return an integral constant index for cell centered dofs
      */
     static constexpr auto cellCenterIdx()
-    { return typename ActualFVGridGeometry::DofTypeIndices::CellCenterIdx{}; }
+    { return typename ActualGridGeometry::DofTypeIndices::CellCenterIdx{}; }
 
     /*!
      * \brief Return an integral constant index for face dofs
      */
     static constexpr auto faceIdx()
-    { return typename ActualFVGridGeometry::DofTypeIndices::FaceIdx{}; }
+    { return typename ActualGridGeometry::DofTypeIndices::FaceIdx{}; }
 
     /*!
      * \brief Return the gridView this grid geometry object lives on
      */
     const auto& gridView() const
-    { return fvGridGeometry_->gridView(); }
+    { return gridGeometry_->gridView(); }
 
     /*!
      * \brief Returns the connectivity map of which dofs have derivatives with respect
      *        to a given dof.
      */
     const auto& connectivityMap() const // TODO return correct map
-    { return fvGridGeometry_->connectivityMap(); }
+    { return gridGeometry_->connectivityMap(); }
 
     /*!
      * \brief Returns the mapper for vertices to indices for possibly adaptive grids.
      */
     const auto& vertexMapper() const
-    { return fvGridGeometry_->vertexMapper(); }
+    { return gridGeometry_->vertexMapper(); }
 
     /*!
      * \brief Returns the mapper for elements to indices for constant grids.
      */
     const auto& elementMapper() const
-    { return fvGridGeometry_->elementMapper(); }
+    { return gridGeometry_->elementMapper(); }
 
     /*!
-     * \brief Returns the actual fvGridGeometry we are a restriction of
+     * \brief Returns the actual gridGeometry we are a restriction of
      */
-    const ActualFVGridGeometry& actualfvGridGeometry() const
-    { return *fvGridGeometry_; }
+    [[deprecated("Use actualGridGeometry instead")]]
+    const ActualGridGeometry& actualfvGridGeometry() const
+    { return actualGridGeometry(); }
+
+    /*!
+     * \brief Returns the actual gridGeometry we are a restriction of
+     */
+    const ActualGridGeometry& actualGridGeometry() const
+    { return *gridGeometry_; }
 
 protected:
-    const ActualFVGridGeometry* fvGridGeometry_;
+    const ActualGridGeometry* gridGeometry_;
 
 };
 
@@ -112,10 +119,10 @@ protected:
  * \brief Cell center specific auxiliary FvGridGeometry classes.
  *        Required for the Dumux multi-domain framework.
  */
-template <class ActualFVGridGeometry>
-class CellCenterFVGridGeometry : public GridGeometryView<ActualFVGridGeometry>
+template <class ActualGridGeometry>
+class CellCenterFVGridGeometry : public GridGeometryView<ActualGridGeometry>
 {
-    using ParentType = GridGeometryView<ActualFVGridGeometry>;
+    using ParentType = GridGeometryView<ActualGridGeometry>;
 public:
 
     using ParentType::ParentType;
@@ -129,7 +136,7 @@ public:
      * \brief The total number of cell centered dofs
      */
     std::size_t numDofs() const
-    { return this->fvGridGeometry_->numCellCenterDofs(); }
+    { return this->gridGeometry_->numCellCenterDofs(); }
 };
 
 /*!
@@ -137,10 +144,10 @@ public:
  * \brief Face specific auxiliary FvGridGeometry classes.
  *        Required for the Dumux multi-domain framework.
  */
-template <class ActualFVGridGeometry>
-class FaceFVGridGeometry : public GridGeometryView<ActualFVGridGeometry>
+template <class ActualGridGeometry>
+class FaceFVGridGeometry : public GridGeometryView<ActualGridGeometry>
 {
-    using ParentType = GridGeometryView<ActualFVGridGeometry>;
+    using ParentType = GridGeometryView<ActualGridGeometry>;
 public:
 
     using ParentType::ParentType;
@@ -154,7 +161,7 @@ public:
      * \brief The total number of cell centered dofs
      */
     std::size_t numDofs() const
-    { return this->fvGridGeometry_->numFaceDofs(); }
+    { return this->gridGeometry_->numFaceDofs(); }
 };
 
 /*!
diff --git a/dumux/discretization/staggered/gridfacevariables.hh b/dumux/discretization/staggered/gridfacevariables.hh
index 109f742f91b813f3a6f470e840ce1bd58b69315e..f6c5eb63155dd862f2bdd9ff8e8390011917f4b8 100644
--- a/dumux/discretization/staggered/gridfacevariables.hh
+++ b/dumux/discretization/staggered/gridfacevariables.hh
@@ -81,15 +81,15 @@ public:
     StaggeredGridFaceVariables(const Problem& problem) : problemPtr_(&problem) {}
 
     //! Update all face variables
-    template<class FVGridGeometry, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry, const SolutionVector& faceSol)
+    template<class GridGeometry, class SolutionVector>
+    void update(const GridGeometry& gridGeometry, const SolutionVector& faceSol)
     {
 
-        faceVariables_.resize(fvGridGeometry.numScvf());
+        faceVariables_.resize(gridGeometry.numScvf());
 
-        for(auto&& element : elements(fvGridGeometry.gridView()))
+        for(auto&& element : elements(gridGeometry.gridView()))
         {
-            auto fvGeometry = localView(fvGridGeometry);
+            auto fvGeometry = localView(gridGeometry);
             fvGeometry.bindElement(element);
 
             for(auto&& scvf : scvfs(fvGeometry))
@@ -137,8 +137,8 @@ public:
     StaggeredGridFaceVariables(const Problem& problem) : problemPtr_(&problem) {}
 
     //! Do nothing here.
-    template<class FVGridGeometry, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry, const SolutionVector& sol) {}
+    template<class GridGeometry, class SolutionVector>
+    void update(const GridGeometry& gridGeometry, const SolutionVector& sol) {}
 
     const Problem& problem() const
     { return *problemPtr_; }
diff --git a/dumux/discretization/staggered/gridfluxvariablescache.hh b/dumux/discretization/staggered/gridfluxvariablescache.hh
index 980da348d57aab568ebca228e5a626d230617a1a..ff6d9273bc49518076e6d7be1e3cf76b1e55d459 100644
--- a/dumux/discretization/staggered/gridfluxvariablescache.hh
+++ b/dumux/discretization/staggered/gridfluxvariablescache.hh
@@ -97,8 +97,8 @@ public:
     {}
 
     // When global caching is enabled, precompute transmissibilities and stencils for all the scv faces
-    template<class FVGridGeometry, class GridVolumeVariables, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry,
+    template<class GridGeometry, class GridVolumeVariables, class SolutionVector>
+    void update(const GridGeometry& gridGeometry,
                 const GridVolumeVariables& gridVolVars,
                 const SolutionVector& sol,
                 bool forceUpdate = false)
@@ -110,11 +110,11 @@ public:
             // FluxVariablesCacheFiller filler(problem()); TODO: use proper ctor
             FluxVariablesCacheFiller filler(problem());
 
-            fluxVarsCache_.resize(fvGridGeometry.numScvf());
-            for (const auto& element : elements(fvGridGeometry.gridView()))
+            fluxVarsCache_.resize(gridGeometry.numScvf());
+            for (const auto& element : elements(gridGeometry.gridView()))
             {
                 // Prepare the geometries within the elements of the stencil
-                auto fvGeometry = localView(fvGridGeometry);
+                auto fvGeometry = localView(gridGeometry);
                 fvGeometry.bind(element);
 
                 auto elemVolVars = localView(gridVolVars);
@@ -187,8 +187,8 @@ public:
       {}
 
     // When global caching is enabled, precompute transmissibilities and stencils for all the scv faces
-    template<class FVGridGeometry, class GridVolumeVariables, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry,
+    template<class GridGeometry, class GridVolumeVariables, class SolutionVector>
+    void update(const GridGeometry& gridGeometry,
                 const GridVolumeVariables& gridVolVars,
                 const SolutionVector& sol,
                 bool forceUpdate = false) {}
diff --git a/dumux/discretization/staggered/gridvariables.hh b/dumux/discretization/staggered/gridvariables.hh
index 95d8578a926db9f69bbe7cc6d16ff3d92879308f..4475e690cd3427b6cfa06ad099c349500aea8363 100644
--- a/dumux/discretization/staggered/gridvariables.hh
+++ b/dumux/discretization/staggered/gridvariables.hh
@@ -94,11 +94,11 @@ public:
 
     //! return the fv grid geometry
     [[deprecated("Use gridGeometry() instead. fvGridGeometry() will be removed after 3.1!")]]
-    const FVGridGeometry& fvGridGeometry() const
-    { return (*gridVariables_->fvGridGeometry_);    }
+    const GridGeometry& fvGridGeometry() const
+    { return (*gridVariables_->gridGeometry_);    }
     //! return the fv grid geometry
-    const FVGridGeometry& gridGeometry() const
-    { return (*gridVariables_->fvGridGeometry_);    }
+    const GridGeometry& gridGeometry() const
+    { return (*gridVariables_->gridGeometry_);    }
 
     // return the actual grid variables
     const ActualGridVariables& gridVariables() const
@@ -215,12 +215,11 @@ template<class GG, class GVV, class GFVC, class GFV>
 class StaggeredGridVariables : public FVGridVariables<GG, GVV, GFVC>
 {
     using ParentType = FVGridVariables<GG, GVV, GFVC>;
-    using FVGridGeometry = GG;
     using ThisType = StaggeredGridVariables<GG, GVV, GFVC, GFV>;
     friend class StaggeredGridVariablesView<ThisType>;
 
-    static constexpr auto cellCenterIdx = FVGridGeometry::cellCenterIdx();
-    static constexpr auto faceIdx = FVGridGeometry::faceIdx();
+    static constexpr auto cellCenterIdx = GG::cellCenterIdx();
+    static constexpr auto faceIdx = GG::faceIdx();
 
 public:
     using CellCenterGridVariablesType = CellCenterGridVariablesView<ThisType>;
@@ -238,8 +237,8 @@ public:
     //! Constructor
     template<class Problem>
     StaggeredGridVariables(std::shared_ptr<Problem> problem,
-                           std::shared_ptr<GridGeometry> fvGridGeometry)
-    : ParentType(problem, fvGridGeometry)
+                           std::shared_ptr<GridGeometry> gridGeometry)
+    : ParentType(problem, gridGeometry)
     , curGridFaceVariables_(*problem)
     , prevGridFaceVariables_(*problem)
     {}
@@ -249,7 +248,7 @@ public:
     void update(const SolutionVector& curSol)
     {
         ParentType::update(curSol[cellCenterIdx]);
-        curGridFaceVariables_.update(*this->fvGridGeometry_, curSol[faceIdx]);
+        curGridFaceVariables_.update(*this->gridGeometry_, curSol[faceIdx]);
     }
 
     //! initialize all variables (stationary case)
@@ -257,8 +256,8 @@ public:
     void init(const SolutionVector& curSol)
     {
         ParentType::init(curSol[cellCenterIdx]);
-        curGridFaceVariables_.update(*this->fvGridGeometry_, curSol[faceIdx]);
-        prevGridFaceVariables_.update(*this->fvGridGeometry_, curSol[faceIdx]);
+        curGridFaceVariables_.update(*this->gridGeometry_, curSol[faceIdx]);
+        prevGridFaceVariables_.update(*this->gridGeometry_, curSol[faceIdx]);
     }
 
     //! initialize all variables (instationary case)
diff --git a/dumux/flux/box/darcyslaw.hh b/dumux/flux/box/darcyslaw.hh
index d97dc02378812ccc204eaddf7476cbbd4e59e13c..fdf0f2ccff2ca705d52c3e487319bb75ec9d0a81 100644
--- a/dumux/flux/box/darcyslaw.hh
+++ b/dumux/flux/box/darcyslaw.hh
@@ -40,7 +40,7 @@ template<class TypeTag, DiscretizationMethod discMethod>
 class DarcysLawImplementation;
 
 // forward declaration
-template<class Scalar, class FVGridGeometry>
+template<class Scalar, class GridGeometry>
 class BoxDarcysLaw;
 
 /*!
@@ -56,15 +56,15 @@ class DarcysLawImplementation<TypeTag, DiscretizationMethod::box>
  * \ingroup BoxFlux
  * \brief Darcy's law for box schemes
  * \tparam Scalar the scalar type for scalar physical quantities
- * \tparam FVGridGeometry the grid geometry
+ * \tparam GridGeometry the grid geometry
  */
-template<class Scalar, class FVGridGeometry>
+template<class Scalar, class GridGeometry>
 class BoxDarcysLaw
 {
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using CoordScalar = typename GridView::ctype;
 
diff --git a/dumux/flux/box/effectivestresslaw.hh b/dumux/flux/box/effectivestresslaw.hh
index c51c2dad792134847199259d14202cf00171561c..524d5cf294df71139f3f96b6c5edc3f37fd5628c 100644
--- a/dumux/flux/box/effectivestresslaw.hh
+++ b/dumux/flux/box/effectivestresslaw.hh
@@ -35,16 +35,16 @@ namespace Dumux {
  * \brief Effective stress law for box scheme
  * \tparam StressType type used for the computation of
  *         purely mechanical stresses (i.e. material law)
- * \tparam FVGridGeometry the finite volume grid geometry
+ * \tparam GridGeometry the finite volume grid geometry
  */
-template<class StressType, class FVGridGeometry>
-class EffectiveStressLaw<StressType, FVGridGeometry, DiscretizationMethod::box>
+template<class StressType, class GridGeometry>
+class EffectiveStressLaw<StressType, GridGeometry, DiscretizationMethod::box>
 {
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
 
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
 
     static constexpr int dim = GridView::dimension;
diff --git a/dumux/flux/box/hookeslaw.hh b/dumux/flux/box/hookeslaw.hh
index 3a8a404c631a0c80686f852cefc762fc74bb6926..3a15e59d3eaf1fde437eec34a30cbd529fa4befa 100644
--- a/dumux/flux/box/hookeslaw.hh
+++ b/dumux/flux/box/hookeslaw.hh
@@ -37,16 +37,16 @@ namespace Dumux {
  * \ingroup BoxFlux
  * \brief Hooke's law for box scheme
  * \tparam ScalarType the scalar type for scalar physical quantities
- * \tparam FVGridGeometry the grid geometry
+ * \tparam GridGeometry the grid geometry
  */
-template<class ScalarType, class FVGridGeometry>
-class HookesLaw<ScalarType, FVGridGeometry, DiscretizationMethod::box>
+template<class ScalarType, class GridGeometry>
+class HookesLaw<ScalarType, GridGeometry, DiscretizationMethod::box>
 {
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
 
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
 
     static constexpr int dim = GridView::dimension;
diff --git a/dumux/flux/ccmpfa/darcyslaw.hh b/dumux/flux/ccmpfa/darcyslaw.hh
index d2558effe8ecbf9796399e99f61f1772b3e2a062..61fb874476b8802325d27536827d87a2a38e29de 100644
--- a/dumux/flux/ccmpfa/darcyslaw.hh
+++ b/dumux/flux/ccmpfa/darcyslaw.hh
@@ -54,8 +54,8 @@ class DarcysLawImplementation<TypeTag, DiscretizationMethod::ccmpfa>
     static constexpr int dim = GridView::dimension;
     static constexpr int dimWorld = GridView::dimensionworld;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
 
@@ -94,7 +94,7 @@ class DarcysLawImplementation<TypeTag, DiscretizationMethod::ccmpfa>
 
         using Stencil = typename DualGridNodalIndexSet::NodalGridStencilType;
 
-        static constexpr bool considerSecondaryIVs = FVGridGeometry::MpfaHelper::considerSecondaryIVs();
+        static constexpr bool considerSecondaryIVs = GridGeometry::MpfaHelper::considerSecondaryIVs();
         using PrimaryDataHandle = typename ElementFluxVariablesCache::PrimaryIvDataHandle::AdvectionHandle;
         using SecondaryDataHandle = typename ElementFluxVariablesCache::SecondaryIvDataHandle::AdvectionHandle;
 
diff --git a/dumux/flux/ccmpfa/fickslaw.hh b/dumux/flux/ccmpfa/fickslaw.hh
index c17384152c94ec0e4e30d0c3bc2a5bcc9fd8570b..ba45b0ab13ca37450284c588255476ea70b6a1cc 100644
--- a/dumux/flux/ccmpfa/fickslaw.hh
+++ b/dumux/flux/ccmpfa/fickslaw.hh
@@ -51,8 +51,8 @@ class FicksLawImplementation<TypeTag, DiscretizationMethod::ccmpfa, referenceSys
     static constexpr int dim = GridView::dimension;
     static constexpr int dimWorld = GridView::dimensionworld;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
@@ -100,7 +100,7 @@ class FicksLawImplementation<TypeTag, DiscretizationMethod::ccmpfa, referenceSys
         using Stencil = typename DualGridNodalIndexSet::NodalGridStencilType;
 
         static constexpr int numPhases = GetPropType<TypeTag, Properties::ModelTraits>::numFluidPhases();
-        static constexpr bool considerSecondaryIVs = FVGridGeometry::MpfaHelper::considerSecondaryIVs();
+        static constexpr bool considerSecondaryIVs = GridGeometry::MpfaHelper::considerSecondaryIVs();
         using PrimaryDataHandle = typename ElementFluxVariablesCache::PrimaryIvDataHandle::DiffusionHandle;
         using SecondaryDataHandle = typename ElementFluxVariablesCache::SecondaryIvDataHandle::DiffusionHandle;
 
diff --git a/dumux/flux/ccmpfa/fourierslaw.hh b/dumux/flux/ccmpfa/fourierslaw.hh
index fcb8ec28a57a90e8089a88af1c15695b5c07af36..b0ba06012f75d784301324a6c0b243dfee1025fc 100644
--- a/dumux/flux/ccmpfa/fourierslaw.hh
+++ b/dumux/flux/ccmpfa/fourierslaw.hh
@@ -51,8 +51,8 @@ class FouriersLawImplementation<TypeTag, DiscretizationMethod::ccmpfa>
     static constexpr int dim = GridView::dimension;
     static constexpr int dimWorld = GridView::dimensionworld;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
     using ElementFluxVarsCache = typename GetPropType<TypeTag, Properties::GridFluxVariablesCache>::LocalView;
@@ -92,7 +92,7 @@ class FouriersLawImplementation<TypeTag, DiscretizationMethod::ccmpfa>
         using DualGridNodalIndexSet = GetPropType<TypeTag, Properties::DualGridNodalIndexSet>;
         using Stencil = typename DualGridNodalIndexSet::NodalGridStencilType;
 
-        static constexpr bool considerSecondaryIVs = FVGridGeometry::MpfaHelper::considerSecondaryIVs();
+        static constexpr bool considerSecondaryIVs = GridGeometry::MpfaHelper::considerSecondaryIVs();
         using PrimaryDataHandle = typename ElementFluxVarsCache::PrimaryIvDataHandle::HeatConductionHandle;
         using SecondaryDataHandle = typename ElementFluxVarsCache::SecondaryIvDataHandle::HeatConductionHandle;
 
diff --git a/dumux/flux/cctpfa/darcyslaw.hh b/dumux/flux/cctpfa/darcyslaw.hh
index 80d949f5ca4079aec8c84fdd90f0d7df56298b9d..61eb7b6f839b8b1bf34b6179add535cca9a5c596 100644
--- a/dumux/flux/cctpfa/darcyslaw.hh
+++ b/dumux/flux/cctpfa/darcyslaw.hh
@@ -42,10 +42,10 @@ class DarcysLawImplementation;
  * \brief Darcy's law for cell-centered finite volume schemes with two-point flux approximation
  * \note Darcy's law is specialized for network and surface grids (i.e. if grid dim < dimWorld)
  * \tparam Scalar the scalar type for scalar physical quantities
- * \tparam FVGridGeometry the grid geometry
+ * \tparam GridGeometry the grid geometry
  * \tparam isNetwork whether we are computing on a network grid embedded in a higher world dimension
  */
-template<class Scalar, class FVGridGeometry, bool isNetwork>
+template<class Scalar, class GridGeometry, bool isNetwork>
 class CCTpfaDarcysLaw;
 
 /*!
@@ -64,12 +64,12 @@ class DarcysLawImplementation<TypeTag, DiscretizationMethod::cctpfa>
  * \ingroup CCTpfaFlux
  * \brief Class that fills the cache corresponding to tpfa Darcy's Law
  */
-template<class FVGridGeometry>
+template<class GridGeometry>
 class TpfaDarcysLawCacheFiller
 {
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
 
 public:
     //! Function to fill a TpfaDarcysLawCache of a given scvf
@@ -92,16 +92,16 @@ public:
  * \ingroup CCTpfaFlux
  * \brief The cache corresponding to tpfa Darcy's Law
  */
-template<class AdvectionType, class FVGridGeometry>
+template<class AdvectionType, class GridGeometry>
 class TpfaDarcysLawCache
 {
     using Scalar = typename AdvectionType::Scalar;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
 
 public:
-    using Filler = TpfaDarcysLawCacheFiller<FVGridGeometry>;
+    using Filler = TpfaDarcysLawCacheFiller<GridGeometry>;
 
     template<class Problem, class ElementVolumeVariables>
     void updateAdvection(const Problem& problem,
@@ -124,14 +124,14 @@ private:
  * \ingroup CCTpfaFlux
  * \brief Specialization of the CCTpfaDarcysLaw grids where dim=dimWorld
  */
-template<class ScalarType, class FVGridGeometry>
-class CCTpfaDarcysLaw<ScalarType, FVGridGeometry, /*isNetwork*/ false>
+template<class ScalarType, class GridGeometry>
+class CCTpfaDarcysLaw<ScalarType, GridGeometry, /*isNetwork*/ false>
 {
-    using ThisType = CCTpfaDarcysLaw<ScalarType, FVGridGeometry, /*isNetwork*/ false>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using ThisType = CCTpfaDarcysLaw<ScalarType, GridGeometry, /*isNetwork*/ false>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
 
     static constexpr int dim = GridView::dimension;
@@ -147,7 +147,7 @@ class CCTpfaDarcysLaw<ScalarType, FVGridGeometry, /*isNetwork*/ false>
     static const DiscretizationMethod discMethod = DiscretizationMethod::cctpfa;
 
     //! state the type for the corresponding cache
-    using Cache = TpfaDarcysLawCache<ThisType, FVGridGeometry>;
+    using Cache = TpfaDarcysLawCache<ThisType, GridGeometry>;
 
     //! Compute the advective flux
     template<class Problem, class ElementVolumeVariables, class ElementFluxVarsCache>
@@ -278,14 +278,14 @@ private:
  * \ingroup CCTpfaFlux
  * \brief Specialization of the CCTpfaDarcysLaw grids where dim < dimWorld (network/surface grids)
  */
-template<class ScalarType, class FVGridGeometry>
-class CCTpfaDarcysLaw<ScalarType, FVGridGeometry, /*isNetwork*/ true>
+template<class ScalarType, class GridGeometry>
+class CCTpfaDarcysLaw<ScalarType, GridGeometry, /*isNetwork*/ true>
 {
-    using ThisType = CCTpfaDarcysLaw<ScalarType, FVGridGeometry, /*isNetwork*/ true>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using ThisType = CCTpfaDarcysLaw<ScalarType, GridGeometry, /*isNetwork*/ true>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
 
     static constexpr int dim = GridView::dimension;
@@ -301,7 +301,7 @@ public:
     static const DiscretizationMethod discMethod = DiscretizationMethod::cctpfa;
 
     //! state the type for the corresponding cache
-    using Cache = TpfaDarcysLawCache<ThisType, FVGridGeometry>;
+    using Cache = TpfaDarcysLawCache<ThisType, GridGeometry>;
 
     //! Compute the advective flux
     template<class Problem, class ElementVolumeVariables, class ElementFluxVarsCache>
diff --git a/dumux/flux/cctpfa/forchheimerslaw.hh b/dumux/flux/cctpfa/forchheimerslaw.hh
index b721a1c12dbea62ca15528cbfe775435613fa863..75203037c4e41ddfa4944ca87b11743f50466b0d 100644
--- a/dumux/flux/cctpfa/forchheimerslaw.hh
+++ b/dumux/flux/cctpfa/forchheimerslaw.hh
@@ -46,10 +46,10 @@ class ForchheimersLawImplementation;
  * \brief Forchheimer's law for cell-centered finite volume schemes with two-point flux approximation
  * \note Forchheimer's law is specialized for network and surface grids (i.e. if grid dim < dimWorld)
  * \tparam Scalar the scalar type for scalar physical quantities
- * \tparam FVGridGeometry the grid geometry
+ * \tparam GridGeometry the grid geometry
  * \tparam isNetwork whether we are computing on a network grid embedded in a higher world dimension
  */
-template<class Scalar, class FVGridGeometry, bool isNetwork>
+template<class Scalar, class GridGeometry, bool isNetwork>
 class CCTpfaForchheimersLaw;
 
 /*!
@@ -68,12 +68,12 @@ class ForchheimersLawImplementation<TypeTag, DiscretizationMethod::cctpfa>
  * \ingroup CCTpfaFlux
  * \brief Class that fills the cache corresponding to tpfa Forchheimer's Law
  */
-template<class FVGridGeometry>
+template<class GridGeometry>
 class TpfaForchheimersLawCacheFiller
 {
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
 
 public:
     //! Function to fill a TpfaForchheimersLawCache of a given scvf
@@ -96,18 +96,18 @@ public:
  * \ingroup CCTpfaFlux
  * \brief The cache corresponding to tpfa Forchheimer's Law
  */
-template<class AdvectionType, class FVGridGeometry>
+template<class AdvectionType, class GridGeometry>
 class TpfaForchheimersLawCache
 {
     using Scalar = typename AdvectionType::Scalar;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
-    static constexpr int dimWorld = FVGridGeometry::GridView::dimensionworld;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
+    static constexpr int dimWorld = GridGeometry::GridView::dimensionworld;
     using DimWorldMatrix = Dune::FieldMatrix<Scalar, dimWorld, dimWorld>;
 
 public:
-    using Filler = TpfaForchheimersLawCacheFiller<FVGridGeometry>;
+    using Filler = TpfaForchheimersLawCacheFiller<GridGeometry>;
 
     template<class Problem, class ElementVolumeVariables>
     void updateAdvection(const Problem& problem,
@@ -135,14 +135,14 @@ private:
  * \ingroup CCTpfaFlux
  * \brief Specialization of the CCTpfaForchheimersLaw grids where dim=dimWorld
  */
-template<class ScalarType, class FVGridGeometry>
-class CCTpfaForchheimersLaw<ScalarType, FVGridGeometry, /*isNetwork*/ false>
+template<class ScalarType, class GridGeometry>
+class CCTpfaForchheimersLaw<ScalarType, GridGeometry, /*isNetwork*/ false>
 {
-    using ThisType = CCTpfaForchheimersLaw<ScalarType, FVGridGeometry, /*isNetwork*/ false>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using ThisType = CCTpfaForchheimersLaw<ScalarType, GridGeometry, /*isNetwork*/ false>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
 
     static constexpr int dim = GridView::dimension;
@@ -152,7 +152,7 @@ class CCTpfaForchheimersLaw<ScalarType, FVGridGeometry, /*isNetwork*/ false>
     using DimWorldVector = Dune::FieldVector<ScalarType, dimWorld>;
     using DimWorldMatrix = Dune::FieldMatrix<ScalarType, dimWorld, dimWorld>;
 
-    using DarcysLaw = CCTpfaDarcysLaw<ScalarType, FVGridGeometry, /*isNetwork*/ false>;
+    using DarcysLaw = CCTpfaDarcysLaw<ScalarType, GridGeometry, /*isNetwork*/ false>;
 
   public:
     //! state the scalar type of the law
@@ -162,7 +162,7 @@ class CCTpfaForchheimersLaw<ScalarType, FVGridGeometry, /*isNetwork*/ false>
     static const DiscretizationMethod discMethod = DiscretizationMethod::cctpfa;
 
     //! state the type for the corresponding cache
-    using Cache = TpfaForchheimersLawCache<ThisType, FVGridGeometry>;
+    using Cache = TpfaForchheimersLawCache<ThisType, GridGeometry>;
 
     /*! \brief Compute the advective flux using the Forchheimer equation
     *
@@ -547,8 +547,8 @@ private:
  * \ingroup CCTpfaFlux
  * \brief Specialization of the CCTpfaForchheimersLaw grids where dim<dimWorld
  */
-template<class ScalarType, class FVGridGeometry>
-class CCTpfaForchheimersLaw<ScalarType, FVGridGeometry, /*isNetwork*/ true>
+template<class ScalarType, class GridGeometry>
+class CCTpfaForchheimersLaw<ScalarType, GridGeometry, /*isNetwork*/ true>
 {
     static_assert(AlwaysFalse<ScalarType>::value, "Forchheimer not implemented for network grids");
 };
diff --git a/dumux/flux/effectivestresslaw.hh b/dumux/flux/effectivestresslaw.hh
index 4779166566b2d2db050da617d1f30329cb1bd9b7..4ec9a0b6fbcfe7422f827b967502cf058ffba066 100644
--- a/dumux/flux/effectivestresslaw.hh
+++ b/dumux/flux/effectivestresslaw.hh
@@ -35,7 +35,7 @@ namespace Dumux {
  * \note Specializations are provided for the different discretization methods.
  * These specializations are found in the headers included below.
  */
-template <class StressType, class FVGridGeometry, DiscretizationMethod dm = FVGridGeometry::discMethod>
+template <class StressType, class GridGeometry, DiscretizationMethod dm = GridGeometry::discMethod>
 class EffectiveStressLaw;
 
 } // end namespace Dumux
diff --git a/dumux/flux/hookeslaw.hh b/dumux/flux/hookeslaw.hh
index a7a7e35e5caad12c665cf1240115afc6be4b17fb..a194ea95c0618fef0ff266422fc377a5bc4426e3 100644
--- a/dumux/flux/hookeslaw.hh
+++ b/dumux/flux/hookeslaw.hh
@@ -35,7 +35,7 @@ namespace Dumux {
  * \note Specializations are provided for the different discretization methods.
  * These specializations are found in the headers included below.
  */
-template <class Scalar, class FVGridGeometry, DiscretizationMethod dm = FVGridGeometry::discMethod>
+template <class Scalar, class GridGeometry, DiscretizationMethod dm = GridGeometry::discMethod>
 class HookesLaw;
 
 } // end namespace Dumux
diff --git a/dumux/flux/staggered/freeflow/fickslaw.hh b/dumux/flux/staggered/freeflow/fickslaw.hh
index 2f47965913c8706525b4c036580ea617269ac0a6..68c00c76da1172489919aded18179686c5c861c9 100644
--- a/dumux/flux/staggered/freeflow/fickslaw.hh
+++ b/dumux/flux/staggered/freeflow/fickslaw.hh
@@ -50,10 +50,10 @@ template <class TypeTag, ReferenceSystemFormulation referenceSystem>
 class FicksLawImplementation<TypeTag, DiscretizationMethod::staggered, referenceSystem>
 {
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
     using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
diff --git a/dumux/flux/staggered/freeflow/fourierslaw.hh b/dumux/flux/staggered/freeflow/fourierslaw.hh
index d810450d0107ced9f24c9e33fcd1201d6e68e732..436b411095b1c721c272bf1d84e885fbea773a20 100644
--- a/dumux/flux/staggered/freeflow/fourierslaw.hh
+++ b/dumux/flux/staggered/freeflow/fourierslaw.hh
@@ -44,11 +44,11 @@ template <class TypeTag>
 class FouriersLawImplementation<TypeTag, DiscretizationMethod::staggered>
 {
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
 
 public:
diff --git a/dumux/flux/staggered/freeflow/maxwellstefanslaw.hh b/dumux/flux/staggered/freeflow/maxwellstefanslaw.hh
index 175c5f534505644955b1bdc2953b93b16cfaa3cb..965039346f6d81883a0863f281fd9b9d7d224b8e 100644
--- a/dumux/flux/staggered/freeflow/maxwellstefanslaw.hh
+++ b/dumux/flux/staggered/freeflow/maxwellstefanslaw.hh
@@ -48,10 +48,10 @@ class MaxwellStefansLawImplementation<TypeTag, DiscretizationMethod::staggered,
 {
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
     using VolumeVariables = GetPropType<TypeTag, Properties::VolumeVariables>;
diff --git a/dumux/flux/upwindscheme.hh b/dumux/flux/upwindscheme.hh
index a292d5bc4ec733d9da28d5ea5795b3353e6abad9..fae491c22217e2927c6d9f62ee044e67d199e398 100644
--- a/dumux/flux/upwindscheme.hh
+++ b/dumux/flux/upwindscheme.hh
@@ -30,7 +30,7 @@
 namespace Dumux {
 
 //! Forward declaration of the upwind scheme implementation
-template<class FVGridGeometry, DiscretizationMethod discMethod>
+template<class GridGeometry, DiscretizationMethod discMethod>
 class UpwindSchemeImpl;
 
 /*!
@@ -38,12 +38,12 @@ class UpwindSchemeImpl;
  * \brief The upwind scheme used for the advective fluxes.
  *        This depends on the chosen discretization method.
  */
-template<class FVGridGeometry>
-using UpwindScheme = UpwindSchemeImpl<FVGridGeometry, FVGridGeometry::discMethod>;
+template<class GridGeometry>
+using UpwindScheme = UpwindSchemeImpl<GridGeometry, GridGeometry::discMethod>;
 
 //! Upwind scheme for the box method
-template<class FVGridGeometry>
-class UpwindSchemeImpl<FVGridGeometry, DiscretizationMethod::box>
+template<class GridGeometry>
+class UpwindSchemeImpl<GridGeometry, DiscretizationMethod::box>
 {
 public:
     // applies a simple upwind scheme to the precalculated advective flux
@@ -72,10 +72,10 @@ public:
 };
 
 //! Upwind scheme for the cell-centered tpfa scheme
-template<class FVGridGeometry>
-class UpwindSchemeImpl<FVGridGeometry, DiscretizationMethod::cctpfa>
+template<class GridGeometry>
+class UpwindSchemeImpl<GridGeometry, DiscretizationMethod::cctpfa>
 {
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     static constexpr int dim = GridView::dimension;
     static constexpr int dimWorld = GridView::dimensionworld;
 
@@ -183,9 +183,9 @@ public:
 };
 
 //! Upwind scheme for cell-centered mpfa schemes
-template<class FVGridGeometry>
-class UpwindSchemeImpl<FVGridGeometry, DiscretizationMethod::ccmpfa>
-: public UpwindSchemeImpl<FVGridGeometry, DiscretizationMethod::cctpfa> {};
+template<class GridGeometry>
+class UpwindSchemeImpl<GridGeometry, DiscretizationMethod::ccmpfa>
+: public UpwindSchemeImpl<GridGeometry, DiscretizationMethod::cctpfa> {};
 
 } // end namespace Dumux
 
diff --git a/dumux/freeflow/compositional/staggered/fluxvariables.hh b/dumux/freeflow/compositional/staggered/fluxvariables.hh
index d122c7eca75a35936fa776ae3f1abd93e1b61567..f1b5212a82840f7008f14716ccad3c006699d0f1 100644
--- a/dumux/freeflow/compositional/staggered/fluxvariables.hh
+++ b/dumux/freeflow/compositional/staggered/fluxvariables.hh
@@ -47,9 +47,9 @@ class FreeflowNCFluxVariablesImpl<TypeTag, DiscretizationMethod::staggered>
 {
     using ParentType = NavierStokesFluxVariables<TypeTag>;
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using CellCenterPrimaryVariables = GetPropType<TypeTag, Properties::CellCenterPrimaryVariables>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
diff --git a/dumux/freeflow/compositional/staggered/localresidual.hh b/dumux/freeflow/compositional/staggered/localresidual.hh
index 4821df6825e4833e496dce68b27aedd0697a97cc..d7883e8b3fbf47b62d66293fac3f755ec7889c54 100644
--- a/dumux/freeflow/compositional/staggered/localresidual.hh
+++ b/dumux/freeflow/compositional/staggered/localresidual.hh
@@ -46,8 +46,8 @@ class FreeflowNCResidualImpl<TypeTag, DiscretizationMethod::staggered>
 
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
diff --git a/dumux/freeflow/navierstokes/problem.hh b/dumux/freeflow/navierstokes/problem.hh
index 16da4bc53047a05988a167c91f4d22f5e889ec03..6887765131e22a004046a15ec402edfec1f08dd6 100644
--- a/dumux/freeflow/navierstokes/problem.hh
+++ b/dumux/freeflow/navierstokes/problem.hh
@@ -64,8 +64,8 @@ class NavierStokesProblem : public NavierStokesParentProblem<TypeTag>
     using ParentType = NavierStokesParentProblem<TypeTag>;
     using Implementation = GetPropType<TypeTag, Properties::Problem>;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
 
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
@@ -76,7 +76,7 @@ class NavierStokesProblem : public NavierStokesParentProblem<TypeTag>
     using ElementVolumeVariables = typename GridVolumeVariables::LocalView;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
@@ -93,11 +93,11 @@ class NavierStokesProblem : public NavierStokesParentProblem<TypeTag>
 public:
     /*!
      * \brief The constructor
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param paramGroup The parameter group in which to look for runtime parameters first (default is "")
      */
-    NavierStokesProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, paramGroup)
+    NavierStokesProblem(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup = "")
+    : ParentType(gridGeometry, paramGroup)
     , gravity_(0.0)
     {
         if (getParamFromGroup<bool>(paramGroup, "Problem.EnableGravity"))
@@ -141,13 +141,13 @@ public:
     { return enableInertiaTerms_; }
 
     //! Applys the initial face solution (velocities on the faces). Specialization for staggered grid discretization.
-    template <class SolutionVector, class G = FVGridGeometry>
+    template <class SolutionVector, class G = GridGeometry>
     typename std::enable_if<G::discMethod == DiscretizationMethod::staggered, void>::type
     applyInitialFaceSolution(SolutionVector& sol,
                              const SubControlVolumeFace& scvf,
                              const PrimaryVariables& initSol) const
     {
-        sol[FVGridGeometry::faceIdx()][scvf.dofIndex()][0] = initSol[Indices::velocity(scvf.directionIndex())];
+        sol[GridGeometry::faceIdx()][scvf.dofIndex()][0] = initSol[Indices::velocity(scvf.directionIndex())];
     }
 
 
@@ -174,7 +174,7 @@ public:
     }
 
     //! Convenience function for staggered grid implementation.
-    template <class ElementVolumeVariables, class ElementFaceVariables, class G = FVGridGeometry>
+    template <class ElementVolumeVariables, class ElementFaceVariables, class G = GridGeometry>
     typename std::enable_if<G::discMethod == DiscretizationMethod::staggered, Scalar>::type
     pseudo3DWallFriction(const SubControlVolumeFace& scvf,
                          const ElementVolumeVariables& elemVolVars,
diff --git a/dumux/freeflow/navierstokes/staggered/fluxoversurface.hh b/dumux/freeflow/navierstokes/staggered/fluxoversurface.hh
index 5e3bdcad246f8f86b7ad4f48ae8d43ae0119fa36..30d3e638ec32377a0aeca19b8c48e9b532e8d347 100644
--- a/dumux/freeflow/navierstokes/staggered/fluxoversurface.hh
+++ b/dumux/freeflow/navierstokes/staggered/fluxoversurface.hh
@@ -49,14 +49,14 @@ template<class GridVariables, class SolutionVector, class ModelTraits, class Loc
 class FluxOverSurface
 {
     using Scalar = typename GridVariables::Scalar;
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using VolumeVariables = typename GridVariables::VolumeVariables;
     using Element = typename GridView::template Codim<0>::Entity;
 
-    using CellCenterPrimaryVariables = std::decay_t<decltype(std::declval<SolutionVector>()[FVGridGeometry::cellCenterIdx()][0])>;
+    using CellCenterPrimaryVariables = std::decay_t<decltype(std::declval<SolutionVector>()[GridGeometry::cellCenterIdx()][0])>;
 
     enum {
         // Grid and world dimension
diff --git a/dumux/freeflow/navierstokes/staggered/fluxvariables.hh b/dumux/freeflow/navierstokes/staggered/fluxvariables.hh
index 7a1431ad5b876c40957052f15ecaa7ad3a790cc8..180170856fcffeb49c8e3ffcca55ff7f9052c9f1 100644
--- a/dumux/freeflow/navierstokes/staggered/fluxvariables.hh
+++ b/dumux/freeflow/navierstokes/staggered/fluxvariables.hh
@@ -70,9 +70,9 @@ class NavierStokesFluxVariablesImpl<TypeTag, DiscretizationMethod::staggered>
     using FaceVariables = typename GridFaceVariables::FaceVariables;
 
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
@@ -81,14 +81,14 @@ class NavierStokesFluxVariablesImpl<TypeTag, DiscretizationMethod::staggered>
     using CellCenterPrimaryVariables = GetPropType<TypeTag, Properties::CellCenterPrimaryVariables>;
     using FacePrimaryVariables = GetPropType<TypeTag, Properties::FacePrimaryVariables>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using VelocityGradients = StaggeredVelocityGradients<Scalar, FVGridGeometry, BoundaryTypes, Indices>;
+    using VelocityGradients = StaggeredVelocityGradients<Scalar, GridGeometry, BoundaryTypes, Indices>;
 
     static constexpr bool normalizePressure = getPropValue<TypeTag, Properties::NormalizePressure>();
 
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
-    static constexpr auto cellCenterIdx = FVGridGeometry::cellCenterIdx();
-    static constexpr auto faceIdx = FVGridGeometry::faceIdx();
+    static constexpr auto cellCenterIdx = GridGeometry::cellCenterIdx();
+    static constexpr auto faceIdx = GridGeometry::faceIdx();
 
     static constexpr int upwindSchemeOrder = getPropValue<TypeTag, Properties::UpwindSchemeOrder>();
     static constexpr bool useHigherOrder = upwindSchemeOrder > 1;
diff --git a/dumux/freeflow/navierstokes/staggered/localresidual.hh b/dumux/freeflow/navierstokes/staggered/localresidual.hh
index b80121ce260c8c9e4ce386430edd8a7d85e9cdc1..7a57d81386995844a95586eacb39114f75cab9a3 100644
--- a/dumux/freeflow/navierstokes/staggered/localresidual.hh
+++ b/dumux/freeflow/navierstokes/staggered/localresidual.hh
@@ -62,9 +62,9 @@ class NavierStokesResidualImpl<TypeTag, DiscretizationMethod::staggered>
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using Implementation = GetPropType<TypeTag, Properties::LocalResidual>;
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
@@ -80,7 +80,7 @@ class NavierStokesResidualImpl<TypeTag, DiscretizationMethod::staggered>
     using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
 
 public:
-    using EnergyLocalResidual = FreeFlowEnergyLocalResidual<FVGridGeometry, FluxVariables, ModelTraits::enableEnergyBalance(), (ModelTraits::numFluidComponents() > 1)>;
+    using EnergyLocalResidual = FreeFlowEnergyLocalResidual<GridGeometry, FluxVariables, ModelTraits::enableEnergyBalance(), (ModelTraits::numFluidComponents() > 1)>;
 
     // account for the offset of the cell center privars within the PrimaryVariables container
     static constexpr auto cellCenterOffset = ModelTraits::numEq() - CellCenterPrimaryVariables::dimension;
diff --git a/dumux/freeflow/navierstokes/staggered/staggeredupwindfluxvariables.hh b/dumux/freeflow/navierstokes/staggered/staggeredupwindfluxvariables.hh
index 06580bedeb4a1f6a34475fdaf9754ccecaff98fc..4e31009d9fb4228e55438ab16b8b74f35a7a63ac 100644
--- a/dumux/freeflow/navierstokes/staggered/staggeredupwindfluxvariables.hh
+++ b/dumux/freeflow/navierstokes/staggered/staggeredupwindfluxvariables.hh
@@ -58,9 +58,9 @@ class StaggeredUpwindFluxVariables
     using FaceVariables = typename GridFaceVariables::FaceVariables;
 
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
@@ -70,7 +70,7 @@ class StaggeredUpwindFluxVariables
     using CellCenterPrimaryVariables = GetPropType<TypeTag, Properties::CellCenterPrimaryVariables>;
     using FacePrimaryVariables = GetPropType<TypeTag, Properties::FacePrimaryVariables>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using VelocityGradients = StaggeredVelocityGradients<Scalar, FVGridGeometry, BoundaryTypes, Indices>;
+    using VelocityGradients = StaggeredVelocityGradients<Scalar, GridGeometry, BoundaryTypes, Indices>;
 
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
     static constexpr bool useHigherOrder = upwindSchemeOrder > 1;
diff --git a/dumux/freeflow/navierstokes/staggered/velocitygradients.hh b/dumux/freeflow/navierstokes/staggered/velocitygradients.hh
index 6b81f1e4f5b08379df7e5f4650cbc1a8ab769acf..f9d7a58edce996cda5d763c232cb17706a30c0ad 100644
--- a/dumux/freeflow/navierstokes/staggered/velocitygradients.hh
+++ b/dumux/freeflow/navierstokes/staggered/velocitygradients.hh
@@ -34,11 +34,11 @@ namespace Dumux {
  * \ingroup NavierStokesModel
  * \brief Helper class for calculating the velocity gradients for the Navier-Stokes model using the staggered grid discretization.
  */
-template<class Scalar, class FVGridGeometry, class BoundaryTypes, class Indices>
+template<class Scalar, class GridGeometry, class BoundaryTypes, class Indices>
 class StaggeredVelocityGradients
 {
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using GridView = typename FVGridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
diff --git a/dumux/freeflow/nonisothermal/localresidual.hh b/dumux/freeflow/nonisothermal/localresidual.hh
index abb3676f68294f2d0ed605f5558157065cc08f8c..1a681c5ddd4f61c2b22ae4cd06e2ed8aa45682c5 100644
--- a/dumux/freeflow/nonisothermal/localresidual.hh
+++ b/dumux/freeflow/nonisothermal/localresidual.hh
@@ -30,7 +30,7 @@
 namespace Dumux {
 
 // forward declaration
-template<class FVGridGeometry, class FluxVariables, DiscretizationMethod discMethod, bool enableEneryBalance, bool isCompositional>
+template<class GridGeometry, class FluxVariables, DiscretizationMethod discMethod, bool enableEneryBalance, bool isCompositional>
 class FreeFlowEnergyLocalResidualImplementation;
 
 /*!
@@ -38,19 +38,19 @@ class FreeFlowEnergyLocalResidualImplementation;
  * \brief Element-wise calculation of the local residual for non-isothermal
  *        free-flow models
  */
-template<class FVGridGeometry, class FluxVariables, bool enableEneryBalance, bool isCompositional>
+template<class GridGeometry, class FluxVariables, bool enableEneryBalance, bool isCompositional>
 using FreeFlowEnergyLocalResidual =
-      FreeFlowEnergyLocalResidualImplementation<FVGridGeometry,
+      FreeFlowEnergyLocalResidualImplementation<GridGeometry,
                                                 FluxVariables,
-                                                FVGridGeometry::discMethod,
+                                                GridGeometry::discMethod,
                                                 enableEneryBalance, isCompositional>;
 
 /*!
  * \ingroup FreeflowNIModel
  * \brief Specialization for isothermal models, does nothing
  */
-template<class FVGridGeometry, class FluxVariables, DiscretizationMethod discMethod, bool isCompositional>
-class FreeFlowEnergyLocalResidualImplementation<FVGridGeometry, FluxVariables, discMethod, false, isCompositional>
+template<class GridGeometry, class FluxVariables, DiscretizationMethod discMethod, bool isCompositional>
+class FreeFlowEnergyLocalResidualImplementation<GridGeometry, FluxVariables, discMethod, false, isCompositional>
 {
 public:
 
@@ -69,14 +69,14 @@ public:
  * \ingroup FreeflowNIModel
  * \brief Specialization for staggered one-phase, non-isothermal models
  */
-template<class FVGridGeometry, class FluxVariables>
-class FreeFlowEnergyLocalResidualImplementation<FVGridGeometry,
+template<class GridGeometry, class FluxVariables>
+class FreeFlowEnergyLocalResidualImplementation<GridGeometry,
                                                 FluxVariables,
                                                 DiscretizationMethod::staggered,
                                                 true, false>
 {
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
 
 public:
@@ -121,22 +121,22 @@ public:
  * \ingroup FreeflowNIModel
  * \brief Specialization for staggered compositional, non-isothermal models
  */
-template<class FVGridGeometry, class FluxVariables>
-class FreeFlowEnergyLocalResidualImplementation<FVGridGeometry,
+template<class GridGeometry, class FluxVariables>
+class FreeFlowEnergyLocalResidualImplementation<GridGeometry,
                                                 FluxVariables,
                                                 DiscretizationMethod::staggered,
                                                 true, true>
-    : public FreeFlowEnergyLocalResidualImplementation<FVGridGeometry,
+    : public FreeFlowEnergyLocalResidualImplementation<GridGeometry,
                                                        FluxVariables,
                                                        DiscretizationMethod::staggered,
                                                        true, false>
 {
-    using ParentType = FreeFlowEnergyLocalResidualImplementation<FVGridGeometry,
+    using ParentType = FreeFlowEnergyLocalResidualImplementation<GridGeometry,
                                                                  FluxVariables,
                                                                  DiscretizationMethod::staggered,
                                                                  true, false>;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
 
 public:
diff --git a/dumux/freeflow/rans/oneeq/problem.hh b/dumux/freeflow/rans/oneeq/problem.hh
index fb549c7d9be1e0d97187ffa0bba7a77dde3cc313..3b7d889cc81683215aa83ba064f5e7061af799bf 100644
--- a/dumux/freeflow/rans/oneeq/problem.hh
+++ b/dumux/freeflow/rans/oneeq/problem.hh
@@ -54,7 +54,7 @@ class RANSProblemImpl<TypeTag, TurbulenceModel::oneeq> : public RANSProblemBase<
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using DimVector = Dune::FieldVector<Scalar, Grid::dimension>;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
 
@@ -66,8 +66,8 @@ class RANSProblemImpl<TypeTag, TurbulenceModel::oneeq> : public RANSProblemBase<
 
 public:
     //! The constructor sets the gravity, if desired by the user.
-    RANSProblemImpl(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, paramGroup)
+    RANSProblemImpl(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup = "")
+    : ParentType(gridGeometry, paramGroup)
     {
         useStoredEddyViscosity_ = getParamFromGroup<bool>(this->paramGroup(),
                                                           "RANS.UseStoredEddyViscosity", false);
@@ -104,9 +104,9 @@ public:
             for (auto&& scv : scvs(fvGeometry))
             {
                 const int dofIdx = scv.dofIndex();
-                const auto& cellCenterPriVars = curSol[FVGridGeometry::cellCenterIdx()][dofIdx];
+                const auto& cellCenterPriVars = curSol[GridGeometry::cellCenterIdx()][dofIdx];
                 PrimaryVariables priVars = makePriVarsFromCellCenterPriVars<PrimaryVariables>(cellCenterPriVars);
-                auto elemSol = elementSolution<typename FVGridGeometry::LocalView>(std::move(priVars));
+                auto elemSol = elementSolution<typename GridGeometry::LocalView>(std::move(priVars));
                 // NOTE: first update the turbulence quantities
                 storedViscosityTilde_[elementIdx] = elemSol[0][Indices::viscosityTildeIdx];
                 // NOTE: then update the volVars
diff --git a/dumux/freeflow/rans/problem.hh b/dumux/freeflow/rans/problem.hh
index 1eec0b80239993c55da8bb56e83653b6bdc5d715..1ba65564b5120a320762df9318dbe988e7ee821d 100644
--- a/dumux/freeflow/rans/problem.hh
+++ b/dumux/freeflow/rans/problem.hh
@@ -60,9 +60,9 @@ class RANSProblemBase : public NavierStokesProblem<TypeTag>
 
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
@@ -82,11 +82,11 @@ class RANSProblemBase : public NavierStokesProblem<TypeTag>
 public:
     /*!
      * \brief The constructor
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param paramGroup The parameter group in which to look for runtime parameters first (default is "")
      */
-    RANSProblemBase(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, paramGroup)
+    RANSProblemBase(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup = "")
+    : ParentType(gridGeometry, paramGroup)
     { }
 
     /*!
@@ -251,7 +251,7 @@ public:
             for (auto&& scvf : scvfs(fvGeometry))
             {
                 const int dofIdxFace = scvf.dofIndex();
-                const auto numericalSolutionFace = curSol[FVGridGeometry::faceIdx()][dofIdxFace][Indices::velocity(scvf.directionIndex())];
+                const auto numericalSolutionFace = curSol[GridGeometry::faceIdx()][dofIdxFace][Indices::velocity(scvf.directionIndex())];
                 velocityTemp[scvf.directionIndex()] += numericalSolutionFace;
             }
             for (unsigned int dimIdx = 0; dimIdx < dim; ++dimIdx)
@@ -416,9 +416,9 @@ public:
                 const int dofIdx = scv.dofIndex();
 
                 // construct a privars object from the cell center solution vector
-                const auto& cellCenterPriVars = curSol[FVGridGeometry::cellCenterIdx()][dofIdx];
+                const auto& cellCenterPriVars = curSol[GridGeometry::cellCenterIdx()][dofIdx];
                 PrimaryVariables priVars = makePriVarsFromCellCenterPriVars<PrimaryVariables>(cellCenterPriVars);
-                auto elemSol = elementSolution<typename FVGridGeometry::LocalView>(std::move(priVars));
+                auto elemSol = elementSolution<typename GridGeometry::LocalView>(std::move(priVars));
 
                 VolumeVariables volVars;
                 volVars.update(elemSol, asImp_(), element, scv);
diff --git a/dumux/freeflow/rans/twoeq/kepsilon/problem.hh b/dumux/freeflow/rans/twoeq/kepsilon/problem.hh
index e56c56fb2a356372305e0c1a7bbe8e3c7193307c..40fccef2c342e9cb86dcafcc7a52988e224a0dcd 100644
--- a/dumux/freeflow/rans/twoeq/kepsilon/problem.hh
+++ b/dumux/freeflow/rans/twoeq/kepsilon/problem.hh
@@ -51,8 +51,8 @@ class RANSProblemImpl<TypeTag, TurbulenceModel::kepsilon> : public RANSProblemBa
     using Implementation = GetPropType<TypeTag, Properties::Problem>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
 
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
@@ -83,8 +83,8 @@ class RANSProblemImpl<TypeTag, TurbulenceModel::kepsilon> : public RANSProblemBa
 public:
 
     //! The constructor sets the gravity, if desired by the user.
-    RANSProblemImpl(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, paramGroup)
+    RANSProblemImpl(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup = "")
+    : ParentType(gridGeometry, paramGroup)
     {
         yPlusThreshold_ = getParamFromGroup<Scalar>(this->paramGroup(), "KEpsilon.YPlusThreshold", 30);
         useStoredEddyViscosity_ = getParamFromGroup<bool>(this->paramGroup(), "RANS.UseStoredEddyViscosity", false);
@@ -125,9 +125,9 @@ public:
             for (auto&& scv : scvs(fvGeometry))
             {
                 const int dofIdx = scv.dofIndex();
-                const auto& cellCenterPriVars = curSol[FVGridGeometry::cellCenterIdx()][dofIdx];
+                const auto& cellCenterPriVars = curSol[GridGeometry::cellCenterIdx()][dofIdx];
                 PrimaryVariables priVars = makePriVarsFromCellCenterPriVars<PrimaryVariables>(cellCenterPriVars);
-                auto elemSol = elementSolution<typename FVGridGeometry::LocalView>(std::move(priVars));
+                auto elemSol = elementSolution<typename GridGeometry::LocalView>(std::move(priVars));
                 // NOTE: first update the turbulence quantities
                 storedDissipation_[elementIdx] = elemSol[0][Indices::dissipationEqIdx];
                 storedTurbulentKineticEnergy_[elementIdx] = elemSol[0][Indices::turbulentKineticEnergyEqIdx];
diff --git a/dumux/freeflow/rans/twoeq/komega/problem.hh b/dumux/freeflow/rans/twoeq/komega/problem.hh
index 98b08b3b6fd896a50d5d7ff9202900bbcd9570d4..808d86be2992ca295fcbfd56421661cb2977a9ea 100644
--- a/dumux/freeflow/rans/twoeq/komega/problem.hh
+++ b/dumux/freeflow/rans/twoeq/komega/problem.hh
@@ -49,7 +49,7 @@ class RANSProblemImpl<TypeTag, TurbulenceModel::komega> : public RANSProblemBase
     using Implementation = GetPropType<TypeTag, Properties::Problem>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
 
     using VolumeVariables = GetPropType<TypeTag, Properties::VolumeVariables>;
@@ -58,12 +58,12 @@ class RANSProblemImpl<TypeTag, TurbulenceModel::komega> : public RANSProblemBase
     using CellCenterPrimaryVariables = GetPropType<TypeTag, Properties::CellCenterPrimaryVariables>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
 
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using DimVector = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    RANSProblemImpl(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, paramGroup)
+    RANSProblemImpl(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup = "")
+    : ParentType(gridGeometry, paramGroup)
     {
         useStoredEddyViscosity_ = getParamFromGroup<bool>(this->paramGroup(), "RANS.UseStoredEddyViscosity", false);
     }
@@ -101,9 +101,9 @@ public:
             for (auto&& scv : scvs(fvGeometry))
             {
                 const int dofIdx = scv.dofIndex();
-                const auto& cellCenterPriVars = curSol[FVGridGeometry::cellCenterIdx()][dofIdx];
+                const auto& cellCenterPriVars = curSol[GridGeometry::cellCenterIdx()][dofIdx];
                 PrimaryVariables priVars = makePriVarsFromCellCenterPriVars<PrimaryVariables>(cellCenterPriVars);
-                auto elemSol = elementSolution<typename FVGridGeometry::LocalView>(std::move(priVars));
+                auto elemSol = elementSolution<typename GridGeometry::LocalView>(std::move(priVars));
                 // NOTE: first update the turbulence quantities
                 storedDissipation_[elementIdx] = elemSol[0][Indices::dissipationEqIdx];
                 storedTurbulentKineticEnergy_[elementIdx] = elemSol[0][Indices::turbulentKineticEnergyEqIdx];
diff --git a/dumux/freeflow/rans/twoeq/lowrekepsilon/problem.hh b/dumux/freeflow/rans/twoeq/lowrekepsilon/problem.hh
index ac72248784e3e1cfa2eb7a1a1fbd96d99529a0c6..0119d0792aad9038bc5eed0018699f05b959d3a0 100644
--- a/dumux/freeflow/rans/twoeq/lowrekepsilon/problem.hh
+++ b/dumux/freeflow/rans/twoeq/lowrekepsilon/problem.hh
@@ -49,7 +49,7 @@ class RANSProblemImpl<TypeTag, TurbulenceModel::lowrekepsilon> : public RANSProb
     using Implementation = GetPropType<TypeTag, Properties::Problem>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
 
     using VolumeVariables = GetPropType<TypeTag, Properties::VolumeVariables>;
@@ -60,8 +60,8 @@ class RANSProblemImpl<TypeTag, TurbulenceModel::lowrekepsilon> : public RANSProb
 
 public:
     //! The constructor sets the gravity, if desired by the user.
-    RANSProblemImpl(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, paramGroup)
+    RANSProblemImpl(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup = "")
+    : ParentType(gridGeometry, paramGroup)
     {
         useStoredEddyViscosity_ = getParamFromGroup<bool>(this->paramGroup(), "RANS.UseStoredEddyViscosity", true);
     }
@@ -97,9 +97,9 @@ public:
             for (auto&& scv : scvs(fvGeometry))
             {
                 const int dofIdx = scv.dofIndex();
-                const auto& cellCenterPriVars = curSol[FVGridGeometry::cellCenterIdx()][dofIdx];
+                const auto& cellCenterPriVars = curSol[GridGeometry::cellCenterIdx()][dofIdx];
                 PrimaryVariables priVars = makePriVarsFromCellCenterPriVars<PrimaryVariables>(cellCenterPriVars);
-                auto elemSol = elementSolution<typename FVGridGeometry::LocalView>(std::move(priVars));
+                auto elemSol = elementSolution<typename GridGeometry::LocalView>(std::move(priVars));
                 // NOTE: first update the turbulence quantities
                 storedDissipationTilde_[elementIdx] = elemSol[0][Indices::dissipationEqIdx];
                 storedTurbulentKineticEnergy_[elementIdx] = elemSol[0][Indices::turbulentKineticEnergyEqIdx];
diff --git a/dumux/freeflow/rans/zeroeq/problem.hh b/dumux/freeflow/rans/zeroeq/problem.hh
index dc2a5d0b55dfa3a5b085e3a16ea267396f672acb..0a439a5828245f7ed99cafb36d85a1f90cd0d325 100644
--- a/dumux/freeflow/rans/zeroeq/problem.hh
+++ b/dumux/freeflow/rans/zeroeq/problem.hh
@@ -54,7 +54,7 @@ class RANSProblemImpl<TypeTag, TurbulenceModel::zeroeq> : public RANSProblemBase
     using Grid = typename GridView::Grid;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using VolumeVariables = GetPropType<TypeTag, Properties::VolumeVariables>;
@@ -72,11 +72,11 @@ class RANSProblemImpl<TypeTag, TurbulenceModel::zeroeq> : public RANSProblemBase
 public:
     /*!
      * \brief The constructor
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param paramGroup The parameter group in which to look for runtime parameters first (default is "")
      */
-    RANSProblemImpl(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, paramGroup)
+    RANSProblemImpl(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup = "")
+    : ParentType(gridGeometry, paramGroup)
     {
         eddyViscosityModel_ = getParamFromGroup<std::string>(paramGroup, "RANS.EddyViscosityModel", "vanDriest");
     }
@@ -120,9 +120,9 @@ public:
                 const int dofIdx = scv.dofIndex();
 
                 // construct a privars object from the cell center solution vector
-                const auto& cellCenterPriVars = curSol[FVGridGeometry::cellCenterIdx()][dofIdx];
+                const auto& cellCenterPriVars = curSol[GridGeometry::cellCenterIdx()][dofIdx];
                 PrimaryVariables priVars = makePriVarsFromCellCenterPriVars<PrimaryVariables>(cellCenterPriVars);
-                auto elemSol = elementSolution<typename FVGridGeometry::LocalView>(std::move(priVars));
+                auto elemSol = elementSolution<typename GridGeometry::LocalView>(std::move(priVars));
 
                 VolumeVariables volVars;
                 volVars.update(elemSol, asImp_(), element, scv);
diff --git a/dumux/freeflow/shallowwater/fluxvariables.hh b/dumux/freeflow/shallowwater/fluxvariables.hh
index d37861c6f02fa33cdfcc5d02c84ef12030bdf6cc..57daf7e066ace07e733ed4a1838519d24ca66842 100644
--- a/dumux/freeflow/shallowwater/fluxvariables.hh
+++ b/dumux/freeflow/shallowwater/fluxvariables.hh
@@ -49,9 +49,9 @@ class ShallowWaterFluxVariables
 
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
     using GridVolumeVariables = typename GridVariables::GridVolumeVariables;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
 
     using Element = typename GridView::template Codim<0>::Entity;
     using ElementVolumeVariables = typename GridVolumeVariables::LocalView;
diff --git a/dumux/freeflow/shallowwater/problem.hh b/dumux/freeflow/shallowwater/problem.hh
index d05e4bf4f04e7931f16d1c09fd7af71f379a3e05..f10bb09849e2e5b3647cda822531f1f2d03958d8 100644
--- a/dumux/freeflow/shallowwater/problem.hh
+++ b/dumux/freeflow/shallowwater/problem.hh
@@ -38,7 +38,7 @@ template<class TypeTag>
 class ShallowWaterProblem : public FVProblem<TypeTag>
 {
     using ParentType = FVProblem<TypeTag>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
 public:
     using SpatialParams = GetPropType<TypeTag, Properties::SpatialParams>;
@@ -46,27 +46,27 @@ public:
     /*!
      * \brief Constructor, passing the spatial parameters
      *
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param spatialParams The spatial parameter class
      * \param paramGroup The parameter group in which to look for runtime parameters first (default is "")
      */
-    ShallowWaterProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    ShallowWaterProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                         std::shared_ptr<SpatialParams> spatialParams,
                         const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, paramGroup)
+    : ParentType(gridGeometry, paramGroup)
     , spatialParams_(spatialParams)
     {}
 
     /*!
      * \brief Constructor, constructing the spatial parameters
      *
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param paramGroup The parameter group in which to look for runtime parameters first (default is "")
      */
-    ShallowWaterProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    ShallowWaterProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                         const std::string& paramGroup = "")
-    : ShallowWaterProblem(fvGridGeometry,
-                          std::make_shared<SpatialParams>(fvGridGeometry),
+    : ShallowWaterProblem(gridGeometry,
+                          std::make_shared<SpatialParams>(gridGeometry),
                           paramGroup)
     {}
 
diff --git a/dumux/geomechanics/fvproblem.hh b/dumux/geomechanics/fvproblem.hh
index daa8b2292367aea064a123f99aceed7e0b1b3b31..6329fa7db982b79c9f6bc1a95f6d6328d07ff571 100644
--- a/dumux/geomechanics/fvproblem.hh
+++ b/dumux/geomechanics/fvproblem.hh
@@ -69,9 +69,9 @@ class GeomechanicsFVProblem : public PorousMediumFlowProblem<TypeTag>
     using ParentType = PorousMediumFlowProblem<TypeTag>;
 
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
diff --git a/dumux/geomechanics/poroelastic/couplingmanager.hh b/dumux/geomechanics/poroelastic/couplingmanager.hh
index 7f981653e09a58382a84409752110194f33c5599..a25a897edfda07d3e6a7a968a64c9e61fe9ce8b7 100644
--- a/dumux/geomechanics/poroelastic/couplingmanager.hh
+++ b/dumux/geomechanics/poroelastic/couplingmanager.hh
@@ -67,9 +67,9 @@ class PoroMechanicsCouplingManager : public virtual CouplingManager< MDTraits >
     template<std::size_t id> using GridVolumeVariables = typename GridVariables<id>::GridVolumeVariables;
     template<std::size_t id> using ElementVolumeVariables = typename GridVolumeVariables<id>::LocalView;
     template<std::size_t id> using VolumeVariables = typename GridVolumeVariables<id>::VolumeVariables;
-    template<std::size_t id> using FVGridGeometry = typename GridVariables<id>::GridGeometry;
-    template<std::size_t id> using FVElementGeometry = typename FVGridGeometry<id>::LocalView;
-    template<std::size_t id> using GridView = typename FVGridGeometry<id>::GridView;
+    template<std::size_t id> using GridGeometry = typename GridVariables<id>::GridGeometry;
+    template<std::size_t id> using FVElementGeometry = typename GridGeometry<id>::LocalView;
+    template<std::size_t id> using GridView = typename GridGeometry<id>::GridView;
     template<std::size_t id> using GridIndexType = typename GridView<id>::IndexSet::IndexType;
     template<std::size_t id> using Element = typename GridView<id>::template Codim<0>::Entity;
     template<std::size_t id> using GlobalPosition = typename Element<id>::Geometry::GlobalCoordinate;
@@ -79,11 +79,11 @@ class PoroMechanicsCouplingManager : public virtual CouplingManager< MDTraits >
                   "The grid types of the two sub-problems have to be equal!");
 
     //! this coupling manager is for cc - box only
-    static_assert(FVGridGeometry<PoroMechId>::discMethod == DiscretizationMethod::box,
+    static_assert(GridGeometry<PoroMechId>::discMethod == DiscretizationMethod::box,
                   "Poro-mechanical problem must be discretized with the box scheme for this coupling manager!");
 
-    static_assert(FVGridGeometry<PMFlowId>::discMethod == DiscretizationMethod::cctpfa ||
-                  FVGridGeometry<PMFlowId>::discMethod == DiscretizationMethod::ccmpfa,
+    static_assert(GridGeometry<PMFlowId>::discMethod == DiscretizationMethod::cctpfa ||
+                  GridGeometry<PMFlowId>::discMethod == DiscretizationMethod::ccmpfa,
                   "Porous medium flow problem must be discretized with a cell-centered scheme for this coupling manager!");
 
     //! this does not work for enabled grid volume variables caching (update of local view in context has no effect)
diff --git a/dumux/geomechanics/poroelastic/model.hh b/dumux/geomechanics/poroelastic/model.hh
index ef4c337e511d2f6ddd7d380e77756b71e064e978..5bd888dacb56582a73b863af1710abca037ed8bc 100644
--- a/dumux/geomechanics/poroelastic/model.hh
+++ b/dumux/geomechanics/poroelastic/model.hh
@@ -115,10 +115,10 @@ struct StressType<TypeTag, TTag::PoroElastic>
 {
 private:
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using ElasticStressType = HookesLaw< Scalar, FVGridGeometry >;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using ElasticStressType = HookesLaw< Scalar, GridGeometry >;
 public:
-    using type = EffectiveStressLaw< ElasticStressType, FVGridGeometry >;
+    using type = EffectiveStressLaw< ElasticStressType, GridGeometry >;
 };
 
 } // namespace Properties
diff --git a/dumux/geomechanics/stressvariablescache.hh b/dumux/geomechanics/stressvariablescache.hh
index e1c79f34cbbc18260d38ad82b0288e6d11652714..f32d48abe6617133228938194e5a24cc1bd52a58 100644
--- a/dumux/geomechanics/stressvariablescache.hh
+++ b/dumux/geomechanics/stressvariablescache.hh
@@ -37,18 +37,18 @@ namespace Dumux {
  * \brief The stress variables cache classes for models involving geomechanics.
  *        Store data required for stress calculation.
  */
-template< class Scalar, class FVGridGeometry, DiscretizationMethod dm = FVGridGeometry::discMethod >
+template< class Scalar, class GridGeometry, DiscretizationMethod dm = GridGeometry::discMethod >
 class StressVariablesCache;
 
 //! We only store discretization-related quantities for the box method.
-template< class Scalar, class FVGridGeometry >
-class StressVariablesCache<Scalar, FVGridGeometry, DiscretizationMethod::box>
-: public BoxFluxVariablesCache< Scalar, FVGridGeometry >
+template< class Scalar, class GridGeometry >
+class StressVariablesCache<Scalar, GridGeometry, DiscretizationMethod::box>
+: public BoxFluxVariablesCache< Scalar, GridGeometry >
 {};
 
 // specialization for the cell centered tpfa method
-template< class Scalar, class FVGridGeometry >
-class StressVariablesCache<Scalar, FVGridGeometry, DiscretizationMethod::cctpfa>
+template< class Scalar, class GridGeometry >
+class StressVariablesCache<Scalar, GridGeometry, DiscretizationMethod::cctpfa>
 : public FluxVariablesCaching::_EmptyCache
 {
 public:
@@ -75,9 +75,9 @@ public:
 };
 
 // specialization for the cell centered mpfa method
-template< class Scalar, class FVGridGeometry >
-class StressVariablesCache<Scalar, FVGridGeometry, DiscretizationMethod::ccmpfa>
-: public StressVariablesCache<Scalar, FVGridGeometry, DiscretizationMethod::cctpfa>
+template< class Scalar, class GridGeometry >
+class StressVariablesCache<Scalar, GridGeometry, DiscretizationMethod::ccmpfa>
+: public StressVariablesCache<Scalar, GridGeometry, DiscretizationMethod::cctpfa>
 {};
 
 } // end namespace Dumux
diff --git a/dumux/io/loadsolution.hh b/dumux/io/loadsolution.hh
index 26533678336073cdb3300d2528e229243688ab13..224254c1cb6731b203779140913080b9a76bfc79 100644
--- a/dumux/io/loadsolution.hh
+++ b/dumux/io/loadsolution.hh
@@ -98,18 +98,18 @@ private:
  * \ingroup InputOutput
  * \brief read from a vtk file into a solution vector with primary variables without state
  */
-template <class SolutionVector, class PvNameFunc, class FVGridGeometry>
+template <class SolutionVector, class PvNameFunc, class GridGeometry>
 auto loadSolutionFromVtkFile(SolutionVector& sol,
                              const std::string fileName,
                              PvNameFunc&& pvNameFunc,
-                             const FVGridGeometry& fvGridGeometry,
+                             const GridGeometry& gridGeometry,
                              const VTKReader::DataType& dataType)
 -> typename std::enable_if_t<!decltype(isValid(Detail::hasState())(sol[0]))::value, void>
 {
     VTKReader vtu(fileName);
     using PrimaryVariables = typename SolutionVector::block_type;
     using Scalar = typename PrimaryVariables::field_type;
-    constexpr auto dim = FVGridGeometry::GridView::dimension;
+    constexpr auto dim = GridGeometry::GridView::dimension;
 
     for (size_t pvIdx = 0; pvIdx < PrimaryVariables::dimension; ++pvIdx)
     {
@@ -119,14 +119,14 @@ auto loadSolutionFromVtkFile(SolutionVector& sol,
         if (dataType == VTKReader::DataType::cellData)
         {
             std::size_t i = 0;
-            for (const auto& element : elements(fvGridGeometry.gridView(), Dune::Partitions::interior))
+            for (const auto& element : elements(gridGeometry.gridView(), Dune::Partitions::interior))
             {
-                const auto eIdx = fvGridGeometry.elementMapper().index(element);
+                const auto eIdx = gridGeometry.elementMapper().index(element);
                 sol[eIdx][pvIdx] = vec[i++];
             }
         }
         // for staggered face data (which is written out as VTK point data) we just read in the vector
-        else if (dataType == VTKReader::DataType::pointData && FVGridGeometry::discMethod == DiscretizationMethod::staggered)
+        else if (dataType == VTKReader::DataType::pointData && GridGeometry::discMethod == DiscretizationMethod::staggered)
         {
             if (sol.size() != vec.size())
                 DUNE_THROW(Dune::InvalidStateException, "Solution size (" << sol.size() << ") does not match input size (" << vec.size() << ")!");
@@ -137,12 +137,12 @@ auto loadSolutionFromVtkFile(SolutionVector& sol,
         else
         {
             std::size_t i = 0;
-            std::vector<bool> visited(fvGridGeometry.gridView().size(dim), false);
-            for (const auto& element : elements(fvGridGeometry.gridView(), Dune::Partitions::interior))
+            std::vector<bool> visited(gridGeometry.gridView().size(dim), false);
+            for (const auto& element : elements(gridGeometry.gridView(), Dune::Partitions::interior))
             {
                 for (int vIdxLocal = 0; vIdxLocal < element.subEntities(dim); ++vIdxLocal)
                 {
-                    const auto vIdxGlobal = fvGridGeometry.vertexMapper().subIndex(element, vIdxLocal, dim);
+                    const auto vIdxGlobal = gridGeometry.vertexMapper().subIndex(element, vIdxLocal, dim);
                     if (!visited[vIdxGlobal])
                     {
                         sol[vIdxGlobal][pvIdx] = vec[i++];
@@ -158,11 +158,11 @@ auto loadSolutionFromVtkFile(SolutionVector& sol,
  * \ingroup InputOutput
  * \brief read from a sequential file into a solution vector with primary variables with state
  */
-template <class SolutionVector, class PvNameFunc, class FVGridGeometry>
+template <class SolutionVector, class PvNameFunc, class GridGeometry>
 auto loadSolutionFromVtkFile(SolutionVector& sol,
                              const std::string fileName,
                              PvNameFunc&& pvNameFunc,
-                             const FVGridGeometry& fvGridGeometry,
+                             const GridGeometry& gridGeometry,
                              const VTKReader::DataType& dataType)
 -> typename std::enable_if_t<decltype(isValid(Detail::hasState())(sol[0]))::value, void>
 {
@@ -187,9 +187,9 @@ auto loadSolutionFromVtkFile(SolutionVector& sol,
         if (dataType == VTKReader::DataType::cellData)
         {
             std::size_t i = 0;
-            for (const auto& element : elements(fvGridGeometry.gridView(), Dune::Partitions::interior))
+            for (const auto& element : elements(gridGeometry.gridView(), Dune::Partitions::interior))
             {
-                const auto eIdx = fvGridGeometry.elementMapper().index(element);
+                const auto eIdx = gridGeometry.elementMapper().index(element);
                 const auto state = stateAtDof[i];
                 sol[eIdx][pvIdx] = data[state][i++];
                 sol[eIdx].setState(state);
@@ -198,13 +198,13 @@ auto loadSolutionFromVtkFile(SolutionVector& sol,
         else
         {
             std::size_t i = 0;
-            constexpr int dim = FVGridGeometry::GridView::dimension;
-            std::vector<bool> visited(fvGridGeometry.gridView().size(dim), false);
-            for (const auto& element : elements(fvGridGeometry.gridView(), Dune::Partitions::interior))
+            constexpr int dim = GridGeometry::GridView::dimension;
+            std::vector<bool> visited(gridGeometry.gridView().size(dim), false);
+            for (const auto& element : elements(gridGeometry.gridView(), Dune::Partitions::interior))
             {
                 for (int vIdxLocal = 0; vIdxLocal < element.subEntities(dim); ++vIdxLocal)
                 {
-                    const auto vIdxGlobal = fvGridGeometry.vertexMapper().subIndex(element, vIdxLocal, dim);
+                    const auto vIdxGlobal = gridGeometry.vertexMapper().subIndex(element, vIdxLocal, dim);
                     if (!visited[vIdxGlobal])
                     {
                         const auto state = stateAtDof[i];
@@ -272,52 +272,52 @@ auto createPVNameFunction(const std::string& paramGroup = "")
  * \param fileName the file name of the file to read from
  * \param pvNameFunc a function with the signature std::string(int pvIdx)
  *        in case the primary variables have a state the signature is std::string(int pvIdx, int state)
- * \param fvGridGeometry the grid geometry of the discretization method used
+ * \param gridGeometry the grid geometry of the discretization method used
  */
-template <class SolutionVector, class PvNameFunc, class FVGridGeometry>
+template <class SolutionVector, class PvNameFunc, class GridGeometry>
 void loadSolution(SolutionVector& sol,
                   const std::string& fileName,
                   PvNameFunc&& pvNameFunc,
-                  const FVGridGeometry& fvGridGeometry)
+                  const GridGeometry& gridGeometry)
 {
     const auto extension = fileName.substr(fileName.find_last_of(".") + 1);
-    auto dataType = FVGridGeometry::discMethod == DiscretizationMethod::box ?
+    auto dataType = GridGeometry::discMethod == DiscretizationMethod::box ?
                     VTKReader::DataType::pointData : VTKReader::DataType::cellData;
 
     if (extension == "vtu" || extension == "vtp")
     {
-        if (FVGridGeometry::discMethod == DiscretizationMethod::staggered && extension == "vtp")
+        if (GridGeometry::discMethod == DiscretizationMethod::staggered && extension == "vtp")
             dataType = VTKReader::DataType::pointData;
 
-        loadSolutionFromVtkFile(sol, fileName, pvNameFunc, fvGridGeometry, dataType);
+        loadSolutionFromVtkFile(sol, fileName, pvNameFunc, gridGeometry, dataType);
     }
     else if (extension == "pvtu" || extension == "pvtp")
     {
-        if (FVGridGeometry::discMethod == DiscretizationMethod::staggered)
+        if (GridGeometry::discMethod == DiscretizationMethod::staggered)
             DUNE_THROW(Dune::NotImplemented, "reading staggered solution from a parallel vtk file");
 
-        loadSolutionFromVtkFile(sol, fileName, pvNameFunc, fvGridGeometry, dataType);
+        loadSolutionFromVtkFile(sol, fileName, pvNameFunc, gridGeometry, dataType);
     }
     else
         DUNE_THROW(Dune::NotImplemented, "loadSolution for file with extension " << extension);
 
     // communicate solution on ghost and overlap dofs
-    if (fvGridGeometry.gridView().comm().size() > 1)
+    if (gridGeometry.gridView().comm().size() > 1)
     {
-        using GridView = typename FVGridGeometry::GridView;
+        using GridView = typename GridGeometry::GridView;
         if (dataType == VTKReader::DataType::cellData)
         {
-            LoadSolutionDataHandle<SolutionVector, typename FVGridGeometry::ElementMapper, 0>
-                dataHandle(sol, fvGridGeometry.elementMapper());
-            fvGridGeometry.gridView().communicate(dataHandle,
+            LoadSolutionDataHandle<SolutionVector, typename GridGeometry::ElementMapper, 0>
+                dataHandle(sol, gridGeometry.elementMapper());
+            gridGeometry.gridView().communicate(dataHandle,
                                                   Dune::InteriorBorder_All_Interface,
                                                   Dune::ForwardCommunication);
         }
         else
         {
-            LoadSolutionDataHandle<SolutionVector, typename FVGridGeometry::VertexMapper, GridView::dimension>
-                dataHandle(sol, fvGridGeometry.vertexMapper());
-            fvGridGeometry.gridView().communicate(dataHandle,
+            LoadSolutionDataHandle<SolutionVector, typename GridGeometry::VertexMapper, GridView::dimension>
+                dataHandle(sol, gridGeometry.vertexMapper());
+            gridGeometry.gridView().communicate(dataHandle,
                                                   Dune::InteriorBorder_All_Interface,
                                                   Dune::ForwardCommunication);
         }
diff --git a/dumux/io/staggeredvtkoutputmodule.hh b/dumux/io/staggeredvtkoutputmodule.hh
index 020dcfaf4c3585abbe07e147891549428bf72190..54a3d54be0766c6f843465f1c5940030243c22f1 100644
--- a/dumux/io/staggeredvtkoutputmodule.hh
+++ b/dumux/io/staggeredvtkoutputmodule.hh
@@ -49,11 +49,11 @@ class StaggeredVtkOutputModule
 : public VtkOutputModule<GridVariables, SolutionVector>
 {
     using ParentType = VtkOutputModule<GridVariables, SolutionVector>;
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using GridView = typename GridGeometry::GridView;
     using Scalar = typename GridVariables::Scalar;
     using FaceVariables = typename GridVariables::GridFaceVariables::FaceVariables;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
 
     using Element = typename GridView::template Codim<0>::Entity;
@@ -111,7 +111,7 @@ public:
     //! \param name The name of the vtk field
     void addFaceField(const std::vector<Scalar>& v, const std::string& name)
     {
-        if (v.size() == this->fvGridGeometry().gridView().size(1))
+        if (v.size() == this->gridGeometry().gridView().size(1))
             faceFieldScalarDataInfo_.emplace_back(v, name);
         else
             DUNE_THROW(Dune::RangeError, "Size mismatch of added field!");
@@ -122,7 +122,7 @@ public:
     //! \param name The name of the vtk field
     void addFaceField(const std::vector<GlobalPosition>& v, const std::string& name)
     {
-        if (v.size() == this->fvGridGeometry().gridView().size(1))
+        if (v.size() == this->gridGeometry().gridView().size(1))
             faceFieldVectorDataInfo_.emplace_back(v, name);
         else
             DUNE_THROW(Dune::RangeError, "Size mismatch of added field!");
@@ -160,10 +160,10 @@ private:
     //! Update the coordinates (the face centers)
     void updateCoordinates_()
     {
-        coordinates_.resize(this->fvGridGeometry().numFaceDofs());
-        for(auto&& facet : facets(this->fvGridGeometry().gridView()))
+        coordinates_.resize(this->gridGeometry().numFaceDofs());
+        for(auto&& facet : facets(this->gridGeometry().gridView()))
         {
-            const int dofIdxGlobal = this->fvGridGeometry().gridView().indexSet().index(facet);
+            const int dofIdxGlobal = this->gridGeometry().gridView().indexSet().index(facet);
             coordinates_[dofIdxGlobal] = facet.geometry().center();
         }
         coordinatesInitialized_ = true;
@@ -173,7 +173,7 @@ private:
      //! \param time The current time
     void getFaceDataAndWrite_(const Scalar time)
     {
-        const auto numPoints = this->fvGridGeometry().numFaceDofs();
+        const auto numPoints = this->gridGeometry().numFaceDofs();
 
         // make sure not to iterate over the same dofs twice
         std::vector<bool> dofVisited(numPoints, false);
@@ -192,9 +192,9 @@ private:
         if(!faceVarVectorDataInfo_.empty())
             faceVarVectorData.resize(faceVarVectorDataInfo_.size(), std::vector<GlobalPosition>(numPoints));
 
-        for (const auto& element : elements(this->fvGridGeometry().gridView(), Dune::Partitions::interior))
+        for (const auto& element : elements(this->gridGeometry().gridView(), Dune::Partitions::interior))
         {
-            auto fvGeometry = localView(this->fvGridGeometry());
+            auto fvGeometry = localView(this->gridGeometry());
             auto elemFaceVars = localView(this->gridVariables().curGridFaceVars());
 
             if (!faceVarScalarDataInfo_.empty() || !faceVarVectorDataInfo_.empty())
diff --git a/dumux/io/vtkoutputmodule.hh b/dumux/io/vtkoutputmodule.hh
index 2c4cb087b3b3e1697ce0c70efcd3d98c72f75d11..3584f0c9c6ed6b091380924d55cf258fdd8e8864 100644
--- a/dumux/io/vtkoutputmodule.hh
+++ b/dumux/io/vtkoutputmodule.hh
@@ -64,12 +64,12 @@ namespace Dumux {
 template<class GridVariables, class SolutionVector>
 class VtkOutputModule
 {
-    using FVGridGeometry = typename GridVariables::GridGeometry;
+    using GridGeometry = typename GridVariables::GridGeometry;
 
     using VV = typename GridVariables::VolumeVariables;
     using Scalar = typename GridVariables::Scalar;
 
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
 
     enum {
         dim = GridView::dimension,
@@ -79,7 +79,7 @@ class VtkOutputModule
     using Element = typename GridView::template Codim<0>::Entity;
     using VolVarsVector = Dune::FieldVector<Scalar, dimWorld>;
 
-    static constexpr bool isBox = FVGridGeometry::discMethod == DiscretizationMethod::box;
+    static constexpr bool isBox = GridGeometry::discMethod == DiscretizationMethod::box;
     static constexpr int dofCodim = isBox ? dim : 0;
 
     struct VolVarScalarDataInfo { std::function<Scalar(const VV&)> get; std::string name; };
@@ -163,8 +163,8 @@ public:
         // Deduce the number of components from the given vector type
         const auto nComp = getNumberOfComponents_(v);
 
-        const auto numElemDofs = fvGridGeometry().elementMapper().size();
-        const auto numVertexDofs = fvGridGeometry().vertexMapper().size();
+        const auto numElemDofs = gridGeometry().elementMapper().size();
+        const auto numVertexDofs = gridGeometry().vertexMapper().size();
 
         // Automatically deduce the field type ...
         if(fieldType == FieldType::automatic)
@@ -193,9 +193,9 @@ public:
 
         // add the appropriate field
         if (fieldType == FieldType::element)
-            fields_.emplace_back(fvGridGeometry().gridView(), fvGridGeometry().elementMapper(), v, name, nComp, 0);
+            fields_.emplace_back(gridGeometry().gridView(), gridGeometry().elementMapper(), v, name, nComp, 0);
         else
-            fields_.emplace_back(fvGridGeometry().gridView(), fvGridGeometry().vertexMapper(), v, name, nComp, dim);
+            fields_.emplace_back(gridGeometry().gridView(), gridGeometry().vertexMapper(), v, name, nComp, dim);
     }
 
     //////////////////////////////////////////////////////////////////////////////////////////////
@@ -230,7 +230,7 @@ public:
 protected:
     // some return functions for differing implementations to use
     const auto& problem() const { return gridVariables_.curGridVolVars().problem(); }
-    const FVGridGeometry& fvGridGeometry() const { return gridVariables_.gridGeometry(); }
+    const GridGeometry& gridGeometry() const { return gridVariables_.gridGeometry(); }
     const GridVariables& gridVariables() const { return gridVariables_; }
     const SolutionVector& sol() const { return sol_; }
 
@@ -276,7 +276,7 @@ private:
             || velocityOutput_->enableOutput()
             || addProcessRank)
         {
-            const auto numCells = fvGridGeometry().gridView().size(0);
+            const auto numCells = gridGeometry().gridView().size(0);
             const auto numDofs = numDofs_();
 
             // get fields for all volume variables
@@ -299,11 +299,11 @@ private:
             // maybe allocate space for the process rank
             if (addProcessRank) rank.resize(numCells);
 
-            for (const auto& element : elements(fvGridGeometry().gridView(), Dune::Partitions::interior))
+            for (const auto& element : elements(gridGeometry().gridView(), Dune::Partitions::interior))
             {
-                const auto eIdxGlobal = fvGridGeometry().elementMapper().index(element);
+                const auto eIdxGlobal = gridGeometry().elementMapper().index(element);
 
-                auto fvGeometry = localView(fvGridGeometry());
+                auto fvGeometry = localView(gridGeometry());
                 auto elemVolVars = localView(gridVariables_.curGridVolVars());
 
                 // If velocity output is enabled we need to bind to the whole stencil
@@ -349,7 +349,7 @@ private:
 
                 //! the rank
                 if (addProcessRank)
-                    rank[eIdxGlobal] = static_cast<double>(fvGridGeometry().gridView().comm().rank());
+                    rank[eIdxGlobal] = static_cast<double>(gridGeometry().gridView().comm().rank());
             }
 
             //////////////////////////////////////////////////////////////
@@ -360,19 +360,19 @@ private:
             if (isBox)
             {
                 for (std::size_t i = 0; i < volVarScalarDataInfo_.size(); ++i)
-                    sequenceWriter_.addVertexData( Field(fvGridGeometry().gridView(), fvGridGeometry().vertexMapper(), volVarScalarData[i],
+                    sequenceWriter_.addVertexData( Field(gridGeometry().gridView(), gridGeometry().vertexMapper(), volVarScalarData[i],
                                                          volVarScalarDataInfo_[i].name, /*numComp*/1, /*codim*/dim).get() );
                 for (std::size_t i = 0; i < volVarVectorDataInfo_.size(); ++i)
-                    sequenceWriter_.addVertexData( Field(fvGridGeometry().gridView(), fvGridGeometry().vertexMapper(), volVarVectorData[i],
+                    sequenceWriter_.addVertexData( Field(gridGeometry().gridView(), gridGeometry().vertexMapper(), volVarVectorData[i],
                                                          volVarVectorDataInfo_[i].name, /*numComp*/dimWorld, /*codim*/dim).get() );
             }
             else
             {
                 for (std::size_t i = 0; i < volVarScalarDataInfo_.size(); ++i)
-                    sequenceWriter_.addCellData( Field(fvGridGeometry().gridView(), fvGridGeometry().elementMapper(), volVarScalarData[i],
+                    sequenceWriter_.addCellData( Field(gridGeometry().gridView(), gridGeometry().elementMapper(), volVarScalarData[i],
                                                        volVarScalarDataInfo_[i].name, /*numComp*/1, /*codim*/0).get() );
                 for (std::size_t i = 0; i < volVarVectorDataInfo_.size(); ++i)
-                    sequenceWriter_.addCellData( Field(fvGridGeometry().gridView(), fvGridGeometry().elementMapper(), volVarVectorData[i],
+                    sequenceWriter_.addCellData( Field(gridGeometry().gridView(), gridGeometry().elementMapper(), volVarVectorData[i],
                                                        volVarVectorDataInfo_[i].name, /*numComp*/dimWorld, /*codim*/0).get() );
             }
 
@@ -382,7 +382,7 @@ private:
                 if (isBox && dim > 1)
                 {
                     for (int phaseIdx = 0; phaseIdx < velocityOutput_->numFluidPhases(); ++phaseIdx)
-                        sequenceWriter_.addVertexData( Field(fvGridGeometry().gridView(), fvGridGeometry().vertexMapper(), velocity[phaseIdx],
+                        sequenceWriter_.addVertexData( Field(gridGeometry().gridView(), gridGeometry().vertexMapper(), velocity[phaseIdx],
                                                              "velocity_" + velocityOutput_->phaseName(phaseIdx) + " (m/s)",
                                                              /*numComp*/dimWorld, /*codim*/dim).get() );
                 }
@@ -390,7 +390,7 @@ private:
                 else
                 {
                     for (int phaseIdx = 0; phaseIdx < velocityOutput_->numFluidPhases(); ++phaseIdx)
-                        sequenceWriter_.addCellData( Field(fvGridGeometry().gridView(), fvGridGeometry().elementMapper(), velocity[phaseIdx],
+                        sequenceWriter_.addCellData( Field(gridGeometry().gridView(), gridGeometry().elementMapper(), velocity[phaseIdx],
                                                            "velocity_" + velocityOutput_->phaseName(phaseIdx) + " (m/s)",
                                                            /*numComp*/dimWorld, /*codim*/0).get() );
                 }
@@ -398,7 +398,7 @@ private:
 
             // the process rank
             if (addProcessRank)
-                sequenceWriter_.addCellData(Field(fvGridGeometry().gridView(), fvGridGeometry().elementMapper(), rank, "process rank", 1, 0).get());
+                sequenceWriter_.addCellData(Field(gridGeometry().gridView(), gridGeometry().elementMapper(), rank, "process rank", 1, 0).get());
 
             // also register additional (non-standardized) user fields if any
             for (auto&& field : fields_)
@@ -460,7 +460,7 @@ private:
             || velocityOutput_->enableOutput()
             || addProcessRank)
         {
-            const auto numCells = fvGridGeometry().gridView().size(0);
+            const auto numCells = gridGeometry().gridView().size(0);
             const auto numDofs = numDofs_();
 
             // get fields for all volume variables
@@ -483,12 +483,12 @@ private:
             // maybe allocate space for the process rank
             if (addProcessRank) rank.resize(numCells);
 
-            for (const auto& element : elements(fvGridGeometry().gridView(), Dune::Partitions::interior))
+            for (const auto& element : elements(gridGeometry().gridView(), Dune::Partitions::interior))
             {
-                const auto eIdxGlobal = fvGridGeometry().elementMapper().index(element);
+                const auto eIdxGlobal = gridGeometry().elementMapper().index(element);
                 const auto numCorners = element.subEntities(dim);
 
-                auto fvGeometry = localView(fvGridGeometry());
+                auto fvGeometry = localView(gridGeometry());
                 auto elemVolVars = localView(gridVariables_.curGridVolVars());
 
                 // resize element-local data containers
@@ -539,7 +539,7 @@ private:
 
                 //! the rank
                 if (addProcessRank)
-                    rank[eIdxGlobal] = static_cast<double>(fvGridGeometry().gridView().comm().rank());
+                    rank[eIdxGlobal] = static_cast<double>(gridGeometry().gridView().comm().rank());
             }
 
             //////////////////////////////////////////////////////////////
@@ -548,11 +548,11 @@ private:
 
             // volume variables if any
             for (std::size_t i = 0; i < volVarScalarDataInfo_.size(); ++i)
-                sequenceWriter_.addVertexData( Field(fvGridGeometry().gridView(), fvGridGeometry().elementMapper(), volVarScalarData[i],
+                sequenceWriter_.addVertexData( Field(gridGeometry().gridView(), gridGeometry().elementMapper(), volVarScalarData[i],
                                                      volVarScalarDataInfo_[i].name, /*numComp*/1, /*codim*/dim, /*nonconforming*/dm_).get() );
 
             for (std::size_t i = 0; i < volVarVectorDataInfo_.size(); ++i)
-                sequenceWriter_.addVertexData( Field(fvGridGeometry().gridView(), fvGridGeometry().elementMapper(), volVarVectorData[i],
+                sequenceWriter_.addVertexData( Field(gridGeometry().gridView(), gridGeometry().elementMapper(), volVarVectorData[i],
                                                      volVarVectorDataInfo_[i].name, /*numComp*/dimWorld, /*codim*/dim, /*nonconforming*/dm_).get() );
 
             // the velocity field
@@ -561,21 +561,21 @@ private:
                 // node-wise velocities
                 if (dim > 1)
                     for (int phaseIdx = 0; phaseIdx < velocityOutput_->numFluidPhases(); ++phaseIdx)
-                        sequenceWriter_.addVertexData( Field(fvGridGeometry().gridView(), fvGridGeometry().vertexMapper(), velocity[phaseIdx],
+                        sequenceWriter_.addVertexData( Field(gridGeometry().gridView(), gridGeometry().vertexMapper(), velocity[phaseIdx],
                                                              "velocity_" + velocityOutput_->phaseName(phaseIdx) + " (m/s)",
                                                              /*numComp*/dimWorld, /*codim*/dim).get() );
 
                 // cell-wise velocities
                 else
                     for (int phaseIdx = 0; phaseIdx < velocityOutput_->numFluidPhases(); ++phaseIdx)
-                        sequenceWriter_.addCellData( Field(fvGridGeometry().gridView(), fvGridGeometry().elementMapper(), velocity[phaseIdx],
+                        sequenceWriter_.addCellData( Field(gridGeometry().gridView(), gridGeometry().elementMapper(), velocity[phaseIdx],
                                                            "velocity_" + velocityOutput_->phaseName(phaseIdx) + " (m/s)",
                                                            /*numComp*/dimWorld, /*codim*/0).get() );
             }
 
             // the process rank
             if (addProcessRank)
-                sequenceWriter_.addCellData( Field(fvGridGeometry().gridView(), fvGridGeometry().elementMapper(), rank, "process rank", 1, 0).get() );
+                sequenceWriter_.addCellData( Field(gridGeometry().gridView(), gridGeometry().elementMapper(), rank, "process rank", 1, 0).get() );
 
             // also register additional (non-standardized) user fields if any
             for (auto&& field : fields_)
@@ -609,7 +609,7 @@ private:
     std::size_t getNumberOfComponents_(const Vector& v) { return 1; }
 
     //! return the number of dofs, we only support vertex and cell data
-    std::size_t numDofs_() const { return dofCodim == dim ? fvGridGeometry().vertexMapper().size() : fvGridGeometry().elementMapper().size(); }
+    std::size_t numDofs_() const { return dofCodim == dim ? gridGeometry().vertexMapper().size() : gridGeometry().elementMapper().size(); }
 
     const GridVariables& gridVariables_;
     const SolutionVector& sol_;
diff --git a/dumux/linear/amgtraits.hh b/dumux/linear/amgtraits.hh
index a1c66c527ffbcb578bf8709a4758529f0fed3769..942f68ee65e22a98ebe840a8acb7287c356be93e 100644
--- a/dumux/linear/amgtraits.hh
+++ b/dumux/linear/amgtraits.hh
@@ -68,11 +68,11 @@ struct canCommunicate<Dune::UGGrid<dim>, codim>
 namespace Dumux {
 
 //! The implementation is specialized for the different discretizations
-template<class MType, class VType, class FVGridGeometry, DiscretizationMethod discMethod> struct AmgTraitsImpl;
+template<class MType, class VType, class GridGeometry, DiscretizationMethod discMethod> struct AmgTraitsImpl;
 
 //! The type traits required for using the AMG backend
-template<class MType, class VType, class FVGridGeometry>
-using AmgTraits = AmgTraitsImpl<MType, VType, FVGridGeometry, FVGridGeometry::discMethod>;
+template<class MType, class VType, class GridGeometry>
+using AmgTraits = AmgTraitsImpl<MType, VType, GridGeometry, GridGeometry::discMethod>;
 
 //! NonoverlappingSolverTraits used by discretization with non-overlapping parallel model
 template <class MType, class VType, bool isParallel>
@@ -98,10 +98,10 @@ public:
 #endif
 
 //! Box: use the non-overlapping AMG
-template<class Matrix, class Vector, class FVGridGeometry>
-struct AmgTraitsImpl<Matrix, Vector, FVGridGeometry, DiscretizationMethod::box>
+template<class Matrix, class Vector, class GridGeometry>
+struct AmgTraitsImpl<Matrix, Vector, GridGeometry, DiscretizationMethod::box>
 {
-    using Grid = typename FVGridGeometry::GridView::Traits::Grid;
+    using Grid = typename GridGeometry::GridView::Traits::Grid;
     enum {
         dofCodim = Grid::dimension,
         isNonOverlapping = true,
@@ -117,7 +117,7 @@ struct AmgTraitsImpl<Matrix, Vector, FVGridGeometry, DiscretizationMethod::box>
     using ScalarProduct = typename SolverTraits::ScalarProduct;
     using Smoother = typename SolverTraits::Smoother;
 
-    using DofMapper = typename FVGridGeometry::VertexMapper;
+    using DofMapper = typename GridGeometry::VertexMapper;
 };
 
 //! OverlappingSolverTraits used by discretization with overlapping parallel model
@@ -144,10 +144,10 @@ public:
 #endif
 
 //! Cell-centered tpfa: use the overlapping AMG
-template<class Matrix, class Vector, class FVGridGeometry>
-struct AmgTraitsImpl<Matrix, Vector, FVGridGeometry, DiscretizationMethod::cctpfa>
+template<class Matrix, class Vector, class GridGeometry>
+struct AmgTraitsImpl<Matrix, Vector, GridGeometry, DiscretizationMethod::cctpfa>
 {
-    using Grid = typename FVGridGeometry::GridView::Traits::Grid;
+    using Grid = typename GridGeometry::GridView::Traits::Grid;
     enum {
         dofCodim = 0,
         isNonOverlapping = false,
@@ -163,12 +163,12 @@ struct AmgTraitsImpl<Matrix, Vector, FVGridGeometry, DiscretizationMethod::cctpf
     using ScalarProduct = typename SolverTraits::ScalarProduct;
     using Smoother = typename SolverTraits::Smoother;
 
-    using DofMapper = typename FVGridGeometry::ElementMapper;
+    using DofMapper = typename GridGeometry::ElementMapper;
 };
 
-template<class Matrix, class Vector, class FVGridGeometry>
-struct AmgTraitsImpl<Matrix, Vector, FVGridGeometry, DiscretizationMethod::ccmpfa>
-: public AmgTraitsImpl<Matrix, Vector, FVGridGeometry, DiscretizationMethod::cctpfa> {};
+template<class Matrix, class Vector, class GridGeometry>
+struct AmgTraitsImpl<Matrix, Vector, GridGeometry, DiscretizationMethod::ccmpfa>
+: public AmgTraitsImpl<Matrix, Vector, GridGeometry, DiscretizationMethod::cctpfa> {};
 
 } // end namespace Dumux
 
diff --git a/dumux/material/chemistry/electrochemistry/electrochemistry.hh b/dumux/material/chemistry/electrochemistry/electrochemistry.hh
index 081acfd9413e75d42b3e96c7e012ae5f4da1c934..9fe071ef33330c67a8e7a3ada4f52a24a321b957 100644
--- a/dumux/material/chemistry/electrochemistry/electrochemistry.hh
+++ b/dumux/material/chemistry/electrochemistry/electrochemistry.hh
@@ -48,7 +48,7 @@ enum ElectroChemistryModel { Ochs, Acosta };
  * \todo TODO: Scalar type should be extracted from VolumeVariables!
  * \todo TODO: This shouldn't depend on grid and discretization!!
  */
-template <class Scalar, class Indices, class FluidSystem, class FVGridGeometry, ElectroChemistryModel electroChemistryModel>
+template <class Scalar, class Indices, class FluidSystem, class GridGeometry, ElectroChemistryModel electroChemistryModel>
 class ElectroChemistry
 {
 
@@ -74,8 +74,8 @@ class ElectroChemistry
         gasPhaseIdx = FluidSystem::gasPhaseIdx
     };
 
-    using GridView = typename FVGridGeometry::GridView;
-    static constexpr bool isBox = FVGridGeometry::discMethod == DiscretizationMethod::box;
+    using GridView = typename GridGeometry::GridView;
+    static constexpr bool isBox = GridGeometry::discMethod == DiscretizationMethod::box;
     using GlobalPosition = typename Dune::FieldVector<typename GridView::ctype, GridView::dimensionworld>;
 
 public:
diff --git a/dumux/material/chemistry/electrochemistry/electrochemistryni.hh b/dumux/material/chemistry/electrochemistry/electrochemistryni.hh
index f2a4b8f6d801912cdd05c3171daac5e54cf90f7c..d4d31de82eb6e089e27a442cccfac2320c67480d 100644
--- a/dumux/material/chemistry/electrochemistry/electrochemistryni.hh
+++ b/dumux/material/chemistry/electrochemistry/electrochemistryni.hh
@@ -37,10 +37,10 @@ namespace Dumux {
  * \todo TODO: Scalar type should be extracted from VolumeVariables!
  * \todo TODO: This shouldn't depend on discretization and grid!!
  */
-template <class Scalar, class Indices, class FluidSystem, class FVGridGeometry, ElectroChemistryModel electroChemistryModel>
-class ElectroChemistryNI : public ElectroChemistry<Scalar, Indices, FluidSystem, FVGridGeometry, electroChemistryModel>
+template <class Scalar, class Indices, class FluidSystem, class GridGeometry, ElectroChemistryModel electroChemistryModel>
+class ElectroChemistryNI : public ElectroChemistry<Scalar, Indices, FluidSystem, GridGeometry, electroChemistryModel>
 {
-    using ParentType = ElectroChemistry<Scalar, Indices, FluidSystem, FVGridGeometry, electroChemistryModel>;
+    using ParentType = ElectroChemistry<Scalar, Indices, FluidSystem, GridGeometry, electroChemistryModel>;
     using Constant = Constants<Scalar>;
 
     enum {
@@ -50,8 +50,8 @@ class ElectroChemistryNI : public ElectroChemistry<Scalar, Indices, FluidSystem,
         energyEqIdx = Indices::energyEqIdx, //energy equation
     };
 
-    using GridView = typename FVGridGeometry::GridView;
-    static constexpr bool isBox = FVGridGeometry::discMethod == DiscretizationMethod::box;
+    using GridView = typename GridGeometry::GridView;
+    static constexpr bool isBox = GridGeometry::discMethod == DiscretizationMethod::box;
     using GlobalPosition = typename Dune::FieldVector<typename GridView::ctype, GridView::dimensionworld>;
     using CellVector = typename Dune::FieldVector<typename GridView::ctype, GridView::dimension>;
 
diff --git a/dumux/material/fluidmatrixinteractions/porositydeformation.hh b/dumux/material/fluidmatrixinteractions/porositydeformation.hh
index e1304dda7a19f49a716ccdc150115967cea3d519..2389db780a9661a4da7c0fdf826b452ab1e71fc3 100644
--- a/dumux/material/fluidmatrixinteractions/porositydeformation.hh
+++ b/dumux/material/fluidmatrixinteractions/porositydeformation.hh
@@ -44,7 +44,7 @@ public:
      *       the displacements in the different grid directions are stored
      *       in the first entries of the primary variable vector.
      *
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param element The finite element
      * \param elemSol The element solution
      * \param globalPos The global position (in the element)
@@ -62,7 +62,7 @@ public:
      *       \f$\phi = \frac{\phi_0 + \text{div} \mathbf{u}}{1 + \text{div} \mathbf{u}}\f$.
      */
     template< class FVGridGeom, class ElemSol >
-    static Scalar evaluatePorosity(const FVGridGeom& fvGridGeometry,
+    static Scalar evaluatePorosity(const FVGridGeom& gridGeometry,
                                    const typename FVGridGeom::GridView::template Codim<0>::Entity& element,
                                    const typename FVGridGeom::GridView::template Codim<0>::Entity::Geometry::GlobalCoordinate& globalPos,
                                    const ElemSol& elemSol,
@@ -72,7 +72,7 @@ public:
     {
         // compute divergence of displacement at the given position
         Scalar divU = 0.0;
-        const auto gradU = evalGradients(element, element.geometry(), fvGridGeometry, elemSol, globalPos);
+        const auto gradU = evalGradients(element, element.geometry(), gridGeometry, elemSol, globalPos);
         for (int dir = 0; dir < FVGridGeom::GridView::dimension; ++dir)
             divU += gradU[dir][dir];
 
@@ -88,7 +88,7 @@ public:
      *       in the first entries of the primary variable vector.
      *
      *
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param element The finite element
      * \param elemSol The element solution
      * \param scv The sub-control volume
@@ -96,7 +96,7 @@ public:
      * \param minPoro A minimum porosity value
      */
     template< class FVGridGeom, class ElemSol >
-    static Scalar evaluatePorosity(const FVGridGeom& fvGridGeometry,
+    static Scalar evaluatePorosity(const FVGridGeom& gridGeometry,
                                    const typename FVGridGeom::GridView::template Codim<0>::Entity& element,
                                    const typename FVGridGeom::SubControlVolume& scv,
                                    const ElemSol& elemSol,
@@ -104,7 +104,7 @@ public:
                                    Scalar minPoro = 0.0)
     {
         // evaluate the porosity at the scv center
-        return evaluatePorosity(fvGridGeometry, element, scv.center(), elemSol, refPoro, minPoro);
+        return evaluatePorosity(gridGeometry, element, scv.center(), elemSol, refPoro, minPoro);
     }
 };
 
diff --git a/dumux/material/spatialparams/fv.hh b/dumux/material/spatialparams/fv.hh
index 3ff1cf17d44625e6cf27688851955b053b3d4c2f..4fb8c097b5c9340fd975218cf9086151f4044dc3 100644
--- a/dumux/material/spatialparams/fv.hh
+++ b/dumux/material/spatialparams/fv.hh
@@ -52,20 +52,20 @@ struct hasMaterialLawParamsAtPos
  * \brief The base class for spatial parameters of multi-phase problems
  * using a fully implicit discretization method.
  */
-template<class FVGridGeometry, class Scalar, class Implementation>
-class FVSpatialParams : public FVSpatialParamsOneP<FVGridGeometry, Scalar, Implementation>
+template<class GridGeometry, class Scalar, class Implementation>
+class FVSpatialParams : public FVSpatialParamsOneP<GridGeometry, Scalar, Implementation>
 {
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar, Implementation>;
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar, Implementation>;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
 
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    FVSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    FVSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {}
 
     /*!
diff --git a/dumux/material/spatialparams/fv1p.hh b/dumux/material/spatialparams/fv1p.hh
index 7bd4bd020cfb3f8560a96dd3267ef24445c4074f..fecc19e4e1008fc3271fec19b81f0e7c92ad4311 100644
--- a/dumux/material/spatialparams/fv1p.hh
+++ b/dumux/material/spatialparams/fv1p.hh
@@ -72,13 +72,13 @@ struct hasPorosityAtPos
  * \brief The base class for spatial parameters of one-phase problems
  * using a fully implicit discretization method.
  */
-template<class FVGridGeometry, class Scalar, class Implementation>
+template<class GridGeometry, class Scalar, class Implementation>
 class FVSpatialParamsOneP
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
     using Element = typename GridView::template Codim<0>::Entity;
 
     enum { dim = GridView::dimension };
@@ -88,8 +88,8 @@ class FVSpatialParamsOneP
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    FVSpatialParamsOneP(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : fvGridGeometry_(fvGridGeometry)
+    FVSpatialParamsOneP(std::shared_ptr<const GridGeometry> gridGeometry)
+    : gridGeometry_(gridGeometry)
     , gravity_(0.0)
     {
         const bool enableGravity = getParam<bool>("Problem.EnableGravity");
@@ -326,13 +326,13 @@ public:
     }
 
     //! The finite volume grid geometry
-    [[deprecated("Use more general GridGeometry instead. FVGridGeometry will be removed after 3.1!")]]
-    const FVGridGeometry& fvGridGeometry() const
-    { return *fvGridGeometry_; }
+    [[deprecated("Use gridGeometry() instead. fvGridGeometry() will be removed after 3.1!")]]
+    const GridGeometry& fvGridGeometry() const
+    { return *gridGeometry_; }
 
     //! The finite volume grid geometry
-    const FVGridGeometry& gridGeometry() const
-    { return *fvGridGeometry_; }
+    const GridGeometry& gridGeometry() const
+    { return *gridGeometry_; }
 
 
 protected:
@@ -343,7 +343,7 @@ protected:
     { return *static_cast<const Implementation*>(this); }
 
 private:
-    std::shared_ptr<const FVGridGeometry> fvGridGeometry_;
+    std::shared_ptr<const GridGeometry> gridGeometry_;
     GlobalPosition gravity_; //!< The gravity vector
     Scalar forchCoeffDefault_;
 };
diff --git a/dumux/material/spatialparams/fvelastic.hh b/dumux/material/spatialparams/fvelastic.hh
index e864051cfb2bb27fabc8e53d39c7eecac5d7852e..84f67a33638a51ec5762154ec8bb9bb92128edce 100644
--- a/dumux/material/spatialparams/fvelastic.hh
+++ b/dumux/material/spatialparams/fvelastic.hh
@@ -53,12 +53,12 @@ struct hasLameParamsAtPos
  * \ingroup SpatialParameters
  * \brief The base class for spatial parameters of linear elastic geomechanical problems
  */
-template<class Scalar, class FVGridGeometry, class Implementation>
+template<class Scalar, class GridGeometry, class Implementation>
 class FVSpatialParamsElastic
 {
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -66,8 +66,8 @@ class FVSpatialParamsElastic
 
 public:
     //! The constructor
-    FVSpatialParamsElastic(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : fvGridGeometry_(fvGridGeometry)
+    FVSpatialParamsElastic(std::shared_ptr<const GridGeometry> gridGeometry)
+    : gridGeometry_(gridGeometry)
     , gravity_(0.0)
     {
         const bool enableGravity = getParam<bool>("Problem.EnableGravity");
@@ -159,13 +159,13 @@ public:
     }
 
     //! The finite volume grid geometry
-    [[deprecated("Use more general GridGeometry instead. FVGridGeometry will be removed after 3.1!")]]
-    const FVGridGeometry& fvGridGeometry() const
-    { return *fvGridGeometry_; }
+    [[deprecated("Use gridGeometry() instead. fvGridGeometry() will be removed after 3.1!")]]
+    const GridGeometry& fvGridGeometry() const
+    { return *gridGeometry_; }
 
     //! The finite volume grid geometry
-    const FVGridGeometry& gridGeometry() const
-    { return *fvGridGeometry_; }
+    const GridGeometry& gridGeometry() const
+    { return *gridGeometry_; }
 
 protected:
     Implementation &asImp_()
@@ -175,7 +175,7 @@ protected:
     { return *static_cast<const Implementation*>(this); }
 
 private:
-    std::shared_ptr<const FVGridGeometry> fvGridGeometry_;
+    std::shared_ptr<const GridGeometry> gridGeometry_;
     GlobalPosition gravity_; //!< The gravity vector
 };
 } // end namespace Dumuxs
diff --git a/dumux/material/spatialparams/fvnonequilibrium.hh b/dumux/material/spatialparams/fvnonequilibrium.hh
index 576fb89182779a7d87bd3da8f05fd285e9d0344e..492d18d2485ba197018d05b2e4676346e91c9c4b 100644
--- a/dumux/material/spatialparams/fvnonequilibrium.hh
+++ b/dumux/material/spatialparams/fvnonequilibrium.hh
@@ -33,14 +33,14 @@ namespace Dumux {
  * \ingroup SpatialParameters
  * \brief Definition of the spatial parameters for non-equilibrium
  */
-template<class FVGridGeometry, class Scalar, class Implementation>
+template<class GridGeometry, class Scalar, class Implementation>
 class FVNonEquilibriumSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar, Implementation>
+: public FVSpatialParams<GridGeometry, Scalar, Implementation>
 {
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, Implementation>;
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, Implementation>;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -50,8 +50,8 @@ public:
     using AwsSurfaceParams = Scalar;
     using AnsSurfaceParams = Scalar;
 
-    FVNonEquilibriumSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    FVNonEquilibriumSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {  }
 
     /*!
diff --git a/dumux/material/spatialparams/fvporoelastic.hh b/dumux/material/spatialparams/fvporoelastic.hh
index df29df7836d035f15898a7f8810c66a7ffad5e0a..602893c0c27b0396774645ea3206c8991ed3ea69 100644
--- a/dumux/material/spatialparams/fvporoelastic.hh
+++ b/dumux/material/spatialparams/fvporoelastic.hh
@@ -74,12 +74,12 @@ struct hasBiotCoeffAtPos
  * \ingroup SpatialParameters
  * \brief The base class for spatial parameters of poro-elastic geomechanical problems
  */
-template<class Scalar, class FVGridGeometry, class Implementation>
+template<class Scalar, class GridGeometry, class Implementation>
 class FVSpatialParamsPoroElastic
 {
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -87,8 +87,8 @@ class FVSpatialParamsPoroElastic
 
 public:
     //! The constructor
-    FVSpatialParamsPoroElastic(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : fvGridGeometry_(fvGridGeometry)
+    FVSpatialParamsPoroElastic(std::shared_ptr<const GridGeometry> gridGeometry)
+    : gridGeometry_(gridGeometry)
     , gravity_(0.0)
     {
         const bool enableGravity = getParam<bool>("Problem.EnableGravity");
@@ -314,13 +314,13 @@ public:
     }
 
     //! The finite volume grid geometry
-    [[deprecated("Use more general GridGeometry instead. FVGridGeometry will be removed after 3.1!")]]
-    const FVGridGeometry& fvGridGeometry() const
-    { return *fvGridGeometry_; }
+    [[deprecated("Use gridGeometry() instead. fvGridGeometry() will be removed after 3.1!")]]
+    const GridGeometry& fvGridGeometry() const
+    { return *gridGeometry_; }
 
     //! The finite volume grid geometry
-    const FVGridGeometry& gridGeometry() const
-    { return *fvGridGeometry_; }
+    const GridGeometry& gridGeometry() const
+    { return *gridGeometry_; }
     
 protected:
     Implementation &asImp_()
@@ -330,7 +330,7 @@ protected:
     { return *static_cast<const Implementation*>(this); }
 
 private:
-    std::shared_ptr<const FVGridGeometry> fvGridGeometry_;
+    std::shared_ptr<const GridGeometry> gridGeometry_;
     GlobalPosition gravity_; //!< The gravity vector
 };
 } // end namespace Dumux
diff --git a/dumux/multidomain/boundary/darcydarcy/couplingmanager.hh b/dumux/multidomain/boundary/darcydarcy/couplingmanager.hh
index 56064912fa83addf7e5dab5324f2ef5237a5ac02..206299bec2552b2805b075746525db6f681411a5 100644
--- a/dumux/multidomain/boundary/darcydarcy/couplingmanager.hh
+++ b/dumux/multidomain/boundary/darcydarcy/couplingmanager.hh
@@ -60,11 +60,11 @@ class DarcyDarcyBoundaryCouplingManager
     template<std::size_t i> using NumEqVector = GetPropType<SubDomainTypeTag<i>, Properties::NumEqVector>;
     template<std::size_t i> using ElementVolumeVariables = typename GetPropType<SubDomainTypeTag<i>, Properties::GridVolumeVariables>::LocalView;
     template<std::size_t i> using VolumeVariables = typename GetPropType<SubDomainTypeTag<i>, Properties::GridVolumeVariables>::VolumeVariables;
-    template<std::size_t i> using FVGridGeometry = typename MDTraits::template SubDomain<i>::GridGeometry;
-    template<std::size_t i> using FVElementGeometry = typename FVGridGeometry<i>::LocalView;
-    template<std::size_t i> using SubControlVolumeFace = typename FVGridGeometry<i>::SubControlVolumeFace;
-    template<std::size_t i> using SubControlVolume = typename FVGridGeometry<i>::SubControlVolume;
-    template<std::size_t i> using GridView = typename FVGridGeometry<i>::GridView;
+    template<std::size_t i> using GridGeometry = typename MDTraits::template SubDomain<i>::GridGeometry;
+    template<std::size_t i> using FVElementGeometry = typename GridGeometry<i>::LocalView;
+    template<std::size_t i> using SubControlVolumeFace = typename GridGeometry<i>::SubControlVolumeFace;
+    template<std::size_t i> using SubControlVolume = typename GridGeometry<i>::SubControlVolume;
+    template<std::size_t i> using GridView = typename GridGeometry<i>::GridView;
     template<std::size_t i> using Element = typename GridView<i>::template Codim<0>::Entity;
 
     template<std::size_t i>
@@ -73,7 +73,7 @@ class DarcyDarcyBoundaryCouplingManager
 
     template<std::size_t i>
     static constexpr bool isCCTpfa()
-    { return FVGridGeometry<i>::discMethod == DiscretizationMethod::cctpfa; }
+    { return GridGeometry<i>::discMethod == DiscretizationMethod::cctpfa; }
 
     using CouplingStencil = std::vector<std::size_t>;
 public:
diff --git a/dumux/multidomain/boundary/darcydarcy/couplingmapper.hh b/dumux/multidomain/boundary/darcydarcy/couplingmapper.hh
index fe7604809141c03cfe71a1e930ee26aa73d3e9a7..f13d1cc8488e0af12bc86ef39f6bb13b5a82ae15 100644
--- a/dumux/multidomain/boundary/darcydarcy/couplingmapper.hh
+++ b/dumux/multidomain/boundary/darcydarcy/couplingmapper.hh
@@ -49,9 +49,9 @@ class DarcyDarcyBoundaryCouplingMapper
 {
     using Scalar = typename MDTraits::Scalar;
 
-    template<std::size_t i> using FVGridGeometry = typename MDTraits::template SubDomain<i>::GridGeometry;
-    template<std::size_t i> using SubControlVolumeFace = typename FVGridGeometry<i>::SubControlVolumeFace;
-    template<std::size_t i> using GridView = typename FVGridGeometry<i>::GridView;
+    template<std::size_t i> using GridGeometry = typename MDTraits::template SubDomain<i>::GridGeometry;
+    template<std::size_t i> using SubControlVolumeFace = typename GridGeometry<i>::SubControlVolumeFace;
+    template<std::size_t i> using GridView = typename GridGeometry<i>::GridView;
     template<std::size_t i> using Element = typename GridView<i>::template Codim<0>::Entity;
 
     template<std::size_t i>
@@ -60,7 +60,7 @@ class DarcyDarcyBoundaryCouplingMapper
 
     template<std::size_t i>
     static constexpr bool isCCTpfa()
-    { return FVGridGeometry<i>::discMethod == DiscretizationMethod::cctpfa; }
+    { return GridGeometry<i>::discMethod == DiscretizationMethod::cctpfa; }
 
     struct ScvfInfo
     {
diff --git a/dumux/multidomain/boundary/stokesdarcy/couplingdata.hh b/dumux/multidomain/boundary/stokesdarcy/couplingdata.hh
index fd03a4eb5f8d28d619d6d7a3a1d6627ca56a6358..c54991c45adcfa4d376d1ee8d8e74624ae383029 100644
--- a/dumux/multidomain/boundary/stokesdarcy/couplingdata.hh
+++ b/dumux/multidomain/boundary/stokesdarcy/couplingdata.hh
@@ -225,11 +225,11 @@ class StokesDarcyCouplingDataImplementationBase
     using Scalar = typename MDTraits::Scalar;
 
     template<std::size_t id> using SubDomainTypeTag = typename MDTraits::template SubDomain<id>::TypeTag;
-    template<std::size_t id> using FVGridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
-    template<std::size_t id> using Element = typename FVGridGeometry<id>::GridView::template Codim<0>::Entity;
-    template<std::size_t id> using FVElementGeometry = typename FVGridGeometry<id>::LocalView;
-    template<std::size_t id> using SubControlVolumeFace = typename FVGridGeometry<id>::LocalView::SubControlVolumeFace;
-    template<std::size_t id> using SubControlVolume = typename FVGridGeometry<id>::LocalView::SubControlVolume;
+    template<std::size_t id> using GridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
+    template<std::size_t id> using Element = typename GridGeometry<id>::GridView::template Codim<0>::Entity;
+    template<std::size_t id> using FVElementGeometry = typename GridGeometry<id>::LocalView;
+    template<std::size_t id> using SubControlVolumeFace = typename GridGeometry<id>::LocalView::SubControlVolumeFace;
+    template<std::size_t id> using SubControlVolume = typename GridGeometry<id>::LocalView::SubControlVolume;
     template<std::size_t id> using Indices = typename GetPropType<SubDomainTypeTag<id>, Properties::ModelTraits>::Indices;
     template<std::size_t id> using ElementVolumeVariables = typename GetPropType<SubDomainTypeTag<id>, Properties::GridVolumeVariables>::LocalView;
     template<std::size_t id> using VolumeVariables = typename GetPropType<SubDomainTypeTag<id>, Properties::GridVolumeVariables>::VolumeVariables;
@@ -241,8 +241,8 @@ class StokesDarcyCouplingDataImplementationBase
     static constexpr auto darcyIdx = CouplingManager::darcyIdx;
 
     using AdvectionType = GetPropType<SubDomainTypeTag<darcyIdx>, Properties::AdvectionType>;
-    using DarcysLaw = DarcysLawImplementation<SubDomainTypeTag<darcyIdx>, FVGridGeometry<darcyIdx>::discMethod>;
-    using ForchheimersLaw = ForchheimersLawImplementation<SubDomainTypeTag<darcyIdx>, FVGridGeometry<darcyIdx>::discMethod>;
+    using DarcysLaw = DarcysLawImplementation<SubDomainTypeTag<darcyIdx>, GridGeometry<darcyIdx>::discMethod>;
+    using ForchheimersLaw = ForchheimersLawImplementation<SubDomainTypeTag<darcyIdx>, GridGeometry<darcyIdx>::discMethod>;
 
     static constexpr bool adapterUsed = ModelTraits<darcyIdx>::numFluidPhases() > 1;
     using IndexHelper = Dumux::IndexHelper<stokesIdx, darcyIdx, FluidSystem<stokesIdx>, adapterUsed>;
@@ -525,11 +525,11 @@ class StokesDarcyCouplingDataImplementation<MDTraits, CouplingManager, enableEne
     template<std::size_t id>
     using SubDomainTypeTag = typename MDTraits::template SubDomain<id>::TypeTag;
 
-    template<std::size_t id> using FVGridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
-    template<std::size_t id> using Element = typename FVGridGeometry<id>::GridView::template Codim<0>::Entity;
-    template<std::size_t id> using FVElementGeometry = typename FVGridGeometry<id>::LocalView;
-    template<std::size_t id> using SubControlVolumeFace = typename FVGridGeometry<id>::LocalView::SubControlVolumeFace;
-    template<std::size_t id> using SubControlVolume = typename FVGridGeometry<id>::LocalView::SubControlVolume;
+    template<std::size_t id> using GridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
+    template<std::size_t id> using Element = typename GridGeometry<id>::GridView::template Codim<0>::Entity;
+    template<std::size_t id> using FVElementGeometry = typename GridGeometry<id>::LocalView;
+    template<std::size_t id> using SubControlVolumeFace = typename GridGeometry<id>::LocalView::SubControlVolumeFace;
+    template<std::size_t id> using SubControlVolume = typename GridGeometry<id>::LocalView::SubControlVolume;
     template<std::size_t id> using Indices = typename GetPropType<SubDomainTypeTag<id>, Properties::ModelTraits>::Indices;
     template<std::size_t id> using ElementVolumeVariables = typename GetPropType<SubDomainTypeTag<id>, Properties::GridVolumeVariables>::LocalView;
     template<std::size_t id> using ElementFaceVariables = typename GetPropType<SubDomainTypeTag<id>, Properties::GridFaceVariables>::LocalView;
@@ -687,11 +687,11 @@ class StokesDarcyCouplingDataImplementation<MDTraits, CouplingManager, enableEne
     template<std::size_t id>
     using SubDomainTypeTag = typename MDTraits::template SubDomain<id>::TypeTag;
 
-    template<std::size_t id> using FVGridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
-    template<std::size_t id> using Element = typename FVGridGeometry<id>::GridView::template Codim<0>::Entity;
-    template<std::size_t id> using FVElementGeometry = typename FVGridGeometry<id>::LocalView;
+    template<std::size_t id> using GridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
+    template<std::size_t id> using Element = typename GridGeometry<id>::GridView::template Codim<0>::Entity;
+    template<std::size_t id> using FVElementGeometry = typename GridGeometry<id>::LocalView;
     template<std::size_t id> using SubControlVolumeFace = typename FVElementGeometry<id>::SubControlVolumeFace;
-    template<std::size_t id> using SubControlVolume = typename FVGridGeometry<id>::LocalView::SubControlVolume;
+    template<std::size_t id> using SubControlVolume = typename GridGeometry<id>::LocalView::SubControlVolume;
     template<std::size_t id> using Indices = typename GetPropType<SubDomainTypeTag<id>, Properties::ModelTraits>::Indices;
     template<std::size_t id> using ElementVolumeVariables = typename GetPropType<SubDomainTypeTag<id>, Properties::GridVolumeVariables>::LocalView;
     template<std::size_t id> using ElementFaceVariables = typename GetPropType<SubDomainTypeTag<id>, Properties::GridFaceVariables>::LocalView;
diff --git a/dumux/multidomain/boundary/stokesdarcy/couplingmanager.hh b/dumux/multidomain/boundary/stokesdarcy/couplingmanager.hh
index 7636ae7d212c7e901fd92e425ffc6be0551490d1..e453df942df8014e93f396c057d8d47b9c948bda 100644
--- a/dumux/multidomain/boundary/stokesdarcy/couplingmanager.hh
+++ b/dumux/multidomain/boundary/stokesdarcy/couplingmanager.hh
@@ -81,8 +81,8 @@ private:
     template<std::size_t id> using ElementVolumeVariables = typename GetPropType<SubDomainTypeTag<id>, Properties::GridVolumeVariables>::LocalView;
     template<std::size_t id> using GridVolumeVariables = GetPropType<SubDomainTypeTag<id>, Properties::GridVolumeVariables>;
     template<std::size_t id> using VolumeVariables = typename GetPropType<SubDomainTypeTag<id>, Properties::GridVolumeVariables>::VolumeVariables;
-    template<std::size_t id> using FVGridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
-    template<std::size_t id> using FVElementGeometry = typename FVGridGeometry<id>::LocalView;
+    template<std::size_t id> using GridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
+    template<std::size_t id> using FVElementGeometry = typename GridGeometry<id>::LocalView;
     template<std::size_t id> using ElementBoundaryTypes = GetPropType<SubDomainTypeTag<id>, Properties::ElementBoundaryTypes>;
     template<std::size_t id> using ElementFluxVariablesCache = typename GetPropType<SubDomainTypeTag<id>, Properties::GridFluxVariablesCache>::LocalView;
     template<std::size_t id> using GridVariables = GetPropType<SubDomainTypeTag<id>, Properties::GridVariables>;
@@ -121,8 +121,8 @@ public:
     using CouplingData = StokesDarcyCouplingData<MDTraits, StokesDarcyCouplingManager<MDTraits>>;
 
     //! Constructor
-    StokesDarcyCouplingManager(std::shared_ptr<const FVGridGeometry<stokesIdx>> stokesFvGridGeometry,
-                               std::shared_ptr<const FVGridGeometry<darcyIdx>> darcyFvGridGeometry) : couplingMapper_(*this)
+    StokesDarcyCouplingManager(std::shared_ptr<const GridGeometry<stokesIdx>> stokesFvGridGeometry,
+                               std::shared_ptr<const GridGeometry<darcyIdx>> darcyFvGridGeometry) : couplingMapper_(*this)
     { }
 
     /*!
diff --git a/dumux/multidomain/embedded/couplingmanager1d3d.hh b/dumux/multidomain/embedded/couplingmanager1d3d.hh
index 0c16d200ed23482b83e97e4dcf047ed55b62f6c8..d40c1485a635ae6acb625b73b8763ac25277d4f4 100644
--- a/dumux/multidomain/embedded/couplingmanager1d3d.hh
+++ b/dumux/multidomain/embedded/couplingmanager1d3d.hh
@@ -53,12 +53,12 @@ struct CircleAveragePointSourceTraits
 {
 private:
     template<std::size_t i> using SubDomainTypeTag = typename MDTraits::template SubDomain<i>::TypeTag;
-    template<std::size_t i> using FVGridGeometry = GetPropType<SubDomainTypeTag<i>, Properties::GridGeometry>;
+    template<std::size_t i> using GridGeometry = GetPropType<SubDomainTypeTag<i>, Properties::GridGeometry>;
     template<std::size_t i> using NumEqVector = GetPropType<SubDomainTypeTag<i>, Properties::NumEqVector>;
 public:
     //! export the point source type for domain i
     template<std::size_t i>
-    using PointSource = IntegrationPointSource<typename FVGridGeometry<i>::GlobalCoordinate, NumEqVector<i>>;
+    using PointSource = IntegrationPointSource<typename GridGeometry<i>::GlobalCoordinate, NumEqVector<i>>;
 
     //! export the point source helper type  for domain i
     template<std::size_t i>
@@ -100,8 +100,8 @@ class EmbeddedCouplingManager1d3d<MDTraits, EmbeddedCouplingMode::line>
     // the sub domain type aliases
     template<std::size_t id> using SubDomainTypeTag = typename MDTraits::template SubDomain<id>::TypeTag;
     template<std::size_t id> using Problem = GetPropType<SubDomainTypeTag<id>, Properties::Problem>;
-    template<std::size_t id> using FVGridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
-    template<std::size_t id> using GridView = typename FVGridGeometry<id>::GridView;
+    template<std::size_t id> using GridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
+    template<std::size_t id> using GridView = typename GridGeometry<id>::GridView;
     template<std::size_t id> using Element = typename GridView<id>::template Codim<0>::Entity;
 
 public:
@@ -200,15 +200,15 @@ class EmbeddedCouplingManager1d3d<MDTraits, EmbeddedCouplingMode::average>
     // the sub domain type aliases
     template<std::size_t id> using SubDomainTypeTag = typename MDTraits::template SubDomain<id>::TypeTag;
     template<std::size_t id> using Problem = GetPropType<SubDomainTypeTag<id>, Properties::Problem>;
-    template<std::size_t id> using FVGridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
-    template<std::size_t id> using GridView = typename FVGridGeometry<id>::GridView;
+    template<std::size_t id> using GridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
+    template<std::size_t id> using GridView = typename GridGeometry<id>::GridView;
     template<std::size_t id> using Element = typename GridView<id>::template Codim<0>::Entity;
 
     using GlobalPosition = typename Element<bulkIdx>::Geometry::GlobalCoordinate;
 
     template<std::size_t id>
     static constexpr bool isBox()
-    { return FVGridGeometry<id>::discMethod == DiscretizationMethod::box; }
+    { return GridGeometry<id>::discMethod == DiscretizationMethod::box; }
 
 
 public:
@@ -577,15 +577,15 @@ class EmbeddedCouplingManager1d3d<MDTraits, EmbeddedCouplingMode::cylindersource
     // the sub domain type aliases
     template<std::size_t id> using SubDomainTypeTag = typename MDTraits::template SubDomain<id>::TypeTag;
     template<std::size_t id> using Problem = GetPropType<SubDomainTypeTag<id>, Properties::Problem>;
-    template<std::size_t id> using FVGridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
-    template<std::size_t id> using GridView = typename FVGridGeometry<id>::GridView;
+    template<std::size_t id> using GridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
+    template<std::size_t id> using GridView = typename GridGeometry<id>::GridView;
     template<std::size_t id> using Element = typename GridView<id>::template Codim<0>::Entity;
 
     using GlobalPosition = typename Element<bulkIdx>::Geometry::GlobalCoordinate;
 
     template<std::size_t id>
     static constexpr bool isBox()
-    { return FVGridGeometry<id>::discMethod == DiscretizationMethod::box; }
+    { return GridGeometry<id>::discMethod == DiscretizationMethod::box; }
 
     enum {
         bulkDim = GridView<bulkIdx>::dimension,
@@ -853,15 +853,15 @@ class EmbeddedCouplingManager1d3d<MDTraits, EmbeddedCouplingMode::kernel>
     // the sub domain type aliases
     template<std::size_t id> using SubDomainTypeTag = typename MDTraits::template SubDomain<id>::TypeTag;
     template<std::size_t id> using Problem = GetPropType<SubDomainTypeTag<id>, Properties::Problem>;
-    template<std::size_t id> using FVGridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
-    template<std::size_t id> using GridView = typename FVGridGeometry<id>::GridView;
+    template<std::size_t id> using GridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
+    template<std::size_t id> using GridView = typename GridGeometry<id>::GridView;
     template<std::size_t id> using Element = typename GridView<id>::template Codim<0>::Entity;
 
     using GlobalPosition = typename Element<bulkIdx>::Geometry::GlobalCoordinate;
 
     template<std::size_t id>
     static constexpr bool isBox()
-    { return FVGridGeometry<id>::discMethod == DiscretizationMethod::box; }
+    { return GridGeometry<id>::discMethod == DiscretizationMethod::box; }
 
     enum {
         bulkDim = GridView<bulkIdx>::dimension,
diff --git a/dumux/multidomain/embedded/couplingmanagerbase.hh b/dumux/multidomain/embedded/couplingmanagerbase.hh
index b50a5e53711e50fe6302cb15d2278443b8dbe397..f64b47db970ded62e2d280f56840758750886c00 100644
--- a/dumux/multidomain/embedded/couplingmanagerbase.hh
+++ b/dumux/multidomain/embedded/couplingmanagerbase.hh
@@ -51,12 +51,12 @@ struct DefaultPointSourceTraits
 {
 private:
     template<std::size_t i> using SubDomainTypeTag = typename MDTraits::template SubDomain<i>::TypeTag;
-    template<std::size_t i> using FVGridGeometry = GetPropType<SubDomainTypeTag<i>, Properties::GridGeometry>;
+    template<std::size_t i> using GridGeometry = GetPropType<SubDomainTypeTag<i>, Properties::GridGeometry>;
     template<std::size_t i> using NumEqVector = GetPropType<SubDomainTypeTag<i>, Properties::NumEqVector>;
 public:
     //! export the point source type for domain i
     template<std::size_t i>
-    using PointSource = IntegrationPointSource<typename FVGridGeometry<i>::GlobalCoordinate, NumEqVector<i>>;
+    using PointSource = IntegrationPointSource<typename GridGeometry<i>::GlobalCoordinate, NumEqVector<i>>;
 
     //! export the point source helper type  for domain i
     template<std::size_t i>
@@ -87,9 +87,9 @@ class EmbeddedCouplingManagerBase
     template<std::size_t id> using SubDomainTypeTag = typename MDTraits::template SubDomain<id>::TypeTag;
     template<std::size_t id> using Problem = GetPropType<SubDomainTypeTag<id>, Properties::Problem>;
     template<std::size_t id> using PrimaryVariables = GetPropType<SubDomainTypeTag<id>, Properties::PrimaryVariables>;
-    template<std::size_t id> using FVGridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
-    template<std::size_t id> using GridView = typename FVGridGeometry<id>::GridView;
-    template<std::size_t id> using ElementMapper = typename FVGridGeometry<id>::ElementMapper;
+    template<std::size_t id> using GridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
+    template<std::size_t id> using GridView = typename GridGeometry<id>::GridView;
+    template<std::size_t id> using ElementMapper = typename GridGeometry<id>::ElementMapper;
     template<std::size_t id> using Element = typename GridView<id>::template Codim<0>::Entity;
 
     enum {
@@ -100,7 +100,7 @@ class EmbeddedCouplingManagerBase
 
     template<std::size_t id>
     static constexpr bool isBox()
-    { return FVGridGeometry<id>::discMethod == DiscretizationMethod::box; }
+    { return GridGeometry<id>::discMethod == DiscretizationMethod::box; }
 
     using CouplingStencil = std::vector<std::size_t>;
     using GlobalPosition = typename Element<bulkIdx>::Geometry::GlobalCoordinate;
@@ -117,8 +117,8 @@ public:
     /*!
     * \brief call this after grid adaption
     */
-    void updateAfterGridAdaption(std::shared_ptr<const FVGridGeometry<bulkIdx>> bulkFvGridGeometry,
-                                 std::shared_ptr<const FVGridGeometry<lowDimIdx>> lowDimFvGridGeometry)
+    void updateAfterGridAdaption(std::shared_ptr<const GridGeometry<bulkIdx>> bulkFvGridGeometry,
+                                 std::shared_ptr<const GridGeometry<lowDimIdx>> lowDimFvGridGeometry)
     {
         glue_ = std::make_shared<GlueType>();
     }
@@ -126,8 +126,8 @@ public:
     /*!
      * \brief Constructor
      */
-    EmbeddedCouplingManagerBase(std::shared_ptr<const FVGridGeometry<bulkIdx>> bulkFvGridGeometry,
-                                std::shared_ptr<const FVGridGeometry<lowDimIdx>> lowDimFvGridGeometry)
+    EmbeddedCouplingManagerBase(std::shared_ptr<const GridGeometry<bulkIdx>> bulkFvGridGeometry,
+                                std::shared_ptr<const GridGeometry<lowDimIdx>> lowDimFvGridGeometry)
     {
         updateAfterGridAdaption(bulkFvGridGeometry, lowDimFvGridGeometry);
     }
@@ -446,7 +446,7 @@ protected:
 
     //! compute the shape function for a given point and geometry
     template<std::size_t i, class FVGG, class Geometry, class ShapeValues, typename std::enable_if_t<FVGG::discMethod == DiscretizationMethod::box, int> = 0>
-    void getShapeValues(Dune::index_constant<i> domainI, const FVGG& fvGridGeometry, const Geometry& geo, const GlobalPosition& globalPos, ShapeValues& shapeValues)
+    void getShapeValues(Dune::index_constant<i> domainI, const FVGG& gridGeometry, const Geometry& geo, const GlobalPosition& globalPos, ShapeValues& shapeValues)
     {
         const auto ipLocal = geo.local(globalPos);
         const auto& localBasis = this->problem(domainI).gridGeometry().feCache().get(geo.type()).localBasis();
@@ -455,7 +455,7 @@ protected:
 
     //! compute the shape function for a given point and geometry
     template<std::size_t i, class FVGG, class Geometry, class ShapeValues, typename std::enable_if_t<FVGG::discMethod != DiscretizationMethod::box, int> = 0>
-    void getShapeValues(Dune::index_constant<i> domainI, const FVGG& fvGridGeometry, const Geometry& geo, const GlobalPosition& globalPos, ShapeValues& shapeValues)
+    void getShapeValues(Dune::index_constant<i> domainI, const FVGG& gridGeometry, const Geometry& geo, const GlobalPosition& globalPos, ShapeValues& shapeValues)
     {
         DUNE_THROW(Dune::InvalidStateException, "Shape values requested for other discretization than box!");
     }
diff --git a/dumux/multidomain/embedded/extendedsourcestencil.hh b/dumux/multidomain/embedded/extendedsourcestencil.hh
index 7e90408154abb0de3e25e738f7b0521571a8d7d6..9d1baae3e6ae44e23a343dfa0f0de1f28ec924db 100644
--- a/dumux/multidomain/embedded/extendedsourcestencil.hh
+++ b/dumux/multidomain/embedded/extendedsourcestencil.hh
@@ -49,8 +49,8 @@ class ExtendedSourceStencil
     using Scalar = typename MDTraits::Scalar;
 
     template<std::size_t id> using SubDomainTypeTag = typename MDTraits::template SubDomain<id>::TypeTag;
-    template<std::size_t id> using FVGridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
-    template<std::size_t id> using GridView = typename FVGridGeometry<id>::GridView;
+    template<std::size_t id> using GridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
+    template<std::size_t id> using GridView = typename GridGeometry<id>::GridView;
     template<std::size_t id> using Element = typename GridView<id>::template Codim<0>::Entity;
 
     static constexpr auto bulkIdx = typename MDTraits::template SubDomain<0>::Index();
@@ -58,7 +58,7 @@ class ExtendedSourceStencil
 
     template<std::size_t id>
     static constexpr bool isBox()
-    { return FVGridGeometry<id>::discMethod == DiscretizationMethod::box; }
+    { return GridGeometry<id>::discMethod == DiscretizationMethod::box; }
 public:
     /*!
      * \brief extend the jacobian pattern of the diagonal block of domain i
diff --git a/dumux/multidomain/embedded/integrationpointsource.hh b/dumux/multidomain/embedded/integrationpointsource.hh
index 4569845609ed030463cd8e9785ccb8dbecd66d1c..74ac494c9f378c6394ee78000e1155c8c14c6c60 100644
--- a/dumux/multidomain/embedded/integrationpointsource.hh
+++ b/dumux/multidomain/embedded/integrationpointsource.hh
@@ -108,8 +108,8 @@ class IntegrationPointSourceHelper
 
 public:
     //! calculate a DOF index to point source map from given vector of point sources
-    template<class FVGridGeometry, class PointSource, class PointSourceMap>
-    static void computePointSourceMap(const FVGridGeometry& fvGridGeometry,
+    template<class GridGeometry, class PointSource, class PointSourceMap>
+    static void computePointSourceMap(const GridGeometry& gridGeometry,
                                       std::vector<PointSource>& sources,
                                       PointSourceMap& pointSourceMap)
     {
@@ -122,15 +122,15 @@ public:
             // loop over all intersected elements
             for (unsigned int eIdx : entities)
             {
-                if (FVGridGeometry::discMethod == DiscretizationMethod::box)
+                if (GridGeometry::discMethod == DiscretizationMethod::box)
                 {
                     // check in which subcontrolvolume(s) we are
-                    const auto element = fvGridGeometry.boundingBoxTree().entitySet().entity(eIdx);
-                    auto fvGeometry = localView(fvGridGeometry);
+                    const auto element = gridGeometry.boundingBoxTree().entitySet().entity(eIdx);
+                    auto fvGeometry = localView(gridGeometry);
                     fvGeometry.bindElement(element);
                     const auto globalPos = source.position();
                     // loop over all sub control volumes and check if the point source is inside
-                    constexpr int dim = FVGridGeometry::GridView::dimension;
+                    constexpr int dim = GridGeometry::GridView::dimension;
                     Dune::ReservedVector<std::size_t, 1<<dim> scvIndices;
                     for (auto&& scv : scvs(fvGeometry))
                         if (intersectsPointGeometry(globalPos, scv.geometry()))
diff --git a/dumux/multidomain/facet/box/couplingmanager.hh b/dumux/multidomain/facet/box/couplingmanager.hh
index 8022db17930359557fae355c6babfd8887f61561..601212f606c995c8f35cc1c7f7bbc116f35c7c12 100644
--- a/dumux/multidomain/facet/box/couplingmanager.hh
+++ b/dumux/multidomain/facet/box/couplingmanager.hh
@@ -68,11 +68,11 @@ class FacetCouplingManager<MDTraits, CouplingMapper, bulkDomainId, lowDimDomainI
     template<std::size_t id> using ElementBoundaryTypes = GetPropType<SubDomainTypeTag<id>, Properties::ElementBoundaryTypes>;
     template<std::size_t id> using LocalResidual = GetPropType<SubDomainTypeTag<id>, Properties::LocalResidual>;
 
-    template<std::size_t id> using FVGridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
-    template<std::size_t id> using FVElementGeometry = typename FVGridGeometry<id>::LocalView;
-    template<std::size_t id> using SubControlVolume = typename FVGridGeometry<id>::SubControlVolume;
-    template<std::size_t id> using SubControlVolumeFace = typename FVGridGeometry<id>::SubControlVolumeFace;
-    template<std::size_t id> using GridView = typename FVGridGeometry<id>::GridView;
+    template<std::size_t id> using GridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
+    template<std::size_t id> using FVElementGeometry = typename GridGeometry<id>::LocalView;
+    template<std::size_t id> using SubControlVolume = typename GridGeometry<id>::SubControlVolume;
+    template<std::size_t id> using SubControlVolumeFace = typename GridGeometry<id>::SubControlVolumeFace;
+    template<std::size_t id> using GridView = typename GridGeometry<id>::GridView;
     template<std::size_t id> using Element = typename GridView<id>::template Codim<0>::Entity;
     template<std::size_t id> using GridIndexType = typename GridView<id>::IndexSet::IndexType;
 
@@ -89,7 +89,7 @@ class FacetCouplingManager<MDTraits, CouplingMapper, bulkDomainId, lowDimDomainI
     static constexpr auto bulkGridId = CouplingMapper::template gridId<bulkDim>();
     static constexpr auto lowDimGridId = CouplingMapper::template gridId<lowDimDim>();
 
-    static constexpr bool lowDimUsesBox = FVGridGeometry<lowDimId>::discMethod == DiscretizationMethod::box;
+    static constexpr bool lowDimUsesBox = GridGeometry<lowDimId>::discMethod == DiscretizationMethod::box;
 
     /*!
      * \brief The coupling context of the bulk domain. Contains all data of the lower-
diff --git a/dumux/multidomain/facet/box/darcyslaw.hh b/dumux/multidomain/facet/box/darcyslaw.hh
index 85e1d70340c65cb72c40906898d97946368d9e89..a7f06d4f279b57ab72c52c4252734ded3991bf11 100644
--- a/dumux/multidomain/facet/box/darcyslaw.hh
+++ b/dumux/multidomain/facet/box/darcyslaw.hh
@@ -46,15 +46,15 @@ namespace Dumux {
  *        where coupling occurs across the facets of the bulk domain elements
  *        with a lower-dimensional domain living on these facets.
  */
-template<class Scalar, class FVGridGeometry>
+template<class Scalar, class GridGeometry>
 class BoxFacetCouplingDarcysLaw
 {
-    using DefaultBoxDarcysLaw = BoxDarcysLaw<Scalar, FVGridGeometry>;
+    using DefaultBoxDarcysLaw = BoxDarcysLaw<Scalar, GridGeometry>;
 
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using CoordScalar = typename GridView::ctype;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
diff --git a/dumux/multidomain/facet/box/elementboundarytypes.hh b/dumux/multidomain/facet/box/elementboundarytypes.hh
index 5093d4290a9f9698ef9e8c7bca3903d5e648e233..e4384855d80b9c94f7f8062c25962bc94c705af1 100644
--- a/dumux/multidomain/facet/box/elementboundarytypes.hh
+++ b/dumux/multidomain/facet/box/elementboundarytypes.hh
@@ -59,8 +59,8 @@ public:
                 const Element &element,
                 const FVElementGeometry &fvGeometry)
     {
-        using FVGridGeometry = typename FVElementGeometry::GridGeometry;
-        using GridView = typename FVGridGeometry::GridView;
+        using GridGeometry = typename FVElementGeometry::GridGeometry;
+        using GridView = typename GridGeometry::GridView;
 
         this->vertexBCTypes_.resize( element.subEntities(GridView::dimension) );
 
diff --git a/dumux/multidomain/facet/box/fvelementgeometry.hh b/dumux/multidomain/facet/box/fvelementgeometry.hh
index 2ef80eb54eee499f6896945a4dc06d267179afc8..fcd7b4c9e1be0dbc0a442e42b018d8b1a70745d5 100644
--- a/dumux/multidomain/facet/box/fvelementgeometry.hh
+++ b/dumux/multidomain/facet/box/fvelementgeometry.hh
@@ -73,8 +73,8 @@ public:
     static constexpr std::size_t maxNumElementScvs = (1<<dim);
 
     //! Constructor
-    BoxFacetCouplingFVElementGeometry(const GridGeometry& fvGridGeometry)
-    : fvGridGeometryPtr_(&fvGridGeometry)
+    BoxFacetCouplingFVElementGeometry(const GridGeometry& gridGeometry)
+    : gridGeometryPtr_(&gridGeometry)
     {}
 
     //! Get a sub control volume with a local scv index
@@ -141,17 +141,17 @@ public:
     }
 
     //! The global finite volume geometry we are a restriction of
-    [[deprecated("Use more general GridGeometry instead. FVGridGeometry will be removed after 3.1!")]]
+    [[deprecated("Use gridGeometry() instead. fvGridGeometry() will be removed after 3.1!")]]
     const GridGeometry& fvGridGeometry() const
-    { return *fvGridGeometryPtr_; }
+    { return *gridGeometryPtr_; }
 
     //! The global finite volume geometry we are a restriction of
     const GridGeometry& gridGeometry() const
-    { return *fvGridGeometryPtr_; }
+    { return *gridGeometryPtr_; }
 
 private:
     Dune::GeometryType elemGeometryType_;
-    const GridGeometry* fvGridGeometryPtr_;
+    const GridGeometry* gridGeometryPtr_;
 
     GridIndexType eIdx_;
 };
@@ -188,8 +188,8 @@ public:
     static constexpr std::size_t maxNumElementScvs = (1<<dim);
 
     //! Constructor
-    BoxFacetCouplingFVElementGeometry(const FVGridGeometry& fvGridGeometry)
-    : fvGridGeometryPtr_(&fvGridGeometry)
+    BoxFacetCouplingFVElementGeometry(const GridGeometry& gridGeometry)
+    : gridGeometryPtr_(&gridGeometry)
     {}
 
     //! Get a sub control volume with a local scv index
@@ -254,13 +254,13 @@ public:
     }
 
     //! The global finite volume geometry we are a restriction of
-    [[deprecated("Use more general GridGeometry instead. FVGridGeometry will be removed after 3.1!")]]
+    [[deprecated("Use gridGeometry() instead. fvGridGeometry() will be removed after 3.1!")]]
     const GridGeometry& fvGridGeometry() const
-    { return *fvGridGeometryPtr_; }
+    { return *gridGeometryPtr_; }
 
     //! The global finite volume geometry we are a restriction of
     const GridGeometry& gridGeometry() const
-    { return *fvGridGeometryPtr_; }
+    { return *gridGeometryPtr_; }
 
 private:
 
@@ -358,7 +358,7 @@ private:
     GridIndexType eIdx_;
 
     //! The global geometry this is a restriction of
-    const FVGridGeometry* fvGridGeometryPtr_;
+    const GridGeometry* gridGeometryPtr_;
 
     //! vectors to store the geometries locally after binding an element
     std::vector<SubControlVolume> scvs_;
diff --git a/dumux/multidomain/facet/box/fvgridgeometry.hh b/dumux/multidomain/facet/box/fvgridgeometry.hh
index c8385ecabdf709a4a4ee5f763c36abfccf0a79ec..3569aac8d05ff2f0e7a49b4385a78916851488eb 100644
--- a/dumux/multidomain/facet/box/fvgridgeometry.hh
+++ b/dumux/multidomain/facet/box/fvgridgeometry.hh
@@ -59,8 +59,8 @@ struct BoxFacetCouplingDefaultGridGeometryTraits
     using SubControlVolume = BoxSubControlVolume<GridView>;
     using SubControlVolumeFace = BoxFacetCouplingSubControlVolumeFace<GridView>;
 
-    template<class FVGridGeometry, bool enableCache>
-    using LocalView = BoxFacetCouplingFVElementGeometry<FVGridGeometry, enableCache>;
+    template<class GridGeometry, bool enableCache>
+    using LocalView = BoxFacetCouplingFVElementGeometry<GridGeometry, enableCache>;
 
     // per default we use an mcmg mapper for the elements
     using ElementMapper = Dune::MultipleCodimMultipleGeomTypeMapper<GridView>;
diff --git a/dumux/multidomain/facet/box/upwindscheme.hh b/dumux/multidomain/facet/box/upwindscheme.hh
index 8ce7d7f19d3feb12ab2a4c9e43593f1f7da320e3..f03dbb2744823d6f5c3a781f8c837842039c89b6 100644
--- a/dumux/multidomain/facet/box/upwindscheme.hh
+++ b/dumux/multidomain/facet/box/upwindscheme.hh
@@ -36,7 +36,7 @@ namespace Dumux {
  *        This is a modified scheme for models involving coupling
  *        with a lower-dimensional domain across the element facets.
  */
-template<class FVGridGeometry>
+template<class GridGeometry>
 class BoxFacetCouplingUpwindScheme
 {
 public:
diff --git a/dumux/multidomain/facet/cellcentered/localresidual.hh b/dumux/multidomain/facet/cellcentered/localresidual.hh
index 46da82281d6d6774d45f7d3828be31feb873cb7e..77819a5918fbe23c97643c724bed83c2a65e52d1 100644
--- a/dumux/multidomain/facet/cellcentered/localresidual.hh
+++ b/dumux/multidomain/facet/cellcentered/localresidual.hh
@@ -48,10 +48,10 @@ class CCFacetCouplingLocalResidual : public CCLocalResidual<TypeTag>
     using ElementVolumeVariables = typename GridVariables::GridVolumeVariables::LocalView;
     using ElementFluxVariablesCache = typename GridVariables::GridFluxVariablesCache::LocalView;
 
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
 
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
 
diff --git a/dumux/multidomain/facet/cellcentered/mpfa/couplingmanager.hh b/dumux/multidomain/facet/cellcentered/mpfa/couplingmanager.hh
index 1b667da08f5bc0fe76183db2c2fb9a2dca05224a..73c1707a4d6af0a73a191b30e91520392956e466 100644
--- a/dumux/multidomain/facet/cellcentered/mpfa/couplingmanager.hh
+++ b/dumux/multidomain/facet/cellcentered/mpfa/couplingmanager.hh
@@ -69,11 +69,11 @@ class FacetCouplingManager<MDTraits, CouplingMapper, bulkDomainId, lowDimDomainI
     template<std::size_t id> using Scalar = GetPropType<SubDomainTypeTag<id>, Properties::Scalar>;
     template<std::size_t id> using Problem = GetPropType<SubDomainTypeTag<id>, Properties::Problem>;
     template<std::size_t id> using NumEqVector = GetPropType<SubDomainTypeTag<id>, Properties::NumEqVector>;
-    template<std::size_t id> using FVGridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
-    template<std::size_t id> using FVElementGeometry = typename FVGridGeometry<id>::LocalView;
-    template<std::size_t id> using SubControlVolume = typename FVGridGeometry<id>::SubControlVolume;
-    template<std::size_t id> using SubControlVolumeFace = typename FVGridGeometry<id>::SubControlVolumeFace;
-    template<std::size_t id> using GridView = typename FVGridGeometry<id>::GridView;
+    template<std::size_t id> using GridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
+    template<std::size_t id> using FVElementGeometry = typename GridGeometry<id>::LocalView;
+    template<std::size_t id> using SubControlVolume = typename GridGeometry<id>::SubControlVolume;
+    template<std::size_t id> using SubControlVolumeFace = typename GridGeometry<id>::SubControlVolumeFace;
+    template<std::size_t id> using GridView = typename GridGeometry<id>::GridView;
     template<std::size_t id> using GridIndexType = typename IndexTraits< GridView<id> >::GridIndex;
     template<std::size_t id> using Element = typename GridView<id>::template Codim<0>::Entity;
     template<std::size_t id> using LocalResidual = GetPropType<SubDomainTypeTag<id>, Properties::LocalResidual>;
@@ -88,7 +88,7 @@ class FacetCouplingManager<MDTraits, CouplingMapper, bulkDomainId, lowDimDomainI
     static constexpr auto bulkGridId = CouplingMapper::template gridId<bulkDim>();
     static constexpr auto lowDimGridId = CouplingMapper::template gridId<lowDimDim>();
 
-    static constexpr bool lowDimUsesBox = FVGridGeometry<lowDimId>::discMethod == DiscretizationMethod::box;
+    static constexpr bool lowDimUsesBox = GridGeometry<lowDimId>::discMethod == DiscretizationMethod::box;
 
 public:
 
diff --git a/dumux/multidomain/facet/cellcentered/tpfa/couplingmanager.hh b/dumux/multidomain/facet/cellcentered/tpfa/couplingmanager.hh
index 24b29a478b5a2091c7ebb599db7c7b2192b84482..19fca678a62f42656425f09dd2e7f29f1b994be1 100644
--- a/dumux/multidomain/facet/cellcentered/tpfa/couplingmanager.hh
+++ b/dumux/multidomain/facet/cellcentered/tpfa/couplingmanager.hh
@@ -68,11 +68,11 @@ class FacetCouplingManager<MDTraits, CouplingMapper, bulkDomainId, lowDimDomainI
     template<std::size_t id> using NumEqVector = GetPropType<SubDomainTypeTag<id>, Properties::NumEqVector>;
     template<std::size_t id> using LocalResidual = GetPropType<SubDomainTypeTag<id>, Properties::LocalResidual>;
 
-    template<std::size_t id> using FVGridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
-    template<std::size_t id> using FVElementGeometry = typename FVGridGeometry<id>::LocalView;
-    template<std::size_t id> using SubControlVolume = typename FVGridGeometry<id>::SubControlVolume;
-    template<std::size_t id> using SubControlVolumeFace = typename FVGridGeometry<id>::SubControlVolumeFace;
-    template<std::size_t id> using GridView = typename FVGridGeometry<id>::GridView;
+    template<std::size_t id> using GridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
+    template<std::size_t id> using FVElementGeometry = typename GridGeometry<id>::LocalView;
+    template<std::size_t id> using SubControlVolume = typename GridGeometry<id>::SubControlVolume;
+    template<std::size_t id> using SubControlVolumeFace = typename GridGeometry<id>::SubControlVolumeFace;
+    template<std::size_t id> using GridView = typename GridGeometry<id>::GridView;
     template<std::size_t id> using Element = typename GridView<id>::template Codim<0>::Entity;
     template<std::size_t id> using GridIndexType = typename IndexTraits< GridView<id> >::GridIndex;
 
@@ -97,7 +97,7 @@ class FacetCouplingManager<MDTraits, CouplingMapper, bulkDomainId, lowDimDomainI
     static constexpr auto bulkGridId = CouplingMapper::template gridId<bulkDim>();
     static constexpr auto lowDimGridId = CouplingMapper::template gridId<lowDimDim>();
 
-    static constexpr bool lowDimUsesBox = FVGridGeometry<lowDimId>::discMethod == DiscretizationMethod::box;
+    static constexpr bool lowDimUsesBox = GridGeometry<lowDimId>::discMethod == DiscretizationMethod::box;
 
     /*!
      * \brief The coupling context of the bulk domain. Contains all data of the lower-
diff --git a/dumux/multidomain/facet/cellcentered/tpfa/darcyslaw.hh b/dumux/multidomain/facet/cellcentered/tpfa/darcyslaw.hh
index fe782aba49f00d91c4bdd810a520826b936f3560..27d5265961636f8af9b36c12502430e21bae1c99 100644
--- a/dumux/multidomain/facet/cellcentered/tpfa/darcyslaw.hh
+++ b/dumux/multidomain/facet/cellcentered/tpfa/darcyslaw.hh
@@ -42,7 +42,7 @@
 namespace Dumux {
 
 //! Forward declaration of the implementation
-template<class ScalarType, class FVGridGeometry, bool isNetwork>
+template<class ScalarType, class GridGeometry, bool isNetwork>
 class CCTpfaFacetCouplingDarcysLawImpl;
 
 /*!
@@ -51,7 +51,7 @@ class CCTpfaFacetCouplingDarcysLawImpl;
  * \note We distinguish between network and non-network grids here. Specializations
  *       for the two cases can be found below.
  */
-template<class AdvectionType, class FVGridGeometry, bool isNetwork>
+template<class AdvectionType, class GridGeometry, bool isNetwork>
 class CCTpfaFacetCouplingDarcysLawCache;
 
 /*!
@@ -60,26 +60,26 @@ class CCTpfaFacetCouplingDarcysLawCache;
  *        in the context of coupled models where the coupling occurs across the facets of the bulk
  *        domain elements with a lower-dimensional domain living on these facets.
  */
-template<class ScalarType, class FVGridGeometry>
+template<class ScalarType, class GridGeometry>
 using CCTpfaFacetCouplingDarcysLaw =
-      CCTpfaFacetCouplingDarcysLawImpl< ScalarType, FVGridGeometry, ( int(FVGridGeometry::GridView::dimension) <
-                                                                      int(FVGridGeometry::GridView::dimensionworld) ) >;
+      CCTpfaFacetCouplingDarcysLawImpl< ScalarType, GridGeometry, ( int(GridGeometry::GridView::dimension) <
+                                                                      int(GridGeometry::GridView::dimensionworld) ) >;
 
 /*!
  * \ingroup FacetCoupling
  * \brief Specialization of the FacetCouplingTpfaDarcysLawCache for non-network grids.
  */
-template<class AdvectionType, class FVGridGeometry>
-class CCTpfaFacetCouplingDarcysLawCache<AdvectionType, FVGridGeometry, /*isNetwork*/false>
+template<class AdvectionType, class GridGeometry>
+class CCTpfaFacetCouplingDarcysLawCache<AdvectionType, GridGeometry, /*isNetwork*/false>
 {
     using Scalar = typename AdvectionType::Scalar;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
 
 public:
     //! export the corresponding filler class
-    using Filler = TpfaDarcysLawCacheFiller<FVGridGeometry>;
+    using Filler = TpfaDarcysLawCacheFiller<GridGeometry>;
 
     //! we store the transmissibilities associated with the interior
     //! cell, outside cell, and the fracture facet in an array. Access
@@ -137,17 +137,17 @@ private:
  * \ingroup FacetCoupling
  * \brief Specialization of the CCTpfaDarcysLaw grids where dim=dimWorld
  */
-template<class ScalarType, class FVGridGeometry>
-class CCTpfaFacetCouplingDarcysLawImpl<ScalarType, FVGridGeometry, /*isNetwork*/false>
+template<class ScalarType, class GridGeometry>
+class CCTpfaFacetCouplingDarcysLawImpl<ScalarType, GridGeometry, /*isNetwork*/false>
 {
-    using ThisType = CCTpfaFacetCouplingDarcysLawImpl<ScalarType, FVGridGeometry, false>;
-    using TpfaDarcysLaw = CCTpfaDarcysLaw<ScalarType, FVGridGeometry, false>;
+    using ThisType = CCTpfaFacetCouplingDarcysLawImpl<ScalarType, GridGeometry, false>;
+    using TpfaDarcysLaw = CCTpfaDarcysLaw<ScalarType, GridGeometry, false>;
 
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
 
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -168,7 +168,7 @@ class CCTpfaFacetCouplingDarcysLawImpl<ScalarType, FVGridGeometry, /*isNetwork*/
     //! export the discretization method this implementation belongs to
     static const DiscretizationMethod discMethod = DiscretizationMethod::cctpfa;
     //! export the type for the corresponding cache
-    using Cache = CCTpfaFacetCouplingDarcysLawCache<ThisType, FVGridGeometry, /*isNetwork*/false>;
+    using Cache = CCTpfaFacetCouplingDarcysLawCache<ThisType, GridGeometry, /*isNetwork*/false>;
     //! export the type used to store transmissibilities
     using TijContainer = typename Cache::AdvectionTransmissibilityContainer;
 
@@ -355,17 +355,17 @@ class CCTpfaFacetCouplingDarcysLawImpl<ScalarType, FVGridGeometry, /*isNetwork*/
  * \ingroup FacetCoupling
  * \brief Specialization of the FacetCouplingTpfaDarcysLawCache for network grids
  */
-template<class AdvectionType, class FVGridGeometry>
-class CCTpfaFacetCouplingDarcysLawCache<AdvectionType, FVGridGeometry, /*isNetwork*/true>
+template<class AdvectionType, class GridGeometry>
+class CCTpfaFacetCouplingDarcysLawCache<AdvectionType, GridGeometry, /*isNetwork*/true>
 {
     using Scalar = typename AdvectionType::Scalar;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
 
 public:
     //! export the corresponding filler class
-    using Filler = TpfaDarcysLawCacheFiller<FVGridGeometry>;
+    using Filler = TpfaDarcysLawCacheFiller<GridGeometry>;
 
     //! we store the transmissibilities associated with the interior
     //! cell and the fracture facet in an array. Access to this array
@@ -410,17 +410,17 @@ private:
  * \ingroup FacetCoupling
  * \brief Specialization of the CCTpfaDarcysLaw grids where dim<dimWorld
  */
-template<class ScalarType, class FVGridGeometry>
-class CCTpfaFacetCouplingDarcysLawImpl<ScalarType, FVGridGeometry, /*isNetwork*/true>
+template<class ScalarType, class GridGeometry>
+class CCTpfaFacetCouplingDarcysLawImpl<ScalarType, GridGeometry, /*isNetwork*/true>
 {
-    using ThisType = CCTpfaFacetCouplingDarcysLawImpl<ScalarType, FVGridGeometry, true>;
-    using TpfaDarcysLaw = CCTpfaDarcysLaw<ScalarType, FVGridGeometry, true>;
+    using ThisType = CCTpfaFacetCouplingDarcysLawImpl<ScalarType, GridGeometry, true>;
+    using TpfaDarcysLaw = CCTpfaDarcysLaw<ScalarType, GridGeometry, true>;
 
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
 
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -430,7 +430,7 @@ class CCTpfaFacetCouplingDarcysLawImpl<ScalarType, FVGridGeometry, /*isNetwork*/
     //! state the discretization method this implementation belongs to
     static const DiscretizationMethod discMethod = DiscretizationMethod::cctpfa;
     //! state the type for the corresponding cache
-    using Cache = CCTpfaFacetCouplingDarcysLawCache<ThisType, FVGridGeometry, /*isNetwork*/true>;
+    using Cache = CCTpfaFacetCouplingDarcysLawCache<ThisType, GridGeometry, /*isNetwork*/true>;
     //! export the type used to store transmissibilities
     using TijContainer = typename Cache::AdvectionTransmissibilityContainer;
 
diff --git a/dumux/multidomain/facet/cellcentered/upwindscheme.hh b/dumux/multidomain/facet/cellcentered/upwindscheme.hh
index cfe8f1d87572c1833462c3504088d12f356c8ea8..c19bfb17c225730d4128a2bee7759cf304224580 100644
--- a/dumux/multidomain/facet/cellcentered/upwindscheme.hh
+++ b/dumux/multidomain/facet/cellcentered/upwindscheme.hh
@@ -37,10 +37,10 @@ namespace Dumux {
  *        This is a modified scheme for models involving coupling
  *        with a lower-dimensional domain across the element facets.
  */
-template<class FVGridGeometry>
+template<class GridGeometry>
 class CCFacetCouplingUpwindScheme
 {
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     static constexpr int dim = GridView::dimension;
     static constexpr int dimWorld = GridView::dimensionworld;
 
diff --git a/dumux/multidomain/facet/couplingmanager.hh b/dumux/multidomain/facet/couplingmanager.hh
index 77860003fcfa9bbae892b119c41a12472b3edf7f..03b2ea07b3bff7690f09fc33a4aef932f7d9ade2 100644
--- a/dumux/multidomain/facet/couplingmanager.hh
+++ b/dumux/multidomain/facet/couplingmanager.hh
@@ -134,10 +134,10 @@ class FacetCouplingThreeDomainManager
     template<std::size_t id> using PrimaryVariables = GetPropType<SubDomainTypeTag<id>, Properties::PrimaryVariables>;
     template<std::size_t id> using Problem = GetPropType<SubDomainTypeTag<id>, Properties::Problem>;
 
-    template<std::size_t id> using FVGridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
-    template<std::size_t id> using FVElementGeometry = typename FVGridGeometry<id>::LocalView;
-    template<std::size_t id> using SubControlVolumeFace = typename FVGridGeometry<id>::SubControlVolumeFace;
-    template<std::size_t id> using GridView = typename FVGridGeometry<id>::GridView;
+    template<std::size_t id> using GridGeometry = GetPropType<SubDomainTypeTag<id>, Properties::GridGeometry>;
+    template<std::size_t id> using FVElementGeometry = typename GridGeometry<id>::LocalView;
+    template<std::size_t id> using SubControlVolumeFace = typename GridGeometry<id>::SubControlVolumeFace;
+    template<std::size_t id> using GridView = typename GridGeometry<id>::GridView;
     template<std::size_t id> using GridIndexType = typename IndexTraits<GridView<id>>::GridIndex;
     template<std::size_t id> using Element = typename GridView<id>::template Codim<0>::Entity;
 
@@ -148,7 +148,7 @@ class FacetCouplingThreeDomainManager
     // helper function to check if a domain uses mpfa
     template<std::size_t id>
     static constexpr bool usesMpfa(Dune::index_constant<id> domainId)
-    { return FVGridGeometry<domainId>::discMethod == DiscretizationMethod::ccmpfa; }
+    { return GridGeometry<domainId>::discMethod == DiscretizationMethod::ccmpfa; }
 
 public:
     //! types used for coupling stencils
diff --git a/dumux/multidomain/facet/couplingmapperbase.hh b/dumux/multidomain/facet/couplingmapperbase.hh
index 42aab8a65835ef867996400348e34dba62d41d79..df6bac359a754475e67a5026f2c37b14bb5a1b41 100644
--- a/dumux/multidomain/facet/couplingmapperbase.hh
+++ b/dumux/multidomain/facet/couplingmapperbase.hh
@@ -205,18 +205,18 @@ protected:
     }
 
     //! Creates a container with the nodal dofs within an element
-    template< class FVGridGeometry>
-    std::vector< typename IndexTraits<typename FVGridGeometry::GridView>::GridIndex >
-    extractNodalDofs_(const typename FVGridGeometry::GridView::template Codim<0>::Entity& element,
-                      const FVGridGeometry& fvGridGeometry)
+    template< class GridGeometry>
+    std::vector< typename IndexTraits<typename GridGeometry::GridView>::GridIndex >
+    extractNodalDofs_(const typename GridGeometry::GridView::template Codim<0>::Entity& element,
+                      const GridGeometry& gridGeometry)
     {
-        static constexpr int dim = FVGridGeometry::GridView::dimension;
-        using GridIndexType = typename IndexTraits<typename FVGridGeometry::GridView>::GridIndex;
+        static constexpr int dim = GridGeometry::GridView::dimension;
+        using GridIndexType = typename IndexTraits<typename GridGeometry::GridView>::GridIndex;
 
         const auto numCorners = element.subEntities(dim);
         std::vector< GridIndexType > nodalDofs(numCorners);
         for (unsigned int i = 0; i < numCorners; ++i)
-            nodalDofs[i] = fvGridGeometry.vertexMapper().subIndex(element, i, dim);
+            nodalDofs[i] = gridGeometry.vertexMapper().subIndex(element, i, dim);
 
         return nodalDofs;
     }
@@ -232,15 +232,15 @@ protected:
 private:
 
     //! Creates the map from element insertion index to grid element index
-    template< class Embeddings, class FVGridGeometry>
-    std::unordered_map< typename IndexTraits<typename FVGridGeometry::GridView>::GridIndex, typename IndexTraits<typename FVGridGeometry::GridView>::GridIndex >
-    makeInsertionToGridIndexMap_(std::shared_ptr<const Embeddings> embeddings, const FVGridGeometry& fvGridGeometry) const
+    template< class Embeddings, class GridGeometry>
+    std::unordered_map< typename IndexTraits<typename GridGeometry::GridView>::GridIndex, typename IndexTraits<typename GridGeometry::GridView>::GridIndex >
+    makeInsertionToGridIndexMap_(std::shared_ptr<const Embeddings> embeddings, const GridGeometry& gridGeometry) const
     {
-        using GridIndexType = typename IndexTraits<typename FVGridGeometry::GridView>::GridIndex;
+        using GridIndexType = typename IndexTraits<typename GridGeometry::GridView>::GridIndex;
 
         std::unordered_map< GridIndexType, GridIndexType > map;
-        for (const auto& e : elements(fvGridGeometry.gridView()))
-            map.insert( std::make_pair( embeddings->template insertionIndex<bulkId>(e), fvGridGeometry.elementMapper().index(e) ) );
+        for (const auto& e : elements(gridGeometry.gridView()))
+            map.insert( std::make_pair( embeddings->template insertionIndex<bulkId>(e), gridGeometry.elementMapper().index(e) ) );
 
         return map;
     }
diff --git a/dumux/multidomain/fvassembler.hh b/dumux/multidomain/fvassembler.hh
index 35952200565c2c81408da7d3f4ddbb83faf26470..13cf56370a65105b1aa3a72b46f543b1ac29d6be 100644
--- a/dumux/multidomain/fvassembler.hh
+++ b/dumux/multidomain/fvassembler.hh
@@ -96,7 +96,7 @@ public:
 private:
 
     using ProblemTuple = typename MDTraits::template TupleOfSharedPtrConst<Problem>;
-    using FVGridGeometryTuple = typename MDTraits::template TupleOfSharedPtrConst<FVGridGeometry>;
+    using GridGeometryTuple = typename MDTraits::template TupleOfSharedPtrConst<GridGeometry>;
     using GridVariablesTuple = typename MDTraits::template TupleOfSharedPtr<GridVariables>;
 
     using TimeLoop = TimeLoopBase<Scalar>;
@@ -130,7 +130,7 @@ private:
     };
 
     template<std::size_t id>
-    using SubDomainAssembler = typename SubDomainAssemblerType<FVGridGeometry<id>::discMethod, id>::type;
+    using SubDomainAssembler = typename SubDomainAssemblerType<GridGeometry<id>::discMethod, id>::type;
 
 public:
 
@@ -141,12 +141,12 @@ public:
      *       it is however guaranteed that the state after assembly will be the same as before
      */
     MultiDomainFVAssembler(ProblemTuple&& problem,
-                           FVGridGeometryTuple&& fvGridGeometry,
+                           GridGeometryTuple&& gridGeometry,
                            GridVariablesTuple&& gridVariables,
                            std::shared_ptr<CouplingManager> couplingManager)
     : couplingManager_(couplingManager)
     , problemTuple_(problem)
-    , fvGridGeometryTuple_(fvGridGeometry)
+    , gridGeometryTuple_(gridGeometry)
     , gridVariablesTuple_(gridVariables)
     , timeLoop_()
     , isStationaryProblem_(true)
@@ -161,13 +161,13 @@ public:
      */
     [[deprecated("Please use constructor taking the previous solution instead. Will be removed after release 3.2!")]]
     MultiDomainFVAssembler(ProblemTuple&& problem,
-                           FVGridGeometryTuple&& fvGridGeometry,
+                           GridGeometryTuple&& gridGeometry,
                            GridVariablesTuple&& gridVariables,
                            std::shared_ptr<CouplingManager> couplingManager,
                            std::shared_ptr<const TimeLoop> timeLoop)
     : couplingManager_(couplingManager)
     , problemTuple_(problem)
-    , fvGridGeometryTuple_(fvGridGeometry)
+    , gridGeometryTuple_(gridGeometry)
     , gridVariablesTuple_(gridVariables)
     , timeLoop_(timeLoop)
     , isStationaryProblem_(false)
@@ -181,14 +181,14 @@ public:
      *       it is however guaranteed that the state after assembly will be the same as before
      */
     MultiDomainFVAssembler(ProblemTuple&& problem,
-                           FVGridGeometryTuple&& fvGridGeometry,
+                           GridGeometryTuple&& gridGeometry,
                            GridVariablesTuple&& gridVariables,
                            std::shared_ptr<CouplingManager> couplingManager,
                            std::shared_ptr<const TimeLoop> timeLoop,
                            const SolutionVector& prevSol)
     : couplingManager_(couplingManager)
     , problemTuple_(problem)
-    , fvGridGeometryTuple_(fvGridGeometry)
+    , gridGeometryTuple_(gridGeometry)
     , gridVariablesTuple_(gridVariables)
     , timeLoop_(timeLoop)
     , prevSol_(&prevSol)
@@ -351,7 +351,7 @@ public:
     //! the number of dof locations of domain i
     template<std::size_t i>
     std::size_t numDofs(Dune::index_constant<i> domainId) const
-    { return std::get<domainId>(fvGridGeometryTuple_)->numDofs(); }
+    { return std::get<domainId>(gridGeometryTuple_)->numDofs(); }
 
     //! the problem of domain i
     template<std::size_t i>
@@ -367,7 +367,7 @@ public:
     //! the finite volume grid geometry of domain i
     template<std::size_t i>
     const auto& gridGeometry(Dune::index_constant<i> domainId) const
-    { return *std::get<domainId>(fvGridGeometryTuple_); }
+    { return *std::get<domainId>(gridGeometryTuple_); }
 
     //! the grid view of domain i
     template<std::size_t i>
@@ -529,7 +529,7 @@ private:
     ProblemTuple problemTuple_;
 
     //! the finite volume geometry of the grid
-    FVGridGeometryTuple fvGridGeometryTuple_;
+    GridGeometryTuple gridGeometryTuple_;
 
     //! the variables container for the grid
     GridVariablesTuple gridVariablesTuple_;
diff --git a/dumux/multidomain/newtonsolver.hh b/dumux/multidomain/newtonsolver.hh
index c9daad5580fdb720774ab119502175f49b482e1f..5d555124041799c3fcadaad06b72f36dba872df1 100644
--- a/dumux/multidomain/newtonsolver.hh
+++ b/dumux/multidomain/newtonsolver.hh
@@ -165,9 +165,9 @@ private:
         priVarsSwitchedInLastIteration_[i] = false;
 
         const auto& problem = this->assembler().problem(id);
-        const auto& fvGridGeometry = this->assembler().gridGeometry(id);
+        const auto& gridGeometry = this->assembler().gridGeometry(id);
         auto& gridVariables = this->assembler().gridVariables(id);
-        priVarSwitch.updateBoundary(problem, fvGridGeometry, gridVariables, sol[id]);
+        priVarSwitch.updateBoundary(problem, gridGeometry, gridVariables, sol[id]);
     }
 
     /*!
@@ -184,7 +184,7 @@ private:
     {
         // update the variable switch (returns true if the pri vars at at least one dof were switched)
         // for disabled grid variable caching
-        const auto& fvGridGeometry = this->assembler().gridGeometry(id);
+        const auto& gridGeometry = this->assembler().gridGeometry(id);
         const auto& problem = this->assembler().problem(id);
         auto& gridVariables = this->assembler().gridVariables(id);
 
@@ -193,17 +193,17 @@ private:
 
         // invoke the primary variable switch
         priVarsSwitchedInLastIteration_[i] = priVarSwitch.update(uCurrentIter, gridVariables,
-                                                                 problem, fvGridGeometry);
+                                                                 problem, gridGeometry);
 
         if (priVarsSwitchedInLastIteration_[i])
         {
-            for (const auto& element : elements(fvGridGeometry.gridView()))
+            for (const auto& element : elements(gridGeometry.gridView()))
             {
                 // if the volume variables are cached globally, we need to update those where the primary variables have been switched
-                priVarSwitch.updateSwitchedVolVars(problem, element, fvGridGeometry, gridVariables, uCurrentIter);
+                priVarSwitch.updateSwitchedVolVars(problem, element, gridGeometry, gridVariables, uCurrentIter);
 
                 // if the flux variables are cached globally, we need to update those where the primary variables have been switched
-                priVarSwitch.updateSwitchedFluxVarsCache(problem, element, fvGridGeometry, gridVariables, uCurrentIter);
+                priVarSwitch.updateSwitchedFluxVarsCache(problem, element, gridGeometry, gridVariables, uCurrentIter);
             }
         }
     }
diff --git a/dumux/multidomain/staggeredcouplingmanager.hh b/dumux/multidomain/staggeredcouplingmanager.hh
index e154281c79984717349e1121449321c3676bdf62..fe75d64c4fd47cedc178f2ef007669da58587563 100644
--- a/dumux/multidomain/staggeredcouplingmanager.hh
+++ b/dumux/multidomain/staggeredcouplingmanager.hh
@@ -42,10 +42,10 @@ class StaggeredCouplingManager: virtual public CouplingManager<MDTraits>
 {
     using ParentType = CouplingManager<MDTraits>;
 
-    template<std::size_t id> using FVGridGeometry = typename MDTraits::template SubDomain<id>::GridGeometry;
-    template<std::size_t id> using GridView = typename FVGridGeometry<id>::GridView;
+    template<std::size_t id> using GridGeometry = typename MDTraits::template SubDomain<id>::GridGeometry;
+    template<std::size_t id> using GridView = typename GridGeometry<id>::GridView;
 
-    using FVElementGeometry = typename FVGridGeometry<0>::LocalView;
+    using FVElementGeometry = typename GridGeometry<0>::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using Element = typename GridView<0>::template Codim<0>::Entity;
 
@@ -58,8 +58,8 @@ public:
 
     using Traits = MDTraits;
 
-    static constexpr auto cellCenterIdx = FVGridGeometry<0>::cellCenterIdx();
-    static constexpr auto faceIdx = FVGridGeometry<0>::faceIdx();
+    static constexpr auto cellCenterIdx = GridGeometry<0>::cellCenterIdx();
+    static constexpr auto faceIdx = GridGeometry<0>::faceIdx();
 
     /*!
      * \copydoc Dumux::CouplingManager::updateCouplingContext()
@@ -186,7 +186,7 @@ public:
      * \brief return the numeric epsilon used for deflecting primary variables of coupled domain i.
      * \note  specialization for non-staggered schemes
      */
-    template<std::size_t i, typename std::enable_if_t<(FVGridGeometry<i>::discMethod != DiscretizationMethod::staggered), int> = 0>
+    template<std::size_t i, typename std::enable_if_t<(GridGeometry<i>::discMethod != DiscretizationMethod::staggered), int> = 0>
     decltype(auto) numericEpsilon(Dune::index_constant<i> id,
                                   const std::string& paramGroup) const
     {
@@ -197,13 +197,13 @@ public:
      * \brief return the numeric epsilon used for deflecting primary variables of coupled domain i.
      * \note  specialization for non-staggered schemes
      */
-    template<std::size_t i, typename std::enable_if_t<(FVGridGeometry<i>::discMethod == DiscretizationMethod::staggered), int> = 0>
+    template<std::size_t i, typename std::enable_if_t<(GridGeometry<i>::discMethod == DiscretizationMethod::staggered), int> = 0>
     decltype(auto) numericEpsilon(Dune::index_constant<i>,
                                   const std::string& paramGroup) const
     {
         constexpr std::size_t numEqCellCenter = Traits::template SubDomain<cellCenterIdx>::PrimaryVariables::dimension;
         constexpr std::size_t numEqFace = Traits::template SubDomain<faceIdx>::PrimaryVariables::dimension;
-        constexpr bool isCellCenter = FVGridGeometry<i>::isCellCenter();
+        constexpr bool isCellCenter = GridGeometry<i>::isCellCenter();
         constexpr std::size_t numEq = isCellCenter ? numEqCellCenter : numEqFace;
         constexpr auto prefix = isCellCenter ? "CellCenter" : "Face";
 
diff --git a/dumux/multidomain/subdomainboxlocalassembler.hh b/dumux/multidomain/subdomainboxlocalassembler.hh
index f267475a6ff8c6fb1f82d95d8b76e73b5983c2d5..f8e068c60d7a475a2d3941f21d31bd6f2427458c 100644
--- a/dumux/multidomain/subdomainboxlocalassembler.hh
+++ b/dumux/multidomain/subdomainboxlocalassembler.hh
@@ -72,10 +72,10 @@ class SubDomainBoxLocalAssemblerBase : public FVLocalAssemblerBase<TypeTag, Asse
     using ElementFluxVariablesCache = typename GridVariables::GridFluxVariablesCache::LocalView;
     using Scalar = typename GridVariables::Scalar;
 
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
 
@@ -347,9 +347,9 @@ class SubDomainBoxLocalAssembler<id, TypeTag, Assembler, DiffMethod::numeric, /*
     using ElementResidualVector = typename ParentType::LocalResidual::ElementResidualVector;
 
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
 
     enum { numEq = GetPropType<TypeTag, Properties::ModelTraits>::numEq() };
@@ -582,9 +582,9 @@ class SubDomainBoxLocalAssembler<id, TypeTag, Assembler, DiffMethod::numeric, /*
     using VolumeVariables = GetPropType<TypeTag, Properties::VolumeVariables>;
     using ElementResidualVector = typename ParentType::LocalResidual::ElementResidualVector;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
 
     enum { numEq = GetPropType<TypeTag, Properties::ModelTraits>::numEq() };
diff --git a/dumux/multidomain/subdomaincclocalassembler.hh b/dumux/multidomain/subdomaincclocalassembler.hh
index e07c42fbf6e92b1cd87994ec5ca4de2f6860ee96..5d1dd8784d78d807b6dc73d5322c2ddfed4bfb0b 100644
--- a/dumux/multidomain/subdomaincclocalassembler.hh
+++ b/dumux/multidomain/subdomaincclocalassembler.hh
@@ -72,10 +72,10 @@ class SubDomainCCLocalAssemblerBase : public FVLocalAssemblerBase<TypeTag, Assem
     using ElementFluxVariablesCache = typename GridVariables::GridFluxVariablesCache::LocalView;
     using Scalar = typename GridVariables::Scalar;
 
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
 
@@ -284,9 +284,9 @@ class SubDomainCCLocalAssembler<id, TypeTag, Assembler, DiffMethod::numeric, /*i
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using LocalResidualValues = GetPropType<TypeTag, Properties::NumEqVector>;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
 
     enum { numEq = GetPropType<TypeTag, Properties::ModelTraits>::numEq() };
@@ -294,7 +294,7 @@ class SubDomainCCLocalAssembler<id, TypeTag, Assembler, DiffMethod::numeric, /*i
 
     static constexpr bool enableGridFluxVarsCache = getPropValue<TypeTag, Properties::EnableGridFluxVariablesCache>();
     static constexpr bool enableGridVolVarsCache = getPropValue<TypeTag, Properties::EnableGridVolumeVariablesCache>();
-    static constexpr int maxElementStencilSize = FVGridGeometry::maxElementStencilSize;
+    static constexpr int maxElementStencilSize = GridGeometry::maxElementStencilSize;
     static constexpr auto domainI = Dune::index_constant<id>();
 
 public:
@@ -318,13 +318,13 @@ public:
         // get some aliases for convenience
         const auto& element = this->element();
         const auto& fvGeometry = this->fvGeometry();
-        const auto& fvGridGeometry = fvGeometry.gridGeometry();
+        const auto& gridGeometry = fvGeometry.gridGeometry();
         auto&& curElemVolVars = this->curElemVolVars();
         auto&& elemFluxVarsCache = this->elemFluxVarsCache();
 
         // get stencil informations
-        const auto globalI = fvGridGeometry.elementMapper().index(element);
-        const auto& connectivityMap = fvGridGeometry.connectivityMap();
+        const auto globalI = gridGeometry.elementMapper().index(element);
+        const auto& connectivityMap = gridGeometry.connectivityMap();
         const auto numNeighbors = connectivityMap[globalI].size();
 
         // container to store the neighboring elements
@@ -341,7 +341,7 @@ public:
         unsigned int j = 1;
         for (const auto& dataJ : connectivityMap[globalI])
         {
-            neighborElements[j-1] = fvGridGeometry.element(dataJ.globalJ);
+            neighborElements[j-1] = gridGeometry.element(dataJ.globalJ);
             for (const auto scvfIdx : dataJ.scvfsJ)
                 origResiduals[j] += this->evalFluxResidual(neighborElements[j-1], fvGeometry.scvf(scvfIdx));
 
@@ -457,12 +457,12 @@ public:
         // get some aliases for convenience
         const auto& element = this->element();
         const auto& fvGeometry = this->fvGeometry();
-        const auto& fvGridGeometry = fvGeometry.gridGeometry();
+        const auto& gridGeometry = fvGeometry.gridGeometry();
         auto&& curElemVolVars = this->curElemVolVars();
         auto&& elemFluxVarsCache = this->elemFluxVarsCache();
 
         // get stencil informations
-        const auto globalI = fvGridGeometry.elementMapper().index(element);
+        const auto globalI = gridGeometry.elementMapper().index(element);
         const auto& stencil = this->couplingManager().couplingStencil(domainI, element, domainJ);
         const auto& curSolJ = this->curSol()[domainJ];
 
@@ -594,11 +594,11 @@ public:
         // get some aliases for convenience
         const auto& element = this->element();
         const auto& fvGeometry = this->fvGeometry();
-        const auto& fvGridGeometry = fvGeometry.gridGeometry();
+        const auto& gridGeometry = fvGeometry.gridGeometry();
         auto&& curElemVolVars = this->curElemVolVars();
 
         // reference to the element's scv (needed later) and corresponding vol vars
-        const auto globalI = fvGridGeometry.elementMapper().index(element);
+        const auto globalI = gridGeometry.elementMapper().index(element);
         const auto& scv = fvGeometry.scv(globalI);
         auto& curVolVars = ParentType::getVolVarAccess(gridVariables.curGridVolVars(), curElemVolVars, scv);
 
@@ -609,7 +609,7 @@ public:
         const auto origVolVars = curVolVars;
 
         // element solution container to be deflected
-        auto elemSol = elementSolution(element, curSol, fvGridGeometry);
+        auto elemSol = elementSolution(element, curSol, gridGeometry);
 
         // derivatives in the neighbors with repect to the current elements
         LocalResidualValues partialDeriv;
@@ -768,12 +768,12 @@ public:
         // get some aliases for convenience
         const auto& element = this->element();
         const auto& fvGeometry = this->fvGeometry();
-        const auto& fvGridGeometry = fvGeometry.gridGeometry();
+        const auto& gridGeometry = fvGeometry.gridGeometry();
         auto&& curElemVolVars = this->curElemVolVars();
         // auto&& elemFluxVarsCache = this->elemFluxVarsCache();
 
         // get stencil informations
-        const auto globalI = fvGridGeometry.elementMapper().index(element);
+        const auto globalI = gridGeometry.elementMapper().index(element);
         const auto& stencil = this->couplingManager().couplingStencil(domainI, element, domainJ);
 
         for (const auto globalJ : stencil)
diff --git a/dumux/multidomain/subdomainstaggeredlocalassembler.hh b/dumux/multidomain/subdomainstaggeredlocalassembler.hh
index faab9bebe8ac4f8dbd88f13b55e36fa7bc4e16c6..c14390b471022b42e6bec91a1159d02151c4cf1a 100644
--- a/dumux/multidomain/subdomainstaggeredlocalassembler.hh
+++ b/dumux/multidomain/subdomainstaggeredlocalassembler.hh
@@ -71,9 +71,9 @@ class SubDomainStaggeredLocalAssemblerBase : public FVLocalAssemblerBase<TypeTag
     using CellCenterResidualValue = typename LocalResidual::CellCenterResidualValue;
     using FaceResidualValue = typename LocalResidual::FaceResidualValue;
 
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
 
@@ -497,9 +497,9 @@ class SubDomainStaggeredLocalAssembler<id, TypeTag, Assembler, DiffMethod::numer
     using GridFaceVariables = GetPropType<TypeTag, Properties::GridFaceVariables>;
     using ElementFaceVariables = typename GetPropType<TypeTag, Properties::GridFaceVariables>::LocalView;
     using FaceVariables = typename ElementFaceVariables::FaceVariables;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
     using VolumeVariables = GetPropType<TypeTag, Properties::VolumeVariables>;
     using CellCenterPrimaryVariables = GetPropType<TypeTag, Properties::CellCenterPrimaryVariables>;
     using FacePrimaryVariables = GetPropType<TypeTag, Properties::FacePrimaryVariables>;
@@ -543,10 +543,10 @@ public:
         const auto& element = this->element();
         const auto& fvGeometry = this->fvGeometry();
         auto&& curElemVolVars = this->curElemVolVars();
-        const auto& fvGridGeometry = this->problem().gridGeometry();
+        const auto& gridGeometry = this->problem().gridGeometry();
         const auto& curSol = this->curSol()[domainI];
 
-        const auto cellCenterGlobalI = fvGridGeometry.elementMapper().index(element);
+        const auto cellCenterGlobalI = gridGeometry.elementMapper().index(element);
         const auto origResidual = this->evalLocalResidualForCellCenter();
 
         /////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -607,7 +607,7 @@ public:
         };
 
         // get the list of cell center dofs that have an influence on the cell center resdiual of the current element
-        const auto& connectivityMap = fvGridGeometry.connectivityMap();
+        const auto& connectivityMap = gridGeometry.connectivityMap();
 
         // evaluate derivatives w.r.t. own dof
         evaluateCellCenterDerivatives(cellCenterGlobalI);
@@ -634,7 +634,7 @@ public:
         const auto& problem = this->problem();
         const auto& element = this->element();
         const auto& fvGeometry = this->fvGeometry();
-        const auto& fvGridGeometry = this->problem().gridGeometry();
+        const auto& gridGeometry = this->problem().gridGeometry();
         const auto& curSol = this->curSol()[domainI];
 
         using FaceSolutionVector = GetPropType<TypeTag, Properties::FaceSolutionVector>; // TODO: use reserved vector
@@ -659,7 +659,7 @@ public:
             const auto faceGlobalI = scvf.dofIndex();
 
             using FaceSolution = GetPropType<TypeTag, Properties::StaggeredFaceSolution>;
-            const auto origFaceSolution = FaceSolution(scvf, curSol, fvGridGeometry);
+            const auto origFaceSolution = FaceSolution(scvf, curSol, gridGeometry);
 
             // Lambda to evaluate the derivatives for faces
             auto evaluateFaceDerivatives = [&](const std::size_t globalJ)
@@ -708,7 +708,7 @@ public:
             evaluateFaceDerivatives(scvf.dofIndex());
 
             // get the list of face dofs that have an influence on the resdiual of the current face
-            const auto& connectivityMap = fvGridGeometry.connectivityMap();
+            const auto& connectivityMap = gridGeometry.connectivityMap();
 
             // evaluate derivatives w.r.t. all other related face dofs
             for (const auto& globalJ : connectivityMap(faceId, faceId, scvf.index()))
@@ -735,10 +735,10 @@ public:
         // get some aliases for convenience
         const auto& element = this->element();
         const auto& fvGeometry = this->fvGeometry();
-        const auto& fvGridGeometry = this->problem().gridGeometry();
+        const auto& gridGeometry = this->problem().gridGeometry();
         const auto& curSol = this->curSol()[domainJ];
         // build derivatives with for cell center dofs w.r.t. cell center dofs
-        const auto cellCenterGlobalI = fvGridGeometry.elementMapper().index(element);
+        const auto cellCenterGlobalI = gridGeometry.elementMapper().index(element);
 
         for (const auto& scvfJ : scvfs(fvGeometry))
         {
@@ -857,8 +857,8 @@ public:
         // get some aliases for convenience
         const auto& problem = this->problem();
         const auto& fvGeometry = this->fvGeometry();
-        const auto& fvGridGeometry = this->problem().gridGeometry();
-        const auto& connectivityMap = fvGridGeometry.connectivityMap();
+        const auto& gridGeometry = this->problem().gridGeometry();
+        const auto& connectivityMap = gridGeometry.connectivityMap();
         const auto& curSol = this->curSol()[domainJ];
 
         // build derivatives with for cell center dofs w.r.t. cell center dofs
diff --git a/dumux/nonlinear/newtonconvergencewriter.hh b/dumux/nonlinear/newtonconvergencewriter.hh
index ac5c7cd78337281afb0253a4ea1758e2bf112aab..cadf82de45baa1cb862b1d1768bf5ccb8c54bcd3 100644
--- a/dumux/nonlinear/newtonconvergencewriter.hh
+++ b/dumux/nonlinear/newtonconvergencewriter.hh
@@ -50,29 +50,29 @@ struct ConvergenceWriterInterface
  *       to write out multiple Newton solves with a unique id, if you don't call use all
  *       Newton iterations just come after each other in the pvd file.
  */
-template <class FVGridGeometry, class SolutionVector>
+template <class GridGeometry, class SolutionVector>
 class NewtonConvergenceWriter : public ConvergenceWriterInterface<SolutionVector>
 {
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     static constexpr auto numEq = SolutionVector::block_type::dimension;
     using Scalar = typename SolutionVector::block_type::value_type;
 
-    static_assert(FVGridGeometry::discMethod != DiscretizationMethod::staggered,
+    static_assert(GridGeometry::discMethod != DiscretizationMethod::staggered,
                   "This convergence writer does not work for the staggered method, use the StaggeredNewtonConvergenceWriter instead");
 public:
     /*!
      * \brief Constructor
-     * \param fvGridGeometry The finite-volume grid geometry
+     * \param gridGeometry The finite-volume grid geometry
      * \param name Base name of the vtk output
      */
-    NewtonConvergenceWriter(const FVGridGeometry& fvGridGeometry,
+    NewtonConvergenceWriter(const GridGeometry& gridGeometry,
                             const std::string& name = "newton_convergence")
-    : fvGridGeometry_(fvGridGeometry)
-    , writer_(fvGridGeometry.gridView(), name, "", "")
+    : gridGeometry_(gridGeometry)
+    , writer_(gridGeometry.gridView(), name, "", "")
     {
         resize();
 
-        if (FVGridGeometry::discMethod == DiscretizationMethod::box)
+        if (GridGeometry::discMethod == DiscretizationMethod::box)
         {
             for (int eqIdx = 0; eqIdx < numEq; ++eqIdx)
             {
@@ -95,7 +95,7 @@ public:
     //! Resizes the output fields. This has to be called whenever the grid changes
     void resize()
     {
-        const auto numDofs = fvGridGeometry_.numDofs();
+        const auto numDofs = gridGeometry_.numDofs();
 
         // resize the output fields
         for (int eqIdx = 0; eqIdx < numEq; ++eqIdx)
@@ -135,7 +135,7 @@ private:
     std::size_t id_ = 0UL;
     std::size_t iteration_ = 0UL;
 
-    const FVGridGeometry& fvGridGeometry_;
+    const GridGeometry& gridGeometry_;
 
     Dune::VTKSequenceWriter<GridView> writer_;
 
diff --git a/dumux/nonlinear/newtonsolver.hh b/dumux/nonlinear/newtonsolver.hh
index 30660b5023079d8a2683049c073b0db3b62a6d95..823ede7e52180f9c4d859ee9afe24e1ce4274866 100644
--- a/dumux/nonlinear/newtonsolver.hh
+++ b/dumux/nonlinear/newtonsolver.hh
@@ -747,9 +747,9 @@ protected:
         priVarsSwitchedInLastIteration_ = false;
 
         const auto& problem = this->assembler().problem();
-        const auto& fvGridGeometry = this->assembler().gridGeometry();
+        const auto& gridGeometry = this->assembler().gridGeometry();
         auto& gridVariables = this->assembler().gridVariables();
-        priVarSwitch_->updateBoundary(problem, fvGridGeometry, gridVariables, sol);
+        priVarSwitch_->updateBoundary(problem, gridGeometry, gridVariables, sol);
     }
 
     /*!
@@ -764,23 +764,23 @@ protected:
     {
         // update the variable switch (returns true if the pri vars at at least one dof were switched)
         // for disabled grid variable caching
-        const auto& fvGridGeometry = this->assembler().gridGeometry();
+        const auto& gridGeometry = this->assembler().gridGeometry();
         const auto& problem = this->assembler().problem();
         auto& gridVariables = this->assembler().gridVariables();
 
         // invoke the primary variable switch
         priVarsSwitchedInLastIteration_ = priVarSwitch_->update(uCurrentIter, gridVariables,
-                                                                problem, fvGridGeometry);
+                                                                problem, gridGeometry);
 
         if (priVarsSwitchedInLastIteration_)
         {
-            for (const auto& element : elements(fvGridGeometry.gridView()))
+            for (const auto& element : elements(gridGeometry.gridView()))
             {
                 // if the volume variables are cached globally, we need to update those where the primary variables have been switched
-                priVarSwitch_->updateSwitchedVolVars(problem, element, fvGridGeometry, gridVariables, uCurrentIter);
+                priVarSwitch_->updateSwitchedVolVars(problem, element, gridGeometry, gridVariables, uCurrentIter);
 
                 // if the flux variables are cached globally, we need to update those where the primary variables have been switched
-                priVarSwitch_->updateSwitchedFluxVarsCache(problem, element, fvGridGeometry, gridVariables, uCurrentIter);
+                priVarSwitch_->updateSwitchedFluxVarsCache(problem, element, gridGeometry, gridVariables, uCurrentIter);
             }
         }
     }
diff --git a/dumux/nonlinear/staggerednewtonconvergencewriter.hh b/dumux/nonlinear/staggerednewtonconvergencewriter.hh
index 1cb85da200eb9be4485731a8dbe9d380b29e785c..251a6d53799180b522c930d120b0ad87b2cdff52 100644
--- a/dumux/nonlinear/staggerednewtonconvergencewriter.hh
+++ b/dumux/nonlinear/staggerednewtonconvergencewriter.hh
@@ -43,13 +43,13 @@ namespace Dumux {
  *       to write out multiple Newton solves with a unique id, if you don't call use all
  *       Newton iterations just come after each other in the pvd file.
  */
-template <class FVGridGeometry, class SolutionVector>
+template <class GridGeometry, class SolutionVector>
 class StaggeredNewtonConvergenceWriter : public ConvergenceWriterInterface<SolutionVector>
 {
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
 
-    using CellCenterSolutionVector = typename std::decay_t<decltype(std::declval<SolutionVector>()[FVGridGeometry::cellCenterIdx()])>;
-    using FaceSolutionVector = typename std::decay_t<decltype(std::declval<SolutionVector>()[FVGridGeometry::faceIdx()])>;
+    using CellCenterSolutionVector = typename std::decay_t<decltype(std::declval<SolutionVector>()[GridGeometry::cellCenterIdx()])>;
+    using FaceSolutionVector = typename std::decay_t<decltype(std::declval<SolutionVector>()[GridGeometry::faceIdx()])>;
 
     using Scalar = typename CellCenterSolutionVector::block_type::value_type;
 
@@ -59,22 +59,22 @@ class StaggeredNewtonConvergenceWriter : public ConvergenceWriterInterface<Solut
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
-    static_assert(FVGridGeometry::discMethod == DiscretizationMethod::staggered,
+    static_assert(GridGeometry::discMethod == DiscretizationMethod::staggered,
                   "This convergence writer does only work for the staggered method, use the NewtonConvergenceWriter instead");
 public:
     /*!
      * \brief Constructor
-     * \param fvGridGeometry The finite volume geometry on the grid view
+     * \param gridGeometry The finite volume geometry on the grid view
      * \param name Base name of the vtk output
      */
-    StaggeredNewtonConvergenceWriter(const FVGridGeometry& fvGridGeometry,
+    StaggeredNewtonConvergenceWriter(const GridGeometry& gridGeometry,
                                      const std::string& name = "newton_convergence")
-    : fvGridGeometry_(fvGridGeometry)
-    , ccWriter_(fvGridGeometry.gridView(), name, "", "")
+    : gridGeometry_(gridGeometry)
+    , ccWriter_(gridGeometry.gridView(), name, "", "")
     , faceWriter_(std::make_shared<PointCloudVtkWriter<Scalar, GlobalPosition>>(coordinates_))
     , faceSequenceWriter_(faceWriter_, name + "-face", "","",
-                          fvGridGeometry.gridView().comm().rank(),
-                          fvGridGeometry.gridView().comm().size())
+                          gridGeometry.gridView().comm().rank(),
+                          gridGeometry.gridView().comm().size())
     {
         resize();
 
@@ -89,8 +89,8 @@ public:
     //! Resizes the output fields. This has to be called whenever the grid changes
     void resize()
     {
-        const auto numCellCenterDofs = fvGridGeometry_.numCellCenterDofs();
-        const auto numFaceDofs = fvGridGeometry_.numFaceDofs();
+        const auto numCellCenterDofs = gridGeometry_.numCellCenterDofs();
+        const auto numFaceDofs = gridGeometry_.numFaceDofs();
 
         // resize the cell center output fields
         for (int eqIdx = 0; eqIdx < numEqCellCenter; ++eqIdx)
@@ -109,9 +109,9 @@ public:
         }
 
         coordinates_.resize(numFaceDofs);
-        for (auto&& facet : facets(fvGridGeometry_.gridView()))
+        for (auto&& facet : facets(gridGeometry_.gridView()))
         {
-            const auto dofIdxGlobal = fvGridGeometry_.gridView().indexSet().index(facet);
+            const auto dofIdxGlobal = gridGeometry_.gridView().indexSet().index(facet);
             coordinates_[dofIdxGlobal] = facet.geometry().center();
         }
     }
@@ -127,13 +127,13 @@ public:
     {
         assert(uLastIter.size() == deltaU.size() && uLastIter.size() == residual.size());
 
-        for (std::size_t dofIdxGlobal = 0; dofIdxGlobal < deltaU[FVGridGeometry::cellCenterIdx()].size(); ++dofIdxGlobal)
+        for (std::size_t dofIdxGlobal = 0; dofIdxGlobal < deltaU[GridGeometry::cellCenterIdx()].size(); ++dofIdxGlobal)
         {
             for (int eqIdx = 0; eqIdx < numEqCellCenter; ++eqIdx)
             {
-                xCellCenter_[eqIdx][dofIdxGlobal] = uLastIter[FVGridGeometry::cellCenterIdx()][dofIdxGlobal][eqIdx];
-                deltaCellCenter_[eqIdx][dofIdxGlobal] = - deltaU[FVGridGeometry::cellCenterIdx()][dofIdxGlobal][eqIdx];
-                defCellCenter_[eqIdx][dofIdxGlobal] = residual[FVGridGeometry::cellCenterIdx()][dofIdxGlobal][eqIdx];
+                xCellCenter_[eqIdx][dofIdxGlobal] = uLastIter[GridGeometry::cellCenterIdx()][dofIdxGlobal][eqIdx];
+                deltaCellCenter_[eqIdx][dofIdxGlobal] = - deltaU[GridGeometry::cellCenterIdx()][dofIdxGlobal][eqIdx];
+                defCellCenter_[eqIdx][dofIdxGlobal] = residual[GridGeometry::cellCenterIdx()][dofIdxGlobal][eqIdx];
             }
         }
 
@@ -144,13 +144,13 @@ public:
             faceWriter_->addPointData(defFace_[eqIdx], "defect_" + std::to_string(eqIdx));
         }
 
-        for (std::size_t dofIdxGlobal = 0; dofIdxGlobal < deltaU[FVGridGeometry::faceIdx()].size(); ++dofIdxGlobal)
+        for (std::size_t dofIdxGlobal = 0; dofIdxGlobal < deltaU[GridGeometry::faceIdx()].size(); ++dofIdxGlobal)
         {
             for (int eqIdx = 0; eqIdx < numEqFace; ++eqIdx)
             {
-                xFace_[eqIdx][dofIdxGlobal] = uLastIter[FVGridGeometry::faceIdx()][dofIdxGlobal][eqIdx];
-                deltaFace_[eqIdx][dofIdxGlobal] = - deltaU[FVGridGeometry::faceIdx()][dofIdxGlobal][eqIdx];
-                defFace_[eqIdx][dofIdxGlobal] = residual[FVGridGeometry::faceIdx()][dofIdxGlobal][eqIdx];
+                xFace_[eqIdx][dofIdxGlobal] = uLastIter[GridGeometry::faceIdx()][dofIdxGlobal][eqIdx];
+                deltaFace_[eqIdx][dofIdxGlobal] = - deltaU[GridGeometry::faceIdx()][dofIdxGlobal][eqIdx];
+                defFace_[eqIdx][dofIdxGlobal] = residual[GridGeometry::faceIdx()][dofIdxGlobal][eqIdx];
             }
         }
 
@@ -163,7 +163,7 @@ private:
     std::size_t id_ = 0UL;
     std::size_t iteration_ = 0UL;
 
-    const FVGridGeometry& fvGridGeometry_;
+    const GridGeometry& gridGeometry_;
 
     Dune::VTKSequenceWriter<GridView> ccWriter_;
 
diff --git a/dumux/porousmediumflow/2p/boxmaterialinterfaceparams.hh b/dumux/porousmediumflow/2p/boxmaterialinterfaceparams.hh
index 4a825532d54b48bae749c7536e386691baa4b4e2..63dad808af722e7200269410866d62b692b5b2a0 100644
--- a/dumux/porousmediumflow/2p/boxmaterialinterfaceparams.hh
+++ b/dumux/porousmediumflow/2p/boxmaterialinterfaceparams.hh
@@ -51,39 +51,39 @@ public:
     /*!
      * \brief Updates the scv -> dofparameter map
      *
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param spatialParams Class encapsulating the spatial parameters
      * \param x The current state of the solution vector
      */
-    template<class FVGridGeometry, class SolutionVector>
-    void update(const FVGridGeometry& fvGridGeometry,
+    template<class GridGeometry, class SolutionVector>
+    void update(const GridGeometry& gridGeometry,
                 const SpatialParams& spatialParams,
                 const SolutionVector& x)
     {
         using MaterialLaw = typename SpatialParams::MaterialLaw;
 
         // Make sure the spatial params return a const ref and no copy!
-        using Elem = typename FVGridGeometry::GridView::template Codim<0>::Entity;
-        using ElemSol = decltype( elementSolution(Elem(), x, fvGridGeometry) );
-        using Scv = typename FVGridGeometry::SubControlVolume;
+        using Elem = typename GridGeometry::GridView::template Codim<0>::Entity;
+        using ElemSol = decltype( elementSolution(Elem(), x, gridGeometry) );
+        using Scv = typename GridGeometry::SubControlVolume;
         using ReturnType = decltype(spatialParams.materialLawParams(Elem(), Scv(), ElemSol()));
         static_assert(std::is_lvalue_reference<ReturnType>::value,
                       "In order to use the box-interface solver please provide access "
                       "to the material law parameters via returning (const) references");
 
         // make sure this is only called for geometries of the box method!
-        if (FVGridGeometry::discMethod != DiscretizationMethod::box)
+        if (GridGeometry::discMethod != DiscretizationMethod::box)
             DUNE_THROW(Dune::InvalidStateException, "Determination of the interface material parameters with "
                                                     "this class only makes sense when using the box method!");
 
         isUpdated_ = true;
-        isOnMaterialInterface_.resize(fvGridGeometry.numDofs(), false);
-        dofParams_.resize(fvGridGeometry.numDofs(), nullptr);
-        for (const auto& element : elements(fvGridGeometry.gridView()))
+        isOnMaterialInterface_.resize(gridGeometry.numDofs(), false);
+        dofParams_.resize(gridGeometry.numDofs(), nullptr);
+        for (const auto& element : elements(gridGeometry.gridView()))
         {
-            const auto elemSol = elementSolution(element, x, fvGridGeometry);
+            const auto elemSol = elementSolution(element, x, gridGeometry);
 
-            auto fvGeometry = localView(fvGridGeometry);
+            auto fvGeometry = localView(gridGeometry);
             fvGeometry.bind(element);
             for (const auto& scv : scvs(fvGeometry))
             {
diff --git a/dumux/porousmediumflow/2p/gridadaptindicator.hh b/dumux/porousmediumflow/2p/gridadaptindicator.hh
index 28d174ebf104e2361aaf0600812e74d1c511c3b7..fbf5205699e5c7ea93d085736169a52a0c1ec7b9 100644
--- a/dumux/porousmediumflow/2p/gridadaptindicator.hh
+++ b/dumux/porousmediumflow/2p/gridadaptindicator.hh
@@ -43,7 +43,7 @@ namespace Dumux {
 template<class TypeTag>
 class TwoPGridAdaptIndicator
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
@@ -56,18 +56,18 @@ public:
     /*!
      * \brief The Constructor
      *
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param paramGroup The parameter group in which to look for runtime parameters first (default is "")
      *
      *  Note: refineBound_, coarsenBound_ & maxSaturationDelta_ are chosen
      *        in a way such that the indicator returns false for all elements
      *        before having been calculated.
      */
-    TwoPGridAdaptIndicator(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup = "")
-    : fvGridGeometry_(fvGridGeometry)
+    TwoPGridAdaptIndicator(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup = "")
+    : gridGeometry_(gridGeometry)
     , refineBound_(std::numeric_limits<Scalar>::max())
     , coarsenBound_(std::numeric_limits<Scalar>::lowest())
-    , maxSaturationDelta_(fvGridGeometry_->gridView().size(0), 0.0)
+    , maxSaturationDelta_(gridGeometry_->gridView().size(0), 0.0)
     , minLevel_(getParamFromGroup<std::size_t>(paramGroup, "Adaptive.MinLevel", 0))
     , maxLevel_(getParamFromGroup<std::size_t>(paramGroup, "Adaptive.MaxLevel", 0))
     {}
@@ -120,7 +120,7 @@ public:
         //! Reset the indicator to a state that returns false for all elements
         refineBound_ = std::numeric_limits<Scalar>::max();
         coarsenBound_ = std::numeric_limits<Scalar>::lowest();
-        maxSaturationDelta_.assign(fvGridGeometry_->gridView().size(0), 0.0);
+        maxSaturationDelta_.assign(gridGeometry_->gridView().size(0), 0.0);
 
         //! maxLevel_ must be higher than minLevel_ to allow for refinement
         if (minLevel_ >= maxLevel_)
@@ -135,15 +135,15 @@ public:
         Scalar globalMin = std::numeric_limits<Scalar>::max();
 
         //! Calculate minimum and maximum saturation
-        for (const auto& element : elements(fvGridGeometry_->gridView()))
+        for (const auto& element : elements(gridGeometry_->gridView()))
         {
             //! Index of the current leaf-element
-            const auto globalIdxI = fvGridGeometry_->elementMapper().index(element);
+            const auto globalIdxI = gridGeometry_->elementMapper().index(element);
 
             //! Obtain the saturation at the center of the element
             const auto geometry = element.geometry();
-            const auto elemSol = elementSolution(element, sol, *fvGridGeometry_);
-            const Scalar satI = evalSolution(element, geometry, *fvGridGeometry_, elemSol, geometry.center())[saturationIdx];
+            const auto elemSol = elementSolution(element, sol, *gridGeometry_);
+            const Scalar satI = evalSolution(element, geometry, *gridGeometry_, elemSol, geometry.center())[saturationIdx];
 
             //! Maybe update the global minimum/maximum
             using std::min;
@@ -152,22 +152,22 @@ public:
             globalMax = max(satI, globalMax);
 
             //! Calculate maximum delta in saturation for this cell
-            for (const auto& intersection : intersections(fvGridGeometry_->gridView(), element))
+            for (const auto& intersection : intersections(gridGeometry_->gridView(), element))
             {
                 //! Only consider internal intersections
                 if (intersection.neighbor())
                 {
                     //! Access neighbor
                     const auto outside = intersection.outside();
-                    const auto globalIdxJ = fvGridGeometry_->elementMapper().index(outside);
+                    const auto globalIdxJ = gridGeometry_->elementMapper().index(outside);
 
                     //! Visit intersection only once
                     if (element.level() > outside.level() || (element.level() == outside.level() && globalIdxI < globalIdxJ))
                     {
                         //! Obtain saturation in the neighbor
                         const auto outsideGeometry = outside.geometry();
-                        const auto elemSolJ = elementSolution(outside, sol, *fvGridGeometry_);
-                        const Scalar satJ = evalSolution(outside, outsideGeometry, *fvGridGeometry_, elemSolJ, outsideGeometry.center())[saturationIdx];
+                        const auto elemSolJ = elementSolution(outside, sol, *gridGeometry_);
+                        const Scalar satJ = evalSolution(outside, outsideGeometry, *gridGeometry_, elemSolJ, outsideGeometry.center())[saturationIdx];
 
                         using std::abs;
                         Scalar localdelta = abs(satI - satJ);
@@ -201,7 +201,7 @@ public:
 //#endif
 
         //! check if neighbors have to be refined too
-        for (const auto& element : elements(fvGridGeometry_->gridView(), Dune::Partitions::interior))
+        for (const auto& element : elements(gridGeometry_->gridView(), Dune::Partitions::interior))
             if (this->operator()(element) > 0)
                 checkNeighborsRefine_(element);
     }
@@ -218,12 +218,12 @@ public:
     int operator() (const Element& element) const
     {
         if (element.hasFather()
-            && maxSaturationDelta_[fvGridGeometry_->elementMapper().index(element)] < coarsenBound_)
+            && maxSaturationDelta_[gridGeometry_->elementMapper().index(element)] < coarsenBound_)
         {
             return -1;
         }
         else if (element.level() < maxLevel_
-                 && maxSaturationDelta_[fvGridGeometry_->elementMapper().index(element)] > refineBound_)
+                 && maxSaturationDelta_[gridGeometry_->elementMapper().index(element)] > refineBound_)
         {
             return 1;
         }
@@ -245,7 +245,7 @@ private:
      */
     bool checkNeighborsRefine_(const Element &element, std::size_t level = 1)
     {
-        for(const auto& intersection : intersections(fvGridGeometry_->gridView(), element))
+        for(const auto& intersection : intersections(gridGeometry_->gridView(), element))
         {
             if(!intersection.neighbor())
                 continue;
@@ -260,7 +260,7 @@ private:
             if (outside.level() < maxLevel_ && outside.level() < element.level())
             {
                 // ensure refinement for outside element
-                maxSaturationDelta_[fvGridGeometry_->elementMapper().index(outside)] = std::numeric_limits<Scalar>::max();
+                maxSaturationDelta_[gridGeometry_->elementMapper().index(outside)] = std::numeric_limits<Scalar>::max();
                 if(level < maxLevel_)
                     checkNeighborsRefine_(outside, ++level);
             }
@@ -269,7 +269,7 @@ private:
         return true;
     }
 
-    std::shared_ptr<const FVGridGeometry> fvGridGeometry_;
+    std::shared_ptr<const GridGeometry> gridGeometry_;
 
     Scalar refineBound_;
     Scalar coarsenBound_;
diff --git a/dumux/porousmediumflow/2p/griddatatransfer.hh b/dumux/porousmediumflow/2p/griddatatransfer.hh
index b89fd3fc6a76f37a0543b2a45af9fbf69a81daeb..8027dd913e504e8dfe97688851369ffc926d9b49 100644
--- a/dumux/porousmediumflow/2p/griddatatransfer.hh
+++ b/dumux/porousmediumflow/2p/griddatatransfer.hh
@@ -49,8 +49,8 @@ class TwoPGridDataTransfer : public GridDataTransfer
     using Grid = GetPropType<TypeTag, Properties::Grid>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
     using VolumeVariables = GetPropType<TypeTag, Properties::VolumeVariables>;
@@ -59,7 +59,7 @@ class TwoPGridDataTransfer : public GridDataTransfer
     using Element = typename Grid::template Codim<0>::Entity;
     using ElementSolution = std::decay_t<decltype(elementSolution(std::declval<Element>(),
                                                                   std::declval<SolutionVector>(),
-                                                                  std::declval<FVGridGeometry>()))>;
+                                                                  std::declval<GridGeometry>()))>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
     using Indices = typename ModelTraits::Indices;
@@ -109,20 +109,20 @@ public:
      * \brief Constructor
      *
      * \param problem The DuMuX problem to be solved
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param gridVariables The secondary variables on the grid
      * \param sol The solution (primary variables) on the grid
      */
     TwoPGridDataTransfer(std::shared_ptr<const Problem> problem,
-                         std::shared_ptr<FVGridGeometry> fvGridGeometry,
+                         std::shared_ptr<GridGeometry> gridGeometry,
                          std::shared_ptr<const GridVariables> gridVariables,
                          SolutionVector& sol)
     : GridDataTransfer()
     , problem_(problem)
-    , fvGridGeometry_(fvGridGeometry)
+    , gridGeometry_(gridGeometry)
     , gridVariables_(gridVariables)
     , sol_(sol)
-    , adaptionMap_(fvGridGeometry->gridView().grid(), 0)
+    , adaptionMap_(gridGeometry->gridView().grid(), 0)
     {}
 
     /*!
@@ -137,7 +137,7 @@ public:
     {
         adaptionMap_.resize();
 
-        const auto& grid = fvGridGeometry_->gridView().grid();
+        const auto& grid = gridGeometry_->gridView().grid();
         for (auto level = grid.maxLevel(); level >= 0; level--)
         {
             for (const auto& element : elements(grid.levelGridView(level)))
@@ -148,11 +148,11 @@ public:
                 // put values in the map for leaf elements
                 if (element.isLeaf())
                 {
-                    auto fvGeometry = localView(*fvGridGeometry_);
+                    auto fvGeometry = localView(*gridGeometry_);
                     fvGeometry.bindElement(element);
 
                     // store current element solution
-                    adaptedValues.u = ElementSolution(element, sol_, *fvGridGeometry_);
+                    adaptedValues.u = ElementSolution(element, sol_, *gridGeometry_);
 
                     // compute mass in the scvs
                     for (const auto& scv : scvs(fvGeometry))
@@ -183,7 +183,7 @@ public:
                 // This element solution constructor uses the vertex mapper to obtain
                 // the privars at the vertices, thus, this works for non-leaf elements!
                 if(isBox && !element.isLeaf())
-                    adaptedValues.u = ElementSolution(element, sol_, *fvGridGeometry_);
+                    adaptedValues.u = ElementSolution(element, sol_, *gridGeometry_);
             }
         }
     }
@@ -203,8 +203,8 @@ public:
     {
         // resize stuff (grid might have changed)
         adaptionMap_.resize();
-        fvGridGeometry_->update();
-        sol_.resize(fvGridGeometry_->numDofs());
+        gridGeometry_->update();
+        sol_.resize(gridGeometry_->numDofs());
 
         // vectors storing the mass associated with each vertex, when using the box method
         std::vector<Scalar> massCoeff;
@@ -212,18 +212,18 @@ public:
 
         if(isBox)
         {
-            massCoeff.resize(fvGridGeometry_->numDofs(), 0.0);
-            associatedMass.resize(fvGridGeometry_->numDofs(), 0.0);
+            massCoeff.resize(gridGeometry_->numDofs(), 0.0);
+            associatedMass.resize(gridGeometry_->numDofs(), 0.0);
         }
 
         // iterate over leaf and reconstruct the solution
-        for (const auto& element : elements(fvGridGeometry_->gridView().grid().leafGridView(), Dune::Partitions::interior))
+        for (const auto& element : elements(gridGeometry_->gridView().grid().leafGridView(), Dune::Partitions::interior))
         {
             if (!element.isNew())
             {
                 const auto& adaptedValues = adaptionMap_[element];
 
-                auto fvGeometry = localView(*fvGridGeometry_);
+                auto fvGeometry = localView(*gridGeometry_);
                 fvGeometry.bindElement(element);
 
                 // obtain element solution from map (divide by count!)
@@ -302,7 +302,7 @@ public:
                     auto elemSolSon = adaptedValuesFather.u;
                     elemSolSon[0] /= adaptedValuesFather.count;
 
-                    auto fvGeometry = localView(*fvGridGeometry_);
+                    auto fvGeometry = localView(*gridGeometry_);
                     fvGeometry.bindElement(element);
 
                     for (const auto& scv : scvs(fvGeometry))
@@ -326,11 +326,11 @@ public:
                 {
                     auto& adaptedValuesFather = adaptionMap_[fatherElement];
 
-                    auto fvGeometry = localView(*fvGridGeometry_);
+                    auto fvGeometry = localView(*gridGeometry_);
                     fvGeometry.bindElement(element);
 
                     // interpolate solution in the father to the vertices of the new son
-                    ElementSolution elemSolSon(element, sol_, *fvGridGeometry_);
+                    ElementSolution elemSolSon(element, sol_, *gridGeometry_);
                     const auto fatherGeometry = fatherElement.geometry();
                     for (const auto& scv : scvs(fvGeometry))
                         elemSolSon[scv.localDofIndex()] = evalSolution(fatherElement,
@@ -367,7 +367,7 @@ public:
 
         if(isBox)
         {
-            for(std::size_t dofIdxGlobal = 0; dofIdxGlobal < fvGridGeometry_->numDofs(); dofIdxGlobal++)
+            for(std::size_t dofIdxGlobal = 0; dofIdxGlobal < gridGeometry_->numDofs(); dofIdxGlobal++)
                 sol_[dofIdxGlobal][saturationIdx] = associatedMass[dofIdxGlobal] / massCoeff[dofIdxGlobal];
         }
 
@@ -434,7 +434,7 @@ public:
     }
 
     std::shared_ptr<const Problem> problem_;
-    std::shared_ptr<FVGridGeometry> fvGridGeometry_;
+    std::shared_ptr<GridGeometry> gridGeometry_;
     std::shared_ptr<const GridVariables> gridVariables_;
     SolutionVector& sol_;
     PersistentContainer adaptionMap_;
diff --git a/dumux/porousmediumflow/2p/incompressiblelocalresidual.hh b/dumux/porousmediumflow/2p/incompressiblelocalresidual.hh
index 54396316e48f83a90b925ea9e1939e5a437b522c..05f2a24c02a866646d0b49ba1e9b9c5bc1690427 100644
--- a/dumux/porousmediumflow/2p/incompressiblelocalresidual.hh
+++ b/dumux/porousmediumflow/2p/incompressiblelocalresidual.hh
@@ -56,8 +56,8 @@ class TwoPIncompressibleLocalResidual : public ImmiscibleLocalResidual<TypeTag>
     using FluxVariables = GetPropType<TypeTag, Properties::FluxVariables>;
     using ElementFluxVariablesCache = typename GetPropType<TypeTag, Properties::GridFluxVariablesCache>::LocalView;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
diff --git a/dumux/porousmediumflow/boxdfm/fvelementgeometry.hh b/dumux/porousmediumflow/boxdfm/fvelementgeometry.hh
index a79f362bff9fe16d1f00d1c4ed684d90c7321b00..bfa34112a07e8803451aba513e32286e0663e437 100644
--- a/dumux/porousmediumflow/boxdfm/fvelementgeometry.hh
+++ b/dumux/porousmediumflow/boxdfm/fvelementgeometry.hh
@@ -78,8 +78,8 @@ public:
     static constexpr std::size_t maxNumElementScvs = (1<<dim)*3;
 
     //! Constructor
-    BoxDfmFVElementGeometry(const GridGeometry& fvGridGeometry)
-    : fvGridGeometryPtr_(&fvGridGeometry) {}
+    BoxDfmFVElementGeometry(const GridGeometry& gridGeometry)
+    : gridGeometryPtr_(&gridGeometry) {}
 
     //! Get a sub control volume with a local scv index
     const SubControlVolume& scv(std::size_t scvIdx) const
@@ -155,15 +155,15 @@ public:
     //! The global finite volume geometry we are a restriction of
     [[deprecated("Use gridGeometry() instead. fvGridGeometry() will be removed after 3.1!")]]
     const GridGeometry& fvGridGeometry() const
-    { return *fvGridGeometryPtr_; }
+    { return *gridGeometryPtr_; }
 
     //! The global finite volume geometry we are a restriction of
     const GridGeometry& gridGeometry() const
-    { return *fvGridGeometryPtr_; }
+    { return *gridGeometryPtr_; }
 
 private:
     Dune::GeometryType elemGeometryType_;
-    const GridGeometry* fvGridGeometryPtr_;
+    const GridGeometry* gridGeometryPtr_;
     GridIndexType eIdx_;
 };
 
@@ -200,8 +200,8 @@ public:
     static constexpr std::size_t maxNumElementScvs = (1<<dim)*3;
 
     //! Constructor
-    BoxDfmFVElementGeometry(const GridGeometry& fvGridGeometry)
-    : fvGridGeometryPtr_(&fvGridGeometry) {}
+    BoxDfmFVElementGeometry(const GridGeometry& gridGeometry)
+    : gridGeometryPtr_(&gridGeometry) {}
 
     //! Get a sub control volume with a local scv index
     const SubControlVolume& scv(std::size_t scvIdx) const
@@ -275,11 +275,11 @@ public:
     //! The global finite volume geometry we are a restriction of
     [[deprecated("Use gridGeometry() instead. fvGridGeometry() will be removed after 3.1!")]]
     const GridGeometry& fvGridGeometry() const
-    { return *fvGridGeometryPtr_; }
+    { return *gridGeometryPtr_; }
 
     //! The global finite volume geometry we are a restriction of
     const GridGeometry& gridGeometry() const
-    { return *fvGridGeometryPtr_; }
+    { return *gridGeometryPtr_; }
 
 private:
 
@@ -445,7 +445,7 @@ private:
     GridIndexType eIdx_;
 
     //! The global geometry this is a restriction of
-    const GridGeometry* fvGridGeometryPtr_;
+    const GridGeometry* gridGeometryPtr_;
 
     /*!
      * \brief Binding of an element, has to be called before using the fvgeometries
diff --git a/dumux/porousmediumflow/boxdfm/fvgridgeometry.hh b/dumux/porousmediumflow/boxdfm/fvgridgeometry.hh
index cdebc859d2add9ada681f79e1a1abd5f7d35a2fb..43fc6ad27c75893f3c7218d523aac0dcf14c4e04 100644
--- a/dumux/porousmediumflow/boxdfm/fvgridgeometry.hh
+++ b/dumux/porousmediumflow/boxdfm/fvgridgeometry.hh
@@ -63,8 +63,8 @@ struct BoxDfmDefaultGridGeometryTraits
     using SubControlVolume = BoxDfmSubControlVolume<GridView>;
     using SubControlVolumeFace = BoxDfmSubControlVolumeFace<GridView>;
 
-    template<class FVGridGeometry, bool enableCache>
-    using LocalView = BoxDfmFVElementGeometry<FVGridGeometry, enableCache>;
+    template<class GridGeometry, bool enableCache>
+    using LocalView = BoxDfmFVElementGeometry<GridGeometry, enableCache>;
 
     // Mapper type for mapping edges
     using FacetMapper = Dune::MultipleCodimMultipleGeomTypeMapper<GridView>;
@@ -106,7 +106,7 @@ class BoxDfmFVGridGeometry<Scalar, GV, true, Traits>
     using CoordScalar = typename GV::ctype;
     static const int dim = GV::dimension;
     static const int dimWorld = GV::dimensionworld;
-    static_assert(dim == 2 || dim == 3, "The box-dfm FVGridGeometry is only implemented in 2 or 3 dimensions.");
+    static_assert(dim == 2 || dim == 3, "The box-dfm GridGeometry is only implemented in 2 or 3 dimensions.");
 
     using ReferenceElements = typename Dune::ReferenceElements<CoordScalar, dim>;
     using FaceReferenceElements = typename Dune::ReferenceElements<CoordScalar, dim-1>;
diff --git a/dumux/porousmediumflow/boxdfm/vtkoutputmodule.hh b/dumux/porousmediumflow/boxdfm/vtkoutputmodule.hh
index 3933dd65a03b317660e06a6f202ef16cef8d263c..1b90c61a5caf3d7e3443e3e5a8b9bd8160544066 100644
--- a/dumux/porousmediumflow/boxdfm/vtkoutputmodule.hh
+++ b/dumux/porousmediumflow/boxdfm/vtkoutputmodule.hh
@@ -56,12 +56,12 @@ template<class GridVariables, class SolutionVector, class FractureGrid>
 class BoxDfmVtkOutputModule : public VtkOutputModule<GridVariables, SolutionVector>
 {
     using ParentType = VtkOutputModule<GridVariables, SolutionVector>;
-    using FVGridGeometry = typename GridVariables::GridGeometry;
+    using GridGeometry = typename GridVariables::GridGeometry;
     using VV = typename GridVariables::VolumeVariables;
     using FluidSystem = typename VV::FluidSystem;
     using Scalar = typename GridVariables::Scalar;
 
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using FractureGridView = typename FractureGrid::LeafGridView;
     using FractureMapper = Dune::MultipleCodimMultipleGeomTypeMapper<FractureGridView>;
 
@@ -82,7 +82,7 @@ class BoxDfmVtkOutputModule : public VtkOutputModule<GridVariables, SolutionVect
     static_assert(dim > 1, "Box-Dfm output only works for dim > 1");
     static_assert(FractureGrid::dimension == int(dim-1), "Fracture grid must be of codimension one!");
     static_assert(FractureGrid::dimensionworld == int(dimWorld), "Fracture grid has to has the same coordinate dimension!");
-    static_assert(FVGridGeometry::discMethod == DiscretizationMethod::box, "Box-Dfm output module can only be used with the box scheme!");
+    static_assert(GridGeometry::discMethod == DiscretizationMethod::box, "Box-Dfm output module can only be used with the box scheme!");
 public:
 
     //! The constructor
@@ -150,7 +150,7 @@ private:
         std::vector<std::vector<GlobalPosition>> volVarVectorDataFracture;
 
         // some references for convenience
-        const auto& gridView = this->fvGridGeometry().gridView();
+        const auto& gridView = this->gridGeometry().gridView();
         const auto& fractureGridView = fractureGrid_->leafGridView();
         const auto& volVarScalarDataInfo = this->volVarScalarDataInfo();
         const auto& volVarVectorDataInfo = this->volVarVectorDataInfo();
@@ -187,9 +187,9 @@ private:
 
             for (const auto& element : elements(gridView, Dune::Partitions::interior))
             {
-                const auto eIdxGlobal = this->fvGridGeometry().elementMapper().index(element);
+                const auto eIdxGlobal = this->gridGeometry().elementMapper().index(element);
 
-                auto fvGeometry = localView(this->fvGridGeometry());
+                auto fvGeometry = localView(this->gridGeometry());
                 auto elemVolVars = localView(this->gridVariables().curGridVolVars());
 
                 // If velocity output is enabled we need to bind to the whole stencil
@@ -257,7 +257,7 @@ private:
 
             for (std::size_t i = 0; i < volVarVectorDataInfo.size(); ++i)
             {
-                this->sequenceWriter().addVertexData( Field(gridView, this->fvGridGeometry().vertexMapper(), volVarVectorData[i],
+                this->sequenceWriter().addVertexData( Field(gridView, this->gridGeometry().vertexMapper(), volVarVectorData[i],
                                                             volVarVectorDataInfo[i].name, /*numComp*/dimWorld, /*codim*/dim).get() );
                 fractureSequenceWriter_->addVertexData( FractureField(fractureGridView, *fractureVertexMapper_, volVarVectorDataFracture[i],
                                                                       volVarVectorDataInfo[i].name, /*numComp*/dimWorld, /*codim*/dim-1).get() );
@@ -267,14 +267,14 @@ private:
             if (this->velocityOutput().enableOutput())
             {
                 for (int phaseIdx = 0; phaseIdx < this->velocityOutput().numFluidPhases(); ++phaseIdx)
-                    this->sequenceWriter().addVertexData( Field(gridView, this->fvGridGeometry().vertexMapper(), velocity[phaseIdx],
+                    this->sequenceWriter().addVertexData( Field(gridView, this->gridGeometry().vertexMapper(), velocity[phaseIdx],
                                                                 "velocity_" + std::string(this->velocityOutput().phaseName(phaseIdx)) + " (m/s)",
                                                                 /*numComp*/dimWorld, /*codim*/dim).get() );
             }
 
             // the process rank
             if (addProcessRank)
-                this->sequenceWriter().addCellData( Field(gridView, this->fvGridGeometry().elementMapper(), rank,
+                this->sequenceWriter().addCellData( Field(gridView, this->gridGeometry().elementMapper(), rank,
                                                           "process rank", /*numComp*/1, /*codim*/0).get() );
 
             // also register additional (non-standardized) user fields if any (only on matrix grid)
@@ -325,7 +325,7 @@ private:
         std::vector< VectorDataContainer > volVarVectorDataFracture;
 
         // some references for convenience
-        const auto& gridView = this->fvGridGeometry().gridView();
+        const auto& gridView = this->gridGeometry().gridView();
         const auto& fractureGridView = fractureGrid_->leafGridView();
         const auto& volVarScalarDataInfo = this->volVarScalarDataInfo();
         const auto& volVarVectorDataInfo = this->volVarVectorDataInfo();
@@ -362,10 +362,10 @@ private:
 
             for (const auto& element : elements(gridView, Dune::Partitions::interior))
             {
-                const auto eIdxGlobal = this->fvGridGeometry().elementMapper().index(element);
+                const auto eIdxGlobal = this->gridGeometry().elementMapper().index(element);
                 const auto numCorners = element.subEntities(dim);
 
-                auto fvGeometry = localView(this->fvGridGeometry());
+                auto fvGeometry = localView(this->gridGeometry());
                 auto elemVolVars = localView(this->gridVariables().curGridVolVars());
 
                 // resize element-local data containers (for bulk grid)
@@ -435,7 +435,7 @@ private:
             // volume variables if any
             for (std::size_t i = 0; i < volVarScalarDataInfo.size(); ++i)
             {
-                this->sequenceWriter().addVertexData( Field(gridView, this->fvGridGeometry().elementMapper(), volVarScalarData[i],
+                this->sequenceWriter().addVertexData( Field(gridView, this->gridGeometry().elementMapper(), volVarScalarData[i],
                                                             volVarScalarDataInfo[i].name, /*numComp*/1, /*codim*/dim,
                                                             /*nonconforming*/this->dataMode()).get() );
                 fractureSequenceWriter_->addVertexData( FractureField(fractureGridView, *fractureElementMapper_, volVarScalarDataFracture[i],
@@ -445,7 +445,7 @@ private:
 
             for (std::size_t i = 0; i < volVarVectorDataInfo.size(); ++i)
             {
-                this->sequenceWriter().addVertexData( Field(gridView, this->fvGridGeometry().elementMapper(), volVarVectorData[i],
+                this->sequenceWriter().addVertexData( Field(gridView, this->gridGeometry().elementMapper(), volVarVectorData[i],
                                                             volVarVectorDataInfo[i].name, /*numComp*/dimWorld, /*codim*/dim,
                                                             /*nonconforming*/this->dataMode()).get() );
                 fractureSequenceWriter_->addVertexData( FractureField(fractureGridView, *fractureElementMapper_, volVarVectorDataFracture[i],
@@ -457,14 +457,14 @@ private:
             if (this->velocityOutput().enableOutput())
             {
                 for (int phaseIdx = 0; phaseIdx < this->velocityOutput().numFluidPhases(); ++phaseIdx)
-                    this->sequenceWriter().addVertexData( Field(gridView, this->fvGridGeometry().vertexMapper(), velocity[phaseIdx],
+                    this->sequenceWriter().addVertexData( Field(gridView, this->gridGeometry().vertexMapper(), velocity[phaseIdx],
                                                                 "velocity_" + std::string(this->velocityOutput().phaseName(phaseIdx)) + " (m/s)",
                                                                 /*numComp*/dimWorld, /*codim*/dim).get() );
             }
 
             // the process rank
             if (addProcessRank)
-                this->sequenceWriter().addCellData( Field(gridView, this->fvGridGeometry().elementMapper(), rank,
+                this->sequenceWriter().addCellData( Field(gridView, this->gridGeometry().elementMapper(), rank,
                                                           "process rank", /*numComp*/1, /*codim*/0).get() );
 
             // also register additional (non-standardized) user fields if any (only on matrix grid)
@@ -496,8 +496,8 @@ private:
     template< class FractureGridAdapter >
     void initializeFracture_(const FractureGridAdapter& fractureGridAdapter)
     {
-        const auto& fvGridGeometry = this->fvGridGeometry();
-        const auto& gridView = fvGridGeometry.gridView();
+        const auto& gridGeometry = this->gridGeometry();
+        const auto& gridView = gridGeometry.gridView();
         Dune::GridFactory<FractureGrid> gridFactory;
 
         // insert fracture vertices
@@ -508,7 +508,7 @@ private:
             if (fractureGridAdapter.isOnFacetGrid(v))
             {
                 gridFactory.insertVertex(v.geometry().center());
-                vertexToFractureVertexIdx_[fvGridGeometry.vertexMapper().index(v)] = fracVertexCount++;
+                vertexToFractureVertexIdx_[gridGeometry.vertexMapper().index(v)] = fracVertexCount++;
             }
         }
 
@@ -518,7 +518,7 @@ private:
         std::set< std::pair<GridIndexType, unsigned int> > handledFacets;
         for (const auto& element : elements(gridView))
         {
-            const auto eIdxGlobal = fvGridGeometry.elementMapper().index(element);
+            const auto eIdxGlobal = gridGeometry.elementMapper().index(element);
             const auto referenceElement = ReferenceElements::general(element.type());
 
             for (const auto& is : intersections(gridView, element))
@@ -530,7 +530,7 @@ private:
 
                 std::vector<GridIndexType> isVertexIndices(numCorners);
                 for (unsigned int i = 0; i < numCorners; ++i)
-                    isVertexIndices[i] = fvGridGeometry.vertexMapper().subIndex(element,
+                    isVertexIndices[i] = gridGeometry.vertexMapper().subIndex(element,
                                                                                 referenceElement.subEntity(indexInInside, 1, i, dim),
                                                                                 dim);
 
@@ -542,7 +542,7 @@ private:
                     if (!is.boundary())
                     {
                         // only proceed if facet has not been handled yet
-                        const auto outsideEIdx = fvGridGeometry.elementMapper().index(is.outside());
+                        const auto outsideEIdx = gridGeometry.elementMapper().index(is.outside());
                         const auto idxInOutside = is.indexInOutside();
                         const auto pair = std::make_pair(outsideEIdx, idxInOutside);
                         if (handledFacets.count( pair ) != 0)
@@ -591,7 +591,7 @@ private:
 
         // update vertex index map
         for (GridIndexType dofIdx = 0; dofIdx < gridView.size(GridView::dimension); ++dofIdx)
-            if (fvGridGeometry.dofOnFracture(dofIdx))
+            if (gridGeometry.dofOnFracture(dofIdx))
                 vertexToFractureVertexIdx_[dofIdx] = insToVertexIdx[ vertexToFractureVertexIdx_[dofIdx] ];
 
         // update fracture element map
diff --git a/dumux/porousmediumflow/compositional/primaryvariableswitch.hh b/dumux/porousmediumflow/compositional/primaryvariableswitch.hh
index 9112ecd129a1e617bfa0bb98904166eaff28d38c..70318d4d68da681e47ff01469c0326d71a65fa0c 100644
--- a/dumux/porousmediumflow/compositional/primaryvariableswitch.hh
+++ b/dumux/porousmediumflow/compositional/primaryvariableswitch.hh
@@ -81,27 +81,27 @@ public:
      * \param curSol The current solution to be updated / modified
      * \param gridVariables The secondary variables on the grid
      * \param problem The problem
-     * \param fvGridGeometry The finite-volume grid geometry
+     * \param gridGeometry The finite-volume grid geometry
      */
     template<class SolutionVector, class GridVariables, class Problem>
     bool update(SolutionVector& curSol,
                 GridVariables& gridVariables,
                 const Problem& problem,
-                const typename GridVariables::GridGeometry& fvGridGeometry)
+                const typename GridVariables::GridGeometry& gridGeometry)
     {
         bool switched = false;
         visited_.assign(wasSwitched_.size(), false);
         std::size_t countSwitched = 0;
-        for (const auto& element : elements(fvGridGeometry.gridView()))
+        for (const auto& element : elements(gridGeometry.gridView()))
         {
             // make sure FVElementGeometry is bound to the element
-            auto fvGeometry = localView(fvGridGeometry);
+            auto fvGeometry = localView(gridGeometry);
             fvGeometry.bindElement(element);
 
             auto elemVolVars = localView(gridVariables.curGridVolVars());
             elemVolVars.bindElement(element, fvGeometry, curSol);
 
-            const auto curElemSol = elementSolution(element, curSol, fvGridGeometry);
+            const auto curElemSol = elementSolution(element, curSol, gridGeometry);
             for (auto&& scv : scvs(fvGeometry))
             {
                 auto dofIdxGlobal = scv.dofIndex();
@@ -126,12 +126,12 @@ public:
 
         if (verbosity_ > 0 && countSwitched > 0)
             std::cout << "Switched primary variables at " << countSwitched << " dof locations on processor "
-                      << fvGridGeometry.gridView().comm().rank() << "." << std::endl;
+                      << gridGeometry.gridView().comm().rank() << "." << std::endl;
 
         // make sure that if there was a variable switch in an
         // other partition we will also set the switch flag for our partition.
-        if (fvGridGeometry.gridView().comm().size() > 1)
-            switched = fvGridGeometry.gridView().comm().max(switched);
+        if (gridGeometry.gridView().comm().size() > 1)
+            switched = gridGeometry.gridView().comm().max(switched);
 
         return switched;
     }
@@ -146,12 +146,12 @@ public:
              std::enable_if_t<GridVariables::GridVolumeVariables::cachingEnabled, int> = 0>
     void updateSwitchedVolVars(const Problem& problem,
                                const typename GridVariables::GridGeometry::GridView::template Codim<0>::Entity& element,
-                               const typename GridVariables::GridGeometry& fvGridGeometry,
+                               const typename GridVariables::GridGeometry& gridGeometry,
                                GridVariables& gridVariables,
                                const SolutionVector& sol)
     {
         // make sure FVElementGeometry is bound to the element
-        auto fvGeometry = localView(fvGridGeometry);
+        auto fvGeometry = localView(gridGeometry);
         fvGeometry.bindElement(element);
 
         // update the secondary variables if global caching is enabled
@@ -160,7 +160,7 @@ public:
             const auto dofIdxGlobal = scv.dofIndex();
             if (asImp_().wasSwitched(dofIdxGlobal))
             {
-                const auto elemSol = elementSolution(element, sol, fvGridGeometry);
+                const auto elemSol = elementSolution(element, sol, gridGeometry);
                 auto& volVars = gridVariables.curGridVolVars().volVars(scv);
                 volVars.update(elemSol, problem, element, scv);
             }
@@ -178,17 +178,17 @@ public:
                                GridVariables::GridGeometry::discMethod != DiscretizationMethod::box), int> = 0>
     void updateSwitchedFluxVarsCache(const Problem& problem,
                                      const typename GridVariables::GridGeometry::GridView::template Codim<0>::Entity& element,
-                                     const typename GridVariables::GridGeometry& fvGridGeometry,
+                                     const typename GridVariables::GridGeometry& gridGeometry,
                                      GridVariables& gridVariables,
                                      const SolutionVector& sol)
     {
         // update the flux variables if global caching is enabled
-        const auto dofIdxGlobal = fvGridGeometry.dofMapper().index(element);
+        const auto dofIdxGlobal = gridGeometry.dofMapper().index(element);
 
         if (asImp_().wasSwitched(dofIdxGlobal))
         {
             // make sure FVElementGeometry and the volume variables are bound
-            auto fvGeometry = localView(fvGridGeometry);
+            auto fvGeometry = localView(gridGeometry);
             fvGeometry.bind(element);
             auto curElemVolVars = localView(gridVariables.curGridVolVars());
             curElemVolVars.bind(element, fvGeometry, sol);
@@ -204,16 +204,16 @@ public:
     template<class Problem, class GridVariables, class SolutionVector,
              std::enable_if_t<(GridVariables::GridGeometry::discMethod == DiscretizationMethod::box), int> = 0>
     void updateBoundary(const Problem& problem,
-                        const typename GridVariables::GridGeometry& fvGridGeometry,
+                        const typename GridVariables::GridGeometry& gridGeometry,
                         GridVariables& gridVariables,
                         SolutionVector& sol)
     {
         std::vector<bool> stateChanged(sol.size(), false);
         std::size_t countChanged = 0;
 
-        for (const auto& element : elements(fvGridGeometry.gridView()))
+        for (const auto& element : elements(gridGeometry.gridView()))
         {
-            auto fvGeometry = localView(fvGridGeometry);
+            auto fvGeometry = localView(gridGeometry);
             fvGeometry.bindElement(element);
 
             // skip if the element is not at a boundary
@@ -227,7 +227,7 @@ public:
             {
                 // this implies that state is set equal for all scvs associated with the dof
                 const auto dofIdx = scv.dofIndex();
-                if (!fvGridGeometry.dofOnBoundary(dofIdx) || stateChanged[dofIdx])
+                if (!gridGeometry.dofOnBoundary(dofIdx) || stateChanged[dofIdx])
                     continue;
 
                 const auto bcTypes = problem.boundaryTypes(element, scv);
@@ -264,7 +264,7 @@ public:
             // update the volVars if caching is enabled
             if (GridVariables::GridVolumeVariables::cachingEnabled && countChanged > 0)
             {
-                const auto curElemSol = elementSolution(element, sol, fvGridGeometry);
+                const auto curElemSol = elementSolution(element, sol, gridGeometry);
                 for (const auto& scv : scvs(fvGeometry))
                 {
                     if (stateChanged[scv.dofIndex()])
@@ -278,7 +278,7 @@ public:
 
         if (verbosity_ > 0 && countChanged > 0)
             std::cout << "Changed primary variable states and solution values at boundary to Dirichlet states and values at " << countChanged << " dof locations on processor "
-                      << fvGridGeometry.gridView().comm().rank() << "." << std::endl;
+                      << gridGeometry.gridView().comm().rank() << "." << std::endl;
     }
 
     //! Do nothing when volume variables are not cached globally.
@@ -286,7 +286,7 @@ public:
              std::enable_if_t<!GridVariables::GridVolumeVariables::cachingEnabled, int> = 0>
     void updateSwitchedVolVars(const Problem& problem,
                                const typename GridVariables::GridGeometry::GridView::template Codim<0>::Entity& element,
-                               const typename GridVariables::GridGeometry& fvGridGeometry,
+                               const typename GridVariables::GridGeometry& gridGeometry,
                                GridVariables& gridVariables,
                                const SolutionVector &uCurrentIter) const {}
 
@@ -296,7 +296,7 @@ public:
                                GridVariables::GridGeometry::discMethod == DiscretizationMethod::box), int> = 0>
     void updateSwitchedFluxVarsCache(const Problem& problem,
                                const typename GridVariables::GridGeometry::GridView::template Codim<0>::Entity& element,
-                               const typename GridVariables::GridGeometry& fvGridGeometry,
+                               const typename GridVariables::GridGeometry& gridGeometry,
                                GridVariables& gridVariables,
                                const SolutionVector& sol) const {}
 
@@ -304,7 +304,7 @@ public:
     template<class Problem, class GridVariables, class SolutionVector,
              std::enable_if_t<(GridVariables::GridGeometry::discMethod != DiscretizationMethod::box), int> = 0>
     void updateBoundary(const Problem& problem,
-                        const typename GridVariables::GridGeometry& fvGridGeometry,
+                        const typename GridVariables::GridGeometry& gridGeometry,
                         GridVariables& gridVariables,
                         SolutionVector& sol) const {}
 
diff --git a/dumux/porousmediumflow/fluxvariables.hh b/dumux/porousmediumflow/fluxvariables.hh
index 1838524d4f23c98212b1db8b0feaf7d5fa23e2b5..60f7cd3c5ffa1424436277a5065a47caf79a9488 100644
--- a/dumux/porousmediumflow/fluxvariables.hh
+++ b/dumux/porousmediumflow/fluxvariables.hh
@@ -53,9 +53,9 @@ class PorousMediumFluxVariables
 {
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
 
diff --git a/dumux/porousmediumflow/fluxvariablescachefiller.hh b/dumux/porousmediumflow/fluxvariablescachefiller.hh
index 916ceff5b2aca2672209dea00c4a98206eebb2b5..8693779f716d6e81db5fab751c2b32306600ca62 100644
--- a/dumux/porousmediumflow/fluxvariablescachefiller.hh
+++ b/dumux/porousmediumflow/fluxvariablescachefiller.hh
@@ -218,9 +218,9 @@ class PorousMediumFluxVariablesCacheFillerImplementation<TypeTag, Discretization
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using MpfaHelper = typename FVGridGeometry::MpfaHelper;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using MpfaHelper = typename GridGeometry::MpfaHelper;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
     using ElementFluxVariablesCache = typename GetPropType<TypeTag, Properties::GridFluxVariablesCache>::LocalView;
@@ -281,8 +281,8 @@ public:
         elemVolVarsPtr_ = &elemVolVars;
 
         // prepare interaction volume and fill caches of all the scvfs connected to it
-        const auto& fvGridGeometry = fvGeometry.gridGeometry();
-        if (fvGridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()))
+        const auto& gridGeometry = fvGeometry.gridGeometry();
+        if (gridGeometry.vertexUsesSecondaryInteractionVolume(scvf.vertexIndex()))
         {
             if (forceUpdateAll)
             {
@@ -290,7 +290,7 @@ public:
                 const auto ivIndexInContainer = ivDataStorage.secondaryInteractionVolumes.size();
 
                 // prepare the locally cached boundary interaction volume
-                const auto& indexSet = fvGridGeometry.gridInteractionVolumeIndexSets().secondaryIndexSet(scvf);
+                const auto& indexSet = gridGeometry.gridInteractionVolumeIndexSets().secondaryIndexSet(scvf);
                 ivDataStorage.secondaryInteractionVolumes.emplace_back();
                 secondaryIv_ = &ivDataStorage.secondaryInteractionVolumes.back();
                 secondaryIv_->bind(indexSet, problem(), fvGeometry);
@@ -320,7 +320,7 @@ public:
                 const auto ivIndexInContainer = ivDataStorage.primaryInteractionVolumes.size();
 
                 // prepare the locally cached boundary interaction volume
-                const auto& indexSet = fvGridGeometry.gridInteractionVolumeIndexSets().primaryIndexSet(scvf);
+                const auto& indexSet = gridGeometry.gridInteractionVolumeIndexSets().primaryIndexSet(scvf);
                 ivDataStorage.primaryInteractionVolumes.emplace_back();
                 primaryIv_ = &ivDataStorage.primaryInteractionVolumes.back();
                 primaryIv_->bind(indexSet, problem(), fvGeometry);
diff --git a/dumux/porousmediumflow/nonequilibrium/gridvariables.hh b/dumux/porousmediumflow/nonequilibrium/gridvariables.hh
index 7d2e2660a3fab0a25fc6acb1448642389eaff552..e27312975058a80f78c4fd025b044fcee6a19f9d 100644
--- a/dumux/porousmediumflow/nonequilibrium/gridvariables.hh
+++ b/dumux/porousmediumflow/nonequilibrium/gridvariables.hh
@@ -88,15 +88,15 @@ public:
         for (int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
         {
             if(isBox && dim == 1)
-                velocity[phaseIdx].resize(this->fvGridGeometry_->gridView().size(0));
+                velocity[phaseIdx].resize(this->gridGeometry_->gridView().size(0));
             else
-                velocity[phaseIdx].resize(this->fvGridGeometry_->numDofs());
+                velocity[phaseIdx].resize(this->gridGeometry_->numDofs());
         }
-        for (const auto& element : elements(this->fvGridGeometry_->gridView(), Dune::Partitions::interior))
+        for (const auto& element : elements(this->gridGeometry_->gridView(), Dune::Partitions::interior))
         {
-            const auto eIdxGlobal = this->fvGridGeometry_->elementMapper().index(element);
+            const auto eIdxGlobal = this->gridGeometry_->elementMapper().index(element);
 
-            auto fvGeometry = localView(*this->fvGridGeometry_);
+            auto fvGeometry = localView(*this->gridGeometry_);
             auto elemVolVars = localView(this->curGridVolVars());
             auto elemFluxVarsCache = localView(this->gridFluxVarsCache());
 
diff --git a/dumux/porousmediumflow/problem.hh b/dumux/porousmediumflow/problem.hh
index 384dd51794e8002459d22364616343cf414db08a..03c55997a9ce6440f5b16095b91ca1b5eec36f69 100644
--- a/dumux/porousmediumflow/problem.hh
+++ b/dumux/porousmediumflow/problem.hh
@@ -38,7 +38,7 @@ template<class TypeTag>
 class PorousMediumFlowProblem : public FVProblem<TypeTag>
 {
     using ParentType = FVProblem<TypeTag>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
 
     enum {
@@ -60,14 +60,14 @@ public:
     /*!
      * \brief Constructor, passing the spatial parameters.
      *
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param spatialParams The spatial parameter class
      * \param paramGroup The parameter group in which to look for runtime parameters first (default is "")
      */
-    PorousMediumFlowProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    PorousMediumFlowProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                             std::shared_ptr<SpatialParams> spatialParams,
                             const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, paramGroup)
+    : ParentType(gridGeometry, paramGroup)
     , gravity_(0.0)
     , spatialParams_(spatialParams)
     {
@@ -79,13 +79,13 @@ public:
     /*!
      * \brief Constructor, constructing the spatial parameters.
      *
-     * \param fvGridGeometry The finite volume grid geometry
+     * \param gridGeometry The finite volume grid geometry
      * \param paramGroup The parameter group in which to look for runtime parameters first (default is "")
      */
-    PorousMediumFlowProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    PorousMediumFlowProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                             const std::string& paramGroup = "")
-    : PorousMediumFlowProblem(fvGridGeometry,
-                              std::make_shared<SpatialParams>(fvGridGeometry),
+    : PorousMediumFlowProblem(gridGeometry,
+                              std::make_shared<SpatialParams>(gridGeometry),
                               paramGroup)
     {}
 
diff --git a/dumux/porousmediumflow/richards/newtonsolver.hh b/dumux/porousmediumflow/richards/newtonsolver.hh
index ffb72218faef890313bc2a148e22503b93e27a20..bafc188d171595db8b09b5a411a1f5e1f59e518b 100644
--- a/dumux/porousmediumflow/richards/newtonsolver.hh
+++ b/dumux/porousmediumflow/richards/newtonsolver.hh
@@ -75,10 +75,10 @@ private:
         if (this->numSteps_ <= 4)
         {
             // clamp saturation change to at most 20% per iteration
-            const auto& fvGridGeometry = this->assembler().gridGeometry();
-            for (const auto& element : elements(fvGridGeometry.gridView()))
+            const auto& gridGeometry = this->assembler().gridGeometry();
+            for (const auto& element : elements(gridGeometry.gridView()))
             {
-                auto fvGeometry = localView(fvGridGeometry);
+                auto fvGeometry = localView(gridGeometry);
                 fvGeometry.bindElement(element);
 
                 for (auto&& scv : scvs(fvGeometry))
@@ -87,7 +87,7 @@ private:
 
                     // calculate the old wetting phase saturation
                     const auto& spatialParams = this->assembler().problem().spatialParams();
-                    const auto elemSol = elementSolution(element, uCurrentIter, fvGridGeometry);
+                    const auto elemSol = elementSolution(element, uCurrentIter, gridGeometry);
                     const auto& materialLawParams = spatialParams.materialLawParams(element, scv, elemSol);
                     const Scalar pcMin = MaterialLaw::pc(materialLawParams, 1.0);
                     const Scalar pw = uLastIter[dofIdxGlobal][pressureIdx];
diff --git a/dumux/porousmediumflow/velocity.hh b/dumux/porousmediumflow/velocity.hh
index 28e9d3affa38b1cf5ac3677ca6b308d8ae66c5e8..5531251ccb7729792447e80a7fcd7f816c546691 100644
--- a/dumux/porousmediumflow/velocity.hh
+++ b/dumux/porousmediumflow/velocity.hh
@@ -45,11 +45,11 @@ namespace Dumux {
 template<class GridVariables, class FluxVariables>
 class PorousMediumFlowVelocity
 {
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GridVolumeVariables = typename GridVariables::GridVolumeVariables;
     using ElementFluxVarsCache = typename GridVariables::GridFluxVariablesCache::LocalView;
@@ -60,7 +60,7 @@ class PorousMediumFlowVelocity
 
     static constexpr int dim = GridView::dimension;
     static constexpr int dimWorld = GridView::dimensionworld;
-    static constexpr bool isBox = FVGridGeometry::discMethod == DiscretizationMethod::box;
+    static constexpr bool isBox = GridGeometry::discMethod == DiscretizationMethod::box;
     static constexpr int dofCodim = isBox ? dim : 0;
 
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
@@ -80,18 +80,18 @@ public:
      */
     PorousMediumFlowVelocity(const GridVariables& gridVariables)
     : problem_(gridVariables.curGridVolVars().problem())
-    , fvGridGeometry_(gridVariables.gridGeometry())
+    , gridGeometry_(gridVariables.gridGeometry())
     , gridVariables_(gridVariables)
     {
         // set the number of scvs the vertices are connected to
         if (isBox && dim > 1)
         {
             // resize to the number of vertices of the grid
-            cellNum_.assign(fvGridGeometry_.gridView().size(dim), 0);
+            cellNum_.assign(gridGeometry_.gridView().size(dim), 0);
 
-            for (const auto& element : elements(fvGridGeometry_.gridView()))
+            for (const auto& element : elements(gridGeometry_.gridView()))
                 for (unsigned int vIdx = 0; vIdx < element.subEntities(dim); ++vIdx)
-                    ++cellNum_[fvGridGeometry_.vertexMapper().subIndex(element, vIdx, dim)];
+                    ++cellNum_[gridGeometry_.vertexMapper().subIndex(element, vIdx, dim)];
         }
     }
 
@@ -135,7 +135,7 @@ public:
                 flux /= insideVolVars.extrusionFactor();
                 tmpVelocity *= flux;
 
-                const int eIdxGlobal = fvGridGeometry_.elementMapper().index(element);
+                const int eIdxGlobal = gridGeometry_.elementMapper().index(element);
                 velocity[eIdxGlobal] = tmpVelocity;
             }
             return;
@@ -205,7 +205,7 @@ public:
             // For the number of scvfs per facet (mpfa) we simply obtain the number of
             // corners of the first facet as prisms/pyramids are not supported here anyway
             // -> for prisms/pyramids the number of scvfs would differ from facet to facet
-            static constexpr bool isMpfa = FVGridGeometry::discMethod == DiscretizationMethod::ccmpfa;
+            static constexpr bool isMpfa = GridGeometry::discMethod == DiscretizationMethod::ccmpfa;
             const int numScvfsPerFace = isMpfa ? element.template subEntity<1>(0).geometry().corners() : 1;
 
             if (fvGeometry.numScvf() != element.subEntities(1)*numScvfsPerFace)
@@ -225,7 +225,7 @@ public:
             // find the local face indices of the scvfs (for conforming meshes)
             std::vector<unsigned int> scvfIndexInInside(fvGeometry.numScvf());
             int localScvfIdx = 0;
-            for (const auto& intersection : intersections(fvGridGeometry_.gridView(), element))
+            for (const auto& intersection : intersections(gridGeometry_.gridView(), element))
             {
                 if (dim < dimWorld)
                     if (handledScvf[intersection.indexInInside()])
@@ -331,7 +331,7 @@ public:
 
             scvVelocity /= geometry.integrationElement(localPos);
 
-            int eIdxGlobal = fvGridGeometry_.elementMapper().index(element);
+            int eIdxGlobal = gridGeometry_.elementMapper().index(element);
 
             velocity[eIdxGlobal] = scvVelocity;
 
@@ -420,7 +420,7 @@ private:
     { return BoundaryTypes(); }
 
     const Problem& problem_;
-    const FVGridGeometry& fvGridGeometry_;
+    const GridGeometry& gridGeometry_;
     const GridVariables& gridVariables_;
 
     std::vector<int> cellNum_;
diff --git a/dumux/porousmediumflow/velocityoutput.hh b/dumux/porousmediumflow/velocityoutput.hh
index 0d04c5b57890d34f34a92432774437909750406d..d9aff469c487c83c8235f2091e109f20ffbc43f8 100644
--- a/dumux/porousmediumflow/velocityoutput.hh
+++ b/dumux/porousmediumflow/velocityoutput.hh
@@ -46,11 +46,11 @@ template<class GridVariables, class FluxVariables>
 class PorousMediumFlowVelocityOutput : public VelocityOutput<GridVariables>
 {
     using ParentType = VelocityOutput<GridVariables>;
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GridVolumeVariables = typename GridVariables::GridVolumeVariables;
     using ElementFluxVarsCache = typename GridVariables::GridFluxVariablesCache::LocalView;
@@ -61,7 +61,7 @@ class PorousMediumFlowVelocityOutput : public VelocityOutput<GridVariables>
 
     static constexpr int dim = GridView::dimension;
     static constexpr int dimWorld = GridView::dimensionworld;
-    static constexpr bool isBox = FVGridGeometry::discMethod == DiscretizationMethod::box;
+    static constexpr bool isBox = GridGeometry::discMethod == DiscretizationMethod::box;
     static constexpr int dofCodim = isBox ? dim : 0;
 
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
diff --git a/examples/1ptracer/main.cc b/examples/1ptracer/main.cc
index ba44ca3f761653d7e7cd5d534a5db055675180d1..0325eeac465862445fcd2a6b55c1278cd57cb03d 100644
--- a/examples/1ptracer/main.cc
+++ b/examples/1ptracer/main.cc
@@ -87,13 +87,13 @@ int main(int argc, char** argv) try
     // #### Set-up
     // We create and initialize the finite volume grid geometry, the problem, the linear system, including the jacobian matrix, the residual and the solution vector and the gridvariables.
     // We need the finite volume geometry to build up the subcontrolvolumes (scv) and subcontrolvolume faces (scvf) for each element of the grid partition.
-    using FVGridGeometry = GetPropType<OnePTypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<OnePTypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // In the problem, we define the boundary and initial conditions.
     using OnePProblem = GetPropType<OnePTypeTag, Properties::Problem>;
-    auto problemOneP = std::make_shared<OnePProblem>(fvGridGeometry);
+    auto problemOneP = std::make_shared<OnePProblem>(gridGeometry);
 
     // The jacobian matrix (`A`), the solution vector (`p`) and the residual (`r`) are parts of the linear system.
     using JacobianMatrix = GetPropType<OnePTypeTag, Properties::JacobianMatrix>;
@@ -105,13 +105,13 @@ int main(int argc, char** argv) try
 
     // The grid variables store variables on scv and scvf (volume and flux variables).
     using OnePGridVariables = GetPropType<OnePTypeTag, Properties::GridVariables>;
-    auto onePGridVariables = std::make_shared<OnePGridVariables>(problemOneP, fvGridGeometry);
+    auto onePGridVariables = std::make_shared<OnePGridVariables>(problemOneP, gridGeometry);
     onePGridVariables->init(p);
 
     // #### Assembling the linear system
     // We created and inizialize the assembler.
     using OnePAssembler = FVAssembler<OnePTypeTag, DiffMethod::analytic>;
-    auto assemblerOneP = std::make_shared<OnePAssembler>(problemOneP, fvGridGeometry, onePGridVariables);
+    auto assemblerOneP = std::make_shared<OnePAssembler>(problemOneP, gridGeometry, onePGridVariables);
     assemblerOneP->setLinearSystem(A, r);
 
     // We assemble the local jacobian and the residual and stop the time needed, which is displayed in the terminal output, using the `assemblyTimer`. Further, we start the timer to evaluate the total time of the assembly, solving and updating.
@@ -159,7 +159,7 @@ int main(int argc, char** argv) try
     // We use the results of the 1p problem to calculate the volume fluxes in the model domain.
 
     using Scalar =  GetPropType<OnePTypeTag, Properties::Scalar>;
-    std::vector<Scalar> volumeFlux(fvGridGeometry->numScvf(), 0.0);
+    std::vector<Scalar> volumeFlux(gridGeometry->numScvf(), 0.0);
 
     using FluxVariables =  GetPropType<OnePTypeTag, Properties::FluxVariables>;
     auto upwindTerm = [](const auto& volVars) { return volVars.mobility(0); };
@@ -167,7 +167,7 @@ int main(int argc, char** argv) try
     // We iterate over all elements.
     for (const auto& element : elements(leafGridView))
     {
-        auto fvGeometry = localView(*fvGridGeometry);
+        auto fvGeometry = localView(*gridGeometry);
         fvGeometry.bind(element);
 
         auto elemVolVars = localView(onePGridVariables->curGridVolVars());
@@ -206,7 +206,7 @@ int main(int argc, char** argv) try
     // #### Set-up
     // Similar to the 1p problem, we first create and initialize the problem.
     using TracerProblem = GetPropType<TracerTypeTag, Properties::Problem>;
-    auto tracerProblem = std::make_shared<TracerProblem>(fvGridGeometry);
+    auto tracerProblem = std::make_shared<TracerProblem>(gridGeometry);
 
     // We use the volume fluxes calculated in the previous section as input for the tracer model.
     tracerProblem->spatialParams().setVolumeFlux(volumeFlux);
@@ -218,7 +218,7 @@ int main(int argc, char** argv) try
 
     // We create and initialize the grid variables.
     using GridVariables = GetPropType<TracerTypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(tracerProblem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(tracerProblem, gridGeometry);
     gridVariables->init(x);
 
     // We read in some time loop parameters from the input file. The parameter `tEnd` defines the duration of the simulation, dt the initial time step size and `maxDt` the maximal time step size.
@@ -232,7 +232,7 @@ int main(int argc, char** argv) try
 
     // We create and inizialize the assembler with time loop for the instationary problem.
     using TracerAssembler = FVAssembler<TracerTypeTag, DiffMethod::analytic, /*implicit=*/false>;
-    auto assembler = std::make_shared<TracerAssembler>(tracerProblem, fvGridGeometry, gridVariables, timeLoop);
+    auto assembler = std::make_shared<TracerAssembler>(tracerProblem, gridGeometry, gridVariables, timeLoop);
     assembler->setLinearSystem(A, r);
 
     // We initialize the vtk output module and add a velocity output.
diff --git a/examples/1ptracer/problem_1p.hh b/examples/1ptracer/problem_1p.hh
index 82dd98a0cba091efbdf5f402e8a0f4da8a366972..cd8caedb33d837adeecb818e87a056acae1ce424 100644
--- a/examples/1ptracer/problem_1p.hh
+++ b/examples/1ptracer/problem_1p.hh
@@ -72,10 +72,10 @@ template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::IncompressibleTest>
 {
     // We define convenient shortcuts to the properties `GridGeometry` and `Scalar`:
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     // Finally, we set the spatial parameters:
-    using type = OnePTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // The local residual contains analytic derivative methods for incompressible flow:
@@ -120,15 +120,15 @@ class OnePTestProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
 
     static constexpr int dimWorld = GridView::dimensionworld;
 
 public:
     // This is the constructor of our problem class:
-    OnePTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry) {}
+    OnePTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry) {}
 
     // First, we define the type of boundary conditions depending on location. Two types of boundary  conditions
     // can be specified: Dirichlet or Neumann boundary condition. On a Dirichlet boundary, the values of the
diff --git a/examples/1ptracer/problem_tracer.hh b/examples/1ptracer/problem_tracer.hh
index bebaa7abdeebcc3675026e8b3e9d8a409e0556af..07f00277c6685c783e5b505d80934aed67cc3fe9 100644
--- a/examples/1ptracer/problem_tracer.hh
+++ b/examples/1ptracer/problem_tracer.hh
@@ -73,9 +73,9 @@ struct Problem<TypeTag, TTag::TracerTest> { using type = TracerTestProblem<TypeT
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::TracerTest>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = TracerTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = TracerTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // We define that mass fractions are used to define the concentrations
@@ -151,20 +151,20 @@ class TracerTestProblem : public PorousMediumFlowProblem<TypeTag>
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using SpatialParams = GetPropType<TypeTag, Properties::SpatialParams>;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
     //We create a bool saying whether mole or mass fractions are used
     static constexpr bool useMoles = getPropValue<TypeTag, Properties::UseMoles>();
 
 public:
     // This is the constructor of our problem class:
-    TracerTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeom)
-    : ParentType(fvGridGeom)
+    TracerTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         // We print out whether mole or mass fractions are used
         if(useMoles)
diff --git a/examples/1ptracer/spatialparams_1p.hh b/examples/1ptracer/spatialparams_1p.hh
index 885f21d1ba56f8d3044404c433620382793b07b3..38d22f0fbad3e17824620e79c46121dad42b1eb0 100644
--- a/examples/1ptracer/spatialparams_1p.hh
+++ b/examples/1ptracer/spatialparams_1p.hh
@@ -34,26 +34,26 @@ namespace Dumux {
 
 // In the `OnePTestSpatialParams` class, we define all functions needed to describe the porous matrix, e.g. porosity and permeability for the 1p_problem.
 
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class OnePTestSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             OnePTestSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             OnePTestSpatialParams<GridGeometry, Scalar>>
 {
     // We introduce `using` declarations that are derived from the property system, which we need in this class.
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                           OnePTestSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar,
+                                           OnePTestSpatialParams<GridGeometry, Scalar>>;
 
     static constexpr int dimWorld = GridView::dimensionworld;
     using GlobalPosition = typename SubControlVolume::GlobalPosition;
 
 public:
     using PermeabilityType = Scalar;
-    OnePTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), K_(fvGridGeometry->gridView().size(0), 0.0)
+    OnePTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), K_(gridGeometry->gridView().size(0), 0.0)
     {
         // ### Generation of the random permeability field
         // We get the permeability of the domain and the lens from the `params.input` file.
@@ -68,9 +68,9 @@ public:
         std::mt19937 rand(0);
         std::lognormal_distribution<Scalar> K(std::log(permeability_), std::log(permeability_)*0.1);
         std::lognormal_distribution<Scalar> KLens(std::log(permeabilityLens_), std::log(permeabilityLens_)*0.1);
-        for (const auto& element : elements(fvGridGeometry->gridView()))
+        for (const auto& element : elements(gridGeometry->gridView()))
         {
-            const auto eIdx = fvGridGeometry->elementMapper().index(element);
+            const auto eIdx = gridGeometry->elementMapper().index(element);
             const auto globalPos = element.geometry().center();
             K_[eIdx] = isInLens_(globalPos) ? KLens(rand) : K(rand);
         }
diff --git a/examples/1ptracer/spatialparams_tracer.hh b/examples/1ptracer/spatialparams_tracer.hh
index 6a13799bded4ce59f9d1fc5948ab3e79b8765747..00bedcae4cce36f5af8ba92f90c339ef5d2752b5 100644
--- a/examples/1ptracer/spatialparams_tracer.hh
+++ b/examples/1ptracer/spatialparams_tracer.hh
@@ -33,26 +33,26 @@ namespace Dumux {
 
 // In the `TracerTestSpatialParams` class, we define all functions needed to describe spatially dependent parameters for the `tracer_problem`.
 
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class TracerTestSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             TracerTestSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             TracerTestSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                           TracerTestSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar,
+                                           TracerTestSpatialParams<GridGeometry, Scalar>>;
 
     static const int dimWorld = GridView::dimensionworld;
     using GlobalPosition = typename Dune::FieldVector<Scalar, dimWorld>;
 
 public:
 
-    TracerTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry) {}
+    TracerTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry) {}
 
     // ### Properties of the porous matrix
     // We define the same porosity for the whole domain as in the 1p spatialparams.
diff --git a/examples/2pinfiltration/main.cc b/examples/2pinfiltration/main.cc
index 46b31e111b878008f29eb023d3f4055089af05a9..8d5f1dc50f7f2899d405d62dab6e2808d8fa0843 100644
--- a/examples/2pinfiltration/main.cc
+++ b/examples/2pinfiltration/main.cc
@@ -102,25 +102,25 @@ int main(int argc, char** argv) try
     // We create and initialize the finite volume grid geometry, the problem, the linear system, including the jacobian matrix, the residual and the solution vector and the gridvariables.
     //
     // We need the finite volume geometry to build up the subcontrolvolumes (scv) and subcontrolvolume faces (scvf) for each element of the grid partition.
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // In the problem, we define the boundary and initial conditions.
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
     // We call the `computePointSourceMap` method  to compute the point sources. The `computePointSourceMap` method is inherited from the fvproblem and therefore specified in the `dumux/common/fvproblem.hh`. It calls the `addPointSources` method specified in the `problem.hh` file.
     problem->computePointSourceMap();
 
     // We initialize the solution vector,
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // and then use the solution vector to intialize the `gridVariables`.
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     //We instantiate the indicator for grid adaption & the data transfer, we read some parameters for indicator from the input file.
@@ -128,12 +128,12 @@ int main(int argc, char** argv) try
     const Scalar refineTol = getParam<Scalar>("Adaptive.RefineTolerance");
     const Scalar coarsenTol = getParam<Scalar>("Adaptive.CoarsenTolerance");
     // We use an indicator for a two-phase flow problem that is saturation-dependent and defined in the file `dumux/porousmediumflow/2p/gridadaptindicator.hh.` It allows to set the minimum and maximum allowed refinement levels via the input parameters.
-    TwoPGridAdaptIndicator<TypeTag> indicator(fvGridGeometry);
+    TwoPGridAdaptIndicator<TypeTag> indicator(gridGeometry);
     // The data transfer performs the transfer of data on a grid from before to after adaptation and is defined in the file `dumux/porousmediumflow/2p/griddatatransfer.hh`. Its main functions are to store and reconstruct the primary variables.
-    TwoPGridDataTransfer<TypeTag> dataTransfer(problem, fvGridGeometry, gridVariables, x);
+    TwoPGridDataTransfer<TypeTag> dataTransfer(problem, gridGeometry, gridVariables, x);
 
     // We do an initial refinement around sources/BCs. We use the `GridAdaptInitializationIndicator` defined in `dumux/adaptive/initializationindicator.hh` for that.
-    GridAdaptInitializationIndicator<TypeTag> initIndicator(problem, fvGridGeometry, gridVariables);
+    GridAdaptInitializationIndicator<TypeTag> initIndicator(problem, gridGeometry, gridVariables);
 
     //We refine up to the maximum level. For every level, the indicator used for the refinement/coarsening is calculated. If any grid cells have to be adapted, the gridvariables and the pointsourcemap are updated.
     const auto maxLevel = getParam<std::size_t>("Adaptive.MaxLevel", 0);
@@ -198,11 +198,11 @@ int main(int argc, char** argv) try
 
     //we set the assembler with the time loop because we have an instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop);
 
     // we set the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // additionally we set the non-linear solver.
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/examples/2pinfiltration/problem.hh b/examples/2pinfiltration/problem.hh
index 913962b7f8ebe53a5da511ec7e110269984f0542..f7ddfceef02c00a5bf21bdba455b2db32289cf1d 100644
--- a/examples/2pinfiltration/problem.hh
+++ b/examples/2pinfiltration/problem.hh
@@ -106,11 +106,11 @@ namespace Dumux {
   {
       // We define convenient shortcuts to the properties GridGeometry and Scalar:
   private:
-      using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+      using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
       using Scalar = GetPropType<TypeTag, Properties::Scalar>;
       // Finally we set the spatial parameters:
   public:
-      using type = TwoPTestSpatialParams<FVGridGeometry, Scalar>;
+      using type = TwoPTestSpatialParams<GridGeometry, Scalar>;
   };
 
   // We enable caching for the grid volume variables, the grid flux variables and the FV grid geometry. The cache
@@ -139,7 +139,7 @@ class PointSourceProblem : public PorousMediumFlowProblem<TypeTag>
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using PointSource =  GetPropType<TypeTag, Properties::PointSource>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
@@ -157,8 +157,8 @@ class PointSourceProblem : public PorousMediumFlowProblem<TypeTag>
 
 public:
     // This is the constructor of our problem class:
-    PointSourceProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-  : ParentType(fvGridGeometry)
+    PointSourceProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+  : ParentType(gridGeometry)
   {
     // We read in the values for the initial condition of our simulation:
     initialValues_ = readFileToContainer<std::vector<PrimaryVariables>>("initialsolutioncc.txt");
diff --git a/examples/2pinfiltration/spatialparams.hh b/examples/2pinfiltration/spatialparams.hh
index c261ac81e4fcd969f370d8438035fc8842b8b9fd..4bcb5292d01b0891a6587d4957baaf304c339d29 100644
--- a/examples/2pinfiltration/spatialparams.hh
+++ b/examples/2pinfiltration/spatialparams.hh
@@ -32,17 +32,17 @@ namespace Dumux {
 
 //In the TwoPTestSpatialParams class we define all functions needed to describe the porous matrix, e.g. porosity and permeability
 
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class TwoPTestSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar, TwoPTestSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar, TwoPTestSpatialParams<GridGeometry, Scalar>>
 {
     //we introduce using declarations that are derived from the property system which we need in this class
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
-    using ThisType = TwoPTestSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, ThisType>;
+    using ThisType = TwoPTestSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, ThisType>;
 
     static constexpr int dimWorld = GridView::dimensionworld;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
@@ -54,8 +54,8 @@ public:
     using MaterialLawParams = typename MaterialLaw::Params;
     using PermeabilityType = Scalar;
 
-    TwoPTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    TwoPTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         //we get the position of the lens from the params.input file. The lens is defined by the position of the lower left and the upper right corner
         lensLowerLeft_ = getParam<GlobalPosition>("SpatialParams.LensLowerLeft");
diff --git a/examples/shallowwaterfriction/problem.hh b/examples/shallowwaterfriction/problem.hh
index 91f9b47cfaaded6630b9652b46fe919699b81b46..8d7c55f968085cf13f71f0da8716cea775cf6114 100644
--- a/examples/shallowwaterfriction/problem.hh
+++ b/examples/shallowwaterfriction/problem.hh
@@ -68,14 +68,14 @@ template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::RoughChannel>
 {
 private:
-    // We define convenient shortcuts to the properties FVGridGeometry, Scalar, ElementVolumeVariables and VolumeVariables:
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    // We define convenient shortcuts to the properties GridGeometry, Scalar, ElementVolumeVariables and VolumeVariables:
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
     using VolumeVariables = typename ElementVolumeVariables::VolumeVariables;
     // Finally we set the spatial parameters:
 public:
-    using type = RoughChannelSpatialParams<FVGridGeometry, Scalar, VolumeVariables>;
+    using type = RoughChannelSpatialParams<GridGeometry, Scalar, VolumeVariables>;
 };
 
 // We enable caching for the FV grid geometry and the grid volume variables. The cache
@@ -103,7 +103,7 @@ class RoughChannelProblem : public ShallowWaterProblem<TypeTag>
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using NeumannFluxes = GetPropType<TypeTag, Properties::NumEqVector>;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
@@ -119,8 +119,8 @@ class RoughChannelProblem : public ShallowWaterProblem<TypeTag>
 
 public:
     // This is the constructor of our problem class.
-    RoughChannelProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    RoughChannelProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         // We read the parameters from the params.input file.
         name_ = getParam<std::string>("Problem.Name");
@@ -130,8 +130,8 @@ public:
         // We calculate the outflow boundary condition using the Gauckler-Manning-Strickler formula.
         hBoundary_ = this->gauklerManningStrickler(discharge_,constManningN_,bedSlope_);
         // We initialize the analytic solution to a verctor of the appropriate size filled with zeros.
-        exactWaterDepth_.resize(fvGridGeometry->numDofs(), 0.0);
-        exactVelocityX_.resize(fvGridGeometry->numDofs(), 0.0);
+        exactWaterDepth_.resize(gridGeometry->numDofs(), 0.0);
+        exactVelocityX_.resize(gridGeometry->numDofs(), 0.0);
     }
 
     // Get the analytical water depth
diff --git a/examples/shallowwaterfriction/spatialparams.hh b/examples/shallowwaterfriction/spatialparams.hh
index a6e6f315afe0435dfc7eebc5e1568115464960a1..17bca79fee127dfc08583c8a67a7fb787477acfe 100644
--- a/examples/shallowwaterfriction/spatialparams.hh
+++ b/examples/shallowwaterfriction/spatialparams.hh
@@ -34,24 +34,24 @@
 namespace Dumux {
 
 //In the RoughChannelSpatialParams class we define all functions needed to describe the spatial distributed parameters.
-template<class FVGridGeometry, class Scalar, class VolumeVariables>
+template<class GridGeometry, class Scalar, class VolumeVariables>
 class RoughChannelSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         RoughChannelSpatialParams<FVGridGeometry, Scalar, VolumeVariables>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         RoughChannelSpatialParams<GridGeometry, Scalar, VolumeVariables>>
 {
     // We introduce using declarations that are derived from the property system which we need in this class
-    using ThisType = RoughChannelSpatialParams<FVGridGeometry, Scalar, VolumeVariables>;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, ThisType>;
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using ThisType = RoughChannelSpatialParams<GridGeometry, Scalar, VolumeVariables>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, ThisType>;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
     // In the constructor be read some values from the `params.input` and initialize the friciton law.
-    RoughChannelSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    RoughChannelSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         gravity_ = getParam<Scalar>("Problem.Gravity");
         bedSlope_ = getParam<Scalar>("Problem.BedSlope");
diff --git a/test/discretization/box/test_boxfvgeometry.cc b/test/discretization/box/test_boxfvgeometry.cc
index 17b719f0ae2ad754a35c05ddff38c302af6768bd..6e6688f9e4013e02d765581f8e6c2c447266c4c0 100644
--- a/test/discretization/box/test_boxfvgeometry.cc
+++ b/test/discretization/box/test_boxfvgeometry.cc
@@ -59,8 +59,8 @@ int main (int argc, char *argv[]) try
 
     constexpr int dim = Grid::dimension;
 
-    using FVGridGeometry = BoxFVGridGeometry<double, typename Grid::LeafGridView, ENABLE_CACHING>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = BoxFVGridGeometry<double, typename Grid::LeafGridView, ENABLE_CACHING>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using GlobalPosition = typename SubControlVolume::GlobalPosition;
@@ -72,15 +72,15 @@ int main (int argc, char *argv[]) try
     std::shared_ptr<Grid> grid = Dune::StructuredGridFactory<Grid>::createCubeGrid(lower, upper, els);
     auto leafGridView = grid->leafGridView();
 
-    FVGridGeometry fvGridGeometry(leafGridView);
-    fvGridGeometry.update();
+    GridGeometry gridGeometry(leafGridView);
+    gridGeometry.update();
 
     // iterate over elements. For every element get fv geometry and loop over scvs and scvfaces
     for (const auto& element : elements(leafGridView))
     {
-        auto eIdx = fvGridGeometry.elementMapper().index(element);
+        auto eIdx = gridGeometry.elementMapper().index(element);
         std::cout << std::endl << "Checking fvGeometry of element " << eIdx << std::endl;
-        auto fvGeometry = localView(fvGridGeometry);
+        auto fvGeometry = localView(gridGeometry);
         fvGeometry.bind(element);
 
         auto range = scvs(fvGeometry);
diff --git a/test/discretization/cellcentered/tpfa/test_tpfafvgeometry.cc b/test/discretization/cellcentered/tpfa/test_tpfafvgeometry.cc
index 5c95f2d5e6dd4e1f09e091898cfee446a9a4288a..856b3f6517cf3889d162c9e7fbf9274c53582947 100644
--- a/test/discretization/cellcentered/tpfa/test_tpfafvgeometry.cc
+++ b/test/discretization/cellcentered/tpfa/test_tpfafvgeometry.cc
@@ -59,8 +59,8 @@ int main (int argc, char *argv[]) try
 
     constexpr int dim = Grid::dimension;
 
-    using FVGridGeometry = CCTpfaFVGridGeometry<typename Grid::LeafGridView, ENABLE_CACHING>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = CCTpfaFVGridGeometry<typename Grid::LeafGridView, ENABLE_CACHING>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using GlobalPosition = typename SubControlVolume::GlobalPosition;
@@ -71,17 +71,17 @@ int main (int argc, char *argv[]) try
     std::array<unsigned int, dim> els{{2, 2}};
     std::shared_ptr<Grid> grid = Dune::StructuredGridFactory<Grid>::createCubeGrid(lower, upper, els);
 
-    // obtain leaf and make FVGridGeometry
+    // obtain leaf and make GridGeometry
     auto leafGridView = grid->leafGridView();
-    FVGridGeometry fvGridGeometry(leafGridView);
-    fvGridGeometry.update();
+    GridGeometry gridGeometry(leafGridView);
+    gridGeometry.update();
 
     // iterate over elements. For every element get fv geometry and loop over scvs and scvfaces
     for (const auto& element : elements(leafGridView))
     {
-        auto eIdx = fvGridGeometry.elementMapper().index(element);
+        auto eIdx = gridGeometry.elementMapper().index(element);
         std::cout << std::endl << "Checking fvGeometry of element " << eIdx << std::endl;
-        auto fvGeometry = localView(fvGridGeometry);
+        auto fvGeometry = localView(gridGeometry);
         fvGeometry.bind(element);
 
         auto range = scvs(fvGeometry);
diff --git a/test/discretization/cellcentered/tpfa/test_tpfafvgeometry_nonconforming.cc b/test/discretization/cellcentered/tpfa/test_tpfafvgeometry_nonconforming.cc
index c5159902879adb1a7c8d77693a19263f13cdcfdc..ffbed2d4b53bf8f53fef3164a65c7ebce01e43de 100644
--- a/test/discretization/cellcentered/tpfa/test_tpfafvgeometry_nonconforming.cc
+++ b/test/discretization/cellcentered/tpfa/test_tpfafvgeometry_nonconforming.cc
@@ -120,8 +120,8 @@ int main (int argc, char *argv[]) try
 
     constexpr int dim = Grid::dimension;
 
-    using FVGridGeometry = CCTpfaFVGridGeometry<typename Grid::LeafGridView, ENABLE_CACHING>;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using GridGeometry = CCTpfaFVGridGeometry<typename Grid::LeafGridView, ENABLE_CACHING>;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
     //! make a grid
@@ -141,22 +141,22 @@ int main (int argc, char *argv[]) try
     if (leafGridView.size(0) != 12)
         DUNE_THROW(Dune::InvalidStateException, "Refined grid does not have exactly 12 elements!");
 
-    //! instantiate and update fvGridGeometry
-    FVGridGeometry fvGridGeometry(leafGridView);
-    fvGridGeometry.update();
+    //! instantiate and update gridGeometry
+    GridGeometry gridGeometry(leafGridView);
+    gridGeometry.update();
 
     //! We should have constructed 12 scvfs
-    if (fvGridGeometry.numScv() != 12)
+    if (gridGeometry.numScv() != 12)
         DUNE_THROW(Dune::InvalidStateException, "FvGridGeometry does not have exactly 12 scvs!");
 
     //! We should have constructed 52 scvfs
-    if (fvGridGeometry.numScvf() != 52)
+    if (gridGeometry.numScvf() != 52)
         DUNE_THROW(Dune::InvalidStateException, "FvGridGeometry does not have exactly 52 scvfs!");
 
     //! iterate over elements and check for each element the number of scvfs
     for (const auto& element : elements(leafGridView))
     {
-        auto fvGeometry = localView(fvGridGeometry);
+        auto fvGeometry = localView(gridGeometry);
         fvGeometry.bind(element);
 
         //! For the tpfa scheme there is always one scv per element
@@ -224,7 +224,7 @@ int main (int argc, char *argv[]) try
             //! check levels of neighbors
             if (!scvf.boundary())
             {
-                const auto outsideElement = fvGridGeometry.element(scvf.outsideScvIdx());
+                const auto outsideElement = gridGeometry.element(scvf.outsideScvIdx());
                 const auto outsideCenter = outsideElement.geometry().center();
 
                 if (isInCentralElement(outsideCenter))
diff --git a/test/discretization/staggered/test_staggered_free_flow_geometry.cc b/test/discretization/staggered/test_staggered_free_flow_geometry.cc
index d0e703c8b612cc1919d914843a7d5baed112c181..b1cdde06fc1dd9fa6e4205affb14900dab5ae9b1 100644
--- a/test/discretization/staggered/test_staggered_free_flow_geometry.cc
+++ b/test/discretization/staggered/test_staggered_free_flow_geometry.cc
@@ -68,11 +68,11 @@ struct TestFVGGTraits : public DefaultMapperTraits<GridView>
         using FaceIdx = Dune::index_constant<1>;
     };
 
-    template<class FVGridGeometry>
-    using ConnectivityMap = StaggeredFreeFlowConnectivityMap<FVGridGeometry>;
+    template<class GridGeometry>
+    using ConnectivityMap = StaggeredFreeFlowConnectivityMap<GridGeometry>;
 
-    template<class FVGridGeometry, bool cachingEnabled>
-    using LocalView = StaggeredFVElementGeometry<FVGridGeometry, cachingEnabled>;
+    template<class GridGeometry, bool cachingEnabled>
+    using LocalView = StaggeredFVElementGeometry<GridGeometry, cachingEnabled>;
 };
 
 } // end namespace Dumux
@@ -95,9 +95,9 @@ int main (int argc, char *argv[]) try
 
     static constexpr int upwindSchemeOrder = 2;
 
-    using FVGridGeometry = StaggeredFVGridGeometry<typename Grid::LeafGridView, /*enable caching=*/ true,
+    using GridGeometry = StaggeredFVGridGeometry<typename Grid::LeafGridView, /*enable caching=*/ true,
                                                    TestFVGGTraits<typename Grid::LeafGridView, upwindSchemeOrder> >;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using GlobalPosition = typename SubControlVolume::GlobalPosition;
@@ -109,8 +109,8 @@ int main (int argc, char *argv[]) try
     std::shared_ptr<Grid> grid = Dune::StructuredGridFactory<Grid>::createCubeGrid(lower, upper, els);
 
     auto leafGridView = grid->leafGridView();
-    FVGridGeometry fvGridGeometry(leafGridView);
-    fvGridGeometry.update();
+    GridGeometry gridGeometry(leafGridView);
+    gridGeometry.update();
 
     std::cout << "Abbreviatons:\n"
               << "pos - postition of face center\n"
@@ -125,11 +125,11 @@ int main (int argc, char *argv[]) try
     // iterate over elements. For every element get fv geometry and loop over scvs and scvfaces
     for (const auto& element : elements(leafGridView))
     {
-        auto eIdx = fvGridGeometry.elementMapper().index(element);
+        auto eIdx = gridGeometry.elementMapper().index(element);
         if(eIdx == 12 || eIdx == 0)
         {
             std::cout << std::endl << "Checking fvGeometry of element " << eIdx << std::endl;
-            auto fvGeometry = localView(fvGridGeometry);
+            auto fvGeometry = localView(gridGeometry);
             fvGeometry.bind(element);
 
             auto range = scvs(fvGeometry);
@@ -162,11 +162,11 @@ int main (int argc, char *argv[]) try
                 std::cout <<  std::fixed << std::left << std::setprecision(2);
 
                 std::cout << " On Axis Dof Index: \n";
-                if(fvGridGeometry.upwindStencilOrder() > 1)
+                if(gridGeometry.upwindStencilOrder() > 1)
                 {std::cout << " | Forward dofIdx : " << std::setw(3) << scvf.axisData().inAxisForwardDofs[0] << "\n";}
                 std::cout << " | Self dofIdx : " << std::setw(3) << scvf.dofIndex() << "\n";
                 std::cout << " | Opposite dofIdx : " << std::setw(3) << scvf.dofIndexOpposingFace() << "\n";
-                if(fvGridGeometry.upwindStencilOrder() > 1)
+                if(gridGeometry.upwindStencilOrder() > 1)
                 {std::cout << " | Backward dofIdx : " << std::setw(3) << scvf.axisData().inAxisBackwardDofs[0] << "\n";}
 
                 std::cout << " Normal Dof Index: \n";
@@ -179,22 +179,22 @@ int main (int argc, char *argv[]) try
                 std::cout << " Parallel Dof Index: \n";
                 for(int i = 0; i < scvf.pairData().size(); i++)
                 {
-                    for(int j = 0; j < fvGridGeometry.upwindStencilOrder(); j++)
+                    for(int j = 0; j < gridGeometry.upwindStencilOrder(); j++)
                     {
                         std::cout << " | Parallel Dof "<< j << " on axis " << i << ": "<<  std::setw(3) << scvf.pairData(i).parallelDofs[j] << "\n";
                     }
                 }
 
                 std::cout << " Distances: \n";
-                if(fvGridGeometry.upwindStencilOrder() > 1)
+                if(gridGeometry.upwindStencilOrder() > 1)
                 {std::cout << " | Opposite To Backwards Face Dist : " << std::setw(3) << scvf.axisData().inAxisBackwardDistances[0] << "\n";}
                 std::cout << " | self To Opposite Dist : " << std::setw(3) << scvf.selfToOppositeDistance() << "\n";
-                if(fvGridGeometry.upwindStencilOrder() > 1)
+                if(gridGeometry.upwindStencilOrder() > 1)
                 {std::cout << " | self To Forwards Face Dist : " << std::setw(3) << scvf.axisData().inAxisForwardDistances[0] << "\n";}
 
                 for(int i = 0; i < scvf.pairData().size(); i++)
                 {
-                    for(int j = 0; j < fvGridGeometry.upwindStencilOrder(); j++)
+                    for(int j = 0; j < gridGeometry.upwindStencilOrder(); j++)
                     {
                         std::cout << " | Parallel Cell Widths "<< j << " on axis " << i << ": "<< std::setw(3) << scvf.pairData(i).parallelCellWidths[j] << "\n";
                     }
@@ -202,7 +202,7 @@ int main (int argc, char *argv[]) try
 
                 for(int i = 0; i < scvf.pairData().size(); i++)
                 {
-                    for(int j = 0; j < fvGridGeometry.upwindStencilOrder(); j++)
+                    for(int j = 0; j < gridGeometry.upwindStencilOrder(); j++)
                     {
                         std::cout << " | Cell Centered Parallel Distance "<< j << " on axis " << i << ": "<< std::setw(3) << scvf.parallelDofsDistance(i,j) << "\n";
                     }
diff --git a/test/discretization/staggered/test_staggeredfvgeometry.cc b/test/discretization/staggered/test_staggeredfvgeometry.cc
index 3296aca99c8253429632cb41f0454d8db37e3b45..e8a067704c7ce06bdd5e978fe90f6f7caff7ed97 100644
--- a/test/discretization/staggered/test_staggeredfvgeometry.cc
+++ b/test/discretization/staggered/test_staggeredfvgeometry.cc
@@ -65,19 +65,19 @@ struct TestFVGGTraits : public DefaultMapperTraits<GridView>
         using FaceIdx = Dune::index_constant<1>;
     };
 
-    //! Dummy connectivity map, required by FVGridGeometry
-    template<class FVGridGeometry>
+    //! Dummy connectivity map, required by GridGeometry
+    template<class GridGeometry>
     struct MockConnectivityMap
     {
-        void update(const FVGridGeometry& fvGridGeometry) {}
+        void update(const GridGeometry& gridGeometry) {}
         void setStencilOrder(const int order) {}
     };
 
-    template<class FVGridGeometry>
-    using ConnectivityMap = MockConnectivityMap<FVGridGeometry>;
+    template<class GridGeometry>
+    using ConnectivityMap = MockConnectivityMap<GridGeometry>;
 
-    template<class FVGridGeometry, bool enableCache>
-    using LocalView = StaggeredFVElementGeometry<FVGridGeometry, enableCache>;
+    template<class GridGeometry, bool enableCache>
+    using LocalView = StaggeredFVElementGeometry<GridGeometry, enableCache>;
 };
 
 } // end namespace Dumux
@@ -101,9 +101,9 @@ int main (int argc, char *argv[]) try
     constexpr int dimworld = Grid::dimensionworld;
 
     using GlobalPosition = typename Dune::FieldVector<Grid::ctype, dimworld>;
-    using FVGridGeometry = StaggeredFVGridGeometry<typename Grid::LeafGridView, /*enable caching=*/ true,
+    using GridGeometry = StaggeredFVGridGeometry<typename Grid::LeafGridView, /*enable caching=*/ true,
                                                    TestFVGGTraits<typename Grid::LeafGridView> >;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
 
@@ -114,15 +114,15 @@ int main (int argc, char *argv[]) try
     std::shared_ptr<Grid> grid = Dune::StructuredGridFactory<Grid>::createCubeGrid(lower, upper, els);
     auto leafGridView = grid->leafGridView();
 
-    FVGridGeometry fvGridGeometry(leafGridView);
-    fvGridGeometry.update();
+    GridGeometry gridGeometry(leafGridView);
+    gridGeometry.update();
 
     // iterate over elements. For every element get fv geometry and loop over scvs and scvfaces
     for (const auto& element : elements(leafGridView))
     {
-        auto eIdx = fvGridGeometry.elementMapper().index(element);
+        auto eIdx = gridGeometry.elementMapper().index(element);
         std::cout << std::endl << "Checking fvGeometry of element " << eIdx << std::endl;
-        auto fvGeometry = localView(fvGridGeometry);
+        auto fvGeometry = localView(gridGeometry);
         fvGeometry.bind(element);
 
         auto range = scvs(fvGeometry);
diff --git a/test/freeflow/navierstokes/angeli/main.cc b/test/freeflow/navierstokes/angeli/main.cc
index 4da3af1cca59d50f73594bcac961ac31ad607cea..cfce492f446b798a9a02006647ea183447a9df68 100644
--- a/test/freeflow/navierstokes/angeli/main.cc
+++ b/test/freeflow/navierstokes/angeli/main.cc
@@ -57,8 +57,8 @@
 template<class Scalar, class Problem>
 auto createAnalyticalSolution(const Scalar time, const Problem& problem)
 {
-    const auto& fvGridGeometry = problem.gridGeometry();
-    using GridView = typename std::decay_t<decltype(fvGridGeometry)>::GridView;
+    const auto& gridGeometry = problem.gridGeometry();
+    using GridView = typename std::decay_t<decltype(gridGeometry)>::GridView;
 
     static constexpr auto dim = GridView::dimension;
     static constexpr auto dimWorld = GridView::dimensionworld;
@@ -69,14 +69,14 @@ auto createAnalyticalSolution(const Scalar time, const Problem& problem)
     std::vector<VelocityVector> analyticalVelocity;
     std::vector<VelocityVector> analyticalVelocityOnFace;
 
-    analyticalPressure.resize(fvGridGeometry.numCellCenterDofs());
-    analyticalVelocity.resize(fvGridGeometry.numCellCenterDofs());
-    analyticalVelocityOnFace.resize(fvGridGeometry.numFaceDofs());
+    analyticalPressure.resize(gridGeometry.numCellCenterDofs());
+    analyticalVelocity.resize(gridGeometry.numCellCenterDofs());
+    analyticalVelocityOnFace.resize(gridGeometry.numFaceDofs());
 
     using Indices = typename Problem::Indices;
-    for (const auto& element : elements(fvGridGeometry.gridView()))
+    for (const auto& element : elements(gridGeometry.gridView()))
     {
-        auto fvGeometry = localView(fvGridGeometry);
+        auto fvGeometry = localView(gridGeometry);
         fvGeometry.bindElement(element);
         for (auto&& scv : scvs(fvGeometry))
         {
@@ -133,9 +133,9 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // get some time loop parameters
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
@@ -149,20 +149,20 @@ int main(int argc, char** argv) try
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
     problem->updateTimeStepSize(timeLoop->timeStepSize());
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     SolutionVector x;
-    x[FVGridGeometry::cellCenterIdx()].resize(fvGridGeometry->numCellCenterDofs());
-    x[FVGridGeometry::faceIdx()].resize(fvGridGeometry->numFaceDofs());
+    x[GridGeometry::cellCenterIdx()].resize(gridGeometry->numCellCenterDofs());
+    x[GridGeometry::faceIdx()].resize(gridGeometry->numFaceDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // initialize the vtk output module
@@ -178,7 +178,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = StaggeredFVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::UMFPackBackend;
@@ -207,8 +207,8 @@ int main(int argc, char** argv) try
 
             using L2Error = NavierStokesTestL2Error<Scalar, ModelTraits, PrimaryVariables>;
             const auto l2error = L2Error::calculateL2Error(*problem, x);
-            const int numCellCenterDofs = fvGridGeometry->numCellCenterDofs();
-            const int numFaceDofs = fvGridGeometry->numFaceDofs();
+            const int numCellCenterDofs = gridGeometry->numCellCenterDofs();
+            const int numFaceDofs = gridGeometry->numFaceDofs();
             std::cout << std::setprecision(8) << "** L2 error (abs/rel) for "
                     << std::setw(6) << numCellCenterDofs << " cc dofs and " << numFaceDofs << " face dofs (total: " << numCellCenterDofs + numFaceDofs << "): "
                     << std::scientific
diff --git a/test/freeflow/navierstokes/angeli/problem.hh b/test/freeflow/navierstokes/angeli/problem.hh
index 2e2f7bd82046dcfa472c50ef9c189f6b7d5a906f..18d1f9090b23ec2e50012fc986283a7624bd90e6 100644
--- a/test/freeflow/navierstokes/angeli/problem.hh
+++ b/test/freeflow/navierstokes/angeli/problem.hh
@@ -88,7 +88,7 @@ class AngeliTestProblem : public NavierStokesProblem<TypeTag>
     using ParentType = NavierStokesProblem<TypeTag>;
 
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
@@ -97,15 +97,15 @@ class AngeliTestProblem : public NavierStokesProblem<TypeTag>
     using TimeLoopPtr = std::shared_ptr<TimeLoop<Scalar>>;
 
     static constexpr auto dimWorld = GetPropType<TypeTag, Properties::GridView>::dimensionworld;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
     using VelocityVector = Dune::FieldVector<Scalar, dimWorld>;
 
 public:
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
 
-    AngeliTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    AngeliTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         kinematicViscosity_ = getParam<Scalar>("Component.LiquidKinematicViscosity", 1.0);
     }
@@ -150,8 +150,8 @@ public:
      * \param pvIdx The primary variable index in the solution vector
      */
     bool isDirichletCell(const Element& element,
-                         const typename FVGridGeometry::LocalView& fvGeometry,
-                         const typename FVGridGeometry::SubControlVolume& scv,
+                         const typename GridGeometry::LocalView& fvGeometry,
+                         const typename GridGeometry::SubControlVolume& scv,
                          int pvIdx) const
     {
         // set a fixed pressure in all cells at the boundary
diff --git a/test/freeflow/navierstokes/channel/1d/main.cc b/test/freeflow/navierstokes/channel/1d/main.cc
index 249474a69eae676648f498d95449a18b0fdcd912..2880b03269d978de714825fb2c91c10ad2c77cc1 100644
--- a/test/freeflow/navierstokes/channel/1d/main.cc
+++ b/test/freeflow/navierstokes/channel/1d/main.cc
@@ -75,23 +75,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     SolutionVector x;
-    x[FVGridGeometry::cellCenterIdx()].resize(fvGridGeometry->numCellCenterDofs());
-    x[FVGridGeometry::faceIdx()].resize(fvGridGeometry->numFaceDofs());
+    x[GridGeometry::cellCenterIdx()].resize(gridGeometry->numCellCenterDofs());
+    x[GridGeometry::faceIdx()].resize(gridGeometry->numFaceDofs());
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -105,7 +105,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = StaggeredFVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables);
 
     // the linear solver
     using LinearSolver = Dumux::UMFPackBackend;
diff --git a/test/freeflow/navierstokes/channel/1d/problem.hh b/test/freeflow/navierstokes/channel/1d/problem.hh
index 4e171491d28a4faea60ec1181b4aa9b0d8a9556d..de84b08752cc736fa9148f6819306db829ae5f23 100644
--- a/test/freeflow/navierstokes/channel/1d/problem.hh
+++ b/test/freeflow/navierstokes/channel/1d/problem.hh
@@ -90,7 +90,7 @@ class NavierStokesAnalyticProblem : public NavierStokesProblem<TypeTag>
     using ParentType = NavierStokesProblem<TypeTag>;
 
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
@@ -99,14 +99,14 @@ class NavierStokesAnalyticProblem : public NavierStokesProblem<TypeTag>
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
 
     static constexpr auto dimWorld = GetPropType<TypeTag, Properties::GridView>::dimensionworld;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
     using DimVector = GlobalPosition;
     using DimMatrix = Dune::FieldMatrix<Scalar, dimWorld, dimWorld>;
 
 public:
-    NavierStokesAnalyticProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), eps_(1e-6)
+    NavierStokesAnalyticProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), eps_(1e-6)
     {
         printL2Error_ = getParam<bool>("Problem.PrintL2Error");
         density_ = getParam<Scalar>("Component.LiquidDensity");
@@ -224,8 +224,8 @@ public:
      * \param pvIdx The primary variable index in the solution vector
      */
     bool isDirichletCell(const Element& element,
-                         const typename FVGridGeometry::LocalView& fvGeometry,
-                         const typename FVGridGeometry::SubControlVolume& scv,
+                         const typename GridGeometry::LocalView& fvGeometry,
+                         const typename GridGeometry::SubControlVolume& scv,
                          int pvIdx) const
     {
         // set a fixed pressure in all cells at the boundary
diff --git a/test/freeflow/navierstokes/channel/2d/main.cc b/test/freeflow/navierstokes/channel/2d/main.cc
index 43da72d5e90b67d505b2d8fbefc810f9657dbdc1..cd95b48b046400e03bd9fcca443c38d85c70f4e4 100644
--- a/test/freeflow/navierstokes/channel/2d/main.cc
+++ b/test/freeflow/navierstokes/channel/2d/main.cc
@@ -76,13 +76,13 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // get some time loop parameters
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
@@ -96,8 +96,8 @@ int main(int argc, char** argv) try
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     SolutionVector x;
-    x[FVGridGeometry::cellCenterIdx()].resize(fvGridGeometry->numCellCenterDofs());
-    x[FVGridGeometry::faceIdx()].resize(fvGridGeometry->numFaceDofs());
+    x[GridGeometry::cellCenterIdx()].resize(gridGeometry->numCellCenterDofs());
+    x[GridGeometry::faceIdx()].resize(gridGeometry->numFaceDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
@@ -108,7 +108,7 @@ int main(int argc, char** argv) try
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // initialize the vtk output module
@@ -119,7 +119,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = StaggeredFVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::UMFPackBackend;
@@ -139,10 +139,10 @@ int main(int argc, char** argv) try
 
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
-    const Scalar xMin = fvGridGeometry->bBoxMin()[0];
-    const Scalar xMax = fvGridGeometry->bBoxMax()[0];
-    const Scalar yMin = fvGridGeometry->bBoxMin()[1];
-    const Scalar yMax = fvGridGeometry->bBoxMax()[1];
+    const Scalar xMin = gridGeometry->bBoxMin()[0];
+    const Scalar xMax = gridGeometry->bBoxMax()[0];
+    const Scalar yMin = gridGeometry->bBoxMin()[1];
+    const Scalar yMax = gridGeometry->bBoxMax()[1];
 
     // The first surface shall be placed at the middle of the channel.
     // If we have an odd number of cells in x-direction, there would not be any cell faces
diff --git a/test/freeflow/navierstokes/channel/2d/problem.hh b/test/freeflow/navierstokes/channel/2d/problem.hh
index d3b47821a7f3346b5d6187ff930d69e1ff1b1655..759ad3bb9732d0e83b172b055ac0f2560ea20851 100644
--- a/test/freeflow/navierstokes/channel/2d/problem.hh
+++ b/test/freeflow/navierstokes/channel/2d/problem.hh
@@ -95,15 +95,15 @@ class ChannelTestProblem : public NavierStokesProblem<TypeTag>
     using ParentType = NavierStokesProblem<TypeTag>;
 
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
     using TimeLoopPtr = std::shared_ptr<CheckPointTimeLoop<Scalar>>;
@@ -115,8 +115,8 @@ class ChannelTestProblem : public NavierStokesProblem<TypeTag>
     };
 
 public:
-    ChannelTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), eps_(1e-6)
+    ChannelTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), eps_(1e-6)
     {
         inletVelocity_ = getParam<Scalar>("Problem.InletVelocity");
         const auto tmp = getParam<std::string>("Problem.OutletCondition", "Outflow");
diff --git a/test/freeflow/navierstokes/channel/3d/main.cc b/test/freeflow/navierstokes/channel/3d/main.cc
index be17fa9846387b54e80de351dc912fb61fae6596..30f792820efd639464df70700b3150de5fd2ff15 100644
--- a/test/freeflow/navierstokes/channel/3d/main.cc
+++ b/test/freeflow/navierstokes/channel/3d/main.cc
@@ -76,23 +76,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     SolutionVector x;
-    x[FVGridGeometry::cellCenterIdx()].resize(fvGridGeometry->numCellCenterDofs());
-    x[FVGridGeometry::faceIdx()].resize(fvGridGeometry->numFaceDofs());
+    x[GridGeometry::cellCenterIdx()].resize(gridGeometry->numCellCenterDofs());
+    x[GridGeometry::faceIdx()].resize(gridGeometry->numFaceDofs());
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -103,7 +103,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = StaggeredFVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables);
 
     // the linear solver
     using LinearSolver = Dumux::UMFPackBackend;
@@ -122,13 +122,13 @@ int main(int argc, char** argv) try
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using GlobalPosition = Dune::FieldVector<Scalar, GridView::dimensionworld>;
 
-    const Scalar xMin = fvGridGeometry->bBoxMin()[0];
-    const Scalar xMax = fvGridGeometry->bBoxMax()[0];
-    const Scalar yMin = fvGridGeometry->bBoxMin()[1];
-    const Scalar yMax = fvGridGeometry->bBoxMax()[1];
+    const Scalar xMin = gridGeometry->bBoxMin()[0];
+    const Scalar xMax = gridGeometry->bBoxMax()[0];
+    const Scalar yMin = gridGeometry->bBoxMin()[1];
+    const Scalar yMax = gridGeometry->bBoxMax()[1];
 #if DIM_3D
-    const Scalar zMin = fvGridGeometry->bBoxMin()[2];
-    const Scalar zMax = fvGridGeometry->bBoxMax()[2];
+    const Scalar zMin = gridGeometry->bBoxMin()[2];
+    const Scalar zMax = gridGeometry->bBoxMax()[2];
 #endif
 
     // The first plane shall be placed at the middle of the channel.
diff --git a/test/freeflow/navierstokes/channel/3d/problem.hh b/test/freeflow/navierstokes/channel/3d/problem.hh
index c9d4f908eccde0233b388f76c9b882d3ae43cfb2..dd5d68fdacd9eaa8371df882b2f7092712e4e116 100644
--- a/test/freeflow/navierstokes/channel/3d/problem.hh
+++ b/test/freeflow/navierstokes/channel/3d/problem.hh
@@ -105,8 +105,8 @@ class ThreeDChannelTestProblem : public NavierStokesProblem<TypeTag>
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using Element = typename GridView::template Codim<0>::Entity;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
 
@@ -123,8 +123,8 @@ class ThreeDChannelTestProblem : public NavierStokesProblem<TypeTag>
     static constexpr bool enablePseudoThreeDWallFriction = !DIM_3D;
 
 public:
-    ThreeDChannelTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), eps_(1e-6)
+    ThreeDChannelTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), eps_(1e-6)
     {
         deltaP_ = getParam<Scalar>("Problem.DeltaP");
         height_ = getParam<Scalar>("Problem.Height");
diff --git a/test/freeflow/navierstokes/closedsystem/main.cc b/test/freeflow/navierstokes/closedsystem/main.cc
index 35e2f9ff8b53b3f8a892ac54aa7df278d1f0b4f6..5e1a20d7a917ce9f76271cbcafca9ecaf49ff7fe 100644
--- a/test/freeflow/navierstokes/closedsystem/main.cc
+++ b/test/freeflow/navierstokes/closedsystem/main.cc
@@ -75,25 +75,25 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     SolutionVector x;
-    x[FVGridGeometry::cellCenterIdx()].resize(fvGridGeometry->numCellCenterDofs());
-    x[FVGridGeometry::faceIdx()].resize(fvGridGeometry->numFaceDofs());
+    x[GridGeometry::cellCenterIdx()].resize(gridGeometry->numCellCenterDofs());
+    x[GridGeometry::faceIdx()].resize(gridGeometry->numFaceDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -114,7 +114,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = StaggeredFVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::UMFPackBackend;
diff --git a/test/freeflow/navierstokes/closedsystem/problem.hh b/test/freeflow/navierstokes/closedsystem/problem.hh
index 3e2054b388b91e010781ae2de2442191528ce335..97153af6faa6f62ba22ea7f35b5f9c06089c79f6 100644
--- a/test/freeflow/navierstokes/closedsystem/problem.hh
+++ b/test/freeflow/navierstokes/closedsystem/problem.hh
@@ -84,21 +84,21 @@ class ClosedSystemTestProblem : public NavierStokesProblem<TypeTag>
     using ParentType = NavierStokesProblem<TypeTag>;
 
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 
     static constexpr auto dimWorld = GetPropType<TypeTag, Properties::GridView>::dimensionworld;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    ClosedSystemTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), eps_(1e-6)
+    ClosedSystemTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), eps_(1e-6)
     {
         lidVelocity_ = getParam<Scalar>("Problem.LidVelocity");
     }
diff --git a/test/freeflow/navierstokes/donea/main.cc b/test/freeflow/navierstokes/donea/main.cc
index c4acd223c09545088cf44cacaa1ad8c4d362122e..1db594dacb9abd0cab367093b0b58af540ab31db 100644
--- a/test/freeflow/navierstokes/donea/main.cc
+++ b/test/freeflow/navierstokes/donea/main.cc
@@ -77,23 +77,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     SolutionVector x;
-    x[FVGridGeometry::cellCenterIdx()].resize(fvGridGeometry->numCellCenterDofs());
-    x[FVGridGeometry::faceIdx()].resize(fvGridGeometry->numFaceDofs());
+    x[GridGeometry::cellCenterIdx()].resize(gridGeometry->numCellCenterDofs());
+    x[GridGeometry::faceIdx()].resize(gridGeometry->numFaceDofs());
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -107,7 +107,7 @@ int main(int argc, char** argv) try
 
     // use the staggered FV assembler
     using Assembler = StaggeredFVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables);
 
     // the linear solver
     using LinearSolver = Dumux::UMFPackBackend;
@@ -117,8 +117,8 @@ int main(int argc, char** argv) try
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
     NewtonSolver nonLinearSolver(assembler, linearSolver);
 
-    using NewtonConvergenceWriter = StaggeredNewtonConvergenceWriter<FVGridGeometry, SolutionVector>;
-    auto convergenceWriter = std::make_shared<NewtonConvergenceWriter>(*fvGridGeometry);
+    using NewtonConvergenceWriter = StaggeredNewtonConvergenceWriter<GridGeometry, SolutionVector>;
+    auto convergenceWriter = std::make_shared<NewtonConvergenceWriter>(*gridGeometry);
     nonLinearSolver.attachConvergenceWriter(convergenceWriter);
 
     // linearize & solve
diff --git a/test/freeflow/navierstokes/donea/problem.hh b/test/freeflow/navierstokes/donea/problem.hh
index 9765de2584b9fa4d4b316898a0369614e16851ff..75026d4e9884ae4f6909fa3b88c32e21b613ac06 100644
--- a/test/freeflow/navierstokes/donea/problem.hh
+++ b/test/freeflow/navierstokes/donea/problem.hh
@@ -91,7 +91,7 @@ class DoneaTestProblem : public NavierStokesProblem<TypeTag>
     using ParentType = NavierStokesProblem<TypeTag>;
 
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
@@ -100,13 +100,13 @@ class DoneaTestProblem : public NavierStokesProblem<TypeTag>
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
 
     static constexpr auto dimWorld = GetPropType<TypeTag, Properties::GridView>::dimensionworld;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
     using VelocityVector = Dune::FieldVector<Scalar, dimWorld>;
 
 public:
-    DoneaTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), eps_(1e-6)
+    DoneaTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), eps_(1e-6)
     {
         printL2Error_ = getParam<bool>("Problem.PrintL2Error");
         createAnalyticalSolution_();
@@ -200,8 +200,8 @@ public:
      * \param pvIdx The primary variable index in the solution vector
      */
     bool isDirichletCell(const Element& element,
-                         const typename FVGridGeometry::LocalView& fvGeometry,
-                         const typename FVGridGeometry::SubControlVolume& scv,
+                         const typename GridGeometry::LocalView& fvGeometry,
+                         const typename GridGeometry::SubControlVolume& scv,
                          int pvIdx) const
     {
         bool onBoundary = false;
diff --git a/test/freeflow/navierstokes/kovasznay/main.cc b/test/freeflow/navierstokes/kovasznay/main.cc
index b60f0d98c051f1dd6554b8cce5e6f0310c9c7420..c21d9a0936fbfe11e162a5ee14395a4ca4a09df6 100644
--- a/test/freeflow/navierstokes/kovasznay/main.cc
+++ b/test/freeflow/navierstokes/kovasznay/main.cc
@@ -75,23 +75,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     SolutionVector x;
-    x[FVGridGeometry::cellCenterIdx()].resize(fvGridGeometry->numCellCenterDofs());
-    x[FVGridGeometry::faceIdx()].resize(fvGridGeometry->numFaceDofs());
+    x[GridGeometry::cellCenterIdx()].resize(gridGeometry->numCellCenterDofs());
+    x[GridGeometry::faceIdx()].resize(gridGeometry->numFaceDofs());
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -105,7 +105,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = StaggeredFVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables);
 
     // the linear solver
     using LinearSolver = Dumux::UMFPackBackend;
diff --git a/test/freeflow/navierstokes/kovasznay/problem.hh b/test/freeflow/navierstokes/kovasznay/problem.hh
index 813b605210fb23c34a44fcc75475a339031eecbb..51441147917a4f936fb2d55f7d93a1dcbabd5b3a 100644
--- a/test/freeflow/navierstokes/kovasznay/problem.hh
+++ b/test/freeflow/navierstokes/kovasznay/problem.hh
@@ -91,9 +91,9 @@ class KovasznayTestProblem : public NavierStokesProblem<TypeTag>
     using ParentType = NavierStokesProblem<TypeTag>;
 
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
@@ -102,18 +102,18 @@ class KovasznayTestProblem : public NavierStokesProblem<TypeTag>
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
 
     static constexpr auto dimWorld = GetPropType<TypeTag, Properties::GridView>::dimensionworld;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
     using VelocityVector = Dune::FieldVector<Scalar, dimWorld>;
 
     static constexpr auto upwindSchemeOrder = getPropValue<TypeTag, Properties::UpwindSchemeOrder>();
 
 public:
-    KovasznayTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), eps_(1e-6)
+    KovasznayTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), eps_(1e-6)
     {
         printL2Error_ = getParam<bool>("Problem.PrintL2Error");
-        std::cout<< "upwindSchemeOrder is: " << FVGridGeometry::upwindStencilOrder() << "\n";
+        std::cout<< "upwindSchemeOrder is: " << GridGeometry::upwindStencilOrder() << "\n";
         kinematicViscosity_ = getParam<Scalar>("Component.LiquidKinematicViscosity", 1.0);
         Scalar reynoldsNumber = 1.0 / kinematicViscosity_;
         lambda_ = 0.5 * reynoldsNumber
diff --git a/test/freeflow/navierstokes/l2error.hh b/test/freeflow/navierstokes/l2error.hh
index 5d19b80104998867d508450f1d04ba80019ac48c..21b0006afe35a5710a4319525a86df669db2b293 100644
--- a/test/freeflow/navierstokes/l2error.hh
+++ b/test/freeflow/navierstokes/l2error.hh
@@ -49,7 +49,7 @@ public:
     template<class Problem, class SolutionVector>
     static auto calculateL2Error(const Problem& problem, const SolutionVector& curSol)
     {
-        using FVGridGeometry = std::decay_t<decltype(problem.gridGeometry())>;
+        using GridGeometry = std::decay_t<decltype(problem.gridGeometry())>;
         PrimaryVariables sumError(0.0), sumReference(0.0), l2NormAbs(0.0), l2NormRel(0.0);
 
         const int numFaceDofs = problem.gridGeometry().numFaceDofs();
@@ -72,7 +72,7 @@ public:
                 const auto dofIdxCellCenter = scv.dofIndex();
                 const auto& posCellCenter = scv.dofPosition();
                 const auto analyticalSolutionCellCenter = problem.dirichletAtPos(posCellCenter)[Indices::pressureIdx];
-                const auto numericalSolutionCellCenter = curSol[FVGridGeometry::cellCenterIdx()][dofIdxCellCenter][Indices::pressureIdx - ModelTraits::dim()];
+                const auto numericalSolutionCellCenter = curSol[GridGeometry::cellCenterIdx()][dofIdxCellCenter][Indices::pressureIdx - ModelTraits::dim()];
                 sumError[Indices::pressureIdx] += squaredDiff_(analyticalSolutionCellCenter, numericalSolutionCellCenter) * scv.volume();
                 sumReference[Indices::pressureIdx] += analyticalSolutionCellCenter * analyticalSolutionCellCenter * scv.volume();
                 totalVolume += scv.volume();
@@ -83,7 +83,7 @@ public:
                     const int dofIdxFace = scvf.dofIndex();
                     const int dirIdx = scvf.directionIndex();
                     const auto analyticalSolutionFace = problem.dirichletAtPos(scvf.center())[Indices::velocity(dirIdx)];
-                    const auto numericalSolutionFace = curSol[FVGridGeometry::faceIdx()][dofIdxFace][0];
+                    const auto numericalSolutionFace = curSol[GridGeometry::faceIdx()][dofIdxFace][0];
                     directionIndex[dofIdxFace] = dirIdx;
                     errorVelocity[dofIdxFace] = squaredDiff_(analyticalSolutionFace, numericalSolutionFace);
                     velocityReference[dofIdxFace] = squaredDiff_(analyticalSolutionFace, 0.0);
diff --git a/test/freeflow/navierstokes/sincos/main.cc b/test/freeflow/navierstokes/sincos/main.cc
index 5437aaa6c84688d982c2eabdc295098864ec2b4a..507ff765ca274320d2dcdab3e33761ca222aa6aa 100644
--- a/test/freeflow/navierstokes/sincos/main.cc
+++ b/test/freeflow/navierstokes/sincos/main.cc
@@ -57,8 +57,8 @@
 template<class Scalar, class Problem>
 auto createAnalyticalSolution(const Scalar time, const Problem& problem)
 {
-    const auto& fvGridGeometry = problem.gridGeometry();
-    using GridView = typename std::decay_t<decltype(fvGridGeometry)>::GridView;
+    const auto& gridGeometry = problem.gridGeometry();
+    using GridView = typename std::decay_t<decltype(gridGeometry)>::GridView;
 
     static constexpr auto dim = GridView::dimension;
     static constexpr auto dimWorld = GridView::dimensionworld;
@@ -69,14 +69,14 @@ auto createAnalyticalSolution(const Scalar time, const Problem& problem)
     std::vector<VelocityVector> analyticalVelocity;
     std::vector<VelocityVector> analyticalVelocityOnFace;
 
-    analyticalPressure.resize(fvGridGeometry.numCellCenterDofs());
-    analyticalVelocity.resize(fvGridGeometry.numCellCenterDofs());
-    analyticalVelocityOnFace.resize(fvGridGeometry.numFaceDofs());
+    analyticalPressure.resize(gridGeometry.numCellCenterDofs());
+    analyticalVelocity.resize(gridGeometry.numCellCenterDofs());
+    analyticalVelocityOnFace.resize(gridGeometry.numFaceDofs());
 
     using Indices = typename Problem::Indices;
-    for (const auto& element : elements(fvGridGeometry.gridView()))
+    for (const auto& element : elements(gridGeometry.gridView()))
     {
-        auto fvGeometry = localView(fvGridGeometry);
+        auto fvGeometry = localView(gridGeometry);
         fvGeometry.bindElement(element);
         for (auto&& scv : scvs(fvGeometry))
         {
@@ -110,17 +110,17 @@ auto createSource(const Problem& problem)
     using Scalar = double;
     using Indices = typename Problem::Indices;
 
-    const auto& fvGridGeometry = problem.gridGeometry();
+    const auto& gridGeometry = problem.gridGeometry();
     std::array<std::vector<Scalar>, Problem::ModelTraits::numEq()> source;
 
     for (auto& component : source)
     {
-        component.resize(fvGridGeometry.numCellCenterDofs());
+        component.resize(gridGeometry.numCellCenterDofs());
     }
 
-    for (const auto& element : elements(fvGridGeometry.gridView()))
+    for (const auto& element : elements(gridGeometry.gridView()))
     {
-        auto fvGeometry = localView(fvGridGeometry);
+        auto fvGeometry = localView(gridGeometry);
         fvGeometry.bindElement(element);
         for (auto&& scv : scvs(fvGeometry))
         {
@@ -137,8 +137,8 @@ auto createSource(const Problem& problem)
     return source;
 }
 
-template<class Problem, class SolutionVector, class FVGridGeometry>
-void printL2Error(const Problem& problem, const SolutionVector& x, const FVGridGeometry& fvGridGeometry)
+template<class Problem, class SolutionVector, class GridGeometry>
+void printL2Error(const Problem& problem, const SolutionVector& x, const GridGeometry& gridGeometry)
 {
     using namespace Dumux;
     using Scalar = double;
@@ -149,8 +149,8 @@ void printL2Error(const Problem& problem, const SolutionVector& x, const FVGridG
 
     using L2Error = NavierStokesTestL2Error<Scalar, ModelTraits, PrimaryVariables>;
     const auto l2error = L2Error::calculateL2Error(*problem, x);
-    const int numCellCenterDofs = fvGridGeometry->numCellCenterDofs();
-    const int numFaceDofs = fvGridGeometry->numFaceDofs();
+    const int numCellCenterDofs = gridGeometry->numCellCenterDofs();
+    const int numFaceDofs = gridGeometry->numFaceDofs();
     std::cout << std::setprecision(8) << "** L2 error (abs/rel) for "
                 << std::setw(6) << numCellCenterDofs << " cc dofs and " << numFaceDofs << " face dofs (total: " << numCellCenterDofs + numFaceDofs << "): "
                 << std::scientific
@@ -195,9 +195,9 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // get some time loop parameters
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
@@ -211,20 +211,20 @@ int main(int argc, char** argv) try
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
     problem->updateTimeStepSize(timeLoop->timeStepSize());
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     SolutionVector x;
-    x[FVGridGeometry::cellCenterIdx()].resize(fvGridGeometry->numCellCenterDofs());
-    x[FVGridGeometry::faceIdx()].resize(fvGridGeometry->numFaceDofs());
+    x[GridGeometry::cellCenterIdx()].resize(gridGeometry->numCellCenterDofs());
+    x[GridGeometry::faceIdx()].resize(gridGeometry->numFaceDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // initialize the vtk output module
@@ -248,8 +248,8 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = StaggeredFVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = isStationary ? std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables)
-                                  : std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = isStationary ? std::make_shared<Assembler>(problem, gridGeometry, gridVariables)
+                                  : std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::UMFPackBackend;
@@ -269,7 +269,7 @@ int main(int argc, char** argv) try
 
         if (shouldPrintL2Error)
         {
-            printL2Error(problem, x, fvGridGeometry);
+            printL2Error(problem, x, gridGeometry);
         }
 
         // write vtk output
@@ -297,7 +297,7 @@ int main(int argc, char** argv) try
 
             if (shouldPrintL2Error)
             {
-                printL2Error(problem, x, fvGridGeometry);
+                printL2Error(problem, x, gridGeometry);
             }
 
             // advance to the time loop to the next step
diff --git a/test/freeflow/navierstokes/sincos/problem.hh b/test/freeflow/navierstokes/sincos/problem.hh
index d4d1d407ebae39a787d730bf58ece450f75d5405..bef74ad581f5f82c6583ec93475298ac4e9bcb8d 100644
--- a/test/freeflow/navierstokes/sincos/problem.hh
+++ b/test/freeflow/navierstokes/sincos/problem.hh
@@ -86,17 +86,17 @@ class SincosTestProblem : public NavierStokesProblem<TypeTag>
     using ParentType = NavierStokesProblem<TypeTag>;
 
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     using TimeLoopPtr = std::shared_ptr<TimeLoop<Scalar>>;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using FVElementGeometry = typename GridGeometry::LocalView;
 
     static constexpr auto dimWorld = GetPropType<TypeTag, Properties::GridView>::dimensionworld;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
     using VelocityVector = Dune::FieldVector<Scalar, dimWorld>;
 
@@ -104,8 +104,8 @@ public:
     using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
 
-    SincosTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), time_(0.0), timeStepSize_(0.0)
+    SincosTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), time_(0.0), timeStepSize_(0.0)
     {
         isStationary_ = getParam<bool>("Problem.IsStationary");
         enableInertiaTerms_ = getParam<bool>("Problem.EnableInertiaTerms");
diff --git a/test/freeflow/navierstokesnc/channel/main.cc b/test/freeflow/navierstokesnc/channel/main.cc
index a50a3442d217e09be323252d74a87a8343f56f38..d4df7d267b43246436d8a414e4370f7a2dae23f5 100644
--- a/test/freeflow/navierstokesnc/channel/main.cc
+++ b/test/freeflow/navierstokesnc/channel/main.cc
@@ -75,13 +75,13 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // get some time loop parameters
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
@@ -97,14 +97,14 @@ int main(int argc, char** argv) try
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     SolutionVector x;
-    x[FVGridGeometry::cellCenterIdx()].resize(fvGridGeometry->numCellCenterDofs());
-    x[FVGridGeometry::faceIdx()].resize(fvGridGeometry->numFaceDofs());
+    x[GridGeometry::cellCenterIdx()].resize(gridGeometry->numCellCenterDofs());
+    x[GridGeometry::faceIdx()].resize(gridGeometry->numFaceDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -116,7 +116,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = StaggeredFVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::UMFPackBackend;
diff --git a/test/freeflow/navierstokesnc/channel/problem.hh b/test/freeflow/navierstokesnc/channel/problem.hh
index 6e66aab472368367d480847dbfb4fccbae6fc9d9..4cf2ab0824972e795061218df451b5b3b9c3ca3f 100644
--- a/test/freeflow/navierstokesnc/channel/problem.hh
+++ b/test/freeflow/navierstokesnc/channel/problem.hh
@@ -111,7 +111,7 @@ class ChannelNCTestProblem : public NavierStokesProblem<TypeTag>
 
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
@@ -127,8 +127,8 @@ class ChannelNCTestProblem : public NavierStokesProblem<TypeTag>
     static constexpr auto transportEqIdx = Indices::conti0EqIdx + compIdx;
 
 public:
-    ChannelNCTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), eps_(1e-6)
+    ChannelNCTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), eps_(1e-6)
     {
         inletVelocity_ = getParam<Scalar>("Problem.InletVelocity");
         FluidSystem::init();
diff --git a/test/freeflow/navierstokesnc/densitydrivenflow/main.cc b/test/freeflow/navierstokesnc/densitydrivenflow/main.cc
index be73aafd0303ecd1ccbf586db5c2dfcb754efb08..59f53534bde6d234365d50aaa69142cbb6b3ade8 100644
--- a/test/freeflow/navierstokesnc/densitydrivenflow/main.cc
+++ b/test/freeflow/navierstokesnc/densitydrivenflow/main.cc
@@ -75,13 +75,13 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // get some time loop parameters
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
@@ -96,14 +96,14 @@ int main(int argc, char** argv) try
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     SolutionVector x;
-    x[FVGridGeometry::cellCenterIdx()].resize(fvGridGeometry->numCellCenterDofs());
-    x[FVGridGeometry::faceIdx()].resize(fvGridGeometry->numFaceDofs());
+    x[GridGeometry::cellCenterIdx()].resize(gridGeometry->numCellCenterDofs());
+    x[GridGeometry::faceIdx()].resize(gridGeometry->numFaceDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -115,7 +115,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = StaggeredFVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::UMFPackBackend;
diff --git a/test/freeflow/navierstokesnc/densitydrivenflow/problem.hh b/test/freeflow/navierstokesnc/densitydrivenflow/problem.hh
index 3cf9146102641ce5731a8bd2ff92dc6395ebcc44..f40cd66ff700b771d7bfd03cfc985be921af327e 100644
--- a/test/freeflow/navierstokesnc/densitydrivenflow/problem.hh
+++ b/test/freeflow/navierstokesnc/densitydrivenflow/problem.hh
@@ -98,13 +98,13 @@ class DensityDrivenFlowProblem : public NavierStokesProblem<TypeTag>
 
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
     using TimeLoopPtr = std::shared_ptr<CheckPointTimeLoop<Scalar>>;
@@ -115,8 +115,8 @@ class DensityDrivenFlowProblem : public NavierStokesProblem<TypeTag>
     static constexpr auto transportEqIdx = Indices::conti0EqIdx + 1;
 
 public:
-    DensityDrivenFlowProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), eps_(1e-6)
+    DensityDrivenFlowProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), eps_(1e-6)
     {
         useWholeLength_ = getParam<bool>("Problem.UseWholeLength");
         FluidSystem::init();
diff --git a/test/freeflow/navierstokesnc/maxwellstefan/main.cc b/test/freeflow/navierstokesnc/maxwellstefan/main.cc
index 0c54f21448b39580a8af60e5bbb911058f64fb71..d38fbe455ed6ce7a9427e9a2d67ec41b76b64d58 100644
--- a/test/freeflow/navierstokesnc/maxwellstefan/main.cc
+++ b/test/freeflow/navierstokesnc/maxwellstefan/main.cc
@@ -75,13 +75,13 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // get some time loop parameters
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
@@ -96,14 +96,14 @@ int main(int argc, char** argv) try
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     SolutionVector x;
-    x[FVGridGeometry::cellCenterIdx()].resize(fvGridGeometry->numCellCenterDofs());
-    x[FVGridGeometry::faceIdx()].resize(fvGridGeometry->numFaceDofs());
+    x[GridGeometry::cellCenterIdx()].resize(gridGeometry->numCellCenterDofs());
+    x[GridGeometry::faceIdx()].resize(gridGeometry->numFaceDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -114,7 +114,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = StaggeredFVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::UMFPackBackend;
diff --git a/test/freeflow/navierstokesnc/maxwellstefan/problem.hh b/test/freeflow/navierstokesnc/maxwellstefan/problem.hh
index f708da444c7b456c7a9154811347f6d88e703d34..7611da93aac51075bb7ca8b1d394e0e473d47be5 100644
--- a/test/freeflow/navierstokesnc/maxwellstefan/problem.hh
+++ b/test/freeflow/navierstokesnc/maxwellstefan/problem.hh
@@ -209,13 +209,13 @@ class MaxwellStefanNCTestProblem : public NavierStokesProblem<TypeTag>
 
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
     using TimeLoopPtr = std::shared_ptr<CheckPointTimeLoop<Scalar>>;
@@ -226,8 +226,8 @@ class MaxwellStefanNCTestProblem : public NavierStokesProblem<TypeTag>
     };
 
 public:
-    MaxwellStefanNCTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    MaxwellStefanNCTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         plotOutput_ = getParam<bool>("Problem.PlotOutput", false);
     }
diff --git a/test/freeflow/rans/main.cc b/test/freeflow/rans/main.cc
index 2146a1810d557df30064e526e1e4c93ceeabaaed..3af7593cbb8b8acd5045875620016b5f1ab95b0a 100644
--- a/test/freeflow/rans/main.cc
+++ b/test/freeflow/rans/main.cc
@@ -99,13 +99,13 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // get some time loop parameters
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
@@ -121,8 +121,8 @@ int main(int argc, char** argv) try
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     SolutionVector x;
-    x[FVGridGeometry::cellCenterIdx()].resize(fvGridGeometry->numCellCenterDofs());
-    x[FVGridGeometry::faceIdx()].resize(fvGridGeometry->numFaceDofs());
+    x[GridGeometry::cellCenterIdx()].resize(gridGeometry->numCellCenterDofs());
+    x[GridGeometry::faceIdx()].resize(gridGeometry->numFaceDofs());
     problem->applyInitialSolution(x);
     problem->updateStaticWallProperties();
     problem->updateDynamicWallProperties(x);
@@ -130,7 +130,7 @@ int main(int argc, char** argv) try
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -141,7 +141,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = StaggeredFVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::UMFPackBackend;
diff --git a/test/freeflow/rans/problem.hh b/test/freeflow/rans/problem.hh
index 472090c824a0ee5103a09e27f00d493c233b5b38..653711cb32a9358dd45d93a784eac4000fa433cf 100644
--- a/test/freeflow/rans/problem.hh
+++ b/test/freeflow/rans/problem.hh
@@ -115,14 +115,14 @@ class PipeLauferProblem : public RANSProblem<TypeTag>
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using FluidState = GetPropType<TypeTag, Properties::FluidState>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 
     using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
@@ -130,11 +130,11 @@ class PipeLauferProblem : public RANSProblem<TypeTag>
 
     using TimeLoopPtr = std::shared_ptr<CheckPointTimeLoop<Scalar>>;
 
-    static constexpr auto dimWorld = FVGridGeometry::GridView::dimensionworld;
+    static constexpr auto dimWorld = GridGeometry::GridView::dimensionworld;
 
 public:
-    PipeLauferProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), eps_(1e-6)
+    PipeLauferProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), eps_(1e-6)
     {
         inletVelocity_ = getParam<Scalar>("Problem.InletVelocity");
         inletTemperature_ = getParam<Scalar>("Problem.InletTemperature", 283.15);
diff --git a/test/freeflow/ransnc/main.cc b/test/freeflow/ransnc/main.cc
index ca5605684fc02e1388da32d4c2aa62458b897464..af8ae9117dcb13731b7ff1377332e557ad4a0e98 100644
--- a/test/freeflow/ransnc/main.cc
+++ b/test/freeflow/ransnc/main.cc
@@ -96,13 +96,13 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // get some time loop parameters
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
@@ -118,8 +118,8 @@ int main(int argc, char** argv) try
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     SolutionVector x;
-    x[FVGridGeometry::cellCenterIdx()].resize(fvGridGeometry->numCellCenterDofs());
-    x[FVGridGeometry::faceIdx()].resize(fvGridGeometry->numFaceDofs());
+    x[GridGeometry::cellCenterIdx()].resize(gridGeometry->numCellCenterDofs());
+    x[GridGeometry::faceIdx()].resize(gridGeometry->numFaceDofs());
     problem->applyInitialSolution(x);
     problem->updateStaticWallProperties();
     problem->updateDynamicWallProperties(x);
@@ -127,7 +127,7 @@ int main(int argc, char** argv) try
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -138,7 +138,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = StaggeredFVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::UMFPackBackend;
diff --git a/test/freeflow/ransnc/problem.hh b/test/freeflow/ransnc/problem.hh
index 15e111ed591fd26f00131c9baae26f9dbf4e1175..ad36aa8a1fb2c3c4e604f211e90f3227b89852ed 100644
--- a/test/freeflow/ransnc/problem.hh
+++ b/test/freeflow/ransnc/problem.hh
@@ -122,14 +122,14 @@ class FlatPlateNCTestProblem : public RANSProblem<TypeTag>
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using FluidState = GetPropType<TypeTag, Properties::FluidState>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 
     using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
@@ -142,8 +142,8 @@ class FlatPlateNCTestProblem : public RANSProblem<TypeTag>
     static constexpr auto transportCompIdx = Indices::conti0EqIdx + 1;
 
 public:
-    FlatPlateNCTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), eps_(1e-6)
+    FlatPlateNCTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), eps_(1e-6)
     {
         inletVelocity_ = getParam<Scalar>("Problem.InletVelocity", 0.1);
         inletTemperature_ = getParam<Scalar>("Problem.InletTemperature", 283.15);
diff --git a/test/freeflow/shallowwater/dambreak/main.cc b/test/freeflow/shallowwater/dambreak/main.cc
index 28a9a56ffeac7fb5cea05e881e5b75e3b4b76008..cacc8c9b336512679663dcef37ca9cac52f8b450 100644
--- a/test/freeflow/shallowwater/dambreak/main.cc
+++ b/test/freeflow/shallowwater/dambreak/main.cc
@@ -78,23 +78,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -119,11 +119,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/freeflow/shallowwater/dambreak/problem.hh b/test/freeflow/shallowwater/dambreak/problem.hh
index bd69eebd1c1b3e13fee74ddef208245f4897c81d..4b23aa6db7cbfb6ef3e2c9d590168625be2f6e67 100644
--- a/test/freeflow/shallowwater/dambreak/problem.hh
+++ b/test/freeflow/shallowwater/dambreak/problem.hh
@@ -66,10 +66,10 @@ template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::DamBreakWet>
 {
 private:
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 public:
-    using type = DamBreakSpatialParams<FVGridGeometry, Scalar>;
+    using type = DamBreakSpatialParams<GridGeometry, Scalar>;
 };
 
 template<class TypeTag>
@@ -113,7 +113,7 @@ class DamBreakProblem : public ShallowWaterProblem<TypeTag>
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using NeumannFluxes = GetPropType<TypeTag, Properties::NumEqVector>;
 
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
@@ -126,12 +126,12 @@ class DamBreakProblem : public ShallowWaterProblem<TypeTag>
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    DamBreakProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    DamBreakProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         name_ = getParam<std::string>("Problem.Name");
-        exactWaterDepth_.resize(fvGridGeometry->numDofs(), 0.0);
-        exactVelocityX_.resize(fvGridGeometry->numDofs(), 0.0);
+        exactWaterDepth_.resize(gridGeometry->numDofs(), 0.0);
+        exactVelocityX_.resize(gridGeometry->numDofs(), 0.0);
     }
 
     //! Get the analytical water depth
diff --git a/test/freeflow/shallowwater/dambreak/spatialparams.hh b/test/freeflow/shallowwater/dambreak/spatialparams.hh
index c5c32c5440beaa9122c81abb34b2b8e27af62793..8b2a832b309a36d01c04652eb7b8c58a5b4b6ec0 100644
--- a/test/freeflow/shallowwater/dambreak/spatialparams.hh
+++ b/test/freeflow/shallowwater/dambreak/spatialparams.hh
@@ -33,22 +33,22 @@ namespace Dumux {
  * \brief The spatial parameters class for the dam break test.
  *
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class DamBreakSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         DamBreakSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         DamBreakSpatialParams<GridGeometry, Scalar>>
 {
-    using ThisType = DamBreakSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, ThisType>;
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using ThisType = DamBreakSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, ThisType>;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    DamBreakSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    DamBreakSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {}
 
     /*! \brief Define the porosity in [-].
diff --git a/test/freeflow/shallowwater/roughchannel/main.cc b/test/freeflow/shallowwater/roughchannel/main.cc
index 1cd061ce57e4f1a506534a79107e587c15287abe..7931a8393c7b577c140ebab10c3974ea551e229f 100644
--- a/test/freeflow/shallowwater/roughchannel/main.cc
+++ b/test/freeflow/shallowwater/roughchannel/main.cc
@@ -76,23 +76,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -117,11 +117,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/freeflow/shallowwater/roughchannel/problem.hh b/test/freeflow/shallowwater/roughchannel/problem.hh
index c8d973ae4de814e5de1e2b4b8fdfa10d93622e9b..33cce2afbedefc042421e208ddd2cf0185461b49 100644
--- a/test/freeflow/shallowwater/roughchannel/problem.hh
+++ b/test/freeflow/shallowwater/roughchannel/problem.hh
@@ -60,12 +60,12 @@ template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::RoughChannel>
 {
 private:
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
     using VolumeVariables = typename ElementVolumeVariables::VolumeVariables;
 public:
-    using type = RoughChannelSpatialParams<FVGridGeometry, Scalar, VolumeVariables>;
+    using type = RoughChannelSpatialParams<GridGeometry, Scalar, VolumeVariables>;
 };
 
 template<class TypeTag>
@@ -116,7 +116,7 @@ class RoughChannelProblem : public ShallowWaterProblem<TypeTag>
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using NeumannFluxes = GetPropType<TypeTag, Properties::NumEqVector>;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
@@ -131,12 +131,12 @@ class RoughChannelProblem : public ShallowWaterProblem<TypeTag>
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
 
 public:
-    RoughChannelProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    RoughChannelProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         name_ = getParam<std::string>("Problem.Name");
-        exactWaterDepth_.resize(fvGridGeometry->numDofs(), 0.0);
-        exactVelocityX_.resize(fvGridGeometry->numDofs(), 0.0);
+        exactWaterDepth_.resize(gridGeometry->numDofs(), 0.0);
+        exactVelocityX_.resize(gridGeometry->numDofs(), 0.0);
         constManningN_ = getParam<Scalar>("Problem.ManningN");
         bedSlope_ = getParam<Scalar>("Problem.BedSlope");
         discharge_ = getParam<Scalar>("Problem.Discharge");
diff --git a/test/freeflow/shallowwater/roughchannel/spatialparams.hh b/test/freeflow/shallowwater/roughchannel/spatialparams.hh
index 87bea05d508e62ced47cb91866983ad7ec73fd8a..73864db30eb6e97521aa1ad5d5752db9528429e6 100644
--- a/test/freeflow/shallowwater/roughchannel/spatialparams.hh
+++ b/test/freeflow/shallowwater/roughchannel/spatialparams.hh
@@ -37,22 +37,22 @@ namespace Dumux {
  * \brief The spatial parameters class for the rough channel test.
  *
  */
-template<class FVGridGeometry, class Scalar, class VolumeVariables>
+template<class GridGeometry, class Scalar, class VolumeVariables>
 class RoughChannelSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         RoughChannelSpatialParams<FVGridGeometry, Scalar, VolumeVariables>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         RoughChannelSpatialParams<GridGeometry, Scalar, VolumeVariables>>
 {
-    using ThisType = RoughChannelSpatialParams<FVGridGeometry, Scalar, VolumeVariables>;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, ThisType>;
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using ThisType = RoughChannelSpatialParams<GridGeometry, Scalar, VolumeVariables>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, ThisType>;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    RoughChannelSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    RoughChannelSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         gravity_ = getParam<Scalar>("Problem.Gravity");
         bedSlope_ = getParam<Scalar>("Problem.BedSlope");
diff --git a/test/geomechanics/elastic/main.cc b/test/geomechanics/elastic/main.cc
index 20d19c55dd37e45823832b023d2cde1cb279b159..f30d53280f337ff53cbdaaef4d094ebd7080c3a4 100644
--- a/test/geomechanics/elastic/main.cc
+++ b/test/geomechanics/elastic/main.cc
@@ -82,22 +82,22 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module and add displacement
@@ -105,9 +105,9 @@ int main(int argc, char** argv) try
     vtkWriter.addField(x, "u");
 
     // also, add exact solution to the output
-    SolutionVector xExact(fvGridGeometry->numDofs());
+    SolutionVector xExact(gridGeometry->numDofs());
     for (const auto& v : vertices(leafGridView))
-        xExact[ fvGridGeometry->vertexMapper().index(v) ] = problem->exactSolution(v.geometry().center());
+        xExact[ gridGeometry->vertexMapper().index(v) ] = problem->exactSolution(v.geometry().center());
     vtkWriter.addField(xExact, "u_exact");
 
     // write initial solution
@@ -115,11 +115,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/geomechanics/elastic/problem.hh b/test/geomechanics/elastic/problem.hh
index cb73e24845d707c269c20738d829effafe7da90a..3a33fc0fc7a3651b7f11f45c5d52843463809631 100644
--- a/test/geomechanics/elastic/problem.hh
+++ b/test/geomechanics/elastic/problem.hh
@@ -77,10 +77,10 @@ class ElasticProblem : public GeomechanicsFVProblem<TypeTag>
     using ElementVolumeVariables = typename GridVariables::GridVolumeVariables::LocalView;
     using ElementFluxVariablesCache = typename GridVariables::GridFluxVariablesCache::LocalView;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
 
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
@@ -92,8 +92,8 @@ class ElasticProblem : public GeomechanicsFVProblem<TypeTag>
     using GradU = Dune::FieldMatrix<Scalar, dim, dimWorld>;
 
 public:
-    ElasticProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry) {}
+    ElasticProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry) {}
 
     //! Returns the temperature in the domain.
     static constexpr Scalar temperature()
diff --git a/test/geomechanics/elastic/spatialparams.hh b/test/geomechanics/elastic/spatialparams.hh
index edc588bf7fbe24cda26234cde318ad84da8a1b7a..c0f4b8104cac08134dceae434e715e2695047dd5 100644
--- a/test/geomechanics/elastic/spatialparams.hh
+++ b/test/geomechanics/elastic/spatialparams.hh
@@ -34,16 +34,16 @@ namespace Dumux {
  * \ingroup GeomechanicsTests
  * \brief Definition of the spatial parameters for the linear elasticity problem.
  */
-template<class Scalar, class FVGridGeometry>
+template<class Scalar, class GridGeometry>
 class ElasticSpatialParams : public FVSpatialParamsElastic< Scalar,
-                                                            FVGridGeometry,
-                                                            ElasticSpatialParams<Scalar, FVGridGeometry> >
+                                                            GridGeometry,
+                                                            ElasticSpatialParams<Scalar, GridGeometry> >
 {
-    using ThisType = ElasticSpatialParams<Scalar, FVGridGeometry>;
-    using ParentType = FVSpatialParamsElastic<Scalar, FVGridGeometry, ThisType>;
+    using ThisType = ElasticSpatialParams<Scalar, GridGeometry>;
+    using ParentType = FVSpatialParamsElastic<Scalar, GridGeometry, ThisType>;
 
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -51,8 +51,8 @@ public:
     //! Export the type of the lame parameters
     using LameParams = Dumux::LameParams<Scalar>;
 
-    ElasticSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    ElasticSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         lameParams_.setLambda(3e9);
         lameParams_.setMu(3e9);
diff --git a/test/geomechanics/poroelastic/main.cc b/test/geomechanics/poroelastic/main.cc
index f6f61d3990f05a3b7ee42d9aca03e6a6d0b07608..f1210550eb1f66cd515bb5d6a267af75a7655473 100644
--- a/test/geomechanics/poroelastic/main.cc
+++ b/test/geomechanics/poroelastic/main.cc
@@ -60,13 +60,13 @@ template< class StressType,
 void assembleElementStresses(SigmaStorage& sigmaStorage,
                              SigmaStorage& effSigmaStorage,
                              const Problem& problem,
-                             const typename GridVariables::GridGeometry& fvGridGeometry,
+                             const typename GridVariables::GridGeometry& gridGeometry,
                              const GridVariables& gridVariables,
                              const SolutionVector& x)
 {
-    for (const auto& element : elements(fvGridGeometry.gridView()))
+    for (const auto& element : elements(gridGeometry.gridView()))
     {
-        auto fvGeometry = localView(fvGridGeometry);
+        auto fvGeometry = localView(gridGeometry);
         auto elemVolVars = localView(gridVariables.curGridVolVars());
 
         fvGeometry.bind(element);
@@ -82,10 +82,10 @@ void assembleElementStresses(SigmaStorage& sigmaStorage,
         const auto effSigma = StressType::effectiveStressTensor(problem, element, fvGeometry, elemVolVars, fluxVarsCache);
 
         // pass values into storage container
-        using FVGridGeometry = typename GridVariables::GridGeometry;
-        for (int dir = 0; dir < FVGridGeometry::GridView::dimension; ++dir)
+        using GridGeometry = typename GridVariables::GridGeometry;
+        for (int dir = 0; dir < GridGeometry::GridView::dimension; ++dir)
         {
-            const auto eIdx = fvGridGeometry.elementMapper().index(element);
+            const auto eIdx = gridGeometry.elementMapper().index(element);
             sigmaStorage[dir][eIdx] = sigma[dir];
             effSigmaStorage[dir][eIdx] = effSigma[dir];
         }
@@ -125,22 +125,22 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module and output fields
@@ -150,14 +150,14 @@ int main(int argc, char** argv) try
     IOFields::initOutputModule(vtkWriter);
 
     // also, add exact solution to the output
-    SolutionVector xExact(fvGridGeometry->numDofs());
+    SolutionVector xExact(gridGeometry->numDofs());
     for (const auto& v : vertices(leafGridView))
-        xExact[ fvGridGeometry->vertexMapper().index(v) ] = problem->exactSolution(v.geometry().center());
+        xExact[ gridGeometry->vertexMapper().index(v) ] = problem->exactSolution(v.geometry().center());
     vtkWriter.addField(xExact, "u_exact");
 
     // Furthermore, write out element stress tensors
-    static constexpr int dim = FVGridGeometry::GridView::dimension;
-    static constexpr int dimWorld = FVGridGeometry::GridView::dimensionworld;
+    static constexpr int dim = GridGeometry::GridView::dimension;
+    static constexpr int dimWorld = GridGeometry::GridView::dimensionworld;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using ForceVector = Dune::FieldVector< Scalar, dimWorld >;
 
@@ -165,7 +165,7 @@ int main(int argc, char** argv) try
     std::array< std::vector<ForceVector>, dim > sigmaStorage;
     std::array< std::vector<ForceVector>, dim > effSigmaStorage;
 
-    const auto numCells = fvGridGeometry->gridView().size(0);
+    const auto numCells = gridGeometry->gridView().size(0);
     std::for_each(sigmaStorage.begin(), sigmaStorage.end(), [numCells] (auto& sigma) { sigma.resize(numCells); });
     std::for_each(effSigmaStorage.begin(), effSigmaStorage.end(), [numCells] (auto& effSigma) { effSigma.resize(numCells); });
 
@@ -177,18 +177,18 @@ int main(int argc, char** argv) try
 
     // use convenience function to compute stresses
     using StressType = GetPropType<TypeTag, Properties::StressType>;
-    assembleElementStresses<StressType>(sigmaStorage, effSigmaStorage, *problem, *fvGridGeometry, *gridVariables, x);
+    assembleElementStresses<StressType>(sigmaStorage, effSigmaStorage, *problem, *gridGeometry, *gridVariables, x);
 
     // write initial solution
     vtkWriter.write(0.0);
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
@@ -201,7 +201,7 @@ int main(int argc, char** argv) try
     gridVariables->update(x);
 
     // write vtk output
-    assembleElementStresses<StressType>(sigmaStorage, effSigmaStorage, *problem, *fvGridGeometry, *gridVariables, x);
+    assembleElementStresses<StressType>(sigmaStorage, effSigmaStorage, *problem, *gridGeometry, *gridVariables, x);
     vtkWriter.write(1.0);
 
     // print time and say goodbye
diff --git a/test/geomechanics/poroelastic/problem.hh b/test/geomechanics/poroelastic/problem.hh
index fffb217f911f8100c6764b21c36a73908184e7c5..350491a600ec33c48b10a4ccf078e9351516633f 100644
--- a/test/geomechanics/poroelastic/problem.hh
+++ b/test/geomechanics/poroelastic/problem.hh
@@ -85,10 +85,10 @@ class PoroElasticProblem : public GeomechanicsFVProblem<TypeTag>
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
 
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
@@ -100,8 +100,8 @@ class PoroElasticProblem : public GeomechanicsFVProblem<TypeTag>
     using GradU = Dune::FieldMatrix<Scalar, dim, dimWorld>;
 
 public:
-    PoroElasticProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    PoroElasticProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {}
 
     //! Returns the temperature in the domain.
diff --git a/test/geomechanics/poroelastic/spatialparams.hh b/test/geomechanics/poroelastic/spatialparams.hh
index 4cb6a97b3048d0a66a0c0d997947062a5688de91..dbfb9541b517ae5fa76955c55f8507210f55436b 100644
--- a/test/geomechanics/poroelastic/spatialparams.hh
+++ b/test/geomechanics/poroelastic/spatialparams.hh
@@ -35,16 +35,16 @@ namespace Dumux {
  * \ingroup GeomechanicsTests
  * \brief Definition of the spatial parameters for the poro-elastic problem.
  */
-template<class Scalar, class FVGridGeometry>
+template<class Scalar, class GridGeometry>
 class PoroElasticSpatialParams : public FVSpatialParamsPoroElastic< Scalar,
-                                                                    FVGridGeometry,
-                                                                    PoroElasticSpatialParams<Scalar, FVGridGeometry> >
+                                                                    GridGeometry,
+                                                                    PoroElasticSpatialParams<Scalar, GridGeometry> >
 {
-    using ThisType = PoroElasticSpatialParams<Scalar, FVGridGeometry>;
-    using ParentType = FVSpatialParamsPoroElastic<Scalar, FVGridGeometry, ThisType>;
+    using ThisType = PoroElasticSpatialParams<Scalar, GridGeometry>;
+    using ParentType = FVSpatialParamsPoroElastic<Scalar, GridGeometry, ThisType>;
 
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -52,8 +52,8 @@ public:
     //! Export the type of the lame parameters
     using LameParams = Dumux::LameParams<Scalar>;
 
-    PoroElasticSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    PoroElasticSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         lameParams_.setLambda(2);
         lameParams_.setMu(2);
diff --git a/test/io/gridmanager/gmshboundaryflagtest.hh b/test/io/gridmanager/gmshboundaryflagtest.hh
index 6d73c3d35cbe8ce83b560c65c01fe64161a6ba96..4d242a469b410877ecdb5f6fd51d02a9b0327dc1 100644
--- a/test/io/gridmanager/gmshboundaryflagtest.hh
+++ b/test/io/gridmanager/gmshboundaryflagtest.hh
@@ -44,15 +44,15 @@ class GmshBoundaryFlagTest
 
 public:
 
-    template<class FVGridGeometry>
+    template<class GridGeometry>
     static void testGmshBoundaryFlag(const GridView& leafGridView,
-                                     std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+                                     std::shared_ptr<const GridGeometry> gridGeometry,
                                      std::shared_ptr<const GridData<Grid>> gridData)
     {
 
         for(const auto& element : elements(leafGridView))
         {
-            auto fvGeometry = localView(*fvGridGeometry);
+            auto fvGeometry = localView(*gridGeometry);
             fvGeometry.bind(element);
 
             for (auto&& scvf : scvfs(fvGeometry))
diff --git a/test/io/vtk/test_vtk_staggeredfreeflowpvnames.cc b/test/io/vtk/test_vtk_staggeredfreeflowpvnames.cc
index f02538e0a4bb06823c2009f52b3932dbb3c6910b..58ab07b2be37ac5704c79ab2ed1381a939b30a71 100644
--- a/test/io/vtk/test_vtk_staggeredfreeflowpvnames.cc
+++ b/test/io/vtk/test_vtk_staggeredfreeflowpvnames.cc
@@ -188,8 +188,8 @@ void assignValues(SolutionVector& sol, Values values)
     }
 }
 
-template<class TypeTag, class FVGridGeometry, std::size_t numValues>
-void testWriteAndReadVtk(std::shared_ptr<FVGridGeometry> fvGridGeometry,
+template<class TypeTag, class GridGeometry, std::size_t numValues>
+void testWriteAndReadVtk(std::shared_ptr<GridGeometry> gridGeometry,
                          const std::array<Dumux::GetPropType<TypeTag, Dumux::Properties::Scalar>, numValues>& values,
                          const std::string& fileName,
                          bool verbose = false,
@@ -201,24 +201,24 @@ void testWriteAndReadVtk(std::shared_ptr<FVGridGeometry> fvGridGeometry,
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     SolutionVector writeFrom;
 
-    writeFrom[FVGridGeometry::cellCenterIdx()].resize(fvGridGeometry->numCellCenterDofs());
-    writeFrom[FVGridGeometry::faceIdx()].resize(fvGridGeometry->numFaceDofs());
+    writeFrom[GridGeometry::cellCenterIdx()].resize(gridGeometry->numCellCenterDofs());
+    writeFrom[GridGeometry::faceIdx()].resize(gridGeometry->numFaceDofs());
 
     SolutionVector readTo = writeFrom;
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
-    assignValues(writeFrom[FVGridGeometry::cellCenterIdx()], values);
-    assignValues(writeFrom[FVGridGeometry::faceIdx()], std::array<GetPropType<TypeTag, Properties::Scalar>, 1>{1.0});
+    assignValues(writeFrom[GridGeometry::cellCenterIdx()], values);
+    assignValues(writeFrom[GridGeometry::faceIdx()], std::array<GetPropType<TypeTag, Properties::Scalar>, 1>{1.0});
 
     problem->updateStaticWallProperties();
     problem->updateDynamicWallProperties(writeFrom);
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(writeFrom);
 
     // initialize the vtk output module
@@ -235,47 +235,47 @@ void testWriteAndReadVtk(std::shared_ptr<FVGridGeometry> fvGridGeometry,
     using FacePrimaryVariables = GetPropType<TypeTag, Properties::FacePrimaryVariables>;
 
     // cc dofs
-    loadSolution(readTo[FVGridGeometry::cellCenterIdx()], fileName + "-00000.vtu",
+    loadSolution(readTo[GridGeometry::cellCenterIdx()], fileName + "-00000.vtu",
                  createCellCenterPVNameFunction<IOFields, CellCenterPrimaryVariables, ModelTraits, FluidSystem>(),
-                 *fvGridGeometry);
+                 *gridGeometry);
 
     if (verbose)
     {
         std::cout << "reference cc " << std::endl;
-        for (const auto& block : writeFrom[FVGridGeometry::cellCenterIdx()])
+        for (const auto& block : writeFrom[GridGeometry::cellCenterIdx()])
         std::cout << block << std::endl;
 
         std::cout << "result cc " << std::endl;
-        for (const auto& block : readTo[FVGridGeometry::cellCenterIdx()])
+        for (const auto& block : readTo[GridGeometry::cellCenterIdx()])
         std::cout << block << std::endl;
     }
 
-    for (int i = 0; i < readTo[FVGridGeometry::cellCenterIdx()].size(); ++i)
+    for (int i = 0; i < readTo[GridGeometry::cellCenterIdx()].size(); ++i)
     {
-        if (Dune::FloatCmp::ne(readTo[FVGridGeometry::cellCenterIdx()][i], writeFrom[FVGridGeometry::cellCenterIdx()][i]))
-            DUNE_THROW(Dune::IOError, "Values don't match: new " << readTo[FVGridGeometry::cellCenterIdx()][i] << ", old " << writeFrom[FVGridGeometry::cellCenterIdx()][i]);
+        if (Dune::FloatCmp::ne(readTo[GridGeometry::cellCenterIdx()][i], writeFrom[GridGeometry::cellCenterIdx()][i]))
+            DUNE_THROW(Dune::IOError, "Values don't match: new " << readTo[GridGeometry::cellCenterIdx()][i] << ", old " << writeFrom[GridGeometry::cellCenterIdx()][i]);
     }
 
     // face dofs
-    loadSolution(readTo[FVGridGeometry::faceIdx()], fileName + "-face-00000.vtp",
+    loadSolution(readTo[GridGeometry::faceIdx()], fileName + "-face-00000.vtp",
                  createFacePVNameFunction<IOFields, FacePrimaryVariables, ModelTraits, FluidSystem>(),
-                 *fvGridGeometry);
+                 *gridGeometry);
 
      if (verbose)
      {
          std::cout << "reference face " << std::endl;
-         for (const auto& block : writeFrom[FVGridGeometry::faceIdx()])
+         for (const auto& block : writeFrom[GridGeometry::faceIdx()])
          std::cout << block << std::endl;
 
          std::cout << "result face " << std::endl;
-         for (const auto& block : readTo[FVGridGeometry::faceIdx()])
+         for (const auto& block : readTo[GridGeometry::faceIdx()])
          std::cout << block << std::endl;
      }
 
-     for (int i = 0; i < readTo[FVGridGeometry::faceIdx()].size(); ++i)
+     for (int i = 0; i < readTo[GridGeometry::faceIdx()].size(); ++i)
      {
-         if (Dune::FloatCmp::ne(readTo[FVGridGeometry::faceIdx()][i], writeFrom[FVGridGeometry::faceIdx()][i]))
-             DUNE_THROW(Dune::IOError, "Values don't match: new " << readTo[FVGridGeometry::faceIdx()][i] << ", old " << writeFrom[FVGridGeometry::faceIdx()][i]);
+         if (Dune::FloatCmp::ne(readTo[GridGeometry::faceIdx()][i], writeFrom[GridGeometry::faceIdx()][i]))
+             DUNE_THROW(Dune::IOError, "Values don't match: new " << readTo[GridGeometry::faceIdx()][i] << ", old " << writeFrom[GridGeometry::faceIdx()][i]);
      }
 
      // clean up the folder
@@ -313,7 +313,7 @@ int main(int argc, char** argv) try
 
     using CommonTypeTag = Properties::TTag::StaggeredPVNamesTestTypeTag;
     using Grid = GetPropType<CommonTypeTag, Properties::Grid>;
-    using FVGridGeometry = GetPropType<CommonTypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<CommonTypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<CommonTypeTag, Properties::Scalar>;
     using GlobalPosition = Dune::FieldVector<Scalar, Grid::dimension>;
 
@@ -324,41 +324,41 @@ int main(int argc, char** argv) try
 
     const auto grid = Dune::StructuredGridFactory<Grid>::createCubeGrid(lowerLeft, upperRight, cells);
     const auto gridView = grid->leafGridView();
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(gridView);
-    fvGridGeometry->update();
+    auto gridGeometry = std::make_shared<GridGeometry>(gridView);
+    gridGeometry->update();
 
     using FluidSystem = GetPropType<CommonTypeTag, Properties::FluidSystem>;
     FluidSystem::init();
 
-    testWriteAndReadVtk<Properties::TTag::NavierStokesPVNameTypeTag>(fvGridGeometry, std::array<Scalar, 1>{1e5}, "navierstokes");
-    testWriteAndReadVtk<Properties::TTag::NavierStokesNIPVNameTypeTag>(fvGridGeometry, std::array<Scalar, 2>{1e5, 300.0}, "navierstokesni");
-    testWriteAndReadVtk<Properties::TTag::NavierStokesNCPVNameTypeTag>(fvGridGeometry, std::array<Scalar, 2>{1e5, 1e-3}, "navierstokesnc");
-    testWriteAndReadVtk<Properties::TTag::NavierStokesNCNIPVNameTypeTag>(fvGridGeometry, std::array<Scalar, 3>{1e5, 1e-3, 300.0}, "navierstokesncni");
-
-    testWriteAndReadVtk<Properties::TTag::ZeroEqNameTestTypeTag>(fvGridGeometry, std::array<Scalar, 1>{1e5}, "zeroeq");
-    testWriteAndReadVtk<Properties::TTag::ZeroEqNINameTestTypeTag>(fvGridGeometry, std::array<Scalar, 2>{1e5, 300.0}, "zeroeqni");
-    testWriteAndReadVtk<Properties::TTag::ZeroEqNCNameTestTypeTag>(fvGridGeometry, std::array<Scalar, 2>{1e5, 1e-3}, "zeroeqnc");
-    testWriteAndReadVtk<Properties::TTag::ZeroEqNCNINameTestTypeTag>(fvGridGeometry, std::array<Scalar, 3>{1e5, 1e-3, 300.0}, "zeroeqncni");
-
-    testWriteAndReadVtk<Properties::TTag::OneEqNameTestTypeTag>(fvGridGeometry, std::array<Scalar, 2>{1e5, 1.0}, "oneeq");
-    testWriteAndReadVtk<Properties::TTag::OneEqNINameTestTypeTag>(fvGridGeometry, std::array<Scalar, 3>{1e5, 1.0, 300.0}, "oneeqni");
-    testWriteAndReadVtk<Properties::TTag::OneEqNCNameTestTypeTag>(fvGridGeometry, std::array<Scalar, 3>{1e5, 1e-3, 1.0}, "oneeqnc");
-    testWriteAndReadVtk<Properties::TTag::OneEqNCNINameTestTypeTag>(fvGridGeometry, std::array<Scalar, 4>{1e5, 1e-3, 1.0, 300.0}, "oneeqncni");
-
-    testWriteAndReadVtk<Properties::TTag::KEpsilonNameTestTypeTag>(fvGridGeometry, std::array<Scalar, 3>{1e5, 1.1, 1.2}, "kepsilon");
-    testWriteAndReadVtk<Properties::TTag::KEpsilonNINameTestTypeTag>(fvGridGeometry, std::array<Scalar, 4>{1e5, 1.1, 1.2, 300.0}, "kepsilonni");
-    testWriteAndReadVtk<Properties::TTag::KEpsilonNCNameTestTypeTag>(fvGridGeometry, std::array<Scalar, 4>{1e5, 1e-3, 1.1, 1.2}, "kepsilonnc");
-    testWriteAndReadVtk<Properties::TTag::KEpsilonNCNINameTestTypeTag>(fvGridGeometry, std::array<Scalar, 5>{1e5, 1e-3, 1.1, 1.2, 300.0}, "kepsilonncni");
-
-    testWriteAndReadVtk<Properties::TTag::LowReKEpsilonNameTestTypeTag>(fvGridGeometry, std::array<Scalar, 3>{1e5, 1.1, 1.2}, "lowrekepsilon");
-    testWriteAndReadVtk<Properties::TTag::LowReKEpsilonNINameTestTypeTag>(fvGridGeometry, std::array<Scalar, 4>{1e5, 1.1, 1.2, 300.0}, "lowrekepsilonni");
-    testWriteAndReadVtk<Properties::TTag::LowReKEpsilonNCNameTestTypeTag>(fvGridGeometry, std::array<Scalar, 4>{1e5, 1e-3, 1.1, 1.2}, "lowrekepsilonnc");
-    testWriteAndReadVtk<Properties::TTag::LowReKEpsilonNCNINameTestTypeTag>(fvGridGeometry, std::array<Scalar, 5>{1e5, 1e-3, 1.1, 1.2, 300.0}, "lowrekepsilonncni");
-
-    testWriteAndReadVtk<Properties::TTag::KOmegaNameTestTypeTag>(fvGridGeometry, std::array<Scalar, 3>{1e5, 1.1, 1.2}, "komega");
-    testWriteAndReadVtk<Properties::TTag::KOmegaNINameTestTypeTag>(fvGridGeometry, std::array<Scalar, 4>{1e5, 1.1, 1.2, 300.0}, "komegani");
-    testWriteAndReadVtk<Properties::TTag::KOmegaNCNameTestTypeTag>(fvGridGeometry, std::array<Scalar, 4>{1e5, 1e-3, 1.1, 1.2}, "komeganc");
-    testWriteAndReadVtk<Properties::TTag::KOmegaNCNINameTestTypeTag>(fvGridGeometry, std::array<Scalar, 5>{1e5, 1e-3, 1.1, 1.2, 300.0}, "komegancni");
+    testWriteAndReadVtk<Properties::TTag::NavierStokesPVNameTypeTag>(gridGeometry, std::array<Scalar, 1>{1e5}, "navierstokes");
+    testWriteAndReadVtk<Properties::TTag::NavierStokesNIPVNameTypeTag>(gridGeometry, std::array<Scalar, 2>{1e5, 300.0}, "navierstokesni");
+    testWriteAndReadVtk<Properties::TTag::NavierStokesNCPVNameTypeTag>(gridGeometry, std::array<Scalar, 2>{1e5, 1e-3}, "navierstokesnc");
+    testWriteAndReadVtk<Properties::TTag::NavierStokesNCNIPVNameTypeTag>(gridGeometry, std::array<Scalar, 3>{1e5, 1e-3, 300.0}, "navierstokesncni");
+
+    testWriteAndReadVtk<Properties::TTag::ZeroEqNameTestTypeTag>(gridGeometry, std::array<Scalar, 1>{1e5}, "zeroeq");
+    testWriteAndReadVtk<Properties::TTag::ZeroEqNINameTestTypeTag>(gridGeometry, std::array<Scalar, 2>{1e5, 300.0}, "zeroeqni");
+    testWriteAndReadVtk<Properties::TTag::ZeroEqNCNameTestTypeTag>(gridGeometry, std::array<Scalar, 2>{1e5, 1e-3}, "zeroeqnc");
+    testWriteAndReadVtk<Properties::TTag::ZeroEqNCNINameTestTypeTag>(gridGeometry, std::array<Scalar, 3>{1e5, 1e-3, 300.0}, "zeroeqncni");
+
+    testWriteAndReadVtk<Properties::TTag::OneEqNameTestTypeTag>(gridGeometry, std::array<Scalar, 2>{1e5, 1.0}, "oneeq");
+    testWriteAndReadVtk<Properties::TTag::OneEqNINameTestTypeTag>(gridGeometry, std::array<Scalar, 3>{1e5, 1.0, 300.0}, "oneeqni");
+    testWriteAndReadVtk<Properties::TTag::OneEqNCNameTestTypeTag>(gridGeometry, std::array<Scalar, 3>{1e5, 1e-3, 1.0}, "oneeqnc");
+    testWriteAndReadVtk<Properties::TTag::OneEqNCNINameTestTypeTag>(gridGeometry, std::array<Scalar, 4>{1e5, 1e-3, 1.0, 300.0}, "oneeqncni");
+
+    testWriteAndReadVtk<Properties::TTag::KEpsilonNameTestTypeTag>(gridGeometry, std::array<Scalar, 3>{1e5, 1.1, 1.2}, "kepsilon");
+    testWriteAndReadVtk<Properties::TTag::KEpsilonNINameTestTypeTag>(gridGeometry, std::array<Scalar, 4>{1e5, 1.1, 1.2, 300.0}, "kepsilonni");
+    testWriteAndReadVtk<Properties::TTag::KEpsilonNCNameTestTypeTag>(gridGeometry, std::array<Scalar, 4>{1e5, 1e-3, 1.1, 1.2}, "kepsilonnc");
+    testWriteAndReadVtk<Properties::TTag::KEpsilonNCNINameTestTypeTag>(gridGeometry, std::array<Scalar, 5>{1e5, 1e-3, 1.1, 1.2, 300.0}, "kepsilonncni");
+
+    testWriteAndReadVtk<Properties::TTag::LowReKEpsilonNameTestTypeTag>(gridGeometry, std::array<Scalar, 3>{1e5, 1.1, 1.2}, "lowrekepsilon");
+    testWriteAndReadVtk<Properties::TTag::LowReKEpsilonNINameTestTypeTag>(gridGeometry, std::array<Scalar, 4>{1e5, 1.1, 1.2, 300.0}, "lowrekepsilonni");
+    testWriteAndReadVtk<Properties::TTag::LowReKEpsilonNCNameTestTypeTag>(gridGeometry, std::array<Scalar, 4>{1e5, 1e-3, 1.1, 1.2}, "lowrekepsilonnc");
+    testWriteAndReadVtk<Properties::TTag::LowReKEpsilonNCNINameTestTypeTag>(gridGeometry, std::array<Scalar, 5>{1e5, 1e-3, 1.1, 1.2, 300.0}, "lowrekepsilonncni");
+
+    testWriteAndReadVtk<Properties::TTag::KOmegaNameTestTypeTag>(gridGeometry, std::array<Scalar, 3>{1e5, 1.1, 1.2}, "komega");
+    testWriteAndReadVtk<Properties::TTag::KOmegaNINameTestTypeTag>(gridGeometry, std::array<Scalar, 4>{1e5, 1.1, 1.2, 300.0}, "komegani");
+    testWriteAndReadVtk<Properties::TTag::KOmegaNCNameTestTypeTag>(gridGeometry, std::array<Scalar, 4>{1e5, 1e-3, 1.1, 1.2}, "komeganc");
+    testWriteAndReadVtk<Properties::TTag::KOmegaNCNINameTestTypeTag>(gridGeometry, std::array<Scalar, 5>{1e5, 1e-3, 1.1, 1.2, 300.0}, "komegancni");
 
     ////////////////////////////////////////////////////////////
     // finalize, print dumux message to say goodbye
diff --git a/test/multidomain/boundary/darcydarcy/1p_1p/main.cc b/test/multidomain/boundary/darcydarcy/1p_1p/main.cc
index cf2743a37495587a83916d1fdab79ce0d946bbd4..5457baed25980ab6c313dc4c2b37f51b7e30cea4 100644
--- a/test/multidomain/boundary/darcydarcy/1p_1p/main.cc
+++ b/test/multidomain/boundary/darcydarcy/1p_1p/main.cc
@@ -188,9 +188,9 @@ int main(int argc, char** argv) try
     ////////////////////////////////////////////////
 
     // create the finite volume grid geometries
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry0 = std::make_shared<FVGridGeometry>(gridView0);
-    auto fvGridGeometry1 = std::make_shared<FVGridGeometry>(gridView1);
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto fvGridGeometry0 = std::make_shared<GridGeometry>(gridView0);
+    auto fvGridGeometry1 = std::make_shared<GridGeometry>(gridView1);
     fvGridGeometry0->update();
     fvGridGeometry1->update();
 
@@ -299,8 +299,8 @@ int main(int argc, char** argv) try
     //////////////////////////////////////////////////////////////////////////
 
     const auto& gridView = gridManager.grid().leafGridView();
-    CCTpfaFVGridGeometry<typename FullDomainGrid::LeafGridView> fvGridGeometry(gridView);
-    const auto& bBoxTree = fvGridGeometry.boundingBoxTree();
+    CCTpfaFVGridGeometry<typename FullDomainGrid::LeafGridView> gridGeometry(gridView);
+    const auto& bBoxTree = gridGeometry.boundingBoxTree();
     // copy data from the subdomains to full domain data vectors
     std::vector<int> processRank(gridView.size(0), 0); // sequential simulation
     std::vector<int> pressure(gridView.size(0));
diff --git a/test/multidomain/boundary/darcydarcy/1p_1p/problem.hh b/test/multidomain/boundary/darcydarcy/1p_1p/problem.hh
index 274d6eeacfdfed90a2d53862406ac82f46046a7e..287f1b1940a897d7cf288c9fb78d1fead1b956d2 100644
--- a/test/multidomain/boundary/darcydarcy/1p_1p/problem.hh
+++ b/test/multidomain/boundary/darcydarcy/1p_1p/problem.hh
@@ -45,10 +45,10 @@ class OnePTestProblem
 {
     using ParentType = PorousMediumFlowProblem<TypeTag>;
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
@@ -60,10 +60,10 @@ class OnePTestProblem
     static constexpr auto domainIdx = Dune::index_constant<tag>{};
 
 public:
-    OnePTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    OnePTestProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                     std::shared_ptr<CouplingManager> couplingManager,
                     const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, paramGroup)
+    : ParentType(gridGeometry, paramGroup)
     , couplingManager_(couplingManager)
     {
         // set a default name for the problem
diff --git a/test/multidomain/boundary/darcydarcy/1p_1p/spatialparams.hh b/test/multidomain/boundary/darcydarcy/1p_1p/spatialparams.hh
index 145c91f6811ca5242c4442604b1b7b50f54ac6b2..67abf4af09a9af85dba413899afec931bd393b32 100644
--- a/test/multidomain/boundary/darcydarcy/1p_1p/spatialparams.hh
+++ b/test/multidomain/boundary/darcydarcy/1p_1p/spatialparams.hh
@@ -56,15 +56,15 @@ bool pointInLens(const GlobalPosition& globalPos,
  * \brief The spatial parameters class for the test problem using the
  *        incompressible 1p model.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class OnePTestSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar, OnePTestSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar, OnePTestSpatialParams<GridGeometry, Scalar>>
 {
-    using ThisType = OnePTestSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar, ThisType>;
-    using GridView = typename FVGridGeometry::GridView;
+    using ThisType = OnePTestSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar, ThisType>;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
 
     static constexpr int dimWorld = GridView::dimensionworld;
@@ -72,8 +72,8 @@ class OnePTestSpatialParams
 
 public:
     using PermeabilityType = Scalar;
-    OnePTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     , lensLowerLeft_(std::numeric_limits<Scalar>::max())
     , lensUpperRight_(std::numeric_limits<Scalar>::lowest())
     {
diff --git a/test/multidomain/boundary/darcydarcy/1p_2p/main.cc b/test/multidomain/boundary/darcydarcy/1p_2p/main.cc
index 536ebcadc46b3d35015ac2a6d60794053d1a9bd1..2abb60e76ca6255f4970b19ec9f18c4c27d10641 100644
--- a/test/multidomain/boundary/darcydarcy/1p_2p/main.cc
+++ b/test/multidomain/boundary/darcydarcy/1p_2p/main.cc
@@ -174,9 +174,9 @@ int main(int argc, char** argv) try
     ////////////////////////////////////////////////
 
     // create the finite volume grid geometries
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry0 = std::make_shared<FVGridGeometry>(gridView0);
-    auto fvGridGeometry1 = std::make_shared<FVGridGeometry>(gridView1);
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto fvGridGeometry0 = std::make_shared<GridGeometry>(gridView0);
+    auto fvGridGeometry1 = std::make_shared<GridGeometry>(gridView1);
     fvGridGeometry0->update();
     fvGridGeometry1->update();
 
diff --git a/test/multidomain/boundary/darcydarcy/1p_2p/problem.hh b/test/multidomain/boundary/darcydarcy/1p_2p/problem.hh
index addcb649a3d2a09fe102103bebb578555c21821a..90a006399060c74d3dd831486af7592c1725cfde 100644
--- a/test/multidomain/boundary/darcydarcy/1p_2p/problem.hh
+++ b/test/multidomain/boundary/darcydarcy/1p_2p/problem.hh
@@ -46,10 +46,10 @@ class OnePTestProblem
 {
     using ParentType = PorousMediumFlowProblem<TypeTag>;
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
@@ -62,10 +62,10 @@ class OnePTestProblem
     static constexpr auto domainIdx = Dune::index_constant<tag>{};
 
 public:
-    OnePTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    OnePTestProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                     std::shared_ptr<CouplingManager> couplingManager,
                     const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, paramGroup)
+    : ParentType(gridGeometry, paramGroup)
     , couplingManager_(couplingManager)
     {
         injectionRate_ = getParam<double>("Problem.InjectionRate");
diff --git a/test/multidomain/boundary/darcydarcy/1p_2p/spatialparams.hh b/test/multidomain/boundary/darcydarcy/1p_2p/spatialparams.hh
index e9a06ed4d6e4d463113b3437b7dd4251f1ec35d2..7cf67002da5f86550b4570bf17f6afdd07a5316a 100644
--- a/test/multidomain/boundary/darcydarcy/1p_2p/spatialparams.hh
+++ b/test/multidomain/boundary/darcydarcy/1p_2p/spatialparams.hh
@@ -36,15 +36,15 @@ namespace Dumux {
  * \brief The spatial parameters class for the test problem using the
  *        incompressible 1p model.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class TestSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar, TestSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar, TestSpatialParams<GridGeometry, Scalar>>
 {
-    using ThisType = TestSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, ThisType>;
-    using GridView = typename FVGridGeometry::GridView;
+    using ThisType = TestSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, ThisType>;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
 
     static constexpr int dimWorld = GridView::dimensionworld;
@@ -56,8 +56,8 @@ public:
 
     using PermeabilityType = Scalar;
 
-    TestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    TestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         materialParams_.setSwr(0.05);
         materialParams_.setSnr(0.0);
diff --git a/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/diffusionlawcomparison/problem_darcy.hh b/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/diffusionlawcomparison/problem_darcy.hh
index d236c9a2e0e243f474e2a063beb7a7b4a22d347f..16415514d1f5987f5f246bf831dd802e8b1ab315 100644
--- a/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/diffusionlawcomparison/problem_darcy.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/diffusionlawcomparison/problem_darcy.hh
@@ -95,9 +95,9 @@ struct MolecularDiffusionType<TypeTag, TTag::DarcyOnePTwoC> { using type = DIFFU
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::DarcyOnePTwoC>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePSpatialParams<GridGeometry, Scalar>;
 };
 } // end namespace Properties
 
@@ -114,7 +114,7 @@ class DarcySubProblem : public PorousMediumFlowProblem<TypeTag>
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using DiffusionCoefficientAveragingType = typename StokesDarcyCouplingOptions::DiffusionCoefficientAveragingType;
 
     // copy some indices for convenience
@@ -135,9 +135,9 @@ class DarcySubProblem : public PorousMediumFlowProblem<TypeTag>
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
 
 public:
-    DarcySubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    DarcySubProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                    std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Darcy"), eps_(1e-7), couplingManager_(couplingManager)
+    : ParentType(gridGeometry, "Darcy"), eps_(1e-7), couplingManager_(couplingManager)
     {
         pressure_ = getParamFromGroup<Scalar>(this->paramGroup(), "Problem.Pressure");
         initialMoleFraction_ = getParamFromGroup<Scalar>(this->paramGroup(), "Problem.InitialMoleFraction");
diff --git a/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/diffusionlawcomparison/problem_stokes.hh b/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/diffusionlawcomparison/problem_stokes.hh
index e0d55c6cb9c44344fcbda9613d365e1ead7c285f..bc60c5b72b6cbfbcb43f85c1aec84b4532a9299c 100644
--- a/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/diffusionlawcomparison/problem_stokes.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/diffusionlawcomparison/problem_stokes.hh
@@ -109,8 +109,8 @@ class StokesSubProblem : public NavierStokesProblem<TypeTag>
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
@@ -122,8 +122,8 @@ class StokesSubProblem : public NavierStokesProblem<TypeTag>
     using DiffusionCoefficientAveragingType = typename StokesDarcyCouplingOptions::DiffusionCoefficientAveragingType;
 
 public:
-    StokesSubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry, std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Stokes"), eps_(1e-6), injectionState_(false), couplingManager_(couplingManager)
+    StokesSubProblem(std::shared_ptr<const GridGeometry> gridGeometry, std::shared_ptr<CouplingManager> couplingManager)
+    : ParentType(gridGeometry, "Stokes"), eps_(1e-6), injectionState_(false), couplingManager_(couplingManager)
     {
         inletVelocity_ = getParamFromGroup<Scalar>(this->paramGroup(), "Problem.Velocity");
         pressure_ = getParamFromGroup<Scalar>(this->paramGroup(), "Problem.Pressure");
diff --git a/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/problem_darcy.hh b/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/problem_darcy.hh
index b53c628daff989b3bcdf4a07b5f407165dfdd041..f536c2dbf1495e735a316c97e2ba28185e66297b 100644
--- a/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/problem_darcy.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/problem_darcy.hh
@@ -82,9 +82,9 @@ struct Grid<TypeTag, TTag::DarcyOnePTwoC> { using type = Dune::YaspGrid<2>; };
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::DarcyOnePTwoC>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePSpatialParams<GridGeometry, Scalar>;
 };
 } // end namespace Dumux
 
@@ -92,8 +92,8 @@ template <class TypeTag>
 class DarcySubProblem : public PorousMediumFlowProblem<TypeTag>
 {
     using ParentType = PorousMediumFlowProblem<TypeTag>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridView = typename GridGeometry::GridView;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
@@ -110,9 +110,9 @@ class DarcySubProblem : public PorousMediumFlowProblem<TypeTag>
     using TimeLoopPtr = std::shared_ptr<TimeLoop<Scalar>>;
 
 public:
-    DarcySubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    DarcySubProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                    std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Darcy"), eps_(1e-7), couplingManager_(couplingManager)
+    : ParentType(gridGeometry, "Darcy"), eps_(1e-7), couplingManager_(couplingManager)
     {
         problemName_  =  getParam<std::string>("Vtk.OutputName") + "_" + getParamFromGroup<std::string>(this->paramGroup(), "Problem.Name");
 
diff --git a/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/problem_stokes.hh b/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/problem_stokes.hh
index ec8a1242f2e877e05f89061309dde98902e85201..2b82b15921bca10d6403b0e4d2b098744af98c36 100644
--- a/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/problem_stokes.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/problem_stokes.hh
@@ -91,8 +91,8 @@ class StokesSubProblem : public NavierStokesProblem<TypeTag>
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
@@ -104,8 +104,8 @@ class StokesSubProblem : public NavierStokesProblem<TypeTag>
     using TimeLoopPtr = std::shared_ptr<TimeLoop<Scalar>>;
 
 public:
-    StokesSubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry, std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Stokes"), eps_(1e-6), couplingManager_(couplingManager)
+    StokesSubProblem(std::shared_ptr<const GridGeometry> gridGeometry, std::shared_ptr<CouplingManager> couplingManager)
+    : ParentType(gridGeometry, "Stokes"), eps_(1e-6), couplingManager_(couplingManager)
     {
         problemName_  =  getParam<std::string>("Vtk.OutputName") + "_" + getParamFromGroup<std::string>(this->paramGroup(), "Problem.Name");
 
diff --git a/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/spatialparams.hh b/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/spatialparams.hh
index b4bcd82c16c42e70469b5ede17a5d9085069fd7d..71c0b03c0987f7bb201f46a81c6e1e34f29a64d0 100644
--- a/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/spatialparams.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/spatialparams.hh
@@ -34,14 +34,14 @@ namespace Dumux {
  * \brief The spatial parameters class for the test problem using the
  *        1p cc model.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class OnePSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             OnePSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             OnePSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                           OnePSpatialParams<FVGridGeometry, Scalar>>;
+    using GridView = typename GridGeometry::GridView;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar,
+                                           OnePSpatialParams<GridGeometry, Scalar>>;
 
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
@@ -50,8 +50,8 @@ public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    OnePSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-        : ParentType(fvGridGeometry)
+    OnePSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+        : ParentType(gridGeometry)
     {
         permeability_ = getParam<Scalar>("SpatialParams.Permeability");
         porosity_ = getParam<Scalar>("SpatialParams.Porosity");
diff --git a/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/problem_darcy.hh b/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/problem_darcy.hh
index c618dd09d96aacf06133dd6b4309799bd2d96729..9b33da50be89c7a5fe7340fe5d7205b1e1cf985d 100644
--- a/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/problem_darcy.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/problem_darcy.hh
@@ -78,9 +78,9 @@ struct UseMoles<TypeTag, TTag::DarcyTwoPTwoC> { static constexpr bool value = tr
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::DarcyTwoPTwoC>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = TwoPTwoCSpatialParams<FVGridGeometry, Scalar>;
+    using type = TwoPTwoCSpatialParams<GridGeometry, Scalar>;
 };
 
 } // end namespace Properties
@@ -98,7 +98,7 @@ class DarcySubProblem : public PorousMediumFlowProblem<TypeTag>
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
     using ElementVolumeVariables = typename GridVariables::GridVolumeVariables::LocalView;
     using ElementFluxVariablesCache = typename GridVariables::GridFluxVariablesCache::LocalView;
@@ -124,9 +124,9 @@ class DarcySubProblem : public PorousMediumFlowProblem<TypeTag>
     using DiffusionCoefficientAveragingType = typename StokesDarcyCouplingOptions::DiffusionCoefficientAveragingType;
 
 public:
-    DarcySubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    DarcySubProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                    std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Darcy"), eps_(1e-7), couplingManager_(couplingManager)
+    : ParentType(gridGeometry, "Darcy"), eps_(1e-7), couplingManager_(couplingManager)
     {
         pressure_ = getParamFromGroup<Scalar>(this->paramGroup(), "Problem.Pressure");
         initialSw_ = getParamFromGroup<Scalar>(this->paramGroup(), "Problem.Saturation");
diff --git a/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/problem_stokes.hh b/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/problem_stokes.hh
index 4432b6710316a749c8e601bfca9f4d053bb59074..462476374aae947c401f2a1e83b67ffe4d118de8 100644
--- a/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/problem_stokes.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/problem_stokes.hh
@@ -99,8 +99,8 @@ class StokesSubProblem : public NavierStokesProblem<TypeTag>
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using Element = typename GridView::template Codim<0>::Entity;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
@@ -120,8 +120,8 @@ class StokesSubProblem : public NavierStokesProblem<TypeTag>
     static constexpr bool useMoles = GetPropType<TypeTag, Properties::ModelTraits>::useMoles();
 
 public:
-    StokesSubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry, std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Stokes"), eps_(1e-6), couplingManager_(couplingManager)
+    StokesSubProblem(std::shared_ptr<const GridGeometry> gridGeometry, std::shared_ptr<CouplingManager> couplingManager)
+    : ParentType(gridGeometry, "Stokes"), eps_(1e-6), couplingManager_(couplingManager)
     {
         refVelocity_ = getParamFromGroup<Scalar>(this->paramGroup(), "Problem.RefVelocity");
         refPressure_ = getParamFromGroup<Scalar>(this->paramGroup(), "Problem.RefPressure");
diff --git a/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/spatialparams.hh b/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/spatialparams.hh
index bd537c15089e851f99350de5cd48afb1b0e801cb..670788f6dc9b4986c833668b64ba7de450aafb91 100644
--- a/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/spatialparams.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/spatialparams.hh
@@ -38,15 +38,15 @@ namespace Dumux
  * \brief The spatial parameters class for the test problem using the
  *        1p cc model.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class TwoPTwoCSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar, TwoPTwoCSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar, TwoPTwoCSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, TwoPTwoCSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, TwoPTwoCSpatialParams<GridGeometry, Scalar>>;
 
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
     using EffectiveLaw = RegularizedVanGenuchten<Scalar>;
@@ -56,8 +56,8 @@ public:
     using MaterialLawParams = typename MaterialLaw::Params;
     using PermeabilityType = Scalar;
 
-    TwoPTwoCSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-        : ParentType(fvGridGeometry)
+    TwoPTwoCSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+        : ParentType(gridGeometry)
     {
         permeability_ = getParam<Scalar>("SpatialParams.Permeability");
         porosity_ = getParam<Scalar>("SpatialParams.Porosity");
diff --git a/test/multidomain/boundary/stokesdarcy/1p3c_1p3c/problem_darcy.hh b/test/multidomain/boundary/stokesdarcy/1p3c_1p3c/problem_darcy.hh
index f2ee08a05f581aa695852ee32f9714adba64d40a..9fdb6227b7f9fc673b15fcb1946d6181b748f14f 100644
--- a/test/multidomain/boundary/stokesdarcy/1p3c_1p3c/problem_darcy.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p3c_1p3c/problem_darcy.hh
@@ -85,9 +85,9 @@ struct MolecularDiffusionType<TypeTag, TTag::DarcyOnePThreeC> { using type = Max
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::DarcyOnePThreeC>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePSpatialParams<GridGeometry, Scalar>;
 };
 
 } // end namespace Properties
@@ -105,7 +105,7 @@ class DarcySubProblem : public PorousMediumFlowProblem<TypeTag>
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using DiffusionCoefficientAveragingType = typename StokesDarcyCouplingOptions::DiffusionCoefficientAveragingType;
 
     // copy some indices for convenience
@@ -126,9 +126,9 @@ class DarcySubProblem : public PorousMediumFlowProblem<TypeTag>
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
 
 public:
-    DarcySubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    DarcySubProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                    std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Darcy"), eps_(1e-7), couplingManager_(couplingManager)
+    : ParentType(gridGeometry, "Darcy"), eps_(1e-7), couplingManager_(couplingManager)
     {
         pressure_ = getParamFromGroup<Scalar>(this->paramGroup(), "Problem.Pressure");
         initialMoleFractionN2_ = getParamFromGroup<Scalar>(this->paramGroup(), "Problem.InitialMoleFractionN2");
diff --git a/test/multidomain/boundary/stokesdarcy/1p3c_1p3c/problem_stokes.hh b/test/multidomain/boundary/stokesdarcy/1p3c_1p3c/problem_stokes.hh
index c6918e3ce030572ef28cbf53ba2305bf1c6e381e..72d391174baeb6b92b632ffc94b1022fb7fec449 100644
--- a/test/multidomain/boundary/stokesdarcy/1p3c_1p3c/problem_stokes.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p3c_1p3c/problem_stokes.hh
@@ -94,8 +94,8 @@ class StokesSubProblem : public NavierStokesProblem<TypeTag>
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
@@ -107,8 +107,8 @@ class StokesSubProblem : public NavierStokesProblem<TypeTag>
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
 
 public:
-    StokesSubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry, std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Stokes"), eps_(1e-6),
+    StokesSubProblem(std::shared_ptr<const GridGeometry> gridGeometry, std::shared_ptr<CouplingManager> couplingManager)
+    : ParentType(gridGeometry, "Stokes"), eps_(1e-6),
     couplingManager_(couplingManager)
     {
         inletVelocity_ = getParamFromGroup<Scalar>(this->paramGroup(), "Problem.Velocity");
diff --git a/test/multidomain/boundary/stokesdarcy/1p_1p/problem_darcy.hh b/test/multidomain/boundary/stokesdarcy/1p_1p/problem_darcy.hh
index 2526dbc20b69ca51d8a6ba15981d6a4fdabcb3a5..fbd698133f6a8890470b1886da6b8ef1fc563a1b 100644
--- a/test/multidomain/boundary/stokesdarcy/1p_1p/problem_darcy.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p_1p/problem_darcy.hh
@@ -66,9 +66,9 @@ struct Grid<TypeTag, TTag::DarcyOneP> { using type = Dune::YaspGrid<2>; };
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::DarcyOneP>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePSpatialParams<GridGeometry, Scalar>;
 };
 } // end namespace Properties
 
@@ -85,7 +85,7 @@ class DarcySubProblem : public PorousMediumFlowProblem<TypeTag>
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
 
@@ -95,9 +95,9 @@ class DarcySubProblem : public PorousMediumFlowProblem<TypeTag>
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
 
 public:
-    DarcySubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    DarcySubProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                    std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Darcy"), eps_(1e-7), couplingManager_(couplingManager)
+    : ParentType(gridGeometry, "Darcy"), eps_(1e-7), couplingManager_(couplingManager)
     {
         problemName_  =  getParam<std::string>("Vtk.OutputName") + "_" + getParamFromGroup<std::string>(this->paramGroup(), "Problem.Name");
 
diff --git a/test/multidomain/boundary/stokesdarcy/1p_1p/problem_stokes.hh b/test/multidomain/boundary/stokesdarcy/1p_1p/problem_stokes.hh
index 52b9cc8ceb62fe26aef19846b526728b233a2f4e..41ab898ad273d41f20d1639ae41091a81fb1dfd4 100644
--- a/test/multidomain/boundary/stokesdarcy/1p_1p/problem_stokes.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p_1p/problem_stokes.hh
@@ -86,8 +86,8 @@ class StokesSubProblem : public NavierStokesProblem<TypeTag>
 
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using Element = typename GridView::template Codim<0>::Entity;
 
@@ -99,8 +99,8 @@ class StokesSubProblem : public NavierStokesProblem<TypeTag>
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
 
 public:
-    StokesSubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry, std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Stokes"), eps_(1e-6), couplingManager_(couplingManager)
+    StokesSubProblem(std::shared_ptr<const GridGeometry> gridGeometry, std::shared_ptr<CouplingManager> couplingManager)
+    : ParentType(gridGeometry, "Stokes"), eps_(1e-6), couplingManager_(couplingManager)
     {
         problemName_  =  getParam<std::string>("Vtk.OutputName") + "_" + getParamFromGroup<std::string>(this->paramGroup(), "Problem.Name");
 
diff --git a/test/multidomain/boundary/stokesdarcy/1p_1p/spatialparams.hh b/test/multidomain/boundary/stokesdarcy/1p_1p/spatialparams.hh
index fb0adabe6240371a406469339a2099ca259eff03..3ef8c3b2866bfee8573c7289ad69ec67f5146dc6 100644
--- a/test/multidomain/boundary/stokesdarcy/1p_1p/spatialparams.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p_1p/spatialparams.hh
@@ -35,14 +35,14 @@ namespace Dumux
  * \brief The spatial parameters class for the test problem using the
  *        1p cc model.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class OnePSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             OnePSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             OnePSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                           OnePSpatialParams<FVGridGeometry, Scalar>>;
+    using GridView = typename GridGeometry::GridView;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar,
+                                           OnePSpatialParams<GridGeometry, Scalar>>;
 
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
@@ -51,8 +51,8 @@ public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    OnePSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-        : ParentType(fvGridGeometry)
+    OnePSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+        : ParentType(gridGeometry)
     {
         permeability_ = getParam<Scalar>("Darcy.SpatialParams.Permeability");
         alphaBJ_ = getParam<Scalar>("Darcy.SpatialParams.AlphaBeaversJoseph");
diff --git a/test/multidomain/boundary/stokesdarcy/1p_2p/problem_darcy.hh b/test/multidomain/boundary/stokesdarcy/1p_2p/problem_darcy.hh
index a71e106b2983f343854f9d4a84953e5576dde66f..1450aafa40b66c02e1fcf134d8b757a116b94c76 100644
--- a/test/multidomain/boundary/stokesdarcy/1p_2p/problem_darcy.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p_2p/problem_darcy.hh
@@ -63,9 +63,9 @@ struct UseMoles<TypeTag, TTag::DarcyTwoP> { static constexpr bool value = false;
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::DarcyTwoP>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = ConservationSpatialParams<FVGridGeometry, Scalar>;
+    using type = ConservationSpatialParams<GridGeometry, Scalar>;
 };
 
 //! Set the default formulation to pw-Sn: This can be over written in the problem.
@@ -91,7 +91,7 @@ class DarcySubProblem : public PorousMediumFlowProblem<TypeTag>
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
 
@@ -110,9 +110,9 @@ class DarcySubProblem : public PorousMediumFlowProblem<TypeTag>
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
 
 public:
-    DarcySubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    DarcySubProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                    std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Darcy"), eps_(1e-7), couplingManager_(couplingManager)
+    : ParentType(gridGeometry, "Darcy"), eps_(1e-7), couplingManager_(couplingManager)
     {
         pressure_ = getParamFromGroup<Scalar>(this->paramGroup(), "Problem.Pressure");
         saturation_ = getParamFromGroup<Scalar>(this->paramGroup(), "Problem.Saturation");
diff --git a/test/multidomain/boundary/stokesdarcy/1p_2p/problem_stokes.hh b/test/multidomain/boundary/stokesdarcy/1p_2p/problem_stokes.hh
index a07ab5eee6ee9208d5c0433f53c5f0a41a5f768f..043344b9098fda1fcc8b27cf1b6f439483bca788 100644
--- a/test/multidomain/boundary/stokesdarcy/1p_2p/problem_stokes.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p_2p/problem_stokes.hh
@@ -77,8 +77,8 @@ class StokesSubProblem : public NavierStokesProblem<TypeTag>
 
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using Element = typename GridView::template Codim<0>::Entity;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
@@ -92,8 +92,8 @@ class StokesSubProblem : public NavierStokesProblem<TypeTag>
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
 
 public:
-    StokesSubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry, std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Stokes"), eps_(1e-6), couplingManager_(couplingManager)
+    StokesSubProblem(std::shared_ptr<const GridGeometry> gridGeometry, std::shared_ptr<CouplingManager> couplingManager)
+    : ParentType(gridGeometry, "Stokes"), eps_(1e-6), couplingManager_(couplingManager)
     {
         inletVelocity_ = getParamFromGroup<Scalar>(this->paramGroup(), "Problem.Velocity");
         pressure_ = getParamFromGroup<Scalar>(this->paramGroup(), "Problem.Pressure");
diff --git a/test/multidomain/boundary/stokesdarcy/1p_2p/spatialparams.hh b/test/multidomain/boundary/stokesdarcy/1p_2p/spatialparams.hh
index ec1ec8d0601cb4467dd06ea9c052a3b96be692f1..46405bb904498ccd18168c06e4e1321d835c809a 100644
--- a/test/multidomain/boundary/stokesdarcy/1p_2p/spatialparams.hh
+++ b/test/multidomain/boundary/stokesdarcy/1p_2p/spatialparams.hh
@@ -38,17 +38,17 @@ namespace Dumux {
  * \brief The spatial parameters class for the test problem using the
  *        1p cc model.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class ConservationSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         ConservationSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         ConservationSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
-    using ThisType = ConservationSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, ThisType>;
+    using ThisType = ConservationSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, ThisType>;
 
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
     using EffectiveLaw = RegularizedVanGenuchten<Scalar>;
@@ -58,8 +58,8 @@ public:
     using MaterialLawParams = typename MaterialLaw::Params;
     using PermeabilityType = Scalar;
 
-    ConservationSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-        : ParentType(fvGridGeometry)
+    ConservationSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+        : ParentType(gridGeometry)
     {
         permeability_ = getParam<Scalar>("SpatialParams.Permeability");
         porosity_ = getParam<Scalar>("SpatialParams.Porosity");
diff --git a/test/multidomain/embedded/1d3d/1p2c_richards2c/problem_root.hh b/test/multidomain/embedded/1d3d/1p2c_richards2c/problem_root.hh
index f7767a164417878222fff8381265b42314b5f3ab..9ced92e868c7a0913297db25c27c83217d008407 100644
--- a/test/multidomain/embedded/1d3d/1p2c_richards2c/problem_root.hh
+++ b/test/multidomain/embedded/1d3d/1p2c_richards2c/problem_root.hh
@@ -108,12 +108,12 @@ class RootProblem : public PorousMediumFlowProblem<TypeTag>
     using NeumannFluxes = GetPropType<TypeTag, Properties::NumEqVector>;
     using SourceValues = GetPropType<TypeTag, Properties::NumEqVector>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GlobalPosition = typename FVGridGeometry::GlobalCoordinate;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GlobalPosition = typename GridGeometry::GlobalCoordinate;
     using Element = typename GridView::template Codim<0>::Entity;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
@@ -137,10 +137,10 @@ public:
     };
 
     template<class SpatialParams>
-    RootProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    RootProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                 std::shared_ptr<SpatialParams> spatialParams,
                 std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, spatialParams, "Root")
+    : ParentType(gridGeometry, spatialParams, "Root")
     , couplingManager_(couplingManager)
     {
         // read parameters from input file
diff --git a/test/multidomain/embedded/1d3d/1p2c_richards2c/problem_soil.hh b/test/multidomain/embedded/1d3d/1p2c_richards2c/problem_soil.hh
index e2994882e90cdf3f05af1e9669e542dd5c568216..9f8f7ad2289a97fe4e20a882088dd239e3748289 100644
--- a/test/multidomain/embedded/1d3d/1p2c_richards2c/problem_soil.hh
+++ b/test/multidomain/embedded/1d3d/1p2c_richards2c/problem_soil.hh
@@ -116,11 +116,11 @@ class SoilProblem : public PorousMediumFlowProblem<TypeTag>
 {
     using ParentType = PorousMediumFlowProblem<TypeTag>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
-    using GlobalPosition = typename FVGridGeometry::GlobalCoordinate;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GridView = typename GridGeometry::GridView;
+    using GlobalPosition = typename GridGeometry::GlobalCoordinate;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
@@ -147,9 +147,9 @@ public:
         liquidPhaseIdx = FluidSystem::liquidPhaseIdx
     };
 
-    SoilProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    SoilProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                 std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Soil")
+    : ParentType(gridGeometry, "Soil")
     , couplingManager_(couplingManager)
     {
         //read parameters from input file
@@ -159,7 +159,7 @@ public:
         // for initial conditions
         const Scalar sw = getParam<Scalar>("Problem.InitTopSaturation", 0.3); // start with 30% saturation on top
         using MaterialLaw = typename GetPropType<TypeTag, Properties::SpatialParams>::MaterialLaw;
-        pcTop_ = MaterialLaw::pc(this->spatialParams().materialLawParamsAtPos(fvGridGeometry->bBoxMax()), sw);
+        pcTop_ = MaterialLaw::pc(this->spatialParams().materialLawParamsAtPos(gridGeometry->bBoxMax()), sw);
     }
 
     /*!
diff --git a/test/multidomain/embedded/1d3d/1p2c_richards2c/spatialparams_root.hh b/test/multidomain/embedded/1d3d/1p2c_richards2c/spatialparams_root.hh
index 9c871659b6d8de8b01b55ff4c2c4edeece0c840e..ea54f7846e41c22faac54521ef628b1290ebfb0c 100644
--- a/test/multidomain/embedded/1d3d/1p2c_richards2c/spatialparams_root.hh
+++ b/test/multidomain/embedded/1d3d/1p2c_richards2c/spatialparams_root.hh
@@ -36,16 +36,16 @@ namespace Dumux {
  * \ingroup EmbeddedTests
  * \brief Definition of the spatial parameters for the root xylem flow.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class RootSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar, RootSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar, RootSpatialParams<GridGeometry, Scalar>>
 {
-    using ThisType = RootSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar, ThisType>;
-    using Grid = typename FVGridGeometry::Grid;
-    using GridView = typename FVGridGeometry::GridView;
+    using ThisType = RootSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar, ThisType>;
+    using Grid = typename GridGeometry::Grid;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
     //! Indices to access the parameters in the dgf file
@@ -61,15 +61,15 @@ public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    RootSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    RootSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry,
                       std::shared_ptr<const GridData<Grid>> gridData)
-    : ParentType(fvGridGeometry), gridData_(gridData)
+    : ParentType(gridGeometry), gridData_(gridData)
     {
         porosity_ = getParam<Scalar>("Root.SpatialParams.Porosity", 0.4);
         constantKx_ = getParam<Scalar>("Root.SpatialParams.Kx", 5.0968e-17);
         constantKr_ = getParam<Scalar>("Root.SpatialParams.Kr", 2.04e-13);
 
-        const auto& gv = fvGridGeometry->gridView();
+        const auto& gv = gridGeometry->gridView();
         radii_.resize(gv.size(0));
         for (const auto& element : elements(gv))
         {
diff --git a/test/multidomain/embedded/1d3d/1p2c_richards2c/spatialparams_soil.hh b/test/multidomain/embedded/1d3d/1p2c_richards2c/spatialparams_soil.hh
index 618e3eeca84593d9a76fd6f6a3641ef340928535..342eb9079ec7a1bcdb3671462e7d065b1d31d340 100644
--- a/test/multidomain/embedded/1d3d/1p2c_richards2c/spatialparams_soil.hh
+++ b/test/multidomain/embedded/1d3d/1p2c_richards2c/spatialparams_soil.hh
@@ -36,15 +36,15 @@ namespace Dumux {
  * \ingroup EmbeddedTests
  * \brief Definition of the spatial parameters for the soil problem.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class SoilSpatialParams
-: public FVSpatialParams<FVGridGeometry,Scalar, SoilSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry,Scalar, SoilSpatialParams<GridGeometry, Scalar>>
 {
-    using ThisType = SoilSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, ThisType>;
-    using GridView = typename FVGridGeometry::GridView;
+    using ThisType = SoilSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, ThisType>;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
@@ -55,8 +55,8 @@ public:
     // export material law params
     using MaterialLawParams = typename MaterialLaw::Params;
 
-    SoilSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    SoilSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         // residual saturations
         materialParams_.setSwr(0.05);
diff --git a/test/multidomain/embedded/1d3d/1p_1p/problem_bloodflow.hh b/test/multidomain/embedded/1d3d/1p_1p/problem_bloodflow.hh
index 1fc60bc8bdfad9b60949b87a5f0a2859b3d1166c..d1fb0288d37a0faed61c6c94d883c7c7a805ca60 100644
--- a/test/multidomain/embedded/1d3d/1p_1p/problem_bloodflow.hh
+++ b/test/multidomain/embedded/1d3d/1p_1p/problem_bloodflow.hh
@@ -112,20 +112,20 @@ class BloodFlowProblem : public PorousMediumFlowProblem<TypeTag>
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
     using Element = typename GridView::template Codim<0>::Entity;
-    using GlobalPosition = typename FVGridGeometry::GlobalCoordinate;
+    using GlobalPosition = typename GridGeometry::GlobalCoordinate;
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
 
 public:
-    BloodFlowProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    BloodFlowProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                      std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Vessel")
+    : ParentType(gridGeometry, "Vessel")
     , couplingManager_(couplingManager)
     {
         //read parameters from input file
diff --git a/test/multidomain/embedded/1d3d/1p_1p/problem_tissue.hh b/test/multidomain/embedded/1d3d/1p_1p/problem_tissue.hh
index b1a255cfe746203e337e65c1c1a7280a1e4888b7..6515785addccb005d16fa3caff2258985a010dc9 100644
--- a/test/multidomain/embedded/1d3d/1p_1p/problem_tissue.hh
+++ b/test/multidomain/embedded/1d3d/1p_1p/problem_tissue.hh
@@ -116,10 +116,10 @@ class TissueProblem : public PorousMediumFlowProblem<TypeTag>
 {
     using ParentType = PorousMediumFlowProblem<TypeTag>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GridView = typename GridGeometry::GridView;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
@@ -128,14 +128,14 @@ class TissueProblem : public PorousMediumFlowProblem<TypeTag>
     using PointSource = GetPropType<TypeTag, Properties::PointSource>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using Element = typename GridView::template Codim<0>::Entity;
-    using GlobalPosition = typename FVGridGeometry::GlobalCoordinate;
+    using GlobalPosition = typename GridGeometry::GlobalCoordinate;
 
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
 
 public:
-    TissueProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    TissueProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                   std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Tissue")
+    : ParentType(gridGeometry, "Tissue")
     , couplingManager_(couplingManager)
     {
         // read parameters from input file
diff --git a/test/multidomain/embedded/1d3d/1p_1p/spatialparams_bloodflow.hh b/test/multidomain/embedded/1d3d/1p_1p/spatialparams_bloodflow.hh
index 4d8f63293c7266db40ddce22059244c5b702f68a..358c6f16c03f3ac43799b0ff2d7e38d239ac2e4a 100644
--- a/test/multidomain/embedded/1d3d/1p_1p/spatialparams_bloodflow.hh
+++ b/test/multidomain/embedded/1d3d/1p_1p/spatialparams_bloodflow.hh
@@ -33,20 +33,20 @@ namespace Dumux {
  * \ingroup EmbeddedTests
  * \brief Definition of the spatial parameters for the blood flow problem.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class BloodFlowSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar, BloodFlowSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar, BloodFlowSpatialParams<GridGeometry, Scalar>>
 {
-    using ThisType = BloodFlowSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar, ThisType>;
-    using GlobalPosition = typename FVGridGeometry::GlobalCoordinate;
+    using ThisType = BloodFlowSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar, ThisType>;
+    using GlobalPosition = typename GridGeometry::GlobalCoordinate;
 
 public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    BloodFlowSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    BloodFlowSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         radius_ = getParam<Scalar>("SpatialParams.Radius");
     }
diff --git a/test/multidomain/embedded/1d3d/1p_1p/spatialparams_tissue.hh b/test/multidomain/embedded/1d3d/1p_1p/spatialparams_tissue.hh
index 82874171dddf8d489f8855b593d292b96880fb35..b9e6ab9445b67db5a4f53feb62bf36aca195fba8 100644
--- a/test/multidomain/embedded/1d3d/1p_1p/spatialparams_tissue.hh
+++ b/test/multidomain/embedded/1d3d/1p_1p/spatialparams_tissue.hh
@@ -33,21 +33,21 @@ namespace Dumux {
  * \ingroup EmbeddedTests
  * \brief Definition of the spatial parameters for the tissue problem.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class TissueSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar, TissueSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar, TissueSpatialParams<GridGeometry, Scalar>>
 {
-    using ThisType = TissueSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar, ThisType>;
-    using GridView = typename FVGridGeometry::GridView;
+    using ThisType = TissueSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar, ThisType>;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
 public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    TissueSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    TissueSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         permeability_ = getParam<Scalar>("SpatialParams.PermeabilityTissue");
         porosity_ = 1.0;
diff --git a/test/multidomain/embedded/1d3d/1p_richards/problem_root.hh b/test/multidomain/embedded/1d3d/1p_richards/problem_root.hh
index 0a22eb6a15a6cdfa835db72962d97b7742c00856..66979692310ab54028eb926c1f09754cdf890103 100644
--- a/test/multidomain/embedded/1d3d/1p_richards/problem_root.hh
+++ b/test/multidomain/embedded/1d3d/1p_richards/problem_root.hh
@@ -108,12 +108,12 @@ class RootProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NeumannFluxes = GetPropType<TypeTag, Properties::NumEqVector>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GlobalPosition = typename FVGridGeometry::GlobalCoordinate;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GlobalPosition = typename GridGeometry::GlobalCoordinate;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
     using Element = typename GridView::template Codim<0>::Entity;
@@ -122,10 +122,10 @@ class RootProblem : public PorousMediumFlowProblem<TypeTag>
 public:
 
     template<class SpatialParams>
-    RootProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    RootProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                 std::shared_ptr<SpatialParams> spatialParams,
                 std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, spatialParams, "Root")
+    : ParentType(gridGeometry, spatialParams, "Root")
     , couplingManager_(couplingManager)
     {
         // read parameters from input file
diff --git a/test/multidomain/embedded/1d3d/1p_richards/problem_soil.hh b/test/multidomain/embedded/1d3d/1p_richards/problem_soil.hh
index 883f51a8bbff0c82b9cc17203ae6b60bdbfe3708..a44d3824bd73ef997ec7e0aebf44e307bab5e857 100644
--- a/test/multidomain/embedded/1d3d/1p_richards/problem_soil.hh
+++ b/test/multidomain/embedded/1d3d/1p_richards/problem_soil.hh
@@ -97,11 +97,11 @@ class SoilProblem : public PorousMediumFlowProblem<TypeTag>
 {
     using ParentType = PorousMediumFlowProblem<TypeTag>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GlobalPosition = typename FVGridGeometry::GlobalCoordinate;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GlobalPosition = typename GridGeometry::GlobalCoordinate;
     using Element = typename GridView::template Codim<0>::Entity;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
@@ -112,9 +112,9 @@ class SoilProblem : public PorousMediumFlowProblem<TypeTag>
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
 
 public:
-    SoilProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    SoilProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                 std::shared_ptr<CouplingManager> couplingManager)
-    : ParentType(fvGridGeometry, "Soil")
+    : ParentType(gridGeometry, "Soil")
     , couplingManager_(couplingManager)
     {
         // read parameters from input file
diff --git a/test/multidomain/embedded/1d3d/1p_richards/spatialparams_root.hh b/test/multidomain/embedded/1d3d/1p_richards/spatialparams_root.hh
index 42a3b62a17d93c7907f082696a8a26affc1fc064..d580b693c57d1cd687ddc5ffda45ae3571ae79ac 100644
--- a/test/multidomain/embedded/1d3d/1p_richards/spatialparams_root.hh
+++ b/test/multidomain/embedded/1d3d/1p_richards/spatialparams_root.hh
@@ -36,16 +36,16 @@ namespace Dumux {
  * \ingroup EmbeddedTests
  * \brief Definition of the spatial parameters for the blood flow problem.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class RootSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar, RootSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar, RootSpatialParams<GridGeometry, Scalar>>
 {
-    using ThisType = RootSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar, ThisType>;
-    using Grid = typename FVGridGeometry::Grid;
-    using GridView = typename FVGridGeometry::GridView;
+    using ThisType = RootSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar, ThisType>;
+    using Grid = typename GridGeometry::Grid;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
     //! Indices to access the parameters in the dgf file
@@ -61,15 +61,15 @@ public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    RootSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    RootSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry,
                       std::shared_ptr<const GridData<Grid>> gridData)
-    : ParentType(fvGridGeometry), gridData_(gridData)
+    : ParentType(gridGeometry), gridData_(gridData)
     {
         porosity_ = getParam<Scalar>("Root.SpatialParams.Porosity", 0.4);
         constantKx_ = getParam<Scalar>("SpatialParams.Kx", 5.0968e-17);
         constantKr_ = getParam<Scalar>("SpatialParams.Kr", 2.04e-13);
 
-        const auto& gv = fvGridGeometry->gridView();
+        const auto& gv = gridGeometry->gridView();
         radii_.resize(gv.size(0));
         for (const auto& element : elements(gv))
         {
diff --git a/test/multidomain/embedded/1d3d/1p_richards/spatialparams_soil.hh b/test/multidomain/embedded/1d3d/1p_richards/spatialparams_soil.hh
index e4a5504b193f43f7450ca99f8d3d640c93d42f16..f2baa36fd3730a66a79e1346bed9acdfe3239f79 100644
--- a/test/multidomain/embedded/1d3d/1p_richards/spatialparams_soil.hh
+++ b/test/multidomain/embedded/1d3d/1p_richards/spatialparams_soil.hh
@@ -36,15 +36,15 @@ namespace Dumux {
  * \ingroup EmbeddedTests
  * \brief Definition of the spatial parameters for the tissue problem.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class SoilSpatialParams
-: public FVSpatialParams<FVGridGeometry,Scalar, SoilSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry,Scalar, SoilSpatialParams<GridGeometry, Scalar>>
 {
-    using ThisType = SoilSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, ThisType>;
-    using GridView = typename FVGridGeometry::GridView;
+    using ThisType = SoilSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, ThisType>;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
@@ -55,8 +55,8 @@ public:
     // export material law params
     using MaterialLawParams = typename MaterialLaw::Params;
 
-    SoilSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    SoilSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         // residual saturations
         materialParams_.setSwr(0.05);
diff --git a/test/multidomain/embedded/2d3d/1p_1p/problem_fracture.hh b/test/multidomain/embedded/2d3d/1p_1p/problem_fracture.hh
index 17fff01a7ac1fe6efaac7352a21f6f06af853171..bb0b52952342976f4f65b4ce6052695b4aa79e69 100644
--- a/test/multidomain/embedded/2d3d/1p_1p/problem_fracture.hh
+++ b/test/multidomain/embedded/2d3d/1p_1p/problem_fracture.hh
@@ -107,10 +107,10 @@ class FractureProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
     using Element = typename GridView::template Codim<0>::Entity;
@@ -119,11 +119,11 @@ class FractureProblem : public PorousMediumFlowProblem<TypeTag>
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
 
 public:
-    FractureProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    FractureProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                     std::shared_ptr<typename ParentType::SpatialParams> spatialParams,
                     std::shared_ptr<CouplingManager> couplingManager,
                     const std::string& paramGroup = "Fracture")
-    : ParentType(fvGridGeometry, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     , couplingManager_(couplingManager)
     {
         // read parameters from input file
diff --git a/test/multidomain/embedded/2d3d/1p_1p/problem_matrix.hh b/test/multidomain/embedded/2d3d/1p_1p/problem_matrix.hh
index e775429903faa57f85a4a4cd1ffcdaf1661dba87..c078d8deaf434937312783287bc6063b6686b86b 100644
--- a/test/multidomain/embedded/2d3d/1p_1p/problem_matrix.hh
+++ b/test/multidomain/embedded/2d3d/1p_1p/problem_matrix.hh
@@ -108,10 +108,10 @@ class MatrixProblem : public PorousMediumFlowProblem<TypeTag>
 {
     using ParentType = PorousMediumFlowProblem<TypeTag>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
@@ -132,11 +132,11 @@ class MatrixProblem : public PorousMediumFlowProblem<TypeTag>
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
 
 public:
-    MatrixProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    MatrixProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                   std::shared_ptr<typename ParentType::SpatialParams> spatialParams,
                   std::shared_ptr<CouplingManager> couplingManager,
                   const std::string& paramGroup = "Matrix")
-    : ParentType(fvGridGeometry, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     , couplingManager_(couplingManager)
     {
         // read parameters from input file
diff --git a/test/multidomain/embedded/2d3d/1p_1p/spatialparams.hh b/test/multidomain/embedded/2d3d/1p_1p/spatialparams.hh
index 602b775adec328217ff99eab0b3416cdfa823368..9118a933d838631fbcb004740a286fd01e8e62b2 100644
--- a/test/multidomain/embedded/2d3d/1p_1p/spatialparams.hh
+++ b/test/multidomain/embedded/2d3d/1p_1p/spatialparams.hh
@@ -33,23 +33,23 @@ namespace Dumux {
  * \ingroup EmbeddedTests
  * \brief Definition of the spatial parameters for the matrix and fracture problem.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class MatrixFractureSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar, MatrixFractureSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar, MatrixFractureSpatialParams<GridGeometry, Scalar>>
 {
-    using ThisType = MatrixFractureSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar, ThisType>;
-    using GridView = typename FVGridGeometry::GridView;
+    using ThisType = MatrixFractureSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar, ThisType>;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
 
 public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    MatrixFractureSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    MatrixFractureSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry,
                                 const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry)
+    : ParentType(gridGeometry)
     {
         permeability_ = getParamFromGroup<Scalar>(paramGroup, "SpatialParams.Permeability");
         porosity_ = getParamFromGroup<Scalar>(paramGroup, "SpatialParams.Porosity", 1.0);
diff --git a/test/multidomain/facet/1p_1p/analytical/main.cc b/test/multidomain/facet/1p_1p/analytical/main.cc
index f148770eb4942c21669a600cba5a04af5c24af12..26644b774bc583d00ec73da74e0b77d6829e5836 100644
--- a/test/multidomain/facet/1p_1p/analytical/main.cc
+++ b/test/multidomain/facet/1p_1p/analytical/main.cc
@@ -160,31 +160,31 @@ computeL2Norm(const GridView& gridView,
  * we have to create additional faces on interior boundaries, which wouldn't be
  * created in the standard scheme.
  */
-template< class FVGridGeometry,
+template< class GridGeometry,
           class GridManager,
           class LowDimGridView,
-          std::enable_if_t<FVGridGeometry::discMethod == Dumux::DiscretizationMethod::box, int> = 0 >
-void updateBulkFVGridGeometry(FVGridGeometry& fvGridGeometry,
+          std::enable_if_t<GridGeometry::discMethod == Dumux::DiscretizationMethod::box, int> = 0 >
+void updateBulkFVGridGeometry(GridGeometry& gridGeometry,
                               const GridManager& gridManager,
                               const LowDimGridView& lowDimGridView)
 {
     using BulkFacetGridAdapter = Dumux::CodimOneGridAdapter<typename GridManager::Embeddings>;
     BulkFacetGridAdapter facetGridAdapter(gridManager.getEmbeddings());
-    fvGridGeometry.update(lowDimGridView, facetGridAdapter);
+    gridGeometry.update(lowDimGridView, facetGridAdapter);
 }
 
 /*!
  * \brief Updates the finite volume grid geometry for the cell-centered schemes.
  */
-template< class FVGridGeometry,
+template< class GridGeometry,
           class GridManager,
           class LowDimGridView,
-          std::enable_if_t<FVGridGeometry::discMethod != Dumux::DiscretizationMethod::box, int> = 0 >
-void updateBulkFVGridGeometry(FVGridGeometry& fvGridGeometry,
+          std::enable_if_t<GridGeometry::discMethod != Dumux::DiscretizationMethod::box, int> = 0 >
+void updateBulkFVGridGeometry(GridGeometry& gridGeometry,
                               const GridManager& gridManager,
                               const LowDimGridView& lowDimGridView)
 {
-    fvGridGeometry.update();
+    gridGeometry.update();
 }
 
 // main program
diff --git a/test/multidomain/facet/1p_1p/analytical/problem_bulk.hh b/test/multidomain/facet/1p_1p/analytical/problem_bulk.hh
index ffde496f2cc77c031f80576f9f1ffb58f5389b3f..8071cdbf2aa9eb5544af01e418a594944baffc0d 100644
--- a/test/multidomain/facet/1p_1p/analytical/problem_bulk.hh
+++ b/test/multidomain/facet/1p_1p/analytical/problem_bulk.hh
@@ -91,11 +91,11 @@ class OnePBulkProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = typename GridVariables::PrimaryVariables;
     using Scalar = typename GridVariables::Scalar;
 
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -104,11 +104,11 @@ class OnePBulkProblem : public PorousMediumFlowProblem<TypeTag>
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
 
 public:
-    OnePBulkProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    OnePBulkProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                     std::shared_ptr<typename ParentType::SpatialParams> spatialParams,
                     std::shared_ptr<CouplingManager> couplingManagerPtr,
                     const std::string& paramGroup = "Bulk")
-    : ParentType(fvGridGeometry, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     , couplingManagerPtr_(couplingManagerPtr)
     , lowDimPermeability_(getParam<Scalar>("LowDim.SpatialParams.Permeability"))
     , aperture_(getParam<Scalar>("Problem.FractureAperture"))
diff --git a/test/multidomain/facet/1p_1p/analytical/problem_lowdim.hh b/test/multidomain/facet/1p_1p/analytical/problem_lowdim.hh
index 76b5d56108dbfcb894acb2744361509c307c5f23..93e0307bb81bd4f419dcdda0c8b4f02bb4801f8e 100644
--- a/test/multidomain/facet/1p_1p/analytical/problem_lowdim.hh
+++ b/test/multidomain/facet/1p_1p/analytical/problem_lowdim.hh
@@ -91,10 +91,10 @@ class OnePLowDimProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = typename GridVariables::PrimaryVariables;
     using Scalar = typename GridVariables::Scalar;
 
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -103,11 +103,11 @@ class OnePLowDimProblem : public PorousMediumFlowProblem<TypeTag>
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
 
 public:
-    OnePLowDimProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    OnePLowDimProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                       std::shared_ptr<typename ParentType::SpatialParams> spatialParams,
                       std::shared_ptr<CouplingManager> couplingManagerPtr,
                       const std::string& paramGroup = "LowDim")
-    : ParentType(fvGridGeometry, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     , couplingManagerPtr_(couplingManagerPtr)
     , aperture_(getParam<Scalar>("Problem.FractureAperture"))
     {
diff --git a/test/multidomain/facet/1p_1p/analytical/spatialparams.hh b/test/multidomain/facet/1p_1p/analytical/spatialparams.hh
index 139b3ab9df39b5769f3423db391b48a57467d082..d99a2de765cb1e2bb3310dacd638cf6b125a7b75 100644
--- a/test/multidomain/facet/1p_1p/analytical/spatialparams.hh
+++ b/test/multidomain/facet/1p_1p/analytical/spatialparams.hh
@@ -33,14 +33,14 @@ namespace Dumux {
  * \ingroup FacetTests
  * \brief The spatial parameters for the single-phase facet coupling test.
  */
-template< class FVGridGeometry, class Scalar >
+template< class GridGeometry, class Scalar >
 class OnePSpatialParams
-: public FVSpatialParamsOneP< FVGridGeometry, Scalar, OnePSpatialParams<FVGridGeometry, Scalar> >
+: public FVSpatialParamsOneP< GridGeometry, Scalar, OnePSpatialParams<GridGeometry, Scalar> >
 {
-    using ThisType = OnePSpatialParams< FVGridGeometry, Scalar >;
-    using ParentType = FVSpatialParamsOneP< FVGridGeometry, Scalar, ThisType >;
+    using ThisType = OnePSpatialParams< GridGeometry, Scalar >;
+    using ParentType = FVSpatialParamsOneP< GridGeometry, Scalar, ThisType >;
 
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -48,8 +48,8 @@ public:
     //! Export the type used for permeabilities
     using PermeabilityType = Scalar;
 
-    OnePSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry)
+    OnePSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup = "")
+    : ParentType(gridGeometry)
     {
         permeability_ = getParamFromGroup<Scalar>(paramGroup, "SpatialParams.Permeability");
     }
diff --git a/test/multidomain/facet/1p_1p/gravity/problem_bulk.hh b/test/multidomain/facet/1p_1p/gravity/problem_bulk.hh
index 25d145cd07daf6f3b0cdc127bc63b1017618d821..60e29e7ffc805ff932e89da41834b19cd9fddae1 100644
--- a/test/multidomain/facet/1p_1p/gravity/problem_bulk.hh
+++ b/test/multidomain/facet/1p_1p/gravity/problem_bulk.hh
@@ -95,11 +95,11 @@ class OnePBulkProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = typename GridVariables::PrimaryVariables;
     using Scalar = typename GridVariables::Scalar;
 
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -110,11 +110,11 @@ class OnePBulkProblem : public PorousMediumFlowProblem<TypeTag>
     static constexpr int dimWorld = GridView::dimensionworld;
 
 public:
-    OnePBulkProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    OnePBulkProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                     std::shared_ptr<typename ParentType::SpatialParams> spatialParams,
                     std::shared_ptr<CouplingManager> couplingManager,
                     const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     , couplingManagerPtr_(couplingManager)
     {
         problemName_  =  getParam<std::string>("Vtk.OutputName") + "_" +
diff --git a/test/multidomain/facet/1p_1p/gravity/problem_lowdim.hh b/test/multidomain/facet/1p_1p/gravity/problem_lowdim.hh
index cab046aefba27545e9778a91859de800961013f5..39163d0e1a5c8b84e22f0317f7d25dabd3c3b79b 100644
--- a/test/multidomain/facet/1p_1p/gravity/problem_lowdim.hh
+++ b/test/multidomain/facet/1p_1p/gravity/problem_lowdim.hh
@@ -97,10 +97,10 @@ class OnePLowDimProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = typename GridVariables::PrimaryVariables;
     using Scalar = typename GridVariables::Scalar;
 
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -111,11 +111,11 @@ class OnePLowDimProblem : public PorousMediumFlowProblem<TypeTag>
     static constexpr int dimWorld = GridView::dimensionworld;
 
 public:
-    OnePLowDimProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    OnePLowDimProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                       std::shared_ptr<typename ParentType::SpatialParams> spatialParams,
                       std::shared_ptr<CouplingManager> couplingManager,
                       const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     , couplingManagerPtr_(couplingManager)
     , aperture_(getParam<Scalar>("Problem.FractureAperture"))
     {
diff --git a/test/multidomain/facet/1p_1p/gravity/spatialparams.hh b/test/multidomain/facet/1p_1p/gravity/spatialparams.hh
index e04fd0aae9fa6e672315c07f34a133f56175e026..a56a110a144f3b3c6c9862cb649ea523f6e513d8 100644
--- a/test/multidomain/facet/1p_1p/gravity/spatialparams.hh
+++ b/test/multidomain/facet/1p_1p/gravity/spatialparams.hh
@@ -32,14 +32,14 @@ namespace Dumux {
  * \ingroup FacetTests
  * \brief The spatial parameters for the single-phase facet coupling test.
  */
-template< class FVGridGeometry, class Scalar >
+template< class GridGeometry, class Scalar >
 class OnePSpatialParams
-: public FVSpatialParamsOneP< FVGridGeometry, Scalar, OnePSpatialParams<FVGridGeometry, Scalar> >
+: public FVSpatialParamsOneP< GridGeometry, Scalar, OnePSpatialParams<GridGeometry, Scalar> >
 {
-    using ThisType = OnePSpatialParams< FVGridGeometry, Scalar >;
-    using ParentType = FVSpatialParamsOneP< FVGridGeometry, Scalar, ThisType >;
+    using ThisType = OnePSpatialParams< GridGeometry, Scalar >;
+    using ParentType = FVSpatialParamsOneP< GridGeometry, Scalar, ThisType >;
 
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -47,8 +47,8 @@ public:
     //! Export the type used for permeabilities
     using PermeabilityType = Scalar;
 
-    OnePSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry)
+    OnePSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup = "")
+    : ParentType(gridGeometry)
     {
         permeability_ = getParamFromGroup<Scalar>(paramGroup, "SpatialParams.Permeability");
     }
diff --git a/test/multidomain/facet/1p_1p/linearprofile/problem_bulk.hh b/test/multidomain/facet/1p_1p/linearprofile/problem_bulk.hh
index dfd2fadc4c098319dc7b71af8de56095fd7696f3..783ac21ac7066c0e5333ef07bcbe26ed0f36b5e7 100644
--- a/test/multidomain/facet/1p_1p/linearprofile/problem_bulk.hh
+++ b/test/multidomain/facet/1p_1p/linearprofile/problem_bulk.hh
@@ -96,11 +96,11 @@ class OnePBulkProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = typename GridVariables::PrimaryVariables;
     using Scalar = typename GridVariables::Scalar;
 
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -109,11 +109,11 @@ class OnePBulkProblem : public PorousMediumFlowProblem<TypeTag>
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
 
 public:
-    OnePBulkProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    OnePBulkProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                     std::shared_ptr<typename ParentType::SpatialParams> spatialParams,
                     std::shared_ptr<CouplingManager> couplingManager,
                     const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     , couplingManagerPtr_(couplingManager)
     {
         problemName_  =  getParam<std::string>("Vtk.OutputName") + "_" +
diff --git a/test/multidomain/facet/1p_1p/linearprofile/problem_lowdim.hh b/test/multidomain/facet/1p_1p/linearprofile/problem_lowdim.hh
index 793178315d17d66f473c05c0cc196cdfec447330..8fb742a17fda3cd56813afe6e644816a247e965d 100644
--- a/test/multidomain/facet/1p_1p/linearprofile/problem_lowdim.hh
+++ b/test/multidomain/facet/1p_1p/linearprofile/problem_lowdim.hh
@@ -97,10 +97,10 @@ class OnePLowDimProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = typename GridVariables::PrimaryVariables;
     using Scalar = typename GridVariables::Scalar;
 
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -109,11 +109,11 @@ class OnePLowDimProblem : public PorousMediumFlowProblem<TypeTag>
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
 
 public:
-    OnePLowDimProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    OnePLowDimProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                       std::shared_ptr<typename ParentType::SpatialParams> spatialParams,
                       std::shared_ptr<CouplingManager> couplingManager,
                       const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     , couplingManagerPtr_(couplingManager)
     , aperture_(getParam<Scalar>("Problem.FractureAperture"))
     {
diff --git a/test/multidomain/facet/1p_1p/linearprofile/spatialparams.hh b/test/multidomain/facet/1p_1p/linearprofile/spatialparams.hh
index 139b3ab9df39b5769f3423db391b48a57467d082..d99a2de765cb1e2bb3310dacd638cf6b125a7b75 100644
--- a/test/multidomain/facet/1p_1p/linearprofile/spatialparams.hh
+++ b/test/multidomain/facet/1p_1p/linearprofile/spatialparams.hh
@@ -33,14 +33,14 @@ namespace Dumux {
  * \ingroup FacetTests
  * \brief The spatial parameters for the single-phase facet coupling test.
  */
-template< class FVGridGeometry, class Scalar >
+template< class GridGeometry, class Scalar >
 class OnePSpatialParams
-: public FVSpatialParamsOneP< FVGridGeometry, Scalar, OnePSpatialParams<FVGridGeometry, Scalar> >
+: public FVSpatialParamsOneP< GridGeometry, Scalar, OnePSpatialParams<GridGeometry, Scalar> >
 {
-    using ThisType = OnePSpatialParams< FVGridGeometry, Scalar >;
-    using ParentType = FVSpatialParamsOneP< FVGridGeometry, Scalar, ThisType >;
+    using ThisType = OnePSpatialParams< GridGeometry, Scalar >;
+    using ParentType = FVSpatialParamsOneP< GridGeometry, Scalar, ThisType >;
 
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -48,8 +48,8 @@ public:
     //! Export the type used for permeabilities
     using PermeabilityType = Scalar;
 
-    OnePSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry)
+    OnePSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup = "")
+    : ParentType(gridGeometry)
     {
         permeability_ = getParamFromGroup<Scalar>(paramGroup, "SpatialParams.Permeability");
     }
diff --git a/test/multidomain/facet/1p_1p/threedomain/main.cc b/test/multidomain/facet/1p_1p/threedomain/main.cc
index a0de169837a8fde1faa4b53e3a5434862171fb8f..85de4b83f594859b0c801f27c1d2ec2bbc67398a 100644
--- a/test/multidomain/facet/1p_1p/threedomain/main.cc
+++ b/test/multidomain/facet/1p_1p/threedomain/main.cc
@@ -105,32 +105,32 @@ struct CouplingManager<TypeTag, TTag::OnePEdgeBox> { using type = typename BoxTr
  * we have to create additional faces on interior boundaries, which wouldn't be
  * created in the standard scheme.
  */
-template< class FVGridGeometry,
+template< class GridGeometry,
           class GridManager,
           class LowDimGridView,
-          std::enable_if_t<FVGridGeometry::discMethod == Dumux::DiscretizationMethod::box, int> = 0 >
-void updateFVGridGeometry(FVGridGeometry& fvGridGeometry,
+          std::enable_if_t<GridGeometry::discMethod == Dumux::DiscretizationMethod::box, int> = 0 >
+void updateFVGridGeometry(GridGeometry& gridGeometry,
                           const GridManager& gridManager,
                           const LowDimGridView& lowDimGridView)
 {
-    static constexpr int higherGridId = int(FVGridGeometry::GridView::dimension) == 3 ? 0 : 1;
+    static constexpr int higherGridId = int(GridGeometry::GridView::dimension) == 3 ? 0 : 1;
     using BulkFacetGridAdapter = Dumux::CodimOneGridAdapter<typename GridManager::Embeddings, higherGridId, higherGridId+1>;
     BulkFacetGridAdapter facetGridAdapter(gridManager.getEmbeddings());
-    fvGridGeometry.update(lowDimGridView, facetGridAdapter);
+    gridGeometry.update(lowDimGridView, facetGridAdapter);
 }
 
 /*!
  * \brief Updates the finite volume grid geometry for the cell-centered schemes.
  */
-template< class FVGridGeometry,
+template< class GridGeometry,
           class GridManager,
           class LowDimGridView,
-          std::enable_if_t<FVGridGeometry::discMethod != Dumux::DiscretizationMethod::box, int> = 0 >
-void updateFVGridGeometry(FVGridGeometry& fvGridGeometry,
+          std::enable_if_t<GridGeometry::discMethod != Dumux::DiscretizationMethod::box, int> = 0 >
+void updateFVGridGeometry(GridGeometry& gridGeometry,
                           const GridManager& gridManager,
                           const LowDimGridView& lowDimGridView)
 {
-    fvGridGeometry.update();
+    gridGeometry.update();
 }
 
 int main(int argc, char** argv) try
@@ -180,10 +180,10 @@ int main(int argc, char** argv) try
     const auto& edgeGridView = gridManager.template grid<edgeId>().leafGridView();
 
     // create the finite volume grid geometries
-    MultiDomainFVGridGeometry<Traits> fvGridGeometry(std::make_tuple(bulkGridView, facetGridView, edgeGridView));
-    updateFVGridGeometry(fvGridGeometry[bulkId], gridManager, facetGridView);
-    updateFVGridGeometry(fvGridGeometry[facetId], gridManager, edgeGridView);
-    fvGridGeometry[edgeId].update();
+    MultiDomainFVGridGeometry<Traits> gridGeometry(std::make_tuple(bulkGridView, facetGridView, edgeGridView));
+    updateFVGridGeometry(gridGeometry[bulkId], gridManager, facetGridView);
+    updateFVGridGeometry(gridGeometry[facetId], gridManager, edgeGridView);
+    gridGeometry[edgeId].update();
 
     // the coupling manager
     using CouplingManager = typename ThisTestTraits::CouplingManager;
@@ -196,13 +196,13 @@ int main(int argc, char** argv) try
     using FacetProblem = MultiDomainFVProblem<Traits>::template Type<facetId>;
     using EdgeProblem = MultiDomainFVProblem<Traits>::template Type<edgeId>;
 
-    auto bulkSpatialParams = std::make_shared<typename BulkProblem::SpatialParams>(fvGridGeometry.get(bulkId), "Bulk");
-    auto facetSpatialParams = std::make_shared<typename FacetProblem::SpatialParams>(fvGridGeometry.get(facetId), "Facet");
-    auto edgeSpatialParams = std::make_shared<typename EdgeProblem::SpatialParams>(fvGridGeometry.get(edgeId), "Edge");
+    auto bulkSpatialParams = std::make_shared<typename BulkProblem::SpatialParams>(gridGeometry.get(bulkId), "Bulk");
+    auto facetSpatialParams = std::make_shared<typename FacetProblem::SpatialParams>(gridGeometry.get(facetId), "Facet");
+    auto edgeSpatialParams = std::make_shared<typename EdgeProblem::SpatialParams>(gridGeometry.get(edgeId), "Edge");
 
-    problem.set(std::make_shared<BulkProblem>(fvGridGeometry.get(bulkId), bulkSpatialParams, couplingManager, "Bulk"), bulkId);
-    problem.set(std::make_shared<FacetProblem>(fvGridGeometry.get(facetId), facetSpatialParams, couplingManager, "Facet"), facetId);
-    problem.set(std::make_shared<EdgeProblem>(fvGridGeometry.get(edgeId), edgeSpatialParams, couplingManager, "Edge"), edgeId);
+    problem.set(std::make_shared<BulkProblem>(gridGeometry.get(bulkId), bulkSpatialParams, couplingManager, "Bulk"), bulkId);
+    problem.set(std::make_shared<FacetProblem>(gridGeometry.get(facetId), facetSpatialParams, couplingManager, "Facet"), facetId);
+    problem.set(std::make_shared<EdgeProblem>(gridGeometry.get(edgeId), edgeSpatialParams, couplingManager, "Edge"), edgeId);
 
     // the solution vector
     typename Traits::SolutionVector x;
@@ -211,14 +211,14 @@ int main(int argc, char** argv) try
     // the coupling mapper
     using CouplingMapper = typename ThisTestTraits::CouplingMapper;
     auto couplingMapper = std::make_shared<CouplingMapper>();
-    couplingMapper->update(fvGridGeometry[bulkId], fvGridGeometry[facetId], fvGridGeometry[edgeId], gridManager.getEmbeddings());
+    couplingMapper->update(gridGeometry[bulkId], gridGeometry[facetId], gridGeometry[edgeId], gridManager.getEmbeddings());
 
     // initialize the coupling manager
     couplingManager->init(problem.get(bulkId), problem.get(facetId), problem.get(edgeId), couplingMapper, x);
 
     // the grid variables
     using GridVariables = MultiDomainFVGridVariables<Traits>;
-    GridVariables gridVars(fvGridGeometry.getTuple(), problem.getTuple());
+    GridVariables gridVars(gridGeometry.getTuple(), problem.getTuple());
     gridVars.init(x);
 
     // intialize the vtk output module
@@ -229,7 +229,7 @@ int main(int argc, char** argv) try
 
     // the assembler
     using Assembler = MultiDomainFVAssembler<Traits, CouplingManager, DiffMethod::numeric, /*implicit?*/true>;
-    auto assembler = std::make_shared<Assembler>( problem.getTuple(), fvGridGeometry.getTuple(), gridVars.getTuple(), couplingManager);
+    auto assembler = std::make_shared<Assembler>( problem.getTuple(), gridGeometry.getTuple(), gridVars.getTuple(), couplingManager);
 
     // the linear solver
     using LinearSolver = ILU0BiCGSTABBackend;
diff --git a/test/multidomain/facet/1p_1p/threedomain/problem_bulk.hh b/test/multidomain/facet/1p_1p/threedomain/problem_bulk.hh
index f37b45af45dd18d20b201b85826c8eafb75b2f04..4d77a6a7169cbeaa114fcdcb0b6d8e3c6fb1dfd5 100644
--- a/test/multidomain/facet/1p_1p/threedomain/problem_bulk.hh
+++ b/test/multidomain/facet/1p_1p/threedomain/problem_bulk.hh
@@ -62,9 +62,9 @@ struct Problem<TypeTag, TTag::OnePBulk> { using type = OnePBulkProblem<TypeTag>;
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePBulk>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePSpatialParams<GridGeometry, Scalar>;
 };
 
 // the fluid system
@@ -94,9 +94,9 @@ class OnePBulkProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = typename GridVariables::PrimaryVariables;
     using Scalar = typename GridVariables::Scalar;
 
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -105,11 +105,11 @@ class OnePBulkProblem : public PorousMediumFlowProblem<TypeTag>
 
 public:
     //! The constructor
-    OnePBulkProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    OnePBulkProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                     std::shared_ptr<typename ParentType::SpatialParams> spatialParams,
                     std::shared_ptr<CouplingManager> couplingManagerPtr,
                     const std::string& paramGroup = "Bulk")
-    : ParentType(fvGridGeometry, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     , couplingManagerPtr_(couplingManagerPtr)
     {
         problemName_  =  getParam<std::string>("Vtk.OutputName") + "_" + getParamFromGroup<std::string>(this->paramGroup(), "Problem.Name");
diff --git a/test/multidomain/facet/1p_1p/threedomain/problem_edge.hh b/test/multidomain/facet/1p_1p/threedomain/problem_edge.hh
index c8423409dfafe55901aa7306350dd8931e760a14..6f47d87b4fe66266311be127a582388bb99f318a 100644
--- a/test/multidomain/facet/1p_1p/threedomain/problem_edge.hh
+++ b/test/multidomain/facet/1p_1p/threedomain/problem_edge.hh
@@ -64,9 +64,9 @@ struct Problem<TypeTag, TTag::OnePEdge> { using type = OnePEdgeProblem<TypeTag>;
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePEdge>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePSpatialParams<GridGeometry, Scalar>;
 };
 
 // the fluid system
@@ -97,11 +97,11 @@ class OnePEdgeProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = typename GridVariables::PrimaryVariables;
     using Scalar = typename GridVariables::Scalar;
 
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -109,11 +109,11 @@ class OnePEdgeProblem : public PorousMediumFlowProblem<TypeTag>
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
 
 public:
-    OnePEdgeProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    OnePEdgeProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                     std::shared_ptr<typename ParentType::SpatialParams> spatialParams,
                     std::shared_ptr<CouplingManager> couplingManagerPtr,
                     const std::string& paramGroup = "Edge")
-    : ParentType(fvGridGeometry, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     , couplingManagerPtr_(couplingManagerPtr)
     {
         const auto a = getParam<Scalar>("Extrusion.Aperture");
diff --git a/test/multidomain/facet/1p_1p/threedomain/problem_facet.hh b/test/multidomain/facet/1p_1p/threedomain/problem_facet.hh
index c52cc5ba268d2cfb3ae413ff38b56d8483d09a30..bce69a373cea7f9a8396decb5c0f0ff52ce824fb 100644
--- a/test/multidomain/facet/1p_1p/threedomain/problem_facet.hh
+++ b/test/multidomain/facet/1p_1p/threedomain/problem_facet.hh
@@ -63,9 +63,9 @@ struct Problem<TypeTag, TTag::OnePFacet> { using type = OnePFacetProblem<TypeTag
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePFacet>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePSpatialParams<GridGeometry, Scalar>;
 };
 
 // the fluid system
@@ -96,11 +96,11 @@ class OnePFacetProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = typename GridVariables::PrimaryVariables;
     using Scalar = typename GridVariables::Scalar;
 
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -108,11 +108,11 @@ class OnePFacetProblem : public PorousMediumFlowProblem<TypeTag>
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
 
 public:
-    OnePFacetProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    OnePFacetProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                      std::shared_ptr<typename ParentType::SpatialParams> spatialParams,
                      std::shared_ptr<CouplingManager> couplingManagerPtr,
                      const std::string& paramGroup = "Facet")
-    : ParentType(fvGridGeometry, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     , couplingManagerPtr_(couplingManagerPtr)
     , aperture_(getParam<Scalar>("Extrusion.Aperture"))
     {
diff --git a/test/multidomain/facet/1p_1p/threedomain/spatialparams.hh b/test/multidomain/facet/1p_1p/threedomain/spatialparams.hh
index 47fe1a395410373585b29b98133338853363b1ad..8a1485932c193a64c1d7e9bc5e443f04cfaffbfc 100644
--- a/test/multidomain/facet/1p_1p/threedomain/spatialparams.hh
+++ b/test/multidomain/facet/1p_1p/threedomain/spatialparams.hh
@@ -33,23 +33,23 @@ namespace Dumux {
  * \ingroup FacetTests
  * \brief The spatial parameters for the single-phase facet coupling test.
  */
-template<class FVGridGeometry, class Scalar>
-class OnePSpatialParams : public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                                     OnePSpatialParams<FVGridGeometry, Scalar>>
+template<class GridGeometry, class Scalar>
+class OnePSpatialParams : public FVSpatialParamsOneP<GridGeometry, Scalar,
+                                                     OnePSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
-    using ThisType = OnePSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar, ThisType>;
+    using ThisType = OnePSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar, ThisType>;
 
 public:
     //! Export the type used for permeability
     using PermeabilityType = Scalar;
 
-    OnePSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry)
+    OnePSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup = "")
+    : ParentType(gridGeometry)
     {
         permeability_ = getParamFromGroup<Scalar>(paramGroup, "SpatialParams.Permeability");
     }
diff --git a/test/multidomain/facet/tracer_tracer/main.cc b/test/multidomain/facet/tracer_tracer/main.cc
index 00b9b4a8eda4ba788e57e5b5dd2e10ef7d4b1c0e..e71e4427b725d3624f6c603229be6d6aad3cfafa 100644
--- a/test/multidomain/facet/tracer_tracer/main.cc
+++ b/test/multidomain/facet/tracer_tracer/main.cc
@@ -119,31 +119,31 @@ struct CouplingManager<TypeTag, TTag::TracerLowDimMpfa> { using type = typename
  * have to create additional faces on interior boundaries, which wouldn't be
  * created in the standard scheme.
  */
-template< class FVGridGeometry,
+template< class GridGeometry,
           class GridManager,
           class LowDimGridView,
-          std::enable_if_t<FVGridGeometry::discMethod == Dumux::DiscretizationMethod::box, int> = 0 >
-void updateBulkFVGridGeometry(FVGridGeometry& fvGridGeometry,
+          std::enable_if_t<GridGeometry::discMethod == Dumux::DiscretizationMethod::box, int> = 0 >
+void updateBulkFVGridGeometry(GridGeometry& gridGeometry,
                               const GridManager& gridManager,
                               const LowDimGridView& lowDimGridView)
 {
     using BulkFacetGridAdapter = Dumux::CodimOneGridAdapter<typename GridManager::Embeddings>;
     BulkFacetGridAdapter facetGridAdapter(gridManager.getEmbeddings());
-    fvGridGeometry.update(lowDimGridView, facetGridAdapter);
+    gridGeometry.update(lowDimGridView, facetGridAdapter);
 }
 
 /*!
  * \brief Updates the finite volume grid geometry for the cell centered schemes.
  */
- template< class FVGridGeometry,
+ template< class GridGeometry,
           class GridManager,
           class LowDimGridView,
-          std::enable_if_t<FVGridGeometry::discMethod != Dumux::DiscretizationMethod::box, int> = 0 >
-void updateBulkFVGridGeometry(FVGridGeometry& fvGridGeometry,
+          std::enable_if_t<GridGeometry::discMethod != Dumux::DiscretizationMethod::box, int> = 0 >
+void updateBulkFVGridGeometry(GridGeometry& gridGeometry,
                               const GridManager& gridManager,
                               const LowDimGridView& lowDimGridView)
 {
-    fvGridGeometry.update();
+    gridGeometry.update();
 }
 
 //! Computes the volume fluxes on all scvfs for a sub-domain.
@@ -152,7 +152,7 @@ void computeVolumeFluxes(Storage& volumeFluxes,
                          CM& couplingManager,
                          const Assembler& assembler,
                          const Prob& problem,
-                         const typename GV::GridGeometry& fvGridGeometry,
+                         const typename GV::GridGeometry& gridGeometry,
                          const GV& gridVariables,
                          const Sol& sol,
                          Dune::index_constant<id> domainId)
@@ -160,17 +160,17 @@ void computeVolumeFluxes(Storage& volumeFluxes,
     static constexpr bool isBox = GV::GridGeometry::discMethod == Dumux::DiscretizationMethod::box;
 
     // resize depending on the scheme
-    if (!isBox) volumeFluxes.assign(fvGridGeometry.numScvf(), {0.0});
-    else volumeFluxes.assign(fvGridGeometry.gridView().size(0), {0.0});
+    if (!isBox) volumeFluxes.assign(gridGeometry.numScvf(), {0.0});
+    else volumeFluxes.assign(gridGeometry.gridView().size(0), {0.0});
 
     auto upwindTerm = [](const auto& volVars) { return volVars.mobility(0); };
-    for (const auto& element : elements(fvGridGeometry.gridView()))
+    for (const auto& element : elements(gridGeometry.gridView()))
     {
-        const auto eIdx = fvGridGeometry.elementMapper().index(element);
+        const auto eIdx = gridGeometry.elementMapper().index(element);
 
         // bind local views
         couplingManager.bindCouplingContext(domainId, element, assembler);
-        auto fvGeometry = localView(fvGridGeometry);
+        auto fvGeometry = localView(gridGeometry);
         auto elemVolVars = localView(gridVariables.curGridVolVars());
         auto elemFluxVars = localView(gridVariables.gridFluxVarsCache());
         fvGeometry.bind(element);
@@ -194,10 +194,10 @@ void computeVolumeFluxes(Storage& volumeFluxes,
                      && problem.boundaryTypes(element, fvGeometry.scv(scvf.insideScvIdx())).hasOnlyDirichlet())
             {
                 // reconstruct flux
-                const auto elemSol = elementSolution(element, sol, fvGridGeometry);
+                const auto elemSol = elementSolution(element, sol, gridGeometry);
                 const auto gradP = evalGradients(element,
                                                  element.geometry(),
-                                                 fvGridGeometry,
+                                                 gridGeometry,
                                                  elemSol,
                                                  scvf.ipGlobal())[0];
                 const auto& insideVolVars = elemVolVars[fvGeometry.scv(scvf.insideScvIdx())];
diff --git a/test/multidomain/facet/tracer_tracer/problem_1p_bulk.hh b/test/multidomain/facet/tracer_tracer/problem_1p_bulk.hh
index 92a4b7269e4c34c2523ea9cb28c8806864446f76..9c4f4f4aece92864bd04822d8673a8774d8e298f 100644
--- a/test/multidomain/facet/tracer_tracer/problem_1p_bulk.hh
+++ b/test/multidomain/facet/tracer_tracer/problem_1p_bulk.hh
@@ -94,11 +94,11 @@ class OnePBulkProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = typename GridVariables::PrimaryVariables;
     using Scalar = typename GridVariables::Scalar;
 
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -108,11 +108,11 @@ class OnePBulkProblem : public PorousMediumFlowProblem<TypeTag>
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
 
 public:
-    OnePBulkProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    OnePBulkProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                     std::shared_ptr<typename ParentType::SpatialParams> spatialParams,
                     std::shared_ptr<CouplingManager> couplingManager,
                     const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     , couplingManagerPtr_(couplingManager)
     , overPressure_(getParamFromGroup<Scalar>(paramGroup, "Problem.BoundaryOverpressure"))
     {
diff --git a/test/multidomain/facet/tracer_tracer/problem_1p_lowdim.hh b/test/multidomain/facet/tracer_tracer/problem_1p_lowdim.hh
index cd333643b92fa5548139a0a6a38f1ba9e75399ea..5147486dae9bb15c5d83a1b1a2ba56e4b8456b14 100644
--- a/test/multidomain/facet/tracer_tracer/problem_1p_lowdim.hh
+++ b/test/multidomain/facet/tracer_tracer/problem_1p_lowdim.hh
@@ -93,10 +93,10 @@ class OnePLowDimProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = typename GridVariables::PrimaryVariables;
     using Scalar = typename GridVariables::Scalar;
 
-    using FVGridGeometry = typename GridVariables::GridGeometry;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = typename GridVariables::GridGeometry;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -106,11 +106,11 @@ class OnePLowDimProblem : public PorousMediumFlowProblem<TypeTag>
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
 
 public:
-    OnePLowDimProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    OnePLowDimProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                       std::shared_ptr<typename ParentType::SpatialParams> spatialParams,
                       std::shared_ptr<CouplingManager> couplingManager,
                       const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     , couplingManagerPtr_(couplingManager)
     , aperture_(getParamFromGroup<Scalar>(paramGroup, "Problem.FractureAperture"))
     {
diff --git a/test/multidomain/facet/tracer_tracer/problem_tracer_bulk.hh b/test/multidomain/facet/tracer_tracer/problem_tracer_bulk.hh
index 04ddab7dce0a2ea7c79fed265e0e9a02176dd507..680fff33dedc1502e5c2c5d95e147b49b5854f1f 100644
--- a/test/multidomain/facet/tracer_tracer/problem_tracer_bulk.hh
+++ b/test/multidomain/facet/tracer_tracer/problem_tracer_bulk.hh
@@ -74,9 +74,9 @@ struct Problem<TypeTag, TTag::TracerTestBulk> { using type = TracerBulkProblem<T
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::TracerTestBulk>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = TracerSpatialParams<FVGridGeometry, Scalar>;
+    using type = TracerSpatialParams<GridGeometry, Scalar>;
 };
 
 // Define whether mole(true) or mass (false) fractions are used
@@ -111,9 +111,9 @@ class TracerBulkProblem : public PorousMediumFlowProblem<TypeTag>
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
@@ -123,17 +123,17 @@ class TracerBulkProblem : public PorousMediumFlowProblem<TypeTag>
     //! property that defines whether mole or mass fractions are used
     static constexpr bool useMoles = getPropValue<TypeTag, Properties::UseMoles>();
 
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
     using typename ParentType::SpatialParams;
 
-    TracerBulkProblem(std::shared_ptr<const FVGridGeometry> fvGridGeom,
+    TracerBulkProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                       std::shared_ptr<SpatialParams> spatialParams,
                       std::shared_ptr<CouplingManager> couplingManager,
                       const std::string& paramGroup = "")
-    : ParentType(fvGridGeom, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     , couplingManagerPtr_(couplingManager)
     , initialMassFraction_(getParamFromGroup<Scalar>(paramGroup, "Problem.ContaminationMassFraction"))
     {
diff --git a/test/multidomain/facet/tracer_tracer/problem_tracer_lowdim.hh b/test/multidomain/facet/tracer_tracer/problem_tracer_lowdim.hh
index 19e2db2beb22b62ece5f0ad813f180cca1f7cd22..04aa633a7a51400eff41de8ebfabc6a9c6c2ddc5 100644
--- a/test/multidomain/facet/tracer_tracer/problem_tracer_lowdim.hh
+++ b/test/multidomain/facet/tracer_tracer/problem_tracer_lowdim.hh
@@ -67,9 +67,9 @@ struct Problem<TypeTag, TTag::TracerTestLowDim> { using type = TracerLowDimProbl
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::TracerTestLowDim>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = TracerSpatialParams<FVGridGeometry, Scalar>;
+    using type = TracerSpatialParams<GridGeometry, Scalar>;
 };
 
 // Define whether mole(true) or mass (false) fractions are used
@@ -104,8 +104,8 @@ class TracerLowDimProblem : public PorousMediumFlowProblem<TypeTag>
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
@@ -116,17 +116,17 @@ class TracerLowDimProblem : public PorousMediumFlowProblem<TypeTag>
     //! property that defines whether mole or mass fractions are used
     static constexpr bool useMoles = getPropValue<TypeTag, Properties::UseMoles>();
 
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
     using typename ParentType::SpatialParams;
 
-    TracerLowDimProblem(std::shared_ptr<const FVGridGeometry> fvGridGeom,
+    TracerLowDimProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                       std::shared_ptr<SpatialParams> spatialParams,
                       std::shared_ptr<CouplingManager> couplingManager,
                       const std::string& paramGroup = "")
-    : ParentType(fvGridGeom, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     , couplingManagerPtr_(couplingManager)
     , aperture_(getParamFromGroup<Scalar>(paramGroup, "Problem.FractureAperture"))
     {
diff --git a/test/multidomain/facet/tracer_tracer/spatialparams_1p.hh b/test/multidomain/facet/tracer_tracer/spatialparams_1p.hh
index f5c564ebb516812b9a13bbc4870a8cdb1fe739bb..041d4d04949e3c3ecd31fa6ab145251199dcb701 100644
--- a/test/multidomain/facet/tracer_tracer/spatialparams_1p.hh
+++ b/test/multidomain/facet/tracer_tracer/spatialparams_1p.hh
@@ -36,14 +36,14 @@ namespace Dumux
  * \brief The spatial parameters of the single-phase problem
  *        within the tracer facet coupling test.
  */
-template< class FVGridGeometry, class Scalar >
+template< class GridGeometry, class Scalar >
 class OnePSpatialParams
-: public FVSpatialParamsOneP< FVGridGeometry, Scalar, OnePSpatialParams<FVGridGeometry, Scalar> >
+: public FVSpatialParamsOneP< GridGeometry, Scalar, OnePSpatialParams<GridGeometry, Scalar> >
 {
-    using ThisType = OnePSpatialParams< FVGridGeometry, Scalar >;
-    using ParentType = FVSpatialParamsOneP< FVGridGeometry, Scalar, ThisType >;
+    using ThisType = OnePSpatialParams< GridGeometry, Scalar >;
+    using ParentType = FVSpatialParamsOneP< GridGeometry, Scalar, ThisType >;
 
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -51,8 +51,8 @@ public:
     //! Export the type used for permeabilities
     using PermeabilityType = Scalar;
 
-    OnePSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry)
+    OnePSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup = "")
+    : ParentType(gridGeometry)
     , permeability_(getParamFromGroup<Scalar>(paramGroup, "SpatialParams.Permeability"))
     , porosity_(getParamFromGroup<Scalar>(paramGroup, "SpatialParams.Porosity"))
     {}
diff --git a/test/multidomain/facet/tracer_tracer/spatialparams_tracer.hh b/test/multidomain/facet/tracer_tracer/spatialparams_tracer.hh
index 0b787d974d8545c439406e607d8276bfb49929e0..a1472f565e024e293dbf2235a2adb08fccbc991e 100644
--- a/test/multidomain/facet/tracer_tracer/spatialparams_tracer.hh
+++ b/test/multidomain/facet/tracer_tracer/spatialparams_tracer.hh
@@ -34,29 +34,29 @@ namespace Dumux {
  * \ingroup FacetTests
  * \brief Definition of the spatial parameters for the tracer problem.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class TracerSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             TracerSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             TracerSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                           TracerSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar,
+                                           TracerSpatialParams<GridGeometry, Scalar>>;
 
-    static constexpr bool isBox = FVGridGeometry::discMethod == DiscretizationMethod::box;
+    static constexpr bool isBox = GridGeometry::discMethod == DiscretizationMethod::box;
     static constexpr int dimWorld = GridView::dimensionworld;
     using GlobalPosition = typename Dune::FieldVector<Scalar, dimWorld>;
 
 public:
 
-    TracerSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    TracerSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry,
                         const std::vector< std::vector<Scalar> >& volumeFluxes,
                         const std::string& paramGroup = "")
-    : ParentType(fvGridGeometry)
+    : ParentType(gridGeometry)
     , volumeFlux_(volumeFluxes)
     , porosity_(getParamFromGroup<Scalar>(paramGroup, "SpatialParams.Porosity"))
     {}
diff --git a/test/multidomain/poromechanics/el1p/problem_1p.hh b/test/multidomain/poromechanics/el1p/problem_1p.hh
index 25516dac45e28206af012b85aa62bcf0f724c6b1..478ef62a952afb73091579f2a198627cab831829 100644
--- a/test/multidomain/poromechanics/el1p/problem_1p.hh
+++ b/test/multidomain/poromechanics/el1p/problem_1p.hh
@@ -67,10 +67,10 @@ struct Problem<TypeTag, TTag::OnePSub> { using type = OnePSubProblem<TypeTag> ;
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePSub>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
-    using type = OnePSpatialParams<FVGridGeometry, Scalar, CouplingManager>;
+    using type = OnePSpatialParams<GridGeometry, Scalar, CouplingManager>;
 };
 } // end namespace Properties
 
@@ -94,13 +94,13 @@ class OnePSubProblem : public PorousMediumFlowProblem<TypeTag>
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
 public:
-    OnePSubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    OnePSubProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                    std::shared_ptr<GetPropType<TypeTag, Properties::SpatialParams>> spatialParams,
                    const std::string& paramGroup = "OneP")
-    : ParentType(fvGridGeometry, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     {
         problemName_  =  getParam<std::string>("Vtk.OutputName") + "_" + getParamFromGroup<std::string>(this->paramGroup(), "Problem.Name");
     }
diff --git a/test/multidomain/poromechanics/el1p/problem_poroelastic.hh b/test/multidomain/poromechanics/el1p/problem_poroelastic.hh
index def8e598b56dbd99081b0d67abae7daac155f895..7fbe2e2c6e9f0f102d31233a4821ec4e55ae75e1 100644
--- a/test/multidomain/poromechanics/el1p/problem_poroelastic.hh
+++ b/test/multidomain/poromechanics/el1p/problem_poroelastic.hh
@@ -87,9 +87,9 @@ class PoroElasticSubProblem : public GeomechanicsFVProblem<TypeTag>
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
 
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
@@ -100,10 +100,10 @@ class PoroElasticSubProblem : public GeomechanicsFVProblem<TypeTag>
     using GradU = Dune::FieldMatrix<Scalar, dim, dimWorld>;
 
 public:
-    PoroElasticSubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    PoroElasticSubProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                           std::shared_ptr<CouplingManager> couplingManagerPtr,
                           const std::string& paramGroup = "PoroElastic")
-    : ParentType(fvGridGeometry, paramGroup)
+    : ParentType(gridGeometry, paramGroup)
     , couplingManagerPtr_(couplingManagerPtr)
     {
         problemName_  =  getParam<std::string>("Vtk.OutputName") + "_" + getParamFromGroup<std::string>(this->paramGroup(), "Problem.Name");
diff --git a/test/multidomain/poromechanics/el1p/spatialparams_1p.hh b/test/multidomain/poromechanics/el1p/spatialparams_1p.hh
index e5331893b2e43c2aa758f837edd8aff6c1edc495..ddff0f7dcadc7028050df5cd21a840b7f79df72e 100644
--- a/test/multidomain/poromechanics/el1p/spatialparams_1p.hh
+++ b/test/multidomain/poromechanics/el1p/spatialparams_1p.hh
@@ -39,25 +39,25 @@ namespace Dumux {
  * \brief The spatial parameters class for the test problem using the
  *        1p box model.
  */
-template<class FVGridGeometry, class Scalar, class CouplingManager>
-class OnePSpatialParams : public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                                     OnePSpatialParams<FVGridGeometry, Scalar, CouplingManager>>
+template<class GridGeometry, class Scalar, class CouplingManager>
+class OnePSpatialParams : public FVSpatialParamsOneP<GridGeometry, Scalar,
+                                                     OnePSpatialParams<GridGeometry, Scalar, CouplingManager>>
 {
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
-    using ThisType = OnePSpatialParams<FVGridGeometry, Scalar, CouplingManager>;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar, ThisType>;
+    using ThisType = OnePSpatialParams<GridGeometry, Scalar, CouplingManager>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar, ThisType>;
 
 public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    OnePSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    OnePSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry,
                       std::shared_ptr<CouplingManager> couplingManagerPtr)
-    : ParentType(fvGridGeometry)
+    : ParentType(gridGeometry)
     , couplingManagerPtr_(couplingManagerPtr)
     , permeability_(getParam<Scalar>("SpatialParams.Permeability"))
     , initPorosity_(getParam<Scalar>("SpatialParams.InitialPorosity"))
diff --git a/test/multidomain/poromechanics/el1p/spatialparams_poroelastic.hh b/test/multidomain/poromechanics/el1p/spatialparams_poroelastic.hh
index 4416db2d9e015285f51cc962ee4184cbee0da844..fa9b37fbf642d4a78a858fd7fafe132ba603b714 100644
--- a/test/multidomain/poromechanics/el1p/spatialparams_poroelastic.hh
+++ b/test/multidomain/poromechanics/el1p/spatialparams_poroelastic.hh
@@ -35,16 +35,16 @@ namespace Dumux {
  * \brief Definition of the spatial parameters for the poro-elastic
  *        sub-problem in the coupled poro-mechanical el1p problem.
  */
-template<class Scalar, class FVGridGeometry>
+template<class Scalar, class GridGeometry>
 class PoroElasticSpatialParams : public FVSpatialParamsPoroElastic< Scalar,
-                                                                    FVGridGeometry,
-                                                                    PoroElasticSpatialParams<Scalar, FVGridGeometry> >
+                                                                    GridGeometry,
+                                                                    PoroElasticSpatialParams<Scalar, GridGeometry> >
 {
-    using ThisType = PoroElasticSpatialParams<Scalar, FVGridGeometry>;
-    using ParentType = FVSpatialParamsPoroElastic<Scalar, FVGridGeometry, ThisType>;
+    using ThisType = PoroElasticSpatialParams<Scalar, GridGeometry>;
+    using ParentType = FVSpatialParamsPoroElastic<Scalar, GridGeometry, ThisType>;
 
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -52,8 +52,8 @@ public:
     //! Export the type of the lame parameters
     using LameParams = Dumux::LameParams<Scalar>;
 
-    PoroElasticSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    PoroElasticSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     , initPorosity_(getParam<Scalar>("SpatialParams.InitialPorosity"))
     {
         // Young's modulus [Pa]
diff --git a/test/multidomain/poromechanics/el2p/problem_2p.hh b/test/multidomain/poromechanics/el2p/problem_2p.hh
index 8db13e8e4b884fc87e5614da75d0cf7854bd3524..60abeddcd50da1f66310f2530afd21fcc4c027cf 100644
--- a/test/multidomain/poromechanics/el2p/problem_2p.hh
+++ b/test/multidomain/poromechanics/el2p/problem_2p.hh
@@ -68,10 +68,10 @@ struct Problem<TypeTag, TTag::TwoPSub> { using type = TwoPSubProblem<TypeTag> ;
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::TwoPSub>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using CouplingManager = GetPropType<TypeTag, Properties::CouplingManager>;
-    using type = TwoPSpatialParams<FVGridGeometry, Scalar, CouplingManager>;
+    using type = TwoPSpatialParams<GridGeometry, Scalar, CouplingManager>;
 };
 } // end namespace Properties
 
@@ -102,13 +102,13 @@ class TwoPSubProblem : public PorousMediumFlowProblem<TypeTag>
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
 public:
-    TwoPSubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    TwoPSubProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                    std::shared_ptr<GetPropType<TypeTag, Properties::SpatialParams>> spatialParams,
                    const std::string& paramGroup = "TwoP")
-    : ParentType(fvGridGeometry, spatialParams, paramGroup)
+    : ParentType(gridGeometry, spatialParams, paramGroup)
     {
         FluidSystem::init();
         problemName_  =  getParam<std::string>("Vtk.OutputName") + "_" + getParamFromGroup<std::string>(this->paramGroup(), "Problem.Name");
diff --git a/test/multidomain/poromechanics/el2p/problem_poroelastic.hh b/test/multidomain/poromechanics/el2p/problem_poroelastic.hh
index 602b27628f72253bbf92c549cc471a0840df167f..c7fa0cab716593de7b5caa44383f8fb38e352cba 100644
--- a/test/multidomain/poromechanics/el2p/problem_poroelastic.hh
+++ b/test/multidomain/poromechanics/el2p/problem_poroelastic.hh
@@ -89,9 +89,9 @@ class PoroElasticSubProblem : public GeomechanicsFVProblem<TypeTag>
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
 
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
@@ -102,10 +102,10 @@ class PoroElasticSubProblem : public GeomechanicsFVProblem<TypeTag>
     using GradU = Dune::FieldMatrix<Scalar, dim, dimWorld>;
 
 public:
-    PoroElasticSubProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    PoroElasticSubProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                           std::shared_ptr<CouplingManager> couplingManagerPtr,
                           const std::string& paramGroup = "PoroElastic")
-    : ParentType(fvGridGeometry, paramGroup)
+    : ParentType(gridGeometry, paramGroup)
     , couplingManagerPtr_(couplingManagerPtr)
     {
         problemName_  =  getParam<std::string>("Vtk.OutputName") + "_" + getParamFromGroup<std::string>(this->paramGroup(), "Problem.Name");
diff --git a/test/multidomain/poromechanics/el2p/spatialparams_2p.hh b/test/multidomain/poromechanics/el2p/spatialparams_2p.hh
index e33c97f6227e4f1f330683aa372abf9681d3ba73..543c5660b0473276ef7679cf3ee5a2b94279b646 100644
--- a/test/multidomain/poromechanics/el2p/spatialparams_2p.hh
+++ b/test/multidomain/poromechanics/el2p/spatialparams_2p.hh
@@ -40,17 +40,17 @@ namespace Dumux {
  * \ingroup PoromechanicsTests
  * \brief The spatial parameters class for the two-phase sub problem in the el2p test problem.
  */
-template<class FVGridGeometry, class Scalar, class CouplingManager>
-class TwoPSpatialParams : public FVSpatialParams<FVGridGeometry, Scalar,
-                                                 TwoPSpatialParams<FVGridGeometry, Scalar, CouplingManager>>
+template<class GridGeometry, class Scalar, class CouplingManager>
+class TwoPSpatialParams : public FVSpatialParams<GridGeometry, Scalar,
+                                                 TwoPSpatialParams<GridGeometry, Scalar, CouplingManager>>
 {
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
-    using ThisType = TwoPSpatialParams<FVGridGeometry, Scalar, CouplingManager>;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, ThisType>;
+    using ThisType = TwoPSpatialParams<GridGeometry, Scalar, CouplingManager>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, ThisType>;
 
 public:
     using EffectiveLaw = RegularizedBrooksCorey<Scalar>;
@@ -59,9 +59,9 @@ public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    TwoPSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    TwoPSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry,
                       std::shared_ptr<CouplingManager> couplingManagerPtr)
-    : ParentType(fvGridGeometry)
+    : ParentType(gridGeometry)
     , couplingManagerPtr_(couplingManagerPtr)
     , initPermeability_(getParam<Scalar>("SpatialParams.Permeability"))
     , initPorosity_(getParam<Scalar>("SpatialParams.InitialPorosity"))
diff --git a/test/multidomain/poromechanics/el2p/spatialparams_poroelastic.hh b/test/multidomain/poromechanics/el2p/spatialparams_poroelastic.hh
index 4416db2d9e015285f51cc962ee4184cbee0da844..fa9b37fbf642d4a78a858fd7fafe132ba603b714 100644
--- a/test/multidomain/poromechanics/el2p/spatialparams_poroelastic.hh
+++ b/test/multidomain/poromechanics/el2p/spatialparams_poroelastic.hh
@@ -35,16 +35,16 @@ namespace Dumux {
  * \brief Definition of the spatial parameters for the poro-elastic
  *        sub-problem in the coupled poro-mechanical el1p problem.
  */
-template<class Scalar, class FVGridGeometry>
+template<class Scalar, class GridGeometry>
 class PoroElasticSpatialParams : public FVSpatialParamsPoroElastic< Scalar,
-                                                                    FVGridGeometry,
-                                                                    PoroElasticSpatialParams<Scalar, FVGridGeometry> >
+                                                                    GridGeometry,
+                                                                    PoroElasticSpatialParams<Scalar, GridGeometry> >
 {
-    using ThisType = PoroElasticSpatialParams<Scalar, FVGridGeometry>;
-    using ParentType = FVSpatialParamsPoroElastic<Scalar, FVGridGeometry, ThisType>;
+    using ThisType = PoroElasticSpatialParams<Scalar, GridGeometry>;
+    using ParentType = FVSpatialParamsPoroElastic<Scalar, GridGeometry, ThisType>;
 
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -52,8 +52,8 @@ public:
     //! Export the type of the lame parameters
     using LameParams = Dumux::LameParams<Scalar>;
 
-    PoroElasticSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    PoroElasticSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     , initPorosity_(getParam<Scalar>("SpatialParams.InitialPorosity"))
     {
         // Young's modulus [Pa]
diff --git a/test/porousmediumflow/1p/implicit/compressible/instationary/main.cc b/test/porousmediumflow/1p/implicit/compressible/instationary/main.cc
index 10ce65de398ba0a1165e0d9e67a11f6084ef845d..ddf18f530593b2b94650ae1e05c76fdfb3f6a6d9 100644
--- a/test/porousmediumflow/1p/implicit/compressible/instationary/main.cc
+++ b/test/porousmediumflow/1p/implicit/compressible/instationary/main.cc
@@ -84,23 +84,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -123,7 +123,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = ILU0BiCGSTABBackend;
diff --git a/test/porousmediumflow/1p/implicit/compressible/instationary/problem.hh b/test/porousmediumflow/1p/implicit/compressible/instationary/problem.hh
index 90b065496341db382e6cc80b65e33891b20f9b19..e3c2ae728fcc93cf05f10d2ba5acb27893be8ee9 100644
--- a/test/porousmediumflow/1p/implicit/compressible/instationary/problem.hh
+++ b/test/porousmediumflow/1p/implicit/compressible/instationary/problem.hh
@@ -66,9 +66,9 @@ struct Problem<TypeTag, TTag::OnePCompressible> { using type = OnePTestProblem<T
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePCompressible>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // the fluid system
@@ -105,14 +105,14 @@ class OnePTestProblem : public PorousMediumFlowProblem<TypeTag>
     using Element = typename GridView::template Codim<0>::Entity;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     static constexpr int dimWorld = GridView::dimensionworld;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    OnePTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         Components::TabulatedComponent<Components::H2O<Scalar>>::init(272.15, 294.15, 10,
                                                       1.0e4, 1.0e6, 200);
diff --git a/test/porousmediumflow/1p/implicit/compressible/instationary/spatialparams.hh b/test/porousmediumflow/1p/implicit/compressible/instationary/spatialparams.hh
index 04b3baf4b7747fa76d7e58ff94f1fd3d9b6605df..870426b05409d552496b308ccbcf0f4a4ffde89c 100644
--- a/test/porousmediumflow/1p/implicit/compressible/instationary/spatialparams.hh
+++ b/test/porousmediumflow/1p/implicit/compressible/instationary/spatialparams.hh
@@ -35,25 +35,25 @@ namespace Dumux {
  * \brief The spatial parameters class for the test problem using the
  *        compressible 1p model.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class OnePTestSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             OnePTestSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             OnePTestSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                           OnePTestSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar,
+                                           OnePTestSpatialParams<GridGeometry, Scalar>>;
 
     static constexpr int dimWorld = GridView::dimensionworld;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
     using PermeabilityType = Scalar;
-    OnePTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         permeability_ = getParam<Scalar>("SpatialParams.Permeability");
         permeabilityLens_ = getParam<Scalar>("SpatialParams.PermeabilityLens");
diff --git a/test/porousmediumflow/1p/implicit/compressible/stationary/main.cc b/test/porousmediumflow/1p/implicit/compressible/stationary/main.cc
index 4a61085b581582de1b7cfa165c85762fb07e7247..6e9e6c3bbb74986d56913b19ede72dc18362944d 100644
--- a/test/porousmediumflow/1p/implicit/compressible/stationary/main.cc
+++ b/test/porousmediumflow/1p/implicit/compressible/stationary/main.cc
@@ -82,21 +82,21 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -109,7 +109,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables);
 
     // the linear solver
     using LinearSolver = ILU0BiCGSTABBackend;
diff --git a/test/porousmediumflow/1p/implicit/compressible/stationary/problem.hh b/test/porousmediumflow/1p/implicit/compressible/stationary/problem.hh
index 90b065496341db382e6cc80b65e33891b20f9b19..e3c2ae728fcc93cf05f10d2ba5acb27893be8ee9 100644
--- a/test/porousmediumflow/1p/implicit/compressible/stationary/problem.hh
+++ b/test/porousmediumflow/1p/implicit/compressible/stationary/problem.hh
@@ -66,9 +66,9 @@ struct Problem<TypeTag, TTag::OnePCompressible> { using type = OnePTestProblem<T
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePCompressible>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // the fluid system
@@ -105,14 +105,14 @@ class OnePTestProblem : public PorousMediumFlowProblem<TypeTag>
     using Element = typename GridView::template Codim<0>::Entity;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     static constexpr int dimWorld = GridView::dimensionworld;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    OnePTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         Components::TabulatedComponent<Components::H2O<Scalar>>::init(272.15, 294.15, 10,
                                                       1.0e4, 1.0e6, 200);
diff --git a/test/porousmediumflow/1p/implicit/compressible/stationary/spatialparams.hh b/test/porousmediumflow/1p/implicit/compressible/stationary/spatialparams.hh
index 90901ac692924f17fd86e9d38d10e322a2cf347d..c34f9bf6ad58efa3a94ae714aca07789eb9d809f 100644
--- a/test/porousmediumflow/1p/implicit/compressible/stationary/spatialparams.hh
+++ b/test/porousmediumflow/1p/implicit/compressible/stationary/spatialparams.hh
@@ -35,25 +35,25 @@ namespace Dumux {
  * \brief The spatial parameters class for the test problem using the
  *        compressible 1p model
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class OnePTestSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             OnePTestSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             OnePTestSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                           OnePTestSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar,
+                                           OnePTestSpatialParams<GridGeometry, Scalar>>;
 
     static constexpr int dimWorld = GridView::dimensionworld;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
     using PermeabilityType = Scalar;
-    OnePTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         permeability_ = getParam<Scalar>("SpatialParams.Permeability");
         permeabilityLens_ = getParam<Scalar>("SpatialParams.PermeabilityLens");
diff --git a/test/porousmediumflow/1p/implicit/convergence/problem.hh b/test/porousmediumflow/1p/implicit/convergence/problem.hh
index 3df9ebca6cb507bdd3d3d4702d3c58aaebaa3676..a1bfcceeb2511882e853aee657b6e1e579a436c0 100644
--- a/test/porousmediumflow/1p/implicit/convergence/problem.hh
+++ b/test/porousmediumflow/1p/implicit/convergence/problem.hh
@@ -67,9 +67,9 @@ struct Problem<TypeTag, TTag::OnePIncompressible> { using type = OnePTestProblem
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePIncompressible>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // use the incompressible local residual (provides analytic jacobian)
@@ -100,20 +100,20 @@ class OnePTestProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
     /*!
      * \brief The constructor.
-     * \param fvGridGeometry The finite-volume grid geometry
+     * \param gridGeometry The finite-volume grid geometry
      */
-    OnePTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {}
 
     /*!
diff --git a/test/porousmediumflow/1p/implicit/convergence/solver.hh b/test/porousmediumflow/1p/implicit/convergence/solver.hh
index ea178eb0d30b6d42b1fe9b8e1ccaad43a51e08c8..371324473a00b8671b937be604f779900866464a 100644
--- a/test/porousmediumflow/1p/implicit/convergence/solver.hh
+++ b/test/porousmediumflow/1p/implicit/convergence/solver.hh
@@ -88,26 +88,26 @@ SolutionStorage<TypeTag> solveRefinementLevel(int numCells)
     Dune::Timer timer;
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    auto x = std::make_shared<SolutionVector>(fvGridGeometry->numDofs());
+    auto x = std::make_shared<SolutionVector>(gridGeometry->numDofs());
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(*x);
 
     // create assembler & linear solver
     using Assembler = FVAssembler<TypeTag, DiffMethod::analytic>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables);
 
     using LinearSolver = ILU0BiCGSTABBackend;
     auto linearSolver = std::make_shared<LinearSolver>();
@@ -125,11 +125,11 @@ SolutionStorage<TypeTag> solveRefinementLevel(int numCells)
 
         // add exact solution
         using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-        std::vector<Scalar> exact(fvGridGeometry->numDofs());
+        std::vector<Scalar> exact(gridGeometry->numDofs());
 
-        for (const auto& element : elements(fvGridGeometry->gridView()))
+        for (const auto& element : elements(gridGeometry->gridView()))
         {
-            auto fvGeometry = localView(*fvGridGeometry);
+            auto fvGeometry = localView(*gridGeometry);
             fvGeometry.bindElement(element);
 
             for (const auto& scv : scvs(fvGeometry))
@@ -141,7 +141,7 @@ SolutionStorage<TypeTag> solveRefinementLevel(int numCells)
     }
 
     // fill storage and return
-    storage.gridGeometry = fvGridGeometry;
+    storage.gridGeometry = gridGeometry;
     storage.solution = x;
     return storage;
 }
diff --git a/test/porousmediumflow/1p/implicit/convergence/spatialparams.hh b/test/porousmediumflow/1p/implicit/convergence/spatialparams.hh
index 9c245763e3a329a15d57c080a7dee1a9c0a00109..af69b25b1a18b0939ccdeea876e36c3a8a597610 100644
--- a/test/porousmediumflow/1p/implicit/convergence/spatialparams.hh
+++ b/test/porousmediumflow/1p/implicit/convergence/spatialparams.hh
@@ -33,15 +33,15 @@ namespace Dumux {
  * \ingroup OnePTests
  * \brief The spatial params of the incompressible single-phase convergence test
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class OnePTestSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             OnePTestSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             OnePTestSpatialParams<GridGeometry, Scalar>>
 {
-    using ThisType = OnePTestSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar, ThisType>;
+    using ThisType = OnePTestSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar, ThisType>;
 
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
@@ -49,10 +49,10 @@ public:
 
     /*!
      * \brief The constructor.
-     * \param fvGridGeometry The finite-volume grid geometry
+     * \param gridGeometry The finite-volume grid geometry
      */
-    OnePTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {}
 
     /*!
diff --git a/test/porousmediumflow/1p/implicit/fracture2d3d/main.cc b/test/porousmediumflow/1p/implicit/fracture2d3d/main.cc
index 15b1f325918bf35d2252090482054529d03729f5..592f892d8050e494de8356c0747719b7c734b748 100644
--- a/test/porousmediumflow/1p/implicit/fracture2d3d/main.cc
+++ b/test/porousmediumflow/1p/implicit/fracture2d3d/main.cc
@@ -105,23 +105,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -144,11 +144,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/1p/implicit/fracture2d3d/problem.hh b/test/porousmediumflow/1p/implicit/fracture2d3d/problem.hh
index c6a4786a1a2fde8b52e9242b9245a40c4eda1ffd..94894add8a74a63bb5f546b23ed8e7edf59e4682 100644
--- a/test/porousmediumflow/1p/implicit/fracture2d3d/problem.hh
+++ b/test/porousmediumflow/1p/implicit/fracture2d3d/problem.hh
@@ -84,9 +84,9 @@ struct FluidSystem<TypeTag, TTag::Fracture>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::Fracture>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = FractureSpatialParams<FVGridGeometry, Scalar>;
+    using type = FractureSpatialParams<GridGeometry, Scalar>;
 };
 
 } // end namespace Properties
@@ -117,11 +117,11 @@ class FractureProblem : public PorousMediumFlowProblem<TypeTag>
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
 public:
-    FractureProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    FractureProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         name_ = getParam<std::string>("Problem.Name");
     }
diff --git a/test/porousmediumflow/1p/implicit/fracture2d3d/spatialparams.hh b/test/porousmediumflow/1p/implicit/fracture2d3d/spatialparams.hh
index 696eba51129164afcbd3700e4eb6d9dddda4912f..edbb0617e29259fb0f7201f62c6171d039f8c6c1 100644
--- a/test/porousmediumflow/1p/implicit/fracture2d3d/spatialparams.hh
+++ b/test/porousmediumflow/1p/implicit/fracture2d3d/spatialparams.hh
@@ -36,14 +36,14 @@ namespace Dumux {
  * \brief The spatial parameters for the LensProblem which uses the
  *        two-phase fully implicit model.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class FractureSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             FractureSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             FractureSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                           FractureSpatialParams<FVGridGeometry, Scalar>>;
+    using GridView = typename GridGeometry::GridView;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar,
+                                           FractureSpatialParams<GridGeometry, Scalar>>;
 
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
@@ -52,8 +52,8 @@ public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    FractureSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    FractureSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {}
 
     /*!
diff --git a/test/porousmediumflow/1p/implicit/incompressible/main.cc b/test/porousmediumflow/1p/implicit/incompressible/main.cc
index 541327d37f2994e466acc15021dac61d2fea0bd0..22ef9abbd39a90ac5f52046bbbda3cbe475517d5 100644
--- a/test/porousmediumflow/1p/implicit/incompressible/main.cc
+++ b/test/porousmediumflow/1p/implicit/incompressible/main.cc
@@ -57,25 +57,25 @@
 #include "../internaldirichlet/problem.hh"
 
 //! Function to write out the scv-wise velocities (overload for mpfa)
-template<class FVGridGeometry, class GridVariables, class Sol,
-         std::enable_if_t<FVGridGeometry::discMethod == Dumux::DiscretizationMethod::ccmpfa, int> = 0>
-void writeMpfaVelocities(const FVGridGeometry& fvGridGeometry,
+template<class GridGeometry, class GridVariables, class Sol,
+         std::enable_if_t<GridGeometry::discMethod == Dumux::DiscretizationMethod::ccmpfa, int> = 0>
+void writeMpfaVelocities(const GridGeometry& gridGeometry,
                          const GridVariables& gridVariables,
                          const Sol& x)
 {
     using Scalar = typename GridVariables::Scalar;
-    using GlobalPos = typename FVGridGeometry::SubControlVolume::GlobalPosition;
+    using GlobalPos = typename GridGeometry::SubControlVolume::GlobalPosition;
 
-    const auto velocities = Dumux::CCMpfaScvGradients::computeVelocities(fvGridGeometry, gridVariables, x, /*phaseIdx*/0);
+    const auto velocities = Dumux::CCMpfaScvGradients::computeVelocities(gridGeometry, gridVariables, x, /*phaseIdx*/0);
     Dumux::PointCloudVtkWriter<Scalar, GlobalPos> writer(velocities.first);
     writer.addPointData(velocities.second, "velocity (m/s)");
     writer.write("mpfa_scv_velocities");
 }
 
 //! Function to write out the scv-wise velocities (overload for NOT mpfa)
-template<class FVGridGeometry, class GridVariables, class Sol,
-         std::enable_if_t<FVGridGeometry::discMethod != Dumux::DiscretizationMethod::ccmpfa, int> = 0>
-void writeMpfaVelocities(const FVGridGeometry& fvGridGeometry,
+template<class GridGeometry, class GridVariables, class Sol,
+         std::enable_if_t<GridGeometry::discMethod != Dumux::DiscretizationMethod::ccmpfa, int> = 0>
+void writeMpfaVelocities(const GridGeometry& gridGeometry,
                          const GridVariables& gridVariables,
                          const Sol& x)
 {}
@@ -114,21 +114,21 @@ int main(int argc, char** argv) try
     Dune::Timer timer;
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -141,7 +141,7 @@ int main(int argc, char** argv) try
 
     // create assembler & linear solver
     using Assembler = FVAssembler<TypeTag, NUMDIFFMETHOD>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables);
 
     using LinearSolver = SSORCGBackend;
     auto linearSolver = std::make_shared<LinearSolver>();
@@ -163,10 +163,10 @@ int main(int argc, char** argv) try
         using VelocityVector = typename VelocityOutput::VelocityVector;
         VelocityVector velocity;
 
-        constexpr bool isBox = FVGridGeometry::discMethod == Dumux::DiscretizationMethod::box;
-        constexpr int dimWorld = FVGridGeometry::GridView::dimensionworld;
+        constexpr bool isBox = GridGeometry::discMethod == Dumux::DiscretizationMethod::box;
+        constexpr int dimWorld = GridGeometry::GridView::dimensionworld;
         const auto numCells = leafGridView.size(0);
-        const auto numDofs = fvGridGeometry->numDofs();
+        const auto numDofs = gridGeometry->numDofs();
         auto numVelocities = (isBox && dimWorld == 1) ? numCells : numDofs;
 
         velocity.resize(numVelocities);
@@ -175,9 +175,9 @@ int main(int argc, char** argv) try
 
         for (const auto& element : elements(leafGridView, Dune::Partitions::interior))
         {
-            const auto eIdx = fvGridGeometry->elementMapper().index(element);
+            const auto eIdx = gridGeometry->elementMapper().index(element);
 
-            auto fvGeometry = localView(*fvGridGeometry);
+            auto fvGeometry = localView(*gridGeometry);
             auto elemVolVars = localView(gridVariables->curGridVolVars());
             auto elemFluxVarsCache = localView(gridVariables->gridFluxVarsCache());
 
@@ -205,7 +205,7 @@ int main(int argc, char** argv) try
 
     // For the mpfa test, write out the gradients in the scv centers
     if (getParam<bool>("IO.WriteMpfaVelocities", false))
-        writeMpfaVelocities(*fvGridGeometry, *gridVariables, x);
+        writeMpfaVelocities(*gridGeometry, *gridVariables, x);
 
     if (mpiHelper.rank() == 0)
         Parameters::print();
diff --git a/test/porousmediumflow/1p/implicit/incompressible/problem.hh b/test/porousmediumflow/1p/implicit/incompressible/problem.hh
index d7ea6a085ea4f9d346f5e510dab842522609f731..c6b430a9aabe2859dfce05bf2a08276a90851d1c 100644
--- a/test/porousmediumflow/1p/implicit/incompressible/problem.hh
+++ b/test/porousmediumflow/1p/implicit/incompressible/problem.hh
@@ -73,9 +73,9 @@ struct Problem<TypeTag, TTag::OnePIncompressible> { using type = OnePTestProblem
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePIncompressible>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // use the incompressible local residual (provides analytic jacobian)
@@ -120,15 +120,15 @@ class OnePTestProblem : public PorousMediumFlowProblem<TypeTag>
     using Element = typename GridView::template Codim<0>::Entity;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     static constexpr int dimWorld = GridView::dimensionworld;
     using GlobalPosition = Dune::FieldVector<Scalar,dimWorld>;
 
 public:
-    OnePTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), velocity_(0.0)
+    OnePTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), velocity_(0.0)
     {
         extrusionFactor_ = getParam<Scalar>("Problem.ExtrusionFactor");
         Scalar permeability = getParam<Scalar>("SpatialParams.Permeability");
diff --git a/test/porousmediumflow/1p/implicit/incompressible/spatialparams.hh b/test/porousmediumflow/1p/implicit/incompressible/spatialparams.hh
index 0b0758dda33538ba996c695c6a7b3d597e9b5dde..bfaf1baeec8e4e3ebdf50cb6801cbb37671550c0 100644
--- a/test/porousmediumflow/1p/implicit/incompressible/spatialparams.hh
+++ b/test/porousmediumflow/1p/implicit/incompressible/spatialparams.hh
@@ -35,25 +35,25 @@ namespace Dumux {
  * \brief The spatial parameters class for the test problem using the
  *        incompressible 1p model
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class OnePTestSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             OnePTestSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             OnePTestSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                           OnePTestSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar,
+                                           OnePTestSpatialParams<GridGeometry, Scalar>>;
 
     static constexpr int dimWorld = GridView::dimensionworld;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
     using PermeabilityType = Scalar;
-    OnePTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         permeability_ = getParam<Scalar>("SpatialParams.Permeability");
         permeabilityLens_ = getParam<Scalar>("SpatialParams.PermeabilityLens");
diff --git a/test/porousmediumflow/1p/implicit/internaldirichlet/problem.hh b/test/porousmediumflow/1p/implicit/internaldirichlet/problem.hh
index 6708ff689c26bc6e812f88aaf755bf429ba5c896..67fd704f16d15722f34514df87101f5066161a01 100644
--- a/test/porousmediumflow/1p/implicit/internaldirichlet/problem.hh
+++ b/test/porousmediumflow/1p/implicit/internaldirichlet/problem.hh
@@ -61,13 +61,13 @@ class OnePTestProblemInternalDirichlet : public OnePTestProblem<TypeTag>
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NeumannValues = GetPropType<TypeTag, Properties::NumEqVector>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    OnePTestProblemInternalDirichlet(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePTestProblemInternalDirichlet(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {}
 
     /*!
diff --git a/test/porousmediumflow/1p/implicit/isothermal/main.cc b/test/porousmediumflow/1p/implicit/isothermal/main.cc
index 260882ed01264a3d10c3a805a29d72926f3f788b..3b9bea6e65c8c7bf5235ac6ceee77a07a3d3bdce 100644
--- a/test/porousmediumflow/1p/implicit/isothermal/main.cc
+++ b/test/porousmediumflow/1p/implicit/isothermal/main.cc
@@ -111,23 +111,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -155,11 +155,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/1p/implicit/isothermal/spatialparams.hh b/test/porousmediumflow/1p/implicit/isothermal/spatialparams.hh
index 9a748b72dda1b81487be6256b4ef7d07bc10652d..35239e43e77253562edc616aab74f630be82c6c6 100644
--- a/test/porousmediumflow/1p/implicit/isothermal/spatialparams.hh
+++ b/test/porousmediumflow/1p/implicit/isothermal/spatialparams.hh
@@ -37,17 +37,17 @@ namespace Dumux {
  * \brief The spatial parameters class for the test problem using the
  *        1p box model.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class OnePTestSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             OnePTestSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             OnePTestSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using IndexSet = typename GridView::IndexSet;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                           OnePTestSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar,
+                                           OnePTestSpatialParams<GridGeometry, Scalar>>;
 
     enum {
         dim=GridView::dimension,
@@ -61,17 +61,17 @@ public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    OnePTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-        : ParentType(fvGridGeometry),
-          randomPermeability_(fvGridGeometry->gridView().size(dim), 0.0),
-          indexSet_(fvGridGeometry->gridView().indexSet())
+    OnePTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+        : ParentType(gridGeometry),
+          randomPermeability_(gridGeometry->gridView().size(dim), 0.0),
+          indexSet_(gridGeometry->gridView().indexSet())
     {
         randomField_ = getParam<bool>("SpatialParams.RandomField", false);
         permeability_ = getParam<Scalar>("SpatialParams.Permeability");
         if(!randomField_)
             permeabilityLens_ = getParam<Scalar>("SpatialParams.PermeabilityLens");
         else
-            initRandomField(*fvGridGeometry);
+            initRandomField(*gridGeometry);
 
         lensLowerLeft_ = getParam<GlobalPosition>("SpatialParams.LensLowerLeft");
         lensUpperRight_ = getParam<GlobalPosition>("SpatialParams.LensUpperRight");
@@ -113,7 +113,7 @@ public:
      *
      * \param gg The finite-volume grid geometry used by the problem
      */
-    void initRandomField(const FVGridGeometry& gg)
+    void initRandomField(const GridGeometry& gg)
     {
         const auto& gridView = gg.gridView();
         const auto& elementMapper = gg.elementMapper();
diff --git a/test/porousmediumflow/1p/implicit/network1d3d/main.cc b/test/porousmediumflow/1p/implicit/network1d3d/main.cc
index b13d508365007b4f960705e2c1d0d3575897cd5e..2827e8b95c451ccdc6c21e35328a7a364a4fc334 100644
--- a/test/porousmediumflow/1p/implicit/network1d3d/main.cc
+++ b/test/porousmediumflow/1p/implicit/network1d3d/main.cc
@@ -105,23 +105,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -144,11 +144,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/1p/implicit/network1d3d/problem.hh b/test/porousmediumflow/1p/implicit/network1d3d/problem.hh
index 67133df7c50fcad313cbaa6b466553d4b9fd3420..3e2ca07f92b568b49baf77d1ca37a22c28937f22 100644
--- a/test/porousmediumflow/1p/implicit/network1d3d/problem.hh
+++ b/test/porousmediumflow/1p/implicit/network1d3d/problem.hh
@@ -112,9 +112,9 @@ struct Problem<TypeTag, TTag::TubesTest> { using type = TubesTestProblem<TypeTag
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::TubesTest>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = TubesTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = TubesTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // the fluid system
@@ -154,7 +154,7 @@ class TubesTestProblem : public PorousMediumFlowProblem<TypeTag>
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
@@ -163,14 +163,14 @@ class TubesTestProblem : public PorousMediumFlowProblem<TypeTag>
     enum { isBox = GetPropType<TypeTag, Properties::GridGeometry>::discMethod == DiscretizationMethod::box };
 
 public:
-    TubesTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    TubesTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         name_ = getParam<std::string>("Problem.Name");
 
         //get hMax_ of the grid
         hMax_ = 0.0;
-        for (const auto& element : elements(fvGridGeometry->gridView()))
+        for (const auto& element : elements(gridGeometry->gridView()))
            hMax_ = std::max(element.geometry().volume(), hMax_);
     }
 
diff --git a/test/porousmediumflow/1p/implicit/network1d3d/spatialparams.hh b/test/porousmediumflow/1p/implicit/network1d3d/spatialparams.hh
index d5abb2fba2a471db818d041bfcc53e124f00cb7b..3d2383faebf1bad3ee6ff783374a7c065e49f986 100644
--- a/test/porousmediumflow/1p/implicit/network1d3d/spatialparams.hh
+++ b/test/porousmediumflow/1p/implicit/network1d3d/spatialparams.hh
@@ -36,17 +36,17 @@ namespace Dumux {
  * \brief A test problem for the 1p model: A pipe system with circular cross-section
  *        and a branching point embedded in a three-dimensional world
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class TubesTestSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             TubesTestSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             TubesTestSpatialParams<GridGeometry, Scalar>>
 {
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                           TubesTestSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar,
+                                           TubesTestSpatialParams<GridGeometry, Scalar>>;
 
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -54,8 +54,8 @@ public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    TubesTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-        : ParentType(fvGridGeometry)
+    TubesTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+        : ParentType(gridGeometry)
     {
         radius_ = 1.0;
 
diff --git a/test/porousmediumflow/1p/implicit/nonisothermal/main.cc b/test/porousmediumflow/1p/implicit/nonisothermal/main.cc
index d5c20b5452cce4a4f2dbcb575d27a4e0c02ae5c5..e4ad2594c0c3e8149431b4723108f923d405cdab 100644
--- a/test/porousmediumflow/1p/implicit/nonisothermal/main.cc
+++ b/test/porousmediumflow/1p/implicit/nonisothermal/main.cc
@@ -108,14 +108,14 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    const std::string paramGroup = FVGridGeometry::discMethod == DiscretizationMethod::ccmpfa ? "MpfaTest" : "";
-    auto problem = std::make_shared<Problem>(fvGridGeometry, paramGroup);
+    const std::string paramGroup = GridGeometry::discMethod == DiscretizationMethod::ccmpfa ? "MpfaTest" : "";
+    auto problem = std::make_shared<Problem>(gridGeometry, paramGroup);
 
     // get some time loop parameters
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
@@ -128,14 +128,14 @@ int main(int argc, char** argv) try
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     if (restartTime > 0)
     {
         using IOFields = GetPropType<TypeTag, Properties::IOFields>;
         using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
         using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
         const auto fileName = getParam<std::string>("Restart.File");
-        loadSolution(x, fileName, createPVNameFunction<IOFields, PrimaryVariables, ModelTraits>(), *fvGridGeometry);
+        loadSolution(x, fileName, createPVNameFunction<IOFields, PrimaryVariables, ModelTraits>(), *gridGeometry);
     }
     else
         problem->applyInitialSolution(x);
@@ -143,7 +143,7 @@ int main(int argc, char** argv) try
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -164,11 +164,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/1p/implicit/nonisothermal/problem_conduction.hh b/test/porousmediumflow/1p/implicit/nonisothermal/problem_conduction.hh
index 64dd602a39ac237e4b4923450b35a8ea0d86a6ec..22ae3df812523537fe9427957f341f5f1679f7f4 100644
--- a/test/porousmediumflow/1p/implicit/nonisothermal/problem_conduction.hh
+++ b/test/porousmediumflow/1p/implicit/nonisothermal/problem_conduction.hh
@@ -77,9 +77,9 @@ struct FluidSystem<TypeTag, TTag::OnePNIConduction>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePNIConduction>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePNISpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePNISpatialParams<GridGeometry, Scalar>;
 };
 }
 
@@ -131,18 +131,18 @@ class OnePNIConductionProblem : public PorousMediumFlowProblem<TypeTag>
 
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
 public:
-    OnePNIConductionProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup)
-    : ParentType(fvGridGeometry, paramGroup)
+    OnePNIConductionProblem(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup)
+    : ParentType(gridGeometry, paramGroup)
     {
         //initialize fluid system
         FluidSystem::init();
 
         name_ = getParam<std::string>("Problem.Name");
         temperatureHigh_ = 300.0;
-        temperatureExact_.resize(fvGridGeometry->numDofs());
+        temperatureExact_.resize(gridGeometry->numDofs());
     }
 
     //! Get the analytical temperature
diff --git a/test/porousmediumflow/1p/implicit/nonisothermal/problem_convection.hh b/test/porousmediumflow/1p/implicit/nonisothermal/problem_convection.hh
index fc9ce339eb8c86cab63c7cbdb9fe93e33a05757b..fd99103799027f24f2e2407a3f1cd0537f93dfac 100644
--- a/test/porousmediumflow/1p/implicit/nonisothermal/problem_convection.hh
+++ b/test/porousmediumflow/1p/implicit/nonisothermal/problem_convection.hh
@@ -77,9 +77,9 @@ struct FluidSystem<TypeTag, TTag::OnePNIConvection>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePNIConvection>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePNISpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePNISpatialParams<GridGeometry, Scalar>;
 };
 } // end namespace Properties
 
@@ -143,11 +143,11 @@ class OnePNIConvectionProblem : public PorousMediumFlowProblem<TypeTag>
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
 public:
-    OnePNIConvectionProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry, const std::string& paramGroup)
-    : ParentType(fvGridGeometry, paramGroup)
+    OnePNIConvectionProblem(std::shared_ptr<const GridGeometry> gridGeometry, const std::string& paramGroup)
+    : ParentType(gridGeometry, paramGroup)
     {
         //initialize fluid system
         FluidSystem::init();
diff --git a/test/porousmediumflow/1p/implicit/nonisothermal/spatialparams.hh b/test/porousmediumflow/1p/implicit/nonisothermal/spatialparams.hh
index 435a4095cd440beabc0cd9cf48a672a0d1209ecd..860a13b7158822a198635abbb332ac5789da2108 100644
--- a/test/porousmediumflow/1p/implicit/nonisothermal/spatialparams.hh
+++ b/test/porousmediumflow/1p/implicit/nonisothermal/spatialparams.hh
@@ -34,14 +34,14 @@ namespace Dumux {
  * \ingroup OnePTests
  * \brief Definition of the spatial parameters for the 1pni problems.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class OnePNISpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             OnePNISpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             OnePNISpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                           OnePNISpatialParams<FVGridGeometry, Scalar>>;
+    using GridView = typename GridGeometry::GridView;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar,
+                                           OnePNISpatialParams<GridGeometry, Scalar>>;
 
     static const int dimWorld = GridView::dimensionworld;
     using Element = typename GridView::template Codim<0>::Entity;
@@ -51,8 +51,8 @@ public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    OnePNISpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry) {}
+    OnePNISpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry) {}
 
     /*!
      * \brief Defines the intrinsic permeability \f$\mathrm{[m^2]}\f$.
diff --git a/test/porousmediumflow/1p/implicit/periodicbc/main.cc b/test/porousmediumflow/1p/implicit/periodicbc/main.cc
index 393ca05ee9926c824a8a65f4b39a8be4980d4120..cfc8188336d26a12e0556761f0c687216db2183b 100644
--- a/test/porousmediumflow/1p/implicit/periodicbc/main.cc
+++ b/test/porousmediumflow/1p/implicit/periodicbc/main.cc
@@ -77,27 +77,27 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry (and make it periodic)
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
-    bool periodic = fvGridGeometry->isPeriodic();
-    periodic = fvGridGeometry->gridView().comm().max(periodic);
+    bool periodic = gridGeometry->isPeriodic();
+    periodic = gridGeometry->gridView().comm().max(periodic);
     if (!periodic)
         DUNE_THROW(Dune::GridError, "Your grid is not periodic. Maybe the grid manager doesn't support periodic boundaries.");
 
     // the problem (boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
     problem->computePointSourceMap();
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -108,7 +108,7 @@ int main(int argc, char** argv) try
 
     // make assemble and attach linear system
     using Assembler = FVAssembler<TypeTag, DiffMethod::analytic>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables);
     using JacobianMatrix = GetPropType<TypeTag, Properties::JacobianMatrix>;
     auto A = std::make_shared<JacobianMatrix>();
     auto r = std::make_shared<SolutionVector>();
@@ -128,7 +128,7 @@ int main(int argc, char** argv) try
     // solve the linear system
     Dune::Timer solverTimer;
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(fvGridGeometry->gridView(), fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(gridGeometry->gridView(), gridGeometry->dofMapper());
 
     if (mpiHelper.rank() == 0) std::cout << "Solving linear system using " + linearSolver->name() + "..." << std::flush;
     linearSolver->solve(*A, x, *r);
diff --git a/test/porousmediumflow/1p/implicit/periodicbc/problem.hh b/test/porousmediumflow/1p/implicit/periodicbc/problem.hh
index cb78df459f2e39fbb630d18187e70bef56315a6c..41a50d7febf77d4aad469c20ca9d7b61135cffa2 100644
--- a/test/porousmediumflow/1p/implicit/periodicbc/problem.hh
+++ b/test/porousmediumflow/1p/implicit/periodicbc/problem.hh
@@ -113,14 +113,14 @@ class OnePTestProblem : public PorousMediumFlowProblem<TypeTag>
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using SourceValues = GetPropType<TypeTag, Properties::NumEqVector>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     static constexpr int dimWorld = GridView::dimensionworld;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    OnePTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         sourcePosition_ = getParam<GlobalPosition>("Source.Position");
         sourceValues_ = getParam<SourceValues>("Source.Values");
diff --git a/test/porousmediumflow/1p/implicit/periodicbc/spatialparams.hh b/test/porousmediumflow/1p/implicit/periodicbc/spatialparams.hh
index 73a25ecd30dd7238d8486048493d492bb85c22a6..c677ea1f9ea06d92f0d19d3ec2deb84f490cd20b 100644
--- a/test/porousmediumflow/1p/implicit/periodicbc/spatialparams.hh
+++ b/test/porousmediumflow/1p/implicit/periodicbc/spatialparams.hh
@@ -41,20 +41,20 @@ class OnePTestSpatialParams
                              OnePTestSpatialParams<TypeTag>>
 {
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar, OnePTestSpatialParams<TypeTag>>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar, OnePTestSpatialParams<TypeTag>>;
 
     static constexpr int dimWorld = GridView::dimensionworld;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
     using PermeabilityType = Scalar;
-    OnePTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         permeability_ = getParam<Scalar>("SpatialParams.Permeability");
         permeabilityLens_ = getParam<Scalar>("SpatialParams.PermeabilityLens");
diff --git a/test/porousmediumflow/1p/implicit/pointsources/spatialparams.hh b/test/porousmediumflow/1p/implicit/pointsources/spatialparams.hh
index 642d30772e92eeb7beefaef1a6eec27a66baa403..03ef1b3845ebf2eb8d28d2bb6e0915ba6901337f 100644
--- a/test/porousmediumflow/1p/implicit/pointsources/spatialparams.hh
+++ b/test/porousmediumflow/1p/implicit/pointsources/spatialparams.hh
@@ -36,25 +36,25 @@ namespace Dumux {
  * \brief The spatial parameters class for the test problem using the
  *        1p model with point sources.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class OnePSingularitySpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             OnePSingularitySpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             OnePSingularitySpatialParams<GridGeometry, Scalar>>
 {
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                           OnePSingularitySpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar,
+                                           OnePSingularitySpatialParams<GridGeometry, Scalar>>;
 
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    OnePSingularitySpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-        : ParentType(fvGridGeometry)
+    OnePSingularitySpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+        : ParentType(gridGeometry)
     {
         permeability_ = getParam<Scalar>("SpatialParams.Permeability");
         porosity_= getParam<Scalar>("SpatialParams.Porosity");
diff --git a/test/porousmediumflow/1p/implicit/pointsources/timedependent/main.cc b/test/porousmediumflow/1p/implicit/pointsources/timedependent/main.cc
index e1c7cafab6405f31b190ea9dc9ec306527252eb6..23a5a542c81bacae65e0c75e0ac242b2f66830d2 100644
--- a/test/porousmediumflow/1p/implicit/pointsources/timedependent/main.cc
+++ b/test/porousmediumflow/1p/implicit/pointsources/timedependent/main.cc
@@ -80,24 +80,24 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
     problem->computePointSourceMap(); // enable point sources
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -120,11 +120,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/1p/implicit/pointsources/timedependent/problem.hh b/test/porousmediumflow/1p/implicit/pointsources/timedependent/problem.hh
index d3c9d1bd7ea36d1c370b011fc3a01304cfd47433..902f784774510538ce94806853594391fbaa3e5f 100644
--- a/test/porousmediumflow/1p/implicit/pointsources/timedependent/problem.hh
+++ b/test/porousmediumflow/1p/implicit/pointsources/timedependent/problem.hh
@@ -75,11 +75,11 @@ class OnePSingularityProblemTimeDependent : public OnePSingularityProblem<TypeTa
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
 public:
-    OnePSingularityProblemTimeDependent(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePSingularityProblemTimeDependent(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {}
 
     /*!
diff --git a/test/porousmediumflow/1p/implicit/pointsources/timeindependent/main.cc b/test/porousmediumflow/1p/implicit/pointsources/timeindependent/main.cc
index d10892dea3360f6f3aef09952ef3f0d59477d164..c5789a9f4748bdc962e728794e3fca1d52e62cb6 100644
--- a/test/porousmediumflow/1p/implicit/pointsources/timeindependent/main.cc
+++ b/test/porousmediumflow/1p/implicit/pointsources/timeindependent/main.cc
@@ -80,24 +80,24 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
     problem->computePointSourceMap(); // enable point sources
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -120,11 +120,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/1p/implicit/pointsources/timeindependent/problem.hh b/test/porousmediumflow/1p/implicit/pointsources/timeindependent/problem.hh
index 816eed96a0584e0a1d111d22dccd8bd1fe4fb8f8..3f2acb0d76f16853ad20586d17aa6c9efbd044b5 100644
--- a/test/porousmediumflow/1p/implicit/pointsources/timeindependent/problem.hh
+++ b/test/porousmediumflow/1p/implicit/pointsources/timeindependent/problem.hh
@@ -75,9 +75,9 @@ struct Problem<TypeTag, TTag::OnePSingularity> { using type = OnePSingularityPro
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePSingularity>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePSingularitySpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePSingularitySpatialParams<GridGeometry, Scalar>;
 };
 }
 
@@ -112,13 +112,13 @@ class OnePSingularityProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using PointSource = GetPropType<TypeTag, Properties::PointSource>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    OnePSingularityProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePSingularityProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         name_ = getParam<std::string>("Problem.Name");
     }
diff --git a/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/main.cc b/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/main.cc
index 0a26f5f85f15e1093d9e89acf2f0e09de4f3e66d..2664ba957cc1100217bcf8fcc86d6ef35ace9eaa 100644
--- a/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/main.cc
+++ b/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/main.cc
@@ -84,23 +84,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -123,7 +123,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = ILU0BiCGSTABBackend;
diff --git a/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/problem.hh b/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/problem.hh
index ad481750832c0781c02c35a99532e489c10ad4ae..f187f283da8f4c25f3c6a843ffbd089f044553ce 100644
--- a/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/problem.hh
+++ b/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/problem.hh
@@ -86,9 +86,9 @@ struct FluidSystem<TypeTag, TTag::OnePTwoCTest>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePTwoCTest>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePNCTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePNCTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // Define whether mole(true) or mass (false) fractions are used
@@ -134,7 +134,7 @@ class OnePTwoCTestProblem : public PorousMediumFlowProblem<TypeTag>
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
 
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
 
@@ -167,8 +167,8 @@ class OnePTwoCTestProblem : public PorousMediumFlowProblem<TypeTag>
     using GlobalPosition = typename SubControlVolumeFace::GlobalPosition;
 
 public:
-    OnePTwoCTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), useNitscheTypeBc_(getParam<bool>("Problem.UseNitscheTypeBc", false))
+    OnePTwoCTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), useNitscheTypeBc_(getParam<bool>("Problem.UseNitscheTypeBc", false))
     {
         //initialize fluid system
         FluidSystem::init();
diff --git a/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/saltwaterintrusion/main.cc b/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/saltwaterintrusion/main.cc
index adbf3fb55a1c6c4ccb3fef48af32bdbfcbd2a394..f55bc9d6106350e2f01f4d475cfbb1dd48f48079 100644
--- a/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/saltwaterintrusion/main.cc
+++ b/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/saltwaterintrusion/main.cc
@@ -84,23 +84,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -123,7 +123,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = ILU0BiCGSTABBackend;
diff --git a/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/saltwaterintrusion/problem.hh b/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/saltwaterintrusion/problem.hh
index 2e96781678b74b8817bc526edc413c4315b84840..1f6e4eec60c917c846d3c2108949a45e268f4b6f 100644
--- a/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/saltwaterintrusion/problem.hh
+++ b/test/porousmediumflow/1pnc/implicit/1p2c/isothermal/saltwaterintrusion/problem.hh
@@ -63,9 +63,9 @@ struct FluidSystem<TypeTag, TTag::SaltWaterIntrusionTest>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::SaltWaterIntrusionTest>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePNCTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePNCTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // Use mass fractions to set salinity conveniently
@@ -97,7 +97,7 @@ class SaltWaterIntrusionTestProblem : public PorousMediumFlowProblem<TypeTag>
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
     // copy pressure index for convenience
     enum { pressureIdx = Indices::pressureIdx };
@@ -106,8 +106,8 @@ class SaltWaterIntrusionTestProblem : public PorousMediumFlowProblem<TypeTag>
     static_assert(!getPropValue<TypeTag, Properties::UseMoles>(), "This test uses mass fractions!");
 
 public:
-    SaltWaterIntrusionTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    SaltWaterIntrusionTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         //initialize fluid system
         FluidSystem::init();
diff --git a/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/conduction/main.cc b/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/conduction/main.cc
index fd9ad1d16d042ecd2d45381fbc9c414b0558c57b..50835dea1b56d386c196143d3e05d8830d001b71 100644
--- a/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/conduction/main.cc
+++ b/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/conduction/main.cc
@@ -84,23 +84,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -126,7 +126,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     //  using LinearSolver = UMFPackBackend;
diff --git a/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/conduction/problem.hh b/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/conduction/problem.hh
index 627739a67f7234cf0d36d29b134f8b9adc4dc848..460e7b8ebf5de4f7a4bf75fe904c0618dec97e5d 100644
--- a/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/conduction/problem.hh
+++ b/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/conduction/problem.hh
@@ -83,9 +83,9 @@ struct FluidSystem<TypeTag, TTag::OnePTwoCNIConduction>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePTwoCNIConduction>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePNCTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePNCTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // Define whether mole(true) or mass (false) fractions are used
@@ -128,7 +128,7 @@ class OnePTwoCNIConductionProblem : public PorousMediumFlowProblem<TypeTag>
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using Element = typename GridView::template Codim<0>::Entity;
     using ThermalConductivityModel = GetPropType<TypeTag, Properties::ThermalConductivityModel>;
@@ -152,8 +152,8 @@ class OnePTwoCNIConductionProblem : public PorousMediumFlowProblem<TypeTag>
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    OnePTwoCNIConductionProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), temperatureHigh_(300.0)
+    OnePTwoCNIConductionProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), temperatureHigh_(300.0)
     {
         //initialize fluid system
         FluidSystem::init();
@@ -164,7 +164,7 @@ public:
         else
             std::cout<<"problem uses mass fractions"<<std::endl;
 
-        temperatureExact_.resize(fvGridGeometry->numDofs(), 290.0);
+        temperatureExact_.resize(gridGeometry->numDofs(), 290.0);
     }
 
     //! Get the analytical temperature
diff --git a/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/convection/main.cc b/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/convection/main.cc
index c7deaed5a0d7cfbbcf9b31b205cf61ff650e4276..203a5a63fc09ea65b85d8041f53ff7f32a04fe1d 100644
--- a/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/convection/main.cc
+++ b/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/convection/main.cc
@@ -84,23 +84,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -126,7 +126,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     //  using LinearSolver = UMFPackBackend;
diff --git a/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/convection/problem.hh b/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/convection/problem.hh
index 8002ec769d6aefcc70007d52dcd62596fd014071..726c81f49665d08159f80226a30745178b492974 100644
--- a/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/convection/problem.hh
+++ b/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/convection/problem.hh
@@ -84,9 +84,9 @@ struct FluidSystem<TypeTag, TTag::OnePTwoCNIConvection>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePTwoCNIConvection>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePNCTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePNCTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // Define whether mole(true) or mass (false) fractions are used
@@ -130,7 +130,7 @@ class OnePTwoCNIConvectionProblem : public PorousMediumFlowProblem<TypeTag>
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
 
@@ -167,8 +167,8 @@ class OnePTwoCNIConvectionProblem : public PorousMediumFlowProblem<TypeTag>
     using GlobalPosition = typename SubControlVolumeFace::GlobalPosition;
 
 public:
-    OnePTwoCNIConvectionProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePTwoCNIConvectionProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         //initialize fluid system
         FluidSystem::init();
@@ -179,7 +179,7 @@ public:
         else
             std::cout<<"problem uses mass fractions"<<std::endl;
 
-        temperatureExact_.resize(fvGridGeometry->numDofs(), 290.0);
+        temperatureExact_.resize(gridGeometry->numDofs(), 290.0);
 
         darcyVelocity_ = getParam<Scalar>("Problem.DarcyVelocity");
 
diff --git a/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/transientbc/main.cc b/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/transientbc/main.cc
index f9564773e87a906b8c5bc4d8b0da7280a32ca7a1..2f9d5764717e9dd13932f480c45ab8520511ecad 100644
--- a/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/transientbc/main.cc
+++ b/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/transientbc/main.cc
@@ -84,23 +84,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -125,7 +125,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = ILU0BiCGSTABBackend;
diff --git a/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/transientbc/problem.hh b/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/transientbc/problem.hh
index 2be743d10a53318cfaa44e3cc100ee4885892df8..4a9113505dde3ae70c0c580adf9087d2435adb80 100644
--- a/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/transientbc/problem.hh
+++ b/test/porousmediumflow/1pnc/implicit/1p2c/nonisothermal/transientbc/problem.hh
@@ -83,9 +83,9 @@ struct FluidSystem<TypeTag, TTag::OnePTwoCNITransientBC>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePTwoCNITransientBC>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePNCTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePNCTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // Define whether mole(true) or mass (false) fractions are used
@@ -141,7 +141,7 @@ class OnePTwoCNITransientBCProblem : public PorousMediumFlowProblem<TypeTag>
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
@@ -174,8 +174,8 @@ class OnePTwoCNITransientBCProblem : public PorousMediumFlowProblem<TypeTag>
     using GlobalPosition = typename SubControlVolumeFace::GlobalPosition;
 
 public:
-    OnePTwoCNITransientBCProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePTwoCNITransientBCProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         //initialize fluid system
         FluidSystem::init();
diff --git a/test/porousmediumflow/1pnc/implicit/1p2c/spatialparams.hh b/test/porousmediumflow/1pnc/implicit/1p2c/spatialparams.hh
index b397abab17eea73afef5a9a546e878997e0afd09..a4d16e26d08150f6c1f1a7147fa3daf325d5e474 100644
--- a/test/porousmediumflow/1pnc/implicit/1p2c/spatialparams.hh
+++ b/test/porousmediumflow/1pnc/implicit/1p2c/spatialparams.hh
@@ -34,17 +34,17 @@ namespace Dumux {
  * \ingroup OnePNCTests
  * \brief Definition of the spatial parameters for the 1pnc test problems.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class OnePNCTestSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             OnePNCTestSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             OnePNCTestSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                           OnePNCTestSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar,
+                                           OnePNCTestSpatialParams<GridGeometry, Scalar>>;
 
     static const int dimWorld = GridView::dimensionworld;
     using GlobalPosition = typename Dune::FieldVector<Scalar, dimWorld>;
@@ -53,8 +53,8 @@ public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    OnePNCTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePNCTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         permeability_ = 1e-10;
         porosity_ = 0.4;
diff --git a/test/porousmediumflow/1pnc/implicit/1p3c/main.cc b/test/porousmediumflow/1pnc/implicit/1p3c/main.cc
index 5d5c2cf24abd2f843e01340472e7d5c4dc14bbe1..d39483e874960d2f8e5e7794cb8fa22e34fc8f58 100644
--- a/test/porousmediumflow/1pnc/implicit/1p3c/main.cc
+++ b/test/porousmediumflow/1pnc/implicit/1p3c/main.cc
@@ -85,23 +85,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -124,7 +124,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop);
 
     // the linear solver
     using LinearSolver = ILU0BiCGSTABBackend;
diff --git a/test/porousmediumflow/1pnc/implicit/1p3c/problem.hh b/test/porousmediumflow/1pnc/implicit/1p3c/problem.hh
index 7bcc590505a796492d763ff8718d04d75f249c6f..3b236cdc66202d0114962181ce41498d4add35e5 100644
--- a/test/porousmediumflow/1pnc/implicit/1p3c/problem.hh
+++ b/test/porousmediumflow/1pnc/implicit/1p3c/problem.hh
@@ -209,9 +209,9 @@ struct FluidSystem<TypeTag, TTag::MaxwellStefanOnePThreeCTest>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::MaxwellStefanOnePThreeCTest>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePNCTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePNCTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // Define whether mole(true) or mass (false) fractions are used
@@ -248,19 +248,19 @@ class MaxwellStefanOnePThreeCTestProblem : public PorousMediumFlowProblem<TypeTa
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     using VolumeVariables = GetPropType<TypeTag, Properties::VolumeVariables>;
 
     //! property that defines whether mole or mass fractions are used
     static constexpr bool useMoles = getPropValue<TypeTag, Properties::UseMoles>();
 
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    MaxwellStefanOnePThreeCTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    MaxwellStefanOnePThreeCTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         name_ = getParam<std::string>("Problem.Name");
 
diff --git a/test/porousmediumflow/1pnc/implicit/nonequilibrium/main.cc b/test/porousmediumflow/1pnc/implicit/nonequilibrium/main.cc
index 0b75cd7a96469267a61b929024a3ac63b795ba38..d1d06385722e5f86fc3d3be79849df2a32184929 100644
--- a/test/porousmediumflow/1pnc/implicit/nonequilibrium/main.cc
+++ b/test/porousmediumflow/1pnc/implicit/nonequilibrium/main.cc
@@ -84,23 +84,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
     problem->setGridVariables(gridVariables);
 
@@ -124,7 +124,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     //  using LinearSolver = UMFPackBackend;
diff --git a/test/porousmediumflow/1pnc/implicit/nonequilibrium/problem.hh b/test/porousmediumflow/1pnc/implicit/nonequilibrium/problem.hh
index ebc2a80e2fa90ee7e6c280a0f3365dc4b892b82d..c89e04bbfd980d6205c1970dd0f85c2a84544941 100644
--- a/test/porousmediumflow/1pnc/implicit/nonequilibrium/problem.hh
+++ b/test/porousmediumflow/1pnc/implicit/nonequilibrium/problem.hh
@@ -76,9 +76,9 @@ struct FluidSystem<TypeTag, TTag::OnePTwoCThermalNonequilibrium>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::OnePTwoCThermalNonequilibrium>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = OnePNCNonequilibriumTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = OnePNCNonequilibriumTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // Define whether mole(true) or mass (false) fractions are used
@@ -114,7 +114,7 @@ class OnePTwoCThermalNonequilibriumProblem : public PorousMediumFlowProblem<Type
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
 
@@ -152,8 +152,8 @@ class OnePTwoCThermalNonequilibriumProblem : public PorousMediumFlowProblem<Type
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    OnePTwoCThermalNonequilibriumProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePTwoCThermalNonequilibriumProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         //initialize fluid system
         FluidSystem::init();
diff --git a/test/porousmediumflow/1pnc/implicit/nonequilibrium/spatialparams.hh b/test/porousmediumflow/1pnc/implicit/nonequilibrium/spatialparams.hh
index 98ba14f99238820c68ef098ca63273786c7d3bb5..2835d16ed6a5facbd05a98ec4d0b5c4dba142339 100644
--- a/test/porousmediumflow/1pnc/implicit/nonequilibrium/spatialparams.hh
+++ b/test/porousmediumflow/1pnc/implicit/nonequilibrium/spatialparams.hh
@@ -36,17 +36,17 @@ namespace Dumux {
  * \ingroup OnePNCTests
  * \brief Definition of the spatial parameters for the 1pnc test problems.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class OnePNCNonequilibriumTestSpatialParams
-: public FVNonEquilibriumSpatialParams<FVGridGeometry, Scalar,
-                                       OnePNCNonequilibriumTestSpatialParams<FVGridGeometry, Scalar>>
+: public FVNonEquilibriumSpatialParams<GridGeometry, Scalar,
+                                       OnePNCNonequilibriumTestSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVNonEquilibriumSpatialParams<FVGridGeometry, Scalar,
-                                           OnePNCNonequilibriumTestSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVNonEquilibriumSpatialParams<GridGeometry, Scalar,
+                                           OnePNCNonequilibriumTestSpatialParams<GridGeometry, Scalar>>;
 
     static const int dimWorld = GridView::dimensionworld;
     using GlobalPosition = typename Dune::FieldVector<Scalar, dimWorld>;
@@ -56,8 +56,8 @@ public:
     using PermeabilityType = Scalar;
     using FluidSolidInterfacialAreaFormulation = FluidSolidInterfacialAreaShiWang<Scalar>;
 
-    OnePNCNonequilibriumTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    OnePNCNonequilibriumTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         permeability_ = 1e-11;
         porosity_ = 0.4;
diff --git a/test/porousmediumflow/1pncmin/implicit/nonisothermal/main.cc b/test/porousmediumflow/1pncmin/implicit/nonisothermal/main.cc
index 324908de81a0c2a4583c44b87fb9f604d9c03eff..07157a6e5f00fd66ee729dba9bd6ed626f7edd2c 100644
--- a/test/porousmediumflow/1pncmin/implicit/nonisothermal/main.cc
+++ b/test/porousmediumflow/1pncmin/implicit/nonisothermal/main.cc
@@ -110,23 +110,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -155,7 +155,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = ILU0BiCGSTABBackend;
diff --git a/test/porousmediumflow/1pncmin/implicit/nonisothermal/problem.hh b/test/porousmediumflow/1pncmin/implicit/nonisothermal/problem.hh
index 67d8627fea18d259ed94063cceda41646d6adfe5..54255c0aee0fdb8fc5c415b5bdadeb511538cb5d 100644
--- a/test/porousmediumflow/1pncmin/implicit/nonisothermal/problem.hh
+++ b/test/porousmediumflow/1pncmin/implicit/nonisothermal/problem.hh
@@ -90,9 +90,9 @@ struct SolidSystem<TypeTag, TTag::ThermoChem>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::ThermoChem>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = ThermoChemSpatialParams<FVGridGeometry, Scalar>;
+    using type = ThermoChemSpatialParams<GridGeometry, Scalar>;
 };
 
 // Define whether mole(true) or mass (false) fractions are used
@@ -134,7 +134,7 @@ class ThermoChemProblem : public PorousMediumFlowProblem<TypeTag>
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     using ReactionRate = ThermoChemReaction;
@@ -164,8 +164,8 @@ class ThermoChemProblem : public PorousMediumFlowProblem<TypeTag>
     using GlobalPosition = typename SubControlVolumeFace::GlobalPosition;
 
 public:
-    ThermoChemProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-        : ParentType(fvGridGeometry)
+    ThermoChemProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+        : ParentType(gridGeometry)
     {
         name_      = getParam<std::string>("Problem.Name");
         FluidSystem::init(/*tempMin=*/473.15,
@@ -181,9 +181,9 @@ public:
         boundaryTemperature_ = getParam<Scalar>("Problem.BoundaryTemperature");
 
         unsigned int codim = GetPropType<TypeTag, Properties::GridGeometry>::discMethod == DiscretizationMethod::box ? dim : 0;
-        permeability_.resize(fvGridGeometry->gridView().size(codim));
-        porosity_.resize(fvGridGeometry->gridView().size(codim));
-        reactionRate_.resize(fvGridGeometry->gridView().size(codim));
+        permeability_.resize(gridGeometry->gridView().size(codim));
+        porosity_.resize(gridGeometry->gridView().size(codim));
+        reactionRate_.resize(gridGeometry->gridView().size(codim));
     }
 
     /*!
diff --git a/test/porousmediumflow/1pncmin/implicit/nonisothermal/spatialparams.hh b/test/porousmediumflow/1pncmin/implicit/nonisothermal/spatialparams.hh
index 662fb4fe6d79e289952c305c504322f8a23f7c0e..2bd4d6ece0b83d81e98160e37d0648be2d7f1fc6 100644
--- a/test/porousmediumflow/1pncmin/implicit/nonisothermal/spatialparams.hh
+++ b/test/porousmediumflow/1pncmin/implicit/nonisothermal/spatialparams.hh
@@ -35,17 +35,17 @@ namespace Dumux {
  * \brief Definition of the spatial parameters for the thermochemistry
  *        problem which uses the non-insothermal 1pncmin model.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class ThermoChemSpatialParams
-: public FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                             ThermoChemSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParamsOneP<GridGeometry, Scalar,
+                             ThermoChemSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParamsOneP<FVGridGeometry, Scalar,
-                                           ThermoChemSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParamsOneP<GridGeometry, Scalar,
+                                           ThermoChemSpatialParams<GridGeometry, Scalar>>;
 
     enum { dimWorld=GridView::dimensionworld };
 
@@ -55,8 +55,8 @@ public:
     // type used for the permeability (i.e. tensor or scalar)
     using PermeabilityType = Scalar;
 
-    ThermoChemSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    ThermoChemSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {}
 
     /*!
diff --git a/test/porousmediumflow/2p/implicit/adaptive/main.cc b/test/porousmediumflow/2p/implicit/adaptive/main.cc
index dabb29b258ea3b797409c3b6791531641d135bd4..43b0ccba983c05b720d3bd4819793b86dc433d98 100644
--- a/test/porousmediumflow/2p/implicit/adaptive/main.cc
+++ b/test/porousmediumflow/2p/implicit/adaptive/main.cc
@@ -123,35 +123,35 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
     problem->computePointSourceMap(); // enable point sources
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // instantiate indicator & data transfer, read parameters for indicator
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     const Scalar refineTol = getParam<Scalar>("Adaptive.RefineTolerance");
     const Scalar coarsenTol = getParam<Scalar>("Adaptive.CoarsenTolerance");
-    TwoPGridAdaptIndicator<TypeTag> indicator(fvGridGeometry);
-    TwoPGridDataTransfer<TypeTag> dataTransfer(problem, fvGridGeometry, gridVariables, x);
+    TwoPGridAdaptIndicator<TypeTag> indicator(gridGeometry);
+    TwoPGridDataTransfer<TypeTag> dataTransfer(problem, gridGeometry, gridVariables, x);
 
     // Do initial refinement around sources/BCs
-    GridAdaptInitializationIndicator<TypeTag> initIndicator(problem, fvGridGeometry, gridVariables);
+    GridAdaptInitializationIndicator<TypeTag> initIndicator(problem, gridGeometry, gridVariables);
 
     // refine up to the maximum level
     const auto maxLevel = getParam<std::size_t>("Adaptive.MaxLevel", 0);
@@ -207,11 +207,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/2p/implicit/adaptive/problem.hh b/test/porousmediumflow/2p/implicit/adaptive/problem.hh
index 3de0f798f2e980ff690e2a6f47bf87d00ba04d14..ad937e92d4ce548bc591ac64ec800abd2a5566fb 100644
--- a/test/porousmediumflow/2p/implicit/adaptive/problem.hh
+++ b/test/porousmediumflow/2p/implicit/adaptive/problem.hh
@@ -46,13 +46,13 @@ class TwoPTestProblemAdaptive : public TwoPTestProblem<TypeTag>
     using Vertex = typename GridView::template Codim<GridView::dimensionworld>::Entity;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
-    static constexpr bool isBox = FVGridGeometry::discMethod == DiscretizationMethod::box;
+    static constexpr bool isBox = GridGeometry::discMethod == DiscretizationMethod::box;
 
 public:
-    TwoPTestProblemAdaptive(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    TwoPTestProblemAdaptive(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         if(!isBox)
             initialValues_ = readFileToContainer<std::vector<PrimaryVariables>>("initialsolutioncc.txt");
diff --git a/test/porousmediumflow/2p/implicit/boxdfm/main.cc b/test/porousmediumflow/2p/implicit/boxdfm/main.cc
index 32090672e92cc90f7f365faffac903898f2c18be..7ba60bfd884218e7801a0777cd6fec14296e9a3d 100644
--- a/test/porousmediumflow/2p/implicit/boxdfm/main.cc
+++ b/test/porousmediumflow/2p/implicit/boxdfm/main.cc
@@ -117,17 +117,17 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.template grid<0>().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update(fractureGridAdapter);
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update(fractureGridAdapter);
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
@@ -136,7 +136,7 @@ int main(int argc, char** argv) try
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -158,7 +158,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = ILU0BiCGSTABBackend;
diff --git a/test/porousmediumflow/2p/implicit/boxdfm/problem.hh b/test/porousmediumflow/2p/implicit/boxdfm/problem.hh
index 7e7d92ff11c93f2407f4e3ca41a46b74db4a8d9e..e2d04c208d3b39f222ab228ad6f1d90c28928632 100644
--- a/test/porousmediumflow/2p/implicit/boxdfm/problem.hh
+++ b/test/porousmediumflow/2p/implicit/boxdfm/problem.hh
@@ -125,8 +125,8 @@ class TwoPTestProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using SubControlVolume = typename FVGridGeometry::SubControlVolume;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using SubControlVolume = typename GridGeometry::SubControlVolume;
 
     // some indices for convenience
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
@@ -144,8 +144,8 @@ class TwoPTestProblem : public PorousMediumFlowProblem<TypeTag>
     static constexpr int dimWorld = GridView::dimensionworld;
 
 public:
-    TwoPTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    TwoPTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {}
 
     /*!
diff --git a/test/porousmediumflow/2p/implicit/boxdfm/spatialparams.hh b/test/porousmediumflow/2p/implicit/boxdfm/spatialparams.hh
index 68e4011439413810c026f53a0deab9d26acf5c8a..21e983c73eff2099e69bdaf6dabfcde6513045b7 100644
--- a/test/porousmediumflow/2p/implicit/boxdfm/spatialparams.hh
+++ b/test/porousmediumflow/2p/implicit/boxdfm/spatialparams.hh
@@ -39,17 +39,17 @@ namespace Dumux {
  * \ingroup TwoPTests
  * \brief The spatial params for the incompressible 2p test.
  */
-template<class FVGridGeometry, class Scalar>
-class TwoPTestSpatialParams : public FVSpatialParams< FVGridGeometry, Scalar, TwoPTestSpatialParams<FVGridGeometry, Scalar> >
+template<class GridGeometry, class Scalar>
+class TwoPTestSpatialParams : public FVSpatialParams< GridGeometry, Scalar, TwoPTestSpatialParams<GridGeometry, Scalar> >
 {
-    using ThisType = TwoPTestSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, ThisType>;
+    using ThisType = TwoPTestSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, ThisType>;
 
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
 
     static constexpr int dimWorld = GridView::dimensionworld;
@@ -59,7 +59,7 @@ public:
     using MaterialLawParams = typename MaterialLaw::Params;
     using PermeabilityType = Scalar;
 
-    TwoPTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry) : ParentType(fvGridGeometry)
+    TwoPTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry) : ParentType(gridGeometry)
     {
         // residual saturations
         matrixMaterialParams_.setSwr(0.18);
diff --git a/test/porousmediumflow/2p/implicit/cornerpoint/main.cc b/test/porousmediumflow/2p/implicit/cornerpoint/main.cc
index 1b55d6dd8a0626781f50c8aa729ba42862dfc104..fc6fe48521ad1c65ef75b960525e2b28c7434b2a 100644
--- a/test/porousmediumflow/2p/implicit/cornerpoint/main.cc
+++ b/test/porousmediumflow/2p/implicit/cornerpoint/main.cc
@@ -118,24 +118,24 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto spatialParams = std::make_shared<typename Problem::SpatialParams>(fvGridGeometry, gridManager.getDeck());
-    auto problem = std::make_shared<Problem>(fvGridGeometry, spatialParams);
+    auto spatialParams = std::make_shared<typename Problem::SpatialParams>(gridGeometry, gridManager.getDeck());
+    auto problem = std::make_shared<Problem>(gridGeometry, spatialParams);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -160,11 +160,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/2p/implicit/cornerpoint/problem.hh b/test/porousmediumflow/2p/implicit/cornerpoint/problem.hh
index 2f31bd79a3a9abc4539981c1887c6115cbf6f37e..586810ce737ec5aabc72de99fc93daa2f9b8ae18 100644
--- a/test/porousmediumflow/2p/implicit/cornerpoint/problem.hh
+++ b/test/porousmediumflow/2p/implicit/cornerpoint/problem.hh
@@ -77,10 +77,10 @@ template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::TwoPCornerPoint>
 {
 private:
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 public:
-    using type = TwoPCornerPointTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = TwoPCornerPointTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // Enable caching
@@ -104,10 +104,10 @@ class TwoPCornerPointTestProblem : public PorousMediumFlowProblem<TypeTag>
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using GridView = typename FVGridGeometry::GridView;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
@@ -117,9 +117,9 @@ class TwoPCornerPointTestProblem : public PorousMediumFlowProblem<TypeTag>
     enum { dimWorld = GridView::dimensionworld };
 
 public:
-    TwoPCornerPointTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    TwoPCornerPointTestProblem(std::shared_ptr<const GridGeometry> gridGeometry,
                                std::shared_ptr<typename ParentType::SpatialParams> spatialParams)
-    : ParentType(fvGridGeometry, spatialParams)
+    : ParentType(gridGeometry, spatialParams)
     {
         gravity_ = {0, 0, 9.81};
         injectionElement_ = getParam<int>("Problem.InjectionElement");
diff --git a/test/porousmediumflow/2p/implicit/cornerpoint/spatialparams.hh b/test/porousmediumflow/2p/implicit/cornerpoint/spatialparams.hh
index 81ef9bfcd09f92fbd77522090d2bf4f88ea7853b..e01602f20605655964480082f2feb4b8a9d835f1 100644
--- a/test/porousmediumflow/2p/implicit/cornerpoint/spatialparams.hh
+++ b/test/porousmediumflow/2p/implicit/cornerpoint/spatialparams.hh
@@ -37,16 +37,16 @@ namespace Dumux {
  * \ingroup TwoPTests
  * \brief The spatial params for the incompressible 2p test.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class TwoPCornerPointTestSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar, TwoPCornerPointTestSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar, TwoPCornerPointTestSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
-    using ThisType = TwoPCornerPointTestSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, ThisType>;
+    using ThisType = TwoPCornerPointTestSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, ThisType>;
 
     static constexpr int dimWorld = GridView::dimensionworld;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
@@ -60,9 +60,9 @@ public:
     using MaterialLawParams = typename MaterialLaw::Params;
     using PermeabilityType = DimWorldMatrix;
 
-    TwoPCornerPointTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    TwoPCornerPointTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry,
                                      std::shared_ptr<const Opm::Deck> deck)
-    : ParentType(fvGridGeometry)
+    : ParentType(gridGeometry)
     , deck_(deck)
     {
         homogeneous_ = getParam<bool>("Problem.Homogeneous");
diff --git a/test/porousmediumflow/2p/implicit/fracture/main.cc b/test/porousmediumflow/2p/implicit/fracture/main.cc
index 6ed7851dc15bd9776ce262d2e6e59b973c3b1c8d..9953b25784d13b09e6de16ec40bb62903f82efae 100644
--- a/test/porousmediumflow/2p/implicit/fracture/main.cc
+++ b/test/porousmediumflow/2p/implicit/fracture/main.cc
@@ -93,23 +93,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -133,11 +133,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/2p/implicit/fracture/problem.hh b/test/porousmediumflow/2p/implicit/fracture/problem.hh
index 0d725b27c51f8a689518defdc48763697aed2fc7..99dd4c67225d6b285adf7b12bc21da344cc7a470 100644
--- a/test/porousmediumflow/2p/implicit/fracture/problem.hh
+++ b/test/porousmediumflow/2p/implicit/fracture/problem.hh
@@ -82,9 +82,9 @@ struct FluidSystem<TypeTag, TTag::Fracture>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::Fracture>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = FractureSpatialParams<FVGridGeometry, Scalar>;
+    using type = FractureSpatialParams<GridGeometry, Scalar>;
 };
 
 // Use global caching
@@ -111,7 +111,7 @@ class FractureProblem : public PorousMediumFlowProblem<TypeTag>
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
@@ -133,8 +133,8 @@ class FractureProblem : public PorousMediumFlowProblem<TypeTag>
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    FractureProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry) {}
+    FractureProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry) {}
 
     /*!
      * \name Problem parameters
diff --git a/test/porousmediumflow/2p/implicit/fracture/spatialparams.hh b/test/porousmediumflow/2p/implicit/fracture/spatialparams.hh
index 24a019cdeb3296e04bafea426a77d9dbdf25c7d7..d9d13cedc8f5687e2623570b38c4d24eaf2403f2 100644
--- a/test/porousmediumflow/2p/implicit/fracture/spatialparams.hh
+++ b/test/porousmediumflow/2p/implicit/fracture/spatialparams.hh
@@ -40,17 +40,17 @@ namespace Dumux {
  * \brief The spatial parameters for the LensProblem which uses the
  *        two-phase fully implicit model.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class FractureSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         FractureSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         FractureSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       FractureSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       FractureSpatialParams<GridGeometry, Scalar>>;
 
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -63,8 +63,8 @@ public:
     using MaterialLaw = EffToAbsLaw<EffectiveLaw>;
     using MaterialLawParams = typename MaterialLaw::Params;
 
-    FractureSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    FractureSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         // residual saturations
         materialParams_.setSwr(0.05);
diff --git a/test/porousmediumflow/2p/implicit/incompressible/main.cc b/test/porousmediumflow/2p/implicit/incompressible/main.cc
index d493c01fb6ef36d5fadf897abb0ad8c9d094c3de..676ac8e40e558f71b06f8ede10540557ec167ab2 100644
--- a/test/porousmediumflow/2p/implicit/incompressible/main.cc
+++ b/test/porousmediumflow/2p/implicit/incompressible/main.cc
@@ -113,13 +113,13 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // get some time loop parameters
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
@@ -132,7 +132,7 @@ int main(int argc, char** argv) try
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     if (restartTime > 0)
     {
         using IOFields = GetPropType<TypeTag, Properties::IOFields>;
@@ -140,7 +140,7 @@ int main(int argc, char** argv) try
         using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
         using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
         const auto fileName = getParam<std::string>("Restart.File");
-        loadSolution(x, fileName, createPVNameFunction<IOFields, PrimaryVariables, ModelTraits, FluidSystem>(), *fvGridGeometry);
+        loadSolution(x, fileName, createPVNameFunction<IOFields, PrimaryVariables, ModelTraits, FluidSystem>(), *gridGeometry);
     }
     else
         problem->applyInitialSolution(x);
@@ -152,7 +152,7 @@ int main(int argc, char** argv) try
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -173,11 +173,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/2p/implicit/incompressible/problem.hh b/test/porousmediumflow/2p/implicit/incompressible/problem.hh
index fafda26c0f45dfb98978b96bc04b41fd468d881c..1b64ca9dc52b66babbf8225fbc3775c7fb2d6d83 100644
--- a/test/porousmediumflow/2p/implicit/incompressible/problem.hh
+++ b/test/porousmediumflow/2p/implicit/incompressible/problem.hh
@@ -84,10 +84,10 @@ template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::TwoPIncompressible>
 {
 private:
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 public:
-    using type = TwoPTestSpatialParams<FVGridGeometry, Scalar>;
+    using type = TwoPTestSpatialParams<GridGeometry, Scalar>;
 };
 
 // Enable caching
@@ -116,7 +116,7 @@ class TwoPTestProblem : public PorousMediumFlowProblem<TypeTag>
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
@@ -130,8 +130,8 @@ class TwoPTestProblem : public PorousMediumFlowProblem<TypeTag>
     };
 
 public:
-    TwoPTestProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry) {}
+    TwoPTestProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry) {}
 
     /*!
      * \brief Specifies which kind of boundary condition should be
diff --git a/test/porousmediumflow/2p/implicit/incompressible/spatialparams.hh b/test/porousmediumflow/2p/implicit/incompressible/spatialparams.hh
index 5a7558ba780af768647203a317eb4393ca098efd..d0912b6feefaf7f947921f4d4fc0888acdbfefde 100644
--- a/test/porousmediumflow/2p/implicit/incompressible/spatialparams.hh
+++ b/test/porousmediumflow/2p/implicit/incompressible/spatialparams.hh
@@ -36,16 +36,16 @@ namespace Dumux {
  * \ingroup TwoPTests
  * \brief The spatial params for the incompressible 2p test.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class TwoPTestSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar, TwoPTestSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar, TwoPTestSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
+    using GridView = typename GridGeometry::GridView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
-    using ThisType = TwoPTestSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, ThisType>;
+    using ThisType = TwoPTestSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, ThisType>;
 
     static constexpr int dimWorld = GridView::dimensionworld;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
@@ -57,8 +57,8 @@ public:
     using MaterialLawParams = typename MaterialLaw::Params;
     using PermeabilityType = Scalar;
 
-    TwoPTestSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    TwoPTestSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         lensIsOilWet_ = getParam<bool>("SpatialParams.LensIsOilWet", false);
 
@@ -150,7 +150,7 @@ public:
     template<class SolutionVector>
     void updateMaterialInterfaceParams(const SolutionVector& x)
     {
-        if (FVGridGeometry::discMethod == DiscretizationMethod::box)
+        if (GridGeometry::discMethod == DiscretizationMethod::box)
             materialInterfaceParams_.update(this->gridGeometry(), *this, x);
     }
 
diff --git a/test/porousmediumflow/2p/implicit/nonisothermal/main.cc b/test/porousmediumflow/2p/implicit/nonisothermal/main.cc
index bcb1684233c7240a64c9d901f9287ed71e387ce8..27c2bbb504965102dd22ced515e7b6694f3102ec 100644
--- a/test/porousmediumflow/2p/implicit/nonisothermal/main.cc
+++ b/test/porousmediumflow/2p/implicit/nonisothermal/main.cc
@@ -104,23 +104,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -143,7 +143,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::ILU0BiCGSTABBackend;
@@ -154,8 +154,8 @@ int main(int argc, char** argv) try
     NewtonSolver nonLinearSolver(assembler, linearSolver);
 
     //the convergence writer
-    using NewtonConvergenceWriter = Dumux::NewtonConvergenceWriter<FVGridGeometry, SolutionVector>;
-    auto convergenceWriter = std::make_shared<NewtonConvergenceWriter>(*fvGridGeometry);
+    using NewtonConvergenceWriter = Dumux::NewtonConvergenceWriter<GridGeometry, SolutionVector>;
+    auto convergenceWriter = std::make_shared<NewtonConvergenceWriter>(*gridGeometry);
     nonLinearSolver.attachConvergenceWriter(convergenceWriter);
 
     // time loop
diff --git a/test/porousmediumflow/2p/implicit/nonisothermal/problem.hh b/test/porousmediumflow/2p/implicit/nonisothermal/problem.hh
index 97554608aa266a3c9f382ba49b295bda7d4c793d..bbd97e0d70baac48fc25012eaba16e4b48d23d14 100644
--- a/test/porousmediumflow/2p/implicit/nonisothermal/problem.hh
+++ b/test/porousmediumflow/2p/implicit/nonisothermal/problem.hh
@@ -82,9 +82,9 @@ struct FluidSystem<TypeTag, TTag::Injection2PNITypeTag> { using type = FluidSyst
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::Injection2PNITypeTag>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = InjectionSpatialParams<FVGridGeometry, Scalar>;
+    using type = InjectionSpatialParams<GridGeometry, Scalar>;
 };
 
 } // namespace Properties
@@ -151,15 +151,15 @@ class InjectionProblem2PNI : public PorousMediumFlowProblem<TypeTag>
 
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
 
 public:
-    InjectionProblem2PNI(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    InjectionProblem2PNI(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         maxDepth_ = 2700.0; // [m]
 
diff --git a/test/porousmediumflow/2p1c/implicit/main.cc b/test/porousmediumflow/2p1c/implicit/main.cc
index d5516a4fdf6dd23ab424f4d5ec083c56606b1154..beb0ebb083499daf805d49e0acc0ad827b7f8cf3 100644
--- a/test/porousmediumflow/2p1c/implicit/main.cc
+++ b/test/porousmediumflow/2p1c/implicit/main.cc
@@ -84,23 +84,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -121,7 +121,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = ILU0BiCGSTABBackend;
diff --git a/test/porousmediumflow/2p1c/implicit/problem.hh b/test/porousmediumflow/2p1c/implicit/problem.hh
index 2708c8fa5d57f1bc7239ace97761c2a2a317f6b8..e779b9732c2800bbc18733ec54753f69d989bae6 100644
--- a/test/porousmediumflow/2p1c/implicit/problem.hh
+++ b/test/porousmediumflow/2p1c/implicit/problem.hh
@@ -74,9 +74,9 @@ public:
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::InjectionProblem>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = InjectionProblemSpatialParams<FVGridGeometry, Scalar>;
+    using type = InjectionProblemSpatialParams<GridGeometry, Scalar>;
 };
 
 //Define whether spurious cold-water flow into the steam is blocked
@@ -111,7 +111,7 @@ class InjectionProblem : public PorousMediumFlowProblem<TypeTag>
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
     // copy some indices for convenience
     enum {
@@ -129,8 +129,8 @@ class InjectionProblem : public PorousMediumFlowProblem<TypeTag>
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    InjectionProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    InjectionProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     { FluidSystem::init(); }
 
     /*!
diff --git a/test/porousmediumflow/2p1c/implicit/spatialparams.hh b/test/porousmediumflow/2p1c/implicit/spatialparams.hh
index 53e900fc79d437a4b703b4544e7030c9f51c56a7..b298ab78a125aa8f96c0aa55a1611abfd46ef559 100644
--- a/test/porousmediumflow/2p1c/implicit/spatialparams.hh
+++ b/test/porousmediumflow/2p1c/implicit/spatialparams.hh
@@ -35,17 +35,17 @@ namespace Dumux {
  * \ingroup TwoPOneCTests
  * \brief Definition of the spatial parameters for various steam injection problems.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class InjectionProblemSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         InjectionProblemSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         InjectionProblemSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       InjectionProblemSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       InjectionProblemSpatialParams<GridGeometry, Scalar>>;
 
     static constexpr int dimWorld = GridView::dimensionworld;
 
@@ -60,8 +60,8 @@ public:
     using MaterialLawParams = typename MaterialLaw::Params;
     using PermeabilityType = DimWorldMatrix;
 
-    InjectionProblemSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    InjectionProblemSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         gasWetting_ = getParam<bool>("SpatialParams.GasWetting", false);
 
diff --git a/test/porousmediumflow/2p2c/implicit/chemicalnonequilibrium/main.cc b/test/porousmediumflow/2p2c/implicit/chemicalnonequilibrium/main.cc
index 161016f4bbc61956473fd6e3d6d65029958a0f41..4b9a47339ac5b1999729a2515c593af4eb526825 100644
--- a/test/porousmediumflow/2p2c/implicit/chemicalnonequilibrium/main.cc
+++ b/test/porousmediumflow/2p2c/implicit/chemicalnonequilibrium/main.cc
@@ -105,23 +105,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
     problem->setGridVariables(gridVariables);
 
@@ -148,11 +148,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NonEquilibriumNewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/2p2c/implicit/chemicalnonequilibrium/problem.hh b/test/porousmediumflow/2p2c/implicit/chemicalnonequilibrium/problem.hh
index a2767464f2e253e4cc906af0dfe5d7cfbf4988bb..0994bf5b9eb244194240541020223262d07068ca 100644
--- a/test/porousmediumflow/2p2c/implicit/chemicalnonequilibrium/problem.hh
+++ b/test/porousmediumflow/2p2c/implicit/chemicalnonequilibrium/problem.hh
@@ -82,9 +82,9 @@ public:
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::TwoPTwoCChemicalNonequilibrium>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = TwoPTwoCChemicalNonequilibriumSpatialParams<FVGridGeometry, Scalar>;
+    using type = TwoPTwoCChemicalNonequilibriumSpatialParams<GridGeometry, Scalar>;
 };
 
 // decide which type to use for floating values (double / quad)
@@ -138,7 +138,7 @@ class TwoPTwoCChemicalNonequilibriumProblem : public PorousMediumFlowProblem<Typ
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     using VolumeVariables = GetPropType<TypeTag, Properties::VolumeVariables>;
 
@@ -147,11 +147,11 @@ class TwoPTwoCChemicalNonequilibriumProblem : public PorousMediumFlowProblem<Typ
 
     static constexpr int dim = GridView::dimension;
     static constexpr int dimWorld = GridView::dimensionworld;
-    static constexpr bool isBox = FVGridGeometry::discMethod == DiscretizationMethod::box;
+    static constexpr bool isBox = GridGeometry::discMethod == DiscretizationMethod::box;
     enum { dofCodim = isBox ? dim : 0 };
 public:
-    TwoPTwoCChemicalNonequilibriumProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    TwoPTwoCChemicalNonequilibriumProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         temperature_ = 273.15 + 25; // -> 25°C
 
diff --git a/test/porousmediumflow/2p2c/implicit/chemicalnonequilibrium/spatialparams.hh b/test/porousmediumflow/2p2c/implicit/chemicalnonequilibrium/spatialparams.hh
index d77fb8e87dea38afb1946281a88c00f2bc087a77..a8fb9a3f61d9780fb29d751e33520a633994ce1f 100644
--- a/test/porousmediumflow/2p2c/implicit/chemicalnonequilibrium/spatialparams.hh
+++ b/test/porousmediumflow/2p2c/implicit/chemicalnonequilibrium/spatialparams.hh
@@ -44,18 +44,18 @@ namespace Dumux {
  * \ingroup TwoPTwoCTests
  * \brief The spatial parameters for the 2p2c chemical nonequilibrium problem.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class TwoPTwoCChemicalNonequilibriumSpatialParams
-: public FVNonEquilibriumSpatialParams<FVGridGeometry, Scalar,
-                                       TwoPTwoCChemicalNonequilibriumSpatialParams<FVGridGeometry, Scalar>>
+: public FVNonEquilibriumSpatialParams<GridGeometry, Scalar,
+                                       TwoPTwoCChemicalNonequilibriumSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
 
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVNonEquilibriumSpatialParams<FVGridGeometry, Scalar,
-                                                     TwoPTwoCChemicalNonequilibriumSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVNonEquilibriumSpatialParams<GridGeometry, Scalar,
+                                                     TwoPTwoCChemicalNonequilibriumSpatialParams<GridGeometry, Scalar>>;
 
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -73,8 +73,8 @@ public:
     using AwnSurface = EffToAbsLawIA<EffectiveIALawAwn, MaterialLawParams>;
     using AwnSurfaceParams = typename AwnSurface::Params;
 
-    TwoPTwoCChemicalNonequilibriumSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    TwoPTwoCChemicalNonequilibriumSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         // intrinsic permeabilities
         coarseK_ = 1e-11;
diff --git a/test/porousmediumflow/2p2c/implicit/injection/main.cc b/test/porousmediumflow/2p2c/implicit/injection/main.cc
index 61861d1c67b52e55b4fee6b86c87ccc17c4bd5ef..94f5f62a1bc481a97322719646e44a503beb76d9 100644
--- a/test/porousmediumflow/2p2c/implicit/injection/main.cc
+++ b/test/porousmediumflow/2p2c/implicit/injection/main.cc
@@ -80,13 +80,13 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // get some time loop parameters
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
@@ -99,7 +99,7 @@ int main(int argc, char** argv) try
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     if (restartTime > 0)
     {
         using IOFields = GetPropType<TypeTag, Properties::IOFields>;
@@ -108,7 +108,7 @@ int main(int argc, char** argv) try
         using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
         const auto fileName = getParam<std::string>("Restart.File");
         const auto pvName = createPVNameFunction<IOFields, PrimaryVariables, ModelTraits, FluidSystem>();
-        loadSolution(x, fileName, pvName, *fvGridGeometry);
+        loadSolution(x, fileName, pvName, *gridGeometry);
     }
     else
         problem->applyInitialSolution(x);
@@ -116,7 +116,7 @@ int main(int argc, char** argv) try
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -133,11 +133,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/2p2c/implicit/injection/problem.hh b/test/porousmediumflow/2p2c/implicit/injection/problem.hh
index 19e1b09295ba6607a3130e73386d34f5f22cf575..5f2db9277054608f104870c1183d11c95bd37fda 100644
--- a/test/porousmediumflow/2p2c/implicit/injection/problem.hh
+++ b/test/porousmediumflow/2p2c/implicit/injection/problem.hh
@@ -76,9 +76,9 @@ struct FluidSystem<TypeTag, TTag::Injection>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::Injection>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = InjectionSpatialParams<FVGridGeometry, Scalar>;
+    using type = InjectionSpatialParams<GridGeometry, Scalar>;
 };
 
 // Define whether mole(true) or mass (false) fractions are used
@@ -143,7 +143,7 @@ class InjectionProblem : public PorousMediumFlowProblem<TypeTag>
 {
     using ParentType = PorousMediumFlowProblem<TypeTag>;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
 
@@ -190,8 +190,8 @@ class InjectionProblem : public PorousMediumFlowProblem<TypeTag>
     static constexpr bool useMoles = ModelTraits::useMoles();
 
 public:
-    InjectionProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    InjectionProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         nTemperature_       = getParam<int>("Problem.NTemperature");
         nPressure_          = getParam<int>("Problem.NPressure");
diff --git a/test/porousmediumflow/2p2c/implicit/injection/spatialparams.hh b/test/porousmediumflow/2p2c/implicit/injection/spatialparams.hh
index d1e4cbe35f02b7d52718464a4573d7a3c55a1500..d23d12282e1e3e3e4892014ff082da307f2a5822 100644
--- a/test/porousmediumflow/2p2c/implicit/injection/spatialparams.hh
+++ b/test/porousmediumflow/2p2c/implicit/injection/spatialparams.hh
@@ -38,16 +38,16 @@ namespace Dumux {
  * \brief Definition of the spatial parameters for the injection problem
  *        which uses the isothermal two-phase two-component fully implicit model.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class InjectionSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         InjectionSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         InjectionSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, InjectionSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, InjectionSpatialParams<GridGeometry, Scalar>>;
 
     static constexpr int dimWorld = GridView::dimensionworld;
 
@@ -62,8 +62,8 @@ public:
     using MaterialLaw = EffToAbsLaw<EffectiveLaw>;
     using MaterialLawParams = typename MaterialLaw::Params;
 
-    InjectionSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    InjectionSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         layerBottom_ = 22.5;
 
diff --git a/test/porousmediumflow/2p2c/implicit/mpnccomparison/main.cc b/test/porousmediumflow/2p2c/implicit/mpnccomparison/main.cc
index 3500d484b1a07749b21359f7135a38ad4f7ef7f2..bafd1a872cfafebdf226803c0bc396416417c29c 100644
--- a/test/porousmediumflow/2p2c/implicit/mpnccomparison/main.cc
+++ b/test/porousmediumflow/2p2c/implicit/mpnccomparison/main.cc
@@ -105,23 +105,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -144,11 +144,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/2p2c/implicit/mpnccomparison/problem.hh b/test/porousmediumflow/2p2c/implicit/mpnccomparison/problem.hh
index 8b2d14ae5c28171dd128b8baec0caa3c9ecf7ab7..2d9cc9fec12d1b5f7381e1dbf2a593364073d29a 100644
--- a/test/porousmediumflow/2p2c/implicit/mpnccomparison/problem.hh
+++ b/test/porousmediumflow/2p2c/implicit/mpnccomparison/problem.hh
@@ -76,9 +76,9 @@ struct FluidSystem<TypeTag, TTag::TwoPTwoCComparison>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::TwoPTwoCComparison>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = TwoPTwoCComparisonSpatialParams<FVGridGeometry, Scalar>;
+    using type = TwoPTwoCComparisonSpatialParams<GridGeometry, Scalar>;
 };
 
 // decide which type to use for floating values (double / quad)
@@ -118,14 +118,14 @@ class TwoPTwoCComparisonProblem : public PorousMediumFlowProblem<TypeTag>
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
     using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
     using Indices = typename ModelTraits::Indices;
 
 public:
-    TwoPTwoCComparisonProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-        : ParentType(fvGridGeometry)
+    TwoPTwoCComparisonProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+        : ParentType(gridGeometry)
     {
         temperature_ = 273.15 + 25; // -> 25°C
 
diff --git a/test/porousmediumflow/2p2c/implicit/mpnccomparison/spatialparams.hh b/test/porousmediumflow/2p2c/implicit/mpnccomparison/spatialparams.hh
index 4214c894ee0a94dc7b30fc3e1136c16527492841..d984c54cb98e7ee6de914dc9aa97cafc21fd9f60 100644
--- a/test/porousmediumflow/2p2c/implicit/mpnccomparison/spatialparams.hh
+++ b/test/porousmediumflow/2p2c/implicit/mpnccomparison/spatialparams.hh
@@ -38,18 +38,18 @@ namespace Dumux {
  * \ingroup TwoPTwoCTests
  * \brief The spatial parameters for the 2p2c mpnc comparison problem.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class TwoPTwoCComparisonSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         TwoPTwoCComparisonSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         TwoPTwoCComparisonSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
 
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       TwoPTwoCComparisonSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       TwoPTwoCComparisonSpatialParams<GridGeometry, Scalar>>;
 
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -65,7 +65,7 @@ public:
     using MaterialLawParams = typename MaterialLaw::Params;
 
 
-    TwoPTwoCComparisonSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry) : ParentType(fvGridGeometry)
+    TwoPTwoCComparisonSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry) : ParentType(gridGeometry)
     {
         // intrinsic permeabilities
         coarseK_ = 1e-12;
diff --git a/test/porousmediumflow/2p2c/implicit/waterair/main.cc b/test/porousmediumflow/2p2c/implicit/waterair/main.cc
index a8a818205e6fdcc32654f6f57cb60923ee1666a4..c3d685aac63a31dca42477602a10e7f991014038 100644
--- a/test/porousmediumflow/2p2c/implicit/waterair/main.cc
+++ b/test/porousmediumflow/2p2c/implicit/waterair/main.cc
@@ -80,13 +80,13 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // get some time loop parameters
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
@@ -99,7 +99,7 @@ int main(int argc, char** argv) try
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     if (restartTime > 0)
     {
         using IOFields = GetPropType<TypeTag, Properties::IOFields>;
@@ -108,7 +108,7 @@ int main(int argc, char** argv) try
         using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
         const auto fileName = getParam<std::string>("Restart.File");
         const auto pvName = createPVNameFunction<IOFields, PrimaryVariables, ModelTraits, FluidSystem>();
-        loadSolution(x, fileName, pvName, *fvGridGeometry);
+        loadSolution(x, fileName, pvName, *gridGeometry);
     }
     else
         problem->applyInitialSolution(x);
@@ -116,7 +116,7 @@ int main(int argc, char** argv) try
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -133,11 +133,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/2p2c/implicit/waterair/problem.hh b/test/porousmediumflow/2p2c/implicit/waterair/problem.hh
index a95f2fde0165f090208a1572a2b9e4788eae91fc..9a7cd74fea5effde7e6864368178a3369451c866 100644
--- a/test/porousmediumflow/2p2c/implicit/waterair/problem.hh
+++ b/test/porousmediumflow/2p2c/implicit/waterair/problem.hh
@@ -68,9 +68,9 @@ struct FluidSystem<TypeTag, TTag::WaterAir> { using type = FluidSystems::H2ON2<G
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::WaterAir>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = WaterAirSpatialParams<FVGridGeometry, Scalar>;
+    using type = WaterAirSpatialParams<GridGeometry, Scalar>;
 };
 
 // Define whether mole(true) or mass (false) fractions are used
@@ -150,7 +150,7 @@ class WaterAirProblem : public PorousMediumFlowProblem<TypeTag>
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
 
@@ -158,8 +158,8 @@ class WaterAirProblem : public PorousMediumFlowProblem<TypeTag>
     static constexpr bool useMoles = ModelTraits::useMoles();
 
 public:
-    WaterAirProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    WaterAirProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         maxDepth_ = 1000.0; // [m]
 
diff --git a/test/porousmediumflow/2p2c/implicit/waterair/spatialparams.hh b/test/porousmediumflow/2p2c/implicit/waterair/spatialparams.hh
index 17d7efd06d89c05502872d3a164f64d87dd5bd2c..ed0bbe01f9e520357c809616f2ac81eb05cd91eb 100644
--- a/test/porousmediumflow/2p2c/implicit/waterair/spatialparams.hh
+++ b/test/porousmediumflow/2p2c/implicit/waterair/spatialparams.hh
@@ -39,17 +39,17 @@ namespace Dumux {
  * \ingroup TwoPTwoCModel
  * \brief Definition of the spatial parameters for the water-air problem.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class WaterAirSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         WaterAirSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         WaterAirSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       WaterAirSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       WaterAirSpatialParams<GridGeometry, Scalar>>;
 
     static constexpr int dimWorld = GridView::dimensionworld;
 
@@ -64,7 +64,7 @@ public:
     using MaterialLaw = EffToAbsLaw<EffectiveLaw>;
     using MaterialLawParams = typename MaterialLaw::Params;
 
-    WaterAirSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry) : ParentType(fvGridGeometry)
+    WaterAirSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry) : ParentType(gridGeometry)
     {
         layerBottom_ = 22.0;
 
diff --git a/test/porousmediumflow/2pnc/implicit/diffusion/main.cc b/test/porousmediumflow/2pnc/implicit/diffusion/main.cc
index ebb030d8ae5b66146854814fa0c1a16521a4efd9..7e980f260bd876b23911f1d3d1f0d2a0c40448f9 100644
--- a/test/porousmediumflow/2pnc/implicit/diffusion/main.cc
+++ b/test/porousmediumflow/2pnc/implicit/diffusion/main.cc
@@ -102,23 +102,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -141,11 +141,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver =  std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver =  std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/2pnc/implicit/diffusion/problem.hh b/test/porousmediumflow/2pnc/implicit/diffusion/problem.hh
index 2c8a3cae7a030d1c05200952092145a877f98f81..91dbd1d19977f747823ce6d8ca99bde45d28ea78 100644
--- a/test/porousmediumflow/2pnc/implicit/diffusion/problem.hh
+++ b/test/porousmediumflow/2pnc/implicit/diffusion/problem.hh
@@ -71,9 +71,9 @@ struct FluidSystem<TypeTag, TTag::TwoPNCDiffusion>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::TwoPNCDiffusion>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = TwoPNCDiffusionSpatialParams<FVGridGeometry, Scalar>;
+    using type = TwoPNCDiffusionSpatialParams<GridGeometry, Scalar>;
 };
 
 // Define whether mole(true) or mass (false) fractions are used
@@ -116,14 +116,14 @@ class TwoPNCDiffusionProblem : public PorousMediumFlowProblem<TypeTag>
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
     //! Property that defines whether mole or mass fractions are used
     static constexpr bool useMoles = getPropValue<TypeTag, Properties::UseMoles>();
 
 public:
-    TwoPNCDiffusionProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    TwoPNCDiffusionProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         // initialize the tables of the fluid system
         FluidSystem::init();
diff --git a/test/porousmediumflow/2pnc/implicit/diffusion/spatialparams.hh b/test/porousmediumflow/2pnc/implicit/diffusion/spatialparams.hh
index b8ecf3fc8064335eb8d6ffabed99151c14d551da..dcbcfce6cf24771446ac4fcd4cead35bba358a57 100644
--- a/test/porousmediumflow/2pnc/implicit/diffusion/spatialparams.hh
+++ b/test/porousmediumflow/2pnc/implicit/diffusion/spatialparams.hh
@@ -39,14 +39,14 @@ namespace Dumux {
  * \brief Definition of the spatial parameters for the TwoPNCDiffusion
  *        problem which uses the isothermal 2p2c box model.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class TwoPNCDiffusionSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         TwoPNCDiffusionSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         TwoPNCDiffusionSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       TwoPNCDiffusionSpatialParams<FVGridGeometry, Scalar>>;
+    using GridView = typename GridGeometry::GridView;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       TwoPNCDiffusionSpatialParams<GridGeometry, Scalar>>;
 
     static constexpr int dimWorld = GridView::dimensionworld;
 
@@ -63,8 +63,8 @@ public:
     using MaterialLaw = EffToAbsLaw<EffectiveLaw>;
     using MaterialLawParams = typename MaterialLaw::Params;
 
-    TwoPNCDiffusionSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), K_(0)
+    TwoPNCDiffusionSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), K_(0)
     {
         // intrinsic permeabilities
         K_[0][0] = 5e-11;
diff --git a/test/porousmediumflow/2pnc/implicit/fuelcell/main.cc b/test/porousmediumflow/2pnc/implicit/fuelcell/main.cc
index 795b08881b9841a196399bb20c329c6ea1ad0ae4..9aad61b7fb885d320a87f572f7549dd26ad79e8c 100644
--- a/test/porousmediumflow/2pnc/implicit/fuelcell/main.cc
+++ b/test/porousmediumflow/2pnc/implicit/fuelcell/main.cc
@@ -102,23 +102,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -142,11 +142,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/2pnc/implicit/fuelcell/problem.hh b/test/porousmediumflow/2pnc/implicit/fuelcell/problem.hh
index 6ef872e50c712630329869b72186e91d2df8a13f..5d8843c106101fc92e25bd023126f6d5c5a2e7b4 100644
--- a/test/porousmediumflow/2pnc/implicit/fuelcell/problem.hh
+++ b/test/porousmediumflow/2pnc/implicit/fuelcell/problem.hh
@@ -74,9 +74,9 @@ struct Problem<TypeTag, TTag::FuelCell> { using type = FuelCellProblem<TypeTag>;
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::FuelCell>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = FuelCellSpatialParams<FVGridGeometry, Scalar>;
+    using type = FuelCellSpatialParams<GridGeometry, Scalar>;
 };
 
 // Set the primary variable combination for the 2pnc model
@@ -118,24 +118,24 @@ class FuelCellProblem : public PorousMediumFlowProblem<TypeTag>
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     using VolumeVariables = GetPropType<TypeTag, Properties::VolumeVariables>;
     // Select the electrochemistry method
 #ifdef NONISOTHERMAL
-    using ElectroChemistry = typename Dumux::ElectroChemistryNI<Scalar, Indices, FluidSystem, FVGridGeometry, ElectroChemistryModel::Ochs>;
+    using ElectroChemistry = typename Dumux::ElectroChemistryNI<Scalar, Indices, FluidSystem, GridGeometry, ElectroChemistryModel::Ochs>;
 #else
-    using ElectroChemistry = typename Dumux::ElectroChemistry<Scalar, Indices, FluidSystem, FVGridGeometry, ElectroChemistryModel::Ochs>;
+    using ElectroChemistry = typename Dumux::ElectroChemistry<Scalar, Indices, FluidSystem, GridGeometry, ElectroChemistryModel::Ochs>;
 #endif
     static constexpr int dim = GridView::dimension;
     static constexpr int dimWorld = GridView::dimensionworld;
-    static constexpr bool isBox = FVGridGeometry::discMethod == DiscretizationMethod::box;
+    static constexpr bool isBox = GridGeometry::discMethod == DiscretizationMethod::box;
     using GlobalPosition = typename SubControlVolume::GlobalPosition;
 
     enum { dofCodim = isBox ? dim : 0 };
 public:
-    FuelCellProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    FuelCellProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         nTemperature_       = getParam<int>("Problem.NTemperature");
         nPressure_          = getParam<int>("Problem.NPressure");
diff --git a/test/porousmediumflow/2pnc/implicit/fuelcell/spatialparams.hh b/test/porousmediumflow/2pnc/implicit/fuelcell/spatialparams.hh
index d2c7714d821843c8b6012bfa553d2514524ec442..668a1cde91ea892f1f5df2a0ac7f47a4538fe9a5 100644
--- a/test/porousmediumflow/2pnc/implicit/fuelcell/spatialparams.hh
+++ b/test/porousmediumflow/2pnc/implicit/fuelcell/spatialparams.hh
@@ -39,18 +39,18 @@ namespace Dumux {
  * \brief Definition of the spatial parameters for the FuelCell
  *        problem which uses the isothermal 2p2c box model.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class FuelCellSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         FuelCellSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         FuelCellSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       FuelCellSpatialParams<FVGridGeometry, Scalar>>;
+    using GridView = typename GridGeometry::GridView;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       FuelCellSpatialParams<GridGeometry, Scalar>>;
 
     static constexpr int dimWorld = GridView::dimensionworld;
 
-    using Element = typename FVGridGeometry::GridView::template Codim<0>::Entity;
+    using Element = typename GridGeometry::GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
     using DimWorldMatrix = Dune::FieldMatrix<Scalar, dimWorld, dimWorld>;
@@ -62,8 +62,8 @@ public:
     using MaterialLawParams = typename MaterialLaw::Params;
     using PermeabilityType = DimWorldMatrix;
 
-    FuelCellSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), K_(0)
+    FuelCellSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), K_(0)
     {
         // intrinsic permeabilities
         K_[0][0] = 5e-11;
diff --git a/test/porousmediumflow/2pncmin/implicit/isothermal/main.cc b/test/porousmediumflow/2pncmin/implicit/isothermal/main.cc
index e4a26d328b570cbb0425f02ba54e76b6cc0c22ce..3e0868b32061f153b8a5b56e42ccd02693cecb1c 100644
--- a/test/porousmediumflow/2pncmin/implicit/isothermal/main.cc
+++ b/test/porousmediumflow/2pncmin/implicit/isothermal/main.cc
@@ -103,13 +103,13 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // get some time loop parameters
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
@@ -122,7 +122,7 @@ int main(int argc, char** argv) try
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     if (restartTime > 0)
     {
         using IOFields = GetPropType<TypeTag, Properties::IOFields>;
@@ -132,7 +132,7 @@ int main(int argc, char** argv) try
         using SolidSystem = GetPropType<TypeTag, Properties::SolidSystem>;
         const auto fileName = getParam<std::string>("Restart.File");
         const auto pvName = createPVNameFunction<IOFields, PrimaryVariables, ModelTraits, FluidSystem, SolidSystem>();
-        loadSolution(x, fileName, pvName, *fvGridGeometry);
+        loadSolution(x, fileName, pvName, *gridGeometry);
     }
     else
         problem->applyInitialSolution(x);
@@ -140,7 +140,7 @@ int main(int argc, char** argv) try
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // initialize the vtk output module
@@ -161,11 +161,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/2pncmin/implicit/isothermal/problem.hh b/test/porousmediumflow/2pncmin/implicit/isothermal/problem.hh
index dcac0dd49177720e017fee07efcb900816c551cf..c69c5ca7f1914b066b0c39ceb41e6856d4d570bb 100644
--- a/test/porousmediumflow/2pncmin/implicit/isothermal/problem.hh
+++ b/test/porousmediumflow/2pncmin/implicit/isothermal/problem.hh
@@ -86,9 +86,9 @@ struct SolidSystem<TypeTag, TTag::Dissolution>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::Dissolution>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = DissolutionSpatialParams<FVGridGeometry, Scalar>;
+    using type = DissolutionSpatialParams<GridGeometry, Scalar>;
 };
 
 // Set properties here to override the default property settings
@@ -178,15 +178,15 @@ class DissolutionProblem : public PorousMediumFlowProblem<TypeTag>
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using GlobalPosition = typename SubControlVolume::GlobalPosition;
 
 public:
-    DissolutionProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    DissolutionProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         outerSalinity_          = getParam<Scalar>("Problem.OuterSalinity");
         temperature_            = getParam<Scalar>("Problem.Temperature");
@@ -210,7 +210,7 @@ public:
         name_                   = getParam<std::string>("Problem.Name");
 
         unsigned int codim = GetPropType<TypeTag, Properties::GridGeometry>::discMethod == DiscretizationMethod::box ? dim : 0;
-        permeability_.resize(fvGridGeometry->gridView().size(codim));
+        permeability_.resize(gridGeometry->gridView().size(codim));
 
         FluidSystem::init(/*Tmin=*/temperatureLow_,
                           /*Tmax=*/temperatureHigh_,
diff --git a/test/porousmediumflow/2pncmin/implicit/isothermal/spatialparams.hh b/test/porousmediumflow/2pncmin/implicit/isothermal/spatialparams.hh
index 1b0806f3c7f5a3440ca7236bca61b4c04d20894d..bcdb15a870c63a5ec9de6ff55b0733d063eac1b2 100644
--- a/test/porousmediumflow/2pncmin/implicit/isothermal/spatialparams.hh
+++ b/test/porousmediumflow/2pncmin/implicit/isothermal/spatialparams.hh
@@ -40,18 +40,18 @@ namespace Dumux {
  * \brief Spatial parameters for the dissolution problem
  * where water is injected in a for flushing precipitated salt clogging a gas reservoir.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class DissolutionSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         DissolutionSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         DissolutionSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
 
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       DissolutionSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       DissolutionSpatialParams<GridGeometry, Scalar>>;
 
     using EffectiveLaw = RegularizedBrooksCorey<Scalar>;
 
@@ -64,8 +64,8 @@ public:
     using MaterialLaw = EffToAbsLaw<EffectiveLaw>;
     using MaterialLawParams = typename MaterialLaw::Params;
 
-    DissolutionSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    DissolutionSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         solubilityLimit_       = getParam<Scalar>("SpatialParams.SolubilityLimit", 0.26);
         referencePorosity_     = getParam<Scalar>("SpatialParams.referencePorosity", 0.11);
diff --git a/test/porousmediumflow/3p/implicit/conduction/main.cc b/test/porousmediumflow/3p/implicit/conduction/main.cc
index 49cef2fc618a5555d27febb396adafd45cb26c82..43232452cc57d036250b61f272a61dc227ecc16c 100644
--- a/test/porousmediumflow/3p/implicit/conduction/main.cc
+++ b/test/porousmediumflow/3p/implicit/conduction/main.cc
@@ -109,23 +109,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -151,11 +151,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/3p/implicit/conduction/problem.hh b/test/porousmediumflow/3p/implicit/conduction/problem.hh
index 7ec8bbbfeae6a9158155f21110b66ac4f6ff0597..162ed18bc5da669d752760508d86ab291d73d965 100644
--- a/test/porousmediumflow/3p/implicit/conduction/problem.hh
+++ b/test/porousmediumflow/3p/implicit/conduction/problem.hh
@@ -73,9 +73,9 @@ struct FluidSystem<TypeTag, TTag::ThreePNIConduction>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::ThreePNIConduction>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = ThreePNISpatialParams<FVGridGeometry, Scalar>;
+    using type = ThreePNISpatialParams<GridGeometry, Scalar>;
 };
 }// end namespace Properties
 
@@ -112,7 +112,7 @@ class ThreePNIConductionProblem : public PorousMediumFlowProblem<TypeTag>
 
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
@@ -139,15 +139,15 @@ class ThreePNIConductionProblem : public PorousMediumFlowProblem<TypeTag>
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    ThreePNIConductionProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    ThreePNIConductionProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         //initialize fluid system
         FluidSystem::init();
 
         name_ = getParam<std::string>("Problem.Name");
         temperatureHigh_ = 300.0;
-        temperatureExact_.resize(fvGridGeometry->numDofs());
+        temperatureExact_.resize(gridGeometry->numDofs());
    }
 
     //! Get the analytical temperature
diff --git a/test/porousmediumflow/3p/implicit/conduction/spatialparams.hh b/test/porousmediumflow/3p/implicit/conduction/spatialparams.hh
index 20462a83392446304d32520067ae38ede21d077b..6fa0971a8e5c32d2586b8c42dba346db593ae88d 100644
--- a/test/porousmediumflow/3p/implicit/conduction/spatialparams.hh
+++ b/test/porousmediumflow/3p/implicit/conduction/spatialparams.hh
@@ -37,17 +37,17 @@ namespace Dumux {
  * \ingroup ThreePTests
  * \brief Definition of the spatial parameters for the 3pni problems.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class ThreePNISpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         ThreePNISpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         ThreePNISpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       ThreePNISpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       ThreePNISpatialParams<GridGeometry, Scalar>>;
 
     using EffectiveLaw = RegularizedParkerVanGen3P<Scalar>;
 
@@ -60,8 +60,8 @@ public:
     using MaterialLaw = EffToAbsLaw<EffectiveLaw>;
     using MaterialLawParams = typename MaterialLaw::Params;
 
-    ThreePNISpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    ThreePNISpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         permeability_ = 1e-10;
         porosity_ = 0.4;
diff --git a/test/porousmediumflow/3p/implicit/convection/main.cc b/test/porousmediumflow/3p/implicit/convection/main.cc
index 3b4ce393db1bb42a651db44709d1c89013650de4..9262a76fea1ead23cc5ee7e32eb87ea0c1b13e08 100644
--- a/test/porousmediumflow/3p/implicit/convection/main.cc
+++ b/test/porousmediumflow/3p/implicit/convection/main.cc
@@ -109,23 +109,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -151,11 +151,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/3p/implicit/convection/problem.hh b/test/porousmediumflow/3p/implicit/convection/problem.hh
index bcdff72d3f2c1d73b18cc101117d393d91fe7a77..ac7f00a36ecbadc86b466e953a48228ab62ef0ef 100644
--- a/test/porousmediumflow/3p/implicit/convection/problem.hh
+++ b/test/porousmediumflow/3p/implicit/convection/problem.hh
@@ -75,9 +75,9 @@ struct FluidSystem<TypeTag, TTag::ThreePNIConvection>
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::ThreePNIConvection>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = ThreePNISpatialParams<FVGridGeometry, Scalar>;
+    using type = ThreePNISpatialParams<GridGeometry, Scalar>;
 };
 } // end namespace Properties
 
@@ -115,7 +115,7 @@ class ThreePNIConvectionProblem : public PorousMediumFlowProblem<TypeTag>
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
@@ -149,8 +149,8 @@ class ThreePNIConvectionProblem : public PorousMediumFlowProblem<TypeTag>
     using GlobalPosition = typename SubControlVolumeFace::GlobalPosition;
 
 public:
-    ThreePNIConvectionProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    ThreePNIConvectionProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         //initialize fluid system
         FluidSystem::init();
diff --git a/test/porousmediumflow/3p/implicit/infiltration/main.cc b/test/porousmediumflow/3p/implicit/infiltration/main.cc
index 7226c3ae8f140670f848fa9bfdd9f6bae66bc815..9aed50b55f44de19f2263f2718176b23c3c17dc4 100644
--- a/test/porousmediumflow/3p/implicit/infiltration/main.cc
+++ b/test/porousmediumflow/3p/implicit/infiltration/main.cc
@@ -109,23 +109,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -148,11 +148,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/3p/implicit/infiltration/problem.hh b/test/porousmediumflow/3p/implicit/infiltration/problem.hh
index 699f999ceffd534017b2b161f7bc08277344c9fa..8c936d70a313789971ce29d8d5b85c44a203fcb4 100644
--- a/test/porousmediumflow/3p/implicit/infiltration/problem.hh
+++ b/test/porousmediumflow/3p/implicit/infiltration/problem.hh
@@ -83,9 +83,9 @@ public:
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::InfiltrationThreeP>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = InfiltrationThreePSpatialParams<FVGridGeometry, Scalar>;
+    using type = InfiltrationThreePSpatialParams<GridGeometry, Scalar>;
 };
 
 }// end namespace Properties
@@ -141,14 +141,14 @@ class InfiltrationThreePProblem : public PorousMediumFlowProblem<TypeTag>
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    InfiltrationThreePProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    InfiltrationThreePProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         temperature_ = 273.15 + 10.0; // -> 10 degrees Celsius
         FluidSystem::init(282.15, 284.15, 3, 8e4, 3e5, 200);
diff --git a/test/porousmediumflow/3p/implicit/infiltration/spatialparams.hh b/test/porousmediumflow/3p/implicit/infiltration/spatialparams.hh
index 8b499b675c640795867393660cbbb57d7ec1a4e8..6fe052f3188aa81072e2fb3889d9218e2e86c4b4 100644
--- a/test/porousmediumflow/3p/implicit/infiltration/spatialparams.hh
+++ b/test/porousmediumflow/3p/implicit/infiltration/spatialparams.hh
@@ -39,17 +39,17 @@ namespace Dumux {
  * \ingroup ThreePTests
  * \brief Definition of the spatial parameters for the infiltration problem
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class InfiltrationThreePSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         InfiltrationThreePSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         InfiltrationThreePSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       InfiltrationThreePSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       InfiltrationThreePSpatialParams<GridGeometry, Scalar>>;
 
     using GlobalPosition = typename SubControlVolume::GlobalPosition;
 
@@ -63,8 +63,8 @@ public:
     using MaterialLaw = EffToAbsLaw<EffectiveLaw>;
     using MaterialLawParams = typename MaterialLaw::Params;
 
-    InfiltrationThreePSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    InfiltrationThreePSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         // intrinsic permeabilities
         fineK_ = getParam<Scalar>("SpatialParams.permeability");
diff --git a/test/porousmediumflow/3p3c/implicit/columnxylol/main.cc b/test/porousmediumflow/3p3c/implicit/columnxylol/main.cc
index 32d93ba26f490a6a2be517da9704bfdf26630b11..ea6edcb4048817bcdf3cca61d92331be18a6e5b3 100644
--- a/test/porousmediumflow/3p3c/implicit/columnxylol/main.cc
+++ b/test/porousmediumflow/3p3c/implicit/columnxylol/main.cc
@@ -107,23 +107,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -147,11 +147,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/3p3c/implicit/columnxylol/problem.hh b/test/porousmediumflow/3p3c/implicit/columnxylol/problem.hh
index 8cea3a60ca5add650f68b36a74f4e9943c60574c..4b372c502e1ea7668d89a2dd8c95a351b0cc7c2d 100644
--- a/test/porousmediumflow/3p3c/implicit/columnxylol/problem.hh
+++ b/test/porousmediumflow/3p3c/implicit/columnxylol/problem.hh
@@ -95,9 +95,9 @@ public:
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::Column>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = ColumnSpatialParams<FVGridGeometry, Scalar>;
+    using type = ColumnSpatialParams<GridGeometry, Scalar>;
 };
 } // end namespace Properties
 
@@ -161,13 +161,13 @@ class ColumnProblem : public PorousMediumFlowProblem<TypeTag>
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
 
 public:
-    ColumnProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    ColumnProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         FluidSystem::init();
         name_ = getParam<std::string>("Problem.Name");
diff --git a/test/porousmediumflow/3p3c/implicit/columnxylol/spatialparams.hh b/test/porousmediumflow/3p3c/implicit/columnxylol/spatialparams.hh
index cb2b187527d6601f4b9ac16a7dc68738e54fa432..4de10b8032374a6a9a8eb9bb503cc8e6ea368f1c 100644
--- a/test/porousmediumflow/3p3c/implicit/columnxylol/spatialparams.hh
+++ b/test/porousmediumflow/3p3c/implicit/columnxylol/spatialparams.hh
@@ -36,18 +36,18 @@ namespace Dumux {
  * \ingroup ThreePThreeCModel
  * \brief Definition of the spatial parameters for the column problem.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class ColumnSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         ColumnSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         ColumnSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
 
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       ColumnSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       ColumnSpatialParams<GridGeometry, Scalar>>;
 
     using GlobalPosition = typename SubControlVolume::GlobalPosition;
     using EffectiveLaw = RegularizedParkerVanGen3P<Scalar>;
@@ -57,8 +57,8 @@ public:
     using MaterialLawParams = typename MaterialLaw::Params;
     using PermeabilityType = Scalar;
 
-    ColumnSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    ColumnSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         // intrinsic permeabilities
         fineK_ = 1.4e-11;
diff --git a/test/porousmediumflow/3p3c/implicit/infiltration/main.cc b/test/porousmediumflow/3p3c/implicit/infiltration/main.cc
index 32d93ba26f490a6a2be517da9704bfdf26630b11..ea6edcb4048817bcdf3cca61d92331be18a6e5b3 100644
--- a/test/porousmediumflow/3p3c/implicit/infiltration/main.cc
+++ b/test/porousmediumflow/3p3c/implicit/infiltration/main.cc
@@ -107,23 +107,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -147,11 +147,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/3p3c/implicit/infiltration/problem.hh b/test/porousmediumflow/3p3c/implicit/infiltration/problem.hh
index 35e4691d9420140c7e6645fb92c5d03084b5f49f..51908096983de1ea040681ad253883c1c9adc6ee 100644
--- a/test/porousmediumflow/3p3c/implicit/infiltration/problem.hh
+++ b/test/porousmediumflow/3p3c/implicit/infiltration/problem.hh
@@ -66,9 +66,9 @@ struct Problem<TypeTag, TTag::InfiltrationThreePThreeC> { using type = Infiltrat
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::InfiltrationThreePThreeC>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = InfiltrationThreePThreeCSpatialParams<FVGridGeometry, Scalar>;
+    using type = InfiltrationThreePThreeCSpatialParams<GridGeometry, Scalar>;
 };
 
 // Set the fluid system
@@ -138,14 +138,14 @@ class InfiltrationThreePThreeCProblem : public PorousMediumFlowProblem<TypeTag>
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
 
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    InfiltrationThreePThreeCProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    InfiltrationThreePThreeCProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         temperature_ = 273.15 + 10.0; // -> 10 degrees Celsius
         FluidSystem::init(/*tempMin=*/temperature_ - 1,
diff --git a/test/porousmediumflow/3p3c/implicit/infiltration/spatialparams.hh b/test/porousmediumflow/3p3c/implicit/infiltration/spatialparams.hh
index fbb20acdedd81b69e2c0aa1dc5b3a0594b0ac6e9..2b7f665c5568643d3210bd937cf9e654a533b4ec 100644
--- a/test/porousmediumflow/3p3c/implicit/infiltration/spatialparams.hh
+++ b/test/porousmediumflow/3p3c/implicit/infiltration/spatialparams.hh
@@ -39,17 +39,17 @@ namespace Dumux {
  * \ingroup ThreePThreeCTests
  * \brief Definition of the spatial parameters for the infiltration problem
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class InfiltrationThreePThreeCSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         InfiltrationThreePThreeCSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         InfiltrationThreePThreeCSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       InfiltrationThreePThreeCSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       InfiltrationThreePThreeCSpatialParams<GridGeometry, Scalar>>;
 
     using EffectiveLaw = RegularizedParkerVanGen3P<Scalar>;
 
@@ -60,8 +60,8 @@ public:
    using MaterialLawParams = typename MaterialLaw::Params;
    using PermeabilityType = Scalar;
 
-    InfiltrationThreePThreeCSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    InfiltrationThreePThreeCSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         // intrinsic permeabilities
         fineK_ = 1.e-11;
diff --git a/test/porousmediumflow/3p3c/implicit/kuevette/main.cc b/test/porousmediumflow/3p3c/implicit/kuevette/main.cc
index 32d93ba26f490a6a2be517da9704bfdf26630b11..ea6edcb4048817bcdf3cca61d92331be18a6e5b3 100644
--- a/test/porousmediumflow/3p3c/implicit/kuevette/main.cc
+++ b/test/porousmediumflow/3p3c/implicit/kuevette/main.cc
@@ -107,23 +107,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -147,11 +147,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/3p3c/implicit/kuevette/problem.hh b/test/porousmediumflow/3p3c/implicit/kuevette/problem.hh
index f73ab7dfa09b6b58cb5fe3c34822176e651b2072..dbda4c15f63ca740322cfdd72622f9936d3b4322 100644
--- a/test/porousmediumflow/3p3c/implicit/kuevette/problem.hh
+++ b/test/porousmediumflow/3p3c/implicit/kuevette/problem.hh
@@ -72,9 +72,9 @@ struct Problem<TypeTag, TTag::Kuevette> { using type = KuevetteProblem<TypeTag>;
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::Kuevette>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = KuevetteSpatialParams<FVGridGeometry, Scalar>;
+    using type = KuevetteSpatialParams<GridGeometry, Scalar>;
 };
 
 // Set the fluid system
@@ -145,7 +145,7 @@ class KuevetteProblem : public PorousMediumFlowProblem<TypeTag>
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
     using ElementVolumeVariables = typename GridVariables::GridVolumeVariables::LocalView;
@@ -155,8 +155,8 @@ class KuevetteProblem : public PorousMediumFlowProblem<TypeTag>
     using GlobalPosition = typename SubControlVolumeFace::GlobalPosition;
 
 public:
-    KuevetteProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    KuevetteProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         FluidSystem::init();
         name_ = getParam<std::string>("Problem.Name");
diff --git a/test/porousmediumflow/3p3c/implicit/kuevette/spatialparams.hh b/test/porousmediumflow/3p3c/implicit/kuevette/spatialparams.hh
index d901cb3c072aaf717ed3e1a3a55acb33cd910d99..4f9bb865bbc23b1732461d6c4018232c5203b937 100644
--- a/test/porousmediumflow/3p3c/implicit/kuevette/spatialparams.hh
+++ b/test/porousmediumflow/3p3c/implicit/kuevette/spatialparams.hh
@@ -39,18 +39,18 @@ namespace Dumux {
  * \ingroup ThreePThreeCTests
  * \brief Definition of the spatial parameters for the kuevette problem
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class KuevetteSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         KuevetteSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         KuevetteSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
 
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       KuevetteSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       KuevetteSpatialParams<GridGeometry, Scalar>>;
 
     using GlobalPosition = typename SubControlVolume::GlobalPosition;
 
@@ -61,8 +61,8 @@ public:
     using MaterialLawParams = typename MaterialLaw::Params;
     using PermeabilityType = Scalar;
 
-    KuevetteSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    KuevetteSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         // intrinsic permeabilities
         fineK_ = 6.28e-12;
diff --git a/test/porousmediumflow/3pwateroil/implicit/main.cc b/test/porousmediumflow/3pwateroil/implicit/main.cc
index 13fe934e550f8dc7b6508ef87e47cc48cb45c1f1..6733382473ed514e30937d261c314f0d6fb8b54b 100644
--- a/test/porousmediumflow/3pwateroil/implicit/main.cc
+++ b/test/porousmediumflow/3pwateroil/implicit/main.cc
@@ -107,23 +107,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -147,11 +147,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/3pwateroil/implicit/problem.hh b/test/porousmediumflow/3pwateroil/implicit/problem.hh
index 448a3d2ec013b263e50f182682d8f190c34ed001..2e7baddc8b47d0659cd607174cd21329d5f2b9ac 100644
--- a/test/porousmediumflow/3pwateroil/implicit/problem.hh
+++ b/test/porousmediumflow/3pwateroil/implicit/problem.hh
@@ -62,9 +62,9 @@ struct Problem<TypeTag, TTag::Sagd> { using type = Dumux::SagdProblem<TypeTag>;
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::Sagd>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = SagdSpatialParams<FVGridGeometry, Scalar>;
+    using type = SagdSpatialParams<GridGeometry, Scalar>;
 };
 
 // Set the fluid system
@@ -99,7 +99,7 @@ class SagdProblem : public PorousMediumFlowProblem<TypeTag>
 {
     using ParentType = PorousMediumFlowProblem<TypeTag>;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
@@ -136,8 +136,8 @@ class SagdProblem : public PorousMediumFlowProblem<TypeTag>
 
 public:
 
-    SagdProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), pOut_(4e6)
+    SagdProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), pOut_(4e6)
     {
         maxDepth_ = 400.0; // [m]
         FluidSystem::init();
diff --git a/test/porousmediumflow/3pwateroil/implicit/spatialparams.hh b/test/porousmediumflow/3pwateroil/implicit/spatialparams.hh
index 543d2dd099508b2edccfc1ae9b9307aedca8cf74..94790c03570605340441641b7034921ddcea5bcf 100644
--- a/test/porousmediumflow/3pwateroil/implicit/spatialparams.hh
+++ b/test/porousmediumflow/3pwateroil/implicit/spatialparams.hh
@@ -40,13 +40,13 @@ namespace Dumux {
  * \ingroup ThreePWaterOilTests
  * \brief Definition of the spatial parameters for the SAGD problem
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class SagdSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         SagdSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         SagdSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
 
     enum { dimWorld=GridView::dimensionworld };
@@ -54,8 +54,8 @@ class SagdSpatialParams
     using GlobalPosition = typename SubControlVolume::GlobalPosition;
 
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       SagdSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       SagdSpatialParams<GridGeometry, Scalar>>;
 
     using EffectiveLaw = RegularizedParkerVanGen3P<Scalar>;
 
@@ -64,8 +64,8 @@ public:
     using MaterialLawParams = typename MaterialLaw::Params;
     using PermeabilityType = Scalar;
 
-    SagdSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry), eps_(1e-6)
+    SagdSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry), eps_(1e-6)
     {
         layerBottom_ = 35.0;
 
diff --git a/test/porousmediumflow/co2/implicit/main.cc b/test/porousmediumflow/co2/implicit/main.cc
index cdbc9af8b5997fba9e8abcdb2d254aad8dc00807..7c18c0909dd1248c6d7b9f3e5d79b8715dc5f19f 100644
--- a/test/porousmediumflow/co2/implicit/main.cc
+++ b/test/porousmediumflow/co2/implicit/main.cc
@@ -79,27 +79,27 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the spatial parameters
     using SpatialParams = GetPropType<TypeTag, Properties::SpatialParams>;
-    auto spatialParams = std::make_shared<SpatialParams>(fvGridGeometry, gridManager.getGridData());
+    auto spatialParams = std::make_shared<SpatialParams>(gridGeometry, gridManager.getGridData());
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry, spatialParams);
+    auto problem = std::make_shared<Problem>(gridGeometry, spatialParams);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -123,11 +123,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/co2/implicit/problem.hh b/test/porousmediumflow/co2/implicit/problem.hh
index 46e7a10a9cab627549615889fbb4a3f6be085bc6..cbeb37669a95a8fcf969119a67578acab29127c2 100644
--- a/test/porousmediumflow/co2/implicit/problem.hh
+++ b/test/porousmediumflow/co2/implicit/problem.hh
@@ -205,7 +205,7 @@ class HeterogeneousProblem : public PorousMediumFlowProblem<TypeTag>
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
@@ -223,8 +223,8 @@ class HeterogeneousProblem : public PorousMediumFlowProblem<TypeTag>
 
 public:
     template<class SpatialParams>
-    HeterogeneousProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry, std::shared_ptr<SpatialParams> spatialParams)
-    : ParentType(fvGridGeometry, spatialParams)
+    HeterogeneousProblem(std::shared_ptr<const GridGeometry> gridGeometry, std::shared_ptr<SpatialParams> spatialParams)
+    : ParentType(gridGeometry, spatialParams)
     , injectionTop_(1)
     , injectionBottom_(2)
     , dirichletBoundary_(3)
diff --git a/test/porousmediumflow/co2/implicit/spatialparams.hh b/test/porousmediumflow/co2/implicit/spatialparams.hh
index 278289e22312d63f191048d74048590b2b0ae8ef..d858b2dab749e3c0f4a81ffb0f727fac3d1f1598 100644
--- a/test/porousmediumflow/co2/implicit/spatialparams.hh
+++ b/test/porousmediumflow/co2/implicit/spatialparams.hh
@@ -42,18 +42,18 @@ namespace Dumux {
  *        problem which uses the non-isothermal or isothermal CO2
  *        fully implicit model.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class HeterogeneousSpatialParams
-: public FVSpatialParams<FVGridGeometry,
+: public FVSpatialParams<GridGeometry,
                          Scalar,
-                         HeterogeneousSpatialParams<FVGridGeometry, Scalar>>
+                         HeterogeneousSpatialParams<GridGeometry, Scalar>>
 {
-    using Grid = typename FVGridGeometry::Grid;
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using Grid = typename GridGeometry::Grid;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, HeterogeneousSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, HeterogeneousSpatialParams<GridGeometry, Scalar>>;
 
     using GlobalPosition = typename SubControlVolume::GlobalPosition;
 
@@ -64,9 +64,9 @@ public:
     using MaterialLawParams = typename MaterialLaw::Params;
     using PermeabilityType = Scalar;
 
-    HeterogeneousSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry,
+    HeterogeneousSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry,
                                std::shared_ptr<const GridData<Grid>> gridData)
-    : ParentType(fvGridGeometry), gridData_(gridData)
+    : ParentType(gridGeometry), gridData_(gridData)
     {
 
         // Set the permeability for the layers
diff --git a/test/porousmediumflow/mpnc/implicit/2p2ccomparison/main.cc b/test/porousmediumflow/mpnc/implicit/2p2ccomparison/main.cc
index af5d82834f89040203d0f51e89da5e217db5a77a..2bae1e10dcb6ac4cf430101101d5d2c71b89cf16 100644
--- a/test/porousmediumflow/mpnc/implicit/2p2ccomparison/main.cc
+++ b/test/porousmediumflow/mpnc/implicit/2p2ccomparison/main.cc
@@ -111,23 +111,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -150,11 +150,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/mpnc/implicit/2p2ccomparison/problem.hh b/test/porousmediumflow/mpnc/implicit/2p2ccomparison/problem.hh
index d70f84ffbd451e5ea3f799791c19ebe7447aad67..64d20457b476d900b1d15a3d1f1a38267fc2db83 100644
--- a/test/porousmediumflow/mpnc/implicit/2p2ccomparison/problem.hh
+++ b/test/porousmediumflow/mpnc/implicit/2p2ccomparison/problem.hh
@@ -73,9 +73,9 @@ struct Problem<TypeTag, TTag::MPNCComparison> { using type = MPNCComparisonProbl
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::MPNCComparison>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = MPNCComparisonSpatialParams<FVGridGeometry, Scalar>;
+    using type = MPNCComparisonSpatialParams<GridGeometry, Scalar>;
 };
 
 // Set fluid configuration
@@ -118,7 +118,7 @@ class MPNCComparisonProblem
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using FluidState = GetPropType<TypeTag, Properties::FluidState>;
     using ParameterCache = typename FluidSystem::ParameterCache;
 
@@ -137,8 +137,8 @@ class MPNCComparisonProblem
     static constexpr bool isBox = GetPropType<TypeTag, Properties::GridGeometry>::discMethod == DiscretizationMethod::box;
 
 public:
-    MPNCComparisonProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-        : ParentType(fvGridGeometry)
+    MPNCComparisonProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+        : ParentType(gridGeometry)
     {
         temperature_ = 273.15 + 25; // -> 25°C
 
diff --git a/test/porousmediumflow/mpnc/implicit/2p2ccomparison/spatialparams.hh b/test/porousmediumflow/mpnc/implicit/2p2ccomparison/spatialparams.hh
index f78aaa105f5f09454712d68f24a3338e1b0d1296..b3697ee9d1fadd515aa16b1bcddddd65f4afae09 100644
--- a/test/porousmediumflow/mpnc/implicit/2p2ccomparison/spatialparams.hh
+++ b/test/porousmediumflow/mpnc/implicit/2p2ccomparison/spatialparams.hh
@@ -39,18 +39,18 @@ namespace Dumux {
  * \brief Definition of the spatial params properties for the obstacle problem
  *
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class MPNCComparisonSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         MPNCComparisonSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         MPNCComparisonSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
 
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       MPNCComparisonSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       MPNCComparisonSpatialParams<GridGeometry, Scalar>>;
 
     using GlobalPosition = typename SubControlVolume::GlobalPosition;
     using EffectiveLaw = RegularizedBrooksCorey<Scalar>;
@@ -60,7 +60,7 @@ public:
     using MaterialLaw = EffToAbsLaw<EffectiveLaw>;
     using MaterialLawParams = typename MaterialLaw::Params;
 
-    MPNCComparisonSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry) : ParentType(fvGridGeometry)
+    MPNCComparisonSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry) : ParentType(gridGeometry)
     {
         // intrinsic permeabilities
         coarseK_ = 1e-12;
diff --git a/test/porousmediumflow/mpnc/implicit/kinetic/main.cc b/test/porousmediumflow/mpnc/implicit/kinetic/main.cc
index 104d5baa29a248eede3e60be9c6ff3ae7e3bd690..9daf38b6e33d78b59e24d7ceafeacb7c6ba1c560 100644
--- a/test/porousmediumflow/mpnc/implicit/kinetic/main.cc
+++ b/test/porousmediumflow/mpnc/implicit/kinetic/main.cc
@@ -108,13 +108,13 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using GridView = GetPropType<TypeTag, Properties::GridView>;
@@ -125,7 +125,7 @@ int main(int argc, char** argv) try
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
     problem->setGridVariables(gridVariables);
 
@@ -149,11 +149,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NonEquilibriumNewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/mpnc/implicit/kinetic/spatialparams.hh b/test/porousmediumflow/mpnc/implicit/kinetic/spatialparams.hh
index 092879eea3079fbb2dfe8bfd9e37a9ea678d5652..c7cc923f7263c9d6289efbd3ad04c062af255e34 100644
--- a/test/porousmediumflow/mpnc/implicit/kinetic/spatialparams.hh
+++ b/test/porousmediumflow/mpnc/implicit/kinetic/spatialparams.hh
@@ -46,17 +46,17 @@ namespace Dumux {
 /**
  * \brief Definition of the spatial parameters for the evaporation atmosphere Problem (using a "poor man's coupling")
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class EvaporationAtmosphereSpatialParams
-: public FVNonEquilibriumSpatialParams<FVGridGeometry, Scalar,
-                                       EvaporationAtmosphereSpatialParams<FVGridGeometry, Scalar>>
+: public FVNonEquilibriumSpatialParams<GridGeometry, Scalar,
+                                       EvaporationAtmosphereSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ThisType = EvaporationAtmosphereSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVNonEquilibriumSpatialParams<FVGridGeometry, Scalar, ThisType>;
+    using ThisType = EvaporationAtmosphereSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVNonEquilibriumSpatialParams<GridGeometry, Scalar, ThisType>;
 
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
@@ -81,8 +81,8 @@ public:
     using AwsSurfaceParams = typename AwsSurface::Params;
     using AnsSurfaceParams = typename AnsSurface::Params;
 
-    EvaporationAtmosphereSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    EvaporationAtmosphereSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         heightPM_               = getParam<std::vector<Scalar>>("Grid.Positions1")[1];
         heightDomain_           = getParam<std::vector<Scalar>>("Grid.Positions1")[2];
diff --git a/test/porousmediumflow/mpnc/implicit/obstacle/main.cc b/test/porousmediumflow/mpnc/implicit/obstacle/main.cc
index af5d82834f89040203d0f51e89da5e217db5a77a..2bae1e10dcb6ac4cf430101101d5d2c71b89cf16 100644
--- a/test/porousmediumflow/mpnc/implicit/obstacle/main.cc
+++ b/test/porousmediumflow/mpnc/implicit/obstacle/main.cc
@@ -111,23 +111,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -150,11 +150,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/mpnc/implicit/obstacle/problem.hh b/test/porousmediumflow/mpnc/implicit/obstacle/problem.hh
index c70f1bdc7def56cc8bc507daebf825c729b001e2..6f6ab94d2d8107b4d6ae5a7bfc07a6e124266590 100644
--- a/test/porousmediumflow/mpnc/implicit/obstacle/problem.hh
+++ b/test/porousmediumflow/mpnc/implicit/obstacle/problem.hh
@@ -76,9 +76,9 @@ struct Problem<TypeTag, TTag::Obstacle> { using type = ObstacleProblem<TypeTag>;
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::Obstacle>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = ObstacleSpatialParams<FVGridGeometry, Scalar>;
+    using type = ObstacleSpatialParams<GridGeometry, Scalar>;
 };
 
 // Set fluid configuration
@@ -139,7 +139,7 @@ class ObstacleProblem
     using SubControlVolumeFace = typename FVElementGeometry::SubControlVolumeFace;
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Element = typename GridView::template Codim<0>::Entity;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using FluidState = GetPropType<TypeTag, Properties::FluidState>;
     using ParameterCache = typename FluidSystem::ParameterCache;
 
@@ -161,8 +161,8 @@ class ObstacleProblem
     using PhaseVector = Dune::FieldVector<Scalar, numPhases>;
 
 public:
-    ObstacleProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-        : ParentType(fvGridGeometry)
+    ObstacleProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+        : ParentType(gridGeometry)
     {
         temperature_ = 273.15 + 25; // -> 25°C
 
diff --git a/test/porousmediumflow/mpnc/implicit/obstacle/spatialparams.hh b/test/porousmediumflow/mpnc/implicit/obstacle/spatialparams.hh
index fee0f4d77a7f788a16657a5851da791a85513884..1272af0a7e6b339d5a1a4c158f0f627b52e7596f 100644
--- a/test/porousmediumflow/mpnc/implicit/obstacle/spatialparams.hh
+++ b/test/porousmediumflow/mpnc/implicit/obstacle/spatialparams.hh
@@ -37,17 +37,17 @@ namespace Dumux {
  * \brief Definition of the spatial params properties for the obstacle problem.
  *
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class ObstacleSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         ObstacleSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         ObstacleSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       ObstacleSpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       ObstacleSpatialParams<GridGeometry, Scalar>>;
 
     enum {dimWorld=GridView::dimensionworld};
     using GlobalPosition = typename SubControlVolume::GlobalPosition;
@@ -60,7 +60,7 @@ public:
     using MaterialLaw = EffToAbsLaw<EffectiveLaw>;
     using MaterialLawParams = typename MaterialLaw::Params;
 
-    ObstacleSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry) : ParentType(fvGridGeometry)
+    ObstacleSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry) : ParentType(gridGeometry)
     {
         // intrinsic permeabilities
         coarseK_ = 1e-12;
diff --git a/test/porousmediumflow/mpnc/implicit/thermalnonequilibrium/main.cc b/test/porousmediumflow/mpnc/implicit/thermalnonequilibrium/main.cc
index e7e39d72200c5deceb6140d1415ea9883f90cfb4..9f8d215c762cc69daf2e80941099783c66509624 100644
--- a/test/porousmediumflow/mpnc/implicit/thermalnonequilibrium/main.cc
+++ b/test/porousmediumflow/mpnc/implicit/thermalnonequilibrium/main.cc
@@ -108,23 +108,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
     problem->setGridVariables(gridVariables);
 
@@ -148,11 +148,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::NonEquilibriumNewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/mpnc/implicit/thermalnonequilibrium/spatialparams.hh b/test/porousmediumflow/mpnc/implicit/thermalnonequilibrium/spatialparams.hh
index e02efcdd6f5352ebe622db0516386f6cc9afdff6..47999c82dd34aee54f545887e389e4344f950005 100644
--- a/test/porousmediumflow/mpnc/implicit/thermalnonequilibrium/spatialparams.hh
+++ b/test/porousmediumflow/mpnc/implicit/thermalnonequilibrium/spatialparams.hh
@@ -42,17 +42,17 @@ namespace Dumux {
 /**
  * \brief Definition of the spatial parameters for the one component combustion problem
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class CombustionSpatialParams
-: public FVNonEquilibriumSpatialParams<FVGridGeometry, Scalar,
-                                       CombustionSpatialParams<FVGridGeometry, Scalar>>
+: public FVNonEquilibriumSpatialParams<GridGeometry, Scalar,
+                                       CombustionSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ThisType = CombustionSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVNonEquilibriumSpatialParams<FVGridGeometry, Scalar, ThisType>;
+    using ThisType = CombustionSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVNonEquilibriumSpatialParams<GridGeometry, Scalar, ThisType>;
 
     enum {dimWorld = GridView::dimensionworld};
     using GlobalPosition = typename SubControlVolume::GlobalPosition;
@@ -67,7 +67,7 @@ public:
     using MaterialLawParams = typename MaterialLaw::Params;
     using FluidSolidInterfacialAreaFormulation = FluidSolidInterfacialAreaShiWang<Scalar>;
 
-    CombustionSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry) : ParentType(fvGridGeometry)
+    CombustionSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry) : ParentType(gridGeometry)
     {
         // this is the parameter value from file part
         porosity_ = getParam<Scalar>("SpatialParams.PorousMedium.porosity");
diff --git a/test/porousmediumflow/richards/implicit/analytical/main.cc b/test/porousmediumflow/richards/implicit/analytical/main.cc
index 13f69c103f60ae4f1d8266b8471eaa37872c00f7..4769399d6617ba8c909d002d43c61df46c19b0b3 100644
--- a/test/porousmediumflow/richards/implicit/analytical/main.cc
+++ b/test/porousmediumflow/richards/implicit/analytical/main.cc
@@ -105,23 +105,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -144,7 +144,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::ILU0BiCGSTABBackend;
diff --git a/test/porousmediumflow/richards/implicit/analytical/problem.hh b/test/porousmediumflow/richards/implicit/analytical/problem.hh
index 03620950b6677e6592c89d42cda2a593c7b3afcd..5f240079e2c66997eb5b3d55e3112814d209bf51 100644
--- a/test/porousmediumflow/richards/implicit/analytical/problem.hh
+++ b/test/porousmediumflow/richards/implicit/analytical/problem.hh
@@ -79,9 +79,9 @@ struct Problem<TypeTag, TTag::RichardsAnalytical> { using type = RichardsAnalyti
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::RichardsAnalytical>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = RichardsAnalyticalSpatialParams<FVGridGeometry, Scalar>;
+    using type = RichardsAnalyticalSpatialParams<GridGeometry, Scalar>;
 };
 } // end namespace Properties
 
@@ -110,7 +110,7 @@ class RichardsAnalyticalProblem :  public PorousMediumFlowProblem<TypeTag>
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     enum {
         // copy some indices for convenience
@@ -125,8 +125,8 @@ class RichardsAnalyticalProblem :  public PorousMediumFlowProblem<TypeTag>
     using Geometry = typename GridView::template Codim<0>::Entity::Geometry;
 
 public:
-    RichardsAnalyticalProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    RichardsAnalyticalProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         pnRef_ = 1e5; // air pressure
         name_ = getParam<std::string>("Problem.Name");
diff --git a/test/porousmediumflow/richards/implicit/analytical/spatialparams.hh b/test/porousmediumflow/richards/implicit/analytical/spatialparams.hh
index 7e941f4ac2c25a2ba0e9e85ef78836a2235fd05f..3f384608b25fe2d750fdf049b72010d50a02bf0b 100644
--- a/test/porousmediumflow/richards/implicit/analytical/spatialparams.hh
+++ b/test/porousmediumflow/richards/implicit/analytical/spatialparams.hh
@@ -41,14 +41,14 @@ namespace Dumux {
  * \ingroup ImplicitTestProblems
  * \brief The spatial parameters for the RichardsAnalyticalProblem.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class RichardsAnalyticalSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         RichardsAnalyticalSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         RichardsAnalyticalSpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       RichardsAnalyticalSpatialParams<FVGridGeometry, Scalar>>;
+    using GridView = typename GridGeometry::GridView;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       RichardsAnalyticalSpatialParams<GridGeometry, Scalar>>;
 
     enum { dimWorld=GridView::dimensionworld };
     using Element = typename GridView::template Codim<0>::Entity;
@@ -64,8 +64,8 @@ public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    RichardsAnalyticalSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-        : ParentType(fvGridGeometry)
+    RichardsAnalyticalSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+        : ParentType(gridGeometry)
     {
         K_ = 5e-12;
         materialParams_.setSwr(0.0);
diff --git a/test/porousmediumflow/richards/implicit/lens/main.cc b/test/porousmediumflow/richards/implicit/lens/main.cc
index 868611ddb69570348a8ff0fd71994ce9dea4ba9f..3c461e469a097f765566c16182b7ad4e254a69e5 100644
--- a/test/porousmediumflow/richards/implicit/lens/main.cc
+++ b/test/porousmediumflow/richards/implicit/lens/main.cc
@@ -85,13 +85,13 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // check if we are about to restart a previously interrupted simulation
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
@@ -99,7 +99,7 @@ int main(int argc, char** argv) try
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     if (restartTime > 0)
     {
         using IOFields = GetPropType<TypeTag, Properties::IOFields>;
@@ -107,7 +107,7 @@ int main(int argc, char** argv) try
         using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
         using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
         const auto fileName = getParam<std::string>("Restart.File");
-        loadSolution(x, fileName, createPVNameFunction<IOFields, PrimaryVariables, ModelTraits, FluidSystem>(), *fvGridGeometry);
+        loadSolution(x, fileName, createPVNameFunction<IOFields, PrimaryVariables, ModelTraits, FluidSystem>(), *gridGeometry);
     }
     else
     {
@@ -118,7 +118,7 @@ int main(int argc, char** argv) try
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // intialize the vtk output module
@@ -140,11 +140,11 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DIFFMETHOD>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::AMGBackend<TypeTag>;
-    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, fvGridGeometry->dofMapper());
+    auto linearSolver = std::make_shared<LinearSolver>(leafGridView, gridGeometry->dofMapper());
 
     // the non-linear solver
     using NewtonSolver = Dumux::RichardsNewtonSolver<Assembler, LinearSolver>;
diff --git a/test/porousmediumflow/richards/implicit/lens/problem.hh b/test/porousmediumflow/richards/implicit/lens/problem.hh
index 3dbb14b98f6b1d015f5a1d0702ef4c18a774ece9..779e80aeebeb016f909bac024223930769b3a019 100644
--- a/test/porousmediumflow/richards/implicit/lens/problem.hh
+++ b/test/porousmediumflow/richards/implicit/lens/problem.hh
@@ -118,7 +118,7 @@ class RichardsLensProblem : public PorousMediumFlowProblem<TypeTag>
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     enum {
         // copy some indices for convenience
         pressureIdx = Indices::pressureIdx,
@@ -133,8 +133,8 @@ class RichardsLensProblem : public PorousMediumFlowProblem<TypeTag>
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    RichardsLensProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    RichardsLensProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         name_ = getParam<std::string>("Problem.Name");
     }
diff --git a/test/porousmediumflow/richards/implicit/lens/spatialparams.hh b/test/porousmediumflow/richards/implicit/lens/spatialparams.hh
index 960739e5cc588967ca89f11635a1dac629f9a1bb..100ecb90da7aacc9e53d3a7e7919a3d1e1c34e25 100644
--- a/test/porousmediumflow/richards/implicit/lens/spatialparams.hh
+++ b/test/porousmediumflow/richards/implicit/lens/spatialparams.hh
@@ -37,14 +37,14 @@ namespace Dumux {
  * \ingroup RichardsTests
  * \brief The spatial parameters for the RichardsLensProblem.
  */
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class RichardsLensSpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar, RichardsLensSpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar, RichardsLensSpatialParams<GridGeometry, Scalar>>
 {
-    using ThisType = RichardsLensSpatialParams<FVGridGeometry, Scalar>;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar, ThisType>;
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using ThisType = RichardsLensSpatialParams<GridGeometry, Scalar>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar, ThisType>;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
@@ -57,8 +57,8 @@ public:
     // export permeability type
     using PermeabilityType = Scalar;
 
-    RichardsLensSpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    RichardsLensSpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
 
         lensLowerLeft_ = {1.0, 2.0};
diff --git a/test/porousmediumflow/richards/implicit/nonisothermal/conduction/main.cc b/test/porousmediumflow/richards/implicit/nonisothermal/conduction/main.cc
index 15b210a10930b67e81ed2b2ae0aac4a93abb1321..0655c611bcde0ae96d53aed4ac02420707303d73 100644
--- a/test/porousmediumflow/richards/implicit/nonisothermal/conduction/main.cc
+++ b/test/porousmediumflow/richards/implicit/nonisothermal/conduction/main.cc
@@ -105,23 +105,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -145,7 +145,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::ILU0BiCGSTABBackend;
diff --git a/test/porousmediumflow/richards/implicit/nonisothermal/conduction/problem.hh b/test/porousmediumflow/richards/implicit/nonisothermal/conduction/problem.hh
index bbf972c8d8f8aeebef62ea10e3bce13b24f21b3d..50168159a9f34d5735e65eade1c3504ea5708b9f 100644
--- a/test/porousmediumflow/richards/implicit/nonisothermal/conduction/problem.hh
+++ b/test/porousmediumflow/richards/implicit/nonisothermal/conduction/problem.hh
@@ -73,9 +73,9 @@ struct FluidSystem<TypeTag, TTag::RichardsNIConduction> { using type = FluidSyst
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::RichardsNIConduction>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = RichardsNISpatialParams<FVGridGeometry, Scalar>;
+    using type = RichardsNISpatialParams<GridGeometry, Scalar>;
 };
 } // end namespace Properties
 
@@ -108,7 +108,7 @@ class RichardsNIConductionProblem :public PorousMediumFlowProblem<TypeTag>
 
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using BoundaryTypes = GetPropType<TypeTag, Properties::BoundaryTypes>;
@@ -133,15 +133,15 @@ class RichardsNIConductionProblem :public PorousMediumFlowProblem<TypeTag>
     using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
 public:
-    RichardsNIConductionProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    RichardsNIConductionProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         //initialize fluid system
         FluidSystem::init();
 
         name_ = getParam<std::string>("Problem.Name");
         temperatureHigh_ = 300.;
-        temperatureExact_.resize(fvGridGeometry->numDofs());
+        temperatureExact_.resize(gridGeometry->numDofs());
     }
 
     //! Get the analytical temperature
diff --git a/test/porousmediumflow/richards/implicit/nonisothermal/convection/main.cc b/test/porousmediumflow/richards/implicit/nonisothermal/convection/main.cc
index 15b210a10930b67e81ed2b2ae0aac4a93abb1321..0655c611bcde0ae96d53aed4ac02420707303d73 100644
--- a/test/porousmediumflow/richards/implicit/nonisothermal/convection/main.cc
+++ b/test/porousmediumflow/richards/implicit/nonisothermal/convection/main.cc
@@ -105,23 +105,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -145,7 +145,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::ILU0BiCGSTABBackend;
diff --git a/test/porousmediumflow/richards/implicit/nonisothermal/convection/problem.hh b/test/porousmediumflow/richards/implicit/nonisothermal/convection/problem.hh
index 557f23e79fe845c750e6344ad1e73c38c7414c0a..ef57233b7771d0710b288c096b1eb3bcfb783bb3 100644
--- a/test/porousmediumflow/richards/implicit/nonisothermal/convection/problem.hh
+++ b/test/porousmediumflow/richards/implicit/nonisothermal/convection/problem.hh
@@ -74,9 +74,9 @@ struct FluidSystem<TypeTag, TTag::RichardsNIConvection> { using type = FluidSyst
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::RichardsNIConvection>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = RichardsNISpatialParams<FVGridGeometry, Scalar>;
+    using type = RichardsNISpatialParams<GridGeometry, Scalar>;
 };
 } // end namespace Properties
 
@@ -111,7 +111,7 @@ class RichardsNIConvectionProblem : public PorousMediumFlowProblem<TypeTag>
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using FVElementGeometry = typename GetPropType<TypeTag, Properties::GridGeometry>::LocalView;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
@@ -141,8 +141,8 @@ class RichardsNIConvectionProblem : public PorousMediumFlowProblem<TypeTag>
     using GlobalPosition = typename SubControlVolumeFace::GlobalPosition;
 
 public:
-    RichardsNIConvectionProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    RichardsNIConvectionProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         // initialize fluid system
         FluidSystem::init();
@@ -153,7 +153,7 @@ public:
         temperatureLow_ = 290.;
         pressureHigh_ = 2e5;
         pressureLow_ = 1e5;
-        temperatureExact_.resize(fvGridGeometry->numDofs());
+        temperatureExact_.resize(gridGeometry->numDofs());
     }
 
     //! Get the analytical temperature
diff --git a/test/porousmediumflow/richards/implicit/nonisothermal/evaporation/main.cc b/test/porousmediumflow/richards/implicit/nonisothermal/evaporation/main.cc
index c272af71881a02fbd056bb38992da8f68cd2e5a3..7fa13f7e18ceec73634451e35f03380560ca511f 100644
--- a/test/porousmediumflow/richards/implicit/nonisothermal/evaporation/main.cc
+++ b/test/porousmediumflow/richards/implicit/nonisothermal/evaporation/main.cc
@@ -79,23 +79,23 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -118,7 +118,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::ILU0BiCGSTABBackend;
diff --git a/test/porousmediumflow/richards/implicit/nonisothermal/evaporation/problem.hh b/test/porousmediumflow/richards/implicit/nonisothermal/evaporation/problem.hh
index bc9a28d6fa1cebb7b86de0b8dcd990081d5bcfa7..cadba22725ca2fcb98023484b0928ae1955bb811 100644
--- a/test/porousmediumflow/richards/implicit/nonisothermal/evaporation/problem.hh
+++ b/test/porousmediumflow/richards/implicit/nonisothermal/evaporation/problem.hh
@@ -72,9 +72,9 @@ struct FluidSystem<TypeTag, TTag::RichardsNIEvaporation> { using type = FluidSys
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::RichardsNIEvaporation>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = RichardsNISpatialParams<FVGridGeometry, Scalar>;
+    using type = RichardsNISpatialParams<GridGeometry, Scalar>;
 };
 
 template<class TypeTag>
@@ -100,9 +100,9 @@ class RichardsNIEvaporationProblem : public PorousMediumFlowProblem<TypeTag>
 
     using GridView = GetPropType<TypeTag, Properties::GridView>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
-    using SubControlVolumeFace = typename FVGridGeometry::SubControlVolumeFace;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using FVElementGeometry = typename GridGeometry::LocalView;
+    using SubControlVolumeFace = typename GridGeometry::SubControlVolumeFace;
     using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
     using NumEqVector = GetPropType<TypeTag, Properties::NumEqVector>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
@@ -130,8 +130,8 @@ class RichardsNIEvaporationProblem : public PorousMediumFlowProblem<TypeTag>
     using GlobalPosition = typename SubControlVolumeFace::GlobalPosition;
 
 public:
-    RichardsNIEvaporationProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    RichardsNIEvaporationProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         // initialize fluid system
         FluidSystem::init();
diff --git a/test/porousmediumflow/richards/implicit/nonisothermal/spatialparams.hh b/test/porousmediumflow/richards/implicit/nonisothermal/spatialparams.hh
index 93c5c9f80542f340d68aa99f246726352fe4d7d4..6b6da0eb446682db076772b5257a92724424deb7 100644
--- a/test/porousmediumflow/richards/implicit/nonisothermal/spatialparams.hh
+++ b/test/porousmediumflow/richards/implicit/nonisothermal/spatialparams.hh
@@ -33,17 +33,17 @@
 
 namespace Dumux {
 
-template<class FVGridGeometry, class Scalar>
+template<class GridGeometry, class Scalar>
 class RichardsNISpatialParams
-: public FVSpatialParams<FVGridGeometry, Scalar,
-                         RichardsNISpatialParams<FVGridGeometry, Scalar>>
+: public FVSpatialParams<GridGeometry, Scalar,
+                         RichardsNISpatialParams<GridGeometry, Scalar>>
 {
-    using GridView = typename FVGridGeometry::GridView;
-    using FVElementGeometry = typename FVGridGeometry::LocalView;
+    using GridView = typename GridGeometry::GridView;
+    using FVElementGeometry = typename GridGeometry::LocalView;
     using SubControlVolume = typename FVElementGeometry::SubControlVolume;
     using Element = typename GridView::template Codim<0>::Entity;
-    using ParentType = FVSpatialParams<FVGridGeometry, Scalar,
-                                       RichardsNISpatialParams<FVGridGeometry, Scalar>>;
+    using ParentType = FVSpatialParams<GridGeometry, Scalar,
+                                       RichardsNISpatialParams<GridGeometry, Scalar>>;
 
     enum { dimWorld=GridView::dimensionworld };
 
@@ -58,8 +58,8 @@ public:
     using MaterialLaw = EffToAbsLaw<EffectiveLaw>;
     using  MaterialLawParams = typename MaterialLaw::Params;
 
-    RichardsNISpatialParams(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-        : ParentType(fvGridGeometry)
+    RichardsNISpatialParams(std::shared_ptr<const GridGeometry> gridGeometry)
+        : ParentType(gridGeometry)
     {
         permeability_ = 1e-10;
         porosity_ = 0.4;
diff --git a/test/porousmediumflow/richardsnc/implicit/main.cc b/test/porousmediumflow/richardsnc/implicit/main.cc
index 495346abe623723209aba794ff7d4971f215cd5e..584db772add680b4e87af3bf1fb1eccbfd83be2e 100644
--- a/test/porousmediumflow/richardsnc/implicit/main.cc
+++ b/test/porousmediumflow/richardsnc/implicit/main.cc
@@ -105,24 +105,24 @@ int main(int argc, char** argv) try
     const auto& leafGridView = gridManager.grid().leafGridView();
 
     // create the finite volume grid geometry
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
-    auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
-    fvGridGeometry->update();
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    auto gridGeometry = std::make_shared<GridGeometry>(leafGridView);
+    gridGeometry->update();
 
     // the problem (initial and boundary conditions)
     using Problem = GetPropType<TypeTag, Properties::Problem>;
-    auto problem = std::make_shared<Problem>(fvGridGeometry);
+    auto problem = std::make_shared<Problem>(gridGeometry);
     problem->computePointSourceMap(); // enable point sources
 
     // the solution vector
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
-    SolutionVector x(fvGridGeometry->numDofs());
+    SolutionVector x(gridGeometry->numDofs());
     problem->applyInitialSolution(x);
     auto xOld = x;
 
     // the grid variables
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
-    auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+    auto gridVariables = std::make_shared<GridVariables>(problem, gridGeometry);
     gridVariables->init(x);
 
     // get some time loop parameters
@@ -145,7 +145,7 @@ int main(int argc, char** argv) try
 
     // the assembler with time loop for instationary problem
     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
-    auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop, xOld);
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
 
     // the linear solver
     using LinearSolver = Dumux::ILU0BiCGSTABBackend;
diff --git a/test/porousmediumflow/richardsnc/implicit/problem.hh b/test/porousmediumflow/richardsnc/implicit/problem.hh
index 6fc6476eca61201d1e885c0929c2c6d6cf9fa3f4..9020c3d4966fb70ef28399a447511614a172a493 100644
--- a/test/porousmediumflow/richardsnc/implicit/problem.hh
+++ b/test/porousmediumflow/richardsnc/implicit/problem.hh
@@ -69,9 +69,9 @@ struct Problem<TypeTag, TTag::RichardsWellTracer> { using type = RichardsWellTra
 template<class TypeTag>
 struct SpatialParams<TypeTag, TTag::RichardsWellTracer>
 {
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
-    using type = RichardsWellTracerSpatialParams<FVGridGeometry, Scalar>;
+    using type = RichardsWellTracerSpatialParams<GridGeometry, Scalar>;
 };
 
 // Set the physical problem to be solved
@@ -121,7 +121,7 @@ class RichardsWellTracerProblem : public PorousMediumFlowProblem<TypeTag>
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
-    using FVGridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
     using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
     using GridVariables = GetPropType<TypeTag, Properties::GridVariables>;
     enum {
@@ -134,8 +134,8 @@ class RichardsWellTracerProblem : public PorousMediumFlowProblem<TypeTag>
     using GlobalPosition = typename SubControlVolume::GlobalPosition;
 
 public:
-    RichardsWellTracerProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
-    : ParentType(fvGridGeometry)
+    RichardsWellTracerProblem(std::shared_ptr<const GridGeometry> gridGeometry)
+    : ParentType(gridGeometry)
     {
         name_ = getParam<std::string>("Problem.Name");
         contaminantMoleFraction_ = getParam<Scalar>("Problem.ContaminantMoleFraction");
diff --git a/test/porousmediumflow/richardsnc/implicit/spatialparams.hh b/test/porousmediumflow/richardsnc/implicit/spatialparams.hh
index b99dcc7c42504584a932b1be2f339b311cb76361..a1