songtianlun/openfoam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ENH: more consistent use of broadcast, combineReduce etc.

Browse Source 
- broadcast           : (replaces scatter)
  - combineReduce       == combineGather + broadcast
  - listCombineReduce   == listCombineGather + broadcast
  - mapCombineReduce    == mapCombineGather + broadcast
  - allGatherList       == gatherList + scatterList

  Before settling on a more consistent naming convention,
  some intermediate namings were used in OpenFOAM-v2206:

    - combineReduce       (2206: combineAllGather)
    - listCombineReduce   (2206: listCombineAllGather)
    - mapCombineReduce    (2206: mapCombineAllGather)
This commit is contained in:
Mark Olesen 2022-08-23 15:58:32 +02:00 committed by Andrew Heather
parent b9c15b8585
commit 473e14418a
103 changed files with 248 additions and 307 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
applications/test/IndirectList/Test-IndirectList.C
View File

@ -182,7 +182,7 @@ int main(int argc, char *argv[])
// MPI barrier
bool barrier = true;
Pstream::scatter(barrier);
Pstream::broadcast(barrier);
}

8
applications/test/Tuple2/Test-Tuple2.C
View File

@ -138,8 +138,8 @@ int main()
maxFirstEqOp<label>()(maxIndexed, item);
}
Pstream::combineAllGather(minIndexed, minFirstEqOp<label>());
Pstream::combineAllGather(maxIndexed, maxFirstEqOp<label>());
Pstream::combineReduce(minIndexed, minFirstEqOp<label>());
Pstream::combineReduce(maxIndexed, maxFirstEqOp<label>());
Info<< "Min indexed: " << minIndexed << nl
<< "Max indexed: " << maxIndexed << nl;
@ -156,8 +156,8 @@ int main()
maxIndexed = maxFirstOp<label>()(maxIndexed, item);
}
Pstream::combineAllGather(minIndexed, minFirstEqOp<label>());
Pstream::combineAllGather(maxIndexed, maxFirstEqOp<label>());
Pstream::combineReduce(minIndexed, minFirstEqOp<label>());
Pstream::combineReduce(maxIndexed, maxFirstEqOp<label>());
Info<< "Min indexed: " << minIndexed << nl
<< "Max indexed: " << maxIndexed << nl;

2
applications/test/decomposedBlockData/Test-decomposedBlockData.C
View File

@ -60,7 +60,7 @@ int main(int argc, char *argv[])
Info<< "Reading " << file << nl << endl;
decomposedBlockData data
(
Pstream::worldComm,
UPstream::worldComm,
IOobject
(
file,

2
applications/test/globalIndex/Test-globalIndex.C
View File

@ -204,7 +204,7 @@ int main(int argc, char *argv[])
labelPair inOut;
pointField allCcs(globalNumbering.gather(mesh.cellCentres()));
inOut[0] = allCcs.size();
Pstream::scatter(allCcs);
Pstream::broadcast(allCcs);
inOut[1] = allCcs.size();
Pout<< " " << inOut << endl;

6
applications/test/minMax1/Test-minMax1.C
View File

@ -234,11 +234,7 @@ int main(int argc, char *argv[])
Pout<< "hashed: " << hashed << nl;
Pstream::mapCombineGather
(
hashed,
plusEqOp<scalarMinMax>()
);
Pstream::mapCombineReduce(hashed, plusEqOp<scalarMinMax>());
Info<< "reduced: " << hashed << nl;

2
applications/test/parallel-communicators/Test-parallel-communicators.C
View File

@ -167,7 +167,7 @@ int main(int argc, char *argv[])
(
localValue,
sumOp<scalar>(),
Pstream::msgType(),
UPstream::msgType(),
comm
);
Pout<< "sum :" << sum << endl;

4
applications/test/parallel-nonBlocking/Test-parallel-nonBlocking.C
View File

@ -125,13 +125,13 @@ int main(int argc, char *argv[])
scalar data1 = 1.0;
label request1 = -1;
{
Foam::reduce(data1, sumOp<scalar>(), Pstream::msgType(), request1);
Foam::reduce(data1, sumOp<scalar>(), UPstream::msgType(), request1);
}
scalar data2 = 0.1;
label request2 = -1;
{
Foam::reduce(data2, sumOp<scalar>(), Pstream::msgType(), request2);
Foam::reduce(data2, sumOp<scalar>(), UPstream::msgType(), request2);
}

8
applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMesh.C
View File

@ -661,8 +661,8 @@ void countExtrudePatches
}
// Synchronise decision. Actual numbers are not important, just make
// sure that they're > 0 on all processors.
Pstream::listCombineAllGather(zoneSidePatch, plusEqOp<label>());
Pstream::listCombineAllGather(zoneZonePatch, plusEqOp<label>());
Pstream::listCombineReduce(zoneSidePatch, plusEqOp<label>());
Pstream::listCombineReduce(zoneZonePatch, plusEqOp<label>());
}
@ -1848,7 +1848,7 @@ int main(int argc, char *argv[])
const primitiveFacePatch extrudePatch(std::move(zoneFaces), mesh.points());
Pstream::listCombineAllGather(isInternal, orEqOp<bool>());
Pstream::listCombineReduce(isInternal, orEqOp<bool>());
// Check zone either all internal or all external faces
checkZoneInside(mesh, zoneNames, zoneID, extrudeMeshFaces, isInternal);
@ -2309,7 +2309,7 @@ int main(int argc, char *argv[])
}
// Reduce
Pstream::mapCombineAllGather(globalSum, plusEqOp<point>());
Pstream::mapCombineReduce(globalSum, plusEqOp<point>());
forAll(localToGlobalRegion, localRegionI)
{

4
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshConformToSurface.C
View File

@ -729,7 +729,7 @@ Foam::label Foam::conformalVoronoiMesh::synchroniseSurfaceTrees
}
}
Pstream::listCombineAllGather(hits, plusEqOp<labelHashSet>());
Pstream::listCombineReduce(hits, plusEqOp<labelHashSet>());
forAll(surfaceHits, eI)
{
@ -816,7 +816,7 @@ Foam::label Foam::conformalVoronoiMesh::synchroniseEdgeTrees
}
}
Pstream::listCombineAllGather(hits, plusEqOp<labelHashSet>());
Pstream::listCombineReduce(hits, plusEqOp<labelHashSet>());
forAll(featureEdgeHits, eI)
{

8
applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C
View File

@ -416,10 +416,12 @@ void extractSurface
// Allocate zone/patch for all patches
HashTable<label> compactZoneID(1024);
if (Pstream::master())
{
forAllConstIters(patchSize, iter)
{
label sz = compactZoneID.size();
compactZoneID.insert(iter.key(), sz);
compactZoneID.insert(iter.key(), compactZoneID.size());
}
}
Pstream::broadcast(compactZoneID);
@ -431,7 +433,7 @@ void extractSurface
label patchi = bMesh.findPatchID(iter.key());
if (patchi != -1)
{
patchToCompactZone[patchi] = iter();
patchToCompactZone[patchi] = iter.val();
}
}

6
applications/utilities/mesh/manipulation/checkMesh/checkTopology.C
View File

@ -588,11 +588,7 @@ Foam::label Foam::checkTopology
}
}
Pstream::listCombineAllGather
(
regionDisconnected,
andEqOp<bool>()
);
Pstream::listCombineReduce(regionDisconnected, andEqOp<bool>());
}

2
applications/utilities/mesh/manipulation/createPatch/createPatch.C
View File

@ -714,7 +714,7 @@ void syncPoints
}
// Combine - globally consistent
Pstream::listCombineAllGather(sharedPts, cop);
Pstream::listCombineReduce(sharedPts, cop);
// Now we will all have the same information. Merge it back with
// my local information.

2
applications/utilities/mesh/manipulation/splitMeshRegions/splitMeshRegions.C
View File

@ -1114,7 +1114,7 @@ label findCorrespondingRegion
}
}
Pstream::listCombineAllGather(cellsInZone, plusEqOp<label>());
Pstream::listCombineReduce(cellsInZone, plusEqOp<label>());
// Pick region with largest overlap of zoneI
label regionI = findMax(cellsInZone);

8
applications/utilities/miscellaneous/foamFormatConvert/foamFormatConvert.C
View File

