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

Merge branch 'master' of /home/dm4/OpenFOAM/OpenFOAM-dev

Browse Source
This commit is contained in:
mattijs
2011-12-13 12:45:12 +00:00
parent 37861591bd 40fda4f99d
commit c63898c9c5
32 changed files with 747 additions and 443 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2007-2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2007-2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -32,9 +32,7 @@ License
namespace Foam
{
defineTypeNameAndDebug(CV2D, 0);
defineTypeNameAndDebug(CV2D, 0);
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
@ -67,6 +65,7 @@ void Foam::CV2D::fast_restore_Delaunay(Vertex_handle vh)
} while (f != start);
}
void Foam::CV2D::external_flip(Face_handle& f, int i)
{
Face_handle n = f->neighbor(i);
@ -82,6 +81,7 @@ void Foam::CV2D::external_flip(Face_handle& f, int i)
external_flip(n, i);
}
bool Foam::CV2D::internal_flip(Face_handle& f, int i)
{
Face_handle n = f->neighbor(i);

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2007-2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -321,18 +321,14 @@ private:
public:
//- Runtime type information
ClassName("CV2D");
//- Runtime type information
ClassName("CV2D");
// Constructors
//- Construct for given surface
CV2D
(
const Time& runTime,
const dictionary& controlDict
);
CV2D(const Time& runTime, const dictionary& controlDict);
//- Destructor
@ -420,6 +416,7 @@ public:
EdgeMap<label>& mapEdgesRegion
) const;
// Write
//- Write internal points to .obj file

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2007-2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -120,11 +120,13 @@ 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());
@ -135,6 +137,7 @@ inline const Foam::point2DField Foam::CV2D::toPoint2D(const pointField& p) const
return temp;
}
inline Foam::point Foam::CV2D::toPoint3D(const point2D& p) const
{
return point(p.x(), p.y(), z_);
@ -148,6 +151,7 @@ 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);
@ -160,6 +164,7 @@ 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());
@ -207,6 +212,7 @@ inline bool Foam::boundaryTriangle(const CV2D::Face_handle fc)
);
}
inline bool Foam::outsideTriangle(const CV2D::Face_handle fc)
{
return outsideTriangle

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2007-2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2007-2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2007-2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -47,7 +47,6 @@ Description
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
@ -62,9 +61,23 @@ int main(int argc, char *argv[])
// Read control dictionary
// ~~~~~~~~~~~~~~~~~~~~~~~
dictionary controlDict(IFstream("system/" + args.executable() + "Dict")());
dictionary shortEdgeFilterDict(controlDict.subDict("shortEdgeFilter"));
dictionary extrusionDict(controlDict.subDict("extrusion"));
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");
@ -97,17 +110,16 @@ int main(int argc, char *argv[])
while (runTime.loop())
{
Info<< nl << "Time = " << runTime.timeName() << endl;
Info<< "Relaxation = " << relax->relaxation() << endl;
Info<< nl << "Time = " << runTime.timeName() << nl
<< "Relaxation = " << relax->relaxation() << endl;
mesh.newPoints(relax->relaxation());
}
mesh.write();
Info<< "Finished Delaunay in = "
<< runTime.cpuTimeIncrement() << " s." << endl;
Info<< "Finished Delaunay in = " << runTime.cpuTimeIncrement() << " s."
<< endl;
Info<< "Begin filtering short edges:" << endl;
shortEdgeFilter2D sef(mesh, shortEdgeFilterDict);
@ -120,8 +132,8 @@ int main(int argc, char *argv[])
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<< "Finished filtering in = " << runTime.cpuTimeIncrement() << " s."
<< endl;
Info<< "Begin constructing a polyMesh:" << endl;

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2007-2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -46,7 +46,7 @@ namespace CGAL
\*---------------------------------------------------------------------------*/
template<class Gt, class Fb=CGAL::Triangulation_face_base_2<Gt> >
class indexedFace
class indexedFace
:
public Fb
{
@ -78,61 +78,45 @@ public:
};
indexedFace()
:
Fb(),
index_(CHANGED)
{}
// Constructors
indexedFace(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2)
:
Fb(v0, v1, v2),
index_(CHANGED)
{}
inline indexedFace();
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)
{}
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
);
void set_vertex(int i, Vertex_handle v)
{
index_ = CHANGED;
Fb::set_vertex(i, v);
}
// Member Functions
void set_vertices()
{
index_ = CHANGED;
Fb::set_vertices();
}
inline void set_vertex(int i, Vertex_handle v);
void set_vertices(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2)
{
index_ = CHANGED;
Fb::set_vertices(v0, v1, v2);
}
inline void set_vertices();
inline void set_vertices
(
Vertex_handle v0,
Vertex_handle v1,
Vertex_handle v2
);
int& faceIndex()
{
return index_;
}
inline int& faceIndex();
inline int faceIndex() const;
int faceIndex() const
{
return index_;
}
};
@ -142,6 +126,10 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "indexedFaceI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

