Merge branch 'master' of /home/noisy3/OpenFOAM/OpenFOAM-dev

src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistribute.H

@@ -319,6 +319,62 @@ public:
                 }
             }
 
+            //- Reverse distribute data using default commsType.
+            //  Since constructSize might be larger than supplied size supply
+            //  a nullValue
+            template<class T>
+            void reverseDistribute
+            (
+                const label constructSize,
+                const T& nullValue,
+                List<T>& fld
+            )
+            const
+            {
+                if (Pstream::defaultCommsType == Pstream::nonBlocking)
+                {
+                    distribute
+                    (
+                        Pstream::nonBlocking,
+                        List<labelPair>(),
+                        constructSize,
+                        constructMap_,
+                        subMap_,
+                        fld,
+                        eqOp<T>(),
+                        nullValue
+                    );
+                }
+                else if (Pstream::defaultCommsType == Pstream::scheduled)
+                {
+                    distribute
+                    (
+                        Pstream::scheduled,
+                        schedule(),
+                        constructSize,
+                        constructMap_,
+                        subMap_,
+                        fld,
+                        eqOp<T>(),
+                        nullValue
+                    );
+                }
+                else
+                {
+                    distribute
+                    (
+                        Pstream::blocking,
+                        List<labelPair>(),
+                        constructSize,
+                        constructMap_,
+                        subMap_,
+                        fld,
+                        eqOp<T>(),
+                        nullValue
+                    );
+                }
+            }
+
             //- Do all sends using PstreamBuffers
             template<class T>
             void send(PstreamBuffers&, const List<T>&) const;

src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistributeTemplates.C

@@ -446,10 +446,11 @@ void Foam::mapDistribute::distribute
         const labelList& map = constructMap[Pstream::myProcNo()];
 
         field.setSize(constructSize);
+        field = nullValue;
 
         forAll(map, i)
         {
-            field[map[i]] = subField[i];
+            cop(field[map[i]], subField[i]);
         }
         return;
     }

src/finiteVolume/fields/fvPatchFields/derived/directMappedFixedValue/directMappedFixedValueFvPatchField.C

@@ -26,6 +26,7 @@ License
 #include "directMappedFixedValueFvPatchField.H"
 #include "directMappedPatchBase.H"
 #include "volFields.H"
+#include "interpolationCell.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -42,8 +43,10 @@ directMappedFixedValueFvPatchField<Type>::directMappedFixedValueFvPatchField
 )
 :
     fixedValueFvPatchField<Type>(p, iF),
+    fieldName_(iF.name()),
     setAverage_(false),
-    average_(pTraits<Type>::zero)
+    average_(pTraits<Type>::zero),
+    interpolationScheme_(interpolationCell<Type>::typeName)
 {}
 
 
@@ -57,8 +60,10 @@ directMappedFixedValueFvPatchField<Type>::directMappedFixedValueFvPatchField
 )
 :
     fixedValueFvPatchField<Type>(ptf, p, iF, mapper),
+    fieldName_(ptf.fieldName_),
     setAverage_(ptf.setAverage_),
-    average_(ptf.average_)
+    average_(ptf.average_),
+    interpolationScheme_(ptf.interpolationScheme_)
 {
     if (!isA<directMappedPatchBase>(this->patch().patch()))
     {
@@ -91,8 +96,10 @@ directMappedFixedValueFvPatchField<Type>::directMappedFixedValueFvPatchField
 )
 :
     fixedValueFvPatchField<Type>(p, iF, dict),
+    fieldName_(dict.lookupOrDefault<word>("fieldName", iF.name())),
     setAverage_(readBool(dict.lookup("setAverage"))),
-    average_(pTraits<Type>(dict.lookup("average")))
+    average_(pTraits<Type>(dict.lookup("average"))),
+    interpolationScheme_(interpolationCell<Type>::typeName)
 {
     if (!isA<directMappedPatchBase>(this->patch().patch()))
     {
@@ -112,6 +119,15 @@ directMappedFixedValueFvPatchField<Type>::directMappedFixedValueFvPatchField
             << " in file " << this->dimensionedInternalField().objectPath()
             << exit(FatalError);
     }
+
+    const directMappedPatchBase& mpp = refCast<const directMappedPatchBase>
+    (
+        directMappedFixedValueFvPatchField<Type>::patch().patch()
+    );
+    if (mpp.mode() == directMappedPatchBase::NEARESTCELL)
+    {
+        dict.lookup("interpolationScheme") >> interpolationScheme_;
+    }
 }
 
 
@@ -122,8 +138,10 @@ directMappedFixedValueFvPatchField<Type>::directMappedFixedValueFvPatchField
 )
 :
     fixedValueFvPatchField<Type>(ptf),
+    fieldName_(ptf.fieldName_),
     setAverage_(ptf.setAverage_),
-    average_(ptf.average_)
+    average_(ptf.average_),
+    interpolationScheme_(ptf.interpolationScheme_)
 {}
 
 
@@ -135,13 +153,67 @@ directMappedFixedValueFvPatchField<Type>::directMappedFixedValueFvPatchField
 )
 :
     fixedValueFvPatchField<Type>(ptf, iF),
+    fieldName_(ptf.fieldName_),
     setAverage_(ptf.setAverage_),
-    average_(ptf.average_)
+    average_(ptf.average_),
+    interpolationScheme_(ptf.interpolationScheme_)
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+template<class Type>
+const GeometricField<Type, fvPatchField, volMesh>&
+directMappedFixedValueFvPatchField<Type>::sampleField() const
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
+
+    const directMappedPatchBase& mpp = refCast<const directMappedPatchBase>
+    (
+        directMappedFixedValueFvPatchField<Type>::patch().patch()
+    );
+    const fvMesh& nbrMesh = refCast<const fvMesh>(mpp.sampleMesh());
+
+    if (mpp.sameRegion())
+    {
+        if (fieldName_ == this->dimensionedInternalField().name())
+        {
+            // Optimisation: bypass field lookup
+            return
+                dynamic_cast<const fieldType&>
+                (
+                    this->dimensionedInternalField()
+                );
+        }
+        else
+        {
+            const fvMesh& thisMesh = this->patch().boundaryMesh().mesh();
+            return thisMesh.lookupObject<fieldType>(fieldName_);
+        }
+    }
+    else
+    {
+        return nbrMesh.lookupObject<fieldType>(fieldName_);
+    }
+}
+
+
+template<class Type>
+const interpolation<Type>&
+directMappedFixedValueFvPatchField<Type>::interpolator() const
+{
+    if (!interpolator_.valid())
+    {
+        interpolator_ = interpolation<Type>::New
+        (
+            interpolationScheme_,
+            sampleField()
+        );
+    }
+    return interpolator_();
+}
+
+
 template<class Type>
 void directMappedFixedValueFvPatchField<Type>::updateCoeffs()
 {
@@ -159,11 +231,8 @@ void directMappedFixedValueFvPatchField<Type>::updateCoeffs()
     );
     const mapDistribute& distMap = mpp.map();
 
