[tracer] Implement tracer model and test

The tracer model solves transport equations for multiple tracers when
a velocity field is given by the user (possibly by a 1p simulation).

dumux/discretization/stationaryvelocityfield.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 This file contains the data which is required to calculate
+ *        volume and mass fluxes of fluid phases over a face of a finite volume.
+ *        A stationary velocity field is given by the user for use in tracer models.
+ */
+#ifndef DUMUX_DISCRETIZATION_STATIONARY_VELOCITY_FIELD_HH
+#define DUMUX_DISCRETIZATION_STATIONARY_VELOCITY_FIELD_HH
+
+#include <dumux/discretization/fluxvariablescaching.hh>
+
+namespace Dumux
+{
+/*!
+ * \ingroup StationaryVelocityField
+ * \brief Evaluates a user given velocity field
+ */
+template <class TypeTag>
+class StationaryVelocityField
+{
+    using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
+    using SubControlVolumeFace = typename GET_PROP_TYPE(TypeTag, SubControlVolumeFace);
+    using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
+    using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
+    using FVElementGeometry = typename GET_PROP_TYPE(TypeTag, FVElementGeometry);
+    using ElementVolumeVariables = typename GET_PROP_TYPE(TypeTag, ElementVolumeVariables);
+    using ElementFluxVarsCache = typename GET_PROP_TYPE(TypeTag, ElementFluxVariablesCache);
+    using Element = typename GridView::template Codim<0>::Entity;
+
+public:
+    // state the discretization method this implementation belongs to
+    static const DiscretizationMethods myDiscretizationMethod = DiscretizationMethods::None;
+
+    //! state the type for the corresponding cache and its filler
+    //! We don't cache anything for this law
+    using Cache = FluxVariablesCaching::EmptyAdvectionCache;
+    using CacheFiller = FluxVariablesCaching::EmptyCacheFiller<TypeTag>;
+
+    static Scalar flux(const Problem& problem,
+                       const Element& element,
+                       const FVElementGeometry& fvGeometry,
+                       const ElementVolumeVariables& elemVolVars,
+                       const SubControlVolumeFace& scvf,
+                       int phaseIdx,
+                       const ElementFluxVarsCache& elemFluxVarsCache)
+    {
+        //! Obtain the velocity field from the user, specified in the spatial params
+        return problem.spatialParams().velocity(element, scvf)
+                  * scvf.unitOuterNormal()
+                  * scvf.area()
+                  * elemVolVars[fvGeometry.scv(scvf.insideScvIdx())].extrusionFactor();
+    }
+};
+
+} // end namespace Dumux
+
+#endif

dumux/porousmediumflow/CMakeLists.txt

@@ -17,3 +17,4 @@ add_subdirectory("mpnc")
 add_subdirectory("nonisothermal")
 add_subdirectory("richards")
 add_subdirectory("sequential")
+add_subdirectory("tracer")

dumux/porousmediumflow/tracer/CMakeLists.txt

+add_subdirectory("implicit")

dumux/porousmediumflow/tracer/implicit/CMakeLists.txt

+
+#install headers
+install(FILES
+indices.hh
+model.hh
+properties.hh
+propertydefaults.hh
+volumevariables.hh
+DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/porousmediumflow/1p2c/implicit)

dumux/porousmediumflow/tracer/implicit/indices.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 Defines the primary variable and equation indices used by tracer model
+ */
+
+#ifndef DUMUX_TRACER_INDICES_HH
+#define DUMUX_TRACER_INDICES_HH
+
+#include "properties.hh"
+
+namespace Dumux
+{
+// \{
+
+/*!
+ * \ingroup TracerModel
+ * \ingroup ImplicitIndices
+ * \brief The indices for the isothermal tracer model.
+ */
+template <class TypeTag, int PVOffset = 0>
+struct TracerIndices
+{
+    //! Component indices are just numbered by component index
+    //! primary variable indices are just numbered by component index
+    //! Equation indices
+    static const int transportEqIdx = PVOffset + 0; //!< transport equation index
+};
+
+// \}
+}
+
+#endif

