zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

COMP: cvMesh and cv2DMesh removed

Browse Source
This commit is contained in:
laurence
2013-01-07 16:08:56 +00:00
parent a13d9b50d0
commit e4c1409679
246 changed files with 68 additions and 104022 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
applications/utilities/mesh/advanced/collapseEdges/collapseDict
View File

@ -2,24 +2,16 @@
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: http://www.openfoam.org |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
root "";
case "";
instance "";
local "";
class dictionary;
object collapseDict;
version 2.0;
format ascii;
class dictionary;
object collapseDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
collapseEdgesCoeffs
@ -78,7 +70,11 @@ meshQualityCoeffs
meshQualityCoeffDict meshQualityDict;
// Maximum number of outer iterations is mesh quality checking is enabled
maximumIterations 30;
maximumIterations 10;
// Maximum number of iterations deletion of a point can cause a bad face
// to be constructed before it is forced to not be deleted
maxPointErrorCount 5;
}

5
applications/utilities/mesh/generation/Allwmake
View File

@ -9,10 +9,5 @@ extrude2DMesh/Allwmake
wmake snappyHexMesh
if [ -d "$CGAL_ARCH_PATH" ]
then
cvMesh/Allwmake
cv2DMesh/Allwmake
fi
# ----------------------------------------------------------------- end-of-file

8
applications/utilities/mesh/generation/cv2DMesh/Allwclean
View File

@ -1,8 +0,0 @@
#!/bin/sh
cd ${0%/*} || exit 1 # run from this directory
set -x
wclean libso conformalVoronoi2DMesh
wclean
# ----------------------------------------------------------------- end-of-file

8
applications/utilities/mesh/generation/cv2DMesh/Allwmake
View File

@ -1,8 +0,0 @@
#!/bin/sh
cd ${0%/*} || exit 1 # run from this directory
set -x
wmake libso conformalVoronoi2DMesh
wmake
# ----------------------------------------------------------------- end-of-file

60
applications/utilities/mesh/generation/cv2DMesh/CGALTriangulation2DKernel.H
View File

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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/>.
Typedefs
CGALTriangulation2DKernel
Description
\*---------------------------------------------------------------------------*/
#ifndef CGALTriangulation2DKernel_H
#define CGALTriangulation2DKernel_H
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "CGAL/Delaunay_triangulation_2.h"
#ifdef CGAL_INEXACT
// Fast kernel using a double as the storage type but the triangulation
// may fail
#include "CGAL/Exact_predicates_inexact_constructions_kernel.h"
typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
#else
// Very robust but expensive kernel
#include "CGAL/Exact_predicates_exact_constructions_kernel.h"
typedef CGAL::Exact_predicates_exact_constructions_kernel K;
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

76
applications/utilities/mesh/generation/cv2DMesh/CGALTriangulation2Ddefs.H
View File

@ -1,76 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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/>.
Typedefs
CGALTriangulation2Ddefs
Description
CGAL data structures used for 2D Delaunay meshing.
Define CGAL_INEXACT to use Exact_predicates_inexact_constructions kernel
otherwise the more robust but much less efficient
Exact_predicates_exact_constructions will be used.
Define CGAL_HIERARCHY to use hierarchical Delaunay triangulation which is
faster but uses more memory than the standard Delaunay triangulation.
\*---------------------------------------------------------------------------*/
#ifndef CGALTriangulation2Ddefs_H
#define CGALTriangulation2Ddefs_H
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "CGALTriangulation2DKernel.H"
#include "indexedVertex.H"
#include "indexedFace.H"
typedef CGAL::indexedVertex<K> Vb;
typedef CGAL::indexedFace<K> Fb;
#ifdef CGAL_HIERARCHY
// Data structures for hierarchical Delaunay triangulation which is more
// efficient but also uses more storage
#include "CGAL/Triangulation_hierarchy_2.h"
typedef CGAL::Triangulation_hierarchy_vertex_base_2<Vb> Vbh;
typedef CGAL::Triangulation_data_structure_2<Vbh, Fb> Tds;
typedef CGAL::Delaunay_triangulation_2<K, Tds> DT;
typedef CGAL::Triangulation_hierarchy_2<DT> Delaunay;
#else
// Data structures for standard Delaunay triangulation
typedef CGAL::Triangulation_data_structure_2<Vb, Fb> Tds;
typedef CGAL::Delaunay_triangulation_2<K, Tds> Delaunay;
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

997
applications/utilities/mesh/generation/cv2DMesh/CV2D.C
View File

@ -1,997 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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 "CV2D.H"
#include "Random.H"
#include "transform.H"
#include "IFstream.H"
#include "uint.H"
#include "ulong.H"
namespace Foam
{
defineTypeNameAndDebug(CV2D, 0);
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void Foam::CV2D::insertBoundingBox()
{
Info<< "insertBoundingBox: creating bounding mesh" << endl;
scalar bigSpan = 10*meshControls().span();
insertPoint(point2D(-bigSpan, -bigSpan), Vb::FAR_POINT);
insertPoint(point2D(-bigSpan, bigSpan), Vb::FAR_POINT);
insertPoint(point2D(bigSpan, -bigSpan), Vb::FAR_POINT);
insertPoint(point2D(bigSpan, bigSpan), Vb::FAR_POINT);
}
void Foam::CV2D::fast_restore_Delaunay(Vertex_handle vh)
{
int i;
Face_handle f = vh->face(), next, start(f);
do
{
i=f->index(vh);
if (!is_infinite(f))
{
if (!internal_flip(f, cw(i))) external_flip(f, i);
if (f->neighbor(i) == start) start = f;
}
f = f->neighbor(cw(i));
} while (f != start);
}
void Foam::CV2D::external_flip(Face_handle& f, int i)
{
Face_handle n = f->neighbor(i);
if
(
CGAL::ON_POSITIVE_SIDE
!= side_of_oriented_circle(n, f->vertex(i)->point())
) return;
flip(f, i);
i = n->index(f->vertex(i));
external_flip(n, i);
}
bool Foam::CV2D::internal_flip(Face_handle& f, int i)
{
Face_handle n = f->neighbor(i);
if
(
CGAL::ON_POSITIVE_SIDE
!= side_of_oriented_circle(n, f->vertex(i)->point())
)
{
return false;
}
flip(f, i);
return true;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::CV2D::CV2D
(
const Time& runTime,
const dictionary& cvMeshDict
)
:
Delaunay(),
runTime_(runTime),
rndGen_(64293*Pstream::myProcNo()),
allGeometry_
(
IOobject
(
"cvSearchableSurfaces",
runTime_.constant(),
"triSurface",
runTime_,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
cvMeshDict.subDict("geometry")
),
qSurf_
(
runTime_,
rndGen_,
allGeometry_,
cvMeshDict.subDict("surfaceConformation")
),
controls_(cvMeshDict, qSurf_.globalBounds()),
cellSizeControl_
(
runTime,
cvMeshDict.subDict("motionControl").subDict("shapeControlFunctions"),
qSurf_,
controls_.minCellSize()
),
relaxationModel_
(
relaxationModel::New
(
cvMeshDict.subDict("motionControl"),
runTime
)
),
z_
(
point
(
cvMeshDict.subDict("surfaceConformation").lookup("locationInMesh")
).z()
),
startOfInternalPoints_(0),
startOfSurfacePointPairs_(0),
startOfBoundaryConformPointPairs_(0),
featurePoints_()
{
Info<< meshControls() << endl;
insertBoundingBox();
insertFeaturePoints();
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::CV2D::~CV2D()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::CV2D::insertPoints
(
const point2DField& points,
const scalar nearness
)
{
Info<< "insertInitialPoints(const point2DField& points): ";
startOfInternalPoints_ = number_of_vertices();
label nVert = startOfInternalPoints_;
// Add the points and index them
forAll(points, i)
{
const point2D& p = points[i];
if (qSurf_.wellInside(toPoint3D(p), nearness))
{
insert(toPoint(p))->index() = nVert++;
}
else
{
Warning
<< "Rejecting point " << p << " outside surface" << endl;
}
}
Info<< nVert << " vertices inserted" << endl;
if (meshControls().objOutput())
{
// Checking validity of triangulation
assert(is_valid());
writeTriangles("initial_triangles.obj", true);
writeFaces("initial_faces.obj", true);
}
}
void Foam::CV2D::insertPoints(const fileName& pointFileName)
{
IFstream pointsFile(pointFileName);
if (pointsFile.good())
{
insertPoints
(
point2DField(pointsFile),
0.5*meshControls().minCellSize2()
);
}
else
{
FatalErrorIn("insertInitialPoints")
<< "Could not open pointsFile " << pointFileName
<< exit(FatalError);
}
}
void Foam::CV2D::insertGrid()
{
Info<< "insertInitialGrid: ";
startOfInternalPoints_ = number_of_vertices();
label nVert = startOfInternalPoints_;
scalar x0 = qSurf_.globalBounds().min().x();
scalar xR = qSurf_.globalBounds().max().x() - x0;
int ni = int(xR/meshControls().minCellSize()) + 1;
scalar deltax = xR/ni;
scalar y0 = qSurf_.globalBounds().min().y();
scalar yR = qSurf_.globalBounds().max().y() - y0;
int nj = int(yR/meshControls().minCellSize()) + 1;
scalar deltay = yR/nj;
Random rndGen(1321);
scalar pert = meshControls().randomPerturbation()*min(deltax, deltay);
for (int i=0; i<ni; i++)
{
for (int j=0; j<nj; j++)
{
point p(x0 + i*deltax, y0 + j*deltay, 0);
if (meshControls().randomiseInitialGrid())
{
p.x() += pert*(rndGen.scalar01() - 0.5);
p.y() += pert*(rndGen.scalar01() - 0.5);
}
if (qSurf_.wellInside(p, 0.5*meshControls().minCellSize2()))
{
insert(Point(p.x(), p.y()))->index() = nVert++;
}
}
}
Info<< nVert << " vertices inserted" << endl;
if (meshControls().objOutput())
{
// Checking validity of triangulation
assert(is_valid());
writeTriangles("initial_triangles.obj", true);
writeFaces("initial_faces.obj", true);
}
}
void Foam::CV2D::insertSurfacePointPairs()
{
startOfSurfacePointPairs_ = number_of_vertices();
if (meshControls().insertSurfaceNearestPointPairs())
{
insertSurfaceNearestPointPairs();
}
write("nearest");
// Insertion of point-pairs for near-points may cause protrusions
// so insertBoundaryConformPointPairs must be executed last
if (meshControls().insertSurfaceNearPointPairs())
{
insertSurfaceNearPointPairs();
}
startOfBoundaryConformPointPairs_ = number_of_vertices();
}
void Foam::CV2D::boundaryConform()
{
if (!meshControls().insertSurfaceNearestPointPairs())
{
markNearBoundaryPoints();
}
// Mark all the faces as SAVE_CHANGED
for
(
Triangulation::Finite_faces_iterator fit = finite_faces_begin();
fit != finite_faces_end();
fit++
)
{
fit->faceIndex() = Fb::SAVE_CHANGED;
}
for (label iter=1; iter<=meshControls().maxBoundaryConformingIter(); iter++)
{
label nIntersections = insertBoundaryConformPointPairs
(
"surfaceIntersections_" + Foam::name(iter) + ".obj"
);
if (nIntersections == 0)
{
break;
}
else
{
Info<< "BC iteration " << iter << ": "
<< nIntersections << " point-pairs inserted" << endl;
}
// Any faces changed by insertBoundaryConformPointPairs will now
// be marked CHANGED, mark those as SAVE_CHANGED and those that
// remained SAVE_CHANGED as UNCHANGED
for
(
Triangulation::Finite_faces_iterator fit = finite_faces_begin();
fit != finite_faces_end();
fit++
)
{
if (fit->faceIndex() == Fb::SAVE_CHANGED)
{
fit->faceIndex() = Fb::UNCHANGED;
}
else if (fit->faceIndex() == Fb::CHANGED)
{
fit->faceIndex() = Fb::SAVE_CHANGED;
}
}
}
Info<< nl;
write("boundary");
}
void Foam::CV2D::removeSurfacePointPairs()
{
for
(
Triangulation::Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
++vit
)
{
if (vit->index() >= startOfSurfacePointPairs_)
{
remove(vit);
}
}
}
void Foam::CV2D::newPoints()
{
const scalar relaxation = relaxationModel_->relaxation();
Info<< "Relaxation = " << relaxation << endl;
Field<point2D> dualVertices(number_of_faces());
label dualVerti = 0;
// Find the dual point of each tetrahedron and assign it an index.
for
(
Triangulation::Finite_faces_iterator fit = finite_faces_begin();
fit != finite_faces_end();
++fit
)
{
fit->faceIndex() = -1;
if
(
fit->vertex(0)->internalOrBoundaryPoint()
|| fit->vertex(1)->internalOrBoundaryPoint()
|| fit->vertex(2)->internalOrBoundaryPoint()
)
{
fit->faceIndex() = dualVerti;
dualVertices[dualVerti] = toPoint2D(circumcenter(fit));
dualVerti++;
}
}
dualVertices.setSize(dualVerti);
Field<vector2D> displacementAccumulator
(
startOfSurfacePointPairs_,
vector2D::zero
);
// Calculate target size and alignment for vertices
scalarField sizes
(
number_of_vertices(),
meshControls().minCellSize()
);
Field<vector2D> alignments
(
number_of_vertices(),
vector2D(1, 0)
);
for
(
Triangulation::Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
++vit
)
{
if (vit->internalOrBoundaryPoint())
{
point2D vert = toPoint2D(vit->point());
// alignment and size determination
pointIndexHit pHit;
label hitSurface = -1;
qSurf_.findSurfaceNearest
(
toPoint3D(vert),
meshControls().span2(),
pHit,
hitSurface
);
if (pHit.hit())
{
vectorField norm(1);
allGeometry_[hitSurface].getNormal
(
List<pointIndexHit>(1, pHit),
norm
);
alignments[vit->index()] = toPoint2D(norm[0]);
sizes[vit->index()] =
cellSizeControl_.cellSize(toPoint3D(vit->point()));
}
}
}
// Info<< "Calculated alignments" << endl;
scalar cosAlignmentAcceptanceAngle = 0.68;
// Upper and lower edge length ratios for weight
scalar u = 1.0;
scalar l = 0.7;
PackedBoolList pointToBeRetained(startOfSurfacePointPairs_, true);
std::list<Point> pointsToInsert;
for
(
Triangulation::Finite_edges_iterator eit = finite_edges_begin();
eit != finite_edges_end();
eit++
)
{
Vertex_handle vA = eit->first->vertex(cw(eit->second));
Vertex_handle vB = eit->first->vertex(ccw(eit->second));
if (!vA->internalOrBoundaryPoint() || !vB->internalOrBoundaryPoint())
{
continue;
}
const point2D& dualV1 = dualVertices[eit->first->faceIndex()];
const point2D& dualV2 =
dualVertices[eit->first->neighbor(eit->second)->faceIndex()];
scalar dualEdgeLength = mag(dualV1 - dualV2);
point2D dVA = toPoint2D(vA->point());
point2D dVB = toPoint2D(vB->point());
Field<vector2D> alignmentDirsA(2);
alignmentDirsA[0] = alignments[vA->index()];
alignmentDirsA[1] = vector2D
(
-alignmentDirsA[0].y(),
alignmentDirsA[0].x()
);
Field<vector2D> alignmentDirsB(2);
alignmentDirsB[0] = alignments[vB->index()];
alignmentDirsB[1] = vector2D
(
-alignmentDirsB[0].y(),
alignmentDirsB[0].x()
);
Field<vector2D> alignmentDirs(2);
forAll(alignmentDirsA, aA)
{
const vector2D& a(alignmentDirsA[aA]);
scalar maxDotProduct = 0.0;
forAll(alignmentDirsB, aB)
{
const vector2D& b(alignmentDirsB[aB]);
scalar dotProduct = a & b;
if (mag(dotProduct) > maxDotProduct)
{
maxDotProduct = mag(dotProduct);
alignmentDirs[aA] = a + sign(dotProduct)*b;
alignmentDirs[aA] /= mag(alignmentDirs[aA]);
}
}
}
vector2D rAB = dVA - dVB;
scalar rABMag = mag(rAB);
forAll(alignmentDirs, aD)
{
vector2D& alignmentDir = alignmentDirs[aD];
if ((rAB & alignmentDir) < 0)
{
// swap the direction of the alignment so that has the
// same sense as rAB
alignmentDir *= -1;
}
scalar alignmentDotProd = ((rAB/rABMag) & alignmentDir);
if (alignmentDotProd > cosAlignmentAcceptanceAngle)
{
scalar targetFaceSize =
0.5*(sizes[vA->index()] + sizes[vB->index()]);
// Test for changing aspect ratio on second alignment (first
// alignment is neartest surface normal)
// if (aD == 1)
// {
// targetFaceSize *= 2.0;
// }
alignmentDir *= 0.5*targetFaceSize;
vector2D delta = alignmentDir - 0.5*rAB;
if (dualEdgeLength < 0.7*targetFaceSize)
{
delta *= 0;
}
else if (dualEdgeLength < targetFaceSize)
{
delta *=
(
dualEdgeLength
/(targetFaceSize*(u - l))
- 1/((u/l) - 1)
);
}
if
(
vA->internalPoint()
&& vB->internalPoint()
&& rABMag > 1.75*targetFaceSize
&& dualEdgeLength > 0.05*targetFaceSize
&& alignmentDotProd > 0.93
)
{
// Point insertion
pointsToInsert.push_back(toPoint(0.5*(dVA + dVB)));
}
else if
(
(vA->internalPoint() || vB->internalPoint())
&& rABMag < 0.65*targetFaceSize
)
{
// Point removal
// Only insert a point at the midpoint of the short edge
// if neither attached point has already been identified
// to be removed.
if
(
pointToBeRetained[vA->index()] == true
&& pointToBeRetained[vB->index()] == true
)
{
pointsToInsert.push_back(toPoint(0.5*(dVA + dVB)));
}
if (vA->internalPoint())
{
pointToBeRetained[vA->index()] = false;
}
if (vB->internalPoint())
{
pointToBeRetained[vB->index()] = false;
}
}
else
{
if (vA->internalPoint())
{
displacementAccumulator[vA->index()] += delta;
}
if (vB->internalPoint())
{
displacementAccumulator[vB->index()] += -delta;
}
}
}
}
}
vector2D totalDisp = sum(displacementAccumulator);
scalar totalDist = sum(mag(displacementAccumulator));
// Relax the calculated displacement
displacementAccumulator *= relaxation;
label numberOfNewPoints = pointsToInsert.size();
for
(
Triangulation::Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
++vit
)
{
if (vit->internalPoint())
{
if (pointToBeRetained[vit->index()])
{
pointsToInsert.push_front
(
toPoint
(
toPoint2D(vit->point())
+ displacementAccumulator[vit->index()]
)
);
}
}
}
// Clear the triangulation and reinsert the bounding box and feature points.
// This is faster than removing and moving points.
this->clear();
insertBoundingBox();
reinsertFeaturePoints();
startOfInternalPoints_ = number_of_vertices();
label nVert = startOfInternalPoints_;
Info<< "Inserting " << numberOfNewPoints << " new points" << endl;
// Use the range insert as it is faster than individually inserting points.
insert(pointsToInsert.begin(), pointsToInsert.end());
for
(
Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
++vit
)
{
if
(
vit->type() == Vb::INTERNAL_POINT
&& vit->index() == Vb::INTERNAL_POINT
)
{
vit->index() = nVert++;
}
}
Info<< " Total displacement = " << totalDisp << nl
<< " Total distance = " << totalDist << nl
<< " Points added = " << pointsToInsert.size()
<< endl;
write("internal");
insertSurfacePointPairs();
boundaryConform();
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Old Method
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// for
// (
// Triangulation::Finite_vertices_iterator vit = finite_vertices_begin();
// vit != finite_vertices_end();
// ++vit
// )
// {
// if (vit->internalPoint())
// {
// // Current dual-cell defining vertex ("centre")
// point2DFromPoint defVert0 = toPoint2D(vit->point());
// Triangulation::Edge_circulator ec = incident_edges(vit);
// Triangulation::Edge_circulator ecStart = ec;
// // Circulate around the edges to find the first which is not
// // infinite
// do
// {
// if (!is_infinite(ec)) break;
// } while (++ec != ecStart);
// // Store the start-end of the first non-infinte edge
// point2D de0 = toPoint2D(circumcenter(ec->first));
// // Keep track of the maximum edge length^2
// scalar maxEdgeLen2 = 0.0;
// // Keep track of the index of the longest edge
// label edgecd0i = -1;
// // Edge counter
// label edgei = 0;
// do
// {
// if (!is_infinite(ec))
// {
// // Get the end of the current edge
// point2D de1 = toPoint2D
// (
// circumcenter(ec->first->neighbor(ec->second))
// );
// // Store the current edge vector
// edges[edgei] = de1 - de0;
// // Store the edge mid-point in the vertices array
// vertices[edgei] = 0.5*(de1 + de0);
// // Move the current edge end into the edge start for the
// // next iteration
// de0 = de1;
// // Keep track of the longest edge
// scalar edgeLen2 = magSqr(edges[edgei]);
// if (edgeLen2 > maxEdgeLen2)
// {
// maxEdgeLen2 = edgeLen2;
// edgecd0i = edgei;
// }
// edgei++;
// }
// } while (++ec != ecStart);
// // Initialise cd0 such that the mesh will align
// // in in the x-y directions
// vector2D cd0(1, 0);
// if (meshControls().relaxOrientation())
// {
// // Get the longest edge from the array and use as the primary
// // direction of the coordinate system of the "square" cell
// cd0 = edges[edgecd0i];
// }
// if (meshControls().nearWallAlignedDist() > 0)
// {
// pointIndexHit pHit = qSurf_.tree().findNearest
// (
// toPoint3D(defVert0),
// meshControls().nearWallAlignedDist2()
// );
// if (pHit.hit())
// {
// cd0 = toPoint2D(faceNormals[pHit.index()]);
// }
// }
// // Rotate by 45deg needed to create an averaging procedure which
// // encourages the cells to be square
// cd0 = vector2D(cd0.x() + cd0.y(), cd0.y() - cd0.x());
// // Normalise the primary coordinate direction
// cd0 /= mag(cd0);
// // Calculate the orthogonal coordinate direction
// vector2D cd1(-cd0.y(), cd0.x());
// // Restart the circulator
// ec = ecStart;
// // ... and the counter
// edgei = 0;
// // Initialise the displacement for the centre and sum-weights
// vector2D disp = vector2D::zero;
// scalar sumw = 0;
// do
// {
// if (!is_infinite(ec))
// {
// // Pick up the current edge
// const vector2D& ei = edges[edgei];
// // Calculate the centre to edge-centre vector
// vector2D deltai = vertices[edgei] - defVert0;
// // Set the weight for this edge contribution
// scalar w = 1;
// if (meshControls().squares())
// {
// w = magSqr(deltai.x()*ei.y() - deltai.y()*ei.x());
// // alternative weights
// //w = mag(deltai.x()*ei.y() - deltai.y()*ei.x());
// //w = magSqr(ei)*mag(deltai);
// // Use the following for an ~square mesh
// // Find the coordinate contributions for this edge delta
// scalar cd0deltai = cd0 & deltai;
// scalar cd1deltai = cd1 & deltai;
// // Create a "square" displacement
// if (mag(cd0deltai) > mag(cd1deltai))
// {
// disp += (w*cd0deltai)*cd0;
// }
// else
// {
// disp += (w*cd1deltai)*cd1;
// }
// }
// else
// {
// // Use this for a hexagon/pentagon mesh
// disp += w*deltai;
// }
// // Sum the weights
// sumw += w;
// }
// else
// {
// FatalErrorIn("CV2D::newPoints() const")
// << "Infinite triangle found in internal mesh"
// << exit(FatalError);
// }
// edgei++;
// } while (++ec != ecStart);
// // Calculate the average displacement
// disp /= sumw;
// totalDisp += disp;
// totalDist += mag(disp);
// // Move the point by a fraction of the average displacement
// movePoint(vit, defVert0 + relaxation*disp);
// }
// }
// Info << "\nTotal displacement = " << totalDisp
// << " total distance = " << totalDist << endl;
}
//void Foam::CV2D::moveInternalPoints(const point2DField& newPoints)
//{
// label pointI = 0;
// for
// (
// Triangulation::Finite_vertices_iterator vit = finite_vertices_begin();
// vit != finite_vertices_end();
// ++vit
// )
// {
// if (vit->internalPoint())
// {
// movePoint(vit, newPoints[pointI++]);
// }
// }
//}
void Foam::CV2D::write() const
{
if (meshControls().objOutput())
{
writeFaces("allFaces.obj", false);
writeFaces("faces.obj", true);
writeTriangles("allTriangles.obj", false);
writeTriangles("triangles.obj", true);
writePatch("patch.pch");
}
}
void Foam::CV2D::write(const word& stage) const
{
if (meshControls().objOutput())
{
Foam::mkDir(stage + "Faces");
Foam::mkDir(stage + "Triangles");
writeFaces
(
stage
+ "Faces/allFaces_"
+ runTime_.timeName()
+ ".obj",
false
);
writeTriangles
(
stage
+ "Triangles/allTriangles_"
+ runTime_.timeName()
+ ".obj",
false
);
}
}
// ************************************************************************* //

474
applications/utilities/mesh/generation/cv2DMesh/CV2D.H
View File

@ -1,474 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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/>.
Class
CV2D
Description
Conformal-Voronoi 2D automatic mesher with grid or read initial points
and point position relaxation with optional "squarification".
There are a substantial number of options to this mesher read from
CV2DMesherDict file e.g.:
// Min cell size used in tolerances when inserting points for
// boundary conforming.
// Also used to as the grid spacing usind in insertGrid.
minCellSize 0.05;
// Feature angle used to inser feature points
// 0 = all features, 180 = no features
featureAngle 45;
// Maximum quadrant angle allowed at a concave corner before
// additional "mitering" lines are added
maxQuadAngle 110;
// Should the mesh be square-dominated or of unbiased hexagons
squares yes;
// Near-wall region where cells are aligned with the wall specified as a
// number of cell layers
nearWallAlignedDist 3;
// Chose if the cell orientation should relax during the iterations
// or remain fixed to the x-y directions
relaxOrientation no;
// Insert near-boundary point mirror or point-pairs
insertSurfaceNearestPointPairs yes;
// Mirror near-boundary points rather than insert point-pairs
mirrorPoints no;
// Insert point-pairs vor dual-cell vertices very near the surface
insertSurfaceNearPointPairs yes;
// Choose if to randomise the initial grid created by insertGrid.
randomiseInitialGrid yes;
// Perturbation fraction, 1 = cell-size.
randomPurturbation 0.1;
// Number of relaxation iterations.
nIterations 5;
// Relaxation factor at the start of the iteration sequence.
// 0.5 is a sensible maximum and < 0.2 converges better.
relaxationFactorStart 0.8;
// Relaxation factor at the end of the iteration sequence.
// Should be <= relaxationFactorStart
relaxationFactorEnd 0;
writeInitialTriangulation no;
writeFeatureTriangulation no;
writeNearestTriangulation no;
writeInsertedPointPairs no;
writeFinalTriangulation yes;
// Maximum number of iterations used in boundaryConform.
maxBoundaryConformingIter 5;
minEdgeLenCoeff 0.5;
maxNotchLenCoeff 0.3;
minNearPointDistCoeff 0.25;
ppDistCoeff 0.05;
SourceFiles
CGALTriangulation2Ddefs.H
indexedVertex.H
indexedFace.H
CV2DI.H
CV2D.C
CV2DIO.C
tolerances.C
controls.C
insertFeaturePoints.C
insertSurfaceNearestPointPairs.C
insertSurfaceNearPointPairs.C
insertBoundaryConformPointPairs.C
\*---------------------------------------------------------------------------*/
#ifndef CV2D_H
#define CV2D_H
#define CGAL_INEXACT
#define CGAL_HIERARCHY
#include "CGALTriangulation2Ddefs.H"
#include "Time.H"
#include "point2DFieldFwd.H"
#include "dictionary.H"
#include "Switch.H"
#include "PackedBoolList.H"
#include "EdgeMap.H"
#include "cv2DControls.H"
#include "tolerances.H"
#include "meshTools.H"
#include "triSurface.H"
#include "searchableSurfaces.H"
#include "conformationSurfaces.H"
#include "relaxationModel.H"
#include "cellSizeAndAlignmentControls.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class CV2D Declaration
\*---------------------------------------------------------------------------*/
class CV2D
:
public Delaunay
{
private:
// Private data
//- The time registry of the application
const Time& runTime_;
mutable Random rndGen_;
//- The surface to mesh
//const querySurface& qSurf_;
//- All geometry of the meshing process, including surfaces to be
// conformed to and those to be used for refinement
searchableSurfaces allGeometry_;
conformationSurfaces qSurf_;
//- Meshing controls
cv2DControls controls_;
//- The cell size control object
cellSizeAndAlignmentControls cellSizeControl_;
//- Relaxation coefficient model. Runtime selectable.
autoPtr<relaxationModel> relaxationModel_;
//- z-level
scalar z_;
//- Keep track of the start of the internal points
label startOfInternalPoints_;
//- Keep track of the start of the surface point-pairs
label startOfSurfacePointPairs_;
//- Keep track of the boundary conform point-pairs
// stored after the insertion of the surface point-pairs in case
// the boundary conform function is called more than once without
// removing and insertin the surface point-pairs
label startOfBoundaryConformPointPairs_;
//- Store the feature points
std::list<Vb> featurePoints_;
//- Temporary storage for a dual-cell
static const label maxNvert = 20;
mutable point2D vertices[maxNvert+1];
mutable vector2D edges[maxNvert+1];
// Private Member Functions
//- Disallow default bitwise copy construct
CV2D(const CV2D&);
//- Disallow default bitwise assignment
void operator=(const CV2D&);
//- Insert point and return it's index
inline label insertPoint
(
const point2D& pt,
const label type
);
//- Insert point and return it's index
inline label insertPoint
(
const point2D& pt,
const label index,
const label type
);
inline label insertPoint
(
const Point& p,
const label index,
const label type
);
inline bool insertMirrorPoint
(
const point2D& nearSurfPt,
const point2D& surfPt
);
//- Insert a point-pair at a distance ppDist either side of
// surface point point surfPt in the direction n
inline void insertPointPair
(
const scalar mirrorDist,
const point2D& surfPt,
const vector2D& n
);
//- Create the initial mesh from the bounding-box
void insertBoundingBox();
//- Check if a point is within a line.
bool on2DLine(const point2D& p, const linePointRef& line);
//- Insert point groups at the feature points.
void insertFeaturePoints();
//- Re-insert point groups at the feature points.
void reinsertFeaturePoints();
//- Insert point-pairs at the given set of points using the surface
// normals corresponding to the given set of surface triangles
// and write the inserted point locations to the given file.
void insertPointPairs
(
const DynamicList<point2D>& nearSurfacePoints,
const DynamicList<point2D>& surfacePoints,
const DynamicList<label>& surfaceTris,
const DynamicList<label>& surfaceHits,
const fileName fName
);
//- Check to see if dual cell specified by given vertex iterator
// intersects the boundary and hence reqires a point-pair.
bool dualCellSurfaceIntersection
(
const Triangulation::Finite_vertices_iterator& vit
) const;
//- Insert point-pairs at the nearest points on the surface to the
// control vertex of dual-cells which intersect the boundary in order
// to provide a boundary-layer mesh.
// NB: This is not guaranteed to close the boundary
void insertSurfaceNearestPointPairs();
//- Insert point-pairs at small dual-cell edges on the surface in order
// to improve the boundary-layer mesh generated by
// insertSurfaceNearestPointPairs.
void insertSurfaceNearPointPairs();
//- Insert point-pair and correcting the Finite_vertices_iterator
// to account for the additional vertices
void insertPointPair
(
Triangulation::Finite_vertices_iterator& vit,
const point2D& p,
const label trii,
const label hitSurface
);
//- Insert point-pair at the best intersection point between the lines
// from the dual-cell real centroid and it's vertices and the surface.
bool insertPointPairAtIntersection
(
Triangulation::Finite_vertices_iterator& vit,
const point2D& defVert,
const point2D vertices[],
const scalar maxProtSize
);
//- Insert point-pairs corresponding to dual-cells which intersect
// the boundary surface
label insertBoundaryConformPointPairs(const fileName& fName);
void markNearBoundaryPoints();
//- Restore the Delaunay contraint
void fast_restore_Delaunay(Vertex_handle vh);
// Flip operations used by fast_restore_Delaunay
void external_flip(Face_handle& f, int i);
bool internal_flip(Face_handle& f, int i);
//- Write all the faces and all the triangles at a particular stage.
void write(const word& stage) const;
public:
//- Runtime type information
ClassName("CV2D");
// Constructors
//- Construct for given surface
CV2D(const Time& runTime, const dictionary& controlDict);
//- Destructor
~CV2D();
// Member Functions
// Access
inline const cv2DControls& meshControls() const;
// Conversion functions between point2D, point and Point
inline const point2D& toPoint2D(const point&) const;
inline const point2DField toPoint2D(const pointField&) const;
inline point toPoint3D(const point2D&) const;
#ifdef CGAL_INEXACT
typedef const point2D& point2DFromPoint;
typedef const Point& PointFromPoint2D;
#else
typedef point2D point2DFromPoint;
typedef Point PointFromPoint2D;
#endif
inline point2DFromPoint toPoint2D(const Point&) const;
inline PointFromPoint2D toPoint(const point2D&) const;
inline point toPoint3D(const Point&) const;
// Point insertion
//- Create the initial mesh from the given internal points.
// Points must be inside the boundary by at least nearness
// otherwise they are ignored.
void insertPoints
(
const point2DField& points,
const scalar nearness
);
//- Create the initial mesh from the internal points in the given
// file. Points outside the geometry are ignored.
void insertPoints(const fileName& pointFileName);
//- Create the initial mesh as a regular grid of points.
// Points outside the geometry are ignored.
void insertGrid();
//- Insert all surface point-pairs from
// insertSurfaceNearestPointPairs and
// findIntersectionForOutsideCentroid
void insertSurfacePointPairs();
//- Insert point-pairs where there are protrusions into
// or out of the surface
void boundaryConform();
// Point removal
//- Remove the point-pairs introduced by insertSurfacePointPairs
// and boundaryConform
void removeSurfacePointPairs();
// Point motion
inline void movePoint(const Vertex_handle& vh, const Point& P);
//- Move the internal points to the given new locations and update
// the triangulation to ensure it is Delaunay
// void moveInternalPoints(const point2DField& newPoints);
//- Calculate the displacements to create the new points
void newPoints();
//- Extract patch names and sizes.
void extractPatches
(
wordList& patchNames,
labelList& patchSizes,
EdgeMap<label>& mapEdgesRegion,
EdgeMap<label>& indirectPatchEdge
) const;
// Write
//- Write internal points to .obj file
void writePoints(const fileName& fName, bool internalOnly) const;
//- Write triangles as .obj file
void writeTriangles(const fileName& fName, bool internalOnly) const;
//- Write dual faces as .obj file
void writeFaces(const fileName& fName, bool internalOnly) const;
//- Calculates dual points (circumcentres of tets) and faces
// (point-cell walk of tets).
// Returns:
// - dualPoints (in triangle ordering)
// - dualFaces (compacted)
void calcDual
(
point2DField& dualPoints,
faceList& dualFaces,
wordList& patchNames,
labelList& patchSizes,
EdgeMap<label>& mapEdgesRegion,
EdgeMap<label>& indirectPatchEdge
) const;
//- Write patch
void writePatch(const fileName& fName) const;
void write() const;
};
inline bool boundaryTriangle(const CV2D::Face_handle fc);
inline bool outsideTriangle(const CV2D::Face_handle fc);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "CV2DI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

227
applications/utilities/mesh/generation/cv2DMesh/CV2DI.H
View File

@ -1,227 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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/>.
\*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
inline Foam::label Foam::CV2D::insertPoint
(
const point2D& p,
const label type
)
{
uint nVert = number_of_vertices();
return insertPoint(toPoint(p), nVert, type);
}
inline Foam::label Foam::CV2D::insertPoint
(
const point2D& p,
const label index,
const label type
)
{
return insertPoint(toPoint(p), index, type);
}
inline Foam::label Foam::CV2D::insertPoint
(
const Point& p,
const label index,
const label type
)
{
uint nVert = number_of_vertices();
Vertex_handle vh = insert(p);
if (nVert == number_of_vertices())
{
WarningIn("Foam::CV2D::insertPoint")
<< "Failed to insert point " << toPoint2D(p) << endl;
}
else
{
vh->index() = index;
vh->type() = type;
}
return vh->index();
}
inline bool Foam::CV2D::insertMirrorPoint
(
const point2D& nearSurfPt,
const point2D& surfPt
)
{
point2D mirrorPoint(2*surfPt - nearSurfPt);
if (qSurf_.outside(toPoint3D(mirrorPoint)))
{
insertPoint(mirrorPoint, Vb::MIRROR_POINT);
return true;
}
else
{
return false;
}
}
inline void Foam::CV2D::insertPointPair
(
const scalar ppDist,
const point2D& surfPt,
const vector2D& n
)
{
vector2D ppDistn = ppDist*n;
label master = insertPoint
(
surfPt - ppDistn,
number_of_vertices() + 1
);
insertPoint(surfPt + ppDistn, master);
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline const Foam::cv2DControls& Foam::CV2D::meshControls() const
{
return controls_;
}
inline const Foam::point2D& Foam::CV2D::toPoint2D(const point& p) const
{
return reinterpret_cast<const point2D&>(p);
}
inline const Foam::point2DField Foam::CV2D::toPoint2D(const pointField& p) const
{
point2DField temp(p.size());
forAll(temp, pointI)
{
temp[pointI] = point2D(p[pointI].x(), p[pointI].y());
}
return temp;
}
inline Foam::point Foam::CV2D::toPoint3D(const point2D& p) const
{
return point(p.x(), p.y(), z_);
}
#ifdef CGAL_INEXACT
inline Foam::CV2D::point2DFromPoint Foam::CV2D::toPoint2D(const Point& P) const
{
return reinterpret_cast<point2DFromPoint>(P);
}
inline Foam::CV2D::PointFromPoint2D Foam::CV2D::toPoint(const point2D& p) const
{
return reinterpret_cast<PointFromPoint2D>(p);
}
#else
inline Foam::CV2D::point2DFromPoint Foam::CV2D::toPoint2D(const Point& P) const
{
return point2D(CGAL::to_double(P.x()), CGAL::to_double(P.y()));
}
inline Foam::CV2D::PointFromPoint2D Foam::CV2D::toPoint(const point2D& p) const
{
return Point(p.x(), p.y());
}
#endif
inline Foam::point Foam::CV2D::toPoint3D(const Point& P) const
{
return point(CGAL::to_double(P.x()), CGAL::to_double(P.y()), z_);
}
inline void Foam::CV2D::movePoint(const Vertex_handle& vh, const Point& P)
{
int i = vh->index();
int t = vh->type();
remove(vh);
Vertex_handle newVh = insert(P);
newVh->index() = i;
newVh->type() = t;
// label i = vh->index();
// move(vh, P);
// vh->index() = i;
//vh->set_point(P);
//fast_restore_Delaunay(vh);
}
// * * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * //
inline bool Foam::boundaryTriangle(const CV2D::Face_handle fc)
{
return boundaryTriangle
(
*fc->vertex(0),
*fc->vertex(1),
*fc->vertex(2)
);
}
inline bool Foam::outsideTriangle(const CV2D::Face_handle fc)
{
return outsideTriangle
(
*fc->vertex(0),
*fc->vertex(1),
*fc->vertex(2)
);
}
// ************************************************************************* //

386
applications/utilities/mesh/generation/cv2DMesh/CV2DIO.C
View File

@ -1,386 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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 "CV2D.H"
#include "OFstream.H"
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::CV2D::writePoints(const fileName& fName, bool internalOnly) const
{
Info<< "Writing points to " << fName << nl << endl;
OFstream str(fName);
for
(
Triangulation::Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
++vit
)
{
if (!internalOnly || vit->internalOrBoundaryPoint())
{
meshTools::writeOBJ(str, toPoint3D(vit->point()));
}
}
}
void Foam::CV2D::writeTriangles(const fileName& fName, bool internalOnly) const
{
Info<< "Writing triangles to " << fName << nl << endl;
OFstream str(fName);
labelList vertexMap(number_of_vertices(), -2);
label verti = 0;
for
(
Triangulation::Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
++vit
)
{
if (!internalOnly || !vit->farPoint())
{
vertexMap[vit->index()] = verti++;
meshTools::writeOBJ(str, toPoint3D(vit->point()));
}
}
for
(
Triangulation::Finite_faces_iterator fit = finite_faces_begin();
fit != finite_faces_end();
++fit
)
{
if
(
!internalOnly
|| (
fit->vertex(0)->internalOrBoundaryPoint()
|| fit->vertex(1)->internalOrBoundaryPoint()
|| fit->vertex(2)->internalOrBoundaryPoint()
)
)
{
str << "f";
for (label i = 0; i < 3; ++i)
{
str << " " << vertexMap[fit->vertex(i)->index()] + 1;
}
str << nl;
}
}
}
void Foam::CV2D::writeFaces(const fileName& fName, bool internalOnly) const
{
Info<< "Writing dual faces to " << fName << nl << endl;
OFstream str(fName);
label dualVerti = 0;
for
(
Triangulation::Finite_faces_iterator fit = finite_faces_begin();
fit != finite_faces_end();
++fit
)
{
if
(
!internalOnly
|| (
fit->vertex(0)->internalOrBoundaryPoint()
|| fit->vertex(1)->internalOrBoundaryPoint()
|| fit->vertex(2)->internalOrBoundaryPoint()
)
)
{
fit->faceIndex() = dualVerti++;
meshTools::writeOBJ(str, toPoint3D(circumcenter(fit)));
}
else
{
fit->faceIndex() = -1;
}
}
for
(
Triangulation::Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
++vit
)
{
if (!internalOnly || vit->internalOrBoundaryPoint())
{
Face_circulator fcStart = incident_faces(vit);
Face_circulator fc = fcStart;
str<< 'f';
do
{
if (!is_infinite(fc))
{
if (fc->faceIndex() < 0)
{
FatalErrorIn
(
"Foam::CV2D::writeFaces"
"(const fileName& fName, bool internalOnly)"
)<< "Dual face uses vertex defined by a triangle"
" defined by an external point"
<< exit(FatalError);
}
str<< ' ' << fc->faceIndex() + 1;
}
} while (++fc != fcStart);
str<< nl;
}
}
}
void Foam::CV2D::extractPatches
(
wordList& patchNames,
labelList& patchSizes,
EdgeMap<label>& mapEdgesRegion,
EdgeMap<label>& indirectPatchEdge
) const
{
label nPatches = qSurf_.patchNames().size() + 1;
label defaultPatchIndex = qSurf_.patchNames().size();
patchNames.setSize(nPatches);
patchSizes.setSize(nPatches, 0);
mapEdgesRegion.clear();
const wordList& existingPatches = qSurf_.patchNames();
forAll(existingPatches, sP)
{
patchNames[sP] = existingPatches[sP];
}
patchNames[defaultPatchIndex] = "CV2D_default_patch";
for
(
Triangulation::Finite_edges_iterator eit = finite_edges_begin();
eit != finite_edges_end();
++eit
)
{
Face_handle fOwner = eit->first;
Face_handle fNeighbor = fOwner->neighbor(eit->second);
Vertex_handle vA = fOwner->vertex(cw(eit->second));
Vertex_handle vB = fOwner->vertex(ccw(eit->second));
if
(
(vA->internalOrBoundaryPoint() && !vB->internalOrBoundaryPoint())
|| (vB->internalOrBoundaryPoint() && !vA->internalOrBoundaryPoint())
)
{
point ptA = toPoint3D(vA->point());
point ptB = toPoint3D(vB->point());
label patchIndex = qSurf_.findPatch(ptA, ptB);
if (patchIndex == -1)
{
patchIndex = defaultPatchIndex;
WarningIn("Foam::CV2D::extractPatches")
<< "Dual face found that is not on a surface "
<< "patch. Adding to CV2D_default_patch."
<< endl;
}
edge e(fOwner->faceIndex(), fNeighbor->faceIndex());
patchSizes[patchIndex]++;
mapEdgesRegion.insert(e, patchIndex);
if (!pointPair(*vA, *vB))
{
indirectPatchEdge.insert(e, 1);
}
}
}
}
void Foam::CV2D::calcDual
(
point2DField& dualPoints,
faceList& dualFaces,
wordList& patchNames,
labelList& patchSizes,
EdgeMap<label>& mapEdgesRegion,
EdgeMap<label>& indirectPatchEdge
) const
{
// Dual points stored in triangle order.
dualPoints.setSize(number_of_faces());
label dualVerti = 0;
for
(
Triangulation::Finite_faces_iterator fit = finite_faces_begin();
fit != finite_faces_end();
++fit
)
{
if
(
fit->vertex(0)->internalOrBoundaryPoint()
|| fit->vertex(1)->internalOrBoundaryPoint()
|| fit->vertex(2)->internalOrBoundaryPoint()
)
{
fit->faceIndex() = dualVerti;
dualPoints[dualVerti++] = toPoint2D(circumcenter(fit));
}
else
{
fit->faceIndex() = -1;
}
}
dualPoints.setSize(dualVerti);
extractPatches(patchNames, patchSizes, mapEdgesRegion, indirectPatchEdge);
forAll(patchNames, patchI)
{
Info<< "Patch " << patchNames[patchI]
<< " has size " << patchSizes[patchI] << endl;
}
// Create dual faces
// ~~~~~~~~~~~~~~~~~
dualFaces.setSize(number_of_vertices());
label dualFacei = 0;
labelList faceVerts(maxNvert);
for
(
Triangulation::Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
++vit
)
{
if (vit->internalOrBoundaryPoint())
{
Face_circulator fcStart = incident_faces(vit);
Face_circulator fc = fcStart;
label verti = 0;
do
{
if (!is_infinite(fc))
{
if (fc->faceIndex() < 0)
{
FatalErrorIn
(
"Foam::CV2D::calcDual"
"(point2DField& dualPoints, faceList& dualFaces)"
)<< "Dual face uses vertex defined by a triangle"
" defined by an external point"
<< exit(FatalError);
}
// Look up the index of the triangle
faceVerts[verti++] = fc->faceIndex();
}
} while (++fc != fcStart);
if (faceVerts.size() > 2)
{
dualFaces[dualFacei++] =
face(labelList::subList(faceVerts, verti));
}
else
{
Info<< "From triangle point:" << vit->index()
<< " coord:" << toPoint2D(vit->point())
<< " generated illegal dualFace:" << faceVerts
<< endl;
}
}
}
dualFaces.setSize(dualFacei);
}
void Foam::CV2D::writePatch(const fileName& fName) const
{
point2DField dual2DPoints;
faceList dualFaces;
wordList patchNames;
labelList patchSizes;
EdgeMap<label> mapEdgesRegion;
EdgeMap<label> indirectPatchEdge;
calcDual
(
dual2DPoints,
dualFaces,
patchNames,
patchSizes,
mapEdgesRegion,
indirectPatchEdge
);
pointField dualPoints(dual2DPoints.size());
forAll(dualPoints, ip)
{
dualPoints[ip] = toPoint3D(dual2DPoints[ip]);
}
// Dump as primitive patch to be read by extrudeMesh.
OFstream str(fName);
Info<< "Writing patch to be used with extrudeMesh to file " << fName
<< endl;
str << dualPoints << nl << dualFaces << nl;
}
// ************************************************************************* //

12
applications/utilities/mesh/generation/cv2DMesh/Make/files
View File

@ -1,12 +0,0 @@
#include CGAL_FILES
CV2D.C
insertFeaturePoints.C
insertSurfaceNearestPointPairs.C
insertSurfaceNearPointPairs.C
insertBoundaryConformPointPairs.C
CV2DIO.C
shortEdgeFilter2D.C
cv2DMesh.C
EXE = $(FOAM_APPBIN)/cv2DMesh

43
applications/utilities/mesh/generation/cv2DMesh/Make/options
View File

@ -1,43 +0,0 @@
EXE_DEBUG = -DFULLDEBUG -g -O0
EXE_FROUNDING_MATH = -frounding-math
EXE_NDEBUG = -DNDEBUG
include $(GENERAL_RULES)/CGAL
FFLAGS = -DCGAL_FILES='"${CGAL_ARCH_PATH}/share/files"'
EXE_INC = \
${EXE_FROUNDING_MATH} \
${EXE_NDEBUG} \
${CGAL_INC} \
-I$(FOAM_APP)/utilities/mesh/generation/extrude2DMesh/extrude2DMesh/lnInclude \
-I../cvMesh/vectorTools \
-IconformalVoronoi2DMesh/lnInclude \
-I$(FOAM_APP)/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/lnInclude \
-I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/surfMesh/lnInclude \
-I$(LIB_SRC)/edgeMesh/lnInclude \
-I$(LIB_SRC)/dynamicMesh/lnInclude \
-I$(LIB_SRC)/mesh/extrudeModel/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude \
-I$(LIB_SRC)/triSurface/lnInclude \
-I$(LIB_SRC)/fileFormats/lnInclude \
EXE_LIBS = \
$(CGAL_LIBS) \
-lboost_thread \
-lmpfr \
-lextrude2DMesh \
-lextrudeModel \
-lcv2DMesh \
-lconformalVoronoiMesh \
-lmeshTools \
-lsurfMesh \
-ledgeMesh \
-ltriSurface \
-ldynamicMesh \
-ldecompositionMethods \
-L$(FOAM_LIBBIN)/dummy -lptscotchDecomp \
-lsampling \
-lfileFormats

3
applications/utilities/mesh/generation/cv2DMesh/conformalVoronoi2DMesh/Make/files
View File

@ -1,3 +0,0 @@
cv2DControls/cv2DControls.C
LIB = $(FOAM_LIBBIN)/libcv2DMesh

3
applications/utilities/mesh/generation/cv2DMesh/conformalVoronoi2DMesh/Make/options
View File

@ -1,3 +0,0 @@
EXE_INC =
LIB_LIBS =

154
applications/utilities/mesh/generation/cv2DMesh/conformalVoronoi2DMesh/cv2DControls/cv2DControls.C
View File

@ -1,154 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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 "cv2DControls.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::cv2DControls::cv2DControls
(
const dictionary& controlDict,
const boundBox& bb
)
:
dict_(controlDict),
motionControl_(controlDict.subDict("motionControl")),
conformationControl_(controlDict.subDict("surfaceConformation")),
minCellSize_(readScalar(motionControl_.lookup("minCellSize"))),
minCellSize2_(Foam::sqr(minCellSize_)),
maxQuadAngle_(readScalar(conformationControl_.lookup("maxQuadAngle"))),
nearWallAlignedDist_
(
readScalar(motionControl_.lookup("nearWallAlignedDist"))*minCellSize_
),
nearWallAlignedDist2_(Foam::sqr(nearWallAlignedDist_)),
insertSurfaceNearestPointPairs_
(
conformationControl_.lookup("insertSurfaceNearestPointPairs")
),
mirrorPoints_(conformationControl_.lookup("mirrorPoints")),
insertSurfaceNearPointPairs_
(
conformationControl_.lookup("insertSurfaceNearPointPairs")
),
objOutput_(motionControl_.lookupOrDefault<Switch>("objOutput", false)),
meshedSurfaceOutput_
(
motionControl_.lookupOrDefault<Switch>("meshedSurfaceOutput", false)
),
randomiseInitialGrid_(conformationControl_.lookup("randomiseInitialGrid")),
randomPerturbation_
(
readScalar(conformationControl_.lookup("randomPerturbation"))
),
maxBoundaryConformingIter_
(
readLabel(conformationControl_.lookup("maxBoundaryConformingIter"))
),
span_
(
max(mag(bb.max().x()), mag(bb.min().x()))
+ max(mag(bb.max().y()), mag(bb.min().y()))
),
span2_(Foam::sqr(span_)),
minEdgeLen_
(
readScalar(conformationControl_.lookup("minEdgeLenCoeff"))
*minCellSize_
),
minEdgeLen2_(Foam::sqr(minEdgeLen_)),
maxNotchLen_
(
readScalar(conformationControl_.lookup("maxNotchLenCoeff"))
*minCellSize_
),
maxNotchLen2_(Foam::sqr(maxNotchLen_)),
minNearPointDist_
(
readScalar(conformationControl_.lookup("minNearPointDistCoeff"))
*minCellSize_
),
minNearPointDist2_(Foam::sqr(minNearPointDist_)),
ppDist_
(
readScalar(conformationControl_.lookup("pointPairDistanceCoeff"))
*minCellSize_
)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::cv2DControls::~cv2DControls()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
void Foam::cv2DControls::write(Ostream& os) const
{
os.indentLevel() = 1;
os.precision(2);
os.flags(ios_base::scientific);
os << nl << "Outputting CV2D Mesher controls:" << nl
<< token::BEGIN_BLOCK << nl
<< indent << "minCellSize2_ : " << minCellSize2_ << nl
<< indent << "span_ / span2_ : " << span_ << " / " << span2_ << nl
<< indent << "maxNotchLen2_ : " << maxNotchLen2_ << nl
<< indent << "minNearPointDist2_ : " << minNearPointDist2_ << nl
<< indent << "nearWallAlignedDist2_ : " << nearWallAlignedDist2_ << nl
<< indent << "ppDist_ : " << ppDist_ << nl
<< indent << "minEdgeLen2_ : " << minEdgeLen2_ << nl
<< token::END_BLOCK << endl;
}
// * * * * * * * * * * * * * * IOStream operators * * * * * * * * * * * * * //
Foam::Ostream& Foam::operator<<(Ostream& os, const cv2DControls& s)
{
s.write(os);
return os;
}
// ************************************************************************* //

260
applications/utilities/mesh/generation/cv2DMesh/conformalVoronoi2DMesh/cv2DControls/cv2DControls.H
View File

@ -1,260 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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/>.
Class
Foam::cv2DControls
Description
Controls for the 2D CV mesh generator.
SourceFiles
cv2DControls.C
cv2DControlsI.H
\*---------------------------------------------------------------------------*/
#ifndef cv2DControls_H
#define cv2DControls_H
#include "Switch.H"
#include "dictionary.H"
#include "boundBox.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cv2DControls Declaration
\*---------------------------------------------------------------------------*/
class cv2DControls
{
// Private data
//- Description of data_
const dictionary& dict_;
const dictionary& motionControl_;
const dictionary& conformationControl_;
// Private Member Functions
//- Disallow default bitwise copy construct
cv2DControls(const cv2DControls&);
//- Disallow default bitwise assignment
void operator=(const cv2DControls&);
public:
// Controls
//- Minimum cell size below which protusions through the surface are
// not split
scalar minCellSize_;
//- Square of minCellSize
scalar minCellSize2_;
//- Maximum quadrant angle allowed at a concave corner before
// additional "mitering" lines are added
scalar maxQuadAngle_;
//- Near-wall region where cells are aligned with the wall
scalar nearWallAlignedDist_;
//- Square of nearWallAlignedDist
scalar nearWallAlignedDist2_;
//- Insert near-boundary point mirror or point-pairs
Switch insertSurfaceNearestPointPairs_;
//- Mirror near-boundary points rather than insert point-pairs
Switch mirrorPoints_;
//- Insert point-pairs vor dual-cell vertices very near the surface
Switch insertSurfaceNearPointPairs_;
Switch objOutput_;
Switch meshedSurfaceOutput_;
Switch randomiseInitialGrid_;
scalar randomPerturbation_;
label maxBoundaryConformingIter_;
// Tolerances
//- Maximum cartesian span of the geometry
scalar span_;
//- Square of span
scalar span2_;
//- Minumum edge-length of the cell size below which protusions
// through the surface are not split
scalar minEdgeLen_;
//- Square of minEdgeLen
scalar minEdgeLen2_;
//- Maximum notch size below which protusions into the surface are
// not filled
scalar maxNotchLen_;
//- Square of maxNotchLen
scalar maxNotchLen2_;
//- The minimum distance alowed between a dual-cell vertex
// and the surface before a point-pair is introduced
scalar minNearPointDist_;
//- Square of minNearPoint
scalar minNearPointDist2_;
//- Distance between boundary conforming point-pairs
scalar ppDist_;
//- Square of ppDist
scalar ppDist2_;
// Constructors
cv2DControls
(
const dictionary& controlDict,
const boundBox& bb
);
//- Destructor
~cv2DControls();
// Member Functions
// Access
//- Return the minimum cell size
inline scalar minCellSize() const;
//- Return the square of the minimum cell size
inline scalar minCellSize2() const;
//- Return the maximum quadrant angle
inline scalar maxQuadAngle() const;
//- Return number of layers to align with the nearest wall
inline scalar nearWallAlignedDist() const;
//- Return square of nearWallAlignedDist
inline scalar nearWallAlignedDist2() const;
//- Return insertSurfaceNearestPointPairs Switch
inline Switch insertSurfaceNearestPointPairs() const;
//- Return mirrorPoints Switch
inline Switch mirrorPoints() const;
//- Return insertSurfaceNearPointPairs Switch
inline Switch insertSurfaceNearPointPairs() const;
//- Return the objOutput Switch
inline Switch objOutput() const;
//- Return the meshedSurfaceOutput Switch
inline Switch meshedSurfaceOutput() const;
//- Return the randomise initial point layout Switch
inline Switch randomiseInitialGrid() const;
//- Return the random perturbation factor
inline scalar randomPerturbation() const;
//- Return the maximum number of boundary conformation iterations
inline label maxBoundaryConformingIter() const;
//- Return the span
inline scalar span() const;
//- Return the span squared
inline scalar span2() const;
//- Return the minEdgeLen
inline scalar minEdgeLen() const;
//- Return the minEdgeLen squared
inline scalar minEdgeLen2() const;
//- Return the maxNotchLen
inline scalar maxNotchLen() const;
//- Return the maxNotchLen squared
inline scalar maxNotchLen2() const;
//- Return the minNearPointDist
inline scalar minNearPointDist() const;
//- Return the minNearPointDist squared
inline scalar minNearPointDist2() const;
//- Return the ppDist
inline scalar ppDist() const;
// Write
//- Write controls to output stream.
void write(Ostream& os) const;
//- Ostream Operator
friend Ostream& operator<<
(
Ostream& os,
const cv2DControls& s
);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "cv2DControlsI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

158
applications/utilities/mesh/generation/cv2DMesh/conformalVoronoi2DMesh/cv2DControls/cv2DControlsI.H
View File

@ -1,158 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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/>.
\*---------------------------------------------------------------------------*/
inline Foam::scalar Foam::cv2DControls::minCellSize() const
{
return minCellSize_;
}
inline Foam::scalar Foam::cv2DControls::minCellSize2() const
{
return minCellSize2_;
}
inline Foam::scalar Foam::cv2DControls::maxQuadAngle() const
{
return maxQuadAngle_;
}
inline Foam::scalar Foam::cv2DControls::nearWallAlignedDist() const
{
return nearWallAlignedDist_;
}
inline Foam::scalar Foam::cv2DControls::nearWallAlignedDist2() const
{
return nearWallAlignedDist2_;
}
inline Foam::Switch Foam::cv2DControls::insertSurfaceNearestPointPairs() const
{
return insertSurfaceNearestPointPairs_;
}
inline Foam::Switch Foam::cv2DControls::mirrorPoints() const
{
return mirrorPoints_;
}
inline Foam::Switch Foam::cv2DControls::insertSurfaceNearPointPairs() const
{
return insertSurfaceNearPointPairs_;
}
inline Foam::Switch Foam::cv2DControls::objOutput() const
{
return objOutput_;
}
inline Foam::Switch Foam::cv2DControls::meshedSurfaceOutput() const
{
return meshedSurfaceOutput_;
}
inline Foam::Switch Foam::cv2DControls::randomiseInitialGrid() const
{
return randomiseInitialGrid_;
}
inline Foam::scalar Foam::cv2DControls::randomPerturbation() const
{
return randomPerturbation_;
}
inline Foam::label Foam::cv2DControls::maxBoundaryConformingIter() const
{
return maxBoundaryConformingIter_;
}
inline Foam::scalar Foam::cv2DControls::span() const
{
return span_;
}
inline Foam::scalar Foam::cv2DControls::span2() const
{
return span2_;
}
inline Foam::scalar Foam::cv2DControls::minEdgeLen() const
{
return minEdgeLen_;
}
inline Foam::scalar Foam::cv2DControls::minEdgeLen2() const
{
return minEdgeLen2_;
}
inline Foam::scalar Foam::cv2DControls::maxNotchLen() const
{
return maxNotchLen_;
}
inline Foam::scalar Foam::cv2DControls::maxNotchLen2() const
{
return maxNotchLen2_;
}
inline Foam::scalar Foam::cv2DControls::minNearPointDist() const
{
return minNearPointDist_;
}
inline Foam::scalar Foam::cv2DControls::minNearPointDist2() const
{
return minNearPointDist2_;
}
inline Foam::scalar Foam::cv2DControls::ppDist() const
{
return ppDist_;
}
// ************************************************************************* //

230
applications/utilities/mesh/generation/cv2DMesh/cv2DMesh.C
View File

@ -1,230 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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/>.
Application
cv2DMesh
Description
Conformal-Voronoi 2D extruding automatic mesher with grid or read
initial points and point position relaxation with optional
"squarification".
\*---------------------------------------------------------------------------*/
#include "CV2D.H"
#include "argList.H"
#include "MeshedSurfaces.H"
#include "shortEdgeFilter2D.H"
#include "extrude2DMesh.H"
#include "polyMesh.H"
#include "patchToPoly2DMesh.H"
#include "extrudeModel.H"
#include "polyTopoChange.H"
#include "edgeCollapser.H"
#include "globalIndex.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
int main(int argc, char *argv[])
{
argList::noParallel();
argList::validArgs.clear();
argList::validOptions.insert
(
"pointsFile",
"filename"
);
#include "addOverwriteOption.H"
#include "setRootCase.H"
#include "createTime.H"
// Read control dictionary
// ~~~~~~~~~~~~~~~~~~~~~~~
IOdictionary controlDict
(
IOobject
(
args.executable() + "Dict",
runTime.system(),
runTime,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
const dictionary& shortEdgeFilterDict
(
controlDict.subDict("shortEdgeFilter")
);
const dictionary& extrusionDict(controlDict.subDict("extrusion"));
Switch extrude(extrusionDict.lookup("extrude"));
const bool overwrite = args.optionFound("overwrite");
// Read and triangulation
// ~~~~~~~~~~~~~~~~~~~~~~
CV2D mesh(runTime, controlDict);
if (args.options().found("pointsFile"))
{
fileName pointFileName(IStringStream(args.options()["pointsFile"])());
mesh.insertPoints(pointFileName);
}
else
{
mesh.insertGrid();
}
mesh.insertSurfacePointPairs();
mesh.boundaryConform();
while (runTime.loop())
{
Info<< nl << "Time = " << runTime.timeName() << endl;
mesh.newPoints();
}
mesh.write();
Info<< "Finished Delaunay in = " << runTime.cpuTimeIncrement() << " s."
<< endl;
Info<< "Begin filtering short edges:" << endl;
shortEdgeFilter2D sef(mesh, shortEdgeFilterDict);
sef.filter();
Info<< "Meshed surface after edge filtering :" << endl;
sef.fMesh().writeStats(Info);
if (mesh.meshControls().meshedSurfaceOutput())
{
Info<< "Write .obj file of the 2D mesh: MeshedSurface.obj" << endl;
sef.fMesh().write("MeshedSurface.obj");
}
Info<< "Finished filtering in = " << runTime.cpuTimeIncrement() << " s."
<< endl;
Info<< "Begin constructing a polyMesh:" << endl;
patchToPoly2DMesh poly2DMesh
(
sef.fMesh(),
sef.patchNames(),
sef.patchSizes(),
sef.mapEdgesRegion()
);
poly2DMesh.createMesh();
polyMesh pMesh
(
IOobject
(
polyMesh::defaultRegion,
runTime.constant(),
runTime,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
xferMove(poly2DMesh.points()),
xferMove(poly2DMesh.faces()),
xferMove(poly2DMesh.owner()),
xferMove(poly2DMesh.neighbour())
);
Info<< "Constructing patches." << endl;
List<polyPatch*> patches(poly2DMesh.patchNames().size());
label countPatches = 0;
forAll(patches, patchI)
{
if (poly2DMesh.patchSizes()[patchI] != 0)
{
patches[countPatches] = new polyPatch
(
poly2DMesh.patchNames()[patchI],
poly2DMesh.patchSizes()[patchI],
poly2DMesh.patchStarts()[patchI],
countPatches,
pMesh.boundaryMesh(),
word::null
);
countPatches++;
}
}
patches.setSize(countPatches);
pMesh.addPatches(patches);
if (extrude)
{
Info<< "Begin extruding the polyMesh:" << endl;
{
// Point generator
autoPtr<extrudeModel> model(extrudeModel::New(extrusionDict));
extrude2DMesh extruder(pMesh, extrusionDict, model());
extruder.addFrontBackPatches();
polyTopoChange meshMod(pMesh.boundaryMesh().size());
extruder.setRefinement(meshMod);
autoPtr<mapPolyMesh> morphMap = meshMod.changeMesh(pMesh, false);
pMesh.updateMesh(morphMap);
}
}
if (!overwrite)
{
runTime++;
}
else
{
pMesh.setInstance("constant");
}
pMesh.write();
Info<< "Finished extruding in = "
<< runTime.cpuTimeIncrement() << " s." << endl;
Info<< nl << "End\n" << endl;
return 0;
}
// ************************************************************************* //

208
applications/utilities/mesh/generation/cv2DMesh/cv2DMeshDict
View File

@ -1,208 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
root "";
case "";
instance "";
local "";
class dictionary;
object cv2DMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
geometry
{
laurence_clean_preciser.stl
{
name laurence_clean_preciser;
type closedTriSurfaceMesh;
//type triSurfaceMesh;
}
// refinementBox
// {
// type searchableBox;
// min (-0.5 0.35 -1000);
// max (-0.5 0.35 1000);
// }
// refinementSphere
// {
// type searchableSphere;
// centre (0.85 0.4 0.0);
// radius 0.01;
// }
}
surfaceConformation
{
locationInMesh (-2.8 0.7 0.5);
pointPairDistanceCoeff 0.005;
minEdgeLenCoeff 0.005;
maxNotchLenCoeff 0.003;
minNearPointDistCoeff 0.0025;
maxQuadAngle 125;
// Insert near-boundary point mirror or point-pairs
insertSurfaceNearestPointPairs yes;
// Mirror near-boundary points rather than insert point-pairs
mirrorPoints no;
// Insert point-pairs vor dual-cell vertices very near the surface
insertSurfaceNearPointPairs yes;
// Maximum number of iterations used in boundaryConform.
maxBoundaryConformingIter 5;
geometryToConformTo
{
laurence_clean_preciser
{
featureMethod extendedFeatureEdgeMesh;
extendedFeatureEdgeMesh "laurence_clean_preciser.extendedFeatureEdgeMesh";
}
}
additionalFeatures
{
}
// Choose if to randomise the initial grid created by insertGrid.
randomiseInitialGrid yes;
// Perturbation fraction, 1 = cell-size.
randomPerturbation 0.1;
}
motionControl
{
defaultCellSize 0.05;
// Assign a priority to all requests for cell sizes, the highest overrules.
defaultPriority 0;
cellSizeControlGeometry
{
laurence_clean_preciser
{
priority 1;
mode bothSides;
cellSizeFunction linearDistance;
linearDistanceCoeffs
{
distanceCellSize 0.05;
surfaceCellSize 0.01;
distance 0.5;
}
uniformCoeffs
{
cellSize 0.01;
}
}
// refinementBox
// {
// priority 1;
// mode outside;
// cellSizeFunction linearDistance;
// linearDistanceCoeffs
// {
// distanceCellSize 0.04;
// surfaceCellSize 0.005;
// distance 0.2;
// }
// }
// refinementSphere
// {
// priority 1;
// mode outside;
// cellSizeFunction linearDistance;
// linearDistanceCoeffs
// {
// distanceCellSize 0.04;
// surfaceCellSize 0.005;
// distance 0.2;
// }
// }
}
relaxationModel adaptiveLinear;
adaptiveLinearCoeffs
{
relaxationStart 0.5;
relaxationEnd 0.0;
}
objOutput no;
// Near-wall region where cells are aligned with the wall specified as a number
// of cell layers
nearWallAlignedDist 3;
}
shortEdgeFilter
{
// Factor to multiply the average of a face's edge lengths by.
// If an edge of that face is smaller than that value then delete it.
shortEdgeFilterFactor 0.2;
// Weighting for the lengths of edges that are attached to the boundaries.
// Used when calculating the length of an edge. Default 2.0.
edgeAttachedToBoundaryFactor 2.0;
}
extrusion
{
extrude on;
extrudeModel linearDirection;
//extrudeModel wedge;
patchInfo
{
//type empty;
//startFace
}
patchType empty;
//patchType wedge;
nLayers 1;
expansionRatio 1.0; //0.9;
linearDirectionCoeffs
{
direction (0 0 1);
thickness 0.1;
}
wedgeCoeffs
{
axisPt (0 0 0);
axis (1 0 0);
angle 10;
}
thickness 0.1;
}

135
applications/utilities/mesh/generation/cv2DMesh/indexedFace.H
View File

@ -1,135 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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/>.
Class
indexedFace
Description
An indexed form of CGAL::Triangulation_face_base_2<K> used to keep
track of the vertices in the triangulation.
\*---------------------------------------------------------------------------*/
#ifndef indexedFace_H
#define indexedFace_H
#include <CGAL/Triangulation_2.h>
#include "indexedVertex.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace CGAL
{
/*---------------------------------------------------------------------------*\
Class indexedFace Declaration
\*---------------------------------------------------------------------------*/
template<class Gt, class Fb=CGAL::Triangulation_face_base_2<Gt> >
class indexedFace
:
public Fb
{
// Private data
//- The index for this triangle face
// -1: triangle and changed and associated data needs updating
// >=0: index of triangles, set by external update algorithm
int index_;
public:
enum faceTypes
{
UNCHANGED = 0,
CHANGED = -1,
SAVE_CHANGED = -2
};
typedef typename Fb::Vertex_handle Vertex_handle;
typedef typename Fb::Face_handle Face_handle;
template < typename TDS2 >
struct Rebind_TDS
{
typedef typename Fb::template Rebind_TDS<TDS2>::Other Fb2;
typedef indexedFace<Gt, Fb2> Other;
};
// Constructors
inline indexedFace();
inline indexedFace
(
Vertex_handle v0,
Vertex_handle v1,
Vertex_handle v2
);
inline indexedFace
(
Vertex_handle v0,
Vertex_handle v1,
Vertex_handle v2,
Face_handle n0,
Face_handle n1,
Face_handle n2
);
// Member Functions
inline void set_vertex(int i, Vertex_handle v);
inline void set_vertices();
inline void set_vertices
(
Vertex_handle v0,
Vertex_handle v1,
Vertex_handle v2
);
inline int& faceIndex();
inline int faceIndex() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace CGAL
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "indexedFaceI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

110
applications/utilities/mesh/generation/cv2DMesh/indexedFaceI.H
View File

@ -1,110 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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/>.
\*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Gt, class Fb>
inline CGAL::indexedFace<Gt, Fb>::indexedFace()
:
Fb(),
index_(CHANGED)
{}
template<class Gt, class Fb>
inline CGAL::indexedFace<Gt, Fb>::indexedFace
(
Vertex_handle v0,
Vertex_handle v1,
Vertex_handle v2
)
:
Fb(v0, v1, v2),
index_(CHANGED)
{}
template<class Gt, class Fb>
inline CGAL::indexedFace<Gt, Fb>::indexedFace
(
Vertex_handle v0,
Vertex_handle v1,
Vertex_handle v2,
Face_handle n0,
Face_handle n1,
Face_handle n2
)
:
Fb(v0, v1, v2, n0, n1, n2),
index_(CHANGED)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Gt, class Fb>
inline void CGAL::indexedFace<Gt, Fb>::set_vertex(int i, Vertex_handle v)
{
index_ = CHANGED;
Fb::set_vertex(i, v);
}
template<class Gt, class Fb>
inline void CGAL::indexedFace<Gt, Fb>::set_vertices()
{
index_ = CHANGED;
Fb::set_vertices();
}
template<class Gt, class Fb>
inline void CGAL::indexedFace<Gt, Fb>::set_vertices
(
Vertex_handle v0,
Vertex_handle v1,
Vertex_handle v2
)
{
index_ = CHANGED;
Fb::set_vertices(v0, v1, v2);
}
template<class Gt, class Fb>
inline int& CGAL::indexedFace<Gt, Fb>::faceIndex()
{
return index_;
}
template<class Gt, class Fb>
inline int CGAL::indexedFace<Gt, Fb>::faceIndex() const
{
return index_;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

210
applications/utilities/mesh/generation/cv2DMesh/indexedVertex.H
View File

@ -1,210 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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/>.
Class
indexedVertex
Description
An indexed form of CGAL::Triangulation_vertex_base_2<K> used to keep
track of the vertices in the triangulation.
\*---------------------------------------------------------------------------*/
#ifndef indexedVertex_H
#define indexedVertex_H
#include <CGAL/Triangulation_2.h>
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace CGAL
{
// Forward declaration of friend functions and operators
template<class Gt, class Vb>
class indexedVertex;
template<class Gt, class Vb>
bool pointPair
(
const indexedVertex<Gt, Vb>& v0,
const indexedVertex<Gt, Vb>& v1
);
template<class Gt, class Vb>
bool boundaryTriangle
(
const indexedVertex<Gt, Vb>& v0,
const indexedVertex<Gt, Vb>& v1,
const indexedVertex<Gt, Vb>& v2
);
template<class Gt, class Vb>
bool outsideTriangle
(
const indexedVertex<Gt, Vb>& v0,
const indexedVertex<Gt, Vb>& v1,
const indexedVertex<Gt, Vb>& v2
);
/*---------------------------------------------------------------------------*\
Class indexedVertex Declaration
\*---------------------------------------------------------------------------*/
template<class Gt, class Vb=CGAL::Triangulation_vertex_base_2<Gt> >
class indexedVertex
:
public Vb
{
// Private data
//- The index for this triangle vertex
int index_;
//- Index of pair-point :
// NEAR_BOUNDARY_POINT : internal near boundary point.
// INTERNAL_POINT : internal point.
// FAR_POINT : far-point.
// >= 0 : part of point-pair. Index of other point.
// Lowest numbered is inside one (master).
int type_;
public:
enum pointTypes
{
NEAR_BOUNDARY_POINT = -4,
INTERNAL_POINT = -3,
MIRROR_POINT = -2,
FAR_POINT = -1
};
typedef typename Vb::Vertex_handle Vertex_handle;
typedef typename Vb::Face_handle Face_handle;
typedef typename Vb::Point Point;
template<typename TDS2>
struct Rebind_TDS
{
typedef typename Vb::template Rebind_TDS<TDS2>::Other Vb2;
typedef indexedVertex<Gt,Vb2> Other;
};
// Constructors
inline indexedVertex();
inline indexedVertex(const Point& p);
inline indexedVertex(const Point& p, const int index, const int& type);
inline indexedVertex(const Point& p, Face_handle f);
inline indexedVertex(Face_handle f);
// Member Functions
inline int& index();
inline int index() const;
inline int& type();
inline int type() const;
//- Is point a far-point
inline bool farPoint() const;
//- Is point internal, i.e. not on boundary
inline bool internalPoint() const;
//- Is point internal and near the boundary
inline bool nearBoundary() const;
//- Set the point to be near the boundary
inline void setNearBoundary();
//- Is point a mirror point
inline bool mirrorPoint() const;
//- Either master or slave of pointPair.
inline bool pairPoint() const;
//- Master of a pointPair is the lowest numbered one.
inline bool ppMaster() const;
//- Slave of a pointPair is the highest numbered one.
inline bool ppSlave() const;
//- Either original internal point or master of pointPair.
inline bool internalOrBoundaryPoint() const;
//- Is point near the boundary or part of the boundary definition
inline bool nearOrOnBoundary() const;
// Friend Functions
//- Do the two given vertices consitute a boundary point-pair
friend bool pointPair <Gt, Vb>
(
const indexedVertex<Gt, Vb>& v0,
const indexedVertex<Gt, Vb>& v1
);
//- Do the three given vertices consitute a boundary triangle
friend bool boundaryTriangle <Gt, Vb>
(
const indexedVertex<Gt, Vb>& v0,
const indexedVertex<Gt, Vb>& v1,
const indexedVertex<Gt, Vb>& v2
);
//- Do the three given vertices consitute an outside triangle
friend bool outsideTriangle <Gt, Vb>
(
const indexedVertex<Gt, Vb>& v0,
const indexedVertex<Gt, Vb>& v1,
const indexedVertex<Gt, Vb>& v2
);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace CGAL
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "indexedVertexI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

233
applications/utilities/mesh/generation/cv2DMesh/indexedVertexI.H
View File

@ -1,233 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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/>.
\*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Gt, class Vb>
inline CGAL::indexedVertex<Gt, Vb>::indexedVertex()
:
Vb(),
index_(INTERNAL_POINT),
type_(INTERNAL_POINT)
{}
template<class Gt, class Vb>
inline CGAL::indexedVertex<Gt, Vb>::indexedVertex(const Point& p)
:
Vb(p),
index_(INTERNAL_POINT),
type_(INTERNAL_POINT)
{}
template<class Gt, class Vb>
inline CGAL::indexedVertex<Gt, Vb>::indexedVertex
(
const Point& p,
const int index,
const int& type
)
:
Vb(p),
index_(index),
type_(type)
{}
template<class Gt, class Vb>
inline CGAL::indexedVertex<Gt, Vb>::indexedVertex(const Point& p, Face_handle f)
:
Vb(f, p),
index_(INTERNAL_POINT),
type_(INTERNAL_POINT)
{}
template<class Gt, class Vb>
inline CGAL::indexedVertex<Gt, Vb>::indexedVertex(Face_handle f)
:
Vb(f),
index_(INTERNAL_POINT),
type_(INTERNAL_POINT)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Gt, class Vb>
inline int& CGAL::indexedVertex<Gt, Vb>::index()
{
return index_;
}
template<class Gt, class Vb>
inline int CGAL::indexedVertex<Gt, Vb>::index() const
{
return index_;
}
template<class Gt, class Vb>
inline int& CGAL::indexedVertex<Gt, Vb>::type()
{
return type_;
}
template<class Gt, class Vb>
inline int CGAL::indexedVertex<Gt, Vb>::type() const
{
return type_;
}
template<class Gt, class Vb>
inline bool CGAL::indexedVertex<Gt, Vb>::farPoint() const
{
return type_ == FAR_POINT;
}
template<class Gt, class Vb>
inline bool CGAL::indexedVertex<Gt, Vb>::internalPoint() const
{
return type_ <= INTERNAL_POINT;
}
template<class Gt, class Vb>
inline bool CGAL::indexedVertex<Gt, Vb>::nearBoundary() const
{
return type_ == NEAR_BOUNDARY_POINT;
}
template<class Gt, class Vb>
inline void CGAL::indexedVertex<Gt, Vb>::setNearBoundary()
{
type_ = NEAR_BOUNDARY_POINT;
}
template<class Gt, class Vb>
inline bool CGAL::indexedVertex<Gt, Vb>::mirrorPoint() const
{
return type_ == MIRROR_POINT;
}
template<class Gt, class Vb>
inline bool CGAL::indexedVertex<Gt, Vb>::pairPoint() const
{
return type_ >= 0;
}
template<class Gt, class Vb>
inline bool CGAL::indexedVertex<Gt, Vb>::ppMaster() const
{
if (type_ > index_)
{
return true;
}
else
{
return false;
}
}
template<class Gt, class Vb>
inline bool CGAL::indexedVertex<Gt, Vb>::ppSlave() const
{
if (type_ >= 0 && type_ < index_)
{
return true;
}
else
{
return false;
}
}
template<class Gt, class Vb>
inline bool CGAL::indexedVertex<Gt, Vb>::internalOrBoundaryPoint() const
{
return internalPoint() || ppMaster();
}
template<class Gt, class Vb>
inline bool CGAL::indexedVertex<Gt, Vb>::nearOrOnBoundary() const
{
return pairPoint() || mirrorPoint() || nearBoundary();
}
// * * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * //
template<class Gt, class Vb>
bool CGAL::pointPair
(
const indexedVertex<Gt, Vb>& v0,
const indexedVertex<Gt, Vb>& v1
)
{
return v0.index_ == v1.type_ || v1.index_ == v0.type_;
}
template<class Gt, class Vb>
bool CGAL::boundaryTriangle
(
const indexedVertex<Gt, Vb>& v0,
const indexedVertex<Gt, Vb>& v1,
const indexedVertex<Gt, Vb>& v2
)
{
return (v0.pairPoint() && pointPair(v1, v2))
|| (v1.pairPoint() && pointPair(v2, v0))
|| (v2.pairPoint() && pointPair(v0, v1));
}
template<class Gt, class Vb>
bool CGAL::outsideTriangle
(
const indexedVertex<Gt, Vb>& v0,
const indexedVertex<Gt, Vb>& v1,
const indexedVertex<Gt, Vb>& v2
)
{
return (v0.farPoint() || v0.ppSlave())
|| (v1.farPoint() || v1.ppSlave())
|| (v2.farPoint() || v2.ppSlave());
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

323
applications/utilities/mesh/generation/cv2DMesh/insertBoundaryConformPointPairs.C
View File

@ -1,323 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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 "CV2D.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void Foam::CV2D::insertPointPair
(
Triangulation::Finite_vertices_iterator& vit,
const point2D& p,
const label trii,
const label hitSurface
)
{
if
(
!meshControls().mirrorPoints()
|| !insertMirrorPoint(toPoint2D(vit->point()), p)
)
{
pointIndexHit pHit
(
true,
toPoint3D(p),
trii
);
vectorField norm(1);
qSurf_.geometry()[hitSurface].getNormal
(
List<pointIndexHit>(1, pHit),
norm
);
insertPointPair
(
meshControls().ppDist(),
p,
toPoint2D(norm[0])
);
}
vit = Triangulation::Finite_vertices_iterator
(
CGAL::Filter_iterator
<
Triangulation::All_vertices_iterator,
Triangulation::Infinite_tester
>(finite_vertices_end(), vit.predicate(), vit.base())
);
}
bool Foam::CV2D::insertPointPairAtIntersection
(
Triangulation::Finite_vertices_iterator& vit,
const point2D& defVert,
const point2D vertices[],
const scalar maxProtSize2
)
{
bool found = false;
point2D interPoint;
label interTri = -1;
label interHitSurface = -1;
scalar interDist2 = 0;
Face_circulator fcStart = incident_faces(vit);
Face_circulator fc = fcStart;
label vi = 0;
do
{
if (!is_infinite(fc))
{
pointIndexHit pHit;
label hitSurface = -1;
qSurf_.findSurfaceNearestIntersection
(
toPoint3D(defVert),
toPoint3D(vertices[vi]),
pHit,
hitSurface
);
if (pHit.hit())
{
scalar dist2 =
magSqr(toPoint2D(pHit.hitPoint()) - vertices[vi]);
// Check the point is further away than the furthest so far
if (dist2 > interDist2)
{
scalar mps2 = maxProtSize2;
// If this is a boundary triangle reset the tolerance
// to avoid finding a hit point very close to a boundary
// vertex
if (boundaryTriangle(fc))
{
mps2 = meshControls().maxNotchLen2();
}
if (dist2 > mps2)
{
found = true;
interPoint = toPoint2D(pHit.hitPoint());
interTri = pHit.index();
interDist2 = dist2;
interHitSurface = hitSurface;
}
}
}
vi++;
}
} while (++fc != fcStart);
if (found)
{
insertPointPair(vit, interPoint, interTri, interHitSurface);
return true;
}
else
{
return false;
}
}
Foam::label Foam::CV2D::insertBoundaryConformPointPairs
(
const fileName& fName
)
{
label nIntersections = 0;
for
(
Triangulation::Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
vit++
)
{
// Consider only those points part of point-pairs or near boundary
if (!vit->nearOrOnBoundary())
{
continue;
}
// Counter-clockwise circulator
Face_circulator fcStart = incident_faces(vit);
Face_circulator fc = fcStart;
bool infinite = false;
bool changed = false;
do
{
if (is_infinite(fc))
{
infinite = true;
break;
}
else if (fc->faceIndex() < Fb::UNCHANGED)
{
changed = true;
break;
}
} while (++fc != fcStart);
// If the dual-cell is connected to the infinite point or none of the
// faces whose circumcentres it uses have changed ignore
if (infinite || !changed) continue;
fc = fcStart;
label nVerts = 0;
do
{
vertices[nVerts++] = toPoint2D(circumcenter(fc));
if (nVerts == maxNvert)
{
break;
}
} while (++fc != fcStart);
// Check if dual-cell has a large number of faces in which case
// assumed to be in the far-field and reject
if (nVerts == maxNvert) continue;
// Set n+1 vertex to the first vertex for easy circulating
vertices[nVerts] = vertices[0];
// Convert triangle vertex to OpenFOAM point
point2DFromPoint defVert = toPoint2D(vit->point());
scalar maxProtSize2 = meshControls().maxNotchLen2();
if (vit->internalOrBoundaryPoint())
{
// Calculate metrics of the dual-cell
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The perimeter of the dual-cell
scalar perimeter = 0;
// Twice the area of the dual-cell
scalar areaT2 = 0;
for (int vi=0; vi<nVerts; vi++)
{
vector2D edge(vertices[vi+1] - vertices[vi]);
perimeter += mag(edge);
vector2D otherEdge = defVert - vertices[vi];
areaT2 += mag(edge.x()*otherEdge.y() - edge.y()*otherEdge.x());
}
// If the dual-cell is very small reject refinement
if (areaT2 < meshControls().minEdgeLen2()) continue;
// Estimate the cell width
scalar cellWidth = areaT2/perimeter;
// Check dimensions of dual-cell
/*
// Quick rejection of dual-cell refinement based on it's perimeter
if (perimeter < 2*meshControls().minCellSize()) continue;
// Also check the area of the cell and reject refinement
// if it is less than that allowed
if (areaT2 < meshControls().minCellSize2()) continue;
// Estimate the cell width and reject refinement if it is less than
// that allowed
if (cellWidth < 0.5*meshControls().minEdgeLen()) continue;
*/
if
(
perimeter > 2*meshControls().minCellSize()
&& areaT2 > meshControls().minCellSize2()
&& cellWidth > 0.5*meshControls().minEdgeLen()
)
{
maxProtSize2 = 0.25*meshControls().maxNotchLen2();
}
}
if (insertPointPairAtIntersection(vit, defVert, vertices, maxProtSize2))
{
nIntersections++;
}
}
return nIntersections;
}
void Foam::CV2D::markNearBoundaryPoints()
{
label count = 0;
for
(
Triangulation::Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
vit++
)
{
if (vit->internalPoint())
{
point vert(toPoint3D(vit->point()));
pointIndexHit pHit;
label hitSurface = -1;
qSurf_.findSurfaceNearest
(
vert,
4*meshControls().minCellSize2(),
pHit,
hitSurface
);
if (pHit.hit())
{
vit->setNearBoundary();
++count;
}
}
}
Info<< count << " points marked as being near a boundary" << endl;
}
// ************************************************************************* //

394
applications/utilities/mesh/generation/cv2DMesh/insertFeaturePoints.C
View File

@ -1,394 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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 "CV2D.H"
#include "plane.H"
#include "unitConversion.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
bool Foam::CV2D::on2DLine(const point2D& p, const linePointRef& line)
{
const point2D& a = toPoint2D(line.start());
const point2D& b = toPoint2D(line.end());
if
(
p.x() < min(a.x(), b.x())
|| p.x() > max(a.x(), b.x())
|| p.y() < min(a.y(), b.y())
|| p.y() > max(a.y(), b.y())
)
{
return false;
}
return true;
}
void Foam::CV2D::insertFeaturePoints()
{
featurePoints_.clear();
label nVert = number_of_vertices();
const PtrList<extendedFeatureEdgeMesh>& feMeshes
(
qSurf_.features()
);
if (feMeshes.empty())
{
WarningIn("CV2D::insertFeaturePoints")
<< "Extended Feature Edge Mesh is empty so no feature points will "
<< "be found." << nl
<< " Use: featureMethod extendedFeatureEdgeMesh;" << nl
<< endl;
}
forAll(feMeshes, i)
{
const extendedFeatureEdgeMesh& feMesh(feMeshes[i]);
const edgeList& edges = feMesh.edges();
const pointField& points = feMesh.points();
if (debug)
{
label nConvex = feMesh.concaveStart() - feMesh.convexStart();
label nConcave = feMesh.mixedStart() - feMesh.concaveStart();
label nMixed = feMesh.nonFeatureStart() - feMesh.mixedStart();
label nExternal = feMesh.internalStart() - feMesh.externalStart();
label nInternal = feMesh.flatStart() - feMesh.internalStart();
label nFlat = feMesh.openStart() - feMesh.flatStart();
label nOpen = feMesh.multipleStart() - feMesh.openStart();
label nMultiple = edges.size() - feMesh.multipleStart();
Info<< "Inserting Feature Points:" << nl
<< " Convex points: " << nConvex << nl
<< " Concave points: " << nConcave << nl
<< " Mixed points: " << nMixed << nl
<< " External edges: " << nExternal << nl
<< " Internal edges: " << nInternal << nl
<< " Flat edges: " << nFlat << nl
<< " Open edges: " << nOpen << nl
<< " Multiple edges: " << nMultiple << endl;
}
// Args: (base point, normal)
// @todo allow user to input this
plane zPlane(vector(0, 0, z_), vector(0, 0, 1));
if (debug)
{
Info<< " plane: " << zPlane << " " << z_ << endl;
}
forAll(edges, edgeI)
{
const edge& e = feMesh.edges()[edgeI];
const point& ep0 = points[e.start()];
const point& ep1 = points[e.end()];
const linePointRef line(ep0, ep1);
scalar intersect = zPlane.lineIntersect(line);
point2D featPoint = toPoint2D(intersect * (ep1 - ep0) + ep0);
if (on2DLine(featPoint, line))
{
vector2DField fpn = toPoint2D(feMesh.edgeNormals(edgeI));
vector2D cornerNormal = sum(fpn);
cornerNormal /= mag(cornerNormal);
if (debug)
{
Info<< nl << " line: " << line << nl
<< " vec: " << line.vec() << nl
<< " featurePoint: " << featPoint << nl
<< " line length: " << line.mag() << nl
<< " intersect: " << intersect << endl;
}
if
(
feMesh.getEdgeStatus(edgeI)
== extendedFeatureEdgeMesh::EXTERNAL
)
{
// Convex Point
Foam::point2D internalPt =
featPoint - meshControls().ppDist()*cornerNormal;
if (debug)
{
Info<< "PREC: " << internalPt << nl
<< " : " << featPoint << nl
<< " : " << meshControls().ppDist() << nl
<< " : " << cornerNormal << endl;
}
featurePoints_.push_back
(
Vb
(
toPoint(internalPt),
nVert,
nVert + 1
)
);
label masterPtIndex = nVert++;
forAll(fpn, nI)
{
const vector n3D(fpn[nI][0], fpn[nI][1], 0.0);
plane planeN = plane(toPoint3D(featPoint), n3D);
Foam::point2D externalPt =
internalPt
+ (
2.0
* planeN.distance(toPoint3D(internalPt))
* fpn[nI]
);
featurePoints_.push_back
(
Vb
(
toPoint(externalPt),
nVert++,
masterPtIndex
)
);
if (debug)
{
Info<< " side point: " << externalPt << endl;
}
}
if (debug)
{
Info<< "Convex Point: " << featPoint << nl
<< " corner norm: " << cornerNormal << nl
<< " reference: " << internalPt << endl;
}
}
else if
(
feMesh.getEdgeStatus(edgeI)
== extendedFeatureEdgeMesh::INTERNAL
)
{
// Concave Point
Foam::point2D externalPt =
featPoint + meshControls().ppDist()*cornerNormal;
Foam::point2D refPt =
featPoint - meshControls().ppDist()*cornerNormal;
label slavePointIndex = 0;
scalar totalAngle =
radToDeg
(
constant::mathematical::pi
+ acos(mag(fpn[0] & fpn[1]))
);
// Number of quadrants the angle should be split into
int nQuads =
int(totalAngle/meshControls().maxQuadAngle()) + 1;
// The number of additional master points needed to
//obtain the required number of quadrants.
int nAddPoints = min(max(nQuads - 2, 0), 2);
// index of reflMaster
label reflectedMaster = nVert + 2 + nAddPoints;
if (debug)
{
Info<< "Concave Point: " << featPoint << nl
<< " corner norm: " << cornerNormal << nl
<< " external: " << externalPt << nl
<< " reference: " << refPt << nl
<< " angle: " << totalAngle << nl
<< " nQuads: " << nQuads << nl
<< " nAddPoints: " << nAddPoints << endl;
}
forAll(fpn, nI)
{
const vector n3D(fpn[nI][0], fpn[nI][1], 0.0);
plane planeN = plane(toPoint3D(featPoint), n3D);
Foam::point2D internalPt =
externalPt
- (
2.0
* planeN.distance(toPoint3D(externalPt))
* fpn[nI]
);
featurePoints_.push_back
(
Vb
(
toPoint(internalPt),
nVert,
reflectedMaster
)
);
slavePointIndex = nVert++;
if (debug)
{
Info<< "Internal Point: " << internalPt << endl;
}
}
if (nAddPoints == 1)
{
// One additional point is the reflection of the slave
// point, i.e., the original reference point
featurePoints_.push_back
(
Vb
(
toPoint(refPt),
nVert++,
reflectedMaster
)
);
if (debug)
{
Info<< "ref Point: " << refPt << endl;
}
}
else if (nAddPoints == 2)
{
point2D reflectedAa =
refPt - ((featPoint - externalPt) & fpn[1])*fpn[1];
featurePoints_.push_back
(
Vb
(
toPoint(reflectedAa),
nVert++,
reflectedMaster
)
);
point2D reflectedBb =
refPt - ((featPoint - externalPt) & fpn[0])*fpn[0];
featurePoints_.push_back
(
Vb
(
toPoint(reflectedBb),
nVert++,
reflectedMaster
)
);
if (debug)
{
Info<< "refA Point: " << reflectedAa << nl
<< "refb Point: " << reflectedBb << endl;
}
}
featurePoints_.push_back
(
Vb
(
toPoint(externalPt),
nVert++,
slavePointIndex
)
);
}
else
{
WarningIn("void Foam::CV2D::insertFeaturePoints()")
<< "Feature Edge " << edges[edgeI] << nl
<< " points(" << points[edges[edgeI].start()]
<< ", " << points[edges[edgeI].end()] << ")" << nl
<< " is not labelled as either concave or convex, it"
<< " is labelled as (#2 = flat): "
<< feMesh.getEdgeStatus(edgeI) << endl;
}
}
else
{
WarningIn("void Foam::CV2D::insertFeaturePoints()")
<< "Point " << featPoint << " is not on the line "
<< line << endl;
}
}
}
// Insert the feature points.
reinsertFeaturePoints();
if (meshControls().objOutput())
{
writePoints("feat_allPoints.obj", false);
writeFaces("feat_allFaces.obj", false);
writeFaces("feat_faces.obj", true);
writeTriangles("feat_triangles.obj", true);
}
}
void Foam::CV2D::reinsertFeaturePoints()
{
for
(
std::list<Vb>::iterator vit=featurePoints_.begin();
vit != featurePoints_.end();
++vit
)
{
insertPoint
(
toPoint2D(vit->point()),
vit->index(),
vit->type()
);
}
}
// ************************************************************************* //

114
applications/utilities/mesh/generation/cv2DMesh/insertSurfaceNearPointPairs.C
View File

@ -1,114 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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 "CV2D.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void Foam::CV2D::insertSurfaceNearPointPairs()
{
Info<< "insertSurfaceNearPointPairs: ";
label nNearPoints = 0;
for
(
Triangulation::Finite_edges_iterator eit = finite_edges_begin();
eit != finite_edges_end();
eit++
)
{
Vertex_handle v0h = eit->first->vertex(cw(eit->second));
Vertex_handle v1h = eit->first->vertex(ccw(eit->second));
if (v0h->ppMaster() && v1h->ppMaster())
{
point2DFromPoint v0(toPoint2D(v0h->point()));
point2DFromPoint v1(toPoint2D(v1h->point()));
// Check that the two triangle vertices are further apart than the
// minimum cell size
if (magSqr(v1 - v0) > meshControls().minCellSize2())
{
point2D e0(toPoint2D(circumcenter(eit->first)));
point2D e1
(
toPoint2D(circumcenter(eit->first->neighbor(eit->second)))
);
// Calculate the length^2 of the edge normal to the surface
scalar edgeLen2 = magSqr(e0 - e1);
if (edgeLen2 < meshControls().minNearPointDist2())
{
pointIndexHit pHit;
label hitSurface = -1;
qSurf_.findSurfaceNearest
(
toPoint3D(e0),
meshControls().minEdgeLen2(),
pHit,
hitSurface
);
if (pHit.hit())
{
vectorField norm(1);
qSurf_.geometry()[hitSurface].getNormal
(
List<pointIndexHit>(1, pHit),
norm
);
insertPointPair
(
meshControls().ppDist(),
toPoint2D(pHit.hitPoint()),
toPoint2D(norm[0])
);
nNearPoints++;
// Correct the edge iterator for the change in the
// number of edges following the point-pair insertion
eit = Finite_edges_iterator
(
finite_edges_end().base(),
eit.predicate(),
eit.base()
);
}
}
}
}
}
Info<< nNearPoints << " point-pairs inserted" << endl;
}
// ************************************************************************* //

244
applications/utilities/mesh/generation/cv2DMesh/insertSurfaceNearestPointPairs.C
View File

@ -1,244 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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 "CV2D.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
bool Foam::CV2D::dualCellSurfaceIntersection
(
const Triangulation::Finite_vertices_iterator& vit
) const
{
Triangulation::Edge_circulator ecStart = incident_edges(vit);
Triangulation::Edge_circulator ec = ecStart;
do
{
if (!is_infinite(ec))
{
point e0 = toPoint3D(circumcenter(ec->first));
// If edge end is outside bounding box then edge cuts boundary
if (!qSurf_.globalBounds().contains(e0))
{
return true;
}
point e1 = toPoint3D(circumcenter(ec->first->neighbor(ec->second)));
// If other edge end is ouside bounding box then edge cuts boundary
if (!qSurf_.globalBounds().contains(e1))
{
return true;
}
if (magSqr(e1 - e0) > meshControls().minEdgeLen2())
{
if (qSurf_.findSurfaceAnyIntersection(e0, e1))
{
return true;
}
}
}
} while (++ec != ecStart);
return false;
}
void Foam::CV2D::insertPointPairs
(
const DynamicList<point2D>& nearSurfacePoints,
const DynamicList<point2D>& surfacePoints,
const DynamicList<label>& surfaceTris,
const DynamicList<label>& surfaceHits,
const fileName fName
)
{
if (meshControls().mirrorPoints())
{
forAll(surfacePoints, ppi)
{
insertMirrorPoint
(
nearSurfacePoints[ppi],
surfacePoints[ppi]
);
}
}
else
{
forAll(surfacePoints, ppi)
{
pointIndexHit pHit
(
true,
toPoint3D(surfacePoints[ppi]),
surfaceTris[ppi]
);
vectorField norm(1);
qSurf_.geometry()[surfaceHits[ppi]].getNormal
(
List<pointIndexHit>(1, pHit),
norm
);
insertPointPair
(
meshControls().ppDist(),
surfacePoints[ppi],
toPoint2D(norm[0])
);
}
}
Info<< surfacePoints.size() << " point-pairs inserted" << endl;
if (meshControls().objOutput())
{
OFstream str(fName);
label vertI = 0;
forAll(surfacePoints, ppi)
{
meshTools::writeOBJ(str, toPoint3D(surfacePoints[ppi]));
vertI++;
}
Info<< "insertPointPairs: Written " << surfacePoints.size()
<< " inserted point-pair locations to file "
<< str.name() << endl;
}
}
void Foam::CV2D::insertSurfaceNearestPointPairs()
{
Info<< "insertSurfaceNearestPointPairs: ";
label nSurfacePointsEst =
min
(
number_of_vertices(),
size_t(10*sqrt(scalar(number_of_vertices())))
);
DynamicList<point2D> nearSurfacePoints(nSurfacePointsEst);
DynamicList<point2D> surfacePoints(nSurfacePointsEst);
DynamicList<label> surfaceTris(nSurfacePointsEst);
DynamicList<label> surfaceHits(nSurfacePointsEst);
// Local references to surface mesh addressing
// const pointField& localPoints = qSurf_.localPoints();
// const labelListList& edgeFaces = qSurf_.edgeFaces();
// const vectorField& faceNormals = qSurf_.faceNormals();
// const labelListList& faceEdges = qSurf_.faceEdges();
for
(
Triangulation::Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
vit++
)
{
if (vit->internalPoint())
{
point2DFromPoint vert(toPoint2D(vit->point()));
pointIndexHit pHit;
label hitSurface = -1;
qSurf_.findSurfaceNearest
(
toPoint3D(vert),
4*meshControls().minCellSize2(),
pHit,
hitSurface
);
if (pHit.hit())
{
vit->setNearBoundary();
// Reference to the nearest triangle
// const labelledTri& f = qSurf_[hitSurface];
// // Find where point is on triangle.
// // Note tolerance needed is relative one
// // (used in comparing normalized [0..1] triangle coordinates).
// label nearType, nearLabel;
// triPointRef
// (
// localPoints[f[0]],
// localPoints[f[1]],
// localPoints[f[2]]
// ).classify(pHit.hitPoint(), nearType, nearLabel);
// // If point is on a edge check if it is an internal feature
// bool internalFeatureEdge = false;
// if (nearType == triPointRef::EDGE)
// {
// label edgeI = faceEdges[hitSurface][nearLabel];
// const labelList& eFaces = edgeFaces[edgeI];
// if
// (
// eFaces.size() == 2
// && (faceNormals[eFaces[0]] & faceNormals[eFaces[1]])
// < -0.2
// )
// {
// internalFeatureEdge = true;
// }
// }
if (dualCellSurfaceIntersection(vit)) //&& !internalFeatureEdge)
{
nearSurfacePoints.append(vert);
surfacePoints.append(toPoint2D(pHit.hitPoint()));
surfaceTris.append(pHit.index());
surfaceHits.append(hitSurface);
}
}
}
}
insertPointPairs
(
nearSurfacePoints,
surfacePoints,
surfaceTris,
surfaceHits,
"surfaceNearestIntersections.obj"
);
}
// ************************************************************************* //

533
applications/utilities/mesh/generation/cv2DMesh/shortEdgeFilter2D.C
View File

@ -1,533 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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 "shortEdgeFilter2D.H"
namespace Foam
{
defineTypeNameAndDebug(shortEdgeFilter2D, 0);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::shortEdgeFilter2D::shortEdgeFilter2D
(
const Foam::CV2D& cv2Dmesh,
const dictionary& dict
)
:
cv2Dmesh_(cv2Dmesh),
shortEdgeFilterFactor_(readScalar(dict.lookup("shortEdgeFilterFactor"))),
edgeAttachedToBoundaryFactor_
(
dict.lookupOrDefault<scalar>("edgeAttachedToBoundaryFactor", 2.0)
),
patchNames_(wordList()),
patchSizes_(labelList()),
mapEdgesRegion_(),
indirectPatchEdge_()
{
point2DField points2D;
faceList faces;
cv2Dmesh.calcDual
(
points2D,
faces,
patchNames_,
patchSizes_,
mapEdgesRegion_,
indirectPatchEdge_
);
pointField points(points2D.size());
forAll(points, ip)
{
points[ip] = cv2Dmesh.toPoint3D(points2D[ip]);
}
if (debug)
{
OFstream str("indirectPatchEdges.obj");
label count = 0;
Info<< "Writing indirectPatchEdges to " << str.name() << endl;
forAllConstIter(EdgeMap<label>, indirectPatchEdge_, iter)
{
const edge& e = iter.key();
meshTools::writeOBJ
(
str,
points[e.start()],
points[e.end()],
count
);
}
}
points2D.clear();
ms_ = MeshedSurface<face>(xferMove(points), xferMove(faces));
Info<< "Meshed surface stats before edge filtering :" << endl;
ms_.writeStats(Info);
if (debug)
{
writeInfo(Info);
ms_.write("MeshedSurface_preFilter.obj");
}
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::shortEdgeFilter2D::~shortEdgeFilter2D()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
void
Foam::shortEdgeFilter2D::filter()
{
// These are global indices.
const pointField& points = ms_.points();
const edgeList& edges = ms_.edges();
const faceList& faces = ms_.faces();
const labelList& meshPoints = ms_.meshPoints();
const labelList& boundaryPoints = ms_.boundaryPoints();
label maxChain = 0;
label nPointsToRemove = 0;
labelList pointsToRemove(ms_.points().size(), -1);
// List of number of vertices in a face.
labelList newFaceVertexCount(faces.size(), -1);
forAll(faces, faceI)
{
newFaceVertexCount[faceI] = faces[faceI].size();
}
// Check if the point is a boundary point. Flag if it is so that
// it will not be deleted.
boolList boundaryPointFlags(points.size(), false);
// This has been removed, otherwise small edges on the boundary are not
// removed.
/* forAll(boundaryPointFlags, pointI)
{
forAll(boundaryPoints, bPoint)
{
if (meshPoints[boundaryPoints[bPoint]] == pointI)
{
boundaryPointFlags[pointI] = true;
}
}
}*/
// Check if an edge has a boundary point. It it does the edge length
// will be doubled when working out its length.
Info<< " Marking edges attached to boundaries." << endl;
boolList edgeAttachedToBoundary(edges.size(), false);
forAll(edges, edgeI)
{
const edge& e = edges[edgeI];
const label startVertex = e.start();
const label endVertex = e.end();
forAll(boundaryPoints, bPoint)
{
if
(
boundaryPoints[bPoint] == startVertex
|| boundaryPoints[bPoint] == endVertex
)
{
edgeAttachedToBoundary[edgeI] = true;
}
}
}
forAll(edges, edgeI)
{
const edge& e = edges[edgeI];
// get the vertices of that edge.
const label startVertex = e.start();
const label endVertex = e.end();
scalar edgeLength =
mag
(
points[meshPoints[startVertex]]
- points[meshPoints[endVertex]]
);
if (edgeAttachedToBoundary[edgeI])
{
edgeLength *= edgeAttachedToBoundaryFactor_;
}
scalar shortEdgeFilterValue = 0.0;
const labelList& psEdges = ms_.pointEdges()[startVertex];
const labelList& peEdges = ms_.pointEdges()[endVertex];
forAll(psEdges, psEdgeI)
{
const edge& psE = edges[psEdges[psEdgeI]];
if (edgeI != psEdges[psEdgeI])
{
shortEdgeFilterValue +=
mag
(
points[meshPoints[psE.start()]]
- points[meshPoints[psE.end()]]
);
}
}
forAll(peEdges, peEdgeI)
{
const edge& peE = edges[peEdges[peEdgeI]];
if (edgeI != peEdges[peEdgeI])
{
shortEdgeFilterValue +=
mag
(
points[meshPoints[peE.start()]]
- points[meshPoints[peE.end()]]
);
}
}
shortEdgeFilterValue *=
shortEdgeFilterFactor_
/(psEdges.size() + peEdges.size() - 2);
edge lookupInPatchEdge
(
meshPoints[startVertex],
meshPoints[endVertex]
);
if
(
edgeLength < shortEdgeFilterValue
|| indirectPatchEdge_.found(lookupInPatchEdge)
)
{
bool flagDegenerateFace = false;
const labelList& pFaces = ms_.pointFaces()[startVertex];
forAll(pFaces, pFaceI)
{
const face& f = ms_.localFaces()[pFaces[pFaceI]];
forAll(f, fp)
{
// If the edge is part of this face...
if (f[fp] == endVertex)
{
// If deleting vertex would create a triangle, don't!
if (newFaceVertexCount[pFaces[pFaceI]] < 4)
{
flagDegenerateFace = true;
}
else
{
newFaceVertexCount[pFaces[pFaceI]]--;
}
}
// If the edge is not part of this face...
else
{
// Deleting vertex of a triangle...
if (newFaceVertexCount[pFaces[pFaceI]] < 3)
{
flagDegenerateFace = true;
}
}
}
}
// This if statement determines whether a point should be deleted.
if
(
pointsToRemove[meshPoints[startVertex]] == -1
&& pointsToRemove[meshPoints[endVertex]] == -1
&& !boundaryPointFlags[meshPoints[startVertex]]
&& !flagDegenerateFace
)
{
pointsToRemove[meshPoints[startVertex]] = meshPoints[endVertex];
++nPointsToRemove;
}
}
}
label totalNewPoints = points.size() - nPointsToRemove;
pointField newPoints(totalNewPoints, vector::zero);
labelList newPointNumbers(points.size(), -1);
label numberRemoved = 0;
forAll(points, pointI)
{
// If the point is NOT going to be removed.
if (pointsToRemove[pointI] == -1)
{
newPoints[pointI - numberRemoved] = points[pointI];
newPointNumbers[pointI] = pointI - numberRemoved;
}
else
{
numberRemoved++;
}
}
// Need a new faceList
faceList newFaces(faces.size());
label newFaceI = 0;
labelList newFace;
label newFaceSize = 0;
// Now need to iterate over the faces and remove points. Global index.
forAll(faces, faceI)
{
const face& f = faces[faceI];
newFace.clear();
newFace.setSize(f.size());
newFaceSize = 0;
forAll(f, fp)
{
label pointI = f[fp];
// If not removing the point, then add it to the new face.
if (pointsToRemove[pointI] == -1)
{
newFace[newFaceSize++] = newPointNumbers[pointI];
}
else
{
label newPointI = pointsToRemove[pointI];
// Replace deleted point with point that it is being
// collapsed to.
if
(
f.nextLabel(fp) != newPointI
&& f.prevLabel(fp) != newPointI
)
{
label pChain = newPointI;
label totalChain = 0;
for (label nChain = 0; nChain <= totalChain; ++nChain)
{
if (newPointNumbers[pChain] != -1)
{
newFace[newFaceSize++] = newPointNumbers[pChain];
newPointNumbers[pointI] = newPointNumbers[pChain];
maxChain = max(totalChain, maxChain);
}
else
{
WarningIn("shortEdgeFilter")
<< "Point " << pChain
<< " marked for deletion as well as point "
<< pointI << nl
<< " Incrementing maxChain by 1 from "
<< totalChain << " to " << totalChain + 1
<< endl;
totalChain++;
}
pChain = pointsToRemove[pChain];
}
}
else
{
if (newPointNumbers[newPointI] != -1)
{
newPointNumbers[pointI] = newPointNumbers[newPointI];
}
}
}
}
newFace.setSize(newFaceSize);
if (newFace.size() > 2)
{
newFaces[newFaceI++] = face(newFace);
}
else
{
FatalErrorIn("shortEdgeFilter")
<< "Only " << newFace.size() << " in face " << faceI
<< exit(FatalError);
}
}
newFaces.setSize(newFaceI);
MeshedSurface<face> fMesh
(
xferMove(newPoints),
xferMove(newFaces),
xferCopy(List<surfZone>())
);
const Map<int>& fMeshPointMap = fMesh.meshPointMap();
// Reset patchSizes_
patchSizes_.clear();
patchSizes_.setSize(patchNames_.size(), 0);
label equalEdges = 0;
label notFound = 0;
label matches = 0;
label negativeLabels = 0;
forAll(newPointNumbers, pointI)
{
if (newPointNumbers[pointI] == -1)
{
WarningIn("shortEdgeFilter")
<< pointI << " will be deleted and " << newPointNumbers[pointI]
<< ", so it will not be replaced. "
<< "This will cause edges to be deleted." << endl;
}
}
// Create new EdgeMap.
Info<< "Creating new EdgeMap." << endl;
EdgeMap<label> newMapEdgesRegion(mapEdgesRegion_.size());
for
(
label bEdgeI = ms_.nInternalEdges();
bEdgeI < edges.size();
++bEdgeI
)
{
label p1 = meshPoints[edges[bEdgeI][0]];
label p2 = meshPoints[edges[bEdgeI][1]];
edge e(p1, p2);
if (mapEdgesRegion_.found(e))
{
if
(
newPointNumbers[p1] != -1
&& newPointNumbers[p2] != -1
)
{
if (newPointNumbers[p1] != newPointNumbers[p2])
{
label region = mapEdgesRegion_.find(e)();
newMapEdgesRegion.insert
(
edge
(
fMeshPointMap[newPointNumbers[p1]],
fMeshPointMap[newPointNumbers[p2]]
),
region
);
patchSizes_[region]++;
matches++;
}
else
{
equalEdges++;
}
}
else
{
negativeLabels++;
}
}
else
{
notFound++;
}
}
if (debug)
{
Info<< "EdgeMapping :" << nl
<< " Matches : " << matches << nl
<< " Equal : " << equalEdges << nl
<< " Negative : " << negativeLabels << nl
<< " Not Found: " << notFound << endl;
}
mapEdgesRegion_.transfer(newMapEdgesRegion);
ms_.transfer(fMesh);
Info<< " Maximum number of chained collapses = " << maxChain << endl;
if (debug)
{
writeInfo(Info);
}
}
void Foam::shortEdgeFilter2D::writeInfo(Ostream& os)
{
os << "Short Edge Filtering Information:" << nl
<< " shortEdgeFilterFactor: " << shortEdgeFilterFactor_ << nl
<< " edgeAttachedToBoundaryFactor: " << edgeAttachedToBoundaryFactor_
<< endl;
forAll(patchNames_, patchI)
{
os << " Patch " << patchNames_[patchI]
<< ", size " << patchSizes_[patchI] << endl;
}
os << " There are " << mapEdgesRegion_.size()
<< " boundary edges." << endl;
os << " Mesh Info:" << nl
<< " Points: " << ms_.nPoints() << nl
<< " Faces: " << ms_.size() << nl
<< " Edges: " << ms_.nEdges() << nl
<< " Internal: " << ms_.nInternalEdges() << nl
<< " External: " << ms_.nEdges() - ms_.nInternalEdges()
<< endl;
}
// ************************************************************************* //

133
applications/utilities/mesh/generation/cv2DMesh/shortEdgeFilter2D.H
View File

@ -1,133 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 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/>.
Class
Foam::shortEdgeFilter2D
Description
This class filters short edges generated by the CV2D mesher.
SourceFiles
shortEdgeFilter2D.C
\*---------------------------------------------------------------------------*/
#ifndef shortEdgeFilter2D_H
#define shortEdgeFilter2D_H
#include "MeshedSurfaces.H"
#include "CV2D.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class shortEdgeFilter2D Declaration
\*---------------------------------------------------------------------------*/
class shortEdgeFilter2D
{
// Private data
const CV2D& cv2Dmesh_;
MeshedSurface<face> ms_;
const scalar shortEdgeFilterFactor_;
const scalar edgeAttachedToBoundaryFactor_;
wordList patchNames_;
labelList patchSizes_;
EdgeMap<label> mapEdgesRegion_;
EdgeMap<label> indirectPatchEdge_;
// Private Member Functions
//- Disallow default bitwise copy construct
shortEdgeFilter2D(const shortEdgeFilter2D&);
//- Disallow default bitwise assignment
void operator=(const shortEdgeFilter2D&);
public:
//- Runtime type information
ClassName("shortEdgeFilter2D");
// Constructors
shortEdgeFilter2D(const CV2D& cv2Dmesh, const dictionary& dict);
//- Destructor
~shortEdgeFilter2D();
// Access Functions
const wordList& patchNames() const
{
return patchNames_;
}
const labelList& patchSizes() const
{
return patchSizes_;
}
const EdgeMap<label>& mapEdgesRegion() const
{
return mapEdgesRegion_;
}
const MeshedSurface<face>& fMesh() const
{
return ms_;
}
// Member Functions
void filter();
void writeInfo(Ostream& os);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

10
applications/utilities/mesh/generation/cvMesh/Allwclean
View File

@ -1,10 +0,0 @@
#!/bin/sh
cd ${0%/*} || exit 1 # run from this directory
set -x
wclean libso conformalVoronoiMesh
wclean
wclean cvMeshSurfaceSimplify
wclean cvMeshBackgroundMesh
# ----------------------------------------------------------------- end-of-file

11
applications/utilities/mesh/generation/cvMesh/Allwmake
View File

@ -1,11 +0,0 @@
#!/bin/sh
cd ${0%/*} || exit 1 # run from this directory
set -x
wmake libso conformalVoronoiMesh
wmake
#wmake cvMeshBackgroundMesh
(cd cvMeshSurfaceSimplify && ./Allwmake)
wmake cellSizeAndAlignmentGrid
# ----------------------------------------------------------------- end-of-file

3
applications/utilities/mesh/generation/cvMesh/Make/files
View File

@ -1,3 +0,0 @@
cvMesh.C
EXE = $(FOAM_APPBIN)/cvMesh

38
applications/utilities/mesh/generation/cvMesh/Make/options
View File

@ -1,38 +0,0 @@
EXE_DEBUG = -DFULLDEBUG -g -O0
EXE_FROUNDING_MATH = -frounding-math
EXE_NDEBUG = -DNDEBUG
CGAL_EXACT = /*-DCGAL_DONT_USE_LAZY_KERNEL*/
CGAL_INEXACT = -DCGAL_INEXACT
include $(GENERAL_RULES)/CGAL
EXE_INC = \
${EXE_FROUNDING_MATH} \
${EXE_NDEBUG} \
${CGAL_INEXACT} \
${CGAL_INC} \
-IconformalVoronoiMesh/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
-I$(LIB_SRC)/edgeMesh/lnInclude \
-I$(LIB_SRC)/fileFormats/lnInclude \
-I$(LIB_SRC)/dynamicMesh/lnInclude \
-I$(LIB_SRC)/triSurface/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude \
-IvectorTools
EXE_LIBS = \
$(CGAL_LIBS) \
-lboost_thread \
-lmpfr \
-lconformalVoronoiMesh \
-lmeshTools \
-ldecompositionMethods \
-L$(FOAM_LIBBIN)/dummy -lptscotchDecomp \
-ledgeMesh \
-lfileFormats \
-ltriSurface \
-ldynamicMesh \
-lsampling

2
applications/utilities/mesh/generation/cvMesh/cellSizeAndAlignmentGrid/Make/files
View File

@ -1,2 +0,0 @@
cellSizeAndAlignmentGrid.C
EXE = $(FOAM_USER_APPBIN)/cellSizeAndAlignmentGrid

40
applications/utilities/mesh/generation/cvMesh/cellSizeAndAlignmentGrid/Make/options
View File

@ -1,40 +0,0 @@
EXE_DEBUG = -DFULLDEBUG -g -O0
EXE_FROUNDING_MATH = -frounding-math
EXE_NDEBUG = -DNDEBUG
CGAL_EXACT = /*-DCGAL_DONT_USE_LAZY_KERNEL*/
CGAL_INEXACT = -DCGAL_INEXACT
include $(GENERAL_RULES)/CGAL
EXE_INC = \
${EXE_FROUNDING_MATH} \
${EXE_NDEBUG} \
${CGAL_INEXACT} \
${CGAL_INC} \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/dynamicMesh/lnInclude \
-I$(LIB_SRC)/triSurface/lnInclude \
-I$(LIB_SRC)/fileFormats/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
-I$(LIB_SRC)/edgeMesh/lnInclude \
-I$(HOME)/OpenFOAM/OpenFOAM-dev/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/lnInclude \
-I$(HOME)/OpenFOAM/OpenFOAM-dev/applications/utilities/mesh/generation/cvMesh/vectorTools
EXE_LIBS = \
$(CGAL_LIBS) \
-lmpfr \
-lboost_thread \
-lconformalVoronoiMesh \
-lfiniteVolume \
-lmeshTools \
-ldecompositionMethods \
-L$(FOAM_LIBBIN)/dummy -lptscotchDecomp \
-ledgeMesh \
-ltriSurface \
-ldynamicMesh \
-lsampling \
-lfileFormats

716
applications/utilities/mesh/generation/cvMesh/cellSizeAndAlignmentGrid/cellSizeAndAlignmentGrid.C
View File

@ -1,716 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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/>.
Application
Test-distributedDelaunayMesh
Description
\*---------------------------------------------------------------------------*/
#include "CGALTriangulation3DKernel.H"
#include "indexedVertex.H"
#include "indexedCell.H"
#include "argList.H"
#include "Time.H"
#include "DistributedDelaunayMesh.H"
#include "backgroundMeshDecomposition.H"
#include "searchableSurfaces.H"
#include "conformationSurfaces.H"
#include "PrintTable.H"
#include "Random.H"
#include "boundBox.H"
#include "point.H"
#include "cellShapeControlMesh.H"
#include "triadField.H"
#include "scalarIOField.H"
#include "pointIOField.H"
#include "triadIOField.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
template <class Triangulation, class Type>
Foam::tmp<Foam::Field<Type> > filterFarPoints
(
const Triangulation& mesh,
const Field<Type>& field
)
{
tmp<Field<Type> > tNewField(new Field<Type>(field.size()));
Field<Type>& newField = tNewField();
label added = 0;
label count = 0;
for
(
typename Triangulation::Finite_vertices_iterator vit =
mesh.finite_vertices_begin();
vit != mesh.finite_vertices_end();
++vit
)
{
if (vit->real())
{
newField[added++] = field[count];
}
count++;
}
newField.resize(added);
return tNewField;
}
template <class T>
autoPtr<mapDistribute> buildMap
(
const T& mesh,
labelListList& pointPoints
)
{
pointPoints.setSize(mesh.vertexCount());
globalIndex globalIndexing(mesh.vertexCount());
for
(
typename T::Finite_vertices_iterator vit = mesh.finite_vertices_begin();
vit != mesh.finite_vertices_end();
++vit
)
{
if (!vit->real())
{
continue;
}
std::list<typename T::Vertex_handle> adjVerts;
mesh.finite_adjacent_vertices(vit, std::back_inserter(adjVerts));
DynamicList<label> indices(adjVerts.size());
for
(
typename std::list<typename T::Vertex_handle>::const_iterator
adjVertI = adjVerts.begin();
adjVertI != adjVerts.end();
++adjVertI
)
{
typename T::Vertex_handle vh = *adjVertI;
if (!vh->farPoint())
{
indices.append
(
globalIndexing.toGlobal(vh->procIndex(), vh->index())
);
}
}
pointPoints[vit->index()].transfer(indices);
}
List<Map<label> > compactMap;
return autoPtr<mapDistribute>
(
new mapDistribute
(
globalIndexing,
pointPoints,
compactMap
)
);
}
template <class T>
Foam::tmp<Foam::triadField> buildAlignmentField(const T& mesh)
{
tmp<triadField> tAlignments
(
new triadField(mesh.vertexCount(), triad::unset)
);
triadField& alignments = tAlignments();
for
(
typename T::Finite_vertices_iterator vit = mesh.finite_vertices_begin();
vit != mesh.finite_vertices_end();
++vit
)
{
if (!vit->real())
{
continue;
}
alignments[vit->index()] = vit->alignment();
}
return tAlignments;
}
template <class T>
Foam::tmp<Foam::pointField> buildPointField(const T& mesh)
{
tmp<pointField> tPoints
(
new pointField(mesh.vertexCount(), point(GREAT, GREAT, GREAT))
);
pointField& points = tPoints();
for
(
typename T::Finite_vertices_iterator vit = mesh.finite_vertices_begin();
vit != mesh.finite_vertices_end();
++vit
)
{
if (!vit->real())
{
continue;
}
points[vit->index()] = topoint(vit->point());
}
return tPoints;
}
void refine
(
cellShapeControlMesh& mesh,
const conformationSurfaces& geometryToConformTo,
const label maxRefinementIterations,
const scalar defaultCellSize
)
{
for (label iter = 0; iter < maxRefinementIterations; ++iter)
{
DynamicList<point> ptsToInsert;
for
(
CellSizeDelaunay::Finite_cells_iterator cit =
mesh.finite_cells_begin();
cit != mesh.finite_cells_end();
++cit
)
{
const point newPoint =
topoint
(
CGAL::centroid
(
cit->vertex(0)->point(),
cit->vertex(1)->point(),
cit->vertex(2)->point(),
cit->vertex(3)->point()
)
);
if (geometryToConformTo.inside(newPoint))
{
ptsToInsert.append(newPoint);
}
}
Info<< " Adding " << returnReduce(ptsToInsert.size(), sumOp<label>())
<< endl;
forAll(ptsToInsert, ptI)
{
mesh.insert
(
ptsToInsert[ptI],
defaultCellSize,
triad::unset,
Vb::vtInternal
);
}
}
}
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
label maxRefinementIterations = 2;
label maxSmoothingIterations = 200;
scalar minResidual = 0;
scalar defaultCellSize = 0.001;
scalar nearFeatDistSqrCoeff = 1e-8;
// Need to decouple vertex and cell type from this class?
// Vertex must have:
// + index
// + procIndex
// - type should be optional
cellShapeControlMesh mesh(runTime);
IOdictionary cvMeshDict
(
IOobject
(
"cvMeshDict",
runTime.system(),
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
);
Random rndGen(64293*Pstream::myProcNo());
searchableSurfaces allGeometry
(
IOobject
(
"cvSearchableSurfaces",
runTime.constant(),
"triSurface",
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
cvMeshDict.subDict("geometry")
);
conformationSurfaces geometryToConformTo
(
runTime,
rndGen,
allGeometry,
cvMeshDict.subDict("surfaceConformation")
);
autoPtr<backgroundMeshDecomposition> bMesh;
if (Pstream::parRun())
{
bMesh.set
(
new backgroundMeshDecomposition
(
runTime,
rndGen,
geometryToConformTo,
cvMeshDict.subDict("backgroundMeshDecomposition")
)
);
}
// Nice to have IO for the delaunay mesh
// IO depend on vertex type.
//
// Define a delaunay mesh as:
// + list of points of the triangulation
// + optionally a list of cells
Info<< nl << "Loop over surfaces" << endl;
forAll(geometryToConformTo.surfaces(), sI)
{
const label surfI = geometryToConformTo.surfaces()[sI];
const searchableSurface& surface =
geometryToConformTo.geometry()[surfI];
Info<< nl << "Inserting points from surface " << surface.name()
<< " (" << surface.type() << ")" << endl;
const tmp<pointField> tpoints(surface.points());
const pointField& points = tpoints();
Info<< " Number of points = " << points.size() << endl;
forAll(points, pI)
{
// Is the point in the extendedFeatureEdgeMesh? If so get the
// point normal, otherwise get the surface normal from
// searchableSurface
pointIndexHit info;
label infoFeature;
geometryToConformTo.findFeaturePointNearest
(
points[pI],
nearFeatDistSqrCoeff,
info,
infoFeature
);
autoPtr<triad> pointAlignment;
if (info.hit())
{
const extendedFeatureEdgeMesh& features =
geometryToConformTo.features()[infoFeature];
vectorField norms = features.featurePointNormals(info.index());
// Create a triad from these norms.
pointAlignment.set(new triad());
forAll(norms, nI)
{
pointAlignment() += norms[nI];
}
pointAlignment().normalize();
pointAlignment().orthogonalize();
}
else
{
geometryToConformTo.findEdgeNearest
(
points[pI],
nearFeatDistSqrCoeff,
info,
infoFeature
);
if (info.hit())
{
const extendedFeatureEdgeMesh& features =
geometryToConformTo.features()[infoFeature];
vectorField norms = features.edgeNormals(info.index());
// Create a triad from these norms.
pointAlignment.set(new triad());
forAll(norms, nI)
{
pointAlignment() += norms[nI];
}
pointAlignment().normalize();
pointAlignment().orthogonalize();
}
else
{
pointField ptField(1, points[pI]);
scalarField distField(1, nearFeatDistSqrCoeff);
List<pointIndexHit> infoList(1, pointIndexHit());
surface.findNearest(ptField, distField, infoList);
vectorField normals(1);
surface.getNormal(infoList, normals);
pointAlignment.set(new triad(normals[0]));
}
}
if (Pstream::parRun())
{
if (bMesh().positionOnThisProcessor(points[pI]))
{
CellSizeDelaunay::Vertex_handle vh = mesh.insert
(
points[pI],
defaultCellSize,
pointAlignment(),
Vb::vtInternalNearBoundary
);
}
}
else
{
CellSizeDelaunay::Vertex_handle vh = mesh.insert
(
points[pI],
defaultCellSize,
pointAlignment(),
Vb::vtInternalNearBoundary
);
}
}
}
// Refine the mesh
refine
(
mesh,
geometryToConformTo,
maxRefinementIterations,
defaultCellSize
);
if (Pstream::parRun())
{
mesh.distribute(bMesh);
}
labelListList pointPoints;
autoPtr<mapDistribute> meshDistributor = buildMap(mesh, pointPoints);
triadField alignments(buildAlignmentField(mesh));
pointField points(buildPointField(mesh));
mesh.printInfo(Info);
// Setup the sizes and alignments on each point
triadField fixedAlignments(mesh.vertexCount(), triad::unset);
for
(
CellSizeDelaunay::Finite_vertices_iterator vit =
mesh.finite_vertices_begin();
vit != mesh.finite_vertices_end();
++vit
)
{
if (vit->nearBoundary())
{
fixedAlignments[vit->index()] = vit->alignment();
}
}
Info<< nl << "Smoothing alignments" << endl;
for (label iter = 0; iter < maxSmoothingIterations; iter++)
{
Info<< "Iteration " << iter;
meshDistributor().distribute(points);
meshDistributor().distribute(alignments);
scalar residual = 0;
triadField triadAv(alignments.size(), triad::unset);
forAll(pointPoints, pI)
{
const labelList& pPoints = pointPoints[pI];
if (pPoints.empty())
{
continue;
}
const triad& oldTriad = alignments[pI];
triad& newTriad = triadAv[pI];
// Enforce the boundary conditions
const triad& fixedAlignment = fixedAlignments[pI];
forAll(pPoints, adjPointI)
{
const label adjPointIndex = pPoints[adjPointI];
scalar dist = mag(points[pI] - points[adjPointIndex]);
// dist = max(dist, SMALL);
triad tmpTriad = alignments[adjPointIndex];
for (direction dir = 0; dir < 3; dir++)
{
if (tmpTriad.set(dir))
{
tmpTriad[dir] *= (1.0/dist);
}
}
newTriad += tmpTriad;
}
newTriad.normalize();
newTriad.orthogonalize();
// newTriad = newTriad.sortxyz();
label nFixed = 0;
forAll(fixedAlignment, dirI)
{
if (fixedAlignment.set(dirI))
{
nFixed++;
}
}
if (nFixed == 1)
{
forAll(fixedAlignment, dirI)
{
if (fixedAlignment.set(dirI))
{
newTriad.align(fixedAlignment[dirI]);
}
}
}
else if (nFixed == 2)
{
forAll(fixedAlignment, dirI)
{
if (fixedAlignment.set(dirI))
{
newTriad[dirI] = fixedAlignment[dirI];
}
else
{
newTriad[dirI] = triad::unset[dirI];
}
}
newTriad.orthogonalize();
}
else if (nFixed == 3)
{
forAll(fixedAlignment, dirI)
{
if (fixedAlignment.set(dirI))
{
newTriad[dirI] = fixedAlignment[dirI];
}
}
}
for (direction dir = 0; dir < 3; ++dir)
{
if
(
newTriad.set(dir)
&& oldTriad.set(dir)
//&& !fixedAlignment.set(dir)
)
{
scalar dotProd = (oldTriad[dir] & newTriad[dir]);
scalar diff = mag(dotProd) - 1.0;
residual += mag(diff);
}
}
}
forAll(alignments, pI)
{
alignments[pI] = triadAv[pI].sortxyz();
}
reduce(residual, sumOp<scalar>());
Info<< ", Residual = " << residual << endl;
if (residual <= minResidual)
{
break;
}
}
// Write alignments to a .obj file
OFstream str(runTime.path()/"alignments.obj");
forAll(alignments, pI)
{
const triad& tri = alignments[pI];
if (tri.set())
{
forAll(tri, dirI)
{
meshTools::writeOBJ(str, points[pI], tri[dirI] + points[pI]);
}
}
}
// Remove the far points
pointIOField pointsIO
(
IOobject
(
"points",
runTime.constant(),
runTime,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
filterFarPoints(mesh, points)
);
scalarField sizes(points.size(), defaultCellSize);
scalarIOField sizesIO
(
IOobject
(
"sizes",
runTime.constant(),
runTime,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
filterFarPoints(mesh, sizes)
);
triadIOField alignmentsIO
(
IOobject
(
"alignments",
runTime.constant(),
runTime,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
filterFarPoints(mesh, alignments)
);
pointsIO.write();
sizesIO.write();
alignmentsIO.write();
Info<< nl << "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
Info<< "\nEnd\n" << endl;
return 0;
}
// ************************************************************************* //

73
applications/utilities/mesh/generation/cvMesh/checkCvMesh/meshQualityDict
View File

@ -1,73 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
root "";
case "";
instance "";
local "";
class dictionary;
object meshQualityDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
//- Maximum non-orthogonality allowed. Set to 180 to disable.
maxNonOrtho 65;
//- Max skewness allowed. Set to <0 to disable.
maxBoundarySkewness 50;
maxInternalSkewness 10;
//- Max concaveness allowed. Is angle (in degrees) below which concavity
// is allowed. 0 is straight face, <0 would be convex face.
// Set to 180 to disable.
maxConcave 80;
//- Minimum quality of the tet formed by the face-centre
// and variable base point minimum decomposition triangles and
// the cell centre. This has to be a positive number for tracking
// to work. Set to very negative number (e.g. -1E30) to
// disable.
// <0 = inside out tet,
// 0 = flat tet
// 1 = regular tet
minTetQuality 1e-30;
//- Minimum pyramid volume. Is absolute volume of cell pyramid.
// Set to a sensible fraction of the smallest cell volume expected.
// Set to very negative number (e.g. -1E30) to disable.
minVol 1e-20;
//- Minimum face area. Set to <0 to disable.
minArea -1;
//- Minimum face twist. Set to <-1 to disable. dot product of face normal
//- and face centre triangles normal
minTwist 0.001;
//- minimum normalised cell determinant
//- 1 = hex, <= 0 = folded or flattened illegal cell
minDeterminant 0.001;
//- minFaceWeight (0 -> 0.5)
minFaceWeight 0.02;
//- minVolRatio (0 -> 1)
minVolRatio 0.01;
//must be >0 for Fluent compatibility
minTriangleTwist -1;
// ************************************************************************* //

233
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMesh.C
View File

@ -1,233 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "DelaunayMesh.H"
#include "labelPair.H"
#include "PrintTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
// * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Triangulation>
Foam::DelaunayMesh<Triangulation>::DelaunayMesh()
:
Triangulation(),
vertexCount_(0),
cellCount_(0)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Triangulation>
Foam::DelaunayMesh<Triangulation>::~DelaunayMesh()
{}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class Triangulation>
void Foam::DelaunayMesh<Triangulation>::reset()
{
Info<< "Clearing triangulation" << endl;
this->clear();
resetVertexCount();
resetCellCount();
}
template<class Triangulation>
void Foam::DelaunayMesh<Triangulation>::insertPoints(const List<Vb>& vertices)
{
rangeInsertWithInfo
(
vertices.begin(),
vertices.end(),
true
);
}
template<class Triangulation>
bool Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_x_3::
operator()
(
const Point_3& p,
const Point_3& q
) const
{
return typename Gt::Less_x_3()(*(p.first), *(q.first));
}
template<class Triangulation>
bool Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_y_3::
operator()
(
const Point_3& p,
const Point_3& q
) const
{
return typename Gt::Less_y_3()(*(p.first), *(q.first));
}
template<class Triangulation>
bool Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_z_3::
operator()
(
const Point_3& p,
const Point_3& q
) const
{
return typename Gt::Less_z_3()(*(p.first), *(q.first));
}
template<class Triangulation>
typename Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_x_3
Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::less_x_3_object()
const
{
return Less_x_3();
}
template<class Triangulation>
typename Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_y_3
Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::less_y_3_object()
const
{
return Less_y_3();
}
template<class Triangulation>
typename Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_z_3
Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::less_z_3_object()
const
{
return Less_z_3();
}
template<class Triangulation>
template<class PointIterator>
void Foam::DelaunayMesh<Triangulation>::rangeInsertWithInfo
(
PointIterator begin,
PointIterator end,
bool printErrors
)
{
typedef DynamicList
<
std::pair
<
const typename Triangulation::Point*,
label
>
> vectorPairPointIndex;
vectorPairPointIndex points;
label count = 0;
for (PointIterator it = begin; it != end; ++it)
{
points.append
(
std::make_pair(&(it->point()), count++)
);
}
std::random_shuffle(points.begin(), points.end());
spatial_sort
(
points.begin(),
points.end(),
Traits_for_spatial_sort()
);
Vertex_handle hint;
for
(
typename vectorPairPointIndex::const_iterator p = points.begin();
p != points.end();
++p
)
{
const size_t checkInsertion = Triangulation::number_of_vertices();
hint = this->insert(*(p->first), hint);
const Vb& vert = *(begin + p->second);
if (checkInsertion != Triangulation::number_of_vertices() - 1)
{
if (printErrors)
{
Vertex_handle nearV =
Triangulation::nearest_vertex(*(p->first));
Pout<< "Failed insertion : " << vert.info()
<< " nearest : " << nearV->info();
}
}
else
{
hint->index() = getNewVertexIndex();
hint->type() = vert.type();
hint->procIndex() = vert.procIndex();
hint->targetCellSize() = vert.targetCellSize();
hint->alignment() = vert.alignment();
}
}
}
// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "DelaunayMeshIO.C"
// ************************************************************************* //

238
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMesh.H
View File

@ -1,238 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Class
Foam::DelaunayMesh
Description
The vertex and cell classes must have an index defined
SourceFiles
DelaunayMeshI.H
DelaunayMesh.C
DelaunayMeshIO.C
\*---------------------------------------------------------------------------*/
#ifndef DelaunayMesh_H
#define DelaunayMesh_H
#include "Pair.H"
#include "HashSet.H"
#include "FixedList.H"
#include "boundBox.H"
#include "indexedVertex.H"
#include "CGALTriangulation3Ddefs.H"
#include "autoPtr.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class fvMesh;
/*---------------------------------------------------------------------------*\
Class DelaunayMesh Declaration
\*---------------------------------------------------------------------------*/
template<class Triangulation>
class DelaunayMesh
:
public Triangulation
{
public:
typedef typename Triangulation::Cell_handle Cell_handle;
typedef typename Triangulation::Vertex_handle Vertex_handle;
typedef typename Triangulation::Point Point;
typedef typename Triangulation::Facet Facet;
typedef typename Triangulation::Finite_vertices_iterator
Finite_vertices_iterator;
typedef typename Triangulation::Finite_cells_iterator
Finite_cells_iterator;
typedef typename Triangulation::Finite_facets_iterator
Finite_facets_iterator;
typedef HashSet
<
Pair<label>,
FixedList<label, 2>::Hash<>
> labelPairHashSet;
private:
// Private data
//- Keep track of the number of vertices that have been added.
// This allows a unique index to be assigned to each vertex.
mutable label vertexCount_;
//- Keep track of the number of cells that have been added.
// This allows a unique index to be assigned to each cell.
mutable label cellCount_;
//- Spatial sort traits to use with a pair of point pointers and an int.
// Taken from a post on the CGAL lists: 2010-01/msg00004.html by
// Sebastien Loriot (Geometry Factory).
struct Traits_for_spatial_sort
:
public Triangulation::Geom_traits
{
typedef typename Triangulation::Geom_traits Gt;
typedef std::pair<const typename Triangulation::Point*, int>
Point_3;
struct Less_x_3
{
bool operator()(const Point_3& p, const Point_3& q) const;
};
struct Less_y_3
{
bool operator()(const Point_3& p, const Point_3& q) const;
};
struct Less_z_3
{
bool operator()(const Point_3& p, const Point_3& q) const;
};
Less_x_3 less_x_3_object() const;
Less_y_3 less_y_3_object() const;
Less_z_3 less_z_3_object() const;
};
// Private Member Functions
void sortFaces
(
faceList& faces,
labelList& owner,
labelList& neighbour
) const;
void addPatches
(
const label nInternalFaces,
faceList& faces,
labelList& owner,
labelList& patchSizes,
labelList& patchStarts,
const List<DynamicList<face> >& patchFaces,
const List<DynamicList<label> >& patchOwners
) const;
//- Disallow default bitwise copy construct
DelaunayMesh(const DelaunayMesh<Triangulation>&);
//- Disallow default bitwise assignment
void operator=(const DelaunayMesh<Triangulation>&);
public:
// Constructors
//- Construct from components
DelaunayMesh();
//- Destructor
~DelaunayMesh();
// Member Functions
inline label getNewVertexIndex() const;
inline label getNewCellIndex() const;
inline label cellCount() const;
inline void resetCellCount();
inline label vertexCount() const;
inline void resetVertexCount();
//- Remove the entire triangulation
void reset();
void insertPoints(const List<Vb>& vertices);
//- Function inserting points into a triangulation and setting the
// index and type data of the point in the correct order. This is
// faster than inserting points individually.
//
// Adapted from a post on the CGAL lists: 2010-01/msg00004.html by
// Sebastien Loriot (Geometry Factory).
template<class PointIterator>
void rangeInsertWithInfo
(
PointIterator begin,
PointIterator end,
bool printErrors = true
);
// Queries
void printInfo(Ostream& os) const;
//- Create an fvMesh from the triangulation.
// The mesh is not parallel consistent - only used for viewing
autoPtr<fvMesh> createMesh
(
const fileName& name,
const Time& runTime,
labelList& vertexMap,
labelList& cellMap
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "DelaunayMeshI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "DelaunayMesh.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

119
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMeshI.H
View File

@ -1,119 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
\*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Triangulation>
inline Foam::label Foam::DelaunayMesh<Triangulation>::getNewVertexIndex() const
{
label id = vertexCount_++;
if (id == labelMax)
{
WarningIn
(
"Foam::DelaunayMesh<Triangulation>::getNewVertexIndex() const"
) << "Vertex counter has overflowed." << endl;
}
return id;
}
template<class Triangulation>
inline Foam::label Foam::DelaunayMesh<Triangulation>::getNewCellIndex() const
{
label id = cellCount_++;
if (id == labelMax)
{
WarningIn
(
"Foam::DelaunayMesh<Triangulation>::getNewCellIndex() const"
) << "Cell counter has overflowed." << endl;
}
return id;
}
template<class Triangulation>
Foam::label Foam::DelaunayMesh<Triangulation>::cellCount() const
{
return cellCount_;
}
template<class Triangulation>
void Foam::DelaunayMesh<Triangulation>::resetCellCount()
{
cellCount_ = 0;
}
template<class Triangulation>
Foam::label Foam::DelaunayMesh<Triangulation>::vertexCount() const
{
return vertexCount_;
}
template<class Triangulation>
void Foam::DelaunayMesh<Triangulation>::resetVertexCount()
{
vertexCount_ = 0;
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Ostream Operator * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// ************************************************************************* //

391
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMeshIO.C
View File

@ -1,391 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "DelaunayMesh.H"
#include "fvMesh.H"
#include "pointConversion.H"
#include "wallPolyPatch.H"
#include "processorPolyPatch.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class Triangulation>
void Foam::DelaunayMesh<Triangulation>::sortFaces
(
faceList& faces,
labelList& owner,
labelList& neighbour
) const
{
// Upper triangular order:
// + owner is sorted in ascending cell order
// + within each block of equal value for owner, neighbour is sorted in
// ascending cell order.
// + faces sorted to correspond
// e.g.
// owner | neighbour
// 0 | 2
// 0 | 23
// 0 | 71
// 1 | 23
// 1 | 24
// 1 | 91
List<labelPair> ownerNeighbourPair(owner.size());
forAll(ownerNeighbourPair, oNI)
{
ownerNeighbourPair[oNI] = labelPair(owner[oNI], neighbour[oNI]);
}
Info<< nl
<< "Sorting faces, owner and neighbour into upper triangular order"
<< endl;
labelList oldToNew;
sortedOrder(ownerNeighbourPair, oldToNew);
oldToNew = invert(oldToNew.size(), oldToNew);
inplaceReorder(oldToNew, faces);
inplaceReorder(oldToNew, owner);
inplaceReorder(oldToNew, neighbour);
}
template<class Triangulation>
void Foam::DelaunayMesh<Triangulation>::addPatches
(
const label nInternalFaces,
faceList& faces,
labelList& owner,
labelList& patchSizes,
labelList& patchStarts,
const List<DynamicList<face> >& patchFaces,
const List<DynamicList<label> >& patchOwners
) const
{
label nPatches = patchFaces.size();
patchSizes.setSize(nPatches, -1);
patchStarts.setSize(nPatches, -1);
label nBoundaryFaces = 0;
forAll(patchFaces, p)
{
patchSizes[p] = patchFaces[p].size();
patchStarts[p] = nInternalFaces + nBoundaryFaces;
nBoundaryFaces += patchSizes[p];
}
faces.setSize(nInternalFaces + nBoundaryFaces);
owner.setSize(nInternalFaces + nBoundaryFaces);
label faceI = nInternalFaces;
forAll(patchFaces, p)
{
forAll(patchFaces[p], f)
{
faces[faceI] = patchFaces[p][f];
owner[faceI] = patchOwners[p][f];
faceI++;
}
}
}
// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * //
template<class Triangulation>
void Foam::DelaunayMesh<Triangulation>::printInfo(Ostream& os) const
{
PrintTable<word, label> triInfoTable("Mesh Statistics");
triInfoTable.add("Points", Triangulation::number_of_vertices());
triInfoTable.add("Edges", Triangulation::number_of_finite_edges());
triInfoTable.add("Faces", Triangulation::number_of_finite_facets());
triInfoTable.add("Cells", Triangulation::number_of_finite_cells());
scalar minSize = GREAT;
scalar maxSize = 0;
for
(
Finite_vertices_iterator vit = Triangulation::finite_vertices_begin();
vit != Triangulation::finite_vertices_end();
++vit
)
{
if (!vit->farPoint())
{
minSize = min(vit->targetCellSize(), minSize);
maxSize = max(vit->targetCellSize(), maxSize);
}
}
Info<< incrIndent;
triInfoTable.print(Info, true, true);
Info<< "Size (Min/Max) = "
<< returnReduce(minSize, minOp<scalar>()) << " "
<< returnReduce(maxSize, maxOp<scalar>()) << endl;
Info<< decrIndent;
}
template<class Triangulation>
Foam::autoPtr<Foam::fvMesh>
Foam::DelaunayMesh<Triangulation>::createMesh
(
const fileName& name,
const Time& runTime,
labelList& vertexMap,
labelList& cellMap
) const
{
pointField points(Triangulation::number_of_vertices());
faceList faces(Triangulation::number_of_finite_facets());
labelList owner(Triangulation::number_of_finite_facets());
labelList neighbour(Triangulation::number_of_finite_facets());
wordList patchNames(1, "cvMesh_defaultPatch");
wordList patchTypes(1, wallPolyPatch::typeName);
labelList patchSizes(1, 0);
labelList patchStarts(1, 0);
List<DynamicList<face> > patchFaces(1, DynamicList<face>());
List<DynamicList<label> > patchOwners(1, DynamicList<label>());
vertexMap.setSize(Triangulation::number_of_vertices());
cellMap.setSize(Triangulation::number_of_finite_cells());
// Calculate pts and a map of point index to location in pts.
label vertI = 0;
for
(
Finite_vertices_iterator vit = Triangulation::finite_vertices_begin();
vit != Triangulation::finite_vertices_end();
++vit
)
{
if (!vit->farPoint())
{
vertexMap[vit->index()] = vertI;
points[vertI] = topoint(vit->point());
vertI++;
}
}
points.setSize(vertI);
// Index the cells
label cellI = 0;
for
(
Finite_cells_iterator cit = Triangulation::finite_cells_begin();
cit != Triangulation::finite_cells_end();
++cit
)
{
if
(
!cit->hasFarPoint()
&& !Triangulation::is_infinite(cit)
)
{
cellMap[cit->cellIndex()] = cellI++;
}
}
label faceI = 0;
labelList verticesOnTriFace(3, -1);
face newFace(verticesOnTriFace);
for
(
Finite_facets_iterator fit = Triangulation::finite_facets_begin();
fit != Triangulation::finite_facets_end();
++fit
)
{
const Cell_handle c1(fit->first);
const int oppositeVertex = fit->second;
const Cell_handle c2(c1->neighbor(oppositeVertex));
label c1I = Cb::ctFar;
bool c1Real = false;
if (!c1->hasFarPoint() && !Triangulation::is_infinite(c1))
{
c1I = cellMap[c1->cellIndex()];
c1Real = true;
}
label c2I = Cb::ctFar;
bool c2Real = false;
if (!c2->hasFarPoint() && !Triangulation::is_infinite(c2))
{
c2I = cellMap[c2->cellIndex()];
c2Real = true;
}
if (!c1Real && !c2Real)
{
// Both tets are outside, skip
continue;
}
label ownerCell = -1;
label neighbourCell = -1;
for (label i = 0; i < 3; i++)
{
verticesOnTriFace[i] = vertexMap
[
c1->vertex
(
Triangulation::vertex_triple_index(oppositeVertex, i)
)->index()
];
}
newFace = face(verticesOnTriFace);
if (!c1Real || !c2Real)
{
// Boundary face...
if (!c1Real)
{
//... with c1 outside
ownerCell = c2I;
}
else
{
// ... with c2 outside
ownerCell = c1I;
reverse(newFace);
}
patchFaces[0].append(newFace);
patchOwners[0].append(ownerCell);
}
else
{
// Internal face...
if (c1I < c2I)
{
// ...with c1 as the ownerCell
ownerCell = c1I;
neighbourCell = c2I;
reverse(newFace);
}
else
{
// ...with c2 as the ownerCell
ownerCell = c2I;
neighbourCell = c1I;
}
faces[faceI] = newFace;
owner[faceI] = ownerCell;
neighbour[faceI] = neighbourCell;
faceI++;
}
}
faces.setSize(faceI);
owner.setSize(faceI);
neighbour.setSize(faceI);
sortFaces(faces, owner, neighbour);
addPatches
(
faceI,
faces,
owner,
patchSizes,
patchStarts,
patchFaces,
patchOwners
);
autoPtr<fvMesh> meshPtr
(
new fvMesh
(
IOobject
(
name,
runTime.timeName(),
runTime,
IOobject::NO_READ,
IOobject::NO_WRITE
),
xferMove(points),
xferMove(faces),
xferMove(owner),
xferMove(neighbour)
)
);
List<polyPatch*> patches(patchStarts.size());
label nValidPatches = 0;
forAll(patches, p)
{
patches[nValidPatches] = polyPatch::New
(
patchTypes[p],
patchNames[p],
patchSizes[p],
patchStarts[p],
nValidPatches,
meshPtr().boundaryMesh()
).ptr();
nValidPatches++;
}
patches.setSize(nValidPatches);
meshPtr().addFvPatches(patches);
return meshPtr;
}
// ************************************************************************* //

938
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DistributedDelaunayMesh.C
View File

@ -1,938 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "DistributedDelaunayMesh.H"
#include "meshSearch.H"
#include "mapDistribute.H"
#include "zeroGradientFvPatchFields.H"
#include "pointConversion.H"
#include "indexedVertexEnum.H"
#include "IOmanip.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
// * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * * //
template<class Triangulation>
Foam::autoPtr<Foam::mapDistribute>
Foam::DistributedDelaunayMesh<Triangulation>::buildMap
(
const List<label>& toProc
)
{
// Determine send map
// ~~~~~~~~~~~~~~~~~~
// 1. Count
labelList nSend(Pstream::nProcs(), 0);
forAll(toProc, i)
{
label procI = toProc[i];
nSend[procI]++;
}
// Send over how many I need to receive
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
labelListList sendSizes(Pstream::nProcs());
sendSizes[Pstream::myProcNo()] = nSend;
combineReduce(sendSizes, UPstream::listEq());
// 2. Size sendMap
labelListList sendMap(Pstream::nProcs());
forAll(nSend, procI)
{
sendMap[procI].setSize(nSend[procI]);
nSend[procI] = 0;
}
// 3. Fill sendMap
forAll(toProc, i)
{
label procI = toProc[i];
sendMap[procI][nSend[procI]++] = i;
}
// Determine receive map
// ~~~~~~~~~~~~~~~~~~~~~
labelListList constructMap(Pstream::nProcs());
// Local transfers first
constructMap[Pstream::myProcNo()] = identity
(
sendMap[Pstream::myProcNo()].size()
);
label constructSize = constructMap[Pstream::myProcNo()].size();
forAll(constructMap, procI)
{
if (procI != Pstream::myProcNo())
{
label nRecv = sendSizes[procI][Pstream::myProcNo()];
constructMap[procI].setSize(nRecv);
for (label i = 0; i < nRecv; i++)
{
constructMap[procI][i] = constructSize++;
}
}
}
return autoPtr<mapDistribute>
(
new mapDistribute
(
constructSize,
sendMap.xfer(),
constructMap.xfer()
)
);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Triangulation>
Foam::DistributedDelaunayMesh<Triangulation>::DistributedDelaunayMesh()
:
DelaunayMesh<Triangulation>(),
allBackgroundMeshBounds_()
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Triangulation>
Foam::DistributedDelaunayMesh<Triangulation>::~DistributedDelaunayMesh()
{}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class Triangulation>
bool Foam::DistributedDelaunayMesh<Triangulation>::distributeBoundBoxes
(
const boundBox& bb
)
{
allBackgroundMeshBounds_.reset(new List<boundBox>(Pstream::nProcs()));
// Give the bounds of every processor to every other processor
allBackgroundMeshBounds_()[Pstream::myProcNo()] = bb;
Pstream::gatherList(allBackgroundMeshBounds_());
Pstream::scatterList(allBackgroundMeshBounds_());
return true;
}
template<class Triangulation>
bool Foam::DistributedDelaunayMesh<Triangulation>::isLocal
(
const Vertex_handle& v
) const
{
return isLocal(v->procIndex());
}
template<class Triangulation>
bool Foam::DistributedDelaunayMesh<Triangulation>::isLocal
(
const label localProcIndex
) const
{
return localProcIndex == Pstream::myProcNo();
}
template<class Triangulation>
Foam::labelList Foam::DistributedDelaunayMesh<Triangulation>::overlapProcessors
(
const point& centre,
const scalar radiusSqr
) const
{
DynamicList<label> toProc(Pstream::nProcs());
forAll(allBackgroundMeshBounds_(), procI)
{
// Test against the bounding box of the processor
if
(
!isLocal(procI)
&& allBackgroundMeshBounds_()[procI].overlaps(centre, radiusSqr)
)
{
toProc.append(procI);
}
}
return toProc;
}
template<class Triangulation>
bool Foam::DistributedDelaunayMesh<Triangulation>::checkProcBoundaryCell
(
const Cell_handle& cit,
Map<labelList>& circumsphereOverlaps
) const
{
const Foam::point& cc = cit->dual();
const scalar crSqr = magSqr
(
cc - topoint(cit->vertex(0)->point())
);
labelList circumsphereOverlap = overlapProcessors
(
cc,
sqr(1.01)*crSqr
);
cit->cellIndex() = this->getNewCellIndex();
if (!circumsphereOverlap.empty())
{
circumsphereOverlaps.insert(cit->cellIndex(), circumsphereOverlap);
return true;
}
return false;
}
template<class Triangulation>
void Foam::DistributedDelaunayMesh<Triangulation>::findProcessorBoundaryCells
(
Map<labelList>& circumsphereOverlaps
) const
{
// Start by assuming that all the cells have no index
// If they do, they have already been visited so ignore them
labelHashSet cellToCheck
(
Triangulation::number_of_finite_cells()
/Pstream::nProcs()
);
for
(
All_cells_iterator cit = Triangulation::all_cells_begin();
cit != Triangulation::all_cells_end();
++cit
)
{
if (Triangulation::is_infinite(cit))
{
// Index of infinite vertex in this cell.
int i = cit->index(Triangulation::infinite_vertex());
Cell_handle c = cit->neighbor(i);
if (c->unassigned())
{
c->cellIndex() = this->getNewCellIndex();
if (checkProcBoundaryCell(c, circumsphereOverlaps))
{
cellToCheck.insert(c->cellIndex());
}
}
}
else if (cit->parallelDualVertex())
{
if (cit->unassigned())
{
if (checkProcBoundaryCell(cit, circumsphereOverlaps))
{
cellToCheck.insert(cit->cellIndex());
}
}
}
}
for
(
Finite_cells_iterator cit = Triangulation::finite_cells_begin();
cit != Triangulation::finite_cells_end();
++cit
)
{
if (cellToCheck.found(cit->cellIndex()))
{
// Get the neighbours and check them
for (label adjCellI = 0; adjCellI < 4; ++adjCellI)
{
Cell_handle citNeighbor = cit->neighbor(adjCellI);
// Ignore if has far point or previously visited
if
(
!citNeighbor->unassigned()
|| !citNeighbor->internalOrBoundaryDualVertex()
|| Triangulation::is_infinite(citNeighbor)
)
{
continue;
}
checkProcBoundaryCell
(
citNeighbor,
circumsphereOverlaps
);
}
}
}
}
template<class Triangulation>
void Foam::DistributedDelaunayMesh<Triangulation>::markVerticesToRefer
(
const Map<labelList>& circumsphereOverlaps,
PtrList<labelPairHashSet>& referralVertices,
DynamicList<label>& targetProcessor,
DynamicList<Vb>& parallelInfluenceVertices
)
{
// Relying on the order of iteration of cells being the same as before
for
(
Finite_cells_iterator cit = Triangulation::finite_cells_begin();
cit != Triangulation::finite_cells_end();
++cit
)
{
if (Triangulation::is_infinite(cit))
{
continue;
}
Map<labelList>::const_iterator iter =
circumsphereOverlaps.find(cit->cellIndex());
// Pre-tested circumsphere potential influence
if (iter != circumsphereOverlaps.cend())
{
const labelList& citOverlaps = iter();
forAll(citOverlaps, cOI)
{
label procI = citOverlaps[cOI];
for (int i = 0; i < 4; i++)
{
Vertex_handle v = cit->vertex(i);
if (v->farPoint())
{
continue;
}
label vProcIndex = v->procIndex();
label vIndex = v->index();
const labelPair procIndexPair(vProcIndex, vIndex);
// Using the hashSet to ensure that each vertex is only
// referred once to each processor.
// Do not refer a vertex to its own processor.
if (vProcIndex != procI)
{
if (referralVertices[procI].insert(procIndexPair))
{
targetProcessor.append(procI);
parallelInfluenceVertices.append
(
Vb
(
v->point(),
v->index(),
v->type(),
v->procIndex()
)
);
parallelInfluenceVertices.last().targetCellSize() =
v->targetCellSize();
parallelInfluenceVertices.last().alignment() =
v->alignment();
}
}
}
}
}
}
}
template<class Triangulation>
Foam::label Foam::DistributedDelaunayMesh<Triangulation>::referVertices
(
const DynamicList<label>& targetProcessor,
DynamicList<Vb>& parallelVertices,
PtrList<labelPairHashSet>& referralVertices,
labelPairHashSet& receivedVertices
)
{
DynamicList<Vb> referredVertices(targetProcessor.size());
const label preDistributionSize = parallelVertices.size();
mapDistribute pointMap = buildMap(targetProcessor);
// Make a copy of the original list.
DynamicList<Vb> originalParallelVertices(parallelVertices);
pointMap.distribute(parallelVertices);
for (label procI = 0; procI < Pstream::nProcs(); procI++)
{
const labelList& constructMap = pointMap.constructMap()[procI];
if (constructMap.size())
{
forAll(constructMap, i)
{
const Vb& v = parallelVertices[constructMap[i]];
if
(
v.procIndex() != Pstream::myProcNo()
&& !receivedVertices.found(labelPair(v.procIndex(), v.index()))
)
{
referredVertices.append(v);
receivedVertices.insert
(
labelPair(v.procIndex(), v.index())
);
}
}
}
}
label preInsertionSize = Triangulation::number_of_vertices();
labelPairHashSet pointsNotInserted = rangeInsertReferredWithInfo
(
referredVertices.begin(),
referredVertices.end()
);
if (!pointsNotInserted.empty())
{
for
(
typename labelPairHashSet::const_iterator iter
= pointsNotInserted.begin();
iter != pointsNotInserted.end();
++iter
)
{
if (receivedVertices.found(iter.key()))
{
receivedVertices.erase(iter.key());
}
}
}
boolList pointInserted(parallelVertices.size(), true);
forAll(parallelVertices, vI)
{
const labelPair procIndexI
(
parallelVertices[vI].procIndex(),
parallelVertices[vI].index()
);
if (pointsNotInserted.found(procIndexI))
{
pointInserted[vI] = false;
}
}
pointMap.reverseDistribute(preDistributionSize, pointInserted);
forAll(originalParallelVertices, vI)
{
const label procIndex = targetProcessor[vI];
if (!pointInserted[vI])
{
if (referralVertices[procIndex].size())
{
if
(
!referralVertices[procIndex].unset
(
labelPair
(
originalParallelVertices[vI].procIndex(),
originalParallelVertices[vI].index()
)
)
)
{
Pout<< "*** not found "
<< originalParallelVertices[vI].procIndex()
<< " " << originalParallelVertices[vI].index() << endl;
}
}
}
}
label postInsertionSize = Triangulation::number_of_vertices();
reduce(preInsertionSize, sumOp<label>());
reduce(postInsertionSize, sumOp<label>());
label nTotalToInsert = referredVertices.size();
reduce(nTotalToInsert, sumOp<label>());
if (preInsertionSize + nTotalToInsert != postInsertionSize)
{
label nNotInserted =
returnReduce(pointsNotInserted.size(), sumOp<label>());
Info<< " Inserted = "
<< setw(name(label(Triangulation::number_of_finite_cells())).size())
<< nTotalToInsert - nNotInserted
<< " / " << nTotalToInsert << endl;
nTotalToInsert -= nNotInserted;
}
else
{
Info<< " Inserted = " << nTotalToInsert << endl;
}
return nTotalToInsert;
}
template<class Triangulation>
void Foam::DistributedDelaunayMesh<Triangulation>::sync
(
const boundBox& bb,
PtrList<labelPairHashSet>& referralVertices,
labelPairHashSet& receivedVertices,
bool iterateReferral
)
{
if (!Pstream::parRun())
{
return;
}
if (allBackgroundMeshBounds_.empty())
{
distributeBoundBoxes(bb);
}
label nVerts = Triangulation::number_of_vertices();
label nCells = Triangulation::number_of_finite_cells();
DynamicList<Vb> parallelInfluenceVertices(0.1*nVerts);
DynamicList<label> targetProcessor(0.1*nVerts);
// Some of these values will not be used, i.e. for non-real cells
DynamicList<Foam::point> circumcentre(0.1*nVerts);
DynamicList<scalar> circumradiusSqr(0.1*nVerts);
Map<labelList> circumsphereOverlaps(nCells);
findProcessorBoundaryCells(circumsphereOverlaps);
Info<< " Influences = "
<< setw(name(nCells).size())
<< returnReduce(circumsphereOverlaps.size(), sumOp<label>()) << " / "
<< returnReduce(nCells, sumOp<label>());
markVerticesToRefer
(
circumsphereOverlaps,
referralVertices,
targetProcessor,
parallelInfluenceVertices
);
referVertices
(
targetProcessor,
parallelInfluenceVertices,
referralVertices,
receivedVertices
);
if (iterateReferral)
{
label oldNReferred = 0;
label nIterations = 1;
Info<< incrIndent << indent
<< "Iteratively referring referred vertices..."
<< endl;
do
{
Info<< indent << "Iteration " << nIterations++ << ":";
circumsphereOverlaps.clear();
targetProcessor.clear();
parallelInfluenceVertices.clear();
findProcessorBoundaryCells(circumsphereOverlaps);
nCells = Triangulation::number_of_finite_cells();
Info<< " Influences = "
<< setw(name(nCells).size())
<< returnReduce(circumsphereOverlaps.size(), sumOp<label>())
<< " / "
<< returnReduce(nCells, sumOp<label>());
markVerticesToRefer
(
circumsphereOverlaps,
referralVertices,
targetProcessor,
parallelInfluenceVertices
);
label nReferred = referVertices
(
targetProcessor,
parallelInfluenceVertices,
referralVertices,
receivedVertices
);
if (nReferred == 0 || nReferred == oldNReferred)
{
break;
}
oldNReferred = nReferred;
} while (true);
Info<< decrIndent;
}
}
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class Triangulation>
bool Foam::DistributedDelaunayMesh<Triangulation>::distribute
(
const boundBox& bb
)
{
notImplemented
(
"Foam::DistributedDelaunayMesh<Triangulation>::distribute"
"("
" const boundBox& bb"
")"
);
if (!Pstream::parRun())
{
return false;
}
distributeBoundBoxes(bb);
return true;
}
template<class Triangulation>
Foam::autoPtr<Foam::mapDistribute>
Foam::DistributedDelaunayMesh<Triangulation>::distribute
(
const backgroundMeshDecomposition& decomposition
)
{
if (!Pstream::parRun())
{
return autoPtr<mapDistribute>();
}
distributeBoundBoxes(decomposition.procBounds());
DynamicList<point> points(Triangulation::number_of_vertices());
for
(
Finite_vertices_iterator vit = Triangulation::finite_vertices_begin();
vit != Triangulation::finite_vertices_end();
++vit
)
{
if (vit->real())
{
points.append(topoint(vit->point()));
}
}
autoPtr<mapDistribute> mapDist = decomposition.distributePoints(points);
return mapDist;
}
template<class Triangulation>
void Foam::DistributedDelaunayMesh<Triangulation>::sync(const boundBox& bb)
{
if (!Pstream::parRun())
{
return;
}
if (allBackgroundMeshBounds_.empty())
{
distributeBoundBoxes(bb);
}
const label nApproxReferred =
Triangulation::number_of_vertices()
/Pstream::nProcs();
PtrList<labelPairHashSet> referralVertices(Pstream::nProcs());
forAll(referralVertices, procI)
{
if (!isLocal(procI))
{
referralVertices.set(procI, new labelPairHashSet(nApproxReferred));
}
}
labelPairHashSet receivedVertices(nApproxReferred);
sync
(
bb,
referralVertices,
receivedVertices,
true
);
}
template<class Triangulation>
template<class PointIterator>
typename Foam::DistributedDelaunayMesh<Triangulation>::labelPairHashSet
Foam::DistributedDelaunayMesh<Triangulation>::rangeInsertReferredWithInfo
(
PointIterator begin,
PointIterator end,
bool printErrors
)
{
const boundBox& bb = allBackgroundMeshBounds_()[Pstream::myProcNo()];
typedef DynamicList
<
std::pair<scalar, label>
> vectorPairPointIndex;
vectorPairPointIndex pointsBbDistSqr;
label count = 0;
for (PointIterator it = begin; it != end; ++it)
{
const Foam::point samplePoint(topoint(it->point()));
scalar distFromBbSqr = 0;
if (!bb.contains(samplePoint))
{
const Foam::point nearestPoint = bb.nearest(samplePoint);
distFromBbSqr = magSqr(nearestPoint - samplePoint);
}
pointsBbDistSqr.append
(
std::make_pair(distFromBbSqr, count++)
);
}
std::random_shuffle(pointsBbDistSqr.begin(), pointsBbDistSqr.end());
// Sort in ascending order by the distance of the point from the centre
// of the processor bounding box
sort(pointsBbDistSqr.begin(), pointsBbDistSqr.end());
typename Triangulation::Vertex_handle hint;
typename Triangulation::Locate_type lt;
int li, lj;
label nNotInserted = 0;
labelPairHashSet uninserted
(
Triangulation::number_of_vertices()
/Pstream::nProcs()
);
for
(
typename vectorPairPointIndex::const_iterator p =
pointsBbDistSqr.begin();
p != pointsBbDistSqr.end();
++p
)
{
const size_t checkInsertion = Triangulation::number_of_vertices();
const Vb& vert = *(begin + p->second);
const Point& pointToInsert = vert.point();
// Locate the point
Cell_handle c = Triangulation::locate(pointToInsert, lt, li, lj, hint);
if (lt == Triangulation::VERTEX)
{
if (printErrors)
{
Vertex_handle nearV =
Triangulation::nearest_vertex(pointToInsert);
Pout<< "Failed insertion, point already exists" << nl
<< "Failed insertion : " << vert.info()
<< " nearest : " << nearV->info();
}
uninserted.insert(labelPair(vert.procIndex(), vert.index()));
nNotInserted++;
continue;
}
// Get the cells that conflict with p in a vector V,
// and a facet on the boundary of this hole in f.
std::vector<Cell_handle> V;
typename Triangulation::Facet f;
Triangulation::find_conflicts
(
pointToInsert,
c,
CGAL::Oneset_iterator<typename Triangulation::Facet>(f),
std::back_inserter(V)
);
bool insert = false;
for (size_t i = 0; i < V.size(); ++i)
{
if (V[i]->real() || V[i]->hasFarPoint())
{
insert = true;
break;
}
}
if (insert)
{
hint = Triangulation::insert_in_hole
(
pointToInsert,
V.begin(),
V.end(),
f.first,
f.second
);
if (checkInsertion != Triangulation::number_of_vertices() - 1)
{
if (printErrors)
{
Vertex_handle nearV =
Triangulation::nearest_vertex(pointToInsert);
Pout<< "Failed insertion : " << vert.info()
<< " nearest : " << nearV->info();
}
}
else
{
hint->index() = vert.index();
hint->type() = vert.type();
hint->procIndex() = vert.procIndex();
hint->targetCellSize() = vert.targetCellSize();
hint->alignment() = vert.alignment();
}
}
else
{
uninserted.insert(labelPair(vert.procIndex(), vert.index()));
nNotInserted++;
}
}
return uninserted;
}
// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * * //
// ************************************************************************* //

208
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DistributedDelaunayMesh.H
View File

@ -1,208 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Class
Foam::DistributedDelaunayMesh
Description
SourceFiles
DistributedDelaunayMeshI.H
DistributedDelaunayMesh.C
DistributedDelaunayMeshIO.C
\*---------------------------------------------------------------------------*/
#ifndef DistributedDelaunayMesh_H
#define DistributedDelaunayMesh_H
#include "DelaunayMesh.H"
#include "backgroundMeshDecomposition.H"
#include "autoPtr.H"
#include "boundBox.H"
#include "indexedVertex.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class mapDistribute;
/*---------------------------------------------------------------------------*\
Class DistributedDelaunayMesh Declaration
\*---------------------------------------------------------------------------*/
template<class Triangulation>
class DistributedDelaunayMesh
:
public DelaunayMesh<Triangulation>
{
public:
typedef typename Triangulation::Vertex_handle Vertex_handle;
typedef typename Triangulation::Cell_handle Cell_handle;
typedef typename Triangulation::Point Point;
typedef typename Triangulation::Finite_vertices_iterator
Finite_vertices_iterator;
typedef typename Triangulation::Finite_cells_iterator
Finite_cells_iterator;
typedef typename Triangulation::All_cells_iterator
All_cells_iterator;
typedef typename DelaunayMesh<Triangulation>::labelPairHashSet
labelPairHashSet;
private:
autoPtr<List<boundBox> > allBackgroundMeshBounds_;
// Private Member Functions
//-
bool distributeBoundBoxes(const boundBox& bb);
//-
bool isLocal(const Vertex_handle& v) const;
bool isLocal(const label localProcIndex) const;
labelList overlapProcessors
(
const point& centre,
const scalar radiusSqr
) const;
bool checkProcBoundaryCell
(
const Cell_handle& cit,
Map<labelList>& circumsphereOverlaps
) const;
void findProcessorBoundaryCells
(
Map<labelList>& circumsphereOverlaps
) const;
void markVerticesToRefer
(
const Map<labelList>& circumsphereOverlaps,
PtrList<labelPairHashSet>& referralVertices,
DynamicList<label>& targetProcessor,
DynamicList<Vb>& parallelInfluenceVertices
);
label referVertices
(
const DynamicList<label>& targetProcessor,
DynamicList<Vb>& parallelVertices,
PtrList<labelPairHashSet>& referralVertices,
labelPairHashSet& receivedVertices
);
//- Disallow default bitwise copy construct
DistributedDelaunayMesh(const DistributedDelaunayMesh<Triangulation>&);
//- Disallow default bitwise assignment
void operator=(const DistributedDelaunayMesh<Triangulation>&);
public:
// Constructors
//- Construct from components
DistributedDelaunayMesh();
//- Destructor
~DistributedDelaunayMesh();
// Member Functions
//- Build a mapDistribute for the supplied destination processor data
static autoPtr<mapDistribute> buildMap(const List<label>& toProc);
//-
bool distribute(const boundBox& bb);
autoPtr<mapDistribute> distribute
(
const backgroundMeshDecomposition& decomposition
);
//- Refer vertices so that the processor interfaces are consistent
void sync(const boundBox& bb);
//- Refer vertices so that the processor interfaces are consistent
void sync
(
const boundBox& bb,
PtrList<labelPairHashSet>& referralVertices,
labelPairHashSet& receivedVertices,
bool iterateReferral = true
);
//- Inserts points into the triangulation if the point is within
// the circumsphere of another cell. Returns HashSet of failed
// point insertions
template<class PointIterator>
labelPairHashSet rangeInsertReferredWithInfo
(
PointIterator begin,
PointIterator end,
bool printErrors = true
);
// distributeField();
// Queries
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
//#include "DistributedDelaunayMeshI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "DistributedDelaunayMesh.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

66
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/Make/files
View File

@ -1,66 +0,0 @@
#include CGAL_FILES
conformalVoronoiMesh/indexedVertex/indexedVertexEnum.C
conformalVoronoiMesh/indexedCell/indexedCellEnum.C
conformalVoronoiMesh/conformalVoronoiMesh.C
conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C
conformalVoronoiMesh/conformalVoronoiMeshConformToSurface.C
conformalVoronoiMesh/conformalVoronoiMeshIO.C
conformalVoronoiMesh/conformalVoronoiMeshFeaturePoints.C
conformalVoronoiMesh/conformalVoronoiMeshFeaturePointSpecialisations.C
cvControls/cvControls.C
conformationSurfaces/conformationSurfaces.C
backgroundMeshDecomposition/backgroundMeshDecomposition.C
cellShapeControl/cellShapeControl/cellShapeControl.C
cellShapeControl/cellShapeControlMesh/cellShapeControlMesh.C
cellSizeAndAlignmentControl = cellShapeControl/cellSizeAndAlignmentControl
$(cellSizeAndAlignmentControl)/cellSizeAndAlignmentControls.C
$(cellSizeAndAlignmentControl)/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl.C
$(cellSizeAndAlignmentControl)/fileControl/fileControl.C
$(cellSizeAndAlignmentControl)/searchableSurfaceControl/searchableSurfaceControl.C
/*cellShapeControl/pQuadCoorControl/pQuadCoorControl.C*/
cellShapeControl/cellAspectRatioControl/cellAspectRatioControl.C
/*cellSizeControlSurfaces/cellSizeControlSurfaces.C*/
cellSizeFunctions = cellSizeControlSurfaces/cellSizeFunction
$(cellSizeFunctions)/cellSizeFunction/cellSizeFunction.C
$(cellSizeFunctions)/uniform/uniform.C
$(cellSizeFunctions)/uniformDistance/uniformDistance.C
$(cellSizeFunctions)/linearDistance/linearDistance.C
$(cellSizeFunctions)/surfaceOffsetLinearDistance/surfaceOffsetLinearDistance.C
$(cellSizeFunctions)/linearSpatial/linearSpatial.C
surfaceCellSizeFunctions = cellSizeControlSurfaces/surfaceCellSizeFunction
$(surfaceCellSizeFunctions)/surfaceCellSizeFunction/surfaceCellSizeFunction.C
$(surfaceCellSizeFunctions)/uniformValue/uniformValue.C
$(surfaceCellSizeFunctions)/nonUniformField/nonUniformField.C
cellSizeCalculationType = $(surfaceCellSizeFunctions)/cellSizeCalculationType
$(cellSizeCalculationType)/cellSizeCalculationType/cellSizeCalculationType.C
$(cellSizeCalculationType)/fieldFromFile/fieldFromFile.C
$(cellSizeCalculationType)/automatic/automatic.C
initialPointsMethod/initialPointsMethod/initialPointsMethod.C
initialPointsMethod/uniformGrid/uniformGrid.C
initialPointsMethod/bodyCentredCubic/bodyCentredCubic.C
initialPointsMethod/faceCentredCubic/faceCentredCubic.C
initialPointsMethod/pointFile/pointFile.C
initialPointsMethod/autoDensity/autoDensity.C
relaxationModel/relaxationModel/relaxationModel.C
relaxationModel/adaptiveLinear/adaptiveLinear.C
relaxationModel/rampHoldFall/rampHoldFall.C
faceAreaWeightModel/faceAreaWeightModel/faceAreaWeightModel.C
faceAreaWeightModel/piecewiseLinearRamp/piecewiseLinearRamp.C
LIB = $(FOAM_LIBBIN)/libconformalVoronoiMesh

33
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/Make/options
View File

@ -1,33 +0,0 @@
EXE_DEBUG = -DFULLDEBUG -g -O0
EXE_FROUNDING_MATH = -frounding-math
EXE_NDEBUG = -DNDEBUG
CGAL_EXACT = /*-DCGAL_DONT_USE_LAZY_KERNEL*/
CGAL_INEXACT = -DCGAL_INEXACT
include $(GENERAL_RULES)/CGAL
FFLAGS = -DCGAL_FILES='"${CGAL_ARCH_PATH}/share/files"'
EXE_INC = \
${EXE_FROUNDING_MATH} \
${EXE_NDEBUG} \
${CGAL_INEXACT} \
${CGAL_INC} \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
-I$(LIB_SRC)/edgeMesh/lnInclude \
-I$(LIB_SRC)/fileFormats/lnInclude \
-I$(LIB_SRC)/dynamicMesh/lnInclude \
-I$(LIB_SRC)/triSurface/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude \
-IPrintTable \
-I../vectorTools
LIB_LIBS = \
-lmeshTools \
-ledgeMesh \
-lfileFormats \
-ltriSurface \
-ldynamicMesh \
-lsampling

234
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/PrintTable/PrintTable.C
View File

@ -1,234 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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 "PrintTable.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class KeyType, class DataType>
Foam::PrintTable<KeyType, DataType>::PrintTable()
:
table_(),
title_(string::null)
{}
template<class KeyType, class DataType>
Foam::PrintTable<KeyType, DataType>::PrintTable(const string& title)
:
table_(),
title_(title)
{}
template<class KeyType, class DataType>
Foam::PrintTable<KeyType, DataType>::PrintTable
(
const PrintTable<KeyType, DataType>& table
)
:
table_(table.table_),
title_(table.title_)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class KeyType, class DataType>
Foam::PrintTable<KeyType, DataType>::~PrintTable()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class KeyType, class DataType>
void Foam::PrintTable<KeyType, DataType>::print
(
Ostream& os,
const bool printSum,
const bool printAverage
) const
{
HashTable<HashTable<DataType, label>, KeyType> combinedTable;
List<HashTableData> procData(Pstream::nProcs(), HashTableData());
procData[Pstream::myProcNo()] = table_;
Pstream::gatherList(procData);
if (Pstream::master())
{
label largestKeyLength = 6;
label largestDataLength = 0;
List<label> largestProcSize(Pstream::nProcs(), 0);
forAll(procData, procI)
{
const HashTableData& procIData = procData[procI];
for
(
typename HashTableData::const_iterator iter = procIData.begin();
iter != procIData.end();
++iter
)
{
if (!combinedTable.found(iter.key()))
{
combinedTable.insert
(
iter.key(),
HashTable<DataType, label>()
);
}
HashTable<DataType, label>& key = combinedTable[iter.key()];
key.insert(procI, iter());
for
(
typename HashTable<DataType, label>
::const_iterator dataIter = key.begin();
dataIter != key.end();
++dataIter
)
{
std::ostringstream buf;
buf << dataIter();
largestDataLength = max
(
largestDataLength,
label(buf.str().length())
);
}
std::ostringstream buf;
buf << iter.key();
largestKeyLength = max
(
largestKeyLength,
label(buf.str().length())
);
}
}
os.width(largestKeyLength);
os << nl << indent << tab << title_.c_str() << endl;
os.width(largestKeyLength);
os << indent << "Proc #";
forAll(procData, procI)
{
os << tab;
os.width(largestDataLength);
os << procI;
}
if (printSum)
{
os << tab;
os.width(largestDataLength);
os << "Sum";
}
if (printAverage)
{
os << tab;
os.width(largestDataLength);
os << "Average";
}
os << endl;
const List<KeyType>& sortedTable = combinedTable.sortedToc();
forAll(sortedTable, keyI)
{
const HashTable<DataType, label>& procDataList
= combinedTable[sortedTable[keyI]];
os.width(largestKeyLength);
os << indent << sortedTable[keyI];
forAll(procDataList, elemI)
{
os << tab;
os.width(largestDataLength);
os << procDataList[elemI];
}
if (printSum)
{
DataType sum = 0;
forAll(procDataList, elemI)
{
sum += procDataList[elemI];
}
os << tab;
os.width(largestDataLength);
os << sum;
if (printAverage)
{
os << tab;
os.width(largestDataLength);
os << sum/Pstream::nProcs();
}
}
os << endl;
}
}
}
// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * //
template<class KeyType, class DataType>
void Foam::PrintTable<KeyType, DataType>::operator=
(
const PrintTable<KeyType, DataType>& rhs
)
{
// Check for assignment to self
if (this == &rhs)
{
FatalErrorIn
(
"Foam::PrintTable<KeyType, DataType>::operator="
"(const Foam::PrintTable<KeyType, DataType>&)"
) << "Attempted assignment to self"
<< abort(FatalError);
}
}
// ************************************************************************* //

140
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/PrintTable/PrintTable.H
View File

@ -1,140 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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/>.
Class
Foam::PrintTable
Description
Print a table in parallel, e.g.;
\verbatim
Vertex Type Information
Proc # 0 1 2 3
Total 145680 145278 145751 145359
Unassigned 0 0 0 0
nExternalFeatureEdge 883 829 828 960
nExternalFeaturePoint 8 10 10 12
nExternalSurface 9533 9488 9502 9482
nFar 0 0 0 0
nInternal 125494 125198 125642 125174
nInternalFeatureEdge 238 241 241 240
nInternalFeaturePoint 2 2 2 2
nInternalNearBoundary 0 0 0 0
nInternalSurface 9522 9510 9526 9489
nReferred 7545 7497 7500 7587
\endverbatim
SourceFiles
PrintTableI.H
PrintTable.C
\*---------------------------------------------------------------------------*/
#ifndef PrintTable_H
#define PrintTable_H
#include "HashTable.H"
#include "Ostream.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class PrintTable Declaration
\*---------------------------------------------------------------------------*/
template<class KeyType, class DataType>
class PrintTable
{
typedef HashTable<DataType, KeyType> HashTableData;
// Private data
//- Hash table holding the data
HashTableData table_;
//- Title of the table
string title_;
// Private Member Functions
//- Disallow default bitwise assignment
void operator=(const PrintTable<KeyType, DataType>&);
public:
// Constructors
//- Null constructor
PrintTable();
//- Construct with a title
explicit PrintTable(const string& title);
//- Copy constructor
PrintTable(const PrintTable<KeyType, DataType>& table);
//- Destructor
~PrintTable();
// Member Functions
//- Add an entry (D) to the given key(K)
void add(const KeyType& K, const DataType& D);
//- Print the table
void print
(
Ostream& os,
const bool printSum = false,
const bool printAverage = false
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "PrintTableI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "PrintTable.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

42
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/PrintTable/PrintTableI.H
View File

@ -1,42 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
\*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class KeyType, class DataType>
void Foam::PrintTable<KeyType, DataType>::add
(
const KeyType& K,
const DataType& D
)
{
table_.set(K, D);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// ************************************************************************* //

1804
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecomposition.C
View File

File diff suppressed because it is too large Load Diff

340
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecomposition.H
View File

@ -1,340 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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/>.
Class
Foam::backgroundMeshDecomposition
Description
Store a background polyMesh to use for the decomposition of space and
queries for parallel conformalVoronoiMesh.
The requirements are:
+ To have a decomposition of space which can quickly interrogate an
arbitrary location from any processor to reliably and unambiguously
determine which processor owns the space that the point is in, i.e. as
the vertices move, or need inserted as part of the surface conformation,
send them to the correct proc.
+ To be able to be dynamically built, refined and redistributed to other
procs the partitioning as the meshing progresses to balance the load.
+ To be able to query whether a sphere (the circumsphere of a Delaunay tet)
overlaps any part of the space defined by the structure, and whether a
ray (Voronoi edge) penetrates any part of the space defined by the
structure, this is what determines if points get referred to a processor.
SourceFiles
backgroundMeshDecompositionI.H
backgroundMeshDecomposition.C
\*---------------------------------------------------------------------------*/
#ifndef backgroundMeshDecomposition_H
#define backgroundMeshDecomposition_H
#include "fvMesh.H"
#include "hexRef8.H"
#include "cellSet.H"
#include "meshTools.H"
#include "polyTopoChange.H"
#include "mapPolyMesh.H"
#include "decompositionMethod.H"
#include "fvMeshDistribute.H"
#include "removeCells.H"
#include "mapDistributePolyMesh.H"
#include "globalIndex.H"
#include "treeBoundBox.H"
#include "primitivePatch.H"
#include "face.H"
#include "labelList.H"
#include "pointField.H"
#include "indexedOctree.H"
#include "treeDataPrimitivePatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef PrimitivePatch<face, List, const pointField, point> bPatch;
typedef treeDataPrimitivePatch<bPatch> treeDataBPatch;
class Time;
class Random;
class conformationSurfaces;
/*---------------------------------------------------------------------------*\
Class backgroundMeshDecomposition Declaration
\*---------------------------------------------------------------------------*/
class backgroundMeshDecomposition
{
// Private data
//- Method details dictionary
//dictionary coeffsDict_;
//- Reference to runtime
const Time& runTime_;
//- Reference to surface
const conformationSurfaces& geometryToConformTo_;
//- Random number generator
Random& rndGen_;
//- Mesh stored on for this processor, specifiying the domain that it
// is responsible for.
fvMesh mesh_;
//- Refinement object
hexRef8 meshCutter_;
//- Patch containing an independent representation of the surface of the
// mesh of this processor
autoPtr<bPatch> boundaryFacesPtr_;
//- Search tree for the boundaryFaces_ patch
autoPtr<indexedOctree<treeDataBPatch> > bFTreePtr_;
//- The bounds of all background meshes on all processors
treeBoundBoxList allBackgroundMeshBounds_;
//- The overall bounds of all of the background meshes, used to test if
// a point that is not found on any processor is in the domain at all
treeBoundBox globalBackgroundBounds_;
//- Decomposition dictionary
IOdictionary decomposeDict_;
//- Decomposition method
autoPtr<decompositionMethod> decomposerPtr_;
//- merge distance required by fvMeshDistribute
scalar mergeDist_;
//- Scale of a cell span vs cell size used to decide to refine a cell
scalar spanScale_;
//- Smallest minimum cell size allowed, i.e. to avoid high initial
// refinement of areas of small size
scalar minCellSizeLimit_;
//- Minimum normal level of refinement
label minLevels_;
//- How fine should the initial sample of the volume a box be to
// investigate the local cell size
label volRes_;
//- Allowed factor above the average cell weight before a background
// cell needs to be split
scalar maxCellWeightCoeff_;
// Private Member Functions
void initialRefinement();
//- Print details of the decomposed mesh
void printMeshData(const polyMesh& mesh) const;
//- Estimate the number of vertices that will be in this cell, returns
// true if the cell is to be split because of the density ratio inside
// it
bool refineCell
(
label cellI,
label volType,
scalar& weightEstimate
) const;
//- Select cells for refinement at the surface of the geometry to be
// meshed
labelList selectRefinementCells
(
labelList& volumeStatus,
volScalarField& cellWeights
) const;
//- Build the surface patch and search tree
void buildPatchAndTree();
//- Disallow default bitwise copy construct
backgroundMeshDecomposition(const backgroundMeshDecomposition&);
//- Disallow default bitwise assignment
void operator=(const backgroundMeshDecomposition&);
public:
//- Runtime type information
ClassName("backgroundMeshDecomposition");
// Constructors
//- Construct from components in cvMesh operation
backgroundMeshDecomposition
(
const Time& runTime,
Random& rndGen,
const conformationSurfaces& geometryToConformTo,
const dictionary& coeffsDict
);
//- Destructor
~backgroundMeshDecomposition();
// Member Functions
//- Build a mapDistribute for the supplied destination processor data
static autoPtr<mapDistribute> buildMap(const List<label>& toProc);
//- Redistribute the background mesh based on a supplied weight field,
// returning a map to use to redistribute vertices.
autoPtr<mapDistributePolyMesh> distribute
(
volScalarField& cellWeights
);
//- Distribute supplied the points to the appropriate processor
autoPtr<mapDistribute> distributePoints(List<point>& points) const;
//- Is the given position inside the domain of this decomposition
bool positionOnThisProcessor(const point& pt) const;
//- Are the given positions inside the domain of this decomposition
boolList positionOnThisProcessor(const List<point>& pts) const;
//- Does the given box overlap the faces of the boundary of this
// processor
bool overlapsThisProcessor(const treeBoundBox& box) const;
//- Does the given sphere overlap the faces of the boundary of this
// processor
bool overlapsThisProcessor
(
const point& centre,
const scalar radiusSqr
) const;
//- Find nearest intersection of line between start and end, (exposing
// underlying indexedOctree)
pointIndexHit findLine
(
const point& start,
const point& end
) const;
//- Find any intersection of line between start and end, (exposing
// underlying indexedOctree)
pointIndexHit findLineAny
(
const point& start,
const point& end
) const;
//- What processor is the given position on?
labelList processorPosition(const List<point>& pts) const;
//- What is the nearest processor to the given position?
labelList processorNearestPosition(const List<point>& pts) const;
//- Which processors are intersected by the line segment, returns all
// processors whose boundary patch is intersected by the sphere. By
// default this does not return the processor that the query is
// launched from, it is assumed that the point is on that processor.
// The index data member of the pointIndexHit is replaced with the
// processor index.
List<List<pointIndexHit> > intersectsProcessors
(
const List<point>& starts,
const List<point>& ends,
bool includeOwnProcessor = false
) const;
bool overlapsOtherProcessors
(
const point& centre,
const scalar& radiusSqr
) const;
labelList overlapProcessors
(
const point& centre,
const scalar radiusSqr
) const;
// //- Which processors overlap the given sphere, returns all processors
// // whose boundary patch is touched by the sphere or whom the sphere
// // is inside. By default this does not return the processor that the
// // query is launched from, it is assumed that the point is on that
// // processor.
// labelListList overlapsProcessors
// (
// const List<point>& centres,
// const List<scalar>& radiusSqrs,
// const Delaunay& T,
// bool includeOwnProcessor
// ) const;
// Access
//- Return access to the underlying mesh
inline const fvMesh& mesh() const;
//- Return access to the underlying tree
inline const indexedOctree<treeDataBPatch>& tree() const;
//- Return the boundBox of this processor
inline const treeBoundBox& procBounds() const;
//- Return the cell level of the underlying mesh
inline const labelList& cellLevel() const;
//- Return the point level of the underlying mesh
inline const labelList& pointLevel() const;
//- Return the current decomposition method
inline const decompositionMethod& decomposer() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "backgroundMeshDecompositionI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

67
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecompositionI.H
View File

@ -1,67 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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/>.
\*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const Foam::fvMesh& Foam::backgroundMeshDecomposition::mesh() const
{
return mesh_;
}
const Foam::indexedOctree<Foam::treeDataBPatch>&
Foam::backgroundMeshDecomposition::tree() const
{
return bFTreePtr_();
}
const Foam::treeBoundBox&
Foam::backgroundMeshDecomposition::procBounds() const
{
return allBackgroundMeshBounds_[Pstream::myProcNo()];
}
const Foam::labelList& Foam::backgroundMeshDecomposition::cellLevel() const
{
return meshCutter_.cellLevel();
}
const Foam::labelList& Foam::backgroundMeshDecomposition::pointLevel() const
{
return meshCutter_.pointLevel();
}
const Foam::decompositionMethod&
Foam::backgroundMeshDecomposition::decomposer() const
{
return decomposerPtr_();
}
// ************************************************************************* //

110
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellAspectRatioControl/cellAspectRatioControl.C
View File

@ -1,110 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "cellAspectRatioControl.H"
#include "vectorTools.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::cellAspectRatioControl::cellAspectRatioControl
(
const dictionary& motionDict
)
:
aspectRatioDict_(motionDict.subOrEmptyDict("cellAspectRatioControl")),
aspectRatio_(aspectRatioDict_.lookupOrDefault<scalar>("aspectRatio", 1.0)),
aspectRatioDirection_
(
aspectRatioDict_.lookupOrDefault<vector>
(
"aspectRatioDirection",
vector(0, 0, 0)
)
)
{
Info<< nl << " Cell Aspect Ratio Control" << nl
<< " Ratio : " << aspectRatio_ << nl
<< " Direction : " << aspectRatioDirection_ << nl << endl;
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::cellAspectRatioControl::~cellAspectRatioControl()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
void Foam::cellAspectRatioControl::updateCellSizeAndFaceArea
(
vector& alignmentDir,
scalar& targetFaceArea,
scalar& targetCellSize
) const
{
const scalar cosAngle = mag
(
vectorTools::cosPhi(alignmentDir, aspectRatioDirection_)
);
// Change target face area based on aspect ratio
targetFaceArea
+= targetFaceArea
*(aspectRatio_ - 1.0)
*(1.0 - cosAngle);
// Change target cell size based on aspect ratio
targetCellSize
+= targetCellSize
*(aspectRatio_ - 1.0)
*cosAngle;
alignmentDir *= 0.5*targetCellSize;
}
void Foam::cellAspectRatioControl::updateDeltaVector
(
const vector& alignmentDir,
const scalar targetCellSize,
const scalar rABMag,
vector& delta
) const
{
const scalar cosAngle = mag
(
vectorTools::cosPhi(alignmentDir, aspectRatioDirection_)
);
delta += 0.5
*delta
*cosAngle
*(targetCellSize/rABMag)
*(aspectRatio_ - 1.0);
}
// ************************************************************************* //

115
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellAspectRatioControl/cellAspectRatioControl.H
View File

@ -1,115 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Class
Foam::cellAspectRatioControl
Description
SourceFiles
cellAspectRatioControl.C
\*---------------------------------------------------------------------------*/
#ifndef cellAspectRatioControl_H
#define cellAspectRatioControl_H
#include "dictionary.H"
#include "vector.H"
#include "scalar.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cellAspectRatioControl Declaration
\*---------------------------------------------------------------------------*/
class cellAspectRatioControl
{
// Private data
const dictionary aspectRatioDict_;
const scalar aspectRatio_;
const vector aspectRatioDirection_;
// Private Member Functions
//- Disallow default bitwise copy construct
cellAspectRatioControl(const cellAspectRatioControl&);
//- Disallow default bitwise assignment
void operator=(const cellAspectRatioControl&);
public:
// Constructors
//- Construct from dictionary
cellAspectRatioControl
(
const dictionary& motionDict
);
//- Destructor
virtual ~cellAspectRatioControl();
// Member Functions
// Query
void updateCellSizeAndFaceArea
(
vector& alignmentDir,
scalar& targetFaceArea,
scalar& targetCellSize
) const;
void updateDeltaVector
(
const vector& alignmentDir,
const scalar targetCellSize,
const scalar rABMag,
vector& delta
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

930
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControl/cellShapeControl.C
View File

@ -1,930 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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 "cellShapeControl.H"
#include "pointField.H"
#include "scalarField.H"
#include "triadField.H"
#include "cellSizeAndAlignmentControl.H"
#include "searchableSurfaceControl.H"
#include "cellSizeFunction.H"
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
template <class Triangulation, class Type>
Foam::tmp<Foam::Field<Type> > Foam::cellShapeControl::filterFarPoints
(
const Triangulation& mesh,
const Field<Type>& field
)
{
tmp<Field<Type> > tNewField(new Field<Type>(field.size()));
Field<Type>& newField = tNewField();
label added = 0;
label count = 0;
for
(
typename Triangulation::Finite_vertices_iterator vit =
mesh.finite_vertices_begin();
vit != mesh.finite_vertices_end();
++vit
)
{
if (vit->real())
{
newField[added++] = field[count];
}
count++;
}
newField.resize(added);
return tNewField;
}
template <class Triangulation>
Foam::autoPtr<Foam::mapDistribute> Foam::cellShapeControl::buildReferredMap
(
const Triangulation& mesh,
labelList& indices
)
{
globalIndex globalIndexing(mesh.vertexCount());
DynamicList<label> dynIndices(mesh.vertexCount()/10);
for
(
typename Triangulation::Finite_vertices_iterator vit =
mesh.finite_vertices_begin();
vit != mesh.finite_vertices_end();
++vit
)
{
if (vit->referred())
{
dynIndices.append
(
globalIndexing.toGlobal(vit->procIndex(), vit->index())
);
}
}
indices.transfer(dynIndices);
List<Map<label> > compactMap;
return autoPtr<mapDistribute>
(
new mapDistribute
(
globalIndexing,
indices,
compactMap
)
);
}
template <class Triangulation>
Foam::autoPtr<Foam::mapDistribute> Foam::cellShapeControl::buildMap
(
const Triangulation& mesh,
labelListList& pointPoints
)
{
pointPoints.setSize(mesh.vertexCount());
globalIndex globalIndexing(mesh.vertexCount());
for
(
typename Triangulation::Finite_vertices_iterator vit =
mesh.finite_vertices_begin();
vit != mesh.finite_vertices_end();
++vit
)
{
if (!vit->real())
{
continue;
}
std::list<typename Triangulation::Vertex_handle> adjVerts;
mesh.finite_adjacent_vertices(vit, std::back_inserter(adjVerts));
DynamicList<label> indices(adjVerts.size());
for
(
typename std::list<typename Triangulation::Vertex_handle>::
const_iterator adjVertI = adjVerts.begin();
adjVertI != adjVerts.end();
++adjVertI
)
{
typename Triangulation::Vertex_handle vh = *adjVertI;
if (!vh->farPoint())
{
indices.append
(
globalIndexing.toGlobal(vh->procIndex(), vh->index())
);
}
}
pointPoints[vit->index()].transfer(indices);
}
List<Map<label> > compactMap;
return autoPtr<mapDistribute>
(
new mapDistribute
(
globalIndexing,
pointPoints,
compactMap
)
);
}
template <class Triangulation>
Foam::tmp<Foam::triadField> Foam::cellShapeControl::buildAlignmentField
(
const Triangulation& mesh
)
{
tmp<triadField> tAlignments
(
new triadField(mesh.vertexCount(), triad::unset)
);
triadField& alignments = tAlignments();
for
(
typename Triangulation::Finite_vertices_iterator vit =
mesh.finite_vertices_begin();
vit != mesh.finite_vertices_end();
++vit
)
{
if (!vit->real())
{
continue;
}
alignments[vit->index()] = vit->alignment();
}
return tAlignments;
}
template <class Triangulation>
Foam::tmp<Foam::pointField> Foam::cellShapeControl::buildPointField
(
const Triangulation& mesh
)
{
tmp<pointField> tPoints
(
new pointField(mesh.vertexCount(), point(GREAT, GREAT, GREAT))
);
pointField& points = tPoints();
for
(
typename Triangulation::Finite_vertices_iterator vit =
mesh.finite_vertices_begin();
vit != mesh.finite_vertices_end();
++vit
)
{
if (!vit->real())
{
continue;
}
points[vit->index()] = topoint(vit->point());
}
return tPoints;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::cellShapeControl::cellShapeControl
(
const Time& runTime,
const dictionary& motionDict,
const searchableSurfaces& allGeometry,
const conformationSurfaces& geometryToConformTo
)
:
dictionary(motionDict),
runTime_(runTime),
allGeometry_(allGeometry),
geometryToConformTo_(geometryToConformTo),
defaultCellSize_(readScalar(lookup("defaultCellSize"))),
minimumCellSize_(readScalar(lookup("minimumCellSize"))),
shapeControlMesh_(runTime),
aspectRatio_(motionDict),
sizeAndAlignment_
(
runTime,
motionDict.subDict("shapeControlFunctions"),
geometryToConformTo,
defaultCellSize_
)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::cellShapeControl::~cellShapeControl()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
Foam::scalarField Foam::cellShapeControl::cellSize
(
const pointField& pts
) const
{
scalarField cellSizes(pts.size());
forAll(pts, i)
{
cellSizes[i] = cellSize(pts[i]);
}
return cellSizes;
}
Foam::scalar Foam::cellShapeControl::cellSize(const point& pt) const
{
scalarList bary;
cellShapeControlMesh::Cell_handle ch;
shapeControlMesh_.barycentricCoords(pt, bary, ch);
scalar size = 0;
label nFarPoints = 0;
for (label pI = 0; pI < 4; ++pI)
{
if (ch->vertex(pI)->farPoint())
{
nFarPoints++;
}
}
if (shapeControlMesh_.is_infinite(ch))
{
// if (nFarPoints != 0)
// {
// for (label pI = 0; pI < 4; ++pI)
// {
// if (!ch->vertex(pI)->farPoint())
// {
// size = ch->vertex(pI)->targetCellSize();
// return size;
// }
// }
// }
// Look up nearest point
cellShapeControlMesh::Vertex_handle nearV =
shapeControlMesh_.nearest_vertex
(
toPoint<cellShapeControlMesh::Point>(pt)
);
size = nearV->targetCellSize();
}
else
{
if (nFarPoints != 0)
{
for (label pI = 0; pI < 4; ++pI)
{
if (!ch->vertex(pI)->farPoint())
{
size = ch->vertex(pI)->targetCellSize();
return size;
}
}
}
else
{
forAll(bary, pI)
{
size += bary[pI]*ch->vertex(pI)->targetCellSize();
}
}
}
return size;
}
//- Return the cell alignment at the given location
Foam::tensor Foam::cellShapeControl::cellAlignment(const point& pt) const
{
scalarList bary;
cellShapeControlMesh::Cell_handle ch;
shapeControlMesh_.barycentricCoords(pt, bary, ch);
tensor alignment = tensor::zero;
label nFarPoints = 0;
for (label pI = 0; pI < 4; ++pI)
{
if (ch->vertex(pI)->farPoint())
{
nFarPoints++;
}
}
if (shapeControlMesh_.is_infinite(ch) || nFarPoints == 4)
{
Pout<< "At Infinite vertex" << endl;
if (nFarPoints != 0)
{
for (label pI = 0; pI < 4; ++pI)
{
if (!ch->vertex(pI)->farPoint())
{
alignment = ch->vertex(pI)->alignment();
return alignment;
}
}
}
// cellShapeControlMesh::Vertex_handle nearV =
// shapeControlMesh_.nearest_vertex
// (
// toPoint<cellShapeControlMesh::Point>(pt)
// );
//
// alignment = nearV->alignment();
}
else
{
// forAll(bary, pI)
// {
// alignment += bary[pI]*ch->vertex(pI)->alignment();
// }
cellShapeControlMesh::Vertex_handle nearV =
shapeControlMesh_.nearest_vertex_in_cell
(
toPoint<cellShapeControlMesh::Point>(pt),
ch
);
alignment = nearV->alignment();
}
return alignment;
}
void Foam::cellShapeControl::cellSizeAndAlignment
(
const point& pt,
scalar& size,
tensor& alignment
) const
{
scalarList bary;
cellShapeControlMesh::Cell_handle ch;
shapeControlMesh_.barycentricCoords(pt, bary, ch);
alignment = tensor::zero;
size = 0;
label nFarPoints = 0;
for (label pI = 0; pI < 4; ++pI)
{
if (ch->vertex(pI)->farPoint())
{
nFarPoints++;
}
}
if (shapeControlMesh_.is_infinite(ch))
{
if (nFarPoints != 0)
{
for (label pI = 0; pI < 4; ++pI)
{
if (!ch->vertex(pI)->farPoint())
{
size = ch->vertex(pI)->targetCellSize();
alignment = ch->vertex(pI)->alignment();
return;
}
}
}
// cellShapeControlMesh::Vertex_handle nearV =
// shapeControlMesh_.nearest_vertex
// (
// toPoint<cellShapeControlMesh::Point>(pt)
// );
//
// size = nearV->targetCellSize();
// alignment = nearV->alignment();
}
else
{
if (nFarPoints != 0)
{
for (label pI = 0; pI < 4; ++pI)
{
if (!ch->vertex(pI)->farPoint())
{
size = ch->vertex(pI)->targetCellSize();
alignment = ch->vertex(pI)->alignment();
return;
}
}
}
else
{
// triad tri;
forAll(bary, pI)
{
size += bary[pI]*ch->vertex(pI)->targetCellSize();
// triad triTmp2 = ch->vertex(pI)->alignment();
// tri += triTmp2*bary[pI];
}
// tri.normalize();
// tri.orthogonalize();
// tri = tri.sortxyz();
//
// alignment = tri;
cellShapeControlMesh::Vertex_handle nearV =
shapeControlMesh_.nearest_vertex
(
toPoint<cellShapeControlMesh::Point>(pt)
);
alignment = nearV->alignment();
}
}
}
void Foam::cellShapeControl::initialMeshPopulation
(
const autoPtr<backgroundMeshDecomposition>& decomposition
)
{
// Need to pass in the background mesh decomposition so that can test if
// a point to insert is on the processor.
if (Pstream::parRun())
{
shapeControlMesh_.insertBoundingPoints(decomposition().procBounds());
}
else
{
shapeControlMesh_.insertBoundingPoints(allGeometry_.bounds());
}
const PtrList<cellSizeAndAlignmentControl>& controlFunctions =
sizeAndAlignment_.controlFunctions();
forAll(controlFunctions, fI)
{
const cellSizeAndAlignmentControl& controlFunction =
controlFunctions[fI];
Info<< "Inserting points from " << controlFunction.name()
<< " (" << controlFunction.type() << ")" << endl;
pointField pts;
scalarField sizes;
triadField alignments;
controlFunction.initialVertices(pts, sizes, alignments);
List<Vb> vertices(pts.size());
// Clip the minimum size
forAll(vertices, vI)
{
vertices[vI] = Vb(pts[vI], Vb::vtInternal);
vertices[vI].targetCellSize() = max(sizes[vI], minimumCellSize_);
vertices[vI].alignment() = alignments[vI];
}
pts.clear();
sizes.clear();
alignments.clear();
label nRejected = 0;
PackedBoolList keepVertex(vertices.size(), true);
if (Pstream::parRun())
{
forAll(vertices, vI)
{
const bool onProc = decomposition().positionOnThisProcessor
(
topoint(vertices[vI].point())
);
if (!onProc)
{
keepVertex[vI] = false;
}
}
}
inplaceSubset(keepVertex, vertices);
const label preInsertedSize = shapeControlMesh_.number_of_vertices();
shapeControlMesh_.rangeInsertWithInfo(vertices.begin(), vertices.end());
Info<< " Inserted "
<< returnReduce
(
shapeControlMesh_.number_of_vertices()
- preInsertedSize, sumOp<label>()
)
<< "/" << vertices.size()
<< endl;
}
}
Foam::label Foam::cellShapeControl::refineMesh
(
const autoPtr<backgroundMeshDecomposition>& decomposition
)
{
const pointField cellCentres(shapeControlMesh_.cellCentres());
Info<< " Created cell centres" << endl;
const PtrList<cellSizeAndAlignmentControl>& controlFunctions =
sizeAndAlignment_.controlFunctions();
DynamicList<Vb> verts(shapeControlMesh_.number_of_vertices());
forAll(cellCentres, cellI)
{
const Foam::point& pt = cellCentres[cellI];
if (!geometryToConformTo_.inside(pt))
{
continue;
}
scalarList bary;
cellShapeControlMesh::Cell_handle ch;
shapeControlMesh_.barycentricCoords(pt, bary, ch);
if (shapeControlMesh_.is_infinite(ch))
{
continue;
}
scalar interpolatedSize = 0;
forAll(bary, pI)
{
interpolatedSize += bary[pI]*ch->vertex(pI)->targetCellSize();
}
label lastPriority = labelMax;
scalar lastCellSize = GREAT;
forAll(controlFunctions, fI)
{
const cellSizeAndAlignmentControl& controlFunction =
controlFunctions[fI];
if (controlFunction.priority() > lastPriority)
{
continue;
}
if (isA<searchableSurfaceControl>(controlFunction))
{
const cellSizeFunction& sizeFunction =
dynamicCast<const searchableSurfaceControl>
(
controlFunction
).sizeFunction();
scalar cellSize = 0;
if (sizeFunction.cellSize(pt, cellSize))
{
if (controlFunction.priority() == lastPriority)
{
if (cellSize < lastCellSize)
{
lastCellSize = cellSize;
}
}
else
{
lastCellSize = cellSize;
}
lastPriority = controlFunction.priority();
}
}
}
if
(
lastCellSize < GREAT
//&& mag(interpolatedSize - lastCellSize)/lastCellSize > 0.2
)
{
if (Pstream::parRun())
{
if (!decomposition().positionOnThisProcessor(pt))
{
continue;
}
}
verts.append
(
Vb
(
toPoint<cellShapeControlMesh::Point>(pt),
Vb::vtInternal
)
);
verts.last().targetCellSize() = lastCellSize;
verts.last().alignment() = triad::unset;
}
}
shapeControlMesh_.insertPoints(verts);
return verts.size();
}
void Foam::cellShapeControl::smoothMesh()
{
label maxSmoothingIterations = readLabel(lookup("maxSmoothingIterations"));
scalar minResidual = 0;
labelListList pointPoints;
autoPtr<mapDistribute> meshDistributor = buildMap
(
shapeControlMesh_,
pointPoints
);
triadField alignments(buildAlignmentField(shapeControlMesh_));
pointField points(buildPointField(shapeControlMesh_));
// Setup the sizes and alignments on each point
triadField fixedAlignments(shapeControlMesh_.vertexCount(), triad::unset);
for
(
CellSizeDelaunay::Finite_vertices_iterator vit =
shapeControlMesh_.finite_vertices_begin();
vit != shapeControlMesh_.finite_vertices_end();
++vit
)
{
if (vit->real())
{
fixedAlignments[vit->index()] = vit->alignment();
}
}
Info<< nl << "Smoothing alignments" << endl;
for (label iter = 0; iter < maxSmoothingIterations; iter++)
{
Info<< "Iteration " << iter;
meshDistributor().distribute(points);
meshDistributor().distribute(alignments);
scalar residual = 0;
triadField triadAv(alignments.size(), triad::unset);
forAll(pointPoints, pI)
{
const labelList& pPoints = pointPoints[pI];
if (pPoints.empty())
{
continue;
}
triad& newTriad = triadAv[pI];
forAll(pPoints, adjPointI)
{
const label adjPointIndex = pPoints[adjPointI];
scalar dist = mag(points[pI] - points[adjPointIndex]);
triad tmpTriad = alignments[adjPointIndex];
for (direction dir = 0; dir < 3; dir++)
{
if (tmpTriad.set(dir))
{
tmpTriad[dir] *= (1.0/dist);
}
}
newTriad += tmpTriad;
}
newTriad.normalize();
newTriad.orthogonalize();
newTriad = newTriad.sortxyz();
// Enforce the boundary conditions
const triad& fixedAlignment = fixedAlignments[pI];
label nFixed = 0;
forAll(fixedAlignment, dirI)
{
if (fixedAlignment.set(dirI))
{
nFixed++;
}
}
if (nFixed == 1)
{
forAll(fixedAlignment, dirI)
{
if (fixedAlignment.set(dirI))
{
newTriad.align(fixedAlignment[dirI]);
}
}
}
else if (nFixed == 2)
{
forAll(fixedAlignment, dirI)
{
if (fixedAlignment.set(dirI))
{
newTriad[dirI] = fixedAlignment[dirI];
}
else
{
newTriad[dirI] = triad::unset[dirI];
}
}
newTriad.orthogonalize();
}
else if (nFixed == 3)
{
forAll(fixedAlignment, dirI)
{
if (fixedAlignment.set(dirI))
{
newTriad[dirI] = fixedAlignment[dirI];
}
}
}
const triad& oldTriad = alignments[pI];
for (direction dir = 0; dir < 3; ++dir)
{
if
(
newTriad.set(dir)
&& oldTriad.set(dir)
//&& !fixedAlignment.set(dir)
)
{
scalar dotProd = (oldTriad[dir] & newTriad[dir]);
scalar diff = mag(dotProd) - 1.0;
residual += mag(diff);
}
}
// if (iter == 198 || iter == 199)
// {
// Info<< "Triad" << nl
// << " Fixed (" << nFixed << ") = " << fixedAlignment
// << nl
// << " Old = " << oldTriad << nl
// << " Pre-Align= " << triadAv[pI] << nl
// << " New = " << newTriad << nl
// << " Residual = " << residual << endl;
// }
}
forAll(alignments, pI)
{
alignments[pI] = triadAv[pI].sortxyz();
}
reduce(residual, sumOp<scalar>());
Info<< ", Residual = " << residual << endl;
if (iter > 0 && residual <= minResidual)
{
break;
}
}
meshDistributor().distribute(alignments);
for
(
CellSizeDelaunay::Finite_vertices_iterator vit =
shapeControlMesh_.finite_vertices_begin();
vit != shapeControlMesh_.finite_vertices_end();
++vit
)
{
if (vit->real())
{
vit->alignment() = alignments[vit->index()];
}
}
labelList referredPoints;
autoPtr<mapDistribute> referredDistributor = buildReferredMap
(
shapeControlMesh_,
referredPoints
);
alignments.setSize(shapeControlMesh_.vertexCount());
referredDistributor().distribute(alignments);
label referredI = 0;
for
(
CellSizeDelaunay::Finite_vertices_iterator vit =
shapeControlMesh_.finite_vertices_begin();
vit != shapeControlMesh_.finite_vertices_end();
++vit
)
{
if (vit->referred())
{
vit->alignment() = alignments[referredPoints[referredI++]];
}
}
}
// ************************************************************************* //

213
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControl/cellShapeControl.H
View File

@ -1,213 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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/>.
Class
Foam::cellShapeControl
Description
SourceFiles
cellShapeControlI.H
cellShapeControl.C
\*---------------------------------------------------------------------------*/
#ifndef cellShapeControl_H
#define cellShapeControl_H
#include "dictionary.H"
#include "autoPtr.H"
#include "tensor.H"
#include "point.H"
#include "primitiveFieldsFwd.H"
#include "pointFieldFwd.H"
#include "Time.H"
#include "searchableSurfaces.H"
#include "conformationSurfaces.H"
#include "cellAspectRatioControl.H"
#include "cellSizeAndAlignmentControls.H"
#include "cellShapeControlMesh.H"
#include "backgroundMeshDecomposition.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cellShapeControl Declaration
\*---------------------------------------------------------------------------*/
class cellShapeControl
:
public dictionary
{
// Private data
const Time& runTime_;
const searchableSurfaces& allGeometry_;
const conformationSurfaces& geometryToConformTo_;
const scalar defaultCellSize_;
const scalar minimumCellSize_;
cellShapeControlMesh shapeControlMesh_;
cellAspectRatioControl aspectRatio_;
cellSizeAndAlignmentControls sizeAndAlignment_;
// Private Member Functions
template <class Triangulation, class Type>
tmp<Field<Type> > filterFarPoints
(
const Triangulation& mesh,
const Field<Type>& field
);
template <class Triangulation>
autoPtr<mapDistribute> buildMap
(
const Triangulation& mesh,
labelListList& pointPoints
);
template <class Triangulation>
autoPtr<mapDistribute> buildReferredMap
(
const Triangulation& mesh,
labelList& indices
);
template <class Triangulation>
tmp<triadField> buildAlignmentField(const Triangulation& mesh);
template <class Triangulation>
tmp<pointField> buildPointField(const Triangulation& mesh);
//- Disallow default bitwise copy construct
cellShapeControl(const cellShapeControl&);
//- Disallow default bitwise assignment
void operator=(const cellShapeControl&);
public:
//- Runtime type information
ClassName("cellShapeControl");
// Constructors
//- Construct from dictionary and references to conformalVoronoiMesh and
// searchableSurfaces
cellShapeControl
(
const Time& runTime,
const dictionary& cellShapeControlDict,
const searchableSurfaces& allGeometry,
const conformationSurfaces& geometryToConformTo
);
//- Destructor
~cellShapeControl();
// Member Functions
// Access
inline const scalar& defaultCellSize() const;
inline cellShapeControlMesh& shapeControlMesh();
inline const cellShapeControlMesh& shapeControlMesh() const;
inline const cellAspectRatioControl& aspectRatio() const;
inline const cellSizeAndAlignmentControls& sizeAndAlignment() const;
// Query
//- Return the cell size at the given location
scalar cellSize(const point& pt) const;
scalarField cellSize(const pointField& pts) const;
//- Return the cell alignment at the given location
tensor cellAlignment(const point& pt) const;
void cellSizeAndAlignment
(
const point& pt,
scalar& size,
tensor& alignment
) const;
// Edit
void initialMeshPopulation
(
const autoPtr<backgroundMeshDecomposition>& decomposition
);
label refineMesh
(
const autoPtr<backgroundMeshDecomposition>& decomposition
);
void smoothMesh();
//- Add a control point with a specified size and alignment
// virtual void addControlPoint
// (
// const point& pt,
// const scalar& size,
// const tensor& alignment
// );
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "cellShapeControlI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

55
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControl/cellShapeControlI.H
View File

@ -1,55 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
\*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline Foam::cellShapeControlMesh&
Foam::cellShapeControl::shapeControlMesh()
{
return shapeControlMesh_;
}
inline const Foam::cellShapeControlMesh&
Foam::cellShapeControl::shapeControlMesh() const
{
return shapeControlMesh_;
}
inline const Foam::scalar& Foam::cellShapeControl::defaultCellSize() const
{
return defaultCellSize_;
}
inline const Foam::cellAspectRatioControl&
Foam::cellShapeControl::aspectRatio() const
{
return aspectRatio_;
}
// ************************************************************************* //

760
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMesh.C
View File

@ -1,760 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "cellShapeControlMesh.H"
#include "pointIOField.H"
#include "scalarIOField.H"
#include "tensorIOField.H"
#include "tetrahedron.H"
#include "plane.H"
#include "transform.H"
#include "meshTools.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(cellShapeControlMesh, 0);
}
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
//Foam::tensor Foam::cellShapeControlMesh::requiredAlignment
//(
// const Foam::point& pt,
// const searchableSurfaces& allGeometry,
// const conformationSurfaces& geometryToConformTo
//) const
//{
// pointIndexHit surfHit;
// label hitSurface;
//
// geometryToConformTo.findSurfaceNearest
// (
// pt,
// sqr(GREAT),
// surfHit,
// hitSurface
// );
//
// if (!surfHit.hit())
// {
// FatalErrorIn
// (
// "Foam::tensor Foam::conformalVoronoiMesh::requiredAlignment"
// ) << "findSurfaceNearest did not find a hit across the surfaces."
// << exit(FatalError) << endl;
// }
//
// // Primary alignment
//
// vectorField norm(1);
//
// allGeometry[hitSurface].getNormal
// (
// List<pointIndexHit>(1, surfHit),
// norm
// );
//
// const vector np = norm[0];
//
// // Generate equally spaced 'spokes' in a circle normal to the
// // direction from the vertex to the closest point on the surface
// // and look for a secondary intersection.
//
// const vector d = surfHit.hitPoint() - pt;
//
// const tensor Rp = rotationTensor(vector(0,0,1), np);
//
// const label s = 36;//cvMeshControls().alignmentSearchSpokes();
//
// scalar closestSpokeHitDistance = GREAT;
//
// pointIndexHit closestSpokeHit;
//
// label closestSpokeSurface = -1;
//
// const scalar spanMag = geometryToConformTo.globalBounds().mag();
//
// for (label i = 0; i < s; i++)
// {
// vector spoke
// (
// Foam::cos(i*constant::mathematical::twoPi/s),
// Foam::sin(i*constant::mathematical::twoPi/s),
// 0
// );
//
// spoke *= spanMag;
//
// spoke = Rp & spoke;
//
// pointIndexHit spokeHit;
//
// label spokeSurface = -1;
//
// // internal spoke
//
// geometryToConformTo.findSurfaceNearestIntersection
// (
// pt,
// pt + spoke,
// spokeHit,
// spokeSurface
// );
//
// if (spokeHit.hit())
// {
// scalar spokeHitDistance = mag
// (
// spokeHit.hitPoint() - pt
// );
//
// if (spokeHitDistance < closestSpokeHitDistance)
// {
// closestSpokeHit = spokeHit;
// closestSpokeSurface = spokeSurface;
// closestSpokeHitDistance = spokeHitDistance;
// }
// }
//
// //external spoke
//
// Foam::point mirrorPt = pt + 2*d;
//
// geometryToConformTo.findSurfaceNearestIntersection
// (
// mirrorPt,
// mirrorPt + spoke,
// spokeHit,
// spokeSurface
// );
//
// if (spokeHit.hit())
// {
// scalar spokeHitDistance = mag
// (
// spokeHit.hitPoint() - mirrorPt
// );
//
// if (spokeHitDistance < closestSpokeHitDistance)
// {
// closestSpokeHit = spokeHit;
// closestSpokeSurface = spokeSurface;
// closestSpokeHitDistance = spokeHitDistance;
// }
// }
// }
//
// if (closestSpokeSurface == -1)
// {
//// WarningIn
//// (
//// "conformalVoronoiMesh::requiredAlignment"
//// "("
//// "const Foam::point& pt"
//// ") const"
//// ) << "No secondary surface hit found in spoke search "
//// << "using " << s
//// << " spokes, try increasing alignmentSearchSpokes."
//// << endl;
//
// return I;
// }
//
// // Auxiliary alignment generated by spoke intersection normal.
//
// allGeometry[closestSpokeSurface].getNormal
// (
// List<pointIndexHit>(1, closestSpokeHit),
// norm
// );
//
// const vector& na = norm[0];
//
// // Secondary alignment
// vector ns = np ^ na;
//
// if (mag(ns) < SMALL)
// {
// FatalErrorIn("conformalVoronoiMesh::requiredAlignment")
// << "Parallel normals detected in spoke search." << nl
// << "point: " << pt << nl
// << "closest surface point: " << surfHit.hitPoint() << nl
// << "closest spoke hit: " << closestSpokeHit.hitPoint() << nl
// << "np: " << surfHit.hitPoint() + np << nl
// << "ns: " << closestSpokeHit.hitPoint() + na << nl
// << exit(FatalError);
// }
//
// ns /= mag(ns);
//
// tensor Rs = rotationTensor((Rp & vector(0,1,0)), ns);
//
// return (Rs & Rp);
//}
Foam::label Foam::cellShapeControlMesh::removePoints()
{
label nRemoved = 0;
for
(
CellSizeDelaunay::Finite_vertices_iterator vit =
finite_vertices_begin();
vit != finite_vertices_end();
++vit
)
{
std::list<Vertex_handle> verts;
adjacent_vertices(vit, std::back_inserter(verts));
bool removePt = true;
for
(
std::list<Vertex_handle>::iterator aVit = verts.begin();
aVit != verts.end();
++aVit
)
{
Vertex_handle avh = *aVit;
scalar diff =
mag(avh->targetCellSize() - vit->targetCellSize())
/max(vit->targetCellSize(), 1e-6);
if (diff > 0.05)
{
removePt = false;
}
}
if (removePt)
{
remove(vit);
nRemoved++;
}
}
return nRemoved;
}
Foam::tmp<Foam::pointField> Foam::cellShapeControlMesh::cellCentres() const
{
tmp<pointField> tcellCentres(new pointField(number_of_finite_cells()));
pointField& cellCentres = tcellCentres();
label count = 0;
for
(
CellSizeDelaunay::Finite_cells_iterator c = finite_cells_begin();
c != finite_cells_end();
++c
)
{
if (c->hasFarPoint())
{
continue;
}
scalarList bary;
cellShapeControlMesh::Cell_handle ch;
const Foam::point centre = topoint
(
CGAL::centroid<baseK>
(
c->vertex(0)->point(),
c->vertex(1)->point(),
c->vertex(2)->point(),
c->vertex(3)->point()
)
);
cellCentres[count++] = centre;
}
cellCentres.resize(count);
return tcellCentres;
}
void Foam::cellShapeControlMesh::writeTriangulation()
{
OFstream str
(
"refinementTriangulation_"
+ name(Pstream::myProcNo())
+ ".obj"
);
label count = 0;
Info<< "Write refinementTriangulation" << endl;
for
(
CellSizeDelaunay::Finite_edges_iterator e = finite_edges_begin();
e != finite_edges_end();
++e
)
{
Cell_handle c = e->first;
Vertex_handle vA = c->vertex(e->second);
Vertex_handle vB = c->vertex(e->third);
// Don't write far edges
if (vA->farPoint() || vB->farPoint())
{
continue;
}
// Don't write unowned edges
if (vA->referred() && vB->referred())
{
continue;
}
pointFromPoint p1 = topoint(vA->point());
pointFromPoint p2 = topoint(vB->point());
meshTools::writeOBJ(str, p1, p2, count);
}
if (is_valid())
{
Info<< " Triangulation is valid" << endl;
}
else
{
FatalErrorIn
(
"Foam::triangulatedMesh::writeRefinementTriangulation()"
) << "Triangulation is not valid"
<< abort(FatalError);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::cellShapeControlMesh::cellShapeControlMesh(const Time& runTime)
:
runTime_(runTime),
defaultCellSize_(0.0)
{}
//Foam::triangulatedMesh::triangulatedMesh
//(
// const Time& runTime,
// const fileName& pointsFile,
// const fileName& sizesFile,
// const fileName& alignmentsFile,
// const scalar& defaultCellSize
//)
//:
// defaultCellSize_(defaultCellSize)
//{
// Info<< " Reading points from file : " << pointsFile << endl;
//
// pointIOField points
// (
// IOobject
// (
// pointsFile,
// runTime.constant(),
// runTime,
// IOobject::MUST_READ,
// IOobject::NO_WRITE
// )
// );
//
// Info<< " Reading sizes from file : " << sizesFile << endl;
//
// scalarIOField sizes
// (
// IOobject
// (
// sizesFile,
// runTime.constant(),
// runTime,
// IOobject::MUST_READ,
// IOobject::NO_WRITE
// )
// );
//
// Info<< " Reading alignments from file : " << alignmentsFile << endl;
//
// tensorIOField alignments
// (
// IOobject
// (
// alignmentsFile,
// runTime.constant(),
// runTime,
// IOobject::MUST_READ,
// IOobject::NO_WRITE
// )
// );
//
// Info<< " Number of points : " << points.size() << endl;
// Info<< " Minimum size : " << min(sizes) << endl;
// Info<< " Average size : " << average(sizes) << endl;
// Info<< " Maximum size : " << max(sizes) << endl;
//
// forAll(points, pI)
// {
// size_t nVert = number_of_vertices();
//
// Vertex_handle v = insert
// (
// Point(points[pI].x(), points[pI].y(), points[pI].z())
// );
//
// if (number_of_vertices() == nVert)
// {
// Info<< " Failed to insert point : " << points[pI] << endl;
// }
//
// v->targetCellSize() = sizes[pI];
//
// const tensor& alignment = alignments[pI];
//
//
//
// v->alignment() = alignment;
// }
//
//// scalar factor = 1.0;
//// label maxIteration = 1;
////
//// for (label iteration = 0; iteration < maxIteration; ++iteration)
//// {
//// Info<< "Iteration : " << iteration << endl;
////
//// label nRefined = refineTriangulation(factor);
////
//// Info<< " Number of cells refined in refinement iteration : "
//// << nRefined << nl << endl;
////
//// if (nRefined <= 0 && iteration != 0)
//// {
//// break;
//// }
////
//// factor *= 1.5;
//// }
//
// //writeRefinementTriangulation();
//}
//Foam::triangulatedMesh::triangulatedMesh
//(
// const Time& runTime,
// const DynamicList<Foam::point>& points,
// const DynamicList<scalar>& sizes,
// const DynamicList<tensor>& alignments,
// const scalar& defaultCellSize
//)
//:
// defaultCellSize_(defaultCellSize)
//{
// forAll(points, pI)
// {
// size_t nVert = number_of_vertices();
//
// Vertex_handle v = insert
// (
// Point(points[pI].x(), points[pI].y(), points[pI].z())
// );
//
// if (number_of_vertices() == nVert)
// {
// Info<< "Failed to insert point : " << points[pI] << endl;
// }
//
// v->targetCellSize() = sizes[pI];
//
// v->alignment() = alignments[pI];
// }
//
// //writeRefinementTriangulation();
//
// Info<< nl << "Refinement triangulation information: " << endl;
// Info<< " Number of vertices: " << label(number_of_vertices()) << endl;
// Info<< " Number of cells : "
// << label(number_of_finite_cells()) << endl;
// Info<< " Number of faces : "
// << label(number_of_finite_facets()) << endl;
// Info<< " Number of edges : "
// << label(number_of_finite_edges()) << endl;
// Info<< " Dimensionality : " << label(dimension()) << nl << endl;
//}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::cellShapeControlMesh::~cellShapeControlMesh()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
void Foam::cellShapeControlMesh::barycentricCoords
(
const Foam::point& pt,
scalarList& bary,
Cell_handle& ch
) const
{
// Use the previous cell handle as a hint on where to start searching
ch = locate
(
Point(pt.x(), pt.y(), pt.z())
);
if (!is_infinite(ch))
{
oldCellHandle_ = ch;
tetPointRef tet
(
topoint(ch->vertex(0)->point()),
topoint(ch->vertex(1)->point()),
topoint(ch->vertex(2)->point()),
topoint(ch->vertex(3)->point())
);
tet.barycentric(pt, bary);
}
}
Foam::boundBox Foam::cellShapeControlMesh::bounds() const
{
DynamicList<Foam::point> pts(number_of_vertices());
for
(
Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
++vit
)
{
if (vit->real())
{
pts.append(topoint(vit->point()));
}
}
boundBox bb(pts);
return bb;
}
void Foam::cellShapeControlMesh::distribute
(
const backgroundMeshDecomposition& decomposition
)
{
if (!Pstream::parRun())
{
return;
}
autoPtr<mapDistribute> mapDist =
DistributedDelaunayMesh<CellSizeDelaunay>::distribute(decomposition);
DynamicList<Foam::point> points(number_of_vertices());
DynamicList<scalar> sizes(number_of_vertices());
DynamicList<tensor> alignments(number_of_vertices());
for
(
Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
++vit
)
{
if (vit->real())
{
points.append(topoint(vit->point()));
sizes.append(vit->targetCellSize());
alignments.append(vit->alignment());
}
}
mapDist().distribute(points);
mapDist().distribute(sizes);
mapDist().distribute(alignments);
// Reset the entire tessellation
DelaunayMesh<CellSizeDelaunay>::reset();
Info<< nl << " Inserting distributed tessellation" << endl;
insertBoundingPoints(decomposition.procBounds());
// Internal points have to be inserted first
DynamicList<Vb> verticesToInsert(points.size());
forAll(points, pI)
{
verticesToInsert.append
(
Vb
(
toPoint<Point>(points[pI]),
-1,
Vb::vtInternal,
Pstream::myProcNo()
)
);
verticesToInsert.last().targetCellSize() = sizes[pI];
verticesToInsert.last().alignment() = alignments[pI];
}
this->rangeInsertWithInfo
(
verticesToInsert.begin(),
verticesToInsert.end(),
true
);
sync(decomposition.procBounds());
Info<< " Total number of vertices after redistribution "
<< returnReduce(label(number_of_vertices()), sumOp<label>()) << endl;
}
Foam::tensorField Foam::cellShapeControlMesh::dumpAlignments() const
{
tensorField alignmentsTmp(number_of_vertices(), tensor::zero);
label count = 0;
for
(
Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
++vit
)
{
alignmentsTmp[count++] = vit->alignment();
}
return alignmentsTmp;
}
void Foam::cellShapeControlMesh::insertBoundingPoints(const boundBox& bb)
{
boundBox bbInflate = bb;
bbInflate.inflate(10);
pointField pts(bbInflate.points());
forAll(pts, pI)
{
insertFar(pts[pI]);
}
}
void Foam::cellShapeControlMesh::write() const
{
Info<< "Writing cell size and alignment mesh" << endl;
const fileName name("cellSizeAndAlignmentMesh");
// Reindex the cells
label cellCount = 0;
for
(
Finite_cells_iterator cit = finite_cells_begin();
cit != finite_cells_end();
++cit
)
{
if (!cit->hasFarPoint() && !is_infinite(cit))
{
cit->cellIndex() = cellCount++;
}
}
labelList vertexMap;
labelList cellMap;
autoPtr<fvMesh> meshPtr = DelaunayMesh<CellSizeDelaunay>::createMesh
(
name,
runTime_,
vertexMap,
cellMap
);
const fvMesh& mesh = meshPtr();
pointScalarField sizes
(
IOobject
(
"sizes",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
pointMesh::New(mesh),
scalar(0)
);
for
(
Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
++vit
)
{
if (!vit->farPoint())
{
sizes[vertexMap[vit->index()]] = vit->targetCellSize();
}
}
mesh.write();
}
// ************************************************************************* //

168
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMesh.H
View File

@ -1,168 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Class
Foam::cellShapeControlMesh
Description
SourceFiles
cellShapeControlMeshI.H
cellShapeControlMesh.C
\*---------------------------------------------------------------------------*/
#ifndef cellShapeControlMesh_H
#define cellShapeControlMesh_H
#include "Time.H"
#include "scalar.H"
#include "point.H"
#include "tensor.H"
#include "triad.H"
#include "fileName.H"
#include "searchableSurfaces.H"
#include "conformationSurfaces.H"
#include "DistributedDelaunayMesh.H"
#include "CGALTriangulation3Ddefs.H"
#include "backgroundMeshDecomposition.H"
#include "boundBox.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cellShapeControlMesh Declaration
\*---------------------------------------------------------------------------*/
class cellShapeControlMesh
:
public DistributedDelaunayMesh<CellSizeDelaunay>
{
public:
typedef CellSizeDelaunay::Cell_handle Cell_handle;
typedef CellSizeDelaunay::Vertex_handle Vertex_handle;
typedef CellSizeDelaunay::Point Point;
private:
// Private data
const Time& runTime_;
mutable Cell_handle oldCellHandle_;
const scalar defaultCellSize_;
// Private Member Functions
//- Disallow default bitwise copy construct
cellShapeControlMesh(const cellShapeControlMesh&);
//- Disallow default bitwise assignment
void operator=(const cellShapeControlMesh&);
public:
//- Runtime type information
ClassName("cellShapeControlMesh");
// Constructors
explicit cellShapeControlMesh(const Time& runTime);
//- Destructor
~cellShapeControlMesh();
// Member Functions
// Query
//- Calculate and return the barycentric coordinates for
// interpolating quantities on the background mesh
void barycentricCoords
(
const Foam::point& pt,
scalarList& bary,
Cell_handle& ch
) const;
boundBox bounds() const;
// Edit
label removePoints();
//- Get the centres of all the tets
tmp<pointField> cellCentres() const;
inline Vertex_handle insert
(
const Foam::point& pt,
const scalar& size,
const triad& alignment,
const Foam::indexedVertexEnum::vertexType type = Vb::vtInternal
);
inline Vertex_handle insertFar
(
const Foam::point& pt
);
void distribute
(
const backgroundMeshDecomposition& decomposition
);
tensorField dumpAlignments() const;
void insertBoundingPoints(const boundBox& bb);
void writeTriangulation();
void write() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "cellShapeControlMeshI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

68
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMeshI.H
View File

@ -1,68 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
\*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::cellShapeControlMesh::Vertex_handle Foam::cellShapeControlMesh::insert
(
const Foam::point& pt,
const scalar& size,
const triad& alignment,
const Foam::indexedVertexEnum::vertexType type
)
{
Vertex_handle v = CellSizeDelaunay::insert
(
Point(pt.x(), pt.y(), pt.z())
);
v->type() = type;
v->index() = getNewVertexIndex();
v->procIndex() = Pstream::myProcNo();
v->targetCellSize() = size;
v->alignment() = tensor(alignment.x(), alignment.y(), alignment.z());
return v;
}
Foam::cellShapeControlMesh::Vertex_handle Foam::cellShapeControlMesh::insertFar
(
const Foam::point& pt
)
{
Vertex_handle v = CellSizeDelaunay::insert
(
Point(pt.x(), pt.y(), pt.z())
);
v->type() = Vb::vtFar;
// v->type() = Vb::vtExternalFeaturePoint;
v->index() = getNewVertexIndex();
v->procIndex() = Pstream::myProcNo();
return v;
}
// ************************************************************************* //

120
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl.C
View File

@ -1,120 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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 "cellSizeAndAlignmentControl.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(cellSizeAndAlignmentControl, 0);
defineRunTimeSelectionTable(cellSizeAndAlignmentControl, dictionary);
}
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::cellSizeAndAlignmentControl::cellSizeAndAlignmentControl
(
const Time& runTime,
const word& name,
const dictionary& controlFunctionDict,
const conformationSurfaces& allGeometry
)
:
runTime_(runTime),
name_(name)
{}
// * * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::cellSizeAndAlignmentControl>
Foam::cellSizeAndAlignmentControl::New
(
const Time& runTime,
const word& name,
const dictionary& controlFunctionDict,
const conformationSurfaces& allGeometry
)
{
word cellSizeAndAlignmentControlTypeName
(
controlFunctionDict.lookup("type")
);
Info<< nl << "Selecting cellSizeAndAlignmentControl "
<< cellSizeAndAlignmentControlTypeName << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find
(
cellSizeAndAlignmentControlTypeName
);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"cellSizeAndAlignmentControl::New()"
) << "Unknown cellSizeAndAlignmentControl type "
<< cellSizeAndAlignmentControlTypeName
<< endl << endl
<< "Valid cellSizeAndAlignmentControl types are :" << endl
<< dictionaryConstructorTablePtr_->toc()
<< exit(FatalError);
}
return autoPtr<cellSizeAndAlignmentControl>
(
cstrIter()
(
runTime,
name,
controlFunctionDict,
allGeometry
)
);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::cellSizeAndAlignmentControl::~cellSizeAndAlignmentControl()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
// ************************************************************************* //

160
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl.H
View File

@ -1,160 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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/>.
Class
Foam::cellSizeAndAlignmentControl
Description
SourceFiles
cellSizeAndAlignmentControlI.H
cellSizeAndAlignmentControl.C
\*---------------------------------------------------------------------------*/
#ifndef cellSizeAndAlignmentControl_H
#define cellSizeAndAlignmentControl_H
#include "dictionary.H"
#include "conformationSurfaces.H"
#include "Time.H"
#include "quaternion.H"
#include "triadField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cellSizeAndAlignmentControl Declaration
\*---------------------------------------------------------------------------*/
class cellSizeAndAlignmentControl
{
protected:
const Time& runTime_;
private:
// Private data
const word name_;
// Private Member Functions
//- Disallow default bitwise copy construct
cellSizeAndAlignmentControl(const cellSizeAndAlignmentControl&);
//- Disallow default bitwise assignment
void operator=(const cellSizeAndAlignmentControl&);
public:
//- Runtime type information
TypeName("cellSizeAndAlignmentControl");
// Declare run-time constructor selection table
declareRunTimeSelectionTable
(
autoPtr,
cellSizeAndAlignmentControl,
dictionary,
(
const Time& runTime,
const word& name,
const dictionary& controlFunctionDict,
const conformationSurfaces& allGeometry
),
(runTime, name, controlFunctionDict, allGeometry)
);
// Constructors
//- Construct from dictionary and references to conformalVoronoiMesh and
// searchableSurfaces
cellSizeAndAlignmentControl
(
const Time& runTime,
const word& name,
const dictionary& controlFunctionDict,
const conformationSurfaces& allGeometry
);
// Selectors
//- Return a reference to the selected cellShapeControl
static autoPtr<cellSizeAndAlignmentControl> New
(
const Time& runTime,
const word& name,
const dictionary& controlFunctionDict,
const conformationSurfaces& allGeometry
);
//- Destructor
virtual ~cellSizeAndAlignmentControl();
// Member Functions
// Access
const word& name() const
{
return name_;
}
virtual label priority() const = 0;
// Query
virtual void initialVertices
(
pointField& pts,
scalarField& sizes,
triadField& alignments
) const = 0;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

177
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControls.C
View File

@ -1,177 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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 "cellSizeAndAlignmentControls.H"
#include "searchableSurfaceControl.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(cellSizeAndAlignmentControls, 0);
}
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
bool Foam::cellSizeAndAlignmentControls::evalCellSizeFunctions
(
const point& pt,
scalar& minSize
) const
{
bool anyFunctionFound = false;
// Regions requesting with the same priority take the smallest
if (controlFunctions_.size())
{
// Maintain priority of current hit. Initialise so it always goes
// through at least once.
label previousPriority = -1;
forAll(controlFunctions_, i)
{
const cellSizeAndAlignmentControl& cSF = controlFunctions_[i];
if (isA<searchableSurfaceControl>(cSF))
{
const searchableSurfaceControl& sSC =
refCast<const searchableSurfaceControl>(cSF);
if (debug)
{
Info<< "size function "
<< sSC.name()
<< " priority " << sSC.priority()
<< endl;
}
if (sSC.priority() < previousPriority)
{
return minSize;
}
scalar sizeI;
if (sSC.sizeFunction().cellSize(pt, sizeI))
{
anyFunctionFound = true;
if (sSC.priority() == previousPriority)
{
if (sizeI < minSize)
{
minSize = sizeI;
}
}
else
{
minSize = sizeI;
}
if (debug)
{
Info<< "sizeI " << sizeI
<<" minSize " << minSize << endl;
}
previousPriority = sSC.priority();
}
}
}
}
return anyFunctionFound;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::cellSizeAndAlignmentControls::cellSizeAndAlignmentControls
(
const Time& runTime,
const dictionary& shapeControlDict,
const conformationSurfaces& allGeometry,
const scalar defaultCellSize
)
:
shapeControlDict_(shapeControlDict),
allGeometry_(allGeometry),
controlFunctions_(shapeControlDict_.size()),
defaultCellSize_(defaultCellSize)
{
label functionI = 0;
forAllConstIter(dictionary, shapeControlDict_, iter)
{
word shapeControlEntryName = iter().keyword();
const dictionary& controlFunctionDict
(
shapeControlDict_.subDict(shapeControlEntryName)
);
controlFunctions_.set
(
functionI,
cellSizeAndAlignmentControl::New
(
runTime,
shapeControlEntryName,
controlFunctionDict,
allGeometry
)
);
functionI++;
}
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::cellSizeAndAlignmentControls::~cellSizeAndAlignmentControls()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
Foam::scalar Foam::cellSizeAndAlignmentControls::cellSize
(
const point& pt
) const
{
scalar size = defaultCellSize_;
evalCellSizeFunctions(pt, size);
return size;
}
// ************************************************************************* //

119
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControls.H
View File

@ -1,119 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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/>.
Class
Foam::cellSizeAndAlignmentControls
Description
SourceFiles
cellSizeAndAlignmentControls.C
\*---------------------------------------------------------------------------*/
#ifndef cellSizeAndAlignmentControls_H
#define cellSizeAndAlignmentControls_H
#include "dictionary.H"
#include "cellSizeAndAlignmentControl.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cellSizeAndAlignmentControls Declaration
\*---------------------------------------------------------------------------*/
class cellSizeAndAlignmentControls
{
// Private data
const dictionary& shapeControlDict_;
const conformationSurfaces& allGeometry_;
PtrList<cellSizeAndAlignmentControl> controlFunctions_;
const scalar defaultCellSize_;
// Private Member Functions
bool evalCellSizeFunctions(const point& pt, scalar& minSize) const;
//- Disallow default bitwise copy construct
cellSizeAndAlignmentControls(const cellSizeAndAlignmentControls&);
//- Disallow default bitwise assignment
void operator=(const cellSizeAndAlignmentControls&);
public:
//- Runtime type information
ClassName("cellSizeAndAlignmentControls");
// Constructors
//- Construct from dictionary
cellSizeAndAlignmentControls
(
const Time& runTime,
const dictionary& shapeControlDict,
const conformationSurfaces& allGeometry,
const scalar defaultCellSize
);
//- Destructor
virtual ~cellSizeAndAlignmentControls();
// Member Functions
// Access
const PtrList<cellSizeAndAlignmentControl>& controlFunctions() const
{
return controlFunctions_;
}
// Query
scalar cellSize(const point& pt) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

242
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/fileControl/fileControl.C
View File

@ -1,242 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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 "fileControl.H"
#include "addToRunTimeSelectionTable.H"
#include "tetrahedron.H"
#include "scalarList.H"
#include "vectorTools.H"
#include "pointIOField.H"
#include "scalarIOField.H"
#include "triadIOField.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(fileControl, 0);
addToRunTimeSelectionTable
(
cellSizeAndAlignmentControl,
fileControl,
dictionary
);
}
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::fileControl::fileControl
(
const Time& runTime,
const word& name,
const dictionary& controlFunctionDict,
const conformationSurfaces& allGeometry
)
:
cellSizeAndAlignmentControl
(
runTime,
name,
controlFunctionDict,
allGeometry
),
pointsFile_(controlFunctionDict.lookup("pointsFile")),
sizesFile_(controlFunctionDict.lookup("sizesFile")),
alignmentsFile_(controlFunctionDict.lookup("alignmentsFile")),
priority_(readLabel(controlFunctionDict.lookup("priority")))
{
Info<< indent << "Loading from file... " << nl
<< indent << " points : " << pointsFile_ << nl
<< indent << " sizes : " << sizesFile_ << nl
<< indent << " alignments : " << alignmentsFile_
<< endl;
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::fileControl::~fileControl()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
//
//Foam::scalar Foam::fileControl::cellSize(const point& pt) const
//{
// scalarList bary;
// Cell_handle ch;
//
// triangulatedMesh_.barycentricCoords(pt, bary, ch);
//
// scalar size = 0;
// forAll(bary, pI)
// {
// size += bary[pI]*ch->vertex(pI)->size();
// }
//
// return size;
//}
//
//
////- Return the cell alignment at the given location
//Foam::tensor Foam::fileControl::cellAlignment(const point& pt) const
//{
// scalarList bary;
// Cell_handle ch;
//
// triangulatedMesh_.barycentricCoords(pt, bary, ch);
//
// label nearest = 0;
//
// tensor alignment = Foam::tensor::zero;
// forAll(bary, pI)
// {
// //alignment += bary[pI]*ch->vertex(pI)->alignment();
//
// // Find nearest point
// if (bary[pI] > nearest)
// {
// alignment = ch->vertex(pI)->alignment();
// nearest = bary[pI];
// }
// }
//
// return alignment;
//}
//
//
////- Return the cell alignment at the given location
//void Foam::fileControl::cellSizeAndAlignment
//(
// const point& pt,
// scalar& size,
// tensor& alignment
//) const
//{
// scalarList bary;
// Cell_handle ch;
//
// triangulatedMesh_.barycentricCoords(pt, bary, ch);
//
// size = 0;
// forAll(bary, pI)
// {
// size += bary[pI]*ch->vertex(pI)->size();
// }
//
//// alignment = Foam::tensor::zero;
//// forAll(bary, pI)
//// {
//// alignment += bary[pI]*ch->vertex(pI)->alignment();
//// }
//
// alignment = cellAlignment(pt);
//}
void Foam::fileControl::initialVertices
(
pointField& pts,
scalarField& sizes,
triadField& alignments
) const
{
Info<< " Reading points from file : " << pointsFile_ << endl;
pointIOField pointsTmp
(
IOobject
(
pointsFile_,
runTime_.constant(),
runTime_,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
pts.transfer(pointsTmp);
Info<< " Reading sizes from file : " << sizesFile_ << endl;
scalarIOField sizesTmp
(
IOobject
(
sizesFile_,
runTime_.constant(),
runTime_,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
sizes.transfer(sizesTmp);
Info<< " Reading alignments from file : " << alignmentsFile_ << endl;
triadIOField alignmentsTmp
(
IOobject
(
alignmentsFile_,
runTime_.constant(),
runTime_,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
alignments.transfer(alignmentsTmp);
if ((pts.size() != sizes.size()) || (pts.size() != alignments.size()))
{
FatalErrorIn
(
"Foam::fileControl::initialVertices"
"("
" pointField&,"
" scalarField&,"
" Field<triad>&"
")"
) << "Size of list of points, sizes and alignments do not match:"
<< nl
<< "Points size = " << pts.size() << nl
<< "Sizes size = " << sizes.size() << nl
<< "Alignments size = " << alignments.size()
<< abort(FatalError);
}
}
// ************************************************************************* //

140
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/fileControl/fileControl.H
View File

@ -1,140 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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/>.
Class
Foam::fileControl
Description
SourceFiles
fileControl.C
\*---------------------------------------------------------------------------*/
#ifndef fileControl_H
#define fileControl_H
#include "cellSizeAndAlignmentControl.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class fileControl Declaration
\*---------------------------------------------------------------------------*/
class fileControl
:
public cellSizeAndAlignmentControl
{
// Private data
const fileName pointsFile_;
const fileName sizesFile_;
const fileName alignmentsFile_;
label priority_;
// Private Member Functions
//- Disallow default bitwise copy construct
fileControl(const fileControl&);
//- Disallow default bitwise assignment
void operator=(const fileControl&);
public:
//- Runtime type information
TypeName("fileControl");
// Constructors
//- Construct from dictionary and references to conformalVoronoiMesh and
// searchableSurfaces
fileControl
(
const Time& runTime,
const word& name,
const dictionary& controlFunctionDict,
const conformationSurfaces& allGeometry
);
//- Destructor
~fileControl();
// Member Functions
// Access
// Query
// //- Return the cell size at the given location
// virtual scalar cellSize(const point& pt) const;
//
// //- Return the cell alignment at the given location
// virtual tensor cellAlignment(const point& pt) const;
//
// virtual void cellSizeAndAlignment
// (
// const point& pt,
// scalar& size,
// tensor& alignment
// ) const;
// Edit
virtual void initialVertices
(
pointField& pts,
scalarField& sizes,
triadField& alignments
) const;
virtual label priority() const
{
return priority_;
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

666
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/searchableSurfaceControl/searchableSurfaceControl.C
View File

@ -1,666 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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 "searchableSurfaceControl.H"
#include "addToRunTimeSelectionTable.H"
#include "cellSizeFunction.H"
#include "triSurfaceMesh.H"
#include "searchableBox.H"
#include "tetrahedron.H"
#include "vectorTools.H"
#include "quaternion.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(searchableSurfaceControl, 0);
addToRunTimeSelectionTable
(
cellSizeAndAlignmentControl,
searchableSurfaceControl,
dictionary
);
}
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
//Foam::tensor Foam::surfaceControl::requiredAlignment
//(
// const Foam::point& pt,
// const vectorField& ptNormals
//) const
//{
//// pointIndexHit surfHit;
//// label hitSurface;
////
//// geometryToConformTo_.findSurfaceNearest
//// (
//// pt,
//// sqr(GREAT),
//// surfHit,
//// hitSurface
//// );
////
//// if (!surfHit.hit())
//// {
//// FatalErrorIn
//// (
//// "Foam::tensor Foam::conformalVoronoiMesh::requiredAlignment"
//// )
//// << "findSurfaceNearest did not find a hit across the surfaces."
//// << exit(FatalError) << endl;
//// }
////
////// Primary alignment
////
//// vectorField norm(1);
////
//// allGeometry_[hitSurface].getNormal
//// (
//// List<pointIndexHit>(1, surfHit),
//// norm
//// );
////
//// const vector np = norm[0];
////
//// const tensor Rp = rotationTensor(vector(0,0,1), np);
////
//// return (Rp);
//
//// Info<< "Point : " << pt << endl;
//// forAll(ptNormals, pnI)
//// {
//// Info<< " normal " << pnI << " : " << ptNormals[pnI] << endl;
//// }
//
// vector np = ptNormals[0];
//
// const tensor Rp = rotationTensor(vector(0,0,1), np);
//
// vector na = vector::zero;
//
// scalar smallestAngle = GREAT;
//
// for (label pnI = 1; pnI < ptNormals.size(); ++pnI)
// {
// const vector& nextNormal = ptNormals[pnI];
//
// const scalar cosPhi = vectorTools::cosPhi(np, nextNormal);
//
// if (mag(cosPhi) < smallestAngle)
// {
// na = nextNormal;
// smallestAngle = cosPhi;
// }
// }
//
// // Secondary alignment
// vector ns = np ^ na;
//
// if (mag(ns) < SMALL)
// {
// WarningIn("conformalVoronoiMesh::requiredAlignment")
// << "Parallel normals detected in spoke search." << nl
// << "point: " << pt << nl
// << "np : " << np << nl
// << "na : " << na << nl
// << "ns : " << ns << nl
// << endl;
//
// ns = np;
// }
//
// ns /= mag(ns);
//
// tensor Rs = rotationTensor((Rp & vector(0,1,0)), ns);
//
//// Info<< "Point " << pt << nl
//// << " np : " << np << nl
//// << " ns : " << ns << nl
//// << " Rp : " << Rp << nl
//// << " Rs : " << Rs << nl
//// << " Rs&Rp: " << (Rs & Rp) << endl;
//
// return (Rs & Rp);
//}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::searchableSurfaceControl::searchableSurfaceControl
(
const Time& runTime,
const word& name,
const dictionary& controlFunctionDict,
const conformationSurfaces& allGeometry
)
:
cellSizeAndAlignmentControl
(
runTime,
name,
controlFunctionDict,
allGeometry
),
surfaceName_(controlFunctionDict.lookupOrDefault<word>("surface", name)),
searchableSurface_(allGeometry.geometry()[surfaceName_]),
allGeometry_(allGeometry),
cellSizeFunction_
(
cellSizeFunction::New(controlFunctionDict, searchableSurface_)
)
// geometryToConformTo_(geometryToConformTo),
// surfaces_(),
// cellSizeFunctions_(),
// triangulatedMesh_()
{
// const dictionary& surfacesDict = coeffDict();
//
// Info<< nl << "Reading cellSizeControlGeometry" << endl;
//
// surfaces_.setSize(surfacesDict.size());
//
// cellSizeFunctions_.setSize(surfacesDict.size());
//
// label surfI = 0;
//
// DynamicList<point> pointsToInsert;
// DynamicList<scalar> sizesToInsert;
// DynamicList<tensor> alignmentsToInsert;
//
// forAllConstIter(dictionary, surfacesDict, iter)
// {
// const dictionary& surfaceSubDict
// (
// surfacesDict.subDict(iter().keyword())
// );
//
// // If the "surface" keyword is not found in the dictionary, assume
// // the name of the dictionary is the surface. Distinction required to
// // allow the same surface to be used multiple times to supply multiple
// // cellSizeFunctions
//
// word surfaceName = surfaceSubDict.lookupOrDefault<word>
// (
// "surface",
// iter().keyword()
// );
//
// surfaces_[surfI] = allGeometry_.findSurfaceID(surfaceName);
//
// if (surfaces_[surfI] < 0)
// {
// FatalErrorIn
// (
// "Foam::surfaceControl::surfaceControl"
// ) << "No surface " << surfaceName << " found. "
// << "Valid geometry is " << nl << allGeometry_.names()
// << exit(FatalError);
// }
//
// const searchableSurface& surface = allGeometry_[surfaces_[surfI]];
//
// Info<< nl << " " << iter().keyword() << nl
// << " surface: " << surfaceName << nl
// << " size : " << surface.size() << endl;
//
// cellSizeFunctions_.set
// (
// surfI,
// cellSizeFunction::New
// (
// surfaceSubDict,
// surface
// )
// );
//
// surfI++;
//
// if (isA<triSurfaceMesh>(surface))
// {
// const triSurfaceMesh& tsm
// = refCast<const triSurfaceMesh>(surface);
//
// const pointField& points = tsm.points();
// const vectorField& faceNormals = tsm.faceNormals();
// const labelListList& pointFaces = tsm.pointFaces();
//
// Info<< " Number of points: " << tsm.nPoints() << endl;
//
// forAll(points, pI)
// {
// const Foam::point& pt = points[pI];
// const labelList& ptFaces = pointFaces[pI];
//
// vectorField pointNormals(ptFaces.size());
//
// forAll(pointNormals, pnI)
// {
// pointNormals[pnI] = faceNormals[ptFaces[pnI]];
// }
//
// pointsToInsert.append(pt);
//
// // Get the value of the point from surfaceCellSizeFunction. If
// // adding points internally then will need to interpolate.
// scalar newSize = 0;
//
// cellSizeFunctions_[surfI - 1].cellSize(pt, newSize);
// sizesToInsert.append(newSize);
//
// tensor newAlignment = requiredAlignment(pt, pointNormals);
//
// alignmentsToInsert.append(newAlignment);
// }
// }
// }
//
// // Add the global bound box to ensure that all internal point queries
// // will return sizes and alignments
//// boundBox bb = allGeometry_.bounds();
////
//// pointField bbPoints = bb.points();
////
//// forAll(bbPoints, pI)
//// {
//// pointsToInsert.append(bbPoints[pI]);
//// sizesToInsert.append(defaultCellSize());
//// alignmentsToInsert.append(tensor(1,0,0,0,1,0,0,0,1));
//// }
//
// triangulatedMesh_.set
// (
// new triangulatedMesh
// (
// runTime,
// pointsToInsert,
// sizesToInsert,
// alignmentsToInsert,
// defaultCellSize()
// )
// );
//
// scalar factor = 1.0;
// label maxIteration = cellShapeControlDict.lookupOrDefault<label>
// (
// "maxRefinementIterations", 1
// );
//
//
// for (label iteration = 0; iteration < maxIteration; ++iteration)
// {
// Info<< "Iteration : " << iteration << endl;
//
// label nRefined = triangulatedMesh_().refineTriangulation
// (
// factor,
// allGeometry_,
// geometryToConformTo_
// );
//
// Info<< " Number of cells refined in refinement iteration : "
// << nRefined << nl << endl;
//
// if (nRefined <= 0 && iteration != 0)
// {
// break;
// }
//
// factor *= 1.5;
// }
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::searchableSurfaceControl::~searchableSurfaceControl()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
//Foam::scalar Foam::surfaceControl::cellSize(const point& pt) const
//{
// scalarList bary;
// Cell_handle ch;
//
// triangulatedMesh_().barycentricCoords(pt, bary, ch);
//
// scalar size = 0;
// forAll(bary, pI)
// {
// size += bary[pI]*ch->vertex(pI)->size();
// }
//
// return size;
//}
//
//
////- Return the cell alignment at the given location
//Foam::tensor Foam::surfaceControl::cellAlignment(const point& pt) const
//{
// scalarList bary;
// Cell_handle ch;
//
// triangulatedMesh_().barycentricCoords(pt, bary, ch);
//
//// vectorField cartesianDirections(3);
////
//// cartesianDirections[0] = vector(0,0,1);
//// cartesianDirections[1] = vector(0,1,0);
//// cartesianDirections[2] = vector(1,0,0);
////
//// // Rearrange each alignment tensor so that the x/y/z components are
//// // in order of whichever makes the smallest angle with the global
//// // coordinate system
//// FixedList<tensor, 4> alignments;
////
//// forAll(alignments, aI)
//// {
//// tensor a = ch->vertex(aI)->alignment();
////
//// tensor tmpA = a;
////
////// Info<< nl << indent<< a << endl;
////
//// scalar minAngle = 0;
////
//// scalar axx = vectorTools::cosPhi(a.x(), cartesianDirections[0]);
//// scalar axy = vectorTools::cosPhi(a.y(), cartesianDirections[0]);
//// scalar axz = vectorTools::cosPhi(a.z(), cartesianDirections[0]);
////
//// scalar ayx = vectorTools::cosPhi(a.x(), cartesianDirections[1]);
//// scalar ayy = vectorTools::cosPhi(a.y(), cartesianDirections[1]);
//// scalar ayz = vectorTools::cosPhi(a.z(), cartesianDirections[1]);
////
//// scalar azx = vectorTools::cosPhi(a.x(), cartesianDirections[2]);
//// scalar azy = vectorTools::cosPhi(a.y(), cartesianDirections[2]);
//// scalar azz = vectorTools::cosPhi(a.z(), cartesianDirections[2]);
////
////// Info<< indent << axx << " " << axy << " " << axz << nl
////// << indent << ayx << " " << ayy << " " << ayz << nl
////// << indent << azx << " " << azy << " " << azz << endl;
////
//// if (mag(axx) >= minAngle)
//// {
//// tmpA.xx() = mag(a.xx());
//// tmpA.xy() = mag(a.xy());
//// tmpA.xz() = mag(a.xz());
//// minAngle = mag(axx);
//// }
//// if (mag(axy) >= minAngle)
//// {
//// tmpA.xx() = mag(a.yx());
//// tmpA.xy() = mag(a.yy());
//// tmpA.xz() = mag(a.yz());
//// minAngle = mag(axy);
//// }
//// if (mag(axz) >= minAngle)
//// {
//// tmpA.xx() = mag(a.zx());
//// tmpA.xy() = mag(a.zy());
//// tmpA.xz() = mag(a.zz());
//// }
////
//// minAngle = 0;
////
//// if (mag(ayx) >= minAngle)
//// {
//// tmpA.yx() = mag(a.xx());
//// tmpA.yy() = mag(a.xy());
//// tmpA.yz() = mag(a.xz());
//// minAngle = mag(ayx);
//// }
//// if (mag(ayy) >= minAngle)
//// {
//// tmpA.yx() = mag(a.yx());
//// tmpA.yy() = mag(a.yy());
//// tmpA.yz() = mag(a.yz());
//// minAngle = mag(ayy);
//// }
//// if (mag(ayz) >= minAngle)
//// {
//// tmpA.yx() = mag(a.zx());
//// tmpA.yy() = mag(a.zy());
//// tmpA.yz() = mag(a.zz());
//// }
////
//// minAngle = 0;
////
//// if (mag(azx) >= minAngle)
//// {
//// tmpA.zx() = mag(a.xx());
//// tmpA.zy() = mag(a.xy());
//// tmpA.zz() = mag(a.xz());
//// minAngle = mag(azx);
//// }
//// if (mag(azy) >= minAngle)
//// {
//// tmpA.zx() = mag(a.yx());
//// tmpA.zy() = mag(a.yy());
//// tmpA.zz() = mag(a.yz());
//// minAngle = mag(azy);
//// }
//// if (mag(azz) >= minAngle)
//// {
//// tmpA.zx() = mag(a.zx());
//// tmpA.zy() = mag(a.zy());
//// tmpA.zz() = mag(a.zz());
//// }
////
//// alignments[aI] = tmpA;
//// }
//
// scalar nearest = 0;
//
//// Info<< nl << "Point " << pt << endl;
////
//// FixedList<quaternion, 4> qAlignments;
//// forAll(qAlignments, aI)
//// {
////// Info<< " Direction " << aI << endl;
////// Info<< " Rot tensor" << alignments[aI] << endl;
//// qAlignments[aI] = quaternion(alignments[aI]);
//// qAlignments[aI].normalize();
////// Info<< " Quaternion: " << qAlignments[aI] << endl;
////// Info<< " Rot tensor from quat: " << qAlignments[aI].R()
////// << endl;
//// }
//
// tensor alignment = Foam::tensor::zero;
// forAll(bary, pI)
// {
//// alignment += bary[pI]*ch->vertex(pI)->alignment();
//
//// alignment += bary[pI]*alignments[pI];
//
// // Try slerp with quaternions
//
// // Find nearest point
// if (bary[pI] > nearest)
// {
// alignment = ch->vertex(pI)->alignment();
// nearest = bary[pI];
// }
// }
//
//// quaternion alignment;
//
//// alignment = qAlignments[0]*bary[0]
//// + qAlignments[1]*bary[1]
//// + qAlignments[2]*bary[2]
//// + qAlignments[3]*bary[3];
//
//// alignment =
//// slerp(qAlignments[0], qAlignments[1], bary[0]+bary[1]+bary[2]);
//// alignment = slerp(alignment, qAlignments[2], bary[0]+bary[1]+bary[2]);
//// alignment = slerp(alignment, qAlignments[3], bary[0]+bary[1]+bary[2]);
//// alignment =
//// slerp(alignment, qAlignments[0], bary[0]/(bary[0]+bary[1]+bary[2]));
//
//// Info<< " Interp alignment : " << alignment << endl;
//// Info<< " Interp rot tensor: " << alignment.R() << endl;
//
// return alignment;
//}
//
//
//void Foam::surfaceControl::cellSizeAndAlignment
//(
// const point& pt,
// scalar& size,
// tensor& alignment
//) const
//{
// scalarList bary;
// Cell_handle ch;
//
// triangulatedMesh_().barycentricCoords(pt, bary, ch);
//
// size = 0;
// forAll(bary, pI)
// {
// size += bary[pI]*ch->vertex(pI)->size();
// }
//
//// alignment = Foam::tensor::zero;
//// forAll(bary, pI)
//// {
//// alignment += bary[pI]*ch->vertex(pI)->alignment();
//// }
//
// alignment = cellAlignment(pt);
//}
void Foam::searchableSurfaceControl::initialVertices
(
pointField& pts,
scalarField& sizes,
triadField& alignments
) const
{
pts = searchableSurface_.points();
sizes.setSize(pts.size());
alignments.setSize(pts.size());
const scalar nearFeatDistSqrCoeff = 1e-8;
forAll(pts, pI)
{
// Is the point in the extendedFeatureEdgeMesh? If so get the
// point normal, otherwise get the surface normal from
// searchableSurface
pointIndexHit info;
label infoFeature;
allGeometry_.findFeaturePointNearest
(
pts[pI],
nearFeatDistSqrCoeff,
info,
infoFeature
);
autoPtr<triad> pointAlignment;
if (info.hit())
{
const extendedFeatureEdgeMesh& features =
allGeometry_.features()[infoFeature];
vectorField norms = features.featurePointNormals(info.index());
// Create a triad from these norms.
pointAlignment.set(new triad());
forAll(norms, nI)
{
pointAlignment() += norms[nI];
}
pointAlignment().normalize();
pointAlignment().orthogonalize();
}
else
{
allGeometry_.findEdgeNearest
(
pts[pI],
nearFeatDistSqrCoeff,
info,
infoFeature
);
if (info.hit())
{
const extendedFeatureEdgeMesh& features =
allGeometry_.features()[infoFeature];
vectorField norms = features.edgeNormals(info.index());
// Create a triad from these norms.
pointAlignment.set(new triad());
forAll(norms, nI)
{
pointAlignment() += norms[nI];
}
pointAlignment().normalize();
pointAlignment().orthogonalize();
}
else
{
pointField ptField(1, pts[pI]);
scalarField distField(1, nearFeatDistSqrCoeff);
List<pointIndexHit> infoList(1, pointIndexHit());
searchableSurface_.findNearest(ptField, distField, infoList);
vectorField normals(1);
searchableSurface_.getNormal(infoList, normals);
pointAlignment.set(new triad(normals[0]));
}
}
if (!cellSizeFunction_().cellSize(pts[pI], sizes[pI]))
{
FatalErrorIn
(
"Foam::searchableSurfaceControl::initialVertices"
"(pointField&, scalarField&, tensorField&)"
) << "Could not calculate cell size"
<< abort(FatalError);
}
alignments[pI] = pointAlignment();
}
}
// ************************************************************************* //

173
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/searchableSurfaceControl/searchableSurfaceControl.H
View File

@ -1,173 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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/>.
Class
Foam::searchableSurfaceControl
Description
SourceFiles
searchableSurfaceControl.C
\*---------------------------------------------------------------------------*/
#ifndef searchableSurfaceControl_H
#define searchableSurfaceControl_H
#include "cellSizeFunction.H"
#include "triad.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class surfaceControl Declaration
\*---------------------------------------------------------------------------*/
class searchableSurfaceControl
:
public cellSizeAndAlignmentControl
{
// Private data
//- Name of the surface
const word surfaceName_;
//- Reference to the searchableSurface object holding the geometry data
const searchableSurface& searchableSurface_;
const conformationSurfaces& allGeometry_;
autoPtr<cellSizeFunction> cellSizeFunction_;
// const conformationSurfaces& geometryToConformTo_;
//
// //- Indices of surfaces in allGeometry that are to be conformed to
// labelList surfaces_;
//
// //- A list of all of the cellSizeFunction objects
// PtrList<cellSizeFunction> cellSizeFunctions_;
//
// autoPtr<triangulatedMesh> triangulatedMesh_;
//
//
// // Private Member Functions
//
// //-
// tensor requiredAlignment
// (
// const point& pt,
// const vectorField& ptNormals
// ) const;
//- Disallow default bitwise copy construct
searchableSurfaceControl(const searchableSurfaceControl&);
//- Disallow default bitwise assignment
void operator=(const searchableSurfaceControl&);
public:
//- Runtime type information
TypeName("searchableSurfaceControl");
// Constructors
//- Construct from dictionary and references to conformalVoronoiMesh and
// searchableSurfaces
searchableSurfaceControl
(
const Time& runTime,
const word& name,
const dictionary& controlFunctionDict,
const conformationSurfaces& allGeometry
);
//- Destructor
~searchableSurfaceControl();
// Member Functions
// Access
// //- Return reference to the searchableSurfaces object containing
// // all of the geometry
// inline const searchableSurfaces& geometry() const;
//
// //- Return the surface indices
// inline const labelList& surfaces() const;
//
//
// // Query
//
// //- Return the cell size at the given location
// virtual scalar cellSize(const point& pt) const;
//
// //- Return the cell alignment at the given location
// virtual tensor cellAlignment(const point& pt) const;
//
// virtual void cellSizeAndAlignment
// (
// const point& pt,
// scalar& size,
// tensor& alignment
// ) const;
virtual void initialVertices
(
pointField& pts,
scalarField& sizes,
triadField& alignments
) const;
const cellSizeFunction& sizeFunction() const
{
return cellSizeFunction_();
}
virtual label priority() const
{
return cellSizeFunction_().priority();
}
// Edit
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

146
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.C
View File

@ -1,146 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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 "cellSizeFunction.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(cellSizeFunction, 0);
defineRunTimeSelectionTable(cellSizeFunction, dictionary);
scalar cellSizeFunction::snapToSurfaceTol_ = 1e-10;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::cellSizeFunction::cellSizeFunction
(
const word& type,
const dictionary& cellSizeFunctionDict,
const searchableSurface& surface
)
:
dictionary(cellSizeFunctionDict),
surface_(surface),
surfaceCellSizeFunction_
(
surfaceCellSizeFunction::New
(
cellSizeFunctionDict,
surface
)
),
coeffsDict_(subDict(type + "Coeffs")),
sideMode_(),
priority_(readLabel(cellSizeFunctionDict.lookup("priority")))
{
word mode = cellSizeFunctionDict.lookup("mode");
if (surface_.hasVolumeType())
{
if (mode == "inside")
{
sideMode_ = smInside;
}
else if (mode == "outside")
{
sideMode_ = smOutside;
}
else if (mode == "bothSides")
{
sideMode_ = rmBothsides;
}
else
{
FatalErrorIn("searchableSurfaceControl::searchableSurfaceControl")
<< "Unknown mode, expected: inside, outside or bothSides" << nl
<< exit(FatalError);
}
}
else
{
if (mode != "bothSides")
{
WarningIn("searchableSurfaceControl::searchableSurfaceControl")
<< "surface does not support volumeType, defaulting mode to "
<< "bothSides."
<< endl;
}
sideMode_ = rmBothsides;
}
}
// * * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::cellSizeFunction> Foam::cellSizeFunction::New
(
const dictionary& cellSizeFunctionDict,
const searchableSurface& surface
)
{
word cellSizeFunctionTypeName
(
cellSizeFunctionDict.lookup("cellSizeFunction")
);
Info<< " Selecting cellSizeFunction " << cellSizeFunctionTypeName
<< endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(cellSizeFunctionTypeName);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"cellSizeFunction::New(dictionary&, "
"const conformalVoronoiMesh&, const searchableSurface&)"
) << "Unknown cellSizeFunction type "
<< cellSizeFunctionTypeName
<< endl << endl
<< "Valid cellSizeFunction types are :" << endl
<< dictionaryConstructorTablePtr_->toc()
<< exit(FatalError);
}
return autoPtr<cellSizeFunction>
(
cstrIter()(cellSizeFunctionDict, surface)
);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::cellSizeFunction::~cellSizeFunction()
{}
// ************************************************************************* //

201
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.H
View File

@ -1,201 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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/>.
Class
Foam::cellSizeFunction
Description
Abstract base class for specifying target cell sizes
SourceFiles
cellSizeFunction.C
\*---------------------------------------------------------------------------*/
#ifndef cellSizeFunction_H
#define cellSizeFunction_H
#include "point.H"
#include "conformalVoronoiMesh.H"
#include "searchableSurface.H"
#include "dictionary.H"
#include "autoPtr.H"
#include "runTimeSelectionTables.H"
#include "surfaceCellSizeFunction.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cellSizeFunction Declaration
\*---------------------------------------------------------------------------*/
class cellSizeFunction
:
public dictionary
{
public:
//- Surface side mode
enum sideMode
{
smInside, // Control inside the surface
smOutside, // Control outside the surface
rmBothsides // Control on both sides of a surface
};
//- Runtime type information
TypeName("cellSizeFunction");
protected:
// Static data
//- Point closeness tolerance to a surface where the function "snaps" to
// including the surface
static scalar snapToSurfaceTol_;
// Protected data
//- Reference to the searchableSurface that cellSizeFunction
// relates to
const searchableSurface& surface_;
//- Cell size at the surface
scalarField surfaceCellSize_;
autoPtr<surfaceCellSizeFunction> surfaceCellSizeFunction_;
//- Method details dictionary
dictionary coeffsDict_;
//- Mode of size specification, i.e. inside, outside or bothSides
sideMode sideMode_;
label priority_;
private:
// Private Member Functions
//- Disallow default bitwise copy construct
cellSizeFunction(const cellSizeFunction&);
//- Disallow default bitwise assignment
void operator=(const cellSizeFunction&);
public:
// Declare run-time constructor selection table
declareRunTimeSelectionTable
(
autoPtr,
cellSizeFunction,
dictionary,
(
const dictionary& cellSizeFunctionDict,
const searchableSurface& surface
),
(cellSizeFunctionDict, surface)
);
// Constructors
//- Construct from components
cellSizeFunction
(
const word& type,
const dictionary& cellSizeFunctionDict,
const searchableSurface& surface
);
// Selectors
//- Return a reference to the selected cellSizeFunction
static autoPtr<cellSizeFunction> New
(
const dictionary& cellSizeFunctionDict,
const searchableSurface& surface
);
//- Destructor
virtual ~cellSizeFunction();
// Member Functions
//- Const access to the details dictionary
inline const dictionary& coeffsDict() const
{
return coeffsDict_;
}
//- Modify scalar argument to the cell size specified by function.
// Return a boolean specifying if the function was used, i.e. false if
// the point was not in range of the surface for a spatially varying
// size.
virtual bool cellSize
(
const point& pt,
scalar& size
) const = 0;
virtual bool setCellSize
(
const pointField& pts
)
{
WarningIn("cellSizeFunction::setCellSize(const pointField&)")
<< "Not overloaded."
<< endl;
return false;
}
label priority() const
{
return priority_;
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

200
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/linearDistance/linearDistance.C
View File

@ -1,200 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "linearDistance.H"
#include "addToRunTimeSelectionTable.H"
#include "triSurfaceMesh.H"
#include "triSurfaceFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(linearDistance, 0);
addToRunTimeSelectionTable(cellSizeFunction, linearDistance, dictionary);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
linearDistance::linearDistance
(
const dictionary& initialPointsDict,
const searchableSurface& surface
)
:
cellSizeFunction(typeName, initialPointsDict, surface),
distanceCellSize_(readScalar(coeffsDict().lookup("distanceCellSize"))),
distance_(readScalar(coeffsDict().lookup("distance"))),
distanceSqr_(sqr(distance_))
{}
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
scalar linearDistance::sizeFunction
(
const point& pt,
scalar d,
label index
) const
{
const scalar interpolatedSize
= surfaceCellSizeFunction_().interpolate(pt, index);
scalar gradient
= (distanceCellSize_ - interpolatedSize)
/distance_;
scalar size = gradient*d + interpolatedSize;
return size;
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool linearDistance::cellSize(const point& pt, scalar& size) const
{
size = 0;
List<pointIndexHit> hits;
surface_.findNearest
(
pointField(1, pt),
scalarField(1, distanceSqr_),
hits
);
const pointIndexHit& hitInfo = hits[0];
if (hitInfo.hit())
{
const point& hitPt = hitInfo.hitPoint();
const label hitIndex = hitInfo.index();
const scalar dist = mag(pt - hitPt);
if (sideMode_ == rmBothsides)
{
size = sizeFunction(hitPt, dist, hitIndex);
return true;
}
// If the nearest point is essentially on the surface, do not do a
// getVolumeType calculation, as it will be prone to error.
if (dist < snapToSurfaceTol_)
{
size = sizeFunction(hitPt, 0, hitIndex);
return true;
}
pointField ptF(1, pt);
List<searchableSurface::volumeType> vTL;
surface_.getVolumeType(ptF, vTL);
bool functionApplied = false;
if
(
sideMode_ == smInside
&& vTL[0] == searchableSurface::INSIDE
)
{
size = sizeFunction(hitPt, dist, hitIndex);
functionApplied = true;
}
else if
(
sideMode_ == smOutside
&& vTL[0] == searchableSurface::OUTSIDE
)
{
size = sizeFunction(hitPt, dist, hitIndex);
functionApplied = true;
}
return functionApplied;
}
return false;
}
bool linearDistance::setCellSize(const pointField& pts)
{
labelHashSet surfaceAlreadyHit(surfaceCellSize_.size());
forAll(pts, ptI)
{
const Foam::point& pt = pts[ptI];
List<pointIndexHit> hits;
surface_.findNearest
(
pointField(1, pt),
scalarField(1, distanceSqr_),
hits
);
const label surfHitI = hits[0].index();
if
(
hits[0].hit()
&& !surfaceAlreadyHit.found(surfHitI)
)
{
// Halving cell size is arbitrary
surfaceCellSizeFunction_().refineSurfaceSize(surfHitI);
surfaceAlreadyHit.insert(surfHitI);
}
}
// Force recalculation of the interpolation
if (!pts.empty())
{
surfaceCellSizeFunction_().recalculateInterpolation();
}
return true;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

121
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/linearDistance/linearDistance.H
View File

@ -1,121 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Class
Foam::linearDistance
Description
SourceFiles
linearDistance.C
\*---------------------------------------------------------------------------*/
#ifndef linearDistance_H
#define linearDistance_H
#include "cellSizeFunction.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class linearDistance Declaration
\*---------------------------------------------------------------------------*/
class linearDistance
:
public cellSizeFunction
{
private:
// Private data
//- cell size at distance_ from the surface
scalar distanceCellSize_;
//- distance from the surface to control over
scalar distance_;
//- distance squared
scalar distanceSqr_;
// Private Member Functions
//- Calculate the cell size as a function of the given distance
scalar sizeFunction(const point& pt, scalar d, label index) const;
public:
//- Runtime type information
TypeName("linearDistance");
// Constructors
//- Construct from components
linearDistance
(
const dictionary& initialPointsDict,
const searchableSurface& surface
);
//- Destructor
virtual ~linearDistance()
{}
// Member Functions
//- Modify scalar argument to the cell size specified by function.
// Return a boolean specifying if the function was used, i.e. false if
// the point was not in range of the surface for a spatially varying
// size.
virtual bool cellSize
(
const point& pt,
scalar& size
) const;
//- Adapt local cell size. Return true if anything changed.
virtual bool setCellSize
(
const pointField& pts
);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

142
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/linearSpatial/linearSpatial.C
View File

@ -1,142 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "linearSpatial.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(linearSpatial, 0);
addToRunTimeSelectionTable(cellSizeFunction, linearSpatial, dictionary);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
linearSpatial::linearSpatial
(
const dictionary& initialPointsDict,
const searchableSurface& surface
)
:
cellSizeFunction(typeName, initialPointsDict, surface),
referencePoint_(coeffsDict().lookup("referencePoint")),
referenceCellSize_(readScalar(coeffsDict().lookup("referenceCellSize"))),
direction_(coeffsDict().lookup("direction")),
cellSizeGradient_(readScalar(coeffsDict().lookup("cellSizeGradient")))
{
direction_ /= mag(direction_);
}
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
scalar linearSpatial::sizeFunction(const point& pt) const
{
return
referenceCellSize_
+ ((pt - referencePoint_) & direction_)*cellSizeGradient_;
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool linearSpatial::cellSize
(
const point& pt,
scalar& size
) const
{
if (sideMode_ == rmBothsides)
{
size = sizeFunction(pt);
return true;
}
size = 0;
List<pointIndexHit> hits;
surface_.findNearest
(
pointField(1, pt),
scalarField(1, sqr(snapToSurfaceTol_)),
hits
);
const pointIndexHit& hitInfo = hits[0];
// If the nearest point is essentially on the surface, do not do a
// getVolumeType calculation, as it will be prone to error.
if (hitInfo.hit())
{
size = sizeFunction(pt);
return true;
}
pointField ptF(1, pt);
List<searchableSurface::volumeType> vTL;
surface_.getVolumeType(ptF, vTL);
bool functionApplied = false;
if
(
sideMode_ == smInside
&& vTL[0] == searchableSurface::INSIDE
)
{
size = sizeFunction(pt);
functionApplied = true;
}
else if
(
sideMode_ == smOutside
&& vTL[0] == searchableSurface::OUTSIDE
)
{
size = sizeFunction(pt);
functionApplied = true;
}
return functionApplied;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

119
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/linearSpatial/linearSpatial.H
View File

@ -1,119 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Class
Foam::linearSpatial
Description
SourceFiles
linearSpatial.C
\*---------------------------------------------------------------------------*/
#ifndef linearSpatial_H
#define linearSpatial_H
#include "cellSizeFunction.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class linearSpatial Declaration
\*---------------------------------------------------------------------------*/
class linearSpatial
:
public cellSizeFunction
{
private:
// Private data
//- Reference point for spatial size grading
point referencePoint_;
//- Cell size at reference point
scalar referenceCellSize_;
//- Direction of cell size grading, stored as unit vector, may be
// supplied with any magnitude
vector direction_;
//- Gradient of cell size change in direction of direction_
scalar cellSizeGradient_;
// Private Member Functions
//- Calculate the cell size as a function of the given position
scalar sizeFunction(const point& pt) const;
public:
//- Runtime type information
TypeName("linearSpatial");
// Constructors
//- Construct from components
linearSpatial
(
const dictionary& initialPointsDict,
const searchableSurface& surface
);
//- Destructor
virtual ~linearSpatial()
{}
// Member Functions
//- Modify scalar argument to the cell size specified by function.
// Return a boolean specifying if the function was used, i.e. false if
// the point was not in range of the surface for a spatially varying
// size.
virtual bool cellSize
(
const point& pt,
scalar& size
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

224
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/surfaceOffsetLinearDistance/surfaceOffsetLinearDistance.C
View File

@ -1,224 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "surfaceOffsetLinearDistance.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(surfaceOffsetLinearDistance, 0);
addToRunTimeSelectionTable
(
cellSizeFunction,
surfaceOffsetLinearDistance,
dictionary
);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
surfaceOffsetLinearDistance::surfaceOffsetLinearDistance
(
const dictionary& initialPointsDict,
const searchableSurface& surface
)
:
cellSizeFunction(typeName, initialPointsDict, surface),
distanceCellSize_(readScalar(coeffsDict().lookup("distanceCellSize"))),
surfaceOffset_(readScalar(coeffsDict().lookup("surfaceOffset"))),
totalDistance_(),
totalDistanceSqr_()
{
if
(
coeffsDict().found("totalDistance")
|| coeffsDict().found("linearDistance")
)
{
if
(
coeffsDict().found("totalDistance")
&& coeffsDict().found("linearDistance")
)
{
FatalErrorIn
(
"surfaceOffsetLinearDistance::surfaceOffsetLinearDistance"
"("
"const dictionary& initialPointsDict, "
"const conformalVoronoiMesh& cvMesh, "
"const searchableSurface& surface"
")"
)
<< "totalDistance and linearDistance found, "
<< "specify one or other, not both."
<< nl << exit(FatalError) << endl;
}
if (coeffsDict().found("totalDistance"))
{
totalDistance_ = readScalar(coeffsDict().lookup("totalDistance"));
}
else
{
totalDistance_ =
readScalar(coeffsDict().lookup("linearDistance"))
+ surfaceOffset_;
}
}
else
{
FatalErrorIn
(
"surfaceOffsetLinearDistance::surfaceOffsetLinearDistance"
"("
"const dictionary& initialPointsDict, "
"const conformalVoronoiMesh& cvMesh, "
"const searchableSurface& surface"
")"
)
<< "totalDistance or linearDistance not found."
<< nl << exit(FatalError) << endl;
}
totalDistanceSqr_ = sqr(totalDistance_);
}
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
scalar surfaceOffsetLinearDistance::sizeFunction
(
const point& pt,
scalar d,
label index
) const
{
const scalar interpolatedSize
= surfaceCellSizeFunction_().interpolate(pt, index);
if (d <= surfaceOffset_)
{
return interpolatedSize;
}
scalar gradient =
(distanceCellSize_ - interpolatedSize)
/(totalDistance_ - surfaceOffset_);
scalar intercept = interpolatedSize - gradient*surfaceOffset_;
return gradient*d + intercept;
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool surfaceOffsetLinearDistance::cellSize
(
const point& pt,
scalar& size
) const
{
size = 0;
List<pointIndexHit> hits;
surface_.findNearest
(
pointField(1, pt),
scalarField(1, totalDistanceSqr_),
hits
);
const pointIndexHit& hitInfo = hits[0];
if (hitInfo.hit())
{
const point& hitPt = hitInfo.hitPoint();
const label hitIndex = hitInfo.index();
const scalar dist = mag(pt - hitPt);
if (sideMode_ == rmBothsides)
{
size = sizeFunction(hitPt, dist, hitIndex);
return true;
}
// If the nearest point is essentially on the surface, do not do a
// getVolumeType calculation, as it will be prone to error.
if (mag(pt - hitInfo.hitPoint()) < snapToSurfaceTol_)
{
size = sizeFunction(hitPt, 0, hitIndex);
return true;
}
pointField ptF(1, pt);
List<searchableSurface::volumeType> vTL;
surface_.getVolumeType(ptF, vTL);
bool functionApplied = false;
if
(
sideMode_ == smInside
&& vTL[0] == searchableSurface::INSIDE
)
{
size = sizeFunction(hitPt, dist, hitIndex);
functionApplied = true;
}
else if
(
sideMode_ == smOutside
&& vTL[0] == searchableSurface::OUTSIDE
)
{
size = sizeFunction(hitPt, dist, hitIndex);
functionApplied = true;
}
return functionApplied;
}
return false;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

119
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/surfaceOffsetLinearDistance/surfaceOffsetLinearDistance.H
View File

@ -1,119 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Class
Foam::surfaceOffsetLinearDistance
Description
SourceFiles
surfaceOffsetLinearDistance.C
\*---------------------------------------------------------------------------*/
#ifndef surfaceOffsetLinearDistance_H
#define surfaceOffsetLinearDistance_H
#include "cellSizeFunction.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class surfaceOffsetLinearDistance Declaration
\*---------------------------------------------------------------------------*/
class surfaceOffsetLinearDistance
:
public cellSizeFunction
{
private:
// Private data
//- cell size at distance_ from the surface
scalar distanceCellSize_;
//- Offset distance from surface for constant size portion
scalar surfaceOffset_;
//- Total distance from the surface to control over (distance +
// surfaceOffset)
scalar totalDistance_;
//- totalDistance squared
scalar totalDistanceSqr_;
// Private Member Functions
//- Calculate the cell size as a function of the given distance
scalar sizeFunction(const point& pt, scalar d, label index) const;
public:
//- Runtime type information
TypeName("surfaceOffsetLinearDistance");
// Constructors
//- Construct from components
surfaceOffsetLinearDistance
(
const dictionary& initialPointsDict,
const searchableSurface& surface
);
//- Destructor
virtual ~surfaceOffsetLinearDistance()
{}
// Member Functions
//- Modify scalar argument to the cell size specified by function.
// Return a boolean specifying if the function was used, i.e. false if
// the point was not in range of the surface for a spatially varying
// size.
virtual bool cellSize
(
const point& pt,
scalar& size
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

175
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/uniform/uniform.C
View File

@ -1,175 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "uniform.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(uniform, 0);
addToRunTimeSelectionTable(cellSizeFunction, uniform, dictionary);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
uniform::uniform
(
const dictionary& initialPointsDict,
const searchableSurface& surface
)
:
cellSizeFunction(typeName, initialPointsDict, surface)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool uniform::cellSize
(
const point& pt,
scalar& size
) const
{
List<pointIndexHit> hits;
surface_.findNearest
(
pointField(1, pt),
scalarField(1, sqr(GREAT)),
hits
);
const pointIndexHit& hitInfo = hits[0];
if (hitInfo.hit())
{
const point& hitPt = hitInfo.hitPoint();
const label index = hitInfo.index();
if (sideMode_ == rmBothsides)
{
size = surfaceCellSizeFunction_().interpolate(hitPt, index);
return true;
}
size = 0;
List<pointIndexHit> closeToSurfaceHits;
surface_.findNearest
(
pointField(1, pt),
scalarField(1, sqr(snapToSurfaceTol_)),
closeToSurfaceHits
);
const pointIndexHit& closeToSurface = closeToSurfaceHits[0];
// If the nearest point is essentially on the surface, do not do a
// getVolumeType calculation, as it will be prone to error.
if (closeToSurface.hit())
{
size = surfaceCellSizeFunction_().interpolate(hitPt, index);
return true;
}
pointField ptF(1, pt);
List<searchableSurface::volumeType> vTL(1);
surface_.getVolumeType(ptF, vTL);
bool functionApplied = false;
if
(
sideMode_ == smInside
&& vTL[0] == searchableSurface::INSIDE
)
{
size = surfaceCellSizeFunction_().interpolate(hitPt, index);
functionApplied = true;
}
else if
(
sideMode_ == smOutside
&& vTL[0] == searchableSurface::OUTSIDE
)
{
size = surfaceCellSizeFunction_().interpolate(hitPt, index);
functionApplied = true;
}
return functionApplied;
}
return false;
}
bool uniform::setCellSize
(
const pointField& pts
)
{
// labelHashSet surfaceAlreadyHit(cellSize_.size());
//
// forAll(pts, ptI)
// {
// const Foam::point& pt = pts[ptI];
//
// List<pointIndexHit> hits;
//
// surface_.findNearest
// (
// pointField(1, pt),
// scalarField(1, sqr(GREAT)),
// hits
// );
//
// if (hits[0].hit() && !surfaceAlreadyHit.found(hits[0].index()))
// {
// surfaceCellSizeFunction_().refineCellSize(hits[0].index());
//
// surfaceAlreadyHit.insert(hits[0].index());
// }
// }
return true;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

106
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/uniform/uniform.H
View File

@ -1,106 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Class
Foam::uniform
Description
SourceFiles
uniform.C
\*---------------------------------------------------------------------------*/
#ifndef uniform_H
#define uniform_H
#include "cellSizeFunction.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class uniform Declaration
\*---------------------------------------------------------------------------*/
class uniform
:
public cellSizeFunction
{
private:
// Private data
public:
//- Runtime type information
TypeName("uniform");
// Constructors
//- Construct from components
uniform
(
const dictionary& initialPointsDict,
const searchableSurface& surface
);
//- Destructor
virtual ~uniform()
{}
// Member Functions
//- Modify scalar argument to the cell size specified by function.
// Return a boolean specifying if the function was used, i.e. false if
// the point was not in range of the surface for a spatially varying
// size.
virtual bool cellSize
(
const point& pt,
scalar& size
) const;
//- Adapt local cell size. Return true if anything changed.
virtual bool setCellSize
(
const pointField& pts
);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

164
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/uniformDistance/uniformDistance.C
View File

@ -1,164 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "uniformDistance.H"
#include "addToRunTimeSelectionTable.H"
#include "dimensionSet.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(uniformDistance, 0);
addToRunTimeSelectionTable(cellSizeFunction, uniformDistance, dictionary);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
uniformDistance::uniformDistance
(
const dictionary& initialPointsDict,
const searchableSurface& surface
)
:
cellSizeFunction(typeName, initialPointsDict, surface),
distance_(readScalar(coeffsDict().lookup("distance"))),
distanceSqr_(sqr(distance_))
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool uniformDistance::cellSize
(
const point& pt,
scalar& size
) const
{
size = 0;
List<pointIndexHit> hits;
surface_.findNearest
(
pointField(1, pt),
scalarField(1, distanceSqr_),
hits
);
const pointIndexHit& hitInfo = hits[0];
if (hitInfo.hit())
{
if (sideMode_ == rmBothsides)
{
size = surfaceCellSizeFunction_().surfaceSize(hitInfo.index());
return true;
}
// If the nearest point is essentially on the surface, do not do a
// getVolumeType calculation, as it will be prone to error.
if (mag(pt - hitInfo.hitPoint()) < snapToSurfaceTol_)
{
size = surfaceCellSizeFunction_().surfaceSize(hitInfo.index());
return true;
}
pointField ptF(1, pt);
List<searchableSurface::volumeType> vTL;
surface_.getVolumeType(ptF, vTL);
bool functionApplied = false;
if
(
sideMode_ == smInside
&& vTL[0] == searchableSurface::INSIDE
)
{
size = surfaceCellSizeFunction_().surfaceSize(hitInfo.index());
functionApplied = true;
}
else if
(
sideMode_ == smOutside
&& vTL[0] == searchableSurface::OUTSIDE
)
{
size = surfaceCellSizeFunction_().surfaceSize(hitInfo.index());
functionApplied = true;
}
return functionApplied;
}
return false;
}
bool uniformDistance::setCellSize
(
const pointField& pts
)
{
labelHashSet surfaceAlreadyHit(surface_.size());
forAll(pts, ptI)
{
const Foam::point& pt = pts[ptI];
List<pointIndexHit> hits;
surface_.findNearest
(
pointField(1, pt),
scalarField(1, distanceSqr_),
hits
);
if (hits[0].hit() && !surfaceAlreadyHit.found(hits[0].index()))
{
surfaceCellSizeFunction_().refineSurfaceSize(hits[0].index());
surfaceAlreadyHit.insert(hits[0].index());
}
}
return true;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

112
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/uniformDistance/uniformDistance.H
View File

@ -1,112 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Class
Foam::uniformDistance
Description
SourceFiles
uniformDistance.C
\*---------------------------------------------------------------------------*/
#ifndef uniformDistance_H
#define uniformDistance_H
#include "cellSizeFunction.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class uniformDistance Declaration
\*---------------------------------------------------------------------------*/
class uniformDistance
:
public cellSizeFunction
{
private:
// Private data
//- Distance
scalar distance_;
//- Distance squared
scalar distanceSqr_;
public:
//- Runtime type information
TypeName("uniformDistance");
// Constructors
//- Construct from components
uniformDistance
(
const dictionary& initialPointsDict,
const searchableSurface& surface
);
//- Destructor
virtual ~uniformDistance()
{}
// Member Functions
//- Modify scalar argument to the cell size specified by function.
// Return a boolean specifying if the function was used, i.e. false if
// the point was not in range of the surface for a spatially varying
// size.
virtual bool cellSize
(
const point& pt,
scalar& size
) const;
//- Adapt local cell size. Return true if anything changed.
virtual bool setCellSize
(
const pointField& pts
);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

292
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/automatic/automatic.C
View File

@ -1,292 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "automatic.H"
#include "addToRunTimeSelectionTable.H"
#include "triSurfaceMesh.H"
#include "vtkSurfaceWriter.H"
#include "Time.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(automatic, 0);
addToRunTimeSelectionTable(cellSizeCalculationType, automatic, dictionary);
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void Foam::automatic::smoothField(triSurfaceScalarField& surf)
{
label nSmoothingIterations = 10;
for (label iter = 0; iter < nSmoothingIterations; ++iter)
{
const pointField& faceCentres = surface_.faceCentres();
forAll(surf, sI)
{
const labelList& faceFaces = surface_.faceFaces()[sI];
const point& fC = faceCentres[sI];
const scalar value = surf[sI];
scalar newValue = 0;
scalar totalDist = 0;
label nFaces = 0;
forAll(faceFaces, fI)
{
const label faceLabel = faceFaces[fI];
const point& faceCentre = faceCentres[faceLabel];
const scalar faceValue = surf[faceLabel];
const scalar distance = mag(faceCentre - fC);
newValue += faceValue/distance;
totalDist += 1.0/distance;
if (value < faceValue)
{
nFaces++;
}
}
// Do not smooth out the peak values
if (nFaces == faceFaces.size())
{
//continue;
}
surf[sI] = newValue/totalDist;
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::automatic::automatic
(
const dictionary& cellSizeCalcTypeDict,
const triSurfaceMesh& surface
)
:
cellSizeCalculationType(typeName, cellSizeCalcTypeDict, surface),
coeffsDict_(cellSizeCalcTypeDict.subDict(typeName + "Coeffs")),
surface_(surface),
surfaceName_(surface.searchableSurface::name()),
readCurvature_(Switch(coeffsDict_.lookup("curvature"))),
curvatureFile_(coeffsDict_.lookup("curvatureFile")),
readFeatureProximity_(Switch(coeffsDict_.lookup("featureProximity"))),
featureProximityFile_(coeffsDict_.lookup("featureProximityFile")),
readInternalCloseness_(Switch(coeffsDict_.lookup("internalCloseness"))),
internalClosenessFile_(coeffsDict_.lookup("internalClosenessFile")),
curvatureCellSizeFactor_
(
readScalar(coeffsDict_.lookup("curvatureCellSizeFactor"))
),
maximumCellSize_
(
readScalar(coeffsDict_.lookup("maximumCellSize"))
)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::triSurfaceScalarField Foam::automatic::load()
{
Info<< indent << "Calculating cell size on surface: "
<< surfaceName_ << endl;
triSurfaceScalarField surfaceCellSize
(
IOobject
(
surfaceName_ + ".cellSize",
surface_.searchableSurface::time().constant(),
"triSurface",
surface_.searchableSurface::time(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
surface_,
dimLength,
scalarField(surface_.size(), maximumCellSize_)
);
if (readCurvature_)
{
Info<< indent << "Reading curvature : "
<< curvatureFile_ << endl;
triSurfacePointScalarField curvature
(
IOobject
(
curvatureFile_,
surface_.searchableSurface::time().constant(),
"triSurface",
surface_.searchableSurface::time(),
IOobject::MUST_READ,
IOobject::NO_WRITE
),
surface_,
dimLength,
true
);
const List<labelledTri>& localFaces = surface_.localFaces();
const labelList& meshPoints = surface_.meshPoints();
forAll(surfaceCellSize, fI)
{
const labelList& facePoints = localFaces[fI].triFaceFace();
scalar interpolatedCurvatureToFace = 0.0;
forAll(facePoints, fpI)
{
interpolatedCurvatureToFace
+= curvature[meshPoints[facePoints[fpI]]];
}
interpolatedCurvatureToFace /= facePoints.size();
surfaceCellSize[fI] =
min
(
1.0
/max
(
(1.0/curvatureCellSizeFactor_)
*interpolatedCurvatureToFace,
1.0/maximumCellSize_
),
surfaceCellSize[fI]
);
}
}
if (readInternalCloseness_)
{
Info<< indent << "Reading internal closeness: "
<< internalClosenessFile_ << endl;
triSurfaceScalarField internalCloseness
(
IOobject
(
internalClosenessFile_,
surface_.searchableSurface::time().constant(),
"triSurface",
surface_.searchableSurface::time(),
IOobject::MUST_READ,
IOobject::NO_WRITE
),
surface_,
dimLength,
true
);
forAll(surfaceCellSize, fI)
{
surfaceCellSize[fI] =
min
(
internalCloseness[fI],
surfaceCellSize[fI]
);
}
}
if (readFeatureProximity_)
{
Info<< indent << "Reading feature proximity : "
<< featureProximityFile_ << endl;
triSurfaceScalarField featureProximity
(
IOobject
(
featureProximityFile_,
surface_.searchableSurface::time().constant(),
"triSurface",
surface_.searchableSurface::time(),
IOobject::MUST_READ,
IOobject::NO_WRITE
),
surface_,
dimLength,
true
);
forAll(surfaceCellSize, fI)
{
surfaceCellSize[fI] =
min
(
featureProximity[fI],
surfaceCellSize[fI]
);
}
}
smoothField(surfaceCellSize);
surfaceCellSize.write();
if (debug)
{
faceList faces(surface_.size());
forAll(surface_, fI)
{
faces[fI] = surface_.triSurface::operator[](fI).triFaceFace();
}
vtkSurfaceWriter().write
(
surface_.searchableSurface::time().constant()/"triSurface",
surfaceName_,
surface_.points(),
faces,
"cellSize",
surfaceCellSize,
false,
true
);
}
return surfaceCellSize;
}
// ************************************************************************* //

129
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/automatic/automatic.H
View File

@ -1,129 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Class
Foam::automatic
Description
SourceFiles
automatic.C
\*---------------------------------------------------------------------------*/
#ifndef automatic_H
#define automatic_H
#include "cellSizeCalculationType.H"
#include "triSurfaceFields.H"
#include "PrimitivePatchInterpolation.H"
#include "Switch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class triSurfaceMesh;
/*---------------------------------------------------------------------------*\
Class automatic Declaration
\*---------------------------------------------------------------------------*/
class automatic
:
public cellSizeCalculationType
{
private:
// Private data
//- Dictionary of coefficients for automatic cell sizing
const dictionary& coeffsDict_;
//- Reference to the triSurfaceMesh
const triSurfaceMesh& surface_;
//- Name of the surface. Used to write the cell size field
const word surfaceName_;
const Switch readCurvature_;
const word curvatureFile_;
const Switch readFeatureProximity_;
const word featureProximityFile_;
const Switch readInternalCloseness_;
const word internalClosenessFile_;
//- The curvature values are multiplied by the inverse of this value to
// get the cell size
const scalar curvatureCellSizeFactor_;
//- The maximum allowable sell size
const scalar maximumCellSize_;
// Private Member Functions
void smoothField(triSurfaceScalarField& surf);
public:
//- Runtime type information
TypeName("automatic");
// Constructors
//- Construct from components
automatic
(
const dictionary& cellSizeCalcTypeDict,
const triSurfaceMesh& surface
);
//- Destructor
virtual ~automatic()
{}
// Member Functions
//- Load the cell size field
virtual triSurfaceScalarField load();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

97
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/cellSizeCalculationType/cellSizeCalculationType.C
View File

@ -1,97 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "cellSizeCalculationType.H"
#include "addToRunTimeSelectionTable.H"
#include "triSurfaceMesh.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(cellSizeCalculationType, 0);
defineRunTimeSelectionTable(cellSizeCalculationType, dictionary);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::cellSizeCalculationType::cellSizeCalculationType
(
const word& type,
const dictionary& cellSizeCalculationTypeDict,
const triSurfaceMesh& surface
)
:
cellSizeCalculationTypeDict_(cellSizeCalculationTypeDict)
{}
// * * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::cellSizeCalculationType> Foam::cellSizeCalculationType::New
(
const dictionary& cellSizeCalculationTypeDict,
const triSurfaceMesh& surface
)
{
word cellSizeCalculationTypeTypeName
(
cellSizeCalculationTypeDict.lookup("cellSizeCalculationType")
);
Info<< " Selecting cellSizeCalculationType "
<< cellSizeCalculationTypeTypeName << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(cellSizeCalculationTypeTypeName);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"cellSizeCalculationType::New(dictionary&, "
"const conformalVoronoiMesh&, const searchableSurface&)"
) << "Unknown cellSizeCalculationType type "
<< cellSizeCalculationTypeTypeName
<< endl << endl
<< "Valid cellSizeCalculationType types are :" << endl
<< dictionaryConstructorTablePtr_->toc()
<< exit(FatalError);
}
return autoPtr<cellSizeCalculationType>
(
cstrIter()(cellSizeCalculationTypeDict, surface)
);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::cellSizeCalculationType::~cellSizeCalculationType()
{}
// ************************************************************************* //

134
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/cellSizeCalculationType/cellSizeCalculationType.H
View File

@ -1,134 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Class
Foam::cellSizeCalculationType
Description
Abstract base class for specifying target cell sizes
SourceFiles
cellSizeCalculationType.C
\*---------------------------------------------------------------------------*/
#ifndef cellSizeCalculationType_H
#define cellSizeCalculationType_H
#include "searchableSurface.H"
#include "autoPtr.H"
#include "runTimeSelectionTables.H"
#include "triSurfaceFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class triSurfaceMesh;
/*---------------------------------------------------------------------------*\
Class cellSizeCalculationType Declaration
\*---------------------------------------------------------------------------*/
class cellSizeCalculationType
{
protected:
const dictionary& cellSizeCalculationTypeDict_;
private:
// Private Member Functions
//- Disallow default bitwise copy construct
cellSizeCalculationType(const cellSizeCalculationType&);
//- Disallow default bitwise assignment
void operator=(const cellSizeCalculationType&);
public:
//- Runtime type information
TypeName("cellSizeCalculationType");
// Declare run-time constructor selection table
declareRunTimeSelectionTable
(
autoPtr,
cellSizeCalculationType,
dictionary,
(
const dictionary& cellSizeCalculationTypeDict,
const triSurfaceMesh& surface
),
(cellSizeCalculationTypeDict, surface)
);
// Constructors
//- Construct from components
cellSizeCalculationType
(
const word& type,
const dictionary& cellSizeCalculationTypeDict,
const triSurfaceMesh& surface
);
// Selectors
//- Return a reference to the selected cellSizeCalculationType
static autoPtr<cellSizeCalculationType> New
(
const dictionary& cellSizeCalculationTypeDict,
const triSurfaceMesh& surface
);
//- Destructor
virtual ~cellSizeCalculationType();
// Member Functions
//- Load the cell size
virtual triSurfaceScalarField load() = 0;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

88
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/fieldFromFile/fieldFromFile.C
View File

@ -1,88 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "fieldFromFile.H"
#include "addToRunTimeSelectionTable.H"
#include "triSurfaceMesh.H"
#include "triSurfaceFields.H"
#include "Time.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(fieldFromFile, 0);
addToRunTimeSelectionTable
(
cellSizeCalculationType,
fieldFromFile,
dictionary
);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::fieldFromFile::fieldFromFile
(
const dictionary& cellSizeCalcTypeDict,
const triSurfaceMesh& surface
)
:
cellSizeCalculationType(typeName, cellSizeCalcTypeDict, surface),
surface_(surface),
fileName_
(
cellSizeCalcTypeDict.subDict(typeName + "Coeffs").lookup("fieldFile")
)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::triSurfaceScalarField Foam::fieldFromFile::load()
{
Info<< indent << "Loading: " << fileName_ << endl;
triSurfaceScalarField surfaceCellSize
(
IOobject
(
fileName_,
surface_.searchableSurface::time().constant(),
"triSurface",
surface_.searchableSurface::time(),
IOobject::MUST_READ,
IOobject::NO_WRITE
),
surface_,
dimLength,
true
);
return surfaceCellSize;
}
// ************************************************************************* //

105
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/fieldFromFile/fieldFromFile.H
View File

@ -1,105 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Class
Foam::fieldFromFile
Description
SourceFiles
fieldFromFile.C
\*---------------------------------------------------------------------------*/
#ifndef fieldFromFile_H
#define fieldFromFile_H
#include "cellSizeCalculationType.H"
#include "triSurfaceFields.H"
#include "PrimitivePatchInterpolation.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class triSurfaceMesh;
/*---------------------------------------------------------------------------*\
Class fieldFromFile Declaration
\*---------------------------------------------------------------------------*/
class fieldFromFile
:
public cellSizeCalculationType
{
private:
// Private data
//- Reference to the triSurfaceMesh
const triSurfaceMesh& surface_;
//- Name of the triSurfaceScalarField file to load in. Must be in
// constant/triSurface
const word fileName_;
public:
//- Runtime type information
TypeName("fieldFromFile");
// Constructors
//- Construct from components
fieldFromFile
(
const dictionary& cellSizeCalcTypeDict,
const triSurfaceMesh& surface
);
//- Destructor
virtual ~fieldFromFile()
{}
// Member Functions
//- Load the cell size field
virtual triSurfaceScalarField load();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

167
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/nonUniformField/nonUniformField.C
View File

@ -1,167 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "nonUniformField.H"
#include "triSurfaceMesh.H"
#include "searchableSurface.H"
#include "addToRunTimeSelectionTable.H"
#include "Time.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(nonUniformField, 0);
addToRunTimeSelectionTable
(
surfaceCellSizeFunction,
nonUniformField,
dictionary
);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::nonUniformField::nonUniformField
(
const dictionary& cellSizeFunctionDict,
const searchableSurface& surface
)
:
surfaceCellSizeFunction(typeName, cellSizeFunctionDict, surface),
surfaceTriMesh_(refCast<const triSurfaceMesh>(surface)),
surfaceCellSize_
(
IOobject
(
"surfaceCellSize.cellSize",
surface.time().constant(),
"triSurface",
surface.time(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
surfaceTriMesh_,
dimLength,
false
),
cellSizeCalculationType_
(
cellSizeCalculationType::New(coeffsDict(), surfaceTriMesh_)
),
pointCellSize_(),
patch_()
{
Info<< incrIndent << incrIndent;
surfaceCellSize_ = cellSizeCalculationType_().load();
Info<< decrIndent;
Info<< indent << "Cell size field statistics:" << nl
<< indent << " Minimum: " << min(surfaceCellSize_).value() << nl
<< indent << " Average: " << average(surfaceCellSize_).value() << nl
<< indent << " Maximum: " << max(surfaceCellSize_).value() << endl;
Info<< decrIndent;
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const Foam::scalar& Foam::nonUniformField::surfaceSize(const label index) const
{
return surfaceCellSize_[index];
}
const Foam::scalar& Foam::nonUniformField::refineSurfaceSize(const label index)
{
surfaceCellSize_[index] *= refinementFactor_;
return surfaceCellSize_[index];
}
Foam::scalar Foam::nonUniformField::interpolate
(
const point& pt,
const label index
) const
{
if (patch_.empty())
{
recalculateInterpolation();
}
const face& faceHitByPt = surfaceTriMesh_.triSurface::operator[](index);
const pointField& pts = surfaceTriMesh_.points();
const Map<label>& pMap = surfaceTriMesh_.meshPointMap();
triPointRef tri
(
pts[faceHitByPt[0]],
pts[faceHitByPt[1]],
pts[faceHitByPt[2]]
);
scalarList bary(3, 0.0);
tri.barycentric(pt, bary);
return pointCellSize_()[pMap[faceHitByPt[0]]]*bary[0]
+ pointCellSize_()[pMap[faceHitByPt[1]]]*bary[1]
+ pointCellSize_()[pMap[faceHitByPt[2]]]*bary[2];
}
void Foam::nonUniformField::recalculateInterpolation() const
{
patch_.reset(new primitivePatchInterpolation(surfaceTriMesh_));
pointCellSize_.reset
(
new triSurfacePointScalarField
(
IOobject
(
"pointCellSize.cellSize",
surfaceTriMesh_.searchableSurface::time().constant(),
"triSurface",
surfaceTriMesh_.searchableSurface::time(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
surfaceTriMesh_,
dimLength,
patch_().faceToPointInterpolate(surfaceCellSize_)
)
);
}
// ************************************************************************* //

123
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/nonUniformField/nonUniformField.H
View File

@ -1,123 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Class
Foam::nonUniformField
Description
SourceFiles
nonUniformField.C
\*---------------------------------------------------------------------------*/
#ifndef nonUniformField_H
#define nonUniformField_H
#include "triSurfaceFields.H"
#include "PrimitivePatchInterpolation.H"
#include "surfaceCellSizeFunction.H"
#include "cellSizeCalculationType.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class triSurfaceMesh;
class searchableSurface;
/*---------------------------------------------------------------------------*\
Class nonUniformField Declaration
\*---------------------------------------------------------------------------*/
class nonUniformField
:
public surfaceCellSizeFunction
{
protected:
// Private typedef
typedef PrimitivePatchInterpolation
<
PrimitivePatch<labelledTri, List, pointField, point>
> primitivePatchInterpolation;
// Private data
const triSurfaceMesh& surfaceTriMesh_;
triSurfaceScalarField surfaceCellSize_;
autoPtr<cellSizeCalculationType> cellSizeCalculationType_;
mutable autoPtr<triSurfacePointScalarField> pointCellSize_;
mutable autoPtr<primitivePatchInterpolation> patch_;
public:
//- Runtime type information
TypeName("nonUniformField");
// Constructors
//- Construct from components
nonUniformField
(
const dictionary& cellSizeFunctionDict,
const searchableSurface& surface
);
//- Destructor
virtual ~nonUniformField()
{}
// Member Functions
virtual const scalar& surfaceSize(const label index) const;
virtual const scalar& refineSurfaceSize(const label index);
virtual scalar interpolate(const point& pt, const label index) const;
virtual void recalculateInterpolation() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

102
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/surfaceCellSizeFunction/surfaceCellSizeFunction.C
View File

@ -1,102 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "surfaceCellSizeFunction.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(surfaceCellSizeFunction, 0);
defineRunTimeSelectionTable(surfaceCellSizeFunction, dictionary);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::surfaceCellSizeFunction::surfaceCellSizeFunction
(
const word& type,
const dictionary& surfaceCellSizeFunctionDict,
const searchableSurface& surface
)
:
dictionary(surfaceCellSizeFunctionDict),
surface_(surface),
coeffsDict_(subDict(type + "Coeffs")),
refinementFactor_
(
lookupOrDefault<scalar>("refinementFactor", 1.0)
)
{}
// * * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::surfaceCellSizeFunction> Foam::surfaceCellSizeFunction::New
(
const dictionary& surfaceCellSizeFunctionDict,
const searchableSurface& surface
)
{
word surfaceCellSizeFunctionTypeName
(
surfaceCellSizeFunctionDict.lookup("surfaceCellSizeFunction")
);
Info<< " Selecting surfaceCellSizeFunction "
<< surfaceCellSizeFunctionTypeName << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(surfaceCellSizeFunctionTypeName);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"surfaceCellSizeFunction::New(dictionary&, "
"const conformalVoronoiMesh&, const searchableSurface&)"
) << "Unknown surfaceCellSizeFunction type "
<< surfaceCellSizeFunctionTypeName
<< endl << endl
<< "Valid surfaceCellSizeFunction types are :" << endl
<< dictionaryConstructorTablePtr_->toc()
<< exit(FatalError);
}
return autoPtr<surfaceCellSizeFunction>
(
cstrIter()(surfaceCellSizeFunctionDict, surface)
);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::surfaceCellSizeFunction::~surfaceCellSizeFunction()
{}
// ************************************************************************* //

159
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/surfaceCellSizeFunction/surfaceCellSizeFunction.H
View File

@ -1,159 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Class
Foam::surfaceCellSizeFunction
Description
Abstract base class for specifying target cell sizes
SourceFiles
surfaceCellSizeFunction.C
\*---------------------------------------------------------------------------*/
#ifndef surfaceCellSizeFunction_H
#define surfaceCellSizeFunction_H
#include "searchableSurface.H"
#include "dictionary.H"
#include "autoPtr.H"
#include "runTimeSelectionTables.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class surfaceCellSizeFunction Declaration
\*---------------------------------------------------------------------------*/
class surfaceCellSizeFunction
:
public dictionary
{
protected:
// Protected data
//- Reference to the searchableSurface that surfaceCellSizeFunction
// relates to
const searchableSurface& surface_;
const dictionary coeffsDict_;
//- If cell resizing is allowed, this is the factor of the old cell size
// to get the new cell size
scalar refinementFactor_;
private:
// Private Member Functions
//- Disallow default bitwise copy construct
surfaceCellSizeFunction(const surfaceCellSizeFunction&);
//- Disallow default bitwise assignment
void operator=(const surfaceCellSizeFunction&);
public:
//- Runtime type information
TypeName("surfaceCellSizeFunction");
// Declare run-time constructor selection table
declareRunTimeSelectionTable
(
autoPtr,
surfaceCellSizeFunction,
dictionary,
(
const dictionary& surfaceCellSizeFunctionDict,
const searchableSurface& surface
),
(surfaceCellSizeFunctionDict, surface)
);
// Constructors
//- Construct from components
surfaceCellSizeFunction
(
const word& type,
const dictionary& surfaceCellSizeFunctionDict,
const searchableSurface& surface
);
// Selectors
//- Return a reference to the selected surfaceCellSizeFunction
static autoPtr<surfaceCellSizeFunction> New
(
const dictionary& surfaceCellSizeFunctionDict,
const searchableSurface& surface
);
//- Destructor
virtual ~surfaceCellSizeFunction();
// Member Functions
//- Const access to the details dictionary
inline const dictionary& coeffsDict() const
{
return coeffsDict_;
}
virtual const scalar& surfaceSize(const label index) const = 0;
virtual const scalar& refineSurfaceSize(const label index) = 0;
virtual scalar interpolate
(
const point& pt,
const label index
) const = 0;
virtual void recalculateInterpolation() const = 0;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

86
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/uniformValue/uniformValue.C
View File

@ -1,86 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "uniformValue.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(uniformValue, 0);
addToRunTimeSelectionTable
(
surfaceCellSizeFunction,
uniformValue,
dictionary
);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::uniformValue::uniformValue
(
const dictionary& cellSizeFunctionDict,
const searchableSurface& surface
)
:
surfaceCellSizeFunction(typeName, cellSizeFunctionDict, surface),
surfaceCellSize_(readScalar(coeffsDict().lookup("surfaceCellSize")))
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const Foam::scalar& Foam::uniformValue::surfaceSize(const label index) const
{
return surfaceCellSize_;
}
const Foam::scalar& Foam::uniformValue::refineSurfaceSize(const label index)
{
surfaceCellSize_ *= refinementFactor_;
return surfaceCellSize_;
}
Foam::scalar Foam::uniformValue::interpolate
(
const point& pt,
const label index
) const
{
return surfaceCellSize_;
}
void Foam::uniformValue::recalculateInterpolation() const
{}
// ************************************************************************* //

105
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/uniformValue/uniformValue.H
View File

@ -1,105 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Class
Foam::uniformValue
Description
SourceFiles
uniformValue.C
\*---------------------------------------------------------------------------*/
#ifndef uniformValue_H
#define uniformValue_H
#include "surfaceCellSizeFunction.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class uniformValue Declaration
\*---------------------------------------------------------------------------*/
class uniformValue
:
public surfaceCellSizeFunction
{
private:
// Private data
scalar surfaceCellSize_;
public:
//- Runtime type information
TypeName("uniformValue");
// Constructors
//- Construct from components
uniformValue
(
const dictionary& cellSizeFunctionDict,
const searchableSurface& surface
);
//- Destructor
virtual ~uniformValue()
{}
// Member Functions
virtual const scalar& surfaceSize(const label index) const;
virtual const scalar& refineSurfaceSize(const label index);
virtual scalar interpolate
(
const point& pt,
const label index
) const;
virtual void recalculateInterpolation() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

62
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/CGALTriangulation3DKernel.H
View File

@ -1,62 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Typedefs
CGALTriangulation3DKernel
Description
\*---------------------------------------------------------------------------*/
#ifndef CGALTriangulation3DKernel_H
#define CGALTriangulation3DKernel_H
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "CGAL/Delaunay_triangulation_3.h"
#ifdef CGAL_INEXACT
// Fast kernel using a double as the storage type but the triangulation may
// fail. Adding robust circumcentre traits
#include "CGAL/Exact_predicates_inexact_constructions_kernel.h"
typedef CGAL::Exact_predicates_inexact_constructions_kernel baseK;
// #include <CGAL/Robust_circumcenter_traits_3.h>
#include <CGAL/Robust_circumcenter_filtered_traits_3.h>
// typedef CGAL::Robust_circumcenter_traits_3<baseK> K;
typedef CGAL::Robust_circumcenter_filtered_traits_3<baseK> K;
#else
// Very robust but expensive kernel
#include "CGAL/Exact_predicates_exact_constructions_kernel.h"
typedef CGAL::Exact_predicates_exact_constructions_kernel baseK;
typedef CGAL::Exact_predicates_exact_constructions_kernel K;
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/CGALTriangulation3Ddefs.H
View File

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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/>.
Typedefs
CGALTriangulation3Ddefs
Description
CGAL data structures used for 3D Delaunay meshing.
Define CGAL_INEXACT to use Exact_predicates_inexact_constructions kernel
otherwise the more robust but much less efficient
Exact_predicates_exact_constructions will be used.
\*---------------------------------------------------------------------------*/
#ifndef CGALTriangulation3Ddefs_H
#define CGALTriangulation3Ddefs_H
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "CGALTriangulation3DKernel.H"
#include "indexedVertex.H"
#include "indexedCell.H"
typedef CGAL::indexedVertex<K> Vb;
typedef CGAL::indexedCell<K> Cb;
typedef CGAL::Compact_location CompactLocator;
typedef CGAL::Fast_location FastLocator;
typedef CGAL::Triangulation_data_structure_3<Vb, Cb> Tds;
typedef CGAL::Delaunay_triangulation_3<K, Tds, CompactLocator> Delaunay;
typedef CGAL::Delaunay_triangulation_3<K, Tds, FastLocator> CellSizeDelaunay;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

2224
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMesh.C
View File

File diff suppressed because it is too large Load Diff

1197
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMesh.H
View File

File diff suppressed because it is too large Load Diff

2571
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C
View File

File diff suppressed because it is too large Load Diff

2106
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshConformToSurface.C
View File

File diff suppressed because it is too large Load Diff

436
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshFeaturePointSpecialisations.C
View File

@ -1,436 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "conformalVoronoiMesh.H"
#include "vectorTools.H"
using namespace Foam::vectorTools;
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
Foam::List<Foam::extendedFeatureEdgeMesh::edgeStatus>
Foam::conformalVoronoiMesh::calcPointFeatureEdgesTypes
(
const extendedFeatureEdgeMesh& feMesh,
const labelList& pEds,
pointFeatureEdgesTypes& pFEdgeTypes
)
{
List<extendedFeatureEdgeMesh::edgeStatus> allEdStat(pEds.size());
forAll(pEds, i)
{
label edgeI = pEds[i];
extendedFeatureEdgeMesh::edgeStatus& eS = allEdStat[i];
eS = feMesh.getEdgeStatus(edgeI);
pFEdgeTypes(eS)++;
}
if (debug)
{
Info<< pFEdgeTypes << endl;
}
return allEdStat;
}
bool Foam::conformalVoronoiMesh::createSpecialisedFeaturePoint
(
const extendedFeatureEdgeMesh& feMesh,
const labelList& pEds,
const pointFeatureEdgesTypes& pFEdgesTypes,
const List<extendedFeatureEdgeMesh::edgeStatus>& allEdStat,
const label ptI,
DynamicList<Vb>& pts
)
{
if
(
!pFEdgesTypes.found(extendedFeatureEdgeMesh::EXTERNAL)
|| !pFEdgesTypes.found(extendedFeatureEdgeMesh::INTERNAL)
)
{
return false;
}
if
(
pFEdgesTypes[extendedFeatureEdgeMesh::EXTERNAL] == 2
&& pFEdgesTypes[extendedFeatureEdgeMesh::INTERNAL] == 1
&& pEds.size() == 3
)
{
Info<< "nExternal == 2 && nInternal == 1" << endl;
const Foam::point& featPt = feMesh.points()[ptI];
if (!positionOnThisProc(featPt))
{
return false;
}
label nVert = number_of_vertices();
const label initialNumOfPoints = pts.size();
const scalar ppDist = pointPairDistance(featPt);
const vectorField& normals = feMesh.normals();
const labelListList& edgeNormals = feMesh.edgeNormals();
label concaveEdgeI = -1;
labelList convexEdgesI(2, -1);
label nConvex = 0;
forAll(pEds, i)
{
const extendedFeatureEdgeMesh::edgeStatus& eS = allEdStat[i];
if (eS == extendedFeatureEdgeMesh::INTERNAL)
{
concaveEdgeI = pEds[i];
}
else if (eS == extendedFeatureEdgeMesh::EXTERNAL)
{
convexEdgesI[nConvex++] = pEds[i];
}
else if (eS == extendedFeatureEdgeMesh::FLAT)
{
WarningIn("Foam::conformalVoronoiMesh::"
"createSpecialisedFeaturePoint")
<< "Edge " << eS << " is flat"
<< endl;
}
else
{
FatalErrorIn("Foam::conformalVoronoiMesh::"
"createSpecialisedFeaturePoint")
<< "Edge " << eS << " not concave/convex"
<< exit(FatalError);
}
}
const vector& concaveEdgePlaneANormal =
normals[edgeNormals[concaveEdgeI][0]];
const vector& concaveEdgePlaneBNormal =
normals[edgeNormals[concaveEdgeI][1]];
// Intersect planes parallel to the concave edge planes offset
// by ppDist and the plane defined by featPt and the edge vector.
plane planeA
(
featPt + ppDist*concaveEdgePlaneANormal,
concaveEdgePlaneANormal
);
plane planeB
(
featPt + ppDist*concaveEdgePlaneBNormal,
concaveEdgePlaneBNormal
);
const vector& concaveEdgeDir = feMesh.edgeDirection
(
concaveEdgeI,
ptI
);
// Todo,needed later but want to get rid of this.
const Foam::point concaveEdgeLocalFeatPt =
featPt + ppDist*concaveEdgeDir;
// Finding the nearest point on the intersecting line to the edge
// point. Floating point errors often occur using planePlaneIntersect
plane planeF(concaveEdgeLocalFeatPt, concaveEdgeDir);
const Foam::point concaveEdgeExternalPt = planeF.planePlaneIntersect
(
planeA,
planeB
);
// Redefine planes to be on the feature surfaces to project through
planeA = plane(featPt, concaveEdgePlaneANormal);
planeB = plane(featPt, concaveEdgePlaneBNormal);
const Foam::point internalPtA =
concaveEdgeExternalPt
- 2.0*planeA.distance(concaveEdgeExternalPt)
*concaveEdgePlaneANormal;
pts.append
(
Vb(internalPtA, Vb::vtInternalFeaturePoint)
);
const Foam::point internalPtB =
concaveEdgeExternalPt
- 2.0*planeB.distance(concaveEdgeExternalPt)
*concaveEdgePlaneBNormal;
pts.append
(
Vb(internalPtB, Vb::vtInternalFeaturePoint)
);
// Add the external points
Foam::point externalPtD;
Foam::point externalPtE;
vector convexEdgePlaneCNormal(0,0,0);
vector convexEdgePlaneDNormal(0,0,0);
const labelList& concaveEdgeNormals = edgeNormals[concaveEdgeI];
const labelList& convexEdgeANormals = edgeNormals[convexEdgesI[0]];
const labelList& convexEdgeBNormals = edgeNormals[convexEdgesI[1]];
forAll(concaveEdgeNormals, edgeNormalI)
{
bool convexEdgeA = false;
bool convexEdgeB = false;
forAll(convexEdgeANormals, edgeAnormalI)
{
const vector& concaveNormal
= normals[concaveEdgeNormals[edgeNormalI]];
const vector& convexNormal
= normals[convexEdgeANormals[edgeAnormalI]];
Info<< "Angle between vectors = "
<< degAngleBetween(concaveNormal, convexNormal) << endl;
// Need a looser tolerance, because sometimes adjacent triangles
// on the same surface will be slightly out of alignment.
if (areParallel(concaveNormal, convexNormal, tolParallel))
{
convexEdgeA = true;
}
}
forAll(convexEdgeBNormals, edgeBnormalI)
{
const vector& concaveNormal
= normals[concaveEdgeNormals[edgeNormalI]];
const vector& convexNormal
= normals[convexEdgeBNormals[edgeBnormalI]];
Info<< "Angle between vectors = "
<< degAngleBetween(concaveNormal, convexNormal) << endl;
// Need a looser tolerance, because sometimes adjacent triangles
// on the same surface will be slightly out of alignment.
if (areParallel(concaveNormal, convexNormal, tolParallel))
{
convexEdgeB = true;
}
}
if ((convexEdgeA && convexEdgeB) || (!convexEdgeA && !convexEdgeB))
{
WarningIn
(
"Foam::conformalVoronoiMesh"
"::createSpecialisedFeaturePoint"
)
<< "Both or neither of the convex edges share the concave "
<< "edge's normal."
<< " convexEdgeA = " << convexEdgeA
<< " convexEdgeB = " << convexEdgeB
<< endl;
// Remove points that have just been added before returning
for (label i = 0; i < 2; ++i)
{
pts.remove();
nVert--;
}
return false;
}
if (convexEdgeA)
{
forAll(convexEdgeANormals, edgeAnormalI)
{
const vector& concaveNormal
= normals[concaveEdgeNormals[edgeNormalI]];
const vector& convexNormal
= normals[convexEdgeANormals[edgeAnormalI]];
if
(
!areParallel(concaveNormal, convexNormal, tolParallel)
)
{
convexEdgePlaneCNormal = convexNormal;
plane planeC(featPt, convexEdgePlaneCNormal);
externalPtD =
internalPtA
+ 2.0*planeC.distance(internalPtA)
*convexEdgePlaneCNormal;
pts.append
(
Vb(externalPtD, Vb::vtExternalFeaturePoint)
);
}
}
}
if (convexEdgeB)
{
forAll(convexEdgeBNormals, edgeBnormalI)
{
const vector& concaveNormal
= normals[concaveEdgeNormals[edgeNormalI]];
const vector& convexNormal
= normals[convexEdgeBNormals[edgeBnormalI]];
if
(
!areParallel(concaveNormal, convexNormal, tolParallel)
)
{
convexEdgePlaneDNormal = convexNormal;
plane planeD(featPt, convexEdgePlaneDNormal);
externalPtE =
internalPtB
+ 2.0*planeD.distance(internalPtB)
*convexEdgePlaneDNormal;
pts.append
(
Vb(externalPtE, Vb::vtExternalFeaturePoint)
);
}
}
}
}
pts.append
(
Vb(concaveEdgeExternalPt, Vb::vtExternalFeaturePoint)
);
const scalar totalAngle = radToDeg
(
constant::mathematical::pi
+ radAngleBetween(concaveEdgePlaneANormal, concaveEdgePlaneBNormal)
);
if (totalAngle > cvMeshControls().maxQuadAngle())
{
// Add additional mitreing points
//scalar angleSign = 1.0;
vector convexEdgesPlaneNormal =
0.5*(convexEdgePlaneCNormal + convexEdgePlaneDNormal);
plane planeM(featPt, convexEdgesPlaneNormal);
// if
// (
// geometryToConformTo_.outside
// (
// featPt - convexEdgesPlaneNormal*ppDist
// )
// )
// {
// angleSign = -1.0;
// }
// scalar phi =
// angleSign*acos(concaveEdgeDir & -convexEdgesPlaneNormal);
//
// scalar guard =
// (
// 1.0 + sin(phi)*ppDist/mag
// (
// concaveEdgeLocalFeatPt - concaveEdgeExternalPt
// )
// )/cos(phi) - 1.0;
const Foam::point internalPtF =
concaveEdgeExternalPt
//+ (2.0 + guard)*(concaveEdgeLocalFeatPt - concaveEdgeExternalPt);
+ 2.0*(concaveEdgeLocalFeatPt - concaveEdgeExternalPt);
pts.append
(
Vb(internalPtF, Vb::vtInternalFeaturePoint)
);
const Foam::point externalPtG =
internalPtF
+ 2.0*planeM.distance(internalPtF)*convexEdgesPlaneNormal;
pts.append
(
Vb(externalPtG, Vb::vtExternalFeaturePoint)
);
}
if (debug)
{
for (label ptI = initialNumOfPoints; ptI < pts.size(); ++ptI)
{
Info<< "Point " << ptI << " : ";
meshTools::writeOBJ(Info, topoint(pts[ptI].point()));
}
}
return true;
}
else if
(
pFEdgesTypes[extendedFeatureEdgeMesh::EXTERNAL] == 1
&& pFEdgesTypes[extendedFeatureEdgeMesh::INTERNAL] == 2
)
{
// Info<< "nExternal == 1 && nInternal == 2" << endl;
return false;
}
return false;
}
// ************************************************************************* //

1235
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshFeaturePoints.C
View File

File diff suppressed because it is too large Load Diff

692
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshI.H
View File

@ -1,692 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 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/>.
\*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
inline Foam::scalar Foam::conformalVoronoiMesh::defaultCellSize() const
{
return cvMeshControls().defaultCellSize();
}
inline Foam::scalar Foam::conformalVoronoiMesh::targetCellSize
(
const Foam::point& pt
) const
{
return cellShapeControls().cellSize(pt);
}
inline Foam::scalar Foam::conformalVoronoiMesh::averageCellSize
(
const Vertex_handle& vA,
const Vertex_handle& vB
) const
{
// Arithmetic mean
// return 0.5*(vA->targetCellSize() + vB->targetCellSize());
// Geometric mean
return sqrt(vA->targetCellSize()*vB->targetCellSize());
// Harmonic mean
// return
// 2.0*(vA->targetCellSize()*vB->targetCellSize())
// /(vA->targetCellSize() + vB->targetCellSize());
}
inline Foam::scalar Foam::conformalVoronoiMesh::averageAnyCellSize
(
const Vertex_handle& vA,
const Vertex_handle& vB
) const
{
if
(
(!vA->internalOrBoundaryPoint() || vA->referred())
&& (!vB->internalOrBoundaryPoint() || vB->referred())
)
{
// There are no internalOrBoundaryPoints available, determine
// size from scratch
// Geometric mean
return sqrt
(
targetCellSize(topoint(vA->point()))
*targetCellSize(topoint(vB->point()))
);
}
else if (!vB->internalOrBoundaryPoint() || vB->referred())
{
return vA->targetCellSize();
}
else if (!vA->internalOrBoundaryPoint() || vA->referred())
{
return vB->targetCellSize();
}
return averageCellSize(vA, vB);
}
inline Foam::scalar Foam::conformalVoronoiMesh::averageAnyCellSize
(
const Delaunay::Finite_facets_iterator& fit
) const
{
// Arithmetic mean
scalar sizeSum = 0;
label nProducts = 0;
const Cell_handle c(fit->first);
const int oppositeVertex = fit->second;
for (label i = 0; i < 3; i++)
{
Vertex_handle v = c->vertex(vertex_triple_index(oppositeVertex, i));
if (v->internalOrBoundaryPoint() && !v->referred())
{
sizeSum += v->targetCellSize();
nProducts++;
}
}
if (nProducts < 1)
{
// There are no internalOrBoundaryPoints available, determine
// size from scratch
for (label i = 0; i < 3; i++)
{
Vertex_handle v = c->vertex(vertex_triple_index(oppositeVertex, i));
sizeSum += targetCellSize(topoint(v->point()));
}
nProducts = 3;
}
if (sizeSum < 0)
{
WarningIn("averageAnyCellSize(const Delaunay::Finite_facets_iterator&)")
<< "sizeSum = " << sizeSum
<< endl;
return 0;
}
return pow(sizeSum, (1.0/nProducts));
}
inline Foam::scalar Foam::conformalVoronoiMesh::pointPairDistance
(
const Foam::point& pt
) const
{
return targetCellSize(pt)*cvMeshControls().pointPairDistanceCoeff();
}
inline Foam::scalar Foam::conformalVoronoiMesh::mixedFeaturePointDistance
(
const Foam::point& pt
) const
{
return
pointPairDistance(pt)
*cvMeshControls().mixedFeaturePointPPDistanceCoeff();
}
inline Foam::scalar Foam::conformalVoronoiMesh::featurePointExclusionDistanceSqr
(
const Foam::point& pt
) const
{
return
sqr
(
targetCellSize(pt)
*cvMeshControls().featurePointExclusionDistanceCoeff()
);
}
inline Foam::scalar Foam::conformalVoronoiMesh::featureEdgeExclusionDistanceSqr
(
const Foam::point& pt
) const
{
return
sqr
(
targetCellSize(pt)
*cvMeshControls().featureEdgeExclusionDistanceCoeff()
);
}
inline Foam::scalar Foam::conformalVoronoiMesh::surfacePtExclusionDistanceSqr
(
const Foam::point& pt
) const
{
return
sqr
(
targetCellSize(pt)
*cvMeshControls().surfacePtExclusionDistanceCoeff()
);
}
inline Foam::scalar Foam::conformalVoronoiMesh::surfaceSearchDistanceSqr
(
const Foam::point& pt
) const
{
return
sqr(targetCellSize(pt)*cvMeshControls().surfaceSearchDistanceCoeff());
}
inline Foam::scalar Foam::conformalVoronoiMesh::maxSurfaceProtrusion
(
const Foam::point& pt
) const
{
return targetCellSize(pt)*cvMeshControls().maxSurfaceProtrusionCoeff();
}
inline bool Foam::conformalVoronoiMesh::insertPoint
(
const Foam::point& p,
const indexedVertexEnum::vertexType type
)
{
return insertPoint(toPoint<Point>(p), type);
}
inline bool Foam::conformalVoronoiMesh::insertPoint
(
const Point& P,
const indexedVertexEnum::vertexType type
)
{
uint nVert = number_of_vertices();
Vertex_handle vh = insert(P);
bool pointInserted = true;
if (nVert == number_of_vertices())
{
Pout<< "Failed to insert point : " << topoint(P)
<< " of type " << type << endl;
pointInserted = false;
}
else
{
vh->index() = getNewVertexIndex();
vh->type() = type;
}
return pointInserted;
}
inline bool Foam::conformalVoronoiMesh::insertReferredPoint(const Vb& P)
{
return insertReferredPoint(P.point(), P.index(), P.type(), P.procIndex());
}
inline bool Foam::conformalVoronoiMesh::insertReferredPoint
(
const Foam::point& p,
const label index,
const indexedVertexEnum::vertexType type,
const label processor
)
{
return insertReferredPoint(toPoint<Point>(p), index, type, processor);
}
inline bool Foam::conformalVoronoiMesh::insertReferredPoint
(
const Point& P,
const label index,
const indexedVertexEnum::vertexType type,
const label processor
)
{
uint nVert = number_of_vertices();
Vertex_handle vh = insert(P);
bool pointInserted = true;
if (nVert == number_of_vertices())
{
Pout<< "Failed to insert point " << topoint(P)
<< " type: " << type << " index: " << index
<< " proc: " << processor << endl;
pointInserted = false;
}
else
{
vh->index() = index;
vh->type() = type;
vh->procIndex() = processor;
}
return pointInserted;
}
inline void Foam::conformalVoronoiMesh::createPointPair
(
const scalar ppDist,
const Foam::point& surfPt,
const vector& n,
DynamicList<Vb>& pts
)
{
vector ppDistn = ppDist*n;
pts.append
(
Vb
(
surfPt - ppDistn,
Vb::vtInternalSurface
)
);
pts.append
(
Vb
(
surfPt + ppDistn,
Vb::vtExternalSurface
)
);
}
inline Foam::point Foam::conformalVoronoiMesh::perturbPoint
(
const Foam::point& pt
) const
{
Foam::point perturbedPt(pt);
// vector delta(xR/ni, yR/nj, zR/nk);
// scalar pert = randomPerturbationCoeff*cmptMin(delta);
scalar pert = 1e-12*defaultCellSize();
perturbedPt.x() += pert*(rndGen_.scalar01() - 0.5);
perturbedPt.y() += pert*(rndGen_.scalar01() - 0.5);
perturbedPt.z() += pert*(rndGen_.scalar01() - 0.5);
return perturbedPt;
}
inline void Foam::conformalVoronoiMesh::createBafflePointPair
(
const scalar ppDist,
const Foam::point& surfPt,
const vector& n,
DynamicList<Vb>& pts
)
{
vector ppDistn = ppDist*n;
pts.append
(
Vb(surfPt - ppDistn, Vb::vtInternalSurface)
);
pts.append
(
Vb(surfPt + ppDistn, Vb::vtInternalSurface)
);
}
inline bool Foam::conformalVoronoiMesh::isPointPair
(
const Vertex_handle& vA,
const Vertex_handle& vB
) const
{
// Want to do this topologically, but problem if vertices are redistributed
// so that one of the point pair is one processor and the other is on
// another.
const Foam::point& ptA = topoint(vA->point());
const Foam::point& ptB = topoint(vB->point());
if
(
(
vA->type() == Vb::vtInternalSurface
&& vB->type() == Vb::vtExternalSurface
)
||
(
vB->type() == Vb::vtInternalSurface
&& vA->type() == Vb::vtExternalSurface
)
||
(
vA->type() == Vb::vtInternalFeatureEdge
&& vB->type() == Vb::vtExternalFeatureEdge
)
||
(
vB->type() == Vb::vtInternalFeatureEdge
&& vA->type() == Vb::vtExternalFeatureEdge
)
||
(
vA->type() == Vb::vtInternalSurface
&& vB->type() == Vb::vtExternalFeatureEdge
)
||
(
vB->type() == Vb::vtInternalSurface
&& vA->type() == Vb::vtExternalFeatureEdge
)
||
(
vA->type() == Vb::vtExternalSurface
&& vB->type() == Vb::vtInternalFeatureEdge
)
||
(
vB->type() == Vb::vtExternalSurface
&& vA->type() == Vb::vtInternalFeatureEdge
)
)
{
const scalar distSqr = magSqr(ptA - ptB);
const scalar ppDistSqr = sqr(2*pointPairDistance(0.5*(ptA + ptB)));
if (distSqr > 1.001*ppDistSqr)
{
return false;
}
}
return true;
}
inline bool Foam::conformalVoronoiMesh::isBoundaryDualFace
(
const Delaunay::Finite_edges_iterator& eit
) const
{
Cell_handle c = eit->first;
Vertex_handle vA = c->vertex(eit->second);
Vertex_handle vB = c->vertex(eit->third);
// if (vA->internalBoundaryPoint() && vB->externalBoundaryPoint())
// {
// if (vA->index() == vB->index() - 1)
// {
// return true;
// }
// }
// else if (vA->externalBoundaryPoint() && vB->internalBoundaryPoint())
// {
// if (vA->index() == vB->index() + 1)
// {
// return true;
// }
// }
//
// return false;
// A dual face on the boundary will result from one Dv inside and
// one outside
return
(
(
(vA->internalOrBoundaryPoint() && !vA->referred())
|| (vB->internalOrBoundaryPoint() && !vB->referred())
)
&& (
!vA->internalOrBoundaryPoint()
|| !vB->internalOrBoundaryPoint()
)
);
}
inline Foam::List<bool> Foam::conformalVoronoiMesh::dualFaceBoundaryPoints
(
const Delaunay::Finite_edges_iterator& eit
) const
{
Cell_circulator ccStart = incident_cells(*eit);
Cell_circulator cc1 = ccStart;
Cell_circulator cc2 = cc1;
// Advance the second circulator so that it always stays on the next
// cell around the edge;
cc2++;
DynamicList<bool> tmpFaceBoundaryPoints;
do
{
label cc1I = cc1->cellIndex();
label cc2I = cc2->cellIndex();
if (cc1I != cc2I)
{
if (cc1->boundaryDualVertex())
{
tmpFaceBoundaryPoints.append(true);
}
else
{
tmpFaceBoundaryPoints.append(false);
}
}
cc1++;
cc2++;
} while (cc1 != ccStart);
return tmpFaceBoundaryPoints;
}
inline Foam::List<Foam::label> Foam::conformalVoronoiMesh::processorsAttached
(
const Delaunay::Finite_facets_iterator& fit
) const
{
DynamicList<label> procsAttached(8);
const Cell_handle c1(fit->first);
const int oppositeVertex = fit->second;
const Cell_handle c2(c1->neighbor(oppositeVertex));
FixedList<label, 4> c1Procs(c1->processorsAttached());
FixedList<label, 4> c2Procs(c2->processorsAttached());
forAll(c1Procs, aPI)
{
if (findIndex(procsAttached, c1Procs[aPI] == -1))
{
procsAttached.append(c1Procs[aPI]);
}
if (findIndex(procsAttached, c2Procs[aPI] == -1))
{
procsAttached.append(c2Procs[aPI]);
}
}
return List<label>(procsAttached);
}
inline bool Foam::conformalVoronoiMesh::isParallelDualEdge
(
const Delaunay::Finite_facets_iterator& fit
) const
{
const Cell_handle c1(fit->first);
const int oppositeVertex = fit->second;
return
(
c1->vertex(vertex_triple_index(oppositeVertex, 0))->referred()
|| c1->vertex(vertex_triple_index(oppositeVertex, 1))->referred()
|| c1->vertex(vertex_triple_index(oppositeVertex, 2))->referred()
);
}
inline bool Foam::conformalVoronoiMesh::isProcBoundaryEdge
(
const Delaunay::Finite_edges_iterator& eit
) const
{
bool isProcBoundaryEdge = false;
Cell_handle c = eit->first;
Vertex_handle vA = c->vertex(eit->second);
Vertex_handle vB = c->vertex(eit->third);
if
(
(
(vA->referred() && !vB->referred())
|| (vB->referred() && !vA->referred())
)
&& vA->internalOrBoundaryPoint()
&& vB->internalOrBoundaryPoint()
)
{
isProcBoundaryEdge = true;
}
return isProcBoundaryEdge;
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline Foam::conformalVoronoiMesh::CGALVector
Foam::conformalVoronoiMesh::toCGALVector(const Foam::vector& v) const
{
return CGALVector(v.x(), v.y(), v.z());
}
inline const Foam::Time& Foam::conformalVoronoiMesh::time() const
{
return runTime_;
}
inline Foam::Random& Foam::conformalVoronoiMesh::rndGen() const
{
return rndGen_;
}
inline const Foam::searchableSurfaces&
Foam::conformalVoronoiMesh::allGeometry() const
{
return allGeometry_;
}
inline const Foam::conformationSurfaces&
Foam::conformalVoronoiMesh::geometryToConformTo() const
{
return geometryToConformTo_;
}
inline const Foam::backgroundMeshDecomposition&
Foam::conformalVoronoiMesh::decomposition() const
{
if (!Pstream::parRun())
{
FatalErrorIn
(
"inline const Foam::backgroundMeshDecomposition& "
"Foam::conformalVoronoiMesh::decomposition() const"
)
<< "The backgroundMeshDecomposition cannot be asked for in serial."
<< exit(FatalError) << endl;
}
return decomposition_();
}
inline const Foam::cellShapeControl&
Foam::conformalVoronoiMesh::cellShapeControls() const
{
return cellShapeControl_;
}
inline const Foam::cvControls&
Foam::conformalVoronoiMesh::cvMeshControls() const
{
return cvMeshControls_;
}
// ************************************************************************* //

Some files were not shown because too many files have changed in this diff Show More