ENH: add single-parameter sortedOrder() function

applications/test/sort/Test-sortList.C

@@ -58,10 +58,12 @@ int main(int argc, char *argv[])
     SortableList<label> list1r(list1.size());
     list1r = list1;
 
-    Info<< "unsorted: " << orig << endl;
+    Info<< "unsorted: " << orig << nl
+        << "order:    " << sortedOrder(list1) << endl;
     sort(list1);
     Info<< "sorted:   " << list1 << nl
-        << "indices:  " << order << endl;
+        << "indices:  " << order << nl
+        << "order:    " << sortedOrder(list1) << endl;
 
     list1r.reverseSort();
     Info<< "reverse ..." << nl;

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMeshIO.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2012-2017 OpenFOAM Foundation
@@ -67,9 +67,7 @@ void Foam::DelaunayMesh<Triangulation>::sortFaces
         << "Sorting faces, owner and neighbour into upper triangular order"
         << endl;
 
-    labelList oldToNew;
+    labelList oldToNew(sortedOrder(ownerNeighbourPair));
-
-    sortedOrder(ownerNeighbourPair, oldToNew);
 
     oldToNew = invert(oldToNew.size(), oldToNew);
 

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2018 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2018-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2012-2016 OpenFOAM Foundation
@@ -1322,8 +1322,7 @@ void Foam::conformalVoronoiMesh::indexDualVertices
 
                 // Sort the vertices so that they will be in the same order on
                 // each processor
-                labelList oldToNew;
+                labelList oldToNew(sortedOrder(cellVerticesPair));
-                sortedOrder(cellVerticesPair, oldToNew);
                 oldToNew = invert(oldToNew.size(), oldToNew);
                 inplaceReorder(oldToNew, cellVertices);
 
@@ -2406,10 +2405,7 @@ void Foam::conformalVoronoiMesh::sortFaces
         << "Sorting faces, owner and neighbour into upper triangular order"
         << endl;
 
-    labelList oldToNew;
+    labelList oldToNew(sortedOrder(ownerNeighbourPair));
-
-    sortedOrder(ownerNeighbourPair, oldToNew);
-
     oldToNew = invert(oldToNew.size(), oldToNew);
 
     inplaceReorder(oldToNew, faces);
@@ -2459,10 +2455,7 @@ void Foam::conformalVoronoiMesh::sortProcPatches
                     << exit(FatalError) << endl;
             }
 
-            labelList oldToNew;
+            labelList oldToNew(sortedOrder(sortingIndices));
-
-            sortedOrder(sortingIndices, oldToNew);
-
             oldToNew = invert(oldToNew.size(), oldToNew);
 
             inplaceReorder(oldToNew, sortingIndices);

applications/utilities/mesh/manipulation/renumberMesh/renumberMesh.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016-2018 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -226,12 +226,10 @@ labelList getFaceOrder
             }
         }
 
-        order.setSize(nbr.size());
         sortedOrder(nbr, order);
 
-        forAll(order, i)
+        for (const label index : order)
         {
-            label index = order[i];
             if (nbr[index] != -1)
             {
                 oldToNewFace[cFaces[index]] = newFacei++;
@@ -495,8 +493,7 @@ autoPtr<mapPolyMesh> reorderMesh
                     newFlipMap[i] = fZone.flipMap()[i];
                 }
             }
