Merge branch 'master' into cvm

.gitignore

@@ -60,8 +60,8 @@ doc/[Dd]oxygen/man
 # untracked configuration files
 /etc/prefs.csh
 /etc/prefs.sh
-/etc/config/*.csh
+/etc/config/prefs.csh
-/etc/config/*.sh
+/etc/config/prefs.sh
 
 # source packages - anywhere
 *.tar.bz2

ReleaseNotes-dev

@@ -126,7 +126,9 @@
     globalPointPatch. Moving mesh cases can now be run non-parallel and
     continued in parallel and reconstructed without any limitation.
 *** *New* compact binary I/O for faces and cells.
-    This speeds up reading/writing meshes in binary.
+    This speeds up reading/writing meshes in binary. Binary mesh reading
+    is backwards (but not forwards) compatible. Use ascii mesh format or
+    foamFormatConvert.
 *** *Updated* runTimeModifiable
     + user selectable model to use for checking run-time modifiable
       dictionaries (see also doc/changes/inotify.txt):
@@ -139,8 +141,9 @@
     + on linux optionally uses inotify instead of time stamps - more efficient
       for large numbers of monitored files. No more fileModificationSkew needed.
     + single integer reduction instead of one reduction per monitored file.
-    + only files that can be re-read are being checked. Drastic reduction of
+    + only files that can be re-read are being checked by specifying
-      number of files to check.
+      in the IOobject constructor MUST_READ_IF_MODIFIED instead of
+      MUST_READ. Drastic reduction of number of files to check.
 *** *New* #codeStream dictionary entry
     Uses dynamic compilation of OpenFOAM C++ code to construct dictionary.
     E.g. in blockMeshDict:
@@ -241,9 +244,11 @@
       - works in parallel
     + =snappyHexMesh=:
       + extrude across multi-processor boundaries
-      + preserve faceZones during layering
+      + preserve faceZones shape during layering
-      + combining patch faces after snapping
+      + combining coincident patch faces is now default after snapping
       + *Warning*:
+            - snapControls::tolerance setting fixed w.r.t. 17x. Is the
+              multiplication to calculate the local search distance for nearest.
             - minMedianAxisAngle angle fixed w.r.t. 17x. Set to
               90 to get same behaviour as 130 in 17x.
             - nGrow did not work in 17x. Set to 0
@@ -308,6 +313,8 @@
     + multipleBoxes, hotBoxes, panel, evaporationTest
   + =interDyMFoam= tutorials:
     + testTubeMixer: showcases =solidBodyMotionFunction=
+  + =snappyHexMesh= tutorials:
+    + flange: demonstration of feature lines in snappyHexMesh
 
 * Other
   + compilable with =clang=

applications/solvers/basic/potentialFoam/potentialFoam.C

@@ -49,6 +49,10 @@ int main(int argc, char *argv[])
 
     Info<< nl << "Calculating potential flow" << endl;
 
+    // Since solver contains no time loop it would never execute
+    // function objects so do it ourselves.
+    runTime.functionObjects().start();
+
     adjustPhi(phi, U, p);
 
     for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
@@ -99,6 +103,9 @@ int main(int argc, char *argv[])
         p.write();
     }
 
+    runTime.functionObjects().end();
+
+
     Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
         << "  ClockTime = " << runTime.elapsedClockTime() << " s"
         << nl << endl;

applications/solvers/lagrangian/sprayFoam/Make/files

@@ -0,0 +1,3 @@
+sprayFoam.C
+
+EXE = $(FOAM_APPBIN)/sprayFoam

applications/solvers/lagrangian/sprayFoam/Make/options

@@ -0,0 +1,50 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I${LIB_SRC}/meshTools/lnInclude \
+    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
+    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
+    -I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
+    -I$(LIB_SRC)/lagrangian/spray/lnInclude \
+    -I$(LIB_SRC)/lagrangian/distributionModels/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/properties/liquidProperties/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/properties/liquidMixtureProperties/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/properties/solidProperties/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/properties/solidMixtureProperties/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/thermophysicalFunctions/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/SLGThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/chemistryModel/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/radiationModels/lnInclude \
+    -I$(LIB_SRC)/ODE/lnInclude \
+    -I$(LIB_SRC)/regionModels/regionModel/lnInclude \
+    -I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(FOAM_SOLVERS)/lagrangian/reactingParcelFoam
+
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lmeshTools \
+    -lcompressibleTurbulenceModel \
+    -lcompressibleRASModels \
+    -lcompressibleLESModels \
+    -llagrangian \
+    -llagrangianIntermediate \
+    -llagrangianSpray \
+    -lspecie \
+    -lbasicThermophysicalModels \
+    -lliquidProperties \
+    -lliquidMixtureProperties \
+    -lsolidProperties \
+    -lsolidMixtureProperties \
+    -lthermophysicalFunctions \
+    -lreactionThermophysicalModels \
+    -lSLGThermo \
+    -lchemistryModel \
+    -lradiationModels \
+    -lODE \
+    -lregionModels \
+    -lsurfaceFilmModels \
+    -lsampling

applications/solvers/lagrangian/sprayFoam/chemistry.H

@@ -0,0 +1,44 @@
+if (chemistry.chemistry())
+{
+    Info<< "Solving chemistry" << endl;
+
+    chemistry.solve
+    (
+        runTime.value() - runTime.deltaTValue(),
+        runTime.deltaTValue()
+    );
+
+    // turbulent time scale
+    if (turbulentReaction)
+    {
+        tmp<volScalarField> tepsilon(turbulence->epsilon());
+        const volScalarField& epsilon = tepsilon();
+        tmp<volScalarField> tmuEff(turbulence->muEff());
+        const volScalarField& muEff = tmuEff();
+        tmp<volScalarField> ttc(chemistry.tc());
+        const volScalarField& tc = ttc();
+
+        forAll(epsilon, i)
+        {
+            if (epsilon[i] > 0)
+            {
+                // Chalmers PaSR model
+                scalar tk = Cmix.value()*Foam::sqrt(muEff[i]/rho[i]/epsilon[i]);
+                kappa[i] =
+                    (runTime.deltaTValue() + tc[i])
+                   /(runTime.deltaTValue() + tc[i] + tk);
+            }
+            else
+            {
+                // Return to laminar combustion
+                kappa[i] = 1.0;
+            }
+        }
+    }
+    else
+    {
+        kappa = 1.0;
+    }
+
+    chemistrySh = kappa*chemistry.Sh()();
+}

applications/solvers/lagrangian/sprayFoam/createClouds.H

@@ -0,0 +1,9 @@
+Info<< "\nConstructing reacting cloud" << endl;
+basicSprayCloud parcels
+(
+    "sprayCloud",
+    rho,
+    U,
+    g,
+    slgThermo
+);

applications/solvers/lagrangian/sprayFoam/sprayFoam.C

@@ -0,0 +1,119 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 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/>.
+
+Application
+    sprayFoam
+
+Description
+    Transient PIMPLE solver for compressible, laminar or turbulent flow with
+    spray parcels.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "hCombustionThermo.H"
+#include "turbulenceModel.H"
+#include "basicSprayCloud.H"
+#include "psiChemistryModel.H"
+#include "chemistrySolver.H"
+#include "radiationModel.H"
+#include "SLGThermo.H"
+#include "pimpleControl.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    #include "setRootCase.H"
+
+    #include "createTime.H"
+    #include "createMesh.H"
+    #include "readChemistryProperties.H"
+    #include "readGravitationalAcceleration.H"
+    #include "createFields.H"
+    #include "createClouds.H"
+    #include "createRadiationModel.H"
+    #include "initContinuityErrs.H"
+    #include "readTimeControls.H"
+    #include "compressibleCourantNo.H"
+    #include "setInitialDeltaT.H"
+
+    pimpleControl pimple(mesh);
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    Info<< "\nStarting time loop\n" << endl;
+
+    while (runTime.run())
+    {
+        #include "readTimeControls.H"
+        #include "compressibleCourantNo.H"
+        #include "setDeltaT.H"
+
+        runTime++;
+
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+
+        parcels.evolve();
+
+        #include "chemistry.H"
+        #include "rhoEqn.H"
+
+        // --- Pressure-velocity PIMPLE corrector loop
+        for (pimple.start(); pimple.loop(); pimple++)
+        {
+            #include "UEqn.H"
+            #include "YEqn.H"
+            #include "hsEqn.H"
+
+            // --- PISO loop
+            for (int corr=0; corr<pimple.nCorr(); corr++)
+            {
+                #include "pEqn.H"
+            }
+
+            if (pimple.turbCorr())
+            {
+                turbulence->correct();
+            }
+        }
+
+        rho = thermo.rho();
+
+        if (runTime.write())
+        {
+            chemistry.dQ()().write();
+        }
+
+        Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
+            << "  ClockTime = " << runTime.elapsedClockTime() << " s"
+            << nl << endl;
+    }
+
+    Info<< "End\n" << endl;
+
+    return(0);
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/createShellMesh.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2010-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2010-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -453,6 +453,7 @@ void Foam::createShellMesh::setRefinement
             label region0 = pointRegions_[eFaces[0]][fp0];
             label region1 = pointRegions_[eFaces[0]][fp1];
 
+            // Pick up points with correct normal
             if (layerI == 0)
             {
                 newF[0] = f[fp0];
@@ -468,6 +469,22 @@ void Foam::createShellMesh::setRefinement
                 newF[3] = addedPoints[nLayers*region0+layerI];
             }
 
+            // Optionally rotate so e[0] is always 0th vertex. Note that
+            // this normally is automatically done by coupled face ordering
+            // but with NOORDERING we have to do it ourselves.
+            if (f[fp0] != e[0])
+            {
+                // rotate one back to get newF[1] (originating from e[0])
+                // into newF[0]
+                label v0 = newF[0];
+                for (label i = 0; i < newF.size()-1; i++)
+                {
+                    newF[i] = newF[newF.fcIndex(i)];
+                }
+                newF.last() = v0;
+            }
+
+
             label minCellI = addedCells[nLayers*eFaces[0]+layerI];
             label maxCellI;
             label patchI;
@@ -569,6 +586,21 @@ void Foam::createShellMesh::setRefinement
                         newF[3] = addedPoints[nLayers*region0+layerI];
                     }
 
+
+                    // Optionally rotate so e[0] is always 0th vertex. Note that
+                    // this normally is automatically done by coupled face
+                    // ordering but with NOORDERING we have to do it ourselves.
+                    if (f[fp0] != e[0])
+                    {
+                        // rotate one back to get newF[1] (originating
+                        // from e[0]) into newF[0].
+                        label v0 = newF[0];
+                        for (label i = 0; i < newF.size()-1; i++)
+                        {
+                            newF[i] = newF[newF.fcIndex(i)];
+                        }
+                        newF.last() = v0;
+                    }
                     ////if (ePatches.size() == 0)
                     //{
                     //    Pout<< "Adding from MULTI face:"

applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict

@@ -220,7 +220,7 @@ snapControls
     //- Maximum relative distance for points to be attracted by surface.
     //  True distance is this factor times local maximum edge length.
     // Note: changed(corrected) w.r.t 17x! (17x used 2* tolerance)
-    tolerance 2.0;
+    tolerance 1.0;
 
     //- Number of mesh displacement relaxation iterations.
     nSolveIter 30;
@@ -228,6 +228,10 @@ snapControls
     //- Maximum number of snapping relaxation iterations. Should stop
     //  before upon reaching a correct mesh.
     nRelaxIter 5;
+
+    //- Highly experimental and wip: number of feature edge snapping
+    //  iterations. Leave out altogether to disable.
+    //nFeatureSnapIter 10;
 }
 
 
@@ -258,6 +262,9 @@ addLayersControls
 
 
     //- Wanted thickness of final added cell layer. If multiple layers
+    //  is the
+    //  thickness of the layer furthest away from the wall.
+    //  Relative to undistorted size of cell outside layer.
     //  is the thickness of the layer furthest away from the wall.
     //  See relativeSizes parameter.
     finalLayerThickness 0.3;
@@ -410,7 +417,7 @@ debug 0;
 
 // Merge tolerance. Is fraction of overall bounding box of initial mesh.
 // Note: the write tolerance needs to be higher than this.
-mergeTolerance 1E-6;
+mergeTolerance 1e-6;
 
 
 // ************************************************************************* //

applications/utilities/miscellaneous/foamFormatConvert/foamFormatConvert.C

@@ -144,10 +144,30 @@ bool writeZones(const word& name, const fileName& meshDir, Time& runTime)
 int main(int argc, char *argv[])
 {
     timeSelector::addOptions();
+    argList::addBoolOption
+    (
+        "noConstant",
+        "exclude the 'constant/' dir in the times list"
+    );
+
 #   include "addRegionOption.H"
 #   include "setRootCase.H"
+
+    // enable noConstant by switching
+    if (!args.optionFound("noConstant"))
+    {
+        args.setOption("constant", "");
+    }
+    else
+    {
+        args.unsetOption("constant");
+        Info<< "Excluding the constant directory." << nl << endl;
+    }
+
+
 #   include "createTime.H"
 
+
     // Make sure we do not use the master-only reading since we read
     // fields (different per processor) as dictionaries.
     regIOobject::fileModificationChecking = regIOobject::timeStamp;

applications/utilities/parallelProcessing/redistributeMeshPar/redistributeMeshPar.C

@@ -98,6 +98,44 @@ autoPtr<fvMesh> createMesh
             xferCopy(labelList()),
             false
         );
+        // Add some dummy zones so upon reading it does not read them
+        // from the undecomposed case. Should be done as extra argument to
+        // regIOobject::readStream?
+        List<pointZone*> pz
+        (
+            1,
+            new pointZone
+            (
+                "dummyPointZone",
+                labelList(0),
+                0,
+                dummyMesh.pointZones()
+            )
+        );
+        List<faceZone*> fz
+        (
+            1,
+            new faceZone
+            (
+                "dummyFaceZone",
+                labelList(0),
+                boolList(0),
+                0,
+                dummyMesh.faceZones()
+            )
+        );
+        List<cellZone*> cz
+        (
+            1,
+            new cellZone
+            (
+                "dummyCellZone",
+                labelList(0),
+                0,
+                dummyMesh.cellZones()
+            )
+        );
+        dummyMesh.addZones(pz, fz, cz);
         //Pout<< "Writing dummy mesh to " << dummyMesh.polyMesh::objectPath()
         //    << endl;
         dummyMesh.write();
@@ -239,7 +277,11 @@ autoPtr<fvMesh> createMesh
 
     if (!haveMesh)
     {
-        // Add the zones
+        // Add the zones. Make sure to remove the old dummy ones first
+        mesh.pointZones().clear();
+        mesh.faceZones().clear();
+        mesh.cellZones().clear();
+
         List<pointZone*> pz(pointZoneNames.size());
         forAll(pointZoneNames, i)
         {
@@ -389,6 +431,12 @@ void printMeshData(const polyMesh& mesh)
 
     globalIndex globalBoundaryFaces(mesh.nFaces()-mesh.nInternalFaces());
 
+    label maxProcCells = 0;
+    label totProcFaces = 0;
+    label maxProcPatches = 0;
+    label totProcPatches = 0;
+    label maxProcFaces = 0;
+
     for (label procI = 0; procI < Pstream::nProcs(); procI++)
     {
         Info<< endl
@@ -413,7 +461,32 @@ void printMeshData(const polyMesh& mesh)
             << "    Number of processor faces = " << nProcFaces << nl
             << "    Number of boundary faces = "
             << globalBoundaryFaces.localSize(procI) << endl;
+
+        maxProcCells = max(maxProcCells, globalCells.localSize(procI));
+        totProcFaces += nProcFaces;
+        totProcPatches += nei.size();
+        maxProcPatches = max(maxProcPatches, nei.size());
+        maxProcFaces = max(maxProcFaces, nProcFaces);
     }
+
+    // Stats
+
+    scalar avgProcCells = scalar(globalCells.size())/Pstream::nProcs();
+    scalar avgProcPatches = scalar(totProcPatches)/Pstream::nProcs();
+    scalar avgProcFaces = scalar(totProcFaces)/Pstream::nProcs();
+
+    Info<< nl
+        << "Number of processor faces = " << totProcFaces/2 << nl
+        << "Max number of cells = " << maxProcCells
+        << " (" << 100.0*(maxProcCells-avgProcCells)/avgProcCells
+        << "% above average " << avgProcCells << ")" << nl
+        << "Max number of processor patches = " << maxProcPatches
+        << " (" << 100.0*(maxProcPatches-avgProcPatches)/avgProcPatches
+        << "% above average " << avgProcPatches << ")" << nl
+        << "Max number of faces between processors = " << maxProcFaces
+        << " (" << 100.0*(maxProcFaces-avgProcFaces)/avgProcFaces
+        << "% above average " << avgProcFaces << ")" << nl
+        << endl;
 }
 
 
@@ -641,6 +714,16 @@ int main(int argc, char *argv[])
     );
 #   include "setRootCase.H"
 
+    if (env("FOAM_SIGFPE"))
+    {
+        WarningIn(args.executable())
+            << "Detected floating point exception trapping (FOAM_SIGFPE)."
+            << " This might give" << nl
+            << "    problems when mapping fields. Switch it off in case"
+            << " of problems." << endl;
+    }
+
+
     // Create processor directory if non-existing
     if (!Pstream::master() && !isDir(args.path()))
     {
@@ -906,7 +989,7 @@ int main(int argc, char *argv[])
 
     // Debugging: Create additional volField that will be mapped.
     // Used to test correctness of mapping
-    volVectorField mapCc("mapCc", 1*mesh.C());
+    //volVectorField mapCc("mapCc", 1*mesh.C());
 
     // Global matching tolerance
     const scalar tolDim = getMergeDistance
@@ -948,7 +1031,7 @@ int main(int argc, char *argv[])
 
 
     // Debugging: test mapped cellcentre field.
-    compareFields(tolDim, mesh.C(), mapCc);
+    //compareFields(tolDim, mesh.C(), mapCc);
 
     // Print nice message
     // ~~~~~~~~~~~~~~~~~~

bin/foamRunTutorials

@@ -3,7 +3,7 @@
 # =========                 |
 # \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
 #  \\    /   O peration     |
-#   \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+#   \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
 #    \\/     M anipulation  |
 #------------------------------------------------------------------------------
 # License
@@ -31,6 +31,39 @@
 #
 #------------------------------------------------------------------------------
 
+#------------------------------------------------------------------------------
+# Select the version of make to be used
+#------------------------------------------------------------------------------
+
+# normally use "make"
+make="make"
+
+# set WM_NCOMPPROCS automatically when both WM_HOSTS and WM_SCHEDULER are set
+if [ -z "$WM_NCOMPPROCS" -a -n "$WM_HOSTS" -a -n "$WM_SCHEDULER" ]
+then
+    WM_NCOMPPROCS=$(wmakeScheduler -count)
+    [ $? -eq 0 ] || unset WM_NCOMPPROCS
+fi
+
+if [ "$WM_NCOMPPROCS" ]
+then
+    if [ "$WM_NCOMPPROCS" -gt 1 -a ! "$MAKEFLAGS" ]
+    then
+        lockDir=$HOME/.$WM_PROJECT/.wmake
+
+        if [ -d $lockDir ]
+        then
+            rm -f $lockDir/*
+        else
+            mkdir -p $lockDir
+        fi
+
+        make="make --no-print-directory -j "$WM_NCOMPPROCS
+    fi
+fi
+
+
+
 # Source tutorial functions
 . $WM_PROJECT_DIR/bin/tools/RunFunctions
 
@@ -62,13 +95,15 @@ else
         fi
     done
     # Recurse to subdirectories
-    for caseName in *
+    #for caseName in *
-    do
+    #do
-        if [ -d $caseName ]
+    #    if [ -d $caseName ]
-        then
+    #    then
-            ( cd $caseName && $thisScript )
+    #        ( cd $caseName && $thisScript )
-        fi
+    #    fi
-    done
+    #done
+    FOAM_TARGETS=$(for d in *; do [ -d "$d" ] && echo "$d"; done | xargs)
+    $make -k -f $WM_PROJECT_DIR/bin/tools/MakefileDirs FOAM_TARGETS="$FOAM_TARGETS" FOAM_APP="$WM_SCHEDULER $thisScript"
 fi
 
 #------------------------------------------------------------------------------

bin/paraFoam

@@ -37,7 +37,7 @@ usage() {
     while [ "$#" -ge 1 ]; do echo "$1"; shift; done
     cat<<USAGE
 
-Usage: ${0##*/} [OPTION]
+Usage: ${0##*/} [OPTION] [PARAVIEW_OPTION]
 options:
   -block            use blockMesh reader  (uses .blockMesh extension)
   -builtin          use VTK builtin OpenFOAM reader  (uses .foam extension)
@@ -47,6 +47,9 @@ options:
   -touchAll         create .blockMesh, .OpenFOAM files (and for all regions)
   -help             print the usage
 
+
+paraview options start with a double dashes
+
 * start paraview $ParaView_VERSION with the OpenFOAM libraries
 
 USAGE
@@ -57,7 +60,7 @@ USAGE
 # to clean up
 unset FOAM_ABORT
 
-unset regionName touchOpt
+unset regionName optTouch
 
 # reader extension
 extension=OpenFOAM
@@ -88,19 +91,48 @@ do
         shift 2
         ;;
     -touch)
