updates/improvements to the cloud IO system and using new constants

applications/solvers/lagrangian/coalChemistryFoam/coalChemistryFoam.C

@@ -38,7 +38,6 @@ Description
 #include "CoalCloud.H"
 #include "psiChemistryModel.H"
 #include "chemistrySolver.H"
-#include "thermoPhysicsTypes.H"
 #include "timeActivatedExplicitCellSource.H"
 #include "radiationModel.H"
 

applications/solvers/lagrangian/coalChemistryFoam/createClouds.H

@@ -1,5 +1,5 @@
 Info<< "\nConstructing coal cloud" << endl;
-CoalCloud<gasThermoPhysics> coalParcels
+thermoCoalCloud coalParcels
 (
     "coalCloud1",
     rho,

applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/createClouds.H

@@ -1,5 +1,5 @@
 Info<< "\nConstructing reacting cloud" << endl;
-BasicReactingCloud<icoPoly8ThermoPhysics> parcels
+icoPoly8ThermoReactingCloud parcels
 (
     "reactingCloud1",
     rho,

applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/porousExplicitSourceReactingParcelFoam.C

@@ -46,7 +46,6 @@ Description
 #include "BasicReactingCloud.H"
 #include "rhoChemistryModel.H"
 #include "chemistrySolver.H"
-#include "thermoPhysicsTypes.H"
 #include "radiationModel.H"
 #include "porousZones.H"
 #include "timeActivatedExplicitMulticomponentPointSource.H"

applications/solvers/lagrangian/reactingParcelFoam/createClouds.H

@@ -1,5 +1,5 @@
 Info<< "\nConstructing reacting cloud" << endl;
-BasicReactingCloud<gasThermoPhysics> parcels
+thermoReactingCloud parcels
 (
     "reactingCloud1",
     rho,

applications/solvers/lagrangian/reactingParcelFoam/reactingParcelFoam.C

@@ -37,7 +37,6 @@ Description
 #include "BasicReactingCloud.H"
 #include "psiChemistryModel.H"
 #include "chemistrySolver.H"
-#include "thermoPhysicsTypes.H"
 #include "radiationModel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/lagrangian/basic/Cloud/CloudIO.C

@@ -139,7 +139,13 @@ void Foam::Cloud<ParticleType>::readFields()
 
 template<class ParticleType>
 void Foam::Cloud<ParticleType>::writeFields() const
-{}
+{
+    if (this->size())
+    {
+        const ParticleType& p = *this->first();
+        ParticleType::writeFields(p.cloud());
+    }
+}
 
 
 template<class ParticleType>

src/lagrangian/coalCombustion/CoalCloud/CoalCloud.C

@@ -1,70 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2008-2009 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "CoalCloud.H"
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-template<class ThermoType>
-Foam::CoalCloud<ThermoType>::CoalCloud
-(
-    const word& cloudName,
-    const volScalarField& rho,
-    const volVectorField& U,
-    const dimensionedVector& g,
-    basicThermo& thermo
-)
-:
-    ReactingMultiphaseCloud<CoalParcel<ThermoType> >
-    (
-        cloudName,
-        rho,
-        U,
-        g,
-        thermo
-    )
-{
-    CoalParcel<ThermoType>::readFields(*this);
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-template<class ThermoType>
-Foam::CoalCloud<ThermoType>::~CoalCloud()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class ThermoType>
-void Foam::CoalCloud<ThermoType>::writeFields() const
-{
-    CoalParcel<ThermoType>::writeFields(*this);
-}
-
-
-// ************************************************************************* //

src/lagrangian/coalCombustion/CoalCloud/CoalCloud.H

@@ -26,9 +26,7 @@ Class
     CoalCloud
 
 Description
-
+    Coal cloud templated on the type of carrier phase thermodynamics
-SourceFiles
-    CoalCloud.C
 
 \*---------------------------------------------------------------------------*/
 
@@ -37,69 +35,21 @@ SourceFiles
 
 #include "ReactingMultiphaseCloud.H"
 #include "CoalParcel.H"
+#include "thermoPhysicsTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
+    typedef ReactingMultiphaseCloud<CoalParcel<constGasThermoPhysics> >
+        constThermoCoalCloud;
 
-/*---------------------------------------------------------------------------*\
+    typedef ReactingMultiphaseCloud<CoalParcel<gasThermoPhysics> >
-                          Class CoalCloud Declaration
+        thermoCoalCloud;
-\*---------------------------------------------------------------------------*/
 
-template<class ThermoType>
+    typedef ReactingMultiphaseCloud<CoalParcel<icoPoly8ThermoPhysics> >
-class CoalCloud
+        icoPoly8ThermoCoalCloud;
-:
+}
-    public ReactingMultiphaseCloud<CoalParcel<ThermoType> >
-{
-    // Private Member Functions
-
-        //- Disallow default bitwise copy construct
-        CoalCloud(const CoalCloud&);
-
-        //- Disallow default bitwise assignment
-        void operator=(const CoalCloud&);
-
-
-public:
-
-    //-Runtime type information
-    TypeName("CoalCloud");
-
-
-    // Constructors
-
-        //- Construct given carrier gas fields
-        CoalCloud
-        (
-            const word& cloudName,
-            const volScalarField& rho,
-            const volVectorField& U,
-            const dimensionedVector& g,
-            basicThermo& thermo
-        );
-
-
-    //- Destructor
-    ~CoalCloud();
-
-
-    // Member Functions
-
-        //- Write fields
-        virtual void writeFields() const;
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#ifdef NoRepository
-    #include "CoalCloud.C"
-#endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/lagrangian/coalCombustion/CoalCloud/defineCoalCloud.C

@@ -1,38 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2008-2009 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "createReactingCloudTypes.H"
-#include "CoalCloud.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    createReactingCloudType(CoalCloud);
-};
-
-
-// ************************************************************************* //

src/lagrangian/coalCombustion/Make/files

@@ -1,6 +1,3 @@
-/* Coal cloud */
-CoalCloud/defineCoalCloud.C
-
 /* Coal parcel and sub-models */
 CoalParcel/defineCoalParcel.C
 CoalParcel/makeCoalParcelSubmodels.C

src/lagrangian/coalCombustion/include/createCoalParcelTypes.H

@@ -92,8 +92,7 @@ License
     (                                                                         \
         ReactingMultiphaseCloud<ParcelType##ThermoType>,                      \
         0                                                                     \
-    );                                                                        \
+    );
-    defineParcelTypeNameAndDebug(CoalCloud<ParcelType##ThermoType>, 0);
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/lagrangian/dieselSpray/parcel/parcelIO.C

@@ -96,10 +96,7 @@ Foam::parcel::parcel
 }
 
 
-void Foam::parcel::readFields
+void Foam::parcel::readFields(Cloud<parcel>& c)
-(
-    Cloud<parcel>& c
-)
 {
     if (!c.size())
     {
@@ -195,10 +192,7 @@ void Foam::parcel::readFields
 }
 
 
-void Foam::parcel::writeFields
+void Foam::parcel::writeFields(const Cloud<parcel>& c)
-(
-    const Cloud<parcel>& c
-)
 {
     Particle<parcel>::writeFields(c);
 

src/lagrangian/dieselSpray/spray/spray.C

@@ -59,7 +59,8 @@ Foam::spray::spray
     const basicMultiComponentMixture& composition,
     const PtrList<gasThermoPhysics>& gasProperties,
     const dictionary&,
-    const dimensionedVector& g
+    const dimensionedVector& g,
+    bool readFields
 )
 :
     Cloud<parcel>(U.mesh(), false), // suppress className checking on positions
@@ -345,7 +346,10 @@ Foam::spray::spray
         }
     }
 
+    if (readFields)
+    {
         parcel::readFields(*this);
+    }
 }
 
 