-    // Force recalculation of schedule
+    const fvMesh& thisMesh = this->patch().boundaryMesh().mesh();
-    (void)distMap.schedule();
-
     const fvMesh& nbrMesh = refCast<const fvMesh>(mpp.sampleMesh());
-    const word& fldName = this->dimensionedInternalField().name();
 
     // Result of obtaining remote values
     Field<Type> newValues;
@@ -172,17 +241,37 @@ void directMappedFixedValueFvPatchField<Type>::updateCoeffs()
     {
         case directMappedPatchBase::NEARESTCELL:
         {
-            if (mpp.sameRegion())
+            if (interpolationScheme_ != interpolationCell<Type>::typeName)
             {
-                newValues = this->internalField();
+                // Send back sample points to the processor that holds the cell
+                vectorField samples(mpp.samplePoints());
+                distMap.reverseDistribute
+                (
+                    (mpp.sameRegion() ? thisMesh.nCells() : nbrMesh.nCells()),
+                    point::max,
+                    samples
+                );
+
+                const interpolation<Type>& interp = interpolator();
+
+                newValues.setSize(samples.size(), pTraits<Type>::max);
+                forAll(samples, cellI)
+                {
+                    if (samples[cellI] != point::max)
+                    {
+                        newValues[cellI] = interp.interpolate
+                        (
+                            samples[cellI],
+                            cellI
+                        );
+                    }
+                }
             }
             else
             {
-                newValues = nbrMesh.lookupObject<fieldType>
+                newValues = sampleField();
-                (
-                    fldName
-                ).internalField();
             }
+
             mapDistribute::distribute
             (
                 Pstream::defaultCommsType,
@@ -213,10 +302,8 @@ void directMappedFixedValueFvPatchField<Type>::updateCoeffs()
                  << abort(FatalError);
             }
 
-            const fieldType& nbrField = nbrMesh.lookupObject<fieldType>
+            const fieldType& nbrField = sampleField();
-            (
+
-                fldName
-            );
             newValues = nbrField.boundaryField()[nbrPatchID];
             mapDistribute::distribute
             (
@@ -234,10 +321,8 @@ void directMappedFixedValueFvPatchField<Type>::updateCoeffs()
         {
             Field<Type> allValues(nbrMesh.nFaces(), pTraits<Type>::zero);
 
-            const fieldType& nbrField = nbrMesh.lookupObject<fieldType>
+            const fieldType& nbrField = sampleField();
-            (
+
-                fldName
-            );
             forAll(nbrField.boundaryField(), patchI)
             {
                 const fvPatchField<Type>& pf =
@@ -294,7 +379,8 @@ void directMappedFixedValueFvPatchField<Type>::updateCoeffs()
 
     if (debug)
     {
-        Info<< "directMapped on field:" << fldName
+        Info<< "directMapped on field:"
+            << this->dimensionedInternalField().name()
             << " patch:" << this->patch().name()
             << "  avg:" << gAverage(*this)
             << "  min:" << gMin(*this)
@@ -310,8 +396,11 @@ template<class Type>
 void directMappedFixedValueFvPatchField<Type>::write(Ostream& os) const
 {
     fvPatchField<Type>::write(os);
+    os.writeKeyword("fieldName") << fieldName_ << token::END_STATEMENT << nl;
     os.writeKeyword("setAverage") << setAverage_ << token::END_STATEMENT << nl;
     os.writeKeyword("average") << average_ << token::END_STATEMENT << nl;
+    os.writeKeyword("interpolationScheme") << interpolationScheme_
+        << token::END_STATEMENT << nl;
     this->writeEntry("value", os);
 }
 

src/finiteVolume/fields/fvPatchFields/derived/directMappedFixedValue/directMappedFixedValueFvPatchField.H

@@ -33,6 +33,17 @@ Description
     mode = NEARESTFACE : sample nearest face on any patch. Note: does not
                          warn if nearest actually is on internal face!
 
+    For NEARESTCELL you have to provide an 'interpolationScheme' entry
+    which can be any one of the interpolation schemes (cell, cellPoint, etc.)
+    In case of interpolation (so scheme != cell) the limitation is that
+    there is only one value per cell. So e.g. if you have a cell with two
+    boundary faces and both faces sample into the cell both faces will get
+    the same value.
+
+    See directMappedPatchBase for options on sampling.
+
+    Optional 'fieldName' entry to supply a different filename
+
 SourceFiles
     directMappedFixedValueFvPatchField.C
 
@@ -43,6 +54,7 @@ SourceFiles
 
 #include "fixedValueFvPatchFields.H"
 #include "directMappedFvPatch.H"
+#include "interpolation.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -60,12 +72,29 @@ class directMappedFixedValueFvPatchField
 {
     // Private data
 
+        //- Name of field to sample - defaults to field associated with this
+        //  patchField if not specified
+        word fieldName_;
+
         //- If true adjust the mapped field to maintain average value average_
-        bool setAverage_;
+        const bool setAverage_;
 
         //- Average value the mapped field is adjusted to maintain if
         //  setAverage_ is set true
-        Type average_;
+        const Type average_;
+
+        //- Interpolation scheme to use for nearestcell mode
+        word interpolationScheme_;
+
+        mutable autoPtr<interpolation<Type> > interpolator_;
+
+    // Private Member Functions
+
+        //- Field to sample. Either on my or nbr mesh
+        const GeometricField<Type, fvPatchField, volMesh>& sampleField() const;
+
+        //- Access the interpolation method
+        const interpolation<Type>& interpolator() const;
 
 public:
 

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

@@ -112,6 +112,29 @@ directMappedVelocityFluxFixedValueFvPatchField
             << " in file " << dimensionedInternalField().objectPath()
             << exit(FatalError);
     }
+
+    const directMappedPatchBase& mpp = refCast<const directMappedPatchBase>
+    (
+        this->patch().patch()
+    );
+    if (mpp.mode() == directMappedPolyPatch::NEARESTCELL)
+    {
+        FatalErrorIn
+        (
+            "directMappedVelocityFluxFixedValueFvPatchField::"
+            "directMappedVelocityFluxFixedValueFvPatchField"
+            "("
+                "const fvPatch&, "
+                "const DimensionedField<vector, volMesh>&, "
+                "const dictionary&"
+            ")"
+        )   << "Patch " << p.name()
+            << " of type '" << p.type()
+            << "' can not be used in 'nearestCell' mode"
+            << " of field " << dimensionedInternalField().name()
+            << " in file " << dimensionedInternalField().objectPath()
+            << exit(FatalError);
+    }
 }
 
 

src/meshTools/directMapped/directMappedPolyPatch/directMappedPatchBase.C

@@ -54,6 +54,18 @@ namespace Foam
         directMappedPatchBase::sampleModeNames_;
 
 
+    template<>
+    const char* NamedEnum<directMappedPatchBase::offsetMode, 3>::names[] =
+    {
+        "uniform",
+        "nonuniform",
+        "normal"
+    };
+
+    const NamedEnum<directMappedPatchBase::offsetMode, 3>
+        directMappedPatchBase::offsetModeNames_;
+
+
     //- Private class for finding nearest
     //  - point+local index
     //  - sqr(distance)
@@ -100,7 +112,7 @@ void Foam::directMappedPatchBase::collectSamples
     labelListList globalFaces(Pstream::nProcs());
 
     globalFc[Pstream::myProcNo()] = patch_.faceCentres();
-    globalSamples[Pstream::myProcNo()] = globalFc[Pstream::myProcNo()]+offsets_;
+    globalSamples[Pstream::myProcNo()] = samplePoints();
     globalFaces[Pstream::myProcNo()] = identity(patch_.size());
 
     // Distribute to all processors
@@ -393,19 +405,34 @@ void Foam::directMappedPatchBase::calcMapping() const
             << "Mapping already calculated" << exit(FatalError);
     }
 
-    if
+    // Do a sanity check
+    // Am I sampling my own patch? This only makes sense for a non-zero
+    // offset.
+    bool sampleMyself =
     (
-        gAverage(mag(offsets_)) <= ROOTVSMALL
+        mode_ == NEARESTPATCHFACE
-     && mode_ == NEARESTPATCHFACE
      && sampleRegion_ == patch_.boundaryMesh().mesh().name()
      && samplePatch_ == patch_.name()
-    )
+    );
+
+    // Check offset
+    vectorField d(samplePoints()-patch_.faceCentres());
+    if (sampleMyself && gAverage(mag(d)) <= ROOTVSMALL)
     {
-        WarningIn("directMappedPatchBase::calcMapping() const")
+        WarningIn
-            << "Invalid offset " << offsets_ << endl
+        (
+            "directMappedPatchBase::directMappedPatchBase\n"
+            "(\n"
+            "    const polyPatch& pp,\n"
+            "    const word& sampleRegion,\n"
+            "    const sampleMode mode,\n"
+            "    const word& samplePatch,\n"
+            "    const vector& offset\n"
+            ")\n"
+        )   << "Invalid offset " << d << endl
             << "Offset is the vector added to the patch face centres to"
             << " find the patch face supplying the data." << endl
-            << "Setting it to " << offsets_
+            << "Setting it to " << d
             << " on the same patch, on the same region"
             << " will find the faces themselves which does not make sense"
             << " for anything but testing." << endl
@@ -413,10 +440,11 @@ void Foam::directMappedPatchBase::calcMapping() const
             << "sampleRegion_:" << sampleRegion_ << endl
             << "mode_:" << sampleModeNames_[mode_] << endl
             << "samplePatch_:" << samplePatch_ << endl
-            << "offsets_:" << offsets_ << endl;
+            << "offsetMode_:" << offsetModeNames_[offsetMode_] << endl;
     }
 
 
+
     // Get global list of all samples and the processor and face they come from.
     pointField samples;
     labelList patchFaceProcs;
@@ -477,40 +505,6 @@ void Foam::directMappedPatchBase::calcMapping() const
     }
 
 
-    //// Check that actual offset vector (sampleLocations - patchFc) is more or
-    //// less constant.
-    //if (Pstream::master())
-    //{
-    //    const scalarField magOffset(mag(sampleLocations - patchFc));
-    //    const scalar avgOffset(average(magOffset));
-    //
-    //    forAll(magOffset, sampleI)
-    //    {
-    //        if
-    //        (
-    //            mag(magOffset[sampleI]-avgOffset)
-    //          > max(SMALL, 0.001*avgOffset)
-    //        )
-    //        {
-    //            WarningIn("directMappedPatchBase::calcMapping() const")
-    //                << "The actual cell/face centres picked up using offset "
-    //                << offsets_ << " are not" << endl
-    //                << "    on a single plane."
-    //                << " This might give numerical problems." << endl
-    //                << "    At patchface " << patchFc[sampleI]
-    //                << " the sampled cell/face " << sampleLocations[sampleI]
-    //                << endl
-    //                << "    is not on a plane " << avgOffset
-    //                << " offset from the patch." << endl
-    //                << "    You might want to shift your plane offset."
-    //                << " Set the debug flag to get a dump of sampled cells."
-    //                << endl;
-    //            break;
-    //        }
-    //    }
-    //}
-
-
     // Determine schedule.
     mapPtr_.reset(new mapDistribute(sampleProcs, patchFaceProcs));
 
@@ -597,9 +591,10 @@ Foam::directMappedPatchBase::directMappedPatchBase
     sampleRegion_(patch_.boundaryMesh().mesh().name()),
     mode_(NEARESTPATCHFACE),
     samplePatch_("none"),
-    uniformOffset_(true),
+    offsetMode_(UNIFORM),
     offset_(vector::zero),
     offsets_(pp.size(), offset_),
+    distance_(0),
     sameRegion_(sampleRegion_ == patch_.boundaryMesh().mesh().name()),
     mapPtr_(NULL)
 {}
@@ -618,8 +613,10 @@ Foam::directMappedPatchBase::directMappedPatchBase
     sampleRegion_(sampleRegion),
     mode_(mode),
     samplePatch_(samplePatch),
-    uniformOffset_(false),
+    offsetMode_(NONUNIFORM),
+    offset_(vector::zero),
     offsets_(offsets),
+    distance_(0),
     sameRegion_(sampleRegion_ == patch_.boundaryMesh().mesh().name()),
     mapPtr_(NULL)
 {}
@@ -638,9 +635,10 @@ Foam::directMappedPatchBase::directMappedPatchBase
     sampleRegion_(sampleRegion),
     mode_(mode),
     samplePatch_(samplePatch),
-    uniformOffset_(true),
+    offsetMode_(UNIFORM),
     offset_(offset),
-    offsets_(pp.size(), offset_),
+    offsets_(0),
+    distance_(0),
     sameRegion_(sampleRegion_ == patch_.boundaryMesh().mesh().name()),
     mapPtr_(NULL)
 {}
@@ -663,22 +661,62 @@ Foam::directMappedPatchBase::directMappedPatchBase
     ),
     mode_(sampleModeNames_.read(dict.lookup("sampleMode"))),
     samplePatch_(dict.lookup("samplePatch")),
-    uniformOffset_(dict.found("offset")),
+    offsetMode_(UNIFORM),
-    offset_
+    offset_(vector::zero),
-    (
+    offsets_(0),
-        uniformOffset_
+    distance_(0.0),
-      ? point(dict.lookup("offset"))
-      : vector::zero
-    ),
-    offsets_
-    (
-        uniformOffset_
-      ? pointField(pp.size(), offset_)
-      : dict.lookup("offsets")
-    ),
     sameRegion_(sampleRegion_ == patch_.boundaryMesh().mesh().name()),
     mapPtr_(NULL)
-{}
+{
+    if (dict.found("offsetMode"))
+    {
+        offsetMode_ = offsetModeNames_.read(dict.lookup("offsetMode"));
+
+        switch(offsetMode_)
+        {
+            case UNIFORM:
+            {
+                offset_ = point(dict.lookup("offset"));
+            }
+            break;
+
+            case NONUNIFORM:
+            {
+                offsets_ = pointField(dict.lookup("offsets"));
+            }
+            break;
+
+            case NORMAL:
+            {
+                distance_ = readScalar(dict.lookup("distance"));
+            }
+            break;
+        }
+    }
+    else if (dict.found("offset"))
+    {
+        offsetMode_ = UNIFORM;
+        offset_ = point(dict.lookup("offset"));
+    }
+    else if (dict.found("offsets"))
+    {
+        offsetMode_ = NONUNIFORM;
+        offsets_ = pointField(dict.lookup("offsets"));
+    }
+    else
+    {
+        FatalErrorIn
+        (
+            "directMappedPatchBase::directMappedPatchBase\n"
+            "(\n"
+            "    const polyPatch& pp,\n"
+            "    const dictionary& dict\n"
+            ")\n"
+        )   << "Please supply the offsetMode as one of "
+            << NamedEnum<offsetMode, 3>::words()
+            << exit(FatalError);
+    }
+}
 
 
 Foam::directMappedPatchBase::directMappedPatchBase
@@ -691,9 +729,10 @@ Foam::directMappedPatchBase::directMappedPatchBase
     sampleRegion_(dmp.sampleRegion_),
     mode_(dmp.mode_),
     samplePatch_(dmp.samplePatch_),
-    uniformOffset_(dmp.uniformOffset_),
+    offsetMode_(dmp.offsetMode_),
     offset_(dmp.offset_),
     offsets_(dmp.offsets_),
+    distance_(dmp.distance_),
     sameRegion_(dmp.sameRegion_),
     mapPtr_(NULL)
 {}
@@ -710,9 +749,10 @@ Foam::directMappedPatchBase::directMappedPatchBase
     sampleRegion_(dmp.sampleRegion_),
     mode_(dmp.mode_),
     samplePatch_(dmp.samplePatch_),
-    uniformOffset_(dmp.uniformOffset_),
+    offsetMode_(dmp.offsetMode_),
     offset_(dmp.offset_),
     offsets_(dmp.offsets_, mapAddressing),
+    distance_(dmp.distance_),
     sameRegion_(dmp.sameRegion_),
     mapPtr_(NULL)
 {}
@@ -762,6 +802,40 @@ const Foam::polyPatch& Foam::directMappedPatchBase::samplePolyPatch() const
 }
 
 
