turbulentBoundaryCoupledFvPatchScalarField.C

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  \\    /   O peration     |
  \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
  \\/     M anipulation  |
  -------------------------------------------------------------------------------
  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/>.
 
  \*---------------------------------------------------------------------------*/
#include "turbulentBoundaryCoupledFvPatchScalarField.H"
#include "addToRunTimeSelectionTable.H"
#include "fvPatchFieldMapper.H"
#include "volFields.H"
#include "mappedPatchBase.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
    namespace incompressible
    {
 
        // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
        turbulentBoundaryCoupledFvPatchScalarField::
            turbulentBoundaryCoupledFvPatchScalarField
            (
             const fvPatch& p,
             const DimensionedField<scalar, volMesh>& iF
            )
            :
                mixedFvPatchScalarField(p, iF),
                TnbrName_("undefined-Tnbr")
        {
            this->refValue() = 0.0;
            this->refGrad() = 0.0;
            this->valueFraction() = 1.0;
        }
 
 
        turbulentBoundaryCoupledFvPatchScalarField::
            turbulentBoundaryCoupledFvPatchScalarField
            (
             const turbulentBoundaryCoupledFvPatchScalarField& ptf,
             const fvPatch& p,
             const DimensionedField<scalar, volMesh>& iF,
             const fvPatchFieldMapper& mapper
            )
            :
                mixedFvPatchScalarField(ptf, p, iF, mapper),
                TnbrName_(ptf.TnbrName_)
        {}
 
 
        turbulentBoundaryCoupledFvPatchScalarField::
            turbulentBoundaryCoupledFvPatchScalarField
            (
             const fvPatch& p,
             const DimensionedField<scalar, volMesh>& iF,
             const dictionary& dict
            )
            :
                mixedFvPatchScalarField(p, iF),
                TnbrName_(dict.lookup("Tnbr"))
        {
            if (!isA<mappedPatchBase>(this->patch().patch()))
            {
                FatalErrorInFunction
                    << "' not type '" << mappedPatchBase::typeName << "'"
                    << "\n    for patch " << p.name()
                    << " of field " << dimensionedInternalField().name()
                    << " in file " << dimensionedInternalField().objectPath()
                    << exit(FatalError);
            }
 
            fvPatchScalarField::operator=(scalarField("value", dict, p.size()));
 
            if (dict.found("refValue"))
            {
                // Full restart
                refValue() = scalarField("refValue", dict, p.size());
                refGrad() = scalarField("refGradient", dict, p.size());
                valueFraction() = scalarField("valueFraction", dict, p.size());
            }
            else
            {
                // Start from user entered data. Assume fixedValue.
                refValue() = *this;
                refGrad() = 0.0;
                valueFraction() = 1.0;
            }
        }
 
 
        turbulentBoundaryCoupledFvPatchScalarField::
            turbulentBoundaryCoupledFvPatchScalarField
            (
             const turbulentBoundaryCoupledFvPatchScalarField& wtcsf,
             const DimensionedField<scalar, volMesh>& iF
            )
            :
                mixedFvPatchScalarField(wtcsf, iF),
                TnbrName_(wtcsf.TnbrName_)
        {}
 
 
        // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
        void turbulentBoundaryCoupledFvPatchScalarField::updateCoeffs()
        {
            if (updated())
            {
                return;
            }
 
            // Since we're inside initEvaluate/evaluate there might be processor
            // comms underway. Change the tag we use.
            int oldTag = UPstream::msgType();
            UPstream::msgType() = oldTag+1;
 
            // Get the coupling information from the mappedPatchBase
            const mappedPatchBase& mpp =
                refCast<const mappedPatchBase>(patch().patch());
            const polyMesh& nbrMesh = mpp.sampleMesh();
            const label samplePatchI = mpp.samplePolyPatch().index();
            const fvPatch& nbrPatch =
                refCast<const fvMesh>(nbrMesh).boundary()[samplePatchI];
 
            // Calculate the temperature by harmonic averaging
            // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
            const turbulentBoundaryCoupledFvPatchScalarField& nbrField =
                refCast
                <
                const turbulentBoundaryCoupledFvPatchScalarField
                >
                (
                 nbrPatch.lookupPatchField<volScalarField, scalar>
                 (
                  TnbrName_
                 )
                );
 
            // Swap to obtain full local values of neighbour internal field
            tmp<scalarField> nbrIntFld(new scalarField(nbrField.size(), 0.0));
            tmp<scalarField> nbrKDelta(new scalarField(nbrField.size(), 0.0));
 
            mpp.distribute(nbrIntFld());
            mpp.distribute(nbrKDelta());
 
            // Both sides agree on
            // - temperature : (myKDelta*fld + nbrKDelta*nbrFld)/(myKDelta+nbrKDelta)
            // - gradient    : (temperature-fld)*delta
            // We've got a degree of freedom in how to implement this in a mixed bc.
            // (what gradient, what fixedValue and mixing coefficient)
            // Two reasonable choices:
            // 1. specify above temperature on one side (preferentially the high side)
            //    and above gradient on the other. So this will switch between pure
            //    fixedvalue and pure fixedgradient
            // 2. specify gradient and temperature such that the equations are the
            //    same on both sides. This leads to the choice of
            //    - refGradient = zero gradient
            //    - refValue = neighbour value
            //    - mixFraction = nbrKDelta / (nbrKDelta + myKDelta())
 
            this->refValue() = nbrIntFld();
            this->refGrad() = 0.0;
            this->valueFraction() = nbrKDelta()/(nbrKDelta());
 
            //这个updateCoeffs方法并不属于这个类或者这个命名空间，这个方法是属于
            //mixedFvPatchScalarField的。
            //#include "mixedFvPatchFields.H"
            //makePatchTypeFieldTypedefs(mixed);
            //这里定义了这个 mixedFvPatchScalarField.
            //updateCoeffs这个函数的实现是在fvPatchField.H
            //Update the coefficients associated with the patch field
            //Sets Updated to true
            // virtual void updateCoeffs()
            // {
            //     updated_ = true;
            // }
            // updateCoeffs()的作用仅仅就是把一布尔类型的变量变成true
            // turbulentTemperatureCoupledBaffleMixedFvPatchScalarField,这个边界条件类
            // 的名字就可以看出，这是一个湍流温度耦合的边界，继承自 mixedFvPatchScalarField
            //既然是继承的，如果updateCoefs是public的，那它自己也可以重载，但是没有
            //所以就只能用::来调用这个updateCoefs()函数了。
            mixedFvPatchScalarField::updateCoeffs();
 
            if (debug)
            {
                Info<< patch().boundaryMesh().mesh().name() << ':'
                    << patch().name() << ':'
                    << this->dimensionedInternalField().name() << " <- "
                    << nbrMesh.name() << ':'
                    << nbrPatch.name() << ':'
                    << this->dimensionedInternalField().name() << " :"
                    << endl;
            }
 
            // Restore tag
            UPstream::msgType() = oldTag;
        }
 
 
        void turbulentBoundaryCoupledFvPatchScalarField::write
            (
             Ostream& os
            ) const
            {
                mixedFvPatchScalarField::write(os);
                os.writeKeyword("Tnbr")<< TnbrName_
                    << token::END_STATEMENT << nl;
            }
 
 
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
        makePatchTypeField
            (
             fvPatchScalarField,
             turbulentBoundaryCoupledFvPatchScalarField
            );
 
 
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
    } // End namespace compressible
} // End namespace Foam
 
 
// ************************************************************************* //