porousmediumflow/2p2c/sequential/problem.hh

Go to the documentation of this file.

// -*- 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 3 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/>.   *
 *****************************************************************************/
#ifndef DUMUX_IMPETPROBLEM_2P2C_HH
#define DUMUX_IMPETPROBLEM_2P2C_HH
 
#include <dumux/porousmediumflow/2p/sequential/impes/problem.hh>
#include <dumux/porousmediumflow/sequential/variableclass.hh>
#include <dumux/porousmediumflow/2p2c/sequential/properties.hh>
 
 
namespace Dumux {
template<class TypeTag>
class IMPETProblem2P2C : public IMPESProblem2P<TypeTag>
{
    using ParentType = IMPESProblem2P<TypeTag>;
    using Implementation = GetPropType<TypeTag, Properties::Problem>;
    using TimeManager = GetPropType<TypeTag, Properties::TimeManager>;
    using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
 
    using GridView = typename GetPropType<TypeTag, Properties::GridGeometry>::GridView;
    using Grid = typename GridView::Grid;
    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 
    using Element = typename GridView::Traits::template Codim<0>::Entity;
 
    // material properties
    using SpatialParams = GetPropType<TypeTag, Properties::SpatialParams>;
 
    enum
    {
        adaptiveGrid = getPropValue<TypeTag, Properties::AdaptiveGrid>()
    };
    enum {
        dimWorld = Grid::dimensionworld
    };
 
    using GlobalPosition = Dune::FieldVector<Scalar, dimWorld>;
 
public:
    IMPETProblem2P2C(TimeManager& timeManager, Grid& grid)
    : IMPETProblem2P2C(timeManager, grid, grid.leafGridView())
    {}
 
    IMPETProblem2P2C(TimeManager &timeManager, Grid& grid, const GridView& gridView)
        : ParentType(timeManager, grid, gridView)
    { }
    IMPETProblem2P2C(TimeManager &timeManager, Grid& grid, SpatialParams &spatialParams)
        : ParentType(timeManager, grid, spatialParams)
    { }
 
    void preTimeStep()
    {
        // if adaptivity is used, this method adapts the grid.
        // if it is not used, this method does nothing.
        if (this->adaptiveGrid)
        {
            this->gridAdapt().adaptGrid();
 
            if(this->gridAdapt().wasAdapted())
                asImp_().pressureModel().updateMaterialLaws(false);
        }
    }
    void postTimeStep()
    {
        ParentType::postTimeStep();
        asImp_().pressureModel().updateMaterialLaws(true);
    }
    // \{
 
    Scalar initSat(const Element& element) const
    {
        return asImp_().initSatAtPos(element.geometry().center());
    }
 
    Scalar initSatAtPos(const GlobalPosition& globalPos) const
    {
        DUNE_THROW(Dune::NotImplemented, "please specify initial saturation in the problem"
                                            " using an initSatAtPos() method!");
        return NAN;
    }
 
    Scalar initConcentration(const Element& element) const
    {
        return asImp_().initConcentrationAtPos(element.geometry().center());
    }
 
    Scalar initConcentrationAtPos(const GlobalPosition& globalPos) const
    {
        DUNE_THROW(Dune::NotImplemented, "please specify initial Concentration in the problem"
                                            " using an initConcentrationAtPos() method!");
    }
    // \}
 
private:
    Implementation &asImp_()
    { return *static_cast<Implementation *>(this); }
 
    const Implementation &asImp_() const
    { return *static_cast<const Implementation *>(this); }
 
protected:
    void setZero(GetPropType<TypeTag, Properties::PrimaryVariables> &values, const int equation = -1) const
    {
        if (equation == Indices::pressureEqIdx)
        {
            values[Indices::pressureEqIdx] = 0.;
        }
        else if(equation == Indices::contiNEqIdx)
            values[Indices::contiNEqIdx] =0.;
        else if(equation == Indices::contiWEqIdx)
            values[Indices::contiWEqIdx] =0.;
        else if (equation == -1)
        {
            // set everything to zero
            for (unsigned int i = 0; i < values.size(); i++)
                values[i] = 0.;
        }
        else
            DUNE_THROW(Dune::InvalidStateException, "vector of primary variables can not be set properly");
    }
};
 
} // end namespace Dumux
 
#endif