Merge branch 'master' of /home/dm4/OpenFOAM/repositories/OpenFOAM-dev

applications/utilities/preProcessing/applyBoundaryLayer/applyBoundaryLayer.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -104,13 +104,15 @@ int main(int argc, char *argv[])
 
     Info<< "Setting boundary layer velocity" << nl << endl;
     scalar yblv = ybl.value();
-    forAll(U, celli)
+    forAll(U, cellI)
     {
-        if (y[celli] <= yblv)
+        if (y[cellI] <= yblv)
         {
-            U[celli] *= ::pow(y[celli]/yblv, (1.0/7.0));
+            mask[cellI] = 1;
+            U[cellI] *= ::pow(y[cellI]/yblv, (1.0/7.0));
         }
     }
+    mask.correctBoundaryConditions();
 
     Info<< "Writing U\n" << endl;
     U.write();
@@ -128,11 +130,15 @@ int main(int argc, char *argv[])
 
     if (isA<incompressible::RASModel>(turbulence()))
     {
-        // Calculate nut
+        // Calculate nut - reference nut is calculated by the turbulence model
+        // on its construction
         tmp<volScalarField> tnut = turbulence->nut();
         volScalarField& nut = tnut();
         volScalarField S(mag(dev(symm(fvc::grad(U)))));
-        nut = sqr(kappa*min(y, ybl))*::sqrt(2)*S;
+        nut = (1 - mask)*nut + mask*sqr(kappa*min(y, ybl))*::sqrt(2)*S;
+
+        // do not correct BC - wall functions will 'undo' manipulation above
+        // by using nut from turbulence model
 
         if (args.optionFound("writenut"))
         {
@@ -140,9 +146,6 @@ int main(int argc, char *argv[])
             nut.write();
         }
 
-        // Create G field - used by RAS wall functions
-        volScalarField G(turbulence().GName(), nut*2*sqr(S));
-
 
         //--- Read and modify turbulence fields
 
@@ -150,8 +153,11 @@ int main(int argc, char *argv[])
         tmp<volScalarField> tk = turbulence->k();
         volScalarField& k = tk();
         scalar ck0 = pow025(Cmu)*kappa;
-        k = sqr(nut/(ck0*min(y, ybl)));
+        k = (1 - mask)*k + mask*sqr(nut/(ck0*min(y, ybl)));
-        k.correctBoundaryConditions();
+
+        // do not correct BC - operation may use inconsistent fields wrt these
+        // local manipulations
+        // k.correctBoundaryConditions();
 
         Info<< "Writing k\n" << endl;
         k.write();
@@ -161,8 +167,11 @@ int main(int argc, char *argv[])
         tmp<volScalarField> tepsilon = turbulence->epsilon();
         volScalarField& epsilon = tepsilon();
         scalar ce0 = ::pow(Cmu, 0.75)/kappa;
-        epsilon = ce0*k*sqrt(k)/min(y, ybl);
+        epsilon = (1 - mask)*epsilon + mask*ce0*k*sqrt(k)/min(y, ybl);
-        epsilon.correctBoundaryConditions();
+
+        // do not correct BC - wall functions will use non-updated k from
+        // turbulence model
+        // epsilon.correctBoundaryConditions();
 
         Info<< "Writing epsilon\n" << endl;
         epsilon.write();
@@ -181,12 +190,12 @@ int main(int argc, char *argv[])
         if (omegaHeader.headerOk())
         {
             volScalarField omega(omegaHeader, mesh);
-            omega =
+            dimensionedScalar k0("VSMALL", k.dimensions(), VSMALL);
-                epsilon
+            omega = (1 - mask)*omega + mask*epsilon/(Cmu*k + k0);
-               /(
+
-                   Cmu*k+dimensionedScalar("VSMALL", k.dimensions(), VSMALL)
+            // do not correct BC - wall functions will use non-updated k from
-                );
+            // turbulence model
-            omega.correctBoundaryConditions();
+            // omega.correctBoundaryConditions();
 
             Info<< "Writing omega\n" << endl;
             omega.write();
@@ -207,7 +216,9 @@ int main(int argc, char *argv[])
         {
             volScalarField nuTilda(nuTildaHeader, mesh);
             nuTilda = nut;
-            nuTilda.correctBoundaryConditions();
+
+            // do not correct BC
+            // nuTilda.correctBoundaryConditions();
 
             Info<< "Writing nuTilda\n" << endl;
             nuTilda.write();

applications/utilities/preProcessing/applyBoundaryLayer/createFields.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -57,5 +57,21 @@ License
 Info<< "\nCreating boundary-layer for U of thickness "
     << ybl.value() << " m" << nl << endl;
 
+Info<< "Creating mask field" << endl;
+volScalarField mask
+(
+    IOobject
+    (
+        "mask",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("zero", dimless, 0.0),
+    zeroGradientFvPatchScalarField::typeName
+);
+
 
 // ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/constraint/cyclicAMI/cyclicAMIFvPatchField.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,9 +23,6 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "cyclicAMIFvPatchField.H"
-#include "transformField.H"
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Type>
@@ -157,7 +154,15 @@ Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField() const
 
     Field<Type> pnf(iField, nbrFaceCells);
 
-    tmp<Field<Type> > tpnf(new Field<Type>(cyclicAMIPatch_.interpolate(pnf)));
+    tmp<Field<Type> > tpnf;
+    if (cyclicAMIPatch_.applyLowWeightCorrection())
+    {
+        tpnf = cyclicAMIPatch_.interpolate(pnf, this->patchInternalField()());
+    }
+    else
+    {
+        tpnf = cyclicAMIPatch_.interpolate(pnf);
+    }
 
     if (doTransform())
     {
@@ -203,7 +208,15 @@ void Foam::cyclicAMIFvPatchField<Type>::updateInterfaceMatrix
     // Transform according to the transformation tensors
     transformCoupleField(pnf, cmpt);
 
+    if (cyclicAMIPatch_.applyLowWeightCorrection())
+    {
+        scalarField pif(psiInternal, cyclicAMIPatch_.faceCells());
+        pnf = cyclicAMIPatch_.interpolate(pnf, pif);
+    }
+    else
+    {
         pnf = cyclicAMIPatch_.interpolate(pnf);
+    }
 
     // Multiply the field by coefficients and add into the result
     const labelUList& faceCells = cyclicAMIPatch_.faceCells();
@@ -232,7 +245,15 @@ void Foam::cyclicAMIFvPatchField<Type>::updateInterfaceMatrix
     // Transform according to the transformation tensors
     transformCoupleField(pnf);
 
+    if (cyclicAMIPatch_.applyLowWeightCorrection())
+    {
+        Field<Type> pif(psiInternal, cyclicAMIPatch_.faceCells());
+        pnf = cyclicAMIPatch_.interpolate(pnf, pif);
+    }
+    else
+    {
         pnf = cyclicAMIPatch_.interpolate(pnf);
+    }
 
     // Multiply the field by coefficients and add into the result
     const labelUList& faceCells = cyclicAMIPatch_.faceCells();

src/finiteVolume/fvMesh/fvPatches/constraint/cyclicAMI/cyclicAMIFvPatch.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -55,7 +55,11 @@ void Foam::cyclicAMIFvPatch::makeWeights(scalarField& w) const
 
         const scalarField nbrDeltas
         (
-            interpolate(nbrPatch.nf() & nbrPatch.fvPatch::delta())
+            interpolate
+            (
+                nbrPatch.nf() & nbrPatch.fvPatch::delta(),
+                scalarField(this->size(), 1.0)
+            )
         );
 
         forAll(deltas, faceI)
@@ -82,7 +86,14 @@ Foam::tmp<Foam::vectorField> Foam::cyclicAMIFvPatch::delta() const
     {
         const vectorField patchD(fvPatch::delta());
 
-        const vectorField nbrPatchD(interpolate(nbrPatch.fvPatch::delta()));
+        const vectorField nbrPatchD
+        (
+            interpolate
+            (
+                nbrPatch.fvPatch::delta(),
+                vectorField(this->size(), vector::zero)
+            )
+        );
 
         tmp<vectorField> tpdv(new vectorField(patchD.size()));
         vectorField& pdv = tpdv();

src/finiteVolume/fvMesh/fvPatches/constraint/cyclicAMI/cyclicAMIFvPatch.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -154,16 +154,29 @@ public:
             //- Return delta (P to N) vectors across coupled patch
             virtual tmp<vectorField> delta() const;
 
-            template<class Type>
+            bool applyLowWeightCorrection() const
-            tmp<Field<Type> > interpolate(const Field<Type>& fld) const
             {
-                return cyclicAMIPolyPatch_.interpolate(fld);
+                return cyclicAMIPolyPatch_.applyLowWeightCorrection();
             }
 
             template<class Type>
-            tmp<Field<Type> > interpolate(const tmp<Field<Type> >& tFld) const
+            tmp<Field<Type> > interpolate
+            (
+                const Field<Type>& fld,
+                const UList<Type>& defaultValues = UList<Type>()
+            ) const
             {
-                return cyclicAMIPolyPatch_.interpolate(tFld);
+                return cyclicAMIPolyPatch_.interpolate(fld, defaultValues);
+            }
+
+            template<class Type>
+            tmp<Field<Type> > interpolate
+            (
+                const tmp<Field<Type> >& tFld,
+                const UList<Type>& defaultValues = UList<Type>()
+            ) const
+            {
+                return cyclicAMIPolyPatch_.interpolate(tFld, defaultValues);
             }
 
 

src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -201,11 +201,14 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
     scalarListList& wght,
     scalarField& wghtSum,
     const bool conformal,
-    const bool output
+    const bool output,
+    const scalar lowWeightTol
 )
 {
     // Normalise the weights
     wghtSum.setSize(wght.size());
+    label nLowWeight = 0;
+
     forAll(wght, faceI)
     {
         scalarList& w = wght[faceI];
@@ -225,6 +228,11 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
         }
 
         wghtSum[faceI] = t;
+
+        if (t < lowWeightTol)
+        {
+            nLowWeight++;
+        }
     }
 
 
@@ -241,6 +249,13 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
                 << gAverage(wghtSum) << endl;
         }
     }
+
+    if (debug && nLowWeight)
+    {
+        Pout<< "AMI: Identified " << nLowWeight
+            << " faces with weights less than " << lowWeightTol
+            << endl;
+    }
 }
 
 
@@ -502,7 +517,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::agglomerate
         srcWeights,
         srcWeightsSum,
         true,
-        false
+        false,
+        -1
     );
 }
 