@ -223,7 +223,7 @@ bool writeOptionalMeshObject
// Make sure all know if there is a valid class name
wordList classNames(1, io.headerClassName());
Pstream::combineAllGather(classNames, uniqueEqOp<word>());
Pstream::combineReduce(classNames, uniqueEqOp<word>());
// Check for correct type
if (classNames[0] == T::typeName)
@ -429,7 +429,7 @@ int main(int argc, char *argv[])
)
);
Pstream::combineAllGather(lagrangianDirs, uniqueEqOp<fileName>());
Pstream::combineReduce(lagrangianDirs, uniqueEqOp<fileName>());
if (!lagrangianDirs.empty())
{
@ -466,7 +466,7 @@ int main(int argc, char *argv[])
)
);
Pstream::combineAllGather(cloudDirs, uniqueEqOp<fileName>());
Pstream::combineReduce(cloudDirs, uniqueEqOp<fileName>());
forAll(cloudDirs, i)
{
@ -492,7 +492,7 @@ int main(int argc, char *argv[])
);
// Combine with all other cloud objects
Pstream::combineAllGather(cloudFields, uniqueEqOp<word>());
Pstream::combineReduce(cloudFields, uniqueEqOp<word>());
for (const word& name : cloudFields)
{

17
applications/utilities/parallelProcessing/redistributePar/parLagrangianDistributor.C
View File

@ -89,10 +89,11 @@ void Foam::parLagrangianDistributor::findClouds
}
// Synchronise cloud names
Pstream::combineGather(cloudNames, ListOps::uniqueEqOp<word>());
Pstream::broadcast(cloudNames);
Pstream::combineReduce(cloudNames, ListOps::uniqueEqOp<word>());
Foam::sort(cloudNames); // Consistent order
objectNames.setSize(cloudNames.size());
objectNames.clear();
objectNames.resize(cloudNames.size());
for (const fileName& localCloudName : localCloudDirs)
{
@ -124,11 +125,11 @@ void Foam::parLagrangianDistributor::findClouds
}
}
// Synchronise objectNames
forAll(objectNames, i)
// Synchronise objectNames (per cloud)
for (wordList& objNames : objectNames)
{
Pstream::combineGather(objectNames[i], ListOps::uniqueEqOp<word>());
Pstream::broadcast(objectNames[i]);
Pstream::combineReduce(objNames, ListOps::uniqueEqOp<word>());
Foam::sort(objNames); // Consistent order
}
}
@ -291,7 +292,7 @@ Foam::parLagrangianDistributor::distributeLagrangianPositions
nsTransPs[sendProcI] = subMap[sendProcI].size();
}
// Send sizes across. Note: blocks.
Pstream::combineAllGather(sizes, Pstream::listEq());
Pstream::combineReduce(sizes, Pstream::listEq());
labelListList constructMap(Pstream::nProcs());
label constructSize = 0;

11
applications/utilities/parallelProcessing/redistributePar/parLagrangianDistributorTemplates.C
View File

@ -51,14 +51,9 @@ Foam::wordList Foam::parLagrangianDistributor::filterObjects
: objects.names<Container>(selectedFields)
);
// Parallel synchronise
// - Combine names from all processors
Pstream::combineGather(fieldNames, ListOps::uniqueEqOp<word>());
Pstream::broadcast(fieldNames);
// Sort for consistent order on all processors
Foam::sort(fieldNames);
// Parallel synchronise - combine names from all processors
Pstream::combineReduce(fieldNames, ListOps::uniqueEqOp<word>());
Foam::sort(fieldNames); // Consistent order
return fieldNames;
}

10
applications/utilities/parallelProcessing/redistributePar/redistributePar.C
View File

@ -132,7 +132,7 @@ void createTimeDirs(const fileName& path)
//Pstream::parRun(oldParRun); // Restore parallel state
masterTimeDirs = localTimeDirs;
}
Pstream::scatter(masterTimeDirs);
Pstream::broadcast(masterTimeDirs);
//DebugVar(masterTimeDirs);
//DebugVar(localTimeDirs);
@ -1168,7 +1168,7 @@ int main(int argc, char *argv[])
bool nfs = true;
{
List<fileName> roots(1, args.rootPath());
Pstream::combineAllGather(roots, ListOps::uniqueEqOp<fileName>());
Pstream::combineReduce(roots, ListOps::uniqueEqOp<fileName>());
nfs = (roots.size() == 1);
}
@ -1203,7 +1203,7 @@ int main(int argc, char *argv[])
}
}
// If master changed to decompose mode make sure all nodes know about it
Pstream::scatter(decompose);
Pstream::broadcast(decompose);
// If running distributed we have problem of new processors not finding
@ -1288,7 +1288,7 @@ int main(int argc, char *argv[])
// use the times list from the master processor
// and select a subset based on the command-line options
instantList timeDirs = timeSelector::select(runTime.times(), args);
Pstream::scatter(timeDirs);
Pstream::broadcast(timeDirs);
if (timeDirs.empty())
{
@ -2067,7 +2067,7 @@ int main(int argc, char *argv[])
args
)[0].value();
}
Pstream::scatter(masterTime);
Pstream::broadcast(masterTime);
Info<< "Setting time to that of master or undecomposed case : "
<< masterTime << endl;
runTime.setTime(masterTime, 0);

2
applications/utilities/postProcessing/dataConversion/foamToEnsight/findCloudFields.H
View File

@ -101,7 +101,7 @@ if (timeDirs.size() && doLagrangian)
{
for (auto& cloudFields : regionCloudFields)
{
Pstream::mapCombineAllGather
Pstream::mapCombineReduce
(
cloudFields,
HashTableOps::plusEqOp<word>()

6
applications/utilities/postProcessing/dataConversion/foamToVTK/convertLagrangian.H
View File

@ -46,11 +46,9 @@ if (doLagrangian)
if (Pstream::parRun())
{
// Synchronise cloud names
Pstream::combineGather(cloudNames, ListOps::uniqueEqOp<word>());
Pstream::broadcast(cloudNames);
Pstream::combineReduce(cloudNames, ListOps::uniqueEqOp<word>());
}
// Consistent order
Foam::sort(cloudNames);
Foam::sort(cloudNames); // Consistent order
for (const word& cloudName : cloudNames)
{

2
applications/utilities/postProcessing/lagrangian/particleTracks/particleTracks.C
View File

@ -186,7 +186,7 @@ int main(int argc, char *argv[])
const label maxNProcs = returnReduce(maxIds.size(), maxOp<label>());
maxIds.resize(maxNProcs, -1);
Pstream::listCombineAllGather(maxIds, maxEqOp<label>());
Pstream::listCombineReduce(maxIds, maxEqOp<label>());
// From ids to count
const labelList numIds = maxIds + 1;

3
applications/utilities/postProcessing/lagrangian/particleTracks/particleTracksSamplerTemplates.C
View File

@ -77,8 +77,7 @@ Foam::label Foam::particleTracksSampler::setTrackFields
if (Pstream::parRun())
{
Pstream::combineGather(fieldNames, ListOps::uniqueEqOp<word>());
Pstream::broadcast(fieldNames);
Pstream::combineReduce(fieldNames, ListOps::uniqueEqOp<word>());
}
for (const word& fieldName : fieldNames)

2
applications/utilities/postProcessing/miscellaneous/postChannel/channelIndexTemplates.C
View File

@ -40,7 +40,7 @@ Foam::Field<T> Foam::channelIndex::regionSum(const Field<T>& cellField) const
}
// Global sum
Pstream::listCombineAllGather(regionField, plusEqOp<T>());
Pstream::listCombineReduce(regionField, plusEqOp<T>());
return regionField;
}

14
applications/utilities/surface/surfaceMeshExtract/surfaceMeshExtract.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2017-2021 OpenCFD Ltd.
Copyright (C) 2017-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -302,6 +302,8 @@ int main(int argc, char *argv[])
Pstream::mapCombineGather(patchSize, plusEqOp<label>());
Pstream::mapCombineGather(zoneSize, plusEqOp<label>());
if (Pstream::master())
{
// Allocate compact numbering for all patches/faceZones
forAllConstIters(patchSize, iter)
{
@ -312,7 +314,7 @@ int main(int argc, char *argv[])
{
compactZoneID.insert(iter.key(), compactZoneID.size());
}
}
Pstream::broadcast(compactZoneID);
@ -391,13 +393,9 @@ int main(int argc, char *argv[])
// Gather all faces
List<faceList> gatheredFaces(Pstream::nProcs());
gatheredFaces[Pstream::myProcNo()] = allBoundary.localFaces();
forAll(gatheredFaces[Pstream::myProcNo()], i)
for (face& f : gatheredFaces[Pstream::myProcNo()])
{
inplaceRenumber
(
pointToGlobal,
gatheredFaces[Pstream::myProcNo()][i]
);
inplaceRenumber(pointToGlobal, f);
}
Pstream::gatherList(gatheredFaces);

2
applications/utilities/surface/surfaceRedistributePar/surfaceRedistributePar.C
View File

@ -252,7 +252,7 @@ int main(int argc, char *argv[])
dict.add("bounds", bbs);
// Scatter patch information
Pstream::scatter(s.patches());
Pstream::broadcast(s.patches());
// Construct distributedTrisurfaceMesh from components
IOobject notReadIO(io);

2
src/OpenFOAM/containers/Lists/SortableList/ParSortableList.C
View File

@ -202,7 +202,7 @@ void Foam::ParSortableList<Type>::sort()
getPivots(sortedPivots, pivots);
}
Pstream::scatter(pivots);
Pstream::broadcast(pivots);
if (debug)
{

6
src/OpenFOAM/db/IOobjectList/IOobjectList.C
View File

@ -90,12 +90,10 @@ void Foam::IOobjectList::syncNames(wordList& objNames)
if (Pstream::parRun())
{
// Synchronize names
Pstream::combineGather(objNames, ListOps::uniqueEqOp<word>());
Pstream::broadcast(objNames);
Pstream::combineReduce(objNames, ListOps::uniqueEqOp<word>());
}
// Consistent order on all processors
Foam::sort(objNames);
Foam::sort(objNames); // Consistent order
}

8
src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
View File

@ -579,7 +579,7 @@ template<class Type> \
ReturnType gFunc(const UList<Type>& f, const label comm) \
{ \
ReturnType res = Func(f); \
reduce(res, rFunc##Op<ReturnType>(), Pstream::msgType(), comm); \
reduce(res, rFunc##Op<ReturnType>(), UPstream::msgType(), comm); \
return res; \
} \
TMP_UNARY_FUNCTION(ReturnType, gFunc)
@ -611,7 +611,7 @@ typename scalarProduct<Type, Type>::type gSumProd
typedef typename scalarProduct<Type, Type>::type prodType;
prodType result = sumProd(f1, f2);
reduce(result, sumOp<prodType>(), Pstream::msgType(), comm);
reduce(result, sumOp<prodType>(), UPstream::msgType(), comm);
return result;
}
@ -624,7 +624,7 @@ Type gSumCmptProd
)
{
Type SumProd = sumCmptProd(f1, f2);
reduce(SumProd, sumOp<Type>(), Pstream::msgType(), comm);
reduce(SumProd, sumOp<Type>(), UPstream::msgType(), comm);
return SumProd;
}
@ -637,7 +637,7 @@ Type gAverage
{
label n = f.size();
Type s = sum(f);
sumReduce(s, n, Pstream::msgType(), comm);
sumReduce(s, n, UPstream::msgType(), comm);
if (n > 0)
{

4
src/OpenFOAM/fields/Fields/Field/FieldOps.C
View File

@ -172,7 +172,7 @@ Foam::Tuple2<T1,T2> Foam::FieldOps::findMinData
result.second() = data[i];
}
Pstream::combineAllGather(result, minFirstEqOp<T1>());
Pstream::combineReduce(result, minFirstEqOp<T1>());
return result;
}
@ -193,7 +193,7 @@ Foam::Tuple2<T1,T2> Foam::FieldOps::findMaxData
result.second() = data[i];
}
Pstream::combineAllGather(result, maxFirstEqOp<T1>());
Pstream::combineReduce(result, maxFirstEqOp<T1>());
return result;
}

