humidityTemperatureCoupledMixedFvPatchScalarField.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) 2015-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::
    compressible::
    humidityTemperatureCoupledMixedFvPatchScalarField
 
Description
    Mixed boundary condition for temperature to be used at the coupling
    interface between fluid solid regions.
 
    This boundary condition can operate in four modes:
    - \c constantMass: thermal inertia only
      - requires \c rho, \c thickness and \c cp
    - \c condensation: condensation only
      - when the wall temperature (Tw) is below the dew temperature (Tdew)
        condesation takes place and the resulting condensed mass is stored
        on the wall
    - \c evaporation: evaporation only
      - initial mass is vaporized when Tw is above the input vaporization
        temperature (Tvap).
    - \c condensationAndEvaporation : condensation and evaporation take place
      simultaneously.
 
    There is no mass flow on the wall, i.e. the mass condensed on a face
    remains on that face. It uses a 'lumped mass' model to include thermal
    inertia effects.
 
    It assumes a drop-wise type of condensation, whereby its heat transfer
    Nusselt number is calculated using:
    \f{eqnarray*}{
        51104 + 2044 (T - 273.15)   & T > 295 & T < 373 \\
        255510                      & T > 373 &
    \f}
 
    References:
    \verbatim
        Standard models (tag:BLID):
            Bergman, T. L., Lavine, A. S.,
            Incropera, F. P., & Dewitt, D. P. (2011).
            Fundamentals of heat and mass transfer.
            John Wiley & Sons. 7th Edition. Chapter 10.
            ISBN:9780470501979
    \endverbatim
 
    The mass transfer correlation used is:
 
    \f[ h_m = D_{ab} \frac{Sh}{L} \f]
 
    where:
    \vartable
        D_{ab} | mass vapour difussivity
        L      | characteristic length
        Sh     | Sherwood number
    \endvartable
 
    The Sherwood number is calculated using:
 
    \f{eqnarray*}{
            0.664 Re^\frac{1}{2} Sc^\frac{1}{3} & Re < 5.0E+05 \\
            0.037 Re^\frac{4}{5} Sc^\frac{1}{3} & Re > 5.0E+05
    \f}
    where:
    \vartable
        Re     | Reynolds number
        Sc     | Schmidt number
    \endvartable
 
    NOTE:
    - The correlation used to calculate Tdew is for water vapour.
    - A scalar transport equation for the carrier specie is required, e.g.
      supplied via a function object or in the main solver. This specie
      transports the vapour phase in the main ragion.
    - The boundary condition of this specie on the coupled wall must be
      fixedGradient in order to allow condensation or evaporation of the
      vapour in or out of this wall
    - Addition of extra layers in possible using thicknessLayers and
      kappaLayers
 
 
    Example usage:
 
    On the fluid side
    \verbatim
    myInterfacePatchName
    {
        type            thermalHumidityCoupledMixed;
        kappaMethod     fluidThermo;
        kappa           none;
 
        // Modes of operation: inert, condensation, vaporization, condEvap
        mode            condEvap;
 
        // Carrier species name
        specieName      H2O;
 
        // Carrier molecular weight
        carrierMolWeight           28.9;
 
        // Characteristic length of the wall
        L               0.1;
 
        // Vaporisation temperature
        Tvap            273;
 
        // Liquid properties for the condensed mass
        liquid
        {
            H2O
            {
                defaultCoeffs       yes;
            }
        }
 
        thicknessLayers (0.1 0.2 0.3 0.4);
        kappaLayers     (1 2 3 4);
 
        // thickness, density and cp required for inert and condensation
        // modes
 
        //thickness       uniform 0;
        //cp              uniform 0;
        //rho             uniform 0;
 
        value           $internalField;
    }
    \endverbatim
 
    On the solid side:
    \verbatim
    myInterfacePatchName
    {
        type            thermalInertiaMassTransferCoupledMixed;
        kappaMethod     solidThermo;
        kappa           none;
        value           uniform 260;
    }
    \endverbatim
 
 
SourceFiles
    humidityTemperatureCoupledMixedFvPatchScalarField.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef humidityTemperatureCoupledMixedFvPatchScalarField_H
#define humidityTemperatureCoupledMixedFvPatchScalarField_H
 
#include "mixedFvPatchFields.H"
#include "temperatureCoupledBase.H"
#include "liquidProperties.H"
#include "autoPtr.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
/*---------------------------------------------------------------------------*\
      Class humidityTemperatureCoupledMixedFvPatchScalarField Declaration
\*---------------------------------------------------------------------------*/
 