@@ -516,12 +532,14 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
     const TargetPatch& tgtPatch,
     const faceAreaIntersect::triangulationMode& triMode,
     const interpolationMethod& method,
+    const scalar lowWeightCorrection,
     const bool reverseTarget
 )
 :
     method_(method),
     reverseTarget_(reverseTarget),
     singlePatchProc_(-999),
+    lowWeightCorrection_(lowWeightCorrection),
     srcAddress_(),
     srcWeights_(),
     srcWeightsSum_(),
@@ -544,12 +562,14 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
     const autoPtr<searchableSurface>& surfPtr,
     const faceAreaIntersect::triangulationMode& triMode,
     const interpolationMethod& method,
+    const scalar lowWeightCorrection,
     const bool reverseTarget
 )
 :
     method_(method),
     reverseTarget_(reverseTarget),
     singlePatchProc_(-999),
+    lowWeightCorrection_(lowWeightCorrection),
     srcAddress_(),
     srcWeights_(),
     srcWeightsSum_(),
@@ -632,6 +652,7 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
     method_(fineAMI.method_),
     reverseTarget_(fineAMI.reverseTarget_),
     singlePatchProc_(fineAMI.singlePatchProc_),
+    lowWeightCorrection_(-1.0),
     srcAddress_(),
     srcWeights_(),
     srcWeightsSum_(),
@@ -908,7 +929,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             srcWeights_,
             srcWeightsSum_,
             AMIPtr->conformal(),
-            true
+            true,
+            lowWeightCorrection_
         );
         normaliseWeights
         (
@@ -918,7 +940,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             tgtWeights_,
             tgtWeightsSum_,
             AMIPtr->conformal(),
-            true
+            true,
+            lowWeightCorrection_
         );
 
         // cache maps and reset addresses