4
src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGProcAgglomerations/procFacesGAMGProcAgglomeration/procFacesGAMGProcAgglomeration.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2013-2016 OpenFOAM Foundation
Copyright (C) 2019-2020 OpenCFD Ltd.
Copyright (C) 2019-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -196,7 +196,7 @@ Foam::procFacesGAMGProcAgglomeration::processorAgglomeration
fineToCoarse = labelUIndList(oldToNew, fineToCoarse)();
}
Pstream::scatter(fineToCoarse, Pstream::msgType(), mesh.comm());
Pstream::broadcast(fineToCoarse, mesh.comm());
UPstream::freeCommunicator(singleCellMeshComm);
return tfineToCoarse;

8
src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.C
View File

@ -1934,7 +1934,7 @@ Foam::pointField Foam::globalMeshData::geometricSharedPoints() const
pointField sharedPoints(mesh_.points(), sharedPointLabels());
// Append from all processors, globally consistent
Pstream::combineAllGather(sharedPoints, ListOps::appendEqOp<point>());
Pstream::combineReduce(sharedPoints, ListOps::appendEqOp<point>());
// Merge tolerance
scalar tolDim = matchTol_ * mesh_.bounds().mag();
@ -2730,7 +2730,7 @@ void Foam::globalMeshData::updateMesh()
(
mesh_.nFaces(),
sumOp<label>(),
Pstream::msgType(),
UPstream::msgType(),
comm
);
@ -2743,7 +2743,7 @@ void Foam::globalMeshData::updateMesh()
(
mesh_.nCells(),
sumOp<label>(),
Pstream::msgType(),
UPstream::msgType(),
comm
);
@ -2756,7 +2756,7 @@ void Foam::globalMeshData::updateMesh()
(
mesh_.nPoints(),
sumOp<label>(),
Pstream::msgType(),
UPstream::msgType(),
comm
);

4
src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistributeBase.H
View File

@ -412,7 +412,7 @@ public:
const globalIndex&,
labelList& elements,
List<Map<label>>& compactMap,
const int tag = Pstream::msgType(),
const int tag = UPstream::msgType(),
const label comm = UPstream::worldComm
);
@ -426,7 +426,7 @@ public:
const globalIndex&,
labelListList& cellCells,
List<Map<label>>& compactMap,
const int tag = Pstream::msgType(),
const int tag = UPstream::msgType(),
const label comm = UPstream::worldComm
);

4
src/OpenFOAM/meshes/polyMesh/syncTools/syncToolsTemplates.C
View File

@ -322,7 +322,7 @@ void Foam::syncTools::syncPointMap
}
// Broadcast: send merged values to all
Pstream::scatter(sharedPointValues);
Pstream::broadcast(sharedPointValues);
}
// Merge sharedPointValues (keyed on sharedPointAddr) into
@ -667,7 +667,7 @@ void Foam::syncTools::syncEdgeMap
}
// Broadcast: send merged values to all
Pstream::scatter(sharedEdgeValues);
Pstream::broadcast(sharedEdgeValues);
}

4
src/OpenFOAM/primitives/globalIndexAndTransform/globalIndexAndTransform.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2019 OpenCFD Ltd.
Copyright (C) 2019-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -269,7 +269,7 @@ void Foam::globalIndexAndTransform::determineTransforms()
}
transforms_.transfer(localTransforms);
Pstream::scatter(transforms_);
Pstream::broadcast(transforms_);
}

26
src/OpenFOAM/primitives/random/Random/Random.C
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2017-2020 OpenCFD Ltd.
Copyright (C) 2017-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -143,14 +143,14 @@ Foam::label Foam::Random::position(const label& start, const label& end)
template<>
Foam::scalar Foam::Random::globalSample01()
{
scalar value(-GREAT);
scalar value(0);
if (Pstream::master())
{
value = scalar01();
}
Pstream::scatter(value);
Pstream::broadcast(value);
return value;
}
@ -159,14 +159,14 @@ Foam::scalar Foam::Random::globalSample01()
template<>
Foam::label Foam::Random::globalSample01()
{
label value(labelMin);
label value(0);
if (Pstream::master())
{
value = round(scalar01());
}
Pstream::scatter(value);
Pstream::broadcast(value);
return value;
}
@ -175,14 +175,14 @@ Foam::label Foam::Random::globalSample01()
template<>
Foam::scalar Foam::Random::globalGaussNormal()
{
scalar value(-GREAT);
scalar value(0);
if (Pstream::master())
{
value = GaussNormal<scalar>();
}
Pstream::scatter(value);
Pstream::broadcast(value);
return value;
}
@ -191,14 +191,14 @@ Foam::scalar Foam::Random::globalGaussNormal()
template<>
Foam::label Foam::Random::globalGaussNormal()
{
label value(labelMin);
label value(0);
if (Pstream::master())
{
value = GaussNormal<label>();
}
Pstream::scatter(value);
Pstream::broadcast(value);
return value;
}
@ -211,14 +211,14 @@ Foam::scalar Foam::Random::globalPosition
const scalar& end
)
{
scalar value(-GREAT);
scalar value(0);
if (Pstream::master())
{
value = position<scalar>(start, end);
}
Pstream::scatter(value);
Pstream::broadcast(value);
return value;
}
@ -231,14 +231,14 @@ Foam::label Foam::Random::globalPosition
const label& end
)
{
label value(labelMin);
label value(0);
if (Pstream::master())
{
value = position<label>(start, end);
}
Pstream::scatter(value);
Pstream::broadcast(value);
return value;
}

