ENH: Migrated stochastic collision models from spray to kinematic clouds, refactored and added models

src/lagrangian/intermediate/Make/files

@@ -25,7 +25,7 @@ $(KINEMATICCOLLIDINGPARCEL)/makeBasicKinematicCollidingParcelSubmodels.C
 
 
 /* thermo parcel sub-models */
-THERMOPARCEL=$(DERIVEDPARCELS)/fluidThermoParcel
+THERMOPARCEL=$(DERIVEDPARCELS)/basicThermoParcel
 $(THERMOPARCEL)/defineBasicThermoParcel.C
 $(THERMOPARCEL)/makeBasicThermoParcelSubmodels.C
 

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

@@ -31,6 +31,7 @@ License
 #include "InjectionModelList.H"
 #include "DispersionModel.H"
 #include "PatchInteractionModel.H"
+#include "StochasticCollisionModel.H"
 #include "SurfaceFilmModel.H"
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
@@ -56,6 +57,15 @@ void Foam::KinematicCloud<CloudType>::setModels()
         ).ptr()
     );
 
+    stochasticCollisionModel_.reset
+    (
+        StochasticCollisionModel<KinematicCloud<CloudType> >::New
+        (
+            subModelProperties_,
+            *this
+        ).ptr()
+    );
+
     surfaceFilmModel_.reset
     (
         SurfaceFilmModel<KinematicCloud<CloudType> >::New
@@ -181,7 +191,6 @@ void Foam::KinematicCloud<CloudType>::evolveCloud(TrackData& td)
         if (preInjectionSize != this->size())
         {
             updateCellOccupancy();
-
             preInjectionSize = this->size();
         }
 
@@ -191,6 +200,8 @@ void Foam::KinematicCloud<CloudType>::evolveCloud(TrackData& td)
         // Assume that motion will update the cellOccupancy as necessary
         // before it is required.
         td.cloud().motion(td);
+
+        stochasticCollision().update(solution_.trackTime());
     }
     else
     {
@@ -249,6 +260,7 @@ void Foam::KinematicCloud<CloudType>::cloudReset(KinematicCloud<CloudType>& c)
 
     dispersionModel_.reset(c.dispersionModel_.ptr());
     patchInteractionModel_.reset(c.patchInteractionModel_.ptr());
+    stochasticCollisionModel_.reset(c.stochasticCollisionModel_.ptr());
     surfaceFilmModel_.reset(c.surfaceFilmModel_.ptr());
 
     UIntegrator_.reset(c.UIntegrator_.ptr());
@@ -338,6 +350,7 @@ Foam::KinematicCloud<CloudType>::KinematicCloud
     ),
     dispersionModel_(NULL),
     patchInteractionModel_(NULL),
+    stochasticCollisionModel_(NULL),
     surfaceFilmModel_(NULL),
     UIntegrator_(NULL),
     UTrans_
@@ -418,6 +431,7 @@ Foam::KinematicCloud<CloudType>::KinematicCloud
     injectors_(c.injectors_),
     dispersionModel_(c.dispersionModel_->clone()),
     patchInteractionModel_(c.patchInteractionModel_->clone()),
+    stochasticCollisionModel_(c.stochasticCollisionModel_->clone()),
     surfaceFilmModel_(c.surfaceFilmModel_->clone()),
     UIntegrator_(c.UIntegrator_->clone()),
     UTrans_
@@ -507,6 +521,7 @@ Foam::KinematicCloud<CloudType>::KinematicCloud
     injectors_(*this),
     dispersionModel_(NULL),
     patchInteractionModel_(NULL),
+    stochasticCollisionModel_(NULL),
     surfaceFilmModel_(NULL),
     UIntegrator_(NULL),
     UTrans_(NULL),

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

@@ -39,6 +39,7 @@ Description
       - dispersion model
       - injection model
       - patch interaction model
+      - stochastic collision model
       - surface film model
 
 SourceFiles
@@ -84,6 +85,9 @@ class PatchInteractionModel;
 template<class CloudType>
 class SurfaceFilmModel;
 
