[test][1p] test experimental assembly with grid variables

This implementation should be replaced as soon as the new assembly is
available. For now, this tests if NewtonSolver supports the new grid
variables-based assembly.

test/porousmediumflow/1p/compressible/instationary/CMakeLists.txt

@@ -30,3 +30,14 @@ dumux_add_test(NAME test_1p_compressible_instationary_box
                         --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_box-reference.vtu
                                 ${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_instationary_box-00010.vtu
                         --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_instationary_box params.input -Problem.Name test_1p_compressible_instationary_box")
+
+dumux_add_test(NAME test_1p_compressible_instationary_tpfa_experimental
+               LABELS porousmediumflow 1p
+               SOURCES main_experimental.cc
+               COMPILE_DEFINITIONS TYPETAG=OnePCompressibleTpfa
+               COMPILE_DEFINITIONS EXPERIMENTAL=1
+               COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
+               CMD_ARGS  --script fuzzy
+                         --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_cc-reference.vtu
+                                 ${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_instationary_tpfa_experimental-00010.vtu
+                         --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_instationary_tpfa_experimental params.input -Problem.Name test_1p_compressible_instationary_tpfa_experimental")

test/porousmediumflow/1p/compressible/instationary/assembler.hh

+// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+// vi: set et ts=4 sw=4 sts=4:
+/*****************************************************************************
+ *   See the file COPYING for full copying permissions.                      *
+ *                                                                           *
+ *   This program is free software: you can redistribute it and/or modify    *
+ *   it under the terms of the GNU General Public License as published by    *
+ *   the Free Software Foundation, either version 3 of the License, or       *
+ *   (at your option) any later version.                                     *
+ *                                                                           *
+ *   This program is distributed in the hope that it will be useful,         *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
+ *   GNU General Public License for more details.                            *
+ *                                                                           *
+ *   You should have received a copy of the GNU General Public License       *
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.   *
+ *****************************************************************************/
+/*!
+ * \file
+ * \ingroup OnePTests
+ * \brief Dummy assembler that fulfills the new experimental assembly interface.
+ */
+#ifndef DUMUX_COMPRESSIBLE_ONEP_TEST_ASSEMBLER_HH
+#define DUMUX_COMPRESSIBLE_ONEP_TEST_ASSEMBLER_HH
+
+namespace Dumux::OnePCompressibleTest {
+
+// Custom assembler to test assembly with grid variables,
+// fulfilling the foreseen required interface
+template<class Assembler>
+class GridVarsAssembler : public Assembler
+{
+public:
+    using Assembler::Assembler;
+    using typename Assembler::GridVariables;
+    using typename Assembler::ResidualType;
+
+    using Variables = GridVariables;
+
+    void assembleJacobianAndResidual(const GridVariables& gridVars)
+    { Assembler::assembleJacobianAndResidual(gridVars.dofs()); }
+
+    void assembleResidual(const GridVariables& gridVars)
+    { Assembler::assembleResidual(gridVars.dofs()); }
+
+    //! Remove residualNorm once this is fixed in the solvers !2113
+    auto residualNorm(const GridVariables& gridVars)
+    { return Assembler::residualNorm(gridVars.dofs()); }
+};
+
+} // end namespace Dumux::OnePCompressibleTest
+
+#endif

test/porousmediumflow/1p/compressible/instationary/gridvariables.hh

+// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+// vi: set et ts=4 sw=4 sts=4:
+/*****************************************************************************
+ *   See the file COPYING for full copying permissions.                      *
+ *                                                                           *
+ *   This program is free software: you can redistribute it and/or modify    *
+ *   it under the terms of the GNU General Public License as published by    *
+ *   the Free Software Foundation, either version 3 of the License, or       *
+ *   (at your option) any later version.                                     *
+ *                                                                           *
+ *   This program is distributed in the hope that it will be useful,         *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
+ *   GNU General Public License for more details.                            *
+ *                                                                           *
+ *   You should have received a copy of the GNU General Public License       *
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.   *
+ *****************************************************************************/
+/*!
+ * \file
+ * \ingroup OnePTests
+ * \brief Wrapper around the current FVGridVariables to fulfill the layout
+ *        of the new grid variables to test grid variables-based assembly.
+ */
+#ifndef DUMUX_COMPRESSIBLE_ONEP_TEST_GRID_VARIABLES_HH
+#define DUMUX_COMPRESSIBLE_ONEP_TEST_GRID_VARIABLES_HH
+
+#include <dumux/discretization/gridvariables.hh>
+
+namespace Dumux::OnePCompressibleTest {
+
+template<class GG, class BaseGridVariables, class SolutionVector>
+class TestGridVariables
+: public BaseGridVariables
+, public Dumux::Experimental::GridVariables<GG, SolutionVector>
+{
+    using ExperimentalBase = Dumux::Experimental::GridVariables<GG, SolutionVector>;
+
+public:
+    // export some types to avoid ambiguity
+    using GridGeometry = GG;
+    using Scalar = typename BaseGridVariables::Scalar;
+
+    template<class Problem>
+    TestGridVariables(std::shared_ptr<Problem> problem,
+                      std::shared_ptr<const GridGeometry> gridGeometry,
+                      const SolutionVector& x)
+    : BaseGridVariables(problem, gridGeometry)
+    , ExperimentalBase(gridGeometry, x)
+    {
+        BaseGridVariables::init(x);
+    }
+
+    // update to a new solution
+    void update(const SolutionVector& x)
+    {
+        BaseGridVariables::update(x);
+        ExperimentalBase::update(x);
+    }
+
+    // overload some functions to avoid ambiguity
+    decltype(auto) gridGeometry() const
+    { return ExperimentalBase::gridGeometry(); }
+};
+
+} // end namespace Dumux::OnePCompressibleTest
+
+#endif

test/porousmediumflow/1p/compressible/instationary/main_experimental.cc

+// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+// vi: set et ts=4 sw=4 sts=4:
+/*****************************************************************************
+ *   See the file COPYING for full copying permissions.                      *
+ *                                                                           *
+ *   This program is free software: you can redistribute it and/or modify    *
+ *   it under the terms of the GNU General Public License as published by    *
+ *   the Free Software Foundation, either version 3 of the License, or       *
+ *   (at your option) any later version.                                     *
+ *                                                                           *
+ *   This program is distributed in the hope that it will be useful,         *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
+ *   GNU General Public License for more details.                            *
+ *                                                                           *
+ *   You should have received a copy of the GNU General Public License       *
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.   *
+ *****************************************************************************/
+/*!
+ * \file
+ * \ingroup OnePTests
+ * \brief Test for the one-phase CC model
+ */
+#include <config.h>
+#include <ctime>
+#include <iostream>
+
+#include <dune/common/parallel/mpihelper.hh>
+#include <dune/common/timer.hh>
+#include <dune/grid/io/file/vtk.hh>
+#include <dune/istl/io.hh>
+
+#include <dumux/discretization/method.hh>
+
+#include <dumux/common/properties.hh>
+#include <dumux/common/parameters.hh>
+#include <dumux/common/dumuxmessage.hh>
+
+#include <dumux/nonlinear/newtonsolver.hh>
+#include <dumux/linear/seqsolverbackend.hh>
+
+#include <dumux/assembly/fvassembler.hh>
+
+#include <dumux/io/vtkoutputmodule.hh>
+#include <dumux/io/grid/gridmanager.hh>
+
+#include "properties.hh"
+#include "assembler.hh"
+
+int main(int argc, char** argv)
+{
+    using namespace Dumux;
+
+    // define the type tag for this problem
+    using TypeTag = Properties::TTag::TYPETAG;
+
+    ////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+
+    // initialize MPI, finalize is done automatically on exit
+    const auto& mpiHelper = Dune::MPIHelper::instance(argc, argv);
+
+    // print dumux start message
+    if (mpiHelper.rank() == 0)
+        DumuxMessage::print(/*firstCall=*/true);
+
+    // initialize parameter tree
+    Parameters::init(argc, argv);
+
+    //////////////////////////////////////////////////////////////////////
+    // try to create a grid (from the given grid file or the input file)
+    /////////////////////////////////////////////////////////////////////
+
+    GridManager<GetPropType<TypeTag, Properties::Grid>> gridManager;
+    gridManager.init();
+
+    ////////////////////////////////////////////////////////////
+    // run instationary non-linear problem on this grid
+    ////////////////////////////////////////////////////////////
+
+    // we compute on the leaf grid view
+    const auto& leafGridView = gridManager.grid().leafGridView();
+
+    // create the finite volume grid geometry
+    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>(gridGeometry);
+
+    // the solution vector
+    using SolutionVector = GetPropType<TypeTag, Properties::SolutionVector>;
+    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, gridGeometry, x);
+
+    // get some time loop parameters
+    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
+    auto tEnd = getParam<Scalar>("TimeLoop.TEnd");
+    auto dt = getParam<Scalar>("TimeLoop.DtInitial");
+    auto maxDt = getParam<Scalar>("TimeLoop.MaxTimeStepSize");
+
+    // intialize the vtk output module
+    VtkOutputModule<GridVariables, SolutionVector> vtkWriter(*gridVariables, gridVariables->dofs(), problem->name());
+    using VelocityOutput = GetPropType<TypeTag, Properties::VelocityOutput>;
+    vtkWriter.addVelocityOutput(std::make_shared<VelocityOutput>(*gridVariables));
+    using IOFields = GetPropType<TypeTag, Properties::IOFields>;
+    IOFields::initOutputModule(vtkWriter); // Add model specific output fields
+    vtkWriter.write(0.0);
+
+    // instantiate time loop
+    auto timeLoop = std::make_shared<CheckPointTimeLoop<Scalar>>(0.0, dt, tEnd);
+    timeLoop->setMaxTimeStepSize(maxDt);
+
+    // the assembler with time loop for instationary problem
+    using BaseAssembler = FVAssembler<TypeTag, DiffMethod::numeric>;
+    using Assembler = Dumux::OnePCompressibleTest::GridVarsAssembler<BaseAssembler>;
+    auto assembler = std::make_shared<Assembler>(problem, gridGeometry, gridVariables, timeLoop, xOld);
+
+    // the linear solver
+    using LinearSolver = ILU0BiCGSTABBackend;
+    auto linearSolver = std::make_shared<LinearSolver>();
+
+    // the non-linear solver
+    using NewtonSolver = Dumux::NewtonSolver<Assembler, LinearSolver>;
+    NewtonSolver nonLinearSolver(assembler, linearSolver);
+
+    // set some check points for the time loop
+    timeLoop->setPeriodicCheckPoint(tEnd/10.0);
+
+    // time loop
+    timeLoop->start(); do
+    {
+        // linearize & solve
+        nonLinearSolver.solve(*gridVariables, *timeLoop);
+
+        // make the new solution the old solution
+        xOld = gridVariables->dofs();
+
+        // advance to the time loop to the next step
+        timeLoop->advanceTimeStep();
+
+        // write vtk output
+        if (timeLoop->isCheckPoint())
+            vtkWriter.write(timeLoop->time());
+
+        // report statistics of this time step
+        timeLoop->reportTimeStep();
+
+        // set new dt as suggested by the newton solver
+        timeLoop->setTimeStepSize(nonLinearSolver.suggestTimeStepSize(timeLoop->timeStepSize()));
+
+    } while (!timeLoop->finished());
+
+    timeLoop->finalize(leafGridView.comm());
+
+    ////////////////////////////////////////////////////////////
+    // finalize, print dumux message to say goodbye
+    ////////////////////////////////////////////////////////////
+
+    // print dumux end message
+    if (mpiHelper.rank() == 0)
+        DumuxMessage::print(/*firstCall=*/false);
+
+    return 0;
+
+}

test/porousmediumflow/1p/compressible/instationary/properties.hh

@@ -27,17 +27,22 @@
 
 #include <dune/grid/yaspgrid.hh>
 
-
 #include <dumux/material/fluidsystems/1pliquid.hh>
 
 #include <dumux/discretization/cctpfa.hh>
 #include <dumux/discretization/ccmpfa.hh>
 #include <dumux/discretization/box.hh>
+#include <dumux/discretization/fvgridvariables.hh>
 
 #include <dumux/porousmediumflow/1p/model.hh>
 
 #include "problem.hh"
 #include "spatialparams.hh"
+#include "gridvariables.hh"
+
+#ifndef EXPERIMENTAL
+#define EXPERIMENTAL 0
+#endif
 
 namespace Dumux::Properties {
 // create the type tag nodes
@@ -76,6 +81,24 @@ public:
     using type = FluidSystems::OnePLiquid<Scalar, Components::TabulatedComponent<Components::H2O<Scalar>>>;
 };
 
+// for the experimental test, overwrite grid variables
+// property in order to test grid variables-based assembly
+#if EXPERIMENTAL
+template<class TypeTag>
+struct GridVariables<TypeTag, TTag::OnePCompressible>
+{
+private:
+    using GG = GetPropType<TypeTag, Properties::GridGeometry>;
+    using GVV = GetPropType<TypeTag, Properties::GridVolumeVariables>;
+    using GFC = GetPropType<TypeTag, Properties::GridFluxVariablesCache>;
+    using Base = Dumux::FVGridVariables<GG, GVV, GFC>;
+    using X = GetPropType<TypeTag, Properties::SolutionVector>;
+
+public:
+    using type = Dumux::OnePCompressibleTest::TestGridVariables<GG, Base, X>;
+};
+#endif
+
 // Disable caching (for testing purposes)
 template<class TypeTag>
 struct EnableGridVolumeVariablesCache<TypeTag, TTag::OnePCompressible> { static constexpr bool value = false; };
@@ -83,6 +106,7 @@ template<class TypeTag>
 struct EnableGridFluxVariablesCache<TypeTag, TTag::OnePCompressible> { static constexpr bool value = false; };
 template<class TypeTag>
 struct EnableGridGeometryCache<TypeTag, TTag::OnePCompressible> { static constexpr bool value = false; };
-}
 
-#endif
\ No newline at end of file
+} // end namespace Dumux::Properties
+
+#endif