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"
+
 
-    if (fluidRegions.size())
-    {
     #include "compressibleMultiRegionCourantNo.H"
-        #include "setInitialDeltaT.H"
+    #include "solidRegionDiffusionNo.H"
-    }
+    #include "setInitialMultiRegionDeltaT.H"
+
 
     while (runTime.run())
     {
         #include "readTimeControls.H"
+        #include "readSolidTimeControls.H"
         #include "readPIMPLEControls.H"
 
-        if (fluidRegions.size())
+
-        {
         #include "compressibleMultiRegionCourantNo.H"
-            #include "setDeltaT.H"
+        #include "solidRegionDiffusionNo.H"
-        }
+        #include "setMultiRegionDeltaT.H"
 
         runTime++;
 

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,4 +1,6 @@
     scalar CoNum = -GREAT;
+    if (fluidRegions.size())
+    {
         forAll(fluidRegions, regionI)
         {
             CoNum = max
@@ -13,3 +15,4 @@
                 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
-            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/vtkPV3FoamUpdateInfo.C

@@ -408,6 +408,19 @@ 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_ += addToSelection<cellSet>

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,8 +209,7 @@ public:
         HashTable(const Xfer<HashTable<T, Key, Hash> >&);
 
 
-    // Destructor
+    //- Destructor
-
     ~HashTable();
 
 
@@ -247,6 +246,7 @@ public:
             //- Print information
             Ostream& printInfo(Ostream&) const;
 
+
         // Edit
 
             //- Insert a new hashedEntry
@@ -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,7 +97,6 @@ Foam::StaticHashTable<T, Key, Hash>::StaticHashTable
 {}
 
 
-
 template<class T, class Key, class Hash>
 Foam::StaticHashTable<T, Key, Hash>::StaticHashTable
 (
@@ -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:
 
 
@@ -185,8 +181,8 @@ public:
         //- Construct by transferring the parameter contents
         StaticHashTable(const Xfer<StaticHashTable<T, Key, Hash> >&);
 
-    // Destructor
 
+    //- Destructor
     ~StaticHashTable();
 
 
@@ -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

@@ -417,6 +417,4 @@ Foam::StaticHashTable<T, Key, Hash>::end() const
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 // ************************************************************************* //

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
@@ -178,6 +178,7 @@ public:
             //- Transfer contents to the Xfer container as a plain List
             inline Xfer<List<T> > xfer();
 
+
         // Member Operators
 
             //- Append an element at the end of the list
@@ -207,6 +208,7 @@ public:
             //- Assignment from UList
             inline void operator=(const UList<T>&);
 
+
         // IOstream operators
 
             // Write DynamicList to Ostream.

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

@@ -66,6 +66,7 @@ public:
         //- Construct given the complete list and by transferring addressing
         inline IndirectList(const UList<T>&, const Xfer<List<label> >&);
 
+
     // Member Functions
 
         // Access
@@ -94,6 +95,7 @@ public:
             //- Return the list addressing
             inline const List<label>& addressing() const;
 
+
         // Edit
 
             //- Reset addressing

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

@@ -87,6 +87,7 @@ protected:
     //  Use with care.
     inline void size(const label);
 
+
 public:
 
     // Static Member Functions
@@ -147,8 +148,7 @@ public:
         inline autoPtr<List<T> > clone() const;
 
 
-    // Destructor
+    //- Destructor
-
     ~List();
 
 

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
@@ -179,6 +182,7 @@ public:
         //- Clone
         inline autoPtr< PackedList<nBits> > clone() const;
 
+
     // Member Functions
 
         // Access
@@ -292,11 +296,13 @@ public:
             //- Assignment operator. Takes linear time.
             void operator=(const UList<label>&);
 
+
         // Ostream operator
 
 //          // Write PackedList to Ostream.
 //          friend Ostream& operator<< <nBits> (Ostream&, const PackedList<nBits>&);
 
+
     // Iterators and helpers
 
         //- The iterator base for PackedList
@@ -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

@@ -146,8 +146,7 @@ public:
         PtrList(Istream&);
 
 
-    // Destructor
+    //- Destructor
-
     ~PtrList();
 
 

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/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/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;

src/edgeMesh/edgeFormats/starcd/STARCDedgeFormat.H

@@ -105,6 +105,7 @@ protected:
             const label nEdges
         );
 
+
 public:
 
     // Constructors

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,
@@ -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
@@ -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)
@@ -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
         {

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/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,7 +214,10 @@ void Foam::activeBaffleVelocityFvPatchVectorField::updateCoeffs()
         }
 
         openFraction_ =
-            max(min(
+            max
+            (
+                min
+                (
                     openFraction_
                   + max
                     (
@@ -227,7 +225,10 @@ void Foam::activeBaffleVelocityFvPatchVectorField::updateCoeffs()
                         maxOpenFractionDelta_
                     )
                    *(orientation_*sign(forceDiff)),
-              1 - 1e-6), 1e-6);
+                    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

@@ -219,7 +219,6 @@ Foam::scalar Foam::InjectionModel<CloudType>::setNumberOfParticles
                     "const label, "
                     "const scalar, "
                     "const scalar, "
-                "    const scalar, "
                     "const scalar"
                 ")"
             )<< "Unknown parcelBasis type" << nl
@@ -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:

src/lagrangian/intermediate/submodels/Kinematic/PostProcessingModel/PatchPostProcessing/PatchPostProcessing.C

@@ -25,7 +25,8 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "PatchPostProcessing.H"
-#include "IOPtrList.H"
+#include "Pstream.H"
+#include "ListListOps.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -54,34 +55,57 @@ void Foam::PatchPostProcessing<CloudType>::write()
 {
     forAll(patchData_, patchI)
     {
-        IOPtrList<parcelType> postObject
+        List<List<string> > procData(Pstream::nProcs());
-        (
+        procData[Pstream::myProcNo()] = patchData_[patchI];
-            IOobject
-            (
-                patchNames_[patchI] + ".post",
-                this->owner().time().timeName(),
-                "postProcessing",
-                this->owner(),
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            patchData_[patchI].size()
-        );
 
-        forAll(postObject, ptrI)
+        Pstream::gatherList(procData);
+
+        if (Pstream::master())
         {
-            postObject.set(ptrI, patchData_[patchI][ptrI].ptr());
+            fileName outputDir;
+
+            if (Pstream::parRun())
+            {
+                // Put in undecomposed case (Note: gives problems for
+                // distributed data running)
+                outputDir =
+                    mesh_.time().path()/".."/"postProcessing"/cloud::prefix/
+                    this->owner().name()/this->owner().time().timeName();
+            }
+            else
+            {
+                outputDir =
+                    mesh_.time().path()/"postProcessing"/cloud::prefix/
+                    this->owner().name()/this->owner().time().timeName();
             }
 
-        postObject.note() = parcelType::propHeader;
+            // Create directory if it doesn't exist
+            mkDir(outputDir);
 
-        postObject.writeObject
+            OFstream patchOutFile
             (
+                outputDir/patchNames_[patchI] + ".post",
                 IOstream::ASCII,
                 IOstream::currentVersion,
                 mesh_.time().writeCompression()
             );
 
+            List<string> globalData;
+            globalData = ListListOps::combine<List<string> >
+            (
+                procData,
+                accessOp<List<string> >()
+            );
+            sort(globalData);
+
+            patchOutFile<< "# Time " + parcelType::propHeader << nl;
+
+            forAll(globalData, i)
+            {
+                patchOutFile<< globalData[i].c_str() << nl;
+            }
+        }
+
         patchData_[patchI].clearStorage();
     }
 }
@@ -98,6 +122,7 @@ Foam::PatchPostProcessing<CloudType>::PatchPostProcessing
 :
     PostProcessingModel<CloudType>(dict, owner, typeName),
     mesh_(owner.mesh()),
+    maxStoredParcels_(readLabel(this->coeffDict().lookup("maxStoredParcels"))),
     patchNames_(this->coeffDict().lookup("patches")),
     patchData_(patchNames_.size()),
     patchIds_(patchNames_.size())
@@ -149,7 +174,9 @@ void Foam::PatchPostProcessing<CloudType>::postPatch
     label localPatchI = applyToPatch(patchI);
     if (localPatchI >= 0 && patchData_[localPatchI].size() < maxStoredParcels_)
     {
-        patchData_[localPatchI].append(p.clone());
+        OStringStream data;
+        data<< this->owner().time().timeName() << ' ' << p;
+        patchData_[localPatchI].append(data.str());
     }
 }
 

src/lagrangian/intermediate/submodels/Kinematic/PostProcessingModel/PatchPostProcessing/PatchPostProcessing.H

@@ -65,8 +65,8 @@ class PatchPostProcessing
         //- List of patch names
         wordList patchNames_;
 
-        //- List of parcel data per patch
+        //- List of output data per patch
-        List<DynamicList<autoPtr<parcelType> > > patchData_;
+        List<DynamicList<string> > patchData_;
 
         //- Mapping from local to global patch ids
         labelList patchIds_;

src/lagrangian/molecularDynamics/molecule/interactionLists/interactionLists.C

@@ -450,8 +450,17 @@ bool Foam::interactionLists::testPointFaceDistance
     // if the algorithm hasn't returned anything by now then something has
     // gone wrong.
 
-    FatalErrorIn("interactionLists.C") << nl
+    FatalErrorIn
-        << "point " << p << " to face " << faceToTest
+    (
+        "interactionLists::testPointFaceDistance"
+        "("
+            "const vector&, "
+            "const labelList&, "
+            "const vectorList&, "
+            "const vector&, "
+            "const vector&"
+        ") const"
+    )   << "point " << p << " to face " << faceToTest
         << " comparison did not find a nearest point"
         << " to be inside or outside face."
         << abort(FatalError);

src/lagrangian/molecularDynamics/molecule/interactionLists/referredCellList/referredCellList.C

@@ -121,8 +121,10 @@ void Foam::referredCellList::buildReferredCellList
         }
         else
         {
-            FatalErrorIn ("referredCellList.C")
+            FatalErrorIn
-                << nl << "unable to read undecomposed boundary file from "
+            (
+                "referredCellList::buildReferredCellList(bool)"
+            )   << "unable to read undecomposed boundary file from "
                 << "constant/polyMesh" << nl
                 << abort(FatalError);
         }
@@ -333,9 +335,10 @@ void Foam::referredCellList::buildReferredCellList
                             > interactionLists::transTol
                     )
                     {
-                        FatalErrorIn ("referredCellList.C")
+                        FatalErrorIn
-                            << nl << "Face pairs on patch "
+                        (
-                            << patch.name()
+                            "referredCellList::buildReferredCellList(bool)"
+                        )   << "Face pairs on patch " << patch.name()
                             << ", segment " << patchNames[nUP]
                             << " do not give the same referring "
                             << " transformations to within tolerance of "
@@ -423,9 +426,10 @@ void Foam::referredCellList::buildReferredCellList
                                 > interactionLists::transTol
                         )
                         {
-                            FatalErrorIn ("referredCellList.C")
+                            FatalErrorIn
-                                << nl << "Face pairs on patch "
+                            (
-                                << patch.name()
+                                "referredCellList::buildReferredCellList(bool)"
+                            )   << "Face pairs on patch " << patch.name()
                                 << " do not give the same referring "
                                 << " transformations to within tolerance of "
                                 << interactionLists::transTol << nl
@@ -1022,8 +1026,10 @@ void Foam::referredCellList::buildReferredCellList
                     {
                         if (faceT == -1)
                         {
-                            FatalErrorIn ("referredCellList.C")
+                            FatalErrorIn
-                                << nl << "faceT == -1 encountered but "
+                            (
+                                "referredCellList::buildReferredCellList(bool)"
+                            )   << "faceT == -1 encountered but "
                                 << meshFacesOnThisSegment.size()
                                 << " faces found on patch segment."
                                 << abort(FatalError);

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

@@ -105,6 +105,8 @@ void Foam::molecule::readFields(Cloud<molecule>& mC)
         return;
     }
 
+    Particle<molecule>::readFields(mC);
+
     IOField<tensor> Q(mC.fieldIOobject("Q", IOobject::MUST_READ));
     mC.checkFieldIOobject(mC, Q);
 

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

@@ -81,7 +81,7 @@ void Foam::moleculeCloud::buildConstProps()
 
             if (siteIds[sI] == -1)
             {
-                FatalErrorIn("moleculeCloud.C") << nl
+                FatalErrorIn("moleculeCloud::buildConstProps()")
                     << siteId << " site not found."
                     << nl << abort(FatalError);
             }

src/lagrangian/molecularDynamics/potential/pairPotential/basic/pairPotential.C

@@ -101,7 +101,7 @@ Foam::scalar Foam::pairPotential::force(const scalar r) const
 
     if (k < 0)
     {
-        FatalErrorIn("pairPotential.C") << nl
+        FatalErrorIn("pairPotential::force(const scalar) const")
             << "r less than rMin in pair potential " << name_ << nl
             << abort(FatalError);
     }
@@ -138,7 +138,7 @@ Foam::scalar Foam::pairPotential::energy(const scalar r) const
 
     if (k < 0)
     {
-        FatalErrorIn("pairPotential.C") << nl
+        FatalErrorIn("pairPotential::energy(const scalar) const")
             << "r less than rMin in pair potential " << name_ << nl
             << abort(FatalError);
     }

src/lagrangian/molecularDynamics/potential/potential/potential.C

@@ -40,7 +40,7 @@ void Foam::potential::setSiteIdList(const IOdictionary& moleculePropertiesDict)
 
         if (!moleculePropertiesDict.found(id))
         {
-            FatalErrorIn("potential.C") << nl
+            FatalErrorIn("potential::setSiteIdList(const IOdictionary&)")
                 << id << " molecule subDict not found"
                 << nl << abort(FatalError);
         }
@@ -67,7 +67,7 @@ void Foam::potential::setSiteIdList(const IOdictionary& moleculePropertiesDict)
 
             if (findIndex(siteIdNames, siteId) == -1)
             {
-                FatalErrorIn("potential.C") << nl
+                FatalErrorIn("potential::setSiteIdList(const IOdictionary&)")
                     << siteId << " in pairPotentialSiteIds is not in siteIds: "
                     << siteIdNames << nl << abort(FatalError);
             }
@@ -174,7 +174,7 @@ void Foam::potential::potential::readPotentialDict()
 
             if (removalOrder_[rO] == -1)
             {
-                FatalErrorIn("potentials.C") << nl
+                FatalErrorIn("potential::readPotentialDict()")
                     << "removalOrder entry: " << remOrd[rO]
                     << " not found in idList."
                     << nl << abort(FatalError);
@@ -187,7 +187,7 @@ void Foam::potential::potential::readPotentialDict()
 
     if (!potentialDict.found("pair"))
     {
-        FatalErrorIn("potentials.C") << nl
+        FatalErrorIn("potential::readPotentialDict()")
             << "pair potential specification subDict not found"
             << abort(FatalError);
     }
@@ -208,7 +208,7 @@ void Foam::potential::potential::readPotentialDict()
     {
         if (!potentialDict.found("tether"))
         {
-            FatalErrorIn("potential.C") << nl
+            FatalErrorIn("potential::readPotentialDict()")
                 << "tether potential specification subDict not found"
                 << abort(FatalError);
         }
@@ -289,11 +289,15 @@ void Foam::potential::potential::readMdInitialiseDict
 
             if (!moleculePropertiesDict.found(id))
             {
-                FatalErrorIn("potential.C") << nl
+                FatalErrorIn
-                    << "Molecule type "
+                (
-                    << id
+                    "potential::readMdInitialiseDict"
-                    << " not found in moleculeProperties dictionary."
+                    "("
-                    << nl
+                        "const IOdictionary&, "
+                        "IOdictionary&"
+                    ")"
+                )   << "Molecule type " << id
+                    << " not found in moleculeProperties dictionary." << nl
                     << abort(FatalError);
             }
 
@@ -340,11 +344,15 @@ void Foam::potential::potential::readMdInitialiseDict
             }
             else
             {
-                FatalErrorIn("potential.C") << nl
+                FatalErrorIn
-                    << "Tether id  "
+                (
-                    << tetherSiteId
+                    "potential::readMdInitialiseDict"
-                    << " not found as a site of any molecule in zone."
+                    "("
-                    << nl
+                        "const IOdictionary&, "
+                        "IOdictionary&"
+                    ")"
+                )   << "Tether id  " << tetherSiteId
+                    << " not found as a site of any molecule in zone." << nl
                     << abort(FatalError);
             }
         }

src/mesh/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.C

@@ -670,7 +670,6 @@ void Foam::refinementSurfaces::findHigherIntersection
             haveLevelField = true;
         }
 
-
         if (haveLevelField)
         {
             forAll(intersectionInfo, i)
@@ -741,8 +740,8 @@ void Foam::refinementSurfaces::findHigherIntersection
             }
             else
             {
-                p0[missI] = p0[pointI];
+                p0[missI] = start[pointI];
-                p1[missI] = p1[pointI];
+                p1[missI] = end[pointI];
                 intersectionToPoint[missI] = pointI;
                 missI++;
             }

src/meshTools/directMapped/directMappedPolyPatch/directMappedPatchBase.C

@@ -623,6 +623,27 @@ Foam::directMappedPatchBase::directMappedPatchBase
 {}
 
 
+Foam::directMappedPatchBase::directMappedPatchBase
+(
+    const polyPatch& pp,
+    const word& sampleRegion,
+    const sampleMode mode,
+    const word& samplePatch,
+    const vector& offset
+)
+:
+    patch_(pp),
+    sampleRegion_(sampleRegion),
+    mode_(mode),
+    samplePatch_(samplePatch),
+    uniformOffset_(true),
+    offset_(offset),
+    offsets_(0),
+    sameRegion_(sampleRegion_ == patch_.boundaryMesh().mesh().name()),
+    mapPtr_(NULL)
+{}
+
+
 Foam::directMappedPatchBase::directMappedPatchBase
 (
     const polyPatch& pp,

src/meshTools/directMapped/directMappedPolyPatch/directMappedPatchBase.H

@@ -157,6 +157,16 @@ public:
             const vectorField& offset
         );
 
+        //- Construct from components
+        directMappedPatchBase
+        (
+            const polyPatch& pp,
+            const word& sampleRegion,
+            const sampleMode sampleMode,
+            const word& samplePatch,
+            const vector& offset
+        );
+
         //- Construct from dictionary
         directMappedPatchBase(const polyPatch&, const dictionary&);
 

src/meshTools/directMapped/directMappedPolyPatch/directMappedPolyPatch.C

@@ -82,6 +82,31 @@ Foam::directMappedPolyPatch::directMappedPolyPatch
 {}
 
 
+Foam::directMappedPolyPatch::directMappedPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const word& sampleRegion,
+    const directMappedPatchBase::sampleMode mode,
+    const word& samplePatch,
+    const vector& offset,
+    const polyBoundaryMesh& bm
+)
+:
+    polyPatch(name, size, start, index, bm),
+    directMappedPatchBase
+    (
+        static_cast<const polyPatch&>(*this),
+        sampleRegion,
+        mode,
+        samplePatch,
+        offset
+    )
+{}
+
+
 Foam::directMappedPolyPatch::directMappedPolyPatch
 (
     const word& name,

src/meshTools/directMapped/directMappedPolyPatch/directMappedPolyPatch.H

@@ -115,6 +115,20 @@ public:
             const polyBoundaryMesh& bm
         );
 
+        //- Construct from components. Uniform offset.
+        directMappedPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const word& sampleRegion,
+            const directMappedPatchBase::sampleMode mode,
+            const word& samplePatch,
+            const vector& offset,
+            const polyBoundaryMesh& bm
+        );
+
         //- Construct from dictionary
         directMappedPolyPatch
         (