@@ -355,12 +359,4 @@ Foam::spray::~spray()
 {}
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-void Foam::spray::writeFields() const
-{
-    parcel::writeFields(*this);
-}
-
-
 // ************************************************************************* //

src/lagrangian/dieselSpray/spray/spray.H

@@ -194,7 +194,8 @@ public:
             const basicMultiComponentMixture& composition,
             const PtrList<gasThermoPhysics>& gasProperties,
             const dictionary& thermophysicalProperties,
-            const dimensionedVector& g
+            const dimensionedVector& g,
+            bool readFields = true
         );
 
 
@@ -339,12 +340,6 @@ public:
 
             //- Return Ambient Temperature
             void calculateAmbientTemperature();
-
-
-    // I/O
-
-            //- Write fields
-            virtual void writeFields() const;
 };
 
 

src/lagrangian/dsmc/clouds/Templates/DsmcCloud/DsmcCloud.C

@@ -28,11 +28,9 @@ License
 #include "BinaryCollisionModel.H"
 #include "WallInteractionModel.H"
 #include "InflowBoundaryModel.H"
+#include "constants.H"
 
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+using namespace Foam::constant;
-
-template<class ParcelType>
-Foam::scalar Foam::DsmcCloud<ParcelType>::kb = 1.380650277e-23;
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
@@ -526,7 +524,8 @@ Foam::DsmcCloud<ParcelType>::DsmcCloud
 (
     const word& cloudName,
     const volScalarField& T,
-    const volVectorField& U
+    const volVectorField& U,
+    bool readFields
 )
 :
     Cloud<ParcelType>(T.mesh(), cloudName, false),
@@ -630,6 +629,11 @@ Foam::DsmcCloud<ParcelType>::DsmcCloud
     {
         collisionSelectionRemainder_[i] = rndGen_.scalar01();
     }
+
+    if (readFields)
+    {
+        ParcelType::readFields(*this);
+    }
 }
 
 
@@ -853,7 +857,7 @@ Foam::vector Foam::DsmcCloud<ParcelType>::equipartitionLinearVelocity
 )
 {
     return
-        sqrt(kb*temperature/mass)
+        sqrt(physicoChemical::k.value()*temperature/mass)
        *vector
         (
             rndGen_.GaussNormal(),
@@ -879,7 +883,7 @@ Foam::scalar Foam::DsmcCloud<ParcelType>::equipartitionInternalEnergy
     else if (iDof < 2.0 + SMALL && iDof > 2.0 - SMALL)
     {
         // Special case for iDof = 2, i.e. diatomics;
-        Ei = -log(rndGen_.scalar01())*kb*temperature;
+        Ei = -log(rndGen_.scalar01())*physicoChemical::k.value()*temperature;
     }
     else
     {
@@ -897,7 +901,7 @@ Foam::scalar Foam::DsmcCloud<ParcelType>::equipartitionInternalEnergy
 
         } while (P < rndGen_.scalar01());
 
-        Ei = energyRatio*kb*temperature;
+        Ei = energyRatio*physicoChemical::k.value()*temperature;
     }
 
     return Ei;

src/lagrangian/dsmc/clouds/Templates/DsmcCloud/DsmcCloud.H

@@ -171,12 +171,6 @@ class DsmcCloud
 
 public:
 
-    // Static data members
-
-        //- Boltzmann constant
-        static scalar kb;
-
-
     // Constructors
 
         //- Construct given name and mesh, will read Parcels from file
@@ -184,7 +178,8 @@ public:
         (
             const word& cloudName,
             const volScalarField& T,
-            const volVectorField& U
+            const volVectorField& U,
+            bool readFields = true
         );
 
         //- Construct given name and mesh.  Used to initialise.
@@ -338,6 +333,7 @@ public:
                     scalar mass
                 ) const;
 
+
             // Sub-models
 
                 //- Return reference to binary elastic collision model
@@ -429,11 +425,8 @@ public:
             //- Evolve the cloud (move, collide)
             void evolve();
 
-
             //- Clear the Cloud
             inline void clear();
-
-
 };
 
 

src/lagrangian/dsmc/clouds/Templates/DsmcCloud/DsmcCloudI.H

@@ -24,7 +24,9 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "mathConstants.H"
+#include "constants.H"
+
+using namespace Foam::constant;
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
@@ -314,7 +316,8 @@ inline Foam::scalar Foam::DsmcCloud<ParcelType>::maxwellianAverageSpeed
     scalar mass
 ) const
 {
-    return 2.0*sqrt(2.0*kb*temperature/(constant::math::pi*mass));
+    return
+        2.0*sqrt(2.0*physicoChemical::k.value()*temperature/(math::pi*mass));
 }
 
 
@@ -325,7 +328,8 @@ inline Foam::scalarField Foam::DsmcCloud<ParcelType>::maxwellianAverageSpeed
     scalar mass
 ) const
 {
-    return 2.0*sqrt(2.0*kb*temperature/(constant::math::pi*mass));
+    return
+        2.0*sqrt(2.0*physicoChemical::k.value()*temperature/(math::pi*mass));
 }
 
 
@@ -336,7 +340,7 @@ inline Foam::scalar Foam::DsmcCloud<ParcelType>::maxwellianRMSSpeed
     scalar mass
 ) const
 {
-    return sqrt(3.0*kb*temperature/mass);
+    return sqrt(3.0*physicoChemical::k.value()*temperature/mass);
 }
 
 
@@ -347,7 +351,7 @@ inline Foam::scalarField Foam::DsmcCloud<ParcelType>::maxwellianRMSSpeed
     scalar mass
 ) const
 {
-    return sqrt(3.0*kb*temperature/mass);
+    return sqrt(3.0*physicoChemical::k.value()*temperature/mass);
 }
 
 
@@ -359,7 +363,7 @@ Foam::DsmcCloud<ParcelType>::maxwellianMostProbableSpeed
     scalar mass
 ) const
 {
-    return sqrt(2.0*kb*temperature/mass);
+    return sqrt(2.0*physicoChemical::k.value()*temperature/mass);
 }
 
 
@@ -371,7 +375,7 @@ Foam::DsmcCloud<ParcelType>::maxwellianMostProbableSpeed
     scalar mass
 ) const
 {
-    return sqrt(2.0*kb*temperature/mass);
+    return sqrt(2.0*physicoChemical::k.value()*temperature/mass);
 }
 
 

src/lagrangian/dsmc/clouds/derived/dsmcCloud/dsmcCloud.C

@@ -44,9 +44,7 @@ Foam::dsmcCloud::dsmcCloud
 )
 :
     DsmcCloud<dsmcParcel>(cloudName, T, U)
-{
+{}
-    dsmcParcel::readFields(*this);
-}
 
 
 Foam::dsmcCloud::dsmcCloud
@@ -65,11 +63,4 @@ Foam::dsmcCloud::~dsmcCloud()
 {}
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-void Foam::dsmcCloud::writeFields() const
-{
-    dsmcParcel::writeFields(*this);
-}
-
 // ************************************************************************* //

src/lagrangian/dsmc/clouds/derived/dsmcCloud/dsmcCloud.H

@@ -86,12 +86,6 @@ public:
 
     //- Destructor
     ~dsmcCloud();
-
-
-    // Member functions
-
-        //- Write fields
-        virtual void writeFields() const;
 };
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/lagrangian/dsmc/parcels/Templates/DsmcParcel/DsmcParcel.H

@@ -308,9 +308,9 @@ public:
 
         // I-O
 
-            static void readFields(DsmcCloud<ParcelType>& c);
+            static void readFields(Cloud<ParcelType>& c);
 
-            static void writeFields(const DsmcCloud<ParcelType>& c);
+            static void writeFields(const Cloud<ParcelType>& c);
 
 
     // Ostream Operator

src/lagrangian/dsmc/parcels/Templates/DsmcParcel/DsmcParcelIO.C