+template<class CloudType>
+class StochasticCollisionModel;
+
 
 /*---------------------------------------------------------------------------*\
                        Class KinematicCloud Declaration
@@ -203,6 +207,10 @@ protected:
             autoPtr<PatchInteractionModel<KinematicCloud<CloudType> > >
                 patchInteractionModel_;
 
+            //- Stochastic collision model
+            autoPtr<StochasticCollisionModel<KinematicCloud<CloudType> > >
+                stochasticCollisionModel_;
+
             //- Surface film model
             autoPtr<SurfaceFilmModel<KinematicCloud<CloudType> > >
                 surfaceFilmModel_;
@@ -416,6 +424,15 @@ public:
                 inline PatchInteractionModel<KinematicCloud<CloudType> >&
                     patchInteraction();
 
+                //- Return const-access to the stochastic collision model
+                inline const
+                    StochasticCollisionModel<KinematicCloud<CloudType> >&
+                    stochasticCollision() const;
+
+                //- Return reference to the stochastic collision model
+                inline StochasticCollisionModel<KinematicCloud<CloudType> >&
+                    stochasticCollision();
+
                 //- Return const-access to the surface film model
                 inline const SurfaceFilmModel<KinematicCloud<CloudType> >&
                     surfaceFilm() const;
@@ -482,6 +499,9 @@ public:
 
             // Fields
 
+                //- Volume swept rate of parcels per cell
+                inline const tmp<volScalarField> vDotSweep() const;
+
                 //- Return the particle volume fraction field
                 //  Note: for particles belonging to this cloud only
                 inline const tmp<volScalarField> theta() const;

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

@@ -204,6 +204,22 @@ Foam::KinematicCloud<CloudType>::patchInteraction()
 }
 
 
+template<class CloudType>
+inline const Foam::StochasticCollisionModel<Foam::KinematicCloud<CloudType> >&
+Foam::KinematicCloud<CloudType>::stochasticCollision() const
+{
+    return stochasticCollisionModel_();
+}
+
+
+template<class CloudType>
+inline Foam::StochasticCollisionModel<Foam::KinematicCloud<CloudType> >&
+Foam::KinematicCloud<CloudType>::stochasticCollision()
+{
+    return stochasticCollisionModel_();
+}
+
+
 template<class CloudType>
 inline const Foam::SurfaceFilmModel<Foam::KinematicCloud<CloudType> >&
 Foam::KinematicCloud<CloudType>::surfaceFilm() const
@@ -571,6 +587,45 @@ Foam::KinematicCloud<CloudType>::SU(volVectorField& U) const
 }
 
 
+template<class CloudType>
+inline const Foam::tmp<Foam::volScalarField>
+Foam::KinematicCloud<CloudType>::vDotSweep() const
+{
+    tmp<volScalarField> tvDotSweep
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                this->name() + ":vDotSweep",
+                this->db().time().timeName(),
+                this->db(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            mesh_,
+            dimensionedScalar("zero", dimless/dimTime, 0.0),
+            zeroGradientFvPatchScalarField::typeName
+        )
+    );
+
+    volScalarField& vDotSweep = tvDotSweep();
+    forAllConstIter(typename KinematicCloud<CloudType>, *this, iter)
+    {
+        const parcelType& p = iter();
+        const label cellI = p.cell();
+
+        vDotSweep[cellI] += p.nParticle()*p.areaP()*mag(p.U() - U_[cellI]);
+    }
+
+    vDotSweep.internalField() /= mesh_.V();
+    vDotSweep.correctBoundaryConditions();
+
+    return vDotSweep;
+}
+
+
 template<class CloudType>
 inline const Foam::tmp<Foam::volScalarField>
 Foam::KinematicCloud<CloudType>::theta() const

src/lagrangian/intermediate/clouds/baseClasses/kinematicCloud/kinematicCloud.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -100,6 +100,9 @@ public:
 
             // Fields
 
+                //- Volume swept rate of parcels per cell
+                virtual const tmp<volScalarField> vDotSweep() const = 0;
+
                 //- Return the particle volume fraction field
                 //  Note: for particles belonging to this cloud only
                 virtual const tmp<volScalarField> theta() const = 0;

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

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -520,8 +520,7 @@ public:
 
         // Helper functions
 
-            //- Return the index of the face to be used in the interpolation
+            //- Return the index of the face used in the interpolation routine
-            //  routine
             inline label faceInterpolation() const;
 
             //- Cell owner mass

src/lagrangian/intermediate/parcels/derived/basicKinematicCollidingParcel/makeBasicKinematicCollidingParcelSubmodels.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -33,6 +33,7 @@ License
 #include "makeParcelInjectionModels.H"
 #include "makeParcelCollisionModels.H"
 #include "makeParcelPatchInteractionModels.H"
+#include "makeParcelStochasticCollisionModels.H"
 #include "makeParcelSurfaceFilmModels.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -47,6 +48,7 @@ namespace Foam
     makeParcelInjectionModels(basicKinematicCollidingCloud);
     makeParcelCollisionModels(basicKinematicCollidingCloud);
     makeParcelPatchInteractionModels(basicKinematicCollidingCloud);
+    makeParcelStochasticCollisionModels(basicKinematicCollidingCloud);
     makeParcelSurfaceFilmModels(basicKinematicCollidingCloud);
 }
 

src/lagrangian/intermediate/parcels/derived/basicKinematicParcel/makeBasicKinematicParcelSubmodels.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -32,6 +32,7 @@ License
 #include "makeParcelDispersionModels.H"
 #include "makeParcelInjectionModels.H"
 #include "makeParcelPatchInteractionModels.H"
+#include "makeParcelStochasticCollisionModels.H"
 #include "makeParcelSurfaceFilmModels.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -45,6 +46,7 @@ namespace Foam
     makeParcelDispersionModels(basicKinematicCloud);
     makeParcelInjectionModels(basicKinematicCloud);
     makeParcelPatchInteractionModels(basicKinematicCloud);
+    makeParcelStochasticCollisionModels(basicKinematicCloud);
     makeParcelSurfaceFilmModels(basicKinematicCloud);
 }
 

src/lagrangian/intermediate/parcels/include/makeParcelStochasticCollisionModels.H

@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     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 3 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, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef makeParcelStochasticCollisionModels_H
+#define makeParcelStochasticCollisionModels_H
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "NoStochasticCollision.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define makeParcelStochasticCollisionModels(CloudType)                             \
+                                                                              \
+    makeStochasticCollisionModel(CloudType);                                  \
+    makeStochasticCollisionModelType(NoStochasticCollision, CloudType);
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/lagrangian/intermediate/parcels/include/makeReactingMultiphaseParcelStochasticCollisionModels.H

@@ -0,0 +1,47 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     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 3 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, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef makeReactingMultiphaseParcelStochasticCollisionModels_H
+#define makeReactingMultiphaseParcelStochasticCollisionModels_H
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "NoStochasticCollision.H"
+#include "SuppressionCollision.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define makeReactingMultiphaseParcelStochasticCollisionModels(CloudType)      \
+                                                                              \
+    makeStochasticCollisionModel(CloudType);                                  \
+    makeStochasticCollisionModelType(NoStochasticCollision, CloudType);       \
+    makeStochasticCollisionModelType(SuppressionCollision, CloudType);
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/lagrangian/intermediate/submodels/Kinematic/StochasticCollision/NoStochasticCollision/NoStochasticCollision.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,6 +25,15 @@ License
 
 #include "NoStochasticCollision.H"
 
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+template<class CloudType>
+void Foam::NoStochasticCollision<CloudType>::collide(const scalar)
+{
+    // do nothing
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class CloudType>
@@ -64,37 +73,4 @@ bool Foam::NoStochasticCollision<CloudType>::active() const
 }
 
 
-template<class CloudType>
-bool Foam::NoStochasticCollision<CloudType>::update
-(
-    const scalar dt,
-    cachedRandom& rndGen,
-    vector& pos1,
-    scalar& m1,
-    scalar& d1,
-    scalar& N1,
-    vector& U,
-    scalar& rho1,
-    scalar& T1,
-    scalarField& Y1,
-    const scalar sigma1,
-    const label celli,
-    const scalar voli,
-    vector& pos2,
-    scalar& m2,
-    scalar& d2,
-    scalar& N2,
-    vector& U2,
-    scalar& rho2,
-    scalar& T2,
-    scalarField& Y2,
-    const scalar sigma2,
-    const label cellj,
-    const scalar volj
-) const
-{
-    return false;
-}
-
-
 // ************************************************************************* //

src/lagrangian/intermediate/submodels/Kinematic/StochasticCollision/NoStochasticCollision/NoStochasticCollision.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -39,7 +39,7 @@ Description
 namespace Foam
 {
 /*---------------------------------------------------------------------------*\
-                       Class NoStochasticCollision Declaration
+                    Class NoStochasticCollision Declaration
 \*---------------------------------------------------------------------------*/
 
 template<class CloudType>
@@ -47,6 +47,14 @@ class NoStochasticCollision
 :
     public StochasticCollisionModel<CloudType>
 {
+protected:
+
+    // Protected Member Functions
+
+        //- Update the model
+        virtual void collide(const scalar dt);
+
+
 public:
 
     //- Runtime type information
@@ -79,34 +87,6 @@ public:
 
         //- Flag to indicate whether model activates collision model
         virtual bool active() const;
-
-        virtual bool update
-        (
-            const scalar dt,
-            cachedRandom& rndGen,
-            vector& pos1,
-            scalar& m1,
-            scalar& d1,
-            scalar& N1,
-            vector& U,
-            scalar& rho1,
-            scalar& T1,
-            scalarField& Y1,
-            const scalar sigma1,
-            const label celli,
-            const scalar voli,
-            vector& pos2,
-            scalar& m2,
-            scalar& d2,
-            scalar& N2,
-            vector& U2,
-            scalar& rho2,
-            scalar& T2,
-            scalarField& Y2,
-            const scalar sigma2,
-            const label cellj,
-            const scalar volj
-        ) const;
 };
 
 