-        touchOpt=true
+        optTouch=true
         shift
         ;;
     -touchAll)
-        touchOpt=all
+        optTouch=all
         shift
         ;;
+    --)
+        shift
+        break    # stop here, treat balance as paraview options
+        ;;
+    --*)
+        break    # stop here, treat this and balance as paraview options
+        ;;
     *)
         usage "unknown option/argument: '$*'"
         ;;
     esac
 done
 
+
+#
+# check for --data=... argument
+#
+hasDataArg()
+{
+    hasData=false
+    while [ "$#" -gt 0 ]
+    do
+        case "$1" in
+        (--data=*)
+            hasData=true
+            break
+            ;;
+        esac
+        shift
+    done
+}
+
+hasDataArg $@
+
+
 # get a sensible caseName from the directory name
 caseName=${PWD##*/}
 caseFile="$caseName.$extension"
@@ -112,7 +144,7 @@ then
     fvControls="$fvControls/$regionName"
 fi
 
-case "${touchOpt:-false}" in
+case "${optTouch:-false}" in
 all)
     extension=OpenFOAM
     if [ -f constant/polyMesh/blockMeshDict ]
@@ -149,33 +181,56 @@ case "$caseName" in
 esac
 
 
-#
+if [ "${hasData:-false}" = true ]
-# check existence of essential files
+then
-#
-case $extension in
-blockMesh)
-    for check in system/controlDict constant/polyMesh/blockMeshDict
-    do
-        [ -s "$parentDir/$check" ] || usage "file does not exist:  '$parentDir/$check'"
-    done
-    ;;
 
-builtin | OpenFOAM)
+    # has --data=.., send directly to paraview
-    for check in system/controlDict $fvControls/fvSchemes $fvControls/fvSolution
+    exec paraview "$@"
-    do
-        [ -s "$parentDir/$check" ] || usage "file does not exist:  '$parentDir/$check'"
-    done
-    ;;
-esac
 
+else
 
-# only create/remove caseFile if it didn't already exist
+    # check existence of essential files
-[ -e $caseFile ] || {
+    warn="WARN file does not exist:"
-    trap "rm -f $caseFile 2>/dev/null; exit 0" EXIT TERM INT
+    case $extension in
-    touch "$caseFile"
+    blockMesh)
-    echo "created temporary '$caseFile'"
+        for check in \
-}
+            system/controlDict \
+            constant/polyMesh/blockMeshDict \
+            ;
+        do
+            [ -s "$parentDir/$check" ] || {
+                [ -n "$warn" ] && echo "$warn" 1>&2
+                echo "    $parentDir/$check" 1>&2
+                unset warn
+            }
+        done
+        ;;
+
+    builtin | OpenFOAM)
+        for check in \
+            system/controlDict \
+            $fvControls/fvSchemes \
+            $fvControls/fvSolution \
+            ;
+        do
+            [ -s "$parentDir/$check" ] || {
+                [ -n "$warn" ] && echo "$warn" 1>&2
+                echo "    $parentDir/$check" 1>&2
+                unset warn
+            }
+        done
+        ;;
+    esac
+
+    # only create/remove caseFile if it didn't already exist
+    [ -e $caseFile ] || {
+        trap "rm -f $caseFile 2>/dev/null; exit 0" EXIT TERM INT
+        touch "$caseFile"
+        echo "created temporary '$caseFile'"
+    }
+
+    paraview --data="$caseFile" "$@"
+fi
 
-paraview --data="$caseFile"
 
 #------------------------------------------------------------------------------

bin/tools/MakefileDirs

@@ -0,0 +1,42 @@
+#-------------------------------*- makefile -*---------------------------------
+# =========                 |
+# \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+#  \\    /   O peration     |
+#   \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
+#    \\/     M anipulation  |
+#------------------------------------------------------------------------------
+# License
+#     This file is part of OpenFOAM.
+#
+#     OpenFOAM is free software: you can redistribute it and/or modify it
+#     under the terms of the GNU General Public License as published by
+#     the Free Software Foundation, either version 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/>.
+#
+# File
+#     MakefileDirs
+#
+# Description
+#     Makefile used by
+#         foamRunTutorials
+#     to call some script in subdirectories.
+#
+#------------------------------------------------------------------------------
+
+.PHONY: application $(FOAM_TARGETS)
+
+application: $(FOAM_TARGETS)
+
+$(FOAM_TARGETS):
+	@(cd $@ && $(FOAM_APP))
+
+
+#------------------------------------------------------------------------------

bin/tools/foamConfigurePaths

@@ -131,7 +131,7 @@ do
         paraviewInstall="$2"
         # replace ParaView_DIR=...
         _inlineSed \
-            etc/apps/paraview3/bashrc \
+            etc/config/paraview.sh \
             '/^[^#]/s@ParaView_DIR=.*@ParaView_DIR='"$paraviewInstall@" \
              "Replacing ParaView_DIR setting by '$paraviewInstall'"
         shift 2

etc/bashrc

@@ -120,7 +120,12 @@ export WM_THIRD_PARTY_DIR=$WM_PROJECT_INST_DIR/ThirdParty-$WM_PROJECT_VERSION
 # Location of site-specific templates etc
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # unset is equivalent to $WM_PROJECT_INST_DIR/site
-unset WM_PROJECT_SITE
+if [ -d "$WM_PROJECT_SITE" ]
+then
+    export WM_PROJECT_SITE
+else
+    unset WM_PROJECT_SITE
+fi
 
 # Location of user files
 # ~~~~~~~~~~~~~~~~~~~~~~
@@ -177,7 +182,7 @@ _foamEval()
 _foamSource `$WM_PROJECT_DIR/bin/foamEtcFile prefs.sh`
 
 # Evaluate command-line parameters and record settings for later
-# these can be used to set/unset values, or specify prefs files
+# these can be used to set/unset values, or specify alternative pref files
 export FOAM_SETTINGS="$@"
 _foamEval $@
 
@@ -200,14 +205,14 @@ export PATH LD_LIBRARY_PATH MANPATH
 
 # Source project setup files
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~
-_foamSource $WM_PROJECT_DIR/etc/settings.sh
+_foamSource $WM_PROJECT_DIR/etc/config/settings.sh
-_foamSource $WM_PROJECT_DIR/etc/aliases.sh
+_foamSource $WM_PROJECT_DIR/etc/config/aliases.sh
 
 
 # Source user setup files for optional packages
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-_foamSource `$WM_PROJECT_DIR/bin/foamEtcFile apps/paraview3/bashrc`
+_foamSource `$WM_PROJECT_DIR/bin/foamEtcFile config/paraview.sh`
-_foamSource `$WM_PROJECT_DIR/bin/foamEtcFile apps/ensight/bashrc`
+_foamSource `$WM_PROJECT_DIR/bin/foamEtcFile config/ensight.sh`
 
 
 # Clean environment paths again. Only remove duplicates

etc/config/README

@@ -0,0 +1,51 @@
+The main OpenFOAM settings are located in the parent etc/ directory
+
+* bashrc, cshrc
+  entry point for sourcing
+
+* prefs.csh, prefs.sh
+  these files are untracked and can be used for some site-defined
+  settings
+
+
+The etc/config/ directory contains various configuration files in
+sh/csh variants:
+
+* settings.csh, settings.sh
+  core settings
+
+* aliases.csh, aliases.sh
+  aliases for interactive shells
+
+* unset.csh, unset.sh
+  sourced to clear as many OpenFOAM environment settings as possible
+
+
+* ensight.csh, ensight.sh
+  application settings for EnSight
+
+* paraview.csh, paraview.sh
+  application settings for ParaView
+
+* scotch.sh
+  application settings for compiling against scotch
+
+---
+
+The config/example directory contains various example configuration files
+in sh/csh variants
+
+* compiler.csh, compiler.sh
+  an example of fine tuning ThirdParty compiler settings for OpenFOAM
+
+* openmpi.csh, openmpi.sh
+  an example of fine tuning openmpi settings for OpenFOAM
+
+* paraview.csh, paraview.sh
+  an example of chaining to the standard config/paraview.sh with a
+  different ParaView_VERSION
+
+* prefs.csh, prefs.sh
+  an example of supplying alternative site-defined settings
+
+---

etc/config/aliases.csh

@@ -22,7 +22,7 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     etc/aliases.csh
+#     etc/config/aliases.csh
 #
 # Description
 #     Aliases for working with OpenFOAM
@@ -39,7 +39,7 @@ alias wmSP 'wmSET WM_PRECISION_OPTION=SP'
 alias wmDP 'wmSET WM_PRECISION_OPTION=DP'
 
 # clear env
-alias wmUNSET='source $WM_PROJECT_DIR/etc/unset.csh'
+alias wmUNSET='source $WM_PROJECT_DIR/etc/config/unset.csh'
 
 # Toggle wmakeScheduler on/off
 #  - also need to set WM_HOSTS
@@ -49,7 +49,7 @@ alias wmSchedOFF 'unsetenv WM_SCHEDULER'
 
 # Change ParaView version
 # ~~~~~~~~~~~~~~~~~~~~~~~
-alias foamPV 'source `$WM_PROJECT_DIR/etc/apps/paraview3/cshrc` ParaView_VERSION=\!*; echo paraview-$ParaView_VERSION'
+alias foamPV 'source `$WM_PROJECT_DIR/etc/config/paraview.csh` ParaView_VERSION=\!*; echo paraview-$ParaView_VERSION'
 
 
 # Change directory aliases

etc/config/aliases.sh

@@ -22,7 +22,7 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     etc/aliases.sh
+#     etc/config/aliases.sh
 #
 # Description
 #     Aliases for working with OpenFOAM
@@ -39,7 +39,7 @@ alias wmSP='wmSET WM_PRECISION_OPTION=SP'
 alias wmDP='wmSET WM_PRECISION_OPTION=DP'
 
 # clear env
-alias wmUNSET='. $WM_PROJECT_DIR/etc/unset.sh'
+alias wmUNSET='. $WM_PROJECT_DIR/etc/config/unset.sh'
 
 # Toggle wmakeScheduler on/off
 #  - also need to set WM_HOSTS
@@ -52,7 +52,7 @@ alias wmSchedOFF='unset WM_SCHEDULER'
 unset foamPV
 foamPV()
 {
-    . $WM_PROJECT_DIR/etc/apps/paraview3/bashrc ParaView_VERSION=$1
+    . $WM_PROJECT_DIR/etc/config/paraview.sh ParaView_VERSION=$1
     echo "paraview-$ParaView_VERSION  (major: $ParaView_MAJOR)"
 }
 

etc/config/ensight.csh

@@ -2,7 +2,7 @@
 # =========                 |
 # \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
 #  \\    /   O peration     |
-#   \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+#   \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
 #    \\/     M anipulation  |
 #-------------------------------------------------------------------------------
 # License
@@ -22,7 +22,7 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     ensight/cshrc
+#     config/ensight.csh
 #
 # Description
 #     Setup file for Ensight

etc/config/ensight.sh

@@ -2,7 +2,7 @@
 # =========                 |
 # \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
 #  \\    /   O peration     |
-#   \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+#   \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
 #    \\/     M anipulation  |
 #------------------------------------------------------------------------------
 # License
@@ -22,7 +22,7 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     ensight/bashrc
+#     config/ensight.sh
 #
 # Description
 #     Setup file for Ensight

etc/config/example/compiler.csh

@@ -22,11 +22,11 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     config/compiler.csh
+#     config/example/compiler.csh
 #
 # Description
-#     Fine tuning of ThirdParty compiler settings for OpenFOAM
+#     Example of fine tuning ThirdParty compiler settings for OpenFOAM
-#     Sourced from OpenFOAM-<VERSION>/etc/settings.csh
+#     Sourced from OpenFOAM-<VERSION>/etc/config/settings.csh
 #
 #------------------------------------------------------------------------------
 

etc/config/example/compiler.sh

@@ -22,11 +22,11 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     config/compiler.sh
+#     config/example/compiler.sh
 #
 # Description
-#     Fine tuning of ThirdParty compiler settings for OpenFOAM
+#     Example of fine tuning ThirdParty compiler settings for OpenFOAM
-#     Sourced from OpenFOAM-<VERSION>/etc/settings.sh
+#     Sourced from OpenFOAM-<VERSION>/etc/config/settings.sh
 #
 #------------------------------------------------------------------------------
 

etc/config/example/openmpi.csh

@@ -22,11 +22,11 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     config/openmpi.csh
+#     config/example/openmpi.csh
 #
 # Description
-#     Fine tuning of openmpi settings for OpenFOAM
+#     Example of fine tuning openmpi settings for OpenFOAM
-#     Sourced from OpenFOAM-<VERSION>/etc/settings.csh
+#     Sourced from OpenFOAM-<VERSION>/etc/config/settings.csh
 #
 #------------------------------------------------------------------------------
 

etc/config/example/openmpi.sh

@@ -22,11 +22,11 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     config/openmpi.sh
+#     config/example/openmpi.sh
 #
 # Description
-#     Fine tuning of openmpi settings for OpenFOAM
+#     Example of fine tuning openmpi settings for OpenFOAM
-#     Sourced from OpenFOAM-<VERSION>/etc/settings.sh
+#     Sourced from OpenFOAM-<VERSION>/etc/config/settings.sh
 #
 #------------------------------------------------------------------------------
 

etc/config/example/paraview.csh

@@ -22,10 +22,10 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     paraview3/cshrc-EXAMPLE
+#     config/example/paraview.csh
 #
 # Description
-#     Example of chaining to the standard paraview3/cshrc with a
+#     Example of chaining to the standard config/paraview.csh with a
 #     different ParaView_VERSION
 #
 # Note
@@ -35,10 +35,10 @@
 #------------------------------------------------------------------------------
 
 #
-# Use other (shipped) cshrc with a different ParaView_VERSION
+# Use other (shipped) paraview.csh with a different ParaView_VERSION
 #
 
-set foamFile=`$WM_PROJECT_DIR/bin/foamEtcFile -mode o apps/paraview3/cshrc`
+set foamFile=`$WM_PROJECT_DIR/bin/foamEtcFile -mode o config/paraview.csh`
 if ( $status == 0 ) source $foamFile ParaView_VERSION=3.9.0
 
 unset foamFile

etc/config/example/paraview.sh

@@ -22,10 +22,10 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     paraview3/bashrc-EXAMPLE
+#     config/example/paraview.sh
 #
 # Description
-#     Example of chaining to the standard paraview3/bashrc with a
+#     Example of chaining to the standard config/paraview.sh with a
 #     different ParaView_VERSION
 #
 # Note
@@ -35,10 +35,10 @@
 #------------------------------------------------------------------------------
 
 #
-# Use other (shipped) bashrc with a different ParaView_VERSION
+# Use other (shipped) paraview.sh with a different ParaView_VERSION
 #
 
-foamFile=$($WM_PROJECT_DIR/bin/foamEtcFile -mode o apps/paraview3/bashrc 2>/dev/null)
+foamFile=$($WM_PROJECT_DIR/bin/foamEtcFile -mode o config/paraview.sh 2>/dev/null)
 [ $? -eq 0 ] && . $foamFile ParaView_VERSION=3.9.0
 
 unset foamFile

etc/config/example/prefs.csh

@@ -22,7 +22,7 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     etc/prefs.csh
+#     config/example/prefs.csh
 #
 # Description
 #     Preset variables for the OpenFOAM configuration - C-Shell shell syntax.

etc/config/example/prefs.sh

@@ -22,7 +22,7 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     etc/prefs.sh
+#     config/example/prefs.sh
 #
 # Description
 #     Preset variables for the OpenFOAM configuration - POSIX shell syntax.

etc/config/paraview.csh

@@ -22,7 +22,7 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     paraview3/cshrc
+#     config/paraview.csh
 #
 # Description
 #     Setup file for paraview-3.x
@@ -49,7 +49,7 @@ foreach cmake ( cmake-2.8.4 cmake-2.8.3 cmake-2.8.1 )
 end
 
 #- ParaView version, automatically determine major version:
-setenv ParaView_VERSION 3.8.0
+setenv ParaView_VERSION 3.10.1
 setenv ParaView_MAJOR detect
 
 

etc/config/paraview.sh

@@ -22,7 +22,7 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     paraview3/bashrc
+#     config/paraview.sh
 #
 # Description
 #     Setup file for paraview-3.x
@@ -51,7 +51,7 @@ done
 
 
 #- ParaView version, automatically determine major version
-export ParaView_VERSION=3.8.0
+export ParaView_VERSION=3.10.1
 export ParaView_MAJOR=detect
 
 
@@ -113,7 +113,6 @@ else
     unset PV_PLUGIN_PATH
 fi
 
-
 unset _foamParaviewEval
 unset cleaned cmake paraviewInstDir paraviewPython
 

etc/config/scotch.sh

@@ -22,7 +22,7 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     scotch/bashrc
+#     config/scotch.sh
 #
 # Description
 #     Setup file for scotch include/libraries.
@@ -36,5 +36,4 @@
 export SCOTCH_VERSION=scotch_5.1.11
 export SCOTCH_ARCH_PATH=$WM_THIRD_PARTY_DIR/platforms/$WM_ARCH$WM_COMPILER/$SCOTCH_VERSION
 
-
 # -----------------------------------------------------------------------------

etc/config/settings.csh

@@ -22,7 +22,7 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     etc/settings.csh
+#     etc/config/settings.csh
 #
 # Description
 #     Startup file for OpenFOAM
@@ -193,7 +193,7 @@ unsetenv MPFR_ARCH_PATH GMP_ARCH_PATH
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 if ( ! $?foamCompiler ) then
     set foamCompiler=system
-    echo "Warning in $WM_PROJECT_DIR/etc/settings.csh:"
+    echo "Warning in $WM_PROJECT_DIR/etc/config/settings.csh:"
     echo "    foamCompiler not set, using '$foamCompiler'"
 endif
 
@@ -241,7 +241,7 @@ case ThirdParty:
         breaksw
     default:
         echo
-        echo "Warning in $WM_PROJECT_DIR/etc/settings.csh:"
+        echo "Warning in $WM_PROJECT_DIR/etc/config/settings.csh:"
         echo "    Unknown OpenFOAM compiler type '$WM_COMPILER'"
         echo "    Please check your settings"
         echo
@@ -262,7 +262,7 @@ case ThirdParty:
         # Check that the compiler directory can be found
         if ( ! -d "$gccDir" ) then
             echo
-            echo "Warning in $WM_PROJECT_DIR/etc/settings.csh:"
+            echo "Warning in $WM_PROJECT_DIR/etc/config/settings.csh:"
             echo "    Cannot find $gccDir installation."
             echo "    Please install this compiler version or if you wish to use the system compiler,"
             echo "    change the 'foamCompiler' setting to 'system'"
@@ -302,7 +302,7 @@ case ThirdParty:
         # Check that the compiler directory can be found
         if ( ! -d "$clangDir" ) then
             echo
-            echo "Warning in $WM_PROJECT_DIR/etc/settings.csh:"
+            echo "Warning in $WM_PROJECT_DIR/etc/config/settings.csh:"
             echo "    Cannot find $clangDir installation."
             echo "    Please install this compiler version or if you wish to use the system compiler,"
             echo "    change the 'foamCompiler' setting to 'system'"

etc/config/settings.sh

@@ -22,7 +22,7 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     etc/settings.sh
+#     etc/config/settings.sh
 #
 # Description
 #     Startup file for OpenFOAM
@@ -215,7 +215,7 @@ unset MPFR_ARCH_PATH GMP_ARCH_PATH
 if [ -z "$foamCompiler" ]
 then
     foamCompiler=system
-    echo "Warning in $WM_PROJECT_DIR/etc/settings.sh:" 1>&2
+    echo "Warning in $WM_PROJECT_DIR/etc/config/settings.sh:" 1>&2
     echo "    foamCompiler not set, using '$foamCompiler'" 1>&2
 fi
 
@@ -258,7 +258,7 @@ OpenFOAM | ThirdParty)
         ;;
     *)
         echo
-        echo "Warning in $WM_PROJECT_DIR/etc/settings.sh:"
+        echo "Warning in $WM_PROJECT_DIR/etc/config/settings.sh:"
         echo "    Unknown OpenFOAM compiler type '$WM_COMPILER'"
         echo "    Please check your settings"
         echo
@@ -278,7 +278,7 @@ OpenFOAM | ThirdParty)
         # Check that the compiler directory can be found
         [ -d "$gccDir" ] || {
             echo
-            echo "Warning in $WM_PROJECT_DIR/etc/settings.sh:"
+            echo "Warning in $WM_PROJECT_DIR/etc/config/settings.sh:"
             echo "    Cannot find $gccDir installation."
             echo "    Please install this compiler version or if you wish to use the system compiler,"
             echo "    change the 'foamCompiler' setting to 'system'"
@@ -322,7 +322,7 @@ OpenFOAM | ThirdParty)
         # Check that the compiler directory can be found
         [ -d "$clangDir" ] || {
             echo
-            echo "Warning in $WM_PROJECT_DIR/etc/settings.sh:"
+            echo "Warning in $WM_PROJECT_DIR/etc/config/settings.sh:"
             echo "    Cannot find $clangDir installation."
             echo "    Please install this compiler version or if you wish to use the system compiler,"
             echo "    change the 'foamCompiler' setting to 'system'"

etc/config/unset.csh

@@ -22,7 +22,7 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     etc/unset.csh
+#     etc/config/unset.csh
 #
 # Description
 #     Clear as many OpenFOAM environment settings as possible

etc/config/unset.sh

@@ -22,7 +22,7 @@
 #     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 #
 # File
-#     etc/unset.sh
+#     etc/config/unset.sh
 #
 # Description
 #     Clear as many OpenFOAM environment settings as possible

etc/controlDict

@@ -494,6 +494,7 @@ DebugSwitches
     geomCellLooper      0;
     geometricSurfacePatch   0;
     global              0;
+    globalIndexAndTransform 0;
     globalMeshData      0;
     globalPoints        0;
     gnuplot             0;

etc/cshrc

@@ -107,9 +107,6 @@ if ( $?WM_PROJECT_INST_DIR ) then
         set foamOldDirs="$WM_PROJECT_INST_DIR $foamOldDirs"
     endif
 endif
-if ( $?WM_PROJECT_SITE ) then
-    set foamOldDirs="$WM_PROJECT_SITE $foamOldDirs"
-endif
 
 
 # Location of installation
@@ -124,7 +121,12 @@ setenv WM_THIRD_PARTY_DIR $WM_PROJECT_INST_DIR/ThirdParty-$WM_PROJECT_VERSION
 # Location of site-specific templates etc
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # unset is equivalent to $WM_PROJECT_INST_DIR/site
-unsetenv WM_PROJECT_SITE
+if ( $?WM_PROJECT_SITE ) then
+    set foamOldDirs="$WM_PROJECT_SITE $foamOldDirs"
+    if ( ! -d "$WM_PROJECT_SITE" ) unsetenv WM_PROJECT_SITE
+else
+    unsetenv WM_PROJECT_SITE
+endif
 
 # Location of user files
 # ~~~~~~~~~~~~~~~~~~~~~~
@@ -138,7 +140,7 @@ alias _foamSource 'if ($?FOAM_VERBOSE && $?prompt) echo "Sourcing: \!*"; if (\!*
 _foamSource `$WM_PROJECT_DIR/bin/foamEtcFile prefs.csh`
 
 # Evaluate command-line parameters and record settings for later
-# these can be used to set/unset values, or specify prefs files
+# these can be used to set/unset values, or specify alternative pref files
 setenv FOAM_SETTINGS "${*}"
 while ( $#argv > 0 )
     switch ($argv[1])
@@ -194,13 +196,13 @@ if ( $status == 0 ) setenv MANPATH $cleaned
 
 # Source project setup files
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~
-_foamSource $WM_PROJECT_DIR/etc/settings.csh
+_foamSource $WM_PROJECT_DIR/etc/config/settings.csh
-_foamSource $WM_PROJECT_DIR/etc/aliases.csh
+_foamSource $WM_PROJECT_DIR/etc/config/aliases.csh
 
 # Source user setup files for optional packages
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-_foamSource `$WM_PROJECT_DIR/bin/foamEtcFile apps/paraview3/cshrc`
+_foamSource `$WM_PROJECT_DIR/bin/foamEtcFile config/paraview.csh`
-_foamSource `$WM_PROJECT_DIR/bin/foamEtcFile apps/ensight/cshrc`
+_foamSource `$WM_PROJECT_DIR/bin/foamEtcFile config/ensight.csh`
 
 
 # Clean environment paths again. Only remove duplicates

src/OpenFOAM/db/dynamicLibrary/dynamicCode/dynamicCode.C

@@ -71,6 +71,27 @@ void Foam::dynamicCode::checkSecurity
             << "using dlopen)"
             << exit(FatalIOError);
     }
+
+    if (!allowSystemOperations)
+    {
+        FatalIOErrorIn
+        (
+            title,
+            dict
+        )   << "Loading a shared library using case-supplied code is not"
+            << " enabled by default" << nl
+            << "because of security issues. If you trust the code you can"
+            << " enable this" << nl
+            << "facility be adding to the InfoSwitches setting in the system"
+            << " controlDict:" << nl << nl
+            << "    allowSystemOperations 1" << nl << nl
+            << "The system controlDict is either" << nl << nl
+            << "    ~/.OpenFOAM/$WM_PROJECT_VERSION/controlDict" << nl << nl
+            << "or" << nl << nl
+            << "    $WM_PROJECT_DIR/etc/controlDict" << nl
+            << endl
+            << exit(FatalIOError);
+    }
 }
 
 
@@ -400,26 +421,6 @@ bool Foam::dynamicCode::copyOrCreateFiles(const bool verbose) const
         Info<< "Creating new library in " << this->libRelPath() << endl;
     }
 
-    if (!allowSystemOperations)
-    {
-        FatalErrorIn
-        (
-            "dynamicCode::copyOrCreateFiles() const"
-        )   <<  "Loading a shared library using case-supplied code is not"
-            << " enabled by default" << nl
-            << "because of security issues. If you trust the code you can"
-            << " enable this" << nl
-            << "facility be adding to the InfoSwitches setting in the system"
-            << " controlDict:" << nl << nl
-            << "    allowSystemOperations 1" << nl << nl
-            << "The system controlDict is either" << nl << nl
-            << "    ~/.OpenFOAM/$WM_PROJECT_VERSION/controlDict" << nl << nl
-            << "or" << nl << nl
-            << "    $WM_PROJECT_DIR/etc/controlDict" << nl
-            << endl
-            << exit(FatalError);
-    }
-
     const label nFiles = compileFiles_.size() + copyFiles_.size();
 
     DynamicList<fileName> resolvedFiles(nFiles);

src/OpenFOAM/global/argList/argList.C

@@ -414,11 +414,11 @@ Foam::argList::argList
             (
                 (
                     validOptions.found(optionName)
-                 && validOptions[optionName] != ""
+                 && !validOptions[optionName].empty()
                 )
              || (
                     validParOptions.found(optionName)
-                 && validParOptions[optionName] != ""
+                 && !validParOptions[optionName].empty()
                 )
             )
             {
@@ -833,6 +833,116 @@ Foam::argList::~argList()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+bool Foam::argList::setOption(const word& opt, const string& param)
+{
+    bool changed = false;
+
+    // only allow valid options
+    if (validOptions.found(opt))
+    {
+        // some options are to be protected
+        if
+        (
+            opt == "case"
+         || opt == "parallel"
+         || opt == "roots"
+        )
+        {
+            FatalError
+                <<"used argList::setOption on a protected option: '"
+                << opt << "'" << endl;
+            FatalError.exit();
+        }
+
+        if (validOptions[opt].empty())
+        {
+            // bool option
+            if (!param.empty())
+            {
+                // disallow change of type
+                FatalError
+                    <<"used argList::setOption to change bool to non-bool: '"
+                    << opt << "'" << endl;
+                FatalError.exit();
+            }
+            else
+            {
+                // did not previously exist
+                changed = !options_.found(opt);
+            }
+        }
+        else
+        {
+            // non-bool option
+            if (param.empty())
+            {
+                // disallow change of type
+                FatalError
+                    <<"used argList::setOption to change non-bool to bool: '"
+                    << opt << "'" << endl;
+                FatalError.exit();
+            }
+            else
+            {
+                // existing value needs changing, or did not previously exist
+                changed = options_.found(opt) ? options_[opt] != param : true;
+            }
+        }
+    }
+    else
+    {
+        FatalError
+            <<"used argList::setOption on an invalid option: '"
+            << opt << "'" << nl << "allowed are the following:"
+            << validOptions << endl;
+        FatalError.exit();
+    }
+
+    // set/change the option as required
+    if (changed)
+    {
+        options_.set(opt, param);
+    }
+
+    return changed;
+}
+
+
+bool Foam::argList::unsetOption(const word& opt)
+{
+    // only allow valid options
+    if (validOptions.found(opt))
+    {
+        // some options are to be protected
+        if
+        (
+            opt == "case"
+         || opt == "parallel"
+         || opt == "roots"
+        )
+        {
+            FatalError
+                <<"used argList::unsetOption on a protected option: '"
+                << opt << "'" << endl;
+            FatalError.exit();
+        }
+
+        // remove the option, return true if state changed
+        return options_.erase(opt);
+    }
+    else
+    {
+        FatalError
+            <<"used argList::unsetOption on an invalid option: '"
+            << opt << "'" << nl << "allowed are the following:"
+            << validOptions << endl;
+        FatalError.exit();
+    }
+
+    return false;
+}
+
+
 void Foam::argList::printNotes() const
 {
     // output notes directly - no automatic text wrapping

src/OpenFOAM/global/argList/argList.H

@@ -334,6 +334,19 @@ public:
             static void noParallel();
 
 
+            //- Set option directly (use with caution)
+            //  An option with an empty param is a bool option.
+            //  Not all valid options can also be set: eg, -case, -roots, ...
+            //  Return true if the existing option value needed changing,
+            //  or if the option did not previously exist.
+            bool setOption(const word& opt, const string& param = "");
+
+            //- Unset option directly (use with caution)
+            //  Not all valid options can also be unset: eg, -case, -roots ...
+            //  Return true if the option existed before being unset.
+            bool unsetOption(const word& opt);
+
+
         // Print
 
             //- Print notes (if any)

src/OpenFOAM/meshes/meshTools/matchPoints.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -124,7 +124,7 @@ bool Foam::matchPoints
                 {
                     label faceI = pts1MagSqr.indices()[j];
 
-                    Pout<< "Compared coord:" << pts1[faceI]
+                    Pout<< "    Compared coord:" << pts1[faceI]
                         << " with difference to point "
                         << mag(pts1[faceI] - pts0[face0I]) << endl;
                 }

src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.C

@@ -57,6 +57,30 @@ Foam::label Foam::globalPoints::countPatchPoints
 }
 
 
+Foam::label Foam::globalPoints::findSamePoint
+(
+    const labelPairList& allInfo,
+    const labelPair& info
+) const
+{
+    const label procI = globalIndexAndTransform::processor(info);
+    const label index = globalIndexAndTransform::index(info);
+
+    forAll(allInfo, i)
+    {
+        if
+        (
+            globalIndexAndTransform::processor(allInfo[i]) == procI
+         && globalIndexAndTransform::index(allInfo[i]) == index
+        )
+        {
+            return i;
+        }
+    }
+    return -1;
+}
+
+
 Foam::labelPairList Foam::globalPoints::addSendTransform
 (
     const label patchI,
@@ -67,6 +91,15 @@ Foam::labelPairList Foam::globalPoints::addSendTransform
 
     forAll(info, i)
     {
+        //Pout<< "    adding send transform to" << nl
+        //    << "    proc:" << globalIndexAndTransform::processor(info[i])
+        //    << nl
+        //    << "    index:" << globalIndexAndTransform::index(info[i]) << nl
+        //    << "    trafo:"
+        //    <<  globalTransforms_.decodeTransformIndex
+        //        (globalIndexAndTransform::transformIndex(info[i]))
+        //    << endl;
+
         sendInfo[i] = globalIndexAndTransform::encode
         (
             globalIndexAndTransform::processor(info[i]),
@@ -129,72 +162,63 @@ bool Foam::globalPoints::mergeInfo
 {
     bool anyChanged = false;
 
+    // Extend to make space for the nbrInfo (trimmed later)
     labelPairList newInfo(myInfo);
     label newI = newInfo.size();
     newInfo.setSize(newI + nbrInfo.size());
 
     forAll(nbrInfo, i)
     {
-        const labelPair& info = nbrInfo[i];
-        label nbrProcI = globalIndexAndTransform::processor(info);
-        label nbrIndex = globalIndexAndTransform::index(info);
-        label nbrTransform = globalIndexAndTransform::transformIndex(info);
-
         // Check if already have information about nbr point. There are two
         // possibilities:
         // - information found about same point but different transform.
         //   Combine transforms
         // - information not found.
 
-        label myIndex = -1;
+        label index = findSamePoint(myInfo, nbrInfo[i]);
-        forAll(myInfo, myI)
-        {
-            if (myInfo[myI] == info)
-            {
-                // Fully identical. We already have nbrInfo.
-                myIndex = myI;
-            }
-            else if
-            (
-                globalIndexAndTransform::processor(myInfo[myI]) == nbrProcI
-             && globalIndexAndTransform::index(myInfo[myI]) == nbrIndex
-            )
-            {
-                // Only differing is the transform.
-                label myTransform = globalIndexAndTransform::transformIndex
-                (
-                    myInfo[myI]
-                );
 
-                // Combine mine and nbr transform
+        if (index == -1)
-                label t = globalTransforms_.mergeTransformIndex
-                (
-                    nbrTransform,
-                    myTransform
-                );
-                myIndex = myI;
-
-                if (t != myTransform)
-                {
-                    // Same point but different transformation
-                    newInfo[myI] = globalIndexAndTransform::encode
-                    (
-                        nbrProcI,
-                        nbrIndex,
-                        t
-                    );
-                    anyChanged = true;
-                    break;
-                }
-            }
-        }
-
-        if (myIndex == -1)
         {
             // New point
             newInfo[newI++] = nbrInfo[i];
             anyChanged = true;
         }
+        else
+        {
+            // Same point. So we already have a connection between localPointI
+            // and the nbrIndex. Two situations:
+            // - same transform
+            // - one transform takes two steps, the other just a single.
+            if (myInfo[index] == nbrInfo[i])
+            {
+                // Everything same (so also transform). Nothing changed.
+            }
+            else
+            {
+                label myTransform = globalIndexAndTransform::transformIndex
+                (
+                    myInfo[index]
+                );
+                label nbrTransform = globalIndexAndTransform::transformIndex
+                (
+                    nbrInfo[i]
+                );
+
+                // Different transform. See which is 'simplest'.
+                label minTransform = globalTransforms_.minimumTransformIndex
+                (
+                    myTransform,
+                    nbrTransform
+                );
+
+                if (minTransform != myTransform)
+                {
+                    // Use nbr info.
+                    newInfo[index] = nbrInfo[i];
+                    anyChanged = true;
+                }
+            }
+        }
     }
 
     newInfo.setSize(newI);
@@ -327,7 +351,7 @@ void Foam::globalPoints::printProcPoints
         label index = globalIndexAndTransform::index(pointInfo[i]);
         label trafoI = globalIndexAndTransform::transformIndex(pointInfo[i]);
 
-        Pout<< "proc:" << procI;
+        Pout<< "    proc:" << procI;
         Pout<< " localpoint:";
         Pout<< index;
         Pout<< " through transform:"
@@ -386,6 +410,10 @@ void Foam::globalPoints::initOwnPoints
                         )
                     );
 
+                    //Pout<< "For point "<< pp.points()[meshPointI]
+                    //    << " inserting info " << knownInfo
+                    //    << endl;
+
                     // Update changedpoints info.
                     if (storeInitialInfo(knownInfo, localPointI))
                     {
@@ -613,80 +641,59 @@ void Foam::globalPoints::receivePatchPoints
                 label meshPointA = meshPoints[i];
                 label meshPointB = coupledMeshPoints[i];
 
-                //Pout<< "Connection between point " << meshPointA
+                if (meshPointA != meshPointB)
-                //    << " at " << mesh_.points()[meshPointA]
-                //    << " and " << meshPointB
-                //    << " at " << mesh_.points()[meshPointB] << endl;
-
-                label localA = meshToLocalPoint
-                (
-                    meshToPatchPoint,
-                    meshPointA
-                );
-                label localB = meshToLocalPoint
-                (
-                    meshToPatchPoint,
-                    meshPointB
-                );
-
-
-                // Do we have information on pointA?
-                Map<label>::iterator procPointA =
-                    meshToProcPoint_.find(localA);
-
-                labelPairList infoA;
-                if (procPointA != meshToProcPoint_.end())
                 {
-                    infoA = addSendTransform
+                    //Pout<< "Connection between point " << meshPointA
+                    //    << " at " << mesh_.points()[meshPointA]
+                    //    << " and " << meshPointB
+                    //    << " at " << mesh_.points()[meshPointB] << endl;
+
+                    label localA = meshToLocalPoint
                     (
-                        cycPatch.index(),
+                        meshToPatchPoint,
-                        procPoints_[procPointA()]
+                        meshPointA
                     );
-                }
+                    label localB = meshToLocalPoint
-
-                // Same for info on pointB
-                Map<label>::iterator procPointB =
-                    meshToProcPoint_.find(localB);
-
-                labelPairList infoB;
-                if (procPointB != meshToProcPoint_.end())
-                {
-                    infoB = addSendTransform
                     (
-                        cycPatch.neighbPatchID(),
+                        meshToPatchPoint,
-                        procPoints_[procPointB()]
+                        meshPointB
                     );
-                }
 
 
-                if (infoA.size())
+                    // Do we have information on pointA?
-                {
+                    Map<label>::iterator procPointA =
-                    if (mergeInfo(infoA, localB))
+                        meshToProcPoint_.find(localA);
+
+                    if (procPointA != meshToProcPoint_.end())
                     {
-                        //Pout<< "  Combined info at point "
+                        const labelPairList infoA = addSendTransform
-                        //    << mesh_.points()[meshPointB]
+                        (
-                        //    << " now " << endl;
+                            cycPatch.index(),
-                        //printProcPoints
+                            procPoints_[procPointA()]
-                        //(
+                        );
-                        //    patchToMeshPoint,
+
-                        //    procPoints_[meshToProcPoint_[localB]]
+                        if (mergeInfo(infoA, localB))
-                        //);
+                        {
-                        changedPoints.insert(localB);
+                            changedPoints.insert(localB);
+                        }
                     }
-                }
+
-                if (infoB.size())
+                    // Same for info on pointB
-                {
+                    Map<label>::iterator procPointB =
-                    if (mergeInfo(infoB, localA))
+                        meshToProcPoint_.find(localB);
+
+                    if (procPointB != meshToProcPoint_.end())
                     {
-                        //Pout<< "  Combined info at point "
+                        const labelPairList infoB = addSendTransform
-                        //    << mesh_.points()[meshPointA]
+                        (
-                        //    << " now " << endl;
+                            cycPatch.neighbPatchID(),
-                        //printProcPoints
+                            procPoints_[procPointB()]
-                        //(
+                        );
-                        //    patchToMeshPoint,
+
-                        //    procPoints_[meshToProcPoint_[localA]]
+                        if (mergeInfo(infoB, localA))
-                        //);
+                        {
-                        changedPoints.insert(localA);
+                            changedPoints.insert(localA);
+                        }
                     }
                 }
             }
@@ -842,6 +849,9 @@ void Foam::globalPoints::calculateSharedPoints
     {
         Pout<< "globalPoints::calculateSharedPoints(..) : "
             << "doing processor to processor communication to get sharedPoints"
+            << endl
+            << "    keepAllPoints :" << keepAllPoints << endl
+            << "    mergeSeparated:" << mergeSeparated << endl
             << endl;
     }
 
@@ -948,7 +958,7 @@ void Foam::globalPoints::calculateSharedPoints
     //    printProcPoints(patchToMeshPoint, pointInfo);
     //    Pout<< endl;
     //}
-    //
+
 
     // Remove direct neighbours from point equivalences.
     if (!keepAllPoints)

src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.H

@@ -143,6 +143,13 @@ class globalPoints
         //  information is collected.
         static label countPatchPoints(const polyBoundaryMesh&);
 
+        //- Find index of same processor+index
+        label findSamePoint
+        (
+            const labelPairList& allInfo,
+            const labelPair& info
+        ) const;
+
         labelPairList addSendTransform
         (
             const label patchI,

src/OpenFOAM/primitives/globalIndexAndTransform/globalIndexAndTransform.C

@@ -24,11 +24,12 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "globalIndexAndTransform.H"
-#include "coupledPolyPatch.H"
 #include "cyclicPolyPatch.H"
 
 // * * * * * * * * * * * * Private Static Data Members * * * * * * * * * * * //
 
+defineTypeNameAndDebug(Foam::globalIndexAndTransform, 0);
+
 const Foam::label Foam::globalIndexAndTransform::base_ = 32;
 
 
@@ -135,7 +136,19 @@ void Foam::globalIndexAndTransform::determineTransforms()
     {
         const polyPatch& pp = patches[patchI];
 
-        if (isA<coupledPolyPatch>(pp))
+        // Note: special check for unordered cyclics. These are in fact
+        // transform bcs and should probably be split off.
+        if
+        (
+            isA<coupledPolyPatch>(pp)
+        && !(
+                isA<cyclicPolyPatch>(pp)
+             && (
+                    refCast<const cyclicPolyPatch>(pp).transform()
+                 == cyclicPolyPatch::NOORDERING
+                )
+            )
+        )
         {
             const coupledPolyPatch& cpp = refCast<const coupledPolyPatch>(pp);
 
@@ -163,21 +176,19 @@ void Foam::globalIndexAndTransform::determineTransforms()
                             ) == 0
                         )
                         {
+                            if (nextTrans == 6)
+                            {
+                                FatalErrorIn
+                                (
+                                     "void Foam::globalIndexAndTransform::"
+                                     "determineTransforms()"
+                                )   << "More than six unsigned transforms"
+                                    << " detected:" << nl << transforms_
+                                    << exit(FatalError);
+                            }
                             transforms_[nextTrans] = transform;
                             maxTol[nextTrans++] = cpp.matchTolerance();
                         }
-
-                        if (nextTrans > 6)
-                        {
-                            FatalErrorIn
-                            (
-                                 "void Foam::globalIndexAndTransform::"
-                                 "determineTransforms()"
-                            )
-                                << "More than six unsigned transforms detected:"
-                                << nl << transforms_
-                                << exit(FatalError);
-                        }
                     }
                 }
             }
@@ -205,21 +216,19 @@ void Foam::globalIndexAndTransform::determineTransforms()
                             ) == 0
                         )
                         {
+                            if (nextTrans == 6)
+                            {
+                                FatalErrorIn
+                                (
+                                    "void Foam::globalIndexAndTransform::"
+                                    "determineTransforms()"
+                                )   << "More than six unsigned transforms"
+                                    << " detected:" << nl << transforms_
+                                    << exit(FatalError);
+                            }
                             transforms_[nextTrans] = transform;
                             maxTol[nextTrans++] = cpp.matchTolerance();
                         }
-
-                        if (nextTrans > 6)
-                        {
-                            FatalErrorIn
-                            (
-                                "void Foam::globalIndexAndTransform::"
-                                "determineTransforms()"
-                            )
-                                << "More than six unsigned transforms detected:"
-                                << nl << transforms_
-                                << exit(FatalError);
-                        }
                     }
                 }
             }
@@ -362,7 +371,19 @@ void Foam::globalIndexAndTransform::determinePatchTransformSign()
 
         // Pout<< nl << patchI << " " << pp.name() << endl;
 
-        if (isA<coupledPolyPatch>(pp))
+        // Note: special check for unordered cyclics. These are in fact
+        // transform bcs and should probably be split off.
+        if
+        (
+            isA<coupledPolyPatch>(pp)
+        && !(
+                isA<cyclicPolyPatch>(pp)
+             && (
+                    refCast<const cyclicPolyPatch>(pp).transform()
+                 == cyclicPolyPatch::NOORDERING
+                )
+            )
+        )
         {
             const coupledPolyPatch& cpp =
             refCast<const coupledPolyPatch>(pp);
@@ -478,6 +499,63 @@ Foam::globalIndexAndTransform::globalIndexAndTransform
     determineTransformPermutations();
 
     determinePatchTransformSign();
+
+    if (debug && transforms_.size() > 0)
+    {
+        const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+        Info<< "Determined global transforms :" << endl;
+        Info<< "\t\ttranslation\trotation" << endl;
+        forAll(transforms_, i)
+        {
+            Info<< '\t' << i << '\t';
+            const vectorTensorTransform& trafo = transforms_[i];
+            if (trafo.hasR())
+            {
+                 Info<< trafo.t() << '\t' << trafo.R();
+            }
+            else
+            {
+                 Info<< trafo.t() << '\t' << "---";
+            }
+            Info<< endl;
+        }
+        Info<< endl;
+
+
+        Info<< "\tpatch\ttransform\tsign" << endl;
+        forAll(patchTransformSign_, patchI)
+        {
+            if (patchTransformSign_[patchI].first() != -1)
+            {
+                Info<< '\t' << patches[patchI].name()
+                    << '\t' << patchTransformSign_[patchI].first()
+                    << '\t' << patchTransformSign_[patchI].second()
+                    << endl;
+            }
+        }
+        Info<< endl;
+
+
+        Info<< "Permutations of transformations:" << endl
+            << "\t\ttranslation\trotation" << endl;
+        forAll(transformPermutations_, i)
+        {
+            Info<< '\t' << i << '\t';
+            const vectorTensorTransform& trafo = transformPermutations_[i];
+            if (trafo.hasR())
+            {
+                 Info<< trafo.t() << '\t' << trafo.R();
+            }
+            else
+            {
+                 Info<< trafo.t() << '\t' << "---";
+            }
+            Info<< endl;
+        }
+        Info<< "nullTransformIndex:" << nullTransformIndex() << endl
+            << endl;
+    }
 }
 
 

src/OpenFOAM/primitives/globalIndexAndTransform/globalIndexAndTransform.H

@@ -164,6 +164,10 @@ public:
         friend class globalPoints;
 
 
+    // Declare name of the class and its debug switch
+    ClassName("globalIndexAndTransform");
+
+
     // Constructors
 
         //- Construct from components

src/OpenFOAM/primitives/globalIndexAndTransform/globalIndexAndTransformI.H

@@ -267,85 +267,47 @@ Foam::label Foam::globalIndexAndTransform::addToTransformIndex
 }
 
 
-Foam::label Foam::globalIndexAndTransform::mergeTransformIndex
-(
-    const label transformIndex0,
-    const label transformIndex1
-) const
-{
-    FixedList<label, 3> permutation0 = decodeTransformIndex(transformIndex0);
-    FixedList<label, 3> permutation1 = decodeTransformIndex(transformIndex1);
-
-    forAll(permutation0, i)
-    {
-        if (permutation0[i] == 0)
-        {
-            // Take over whatever sign 1 has
-            permutation0[i] = permutation1[i];
-        }
-        else if (permutation1[i] != 0 && permutation0[i] != permutation1[i])
-        {
-            FatalErrorIn
-            (
-                "Foam::label "
-                "Foam::globalIndexAndTransform::addToTransformIndex\n"
-                "(\n"
-                    "const label,\n"
-                    "const label\n"
-                ") const\n"
-            )   << "More than one patch accessing the same transform "
-                << "but not of the same sign." << endl
-                << "Trying to combine two transforms " << transformIndex0
-                << " with signs " << permutation0
-                << " and " << transformIndex1
-                << " with signs " << permutation1
-                << exit(FatalError);
-        }
-    }
-    return encodeTransformIndex(permutation0);
-}
-
-
 Foam::label Foam::globalIndexAndTransform::minimumTransformIndex
 (
     const label transformIndex0,
     const label transformIndex1
 ) const
 {
-    FixedList<label, 3> permutation0 = decodeTransformIndex(transformIndex0);
+    if (transformIndex0 == transformIndex1)
-    FixedList<label, 3> permutation1 = decodeTransformIndex(transformIndex1);
+    {
+        return transformIndex0;
+    }
 
+
+    // Count number of transforms
+    FixedList<label, 3> permutation0 = decodeTransformIndex(transformIndex0);
+    label n0 = 0;
     forAll(permutation0, i)
     {
-        if (permutation0[i] == 0)
+        if (permutation0[i] != 0)
         {
-            // 0 wins.
+            n0++;
-        }
-        else if (permutation1[i] == 0)
-        {
-            // 0 wins.
-            permutation0[i] = permutation1[i];
-        }
-        else if (permutation0[i] != permutation1[i])
-        {
-            FatalErrorIn
-            (
-                "Foam::label "
-                "Foam::globalIndexAndTransform::minimumTransformIndex\n"
-                "(\n"
-                    "const label,\n"
-                    "const label\n"
-                ") const\n"
-            )   << "More than one patch accessing the same transform "
-                << "but not of the same sign." << endl
-                << "Trying to combine two transforms " << transformIndex0
-                << " with signs " << permutation0
-                << " and " << transformIndex1
-                << " with signs " << permutation1
-                << exit(FatalError);
         }
     }
-    return encodeTransformIndex(permutation0);
+
+    FixedList<label, 3> permutation1 = decodeTransformIndex(transformIndex1);
+    label n1 = 0;
+    forAll(permutation1, i)
+    {
+        if (permutation1[i] != 0)
+        {
+            n1++;
+        }
+    }
+
+    if (n0 <= n1)
+    {
+        return transformIndex0;
+    }
+    else
+    {
+        return transformIndex1;
+    }
 }
 
 

src/dynamicFvMesh/dynamicFvMesh/dynamicFvMesh.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -40,6 +40,48 @@ Foam::dynamicFvMesh::dynamicFvMesh(const IOobject& io)
 {}
 
 
+Foam::dynamicFvMesh::dynamicFvMesh
+(
+    const IOobject& io,
+    const Xfer<pointField>& points,
+    const Xfer<faceList>& faces,
+    const Xfer<labelList>& allOwner,
+    const Xfer<labelList>& allNeighbour,
+    const bool syncPar
+)
+:
+    fvMesh
+    (
+        io,
+        points,
+        faces,
+        allOwner,
+        allNeighbour,
+        syncPar
+    )
+{}
+
+
+Foam::dynamicFvMesh::dynamicFvMesh
+(
+    const IOobject& io,
+    const Xfer<pointField>& points,
+    const Xfer<faceList>& faces,
+    const Xfer<cellList>& cells,
+    const bool syncPar
+)
+:
+    fvMesh
+    (
+        io,
+        points,
+        faces,
+        cells,
+        syncPar
+    )
+{}
+
+
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::dynamicFvMesh::~dynamicFvMesh()

src/dynamicFvMesh/dynamicFvMesh/dynamicFvMesh.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -85,6 +85,29 @@ public:
         //- Construct from objectRegistry, and read/write options
         explicit dynamicFvMesh(const IOobject& io);
 
+        //- Construct from components without boundary.
+        //  Boundary is added using addFvPatches() member function
+        dynamicFvMesh
+        (
+            const IOobject& io,
+            const Xfer<pointField>& points,
+            const Xfer<faceList>& faces,
+            const Xfer<labelList>& allOwner,
+            const Xfer<labelList>& allNeighbour,
+            const bool syncPar = true
+        );
+
+        //- Construct without boundary from cells rather than owner/neighbour.
+        //  Boundary is added using addPatches() member function
+        dynamicFvMesh
+        (
+            const IOobject& io,
+            const Xfer<pointField>& points,
+            const Xfer<faceList>& faces,
+            const Xfer<cellList>& cells,
+            const bool syncPar = true
+        );
+
 
     // Selectors
 

src/lagrangian/Allwmake

@@ -7,6 +7,7 @@ wmake $makeType distributionModels
 wmake $makeType basic
 wmake $makeType solidParticle
 wmake $makeType intermediate
+wmake $makeType spray
 wmake $makeType dieselSpray
 wmake $makeType dsmc
 wmake $makeType coalCombustion

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

@@ -126,17 +126,6 @@ void Foam::KinematicCloud<CloudType>::solve(TrackData& td)
 }
 
 