dumux/porousmediumflow/tracer/implicit/localresidual.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 Element-wise calculation of the local residual for problems
+ *        using fully implicit tracer model.
+ */
+#ifndef DUMUX_TRACER_LOCAL_RESIDUAL_HH
+#define DUMUX_TRACER_LOCAL_RESIDUAL_HH
+
+namespace Dumux
+{
+
+/*!
+ * \ingroup Implicit
+ * \ingroup TracerLocalResidual
+ * \brief Element-wise calculation of the local residual for problems
+ *        using fully implicit tracer model.
+ *
+ */
+template<class TypeTag>
+class TracerLocalResidual: public GET_PROP_TYPE(TypeTag, BaseLocalResidual)
+{
+    using ParentType = typename GET_PROP_TYPE(TypeTag, BaseLocalResidual);
+    using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
+    using SubControlVolume = typename GET_PROP_TYPE(TypeTag, SubControlVolume);
+    using SubControlVolumeFace = typename GET_PROP_TYPE(TypeTag, SubControlVolumeFace);
+    using PrimaryVariables = typename GET_PROP_TYPE(TypeTag, PrimaryVariables);
+    using FluxVariables = typename GET_PROP_TYPE(TypeTag, FluxVariables);
+    using ElementFluxVariablesCache = typename GET_PROP_TYPE(TypeTag, ElementFluxVariablesCache);
+    using Indices = typename GET_PROP_TYPE(TypeTag, Indices);
+    using BoundaryTypes = typename GET_PROP_TYPE(TypeTag, BoundaryTypes);
+    using FVElementGeometry = typename GET_PROP_TYPE(TypeTag, FVElementGeometry);
+    using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
+    using Element = typename GridView::template Codim<0>::Entity;
+    using ElementVolumeVariables = typename GET_PROP_TYPE(TypeTag, ElementVolumeVariables);
+    using VolumeVariables = typename GET_PROP_TYPE(TypeTag, VolumeVariables);
+    using EnergyLocalResidual = typename GET_PROP_TYPE(TypeTag, EnergyLocalResidual);
+
+    static const int numComponents = GET_PROP_VALUE(TypeTag, NumComponents);
+
+public:
+
+    /*!
+     * \brief Evaluate the amount of all conservation quantities
+     *        (e.g. phase mass) within a sub-control volume.
+     *
+     * The result should be averaged over the volume (e.g. phase mass
+     * inside a sub control volume divided by the volume)
+     *
+     *  \param scv The sub control volume
+     *  \param volVars The primary and secondary varaibles on the scv
+     *  \param useMoles If mole or mass fractions are used
+     */
+    PrimaryVariables computeStorage(const SubControlVolume& scv,
+                                    const VolumeVariables& volVars,
+                                    bool useMoles = true) const
+    {
+        PrimaryVariables storage(0.0);
+
+        // formulation with mole balances
+        if (useMoles)
+        {
+            for (int compIdx = 0; compIdx < numComponents; ++compIdx)
+                storage[compIdx] += volVars.porosity()
+                                    * volVars.molarDensity(0)
+                                    * volVars.moleFraction(0, compIdx);
+        }
+        // formulation with mass balances
+        else
+        {
+            for (int compIdx = 0; compIdx < numComponents; ++compIdx)
+                storage[compIdx] += volVars.porosity()
+                                    * volVars.density(0)
+                                    * volVars.massFraction(0, compIdx);
+        }
+
+        return storage;
+    }
+
+    /*!
+     * \brief Evaluates the total flux of all conservation quantities
+     *        over a face of a sub-control volume.
+     *
+     * \param element The element
+     * \param fvGeometry The finite volume geometry context
+     * \param elemVolVars The volume variables for all flux stencil elements
+     * \param scvf The sub control volume face
+     * \param elemFluxVarsCache The cache related to flux compuation
+     * \param useMoles If mole or mass fractions are used
+     */
+    PrimaryVariables computeFlux(const Element& element,
+                                 const FVElementGeometry& fvGeometry,
+                                 const ElementVolumeVariables& elemVolVars,
+                                 const SubControlVolumeFace& scvf,
+                                 const ElementFluxVariablesCache& elemFluxVarsCache,
+                                 bool useMoles = true)
+    {
+        FluxVariables fluxVars;
+        fluxVars.init(this->problem(), element, fvGeometry, elemVolVars, scvf, elemFluxVarsCache);
+
+        // get upwind weights into local scope
+        PrimaryVariables flux(0.0);
+
+        // formulation with mole balances
+        if (useMoles)
+        {
+            for (int compIdx = 0; compIdx < numComponents; ++compIdx)
+            {
+                // the physical quantities for which we perform upwinding
+                auto upwindTerm = [compIdx](const VolumeVariables& volVars)
+                { return volVars.molarDensity()*volVars.moleFraction(0, compIdx); };
+
+                // advective fluxes
+                flux[compIdx] += fluxVars.advectiveFlux(0, upwindTerm);
+                // diffusive fluxes
+                flux[compIdx] += fluxVars.molecularDiffusionFlux(0, compIdx);
+            }
+        }
+        // formulation with mass balances
+        else
+        {
+            for (int compIdx = 0; compIdx < numComponents; ++compIdx)
+            {
+                // the physical quantities for which we perform upwinding
+                auto upwindTerm = [compIdx](const VolumeVariables& volVars)
+                { return volVars.density()*volVars.massFraction(0, compIdx); };
+
+                // advective fluxes
+                flux[compIdx] += fluxVars.advectiveFlux(0, upwindTerm);
+                // diffusive fluxes
+                flux[compIdx] += fluxVars.molecularDiffusionFlux(0, compIdx);
+            }
+        }
+
+        return flux;
+    }
+};
+
+} // end namespace Dumux
+
+#endif