18
src/OpenFOAM/primitives/random/Random/RandomTemplates.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2015 OpenFOAM Foundation
Copyright (C) 2018 OpenCFD Ltd.
Copyright (C) 2018-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -92,14 +92,14 @@ void Foam::Random::shuffle(UList<Type>& values)
template<class Type>
Type Foam::Random::globalSample01()
{
Type value = -GREAT*pTraits<Type>::one;
Type value(Zero);
if (Pstream::master())
{
value = sample01<Type>();
}
Pstream::scatter(value);
Pstream::broadcast(value);
return value;
}
@ -108,14 +108,14 @@ Type Foam::Random::globalSample01()
template<class Type>
Type Foam::Random::globalGaussNormal()
{
Type value = -GREAT*pTraits<Type>::one;
Type value(Zero);
if (Pstream::master())
{
value = GaussNormal<Type>();
}
Pstream::scatter(value);
Pstream::broadcast(value);
return value;
}
@ -124,14 +124,14 @@ Type Foam::Random::globalGaussNormal()
template<class Type>
Type Foam::Random::globalPosition(const Type& start, const Type& end)
{
Type value = -GREAT*pTraits<Type>::one;
Type value(Zero);
if (Pstream::master())
{
value = position<Type>(start, end);
}
Pstream::scatter(value);
Pstream::broadcast(value);
return value;
}
@ -140,14 +140,12 @@ Type Foam::Random::globalPosition(const Type& start, const Type& end)
template<class Type>
void Foam::Random::globalRandomise01(Type& value)
{
value = -GREAT*pTraits<Type>::one;
if (Pstream::master())
{
value = sample01<Type>();
}
Pstream::scatter(value);
Pstream::broadcast(value);
}

2
src/dynamicMesh/extrudePatchMesh/extrudePatchMesh.C
View File

@ -228,7 +228,7 @@ void Foam::extrudePatchMesh::extrudeMesh(polyPatchList& regionPatches)
}
// Reduce
Pstream::mapCombineAllGather(globalSum, plusEqOp<point>());
Pstream::mapCombineReduce(globalSum, plusEqOp<point>());
forAll(localToGlobalRegion, localRegionI)
{

2
src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
View File

@ -216,7 +216,7 @@ Foam::wordList Foam::fvMeshDistribute::mergeWordList(const wordList& procNames)
}
}
}
Pstream::scatter(mergedNames);
Pstream::broadcast(mergedNames);
return mergedNames;
}

4
src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef8/hexRef8.C
View File

@ -436,7 +436,7 @@ Foam::scalar Foam::hexRef8::getLevel0EdgeLength() const
// Get the minimum per level over all processors. Note minimum so if
// cells are not cubic we use the smallest edge side.
Pstream::listCombineAllGather(typEdgeLenSqr, minEqOp<scalar>());
Pstream::listCombineReduce(typEdgeLenSqr, minEqOp<scalar>());
if (debug)
{
@ -470,7 +470,7 @@ Foam::scalar Foam::hexRef8::getLevel0EdgeLength() const
}
}
Pstream::listCombineAllGather(maxEdgeLenSqr, maxEqOp<scalar>());
Pstream::listCombineReduce(maxEdgeLenSqr, maxEqOp<scalar>());
if (debug)
{

2
src/fileFormats/vtk/file/foamVtkFileWriter.H
View File

@ -263,7 +263,7 @@ public:
virtual bool open
(
const fileName& file,
bool parallel = Pstream::parRun()
bool parallel = UPstream::parRun()
);
//- End the file contents and close the file after writing.

2
src/finiteArea/faMesh/faGlobalMeshData/faGlobalMeshData.C
View File

@ -118,7 +118,7 @@ void Foam::faGlobalMeshData::updateMesh()
sharedPointLabels_ = sharedPointLabels.toc();
Pstream::combineAllGather(globalList, plusEqOp<labelField>());
Pstream::combineReduce(globalList, plusEqOp<labelField>());
nGlobalPoints_ = 0;
for (label i=0; i<globalList.size(); ++i)

2
src/finiteVolume/fields/fvPatchFields/derived/turbulentDFSEMInlet/turbulentDFSEMInletFvPatchVectorField.C
View File

@ -164,7 +164,7 @@ void Foam::turbulentDFSEMInletFvPatchVectorField::initialisePatch()
sumTriMagSf_ = Zero;
sumTriMagSf_[Pstream::myProcNo() + 1] = sum(triMagSf);
Pstream::listCombineAllGather(sumTriMagSf_, maxEqOp<scalar>());
Pstream::listCombineReduce(sumTriMagSf_, maxEqOp<scalar>());
for (label i = 1; i < triMagSf.size(); ++i)
{

2
src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubset.C
View File

@ -1042,7 +1042,7 @@ void Foam::fvMeshSubset::reset
// Get patch sizes (up to nextPatchID).
// Note that up to nextPatchID the globalPatchMap is an identity so
// no need to index through that.
Pstream::listCombineAllGather(globalPatchSizes, plusEqOp<label>());
Pstream::listCombineReduce(globalPatchSizes, plusEqOp<label>());
// Now all processors have all the patchnames.
// Decide: if all processors have the same patch names and size is zero

2
src/functionObjects/field/Curle/Curle.C
View File

@ -223,7 +223,7 @@ bool Foam::functionObjects::Curle::execute()
pDash /= 4*mathematical::pi;
Pstream::listCombineAllGather(pDash, plusEqOp<scalar>());
Pstream::listCombineReduce(pDash, plusEqOp<scalar>());
if (surfaceWriterPtr_)
{

24
src/functionObjects/field/DMD/DMDModels/derived/STDMD/STDMD.C
View File

@ -188,8 +188,8 @@ void Foam::DMDModels::STDMD::compress()
q.subColumn(i) = EVecs.subColumn(permutation[i]);
}
}
Pstream::scatter(G_);
Pstream::scatter(q);
Pstream::broadcast(G_);
Pstream::broadcast(q);
// Update "Q"
Q_ = Q_*q;
@ -357,8 +357,8 @@ reducedKoopmanOperator()
A1 = RxInv_*RMatrix(MatrixTools::pinv(Rx*(G_^Rx)));
Rx.clear();
}
Pstream::scatter(RxInv_);
Pstream::scatter(A1);
Pstream::broadcast(RxInv_);
Pstream::broadcast(A1);
Info<< tab << "Computing A2" << endl;
SMatrix A2(Qupper_ & Qlower_);
@ -452,15 +452,15 @@ bool Foam::DMDModels::STDMD::eigendecomposition(SMatrix& Atilde)
evals_ = cp;
}
}
Pstream::scatter(fail);
Pstream::broadcast(fail);
if (fail)
{
return false;
}
Pstream::scatter(evals_);
Pstream::scatter(evecs_);
Pstream::broadcast(evals_);
Pstream::broadcast(evecs_);
return true;
}
@ -503,8 +503,8 @@ void Foam::DMDModels::STDMD::frequencies()
it = std::find_if(std::next(it), freqs_.cend(), margin);
}
}
Pstream::scatter(freqs_);
Pstream::scatter(freqsi_);
Pstream::broadcast(freqs_);
Pstream::broadcast(freqsi_);
}
@ -567,7 +567,7 @@ void Foam::DMDModels::STDMD::amplitudes()
}
}
}
Pstream::scatter(amps_);
Pstream::broadcast(amps_);
}
@ -648,8 +648,8 @@ void Foam::DMDModels::STDMD::magnitudes()
std::sort(magsi_.begin(), magsi_.end(), descend);
}
Pstream::scatter(mags_);
Pstream::scatter(magsi_);
Pstream::broadcast(mags_);
Pstream::broadcast(magsi_);
}

4
src/functionObjects/field/columnAverage/columnAverageTemplates.C
View File

@ -87,8 +87,8 @@ bool Foam::functionObjects::columnAverage::columnAverageField
}
// Global sum
Pstream::listCombineAllGather(regionField, plusEqOp<Type>());
Pstream::listCombineAllGather(regionCount, plusEqOp<label>());
Pstream::listCombineReduce(regionField, plusEqOp<Type>());
Pstream::listCombineReduce(regionCount, plusEqOp<label>());
forAll(regionField, regioni)
{

2
src/functionObjects/field/externalCoupled/externalCoupled.C
View File

@ -430,7 +430,7 @@ void Foam::functionObjects::externalCoupled::initCoupling()
|| isFile(dir/"patchFaces");
}
Pstream::scatter(geomExists);
Pstream::broadcast(geomExists);
if (!geomExists)
{

4
src/functionObjects/field/extractEulerianParticles/extractEulerianParticles/extractEulerianParticles.C
View File

@ -333,7 +333,7 @@ void Foam::functionObjects::extractEulerianParticles::calculateAddressing
// Create map from new regions to slots in particles list
// - filter through new-to-new addressing to identify new particles
Pstream::listCombineAllGather(newToNewRegion, maxEqOp<label>());
Pstream::listCombineReduce(newToNewRegion, maxEqOp<label>());
label nParticle = -1;
labelHashSet newRegions;
@ -352,7 +352,7 @@ void Foam::functionObjects::extractEulerianParticles::calculateAddressing
// Accumulate old region data or create a new particle if there is no
// mapping from the old-to-new region
Pstream::listCombineAllGather(oldToNewRegion, maxEqOp<label>());
Pstream::listCombineReduce(oldToNewRegion, maxEqOp<label>());
List<eulerianParticle> newParticles(newRegionToParticleMap.size());
forAll(oldToNewRegion, oldRegioni)

4
src/functionObjects/field/regionSizeDistribution/regionSizeDistribution.C
View File

@ -66,7 +66,7 @@ static Map<Type> regionSum(const regionSplit& regions, const Field<Type>& fld)
regionToSum(regioni, Type(Zero)) += fld[celli];
}
Pstream::mapCombineAllGather(regionToSum, plusEqOp<Type>());
Pstream::mapCombineReduce(regionToSum, plusEqOp<Type>());
return regionToSum;
}
@ -214,7 +214,7 @@ Foam::functionObjects::regionSizeDistribution::findPatchRegions
// Make sure all the processors have the same set of regions
Pstream::mapCombineAllGather(patchRegions, minEqOp<label>());
Pstream::mapCombineReduce(patchRegions, minEqOp<label>());
return patchRegions;
}

2
src/functionObjects/field/streamLine/streamLineBase.C
View File

@ -800,7 +800,7 @@ bool Foam::functionObjects::streamLineBase::writeToFile()
// File names generated on the master but setProperty needed everywher
Pstream::scatter(outputFileNames);
Pstream::broadcast(outputFileNames);
forAllConstIters(outputFileNames, iter)
{

4
src/functionObjects/forces/propellerInfo/propellerInfo.C
View File

@ -470,7 +470,7 @@ void Foam::functionObjects::propellerInfo::updateSampleDiskCells()
}
}
Pstream::listCombineAllGather(pointMask_, orEqOp<bool>());
Pstream::listCombineReduce(pointMask_, orEqOp<bool>());
}
@ -785,7 +785,7 @@ Foam::tmp<Foam::Field<Type>> Foam::functionObjects::propellerInfo::interpolate
}
}
Pstream::listCombineAllGather(field, maxEqOp<Type>());
Pstream::listCombineReduce(field, maxEqOp<Type>());
return tfield;
}

9
src/functionObjects/lagrangian/vtkCloud/vtkCloudTemplates.C
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2018-2021 OpenCFD Ltd.
Copyright (C) 2018-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -56,11 +56,8 @@ Foam::wordList Foam::functionObjects::vtkCloud::writeFields
// Thus need to resolve names between all processors.
wordList fieldNames(obrTmp.names<IOField<Type>>());
Pstream::combineGather(fieldNames, ListOps::uniqueEqOp<word>());
Pstream::broadcast(fieldNames);
// Consistent order on all processors
Foam::sort(fieldNames);
Pstream::combineReduce(fieldNames, ListOps::uniqueEqOp<word>());
Foam::sort(fieldNames); // Consistent order
for (const word& fieldName : fieldNames)
{

8
src/functionObjects/utilities/abort/abort.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2016-2021 OpenCFD Ltd.
Copyright (C) 2016-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -218,9 +218,9 @@ bool Foam::functionObjects::abort::execute()
}
}
// Send to slaves. Also acts as an MPI barrier
label intAction(action);
Pstream::scatter(intAction);
// Send to sub-ranks. Also acts as an MPI barrier
int intAction(action);
Pstream::broadcast(intAction);
action = Time::stopAtControls(intAction);

2
src/functionObjects/utilities/areaWrite/areaWrite.C
View File

@ -267,7 +267,7 @@ bool Foam::areaWrite::write()
}
// Parallel consistency (no-op in serial)
Pstream::mapCombineAllGather(selected, HashSetOps::plusEqOp<word>());
Pstream::mapCombineReduce(selected, HashSetOps::plusEqOp<word>());
missed.clear();

12
src/functionObjects/utilities/areaWrite/areaWriteTemplates.C
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2019-2021 OpenCFD Ltd.
Copyright (C) 2019-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -73,16 +73,12 @@ void Foam::areaWrite::performAction
{
fieldNames = areaMesh.thisDb().names<GeoField>(fieldSelection_);
// With syncPar
// Synchronize names
if (Pstream::parRun())
{
// Synchronize names
Pstream::combineGather(fieldNames, ListOps::uniqueEqOp<word>());
Pstream::broadcast(fieldNames);
Pstream::combineReduce(fieldNames, ListOps::uniqueEqOp<word>());
}
// Sort for consistent order on all processors
Foam::sort(fieldNames);
Foam::sort(fieldNames); // Consistent order
}
for (const word& fieldName : fieldNames)

1
src/functionObjects/utilities/parProfiling/parProfiling.C
View File

@ -27,7 +27,6 @@ License
#include "parProfiling.H"
#include "addToRunTimeSelectionTable.H"
#include "UPstream.H"
#include "Pstream.H"
#include "PstreamReduceOps.H"
#include "profilingPstream.H"

4
src/functionObjects/utilities/systemCall/systemCall.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2018-2020 OpenCFD Ltd.
Copyright (C) 2018-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -73,7 +73,7 @@ Foam::label Foam::functionObjects::systemCall::dispatch(const stringList& calls)
// MPI barrier
if (masterOnly_)
{
Pstream::scatter(nCalls);
Pstream::broadcast(nCalls);
}
return nCalls;

2
src/lagrangian/basic/Cloud/CloudIO.C
View File

@ -104,7 +104,7 @@ void Foam::Cloud<ParticleType>::writeCloudUniformProperties() const
labelList np(Pstream::nProcs(), Zero);
np[Pstream::myProcNo()] = ParticleType::particleCount_;
Pstream::listCombineAllGather(np, maxEqOp<label>());
Pstream::listCombineReduce(np, maxEqOp<label>());
uniformPropsDict.add
(

3
src/lagrangian/intermediate/submodels/CloudFunctionObjects/ParticleZoneInfo/ParticleZoneInfo.C
View File

@ -361,8 +361,7 @@ void Foam::ParticleZoneInfo<CloudType>::write()
{
// Find number of particles per proc
labelList allMaxIDs(maxIDs_);
Pstream::listCombineGather(allMaxIDs, maxEqOp<label>());
Pstream::broadcast(allMaxIDs);
Pstream::listCombineReduce(allMaxIDs, maxEqOp<label>());
// Combine into single list
label n = returnReduce(data_.size(), sumOp<label>());

2
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/CellZoneInjection/CellZoneInjection.C
View File

@ -120,7 +120,7 @@ void Foam::CellZoneInjection<CloudType>::setPositions
globalPositions.localStart(Pstream::myProcNo())
) = positions;
Pstream::listCombineAllGather(allPositions, minEqOp<point>());
Pstream::listCombineReduce(allPositions, minEqOp<point>());
// Gather local cell tet and tet-point Ids, but leave non-local ids set -1
SubList<label>

4
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/InflationInjection/InflationInjection.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2015-2021 OpenCFD Ltd.
Copyright (C) 2015-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -417,7 +417,7 @@ Foam::label Foam::InflationInjection<CloudType>::parcelsToInject
newParticles_ = combinedNewParticles;
}
Pstream::scatter(newParticles_);
Pstream::broadcast(newParticles_);
}
return newParticles_.size();

17
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/InjectedParticleDistributionInjection/InjectedParticleDistributionInjection.C
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2015-2020 OpenCFD Ltd.
Copyright (C) 2015-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -62,8 +62,7 @@ void Foam::InjectedParticleDistributionInjection<CloudType>::initialise()
{
List<List<label>> procTag(Pstream::nProcs());
procTag[Pstream::myProcNo()].transfer(tag);
Pstream::gatherList(procTag);
Pstream::scatterList(procTag);
Pstream::allGatherList(procTag);
tag =
ListListOps::combine<List<label>>
(
@ -72,8 +71,7 @@ void Foam::InjectedParticleDistributionInjection<CloudType>::initialise()
List<List<point>> procPosition(Pstream::nProcs());
procPosition[Pstream::myProcNo()].transfer(position);
Pstream::gatherList(procPosition);
Pstream::scatterList(procPosition);
Pstream::allGatherList(procPosition);
position =
ListListOps::combine<List<point>>
(
@ -82,8 +80,7 @@ void Foam::InjectedParticleDistributionInjection<CloudType>::initialise()
List<List<vector>> procU(Pstream::nProcs());
procU[Pstream::myProcNo()].transfer(U);
Pstream::gatherList(procU);
Pstream::scatterList(procU);
Pstream::allGatherList(procU);
U =
ListListOps::combine<List<vector>>
(
@ -92,8 +89,7 @@ void Foam::InjectedParticleDistributionInjection<CloudType>::initialise()
List<List<scalar>> procSOI(Pstream::nProcs());
procSOI[Pstream::myProcNo()].transfer(soi);
Pstream::gatherList(procSOI);
Pstream::scatterList(procSOI);
Pstream::allGatherList(procSOI);
soi =
ListListOps::combine<List<scalar>>
(
@ -102,8 +98,7 @@ void Foam::InjectedParticleDistributionInjection<CloudType>::initialise()
List<List<scalar>> procD(Pstream::nProcs());
procD[Pstream::myProcNo()].transfer(d);
Pstream::gatherList(procD);
Pstream::scatterList(procD);
Pstream::allGatherList(procD);
d =
ListListOps::combine<List<scalar>>
(

14
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/InjectedParticleInjection/InjectedParticleInjection.C
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2015-2020 OpenCFD Ltd.
Copyright (C) 2015-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -62,8 +62,7 @@ void Foam::InjectedParticleInjection<CloudType>::initialise()
{
List<List<scalar>> procTime(Pstream::nProcs());
procTime[Pstream::myProcNo()].transfer(time);
Pstream::gatherList(procTime);
Pstream::scatterList(procTime);
Pstream::allGatherList(procTime);
time =
ListListOps::combine<List<scalar>>
(
@ -72,8 +71,7 @@ void Foam::InjectedParticleInjection<CloudType>::initialise()
List<List<point>> procPosition(Pstream::nProcs());
procPosition[Pstream::myProcNo()].transfer(position);
Pstream::gatherList(procPosition);
Pstream::scatterList(procPosition);
Pstream::allGatherList(procPosition);
position =
ListListOps::combine<List<point>>
(
@ -82,8 +80,7 @@ void Foam::InjectedParticleInjection<CloudType>::initialise()
List<List<scalar>> procD(Pstream::nProcs());
procD[Pstream::myProcNo()].transfer(diameter);
Pstream::gatherList(procD);
Pstream::scatterList(procD);
Pstream::allGatherList(procD);
diameter =
ListListOps::combine<List<scalar>>
(
@ -92,8 +89,7 @@ void Foam::InjectedParticleInjection<CloudType>::initialise()
List<List<vector>> procU(Pstream::nProcs());
procU[Pstream::myProcNo()].transfer(U);
Pstream::gatherList(procU);
Pstream::scatterList(procU);
Pstream::allGatherList(procU);
U =
ListListOps::combine<List<vector>>
(

2
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/PatchInjection/patchInjectionBase.C
View File

@ -114,7 +114,7 @@ void Foam::patchInjectionBase::updateMesh(const polyMesh& mesh)
sumTriMagSf_ = Zero;
sumTriMagSf_[Pstream::myProcNo() + 1] = sum(triMagSf);
Pstream::listCombineAllGather(sumTriMagSf_, maxEqOp<scalar>());
Pstream::listCombineReduce(sumTriMagSf_, maxEqOp<scalar>());
for (label i = 1; i < triMagSf.size(); i++)
{

2
src/lagrangian/spray/clouds/Templates/SprayCloud/SprayCloudI.H
View File

@ -181,7 +181,7 @@ inline Foam::scalar Foam::SprayCloud<CloudType>::penetration
}
}
Pstream::scatter(distance);
Pstream::broadcast(distance);
return distance;
}

6
src/lumpedPointMotion/movement/lumpedPointMovement.C
View File

@ -880,7 +880,7 @@ Foam::List<Foam::scalar> Foam::lumpedPointMovement::areas
}
}
Pstream::listCombineAllGather(zoneAreas, plusEqOp<scalar>());
Pstream::listCombineReduce(zoneAreas, plusEqOp<scalar>());
return zoneAreas;
}
@ -1008,8 +1008,8 @@ bool Foam::lumpedPointMovement::forcesAndMoments
Info<<"No pressure field" << endl;
}
Pstream::listCombineAllGather(forces, plusEqOp<vector>());
Pstream::listCombineAllGather(moments, plusEqOp<vector>());
Pstream::listCombineReduce(forces, plusEqOp<vector>());
Pstream::listCombineReduce(moments, plusEqOp<vector>());
return true;
}

2
src/mesh/snappyHexMesh/meshRefinement/meshRefinement.C
View File

@ -1973,7 +1973,7 @@ Foam::autoPtr<Foam::mapDistributePolyMesh> Foam::meshRefinement::balance
labelList nProcCells(distributor.countCells(distribution));
Pout<< "Wanted distribution:" << nProcCells << endl;
Pstream::listCombineAllGather(nProcCells, plusEqOp<label>());
Pstream::listCombineReduce(nProcCells, plusEqOp<label>());
Pout<< "Wanted resulting decomposition:" << endl;
forAll(nProcCells, proci)

10
src/mesh/snappyHexMesh/meshRefinement/meshRefinementBaffles.C
View File

@ -823,7 +823,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::createZoneBaffles
if (nTotalBaffles > 0)
{
Pstream::listCombineAllGather(nBaffles, plusEqOp<label>());
Pstream::listCombineReduce(nBaffles, plusEqOp<label>());
Info<< nl
<< setf(ios_base::left)
@ -1953,7 +1953,7 @@ void Foam::meshRefinement::findCellZoneTopo
// - region numbers are identical on all processors
// - keepRegion is identical ,,
// - cellZones are identical ,,
Pstream::listCombineAllGather(regionToCellZone, maxEqOp<label>());
Pstream::listCombineReduce(regionToCellZone, maxEqOp<label>());
// Find the region containing the keepPoint
@ -2003,7 +2003,7 @@ void Foam::meshRefinement::findCellZoneTopo
// - cellZones are identical ,,
// This done at top of loop to account for geometric matching
// not being synchronised.
Pstream::listCombineAllGather(regionToCellZone, maxEqOp<label>());
Pstream::listCombineReduce(regionToCellZone, maxEqOp<label>());
bool changed = false;
@ -5862,7 +5862,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
// 2.Combine faceZoneNames allocated on different processors
Pstream::mapCombineAllGather(zonesToFaceZone, eqOp<word>());
Pstream::mapCombineReduce(zonesToFaceZone, eqOp<word>());
// 3. Allocate faceZones from (now synchronised) faceZoneNames
@ -6085,7 +6085,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
nPosOrientation.find(faceToConnectedZone[faceI])() += n;
}
}
Pstream::mapCombineAllGather(nPosOrientation, plusEqOp<label>());
Pstream::mapCombineReduce(nPosOrientation, plusEqOp<label>());
Info<< "Split " << nFreeStanding << " free-standing zone faces"

6
src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyRefineDriver.C
View File

@ -3263,9 +3263,9 @@ void Foam::snappyRefineDriver::deleteSmallRegions
nCellsPerRegion[regioni]++;
nCellsPerZone[zonei]++;
}
Pstream::listCombineAllGather(nCellsPerRegion, plusEqOp<label>());
Pstream::listCombineAllGather(regionToZone, maxEqOp<label>());
Pstream::listCombineAllGather(nCellsPerZone, plusEqOp<label>());
Pstream::listCombineReduce(nCellsPerRegion, plusEqOp<label>());
Pstream::listCombineReduce(regionToZone, maxEqOp<label>());
Pstream::listCombineReduce(nCellsPerZone, plusEqOp<label>());
// Mark small regions. Note that all processors have the same information

12
src/meshTools/coupling/externalFileCoupler.C
View File

@ -282,9 +282,9 @@ Foam::externalFileCoupler::waitForMaster() const
}
}
label intAction(action);
Pstream::scatter(intAction); // Also acts as MPI barrier
// Send to sub-ranks. Also acts as an MPI barrier
int intAction(action);
Pstream::broadcast(intAction);
return Time::stopAtControls(intAction);
}
@ -326,9 +326,9 @@ Foam::externalFileCoupler::waitForSlave() const
Log << type() << ": found lock file " << lck << endl;
}
label intAction(action);
Pstream::scatter(intAction); // Also acts as MPI barrier
// Send to sub-ranks. Also acts as an MPI barrier
int intAction(action);
Pstream::broadcast(intAction);
return Time::stopAtControls(intAction);
}

2
src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBase.C
View File

@ -668,7 +668,7 @@ void Foam::mappedPatchBase::findSamples
// Find nearest - globally consistent
Pstream::listCombineAllGather
Pstream::listCombineReduce
(
nearest,
nearestWorldEqOp(),

9
src/meshTools/multiWorld/multiWorldConnectionsObject.C
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2021 OpenCFD Ltd.
Copyright (C) 2021-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -241,12 +241,7 @@ void Foam::multiWorldConnections::createComms()
if (Pstream::parRun())
{
Pstream::combineGather
(
allConnections,
worldConnectBitOrEq()
);
Pstream::scatter(allConnections);
Pstream::combineReduce(allConnections, worldConnectBitOrEq());
}
// Check for mismatched connections

8
src/meshTools/output/vtk/topoSet/foamVtkWriteTopoSet.H
View File

@ -70,7 +70,7 @@ bool writeTopoSet
const topoSet& set,
const vtk::outputOptions opts,
const fileName& file,
bool parallel = Pstream::parRun()
bool parallel = UPstream::parRun()
);
@ -83,7 +83,7 @@ bool writeFaceSet
const faceSet& set,
const vtk::outputOptions opts,
const fileName& file,
bool parallel = Pstream::parRun()
bool parallel = UPstream::parRun()
);
@ -96,7 +96,7 @@ bool writeCellSetFaces
const cellSet& set,
const vtk::outputOptions opts,
const fileName& file,
bool parallel = Pstream::parRun()
bool parallel = UPstream::parRun()
);
@ -109,7 +109,7 @@ bool writePointSet
const pointSet& set,
const vtk::outputOptions opts,
const fileName& file,
bool parallel = Pstream::parRun()
bool parallel = UPstream::parRun()
);

