Merge branch 'master' of ssh://noisy/home/noisy3/OpenFOAM/OpenFOAM-dev

applications/solvers/heatTransfer/chtMultiRegionFoam/Make/files

@@ -1,6 +1,10 @@
+regionProperties/regionProperties.C
+
 derivedFvPatchFields/solidWallHeatFluxTemperature/solidWallHeatFluxTemperatureFvPatchScalarField.C
+derivedFvPatchFields/solidWallMixedTemperatureCoupled/solidWallMixedTemperatureCoupledFvPatchScalarField.C
 
 fluid/compressibleCourantNo.C
+solid/solidRegionDiffNo.C
 
 chtMultiRegionFoam.C
 

applications/solvers/heatTransfer/chtMultiRegionFoam/Make/options

@@ -2,11 +2,11 @@ EXE_INC = \
     -Ifluid \
     -Isolid \
     -IregionProperties \
+    -Iinclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
-    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
+    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel
-    -I$(LIB_SRC)/turbulenceModels/compressible/RAS/lnInclude
 
 EXE_LIBS = \
     -lbasicThermophysicalModels \

applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionFoam.C

@@ -37,6 +37,7 @@ Description
 #include "fixedGradientFvPatchFields.H"
 #include "regionProperties.H"
 #include "compressibleCourantNo.H"
+#include "solidRegionDiffNo.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -56,23 +57,24 @@ int main(int argc, char *argv[])
     #include "initContinuityErrs.H"
 
     #include "readTimeControls.H"
+    #include "readSolidTimeControls.H"
+
+
+    #include "compressibleMultiRegionCourantNo.H"
+    #include "solidRegionDiffusionNo.H"
+    #include "setInitialMultiRegionDeltaT.H"
 
-    if (fluidRegions.size())
-    {
-        #include "compressibleMultiRegionCourantNo.H"
-        #include "setInitialDeltaT.H"
-    }
 
     while (runTime.run())
     {
         #include "readTimeControls.H"
+        #include "readSolidTimeControls.H"
         #include "readPIMPLEControls.H"
 
-        if (fluidRegions.size())
+
-        {
+        #include "compressibleMultiRegionCourantNo.H"
-            #include "compressibleMultiRegionCourantNo.H"
+        #include "solidRegionDiffusionNo.H"
-            #include "setDeltaT.H"
+        #include "setMultiRegionDeltaT.H"
-        }
 
         runTime++;
 
@@ -117,7 +119,7 @@ int main(int argc, char *argv[])
             << nl << endl;
     }
 
-    Info<< "End\n" << endl;
+    Info << "End\n" << endl;
 
     return 0;
 }

applications/solvers/heatTransfer/chtMultiRegionFoam/derivedFvPatchFields/solidWallMixedTemperatureCoupled/solidWallMixedTemperatureCoupledFvPatchScalarField.C

@@ -0,0 +1,382 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "solidWallMixedTemperatureCoupledFvPatchScalarField.H"
+#include "addToRunTimeSelectionTable.H"
+#include "fvPatchFieldMapper.H"
+#include "volFields.H"
+#include "directMappedPatchBase.H"
+#include "regionProperties.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+bool Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::interfaceOwner
+(
+    const polyMesh& nbrRegion
+) const
+{
+    const fvMesh& myRegion = patch().boundaryMesh().mesh();
+
+    const regionProperties& props =
+        myRegion.objectRegistry::parent().lookupObject<regionProperties>
+        (
+            "regionProperties"
+        );
+
+    label myIndex = findIndex(props.fluidRegionNames(), myRegion.name());
+    if (myIndex == -1)
+    {
+        label i = findIndex(props.solidRegionNames(), myRegion.name());
+
+        if (i == -1)
+        {
+            FatalErrorIn
+            (
+                "solidWallMixedTemperatureCoupledFvPatchScalarField"
+                "::interfaceOwner(const polyMesh&) const"
+            )   << "Cannot find region " << myRegion.name()
+                << " neither in fluids " << props.fluidRegionNames()
+                << " nor in solids " << props.solidRegionNames()
+                << exit(FatalError);
+        }
+        myIndex = props.fluidRegionNames().size() + i;
+    }
+    label nbrIndex = findIndex(props.fluidRegionNames(), nbrRegion.name());
+    if (nbrIndex == -1)
+    {
+        label i = findIndex(props.solidRegionNames(), nbrRegion.name());
+
+        if (i == -1)
+        {
+            FatalErrorIn("coupleManager::interfaceOwner(const polyMesh&) const")
+                << "Cannot find region " << nbrRegion.name()
+                << " neither in fluids " << props.fluidRegionNames()
+                << " nor in solids " << props.solidRegionNames()
+                << exit(FatalError);
+        }
+        nbrIndex = props.fluidRegionNames().size() + i;
+    }
+
+    return myIndex < nbrIndex;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::
+solidWallMixedTemperatureCoupledFvPatchScalarField
+(
+    const fvPatch& p,
+    const DimensionedField<scalar, volMesh>& iF
+)
+:
+    mixedFvPatchScalarField(p, iF),
+    neighbourFieldName_("undefined-neighbourFieldName"),
+    KName_("undefined-K")
+{
+    this->refValue() = 0.0;
+    this->refGrad() = 0.0;
+    this->valueFraction() = 1.0;
+    this->fixesValue_ = true;
+}
+
+
+Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::
+solidWallMixedTemperatureCoupledFvPatchScalarField
+(
+    const solidWallMixedTemperatureCoupledFvPatchScalarField& ptf,
+    const fvPatch& p,
+    const DimensionedField<scalar, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    mixedFvPatchScalarField(ptf, p, iF, mapper),
+    neighbourFieldName_(ptf.neighbourFieldName_),
+    KName_(ptf.KName_),
+    fixesValue_(ptf.fixesValue_)
+{}
+
+
+Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::
+solidWallMixedTemperatureCoupledFvPatchScalarField
+(
+    const fvPatch& p,
+    const DimensionedField<scalar, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    mixedFvPatchScalarField(p, iF),
+    neighbourFieldName_(dict.lookup("neighbourFieldName")),
+    KName_(dict.lookup("K"))
+{
+    if (!isA<directMappedPatchBase>(this->patch().patch()))
+    {
+        FatalErrorIn
+        (
+            "solidWallMixedTemperatureCoupledFvPatchScalarField::"
+            "solidWallMixedTemperatureCoupledFvPatchScalarField\n"
+            "(\n"
+            "    const fvPatch& p,\n"
+            "    const DimensionedField<scalar, volMesh>& iF,\n"
+            "    const dictionary& dict\n"
+            ")\n"
+        )   << "\n    patch type '" << p.type()
+            << "' not type '" << directMappedPatchBase::typeName << "'"
+            << "\n    for patch " << p.name()
+            << " of field " << dimensionedInternalField().name()
+            << " in file " << dimensionedInternalField().objectPath()
+            << exit(FatalError);
+    }
+
+    fvPatchScalarField::operator=(scalarField("value", dict, p.size()));
+
+    if (dict.found("refValue"))
+    {
+        // Full restart
+        refValue() = scalarField("refValue", dict, p.size());
+        refGrad() = scalarField("refGradient", dict, p.size());
+        valueFraction() = scalarField("valueFraction", dict, p.size());
+        fixesValue_ = readBool(dict.lookup("fixesValue"));
+    }
+    else
+    {
+        // Start from user entered data. Assume fixedValue.
+        refValue() = *this;
+        refGrad() = 0.0;
+        valueFraction() = 1.0;
+        fixesValue_ = true;
+    }
+}
+
+
+Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::
+solidWallMixedTemperatureCoupledFvPatchScalarField
+(
+    const solidWallMixedTemperatureCoupledFvPatchScalarField& wtcsf,
+    const DimensionedField<scalar, volMesh>& iF
+)
+:
+    mixedFvPatchScalarField(wtcsf, iF),
+    neighbourFieldName_(wtcsf.neighbourFieldName_),
+    KName_(wtcsf.KName_),
+    fixesValue_(wtcsf.fixesValue_)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::fvPatchScalarField&
+Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::K() const
+{
+    return this->patch().lookupPatchField<volScalarField, scalar>(KName_);
+}
+
+
+void Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::updateCoeffs()
+{
+    if (updated())
+    {
+        return;
+    }
+
+    // Get the coupling information from the directMappedPatchBase
+    const directMappedPatchBase& mpp = refCast<const directMappedPatchBase>
+    (
+        patch().patch()
+    );
+    const polyMesh& nbrMesh = mpp.sampleMesh();
+    // Force recalculation of mapping and schedule
+    const mapDistribute& distMap = mpp.map();
+    (void)distMap.schedule();
+
+    tmp<scalarField> intFld = patchInternalField();
+
+    if (interfaceOwner(nbrMesh))
+    {
+        // Note: other side information could be cached - it only needs
+        // to be updated the first time round the iteration (i.e. when
+        // switching regions) but unfortunately we don't have this information.
+
+        const fvPatch& nbrPatch = refCast<const fvMesh>
+        (
+            nbrMesh
+        ).boundary()[mpp.samplePolyPatch().index()];
+
+
+        // Calculate the temperature by harmonic averaging
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        const solidWallMixedTemperatureCoupledFvPatchScalarField& nbrField =
+        refCast<const solidWallMixedTemperatureCoupledFvPatchScalarField>
+        (
+            nbrPatch.lookupPatchField<volScalarField, scalar>
+            (
+                neighbourFieldName_
+            )
+        );
+
+        // Swap to obtain full local values of neighbour internal field
+        scalarField nbrIntFld = nbrField.patchInternalField();
+        mapDistribute::distribute
+        (
+            Pstream::defaultCommsType,
+            distMap.schedule(),
+            distMap.constructSize(),
+            distMap.subMap(),           // what to send
+            distMap.constructMap(),     // what to receive
+            nbrIntFld
+        );
+
+        // Swap to obtain full local values of neighbour K*delta
+        scalarField nbrKDelta = nbrField.K()*nbrPatch.deltaCoeffs();
+        mapDistribute::distribute
+        (
+            Pstream::defaultCommsType,
+            distMap.schedule(),
+            distMap.constructSize(),
+            distMap.subMap(),           // what to send
+            distMap.constructMap(),     // what to receive
+            nbrKDelta
+        );
+
+
+        tmp<scalarField> myKDelta = K()*patch().deltaCoeffs();
+
+        // Calculate common wall temperature. Reuse *this to store common value.
+        scalarField Twall
+        (
+            (myKDelta()*intFld() + nbrKDelta*nbrIntFld)
+          / (myKDelta() + nbrKDelta)
+        );
+        // Assign to me
+        fvPatchScalarField::operator=(Twall);
+        // Distribute back and assign to neighbour
+        mapDistribute::distribute
+        (
+            Pstream::defaultCommsType,
+            distMap.schedule(),
+            nbrField.size(),
+            distMap.constructMap(),     // reverse : what to send
+            distMap.subMap(),
+            Twall
+        );
+        const_cast<solidWallMixedTemperatureCoupledFvPatchScalarField&>
+        (
+            nbrField
+        ).fvPatchScalarField::operator=(Twall);
+    }
+
+
+    // Switch between fixed value (of harmonic avg) or gradient
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    label nFixed = 0;
+
+    // Like snGrad but bypass switching on refValue/refGrad.
+    tmp<scalarField> normalGradient = (*this-intFld())*patch().deltaCoeffs();
+
+    if (debug)
+    {
+        scalar Q = gSum(K()*patch().magSf()*normalGradient());
+
+        Info<< "solidWallMixedTemperatureCoupledFvPatchScalarField::"
+            << "updateCoeffs() :"
+            << " patch:" << patch().name()
+            << " heatFlux:" << Q
+            << " walltemperature "
+            << " min:" << gMin(*this)
+            << " max:" << gMax(*this)
+            << " avg:" << gAverage(*this)
+            << endl;
+    }
+
+    forAll(*this, i)
+    {
+        // if outgoing flux use fixed value.
+        if (normalGradient()[i] < 0.0)
+        {
+            this->refValue()[i] = operator[](i);
+            this->refGrad()[i] = 0.0;   // not used by me
+            this->valueFraction()[i] = 1.0;
+            nFixed++;
+        }
+        else
+        {
+            // Fixed gradient. Make sure to have valid refValue (even though
+            // I am not using it - other boundary conditions might)
+            this->refValue()[i] = operator[](i);
+            this->refGrad()[i] = normalGradient()[i];
+            this->valueFraction()[i] = 0.0;
+        }
+    }
+
+    reduce(nFixed, sumOp<label>());
+
+    fixesValue_ = (nFixed > 0);
+
+    if (debug)
+    {
+        label nTotSize = returnReduce(this->size(), sumOp<label>());
+
+        Info<< "solidWallMixedTemperatureCoupledFvPatchScalarField::"
+            << "updateCoeffs() :"
+            << " patch:" << patch().name()
+            << " out of:" << nTotSize
+            << " fixedBC:" << nFixed
+            << " gradient:" << nTotSize-nFixed << endl;
+    }
+
+    mixedFvPatchScalarField::updateCoeffs();
+}
+
+
+void Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::write
+(
+    Ostream& os
+) const
+{
+    mixedFvPatchScalarField::write(os);
+    os.writeKeyword("neighbourFieldName")<< neighbourFieldName_
+        << token::END_STATEMENT << nl;
+    os.writeKeyword("K") << KName_ << token::END_STATEMENT << nl;
+    os.writeKeyword("fixesValue") << fixesValue_ << token::END_STATEMENT << nl;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+makePatchTypeField
+(
+    fvPatchScalarField,
+    solidWallMixedTemperatureCoupledFvPatchScalarField
+);
+
+} // End namespace Foam
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/derivedFvPatchFields/solidWallMixedTemperatureCoupled/solidWallMixedTemperatureCoupledFvPatchScalarField.H

@@ -0,0 +1,193 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    solidWallMixedTemperatureCoupledFvPatchScalarField
+
+Description
+    Mixed boundary condition for temperature, to be used by the
+    conjugate heat transfer solver.
+    If my temperature is T1, neighbour is T2:
+
+    T1 > T2: my side becomes fixedValue T2 bc, other side becomes fixedGradient.
+    
+
+    Example usage:
+        myInterfacePatchName
+        {
+            type                solidWallMixedTemperatureCoupled;
+            neighbourFieldName  T;
+            K                   K;
+            value               uniform 300;
+        }
+
+    Needs to be on underlying directMapped(Wall)FvPatch.
+
+    Note: runs in parallel with arbitrary decomposition. Uses directMapped
+    functionality to calculate exchange.
+
+    Note: lags interface data so both sides use same data.
+    - problem: schedule to calculate average would interfere
+    with standard processor swaps.
+    - so: updateCoeffs sets both to same Twall. Only need to do
+    this for last outer iteration but don't have access to this.
+
+SourceFiles
+    solidWallMixedTemperatureCoupledFvPatchScalarField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef solidWallMixedTemperatureCoupledFvPatchScalarField_H
+#define solidWallMixedTemperatureCoupledFvPatchScalarField_H
+
+#include "fvPatchFields.H"
+#include "mixedFvPatchFields.H"
+#include "fvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+        Class solidWallMixedTemperatureCoupledFvPatchScalarField Declaration
+\*---------------------------------------------------------------------------*/
+
+class solidWallMixedTemperatureCoupledFvPatchScalarField
+:
+    public mixedFvPatchScalarField
+{
+    // Private data
+
+        //- Name of field on the neighbour region
+        const word neighbourFieldName_;
+        
+        //- Name of thermal conductivity field
+        const word KName_;
+
+        bool fixesValue_;
+
+
+    // Private Member Functions
+
+        //- Am I or neighbour owner of interface
+        bool interfaceOwner(const polyMesh& nbrRegion) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("solidWallMixedTemperatureCoupled");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        solidWallMixedTemperatureCoupledFvPatchScalarField
+        (
+            const fvPatch&,
+            const DimensionedField<scalar, volMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        solidWallMixedTemperatureCoupledFvPatchScalarField
+        (
+            const fvPatch&,
+            const DimensionedField<scalar, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given
+        //  solidWallMixedTemperatureCoupledFvPatchScalarField onto a new patch
+        solidWallMixedTemperatureCoupledFvPatchScalarField
+        (
+            const solidWallMixedTemperatureCoupledFvPatchScalarField&,
+            const fvPatch&,
+            const DimensionedField<scalar, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<fvPatchScalarField> clone() const
+        {
+            return tmp<fvPatchScalarField>
+            (
+                new solidWallMixedTemperatureCoupledFvPatchScalarField(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        solidWallMixedTemperatureCoupledFvPatchScalarField
+        (
+            const solidWallMixedTemperatureCoupledFvPatchScalarField&,
+            const DimensionedField<scalar, volMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<fvPatchScalarField> clone
+        (
+            const DimensionedField<scalar, volMesh>& iF
+        ) const
+        {
+            return tmp<fvPatchScalarField>
+            (
+                new solidWallMixedTemperatureCoupledFvPatchScalarField
+                (
+                    *this,
+                    iF
+                )
+            );
+        }
+
+
+    // Member functions
+
+        //- Get corresponding K field
+        const fvPatchScalarField& K() const;
+
+        //- Return true if this patch field fixes a value.
+        //  Needed to check if a level has to be specified while solving
+        //  Poissons equations.
+        virtual bool fixesValue() const
+        {
+            return fixesValue_;
+        }
+
+        //- Update the coefficients associated with the patch field
+        virtual void updateCoeffs();
+
+        //- Write
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/compressibleCourantNo.C

@@ -47,10 +47,10 @@ Foam::scalar Foam::compressibleCourantNo
           / fvc::interpolate(rho);
 
         CoNum = max(SfUfbyDelta/mesh.magSf())
-            .value()*runTime.deltaTValue();
+            .value()*runTime.deltaT().value();
 
         meanCoNum = (sum(SfUfbyDelta)/sum(mesh.magSf()))
-            .value()*runTime.deltaTValue();
+            .value()*runTime.deltaT().value();
     }
 
     Info<< "Region: " << mesh.name() << " Courant Number mean: " << meanCoNum

applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/compressibleMultiRegionCourantNo.H

@@ -1,15 +1,18 @@
     scalar CoNum = -GREAT;
-    forAll(fluidRegions, regionI)
+    if (fluidRegions.size())
     {
-        CoNum = max
+        forAll(fluidRegions, regionI)
-        (
+        {
-            compressibleCourantNo
+            CoNum = max
             (
-                fluidRegions[regionI],
+                compressibleCourantNo
-                runTime,
+                (
-                rhoFluid[regionI],
+                    fluidRegions[regionI],
-                phiFluid[regionI]
+                    runTime,
-            ),
+                    rhoFluid[regionI],
-            CoNum
+                    phiFluid[regionI]
-        );
+                ),
+                CoNum
+            );
+        }
     }

applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidFields.H

@@ -41,6 +41,24 @@
             )
         );
 
+        Info<< "    Adding to KFluid\n" << endl;
+        KFluid.set
+        (
+            i,
+            new volScalarField
+            (
+                IOobject
+                (
+                    "K",
+                    runTime.timeName(),
+                    fluidRegions[i],
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE
+                ),
+                thermoFluid[i].Cp()*thermoFluid[i].alpha()
+            )
+        );
+
         Info<< "    Adding to UFluid\n" << endl;
         UFluid.set
         (
@@ -111,24 +129,6 @@
             ).ptr()
         );
 
-        Info<< "    Adding to KFluid\n" << endl;
-        KFluid.set
-        (
-            i,
-            new volScalarField
-            (
-                IOobject
-                (
-                    "K",
-                    runTime.timeName(),
-                    fluidRegions[i],
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE
-                ),
-                thermoFluid[i].Cp()*turbulence[i].alphaEff()
-            )
-        );
-
         Info<< "    Adding to DpDtFluid\n" << endl;
         DpDtFluid.set
         (

applications/solvers/heatTransfer/chtMultiRegionFoam/include/setInitialMultiRegionDeltaT.H

@@ -0,0 +1,60 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2010-2010 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Global
+    setInitialDeltaT
+
+Description
+    Set the initial timestep for the CHT MultiRegion solver.
+
+\*---------------------------------------------------------------------------*/
+
+if (adjustTimeStep)
+{
+    if ((runTime.timeIndex() == 0) && ((CoNum > SMALL) || (DiNum > SMALL)))
+    {
+
+        if (CoNum == -GREAT)
+        {
+            CoNum = SMALL;
+        }
+
+        if (DiNum == -GREAT)
+        {
+            DiNum = SMALL;
+        }
+
+        runTime.setDeltaT
+        (
+            min
+            (
+                min(maxCo/CoNum, maxDi/DiNum)*runTime.deltaT().value(),
+                maxDeltaT
+            )
+        );
+        Info<< "deltaT = " <<  runTime.deltaT().value() << endl;
+    }
+}
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/include/setMultiRegionDeltaT.H

@@ -0,0 +1,69 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2010-2010 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Global
+    setMultiRegionDeltaT
+
+Description
+    Reset the timestep to maintain a constant maximum courant and diffusion
+    Numbers. Reduction of time-step is immediate, but increase is damped to avoid
+    unstable oscillations.
+
+\*---------------------------------------------------------------------------*/
+
+if (adjustTimeStep)
+{
+    if (CoNum == -GREAT)
+    {
+        CoNum = SMALL;
+    }
+
+    if (DiNum == -GREAT)
+    {
+        DiNum = SMALL;
+    }
+
+    scalar maxDeltaTFluid = maxCo/(CoNum + SMALL);
+    scalar maxDeltaTSolid = maxDi/(DiNum + SMALL);
+
+    scalar deltaTFluid =
+        min
+        (
+            min(maxDeltaTFluid, 1.0 + 0.1*maxDeltaTFluid),
+            1.2
+        );
+
+    runTime.setDeltaT
+    (
+        min
+        (
+            min(deltaTFluid, maxDeltaTSolid)*runTime.deltaT().value(),
+            maxDeltaT
+        )
+    );
+
+    Info<< "deltaT = " <<  runTime.deltaT().value() << endl;
+}
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/regionProperties/regionProperties.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,32 +22,48 @@ License
     along with OpenFOAM; if not, write to the Free Software Foundation,
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
-Description
-    Macros for defining parcel IOLists
-
 \*---------------------------------------------------------------------------*/
 
-#ifndef makeParcelIOList_H
+#include "regionProperties.H"
-#define makeParcelIOList_H
 
-#include "IOPtrList.H"
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+Foam::regionProperties::regionProperties(const Time& runTime)
+:
+    IOdictionary
+    (
+        IOobject
+        (
+            "regionProperties",
+            runTime.time().constant(),
+            runTime.db(),
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        )
+    ),
+    fluidRegionNames_(lookup("fluidRegionNames")),
+    solidRegionNames_(lookup("solidRegionNames"))
+{}
 
-#define makeParcelIOList(ParcelType)                                          \
-                                                                              \
-    typedef IOPtrList<ParcelType> IOPtrList##ParcelType;                      \
-                                                                              \
-    defineTemplateTypeNameAndDebugWithName                                    \
-    (                                                                         \
-        IOPtrList##ParcelType,                                                \
-        "IOPtrList<"#ParcelType">",                                           \
-        0                                                                     \
-    );
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::regionProperties::~regionProperties()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::List<Foam::word>& Foam::regionProperties::fluidRegionNames() const
+{
+    return fluidRegionNames_;
+}
+
+
+const Foam::List<Foam::word>& Foam::regionProperties::solidRegionNames() const
+{
+    return solidRegionNames_;
+}
 
-#endif
 
 // ************************************************************************* //
-

applications/solvers/heatTransfer/chtMultiRegionFoam/regionProperties/regionProperties.H

@@ -0,0 +1,106 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    regionProperties
+
+Description
+    Simple class to hold region information for coupled region simulations
+
+SourceFiles
+    regionProperties.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef regionProperties_H
+#define regionProperties_H
+
+#include "IOdictionary.H"
+#include "Time.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class regionProperties Declaration
+\*---------------------------------------------------------------------------*/
+
+class regionProperties
+:
+    public IOdictionary
+{
+    // Private data
+
+        //- List of the fluid region names
+        List<word> fluidRegionNames_;
+
+        //- List of the solid region names
+        List<word> solidRegionNames_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        regionProperties(const regionProperties&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const regionProperties&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        regionProperties(const Time& runTime);
+
+
+    // Destructor
+
+        ~regionProperties();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return const reference to the list of fluid region names
+            const List<word>& fluidRegionNames() const;
+
+            //- Return const reference to the list of solid region names
+            const List<word>& solidRegionNames() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/solid/readSolidTimeControls.H

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2010-2010 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Global
+    readSolidTimeControls
+
+Description
+    Read the control parameters used in the solid
+
+\*---------------------------------------------------------------------------*/
+
+scalar maxDi = runTime.controlDict().lookupOrDefault<scalar>("maxDi", 10.0);
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/solid/solidRegionDiffNo.C

@@ -0,0 +1,61 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2010-2010 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "solidRegionDiffNo.H"
+#include "fvc.H"
+
+Foam::scalar Foam::solidRegionDiffNo
+(
+    const fvMesh& mesh,
+    const Time& runTime,
+    const volScalarField& Cprho,
+    const volScalarField& K
+)
+{
+    scalar DiNum = 0.0;
+    scalar meanDiNum = 0.0;
+
+    //- Can have fluid domains with 0 cells so do not test.
+    if (mesh.nInternalFaces())
+    {
+        surfaceScalarField KrhoCpbyDelta =
+            mesh.surfaceInterpolation::deltaCoeffs()
+          * fvc::interpolate(K)
+          / fvc::interpolate(Cprho);
+
+        DiNum = max(KrhoCpbyDelta.internalField())*runTime.deltaT().value();
+
+        meanDiNum = (average(KrhoCpbyDelta)).value()*runTime.deltaT().value();
+    }
+
+    Info<< "Region: " << mesh.name() << " Diffusion Number mean: " << meanDiNum
+        << " max: " << DiNum << endl;
+
+    return DiNum;
+}
+
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/solid/solidRegionDiffNo.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2010-2010 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Description
+    Calculates and outputs the mean and maximum Diffusion Numbers for the solid
+    regions
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef solidRegionDiff_H
+#define solidRegionDiff_H
+
+#include "fvMesh.H"
+
+namespace Foam
+{
+    scalar solidRegionDiffNo
+    (
+        const fvMesh& mesh,
+        const Time& runTime,
+        const volScalarField& Cprho,
+        const volScalarField& K
+    );
+}
+
+#endif
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/solid/solidRegionDiffusionNo.H

@@ -0,0 +1,18 @@
+    scalar DiNum = -GREAT;
+    if (solidRegions.size())//
+    {
+        forAll(solidRegions, regionI)
+        {
+            DiNum = max
+            (
+                solidRegionDiffNo
+                (
+                    solidRegions[regionI],
+                    runTime,
+                    rhosCps[regionI],
+                    Ks[regionI]
+                ),
+                DiNum
+            );
+        }
+    }

applications/utilities/mesh/manipulation/checkMesh/checkGeometry.C

@@ -47,6 +47,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
                 Info<< "  <<Writing " << nNonAligned
                     << " points on non-aligned edges to set "
                     << nonAlignedPoints.name() << endl;
+                nonAlignedPoints.instance() = mesh.pointsInstance();
                 nonAlignedPoints.write();
             }
         }
@@ -67,6 +68,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
             {
                 Info<< "  <<Writing " << nNonClosed
                     << " non closed cells to set " << cells.name() << endl;
+                cells.instance() = mesh.pointsInstance();
                 cells.write();
             }
         }
@@ -78,6 +80,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
             Info<< "  <<Writing " << nHighAspect
                 << " cells with high aspect ratio to set "
                 << aspectCells.name() << endl;
+            aspectCells.instance() = mesh.pointsInstance();
             aspectCells.write();
         }
     }
@@ -94,6 +97,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
             {
                 Info<< "  <<Writing " << nFaces
                     << " zero area faces to set " << faces.name() << endl;
+                faces.instance() = mesh.pointsInstance();
                 faces.write();
             }
         }
@@ -111,6 +115,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
             {
                 Info<< "  <<Writing " << nCells
                     << " zero volume cells to set " << cells.name() << endl;
+                cells.instance() = mesh.pointsInstance();
                 cells.write();
             }
         }
@@ -129,6 +134,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
         {
             Info<< "  <<Writing " << nFaces
                 << " non-orthogonal faces to set " << faces.name() << endl;
+            faces.instance() = mesh.pointsInstance();
             faces.write();
         }
     }
@@ -147,6 +153,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
                 Info<< "  <<Writing " << nFaces
                     << " faces with incorrect orientation to set "
                     << faces.name() << endl;
+                faces.instance() = mesh.pointsInstance();
                 faces.write();
             }
         }