@@ -74,10 +74,7 @@ Foam::DsmcParcel<ParcelType>::DsmcParcel
 
 
 template<class ParcelType>
-void Foam::DsmcParcel<ParcelType>::readFields
+void Foam::DsmcParcel<ParcelType>::readFields(Cloud<ParcelType>& c)
-(
-    DsmcCloud<ParcelType>& c
-)
 {
     if (!c.size())
     {
@@ -107,10 +104,7 @@ void Foam::DsmcParcel<ParcelType>::readFields
 
 
 template<class ParcelType>
-void Foam::DsmcParcel<ParcelType>::writeFields
+void Foam::DsmcParcel<ParcelType>::writeFields(const Cloud<ParcelType>& c)
-(
-    const DsmcCloud<ParcelType>& c
-)
 {
     Particle<ParcelType>::writeFields(c);
 

src/lagrangian/dsmc/submodels/BinaryCollisionModel/LarsenBorgnakkeVariableHardSphere/LarsenBorgnakkeVariableHardSphere.C

@@ -25,7 +25,9 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "LarsenBorgnakkeVariableHardSphere.H"
-#include "mathConstants.H"
+#include "constants.H"
+
+using namespace Foam::constant;
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -157,8 +159,8 @@ Foam::scalar Foam::LarsenBorgnakkeVariableHardSphere<CloudType>::sigmaTcR
 
     // calculating cross section = pi*dPQ^2, where dPQ is from Bird, eq. 4.79
     scalar sigmaTPQ =
-        constant::math::pi*dPQ*dPQ
+        math::pi*dPQ*dPQ
-       *pow(2.0*CloudType::kb*Tref_/(mR*cR*cR), omegaPQ - 0.5)
+       *pow(2.0*physicoChemical::k.value()*Tref_/(mR*cR*cR), omegaPQ - 0.5)
        /exp(Foam::lgamma(2.5 - omegaPQ));
 
     return sigmaTPQ*cR;
@@ -253,7 +255,7 @@ void Foam::LarsenBorgnakkeVariableHardSphere<CloudType>::collide
 
     scalar sinTheta = sqrt(1.0 - cosTheta*cosTheta);
 
-    scalar phi = constant::math::twoPi*rndGen.scalar01();
+    scalar phi = math::twoPi*rndGen.scalar01();
 
     vector postCollisionRelU =
         cR

src/lagrangian/dsmc/submodels/BinaryCollisionModel/VariableHardSphere/VariableHardSphere.C

@@ -25,7 +25,9 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "VariableHardSphere.H"
-#include "mathConstants.H"
+#include "constants.H"
+
+using namespace Foam::constant;
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -91,8 +93,8 @@ Foam::scalar Foam::VariableHardSphere<CloudType>::sigmaTcR
 
     // calculating cross section = pi*dPQ^2, where dPQ is from Bird, eq. 4.79
     scalar sigmaTPQ =
-        constant::math::pi*dPQ*dPQ
+        math::pi*dPQ*dPQ
-       *pow(2.0*CloudType::kb*Tref_/(mR*cR*cR), omegaPQ - 0.5)
+       *pow(2.0*physicoChemical::k.value()*Tref_/(mR*cR*cR), omegaPQ - 0.5)
        /exp(Foam::lgamma(2.5 - omegaPQ));
 
     return sigmaTPQ*cR;
@@ -126,7 +128,7 @@ void Foam::VariableHardSphere<CloudType>::collide
 
     scalar sinTheta = sqrt(1.0 - cosTheta*cosTheta);
 
-    scalar phi = constant::math::twoPi*rndGen.scalar01();
+    scalar phi = math::twoPi*rndGen.scalar01();
 
     vector postCollisionRelU =
         cR

src/lagrangian/dsmc/submodels/InflowBoundaryModel/FreeStream/FreeStream.C

@@ -25,7 +25,9 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "FreeStream.H"
-#include "mathConstants.H"
+#include "constants.H"
+
+using namespace Foam::constant;
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -131,7 +133,7 @@ void Foam::FreeStream<CloudType>::inflow()
 
     Random& rndGen(cloud.rndGen());
 
-    scalar sqrtPi = sqrt(constant::math::pi);
+    scalar sqrtPi = sqrt(math::pi);
 
     label particlesInserted = 0;
 
@@ -370,7 +372,7 @@ void Foam::FreeStream<CloudType>::inflow()
                     } while (P < rndGen.scalar01());
 
                     vector U =
-                        sqrt(CloudType::kb*faceTemperature/mass)
+                        sqrt(physicoChemical::k.value()*faceTemperature/mass)
                        *(
                             rndGen.GaussNormal()*t1
                           + rndGen.GaussNormal()*t2

src/lagrangian/dsmc/submodels/WallInteractionModel/MaxwellianThermal/MaxwellianThermal.C

@@ -25,6 +25,9 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "MaxwellianThermal.H"
+#include "constants.H"
+
+using namespace Foam::constant;
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -108,7 +111,7 @@ void Foam::MaxwellianThermal<CloudType>::correct
     scalar iDof = cloud.constProps(typeId).internalDegreesOfFreedom();
 
     U =
-        sqrt(CloudType::kb*T/mass)
+        sqrt(physicoChemical::k.value()*T/mass)
        *(
             rndGen.GaussNormal()*tw1
           + rndGen.GaussNormal()*tw2

src/lagrangian/intermediate/Make/files

@@ -18,13 +18,6 @@ $(BASECLOUDS)/reactingCloud/reactingCloud.C
 $(BASECLOUDS)/reactingMultiphaseCloud/reactingMultiphaseCloud.C
 
 
-/* Cloud container/injection mechanisms */
-$(DERIVEDCLOUDS)/basicKinematicCloud/basicKinematicCloud.C
-$(DERIVEDCLOUDS)/basicThermoCloud/basicThermoCloud.C
-$(DERIVEDCLOUDS)/BasicReactingCloud/defineBasicReactingCloud.C
-$(DERIVEDCLOUDS)/BasicReactingMultiphaseCloud/defineBasicReactingMultiphaseCloud.C
-
-
 /* kinematic parcel sub-models */
 KINEMATICPARCEL=$(DERIVEDPARCELS)/basicKinematicParcel
 $(KINEMATICPARCEL)/basicKinematicParcel.C

src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.C

@@ -43,7 +43,8 @@ Foam::KinematicCloud<ParcelType>::KinematicCloud
     const volScalarField& rho,
     const volVectorField& U,
     const volScalarField& mu,
-    const dimensionedVector& g
+    const dimensionedVector& g,
+    bool readFields
 )
 :
     Cloud<ParcelType>(rho.mesh(), cloudName, false),
@@ -136,7 +137,12 @@ Foam::KinematicCloud<ParcelType>::KinematicCloud
         mesh_,
         dimensionedVector("zero", dimMass*dimVelocity, vector::zero)
     )
-{}
+{
+    if (readFields)
+    {
+        ParcelType::readFields(*this);
+    }
+}
 
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //

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

@@ -204,7 +204,8 @@ public:
             const volScalarField& rho,
             const volVectorField& U,
             const volScalarField& mu,
-            const dimensionedVector& g
+            const dimensionedVector& g,
+            bool readFields = true
         );
 
 

src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.C

@@ -67,10 +67,11 @@ Foam::ReactingCloud<ParcelType>::ReactingCloud
     const volScalarField& rho,
     const volVectorField& U,
     const dimensionedVector& g,
-    basicThermo& thermo
+    basicThermo& thermo,
+    bool readFields
 )
 :
-    ThermoCloud<ParcelType>(cloudName, rho, U, g, thermo),
+    ThermoCloud<ParcelType>(cloudName, rho, U, g, thermo, false),
     reactingCloud(),
     constProps_(this->particleProperties()),
     mcCarrierThermo_
@@ -118,6 +119,11 @@ Foam::ReactingCloud<ParcelType>::ReactingCloud
             )
         );
     }
