multiphasebaseextensivequantities.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:
/*
  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/>.
*/
#ifndef EWOMS_MULTI_PHASE_BASE_EXTENSIVE_QUANTITIES_HH
#define EWOMS_MULTI_PHASE_BASE_EXTENSIVE_QUANTITIES_HH

#include "multiphasebaseproperties.hh"

#include <ewoms/models/common/quantitycallbacks.hh>
#include <ewoms/disc/common/fvbaseextensivequantities.hh>
#include <ewoms/common/parametersystem.hh>

#include <dune/common/fvector.hh>

namespace Ewoms {
template <class TypeTag>
class MultiPhaseBaseExtensiveQuantities
    : public GET_PROP_TYPE(TypeTag, DiscExtensiveQuantities)
    , public GET_PROP_TYPE(TypeTag, FluxModule)::FluxExtensiveQuantities
{
    typedef typename GET_PROP_TYPE(TypeTag, DiscExtensiveQuantities) ParentType;

    typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
    typedef typename GET_PROP_TYPE(TypeTag, ElementContext) ElementContext;
    typedef typename GET_PROP_TYPE(TypeTag, FluidSystem) FluidSystem;

    enum { numPhases = GET_PROP_VALUE(TypeTag, NumPhases) };


    typedef typename GET_PROP_TYPE(TypeTag, FluxModule) FluxModule;
    typedef typename FluxModule::FluxExtensiveQuantities FluxExtensiveQuantities;

public:
    static void registerParameters()
    {
        FluxModule::registerParameters();
    }

    void update(const ElementContext &elemCtx, int scvfIdx, int timeIdx)
    {
        ParentType::update(elemCtx, scvfIdx, timeIdx);

        // compute the pressure potential gradients
        FluxExtensiveQuantities::calculateGradients_(elemCtx, scvfIdx, timeIdx);

        // Check whether the pressure potential is in the same direction as the face
        // normal or in the opposite one
        for (int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
            if (!elemCtx.model().phaseIsConsidered(phaseIdx)) {
                Valgrind::SetUndefined(upstreamScvIdx_[phaseIdx]);
                Valgrind::SetUndefined(downstreamScvIdx_[phaseIdx]);
                continue;
            }

            upstreamScvIdx_[phaseIdx] = FluxExtensiveQuantities::upstreamIndex_(phaseIdx);
            downstreamScvIdx_[phaseIdx] = FluxExtensiveQuantities::downstreamIndex_(phaseIdx);
        }

        FluxExtensiveQuantities::calculateFluxes_(elemCtx, scvfIdx, timeIdx);
    }


    template <class Context, class FluidState>
    void updateBoundary(const Context &context,
                        int bfIdx,
                        int timeIdx,
                        const FluidState &fluidState,
                        typename FluidSystem::ParameterCache &paramCache)
    {
        ParentType::updateBoundary(context, bfIdx, timeIdx, fluidState, paramCache);

        FluxExtensiveQuantities::calculateBoundaryGradients_(context.elementContext(),
                                                                 bfIdx,
                                                                 timeIdx,
                                                                 fluidState,
                                                                 paramCache);
        FluxExtensiveQuantities::calculateBoundaryFluxes_(context.elementContext(),
                                                                  bfIdx,
                                                                  timeIdx);
    }

    short upstreamIndex(int phaseIdx) const
    { return upstreamScvIdx_[phaseIdx]; }

    short downstreamIndex(int phaseIdx) const
    { return downstreamScvIdx_[phaseIdx]; }

    Scalar upstreamWeight(int phaseIdx) const
    { return 1.0; }

    Scalar downstreamWeight(int phaseIdx) const
    { return 1.0 - upstreamWeight(phaseIdx); }

private:
    short upstreamScvIdx_[numPhases];
    short downstreamScvIdx_[numPhases];
};

} // namespace Ewoms

#endif