@@ -965,7 +988,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             srcWeights_,
             srcWeightsSum_,
             AMIPtr->conformal(),
-            true
+            true,
+            lowWeightCorrection_
         );
         normaliseWeights
         (
@@ -975,7 +999,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             tgtWeights_,
             tgtWeightsSum_,
             AMIPtr->conformal(),
-            true
+            true,
+            lowWeightCorrection_
         );
     }
 
@@ -998,7 +1023,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
 (
     const UList<Type>& fld,
     const CombineOp& cop,
-    List<Type>& result
+    List<Type>& result,
+    const UList<Type>& defaultValues
 ) const
 {
     if (fld.size() != srcAddress_.size())
@@ -1009,7 +1035,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
             "("
                 "const UList<Type>&, "
                 "const CombineOp&, "
-                "List<Type>&"
+                "List<Type>&, "
+                "const UList<Type>&"
             ") const"
         )   << "Supplied field size is not equal to source patch size" << nl
             << "    source patch   = " << srcAddress_.size() << nl
@@ -1018,6 +1045,29 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
             << abort(FatalError);
     }
 
+    if (lowWeightCorrection_ > 0)
+    {
+        if (defaultValues.size() != tgtAddress_.size())
+        {
+            FatalErrorIn
+            (
+                "AMIInterpolation::interpolateToTarget"
+                "("
+                    "const UList<Type>&, "
+                    "const CombineOp&, "
+                    "List<Type>&, "
+                    "const UList<Type>&"
+                ") const"
+            )   << "Employing default values when sum of weights falls below "
+                << lowWeightCorrection_
+                << " but supplied default field size is not equal to target "
+                << "patch size" << nl
+                << "    default values = " << defaultValues.size() << nl
+                << "    target patch   = " << tgtAddress_.size() << nl
+                << abort(FatalError);
+        }
+    }
+
     result.setSize(tgtAddress_.size());
 
     if (singlePatchProc_ == -1)
@@ -1028,6 +1078,12 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
         map.distribute(work);
 
         forAll(result, faceI)
+        {
+            if (tgtWeightsSum_[faceI] < lowWeightCorrection_)
+            {
+                result[faceI] = defaultValues[faceI];
+            }
+            else
             {
                 const labelList& faces = tgtAddress_[faceI];
                 const scalarList& weights = tgtWeights_[faceI];
@@ -1038,9 +1094,16 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
                 }
             }
         }
+    }
     else
     {
         forAll(result, faceI)
+        {
+            if (tgtWeightsSum_[faceI] < lowWeightCorrection_)
+            {
+                result[faceI] = defaultValues[faceI];
+            }
+            else
             {
                 const labelList& faces = tgtAddress_[faceI];
                 const scalarList& weights = tgtWeights_[faceI];
@@ -1052,6 +1115,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
             }
         }
     }
+}
 
 
 template<class SourcePatch, class TargetPatch>
@@ -1060,7 +1124,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
 (
     const UList<Type>& fld,
     const CombineOp& cop,
-    List<Type>& result
+    List<Type>& result,
+    const UList<Type>& defaultValues
 ) const
 {
     if (fld.size() != tgtAddress_.size())
@@ -1071,7 +1136,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
             "("
                 "const UList<Type>&, "
                 "const CombineOp&, "
-                "List<Type>&"
+                "List<Type>&, "
+                "const UList<Type>&"
             ") const"
         )   << "Supplied field size is not equal to target patch size" << nl
             << "    source patch   = " << srcAddress_.size() << nl
@@ -1080,6 +1146,29 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
             << abort(FatalError);
     }
 
+    if (lowWeightCorrection_ > 0)
+    {
+        if (defaultValues.size() != srcAddress_.size())
+        {
+            FatalErrorIn
+            (
+                "AMIInterpolation::interpolateToSource"
+                "("
+                    "const UList<Type>&, "
+                    "const CombineOp&, "
+                    "List<Type>&, "
+                    "const UList<Type>&"
+                ") const"
+            )   << "Employing default values when sum of weights falls below "
+                << lowWeightCorrection_
+                << " but supplied default field size is not equal to target "
+                << "patch size" << nl
+                << "    default values = " << defaultValues.size() << nl
+                << "    source patch   = " << srcAddress_.size() << nl
+                << abort(FatalError);
+        }
+    }
+
     result.setSize(srcAddress_.size());
 
     if (singlePatchProc_ == -1)
@@ -1090,6 +1179,12 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
         map.distribute(work);
 
         forAll(result, faceI)
+        {
+            if (srcWeightsSum_[faceI] < lowWeightCorrection_)
+            {
+                result[faceI] = defaultValues[faceI];
+            }
+            else
             {
                 const labelList& faces = srcAddress_[faceI];
                 const scalarList& weights = srcWeights_[faceI];
@@ -1100,9 +1195,16 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
                 }
             }
         }
+    }
     else
     {
         forAll(result, faceI)
+        {
+            if (srcWeightsSum_[faceI] < lowWeightCorrection_)
+            {
+                result[faceI] = defaultValues[faceI];
+            }
+            else
             {
                 const labelList& faces = srcAddress_[faceI];
                 const scalarList& weights = srcWeights_[faceI];
@@ -1114,6 +1216,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
             }
         }
     }
+}
 
 
 template<class SourcePatch, class TargetPatch>
