netgen/libsrc/meshing/meshclass.hpp

853 lines
24 KiB
C++
Raw Normal View History

2009-01-13 04:40:13 +05:00
#ifndef MESHCLASS
#define MESHCLASS
/**************************************************************************/
/* File: meshclass.hpp */
/* Author: Joachim Schoeberl */
/* Date: 20. Nov. 99 */
/**************************************************************************/
/*
The mesh class
*/
2011-03-03 01:50:39 +05:00
namespace netgen
{
enum resthtype { RESTRICTH_FACE, RESTRICTH_EDGE,
RESTRICTH_SURFACEELEMENT, RESTRICTH_POINT, RESTRICTH_SEGMENT };
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
class HPRefElement;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// 2d/3d mesh
class Mesh
{
public:
typedef ::netgen::T_POINTS T_POINTS;
typedef Array<Element, 0, size_t> T_VOLELEMENTS;
// typedef Array<Element2d, 0, SurfaceElementIndex> T_SURFELEMENTS;
typedef Array<Element2d, 0, size_t> T_SURFELEMENTS;
2011-03-03 01:50:39 +05:00
private:
/// point coordinates
T_POINTS points;
/// line-segments at edges
2017-10-29 15:31:23 +05:00
Array<Segment, 0, size_t> segments;
2011-03-03 01:50:39 +05:00
/// surface elements, 2d-inner elements
T_SURFELEMENTS surfelements;
/// volume elements
T_VOLELEMENTS volelements;
/// points will be fixed forever
Array<PointIndex> lockedpoints;
/// surface indices at boundary nodes
// TABLE<int,PointIndex::BASE> surfacesonnode;
2011-03-03 01:50:39 +05:00
/// boundary edges (1..normal bedge, 2..segment)
INDEX_2_CLOSED_HASHTABLE<int> * boundaryedges;
///
INDEX_2_CLOSED_HASHTABLE<int> * segmentht;
///
INDEX_3_CLOSED_HASHTABLE<int> * surfelementht;
/// faces of rest-solid
Array<Element2d> openelements;
/// open segmenets for surface meshing
Array<Segment> opensegments;
/**
Representation of local mesh-size h
*/
LocalH * lochfunc;
///
double hglob;
///
double hmin;
///
Array<double> maxhdomain;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/**
the face-index of the surface element maps into
this table.
*/
Array<FaceDescriptor> facedecoding;
2009-01-13 04:40:13 +05:00
2009-09-22 13:12:00 +06:00
2011-03-03 01:50:39 +05:00
/**
the edge-index of the line element maps into
this table.
*/
Array<EdgeDescriptor> edgedecoding;
2009-09-22 13:12:00 +06:00
2011-03-03 01:50:39 +05:00
/// sub-domain materials
2016-02-27 00:30:40 +05:00
Array<string*> materials;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// labels for boundary conditions
Array<string*> bcnames;
2009-01-13 04:40:13 +05:00
2016-10-04 22:30:57 +05:00
/// labels for co dim 2 bboundary conditions
Array<string*> cd2names;
2011-03-03 01:50:39 +05:00
/// Periodic surface, close surface, etc. identifications
Identifications * ident;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// number of vertices (if < 0, use np)
int numvertices;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// geometric search tree for interval intersection search
BoxTree<3> * elementsearchtree;
2011-03-03 01:50:39 +05:00
/// time stamp for tree
2013-04-03 02:29:53 +06:00
mutable int elementsearchtreets;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// element -> face, element -> edge etc ...
MeshTopology topology;
2011-03-03 01:50:39 +05:00
/// methods for high order elements
class CurvedElements * curvedelems;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// nodes identified by close points
class AnisotropicClusters * clusters;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// space dimension (2 or 3)
int dimension;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// changed by every minor modification (addpoint, ...)
int timestamp;
/// changed after finishing global algorithm (improve, ...)
int majortimestamp;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// mesh access semaphors.
NgMutex mutex;
/// mesh access semaphors.
NgMutex majormutex;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
SYMBOLTABLE< Array<int>* > userdata_int;
SYMBOLTABLE< Array<double>* > userdata_double;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
mutable Array< Point3d > pointcurves;
mutable Array<int> pointcurves_startpoint;
mutable Array<double> pointcurves_red,pointcurves_green,pointcurves_blue;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// start element for point search (GetElementOfPoint)
mutable int ps_startelement;
2009-01-13 04:40:13 +05:00
#ifdef PARALLEL
2011-03-03 01:50:39 +05:00
/// connection to parallel meshes
class ParallelMeshTopology * paralleltop;
2009-01-13 04:40:13 +05:00
#endif
2015-08-08 22:10:48 +05:00
shared_ptr<NetgenGeometry> geometry;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
private:
void BuildBoundaryEdges(void);
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
public:
bool PointContainedIn2DElement(const Point3d & p,
double lami[3],
const int element,
bool consider3D = false) const;
bool PointContainedIn3DElement(const Point3d & p,
double lami[3],
const int element) const;
bool PointContainedIn3DElementOld(const Point3d & p,
double lami[3],
const int element) const;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
public:
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
// store coarse mesh before hp-refinement
Array<HPRefElement> * hpelements;
Mesh * coarsemesh;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// number of refinement levels
int mglevels;
/// refinement hierarchy
Array<PointIndices<2>,PointIndex::BASE> mlbetweennodes;
2011-03-03 01:50:39 +05:00
/// parent element of volume element
Array<int> mlparentelement;
/// parent element of surface element
Array<int> mlparentsurfaceelement;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
///
DLL_HEADER Mesh();
2011-03-03 01:50:39 +05:00
///
DLL_HEADER ~Mesh();
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
Mesh & operator= (const Mesh & mesh2);
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
///
2011-09-02 18:37:54 +06:00
DLL_HEADER void DeleteMesh();
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
///
void ClearSurfaceElements();
///
2016-12-12 00:17:07 +05:00
DLL_HEADER void ClearVolumeElements()
2011-03-03 01:50:39 +05:00
{
volelements.SetSize(0);
timestamp = NextTimeStamp();
}
///
2016-12-12 00:17:07 +05:00
DLL_HEADER void ClearSegments()
2011-03-03 01:50:39 +05:00
{
segments.SetSize(0);
timestamp = NextTimeStamp();
}
2016-12-12 00:17:07 +05:00
2011-03-03 01:50:39 +05:00
///
bool TestOk () const;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
void SetAllocSize(int nnodes, int nsegs, int nsel, int nel);
2016-12-12 00:17:07 +05:00
2009-01-13 04:40:13 +05:00
DLL_HEADER PointIndex AddPoint (const Point3d & p, int layer = 1);
DLL_HEADER PointIndex AddPoint (const Point3d & p, int layer, POINTTYPE type);
2013-04-03 02:29:53 +06:00
2011-03-03 01:50:39 +05:00
int GetNP () const { return points.Size(); }
2009-01-13 04:40:13 +05:00
2016-12-11 16:12:05 +05:00
// [[deprecated("Use Point(PointIndex) instead of int !")]]
2011-03-03 01:50:39 +05:00
MeshPoint & Point(int i) { return points.Elem(i); }
MeshPoint & Point(PointIndex pi) { return points[pi]; }
2016-12-11 16:12:05 +05:00
// [[deprecated("Use Point(PointIndex) instead of int !")]]
2011-03-03 01:50:39 +05:00
const MeshPoint & Point(int i) const { return points.Get(i); }
const MeshPoint & Point(PointIndex pi) const { return points[pi]; }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
const MeshPoint & operator[] (PointIndex pi) const { return points[pi]; }
MeshPoint & operator[] (PointIndex pi) { return points[pi]; }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
const T_POINTS & Points() const { return points; }
T_POINTS & Points() { return points; }
2009-01-13 04:40:13 +05:00
DLL_HEADER SegmentIndex AddSegment (const Segment & s);
2011-03-03 01:50:39 +05:00
void DeleteSegment (int segnr)
{
2016-12-11 16:12:05 +05:00
segments.Elem(segnr)[0].Invalidate();
segments.Elem(segnr)[1].Invalidate();
2011-03-03 01:50:39 +05:00
}
2016-12-12 00:17:07 +05:00
/*
2011-03-03 01:50:39 +05:00
void FullDeleteSegment (int segnr) // von wem ist das ???
{
segments.Delete(segnr-PointIndex::BASE);
}
2016-12-12 00:17:07 +05:00
*/
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
int GetNSeg () const { return segments.Size(); }
2016-12-13 03:08:22 +05:00
// [[deprecated("Use LineSegment(SegmentIndex) instead of int !")]]
2011-03-03 01:50:39 +05:00
Segment & LineSegment(int i) { return segments.Elem(i); }
2016-12-13 03:08:22 +05:00
// [[deprecated("Use LineSegment(SegmentIndex) instead of int !")]]
2011-03-03 01:50:39 +05:00
const Segment & LineSegment(int i) const { return segments.Get(i); }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
Segment & LineSegment(SegmentIndex si) { return segments[si]; }
const Segment & LineSegment(SegmentIndex si) const { return segments[si]; }
const Segment & operator[] (SegmentIndex si) const { return segments[si]; }
Segment & operator[] (SegmentIndex si) { return segments[si]; }
2009-01-13 04:40:13 +05:00
2017-10-29 15:31:23 +05:00
/*
2015-05-18 19:19:38 +05:00
const Array<Segment> & LineSegments() const { return segments; }
Array<Segment> & LineSegments() { return segments; }
2017-10-29 15:31:23 +05:00
*/
const auto & LineSegments() const { return segments; }
auto & LineSegments() { return segments; }
2015-11-11 22:46:18 +05:00
Array<Element0d> pointelements; // only via python interface
2009-01-13 04:40:13 +05:00
DLL_HEADER SurfaceElementIndex AddSurfaceElement (const Element2d & el);
// write to pre-allocated container, thread-safe
DLL_HEADER void SetSurfaceElement (SurfaceElementIndex sei, const Element2d & el);
2016-12-12 00:17:07 +05:00
2016-12-13 03:08:22 +05:00
// [[deprecated("Use DeleteSurfaceElement(SurfaceElementIndex) instead of int !")]]
2011-03-03 01:50:39 +05:00
void DeleteSurfaceElement (int eli)
{
surfelements.Elem(eli).Delete();
2016-12-11 16:12:05 +05:00
surfelements.Elem(eli).PNum(1).Invalidate();
surfelements.Elem(eli).PNum(2).Invalidate();
surfelements.Elem(eli).PNum(3).Invalidate();
2011-03-03 01:50:39 +05:00
timestamp = NextTimeStamp();
}
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
void DeleteSurfaceElement (SurfaceElementIndex eli)
{
2016-12-12 00:17:07 +05:00
for (auto & p : surfelements[eli].PNums()) p.Invalidate();
surfelements[eli].Delete();
timestamp = NextTimeStamp();
2011-03-03 01:50:39 +05:00
}
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
int GetNSE () const { return surfelements.Size(); }
2016-12-12 00:17:07 +05:00
2016-12-13 03:08:22 +05:00
// [[deprecated("Use SurfaceElement(SurfaceElementIndex) instead of int !")]]
2011-03-03 01:50:39 +05:00
Element2d & SurfaceElement(int i) { return surfelements.Elem(i); }
2016-12-13 03:08:22 +05:00
// [[deprecated("Use SurfaceElement(SurfaceElementIndex) instead of int !")]]
2011-03-03 01:50:39 +05:00
const Element2d & SurfaceElement(int i) const { return surfelements.Get(i); }
Element2d & SurfaceElement(SurfaceElementIndex i) { return surfelements[i]; }
const Element2d & SurfaceElement(SurfaceElementIndex i) const { return surfelements[i]; }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
const Element2d & operator[] (SurfaceElementIndex ei) const
{ return surfelements[ei]; }
Element2d & operator[] (SurfaceElementIndex ei)
{ return surfelements[ei]; }
2009-01-13 04:40:13 +05:00
2014-08-31 15:14:18 +06:00
const T_SURFELEMENTS & SurfaceElements() const { return surfelements; }
T_SURFELEMENTS & SurfaceElements() { return surfelements; }
2009-01-13 04:40:13 +05:00
DLL_HEADER void RebuildSurfaceElementLists ();
DLL_HEADER void GetSurfaceElementsOfFace (int facenr, Array<SurfaceElementIndex> & sei) const;
2009-01-13 04:40:13 +05:00
DLL_HEADER ElementIndex AddVolumeElement (const Element & el);
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
int GetNE () const { return volelements.Size(); }
2009-01-13 04:40:13 +05:00
2016-12-11 16:12:05 +05:00
// [[deprecated("Use VolumeElement(ElementIndex) instead of int !")]]
2011-03-03 01:50:39 +05:00
Element & VolumeElement(int i) { return volelements.Elem(i); }
2016-12-11 16:12:05 +05:00
// [[deprecated("Use VolumeElement(ElementIndex) instead of int !")]]
2011-03-03 01:50:39 +05:00
const Element & VolumeElement(int i) const { return volelements.Get(i); }
Element & VolumeElement(ElementIndex i) { return volelements[i]; }
const Element & VolumeElement(ElementIndex i) const { return volelements[i]; }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
const Element & operator[] (ElementIndex ei) const
{ return volelements[ei]; }
Element & operator[] (ElementIndex ei)
{ return volelements[ei]; }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
ELEMENTTYPE ElementType (ElementIndex i) const
{ return (volelements[i].flags.fixed) ? FIXEDELEMENT : FREEELEMENT; }
2009-01-13 04:40:13 +05:00
2016-12-12 00:17:07 +05:00
const auto & VolumeElements() const { return volelements; }
auto & VolumeElements() { return volelements; }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
///
2011-07-25 14:40:23 +06:00
DLL_HEADER double ElementError (int eli, const MeshingParameters & mp) const;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
///
DLL_HEADER void AddLockedPoint (PointIndex pi);
2011-03-03 01:50:39 +05:00
///
void ClearLockedPoints ();
2009-01-13 04:40:13 +05:00
2016-12-12 00:17:07 +05:00
const auto & LockedPoints() const { return lockedpoints; }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// Returns number of domains
DLL_HEADER int GetNDomains() const;
2011-03-03 01:50:39 +05:00
///
2016-12-12 00:17:07 +05:00
int GetDimension() const { return dimension; }
void SetDimension (int dim) { dimension = dim; }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// sets internal tables
void CalcSurfacesOfNode ();
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// additional (temporarily) fix points
void FixPoints (const BitArray & fixpoints);
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/**
finds elements without neighbour and
boundary elements without inner element.
Results are stored in openelements.
if dom == 0, all sub-domains, else subdomain dom */
DLL_HEADER void FindOpenElements (int dom = 0);
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/**
finds segments without surface element,
and surface elements without neighbours.
store in opensegmentsy
*/
DLL_HEADER void FindOpenSegments (int surfnr = 0);
2011-03-03 01:50:39 +05:00
/**
remove one layer of surface elements
*/
DLL_HEADER void RemoveOneLayerSurfaceElements ();
2011-03-03 01:50:39 +05:00
int GetNOpenSegments () { return opensegments.Size(); }
const Segment & GetOpenSegment (int nr) { return opensegments.Get(nr); }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/**
Checks overlap of boundary
return == 1, iff overlap
*/
DLL_HEADER int CheckOverlappingBoundary ();
2011-03-03 01:50:39 +05:00
/**
Checks consistent boundary
return == 0, everything ok
*/
DLL_HEADER int CheckConsistentBoundary () const;
2011-03-03 01:50:39 +05:00
/*
checks element orientation
*/
DLL_HEADER int CheckVolumeMesh () const;
2011-03-03 01:50:39 +05:00
/**
finds average h of surface surfnr if surfnr > 0,
else of all surfaces.
*/
DLL_HEADER double AverageH (int surfnr = 0) const;
2011-03-03 01:50:39 +05:00
/// Calculates localh
2011-07-25 14:40:23 +06:00
DLL_HEADER void CalcLocalH (double grading);
2011-03-03 01:50:39 +05:00
///
2014-12-02 18:23:36 +05:00
DLL_HEADER void SetLocalH (netgen::Point<3> pmin, netgen::Point<3> pmax, double grading);
2011-03-03 01:50:39 +05:00
///
DLL_HEADER void RestrictLocalH (const Point3d & p, double hloc);
2011-03-03 01:50:39 +05:00
///
DLL_HEADER void RestrictLocalHLine (const Point3d & p1, const Point3d & p2,
2011-03-03 01:50:39 +05:00
double hloc);
/// number of elements per radius
2011-07-25 14:40:23 +06:00
DLL_HEADER void CalcLocalHFromSurfaceCurvature(double grading, double elperr);
2011-03-03 01:50:39 +05:00
///
2011-07-25 14:40:23 +06:00
DLL_HEADER void CalcLocalHFromPointDistances(double grading);
2011-03-03 01:50:39 +05:00
///
DLL_HEADER void RestrictLocalH (resthtype rht, int nr, double loch);
2011-03-03 01:50:39 +05:00
///
2014-08-31 18:12:31 +06:00
DLL_HEADER void LoadLocalMeshSize (const string & meshsizefilename);
2011-03-03 01:50:39 +05:00
///
DLL_HEADER void SetGlobalH (double h);
2011-03-03 01:50:39 +05:00
///
2015-10-19 13:08:30 +05:00
DLL_HEADER void SetMinimalH (double h);
2011-03-03 01:50:39 +05:00
///
2015-10-19 13:08:30 +05:00
DLL_HEADER double MaxHDomain (int dom) const;
2011-03-03 01:50:39 +05:00
///
2015-10-19 13:08:30 +05:00
DLL_HEADER void SetMaxHDomain (const Array<double> & mhd);
2011-03-03 01:50:39 +05:00
///
DLL_HEADER double GetH (const Point3d & p) const;
2011-03-03 01:50:39 +05:00
///
double GetMinH (const Point3d & pmin, const Point3d & pmax);
///
2016-02-23 22:22:00 +05:00
bool HasLocalHFunction () { return lochfunc != nullptr; }
///
2011-03-03 01:50:39 +05:00
LocalH & LocalHFunction () { return * lochfunc; }
///
bool LocalHFunctionGenerated(void) const { return (lochfunc != NULL); }
/// Find bounding box
DLL_HEADER void GetBox (Point3d & pmin, Point3d & pmax, int dom = -1) const;
2011-03-03 01:50:39 +05:00
/// Find bounding box of points of typ ptyp or less
DLL_HEADER void GetBox (Point3d & pmin, Point3d & pmax, POINTTYPE ptyp ) const;
2011-03-03 01:50:39 +05:00
///
int GetNOpenElements() const
{ return openelements.Size(); }
///
const Element2d & OpenElement(int i) const
{ return openelements.Get(i); }
/// are also quads open elements
bool HasOpenQuads () const;
/// split into connected pieces
2015-10-19 13:08:30 +05:00
DLL_HEADER void SplitIntoParts ();
2011-03-03 01:50:39 +05:00
///
2015-10-19 13:08:30 +05:00
DLL_HEADER void SplitSeparatedFaces ();
2011-03-03 01:50:39 +05:00
/// Refines mesh and projects points to true surface
// void Refine (int levels, const CSGeometry * geom);
2009-01-13 04:40:13 +05:00
2017-09-22 19:55:10 +05:00
2011-03-03 01:50:39 +05:00
bool BoundaryEdge (PointIndex pi1, PointIndex pi2) const
{
if(!boundaryedges)
const_cast<Mesh *>(this)->BuildBoundaryEdges();
INDEX_2 i2 (pi1, pi2);
i2.Sort();
return boundaryedges->Used (i2);
}
bool IsSegment (PointIndex pi1, PointIndex pi2) const
{
INDEX_2 i2 (pi1, pi2);
i2.Sort();
return segmentht->Used (i2);
}
SegmentIndex SegmentNr (PointIndex pi1, PointIndex pi2) const
{
INDEX_2 i2 (pi1, pi2);
i2.Sort();
return segmentht->Get (i2);
}
/**
Remove unused points. etc.
*/
DLL_HEADER void Compress ();
2011-03-03 01:50:39 +05:00
2016-05-13 15:06:12 +05:00
/// first vertex has lowest index
void OrderElements();
2011-03-03 01:50:39 +05:00
///
2015-10-19 13:08:30 +05:00
DLL_HEADER void Save (ostream & outfile) const;
2011-03-03 01:50:39 +05:00
///
2015-10-19 13:08:30 +05:00
DLL_HEADER void Load (istream & infile);
2011-03-03 01:50:39 +05:00
///
2015-10-19 13:08:30 +05:00
DLL_HEADER void Merge (istream & infile, const int surfindex_offset = 0);
2011-03-03 01:50:39 +05:00
///
2015-10-19 13:08:30 +05:00
DLL_HEADER void Save (const string & filename) const;
2011-03-03 01:50:39 +05:00
///
2015-10-19 13:08:30 +05:00
DLL_HEADER void Load (const string & filename);
2011-03-03 01:50:39 +05:00
///
2015-10-19 13:08:30 +05:00
DLL_HEADER void Merge (const string & filename, const int surfindex_offset = 0);
2011-03-03 01:50:39 +05:00
///
2015-10-19 13:08:30 +05:00
DLL_HEADER void ImproveMesh (const MeshingParameters & mp, OPTIMIZEGOAL goal = OPT_QUALITY);
2011-03-03 01:50:39 +05:00
///
2011-07-25 17:33:19 +06:00
void ImproveMeshJacobian (const MeshingParameters & mp, OPTIMIZEGOAL goal = OPT_QUALITY, const BitArray * usepoint = NULL);
2011-03-03 01:50:39 +05:00
///
2011-07-25 17:33:19 +06:00
void ImproveMeshJacobianOnSurface (const MeshingParameters & mp,
const BitArray & usepoint,
2011-03-03 01:50:39 +05:00
const Array< Vec<3>* > & nv,
OPTIMIZEGOAL goal = OPT_QUALITY,
const Array< Array<int,PointIndex::BASE>* > * idmaps = NULL);
/**
free nodes in environment of openelements
for optimiztion
*/
void FreeOpenElementsEnvironment (int layers);
///
bool LegalTet (Element & el) const
{
if (el.IllegalValid())
return !el.Illegal();
return LegalTet2 (el);
}
///
bool LegalTet2 (Element & el) const;
///
bool LegalTrig (const Element2d & el) const;
/**
if values non-null, return values in 4-double array:
triangle angles min/max, tetangles min/max
if null, output results on cout
*/
2015-10-19 13:08:30 +05:00
DLL_HEADER void CalcMinMaxAngle (double badellimit, double * retvalues = NULL);
2011-03-03 01:50:39 +05:00
/*
Marks elements which are dangerous to refine
return: number of illegal elements
*/
2015-10-19 13:08:30 +05:00
DLL_HEADER int MarkIllegalElements ();
2011-03-03 01:50:39 +05:00
/// orient surface mesh, for one sub-domain only
2015-10-19 13:08:30 +05:00
DLL_HEADER void SurfaceMeshOrientation ();
2011-03-03 01:50:39 +05:00
/// convert mixed element mesh to tet-mesh
2015-10-19 13:08:30 +05:00
DLL_HEADER void Split2Tets();
2011-03-03 01:50:39 +05:00
/// build box-search tree
2011-09-02 18:37:54 +06:00
DLL_HEADER void BuildElementSearchTree ();
2011-03-03 01:50:39 +05:00
void SetPointSearchStartElement(const int el) const {ps_startelement = el;}
/// gives element of point, barycentric coordinates
2013-04-03 02:29:53 +06:00
int GetElementOfPoint (const netgen::Point<3> & p,
2011-03-03 01:50:39 +05:00
double * lami,
bool build_searchtree = 0,
const int index = -1,
const bool allowindex = true) const;
2013-04-03 02:29:53 +06:00
int GetElementOfPoint (const netgen::Point<3> & p,
2011-03-03 01:50:39 +05:00
double * lami,
const Array<int> * const indices,
bool build_searchtree = 0,
const bool allowindex = true) const;
2013-04-03 02:29:53 +06:00
int GetSurfaceElementOfPoint (const netgen::Point<3> & p,
2011-03-03 01:50:39 +05:00
double * lami,
bool build_searchtree = 0,
const int index = -1,
const bool allowindex = true) const;
2013-04-03 02:29:53 +06:00
int GetSurfaceElementOfPoint (const netgen::Point<3> & p,
2011-03-03 01:50:39 +05:00
double * lami,
const Array<int> * const indices,
bool build_searchtree = 0,
const bool allowindex = true) const;
/// give list of vol elements which are int the box(p1,p2)
void GetIntersectingVolEls(const Point3d& p1, const Point3d& p2,
Array<int> & locels) const;
///
int AddFaceDescriptor(const FaceDescriptor& fd)
{ facedecoding.Append(fd); return facedecoding.Size(); }
2011-03-03 01:50:39 +05:00
int AddEdgeDescriptor(const EdgeDescriptor & fd)
{ edgedecoding.Append(fd); return edgedecoding.Size() - 1; }
2011-03-03 01:50:39 +05:00
///
2016-02-27 00:30:40 +05:00
DLL_HEADER void SetMaterial (int domnr, const string & mat);
2011-03-03 01:50:39 +05:00
///
2017-07-19 22:18:04 +05:00
DLL_HEADER const string & GetMaterial (int domnr) const;
DLL_HEADER static string defaultmat;
2016-02-27 00:30:40 +05:00
const string * GetMaterialPtr (int domnr) const // 1-based
2017-05-13 13:24:12 +05:00
{
return domnr <= materials.Size() ? materials.Get(domnr) : &defaultmat;
}
2009-01-13 04:40:13 +05:00
DLL_HEADER void SetNBCNames ( int nbcn );
2009-01-13 04:40:13 +05:00
DLL_HEADER void SetBCName ( int bcnr, const string & abcname );
2009-01-13 04:40:13 +05:00
2017-07-19 22:18:04 +05:00
DLL_HEADER const string & GetBCName ( int bcnr ) const;
2016-10-04 22:30:57 +05:00
DLL_HEADER void SetNCD2Names (int ncd2n);
DLL_HEADER void SetCD2Name (int cd2nr, const string & abcname);
2017-07-19 22:18:04 +05:00
DLL_HEADER const string & GetCD2Name (int cd2nr ) const;
DLL_HEADER static string cd2_default_name;
2017-04-03 21:15:34 +05:00
string * GetCD2NamePtr (int cd2nr ) const
{
if (cd2nr < cd2names.Size() && cd2names[cd2nr]) return cd2names[cd2nr];
return &cd2_default_name;
}
2016-10-28 19:49:50 +05:00
size_t GetNCD2Names() const { return cd2names.Size(); }
2009-01-13 04:40:13 +05:00
2016-02-27 00:30:40 +05:00
string * GetBCNamePtr (int bcnr) const
{ return bcnr < bcnames.Size() ? bcnames[bcnr] : nullptr; }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
///
void ClearFaceDescriptors()
{ facedecoding.SetSize(0); }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
///
int GetNFD () const
{ return facedecoding.Size(); }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
const FaceDescriptor & GetFaceDescriptor (int i) const
{ return facedecoding.Get(i); }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
const EdgeDescriptor & GetEdgeDescriptor (int i) const
{ return edgedecoding[i]; }
2009-09-22 13:12:00 +06:00
2011-03-03 01:50:39 +05:00
///
FaceDescriptor & GetFaceDescriptor (int i)
{ return facedecoding.Elem(i); }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
// #ifdef NONE
// /*
// Identify points pi1 and pi2, due to
// identification nr identnr
// */
// void AddIdentification (int pi1, int pi2, int identnr);
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
// int GetIdentification (int pi1, int pi2) const;
// int GetIdentificationSym (int pi1, int pi2) const;
// ///
// INDEX_2_HASHTABLE<int> & GetIdentifiedPoints ()
// {
// return *identifiedpoints;
// }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
// ///
// void GetIdentificationMap (int identnr, Array<int> & identmap) const;
// ///
// void GetIdentificationPairs (int identnr, Array<INDEX_2> & identpairs) const;
// ///
// int GetMaxIdentificationNr () const
// {
// return maxidentnr;
// }
// #endif
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// return periodic, close surface etc. identifications
Identifications & GetIdentifications () { return *ident; }
/// return periodic, close surface etc. identifications
const Identifications & GetIdentifications () const { return *ident; }
2016-02-23 22:22:00 +05:00
///
bool HasIdentifications() const { return ident != nullptr; }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
void InitPointCurve(double red = 1, double green = 0, double blue = 0) const;
void AddPointCurvePoint(const Point3d & pt) const;
int GetNumPointCurves(void) const;
int GetNumPointsOfPointCurve(int curve) const;
Point3d & GetPointCurvePoint(int curve, int n) const;
void GetPointCurveColor(int curve, double & red, double & green, double & blue) const;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// find number of vertices
void ComputeNVertices ();
/// number of vertices (no edge-midpoints)
int GetNV () const;
/// remove edge points
void SetNP (int np);
2009-01-13 04:40:13 +05:00
2016-01-07 17:37:48 +05:00
DLL_HEADER bool PureTrigMesh (int faceindex = 0) const;
DLL_HEADER bool PureTetMesh () const;
2009-01-13 04:40:13 +05:00
2016-01-07 17:37:48 +05:00
const MeshTopology & GetTopology () const
{ return topology; }
2009-01-13 04:40:13 +05:00
DLL_HEADER void UpdateTopology (TaskManager tm = &DummyTaskManager);
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
class CurvedElements & GetCurvedElements () const
{ return *curvedelems; }
2016-01-07 17:37:48 +05:00
DLL_HEADER void BuildCurvedElements (const class Refinement * ref, int aorder, bool arational = false);
2015-04-27 14:18:22 +05:00
2011-03-03 01:50:39 +05:00
const class AnisotropicClusters & GetClusters () const
{ return *clusters; }
2009-01-13 04:40:13 +05:00
2012-10-22 19:13:57 +06:00
class CSurfaceArea
{
const Mesh & mesh;
bool valid;
double area;
public:
CSurfaceArea (const Mesh & amesh)
: mesh(amesh), valid(false) { ; }
void Add (const Element2d & sel)
{
if (sel.GetNP() == 3)
area += Cross ( mesh[sel[1]]-mesh[sel[0]],
mesh[sel[2]]-mesh[sel[0]] ).Length() / 2;
else
2014-12-02 18:23:36 +05:00
area += Cross (Vec3d (mesh[sel.PNum(1)], mesh[sel.PNum(3)]),
Vec3d (mesh[sel.PNum(1)], mesh[sel.PNum(4)])).Length() / 2;;
2012-10-22 19:13:57 +06:00
}
void ReCalc ()
{
area = 0;
for (SurfaceElementIndex sei = 0; sei < mesh.GetNSE(); sei++)
Add (mesh[sei]);
valid = true;
}
operator double () const { return area; }
bool Valid() const { return valid; }
};
CSurfaceArea surfarea;
CSurfaceArea & SurfaceArea() { return surfarea; }
const CSurfaceArea & SurfaceArea() const { return surfarea; }
2011-03-03 01:50:39 +05:00
int GetTimeStamp() const { return timestamp; }
void SetNextTimeStamp()
{ timestamp = NextTimeStamp(); }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
int GetMajorTimeStamp() const { return majortimestamp; }
void SetNextMajorTimeStamp()
{ majortimestamp = timestamp = NextTimeStamp(); }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// return mutex
NgMutex & Mutex () { return mutex; }
NgMutex & MajorMutex () { return majormutex; }
2009-01-13 04:40:13 +05:00
2015-08-08 22:10:48 +05:00
shared_ptr<NetgenGeometry> GetGeometry() const
{
return geometry;
}
void SetGeometry (shared_ptr<NetgenGeometry> geom)
{
geometry = geom;
}
2011-03-03 01:50:39 +05:00
///
void SetUserData(const char * id, Array<int> & data);
///
bool GetUserData(const char * id, Array<int> & data, int shift = 0) const;
///
void SetUserData(const char * id, Array<double> & data);
///
bool GetUserData(const char * id, Array<double> & data, int shift = 0) const;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
///
friend void OptimizeRestart (Mesh & mesh3d);
///
void PrintMemInfo (ostream & ost) const;
///
friend class Meshing3;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
enum GEOM_TYPE { NO_GEOM = 0, GEOM_2D = 1, GEOM_CSG = 10, GEOM_STL = 11, GEOM_OCC = 12, GEOM_ACIS = 13 };
GEOM_TYPE geomtype;
2009-01-13 04:40:13 +05:00
#ifdef PARALLEL
2011-03-03 01:50:39 +05:00
/// returns parallel topology
class ParallelMeshTopology & GetParallelTopology () const
{ return *paralleltop; }
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// distributes the master-mesh to local meshes
void Distribute ();
2012-10-17 16:31:43 +06:00
void Distribute (Array<int> & volume_weights, Array<int> & surface_weights,
Array<int> & segment_weights);
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// find connection to parallel meshes
// void FindExchangePoints () ;
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
// void FindExchangeEdges ();
// void FindExchangeFaces ();
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
/// use metis to decompose master mesh
void ParallelMetis (); // Array<int> & neloc );
2012-10-17 16:31:43 +06:00
void ParallelMetis (Array<int> & volume_weights, Array<int> & surface_weights,
Array<int> & segment_weights);
2011-03-03 01:50:39 +05:00
void PartHybridMesh (); // Array<int> & neloc );
void PartDualHybridMesh (); // Array<int> & neloc );
void PartDualHybridMesh2D (); // ( Array<int> & neloc );
2009-01-13 04:40:13 +05:00
2011-07-04 18:29:02 +06:00
/// send mesh from master to local procs
void SendRecvMesh ();
2011-03-03 01:50:39 +05:00
/// send mesh to parallel machine, keep global mesh at master
void SendMesh ( ) const; // Mesh * mastermesh, Array<int> & neloc) const;
2011-07-04 18:29:02 +06:00
/// loads a mesh sent from master processor
void ReceiveParallelMesh ();
2009-01-13 04:40:13 +05:00
#endif
2011-03-03 01:50:39 +05:00
};
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
inline ostream& operator<<(ostream& ost, const Mesh& mesh)
{
ost << "mesh: " << endl;
mesh.Save(ost);
return ost;
}
2009-01-13 04:40:13 +05:00
2011-03-03 01:50:39 +05:00
}
2009-01-13 04:40:13 +05:00
#endif