@@ -164,6 +171,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
             {
                 Info<< "  <<Writing " << nFaces
                     << " skew faces to set " << faces.name() << endl;
+                faces.instance() = mesh.pointsInstance();
                 faces.write();
             }
         }
@@ -184,6 +192,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
                 Info<< "  <<Writing " << nPoints
                     << " points on short edges to set " << points.name()
                     << endl;
+                points.instance() = mesh.pointsInstance();
                 points.write();
             }
         }
@@ -202,6 +211,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
                 Info<< "  <<Writing " << nPoints
                     << " near (closer than " << Foam::sqrt(minDistSqr)
                     << " apart) points to set " << nearPoints.name() << endl;
+                nearPoints.instance() = mesh.pointsInstance();
                 nearPoints.write();
             }
         }
@@ -221,6 +231,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
                 Info<< "  <<Writing " << nFaces
                     << " faces with concave angles to set " << faces.name()
                     << endl;
+                faces.instance() = mesh.pointsInstance();
                 faces.write();
             }
         }
@@ -239,6 +250,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
             {
                 Info<< "  <<Writing " << nFaces
                     << " warped faces to set " << faces.name() << endl;
+                faces.instance() = mesh.pointsInstance();
                 faces.write();
             }
         }
@@ -255,6 +267,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
 
             Info<< "  <<Writing " << nCells
                 << " under-determined cells to set " << cells.name() << endl;
+            cells.instance() = mesh.pointsInstance();
             cells.write();
         }
     }

applications/utilities/mesh/manipulation/checkMesh/checkTopology.C

@@ -89,6 +89,7 @@ Foam::label Foam::checkTopology
 
             Info<< "  <<Writing " << nPoints
                 << " unused points to set " << points.name() << endl;
+            points.instance() = mesh.pointsInstance();
             points.write();
         }
     }
@@ -106,6 +107,7 @@ Foam::label Foam::checkTopology
         {
             Info<< "  <<Writing " << nFaces
                 << " unordered faces to set " << faces.name() << endl;
+            faces.instance() = mesh.pointsInstance();
             faces.write();
         }
     }
@@ -122,6 +124,7 @@ Foam::label Foam::checkTopology
             Info<< "  <<Writing " << nCells
                 << " cells with over used edges to set " << cells.name()
                 << endl;
+            cells.instance() = mesh.pointsInstance();
             cells.write();
         }
     }
@@ -137,6 +140,7 @@ Foam::label Foam::checkTopology
             Info<< "  <<Writing " << nFaces
                 << " faces with out-of-range or duplicate vertices to set "
                 << faces.name() << endl;
+            faces.instance() = mesh.pointsInstance();
             faces.write();
         }
     }
@@ -153,6 +157,7 @@ Foam::label Foam::checkTopology
             Info<< "  <<Writing " << nFaces
                 << " faces with incorrect edges to set " << faces.name()
                 << endl;
+            faces.instance() = mesh.pointsInstance();
             faces.write();
         }
     }
@@ -203,6 +208,7 @@ Foam::label Foam::checkTopology
                 << " cells with with single non-boundary face to set "
                 << oneCells.name()
                 << endl;
+            oneCells.instance() = mesh.pointsInstance();
             oneCells.write();
         }
 
@@ -214,6 +220,7 @@ Foam::label Foam::checkTopology
                 << " cells with with single non-boundary face to set "
                 << twoCells.name()
                 << endl;
+            twoCells.instance() = mesh.pointsInstance();
             twoCells.write();
         }
     }