@@ -1122,7 +1225,8 @@ Foam::tmp<Foam::Field<Type> >
 Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
 (
     const Field<Type>& fld,
-    const CombineOp& cop
+    const CombineOp& cop,
+    const UList<Type>& defaultValues
 ) const
 {
     tmp<Field<Type> > tresult
@@ -1138,7 +1242,8 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
     (
         fld,
         multiplyWeightedOp<Type, CombineOp>(cop),
-        tresult()
+        tresult(),
+        defaultValues
     );
 
     return tresult;
@@ -1151,10 +1256,11 @@ Foam::tmp<Foam::Field<Type> >
 Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
 (
     const tmp<Field<Type> >& tFld,
-    const CombineOp& cop
+    const CombineOp& cop,
+    const UList<Type>& defaultValues
 ) const
 {
-    return interpolateToSource(tFld(), cop);
+    return interpolateToSource(tFld(), cop, defaultValues);
 }
 
 
@@ -1164,7 +1270,8 @@ Foam::tmp<Foam::Field<Type> >
 Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
 (
     const Field<Type>& fld,
-    const CombineOp& cop
+    const CombineOp& cop,
+    const UList<Type>& defaultValues
 ) const
 {
     tmp<Field<Type> > tresult
@@ -1180,7 +1287,8 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
     (
         fld,
         multiplyWeightedOp<Type, CombineOp>(cop),
-        tresult()
+        tresult(),
+        defaultValues
     );
 
     return tresult;
@@ -1193,10 +1301,11 @@ Foam::tmp<Foam::Field<Type> >
 Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
 (
     const tmp<Field<Type> >& tFld,
-    const CombineOp& cop
+    const CombineOp& cop,
+    const UList<Type>& defaultValues
 ) const
 {
-    return interpolateToTarget(tFld(), cop);
+    return interpolateToTarget(tFld(), cop, defaultValues);
 }
 
 
@@ -1205,10 +1314,11 @@ template<class Type>
 Foam::tmp<Foam::Field<Type> >
 Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
 (
-    const Field<Type>& fld
+    const Field<Type>& fld,
+    const UList<Type>& defaultValues
 ) const
 {
-    return interpolateToSource(fld, plusEqOp<Type>());
+    return interpolateToSource(fld, plusEqOp<Type>(), defaultValues);
 }
 
 
@@ -1217,10 +1327,11 @@ template<class Type>
 Foam::tmp<Foam::Field<Type> >
 Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
 (
-    const tmp<Field<Type> >& tFld
+    const tmp<Field<Type> >& tFld,
+    const UList<Type>& defaultValues
 ) const
 {
-    return interpolateToSource(tFld(), plusEqOp<Type>());
+    return interpolateToSource(tFld(), plusEqOp<Type>(), defaultValues);
 }
 
 
@@ -1229,10 +1340,11 @@ template<class Type>
 Foam::tmp<Foam::Field<Type> >
 Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
 (
-    const Field<Type>& fld
+    const Field<Type>& fld,
+    const UList<Type>& defaultValues
 ) const
 {
-    return interpolateToTarget(fld, plusEqOp<Type>());
+    return interpolateToTarget(fld, plusEqOp<Type>(), defaultValues);
 }
 
 
@@ -1241,10 +1353,11 @@ template<class Type>
 Foam::tmp<Foam::Field<Type> >
 Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
 (
-    const tmp<Field<Type> >& tFld
+    const tmp<Field<Type> >& tFld,
+    const UList<Type>& defaultValues
 ) const
 {
-    return interpolateToTarget(tFld(), plusEqOp<Type>());
+    return interpolateToTarget(tFld(), plusEqOp<Type>(), defaultValues);
 }
 
 

src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -120,6 +120,9 @@ private:
         //  cases
         label singlePatchProc_;
 
+        //- Threshold weight below which interpolation is deactivated
+        scalar lowWeightCorrection_;
+
 
         // Source patch
 
@@ -238,7 +241,8 @@ private:
                 scalarListList& wght,
                 scalarField& wghtSum,
                 const bool conformal,
-                const bool output
+                const bool output,
+                const scalar lowWeightTol
             );
 
 
@@ -273,6 +277,7 @@ public:
             const TargetPatch& tgtPatch,
             const faceAreaIntersect::triangulationMode& triMode,
             const interpolationMethod& method = imFaceAreaWeight,
+            const scalar lowWeightCorrection = -1,
             const bool reverseTarget = false
         );
 
@@ -284,6 +289,7 @@ public:
             const autoPtr<searchableSurface>& surf,
             const faceAreaIntersect::triangulationMode& triMode,
             const interpolationMethod& method = imFaceAreaWeight,
+            const scalar lowWeightCorrection = -1,
             const bool reverseTarget = false
         );
 
@@ -313,7 +319,13 @@ public:
 
             //- Set to -1, or the processor holding all faces (both sides) of
             //  the AMI
-            label singlePatchProc() const;
+            inline label singlePatchProc() const;
+
+            //- Threshold weight below which interpolation is deactivated
+            inline scalar lowWeightCorrection() const;
+
+            //- Return true if employing a 'lowWeightCorrection'
+            inline bool applyLowWeightCorrection() const;
 
 
             // Source patch
@@ -379,7 +391,8 @@ public:
                 (
                     const UList<Type>& fld,
                     const CombineOp& cop,
-                    List<Type>& result
+                    List<Type>& result,
+                    const UList<Type>& defaultValues = UList<Type>::null()
                 ) const;
 
                 //- Interpolate from source to target with supplied op
@@ -389,7 +402,8 @@ public:
                 (
                     const UList<Type>& fld,
                     const CombineOp& cop,
-                    List<Type>& result
+                    List<Type>& result,
+                    const UList<Type>& defaultValues = UList<Type>::null()
                 ) const;
 
 
@@ -398,7 +412,8 @@ public:
             tmp<Field<Type> > interpolateToSource
             (
                 const Field<Type>& fld,
-                const CombineOp& cop
+                const CombineOp& cop,
+                const UList<Type>& defaultValues = UList<Type>::null()
             ) const;
 
             //- Interpolate from target tmp field to source with supplied op
@@ -406,7 +421,8 @@ public:
             tmp<Field<Type> > interpolateToSource
             (
                 const tmp<Field<Type> >& tFld,
-                const CombineOp& cop
+                const CombineOp& cop,
+                const UList<Type>& defaultValues = UList<Type>::null()
             ) const;
 
             //- Interpolate from source to target with supplied op
@@ -414,7 +430,8 @@ public:
             tmp<Field<Type> > interpolateToTarget
             (
                 const Field<Type>& fld,
-                const CombineOp& cop
+                const CombineOp& cop,
+                const UList<Type>& defaultValues = UList<Type>::null()
             ) const;
 
             //- Interpolate from source tmp field to target with supplied op
