12#ifndef DUMUX_3P_IMMISCIBLE_FLUID_SYSTEM_HH 
   13#define DUMUX_3P_IMMISCIBLE_FLUID_SYSTEM_HH 
   19#include <dune/common/exceptions.hh> 
   46template <
class Scalar, 
class WettingFlu
id, 
class NonwettingFlu
id, 
class Gas>
 
   48: 
public Base<Scalar, ThreePImmiscible<Scalar, WettingFluid, NonwettingFluid, Gas> >
 
   50    static_assert((WettingFluid::numPhases == 1), 
"WettingFluid has more than one phase");
 
   51    static_assert((NonwettingFluid::numPhases == 1), 
"NonwettingFluid has more than one phase");
 
   52    static_assert((Gas::numPhases == 1), 
"Gas has more than one phase");
 
   53    static_assert((WettingFluid::numComponents == 1), 
"WettingFluid has more than one component");
 
   54    static_assert((NonwettingFluid::numComponents == 1), 
"NonwettingFluid has more than one component");
 
   55    static_assert((Gas::numComponents == 1), 
"Gas has more than one component");
 
   80        assert(0 <= phaseIdx && phaseIdx < 
numPhases);
 
   89        DUNE_THROW(Dune::InvalidStateException, 
"Invalid phase index " << phaseIdx);
 
 
  102    static constexpr bool isGas(
int phaseIdx)
 
  104        assert(0 <= phaseIdx && phaseIdx < 
numPhases);
 
  108            case wPhaseIdx: 
return WettingFluid::isGas(); 
break;
 
  109            case nPhaseIdx: 
return NonwettingFluid::isGas(); 
break;
 
  110            case gPhaseIdx: 
return Gas::isGas(); 
break;
 
  111            default: 
return false; 
 
 
  142        assert(0 <= phaseIdx && phaseIdx < 
numPhases);
 
  147            case wPhaseIdx: 
return WettingFluid::isCompressible(); 
break;
 
  148            case nPhaseIdx: 
return NonwettingFluid::isCompressible(); 
break;
 
  149            case gPhaseIdx: 
return Gas::isCompressible(); 
break;
 
  150            default: 
return false; 
 
 
  162        assert(0 <= phaseIdx && phaseIdx < 
numPhases);
 
  167            case wPhaseIdx: 
return WettingFluid::isIdealGas(); 
break;
 
  168            case nPhaseIdx: 
return NonwettingFluid::isIdealGas(); 
break;
 
  169            case gPhaseIdx: 
return Gas::isIdealGas(); 
break;
 
  170            default: 
return false; 
 
 
  199            case wCompIdx: 
return WettingFluid::name(); 
break;
 
  200            case nCompIdx: 
return NonwettingFluid::name(); 
break;
 
  201            case gCompIdx: 
return Gas::name(); 
break;
 
  202            default: DUNE_THROW(Dune::InvalidStateException, 
"Invalid component index");
 
 
  216            case wCompIdx: 
return WettingFluid::molarMass(); 
break;
 
  217            case nCompIdx: 
return NonwettingFluid::molarMass(); 
break;
 
  218            case gCompIdx: 
return Gas::molarMass(); 
break;
 
  219            default: DUNE_THROW(Dune::InvalidStateException, 
"Invalid component index");
 
 
  233            case wCompIdx: 
return WettingFluid::criticalTemperature(); 
break;
 
  234            case nCompIdx: 
return NonwettingFluid::criticalTemperature(); 
break;
 
  235            case gCompIdx: 
return Gas::criticalTemperature(); 
break;
 
  236            default: DUNE_THROW(Dune::InvalidStateException, 
"Invalid component index");
 
 
  250            case wCompIdx: 
return WettingFluid::criticalPressure(); 
break;
 
  251            case nCompIdx: 
return NonwettingFluid::criticalPressure(); 
break;
 
  252            case gCompIdx: 