+Foam::tmp<Foam::pointField> Foam::directMappedPatchBase::samplePoints() const
+{
+    tmp<pointField> tfld(new pointField(patch_.faceCentres()));
+    pointField& fld = tfld();
+
+    switch(offsetMode_)
+    {
+        case UNIFORM:
+        {
+            fld += offset_;
+        }
+        break;
+
+        case NONUNIFORM:
+        {
+            fld += offsets_;
+        }
+        break;
+
+        case NORMAL:
+        {
+            // Get outwards pointing normal
+            vectorField n(patch_.faceAreas());
+            n /= mag(n);
+
+            fld += distance_*n;
+        }
+        break;
+    }
+
+    return tfld;
+}
+
+
 void Foam::directMappedPatchBase::write(Ostream& os) const
 {
     os.writeKeyword("sampleMode") << sampleModeNames_[mode_]
@@ -770,13 +844,31 @@ void Foam::directMappedPatchBase::write(Ostream& os) const
         << token::END_STATEMENT << nl;
     os.writeKeyword("samplePatch") << samplePatch_
         << token::END_STATEMENT << nl;
-    if (uniformOffset_)
+
+    os.writeKeyword("offsetMode") << offsetModeNames_[offsetMode_]
+        << token::END_STATEMENT << nl;
+
+    switch(offsetMode_)
+    {
+        case UNIFORM:
         {
             os.writeKeyword("offset") << offset_ << token::END_STATEMENT << nl;
         }
-    else
+        break;
+
+        case NONUNIFORM:
         {
-        os.writeKeyword("offsets") << offsets_ << token::END_STATEMENT << nl;
+            os.writeKeyword("offsets") << offsets_ << token::END_STATEMENT
+                << nl;
+        }
+        break;
+
+        case NORMAL:
+        {
+            os.writeKeyword("distance") << distance_ << token::END_STATEMENT
+                << nl;
+        }
+        break;
     }
 }
 

