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) 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 "ReactingCloud.H"
  27
  28 #include "CompositionModel.H"
  29 #include "PhaseChangeModel.H"
  30
  31 // * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * * //
  32
  33 template<class CloudType>
  34 void Foam::ReactingCloud<CloudType>::setModels()
  35 {
  36     compositionModel_.reset
  37     (
  38         CompositionModel<ReactingCloud<CloudType> >::New
  39         (
  40             this->subModelProperties(),
  41             *this
  42         ).ptr()
  43     );
  44
  45     phaseChangeModel_.reset
  46     (
  47         PhaseChangeModel<ReactingCloud<CloudType> >::New
  48         (
  49             this->subModelProperties(),
  50             *this
  51         ).ptr()
  52     );
  53 }
  54
  55
  56 template<class CloudType>
  57 void Foam::ReactingCloud<CloudType>::checkSuppliedComposition
  58 (
  59     const scalarField& YSupplied,
  60     const scalarField& Y,
  61     const word& YName
  62 )
  63 {
  64     if (YSupplied.size() != Y.size())
  65     {
  66         FatalErrorIn
  67         (
  68             "ReactingCloud<CloudType>::checkSuppliedComposition"
  69             "("
  70                 "const scalarField&, "
  71                 "const scalarField&, "
  72                 "const word&"
  73             ")"
  74         )   << YName << " supplied, but size is not compatible with "
  75             << "parcel composition: " << nl << "    "
  76             << YName << "(" << YSupplied.size() << ") vs required composition "
  77             << YName << "(" << Y.size() << ")" << nl
  78             << abort(FatalError);
  79     }
  80 }
  81
  82
  83 template<class CloudType>
  84 void Foam::ReactingCloud<CloudType>::cloudReset(ReactingCloud<CloudType>& c)
  85 {
  86     CloudType::cloudReset(c);
  87
  88     compositionModel_.reset(c.compositionModel_.ptr());
  89     phaseChangeModel_.reset(c.phaseChangeModel_.ptr());
  90
  91     dMassPhaseChange_ = c.dMassPhaseChange_;
  92 }
  93
  94
  95 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  96
  97 template<class CloudType>
  98 Foam::ReactingCloud<CloudType>::ReactingCloud
  99 (
 100     const word& cloudName,
 101     const volScalarField& rho,
 102     const volVectorField& U,
 103     const dimensionedVector& g,
 104     const SLGThermo& thermo,
 105     bool readFields
 106 )
 107 :
 108     CloudType(cloudName, rho, U, g, thermo, false),
 109     reactingCloud(),
 110     cloudCopyPtr_(NULL),
 111     constProps_(this->particleProperties(), this->solution().active()),
 112     compositionModel_(NULL),
 113     phaseChangeModel_(NULL),
 114     rhoTrans_(thermo.carrier().species().size()),
 115     dMassPhaseChange_(0.0)
 116 {
 117     if (this->solution().active())
 118     {
 119         setModels();
 120
 121         if (readFields)
 122         {
 123             parcelType::readFields(*this, this->composition());
 124         }
 125     }
 126
 127     // Set storage for mass source fields and initialise to zero
 128     forAll(rhoTrans_, i)
 129     {
 130         const word& specieName = thermo.carrier().species()[i];
 131         rhoTrans_.set
 132         (
 133             i,
 134             new DimensionedField<scalar, volMesh>
 135             (
 136                 IOobject
 137                 (
 138                     this->name() + "rhoTrans_" + specieName,
 139                     this->db().time().timeName(),
 140                     this->db(),
 141                     IOobject::READ_IF_PRESENT,
 142                     IOobject::AUTO_WRITE
 143                 ),
 144                 this->mesh(),
 145                 dimensionedScalar("zero", dimMass, 0.0)
 146             )
 147         );
 148     }
 149
 150     if (this->solution().resetSourcesOnStartup())
 151     {
 152         resetSourceTerms();
 153     }
 154 }
 155
 156
 157 template<class CloudType>
 158 Foam::ReactingCloud<CloudType>::ReactingCloud
 159 (
 160     ReactingCloud<CloudType>& c,
 161     const word& name
 162 )
 163 :
 164     CloudType(c, name),
 165     reactingCloud(),
 166     cloudCopyPtr_(NULL),
 167     constProps_(c.constProps_),
 168     compositionModel_(c.compositionModel_->clone()),
 169     phaseChangeModel_(c.phaseChangeModel_->clone()),
 170     rhoTrans_(c.rhoTrans_.size()),
 171     dMassPhaseChange_(c.dMassPhaseChange_)
 172 {
 173     forAll(c.rhoTrans_, i)
 174     {
 175         const word& specieName = this->thermo().carrier().species()[i];
 176         rhoTrans_.set
 177         (
 178             i,
 179             new DimensionedField<scalar, volMesh>
 180             (
 181                 IOobject
 182                 (
 183                     this->name() + "rhoTrans_" + specieName,
 184                     this->db().time().timeName(),
 185                     this->db(),
 186                     IOobject::NO_READ,
 187                     IOobject::NO_WRITE,
 188                     false
 189                 ),
 190                 c.rhoTrans_[i]
 191             )
 192         );
 193     }
 194 }
 195
 196
 197 template<class CloudType>
 198 Foam::ReactingCloud<CloudType>::ReactingCloud
 199 (
 200     const fvMesh& mesh,
 201     const word& name,
 202     const ReactingCloud<CloudType>& c
 203 )
 204 :
 205     CloudType(mesh, name, c),
 206     reactingCloud(),
 207     cloudCopyPtr_(NULL),
 208     constProps_(),
 209     compositionModel_(c.compositionModel_->clone()),
 210 //    compositionModel_(NULL),
 211     phaseChangeModel_(NULL),
 212     rhoTrans_(0),
 213     dMassPhaseChange_(0.0)
 214 {}
 215
 216
 217 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 218
 219 template<class CloudType>
 220 Foam::ReactingCloud<CloudType>::~ReactingCloud()
 221 {}
 222
 223
 224 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 225
 226 template<class CloudType>
 227 void Foam::ReactingCloud<CloudType>::setParcelThermoProperties
 228 (
 229     parcelType& parcel,
 230     const scalar lagrangianDt
 231 )
 232 {
 233     CloudType::setParcelThermoProperties(parcel, lagrangianDt);
 234
 235     parcel.pc() = this->thermo().thermo().p()[parcel.cell()];
 236     parcel.Y() = composition().YMixture0();
 237 }
 238
 239
 240 template<class CloudType>
 241 void Foam::ReactingCloud<CloudType>::checkParcelProperties
 242 (
 243     parcelType& parcel,
 244     const scalar lagrangianDt,
 245     const bool fullyDescribed
 246 )
 247 {
 248     CloudType::checkParcelProperties(parcel, lagrangianDt, fullyDescribed);
 249
 250     if (fullyDescribed)
 251     {
 252         checkSuppliedComposition
 253         (
 254             parcel.Y(),
 255             composition().YMixture0(),
 256             "YMixture"
 257         );
 258     }
 259
 260     // derived information - store initial mass
 261     parcel.mass0() = parcel.mass();
 262 }
 263
 264
 265 template<class CloudType>
 266 void Foam::ReactingCloud<CloudType>::storeState()
 267 {
 268     cloudCopyPtr_.reset
 269     (
 270         static_cast<ReactingCloud<CloudType>*>
 271         (
 272             clone(this->name() + "Copy").ptr()
 273         )
 274     );
 275 }
 276
 277
 278 template<class CloudType>
 279 void Foam::ReactingCloud<CloudType>::restoreState()
 280 {
 281     cloudReset(cloudCopyPtr_());
 282     cloudCopyPtr_.clear();
 283 }
 284
 285
 286 template<class CloudType>
 287 void Foam::ReactingCloud<CloudType>::resetSourceTerms()
 288 {
 289     CloudType::resetSourceTerms();
 290     forAll(rhoTrans_, i)
 291     {
 292         rhoTrans_[i].field() = 0.0;
 293     }
 294 }
 295
 296
 297 template<class CloudType>
 298 void Foam::ReactingCloud<CloudType>::relaxSources
 299 (
 300     const ReactingCloud<CloudType>& cloudOldTime
 301 )
 302 {
 303     CloudType::relaxSources(cloudOldTime);
 304
 305     typedef DimensionedField<scalar, volMesh> dsfType;
 306
 307     forAll(rhoTrans_, fieldI)
 308     {
 309         dsfType& rhoT = rhoTrans_[fieldI];
 310         const dsfType& rhoT0 = cloudOldTime.rhoTrans()[fieldI];
 311         this->relax(rhoT, rhoT0, "rho");
 312     }
 313 }
 314
 315
 316 template<class CloudType>
 317 void Foam::ReactingCloud<CloudType>::scaleSources()
 318 {
 319     CloudType::scaleSources();
 320
 321     typedef DimensionedField<scalar, volMesh> dsfType;
 322
 323     forAll(rhoTrans_, fieldI)
 324     {
 325         dsfType& rhoT = rhoTrans_[fieldI];
 326         this->scale(rhoT, "rho");
 327     }
 328 }
 329
 330
 331 template<class CloudType>
 332 void Foam::ReactingCloud<CloudType>::evolve()
 333 {
 334     if (this->solution().canEvolve())
 335     {
 336         typename parcelType::template
 337             TrackingData<ReactingCloud<CloudType> > td(*this);
 338
 339         this->solve(td);
 340     }
 341 }
 342
 343
 344 template<class CloudType>
 345 void Foam::ReactingCloud<CloudType>::addToMassPhaseChange(const scalar dMass)
 346 {
 347     dMassPhaseChange_ += dMass;
 348 }
 349
 350
 351 template<class CloudType>
 352 void Foam::ReactingCloud<CloudType>::info() const
 353 {
 354     CloudType::info();
 355
 356     Info<< "    Mass transfer phase change      = "
 357         << returnReduce(dMassPhaseChange_, sumOp<scalar>()) << nl;
 358 }
 359
 360
 361 template<class CloudType>
 362 void Foam::ReactingCloud<CloudType>::writeFields() const
 363 {
 364     if (this->size())
 365     {
 366         CloudType::particleType::writeFields(*this, this->composition());
 367     }
 368 }
 369
 370
 371 // ************************************************************************* //