class humidityTemperatureCoupledMixedFvPatchScalarField
:
    public mixedFvPatchScalarField,
    public temperatureCoupledBase
{
public:
 
    //  Public enumeration
 
        //- Modes of mass transfer
        enum massTransferMode
        {
            mtConstantMass,
            mtCondensation,
            mtEvaporation,
            mtCondensationAndEvaporation
        };
 
 
private:
 
    // Private data
 
        static const Enum<massTransferMode> massModeTypeNames_;
 
        //- Operating mode
        massTransferMode mode_;
 
 
        // Field names
 
            //- Name of the pressure field
            const word pName_;
 
            //- Name of the velocity field
            const word UName_;
 
            //- Name of the density field
            const word rhoName_;
 
            //- Name of the dynamic viscosity field
            const word muName_;
 
            //- Name of temperature field on the neighbour region
            const word TnbrName_;
 
            //- Name of the radiative heat flux in the neighbour region
            const word qrNbrName_;
 
            //- Name of the radiative heat flux field
            const word qrName_;
 
            //- Name of the species on which the mass transferred (default H2O)
            const word specieName_;
 
 
        //- Liquid properties
        autoPtr<liquidProperties> liquid_;
 
        //- Liquid dictionary
        dictionary liquidDict_;
 
        //- Mass accumulated on faces
        scalarField mass_;
 
        //- Vaporization temperature
        scalar Tvap_;
 
        //- Cache myDelta
        scalarField myKDelta_;
 
        //- Phase change energy
        scalarField dmHfg_;
 
        //- Thermal inertia
        scalarField mpCpTp_;
 
        //- Average molecular weight for the carrier mixture in the gas phase
        scalar Mcomp_;
 
        //- Characteristic length scale
        scalar L_;
 
        //- Fluid side
        bool fluid_;
 
        //- Cp field for inert mode
        scalarField cp_;
 
        //- Thickness field for inert mode
        scalarField thickness_;
 
        //- Density field for inert mode
        scalarField rho_;
 
        //- Thickness of layers
        scalarList thicknessLayers_;
 
        //- Conductivity of layers
        scalarList kappaLayers_;
 
 
    // Private members
 
        //- Calculation of Sh
        scalar Sh(const scalar Re, const scalar Sc) const;
 
        //- Calculation of htc from the condensed surface
        scalar htcCondensation(const scalar TSat, const scalar Re) const;
 
        //- Lookup (or create) thickness field for output
        volScalarField& thicknessField(const word&, const fvMesh&);
 
 
public:
 
    //- Runtime type information
    TypeName("humidityTemperatureCoupledMixed");
 
 
    // Constructors
 
        //- Construct from patch and internal field
        humidityTemperatureCoupledMixedFvPatchScalarField
        (
            const fvPatch&,
            const DimensionedField<scalar, volMesh>&
        );
 
        //- Construct from patch, internal field and dictionary
        humidityTemperatureCoupledMixedFvPatchScalarField
        (
            const fvPatch&,
            const DimensionedField<scalar, volMesh>&,
            const dictionary&
        );
 
        //- Construct by mapping given
        //  turbulentTemperatureCoupledBaffleMixedFvPatchScalarField onto a
        //  new patch
        humidityTemperatureCoupledMixedFvPatchScalarField
        (
            const
            humidityTemperatureCoupledMixedFvPatchScalarField&,
            const fvPatch&,
            const DimensionedField<scalar, volMesh>&,
            const fvPatchFieldMapper&
        );
 
        //- Construct as copy setting internal field reference
        humidityTemperatureCoupledMixedFvPatchScalarField
        (
            const humidityTemperatureCoupledMixedFvPatchScalarField&,
            const DimensionedField<scalar, volMesh>&
        );
 
        //- Return a clone
        virtual tmp<fvPatchField<scalar>> clone() const
        {
            return fvPatchField<scalar>::Clone(*this);
        }
 
        //- Clone with an internal field reference
        virtual tmp<fvPatchField<scalar>> clone
        (
            const DimensionedField<scalar, volMesh>& iF
        ) const
        {
            return fvPatchField<scalar>::Clone(*this, iF);
        }
 
 
    // Member functions
 
            // Mapping functions
 
                //- Map (and resize as needed) from self given a mapping object
                virtual void autoMap
                (
                    const fvPatchFieldMapper&
                );
 
                //- Reverse map the given fvPatchField onto this fvPatchField
                virtual void rmap
                (
                    const fvPatchScalarField&,
                    const labelList&
                );
 
 
        //- Return myKDelta
        const scalarField myKDelta() const
        {
            return myKDelta_;
        }
 
        //- Return mpCpTp
        const scalarField mpCpTp() const
        {
            return mpCpTp_;
        }
 
        //- Return dmHfg
        const scalarField dmHfg() const
        {
            return dmHfg_;
        }
 
        //- Update the coefficients associated with the patch field
        virtual void updateCoeffs();
 
        //- Write
        virtual void write(Ostream&) const;
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //