elementstatefine.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:
//
// SPDX-FileCopyrightText: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
// SPDX-License-Identifier: GPL-3.0-or-later
//
 
#ifndef DUMUX_TWOPVE_FINE_LEVEL_ELEMENTSTATE_HH
#define DUMUX_TWOPVE_FINE_LEVEL_ELEMENTSTATE_HH
 
#include <array>
 
#include <dumux/porousmediumflow/2pve/quantityreconstruction.hh>
 
namespace Dumux {

template<class Scalar>
struct TwoPVEColumnState
{
    Scalar pwCoarse{};
    Scalar swCoarse{};
    Scalar temperature{};
 
    Scalar domainHeight{};
 
    Scalar swr{};
    Scalar snr{};
 
    Scalar brooksCoreyLambda{};
    Scalar entryPressure{};
    Scalar gravityNorm{};
 
    Scalar densityW{};
    Scalar densityNw{};
    Scalar viscosityW{};
    Scalar viscosityNw{};
 
    Scalar gasPlumeDistance{};
    Scalar minimumGasPlumeDistance{}; // required for hysteresis
};

template<class GridGeometry, class Scalar, class FluidSystem>
class TwoPVEFineLevelElementState
{
    using GridView = typename GridGeometry::GridView;
    using Element = typename GridView::template Codim<0>::Entity;
    static constexpr int dim = GridView::dimension;
    static constexpr int wettingPhaseIdx = FluidSystem::phase0Idx;
    static constexpr int nonwettingPhaseIdx = FluidSystem::phase1Idx;
    static constexpr int numPhases = FluidSystem::numPhases;
    using QuantityReconstructor = TwoPVEQuantityReconstruction<Scalar, FluidSystem>;
 
    using GasPlumeDistances = TwoPVE::GasPlumeDistancesData<Scalar>;
    using PhaseDensities = TwoPVE::PhaseDensitiesData<Scalar>;
    using PhaseViscosities = TwoPVE::PhaseViscositiesData<Scalar>;
    using ResidualSaturations = TwoPVE::ResidualSaturationsData<Scalar>;
    using BrooksCoreyParameters = TwoPVE::BrooksCoreyParametersData<Scalar>;
 
public:

    template<typename SpatialParamsFine>
    void update(const Element& fineElement,
                const TwoPVEColumnState<Scalar>& column,
                const SpatialParamsFine& fineSpatialParams,
                const QuantityReconstructor& reconstructor,
                const Scalar fineCellHeight)
    {
        // relative height instead of absolute height is required for the reconstruction functions
        const Scalar fineElementPosZ = fineElement.geometry().center()[dim-1];
        const Scalar heightAboveBottom = fineElementPosZ - fineSpatialParams.gridGeometry().bBoxMin()[dim-1];
 
        const auto pressures = reconstructor.reconstructPressure(
            column.gasPlumeDistance,
            PhaseDensities{column.densityW, column.densityNw},
            column.gravityNorm,
            heightAboveBottom,
            column.pwCoarse,
            column.entryPressure);
        pressure_[wettingPhaseIdx] = pressures[wettingPhaseIdx];
        pressure_[nonwettingPhaseIdx] = pressures[nonwettingPhaseIdx];
 
        const Scalar saturationW = reconstructor.reconstructSaturation(
            GasPlumeDistances{column.gasPlumeDistance, column.minimumGasPlumeDistance},
            PhaseDensities{column.densityW, column.densityNw},
            ResidualSaturations{column.swr, column.snr},
            column.gravityNorm,
            heightAboveBottom,
            fineCellHeight,
            BrooksCoreyParameters{column.brooksCoreyLambda, column.entryPressure});
        saturation_[wettingPhaseIdx] = saturationW;
        saturation_[nonwettingPhaseIdx] = 1.0 - saturationW;
 
        const Scalar capillaryPressure = reconstructor.reconstructCapillaryPressure(
            column.gasPlumeDistance,
            PhaseDensities{column.densityW, column.densityNw},
            column.gravityNorm,
            heightAboveBottom,
            column.entryPressure);
        capillaryPressure_ = capillaryPressure;
 
        const auto mobilities = reconstructor.reconstructMobilitiesFine(
            GasPlumeDistances{column.gasPlumeDistance, column.minimumGasPlumeDistance},
            PhaseDensities{column.densityW, column.densityNw},
            PhaseViscosities{column.viscosityW, column.viscosityNw},
            column.gravityNorm,
            heightAboveBottom,
            fineCellHeight,
            BrooksCoreyParameters{column.brooksCoreyLambda, column.entryPressure});
        mobility_[wettingPhaseIdx] = mobilities[wettingPhaseIdx];
        mobility_[nonwettingPhaseIdx] = mobilities[nonwettingPhaseIdx];
 
        density_[wettingPhaseIdx] = column.densityW;
        density_[nonwettingPhaseIdx] = column.densityNw;
 
        viscosity_[wettingPhaseIdx] = column.viscosityW;
        viscosity_[nonwettingPhaseIdx] = column.viscosityNw;
 
        permeability_ = fineSpatialParams.permeabilityAtElement(fineElement);
        porosity_ = fineSpatialParams.porosityAtElement(fineElement);
 
        temperature_ = column.temperature;
        gasPlumeDistance_ = column.gasPlumeDistance;
    }

    Scalar pressure(int phaseIdx) const
    { return pressure_[phaseIdx]; }

    Scalar saturation(int phaseIdx) const
    { return saturation_[phaseIdx]; }

    Scalar capillaryPressure() const
    { return capillaryPressure_; }

    Scalar mobility(int phaseIdx) const
    { return mobility_[phaseIdx]; }

    Scalar density(int phaseIdx) const
    { return density_[phaseIdx]; }

    Scalar viscosity(int phaseIdx) const
    { return viscosity_[phaseIdx]; }

    Scalar permeability() const
    { return permeability_; }

    Scalar porosity() const
    { return porosity_; }

    Scalar temperature() const
    { return temperature_; }

    Scalar gasPlumeDist() const
    { return gasPlumeDistance_; }
 
private:
    std::array<Scalar, numPhases> pressure_{};
    std::array<Scalar, numPhases> saturation_{};
    Scalar capillaryPressure_{};
    std::array<Scalar, numPhases> mobility_{};
    std::array<Scalar, numPhases> density_{};
    std::array<Scalar, numPhases> viscosity_{};
    Scalar permeability_{};
    Scalar porosity_{};
    Scalar temperature_{};
    Scalar gasPlumeDistance_{};
};
 
} // end namespace Dumux
 
#endif