[test][1p2cni] Make cc conduction test pass again

test/porousmediumflow/1pnc/implicit/1p2cniconductionproblem.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 2 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
+ * \brief Definition of a problem, for the 1pnc problem:
+ * Component transport of nitrogen dissolved in the water phase.
+ */
+#ifndef DUMUX_1P2CNI_CONDUCTION_TEST_PROBLEM_HH
+#define DUMUX_1P2CNI_CONDUCTION_TEST_PROBLEM_HH
+
+#include <dumux/discretization/cellcentered/tpfa/properties.hh>
+#include <dumux/discretization/cellcentered/mpfa/properties.hh>
+#include <dumux/discretization/box/properties.hh>
+#include <dumux/porousmediumflow/1pnc/implicit/model.hh>
+#include <dumux/porousmediumflow/problem.hh>
+
+#include <dumux/material/fluidsystems/h2on2.hh>
+#include <dumux/material/components/h2o.hh>
+#include "1pnctestspatialparams.hh"
+
+namespace Dumux
+{
+
+template <class TypeTag>
+class OnePTwoCNIConductionProblem;
+
+namespace Properties
+{
+NEW_TYPE_TAG(OnePTwoCNIConductionProblem, INHERITS_FROM(OnePNCNI));
+NEW_TYPE_TAG(OnePTwoCNIConductionCCTpfaProblem, INHERITS_FROM(CCTpfaModel, OnePTwoCNIConductionProblem));
+
+// Set the grid type
+#if HAVE_UG
+SET_TYPE_PROP(OnePTwoCNIConductionProblem, Grid, Dune::UGGrid<2>);
+#else
+SET_TYPE_PROP(OnePTwoCNIConductionProblem, Grid, Dune::YaspGrid<2>);
+#endif
+
+// Set the problem property
+SET_TYPE_PROP(OnePTwoCNIConductionProblem, Problem, OnePTwoCNIConductionProblem<TypeTag>);
+
+// Set fluid configuration
+SET_TYPE_PROP(OnePTwoCNIConductionProblem,
+              FluidSystem,
+              FluidSystems::H2ON2<typename GET_PROP_TYPE(TypeTag, Scalar), true>);
+
+// Set the spatial parameters
+SET_TYPE_PROP(OnePTwoCNIConductionProblem, SpatialParams, OnePNCTestSpatialParams<TypeTag>);
+
+// Define whether mole(true) or mass (false) fractions are used
+SET_BOOL_PROP(OnePTwoCNIConductionProblem, UseMoles, true);
+}
+
+
+/*!
+ * \ingroup OnePNCModel
+ * \ingroup ImplicitTestProblems
+ *
+ * \brief Definition of a problem, for the 1pnc problem:
+ * Nitrogen is dissolved in the water phase and
+ * is transported with the water flow from the left side to the right.
+ *
+ * The model domain is 1 m times 1 m with a discretization length of 0.05 m
+ * and homogeneous soil properties (\f$ \mathrm{K=10e-10, \Phi=0.4, \tau=0.28}\f$).
+ * Initially the domain is filled with pure water.
+ *
+ * At the left side, a Dirichlet condition defines a nitrogen mole fraction
+ * of 0.3 mol/mol.
+ * The water phase flows from the left side to the right due to the applied pressure
+ * gradient of 1e5 Pa/m. The nitrogen is transported with the water flow
+ * and leaves the domain at the right boundary
+ * where again Dirichlet boundary conditions are applied. Here, the nitrogen mole
+ * fraction is set to 0.0 mol/mol.
+ *
+ * This problem uses the \ref OnePNCModel model.
+ *
+ * To run the simulation execute the following line in shell:
+ * <tt>./test_box1pnc -parameterFile ./test_box1pnc.input</tt> or
+ * <tt>./test_cc1pnc -parameterFile ./test_cc1pnc.input</tt>
+ */
+template <class TypeTag>
+class OnePTwoCNIConductionProblem : public PorousMediumFlowProblem<TypeTag>
+{
+    using ParentType = PorousMediumFlowProblem<TypeTag>;
+
+    using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
+    using Indices = typename GET_PROP_TYPE(TypeTag, Indices);
+    using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
+    using FluidSystem = typename GET_PROP_TYPE(TypeTag, FluidSystem);
+    using BoundaryTypes = typename GET_PROP_TYPE(TypeTag, BoundaryTypes);
+    using PrimaryVariables = typename GET_PROP_TYPE(TypeTag, PrimaryVariables);
+    using FVGridGeometry = typename GET_PROP_TYPE(TypeTag, FVGridGeometry);
+    using FVElementGeometry = typename GET_PROP_TYPE(TypeTag, FVElementGeometry);
+    using ResidualVector = typename GET_PROP_TYPE(TypeTag, NumEqVector);
+    using ElementVolumeVariables = typename GET_PROP_TYPE(TypeTag, ElementVolumeVariables);
+    using SubControlVolumeFace = typename GET_PROP_TYPE(TypeTag, SubControlVolumeFace);
+    using ElementSolutionVector = typename GET_PROP_TYPE(TypeTag, ElementSolutionVector);
+    using Element = typename GridView::template Codim<0>::Entity;
+    using FluidState = typename GET_PROP_TYPE(TypeTag, FluidState);
+    using ThermalConductivityModel = typename GET_PROP_TYPE(TypeTag, ThermalConductivityModel);
+    using SolutionVector = typename GET_PROP_TYPE(TypeTag, SolutionVector);
+    using VolumeVariables = typename GET_PROP_TYPE(TypeTag, VolumeVariables);
+    using IapwsH2O = H2O<Scalar>;
+
+    // copy some indices for convenience
+    enum
+    {
+        // indices of the primary variables
+        pressureIdx = Indices::pressureIdx,
+        massOrMoleFracIdx = Indices::firstMoleFracIdx,
+        temperatureIdx = Indices::temperatureIdx,
+
+        // indices of the equations
+        conti0EqIdx = Indices::conti0EqIdx,
+        transportEqIdx = Indices::firstTransportEqIdx,
+        energyEqIdx = Indices::energyEqIdx
+    };
+
+    //! property that defines whether mole or mass fractions are used
+    static const bool useMoles = GET_PROP_VALUE(TypeTag, UseMoles);
+    static const auto phaseIdx = GET_PROP_VALUE(TypeTag, PhaseIdx);
+    static const bool isBox = GET_PROP_VALUE(TypeTag, DiscretizationMethod) == DiscretizationMethods::Box;
+
+    static const int dimWorld = GridView::dimensionworld;
+    using GlobalPosition = Dune::FieldVector<Scalar, dimWorld>;
+
+public:
+    OnePTwoCNIConductionProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
+    : ParentType(fvGridGeometry), temperatureHigh_(300.0)
+    {
+        //initialize fluid system
+        FluidSystem::init();
+
+        // stating in the console whether mole or mass fractions are used
+        if(useMoles)
+            std::cout<<"problem uses mole fractions"<<std::endl;
+        else
+            std::cout<<"problem uses mass fractions"<<std::endl;
+
+        temperatureExact_.resize(fvGridGeometry->numDofs(), 290.0);
+    }
+
+    //! get the analytical temperature
+    const std::vector<Scalar>& getExactTemperature()
+    {
+        return temperatureExact_;
+    }
+
+    //! udpate the analytical temperature
+    void updateExactTemperature(const SolutionVector& curSol, Scalar time)
+    {
+        const auto someElement = *(elements(this->fvGridGeometry().gridView()).begin());
+
+        ElementSolutionVector someElemSol(someElement, curSol, this->fvGridGeometry());
+        const auto someInitSol = initialAtPos(someElement.geometry().center());
+
+        auto fvGeometry = localView(this->fvGridGeometry());
+        fvGeometry.bindElement(someElement);
+        const auto someScv = *(scvs(fvGeometry).begin());
+
+        VolumeVariables volVars;
+        volVars.update(someElemSol, *this, someElement, someScv);
+
+        const auto porosity = this->spatialParams().porosity(someElement, someScv, someElemSol);
+        const auto densityW = volVars.density(phaseIdx);
+        const auto heatCapacityW = IapwsH2O::liquidHeatCapacity(someInitSol[temperatureIdx], someInitSol[pressureIdx]);
+        const auto densityS = this->spatialParams().solidDensity(someElement, someScv, someElemSol);
+        const auto heatCapacityS = this->spatialParams().solidHeatCapacity(someElement, someScv, someElemSol);
+        const auto storage = densityW*heatCapacityW*porosity + densityS*heatCapacityS*(1 - porosity);
+        const auto effectiveThermalConductivity = ThermalConductivityModel::effectiveThermalConductivity(volVars, this->spatialParams(),
+                                                                                                         someElement, fvGeometry, someScv);
+        using std::max;
+        time = max(time, 1e-10);
+        for (const auto& element : elements(this->fvGridGeometry().gridView()))
+        {
+            auto fvGeometry = localView(this->fvGridGeometry());
+            fvGeometry.bindElement(element);
+
+            for (auto&& scv : scvs(fvGeometry))
+            {
+               auto globalIdx = scv.dofIndex();
+               const auto& globalPos = scv.dofPosition();
+               using std::erf;
+               using std::sqrt;
+               temperatureExact_[globalIdx] = temperatureHigh_ + (someInitSol[temperatureIdx] - temperatureHigh_)
+                                              *erf(0.5*sqrt(globalPos[0]*globalPos[0]*storage/time/effectiveThermalConductivity));
+
+            }
+        }
+    }
+
+    /*!
+     * \name Problem parameters
+     */
+    // \{
+
+    /*!
+     * \brief Returns the temperature within the domain [K].
+     *
+     * This problem assumes a temperature of 20 degrees Celsius.
+     */
+    Scalar temperature() const
+    { return 273.15 + 20; } // in [K]
+
+    // \}
+
+    /*!
+     * \name Boundary conditions
+     */
+    // \{
+
+    /*!
+     * \brief Specifies which kind of boundary condition should be
+     *        used for which equation on a given boundary segment.
+     *
+     * \param globalPos The position for which the bc type should be evaluated
+     */
+    BoundaryTypes boundaryTypesAtPos(const GlobalPosition &globalPos) const
+    {
+        BoundaryTypes values;
+
+        if(globalPos[0] < eps_ || globalPos[0] > this->fvGridGeometry().bBoxMax()[0] - eps_)
+        {
+            values.setAllDirichlet();
+        }
+        else
+        {
+            values.setAllNeumann();
+        }
+
+        return values;
+    }
+
+    /*!
+     * \brief Evaluate the boundary conditions for a dirichlet
+     *        boundary segment.
+     *
+     * \param globalPos The position for which the bc type should be evaluated
+     */
+    PrimaryVariables dirichletAtPos(const GlobalPosition &globalPos) const
+    {
+        PrimaryVariables values = initial_(globalPos);
+
+        // condition for the temperature at left boundary
+        if (globalPos[0] < eps_)
+            values[temperatureIdx] = temperatureHigh_;
+
+        return values;
+    }
+
+    /*!
+     * \brief Evaluate the boundary conditions for a neumann
+     *        boundary segment.
+     */
+    ResidualVector neumannAtPos(const GlobalPosition &globalPos) const
+    { return ResidualVector(0.0); }
+
+    // \}
+
+    /*!
+     * \name Volume terms
+     */
+    // \{
+
+    /*!
+     * \brief Evaluate the source term for all phases within a given
+     *        sub-control-volume.
+     *
+     * For this method, the \a priVars parameter stores the rate mass
+     * of a component is generated or annihilate per volume
+     * unit. Positive values mean that mass is created, negative ones
+     * mean that it vanishes.
+     *
+     * The units must be according to either using mole or mass fractions. (mole/(m^3*s) or kg/(m^3*s))
+     */
+    PrimaryVariables sourceAtPos(const GlobalPosition &globalPos) const
+    { return PrimaryVariables(0.0); }
+
+    /*!
+     * \brief Evaluate the initial value for a control volume.
+     *
+     * \param globalPos The position for which the initial condition should be evaluated
+     *
+     * For this method, the \a values parameter stores primary
+     * variables.
+     */
+    PrimaryVariables initialAtPos(const GlobalPosition &globalPos) const
+    { return initial_(globalPos); }
+
+    // \}
+private:
+
+    // the internal method for the initial condition
+    PrimaryVariables initial_(const GlobalPosition &globalPos) const
+    {
+        PrimaryVariables priVars;
+        priVars[pressureIdx] = 1e5; // initial condition for the pressure
+        priVars[massOrMoleFracIdx] = 1e-5;  // initial condition for the N2 molefraction
+        priVars[temperatureIdx] = 290.;
+        return priVars;
+    }
+        static constexpr Scalar eps_ = 1e-6;
+        Scalar temperatureHigh_;
+        std::vector<Scalar> temperatureExact_;
+    };
+
+} //end namespace Dumux
+
+#endif