src/meshTools/directMapped/directMappedPolyPatch/directMappedPatchBase.H

@@ -28,6 +28,33 @@ Description
     Determines a mapping between patch face centres and mesh cell or face
     centres and processors they're on.
 
+    If constructed from dictionary:
+        // Region to sample (default is region0)
+        sampleRegion region0;
+
+        // What to sample:
+        // - nearestCell : sample nearest cell
+        // - nearestPatchFace : nearest face on selected patch
+        // - nearestFace : nearest boundary face on any patch
+        sampleMode nearestCell;
+
+        // If sampleMod is nearestPatchFace : patch to find faces of
+        samplePatch movingWall;
+
+        // How to supply offset (w.r.t. my patch face centres):
+        // - uniform : single offset vector
+        // - nonuniform : per-face offset vector
+        // - normal : using supplied distance and face normal
+        offsetMode uniform;
+
+        // According to offsetMode (see above) supply one of
+        // offset, offsets or distance
+        offset  (1 0 0);
+
+    Note: if offsetMode is 'normal' it uses outwards pointing normals. So
+    supply a negative distance if sampling inside the domain.
+
+
 Note
     Storage is not optimal. It temporary collects all (patch)face centres
     on all processors to keep the addressing calculation simple.
@@ -71,12 +98,22 @@ public:
             NEARESTFACE         // nearest face
         };
 
+        //- How to project face centres
+        enum offsetMode
+        {
+            UNIFORM,            // single offset vector
+            NONUNIFORM,         // per-face offset vector
+            NORMAL              // use face normal + distance
+        };
+
 private:
 
     // Private data
 
         static const NamedEnum<sampleMode, 3> sampleModeNames_;
 