108
applications/utilities/mesh/generation/cv2DMesh/indexedFaceI.H Normal file
View File

@ -0,0 +1,108 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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_;
}

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2007-2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -40,6 +40,34 @@ Description
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
\*---------------------------------------------------------------------------*/
@ -85,173 +113,84 @@ public:
};
indexedVertex()
:
Vb(),
index_(INTERNAL_POINT),
type_(INTERNAL_POINT)
{}
// Constructors
indexedVertex(const Point& p)
:
Vb(p),
index_(INTERNAL_POINT),
type_(INTERNAL_POINT)
{}
inline indexedVertex();
indexedVertex(const Point& p, const int index, const int& type)
:
Vb(p),
index_(index),
type_(type)
{}
inline indexedVertex(const Point& p);
indexedVertex(const Point& p, Face_handle f)
:
Vb(f, p),
index_(INTERNAL_POINT),
type_(INTERNAL_POINT)
{}
inline indexedVertex(const Point& p, const int index, const int& type);
indexedVertex(Face_handle f)
:
Vb(f),
index_(INTERNAL_POINT),
type_(INTERNAL_POINT)
{}
inline indexedVertex(const Point& p, Face_handle f);
inline indexedVertex(Face_handle f);
int& index()
{
return index_;
}
// Member Functions
int index() const
{
return index_;
}
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;
int& type()
{
return type_;
}
// Friend Functions
int type() const
{
return type_;
}
//- 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
);
//- Is point a far-point
inline bool farPoint() const
{
return type_ == FAR_POINT;
}
//- Is point internal, i.e. not on boundary
inline bool internalPoint() const
{
return type_ <= INTERNAL_POINT;
}
//- Is point internal and near the boundary
inline bool nearBoundary() const
{
return type_ == NEAR_BOUNDARY_POINT;
}
//- Set the point to be near the boundary
inline void setNearBoundary()
{
type_ = NEAR_BOUNDARY_POINT;
}
//- Is point a mirror point
inline bool mirrorPoint() const
{
return type_ == MIRROR_POINT;
}
//- Either master or slave of pointPair.
inline bool pairPoint() const
{
return type_ >= 0;
}
//- Master of a pointPair is the lowest numbered one.
inline bool ppMaster() const
{
if (type_ > index_)
{
return true;
}
else
{
return false;
}
}
//- Slave of a pointPair is the highest numbered one.
inline bool ppSlave() const
{
if (type_ >= 0 && type_ < index_)
{
return true;
}
else
{
return false;
}
}
//- Either original internal point or master of pointPair.
inline bool internalOrBoundaryPoint() const
{
return internalPoint() || ppMaster();
}
//- Is point near the boundary or part of the boundary definition
inline bool nearOrOnBoundary() const
{
return pairPoint() || mirrorPoint() || nearBoundary();
}
//- Do the two given vertices consitute a boundary point-pair
inline friend bool pointPair
(
const indexedVertex& v0,
const indexedVertex& v1
)
{
return v0.index_ == v1.type_ || v1.index_ == v0.type_;
}
//- Do the three given vertices consitute a boundary triangle
inline friend bool boundaryTriangle
(
const indexedVertex& v0,
const indexedVertex& v1,
const indexedVertex& v2
)
{
return (v0.pairPoint() && pointPair(v1, v2))
|| (v1.pairPoint() && pointPair(v2, v0))
|| (v2.pairPoint() && pointPair(v0, v1));
}
//- Do the three given vertices consitute an outside triangle
inline friend bool outsideTriangle
(
const indexedVertex& v0,
const indexedVertex& v1,
const indexedVertex& v2
)
{
return (v0.farPoint() || v0.ppSlave())
|| (v1.farPoint() || v1.ppSlave())
|| (v2.farPoint() || v2.ppSlave());
}
//- 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
);
};
@ -260,6 +199,9 @@ public:
} // End namespace CGAL
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "indexedVertexI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