test/porousmediumflow/1pnc/implicit/CMakeLists.txt

@@ -29,3 +29,13 @@ dune_add_test(NAME test_1p2c_mpfa
                                 ${CMAKE_CURRENT_BINARY_DIR}/1pnctest_mpfa-00009.vtu
                         --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p2c_mpfa test_1p2c_fv.input -Problem.Name 1pnctest_mpfa"
                         --zeroThreshold {"velocity_w \(m/s\)_1":1e-15})
+
+dune_add_test(NAME test_1p2cni_conduction_tpfa
+              SOURCES test_1p2cni_conduction_fv.cc
+              COMPILE_DEFINITIONS TYPETAG=OnePTwoCNIConductionCCTpfaProblem
+              COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
+              CMD_ARGS  --script fuzzy
+                        --files ${CMAKE_SOURCE_DIR}/test/references/1p2cniccconduction-reference.vtu
+                                ${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_conduction_tpfa-00006.vtu
+                        --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_conduction_tpfa test_1p2cni_fv.input"
+                        --zeroThreshold {"velocity_w \(m/s\)_0":1e-9})

test/porousmediumflow/1pnc/implicit/test_1p2cni_conduction_fv.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 2 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
+ *
+ * \brief test for the 1pnc model
+ */
+ #include <config.h>
+
+ #include "1p2cniconductionproblem.hh"
+
+ #include <ctime>
+ #include <iostream>
+
+ #include <dune/common/parallel/mpihelper.hh>
+ #include <dune/common/timer.hh>
+ #include <dune/grid/io/file/dgfparser/dgfexception.hh>
+ #include <dune/grid/io/file/vtk.hh>
+ #include <dune/istl/io.hh>
+
+ #include <dumux/discretization/methods.hh>
+
+ #include <dumux/common/propertysystem.hh>
+ #include <dumux/common/parameters.hh>
+ #include <dumux/common/valgrind.hh>
+ #include <dumux/common/dumuxmessage.hh>
+ #include <dumux/common/defaultusagemessage.hh>
+ #include <dumux/common/parameterparser.hh>
+
+ #include <dumux/nonlinear/newtoncontroller.hh>
+ #include <dumux/linear/seqsolverbackend.hh>
+ #include <dumux/nonlinear/newtonmethod.hh>
+
+ #include <dumux/assembly/fvassembler.hh>
+
+ #include <dumux/io/vtkoutputmodule.hh>
+
+ int main(int argc, char** argv) try
+ {
+     using namespace Dumux;
+
+     // define the type tag for this problem
+     using TypeTag = 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)
+     /////////////////////////////////////////////////////////////////////
+
+     using GridCreator = typename GET_PROP_TYPE(TypeTag, GridCreator);
+     GridCreator::makeGrid();
+     GridCreator::loadBalance();
+
+     ////////////////////////////////////////////////////////////
+     // run instationary non-linear problem on this grid
+     ////////////////////////////////////////////////////////////
+
+     // we compute on the leaf grid view
+     const auto& leafGridView = GridCreator::grid().leafGridView();
+
+     // create the finite volume grid geometry
+     using FVGridGeometry = typename GET_PROP_TYPE(TypeTag, FVGridGeometry);
+     auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
+     fvGridGeometry->update();
+
+     // the problem (initial and boundary conditions)
+     using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
+     auto problem = std::make_shared<Problem>(fvGridGeometry);
+
+     // the solution vector
+     using SolutionVector = typename GET_PROP_TYPE(TypeTag, SolutionVector);
+     SolutionVector x(fvGridGeometry->numDofs());
+     problem->applyInitialSolution(x);
+     auto xOld = x;
+
+     // the grid variables
+     using GridVariables = typename GET_PROP_TYPE(TypeTag, GridVariables);
+     auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+     gridVariables->init(x, xOld);
+
+     // get some time loop parameters
+     using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
+     auto tEnd = getParam<Scalar>("TimeLoop.TEnd");
+     auto dt = getParam<Scalar>("TimeLoop.DtInitial");
+     auto maxDivisions = getParam<int>("TimeLoop.MaxTimeStepDivisions");
+     auto maxDt = getParam<Scalar>("TimeLoop.MaxTimeStepSize");
+
+     // intialize the vtk output module
+     VtkOutputModule<TypeTag> vtkWriter(*problem, *fvGridGeometry, *gridVariables, x, problem->name());
+     using VtkOutputFields = typename GET_PROP_TYPE(TypeTag, VtkOutputFields);
+     VtkOutputFields::init(vtkWriter); //! Add model specific output fields
+     vtkWriter.addField(problem->getExactTemperature(), "temperatureExact");
+     vtkWriter.write(0.0);
+     // output every vtkOutputInterval time step
+     const auto vtkOutputInterval = getParam<int>("Problem.OutputInterval");
+
+     // instantiate time loop
+     auto timeLoop = std::make_shared<TimeLoop<Scalar>>(0.0, dt, tEnd);
+     timeLoop->setMaxTimeStepSize(maxDt);
+
+     // the assembler with time loop for instationary problem
+     using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
+     auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop);
+
+     // the linear solver
+    //  using LinearSolver = UMFPackBackend<TypeTag>;
+     using LinearSolver = ILU0BiCGSTABBackend<TypeTag>;
+     auto linearSolver = std::make_shared<LinearSolver>();
+
+     // the non-linear solver
+     using NewtonController = Dumux::NewtonController<TypeTag>;
+     auto newtonController = std::make_shared<NewtonController>(leafGridView.comm(), timeLoop);
+     NewtonMethod<NewtonController, Assembler, LinearSolver> nonLinearSolver(newtonController, assembler, linearSolver);
+
+     // time loop
+     timeLoop->start(); do
+     {
+         // set previous solution for storage evaluations
+         assembler->setPreviousSolution(xOld);
+
+         // try solving the non-linear system
+         for (int i = 0; i < maxDivisions; ++i)
+         {
+             // linearize & solve
+             auto converged = nonLinearSolver.solve(x);
+
+             if (converged)
+                 break;
+
+             if (!converged && i == maxDivisions-1)
+                 DUNE_THROW(Dune::MathError,
+                            "Newton solver didn't converge after "
+                            << maxDivisions
+                            << " time-step divisions. dt="
+                            << timeLoop->timeStepSize()
+                            << ".\nThe solutions of the current and the previous time steps "
+                            << "have been saved to restart files.");
+         }
+
+         // update the exact time temperature
+         problem->updateExactTemperature(x, timeLoop->time()+timeLoop->timeStepSize());
+
+         // make the new solution the old solution
+         xOld = x;
+         gridVariables->advanceTimeStep();
+
+         // advance to the time loop to the next step
+         timeLoop->advanceTimeStep();
+
+         // write vtk output
+         if (timeLoop->timeStepIndex()==0 || timeLoop->timeStepIndex() % vtkOutputInterval == 0 || timeLoop->willBeFinished())
+            vtkWriter.write(timeLoop->time());
+
+         // report statistics of this time step
+         timeLoop->reportTimeStep();
+
+         // set new dt as suggested by newton controller
+         timeLoop->setTimeStepSize(newtonController->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;
+
+ }
+ catch (Dumux::ParameterException &e)
+ {
+     std::cerr << std::endl << e << " ---> Abort!" << std::endl;
+     return 1;
+ }
+ catch (Dune::DGFException & e)
+ {
+     std::cerr << "DGF exception thrown (" << e <<
+                  "). Most likely, the DGF file name is wrong "
+                  "or the DGF file is corrupted, "
+                  "e.g. missing hash at end of file or wrong number (dimensions) of entries."
+                  << " ---> Abort!" << std::endl;
+     return 2;
+ }
+ catch (Dune::Exception &e)
+ {
+     std::cerr << "Dune reported error: " << e << " ---> Abort!" << std::endl;
+     return 3;
+ }
+ catch (...)
+ {
+     std::cerr << "Unknown exception thrown! ---> Abort!" << std::endl;
+     return 4;
+ }

test/porousmediumflow/1pnc/implicit/test_1p2cni_fv.input

+[TimeLoop]
+DtInitial = 1 # [s]
+TEnd = 1e5 # [s]
+MaxTimeStepSize = 1e10
+
+[Grid]
+LowerLeft = 0 0
+UpperRight = 5 1
+Cells = 200 1
+
+
+[Problem]
+Name = test_1p2cni_conduction_tpfa # name passed to the output routines
+OutputInterval = 5 # every 5th timestep an output file is written
+EnableGravity = 0 # disable gravity
+
+[Vtk]
+AddVelocity = 1 # enable velocity output

test/references/1p2cniccconduction-reference.vtu

@@ -2,8 +2,8 @@
 <VTKFile type="UnstructuredGrid" version="0.1" byte_order="LittleEndian">
   <UnstructuredGrid>
     <Piece NumberOfCells="200" NumberOfPoints="402">
-      <CellData Scalars="P" Vectors="velocity">
-        <DataArray type="Float32" Name="P" NumberOfComponents="1" format="ascii">
+      <CellData Scalars="pressure" Vectors="velocity_w (m/s)">
+        <DataArray type="Float32" Name="pressure" NumberOfComponents="1" format="ascii">
           100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000
           100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000
           100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000
@@ -41,7 +41,7 @@
           0.000466521 0.000442597 0.000418673 0.000394748 0.000370824 0.0003469 0.000322976 0.000299052 0.000275128 0.000251204 0.000227279 0.000203355
           0.000179431 0.000155507 0.000131583 0.000107659 8.37345e-05 5.98104e-05 3.58862e-05 1.19621e-05
         </DataArray>
-        <DataArray type="Float32" Name="velocity" NumberOfComponents="3" format="ascii">
+        <DataArray type="Float32" Name="velocity_w (m/s)" NumberOfComponents="3" format="ascii">
           -1.16432e-09 0 0 -1.15349e-09 0 0 -1.13227e-09 0 0 -1.10279e-09 0 0
           -1.06692e-09 0 0 -1.02441e-09 0 0 -9.75539e-10 0 0 -9.21308e-10 0 0
           -8.62751e-10 0 0 -8.00917e-10 0 0 -7.41148e-10 0 0 -6.85144e-10 0 0