2
src/meshTools/regionSplit2D/regionSplit2D.C
View File

@ -139,7 +139,7 @@ Foam::regionSplit2D::regionSplit2D
// Ensure regionToCompactAddr consistent across all processors
// - not concerned about the op (keys are unique)
// - map size will be the number of regions in the set of faces
Pstream::mapCombineAllGather(regionToCompactAddr, minEqOp<label>());
Pstream::mapCombineReduce(regionToCompactAddr, minEqOp<label>());
nRegions_ = regionToCompactAddr.size();

4
src/meshTools/searchableSurfaces/triSurfaceMesh/triSurfaceMesh.C
View File

@ -462,7 +462,7 @@ Foam::triSurfaceMesh::triSurfaceMesh(const IOobject& io, const readAction r)
triSurface s2(actualFile);
triSurface::transfer(s2);
}
Pstream::scatter(triSurface::patches());
Pstream::broadcast(triSurface::patches());
if (debug)
{
Pout<< "triSurfaceMesh(const IOobject& io) :"
@ -587,7 +587,7 @@ Foam::triSurfaceMesh::triSurfaceMesh
triSurface s2(actualFile, surfType, scaleFactor);
triSurface::transfer(s2);
}
Pstream::scatter(triSurface::patches());
Pstream::broadcast(triSurface::patches());
if (debug)
{
Pout<< "triSurfaceMesh(const IOobject& io) :"

2
src/meshTools/topoSet/cellSources/nearestToCell/nearestToCell.C
View File

@ -85,7 +85,7 @@ void Foam::nearestToCell::combine(topoSet& set, const bool add) const
);
}
Pstream::listCombineAllGather(nearest, mappedPatchBase::nearestEqOp());
Pstream::listCombineReduce(nearest, mappedPatchBase::nearestEqOp());
for (const auto& near : nearest)
{

2
src/meshTools/topoSet/faceSources/regionToFace/regionToFace.C
View File

@ -176,7 +176,7 @@ void Foam::regionToFace::combine(topoSet& set, const bool add) const
}
// Globally reduce
Pstream::combineAllGather(ni, mappedPatchBase::nearestEqOp());
Pstream::combineReduce(ni, mappedPatchBase::nearestEqOp());
if (verbose_)
{

4
src/meshTools/topoSet/faceZoneSources/planeToFaceZone/planeToFaceZone.C
View File

@ -217,7 +217,7 @@ void Foam::planeToFaceZone::combine(faceZoneSet& fzSet, const bool add) const
regionRegions[regioni].unset(regioni);
}
}
Pstream::listCombineAllGather(regionRegions, bitOrEqOp<bitSet>());
Pstream::listCombineReduce(regionRegions, bitOrEqOp<bitSet>());
// Collapse the region connections into a map between each region
// and the lowest numbered region that it connects to
@ -258,7 +258,7 @@ void Foam::planeToFaceZone::combine(faceZoneSet& fzSet, const bool add) const
{
++ regionNFaces[regioni];
}
Pstream::listCombineAllGather(regionNFaces, plusEqOp<label>());
Pstream::listCombineReduce(regionNFaces, plusEqOp<label>());
Info<< " Found " << nRegions << " contiguous regions with "
<< regionNFaces << " faces" << endl;

2
src/meshTools/topoSet/pointSources/nearestToPoint/nearestToPoint.C
View File

@ -104,7 +104,7 @@ void Foam::nearestToPoint::combine(topoSet& set, const bool add) const
}
Pstream::listCombineAllGather(nearest, mappedPatchBase::nearestEqOp());
Pstream::listCombineReduce(nearest, mappedPatchBase::nearestEqOp());
for (const auto& near : nearest)
{

4
src/optimisation/adjointOptimisation/adjoint/parameterization/NURBS/NURBS3DVolume/NURBS3DVolume/NURBS3DVolume.C
View File

@ -1010,7 +1010,7 @@ Foam::vectorField Foam::NURBS3DVolume::computeControlPointSensitivities
}
// Sum contributions from all processors
Pstream::listCombineAllGather(controlPointDerivs, plusEqOp<vector>());
Pstream::listCombineReduce(controlPointDerivs, plusEqOp<vector>());
return controlPointDerivs;
}
@ -1095,7 +1095,7 @@ Foam::vectorField Foam::NURBS3DVolume::computeControlPointSensitivities
}
}
// Sum contributions from all processors
Pstream::listCombineAllGather(controlPointDerivs, plusEqOp<vector>());
Pstream::listCombineReduce(controlPointDerivs, plusEqOp<vector>());
return controlPointDerivs;
}

4
src/overset/cellCellStencil/cellVolumeWeight/cellVolumeWeightCellCellStencil.C
View File

@ -377,7 +377,7 @@ void Foam::cellCellStencils::cellVolumeWeight::findHoles
{
// Synchronise region status on processors
// (could instead swap status through processor patches)
Pstream::listCombineAllGather(regionType, maxEqOp<label>());
Pstream::listCombineReduce(regionType, maxEqOp<label>());
// Communicate region status through interpolative cells
labelList cellRegionType(labelUIndList(regionType, cellRegion));
@ -754,7 +754,7 @@ bool Foam::cellCellStencils::cellVolumeWeight::update()
{
nCellsPerZone[zoneID[cellI]]++;
}
Pstream::listCombineAllGather(nCellsPerZone, plusEqOp<label>());
Pstream::listCombineReduce(nCellsPerZone, plusEqOp<label>());
Info<< typeName << " : detected " << nZones

4
src/overset/cellCellStencil/inverseDistance/inverseDistanceCellCellStencil.C
View File

@ -1118,7 +1118,7 @@ void Foam::cellCellStencils::inverseDistance::findHoles
{
// Synchronise region status on processors
// (could instead swap status through processor patches)
Pstream::listCombineAllGather(regionType, maxEqOp<label>());
Pstream::listCombineReduce(regionType, maxEqOp<label>());
DebugInfo<< FUNCTION_NAME << " : Gathered region type" << endl;
@ -1722,7 +1722,7 @@ bool Foam::cellCellStencils::inverseDistance::update()
{
nCellsPerZone[zoneID[cellI]]++;
}
Pstream::listCombineAllGather(nCellsPerZone, plusEqOp<label>());
Pstream::listCombineReduce(nCellsPerZone, plusEqOp<label>());
const boundBox& allBb(mesh_.bounds());

2
src/overset/cellCellStencil/trackingInverseDistance/trackingInverseDistanceCellCellStencil.C
View File

@ -517,7 +517,7 @@ Foam::cellCellStencils::trackingInverseDistance::trackingInverseDistance
{
nCellsPerZone[zoneID[celli]]++;
}
Pstream::listCombineAllGather(nCellsPerZone, plusEqOp<label>());
Pstream::listCombineReduce(nCellsPerZone, plusEqOp<label>());
meshParts_.setSize(nZones);
forAll(meshParts_, zonei)

4
src/overset/regionsToCell/findRefCells.C
View File

@ -68,7 +68,7 @@ void Foam::setRefCells
}
}
Pstream::listCombineAllGather(regionNeedReference, orEqOp<bool>());
Pstream::listCombineReduce(regionNeedReference, orEqOp<bool>());
}
@ -188,7 +188,7 @@ void Foam::setRefCells
}
}
Pstream::listCombineAllGather(hasRef, plusEqOp<label>());
Pstream::listCombineReduce(hasRef, plusEqOp<label>());
forAll(hasRef, regionI)
{

4
src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.C
View File

@ -480,7 +480,7 @@ void Foam::decompositionMethod::calcCellCells
// Create global cell numbers
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
const globalIndex globalAgglom(nLocalCoarse, Pstream::worldComm, parallel);
const globalIndex globalAgglom(nLocalCoarse, UPstream::worldComm, parallel);
// Get agglomerate owner on other side of coupled faces
@ -673,7 +673,7 @@ void Foam::decompositionMethod::calcCellCells
// Create global cell numbers
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
const globalIndex globalAgglom(nLocalCoarse, Pstream::worldComm, parallel);
const globalIndex globalAgglom(nLocalCoarse, UPstream::worldComm, parallel);
// Get agglomerate owner on other side of coupled faces

8
src/parallel/decompose/decompositionMethods/multiLevelDecomp/multiLevelDecomp.C
View File

@ -419,11 +419,7 @@ void Foam::multiLevelDecomp::decompose
label nPoints = returnReduce(domainPoints.size(), sumOp<label>());
Pstream::listCombineAllGather
(
nOutsideConnections,
plusEqOp<label>()
);
Pstream::listCombineReduce(nOutsideConnections, plusEqOp<label>());
label nPatches = 0;
label nFaces = 0;
for (const label nConnect : nOutsideConnections)
@ -530,7 +526,7 @@ void Foam::multiLevelDecomp::decompose
}
reduce(nPoints, sumOp<label>());
Pstream::listCombineAllGather
Pstream::listCombineReduce
(
nOutsideConnections,
plusEqOp<label>()

19
src/parallel/reconstruct/faReconstruct/faMeshReconstructor.C
View File

@ -101,7 +101,7 @@ void Foam::faMeshReconstructor::calcAddressing
? 0
: singlePatchFaceLabels_.first()
);
Pstream::scatter(patchFirstMeshfacei);
Pstream::broadcast(patchFirstMeshfacei);
for (label& facei : faFaceProcAddr_)
{
@ -169,7 +169,7 @@ void Foam::faMeshReconstructor::calcAddressing
}
// Broadcast the same information everywhere
Pstream::scatter(singlePatchFaceLabels_);
Pstream::broadcast(singlePatchFaceLabels_);
// ------------------
@ -283,7 +283,7 @@ void Foam::faMeshReconstructor::calcAddressing
mpm[mp[i]] = i;
}
}
Pstream::scatter(mpm);
Pstream::broadcast(mpm);
// Rewrite pointToGlobal according to the correct point order
for (label& pointi : pointToGlobal)
@ -299,8 +299,8 @@ void Foam::faMeshReconstructor::calcAddressing
}
// Broadcast the same information everywhere
Pstream::scatter(singlePatchFaces_);
Pstream::scatter(singlePatchPoints_);
Pstream::broadcast(singlePatchFaces_);
Pstream::broadcast(singlePatchPoints_);
// Now have enough global information to determine global edge mappings
@ -383,13 +383,8 @@ void Foam::faMeshReconstructor::calcAddressing
// OR patchEdgeLabels =
// UIndirectList<label>(faEdgeProcAddr_, fap.edgeLabels());
// Collect from all processors
Pstream::combineAllGather
(
patchEdgeLabels,
ListOps::appendEqOp<label>()
);
// Combine from all processors
Pstream::combineReduce(patchEdgeLabels, ListOps::appendEqOp<label>());
// Sorted order will be the original non-decomposed order
Foam::sort(patchEdgeLabels);

2
src/regionModels/regionModel/singleLayerRegion/singleLayerRegion.C
View File

@ -142,7 +142,7 @@ void Foam::regionModels::singleLayerRegion::initialise()
}
}
Pstream::listCombineAllGather(passivePatchIDs_, maxEqOp<label>());
Pstream::listCombineReduce(passivePatchIDs_, maxEqOp<label>());
magSf.field() = 0.5*(magSf + passiveMagSf);
magSf.correctBoundaryConditions();

2
src/rigidBodyDynamics/rigidBodyMotion/rigidBodyMotion.C
View File

@ -190,7 +190,7 @@ void Foam::RBD::rigidBodyMotion::solve
solver_->solve(tau, fx);
}
Pstream::scatter(motionState_);
Pstream::broadcast(motionState_);
// Update the body-state to correspond to the current joint-state
forwardDynamicsCorrection(motionState_);

2
src/sampling/probes/patchProbes.C
View File

@ -166,7 +166,7 @@ void Foam::patchProbes::findElements(const fvMesh& mesh)
// Find nearest - globally consistent
Pstream::listCombineAllGather(nearest, mappedPatchBase::nearestEqOp());
Pstream::listCombineReduce(nearest, mappedPatchBase::nearestEqOp());
oldPoints_.resize(this->size());

4
src/sampling/probes/patchProbesTemplates.C
View File

@ -111,7 +111,7 @@ Foam::patchProbes::sample(const VolumeField<Type>& vField) const
}
}
Pstream::listCombineAllGather(values, isNotEqOp<Type>());
Pstream::listCombineReduce(values, isNotEqOp<Type>());
return tvalues;
}
@ -141,7 +141,7 @@ Foam::patchProbes::sample(const SurfaceField<Type>& sField) const
}
}
Pstream::listCombineAllGather(values, isNotEqOp<Type>());
Pstream::listCombineReduce(values, isNotEqOp<Type>());
return tvalues;
}

4
src/sampling/probes/probesTemplates.C
View File

@ -225,7 +225,7 @@ Foam::probes::sample(const VolumeField<Type>& vField) const
}
}
Pstream::listCombineAllGather(values, isNotEqOp<Type>());
Pstream::listCombineReduce(values, isNotEqOp<Type>());
return tvalues;
}
@ -248,7 +248,7 @@ Foam::probes::sample(const SurfaceField<Type>& sField) const
}
}
Pstream::listCombineAllGather(values, isNotEqOp<Type>());
Pstream::listCombineReduce(values, isNotEqOp<Type>());
return tvalues;
}

4
src/sampling/sampledSet/cloud/cloudSet.C
View File

@ -84,8 +84,8 @@ void Foam::cloudSet::calcSamples
minFoundProc[i] = foundProc[i];
}
}
Pstream::listCombineAllGather(minFoundProc, minEqOp<label>());
Pstream::listCombineAllGather(maxFoundProc, maxEqOp<label>());
Pstream::listCombineReduce(minFoundProc, minEqOp<label>());
Pstream::listCombineReduce(maxFoundProc, maxEqOp<label>());
DynamicField<point> missingPoints(sampleCoords_.size());

2
src/sampling/sampledSet/patchCloud/patchCloudSet.C
View File

@ -155,7 +155,7 @@ void Foam::patchCloudSet::calcSamples
// Find nearest - globally consistent
Pstream::listCombineAllGather(nearest, mappedPatchBase::nearestEqOp());
Pstream::listCombineReduce(nearest, mappedPatchBase::nearestEqOp());
if (debug && Pstream::master())

6
src/sampling/sampledSet/patchSeed/patchSeedSet.C
View File

@ -178,11 +178,7 @@ void Foam::patchSeedSet::calcSamples
// 2. Reduce on master. Select nearest processor.
// Find nearest - globally consistent
Pstream::listCombineAllGather
(
nearest,
mappedPatchBase::nearestEqOp()
);
Pstream::listCombineReduce(nearest, mappedPatchBase::nearestEqOp());
// 3. Pick up my local faces that have won

2
src/sampling/sampledSet/sampledSets/sampledSets.C
View File

@ -196,7 +196,7 @@ Foam::IOobjectList Foam::sampledSets::preCheckFields(unsigned request)
// Parallel consistency (no-op in serial)
// Probably not needed...
/// Pstream::mapCombineAllGather(selected, HashSetOps::plusEqOp<word>());
/// Pstream::mapCombineReduce(selected, HashSetOps::plusEqOp<word>());
DynamicList<label> missed(fieldSelection_.size());

2
src/sampling/sampledSet/shortestPath/shortestPathSet.C
View File

@ -264,7 +264,7 @@ void Foam::shortestPathSet::sync
celli,
Tuple2<point, bool>(origin, findMinDistance)
);
Pstream::combineAllGather
Pstream::combineReduce
(
searchData,
[](ProcData& x, const ProcData& y)

2
src/sampling/sampledSurface/sampledMeshedSurface/sampledMeshedSurface.C
View File

@ -227,7 +227,7 @@ bool Foam::sampledMeshedSurface::update(const meshSearch& meshSearcher)
// See which processor has the nearest. Mark and subset
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Pstream::listCombineAllGather(nearest, minFirstEqOp<scalar>{});
Pstream::listCombineReduce(nearest, minFirstEqOp<scalar>{});
labelList cellOrFaceLabels(fc.size(), -1);

2
src/sampling/sampledSurface/sampledSurfaces/sampledSurfaces.C
View File

@ -119,7 +119,7 @@ Foam::IOobjectList Foam::sampledSurfaces::preCheckFields()
}
// Parallel consistency (no-op in serial)
Pstream::mapCombineAllGather(selected, HashSetOps::plusEqOp<word>());
Pstream::mapCombineReduce(selected, HashSetOps::plusEqOp<word>());
DynamicList<label> missed(fieldSelection_.size());

2
src/sampling/surface/isoSurface/isoSurfacePoint.C
View File

@ -262,7 +262,7 @@ void Foam::isoSurfacePoint::syncUnseparatedPoints
}
// Globally consistent
Pstream::listCombineAllGather(sharedPts, minEqOp<point>());
Pstream::listCombineReduce(sharedPts, minEqOp<point>());
// Now we will all have the same information. Merge it back with
// my local information.

2
src/sixDoFRigidBodyMotion/sixDoFRigidBodyMotion/sixDoFRigidBodyMotion.C
View File

@ -323,7 +323,7 @@ void Foam::sixDoFRigidBodyMotion::update
}
}
Pstream::scatter(motionState_);
Pstream::broadcast(motionState_);
}

Some files were not shown because too many files have changed in this diff Show More