checkGeometry.C

                            mergedFaces,
                            mergedPoints
                        );
                        // Collect field
                        scalarField mergedWeights;
                        globalFaces().gather
                        (
                            ami.srcWeightsSum(),
                            mergedWeights
                        );

                        if (Pstream::master())
                        {
                            const word fName
                            (
                                "patch" + Foam::name(cpp.index())
                              + "-src_" + tmName
                            );

                            wr.open
                            (
                                mergedPoints,
                                mergedFaces,
                                (outputDir / fName),
                                false  // serial - already merged
                            );

                            wr.write("weightsSum", mergedWeights);
                            wr.clear();
                        }

                        if (isA<cyclicACMIPolyPatch>(pbm[patchi]))
                        {
                            const cyclicACMIPolyPatch& pp =
                                refCast<const cyclicACMIPolyPatch>(pbm[patchi]);

                            scalarField mergedMask;
                            globalFaces().gather
                            (
                                pp.mask(),
                                mergedMask
                            );

                            if (Pstream::master())
                            {
                                const word fName
                                (
                                    "patch" + Foam::name(cpp.index())
                                  + "-src_" + tmName
                                );

                                wr.open
                                (
                                    mergedPoints,
                                    mergedFaces,
                                    (outputDir / fName),
                                    false  // serial - already merged
                                );

                                wr.write("mask", mergedMask);
                                wr.clear();
                            }
                        }
                    }
                    {
                        // 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
                        (
                            ami.tgtWeightsSum(),
                            mergedWeights
                        );

                        if (Pstream::master())
                        {
                            const word fName
                            (
                                "patch" + Foam::name(cpp.index())
                              + "-tgt_" + tmName
                            );

                            wr.open
                            (
                                mergedPoints,
                                mergedFaces,
                                (outputDir / fName),
                                false  // serial - already merged
                            );

                            wr.write("weightsSum", mergedWeights);
                            wr.clear();
                        }

                        if (isA<cyclicACMIPolyPatch>(pbm[patchi]))
                        {
                            const cyclicACMIPolyPatch& pp =
                                refCast<const cyclicACMIPolyPatch>(pbm[patchi]);
                            scalarField mergedMask;
                            globalFaces().gather
                            (
                                pp.neighbPatch().mask(),
                                mergedMask
                            );

                            if (Pstream::master())
                            {
                                const word fName
                                (
                                    "patch" + Foam::name(cpp.index())
                                  + "-tgt_" + tmName
                                );

                                wr.open
                                (
                                    mergedPoints,
                                    mergedFaces,
                                    (outputDir / fName),
                                    false  // serial - already merged
                                );

                                wr.write("mask", mergedMask);
                                wr.clear();
                            }
                        }
                    }
                }
            }
        }
    }

    return noFailedChecks;
}