dumux/porousmediumflow/tracer/implicit/model.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 Base class for all models which use the fully implicit tracer model.
+ *        Adaption of the fully implicit scheme to the tracer transport model.
+ */
+
+#ifndef DUMUX_TRACER_MODEL_HH
+#define DUMUX_TRACER_MODEL_HH
+
+#include "properties.hh"
+
+namespace Dumux
+{
+
+/*!
+ * \ingroup TracerModel
+ * \brief Adaption of the fully implicit scheme to the tracer transport model.
+ *
+ * This model implements a transport of a tracer, where density and viscosity of the
+ * fluid phase in which the tracer gets transported are not affected by the tracer.
+ * The velocity field is a given spatial parameter.
+ * The model is mainly useful for fast computations on given or precomputed
+ * velocity fields and thus generally makes sense only in combination with an incompressible
+ * one-phase flow velocity field or analytically given / artificial fields. However, reactions
+ * between multiple tracer components can be implemented.
+ *
+ * The transport of the components \f$\kappa \in \{ a, b, c, ... \}\f$ is described by the following equation:
+ \f[
+ \phi \frac{ \partial \varrho X^\kappa}{\partial t}
+ - \text{div} \left\lbrace \varrho X^\kappa {\textbf v_f}
+ + \varrho D^\kappa_\text{pm} \frac{M^\kappa}{M_\alpha} \textbf{grad} x^\kappa \right\rbrace = q.
+ \f]
+ *
+ * All equations are discretized using a vertex-centered finite volume (box)
+ * or cell-centered finite volume scheme (TPFA or MPFA) as spatial
+ * and the implicit Euler method as time discretization.
+ * The model is able to use either mole or mass fractions. The property useMoles can be set to either true or false in the
+ * problem file. Make sure that the according units are used in the problem setup. useMoles is set to true by default.
+ *
+ * The primary variables the mole or mass fraction of dissolved components \f$x\f$.
+ * Note that the tracer model is always considered non-isothermal.
+ * The velocity output is fully compatible with the tracer model if you want to write the velocity field to vtk.
+ */
+
+template<class TypeTag >
+class TracerModel : public GET_PROP_TYPE(TypeTag, BaseModel)
+{
+    using ParentType = typename GET_PROP_TYPE(TypeTag, BaseModel);
+    using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
+    using FluidSystem = typename GET_PROP_TYPE(TypeTag, FluidSystem);
+    using VolumeVariables = typename GET_PROP_TYPE(TypeTag, VolumeVariables);
+
+public:
+
+    /*!
+     * \brief Apply the initial conditions to the model.
+     *
+     * \param problem The object representing the problem which needs to
+     *             be simulated.
+     */
+    void init(Problem& problem)
+    {
+        ParentType::init(problem);
+
+        // register standardized vtk output fields
+        auto& vtkOutputModule = problem.vtkOutputModule();
+        vtkOutputModule.addSecondaryVariable("x_" + std::string(FluidSystem::componentName(0)),
+                                             [](const VolumeVariables& v){ return v.moleFraction(0, 0); });
+        vtkOutputModule.addSecondaryVariable("X_" + std::string(FluidSystem::componentName(0)),
+                                             [](const VolumeVariables& v){ return v.massFraction(0, 0); });
+        vtkOutputModule.addSecondaryVariable("rho", [](const VolumeVariables& v){ return v.density(); });
+    }
+};
+
+} // end namespace Dumux
+
+#include "propertydefaults.hh"
+
+#endif