@@ -422,35 +439,40 @@ public:
             tmp<Field<Type> > interpolateToTarget
             (
                 const tmp<Field<Type> >& tFld,
-                const CombineOp& cop
+                const CombineOp& cop,
+                const UList<Type>& defaultValues = UList<Type>::null()
             ) const;
 
             //- Interpolate from target to source
             template<class Type>
             tmp<Field<Type> > interpolateToSource
             (
-                const Field<Type>& fld
+                const Field<Type>& fld,
+                const UList<Type>& defaultValues = UList<Type>::null()
             ) const;
 
             //- Interpolate from target tmp field
             template<class Type>
             tmp<Field<Type> > interpolateToSource
             (
-                const tmp<Field<Type> >& tFld
+                const tmp<Field<Type> >& tFld,
+                const UList<Type>& defaultValues = UList<Type>::null()
             ) const;
 
             //- Interpolate from source to target
             template<class Type>
             tmp<Field<Type> > interpolateToTarget
             (
-                const Field<Type>& fld
+                const Field<Type>& fld,
+                const UList<Type>& defaultValues = UList<Type>::null()
             ) const;
 
             //- Interpolate from source tmp field
             template<class Type>
             tmp<Field<Type> > interpolateToTarget
             (
-                const tmp<Field<Type> >& tFld
+                const tmp<Field<Type> >& tFld,
+                const UList<Type>& defaultValues = UList<Type>::null()
             ) const;
 
 

src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolationI.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -31,6 +31,23 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::singlePatchProc() const
 }
 
 
+template<class SourcePatch, class TargetPatch>
+inline Foam::scalar
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::lowWeightCorrection() const
+{
+    return lowWeightCorrection_;
+}
+
+
+template<class SourcePatch, class TargetPatch>
+inline bool
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::
+applyLowWeightCorrection() const
+{
+    return lowWeightCorrection_ > 0;
+}
+
+
 template<class SourcePatch, class TargetPatch>
 inline const Foam::scalarField&
 Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcMagSf() const

src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -310,6 +310,8 @@ Foam::scalar Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::interArea
     const label tgtFaceI
 ) const
 {
+    scalar area = 0;
+
     const pointField& srcPoints = this->srcPatch_.points();
     const pointField& tgtPoints = this->tgtPatch_.points();
 
@@ -322,7 +324,7 @@ Foam::scalar Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::interArea
     const scalar tgtMag = tgt.mag(tgtPoints);
     if ((this->srcMagSf_[srcFaceI] < ROOTVSMALL) || (tgtMag < ROOTVSMALL))
     {
-        return 0.0;
+        return area;
     }
 
     // create intersection object
@@ -338,12 +340,11 @@ Foam::scalar Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::interArea
     {
         n += this->tgtPatch_.faceNormals()[tgtFaceI];
     }
-    n *= 0.5;
+    scalar magN = mag(n);
 
-    scalar area = 0;
+    if (magN > ROOTVSMALL)
-    if (mag(n) > ROOTVSMALL)
     {
-        area = inter.calc(src, tgt, n, this->triMode_);
+        area = inter.calc(src, tgt, n/magN, this->triMode_);
     }
     else
     {
@@ -549,7 +550,7 @@ void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::calculate
         tgtFaceI
     );
 
-    if (this->srcNonOverlap_.size() != 0)
+    if (debug && !this->srcNonOverlap_.empty())
     {
         Pout<< "    AMI: " << this->srcNonOverlap_.size()
             << " non-overlap faces identified"

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -175,7 +175,22 @@ void Foam::cyclicAMIPointPatchField<Type>::swapAddSeparated
             Field<Type> nbrFcFld(nbrPpi().pointToFaceInterpolate(nbrPtFld));
 
             // interpolate to owner
-            nbrFcFld = cyclicAMIPatch_.cyclicAMIPatch().interpolate(nbrFcFld);
+            if (cyclicAMIPatch_.cyclicAMIPatch().applyLowWeightCorrection())
+            {
+                Field<Type> fcFld(ppi().pointToFaceInterpolate(ptFld));
+
+                nbrFcFld =
+                    cyclicAMIPatch_.cyclicAMIPatch().interpolate
+                    (
+                        nbrFcFld,
+                        fcFld
+                    );
+            }
+            else
+            {
+                nbrFcFld =
+                    cyclicAMIPatch_.cyclicAMIPatch().interpolate(nbrFcFld);
+            }
 
             // add to internal field
             this->addToInternalField
@@ -190,11 +205,25 @@ void Foam::cyclicAMIPointPatchField<Type>::swapAddSeparated
             Field<Type> fcFld(ppi().pointToFaceInterpolate(ptFld));
 
             // interpolate to neighbour
+            if (cyclicAMIPatch_.cyclicAMIPatch().applyLowWeightCorrection())
+            {
+                Field<Type> nbrFcFld(nbrPpi().pointToFaceInterpolate(nbrPtFld));
+
+                fcFld =
+                    cyclicAMIPatch_.cyclicAMIPatch().neighbPatch().interpolate
+                    (
+                        fcFld,
+                        nbrFcFld
+                    );
+            }
+            else
+            {
                 fcFld =
                     cyclicAMIPatch_.cyclicAMIPatch().neighbPatch().interpolate
                     (
                         fcFld
                     );
+            }
 
             // add to internal field
             nbr.addToInternalField

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C

@@ -359,6 +359,7 @@ void Foam::cyclicAMIPolyPatch::resetAMI
                 surfPtr(),
                 faceAreaIntersect::tmMesh,
                 AMIMethod,
+                AMILowWeightCorrection_,
                 AMIReverse_
             )
         );
@@ -470,6 +471,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     separationVector_(vector::zero),
     AMIPtr_(NULL),
     AMIReverse_(false),