@@ -354,6 +361,7 @@ Foam::label Foam::checkTopology
                 << " conflicting points to set "
                 << points.name() << endl;
 
+            points.instance() = mesh.pointsInstance();
             points.write();
         }
 

applications/utilities/mesh/manipulation/createPatch/createPatchDict

@@ -43,6 +43,8 @@ FoamFile
 matchTolerance 1E-3;
 
 // Do a synchronisation of coupled points after creation of any patches.
+// Note: this does not work with points that are on multiple coupled patches
+//       with transformations.
 pointSync true;
 
 // Patches to create.

applications/utilities/mesh/manipulation/splitMeshRegions/splitMeshRegions.C

@@ -64,6 +64,7 @@ Description
 #include "syncTools.H"
 #include "ReadFields.H"
 #include "directMappedWallPolyPatch.H"
+#include "zeroGradientFvPatchFields.H"
 
 using namespace Foam;
 
@@ -164,25 +165,24 @@ void reorderPatchFields(fvMesh& mesh, const labelList& oldToNew)
 
 
 // Adds patch if not yet there. Returns patchID.
-template<class PatchType>
+label addPatch(fvMesh& mesh, const polyPatch& patch)
-label addPatch(fvMesh& mesh, const word& patchName)
 {
     polyBoundaryMesh& polyPatches =
         const_cast<polyBoundaryMesh&>(mesh.boundaryMesh());
 
-    label patchI = polyPatches.findPatchID(patchName);
+    label patchI = polyPatches.findPatchID(patch.name());
     if (patchI != -1)
     {
-        if (isA<PatchType>(polyPatches[patchI]))
+        if (polyPatches[patchI].type() == patch.type())
         {
             // Already there
             return patchI;
         }
         else
         {
-            FatalErrorIn("addPatch<PatchType>(fvMesh&, const word&)")
+            FatalErrorIn("addPatch(fvMesh&, const polyPatch*)")
-                << "Already have patch " << patchName
+                << "Already have patch " << patch.name()
-                << " but of type " << PatchType::typeName
+                << " but of type " << patch.type()
                 << exit(FatalError);
         }
     }
@@ -219,14 +219,12 @@ label addPatch(fvMesh& mesh, const word& patchName)
     polyPatches.set
     (
         sz,
-        polyPatch::New
+        patch.clone
         (
-            PatchType::typeName,
+            polyPatches,
-            patchName,
+            insertPatchI,   //index
-            0,              // size
+            0,              //size
-            startFaceI,
+            startFaceI      //start
-            insertPatchI,
-            polyPatches
         )
     );
     fvPatches.setSize(sz+1);
@@ -1086,16 +1084,37 @@ EdgeMap<label> addRegionPatches
 
         if (interfaceSizes[e] > 0)
         {
-            label patchI = addPatch<directMappedWallPolyPatch>
+            const word inter1 = regionNames[e[0]] + "_to_" + regionNames[e[1]];
+            const word inter2 = regionNames[e[1]] + "_to_" + regionNames[e[0]];
+
+            directMappedWallPolyPatch patch1
             (
-                mesh,
+                inter1,
-                regionNames[e[0]] + "_to_" + regionNames[e[1]]
+                0,                  // overridden
+                0,                  // overridden
+                0,                  // overridden
+                regionNames[e[1]],  // sampleRegion
+                directMappedPatchBase::NEARESTPATCHFACE,
+                inter2,             // samplePatch
+                point::zero,        // offset
+                mesh.boundaryMesh()
             );
-            addPatch<directMappedWallPolyPatch>
+
+            label patchI = addPatch(mesh, patch1);
+
+            directMappedWallPolyPatch patch2
             (
-                mesh,
+                inter2,
-                regionNames[e[1]] + "_to_" + regionNames[e[0]]
+                0,
+                0,
+                0,
+                regionNames[e[0]],  // sampleRegion
+                directMappedPatchBase::NEARESTPATCHFACE,
+                inter1,
+                point::zero,        // offset
+                mesh.boundaryMesh()
             );
+            addPatch(mesh, patch2);
 
             Info<< "For interface between region " << e[0]
                 << " and " << e[1] << " added patch " << patchI
@@ -1495,7 +1514,8 @@ int main(int argc, char *argv[])
                 false
             ),
             mesh,
-            dimensionedScalar("zero", dimless, 0)
+            dimensionedScalar("zero", dimless, 0),
+            zeroGradientFvPatchScalarField::typeName
         );
         forAll(cellRegion, cellI)
         {

applications/utilities/parallelProcessing/decomposePar/lagrangianFieldDecomposer.C

@@ -80,6 +80,4 @@ Foam::lagrangianFieldDecomposer::lagrangianFieldDecomposer
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 // ************************************************************************* //

applications/utilities/postProcessing/dataConversion/foamToTecplot360/tecplotWriterTemplates.C

@@ -24,14 +24,14 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "tecplotWriter.H"
-
 //extern "C"
 //{
     #include "MASTER.h"
     #include "GLOBAL.h"
 //}
 
+#include "tecplotWriter.H"
+
 #include "fvc.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamLagrangianFields.H

@@ -67,11 +67,11 @@ void Foam::vtkPV3Foam::convertLagrangianField
 {
     const label nComp = pTraits<Type>::nComponents;
 
-    vtkFloatArray *pointData = vtkFloatArray::New();
+    vtkFloatArray* pointData = vtkFloatArray::New();
-    pointData->SetNumberOfTuples( tf.size() );
+    pointData->SetNumberOfTuples(tf.size());
-    pointData->SetNumberOfComponents( nComp );
+    pointData->SetNumberOfComponents(nComp);
-    pointData->Allocate( nComp*tf.size() );
+    pointData->Allocate(nComp*tf.size());
-    pointData->SetName( tf.name().c_str() );
+    pointData->SetName(tf.name().c_str());
 
     if (debug)
     {

applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamUpdateInfo.C

@@ -130,7 +130,7 @@ void Foam::vtkPV3Foam::updateInfoInternalMesh
 
     // Determine mesh parts (internalMesh, patches...)
     //- Add internal mesh as first entry
-    arrayRangeVolume_.reset( arraySelection->GetNumberOfArrays() );
+    arrayRangeVolume_.reset(arraySelection->GetNumberOfArrays());
     arraySelection->AddArray
     (
         "internalMesh"
@@ -173,7 +173,7 @@ void Foam::vtkPV3Foam::updateInfoLagrangian
         readDir(dbPtr_->timePath()/lagrangianPrefix, fileName::DIRECTORY)
     );
 
-    arrayRangeLagrangian_.reset( arraySelection->GetNumberOfArrays() );
+    arrayRangeLagrangian_.reset(arraySelection->GetNumberOfArrays());
 
     int nClouds = 0;
     forAll(cloudDirs, cloudI)
@@ -209,7 +209,7 @@ void Foam::vtkPV3Foam::updateInfoPatches
             << " [meshPtr=" << (meshPtr_ ? "set" : "NULL") << "]" << endl;
     }
 
-    arrayRangePatches_.reset( arraySelection->GetNumberOfArrays() );
+    arrayRangePatches_.reset(arraySelection->GetNumberOfArrays());
 
     int nPatches = 0;
     if (meshPtr_)
@@ -319,7 +319,7 @@ void Foam::vtkPV3Foam::updateInfoZones
         namesLst = readZoneNames("cellZones");
     }
 
-    arrayRangeCellZones_.reset( arraySelection->GetNumberOfArrays() );
+    arrayRangeCellZones_.reset(arraySelection->GetNumberOfArrays());
     forAll(namesLst, elemI)
     {
         arraySelection->AddArray
@@ -342,7 +342,7 @@ void Foam::vtkPV3Foam::updateInfoZones
         namesLst = readZoneNames("faceZones");
     }
 
-    arrayRangeFaceZones_.reset( arraySelection->GetNumberOfArrays() );
+    arrayRangeFaceZones_.reset(arraySelection->GetNumberOfArrays());
     forAll(namesLst, elemI)
     {
         arraySelection->AddArray
@@ -365,7 +365,7 @@ void Foam::vtkPV3Foam::updateInfoZones
         namesLst = readZoneNames("pointZones");
     }
 
-    arrayRangePointZones_.reset( arraySelection->GetNumberOfArrays() );
+    arrayRangePointZones_.reset(arraySelection->GetNumberOfArrays());
     forAll(namesLst, elemI)
     {
         arraySelection->AddArray
@@ -408,8 +408,21 @@ void Foam::vtkPV3Foam::updateInfoSets
         meshDir_/"sets"
     );
 
+    if (debug)
+    {
+        Info<< "     Foam::vtkPV3Foam::updateInfoSets read "
+            << objects.names() << " from "
+            <<  dbPtr_().findInstance
+                (
+                    meshDir_,
+                    "faces",
+                    IOobject::READ_IF_PRESENT
+                )
+            << endl;
+    }
 
-    arrayRangeCellSets_.reset( arraySelection->GetNumberOfArrays() );
+
+    arrayRangeCellSets_.reset(arraySelection->GetNumberOfArrays());
     arrayRangeCellSets_ += addToSelection<cellSet>
     (
         arraySelection,
@@ -417,7 +430,7 @@ void Foam::vtkPV3Foam::updateInfoSets
         " - cellSet"
     );
 
-    arrayRangeFaceSets_.reset( arraySelection->GetNumberOfArrays() );
+    arrayRangeFaceSets_.reset(arraySelection->GetNumberOfArrays());
     arrayRangeFaceSets_ += addToSelection<faceSet>
     (
         arraySelection,
@@ -425,7 +438,7 @@ void Foam::vtkPV3Foam::updateInfoSets
         " - faceSet"
     );
 
-    arrayRangePointSets_.reset( arraySelection->GetNumberOfArrays() );
+    arrayRangePointSets_.reset(arraySelection->GetNumberOfArrays());
     arrayRangePointSets_ += addToSelection<pointSet>
     (
         arraySelection,

applications/utilities/postProcessing/sampling/sample/sampleDict

@@ -83,9 +83,9 @@ sets
         type        uniform;
         axis        distance;
 
-        //- cavity
+        //- cavity. Slightly perturbed so not to align with face or edge.
-        start       (0.02 0.051 0.005);
+        start       (0.0201 0.05101 0.00501);
-        end         (0.06 0.051 0.005);
+        end         (0.0601 0.05101 0.00501);
         nPoints     10;
     }
 
@@ -103,8 +103,8 @@ sets
         //end         ( 1 0.05 0.005);
 
         //- cavity
-        start       (0.0 0.51  0.005);
+        start       (0.001 0.5101  0.00501);
-        end         (2 0.51  0.005);
+        end         (2.01 0.5101  0.00501);
         nPoints     10;
     }
 
@@ -112,7 +112,7 @@ sets
     {
         type    cloud;
         axis    xyz;
-        points  ((0.049 0.049 0.005)(0.051 0.049 0.005));
+        points  ((0.049 0.049 0.00501)(0.051 0.049 0.00501));
     }
 
 );

applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunction.C

@@ -1,4 +1,3 @@
-
 /*---------------------------------------------------------------------------*\
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox

bin/mpirunDebug

@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/bash
 #------------------------------------------------------------------------------
 # =========                 |
 # \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox

etc/apps/paraview3/cshrc

@@ -44,8 +44,8 @@ foreach cmake ( cmake-2.6.4 cmake-2.6.2 cmake-2.4.6 )
     endif
 end
 
-set paraviewMajor=paraview-3.6
+if ( ! $?ParaView_MAJOR ) setenv ParaView_MAJOR paraview-3.6
-setenv ParaView_VERSION 3.6.1
+if ( ! $?ParaView_VERSION ) setenv ParaView_VERSION 3.6.1
 
 setenv ParaView_INST_DIR $WM_THIRD_PARTY_DIR/paraview-$ParaView_VERSION
 setenv ParaView_DIR $ParaView_INST_DIR/platforms/$WM_ARCH$WM_COMPILER
@@ -54,9 +54,9 @@ setenv ParaView_DIR $ParaView_INST_DIR/platforms/$WM_ARCH$WM_COMPILER
 set paraviewPython=$ParaView_DIR/Utilities/VTKPythonWrapping
 if ( -r $paraviewPython ) then
     if ($?PYTHONPATH) then
-        setenv PYTHONPATH ${PYTHONPATH}:${paraviewPython}:$ParaView_DIR/lib/${paraviewMajor}
+        setenv PYTHONPATH ${PYTHONPATH}:${paraviewPython}:$ParaView_DIR/lib/${ParaView_MAJOR}
     else
-        setenv PYTHONPATH ${paraviewPython}:$ParaView_DIR/lib/${paraviewMajor}
+        setenv PYTHONPATH ${paraviewPython}:$ParaView_DIR/lib/${ParaView_MAJOR}
     endif
 endif
 
@@ -65,5 +65,5 @@ if ( -r $ParaView_INST_DIR ) then
     setenv PV_PLUGIN_PATH $FOAM_LIBBIN/paraview
 endif
 
-unset cmake paraviewMajor paraviewPython
+unset cmake paraviewPython
 # -----------------------------------------------------------------------------

src/OpenFOAM/containers/HashTables/HashTable/HashTable.H

@@ -109,7 +109,6 @@ struct HashTableCore
     {
         return iteratorEnd();
     }
-
 };
 
 
@@ -139,6 +138,7 @@ class HashTable
             //- Construct from key, next pointer and object
             inline hashedEntry(const Key&, hashedEntry* next, const T&);
 
+
         private:
             //- Disallow default bitwise copy construct
             hashedEntry(const hashedEntry&);
@@ -209,9 +209,8 @@ public:
         HashTable(const Xfer<HashTable<T, Key, Hash> >&);
 
 
-    // Destructor
+    //- Destructor
-
+    ~HashTable();
-        ~HashTable();
 
 
     // Member Functions
@@ -247,6 +246,7 @@ public:
             //- Print information
             Ostream& printInfo(Ostream&) const;
 
+
         // Edit
 
             //- Insert a new hashedEntry
@@ -291,7 +291,7 @@ public:
             void transfer(HashTable<T, Key, Hash>&);
 
             //- Transfer contents to the Xfer container
-            inline Xfer< HashTable<T, Key, Hash> > xfer();
+            inline Xfer<HashTable<T, Key, Hash> > xfer();
 
 
     // Member Operators
@@ -356,9 +356,8 @@ public:
                 //- Current hash index
                 label hashIndex_;
 
-        protected:
 
-            // Protected Member Functions
+        protected:
 
             // Constructors
 
@@ -380,6 +379,8 @@ public:
                 );
 
 
+            // Protected Member Functions
+
                 //- Increment to the next position
                 inline void increment();
 
@@ -392,6 +393,7 @@ public:
                 //- Return const access to referenced object
                 inline const T& cobject() const;
 
+
         public:
 
             // Member operators
@@ -434,6 +436,7 @@ public:
                     const label hashIndex
                 );
 
+
         public:
 
             // Constructors
@@ -444,13 +447,12 @@ public:
                 //- Construct end iterator
                 inline iterator(const iteratorEnd& unused);
 
+
             // Member operators
 
                 //- Conversion to a const_iterator
                 inline operator const_iterator() const;
 
-                // Access
-
                 //- Return referenced hash value
                 inline T& operator*();
                 inline T& operator()();
@@ -492,6 +494,7 @@ public:
                     const label hashIndex
                 );
 
+
         public:
 
             // Constructors
@@ -502,9 +505,8 @@ public:
                 //- Construct end iterator
                 inline const_iterator(const iteratorEnd& unused);
 
-            // Member operators
 
-                // Access
+            // Member operators
 
                 //- Return referenced hash value
                 inline const T& operator*() const;
@@ -536,7 +538,6 @@ public:
             Ostream&,
             const HashTable<T, Key, Hash>&
         );
-
 };
 
 

src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTable.C

@@ -97,11 +97,10 @@ Foam::StaticHashTable<T, Key, Hash>::StaticHashTable
 {}
 
 
-
 template<class T, class Key, class Hash>
 Foam::StaticHashTable<T, Key, Hash>::StaticHashTable
 (
-    const Xfer< StaticHashTable<T, Key, Hash> >& ht
+    const Xfer<StaticHashTable<T, Key, Hash> >& ht
 )
 :
     StaticHashTableCore(),
@@ -452,7 +451,6 @@ void Foam::StaticHashTable<T, Key, Hash>::clearStorage()
 }
 
 
-
 template<class T, class Key, class Hash>
 void Foam::StaticHashTable<T, Key, Hash>::transfer
 (

src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTable.H

@@ -72,10 +72,6 @@ template<class T, class Key, class Hash> Ostream& operator<<
 );
 
 
-/*---------------------------------------------------------------------------*\
-                     Class StaticHashTableName Declaration
-\*---------------------------------------------------------------------------*/
-
 /*---------------------------------------------------------------------------*\
                      Class StaticHashTableCore Declaration
 \*---------------------------------------------------------------------------*/
@@ -100,7 +96,6 @@ struct StaticHashTableCore
         iteratorEnd()
         {}
     };
-
 };
 
 
@@ -135,6 +130,7 @@ class StaticHashTable
         //- Assign a new hashed entry to a possibly already existing key
         bool set(const Key&, const T& newElmt, bool protect);
 
+
 public:
 
 
@@ -183,11 +179,11 @@ public:
         StaticHashTable(const StaticHashTable<T, Key, Hash>&);
 
         //- Construct by transferring the parameter contents
-        StaticHashTable(const Xfer< StaticHashTable<T, Key, Hash> >&);
+        StaticHashTable(const Xfer<StaticHashTable<T, Key, Hash> >&);
 
-    // Destructor
 
-        ~StaticHashTable();
+    //- Destructor
+    ~StaticHashTable();
 
 
     // Member Functions
@@ -251,7 +247,7 @@ public:
             void transfer(StaticHashTable<T, Key, Hash>&);
 
             //- Transfer contents to the Xfer container
-            inline Xfer< StaticHashTable<T, Key, Hash> > xfer();
+            inline Xfer<StaticHashTable<T, Key, Hash> > xfer();
 
 
     // Member Operators
@@ -275,6 +271,7 @@ public:
         //- The opposite of the equality operation.
         bool operator!=(const StaticHashTable<T, Key, Hash>&) const;
 
+
     // STL type definitions
 
         //- Type of values the StaticHashTable contains.
@@ -317,6 +314,7 @@ public:
                 //- Index of current element at hashIndex
                 label elemIndex_;
 
+
         public:
 
             // Constructors

src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTableI.H

@@ -79,7 +79,7 @@ inline bool Foam::StaticHashTable<T, Key, Hash>::set
 
 
 template<class T, class Key, class Hash>
-inline Foam::Xfer< Foam::StaticHashTable<T, Key, Hash> >
+inline Foam::Xfer<Foam::StaticHashTable<T, Key, Hash> >
 Foam::StaticHashTable<T, Key, Hash>::xfer()
 {
     return xferMove(*this);
@@ -417,6 +417,4 @@ Foam::StaticHashTable<T, Key, Hash>::end() const
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 // ************************************************************************* //

src/OpenFOAM/containers/Lists/BiIndirectList/BiIndirectList.H

@@ -74,7 +74,7 @@ public:
         (
             const UList<T>& posList,
             const UList<T>& negList,
-            const Xfer< List<label> >&
+            const Xfer<List<label> >&
         );
 
 
@@ -102,7 +102,7 @@ public:
 
             //- Reset addressing
             inline void resetAddressing(const UList<label>&);
-            inline void resetAddressing(const Xfer< List<label> >&);
+            inline void resetAddressing(const Xfer<List<label> >&);
 
 
         // Member Operators

src/OpenFOAM/containers/Lists/BiIndirectList/BiIndirectListI.H

@@ -45,7 +45,7 @@ inline Foam::BiIndirectList<T>::BiIndirectList
 (
     const UList<T>& posList,
     const UList<T>& negList,
-    const Xfer< List<label> >& addr
+    const Xfer<List<label> >& addr
 )
 :
     posList_(const_cast<UList<T>&>(posList)),
@@ -105,7 +105,7 @@ inline void Foam::BiIndirectList<T>::resetAddressing
 template<class T>
 inline void Foam::BiIndirectList<T>::resetAddressing
 (
-    const Xfer< List<label> >& addr
+    const Xfer<List<label> >& addr
 )
 {
     addressing_.transfer(addr());

src/OpenFOAM/containers/Lists/CompactListList/CompactListListI.H

@@ -224,7 +224,7 @@ inline Foam::UList<T> Foam::CompactListList<T, Container>::operator[]
 )
 {
     label start = offsets_[i];
-    return UList<T>(&m_[start], offsets_[i+1] - start);
+    return UList<T>((m_.size() ? &m_[start] : NULL), offsets_[i+1] - start);
 }
 
 
@@ -238,7 +238,7 @@ Foam::CompactListList<T, Container>::operator[]
     label start = offsets_[i];
     return UList<T>
     (
-        const_cast<T*>(&m_[start]),
+        (m_.size() ? const_cast<T*>(&m_[start]) : NULL),
         offsets_[i+1] - start
     );
 }

src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H

@@ -84,7 +84,6 @@ class DynamicList
         //- The capacity (allocated size) of the underlying list.
         label capacity_;
 
-    // Private Member Functions
 
 public:
 
@@ -93,6 +92,7 @@ public:
         //- Declare friendship with the List class
         friend class List<T>;
 
+
     // Constructors
 
         //- Construct null
@@ -115,7 +115,7 @@ public:
         explicit inline DynamicList(const UIndirectList<T>&);
 
         //- Construct by transferring the parameter contents
-        explicit inline DynamicList(const Xfer< List<T> >&);
+        explicit inline DynamicList(const Xfer<List<T> >&);
 
         //- Construct from Istream. Size set to size of read list.
         explicit DynamicList(Istream&);
@@ -125,103 +125,105 @@ public:
 
         // Access
 
-        //- Size of the underlying storage.
+            //- Size of the underlying storage.
-        inline label capacity() const;
+            inline label capacity() const;
 
         // Edit
 
-        //- Alter the size of the underlying storage.
+            //- Alter the size of the underlying storage.
-        //  The addressed size will be truncated if needed to fit, but will
+            //  The addressed size will be truncated if needed to fit, but will
-        //  remain otherwise untouched.
+            //  remain otherwise untouched.
-        //  Use this or reserve() in combination with append().
+            //  Use this or reserve() in combination with append().
-        inline void setCapacity(const label);
+            inline void setCapacity(const label);
 
-        //- Alter the addressed list size.
+            //- Alter the addressed list size.
-        //  New space will be allocated if required.
+            //  New space will be allocated if required.
-        //  Use this to resize the list prior to using the operator[] for
+            //  Use this to resize the list prior to using the operator[] for
-        //  setting values (as per List usage).
+            //  setting values (as per List usage).
-        inline void setSize(const label);
+            inline void setSize(const label);
 
-        //- Alter the addressed list size and fill new space with a constant.
+            //- Alter the addressed list size and fill new space with a constant.
-        inline void setSize(const label, const T&);
+            inline void setSize(const label, const T&);
 
-        //- Alter the addressed list size.
+            //- Alter the addressed list size.
-        //  New space will be allocated if required.
+            //  New space will be allocated if required.
-        //  Use this to resize the list prior to using the operator[] for
+            //  Use this to resize the list prior to using the operator[] for
-        //  setting values (as per List usage).
+            //  setting values (as per List usage).
-        inline void resize(const label);
+            inline void resize(const label);
 
-        //- Alter the addressed list size and fill new space with a constant.
+            //- Alter the addressed list size and fill new space with a constant.
-        inline void resize(const label, const T&);
+            inline void resize(const label, const T&);
 
-        //- Reserve allocation space for at least this size.
+            //- Reserve allocation space for at least this size.
-        //  Never shrinks the allocated size, use setCapacity() for that.
+            //  Never shrinks the allocated size, use setCapacity() for that.
-        inline void reserve(const label);
+            inline void reserve(const label);
 
-        //- Clear the addressed list, i.e. set the size to zero.
+            //- Clear the addressed list, i.e. set the size to zero.
-        //  Allocated size does not change
+            //  Allocated size does not change
-        inline void clear();
+            inline void clear();
 
-        //- Clear the list and delete storage.
+            //- Clear the list and delete storage.
-        inline void clearStorage();
+            inline void clearStorage();
 
-        //- Shrink the allocated space to the number of elements used.
+            //- Shrink the allocated space to the number of elements used.
-        //  Returns a reference to the DynamicList.
+            //  Returns a reference to the DynamicList.
-        inline DynamicList<T, SizeInc, SizeMult, SizeDiv>& shrink();
+            inline DynamicList<T, SizeInc, SizeMult, SizeDiv>& shrink();
 
-        //- Transfer contents of the argument List into this DynamicList
+            //- Transfer contents of the argument List into this DynamicList
-        inline void transfer(List<T>&);
+            inline void transfer(List<T>&);
 
-        //- Transfer contents of the argument DynamicList into this DynamicList
+            //- Transfer contents of the argument DynamicList into this DynamicList
-        inline void transfer(DynamicList<T, SizeInc, SizeMult, SizeDiv>&);
+            inline void transfer(DynamicList<T, SizeInc, SizeMult, SizeDiv>&);
 
-        //- Transfer contents to the Xfer container as a plain List
+            //- Transfer contents to the Xfer container as a plain List
-        inline Xfer< List<T> > xfer();
+            inline Xfer<List<T> > xfer();
 
-    // Member Operators
 
-        //- Append an element at the end of the list
+        // Member Operators
-        inline void append(const T&);
 
-        //- Append a List at the end of this list
+            //- Append an element at the end of the list
-        inline void append(const UList<T>&);
+            inline void append(const T&);
 
-        //- Append a UIndirectList at the end of this list
+            //- Append a List at the end of this list
-        inline void append(const UIndirectList<T>&);
+            inline void append(const UList<T>&);
 
-        //- Remove and return the top element
+            //- Append a UIndirectList at the end of this list
-        inline T remove();
+            inline void append(const UIndirectList<T>&);
 
-        //- Return non-const access to an element, resizing list if necessary
+            //- Remove and return the top element
-        inline T& operator()(const label);
+            inline T remove();
 
-        //- Assignment of all addressed entries to the given value
+            //- Return non-const access to an element, resizing list if necessary
-        inline void operator=(const T&);
+            inline T& operator()(const label);
 
-        //- Assignment from DynamicList
+            //- Assignment of all addressed entries to the given value
-        inline void operator=
+            inline void operator=(const T&);
-        (
-            const DynamicList<T, SizeInc, SizeMult, SizeDiv>&
-        );
 
-        //- Assignment from UList
+            //- Assignment from DynamicList
-        inline void operator=(const UList<T>&);
+            inline void operator=
+            (
+                const DynamicList<T, SizeInc, SizeMult, SizeDiv>&
+            );
 
-    // IOstream operators
+            //- Assignment from UList
+            inline void operator=(const UList<T>&);
 
-        // Write DynamicList to Ostream.
-        friend Ostream& operator<< <T, SizeInc, SizeMult, SizeDiv>
-        (
-            Ostream&,
-            const DynamicList<T, SizeInc, SizeMult, SizeDiv>&
-        );
 
-        //- Read from Istream, discarding contents of existing DynamicList.
+        // IOstream operators
-        friend Istream& operator>> <T, SizeInc, SizeMult, SizeDiv>
+
-        (
+            // Write DynamicList to Ostream.
-            Istream&,
+            friend Ostream& operator<< <T, SizeInc, SizeMult, SizeDiv>
-            DynamicList<T, SizeInc, SizeMult, SizeDiv>&
+            (
-        );
+                Ostream&,
+                const DynamicList<T, SizeInc, SizeMult, SizeDiv>&
+            );
+
+            //- Read from Istream, discarding contents of existing DynamicList.
+            friend Istream& operator>> <T, SizeInc, SizeMult, SizeDiv>
+            (
+                Istream&,
+                DynamicList<T, SizeInc, SizeMult, SizeDiv>&
+            );
 };
 
 

src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H

@@ -298,7 +298,7 @@ Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::transfer
 
 
 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
