From 6408c6687021dbaf290e8af9221ecc31c635a6ad Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 2 Jul 2014 16:08:50 +0100
Subject: [PATCH 1/4] BUG: faceSource - corrections for oriented fields

---
 .../field/fieldValues/faceSource/faceSource.C | 95 ++++++++++++++-----
 .../field/fieldValues/faceSource/faceSource.H | 25 ++++-
 .../faceSource/faceSourceTemplates.C          | 30 +++---
 3 files changed, 107 insertions(+), 43 deletions(-)

diff --git a/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.C b/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.C
index ba1e110c..5a862378 100644
--- a/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.C
+++ b/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.C
@@ -99,11 +99,10 @@ void Foam::fieldValues::faceSource::setFaceZoneFaces()
 
     const faceZone& fZone = mesh().faceZones()[zoneId];
 
-    faceId_.setSize(fZone.size());
-    facePatchId_.setSize(fZone.size());
-    faceSign_.setSize(fZone.size());
+    DynamicList<label> faceIds(fZone.size());
+    DynamicList<label> facePatchIds(fZone.size());
+    DynamicList<label> faceSigns(fZone.size());
 
-    label count = 0;
     forAll(fZone, i)
     {
         label faceI = fZone[i];
@@ -145,27 +144,26 @@ void Foam::fieldValues::faceSource::setFaceZoneFaces()
         {
             if (fZone.flipMap()[i])
             {
-                faceSign_[count] = -1;
+                faceSigns.append(-1);
             }
             else
             {
-                faceSign_[count] = 1;
+                faceSigns.append(1);
             }
-            faceId_[count] = faceId;
-            facePatchId_[count] = facePatchId;
-            count++;
+            faceIds.append(faceId);
+            facePatchIds.append(facePatchId);
         }
     }
 
-    faceId_.setSize(count);
-    facePatchId_.setSize(count);
-    faceSign_.setSize(count);
+    faceId_.transfer(faceIds);
+    facePatchId_.transfer(facePatchIds);
+    faceSign_.transfer(faceSigns);
     nFaces_ = returnReduce(faceId_.size(), sumOp<label>());
 
     if (debug)
     {
         Pout<< "Original face zone size = " << fZone.size()
-            << ", new size = " << count << endl;
+            << ", new size = " << faceId_.size() << endl;
     }
 }
 
@@ -445,12 +443,43 @@ void Foam::fieldValues::faceSource::initialise(const dictionary& dict)
 
     if (dict.readIfPresent("weightField", weightFieldName_))
     {
-        Info<< "    weight field = " << weightFieldName_;
+        Info<< "    weight field = " << weightFieldName_ << nl;
+    }
+
+    if (dict.found("orientedWeightField"))
+    {
+        if (weightFieldName_ == "none")
+        {
+            dict.lookup("orientedWeightField") >>  weightFieldName_;
+            Info<< "    weight field = " << weightFieldName_ << nl;
+            orientWeightField_ = true;
+        }
+        else
+        {
+            FatalIOErrorIn
+            (
+                "void Foam::fieldValues::faceSource::initialise"
+                "("
+                    "const dictionary&"
+                ")",
+                dict
+            )
+                << "Either weightField or orientedWeightField can be supplied, "
+                << "but not both"
+                << exit(FatalIOError);
+        }
+    }
+
+    List<word> orientedFields;
+    if (dict.readIfPresent("orientedFields", orientedFields))
+    {
+        orientedFieldsStart_ = fields_.size();
+        fields_.append(orientedFields);
     }
 
     if (dict.readIfPresent("scaleFactor", scaleFactor_))
     {
-        Info<< "    scale factor = " << scaleFactor_;
+        Info<< "    scale factor = " << scaleFactor_ << nl;
     }
 
     Info<< nl << endl;
@@ -581,6 +610,8 @@ Foam::fieldValues::faceSource::faceSource
     source_(sourceTypeNames_.read(dict.lookup("source"))),
     operation_(operationTypeNames_.read(dict.lookup("operation"))),
     weightFieldName_("none"),
+    orientWeightField_(false),
+    orientedFieldsStart_(labelMax),
     scaleFactor_(1.0),
     nFaces_(0),
     faceId_(),
@@ -628,24 +659,42 @@ void Foam::fieldValues::faceSource::write()
             totalArea = gSum(filterField(mesh().magSf(), false));
         }
 
-
         if (Pstream::master())
         {
             file() << obr_.time().value() << tab << totalArea;
         }
 