dumux/porousmediumflow/tracer/implicit/properties.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/>.   *
+ *****************************************************************************/
+/*!
+ * \ingroup Properties
+ * \ingroup ImplicitProperties
+ * \ingroup TracerModel
+ * \file
+ *
+ * \brief Defines the properties required for the fully implicit tracer model.
+ */
+
+#ifndef DUMUX_TRACER_PROPERTIES_HH
+#define DUMUX_TRACER_PROPERTIES_HH
+
+
+#include <dumux/implicit/box/properties.hh>
+#include <dumux/implicit/cellcentered/tpfa/properties.hh>
+#include <dumux/porousmediumflow/nonisothermal/implicit/properties.hh>
+
+namespace Dumux
+{
+// \{
+namespace Properties
+{
+
+//////////////////////////////////////////////////////////////////
+// Type tags
+//////////////////////////////////////////////////////////////////
+
+//! The type tags for the fully implicit tracer model.
+NEW_TYPE_TAG(Tracer);
+NEW_TYPE_TAG(BoxTracer, INHERITS_FROM(BoxModel, Tracer));
+NEW_TYPE_TAG(CCTracer, INHERITS_FROM(CCTpfaModel, Tracer));
+
+//////////////////////////////////////////////////////////////////
+// Property tags
+//////////////////////////////////////////////////////////////////
+
+NEW_PROP_TAG(NumPhases);   //!< Number of fluid phases in the system
+NEW_PROP_TAG(NumComponents);   //!< Number of fluid components in the system
+NEW_PROP_TAG(Indices); //!< Enumerations for the model
+NEW_PROP_TAG(SpatialParams); //!< The type of the spatial parameters
+NEW_PROP_TAG(EffectiveDiffusivityModel); //!< The employed model for the computation of the effective diffusivity
+NEW_PROP_TAG(FluidSystem); //!< Type of the multi-component relations
+NEW_PROP_TAG(UseMoles); //!< Defines whether mole (true) or mass (false) fractions are used
+NEW_PROP_TAG(SpatialParamsForchCoeff); //!< Property for the forchheimer coefficient
+NEW_PROP_TAG(TauTortuosity); //!< Tortuosity value (tau) used in macroscopic diffusion
+NEW_PROP_TAG(ProblemEnableGravity); //!< gravity flag for compatibility
+
+}
+// \}
+}
+
+#endif

