src/lagrangian/intermediate/clouds/Templates/ReactingMultiphaseCloud/ReactingMultiphaseCloud.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 "ReactingMultiphaseCloud.H"
  28
  29 #include "DevolatilisationModel.H"
  30 #include "SurfaceReactionModel.H"
  31
  32 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
  33
  34 template<class ParcelType>
  35 void Foam::ReactingMultiphaseCloud<ParcelType>::preEvolve()
  36 {
  37     ReactingCloud<ParcelType>::preEvolve();
  38 }
  39
  40
  41 template<class ParcelType>
  42 void Foam::ReactingMultiphaseCloud<ParcelType>::evolveCloud()
  43 {
  44     const volScalarField& T = this->carrierThermo().T();
  45     const volScalarField cp = this->carrierThermo().Cp();
  46     const volScalarField& p = this->carrierThermo().p();
  47
  48     autoPtr<interpolation<scalar> > rhoInterp = interpolation<scalar>::New
  49     (
  50         this->interpolationSchemes(),
  51         this->rho()
  52     );
  53
  54     autoPtr<interpolation<vector> > UInterp = interpolation<vector>::New
  55     (
  56         this->interpolationSchemes(),
  57         this->U()
  58     );
  59
  60     autoPtr<interpolation<scalar> > muInterp = interpolation<scalar>::New
  61     (
  62         this->interpolationSchemes(),
  63         this->mu()
  64     );
  65
  66     autoPtr<interpolation<scalar> > TInterp = interpolation<scalar>::New
  67     (
  68         this->interpolationSchemes(),
  69         T
  70     );
  71
  72     autoPtr<interpolation<scalar> > cpInterp = interpolation<scalar>::New
  73     (
  74         this->interpolationSchemes(),
  75         cp
  76     );
  77
  78     autoPtr<interpolation<scalar> > pInterp = interpolation<scalar>::New
  79     (
  80         this->interpolationSchemes(),
  81         p
  82     );
  83
  84     typename ParcelType::trackData td
  85     (
  86         *this,
  87         constProps_,
  88         rhoInterp(),
  89         UInterp(),
  90         muInterp(),
  91         TInterp(),
  92         cpInterp(),
  93         pInterp(),
  94         this->g().value()
  95     );
  96
  97     this->injection().inject(td);
  98
  99     if (this->coupled())
 100     {
 101         resetSourceTerms();
 102     }
 103
 104     Cloud<ParcelType>::move(td);
 105 }
 106
 107
 108 template<class ParcelType>
 109 void Foam::ReactingMultiphaseCloud<ParcelType>::postEvolve()
 110 {
 111     ReactingCloud<ParcelType>::postEvolve();
 112 }
 113
 114
 115 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 116
 117 template<class ParcelType>
 118 Foam::ReactingMultiphaseCloud<ParcelType>::ReactingMultiphaseCloud
 119 (
 120     const word& cloudName,
 121     const volScalarField& rho,
 122     const volVectorField& U,
 123     const dimensionedVector& g,
 124     basicThermo& thermo,
 125     bool readFields
 126 )
 127 :
 128     ReactingCloud<ParcelType>(cloudName, rho, U, g, thermo, false),
 129     reactingMultiphaseCloud(),
 130     constProps_(this->particleProperties()),
 131     devolatilisationModel_
 132     (
 133         DevolatilisationModel<ReactingMultiphaseCloud<ParcelType> >::New
 134         (
 135             this->particleProperties(),
 136             *this
 137         )
 138     ),
 139     surfaceReactionModel_
 140     (
 141         SurfaceReactionModel<ReactingMultiphaseCloud<ParcelType> >::New
 142         (
 143             this->particleProperties(),
 144             *this
 145         )
 146     ),
 147     dMassDevolatilisation_(0.0)
 148 {
 149     if (readFields)
 150     {
 151         ParcelType::readFields(*this);
 152     }
 153 }
 154
 155
 156 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 157
 158 template<class ParcelType>
 159 Foam::ReactingMultiphaseCloud<ParcelType>::~ReactingMultiphaseCloud()
 160 {}
 161
 162
 163 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 164
 165 template<class ParcelType>
 166 void Foam::ReactingMultiphaseCloud<ParcelType>::checkParcelProperties
 167 (
 168     ParcelType& parcel,
 169     const scalar lagrangianDt,
 170     const bool fullyDescribed
 171 )
 172 {
 173     ReactingCloud<ParcelType>::checkParcelProperties
 174     (
 175         parcel,
 176         lagrangianDt,
 177         fullyDescribed
 178     );
 179
 180     label idGas = this->composition().idGas();
 181     label idLiquid = this->composition().idLiquid();
 182     label idSolid = this->composition().idSolid();
 183
 184     if (!fullyDescribed)
 185     {
 186         parcel.YGas() = this->composition().Y0(idGas);
 187         parcel.YLiquid() = this->composition().Y0(idLiquid);
 188         parcel.YSolid() = this->composition().Y0(idSolid);
 189     }
 190     else
 191     {
 192         this->checkSuppliedComposition
 193         (
 194             parcel.YGas(),
 195             this->composition().Y0(idGas),
 196             "YGas"
 197         );
 198         this->checkSuppliedComposition
 199         (
 200             parcel.YLiquid(),
 201             this->composition().Y0(idLiquid),
 202             "YLiquid"
 203         );
 204         this->checkSuppliedComposition
 205         (
 206             parcel.YSolid(),
 207             this->composition().Y0(idSolid),
 208             "YSolid"
 209         );
 210     }
 211 }
 212
 213
 214 template<class ParcelType>
 215 void Foam::ReactingMultiphaseCloud<ParcelType>::resetSourceTerms()
 216 {
 217     ReactingCloud<ParcelType>::resetSourceTerms();
 218 }
 219
 220
 221 template<class ParcelType>
 222 void Foam::ReactingMultiphaseCloud<ParcelType>::evolve()
 223 {
 224     if (this->active())
 225     {
 226         preEvolve();
 227
 228         evolveCloud();
 229
 230         postEvolve();
 231
 232         info();
 233         Info<< endl;
 234     }
 235 }
 236
 237
 238 template<class ParcelType>
 239 void Foam::ReactingMultiphaseCloud<ParcelType>::info() const
 240 {
 241     ReactingCloud<ParcelType>::info();
 242     Info<< "    Mass transfer devolatilisation  = "
 243         << returnReduce(dMassDevolatilisation_, sumOp<scalar>()) << nl;
 244     Info<< "    Mass transfer surface reaction  = "
 245         << returnReduce(dMassSurfaceReaction_, sumOp<scalar>()) << nl;
 246 }
 247
 248
 249 template<class ParcelType>
 250 void Foam::ReactingMultiphaseCloud<ParcelType>::addToMassDevolatilisation
 251 (
 252     const scalar dMass
 253 )
 254 {
 255     dMassDevolatilisation_ += dMass;
 256 }
 257
 258
 259 template<class ParcelType>
 260 void Foam::ReactingMultiphaseCloud<ParcelType>::addToMassSurfaceReaction
 261 (
 262     const scalar dMass
 263 )
 264 {
 265     dMassSurfaceReaction_ += dMass;
 266 }
 267
 268
 269 // ************************************************************************* //