src/lagrangian/intermediate/clouds/Templates/ReactingMultiphaseCloud/ReactingMultiphaseCloud.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   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 Class
  25     Foam::ReactingMultiphaseCloud
  26
  27 Description
  28     Templated base class for multiphase reacting cloud
  29
  30     - Adds to reacting cloud
  31       - multiphase composition
  32       - devolatilisatsion
  33       - surface reactions
  34
  35 SourceFiles
  36     ReactingMultiphaseCloudI.H
  37     ReactingMultiphaseCloud.C
  38
  39 \*---------------------------------------------------------------------------*/
  40
  41 #ifndef ReactingMultiphaseCloud_H
  42 #define ReactingMultiphaseCloud_H
  43
  44 #include "reactingMultiphaseCloud.H"
  45
  46 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  47
  48 namespace Foam
  49 {
  50
  51 // Forward declaration of classes
  52
  53 template<class CloudType>
  54 class DevolatilisationModel;
  55
  56 template<class CloudType>
  57 class SurfaceReactionModel;
  58
  59 /*---------------------------------------------------------------------------*\
  60                    Class ReactingMultiphaseCloud Declaration
  61 \*---------------------------------------------------------------------------*/
  62
  63 template<class CloudType>
  64 class ReactingMultiphaseCloud
  65 :
  66     public CloudType,
  67     public reactingMultiphaseCloud
  68 {
  69 public:
  70
  71     // Public typedefs
  72
  73         //- Type of cloud this cloud was instantiated for
  74         typedef CloudType cloudType;
  75
  76         //- Type of parcel the cloud was instantiated for
  77         typedef typename CloudType::particleType parcelType;
  78
  79         //- Convenience typedef for this cloud type
  80         typedef ReactingMultiphaseCloud<CloudType> reactingMultiphaseCloudType;
  81
  82
  83 private:
  84
  85     // Private data
  86
  87         //- Cloud copy pointer
  88         autoPtr<ReactingMultiphaseCloud<CloudType> > cloudCopyPtr_;
  89
  90
  91     // Private member functions
  92
  93         //- Disallow default bitwise copy construct
  94         ReactingMultiphaseCloud(const ReactingMultiphaseCloud&);
  95
  96         //- Disallow default bitwise assignment
  97         void operator=(const ReactingMultiphaseCloud&);
  98
  99
 100 protected:
 101
 102     // Protected data
 103
 104         //- Parcel constant properties
 105         typename parcelType::constantProperties constProps_;
 106
 107
 108         // References to the cloud sub-models
 109
 110             //- Devolatilisation model
 111             autoPtr
 112             <
 113                 DevolatilisationModel<ReactingMultiphaseCloud<CloudType> >
 114             >
 115             devolatilisationModel_;
 116
 117             //- Surface reaction model
 118             autoPtr
 119             <
 120                 SurfaceReactionModel<ReactingMultiphaseCloud<CloudType> >
 121             >
 122             surfaceReactionModel_;
 123
 124
 125         // Check
 126
 127             //- Total mass transferred to continuous phase via devolatilisation
 128             scalar dMassDevolatilisation_;
 129
 130             //- Total mass transferred to continuous phase via surface
 131             //  reactions
 132             scalar dMassSurfaceReaction_;
 133
 134
 135     // Protected Member Functions
 136
 137         // Initialisation
 138
 139             //- Set cloud sub-models
 140             void setModels();
 141
 142
 143         // Cloud evolution functions
 144
 145             //- Reset state of cloud
 146             void cloudReset(ReactingMultiphaseCloud<CloudType>& c);
 147
 148
 149 public:
 150
 151     // Constructors
 152
 153         //- Construct given carrier gas fields
 154         ReactingMultiphaseCloud
 155         (
 156             const word& cloudName,
 157             const volScalarField& rho,
 158             const volVectorField& U,
 159             const dimensionedVector& g,
 160             const SLGThermo& thermo,
 161             bool readFields = true
 162         );
 163
 164
 165         //- Copy constructor with new name
 166         ReactingMultiphaseCloud
 167         (
 168             ReactingMultiphaseCloud<CloudType>& c,
 169             const word& name
 170         );
 171
 172         //- Copy constructor with new name - creates bare cloud
 173         ReactingMultiphaseCloud
 174         (
 175             const fvMesh& mesh,
 176             const word& name,
 177             const ReactingMultiphaseCloud<CloudType>& c
 178         );
 179
 180         //- Construct and return clone based on (this) with new name
 181         virtual autoPtr<Cloud<parcelType> > clone(const word& name)
 182         {
 183             return autoPtr<Cloud<parcelType> >
 184             (
 185                 new ReactingMultiphaseCloud(*this, name)
 186             );
 187         }
 188
 189         //- Construct and return bare clone based on (this) with new name
 190         virtual autoPtr<Cloud<parcelType> > cloneBare(const word& name) const
 191         {
 192             return autoPtr<Cloud<parcelType> >
 193             (
 194                 new ReactingMultiphaseCloud(this->mesh(), name, *this)
 195             );
 196         }
 197
 198
 199     //- Destructor
 200     virtual ~ReactingMultiphaseCloud();
 201
 202
 203     // Member Functions
 204
 205         // Access
 206
 207             //- Return a reference to the cloud copy
 208             inline const ReactingMultiphaseCloud& cloudCopy() const;
 209
 210             //- Return the constant properties
 211             inline const typename parcelType::constantProperties&
 212                 constProps() const;
 213
 214
 215             // Sub-models
 216
 217                 //- Return reference to devolatilisation model
 218                 inline const DevolatilisationModel
 219                 <
 220                     ReactingMultiphaseCloud<CloudType>
 221                 >&
 222                 devolatilisation() const;
 223
 224                 //- Return reference to reacting surface reaction model
 225                 inline const SurfaceReactionModel
 226                 <
 227                     ReactingMultiphaseCloud<CloudType>
 228                 >&
 229                 surfaceReaction() const;
 230
 231
 232         // Check
 233
 234             //- Add to cumulative volatilisation mass transfer
 235             void addToMassDevolatilisation(const scalar dMass);
 236
 237             //- Add to cumulative surface reaction transfer
 238             void addToMassSurfaceReaction(const scalar dMass);
 239
 240
 241         // Cloud evolution functions
 242
 243             //- Set parcel thermo properties
 244             void setParcelThermoProperties
 245             (
 246                 parcelType& parcel,
 247                 const scalar lagrangianDt
 248             );
 249
 250             //- Check parcel properties
 251             void checkParcelProperties
 252             (
 253                 parcelType& parcel,
 254                 const scalar lagrangianDt,
 255                 const bool fullyDescribed
 256             );
 257
 258             //- Store the current cloud state
 259             void storeState();
 260
 261             //- Reset the current cloud to the previously stored state
 262             void restoreState();
 263
 264             //- Reset the cloud source terms
 265             void resetSourceTerms();
 266
 267             //- Evolve the cloud
 268             void evolve();
 269
 270             //- Print cloud information
 271             void info() const;
 272
 273
 274         // I-O
 275
 276             //- Write the field data for the cloud
 277             virtual void writeFields() const;
 278 };
 279
 280
 281 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 282
 283 } // End namespace Foam
 284
 285 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 286
 287 #include "ReactingMultiphaseCloudI.H"
 288
 289 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 290
 291 #ifdef NoRepository
 292 #   include "ReactingMultiphaseCloud.C"
 293 #endif
 294
 295 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 296
 297 #endif
 298
 299 // ************************************************************************* //