230
applications/utilities/mesh/generation/cv2DMesh/indexedVertexI.H Normal file
View File

@ -0,0 +1,230 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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());
}

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2007-2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2007-2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,13 +25,10 @@ License
#include "CV2D.H"
#include "plane.H"
#include "triSurfaceTools.H"
#include "unitConversion.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
bool Foam::CV2D::on2DLine(const point2D& p, const linePointRef& line)
{
const point2D& a = toPoint2D(line.start());
@ -52,8 +49,6 @@ bool Foam::CV2D::on2DLine(const point2D& p, const linePointRef& line)
}
// Create feature points/edges by creating a triplet in the corner.
// (this triplet will have as its circumcentre the feature)
void Foam::CV2D::insertFeaturePoints()
{
featurePoints_.clear();
@ -394,4 +389,6 @@ void Foam::CV2D::reinsertFeaturePoints()
);
}
}
// ************************************************************************* //

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2007-2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2007-2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License

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

@ -27,13 +27,9 @@ License
namespace Foam
{
defineTypeNameAndDebug(shortEdgeFilter2D, 0);
defineTypeNameAndDebug(shortEdgeFilter2D, 0);
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -51,7 +51,6 @@ class shortEdgeFilter2D
{
// Private data
//- Description of data_
const CV2D& cv2Dmesh_;
MeshedSurface<face> ms_;
@ -83,11 +82,7 @@ public:
// Constructors
shortEdgeFilter2D
(
const CV2D& cv2Dmesh,
const dictionary& dict
);
shortEdgeFilter2D(const CV2D& cv2Dmesh, const dictionary& dict);
//- Destructor
@ -116,12 +111,12 @@ public:
return ms_;
}
// Member Functions
void filter();
void writeInfo(Ostream& os);
};

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

@ -281,7 +281,8 @@ Foam::scalar Foam::cellSizeControlSurfaces::cellSize
{
scalar size = defaultCellSize_;
bool anyFunctionFound = evalCellSizeFunctions(pt, size);
// bool anyFunctionFound = evalCellSizeFunctions(pt, size);
evalCellSizeFunctions(pt, size);
//if (!anyFunctionFound)
//{

14
applications/utilities/mesh/generation/extrude2DMesh/extrude2DMesh/extrude2DMesh/extrude2DMesh.C
View File

@ -31,9 +31,7 @@ License
namespace Foam
{
defineTypeNameAndDebug(extrude2DMesh, 0);
defineTypeNameAndDebug(extrude2DMesh, 0);
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
@ -45,10 +43,10 @@ void Foam::extrude2DMesh::check2D() const
{
if (faces[faceI].size() != 2)
{
FatalErrorIn("extrude2DMesh.C")
FatalErrorIn("void Foam::extrude2DMesh::check2D() const")
<< "Face " << faceI << " size " << faces[faceI].size()
<< " is not of size 2 so mesh is not proper two-dimensional."
<< exit(FatalError);
<< " is not of size 2: mesh is not a valid two-dimensional "
<< "mesh" << exit(FatalError);
}
}
}
@ -537,7 +535,7 @@ void Foam::extrude2DMesh::setRefinement
-1, // nei
-1, // masterPointID
-1, // masterEdgeID
nFaces++, // masterFaceID
nFaces++, // masterFaceID
false, // flipFaceFlux
backPatchI_, // patchID
-1, // zoneID
@ -567,7 +565,7 @@ void Foam::extrude2DMesh::setRefinement
-1, // nei
-1, // masterPointID
-1, // masterEdgeID
nFaces++, // masterFaceID
nFaces++, // masterFaceID
false, // flipFaceFlux
frontPatchI_, // patchID
-1, // zoneID

34
applications/utilities/mesh/generation/extrude2DMesh/extrude2DMeshApp.C
View File

@ -111,8 +111,6 @@ static const NamedEnum<ExtrudeMode, 2> ExtrudeModeNames;
int main(int argc, char *argv[])
{
#include "addOverwriteOption.H"
argList::validArgs.append("surfaceFormat");
#include "setRootCase.H"
@ -128,11 +126,10 @@ int main(int argc, char *argv[])
runTimeExtruded.functionObjects().off();
const bool overwrite = args.optionFound("overwrite");
const ExtrudeMode surfaceFormat = ExtrudeModeNames[args[1]];
Info<< "Extruding from " << ExtrudeModeNames[surfaceFormat] << endl;
Info<< "Extruding from " << ExtrudeModeNames[surfaceFormat]
<< " at time " << runTimeExtruded.timeName() << endl;
IOdictionary extrude2DMeshDict
(
@ -164,12 +161,12 @@ int main(int argc, char *argv[])
EdgeMap<label> edgeRegionMap;
wordList patchNames(1, "default");
labelList patchSizes(1, fMesh->nEdges() - fMesh->nInternalEdges());
labelList patchSizes(1, fMesh().nEdges() - fMesh().nInternalEdges());
const edgeList& edges = fMesh->edges();
const edgeList& edges = fMesh().edges();
forAll(edges, edgeI)
{
if (!fMesh->isInternalEdge(edgeI))
if (!fMesh().isInternalEdge(edgeI))
{
edgeRegionMap.insert(edges[edgeI], 0);
}
@ -216,11 +213,11 @@ int main(int argc, char *argv[])
poly2DMesh.patchSizes()[patchI],
poly2DMesh.patchStarts()[patchI],
patchI,
mesh->boundaryMesh()
mesh().boundaryMesh()
);
}
mesh->addPatches(patches);
mesh().addPatches(patches);
}
else if (surfaceFormat == POLYMESH2D)
{
@ -249,17 +246,17 @@ int main(int argc, char *argv[])
extruder.setRefinement(meshMod());
// Create a mesh from topo changes.
autoPtr<mapPolyMesh> morphMap = meshMod->changeMesh(mesh(), false);
autoPtr<mapPolyMesh> morphMap = meshMod().changeMesh(mesh(), false);
mesh->updateMesh(morphMap);
mesh().updateMesh(morphMap);
{
edgeCollapser collapser(mesh());
const edgeList& edges = mesh->edges();
const pointField& points = mesh->points();
const edgeList& edges = mesh().edges();
const pointField& points = mesh().points();
const boundBox& bb = mesh->bounds();
const boundBox& bb = mesh().bounds();
const scalar mergeDim = 1E-4 * bb.minDim();
forAll(edges, edgeI)
@ -286,14 +283,11 @@ int main(int argc, char *argv[])
autoPtr<mapPolyMesh> morphMap
= meshModCollapse.changeMesh(mesh(), false);
mesh->updateMesh(morphMap);
mesh().updateMesh(morphMap);
}
mesh->setInstance(runTimeExtruded.constant());
// Take over refinement levels and write to new time directory.
Pout<< "Writing extruded mesh to time = " << runTimeExtruded.timeName()
Pout<< "\nWriting extruded mesh to time = " << runTimeExtruded.timeName()
<< nl << endl;
mesh().write();