-inline Foam::Xfer< Foam::List<T> >
+inline Foam::Xfer<Foam::List<T> >
 Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::xfer()
 {
     return xferMoveTo< List<T> >(*this);

src/OpenFOAM/containers/Lists/IndirectList/IndirectList.H

@@ -64,7 +64,8 @@ public:
         inline IndirectList(const UList<T>&, const UList<label>&);
 
         //- Construct given the complete list and by transferring addressing
-        inline IndirectList(const UList<T>&, const Xfer< List<label> >&);
+        inline IndirectList(const UList<T>&, const Xfer<List<label> >&);
+
 
     // Member Functions
 
@@ -94,11 +95,12 @@ public:
             //- Return the list addressing
             inline const List<label>& addressing() const;
 
+
         // Edit
 
             //- Reset addressing
             inline void resetAddressing(const UList<label>&);
-            inline void resetAddressing(const Xfer< List<label> >&);
+            inline void resetAddressing(const Xfer<List<label> >&);
 
 
         // Member Operators

src/OpenFOAM/containers/Lists/IndirectList/IndirectListI.H

@@ -42,7 +42,7 @@ template<class T>
 inline Foam::IndirectList<T>::IndirectList
 (
     const UList<T>& completeList,
-    const Xfer< List<label> >& addr
+    const Xfer<List<label> >& addr
 )
 :
     completeList_(const_cast<UList<T>&>(completeList)),
@@ -121,7 +121,7 @@ inline void Foam::IndirectList<T>::resetAddressing
 template<class T>
 inline void Foam::IndirectList<T>::resetAddressing
 (
-    const Xfer< List<label> >& addr
+    const Xfer<List<label> >& addr
 )
 {
     addressing_.transfer(addr());

src/OpenFOAM/containers/Lists/List/List.C

@@ -114,7 +114,7 @@ Foam::List<T>::List(const List<T>& a)
 
 // Construct by transferring the parameter contents
 template<class T>
-Foam::List<T>::List(const Xfer< List<T> >& lst)
+Foam::List<T>::List(const Xfer<List<T> >& lst)
 {
     transfer(lst());
 }

src/OpenFOAM/containers/Lists/List/List.H

@@ -87,6 +87,7 @@ protected:
     //  Use with care.
     inline void size(const label);
 
+
 public:
 
     // Static Member Functions
@@ -109,7 +110,7 @@ public:
         List(const List<T>&);
 
         //- Construct by transferring the parameter contents
-        List(const Xfer< List<T> >&);
+        List(const Xfer<List<T> >&);
 
         //- Construct as copy or re-use as specified.
         List(List<T>&, bool reUse);
@@ -147,9 +148,8 @@ public:
         inline autoPtr<List<T> > clone() const;
 
 
-    // Destructor
+    //- Destructor
-
+    ~List();
-        ~List();
 
 
     // Related types
@@ -201,7 +201,7 @@ public:
             void transfer(SortableList<T>&);
 
             //- Transfer contents to the Xfer container
-            inline Xfer< List<T> > xfer();
+            inline Xfer<List<T> > xfer();
 
             //- Return subscript-checked element of UList.
             inline T& newElmt(const label);

src/OpenFOAM/containers/Lists/List/ListI.H

@@ -88,7 +88,7 @@ inline Foam::label Foam::List<T>::size() const
 
 
 template<class T>
-inline Foam::Xfer< Foam::List<T> > Foam::List<T>::xfer()
+inline Foam::Xfer<Foam::List<T> > Foam::List<T>::xfer()
 {
     return xferMove(*this);
 }

src/OpenFOAM/containers/Lists/PackedList/PackedList.H

@@ -132,6 +132,7 @@ class PackedList
         //- Calculate the list length when packed
         inline static label packedLength(const label);
 
+
 public:
 
     // Public data
@@ -150,12 +151,14 @@ public:
         //- Masking for all bits below the offset
         inline static unsigned int maskLower(unsigned offset);
 
+
     // Forward declaration of iterators
 
         class iteratorBase;
         class iterator;
         class const_iterator;
 
+
     // Constructors
 
         //- Null constructor
@@ -171,7 +174,7 @@ public:
         inline PackedList(const PackedList<nBits>&);
 
         //- Construct by transferring the parameter contents
-        inline PackedList(const Xfer< PackedList<nBits> >&);
+        inline PackedList(const Xfer<PackedList<nBits> >&);
 
         //- Construct from a list of labels
         explicit PackedList(const UList<label>&);
@@ -179,123 +182,126 @@ public:
         //- Clone
         inline autoPtr< PackedList<nBits> > clone() const;
 
+
     // Member Functions
 
         // Access
 
-        //- The number of elements that can be stored before reallocating
+            //- The number of elements that can be stored before reallocating
-        inline label capacity() const;
+            inline label capacity() const;
 
-        //- Number of entries.
+            //- Number of entries.
-        inline label size() const;
+            inline label size() const;
 
-        //- Return true if the list is empty (ie, size() is zero).
+            //- Return true if the list is empty (ie, size() is zero).
-        inline bool empty() const;
+            inline bool empty() const;
 
-        //- Get value at index I.
+            //- Get value at index I.
-        //  Never auto-vivify entries.
+            //  Never auto-vivify entries.
-        inline unsigned int get(const label) const;
+            inline unsigned int get(const label) const;
 
-        //- Set value at index I. Return true if value changed.
+            //- Set value at index I. Return true if value changed.
-        //  Does auto-vivify for non-existent entries.
+            //  Does auto-vivify for non-existent entries.
-        //  Default value set is the max_value.
+            //  Default value set is the max_value.
-        inline bool set(const label, const unsigned int val = ~0u);
+            inline bool set(const label, const unsigned int val = ~0u);
 
-        //- Unset the entry at index I. Return true if value changed.
+            //- Unset the entry at index I. Return true if value changed.
-        //  Never auto-vivify entries.
+            //  Never auto-vivify entries.
-        inline bool unset(const label);
+            inline bool unset(const label);
 
-        //- Return the underlying packed storage
+            //- Return the underlying packed storage
-        inline List<unsigned int>& storage();
+            inline List<unsigned int>& storage();
 
-        //- Return the underlying packed storage
+            //- Return the underlying packed storage
-        inline const List<unsigned int>& storage() const;
+            inline const List<unsigned int>& storage() const;
 
-        //- Count number of bits set, O(log(n))
+            //- Count number of bits set, O(log(n))
-        //  Uses the Hamming weight (population count) method
+            //  Uses the Hamming weight (population count) method
-        //  http://en.wikipedia.org/wiki/Hamming_weight
+            //  http://en.wikipedia.org/wiki/Hamming_weight
-        unsigned int count() const;
+            unsigned int count() const;
 
-        //- Return the values as a labelList
+            //- Return the values as a labelList
-        labelList values() const;
+            labelList values() const;
 
-        //- Print values and information
+            //- Print values and information
-        Ostream& print(Ostream&) const;
+            Ostream& print(Ostream&) const;
 
         // Edit
 
-        //- Trim any trailing zero elements
+            //- Trim any trailing zero elements
-        bool trim();
+            bool trim();
 
-        //- Invert the bits in the addressable region.
+            //- Invert the bits in the addressable region.
-        void flip();
+            void flip();
 
-        //- Alter the size of the underlying storage.
+            //- Alter the size of the underlying storage.
-        //  The addressed size will be truncated if needed to fit, but will
+            //  The addressed size will be truncated if needed to fit, but will
-        //  remain otherwise untouched.
+            //  remain otherwise untouched.
-        inline void setCapacity(const label);
+            inline void setCapacity(const label);
 
-        //- Reset addressable list size, does not shrink the allocated size.
+            //- Reset addressable list size, does not shrink the allocated size.
-        //  Optionally specify a value for new elements.
+            //  Optionally specify a value for new elements.
-        inline void resize(const label, const unsigned int& val = 0);
+            inline void resize(const label, const unsigned int& val = 0);
 
-        //- Alias for resize()
+            //- Alias for resize()
-        inline void setSize(const label, const unsigned int& val = 0);
+            inline void setSize(const label, const unsigned int& val = 0);
 
-        //- Reserve allocation space for at least this size.
+            //- Reserve allocation space for at least this size.
-        //  Never shrinks the allocated size.
+            //  Never shrinks the allocated size.
-        //  The list size is adjusted as per DynamicList with
+            //  The list size is adjusted as per DynamicList with
-        //  SizeInc=0, SizeMult=2, SizeDiv=1
+            //  SizeInc=0, SizeMult=2, SizeDiv=1
-        inline void reserve(const label);
+            inline void reserve(const label);
 
-        //- Clear the list, i.e. set addressable size to zero.
+            //- Clear the list, i.e. set addressable size to zero.
-        //  Does not adjust the underlying storage
+            //  Does not adjust the underlying storage
-        inline void clear();
+            inline void clear();
 
-        //- Clear the list and delete storage.
+            //- Clear the list and delete storage.
-        inline void clearStorage();
+            inline void clearStorage();
 
-        //- Shrink the allocated space to what is actually used.
+            //- Shrink the allocated space to what is actually used.
-        inline void shrink();
+            inline void shrink();
 
-        //- Transfer the contents of the argument list into this list
+            //- Transfer the contents of the argument list into this list
-        //  and annul the argument list.
+            //  and annul the argument list.
-        inline void transfer(PackedList<nBits>&);
+            inline void transfer(PackedList<nBits>&);
 
-        //- Transfer contents to the Xfer container
+            //- Transfer contents to the Xfer container
-        inline Xfer< PackedList<nBits> > xfer();
+            inline Xfer<PackedList<nBits> > xfer();
 
 
     // Member operators
 
-        //- Append a value at the end of the list
+            //- Append a value at the end of the list
-        inline void append(const unsigned int val);
+            inline void append(const unsigned int val);
 
-        //- Remove and return the last element
+            //- Remove and return the last element
-        inline unsigned int remove();
+            inline unsigned int remove();
 
-        //- Get value at index I
+            //- Get value at index I
-        //  Never auto-vivify entries.
+            //  Never auto-vivify entries.
-        inline unsigned int operator[](const label) const;
+            inline unsigned int operator[](const label) const;
 
-        //- Set value at index I.
+            //- Set value at index I.
-        //  Returns iterator to perform the actual operation.
+            //  Returns iterator to perform the actual operation.
-        //  Does not auto-vivify entries, but will when assigned to.
+            //  Does not auto-vivify entries, but will when assigned to.
-        inline iteratorBase operator[](const label);
+            inline iteratorBase operator[](const label);
 
-        //- Assignment of all entries to the given value. Takes linear time.
+            //- Assignment of all entries to the given value. Takes linear time.
-        inline void operator=(const unsigned int val);
+            inline void operator=(const unsigned int val);
 
-        //- Assignment operator. Takes linear time.
+            //- Assignment operator. Takes linear time.
-        void operator=(const PackedList<nBits>&);
+            void operator=(const PackedList<nBits>&);
 
-        //- Assignment operator. Takes linear time.
+            //- Assignment operator. Takes linear time.
-        void operator=(const UList<label>&);
+            void operator=(const UList<label>&);
 
-    // Ostream operator
 
-//      // Write PackedList to Ostream.
+        // Ostream operator
-//      friend Ostream& operator<< <nBits> (Ostream&, const PackedList<nBits>&);
+
+//          // Write PackedList to Ostream.
+//          friend Ostream& operator<< <nBits> (Ostream&, const PackedList<nBits>&);
+
 
     // Iterators and helpers
 
@@ -317,6 +323,7 @@ public:
                 //- Element index
                 label index_;
 
+
             // Protected Member Functions
 
                 //- Get value as unsigned, no range-checking
@@ -325,6 +332,7 @@ public:
                 //- Set value, returning true if changed, no range-checking
                 inline bool set(unsigned int);
 
+
             // Constructors
 
                 //- Construct null
@@ -333,6 +341,7 @@ public:
                 //- Construct from base list and position index
                 inline iteratorBase(const PackedList*, const label);
 
+
         public:
 
             // Member Operators
@@ -370,6 +379,7 @@ public:
             //- Disallow assignment from const_iterator - violates const-ness!
             void operator=(const const_iterator&);
 
+
         public:
 
             // Constructors
@@ -385,6 +395,7 @@ public:
                 //- Construct from base list and position index
                 inline iterator(const PackedList*, const label);
 
+
             // Member Operators
 
                 //- Compare positions (not values)
@@ -445,6 +456,7 @@ public:
                 //- Construct from iterator
                 inline const_iterator(const iterator&);
 
+
             // Member operators
 
                 //- Compare positions (not values)
@@ -466,7 +478,6 @@ public:
 
                 inline const_iterator& operator--();
                 inline const_iterator operator--(int);
-
         };
 
 

src/OpenFOAM/containers/Lists/PackedList/PackedListI.H

@@ -334,7 +334,6 @@ inline bool Foam::PackedList<nBits>::iterator::operator!=
 }
 
 
-
 template<unsigned nBits>
 inline bool Foam::PackedList<nBits>::const_iterator::operator==
 (
@@ -355,7 +354,6 @@ inline bool Foam::PackedList<nBits>::const_iterator::operator!=
 }
 
 
-
 template<unsigned nBits>
 inline typename Foam::PackedList<nBits>::iterator&
 Foam::PackedList<nBits>::iterator::operator=(const iteratorBase& iter)
@@ -712,16 +710,14 @@ inline void Foam::PackedList<nBits>::shrink()
 }
 
 template<unsigned nBits>
-inline Foam::List<unsigned int>&
+inline Foam::List<unsigned int>& Foam::PackedList<nBits>::storage()
-Foam::PackedList<nBits>::storage()
 {
     return static_cast<StorageList&>(*this);
 }
 
 
 template<unsigned nBits>
-inline const Foam::List<unsigned int>&
+inline const Foam::List<unsigned int>& Foam::PackedList<nBits>::storage() const
-Foam::PackedList<nBits>::storage() const
 {
     return static_cast<const StorageList&>(*this);
 }
@@ -738,8 +734,7 @@ inline void Foam::PackedList<nBits>::transfer(PackedList<nBits>& lst)
 
 
 template<unsigned nBits>
-inline Foam::Xfer< Foam::PackedList<nBits> >
+inline Foam::Xfer<Foam::PackedList<nBits> > Foam::PackedList<nBits>::xfer()
-Foam::PackedList<nBits>::xfer()
 {
     return xferMove(*this);
 }

src/OpenFOAM/containers/Lists/PtrList/PtrList.H

@@ -130,7 +130,7 @@ public:
         PtrList(const PtrList<T>&, const CloneArg&);
 
         //- Construct by transferring the parameter contents
-        PtrList(const Xfer< PtrList<T> >&);
+        PtrList(const Xfer<PtrList<T> >&);
 
         //- Construct as copy or re-use as specified.
         PtrList(PtrList<T>&, bool reUse);
@@ -146,9 +146,8 @@ public:
         PtrList(Istream&);
 
 
-    // Destructor
+    //- Destructor
-
+    ~PtrList();
-        ~PtrList();
 
 
     // Member functions
@@ -196,7 +195,7 @@ public:
             void transfer(PtrList<T>&);
 
             //- Transfer contents to the Xfer container
-            inline Xfer< PtrList<T> > xfer();
+            inline Xfer<PtrList<T> > xfer();
 
             //- Is element set
             inline bool set(const label) const;

src/OpenFOAM/containers/Lists/PtrList/PtrListI.H

@@ -170,30 +170,35 @@ inline Foam::PtrList<T>::iterator::iterator(T** ptr)
     ptr_(ptr)
 {}
 
+
 template<class T>
 inline bool Foam::PtrList<T>::iterator::operator==(const iterator& iter) const
 {
     return ptr_ == iter.ptr_;
 }
 
+
 template<class T>
 inline bool Foam::PtrList<T>::iterator::operator!=(const iterator& iter) const
 {
     return ptr_ != iter.ptr_;
 }
 
+
 template<class T>
 inline T& Foam::PtrList<T>::iterator::operator*()
 {
     return **ptr_;
 }
 
+
 template<class T>
 inline T& Foam::PtrList<T>::iterator::operator()()
 {
     return operator*();
 }
 
+
 template<class T>
 inline typename Foam::PtrList<T>::iterator
 Foam::PtrList<T>::iterator::operator++()
@@ -202,6 +207,7 @@ Foam::PtrList<T>::iterator::operator++()
     return *this;
 }
 
+
 template<class T>
 inline typename Foam::PtrList<T>::iterator
 Foam::PtrList<T>::iterator::operator++(int)
@@ -211,6 +217,7 @@ Foam::PtrList<T>::iterator::operator++(int)
     return tmp;
 }
 
+
 template<class T>
 inline typename Foam::PtrList<T>::iterator
 Foam::PtrList<T>::iterator::operator--()
@@ -219,6 +226,7 @@ Foam::PtrList<T>::iterator::operator--()
     return *this;
 }
 
+
 template<class T>
 inline typename Foam::PtrList<T>::iterator
 Foam::PtrList<T>::iterator::operator--(int)
@@ -228,6 +236,7 @@ Foam::PtrList<T>::iterator::operator--(int)
     return tmp;
 }
 
+
 template<class T>
 inline typename Foam::PtrList<T>::iterator
 Foam::PtrList<T>::iterator::operator+=(label n)
@@ -236,6 +245,7 @@ Foam::PtrList<T>::iterator::operator+=(label n)
     return *this;
 }
 
+
 template<class T>
 inline typename Foam::PtrList<T>::iterator
 Foam::operator+(const typename PtrList<T>::iterator& iter, label n)
@@ -244,6 +254,7 @@ Foam::operator+(const typename PtrList<T>::iterator& iter, label n)
     return tmp += n;
 }
 
+
 template<class T>
 inline typename Foam::PtrList<T>::iterator
 Foam::operator+(label n, const typename PtrList<T>::iterator& iter)
@@ -252,6 +263,7 @@ Foam::operator+(label n, const typename PtrList<T>::iterator& iter)
     return tmp += n;
 }
 
+
 template<class T>
 inline typename Foam::PtrList<T>::iterator
 Foam::PtrList<T>::iterator::operator-=(label n)
@@ -260,6 +272,7 @@ Foam::PtrList<T>::iterator::operator-=(label n)
     return *this;
 }
 
+
 template<class T>
 inline typename Foam::PtrList<T>::iterator
 Foam::operator-(const typename PtrList<T>::iterator& iter, label n)
@@ -268,6 +281,7 @@ Foam::operator-(const typename PtrList<T>::iterator& iter, label n)
     return tmp -= n;
 }
 
+
 template<class T>
 inline Foam::label Foam::operator-
 (
@@ -278,46 +292,51 @@ inline Foam::label Foam::operator-
     return (iter1.ptr_ - iter2.ptr_)/sizeof(T*);
 }
 
+
 template<class T>
 inline T& Foam::PtrList<T>::iterator::operator[](label n)
 {
     return *(*this + n);
 }
 
+
 template<class T>
 inline bool Foam::PtrList<T>::iterator::operator<(const iterator& iter) const
 {
     return ptr_ < iter.ptr_;
 }
 
+
 template<class T>
 inline bool Foam::PtrList<T>::iterator::operator>(const iterator& iter) const
 {
     return ptr_ > iter.ptr_;
 }
 
+
 template<class T>
 inline bool Foam::PtrList<T>::iterator::operator<=(const iterator& iter) const
 {
     return ptr_ <= iter.ptr_;
 }
 
+
 template<class T>
 inline bool Foam::PtrList<T>::iterator::operator>=(const iterator& iter) const
 {
     return ptr_ >= iter.ptr_;
 }
 
+
 template<class T>
-inline typename Foam::PtrList<T>::iterator
+inline typename Foam::PtrList<T>::iterator Foam::PtrList<T>::begin()
-Foam::PtrList<T>::begin()
 {
     return ptrs_.begin();
 }
 
+
 template<class T>
-inline typename Foam::PtrList<T>::iterator
+inline typename Foam::PtrList<T>::iterator Foam::PtrList<T>::end()
-Foam::PtrList<T>::end()
 {
     return ptrs_.end();
 }

src/OpenFOAM/containers/Lists/UPtrList/UPtrList.H