+    AMILowWeightCorrection_(-1.0),
     surfPtr_(NULL),
     surfDict_(fileName("surface"))
 {
@@ -498,6 +500,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     separationVector_(vector::zero),
     AMIPtr_(NULL),
     AMIReverse_(dict.lookupOrDefault<bool>("flipNormals", false)),
+    AMILowWeightCorrection_(dict.lookupOrDefault("lowWeightCorrection", -1.0)),
     surfPtr_(NULL),
     surfDict_(dict.subOrEmptyDict("surface"))
 {
@@ -606,6 +609,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     separationVector_(pp.separationVector_),
     AMIPtr_(NULL),
     AMIReverse_(pp.AMIReverse_),
+    AMILowWeightCorrection_(pp.AMILowWeightCorrection_),
     surfPtr_(NULL),
     surfDict_(pp.surfDict_)
 {
@@ -635,6 +639,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     separationVector_(pp.separationVector_),
     AMIPtr_(NULL),
     AMIReverse_(pp.AMIReverse_),
+    AMILowWeightCorrection_(pp.AMILowWeightCorrection_),
     surfPtr_(NULL),
     surfDict_(pp.surfDict_)
 {
@@ -678,6 +683,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     separationVector_(pp.separationVector_),
     AMIPtr_(NULL),
     AMIReverse_(pp.AMIReverse_),
+    AMILowWeightCorrection_(pp.AMILowWeightCorrection_),
     surfPtr_(NULL),
     surfDict_(pp.surfDict_)
 {}
@@ -793,6 +799,19 @@ const Foam::AMIPatchToPatchInterpolation& Foam::cyclicAMIPolyPatch::AMI() const
 }
 
 
+bool Foam::cyclicAMIPolyPatch::applyLowWeightCorrection() const
+{
+    if (owner())
+    {
+        return AMI().applyLowWeightCorrection();
+    }
+    else
+    {
+        return neighbPatch().AMI().applyLowWeightCorrection();
+    }
+}
+
+
 void Foam::cyclicAMIPolyPatch::transformPosition(pointField& l) const
 {
     if (!parallel())
@@ -970,7 +989,6 @@ void Foam::cyclicAMIPolyPatch::write(Ostream& os) const
             {
                 os.writeKeyword("rotationAngle") << radToDeg(rotationAngle_)
                     << token::END_STATEMENT << nl;
-
             }
 
             break;
@@ -997,6 +1015,12 @@ void Foam::cyclicAMIPolyPatch::write(Ostream& os) const
             << token::END_STATEMENT << nl;
     }
 
+    if (AMILowWeightCorrection_ > 0)
+    {
+        os.writeKeyword("lowWeightCorrection") << AMILowWeightCorrection_
+            << token::END_STATEMENT << nl;
+    }
+
     if (!surfDict_.empty())
     {
         os.writeKeyword(surfDict_.dictName());

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H

@@ -97,6 +97,9 @@ private:
         //- Flag to indicate that slave patch should be reversed for AMI
         const bool AMIReverse_;
 
+        //- Low weight correction threshold for AMI
+        const scalar AMILowWeightCorrection_;
+
         //- Projection surface
         mutable autoPtr<searchableSurface> surfPtr_;
 
@@ -298,6 +301,9 @@ public:
             //- Return a reference to the AMI interpolator
             const AMIPatchToPatchInterpolation& AMI() const;
 
+            //- Return true if applying the low weight correction
+            bool applyLowWeightCorrection() const;
+
 
             // Transformations
 
@@ -325,13 +331,18 @@ public:
 
                 //- Interpolate field
                 template<class Type>
-                tmp<Field<Type> > interpolate(const Field<Type>& fld) const;
+                tmp<Field<Type> > interpolate
+                (
+                    const Field<Type>& fld,
+                    const UList<Type>& defaultValues = UList<Type>()
+                ) const;
 
                 //- Interpolate tmp field
                 template<class Type>
                 tmp<Field<Type> > interpolate
                 (
-                    const tmp<Field<Type> >& tFld
+                    const tmp<Field<Type> >& tFld,
+                    const UList<Type>& defaultValues = UList<Type>()
                 ) const;
 
                 //- Low-level interpolate List
@@ -340,7 +351,8 @@ public:
                 (
                     const UList<Type>& fld,
                     const CombineOp& cop,
-                    List<Type>& result
+                    List<Type>& result,
+                    const UList<Type>& defaultValues = UList<Type>()
                 ) const;
 
 

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,16 +28,17 @@ License
 template<class Type>
 Foam::tmp<Foam::Field<Type> > Foam::cyclicAMIPolyPatch::interpolate
 (
-    const Field<Type>& fld
+    const Field<Type>& fld,
+    const UList<Type>& defaultValues
 ) const
 {
     if (owner())
     {
-        return AMI().interpolateToSource(fld);
+        return AMI().interpolateToSource(fld, defaultValues);
     }
     else
     {
-        return neighbPatch().AMI().interpolateToTarget(fld);
+        return neighbPatch().AMI().interpolateToTarget(fld, defaultValues);
     }
 }
 
@@ -45,17 +46,11 @@ Foam::tmp<Foam::Field<Type> > Foam::cyclicAMIPolyPatch::interpolate
 template<class Type>
 Foam::tmp<Foam::Field<Type> > Foam::cyclicAMIPolyPatch::interpolate
 (
-    const tmp<Field<Type> >& tFld
+    const tmp<Field<Type> >& tFld,
+    const UList<Type>& defaultValues
 ) const
 {
-    if (owner())
+    return interpolate(tFld(), defaultValues);
-    {
-        return AMI().interpolateToSource(tFld);
-    }
-    else
-    {
-        return neighbPatch().AMI().interpolateToTarget(tFld);
-    }
 }
 
 
@@ -64,16 +59,29 @@ void Foam::cyclicAMIPolyPatch::interpolate
 (
     const UList<Type>& fld,
     const CombineOp& cop,
-    List<Type>& result
+    List<Type>& result,
+    const UList<Type>& defaultValues
 ) const
 {
     if (owner())
     {
-        AMI().interpolateToSource(fld, cop, result);
+        AMI().interpolateToSource
+        (
+            fld,
+            cop,
+            result,
+            defaultValues
+        );
     }
     else
     {
-        neighbPatch().AMI().interpolateToTarget(fld, cop, result);
+        neighbPatch().AMI().interpolateToTarget
+        (
+            fld,
+            cop,
+            result,
+            defaultValues
+        );
     }
 }
 

src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBase.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -837,6 +837,7 @@ void Foam::mappedPatchBase::calcAMI() const
             surfPtr(),
             faceAreaIntersect::tmMesh,
             AMIPatchToPatchInterpolation::imFaceAreaWeight,
+            -1,
             AMIReverse_
         )
     );

src/meshTools/regionCoupled/patches/regionCoupledPolyPatch/regionCoupledBase.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -92,6 +92,7 @@ void Foam::regionCoupledBase::resetAMI() const
                 surfPtr(),
                 faceAreaIntersect::tmMesh,
                 AMIPatchToPatchInterpolation::imFaceAreaWeight,
+                -1,
                 AMIReverse_
             )
         );

