f5be4b05a5
For example, to mesh a sphere with a single block the geometry is defined in the
blockMeshDict as a searchableSurface:
geometry
{
sphere
{
type searchableSphere;
centre (0 0 0);
radius 1;
}
}
The vertices, block topology and curved edges are defined in the usual
way, for example
v 0.5773502;
mv -0.5773502;
a 0.7071067;
ma -0.7071067;
vertices
(
($mv $mv $mv)
( $v $mv $mv)
( $v $v $mv)
($mv $v $mv)
($mv $mv $v)
( $v $mv $v)
( $v $v $v)
($mv $v $v)
);
blocks
(
hex (0 1 2 3 4 5 6 7) (10 10 10) simpleGrading (1 1 1)
);
edges
(
arc 0 1 (0 $ma $ma)
arc 2 3 (0 $a $ma)
arc 6 7 (0 $a $a)
arc 4 5 (0 $ma $a)
arc 0 3 ($ma 0 $ma)
arc 1 2 ($a 0 $ma)
arc 5 6 ($a 0 $a)
arc 4 7 ($ma 0 $a)
arc 0 4 ($ma $ma 0)
arc 1 5 ($a $ma 0)
arc 2 6 ($a $a 0)
arc 3 7 ($ma $a 0)
);
which will produce a mesh in which the block edges conform to the sphere
but the faces of the block lie somewhere between the original cube and
the spherical surface which is a consequence of the edge-based
transfinite interpolation.
Now the projection of the block faces to the geometry specified above
can also be specified:
faces
(
project (0 4 7 3) sphere
project (2 6 5 1) sphere
project (1 5 4 0) sphere
project (3 7 6 2) sphere
project (0 3 2 1) sphere
project (4 5 6 7) sphere
);
which produces a mesh that actually conforms to the sphere.
See OpenFOAM-dev/tutorials/mesh/blockMesh/sphere
This functionality is experimental and will undergo further development
and generalization in the future to support more complex surfaces,
feature edge specification and extraction etc. Please get involved if
you would like to see blockMesh become a more flexible block-structured
mesher.
Henry G. Weller, CFD Direct.
131 lines
3.7 KiB
C++
131 lines
3.7 KiB
C++
/*---------------------------------------------------------------------------*\
|
|
========= |
|
|
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
|
\\ / O peration |
|
|
\\ / A nd | Copyright (C) 2011-2016 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::polyLine
|
|
|
|
Description
|
|
A series of straight line segments, which can also be interpreted as
|
|
a series of control points for splines, etc.
|
|
|
|
A future implementation could also handle a closed polyLine.
|
|
|
|
SourceFiles
|
|
polyLine.C
|
|
|
|
\*---------------------------------------------------------------------------*/
|
|
|
|
#ifndef polyLine_H
|
|
#define polyLine_H
|
|
|
|
#include "pointField.H"
|
|
#include "scalarList.H"
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
namespace Foam
|
|
{
|
|
|
|
/*---------------------------------------------------------------------------*\
|
|
Class polyLine Declaration
|
|
\*---------------------------------------------------------------------------*/
|
|
|
|
|
|
class polyLine
|
|
{
|
|
// Private Member Functions
|
|
|
|
//- Disallow default bitwise copy construct
|
|
polyLine(const polyLine&);
|
|
|
|
//- Disallow default bitwise assignment
|
|
void operator=(const polyLine&);
|
|
|
|
|
|
protected:
|
|
|
|
// Protected data
|
|
|
|
//- The control points or ends of each segments
|
|
pointField points_;
|
|
|
|
//- The real line length
|
|
scalar lineLength_;
|
|
|
|
//- The rational (0-1) cumulative parameter value for each point
|
|
scalarList param_;
|
|
|
|
|
|
// Protected Member Functions
|
|
|
|
//- Precalculate the rational cumulative parameter value
|
|
// and the line-length
|
|
void calcParam();
|
|
|
|
//- Return the line segment and the local parameter [0..1]
|
|
// corresponding to the global lambda [0..1]
|
|
label localParameter(scalar& lambda) const;
|
|
|
|
|
|
public:
|
|
|
|
// Constructors
|
|
|
|
//- Construct from components
|
|
polyLine
|
|
(
|
|
const pointField&,
|
|
const bool notImplementedClosed = false
|
|
);
|
|
|
|
|
|
// Member Functions
|
|
|
|
//- Return const-access to the control-points
|
|
const pointField& points() const;
|
|
|
|
//- Return the number of line segments
|
|
label nSegments() const;
|
|
|
|
//- Return the point position corresponding to the curve parameter
|
|
// 0 <= lambda <= 1
|
|
point position(const scalar) const;
|
|
|
|
//- Return the point position corresponding to the local parameter
|
|
// 0 <= lambda <= 1 on the given segment
|
|
point position(const label segment, const scalar) const;
|
|
|
|
//- Return the length of the curve
|
|
scalar length() const;
|
|
};
|
|
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
} // End namespace Foam
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
#endif
|
|
|
|
// ************************************************************************* //
|