src/lagrangian/intermediate/submodels/Kinematic/StochasticCollision/StochasticCollisionModel/StochasticCollisionModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,6 +25,18 @@ License
 
 #include "StochasticCollisionModel.H"
 
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+template<class CloudType>
+void Foam::StochasticCollisionModel<CloudType>::collide(const scalar dt)
+{
+    notImplemented
+    (
+        "void Foam::NoStochasticCollision<CloudType>::collide(const scalar)"
+    );
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class CloudType>
@@ -69,66 +81,12 @@ Foam::StochasticCollisionModel<CloudType>::~StochasticCollisionModel()
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class CloudType>
-bool Foam::StochasticCollisionModel<CloudType>::update
+void Foam::StochasticCollisionModel<CloudType>::update(const scalar dt)
-(
-    const scalar dt,
-    cachedRandom& rndGen,
-    vector& pos1,
-    scalar& m1,
-    scalar& d1,
-    scalar& N1,
-    vector& U1,
-    scalar& rho1,
-    scalar& T1,
-    scalarField& Y1,
-    const scalar sigma1,
-    const label celli,
-    const scalar voli,
-    vector& pos2,
-    scalar& m2,
-    scalar& d2,
-    scalar& N2,
-    vector& U2,
-    scalar& rho2,
-    scalar& T2,
-    scalarField& Y2,
-    const scalar sigma2,
-    const label cellj,
-    const scalar volj
-) const
 {
-    notImplemented
+    if (this->active())
-    (
+    {
-        "bool Foam::StochasticCollisionModel<CloudType>::update"
+        this->collide(dt);
-        "("
+    }
-            "const scalar, "
-            "cachedRandom&, "
-            "vector&, "
-            "scalar&, "
-            "scalar&, "
-            "scalar&, "
-            "vector&, "
-            "scalar&, "
-            "scalar&, "
-            "scalarField&, "
-            "const scalar, "
-            "const label, "
-            "const scalar, "
-            "vector&, "
-            "scalar&, "
-            "scalar&, "
-            "scalar&, "
-            "vector&, "
-            "scalar&, "
-            "scalar&, "
-            "scalarField&, "
-            "const scalar, "
-            "const label, "
-            "const scalar"
-        ") const"
-    );
-
-    return false;
 }
 
 
@@ -137,4 +95,3 @@ bool Foam::StochasticCollisionModel<CloudType>::update
 #include "StochasticCollisionModelNew.C"
 
 // ************************************************************************* //
-

src/lagrangian/intermediate/submodels/Kinematic/StochasticCollision/StochasticCollisionModel/StochasticCollisionModel.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -55,6 +55,12 @@ class StochasticCollisionModel
 :
     public SubModelBase<CloudType>
 {
+protected:
+
+    //- Main collision routine
+    virtual void collide(const scalar dt);
+
+
 public:
 
     //- Runtime type information
@@ -114,33 +120,8 @@ public:
 
     // Member Functions
 
-        virtual bool update
+        //- Update the model
-        (
+        void update(const scalar dt);
-            const scalar dt,
-            cachedRandom& rndGen,
-            vector& pos1,
-            scalar& m1,
-            scalar& d1,
-            scalar& N1,
-            vector& U1,
-            scalar& rho1,
-            scalar& T1,
-            scalarField& Y1,
-            const scalar sigma1,
-            const label celli,
-            const scalar voli,
-            vector& pos2,
-            scalar& m2,
-            scalar& d2,
-            scalar& N2,
-            vector& U2,
-            scalar& rho2,
-            scalar& T2,
-            scalarField& Y2,
-            const scalar sigma2,
-            const label cellj,
-            const scalar volj
-        ) const;
 };
 
 
@@ -152,27 +133,27 @@ public:
 
 #define makeStochasticCollisionModel(CloudType)                                         \
                                                                               \
-    typedef CloudType::sprayCloudType sprayCloudType;                         \
+    typedef CloudType::kinematicCloudType kinematicCloudType;                 \
     defineNamedTemplateTypeNameAndDebug                                       \
     (                                                                         \
-        StochasticCollisionModel<sprayCloudType>,                             \
+        StochasticCollisionModel<kinematicCloudType>,                         \
         0                                                                     \
     );                                                                        \
     defineTemplateRunTimeSelectionTable                                       \
     (                                                                         \
-        StochasticCollisionModel<sprayCloudType>,                             \
+        StochasticCollisionModel<kinematicCloudType>,                         \
         dictionary                                                            \
     );
 
 
 #define makeStochasticCollisionModelType(SS, CloudType)                       \
                                                                               \
-    typedef CloudType::sprayCloudType sprayCloudType;                         \
+    typedef CloudType::kinematicCloudType kinematicCloudType;                 \
-    defineNamedTemplateTypeNameAndDebug(SS<sprayCloudType>, 0);               \
+    defineNamedTemplateTypeNameAndDebug(SS<kinematicCloudType>, 0);           \
                                                                               \
-    StochasticCollisionModel<sprayCloudType>::                                \
+    StochasticCollisionModel<kinematicCloudType>::                            \
-        adddictionaryConstructorToTable<SS<sprayCloudType> >                  \
+        adddictionaryConstructorToTable<SS<kinematicCloudType> >              \
-            add##SS##CloudType##sprayCloudType##ConstructorToTable_;
+            add##SS##CloudType##kinematicCloudType##ConstructorToTable_;
 
 
 

src/lagrangian/intermediate/submodels/Kinematic/StochasticCollision/StochasticCollisionModel/StochasticCollisionModelNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -37,7 +37,7 @@ Foam::StochasticCollisionModel<CloudType>::New
 {
     word modelType(dict.lookup("stochasticCollisionModel"));
 
-    Info<< "Selecting StochasticCollisionModel " << modelType << endl;
+    Info<< "Selecting stochastic collision model " << modelType << endl;
 
     typename dictionaryConstructorTable::iterator cstrIter =
         dictionaryConstructorTablePtr_->find(modelType);
@@ -51,9 +51,9 @@ Foam::StochasticCollisionModel<CloudType>::New
                 "const dictionary&, "
                 "CloudType&"
             ")"
-        )   << "Unknown StochasticCollisionModelType type "
+        )   << "Unknown model type type "
             << modelType << ", constructor not in hash table" << nl << nl
-            << "    Valid StochasticCollisionModel types are:" << nl
+            << "    Valid model types are:" << nl
             << dictionaryConstructorTablePtr_->sortedToc() << exit(FatalError);
     }
 

src/lagrangian/intermediate/submodels/ReactingMultiphase/StochasticCollision/SuppressionCollision/SuppressionCollision.C

@@ -0,0 +1,91 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     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 3 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, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "SuppressionCollision.H"
+#include "kinematicCloud.H"
+
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+template<class CloudType>
+void Foam::SuppressionCollision<CloudType>::collide(const scalar dt)
+{
+    const kinematicCloud& sc =
+        this->owner().mesh().template
+        lookupObject<kinematicCloud>(suppressionCloud_);
+
+    volScalarField vDotSweep(sc.vDotSweep());
+    volScalarField P(type() + ":p", 1.0 - exp(-vDotSweep*dt));
+
+    forAllIter(typename CloudType, this->owner(), iter)
+    {
+        typename CloudType::parcelType& p = iter();
+        label cellI = p.cell();
+
+        scalar xx = this->owner().rndGen().template sample01<scalar>();
+
+        if (xx < P[cellI])
+        {
+            p.canCombust() = -1;
+            p.typeId() = max(p.typeId(), suppressedParcelType_);
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::SuppressionCollision<CloudType>::SuppressionCollision
+(
+    const dictionary& dict,
+    CloudType& owner
+)
+:
+    StochasticCollisionModel<CloudType>(owner),
+    suppressionCloud_(dict.lookup("suppressionCloud")),
+    suppressedParcelType_(dict.lookupOrDefault("suppressedParcelType", -1))
+{}
+
+
+template<class CloudType>
+Foam::SuppressionCollision<CloudType>::SuppressionCollision
+(
+    const SuppressionCollision<CloudType>& cm
+)
+:
+    StochasticCollisionModel<CloudType>(cm),
+    suppressionCloud_(cm.suppressionCloud_),
+    suppressedParcelType_(cm.suppressedParcelType_)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::SuppressionCollision<CloudType>::~SuppressionCollision()
+{}
+
+
+// ************************************************************************* //

src/lagrangian/intermediate/submodels/ReactingMultiphase/StochasticCollision/SuppressionCollision/SuppressionCollision.H

@@ -0,0 +1,111 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     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 3 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, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::SuppressionCollision
+
+Description
+    Inter-cloud collision model, whereby the \c canReact flag can be used
+    to inhibit devolatilisation and surface reactions
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef SuppressionCollision_H
+#define SuppressionCollision_H
+
+#include "StochasticCollisionModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+/*---------------------------------------------------------------------------*\
+                    Class SuppressionCollision Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class CloudType>
+class SuppressionCollision
+:
+    public StochasticCollisionModel<CloudType>
+{
+protected:
+
+    // Protected data
+
+        //- Name of cloud used for suppression
+        const word suppressionCloud_;
+
+        //- Suppressed parcel type - optional
+        const label suppressedParcelType_;
+
+
+   // Protected Member Functions
+
+        //- Update the model
+        virtual void collide(const scalar dt);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("suppressionCollision");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        SuppressionCollision(const dictionary& dict, CloudType& owner);
+
+        //- Construct copy
+        SuppressionCollision(const SuppressionCollision<CloudType>& cm);
+
+        //- Construct and return a clone
+        virtual autoPtr<StochasticCollisionModel<CloudType> > clone() const
+        {
+            return autoPtr<StochasticCollisionModel<CloudType> >
+            (
+                new SuppressionCollision<CloudType>(*this)
+            );
+        }
+
+
+    //- Destructor
+    virtual ~SuppressionCollision();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "SuppressionCollision.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

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

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -26,7 +26,6 @@ License
 #include "SprayCloud.H"
 #include "AtomizationModel.H"
 #include "BreakupModel.H"
-#include "StochasticCollisionModel.H"
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
@@ -50,15 +49,6 @@ void Foam::SprayCloud<CloudType>::setModels()
             *this
         ).ptr()
     );
-
-    stochasticCollisionModel_.reset
-    (
-        StochasticCollisionModel<SprayCloud<CloudType> >::New
-        (
-            this->subModelProperties(),
-            *this
-        ).ptr()
-    );
 }
 
 
@@ -72,7 +62,6 @@ void Foam::SprayCloud<CloudType>::cloudReset
 
     atomizationModel_.reset(c.atomizationModel_.ptr());
     breakupModel_.reset(c.breakupModel_.ptr());
-    stochasticCollisionModel_.reset(c.stochasticCollisionModel_.ptr());
 }
 
 
