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 (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 "ReactingMultiphaseCloud.H"
  27
  28 #include "DevolatilisationModel.H"
  29 #include "SurfaceReactionModel.H"
  30
  31 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
  32
  33 template<class CloudType>
  34 void Foam::ReactingMultiphaseCloud<CloudType>::setModels()
  35 {
  36     devolatilisationModel_.reset
  37     (
  38         DevolatilisationModel<ReactingMultiphaseCloud<CloudType> >::New
  39         (
  40             this->subModelProperties(),
  41             *this
  42         ).ptr()
  43     );
  44
  45     surfaceReactionModel_.reset
  46     (
  47         SurfaceReactionModel<ReactingMultiphaseCloud<CloudType> >::New
  48         (
  49             this->subModelProperties(),
  50             *this
  51         ).ptr()
  52     );
  53 }
  54
  55
  56 template<class CloudType>
  57 void Foam::ReactingMultiphaseCloud<CloudType>::cloudReset
  58 (
  59     ReactingMultiphaseCloud<CloudType>& c
  60 )
  61 {
  62     CloudType::cloudReset(c);
  63
  64     devolatilisationModel_.reset(c.devolatilisationModel_.ptr());
  65     surfaceReactionModel_.reset(c.surfaceReactionModel_.ptr());
  66
  67     dMassDevolatilisation_ = c.dMassDevolatilisation_;
  68     dMassSurfaceReaction_ = c.dMassSurfaceReaction_;
  69 }
  70
  71
  72 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  73
  74 template<class CloudType>
  75 Foam::ReactingMultiphaseCloud<CloudType>::ReactingMultiphaseCloud
  76 (
  77     const word& cloudName,
  78     const volScalarField& rho,
  79     const volVectorField& U,
  80     const dimensionedVector& g,
  81     const SLGThermo& thermo,
  82     bool readFields
  83 )
  84 :
  85     CloudType(cloudName, rho, U, g, thermo, false),
  86     reactingMultiphaseCloud(),
  87     cloudCopyPtr_(NULL),
  88     constProps_(this->particleProperties(), this->solution().active()),
  89     devolatilisationModel_(NULL),
  90     surfaceReactionModel_(NULL),
  91     dMassDevolatilisation_(0.0),
  92     dMassSurfaceReaction_(0.0)
  93 {
  94     if (this->solution().active())
  95     {
  96         setModels();
  97
  98         if (readFields)
  99         {
 100             parcelType::readFields(*this, this->composition());
 101         }
 102     }
 103
 104     if (this->solution().resetSourcesOnStartup())
 105     {
 106         resetSourceTerms();
 107     }
 108 }
 109
 110
 111 template<class CloudType>
 112 Foam::ReactingMultiphaseCloud<CloudType>::ReactingMultiphaseCloud
 113 (
 114     ReactingMultiphaseCloud<CloudType>& c,
 115     const word& name
 116 )
 117 :
 118     CloudType(c, name),
 119     reactingMultiphaseCloud(),
 120     cloudCopyPtr_(NULL),
 121     constProps_(c.constProps_),
 122     devolatilisationModel_(c.devolatilisationModel_->clone()),
 123     surfaceReactionModel_(c.surfaceReactionModel_->clone()),
 124     dMassDevolatilisation_(c.dMassDevolatilisation_),
 125     dMassSurfaceReaction_(c.dMassSurfaceReaction_)
 126 {}
 127
 128
 129 template<class CloudType>
 130 Foam::ReactingMultiphaseCloud<CloudType>::ReactingMultiphaseCloud
 131 (
 132     const fvMesh& mesh,
 133     const word& name,
 134     const ReactingMultiphaseCloud<CloudType>& c
 135 )
 136 :
 137     CloudType(mesh, name, c),
 138     reactingMultiphaseCloud(),
 139     cloudCopyPtr_(NULL),
 140     constProps_(),
 141     devolatilisationModel_(NULL),
 142     surfaceReactionModel_(NULL),
 143     dMassDevolatilisation_(0.0),
 144     dMassSurfaceReaction_(0.0)
 145 {}
 146
 147
 148 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 149
 150 template<class CloudType>
 151 Foam::ReactingMultiphaseCloud<CloudType>::~ReactingMultiphaseCloud()
 152 {}
 153
 154
 155 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 156
 157 template<class CloudType>
 158 void Foam::ReactingMultiphaseCloud<CloudType>::setParcelThermoProperties
 159 (
 160     parcelType& parcel,
 161     const scalar lagrangianDt
 162 )
 163 {
 164     CloudType::setParcelThermoProperties(parcel, lagrangianDt);
 165
 166     label idGas = this->composition().idGas();
 167     label idLiquid = this->composition().idLiquid();
 168     label idSolid = this->composition().idSolid();
 169
 170     parcel.YGas() = this->composition().Y0(idGas);
 171     parcel.YLiquid() = this->composition().Y0(idLiquid);
 172     parcel.YSolid() = this->composition().Y0(idSolid);
 173 }
 174
 175
 176 template<class CloudType>
 177 void Foam::ReactingMultiphaseCloud<CloudType>::checkParcelProperties
 178 (
 179     parcelType& parcel,
 180     const scalar lagrangianDt,
 181     const bool fullyDescribed
 182 )
 183 {
 184     CloudType::checkParcelProperties(parcel, lagrangianDt, fullyDescribed);
 185
 186     if (fullyDescribed)
 187     {
 188         label idGas = this->composition().idGas();
 189         label idLiquid = this->composition().idLiquid();
 190         label idSolid = this->composition().idSolid();
 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 CloudType>
 215 void Foam::ReactingMultiphaseCloud<CloudType>::storeState()
 216 {
 217     cloudCopyPtr_.reset
 218     (
 219         static_cast<ReactingMultiphaseCloud<CloudType>*>
 220         (
 221             clone(this->name() + "Copy").ptr()
 222         )
 223     );
 224 }
 225
 226
 227 template<class CloudType>
 228 void Foam::ReactingMultiphaseCloud<CloudType>::restoreState()
 229 {
 230     cloudReset(cloudCopyPtr_());
 231     cloudCopyPtr_.clear();
 232 }
 233
 234
 235 template<class CloudType>
 236 void Foam::ReactingMultiphaseCloud<CloudType>::resetSourceTerms()
 237 {
 238     CloudType::resetSourceTerms();
 239 }
 240
 241
 242 template<class CloudType>
 243 void Foam::ReactingMultiphaseCloud<CloudType>::evolve()
 244 {
 245     if (this->solution().canEvolve())
 246     {
 247         typename parcelType::template
 248             TrackingData<ReactingMultiphaseCloud<CloudType> > td(*this);
 249
 250         this->solve(td);
 251     }
 252 }
 253
 254
 255 template<class CloudType>
 256 void Foam::ReactingMultiphaseCloud<CloudType>::addToMassDevolatilisation
 257 (
 258     const scalar dMass
 259 )
 260 {
 261     dMassDevolatilisation_ += dMass;
 262 }
 263
 264
 265 template<class CloudType>
 266 void Foam::ReactingMultiphaseCloud<CloudType>::addToMassSurfaceReaction
 267 (
 268     const scalar dMass
 269 )
 270 {
 271     dMassSurfaceReaction_ += dMass;
 272 }
 273
 274
 275 template<class CloudType>
 276 void Foam::ReactingMultiphaseCloud<CloudType>::info() const
 277 {
 278     CloudType::info();
 279     Info<< "    Mass transfer devolatilisation  = "
 280         << returnReduce(dMassDevolatilisation_, sumOp<scalar>()) << nl;
 281     Info<< "    Mass transfer surface reaction  = "
 282         << returnReduce(dMassSurfaceReaction_, sumOp<scalar>()) << nl;
 283 }
 284
 285
 286 template<class CloudType>
 287 void Foam::ReactingMultiphaseCloud<CloudType>::writeFields() const
 288 {
 289     if (this->size())
 290     {
 291         CloudType::particleType::writeFields(*this, this->composition());
 292     }
 293 }
 294
 295
 296 // ************************************************************************* //