mirror of
https://github.com/OPM/opm-simulators.git
synced 2025-02-25 18:55:30 -06:00
8e0e9e9d31
"intensive" means that the value of these quantities at a given spatial location does not depend on any value of the neighboring intensive quantities. In contrast, "extensive" quantities depend in the intensive quantities of the environment of the spatial location. this change is necessary is because the previous nomenclature was very specific to finite volume discretizations, but the models themselves were already rather generic. (i.e., "volume variables" are the intensive quantities of finite volume methods and "flux variables" are the extensive ones.)
286 lines
8.8 KiB
C++
286 lines
8.8 KiB
C++
/*
|
|
Copyright (C) 2009-2013 by Andreas Lauser
|
|
|
|
This file is part of the Open Porous Media project (OPM).
|
|
|
|
OPM 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.
|
|
|
|
OPM 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 OPM. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
/*!
|
|
* \file
|
|
* \copydoc Ewoms::Stokes2cTestProblem
|
|
*/
|
|
#ifndef EWOMS_STOKES_2C_TEST_PROBLEM_HH
|
|
#define EWOMS_STOKES_2C_TEST_PROBLEM_HH
|
|
|
|
#include <ewoms/models/stokes/stokesmodel.hh>
|
|
#include <opm/material/fluidsystems/H2OAirFluidSystem.hpp>
|
|
|
|
#include <dune/grid/yaspgrid.hh>
|
|
|
|
#include <dune/common/version.hh>
|
|
#include <dune/common/fvector.hh>
|
|
|
|
namespace Ewoms {
|
|
template <class TypeTag>
|
|
class Stokes2cTestProblem;
|
|
}
|
|
|
|
namespace Opm {
|
|
//////////
|
|
// Specify the properties for the stokes2c problem
|
|
//////////
|
|
namespace Properties {
|
|
NEW_TYPE_TAG(Stokes2cTestProblem, INHERITS_FROM(StokesModel));
|
|
|
|
// Set the grid type
|
|
SET_TYPE_PROP(Stokes2cTestProblem, Grid, Dune::YaspGrid<2>);
|
|
|
|
// Set the problem property
|
|
SET_TYPE_PROP(Stokes2cTestProblem, Problem, Ewoms::Stokes2cTestProblem<TypeTag>);
|
|
|
|
//! Select the fluid system
|
|
SET_TYPE_PROP(Stokes2cTestProblem, FluidSystem,
|
|
Opm::FluidSystems::H2OAir<typename GET_PROP_TYPE(TypeTag, Scalar)>);
|
|
|
|
//! Select the phase to be considered
|
|
SET_INT_PROP(Stokes2cTestProblem, StokesPhaseIndex,
|
|
GET_PROP_TYPE(TypeTag, FluidSystem)::gasPhaseIdx);
|
|
|
|
// Disable gravity
|
|
SET_BOOL_PROP(Stokes2cTestProblem, EnableGravity, false);
|
|
|
|
// Enable constraints
|
|
SET_BOOL_PROP(Stokes2cTestProblem, EnableConstraints, true);
|
|
|
|
// Default simulation end time [s]
|
|
SET_SCALAR_PROP(Stokes2cTestProblem, EndTime, 2.0);
|
|
|
|
// Default initial time step size [s]
|
|
SET_SCALAR_PROP(Stokes2cTestProblem, InitialTimeStepSize, 0.1);
|
|
|
|
// Default grid file to load
|
|
SET_STRING_PROP(Stokes2cTestProblem, GridFile, "data/test_stokes2c.dgf");
|
|
} // namespace Properties
|
|
} // namespace Opm
|
|
|
|
namespace Ewoms {
|
|
/*!
|
|
* \ingroup Stokes2cModel
|
|
* \ingroup VcfvTestProblems
|
|
*
|
|
* \brief Stokes transport problem with humid air flowing from the
|
|
* left to the right.
|
|
*
|
|
* The domain is sized 1m times 1m. The boundaries are specified using
|
|
* constraints, with finite volumes on the left side of the domain
|
|
* exhibiting slightly higher humitiy than the ones on the right.
|
|
*/
|
|
template <class TypeTag>
|
|
class Stokes2cTestProblem : public GET_PROP_TYPE(TypeTag, BaseProblem)
|
|
{
|
|
typedef typename GET_PROP_TYPE(TypeTag, BaseProblem) ParentType;
|
|
typedef typename GET_PROP_TYPE(TypeTag, GridView) GridView;
|
|
typedef typename GET_PROP_TYPE(TypeTag, Simulator) Simulator;
|
|
typedef typename GET_PROP_TYPE(TypeTag, Indices) Indices;
|
|
typedef typename GET_PROP_TYPE(TypeTag, FluidSystem) FluidSystem;
|
|
typedef typename GET_PROP_TYPE(TypeTag, BoundaryRateVector) BoundaryRateVector;
|
|
typedef typename GET_PROP_TYPE(TypeTag, RateVector) RateVector;
|
|
typedef typename GET_PROP_TYPE(TypeTag, PrimaryVariables) PrimaryVariables;
|
|
typedef typename GET_PROP_TYPE(TypeTag, Constraints) Constraints;
|
|
typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
|
|
typedef typename GET_PROP_TYPE(TypeTag, Model) Model;
|
|
|
|
enum { dimWorld = GridView::dimensionworld };
|
|
enum { numComponents = FluidSystem::numComponents };
|
|
enum {
|
|
// copy some indices for convenience
|
|
conti0EqIdx = Indices::conti0EqIdx,
|
|
momentum0EqIdx = Indices::momentum0EqIdx,
|
|
velocity0Idx = Indices::velocity0Idx,
|
|
moleFrac1Idx = Indices::moleFrac1Idx,
|
|
pressureIdx = Indices::pressureIdx,
|
|
H2OIdx = FluidSystem::H2OIdx,
|
|
AirIdx = FluidSystem::AirIdx
|
|
};
|
|
|
|
typedef typename GridView::ctype CoordScalar;
|
|
typedef Dune::FieldVector<CoordScalar, dimWorld> GlobalPosition;
|
|
|
|
public:
|
|
/*!
|
|
* \copydoc Doxygen::defaultProblemConstructor
|
|
*/
|
|
Stokes2cTestProblem(Simulator &simulator)
|
|
: ParentType(simulator)
|
|
{
|
|
eps_ = 1e-6;
|
|
|
|
// initialize the tables of the fluid system
|
|
FluidSystem::init();
|
|
}
|
|
|
|
/*!
|
|
* \name Problem parameters
|
|
*/
|
|
//! \{
|
|
|
|
/*!
|
|
* \copydoc VcfvProblem::name
|
|
*/
|
|
std::string name() const
|
|
{ return "stokes2ctest"; }
|
|
|
|
/*!
|
|
* \brief StokesProblem::temperature
|
|
*
|
|
* This problem assumes a temperature of 10 degrees Celsius.
|
|
*/
|
|
template <class Context>
|
|
Scalar temperature(const Context &context, int spaceIdx, int timeIdx) const
|
|
{ return 273.15 + 10; /* -> 10 deg C */ }
|
|
|
|
// \}
|
|
|
|
/*!
|
|
* \name Boundary conditions
|
|
*/
|
|
//! \{
|
|
|
|
/*!
|
|
* \copydoc VcfvProblem::boundary
|
|
*
|
|
* This problem uses an out-flow boundary on the lower edge of the
|
|
* domain, no-flow on the left and right edges and constrains the
|
|
* upper edge.
|
|
*/
|
|
template <class Context>
|
|
void boundary(BoundaryRateVector &values, const Context &context,
|
|
int spaceIdx, int timeIdx) const
|
|
{
|
|
const GlobalPosition &pos = context.pos(spaceIdx, timeIdx);
|
|
|
|
if (onLowerBoundary_(pos))
|
|
values.setOutFlow(context, spaceIdx, timeIdx);
|
|
else if (onUpperBoundary_(pos)) {
|
|
// upper boundary is constraint!
|
|
values = 0.0;
|
|
}
|
|
else {
|
|
// left and right boundaries
|
|
values.setNoFlow(context, spaceIdx, timeIdx);
|
|
}
|
|
}
|
|
|
|
//! \}
|
|
|
|
/*!
|
|
* \name Volumetric terms
|
|
*/
|
|
//! \{
|
|
|
|
/*!
|
|
* \copydoc VcfvProblem::initial
|
|
*
|
|
* For this method a parabolic velocity profile from left to
|
|
* right, atmospheric pressure and a mole fraction of water of
|
|
* 0.5% is set.
|
|
*/
|
|
template <class Context>
|
|
void initial(PrimaryVariables &values, const Context &context, int spaceIdx,
|
|
int timeIdx) const
|
|
{
|
|
const GlobalPosition &globalPos = context.pos(spaceIdx, timeIdx);
|
|
values = 0.0;
|
|
|
|
// parabolic profile
|
|
const Scalar v1 = 1.0;
|
|
values[velocity0Idx + 1] =
|
|
- v1
|
|
* (globalPos[0] - this->boundingBoxMin()[0])
|
|
* (this->boundingBoxMax()[0] - globalPos[0])
|
|
/ (0.25
|
|
* (this->boundingBoxMax()[0] - this->boundingBoxMin()[0])
|
|
* (this->boundingBoxMax()[0] - this->boundingBoxMin()[0]));
|
|
|
|
Scalar moleFrac[numComponents];
|
|
if (onUpperBoundary_(globalPos))
|
|
moleFrac[H2OIdx] = 0.005;
|
|
else
|
|
moleFrac[H2OIdx] = 0.007;
|
|
moleFrac[AirIdx] = 1.0 - moleFrac[H2OIdx];
|
|
|
|
values[pressureIdx] = 1e5;
|
|
values[velocity0Idx + 0] = 0.0;
|
|
values[moleFrac1Idx] = moleFrac[1];
|
|
}
|
|
|
|
/*!
|
|
* \copydoc VcfvProblem::source
|
|
*
|
|
* For this problem, the source term of all conserved quantities
|
|
* is 0 everywhere.
|
|
*/
|
|
template <class Context>
|
|
void source(RateVector &rate, const Context &context, int spaceIdx,
|
|
int timeIdx) const
|
|
{ rate = Scalar(0.0); }
|
|
|
|
/*!
|
|
* \copydoc VcfvProblem::constraints
|
|
*
|
|
* In this problem, the method sets the domain's lower edge to
|
|
* initial conditions.
|
|
*/
|
|
template <class Context>
|
|
void constraints(Constraints &constraints, const Context &context,
|
|
int spaceIdx, int timeIdx) const
|
|
{
|
|
const auto &pos = context.pos(spaceIdx, timeIdx);
|
|
|
|
if (onUpperBoundary_(pos)) {
|
|
PrimaryVariables initCond;
|
|
initial(initCond, context, spaceIdx, timeIdx);
|
|
|
|
constraints.setConstraint(pressureIdx, conti0EqIdx,
|
|
initCond[pressureIdx]);
|
|
;
|
|
constraints.setConstraint(moleFrac1Idx, conti0EqIdx + 1,
|
|
initCond[moleFrac1Idx]);
|
|
for (int axisIdx = 0; axisIdx < dimWorld; ++axisIdx)
|
|
constraints.setConstraint(velocity0Idx + axisIdx,
|
|
momentum0EqIdx + axisIdx,
|
|
initCond[velocity0Idx + axisIdx]);
|
|
}
|
|
}
|
|
//! \}
|
|
|
|
private:
|
|
bool onLeftBoundary_(const GlobalPosition &globalPos) const
|
|
{ return globalPos[0] < this->boundingBoxMin()[0] + eps_; }
|
|
|
|
bool onRightBoundary_(const GlobalPosition &globalPos) const
|
|
{ return globalPos[0] > this->boundingBoxMax()[0] - eps_; }
|
|
|
|
bool onLowerBoundary_(const GlobalPosition &globalPos) const
|
|
{ return globalPos[1] < this->boundingBoxMin()[1] + eps_; }
|
|
|
|
bool onUpperBoundary_(const GlobalPosition &globalPos) const
|
|
{ return globalPos[1] > this->boundingBoxMax()[1] - eps_; }
|
|
|
|
Scalar eps_;
|
|
};
|
|
} // namespace Ewoms
|
|
|
|
#endif
|