src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 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 the
  13     Free Software Foundation; either version 2 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 "ReactingCloud.H"
  28
  29 #include "CompositionModel.H"
  30 #include "PhaseChangeModel.H"
  31
  32 // * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * * //
  33
  34 template<class ParcelType>
  35 void Foam::ReactingCloud<ParcelType>::checkSuppliedComposition
  36 (
  37     const scalarField& YSupplied,
  38     const scalarField& Y,
  39     const word& YName
  40 )
  41 {
  42     if (YSupplied.size() != Y.size())
  43     {
  44         FatalErrorIn
  45         (
  46             "ReactingCloud<ParcelType>::checkSuppliedComposition"
  47             "("
  48                 "const scalarField&, "
  49                 "const scalarField&, "
  50                 "const word&"
  51             ")"
  52         )   << YName << " supplied, but size is not compatible with "
  53             << "parcel composition: " << nl << "    "
  54             << YName << "(" << YSupplied.size() << ") vs required composition "
  55             << YName << "(" << Y.size() << ")" << nl
  56             << abort(FatalError);
  57     }
  58 }
  59
  60
  61 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  62
  63 template<class ParcelType>
  64 Foam::ReactingCloud<ParcelType>::ReactingCloud
  65 (
  66     const word& cloudName,
  67     const volScalarField& rho,
  68     const volVectorField& U,
  69     const dimensionedVector& g,
  70     basicThermo& thermo
  71 )
  72 :
  73     ThermoCloud<ParcelType>(cloudName, rho, U, g, thermo),
  74     reactingCloud(),
  75     constProps_(this->particleProperties()),
  76     mcCarrierThermo_
  77     (
  78         dynamic_cast<multiComponentMixture<thermoType>&>(thermo)
  79     ),
  80     compositionModel_
  81     (
  82         CompositionModel<ReactingCloud<ParcelType> >::New
  83         (
  84             this->particleProperties(),
  85             *this
  86         )
  87     ),
  88     phaseChangeModel_
  89     (
  90         PhaseChangeModel<ReactingCloud<ParcelType> >::New
  91         (
  92             this->particleProperties(),
  93             *this
  94         )
  95     ),
  96     rhoTrans_(mcCarrierThermo_.species().size()),
  97     dMassPhaseChange_(0.0)
  98 {
  99     // Set storage for mass source fields and initialise to zero
 100     forAll(rhoTrans_, i)
 101     {
 102         rhoTrans_.set
 103         (
 104             i,
 105             new DimensionedField<scalar, volMesh>
 106             (
 107                 IOobject
 108                 (
 109                     this->name() + "rhoTrans_" + mcCarrierThermo_.species()[i],
 110                     this->db().time().timeName(),
 111                     this->db(),
 112                     IOobject::NO_READ,
 113                     IOobject::NO_WRITE,
 114                     false
 115                 ),
 116                 this->mesh(),
 117                 dimensionedScalar("zero", dimMass, 0.0)
 118             )
 119         );
 120     }
 121 }
 122
 123
 124 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 125
 126 template<class ParcelType>
 127 Foam::ReactingCloud<ParcelType>::~ReactingCloud()
 128 {}
 129
 130
 131 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 132
 133 template<class ParcelType>
 134 void Foam::ReactingCloud<ParcelType>::checkParcelProperties
 135 (
 136     ParcelType& parcel,
 137     const scalar lagrangianDt,
 138     const bool fullyDescribed
 139 )
 140 {
 141     ThermoCloud<ParcelType>::checkParcelProperties
 142     (
 143         parcel,
 144         lagrangianDt,
 145         fullyDescribed
 146     );
 147
 148     if (!fullyDescribed)
 149     {
 150         parcel.Y() = composition().YMixture0();
 151     }
 152     else
 153     {
 154         checkSuppliedComposition
 155         (
 156             parcel.Y(),
 157             composition().YMixture0(),
 158             "YMixture"
 159         );
 160     }
 161
 162     // derived information - store initial mass
 163     parcel.mass0() = parcel.mass();
 164 }
 165
 166
 167 template<class ParcelType>
 168 void Foam::ReactingCloud<ParcelType>::resetSourceTerms()
 169 {
 170     ThermoCloud<ParcelType>::resetSourceTerms();
 171     forAll(rhoTrans_, i)
 172     {
 173         rhoTrans_[i].field() = 0.0;
 174     }
 175 }
 176
 177
 178 template<class ParcelType>
 179 void Foam::ReactingCloud<ParcelType>::preEvolve()
 180 {
 181     ThermoCloud<ParcelType>::preEvolve();
 182 }
 183
 184
 185 template<class ParcelType>
 186 void Foam::ReactingCloud<ParcelType>::postEvolve()
 187 {
 188     ThermoCloud<ParcelType>::postEvolve();
 189 }
 190
 191
 192 template<class ParcelType>
 193 void Foam::ReactingCloud<ParcelType>::evolve()
 194 {
 195     preEvolve();
 196
 197     const volScalarField& T = this->carrierThermo().T();
 198     const volScalarField cp = this->carrierThermo().Cp();
 199     const volScalarField& p = this->carrierThermo().p();
 200
 201     autoPtr<interpolation<scalar> > rhoInterp = interpolation<scalar>::New
 202     (
 203         this->interpolationSchemes(),
 204         this->rho()
 205     );
 206
 207     autoPtr<interpolation<vector> > UInterp = interpolation<vector>::New
 208     (
 209         this->interpolationSchemes(),
 210         this->U()
 211     );
 212
 213     autoPtr<interpolation<scalar> > muInterp = interpolation<scalar>::New
 214     (
 215         this->interpolationSchemes(),
 216         this->mu()
 217     );
 218
 219     autoPtr<interpolation<scalar> > TInterp = interpolation<scalar>::New
 220     (
 221         this->interpolationSchemes(),
 222         T
 223     );
 224
 225     autoPtr<interpolation<scalar> > cpInterp = interpolation<scalar>::New
 226     (
 227         this->interpolationSchemes(),
 228         cp
 229     );
 230
 231     autoPtr<interpolation<scalar> > pInterp = interpolation<scalar>::New
 232     (
 233         this->interpolationSchemes(),
 234         p
 235     );
 236
 237     typename ParcelType::trackData td
 238     (
 239         *this,
 240         constProps_,
 241         rhoInterp(),
 242         UInterp(),
 243         muInterp(),
 244         TInterp(),
 245         cpInterp(),
 246         pInterp(),
 247         this->g().value()
 248     );
 249
 250     this->injection().inject(td);
 251
 252     if (this->coupled())
 253     {
 254         resetSourceTerms();
 255     }
 256
 257     Cloud<ParcelType>::move(td);
 258
 259     postEvolve();
 260 }
 261
 262
 263 template<class ParcelType>
 264 void Foam::ReactingCloud<ParcelType>::info() const
 265 {
 266     ThermoCloud<ParcelType>::info();
 267
 268     Info<< "    Mass transfer phase change      = "
 269         << returnReduce(dMassPhaseChange_, sumOp<scalar>()) << nl;
 270 }
 271
 272
 273 template<class ParcelType>
 274 void Foam::ReactingCloud<ParcelType>::addToMassPhaseChange(const scalar dMass)
 275 {
 276     dMassPhaseChange_ += dMass;
 277 }
 278
 279
 280 // ************************************************************************* //