2p/sequential/celldata.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_ELEMENTDATA2P_HH
#define DUMUX_ELEMENTDATA2P_HH
 
#include "properties.hh"
#include "fluxdata.hh"
 
namespace Dumux {
template<class TypeTag>
class FluxData2P;
 
template<class TypeTag, bool enableCompressibility>
class CellData2P;
 
template<class TypeTag>
class CellData2P<TypeTag, false>
{
private:
    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
    using GridView = typename GetPropType<TypeTag, Properties::GridGeometry>::GridView;
    using FluxData = FluxData2P<TypeTag>;
    using FluidState = GetPropType<TypeTag, Properties::FluidState>;
 
    enum
    {
        dim = GridView::dimension, dimWorld = GridView::dimensionworld
    };
 
    using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
 
    enum
    {
        wPhaseIdx = Indices::wPhaseIdx, nPhaseIdx = Indices::nPhaseIdx
    };
    enum
    {
        numPhases = getPropValue<TypeTag, Properties::NumPhases>()
    };
private:
    Scalar saturation_[numPhases];
    Scalar pressure_[numPhases];
    Scalar potential_[numPhases];
    Scalar mobility_[numPhases];
    Scalar fracFlowFunc_[numPhases];
 
    Scalar capillaryPressure_;
    Scalar update_;
 
    FluxData fluxData_;
public:
 
    CellData2P()
    {
        for (int i = 0; i < numPhases;i++)
        {
            saturation_[i] = 0.0;
            pressure_[i] = 0.0;
            potential_[i] = 0.0;
            mobility_[i] = 0.0;
            fracFlowFunc_[i] = 0.0;
        }
        capillaryPressure_ = 0.0;
        update_ = 0.0;
    }
 
    FluxData& fluxData()
    {
        return fluxData_;
    }
 
    const FluxData& fluxData() const
    {
        return fluxData_;
    }
 
    FluidState& fluidState()
    {
        DUNE_THROW(Dune::NotImplemented,"fluid states not stored in cell data of incompressible models!");
    }
 
    const FluidState& fluidState() const
    {
        DUNE_THROW(Dune::NotImplemented,"fluid states not stored in cell data of incompressible models!");
    }
 
    // functions returning primary variables
 
    Scalar pressure(int phaseIdx)
    {
        return pressure_[phaseIdx];
    }
 
    Scalar pressure(int phaseIdx) const
    {
        return pressure_[phaseIdx];
    }
 
    void setPressure(int phaseIdx, Scalar press)
    {
        pressure_[phaseIdx] = press;
    }
 
    Scalar globalPressure()
    {
        return pressure_[wPhaseIdx];
    }
 
    Scalar globalPressure() const
    {
        return pressure_[wPhaseIdx];
    }
 
    void setGlobalPressure(Scalar press)
    {
        pressure_[wPhaseIdx] = press;
    }
 
    Scalar potential(int phaseIdx)
    {
        return potential_[phaseIdx];
    }
 
    Scalar potential(int phaseIdx) const
    {
        return potential_[phaseIdx];
    }
 
    void setPotential(int phaseIdx, Scalar pot)
    {
        potential_[phaseIdx] = pot;
    }
 
    Scalar saturation(int phaseIdx)
    {
        return saturation_[phaseIdx];
    }
 
    Scalar saturation(int phaseIdx) const
    {
        return saturation_[phaseIdx];
    }
 
    void setSaturation(int phaseIdx, Scalar sat)
    {
        saturation_[phaseIdx] = sat;
    }
 
    // functions returning the vectors of secondary variables
 
    Scalar mobility(int phaseIdx)
    {
        return mobility_[phaseIdx];
    }
 
    Scalar mobility(int phaseIdx) const
    {
        return mobility_[phaseIdx];
    }
 
    void setMobility(int phaseIdx, Scalar mobility)
    {
        mobility_[phaseIdx] = mobility;
    }
 
    Scalar fracFlowFunc(int phaseIdx)
    {
        return fracFlowFunc_[phaseIdx];
    }
 
    Scalar fracFlowFunc(int phaseIdx) const
    {
        return fracFlowFunc_[phaseIdx];
    }
 
    void  setFracFlowFunc(int phaseIdx, Scalar fracFlowFunc)
    {
        fracFlowFunc_[phaseIdx] = fracFlowFunc;
    }
 
    Scalar capillaryPressure()
    {
        return capillaryPressure_;
    }
 
    Scalar capillaryPressure() const
    {
        return capillaryPressure_;
    }
 
    void setCapillaryPressure(Scalar pc)
    {
        capillaryPressure_ = pc;
    }
 
    void setUpdate(Scalar update)
    {
        update_ = update;
    }
 
    Scalar volumeCorrection()
    {
        return update_;
    }
    Scalar volumeCorrection() const
    {
        return update_;
    }
 
    //densities are not stored for the incompressible model, however the function is needed to avoid compiler errors
    Scalar density(int phaseIdx)
    {
        DUNE_THROW(Dune::NotImplemented,"density function not implemented in cell data of incompressible models!");
    }
    Scalar density(int phaseIdx) const
    {
        DUNE_THROW(Dune::NotImplemented,"density function not implemented in cell data of incompressible models!");
    }
 
    //viscosities are not stored for the incompressible model, however the function is needed to avoid compiler errors
    Scalar viscosity(int phaseIdx)
    {
        DUNE_THROW(Dune::NotImplemented,"viscosity function not implemented in cell data of incompressible models!");
    }
 