dumux/porousmediumflow/tracer/implicit/propertydefaults.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/>.   *
+ *****************************************************************************/
+/*!
+ * \ingroup Properties
+ * \ingroup ImplicitProperties
+ * \ingroup TracerModel
+ * \file
+ *
+ * \brief Defines some default values for the properties of the fully implicit tracer model.
+ */
+
+#ifndef DUMUX_TRACER_PROPERTY_DEFAULTS_HH
+#define DUMUX_TRACER_PROPERTY_DEFAULTS_HH
+
+#include "properties.hh"
+#include "model.hh"
+#include "volumevariables.hh"
+#include "indices.hh"
+#include "localresidual.hh"
+
+#include <dumux/material/spatialparams/implicit1p.hh>
+#include <dumux/discretization/stationaryvelocityfield.hh>
+#include <dumux/material/fluidmatrixinteractions/diffusivityconstant.hh>
+
+namespace Dumux
+{
+// \{
+namespace Properties
+{
+//////////////////////////////////////////////////////////////////
+// Property values
+//////////////////////////////////////////////////////////////////
+SET_INT_PROP(Tracer, NumPhases, 1); //!< The number of phases
+
+SET_PROP(Tracer, NumEq) //!< set the number of equations
+{
+    using FluidSystem = typename GET_PROP_TYPE(TypeTag, FluidSystem);
+    static const int value = FluidSystem::numComponents;
+};
+
+SET_PROP(Tracer, NumComponents) //!< set the number of components
+{
+    using FluidSystem = typename GET_PROP_TYPE(TypeTag, FluidSystem);
+    static const int value = FluidSystem::numComponents;
+};
+
+SET_BOOL_PROP(Tracer, UseMoles, true); //!< Define that mole fractions are used in the balance equations
+
+//! Use the tracer local residual function for the tracer model
+SET_TYPE_PROP(Tracer, LocalResidual, TracerLocalResidual<TypeTag>);
+
+//! define the model
+SET_TYPE_PROP(Tracer, Model, TracerModel<TypeTag>);
+
+//! define the VolumeVariables
+SET_TYPE_PROP(Tracer, VolumeVariables, TracerVolumeVariables<TypeTag>);
+
+//! We use darcy's law as the default for the advective fluxes
+SET_TYPE_PROP(Tracer, AdvectionType, StationaryVelocityField<TypeTag>);
+
+//! set gravity flag for compatibility
+SET_BOOL_PROP(Tracer, ProblemEnableGravity, false);
+
+//! Set the indices used by the tracer model
+SET_TYPE_PROP(Tracer, Indices, TracerIndices<TypeTag>);
+//! The spatial parameters to be employed.
+//! Use ImplicitSpatialParamsOneP by default.
+SET_TYPE_PROP(Tracer, SpatialParams, ImplicitSpatialParamsOneP<TypeTag>);
+
+//! Use simple model with constant tortuosity as pm diffusivity model
+SET_PROP(Tracer, EffectiveDiffusivityModel)
+{
+    using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
+    using type = DiffusivityConstant<TypeTag>;
+};
+
+// physical processes to be considered by the isothermal model
+SET_BOOL_PROP(Tracer, EnableAdvection, true);
+SET_BOOL_PROP(Tracer, EnableMolecularDiffusion, true);
+SET_BOOL_PROP(Tracer, EnableEnergyBalance, false);
+
+//! default value for the forchheimer coefficient
+// Source: Ward, J.C. 1964 Turbulent flow in porous media. ASCE J. Hydraul. Div 90.
+//        Actually the Forchheimer coefficient is also a function of the dimensions of the
+//        porous medium. Taking it as a constant is only a first approximation
+//        (Nield, Bejan, Convection in porous media, 2006, p. 10)
+SET_SCALAR_PROP(Tracer, SpatialParamsForchCoeff, 0.55);
+
+/*!
+ * \brief default value for tortuosity value (tau) used in macroscopic diffusion
+ *
+ * Value is 0.5 according to Carman 1937: <i>Fluid flow through granular beds</i>
+ * \cite carman1937
+ */
+SET_SCALAR_PROP(Tracer, TauTortuosity, 0.5);
+
+} // end namespace Properties
+// \}
+} // end namespace Dumux
+
+#endif

dumux/porousmediumflow/tracer/implicit/volumevariables.hh

+// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-