phaseModel.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::phaseModel

Description

SourceFiles
    phaseModel.C

\*---------------------------------------------------------------------------*/

#ifndef Foam_multiphaseInter_phaseModel_H
#define Foam_multiphaseInter_phaseModel_H

#include "dictionary.H"
#include "dimensionedScalar.H"
#include "volFields.H"
#include "surfaceFields.H"
#include "fvMatricesFwd.H"
#include "runTimeSelectionTables.H"
#include "rhoThermo.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

// Forward Declarations
class multiphaseInterSystem;

namespace multiphaseInter
{
/*---------------------------------------------------------------------------*\
                         Class phaseModel Declaration
\*---------------------------------------------------------------------------*/

class phaseModel
:
    public volScalarField
{
    // Private Data

        //- Reference to the multiphaseInterSystem to which this phase belongs
        const multiphaseInterSystem& fluid_;

        //- Name of phase
        word name_;


public:

    //- Runtime type information
    ClassName("phaseModel");

    // Declare runtime construction
    declareRunTimeSelectionTable
    (
        autoPtr,
        phaseModel,
        multiphaseInterSystem,
        (
            const multiphaseInterSystem& fluid,
            const word& phaseName
        ),
        (fluid, phaseName)
    );


    // Constructors

        //- Construct from multiphaseInterSystem and phaseName
        phaseModel(const multiphaseInterSystem& fluid, const word& phaseName);


    //- Destructor
    virtual ~phaseModel() = default;


    // Selectors

        static autoPtr<phaseModel> New
        (
            const multiphaseInterSystem& fluid,
            const word& phaseName
        );


    // Member Functions

        //- The name of this phase
        const word& name() const
        {
            return name_;
        }

        //- Return the system to which this phase belongs
        const multiphaseInterSystem& fluid() const;

        //- Correct phase thermo
        virtual void correct();

        //- Correct the turbulence
        virtual void correctTurbulence();

        //- Solve species fraction equation
        virtual void solveYi
        (
            PtrList<volScalarField::Internal>& Su,
            PtrList<volScalarField::Internal>& Sp
        ) = 0;

        //- Read phase properties dictionary
        virtual bool read();


    // Thermo

        //- Access const to phase thermo
        virtual const rhoThermo& thermo() const = 0;

        //- Access to phase thermo
        virtual rhoThermo& thermo() = 0;

        //- Return the phase density
        tmp<volScalarField> rho() const;

        //- Return phase density on a patch
        tmp<scalarField> rho(const label patchi) const;

        //- Chemical enthalpy for phase [J/kg]
        tmp<volScalarField> hc() const;

        //- Return phase Cp
        tmp<volScalarField> Cp() const;

        //- Heat capacity of the phase at constant pressure for patch
        // [J/kg/K]
        tmp<scalarField> Cp
        (
            const scalarField& p,
            const scalarField& T,
            const label patchi
        ) const;

        //- Return Cv of the phase
        tmp<volScalarField> Cv() const;

        //- Heat capacity at constant volume for phase for a patch [J/kg/K]
        tmp<scalarField> Cv
        (
            const scalarField& p,
            const scalarField& T,
            const label patchI
        ) const;

        //- Gamma = Cp/Cv of phase[]
        tmp<volScalarField> gamma() const;

        //- Gamma = Cp/Cv for phase on patch []
        tmp<scalarField> gamma
        (
            const scalarField& p,
            const scalarField& T,
            const label patchi
        ) const;

        //- Heat capacity at constant pressure/volume for phase [J/kg/K]
        tmp<volScalarField> Cpv() const;

        //- Heat capacity at constant pressure/volume for phase at patch
        // [J/kg/K]
        tmp<scalarField> Cpv
        (
            const scalarField& p,
            const scalarField& T,
            const label patchi
        ) const;

        //- Heat capacity ratio for phase []
        tmp<volScalarField> CpByCpv() const;

        //- Heat capacity ratio for phase at patch []
        tmp<scalarField> CpByCpv
        (
            const scalarField& p,
            const scalarField& T,
            const label patchi
        ) const;

        //- Query thermo for dpdt
        bool dpdt() const
        {
             return thermo().dpdt();
        }


    // Transport

        //- Thermal diffusivity for enthalpy of mixture [kg/m/s]
        const volScalarField& alpha() const;

        //- Thermal diffusivity for enthalpy of mixture for patch [kg/m/s]
        const scalarField& alpha(const label patchi) const;

        //- Thermal diffusivity for temperature of phase [J/m/s/K]
        tmp<volScalarField> kappa() const;

        //- Thermal diffusivity for temperature of phase for patch [J/m/s/K]
        tmp<scalarField> kappa(const label patchi) const;

        //- Thermal diffusivity for energy of mixture [kg/m/s]
        tmp<volScalarField> alphahe() const;

        //- Thermal diffusivity for energy of mixture for patch [kg/m/s]
        tmp<scalarField> alphahe(const label patchi) const;

        //- Effective thermal diffusivity for temperature of phase [J/m/s/K]
        tmp<volScalarField> kappaEff(const volScalarField&) const;

        //- Effective thermal diffusivity for temperature
        //  of phase for patch [J/m/s/K]
        tmp<scalarField> kappaEff
        (
            const scalarField& alphat,
            const label patchi
        ) const;

        //- Effective thermal diffusivity of phase [kg/m/s]
        tmp<volScalarField> alphaEff(const volScalarField& alphat) const;

        //- Effective thermal diffusivity of phase for patch [kg/m/s]
        tmp<scalarField> alphaEff
        (
            const scalarField& alphat,
            const label patchi
        ) const;

        //- Return the mixture kinematic viscosity
        virtual tmp<volScalarField> nu() const;

        //- Return the mixture kinematic viscosity on patchi
        virtual tmp<scalarField> nu(const label patchi) const;

        //- Return the mixture dymanic viscosity
        virtual tmp<volScalarField> mu() const;

        //- Return the mixture dymanic viscosity on patchi
        virtual tmp<scalarField> mu(const label patchi) const;

        //- Diffusion number
        virtual tmp<surfaceScalarField> diffNo() const = 0;


    // Species

        //- Constant access the species mass fractions
        virtual const PtrList<volScalarField>& Y() const = 0;

        //- Access the species mass fractions
        virtual PtrList<volScalarField>& Y() = 0;


    // Momentum

        //- Constant access the volumetric flux
        virtual tmp<surfaceScalarField> phi() const = 0;

        //- Access the volumetric flux
        virtual const surfaceScalarField& phi() = 0;

        //- Constant access the volumetric flux of the phase
        virtual tmp<surfaceScalarField> alphaPhi() const = 0;

        //- Access the volumetric flux of the phase
        virtual surfaceScalarField& alphaPhi() = 0;

        //- Access const reference to U
        virtual tmp<volVectorField> U() const = 0;


    // Turbulence (WIP: possible to add turbulence on each phase)

        /*
        //- Return the turbulent dynamic viscosity
        virtual tmp<volScalarField> mut() const = 0;

        //- Return the turbulent dynamic viscosity on a patch
        virtual tmp<scalarField> mut(const label patchI) const = 0;

        //- Return the turbulent kinematic viscosity
        virtual tmp<volScalarField> nut() const = 0;

        //- Return the turbulent kinematic viscosity on a patch
        virtual tmp<scalarField> nut(const label patchI) const = 0;

        //- Return the kinetic pressure derivative w.r.t. volume fraction
        virtual tmp<volScalarField> pPrime() const = 0;

        //- Return the turbulent kinetic energy
        virtual tmp<volScalarField> k() const = 0;
        */
};

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace multiphaseInter
} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //


#endif

// ************************************************************************* //