+
+    if (readFields)
+    {
+        ParcelType::readFields(*this);
+    }
 }
 
 

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

@@ -152,7 +152,8 @@ public:
             const volScalarField& rho,
             const volVectorField& U,
             const dimensionedVector& g,
-            basicThermo& thermo
+            basicThermo& thermo,
+            bool readFields = true
         );
 
 

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

@@ -38,10 +38,11 @@ Foam::ReactingMultiphaseCloud<ParcelType>::ReactingMultiphaseCloud
     const volScalarField& rho,
     const volVectorField& U,
     const dimensionedVector& g,
-    basicThermo& thermo
+    basicThermo& thermo,
+    bool readFields
 )
 :
-    ReactingCloud<ParcelType>(cloudName, rho, U, g, thermo),
+    ReactingCloud<ParcelType>(cloudName, rho, U, g, thermo, false),
     reactingMultiphaseCloud(),
     constProps_(this->particleProperties()),
     devolatilisationModel_
@@ -61,7 +62,12 @@ Foam::ReactingMultiphaseCloud<ParcelType>::ReactingMultiphaseCloud
         )
     ),
     dMassDevolatilisation_(0.0)
-{}
+{
+    if (readFields)
+    {
+        ParcelType::readFields(*this);
+    }
+}
 
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //

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

@@ -134,7 +134,8 @@ public:
             const volScalarField& rho,
             const volVectorField& U,
             const dimensionedVector& g,
-            basicThermo& thermo
+            basicThermo& thermo,
+            bool readFields = true
         );
 
 

src/lagrangian/intermediate/clouds/Templates/ThermoCloud/ThermoCloud.C

@@ -39,7 +39,8 @@ Foam::ThermoCloud<ParcelType>::ThermoCloud
     const volScalarField& rho,
     const volVectorField& U,
     const dimensionedVector& g,
-    basicThermo& thermo
+    basicThermo& thermo,
+    bool readFields
 )
 :
     KinematicCloud<ParcelType>
@@ -48,7 +49,8 @@ Foam::ThermoCloud<ParcelType>::ThermoCloud
         rho,
         U,
         thermo.mu(),
-        g
+        g,
+        false
     ),
     thermoCloud(),
     constProps_(this->particleProperties()),
@@ -98,7 +100,12 @@ Foam::ThermoCloud<ParcelType>::ThermoCloud
         this->mesh(),
         dimensionedScalar("zero", dimensionSet(1, 2, -2, 0, 0), 0.0)
     )
-{}
+{
+    if (readFields)
+    {
+        ParcelType::readFields(*this);
+    }
+}
 
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //

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

@@ -140,7 +140,8 @@ public:
             const volScalarField& rho,
             const volVectorField& U,
             const dimensionedVector& g,
-            basicThermo& thermo
+            basicThermo& thermo,
+            bool readFields = true
         );
 
 

src/lagrangian/intermediate/clouds/derived/BasicReactingCloud/BasicReactingCloud.C

@@ -1,70 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "BasicReactingCloud.H"
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-template<class ThermoType>
-Foam::BasicReactingCloud<ThermoType>::BasicReactingCloud
-(
-    const word& cloudName,
-    const volScalarField& rho,
-    const volVectorField& U,
-    const dimensionedVector& g,
-    basicThermo& thermo
-)
-:
-    ReactingCloud<BasicReactingParcel<ThermoType> >
-    (
-        cloudName,
-        rho,
-        U,
-        g,
-        thermo
-    )
-{
-    BasicReactingParcel<ThermoType>::readFields(*this);
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-template<class ThermoType>
-Foam::BasicReactingCloud<ThermoType>::~BasicReactingCloud()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class ThermoType>
-void Foam::BasicReactingCloud<ThermoType>::writeFields() const
-{
-    BasicReactingParcel<ThermoType>::writeFields(*this);
-}
-
-
-// ************************************************************************* //

src/lagrangian/intermediate/clouds/derived/BasicReactingCloud/BasicReactingCloud.H

@@ -38,73 +38,21 @@ SourceFiles
 
 #include "ReactingCloud.H"
 #include "BasicReactingParcel.H"
+#include "thermoPhysicsTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
+    typedef ReactingCloud<BasicReactingParcel<constGasThermoPhysics> >
+        constThermoReactingCloud;
 
-// Forward declaration of classes
+    typedef ReactingCloud<BasicReactingParcel<gasThermoPhysics> >
-template<class ThermoType>
+        thermoReactingCloud;
-class BasicReactingCloud;
 
-/*---------------------------------------------------------------------------*\
+    typedef ReactingCloud<BasicReactingParcel<icoPoly8ThermoPhysics> >
-                        Class BasicReactingCloud Declaration
+        icoPoly8ThermoReactingCloud;
-\*---------------------------------------------------------------------------*/
+}
-
-template<class ThermoType>
-class BasicReactingCloud
-:
-    public ReactingCloud<BasicReactingParcel<ThermoType> >
-{
-    // Private Member Functions
-
-        //- Disallow default bitwise copy construct
-        BasicReactingCloud(const BasicReactingCloud&);
-
-        //- Disallow default bitwise assignment
-        void operator=(const BasicReactingCloud&);
-
-
-public:
-
-    //- Runtime type information
-    TypeName("BasicReactingCloud");
-
-
-    // Constructors
-
-        //- Construct given carrier gas fields
-        BasicReactingCloud
-        (
-            const word& cloudName,
-            const volScalarField& rho,
-            const volVectorField& U,
-            const dimensionedVector& g,
-            basicThermo& thermo
-        );
-
-
-    //- Destructor
-    ~BasicReactingCloud();
-
-
-    // Member Functions
-
-        //- Write fields
-        virtual void writeFields() const;
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#ifdef NoRepository
-    #include "BasicReactingCloud.C"
-#endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/lagrangian/intermediate/clouds/derived/BasicReactingCloud/defineBasicReactingCloud.C

@@ -1,38 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "createReactingCloudTypes.H"
-#include "BasicReactingCloud.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    createReactingCloudType(BasicReactingCloud);
-};
-
-
-// ************************************************************************* //

src/lagrangian/intermediate/clouds/derived/BasicReactingMultiphaseCloud/BasicReactingMultiphaseCloud.C

