multiphaseInterSystem.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2017-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.
 
    OpenFOAM 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.
 
    OpenFOAM 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 OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
Class
    Foam::multiphaseInterSystem
 
Description
 
SourceFiles
    multiphaseInterSystem.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef multiphaseInterSystem_H
#define multiphaseInterSystem_H
 
#include "basicThermo.H"
 
#include "phaseModel.H"
#include "phasePair.H"
#include "orderedPhasePair.H"
 
#include "volFields.H"
#include "surfaceFields.H"
#include "fvMatricesFwd.H"
#include "compressibleTransportModel.H"
#include "localMin.H"
 
#include "compressibleTurbulenceModel.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
// Forward Declarations
namespace multiphaseInter
{
class surfaceTensionModel;
}
class porousModel;
 
/*---------------------------------------------------------------------------*\
                    Class multiphaseInterSystem Declaration
\*---------------------------------------------------------------------------*/
 
class multiphaseInterSystem
:
    public basicThermo,
    public compressibleTransportModel
{
public:
 
    // Public typedefs
 
        typedef
            HashTable
            <
                autoPtr<phasePair>, phasePairKey, phasePairKey::hash
            >
            phasePairTable;
 
 
        typedef HashTable<autoPtr<multiphaseInter::phaseModel>> phaseModelTable;
 
 
        typedef HashTable<volScalarField::Internal> SuSpTable;
 
 
protected:
 
    // Protected typedefs
 
        typedef
            HashTable<dictionary, phasePairKey, phasePairKey::hash> dictTable;
 
 
        typedef
            HashTable
            <
                autoPtr<multiphaseInter::surfaceTensionModel>,
                phasePairKey,
                phasePairKey::hash
            >
            surfaceTensionModelTable;
 
 
        typedef
            HashTable
            <
                autoPtr<porousModel>,
                phasePairKey,
                phasePairKey::hash
            >
            interfacePorousModelTable;
 
 
 
    // Protected data
 
        //- Reference to the mesh
        const fvMesh& mesh_;
 
        //- Dynamic viscocity
        volScalarField mu_;
 
        //- Phase names
        wordList phaseNames_;
 
        //- Mixture total volumetric flux
        surfaceScalarField phi_;
 
        //- Mixture total mass flux
        surfaceScalarField rhoPhi_;
 
        //- Phase models
        phaseModelTable phaseModels_;
 
        //- Phase pairs
        phasePairTable phasePairs_;
 
        //- Total ordered phase pairs in the system
        phasePairTable totalPhasePairs_;
 
        //- Turbulent Prandt number
        dimensionedScalar Prt_;
 
        //- Turbulence model
        compressibleTurbulenceModel* turb_;
 
 
        // Sub Models
 
            //- Surface tension models
            surfaceTensionModelTable surfaceTensionModels_;
 
            //- Interface porous models
            interfacePorousModelTable interfacePorousModelTable_;
 
 
    // Protected member functions
 
 
        //- Calculate and return the laminar viscosity
        void calcMu();
 
        //- Generate the phases
        HashTable<autoPtr<multiphaseInter::phaseModel>> generatePhaseModels
        (
            const wordList& names
        ) const;
 
        //- Generate the mixture flux
        tmp<surfaceScalarField> generatePhi
        (
            const HashTable<autoPtr<multiphaseInter::phaseModel>>& phaseModels
        ) const;
 
        //- Generate pairs
        void generatePairs(const dictTable& modelDicts);
 
        //- Generate pair table
        void generatePairsTable();
 
        //- Generate pairs and sub-model tables using pair keys
        template<class modelType>
        void createSubModels
        (
            const dictTable& modelDicts,
            HashTable
            <
                autoPtr<modelType>,
                phasePairKey,
                phasePairKey::hash
            >& models
        );
 
        //- Generate pairs and sub-model tables using mesh
        template<class modelType>
        void createSubModels
        (
            const dictTable& modelDicts,
            const fvMesh& mesh,
            HashTable
            <
                autoPtr<modelType>,
                phasePairKey,
                phasePairKey::hash
            >& models
        );
 
        //- Generate pairs and sub-model tables
        template<class modelType>
        void generatePairsAndSubModels
        (
            const word& modelName,
            HashTable
            <
                autoPtr<modelType>,
                phasePairKey,
                phasePairKey::hash
            >& models
        );
 
 
        //- Generate pairs and per-phase sub-model tables with mesh ref
        template<class modelType>
        void generatePairsAndSubModels
        (
            const word& modelName,
            const fvMesh& mesh,
            HashTable
            <
                autoPtr<modelType>,
                phasePairKey,
                phasePairKey::hash
            >& models
        );
 
 
        //- Generate pairs and per-phase sub-model tables
        template<class modelType>
        void generatePairsAndSubModels
        (
            const word& modelName,
            HashTable
            <
                HashTable<autoPtr<modelType>>,
                phasePairKey,
                phasePairKey::hash
            >& models
        );
 
 
public:
 
    //- Runtime type information
    TypeName("multiphaseInterSystem");
 
    //- Default name of the phase properties dictionary
    static const word phasePropertiesName;
 
 
    // Constructors
 
        //- Construct from fvMesh
        multiphaseInterSystem(const fvMesh& mesh);
 
 
    //- Destructor
    virtual ~multiphaseInterSystem();
 
 
    // Member Functions
 
    // Energy related thermo functionaliy functions
 
        //- Return access to the internal energy field [J/Kg]
        //  \note this mixture thermo is prepared to work with T
        virtual volScalarField& he()
        {
            NotImplemented;
            return const_cast<volScalarField&>(volScalarField::null());
        }
 
        //- Return access to the internal energy field [J/Kg]
        //  \note this mixture thermo is prepared to work with T
        virtual const volScalarField& he() const
        {
           NotImplemented;
           return volScalarField::null();
        }
 
        //- Enthalpy/Internal energy
        //  for given pressure and temperature [J/kg]
        virtual tmp<volScalarField> he
        (
            const volScalarField& p,
            const volScalarField& T
        ) const;
 
        //- Enthalpy/Internal energy for cell-set [J/kg]
        virtual tmp<scalarField> he
        (
            const scalarField& p,
            const scalarField& T,
            const labelList& cells
        ) const;
 
        //- Enthalpy/Internal energy for patch [J/kg]
        virtual tmp<scalarField> he
        (
            const scalarField& p,
            const scalarField& T,
            const label patchi
        ) const;
 
        //- Chemical enthalpy of the mixture [J/kg]
        virtual tmp<volScalarField> hc() const;
 
        //- Temperature from enthalpy/internal energy for cell-set
        virtual tmp<scalarField> THE
        (
            const scalarField& h,
            const scalarField& p,
            const scalarField& T0,
            const labelList& cells
        ) const;
 
        //- Temperature from enthalpy/internal energy for patch
        virtual tmp<scalarField> THE
        (
            const scalarField& h,
            const scalarField& p,
            const scalarField& T0,
            const label patchi
        ) const;
 
 
    // Thermo
 
        //- Return the mixture density
        virtual tmp<volScalarField> rho() const;
 
        //- Return the mixture density on a patch
        virtual tmp<scalarField> rho(const label patchi) const;
 
        //- Return Cp of the mixture
        virtual tmp<volScalarField> Cp() const;
 
        //- Heat capacity at constant pressure for patch [J/kg/K]
        virtual tmp<scalarField> Cp
        (
            const scalarField& p,
            const scalarField& T,
            const label patchi
        ) const;
 
        //- Heat capacity using pressure and temperature
        virtual tmp<scalarField> Cp
        (
            const scalarField& p,
            const scalarField& T,
            const labelList& cells
        ) const
        {
            NotImplemented;
            return tmp<scalarField>::New(p);
        }
 
        //- Return Cv of the mixture
        virtual tmp<volScalarField> Cv() const;
 
        //- Heat capacity at constant volume for patch [J/kg/K]
        virtual tmp<scalarField> Cv
        (
            const scalarField& p,
            const scalarField& T,
            const label patchI
        ) const;
 
        //- Density from pressure and temperature
        virtual tmp<scalarField> rhoEoS
        (
            const scalarField& p,
            const scalarField& T,
            const labelList& cells
        ) const;
 
        //- Gamma = Cp/Cv []
        virtual tmp<volScalarField> gamma() const;
 
        //- Gamma = Cp/Cv for patch []
        virtual tmp<scalarField> gamma
        (
            const scalarField& p,
            const scalarField& T,
            const label patchi
        ) const;
 
         //- Heat capacity at constant pressure/volume [J/kg/K]
        virtual tmp<volScalarField> Cpv() const;
 
        //- Heat capacity at constant pressure/volume for patch [J/kg/K]
        virtual tmp<scalarField> Cpv
        (
            const scalarField& p,
            const scalarField& T,
            const label patchi
        ) const;
 
        //- Heat capacity ratio []
        virtual tmp<volScalarField> CpByCpv() const;
 
        //- Heat capacity ratio for patch []
        virtual tmp<scalarField> CpByCpv
        (
            const scalarField& p,
            const scalarField& T,
            const label patchi
        ) const;
 
        //- Molecular weight [kg/kmol] of the mixture
        virtual tmp<volScalarField> W() const;
 
 
    // Transport
 
        //- Thermal diffusivity for temperature of mixture [J/m/s/K]
        virtual tmp<volScalarField> kappa() const;
 
        //- Thermal diffusivity for temperature
        //  of mixture for patch [J/m/s/K]
        virtual tmp<scalarField> kappa
        (
            const label patchi
        ) const;
 
        //- Thermal diffusivity for energy of mixture [kg/m/s]
        virtual tmp<volScalarField> alphahe() const;
 
        //- Thermal diffusivity for energy of mixture for patch [kg/m/s]
        virtual tmp<scalarField> alphahe(const label patchi) const;
 
        //- Effective thermal diffusivity for temperature
        //  of mixture [J/m/s/K]
        virtual tmp<volScalarField> kappaEff
        (
            const volScalarField& kappat
        ) const;
 
        //- Effective thermal diffusivity for temperature
        //  of mixture for patch [J/m/s/K]
        virtual tmp<scalarField> kappaEff
        (
            const scalarField& alphat,
            const label patchi
        ) const;
 
        //- Effective thermal diffusivity of mixture [kg/m/s]
        virtual tmp<volScalarField> alphaEff
        (
            const volScalarField& alphat
        ) const;
 
        //- Effective thermal diffusivity of mixture for patch [kg/m/s]
        virtual tmp<scalarField> alphaEff
        (
            const scalarField& alphat,
            const label patchi
        ) const;
 
        //- Return Prandt number
        const dimensionedScalar& Prt() const;
 
 
    // Access to transport state variables
 
        //- Dynamic viscosity of mixture [kg/m/s]
        virtual tmp<volScalarField> mu() const;
 
        //- Dynamic viscosity of mixture for patch [kg/m/s]
        virtual tmp<scalarField> mu(const label patchi) const;
 
        //- Kinematic viscosity of mixture [m^2/s]
        virtual tmp<volScalarField> nu() const;
 
        //- Kinematic viscosity of mixture for patch [m^2/s]
        virtual tmp<scalarField> nu(const label patchi) const;
 
 
    // Turbulence
 
        //- Set turbulence model
        void setTurbulence(compressibleTurbulenceModel& turb)
        {
            turb_ = &turb;
        }
 
        //- Return pointer to turbulence model
        compressibleTurbulenceModel* turbulence() const
        {
            return turb_;
        }
 
        //- Return the turbulent dynamic viscosity
        tmp<volScalarField> mut() const;
 
        //- Return the effective dynamic viscosity
        tmp<volScalarField> muEff() const;
 
        //- Return the turbulent kinematic viscosity
        tmp<volScalarField> nut() const;
 
        //- Return the effective kinematic viscosity
        tmp<volScalarField> nuEff() const;
 
        //- Effective thermal turbulent diffusivity for temperature
        //  of mixture [J/m/s/K]
        tmp<volScalarField> kappaEff() const;
 
        //- Effective thermal turbulent diffusivity for temperature
        //  of mixture for patch [J/m/s/K]
        tmp<scalarField> kappaEff(const label patchi) const;
 
        //- Effective thermal turbulent diffusivity of mixture [kg/m/s]
        tmp<volScalarField> alphaEff() const;
 
        //- Effective thermal turbulent diffusivity of mixture [kg/m/s]
        tmp<scalarField> alphaEff(const label patchi) const;
 
 
    // Phase fluxes
 
        //- Constant access to the total flux
        const surfaceScalarField& phi() const;
 
        //- Access to the total mixture flux
        surfaceScalarField& phi();
 
        //- Constant access to the mixture mass flux
        const surfaceScalarField& rhoPhi() const;
 
        //- Access to the total mixture mass flux
        surfaceScalarField& rhoPhi();
 
        //- Mixture U
        tmp<volVectorField> U() const;
 
 
    // Surface tension
 
        //- Calculate surface tension of the mixture
        tmp<surfaceScalarField> surfaceTensionForce() const;
 
        //- Return the surface tension coefficient
        virtual tmp<volScalarField> surfaceTensionCoeff
        (
            const phasePairKey& key
        ) const;
 
 
        //- Return coefficients (1/rho)
        virtual tmp<volScalarField> coeffs(const word& key) const;
 
 
    // Interface porous between solid/fluid phases
 
        //- Add interface porosity on phasePair
        void addInterfacePorosity(fvVectorMatrix& UEqn);
 
 
    // Inter-Phase mass and heat transfe
 
        //- Return interfacial source mass rate per phase pair
        virtual tmp<volScalarField> dmdt(const phasePairKey& key) const = 0;
 
        //- Return the heat transfer matrices
        virtual tmp<fvScalarMatrix> heatTransfer
        (
            const volScalarField& T
        ) = 0;
 
        //- Return the volumetric rate transfer matrix
        virtual tmp<fvScalarMatrix> volTransfer
        (
            const volScalarField& p
        ) = 0;
 
        //- Calculate mass transfer for alpha's
        virtual void alphaTransfer(SuSpTable& Su, SuSpTable& Sp) = 0;
 
        //- Calculate mass transfer for species
        virtual void massSpeciesTransfer
        (
            const multiphaseInter::phaseModel& phase,
            volScalarField::Internal& Su,
            volScalarField::Internal& Sp,
            const word speciesName
        ) = 0;
 
        //- Add volume change in pEq
        virtual bool includeVolChange() = 0;
 
 
    // Solve phases and correct models
 
        //- Solve for the phase transport equations
        virtual void solve() = 0;
 
        //- Correct the mixture thermos
        virtual void correct();
 
        //- Correct mass sources
        virtual void correctMassSources(const volScalarField& T) = 0;
 
        //- Return the name of the thermo physics
        virtual word thermoName() const
        {
            NotImplemented;
            return word();
        }
 
        //- Correct the turbulence
        //  \note Each phase could have its own turbulence
        virtual void correctTurbulence();
 
        //- Read base phaseProperties dictionary
        virtual bool read();
 
 
    // Access to phases models
 
        //- Constant access the total phase pairs
        const phasePairTable& totalPhasePairs() const;
 
        //- Non-constant access the total phase pairs
        phasePairTable& totalPhasePairs();
 
        //- Constant access the phases
        const phaseModelTable& phases() const;
 
        //- Access the phases
        phaseModelTable& phases();
 
        //- Access a sub model between a phase pair
        template <class modelType>
        const modelType& lookupSubModel(const phasePair& key) const;
 
        //- Access a sub model between two phases
        template <class modelType>
        const modelType& lookupSubModel
        (
            const multiphaseInter::phaseModel& from,
            const multiphaseInter::phaseModel& to
        ) const;
 
 
    // Query phase thermo information
 
        //- Return true if the equation of state is incompressible for all
        //  phases
        virtual bool incompressible() const;
 
        //- Return true if a phase is incompressible
        virtual bool incompressible(const word) const;
 
        //- Return true if the equation of state is isochoric for all phasses
        //  i.e. rho = const
        virtual bool isochoric() const;
 
        //- Return mesh
        const fvMesh& mesh() const;
 
 
    // Help functions for the interfaces
 
        //- Interface normal surface vector
        tmp<surfaceVectorField> nHatfv
        (
            const volScalarField& alpha1,
            const volScalarField& alpha2
        ) const;
 
        //- Interface normal volField vector
        tmp<volVectorField> nVolHatfv
        (
            const volScalarField& alpha1,
            const volScalarField& alpha2
        ) const;
 
        //- Interface normal surface vector
        tmp<surfaceScalarField> nHatf
        (
            const volScalarField& alpha1,
            const volScalarField& alpha2
        ) const;
 
        //- Interface curvature
        tmp<volScalarField> K
        (
            const volScalarField& alpha1,
            const volScalarField& alpha2
        ) const;
 
        //- Near Interface of alpha1 and alpha2
        tmp<volScalarField> nearInterface
        (
            const volScalarField& alpha1,
            const volScalarField& alpha2
        ) const;
 
        //- Near Interface of alpha'n
        tmp<volScalarField> nearInterface() const;
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#ifdef NoRepository
#   include "multiphaseInterSystemTemplates.H"
#endif
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //