src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/turbulentTemperatureCoupledBaffle/turbulentTemperatureCoupledBaffleFvPatchScalarField.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "turbulentTemperatureCoupledBaffleFvPatchScalarField.H"
  27 #include "addToRunTimeSelectionTable.H"
  28 #include "fvPatchFieldMapper.H"
  29 #include "volFields.H"
  30 #include "directMappedPatchBase.H"
  31 #include "regionProperties.H"
  32
  33 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  34
  35 bool Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::interfaceOwner
  36 (
  37     const polyMesh& nbrRegion,
  38     const polyPatch& nbrPatch
  39 ) const
  40 {
  41     const fvMesh& myRegion = patch().boundaryMesh().mesh();
  42
  43     if (nbrRegion.name() == myRegion.name())
  44     {
  45         return patch().index() < nbrPatch.index();
  46     }
  47     else
  48     {
  49         const regionProperties& props =
  50             myRegion.objectRegistry::parent().lookupObject<regionProperties>
  51             (
  52                 "regionProperties"
  53             );
  54
  55         label myIndex = findIndex(props.fluidRegionNames(), myRegion.name());
  56         if (myIndex == -1)
  57         {
  58             label i = findIndex(props.solidRegionNames(), myRegion.name());
  59
  60             if (i == -1)
  61             {
  62                 FatalErrorIn
  63                 (
  64                     "turbulentTemperatureCoupledBaffleFvPatchScalarField"
  65                     "::interfaceOwner(const polyMesh&"
  66                     ", const polyPatch&)const"
  67                 )   << "Cannot find region " << myRegion.name()
  68                     << " neither in fluids " << props.fluidRegionNames()
  69                     << " nor in solids " << props.solidRegionNames()
  70                     << exit(FatalError);
  71             }
  72             myIndex = props.fluidRegionNames().size() + i;
  73         }
  74         label nbrIndex = findIndex
  75         (
  76             props.fluidRegionNames(),
  77             nbrRegion.name()
  78         );
  79         if (nbrIndex == -1)
  80         {
  81             label i = findIndex(props.solidRegionNames(), nbrRegion.name());
  82
  83             if (i == -1)
  84             {
  85                 FatalErrorIn
  86                 (
  87                     "coupleManager::interfaceOwner"
  88                     "(const polyMesh&, const polyPatch&) const"
  89                 )   << "Cannot find region " << nbrRegion.name()
  90                     << " neither in fluids " << props.fluidRegionNames()
  91                     << " nor in solids " << props.solidRegionNames()
  92                     << exit(FatalError);
  93             }
  94             nbrIndex = props.fluidRegionNames().size() + i;
  95         }
  96
  97         return myIndex < nbrIndex;
  98     }
  99 }
 100
 101
 102 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 103
 104 Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::
 105 turbulentTemperatureCoupledBaffleFvPatchScalarField
 106 (
 107     const fvPatch& p,
 108     const DimensionedField<scalar, volMesh>& iF
 109 )
 110 :
 111     fixedValueFvPatchScalarField(p, iF),
 112     temperatureCoupledBase(patch(), "undefined", "undefined-K"),
 113     neighbourFieldName_("undefined-neighbourFieldName")
 114 {}
 115
 116
 117 Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::
 118 turbulentTemperatureCoupledBaffleFvPatchScalarField
 119 (
 120     const turbulentTemperatureCoupledBaffleFvPatchScalarField& ptf,
 121     const fvPatch& p,
 122     const DimensionedField<scalar, volMesh>& iF,
 123     const fvPatchFieldMapper& mapper
 124 )
 125 :
 126     fixedValueFvPatchScalarField(ptf, p, iF, mapper),
 127     temperatureCoupledBase(patch(), ptf.KMethod(), ptf.KName()),
 128     neighbourFieldName_(ptf.neighbourFieldName_)
 129 {}
 130
 131
 132 Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::
 133 turbulentTemperatureCoupledBaffleFvPatchScalarField
 134 (
 135     const fvPatch& p,
 136     const DimensionedField<scalar, volMesh>& iF,
 137     const dictionary& dict
 138 )
 139 :
 140     fixedValueFvPatchScalarField(p, iF, dict),
 141     temperatureCoupledBase(patch(), dict),
 142     neighbourFieldName_(dict.lookup("neighbourFieldName"))
 143 {
 144     if (!isA<directMappedPatchBase>(this->patch().patch()))
 145     {
 146         FatalErrorIn
 147         (
 148             "turbulentTemperatureCoupledBaffleFvPatchScalarField::"
 149             "turbulentTemperatureCoupledBaffleFvPatchScalarField\n"
 150             "(\n"
 151             "    const fvPatch& p,\n"
 152             "    const DimensionedField<scalar, volMesh>& iF,\n"
 153             "    const dictionary& dict\n"
 154             ")\n"
 155         )   << "\n    patch type '" << p.type()
 156             << "' not type '" << directMappedPatchBase::typeName << "'"
 157             << "\n    for patch " << p.name()
 158             << " of field " << dimensionedInternalField().name()
 159             << " in file " << dimensionedInternalField().objectPath()
 160             << exit(FatalError);
 161     }
 162 }
 163
 164
 165 Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::
 166 turbulentTemperatureCoupledBaffleFvPatchScalarField
 167 (
 168     const turbulentTemperatureCoupledBaffleFvPatchScalarField& wtcsf,
 169     const DimensionedField<scalar, volMesh>& iF
 170 )
 171 :
 172     fixedValueFvPatchScalarField(wtcsf, iF),
 173     temperatureCoupledBase(patch(), wtcsf.KMethod(), wtcsf.KName()),
 174     neighbourFieldName_(wtcsf.neighbourFieldName_)
 175 {}
 176
 177
 178 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 179
 180 void Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::updateCoeffs()
 181 {
 182     if (updated())
 183     {
 184         return;
 185     }
 186
 187     // Get the coupling information from the directMappedPatchBase
 188     const directMappedPatchBase& mpp = refCast<const directMappedPatchBase>
 189     (
 190         this->patch().patch()
 191     );
 192     const polyMesh& nbrMesh = mpp.sampleMesh();
 193     const fvPatch& nbrPatch = refCast<const fvMesh>
 194     (
 195         nbrMesh
 196     ).boundary()[mpp.samplePolyPatch().index()];
 197
 198     // Force recalculation of mapping and schedule
 199     const mapDistribute& distMap = mpp.map();
 200     (void)distMap.schedule();
 201
 202     tmp<scalarField> intFld = patchInternalField();
 203
 204     if (interfaceOwner(nbrMesh, nbrPatch.patch()))
 205     {
 206         // Note: other side information could be cached - it only needs
 207         // to be updated the first time round the iteration (i.e. when
 208         // switching regions) but unfortunately we don't have this information.
 209
 210
 211         // Calculate the temperature by harmonic averaging
 212         // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 213
 214         const turbulentTemperatureCoupledBaffleFvPatchScalarField& nbrField =
 215         refCast<const turbulentTemperatureCoupledBaffleFvPatchScalarField>
 216         (
 217             nbrPatch.lookupPatchField<volScalarField, scalar>
 218             (
 219                 neighbourFieldName_
 220             )
 221         );
 222
 223         // Swap to obtain full local values of neighbour internal field
 224         scalarField nbrIntFld(nbrField.patchInternalField());
 225         distMap.distribute(nbrIntFld);
 226
 227         // Swap to obtain full local values of neighbour K*delta
 228         scalarField nbrKDelta(nbrField.K(nbrField)*nbrPatch.deltaCoeffs());
 229         distMap.distribute(nbrKDelta);
 230
 231         tmp<scalarField> myKDelta = K(*this)*patch().deltaCoeffs();
 232
 233         // Calculate common wall temperature. Reuse *this to store common value.
 234         scalarField Twall
 235         (
 236             (myKDelta()*intFld() + nbrKDelta*nbrIntFld)
 237           / (myKDelta() + nbrKDelta)
 238         );
 239         // Assign to me
 240         fvPatchScalarField::operator=(Twall);
 241         // Distribute back and assign to neighbour
 242         distMap.reverseDistribute(nbrField.size(), Twall);
 243         const_cast<turbulentTemperatureCoupledBaffleFvPatchScalarField&>
 244         (
 245             nbrField
 246         ).fvPatchScalarField::operator=(Twall);
 247     }
 248
 249     if (debug)
 250     {
 251         //tmp<scalarField> normalGradient =
 252         //    (*this-intFld())
 253         //  * patch().deltaCoeffs();
 254
 255         scalar Q = gSum(K(*this)*patch().magSf()*snGrad());
 256
 257         Info<< patch().boundaryMesh().mesh().name() << ':'
 258             << patch().name() << ':'
 259             << this->dimensionedInternalField().name() << " <- "
 260             << nbrMesh.name() << ':'
 261             << nbrPatch.name() << ':'
 262             << this->dimensionedInternalField().name() << " :"
 263             << " heat[W]:" << Q
 264             << " walltemperature "
 265             << " min:" << gMin(*this)
 266             << " max:" << gMax(*this)
 267             << " avg:" << gAverage(*this)
 268             << endl;
 269     }
 270
 271     fixedValueFvPatchScalarField::updateCoeffs();
 272 }
 273
 274
 275 void Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::write
 276 (
 277     Ostream& os
 278 ) const
 279 {
 280     fixedValueFvPatchScalarField::write(os);
 281     os.writeKeyword("neighbourFieldName")<< neighbourFieldName_
 282         << token::END_STATEMENT << nl;
 283     temperatureCoupledBase::write(os);
 284 }
 285
 286
 287 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 288
 289 namespace Foam
 290 {
 291
 292 makePatchTypeField
 293 (
 294     fvPatchScalarField,
 295     turbulentTemperatureCoupledBaffleFvPatchScalarField
 296 );
 297
 298 } // End namespace Foam
 299
 300 // ************************************************************************* //