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 held by original author
   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 template<class ParcelType>
  62 void Foam::ReactingCloud<ParcelType>::preEvolve()
  63 {
  64     ThermoCloud<ParcelType>::preEvolve();
  65 }
  66
  67
  68 template<class ParcelType>
  69 void Foam::ReactingCloud<ParcelType>::evolveCloud()
  70 {
  71     const volScalarField& T = this->carrierThermo().T();
  72     const volScalarField cp = this->carrierThermo().Cp();
  73     const volScalarField& p = this->carrierThermo().p();
  74
  75     autoPtr<interpolation<scalar> > rhoInterp = interpolation<scalar>::New
  76     (
  77         this->interpolationSchemes(),
  78         this->rho()
  79     );
  80
  81     autoPtr<interpolation<vector> > UInterp = interpolation<vector>::New
  82     (
  83         this->interpolationSchemes(),
  84         this->U()
  85     );
  86
  87     autoPtr<interpolation<scalar> > muInterp = interpolation<scalar>::New
  88     (
  89         this->interpolationSchemes(),
  90         this->mu()
  91     );
  92
  93     autoPtr<interpolation<scalar> > TInterp = interpolation<scalar>::New
  94     (
  95         this->interpolationSchemes(),
  96         T
  97     );
  98
  99     autoPtr<interpolation<scalar> > cpInterp = interpolation<scalar>::New
 100     (
 101         this->interpolationSchemes(),
 102         cp
 103     );
 104
 105     autoPtr<interpolation<scalar> > pInterp = interpolation<scalar>::New
 106     (
 107         this->interpolationSchemes(),
 108         p
 109     );
 110
 111     typename ParcelType::trackData td
 112     (
 113         *this,
 114         constProps_,
 115         rhoInterp(),
 116         UInterp(),
 117         muInterp(),
 118         TInterp(),
 119         cpInterp(),
 120         pInterp(),
 121         this->g().value()
 122     );
 123
 124     this->injection().inject(td);
 125
 126     if (this->coupled())
 127     {
 128         resetSourceTerms();
 129     }
 130
 131     Cloud<ParcelType>::move(td);
 132 }
 133
 134
 135 template<class ParcelType>
 136 void Foam::ReactingCloud<ParcelType>::postEvolve()
 137 {
 138     ThermoCloud<ParcelType>::postEvolve();
 139 }
 140
 141
 142 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 143
 144 template<class ParcelType>
 145 Foam::ReactingCloud<ParcelType>::ReactingCloud
 146 (
 147     const word& cloudName,
 148     const volScalarField& rho,
 149     const volVectorField& U,
 150     const dimensionedVector& g,
 151     basicThermo& thermo,
 152     bool readFields
 153 )
 154 :
 155     ThermoCloud<ParcelType>(cloudName, rho, U, g, thermo, false),
 156     reactingCloud(),
 157     constProps_(this->particleProperties()),
 158     mcCarrierThermo_
 159     (
 160         dynamic_cast<multiComponentMixture<thermoType>&>(thermo)
 161     ),
 162     compositionModel_
 163     (
 164         CompositionModel<ReactingCloud<ParcelType> >::New
 165         (
 166             this->particleProperties(),
 167             *this
 168         )
 169     ),
 170     phaseChangeModel_
 171     (
 172         PhaseChangeModel<ReactingCloud<ParcelType> >::New
 173         (
 174             this->particleProperties(),
 175             *this
 176         )
 177     ),
 178     rhoTrans_(mcCarrierThermo_.species().size()),
 179     dMassPhaseChange_(0.0)
 180 {
 181     // Set storage for mass source fields and initialise to zero
 182     forAll(rhoTrans_, i)
 183     {
 184         rhoTrans_.set
 185         (
 186             i,
 187             new DimensionedField<scalar, volMesh>
 188             (
 189                 IOobject
 190                 (
 191                     this->name() + "rhoTrans_" + mcCarrierThermo_.species()[i],
 192                     this->db().time().timeName(),
 193                     this->db(),
 194                     IOobject::NO_READ,
 195                     IOobject::NO_WRITE,
 196                     false
 197                 ),
 198                 this->mesh(),
 199                 dimensionedScalar("zero", dimMass, 0.0)
 200             )
 201         );
 202     }
 203
 204     if (readFields)
 205     {
 206         ParcelType::readFields(*this);
 207     }
 208 }
 209
 210
 211 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 212
 213 template<class ParcelType>
 214 Foam::ReactingCloud<ParcelType>::~ReactingCloud()
 215 {}
 216
 217
 218 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 219
 220 template<class ParcelType>
 221 void Foam::ReactingCloud<ParcelType>::checkParcelProperties
 222 (
 223     ParcelType& parcel,
 224     const scalar lagrangianDt,
 225     const bool fullyDescribed
 226 )
 227 {
 228     ThermoCloud<ParcelType>::checkParcelProperties
 229     (
 230         parcel,
 231         lagrangianDt,
 232         fullyDescribed
 233     );
 234
 235     if (!fullyDescribed)
 236     {
 237         parcel.Y() = composition().YMixture0();
 238     }
 239     else
 240     {
 241         checkSuppliedComposition
 242         (
 243             parcel.Y(),
 244             composition().YMixture0(),
 245             "YMixture"
 246         );
 247     }
 248
 249     // derived information - store initial mass
 250     parcel.mass0() = parcel.mass();
 251 }
 252
 253
 254 template<class ParcelType>
 255 void Foam::ReactingCloud<ParcelType>::resetSourceTerms()
 256 {
 257     ThermoCloud<ParcelType>::resetSourceTerms();
 258     forAll(rhoTrans_, i)
 259     {
 260         rhoTrans_[i].field() = 0.0;
 261     }
 262 }
 263
 264
 265 template<class ParcelType>
 266 void Foam::ReactingCloud<ParcelType>::evolve()
 267 {
 268     if (this->active())
 269     {
 270         preEvolve();
 271
 272         evolveCloud();
 273
 274         postEvolve();
 275
 276         info();
 277         Info<< endl;
 278     }
 279 }
 280
 281
 282 template<class ParcelType>
 283 void Foam::ReactingCloud<ParcelType>::info() const
 284 {
 285     ThermoCloud<ParcelType>::info();
 286
 287     Info<< "    Mass transfer phase change      = "
 288         << returnReduce(dMassPhaseChange_, sumOp<scalar>()) << nl;
 289 }
 290
 291
 292 template<class ParcelType>
 293 void Foam::ReactingCloud<ParcelType>::addToMassPhaseChange(const scalar dMass)
 294 {
 295     dMassPhaseChange_ += dMass;
 296 }
 297
 298
 299 // ************************************************************************* //