mirror of
https://develop.openfoam.com/Development/openfoam.git
synced 2025-11-28 03:28:01 +00:00
009203188f
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.
293 lines
8.4 KiB
C++
293 lines
8.4 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::searchableSurfaceCollection
|
|
|
|
Description
|
|
Set of transformed searchableSurfaces. Does not do boolean operations.
|
|
So when meshing might find parts 'inside'.
|
|
|
|
SourceFiles
|
|
searchableSurfaceCollection.C
|
|
|
|
\*---------------------------------------------------------------------------*/
|
|
|
|
#ifndef searchableSurfaceCollection_H
|
|
#define searchableSurfaceCollection_H
|
|
|
|
#include "searchableSurface.H"
|
|
#include "treeBoundBox.H"
|
|
#include "coordinateSystem.H"
|
|
#include "UPtrList.H"
|
|
#include "Switch.H"
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
namespace Foam
|
|
{
|
|
|
|
/*---------------------------------------------------------------------------*\
|
|
Class searchableSurfaceCollection Declaration
|
|
\*---------------------------------------------------------------------------*/
|
|
|
|
class searchableSurfaceCollection
|
|
:
|
|
public searchableSurface
|
|
{
|
|
// Private Member Data
|
|
|
|
// Per instance data
|
|
|
|
//- Instance name
|
|
wordList instance_;
|
|
|
|
//- Scaling vector
|
|
vectorField scale_;
|
|
|
|
//- transformation
|
|
PtrList<coordinateSystem> transform_;
|
|
|
|
UPtrList<searchableSurface> subGeom_;
|
|
|
|
Switch mergeSubRegions_;
|
|
|
|
//- Offsets for indices coming from different surfaces
|
|
// (sized with size() of each surface)
|
|
labelList indexOffset_;
|
|
|
|
//- Region names
|
|
mutable wordList regions_;
|
|
|
|
//- From individual regions to collection regions
|
|
mutable labelList regionOffset_;
|
|
|
|
|
|
// Private Member Functions
|
|
|
|
//- Inherit findNearest from searchableSurface
|
|
using searchableSurface::findNearest;
|
|
|
|
//- Find point nearest to sample. Updates minDistSqr. Sets nearestInfo
|
|
// and surface index
|
|
void findNearest
|
|
(
|
|
const pointField& samples,
|
|
scalarField& minDistSqr,
|
|
List<pointIndexHit>& nearestInfo,
|
|
labelList& nearestSurf
|
|
) const;
|
|
|
|
//- Sort hits into per-surface bins. Misses are rejected.
|
|
// Maintains map back to position
|
|
void sortHits
|
|
(
|
|
const List<pointIndexHit>& info,
|
|
List<List<pointIndexHit>>& surfInfo,
|
|
labelListList& infoMap
|
|
) const;
|
|
|
|
|
|
//- Disallow default bitwise copy construct
|
|
searchableSurfaceCollection(const searchableSurfaceCollection&);
|
|
|
|
//- Disallow default bitwise assignment
|
|
void operator=(const searchableSurfaceCollection&);
|
|
|
|
|
|
public:
|
|
|
|
//- Runtime type information
|
|
TypeName("searchableSurfaceCollection");
|
|
|
|
|
|
// Constructors
|
|
|
|
//- Construct from dictionary (used by searchableSurface)
|
|
searchableSurfaceCollection
|
|
(
|
|
const IOobject& io,
|
|
const dictionary& dict
|
|
);
|
|
|
|
|
|
//- Destructor
|
|
virtual ~searchableSurfaceCollection();
|
|
|
|
|
|
// Member Functions
|
|
|
|
//- Scaling vector per subsurface
|
|
const vectorField& scale() const
|
|
{
|
|
return scale_;
|
|
}
|
|
|
|
//- Scaling vector per subsurface
|
|
vectorField& scale()
|
|
{
|
|
return scale_;
|
|
}
|
|
|
|
//- Coordinate system per subsurface
|
|
const PtrList<coordinateSystem>& transform() const
|
|
{
|
|
return transform_;
|
|
}
|
|
|
|
//- Coordinate system per subsurface
|
|
PtrList<coordinateSystem>& transform()
|
|
{
|
|
return transform_;
|
|
}
|
|
|
|
virtual const wordList& regions() const;
|
|
|
|
//- Whether supports volume type below
|
|
virtual bool hasVolumeType() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//- Range of local indices that can be returned.
|
|
virtual label size() const;
|
|
|
|
//- Get representative set of element coordinates
|
|
// Usually the element centres (should be of length size()).
|
|
virtual tmp<pointField> coordinates() const;
|
|
|
|
//- Get bounding spheres (centre and radius squared), one per element.
|
|
// Any point on element is guaranteed to be inside.
|
|
virtual void boundingSpheres
|
|
(
|
|
pointField& centres,
|
|
scalarField& radiusSqr
|
|
) const;
|
|
|
|
//- Get the points that define the surface.
|
|
virtual tmp<pointField> points() const;
|
|
|
|
//- Does any part of the surface overlap the supplied bound box?
|
|
virtual bool overlaps(const boundBox& bb) const
|
|
{
|
|
NotImplemented;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
// Multiple point queries.
|
|
|
|
virtual void findNearest
|
|
(
|
|
const pointField& sample,
|
|
const scalarField& nearestDistSqr,
|
|
List<pointIndexHit>&
|
|
) const;
|
|
|
|
virtual void findLine
|
|
(
|
|
const pointField& start,
|
|
const pointField& end,
|
|
List<pointIndexHit>&
|
|
) const;
|
|
|
|
virtual void findLineAny
|
|
(
|
|
const pointField& start,
|
|
const pointField& end,
|
|
List<pointIndexHit>&
|
|
) const;
|
|
|
|
//- Get all intersections in order from start to end.
|
|
virtual void findLineAll
|
|
(
|
|
const pointField& start,
|
|
const pointField& end,
|
|
List<List<pointIndexHit>>&
|
|
) const;
|
|
|
|
//- From a set of points and indices get the region
|
|
virtual void getRegion
|
|
(
|
|
const List<pointIndexHit>&,
|
|
labelList& region
|
|
) const;
|
|
|
|
//- From a set of points and indices get the normal
|
|
virtual void getNormal
|
|
(
|
|
const List<pointIndexHit>&,
|
|
vectorField& normal
|
|
) const;
|
|
|
|
//- Determine type (inside/outside/mixed) for point. unknown if
|
|
// cannot be determined (e.g. non-manifold surface)
|
|
virtual void getVolumeType
|
|
(
|
|
const pointField&,
|
|
List<volumeType>&
|
|
) const;
|
|
|
|
// Other
|
|
|
|
//- Set bounds of surface. Bounds currently set as list of
|
|
// bounding boxes. The bounds are hints to the surface as for
|
|
// the range of queries it can expect. faceMap/pointMap can be
|
|
// set if the surface has done any redistribution.
|
|
virtual void distribute
|
|
(
|
|
const List<treeBoundBox>&,
|
|
const bool keepNonLocal,
|
|
autoPtr<mapDistribute>& faceMap,
|
|
autoPtr<mapDistribute>& pointMap
|
|
);
|
|
|
|
//- WIP. Store element-wise field.
|
|
virtual void setField(const labelList& values);
|
|
|
|
//- WIP. From a set of hits (points and
|
|
// indices) get the specified field. Misses do not get set. Return
|
|
// empty field if not supported.
|
|
virtual void getField(const List<pointIndexHit>&, labelList&) const;
|
|
|
|
// regIOobject implementation
|
|
|
|
bool writeData(Ostream&) const
|
|
{
|
|
NotImplemented;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
} // End namespace Foam
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
#endif
|
|
|
|
// ************************************************************************* //
|