@@ -111,7 +111,7 @@ public:
         explicit UPtrList(const label);
 
         //- Construct by transferring the parameter contents
-        UPtrList(const Xfer< UPtrList<T> >&);
+        UPtrList(const Xfer<UPtrList<T> >&);
 
         //- Construct as copy or re-use as specified.
         UPtrList(UPtrList<T>&, bool reUse);
@@ -160,7 +160,7 @@ public:
             void transfer(UPtrList<T>&);
 
             //- Transfer contents to the Xfer container
-            inline Xfer< UPtrList<T> > xfer();
+            inline Xfer<UPtrList<T> > xfer();
 
             //- Is element set
             inline bool set(const label) const;

src/OpenFOAM/db/IOstreams/Tstreams/ITstream.H

@@ -89,7 +89,7 @@ public:
         ITstream
         (
             const string& name,
-            const Xfer< List<token> >& tokens,
+            const Xfer<List<token> >& tokens,
             streamFormat format=ASCII,
             versionNumber version=currentVersion
         )

src/OpenFOAM/db/dictionary/primitiveEntry/primitiveEntry.C

@@ -107,7 +107,7 @@ Foam::primitiveEntry::primitiveEntry
 Foam::primitiveEntry::primitiveEntry
 (
     const keyType& key,
-    const Xfer< List<token> >& tokens
+    const Xfer<List<token> >& tokens
 )
 :
     entry(key),

src/OpenFOAM/db/dictionary/primitiveEntry/primitiveEntry.H

@@ -114,7 +114,7 @@ public:
         primitiveEntry(const keyType&, const UList<token>&);
 
         //- Construct from keyword and by transferring a list of tokens
-        primitiveEntry(const keyType&, const Xfer< List<token> >&);
+        primitiveEntry(const keyType&, const Xfer<List<token> >&);
 
         //- Construct from keyword and a T
         template<class T>

src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C

@@ -1138,7 +1138,7 @@ void Foam::fvMeshDistribute::sendMesh
     {
         const cellZoneMesh& cellZones = mesh.cellZones();
 
-        labelList rowSizes(pointZoneNames.size(), 0);
+        labelList rowSizes(cellZoneNames.size(), 0);
 
         forAll(cellZoneNames, nameI)
         {

src/edgeMesh/edgeFormats/edgeFormatsCore.H

@@ -45,7 +45,7 @@ SourceFiles
 namespace Foam
 {
 
-// Forward declaration of friend functions and operators
+// Forward declaration of classes
 
 class IFstream;
 class Time;
@@ -61,10 +61,13 @@ class edgeFormatsCore
 {
 protected:
 
+    // Protected Member Functions
+
         //- Read non-comment line
         static string getLineNoComment(IFstream&);
 
 public:
+
     // Static Data
 
         //- The file extension corresponding to 'native' edge format

src/edgeMesh/edgeFormats/emesh/EMESHedgeFormat.C

@@ -29,7 +29,6 @@ License
 #include "IFstream.H"
 #include "clock.H"
 
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::fileFormats::EMESHedgeFormat::EMESHedgeFormat
@@ -119,8 +118,7 @@ bool Foam::fileFormats::EMESHedgeFormat::read
 }
 
 
-Foam::Ostream&
+Foam::Ostream& Foam::fileFormats::EMESHedgeFormat::write
-Foam::fileFormats::EMESHedgeFormat::write
 (
     Ostream& os,
     const pointField& pointLst,

src/edgeMesh/edgeFormats/emesh/EMESHedgeFormat.H

@@ -79,6 +79,7 @@ protected:
             const edgeList&
         );
 
+
 public:
 
     // Constructors

src/edgeMesh/edgeFormats/obj/OBJedgeFormat.C

@@ -64,7 +64,7 @@ bool Foam::fileFormats::OBJedgeFormat::read
     }
 
     DynamicList<point> dynPoints;
-    DynamicList<edge>  dynEdges;
+    DynamicList<edge> dynEdges;
     DynamicList<label> dynUsedPoints;
 
     while (is.good())
@@ -195,7 +195,7 @@ void Foam::fileFormats::OBJedgeFormat::write
 )
 {
     const pointField& pointLst = mesh.points();
-    const edgeList&   edgeLst  = mesh.edges();
+    const edgeList& edgeLst = mesh.edges();
 
     OFstream os(filename);
     if (!os.good())

src/edgeMesh/edgeFormats/starcd/STARCDedgeFormat.C

@@ -160,7 +160,6 @@ bool Foam::fileFormats::STARCDedgeFormat::readPoints
 }
 
 
-
 void Foam::fileFormats::STARCDedgeFormat::writePoints
 (
     Ostream& os,
@@ -177,8 +176,7 @@ void Foam::fileFormats::STARCDedgeFormat::writePoints
 
     forAll(pointLst, ptI)
     {
-        os
+        os  << ptI + 1 << " "
-            << ptI + 1 << " "
             << pointLst[ptI].x() << " "
             << pointLst[ptI].y() << " "
             << pointLst[ptI].z() << nl;
@@ -367,7 +365,7 @@ void Foam::fileFormats::STARCDedgeFormat::write
 )
 {
     const pointField& pointLst = mesh.points();
-    const edgeList&   edgeLst  = mesh.edges();
+    const edgeList& edgeLst = mesh.edges();
 
     fileName baseName = filename.lessExt();
 

src/edgeMesh/edgeFormats/starcd/STARCDedgeFormat.H

@@ -90,20 +90,21 @@ protected:
 
     // Protected Member Functions
 
-    static bool readHeader(IFstream&, const word&);
+        static bool readHeader(IFstream&, const word&);
 
-    static void writeHeader(Ostream&, const char* filetype);
+        static void writeHeader(Ostream&, const char* filetype);
 
-    static bool readPoints(IFstream&, pointField&, labelList& ids);
+        static bool readPoints(IFstream&, pointField&, labelList& ids);
 
-    static void writePoints(Ostream&, const pointField&);
+        static void writePoints(Ostream&, const pointField&);
+
+        static void writeCase
+        (
+            Ostream&,
+            const pointField&,
+            const label nEdges
+        );
 
-    static void writeCase
-    (
-        Ostream&,
-        const pointField&,
-        const label nEdges
-    );
 
 public:
 

src/edgeMesh/edgeFormats/vtk/VTKedgeFormat.C

@@ -60,8 +60,7 @@ void Foam::fileFormats::VTKedgeFormat::writeEdges
     const UList<edge>& edgeLst
 )
 {
-    os  << "LINES " << edgeLst.size() << ' '
+    os  << "LINES " << edgeLst.size() << ' ' << 3*edgeLst.size() << nl;
-        << 3*edgeLst.size() << nl;
 
     forAll(edgeLst, edgeI)
     {
@@ -72,8 +71,6 @@ void Foam::fileFormats::VTKedgeFormat::writeEdges
 }
 
 
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::fileFormats::VTKedgeFormat::VTKedgeFormat()
@@ -104,4 +101,5 @@ void Foam::fileFormats::VTKedgeFormat::write
     writeEdges(os, eMesh.edges());
 }
 
+
 // ************************************************************************* //

src/edgeMesh/edgeFormats/vtk/VTKedgeFormat.H

@@ -76,6 +76,7 @@ protected:
         //- Write edges
         static void writeEdges(Ostream&, const UList<edge>&);
 
+
 public:
 
     // Constructors

src/edgeMesh/edgeMesh.C

@@ -38,11 +38,13 @@ namespace Foam
     defineMemberFunctionSelectionTable(edgeMesh,write,fileExtension);
 }
 
+
 Foam::wordHashSet Foam::edgeMesh::readTypes()
 {
     return wordHashSet(*fileExtensionConstructorTablePtr_);
 }
 
+
 Foam::wordHashSet Foam::edgeMesh::writeTypes()
 {
     return wordHashSet(*writefileExtensionMemberFunctionTablePtr_);
@@ -66,6 +68,7 @@ bool Foam::edgeMesh::canReadType
    );
 }
 
+
 bool Foam::edgeMesh::canWriteType
 (
     const word& ext,
@@ -197,8 +200,8 @@ void Foam::edgeMesh::clear()
 
 void Foam::edgeMesh::reset
 (
-    const Xfer< pointField >& pointLst,
+    const Xfer<pointField>& pointLst,
-    const Xfer< edgeList >& edgeLst
+    const Xfer<edgeList>& edgeLst
 )
 {
     // Take over new primitive data.
@@ -215,7 +218,6 @@ void Foam::edgeMesh::reset
         // connectivity likely changed
         pointEdgesPtr_.clear();
     }
-
 }
 
 
@@ -227,8 +229,7 @@ void Foam::edgeMesh::transfer(edgeMesh& mesh)
 }
 
 
-Foam::Xfer< Foam::edgeMesh >
+Foam::Xfer<Foam::edgeMesh> Foam::edgeMesh::xfer()
-Foam::edgeMesh::xfer()
 {
     return xferMove(*this);
 }

src/edgeMesh/edgeMesh.H

@@ -101,6 +101,7 @@ public:
         //- Runtime type information
         TypeName("edgeMesh");
 
+
     // Static
 
         //- Can we read this file format?
@@ -115,6 +116,7 @@ public:
         static wordHashSet readTypes();
         static wordHashSet writeTypes();
 
+
     // Constructors
 
         //- Construct null
@@ -126,8 +128,8 @@ public:
         //- Construct by transferring components (points, edges).
         edgeMesh
         (
-            const Xfer< pointField >&,
+            const Xfer<pointField>&,
-            const Xfer< edgeList >&
+            const Xfer<edgeList>&
         );
 
         //- Construct as copy
@@ -142,6 +144,7 @@ public:
         //- Construct from Istream
         edgeMesh(Istream&);
 
+
     // Declare run-time constructor selection table
 
         declareRunTimeSelectionTable
@@ -155,6 +158,7 @@ public:
             (name)
         );
 
+
     // Selectors
 
         //- Select constructed from filename (explicit extension)
@@ -197,7 +201,7 @@ public:
         void transfer(edgeMesh&);
 
         //- Transfer contents to the Xfer container
-        Xfer< edgeMesh > xfer();
+        Xfer<edgeMesh > xfer();
 
     // Read
 
@@ -233,8 +237,8 @@ public:
         //  Note, optimized to avoid overwriting data (with Xfer::null)
         virtual void reset
         (
-            const Xfer< pointField >& points,
+            const Xfer<pointField>& points,
-            const Xfer< edgeList >& edges
+            const Xfer<edgeList>& edges
         );
 
         //- Scale points. A non-positive factor is ignored
@@ -248,8 +252,6 @@ public:
 
         void writeStats(Ostream&) const;
 
-    // Write
-
         //- Generic write routine. Chooses writer based on extension.
         virtual void write(const fileName& name) const
         {
@@ -261,10 +263,10 @@ public:
 
         inline void operator=(const edgeMesh&);
 
-    // Ostream Operator
+        // Ostream Operator
 
-        friend Ostream& operator<<(Ostream&, const edgeMesh&);
+            friend Ostream& operator<<(Ostream&, const edgeMesh&);
-        friend Istream& operator>>(Istream&, edgeMesh&);
+            friend Istream& operator>>(Istream&, edgeMesh&);
 
 };
 

src/edgeMesh/edgeMeshNew.C

@@ -28,7 +28,6 @@ License
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-
 Foam::autoPtr< Foam::edgeMesh >
 Foam::edgeMesh::New(const fileName& name, const word& ext)
 {
@@ -62,4 +61,5 @@ Foam::edgeMesh::New(const fileName& name)
     return New(name, ext);
 }
 
+
 // ************************************************************************* //

src/edgeMesh/featureEdgeMesh/featureEdgeMesh.C

@@ -73,8 +73,8 @@ Foam::featureEdgeMesh::featureEdgeMesh
 Foam::featureEdgeMesh::featureEdgeMesh
 (
     const IOobject& io,
-    const Xfer< pointField >& pointLst,
+    const Xfer<pointField>& pointLst,
-    const Xfer< edgeList >& edgeLst
+    const Xfer<edgeList>& edgeLst
 )
 :
     regIOobject(io),

src/finiteVolume/cfdTools/general/fieldSources/pressureGradientExplicitSource/pressureGradientExplicitSource.H

@@ -84,7 +84,7 @@ class pressureGradientExplicitSource
         //- Name of cell source
         word cellSource_;
 
-        //- The method by which the cells will be selecetd
+        //- The method by which the cells will be selected
         autoPtr<topoSetSource> cellSelector_;
 
         //- The set of selected cells

src/finiteVolume/cfdTools/general/fieldSources/timeActivatedExplicitSource/timeActivatedExplicitSource.H

@@ -28,7 +28,7 @@ Class
 Description
     Base class for field sources. Provides:
     - name
-    - references to mesh and time
+    - references to mesh and time databases
     - dimensions
     - volume type
     - startTime

src/finiteVolume/fields/fvPatchFields/derived/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.C

@@ -84,7 +84,7 @@ activeBaffleVelocityFvPatchVectorField
 )
 :
     fixedValueFvPatchVectorField(p, iF),
-    pName_("p"),
+    pName_(dict.lookupOrDefault<word>("p", "p")),
     cyclicPatchName_(dict.lookup("cyclicPatch")),
     cyclicPatchLabel_(p.patch().boundaryMesh().findPatchID(cyclicPatchName_)),
     orientation_(readLabel(dict.lookup("orientation"))),
@@ -96,11 +96,6 @@ activeBaffleVelocityFvPatchVectorField
     curTimeIndex_(-1)
 {
     fvPatchVectorField::operator=(vector::zero);
-
-    if (dict.found("p"))
-    {
-        dict.lookup("p") >> pName_;
-    }
 }
 
 
@@ -219,15 +214,21 @@ void Foam::activeBaffleVelocityFvPatchVectorField::updateCoeffs()
         }
 
         openFraction_ =
-            max(min(
+            max
-                openFraction_
+            (
-              + max
+                min
                 (
-                    this->db().time().deltaTValue()/openingTime_,
+                    openFraction_
-                    maxOpenFractionDelta_
+                  + max
-                )
+                    (
-               *(orientation_*sign(forceDiff)),
+                        this->db().time().deltaTValue()/openingTime_,
-              1 - 1e-6), 1e-6);
+                        maxOpenFractionDelta_
+                    )
+                   *(orientation_*sign(forceDiff)),
+                    1 - 1e-6
+                ),
+                1e-6
+            );
 
         Info<< "openFraction = " << openFraction_ << endl;
 
@@ -264,8 +265,7 @@ void Foam::activeBaffleVelocityFvPatchVectorField::write(Ostream& os) const
         << maxOpenFractionDelta_ << token::END_STATEMENT << nl;
     os.writeKeyword("openFraction")
         << openFraction_ << token::END_STATEMENT << nl;
-    os.writeKeyword("p")
+    writeEntryIfDifferent<word>(os, "p", "p", pName_);
-        << pName_ << token::END_STATEMENT << nl;
     writeEntry("value", os);
 }
 

src/finiteVolume/fields/fvPatchFields/derived/directMappedVelocityFluxFixedValue/directMappedVelocityFluxFixedValueFvPatchField.C

@@ -46,7 +46,7 @@ directMappedVelocityFluxFixedValueFvPatchField
 )
 :
     fixedValueFvPatchVectorField(p, iF),
-    phiName_("undefinedPhi")
+    phiName_("phi")
 {}
 
 
@@ -93,22 +93,22 @@ directMappedVelocityFluxFixedValueFvPatchField
 )
 :
     fixedValueFvPatchVectorField(p, iF, dict),