-template<class CloudType>
-void Foam::KinematicCloud<CloudType>::preEvolve()
-{
-    Info<< "\nSolving cloud " << this->name() << endl;
-
-    this->dispersion().cacheFields(true);
-    forces_.cacheFields(true);
-    updateCellOccupancy();
-}
-
-
 template<class CloudType>
 void Foam::KinematicCloud<CloudType>::buildCellOccupancy()
 {
@@ -310,6 +299,7 @@ Foam::KinematicCloud<CloudType>::KinematicCloud
     U_(U),
     mu_(mu),
     g_(g),
+    pAmbient_(0.0),
     forces_
     (
         *this,
@@ -403,6 +393,7 @@ Foam::KinematicCloud<CloudType>::KinematicCloud
     U_(c.U_),
     mu_(c.mu_),
     g_(c.g_),
+    pAmbient_(c.pAmbient_),
     forces_(c.forces_),
     functions_(c.functions_),
     dispersionModel_(c.dispersionModel_->clone()),
@@ -478,6 +469,7 @@ Foam::KinematicCloud<CloudType>::KinematicCloud
     U_(c.U_),
     mu_(c.mu_),
     g_(c.g_),
+    pAmbient_(c.pAmbient_),
     forces_(*this, mesh),
     functions_(*this),
     dispersionModel_(NULL),
@@ -506,6 +498,17 @@ bool Foam::KinematicCloud<CloudType>::hasWallImpactDistance() const
 }
 
 
+template<class CloudType>
+void Foam::KinematicCloud<CloudType>::setParcelThermoProperties
+(
+    parcelType& parcel,
+    const scalar lagrangianDt
+)
+{
+    parcel.rho() = constProps_.rho0();
+}
+
+
 template<class CloudType>
 void Foam::KinematicCloud<CloudType>::checkParcelProperties
 (
@@ -514,11 +517,6 @@ void Foam::KinematicCloud<CloudType>::checkParcelProperties
     const bool fullyDescribed
 )
 {
-    if (!fullyDescribed)
-    {
-        parcel.rho() = constProps_.rho0();
-    }
-
     const scalar carrierDt = mesh_.time().deltaTValue();
     parcel.stepFraction() = (carrierDt - lagrangianDt)/carrierDt;
     parcel.typeId() = constProps_.parcelTypeId();
@@ -600,6 +598,20 @@ void Foam::KinematicCloud<CloudType>::scaleSources()
 }
 
 
+template<class CloudType>
+void Foam::KinematicCloud<CloudType>::preEvolve()
+{
+    Info<< "\nSolving cloud " << this->name() << endl;
+
+    this->dispersion().cacheFields(true);
+    forces_.cacheFields(true);
+    updateCellOccupancy();
+
+    pAmbient_ = constProps_.dict().template
+        lookupOrDefault<scalar>("pAmbient", pAmbient_);
+}
+
+
 template<class CloudType>
 void Foam::KinematicCloud<CloudType>::evolve()
 {

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

@@ -176,6 +176,9 @@ protected:
             //- Gravity
             const dimensionedVector& g_;
 
+            //- Averaged ambient domain pressure
+            scalar pAmbient_;
+
 
         //- Optional particle forces
         forceType forces_;
@@ -230,9 +233,6 @@ protected:
             template<class TrackData>
             void solve(TrackData& td);
 
-            //- Pre-evolve
-            void preEvolve();
-
             //- Build the cellOccupancy
             void buildCellOccupancy();
 
@@ -367,6 +367,12 @@ public:
                 //- Gravity
                 inline const dimensionedVector& g() const;
 
+                //- Return const-access to the ambient pressure
+                inline scalar pAmbient() const;
+
+                //- Return reference to the ambient pressure
+                inline scalar& pAmbient();
+
 
             //- Optional particle forces
 //            inline const typename parcelType::forceType& forces() const;
@@ -456,6 +462,12 @@ public:
             //- Total rotational kinetic energy in the system
             inline scalar rotationalKineticEnergyOfSystem() const;
 
+            //- Penetration for percentage of the current total mass
+            inline scalar penetration(const scalar& prc) const;
+
+            //- Mean diameter Dij
+            inline scalar Dij(const label i, const label j) const;
+
 
             // Fields
 
@@ -474,6 +486,13 @@ public:
 
         // Cloud evolution functions
 
+            //- Set parcel thermo properties
+            void setParcelThermoProperties
+            (
+                parcelType& parcel,
+                const scalar lagrangianDt
+            );
+
             //- Check parcel properties
             void checkParcelProperties
             (
@@ -514,6 +533,9 @@ public:
             //- Apply scaling to (transient) cloud sources
             void scaleSources();
 
+            //- Pre-evolve
+            void preEvolve();
+
             //- Evolve the cloud
             void evolve();
 

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

@@ -109,6 +109,20 @@ inline const Foam::dimensionedVector& Foam::KinematicCloud<CloudType>::g() const
 }
 
 
+template<class CloudType>
+inline Foam::scalar Foam::KinematicCloud<CloudType>::pAmbient() const
+{
+    return pAmbient_;
+}
+
+
+template<class CloudType>
+inline Foam::scalar& Foam::KinematicCloud<CloudType>::pAmbient()
+{
+    return pAmbient_;
+}
+
+
 template<class CloudType>
 //inline const typename CloudType::parcelType::forceType&
 inline const typename Foam::KinematicCloud<CloudType>::forceType&
@@ -264,6 +278,131 @@ Foam::KinematicCloud<CloudType>::rotationalKineticEnergyOfSystem() const
 }
 
 
+template<class CloudType>
+inline Foam::scalar Foam::KinematicCloud<CloudType>::Dij
+(
+    const label i,
+    const label j
+) const
+{
+    scalar si = 0.0;
+    scalar sj = 0.0;
+    forAllConstIter(typename KinematicCloud<CloudType>, *this, iter)
+    {
+        const parcelType& p = iter();
+        si += p.nParticle()*pow(p.d(), i);
+        sj += p.nParticle()*pow(p.d(), j);
+    }
+
+    reduce(si, sumOp<scalar>());
+    reduce(sj, sumOp<scalar>());
+    sj = max(sj, VSMALL);
+
+    return si/sj;
+}
+
+
+template<class CloudType>
+inline Foam::scalar Foam::KinematicCloud<CloudType>::penetration
+(
+    const scalar& prc
+) const
+{
+    scalar distance = 0.0;
+    scalar mTot = 0.0;
+
+    label np = this->size();
+
+    // arrays containing the parcels mass and
+    // distance from injector in ascending order
+    scalarField mass(np);
+    scalarField dist(np);
+
+    if (np > 0)
+    {
+        label n = 0;
+
+        // first arrange the parcels in ascending order
+        // the first parcel is closest to its injection position
+        // and the last one is most far away.
+        forAllConstIter(typename KinematicCloud<CloudType>, *this, iter)
+        {
+            const parcelType& p = iter();
+            scalar mi = p.nParticle()*p.mass();
+            scalar di = mag(p.position() - p.position0());
+            mTot += mi;
+
+            // insert at the last place
+            mass[n] = mi;
+            dist[n] = di;
+
+            label i = 0;
+            bool found = false;
+
+            // insert the parcel in the correct place
+            // and move the others
+            while ((i < n) && (!found))
+            {
+                if (di < dist[i])
+                {
+                    found = true;
+                    for (label j=n; j>i; j--)
+                    {
+                        mass[j] = mass[j-1];
+                        dist[j] = dist[j-1];
+                    }
+                    mass[i] = mi;
+                    dist[i] = di;
+                }
+                i++;
+            }
+            n++;
+        }
+    }
+
+    reduce(mTot, sumOp<scalar>());
+
+    if (np > 0)
+    {
+        scalar mLimit = prc*mTot;
+        scalar mOff = (1.0 - prc)*mTot;
+
+        if (np > 1)
+        {
+            // 'prc' is large enough that the parcel most far
+            // away will be used, no need to loop...
+            if (mLimit > mTot - mass[np-1])
+            {
+                distance = dist[np-1];
+            }
+            else
+            {
+                scalar mOffSum = 0.0;
+                label i = np;
+
+                while ((mOffSum < mOff) && (i>0))
+                {
+                    i--;
+                    mOffSum += mass[i];
+                }
+                distance =
+                    dist[i+1]
+                  + (dist[i] - dist[i+1])*(mOffSum - mOff)
+                   /mass[i+1] ;
+            }
+        }
+        else
+        {
+            distance = dist[0];
+        }
+    }
+
+    reduce(distance, maxOp<scalar>());
+
+    return distance;
+}
+
+
 template<class CloudType>
 inline Foam::cachedRandom& Foam::KinematicCloud<CloudType>::rndGen()
 {

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

@@ -174,6 +174,9 @@ public:
             //- Return const access to the coupled flag
             inline const Switch coupled() const;
 
+            //- Return non-const access to the coupled flag
+            inline Switch& coupled();
+
             //- Return const access to the cell value correction flag
             inline const Switch cellValueSourceCorrection() const;
 

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

@@ -101,6 +101,12 @@ inline Foam::scalar Foam::cloudSolution::trackTime() const
 }
 
 
+inline Foam::Switch& Foam::cloudSolution::coupled()
+{
+    return coupled_;
+}
+
+
 inline const Foam::Switch Foam::cloudSolution::coupled() const
 {
     return coupled_;

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

@@ -223,6 +223,20 @@ Foam::ReactingCloud<CloudType>::~ReactingCloud()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+template<class CloudType>
+void Foam::ReactingCloud<CloudType>::setParcelThermoProperties
+(
+    parcelType& parcel,
+    const scalar lagrangianDt
+)
+{
+    CloudType::setParcelThermoProperties(parcel, lagrangianDt);
+
+    parcel.pc() = this->thermo().thermo().p()[parcel.cell()];
+    parcel.Y() = composition().YMixture0();
+}
+
+
 template<class CloudType>
 void Foam::ReactingCloud<CloudType>::checkParcelProperties
 (
@@ -231,18 +245,9 @@ void Foam::ReactingCloud<CloudType>::checkParcelProperties
     const bool fullyDescribed
 )
 {
-    CloudType::checkParcelProperties
+    CloudType::checkParcelProperties(parcel, lagrangianDt, fullyDescribed);
-    (
-        parcel,
-        lagrangianDt,
-        fullyDescribed
-    );
 
-    if (!fullyDescribed)
+    if (fullyDescribed)
-    {
-        parcel.Y() = composition().YMixture0();
-    }
-    else
     {
         checkSuppliedComposition
         (

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

@@ -267,6 +267,13 @@ public:
 
         // Cloud evolution functions
 
+            //- Set parcel thermo properties
+            void setParcelThermoProperties
+            (
+                parcelType& parcel,
+                const scalar lagrangianDt
+            );
+
             //- Check parcel properties
             void checkParcelProperties
             (

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

@@ -154,6 +154,25 @@ Foam::ReactingMultiphaseCloud<CloudType>::~ReactingMultiphaseCloud()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+template<class CloudType>
+void Foam::ReactingMultiphaseCloud<CloudType>::setParcelThermoProperties
+(
+    parcelType& parcel,
+    const scalar lagrangianDt
+)
+{
+    CloudType::setParcelThermoProperties(parcel, lagrangianDt);
+
+    label idGas = this->composition().idGas();
+    label idLiquid = this->composition().idLiquid();
+    label idSolid = this->composition().idSolid();
+
+    parcel.YGas() = this->composition().Y0(idGas);
+    parcel.YLiquid() = this->composition().Y0(idLiquid);
+    parcel.YSolid() = this->composition().Y0(idSolid);
+}
+
+
 template<class CloudType>
 void Foam::ReactingMultiphaseCloud<CloudType>::checkParcelProperties
 (
@@ -162,25 +181,14 @@ void Foam::ReactingMultiphaseCloud<CloudType>::checkParcelProperties
     const bool fullyDescribed
 )
 {
-    CloudType::checkParcelProperties
+    CloudType::checkParcelProperties(parcel, lagrangianDt, fullyDescribed);
-    (
-        parcel,
-        lagrangianDt,
-        fullyDescribed
-    );
 
-    label idGas = this->composition().idGas();
+    if (fullyDescribed)
-    label idLiquid = this->composition().idLiquid();
+    {
-    label idSolid = this->composition().idSolid();
+        label idGas = this->composition().idGas();
+        label idLiquid = this->composition().idLiquid();
+        label idSolid = this->composition().idSolid();
 
-    if (!fullyDescribed)
-    {
-        parcel.YGas() = this->composition().Y0(idGas);
-        parcel.YLiquid() = this->composition().Y0(idLiquid);
-        parcel.YSolid() = this->composition().Y0(idSolid);
-    }
-    else
-    {
         this->checkSuppliedComposition
         (
             parcel.YGas(),

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

@@ -41,7 +41,6 @@ SourceFiles
 #ifndef ReactingMultiphaseCloud_H
 #define ReactingMultiphaseCloud_H
 
-#include "ReactingCloud.H"
 #include "reactingMultiphaseCloud.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -241,6 +240,13 @@ public:
 
         // Cloud evolution functions
 
+            //- Set parcel thermo properties
+            void setParcelThermoProperties
+            (
+                parcelType& parcel,
+                const scalar lagrangianDt
+            );
+
             //- Check parcel properties
             void checkParcelProperties
             (

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

@@ -233,6 +233,20 @@ Foam::ThermoCloud<CloudType>::~ThermoCloud()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+template<class CloudType>
+void Foam::ThermoCloud<CloudType>::setParcelThermoProperties
+(
+    parcelType& parcel,
+    const scalar lagrangianDt
+)
+{
+    CloudType::setParcelThermoProperties(parcel, lagrangianDt);
+
+    parcel.T() = constProps_.T0();
+    parcel.Cp() = constProps_.Cp0();
+}
+
+
 template<class CloudType>
 void Foam::ThermoCloud<CloudType>::checkParcelProperties
 (
@@ -242,12 +256,6 @@ void Foam::ThermoCloud<CloudType>::checkParcelProperties
 )
 {
     CloudType::checkParcelProperties(parcel, lagrangianDt, fullyDescribed);
-
-    if (!fullyDescribed)
-    {
-        parcel.T() = constProps_.T0();
-        parcel.Cp() = constProps_.Cp0();
-    }
 }
 
 
@@ -304,6 +312,15 @@ void Foam::ThermoCloud<CloudType>::scaleSources()
 }
 
 
+template<class CloudType>
+void Foam::ThermoCloud<CloudType>::preEvolve()
+{
+    CloudType::preEvolve();
+
+    this->pAmbient() = thermo_.thermo().p().average().value();
+}
+
+
 template<class CloudType>
 void Foam::ThermoCloud<CloudType>::evolve()
 {

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

@@ -281,6 +281,13 @@ public:
 
         // Cloud evolution functions
 
+            //- Set parcel thermo properties
+            void setParcelThermoProperties
+            (
+                parcelType& parcel,
+                const scalar lagrangianDt
+            );
+
             //- Check parcel properties
             void checkParcelProperties
             (
@@ -304,6 +311,9 @@ public:
             //- Apply scaling to (transient) cloud sources
             void scaleSources();
 
+            //- Pre-evolve
+            void preEvolve();
+
             //- Evolve the cloud
             void evolve();
 

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

@@ -124,6 +124,17 @@ public:
                 const bool readFields = true
             );
 
+            //- Construct from components
+            constantProperties
+            (
+                const label parcelTypeId,
+                const scalar rhoMin,
+                const scalar rho0,
+                const scalar minParticleMass,
+                const scalar youngsModulus,
+                const scalar poissonsRatio
+            );
+
 
         // Member functions
 
@@ -536,6 +547,15 @@ public:
                 const scalar muc        // carrier dynamic viscosity
             ) const;
 
+            //- Weber number
+            inline scalar We
+            (
+                const vector& U,        // particle velocity
+                const scalar d,         // particle diameter
+                const scalar rhoc,      // carrier density
+                const scalar sigma      // particle surface tension
+            ) const;
+
 
         // Main calculation loop
 

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

@@ -85,6 +85,26 @@ inline Foam::KinematicParcel<ParcelType>::constantProperties::constantProperties
     }
 }
 
+template<class ParcelType>
+inline Foam::KinematicParcel<ParcelType>::constantProperties::constantProperties
+(
+    const label parcelTypeId,
+    const scalar rhoMin,
+    const scalar rho0,
+    const scalar minParticleMass,
+    const scalar youngsModulus,
+    const scalar poissonsRatio
+)
+:
+    dict_(dictionary::null),
+    parcelTypeId_(parcelTypeId),
+    rhoMin_(rhoMin),
+    rho0_(rho0),
+    minParticleMass_(minParticleMass),
+    youngsModulus_(youngsModulus),
+    poissonsRatio_(poissonsRatio)
+{}
+
 
 template<class ParcelType>
 inline Foam::KinematicParcel<ParcelType>::KinematicParcel
@@ -522,4 +542,17 @@ inline Foam::scalar Foam::KinematicParcel<ParcelType>::Re
 }
 
 
+template<class ParcelType>
+inline Foam::scalar Foam::KinematicParcel<ParcelType>::We
+(
+    const vector& U,
+    const scalar d,
+    const scalar rhoc,
+    const scalar sigma
+) const
+{
+    return rhoc*magSqr(U - Uc_)*d/(sigma + ROOTVSMALL);
+}
+
+
 // ************************************************************************* //

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

@@ -38,8 +38,8 @@ SourceFiles
 #ifndef ReactingMultiphaseParcel_H
 #define ReactingMultiphaseParcel_H
 
-#include "ReactingParcel.H"
+#include "particle.H"
-#include "ReactingMultiphaseCloud.H"
+#include "SLGThermo.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

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

@@ -26,8 +26,7 @@ License
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class ParcelType>
-inline
+inline Foam::ReactingMultiphaseParcel<ParcelType>::constantProperties::
-Foam::ReactingMultiphaseParcel<ParcelType>::constantProperties::
 constantProperties()
 :
     ParcelType::constantProperties(),
@@ -37,8 +36,7 @@ constantProperties()
 
 
 template<class ParcelType>
-inline
+inline Foam::ReactingMultiphaseParcel<ParcelType>::constantProperties::
-Foam::ReactingMultiphaseParcel<ParcelType>::constantProperties::
 constantProperties
 (
     const constantProperties& cp
@@ -227,4 +225,5 @@ inline bool& Foam::ReactingMultiphaseParcel<ParcelType>::canCombust()
     return canCombust_;
 }
 
+
 // ************************************************************************* //

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

@@ -24,8 +24,9 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "ReactingParcel.H"
-#include "mathematicalConstants.H"
 #include "specie.H"
+#include "CompositionModel.H"
+#include "mathematicalConstants.H"
 
 using namespace Foam::constant::mathematical;
 

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

@@ -38,8 +38,8 @@ SourceFiles
 #ifndef ReactingParcel_H
 #define ReactingParcel_H
 
-#include "ThermoParcel.H"
+#include "particle.H"
-#include "ReactingCloud.H"
+#include "SLGThermo.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -104,6 +104,27 @@ public:
                 const bool readFields = true
             );
 
+            //- Construct from components
+            constantProperties
+            (
+                const label parcelTypeId,
+                const scalar rhoMin,
+                const scalar rho0,
+                const scalar minParticleMass,
+                const scalar youngsModulus,
+                const scalar poissonsRatio,
+                const scalar T0,
+                const scalar TMin,
+                const scalar Cp0,
+                const scalar epsilon0,
+                const scalar f0,
+                const scalar Pr,
+                const scalar pMin,
+                const Switch& constantVolume,
+                const scalar Tvap,
+                const scalar Tbp
+            );
+
 
         // Access
 
@@ -136,7 +157,6 @@ public:
                 autoPtr<interpolation<scalar> > pInterp_;
 
 
-
     public:
 
         typedef typename ParcelType::template TrackingData<CloudType>::trackPart
@@ -327,6 +347,9 @@ public:
             //- Return the owner cell pressure
             inline scalar pc() const;
 
+            //- Return reference to the owner cell pressure
+            inline scalar& pc();
+
 
         // Edit
 
@@ -403,7 +426,7 @@ public:
                 const CompositionType& compModel
             );
 
-            //- Read - composition supplied
+            //- Write - composition supplied
             template<class CloudType>
             static void writeFields(const CloudType& c);
 

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

@@ -74,6 +74,49 @@ inline Foam::ReactingParcel<ParcelType>::constantProperties::constantProperties
 }
 
 
+template<class ParcelType>
+inline Foam::ReactingParcel<ParcelType>::constantProperties::constantProperties
+(
+    const label parcelTypeId,
+    const scalar rhoMin,
+    const scalar rho0,
+    const scalar minParticleMass,
+    const scalar youngsModulus,
+    const scalar poissonsRatio,
+    const scalar T0,
+    const scalar TMin,
+    const scalar Cp0,
+    const scalar epsilon0,
+    const scalar f0,
+    const scalar Pr,
+    const scalar pMin,
+    const Switch& constantVolume,
+    const scalar Tvap,
+    const scalar Tbp
+)
+:
+    ParcelType::constantProperties
+    (
+        parcelTypeId,
+        rhoMin,
+        rho0,
+        minParticleMass,
+        youngsModulus,
+        poissonsRatio,
+        T0,
+        TMin,
+        Cp0,
+        epsilon0,
+        f0,
+        Pr
+    ),
+    pMin_(pMin),
+    constantVolume_(constantVolume),
+    Tvap_(Tvap),
+    Tbp_(Tbp)
+{}
+
+
 template<class ParcelType>
 inline Foam::ReactingParcel<ParcelType>::ReactingParcel
 (
@@ -194,6 +237,13 @@ inline Foam::scalar Foam::ReactingParcel<ParcelType>::pc() const
 }
 
 
+template<class ParcelType>
+inline Foam::scalar& Foam::ReactingParcel<ParcelType>::pc()
+{
+    return pc_;
+}
+
+
 template<class ParcelType>
 inline Foam::scalar& Foam::ReactingParcel<ParcelType>::mass0()
 {

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

@@ -39,8 +39,8 @@ SourceFiles
 #ifndef ThermoParcel_H
 #define ThermoParcel_H
 
-#include "KinematicParcel.H"
+#include "particle.H"
-#include "ThermoCloud.H"
+#include "SLGThermo.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -112,6 +112,23 @@ public:
                 const bool readFields = true
             );
 
+            //- Construct from components
+            constantProperties
+            (
+                const label parcelTypeId,
+                const scalar rhoMin,
+                const scalar rho0,
+                const scalar minParticleMass,
+                const scalar youngsModulus,
+                const scalar poissonsRatio,
+                const scalar T0,
+                const scalar TMin,
+                const scalar Cp0,
+                const scalar epsilon0,
+                const scalar f0,
+                const scalar Pr
+            );
+
 
         // Member functions
 

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

@@ -81,6 +81,41 @@ inline Foam::ThermoParcel<ParcelType>::constantProperties::constantProperties
 }
 
 
+template<class ParcelType>
+inline Foam::ThermoParcel<ParcelType>::constantProperties::constantProperties
+(
+    const label parcelTypeId,
+    const scalar rhoMin,
+    const scalar rho0,
+    const scalar minParticleMass,
+    const scalar youngsModulus,
+    const scalar poissonsRatio,
+    const scalar T0,
+    const scalar TMin,
+    const scalar Cp0,
+    const scalar epsilon0,
+    const scalar f0,
+    const scalar Pr
+)
+:
+    ParcelType::constantProperties
+    (
+        parcelTypeId,
+        rhoMin,
+        rho0,
+        minParticleMass,
+        youngsModulus,
+        poissonsRatio
+    ),
+    T0_(T0),
+    TMin_(TMin),
+    Cp0_(Cp0),
+    epsilon0_(epsilon0),
+    f0_(f0),
+    Pr_(Pr)
+{}
+
+
 template<class ParcelType>
 inline Foam::ThermoParcel<ParcelType>::ThermoParcel
 (

src/lagrangian/intermediate/parcels/derived/basicReactingParcel/makeBasicReactingParcelSubmodels.C

@@ -45,9 +45,6 @@ License
 
 namespace Foam
 {
-    typedef basicReactingCloud::thermoCloudType thermoCloudType2;
-    typedef basicReactingCloud::kinematicCloudType kinematicCloudType2;
-
     makeParcelCloudFunctionObjects(basicReactingCloud);
 
     // Kinematic sub-models

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

@@ -30,6 +30,7 @@ License
 
 #include "CellZoneInjection.H"
 #include "ConeInjection.H"
+#include "ConeNozzleInjection.H"
 #include "FieldActivatedInjection.H"
 #include "InflationInjection.H"
 #include "KinematicLookupTableInjection.H"

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

@@ -30,6 +30,7 @@ License
 
 #include "CellZoneInjection.H"
 #include "ConeInjection.H"
+#include "ConeNozzleInjection.H"
 #include "FieldActivatedInjection.H"
 #include "ManualInjection.H"
 #include "NoInjection.H"

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

@@ -30,6 +30,7 @@ License
 
 #include "CellZoneInjection.H"
 #include "ConeInjection.H"
+#include "ConeNozzleInjection.H"
 #include "FieldActivatedInjection.H"
 #include "ManualInjection.H"
 #include "NoInjection.H"

src/lagrangian/intermediate/submodels/CloudFunctionObjects/FacePostProcessing/FacePostProcessing.C

@@ -27,24 +27,33 @@ License
 #include "Pstream.H"
 #include "ListListOps.H"
 #include "surfaceWriter.H"
+#include "globalIndex.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 template<class CloudType>
-Foam::label Foam::FacePostProcessing<CloudType>::applyToFace
+void Foam::FacePostProcessing<CloudType>::applyToFace
 (
-    const label faceI
+    const label faceIn,
+    label& zoneI,
+    label& faceI
 ) const
 {
-    forAll(fZone_, i)
+    const faceZoneMesh& fzm = this->owner().mesh().faceZones();
-    {
-        if (fZone_[i] == faceI)
-        {
-            return i;
-        }
-    }
 
-    return -1;
+    forAll(faceZoneIDs_, i)
+    {
+        const faceZone& fz = fzm[faceZoneIDs_[i]];
+        forAll(fz, j)
+        {
+            if (fz[j] == faceIn)
+            {
+                zoneI = i;
+                faceI = j;
+                return;
+            }
+        }        
+    }
 }
 
 
@@ -52,6 +61,7 @@ template<class CloudType>
 void Foam::FacePostProcessing<CloudType>::write()
 {
     const fvMesh& mesh = this->owner().mesh();
+    const faceZoneMesh& fzm = this->owner().mesh().faceZones();
     const scalar dt = this->owner().time().deltaTValue();
 
     totalTime_ += dt;
@@ -59,136 +69,163 @@ void Foam::FacePostProcessing<CloudType>::write()
     const scalar alpha = (totalTime_ - dt)/totalTime_;
     const scalar beta = dt/totalTime_;
 
-    massTotal_ += mass_;
+    forAll(faceZoneIDs_, zoneI)
-
+    {
-    massFlux_ = alpha*massFlux_ + beta*mass_/dt;
+        massTotal_[zoneI] += mass_[zoneI];
+        massFlux_[zoneI] = alpha*massFlux_[zoneI] + beta*mass_[zoneI]/dt;
+    }
 
     const label procI = Pstream::myProcNo();
 
-    scalarListList allProcMass(Pstream::nProcs());
+    Info<< "particleFaceFlux output:" << nl;
-    allProcMass[procI].setSize(massTotal_.size());
-    allProcMass[procI] = massTotal_;
-    Pstream::gatherList(allProcMass);
-    scalarList allMass
-    (
-        ListListOps::combine<scalarList>
-        (
-            allProcMass, accessOp<scalarList>()
-        )
-    );
 
-    scalarListList allProcMassFlux(Pstream::nProcs());
+    List<scalarField> zoneMassTotal(mass_.size());
-    allProcMassFlux[procI].setSize(massFlux_.size());
+    forAll(zoneMassTotal, zoneI)
-    allProcMassFlux[procI] = massFlux_;
+    {
-    Pstream::gatherList(allProcMassFlux);
+        scalarListList allProcMass(Pstream::nProcs());
-    scalarList allMassFlux
+        allProcMass[procI] = massTotal_[zoneI];
-    (
+        Pstream::gatherList(allProcMass);
-        ListListOps::combine<scalarList>
+        zoneMassTotal[zoneI] =
-        (
+            ListListOps::combine<scalarList>
-            allProcMassFlux, accessOp<scalarList>()
+            (
-        )
+                allProcMass, accessOp<scalarList>()
-    );
+            );
 
-    Info<< "particleFaceFlux output:" << nl
+        const word& zoneName = fzm[faceZoneIDs_[zoneI]].name();
-        << "    total mass      = " << sum(allMass) << nl
+        Info<< "    " << zoneName << " total mass      = "
-        << "    average mass flux = " << sum(allMassFlux) << nl << endl;
+            << sum(zoneMassTotal[zoneI]) << nl;
+    }
+
+    List<scalarField> zoneMassFlux(massFlux_.size());
+    forAll(zoneMassFlux, zoneI)
+    {
+        scalarListList allProcMassFlux(Pstream::nProcs());
+        allProcMassFlux[procI] = massFlux_[zoneI];
+        Pstream::gatherList(allProcMassFlux);
+        zoneMassFlux[zoneI] =
+            ListListOps::combine<scalarList>
+            (
+                allProcMassFlux, accessOp<scalarList>()
+            );
+
+        const word& zoneName = fzm[faceZoneIDs_[zoneI]].name();
+        Info<< "    " << zoneName << " average mass flux = "
+            << sum(zoneMassFlux[zoneI]) << nl;
+    }
+
+    Info<< endl;
 
 
     if (surfaceFormat_ != "none")
     {
-        labelList pointToGlobal;
+        fileName outputDir = mesh.time().path();
-        labelList uniqueMeshPointLabels;
-        autoPtr<globalIndex> globalPointsPtr =
-            mesh.globalData().mergePoints
-            (
-                fZone_().meshPoints(),
-                fZone_().meshPointMap(),
-                pointToGlobal,
-                uniqueMeshPointLabels
-            );
 
-        pointField uniquePoints(mesh.points(), uniqueMeshPointLabels);
+        if (Pstream::parRun())
-        List<pointField> allProcPoints(Pstream::nProcs());
-        allProcPoints[procI].setSize(uniquePoints.size());
-        allProcPoints[procI] = uniquePoints;
-        Pstream::gatherList(allProcPoints);
-        pointField allPoints
-        (
-            ListListOps::combine<pointField>
-            (
-                allProcPoints, accessOp<pointField>()
-            )
-        );
-
-        faceList faces(fZone_().localFaces());
-        forAll(faces, i)
         {
-            inplaceRenumber(pointToGlobal, faces[i]);
+            // Put in undecomposed case (Note: gives problems for
+            // distributed data running)
+            outputDir =
+                outputDir/".."/"postProcessing"/cloud::prefix/
+                this->owner().name()/mesh.time().timeName();
         }
-        List<faceList> allProcFaces(Pstream::nProcs());
+        else
-        allProcFaces[procI].setSize(faces.size());
-        allProcFaces[procI] = faces;
-        Pstream::gatherList(allProcFaces);
-        faceList allFaces
-        (
-            ListListOps::combine<faceList>
-            (
-                allProcFaces, accessOp<faceList>()
-            )
-        );
-
-
-        if (Pstream::master())
         {
-            fileName outputDir = mesh.time().path();
+            outputDir =
+                outputDir/"postProcessing"/cloud::prefix/
+                this->owner().name()/mesh.time().timeName();
+        }
 
-            if (Pstream::parRun())
+        forAll(faceZoneIDs_, zoneI)
-            {
+        {
-                // Put in undecomposed case (Note: gives problems for
+            const faceZone& fZone = fzm[faceZoneIDs_[zoneI]];
-                // distributed data running)
-                outputDir =
-                    outputDir/".."/"postProcessing"/cloud::prefix/
-                    this->owner().name()/mesh.time().timeName();
-            }
-            else
-            {
-                outputDir =
-                    outputDir/"postProcessing"/cloud::prefix/
-                    this->owner().name()/mesh.time().timeName();
-            }
 
-            autoPtr<surfaceWriter> writer(surfaceWriter::New(surfaceFormat_));
+            labelList pointToGlobal;
-            writer->write
+            labelList uniqueMeshPointLabels;
-            (
+            autoPtr<globalIndex> globalPointsPtr =
-                outputDir,
+                mesh.globalData().mergePoints
-                "massTotal",
+                (
-                allPoints,
+                    fZone().meshPoints(),
-                allFaces,
+                    fZone().meshPointMap(),
-                "massTotal",
+                    pointToGlobal,
-                massTotal_,
+                    uniqueMeshPointLabels
-                false
+                );
-            );
+
-            writer->write
+            pointField uniquePoints(mesh.points(), uniqueMeshPointLabels);
-            (
+            List<pointField> allProcPoints(Pstream::nProcs());
-                outputDir,
+            allProcPoints[procI] = uniquePoints;
-                "massFlux",
+            Pstream::gatherList(allProcPoints);
-                allPoints,
+
-                allFaces,
+            faceList faces(fZone().localFaces());
-                "massFlux",
+            forAll(faces, i)
-                massFlux_,
+            {
-                false
+                inplaceRenumber(pointToGlobal, faces[i]);
-            );
+            }
+            List<faceList> allProcFaces(Pstream::nProcs());
+            allProcFaces[procI] = faces;
+            Pstream::gatherList(allProcFaces);
+
+            if (Pstream::master())
+            {
+                pointField allPoints
+                (
+                    ListListOps::combine<pointField>
+                    (
+                        allProcPoints, accessOp<pointField>()
+                    )
+                );
+
+                faceList allFaces
+                (
+                    ListListOps::combine<faceList>
+                    (
+                        allProcFaces, accessOp<faceList>()
+                    )
+                );
+
+                autoPtr<surfaceWriter> writer
+                (
+                    surfaceWriter::New(surfaceFormat_)
+                );
+
+                writer->write
+                (
+                    outputDir,
+                    fZone.name(),
+                    allPoints,
+                    allFaces,
+                    "massTotal",
+                    zoneMassTotal[zoneI],
+                    false
+                );
+
+                writer->write
+                (
+                    outputDir,
+                    fZone.name(),
+                    allPoints,
+                    allFaces,
+                    "massFlux",
+                    zoneMassFlux[zoneI],
+                    false
+                );
+            }
         }
     }
 
 
     if (resetOnWrite_)
     {
-        massFlux_ = 0.0;
+        forAll(faceZoneIDs_, zoneI)
+        {
+            massFlux_[zoneI] = 0.0;
+        }
         totalTime_ = 0.0;
     }
 
-    mass_ = 0.0;
+    forAll(mass_, zoneI)
+    {
+        mass_[zoneI] = 0.0;
+    }
 
     // writeProperties();
 }
@@ -204,7 +241,7 @@ Foam::FacePostProcessing<CloudType>::FacePostProcessing
 )
 :
     CloudFunctionObject<CloudType>(dict, owner, typeName),
-    fZone_(owner.mesh().faceZones()[this->coeffDict().lookup("faceZone")]),
+    faceZoneIDs_(),
     surfaceFormat_(this->coeffDict().lookup("surfaceFormat")),
     resetOnWrite_(this->coeffDict().lookup("resetOnWrite")),
     totalTime_(0.0),
@@ -212,15 +249,32 @@ Foam::FacePostProcessing<CloudType>::FacePostProcessing
     massTotal_(),
     massFlux_()
 {
-    label allFaces = returnReduce(fZone_().size(), sumOp<scalar>());
+    wordList faceZoneNames(this->coeffDict().lookup("faceZones"));
-    Info<< "        Number of faces = " << allFaces << endl;
+    mass_.setSize(faceZoneNames.size());
+    massTotal_.setSize(faceZoneNames.size());
+    massFlux_.setSize(faceZoneNames.size());
 
-    mass_.setSize(fZone_.size(), 0.0);
+    DynamicList<label> zoneIDs;
+    const faceZoneMesh& fzm = owner.mesh().faceZones();
+    forAll(faceZoneNames, i)
+    {
+        const word& zoneName = faceZoneNames[i];
+        label zoneI = fzm.findZoneID(zoneName);
+        if (zoneI != -1)
+        {
+            zoneIDs.append(zoneI);
+            const faceZone& fz = fzm[zoneI];
+            label nFaces = returnReduce(fz.size(), sumOp<label>());
+            mass_[i].setSize(nFaces, 0.0);
+            massTotal_[i].setSize(nFaces, 0.0);
+            massFlux_[i].setSize(nFaces, 0.0);
+            Info<< "        " << zoneName << " faces: " << nFaces;
+        }
+    }
+
+    faceZoneIDs_.transfer(zoneIDs);
 
     // readProperties(); AND initialise mass... fields
-
-    massTotal_.setSize(fZone_.size(), 0.0);
-    massFlux_.setSize(fZone_.size(), 0.0);
 }
 
 
@@ -231,7 +285,7 @@ Foam::FacePostProcessing<CloudType>::FacePostProcessing
 )
 :
     CloudFunctionObject<CloudType>(pff),
-    fZone_(pff.fZone_.clone(pff.fZone_.zoneMesh())),
+    faceZoneIDs_(pff.faceZoneIDs_),
     surfaceFormat_(pff.surfaceFormat_),
     resetOnWrite_(pff.resetOnWrite_),
     totalTime_(pff.totalTime_),
@@ -268,11 +322,13 @@ void Foam::FacePostProcessing<CloudType>::postFace(const parcelType& p)
      || this->owner().solution().transient()
     )
     {
-        const label faceI = applyToFace(p.face());
+        label zoneI = -1;
+        label faceI = -1;
+        applyToFace(p.face(), zoneI, faceI);
 
-        if (faceI != -1)
+        if ((zoneI != -1) && (faceI != -1))
         {
-            mass_[faceI] += p.mass()*p.nParticle();
+            mass_[zoneI][faceI] += p.mass()*p.nParticle();
         }
     }
 }

src/lagrangian/intermediate/submodels/CloudFunctionObjects/FacePostProcessing/FacePostProcessing.H

@@ -64,8 +64,8 @@ class FacePostProcessing
             typedef typename CloudType::parcelType parcelType;
 
 
-        //- Face zone
+        //- Face zone IDs
-        const faceZone& fZone_;
+        labelList faceZoneIDs_;
 
         //- Surface output format
         const word surfaceFormat_;
@@ -77,19 +77,24 @@ class FacePostProcessing
         scalar totalTime_;
 
         //- Mass storage
-        scalarField mass_;
+        List<scalarField> mass_;
 
         //- Mass total storage
-        scalarField massTotal_;
+        List<scalarField> massTotal_;
 
         //- Mass flux storage
-        scalarField massFlux_;
+        List<scalarField> massFlux_;
 
 
     // Private Member Functions
 
-        //- Return index into massFlux_ list if valid face, else -1
+        //- Return index into storage lists if valid zone and face
-        label applyToFace(const label faceI) const;
+        void applyToFace
+        (
+            const label faceIn,
+            label& zoneI, label&
+            faceI
+        ) const;
 
 
 protected:

src/lagrangian/intermediate/submodels/Kinematic/CollisionModel/NoCollision/NoCollision.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2009-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2009-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -87,7 +87,7 @@ public:
         //  this model this will always be 1.
         virtual label nSubCycles() const;
 
-        //- Flag to indicate whether model activates injection model
+        //- Flag to indicate whether model activates collision model
         virtual bool active() const;
 
         //- Indicates whether model determines wall collisions or not,

src/lagrangian/intermediate/submodels/Kinematic/CollisionModel/PairCollision/PairModel/PairSpringSliderDashpot/PairSpringSliderDashpot.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2008-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2008-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -92,12 +92,14 @@ Foam::PairSpringSliderDashpot<CloudType>::PairSpringSliderDashpot
     alpha_(readScalar(this->coeffDict().lookup("alpha"))),
     b_(readScalar(this->coeffDict().lookup("b"))),
     mu_(readScalar(this->coeffDict().lookup("mu"))),
+    cohesionEnergyDensity_
+    (
+        readScalar(this->coeffDict().lookup("cohesionEnergyDensity"))
+    ),
+    cohesion_(false),
     collisionResolutionSteps_
     (
-        readScalar
+        readScalar(this->coeffDict().lookup("collisionResolutionSteps"))
-        (
-            this->coeffDict().lookup("collisionResolutionSteps")
-        )
     ),
     volumeFactor_(1.0),
     useEquivalentSize_(Switch(this->coeffDict().lookup("useEquivalentSize")))
@@ -116,6 +118,8 @@ Foam::PairSpringSliderDashpot<CloudType>::PairSpringSliderDashpot
     scalar G = E/(2.0*(1.0 + nu));
 
     Gstar_ = G/(2.0*(2.0 - nu));
+
+    cohesion_ = (mag(cohesionEnergyDensity_) > VSMALL);
 }
 
 