return Gas::criticalPressure(); 
break;
 
  253            default: DUNE_THROW(Dune::InvalidStateException, 
"Invalid component index");
 
 
  267            case wCompIdx: 
return WettingFluid::Component::acentricFactor(); 
break;
 
  268            case nCompIdx: 
return NonwettingFluid::Component::acentricFactor(); 
break;
 
  269            case gCompIdx: 
return Gas::Component::acentricFactor(); 
break;
 
  270            default: DUNE_THROW(Dune::InvalidStateException, 
"Invalid component index");
 
 
  285        static_assert(!WettingFluid::isGas() && !NonwettingFluid::isGas() && Gas::isGas(), 
"There can only be one gaseous phase!");
 
 
  303        static_assert(!WettingFluid::isGas() && !NonwettingFluid::isGas() && Gas::isGas(), 
"There can only be one gaseous phase!");
 
  305        if (WettingFluid::Component::isTabulated)
 
  307            std::cout << 
"Initializing tables for the wetting fluid properties (" 
  311            WettingFluid::Component::init(tempMin, tempMax, nTemp,
 
  312                                          pressMin, pressMax, nPress);
 
  316        if (NonwettingFluid::Component::isTabulated)
 
  318            std::cout << 
"Initializing tables for the nonwetting fluid properties (" 
  322            NonwettingFluid::Component::init(tempMin, tempMax, nTemp,
 
  323                                             pressMin, pressMax, nPress);
 
  327        if (Gas::Component::isTabulated)
 
  329            std::cout << 
"Initializing tables for the gas fluid properties (" 
  333            Gas::Component::init(tempMin, tempMax, nTemp,
 
  334                                 pressMin, pressMax, nPress);
 
 
  341    template <
class Flu
idState>
 
  345        assert(0 <= phaseIdx && phaseIdx < 
numPhases);
 
  347        Scalar temperature = fluidState.temperature(phaseIdx);
 
  348        Scalar pressure = fluidState.pressure(phaseIdx);
 
  352            case wPhaseIdx: 
return WettingFluid::density(temperature, pressure); 
break;
 
  353            case nPhaseIdx: 
return NonwettingFluid::density(temperature, pressure); 
break;
 
  354            case gPhaseIdx: 
return Gas::density(temperature, pressure); 
break;
 
  355            default: DUNE_THROW(Dune::InvalidStateException, 
"Invalid phase index");
 
 
  369    template <
class Flu
idState>
 
  373        assert(0 <= phaseIdx && phaseIdx < 
numPhases);
 
  375        Scalar temperature = fluidState.temperature(phaseIdx);
 
  376        Scalar pressure = fluidState.pressure(phaseIdx);
 
  380            case wPhaseIdx: 
return WettingFluid::molarDensity(temperature, pressure);
 
  381            case nPhaseIdx: 
return NonwettingFluid::molarDensity(temperature, pressure);
 
  382            case gPhaseIdx: 
return Gas::molarDensity(temperature, pressure);
 
  383            default: DUNE_THROW(Dune::InvalidStateException, 
"Invalid phase index");
 
 
  393    template <
class Flu
idState>
 
  397        assert(0 <= phaseIdx  && phaseIdx < 
numPhases);
 
  399        Scalar temperature = fluidState.temperature(phaseIdx);
 
  400        Scalar pressure = fluidState.pressure(phaseIdx);
 
  404            case wPhaseIdx: 
return WettingFluid::viscosity(temperature, pressure); 
break;
 
  405            case nPhaseIdx: 
return NonwettingFluid::viscosity(temperature, pressure); 
break;
 
  406            case gPhaseIdx: 
return Gas::viscosity(temperature, pressure); 
break;
 
  407            default: DUNE_THROW(Dune::InvalidStateException, 
"Invalid phase index");
 
 
  428    template <
class Flu
idState>
 
  433        assert(0 <= phaseIdx  && phaseIdx < 
numPhases);
 
  436        if (phaseIdx == compIdx)
 
  442        return std::numeric_limits<Scalar>::infinity();
 
 
  468    template <
