ENH: decomposePar: cyclicAMI in constraints. Fixes #2242

The preservePatches constraint in decomposeParDict can be used to keep owner and neighbour cells of coupled patches on the same processor. It previously only handled one-to-one coupling (cyclic, processor) but has been extended to handle many-to-one coupling (cyclicAMI, cyclicACMI).

Without syncing across (in green) cyclicAMI:

With syncing across (in green) cyclicAMI:

src/parallel/decompose/decompositionMethods/decompositionConstraints/decompositionConstraint/decompositionConstraint.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2015-2017 OpenFOAM Foundation
-    Copyright (C) 2015-2019 OpenCFD Ltd.
+    Copyright (C) 2015-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -27,6 +27,8 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "decompositionConstraint.H"
+#include "syncTools.H"
+#include "cyclicAMIPolyPatch.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -36,6 +38,95 @@ namespace Foam
     defineRunTimeSelectionTable(decompositionConstraint, dictionary);
 }
 
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::decompositionConstraint::getMinBoundaryValue
+(
+    const polyMesh& mesh,
+    const labelList& decomposition,
+    labelList& destProc
+) const
+{
+    destProc.setSize(mesh.nBoundaryFaces());
+    destProc = labelMax;
+
+    const polyBoundaryMesh& pbm = mesh.boundaryMesh();
+
+    for (const polyPatch& pp : pbm)
+    {
+        const labelUList& faceCells = pp.faceCells();
+
+        forAll(faceCells, i)
+        {
+            label bFacei = pp.offset()+i;
+            destProc[bFacei] = decomposition[faceCells[i]];
+        }
+    }
+
+    // Take minimum of coupled faces (over all patches!)
+    syncTools::syncBoundaryFaceList(mesh, destProc, minEqOp<label>());
+
+    // Do cyclicAMI ourselves
+    for (const auto& pp : pbm)
+    {
+        const auto* ppp = isA<cyclicAMIPolyPatch>(pp);
+        if (ppp)
+        {
+            const auto& cycPp = *ppp;
+            const auto& nbrPp = cycPp.neighbPatch();
+            const labelList nbrDecomp(decomposition, nbrPp.faceCells());
+            labelList thisDecomp(decomposition, cycPp.faceCells());
+
+            if (cycPp.owner())
+            {
+                cycPp.AMI().interpolateToSource
+                (
+                    nbrDecomp,
+                    []
+                    (
+                        label& res,
+                        const label facei,
+                        const label& fld,
+                        const scalar& w
+                    )
+                    {
+                        res = min(res, fld);
+                    },
+                    thisDecomp,
+                    thisDecomp      // used in case of low-weight-corr
+                );
+            }
+            else
+            {
+                nbrPp.AMI().interpolateToTarget
+                (
+                    nbrDecomp,
+                    []
+                    (
+                        label& res,
+                        const label facei,
+                        const label& fld,
+                        const scalar& w
+                    )
+                    {
+                        res = min(res, fld);
+                    },
+                    thisDecomp,
+                    thisDecomp      // used in case of low-weight-corr
+                );
+            }
+
+            forAll(thisDecomp, i)
+            {
+                label& proc = destProc[cycPp.offset()+i];
+                proc = min(proc, thisDecomp[i]);
+            }
+        }
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::decompositionConstraint::decompositionConstraint