combustionfluidsystem.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_PURE_WATER_FLUID_SYSTEM_HH
#define DUMUX_PURE_WATER_FLUID_SYSTEM_HH
 
#include <cassert>
 
#include <dumux/material/idealgas.hh>
 
#include <dumux/material/fluidsystems/base.hh>
#include <dumux/material/components/n2.hh>
#include <dumux/material/components/simpleh2o.hh>
#include <dumux/material/binarycoefficients/h2o_n2.hh>
 
#include <dumux/common/valgrind.hh>
#include <dumux/common/exceptions.hh>
 
namespace Dumux {
namespace FluidSystems {
 
template <class Scalar>
class CombustionFluidsystem
    : public Base<Scalar, CombustionFluidsystem<Scalar> >
{
    using ThisType = CombustionFluidsystem<Scalar>;
    using Base = Dumux::FluidSystems::Base<Scalar, ThisType>;
 
    // convenience using declarations
    using IdealGas = Dumux::IdealGas<Scalar>;
    using SimpleH2O = Dumux::Components::SimpleH2O<Scalar>;
    using SimpleN2 = Dumux::Components::N2<Scalar>;
 
public:
    /****************************************
     * Fluid phase related static parameters
     ****************************************/
 
    static constexpr int numPhases = 2;
 
    static constexpr int wPhaseIdx = 0; // index of the wetting phase
    static constexpr int nPhaseIdx = 1; // index of the non-wetting phase
    static constexpr int phase0Idx = 0; // index of the wetting phase
    static constexpr int phase1Idx = 1; // index of the non-wetting phase
 
    // export component indices to indicate the main component
    // of the corresponding phase at atmospheric pressure 1 bar
    // and room temperature 20°C:
    static constexpr int wCompIdx = wPhaseIdx;
    static constexpr int nCompIdx = nPhaseIdx;
    static constexpr int comp0Idx = 0; // index of the wetting phase
    static constexpr int comp1Idx = 1; // index of the non-wetting phase
 
    static std::string phaseName(int phaseIdx)
    {
        assert(0 <= phaseIdx && phaseIdx < numPhases);
        switch (phaseIdx)
        {
            case wPhaseIdx: return "liq";
            case nPhaseIdx: return "gas";
        }
        DUNE_THROW(Dune::InvalidStateException, "Invalid phase index " << phaseIdx);
    }
 
    static constexpr bool isGas(int phaseIdx)
    {
        assert(0 <= phaseIdx && phaseIdx < numPhases);
        return phaseIdx == nPhaseIdx;
    }
 
    static bool isIdealMixture(int phaseIdx)
    {
        assert(0 <= phaseIdx && phaseIdx < numPhases);
        // we assume Henry's and Raoult's laws for the water phase and
        // and no interaction between gas molecules of different
        // components, so all phases are ideal mixtures!
        return true;
    }
 
    static constexpr bool isCompressible(int phaseIdx)
    {
        assert(0 <= phaseIdx && phaseIdx < numPhases);
        // gases are always compressible
        if (phaseIdx == nPhaseIdx)
            return true;
        // the water component decides for the liquid phase...
        return H2O::liquidIsCompressible();
    }
 
    static bool isIdealGas(int phaseIdx)
    {
        assert(0 <= phaseIdx && phaseIdx < numPhases);
 
        if (phaseIdx == nPhaseIdx)
            // let the components decide
            return H2O::gasIsIdeal() && N2::gasIsIdeal();
        return false; // not a gas
    }
 
    /****************************************
     * Component related static parameters
     ****************************************/
 
    static constexpr int numComponents = 2;
 
    static constexpr int H2OIdx = wCompIdx;
    static constexpr int N2Idx = nCompIdx;
 
    using H2O = SimpleH2O;
 
    using N2 = SimpleN2;
 
    static std::string componentName(int compIdx)
    {
        static std::string name[] = {
            H2O::name(),
            N2::name()
        };
 
        assert(0 <= compIdx && compIdx < numComponents);
        return name[compIdx];
    }
 
    static Scalar molarMass(int compIdx)
    {
        static const Scalar M[] = {
            H2O::molarMass(),
            N2::molarMass(),
        };
 
        assert(0 <= compIdx && compIdx < numComponents);
        return M[compIdx];
    }
 
    static Scalar criticalTemperature(int compIdx)
    {
        static const Scalar Tcrit[] = {
            H2O::criticalTemperature(), // H2O
            N2::criticalTemperature() // N2
        };
 
        assert(0 <= compIdx && compIdx < numComponents);
        return Tcrit[compIdx];
    }
 
    static Scalar criticalPressure(int compIdx)
    {
        static const Scalar pcrit[] = {
            H2O::criticalPressure(),
            N2::criticalPressure()
        };
 
        assert(0 <= compIdx && compIdx < numComponents);
        return pcrit[compIdx];
    }
 
    static Scalar criticalMolarVolume(int compIdx)
    {
        DUNE_THROW(Dune::NotImplemented, "criticalMolarVolume()");
    }
 
    static Scalar acentricFactor(int compIdx)
    {
        static const Scalar accFac[] = {
            H2O::acentricFactor(), // H2O (from Reid, et al.)
            N2::acentricFactor()
        };
 
        assert(0 <= compIdx && compIdx < numComponents);
        return accFac[compIdx];
    }
 
    /****************************************
     * thermodynamic relations
     ****************************************/
 
    static void init()
    {
        init(/*tempMin=*/273.15,
             /*tempMax=*/623.15,
             /*numTemp=*/100,
             /*pMin=*/0.0,
             /*pMax=*/20e6,
             /*numP=*/200);
    }
 
    static void init(Scalar tempMin, Scalar tempMax, unsigned nTemp,
                     Scalar pressMin, Scalar pressMax, unsigned nPress)
    {
        std::cout << "Using very simple pure water fluid system\n";
    }
 
    using Base::density;
    template <class FluidState>
    static Scalar density(const FluidState &fluidState,
                          int phaseIdx)
    {
        assert(0 <= phaseIdx  && phaseIdx < numPhases);
 
        // liquid phase
        if (phaseIdx == wPhaseIdx)
        {
            return 1044.0;
        }
        else if (phaseIdx == nPhaseIdx)// gas phase
        {
            return 1.679;
        }
        else DUNE_THROW(Dune::NotImplemented, "Wrong phase index");
    }
 
    using Base::molarDensity;
    template <class FluidState>
    static Scalar molarDensity(const FluidState &fluidState, int phaseIdx)
    {
        if (phaseIdx == wPhaseIdx)
        {
            return density(fluidState, phaseIdx)/fluidState.averageMolarMass(phaseIdx);
        }
        else if (phaseIdx == nPhaseIdx)
        {
            return density(fluidState, phaseIdx)/fluidState.averageMolarMass(phaseIdx);
        }
        else DUNE_THROW(Dune::NotImplemented, "Wrong phase index");
    }
 
    using Base::viscosity;
    template <class FluidState>
    static Scalar viscosity(const FluidState &fluidState,
                            int phaseIdx)
    {
        assert(0 <= phaseIdx  && phaseIdx < numPhases);
 
        // liquid phase
        if (phaseIdx == wPhaseIdx)
        {
            return 2.694e-7 * density(fluidState, phaseIdx);
        }
        else if (phaseIdx == nPhaseIdx) // gas phase
        {
            return 7.16e-6 * density(fluidState, phaseIdx);
        }
        else DUNE_THROW(Dune::NotImplemented, "Wrong phase index");
    }
 
    template <class FluidState>
    static Scalar vaporTemperature(const FluidState &fluidState,
                                   const unsigned int phaseIdx)
    {
        assert(0 <= phaseIdx  && phaseIdx < numPhases);
        Scalar pressure = fluidState.pressure(nPhaseIdx);
 
        return IAPWS::Region4<Scalar>::vaporTemperature( pressure );
    }
 
    using Base::fugacityCoefficient;
    template <class FluidState>
    static Scalar fugacityCoefficient(const FluidState &fluidState,
                                      int phaseIdx,
                                      int compIdx)
    {
        assert(0 <= phaseIdx  && phaseIdx < numPhases);
        assert(0 <= compIdx  && compIdx < numComponents);
 
        Scalar T = fluidState.temperature(phaseIdx);
        Scalar p = fluidState.pressure(phaseIdx);
 
        // liquid phase
        if (phaseIdx == wPhaseIdx)
        {
            if (compIdx == H2OIdx)
                return H2O::vaporPressure(T)/p;
            return BinaryCoeff::H2O_N2::henry(T)/p;
        }
 
        // for the gas phase, assume an ideal gas when it comes to
        // fugacity (-> fugacity == partial pressure)
        return 1.0;
    }
 
    using Base::diffusionCoefficient;
    template <class FluidState>
    static Scalar diffusionCoefficient(const FluidState &fluidState,
                                       int phaseIdx,
                                       int compIdx)
    {
        DUNE_THROW(Dune::NotImplemented, "Diffusion coefficients");
    }
 
    using Base::binaryDiffusionCoefficient;
    template <class FluidState>
    static Scalar binaryDiffusionCoefficient(const FluidState &fluidState,
                                             int phaseIdx,
                                             int compIIdx,
                                             int compJIdx)
 
    {
        DUNE_THROW(Dune::NotImplemented, "Binary Diffusion coefficients");
    }
 
    using Base::enthalpy;
    template <class FluidState>
    static Scalar enthalpy(const FluidState &fluidState,
                           int phaseIdx)
    {
        assert(0 <= phaseIdx  && phaseIdx < numPhases);
        Scalar temperature = fluidState.temperature(phaseIdx);
 
        const Scalar cp = heatCapacity(fluidState, phaseIdx);
 
        // liquid phase
        if (phaseIdx == wPhaseIdx)
        {
            return cp * (temperature - 373.15);
        }
        else if (phaseIdx == nPhaseIdx) // gas phase
        {
            return cp * (temperature - 373.15) + 2.257e6;
        }
        else DUNE_THROW(Dune::NotImplemented, "Wrong phase index");
    }
 
    using Base::thermalConductivity;
    template <class FluidState>
    static Scalar thermalConductivity(const FluidState &fluidState,
                                      const int phaseIdx)
    {
        assert(0 <= phaseIdx  && phaseIdx < numPhases);
        // liquid phase
        if (phaseIdx == wPhaseIdx)
        {
            return 0.68;
        }
        else if (phaseIdx == nPhaseIdx) // gas phase
        {
            return 0.0248;
        }
        else DUNE_THROW(Dune::NotImplemented, "Wrong phase index");
    }
 
    using Base::heatCapacity;
    template <class FluidState>
    static Scalar heatCapacity(const FluidState &fluidState,
                               int phaseIdx)
    {
        assert(0 <= phaseIdx  && phaseIdx < numPhases);
        // liquid phase
        if (phaseIdx == wPhaseIdx)
        {
            return 4.217e3;
        }
        else if (phaseIdx == nPhaseIdx) // gas phase
        {
            return 2.029e3;
        }
        else DUNE_THROW(Dune::NotImplemented, "Wrong phase index");
    }
};
 
} // end namespace FluidSystems
} // end namespace Dumux
 
#endif