-            labelList newToOld;
+            labelList newToOld(sortedOrder(newAddressing));
-            sortedOrder(newAddressing, newToOld);
             fZone.resetAddressing
             (
                 labelUIndList(newAddressing, newToOld)(),
@@ -1010,8 +1007,7 @@ int main(int argc, char *argv[])
             bndCellMap.setSize(nBndCells);
 
             // Sort
-            labelList order;
+            labelList order(sortedOrder(bndCellMap));
-            sortedOrder(bndCellMap, order);
 
             // Redo newReverseCellOrder
             labelList newReverseCellOrder(mesh.nCells(), -1);

src/OpenFOAM/containers/Lists/ListOps/ListOps.H

@@ -177,6 +177,10 @@ template<class Container>
 label inplaceMapValue(const Map<label>& mapper, Container& input);
 
 
+//- Return the (stable) sort order for the list
+template<class T>
+labelList sortedOrder(const UList<T>& input);
+
 //- Generate the (stable) sort order for the list
 template<class T>
 void sortedOrder(const UList<T>& input, labelList& order);
@@ -191,6 +195,10 @@ void sortedOrder
 );
 
 
+//- Return (sorted) indices corresponding to duplicate list values
+template<class T>
+labelList duplicateOrder(const UList<T>& input);
+
 //- Generate (sorted) indices corresponding to duplicate list values
 template<class T>
 void duplicateOrder(const UList<T>& input, labelList& order);
@@ -206,6 +214,10 @@ void duplicateOrder
 );
 
 
+//- Return (sorted) indices corresponding to unique list values
+template<class T>
+labelList uniqueOrder(const UList<T>& input);
+
 //- Generate (sorted) indices corresponding to unique list values
 template<class T>
 void uniqueOrder(const UList<T>& input, labelList& order);

src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C

@@ -320,6 +320,18 @@ Foam::label Foam::inplaceMapValue
 }
 
 
+template<class T>
+Foam::labelList Foam::sortedOrder
+(
+    const UList<T>& input
+)
+{
+    labelList order(input.size());
+    sortedOrder(input, order, typename UList<T>::less(input));
+    return order;
+}
+
+
 template<class T>
 void Foam::sortedOrder
 (
@@ -355,6 +367,18 @@ void Foam::sortedOrder
 }
 
 
+template<class T>
+Foam::labelList Foam::duplicateOrder
+(
+    const UList<T>& input
+)
+{
+    labelList order(input.size());
+    duplicateOrder(input, order, typename UList<T>::less(input));
+    return order;
+}
+
+
 template<class T>
 void Foam::duplicateOrder
 (
@@ -396,6 +420,18 @@ void Foam::duplicateOrder
 }
 
 
+template<class T>
+Foam::labelList Foam::uniqueOrder
+(
+    const UList<T>& input
+)
+{
+    labelList order(input.size());
+    uniqueOrder(input, order, typename UList<T>::less(input));
+    return order;
+}
+
+
 template<class T>
 void Foam::uniqueOrder
 (

src/OpenFOAM/containers/PtrLists/PtrListOps/PtrListOps.H

@@ -49,6 +49,10 @@ SourceFiles
 namespace Foam
 {
 
+//- Return (stable) sort order for the list
+template<class T>
+labelList sortedOrder(const UPtrList<T>& input);
+
 //- Generate (stable) sort order for the list
 template<class T>
 void sortedOrder(const UPtrList<T>& input, labelList& order);

src/OpenFOAM/containers/PtrLists/PtrListOps/PtrListOpsTemplates.C

@@ -27,6 +27,18 @@ License
 
 // * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
 
+template<class T>
+Foam::labelList Foam::sortedOrder
+(
+    const UPtrList<T>& input
+)
+{
+    labelList order(input.size());
+    sortedOrder(input, order, typename PtrListOps::less<T>(input));
+    return order;
+}
+
+
 template<class T>
 void Foam::sortedOrder
 (
@@ -65,7 +77,7 @@ void Foam::sortedOrder
 template<class T>
 void Foam::sort(UPtrList<T>& list)
 {
-    labelList order;
+    labelList order(input.size());
     sortedOrder(list, order);
     list.sortOrder(order, false);  // false = allow nullptr
 }
@@ -74,7 +86,7 @@ void Foam::sort(UPtrList<T>& list)
 template<class T, class Compare>
 void Foam::sort(UPtrList<T>& list, const Compare& comp)
 {
-    labelList order;
+    labelList order(input.size());
     sortedOrder(list, order, comp);
     list.sortOrder(order, false);  // false = allow nullptr
 }
@@ -83,7 +95,7 @@ void Foam::sort(UPtrList<T>& list, const Compare& comp)
 template<class T>
 void Foam::shuffle(UPtrList<T>& list)
 {
-    labelList order = identity(list.size());
+    labelList order(identity(list.size()));
     Foam::shuffle(order);
     list.sortOrder(order, false);  // false = allow nullptr
 }

src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGProcAgglomerations/procFacesGAMGProcAgglomeration/procFacesGAMGProcAgglomeration.C

@@ -190,8 +190,7 @@ Foam::procFacesGAMGProcAgglomeration::processorAgglomeration
         }
 
         // Sort according to master and redo restriction
-        labelList newToOld;
+        labelList newToOld(sortedOrder(coarseToMaster));
-        sortedOrder(coarseToMaster, newToOld);
         labelList oldToNew(invert(newToOld.size(), newToOld));
 
         fineToCoarse = labelUIndList(oldToNew, fineToCoarse)();

src/OpenFOAM/meshes/lduMesh/lduPrimitiveMesh.C

@@ -182,16 +182,14 @@ Foam::labelList Foam::lduPrimitiveMesh::upperTriOrder
         label nNbr = offsets[celli+1] - startOfCell;
 
         nbr.setSize(nNbr);
-        order.setSize(nNbr);
+        forAll(nbr, i)
-        forAll(order, i)
         {
             nbr[i] = upper[cellToFaces[offsets[celli]+i]];
         }
         sortedOrder(nbr, order);
 
-        forAll(order, i)
+        for (const label index : order)
         {
-            label index = order[i];
             oldToNew[cellToFaces[startOfCell + index]] = newFacei++;
         }
     }
@@ -807,8 +805,7 @@ Foam::lduPrimitiveMesh::lduPrimitiveMesh
             );
         }
 
-        labelList order;
+        labelList order(sortedOrder(procPairs));
-        sortedOrder(procPairs, order);
 
         // Count
         label n = 0;

src/OpenFOAM/meshes/meshTools/mergePoints.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2017-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -84,8 +84,7 @@ Foam::label Foam::mergePoints
     {
         magSqrDist[pointi] = magSqr(points[pointi] - compareOrigin);
     }
-    labelList order;
+    labelList order(Foam::sortedOrder(magSqrDist));
-    Foam::sortedOrder(magSqrDist, order);
 
 
     Field<scalar> sortedTol(nPoints);

src/conversion/starcd/STARCDMeshReader.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016-2018 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -771,8 +771,10 @@ void Foam::fileFormats::STARCDMeshReader::readBoundary
     // Sort according to ascending region numbers, but leave
     // "Default_Boundary_Region" as the final patch
     {
-        labelList sortedIndices;
+        labelList sortedIndices
-        sortedOrder(SubList<label>(origRegion, nPatches-1), sortedIndices);
+        (
+            sortedOrder(SubList<label>(origRegion, nPatches-1))
+        );
 
         labelList oldToNew = identity(nPatches);
         forAll(sortedIndices, i)

src/dynamicMesh/polyMeshAdder/polyMeshAdder.C

@@ -1183,8 +1183,8 @@ void Foam::polyMeshAdder::mergeFaceZones
         fzFaces[i].shrink();
         fzFlips[i].shrink();
 
-        labelList order;
+        labelList order(sortedOrder(fzFaces[i]));
-        sortedOrder(fzFaces[i], order);
+
         fzFaces[i] = labelUIndList(fzFaces[i], order)();
         fzFlips[i] = boolUIndList(fzFlips[i], order)();
     }