+        static const NamedEnum<offsetMode, 3> offsetModeNames_;
+
         //- Patch to sample
         const polyPatch& patch_;
 
@@ -89,14 +126,17 @@ private:
         //- Patch (only if NEARESTPATCHFACE)
         const word samplePatch_;
 
-        //- For backwards compatibility : reading/writing of uniform offset.
+        //- How to obtain samples
-        const bool uniformOffset_;
+        offsetMode offsetMode_;
 
         //- Offset vector (uniform)
-        const vector offset_;
+        vector offset_;
 
-        //- Offset vector
+        //- Offset vector (nonuniform)
-        const vectorField offsets_;
+        vectorField offsets_;
+
+        //- Offset distance (normal)
+        scalar distance_;
 
         //- Same region
         const bool sameRegion_;
@@ -146,17 +186,17 @@ public:
         //- Construct from patch
         directMappedPatchBase(const polyPatch&);
 
-        //- Construct from components
+        //- Construct with offsetMode=non-uniform
         directMappedPatchBase
         (
             const polyPatch& pp,
             const word& sampleRegion,
             const sampleMode sampleMode,
             const word& samplePatch,
-            const vectorField& offset
+            const vectorField& offsets
         );
 
-        //- Construct from components
+        //- Construct from offsetMode=uniform
         directMappedPatchBase
         (
             const polyPatch& pp,
@@ -166,6 +206,16 @@ public:
             const vector& offset
         );
 
+        ////- Construct from normal and distance
+        //directMappedPatchBase
+        //(
+        //    const polyPatch& pp,
+        //    const word& sampleRegion,
+        //    const word& samplePatch,
+        //    const sampleMode sampleMode,
+        //    const vector& offset
+        //);
+
         //- Construct from dictionary
         directMappedPatchBase(const polyPatch&, const dictionary&);
 
@@ -241,6 +291,9 @@ public:
         //- Get the patch on the region
         const polyPatch& samplePolyPatch() const;
 
+        //- Get the sample points
+        tmp<pointField> samplePoints() const;
+
         //- Write as a dictionary
         virtual void write(Ostream&) const;
 };

src/sampling/sampledSurface/distanceSurface/distanceSurface.C

@@ -50,6 +50,9 @@ void Foam::distanceSurface::createGeometry()
     // Clear any stored topologies
     facesPtr_.clear();
 
+    // Clear derived data
+    clearGeom();
+
     const fvMesh& fvm = static_cast<const fvMesh&>(mesh());
 
     // Distance to cell centres
@@ -361,6 +364,9 @@ bool Foam::distanceSurface::expire()
     // Clear any stored topologies
     facesPtr_.clear();
 