+        // construct weight field
+        scalarField weightField(faceId_.size(), 1.0);
+        if (weightFieldName_ != "none")
+        {
+            weightField =
+                getFieldValues<scalar>
+                (
+                    weightFieldName_,
+                    true,
+                    orientWeightField_
+                );
+        }
+
+        // Combine onto master
+        combineFields(weightField);
+
+        // process the fields
         forAll(fields_, i)
         {
             const word& fieldName = fields_[i];
-            bool processed = false;
+            bool ok = false;
 
-            processed = processed || writeValues<scalar>(fieldName);
-            processed = processed || writeValues<vector>(fieldName);
-            processed = processed || writeValues<sphericalTensor>(fieldName);
-            processed = processed || writeValues<symmTensor>(fieldName);
-            processed = processed || writeValues<tensor>(fieldName);
+            bool orient = i >= orientedFieldsStart_;
+            ok = ok || writeValues<scalar>(fieldName, weightField, orient);
+            ok = ok || writeValues<vector>(fieldName, weightField, orient);
+            ok = ok
+              || writeValues<sphericalTensor>(fieldName, weightField, orient);
+            ok = ok || writeValues<symmTensor>(fieldName, weightField, orient);
+            ok = ok || writeValues<tensor>(fieldName, weightField, orient);
 
-            if (!processed)
+            if (!ok)
             {
                 WarningIn("void Foam::fieldValues::faceSource::write()")
                     << "Requested field " << fieldName
diff --git a/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.H b/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.H
index d58f1d9a..9589304c 100644
--- a/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.H
+++ b/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.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
@@ -71,8 +71,10 @@ Description
         sourceName   | name of face source if required  | no |
         operation    | operation to perform    | yes         |
         weightField  | name of field to apply weighting | no |
+        orientedWeightField  | name of oriented field to apply weighting | no |
         scaleFactor  | scale factor            | no          | 1
         fields       | list of fields to operate on | yes    |
+        orientedFields | list of oriented fields to operate on | no |
     \endtable
 
     \linebreak
@@ -109,8 +111,8 @@ Note
     - faces on empty patches get ignored
     - if the field is a volField the \c faceZone can only consist of boundary
       faces
-    - all fields are oriented according to the \c faceZone (so you might
-      e.g. see negative pressure)
+    - the `oriented' entries relate to mesh-oriented fields, such as the
+      flux, phi.  These fields will be oriented according to the face normals.
     - using \c sampledSurfaces:
         - not available for surface fields
         - if interpolate=true they use \c interpolationCellPoint
@@ -128,6 +130,7 @@ SeeAlso
 
 SourceFiles
     faceSource.C
+    faceSourceTemplates.C
 
 \*---------------------------------------------------------------------------*/
 
@@ -242,6 +245,12 @@ protected:
         //- Weight field name - optional
         word weightFieldName_;
 
+        //- Flag to indicate if flipMap should be applied to the weight field
+        bool orientWeightField_;
+
+        //- Start index of fields that require application of flipMap
+        label orientedFieldsStart_;
+
         //- Scale factor - optional
         scalar scaleFactor_;
 
@@ -282,7 +291,8 @@ protected:
         tmp<Field<Type> > getFieldValues
         (
             const word& fieldName,
-            const bool mustGet = false
+            const bool mustGet = false,
+            const bool applyOrientation = false
         ) const;
 
         //- Apply the 'operation' to the values. Operation has to
@@ -356,7 +366,12 @@ public:
 
             //- Templated helper function to output field values
             template<class Type>
-            bool writeValues(const word& fieldName);
+            bool writeValues
+            (
+                const word& fieldName,
+                const scalarField& weightField,
+                const bool orient
+            );
 
             //- Filter a surface field according to faceIds
             template<class Type>
diff --git a/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSourceTemplates.C b/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSourceTemplates.C
index 6def30c5..c9e69771 100644
--- a/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSourceTemplates.C
+++ b/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSourceTemplates.C
@@ -54,7 +54,8 @@ template<class Type>
 Foam::tmp<Foam::Field<Type> > Foam::fieldValues::faceSource::getFieldValues
 (
     const word& fieldName,
-    const bool mustGet
+    const bool mustGet,
+    const bool applyOrientation
 ) const
 {
     typedef GeometricField<Type, fvsPatchField, surfaceMesh> sf;
@@ -62,7 +63,7 @@ Foam::tmp<Foam::Field<Type> > Foam::fieldValues::faceSource::getFieldValues
 
     if (source_ != stSampledSurface && obr_.foundObject<sf>(fieldName))
     {
-        return filterField(obr_.lookupObject<sf>(fieldName), true);
+        return filterField(obr_.lookupObject<sf>(fieldName), applyOrientation);
     }
     else if (obr_.foundObject<vf>(fieldName))
     {
@@ -103,7 +104,7 @@ Foam::tmp<Foam::Field<Type> > Foam::fieldValues::faceSource::getFieldValues
         }
         else
         {
-            return filterField(fld, true);
+            return filterField(fld, applyOrientation);
         }
     }
 
@@ -115,6 +116,7 @@ Foam::tmp<Foam::Field<Type> > Foam::fieldValues::faceSource::getFieldValues
             "Foam::fieldValues::faceSource::getFieldValues"
             "("
                 "const word&, "
+                "const bool, "
                 "const bool"
             ") const"
         )   << "Field " << fieldName << " not found in database"
@@ -267,22 +269,20 @@ Type Foam::fieldValues::faceSource::processValues
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class Type>
-bool Foam::fieldValues::faceSource::writeValues(const word& fieldName)
+bool Foam::fieldValues::faceSource::writeValues
+(
+    const word& fieldName,
+    const scalarField& weightField,
+    const bool orient
+)
 {
     const bool ok = validField<Type>(fieldName);
 
     if (ok)
     {
-        Field<Type> values(getFieldValues<Type>(fieldName));
-        scalarField weightField(values.size(), 1.0);
-
-        if (weightFieldName_ != "none")
-        {
-            weightField = getFieldValues<scalar>(weightFieldName_, true);
-        }
+        Field<Type> values(getFieldValues<Type>(fieldName, true, orient));
 
         vectorField Sf;
-
         if (surfacePtr_.valid())
         {
             // Get oriented Sf
@@ -291,13 +291,12 @@ bool Foam::fieldValues::faceSource::writeValues(const word& fieldName)
         else
         {
             // Get oriented Sf
-            Sf = filterField(mesh().Sf(), false);
+            Sf = filterField(mesh().Sf(), true);
         }
 
         // Combine onto master
         combineFields(values);
         combineFields(Sf);
-        combineFields(weightField);
 
         // Write raw values on surface if specified
         if (surfaceWriterPtr_.valid())
@@ -378,7 +377,8 @@ Foam::tmp<Foam::Field<Type> > Foam::fieldValues::faceSource::filterField
             (
                 "fieldValues::faceSource::filterField"
                 "("
-                    "const GeometricField<Type, fvPatchField, volMesh>&"
+                    "const GeometricField<Type, fvPatchField, volMesh>&, "
+                    "const bool"
                 ") const"
             )   << type() << " " << name_ << ": "
                 << sourceTypeNames_[source_] << "(" << sourceName_ << "):"

From f39a8ffdb574399b21e9747a2e710992f1776e0b Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 2 Jul 2014 16:09:46 +0100
Subject: [PATCH 2/4] ENH: extrudeMesh - migrating new functionlity from
 internal development line

---
 .../extrude/extrudeMesh/extrudeMesh.C         | 64 ++++++++++++++++++-
 1 file changed, 63 insertions(+), 1 deletion(-)

diff --git a/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C b/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C
index f2c091e4..e1387379 100644
--- a/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C
+++ b/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.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
@@ -47,6 +47,7 @@ Description
 #include "fvMesh.H"
 #include "MeshedSurfaces.H"
 #include "globalIndex.H"
+#include "cellSet.H"
 
 #include "extrudedMesh.H"
 #include "extrudeModel.H"
@@ -192,6 +193,23 @@ void updateFaceLabels(const mapPolyMesh& map, labelList& faceLabels)
 }
 
 
+void updateCellSet(const mapPolyMesh& map, labelHashSet& cellLabels)
+{
+    const labelList& reverseMap = map.reverseCellMap();
+
+    labelHashSet newCellLabels(2*cellLabels.size());
+
+    forAll(cellLabels, i)
+    {
+        label oldCellI = cellLabels[i];
+
+        if (reverseMap[oldCellI] >= 0)
+        {
+            newCellLabels.insert(reverseMap[oldCellI]);
+        }
+    }
+    cellLabels.transfer(newCellLabels);
+}
 
 
 int main(int argc, char *argv[])
@@ -270,6 +288,9 @@ int main(int argc, char *argv[])
     word backPatchName;
     labelList backPatchFaces;
 
+    // Optional added cells (get written to cellSet)
+    labelHashSet addedCellsSet;
+
     if (mode == PATCH || mode == MESH)
     {
         if (flipNormals && mode == MESH)
@@ -670,11 +691,33 @@ int main(int argc, char *argv[])
             map().reverseFaceMap(),
             backPatchFaces
         );
+
+        // Store added cells
+        if (mode == MESH)
+        {
+            const labelListList addedCells
+            (
+                layerExtrude.addedCells
+                (
+                    meshFromMesh,
+                    layerExtrude.layerFaces()
+                )
+            );
+            forAll(addedCells, faceI)
+            {
+                const labelList& aCells = addedCells[faceI];
+                forAll(aCells, i)
+                {
+                    addedCellsSet.insert(aCells[i]);
+                }
+            }
+        }
     }
     else
     {
         // Read from surface
         fileName surfName(dict.lookup("surface"));
+        surfName.expand();
 
         Info<< "Extruding surfaceMesh read from file " << surfName << nl
             << endl;
@@ -810,6 +853,7 @@ int main(int argc, char *argv[])
             // Update stored data
             updateFaceLabels(map(), frontPatchFaces);
             updateFaceLabels(map(), backPatchFaces);
+            updateCellSet(map(), addedCellsSet);
 
             // Move mesh (if inflation used)
             if (map().hasMotionPoints())
@@ -913,6 +957,9 @@ int main(int argc, char *argv[])
         // Update fields
         mesh.updateMesh(map);
 
+        // Update local data
+        updateCellSet(map(), addedCellsSet);
+
         // Move mesh (if inflation used)
         if (map().hasMotionPoints())
         {
@@ -929,6 +976,21 @@ int main(int argc, char *argv[])
             << exit(FatalError);
     }
 
+    // Need writing cellSet
+    label nAdded = returnReduce(addedCellsSet.size(), sumOp<label>());
+    if (nAdded > 0)
+    {
+        cellSet addedCells(mesh, "addedCells", addedCellsSet);
+        Info<< "Writing added cells to cellSet " << addedCells.name()
+            << nl << endl;
+        if (!addedCells.write())
+        {
+            FatalErrorIn(args.executable()) << "Failed writing cellSet"
+                << addedCells.name()
+                << exit(FatalError);
+        }
+    }
+
     Info<< "End\n" << endl;
 
     return 0;

From c1325cdb29f4e7a588e608ad47597d1054fbc578 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 2 Jul 2014 16:11:35 +0100
Subject: [PATCH 3/4] ENH: directAMI - migrating new functionlity from internal
 development line

---
 .../AMIMethod/directAMI/directAMI.C           | 123 ++++++++++++++++--
 .../AMIMethod/directAMI/directAMI.H           |  12 +-
 2 files changed, 123 insertions(+), 12 deletions(-)

diff --git a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/directAMI/directAMI.C b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/directAMI/directAMI.C
index 70673d31..b63e0f7a 100644
--- a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/directAMI/directAMI.C
+++ b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/directAMI/directAMI.C
@@ -30,7 +30,7 @@ License
 template<class SourcePatch, class TargetPatch>
 void Foam::directAMI<SourcePatch, TargetPatch>::appendToDirectSeeds
 (
-    boolList& mapFlag,
+    labelList& mapFlag,
     labelList& srcTgtSeed,
     DynamicList<label>& srcSeeds,
     DynamicList<label>& nonOverlapFaces,
@@ -50,19 +50,32 @@ void Foam::directAMI<SourcePatch, TargetPatch>::appendToDirectSeeds
     {
         label srcI = srcNbr[i];
 
-        if (mapFlag[srcI] && srcTgtSeed[srcI] == -1)
+        if ((mapFlag[srcI] == 0) && (srcTgtSeed[srcI] == -1))
         {
+            // first attempt: match by comparing face centres
             const face& srcF = this->srcPatch_[srcI];
-            const vector srcN = srcF.normal(srcPoints);
+            const point& srcC = srcCf[srcI];
+
+            scalar tol = GREAT;
+            forAll(srcF, fpI)
+            {
+                const point& p = srcPoints[srcF[fpI]];
+                scalar d2 = magSqr(p - srcC);
+                if (d2 < tol)
+                {
+                    tol = d2;
+                }
+            }
+            tol = max(SMALL, 0.0001*sqrt(tol));
 
             bool found = false;
             forAll(tgtNbr, j)
             {
                 label tgtI = tgtNbr[j];
                 const face& tgtF = this->tgtPatch_[tgtI];
-                pointHit ray = tgtF.ray(srcCf[srcI], srcN, tgtPoints);
+                const point tgtC = tgtF.centre(tgtPoints);
 
-                if (ray.hit())
+                if (mag(srcC - tgtC) < tol)
                 {
                     // new match - append to lists
                     found = true;
@@ -74,11 +87,57 @@ void Foam::directAMI<SourcePatch, TargetPatch>::appendToDirectSeeds
                 }
             }
 
+            // second attempt: match by shooting a ray into the tgt face
             if (!found)
             {
-                // no match available for source face srcI
-                mapFlag[srcI] = false;
+                const vector srcN = srcF.normal(srcPoints);
+
+                forAll(tgtNbr, j)
+                {
+                    label tgtI = tgtNbr[j];
+                    const face& tgtF = this->tgtPatch_[tgtI];
+                    pointHit ray = tgtF.ray(srcCf[srcI], srcN, tgtPoints);
+
+                    if (ray.hit())
+                    {
+                        // new match - append to lists
+                        found = true;
+
+                        srcTgtSeed[srcI] = tgtI;
+                        srcSeeds.append(srcI);
+
+                        break;
+                    }
+                }
+            }
+
+            // no match available for source face srcI
+            if (!found)
+            {
+                mapFlag[srcI] = -1;
                 nonOverlapFaces.append(srcI);
+
+                if (debug)
+                {
+                    Pout<< "source face not found: id=" << srcI
+                        << " centre=" << srcCf[srcI]
+                        << " normal=" << srcF.normal(srcPoints)
+                        << " points=" << srcF.points(srcPoints)
+                        << endl;
+
+                    Pout<< "target neighbours:" << nl;
+                    forAll(tgtNbr, j)
+                    {
+                        label tgtI = tgtNbr[j];
+                        const face& tgtF = this->tgtPatch_[tgtI];
+
+                        Pout<< "face id: " << tgtI
+                            << " centre=" << tgtF.centre(tgtPoints)
+                            << " normal=" << tgtF.normal(tgtPoints)
+                            << " points=" << tgtF.points(tgtPoints)
+                            << endl;
+                    }
+                }
             }
         }
     }
@@ -96,6 +155,36 @@ void Foam::directAMI<SourcePatch, TargetPatch>::appendToDirectSeeds
 }
 
 
+template<class SourcePatch, class TargetPatch>
+void Foam::directAMI<SourcePatch, TargetPatch>::restartAdvancingFront
+(
+    labelList& mapFlag,
+    DynamicList<label>& nonOverlapFaces,
+    label& srcFaceI,
+    label& tgtFaceI
+) const
+{
+    forAll(mapFlag, faceI)
+    {
+        if (mapFlag[faceI] == 0)
+        {
+            tgtFaceI = this->findTargetFace(faceI);
+
+            if (tgtFaceI < 0)
+            {
+                mapFlag[faceI] = -1;
+                nonOverlapFaces.append(faceI);
+            }
+            else
+            {
+                srcFaceI = faceI;
+                break;
+            }
+        }
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class SourcePatch, class TargetPatch>
@@ -176,15 +265,19 @@ void Foam::directAMI<SourcePatch, TargetPatch>::calculate
     srcTgtSeed[srcFaceI] = tgtFaceI;
 
     // list to keep track of whether src face can be mapped
-    boolList mapFlag(srcAddr.size(), true);
+    // 1 = mapped, 0 = untested, -1 = cannot map
+    labelList mapFlag(srcAddr.size(), 0);
 
+    label nTested = 0;
     DynamicList<label> nonOverlapFaces;
     do
     {
         srcAddr[srcFaceI].append(tgtFaceI);
         tgtAddr[tgtFaceI].append(srcFaceI);
 
-        mapFlag[srcFaceI] = false;
+        mapFlag[srcFaceI] = 1;
+
+        nTested++;
 
         // Do advancing front starting from srcFaceI, tgtFaceI
         appendToDirectSeeds
@@ -196,6 +289,12 @@ void Foam::directAMI<SourcePatch, TargetPatch>::calculate
             srcFaceI,
             tgtFaceI
         );
+
+        if (srcFaceI < 0 && nTested < this->srcPatch_.size())
+        {
+            restartAdvancingFront(mapFlag, nonOverlapFaces, srcFaceI, tgtFaceI);
+        }
+
     } while (srcFaceI >= 0);
 
     if (nonOverlapFaces.size() != 0)
@@ -211,14 +310,16 @@ void Foam::directAMI<SourcePatch, TargetPatch>::calculate
     forAll(srcAddr, i)
     {
         scalar magSf = this->srcMagSf_[i];
-        srcAddress[i].transfer(srcAddr[i]);
+//        srcWeights[i] = scalarList(srcAddr[i].size(), magSf);
         srcWeights[i] = scalarList(1, magSf);
+        srcAddress[i].transfer(srcAddr[i]);
     }
     forAll(tgtAddr, i)
     {
         scalar magSf = this->tgtMagSf_[i];
-        tgtAddress[i].transfer(tgtAddr[i]);
+//        tgtWeights[i] = scalarList(tgtAddr[i].size(), magSf);
         tgtWeights[i] = scalarList(1, magSf);
+        tgtAddress[i].transfer(tgtAddr[i]);
     }
 }
 
diff --git a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/directAMI/directAMI.H b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/directAMI/directAMI.H
index dc273c79..d74094d0 100644
--- a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/directAMI/directAMI.H
+++ b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/directAMI/directAMI.H
@@ -67,7 +67,7 @@ private:
             //- Append to list of src face seed indices
             void appendToDirectSeeds
             (
-                boolList& mapFlag,
+                labelList& mapFlag,
                 labelList& srcTgtSeed,
                 DynamicList<label>& srcSeeds,
                 DynamicList<label>& nonOverlapFaces,
@@ -75,6 +75,16 @@ private:
                 label& tgtFaceI
             ) const;
 
+            //- Restart the advancing front - typically happens for
+            //  disconnected regions
+            void restartAdvancingFront
+            (
+                labelList& mapFlag,
+                DynamicList<label>& nonOverlapFaces,
+                label& srcFaceI,
+                label& tgtFaceI
+            ) const;
+
 
         // Evaluation
 

From 7ea650d4ca1908ec8a59cdeef9097497d8c37c36 Mon Sep 17 00:00:00 2001
From: Henry <Henry>
Date: Sun, 6 Jul 2014 20:20:16 +0100
Subject: [PATCH 4/4] Revert non-orthogonality treatment for non-coupled BCs.

---
 .../fvMesh/fvPatches/constraint/wedge/wedgeFvPatch.C     | 9 ---------
 .../fvMesh/fvPatches/constraint/wedge/wedgeFvPatch.H     | 3 ---
 src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.C      | 4 +++-
 3 files changed, 3 insertions(+), 13 deletions(-)

diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/wedge/wedgeFvPatch.C b/src/finiteVolume/fvMesh/fvPatches/constraint/wedge/wedgeFvPatch.C
index ddc60991..f5ce1243 100644
--- a/src/finiteVolume/fvMesh/fvPatches/constraint/wedge/wedgeFvPatch.C
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/wedge/wedgeFvPatch.C
@@ -46,15 +46,6 @@ wedgeFvPatch::wedgeFvPatch(const polyPatch& patch, const fvBoundaryMesh& bm)
 {}
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-Foam::tmp<Foam::vectorField> Foam::wedgeFvPatch::delta() const
-{
-    const vectorField nHat(nf());
-    return nHat*(nHat & (Cf() - Cn()));
-}
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/wedge/wedgeFvPatch.H b/src/finiteVolume/fvMesh/fvPatches/constraint/wedge/wedgeFvPatch.H
index 16fab3e4..25be556b 100644
--- a/src/finiteVolume/fvMesh/fvPatches/constraint/wedge/wedgeFvPatch.H
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/wedge/wedgeFvPatch.H
@@ -83,9 +83,6 @@ public:
             {
                 return wedgePolyPatch_.cellT();
             }
-
-            //- Return cell-centre to face normal vector
-            virtual tmp<vectorField> delta() const;
 };
 
 
diff --git a/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.C b/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.C
index c55ad272..e7dd4120 100644
--- a/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.C
+++ b/src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.C
@@ -140,7 +140,9 @@ const Foam::scalarField& Foam::fvPatch::magSf() const
 
 Foam::tmp<Foam::vectorField> Foam::fvPatch::delta() const
 {
-    return Cf() - Cn();
+    // Use patch-normal delta for all non-coupled BCs
+    const vectorField nHat(nf());
+    return nHat*(nHat & (Cf() - Cn()));
 }