@@ -1,70 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2008-2009 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "BasicReactingMultiphaseCloud.H"
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-template<class ThermoType>
-Foam::BasicReactingMultiphaseCloud<ThermoType>::BasicReactingMultiphaseCloud
-(
-    const word& cloudName,
-    const volScalarField& rho,
-    const volVectorField& U,
-    const dimensionedVector& g,
-    basicThermo& thermo
-)
-:
-    ReactingMultiphaseCloud<BasicReactingMultiphaseParcel<ThermoType> >
-    (
-        cloudName,
-        rho,
-        U,
-        g,
-        thermo
-    )
-{
-    BasicReactingMultiphaseParcel<ThermoType>::readFields(*this);
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-template<class ThermoType>
-Foam::BasicReactingMultiphaseCloud<ThermoType>::~BasicReactingMultiphaseCloud()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class ThermoType>
-void Foam::BasicReactingMultiphaseCloud<ThermoType>::writeFields() const
-{
-    BasicReactingMultiphaseParcel<ThermoType>::writeFields(*this);
-}
-
-
-// ************************************************************************* //

src/lagrangian/intermediate/clouds/derived/BasicReactingMultiphaseCloud/BasicReactingMultiphaseCloud.H

@@ -26,10 +26,8 @@ Class
     Foam::BasicReactingMultiphaseCloud
 
 Description
-    Reacting multiphase cloud templated on the type of carrier phase thermodynamics
+    Reacting multiphase cloud templated on the type of carrier phase
-
+    thermodynamics
-SourceFiles
-    BasicReactingMultiphaseCloud.C
 
 \*---------------------------------------------------------------------------*/
 
@@ -38,73 +36,21 @@ SourceFiles
 
 #include "ReactingMultiphaseCloud.H"
 #include "BasicReactingMultiphaseParcel.H"
+#include "thermoPhysicsTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
+    typedef ReactingMultiphaseCloud<BasicReactingParcel<constGasThermoPhysics> >
+        constThermoReactingMultiphaseCloud;
 
-// Forward declaration of classes
+    typedef ReactingMultiphaseCloud<BasicReactingParcel<gasThermoPhysics> >
-template<class ThermoType>
+        thermoReactingMultiphaseCloud;
-class BasicReactingMultiphaseCloud;
 
-/*---------------------------------------------------------------------------*\
+    typedef ReactingMultiphaseCloud<BasicReactingParcel<icoPoly8ThermoPhysics> >
-                Class BasicReactingMultiphaseCloud Declaration
+        icoPoly8ThermoReactingMultiphaseCloud;
-\*---------------------------------------------------------------------------*/
+}
-
-template<class ThermoType>
-class BasicReactingMultiphaseCloud
-:
-    public ReactingMultiphaseCloud<BasicReactingMultiphaseParcel<ThermoType> >
-{
-    // Private Member Functions
-
-        //- Disallow default bitwise copy construct
-        BasicReactingMultiphaseCloud(const BasicReactingMultiphaseCloud&);
-
-        //- Disallow default bitwise assignment
-        void operator=(const BasicReactingMultiphaseCloud&);
-
-
-public:
-
-    //- Runtime type information
-    TypeName("BasicReactingMultiphaseCloud");
-
-
-    // Constructors
-
-        //- Construct given carrier gas fields
-        BasicReactingMultiphaseCloud
-        (
-            const word& cloudName,
-            const volScalarField& rho,
-            const volVectorField& U,
-            const dimensionedVector& g,
-            basicThermo& thermo
-        );
-
-
-    //- Destructor
-    ~BasicReactingMultiphaseCloud();
-
-
-    // Member Functions
-
-        //- Write fields
-        virtual void writeFields() const;
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#ifdef NoRepository
-    #include "BasicReactingMultiphaseCloud.C"
-#endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/lagrangian/intermediate/clouds/derived/BasicReactingMultiphaseCloud/defineBasicReactingMultiphaseCloud.C

@@ -1,38 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2008-2009 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "createReactingCloudTypes.H"
-#include "BasicReactingMultiphaseCloud.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    createReactingCloudType(BasicReactingMultiphaseCloud);
-};
-
-
-// ************************************************************************* //

src/lagrangian/intermediate/clouds/derived/basicKinematicCloud/basicKinematicCloud.C

