src/lagrangian/intermediate/clouds/Templates/ThermoCloud/ThermoCloudI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2008-2011 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 "physicoChemicalConstants.H"
  27
  28 using namespace Foam::constant;
  29
  30 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  31
  32 template<class CloudType>
  33 inline const Foam::ThermoCloud<CloudType>&
  34 Foam::ThermoCloud<CloudType>::cloudCopy() const
  35 {
  36     return cloudCopyPtr_();
  37 }
  38
  39
  40 template<class CloudType>
  41 inline const typename CloudType::particleType::constantProperties&
  42 Foam::ThermoCloud<CloudType>::constProps() const
  43 {
  44     return constProps_;
  45 }
  46
  47
  48 template<class CloudType>
  49 inline const Foam::SLGThermo& Foam::ThermoCloud<CloudType>::thermo() const
  50 {
  51     return thermo_;
  52 }
  53
  54
  55 template<class CloudType>
  56 inline const Foam::volScalarField& Foam::ThermoCloud<CloudType>::T() const
  57 {
  58     return T_;
  59 }
  60
  61
  62 template<class CloudType>
  63 inline const Foam::volScalarField& Foam::ThermoCloud<CloudType>::p() const
  64 {
  65     return p_;
  66 }
  67
  68
  69 template<class CloudType>
  70 inline const Foam::HeatTransferModel<Foam::ThermoCloud<CloudType> >&
  71 Foam::ThermoCloud<CloudType>::heatTransfer() const
  72 {
  73     return heatTransferModel_;
  74 }
  75
  76
  77 template<class CloudType>
  78 inline const Foam::scalarIntegrationScheme&
  79 Foam::ThermoCloud<CloudType>::TIntegrator() const
  80 {
  81     return TIntegrator_;
  82 }
  83
  84
  85 template<class CloudType>
  86 inline bool Foam::ThermoCloud<CloudType>::radiation() const
  87 {
  88     return radiation_;
  89 }
  90
  91
  92 template<class CloudType>
  93 inline Foam::DimensionedField<Foam::scalar, Foam::volMesh>&
  94 Foam::ThermoCloud<CloudType>::hsTrans()
  95 {
  96     return hsTrans_();
  97 }
  98
  99
 100 template<class CloudType>
 101 inline const Foam::DimensionedField<Foam::scalar, Foam::volMesh>&
 102 Foam::ThermoCloud<CloudType>::hsTrans() const
 103 {
 104     return hsTrans_();
 105 }
 106
 107
 108 template<class CloudType>
 109 inline Foam::DimensionedField<Foam::scalar, Foam::volMesh>&
 110 Foam::ThermoCloud<CloudType>::hsCoeff()
 111 {
 112     return hsCoeff_();
 113 }
 114
 115
 116 template<class CloudType>
 117 inline const Foam::DimensionedField<Foam::scalar, Foam::volMesh>&
 118 Foam::ThermoCloud<CloudType>::hsCoeff() const
 119 {
 120     return hsCoeff_();
 121 }
 122
 123
 124 template<class CloudType>
 125 inline Foam::tmp<Foam::fvScalarMatrix>
 126 Foam::ThermoCloud<CloudType>::Sh(volScalarField& hs) const
 127 {
 128     if (debug)
 129     {
 130         Info<< "hsTrans min/max = " << min(hsTrans()).value() << ", "
 131             << max(hsTrans()).value() << nl
 132             << "hsCoeff min/max = " << min(hsCoeff()).value() << ", "
 133             << max(hsCoeff()).value() << endl;
 134     }
 135
 136     if (this->solution().coupled())
 137     {
 138         if (this->solution().semiImplicit("hs"))
 139         {
 140             const volScalarField Cp(thermo_.thermo().Cp());
 141             const DimensionedField<scalar, volMesh>
 142                 Vdt(this->mesh().V()*this->db().time().deltaT());
 143
 144             return
 145                 hsTrans()/Vdt
 146               - fvm::SuSp(hsCoeff()/(Cp*Vdt), hs)
 147               + hsCoeff()/(Cp*Vdt)*hs;
 148         }
 149         else
 150         {
 151             tmp<fvScalarMatrix> tfvm(new fvScalarMatrix(hs, dimEnergy/dimTime));
 152             fvScalarMatrix& fvm = tfvm();
 153
 154             fvm.source() = -hsTrans()/(this->db().time().deltaT());
 155
 156             return tfvm;
 157         }
 158     }
 159
 160     return tmp<fvScalarMatrix>(new fvScalarMatrix(hs, dimEnergy/dimTime));
 161 }
 162
 163
 164 template<class CloudType>
 165 inline Foam::tmp<Foam::volScalarField> Foam::ThermoCloud<CloudType>::Ep() const
 166 {
 167     tmp<volScalarField> tEp
 168     (
 169         new volScalarField
 170         (
 171             IOobject
 172             (
 173                 this->name() + "radiation::Ep",
 174                 this->db().time().timeName(),
 175                 this->db(),
 176                 IOobject::NO_READ,
 177                 IOobject::NO_WRITE,
 178                 false
 179             ),
 180             this->mesh(),
 181             dimensionedScalar("zero", dimMass/dimLength/pow3(dimTime), 0.0)
 182         )
 183     );
 184
 185     // Need to check if coupled as field is created on-the-fly
 186     if (radiation_ && this->solution().coupled())
 187     {
 188         scalarField& Ep = tEp().internalField();
 189         const scalarField& V = this->mesh().V();
 190         const scalar epsilon = constProps_.epsilon0();
 191
 192         forAllConstIter(typename ThermoCloud<CloudType>, *this, iter)
 193         {
 194             const parcelType& p = iter();
 195             const label cellI = p.cell();
 196             Ep[cellI] += p.nParticle()*p.areaP()*pow4(p.T());
 197         }
 198
 199         Ep *= epsilon*physicoChemical::sigma.value()/V;
 200     }
 201
 202     return tEp;
 203 }
 204
 205
 206 template<class CloudType>
 207 inline Foam::tmp<Foam::volScalarField> Foam::ThermoCloud<CloudType>::ap() const
 208 {
 209     tmp<volScalarField> tap
 210     (
 211         new volScalarField
 212         (
 213             IOobject
 214             (
 215                 this->name() + "radiation::ap",
 216                 this->db().time().timeName(),
 217                 this->db(),
 218                 IOobject::NO_READ,
 219                 IOobject::NO_WRITE,
 220                 false
 221             ),
 222             this->mesh(),
 223             dimensionedScalar("zero", dimless/dimLength, 0.0)
 224         )
 225     );
 226
 227     // Need to check if coupled as field is created on-the-fly
 228     if (radiation_ && this->solution().coupled())
 229     {
 230         scalarField& ap = tap().internalField();
 231         const scalarField& V = this->mesh().V();
 232         const scalar epsilon = constProps_.epsilon0();
 233
 234         forAllConstIter(typename ThermoCloud<CloudType>, *this, iter)
 235         {
 236             const parcelType& p = iter();
 237             const label cellI = p.cell();
 238             ap[cellI] += p.nParticle()*p.areaP();
 239         }
 240
 241         ap *= epsilon/V;
 242     }
 243
 244     return tap;
 245 }
 246
 247
 248 template<class CloudType>
 249 inline Foam::tmp<Foam::volScalarField>
 250 Foam::ThermoCloud<CloudType>::sigmap() const
 251 {
 252     tmp<volScalarField> tsigmap
 253     (
 254         new volScalarField
 255         (
 256             IOobject
 257             (
 258                 this->name() + "radiation::sigmap",
 259                 this->db().time().timeName(),
 260                 this->db(),
 261                 IOobject::NO_READ,
 262                 IOobject::NO_WRITE,
 263                 false
 264             ),
 265             this->mesh(),
 266             dimensionedScalar("zero", dimless/dimLength, 0.0)
 267         )
 268     );
 269
 270     // Need to check if coupled as field is created on-the-fly
 271     if (radiation_ && this->solution().coupled())
 272     {
 273         scalarField& sigmap = tsigmap().internalField();
 274
 275         const scalarField& V = this->mesh().V();
 276         const scalar epsilon = constProps_.epsilon0();
 277         const scalar f = constProps_.f0();
 278
 279         forAllConstIter(typename ThermoCloud<CloudType>, *this, iter)
 280         {
 281             const parcelType& p = iter();
 282             const label cellI = p.cell();
 283             sigmap[cellI] += p.nParticle()*p.areaP();
 284         }
 285
 286         sigmap *= (1.0 - f)*(1.0 - epsilon)/V;
 287     }
 288
 289     return tsigmap;
 290 }
 291
 292
 293 // ************************************************************************* //