class Flu
idState>
 
  473        DUNE_THROW(Dune::InvalidStateException,
 
  474                   "Diffusion coefficients of components are meaningless if" 
  475                   " immiscibility is assumed");
 
 
  488    template <
class Flu
idState>
 
  495        DUNE_THROW(Dune::InvalidStateException,
 
  496                   "Binary diffusion coefficients of components are meaningless if" 
  497                   " immiscibility is assumed");
 
 
  506    template <
class Flu
idState>
 
  510        assert(0 <= phaseIdx  && phaseIdx < 
numPhases);
 
  512        Scalar temperature = fluidState.temperature(phaseIdx);
 
  513        Scalar pressure = fluidState.pressure(phaseIdx);
 
  517            case wPhaseIdx: 
return WettingFluid::enthalpy(temperature, pressure); 
break;
 
  518            case nPhaseIdx: 
return NonwettingFluid::enthalpy(temperature, pressure); 
break;
 
  519            case gPhaseIdx: 
return Gas::enthalpy(temperature, pressure); 
break;
 
  520            default: DUNE_THROW(Dune::InvalidStateException, 
"Invalid phase index");
 
 
  530    template <
class Flu
idState>
 
  534        assert(0 <= phaseIdx  && phaseIdx < 
numPhases);
 
  536        Scalar temperature = fluidState.temperature(phaseIdx);
 
  537        Scalar pressure = fluidState.pressure(phaseIdx);
 
  541            case wPhaseIdx: 
return WettingFluid::thermalConductivity(temperature, pressure); 
break;
 
  542            case nPhaseIdx: 
return NonwettingFluid::thermalConductivity(temperature, pressure); 
break;
 
  543            case gPhaseIdx: 
return Gas::thermalConductivity(temperature, pressure); 
break;
 
  544            default: DUNE_THROW(Dune::InvalidStateException, 
"Invalid phase index");
 
 
  560    template <
class Flu
idState>
 
  564        assert(0 <= phaseIdx  && phaseIdx < 
numPhases);
 
  566        Scalar temperature = fluidState.temperature(phaseIdx);
 
  567        Scalar pressure = fluidState.pressure(phaseIdx);
 
  571            case wPhaseIdx: 
return WettingFluid::heatCapacity(temperature, pressure); 
break;
 
  572            case nPhaseIdx: 
return NonwettingFluid::heatCapacity(temperature, pressure); 
break;
 
  573            case gPhaseIdx: 
return Gas::heatCapacity(temperature, pressure); 
break;
 
  574            default: DUNE_THROW(Dune::InvalidStateException, 
"Invalid phase index");
 
 
 