src/postProcessing/functionObjects/forces/forceCoeffs/forceCoeffs.C

@@ -100,7 +100,7 @@ void Foam::forceCoeffs::writeFileHeader(const label i)
 
         for (label j = 0; j < nBin_; j++)
         {
-            const word jn('[' + Foam::name(j) + ']');
+            const word jn('(' + Foam::name(j) + ')');
             writeTabbed(file(i), "Cm" + jn);
             writeTabbed(file(i), "Cd" + jn);
             writeTabbed(file(i), "Cl" + jn);

src/postProcessing/functionObjects/forces/forces/forces.C

@@ -78,8 +78,8 @@ void Foam::forces::writeFileHeader(const label i)
         writeCommented(file(i), "Time");
 
         file(i)
-            << "forces[pressure,viscous,porous] "
+            << "forces(pressure viscous porous) "
-            << "moment[pressure,viscous,porous]";
+            << "moment(pressure viscous porous)";
 
         if (localSystem_)
         {
@@ -126,7 +126,7 @@ void Foam::forces::writeFileHeader(const label i)
 
         for (label j = 0; j < nBin_; j++)
         {
-            const word jn('[' + Foam::name(j) + ']');
+            const word jn('(' + Foam::name(j) + ')');
             const word f("forces" + jn + "[pressure,viscous,porous]");
             const word m("moments" + jn + "[pressure,viscous,porous]");
 
@@ -136,7 +136,7 @@ void Foam::forces::writeFileHeader(const label i)
         {
             for (label j = 0; j < nBin_; j++)
             {
-                const word jn('[' + Foam::name(j) + ']');
+                const word jn('(' + Foam::name(j) + ')');
                 const word f("localForces" + jn + "[pressure,viscous,porous]");
                 const word m("localMoments" + jn + "[pressure,viscous,porous]");
 
@@ -403,13 +403,13 @@ void Foam::forces::writeForces()
         << "        porous   : " << sum(moment_[2])
         << endl;
 
-    file(0) << obr_.time().value() << tab << setw(1) << '['
+    file(0) << obr_.time().value() << tab << setw(1) << '('
-        << sum(force_[0]) << setw(1) << ','
+        << sum(force_[0]) << setw(1) << ' '
-        << sum(force_[1]) << setw(1) << ","
+        << sum(force_[1]) << setw(1) << ' '
-        << sum(force_[2]) << setw(3) << "] ["
+        << sum(force_[2]) << setw(3) << ") ("
-        << sum(moment_[0]) << setw(1) << ","
+        << sum(moment_[0]) << setw(1) << ' '
-        << sum(moment_[1]) << setw(1) << ","
+        << sum(moment_[1]) << setw(1) << ' '
-        << sum(moment_[2]) << setw(1) << "]"
+        << sum(moment_[2]) << setw(1) << ')'
         << endl;
 
     if (localSystem_)
@@ -421,13 +421,13 @@ void Foam::forces::writeForces()
         vectorField localMomentT(coordSys_.localVector(moment_[1]));
         vectorField localMomentP(coordSys_.localVector(moment_[2]));
 
-        file(0) << obr_.time().value() << tab << setw(1) << "["
+        file(0) << obr_.time().value() << tab << setw(1) << '('
-            << sum(localForceN) << setw(1) << ","
+            << sum(localForceN) << setw(1) << ' '
-            << sum(localForceT) << setw(1) << ","
+            << sum(localForceT) << setw(1) << ' '
-            << sum(localForceP) << setw(3) << "] ["
+            << sum(localForceP) << setw(3) << ") ("
-            << sum(localMomentN) << setw(1) << ","
+            << sum(localMomentN) << setw(1) << ' '
-            << sum(localMomentT) << setw(1) << ","
+            << sum(localMomentT) << setw(1) << ' '
-            << sum(localMomentP) << setw(1) << "]"
+            << sum(localMomentP) << setw(1) << ')'
             << endl;
     }
 }
@@ -462,13 +462,13 @@ void Foam::forces::writeBins()
     forAll(f[0], i)
     {
         file(1)
-            << tab << setw(1) << "["
+            << tab << setw(1) << '('
-            << f[0][i] << setw(1) << ","
+            << f[0][i] << setw(1) << ' '
-            << f[1][i] << setw(1) << ","
+            << f[1][i] << setw(1) << ' '
-            << f[2][i] << setw(3) << "] ["
+            << f[2][i] << setw(3) << ") ("
-            << m[0][i] << setw(1) << ","
+            << m[0][i] << setw(1) << ' '
-            << m[1][i] << setw(1) << ","
+            << m[1][i] << setw(1) << ' '
-            << m[2][i] << setw(1) << "]";
+            << m[2][i] << setw(1) << ')';
     }
 
     if (localSystem_)
@@ -498,13 +498,13 @@ void Foam::forces::writeBins()
         forAll(lf[0], i)
         {
             file(1)
-                << tab << setw(1) << "["
+                << tab << setw(1) << '('
-                << lf[0][i] << setw(1) << ","
+                << lf[0][i] << setw(1) << ' '
-                << lf[1][i] << setw(1) << ","
+                << lf[1][i] << setw(1) << ' '
-                << lf[2][i] << setw(3) << "] ["
+                << lf[2][i] << setw(3) << ") ("
-                << lm[0][i] << setw(1) << ","
+                << lm[0][i] << setw(1) << ' '
-                << lm[1][i] << setw(1) << ","
+                << lm[1][i] << setw(1) << ' '
-                << lm[2][i] << setw(1) << "]";
+                << lm[2][i] << setw(1) << ')';
         }
     }
 

src/regionModels/regionModel/regionModel/regionModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -243,6 +243,7 @@ Foam::regionModels::regionModel::interRegionAMI
                     nbrP,
                     faceAreaIntersect::tmMesh,
                     AMIPatchToPatchInterpolation::imFaceAreaWeight,
+                    -1,
                     flip
                 )
             );
