BUG: GAMG: processorAgglomeration not merging proc coeffs. Fixes #3172

src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGSolverAgglomerateMatrix.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2023 OpenCFD Ltd.
+    Copyright (C) 2023-2024 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -332,37 +332,49 @@ void Foam::GAMGSolver::gatherMatrices
 
         const label proci = UPstream::myProcNo(comm);
 
-        labelList validInterface(interfaces.size(), -1);
+        // All interfaceBouCoeffs need to be sent across
+        bitSet validCoeffs(interfaces.size());
+        forAll(interfaceBouCoeffs, intI)
+        {
+            if (interfaceBouCoeffs.set(intI))
+            {
+                validCoeffs.set(intI);
+            }
+        }
+        // Only preserved interfaces need to be sent across
+        bitSet validInterface(interfaces.size());
         forAll(interfaces, intI)
         {
             const label allIntI = boundaryMap[proci][intI];
             if (interfaces.set(intI) && allIntI != -1)
             {
-                validInterface[intI] = intI;
+                validInterface.set(intI);
             }
         }
 
         UOPstream toMaster(UPstream::masterNo(), pBufs);
 
-        toMaster<< mat << token::SPACE << validInterface;
+        toMaster<< mat
+            << token::SPACE << validCoeffs
+            << token::SPACE << validInterface;
 
-        forAll(validInterface, intI)
+        for (const label intI : validCoeffs)
         {
-            if (validInterface[intI] != -1)
+            toMaster
+                << interfaceBouCoeffs[intI]
+                << interfaceIntCoeffs[intI];
+        }
+        for (const label intI : validInterface)
         {
             const auto& interface = refCast<const GAMGInterfaceField>
             (
                 interfaces[intI]
             );
 
-                toMaster
+            toMaster << interface.type();
-                    << interfaceBouCoeffs[intI]
-                    << interfaceIntCoeffs[intI]
-                    << interface.type();
             interface.write(toMaster);
         }
     }
-    }
 
     // Wait for finish
     pBufs.finishedGathers();
@@ -389,42 +401,24 @@ void Foam::GAMGSolver::gatherMatrices
 
             otherMats.set(otherI, new lduMatrix(destMesh, fromProc));
 
-            // Receive number of/valid interfaces
+            // Receive bitSet of/valid interfaceCoeffs/interfaces
-            // >= 0 : remote interface index
+            const bitSet validCoeffs(fromProc);
-            // -1   : invalid interface
+            const bitSet validInterface(fromProc);
-            const labelList validInterface(fromProc);
 
-            otherBouCoeffs.set
+            otherBouCoeffs.emplace_set(otherI, validCoeffs.size());
-            (
+            otherIntCoeffs.emplace_set(otherI, validCoeffs.size());
-                otherI,
+            otherInterfaces.emplace_set(otherI, validInterface.size());
-                new FieldField<Field, scalar>(validInterface.size())
-            );
-            otherIntCoeffs.set
-            (
-                otherI,
-                new FieldField<Field, scalar>(validInterface.size())
-            );
-            otherInterfaces.set
-            (
-                otherI,
-                new PtrList<lduInterfaceField>(validInterface.size())
-            );
 
-            forAll(validInterface, intI)
+            // Receive individual interface contributions
+            for (const label intI : validCoeffs)
             {
-                if (validInterface[intI] != -1)
+                otherBouCoeffs[otherI].emplace_set(intI, fromProc);
-                {
+                otherIntCoeffs[otherI].emplace_set(intI, fromProc);
-                    otherBouCoeffs[otherI].set
+            }
-                    (
-                        intI,
-                        new scalarField(fromProc)
-                    );
-                    otherIntCoeffs[otherI].set
-                    (
-                        intI,
-                        new scalarField(fromProc)
-                    );
 
+            // Receive individual interface contributions
+            for (const label intI : validInterface)
+            {
                 const word coupleType(fromProc);
 
                 const label allIntI = boundaryMap[proci][intI];
@@ -446,7 +440,6 @@ void Foam::GAMGSolver::gatherMatrices
         }
     }
 }
-}
 
 
 void Foam::GAMGSolver::procAgglomerateMatrix