A gaseous phase consisting of a single component.
A liquid phase consisting of a single component.
Fluid system base class.
Definition fluidsystems/base.hh:32
Scalar Scalar
Definition fluidsystems/base.hh:35
A fluid system for three-phase models assuming immiscibility and thermodynamic equilibrium.
Definition 3pimmiscible.hh:49
static std::string componentName(int compIdx)
Return the human readable name of a component.
Definition 3pimmiscible.hh:193
static constexpr int numPhases
Number of phases in the fluid system.
Definition 3pimmiscible.hh:65
static constexpr bool isCompressible(int phaseIdx)
Returns true if and only if a fluid phase is assumed to be compressible.
Definition 3pimmiscible.hh:140
static constexpr int wPhaseIdx
Index of the wetting phase.
Definition 3pimmiscible.hh:68
static constexpr void init()
Initialize the fluid system's static parameters.
Definition 3pimmiscible.hh:281
static std::string phaseName(int phaseIdx)
Return the human readable name of a fluid phase.
Definition 3pimmiscible.hh:78
static constexpr int gCompIdx
Index of the gas phase's component.
Definition 3pimmiscible.hh:186
static Scalar viscosity(const FluidState &fluidState, int phaseIdx)
Return the viscosity of a phase .
Definition 3pimmiscible.hh:394
static void init(Scalar tempMin, Scalar tempMax, unsigned nTemp, Scalar pressMin, Scalar pressMax, unsigned nPress)
Initialize the fluid system's static parameters using problem specific temperature and pressure range...
Definition 3pimmiscible.hh:299
static constexpr int numComponents
Number of components in the fluid system.
Definition 3pimmiscible.hh:179
static Scalar molarMass(int compIdx)
Return the molar mass of a component in .
Definition 3pimmiscible.hh:210
static constexpr int wCompIdx
Index of the wetting phase's component.
Definition 3pimmiscible.hh:182
static Scalar criticalPressure(int compIdx)
Critical pressure of a component .
Definition 3pimmiscible.hh:244
static Scalar fugacityCoefficient(const FluidState &fluidState, int phaseIdx, int compIdx)
Calculate the fugacity coefficient  of an individual component in a fluid phase.
Definition 3pimmiscible.hh:429
static constexpr int nPhaseIdx
Index of the nonwetting phase.
Definition 3pimmiscible.hh:70
static Scalar criticalTemperature(int compIdx)
Critical temperature of a component .
Definition 3pimmiscible.hh:227
static constexpr bool isGas(int phaseIdx)
Return whether a phase is gaseous.
Definition 3pimmiscible.hh:102
static Scalar density(const FluidState &fluidState, int phaseIdx)
Calculate the density  of a fluid phase.
Definition 3pimmiscible.hh:342
static Scalar diffusionCoefficient(const FluidState &fluidState, int phaseIdx, int compIdx)
Calculate the binary molecular diffusion coefficient for a component in a fluid phase .
Definition 3pimmiscible.hh:469
static constexpr bool isMiscible()
Returns whether the fluids are miscible.
Definition 3pimmiscible.hh:95
static Scalar heatCapacity(const FluidState &fluidState, int phaseIdx)
Thermal conductivity  of a fluid phase .
Definition 3pimmiscible.hh:561
static constexpr int gPhaseIdx
Index of the gas phase.
Definition 3pimmiscible.hh:72
static Scalar acentricFactor(int compIdx)
The acentric factor of a component .
Definition 3pimmiscible.hh:261
static constexpr bool isIdealGas(int phaseIdx)
Returns true if and only if a fluid phase is assumed to be an ideal gas.
Definition 3pimmiscible.hh:160
static Scalar molarDensity(const FluidState &fluidState, int phaseIdx)
The molar density  of a fluid phase  in .
Definition 3pimmiscible.hh:370
static Scalar thermalConductivity(const FluidState &fluidState, int phaseIdx)
Thermal conductivity of a fluid phase .
Definition 3pimmiscible.hh:531
static constexpr bool isIdealMixture(int phaseIdx)
Returns true if and only if a fluid phase is assumed to be an ideal mixture.
Definition 3pimmiscible.hh:128
static constexpr int nCompIdx
Index of the nonwetting phase's component.
Definition 3pimmiscible.hh:184
static Scalar enthalpy(const FluidState &fluidState, int phaseIdx)
Return the specific enthalpy of a fluid phase .
Definition 3pimmiscible.hh:507
static Scalar binaryDiffusionCoefficient(const FluidState &fluidState, int phaseIdx, int compIIdx, int compJIdx)
Given a phase's composition, temperature and pressure, return the binary diffusion coefficient  for c...
Definition 3pimmiscible.hh:489
Base class for all components Components provide the thermodynamic relations for the liquid,...
Represents all relevant thermodynamic quantities of a multi-phase fluid system assuming immiscibility...
A collection of input/output field names for common physical quantities.
std::string gaseousPhase() noexcept
I/O name of gaseous phase.
Definition name.hh:111
std::string naplPhase() noexcept
I/O name of napl phase.
Definition name.hh:119
std::string aqueousPhase() noexcept
I/O name of aqueous phase.
Definition name.hh:115
IsAqueous struct.
Definition components/base.hh:34