mirror of
https://develop.openfoam.com/Development/openfoam.git
synced 2025-12-28 03:37:59 +00:00
469 lines
12 KiB
C
469 lines
12 KiB
C
/*---------------------------------------------------------------------------*\
|
|
========= |
|
|
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
|
\\ / O peration |
|
|
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
|
|
\\/ M anipulation | Copyright (C) 2015 OpenCFD Ltd.
|
|
-------------------------------------------------------------------------------
|
|
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 "regionToCell.H"
|
|
#include "regionSplit.H"
|
|
#include "emptyPolyPatch.H"
|
|
#include "cellSet.H"
|
|
#include "syncTools.H"
|
|
#include "addToRunTimeSelectionTable.H"
|
|
|
|
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
|
|
|
|
namespace Foam
|
|
{
|
|
|
|
defineTypeNameAndDebug(regionToCell, 0);
|
|
|
|
addToRunTimeSelectionTable(topoSetSource, regionToCell, word);
|
|
|
|
addToRunTimeSelectionTable(topoSetSource, regionToCell, istream);
|
|
|
|
}
|
|
|
|
|
|
Foam::topoSetSource::addToUsageTable Foam::regionToCell::usage_
|
|
(
|
|
regionToCell::typeName,
|
|
"\n Usage: regionToCell subCellSet (pt0 .. ptn) nErode\n\n"
|
|
" Select all cells in the connected region containing"
|
|
" points (pt0..ptn).\n"
|
|
);
|
|
|
|
|
|
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
|
|
|
|
void Foam::regionToCell::markRegionFaces
|
|
(
|
|
const boolList& selectedCell,
|
|
boolList& regionFace
|
|
) const
|
|
{
|
|
// Internal faces
|
|
const labelList& faceOwner = mesh_.faceOwner();
|
|
const labelList& faceNeighbour = mesh_.faceNeighbour();
|
|
forAll(faceNeighbour, faceI)
|
|
{
|
|
if
|
|
(
|
|
selectedCell[faceOwner[faceI]]
|
|
!= selectedCell[faceNeighbour[faceI]]
|
|
)
|
|
{
|
|
regionFace[faceI] = true;
|
|
}
|
|
}
|
|
|
|
// Swap neighbour selectedCell state
|
|
boolList nbrSelected;
|
|
syncTools::swapBoundaryCellList(mesh_, selectedCell, nbrSelected);
|
|
|
|
// Boundary faces
|
|
const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
|
|
forAll(pbm, patchI)
|
|
{
|
|
const polyPatch& pp = pbm[patchI];
|
|
const labelUList& faceCells = pp.faceCells();
|
|
forAll(faceCells, i)
|
|
{
|
|
label faceI = pp.start()+i;
|
|
label bFaceI = faceI-mesh_.nInternalFaces();
|
|
if
|
|
(
|
|
selectedCell[faceCells[i]]
|
|
!= selectedCell[nbrSelected[bFaceI]]
|
|
)
|
|
{
|
|
regionFace[faceI] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
Foam::boolList Foam::regionToCell::findRegions
|
|
(
|
|
const bool verbose,
|
|
const regionSplit& cellRegion
|
|
) const
|
|
{
|
|
boolList keepRegion(cellRegion.nRegions(), false);
|
|
|
|
forAll(insidePoints_, i)
|
|
{
|
|
// Find the region containing the insidePoint
|
|
|
|
label cellI = mesh_.findCell(insidePoints_[i]);
|
|
|
|
label keepRegionI = -1;
|
|
label keepProcI = -1;
|
|
if (cellI != -1)
|
|
{
|
|
keepRegionI = cellRegion[cellI];
|
|
keepProcI = Pstream::myProcNo();
|
|
}
|
|
reduce(keepRegionI, maxOp<label>());
|
|
keepRegion[keepRegionI] = true;
|
|
|
|
reduce(keepProcI, maxOp<label>());
|
|
|
|
if (keepProcI == -1)
|
|
{
|
|
FatalErrorInFunction
|
|
<< "Did not find " << insidePoints_[i]
|
|
<< " in mesh." << " Mesh bounds are " << mesh_.bounds()
|
|
<< exit(FatalError);
|
|
}
|
|
|
|
if (verbose)
|
|
{
|
|
Info<< " Found location " << insidePoints_[i]
|
|
<< " in cell " << cellI << " on processor " << keepProcI
|
|
<< " in global region " << keepRegionI
|
|
<< " out of " << cellRegion.nRegions() << " regions." << endl;
|
|
}
|
|
}
|
|
|
|
return keepRegion;
|
|
}
|
|
|
|
|
|
void Foam::regionToCell::unselectOutsideRegions
|
|
(
|
|
boolList& selectedCell
|
|
) const
|
|
{
|
|
// Determine faces on the edge of selectedCell
|
|
boolList blockedFace(mesh_.nFaces(), false);
|
|
markRegionFaces(selectedCell, blockedFace);
|
|
|
|
// Determine regions
|
|
regionSplit cellRegion(mesh_, blockedFace);
|
|
|
|
// Determine regions containing insidePoints_
|
|
boolList keepRegion(findRegions(true, cellRegion));
|
|
|
|
// Go back to bool per cell
|
|
forAll(cellRegion, cellI)
|
|
{
|
|
if (!keepRegion[cellRegion[cellI]])
|
|
{
|
|
selectedCell[cellI] = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Foam::regionToCell::shrinkRegions
|
|
(
|
|
boolList& selectedCell
|
|
) const
|
|
{
|
|
// Select points on unselected cells and boundary
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
boolList boundaryPoint(mesh_.nPoints(), false);
|
|
|
|
const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
|
|
|
|
forAll(pbm, patchI)
|
|
{
|
|
const polyPatch& pp = pbm[patchI];
|
|
|
|
if (!pp.coupled() && !isA<emptyPolyPatch>(pp))
|
|
{
|
|
forAll(pp, i)
|
|
{
|
|
const face& f = pp[i];
|
|
forAll(f, fp)
|
|
{
|
|
boundaryPoint[f[fp]] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
forAll(selectedCell, cellI)
|
|
{
|
|
if (!selectedCell[cellI])
|
|
{
|
|
const labelList& cPoints = mesh_.cellPoints(cellI);
|
|
forAll(cPoints, i)
|
|
{
|
|
boundaryPoint[cPoints[i]] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
syncTools::syncPointList(mesh_, boundaryPoint, orEqOp<bool>(), false);
|
|
|
|
|
|
// Select all cells using these points
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
label nChanged = 0;
|
|
forAll(boundaryPoint, pointI)
|
|
{
|
|
if (boundaryPoint[pointI])
|
|
{
|
|
const labelList& pCells = mesh_.pointCells(pointI);
|
|
forAll(pCells, i)
|
|
{
|
|
label cellI = pCells[i];
|
|
if (selectedCell[cellI])
|
|
{
|
|
selectedCell[cellI] = false;
|
|
nChanged++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Info<< " Eroded " << returnReduce(nChanged, sumOp<label>())
|
|
<< " cells." << endl;
|
|
}
|
|
|
|
|
|
void Foam::regionToCell::erode
|
|
(
|
|
boolList& selectedCell
|
|
) const
|
|
{
|
|
//Info<< "Entering shrinkRegions:" << count(selectedCell) << endl;
|
|
//generateField("selectedCell_before", selectedCell)().write();
|
|
|
|
// Now erode and see which regions get disconnected
|
|
boolList shrunkSelectedCell(selectedCell);
|
|
|
|
for (label iter = 0; iter < nErode_; iter++)
|
|
{
|
|
shrinkRegions(shrunkSelectedCell);
|
|
}
|
|
|
|
//Info<< "After shrinking:" << count(shrunkSelectedCell) << endl;
|
|
//generateField("shrunkSelectedCell", shrunkSelectedCell)().write();
|
|
|
|
|
|
|
|
// Determine faces on the edge of shrunkSelectedCell
|
|
boolList blockedFace(mesh_.nFaces(), false);
|
|
markRegionFaces(shrunkSelectedCell, blockedFace);
|
|
|
|
// Find disconnected regions
|
|
regionSplit cellRegion(mesh_, blockedFace);
|
|
|
|
// Determine regions containing insidePoints
|
|
boolList keepRegion(findRegions(true, cellRegion));
|
|
|
|
|
|
// Extract cells in regions that are not to be kept.
|
|
boolList removeCell(mesh_.nCells(), false);
|
|
forAll(cellRegion, cellI)
|
|
{
|
|
if (shrunkSelectedCell[cellI] && !keepRegion[cellRegion[cellI]])
|
|
{
|
|
removeCell[cellI] = true;
|
|
}
|
|
}
|
|
|
|
//Info<< "removeCell before:" << count(removeCell) << endl;
|
|
//generateField("removeCell_before", removeCell)().write();
|
|
|
|
|
|
|
|
// Grow removeCell
|
|
for (label iter = 0; iter < nErode_; iter++)
|
|
{
|
|
// Grow selected cell in regions that are not for keeping
|
|
boolList boundaryPoint(mesh_.nPoints(), false);
|
|
forAll(removeCell, cellI)
|
|
{
|
|
if (removeCell[cellI])
|
|
{
|
|
const labelList& cPoints = mesh_.cellPoints(cellI);
|
|
forAll(cPoints, i)
|
|
{
|
|
boundaryPoint[cPoints[i]] = true;
|
|
}
|
|
}
|
|
}
|
|
syncTools::syncPointList(mesh_, boundaryPoint, orEqOp<bool>(), false);
|
|
|
|
// Select all cells using these points
|
|
|
|
label nChanged = 0;
|
|
forAll(boundaryPoint, pointI)
|
|
{
|
|
if (boundaryPoint[pointI])
|
|
{
|
|
const labelList& pCells = mesh_.pointCells(pointI);
|
|
forAll(pCells, i)
|
|
{
|
|
label cellI = pCells[i];
|
|
if (!removeCell[cellI])
|
|
{
|
|
removeCell[cellI] = true;
|
|
nChanged++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Info<< "removeCell after:" << count(removeCell) << endl;
|
|
//generateField("removeCell_after", removeCell)().write();
|
|
|
|
|
|
// Unmark removeCell
|
|
forAll(removeCell, cellI)
|
|
{
|
|
if (removeCell[cellI])
|
|
{
|
|
selectedCell[cellI] = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Foam::regionToCell::combine(topoSet& set, const bool add) const
|
|
{
|
|
// Note: wip. Select cells first
|
|
boolList selectedCell(mesh_.nCells(), true);
|
|
|
|
if (setName_.size() && setName_ != "none")
|
|
{
|
|
Info<< " Loading subset " << setName_ << " to delimit search region."
|
|
<< endl;
|
|
cellSet subSet(mesh_, setName_);
|
|
|
|
selectedCell = false;
|
|
forAllConstIter(cellSet, subSet, iter)
|
|
{
|
|
selectedCell[iter.key()] = true;
|
|
}
|
|
}
|
|
|
|
|
|
unselectOutsideRegions(selectedCell);
|
|
|
|
if (nErode_ > 0)
|
|
{
|
|
erode(selectedCell);
|
|
}
|
|
|
|
|
|
forAll(selectedCell, cellI)
|
|
{
|
|
if (selectedCell[cellI])
|
|
{
|
|
addOrDelete(set, cellI, add);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
|
|
|
|
// Construct from components
|
|
Foam::regionToCell::regionToCell
|
|
(
|
|
const polyMesh& mesh,
|
|
const word& setName,
|
|
const pointField& insidePoints,
|
|
const label nErode
|
|
)
|
|
:
|
|
topoSetSource(mesh),
|
|
setName_(setName),
|
|
insidePoints_(insidePoints),
|
|
nErode_(nErode)
|
|
{}
|
|
|
|
|
|
// Construct from dictionary
|
|
Foam::regionToCell::regionToCell
|
|
(
|
|
const polyMesh& mesh,
|
|
const dictionary& dict
|
|
)
|
|
:
|
|
topoSetSource(mesh),
|
|
setName_(dict.lookupOrDefault<word>("set", "none")),
|
|
insidePoints_
|
|
(
|
|
dict.found("insidePoints")
|
|
? dict.lookup("insidePoints")
|
|
: dict.lookup("insidePoint")
|
|
),
|
|
nErode_(dict.lookupOrDefault("nErode", 0))
|
|
{}
|
|
|
|
|
|
// Construct from Istream
|
|
Foam::regionToCell::regionToCell
|
|
(
|
|
const polyMesh& mesh,
|
|
Istream& is
|
|
)
|
|
:
|
|
topoSetSource(mesh),
|
|
setName_(checkIs(is)),
|
|
insidePoints_(checkIs(is)),
|
|
nErode_(readLabel(checkIs(is)))
|
|
{}
|
|
|
|
|
|
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
|
|
|
|
Foam::regionToCell::~regionToCell()
|
|
{}
|
|
|
|
|
|
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
|
|
|
void Foam::regionToCell::applyToSet
|
|
(
|
|
const topoSetSource::setAction action,
|
|
topoSet& set
|
|
) const
|
|
{
|
|
if ((action == topoSetSource::NEW) || (action == topoSetSource::ADD))
|
|
{
|
|
Info<< " Adding all cells of connected region containing points "
|
|
<< insidePoints_ << " ..." << endl;
|
|
|
|
combine(set, true);
|
|
}
|
|
else if (action == topoSetSource::DELETE)
|
|
{
|
|
Info<< " Removing all cells of connected region containing points "
|
|
<< insidePoints_ << " ..." << endl;
|
|
|
|
combine(set, false);
|
|
}
|
|
}
|
|
|
|
|
|
// ************************************************************************* //
|