Commit b45c57ac authored by Thomas Fetzer's avatar Thomas Fetzer
Browse files

[freeflow]

- added individual headers for boundary layer and mass transfer models, which were implemented in the couplinglocaloperator

[multidomain]
- uses above mentioned new header and classes
- improved own start function, especially the usage function
- updated parts of the reference solutions, due to marginal deviations

[implicit]
- added convenience function for the viscosity in the 2p2c model 


git-svn-id: svn://svn.iws.uni-stuttgart.de/DUMUX/dumux/trunk@14743 2fb0f335-1f38-0410-981e-8018bf24f1b0
parent 366f309d
// -*- 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 files contains a class to calculate the boundary layer thickness
* of a free flow based on analytical and empirical approaches.
*/
#ifndef DUMUX_BOUNDARY_LAYER_MODEL_HH
#define DUMUX_BOUNDARY_LAYER_MODEL_HH
#include <cassert>
#include <dumux/common/basicproperties.hh>
#include <dumux/common/parameters.hh>
namespace Dumux
{
/*!
* \brief This is a class to calculate the boundary layer thickness
* of a free flow based on analytical and empirical approaches.
*/
template <class TypeTag>
class BoundaryLayerModel
{
typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
/*!
* \brief This is a class to calculate the boundary layer thickness
* of a free flow based on analytical and empirical approaches.
*
* \param velocity Mean Free Flow Velocity
* \param distance Distance to the current location (including artificial run-up lengths)
* \param kinematicViscosity Kinematic viscosity of the free fluid
* \param boundaryLayerModel The index of the chosen boundary layer model
*/
public:
BoundaryLayerModel(const Scalar velocity, const Scalar distance,
const Scalar kinematicViscosity, unsigned int boundaryLayerModel)
: velocity_(velocity), distance_(distance), kinematicViscosity_(kinematicViscosity),
boundaryLayerModel_(boundaryLayerModel)
{
// distance has to be positive, that the boundary layer can not be zero
assert (distance_ > 1e-10);
constThickness_ = 0.0; // dummy default
roughnessLength_ = 0.0; // dummy default
yPlus_ = 5.0; // end of viscous sublayer
}
//! \brief Sets the constant boundary layer thickness \f$[m]\f$.
void setConstThickness(Scalar constThickness)
{ constThickness_ = constThickness; }
//! \brief Sets the roughness length \f$[m]\f$.
void setRoughnessLength(Scalar roughnessLength)
{ roughnessLength_ = roughnessLength; }
//! \brief Sets the \f$ y^+\f$-value \f$[-]\f$.
void setYPlus(Scalar yPlus)
{ yPlus_ = yPlus; }
//! \brief Returns the Reynolds number
const Scalar reynoldsNumber()
{ return velocity_ * distance_ / kinematicViscosity_; }
/*!
* \brief Returns the momentum boundary layer thickness of the flow.
*
* Different models for the approximation of the boundary layer thickness are available:<br>
* 0 = no boundary layer model<br>
* 1 = constant boundary layer thickness, which can be set in the parameter file<br>
* 2 = laminar: Blasius' analytical solution<br>
* 3 = turbulent (smooth);<br>
* 4 = viscous sublayer (smooth); after Schultz-Grunow<br>
* 5 = viscous sublayer (smooth); after Truckenbrodt<br>
* 6 = viscous sublayer (rough); after Truckenbrodt<br>
*/
const Scalar viscousBoundaryLayerThickness()
{
Scalar reynoldsX = reynoldsNumber();
// no boundary layer model
if (boundaryLayerModel_ == 0)
{
// has to be empty for the multidomain models
}
// Constant Boundary Layer Thickness
else if (boundaryLayerModel_ == 1)
{
// boundary layer thickness has to be positive
assert (constThickness_ > 1e-10);
return constThickness_;
}
// laminar: Blasius (analytical solution)
else if (boundaryLayerModel_ == 2)
{
return 5.0 * distance_ / std::sqrt(reynoldsX);
}
// turbulent, smooth: turbulent boundary layer thickness
// source: http://en.wikipedia.org/wiki/Boundary_layer_thickness
else if (boundaryLayerModel_ == 3)
{
return 0.37 * distance_ / std::pow(reynoldsX, 0.2);
}
// turbulent, smooth: viscous sublayer thickness via friction coefficient (after Schultz-Grunow)
// source: Pope, S. B. Turbulent flows Cambridge University Press, 2006, XXXIV, p. 307
else if (boundaryLayerModel_ == 4)
{
Scalar cf = 0.37 * std::pow(std::log10(reynoldsX), -2.584);
return yPlus_ * distance_ / (reynoldsX * std::sqrt(cf / 2.0));
}
// turbulent, rough: viscous sublayer thickness via friction coefficient
// source: Truckenbrodt, E. Elementare Strömungsvorgänge dichteveränderlicher Fluide Fluidmechanik,
// Springer Berlin Heidelberg, 2008, doi: 10.1007/978-3-540-79024-2_1, p. 333
else if (boundaryLayerModel_ == 5)
{
// roughness length has to be positive
assert (roughnessLength_ > 1e-10);
// application is bounded to specific roughness length
assert (1e-6 < roughnessLength_ / distance_ && roughnessLength_ / distance_ < 1e-2);
Scalar cf = std::pow(1.89 - 1.62 * std::log10(roughnessLength_ / distance_), -2.5);
return yPlus_ * distance_ / (reynoldsX * std::sqrt(cf / 2.0));
}
// turbulent, rough: viscous sublayer thickness via friction coefficient
// source: Truckenbrodt, E. Elementare Strömungsvorgänge dichteveränderlicher Fluide Fluidmechanik,
// Springer Berlin Heidelberg, 2008, doi: 10.1007/978-3-540-79024-2_1, p. 333
else if (boundaryLayerModel_ == 6)
{
// roughness length has to be positive
assert (roughnessLength_ > 1e-10);
Scalar cf = 0.024 * std::pow(roughnessLength_ / distance_, 1.0/6.0);
return yPlus_ * distance_ / (reynoldsX * std::sqrt(cf / 2.0));
}
else
DUNE_THROW(Dune::NotImplemented, "This boundary layer model is not implemented");
return 0.0;
}
/*!
* \brief Convenience function to return the mass boundary layer thickness
*
* The mass and momentum boundary layer thickness could different.
*/
const Scalar massBoundaryLayerThickness()
{ return viscousBoundaryLayerThickness(); }
/*!
* \brief Convenience function to return the thermal boundary layer thickness
*
* The thermal and momentum boundary layer thickness could different.
*/
const Scalar thermalBoundaryLayerThickness()
{ return viscousBoundaryLayerThickness(); }
private:
Scalar velocity_;
Scalar distance_;
Scalar kinematicViscosity_;
unsigned int boundaryLayerModel_;
Scalar constThickness_;
Scalar yPlus_;
Scalar roughnessLength_;
};
} //end namespace
#endif // DUMUX_BOUNDARY_LAYER_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 This files contains a class to adapt the mass transfer in the
* boundary layer of the free flow, near to a porous-interface.
*/
#ifndef DUMUX_MASS_TRANSFER_MODEL_HH
#define DUMUX_MASS_TRANSFER_MODEL_HH
#include <dumux/common/basicproperties.hh>
#include <dumux/common/parameters.hh>
namespace Dumux
{
/*!
* \brief This files contains a class to adapt the mass transfer in the
* boundary layer of the free flow, near to a porous-interface.
*/
template <class TypeTag>
class MassTransferModel
{
typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
/*!
* \brief This files contains a class to adapt the mass transfer in the
* boundary layer of the free flow, near to a porous-interface.
*
* \param saturation Saturation of the component's phase inside the porous medium
* \param porosity Porosity of the porous medium
* \param charPoreRadius Characteristic pore radius of the porous medium
* \param blThickness Free flow boundary layer thickness
* \param massTransferModel The index of the chosen mass transfer model
*/
public:
MassTransferModel(Scalar saturation, Scalar porosity, Scalar charPoreRadius,
Scalar blThickness, unsigned int massTransferModel)
: saturation_(saturation), porosity_(porosity), charPoreRadius_(charPoreRadius),
blThickness_(blThickness), massTransferModel_(massTransferModel)
{
moistureContent_ = saturation_ * porosity_;
massTransferCoeff_ = 0.0; // dummy default
capillaryPressure_ = 1e10; // dummy default
}
//! \brief Sets a mass transfer coefficient \f$[-]\f$.
void setMassTransferCoeff(Scalar massTransferCoeff)
{ massTransferCoeff_ = massTransferCoeff; }
//! \brief Sets the capillary pressure \f$[Pa]\f$.
void setCapillaryPressure(Scalar capillaryPressure)
{ capillaryPressure_ = capillaryPressure; }
/*!
* \brief Returns a mass transfer coefficient to weaken to diffusive mass transfer
* in vicinity of a porous surface.
*
* Provides different options for the determining the mass transfer coefficient:<br>
* 0) no mass transfer model<br>
* 1) exponential law with a saturation as base and a mass transfer coefficient as exponent<br>
* 2) the conventional Schlünder model with one characteristic pore size<br>
* 3) the Schlünder model with a variable characteristic pore size deduced from the
* two-phase relations (Van Genuchten curve)<br>
* 4) a manually adapted Schlünder model
*/
const Scalar massTransferCoefficient()
{
// no mass transfer model
if (massTransferModel_ == 0)
{
// has to be empty for the multidomain models
}
// exponential mass transfer law
else if (massTransferModel_ == 1)
{
// use meaningful transfer coefficients
assert (0 < massTransferCoeff_ && massTransferCoeff_ < 1.0);
return std::pow(saturation_, massTransferCoeff_);
}
// Schlünder model (Schlünder, CES 1988)
else if (massTransferModel_ == 2)
{
Scalar charPoreRadius = charPoreRadius_;
Scalar massTransferCoeff = 1. + 2./M_PI * charPoreRadius / blThickness_
* std::sqrt(M_PI/(4.*moistureContent_))
* (std::sqrt(M_PI/(4.*moistureContent_)) - 1.);
return 1./massTransferCoeff;
}
// Schlünder model (Schlünder, CES 1988) with variable char. pore diameter depending on Pc
else if (massTransferModel_ == 3)
{
// check if capillary pressure was set
assert (capillaryPressure_ < 9e9);
Scalar surfaceTension = 72.85e-3; // source: Wikipedia
Scalar charPoreRadius = 2 * surfaceTension / capillaryPressure_;
Scalar massTransferCoeff = 1. + 2./M_PI * charPoreRadius / blThickness_
* std::sqrt(M_PI/(4.*moistureContent_))
* (std::sqrt(M_PI/(4.*moistureContent_)) - 1.);
return 1./massTransferCoeff;
}
// modified Schlünder model
else if (massTransferModel_ == 4)
{
Scalar charPoreRadius = charPoreRadius_;
Scalar massTransferCoeff = 1. + 2./M_PI * charPoreRadius / blThickness_
* (1./moistureContent_) * (1./moistureContent_ - 1.);
return 1./massTransferCoeff;
}
else
DUNE_THROW(Dune::NotImplemented, "This mass transfer model is not implemented");
return 1.0;
}
private:
Scalar saturation_;
Scalar porosity_;
Scalar moistureContent_;
Scalar charPoreRadius_;
Scalar blThickness_;
unsigned int massTransferModel_;
Scalar massTransferCoeff_;
Scalar capillaryPressure_;
};
} //end namespace
#endif // DUMUX_MASS_TRANSFER_MODEL_HH
......@@ -532,6 +532,15 @@ public:
Scalar density(const int phaseIdx) const
{ return fluidState_.density(phaseIdx); }
/*!
* \brief Returns the dynamic viscosity of the fluid within the
* control volume in \f$\mathrm{[Pa s]}\f$.
*
* \param phaseIdx The phase index
*/
Scalar viscosity(const int phaseIdx) const
{ return fluidState_.viscosity(phaseIdx); }
/*!
* \brief Returns the mass density of a given phase within the
* control volume in \f$[mol/m^3]\f$.
......
......@@ -34,9 +34,12 @@
#include <dumux/multidomain/common/multidomainproperties.hh>
#include <dumux/multidomain/2cstokes2p2c/2cstokes2p2cpropertydefaults.hh>
#include <dumux/freeflow/boundarylayermodel.hh>
#include <dumux/freeflow/masstransfermodel.hh>
#include <dumux/freeflow/stokesnc/stokesncmodel.hh>
#include <dumux/implicit/2p2c/2p2cmodel.hh>
namespace Dumux {
/*!
......@@ -130,8 +133,8 @@ class TwoCStokesTwoPTwoCLocalOperator :
TwoCStokesTwoPTwoCLocalOperator(GlobalProblem& globalProblem)
: globalProblem_(globalProblem)
{
blModel_ = GET_PARAM_FROM_GROUP(TypeTag, int, FreeFlow, BoundaryLayerModel);
massTransferModel_ = GET_PARAM_FROM_GROUP(TypeTag, int, FreeFlow, MassTransferModel);
blModel_ = GET_PARAM_FROM_GROUP(TypeTag, int, BoundaryLayer, Model);
massTransferModel_ = GET_PARAM_FROM_GROUP(TypeTag, int, MassTransfer, Model);
if (blModel_ != 0)
std::cout << "Using boundary layer model " << blModel_ << std::endl;
......@@ -366,9 +369,19 @@ class TwoCStokesTwoPTwoCLocalOperator :
cParams.elemVolVarsCur1[vertInElem1].moleFraction(transportCompIdx1) -
moleFractionOut;
// multiplied by the Schmidt number^(1/3)
const Scalar deltaMassBL = computeBoundaryLayerThickness(cParams, globalPos1, vertInElem1);
normalMoleFracGrad /= deltaMassBL;
const Scalar velocity = GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, FreeFlow, RefVelocity);
// current position + additional virtual runup distance
const Scalar distance = globalPos1[0] + GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, BoundaryLayer, Offset);
const Scalar kinematicViscosity = cParams.elemVolVarsCur1[vertInElem2].kinematicViscosity();
BoundaryLayerModel<TypeTag> boundaryLayerModel(velocity, distance, kinematicViscosity, blModel_);
if (blModel_ == 1)
boundaryLayerModel.setConstThickness(GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, BoundaryLayer, ConstThickness));
if (blModel_ >= 4)
boundaryLayerModel.setYPlus(GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, BoundaryLayer, YPlus));
if (blModel_ >= 5)
boundaryLayerModel.setRoughnessLength(GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, BoundaryLayer, RoughnessLength));
normalMoleFracGrad /= boundaryLayerModel.massBoundaryLayerThickness();
const Scalar diffusiveFlux =
bfNormal1.two_norm() *
......@@ -386,12 +399,20 @@ class TwoCStokesTwoPTwoCLocalOperator :
// when saturations become small; only diffusive fluxes are scaled!
else
{
const Scalar massTransferCoeff = massTransferCoefficient(cParams, sdElement1, sdElement2, globalPos1,
vertInElem1, vertInElem2);
MassTransferModel<TypeTag> massTransferModel(cParams.elemVolVarsCur2[vertInElem2].saturation(wPhaseIdx2),
cParams.elemVolVarsCur2[vertInElem2].porosity(),
GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, MassTransfer, CharPoreDiameter),
boundaryLayerModel.massBoundaryLayerThickness(),
massTransferModel_);
if (massTransferModel_ == 1)
massTransferModel.setMassTransferCoeff(GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, MassTransfer, Coefficient));
if (massTransferModel_ == 3)
massTransferModel.setCapillaryPressure(cParams.elemVolVarsCur2[vertInElem2].capillaryPressure());
const Scalar massTransferCoeff = massTransferModel.massTransferCoefficient();
if (massTransferCoeff > 1.0 || massTransferCoeff < 0.0)
std::cout << "MTC out of bounds, should be in between 0.0 and 1.0! >>> " << massTransferCoeff << std::endl;
if (globalProblem_.sdProblem1().isCornerPoint(globalPos1))
{
const Scalar diffusiveFluxAtCorner =
......@@ -517,113 +538,6 @@ class TwoCStokesTwoPTwoCLocalOperator :
}
protected:
/*!
* \brief allows to choose the approximation of the boundary layer thickness:<br>
* 1) Blasius solution<br>
* 2) and 3) approximations of a turbulent boundary layer<br>
* 9) constant boundary layer thickness, which can be set in the parameter file
*/
template<typename CParams>
const Scalar computeBoundaryLayerThickness(const CParams& cParams,
const DimVector& globalPos,
const int vertexIdx) const
{
const Scalar vxmax = GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, FreeFlow, VxMax);
const Scalar boundaryLayerOffset = GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, FreeFlow, BoundaryLayerOffset);
const Scalar distance = globalPos[0]+boundaryLayerOffset;
Scalar reynoldsX = vxmax * distance * cParams.elemVolVarsCur1[vertexIdx].fluidState().density(nPhaseIdx1)
/ cParams.elemVolVarsCur1[vertexIdx].fluidState().viscosity(nPhaseIdx1);
if (blModel_ == 1)
{
return 5.0 * distance / std::sqrt(reynoldsX);
}
if (blModel_ == 2)
{
return 0.37 * distance / std::pow(reynoldsX, 0.2);
}
if (blModel_ == 3)
{
const Scalar cf = 2*std::pow(0.41*1.5/std::log(reynoldsX),2);
return 50.0 * distance / (reynoldsX * std::sqrt(cf/2.0));
}
if (blModel_ == 9)
{
if (ParameterTree::tree().hasKey("FreeFlow.ConstThickness"))
return GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, FreeFlow, ConstThickness);
else
std::cerr << "FreeFlow.ConstThickness not defined\n";
}
else
std::cerr << "invalid boundary layer model\n";
return 0;
}
/*!
* \brief Provides different options for the computations of the mass transfer coefficient:<br>
* 1) exponential law with a saturation as base and a mass transfer coefficient as exponent<br>
* 2) the conventional Schlünder model with one characteristic pore size<br>
* 3) the Schlünder model with a variable characteristic pore size deduced from the
* two-phase relations (Van Genuchten curve)
*/
template<typename CParams>
const Scalar massTransferCoefficient(const CParams &cParams,
const SDElement1& sdElement1, const SDElement2& sdElement2,
const DimVector& globalPos,
const int vertInElem1, const int vertInElem2) const
{
if (massTransferModel_ == 1)
{
Scalar exponentMTC = GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, FreeFlow, ExponentMTC);
return std::pow(cParams.elemVolVarsCur2[vertInElem2].saturation(wPhaseIdx2), exponentMTC);
}
// Schlünder model (Schlünder, CES 1988)
else if (massTransferModel_ == 2)
{
Scalar charPoreRadius = GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, PorousMedium, CharPoreDiameter);
const Scalar blThickness = computeBoundaryLayerThickness(cParams, globalPos, vertInElem1);
const Scalar moistureContent = cParams.elemVolVarsCur2[vertInElem2].saturation(wPhaseIdx2) *
globalProblem_.sdProblem2().spatialParams().porosity(sdElement2, cParams.fvGeometry2, vertInElem2);
Scalar massTransferCoeff = 1. + 2./M_PI * charPoreRadius/blThickness
* std::sqrt(M_PI/(4*moistureContent)) * (std::sqrt(M_PI/(4*moistureContent)) - 1.);
return 1./massTransferCoeff;
}
// Schlünder model (Schlünder, CES 1988) with variable char. pore diameter depending on Pc
else if (massTransferModel_ == 3)
{
const Scalar surfaceTension = 72.85e-3; // source: Wikipedia
const Scalar charPoreRadius = 2*surfaceTension/cParams.elemVolVarsCur2[vertInElem2].capillaryPressure();
const Scalar blThickness = computeBoundaryLayerThickness(cParams, globalPos, vertInElem1);
const Scalar moistureContent = cParams.elemVolVarsCur2[vertInElem2].saturation(wPhaseIdx2) *
globalProblem_.sdProblem2().spatialParams().porosity(sdElement2, cParams.fvGeometry2, vertInElem2);
Scalar massTransferCoeff = 1. + 2./M_PI * charPoreRadius/blThickness
* std::sqrt(M_PI/(4*moistureContent)) * (std::sqrt(M_PI/(4*moistureContent)) - 1.);
return 1./massTransferCoeff;
}
// modified Schlünder model
else if (massTransferModel_ == 4)
{
Scalar charPoreRadius = GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, PorousMedium, CharPoreDiameter);
const Scalar blThickness = computeBoundaryLayerThickness(cParams, globalPos, vertInElem1);
const Scalar moistureContent = cParams.elemVolVarsCur2[vertInElem2].saturation(wPhaseIdx2) *
globalProblem_.sdProblem2().spatialParams().porosity(sdElement2, cParams.fvGeometry2, vertInElem2);
Scalar massTransferCoeff = 1. + 2./M_PI * charPoreRadius/blThickness
* (1./moistureContent) * (1./moistureContent - 1.);
return 1./massTransferCoeff;
}
return 1.;
}
GlobalProblem& globalProblem() const
{ return globalProblem_; }
......@@ -649,9 +563,8 @@ class TwoCStokesTwoPTwoCLocalOperator :
FVElementGeometry2 fvGeometry2;
};
unsigned blModel_;
unsigned massTransferModel_;
Scalar exponentMTC_;
unsigned int blModel_;
unsigned int massTransferModel_;
GlobalProblem& globalProblem_;
};
......
......@@ -49,9 +49,8 @@ NEW_TYPE_TAG(TwoCStokesTwoPTwoC, INHERITS_FROM(MultiDomain));
//////////////////////////////////////////////////////////////////
// Property tags
//////////////////////////////////////////////////////////////////
NEW_PROP_TAG(FreeFlowBoundaryLayerModel); //!< Type of the used boundary layer model
NEW_PROP_TAG(FreeFlowMassTransferModel); //!< Type of the used mass transfer model
NEW_PROP_TAG(BoundaryLayerModel); //!< Type of the used boundary layer model
NEW_PROP_TAG(MassTransferModel); //!< Type of the used mass transfer model
} // end namespace properties
......
......@@ -68,11 +68,11 @@ SET_INT_PROP(TwoCStokesTwoPTwoC, NumEq, 1);
// Specitfy if the solutions of individual newton iterations should be written
SET_BOOL_PROP(TwoCStokesTwoPTwoC, NewtonWriteConvergence, false);
// 0 = none, 1 = Blasius, 2 and 3 = turbulent BL, 9 = constant thickness
SET_INT_PROP(TwoCStokesTwoPTwoC, FreeFlowBoundaryLayerModel, 0);
// Specify the used boundary layer model
SET_INT_PROP(TwoCStokesTwoPTwoC, BoundaryLayerModel, 0);
// 0 = none, 1 = power law, 2 = Schluender model mass transfer model
SET_INT_PROP(TwoCStokesTwoPTwoC, FreeFlowMassTransferModel, 0);
// Specify the used mass transfer model
SET_INT_PROP(TwoCStokesTwoPTwoC, MassTransferModel, 0);
} // end namespace properties
......
......@@ -28,6 +28,8 @@
#include <dune/common/parallel/mpihelper.hh>
#include <dune/common/parametertreeparser.hh>
#include <dumux/common/start.hh>
#include <dumux/io/interfacemeshcreator.hh>
#include "2cnistokes2p2cniproblem.hh"
......@@ -35,18 +37,38 @@
/*!
* \brief Print a usage string for simulations.
*
* \param progName The name of the executable
* \param progName The name of the program, that was tried to be started.