mirror of
https://develop.openfoam.com/Development/openfoam.git
synced 2025-11-28 03:28:01 +00:00
Merge branch 'master' into splitCyclic
Conflicts: src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.H src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.C src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C src/parallel/decompose/scotchDecomp/scotchDecomp.C src/parallel/parMetisDecomp/parMetisDecomp.C src/sampling/sampledSurface/isoSurface/isoSurfaceCell.C
This commit is contained in:
mattijs
@ -0,0 +1,7 @@
|
||||
patchPointEdgeCirculator.C
|
||||
createShellMesh.C
|
||||
extrudeToRegionMesh.C
|
||||
|
||||
EXE = $(FOAM_APPBIN)/extrudeToRegionMesh
|
||||
|
||||
|
||||
@ -0,0 +1,14 @@
|
||||
EXE_INC = \
|
||||
-I$(LIB_SRC)/finiteVolume/lnInclude \
|
||||
/* -I$(LIB_SRC)/surfMesh/lnInclude */ \
|
||||
/* -I$(LIB_SRC)/lagrangian/basic/lnInclude */ \
|
||||
-I$(LIB_SRC)/meshTools/lnInclude \
|
||||
-I$(LIB_SRC)/dynamicMesh/lnInclude
|
||||
|
||||
EXE_LIBS = \
|
||||
-lfiniteVolume \
|
||||
/* -lsurfMesh */ \
|
||||
/* -llagrangian */ \
|
||||
-lmeshTools \
|
||||
-ldynamicMesh
|
||||
|
||||
@ -0,0 +1,588 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
|
||||
\\/ 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 2 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, write to the Free Software Foundation,
|
||||
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "createShellMesh.H"
|
||||
#include "polyTopoChange.H"
|
||||
#include "meshTools.H"
|
||||
#include "mapPolyMesh.H"
|
||||
#include "polyAddPoint.H"
|
||||
#include "polyAddFace.H"
|
||||
#include "polyModifyFace.H"
|
||||
#include "polyAddCell.H"
|
||||
#include "patchPointEdgeCirculator.H"
|
||||
|
||||
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
|
||||
|
||||
defineTypeNameAndDebug(Foam::createShellMesh, 0);
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
|
||||
|
||||
void Foam::createShellMesh::calcPointRegions
|
||||
(
|
||||
const primitiveFacePatch& patch,
|
||||
const PackedBoolList& nonManifoldEdge,
|
||||
faceList& pointRegions,
|
||||
labelList& regionPoints
|
||||
)
|
||||
{
|
||||
pointRegions.setSize(patch.size());
|
||||
forAll(pointRegions, faceI)
|
||||
{
|
||||
const face& f = patch.localFaces()[faceI];
|
||||
pointRegions[faceI].setSize(f.size(), -1);
|
||||
}
|
||||
|
||||
label nRegions = 0;
|
||||
|
||||
forAll(pointRegions, faceI)
|
||||
{
|
||||
const face& f = patch.localFaces()[faceI];
|
||||
|
||||
forAll(f, fp)
|
||||
{
|
||||
if (pointRegions[faceI][fp] == -1)
|
||||
{
|
||||
// Found unassigned point. Distribute current region.
|
||||
label pointI = f[fp];
|
||||
label edgeI = patch.faceEdges()[faceI][fp];
|
||||
|
||||
patchPointEdgeCirculator circ
|
||||
(
|
||||
patch,
|
||||
nonManifoldEdge,
|
||||
edgeI,
|
||||
findIndex(patch.edgeFaces()[edgeI], faceI),
|
||||
pointI
|
||||
);
|
||||
|
||||
for
|
||||
(
|
||||
patchPointEdgeCirculator iter = circ.begin();
|
||||
iter != circ.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
label face2 = iter.faceID();
|
||||
|
||||
if (face2 != -1)
|
||||
{
|
||||
const face& f2 = patch.localFaces()[face2];
|
||||
label fp2 = findIndex(f2, pointI);
|
||||
label& region = pointRegions[face2][fp2];
|
||||
if (region != -1)
|
||||
{
|
||||
FatalErrorIn
|
||||
(
|
||||
"createShellMesh::calcPointRegions(..)"
|
||||
) << "On point " << pointI
|
||||
<< " at:" << patch.localPoints()[pointI]
|
||||
<< " found region:" << region
|
||||
<< abort(FatalError);
|
||||
}
|
||||
region = nRegions;
|
||||
}
|
||||
}
|
||||
|
||||
nRegions++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// From region back to originating point (many to one, a point might
|
||||
// have multiple regions though)
|
||||
regionPoints.setSize(nRegions);
|
||||
forAll(pointRegions, faceI)
|
||||
{
|
||||
const face& f = patch.localFaces()[faceI];
|
||||
|
||||
forAll(f, fp)
|
||||
{
|
||||
regionPoints[pointRegions[faceI][fp]] = f[fp];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (debug)
|
||||
{
|
||||
const labelListList& pointFaces = patch.pointFaces();
|
||||
forAll(pointFaces, pointI)
|
||||
{
|
||||
label region = -1;
|
||||
const labelList& pFaces = pointFaces[pointI];
|
||||
forAll(pFaces, i)
|
||||
{
|
||||
label faceI = pFaces[i];
|
||||
const face& f = patch.localFaces()[faceI];
|
||||
label fp = findIndex(f, pointI);
|
||||
|
||||
if (region == -1)
|
||||
{
|
||||
region = pointRegions[faceI][fp];
|
||||
}
|
||||
else if (region != pointRegions[faceI][fp])
|
||||
{
|
||||
Pout<< "Non-manifold point:" << pointI
|
||||
<< " at " << patch.localPoints()[pointI]
|
||||
<< " region:" << region
|
||||
<< " otherRegion:" << pointRegions[faceI][fp]
|
||||
<< endl;
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
|
||||
|
||||
Foam::createShellMesh::createShellMesh
|
||||
(
|
||||
const primitiveFacePatch& patch,
|
||||
const faceList& pointRegions,
|
||||
const labelList& regionPoints
|
||||
)
|
||||
:
|
||||
patch_(patch),
|
||||
pointRegions_(pointRegions),
|
||||
regionPoints_(regionPoints)
|
||||
{
|
||||
if (pointRegions_.size() != patch_.size())
|
||||
{
|
||||
FatalErrorIn("createShellMesh::createShellMesh(..)")
|
||||
<< "nFaces:" << patch_.size()
|
||||
<< " pointRegions:" << pointRegions.size()
|
||||
<< exit(FatalError);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
|
||||
void Foam::createShellMesh::setRefinement
|
||||
(
|
||||
const pointField& thickness,
|
||||
const labelList& topPatchID,
|
||||
const labelList& bottomPatchID,
|
||||
const labelListList& extrudeEdgePatches,
|
||||
polyTopoChange& meshMod
|
||||
)
|
||||
{
|
||||
if (thickness.size() != regionPoints_.size())
|
||||
{
|
||||
FatalErrorIn("createShellMesh::setRefinement(..)")
|
||||
<< "nRegions:" << regionPoints_.size()
|
||||
<< " thickness:" << thickness.size()
|
||||
<< exit(FatalError);
|
||||
}
|
||||
|
||||
if
|
||||
(
|
||||
topPatchID.size() != patch_.size()
|
||||
&& bottomPatchID.size() != patch_.size()
|
||||
)
|
||||
{
|
||||
FatalErrorIn("createShellMesh::setRefinement(..)")
|
||||
<< "nFaces:" << patch_.size()
|
||||
<< " topPatchID:" << topPatchID.size()
|
||||
<< " bottomPatchID:" << bottomPatchID.size()
|
||||
<< exit(FatalError);
|
||||
}
|
||||
|
||||
if (extrudeEdgePatches.size() != patch_.nEdges())
|
||||
{
|
||||
FatalErrorIn("createShellMesh::setRefinement(..)")
|
||||
<< "nEdges:" << patch_.nEdges()
|
||||
<< " extrudeEdgePatches:" << extrudeEdgePatches.size()
|
||||
<< exit(FatalError);
|
||||
}
|
||||
|
||||
|
||||
|
||||
// From cell to patch (trivial)
|
||||
DynamicList<label> cellToFaceMap(patch_.size());
|
||||
// From face to patch+turning index
|
||||
DynamicList<label> faceToFaceMap(2*patch_.size()+patch_.nEdges());
|
||||
// From face to patch edge index
|
||||
DynamicList<label> faceToEdgeMap(patch_.nEdges()+patch_.nEdges());
|
||||
// From point to patch point index
|
||||
DynamicList<label> pointToPointMap(2*patch_.nPoints());
|
||||
|
||||
|
||||
// Introduce new cell for every face
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
labelList addedCells(patch_.size());
|
||||
forAll(patch_, faceI)
|
||||
{
|
||||
addedCells[faceI] = meshMod.addCell
|
||||
(
|
||||
-1, // masterPointID
|
||||
-1, // masterEdgeID
|
||||
-1, // masterFaceID
|
||||
cellToFaceMap.size(), // masterCellID
|
||||
-1 // zoneID
|
||||
);
|
||||
cellToFaceMap.append(faceI);
|
||||
}
|
||||
|
||||
|
||||
// Introduce original points
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
// Original point numbers in local point ordering so no need to store.
|
||||
forAll(patch_.localPoints(), pointI)
|
||||
{
|
||||
//label addedPointI =
|
||||
meshMod.addPoint
|
||||
(
|
||||
patch_.localPoints()[pointI], // point
|
||||
pointToPointMap.size(), // masterPointID
|
||||
-1, // zoneID
|
||||
true // inCell
|
||||
);
|
||||
pointToPointMap.append(pointI);
|
||||
|
||||
//Pout<< "Added bottom point " << addedPointI
|
||||
// << " at " << patch_.localPoints()[pointI]
|
||||
// << " from point " << pointI
|
||||
// << endl;
|
||||
}
|
||||
|
||||
|
||||
// Introduce new points (one for every region)
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
labelList addedPoints(regionPoints_.size());
|
||||
forAll(regionPoints_, regionI)
|
||||
{
|
||||
label pointI = regionPoints_[regionI];
|
||||
point extrudedPt = patch_.localPoints()[pointI] + thickness[regionI];
|
||||
|
||||
addedPoints[regionI] = meshMod.addPoint
|
||||
(
|
||||
extrudedPt, // point
|
||||
pointToPointMap.size(), // masterPointID - used only addressing
|
||||
-1, // zoneID
|
||||
true // inCell
|
||||
);
|
||||
pointToPointMap.append(pointI);
|
||||
|
||||
//Pout<< "Added top point " << addedPoints[regionI]
|
||||
// << " at " << extrudedPt
|
||||
// << " from point " << pointI
|
||||
// << endl;
|
||||
}
|
||||
|
||||
|
||||
// Add face on bottom side
|
||||
forAll(patch_.localFaces(), faceI)
|
||||
{
|
||||
meshMod.addFace
|
||||
(
|
||||
patch_.localFaces()[faceI].reverseFace(),// vertices
|
||||
addedCells[faceI], // own
|
||||
-1, // nei
|
||||
-1, // masterPointID
|
||||
-1, // masterEdgeID
|
||||
faceToFaceMap.size(), // masterFaceID : current faceI
|
||||
true, // flipFaceFlux
|
||||
bottomPatchID[faceI],// patchID
|
||||
-1, // zoneID
|
||||
false // zoneFlip
|
||||
);
|
||||
faceToFaceMap.append(-faceI-1); // points to flipped original face
|
||||
faceToEdgeMap.append(-1);
|
||||
|
||||
//Pout<< "Added bottom face "
|
||||
// << patch_.localFaces()[faceI].reverseFace()
|
||||
// << " own " << addedCells[faceI]
|
||||
// << " at " << patch_.faceCentres()[faceI]
|
||||
// << endl;
|
||||
|
||||
}
|
||||
|
||||
// Add face on top
|
||||
forAll(patch_.localFaces(), faceI)
|
||||
{
|
||||
// Get face in original ordering
|
||||
const face& f = patch_.localFaces()[faceI];
|
||||
|
||||
// Pick up point based on region
|
||||
face newF(f.size());
|
||||
forAll(f, fp)
|
||||
{
|
||||
label region = pointRegions_[faceI][fp];
|
||||
newF[fp] = addedPoints[region];
|
||||
}
|
||||
|
||||
meshMod.addFace
|
||||
(
|
||||
newF, // vertices
|
||||
addedCells[faceI], // own
|
||||
-1, // nei
|
||||
-1, // masterPointID
|
||||
-1, // masterEdgeID
|
||||
faceToFaceMap.size(), // masterFaceID : current faceI
|
||||
false, // flipFaceFlux
|
||||
topPatchID[faceI], // patchID
|
||||
-1, // zoneID
|
||||
false // zoneFlip
|
||||
);
|
||||
faceToFaceMap.append(faceI+1); // unflipped
|
||||
faceToEdgeMap.append(-1);
|
||||
|
||||
//Pout<< "Added top face " << newF
|
||||
// << " own " << addedCells[faceI]
|
||||
// << " at " << patch_.faceCentres()[faceI]
|
||||
// << endl;
|
||||
}
|
||||
|
||||
|
||||
// Add side faces
|
||||
// ~~~~~~~~~~~~~~
|
||||
// Note that we loop over edges multiple times so for edges with
|
||||
// two cyclic faces they get added in two passes (for correct ordering)
|
||||
|
||||
// Pass1. Internal edges and first face of other edges
|
||||
forAll(extrudeEdgePatches, edgeI)
|
||||
{
|
||||
const labelList& eFaces = patch_.edgeFaces()[edgeI];
|
||||
const labelList& ePatches = extrudeEdgePatches[edgeI];
|
||||
|
||||
if (ePatches.size() == 0)
|
||||
{
|
||||
// internal face.
|
||||
|
||||
if (eFaces.size() != 2)
|
||||
{
|
||||
FatalErrorIn("createShellMesh::setRefinement(..)")
|
||||
<< "edge:" << edgeI
|
||||
<< " not internal but does not have side-patches defined."
|
||||
<< exit(FatalError);
|
||||
}
|
||||
|
||||
// Extrude
|
||||
|
||||
// Make face pointing in to eFaces[0] so out of new master face
|
||||
const face& f = patch_.localFaces()[eFaces[0]];
|
||||
const edge& e = patch_.edges()[edgeI];
|
||||
|
||||
label fp0 = findIndex(f, e[0]);
|
||||
label fp1 = f.fcIndex(fp0);
|
||||
|
||||
if (f[fp1] != e[1])
|
||||
{
|
||||
fp1 = fp0;
|
||||
fp0 = f.rcIndex(fp1);
|
||||
}
|
||||
|
||||
face newF(4);
|
||||
newF[0] = f[fp0];
|
||||
newF[1] = f[fp1];
|
||||
newF[2] = addedPoints[pointRegions_[eFaces[0]][fp1]];
|
||||
newF[3] = addedPoints[pointRegions_[eFaces[0]][fp0]];
|
||||
|
||||
label minCellI = addedCells[eFaces[0]];
|
||||
label maxCellI = addedCells[eFaces[1]];
|
||||
|
||||
if (minCellI > maxCellI)
|
||||
{
|
||||
// Swap
|
||||
Swap(minCellI, maxCellI);
|
||||
newF = newF.reverseFace();
|
||||
}
|
||||
|
||||
//Pout<< "for internal edge:" << e
|
||||
// << " at:" << patch_.localPoints()[e[0]]
|
||||
// << patch_.localPoints()[e[1]]
|
||||
// << " adding face:" << newF
|
||||
// << " from f:" << f
|
||||
// << " inbetween " << minCellI << " and " << maxCellI << endl;
|
||||
|
||||
// newF already outwards pointing.
|
||||
meshMod.addFace
|
||||
(
|
||||
newF, // vertices
|
||||
minCellI, // own
|
||||
maxCellI, // nei
|
||||
-1, // masterPointID
|
||||
-1, // masterEdgeID
|
||||
faceToFaceMap.size(), // masterFaceID
|
||||
false, // flipFaceFlux
|
||||
-1, // patchID
|
||||
-1, // zoneID
|
||||
false // zoneFlip
|
||||
);
|
||||
faceToFaceMap.append(0);
|
||||
faceToEdgeMap.append(edgeI);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (eFaces.size() != ePatches.size())
|
||||
{
|
||||
FatalErrorIn("createShellMesh::setRefinement(..)")
|
||||
<< "external/feature edge:" << edgeI
|
||||
<< " has " << eFaces.size() << " connected extruded faces "
|
||||
<< " but only " << ePatches.size()
|
||||
<< " boundary faces defined." << exit(FatalError);
|
||||
}
|
||||
|
||||
|
||||
// Extrude eFaces[0]
|
||||
label minFaceI = eFaces[0];
|
||||
|
||||
// Make face pointing in to eFaces[0] so out of new master face
|
||||
const face& f = patch_.localFaces()[minFaceI];
|
||||
|
||||
const edge& e = patch_.edges()[edgeI];
|
||||
label fp0 = findIndex(f, e[0]);
|
||||
label fp1 = f.fcIndex(fp0);
|
||||
|
||||
if (f[fp1] != e[1])
|
||||
{
|
||||
fp1 = fp0;
|
||||
fp0 = f.rcIndex(fp1);
|
||||
}
|
||||
|
||||
face newF(4);
|
||||
newF[0] = f[fp0];
|
||||
newF[1] = f[fp1];
|
||||
newF[2] = addedPoints[pointRegions_[minFaceI][fp1]];
|
||||
newF[3] = addedPoints[pointRegions_[minFaceI][fp0]];
|
||||
|
||||
|
||||
//Pout<< "for external edge:" << e
|
||||
// << " at:" << patch_.localPoints()[e[0]]
|
||||
// << patch_.localPoints()[e[1]]
|
||||
// << " adding first patch face:" << newF
|
||||
// << " from:" << f
|
||||
// << " into patch:" << ePatches[0]
|
||||
// << " own:" << addedCells[minFaceI]
|
||||
// << endl;
|
||||
|
||||
|
||||
// newF already outwards pointing.
|
||||
meshMod.addFace
|
||||
(
|
||||
newF, // vertices
|
||||
addedCells[minFaceI], // own
|
||||
-1, // nei
|
||||
-1, // masterPointID
|
||||
-1, // masterEdgeID
|
||||
faceToFaceMap.size(), // masterFaceID
|
||||
false, // flipFaceFlux
|
||||
ePatches[0], // patchID
|
||||
-1, // zoneID
|
||||
false // zoneFlip
|
||||
);
|
||||
faceToFaceMap.append(0);
|
||||
faceToEdgeMap.append(edgeI);
|
||||
}
|
||||
}
|
||||
|
||||
// Pass2. Other faces of boundary edges
|
||||
forAll(extrudeEdgePatches, edgeI)
|
||||
{
|
||||
const labelList& eFaces = patch_.edgeFaces()[edgeI];
|
||||
const labelList& ePatches = extrudeEdgePatches[edgeI];
|
||||
|
||||
if (ePatches.size() >= 2)
|
||||
{
|
||||
for (label i = 1; i < ePatches.size(); i++)
|
||||
{
|
||||
// Extrude eFaces[i]
|
||||
label minFaceI = eFaces[i];
|
||||
|
||||
// Make face pointing in to eFaces[0] so out of new master face
|
||||
const face& f = patch_.localFaces()[minFaceI];
|
||||
|
||||
const edge& e = patch_.edges()[edgeI];
|
||||
label fp0 = findIndex(f, e[0]);
|
||||
label fp1 = f.fcIndex(fp0);
|
||||
|
||||
if (f[fp1] != e[1])
|
||||
{
|
||||
fp1 = fp0;
|
||||
fp0 = f.rcIndex(fp1);
|
||||
}
|
||||
|
||||
face newF(4);
|
||||
newF[0] = f[fp0];
|
||||
newF[1] = f[fp1];
|
||||
newF[2] = addedPoints[pointRegions_[minFaceI][fp1]];
|
||||
newF[3] = addedPoints[pointRegions_[minFaceI][fp0]];
|
||||
|
||||
//Pout<< "for external edge:" << e
|
||||
// << " at:" << patch_.localPoints()[e[0]]
|
||||
// << patch_.localPoints()[e[1]]
|
||||
// << " adding patch face:" << newF
|
||||
// << " from:" << f
|
||||
// << " into patch:" << ePatches[i]
|
||||
// << endl;
|
||||
|
||||
// newF already outwards pointing.
|
||||
meshMod.addFace
|
||||
(
|
||||
newF, // vertices
|
||||
addedCells[minFaceI], // own
|
||||
-1, // nei
|
||||
-1, // masterPointID
|
||||
-1, // masterEdgeID
|
||||
faceToFaceMap.size(), // masterFaceID
|
||||
false, // flipFaceFlux
|
||||
ePatches[i], // patchID
|
||||
-1, // zoneID
|
||||
false // zoneFlip
|
||||
);
|
||||
faceToFaceMap.append(0);
|
||||
faceToEdgeMap.append(edgeI);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
cellToFaceMap_.transfer(cellToFaceMap);
|
||||
faceToFaceMap_.transfer(faceToFaceMap);
|
||||
faceToEdgeMap_.transfer(faceToEdgeMap);
|
||||
pointToPointMap_.transfer(pointToPointMap);
|
||||
}
|
||||
|
||||
|
||||
void Foam::createShellMesh::updateMesh(const mapPolyMesh& map)
|
||||
{
|
||||
inplaceReorder(map.reverseCellMap(), cellToFaceMap_);
|
||||
inplaceReorder(map.reverseFaceMap(), faceToFaceMap_);
|
||||
inplaceReorder(map.reverseFaceMap(), faceToEdgeMap_);
|
||||
inplaceReorder(map.reversePointMap(), pointToPointMap_);
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,177 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
|
||||
\\/ 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 2 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, write to the Free Software Foundation,
|
||||
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
Class
|
||||
Foam::createShellMesh
|
||||
|
||||
Description
|
||||
Creates mesh by extruding a patch.
|
||||
|
||||
SourceFiles
|
||||
createShellMesh.C
|
||||
|
||||
Extrudes into thickness direction.
|
||||
- bottom faces originate from reversed original faces (have turning index)
|
||||
- top faces originate from original faces (no turning index)
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef createShellMesh_H
|
||||
#define createShellMesh_H
|
||||
|
||||
#include "primitiveFacePatch.H"
|
||||
#include "PackedBoolList.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
// Forward declaration of classes
|
||||
class mapPolyMesh;
|
||||
class polyTopoChange;
|
||||
|
||||
/*---------------------------------------------------------------------------*\
|
||||
Class createShellMesh Declaration
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
class createShellMesh
|
||||
{
|
||||
// Private data
|
||||
|
||||
//- Reference to patch to extrude
|
||||
const primitiveFacePatch& patch_;
|
||||
|
||||
//- Per point on face the region
|
||||
const faceList& pointRegions_;
|
||||
|
||||
//- From region to original patch point
|
||||
const labelList& regionPoints_;
|
||||
|
||||
|
||||
labelList cellToFaceMap_;
|
||||
|
||||
labelList faceToFaceMap_;
|
||||
|
||||
labelList faceToEdgeMap_;
|
||||
|
||||
labelList pointToPointMap_;
|
||||
|
||||
|
||||
// Private Member Functions
|
||||
|
||||
//- Disallow default bitwise copy construct
|
||||
createShellMesh(const createShellMesh&);
|
||||
|
||||
//- Disallow default bitwise assignment
|
||||
void operator=(const createShellMesh&);
|
||||
|
||||
|
||||
public:
|
||||
|
||||
//- Runtime type information
|
||||
ClassName("createShellMesh");
|
||||
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct from mesh.
|
||||
createShellMesh
|
||||
(
|
||||
const primitiveFacePatch& patch,
|
||||
const faceList& pointRegions,
|
||||
const labelList& regionPoints
|
||||
);
|
||||
|
||||
|
||||
// Member Functions
|
||||
|
||||
|
||||
// Access
|
||||
|
||||
//- From region cell to patch face
|
||||
const labelList& cellToFaceMap() const
|
||||
{
|
||||
return cellToFaceMap_;
|
||||
}
|
||||
|
||||
//- From region face to patch face. Contains turning index:
|
||||
// > 0 : face in same orientation as patch face. face will
|
||||
// be in top patch
|
||||
// < 0 : face in opposite orientation as patch face. face will
|
||||
// be in bottom patch
|
||||
// = 0 : for all side faces
|
||||
const labelList& faceToFaceMap() const
|
||||
{
|
||||
return faceToFaceMap_;
|
||||
}
|
||||
|
||||
//- From region side-face to patch edge. -1 for non-edge faces.
|
||||
const labelList& faceToEdgeMap() const
|
||||
{
|
||||
return faceToEdgeMap_;
|
||||
}
|
||||
|
||||
//- From region point to patch point.
|
||||
const labelList& pointToPointMap() const
|
||||
{
|
||||
return pointToPointMap_;
|
||||
}
|
||||
|
||||
|
||||
// Other
|
||||
|
||||
//- Helper: calculate point regions
|
||||
static void calcPointRegions
|
||||
(
|
||||
const primitiveFacePatch& patch,
|
||||
const PackedBoolList& nonManifoldEdge,
|
||||
faceList& pointRegions,
|
||||
labelList& regionPoints
|
||||
);
|
||||
|
||||
//- Play commands into polyTopoChange to create layer mesh.
|
||||
void setRefinement
|
||||
(
|
||||
const pointField& thickness,
|
||||
const labelList& topPatchID,
|
||||
const labelList& bottomPatchID,
|
||||
const labelListList& extrudeEdgePatches,
|
||||
polyTopoChange& meshMod
|
||||
);
|
||||
|
||||
//- Update any locally stored mesh information.
|
||||
void updateMesh(const mapPolyMesh&);
|
||||
};
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#endif
|
||||
|
||||
// ************************************************************************* //
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,68 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
|
||||
\\/ 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 2 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, write to the Free Software Foundation,
|
||||
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "patchPointEdgeCirculator.H"
|
||||
|
||||
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
|
||||
|
||||
const Foam::patchPointEdgeCirculator
|
||||
Foam::patchPointEdgeCirculator::endConstIter
|
||||
(
|
||||
*reinterpret_cast<primitiveFacePatch*>(0), // primitiveFacePatch
|
||||
*reinterpret_cast<PackedBoolList*>(0), // PackedBoolList
|
||||
-1, // edgeID
|
||||
-1, // index
|
||||
-1 // pointID
|
||||
);
|
||||
|
||||
|
||||
Foam::Ostream& Foam::operator<<
|
||||
(
|
||||
Ostream& os,
|
||||
const InfoProxy<patchPointEdgeCirculator>& ip
|
||||
)
|
||||
{
|
||||
const patchPointEdgeCirculator& c = ip.t_;
|
||||
|
||||
const pointField& pts = c.patch_.localPoints();
|
||||
const edge& e = c.patch_.edges()[c.edgeID_];
|
||||
label faceI = c.faceID();
|
||||
|
||||
os << "around point:" << c.pointID_
|
||||
<< " coord:" << pts[c.pointID_]
|
||||
<< " at edge:" << c.edgeID_
|
||||
<< " coord:" << pts[e.otherVertex(c.pointID_)]
|
||||
<< " in direction of face:" << faceI;
|
||||
|
||||
if (faceI != -1)
|
||||
{
|
||||
os<< " fc:" << c.patch_.localFaces()[faceI].centre(pts);
|
||||
}
|
||||
return os;
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,206 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
|
||||
\\/ 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 2 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, write to the Free Software Foundation,
|
||||
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
Class
|
||||
Foam::patchPointEdgeCirculator
|
||||
|
||||
Description
|
||||
Walks from starting edge/face around point on patch.
|
||||
|
||||
-# Use in-place: \n
|
||||
@code
|
||||
patchPointEdgeCirculator circ(..);
|
||||
|
||||
// Walk
|
||||
do
|
||||
{
|
||||
Info<< "edge:" << circ.edgeID() << endl;
|
||||
++circ;
|
||||
}
|
||||
while (circ != circ.end());
|
||||
@endcode
|
||||
|
||||
-# Use like STL iterator: \n
|
||||
@code
|
||||
patchPointEdgeCirculator circ(..);
|
||||
for
|
||||
(
|
||||
patchPointEdgeCirculator iter = circ.begin();
|
||||
iter != circ.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
Info<< "edge:" << iter.edgeID() << endl;
|
||||
}
|
||||
@endcode
|
||||
|
||||
|
||||
SourceFiles
|
||||
patchPointEdgeCirculator.C
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef patchPointEdgeCirculator_H
|
||||
#define patchPointEdgeCirculator_H
|
||||
|
||||
#include "face.H"
|
||||
#include "ListOps.H"
|
||||
#include "primitiveFacePatch.H"
|
||||
#include "PackedBoolList.H"
|
||||
#include "InfoProxy.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
// Forward declaration of classes
|
||||
|
||||
/*---------------------------------------------------------------------------*\
|
||||
Class patchPointEdgeCirculator Declaration
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
class patchPointEdgeCirculator
|
||||
{
|
||||
// Static data members
|
||||
|
||||
//- end iterator
|
||||
static const patchPointEdgeCirculator endConstIter;
|
||||
|
||||
|
||||
// Private data
|
||||
|
||||
//- Patch
|
||||
const primitiveFacePatch& patch_;
|
||||
|
||||
const PackedBoolList& nonManifoldEdge_;
|
||||
|
||||
//- Current edge
|
||||
label edgeID_;
|
||||
|
||||
//- Current direction (face, expressed as index into edgeFaces()[edgeID]
|
||||
label index_;
|
||||
|
||||
//- Point
|
||||
label pointID_;
|
||||
|
||||
//- Starting edge so we know when to stop.
|
||||
label startEdgeID_;
|
||||
|
||||
|
||||
// Private Member Functions
|
||||
|
||||
//- Set to end() iterator
|
||||
inline void setEnd();
|
||||
|
||||
//- Set edgeID_ to be the other edge on the face that uses the
|
||||
// point.
|
||||
inline void otherEdge(const label cellI);
|
||||
|
||||
public:
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct from components
|
||||
inline patchPointEdgeCirculator
|
||||
(
|
||||
const primitiveFacePatch&,
|
||||
const PackedBoolList& nonManifoldEdge,
|
||||
const label edgeID,
|
||||
const label index,
|
||||
const label pointID
|
||||
);
|
||||
|
||||
//- Construct as copy
|
||||
inline patchPointEdgeCirculator(const patchPointEdgeCirculator&);
|
||||
|
||||
|
||||
// Member Functions
|
||||
|
||||
inline label edgeID() const;
|
||||
|
||||
inline label index() const;
|
||||
|
||||
inline label pointID() const;
|
||||
|
||||
//- Helper: get face according to the index.
|
||||
// Returns -1 if on end.
|
||||
inline label faceID() const;
|
||||
|
||||
//- Walk back until non-manifold edge (if any) or minimum edge.
|
||||
inline void setCanonical();
|
||||
|
||||
|
||||
// Member Operators
|
||||
|
||||
inline void operator=(const patchPointEdgeCirculator& iter);
|
||||
|
||||
inline bool operator==(const patchPointEdgeCirculator& iter) const;
|
||||
|
||||
inline bool operator!=(const patchPointEdgeCirculator& iter) const;
|
||||
|
||||
//- Step to next face.
|
||||
inline patchPointEdgeCirculator& operator++();
|
||||
|
||||
//- iterator set to the beginning face. For internal edges this is
|
||||
// the current face. For boundary edges this is the first boundary face
|
||||
// reached from walking back (i.e. in opposite direction to ++)
|
||||
inline patchPointEdgeCirculator begin() const;
|
||||
inline patchPointEdgeCirculator cbegin() const;
|
||||
|
||||
//- iterator set to beyond the end of the walk.
|
||||
inline const patchPointEdgeCirculator& end() const;
|
||||
inline const patchPointEdgeCirculator& cend() const;
|
||||
|
||||
// Info
|
||||
|
||||
//- Return info proxy.
|
||||
// Used to print token information to a stream
|
||||
InfoProxy<patchPointEdgeCirculator> info() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
friend Ostream& operator<<
|
||||
(
|
||||
Ostream&,
|
||||
const InfoProxy<patchPointEdgeCirculator>&
|
||||
);
|
||||
};
|
||||
|
||||
Ostream& operator<<(Ostream&, const InfoProxy<patchPointEdgeCirculator>&);
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#include "patchPointEdgeCirculatorI.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#endif
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,309 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
|
||||
\\/ 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 2 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, write to the Free Software Foundation,
|
||||
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
|
||||
|
||||
void Foam::patchPointEdgeCirculator::setEnd()
|
||||
{
|
||||
edgeID_ = -1;
|
||||
pointID_ = -1;
|
||||
}
|
||||
|
||||
|
||||
// Cross face to other edge on point
|
||||
void Foam::patchPointEdgeCirculator::otherEdge(const label faceI)
|
||||
{
|
||||
const labelList& fEdges = patch_.faceEdges()[faceI];
|
||||
const face& f = patch_.localFaces()[faceI];
|
||||
label fp = findIndex(f, pointID_);
|
||||
|
||||
if (fEdges[fp] == edgeID_)
|
||||
{
|
||||
edgeID_ = fEdges[f.rcIndex(fp)];
|
||||
}
|
||||
else
|
||||
{
|
||||
// Check for now
|
||||
if (fEdges[f.rcIndex(fp)] != edgeID_)
|
||||
{
|
||||
FatalErrorIn("patchPointEdgeCirculator::otherEdge(const label)")
|
||||
<< "face:" << faceI
|
||||
<< " verts:" << f
|
||||
<< " edges:" << fEdges
|
||||
<< " looking for other edge than " << edgeID_
|
||||
<< abort(FatalError);
|
||||
}
|
||||
edgeID_ = fEdges[fp];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
|
||||
|
||||
//- Construct from components
|
||||
Foam::patchPointEdgeCirculator::patchPointEdgeCirculator
|
||||
(
|
||||
const primitiveFacePatch& patch,
|
||||
const PackedBoolList& nonManifoldEdge,
|
||||
const label edgeID,
|
||||
const label index,
|
||||
|
||||
const label pointID
|
||||
)
|
||||
:
|
||||
patch_(patch),
|
||||
nonManifoldEdge_(nonManifoldEdge),
|
||||
edgeID_(edgeID),
|
||||
index_(index),
|
||||
pointID_(pointID),
|
||||
startEdgeID_(edgeID_)
|
||||
{
|
||||
if (edgeID_ != -1)
|
||||
{
|
||||
const edge& e = patch_.edges()[edgeID_];
|
||||
|
||||
if (pointID_ != e[0] && pointID_ != e[1])
|
||||
{
|
||||
FatalErrorIn
|
||||
(
|
||||
"patchPointEdgeCirculator::patchPointEdgeCirculator(..)"
|
||||
) << "edge " << edgeID_ << " verts " << e
|
||||
<< " does not contain point " << pointID_ << abort(FatalError);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//- Construct copy
|
||||
Foam::patchPointEdgeCirculator::patchPointEdgeCirculator
|
||||
(
|
||||
const patchPointEdgeCirculator& circ
|
||||
)
|
||||
:
|
||||
patch_(circ.patch_),
|
||||
nonManifoldEdge_(circ.nonManifoldEdge_),
|
||||
edgeID_(circ.edgeID_),
|
||||
index_(circ.index_),
|
||||
pointID_(circ.pointID_),
|
||||
startEdgeID_(circ.startEdgeID_)
|
||||
{}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
Foam::label Foam::patchPointEdgeCirculator::edgeID() const
|
||||
{
|
||||
return edgeID_;
|
||||
}
|
||||
|
||||
|
||||
Foam::label Foam::patchPointEdgeCirculator::index() const
|
||||
{
|
||||
return index_;
|
||||
}
|
||||
|
||||
|
||||
Foam::label Foam::patchPointEdgeCirculator::pointID() const
|
||||
{
|
||||
return pointID_;
|
||||
}
|
||||
|
||||
|
||||
Foam::label Foam::patchPointEdgeCirculator::faceID() const
|
||||
{
|
||||
if (edgeID_ != -1 && index_ != -1)
|
||||
{
|
||||
return patch_.edgeFaces()[edgeID_][index_];
|
||||
}
|
||||
else
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Foam::patchPointEdgeCirculator::operator=
|
||||
(
|
||||
const patchPointEdgeCirculator& circ
|
||||
)
|
||||
{
|
||||
edgeID_ = circ.edgeID_;
|
||||
index_ = circ.index_;
|
||||
pointID_ = circ.pointID_;
|
||||
startEdgeID_ = circ.startEdgeID_;
|
||||
}
|
||||
|
||||
|
||||
bool Foam::patchPointEdgeCirculator::operator==
|
||||
(
|
||||
const patchPointEdgeCirculator& circ
|
||||
) const
|
||||
{
|
||||
// Do just enough to have setEnd() produce an iterator equal to end().
|
||||
// Could include the direction(i.e. index_) to make sure that two
|
||||
// circulators around same point but in different direction are not equal.
|
||||
return edgeID_ == circ.edgeID_ && pointID_ == circ.pointID_;
|
||||
}
|
||||
|
||||
|
||||
bool Foam::patchPointEdgeCirculator::operator!=
|
||||
(
|
||||
const patchPointEdgeCirculator& circ
|
||||
) const
|
||||
{
|
||||
return !(*this == circ);
|
||||
}
|
||||
|
||||
|
||||
void Foam::patchPointEdgeCirculator::setCanonical()
|
||||
{
|
||||
if (edgeID_ == -1)
|
||||
{
|
||||
FatalErrorIn("patchPointEdgeCirculator::setCanonical()")
|
||||
<< "Already reached end(). Cannot walk any further."
|
||||
<< abort(FatalError);
|
||||
}
|
||||
|
||||
label minEdgeID = edgeID_;
|
||||
label minIndex = index_;
|
||||
|
||||
while (true)
|
||||
{
|
||||
if (nonManifoldEdge_[edgeID_])
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
// Step back
|
||||
const labelList& eFaces = patch_.edgeFaces()[edgeID_];
|
||||
|
||||
if (eFaces.size() != 2)
|
||||
{
|
||||
FatalErrorIn("patchPointEdgeCirculator::setCanonical()")
|
||||
<< "problem eFaces:" << eFaces << abort(FatalError);
|
||||
}
|
||||
|
||||
label faceI = (index_ == 0 ? eFaces[1] : eFaces[0]);
|
||||
|
||||
// Step to other edge on face
|
||||
otherEdge(faceI);
|
||||
|
||||
// Update index
|
||||
index_ = findIndex(patch_.edgeFaces()[edgeID_], faceI);
|
||||
|
||||
if (edgeID_ < minEdgeID)
|
||||
{
|
||||
minEdgeID = edgeID_;
|
||||
minIndex = index_;
|
||||
}
|
||||
|
||||
if (edgeID_ == startEdgeID_)
|
||||
{
|
||||
edgeID_ = minEdgeID;
|
||||
index_ = minIndex;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
startEdgeID_ = edgeID_;
|
||||
}
|
||||
|
||||
|
||||
//- Step to next edge.
|
||||
Foam::patchPointEdgeCirculator::patchPointEdgeCirculator&
|
||||
Foam::patchPointEdgeCirculator::operator++()
|
||||
{
|
||||
if (index_ == -1)
|
||||
{
|
||||
setEnd();
|
||||
}
|
||||
else
|
||||
{
|
||||
// Step to other edge on face
|
||||
label faceI = patch_.edgeFaces()[edgeID_][index_];
|
||||
otherEdge(faceI);
|
||||
|
||||
if (edgeID_ == startEdgeID_)
|
||||
{
|
||||
setEnd();
|
||||
}
|
||||
else if (nonManifoldEdge_[edgeID_])
|
||||
{
|
||||
// Reached non-manifold edge. Cannot walk further.
|
||||
// Mark so it gets set to end next time.
|
||||
index_ = -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
const labelList& eFaces = patch_.edgeFaces()[edgeID_];
|
||||
|
||||
if (eFaces.size() != 2)
|
||||
{
|
||||
FatalErrorIn("patchPointEdgeCirculator:::operator++()")
|
||||
<< "problem eFaces:" << eFaces << abort(FatalError);
|
||||
}
|
||||
// Point to the face that is not faceI
|
||||
index_ = (eFaces[0] != faceI ? 0 : 1);
|
||||
}
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
Foam::patchPointEdgeCirculator Foam::patchPointEdgeCirculator::begin() const
|
||||
{
|
||||
patchPointEdgeCirculator iter(*this);
|
||||
iter.setCanonical();
|
||||
|
||||
return iter;
|
||||
}
|
||||
|
||||
|
||||
Foam::patchPointEdgeCirculator Foam::patchPointEdgeCirculator::cbegin() const
|
||||
{
|
||||
patchPointEdgeCirculator iter(*this);
|
||||
iter.setCanonical();
|
||||
|
||||
return iter;
|
||||
}
|
||||
|
||||
|
||||
const Foam::patchPointEdgeCirculator& Foam::patchPointEdgeCirculator::end()
|
||||
const
|
||||
{
|
||||
return endConstIter;
|
||||
}
|
||||
|
||||
const Foam::patchPointEdgeCirculator& Foam::patchPointEdgeCirculator::cend()
|
||||
const
|
||||
{
|
||||
return endConstIter;
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -1,6 +1,6 @@
|
||||
EXE_INC = \
|
||||
/* -g -DFULLDEBUG -O0 */ \
|
||||
-I$(LIB_SRC)/parallel/decompositionMethods/lnInclude \
|
||||
-I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
|
||||
-I$(LIB_SRC)/mesh/autoMesh/lnInclude \
|
||||
-I$(LIB_SRC)/meshTools/lnInclude \
|
||||
-I$(LIB_SRC)/triSurface/lnInclude \
|
||||
@ -11,6 +11,7 @@ EXE_INC = \
|
||||
EXE_LIBS = \
|
||||
-lfiniteVolume \
|
||||
-ldecompositionMethods \
|
||||
-L$(FOAM_MPI_LIBBIN) -lptscotchDecomp \
|
||||
-lmeshTools \
|
||||
-ldynamicMesh \
|
||||
-lautoMesh
|
||||
|
||||
@ -347,7 +347,7 @@ int main(int argc, char *argv[])
|
||||
<< "You have selected decomposition method "
|
||||
<< decomposer.typeName
|
||||
<< " which is not parallel aware." << endl
|
||||
<< "Please select one that is (hierarchical, parMetis)"
|
||||
<< "Please select one that is (hierarchical, ptscotch)"
|
||||
<< exit(FatalError);
|
||||
}
|
||||
|
||||
|
||||
@ -71,7 +71,7 @@ Foam::label Foam::checkTopology
|
||||
{
|
||||
Info<< " ***FaceZone " << mesh.faceZones()[zoneI].name()
|
||||
<< " is not correctly synchronised"
|
||||
<< " acrosss coupled boundaries."
|
||||
<< " across coupled boundaries."
|
||||
<< " (coupled faces both"
|
||||
<< " present in set but with opposite flipmap)" << endl;
|
||||
noFailedChecks++;
|
||||
|
||||
@ -259,13 +259,34 @@ void dumpCyclicMatch(const fileName& prefix, const polyMesh& mesh)
|
||||
|
||||
void separateList
|
||||
(
|
||||
const vector& separation,
|
||||
const vectorField& separation,
|
||||
UList<vector>& field
|
||||
)
|
||||
{
|
||||
forAll(field, i)
|
||||
if (separation.size() == 1)
|
||||
{
|
||||
field[i] += separation;
|
||||
// Single value for all.
|
||||
|
||||
forAll(field, i)
|
||||
{
|
||||
field[i] += separation[0];
|
||||
}
|
||||
}
|
||||
else if (separation.size() == field.size())
|
||||
{
|
||||
forAll(field, i)
|
||||
{
|
||||
field[i] += separation[i];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
FatalErrorIn
|
||||
(
|
||||
"separateList(const vectorField&, UList<vector>&)"
|
||||
) << "Sizes of field and transformation not equal. field:"
|
||||
<< field.size() << " transformation:" << separation.size()
|
||||
<< abort(FatalError);
|
||||
}
|
||||
}
|
||||
|
||||
@ -423,8 +444,7 @@ void syncPoints
|
||||
else if (cycPatch.separated())
|
||||
{
|
||||
hasTransformation = true;
|
||||
const vector& v = cycPatch.separation();
|
||||
separateList(v, half0Values);
|
||||
separateList(cycPatch.separation(), half0Values);
|
||||
}
|
||||
|
||||
forAll(coupledPoints, i)
|
||||
@ -540,7 +560,7 @@ int main(int argc, char *argv[])
|
||||
dumpCyclicMatch("initial_", mesh);
|
||||
|
||||
// Read patch construct info from dictionary
|
||||
PtrList<dictionary> patchSources(dict.lookup("patchInfo"));
|
||||
PtrList<dictionary> patchSources(dict.lookup("patches"));
|
||||
|
||||
|
||||
|
||||
@ -585,7 +605,7 @@ int main(int argc, char *argv[])
|
||||
|
||||
if (destPatchI == -1)
|
||||
{
|
||||
dictionary patchDict(dict.subDict("dictionary"));
|
||||
dictionary patchDict(dict.subDict("patchInfo"));
|
||||
|
||||
destPatchI = allPatches.size();
|
||||
|
||||
@ -772,7 +792,7 @@ int main(int argc, char *argv[])
|
||||
<< " separation[0] was "
|
||||
<< cpp.separation()[0] << endl;
|
||||
|
||||
if (isA<cyclicPolyPatch>(pp))
|
||||
if (isA<cyclicPolyPatch>(pp) && pp.size())
|
||||
{
|
||||
const cyclicPolyPatch& cycpp =
|
||||
refCast<const cyclicPolyPatch>(pp);
|
||||
@ -783,14 +803,44 @@ int main(int argc, char *argv[])
|
||||
Info<< "On cyclic translation patch " << pp.name()
|
||||
<< " forcing uniform separation of "
|
||||
<< cycpp.separationVector() << endl;
|
||||
const_cast<vector&>(cpp.separation()) =
|
||||
cycpp.separationVector();
|
||||
const_cast<vectorField&>(cpp.separation()) =
|
||||
pointField(1, cycpp.separationVector());
|
||||
}
|
||||
else
|
||||
{
|
||||
const cyclicPolyPatch& nbr = cycpp.neighbPatch();
|
||||
const_cast<vectorField&>(cpp.separation()) =
|
||||
pointField
|
||||
(
|
||||
1,
|
||||
nbr[0].centre(mesh.points())
|
||||
- cycpp[0].centre(mesh.points())
|
||||
);
|
||||
}
|
||||
}
|
||||
Info<< "On coupled patch " << pp.name()
|
||||
<< " forcing uniform separation of "
|
||||
<< cpp.separation() << endl;
|
||||
}
|
||||
else if (!cpp.parallel())
|
||||
{
|
||||
Info<< "On coupled patch " << pp.name()
|
||||
<< " forcing uniform rotation of "
|
||||
<< cpp.forwardT()[0] << endl;
|
||||
|
||||
const_cast<tensorField&>
|
||||
(
|
||||
cpp.forwardT()
|
||||
).setSize(1);
|
||||
const_cast<tensorField&>
|
||||
(
|
||||
cpp.reverseT()
|
||||
).setSize(1);
|
||||
|
||||
Info<< "On coupled patch " << pp.name()
|
||||
<< " forcing uniform rotation of "
|
||||
<< cpp.forwardT() << endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -48,14 +48,14 @@ matchTolerance 1E-3;
|
||||
pointSync true;
|
||||
|
||||
// Patches to create.
|
||||
patchInfo
|
||||
patches
|
||||
(
|
||||
{
|
||||
// Name of new patch
|
||||
name sidePatches;
|
||||
|
||||
// Type of new patch
|
||||
dictionary
|
||||
patchInfo
|
||||
{
|
||||
type cyclic;
|
||||
|
||||
|
||||
@ -28,20 +28,6 @@ License
|
||||
#include "Time.H"
|
||||
#include "plane.H"
|
||||
|
||||
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
|
||||
|
||||
const Foam::label Foam::mirrorFvMesh::cellRenumber[8][8] =
|
||||
{
|
||||
{-1, -1, -1, -1, -1, -1, -1, -1}, // unknown
|
||||
{-1, -1, -1, -1, -1, -1, -1, -1}, //
|
||||
{-1, -1, -1, -1, -1, -1, -1, -1}, //
|
||||
{ 0, 3, 2, 1, 4, 7, 6, 5}, // hex
|
||||
{ 2, 1, 0, 5, 4, 3, 6, -1}, // wedge
|
||||
{ 0, 2, 1, 3, 5, 4, -1, -1}, // prism
|
||||
{ 0, 3, 2, 1, 4, -1, -1, -1}, // pyramid
|
||||
{ 2, 1, 0, 3, -1, -1, -1, -1}, // tet
|
||||
};
|
||||
|
||||
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
|
||||
|
||||
Foam::mirrorFvMesh::mirrorFvMesh(const IOobject& io)
|
||||
|
||||
@ -71,12 +71,6 @@ class mirrorFvMesh
|
||||
public:
|
||||
|
||||
|
||||
// Static data
|
||||
|
||||
//- Cell renumnering table
|
||||
static const label cellRenumber[8][8];
|
||||
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct from IOobject
|
||||
|
||||
@ -2,7 +2,7 @@ EXE_INC = \
|
||||
-I$(LIB_SRC)/meshTools/lnInclude \
|
||||
-I$(LIB_SRC)/dynamicMesh/lnInclude \
|
||||
-I$(LIB_SRC)/finiteVolume/lnInclude \
|
||||
-I$(LIB_SRC)/parallel/decompositionMethods/lnInclude
|
||||
-I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude
|
||||
|
||||
EXE_LIBS = \
|
||||
-lmeshTools \
|
||||
|
||||
@ -960,7 +960,14 @@ int main(int argc, char *argv[])
|
||||
# endif
|
||||
}
|
||||
|
||||
if (rawLine.empty() || rawLine[0] == '#')
|
||||
// Strip off anything after #
|
||||
string::size_type i = rawLine.find_first_of("#");
|
||||
if (i != string::npos)
|
||||
{
|
||||
rawLine = rawLine(0, i);
|
||||
}
|
||||
|
||||
if (rawLine.empty())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -68,6 +68,104 @@ Description
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
label addPointZone(const polyMesh& mesh, const word& name)
|
||||
{
|
||||
label zoneID = mesh.pointZones().findZoneID(name);
|
||||
|
||||
if (zoneID != -1)
|
||||
{
|
||||
Info<< "Reusing existing pointZone "
|
||||
<< mesh.pointZones()[zoneID].name()
|
||||
<< " at index " << zoneID << endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
pointZoneMesh& pointZones = const_cast<polyMesh&>(mesh).pointZones();
|
||||
zoneID = pointZones.size();
|
||||
Info<< "Adding pointZone " << name << " at index " << zoneID << endl;
|
||||
|
||||
pointZones.setSize(zoneID+1);
|
||||
pointZones.set
|
||||
(
|
||||
zoneID,
|
||||
new pointZone
|
||||
(
|
||||
name,
|
||||
labelList(0),
|
||||
zoneID,
|
||||
pointZones
|
||||
)
|
||||
);
|
||||
}
|
||||
return zoneID;
|
||||
}
|
||||
|
||||
|
||||
label addFaceZone(const polyMesh& mesh, const word& name)
|
||||
{
|
||||
label zoneID = mesh.faceZones().findZoneID(name);
|
||||
|
||||
if (zoneID != -1)
|
||||
{
|
||||
Info<< "Reusing existing faceZone " << mesh.faceZones()[zoneID].name()
|
||||
<< " at index " << zoneID << endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
faceZoneMesh& faceZones = const_cast<polyMesh&>(mesh).faceZones();
|
||||
zoneID = faceZones.size();
|
||||
Info<< "Adding faceZone " << name << " at index " << zoneID << endl;
|
||||
|
||||
faceZones.setSize(zoneID+1);
|
||||
faceZones.set
|
||||
(
|
||||
zoneID,
|
||||
new faceZone
|
||||
(
|
||||
name,
|
||||
labelList(0),
|
||||
boolList(),
|
||||
zoneID,
|
||||
faceZones
|
||||
)
|
||||
);
|
||||
}
|
||||
return zoneID;
|
||||
}
|
||||
|
||||
|
||||
label addCellZone(const polyMesh& mesh, const word& name)
|
||||
{
|
||||
label zoneID = mesh.cellZones().findZoneID(name);
|
||||
|
||||
if (zoneID != -1)
|
||||
{
|
||||
Info<< "Reusing existing cellZone " << mesh.cellZones()[zoneID].name()
|
||||
<< " at index " << zoneID << endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
cellZoneMesh& cellZones = const_cast<polyMesh&>(mesh).cellZones();
|
||||
zoneID = cellZones.size();
|
||||
Info<< "Adding cellZone " << name << " at index " << zoneID << endl;
|
||||
|
||||
cellZones.setSize(zoneID+1);
|
||||
cellZones.set
|
||||
(
|
||||
zoneID,
|
||||
new cellZone
|
||||
(
|
||||
name,
|
||||
labelList(0),
|
||||
zoneID,
|
||||
cellZones
|
||||
)
|
||||
);
|
||||
}
|
||||
return zoneID;
|
||||
}
|
||||
|
||||
|
||||
// Checks whether patch present
|
||||
void checkPatch(const polyBoundaryMesh& bMesh, const word& name)
|
||||
{
|
||||
@ -211,29 +309,20 @@ int main(int argc, char *argv[])
|
||||
polyTopoChanger stitcher(mesh);
|
||||
stitcher.setSize(1);
|
||||
|
||||
DynamicList<pointZone*> pz;
|
||||
DynamicList<faceZone*> fz;
|
||||
DynamicList<cellZone*> cz;
|
||||
mesh.pointZones().clearAddressing();
|
||||
mesh.faceZones().clearAddressing();
|
||||
mesh.cellZones().clearAddressing();
|
||||
|
||||
if (perfectCover)
|
||||
{
|
||||
// Add empty zone for resulting internal faces
|
||||
fz.append
|
||||
(
|
||||
new faceZone
|
||||
(
|
||||
cutZoneName,
|
||||
isf,
|
||||
boolList(masterPatch.size(), false),
|
||||
0,
|
||||
mesh.faceZones()
|
||||
)
|
||||
);
|
||||
label cutZoneID = addFaceZone(mesh, cutZoneName);
|
||||
|
||||
// Note: make sure to add the zones BEFORE constructing polyMeshModifier
|
||||
// (since looks up various zones at construction time)
|
||||
Info<< "Adding point and face zones" << endl;
|
||||
mesh.addZones(pz.shrink(), fz.shrink(), cz.shrink());
|
||||
mesh.faceZones()[cutZoneID].resetAddressing
|
||||
(
|
||||
isf,
|
||||
boolList(masterPatch.size(), false)
|
||||
);
|
||||
|
||||
// Add the perfect interface mesh modifier
|
||||
stitcher.set
|
||||
@ -252,27 +341,15 @@ int main(int argc, char *argv[])
|
||||
}
|
||||
else
|
||||
{
|
||||
pz.append
|
||||
(
|
||||
new pointZone
|
||||
(
|
||||
mergePatchName + "CutPointZone",
|
||||
labelList(0),
|
||||
0,
|
||||
mesh.pointZones()
|
||||
)
|
||||
);
|
||||
label pointZoneID = addPointZone(mesh, mergePatchName + "CutPointZone");
|
||||
mesh.pointZones()[pointZoneID] = labelList(0);
|
||||
|
||||
fz.append
|
||||
label masterZoneID = addFaceZone(mesh, mergePatchName + "MasterZone");
|
||||
|
||||
mesh.faceZones()[masterZoneID].resetAddressing
|
||||
(
|
||||
new faceZone
|
||||
(
|
||||
mergePatchName + "MasterZone",
|
||||
isf,
|
||||
boolList(masterPatch.size(), false),
|
||||
0,
|
||||
mesh.faceZones()
|
||||
)
|
||||
isf,
|
||||
boolList(masterPatch.size(), false)
|
||||
);
|
||||
|
||||
// Slave patch
|
||||
@ -284,42 +361,27 @@ int main(int argc, char *argv[])
|
||||
|
||||
labelList osf(slavePatch.size());
|
||||
|
||||
forAll(osf, i)
|
||||
forAll (osf, i)
|
||||
{
|
||||
osf[i] = slavePatch.start() + i;
|
||||
}
|
||||
|
||||
fz.append
|
||||
label slaveZoneID = addFaceZone(mesh, mergePatchName + "SlaveZone");
|
||||
mesh.faceZones()[slaveZoneID].resetAddressing
|
||||
(
|
||||
new faceZone
|
||||
(
|
||||
mergePatchName + "SlaveZone",
|
||||
osf,
|
||||
boolList(slavePatch.size(), false),
|
||||
1,
|
||||
mesh.faceZones()
|
||||
)
|
||||
osf,
|
||||
boolList(slavePatch.size(), false)
|
||||
);
|
||||
|
||||
// Add empty zone for cut faces
|
||||
fz.append
|
||||
label cutZoneID = addFaceZone(mesh, cutZoneName);
|
||||
mesh.faceZones()[cutZoneID].resetAddressing
|
||||
(
|
||||
new faceZone
|
||||
(
|
||||
cutZoneName,
|
||||
labelList(0),
|
||||
boolList(0, false),
|
||||
2,
|
||||
mesh.faceZones()
|
||||
)
|
||||
labelList(0),
|
||||
boolList(0, false)
|
||||
);
|
||||
|
||||
|
||||
// Note: make sure to add the zones BEFORE constructing polyMeshModifier
|
||||
// (since looks up various zones at construction time)
|
||||
Info<< "Adding point and face zones" << endl;
|
||||
mesh.addZones(pz.shrink(), fz.shrink(), cz.shrink());
|
||||
|
||||
// Add the sliding interface mesh modifier
|
||||
stitcher.set
|
||||
(
|
||||
|
||||
Reference in New Issue
Block a user