netgen/libsrc/include/nginterface_v2.hpp

430 lines
10 KiB
C++
Raw Normal View History

2009-07-20 14:36:36 +06:00
#ifndef NGINTERFACE_V2
#define NGINTERFACE_V2
/**************************************************************************/
/* File: nginterface_v2.hpp */
/* Author: Joachim Schoeberl */
/* Date: May 09 */
/**************************************************************************/
2009-04-03 20:39:52 +06:00
#include "mydefs.hpp"
2009-07-20 14:36:36 +06:00
/*
C++ interface to Netgen
*/
#ifndef NGINTERFACE
// implemented element types:
enum NG_ELEMENT_TYPE {
NG_PNT = 0,
NG_SEGM = 1, NG_SEGM3 = 2,
2019-01-18 02:08:35 +05:00
NG_TRIG = 10, NG_QUAD=11, NG_TRIG6 = 12, NG_QUAD6 = 13, NG_QUAD8 = 14,
NG_TET = 20, NG_TET10 = 21,
NG_PYRAMID = 22, NG_PRISM = 23, NG_PRISM12 = 24, NG_PRISM15 = 27, NG_PYRAMID13 = 28,
2019-01-18 02:08:35 +05:00
NG_HEX = 25, NG_HEX20 = 26
};
enum NG_REFINEMENT_TYPE { NG_REFINE_H = 0, NG_REFINE_P = 1, NG_REFINE_HP = 2 };
#endif
2019-02-12 02:12:29 +05:00
// #ifndef PARALLEL
// typedef int MPI_Comm;
// #endif
2019-01-31 23:11:22 +05:00
2009-07-20 14:36:36 +06:00
namespace netgen
{
2019-02-08 13:51:38 +05:00
using namespace std;
using namespace ngcore;
2019-02-13 02:11:55 +05:00
// extern DLL_HEADER NgMPI_Comm ng_comm;
2019-02-08 13:51:38 +05:00
2016-12-11 16:12:05 +05:00
static constexpr int POINTINDEX_BASE = 1;
2014-01-07 16:42:39 +06:00
struct T_EDGE2
{
// int orient:1;
// int nr:31; // 0-based
int nr; // 0-based
2014-01-07 16:42:39 +06:00
};
struct T_FACE2
{
// int orient:3;
// int nr:29; // 0-based
int nr; // 0-based
2014-01-07 16:42:39 +06:00
};
2013-04-03 02:27:12 +06:00
2018-06-08 19:28:51 +05:00
template <typename T>
class Ng_Buffer
{
size_t s;
T * data;
public:
Ng_Buffer (size_t as, T * adata)
: s(as), data(adata) { ; }
Ng_Buffer (Ng_Buffer && buffer)
: s(buffer.Size()), data(buffer.Release()) { ; }
~Ng_Buffer () { delete [] data; }
size_t Size() const { return s; }
T * Release() { T * hd = data; data = nullptr; return hd; }
};
template <typename T, int S>
class Ng_BufferMS
{
size_t s;
T data[S];
public:
Ng_BufferMS (size_t as) : s(as) { ; }
size_t Size() const { return s; }
T & operator[] (size_t i) { return data[i]; }
T operator[] (size_t i) const { return data[i]; }
};
2018-06-08 19:28:51 +05:00
2009-07-20 14:36:36 +06:00
class Ng_Element
2009-07-13 19:03:01 +06:00
{
2009-07-20 14:36:36 +06:00
class Ng_Points
{
public:
2017-02-25 21:11:30 +05:00
size_t num;
2009-07-20 14:36:36 +06:00
const int * ptr;
2009-07-13 19:03:01 +06:00
2017-02-25 21:11:30 +05:00
size_t Size() const { return num; }
int operator[] (size_t i) const { return ptr[i]-POINTINDEX_BASE; }
2009-07-20 14:36:36 +06:00
};
2009-07-13 19:03:01 +06:00
2009-07-20 14:36:36 +06:00
class Ng_Vertices
{
public:
2017-02-25 21:11:30 +05:00
size_t num;
2009-07-20 14:36:36 +06:00
const int * ptr;
2009-07-13 19:03:01 +06:00
2017-02-25 21:11:30 +05:00
size_t Size() const { return num; }
int operator[] (size_t i) const { return ptr[i]-POINTINDEX_BASE; }
2009-07-20 14:36:36 +06:00
};
2009-04-03 20:39:52 +06:00
2009-07-20 14:36:36 +06:00
class Ng_Edges
{
public:
2017-02-25 21:11:30 +05:00
size_t num;
2014-01-07 16:42:39 +06:00
const T_EDGE2 * ptr;
2009-07-13 19:03:01 +06:00
2017-02-25 21:11:30 +05:00
size_t Size() const { return num; }
int operator[] (size_t i) const { return ptr[i].nr; }
2009-07-20 14:36:36 +06:00
};
class Ng_Faces
{
public:
2017-02-25 21:11:30 +05:00
size_t num;
2014-01-07 16:42:39 +06:00
const T_FACE2 * ptr;
2009-07-20 14:36:36 +06:00
2017-02-25 21:11:30 +05:00
size_t Size() const { return num; }
int operator[] (size_t i) const { return ptr[i].nr; }
2009-07-20 14:36:36 +06:00
};
class Ng_Facets
{
public:
2017-02-25 21:11:30 +05:00
size_t num;
int base;
const int * ptr;
2017-02-25 21:11:30 +05:00
size_t Size() const { return num; }
int operator[] (size_t i) const { return ptr[i]-base; }
};
2009-07-20 14:36:36 +06:00
public:
NG_ELEMENT_TYPE type;
2014-12-04 17:39:12 +05:00
int index; // material / boundary condition
2016-02-27 00:30:40 +05:00
const string * mat; // material / boundary label
2009-07-20 14:36:36 +06:00
NG_ELEMENT_TYPE GetType() const { return type; }
2015-01-10 19:48:49 +05:00
int GetIndex() const { return index-1; }
2009-07-20 14:36:36 +06:00
Ng_Points points; // all points
Ng_Vertices vertices;
Ng_Edges edges;
Ng_Faces faces;
Ng_Facets facets;
2015-04-27 14:18:22 +05:00
bool is_curved;
2009-07-13 19:03:01 +06:00
};
2009-04-03 20:39:52 +06:00
2009-09-07 17:50:13 +06:00
class Ng_Point
{
double * pt;
2014-01-07 16:42:39 +06:00
public:
Ng_Point (double * apt) : pt(apt) { ; }
2017-05-31 10:52:45 +05:00
double operator[] (size_t i)
2009-09-07 17:50:13 +06:00
{ return pt[i]; }
2014-01-07 16:42:39 +06:00
operator const double * () { return pt; }
2009-09-07 17:50:13 +06:00
};
2009-07-20 14:36:36 +06:00
template <int DIM> class Ng_Node;
template <>
class Ng_Node<0>
{
class Ng_Elements
{
public:
2017-05-31 10:52:45 +05:00
size_t ne;
const int * ptr;
2017-05-31 10:52:45 +05:00
size_t Size() const { return ne; }
int operator[] (size_t i) const { return ptr[i]; }
};
public:
Ng_Elements elements;
2016-03-23 12:17:45 +05:00
Ng_Elements bnd_elements;
};
2009-07-20 14:36:36 +06:00
template <>
class Ng_Node<1>
2009-04-03 20:39:52 +06:00
{
2009-07-20 14:36:36 +06:00
class Ng_Vertices
{
public:
const int * ptr;
2009-07-13 19:03:01 +06:00
2017-05-31 10:52:45 +05:00
size_t Size() const { return 2; }
int operator[] (size_t i) const { return ptr[i]-POINTINDEX_BASE; }
2009-07-20 14:36:36 +06:00
};
2009-07-13 19:03:01 +06:00
2009-07-20 14:36:36 +06:00
public:
Ng_Vertices vertices;
};
2010-05-17 15:00:30 +06:00
template <>
class Ng_Node<2>
{
class Ng_Vertices
{
public:
2017-05-31 10:52:45 +05:00
size_t nv;
2010-05-17 15:00:30 +06:00
const int * ptr;
2017-05-31 10:52:45 +05:00
size_t Size() const { return nv; }
int operator[] (size_t i) const { return ptr[i]-POINTINDEX_BASE; }
2010-05-17 15:00:30 +06:00
};
/*
2010-05-17 15:00:30 +06:00
class Ng_Edges
{
public:
2017-05-31 10:52:45 +05:00
size_t ned;
2010-05-17 15:00:30 +06:00
const int * ptr;
2017-05-31 10:52:45 +05:00
size_t Size() const { return ned; }
int operator[] (size_t i) const { return ptr[i]-1; }
2010-05-17 15:00:30 +06:00
};
*/
2010-05-17 15:00:30 +06:00
public:
Ng_Vertices vertices;
// Ng_Edges edges;
2017-05-10 20:41:44 +05:00
int surface_el; // -1 if face not on surface
2010-05-17 15:00:30 +06:00
};
2009-07-20 14:36:36 +06:00
2009-04-03 20:39:52 +06:00
2014-09-08 21:21:09 +06:00
class Mesh;
2009-07-19 23:33:25 +06:00
inline void DummyTaskManager2 (function<void(int,int)> func)
{ func(0,1); }
2018-01-04 14:43:22 +05:00
inline void DummyTracer2 (string, bool) { ; }
2013-04-05 16:06:06 +06:00
class DLL_HEADER Ngx_Mesh
2013-04-03 02:27:12 +06:00
{
private:
2014-09-08 21:21:09 +06:00
shared_ptr<Mesh> mesh;
2013-04-03 02:27:12 +06:00
public:
2014-01-20 15:30:17 +06:00
// Ngx_Mesh () { ; }
// Ngx_Mesh(class Mesh * amesh) : mesh(amesh) { ; }
2014-01-07 16:42:39 +06:00
/** reuse a netgen-mesh **/
Ngx_Mesh (shared_ptr<Mesh> amesh);
/** load a new mesh **/
2019-02-13 02:11:55 +05:00
Ngx_Mesh (string filename, NgMPI_Comm acomm = NgMPI_Comm{});
2019-02-13 02:11:55 +05:00
void LoadMesh (const string & filename, NgMPI_Comm comm = NgMPI_Comm{});
2019-02-13 02:11:55 +05:00
void LoadMesh (istream & str, NgMPI_Comm comm = NgMPI_Comm{});
2014-02-24 01:31:40 +06:00
void SaveMesh (ostream & str) const;
2014-10-19 19:53:57 +06:00
void UpdateTopology ();
2018-11-29 22:35:30 +05:00
void DoArchive (Archive & archive);
2014-02-24 01:31:40 +06:00
const NgMPI_Comm & GetCommunicator() const;
2013-04-03 02:27:12 +06:00
virtual ~Ngx_Mesh();
2014-01-07 16:42:39 +06:00
bool Valid () const { return mesh != NULL; }
2013-04-03 02:27:12 +06:00
int GetDimension() const;
int GetNLevels() const;
size_t GetNVLevel (int level) const;
2013-04-03 02:27:12 +06:00
int GetNElements (int dim) const;
int GetNNodes (int nt) const;
Ng_Point GetPoint (int nr) const;
template <int DIM>
2017-02-25 21:11:30 +05:00
Ng_Element GetElement (size_t nr) const;
2013-04-03 02:27:12 +06:00
template <int DIM>
2017-02-25 21:11:30 +05:00
int GetElementIndex (size_t nr) const;
2013-04-03 02:27:12 +06:00
/// material/boundary label of region, template argument is co-dimension
template <int DIM>
const string & GetMaterialCD (int region_nr) const;
2013-04-03 02:27:12 +06:00
/// Curved Elements:
/// elnr .. element nr
/// xi..... DIM_EL local coordinates
/// x ..... DIM_SPACE global coordinates
/// dxdxi...DIM_SPACE x DIM_EL Jacobian matrix (row major storage)
template <int DIM_EL, int DIM_SPACE>
2013-04-04 20:35:21 +06:00
void ElementTransformation (int elnr,
const double * xi,
double * x,
double * dxdxi) const;
2013-04-03 02:27:12 +06:00
/// Curved Elements:
/// elnr .. element nr
/// npts .. number of points
/// xi..... DIM_EL local coordinates
/// sxi ... step xi
/// x ..... DIM_SPACE global coordinates
/// dxdxi...DIM_SPACE x DIM_EL Jacobian matrix (row major storage)
2016-04-10 09:36:05 +05:00
template <int DIM_EL, int DIM_SPACE, typename T>
2013-04-04 20:35:21 +06:00
void MultiElementTransformation (int elnr, int npts,
2016-04-10 09:36:05 +05:00
const T * xi, size_t sxi,
T * x, size_t sx,
T * dxdxi, size_t sdxdxi) const;
2013-04-04 20:35:21 +06:00
2013-04-03 02:27:12 +06:00
template <int DIM>
2016-03-22 22:16:04 +05:00
const Ng_Node<DIM> GetNode (int nr) const;
Ng_BufferMS<int,4> GetFaceEdges (int fnr) const;
2013-04-03 02:27:12 +06:00
template <int DIM>
2013-04-04 20:35:21 +06:00
int GetNNodes ();
2013-04-03 02:27:12 +06:00
// returns domain numbers of domains next to boundary bnr -> (domin, domout)
// 3D only
// std::pair<int,int> GetBoundaryNeighbouringDomains (int bnr);
template <int DIM>
void SetRefinementFlag (size_t elnr, bool flag);
2018-05-02 00:26:47 +05:00
void Curve (int order);
int GetCurveOrder ();
2021-02-18 03:32:15 +05:00
void EnableTable (string name, bool set);
void Refine (NG_REFINEMENT_TYPE reftype, bool onlyonce,
2018-01-04 14:43:22 +05:00
void (*taskmanager)(function<void(int,int)>) = &DummyTaskManager2,
void (*tracer)(string, bool) = &DummyTracer2);
2018-12-06 16:49:38 +05:00
int GetHPElementLevel (int ei, int dir) const;
void GetParentNodes (int ni, int * parents) const;
int GetParentElement (int ei) const;
int GetParentSElement (int ei) const;
bool HasParentEdges() const;
tuple<int, std::array<int,3>> GetParentEdges (int enr) const;
tuple<int, std::array<int,4>> GetParentFaces (int fnr) const;
int GetNIdentifications() const;
int GetIdentificationType(int idnr) const;
2018-06-08 19:28:51 +05:00
Ng_Buffer<int[2]> GetPeriodicVertices(int idnr) const;
2013-04-03 02:27:12 +06:00
// Find element of point, returns local coordinates
template <int DIM>
2013-04-04 20:35:21 +06:00
int FindElementOfPoint
2013-04-03 02:27:12 +06:00
(double * p, double * lami,
bool build_searchtrees = false,
2014-01-07 16:42:39 +06:00
int * const indices = NULL, int numind = 0) const;
2013-04-03 02:27:12 +06:00
2014-12-03 02:50:38 +05:00
2019-02-11 11:57:09 +05:00
// for MPI-parallel
2020-08-21 19:29:33 +05:00
FlatArray<int> GetDistantProcs (int nodetype, int locnum) const;
size_t GetGlobalVertexNum (int locnum) const;
2016-05-06 20:58:45 +05:00
shared_ptr<Mesh> GetMesh () const { return mesh; }
2014-09-08 21:21:09 +06:00
shared_ptr<Mesh> SelectMesh () const;
2018-05-19 00:13:09 +05:00
inline auto GetTimeStamp() const;
// also added from nginterface.h, still 1-based, need redesign
void HPRefinement (int levels, double parameter = 0.125,
bool setorders = true,bool ref_level = false);
size_t GetNP() const;
int GetSurfaceElementSurfaceNumber (size_t ei) const;
int GetSurfaceElementFDNumber (size_t ei) const;
int GetElementOrder (int enr) const;
void GetElementOrders (int enr, int * ox, int * oy, int * oz) const;
void SetElementOrder (int enr, int order);
void SetElementOrders (int enr, int ox, int oy, int oz);
int GetSurfaceElementOrder (int enr) const;
void GetSurfaceElementOrders (int enr, int * ox, int * oy) const;
void SetSurfaceElementOrder (int enr, int order);
void SetSurfaceElementOrders (int enr, int ox, int oy);
int GetClusterRepVertex (int vi) const;
int GetClusterRepEdge (int edi) const;
int GetClusterRepFace (int fai) const;
int GetClusterRepElement (int eli) const;
2013-04-03 02:27:12 +06:00
};
DLL_HEADER Ngx_Mesh * LoadMesh (const string & filename);
2014-01-07 16:42:39 +06:00
}
2013-04-03 02:27:12 +06:00
2014-01-07 16:42:39 +06:00
#ifdef HAVE_NETGEN_SOURCES
#include <meshing.hpp>
2013-04-03 02:27:12 +06:00
2014-01-07 16:42:39 +06:00
namespace netgen
{
2016-01-07 17:37:48 +05:00
#ifdef __GNUC__
#define NGX_INLINE __attribute__ ((__always_inline__)) inline
#else
2014-01-07 16:42:39 +06:00
#define NGX_INLINE inline
2016-01-07 17:37:48 +05:00
#endif
2014-01-07 16:42:39 +06:00
#include <nginterface_v2_impl.hpp>
2009-07-20 14:36:36 +06:00
}
2014-01-07 16:42:39 +06:00
#endif
2009-07-20 14:36:36 +06:00
#endif