-    phiName_(dict.lookup("phi"))
+    phiName_(dict.lookupOrDefault<word>("phi", "phi"))
 {
     if (!isA<directMappedPatchBase>(this->patch().patch()))
     {
         FatalErrorIn
         (
             "directMappedVelocityFluxFixedValueFvPatchField::"
-            "directMappedVelocityFluxFixedValueFvPatchField\n"
+            "directMappedVelocityFluxFixedValueFvPatchField"
-            "(\n"
+            "("
-            "    const fvPatch& p,\n"
+                "const fvPatch&, "
-            "    const DimensionedField<vector, volMesh>& iF,\n"
+                "const DimensionedField<vector, volMesh>& iF, "
-            "    const dictionary& dict\n"
+                "const dictionary&"
-            ")\n"
+            ")"
-        )   << "\n    patch type '" << p.type()
+        )   << "patch type '" << p.type()
             << "' not type '" << directMappedPatchBase::typeName << "'"
-            << "\n    for patch " << p.name()
+            << " for patch " << p.name()
             << " of field " << dimensionedInternalField().name()
             << " in file " << dimensionedInternalField().objectPath()
             << exit(FatalError);
@@ -274,7 +274,7 @@ void directMappedVelocityFluxFixedValueFvPatchField::updateCoeffs()
 void directMappedVelocityFluxFixedValueFvPatchField::write(Ostream& os) const
 {
     fvPatchVectorField::write(os);
-    os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
+    writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
     this->writeEntry("value", os);
 }
 

src/finiteVolume/fields/fvPatchFields/derived/fixedFluxPressure/fixedFluxPressureFvPatchScalarField.C

@@ -161,18 +161,9 @@ void Foam::fixedFluxPressureFvPatchScalarField::updateCoeffs()
 void Foam::fixedFluxPressureFvPatchScalarField::write(Ostream& os) const
 {
     fvPatchScalarField::write(os);
-    if (UName_ != "U")
+    writeEntryIfDifferent<word>(os, "U", "U", UName_);
-    {
+    writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
-        os.writeKeyword("U") << UName_ << token::END_STATEMENT << nl;
+    writeEntryIfDifferent<word>(os, "rho", "rho", rhoName_);
-    }
-    if (phiName_ != "phi")
-    {
-        os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
-    }
-    if (rhoName_ != "rho")
-    {
-        os.writeKeyword("rho") << rhoName_ << token::END_STATEMENT << nl;
-    }
     os.writeKeyword("adjoint") << adjoint_ << token::END_STATEMENT << nl;
     gradient().writeEntry("gradient", os);
 }

src/finiteVolume/fields/fvPatchFields/derived/fixedPressureCompressibleDensity/fixedPressureCompressibleDensityFvPatchScalarField.C

@@ -45,7 +45,7 @@ fixedPressureCompressibleDensityFvPatchScalarField
 )
 :
     fixedValueFvPatchField<scalar>(p, iF),
-    pName_("pNameIsUndefined")
+    pName_("p")
 {}
 
 
@@ -72,7 +72,7 @@ fixedPressureCompressibleDensityFvPatchScalarField
 )
 :
     fixedValueFvPatchField<scalar>(p, iF, dict),
-    pName_(dict.lookup("p"))
+    pName_(dict.lookupOrDefault<word>("p", "p"))
 {}
 
 
@@ -134,7 +134,7 @@ void fixedPressureCompressibleDensityFvPatchScalarField::write
 ) const
 {
     fvPatchField<scalar>::write(os);
-    os.writeKeyword("p") << pName_ << token::END_STATEMENT << nl;
+    writeEntryIfDifferent<word>(os, "p", "p", pName_);
     writeEntry("value", os);
 }
 

src/finiteVolume/fields/fvPatchFields/derived/fluxCorrectedVelocity/fluxCorrectedVelocityFvPatchVectorField.C

@@ -143,14 +143,8 @@ void Foam::fluxCorrectedVelocityFvPatchVectorField::evaluate
 void Foam::fluxCorrectedVelocityFvPatchVectorField::write(Ostream& os) const
 {
     fvPatchVectorField::write(os);
-    if (phiName_ != "phi")
+    writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
-    {
+    writeEntryIfDifferent<word>(os, "rho", "rho", rhoName_);
-        os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
-    }
-    if (rhoName_ != "rho")
-    {
-        os.writeKeyword("rho") << rhoName_ << token::END_STATEMENT << nl;
-    }
     writeEntry("value", os);
 }
 

src/finiteVolume/fields/fvPatchFields/derived/inletOutletTotalTemperature/inletOutletTotalTemperatureFvPatchScalarField.C

@@ -30,8 +30,6 @@ License
 #include "volFields.H"
 #include "surfaceFields.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::inletOutletTotalTemperatureFvPatchScalarField::
@@ -193,18 +191,9 @@ void Foam::inletOutletTotalTemperatureFvPatchScalarField::write(Ostream& os)
 const
 {
     fvPatchScalarField::write(os);
-    if (UName_ != "U")
+    writeEntryIfDifferent<word>(os, "U", "U", UName_);
-    {
+    writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
-        os.writeKeyword("U") << UName_ << token::END_STATEMENT << nl;
+    writeEntryIfDifferent<word>(os, "psi", "psi", psiName_);
-    }
-    if (phiName_ != "phi")
-    {
-        os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
-    }
-    if (phiName_ != "psi")
-    {
-        os.writeKeyword("psi") << psiName_ << token::END_STATEMENT << nl;
-    }
     os.writeKeyword("gamma") << gamma_ << token::END_STATEMENT << nl;
     T0_.writeEntry("T0", os);
     writeEntry("value", os);

src/finiteVolume/fields/fvPatchFields/derived/movingWallVelocity/movingWallVelocityFvPatchVectorField.C

@@ -43,7 +43,8 @@ movingWallVelocityFvPatchVectorField::movingWallVelocityFvPatchVectorField
     const DimensionedField<vector, volMesh>& iF
 )
 :
-    fixedValueFvPatchVectorField(p, iF)
+    fixedValueFvPatchVectorField(p, iF),
+    UName_("U")
 {}
 
 
@@ -55,7 +56,8 @@ movingWallVelocityFvPatchVectorField::movingWallVelocityFvPatchVectorField
     const fvPatchFieldMapper& mapper
 )
 :
-    fixedValueFvPatchVectorField(ptf, p, iF, mapper)
+    fixedValueFvPatchVectorField(ptf, p, iF, mapper),
+    UName_(ptf.UName_)
 {}
 
 
@@ -66,7 +68,8 @@ movingWallVelocityFvPatchVectorField::movingWallVelocityFvPatchVectorField
     const dictionary& dict
 )
 :
-    fixedValueFvPatchVectorField(p, iF)
+    fixedValueFvPatchVectorField(p, iF),
+    UName_(dict.lookupOrDefault<word>("U", "U"))
 {
     fvPatchVectorField::operator=(vectorField("value", dict, p.size()));
 }
@@ -74,20 +77,22 @@ movingWallVelocityFvPatchVectorField::movingWallVelocityFvPatchVectorField
 
 movingWallVelocityFvPatchVectorField::movingWallVelocityFvPatchVectorField
 (
-    const movingWallVelocityFvPatchVectorField& pivpvf
+    const movingWallVelocityFvPatchVectorField& mwvpvf
 )
 :
-    fixedValueFvPatchVectorField(pivpvf)
+    fixedValueFvPatchVectorField(mwvpvf),
+    UName_(mwvpvf.UName_)
 {}
 
 
 movingWallVelocityFvPatchVectorField::movingWallVelocityFvPatchVectorField
 (
-    const movingWallVelocityFvPatchVectorField& pivpvf,
+    const movingWallVelocityFvPatchVectorField& mwvpvf,
     const DimensionedField<vector, volMesh>& iF
 )
 :
-    fixedValueFvPatchVectorField(pivpvf, iF)
+    fixedValueFvPatchVectorField(mwvpvf, iF),
+    UName_(mwvpvf.UName_)
 {}
 
 
@@ -114,7 +119,7 @@ void movingWallVelocityFvPatchVectorField::updateCoeffs()
 
     vectorField Up = (pp.faceCentres() - oldFc)/mesh.time().deltaTValue();
 
-    const volVectorField& U = db().lookupObject<volVectorField>("U");
+    const volVectorField& U = db().lookupObject<volVectorField>(UName_);
     scalarField phip =
         p.patchField<surfaceScalarField, scalar>(fvc::meshPhi(U));
 
@@ -132,6 +137,7 @@ void movingWallVelocityFvPatchVectorField::updateCoeffs()
 void movingWallVelocityFvPatchVectorField::write(Ostream& os) const
 {
     fvPatchVectorField::write(os);
+    writeEntryIfDifferent<word>(os, "U", "U", UName_);
     writeEntry("value", os);
 }
 

src/finiteVolume/fields/fvPatchFields/derived/movingWallVelocity/movingWallVelocityFvPatchVectorField.H

@@ -52,6 +52,11 @@ class movingWallVelocityFvPatchVectorField
 :
     public fixedValueFvPatchVectorField
 {
+    // Private data
+
+       //- Name of velocity field
+       word UName_;
+
 
 public:
 

src/finiteVolume/fields/fvPatchFields/derived/pressureDirectedInletOutletVelocity/pressureDirectedInletOutletVelocityFvPatchVectorField.C

@@ -196,14 +196,8 @@ void pressureDirectedInletOutletVelocityFvPatchVectorField::
 write(Ostream& os) const
 {
     fvPatchVectorField::write(os);
-    if (phiName_ != "phi")
+    writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
-    {
+    writeEntryIfDifferent<word>(os, "rho", "rho", rhoName_);
-        os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
-    }
-    if (rhoName_ != "rho")
-    {
-        os.writeKeyword("rho") << rhoName_ << token::END_STATEMENT << nl;
-    }
     inletDir_.writeEntry("inletDirection", os);
     writeEntry("value", os);
 }

src/finiteVolume/fields/fvPatchFields/derived/pressureDirectedInletVelocity/pressureDirectedInletVelocityFvPatchVectorField.C

@@ -184,14 +184,8 @@ void pressureDirectedInletVelocityFvPatchVectorField::updateCoeffs()
 void pressureDirectedInletVelocityFvPatchVectorField::write(Ostream& os) const
 {
     fvPatchVectorField::write(os);
-    if (phiName_ != "phi")
+    writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
-    {
+    writeEntryIfDifferent<word>(os, "rho", "rho", rhoName_);
-        os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
-    }
-    if (rhoName_ != "rho")
-    {
-        os.writeKeyword("rho") << rhoName_ << token::END_STATEMENT << nl;
-    }
     inletDir_.writeEntry("inletDirection", os);
     writeEntry("value", os);
 }

src/finiteVolume/fields/fvPatchFields/derived/pressureInletOutletVelocity/pressureInletOutletVelocityFvPatchVectorField.C

@@ -188,10 +188,7 @@ void pressureInletOutletVelocityFvPatchVectorField::updateCoeffs()
 void pressureInletOutletVelocityFvPatchVectorField::write(Ostream& os) const
 {
     fvPatchVectorField::write(os);
-    if (phiName_ != "phi")
+    writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
-    {
-        os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
-    }
     if (tangentialVelocity_.size())
     {
         tangentialVelocity_.writeEntry("tangentialVelocity", os);

src/finiteVolume/fields/fvPatchFields/derived/pressureInletVelocity/pressureInletVelocityFvPatchVectorField.C

@@ -146,14 +146,8 @@ void pressureInletVelocityFvPatchVectorField::updateCoeffs()
 void pressureInletVelocityFvPatchVectorField::write(Ostream& os) const
 {
     fvPatchVectorField::write(os);
-    if (phiName_ != "phi")
+    writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
-    {
+    writeEntryIfDifferent<word>(os, "rho", "rho", rhoName_);
-        os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
-    }
-    if (rhoName_ != "rho")
-    {
-        os.writeKeyword("rho") << rhoName_ << token::END_STATEMENT << nl;
-    }
     writeEntry("value", os);
 }
 

src/finiteVolume/fields/fvPatchFields/derived/timeVaryingUniformTotalPressure/timeVaryingUniformTotalPressureFvPatchScalarField.C

@@ -218,14 +218,8 @@ void Foam::timeVaryingUniformTotalPressureFvPatchScalarField::
 write(Ostream& os) const
 {
     fvPatchScalarField::write(os);
-    if (UName_ != "U")
+    writeEntryIfDifferent<word>(os, "U", "U", UName_);
-    {
+    writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
-        os.writeKeyword("U") << UName_ << token::END_STATEMENT << nl;
-    }
-    if (phiName_ != "phi")
-    {
-        os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
-    }
     os.writeKeyword("rho") << rhoName_ << token::END_STATEMENT << nl;
     os.writeKeyword("psi") << psiName_ << token::END_STATEMENT << nl;
     os.writeKeyword("gamma") << gamma_ << token::END_STATEMENT << nl;

src/finiteVolume/fields/fvPatchFields/derived/totalTemperature/totalTemperatureFvPatchScalarField.C

@@ -30,8 +30,6 @@ License
 #include "volFields.H"
 #include "surfaceFields.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::totalTemperatureFvPatchScalarField::totalTemperatureFvPatchScalarField
@@ -180,18 +178,9 @@ void Foam::totalTemperatureFvPatchScalarField::updateCoeffs()
 void Foam::totalTemperatureFvPatchScalarField::write(Ostream& os) const
 {
     fvPatchScalarField::write(os);
-    if (UName_ != "U")
+    writeEntryIfDifferent<word>(os, "U", "U", UName_);
-    {
+    writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
-        os.writeKeyword("U") << UName_ << token::END_STATEMENT << nl;
+    writeEntryIfDifferent<word>(os, "psi", "psi", psiName_);
-    }
-    if (phiName_ != "phi")
-    {
-        os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
-    }
-    if (psiName_ != "psi")
-    {
-        os.writeKeyword("psi") << psiName_ << token::END_STATEMENT << nl;
-    }
     os.writeKeyword("gamma") << gamma_ << token::END_STATEMENT << nl;
     T0_.writeEntry("T0", os);
     writeEntry("value", os);

src/finiteVolume/fields/fvPatchFields/derived/turbulentIntensityKineticEnergyInlet/turbulentIntensityKineticEnergyInletFvPatchScalarField.C

@@ -40,6 +40,7 @@ turbulentIntensityKineticEnergyInletFvPatchScalarField
 )
 :
     fixedValueFvPatchField<scalar>(p, iF),
+    UName_("U"),
     intensity_(0.05)
 {}
 
@@ -53,6 +54,7 @@ turbulentIntensityKineticEnergyInletFvPatchScalarField
 )
 :
     fixedValueFvPatchField<scalar>(ptf, p, iF, mapper),
+    UName_(ptf.UName_),
     intensity_(ptf.intensity_)
 {}
 
@@ -65,6 +67,7 @@ turbulentIntensityKineticEnergyInletFvPatchScalarField
 )
 :
     fixedValueFvPatchField<scalar>(p, iF, dict),
+    UName_(dict.lookupOrDefault<word>("U", "U")),
     intensity_(readScalar(dict.lookup("intensity")))
 {
     if (intensity_ < 0 || intensity_ > 1)
@@ -92,6 +95,7 @@ turbulentIntensityKineticEnergyInletFvPatchScalarField
 )
 :
     fixedValueFvPatchField<scalar>(ptf),
+    UName_(ptf.UName_),
     intensity_(ptf.intensity_)
 {}
 
@@ -104,6 +108,7 @@ turbulentIntensityKineticEnergyInletFvPatchScalarField
 )
 :
     fixedValueFvPatchField<scalar>(ptf, iF),
+    UName_(ptf.UName_),
     intensity_(ptf.intensity_)
 {}
 
@@ -119,7 +124,7 @@ updateCoeffs()
     }
 
     const fvPatchField<vector>& Up =
-        patch().lookupPatchField<volVectorField, vector>("U");
+        patch().lookupPatchField<volVectorField, vector>(UName_);
 
     operator==(1.5*sqr(intensity_)*magSqr(Up));
 
@@ -133,6 +138,7 @@ void Foam::turbulentIntensityKineticEnergyInletFvPatchScalarField::write
 ) const
 {
     fvPatchField<scalar>::write(os);
+    writeEntryIfDifferent<word>(os, "U", "U", UName_);
     os.writeKeyword("intensity") << intensity_ << token::END_STATEMENT << nl;
     writeEntry("value", os);
 }

src/finiteVolume/fields/fvPatchFields/derived/turbulentIntensityKineticEnergyInlet/turbulentIntensityKineticEnergyInletFvPatchScalarField.H

@@ -34,6 +34,7 @@ Description
         inlet
         {
             type        turbulentIntensityKineticEnergyInlet;
+            U           U;              // Name of U field (optional)
             intensity   0.05;           // 5% turbulence
             value       uniform 1;      // placeholder
         }