src/dynamicMesh/polyTopoChange/polyTopoChange/edgeCollapser.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2017 OpenFOAM Foundation
@@ -583,9 +583,7 @@ Foam::edgeCollapser::collapseType Foam::edgeCollapser::collapseFace
     // Sort the projected distances and the corresponding vertex
     // indices along the collapse axis
 
-    labelList oldToNew;
+    labelList oldToNew(sortedOrder(d));
-
-    sortedOrder(d, oldToNew);
 
     oldToNew = invert(oldToNew.size(), oldToNew);
 

src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2015-2018 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2015-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2017 OpenFOAM Foundation
@@ -725,7 +725,6 @@ void Foam::polyTopoChange::getFaceOrder
         label nFaces = cellFaceOffsets[celli+1] - startOfCell;
 
         // Neighbouring cells
-        //SortableList<label> nbr(nFaces);
         nbr.setSize(nFaces);
 
         for (label i = 0; i < nFaces; i++)
@@ -765,21 +764,10 @@ void Foam::polyTopoChange::getFaceOrder
             }
         }
 
-        //nbr.sort();
-        order.setSize(nFaces);
         sortedOrder(nbr, order);
 
-        //forAll(nbr, i)
+        for (const label index : order)
-        //{
-        //    if (nbr[i] != -1)
-        //    {
-        //        oldToNew[cellFaces[startOfCell + nbr.indices()[i]]] =
-        //            newFacei++;
-        //    }
-        //}
-        forAll(order, i)
         {
-            label index = order[i];
             if (nbr[index] != -1)
             {
                 oldToNew[cellFaces[startOfCell + index]] = newFacei++;
@@ -1672,8 +1660,7 @@ void Foam::polyTopoChange::resetZones
         // Sort the addressing
         forAll(addressing, zonei)
         {
-            labelList newToOld;
+            labelList newToOld(sortedOrder(addressing[zonei]));
-            sortedOrder(addressing[zonei], newToOld);
             {
                 labelList newAddressing(addressing[zonei].size());
                 forAll(newAddressing, i)

src/finiteVolume/fvMatrices/solvers/isoAdvection/isoCutCell/isoCutCell.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016-2017 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                 isoAdvector | Copyright (C) 2016-2017 DHI
@@ -299,8 +299,7 @@ void Foam::isoCutCell::calcIsoFacePointsFromEdges()
     DebugPout<< "Calculated isoFace point angles" << endl;
 
     // Sorting isoface points by angle and inserting into isoFacePoints_
-    labelList order(unsortedIsoFacePointAngles.size());
+    labelList order(sortedOrder(unsortedIsoFacePointAngles));
-    Foam::sortedOrder(unsortedIsoFacePointAngles, order);
     isoFacePoints_.append(unsortedIsoFacePoints[order[0]]);
     for (label pi = 1; pi < order.size(); pi++)
     {
@@ -508,8 +507,7 @@ Foam::label Foam::isoCutCell::vofCutCell
     {
         fvert[pi] = f_[pLabels[pi]];
     }
-    labelList order(fvert.size());
+    labelList order(sortedOrder(fvert));
-    sortedOrder(fvert, order);
     scalar f1 = fvert[order.first()];
     scalar f2 = fvert[order.last()];
 

src/finiteVolume/fvMatrices/solvers/isoAdvection/isoCutFace/isoCutFace.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016-2017 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                 isoAdvector | Copyright (C) 2016-2017 DHI
@@ -496,8 +496,7 @@ Foam::scalar Foam::isoCutFace::timeIntegratedArea
     scalar tIntArea = 0.0;
 
     // Finding ordering of vertex points
-    labelList order(pTimes.size());
+    labelList order(sortedOrder(pTimes));
-    sortedOrder(pTimes, order);
     const scalar firstTime = pTimes[order.first()];
     const scalar lastTime = pTimes[order.last()];
 

src/functionObjects/field/externalCoupled/externalCoupled.C

@@ -388,8 +388,7 @@ void Foam::functionObjects::externalCoupled::checkOrder
     const wordList& regionNames
 )
 {
-    labelList order;
+    labelList order(sortedOrder(regionNames));
-    sortedOrder(regionNames, order);
     if (order != identity(regionNames.size()))
     {
         FatalErrorInFunction

src/lagrangian/intermediate/submodels/CloudFunctionObjects/PatchPostProcessing/PatchPostProcessing.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2017 OpenFOAM Foundation
@@ -97,8 +97,7 @@ void Foam::PatchPostProcessing<CloudType>::write()
                 accessOp<List<scalar>>()
             );
 
-            labelList indices;
+            labelList indices(sortedOrder(globalTimes));
-            sortedOrder(globalTimes, indices);
 
             string header("# Time currentProc " + parcelType::propertyList_);
             patchOutFile<< header.c_str() << nl;

src/lagrangian/intermediate/submodels/Kinematic/CollisionModel/PairCollision/PairCollision.C

@@ -375,14 +375,13 @@ void Foam::PairCollision<CloudType>::wallInteraction()
             // ascending distance to their nearest point so that
             // grouping occurs around the closest in any group
 
-            labelList sortedOtherSiteIndices;
+            labelList sortedOtherSiteIndices
+            (
+                sortedOrder(otherSiteDistances)
+            );
 
-            sortedOrder(otherSiteDistances, sortedOtherSiteIndices);
+            for (const label orderedIndex : sortedOtherSiteIndices)
-
-            forAll(sortedOtherSiteIndices, siteI)
             {
-                label orderedIndex = sortedOtherSiteIndices[siteI];
-
                 const point& otherPt = otherSitePoints[orderedIndex];
 
                 if

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/InjectedParticleInjection/InjectedParticleInjection.C

@@ -110,8 +110,8 @@ void Foam::InjectedParticleInjection<CloudType>::initialise()
     }
 
     // Sort and renumber to ensure lists in ascending time
-    labelList sortedIndices;
+    labelList sortedIndices(Foam::sortedOrder(time));
-    Foam::sortedOrder(time, sortedIndices);
+
     time_ = UIndirectList<scalar>(time, sortedIndices);
     position_ = UIndirectList<point>(position, sortedIndices);
     diameter_ = UIndirectList<scalar>(diameter, sortedIndices);

src/mesh/snappyHexMesh/meshRefinement/meshRefinement.C

@@ -2639,8 +2639,7 @@ Foam::label Foam::meshRefinement::findRegions
                     );
 
                     // Sort according to curveDist
-                    labelList indexSet;
+                    labelList indexSet(Foam::sortedOrder(allDist));
-                    Foam::sortedOrder(allDist, indexSet);
 
                     allLeakPaths.set
                     (

src/mesh/snappyHexMesh/meshRefinement/meshRefinementTemplates.C

@@ -186,11 +186,9 @@ void Foam::meshRefinement::collectAndPrint
 
     scalarField magAllPoints(mag(allPoints-point(-0.317, 0.117, 0.501)));
 
-    labelList visitOrder;
+    labelList visitOrder(sortedOrder(magAllPoints));
-    sortedOrder(magAllPoints, visitOrder);
+    for (const label allPointi : visitOrder)
-    forAll(visitOrder, i)
     {
-        label allPointi = visitOrder[i];
         Info<< allPoints[allPointi] << " : " << allData[allPointi]
             << endl;
     }

src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyRefineDriver.C

@@ -2138,8 +2138,7 @@ Foam::label Foam::snappyRefineDriver::directionalSmooth
             }
 
             // Sort the normalized position
-            labelList order;
+            labelList order(sortedOrder(normalizedPosition));
-            sortedOrder(normalizedPosition, order);
 
             DynamicList<scalar> seedPointDist;
 

src/mesh/snappyHexMesh/snappyHexMeshDriver/snappySnapDriverFeature.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2015 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2015-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -724,8 +724,7 @@ void Foam::snappySnapDriver::correctAttraction
     // Tangential component along edge
     scalar tang = ((pt-edgePt)&edgeNormal);
 
-    labelList order;
+    labelList order(sortedOrder(surfaceCounts));
-    Foam::sortedOrder(surfaceCounts, order);
 
     if (order[0] < order[1])
     {

src/meshTools/sets/topoSets/cellZoneSet.C

@@ -45,8 +45,7 @@ namespace Foam
 
 void Foam::cellZoneSet::updateSet()
 {
-    labelList order;
+    labelList order(sortedOrder(addressing_));
-    sortedOrder(addressing_, order);
     inplaceReorder(order, addressing_);
 
     cellSet::clearStorage();

src/meshTools/sets/topoSets/faceZoneSet.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2018 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2018-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2017 OpenFOAM Foundation
@@ -49,8 +49,7 @@ namespace Foam
 
 void Foam::faceZoneSet::updateSet()
 {
-    labelList order;
+    labelList order(sortedOrder(addressing_));
-    sortedOrder(addressing_, order);
     addressing_ = labelUIndList(addressing_, order)();
     flipMap_ = boolUIndList(flipMap_, order)();
 

src/meshTools/sets/topoSets/pointZoneSet.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2018 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2018-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2017 OpenFOAM Foundation
@@ -46,8 +46,7 @@ namespace Foam
 
 void Foam::pointZoneSet::updateSet()
 {
-    labelList order;
+    labelList order(sortedOrder(addressing_));
-    sortedOrder(addressing_, order);
     inplaceReorder(order, addressing_);
 
     pointSet::clearStorage();

src/renumber/renumberMethods/springRenumber/springRenumber.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2017 OpenFOAM Foundation
@@ -161,8 +161,7 @@ Foam::labelList Foam::springRenumber::renumber
     //writeOBJ("endPosition.obj", cellCells, position);
 
     // Move cells to new position
-    labelList shuffle;
+    labelList shuffle(sortedOrder(position));
-    sortedOrder(position, shuffle);
 
     // Reorder oldToNew
     inplaceReorder(shuffle, oldToNew);

src/surfMesh/MeshedSurface/MeshedSurfaceZones.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -85,8 +85,7 @@ void Foam::MeshedSurface<Face>::sortFacesAndStore
 
     // Determine the sorted order:
     // use sortedOrder directly since we discard the intermediate list anyhow
-    List<label> faceMap;
+    labelList faceMap(sortedOrder(zones));
-    sortedOrder(zones, faceMap);
     zones.clear();
 
     // Sorted faces

src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016-2017 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -164,8 +164,7 @@ bool Foam::fileFormats::STLsurfaceFormat<Face>::read
     {
         // Determine the sorted order:
         // use sortedOrder directly (the intermediate list is discarded anyhow)
-        labelList faceMap;
+        labelList faceMap(sortedOrder(zoneIds));
-        sortedOrder(zoneIds, faceMap);
 
         // Generate sorted faces
         forAll(faceMap, facei)

src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016-2017 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -124,8 +124,7 @@ bool Foam::fileFormats::TRIsurfaceFormat<Face>::read
     {
         // Determine the sorted order:
         // use sortedOrder directly (the intermediate list is discared anyhow)
-        labelList faceMap;
+        labelList faceMap(sortedOrder(zoneIds));
-        sortedOrder(zoneIds, faceMap);
 
         // Generate sorted faces
         forAll(faceMap, facei)

src/surfMesh/triSurface/triSurface.C

@@ -304,7 +304,7 @@ Foam::triSurface::calcPatches(labelList& faceMap) const
     // Determine the sorted order:
     // use sortedOrder directly (the intermediate list is discarded anyhow)
 
-    List<label> regions(size());
+    labelList regions(size());
     forAll(regions, facei)
     {
         regions[facei] = operator[](facei).region();