@@ -94,8 +83,7 @@ Foam::SprayCloud<CloudType>::SprayCloud
     cloudCopyPtr_(NULL),
     averageParcelMass_(0.0),
     atomizationModel_(NULL),
-    breakupModel_(NULL),
+    breakupModel_(NULL)
-    stochasticCollisionModel_(NULL)
 {
     if (this->solution().active())
     {
@@ -130,8 +118,7 @@ Foam::SprayCloud<CloudType>::SprayCloud
     cloudCopyPtr_(NULL),
     averageParcelMass_(c.averageParcelMass_),
     atomizationModel_(c.atomizationModel_->clone()),
-    breakupModel_(c.breakupModel_->clone()),
+    breakupModel_(c.breakupModel_->clone())
-    stochasticCollisionModel_(c.stochasticCollisionModel_->clone())
 {}
 
 
@@ -148,8 +135,7 @@ Foam::SprayCloud<CloudType>::SprayCloud
     cloudCopyPtr_(NULL),
     averageParcelMass_(0.0),
     atomizationModel_(NULL),
-    breakupModel_(NULL),
+    breakupModel_(NULL)
-    stochasticCollisionModel_(NULL)
 {}
 
 
@@ -179,6 +165,8 @@ void Foam::SprayCloud<CloudType>::setParcelThermoProperties
     // override rho and Cp from constantProperties
     parcel.Cp() = liqMix.Cp(parcel.pc(), parcel.T(), X);
     parcel.rho() = liqMix.rho(parcel.pc(), parcel.T(), X);
+    parcel.sigma() = liqMix.sigma(parcel.pc(), parcel.T(), X);
+    parcel.mu() = liqMix.mu(parcel.pc(), parcel.T(), X);
 }
 
 
@@ -237,128 +225,6 @@ void Foam::SprayCloud<CloudType>::evolve()
 }
 
 
-template<class CloudType>
-template<class TrackData>
-void Foam::SprayCloud<CloudType>::motion(TrackData& td)
-{
-    const scalar dt = this->solution().trackTime();
-
-    td.part() = TrackData::tpLinearTrack;
-    CloudType::move(td, dt);
-
-    this->updateCellOccupancy();
-
-    if (stochasticCollision().active())
-    {
-        const liquidMixtureProperties& liqMix = this->composition().liquids();
-
-        label i = 0;
-        forAllIter(typename SprayCloud<CloudType>, *this, iter)
-        {
-            label j = 0;
-            forAllIter(typename SprayCloud<CloudType>, *this, jter)
-            {
-                if (j > i)
-                {
-                    parcelType& p = iter();
-                    scalar Vi = this->mesh().V()[p.cell()];
-                    scalarField X1(liqMix.X(p.Y()));
-                    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(liqMix.X(q.Y()));
-                    scalar sigma2 = liqMix.sigma(q.pc(), q.T(), X2);
-                    scalar mq = q.mass()*q.nParticle();
-
-                    bool updateProperties = stochasticCollision().update
-                    (
-                        dt,
-                        this->rndGen(),
-                        p.position(),
-                        mp,
-                        p.d(),
-                        p.nParticle(),
-                        p.U(),
-                        p.rho(),
-                        p.T(),
-                        p.Y(),
-                        sigma1,
-                        p.cell(),
-                        Vi,
-                        q.position(),
-                        mq,
-                        q.d(),
-                        q.nParticle(),
-                        q.U(),
-                        q.rho(),
-                        q.T(),
-                        q.Y(),
-                        sigma2,
-                        q.cell(),
-                        Vj
-                    );
-
-                    // for coalescence we need to update the density and
-                    // the diameter cause of the temp/conc/mass-change
-                    if (updateProperties)
-                    {
-                        if (mp > VSMALL)
-                        {
-                            scalarField Xp(liqMix.X(p.Y()));
-                            p.rho() = liqMix.rho(p.pc(), p.T(), Xp);
-                            p.Cp() = liqMix.Cp(p.pc(), p.T(), Xp);
-                            p.d() =
-                                cbrt
-                                (
-                                    6.0*mp
-                                   /(
-                                        p.nParticle()
-                                       *p.rho()
-                                       *constant::mathematical::pi
-                                    )
-                                );
-                        }
-
-                        if (mq > VSMALL)
-                        {
-                            scalarField Xq(liqMix.X(q.Y()));
-                            q.rho() = liqMix.rho(q.pc(), q.T(), Xq);
-                            q.Cp() = liqMix.Cp(q.pc(), q.T(), Xq);
-                            q.d() =
-                                cbrt
-                                (
-                                    6.0*mq
-                                   /(
-                                        q.nParticle()
-                                       *q.rho()
-                                       *constant::mathematical::pi
-                                    )
-                                );
-                        }
-                    }
-                }
-                j++;
-            }
-            i++;
-        }
-
-        // remove coalesced parcels that fall below minimum mass threshold
-        forAllIter(typename SprayCloud<CloudType>, *this, iter)
-        {
-            parcelType& p = iter();
-            scalar mass = p.nParticle()*p.mass();
-
-            if (mass < td.cloud().constProps().minParticleMass())
-            {
-                this->deleteParticle(p);
-            }
-        }
-    }
-}
-
-
 template<class CloudType>
 void Foam::SprayCloud<CloudType>::info()
 {

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

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,6 +27,10 @@ Class
 Description
     Templated base class for spray cloud
 
+    - sub-models:
+      - atomization model
+      - break-up model
+
 \*---------------------------------------------------------------------------*/
 
 #ifndef SprayCloud_H
@@ -46,9 +50,6 @@ class AtomizationModel;
 template<class CloudType>
 class BreakupModel;
 
-template<class CloudType>
-class StochasticCollisionModel;
-
 /*---------------------------------------------------------------------------*\
                       Class SprayCloud Declaration
 \*---------------------------------------------------------------------------*/
@@ -106,10 +107,6 @@ protected:
             //- Break-up model
             autoPtr<BreakupModel<SprayCloud<CloudType> > > breakupModel_;
 
-            //- Collision model
-            autoPtr<StochasticCollisionModel<SprayCloud<CloudType> > >
-                stochasticCollisionModel_;
-
 
     // Protected Member Functions
 
@@ -202,14 +199,6 @@ public:
                 //- Return reference to the breakup model
                 inline BreakupModel<SprayCloud<CloudType> >& breakup();
 
-                //- Return const-access to the breakup model
-                inline const StochasticCollisionModel<SprayCloud<CloudType> >&
-                    stochasticCollision() const;
-
-                //- Return reference to the breakup model
-                inline StochasticCollisionModel<SprayCloud<CloudType> >&
-                    stochasticCollision();
-
 
         // Cloud evolution functions
 
@@ -236,10 +225,6 @@ public:
 
             //- Evolve the spray (inject, move)
             void evolve();
-            //- Particle motion
-
-            template<class TrackData>
-            void motion(TrackData& td);
 
 
         // I-O
@@ -249,7 +234,6 @@ public:
 };
 
 
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

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

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -65,22 +65,6 @@ Foam::SprayCloud<CloudType>::breakup()
 }
 
 
-template<class CloudType>
-inline const Foam::StochasticCollisionModel<Foam::SprayCloud<CloudType> >&
-Foam::SprayCloud<CloudType>::stochasticCollision() const
-{
-    return stochasticCollisionModel_;
-}
-
-
-template<class CloudType>
-inline Foam::StochasticCollisionModel<Foam::SprayCloud<CloudType> >&
-Foam::SprayCloud<CloudType>::stochasticCollision()
-{
-    return stochasticCollisionModel_();
-}
-
-
 template<class CloudType>
 inline Foam::scalar Foam::SprayCloud<CloudType>::averageParcelMass() const
 {

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

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

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

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -32,6 +32,7 @@ License
 #include "makeParcelDispersionModels.H"
 #include "makeSprayParcelInjectionModels.H" // Spray variant
 #include "makeParcelPatchInteractionModels.H"
+#include "makeSprayParcelStochasticCollisionModels.H" // Spray variant
 
 // Thermodynamic
 #include "makeParcelHeatTransferModels.H"
@@ -44,7 +45,6 @@ License
 // Spray
 #include "makeSprayParcelAtomizationModels.H"
 #include "makeSprayParcelBreakupModels.H"
-#include "makeSprayParcelCollisionModels.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -57,6 +57,7 @@ namespace Foam
     makeParcelDispersionModels(basicSprayCloud);
     makeSprayParcelInjectionModels(basicSprayCloud);
     makeParcelPatchInteractionModels(basicSprayCloud);
+    makeSprayParcelStochasticCollisionModels(basicSprayCloud);
 
     // Thermo sub-models
     makeParcelHeatTransferModels(basicSprayCloud);
@@ -69,7 +70,6 @@ namespace Foam
     // Spray sub-models
     makeSprayParcelAtomizationModels(basicSprayCloud);
     makeSprayParcelBreakupModels(basicSprayCloud);
-    makeSprayParcelCollisionModels(basicSprayCloud);
 };
 
 

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

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,8 +23,8 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef makeSprayParcelCollisionModels_H
+#ifndef makeSprayParcelStochasticCollisionModels_H
-#define makeSprayParcelCollisionModels_H
+#define makeSprayParcelStochasticCollisionModels_H
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -34,7 +34,7 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define makeSprayParcelCollisionModels(CloudType)                             \
+#define makeSprayParcelStochasticCollisionModels(CloudType)                   \
                                                                               \
     makeStochasticCollisionModel(CloudType);                                  \
     makeStochasticCollisionModelType(NoStochasticCollision, CloudType);       \

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

