2p2c/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_ELEMENTDATA2P2C_HH
#define DUMUX_ELEMENTDATA2P2C_HH
 
#include "fluxdata.hh"
 
namespace Dumux {
template<class TypeTag>
class CellData2P2C
{
private:
    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
    using FluxData = FluxData2P2C<TypeTag>;
    using FluidState = GetPropType<TypeTag, Properties::FluidState>;
 
    using Indices = typename GetPropType<TypeTag, Properties::ModelTraits>::Indices;
 
    enum
    {
        wPhaseIdx = Indices::wPhaseIdx, nPhaseIdx = Indices::nPhaseIdx,
        wCompIdx = Indices::wPhaseIdx, nCompIdx = Indices::nPhaseIdx,
        contiWEqIdx = Indices::contiWEqIdx
    };
    enum
    {
        numPhases = getPropValue<TypeTag, Properties::NumPhases>(),
        numComponents = getPropValue<TypeTag, Properties::NumComponents>()
    };
protected:
    // primary variable (phase pressure has to be stored in fluidstate)
    Scalar massConcentration_[numComponents];
 
    Scalar mobility_[numPhases];
 
    //numerical quantities
    Scalar volumeError_;
    Scalar errorCorrection_;
    Scalar dv_dp_;
    Scalar dv_[numComponents];
    bool volumeDerivativesAvailable_;
    bool wasRefined_;
 
    int globalIdx_;
    Scalar perimeter_;
 
    std::shared_ptr<FluidState> fluidState_;
    FluxData fluxData_;
public:
 
    CellData2P2C()
    {
        for (int i = 0; i < numPhases;i++)
        {
            mobility_[i] = 0.0;
            dv_[i] = 0.0;
        }
        volumeError_ = 0.;
        errorCorrection_= 0.;
        dv_dp_ = 0.;
        volumeDerivativesAvailable_ = false;
        wasRefined_ = false;
        globalIdx_ = 0;
        perimeter_ = 0.;
    }
    FluxData& fluxData()
    {
        return fluxData_;
    }
    const FluxData& fluxData() const
    {
        return fluxData_;
    }
 
    Scalar pressure(int phaseIdx)
    {
        return fluidState_->pressure(phaseIdx);
    }
 
    const Scalar pressure(int phaseIdx) const
    {
        return fluidState_->pressure(phaseIdx);
    }
 
    const Scalar totalConcentration(int compIdx) const
    {
        return massConcentration_[compIdx];
    }
 
    const Scalar massConcentration(int compIdx) const
    {
        return massConcentration_[compIdx];
    }
 
    void setTotalConcentration(int compIdx, Scalar value)
    {
        massConcentration_[compIdx] = value;
    }
 
    void setMassConcentration(int compIdx, Scalar value)
    {
        massConcentration_[compIdx] = value;
    }
    void calculateMassConcentration(Scalar porosity)
    {
        massConcentration_[wCompIdx] =
                porosity * (massFraction(wPhaseIdx,wCompIdx) * saturation(wPhaseIdx) * density(wPhaseIdx)
              + massFraction(nPhaseIdx,wCompIdx) * saturation(nPhaseIdx) * density(nPhaseIdx));
        massConcentration_[nCompIdx] =
                porosity * (massFraction(wPhaseIdx,nCompIdx) * saturation(wPhaseIdx) * density(wPhaseIdx)
              + massFraction(nPhaseIdx,nCompIdx) * saturation(nPhaseIdx) * density(nPhaseIdx));
    }
 
 
    const Scalar& mobility(int phaseIdx) const
    {
        return mobility_[phaseIdx];
    }
 
    void setMobility(int phaseIdx, Scalar value)
    {
        mobility_[phaseIdx]=value;
    }
 
    Scalar& volumeError()
    {
        return volumeError_;
    }
 
    const Scalar& volumeError() const
    {
        return volumeError_;
    }
 
    Scalar& errorCorrection()
    {
        return errorCorrection_;
    }
 
    const Scalar& errorCorrection() const
    {
        return errorCorrection_;
    }
 
    Scalar& dv_dp()
    {
        return dv_dp_;
    }
 
    const Scalar& dv_dp() const
    {
        return dv_dp_;
    }
 
    Scalar& dv(int compIdx)
    {
        return dv_[compIdx];
    }
 
    const Scalar& dv(int compIdx) const
    {
        return dv_[compIdx];
    }
 
    Scalar& perimeter()
    {
        return perimeter_;
    }
    const Scalar& perimeter() const
    {
        return perimeter_;
    }
 
    /*** b) from fluidstate ***/
 
    const Scalar saturation(int phaseIdx) const
    {
        return fluidState_->saturation(phaseIdx);
    }
 
    const Scalar viscosity(int phaseIdx) const
    {
        return fluidState_->viscosity(phaseIdx);
    }
 
    const Scalar capillaryPressure() const
    {
        return fluidState_->pressure(nPhaseIdx) - fluidState_->pressure(wPhaseIdx);
    }
 
    const Scalar density(int phaseIdx) const
    {
        return (fluidState_->density(phaseIdx));
    }
 
    const Scalar massFraction(int phaseIdx, int compIdx) const
    {
        return fluidState_->massFraction(phaseIdx, compIdx);
    }
 
    const Scalar moleFraction(int phaseIdx, int compIdx) const
    {
        return fluidState_->moleFraction(phaseIdx, compIdx);
    }
 
    const Scalar temperature(int phaseIdx) const
    {
        return fluidState_->temperature(phaseIdx);
    }
 
    const Scalar phaseMassFraction(int phaseIdx) const
    {
        return fluidState_->phaseMassFraction(phaseIdx);
    }
 
    const FluidState& fluidState() const
    {
        return *fluidState_;
    }
 
    FluidState& manipulateFluidState()
    {
        if(!fluidState_)
            fluidState_ = std::make_shared<FluidState>();
        return *fluidState_;
    }
 
    int& globalIdx()
    { return globalIdx_;}
    bool hasVolumeDerivatives() const
    { return volumeDerivativesAvailable_;}
    void confirmVolumeDerivatives()
    { volumeDerivativesAvailable_ = true;}
    void volumeDerivativesAvailable(bool value)
    { volumeDerivativesAvailable_ = value;}
    void reset()
    {
        wasRefined_ = false;
        volumeDerivativesAvailable_ = false;
    }
    bool& wasRefined()
    {   return wasRefined_;}
    const bool& wasRefined() const
    {   return wasRefined_;}
 
    const bool& isUpwindCell(int indexInInside, int phaseIdx) const
    {
        return fluxData_.isUpwindCell(indexInInside, phaseIdx);
    }
    void setUpwindCell(int indexInInside, int phaseIdx, bool value)
    {
        fluxData_.setUpwindCell(indexInInside, phaseIdx, value);
    }
 
};
}
#endif