checkMesh, moveDynamicMesh: option -checkAMI writes the reconstructed AMI weights

Patch contributed by Mattijs Janssens

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

@@ -1,3 +1,4 @@
+#include "PatchTools.H"
 #include "checkGeometry.H"
 #include "polyMesh.H"
 #include "cellSet.H"
@@ -9,7 +10,9 @@
 #include "polyMeshTetDecomposition.H"
 #include "surfaceWriter.H"
 #include "checkTools.H"
-
+#include "vtkSurfaceWriter.H"
+#include "cyclicAMIPolyPatch.H"
+#include "Time.H"
 
 // Find wedge with opposite orientation. Note: does not actually check that
 // it is opposite, only that it has opposite normal and same axis
@@ -925,5 +928,134 @@ Foam::label Foam::checkGeometry
         }
     }
 
+    if (allGeometry)
+    {
+        const polyBoundaryMesh& pbm = mesh.boundaryMesh();
+
+        const word tmName(mesh.time().timeName());
+        const word procAndTime(Foam::name(Pstream::myProcNo()) + "_" + tmName);
+
+        autoPtr<surfaceWriter> patchWriter;
+        if (!writer.valid())
+        {
+            patchWriter.reset(new vtkSurfaceWriter());
+        }
+        const surfaceWriter& wr = (writer.valid() ? writer() : patchWriter());
+
+        forAll(pbm, patchi)
+        {
+            if (isA<cyclicAMIPolyPatch>(pbm[patchi]))
+            {
+                const cyclicAMIPolyPatch& cpp =
+                    refCast<const cyclicAMIPolyPatch>(pbm[patchi]);
+
+                if (cpp.owner())
+                {
+                    Info<< "Calculating AMI weights between owner patch: "
+                        << cpp.name() << " and neighbour patch: "
+                        << cpp.neighbPatch().name() << endl;
+
+                    const AMIPatchToPatchInterpolation& ami =
+                        cpp.AMI();
+
+                    {
+                        // Collect geometry
+                        labelList pointToGlobal;
+                        labelList uniqueMeshPointLabels;
+                        autoPtr<globalIndex> globalPoints;
+                        autoPtr<globalIndex> globalFaces;
+                        faceList mergedFaces;
+                        pointField mergedPoints;
+                        Foam::PatchTools::gatherAndMerge
+                        (
+                            mesh,
+                            cpp.localFaces(),
+                            cpp.meshPoints(),
+                            cpp.meshPointMap(),
+
+                            pointToGlobal,
+                            uniqueMeshPointLabels,
+                            globalPoints,
+                            globalFaces,
+
+                            mergedFaces,
+                            mergedPoints
+                        );
+                        // Collect field
+                        scalarField mergedWeights;
+                        globalFaces().gather
+                        (
+                            UPstream::worldComm,
+                            UPstream::procID(UPstream::worldComm),
+                            ami.srcWeightsSum(),
+                            mergedWeights
+                        );
+
+                        if (Pstream::master())
+                        {
+                            wr.write
+                            (
+                                "postProcessing",
+                                "src_" + tmName,
+                                mergedPoints,
+                                mergedFaces,
+                                "weightsSum",
+                                mergedWeights,
+                                false
+                            );
+                        }
+                    }
+                    {
+                        // Collect geometry
+                        labelList pointToGlobal;
+                        labelList uniqueMeshPointLabels;
+                        autoPtr<globalIndex> globalPoints;
+                        autoPtr<globalIndex> globalFaces;
+                        faceList mergedFaces;
+                        pointField mergedPoints;
+                        Foam::PatchTools::gatherAndMerge
+                        (
+                            mesh,
+                            cpp.neighbPatch().localFaces(),
+                            cpp.neighbPatch().meshPoints(),
+                            cpp.neighbPatch().meshPointMap(),
+
+                            pointToGlobal,
+                            uniqueMeshPointLabels,
+                            globalPoints,
+                            globalFaces,
+
+                            mergedFaces,
+                            mergedPoints
+                        );
+                        // Collect field
+                        scalarField mergedWeights;
+                        globalFaces().gather
+                        (
+                            UPstream::worldComm,
+                            UPstream::procID(UPstream::worldComm),
+                            ami.tgtWeightsSum(),
+                            mergedWeights
+                        );
+
+                        if (Pstream::master())
+                        {
+                            wr.write
+                            (
+                                "postProcessing",
+                                "tgt_" + tmName,
+                                mergedPoints,
+                                mergedFaces,
+                                "weightsSum",
+                                mergedWeights,
+                                false
+                            );
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     return noFailedChecks;
 }

applications/utilities/mesh/manipulation/moveDynamicMesh/moveDynamicMesh.C

@@ -35,6 +35,7 @@ Description
 #include "pimpleControl.H"
 #include "vtkSurfaceWriter.H"
 #include "cyclicAMIPolyPatch.H"
+#include "PatchTools.H"
 
 using namespace Foam;
 
@@ -43,6 +44,7 @@ using namespace Foam;
 // Dump patch + weights to vtk file
 void writeWeights
 (
+    const polyMesh& mesh,
     const scalarField& wghtSum,
     const primitivePatch& patch,
     const fileName& directory,
@@ -52,17 +54,52 @@ void writeWeights
 {
     vtkSurfaceWriter writer;
 
+    // Collect geometry
+    labelList pointToGlobal;
+    labelList uniqueMeshPointLabels;
+    autoPtr<globalIndex> globalPoints;
+    autoPtr<globalIndex> globalFaces;
+    faceList mergedFaces;
+    pointField mergedPoints;
+    Foam::PatchTools::gatherAndMerge
+    (
+        mesh,
+        patch.localFaces(),
+        patch.meshPoints(),
+        patch.meshPointMap(),
+
+        pointToGlobal,
+        uniqueMeshPointLabels,
+        globalPoints,
+        globalFaces,
+
+        mergedFaces,
+        mergedPoints
+    );
+    // Collect field
+    scalarField mergedWeights;
+    globalFaces().gather
+    (
+        UPstream::worldComm,
+        UPstream::procID(UPstream::worldComm),
+        wghtSum,
+        mergedWeights
+    );
+
+    if (Pstream::master())
+    {
         writer.write
         (
             directory,
-        prefix + "_proc" + Foam::name(Pstream::myProcNo()) + "_" + timeName,
+            prefix + "_" + timeName,
-        patch.localPoints(),
+            mergedPoints,
-        patch.localFaces(),
+            mergedFaces,
             "weightsSum",
-        wghtSum,
+            mergedWeights,
             false
         );
     }
+}
 
 
 void writeWeights(const polyMesh& mesh)
@@ -89,6 +126,7 @@ void writeWeights(const polyMesh& mesh)
 
                 writeWeights
                 (
+                    mesh,
                     ami.tgtWeightsSum(),
                     cpp.neighbPatch(),
                     "postProcessing",
@@ -97,6 +135,7 @@ void writeWeights(const polyMesh& mesh)
                 );
                 writeWeights
                 (
+                    mesh,
                     ami.srcWeightsSum(),
                     cpp,
                     "postProcessing",

src/OpenFOAM/meshes/primitiveMesh/PatchTools/PatchToolsGatherAndMerge.C

@@ -219,6 +219,12 @@ void Foam::PatchTools::gatherAndMerge
     }
     else
     {
+        pointToGlobal = identity(meshPoints.size());
+        uniqueMeshPointLabels = pointToGlobal;
+
+        globalPointsPtr.reset(new globalIndex(meshPoints.size()));
+        globalFacesPtr.reset(new globalIndex(localFaces.size()));
+
         mergedFaces = localFaces;
         mergedPoints = pointField(mesh.points(), meshPoints);
     }