@@ -24,150 +24,120 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "ORourkeCollision.H"
+#include "mathematicalConstants.H"
+#include "SLGThermo.H"
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+using namespace Foam::constant::mathematical;
+
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
 template<class CloudType>
-Foam::ORourkeCollision<CloudType>::ORourkeCollision
+void Foam::ORourkeCollision<CloudType>::collide(const scalar dt)
-(
+{
-    const dictionary& dict,
+    label i = 0;
-    CloudType& owner
+    forAllIter(typename CloudType, this->owner(), iter1)
-)
+    {
-:
+        label j = 0;
-    StochasticCollisionModel<CloudType>(dict, owner, typeName),
+        forAllIter(typename CloudType, this->owner(), iter2)
-    coalescence_(this->coeffDict().lookup("coalescence"))
+        {
-{}
+            if (j > i)
+            {
+                parcelType& p1 = iter1();
+                parcelType& p2 = iter2();
+
+                scalar m1 = p1.nParticle()*p1.mass();
+                scalar m2 = p2.nParticle()*p2.mass();
+
+                bool massChanged = collideParcels(dt, p1, p2, m1, m2);
+
+                if (massChanged)
+                {
+                    if (m1 > ROOTVSMALL)
+                    {
+                        const scalarField X(liquids_.X(p1.Y()));
+                        p1.rho() = liquids_.rho(p1.pc(), p1.T(), X);
+                        p1.Cp() = liquids_.Cp(p1.pc(), p1.T(), X);
+                        p1.sigma() = liquids_.sigma(p1.pc(), p1.T(), X);
+                        p1.mu() = liquids_.mu(p1.pc(), p1.T(), X);
+                        p1.d() = cbrt(6.0*m1/(p1.nParticle()*p1.rho()*pi));
+                    }
+
+                    if (m2 > ROOTVSMALL)
+                    {
+                        const scalarField X(liquids_.X(p2.Y()));
+                        p2.rho() = liquids_.rho(p2.pc(), p2.T(), X);
+                        p2.Cp() = liquids_.Cp(p2.pc(), p2.T(), X);
+                        p2.sigma() = liquids_.sigma(p2.pc(), p2.T(), X);
+                        p2.mu() = liquids_.mu(p2.pc(), p2.T(), X);
+                        p2.d() = cbrt(6.0*m2/(p2.nParticle()*p2.rho()*pi));
+                    }
+                }
+            }
+            j++;
+        }
+        i++;
+    }
+
+    // remove coalesced parcels that fall below minimum mass threshold
+    forAllIter(typename CloudType, this->owner(), iter)
+    {
+        parcelType& p = iter();
+        scalar mass = p.nParticle()*p.mass();
+
+        if (mass < this->owner().constProps().minParticleMass())
+        {
+            this->owner().deleteParticle(p);
+        }
+    }
+}
 
 
 template<class CloudType>
-Foam::ORourkeCollision<CloudType>::ORourkeCollision
+bool Foam::ORourkeCollision<CloudType>::collideParcels
-(
-    const ORourkeCollision<CloudType>& cm
-)
-:
-    StochasticCollisionModel<CloudType>(cm),
-    coalescence_(cm.coalescence_)
-{}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-template<class CloudType>
-Foam::ORourkeCollision<CloudType>::~ORourkeCollision()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class CloudType>
-bool Foam::ORourkeCollision<CloudType>::update
 (
     const scalar dt,
-    cachedRandom& rndGen,
+    parcelType& p1,
-    vector& pos1,
+    parcelType& p2,
     scalar& m1,
-    scalar& d1,
+    scalar& m2
-    scalar& N1,
+)
-    vector& U1,
-    scalar& rho1,
-    scalar& T1,
-    scalarField& Y1,
-    const scalar sigma1,
-    const label celli,
-    const scalar voli,
-    vector& pos2,
-    scalar& m2,
-    scalar& d2,
-    scalar& N2,
-    vector& U2,
-    scalar& rho2,
-    scalar& T2,
-    scalarField& Y2,
-    const scalar sigma2,
-    const label cellj,
-    const scalar volj
-) const
 {
+    const label cell1 = p1.cell();
+    const label cell2 = p2.cell();
+
     // check if parcels belong to same cell
-    if ((celli != cellj) || (m1 < VSMALL) || (m2 < VSMALL))
+    if ((cell1 != cell2) || (m1 < ROOTVSMALL) || (m2 < ROOTVSMALL))
     {
         return false;
     }
 
     bool coalescence = false;
 
-    scalar magVrel = mag(U1-U2);
+    const scalar Vc = this->owner().mesh().V()[cell1];
+    const scalar d1 = p1.d();
+    const scalar d2 = p2.d();
+
+    scalar magUrel = mag(p1.U() - p2.U());
     scalar sumD = d1 + d2;
-    scalar nu0 = 0.25*constant::mathematical::pi*sumD*sumD*magVrel*dt/volj;
+    scalar nu0 = 0.25*constant::mathematical::pi*sqr(sumD)*magUrel*dt/Vc;
-    scalar nMin = min(N1, N2);
+    scalar nMin = min(p1.nParticle(), p2.nParticle());
     scalar nu = nMin*nu0;
     scalar collProb = exp(-nu);
-    scalar xx = rndGen.sample01<scalar>();
+    scalar xx = this->owner().rndGen().template sample01<scalar>();
 
     // collision occurs
     if (xx > collProb)
     {
         if (d1 > d2)
         {
-            coalescence = collideSorted
+            coalescence = collideSorted(dt, p1, p2, m1, m2);
-            (
-                dt,
-                rndGen,
-                pos1,
-                m1,
-                d1,
-                N1,
-                U1,
-                rho1,
-                T1,
-                Y1,
-                sigma1,
-                celli,
-                voli,
-                pos2,
-                m2,
-                d2,
-                N2,
-                U2,
-                rho2,
-                T2,
-                Y2,
-                sigma2,
-                cellj,
-                volj
-            );
         }
         else
         {
-            coalescence = collideSorted
+            coalescence = collideSorted(dt, p2, p1, m2, m1);
-            (
-                dt,
-                rndGen,
-                pos2,
-                m2,
-                d2,
-                N2,
-                U2,
-                rho2,
-                T2,
-                Y2,
-                sigma2,
-                cellj,
-                volj,
-                pos1,
-                m1,
-                d1,
-                N1,
-                U1,
-                rho1,
-                T1,
-                Y1,
-                sigma1,
-                celli,
-                voli
-            );
         }
     }
+
     return coalescence;
 }
 