@@ -1,68 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "basicKinematicCloud.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(basicKinematicCloud, 0);
-};
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::basicKinematicCloud::basicKinematicCloud
-(
-    const word& cloudName,
-    const volScalarField& rho,
-    const volVectorField& U,
-    const volScalarField& mu,
-    const dimensionedVector& g
-)
-:
-    KinematicCloud<basicKinematicParcel>(cloudName, rho, U, mu, g)
-{
-    basicKinematicParcel::readFields(*this);
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::basicKinematicCloud::~basicKinematicCloud()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-void Foam::basicKinematicCloud::writeFields() const
-{
-    basicKinematicParcel::writeFields(*this);
-}
-
-
-// ************************************************************************* //

src/lagrangian/intermediate/clouds/derived/basicKinematicCloud/basicKinematicCloud.H

@@ -43,56 +43,8 @@ SourceFiles
 
 namespace Foam
 {
-
+    typedef KinematicCloud<basicKinematicParcel> basicKinematicCloud;
-/*---------------------------------------------------------------------------*\
+}
-                      Class basicKinematicCloud Declaration
-\*---------------------------------------------------------------------------*/
-
-class basicKinematicCloud
-:
-    public KinematicCloud<basicKinematicParcel>
-{
-    // Private member functions
-
-        //- Disallow default bitwise copy construct
-        basicKinematicCloud(const basicKinematicCloud&);
-
-        //- Disallow default bitwise assignment
-        void operator=(const basicKinematicCloud&);
-
-
-public:
-
-    //- Runtime type information
-    TypeName("basicKinematicCloud");
-
-
-    // Constructors
-
-        //- Construct from components
-        basicKinematicCloud
-        (
-            const word& cloudName,
-            const volScalarField& rho,
-            const volVectorField& U,
-            const volScalarField& mu,
-            const dimensionedVector& g
-        );
-
-
-    //- Destructor
-    ~basicKinematicCloud();
-
-
-    // Member functions
-
-        //- Write fields
-        virtual void writeFields() const;
-};
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/lagrangian/intermediate/clouds/derived/basicThermoCloud/basicThermoCloud.C

@@ -1,68 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "basicThermoCloud.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(basicThermoCloud, 0);
-};
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::basicThermoCloud::basicThermoCloud
-(
-    const word& cloudName,
-    const volScalarField& rho,
-    const volVectorField& U,
-    const dimensionedVector& g,
-    basicThermo& thermo
-)
-:
-    ThermoCloud<basicThermoParcel>(cloudName, rho, U, g, thermo)
-{
-    basicThermoParcel::readFields(*this);
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::basicThermoCloud::~basicThermoCloud()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-void Foam::basicThermoCloud::writeFields() const
-{
-    basicThermoParcel::writeFields(*this);
-}
-
-
-// ************************************************************************* //

src/lagrangian/intermediate/clouds/derived/basicThermoCloud/basicThermoCloud.H

@@ -43,60 +43,8 @@ SourceFiles
 
 namespace Foam
 {
-
+    typedef ThermoCloud<basicThermoParcel> basicThermoCloud;
-/*---------------------------------------------------------------------------*\
+}
-                        Class basicThermoCloud Declaration
-\*---------------------------------------------------------------------------*/
-
-class basicThermoCloud
-:
-    public ThermoCloud<basicThermoParcel>
-{
-    // Private Member Functions
-
-        //- Disallow default bitwise copy construct
-        basicThermoCloud
-        (
-            const basicThermoCloud&
-        );
-
-        //- Disallow default bitwise assignment
-        void operator=(const basicThermoCloud&);
-
-
-public:
-
-    //- Runtime type information
-    TypeName("basicThermoCloud");
-
-
-    // Constructors
-
-        //- Construct given carrier gas fields
-        basicThermoCloud
-        (
-            const word& cloudName,
-            const volScalarField& rho,
-            const volVectorField& U,
-            const dimensionedVector& g,
-            basicThermo& thermo
-        );
-
-
-    //- Destructor
-    ~basicThermoCloud();
-
-
-    // Member Functions
-
-        //- Write fields
-        virtual void writeFields() const;
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/lagrangian/intermediate/clouds/include/createReactingCloudTypes.H

@@ -1,50 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2008-2009 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef createReactingCloudTypes_H
-#define createReactingCloudTypes_H
-
-#include "thermoPhysicsTypes.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#define createReactingCloudType(CloudType)                                    \
-                                                                              \
-    createReactingCloudThermoType(CloudType, constGasThermoPhysics);          \
-    createReactingCloudThermoType(CloudType, gasThermoPhysics);               \
-    createReactingCloudThermoType(CloudType, icoPoly8ThermoPhysics);
-
-
-#define createReactingCloudThermoType(CloudType, ThermoType)                  \
-                                                                              \
-    defineTemplateTypeNameAndDebug(CloudType<ThermoType>, 0);
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcel.H

@@ -520,10 +520,10 @@ public:
         // I-O
 
             //- Read
-            static void readFields(KinematicCloud<ParcelType>& c);
+            static void readFields(Cloud<ParcelType>& c);
 
             //- Write
-            static void writeFields(const KinematicCloud<ParcelType>& c);
+            static void writeFields(const Cloud<ParcelType>& c);
 
 
     // Ostream Operator

src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcelIO.C

@@ -103,10 +103,7 @@ Foam::KinematicParcel<ParcelType>::KinematicParcel
 
 
 template<class ParcelType>
-void Foam::KinematicParcel<ParcelType>::readFields
+void Foam::KinematicParcel<ParcelType>::readFields(Cloud<ParcelType>& c)
-(
-    KinematicCloud<ParcelType>& c
-)
 {
     if (!c.size())
     {
@@ -153,10 +150,7 @@ void Foam::KinematicParcel<ParcelType>::readFields
 
 
 template<class ParcelType>
-void Foam::KinematicParcel<ParcelType>::writeFields
+void Foam::KinematicParcel<ParcelType>::writeFields(const Cloud<ParcelType>& c)
-(
-    const KinematicCloud<ParcelType>& c
-)
 {
     Particle<ParcelType>::writeFields(c);
 

src/lagrangian/intermediate/parcels/Templates/ReactingMultiphaseParcel/ReactingMultiphaseParcel.H

@@ -399,13 +399,10 @@ public:
         // I-O
 
             //- Read
-            static void readFields(ReactingMultiphaseCloud<ParcelType>& c);
+            static void readFields(Cloud<ParcelType>& c);
 
             //- Write
-            static void writeFields
+            static void writeFields(const Cloud<ParcelType>& c);
-            (
-                const ReactingMultiphaseCloud<ParcelType>& c
-            );
 
 
     // Ostream Operator

src/lagrangian/intermediate/parcels/Templates/ReactingMultiphaseParcel/ReactingMultiphaseParcelIO.C

@@ -94,14 +94,17 @@ Foam::ReactingMultiphaseParcel<ParcelType>::ReactingMultiphaseParcel
 template<class ParcelType>
 void Foam::ReactingMultiphaseParcel<ParcelType>::readFields
 (
-    ReactingMultiphaseCloud<ParcelType>& c
+    Cloud<ParcelType>& cIn
 )
 {
-    if (!c.size())
+    if (!cIn.size())
     {
         return;
     }
 
+    ReactingMultiphaseCloud<ParcelType>& c =
+        dynamic_cast<ReactingMultiphaseCloud<ParcelType>&>(cIn);
+
     ReactingParcel<ParcelType>::readFields(c);
 
     // Get names and sizes for each Y...
@@ -185,9 +188,12 @@ void Foam::ReactingMultiphaseParcel<ParcelType>::readFields
 template<class ParcelType>
 void Foam::ReactingMultiphaseParcel<ParcelType>::writeFields
 (
-    const ReactingMultiphaseCloud<ParcelType>& c
+    const Cloud<ParcelType>& cIn
 )
 {
+    const ReactingMultiphaseCloud<ParcelType>& c =
+        dynamic_cast<const ReactingMultiphaseCloud<ParcelType>&>(cIn);
+
     ReactingParcel<ParcelType>::writeFields(c);
 
     label np =  c.size();

src/lagrangian/intermediate/parcels/Templates/ReactingParcel/ReactingParcel.H

@@ -348,10 +348,10 @@ public:
         // I-O
 
             //- Read
-            static void readFields(ReactingCloud<ParcelType>& c);
+            static void readFields(Cloud<ParcelType>& c);
 
             //- Write
-            static void writeFields(const ReactingCloud<ParcelType>& c);
+            static void writeFields(const Cloud<ParcelType>& c);
 
 
     // Ostream Operator

src/lagrangian/intermediate/parcels/Templates/ReactingParcel/ReactingParcelIO.C

@@ -88,16 +88,16 @@ Foam::ReactingParcel<ParcelType>::ReactingParcel
 
 
 template<class ParcelType>
-void Foam::ReactingParcel<ParcelType>::readFields
+void Foam::ReactingParcel<ParcelType>::readFields(Cloud<ParcelType>& cIn)
-(
-    ReactingCloud<ParcelType>& c
-)
 {
-    if (!c.size())
+    if (!cIn.size())
     {
         return;
     }
 
+    ReactingCloud<ParcelType>& c =
+        dynamic_cast<ReactingCloud<ParcelType>&>(cIn);
+
     ThermoParcel<ParcelType>::readFields(c);
 
     IOField<scalar> mass0(c.fieldIOobject("mass0", IOobject::MUST_READ));
@@ -152,9 +152,12 @@ void Foam::ReactingParcel<ParcelType>::readFields
 template<class ParcelType>
 void Foam::ReactingParcel<ParcelType>::writeFields
 (
-    const ReactingCloud<ParcelType>& c
+    const Cloud<ParcelType>& cIn
 )
 {
+    const ReactingCloud<ParcelType>& c =
+        dynamic_cast<const ReactingCloud<ParcelType>&>(cIn);
+
     ThermoParcel<ParcelType>::writeFields(c);
 
     const label np = c.size();

src/lagrangian/intermediate/parcels/Templates/ThermoParcel/ThermoParcel.H

@@ -359,10 +359,10 @@ public:
         // I-O
 
             //- Read
-            static void readFields(ThermoCloud<ParcelType>& c);
+            static void readFields(Cloud<ParcelType>& c);
 
             //- Write
-            static void writeFields(const ThermoCloud<ParcelType>& c);
+            static void writeFields(const Cloud<ParcelType>& c);
 
 
     // Ostream Operator

src/lagrangian/intermediate/parcels/Templates/ThermoParcel/ThermoParcelIO.C

@@ -79,10 +79,7 @@ Foam::ThermoParcel<ParcelType>::ThermoParcel
 
 
 template<class ParcelType>
-void Foam::ThermoParcel<ParcelType>::readFields
+void Foam::ThermoParcel<ParcelType>::readFields(Cloud<ParcelType>& c)
-(
-    ThermoCloud<ParcelType>& c
-)
 {
     if (!c.size())
     {
@@ -111,10 +108,7 @@ void Foam::ThermoParcel<ParcelType>::readFields
 
 
 template<class ParcelType>
-void Foam::ThermoParcel<ParcelType>::writeFields
+void Foam::ThermoParcel<ParcelType>::writeFields(const Cloud<ParcelType>& c)
-(
-    const ThermoCloud<ParcelType>& c
-)
 {
     KinematicParcel<ParcelType>::writeFields(c);
 

src/lagrangian/molecularDynamics/molecule/mdTools/temperatureAndPressure.H

@@ -57,7 +57,7 @@ if (runTime.outputTime())
 
         averageTemperature =
         (
-            2.0/(moleculeCloud::kb * accumulatedDOFs)
+            2.0/(physicoChemical::k.value()*accumulatedDOFs)
             *
             (
                 accumulatedTotalLinearKE + accumulatedTotalAngularKE
@@ -70,10 +70,8 @@ if (runTime.outputTime())
         (
             (
                 (accumulatedNMols/nAveragingSteps)
-                *
+               *physicoChemical::k.value()*averageTemperature
-                moleculeCloud::kb * averageTemperature
+              + accumulatedTotalrDotfSum/(6.0*nAveragingSteps)
-                +
-                accumulatedTotalrDotfSum/(6.0 * nAveragingSteps)
             )
             /
             meshVolume

src/lagrangian/molecularDynamics/molecule/molecule/molecule.H

@@ -382,9 +382,12 @@ public:
             int&
         );
 
-        static void readFields(moleculeCloud& mC);
 
-        static void writeFields(const moleculeCloud& mC);
+    // I-O
+
+        static void readFields(Cloud<molecule>& mC);
+
+        static void writeFields(const Cloud<molecule>& mC);
 
 
     // IOstream Operators

src/lagrangian/molecularDynamics/molecule/molecule/moleculeIO.C

@@ -98,7 +98,7 @@ Foam::molecule::molecule
 }
 
 
-void Foam::molecule::readFields(moleculeCloud& mC)
+void Foam::molecule::readFields(Cloud<molecule>& mC)
 {
     if (!mC.size())
     {
@@ -150,7 +150,7 @@ void Foam::molecule::readFields(moleculeCloud& mC)
 }
 
 
-void Foam::molecule::writeFields(const moleculeCloud& mC)
+void Foam::molecule::writeFields(const Cloud<molecule>& mC)
 {
     Particle<molecule>::writeFields(mC);
 
@@ -241,9 +241,10 @@ void Foam::molecule::writeFields(const moleculeCloud& mC)
     orientation2.write();
     orientation3.write();
 
-    mC.writeXYZ
+    const moleculeCloud& m = dynamic_cast<const moleculeCloud&>(mC);
+    m.writeXYZ
     (
-        mC.mesh().time().timePath() + "/lagrangian" + "/moleculeCloud.xmol"
+        m.mesh().time().timePath() + "/lagrangian" + "/moleculeCloud.xmol"
     );
 }
 

src/lagrangian/molecularDynamics/molecule/moleculeCloud/moleculeCloud.C

@@ -28,6 +28,8 @@ License
 #include "fvMesh.H"
 #include "mathConstants.H"
 
+using namespace Foam::constant;
+
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
@@ -36,13 +38,6 @@ namespace Foam
     defineTemplateTypeNameAndDebug(Cloud<molecule>, 0);
 };
 
-Foam::scalar Foam::moleculeCloud::kb = 1.380650277e-23;
-
-Foam::scalar Foam::moleculeCloud::elementaryCharge = 1.602176487e-19;
-
-Foam::scalar Foam::moleculeCloud::vacuumPermittivity = 8.854187817e-12;
-
-
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 void Foam::moleculeCloud::buildConstProps()
@@ -103,9 +98,7 @@ void Foam::moleculeCloud::buildConstProps()
 
 void Foam::moleculeCloud::setSiteSizesAndPositions()
 {
-    iterator mol(this->begin());
+    forAllIter(moleculeCloud, *this, mol)
-
-    for (mol = this->begin(); mol != this->end(); ++mol)
     {
         const molecule::constantProperties& cP = constProps(mol().id());
 
@@ -123,14 +116,7 @@ void Foam::moleculeCloud::buildCellOccupancy()
         cellOccupancy_[cO].clear();
     }
 
-    iterator mol(this->begin());
+    forAllIter(moleculeCloud, *this, mol)
-
-    for
-    (
-        mol = this->begin();
-        mol != this->end();
-        ++mol
-    )
     {
         cellOccupancy_[mol().cell()].append(&mol());
     }
@@ -225,9 +211,7 @@ void Foam::moleculeCloud::calculateTetherForce()
 {
     const tetherPotentialList& tetherPot(pot_.tetherPotentials());
 
-    iterator mol(this->begin());
+    forAllIter(moleculeCloud, *this, mol)
-
-    for (mol = this->begin(); mol != this->end(); ++mol)
     {
         if (mol().tethered())
         {
@@ -252,9 +236,7 @@ void Foam::moleculeCloud::calculateTetherForce()
 
 void Foam::moleculeCloud::calculateExternalForce()
 {
-    iterator mol(this->begin());
+    forAllIter(moleculeCloud, *this, mol)
-
-    for (mol = this->begin(); mol != this->end(); ++mol)
     {
         mol().a() += pot_.gravity();
     }
@@ -624,11 +606,11 @@ void Foam::moleculeCloud::initialiseMolecules
                     zoneDict.lookup("orientationAngles")
                 );
 
-                scalar phi(orientationAngles.x()*constant::math::pi/180.0);
+                scalar phi(orientationAngles.x()*math::pi/180.0);
 
-                scalar theta(orientationAngles.y()*constant::math::pi/180.0);
+                scalar theta(orientationAngles.y()*math::pi/180.0);
 
-                scalar psi(orientationAngles.z()*constant::math::pi/180.0);
+                scalar psi(orientationAngles.z()*math::pi/180.0);
 
                 const tensor R
                 (
@@ -994,11 +976,11 @@ void Foam::moleculeCloud::createMolecule
     {
         pi = equipartitionAngularMomentum(temperature, cP);
 
-        scalar phi(rndGen_.scalar01()*constant::math::twoPi);
+        scalar phi(rndGen_.scalar01()*math::twoPi);
 
-        scalar theta(rndGen_.scalar01()*constant::math::twoPi);
+        scalar theta(rndGen_.scalar01()*math::twoPi);
 
-        scalar psi(rndGen_.scalar01()*constant::math::twoPi);
+        scalar psi(rndGen_.scalar01()*math::twoPi);
 
         Q = tensor
         (
@@ -1039,9 +1021,7 @@ Foam::label Foam::moleculeCloud::nSites() const
 {
     label n = 0;
 
-    const_iterator mol(this->begin());
+    forAllConstIter(moleculeCloud, *this, mol)
-
-    for (mol = this->begin(); mol != this->end(); ++mol)
     {
         n += constProps(mol().id()).nSites();
     }
@@ -1055,7 +1035,8 @@ Foam::label Foam::moleculeCloud::nSites() const
 Foam::moleculeCloud::moleculeCloud
 (
     const polyMesh& mesh,
-    const potential& pot
+    const potential& pot,
+    bool readFields
 )
 :
     Cloud<molecule>(mesh, "moleculeCloud", false),
@@ -1066,7 +1047,10 @@ Foam::moleculeCloud::moleculeCloud
     constPropList_(),
     rndGen_(clock::getTime())
 {
+    if (readFields)
+    {
         molecule::readFields(*this);
+    }
 
     buildConstProps();
 
@@ -1082,9 +1066,10 @@ Foam::moleculeCloud::moleculeCloud
 (
     const polyMesh& mesh,
     const potential& pot,
-    const IOdictionary& mdInitialiseDict
+    const IOdictionary& mdInitialiseDict,
+    bool readFields
 )
-    :
+:
     Cloud<molecule>(mesh, "moleculeCloud", false),
     mesh_(mesh),
     pot_(pot),
@@ -1092,7 +1077,10 @@ Foam::moleculeCloud::moleculeCloud
     constPropList_(),
     rndGen_(clock::getTime())
 {
+    if (readFields)
+    {
         molecule::readFields(*this);
+    }
 
     clear();
 
@@ -1126,10 +1114,8 @@ void Foam::moleculeCloud::calculateForce()
 {
     buildCellOccupancy();
 
-    iterator mol(this->begin());
-
     // Set accumulated quantities to zero
-    for (mol = this->begin(); mol != this->end(); ++mol)
+    forAllIter(moleculeCloud, *this, mol)
     {
         mol().siteForces() = vector::zero;
 
@@ -1166,9 +1152,7 @@ void Foam::moleculeCloud::applyConstraintsAndThermostats
         << "----------------------------------------"
         << endl;
 
-    iterator mol(this->begin());
+    forAllIter(moleculeCloud, *this, mol)
-
-    for (mol = this->begin(); mol != this->end(); ++mol)
     {
         mol().v() *= temperatureCorrectionFactor;
 
@@ -1177,21 +1161,13 @@ void Foam::moleculeCloud::applyConstraintsAndThermostats
 }
 
 
-void Foam::moleculeCloud::writeFields() const
-{
-    molecule::writeFields(*this);
-}
-
-
 void Foam::moleculeCloud::writeXYZ(const fileName& fName) const
 {
     OFstream str(fName);
 
     str << nSites() << nl << "moleculeCloud site positions in angstroms" << nl;
 
-    const_iterator mol(this->begin());
+    forAllConstIter(moleculeCloud, *this, mol)
-
-    for (mol = this->begin(); mol != this->end(); ++mol)
     {
         const molecule::constantProperties& cP = constProps(mol().id());
 

src/lagrangian/molecularDynamics/molecule/moleculeCloud/moleculeCloud.H

@@ -156,22 +156,14 @@ private:
 
 public:
 
-    // Static data members
-
-        static scalar kb;
-
-        static scalar elementaryCharge;
-
-        static scalar vacuumPermittivity;
-
-
     // Constructors
 
         //- Construct given mesh and potential references
         moleculeCloud
         (
             const polyMesh& mesh,
-            const potential& pot
+            const potential& pot,
+            bool readFields = true
         );
 
         //- Construct given mesh, potential and mdInitialiseDict
@@ -179,7 +171,8 @@ public:
         (
             const polyMesh& mesh,
             const potential& pot,
-            const IOdictionary& mdInitialiseDict
+            const IOdictionary& mdInitialiseDict,
+            bool readFields = true
         );
 
 
@@ -217,9 +210,6 @@ public:
 
     // Member Operators
 
-        //- Write fields
-        void writeFields() const;
-
         //- Write molecule sites in XYZ format
         void writeXYZ(const fileName& fName) const;
 };

src/lagrangian/molecularDynamics/molecule/moleculeCloud/moleculeCloudI.H

@@ -24,6 +24,10 @@ License
 
 \*---------------------------------------------------------------------------*/
 
+#include "constants.H"
+
+using namespace Foam::constant;
+
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 inline void Foam::moleculeCloud::evaluatePair
@@ -576,7 +580,7 @@ inline Foam::vector Foam::moleculeCloud::equipartitionLinearVelocity
     scalar mass
 )
 {
-    return sqrt(kb*temperature/mass)*vector
+    return sqrt(physicoChemical::k.value()*temperature/mass)*vector
     (
         rndGen_.GaussNormal(),
         rndGen_.GaussNormal(),
@@ -591,7 +595,7 @@ inline Foam::vector Foam::moleculeCloud::equipartitionAngularMomentum
     const molecule::constantProperties& cP
 )
 {
-    scalar sqrtKbT = sqrt(kb*temperature);
+    scalar sqrtKbT = sqrt(physicoChemical::k.value()*temperature);
 
     if (cP.linearMolecule())
     {

src/lagrangian/solidParticle/solidParticleCloud.C

@@ -42,7 +42,8 @@ namespace Foam
 Foam::solidParticleCloud::solidParticleCloud
 (
     const fvMesh& mesh,
-    const word& cloudName
+    const word& cloudName,
+    bool readFields
 )
 :
     Cloud<solidParticle>(mesh, cloudName, false),
@@ -62,7 +63,10 @@ Foam::solidParticleCloud::solidParticleCloud
     e_(dimensionedScalar(particleProperties_.lookup("e")).value()),
     mu_(dimensionedScalar(particleProperties_.lookup("mu")).value())
 {
+    if (readFields)
+    {
         solidParticle::readFields(*this);
+    }
 }
 
 
@@ -84,10 +88,4 @@ void Foam::solidParticleCloud::move(const dimensionedVector& g)
 }
 
 
-void Foam::solidParticleCloud::writeFields() const
-{
-    solidParticle::writeFields(*this);
-}
-
-
 // ************************************************************************* //

src/lagrangian/solidParticle/solidParticleCloud.H

@@ -86,7 +86,8 @@ public:
         solidParticleCloud
         (
             const fvMesh&,
-            const word& cloudName = "defaultCloud"
+            const word& cloudName = "defaultCloud",
+            bool readFields = true
         );
 
 
@@ -106,12 +107,6 @@ public:
             //- Move the particles under the influence of the given
             //  gravitational acceleration
             void move(const dimensionedVector& g);
-
-
-        // Write
-
-            //- Write fields
-            virtual void writeFields() const;
 };
 
 

src/postProcessing/functionObjects/field/streamLine/streamLineParticle.C

@@ -387,10 +387,7 @@ void Foam::streamLineParticle::hitPatch
 {}
 
 
-void Foam::streamLineParticle::readFields
+void Foam::streamLineParticle::readFields(Cloud<streamLineParticle>& c)
-(
-    Cloud<streamLineParticle>& c
-)
 {
     if (!c.size())
     {
@@ -426,10 +423,7 @@ void Foam::streamLineParticle::readFields
 }
 
 
-void Foam::streamLineParticle::writeFields
+void Foam::streamLineParticle::writeFields(const Cloud<streamLineParticle>& c)
-(
-    const Cloud<streamLineParticle>& c
-)
 {
     Particle<streamLineParticle>::writeFields(c);
 

src/postProcessing/functionObjects/field/streamLine/streamLineParticleCloud.C

@@ -26,15 +26,11 @@ License
 
 #include "streamLineParticleCloud.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-
+    defineTemplateTypeNameAndDebug(Cloud<streamLineParticle>, 0);
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-defineTemplateTypeNameAndDebug(Cloud<streamLineParticle>, 0);
-
 };
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
@@ -42,12 +38,16 @@ defineTemplateTypeNameAndDebug(Cloud<streamLineParticle>, 0);
 Foam::streamLineParticleCloud::streamLineParticleCloud
 (
     const polyMesh& mesh,
-    const word& cloudName
+    const word& cloudName,
+    bool readFields
 )
 :
     Cloud<streamLineParticle>(mesh, cloudName, false)
 {
-    readFields();
+    if (readFields)
+    {
+        streamLineParticle::readFields(*this);
+    }
 }
 
 
@@ -62,18 +62,4 @@ Foam::streamLineParticleCloud::streamLineParticleCloud
 {}
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-void Foam::streamLineParticleCloud::readFields()
-{
-    streamLineParticle::readFields(*this);
-}
-
-
-void Foam::streamLineParticleCloud::writeFields() const
-{
-    streamLineParticle::writeFields(*this);
-}
-
-
 // ************************************************************************* //

src/postProcessing/functionObjects/field/streamLine/streamLineParticleCloud.H

@@ -72,7 +72,8 @@ public:
         streamLineParticleCloud
         (
             const polyMesh&,
-            const word& cloudName = "defaultCloud"
+            const word& cloudName = "defaultCloud",
+            bool readFields = true
         );
 
         //- Construct from mesh, cloud name, and a list of particles
@@ -82,15 +83,6 @@ public:
             const word& cloudName,
             const IDLList<streamLineParticle>& particles
         );
-
-
-    // Member Functions
-
-        //- Read fields
-        virtual void readFields();
-
-        //- Write fields
-        virtual void writeFields() const;
 };
 
 

src/postProcessing/functionObjects/utilities/dsmcFields/dsmcFields.C

@@ -29,6 +29,10 @@ License
 #include "dictionary.H"
 #include "dsmcCloud.H"
 
+#include "constants.H"
+
+using namespace Foam::constant;
+
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
@@ -164,7 +168,7 @@ void Foam::dsmcFields::write()
                     obr_,
                     IOobject::NO_READ
                 ),
-                2.0/(3.0*dsmcCloud::kb*rhoNMean)
+                2.0/(3.0*physicoChemical::k.value()*rhoNMean)
                 *(linearKEMean - 0.5*rhoMMean*(UMean & UMean))
             );
 
@@ -178,7 +182,7 @@ void Foam::dsmcFields::write()
                     obr_,
                     IOobject::NO_READ
                 ),
-                2.0/(dsmcCloud::kb*iDofMean)*internalEMean
+                2.0/(physicoChemical::k.value()*iDofMean)*internalEMean
             );
 
             Info<< "    Calculating overallT field." << endl;
@@ -191,7 +195,7 @@ void Foam::dsmcFields::write()
                     obr_,
                     IOobject::NO_READ
                 ),
-                2.0/(dsmcCloud::kb*(3.0*rhoNMean + iDofMean))
+                2.0/(physicoChemical::k.value()*(3.0*rhoNMean + iDofMean))
                 *(linearKEMean - 0.5*rhoMMean*(UMean & UMean) + internalEMean)
             );