3pimmiscible.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-FileCopyrightInfo: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
// SPDX-License-Identifier: GPL-3.0-or-later
//
#ifndef DUMUX_3P_IMMISCIBLE_FLUID_SYSTEM_HH
#define DUMUX_3P_IMMISCIBLE_FLUID_SYSTEM_HH
 
#include <cassert>
#include <limits>
#include <iostream>
 
#include <dune/common/exceptions.hh>
 
#include <dumux/material/fluidsystems/1pliquid.hh>
#include <dumux/material/fluidsystems/1pgas.hh>
#include <dumux/material/fluidstates/immiscible.hh>
#include <dumux/material/components/base.hh>
#include <dumux/io/name.hh>
 
namespace Dumux {
namespace FluidSystems {
 
template <class Scalar, class WettingFluid, class NonwettingFluid, class Gas>
class ThreePImmiscible
: public Base<Scalar, ThreePImmiscible<Scalar, WettingFluid, NonwettingFluid, Gas> >
{
    static_assert((WettingFluid::numPhases == 1), "WettingFluid has more than one phase");
    static_assert((NonwettingFluid::numPhases == 1), "NonwettingFluid has more than one phase");
    static_assert((Gas::numPhases == 1), "Gas has more than one phase");
    static_assert((WettingFluid::numComponents == 1), "WettingFluid has more than one component");
    static_assert((NonwettingFluid::numComponents == 1), "NonwettingFluid has more than one component");
    static_assert((Gas::numComponents == 1), "Gas has more than one component");
 
    using ThisType = ThreePImmiscible<Scalar, WettingFluid, NonwettingFluid, Gas>;
 
public:
    /****************************************
     * Fluid phase related static parameters
     ****************************************/
 
    static constexpr int numPhases = 3;
 
    static constexpr int wPhaseIdx = 0;
    static constexpr int nPhaseIdx = 1;
    static constexpr int gPhaseIdx = 2;
 
    static std::string phaseName(int phaseIdx)
    {
        assert(0 <= phaseIdx && phaseIdx < numPhases);
        switch (phaseIdx)
        {
            case wPhaseIdx: return Components::IsAqueous<typename WettingFluid::Component>::value
                            ? IOName::aqueousPhase() : IOName::naplPhase();
            case nPhaseIdx: return Components::IsAqueous<typename NonwettingFluid::Component>::value
                            ? IOName::aqueousPhase() : IOName::naplPhase();
            case gPhaseIdx: return IOName::gaseousPhase();
        }
        DUNE_THROW(Dune::InvalidStateException, "Invalid phase index " << phaseIdx);
    }
 
    static constexpr bool isMiscible()
    { return false; }
 
    static constexpr bool isGas(int phaseIdx)
    {
        assert(0 <= phaseIdx && phaseIdx < numPhases);
 
        switch (phaseIdx)
        {
            case wPhaseIdx: return WettingFluid::isGas(); break;
            case nPhaseIdx: return NonwettingFluid::isGas(); break;
            case gPhaseIdx: return Gas::isGas(); break;
            default: return false; // TODO: constexpr-compatible throw
        }
    }
 
    static constexpr bool isIdealMixture(int phaseIdx)
    { return true; }
 
    static constexpr bool isCompressible(int phaseIdx)
    {
        assert(0 <= phaseIdx && phaseIdx < numPhases);
 
        // let the fluids decide
        switch(phaseIdx)
        {
            case wPhaseIdx: return WettingFluid::isCompressible(); break;
            case nPhaseIdx: return NonwettingFluid::isCompressible(); break;
            case gPhaseIdx: return Gas::isCompressible(); break;
            default: return false; // TODO: constexpr-compatible throw
        }
    }
 
    static constexpr bool isIdealGas(int phaseIdx)
    {
        assert(0 <= phaseIdx && phaseIdx < numPhases);
 
        // let the fluids decide
        switch(phaseIdx)
        {
            case wPhaseIdx: return WettingFluid::isIdealGas(); break;
            case nPhaseIdx: return NonwettingFluid::isIdealGas(); break;
            case gPhaseIdx: return Gas::isIdealGas(); break;
            default: return false; // TODO: constexpr-compatible throw
        }
    }
 
    /****************************************
     * Component related static parameters
     ****************************************/
 
    static constexpr int numComponents = 3;//WettingFluid::numComponents + NonwettingFluid::numComponents + Gas::numComponents; // TODO: 3??
 
    static constexpr int wCompIdx = 0;
    static constexpr int nCompIdx = 1;
    static constexpr int gCompIdx = 2; // TODO: correct??
 
    static std::string componentName(int compIdx)
    {
        assert(0 <= compIdx && compIdx < numComponents);
 
        switch(compIdx)
        {
            case wCompIdx: return WettingFluid::name(); break;
            case nCompIdx: return NonwettingFluid::name(); break;
            case gCompIdx: return Gas::name(); break;
            default: DUNE_THROW(Dune::InvalidStateException, "Invalid component index");
        }
    }
 
    static Scalar molarMass(int compIdx)
    {
        assert(0 <= compIdx && compIdx < numComponents);
 
        switch(compIdx)
        {
            case wCompIdx: return WettingFluid::molarMass(); break;
            case nCompIdx: return NonwettingFluid::molarMass(); break;
            case gCompIdx: return Gas::molarMass(); break;
            default: DUNE_THROW(Dune::InvalidStateException, "Invalid component index");
        }
    }
 
    static Scalar criticalTemperature(int compIdx)
    {
        assert(0 <= compIdx && compIdx < numComponents);
 
        switch(compIdx)
        {
            case wCompIdx: return WettingFluid::criticalTemperature(); break;
            case nCompIdx: return NonwettingFluid::criticalTemperature(); break;
            case gCompIdx: return Gas::criticalTemperature(); break;
            default: DUNE_THROW(Dune::InvalidStateException, "Invalid component index");
        }
    }
 
    static Scalar criticalPressure(int compIdx)
    {
        assert(0 <= compIdx && compIdx < numComponents);
 
        switch(compIdx)
        {
            case wCompIdx: return WettingFluid::criticalPressure(); break;
            case nCompIdx: return NonwettingFluid::criticalPressure(); break;
            case gCompIdx: return Gas::criticalPressure(); break;
            default: DUNE_THROW(Dune::InvalidStateException, "Invalid component index");
        }
    }
 
    static Scalar acentricFactor(int compIdx)
    {
        assert(0 <= compIdx && compIdx < numComponents);
 
        switch(compIdx)
        {
            case wCompIdx: return WettingFluid::Component::acentricFactor(); break;
            case nCompIdx: return NonwettingFluid::Component::acentricFactor(); break;
            case gCompIdx: return Gas::Component::acentricFactor(); break;
            default: DUNE_THROW(Dune::InvalidStateException, "Invalid component index");
        }
    }
 
    /****************************************
     * thermodynamic relations
     ****************************************/
 
    static constexpr void init()
    {
        // two gaseous phases at once do not make sense physically!
        // (But two liquids are fine)
        static_assert(!WettingFluid::isGas() && !NonwettingFluid::isGas() && Gas::isGas(), "There can only be one gaseous phase!");
    }
 
    static void init(Scalar tempMin, Scalar tempMax, unsigned nTemp,
                     Scalar pressMin, Scalar pressMax, unsigned nPress)
    {
        // two gaseous phases at once do not make sense physically!
        static_assert(!WettingFluid::isGas() && !NonwettingFluid::isGas() && Gas::isGas(), "There can only be one gaseous phase!");
 
        if (WettingFluid::Component::isTabulated)
        {
            std::cout << "Initializing tables for the wetting fluid properties ("
                      << nTemp*nPress
                      << " entries).\n";
 
            WettingFluid::Component::init(tempMin, tempMax, nTemp,
                                          pressMin, pressMax, nPress);
 
        }
 
        if (NonwettingFluid::Component::isTabulated)
        {
            std::cout << "Initializing tables for the nonwetting fluid properties ("
                      << nTemp*nPress
                      << " entries).\n";
 
            NonwettingFluid::Component::init(tempMin, tempMax, nTemp,
                                             pressMin, pressMax, nPress);
 
        }
 
        if (Gas::Component::isTabulated)
        {
            std::cout << "Initializing tables for the gas fluid properties ("
                      << nTemp*nPress
                      << " entries).\n";
 
            Gas::Component::init(tempMin, tempMax, nTemp,
                                 pressMin, pressMax, nPress);
 
        }
    }
 
    using Base<Scalar, ThisType>::density;
    template <class FluidState>
    static Scalar density(const FluidState &fluidState,
                          int phaseIdx)
    {
        assert(0 <= phaseIdx && phaseIdx < numPhases);
 
        Scalar temperature = fluidState.temperature(phaseIdx);
        Scalar pressure = fluidState.pressure(phaseIdx);
 
        switch(phaseIdx)
        {
            case wPhaseIdx: return WettingFluid::density(temperature, pressure); break;
            case nPhaseIdx: return NonwettingFluid::density(temperature, pressure); break;
            case gPhaseIdx: return Gas::density(temperature, pressure); break;
            default: DUNE_THROW(Dune::InvalidStateException, "Invalid phase index");
        }
    }
 
    using Base<Scalar, ThisType>::molarDensity;
    template <class FluidState>
    static Scalar molarDensity(const FluidState &fluidState,
                               int phaseIdx)
    {
        assert(0 <= phaseIdx && phaseIdx < numPhases);
 
        Scalar temperature = fluidState.temperature(phaseIdx);
        Scalar pressure = fluidState.pressure(phaseIdx);
 
        switch(phaseIdx)
        {
            case wPhaseIdx: return WettingFluid::molarDensity(temperature, pressure);
            case nPhaseIdx: return NonwettingFluid::molarDensity(temperature, pressure);
            case gPhaseIdx: return Gas::molarDensity(temperature, pressure);
            default: DUNE_THROW(Dune::InvalidStateException, "Invalid phase index");
        }
    }
 
    using Base<Scalar, ThisType>::viscosity;
    template <class FluidState>
    static Scalar viscosity(const FluidState &fluidState,
                            int phaseIdx)
    {
        assert(0 <= phaseIdx  && phaseIdx < numPhases);
 
        Scalar temperature = fluidState.temperature(phaseIdx);
        Scalar pressure = fluidState.pressure(phaseIdx);
 
        switch(phaseIdx)
        {
            case wPhaseIdx: return WettingFluid::viscosity(temperature, pressure); break;
            case nPhaseIdx: return NonwettingFluid::viscosity(temperature, pressure); break;
            case gPhaseIdx: return Gas::viscosity(temperature, pressure); break;
            default: DUNE_THROW(Dune::InvalidStateException, "Invalid phase index");
        }
    }
 
    using Base<Scalar, ThisType>::fugacityCoefficient;
    template <class FluidState>
    static Scalar fugacityCoefficient(const FluidState &fluidState,
                                      int phaseIdx,
                                      int compIdx)
    {
        assert(0 <= phaseIdx  && phaseIdx < numPhases);
        assert(0 <= compIdx  && compIdx < numComponents);
 
        if (phaseIdx == compIdx)
            // We could calculate the real fugacity coefficient of
            // the component in the fluid. Probably that's not worth
            // the effort, since the fugacity coefficient of the other
            // component is infinite anyway...
            return 1.0;
        return std::numeric_limits<Scalar>::infinity();
    }
 
    using Base<Scalar, ThisType>::diffusionCoefficient;
    template <class FluidState>
    static Scalar diffusionCoefficient(const FluidState &fluidState,
                                       int phaseIdx,
                                       int compIdx)
    {
        DUNE_THROW(Dune::InvalidStateException,
                   "Diffusion coefficients of components are meaningless if"
                   " immiscibility is assumed");
    }
 
    using Base<Scalar, ThisType>::binaryDiffusionCoefficient;
    template <class FluidState>
    static Scalar binaryDiffusionCoefficient(const FluidState &fluidState,
                                             int phaseIdx,
                                             int compIIdx,
                                             int compJIdx)
 
    {
        DUNE_THROW(Dune::InvalidStateException,
                   "Binary diffusion coefficients of components are meaningless if"
                   " immiscibility is assumed");
    }
 
    using Base<Scalar, ThisType>::enthalpy;
    template <class FluidState>
    static Scalar enthalpy(const FluidState &fluidState,
                                 int phaseIdx)
    {
        assert(0 <= phaseIdx  && phaseIdx < numPhases);
 
        Scalar temperature = fluidState.temperature(phaseIdx);
        Scalar pressure = fluidState.pressure(phaseIdx);
 
        switch(phaseIdx)
        {
            case wPhaseIdx: return WettingFluid::enthalpy(temperature, pressure); break;
            case nPhaseIdx: return NonwettingFluid::enthalpy(temperature, pressure); break;
            case gPhaseIdx: return Gas::enthalpy(temperature, pressure); break;
            default: DUNE_THROW(Dune::InvalidStateException, "Invalid phase index");
        }
    }
 
    using Base<Scalar, ThisType>::thermalConductivity;
    template <class FluidState>
    static Scalar thermalConductivity(const FluidState &fluidState,
                                      int phaseIdx)
    {
        assert(0 <= phaseIdx  && phaseIdx < numPhases);
 
        Scalar temperature = fluidState.temperature(phaseIdx);
        Scalar pressure = fluidState.pressure(phaseIdx);
 
        switch(phaseIdx)
        {
            case wPhaseIdx: return WettingFluid::thermalConductivity(temperature, pressure); break;
            case nPhaseIdx: return NonwettingFluid::thermalConductivity(temperature, pressure); break;
            case gPhaseIdx: return Gas::thermalConductivity(temperature, pressure); break;
            default: DUNE_THROW(Dune::InvalidStateException, "Invalid phase index");
        }
    }
 
    using Base<Scalar, ThisType>::heatCapacity;
    template <class FluidState>
    static Scalar heatCapacity(const FluidState &fluidState,
                               int phaseIdx)
    {
        assert(0 <= phaseIdx  && phaseIdx < numPhases);
 
        Scalar temperature = fluidState.temperature(phaseIdx);
        Scalar pressure = fluidState.pressure(phaseIdx);
 
        switch(phaseIdx)
        {
            case wPhaseIdx: return WettingFluid::heatCapacity(temperature, pressure); break;
            case nPhaseIdx: return NonwettingFluid::heatCapacity(temperature, pressure); break;
            case gPhaseIdx: return Gas::heatCapacity(temperature, pressure); break;
            default: DUNE_THROW(Dune::InvalidStateException, "Invalid phase index");
        }
    }
};
 
} // end namespace FluidSystems
} // end namespace Dumux
 
#endif