@@ -176,85 +146,81 @@ template<class CloudType>
 bool Foam::ORourkeCollision<CloudType>::collideSorted
 (
     const scalar dt,
-    cachedRandom& rndGen,
+    parcelType& p1,
-    vector& pos1,
+    parcelType& p2,
     scalar& m1,
-    scalar& d1,
+    scalar& m2
-    scalar& N1,
+)
-    vector& U1,
-    scalar& rho1,
-    scalar& T1,
-    scalarField& Y1,
-    const scalar sigma1,
-    const label celli,
-    const scalar voli,
-    vector& pos2,
-    scalar& m2,
-    scalar& d2,
-    scalar& N2,
-    vector& U2,
-    scalar& rho2,
-    scalar& T2,
-    scalarField& Y2,
-    const scalar sigma2,
-    const label cellj,
-    const scalar volj
-) const
 {
     bool coalescence = false;
 
-    vector vRel = U1 - U2;
+    const scalar sigma1 = p1.sigma();
-    scalar magVRel = mag(vRel);
+    const scalar sigma2 = p2.sigma();
 
-    scalar mdMin = m2/N2;
+    const scalar d1 = p1.d();
+    const scalar d2 = p2.d();
+
+    const scalar T1 = p1.T();
+    const scalar T2 = p2.T();
+
+    const scalar rho1 = p1.rho();
+    const scalar rho2 = p2.rho();
+
+    const vector& U1 = p1.U();
+    const vector& U2 = p2.U();
+
+    const label& nP1 = p1.nParticle();
+    const label& nP2 = p2.nParticle();
+
+
+    vector URel = U1 - U2;
+    scalar magURel = mag(URel);
 
     scalar mTot = m1 + m2;
 
-    scalar gamma = d1/max(d2, 1.0e-12);
+    scalar gamma = d1/max(ROOTVSMALL, d2);
-    scalar f = gamma*gamma*gamma + 2.7*gamma - 2.4*gamma*gamma;
+    scalar f = pow3(gamma) + 2.7*gamma - 2.4*sqr(gamma);
 
-    vector momMax = m1*U1;
+    // mass-averaged temperature
-    vector momMin = m2*U2;
+    scalar Tave = (T1*m1 + T2*m2)/mTot;
 
-    // use mass-averaged temperature to calculate We number
+    // interpolate to find average surface tension
-    scalar Tm = (T1*m1 + T2*m2)/mTot;
+    scalar sigmaAve = sigma1 + (sigma2 - sigma1)*(Tave - T1)/(T2 - T1);
 
-    // interpolate the averaged surface tension
-    scalar sigma = sigma1 + (sigma2 - sigma1)*(Tm - T1)/(T2 - T1);
-
-    sigma = max(1.0e-6, sigma);
     scalar Vtot = m1/rho1 + m2/rho2;
-    scalar rho = mTot/Vtot;
+    scalar rhoAve = mTot/Vtot;
 
-    scalar dMean = sqrt(d1*d2);
+    scalar dAve = sqrt(d1*d2);
-    scalar WeColl = max(1.0e-12, 0.5*rho*magVRel*magVRel*dMean/sigma);
+    scalar WeColl = 0.5*rhoAve*sqr(magURel)*dAve/max(ROOTVSMALL, sigmaAve);
 
-    scalar coalesceProb = min(1.0, 2.4*f/WeColl);
+    scalar coalesceProb = min(1.0, 2.4*f/max(ROOTVSMALL, WeColl));
 
-    scalar prob = rndGen.sample01<scalar>();
+    scalar prob = this->owner().rndGen().template sample01<scalar>();
 
     // Coalescence
     if (prob < coalesceProb && coalescence_)
     {
         coalescence = true;
-        // How 'many' of the droplets coalesce
-        scalar nProb = prob*N2/N1;
 
-        // Conservation of mass, momentum and energy
+        // number of the droplets that coalesce
-        scalar m2Org = m2;
+        scalar nProb = prob*nP2/nP1;
-        scalar dm = N1*nProb*mdMin;
-        m2 -= dm;
-        scalar V2 = constant::mathematical::pi*pow3(d2)/6.0;
-        N2 = m2/(rho2*V2);
 
+        // conservation of mass, momentum and energy
         scalar m1Org = m1;
+        scalar m2Org = m2;
+
+        scalar dm = nP1*nProb*m2/scalar(nP2);
+
         m1 += dm;
-        T1 = (Tm*mTot - m2*T2)/m1;
+        m2 -= dm;
 
-        U1 =(momMax + (1.0 - m2/m2Org)*momMin)/m1;
+        p1.T() = (Tave*mTot - m2*T2)/m1;
 
-        // update the liquid mass fractions
+        p1.U() = (m1*U1 + (1.0 - m2/m2Org)*m2*U2)/m1;
-        Y1 = (m1Org*Y1 + dm*Y2)/m1;
+
+        p1.Y() = (m1Org*p1.Y() + dm*p2.Y())/m1;
+
+        p2.nParticle() = m2/(rho2*p2.volume());
     }
     // Grazing collision (no coalescence)
     else
@@ -271,28 +237,65 @@ bool Foam::ORourkeCollision<CloudType>::collideSorted
         // and these parcels should have coalesced
         gf = max(0.0, gf);
 
-        // gf -> 1 => v1p -> p1().U() ...
+        // gf -> 1 => v1p -> U1 ...
-        // gf -> 0 => v1p -> momentum/(m1+m2)
+        // gf -> 0 => v1p -> momentum/mTot
 
         vector mr = m1*U1 + m2*U2;
-        vector v1p = (mr + m2*gf*vRel)/(m1+m2);
+        vector v1p = (mr + m2*gf*URel)/mTot;
-        vector v2p = (mr - m1*gf*vRel)/(m1+m2);
+        vector v2p = (mr - m1*gf*URel)/mTot;
 
-        if (N1 < N2)
+        if (nP1 < nP2)
         {
-            U1 = v1p;
+            p1.U() = v1p;
-            U2 = (N1*v2p + (N2-N1)*U2)/N2;
+            p2.U() = (nP1*v2p + (nP2 - nP1)*U2)/nP2;
         }
         else
         {
-            U1 = (N2*v1p + (N1-N2)*U1)/N1;
+            p1.U() = (nP2*v1p + (nP1 - nP2)*U1)/nP1;
-            U2 = v2p;
+            p2.U() = v2p;
         }
-
     }
 
     return coalescence;
 }
 
 
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::ORourkeCollision<CloudType>::ORourkeCollision
+(
+    const dictionary& dict,
+    CloudType& owner,
+    const word& modelName
+)
+:
+    StochasticCollisionModel<CloudType>(dict, owner, modelName),
+    liquids_
+    (
+        owner.db().template lookupObject<SLGThermo>("SLGThermo").liquids()
+    ),
+    coalescence_(this->coeffDict().lookup("coalescence"))
+{}
+
+
+template<class CloudType>
+Foam::ORourkeCollision<CloudType>::ORourkeCollision
+(
+    const ORourkeCollision<CloudType>& cm
+)
+:
+    StochasticCollisionModel<CloudType>(cm),
+    liquids_(cm.liquids_),
+    coalescence_(cm.coalescence_)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::ORourkeCollision<CloudType>::~ORourkeCollision()
+{}
+
+
 // ************************************************************************* //

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

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,13 +34,14 @@ Description
 #define ORourkeCollision_H
 
 #include "StochasticCollisionModel.H"
+#include "liquidMixtureProperties.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 /*---------------------------------------------------------------------------*\
-                       Class ORourkeCollision Declaration
+                      Class ORourkeCollision Declaration
 \*---------------------------------------------------------------------------*/
 
 template<class CloudType>
