ENH: Further updates to new spray library

src/lagrangian/spray/clouds/Templates/SprayCloud/SprayCloud.C

@@ -26,7 +26,7 @@ License
 #include "SprayCloud.H"
 #include "AtomizationModel.H"
 #include "BreakupModel.H"
-#include "CollisionModel.H"
+#include "StochasticCollisionModel.H"
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
@@ -51,9 +51,9 @@ void Foam::SprayCloud<CloudType>::setModels()
         ).ptr()
     );
 
-    collisionModel_.reset
+    stochasticCollisionModel_.reset
     (
-        CollisionModel<SprayCloud<CloudType> >::New
+        StochasticCollisionModel<SprayCloud<CloudType> >::New
         (
             this->subModelProperties(),
             *this
@@ -72,7 +72,7 @@ void Foam::SprayCloud<CloudType>::cloudReset
 
     atomizationModel_.reset(c.atomizationModel_.ptr());
     breakupModel_.reset(c.breakupModel_.ptr());
-    collisionModel_.reset(c.collisionModel_.ptr());
+    stochasticCollisionModel_.reset(c.stochasticCollisionModel_.ptr());
 }
 
 
@@ -92,47 +92,23 @@ Foam::SprayCloud<CloudType>::SprayCloud
     CloudType(cloudName, rho, U, g, thermo, false),
     sprayCloud(),
     cloudCopyPtr_(NULL),
-    averageParcelMass_(this->injection().averageParcelMass()),
+    averageParcelMass_(0.0),
-    atomizationModel_
+    atomizationModel_(NULL),
-    (
+    breakupModel_(NULL),
-        AtomizationModel<SprayCloud<CloudType> >::New
+    stochasticCollisionModel_(NULL)
-        (
-            this->particleProperties(),
-            *this
-        )
-    ),
-    breakupModel_
-    (
-        BreakupModel<SprayCloud<CloudType> >::New
-        (
-            this->particleProperties(),
-            *this
-        )
-    ),
-    collisionModel_
-    (
-        CollisionModel<SprayCloud<CloudType> >::New
-        (
-            this->particleProperties(),
-            *this
-        )
-    )
 {
     if (this->solution().active())
     {
         setModels();
 
+        averageParcelMass_ = this->injection().averageParcelMass();
+
         if (readFields)
         {
             parcelType::readFields(*this, this->composition());
         }
     }
 
-    if (this->solution().resetSourcesOnStartup())
-    {
-        resetSourceTerms();
-    }
-
     Info << "    Average parcel mass: " << averageParcelMass_ << endl;
 }
 
@@ -150,7 +126,7 @@ Foam::SprayCloud<CloudType>::SprayCloud
     averageParcelMass_(c.averageParcelMass_),
     atomizationModel_(c.atomizationModel_->clone()),
     breakupModel_(c.breakupModel_->clone()),
-    collisionModel_(c.collisionModel_->clone())
+    stochasticCollisionModel_(c.stochasticCollisionModel_->clone())
 {}
 
 
@@ -168,7 +144,7 @@ Foam::SprayCloud<CloudType>::SprayCloud
     averageParcelMass_(0.0),
     atomizationModel_(NULL),
     breakupModel_(NULL),
-    collisionModel_(NULL)
+    stochasticCollisionModel_(NULL)
 {}
 
 
@@ -257,9 +233,10 @@ void Foam::SprayCloud<CloudType>::motion(TrackData& td)
 
     this->updateCellOccupancy();
 
-
+    if (stochasticCollision().active())
-    if (collision().active())
     {
+        const liquidMixtureProperties& liqMix = this->composition().liquids();
+
         label i = 0;
         forAllIter(typename SprayCloud<CloudType>, *this, iter)
         {
@@ -270,17 +247,17 @@ void Foam::SprayCloud<CloudType>::motion(TrackData& td)
                 {
                     parcelType& p = iter();
                     scalar Vi = this->mesh().V()[p.cell()];
-                    scalarField X1(this->composition().liquids().X(p.Y()));
+                    scalarField X1(liqMix.X(p.Y()));
-                    scalar sigma1 = this->composition().liquids().sigma(p.pc(), p.T(), X1);
+                    scalar sigma1 = liqMix.sigma(p.pc(), p.T(), X1);
                     scalar mp = p.mass()*p.nParticle();
 
                     parcelType& q = jter();
                     scalar Vj = this->mesh().V()[q.cell()];
-                    scalarField X2(this->composition().liquids().X(q.Y()));
+                    scalarField X2(liqMix.X(q.Y()));
-                    scalar sigma2 = this->composition().liquids().sigma(q.pc(), q.T(), X2);
+                    scalar sigma2 = liqMix.sigma(q.pc(), q.T(), X2);
                     scalar mq = q.mass()*q.nParticle();
 
-                    bool updateProperties = collision().update
+                    bool updateProperties = stochasticCollision().update
                     (
                         dt,
                         this->rndGen(),
@@ -314,18 +291,26 @@ void Foam::SprayCloud<CloudType>::motion(TrackData& td)
                     {
                         if (mp > VSMALL)
                         {
-                            scalarField Xp(this->composition().liquids().X(p.Y()));
+                            scalarField Xp(liqMix.X(p.Y()));
-                            p.rho() = this->composition().liquids().rho(p.pc(), p.T(), Xp);
+                            p.rho() = liqMix.rho(p.pc(), p.T(), Xp);
-                            p.Cp() = this->composition().liquids().Cp(p.pc(), p.T(), Xp);
+                            p.Cp() = liqMix.Cp(p.pc(), p.T(), Xp);
-                            scalar rhs = 6.0*mp/(p.nParticle()*p.rho()*constant::mathematical::pi);
+                            p.d() =
-                            p.d() = pow(rhs, 1.0/3.0);
+                                cbrt
+                                (
+                                    6.0*mp
+                                   /(
+                                        p.nParticle()
+                                       *p.rho()
+                                       *constant::mathematical::pi
+                                    )
+                                );
                         }
 
                         if (mq > VSMALL)
                         {
-                            scalarField Xq(this->composition().liquids().X(q.Y()));
+                            scalarField Xq(liqMix.X(q.Y()));
-                            q.rho() = this->composition().liquids().rho(q.pc(), q.T(), Xq);
+                            q.rho() = liqMix.rho(q.pc(), q.T(), Xq);
-                            q.Cp() = this->composition().liquids().Cp(q.pc(), q.T(), Xq);
+                            q.Cp() = liqMix.Cp(q.pc(), q.T(), Xq);
                             scalar rhs = 6.0*mq/(q.nParticle()*q.rho()*constant::mathematical::pi);
                             q.d() = pow(rhs, 1.0/3.0);
                         }

src/lagrangian/spray/clouds/Templates/SprayCloud/SprayCloud.H

@@ -47,7 +47,7 @@ template<class CloudType>
 class BreakupModel;
 
 template<class CloudType>
-class CollisionModel;
+class StochasticCollisionModel;
 
 /*---------------------------------------------------------------------------*\
                       Class SprayCloud Declaration
@@ -107,7 +107,8 @@ protected:
             autoPtr<BreakupModel<SprayCloud<CloudType> > > breakupModel_;
 
             //- Collision model
-            autoPtr<CollisionModel<SprayCloud<CloudType> > > collisionModel_;
+            autoPtr<StochasticCollisionModel<SprayCloud<CloudType> > >
+                stochasticCollisionModel_;
 
 
     // Protected Member Functions
@@ -196,8 +197,8 @@ public:
                     breakup() const;
 
                 //- Return const-access to the breakup model
-                inline const CollisionModel<SprayCloud<CloudType> >&
+                inline const StochasticCollisionModel<SprayCloud<CloudType> >&
-                    collision() const;
+                    stochasticCollision() const;
 
 
         // Check
@@ -228,9 +229,6 @@ public:
             //- Reset the current cloud to the previously stored state
             void restoreState();
 
-            //- Reset the spray source terms
-            void resetSourceTerms();
-
             //- Evolve the spray (inject, move)
             void evolve();
             //- Particle motion

src/lagrangian/spray/clouds/Templates/SprayCloud/SprayCloudI.H

@@ -50,10 +50,10 @@ Foam::SprayCloud<CloudType>::breakup() const
 
 
 template<class CloudType>
-inline const Foam::CollisionModel<Foam::SprayCloud<CloudType> >&
+inline const Foam::StochasticCollisionModel<Foam::SprayCloud<CloudType> >&
-Foam::SprayCloud<CloudType>::collision() const
+Foam::SprayCloud<CloudType>::stochasticCollision() const
 {
-    return collisionModel_;
+    return stochasticCollisionModel_;
 }
 
 

src/lagrangian/spray/parcels/Templates/SprayParcel/SprayParcel.C

@@ -210,6 +210,13 @@ void Foam::SprayParcel<ParcelType>::calcBreakup
     const CompositionModel<reactingCloudType>& composition =
         td.cloud().composition();
 
+    typedef typename TrackData::cloudType cloudType;
+    typedef typename cloudType::parcelType parcelType;
+    typedef typename cloudType::forceType forceType;
+
+    const parcelType& p = static_cast<const parcelType&>(*this);
+    const forceType& forces = td.cloud().forces();
+
     if (td.cloud().breakup().solveOscillationEq())
     {
         solveTABEq(td, dt);
@@ -233,11 +240,12 @@ void Foam::SprayParcel<ParcelType>::calcBreakup
     scalar muAv = this->muc();
     vector Urel = this->U() - this->Uc();
     scalar Urmag = mag(Urel);
-    scalar As = this->areaS(this->d());
+    scalar Re = this->Re(this->U(), this->d(), rhoAv, muAv);
-    scalar Re = rhoAv*Urmag*this->d()/muAv;
 
-    scalar utc = td.cloud().drag().utc(Re, this->d(), muAv) + ROOTVSMALL;
+    const scalar mass = p.mass();
-    scalar tMom = 1.0/(As*utc);
+    const forceSuSp Fcp = forces.calcCoupled(p, dt, mass, Re, muAv);
+    const forceSuSp Fncp = forces.calcNonCoupled(p, dt, mass, Re, muAv);
+    scalar tMom = 1.0/(Fcp.Sp() + Fncp.Sp());
 
     const vector g = td.cloud().g().value();
 
@@ -273,17 +281,20 @@ void Foam::SprayParcel<ParcelType>::calcBreakup
         )
     )
     {
-        scalar As = this->areaS(dChild);
         scalar Re = rhoAv*Urmag*dChild/muAv;
-        scalar utc = td.cloud().drag().utc(Re, dChild, muAv) + ROOTVSMALL;
         this->mass0() -= massChild;
 
         // Add child parcel as copy of parent
         SprayParcel<ParcelType>* child = new SprayParcel<ParcelType>(*this);
-        scalar massDrop = rho*constant::mathematical::pi*pow(dChild, 3.0)/6.0;
         child->mass0() = massChild;
         child->d() = dChild;
-        child->nParticle() = massChild/massDrop;
+        child->nParticle() = massChild/rho*this->volume(dChild);
+
+        const forceSuSp Fcp =
+            forces.calcCoupled(*child, dt, massChild, Re, muAv);
+        const forceSuSp Fncp =
+            forces.calcNonCoupled(*child, dt, massChild, Re, muAv);
+
         child->liquidCore() = 0.0;
         child->KHindex() = 1.0;
         child->y() = td.cloud().breakup().y0();
@@ -291,7 +302,7 @@ void Foam::SprayParcel<ParcelType>::calcBreakup
         child->tc() = -GREAT;
         child->ms() = 0.0;
         child->injector() = this->injector();
-        child->tMom() = 1.0/(As*utc);
+        child->tMom() = 1.0/(Fcp.Sp() + Fncp.Sp());
         child->user() = 0.0;
         child->setCellValues(td, dt, cellI);
 
@@ -322,7 +333,7 @@ Foam::scalar Foam::SprayParcel<ParcelType>::chi
     scalar p0 = this->pc();
     scalar pAmb = td.cloud().pAmbient();
 
-    scalar pv = composition.liquids().sigma(p0, T0, X);
+    scalar pv = composition.liquids().pv(p0, T0, X);
 
     forAll(composition.liquids(), i)
     {
@@ -377,16 +388,16 @@ void Foam::SprayParcel<ParcelType>::solveTABEq
     const scalar& TABWeCrit = td.cloud().breakup().TABWeCrit();
     const scalar& TABComega = td.cloud().breakup().TABComega();
 
-    scalar r = 0.5*this->d_;
+    scalar r = 0.5*this->d();
     scalar r2 = r*r;
     scalar r3 = r*r2;
 
     const scalarField& Y(this->Y());
     scalarField X(composition.liquids().X(Y));
 
-    scalar rho = composition.liquids().rho(this->pc_, this->T(), X);
+    scalar rho = composition.liquids().rho(this->pc(), this->T(), X);
-    scalar mu = composition.liquids().mu(this->pc_, this->T(), X);
+    scalar mu = composition.liquids().mu(this->pc(), this->T(), X);
-    scalar sigma = composition.liquids().sigma(this->pc_, this->T(), X);
+    scalar sigma = composition.liquids().sigma(this->pc(), this->T(), X);
 
     // inverse of characteristic viscous damping time
     scalar rtd = 0.5*TABCmu*mu/(rho*r2);
@@ -397,11 +408,8 @@ void Foam::SprayParcel<ParcelType>::solveTABEq
     if(omega2 > 0)
     {
         scalar omega = sqrt(omega2);
-        scalar rhoc = this->rhoc_; //spray_.rho()[p.cell()];
+        scalar rhoc = this->rhoc();
-        scalar We = rhoc*pow(mag(this->Uc_ - this->U()), 2.0)*r/sigma;
+        scalar Wetmp = this->We(this->U(), r, rhoc, sigma)/TABWeCrit;
-
-        //scalar We = p.We(Ug, rhog, sigma);
-        scalar Wetmp = We/TABWeCrit;
 
         scalar y1 = this->y() - Wetmp;
         scalar y2 = this->yDot()/omega;
@@ -435,10 +443,7 @@ void Foam::SprayParcel<ParcelType>::solveTABEq
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template <class ParcelType>
-Foam::SprayParcel<ParcelType>::SprayParcel
+Foam::SprayParcel<ParcelType>::SprayParcel(const SprayParcel<ParcelType>& p)
-(
-    const SprayParcel<ParcelType>& p
-)
 :
     ParcelType(p),
     d0_(p.d0_),
@@ -455,6 +460,28 @@ Foam::SprayParcel<ParcelType>::SprayParcel
 {}
 
 
+template <class ParcelType>
+Foam::SprayParcel<ParcelType>::SprayParcel
+(
+    const SprayParcel<ParcelType>& p,
+    const polyMesh& mesh
+)
+:
+    ParcelType(p, mesh),
+    d0_(p.d0_),
+    position0_(p.position0_),
+    liquidCore_(p.liquidCore_),
+    KHindex_(p.KHindex_),
+    y_(p.y_),
+    yDot_(p.yDot_),
+    tc_(p.tc_),
+    ms_(p.ms_),
+    injector_(p.injector_),
+    tMom_(p.tMom_),
+    user_(p.user_)
+{}
+
+
 // * * * * * * * * * * * * * * IOStream operators  * * * * * * * * * * * * * //
 
 #include "SprayParcelIO.C"

src/lagrangian/spray/parcels/derived/basicSprayParcel/makeBasicSprayParcelSubmodels.C

@@ -39,6 +39,7 @@ License
 // Reacting
 #include "makeReactingParcelCompositionModels.H"
 #include "makeReactingParcelPhaseChangeModels.H"
+#include "makeReactingParcelSurfaceFilmModels.H"
 
 // Spray
 #include "makeSprayParcelAtomizationModels.H"
@@ -63,11 +64,12 @@ namespace Foam
     // Reacting sub-models
     makeReactingParcelCompositionModels(basicSprayCloud);
     makeReactingParcelPhaseChangeModels(basicSprayCloud);
+    makeReactingParcelSurfaceFilmModels(basicSprayCloud);
 
     // Spray sub-models
     makeSprayParcelAtomizationModels(basicSprayCloud);
     makeSprayParcelBreakupModels(basicSprayCloud);
-//    makeSprayParcelCollisionModels(basicSprayCloud);
+    makeSprayParcelCollisionModels(basicSprayCloud);
 };
 
 

src/lagrangian/spray/parcels/include/makeSprayParcelCollisionModels.H

@@ -28,7 +28,7 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "NoCollision.H"
+#include "NoStochasticCollision.H"
 #include "ORourkeCollision.H"
 #include "TrajectoryCollision.H"
 
@@ -36,10 +36,10 @@ License
 
 #define makeSprayParcelCollisionModels(CloudType)                             \
                                                                               \
-    makeCollisionModel(CloudType);                                            \
+    makeStochasticCollisionModel(CloudType);                                  \
-    makeCollisionModelType(NoCollision, CloudType);                           \
+    makeStochasticCollisionModelType(NoStochasticCollision, CloudType);       \
-    makeCollisionModelType(ORourkeCollision, CloudType);                      \
+    makeStochasticCollisionModelType(ORourkeCollision, CloudType);            \
-    makeCollisionModelType(TrajectoryCollision, CloudType);
+    makeStochasticCollisionModelType(TrajectoryCollision, CloudType);
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/lagrangian/spray/submodels/AtomizationModel/NoAtomization/NoAtomization.C

@@ -57,6 +57,13 @@ Foam::NoAtomization<CloudType>::~NoAtomization()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+template<class CloudType>
+bool Foam::NoAtomization<CloudType>::active() const
+{
+    return false;
+}
+
+
 template<class CloudType>
 Foam::scalar Foam::NoAtomization<CloudType>::initLiquidCore() const
 {

src/lagrangian/spray/submodels/AtomizationModel/NoAtomization/NoAtomization.H

@@ -77,6 +77,9 @@ public:
 
     // Member Functions
 
+        //- Flag to indicate whether model activates atomization model
+        virtual bool active() const;
+
         //- Initial value of liquidCore
         virtual scalar initLiquidCore() const;
 

src/lagrangian/spray/submodels/BreakupModel/BreakupModel/BreakupModel.C

@@ -77,12 +77,14 @@ Foam::BreakupModel<CloudType>::BreakupModel
 {
     if (solveOscillationEq_)
     {
-        const dictionary TABcoeffsDict(this->coeffDict().subDict("TABCoeffs"));
+        const dictionary TABcoeffsDict(dict.subDict("TABCoeffs"));
-        y0_ = readScalar(TABcoeffsDict.lookup("y0"));
+        y0_ = TABcoeffsDict.template lookupOrDefault<scalar>("y0", 0.0);
-        yDot0_ = readScalar(TABcoeffsDict.lookup("yDot0"));
+        yDot0_ = TABcoeffsDict.template lookupOrDefault<scalar>("yDot0", 0.0);
-        TABComega_ = readScalar(TABcoeffsDict.lookup("Comega"));
+        TABComega_ =
-        TABCmu_ = readScalar(TABcoeffsDict.lookup("Cmu"));
+            TABcoeffsDict.template lookupOrDefault<scalar>("Comega", 8.0);
-        TABWeCrit_ = readScalar(TABcoeffsDict.lookup("WeCrit"));
+        TABCmu_ = TABcoeffsDict.template lookupOrDefault<scalar>("Cmu", 10.0);
+        TABWeCrit_ =
+            TABcoeffsDict.template lookupOrDefault<scalar>("WeCrit", 12.0);
     }
 }
 

src/lagrangian/spray/submodels/BreakupModel/ETAB/ETAB.C

@@ -35,12 +35,22 @@ Foam::ETAB<CloudType>::ETAB
 )
 :
     BreakupModel<CloudType>(dict, owner, typeName),
-    Cmu_(readScalar(this->coeffDict().lookup("Cmu"))),
+    Cmu_(this->coeffDict().template lookupOrDefault<scalar>("Cmu", 10.0)),
-    Comega_(readScalar(this->coeffDict().lookup("Comega"))),
+    Comega_(this->coeffDict().template lookupOrDefault<scalar>("Comega", 8.0)),
-    k1_(readScalar(this->coeffDict().lookup("k1"))),
+    k1_(this->coeffDict().template lookupOrDefault<scalar>("k1", 0.2)),
-    k2_(readScalar(this->coeffDict().lookup("k2"))),
+    k2_(this->coeffDict().template lookupOrDefault<scalar>("k2", 0.2)),
-    WeCrit_(readScalar(this->coeffDict().lookup("WeCrit"))),
+    WeCrit_
-    WeTransition_(readScalar(this->coeffDict().lookup("WeTransition"))),
+(
+    this->coeffDict().template lookupOrDefault<scalar>("WeCrit", 12.0)
+),
+    WeTransition_
+    (
+        this->coeffDict().template lookupOrDefault<scalar>
+        (
+            "WeTransition",
+            100.0
+        )
+    ),
     AWe_(0.0)
 {
     scalar k21 = k2_/k1_;

src/lagrangian/spray/submodels/BreakupModel/NoBreakup/NoBreakup.C

@@ -55,6 +55,13 @@ Foam::NoBreakup<CloudType>::~NoBreakup()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+template<class CloudType>
+bool Foam::NoBreakup<CloudType>::active() const
+{
+    return false;
+}
+
+
 template<class CloudType>
 bool Foam::NoBreakup<CloudType>::update
 (

src/lagrangian/spray/submodels/BreakupModel/NoBreakup/NoBreakup.H

@@ -77,6 +77,9 @@ public:
 
     // Member Functions
 
+        //- Flag to indicate whether model activates break-up model
+        virtual bool active() const;
+
         //- update the parcel properties
         virtual bool update
         (

src/lagrangian/spray/submodels/BreakupModel/ReitzKHRT/ReitzKHRT.C

@@ -35,11 +35,18 @@ Foam::ReitzKHRT<CloudType>::ReitzKHRT
 )
 :
     BreakupModel<CloudType>(dict, owner, typeName),
-    b0_(readScalar(this->coeffDict().lookup("B0"))),
+    b0_(this->coeffDict().template lookupOrDefault<scalar>("B0", 0.61)),
-    b1_(readScalar(this->coeffDict().lookup("B1"))),
+    b1_(this->coeffDict().template lookupOrDefault<scalar>("B1", 40.0)),
-    cTau_(readScalar(this->coeffDict().lookup("Ctau"))),
+    cTau_(this->coeffDict().template lookupOrDefault<scalar>("Ctau", 1.0)),
-    cRT_(readScalar(this->coeffDict().lookup("CRT"))),
+    cRT_(this->coeffDict().template lookupOrDefault<scalar>("CRT", 0.1)),
-    msLimit_(readScalar(this->coeffDict().lookup("msLimit"))),
+    msLimit_
+    (
+        this->coeffDict().template lookupOrDefault<scalar>
+        (
+            "msLimit",
+            0.03
+        )
+    ),
     weberLimit_(readScalar(this->coeffDict().lookup("WeberLimit")))
 {}
 

src/lagrangian/spray/submodels/StochasticCollision/NoStochasticCollision/NoStochasticCollision.C

@@ -23,39 +23,49 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "NoCollision.H"
+#include "NoStochasticCollision.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class CloudType>
-Foam::NoCollision<CloudType>::NoCollision
+Foam::NoStochasticCollision<CloudType>::NoStochasticCollision
 (
     const dictionary& dict,
     CloudType& owner
 )
 :
-    CollisionModel<CloudType>(owner)
+    StochasticCollisionModel<CloudType>(owner)
 {}
 
 
 template<class CloudType>
-Foam::NoCollision<CloudType>::NoCollision(const NoCollision<CloudType>& cm)
+Foam::NoStochasticCollision<CloudType>::NoStochasticCollision
+(
+    const NoStochasticCollision<CloudType>& cm
+)
 :
-    CollisionModel<CloudType>(cm)
+    StochasticCollisionModel<CloudType>(cm)
 {}
 
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 template<class CloudType>
-Foam::NoCollision<CloudType>::~NoCollision()
+Foam::NoStochasticCollision<CloudType>::~NoStochasticCollision()
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class CloudType>
-bool Foam::NoCollision<CloudType>::update
+bool Foam::NoStochasticCollision<CloudType>::active() const
+{
+    return false;
+}
+
+
+template<class CloudType>
+bool Foam::NoStochasticCollision<CloudType>::update
 (
     const scalar dt,
     cachedRandom& rndGen,

src/lagrangian/spray/submodels/StochasticCollision/NoStochasticCollision/NoStochasticCollision.H

@@ -22,30 +22,30 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::NoCollision
+    Foam::NoStochasticCollision
 
 Description
     Dummy collision model for 'none'
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef NoCollision_H
+#ifndef NoStochasticCollision_H
-#define NoCollision_H
+#define NoStochasticCollision_H
 
-#include "CollisionModel.H"
+#include "StochasticCollisionModel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 /*---------------------------------------------------------------------------*\
-                       Class NoCollision Declaration
+                       Class NoStochasticCollision Declaration
 \*---------------------------------------------------------------------------*/
 
 template<class CloudType>
-class NoCollision
+class NoStochasticCollision
 :
-    public CollisionModel<CloudType>
+    public StochasticCollisionModel<CloudType>
 {
 public:
 
@@ -56,27 +56,30 @@ public:
     // Constructors
 
         //- Construct from dictionary
-        NoCollision(const dictionary& dict, CloudType& cloud);
+        NoStochasticCollision(const dictionary& dict, CloudType& owner);
 
         //- Construct copy
-        NoCollision(const NoCollision<CloudType>& cm);
+        NoStochasticCollision(const NoStochasticCollision<CloudType>& cm);
 
         //- Construct and return a clone
-        virtual autoPtr<CollisionModel<CloudType> > clone() const
+        virtual autoPtr<StochasticCollisionModel<CloudType> > clone() const
         {
-            return autoPtr<CollisionModel<CloudType> >
+            return autoPtr<StochasticCollisionModel<CloudType> >
             (
-                new NoCollision<CloudType>(*this)
+                new NoStochasticCollision<CloudType>(*this)
             );
         }
 
 
     //- Destructor
-    virtual ~NoCollision();
+    virtual ~NoStochasticCollision();
 
 
     // Member Functions
 
+        //- Flag to indicate whether model activates collision model
+        virtual bool active() const;
+
         virtual bool update
         (
             const scalar dt,
@@ -114,7 +117,7 @@ public:
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #ifdef NoRepository
-#   include "NoCollision.C"
+#   include "NoStochasticCollision.C"
 #endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/lagrangian/spray/submodels/StochasticCollision/ORourkeCollision/ORourkeCollision.C

@@ -34,7 +34,7 @@ Foam::ORourkeCollision<CloudType>::ORourkeCollision
     CloudType& owner
 )
 :
-    CollisionModel<CloudType>(dict, owner),
+    StochasticCollisionModel<CloudType>(dict, owner, typeName),
     coalescence_(this->coeffDict().lookup("coalescence"))
 {}
 
@@ -45,7 +45,7 @@ Foam::ORourkeCollision<CloudType>::ORourkeCollision
     const ORourkeCollision<CloudType>& cm
 )
 :
-    CollisionModel<CloudType>(cm),
+    StochasticCollisionModel<CloudType>(cm),
     coalescence_(cm.coalescence_)
 {}
 

src/lagrangian/spray/submodels/StochasticCollision/ORourkeCollision/ORourkeCollision.H

@@ -33,7 +33,7 @@ Description
 #ifndef ORourkeCollision_H
 #define ORourkeCollision_H
 
-#include "CollisionModel.H"
+#include "StochasticCollisionModel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -46,7 +46,7 @@ namespace Foam
 template<class CloudType>
 class ORourkeCollision
 :
-    public CollisionModel<CloudType>
+    public StochasticCollisionModel<CloudType>
 {
 private:
 
@@ -68,9 +68,9 @@ public:
         ORourkeCollision(const ORourkeCollision<CloudType>& cm);
 
         //- Construct and return a clone
-        virtual autoPtr<CollisionModel<CloudType> > clone() const
+        virtual autoPtr<StochasticCollisionModel<CloudType> > clone() const
         {
-            return autoPtr<CollisionModel<CloudType> >
+            return autoPtr<StochasticCollisionModel<CloudType> >
             (
                 new ORourkeCollision<CloudType>(*this)
             );

src/lagrangian/spray/submodels/StochasticCollision/StochasticCollisionModel/StochasticCollisionModel.C

@@ -23,12 +23,12 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "CollisionModel.H"
+#include "StochasticCollisionModel.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class CloudType>
-Foam::CollisionModel<CloudType>::CollisionModel
+Foam::StochasticCollisionModel<CloudType>::StochasticCollisionModel
 (
     CloudType& owner
 )
@@ -38,9 +38,9 @@ Foam::CollisionModel<CloudType>::CollisionModel
 
 
 template<class CloudType>
-Foam::CollisionModel<CloudType>::CollisionModel
+Foam::StochasticCollisionModel<CloudType>::StochasticCollisionModel
 (
-    const CollisionModel<CloudType>& cm
+    const StochasticCollisionModel<CloudType>& cm
 )
 :
     SubModelBase<CloudType>(cm)
@@ -48,7 +48,7 @@ Foam::CollisionModel<CloudType>::CollisionModel
 
 
 template<class CloudType>
-Foam::CollisionModel<CloudType>::CollisionModel
+Foam::StochasticCollisionModel<CloudType>::StochasticCollisionModel
 (
     const dictionary& dict,
     CloudType& owner,
@@ -62,14 +62,14 @@ Foam::CollisionModel<CloudType>::CollisionModel
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 template<class CloudType>
-Foam::CollisionModel<CloudType>::~CollisionModel()
+Foam::StochasticCollisionModel<CloudType>::~StochasticCollisionModel()
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class CloudType>
-bool Foam::CollisionModel<CloudType>::update
+bool Foam::StochasticCollisionModel<CloudType>::update
 (
     const scalar dt,
     cachedRandom& rndGen,
@@ -99,7 +99,7 @@ bool Foam::CollisionModel<CloudType>::update
 {
     notImplemented
     (
-        "bool Foam::CollisionModel<CloudType>::update"
+        "bool Foam::StochasticCollisionModel<CloudType>::update"
         "("
             "const scalar, "
             "cachedRandom&, "
@@ -134,7 +134,7 @@ bool Foam::CollisionModel<CloudType>::update
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "CollisionModelNew.C"
+#include "StochasticCollisionModelNew.C"
 
 // ************************************************************************* //
 

src/lagrangian/spray/submodels/StochasticCollision/StochasticCollisionModel/StochasticCollisionModel.H

@@ -22,19 +22,19 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::CollisionModel
+    Foam::StochasticCollisionModel
 
 Description
-    Templated collision model class
+    Templated stochastic collision model class
 
 SourceFiles
-    CollisionModel.C
+    StochasticCollisionModel.C
-    CollisionModelNew.C
+    StochasticCollisionModelNew.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef CollisionModel_H
+#ifndef StochasticCollisionModel_H
-#define CollisionModel_H
+#define StochasticCollisionModel_H
 
 #include "IOdictionary.H"
 #include "autoPtr.H"
@@ -47,11 +47,11 @@ namespace Foam
 {
 
 /*---------------------------------------------------------------------------*\
-                      Class CollisionModel Declaration
+                  Class StochasticCollisionModel Declaration
 \*---------------------------------------------------------------------------*/
 
 template<class CloudType>
-class CollisionModel
+class StochasticCollisionModel
 :
     public SubModelBase<CloudType>
 {
@@ -64,7 +64,7 @@ public:
     declareRunTimeSelectionTable
     (
         autoPtr,
-        CollisionModel,
+        StochasticCollisionModel,
         dictionary,
         (
             const dictionary& dict,
@@ -77,10 +77,10 @@ public:
     // Constructors
 
         //- Construct null from owner
-        CollisionModel(CloudType& owner);
+        StochasticCollisionModel(CloudType& owner);
 
         //- Construct from dictionary
-        CollisionModel
+        StochasticCollisionModel
         (
             const dictionary& dict,
             CloudType& owner,
@@ -88,24 +88,24 @@ public:
         );
 
         //- Construct copy
-        CollisionModel(const CollisionModel<CloudType>& cm);
+        StochasticCollisionModel(const StochasticCollisionModel<CloudType>& cm);
 
         //- Construct and return a clone
-        virtual autoPtr<CollisionModel<CloudType> > clone() const
+        virtual autoPtr<StochasticCollisionModel<CloudType> > clone() const
         {
-            return autoPtr<CollisionModel<CloudType> >
+            return autoPtr<StochasticCollisionModel<CloudType> >
             (
-                new CollisionModel<CloudType>(*this)
+                new StochasticCollisionModel<CloudType>(*this)
             );
         }
 
 
     //- Destructor
-    virtual ~CollisionModel();
+    virtual ~StochasticCollisionModel();
 
 
     //- Selector
-    static autoPtr<CollisionModel<CloudType> > New
+    static autoPtr<StochasticCollisionModel<CloudType> > New
     (
         const dictionary& dict,
         CloudType& owner
@@ -150,27 +150,27 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define makeCollisionModel(CloudType)                                         \
+#define makeStochasticCollisionModel(CloudType)                                         \
                                                                               \
     typedef CloudType::sprayCloudType sprayCloudType;                         \
     defineNamedTemplateTypeNameAndDebug                                       \
     (                                                                         \
-        CollisionModel<sprayCloudType>,                                       \
+        StochasticCollisionModel<sprayCloudType>,                             \
         0                                                                     \
     );                                                                        \
     defineTemplateRunTimeSelectionTable                                       \
     (                                                                         \
-        CollisionModel<sprayCloudType>,                                       \
+        StochasticCollisionModel<sprayCloudType>,                             \
         dictionary                                                            \
     );
 
 
-#define makeCollisionModelType(SS, CloudType)                                 \
+#define makeStochasticCollisionModelType(SS, CloudType)                       \
                                                                               \
     typedef CloudType::sprayCloudType sprayCloudType;                         \
     defineNamedTemplateTypeNameAndDebug(SS<sprayCloudType>, 0);               \
                                                                               \
-    CollisionModel<reactingCloudType>::                                       \
+    StochasticCollisionModel<sprayCloudType>::                                \
         adddictionaryConstructorToTable<SS<sprayCloudType> >                  \
             add##SS##CloudType##sprayCloudType##ConstructorToTable_;
 
@@ -179,7 +179,7 @@ public:
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #ifdef NoRepository
-#   include "CollisionModel.C"
+#   include "StochasticCollisionModel.C"
 #endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/lagrangian/spray/submodels/StochasticCollision/StochasticCollisionModel/StochasticCollisionModelNew.C

@@ -23,42 +23,44 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "CollisionModel.H"
+#include "StochasticCollisionModel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 template<class CloudType>
-Foam::autoPtr<Foam::CollisionModel<CloudType> >
+Foam::autoPtr<Foam::StochasticCollisionModel<CloudType> >
-Foam::CollisionModel<CloudType>::New
+Foam::StochasticCollisionModel<CloudType>::New
 (
     const dictionary& dict,
     CloudType& owner
 )
 {
-    word CollisionModelType(dict.lookup("CollisionModel"));
+    word modelType(dict.lookup("StochasticCollisionModel"));
 
-    Info<< "Selecting CollisionModel " << CollisionModelType << endl;
+    Info<< "Selecting StochasticCollisionModel " << modelType << endl;
 
     typename dictionaryConstructorTable::iterator cstrIter =
-        dictionaryConstructorTablePtr_->find(CollisionModelType);
+        dictionaryConstructorTablePtr_->find(modelType);
 
     if (cstrIter == dictionaryConstructorTablePtr_->end())
     {
         FatalErrorIn
         (
-            "CollisionModel<CloudType>::New"
+            "StochasticCollisionModel<CloudType>::New"
             "("
                 "const dictionary&, "
                 "CloudType&"
             ")"
-        )   << "Unknown CollisionModelType type "
+        )   << "Unknown StochasticCollisionModelType type "
-            << CollisionModelType
+            << modelType << ", constructor not in hash table" << nl << nl
-            << ", constructor not in hash table" << nl << nl
+            << "    Valid StochasticCollisionModel types are:" << nl
-            << "    Valid CollisionModel types are:" << nl
             << dictionaryConstructorTablePtr_->sortedToc() << exit(FatalError);
     }
 
-    return autoPtr<CollisionModel<CloudType> >(cstrIter()(dict, owner));
+    return autoPtr<StochasticCollisionModel<CloudType> >
+    (
+        cstrIter()(dict, owner)
+    );
 }
 
 

src/lagrangian/spray/submodels/StochasticCollision/TrajectoryCollision/TrajectoryCollision.C

@@ -34,7 +34,7 @@ Foam::TrajectoryCollision<CloudType>::TrajectoryCollision
     CloudType& owner
 )
 :
-    CollisionModel<CloudType>(dict, owner, typeName),
+    StochasticCollisionModel<CloudType>(dict, owner, typeName),
     cSpace_(readScalar(this->coeffDict().lookup("cSpace"))),
     cTime_(readScalar(this->coeffDict().lookup("cTime"))),
     coalescence_(this->coeffDict().lookup("coalescence"))
@@ -47,7 +47,7 @@ Foam::TrajectoryCollision<CloudType>::TrajectoryCollision
     const TrajectoryCollision<CloudType>& cm
 )
 :
-    CollisionModel<CloudType>(cm),
+    StochasticCollisionModel<CloudType>(cm),
     cSpace_(cm.cSpace_),
     cTime_(cm.cTime_),
     coalescence_(cm.coalescence_)

src/lagrangian/spray/submodels/StochasticCollision/TrajectoryCollision/TrajectoryCollision.H

@@ -32,7 +32,7 @@ Description
 #ifndef TrajectoryCollision_H
 #define TrajectoryCollision_H
 
-#include "CollisionModel.H"
+#include "StochasticCollisionModel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -45,7 +45,7 @@ namespace Foam
 template<class CloudType>
 class TrajectoryCollision
 :
-    public CollisionModel<CloudType>
+    public StochasticCollisionModel<CloudType>
 {
 private:
 
@@ -71,9 +71,9 @@ public:
         TrajectoryCollision(const TrajectoryCollision<CloudType>& cm);
 
         //- Construct and return a clone
-        virtual autoPtr<CollisionModel<CloudType> > clone() const
+        virtual autoPtr<StochasticCollisionModel<CloudType> > clone() const
         {
-            return autoPtr<CollisionModel<CloudType> >
+            return autoPtr<StochasticCollisionModel<CloudType> >
             (
                 new TrajectoryCollision<CloudType>(*this)
             );