Hugging Face's logo

Datasets:
introvoyz042
/
OpenFOAM-dev

License:
Dataset card Files
xet
 Community
OpenFOAM-dev / data /src /mesh /snappyHexMesh /meshRefinement /meshRefinementBaffles.C
introvoyz042's picture
introvoyz042
Migrated from GitHub
5a600cf verified
Raw History Blame Contribute Delete
91.5 kB
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2026 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "meshRefinement.H"
#include "refinementSurfaces.H"
#include "faceSet.H"
#include "polyTopoChange.H"
#include "localPointRegion.H"
#include "duplicatePoints.H"
#include "regionSplit.H"
#include "removeCells.H"
#include "OBJstream.H"
#include "patchFaceOrientation.H"
#include "PatchEdgeFaceWave.H"
#include "patchEdgeFaceRegion.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
Foam::label Foam::meshRefinement::createBaffle
(
const label facei,
const label ownPatch,
const label nbrPatch,
polyTopoChange& meshMod
) const
{
const face& f = mesh_.faces()[facei];
meshMod.modifyFace
(
f, // modified face
facei, // label of face
mesh_.faceOwner()[facei], // owner
-1, // neighbour
false, // face flip
ownPatch // patch for face
);
label dupFacei = -1;
if (mesh_.isInternalFace(facei))
{
if (nbrPatch == -1)
{
FatalErrorInFunction
<< "No neighbour patch for internal face " << facei
<< " fc:" << mesh_.faceCentres()[facei]
<< " ownPatch:" << ownPatch << abort(FatalError);
}
dupFacei = meshMod.addFace
(
f.reverseFace(), // modified face
mesh_.faceNeighbour()[facei],// owner
-1, // neighbour
facei, // masterFaceID,
true, // face flip
nbrPatch // patch for face
);
}
return dupFacei;
}
void Foam::meshRefinement::getBafflePatches
(
const labelList& globalToMasterPatch,
const labelList& neiLevel,
const pointField& neiCc,
labelList& ownPatch,
labelList& nbrPatch
) const
{
const pointField& cellCentres = mesh_.cellCentres();
// Surfaces that need to be baffled
const labelList surfacesToBaffle
(
surfaceZonesInfo::getUnnamedSurfaces(surfaces_.surfZones())
);
ownPatch.setSize(mesh_.nFaces());
ownPatch = -1;
nbrPatch.setSize(mesh_.nFaces());
nbrPatch = -1;
// Collect candidate faces
// ~~~~~~~~~~~~~~~~~~~~~~~
labelList testFaces(intersectedFaces());
// Collect segments
// ~~~~~~~~~~~~~~~~
pointField start(testFaces.size());
pointField end(testFaces.size());
forAll(testFaces, i)
{
const label facei = testFaces[i];
const label own = mesh_.faceOwner()[facei];
if (mesh_.isInternalFace(facei))
{
start[i] = cellCentres[own];
end[i] = cellCentres[mesh_.faceNeighbour()[facei]];
}
else
{
start[i] = cellCentres[own];
end[i] = neiCc[facei-mesh_.nInternalFaces()];
}
}
// Extend segments a bit
{
const vectorField smallVec(rootSmall*(end-start));
start -= smallVec;
end += smallVec;
}
// Do test for intersections
// ~~~~~~~~~~~~~~~~~~~~~~~~~
labelList surface1;
List<pointIndexHit> hit1;
labelList region1;
labelList surface2;
List<pointIndexHit> hit2;
labelList region2;
surfaces_.findNearestIntersection
(
surfacesToBaffle,
start,
end,
surface1,
hit1,
region1,
surface2,
hit2,
region2
);
forAll(testFaces, i)
{
const label facei = testFaces[i];
if (hit1[i].hit() && hit2[i].hit())
{
// Pick up the patches
ownPatch[facei] = globalToMasterPatch
[
surfaces_.globalRegion(surface1[i], region1[i])
];
nbrPatch[facei] = globalToMasterPatch
[
surfaces_.globalRegion(surface2[i], region2[i])
];
if (ownPatch[facei] == -1 || nbrPatch[facei] == -1)
{
FatalErrorInFunction
<< "problem." << abort(FatalError);
}
}
}
// No need to parallel sync since intersection data (surfaceIndex_ etc.)
// already guaranteed to be synced...
// However:
// - owncc and neicc are reversed on different procs so might pick
// up different regions reversed? No problem. Neighbour on one processor
// might not be owner on the other processor but the neighbour is
// not used when creating baffles from proc faces.
// - tolerances issues occasionally crop up.
syncTools::syncFaceList(mesh_, ownPatch, maxEqOp());
syncTools::syncFaceList(mesh_, nbrPatch, maxEqOp());
}
Foam::Map<Foam::labelPair> Foam::meshRefinement::getZoneBafflePatches
(
const bool allowBoundary,
const labelList& globalToMasterPatch,
const labelList& globalToSlavePatch
) const
{
Map<labelPair> bafflePatch(mesh_.nFaces()/1000);
const PtrList<surfaceZonesInfo>& surfZones = surfaces_.surfZones();
const faceZoneList& fZones = mesh_.faceZones();
forAll(surfZones, surfi)
{
const word& faceZoneName = surfZones[surfi].faceZoneName();
if (faceZoneName.size())
{
// Get zone
const label zonei = fZones.findIndex(faceZoneName);
const faceZone& fZone = fZones[zonei];
// Get patch allocated for zone
const label globalRegioni = surfaces_.globalRegion(surfi, 0);
const labelPair zPatches
(
globalToMasterPatch[globalRegioni],
globalToSlavePatch[globalRegioni]
);
Info<< "For zone " << fZone.name() << " found patches "
<< mesh_.poly().boundary()[zPatches[0]].name() << " and "
<< mesh_.poly().boundary()[zPatches[1]].name()
<< endl;
forAll(fZone, i)
{
const label facei = fZone[i];
if (allowBoundary || mesh_.isInternalFace(facei))
{
labelPair patches = zPatches;
if (fZone.flipMap()[i])
{
patches = reverse(patches);
}
if (!bafflePatch.insert(facei, patches))
{
FatalErrorInFunction
<< "Face " << facei
<< " fc:" << mesh_.faceCentres()[facei]
<< " in zone " << fZone.name()
<< " is in multiple zones!"
<< abort(FatalError);
}
}
}
}
}
return bafflePatch;
}
Foam::autoPtr<Foam::polyTopoChangeMap> Foam::meshRefinement::createBaffles
(
const labelList& ownPatch,
const labelList& nbrPatch
)
{
if
(
ownPatch.size() != mesh_.nFaces()
|| nbrPatch.size() != mesh_.nFaces()
)
{
FatalErrorInFunction
<< "Illegal size :"
<< " ownPatch:" << ownPatch.size()
<< " nbrPatch:" << nbrPatch.size()
<< ". Should be number of faces:" << mesh_.nFaces()
<< abort(FatalError);
}
if (debug)
{
labelList syncedOwnPatch(ownPatch);
syncTools::syncFaceList(mesh_, syncedOwnPatch, maxEqOp());
labelList syncedNeiPatch(nbrPatch);
syncTools::syncFaceList(mesh_, syncedNeiPatch, maxEqOp());
forAll(syncedOwnPatch, facei)
{
if
(
(ownPatch[facei] == -1 && syncedOwnPatch[facei] != -1)
|| (nbrPatch[facei] == -1 && syncedNeiPatch[facei] != -1)
)
{
FatalErrorInFunction
<< "Non synchronised at face:" << facei
<< " on patch:" << mesh_.poly().boundary().whichPatch(facei)
<< " fc:" << mesh_.faceCentres()[facei] << endl
<< "ownPatch:" << ownPatch[facei]
<< " syncedOwnPatch:" << syncedOwnPatch[facei]
<< " nbrPatch:" << nbrPatch[facei]
<< " syncedNeiPatch:" << syncedNeiPatch[facei]
<< abort(FatalError);
}
}
}
// Topochange container
polyTopoChange meshMod(mesh_);
label nBaffles = 0;
forAll(ownPatch, facei)
{
if (ownPatch[facei] != -1)
{
// Create baffle or repatch face. Return label of inserted baffle
// face.
createBaffle
(
facei,
ownPatch[facei], // owner side patch
nbrPatch[facei], // neighbour side patch
meshMod
);
nBaffles++;
}
}
mesh_.clearOut();
// Change the mesh, parallel sync
autoPtr<polyTopoChangeMap> map = meshMod.changeMesh(mesh_, true);
// Update fields
mesh_.topoChange(map);
// Reset the instance for if in overwrite mode
mesh_.setInstance(name());
//- Redo the intersections on the newly create baffle faces. Note that
// this changes also the cell centre positions.
faceSet baffledFacesSet(mesh_, "baffledFacesSet", 2*nBaffles);
const labelList& reverseFaceMap = map().reverseFaceMap();
const labelList& faceMap = map().faceMap();
// Pick up owner side of baffle
forAll(ownPatch, oldFacei)
{
const label facei = reverseFaceMap[oldFacei];
if (ownPatch[oldFacei] != -1 && facei >= 0)
{
const cell& ownFaces = mesh_.cells()[mesh_.faceOwner()[facei]];
forAll(ownFaces, i)
{
baffledFacesSet.insert(ownFaces[i]);
}
}
}
// Pick up neighbour side of baffle (added faces)
forAll(faceMap, facei)
{
const label oldFacei = faceMap[facei];
if (oldFacei >= 0 && reverseFaceMap[oldFacei] != facei)
{
const cell& ownFaces = mesh_.cells()[mesh_.faceOwner()[facei]];
forAll(ownFaces, i)
{
baffledFacesSet.insert(ownFaces[i]);
}
}
}
baffledFacesSet.sync(mesh_);
topoChange(map, baffledFacesSet.toc());
return map;
}
void Foam::meshRefinement::checkZoneFaces() const
{
const faceZoneList& fZones = mesh_.faceZones();
const polyBoundaryMesh& pbm = mesh_.poly().boundary();
forAll(pbm, patchi)
{
const polyPatch& pp = pbm[patchi];
if (isA<processorPolyPatch>(pp))
{
forAll(pp, i)
{
const label facei = pp.start() + i;
const labelList zones = fZones.whichZones(facei);
forAll(zones, zonei)
{
if (zones[zonei] != -1)
{
FatalErrorInFunction
<< "face:" << facei << " on patch " << pp.name()
<< " is in zone " << fZones[zones[zonei]].name()
<< exit(FatalError);
}
}
}
}
}
}
Foam::autoPtr<Foam::polyTopoChangeMap> Foam::meshRefinement::createZoneBaffles
(
const labelList& globalToMasterPatch,
const labelList& globalToSlavePatch,
List<labelPair>& baffles
)
{
const labelList zonedSurfaces
(
surfaceZonesInfo::getNamedSurfaces(surfaces_.surfZones())
);
autoPtr<polyTopoChangeMap> map;
// No need to sync; all processors will have all same zonedSurfaces.
if (zonedSurfaces.size())
{
// Split internal faces on interface surfaces
Info<< "Converting zoned faces into baffles ..." << endl;
// Get faces (internal only) to be baffled. Map from face to patch
// label.
Map<labelPair> faceToPatch
(
getZoneBafflePatches
(
false,
globalToMasterPatch,
globalToSlavePatch
)
);
const label nZoneFaces =
returnReduce(faceToPatch.size(), sumOp());
if (nZoneFaces > 0)
{
// Convert into labelLists
labelList ownPatch(mesh_.nFaces(), -1);
labelList nbrPatch(mesh_.nFaces(), -1);
forAllConstIter(Map<labelPair>, faceToPatch, iter)
{
ownPatch[iter.key()] = iter().first();
nbrPatch[iter.key()] = iter().second();
}
// Create baffles. both sides same patch.
map = createBaffles(ownPatch, nbrPatch);
// Get pairs of faces created.
// Just loop over faceMap and store baffle if we encounter a slave
// face.
baffles.setSize(faceToPatch.size());
label baffleI = 0;
const labelList& faceMap = map().faceMap();
const labelList& reverseFaceMap = map().reverseFaceMap();
forAll(faceMap, facei)
{
const label oldFacei = faceMap[facei];
// Does face originate from face-to-patch
Map<labelPair>::const_iterator iter = faceToPatch.find
(
oldFacei
);
if (iter != faceToPatch.end())
{
const label masterFacei = reverseFaceMap[oldFacei];
if (facei != masterFacei)
{
baffles[baffleI++] = labelPair(masterFacei, facei);
}
}
}
if (baffleI != faceToPatch.size())
{
FatalErrorInFunction
<< "Had " << faceToPatch.size() << " patches to create "
<< " but encountered " << baffleI
<< " slave faces originating from patcheable faces."
<< abort(FatalError);
}
if (debug&MESH)
{
const_cast<Time&>(mesh_.time())++;
Pout<< "Writing zone-baffled mesh to time " << name()
<< endl;
write
(
debugType(debug),
writeType(writeLevel() | WRITEMESH),
mesh_.time().path()/"baffles"
);
}
}
Info<< "Created " << nZoneFaces << " baffles in = "
<< mesh_.time().cpuTimeIncrement() << " s\n" << nl << endl;
}
return map;
}
Foam::List<Foam::labelPair> Foam::meshRefinement::freeStandingBaffles
(
const List<labelPair>& couples,
const scalar planarAngle
) const
{
// Done by counting the number of baffles faces per mesh edge. If edge
// has 2 boundary faces and both are baffle faces it is the edge of a baffle
// region.
// All duplicate faces on edge of the patch are to be merged.
// So we count for all edges of duplicate faces how many duplicate
// faces use them.
labelList nBafflesPerEdge(mesh_.nEdges(), 0);
// This algorithm is quite tricky. We don't want to use edgeFaces and
// also want it to run in parallel so it is now an algorithm over
// all (boundary) faces instead.
// We want to pick up any edges that are only used by the baffle
// or internal faces but not by any other boundary faces. So
// - increment count on an edge by 1 if it is used by any (uncoupled)
// boundary face.
// - increment count on an edge by 1000000 if it is used by a baffle face
// - sum in parallel
//
// So now any edge that is used by baffle faces only will have the
// value 2*1000000+2*1.
const label baffleValue = 1000000;
// Count number of boundary faces per edge
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
const polyBoundaryMesh& patches = mesh_.poly().boundary();
forAll(patches, patchi)
{
const polyPatch& pp = patches[patchi];
// Count number of boundary faces. Discard coupled boundary faces.
if (!pp.coupled())
{
label facei = pp.start();
forAll(pp, i)
{
const labelList& fEdges = mesh_.faceEdges(facei);
forAll(fEdges, fEdgei)
{
nBafflesPerEdge[fEdges[fEdgei]]++;
}
facei++;
}
}
}
DynamicList<label> fe0;
DynamicList<label> fe1;
// Count number of duplicate boundary faces per edge
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
forAll(couples, i)
{
{
const label f0 = couples[i].first();
const labelList& fEdges0 = mesh_.faceEdges(f0, fe0);
forAll(fEdges0, fEdgei)
{
nBafflesPerEdge[fEdges0[fEdgei]] += baffleValue;
}
}
{
const label f1 = couples[i].second();
const labelList& fEdges1 = mesh_.faceEdges(f1, fe1);
forAll(fEdges1, fEdgei)
{
nBafflesPerEdge[fEdges1[fEdgei]] += baffleValue;
}
}
}
// Add nBaffles on shared edges
syncTools::syncEdgeList
(
mesh_,
nBafflesPerEdge,
addEqOp(), // in-place add
label(0) // initial value
);
// Baffles which are not next to other boundaries and baffles will have
// nBafflesPerEdge value 2*baffleValue+2*1 (from 2 boundary faces which
// are both baffle faces)
List<labelPair> filteredCouples(couples.size());
label filterI = 0;
forAll(couples, i)
{
const labelPair& couple = couples[i];
if
(
patches.whichPatch(couple.first())
== patches.whichPatch(couple.second())
)
{
const labelList& fEdges = mesh_.faceEdges(couple.first());
forAll(fEdges, fEdgei)
{
const label edgei = fEdges[fEdgei];
if (nBafflesPerEdge[edgei] == 2*baffleValue+2*1)
{
filteredCouples[filterI++] = couple;
break;
}
}
}
}
filteredCouples.setSize(filterI);
const label nFiltered =
returnReduce(filteredCouples.size(), sumOp());
Info<< "freeStandingBaffles : detected "
<< nFiltered
<< " free-standing baffles out of "
<< returnReduce(couples.size(), sumOp())
<< nl << endl;
if (nFiltered > 0)
{
// Collect segments
// ~~~~~~~~~~~~~~~~
pointField start(filteredCouples.size());
pointField end(filteredCouples.size());
const pointField& cellCentres = mesh_.cellCentres();
forAll(filteredCouples, i)
{
const labelPair& couple = filteredCouples[i];
start[i] = cellCentres[mesh_.faceOwner()[couple.first()]];
end[i] = cellCentres[mesh_.faceOwner()[couple.second()]];
}
// Extend segments a bit
{
const vectorField smallVec(rootSmall*(end-start));
start -= smallVec;
end += smallVec;
}
// Do test for intersections
// ~~~~~~~~~~~~~~~~~~~~~~~~~
labelList surface1;
List<pointIndexHit> hit1;
labelList region1;
vectorField normal1;
labelList surface2;
List<pointIndexHit> hit2;
labelList region2;
vectorField normal2;
surfaces_.findNearestIntersection
(
identityMap(surfaces_.surfaces().size()),
start,
end,
surface1,
hit1,
region1,
normal1,
surface2,
hit2,
region2,
normal2
);
const scalar planarAngleCos = Foam::cos(planarAngle);
label filterI = 0;
forAll(filteredCouples, i)
{
const labelPair& couple = filteredCouples[i];
if
(
hit1[i].hit()
&& hit2[i].hit()
&& (
surface1[i] != surface2[i]
|| hit1[i].index() != hit2[i].index()
)
)
{
if ((normal1[i ]& normal2[i]) > planarAngleCos)
{
// Both normals aligned
const vector n = end[i] - start[i];
const scalar magN = mag(n);
if (magN > vSmall)
{
filteredCouples[filterI++] = couple;
}
}
}
else if (hit1[i].hit() || hit2[i].hit())
{
// Single hit. Do not include in freestanding baffles.
}
}
filteredCouples.setSize(filterI);
Info<< "freeStandingBaffles : detected "
<< returnReduce(filterI, sumOp())
<< " planar (within " << radToDeg(planarAngle)
<< " degrees) free-standing baffles out of "
<< nFiltered
<< nl << endl;
}
return filteredCouples;
}
Foam::autoPtr<Foam::polyTopoChangeMap> Foam::meshRefinement::mergeBaffles
(
const List<labelPair>& couples
)
{
// Mesh change engine
polyTopoChange meshMod(mesh_);
const faceList& faces = mesh_.faces();
const labelList& faceOwner = mesh_.faceOwner();
forAll(couples, i)
{
const label face0 = couples[i].first();
const label face1 = couples[i].second();
// face1 < 0 signals a coupled face that has been converted to baffle.
const label own0 = faceOwner[face0];
const label own1 = faceOwner[face1];
if (face1 < 0 || own0 < own1)
{
// Use face0 as the new internal face.
const label nei = (face1 < 0 ? -1 : own1);
meshMod.removeFace(face1, -1);
meshMod.modifyFace
(
faces[face0], // modified face
face0, // label of face being modified
own0, // owner
nei, // neighbour
false, // face flip
-1 // patch for face
);
}
else
{
// Use face1 as the new internal face.
meshMod.removeFace(face0, -1);
meshMod.modifyFace
(
faces[face1], // modified face
face1, // label of face being modified
own1, // owner
own0, // neighbour
false, // face flip
-1 // patch for face
);
}
}
mesh_.clearOut();
// Change the mesh, parallel sync
autoPtr<polyTopoChangeMap> map = meshMod.changeMesh(mesh_, true);
// Update fields
mesh_.topoChange(map);
// Reset the instance for if in overwrite mode
mesh_.setInstance(name());
// Update intersections. Recalculate intersections on merged faces since
// this seems to give problems? Note: should not be necessary since
// baffles preserve intersections from when they were created.
labelList newExposedFaces(2*couples.size());
label newI = 0;
forAll(couples, i)
{
const label newFace0 = map().reverseFaceMap()[couples[i].first()];
if (newFace0 != -1)
{
newExposedFaces[newI++] = newFace0;
}
const label newFace1 = map().reverseFaceMap()[couples[i].second()];
if (newFace1 != -1)
{
newExposedFaces[newI++] = newFace1;
}
}
newExposedFaces.setSize(newI);
topoChange(map, newExposedFaces);
return map;
}
// Finds region per cell for cells inside closed named surfaces
void Foam::meshRefinement::findCellZoneGeometric
(
const pointField& neiCc,
const labelList& closedNamedSurfaces, // indices of closed surfaces
labelList& namedSurfaceIndex, // per face index of named surface
const labelList& surfaceToCellZone, // cell zone index per surface
labelList& cellToZone
) const
{
const pointField& cellCentres = mesh_.cellCentres();
const labelList& faceOwner = mesh_.faceOwner();
const labelList& faceNeighbour = mesh_.faceNeighbour();
// Check if cell centre is inside
labelList insideSurfaces;
surfaces_.findInside
(
closedNamedSurfaces,
cellCentres,
insideSurfaces
);
forAll(insideSurfaces, celli)
{
if (cellToZone[celli] == -2)
{
label surfi = insideSurfaces[celli];
if (surfi != -1)
{
cellToZone[celli] = surfaceToCellZone[surfi];
}
}
}
// Some cells with cell centres close to surface might have
// had been put into wrong surface. Recheck with perturbed cell centre.
// 1. Collect points
// Count points to test.
label nCandidates = 0;
forAll(namedSurfaceIndex, facei)
{
const label surfi = namedSurfaceIndex[facei];
if (surfi != -1)
{
if (mesh_.isInternalFace(facei))
{
nCandidates += 2;
}
else
{
nCandidates += 1;
}
}
}
// Collect points.
pointField candidatePoints(nCandidates);
nCandidates = 0;
forAll(namedSurfaceIndex, facei)
{
const label surfi = namedSurfaceIndex[facei];
if (surfi != -1)
{
const label own = faceOwner[facei];
const point& ownCc = cellCentres[own];
if (mesh_.isInternalFace(facei))
{
const label nei = faceNeighbour[facei];
const point& neiCc = cellCentres[nei];
// Perturbed cc
const vector d = 1e-4*(neiCc - ownCc);
candidatePoints[nCandidates++] = ownCc-d;
candidatePoints[nCandidates++] = neiCc+d;
}
else
{
const point& neiFc = neiCc[facei - mesh_.nInternalFaces()];
// Perturbed cc
const vector d = 1e-4*(neiFc - ownCc);
candidatePoints[nCandidates++] = ownCc-d;
}
}
}
// 2. Test points for inside
surfaces_.findInside
(
closedNamedSurfaces,
candidatePoints,
insideSurfaces
);
// 3. Update zone information
nCandidates = 0;
forAll(namedSurfaceIndex, facei)
{
const label surfi = namedSurfaceIndex[facei];
if (surfi != -1)
{
const label own = faceOwner[facei];
if (mesh_.isInternalFace(facei))
{
const label ownSurfI = insideSurfaces[nCandidates++];
if (ownSurfI != -1)
{
cellToZone[own] = surfaceToCellZone[ownSurfI];
}
const label neiSurfI = insideSurfaces[nCandidates++];
if (neiSurfI != -1)
{
label nei = faceNeighbour[facei];
cellToZone[nei] = surfaceToCellZone[neiSurfI];
}
}
else
{
const label ownSurfI = insideSurfaces[nCandidates++];
if (ownSurfI != -1)
{
cellToZone[own] = surfaceToCellZone[ownSurfI];
}
}
}
}
// Adapt the namedSurfaceIndex
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
// for if any cells were not completely covered.
for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
{
const label ownZone = cellToZone[mesh_.faceOwner()[facei]];
const label neiZone = cellToZone[mesh_.faceNeighbour()[facei]];
if (namedSurfaceIndex[facei] == -1 && (ownZone != neiZone))
{
// Give face the zone of max cell zone
namedSurfaceIndex[facei] = findIndex
(
surfaceToCellZone,
max(ownZone, neiZone)
);
}
}
labelList neiCellZone(mesh_.nFaces() - mesh_.nInternalFaces());
const polyBoundaryMesh& patches = mesh_.poly().boundary();
forAll(patches, patchi)
{
const polyPatch& pp = patches[patchi];
if (pp.coupled())
{
forAll(pp, i)
{
const label facei = pp.start() + i;
const label ownZone = cellToZone[mesh_.faceOwner()[facei]];
neiCellZone[facei-mesh_.nInternalFaces()] = ownZone;
}
}
}
syncTools::swapBoundaryFaceList(mesh_, neiCellZone);
forAll(patches, patchi)
{
const polyPatch& pp = patches[patchi];
if (pp.coupled())
{
forAll(pp, i)
{
const label facei = pp.start() + i;
const label ownZone = cellToZone[mesh_.faceOwner()[facei]];
const label neiZone = neiCellZone[facei-mesh_.nInternalFaces()];
if (namedSurfaceIndex[facei] == -1 && (ownZone != neiZone))
{
// Give face the max cell zone
namedSurfaceIndex[facei] = findIndex
(
surfaceToCellZone,
max(ownZone, neiZone)
);
}
}
}
}
// Sync
syncTools::syncFaceList(mesh_, namedSurfaceIndex, maxEqOp());
}
void Foam::meshRefinement::findCellZoneInsideWalk
(
const labelList& locationSurfaces, // indices of surfaces with inside point
const labelList& namedSurfaceIndex, // per face index of named surface
const labelList& surfaceToCellZone, // cell zone index per surface
labelList& cellToZone
) const
{
// Analyse regions. Reuse regionsplit
boolList blockedFace(mesh_.nFaces());
// selectSeparatedCoupledFaces(blockedFace);
forAll(namedSurfaceIndex, facei)
{
if (namedSurfaceIndex[facei] == -1)
{
blockedFace[facei] = false;
}
else
{
blockedFace[facei] = true;
}
}
// No need to sync since namedSurfaceIndex already is synced
// Set region per cell based on walking
regionSplit cellRegion(mesh_, blockedFace);
blockedFace.clear();
// Force calculation of face decomposition (used in findCell)
(void)mesh_.tetBasePtIs();
const PtrList<surfaceZonesInfo>& surfZones = surfaces_.surfZones();
// For all locationSurface find the cell
forAll(locationSurfaces, i)
{
const label surfi = locationSurfaces[i];
const point& insidePoint = surfZones[surfi].zoneInsidePoint();
Info<< "For surface " << surfaces_.names()[surfi]
<< " finding inside point " << insidePoint
<< endl;
// Find the region containing the insidePoint
label regioninMeshi = findRegion
(
mesh_,
cellRegion,
mergeDistance_*vector::one,
insidePoint
);
Info<< "For surface " << surfaces_.names()[surfi]
<< " found point " << insidePoint
<< " in global region " << regioninMeshi
<< " out of " << cellRegion.nRegions() << " regions." << endl;
if (regioninMeshi == -1)
{
FatalErrorInFunction
<< "Point " << insidePoint
<< " is not inside the mesh." << nl
<< "Bounding box of the mesh:" << mesh_.bounds()
<< exit(FatalError);
}
// Set all cells with this region
forAll(cellRegion, celli)
{
if (cellRegion[celli] == regioninMeshi)
{
if (cellToZone[celli] == -2)
{
cellToZone[celli] = surfaceToCellZone[surfi];
}
else if (cellToZone[celli] != surfaceToCellZone[surfi])
{
WarningInFunction
<< "Cell " << celli
<< " at " << mesh_.cellCentres()[celli]
<< " is inside surface " << surfaces_.names()[surfi]
<< " but already marked as being in zone "
<< cellToZone[celli] << endl
<< "This can happen if your surfaces are not"
<< " (sufficiently) closed."
<< endl;
}
}
}
}
}
bool Foam::meshRefinement::calcRegionToZone
(
const label surfZoneI,
const label ownRegion,
const label neiRegion,
labelList& regionToCellZone
) const
{
bool changed = false;
// Check whether in between different regions
if (ownRegion != neiRegion)
{
// Jump. Change one of the sides to my type.
// 1. Interface between my type and unset region.
// Set region to regioninMesh
if (regionToCellZone[ownRegion] == -2)
{
if (regionToCellZone[neiRegion] == surfZoneI)
{
// Face between unset and my region. Put unset
// region into regioninMesh
regionToCellZone[ownRegion] = -1;
changed = true;
}
else if (regionToCellZone[neiRegion] != -2)
{
// Face between unset and other region.
// Put unset region into my region
regionToCellZone[ownRegion] = surfZoneI;
changed = true;
}
}
else if (regionToCellZone[neiRegion] == -2)
{
if (regionToCellZone[ownRegion] == surfZoneI)
{
// Face between unset and my region. Put unset
// region into regioninMesh
regionToCellZone[neiRegion] = -1;
changed = true;
}
else if (regionToCellZone[ownRegion] != -2)
{
// Face between unset and other region.
// Put unset region into my region
regionToCellZone[neiRegion] = surfZoneI;
changed = true;
}
}
}
return changed;
}
void Foam::meshRefinement::findCellZoneTopo
(
const List<point>& insidePoints,
const labelList& namedSurfaceIndex,
const labelList& surfaceToCellZone,
labelList& cellToZone
) const
{
// Assumes:
// - region containing insidePoints does not go into a cellZone
// - all other regions can be found by crossing faces marked in
// namedSurfaceIndex.
// Analyse regions. Reuse regionsplit
boolList blockedFace(mesh_.nFaces());
forAll(namedSurfaceIndex, facei)
{
if (namedSurfaceIndex[facei] == -1)
{
blockedFace[facei] = false;
}
else
{
blockedFace[facei] = true;
}
}
// No need to sync since namedSurfaceIndex already is synced
// Set region per cell based on walking
regionSplit cellRegion(mesh_, blockedFace);
blockedFace.clear();
// Per mesh region the zone the cell should be put in.
// -2 : not analysed yet
// -1 : insidePoint region. Not put into any cellzone.
// >= 0 : index of cellZone
labelList regionToCellZone(cellRegion.nRegions(), -2);
// See which cells already are set in the cellToZone (from geometric
// searching) and use these to take over their zones.
// Note: could be improved to count number of cells per region.
forAll(cellToZone, celli)
{
if (cellToZone[celli] != -2)
{
regionToCellZone[cellRegion[celli]] = cellToZone[celli];
}
}
// Find the regions containing the insidePoints
forAll(insidePoints, i)
{
const label regioninMeshi = findRegion
(
mesh_,
cellRegion,
mergeDistance_*vector::one,
insidePoints[i]
);
Info<< "Found point " << insidePoints[i]
<< " in global region " << regioninMeshi
<< " out of " << cellRegion.nRegions() << " regions." << endl;
if (regioninMeshi == -1)
{
FatalErrorInFunction
<< "Point " << insidePoints[i]
<< " is not inside the mesh." << nl
<< "Bounding box of the mesh:" << mesh_.bounds()
<< exit(FatalError);
}
// Mark default region with zone -1.
if (regionToCellZone[regioninMeshi] == -2)
{
regionToCellZone[regioninMeshi] = -1;
}
}
// Find correspondence between cell zone and surface
// by changing cell zone every time we cross a surface.
while (true)
{
// Synchronise regionToCellZone.
// Note:
// - region numbers are identical on all processors
// - regioninMesh is identical ,,
// - cellZones are identical ,,
// This done at top of loop to account for geometric matching
// not being synchronised.
Pstream::listCombineGather(regionToCellZone, maxEqOp());
Pstream::listCombineScatter(regionToCellZone);
bool changed = false;
// Internal faces
for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
{
const label surfi = namedSurfaceIndex[facei];
// Connected even if no cellZone defined for surface
if (surfi != -1)
{
// Calculate region to zone from cellRegions on either side
// of internal face.
const bool changedCell = calcRegionToZone
(
surfaceToCellZone[surfi],
cellRegion[mesh_.faceOwner()[facei]],
cellRegion[mesh_.faceNeighbour()[facei]],
regionToCellZone
);
changed = changed | changedCell;
}
}
// Boundary faces
const polyBoundaryMesh& patches = mesh_.poly().boundary();
// Get coupled neighbour cellRegion
labelList neiCellRegion(mesh_.nFaces() - mesh_.nInternalFaces());
forAll(patches, patchi)
{
const polyPatch& pp = patches[patchi];
if (pp.coupled())
{
forAll(pp, i)
{
const label facei = pp.start() + i;
neiCellRegion[facei-mesh_.nInternalFaces()] =
cellRegion[mesh_.faceOwner()[facei]];
}
}
}
syncTools::swapBoundaryFaceList(mesh_, neiCellRegion);
// Calculate region to zone from cellRegions on either side of coupled
// face.
forAll(patches, patchi)
{
const polyPatch& pp = patches[patchi];
if (pp.coupled())
{
forAll(pp, i)
{
const label facei = pp.start() + i;
const label surfi = namedSurfaceIndex[facei];
// Connected even if no cellZone defined for surface
if (surfi != -1)
{
const bool changedCell = calcRegionToZone
(
surfaceToCellZone[surfi],
cellRegion[mesh_.faceOwner()[facei]],
neiCellRegion[facei-mesh_.nInternalFaces()],
regionToCellZone
);
changed = changed | changedCell;
}
}
}
}
if (!returnReduce(changed, orOp()))
{
break;
}
}
forAll(regionToCellZone, regioni)
{
const label zonei = regionToCellZone[regioni];
if (zonei == -2)
{
FatalErrorInFunction
<< "For region " << regioni << " haven't set cell zone."
<< exit(FatalError);
}
}
if (debug)
{
forAll(regionToCellZone, regioni)
{
Pout<< "Region " << regioni
<< " becomes cellZone:" << regionToCellZone[regioni]
<< endl;
}
}
// Rework into cellToZone
forAll(cellToZone, celli)
{
cellToZone[celli] = regionToCellZone[cellRegion[celli]];
}
}
void Foam::meshRefinement::makeConsistentFaceIndex
(
const labelList& cellToZone,
labelList& namedSurfaceIndex
) const
{
const labelList& faceOwner = mesh_.faceOwner();
const labelList& faceNeighbour = mesh_.faceNeighbour();
for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
{
const label ownZone = cellToZone[faceOwner[facei]];
const label neiZone = cellToZone[faceNeighbour[facei]];
if (ownZone == neiZone && namedSurfaceIndex[facei] != -1)
{
namedSurfaceIndex[facei] = -1;
}
else if (ownZone != neiZone && namedSurfaceIndex[facei] == -1)
{
FatalErrorInFunction
<< "Different cell zones on either side of face " << facei
<< " at " << mesh_.faceCentres()[facei]
<< " but face not marked with a surface."
<< abort(FatalError);
}
}
const polyBoundaryMesh& patches = mesh_.poly().boundary();
// Get coupled neighbour cellZone
labelList neiCellZone(mesh_.nFaces() - mesh_.nInternalFaces());
forAll(patches, patchi)
{
const polyPatch& pp = patches[patchi];
if (pp.coupled())
{
forAll(pp, i)
{
const label facei = pp.start() + i;
neiCellZone[facei-mesh_.nInternalFaces()] =
cellToZone[mesh_.faceOwner()[facei]];
}
}
}
syncTools::swapBoundaryFaceList(mesh_, neiCellZone);
// Use coupled cellZone to do check
forAll(patches, patchi)
{
const polyPatch& pp = patches[patchi];
if (pp.coupled())
{
forAll(pp, i)
{
const label facei = pp.start() + i;
const label ownZone = cellToZone[faceOwner[facei]];
const label neiZone = neiCellZone[facei-mesh_.nInternalFaces()];
if (ownZone == neiZone && namedSurfaceIndex[facei] != -1)
{
namedSurfaceIndex[facei] = -1;
}
else if (ownZone != neiZone && namedSurfaceIndex[facei] == -1)
{
FatalErrorInFunction
<< "Different cell zones on either side of face "
<< facei << " at " << mesh_.faceCentres()[facei]
<< " but face not marked with a surface."
<< abort(FatalError);
}
}
}
else
{
// Unzonify boundary faces
forAll(pp, i)
{
const label facei = pp.start() + i;
namedSurfaceIndex[facei] = -1;
}
}
}
}
void Foam::meshRefinement::handleSnapProblems
(
const snapParameters& snapParams,
const bool useTopologicalSnapDetection,
const bool removeEdgeConnectedCells,
const scalarField& perpendicularAngle,
const dictionary& motionDict,
Time& runTime,
const labelList& globalToMasterPatch,
const labelList& globalToSlavePatch
)
{
Info<< nl
<< "Introducing baffles to block off problem cells" << nl
<< "----------------------------------------------" << nl
<< endl;
labelList facePatch;
if (useTopologicalSnapDetection)
{
facePatch = markFacesOnProblemCells
(
motionDict,
removeEdgeConnectedCells,
perpendicularAngle,
globalToMasterPatch
);
}
else
{
facePatch = markFacesOnProblemCellsGeometric(snapParams, motionDict);
}
Info<< "Analyzed problem cells in = "
<< runTime.cpuTimeIncrement() << " s\n" << nl << endl;
if (debug&MESH)
{
faceSet problemFaces(mesh_, "problemFaces", mesh_.nFaces()/100);
forAll(facePatch, facei)
{
if (facePatch[facei] != -1)
{
problemFaces.insert(facei);
}
}
problemFaces.instance() = name();
Pout<< "Dumping " << problemFaces.size()
<< " problem faces to " << problemFaces.objectPath() << endl;
problemFaces.write();
}
Info<< "Introducing baffles to delete problem cells." << nl << endl;
if (debug)
{
runTime++;
}
// Create baffles with same owner and neighbour for now.
createBaffles(facePatch, facePatch);
if (debug)
{
// Debug:test all is still synced across proc patches
checkData();
}
Info<< "Created baffles in = "
<< runTime.cpuTimeIncrement() << " s\n" << nl << endl;
printMeshInfo(debug, "After introducing baffles");
if (debug&MESH)
{
Pout<< "Writing extra baffled mesh to time "
<< name() << endl;
write
(
debugType(debug),
writeType(writeLevel() | WRITEMESH),
runTime.path()/"extraBaffles"
);
Pout<< "Dumped debug data in = "
<< runTime.cpuTimeIncrement() << " s\n" << nl << endl;
}
}
Foam::labelList Foam::meshRefinement::freeStandingBaffleFaces
(
const labelList& faceToZone,
const labelList& cellToZone,
const labelList& neiCellZone
) const
{
const polyBoundaryMesh& patches = mesh_.poly().boundary();
const labelList& faceOwner = mesh_.faceOwner();
const labelList& faceNeighbour = mesh_.faceNeighbour();
// We want to pick up the faces to orient. These faces come in
// two variants:
// - faces originating from stand-alone faceZones
// (these will most likely have no cellZone on either side so
// ownZone and neiZone both -1)
// - sticky-up faces originating from a 'bulge' in a outside of
// a cellZone. These will have the same cellZone on either side.
// How to orient these is not really clearly defined so do them
// same as stand-alone faceZone faces for now. (Normally these will
// already have been removed by the 'allowFreeStandingZoneFaces=false'
// default setting)
// Note that argument neiCellZone will have -1 on uncoupled boundaries.
DynamicList<label> faceLabels(mesh_.nFaces()/100);
for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
{
if (faceToZone[facei] != -1)
{
// Free standing baffle?
const label ownZone = cellToZone[faceOwner[facei]];
const label neiZone = cellToZone[faceNeighbour[facei]];
if (ownZone == neiZone)
{
faceLabels.append(facei);
}
}
}
forAll(patches, patchi)
{
const polyPatch& pp = patches[patchi];
forAll(pp, i)
{
const label facei = pp.start() + i;
if (faceToZone[facei] != -1)
{
// Free standing baffle?
const label ownZone = cellToZone[faceOwner[facei]];
const label neiZone =
neiCellZone[facei - mesh_.nInternalFaces()];
if (ownZone == neiZone)
{
faceLabels.append(facei);
}
}
}
}
return faceLabels.shrink();
}
void Foam::meshRefinement::calcPatchNumMasterFaces
(
const PackedBoolList& isMasterFace,
const indirectPrimitivePatch& patch,
labelList& nMasterFacesPerEdge
) const
{
// Number of (master)faces per edge
nMasterFacesPerEdge.setSize(patch.nEdges());
nMasterFacesPerEdge = 0;
forAll(patch.addressing(), facei)
{
const label meshFacei = patch.addressing()[facei];
if (isMasterFace[meshFacei])
{
const labelList& fEdges = patch.faceEdges()[facei];
forAll(fEdges, fEdgei)
{
nMasterFacesPerEdge[fEdges[fEdgei]]++;
}
}
}
syncTools::syncEdgeList
(
mesh_,
patch.meshEdges(mesh_.edges(), mesh_.pointEdges()),
nMasterFacesPerEdge,
addEqOp(),
label(0)
);
}
Foam::label Foam::meshRefinement::markPatchZones
(
const indirectPrimitivePatch& patch,
const labelList& nMasterFacesPerEdge,
labelList& faceToZone
) const
{
List<patchEdgeFaceRegion> allEdgeInfo(patch.nEdges());
List<patchEdgeFaceRegion> allFaceInfo(patch.size());
// Protect all non-manifold edges
{
forAll(nMasterFacesPerEdge, edgei)
{
if (nMasterFacesPerEdge[edgei] > 2)
{
allEdgeInfo[edgei] = -2;
}
}
}
// Hand out zones
DynamicList<label> changedEdges;
DynamicList<patchEdgeFaceRegion> changedInfo;
const scalar tol = PatchEdgeFaceWave
<
indirectPrimitivePatch,
patchEdgeFaceRegion
>::propagationTol();
int dummyTrackData;
const globalIndex globalFaces(patch.size());
label facei = 0;
label currentZoneI = 0;
while (true)
{
// Pick an unset face
label globalSeed = labelMax;
for (; facei < allFaceInfo.size(); facei++)
{
if (!allFaceInfo[facei].valid(dummyTrackData))
{
globalSeed = globalFaces.toGlobal(facei);
break;
}
}
reduce(globalSeed, minOp());
if (globalSeed == labelMax)
{
break;
}
const label proci = globalFaces.whichProcID(globalSeed);
const label seedFacei = globalFaces.toLocal(proci, globalSeed);
// Info<< "Seeding zone " << currentZoneI
// << " from processor " << proci << " face " << seedFacei
// << endl;
if (proci == Pstream::myProcNo())
{
patchEdgeFaceRegion& faceInfo = allFaceInfo[seedFacei];
// Set face
faceInfo = currentZoneI;
// .. and seed its edges
const labelList& fEdges = patch.faceEdges()[seedFacei];
forAll(fEdges, fEdgei)
{
const label edgei = fEdges[fEdgei];
patchEdgeFaceRegion& edgeinfo = allEdgeInfo[edgei];
if
(
edgeinfo.updateEdge<indirectPrimitivePatch, int>
(
mesh_,
patch,
edgei,
seedFacei,
faceInfo,
tol,
dummyTrackData
)
)
{
changedEdges.append(edgei);
changedInfo.append(edgeinfo);
}
}
}
if (returnReduce(changedEdges.size(), sumOp()) == 0)
{
break;
}
// Walk
PatchEdgeFaceWave
<
indirectPrimitivePatch,
patchEdgeFaceRegion
> calc
(
mesh_,
patch,
changedEdges,
changedInfo,
allEdgeInfo,
allFaceInfo,
returnReduce(patch.nEdges(), sumOp())
);
currentZoneI++;
}
faceToZone.setSize(patch.size());
forAll(allFaceInfo, facei)
{
if (!allFaceInfo[facei].valid(dummyTrackData))
{
FatalErrorInFunction
<< "Problem: unvisited face " << facei
<< " at " << patch.faceCentres()[facei]
<< exit(FatalError);
}
faceToZone[facei] = allFaceInfo[facei].region();
}
return currentZoneI;
}
void Foam::meshRefinement::consistentOrientation
(
const PackedBoolList& isMasterFace,
const indirectPrimitivePatch& patch,
const labelList& nMasterFacesPerEdge,
const labelList& faceToZone,
const Map<label>& zoneToOrientation,
boolList& meshFlipMap
) const
{
const polyBoundaryMesh& bm = mesh_.poly().boundary();
// Data on all edges and faces
List<patchFaceOrientation> allEdgeInfo(patch.nEdges());
List<patchFaceOrientation> allFaceInfo(patch.size());
// Make sure we don't walk through
// - slaves of coupled faces
// - non-manifold edges
{
forAll(patch.addressing(), facei)
{
const label meshFacei = patch.addressing()[facei];
const label patchi = bm.whichPatch(meshFacei);
if
(
patchi != -1
&& bm[patchi].coupled()
&& !isMasterFace[meshFacei]
)
{
// Slave side. Mark so doesn't get visited.
allFaceInfo[facei] = orientedSurface::NOFLIP;
}
}
}
{
label nProtected = 0;
forAll(nMasterFacesPerEdge, edgei)
{
if (nMasterFacesPerEdge[edgei] > 2)
{
allEdgeInfo[edgei] = orientedSurface::NOFLIP;
nProtected++;
}
}
Info<< "Protected from visiting "
<< returnReduce(nProtected, sumOp())
<< " non-manifold edges" << nl << endl;
}
DynamicList<label> changedEdges;
DynamicList<patchFaceOrientation> changedInfo;
const scalar tol = PatchEdgeFaceWave
<
indirectPrimitivePatch,
patchFaceOrientation
>::propagationTol();
int dummyTrackData;
globalIndex globalFaces(patch.size());
while (true)
{
// Pick an unset face
label globalSeed = labelMax;
forAll(allFaceInfo, facei)
{
if (allFaceInfo[facei] == orientedSurface::UNVISITED)
{
globalSeed = globalFaces.toGlobal(facei);
break;
}
}
reduce(globalSeed, minOp());
if (globalSeed == labelMax)
{
break;
}
const label proci = globalFaces.whichProcID(globalSeed);
const label seedFacei = globalFaces.toLocal(proci, globalSeed);
// Info<< "Seeding from processor " << proci << " face " << seedFacei
// << endl;
if (proci == Pstream::myProcNo())
{
// Determine orientation of seedFace
patchFaceOrientation& faceInfo = allFaceInfo[seedFacei];
// Start off with correct orientation
faceInfo = orientedSurface::NOFLIP;
if (zoneToOrientation[faceToZone[seedFacei]] < 0)
{
faceInfo.flip();
}
const labelList& fEdges = patch.faceEdges()[seedFacei];
forAll(fEdges, fEdgei)
{
const label edgei = fEdges[fEdgei];
patchFaceOrientation& edgeinfo = allEdgeInfo[edgei];
if
(
edgeinfo.updateEdge<int>
(
mesh_,
patch,
edgei,
seedFacei,
faceInfo,
tol,
dummyTrackData
)
)
{
changedEdges.append(edgei);
changedInfo.append(edgeinfo);
}
}
}
if (returnReduce(changedEdges.size(), sumOp()) == 0)
{
break;
}
// Walk
PatchEdgeFaceWave
<
indirectPrimitivePatch,
patchFaceOrientation
> calc
(
mesh_,
patch,
changedEdges,
changedInfo,
allEdgeInfo,
allFaceInfo,
returnReduce(patch.nEdges(), sumOp())
);
}
// Push master zone info over to slave (since slave faces never visited)
{
labelList neiStatus
(
mesh_.nFaces() - mesh_.nInternalFaces(),
orientedSurface::UNVISITED
);
forAll(patch.addressing(), i)
{
const label meshFacei = patch.addressing()[i];
if (!mesh_.isInternalFace(meshFacei))
{
neiStatus[meshFacei-mesh_.nInternalFaces()] =
allFaceInfo[i].flipStatus();
}
}
syncTools::swapBoundaryFaceList(mesh_, neiStatus);
forAll(patch.addressing(), i)
{
const label meshFacei = patch.addressing()[i];
const label patchi = bm.whichPatch(meshFacei);
if
(
patchi != -1
&& bm[patchi].coupled()
&& !isMasterFace[meshFacei]
)
{
// Slave side. Take flipped from neighbour
label bFacei = meshFacei-mesh_.nInternalFaces();
if (neiStatus[bFacei] == orientedSurface::NOFLIP)
{
allFaceInfo[i] = orientedSurface::FLIP;
}
else if (neiStatus[bFacei] == orientedSurface::FLIP)
{
allFaceInfo[i] = orientedSurface::NOFLIP;
}
else
{
FatalErrorInFunction
<< "Incorrect status for face " << meshFacei
<< abort(FatalError);
}
}
}
}
// Convert to meshFlipMap and adapt faceZones
meshFlipMap.setSize(mesh_.nFaces());
meshFlipMap = false;
forAll(allFaceInfo, facei)
{
label meshFacei = patch.addressing()[facei];
if (allFaceInfo[facei] == orientedSurface::NOFLIP)
{
meshFlipMap[meshFacei] = false;
}
else if (allFaceInfo[facei] == orientedSurface::FLIP)
{
meshFlipMap[meshFacei] = true;
}
else
{
FatalErrorInFunction
<< "Problem : unvisited face " << facei
<< " centre:" << mesh_.faceCentres()[meshFacei]
<< abort(FatalError);
}
}
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::meshRefinement::baffleAndSplitMesh
(
const bool doHandleSnapProblems,
const snapParameters& snapParams,
const bool useTopologicalSnapDetection,
const bool removeEdgeConnectedCells,
const scalarField& perpendicularAngle,
const bool mergeFreeStanding,
const scalar planarAngle,
const dictionary& motionDict,
Time& runTime,
const labelList& globalToMasterPatch,
const labelList& globalToSlavePatch,
const refinementParameters::cellSelectionPoints& selectionPoints
)
{
// Introduce baffles
// ~~~~~~~~~~~~~~~~~
// Split the mesh along internal faces wherever there is a pierce between
// two cell centres.
Info<< "Introducing baffles for "
<< returnReduce(countHits(), sumOp())
<< " faces that are intersected by the surface." << nl << endl;
// Swap neighbouring cell centres and cell level
labelList neiLevel(mesh_.nFaces() - mesh_.nInternalFaces());
pointField neiCc(mesh_.nFaces() - mesh_.nInternalFaces());
calcNeighbourData(neiLevel, neiCc);
labelList ownPatch, nbrPatch;
getBafflePatches
(
globalToMasterPatch,
neiLevel,
neiCc,
ownPatch,
nbrPatch
);
createBaffles(ownPatch, nbrPatch);
if (debug)
{
// Debug:test all is still synced across proc patches
checkData();
}
Info<< "Created baffles in = "
<< runTime.cpuTimeIncrement() << " s\n" << nl << endl;
printMeshInfo(debug, "After introducing baffles");
if (debug&MESH)
{
Pout<< "Writing baffled mesh to time " << name()
<< endl;
write
(
debugType(debug),
writeType(writeLevel() | WRITEMESH),
runTime.path()/"baffles"
);
Pout<< "Dumped debug data in = "
<< runTime.cpuTimeIncrement() << " s\n" << nl << endl;
}
// Introduce baffles to delete problem cells
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Create some additional baffles where we want surface cells removed.
if (doHandleSnapProblems)
{
handleSnapProblems
(
snapParams,
useTopologicalSnapDetection,
removeEdgeConnectedCells,
perpendicularAngle,
motionDict,
runTime,
globalToMasterPatch,
globalToSlavePatch
);
}
// Select part of mesh
// ~~~~~~~~~~~~~~~~~~~
Info<< nl
<< "Remove unreachable sections of mesh" << nl
<< "-----------------------------------" << nl
<< endl;
if (debug)
{
runTime++;
}
splitMeshRegions(globalToMasterPatch, globalToSlavePatch, selectionPoints);
if (debug)
{
// Debug:test all is still synced across proc patches
checkData();
}
Info<< "Split mesh in = "
<< runTime.cpuTimeIncrement() << " s\n" << nl << endl;
printMeshInfo(debug, "After subsetting");
if (debug&MESH)
{
Pout<< "Writing subsetted mesh to time " << name()
<< endl;
write
(
debugType(debug),
writeType(writeLevel() | WRITEMESH),
runTime.path()/name()
);
Pout<< "Dumped debug data in = "
<< runTime.cpuTimeIncrement() << " s\n" << nl << endl;
}
// Merge baffles
// ~~~~~~~~~~~~~
if (mergeFreeStanding)
{
Info<< nl
<< "Merge free-standing baffles" << nl
<< "---------------------------" << nl
<< endl;
// List of pairs of freestanding baffle faces.
List<labelPair> couples
(
freeStandingBaffles // filter out freestanding baffles
(
localPointRegion::findDuplicateFacePairs(mesh_),
planarAngle
)
);
label nCouples = couples.size();
reduce(nCouples, sumOp());
Info<< "Detected free-standing baffles : " << nCouples << endl;
if (nCouples > 0)
{
// Actually merge baffles. Note: not exactly parallelised. Should
// convert baffle faces into processor faces if they resulted
// from them.
mergeBaffles(couples);
// Detect any problem cells resulting from merging of baffles
// and delete them
handleSnapProblems
(
snapParams,
useTopologicalSnapDetection,
removeEdgeConnectedCells,
perpendicularAngle,
motionDict,
runTime,
globalToMasterPatch,
globalToSlavePatch
);
if (debug)
{
// Debug:test all is still synced across proc patches
checkData();
}
}
Info<< "Merged free-standing baffles in = "
<< runTime.cpuTimeIncrement() << " s\n" << nl << endl;
}
}
Foam::autoPtr<Foam::polyTopoChangeMap> Foam::meshRefinement::splitMesh
(
const label nBufferLayers,
const labelList& globalToMasterPatch,
const labelList& globalToSlavePatch,
const refinementParameters::cellSelectionPoints& selectionPoints
)
{
// Determine patches to put intersections into
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Swap neighbouring cell centres and cell level
labelList neiLevel(mesh_.nFaces() - mesh_.nInternalFaces());
pointField neiCc(mesh_.nFaces() - mesh_.nInternalFaces());
calcNeighbourData(neiLevel, neiCc);
labelList ownPatch;
labelList nbrPatch;
getBafflePatches
(
globalToMasterPatch,
neiLevel,
neiCc,
ownPatch,
nbrPatch
);
// Analyse regions. Reuse regionsplit
boolList blockedFace(mesh_.nFaces(), false);
forAll(ownPatch, facei)
{
if (ownPatch[facei] != -1 || nbrPatch[facei] != -1)
{
blockedFace[facei] = true;
}
}
syncTools::syncFaceList(mesh_, blockedFace, orEqOp());
// Set region per cell based on walking
regionSplit cellRegion(mesh_, blockedFace);
blockedFace.clear();
// Find the regions containing any of the points in selectionPoints
findRegions
(
mesh_,
cellRegion,
mergeDistance_*vector::one,
selectionPoints
);
// Walk out nBufferlayers from region split
// (modifies cellRegion, ownPatch)
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Takes over face patch onto points and then back to faces and cells
// (so cell-face-point walk)
const labelList& faceOwner = mesh_.faceOwner();
const labelList& faceNeighbour = mesh_.faceNeighbour();
// Patch for exposed faces for lack of anything sensible.
label defaultPatch = 0;
if (globalToMasterPatch.size())
{
defaultPatch = globalToMasterPatch[0];
}
for (label i = 0; i < nBufferLayers; i++)
{
// 1. From cells (via faces) to points
labelList pointBaffle(mesh_.nPoints(), -1);
forAll(faceNeighbour, facei)
{
const face& f = mesh_.faces()[facei];
const label ownRegion = cellRegion[faceOwner[facei]];
const label neiRegion = cellRegion[faceNeighbour[facei]];
if (ownRegion == -1 && neiRegion != -1)
{
// Note max(..) since possibly regionSplit might have split
// off extra unreachable parts of mesh. Note: or can this only
// happen for boundary faces?
forAll(f, fp)
{
pointBaffle[f[fp]] = max(defaultPatch, ownPatch[facei]);
}
}
else if (ownRegion != -1 && neiRegion == -1)
{
label newPatchi = nbrPatch[facei];
if (newPatchi == -1)
{
newPatchi = max(defaultPatch, ownPatch[facei]);
}
forAll(f, fp)
{
pointBaffle[f[fp]] = newPatchi;
}
}
}
for
(
label facei = mesh_.nInternalFaces();
facei < mesh_.nFaces();
facei++
)
{
const face& f = mesh_.faces()[facei];
const label ownRegion = cellRegion[faceOwner[facei]];
if (ownRegion == -1)
{
forAll(f, fp)
{
pointBaffle[f[fp]] = max(defaultPatch, ownPatch[facei]);
}
}
}
// Sync
syncTools::syncPointList
(
mesh_,
pointBaffle,
maxEqOp(),
label(-1) // null value
);
// 2. From points back to faces
const labelListList& pointFaces = mesh_.pointFaces();
forAll(pointFaces, pointi)
{
if (pointBaffle[pointi] != -1)
{
const labelList& pFaces = pointFaces[pointi];
forAll(pFaces, pFacei)
{
const label facei = pFaces[pFacei];
if (ownPatch[facei] == -1)
{
ownPatch[facei] = pointBaffle[pointi];
}
}
}
}
syncTools::syncFaceList(mesh_, ownPatch, maxEqOp());
// 3. From faces to cells (cellRegion) and back to faces (ownPatch)
labelList newOwnPatch(ownPatch);
forAll(ownPatch, facei)
{
if (ownPatch[facei] != -1)
{
const label own = faceOwner[facei];
if (cellRegion[own] == -1)
{
cellRegion[own] = labelMax;
const cell& ownFaces = mesh_.cells()[own];
forAll(ownFaces, j)
{
if (ownPatch[ownFaces[j]] == -1)
{
newOwnPatch[ownFaces[j]] = ownPatch[facei];
}
}
}
if (mesh_.isInternalFace(facei))
{
const label nei = faceNeighbour[facei];
if (cellRegion[nei] == -1)
{
cellRegion[nei] = labelMax;
const cell& neiFaces = mesh_.cells()[nei];
forAll(neiFaces, j)
{
if (ownPatch[neiFaces[j]] == -1)
{
newOwnPatch[neiFaces[j]] = ownPatch[facei];
}
}
}
}
}
}
ownPatch.transfer(newOwnPatch);
syncTools::syncFaceList(mesh_, ownPatch, maxEqOp());
}
// Subset
// ~~~~~~
// Get cells to remove
DynamicList<label> cellsToRemove(mesh_.nCells());
forAll(cellRegion, celli)
{
if (cellRegion[celli] == -1)
{
cellsToRemove.append(celli);
}
}
cellsToRemove.shrink();
label nCellsInMesh = mesh_.nCells() - cellsToRemove.size();
reduce(nCellsInMesh, sumOp());
Info<< indent
<< "Selecting all cells in regions containing any of the points in "
<< selectionPoints.inside() << endl
<< "Selected: " << nCellsInMesh << " cells." << endl;
// Remove cells
removeCells cellRemover(mesh_);
// Pick up patches for exposed faces
labelList exposedFaces(cellRemover.getExposedFaces(cellsToRemove));
labelList exposedPatches(exposedFaces.size());
forAll(exposedFaces, i)
{
const label facei = exposedFaces[i];
if (ownPatch[facei] != -1)
{
exposedPatches[i] = ownPatch[facei];
}
else
{
WarningInFunction
<< "For exposed face " << facei
<< " fc:" << mesh_.faceCentres()[facei]
<< " found no patch." << endl
<< " Taking patch " << defaultPatch
<< " instead." << endl;
exposedPatches[i] = defaultPatch;
}
}
return doRemoveCells
(
cellsToRemove,
exposedFaces,
exposedPatches,
cellRemover
);
}
Foam::autoPtr<Foam::polyTopoChangeMap>
Foam::meshRefinement::dupNonManifoldPoints
(
const localPointRegion& regionSide
)
{
// Topochange container
polyTopoChange meshMod(mesh_);
const label nNonManifPoints = returnReduce
(
regionSide.meshPointMap().size(),
sumOp()
);
Info<< "dupNonManifoldPoints : Found : " << nNonManifPoints
<< " non-manifold points (out of "
<< mesh_.globalData().nTotalPoints()
<< ')' << endl;
// Topo change engine
duplicatePoints pointDuplicator(mesh_);
// Insert changes into meshMod
pointDuplicator.setRefinement(regionSide, meshMod);
mesh_.clearOut();
// Change the mesh, parallel sync
autoPtr<polyTopoChangeMap> map = meshMod.changeMesh(mesh_, true);
// Update fields
mesh_.topoChange(map);
// Reset the instance for if in overwrite mode
mesh_.setInstance(name());
// Update intersections. Is mapping only (no faces created, positions stay
// same) so no need to recalculate intersections.
topoChange(map, labelList(0));
return map;
}
Foam::autoPtr<Foam::polyTopoChangeMap>
Foam::meshRefinement::dupNonManifoldPoints()
{
// Analyse which points need to be duplicated
localPointRegion regionSide(mesh_);
return dupNonManifoldPoints(regionSide);
}
Foam::autoPtr<Foam::polyTopoChangeMap> Foam::meshRefinement::zonify
(
const List<point>& insidePoints,
const bool allowFreeStandingZoneFaces
)
{
const PtrList<surfaceZonesInfo>& surfZones = surfaces_.surfZones();
const labelList namedSurfaces
(
surfaceZonesInfo::getNamedSurfaces(surfZones)
);
forAll(namedSurfaces, i)
{
label surfi = namedSurfaces[i];
Info<< "Surface : " << surfaces_.names()[surfi] << nl
<< " faceZone : " << surfZones[surfi].faceZoneName() << nl
<< " cellZone : " << surfZones[surfi].cellZoneName() << endl;
}
// Add zones to mesh
const labelList surfaceToFaceZone =
surfaceZonesInfo::addFaceZonesToMesh
(
surfZones,
namedSurfaces,
mesh_
);
const labelList surfaceToCellZone =
surfaceZonesInfo::addCellZonesToMesh
(
surfZones,
namedSurfaces,
mesh_
);
const pointField& cellCentres = mesh_.cellCentres();
const labelList& faceOwner = mesh_.faceOwner();
const labelList& faceNeighbour = mesh_.faceNeighbour();
const polyBoundaryMesh& patches = mesh_.poly().boundary();
// Swap neighbouring cell centres and cell level
labelList neiLevel(mesh_.nFaces() - mesh_.nInternalFaces());
pointField neiCc(mesh_.nFaces() - mesh_.nInternalFaces());
calcNeighbourData(neiLevel, neiCc);
// Mark faces intersecting zoned surfaces
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Like surfaceIndex_ but only for named surfaces.
labelList namedSurfaceIndex(mesh_.nFaces(), -1);
PackedBoolList posOrientation(mesh_.nFaces());
{
// Statistics: number of faces per faceZone
labelList nSurfFaces(surfZones.size(), 0);
// Note: for all internal faces? internal + coupled?
// Since zonify is run after baffling the surfaceIndex_ on baffles is
// not synchronised across both baffle faces. Fortunately we don't
// do zonify baffle faces anyway (they are normal boundary faces).
// Collect candidate faces
// ~~~~~~~~~~~~~~~~~~~~~~~
labelList testFaces(intersectedFaces());
// Collect segments
// ~~~~~~~~~~~~~~~~
pointField start(testFaces.size());
pointField end(testFaces.size());
forAll(testFaces, i)
{
label facei = testFaces[i];
if (mesh_.isInternalFace(facei))
{
start[i] = cellCentres[faceOwner[facei]];
end[i] = cellCentres[faceNeighbour[facei]];
}
else
{
start[i] = cellCentres[faceOwner[facei]];
end[i] = neiCc[facei-mesh_.nInternalFaces()];
}
}
// Extend segments a bit
{
const vectorField smallVec(rootSmall*(end-start));
start -= smallVec;
end += smallVec;
}
// Do test for intersections
// ~~~~~~~~~~~~~~~~~~~~~~~~~
// Note that we intersect all intersected faces again. Could reuse
// the information already in surfaceIndex_.
labelList surface1;
List<pointIndexHit> hit1;
vectorField normal1;
labelList surface2;
List<pointIndexHit> hit2;
vectorField normal2;
{
labelList region1;
labelList region2;
surfaces_.findNearestIntersection
(
namedSurfaces,
start,
end,
surface1,
hit1,
region1,
normal1,
surface2,
hit2,
region2,
normal2
);
}
forAll(testFaces, i)
{
label facei = testFaces[i];
const vector& area = mesh_.faceAreas()[facei];
if (surface1[i] != -1)
{
// If both hit should probably choose 'nearest'
if
(
surface2[i] != -1
&& (
magSqr(hit2[i].hitPoint())
< magSqr(hit1[i].hitPoint())
)
)
{
namedSurfaceIndex[facei] = surface2[i];
posOrientation[facei] = ((area&normal2[i]) > 0);
nSurfFaces[surface2[i]]++;
}
else
{
namedSurfaceIndex[facei] = surface1[i];
posOrientation[facei] = ((area&normal1[i]) > 0);
nSurfFaces[surface1[i]]++;
}
}
else if (surface2[i] != -1)
{
namedSurfaceIndex[facei] = surface2[i];
posOrientation[facei] = ((area&normal2[i]) > 0);
nSurfFaces[surface2[i]]++;
}
}
// surfaceIndex might have different surfaces on both sides if
// there happen to be a (obviously thin) surface with different
// regions between the cell centres. If one is on a named surface
// and the other is not this might give problems so sync.
syncTools::syncFaceList
(
mesh_,
namedSurfaceIndex,
maxEqOp()
);
// Print a bit
if (debug)
{
forAll(nSurfFaces, surfi)
{
Pout<< "Surface:"
<< surfaces_.names()[surfi]
<< " nZoneFaces:" << nSurfFaces[surfi] << nl;
}
Pout<< endl;
}
}
// Put the cells into the correct zone
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Zone per cell:
// -2 : unset
// -1 : not in any zone
// >=0: zoneID
labelList cellToZone(mesh_.nCells(), -2);
// Set using geometric test
// ~~~~~~~~~~~~~~~~~~~~~~~~
// Closed surfaces with cellZone specified.
labelList closedNamedSurfaces
(
surfaceZonesInfo::getClosedNamedSurfaces
(
surfZones,
surfaces_.geometry(),
surfaces_.surfaces()
)
);
if (closedNamedSurfaces.size())
{
Info<< "Found " << closedNamedSurfaces.size()
<< " closed, named surfaces. Assigning cells in/outside"
<< " these surfaces to the corresponding cellZone."
<< nl << endl;
findCellZoneGeometric
(
neiCc,
closedNamedSurfaces, // indices of closed surfaces
namedSurfaceIndex, // per face index of named surface
surfaceToCellZone, // cell zone index per surface
cellToZone
);
}
// Set using provided locations
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
labelList locationSurfaces
(
surfaceZonesInfo::getInsidePointNamedSurfaces(surfZones)
);
if (locationSurfaces.size())
{
Info<< "Found " << locationSurfaces.size()
<< " named surfaces with a provided inside point."
<< " Assigning cells inside these surfaces"
<< " to the corresponding cellZone."
<< nl << endl;
findCellZoneInsideWalk
(
locationSurfaces, // indices of closed surfaces
namedSurfaceIndex, // per face index of named surface
surfaceToCellZone, // cell zone index per surface
cellToZone
);
}
// Set using walking
// ~~~~~~~~~~~~~~~~~
{
Info<< "Walking from locations-in-mesh " << insidePoints
<< " to assign cellZones "
<< "- crossing a faceZone face changes cellZone" << nl << endl;
// Topological walk
findCellZoneTopo
(
insidePoints,
namedSurfaceIndex,
surfaceToCellZone,
cellToZone
);
}
// Make sure namedSurfaceIndex is unset in between same cell cell zones.
if (!allowFreeStandingZoneFaces)
{
Info<< "Only selecting zone faces in between different cellZones."
<< nl << endl;
makeConsistentFaceIndex(cellToZone, namedSurfaceIndex);
}
//- Per face index of faceZone or -1
labelList faceToZone(mesh_.nFaces(), -1);
// Convert namedSurfaceIndex (index of named surfaces) to
// actual faceZone index
forAll(namedSurfaceIndex, facei)
{
const label surfi = namedSurfaceIndex[facei];
if (surfi != -1)
{
faceToZone[facei] = surfaceToFaceZone[surfi];
}
}
// Put the cells into the correct zone
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
List<labelHashSet> cellZoneNewCells(mesh_.cellZones().size());
forAll(cellToZone, celli)
{
const label zonei = cellToZone[celli];
if (zonei >= 0)
{
cellZoneNewCells[zonei].insert(celli);
}
}
forAll(cellZoneNewCells, zonei)
{
mesh_.cellZones()[zonei].insert(cellZoneNewCells[zonei]);
}
// Topochange container
polyTopoChange meshMod(mesh_);
// Get coupled neighbour cellZone. Set to -1 on non-coupled patches.
labelList neiCellZone;
syncTools::swapBoundaryCellList(mesh_, cellToZone, neiCellZone);
forAll(patches, patchi)
{
const polyPatch& pp = patches[patchi];
if (!pp.coupled())
{
label bFacei = pp.start() - mesh_.nInternalFaces();
forAll(pp, i)
{
neiCellZone[bFacei++] = -1;
}
}
}
// Get per face whether is it master (of a coupled set of faces)
const PackedBoolList isMasterFace(syncTools::getMasterFaces(mesh_));
// faceZones
// ~~~~~~~~~
// Faces on faceZones come in two variants:
// - faces on the outside of a cellZone. They will be oriented to
// point out of the maximum cellZone.
// - free-standing faces. These will be oriented according to the
// local surface normal. We do this in a two step algorithm:
// - do a consistent orientation
// - check number of faces with consistent orientation
// - if <0 flip the whole patch
boolList meshFlipMap(mesh_.nFaces(), false);
{
// Collect all data on zone faces without cellZones on either side.
const indirectPrimitivePatch patch
(
IndirectList<face>
(
mesh_.faces(),
freeStandingBaffleFaces
(
faceToZone,
cellToZone,
neiCellZone
)
),
mesh_.points()
);
label nFreeStanding = returnReduce(patch.size(), sumOp());
if (nFreeStanding > 0)
{
Info<< "Detected " << nFreeStanding << " free-standing zone faces"
<< endl;
if (debug)
{
OBJstream str(mesh_.time().path()/"freeStanding.obj");
str.write(patch.localFaces(), patch.localPoints(), false);
}
// Detect non-manifold edges
labelList nMasterFacesPerEdge;
calcPatchNumMasterFaces(isMasterFace, patch, nMasterFacesPerEdge);
// Mark zones. Even a single original surface might create multiple
// disconnected/non-manifold-connected zones
labelList faceToConnectedZone;
const label nZones = markPatchZones
(
patch,
nMasterFacesPerEdge,
faceToConnectedZone
);
Map<label> nPosOrientation(2*nZones);
for (label zonei = 0; zonei < nZones; zonei++)
{
nPosOrientation.insert(zonei, 0);
}
// Make orientations consistent in a topological way. This just
// checks the first face per zone for whether nPosOrientation
// is negative (which it never is at this point)
consistentOrientation
(
isMasterFace,
patch,
nMasterFacesPerEdge,
faceToConnectedZone,
nPosOrientation,
meshFlipMap
);
// Count per region the number of orientations (taking the new
// flipMap into account)
forAll(patch.addressing(), facei)
{
label meshFacei = patch.addressing()[facei];
if (isMasterFace[meshFacei])
{
label n = 1;
if
(
bool(posOrientation[meshFacei])
== meshFlipMap[meshFacei]
)
{
n = -1;
}
nPosOrientation.find(faceToConnectedZone[facei])() += n;
}
}
Pstream::mapCombineGather(nPosOrientation, addEqOp());
Pstream::mapCombineScatter(nPosOrientation);
Info<< "Split " << nFreeStanding << " free-standing zone faces"
<< " into " << nZones << " disconnected regions with size"
<< " (negative denotes wrong orientation) :"
<< endl;
for (label zonei = 0; zonei < nZones; zonei++)
{
Info<< " " << zonei << "\t" << nPosOrientation[zonei]
<< endl;
}
Info<< endl;
// Reapply with new counts (in nPosOrientation). This will cause
// zones with a negative count to be flipped.
consistentOrientation
(
isMasterFace,
patch,
nMasterFacesPerEdge,
faceToConnectedZone,
nPosOrientation,
meshFlipMap
);
}
}
// Put the faces into the correct zone
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
List<Map<bool>> faceZonesAddedFaces(mesh_.faceZones().size());
for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
{
label faceZoneI = faceToZone[facei];
if (faceZoneI != -1)
{
// Orient face zone to have slave cells in max cell zone.
// Note: logic to use flipMap should be consistent with logic
// to pick up the freeStandingBaffleFaces!
const label ownZone = cellToZone[faceOwner[facei]];
const label neiZone = cellToZone[faceNeighbour[facei]];
bool flip;
if (ownZone == neiZone)
{
// free-standing face. Use geometrically derived orientation
flip = meshFlipMap[facei];
}
else
{
flip =
(
ownZone == -1
|| (neiZone != -1 && ownZone > neiZone)
);
}
faceZonesAddedFaces[faceZoneI].insert(facei, flip);
}
}
// Set owner as no-flip
forAll(patches, patchi)
{
const polyPatch& pp = patches[patchi];
label facei = pp.start();
forAll(pp, i)
{
const label faceZoneI = faceToZone[facei];
if (faceZoneI != -1)
{
const label ownZone = cellToZone[faceOwner[facei]];
const label neiZone = neiCellZone[facei-mesh_.nInternalFaces()];
bool flip;
if (ownZone == neiZone)
{
// free-standing face. Use geometrically derived orientation
flip = meshFlipMap[facei];
}
else
{
flip =
(
ownZone == -1
|| (neiZone != -1 && ownZone > neiZone)
);
}
faceZonesAddedFaces[faceZoneI].insert(facei, flip);
}
facei++;
}
}
mesh_.clearOut();
// Change the mesh without keeping old points, parallel sync
autoPtr<polyTopoChangeMap> map = meshMod.changeMesh(mesh_, true);
// Add the new faces to the faceZones in the merged mesh
mesh_.faceZones().insert(faceZonesAddedFaces);
// Update fields
mesh_.topoChange(map);
// Reset the instance for if in overwrite mode
mesh_.setInstance(name());
// Print some stats (note: zones are synchronised)
if (mesh_.cellZones().size() > 0)
{
Info<< "CellZones:" << endl;
forAll(mesh_.cellZones(), zonei)
{
const cellZone& cz = mesh_.cellZones()[zonei];
Info<< " " << cz.name()
<< "\tsize:" << returnReduce(cz.size(), sumOp())
<< endl;
}
Info<< endl;
}
if (mesh_.faceZones().size() > 0)
{
Info<< "FaceZones:" << endl;
forAll(mesh_.faceZones(), zonei)
{
const faceZone& fz = mesh_.faceZones()[zonei];
Info<< " " << fz.name()
<< "\tsize:" << returnReduce(fz.size(), sumOp())
<< endl;
}
Info<< endl;
}
// None of the faces has changed, only the zones. Still...
topoChange(map, labelList());
return map;
}
// ************************************************************************* //