@@ -183,13 +187,15 @@ void Foam::PairSpringSliderDashpot<CloudType>::evaluatePair
         dBEff *= cbrt(pB.nParticle()*volumeFactor_);
     }
 
-    scalar normalOverlapMag = 0.5*(dAEff + dBEff) - mag(r_AB);
+    scalar r_AB_mag = mag(r_AB);
+
+    scalar normalOverlapMag = 0.5*(dAEff + dBEff) - r_AB_mag;
 
     if (normalOverlapMag > 0)
     {
         //Particles in collision
 
-        vector rHat_AB = r_AB/(mag(r_AB) + VSMALL);
+        vector rHat_AB = r_AB/(r_AB_mag + VSMALL);
 
         vector U_AB = pA.U() - pB.U();
 
@@ -208,6 +214,15 @@ void Foam::PairSpringSliderDashpot<CloudType>::evaluatePair
             rHat_AB
            *(kN*pow(normalOverlapMag, b_) - etaN*(U_AB & rHat_AB));
 
+        // Cohesion force
+        if (cohesion_)
+        {
+            fN_AB +=
+                -cohesionEnergyDensity_
+                *overlapArea(dAEff/2.0, dBEff/2.0, r_AB_mag)
+                *rHat_AB;
+        }
+
         pA.f() += fN_AB;
         pB.f() += -fN_AB;
 

src/lagrangian/intermediate/submodels/Kinematic/CollisionModel/PairCollision/PairModel/PairSpringSliderDashpot/PairSpringSliderDashpot.H

@@ -34,6 +34,7 @@ Description
 
 #include "PairModel.H"
 #include "CollisionRecordList.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -67,6 +68,12 @@ class PairSpringSliderDashpot
         //- Coefficient of friction in for tangential sliding
         scalar mu_;
 
+        //- Cohesion energy density [J/m^3]
+        scalar cohesionEnergyDensity_;
+
+        // Switch cohesion on and off
+        bool cohesion_;
+
         //- The number of steps over which to resolve the minimum
         //  harmonic approximation of the collision period
         scalar collisionResolutionSteps_;
@@ -129,6 +136,23 @@ public:
             return volumeFactor_;
         }
 
+        // Return the area of overlap between two spheres of radii rA and rB,
+        // centres separated by a distance rAB.  Assumes rAB < (rA + rB).
+        inline scalar overlapArea(scalar rA, scalar rB, scalar rAB) const
+        {
+            // From:
+            // http://mathworld.wolfram.com/Sphere-SphereIntersection.html
+            return
+                mathematical::pi/4.0
+               /sqr(rAB)
+               *(
+                    (-rAB + rA - rB)
+                   *(-rAB - rA + rB)
+                   *(-rAB + rA + rB)
+                   *( rAB + rA + rA)
+                );
+        }
+
         //- Whether the PairModel has a timestep limit that will
         //  require subCycling
         virtual bool controlsTimestep() const;

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/CellZoneInjection/CellZoneInjection.C

@@ -158,45 +158,6 @@ void Foam::CellZoneInjection<CloudType>::setPositions
 }
 
 
-// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
-
-template<class CloudType>
-Foam::label Foam::CellZoneInjection<CloudType>::parcelsToInject
-(
-    const scalar time0,
-    const scalar time1
-)
-{
-    if ((0.0 >= time0) && (0.0 < time1))
-    {
-        return positions_.size();
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-
-template<class CloudType>
-Foam::scalar Foam::CellZoneInjection<CloudType>::volumeToInject
-(
-    const scalar time0,
-    const scalar time1
-)
-{
-    // All parcels introduced at SOI
-    if ((0.0 >= time0) && (0.0 < time1))
-    {
-        return this->volumeTotal_;
-    }
-    else
-    {
-        return 0.0;
-    }
-}
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class CloudType>
@@ -316,6 +277,43 @@ Foam::scalar Foam::CellZoneInjection<CloudType>::timeEnd() const
 }
 
 
+template<class CloudType>
+Foam::label Foam::CellZoneInjection<CloudType>::parcelsToInject
+(
+    const scalar time0,
+    const scalar time1
+)
+{
+    if ((0.0 >= time0) && (0.0 < time1))
+    {
+        return positions_.size();
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+
+template<class CloudType>
+Foam::scalar Foam::CellZoneInjection<CloudType>::volumeToInject
+(
+    const scalar time0,
+    const scalar time1
+)
+{
+    // All parcels introduced at SOI
+    if ((0.0 >= time0) && (0.0 < time1))
+    {
+        return this->volumeTotal_;
+    }
+    else
+    {
+        return 0.0;
+    }
+}
+
+
 template<class CloudType>
 void Foam::CellZoneInjection<CloudType>::setPositionAndCell
 (

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/CellZoneInjection/CellZoneInjection.H

@@ -95,25 +95,6 @@ class CellZoneInjection
         void setPositions(const labelList& cellZoneCells);
 
 
-protected:
-
-    // Protected member functions
-
-        //- Number of parcels to introduce over the time step relative to SOI
-        label parcelsToInject
-        (
-            const scalar time0,
-            const scalar time1
-        );
-
-        //- Volume of parcels to introduce over the time step relative to SOI
-        scalar volumeToInject
-        (
-            const scalar time0,
-            const scalar time1
-        );
-
-
 public:
 
     //- Runtime type information
@@ -147,6 +128,12 @@ public:
         //- Return the end-of-injection time
         scalar timeEnd() const;
 
+        //- Number of parcels to introduce relative to SOI
+        label parcelsToInject(const scalar time0, const scalar time1);
+
+        //- Volume of parcels to introduce relative to SOI
+        scalar volumeToInject(const scalar time0, const scalar time1);
+
 
         // Injection geometry
 

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeInjection/ConeInjection.C

@@ -30,53 +30,6 @@ License
 
 using namespace Foam::constant::mathematical;
 
-// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
-
-template<class CloudType>
-Foam::label Foam::ConeInjection<CloudType>::parcelsToInject
-(
-    const scalar time0,
-    const scalar time1
-)
-{
-    if ((time0 >= 0.0) && (time0 < duration_))
-    {
-        const scalar targetVolume = flowRateProfile_().integrate(0, time1);
-
-        const label targetParcels =
-            parcelsPerInjector_*targetVolume/this->volumeTotal_;
-
-        const label nToInject = targetParcels - nInjected_;
-
-        nInjected_ += nToInject;
-
-        return positionAxis_.size()*nToInject;
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-
-template<class CloudType>
-Foam::scalar Foam::ConeInjection<CloudType>::volumeToInject
-(
-    const scalar time0,
-    const scalar time1
-)
-{
-    if ((time0 >= 0.0) && (time0 < duration_))
-    {
-        return flowRateProfile_().integrate(time0, time1);
-    }
-    else
-    {
-        return 0.0;
-    }
-}
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class CloudType>
@@ -195,6 +148,51 @@ Foam::scalar Foam::ConeInjection<CloudType>::timeEnd() const
 }
 
 
+template<class CloudType>
+Foam::label Foam::ConeInjection<CloudType>::parcelsToInject
+(
+    const scalar time0,
+    const scalar time1
+)
+{
+    if ((time0 >= 0.0) && (time0 < duration_))
+    {
+        const scalar targetVolume = flowRateProfile_().integrate(0, time1);
+
+        const label targetParcels =
+            parcelsPerInjector_*targetVolume/this->volumeTotal_;
+
+        const label nToInject = targetParcels - nInjected_;
+
+        nInjected_ += nToInject;
+
+        return positionAxis_.size()*nToInject;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+
+template<class CloudType>
+Foam::scalar Foam::ConeInjection<CloudType>::volumeToInject
+(
+    const scalar time0,
+    const scalar time1
+)
+{
+    if ((time0 >= 0.0) && (time0 < duration_))
+    {
+        return flowRateProfile_().integrate(time0, time1);
+    }
+    else
+    {
+        return 0.0;
+    }
+}
+
+
 template<class CloudType>
 void Foam::ConeInjection<CloudType>::setPositionAndCell
 (

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeInjection/ConeInjection.H

@@ -113,17 +113,6 @@ class ConeInjection
             vectorList tanVec2_;
 
 
-protected:
-
-    // Protected Member Functions
-
-        //- Number of parcels to introduce over the time step relative to SOI
-        virtual label parcelsToInject(const scalar time0, const scalar time1);
-
-        //- Volume of parcels to introduce over the time step relative to SOI
-        virtual scalar volumeToInject(const scalar time0, const scalar time1);
-
-
 public:
 
     //- Runtime type information
@@ -157,6 +146,13 @@ public:
         //- Return the end-of-injection time
         scalar timeEnd() const;
 
+        //- Number of parcels to introduce relative to SOI
+        virtual label parcelsToInject(const scalar time0, const scalar time1);
+
+        //- Volume of parcels to introduce relative to SOI
+        virtual scalar volumeToInject(const scalar time0, const scalar time1);
+
+
 
         // Injection geometry
 

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.C

@@ -0,0 +1,374 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 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 "ConeNozzleInjection.H"
+#include "DataEntry.H"
+#include "mathematicalConstants.H"
+#include "distributionModel.H"
+
+using namespace Foam::constant;
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::ConeNozzleInjection<CloudType>::ConeNozzleInjection
+(
+    const dictionary& dict,
+    CloudType& owner
+)
+:
+    InjectionModel<CloudType>(dict, owner, typeName),
+    injectionMethod_(imPoint),
+    outerNozzleDiameter_
+    (
+        readScalar(this->coeffDict().lookup("outerNozzleDiameter"))
+    ),
+    innerNozzleDiameter_
+    (
+        readScalar(this->coeffDict().lookup("innerNozzleDiameter"))
+    ),
+    duration_(readScalar(this->coeffDict().lookup("duration"))),
+    position_(this->coeffDict().lookup("position")),
+    injectorCell_(-1),
+    tetFaceI_(-1),
+    tetPtI_(-1),
+    direction_(this->coeffDict().lookup("direction")),
+    parcelsPerSecond_
+    (
+        readScalar(this->coeffDict().lookup("parcelsPerSecond"))
+    ),
+    volumeFlowRate_
+    (
+        DataEntry<scalar>::New
+        (
+            "volumeFlowRate",
+            this->coeffDict()
+        )
+    ),
+    Cd_
+    (
+        DataEntry<scalar>::New
+        (
+            "Cd",
+            this->coeffDict()
+        )
+    ),
+    thetaInner_
+    (
+        DataEntry<scalar>::New
+        (
+            "thetaInner",
+            this->coeffDict()
+        )
+    ),
+    thetaOuter_
+    (
+        DataEntry<scalar>::New
+        (
+            "thetaOuter",
+            this->coeffDict()
+        )
+    ),
+    sizeDistribution_
+    (
+        distributionModels::distributionModel::New
+        (
+            this->coeffDict().subDict("sizeDistribution"),
+            owner.rndGen()
+        )
+    ),
+    tanVec1_(vector::zero),
+    tanVec2_(vector::zero),
+    normal_(vector::zero)
+{
+    if (innerNozzleDiameter_ >= outerNozzleDiameter_)
+    {
+        FatalErrorIn
+        (
+            "Foam::ConeNozzleInjection<CloudType>::ConeNozzleInjection"
+            "("
+                "const dictionary&, "
+                "CloudType&"
+            ")"
+        )<< "innerNozzleDiameter >= outerNozzleDiameter" << nl
+         << exit(FatalError);
+    }
+
+    word injectionMethodType = this->coeffDict().lookup("injectionMethod");
+
+    if (injectionMethodType == "disc")
+    {
+        injectionMethod_ = imDisc;
+    }
+    else if (injectionMethodType == "point")
+    {
+        injectionMethod_ = imPoint;
+
+        // Set/cache the injector cell
+        this->findCellAtPosition
+        (
+            injectorCell_,
+            tetFaceI_,
+            tetPtI_,
+            position_,
+            false
+        );
+    }
+    else
+    {
+        FatalErrorIn
+        (
+            "Foam::InjectionModel<CloudType>::InjectionModel"
+            "("
+                "const dictionary&, "
+                "CloudType&"
+            ")"
+        )<< "injectionMethod must be either 'point' or 'disc'" << nl
+         << exit(FatalError);
+    }
+
+    cachedRandom& rndGen = this->owner().rndGen();
+
+    // Normalise direction vector
+    direction_ /= mag(direction_);
+
+    // Determine direction vectors tangential to direction
+    vector tangent = vector::zero;
+    scalar magTangent = 0.0;
+
+    while(magTangent < SMALL)
+    {
+        vector v = rndGen.sample01<vector>();
+
+        tangent = v - (v & direction_)*direction_;
+        magTangent = mag(tangent);
+    }
+
+    tanVec1_ = tangent/magTangent;
+    tanVec2_ = direction_^tanVec1_;
+
+    // Set total volume to inject
+    this->volumeTotal_ = volumeFlowRate_().integrate(0.0, duration_);
+}
+
+
+template<class CloudType>
+Foam::ConeNozzleInjection<CloudType>::ConeNozzleInjection
+(
+    const ConeNozzleInjection<CloudType>& im
+)
+:
+    InjectionModel<CloudType>(im),
+    injectionMethod_(im.injectionMethod_),
+    outerNozzleDiameter_(im.outerNozzleDiameter_),
+    innerNozzleDiameter_(im.innerNozzleDiameter_),
+    duration_(im.duration_),
+    position_(im.position_),
+    injectorCell_(im.injectorCell_),
+    direction_(im.direction_),
+    parcelsPerSecond_(im.parcelsPerSecond_),
+    volumeFlowRate_(im.volumeFlowRate_().clone().ptr()),
+    Cd_(im.Cd_().clone().ptr()),
+    thetaInner_(im.thetaInner_().clone().ptr()),
+    thetaOuter_(im.thetaOuter_().clone().ptr()),
+    sizeDistribution_(im.sizeDistribution_().clone().ptr()),
+    tanVec1_(im.tanVec1_),
+    tanVec2_(im.tanVec1_),
+    normal_(im.normal_)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::ConeNozzleInjection<CloudType>::~ConeNozzleInjection()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::scalar Foam::ConeNozzleInjection<CloudType>::timeEnd() const
+{
+    return this->SOI_ + duration_;
+}
+
+
+template<class CloudType>
+Foam::label Foam::ConeNozzleInjection<CloudType>::parcelsToInject
+(
+    const scalar time0,
+    const scalar time1
+)
+{
+    if ((time0 >= 0.0) && (time0 < duration_))
+    {
+        return floor((time1 - time0)*parcelsPerSecond_);
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+
+template<class CloudType>
+Foam::scalar Foam::ConeNozzleInjection<CloudType>::volumeToInject
+(
+    const scalar time0,
+    const scalar time1
+)
+{
+    if ((time0 >= 0.0) && (time0 < duration_))
+    {
+        return volumeFlowRate_().integrate(time0, time1);
+    }
+    else
+    {
+        return 0.0;
+    }
+}
+
+
+template<class CloudType>
+void Foam::ConeNozzleInjection<CloudType>::setPositionAndCell
+(
+    const label,
+    const label,
+    const scalar,
+    vector& position,
+    label& cellOwner,
+    label& tetFaceI,
+    label& tetPtI
+)
+{
+    cachedRandom& rndGen = this->owner().rndGen();
+
+    scalar beta = mathematical::twoPi*rndGen.sample01<scalar>();
+    normal_ = tanVec1_*cos(beta) + tanVec2_*sin(beta);
+
+    switch (injectionMethod_)
+    {
+        case imPoint:
+        {
+            position = position_;
+            cellOwner = injectorCell_;
+            tetFaceI = tetFaceI_;
+            tetPtI = tetPtI_;
+
+            break;
+        }
+        case imDisc:
+        {
+            scalar frac = rndGen.sample01<scalar>();
+            scalar dr = outerNozzleDiameter_ - innerNozzleDiameter_;
+            scalar r = 0.5*(innerNozzleDiameter_ + frac*dr);
+            position = position_ + r*normal_;
+
+            this->findCellAtPosition
+            (
+                cellOwner,
+                tetFaceI,
+                tetPtI,
+                position,
+                false
+            );
+            break;
+        }
+        default:
+        {
+            FatalErrorIn
+            (
+                "void Foam::ConeNozzleInjection<CloudType>::setPositionAndCell"
+                "("
+                    "const label, "
+                    "const label, "
+                    "const scalar, "
+                    "vector&, "
+                    "label&"
+                ")"
+            )<< "Unknown injectionMethod type" << nl
+             << exit(FatalError);
+        }
+    }
+}
+
+
+template<class CloudType>
+void Foam::ConeNozzleInjection<CloudType>::setProperties
+(
+    const label parcelI,
+    const label,
+    const scalar time,
+    typename CloudType::parcelType& parcel
+)
+{
+    cachedRandom& rndGen = this->owner().rndGen();
+
+    // set particle velocity
+    const scalar deg2Rad = mathematical::pi/180.0;
+
+    scalar t = time - this->SOI_;
+    scalar ti = thetaInner_().value(t);
+    scalar to = thetaOuter_().value(t);
+    scalar coneAngle = rndGen.sample01<scalar>()*(to - ti) + ti;
+
+    coneAngle *= deg2Rad;
+    scalar alpha = sin(coneAngle);
+    scalar dcorr = cos(coneAngle);
+
+    vector normal = alpha*normal_;
+    vector dirVec = dcorr*direction_;
+    dirVec += normal;
+    dirVec /= mag(dirVec);
+
+    scalar Ao = 0.25*mathematical::pi*outerNozzleDiameter_*outerNozzleDiameter_;
+    scalar Ai = 0.25*mathematical::pi*innerNozzleDiameter_*innerNozzleDiameter_;
+    scalar massFlowRate =
+        this->massTotal()*volumeFlowRate_().value(t)/this->volumeTotal();
+
+    scalar Umag = massFlowRate/(parcel.rho()*Cd_().value(t)*(Ao - Ai));
+    parcel.U() = Umag*dirVec;
+
+    // set particle diameter
+    parcel.d() = sizeDistribution_->sample();
+}
+
+
+template<class CloudType>
+bool Foam::ConeNozzleInjection<CloudType>::fullyDescribed() const
+{
+    return false;
+}
+
+
+template<class CloudType>
+bool Foam::ConeNozzleInjection<CloudType>::validInjection(const label)
+{
+    return true;
+}
+
+
+// ************************************************************************* //

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.H

@@ -0,0 +1,235 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 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::ConeNozzleInjection
+
+Description
+    Cone injection
+
+    - User specifies
+      - time of start of injection
+      - injector position
+      - direction (along injection axis)
+      - parcel flow rate
+      - discharge coefficient, Cd
+      - inner and outer cone angles
+
+    - Parcel diameters obtained by size distribution model
+
+    - Parcel velocity is calculated as:
+
+        U = V_dot/(A * Cd), where V_dot is the volume flow rate
+
+    Based on the old 'unitInjection' model
+
+SourceFiles
+    ConeNozzleInjection.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef ConeNozzleInjection_H
+#define ConeNozzleInjection_H
+
+#include "InjectionModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+
+template<class Type>
+class DataEntry;
+
+class distributionModel;
+
+/*---------------------------------------------------------------------------*\
+                     Class ConeNozzleInjection Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class CloudType>
+class ConeNozzleInjection
+:
+    public InjectionModel<CloudType>
+{
+public:
+
+    //- Injection method enumeration
+    enum injectionMethod
+    {
+        imPoint,
+        imDisc
+    };
+
+
+private:
+
+    // Private data
+
+        //- point/disc injection method
+        injectionMethod injectionMethod_;
+
+        //- Outer nozzle diameter [m]
+        const scalar outerNozzleDiameter_;
+
+        //- Inner nozzle diameter [m]
+        const scalar innerNozzleDiameter_;
+
+        //- Injection duration [s]
+        const scalar duration_;
+
+        //- Injector position [m]
+        vector position_;
+
+        //- Cell containing injector position []
+        label injectorCell_;
+
+        //- Index of tet face for injector cell
+        label tetFaceI_;
+
+        //- Index of tet point for injector cell
+        label tetPtI_;
+
+        //- Injector direction []
+        vector direction_;
+
+        //- Number of parcels to introduce per second []
+        const label parcelsPerSecond_;
+
+        //- Volume flow rate of parcels to introduce relative to SOI [m^3/s]
+        const autoPtr<DataEntry<scalar> > volumeFlowRate_;
+
+        //- Discharge coefficient, relative to SOI [m/s]
+        const autoPtr<DataEntry<scalar> > Cd_;
+
+        //- Inner cone angle relative to SOI [deg]
+        const autoPtr<DataEntry<scalar> > thetaInner_;
+
+        //- Outer cone angle relative to SOI [deg]
+        const autoPtr<DataEntry<scalar> > thetaOuter_;
+
+        //- Parcel size PDF model
+        const autoPtr<distributionModels::distributionModel> sizeDistribution_;
+
+
+        // Tangential vectors to the direction vector
+
+            //- First tangential vector
+            vector tanVec1_;
+
+            //- Second tangential vector
+            vector tanVec2_;
+
+            //- injection vector orthogonal to direction
+            vector normal_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("coneNozzleInjection");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        ConeNozzleInjection(const dictionary& dict, CloudType& owner);
+
+        //- Construct copy
+        ConeNozzleInjection(const ConeNozzleInjection<CloudType>& im);
+
+        //- Construct and return a clone
+        virtual autoPtr<InjectionModel<CloudType> > clone() const
+        {
+            return autoPtr<InjectionModel<CloudType> >
+            (
+                new ConeNozzleInjection<CloudType>(*this)
+            );
+        }
+
+
+    //- Destructor
+    virtual ~ConeNozzleInjection();
+
+
+    // Member Functions
+
+        //- Return the end-of-injection time
+        scalar timeEnd() const;
+
+        //- Number of parcels to introduce relative to SOI
+        virtual label parcelsToInject(const scalar time0, const scalar time1);
+
+        //- Volume of parcels to introduce relative to SOI
+        virtual scalar volumeToInject(const scalar time0, const scalar time1);
+
+
+        // Injection geometry
+
+            //- Set the injection position and owner cell
+            virtual void setPositionAndCell
+            (
+                const label parcelI,
+                const label nParcels,
+                const scalar time,
+                vector& position,
+                label& cellOwner,
+                label& tetFaceI,
+                label& tetPtI
+            );
+
+            //- Set the parcel properties
+            virtual void setProperties
+            (
+                const label parcelI,
+                const label nParcels,
+                const scalar time,
+                typename CloudType::parcelType& parcel
+            );
+
+            //- Flag to identify whether model fully describes the parcel
+            virtual bool fullyDescribed() const;
+
+            //- Return flag to identify whether or not injection of parcelI is
+            //  permitted
+            virtual bool validInjection(const label parcelI);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "ConeNozzleInjection.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/FieldActivatedInjection/FieldActivatedInjection.C

@@ -29,44 +29,6 @@ License
 
 using namespace Foam::constant::mathematical;
 
-// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
-
-template<class CloudType>
-Foam::label Foam::FieldActivatedInjection<CloudType>::parcelsToInject
-(
-    const scalar time0,
-    const scalar time1
-)
-{
-    if (sum(nParcelsInjected_) < nParcelsPerInjector_*positions_.size())
-    {
-        return positions_.size();
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-
-template<class CloudType>
-Foam::scalar Foam::FieldActivatedInjection<CloudType>::volumeToInject
-(
-    const scalar time0,
-    const scalar time1
-)
-{
-    if (sum(nParcelsInjected_) < nParcelsPerInjector_*positions_.size())
-    {
-        return this->volumeTotal_/nParcelsPerInjector_;
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class CloudType>
@@ -180,16 +142,45 @@ Foam::FieldActivatedInjection<CloudType>::~FieldActivatedInjection()
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class CloudType>
-bool Foam::FieldActivatedInjection<CloudType>::active() const
+Foam::scalar Foam::FieldActivatedInjection<CloudType>::timeEnd() const
 {
-    return true;
+    return GREAT;
 }
 
 
 template<class CloudType>
-Foam::scalar Foam::FieldActivatedInjection<CloudType>::timeEnd() const
+Foam::label Foam::FieldActivatedInjection<CloudType>::parcelsToInject
+(
+    const scalar time0,
+    const scalar time1
+)
 {
-    return GREAT;
+    if (sum(nParcelsInjected_) < nParcelsPerInjector_*positions_.size())
+    {
+        return positions_.size();
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+
+template<class CloudType>
+Foam::scalar Foam::FieldActivatedInjection<CloudType>::volumeToInject
+(
+    const scalar time0,
+    const scalar time1
+)
+{
+    if (sum(nParcelsInjected_) < nParcelsPerInjector_*positions_.size())
+    {
+        return this->volumeTotal_/nParcelsPerInjector_;
+    }
+    else
+    {
+        return 0;
+    }
 }
 
 

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/FieldActivatedInjection/FieldActivatedInjection.H

@@ -115,17 +115,6 @@ class FieldActivatedInjection
                 sizeDistribution_;
 
 
-protected:
-
-    // Protected Member Functions
-
-        //- Number of parcels to introduce over the time step relative to SOI
-        virtual label parcelsToInject(const scalar time0, const scalar time1);
-
-        //- Volume of parcels to introduce over the time step relative to SOI
-        virtual scalar volumeToInject(const scalar time0, const scalar time1);
-
-
 public:
 
     //- Runtime type information
@@ -156,12 +145,15 @@ public:
 
     // Member Functions
 
-        //- Flag to indicate whether model activates injection model
-        bool active() const;
-
         //- Return the end-of-injection time
         scalar timeEnd() const;
 
+        //- Number of parcels to introduce relative to SOI
+        virtual label parcelsToInject(const scalar time0, const scalar time1);
+
+        //- Volume of parcels to introduce relative to SOI
+        virtual scalar volumeToInject(const scalar time0, const scalar time1);
+
 
         // Injection geometry
 

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/InflationInjection/InflationInjection.C

@@ -31,7 +31,129 @@ License
 
 using namespace Foam::constant::mathematical;
 
-// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::InflationInjection<CloudType>::InflationInjection
+(
+    const dictionary& dict,
+    CloudType& owner
+)
+:
+    InjectionModel<CloudType>(dict, owner, typeName),
+    generationSetName_(this->coeffDict().lookup("generationCellSet")),
+    inflationSetName_(this->coeffDict().lookup("inflationCellSet")),
+    generationCells_(),
+    inflationCells_(),
+    duration_(readScalar(this->coeffDict().lookup("duration"))),
+    flowRateProfile_
+    (
+        DataEntry<scalar>::New
+        (
+            "flowRateProfile",
+            this->coeffDict()
+        )
+    ),
+    growthRate_
+    (
+        DataEntry<scalar>::New
+        (
+            "growthRate",
+            this->coeffDict()
+        )
+    ),
+    newParticles_(),
+    volumeAccumulator_(0.0),
+    fraction_(1.0),
+    selfSeed_(this->coeffDict().lookupOrDefault("selfSeed", false)),
+    dSeed_(SMALL),
+    sizeDistribution_
+    (
+        distributionModels::distributionModel::New
+        (
+            this->coeffDict().subDict("sizeDistribution"),
+            owner.rndGen()
+        )
+    )
+{
+    if (selfSeed_)
+    {
+        dSeed_ = readScalar(this->coeffDict().lookup("dSeed"));
+    }
+
+    cellSet generationCells(this->owner().mesh(), generationSetName_);
+
+    generationCells_ = generationCells.toc();
+
+    cellSet inflationCells(this->owner().mesh(), inflationSetName_);
+
+    // Union of cellSets
+    inflationCells |= generationCells;
+
+    inflationCells_ = inflationCells.toc();
+
+    if (Pstream::parRun())
+    {
+        scalar generationVolume = 0.0;
+
+        forAll(generationCells_, gCI)
+        {
+            label cI = generationCells_[gCI];
+
+            generationVolume += this->owner().mesh().cellVolumes()[cI];
+        }
+
+        scalar totalGenerationVolume = generationVolume;
+
+        reduce(totalGenerationVolume, sumOp<scalar>());
+
+        fraction_ = generationVolume/totalGenerationVolume;
+    }
+
+    // Set total volume/mass to inject
+    this->volumeTotal_ = fraction_*flowRateProfile_().integrate(0.0, duration_);
+    this->massTotal_ *= fraction_;
+}
+
+
+template<class CloudType>
+Foam::InflationInjection<CloudType>::InflationInjection
+(
+    const Foam::InflationInjection<CloudType>& im
+)
+:
+    InjectionModel<CloudType>(im),
+    generationSetName_(im.generationSetName_),
+    inflationSetName_(im.inflationSetName_),
+    generationCells_(im.generationCells_),
+    inflationCells_(im.inflationCells_),
+    duration_(im.duration_),
+    flowRateProfile_(im.flowRateProfile_().clone().ptr()),
+    growthRate_(im.growthRate_().clone().ptr()),
+    newParticles_(im.newParticles_),
+    volumeAccumulator_(im.volumeAccumulator_),
+    fraction_(im.fraction_),
+    selfSeed_(im.selfSeed_),
+    dSeed_(im.dSeed_),
+    sizeDistribution_(im.sizeDistribution_().clone().ptr())
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::InflationInjection<CloudType>::~InflationInjection()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::scalar Foam::InflationInjection<CloudType>::timeEnd() const
+{
+    return this->SOI_ + duration_;
+}
+
 
 template<class CloudType>
 Foam::label Foam::InflationInjection<CloudType>::parcelsToInject
@@ -305,130 +427,6 @@ Foam::scalar Foam::InflationInjection<CloudType>::volumeToInject
 }
 
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-template<class CloudType>
-Foam::InflationInjection<CloudType>::InflationInjection
-(
-    const dictionary& dict,
-    CloudType& owner
-)
-:
-    InjectionModel<CloudType>(dict, owner, typeName),
-    generationSetName_(this->coeffDict().lookup("generationCellSet")),
-    inflationSetName_(this->coeffDict().lookup("inflationCellSet")),
-    generationCells_(),
-    inflationCells_(),
-    duration_(readScalar(this->coeffDict().lookup("duration"))),
-    flowRateProfile_
-    (
-        DataEntry<scalar>::New
-        (
-            "flowRateProfile",
-            this->coeffDict()
-        )
-    ),
-    growthRate_
-    (
-        DataEntry<scalar>::New
-        (
-            "growthRate",
-            this->coeffDict()
-        )
-    ),
-    newParticles_(),
-    volumeAccumulator_(0.0),
-    fraction_(1.0),
-    selfSeed_(this->coeffDict().lookupOrDefault("selfSeed", false)),
-    dSeed_(SMALL),
-    sizeDistribution_
-    (
-        distributionModels::distributionModel::New
-        (
-            this->coeffDict().subDict("sizeDistribution"),
-            owner.rndGen()
-        )
-    )
-{
-    if (selfSeed_)
-    {
-        dSeed_ = readScalar(this->coeffDict().lookup("dSeed"));
-    }
-
-    cellSet generationCells(this->owner().mesh(), generationSetName_);
-
-    generationCells_ = generationCells.toc();
-
-    cellSet inflationCells(this->owner().mesh(), inflationSetName_);
-
-    // Union of cellSets
-    inflationCells |= generationCells;
-
-    inflationCells_ = inflationCells.toc();
-
-    if (Pstream::parRun())
-    {
-        scalar generationVolume = 0.0;
-
-        forAll(generationCells_, gCI)
-        {
-            label cI = generationCells_[gCI];
-
-            generationVolume += this->owner().mesh().cellVolumes()[cI];
-        }
-
-        scalar totalGenerationVolume = generationVolume;
-
-        reduce(totalGenerationVolume, sumOp<scalar>());
-
-        fraction_ = generationVolume/totalGenerationVolume;
-    }
-
-    // Set total volume/mass to inject
-    this->volumeTotal_ = fraction_*flowRateProfile_().integrate(0.0, duration_);
-    this->massTotal_ *= fraction_;
-}
-
-
-template<class CloudType>
-Foam::InflationInjection<CloudType>::InflationInjection
-(
-    const Foam::InflationInjection<CloudType>& im
-)
-:
-    InjectionModel<CloudType>(im),
-    generationSetName_(im.generationSetName_),
-    inflationSetName_(im.inflationSetName_),
-    generationCells_(im.generationCells_),
-    inflationCells_(im.inflationCells_),
-    duration_(im.duration_),
-    flowRateProfile_(im.flowRateProfile_().clone().ptr()),
-    growthRate_(im.growthRate_().clone().ptr()),
-    newParticles_(im.newParticles_),
-    volumeAccumulator_(im.volumeAccumulator_),
-    fraction_(im.fraction_),
-    selfSeed_(im.selfSeed_),
-    dSeed_(im.dSeed_),
-    sizeDistribution_(im.sizeDistribution_().clone().ptr())
-{}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-template<class CloudType>
-Foam::InflationInjection<CloudType>::~InflationInjection()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class CloudType>
-Foam::scalar Foam::InflationInjection<CloudType>::timeEnd() const
-{
-    return this->SOI_ + duration_;
-}
-
-
 template<class CloudType>
 void Foam::InflationInjection<CloudType>::setPositionAndCell
 (

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/InflationInjection/InflationInjection.H

@@ -111,17 +111,6 @@ class InflationInjection
         const autoPtr<distributionModels::distributionModel> sizeDistribution_;
 
 
-protected:
-
-    // Protected Member Functions
-
-        //- Number of parcels to introduce over the time step relative to SOI
-        virtual label parcelsToInject(const scalar time0, const scalar time1);
-
-        //- Volume of parcels to introduce over the time step relative to SOI
-        virtual scalar volumeToInject(const scalar time0, const scalar time1);
-
-
 public:
 
     //- Runtime type information
@@ -155,6 +144,12 @@ public:
         //- Return the end-of-injection time
         scalar timeEnd() const;
 
+        //- Number of parcels to introduce relative to SOI
+        virtual label parcelsToInject(const scalar time0, const scalar time1);
+
+        //- Volume of parcels to introduce relative to SOI
+        virtual scalar volumeToInject(const scalar time0, const scalar time1);
+
 
         // Injection geometry
 

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/InjectionModel/InjectionModel.C

@@ -101,46 +101,6 @@ void Foam::InjectionModel<CloudType>::writeProps()
 }
 
 
-template<class CloudType>
-Foam::label Foam::InjectionModel<CloudType>::parcelsToInject
-(
-    const scalar time0,
-    const scalar time1
-)
-{
-    notImplemented
-    (
-        "Foam::label Foam::InjectionModel<CloudType>::parcelsToInject"
-        "("
-            "const scalar, "
-            "const scalar"
-        ") const"
-    );
-
-    return 0;
-}
-
-
-template<class CloudType>
-Foam::scalar Foam::InjectionModel<CloudType>::volumeToInject
-(
-    const scalar time0,
-    const scalar time1
-)
-{
-    notImplemented
-    (
-        "Foam::scalar Foam::InjectionModel<CloudType>::volumeToInject"
-        "("
-            "const scalar, "
-            "const scalar"
-        ") const"
-    );
-
-    return 0.0;
-}
-
-
 template<class CloudType>
 bool Foam::InjectionModel<CloudType>::validInjection(const label parcelI)
 {
@@ -510,6 +470,54 @@ Foam::scalar Foam::InjectionModel<CloudType>::timeEnd() const
 }
 
 
+template<class CloudType>
+Foam::label Foam::InjectionModel<CloudType>::parcelsToInject
+(
+    const scalar time0,
+    const scalar time1
+)
+{
+    notImplemented
+    (
+        "Foam::label Foam::InjectionModel<CloudType>::parcelsToInject"
+        "("
+            "const scalar, "
+            "const scalar"
+        ") const"
+    );
+
+    return 0;
+}
+
+
+template<class CloudType>
+Foam::scalar Foam::InjectionModel<CloudType>::volumeToInject
+(
+    const scalar time0,
+    const scalar time1
+)
+{
+    notImplemented
+    (
+        "Foam::scalar Foam::InjectionModel<CloudType>::volumeToInject"
+        "("
+            "const scalar, "
+            "const scalar"
+        ") const"
+    );
+
+    return 0.0;
+}
+
+
+template<class CloudType>
+Foam::scalar Foam::InjectionModel<CloudType>::averageParcelMass()
+{
+    label nTotal = parcelsToInject(0.0, timeEnd() - timeStart());
+    return massTotal_/nTotal;
+}
+
+
 template<class CloudType>
 template<class TrackData>
 void Foam::InjectionModel<CloudType>::inject(TrackData& td)
@@ -522,6 +530,7 @@ void Foam::InjectionModel<CloudType>::inject(TrackData& td)
     const scalar time = this->owner().db().time().value();
     const scalar trackTime = this->owner().solution().trackTime();
     const polyMesh& mesh = this->owner().mesh();
+    typename TrackData::cloudType& cloud = td.cloud();
 
     // Prepare for next time step
     label parcelsAdded = 0;
@@ -583,11 +592,14 @@ void Foam::InjectionModel<CloudType>::inject(TrackData& td)
                     tetPtI
                 );
 
+                // Check/set new parcel thermo properties
+                cloud.setParcelThermoProperties(*pPtr, dt);
+
                 // Assign new parcel properties in injection model
                 setProperties(parcelI, newParcels, timeInj, *pPtr);
 
-                // Check new parcel properties
+                // Check/set new parcel injection properties
-                td.cloud().checkParcelProperties(*pPtr, dt, fullyDescribed());
+                cloud.checkParcelProperties(*pPtr, dt, fullyDescribed());
 
                 // Apply correction to velocity for 2-D cases
                 meshTools::constrainDirection
@@ -639,6 +651,7 @@ void Foam::InjectionModel<CloudType>::injectSteadyState
     }
 
     const polyMesh& mesh = this->owner().mesh();
+    typename TrackData::cloudType& cloud = td.cloud();
 
     // Reset counters
     time0_ = 0.0;
@@ -688,11 +701,14 @@ void Foam::InjectionModel<CloudType>::injectSteadyState
                 tetPtI
             );
 
+            // Check/set new parcel thermo properties
+            cloud.setParcelThermoProperties(*pPtr, 0.0);
+
             // Assign new parcel properties in injection model
             setProperties(parcelI, newParcels, 0.0, *pPtr);
 
-            // Check new parcel properties
+            // Check/set new parcel injection properties
-            td.cloud().checkParcelProperties(*pPtr, 0.0, fullyDescribed());
+            cloud.checkParcelProperties(*pPtr, 0.0, fullyDescribed());
 
             // Apply correction to velocity for 2-D cases
             meshTools::constrainDirection

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/InjectionModel/InjectionModel.H

@@ -143,12 +143,6 @@ protected:
 
     // Protected Member Functions
 
-        //- Number of parcels to introduce over the time step relative to SOI
-        virtual label parcelsToInject(const scalar time0, const scalar time1);
-
-        //- Volume of parcels to introduce over the time step relative to SOI
-        virtual scalar volumeToInject(const scalar time0, const scalar time1);
-
         //- Additional flag to identify whether or not injection of parcelI is
         //  permitted
         virtual bool validInjection(const label parcelI);
@@ -266,6 +260,24 @@ public:
             //- Return the end-of-injection time
             virtual scalar timeEnd() const;
 
+            //- Number of parcels to introduce relative to SOI
+            virtual label parcelsToInject
+            (
+                const scalar time0,
+                const scalar time1
+            );
+
+            //- Volume of parcels to introduce relative to SOI
+            virtual scalar volumeToInject
+            (
+                const scalar time0,
+                const scalar time1
+            );
+
+            //- Return the average parcel mass over the injection period
+            scalar averageParcelMass();
+
+
             // Counters
 
                 //- Return the number of injections

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/KinematicLookupTableInjection/KinematicLookupTableInjection.C

@@ -26,46 +26,6 @@ License
 #include "KinematicLookupTableInjection.H"
 #include "scalarIOList.H"
 
-// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
-
-template<class CloudType>
-Foam::label Foam::KinematicLookupTableInjection<CloudType>::parcelsToInject
-(
-    const scalar time0,
-    const scalar time1
-)
-{
-    if ((time0 >= 0.0) && (time0 < duration_))
-    {
-        return floor(injectorCells_.size()*(time1 - time0)*parcelsPerSecond_);
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-
-template<class CloudType>
-Foam::scalar Foam::KinematicLookupTableInjection<CloudType>::volumeToInject
-(
-    const scalar time0,
-    const scalar time1
-)
-{
-    scalar volume = 0.0;
-    if ((time0 >= 0.0) && (time0 < duration_))
-    {
-        forAll(injectors_, i)
-        {
-            volume += injectors_[i].mDot()/injectors_[i].rho()*(time1 - time0);
-        }
-    }
-
-    return volume;
-}
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class CloudType>
@@ -156,6 +116,44 @@ Foam::scalar Foam::KinematicLookupTableInjection<CloudType>::timeEnd() const
 }
 
 
+template<class CloudType>
+Foam::label Foam::KinematicLookupTableInjection<CloudType>::parcelsToInject
+(
+    const scalar time0,
+    const scalar time1
+)
+{
+    if ((time0 >= 0.0) && (time0 < duration_))
+    {
+        return floor(injectorCells_.size()*(time1 - time0)*parcelsPerSecond_);
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+
+template<class CloudType>
+Foam::scalar Foam::KinematicLookupTableInjection<CloudType>::volumeToInject
+(
+    const scalar time0,
+    const scalar time1
+)
+{
+    scalar volume = 0.0;
+    if ((time0 >= 0.0) && (time0 < duration_))
+    {
+        forAll(injectors_, i)
+        {
+            volume += injectors_[i].mDot()/injectors_[i].rho()*(time1 - time0);
+        }
+    }
+
+    return volume;
+}
+
+
 template<class CloudType>
 void Foam::KinematicLookupTableInjection<CloudType>::setPositionAndCell
 (

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/KinematicLookupTableInjection/KinematicLookupTableInjection.H

@@ -91,17 +91,6 @@ class KinematicLookupTableInjection
         labelList injectorTetPts_;
 
 
-protected:
-
-    // Protected Member Functions
-
-        //- Number of parcels to introduce over the time step relative to SOI
-        virtual label parcelsToInject(const scalar time0, const scalar time1);
-
-        //- Volume of parcels to introduce over the time step relative to SOI
-        virtual scalar volumeToInject(const scalar time0, const scalar time1);
-
-
 public:
 
     //- Runtime type information
@@ -138,6 +127,12 @@ public:
         //- Return the end-of-injection time
         scalar timeEnd() const;
 
+        //- Number of parcels to introduce relative to SOI
+        virtual label parcelsToInject(const scalar time0, const scalar time1);
+
+        //- Volume of parcels to introduce relative to SOI
+        virtual scalar volumeToInject(const scalar time0, const scalar time1);
+
 
         // Injection geometry
 

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ManualInjection/ManualInjection.C

@@ -30,45 +30,6 @@ License
 
 using namespace Foam::constant::mathematical;
 
-// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
-
-template<class CloudType>
-Foam::label Foam::ManualInjection<CloudType>::parcelsToInject
-(
-    const scalar time0,
-    const scalar time1
-)
-{
-    if ((0.0 >= time0) && (0.0 < time1))
-    {
-        return positions_.size();
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-
-template<class CloudType>
-Foam::scalar Foam::ManualInjection<CloudType>::volumeToInject
-(
-    const scalar time0,
-    const scalar time1
-)
-{
-    // All parcels introduced at SOI
-    if ((0.0 >= time0) && (0.0 < time1))
-    {
-        return this->volumeTotal_;
-    }
-    else
-    {
-        return 0.0;
-    }
-}
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class CloudType>
@@ -192,6 +153,43 @@ Foam::scalar Foam::ManualInjection<CloudType>::timeEnd() const
 }
 
 
+template<class CloudType>
+Foam::label Foam::ManualInjection<CloudType>::parcelsToInject
+(
+    const scalar time0,
+    const scalar time1
+)
+{
+    if ((0.0 >= time0) && (0.0 < time1))
+    {
+        return positions_.size();
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+
+template<class CloudType>
+Foam::scalar Foam::ManualInjection<CloudType>::volumeToInject
+(
+    const scalar time0,
+    const scalar time1
+)
+{
+    // All parcels introduced at SOI
+    if ((0.0 >= time0) && (0.0 < time1))
+    {
+        return this->volumeTotal_;
+    }
+    else
+    {
+        return 0.0;
+    }
+}
+
+
 template<class CloudType>
 void Foam::ManualInjection<CloudType>::setPositionAndCell
 (