@@ -284,6 +285,7 @@ Foam::regionModels::regionModel::interRegionAMI
                 nbrP,
                 faceAreaIntersect::tmMesh,
                 AMIPatchToPatchInterpolation::imFaceAreaWeight,
+                -1,
                 flip
             )
         );

src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.C

@@ -420,6 +420,7 @@ Foam::meshToMesh::patchAMIs() const
                     tgtPP,
                     faceAreaIntersect::tmMesh,
                     interpolationMethodAMI(method_),
+                    -1,
                     true // flip target patch since patch normals are aligned
                 )
             );

src/sampling/meshToMeshInterpolation/meshToMesh/meshToMeshTemplates.C

@@ -354,7 +354,8 @@ void Foam::meshToMesh::mapSrcToTgt
         (
             srcField,
             multiplyWeightedOp<Type, CombineOp>(cop),
-            tgtField
+            tgtField,
+            UList<Type>::null()
         );
     }
 
@@ -385,7 +386,7 @@ Foam::meshToMesh::mapSrcToTgt
         (
             IOobject
             (
-                type() + ".interpolate(" + field.name() + ")",
+                type() + ":interpolate(" + field.name() + ")",
                 tgtMesh.time().timeName(),
                 tgtMesh,
                 IOobject::NO_READ,
@@ -498,7 +499,7 @@ Foam::meshToMesh::mapTgtToSrc
         (
             IOobject
             (
-                type() + ".interpolate(" + field.name() + ")",
+                type() + ":interpolate(" + field.name() + ")",
                 srcMesh.time().timeName(),
                 srcMesh,
                 IOobject::NO_READ,

tutorials/mesh/foamyHexMesh/mixerVessel/0.org/alpha.phase1

@@ -10,7 +10,7 @@ FoamFile
     version     2.0;
     format      ascii;
     class       volScalarField;
-    object      alpha.water;
+    object      alpha.phase1;
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

tutorials/mesh/foamyHexMesh/mixerVessel/Allrun

@@ -8,6 +8,6 @@ cd ${0%/*} || exit 1    # run from this directory
 ./Allrun-pre
 
 ## Run simulation
-#./Allrun-simulation
+./Allrun-simulation
 
 # ----------------------------------------------------------------- end-of-file

tutorials/mesh/foamyHexMesh/mixerVessel/Allrun-pre

@@ -93,17 +93,17 @@ runParallel foamyHexMesh $nProcs
 runParallel collapseEdges $nProcs -collapseFaces -latestTime
 mv log.collapseEdges log.collapseFaces
 
-\cp system/collapseDict.indirectPatchFaces system/collapseDict
+#\cp system/collapseDict.indirectPatchFaces system/collapseDict
-runParallel collapseEdges $nProcs -collapseFaceSet indirectPatchFaces -latestTime
+#runParallel collapseEdges $nProcs -collapseFaceSet indirectPatchFaces -latestTime
-mv log.collapseEdges log.collapseFaceSet
+#mv log.collapseEdges log.collapseFaceSet
 
 runParallel checkMesh $nProcs -allTopology -allGeometry -latestTime
 
 runApplication reconstructParMesh -latestTime
 
 # Copy the mesh into polyMesh and delete the 102 directory
-\cp -r 102/polyMesh constant
+\cp -r 101/polyMesh constant
-\rm -rf 102
+\rm -rf 101
 
 
 # ----------------------------------------------------------------- end-of-file

tutorials/mesh/foamyHexMesh/mixerVessel/Allrun-simulation

@@ -31,7 +31,7 @@ runApplication setFields
 runApplication decomposePar -force
 
 # Run
-runParallel $application 8
+runParallel $application $nProcs
 
 # Reconstruct
 runApplication reconstructPar -noFunctionObjects

tutorials/mesh/foamyHexMesh/mixerVessel/constant/transportProperties

@@ -15,16 +15,16 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-phases (water air);
+phases (phase1 phase2);
 
-water
+phase1
 {
     transportModel  Newtonian;
     nu              nu [ 0 2 -1 0 0 0 0 ] 1e-06;
     rho             rho [ 1 -3 0 0 0 0 0 ] 300;
 }
 
-air
+phase2
 {
     transportModel  Newtonian;
     nu              nu [ 0 2 -1 0 0 0 0 ] 1e-6;

tutorials/mesh/foamyHexMesh/mixerVessel/system/createBafflesDict

@@ -81,6 +81,7 @@ baffles
                 matchTolerance  0.0001;
                 neighbourPatch  AMI2;
                 transform       noOrdering;
+                lowWeightCorrection 0.2;
                 // Note: since imperfect meshing around feature edge make
                 // sure to project both sides onto 'proper' geometry to
                 // avoid errors leading to zero weights
@@ -99,6 +100,7 @@ baffles
                 matchTolerance  0.0001;
                 neighbourPatch  AMI1;
                 transform       noOrdering;
+                lowWeightCorrection 0.2;
                 surface
                 {
                     type        triSurfaceMesh;

tutorials/mesh/foamyHexMesh/mixerVessel/system/fvSolution

@@ -17,7 +17,7 @@ FoamFile
 
 solvers
 {
-    alpha.water
+    alpha.phase1
     {
         nAlphaCorr          1;
         nAlphaSubCycles     2;

tutorials/mesh/foamyHexMesh/mixerVessel/system/setFieldsDict

@@ -17,7 +17,7 @@ FoamFile
 
 defaultFieldValues
 (
-    volScalarFieldValue alpha.water 1
+    volScalarFieldValue alpha.phase1 1
 );
 
 regions
@@ -27,7 +27,7 @@ regions
         box (-4 -4 -1) (4 4 0.74);
         fieldValues
         (
-            volScalarFieldValue alpha.water 0
+            volScalarFieldValue alpha.phase1 0
         );
     }
 );