    Scalar viscosity(int phaseIdx) const
    {
        DUNE_THROW(Dune::NotImplemented,"viscosity function not implemented in cell data of incompressible models!");
    }
};
 
template<class TypeTag>
class CellData2P<TypeTag, true>
{
private:
    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
    using GridView = typename GetPropType<TypeTag, Properties::GridGeometry>::GridView;
    using FluxData = FluxData2P<TypeTag>;
    using FluidState = GetPropType<TypeTag, Properties::FluidState>;
 
    enum
    {
        dim = GridView::dimension, dimWorld = GridView::dimensionworld
    };
 
    using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
 
    enum
    {
        wPhaseIdx = Indices::wPhaseIdx, nPhaseIdx = Indices::nPhaseIdx
    };
    enum
    {
        numPhases = getPropValue<TypeTag, Properties::NumPhases>()
    };
private:
    Scalar potential_[numPhases];
    Scalar mobility_[numPhases];
    Scalar fracFlowFunc_[numPhases];
    Scalar update_;
 
    FluxData fluxData_;
    FluidState fluidState_;
public:
 
    CellData2P()
    {
        for (int i = 0; i < numPhases;i++)
        {
            mobility_[i] = 0.0;
            potential_[i] = 0.0;
            fracFlowFunc_[i] = 0.0;
        }
        update_ = 0.0;
    }
 
    FluxData& fluxData()
    {
        return fluxData_;
    }
 
    const FluxData& fluxData() const
    {
        return fluxData_;
    }
 
    FluidState& fluidState()
    {
        return fluidState_;
    }
    const FluidState& fluidState() const
    {
        return fluidState_;
    }
 
    // functions returning primary variables
 
    Scalar pressure(int phaseIdx)
    {
        return fluidState_.pressure(phaseIdx);
    }
 
    Scalar pressure(int phaseIdx) const
    {
        return fluidState_.pressure(phaseIdx);
    }
 
    void setPressure(int phaseIdx, Scalar press)
    {
        fluidState_.setPressure(phaseIdx, press);
    }
 
    Scalar potential(int phaseIdx)
    {
        return potential_[phaseIdx];
    }
 
    Scalar potential(int phaseIdx) const
    {
        return potential_[phaseIdx];
    }
 
    void setPotential(int phaseIdx, Scalar pot)
    {
        potential_[phaseIdx] = pot;
    }
 
    // global pressure is not supported in the compressible case, however the function hast to be defined to avoid compiler errors!
    Scalar globalPressure()
    {
        DUNE_THROW(Dune::NotImplemented,"no global pressure defined for compressible models!");
    }
 
    // global pressure is not supported in the compressible case, however the function hast to be defined to avoid compiler errors!
    Scalar globalPressure() const
    {
        DUNE_THROW(Dune::NotImplemented,"no global pressure defined for compressible models!");
    }
 
    // global pressure is not supported in the compressible case, however the function hast to be defined to avoid compiler errors!
    void setGlobalPressure(Scalar press)
    {
        DUNE_THROW(Dune::NotImplemented,"no global pressure defined for compressible models!");
    }
 
    Scalar saturation(int phaseIdx)
    {
        return fluidState_.saturation(phaseIdx);
    }
 
    Scalar saturation(int phaseIdx) const
    {
        return fluidState_.saturation(phaseIdx);
    }
 
    void setSaturation(int phaseIdx, Scalar sat)
    {
        fluidState_.setSaturation(phaseIdx, sat);
    }
 
    // functions returning the vectors of secondary variables
 
    Scalar mobility(int phaseIdx)
    {
        return mobility_[phaseIdx];
    }
 
    Scalar mobility(int phaseIdx) const
    {
        return mobility_[phaseIdx];
    }
 
    void setMobility(int phaseIdx, Scalar mobility)
    {
        mobility_[phaseIdx] = mobility;
    }
 
    Scalar fracFlowFunc(int phaseIdx)
    {
        return fracFlowFunc_[phaseIdx];
    }
 
    Scalar fracFlowFunc(int phaseIdx) const
    {
        return fracFlowFunc_[phaseIdx];
    }
 
    void  setFracFlowFunc(int phaseIdx, Scalar fracFlowFunc)
    {
        fracFlowFunc_[phaseIdx] = fracFlowFunc;
    }
 
    Scalar capillaryPressure()
    {
        return fluidState_.pressure(nPhaseIdx) - fluidState_.pressure(wPhaseIdx);
    }
 
    Scalar capillaryPressure() const
    {
        return fluidState_.pressure(nPhaseIdx) - fluidState_.pressure(wPhaseIdx);
    }
 
    //in the compressible model capillary pressure is not stored explicitly, however the function is needed to avoid compiler errors
    void setCapillaryPressure(Scalar pc)
    {
        DUNE_THROW(Dune::NotImplemented,"no capillary pressure stored for compressible models!");
    }
 
    Scalar density(int phaseIdx)
    {
        return fluidState_.density(phaseIdx);
    }
 
    Scalar density(int phaseIdx) const
    {
        return fluidState_.density(phaseIdx);
    }
 
    void setDensity(int phaseIdx, Scalar density)
    {
        fluidState_.setDensity(phaseIdx, density);
    }
 
    Scalar viscosity(int phaseIdx)
    {
        return fluidState_.viscosity(phaseIdx);
    }
 
    Scalar viscosity(int phaseIdx) const
    {
        return fluidState_.viscosity(phaseIdx);
    }
 
    void setViscosity(int phaseIdx, Scalar viscosity)
    {
        fluidState_.setViscosity(phaseIdx, viscosity);
    }
 
    void setUpdate(Scalar update)
    {
        update_ = update;
    }
 
    Scalar volumeCorrection()
    {
        return update_;
    }
 
    Scalar volumeCorrection() const
    {
        return update_;
    }
 
};
} // end namespace Dumux
#endif