+    // Clear derived data
+    clearGeom();
+
     // already marked as expired
     if (needsUpdate_)
     {

src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C

@@ -333,6 +333,9 @@ bool Foam::sampledIsoSurface::updateGeometry() const
     surfPtr_.clear();
     facesPtr_.clear();
 
+    // Clear derived data
+    clearGeom();
+
     if (subMeshPtr_.valid())
     {
         surfPtr_.reset
@@ -471,6 +474,9 @@ bool Foam::sampledIsoSurface::expire()
     facesPtr_.clear();
     subMeshPtr_.clear();
 
+    // Clear derived data
+    clearGeom();
+
     // already marked as expired
     if (prevTimeIndex_ == -1)
     {

src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceCell.C

@@ -62,6 +62,9 @@ bool Foam::sampledIsoSurfaceCell::updateGeometry() const
     // Clear any stored topo
     facesPtr_.clear();
 
+    // Clear derived data
+    sampledSurface::clearGeom();
+
     // Optionally read volScalarField
     autoPtr<volScalarField> readFieldPtr_;
 
@@ -240,6 +243,9 @@ bool Foam::sampledIsoSurfaceCell::expire()
 {
     facesPtr_.clear();
 
+    // Clear derived data
+    sampledSurface::clearGeom();
+
     // already marked as expired
     if (prevTimeIndex_ == -1)
     {

src/sampling/sampledSurface/sampledCuttingPlane/sampledCuttingPlane.C

@@ -60,6 +60,8 @@ void Foam::sampledCuttingPlane::createGeometry()
     pointDistance_.clear();
     cellDistancePtr_.clear();
 
+    // Clear derived data
+    clearGeom();
 
     // Get any subMesh
     if (zoneID_.index() != -1 && !subMeshPtr_.valid())
@@ -321,6 +323,9 @@ bool Foam::sampledCuttingPlane::expire()
     // Clear any stored topologies
     facesPtr_.clear();
 
+    // Clear derived data
+    clearGeom();
+
     // already marked as expired
     if (needsUpdate_)
     {

src/sampling/sampledSurface/thresholdCellFaces/sampledThresholdCellFaces.C

@@ -124,6 +124,8 @@ bool Foam::sampledThresholdCellFaces::updateGeometry() const
     ).MeshedSurface<face>::transfer(surf);
     meshCells_.transfer(surf.meshCells());
 
+    // clear derived data
+    sampledSurface::clearGeom();
 
     if (debug)
     {

src/surfaceFilmModels/Make/files

@@ -26,7 +26,6 @@ submodels/thermo/heatTransferModel/mappedConvectiveHeatTransfer/mappedConvective
 
 /* Boundary conditions */
 derivedFvPatchFields/directMappedFixedInternalValue/directMappedFixedInternalValueFvPatchFields.C
-derivedFvPatchFields/directMappedNamedFixedValue/directMappedNamedFixedValueFvPatchFields.C
 derivedFvPatchFields/directMappedFixedPushedInternalValue/directMappedFixedPushedInternalValueFvPatchFields.C
 derivedFvPatchFields/filmHeightInletVelocity/filmHeightInletVelocityFvPatchVectorField.C
 derivedFvPatchFields/htcConv/htcConvFvPatchScalarField.C

src/surfaceFilmModels/derivedFvPatchFields/directMappedNamedFixedValue/directMappedNamedFixedValueFvPatchField.C

@@ -1,334 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  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 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "directMappedNamedFixedValueFvPatchField.H"
-#include "directMappedPatchBase.H"
-#include "volFields.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-template<class Type>
-directMappedNamedFixedValueFvPatchField<Type>::
-directMappedNamedFixedValueFvPatchField
-(
-    const fvPatch& p,
-    const DimensionedField<Type, volMesh>& iF
-)
-:
-    fixedValueFvPatchField<Type>(p, iF),
-    fieldName_(iF.name()),
-    setAverage_(false),
-    average_(pTraits<Type>::zero)
-{}
-
-
-template<class Type>
-directMappedNamedFixedValueFvPatchField<Type>::
-directMappedNamedFixedValueFvPatchField
-(
-    const directMappedNamedFixedValueFvPatchField<Type>& ptf,
-    const fvPatch& p,
-    const DimensionedField<Type, volMesh>& iF,
-    const fvPatchFieldMapper& mapper
-)
-:
-    fixedValueFvPatchField<Type>(ptf, p, iF, mapper),
-    fieldName_(ptf.fieldName_),
-    setAverage_(ptf.setAverage_),
-    average_(ptf.average_)
-{
-    if (!isA<directMappedPatchBase>(this->patch().patch()))
-    {
-        FatalErrorIn
-        (
-            "directMappedNamedFixedValueFvPatchField<Type>::"
-            "directMappedNamedFixedValueFvPatchField\n"
-            "("
-                "const directMappedNamedFixedValueFvPatchField<Type>&, "
-                "const fvPatch&, "
-                "const Field<Type>&, "
-                "const fvPatchFieldMapper& "
-            ")"
-        )   << "    patch type '" << p.type()
-            << "' not type '" << directMappedPatchBase::typeName << "'"
-            << "\n    for patch " << p.name()
-            << " of field " << this->dimensionedInternalField().name()
-            << " in file " << this->dimensionedInternalField().objectPath()
-            << exit(FatalError);
-    }
-}
-
-
-template<class Type>
-directMappedNamedFixedValueFvPatchField<Type>::
-directMappedNamedFixedValueFvPatchField
-(
-    const fvPatch& p,
-    const DimensionedField<Type, volMesh>& iF,
-    const dictionary& dict
-)
-:
-    fixedValueFvPatchField<Type>(p, iF, dict),
-    fieldName_(dict.lookupOrDefault<word>("fieldName", iF.name())),
-    setAverage_(readBool(dict.lookup("setAverage"))),
-    average_(pTraits<Type>(dict.lookup("average")))
-{
-    if (!isA<directMappedPatchBase>(this->patch().patch()))
-    {
-        FatalErrorIn
-        (
-            "directMappedNamedFixedValueFvPatchField<Type>::"
-            "directMappedNamedFixedValueFvPatchField"
-            "("
-                "const fvPatch&, "
-                "const DimensionedField<Type, volMesh>& iF, "
-                "const dictionary&"
-            ")"
-        )   << "    patch type '" << p.type()
-            << "' not type '" << directMappedPatchBase::typeName << "'"
-            << "\n    for patch " << p.name()
-            << " of field " << fieldName_
-            << " in file " << this->dimensionedInternalField().objectPath()
-            << exit(FatalError);
-    }
-
-    //// Force calculation of schedule (uses parallel comms)
-    //const directMappedPatchBase& mpp = refCast<const directMappedPatchBase>
-    //(
-    //    this->patch().patch()
-    //);
-    //(void)mpp.map().schedule();
-}
-
-
-template<class Type>
-directMappedNamedFixedValueFvPatchField<Type>::
-directMappedNamedFixedValueFvPatchField
-(
-    const directMappedNamedFixedValueFvPatchField<Type>& ptf
-)
-:
-    fixedValueFvPatchField<Type>(ptf),
-    fieldName_(ptf.fieldName_),
-    setAverage_(ptf.setAverage_),
-    average_(ptf.average_)
-{}
-
-
-template<class Type>
-directMappedNamedFixedValueFvPatchField<Type>::
-directMappedNamedFixedValueFvPatchField
-(
-    const directMappedNamedFixedValueFvPatchField<Type>& ptf,
-    const DimensionedField<Type, volMesh>& iF
-)
-:
-    fixedValueFvPatchField<Type>(ptf, iF),
-    fieldName_(ptf.fieldName_),
-    setAverage_(ptf.setAverage_),
-    average_(ptf.average_)
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class Type>
-void directMappedNamedFixedValueFvPatchField<Type>::updateCoeffs()
-{
-    if (this->updated())
-    {
-        return;
-    }
-
-    typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
-
-    // Get the scheduling information from the directMappedPatchBase
-    const directMappedPatchBase& mpp = refCast<const directMappedPatchBase>
-    (
-        directMappedNamedFixedValueFvPatchField<Type>::patch().patch()
-    );
-    const mapDistribute& distMap = mpp.map();
-
-    // Force recalculation of schedule
-    (void)distMap.schedule();
-
-    const fvMesh& nbrMesh = refCast<const fvMesh>(mpp.sampleMesh());
-
-    // Result of obtaining remote values
-    Field<Type> newValues;
-
-    switch (mpp.mode())
-    {
-        case directMappedPatchBase::NEARESTCELL:
-        {
-            if (mpp.sameRegion())
-            {
-                newValues = this->internalField();
-            }
-            else
-            {
-                newValues = nbrMesh.lookupObject<fieldType>
-                (
-                    fieldName_
-                ).internalField();
-            }
-            mapDistribute::distribute
-            (
-                Pstream::defaultCommsType,
-                distMap.schedule(),
-                distMap.constructSize(),
-                distMap.subMap(),
-                distMap.constructMap(),
-                newValues
-            );
-
-            break;
-        }
-        case directMappedPatchBase::NEARESTPATCHFACE:
-        {
-            const label nbrPatchID =
-                nbrMesh.boundaryMesh().findPatchID(mpp.samplePatch());
-            if (nbrPatchID < 0)
-            {
-                FatalErrorIn
-                (
-                    "void directMappedNamedFixedValueFvPatchField<Type>::"
-                    "updateCoeffs()"
-                )<< "Unable to find sample patch " << mpp.samplePatch()
-                 << " in region " << mpp.sampleRegion()
-                 << " for patch " << this->patch().name() << nl
-                 << abort(FatalError);
-            }
-
-            const fieldType& nbrField =
-                nbrMesh.lookupObject<fieldType>(fieldName_);
-            newValues = nbrField.boundaryField()[nbrPatchID];
-            mapDistribute::distribute
-            (
-                Pstream::defaultCommsType,
-                distMap.schedule(),
-                distMap.constructSize(),
-                distMap.subMap(),
-                distMap.constructMap(),
-                newValues
-            );
-
-            break;
-        }
-        case directMappedPatchBase::NEARESTFACE:
-        {
-            Field<Type> allValues(nbrMesh.nFaces(), pTraits<Type>::zero);
-
-            const fieldType& nbrField =
-                nbrMesh.lookupObject<fieldType>(fieldName_);
-            forAll(nbrField.boundaryField(), patchI)
-            {
-                const fvPatchField<Type>& pf =
-                    nbrField.boundaryField()[patchI];
-                label faceStart = pf.patch().patch().start();
-
-                forAll(pf, faceI)
-                {
-                    allValues[faceStart++] = pf[faceI];
-                }
-            }
-
-            mapDistribute::distribute
-            (
-                Pstream::defaultCommsType,
-                distMap.schedule(),
-                distMap.constructSize(),
-                distMap.subMap(),
-                distMap.constructMap(),
-                allValues
-            );
-
-            newValues = this->patch().patchSlice(allValues);
-
-            break;
-        }
-        default:
-        {
-            FatalErrorIn
-            (
-                "directMappedNamedFixedValueFvPatchField<Type>::updateCoeffs()"
-            )<< "Unknown sampling mode: " << mpp.mode()
-             << nl << abort(FatalError);
-        }
-    }
-
-    if (setAverage_)
-    {
-        Type averagePsi =
-            gSum(this->patch().magSf()*newValues)
-           /gSum(this->patch().magSf());
-
-        if (mag(averagePsi)/mag(average_) > 0.5)
-        {
-            newValues *= mag(average_)/mag(averagePsi);
-        }
-        else
-        {
-            newValues += (average_ - averagePsi);
-        }
-    }
-
-    this->operator==(newValues);
-
-    if (debug)
-    {
-        Info<< "directMapped on field:" << fieldName_
-            << " patch:" << this->patch().name()
-            << "  avg:" << gAverage(*this)
-            << "  min:" << gMin(*this)
-            << "  max:" << gMax(*this)
-            << endl;
-    }
-
-    fixedValueFvPatchField<Type>::updateCoeffs();
-}
-
-
-template<class Type>
-void directMappedNamedFixedValueFvPatchField<Type>::write(Ostream& os) const
-{
-    fvPatchField<Type>::write(os);
-    os.writeKeyword("fieldName") << fieldName_ << token::END_STATEMENT << nl;
-    os.writeKeyword("setAverage") << setAverage_ << token::END_STATEMENT << nl;
-    os.writeKeyword("average") << average_ << token::END_STATEMENT << nl;
-    this->writeEntry("value", os);
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// ************************************************************************* //

src/surfaceFilmModels/derivedFvPatchFields/directMappedNamedFixedValue/directMappedNamedFixedValueFvPatchField.H

@@ -1,164 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  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 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::directMappedNamedFixedValueFvPatchField
-
-Description
-    Variant of directMappedFixedValueFvPatch where the name of the field to
-    map is input.
-
-SourceFiles
-    directMappedNamedFixedValueFvPatchField.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef directMappedNamedFixedValueFvPatchField_H
-#define directMappedNamedFixedValueFvPatchField_H
-
-#include "fixedValueFvPatchField.H"
-#include "directMappedFvPatch.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-          Class directMappedNamesFixedValueFvPatchField Declaration
-\*---------------------------------------------------------------------------*/
-
-template<class Type>
-class directMappedNamedFixedValueFvPatchField
-:
-    public fixedValueFvPatchField<Type>
-{
-    // Private data
-
-        //- Name of field to sample - defaults to field associated with this
-        //  patch if not specified
-        word fieldName_;
-
-        //- If true adjust the mapped field to maintain average value average_
-        bool setAverage_;
-
-        //- Average value the mapped field is adjusted to maintain if
-        //  setAverage_ is set true
-        Type average_;
-
-
-public:
-
-    //- Runtime type information
-    TypeName("directMappedNamedFixedValue");
-
-
-    // Constructors
-
-        //- Construct from patch and internal field
-        directMappedNamedFixedValueFvPatchField
-        (
-            const fvPatch&,
-            const DimensionedField<Type, volMesh>&
-        );
-
-        //- Construct from patch, internal field and dictionary
-        directMappedNamedFixedValueFvPatchField
-        (
-            const fvPatch&,
-            const DimensionedField<Type, volMesh>&,
-            const dictionary&
-        );
-
-        //- Construct by mapping given directMappedNamedFixedValueFvPatchField
-        //  onto a new patch
-        directMappedNamedFixedValueFvPatchField
-        (
-            const directMappedNamedFixedValueFvPatchField<Type>&,
-            const fvPatch&,
-            const DimensionedField<Type, volMesh>&,
-            const fvPatchFieldMapper&
-        );
-
-        //- Construct as copy
-        directMappedNamedFixedValueFvPatchField
-        (
-            const directMappedNamedFixedValueFvPatchField<Type>&
-        );
-
-        //- Construct and return a clone
-        virtual tmp<fvPatchField<Type> > clone() const
-        {
-            return tmp<fvPatchField<Type> >
-            (
-                new directMappedNamedFixedValueFvPatchField<Type>(*this)
-            );
-        }
-
-        //- Construct as copy setting internal field reference
-        directMappedNamedFixedValueFvPatchField
-        (
-            const directMappedNamedFixedValueFvPatchField<Type>&,
-            const DimensionedField<Type, volMesh>&
-        );
-
-        //- Construct and return a clone setting internal field reference
-        virtual tmp<fvPatchField<Type> > clone
-        (
-            const DimensionedField<Type, volMesh>& iF
-        ) const
-        {
-            return tmp<fvPatchField<Type> >
-            (
-                new directMappedNamedFixedValueFvPatchField<Type>(*this, iF)
-            );
-        }
-
-
-    // Member functions
-
-        // Evaluation functions
-
-            //- Update the coefficients associated with the patch field
-            virtual void updateCoeffs();
-
-        //- Write
-        virtual void write(Ostream&) const;
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#ifdef NoRepository
-#   include "directMappedNamedFixedValueFvPatchField.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

src/surfaceFilmModels/derivedFvPatchFields/directMappedNamedFixedValue/directMappedNamedFixedValueFvPatchFields.C

@@ -1,43 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  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 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "directMappedNamedFixedValueFvPatchFields.H"
-#include "volMesh.H"
-#include "addToRunTimeSelectionTable.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-makePatchFields(directMappedNamedFixedValue);
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// ************************************************************************* //

src/surfaceFilmModels/derivedFvPatchFields/directMappedNamedFixedValue/directMappedNamedFixedValueFvPatchFields.H

@@ -1,49 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  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 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef directMappedNamedFixedValueFvPatchFields_H
-#define directMappedNamedFixedValueFvPatchFields_H
-
-#include "directMappedNamedFixedValueFvPatchField.H"
-#include "fieldTypes.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-makePatchTypeFieldTypedefs(directMappedNamedFixedValue)
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

src/surfaceFilmModels/derivedFvPatchFields/directMappedNamedFixedValue/directMappedNamedFixedValueFvPatchFieldsFwd.H

@@ -1,50 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  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 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef directMappedNamedFixedValueFvPatchFieldsFwd_H
-#define directMappedNamedFixedValueFvPatchFieldsFwd_H
-
-#include "fieldTypes.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-template<class Type> class directMappedNamedFixedValueFvPatchField;
-
-makePatchTypeFieldTypedefs(directMappedNamedFixedValue)
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

src/surfaceFilmModels/derivedFvPatchFields/directMappedNamedFixedValue/directMappedNamesFixedValueFvPatchFieldsFwd.H

@@ -1,50 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  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 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef directMappedNamedFixedValueFvPatchFieldsFwd_H
-#define directMappedNamedFixedValueFvPatchFieldsFwd_H
-
-#include "fieldTypes.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-template<class Type> class directMappedNamedFixedValueFvPatchField;
-
-makePatchTypeFieldTypedefs(directMappedNamedFixedValue)
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

tutorials/incompressible/MRFSimpleFoam/mixerVessel2D/makeMesh

@@ -2,4 +2,4 @@
 set -x
 
 m4 < constant/polyMesh/blockMeshDict.m4 > constant/polyMesh/blockMeshDict
-blockMesh >& log.blockMesh
+blockMesh > log.blockMesh 2>&1

tutorials/lagrangian/reactingParcelFilmFoam/evaporationTest/0.org/T

@@ -28,7 +28,7 @@ boundaryField
     }
     region0_to_wallFilmRegion_wallFilmFaces
     {
-        type            directMappedNamedFixedValue;
+        type            directMapped;
         fieldName       Tsf;
         average         300;
         setAverage      no;

tutorials/lagrangian/reactingParcelFilmFoam/evaporationTest/0.org/U

@@ -28,7 +28,7 @@ boundaryField
     }
     region0_to_wallFilmRegion_wallFilmFaces
     {
-        type            directMappedNamedFixedValue;
+        type            directMapped;
         fieldName       Usf;
         average         ( 0 0 0 );
         setAverage      no;

tutorials/lagrangian/reactingParcelFilmFoam/evaporationTest/0/T

@@ -28,7 +28,7 @@ boundaryField
     }
     region0_to_wallFilmRegion_wallFilmFaces
     {
-        type            directMappedNamedFixedValue;
+        type            directMapped;
         fieldName       Tsf;
         average         300;
         setAverage      no;

tutorials/lagrangian/reactingParcelFilmFoam/evaporationTest/0/U

@@ -28,7 +28,7 @@ boundaryField
     }
     region0_to_wallFilmRegion_wallFilmFaces
     {
-        type            directMappedNamedFixedValue;
+        type            directMapped;
         fieldName       Usf;
         average         ( 0 0 0 );
         setAverage      no;

tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/0.org/T

@@ -29,7 +29,7 @@ boundaryField
     wallFilm
     {
         type            zeroGradient;
-//        type            directMappedNamedFixedValue;
+//        type            directMapped;
 //        fieldName       Tsf;
 //        average         300;
 //        setAverage      no;

tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/0.org/U

@@ -30,7 +30,7 @@ boundaryField
     {
         type            fixedValue;
         value           uniform (0 0 0);
-//        type            directMappedNamedFixedValue;
+//        type            directMapped;
 //        fieldName       Usf;
 //        average         (0 0 0);
 //        setAverage      no;

tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/0/T

@@ -29,7 +29,7 @@ boundaryField
     wallFilm
     {
         type            zeroGradient;
-//        type            directMappedNamedFixedValue;
+//        type            directMapped;
 //        fieldName       Tsf;
 //        average         300;
 //        setAverage      no;

tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/0/U

@@ -30,7 +30,7 @@ boundaryField
     {
         type            fixedValue;
         value           uniform (0 0 0);
-//        type            directMappedNamedFixedValue;
+//        type            directMapped;
 //        fieldName       Usf;
 //        average         (0 0 0);
 //        setAverage      no;

tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/Allrun-parallel

@@ -7,11 +7,11 @@ cd ${0%/*} || exit 1    # run from this directory
 
 ./Allrun.pre
 
-decomposePar -region wallFilmRegion >& log.decomposePar.wallFilmRegion
+decomposePar -region wallFilmRegion > log.decomposePar.wallFilmRegion 2>&1
-decomposePar >& log.decomposePar.primaryRegion
+decomposePar > log.decomposePar.primaryRegion 2>&1
 
 runParallel reactingParcelFilmFoam 4
 
-reconstructPar -region wallFilmRegion >& log.reconstructPar.wallFilmRegion
+reconstructPar -region wallFilmRegion > log.reconstructPar.wallFilmRegion 2>&1
-reconstructPar >& log.reconstructPar.primaryRegion
+reconstructPar > log.reconstructPar.primaryRegion 2>&1
 

tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/Allrun.pre

@@ -14,7 +14,7 @@ runApplication subsetMesh c0 -patch wallFilm -overwrite
 
 # split the obstacle patches into cube[1-6]_patch[1-6]
 echo "running patchifyObstacles"
-./patchifyObstacles >& log.patchifyObstacles
+./patchifyObstacles > log.patchifyObstacles 2>&1
 
 # Create the wall film region via extrusion
 runApplication extrudeToRegionMesh \

tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/system/changeDictionaryDict

@@ -22,7 +22,7 @@ dictionaryReplacement
         {
             wallFilm
             {
-                type            directMappedNamedFixedValue;
+                type            directMapped;
                 fieldName       Tsf;
                 average         300;
                 setAverage      no;
@@ -37,7 +37,7 @@ dictionaryReplacement
         {
             wallFilm
             {
-                type            directMappedNamedFixedValue;
+                type            directMapped;
                 fieldName       Usf;
                 average         (0 0 0);
                 setAverage      no;

tutorials/lagrangian/reactingParcelFilmFoam/multipleBoxes/Allrun-parallel

@@ -4,11 +4,11 @@
 
 ./Allrun.pre
 
-decomposePar -region wallFilmRegion >& log.decomposePar.wallFilmRegion
+decomposePar -region wallFilmRegion > log.decomposePar.wallFilmRegion 2>&1
-decomposePar >& log.decomposePar.primaryRegion
+decomposePar > log.decomposePar.primaryRegion 2>&1
 
 runParallel reactingParcelFilmFoam 4
 
-reconstructPar -region wallFilmRegion >& log.reconstructPar.wallFilmRegion
+reconstructPar -region wallFilmRegion > log.reconstructPar.wallFilmRegion 2>&1
-reconstructPar >& log.reconstructPar.primaryRegion
+reconstructPar > log.reconstructPar.primaryRegion 2>&1
 

tutorials/lagrangian/reactingParcelFilmFoam/multipleBoxes/Allrun.pre

@@ -14,7 +14,7 @@ runApplication subsetMesh c0 -patch wallFilm -overwrite
 
 # split the obstacle patches into cube[1-6]_patch[1-6]
 echo "running patchifyObstacles"
-./patchifyObstacles >& log.patchifyObstacles
+./patchifyObstacles > log.patchifyObstacles 2>&1
 
 # Create the wall film region via extrusion
 runApplication extrudeToRegionMesh \