@@ -48,10 +49,44 @@ class ORourkeCollision
 :
     public StochasticCollisionModel<CloudType>
 {
-private:
+protected:
+
+    // Protected Data
+
+        //- Convenience typedef to the cloud's parcel type
+        typedef typename CloudType::parcelType parcelType;
+
+        const liquidMixtureProperties& liquids_;
+
+        //- Coalescence activation switch
+        Switch coalescence_;
+
+
+    // Protected Member Functions
+
+        //- Main collision routine
+        virtual void collide(const scalar dt);
+
+        //- Collide parcels and return true if mass has changed
+        virtual bool collideParcels
+        (
+            const scalar dt,
+            parcelType& p1,
+            parcelType& p2,
+            scalar& m1,
+            scalar& m2
+        );
+
+        // 1 is the larger drop and 2 is the smaller
+        virtual bool collideSorted
+        (
+            const scalar dt,
+            parcelType& p1,
+            parcelType& p2,
+            scalar& m1,
+            scalar& m2
+        );
 
-    dictionary coeffsDict_;
-    Switch coalescence_;
 
 public:
 
@@ -62,7 +97,12 @@ public:
     // Constructors
 
         //- Construct from dictionary
-        ORourkeCollision(const dictionary& dict, CloudType& cloud);
+        ORourkeCollision
+        (
+            const dictionary& dict,
+            CloudType& cloud,
+            const word& modelName = typeName
+        );
 
         //- Construct copy
         ORourkeCollision(const ORourkeCollision<CloudType>& cm);
@@ -79,67 +119,6 @@ public:
 
     //- Destructor
     virtual ~ORourkeCollision();
-
-
-    // Member Functions
-
-        virtual bool update
-        (
-            const scalar dt,
-            cachedRandom& rndGen,
-            vector& pos1,
-            scalar& m1,
-            scalar& d1,
-            scalar& N1,
-            vector& U,
-            scalar& rho1,
-            scalar& T1,
-            scalarField& Y1,
-            const scalar sigma1,
-            const label celli,
-            const scalar voli,
-            vector& pos2,
-            scalar& m2,
-            scalar& d2,
-            scalar& N2,
-            vector& U2,
-            scalar& rho2,
-            scalar& T2,
-            scalarField& Y2,
-            const scalar sigma2,
-            const label cellj,
-            const scalar volj
-        ) const;
-
-
-        // 1 is the larger drop and 2 is the smaller
-        bool collideSorted
-        (
-            const scalar dt,
-            cachedRandom& rndGen,
-            vector& pos1,
-            scalar& m1,
-            scalar& d1,
-            scalar& N1,
-            vector& U,
-            scalar& rho1,
-            scalar& T1,
-            scalarField& Y1,
-            const scalar sigma1,
-            const label celli,
-            const scalar voli,
-            vector& pos2,
-            scalar& m2,
-            scalar& d2,
-            scalar& N2,
-            vector& U2,
-            scalar& rho2,
-            scalar& T2,
-            scalarField& Y2,
-            const scalar sigma2,
-            const label cellj,
-            const scalar volj
-        ) const;
 };
 
 

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

@@ -25,187 +25,96 @@ License
 
 #include "TrajectoryCollision.H"
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
 template<class CloudType>
-Foam::TrajectoryCollision<CloudType>::TrajectoryCollision
+void Foam::TrajectoryCollision<CloudType>::collide(const scalar dt)
-(
+{
-    const dictionary& dict,
+    ORourkeCollision<CloudType>::collide(dt);
-    CloudType& owner
+}
-)
-:
-    StochasticCollisionModel<CloudType>(dict, owner, typeName),
-    cSpace_(readScalar(this->coeffDict().lookup("cSpace"))),
-    cTime_(readScalar(this->coeffDict().lookup("cTime"))),
-    coalescence_(this->coeffDict().lookup("coalescence"))
-{}
 
 
 template<class CloudType>
