From 1177dbd111e2aafdbe5f47b4d01946138df29119 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs>
Date: Wed, 21 Apr 2021 17:22:41 +0100
Subject: [PATCH] ENH: checkMesh: -allRegions. See #2072
---
.../mesh/manipulation/checkMesh/checkMesh.C | 172 ++-
.../mesh/manipulation/checkMesh/checkTools.C | 14 +-
.../manipulation/renumberMesh/renumberMesh.C | 1186 +++++++++--------
.../polyMesh/polyMeshCheck/polyMeshTools.C | 32 +
.../polyMesh/polyMeshCheck/polyMeshTools.H | 8 +
5 files changed, 752 insertions(+), 660 deletions(-)
diff --git a/applications/utilities/mesh/manipulation/checkMesh/checkMesh.C b/applications/utilities/mesh/manipulation/checkMesh/checkMesh.C
index c68bf78709b..14e91bd7dd6 100644
--- a/applications/utilities/mesh/manipulation/checkMesh/checkMesh.C
+++ b/applications/utilities/mesh/manipulation/checkMesh/checkMesh.C
@@ -50,6 +50,9 @@ Usage
- \par -region \<name\>
Specify an alternative mesh region.
+ - \par -allRegions
+ Check all regions in regionProperties.
+
\param -writeSets \<surfaceFormat\> \n
Reconstruct all cellSets and faceSets geometry and write to postProcessing
directory according to surfaceFormat (e.g. vtk or ensight). Additionally
@@ -74,6 +77,8 @@ Usage
#include "vtkSetWriter.H"
#include "vtkSurfaceWriter.H"
#include "IOdictionary.H"
+#include "regionProperties.H"
+#include "polyMeshTools.H"
#include "checkTools.H"
#include "checkTopology.H"
@@ -93,7 +98,8 @@ int main(int argc, char *argv[])
);
timeSelector::addOptions();
- #include "addRegionOption.H"
+ #include "addAllRegionOptions.H"
+
argList::addBoolOption
(
"noTopology",
@@ -139,8 +145,9 @@ int main(int argc, char *argv[])
#include "setRootCase.H"
#include "createTime.H"
+ #include "getAllRegionOptions.H"
instantList timeDirs = timeSelector::select0(runTime, args);
- #include "createNamedMesh.H"
+ #include "createNamedMeshes.H"
const bool noTopology = args.found("noTopology");
const bool allGeometry = args.found("allGeometry");
@@ -230,23 +237,27 @@ int main(int argc, char *argv[])
}
- autoPtr<IOdictionary> qualDict;
+ PtrList<IOdictionary> qualDict(meshes.size());
if (meshQuality)
{
- qualDict.reset
- (
- new IOdictionary
+ forAll(meshes, meshi)
+ {
+ qualDict.set
(
- IOobject
+ meshi,
+ new IOdictionary
(
- "meshQualityDict",
- mesh.time().system(),
- mesh,
- IOobject::MUST_READ,
- IOobject::NO_WRITE
+ IOobject
+ (
+ "meshQualityDict",
+ meshes[meshi].time().system(),
+ meshes[meshi],
+ IOobject::MUST_READ,
+ IOobject::NO_WRITE
+ )
)
- )
- );
+ );
+ }
}
@@ -263,7 +274,13 @@ int main(int argc, char *argv[])
{
runTime.setTime(timeDirs[timeI], timeI);
- polyMesh::readUpdateState state = mesh.readUpdate();
+ // Get most changed of all meshes
+ polyMesh::readUpdateState state = polyMesh::UNCHANGED;
+ for (auto& mesh : meshes)
+ {
+ state = polyMeshTools::combine(state, mesh.readUpdate());
+ }
+
if
(
@@ -274,87 +291,100 @@ int main(int argc, char *argv[])
{
Info<< "Time = " << runTime.timeName() << nl << endl;
- // Reconstruct globalMeshData
- mesh.globalData();
+ forAll(meshes, meshi)
+ {
+ const auto& mesh = meshes[meshi];
- printMeshStats(mesh, allTopology);
+ // Reconstruct globalMeshData
+ mesh.globalData();
- label nFailedChecks = 0;
+ printMeshStats(mesh, allTopology);
- if (!noTopology)
- {
- nFailedChecks += checkTopology
+ label nFailedChecks = 0;
+
+ if (!noTopology)
+ {
+ nFailedChecks += checkTopology
+ (
+ mesh,
+ allTopology,
+ allGeometry,
+ surfWriter,
+ setWriter
+ );
+ }
+
+ nFailedChecks += checkGeometry
(
mesh,
- allTopology,
allGeometry,
surfWriter,
setWriter
);
- }
-
- nFailedChecks += checkGeometry
- (
- mesh,
- allGeometry,
- surfWriter,
- setWriter
- );
- if (meshQuality)
- {
- nFailedChecks += checkMeshQuality(mesh, qualDict(), surfWriter);
- }
+ if (meshQuality)
+ {
+ nFailedChecks +=
+ checkMeshQuality(mesh, qualDict[meshi], surfWriter);
+ }
- // Note: no reduction in nFailedChecks necessary since is
- // counter of checks, not counter of failed cells,faces etc.
+ // Note: no reduction in nFailedChecks necessary since is
+ // counter of checks, not counter of failed cells,faces
+ // etc.
- if (nFailedChecks == 0)
- {
- Info<< "\nMesh OK.\n" << endl;
- }
- else
- {
- Info<< "\nFailed " << nFailedChecks << " mesh checks.\n"
- << endl;
- }
+ if (nFailedChecks == 0)
+ {
+ Info<< "\nMesh OK.\n" << endl;
+ }
+ else
+ {
+ Info<< "\nFailed " << nFailedChecks << " mesh checks.\n"
+ << endl;
+ }
- // Write selected fields
- Foam::writeFields(mesh, selectedFields, writeFaceFields);
+ // Write selected fields
+ Foam::writeFields(mesh, selectedFields, writeFaceFields);
+ }
}
else if (state == polyMesh::POINTS_MOVED)
{
Info<< "Time = " << runTime.timeName() << nl << endl;
- label nFailedChecks = checkGeometry
- (
- mesh,
- allGeometry,
- surfWriter,
- setWriter
- );
-
- if (meshQuality)
+ forAll(meshes, meshi)
{
- nFailedChecks += checkMeshQuality(mesh, qualDict(), surfWriter);
- }
+ const auto& mesh = meshes[meshi];
+ label nFailedChecks = checkGeometry
+ (
+ mesh,
+ allGeometry,
+ surfWriter,
+ setWriter
+ );
+
+ if (meshQuality)
+ {
+ nFailedChecks +=
+ checkMeshQuality(mesh, qualDict[meshi], surfWriter);
+ }
- if (nFailedChecks)
- {
- Info<< "\nFailed " << nFailedChecks << " mesh checks.\n"
- << endl;
- }
- else
- {
- Info<< "\nMesh OK.\n" << endl;
- }
+ if (nFailedChecks)
+ {
+ Info<< "\nFailed " << nFailedChecks << " mesh checks.\n"
+ << endl;
+ }
+ else
+ {
+ Info<< "\nMesh OK.\n" << endl;
+ }
- // Write selected fields
- Foam::writeFields(mesh, selectedFields, writeFaceFields);
+
+ // Write selected fields
+ Foam::writeFields(mesh, selectedFields, writeFaceFields);
+ }
}
}
diff --git a/applications/utilities/mesh/manipulation/checkMesh/checkTools.C b/applications/utilities/mesh/manipulation/checkMesh/checkTools.C
index ad29e420dc3..80cc5212588 100644
--- a/applications/utilities/mesh/manipulation/checkMesh/checkTools.C
+++ b/applications/utilities/mesh/manipulation/checkMesh/checkTools.C
@@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2015-2017 OpenFOAM Foundation
- Copyright (C) 2015-2020 OpenCFD Ltd.
+ Copyright (C) 2015-2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@@ -50,10 +50,18 @@ License
void Foam::printMeshStats(const polyMesh& mesh, const bool allTopology)
{
- Info<< "Mesh stats" << nl
- << " points: "
+ if (mesh.name() == Foam::polyMesh::defaultRegion)
+ {
+ Info<< "Mesh stats" << nl;
+ }
+ else
+ {
+ Info<< "Mesh " << mesh.name() << " stats" << nl;
+ }
+ Info<< " points: "
<< returnReduce(mesh.points().size(), sumOp<label>()) << nl;
+
// Count number of internal points (-1 if not sorted; 0 if no internal
// points)
const label minInt = returnReduce(mesh.nInternalPoints(), minOp<label>());
diff --git a/applications/utilities/mesh/manipulation/renumberMesh/renumberMesh.C b/applications/utilities/mesh/manipulation/renumberMesh/renumberMesh.C
index d8a17b7e910..13cac5a3cd5 100644
--- a/applications/utilities/mesh/manipulation/renumberMesh/renumberMesh.C
+++ b/applications/utilities/mesh/manipulation/renumberMesh/renumberMesh.C
@@ -57,6 +57,8 @@ Description
#include "pointSet.H"
#include "processorMeshes.H"
#include "hexRef8Data.H"
+#include "regionProperties.H"
+#include "polyMeshTools.H"
#ifdef HAVE_ZOLTAN
#include "zoltanRenumber.H"
@@ -613,7 +615,7 @@ int main(int argc, char *argv[])
"Renumber mesh cells to reduce the bandwidth"
);
- #include "addRegionOption.H"
+ #include "addAllRegionOptions.H"
#include "addOverwriteOption.H"
#include "addTimeOptions.H"
@@ -629,7 +631,7 @@ int main(int argc, char *argv[])
#include "setRootCase.H"
#include "createTime.H"
-
+ #include "getAllRegionOptions.H"
// Force linker to include zoltan symbols. This section is only needed since
// Zoltan is a static library
@@ -638,7 +640,6 @@ int main(int argc, char *argv[])
(void)zoltanRenumber::typeName;
#endif
-
// Get times list
instantList Times = runTime.times();
@@ -647,773 +648,786 @@ int main(int argc, char *argv[])
runTime.setTime(Times[startTime], startTime);
- #include "createNamedMesh.H"
-
- const word oldInstance = mesh.pointsInstance();
+ #include "createNamedMeshes.H"
const bool readDict = args.found("dict");
const bool doFrontWidth = args.found("frontWidth");
const bool overwrite = args.found("overwrite");
- label band;
- scalar profile;
- scalar sumSqrIntersect;
- getBand
- (
- doFrontWidth,
- mesh.nCells(),
- mesh.faceOwner(),
- mesh.faceNeighbour(),
- band,
- profile,
- sumSqrIntersect
- );
- reduce(band, maxOp<label>());
- reduce(profile, sumOp<scalar>());
- scalar rmsFrontwidth = Foam::sqrt
- (
- returnReduce
+ for (fvMesh& mesh : meshes)
+ {
+ // Reset time in case of multiple meshes and not overwrite
+ runTime.setTime(Times[startTime], startTime);
+
+ const word oldInstance = mesh.pointsInstance();
+
+ label band;
+ scalar profile;
+ scalar sumSqrIntersect;
+ getBand
(
- sumSqrIntersect,
- sumOp<scalar>()
- )/mesh.globalData().nTotalCells()
- );
+ doFrontWidth,
+ mesh.nCells(),
+ mesh.faceOwner(),
+ mesh.faceNeighbour(),
+ band,
+ profile,
+ sumSqrIntersect
+ );
- Info<< "Mesh size: " << mesh.globalData().nTotalCells() << nl
- << "Before renumbering :" << nl
- << " band : " << band << nl
- << " profile : " << profile << nl;
+ reduce(band, maxOp<label>());
+ reduce(profile, sumOp<scalar>());
+ scalar rmsFrontwidth = Foam::sqrt
+ (
+ returnReduce
+ (
+ sumSqrIntersect,
+ sumOp<scalar>()
+ )/mesh.globalData().nTotalCells()
+ );
- if (doFrontWidth)
- {
- Info<< " rms frontwidth : " << rmsFrontwidth << nl;
- }
+ Info<< "Mesh " << mesh.name()
+ << " size: " << mesh.globalData().nTotalCells() << nl
+ << "Before renumbering :" << nl
+ << " band : " << band << nl
+ << " profile : " << profile << nl;
- Info<< endl;
+ if (doFrontWidth)
+ {
+ Info<< " rms frontwidth : " << rmsFrontwidth << nl;
+ }
- bool sortCoupledFaceCells = false;
- bool writeMaps = false;
- bool orderPoints = false;
- label blockSize = 0;
+ Info<< endl;
- // Construct renumberMethod
- autoPtr<IOdictionary> renumberDictPtr;
- autoPtr<renumberMethod> renumberPtr;
+ bool sortCoupledFaceCells = false;
+ bool writeMaps = false;
+ bool orderPoints = false;
+ label blockSize = 0;
- if (readDict)
- {
- const word dictName("renumberMeshDict");
- #include "setSystemMeshDictionaryIO.H"
+ // Construct renumberMethod
+ autoPtr<IOdictionary> renumberDictPtr;
+ autoPtr<renumberMethod> renumberPtr;
- Info<< "Renumber according to " << dictIO.name() << nl << endl;
+ if (readDict)
+ {
+ const word dictName("renumberMeshDict");
+ #include "setSystemMeshDictionaryIO.H"
- renumberDictPtr.reset(new IOdictionary(dictIO));
- const IOdictionary& renumberDict = renumberDictPtr();
+ Info<< "Renumber according to " << dictIO.name() << nl << endl;
- renumberPtr = renumberMethod::New(renumberDict);
+ renumberDictPtr.reset(new IOdictionary(dictIO));
+ const IOdictionary& renumberDict = renumberDictPtr();
- sortCoupledFaceCells = renumberDict.getOrDefault
- (
- "sortCoupledFaceCells",
- false
- );
- if (sortCoupledFaceCells)
- {
- Info<< "Sorting cells on coupled boundaries to be last." << nl
- << endl;
- }
+ renumberPtr = renumberMethod::New(renumberDict);
- blockSize = renumberDict.getOrDefault("blockSize", 0);
- if (blockSize > 0)
- {
- Info<< "Ordering cells into regions of size " << blockSize
- << " (using decomposition);"
- << " ordering faces into region-internal and region-external."
- << nl << endl;
+ sortCoupledFaceCells = renumberDict.getOrDefault
+ (
+ "sortCoupledFaceCells",
+ false
+ );
+ if (sortCoupledFaceCells)
+ {
+ Info<< "Sorting cells on coupled boundaries to be last." << nl
+ << endl;
+ }
- if (blockSize < 0 || blockSize >= mesh.nCells())
+ blockSize = renumberDict.getOrDefault("blockSize", 0);
+ if (blockSize > 0)
{
- FatalErrorInFunction
- << "Block size " << blockSize
- << " should be positive integer"
- << " and less than the number of cells in the mesh."
- << exit(FatalError);
+ Info<< "Ordering cells into regions of size " << blockSize
+ << " (using decomposition);"
+ << " ordering faces into region-internal"
+ << " and region-external."
+ << nl << endl;
+
+ if (blockSize < 0 || blockSize >= mesh.nCells())
+ {
+ FatalErrorInFunction
+ << "Block size " << blockSize
+ << " should be positive integer"
+ << " and less than the number of cells in the mesh."
+ << exit(FatalError);
+ }
}
- }
- orderPoints = renumberDict.getOrDefault("orderPoints", false);
- if (orderPoints)
- {
- Info<< "Ordering points into internal and boundary points." << nl
- << endl;
- }
+ orderPoints = renumberDict.getOrDefault("orderPoints", false);
+ if (orderPoints)
+ {
+ Info<< "Ordering points into internal and boundary points."
+ << nl
+ << endl;
+ }
- renumberDict.readEntry("writeMaps", writeMaps);
- if (writeMaps)
+ renumberDict.readEntry("writeMaps", writeMaps);
+ if (writeMaps)
+ {
+ Info<< "Writing renumber maps (new to old) to polyMesh." << nl
+ << endl;
+ }
+ }
+ else
{
- Info<< "Writing renumber maps (new to old) to polyMesh." << nl
- << endl;
+ Info<< "Using default renumberMethod." << nl << endl;
+ dictionary renumberDict;
+ renumberPtr.reset(new CuthillMcKeeRenumber(renumberDict));
}
- }
- else
- {
- Info<< "Using default renumberMethod." << nl << endl;
- dictionary renumberDict;
- renumberPtr.reset(new CuthillMcKeeRenumber(renumberDict));
- }
- Info<< "Selecting renumberMethod " << renumberPtr().type() << nl << endl;
+ Info<< "Selecting renumberMethod " << renumberPtr().type() << nl
+ << endl;
- // Read parallel reconstruct maps
- labelIOList cellProcAddressing
- (
- IOobject
+ // Read parallel reconstruct maps
+ labelIOList cellProcAddressing
(
- "cellProcAddressing",
- mesh.facesInstance(),
- polyMesh::meshSubDir,
- mesh,
- IOobject::READ_IF_PRESENT,
- IOobject::AUTO_WRITE
- ),
- labelList(0)
- );
+ IOobject
+ (
+ "cellProcAddressing",
+ mesh.facesInstance(),
+ polyMesh::meshSubDir,
+ mesh,
+ IOobject::READ_IF_PRESENT,
+ IOobject::AUTO_WRITE
+ ),
+ labelList(0)
+ );
- labelIOList faceProcAddressing
- (
- IOobject
+ labelIOList faceProcAddressing
(
- "faceProcAddressing",
- mesh.facesInstance(),
- polyMesh::meshSubDir,
- mesh,
- IOobject::READ_IF_PRESENT,
- IOobject::AUTO_WRITE
- ),
- labelList(0)
- );
- labelIOList pointProcAddressing
- (
- IOobject
+ IOobject
+ (
+ "faceProcAddressing",
+ mesh.facesInstance(),
+ polyMesh::meshSubDir,
+ mesh,
+ IOobject::READ_IF_PRESENT,
+ IOobject::AUTO_WRITE
+ ),
+ labelList(0)
+ );
+ labelIOList pointProcAddressing
(
- "pointProcAddressing",
- mesh.pointsInstance(),
- polyMesh::meshSubDir,
- mesh,
- IOobject::READ_IF_PRESENT,
- IOobject::AUTO_WRITE
- ),
- labelList(0)
- );
- labelIOList boundaryProcAddressing
- (
- IOobject
+ IOobject
+ (
+ "pointProcAddressing",
+ mesh.pointsInstance(),
+ polyMesh::meshSubDir,
+ mesh,
+ IOobject::READ_IF_PRESENT,
+ IOobject::AUTO_WRITE
+ ),
+ labelList(0)
+ );
+ labelIOList boundaryProcAddressing
(
- "boundaryProcAddressing",
- mesh.pointsInstance(),
- polyMesh::meshSubDir,
- mesh,
- IOobject::READ_IF_PRESENT,
- IOobject::AUTO_WRITE
- ),
- labelList(0)
- );
+ IOobject
+ (
+ "boundaryProcAddressing",
+ mesh.pointsInstance(),
+ polyMesh::meshSubDir,
+ mesh,
+ IOobject::READ_IF_PRESENT,
+ IOobject::AUTO_WRITE
+ ),
+ labelList(0)
+ );
- // Read objects in time directory
- IOobjectList objects(mesh, runTime.timeName());
+ // Read objects in time directory
+ IOobjectList objects(mesh, runTime.timeName());
- // Read vol fields.
+ // Read vol fields.
- PtrList<volScalarField> vsFlds;
- ReadFields(mesh, objects, vsFlds);
+ PtrList<volScalarField> vsFlds;
+ ReadFields(mesh, objects, vsFlds);
- PtrList<volVectorField> vvFlds;
- ReadFields(mesh, objects, vvFlds);
+ PtrList<volVectorField> vvFlds;
+ ReadFields(mesh, objects, vvFlds);
- PtrList<volSphericalTensorField> vstFlds;
- ReadFields(mesh, objects, vstFlds);
+ PtrList<volSphericalTensorField> vstFlds;
+ ReadFields(mesh, objects, vstFlds);
- PtrList<volSymmTensorField> vsymtFlds;
- ReadFields(mesh, objects, vsymtFlds);
+ PtrList<volSymmTensorField> vsymtFlds;
+ ReadFields(mesh, objects, vsymtFlds);
- PtrList<volTensorField> vtFlds;
- ReadFields(mesh, objects, vtFlds);
+ PtrList<volTensorField> vtFlds;
+ ReadFields(mesh, objects, vtFlds);
- // Read surface fields.
+ // Read surface fields.
- PtrList<surfaceScalarField> ssFlds;
- ReadFields(mesh, objects, ssFlds);
+ PtrList<surfaceScalarField> ssFlds;
+ ReadFields(mesh, objects, ssFlds);
- PtrList<surfaceVectorField> svFlds;
- ReadFields(mesh, objects, svFlds);
+ PtrList<surfaceVectorField> svFlds;
+ ReadFields(mesh, objects, svFlds);
- PtrList<surfaceSphericalTensorField> sstFlds;
- ReadFields(mesh, objects, sstFlds);
+ PtrList<surfaceSphericalTensorField> sstFlds;
+ ReadFields(mesh, objects, sstFlds);
- PtrList<surfaceSymmTensorField> ssymtFlds;
- ReadFields(mesh, objects, ssymtFlds);
+ PtrList<surfaceSymmTensorField> ssymtFlds;
+ ReadFields(mesh, objects, ssymtFlds);
- PtrList<surfaceTensorField> stFlds;
- ReadFields(mesh, objects, stFlds);
+ PtrList<surfaceTensorField> stFlds;
+ ReadFields(mesh, objects, stFlds);
- // Read point fields.
+ // Read point fields.
- PtrList<pointScalarField> psFlds;
- ReadFields(pointMesh::New(mesh), objects, psFlds);
+ PtrList<pointScalarField> psFlds;
+ ReadFields(pointMesh::New(mesh), objects, psFlds);
- PtrList<pointVectorField> pvFlds;
- ReadFields(pointMesh::New(mesh), objects, pvFlds);
+ PtrList<pointVectorField> pvFlds;
+ ReadFields(pointMesh::New(mesh), objects, pvFlds);
- PtrList<pointSphericalTensorField> pstFlds;
- ReadFields(pointMesh::New(mesh), objects, pstFlds);
+ PtrList<pointSphericalTensorField> pstFlds;
+ ReadFields(pointMesh::New(mesh), objects, pstFlds);
- PtrList<pointSymmTensorField> psymtFlds;
- ReadFields(pointMesh::New(mesh), objects, psymtFlds);
+ PtrList<pointSymmTensorField> psymtFlds;
+ ReadFields(pointMesh::New(mesh), objects, psymtFlds);
- PtrList<pointTensorField> ptFlds;
- ReadFields(pointMesh::New(mesh), objects, ptFlds);
+ PtrList<pointTensorField> ptFlds;
+ ReadFields(pointMesh::New(mesh), objects, ptFlds);
- // Read sets
- PtrList<cellSet> cellSets;
- PtrList<faceSet> faceSets;
- PtrList<pointSet> pointSets;
- {
// Read sets
- IOobjectList objects(mesh, mesh.facesInstance(), "polyMesh/sets");
- ReadFields(objects, cellSets);
- ReadFields(objects, faceSets);
- ReadFields(objects, pointSets);
- }
+ PtrList<cellSet> cellSets;
+ PtrList<faceSet> faceSets;
+ PtrList<pointSet> pointSets;
+ {
+ // Read sets
+ IOobjectList objects(mesh, mesh.facesInstance(), "polyMesh/sets");
+ ReadFields(objects, cellSets);
+ ReadFields(objects, faceSets);
+ ReadFields(objects, pointSets);
+ }
- Info<< endl;
+ Info<< endl;
- // From renumbering:
- // - from new cell/face back to original cell/face
- labelList cellOrder;
- labelList faceOrder;
+ // From renumbering:
+ // - from new cell/face back to original cell/face
+ labelList cellOrder;
+ labelList faceOrder;
- if (blockSize > 0)
- {
- // Renumbering in two phases. Should be done in one so mapping of
- // fields is done correctly!
+ if (blockSize > 0)
+ {
+ // Renumbering in two phases. Should be done in one so mapping of
+ // fields is done correctly!
- label nBlocks = mesh.nCells()/blockSize;
- Info<< "nBlocks = " << nBlocks << endl;
+ label nBlocks = mesh.nCells()/blockSize;
+ Info<< "nBlocks = " << nBlocks << endl;
- // Read decompositionMethod dictionary
- dictionary decomposeDict(renumberDictPtr().subDict("blockCoeffs"));
- decomposeDict.set("numberOfSubdomains", nBlocks);
+ // Read decompositionMethod dictionary
+ dictionary decomposeDict(renumberDictPtr().subDict("blockCoeffs"));
+ decomposeDict.set("numberOfSubdomains", nBlocks);
- const bool oldParRun = UPstream::parRun(false);
+ const bool oldParRun = UPstream::parRun(false);
- autoPtr<decompositionMethod> decomposePtr = decompositionMethod::New
- (
- decomposeDict
- );
+ autoPtr<decompositionMethod> decomposePtr = decompositionMethod::New
+ (
+ decomposeDict
+ );
- labelList cellToRegion
- (
- decomposePtr().decompose
+ labelList cellToRegion
(
- mesh,
- mesh.cellCentres()
- )
- );
+ decomposePtr().decompose
+ (
+ mesh,
+ mesh.cellCentres()
+ )
+ );
- UPstream::parRun(oldParRun); // Restore parallel state
+ UPstream::parRun(oldParRun); // Restore parallel state
- // For debugging: write out region
- createScalarField
- (
- mesh,
- "cellDist",
- cellToRegion
- )().write();
+ // For debugging: write out region
+ createScalarField
+ (
+ mesh,
+ "cellDist",
+ cellToRegion
+ )().write();
- Info<< nl << "Written decomposition as volScalarField to "
- << "cellDist for use in postprocessing."
- << nl << endl;
+ Info<< nl << "Written decomposition as volScalarField to "
+ << "cellDist for use in postprocessing."
+ << nl << endl;
- cellOrder = regionRenumber(renumberPtr(), mesh, cellToRegion);
+ cellOrder = regionRenumber(renumberPtr(), mesh, cellToRegion);
- // Determine new to old face order with new cell numbering
- faceOrder = getRegionFaceOrder
- (
- mesh,
- cellOrder,
- cellToRegion
- );
- }
- else
- {
- // Determines sorted back to original cell ordering
- cellOrder = renumberPtr().renumber
- (
- mesh,
- mesh.cellCentres()
- );
-
- if (sortCoupledFaceCells)
+ // Determine new to old face order with new cell numbering
+ faceOrder = getRegionFaceOrder
+ (
+ mesh,
+ cellOrder,
+ cellToRegion
+ );
+ }
+ else
{
- // Change order so all coupled patch faceCells are at the end.
- const polyBoundaryMesh& pbm = mesh.boundaryMesh();
+ // Determines sorted back to original cell ordering
+ cellOrder = renumberPtr().renumber
+ (
+ mesh,
+ mesh.cellCentres()
+ );
- // Collect all boundary cells on coupled patches
- label nBndCells = 0;
- forAll(pbm, patchi)
+ if (sortCoupledFaceCells)
{
- if (pbm[patchi].coupled())
+ // Change order so all coupled patch faceCells are at the end.
+ const polyBoundaryMesh& pbm = mesh.boundaryMesh();
+
+ // Collect all boundary cells on coupled patches
+ label nBndCells = 0;
+ forAll(pbm, patchi)
{
- nBndCells += pbm[patchi].size();
+ if (pbm[patchi].coupled())
+ {
+ nBndCells += pbm[patchi].size();
+ }
}
- }
- labelList reverseCellOrder = invert(mesh.nCells(), cellOrder);
+ labelList reverseCellOrder = invert(mesh.nCells(), cellOrder);
- labelList bndCells(nBndCells);
- labelList bndCellMap(nBndCells);
- nBndCells = 0;
- forAll(pbm, patchi)
- {
- if (pbm[patchi].coupled())
+ labelList bndCells(nBndCells);
+ labelList bndCellMap(nBndCells);
+ nBndCells = 0;
+ forAll(pbm, patchi)
{
- const labelUList& faceCells = pbm[patchi].faceCells();
- forAll(faceCells, i)
+ if (pbm[patchi].coupled())
{
- label celli = faceCells[i];
-
- if (reverseCellOrder[celli] != -1)
+ const labelUList& faceCells = pbm[patchi].faceCells();
+ forAll(faceCells, i)
{
- bndCells[nBndCells] = celli;
- bndCellMap[nBndCells++] = reverseCellOrder[celli];
- reverseCellOrder[celli] = -1;
+ label celli = faceCells[i];
+
+ if (reverseCellOrder[celli] != -1)
+ {
+ bndCells[nBndCells] = celli;
+ bndCellMap[nBndCells++] =
+ reverseCellOrder[celli];
+ reverseCellOrder[celli] = -1;
+ }
}
}
}
- }
- bndCells.setSize(nBndCells);
- bndCellMap.setSize(nBndCells);
+ bndCells.setSize(nBndCells);
+ bndCellMap.setSize(nBndCells);
- // Sort
- labelList order(sortedOrder(bndCellMap));
+ // Sort
+ labelList order(sortedOrder(bndCellMap));
- // Redo newReverseCellOrder
- labelList newReverseCellOrder(mesh.nCells(), -1);
+ // Redo newReverseCellOrder
+ labelList newReverseCellOrder(mesh.nCells(), -1);
- label sortedI = mesh.nCells();
- forAllReverse(order, i)
- {
- label origCelli = bndCells[order[i]];
- newReverseCellOrder[origCelli] = --sortedI;
- }
+ label sortedI = mesh.nCells();
+ forAllReverse(order, i)
+ {
+ label origCelli = bndCells[order[i]];
+ newReverseCellOrder[origCelli] = --sortedI;
+ }
- Info<< "Ordered all " << nBndCells << " cells with a coupled face"
- << " to the end of the cell list, starting at " << sortedI
- << endl;
+ Info<< "Ordered all " << nBndCells
+ << " cells with a coupled face"
+ << " to the end of the cell list, starting at " << sortedI
+ << endl;
- // Compact
- sortedI = 0;
- forAll(cellOrder, newCelli)
- {
- label origCelli = cellOrder[newCelli];
- if (newReverseCellOrder[origCelli] == -1)
+ // Compact
+ sortedI = 0;
+ forAll(cellOrder, newCelli)
{
- newReverseCellOrder[origCelli] = sortedI++;
+ label origCelli = cellOrder[newCelli];
+ if (newReverseCellOrder[origCelli] == -1)
+ {
+ newReverseCellOrder[origCelli] = sortedI++;
+ }
}
- }
-
- // Update sorted back to original (unsorted) map
- cellOrder = invert(mesh.nCells(), newReverseCellOrder);
- }
+ // Update sorted back to original (unsorted) map
+ cellOrder = invert(mesh.nCells(), newReverseCellOrder);
+ }
- // Determine new to old face order with new cell numbering
- faceOrder = getFaceOrder
- (
- mesh,
- cellOrder // New to old cell
- );
- }
+ // Determine new to old face order with new cell numbering
+ faceOrder = getFaceOrder
+ (
+ mesh,
+ cellOrder // New to old cell
+ );
+ }
- if (!overwrite)
- {
- ++runTime;
- }
+ if (!overwrite)
+ {
+ ++runTime;
+ }
- // Change the mesh.
- autoPtr<mapPolyMesh> map = reorderMesh(mesh, cellOrder, faceOrder);
+ // Change the mesh.
+ autoPtr<mapPolyMesh> map = reorderMesh(mesh, cellOrder, faceOrder);
- if (orderPoints)
- {
- polyTopoChange meshMod(mesh);
- autoPtr<mapPolyMesh> pointOrderMap = meshMod.changeMesh
- (
- mesh,
- false, // inflate
- true, // syncParallel
- false, // orderCells
- orderPoints // orderPoints
- );
- // Combine point reordering into map.
- const_cast<labelList&>(map().pointMap()) = labelUIndList
- (
- map().pointMap(),
- pointOrderMap().pointMap()
- )();
+ if (orderPoints)
+ {
+ polyTopoChange meshMod(mesh);
+ autoPtr<mapPolyMesh> pointOrderMap = meshMod.changeMesh
+ (
+ mesh,
+ false, // inflate
+ true, // syncParallel
+ false, // orderCells
+ orderPoints // orderPoints
+ );
- inplaceRenumber
- (
- pointOrderMap().reversePointMap(),
- const_cast<labelList&>(map().reversePointMap())
- );
- }
+ // Combine point reordering into map.
+ const_cast<labelList&>(map().pointMap()) = labelUIndList
+ (
+ map().pointMap(),
+ pointOrderMap().pointMap()
+ )();
+ inplaceRenumber
+ (
+ pointOrderMap().reversePointMap(),
+ const_cast<labelList&>(map().reversePointMap())
+ );
+ }
- // Update fields
- mesh.updateMesh(map());
- // Update proc maps
- if (cellProcAddressing.headerOk())
- {
- bool localOk = (cellProcAddressing.size() == mesh.nCells());
+ // Update fields
+ mesh.updateMesh(map());
- if (returnReduce(localOk, andOp<bool>()))
+ // Update proc maps
+ if (cellProcAddressing.headerOk())
{
- Info<< "Renumbering processor cell decomposition map "
- << cellProcAddressing.name() << endl;
+ bool localOk = (cellProcAddressing.size() == mesh.nCells());
- cellProcAddressing = labelList
- (
- labelUIndList(cellProcAddressing, map().cellMap())
- );
+ if (returnReduce(localOk, andOp<bool>()))
+ {
+ Info<< "Renumbering processor cell decomposition map "
+ << cellProcAddressing.name() << endl;
+
+ cellProcAddressing = labelList
+ (
+ labelUIndList(cellProcAddressing, map().cellMap())
+ );
+ }
+ else
+ {
+ Info<< "Not writing inconsistent processor cell decomposition"
+ << " map " << cellProcAddressing.filePath() << endl;
+ cellProcAddressing.writeOpt(IOobject::NO_WRITE);
+ }
}
else
{
- Info<< "Not writing inconsistent processor cell decomposition"
- << " map " << cellProcAddressing.filePath() << endl;
cellProcAddressing.writeOpt(IOobject::NO_WRITE);
}
- }
- else
- {
- cellProcAddressing.writeOpt(IOobject::NO_WRITE);
- }
-
- if (faceProcAddressing.headerOk())
- {
- bool localOk = (faceProcAddressing.size() == mesh.nFaces());
- if (returnReduce(localOk, andOp<bool>()))
+ if (faceProcAddressing.headerOk())
{
- Info<< "Renumbering processor face decomposition map "
- << faceProcAddressing.name() << endl;
-
- faceProcAddressing = labelList
- (
- labelUIndList(faceProcAddressing, map().faceMap())
- );
+ bool localOk = (faceProcAddressing.size() == mesh.nFaces());
- // Detect any flips.
- const labelHashSet& fff = map().flipFaceFlux();
- for (const label facei : fff)
+ if (returnReduce(localOk, andOp<bool>()))
{
- label masterFacei = faceProcAddressing[facei];
+ Info<< "Renumbering processor face decomposition map "
+ << faceProcAddressing.name() << endl;
- faceProcAddressing[facei] = -masterFacei;
+ faceProcAddressing = labelList
+ (
+ labelUIndList(faceProcAddressing, map().faceMap())
+ );
- if (masterFacei == 0)
+ // Detect any flips.
+ const labelHashSet& fff = map().flipFaceFlux();
+ for (const label facei : fff)
{
- FatalErrorInFunction
- << " masterFacei:" << masterFacei << exit(FatalError);
+ label masterFacei = faceProcAddressing[facei];
+
+ faceProcAddressing[facei] = -masterFacei;
+
+ if (masterFacei == 0)
+ {
+ FatalErrorInFunction
+ << " masterFacei:" << masterFacei
+ << exit(FatalError);
+ }
}
}
+ else
+ {
+ Info<< "Not writing inconsistent processor face decomposition"
+ << " map " << faceProcAddressing.filePath() << endl;
+ faceProcAddressing.writeOpt(IOobject::NO_WRITE);
+ }
}
else
{
- Info<< "Not writing inconsistent processor face decomposition"
- << " map " << faceProcAddressing.filePath() << endl;
faceProcAddressing.writeOpt(IOobject::NO_WRITE);
}
- }
- else
- {
- faceProcAddressing.writeOpt(IOobject::NO_WRITE);
- }
-
- if (pointProcAddressing.headerOk())
- {
- bool localOk = (pointProcAddressing.size() == mesh.nPoints());
- if (returnReduce(localOk, andOp<bool>()))
+ if (pointProcAddressing.headerOk())
{
- Info<< "Renumbering processor point decomposition map "
- << pointProcAddressing.name() << endl;
+ bool localOk = (pointProcAddressing.size() == mesh.nPoints());
- pointProcAddressing = labelList
- (
- labelUIndList(pointProcAddressing, map().pointMap())
- );
+ if (returnReduce(localOk, andOp<bool>()))
+ {
+ Info<< "Renumbering processor point decomposition map "
+ << pointProcAddressing.name() << endl;
+
+ pointProcAddressing = labelList
+ (
+ labelUIndList(pointProcAddressing, map().pointMap())
+ );
+ }
+ else
+ {
+ Info<< "Not writing inconsistent processor point decomposition"
+ << " map " << pointProcAddressing.filePath() << endl;
+ pointProcAddressing.writeOpt(IOobject::NO_WRITE);
+ }
}
else
{
- Info<< "Not writing inconsistent processor point decomposition"
- << " map " << pointProcAddressing.filePath() << endl;
pointProcAddressing.writeOpt(IOobject::NO_WRITE);
}
- }
- else
- {
- pointProcAddressing.writeOpt(IOobject::NO_WRITE);
- }
- if (boundaryProcAddressing.headerOk())
- {
- bool localOk =
- (
- boundaryProcAddressing.size()
- == mesh.boundaryMesh().size()
- );
- if (returnReduce(localOk, andOp<bool>()))
+ if (boundaryProcAddressing.headerOk())
{
- // No renumbering needed
+ bool localOk =
+ (
+ boundaryProcAddressing.size()
+ == mesh.boundaryMesh().size()
+ );
+ if (returnReduce(localOk, andOp<bool>()))
+ {
+ // No renumbering needed
+ }
+ else
+ {
+ Info<< "Not writing inconsistent processor patch decomposition"
+ << " map " << boundaryProcAddressing.filePath() << endl;
+ boundaryProcAddressing.writeOpt(IOobject::NO_WRITE);
+ }
}
else
{
- Info<< "Not writing inconsistent processor patch decomposition"
- << " map " << boundaryProcAddressing.filePath() << endl;
boundaryProcAddressing.writeOpt(IOobject::NO_WRITE);
}
- }
- else
- {
- boundaryProcAddressing.writeOpt(IOobject::NO_WRITE);
- }
- // Move mesh (since morphing might not do this)
- if (map().hasMotionPoints())
- {
- mesh.movePoints(map().preMotionPoints());
- }
-
-
- {
- label band;
- scalar profile;
- scalar sumSqrIntersect;
- getBand
- (
- doFrontWidth,
- mesh.nCells(),
- mesh.faceOwner(),
- mesh.faceNeighbour(),
- band,
- profile,
- sumSqrIntersect
- );
- reduce(band, maxOp<label>());
- reduce(profile, sumOp<scalar>());
- scalar rmsFrontwidth = Foam::sqrt
- (
- returnReduce
- (
- sumSqrIntersect,
- sumOp<scalar>()
- )/mesh.globalData().nTotalCells()
- );
-
- Info<< "After renumbering :" << nl
- << " band : " << band << nl
- << " profile : " << profile << nl;
-
- if (doFrontWidth)
+ // Move mesh (since morphing might not do this)
+ if (map().hasMotionPoints())
{
-
- Info<< " rms frontwidth : " << rmsFrontwidth << nl;
+ mesh.movePoints(map().preMotionPoints());
}
- Info<< endl;
- }
- if (orderPoints)
- {
- // Force edge calculation (since only reason that points would need to
- // be sorted)
- (void)mesh.edges();
+ {
+ label band;
+ scalar profile;
+ scalar sumSqrIntersect;
+ getBand
+ (
+ doFrontWidth,
+ mesh.nCells(),
+ mesh.faceOwner(),
+ mesh.faceNeighbour(),
+ band,
+ profile,
+ sumSqrIntersect
+ );
+ reduce(band, maxOp<label>());
+ reduce(profile, sumOp<scalar>());
+ scalar rmsFrontwidth = Foam::sqrt
+ (
+ returnReduce
+ (
+ sumSqrIntersect,
+ sumOp<scalar>()
+ )/mesh.globalData().nTotalCells()
+ );
- label nTotPoints = returnReduce
- (
- mesh.nPoints(),
- sumOp<label>()
- );
- label nTotIntPoints = returnReduce
- (
- mesh.nInternalPoints(),
- sumOp<label>()
- );
+ Info<< "After renumbering :" << nl
+ << " band : " << band << nl
+ << " profile : " << profile << nl;
- label nTotEdges = returnReduce
- (
- mesh.nEdges(),
- sumOp<label>()
- );
- label nTotIntEdges = returnReduce
- (
- mesh.nInternalEdges(),
- sumOp<label>()
- );
- label nTotInt0Edges = returnReduce
- (
- mesh.nInternal0Edges(),
- sumOp<label>()
- );
- label nTotInt1Edges = returnReduce
- (
- mesh.nInternal1Edges(),
- sumOp<label>()
- );
-
- Info<< "Points:" << nl
- << " total : " << nTotPoints << nl
- << " internal: " << nTotIntPoints << nl
- << " boundary: " << nTotPoints-nTotIntPoints << nl
- << "Edges:" << nl
- << " total : " << nTotEdges << nl
- << " internal: " << nTotIntEdges << nl
- << " internal using 0 boundary points: "
- << nTotInt0Edges << nl
- << " internal using 1 boundary points: "
- << nTotInt1Edges-nTotInt0Edges << nl
- << " internal using 2 boundary points: "
- << nTotIntEdges-nTotInt1Edges << nl
- << " boundary: " << nTotEdges-nTotIntEdges << nl
- << endl;
- }
+ if (doFrontWidth)
+ {
+ Info<< " rms frontwidth : " << rmsFrontwidth << nl;
+ }
- if (overwrite)
- {
- mesh.setInstance(oldInstance);
- }
- else
- {
- mesh.setInstance(runTime.timeName());
- }
+ Info<< endl;
+ }
+ if (orderPoints)
+ {
+ // Force edge calculation (since only reason that points would
+ // need to be sorted)
+ (void)mesh.edges();
- Info<< "Writing mesh to " << mesh.facesInstance() << endl;
+ label nTotPoints = returnReduce
+ (
+ mesh.nPoints(),
+ sumOp<label>()
+ );
+ label nTotIntPoints = returnReduce
+ (
+ mesh.nInternalPoints(),
+ sumOp<label>()
+ );
- // Remove old procAddressing files
- processorMeshes::removeFiles(mesh);
+ label nTotEdges = returnReduce
+ (
+ mesh.nEdges(),
+ sumOp<label>()
+ );
+ label nTotIntEdges = returnReduce
+ (
+ mesh.nInternalEdges(),
+ sumOp<label>()
+ );
+ label nTotInt0Edges = returnReduce
+ (
+ mesh.nInternal0Edges(),
+ sumOp<label>()
+ );
+ label nTotInt1Edges = returnReduce
+ (
+ mesh.nInternal1Edges(),
+ sumOp<label>()
+ );
- // Update refinement data
- hexRef8Data refData
- (
- IOobject
- (
- "dummy",
- mesh.facesInstance(),
- polyMesh::meshSubDir,
- mesh,
- IOobject::READ_IF_PRESENT,
- IOobject::NO_WRITE,
- false
- )
- );
- refData.updateMesh(map());
- refData.write();
+ Info<< "Points:" << nl
+ << " total : " << nTotPoints << nl
+ << " internal: " << nTotIntPoints << nl
+ << " boundary: " << nTotPoints-nTotIntPoints << nl
+ << "Edges:" << nl
+ << " total : " << nTotEdges << nl
+ << " internal: " << nTotIntEdges << nl
+ << " internal using 0 boundary points: "
+ << nTotInt0Edges << nl
+ << " internal using 1 boundary points: "
+ << nTotInt1Edges-nTotInt0Edges << nl
+ << " internal using 2 boundary points: "
+ << nTotIntEdges-nTotInt1Edges << nl
+ << " boundary: " << nTotEdges-nTotIntEdges << nl
+ << endl;
+ }
- // Update sets
- topoSet::updateMesh(mesh.facesInstance(), map(), cellSets);
- topoSet::updateMesh(mesh.facesInstance(), map(), faceSets);
- topoSet::updateMesh(mesh.facesInstance(), map(), pointSets);
- mesh.write();
+ if (overwrite)
+ {
+ mesh.setInstance(oldInstance);
+ }
+ else
+ {
+ mesh.setInstance(runTime.timeName());
+ }
- if (writeMaps)
- {
- // For debugging: write out region
- createScalarField
- (
- mesh,
- "origCellID",
- map().cellMap()
- )().write();
- createScalarField
- (
- mesh,
- "cellID",
- identity(mesh.nCells())
- )().write();
+ Info<< "Writing mesh to " << mesh.facesInstance() << endl;
- Info<< nl << "Written current cellID and origCellID as volScalarField"
- << " for use in postprocessing."
- << nl << endl;
+ // Remove old procAddressing files
+ processorMeshes::removeFiles(mesh);
- labelIOList
+ // Update refinement data
+ hexRef8Data refData
(
IOobject
(
- "cellMap",
+ "dummy",
mesh.facesInstance(),
polyMesh::meshSubDir,
mesh,
- IOobject::NO_READ,
+ IOobject::READ_IF_PRESENT,
IOobject::NO_WRITE,
false
- ),
- map().cellMap()
- ).write();
+ )
+ );
+ refData.updateMesh(map());
+ refData.write();
- labelIOList
- (
- IOobject
+ // Update sets
+ topoSet::updateMesh(mesh.facesInstance(), map(), cellSets);
+ topoSet::updateMesh(mesh.facesInstance(), map(), faceSets);
+ topoSet::updateMesh(mesh.facesInstance(), map(), pointSets);
+
+ mesh.write();
+
+ if (writeMaps)
+ {
+ // For debugging: write out region
+ createScalarField
(
- "faceMap",
- mesh.facesInstance(),
- polyMesh::meshSubDir,
mesh,
- IOobject::NO_READ,
- IOobject::NO_WRITE,
- false
- ),
- map().faceMap()
- ).write();
+ "origCellID",
+ map().cellMap()
+ )().write();
- labelIOList
- (
- IOobject
+ createScalarField
(
- "pointMap",
- mesh.facesInstance(),
- polyMesh::meshSubDir,
mesh,
- IOobject::NO_READ,
- IOobject::NO_WRITE,
- false
- ),
- map().pointMap()
- ).write();
- }
+ "cellID",
+ identity(mesh.nCells())
+ )().write();
+ Info<< nl
+ << "Written current cellID and origCellID as volScalarField"
+ << " for use in postprocessing." << nl << endl;
+
+ labelIOList
+ (
+ IOobject
+ (
+ "cellMap",
+ mesh.facesInstance(),
+ polyMesh::meshSubDir,
+ mesh,
+ IOobject::NO_READ,
+ IOobject::NO_WRITE,
+ false
+ ),
+ map().cellMap()
+ ).write();
+
+ labelIOList
+ (
+ IOobject
+ (
+ "faceMap",
+ mesh.facesInstance(),
+ polyMesh::meshSubDir,
+ mesh,
+ IOobject::NO_READ,
+ IOobject::NO_WRITE,
+ false
+ ),
+ map().faceMap()
+ ).write();
+
+ labelIOList
+ (
+ IOobject
+ (
+ "pointMap",
+ mesh.facesInstance(),
+ polyMesh::meshSubDir,
+ mesh,
+ IOobject::NO_READ,
+ IOobject::NO_WRITE,
+ false
+ ),
+ map().pointMap()
+ ).write();
+ }
+ }
Info<< "End\n" << endl;
diff --git a/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshTools.C b/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshTools.C
index dec2d5aa518..a90525c3bb5 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshTools.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshTools.C
@@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2012-2016 OpenFOAM Foundation
+ Copyright (C) 2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@@ -280,4 +281,35 @@ Foam::tmp<Foam::scalarField> Foam::polyMeshTools::volRatio
}
+Foam::polyMesh::readUpdateState Foam::polyMeshTools::combine
+(
+ const polyMesh::readUpdateState& state0,
+ const polyMesh::readUpdateState& state1
+)
+{
+ if
+ (
+ (
+ state0 == polyMesh::UNCHANGED
+ && state1 != polyMesh::UNCHANGED
+ )
+ || (
+ state0 == polyMesh::POINTS_MOVED
+ && (state1 != polyMesh::UNCHANGED && state1 != polyMesh::POINTS_MOVED)
+ )
+ || (
+ state0 == polyMesh::TOPO_CHANGE
+ && state1 == polyMesh::TOPO_PATCH_CHANGE
+ )
+ )
+ {
+ return state1;
+ }
+ else
+ {
+ return state0;
+ }
+}
+
+
// ************************************************************************* //
diff --git a/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshTools.H b/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshTools.H
index 0624c07f9b2..8e599d9e759 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshTools.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshTools.H
@@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2012-2013 OpenFOAM Foundation
+ Copyright (C) 2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@@ -92,6 +93,13 @@ public:
const scalarField& vol
);
+ //- Combine readUpdateState. topo change trumps geom-only
+ // change etc.
+ static polyMesh::readUpdateState combine
+ (
+ const polyMesh::readUpdateState& state0,
+ const polyMesh::readUpdateState& state1
+ );
};
--
GitLab