@@ -64,6 +65,9 @@ class turbulentIntensityKineticEnergyInletFvPatchScalarField
 {
     // Private data
 
+        //- Name of belocity field
+        word UName_;
+
         //- Turbulent intensity as fraction of mean velocity
         scalar intensity_;
 

src/lagrangian/basic/Cloud/Cloud.H

@@ -87,6 +87,12 @@ class Cloud
         //- Initialise cloud on IO constructor
         void initCloud(const bool checkClass);
 
+        //- Read cloud properties dictionary
+        void readCloudUniformProperties();
+
+        //- Write cloud properties dictionary
+        void writeCloudUniformProperties() const;
+
 
 public:
 
@@ -104,6 +110,12 @@ public:
     TypeName("Cloud");
 
 
+    // Static data
+
+        //- Name of cloud properties dictionary
+        static word cloudPropertiesName;
+
+
     // Constructors
 
         //- Construct from mesh and a list of particles

src/lagrangian/basic/Cloud/CloudIO.C

@@ -29,11 +29,85 @@ License
 #include "Time.H"
 #include "IOPosition.H"
 
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+template<class ParticleType>
+Foam::word Foam::Cloud<ParticleType>::cloudPropertiesName("cloudProperties");
+
+
 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
 
+template<class ParticleType>
+void Foam::Cloud<ParticleType>::readCloudUniformProperties()
+{
+    IOobject uniformPropsDictHeader
+    (
+        cloudPropertiesName,
+        time().timeName(),
+        "uniform"/cloud::prefix/name(),
+        db(),
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE,
+        false
+    );
+
+    if (uniformPropsDictHeader.headerOk())
+    {
+        const IOdictionary uniformPropsDict(uniformPropsDictHeader);
+
+        word procName("processor" + Foam::name(Pstream::myProcNo()));
+        if (uniformPropsDict.found(procName))
+        {
+            uniformPropsDict.subDict(procName).lookup("particleCount")
+                >> particleCount_;
+        }
+    }
+    else
+    {
+        particleCount_ = 0;
+    }
+}
+
+
+template<class ParticleType>
+void Foam::Cloud<ParticleType>::writeCloudUniformProperties() const
+{
+    IOdictionary uniformPropsDict
+    (
+        IOobject
+        (
+            cloudPropertiesName,
+            time().timeName(),
+            "uniform"/cloud::prefix/name(),
+            db(),
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        )
+    );
+
+    labelList np(Pstream::nProcs(), 0);
+    np[Pstream::myProcNo()] = particleCount_;
+
+    Pstream::listCombineGather(np, maxEqOp<label>());
+    Pstream::listCombineScatter(np);
+
+    forAll(np, i)
+    {
+        word procName("processor" + Foam::name(i));
+        uniformPropsDict.add(procName, dictionary());
+        uniformPropsDict.subDict(procName).add("particleCount", np[i]);
+    }
+
+    uniformPropsDict.regIOobject::write();
+}
+
+
 template<class ParticleType>
 void Foam::Cloud<ParticleType>::initCloud(const bool checkClass)
 {
+    readCloudUniformProperties();
+
     IOPosition<ParticleType> ioP(*this);
 
     if (ioP.headerOk())
@@ -156,6 +230,8 @@ bool Foam::Cloud<ParticleType>::writeObject
     IOstream::compressionType cmp
 ) const
 {
+    writeCloudUniformProperties();
+
     if (this->size())
     {
         writeFields();

src/lagrangian/basic/IOPosition/IOPosition.C

@@ -26,70 +26,6 @@ License
 
 #include "IOPosition.H"
 
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-template<class ParticleType>
-Foam::word Foam::IOPosition<ParticleType>::particlePropertiesName
-(
-    "particleProperties"
-);
-
-
-// * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * * //
-
-template<class ParticleType>
-void Foam::IOPosition<ParticleType>::readParticleProperties()
-{
-    IOobject propsDictHeader
-    (
-        particlePropertiesName,
-        cloud_.db().time().timeName(),
-        "uniform"/cloud::prefix/cloud_.name(),
-        cloud_.db(),
-        IOobject::MUST_READ,
-        IOobject::NO_WRITE,
-        false
-    );
-
-    if (propsDictHeader.headerOk())
-    {
-        const IOdictionary propsDict(propsDictHeader);
-
-        word procName("processor" + Foam::name(Pstream::myProcNo()));
-        if (propsDict.found(procName))
-        {
-            propsDict.subDict(procName).lookup("particleCount")
-                >> cloud_.particleCount_;
-        }
-    }
-}
-
-
-template<class ParticleType>
-void Foam::IOPosition<ParticleType>::writeParticleProperties() const
-{
-    IOdictionary propsDict
-    (
-        IOobject
-        (
-            particlePropertiesName,
-            cloud_.db().time().timeName(),
-            "uniform"/cloud::prefix/cloud_.name(),
-            cloud_.db(),
-            IOobject::NO_READ,
-            IOobject::NO_WRITE,
-            false
-        )
-    );
-
-    word procName("processor" + Foam::name(Pstream::myProcNo()));
-    propsDict.add(procName, dictionary());
-    propsDict.subDict(procName).add("particleCount", cloud_.particleCount_);
-
-    propsDict.regIOobject::write();
-}
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class ParticleType>
@@ -132,9 +68,6 @@ bool Foam::IOPosition<ParticleType>::write() const
 template<class ParticleType>
 bool Foam::IOPosition<ParticleType>::writeData(Ostream& os) const
 {
-    // Write global cloud data
-    writeParticleProperties();
-
     os<< cloud_.size() << nl << token::BEGIN_LIST << nl;
 
     forAllConstIter(typename Cloud<ParticleType>, cloud_, iter)
@@ -161,9 +94,6 @@ void Foam::IOPosition<ParticleType>::readData
     bool checkClass
 )
 {
-    // Read global cloud data. Resets count on cloud.
-    readParticleProperties();
-
     Istream& is = readStream(checkClass ? typeName : "");
 
     token firstToken(is);

src/lagrangian/basic/IOPosition/IOPosition.H

@@ -59,15 +59,6 @@ class IOPosition
         const Cloud<ParticleType>& cloud_;
 
 
-    // Private member functions
-
-        //- Read particle properties dictionary
-        void readParticleProperties();
-
-        //- Write particle properties dictionary
-        void writeParticleProperties() const;
-
-
 public:
 
     // Static data
@@ -78,9 +69,6 @@ public:
             return cloud_.type();
         }
 
-        //- Name of particle properties dictionary
-        static word particlePropertiesName;
-
 
     // Constructors
 

src/lagrangian/basic/Particle/ParticleIO.C

@@ -60,10 +60,6 @@ Foam::Particle<ParticleType>::Particle
         {
             is >> origProc_ >> origId_;
         }
-        else
-        {
-            origId_ = cloud_.getNewParticleID();
-        }
     }
     else
     {
@@ -91,7 +87,6 @@ Foam::Particle<ParticleType>::Particle
               + sizeof(facei_)
               + sizeof(stepFraction_)
             );
-            origId_ = cloud_.getNewParticleID();
         }
     }
 

src/lagrangian/coalCombustion/include/createCoalParcelTypes.H

@@ -27,7 +27,6 @@ License
 #ifndef createCoalParcelTypes_H
 #define createCoalParcelTypes_H
 
-#include "makeParcelIOList.H"
 #include "thermoPhysicsTypes.H"
 #include "CoalCloud.H"
 
@@ -56,8 +55,6 @@ License
                                                                               \
     typedef ParcelType<ThermoType> ParcelType##ThermoType;                    \
                                                                               \
-    makeParcelIOList(ParcelType##ThermoType);                                 \
-                                                                              \
     defineTemplateTypeNameAndDebug(ParcelType##ThermoType, 0);                \
     defineTemplateTypeNameAndDebug(Particle<ParcelType##ThermoType>, 0);      \
     defineTemplateTypeNameAndDebug(Cloud<ParcelType##ThermoType>, 0);         \

src/lagrangian/dieselSpray/parcel/parcelIO.C

@@ -103,6 +103,8 @@ void Foam::parcel::readFields(Cloud<parcel>& c)
         return;
     }
 
+    Particle<parcel>::readFields(c);
+
     IOField<scalar> d(c.fieldIOobject("d", IOobject::MUST_READ));
     c.checkFieldIOobject(c, d);
 

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

@@ -81,6 +81,8 @@ void Foam::DsmcParcel<ParcelType>::readFields(Cloud<ParcelType>& c)
         return;
     }
 
+    Particle<ParcelType>::readFields(c);
+
     IOField<vector> U(c.fieldIOobject("U", IOobject::MUST_READ));
     c.checkFieldIOobject(c, U);
 

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

@@ -269,11 +269,9 @@ void Foam::KinematicCloud<ParcelType>::info() const
 {
     Info<< "Cloud: " << this->name() << nl
         << "    Total number of parcels added   = "
-        << returnReduce(this->injection().parcelsAddedTotal(), sumOp<label>())
+        << this->injection().parcelsAddedTotal() << nl
-            << nl
         << "    Total mass introduced           = "
-        << returnReduce(this->injection().massInjected(), sumOp<scalar>())
+        << this->injection().massInjected() << nl
-            << nl
         << "    Current number of parcels       = "
         << returnReduce(this->size(), sumOp<label>()) << nl
         << "    Current mass in system          = "

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

@@ -40,7 +40,7 @@ Foam::string Foam::KinematicParcel<ParcelType>::propHeader =
   + " (Ux Uy Uz)"
   + " rho"
   + " tTurb"
-  + " UTurb";
+  + " (UTurbx UTurby UTurbz)";
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
@@ -110,6 +110,8 @@ void Foam::KinematicParcel<ParcelType>::readFields(Cloud<ParcelType>& c)
         return;
     }
 
+    Particle<ParcelType>::readFields(c);
+
     IOField<label> typeId(c.fieldIOobject("typeId", IOobject::MUST_READ));
     c.checkFieldIOobject(c, typeId);
 

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

@@ -26,7 +26,6 @@ License
 
 #include "basicKinematicParcel.H"
 #include "KinematicCloud.H"
-#include "makeParcelIOList.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -35,8 +34,6 @@ namespace Foam
     defineTemplateTypeNameAndDebug(Cloud<basicKinematicParcel>, 0);
 
     defineParcelTypeNameAndDebug(KinematicCloud<basicKinematicParcel>, 0);
-
-    makeParcelIOList(basicKinematicParcel);
 };
 
 

src/lagrangian/intermediate/parcels/derived/basicThermoParcel/defineBasicThermoParcel.C

@@ -26,7 +26,6 @@ License
 
 #include "basicThermoParcel.H"
 #include "ThermoCloud.H"
-#include "makeParcelIOList.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -41,8 +40,6 @@ namespace Foam
     defineParcelTypeNameAndDebug(KinematicCloud<basicThermoParcel>, 0);
 
     defineParcelTypeNameAndDebug(ThermoCloud<basicThermoParcel>, 0);
-
-    makeParcelIOList(basicThermoParcel);
 };
 
 

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

@@ -27,7 +27,6 @@ License
 #ifndef createReactingMultiphaseParcelTypes_H
 #define createReactingMultiphaseParcelTypes_H
 
-#include "makeParcelIOList.H"
 #include "thermoPhysicsTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -55,8 +54,6 @@ License
                                                                               \
     typedef ParcelType<ThermoType> ParcelType##ThermoType;                    \
                                                                               \
-    makeParcelIOList(ParcelType##ThermoType);                                 \
-                                                                              \
     defineTemplateTypeNameAndDebug(ParcelType##ThermoType, 0);                \
     defineTemplateTypeNameAndDebug(Particle<ParcelType##ThermoType>, 0);      \
     defineTemplateTypeNameAndDebug(Cloud<ParcelType##ThermoType>, 0);         \

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

@@ -27,7 +27,6 @@ License
 #ifndef createReactingParcelTypes_H
 #define createReactingParcelTypes_H
 
-#include "makeParcelIOList.H"
 #include "thermoPhysicsTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -43,8 +42,6 @@ License
                                                                               \
     typedef ParcelType<ThermoType> ParcelType##ThermoType;                    \
                                                                               \
-    makeParcelIOList(ParcelType##ThermoType);                                 \
-                                                                              \
     defineTemplateTypeNameAndDebug(ParcelType##ThermoType, 0);                \
     defineTemplateTypeNameAndDebug(Particle<ParcelType##ThermoType>, 0);      \
     defineTemplateTypeNameAndDebug(Cloud<ParcelType##ThermoType>, 0);         \

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

@@ -216,11 +216,10 @@ Foam::scalar Foam::InjectionModel<CloudType>::setNumberOfParticles
                 "Foam::scalar "
                 "Foam::InjectionModel<CloudType>::setNumberOfParticles"
                 "("
-                "    const label, "
+                    "const label, "
-                "    const scalar, "
+                    "const scalar, "
-                "    const scalar, "
+                    "const scalar, "
-                "    const scalar, "
+                    "const scalar"
-                "    const scalar"
                 ")"
             )<< "Unknown parcelBasis type" << nl
              << exit(FatalError);
@@ -232,18 +231,26 @@ Foam::scalar Foam::InjectionModel<CloudType>::setNumberOfParticles
 
 
 template<class CloudType>
-void Foam::InjectionModel<CloudType>::postInjectCheck(const label parcelsAdded)
+void Foam::InjectionModel<CloudType>::postInjectCheck
+(
+    const label parcelsAdded,
+    const scalar massAdded
+)
 {
-    if (parcelsAdded > 0)
+    const label allParcelsAdded = returnReduce(parcelsAdded, sumOp<label>());
+
+    if (allParcelsAdded > 0)
     {
-        Pout<< nl
+        Info<< nl
             << "--> Cloud: " << owner_.name() << nl
-            << "    Added " << parcelsAdded
+            << "    Added " << allParcelsAdded << " new parcels" << nl << endl;
-            << " new parcels" << nl << endl;
     }
 
     // Increment total number of parcels added
-    parcelsAddedTotal_ += parcelsAdded;
+    parcelsAddedTotal_ += allParcelsAdded;
+
+    // Increment total mass injected
+    massInjected_ += returnReduce(massAdded, sumOp<scalar>());
 
     // Update time for start of next injection
     time0_ = owner_.db().time().value();
@@ -355,16 +362,12 @@ void Foam::InjectionModel<CloudType>::inject(TrackData& td)
     const polyMesh& mesh = owner_.mesh();
 
     // Prepare for next time step
+    label parcelsAdded = 0;
+    scalar massAdded = 0.0;
     label newParcels = 0;
     scalar newVolume = 0.0;
-    prepareForNextTimeStep(time, newParcels, newVolume);
 
-    // Return if no parcels are required
+    prepareForNextTimeStep(time, newParcels, newVolume);
-    if (newParcels == 0)
-    {
-        postInjectCheck(0);
-        return;
-    }
 
     // Duration of injection period during this timestep
     const scalar deltaT =
@@ -374,7 +377,6 @@ void Foam::InjectionModel<CloudType>::inject(TrackData& td)
     const scalar padTime = max(0.0, SOI_ - time0_);
 
     // Introduce new parcels linearly across carrier phase timestep
-    label parcelsAdded = 0;
     for (label parcelI=0; parcelI<newParcels; parcelI++)
     {
         if (validInjection(parcelI))
@@ -425,13 +427,13 @@ void Foam::InjectionModel<CloudType>::inject(TrackData& td)
                 // Add the new parcel
                 td.cloud().addParticle(pPtr);
 
-                massInjected_ += pPtr->nParticle()*pPtr->mass();
+                massAdded += pPtr->nParticle()*pPtr->mass();
                 parcelsAdded++;
             }
         }
     }
 
-    postInjectCheck(parcelsAdded);
+    postInjectCheck(parcelsAdded, massAdded);
 }
 
 

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

@@ -188,7 +188,11 @@ protected:
         );
 
         //- Post injection checks
-        virtual void postInjectCheck(const label parcelsAdded);
+        virtual void postInjectCheck
+        (
+            const label parcelsAdded,
+            const scalar massAdded
+        );
 
 
 public: