Commit 78691a29 authored by Dennis Gläser's avatar Dennis Gläser

Merge branch 'feature/1pncmin-next' into 'next'

Feature/1pncmin next

See merge request !672
parents 365b46da 973d5c2d
......@@ -5,8 +5,8 @@ install(FILES
air.hh
benzene.hh
brine.hh
CaO.hh
CaO2H2.hh
cao.hh
cao2h2.hh
ch4.hh
co2.hh
co2tablereader.hh
......
......@@ -62,7 +62,7 @@ public:
*/
static Scalar density()
{
return 3370.0; //at 293 K ; Shao et al. (2013)
return 3370;
}
/*!
......
......@@ -62,7 +62,7 @@ public:
*/
static Scalar density()
{
return 2249.0; //at 293 K ; Shao et al. (2013)
return 2200.0; //at 293 K ; Shao et al. (2013)
}
/*!
......@@ -70,7 +70,7 @@ public:
*/
static Scalar heatCapacity()
{
return 0.0206; //Nagel et al. (2014) : 1530 J/kgK
return 1530; //Nagel et al. (2014) : 1530 J/kgK
}
};
......
......@@ -3,6 +3,7 @@ add_subdirectory("2p")
add_subdirectory("2pia")
add_subdirectory("3p")
add_subdirectory("mp")
add_subdirectory("mineralization")
#install headers
install(FILES
......
#install headers
install(FILES
effectivesoliddensity.hh
effectivesolidheatcapacity.hh
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/material/fluidmatrixinteractions/mineralization)
......@@ -19,37 +19,72 @@
/*!
* \file
*
* \brief Test for the 2pnc box model used for water management in PEM fuel cells.
* \brief Class for the evaluation of the porosity subject to precipitation.
*/
#include <config.h>
#include "thermochemproblem.hh"
#include <dumux/common/start.hh>
#ifndef DUMUX_EFFECTIVE_SOLID_DENSITY_HH
#define DUMUX_EFFECTIVE_SOLID_DENSITY_HH
#include <dumux/discretization/evalsolution.hh>
namespace Dumux
{
/*!
* \brief Provides an interface for customizing error messages associated with
* reading in parameters.
*
* \param progName The name of the program, that was tried to be started.
* \param errorMsg The error message that was issued by the start function.
* Comprises the thing that went wrong and a general help message.
* \ingroup Fluidmatrixinteractions
*/
void usage(const char *progName, const std::string &errorMsg)
/**
* \brief Calculates the effective solid density
*/
template<class TypeTag>
class EffectiveSolidDensity
{
if (errorMsg.size() > 0) {
std::string errorMessageOut = "\nUsage: ";
errorMessageOut += progName;
errorMessageOut += " [options]\n";
errorMessageOut += errorMsg;
errorMessageOut += "\n\nThe list of mandatory options for this program is:\n"
"\t-ParameterFile Parameter file (Input file) \n";
std::cout << errorMessageOut
<< "\n";
using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
using SpatialParams = typename GET_PROP_TYPE(TypeTag, SpatialParams);
using ElementSolution = typename GET_PROP_TYPE(TypeTag, ElementSolutionVector);
using SubControlVolume = typename GET_PROP_TYPE(TypeTag, SubControlVolume);
static const int dim = GridView::dimension;
static const int dimWorld = GridView::dimensionworld;
static const int numComponents = GET_PROP_VALUE(TypeTag, NumComponents);
static const int numSolidPhases = GET_PROP_VALUE(TypeTag, NumSPhases);
using Element = typename GridView::template Codim<0>:: Entity;
public:
void init(const SpatialParams& spatialParams)
{
spatialParamsPtr_ = &spatialParams;
}
}
int main(int argc, char** argv)
{
using ProblemTypeTag = TTAG(ThermoChemBoxProblem);
return Dumux::start<ProblemTypeTag>(argc, argv, usage);
}
// calculates the effective solid density of multiple solid phases according to
// their volume fractions
Scalar effectiveSolidDensity(const Element& element,
const SubControlVolume& scv,
const ElementSolution& elemSol) const
{
auto priVars = evalSolution(element, element.geometry(), elemSol, scv.center());
Scalar sumPrecipitates = 0.0;
Scalar effRhoS = 0.0;
for (unsigned int solidPhaseIdx = 0; solidPhaseIdx < numSolidPhases; ++solidPhaseIdx)
{
sumPrecipitates += priVars[numComponents + solidPhaseIdx];
effRhoS += priVars[numComponents + solidPhaseIdx]*spatialParams_().solidPhaseDensity(element, scv, elemSol, solidPhaseIdx);
}
return effRhoS/sumPrecipitates;
}
private:
const SpatialParams& spatialParams_() const
{ return *spatialParamsPtr_; }
const SpatialParams* spatialParamsPtr_;
};
} // namespace Dumux
#endif
// -*- 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 Class for the evaluation of the porosity subject to precipitation.
*/
#ifndef DUMUX_EFFECTIVE_SOLID_HEATCAPACITY_HH
#define DUMUX_EFFECTIVE_SOLID_HEATCAPACITY_HH
#include <dumux/discretization/evalsolution.hh>
namespace Dumux
{
/*!
* \ingroup Fluidmatrixinteractions
*/
/**
* \brief Calculates the effective solid heat capacity
*/
template<class TypeTag>
class EffectiveSolidHeatCapacity
{
using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
using SpatialParams = typename GET_PROP_TYPE(TypeTag, SpatialParams);
using ElementSolution = typename GET_PROP_TYPE(TypeTag, ElementSolutionVector);
using SubControlVolume = typename GET_PROP_TYPE(TypeTag, SubControlVolume);
static const int dim = GridView::dimension;
static const int dimWorld = GridView::dimensionworld;
static const int numComponents = GET_PROP_VALUE(TypeTag, NumComponents);
static const int numSolidPhases = GET_PROP_VALUE(TypeTag, NumSPhases);
using Element = typename GridView::template Codim<0>:: Entity;
public:
void init(const SpatialParams& spatialParams)
{
spatialParamsPtr_ = &spatialParams;
}
// calculates the effective solid heat capacity of multiple solid phases accordin to
// their volume fractions
Scalar effectiveSolidHeatCapacity(const Element& element,
const SubControlVolume& scv,
const ElementSolution& elemSol) const
{
auto priVars = evalSolution(element, element.geometry(), elemSol, scv.center());
Scalar sumPrecipitates = 0.0;
Scalar effCp = 0.0;
for (unsigned int solidPhaseIdx = 0; solidPhaseIdx < numSolidPhases; ++solidPhaseIdx)
{
sumPrecipitates += priVars[numComponents + solidPhaseIdx];
effCp += priVars[numComponents + solidPhaseIdx]*spatialParams_().solidPhaseHeatCapacity(element, scv, elemSol, solidPhaseIdx);
}
return effCp/sumPrecipitates;
}
private:
const SpatialParams& spatialParams_() const
{ return *spatialParamsPtr_; }
const SpatialParams* spatialParamsPtr_;
};
} // namespace Dumux
#endif
......@@ -24,7 +24,7 @@
#ifndef DUMUX_POROSITY_REACTIVE_BED_HH
#define DUMUX_POROSITY_REACTIVE_BED_HH
#include <dumux/discretization/scvoperator.hh>
#include <dumux/discretization/evalsolution.hh>
namespace Dumux
{
......@@ -42,7 +42,6 @@ class PorosityReactiveBed
using SpatialParams = typename GET_PROP_TYPE(TypeTag, SpatialParams);
using ElementSolution = typename GET_PROP_TYPE(TypeTag, ElementSolutionVector);
using SubControlVolume = typename GET_PROP_TYPE(TypeTag, SubControlVolume);
using ScvOperator = SubControlVolumeOperator<TypeTag>;
static const int dim = GridView::dimension;
static const int dimWorld = GridView::dimensionworld;
......@@ -68,7 +67,7 @@ public:
const SubControlVolume& scv,
const ElementSolution& elemSol) const
{
auto priVars = ScvOperator::evaluateSolution(element, scv, elemSol);
auto priVars = evalSolution(element, element.geometry(), elemSol, scv.center());
Scalar sumPrecipitates = 0.0;
for (unsigned int solidPhaseIdx = 0; solidPhaseIdx < numSolidPhases; ++solidPhaseIdx)
......
......@@ -30,8 +30,8 @@
#include <dumux/material/fluidsystems/base.hh>
#include <dumux/material/components/air.hh>
#include <dumux/material/components/simpleh2o.hh>
#include <dumux/material/components/CaO2H2.hh>
#include <dumux/material/components/CaO.hh>
#include <dumux/material/components/cao2h2.hh>
#include <dumux/material/components/cao.hh>
#include <dumux/material/binarycoefficients/h2o_air.hh>
#include <dumux/material/components/tabulatedcomponent.hh>
......
This diff is collapsed.
add_subdirectory("implicit")
#install headers
install(FILES
model.hh
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/porousmediumflow/1pncmin)
#install headers
install(FILES
indices.hh
localresidual.hh
model.hh
properties.hh
propertydefaults.hh
volumevariables.hh
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/porousmediumflow/1pncmin/implicit)
// -*- 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 Jacobian matrix for problems
* using the one-phase n-component mineralisation model.
*/
#ifndef DUMUX_1PNCMIN_LOCAL_RESIDUAL_BASE_HH
#define DUMUX_1PNCMIN_LOCAL_RESIDUAL_BASE_HH
#include "properties.hh"
#include <dumux/porousmediumflow/compositional/localresidual.hh>
namespace Dumux
{
/*!
* \ingroup OnePNCMinModel
* \ingroup ImplicitLocalResidual
* \brief Element-wise calculation of the Jacobian matrix for problems
* using the one-phase n-component mineralization fully implicit model.
*
* This class is used to fill the gaps in ImplicitLocalResidual for the one-phase n-component flow.
*/
template<class TypeTag>
class OnePNCMinLocalResidual: public CompositionalLocalResidual<TypeTag>
{
protected:
using ParentType = CompositionalLocalResidual<TypeTag>;
using ThisType = OnePNCMinLocalResidual<TypeTag>;
using PrimaryVariables = typename GET_PROP_TYPE(TypeTag, PrimaryVariables);
using Indices = typename GET_PROP_TYPE(TypeTag, Indices);
using SubControlVolume = typename GET_PROP_TYPE(TypeTag, SubControlVolume);
using VolumeVariables = typename GET_PROP_TYPE(TypeTag, VolumeVariables);
enum
{
numEq = GET_PROP_VALUE(TypeTag, NumEq),
numPhases = GET_PROP_VALUE(TypeTag, NumPhases),
numSPhases = GET_PROP_VALUE(TypeTag, NumSPhases),
numComponents = GET_PROP_VALUE(TypeTag, NumComponents),
pressureIdx = Indices::pressureIdx,
firstMoleFracIdx = Indices::firstMoleFracIdx,
phaseIdx = Indices::phaseIdx,
sPhaseIdx = 1, // don't use the sPhaseIdx of the fluidsystem
conti0EqIdx = Indices::conti0EqIdx,
};
public:
/*!
* \brief Evaluate the amount 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).
* In contrast to the 1pnc model, here, the storage of solid phases is included too.
*
* \param scv the SCV (sub-control-volume)
* \param volVars The volume variables of the right time step
*/
PrimaryVariables computeStorage(const SubControlVolume& scv,
const VolumeVariables& volVars) const
{
//call parenttype function
auto storage = ParentType::computeStorage(scv, volVars);
// Compute storage term of all solid (precipitated) phases (excluding the non-reactive matrix)
for (int Idx = sPhaseIdx; Idx < numPhases + numSPhases; ++Idx)
{
auto eqIdx = conti0EqIdx + numComponents-numPhases + Idx;
storage[eqIdx] += volVars.precipitateVolumeFraction(Idx)*volVars.molarDensity(Idx);
}
return storage;
}
};
} // end namespace Dumux
#endif
// -*- 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 Adaption of the fully implicit box scheme to the two-phase n-component flow model.
*/
#ifndef DUMUX_1PNCMIN_MODEL_HH
#define DUMUX_1PNCMIN_MODEL_HH
#include "properties.hh"
#include "indices.hh"
#include "localresidual.hh"
#include <dumux/porousmediumflow/1pnc/model.hh>
namespace Dumux
{
/*!
* \ingroup OnePNCMinModel
* \brief Adaption of the fully implicit scheme to the
* one-phase n-component fully implicit model with additional solid/mineral phases.
*
* This model implements one-phase n-component flow of a compressible fluid composed of
* the n components \f$\kappa \f$ in combination with mineral precipitation and dissolution
* of the solid phases. The standard multiphase Darcy
* approach is used as the equation for the conservation of momentum:
* \f[
v = - \frac{k_{r}}{\mu} \mbox{\bf K}
\left(\text{grad}\, p - \varrho_{f} \mbox{\bf g} \right)
* \f]
*
* By inserting this into the equations for the conservation of the
* components, one gets one transport equation for each component
* \f{eqnarray}
&& \frac{\partial ( \varrho_f X^\kappa \phi )}
{\partial t} - \text{div} \left\{ \varrho_f X^\kappa
\frac{k_{r}}{\mu} \mbox{\bf K}
(\text{grad}\, p - \varrho_{f} \mbox{\bf g}) \right\}
\nonumber \\ \nonumber \\
&-& \text{div} \left\{{\bf D_{pm}^\kappa} \varrho_{f} \text{grad}\, X^\kappa \right\}
- q_\kappa = 0 \qquad \kappa \in \{w, a,\cdots \}
\f}
*
* The solid or mineral phases are assumed to consist of a single component.
* Their mass balance consist only of a storage and a source term:
* \f$\frac{\partial \varrho_\lambda \phi_\lambda )} {\partial t}
* = q_\lambda\f$
*
* All equations are discretized using a vertex-centered finite volume (box)
* or cell-centered finite volume scheme as spatial and the implicit Euler method as time
* discretization.
*
* The primary variables are the pressure \f$p\f$ and the mole fractions of the
* dissolved components \f$x^k\f$. The primary variable of the solid phases is the volume
* fraction \f$\phi_\lambda = \frac{V_\lambda}{V_{total}}\f$.
*
* The source an sink terms link the mass balances of the n-transported component to the
* solid phases. The porosity \f$\phi\f$ is updated according to the reduction of the initial * (or solid-phase-free porous medium) porosity \f$\phi_0\f$ by the accumulated volume
* fractions of the solid phases:
* \f$ \phi = \phi_0 - \sum (\phi_\lambda)\f$
* Additionally, the permeability is updated depending on the current porosity.
*/
template<class TypeTag>
class OnePNCMinModel: public OnePNCModel<TypeTag>
{
using ThisType = Dumux::OnePNCMinModel<TypeTag>;
using ParentType = Dumux::OnePNCModel<TypeTag>;
using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
using FluidSystem = typename GET_PROP_TYPE(TypeTag, FluidSystem);
using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
using FVElementGeometry = typename GET_PROP_TYPE(TypeTag, FVElementGeometry);
using VolumeVariables = typename GET_PROP_TYPE(TypeTag, VolumeVariables);
using Indices = typename GET_PROP_TYPE(TypeTag, Indices);
enum {
dim = GridView::dimension,
dimWorld = GridView::dimensionworld,
numPhases = GET_PROP_VALUE(TypeTag, NumPhases),
numSPhases = GET_PROP_VALUE(TypeTag, NumSPhases),
numComponents = GET_PROP_VALUE(TypeTag, NumComponents),
numSComponents = FluidSystem::numSComponents,
pressureIdx = Indices::pressureIdx,
firstMoleFracIdx = Indices::firstMoleFracIdx,
phaseIdx = Indices::phaseIdx,
};
using Element = typename GridView::template Codim<0>::Entity;
using GlobalPosition = Dune::FieldVector<Scalar, dimWorld>;
using CoordScalar = typename GridView::ctype;
using Tensor = Dune::FieldMatrix<CoordScalar, dimWorld, dimWorld>;
enum { isBox = GET_PROP_VALUE(TypeTag, ImplicitIsBox) };
enum { dofCodim = isBox ? dim : 0 };
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("Kxx",
[this](const VolumeVariables& v){ return this->perm_(v.permeability())[0][0]; });
if (dim >= 2)
vtkOutputModule.addSecondaryVariable("Kyy",
[this](const VolumeVariables& v){ return this->perm_(v.permeability())[1][1]; });
if (dim >= 3)
vtkOutputModule.addSecondaryVariable("Kzz",
[this](const VolumeVariables& v){ return this->perm_(v.permeability())[2][2]; });
vtkOutputModule.addSecondaryVariable("permeabilityFactor", [](const VolumeVariables& v)
{ return v.permeabilityFactor(); });
for (int sPhaseIdx = 0; sPhaseIdx < numSPhases; ++sPhaseIdx)
vtkOutputModule.addSecondaryVariable("precipitateVolumeFraction_" + FluidSystem::phaseName(numPhases + sPhaseIdx),
[sPhaseIdx](const VolumeVariables& v)
{ return v.precipitateVolumeFraction(numPhases + sPhaseIdx); });
}
/*!
* \brief Write the current solution to a restart file.
*
* \param outStream The output stream of one entity for the restart file
* \param entity The entity, either a vertex or an element
*/
template<class Entity>
void serializeEntity(std::ostream &outStream, const Entity &entity)
{
// write primary variables
ParentType::serializeEntity(outStream, entity);
int dofIdxGlobal = this->dofMapper().index(entity);
if (!outStream.good())
DUNE_THROW(Dune::IOError, "Could not serialize entity " << dofIdxGlobal);
}
/*!
* \brief Reads the current solution from a restart file.
*
* \param inStream The input stream of one entity from the restart file
* \param entity The entity, either a vertex or an element
*/
template<class Entity>
void deserializeEntity(std::istream &inStream, const Entity &entity)
{
// read primary variables
ParentType::deserializeEntity(inStream, entity);
// read phase presence
int dofIdxGlobal = this->dofMapper().index(entity);
if (!inStream.good())
DUNE_THROW(Dune::IOError, "Could not deserialize entity " << dofIdxGlobal);
}
private:
Tensor perm_(Scalar perm) const
{
Tensor K(0.0);
for(int i=0; i<dimWorld; i++)
K[i][i] = perm;
return K;
}
const Tensor& perm_(const Tensor& perm) const
{
return perm;
}
};
} // end namespace Dumux
#include "propertydefaults.hh"
#endif
// -**- 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 OnePNCMinModel
*
* \file
*
* \brief Defines the properties required for the one-phase n-component mineralization
* fully implicit model.
*/
#ifndef DUMUX_1PNCMIN_PROPERTIES_HH
#define DUMUX_1PNCMIN_PROPERTIES_HH
#include <dumux/porousmediumflow/1pnc/model.hh>
namespace Dumux {
namespace Properties {
//////////////////////////////////////////////////////////////////
// Type tags
//////////////////////////////////////////////////////////////////
//! The type tag for the isothermal two phase n component mineralisation problems
NEW_TYPE_TAG(OnePNCMin, INHERITS_FROM(OnePNC));
NEW_TYPE_TAG(BoxOnePNCMin, INHERITS_FROM(BoxModel, OnePNCMin));
NEW_TYPE_TAG(CCOnePNCMin, INHERITS_FROM(CCModel, OnePNCMin));
//! The type tags for the corresponding non-isothermal problems
NEW_TYPE_TAG(OnePNCMinNI, INHERITS_FROM(OnePNCMin, NonIsothermal));
NEW_TYPE_TAG(BoxOnePNCMinNI, INHERITS_FROM(BoxModel, OnePNCMinNI));
NEW_TYPE_TAG(CCOnePNCMinNI, INHERITS_FROM(CCModel, OnePNCMinNI));
//////////////////////////////////////////////////////////////////
// Property tags
//////////////////////////////////////////////////////////////////
NEW_PROP_TAG(NumSPhases); //!< Number of solid phases in the system
NEW_PROP_TAG(NumFSPhases); //!< Number of fluid and solid phases in the system
NEW_PROP_TAG(NumSComponents); //!< Number of solid components in the system
NEW_PROP_TAG(NumPSComponents); //!< Number of fluid and solid components in the system
NEW_PROP_TAG(NumTraceComponents); //!< Number of trace fluid components which are not considered in the calculation of the phase density
NEW_PROP_TAG(NumSecComponents); //!< Number of secondary components which are not primary variables
NEW_PROP_TAG(OnePNCMinIndices); //!< Enumerations for the 2pncMin models
NEW_PROP_TAG(SpatialParamsForchCoeff); //!< Property for the forchheimer coefficient
}
}
#endif
// -**- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*****************************************************************************