src/regionModels/thermoBaffleModels/thermoBaffle2D/thermoBaffle2D.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   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 the
  13     Free Software Foundation; either version 3 of the License, or (at your
  14     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, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 \*---------------------------------------------------------------------------*/
  26
  27 #include "thermoBaffle2D.H"
  28
  29 #include "fvm.H"
  30 #include "addToRunTimeSelectionTable.H"
  31 #include "zeroGradientFvPatchFields.H"
  32 #include "fvMatrices.H"
  33
  34
  35 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  36
  37 namespace Foam
  38 {
  39 namespace regionModels
  40 {
  41 namespace thermoBaffleModels
  42 {
  43
  44 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  45
  46 defineTypeNameAndDebug(thermoBaffle2D, 0);
  47
  48 addToRunTimeSelectionTable(thermoBaffleModel, thermoBaffle2D, mesh);
  49 addToRunTimeSelectionTable(thermoBaffleModel, thermoBaffle2D, dictionary);
  50
  51 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
  52
  53
  54 bool thermoBaffle2D::read()
  55 {
  56     this->solution().lookup("nNonOrthCorr") >> nNonOrthCorr_;
  57     return regionModel1D::read();
  58 }
  59
  60
  61 void thermoBaffle2D::solveEnergy()
  62 {
  63     if (debug)
  64     {
  65         Info<< "thermoBaffle2D::solveEnergy()" << endl;
  66     }
  67
  68     const polyBoundaryMesh& rbm = regionMesh().boundaryMesh();
  69
  70     tmp<volScalarField> tQ
  71     (
  72         new volScalarField
  73         (
  74             IOobject
  75             (
  76                 "tQ",
  77                 regionMesh().time().timeName(),
  78                 regionMesh(),
  79                 IOobject::NO_READ,
  80                 IOobject::NO_WRITE,
  81                 false
  82             ),
  83             regionMesh(),
  84             dimensionedScalar("zero", dimEnergy/dimVolume/dimTime, 0.0)
  85         )
  86     );
  87
  88     volScalarField& Q = tQ();
  89
  90     volScalarField rhoCp("rhoCp", thermo_->rho()*thermo_->Cp()());
  91     volScalarField K("K", thermo_->K());
  92
  93
  94     //If region is one-dimension variable thickness
  95     if (oneD_ && !constantThickness_)
  96     {
  97         // Scale K and rhoCp and fill Q in the internal baffle region.
  98         const label patchI = intCoupledPatchIDs_[0];
  99         const polyPatch& ppCoupled = rbm[patchI];
 100
 101         forAll(ppCoupled, localFaceI)
 102         {
 103             const labelList& cells = boundaryFaceCells_[localFaceI];
 104             forAll (cells, i)
 105             {
 106                 const label cellId = cells[i];
 107
 108                 Q[cellId] =
 109                     Qs_.boundaryField()[patchI][localFaceI]
 110                     /thickness_[localFaceI];
 111
 112                 rhoCp[cellId] *= delta_.value()/thickness_[localFaceI];
 113
 114                 K[cellId] *= delta_.value()/thickness_[localFaceI];
 115             }
 116         }
 117     }
 118     else
 119     {
 120         Q = Q_;
 121     }
 122
 123     fvScalarMatrix TEqn
 124     (
 125         fvm::ddt(rhoCp, T_)
 126       - fvm::laplacian(K, T_)
 127      ==
 128         Q
 129     );
 130
 131     TEqn.relax();
 132     TEqn.solve();
 133
 134     thermo_->correct();
 135 }
 136
 137
 138 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 139
 140
 141 thermoBaffle2D::thermoBaffle2D
 142 (
 143     const word& modelType,
 144     const fvMesh& mesh,
 145     const dictionary& dict
 146 )
 147 :
 148     thermoBaffleModel(modelType, mesh, dict),
 149     nNonOrthCorr_(readLabel(solution().lookup("nNonOrthCorr"))),
 150     thermo_(basicSolidThermo::New(regionMesh(), dict)),
 151     T_(thermo_->T()),
 152     Qs_
 153     (
 154         IOobject
 155         (
 156             "Qs",
 157             regionMesh().time().timeName(),
 158             regionMesh(),
 159             IOobject::READ_IF_PRESENT,
 160             IOobject::AUTO_WRITE
 161         ),
 162         regionMesh(),
 163         dimensionedScalar
 164         (
 165             "zero",
 166             dimEnergy/dimArea/dimTime,
 167             pTraits<scalar>::zero
 168         )
 169     ),
 170     Q_
 171     (
 172         IOobject
 173         (
 174             "Q",
 175             regionMesh().time().timeName(),
 176             regionMesh(),
 177             IOobject::READ_IF_PRESENT,
 178             IOobject::AUTO_WRITE
 179         ),
 180         regionMesh(),
 181         dimensionedScalar
 182         (
 183             "zero",
 184             dimEnergy/dimVolume/dimTime,
 185             pTraits<scalar>::zero
 186         )
 187     )
 188 {
 189     init();
 190     thermo_->correct();
 191 }
 192
 193
 194 thermoBaffle2D::thermoBaffle2D
 195 (
 196     const word& modelType,
 197     const fvMesh& mesh
 198 )
 199 :
 200     thermoBaffleModel(modelType, mesh),
 201     nNonOrthCorr_(readLabel(solution().lookup("nNonOrthCorr"))),
 202     thermo_(basicSolidThermo::New(regionMesh())),
 203     T_(thermo_->T()),
 204     Qs_
 205     (
 206         IOobject
 207         (
 208             "Qs",
 209             regionMesh().time().timeName(),
 210             regionMesh(),
 211             IOobject::READ_IF_PRESENT,
 212             IOobject::AUTO_WRITE
 213         ),
 214         regionMesh(),
 215         dimensionedScalar
 216         (
 217             "zero",
 218             dimEnergy/dimArea/dimTime,
 219             pTraits<scalar>::zero
 220         )
 221     ),
 222     Q_
 223     (
 224         IOobject
 225         (
 226             "Q",
 227             regionMesh().time().timeName(),
 228             regionMesh(),
 229             IOobject::READ_IF_PRESENT,
 230             IOobject::AUTO_WRITE
 231         ),
 232         regionMesh(),
 233         dimensionedScalar
 234         (
 235             "zero",
 236             dimEnergy/dimVolume/dimTime,
 237             pTraits<scalar>::zero
 238         )
 239     )
 240 {
 241     init();
 242     thermo_->correct();
 243 }
 244
 245
 246 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 247
 248 thermoBaffle2D::~thermoBaffle2D()
 249 {}
 250
 251
 252 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 253
 254 void thermoBaffle2D::init()
 255 {
 256     if (oneD_ && !constantThickness_)
 257     {
 258         label patchI = intCoupledPatchIDs_[0];
 259         const label Qsb = Qs_.boundaryField()[patchI].size();
 260         if (Qsb!= thickness_.size())
 261         {
 262             FatalErrorIn
 263             (
 264                 "thermoBaffle2D::thermoBaffle2D"
 265                 "("
 266                 "   const word& modelType,"
 267                 "   const fvMesh& mesh,"
 268                 "   const dictionary& dict"
 269                 ")"
 270             )   << "the boundary field of Qs is "
 271                 << Qsb << " and " << nl
 272                 << "the field 'thickness' is " << thickness_.size() << nl
 273                 << exit(FatalError);
 274         }
 275     }
 276 }
 277
 278
 279 void thermoBaffle2D::preEvolveRegion()
 280 {}
 281
 282
 283 void thermoBaffle2D::evolveRegion()
 284 {
 285     for (int nonOrth=0; nonOrth<=nNonOrthCorr_; nonOrth++)
 286     {
 287         solveEnergy();
 288     }
 289 }
 290
 291
 292 const tmp<volScalarField> thermoBaffle2D::Cp() const
 293 {
 294     return thermo_->Cp();
 295 }
 296
 297
 298 const volScalarField& thermoBaffle2D::kappa() const
 299 {
 300     return thermo_->kappa();
 301 }
 302
 303
 304 const volScalarField& thermoBaffle2D::rho() const
 305 {
 306     return thermo_->rho();
 307 }
 308
 309
 310 const volScalarField& thermoBaffle2D::K() const
 311 {
 312     return thermo_->K();
 313 }
 314
 315
 316 const volScalarField& thermoBaffle2D::T() const
 317 {
 318     return T_;
 319 }
 320
 321
 322 const basicSolidThermo& thermoBaffle2D::thermo() const
 323 {
 324     return thermo_;
 325 }
 326
 327
 328 void thermoBaffle2D::info() const
 329 {
 330     Info<< indent << "min/max(T) = " << min(T_).value() << ", "
 331         << max(T_).value() << nl;
 332
 333     const labelList& coupledPatches = intCoupledPatchIDs();
 334     forAll (coupledPatches, i)
 335     {
 336         const label patchI = coupledPatches[i];
 337         const fvPatchScalarField& pT = T_.boundaryField()[patchI];
 338         const word patchName = regionMesh().boundary()[patchI].name();
 339         Info << indent << "Q : " << patchName << indent <<
 340             gSum
 341             (
 342                 mag(regionMesh().Sf().boundaryField()[patchI])
 343               * pT.snGrad()
 344               * thermo_->K().boundaryField()[patchI]
 345             ) << endl;
 346     }
 347 }
 348
 349
 350 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 351
 352 } // end namespace thermoBaffleModels
 353 } // end namespace regionModels
 354 } // end namespace Foam
 355
 356 // ************************************************************************* //