-Foam::TrajectoryCollision<CloudType>::TrajectoryCollision
+bool Foam::TrajectoryCollision<CloudType>::collideParcels
-(
-    const TrajectoryCollision<CloudType>& cm
-)
-:
-    StochasticCollisionModel<CloudType>(cm),
-    cSpace_(cm.cSpace_),
-    cTime_(cm.cTime_),
-    coalescence_(cm.coalescence_)
-{}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-template<class CloudType>
-Foam::TrajectoryCollision<CloudType>::~TrajectoryCollision()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class CloudType>
-bool Foam::TrajectoryCollision<CloudType>::update
 (
     const scalar dt,
-    cachedRandom& rndGen,
+    parcelType& p1,
-    vector& pos1,
+    parcelType& p2,
     scalar& m1,
-    scalar& d1,
+    scalar& m2
-    scalar& N1,
+)
-    vector& U1,
-    scalar& rho1,
-    scalar& T1,
-    scalarField& Y1,
-    const scalar sigma1,
-    const label celli,
-    const scalar voli,
-    vector& pos2,
-    scalar& m2,
-    scalar& d2,
-    scalar& N2,
-    vector& U2,
-    scalar& rho2,
-    scalar& T2,
-    scalarField& Y2,
-    const scalar sigma2,
-    const label cellj,
-    const scalar volj
-) const
 {
     bool coalescence = false;
 
-    vector vRel = U1 - U2;
+    const vector& pos1 = p1.position();
+    const vector& pos2 = p2.position();
 
-    vector p = pos2 - pos1;
+    const vector& U1 = p1.U();
-    scalar dist = mag(p);
+    const vector& U2 = p2.U();
 
-    scalar vAlign = vRel & (p/(dist + SMALL));
+    vector URel = U1 - U2;
+
+    vector d = pos2 - pos1;
+    scalar magd = mag(d);
+
+    scalar vAlign = URel & (d/(magd + ROOTVSMALL));
 
     if (vAlign > 0)
     {
+        const scalar d1 = p1.d();
+        const scalar d2 = p2.d();
+
         scalar sumD = d1 + d2;
 
-        if (vAlign*dt > dist - 0.5*sumD)
+        if (vAlign*dt > magd - 0.5*sumD)
         {
-            scalar v1Mag = mag(U1);
+            scalar magU1 = mag(U1) + ROOTVSMALL;
-            scalar v2Mag = mag(U2);
+            scalar magU2 = mag(U2) + ROOTVSMALL;
-            vector nv1 = U1/v1Mag;
+            vector n1 = U1/magU1;
-            vector nv2 = U2/v2Mag;
+            vector n2 = U2/magU2;
 
-            scalar v1v2 = nv1 & nv2;
+            scalar n1n2 = n1 & n2;
-            scalar v1p = nv1 & p;
+            scalar n1d = n1 & d;
-            scalar v2p = nv2 & p;
+            scalar n2d = n2 & d;
 
-            scalar det = 1.0 - v1v2*v1v2;
+            scalar det = 1.0 - sqr(n1n2);
 
-            scalar alpha = 1.0e+20;
+            scalar alpha = GREAT;
-            scalar beta = 1.0e+20;
+            scalar beta = GREAT;
 
             if (mag(det) > 1.0e-4)
             {
-                beta = -(v2p - v1v2*v1p)/det;
+                beta = -(n2d - n1n2*n1d)/det;
-                alpha = v1p + v1v2*beta;
+                alpha = n1d + n1n2*beta;
             }
 
-            alpha /= v1Mag*dt;
+            alpha /= magU1*dt;
-            beta /= v2Mag*dt;
+            beta /= magU2*dt;
 
             // is collision possible within this timestep
-            if ((alpha>0) && (alpha<1.0) && (beta>0) && (beta<1.0))
+            if ((alpha > 0) && (alpha < 1.0) && (beta > 0) && (beta < 1.0))
             {
                 vector p1c = pos1 + alpha*U1*dt;
                 vector p2c = pos2 + beta*U2*dt;
 
-                scalar closestDist = mag(p1c-p2c);
+                scalar closestDist = mag(p1c - p2c);
 
                 scalar collProb =
                     pow(0.5*sumD/max(0.5*sumD, closestDist), cSpace_)
-                  * exp(-cTime_*mag(alpha-beta));
+                   *exp(-cTime_*mag(alpha - beta));
 
-                scalar xx = rndGen.sample01<scalar>();
+                scalar xx = this->owner().rndGen().template sample01<scalar>();
 
-                // collision occur
+                // collision occurs
-                if ((xx < collProb) && (m1 > VSMALL) && (m2 > VSMALL))
+                if (xx > collProb)
                 {
                     if (d1 > d2)
                     {
-                        coalescence = collideSorted
+                        coalescence = this->collideSorted(dt, p1, p2, m1, m2);
-                        (
-                            dt,
-                            rndGen,
-                            pos1,
-                            m1,
-                            d1,
-                            N1,
-                            U1,
-                            rho1,
-                            T1,
-                            Y1,
-                            sigma1,
-                            celli,
-                            voli,
-                            pos2,
-                            m2,
-                            d2,
-                            N2,
-                            U2,
-                            rho2,
-                            T2,
-                            Y2,
-                            sigma2,
-                            cellj,
-                            volj
-                        );
                     }
                     else
                     {
-                        coalescence = collideSorted
+                        coalescence = this->collideSorted(dt, p2, p1, m2, m1);
-                        (
-                            dt,
-                            rndGen,
-                            pos2,
-                            m2,
-                            d2,
-                            N2,
-                            U2,
-                            rho2,
-                            T2,
-                            Y2,
-                            sigma2,
-                            cellj,
-                            volj,
-                            pos1,
-                            m1,
-                            d1,
-                            N1,
-                            U1,
-                            rho1,
-                            T1,
-                            Y1,
-                            sigma1,
-                            celli,
-                            voli
-                        );
                     }
                 }
             }
@@ -216,128 +125,38 @@ bool Foam::TrajectoryCollision<CloudType>::update
 }
 
 
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
 template<class CloudType>
-bool Foam::TrajectoryCollision<CloudType>::collideSorted
+Foam::TrajectoryCollision<CloudType>::TrajectoryCollision
 (
-    const scalar dt,
+    const dictionary& dict,
-    cachedRandom& rndGen,
+    CloudType& owner
-    vector& pos1,
+)
-    scalar& m1,
+:
-    scalar& d1,
+    ORourkeCollision<CloudType>(dict, owner, typeName),
-    scalar& N1,
+    cSpace_(readScalar(this->coeffDict().lookup("cSpace"))),
-    vector& U1,
+    cTime_(readScalar(this->coeffDict().lookup("cTime")))
-    scalar& rho1,
+{}
-    scalar& T1,
-    scalarField& Y1,
-    const scalar sigma1,
-    const label celli,
-    const scalar voli,
-    vector& pos2,
-    scalar& m2,
-    scalar& d2,
-    scalar& N2,
-    vector& U2,
-    scalar& rho2,
-    scalar& T2,
-    scalarField& Y2,
-    const scalar sigma2,
-    const label cellj,
-    const scalar volj
-) const
-{
-    bool coalescence = false;
 
-    vector vRel = U1 - U2;
 
-    scalar mdMin = m2/N2;
+template<class CloudType>
+Foam::TrajectoryCollision<CloudType>::TrajectoryCollision
+(
+    const TrajectoryCollision<CloudType>& cm
+)
+:
+    ORourkeCollision<CloudType>(cm),
+    cSpace_(cm.cSpace_),
+    cTime_(cm.cTime_)
+{}
 
-    scalar mTot = m1 + m2;
 
-    scalar gamma = d1/max(d2, 1.0e-12);
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-    scalar f = gamma*gamma*gamma + 2.7*gamma - 2.4*gamma*gamma;
 
-    vector momMax = m1*U1;
+template<class CloudType>
-    vector momMin = m2*U2;
+Foam::TrajectoryCollision<CloudType>::~TrajectoryCollision()
-
+{}
-    // use mass-averaged temperature to calculate We number
-    scalar Tm = (T1*m1 + T2*m2)/mTot;
-
-    // and mass averaged fractions ...
-    //scalarField Yav((m1*Y1 + m2*Y2)/mTot;
-
-    // interpolate the averaged surface tension
-    scalar sigma = sigma1 + (sigma2 - sigma1)*(Tm - T1)/(T2 - T1);
-
-    sigma = max(1.0e-6, sigma);
-    scalar Vtot = m1/rho1 + m2/rho2;
-    scalar rho = mTot/Vtot;
-
-    scalar dMean = sqrt(d1*d2);
-    scalar WeColl = max(1.0e-12, 0.5*rho*magSqr(vRel)*dMean/sigma);
-
-    scalar coalesceProb = min(1.0, 2.4*f/WeColl);
-
-    scalar prob = rndGen.sample01<scalar>();
-
-    // Coalescence
-    if ( prob < coalesceProb && coalescence_)
-    {
-        coalescence = true;
-        // How 'many' of the droplets coalesce
-        scalar nProb = prob*N2/N1;
-
-        // Conservation of mass, momentum and energy
-        scalar m2Org = m2;
-        scalar dm = N1*nProb*mdMin;
-        m2 -= dm;
-        scalar V2 = constant::mathematical::pi*pow3(d2)/6.0;
-        N2 = m2/(rho2*V2);
-
-        scalar m1Org = m1;
-        m1 += dm;
-        T1 = (Tm*mTot - m2*T2)/m1;
-
-        U1 =(momMax + (1.0 - m2/m2Org)*momMin)/m1;
-
-        // update the liquid mass fractions
-        Y1 = (m1Org*Y1 + dm*Y2)/m1;
-    }
-    // Grazing collision (no coalescence)
-    else
-    {
-        scalar gf = sqrt(prob) - sqrt(coalesceProb);
-        scalar denom = 1.0 - sqrt(coalesceProb);
-        if (denom < 1.0e-5)
-        {
-            denom = 1.0;
-        }
-        gf /= denom;
-
-        // if gf negative, this means that coalescence is turned off
-        // and these parcels should have coalesced
-        gf = max(0.0, gf);
-
-        // gf -> 1 => v1p -> p1().U() ...
-        // gf -> 0 => v1p -> momentum/(m1 + m2)
-
-        vector mr = m1*U1 + m2*U2;
-        vector v1p = (mr + m2*gf*vRel)/(m1 + m2);
-        vector v2p = (mr - m1*gf*vRel)/(m1 + m2);
-
-        if (N1 < N2)
-        {
-            U1 = v1p;
-            U2 = (N1*v2p + (N2 - N1)*U2)/N2;
-        }
-        else
-        {
-            U1 = (N2*v1p + (N1 - N2)*U1)/N1;
-            U2 = v2p;
-        }
-    }
-
-    return coalescence;
-}
 
 
 // ************************************************************************* //

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

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,35 +25,57 @@ Class
     Foam::TrajectoryCollision
 
 Description
-    Trajectory collision model by N. Nordin.
+    Trajectory collision model by N. Nordin, based on O'Rourke's collision
+    model
 
 \*---------------------------------------------------------------------------*/
 
 #ifndef TrajectoryCollision_H
 #define TrajectoryCollision_H
 
-#include "StochasticCollisionModel.H"
+#include "ORourkeCollision.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 /*---------------------------------------------------------------------------*\
-                       Class TrajectoryCollision Declaration
+                     Class TrajectoryCollision Declaration
 \*---------------------------------------------------------------------------*/
 
 template<class CloudType>
 class TrajectoryCollision
 :
-    public StochasticCollisionModel<CloudType>
+    public ORourkeCollision<CloudType>
 {
-private:
+protected:
 
-    // Private data
+    // Protected Data
 
+        //- Convenience typedef to the cloud's parcel type
+        typedef typename CloudType::parcelType parcelType;
+
+        //- Space coefficient
         scalar cSpace_;
+
+        //- Time coefficient
         scalar cTime_;
-        Switch coalescence_;
+
+
+    // Protected Member Functions
+
+        //- Main collision routine
+        virtual void collide(const scalar dt);
+
+        //- Collide parcels and return true if mass has changed
+        virtual bool collideParcels
+        (
+            const scalar dt,
+            parcelType& p1,
+            parcelType& p2,
+            scalar& m1,
+            scalar& m2
+        );
 
 
 public:
@@ -82,66 +104,6 @@ public:
 
     //- Destructor
     virtual ~TrajectoryCollision();
-
-
-    // Member Functions
-
-        virtual bool update
-        (
-            const scalar dt,
-            cachedRandom& rndGen,
-            vector& pos1,
-            scalar& m1,
-            scalar& d1,
-            scalar& N1,
-            vector& U,
-            scalar& rho1,
-            scalar& T1,
-            scalarField& Y1,
-            const scalar sigma1,
-            const label celli,
-            const scalar voli,
-            vector& pos2,
-            scalar& m2,
-            scalar& d2,
-            scalar& N2,
-            vector& U2,
-            scalar& rho2,
-            scalar& T2,
-            scalarField& Y2,
-            const scalar sigma2,
-            const label cellj,
-            const scalar volj
-        ) const;
-
-        // 1 is the larger drop and 2 is the smaller
-        bool collideSorted
-        (
-            const scalar dt,
-            cachedRandom& rndGen,
-            vector& pos1,
-            scalar& m1,
-            scalar& d1,
-            scalar& N1,
-            vector& U,
-            scalar& rho1,
-            scalar& T1,
-            scalarField& Y1,
-            const scalar sigma1,
-            const label celli,
-            const scalar voli,
-            vector& pos2,
-            scalar& m2,
-            scalar& d2,
-            scalar& N2,
-            vector& U2,
-            scalar& rho2,
-            scalar& T2,
-            scalarField& Y2,
-            const scalar sigma2,
-            const label cellj,
-            const scalar volj
-        ) const;
 };