netgen-mesher 6.2.2506.post35.dev0__cp314-cp314-win_amd64.whl

netgen/include/meshing/clusters.hpp

@@ -0,0 +1,46 @@
+#ifndef NETGEN_CLUSTERS_HPP
+#define NETGEN_CLUSTERS_HPP
+
+/**************************************************************************/
+/* File:   clusers.hh                                                     */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   28. Apr. 01                                                    */
+/**************************************************************************/
+
+/*
+  Anisotropic clusters
+
+  nodes, edges, faces, elements
+*/
+
+#include "meshclass.hpp"
+
+namespace netgen
+{
+
+class AnisotropicClusters
+{
+  const Mesh & mesh;
+
+  int nv, ned, nfa, ne;
+
+  // connected nodes, nodes = vertices, edges, faces, elements
+  NgArray<int> cluster_reps;
+
+public:
+  AnisotropicClusters (const Mesh & amesh);
+  ~AnisotropicClusters();
+
+  void Update();
+
+  int GetVertexRepresentant (int vnr) const
+  { return cluster_reps.Get(vnr); }
+  int GetEdgeRepresentant (int ednr) const
+  { return cluster_reps.Get(nv+ednr); }
+  int GetFaceRepresentant (int fnr) const
+  { return cluster_reps.Get(nv+ned+fnr); }
+  int GetElementRepresentant (int enr) const
+  { return cluster_reps.Get(nv+ned+nfa+enr); }
+};
+} // namespace netgen
+#endif // NETGEN_CLUSTERS_HPP

netgen/include/meshing/curvedelems.hpp

@@ -0,0 +1,274 @@
+#ifndef NETGEN_CURVEDELEMS_HPP
+#define NETGEN_CURVEDELEMS_HPP
+
+/**************************************************************************/
+/* File:   curvedelems.hpp                                                */
+/* Author: Robert Gaisbauer (first version)                               */
+/*         redesign by Joachim Schoeberl                                  */
+/* Date:   27. Sep. 02, Feb 2006                                          */
+/**************************************************************************/
+
+#include <mydefs.hpp>
+#include <general/ngarray.hpp>
+#include <gprim/geomobjects.hpp>
+
+#include "meshtype.hpp"
+#include "meshclass.hpp"
+
+namespace netgen
+{
+class Refinement;
+class Mesh;
+
+class CurvedElements
+{
+  const Mesh & mesh;
+
+  NgArray<int> edgeorder;
+  NgArray<int> faceorder;
+
+  NgArray<int> edgecoeffsindex;
+  NgArray<int> facecoeffsindex;
+
+  NgArray< Vec<3> > edgecoeffs;
+  NgArray< Vec<3> > facecoeffs;
+
+  NgArray< double > edgeweight;  // for rational 2nd order splines
+
+  int order;
+  bool rational;
+
+  bool ishighorder;
+
+public:
+  DLL_HEADER CurvedElements (const Mesh & amesh);
+  DLL_HEADER ~CurvedElements();
+
+  // bool IsHighOrder() const { return order > 1; }
+  bool IsHighOrder() const { return ishighorder; }
+
+  // void SetHighOrder (int aorder) { order=aorder; }
+  void SetIsHighOrder (bool ho) { ishighorder = ho; }
+  
+  DLL_HEADER void BuildCurvedElements(const Refinement * ref, int aorder, bool arational = false);
+
+  int GetOrder () { return order; }
+
+  void DoArchive(Archive& ar)
+  {
+    ar & edgeorder & faceorder & edgecoeffsindex & facecoeffsindex & edgecoeffs & facecoeffs
+      & edgeweight & order & rational & ishighorder;
+  }
+
+  DLL_HEADER bool IsSegmentCurved (SegmentIndex segnr) const;
+  DLL_HEADER bool IsSurfaceElementCurved (SurfaceElementIndex sei) const;
+  DLL_HEADER bool IsElementCurved (ElementIndex ei) const;
+  DLL_HEADER bool IsElementHighOrder (ElementIndex ei) const;
+
+
+  void CalcSegmentTransformation (double xi, SegmentIndex segnr,
+				  Point<3> & x)
+  { CalcSegmentTransformation<double> (xi, segnr, &x, NULL); };
+
+  void CalcSegmentTransformation (double xi, SegmentIndex segnr,
+				  Vec<3> & dxdxi)
+  { CalcSegmentTransformation<double> (xi, segnr, NULL, &dxdxi); };
+
+  void CalcSegmentTransformation (double xi, SegmentIndex segnr,
+				  Point<3> & x, Vec<3> & dxdxi)
+  { CalcSegmentTransformation<double> (xi, segnr, &x, &dxdxi, NULL); };
+
+  void CalcSegmentTransformation (double xi, SegmentIndex segnr,
+				  Point<3> & x, Vec<3> & dxdxi, bool & curved)
+  { CalcSegmentTransformation (xi, segnr, &x, &dxdxi, &curved); };
+
+
+
+  void CalcSurfaceTransformation (const Point<2> & xi, SurfaceElementIndex elnr,
+				  Point<3> & x)
+  { CalcSurfaceTransformation (xi, elnr, &x, NULL); };
+
+  void CalcSurfaceTransformation (const Point<2> & xi, SurfaceElementIndex elnr,
+				  Mat<3,2> & dxdxi)
+  { CalcSurfaceTransformation (xi, elnr, NULL, &dxdxi); };
+
+  void CalcSurfaceTransformation (const Point<2> & xi, SurfaceElementIndex elnr,
+				  Point<3> & x, Mat<3,2> & dxdxi)
+  { CalcSurfaceTransformation (xi, elnr, &x, &dxdxi, NULL); };
+
+  void CalcSurfaceTransformation (const Point<2> & xi, SurfaceElementIndex elnr,
+				  Point<3> & x, Mat<3,2> & dxdxi, bool & curved)
+  { CalcSurfaceTransformation (xi, elnr, &x, &dxdxi, &curved); };
+
+
+
+
+
+  void CalcElementTransformation (const Point<3> & xi, ElementIndex elnr,
+				  Point<3> & x)
+  { CalcElementTransformation (xi, elnr, &x, NULL); };
+
+  void CalcElementTransformation (const Point<3> & xi, ElementIndex elnr,
+				  Mat<3,3> & dxdxi)
+  { CalcElementTransformation (xi, elnr, NULL, &dxdxi); };
+
+  void CalcElementTransformation (const Point<3> & xi, ElementIndex elnr,
+				  Point<3> & x, Mat<3,3> & dxdxi)
+  { CalcElementTransformation (xi, elnr, &x, &dxdxi /* , NULL */ ); };
+
+  void CalcElementTransformation (const Point<3> & xi, ElementIndex elnr,
+				  Point<3> & x, Mat<3,3> & dxdxi,
+                                  void * buffer, bool valid)
+  { CalcElementTransformation (xi, elnr, &x, &dxdxi, /* NULL, */ buffer, valid ); };
+
+  // void CalcElementTransformation (const Point<3> & xi, ElementIndex elnr,
+  // 				  Point<3> & x, Mat<3,3> & dxdxi) // , bool & curved)
+  //   { CalcElementTransformation (xi, elnr, &x, &dxdxi /* , &curved * ); }
+
+
+  /*
+  void CalcMultiPointSegmentTransformation (NgArray<double> * xi, SegmentIndex segnr,
+					    NgArray<Point<3> > * x,
+					    NgArray<Vec<3> > * dxdxi);
+  */
+  
+  template <int DIM_SPACE, typename T>
+  void CalcMultiPointSegmentTransformation (SegmentIndex elnr, int n,
+                                            const T * xi, size_t sxi,
+                                            T * x, size_t sx,
+                                            T * dxdxi, size_t sdxdxi);
+
+  DLL_HEADER void CalcMultiPointSurfaceTransformation (NgArray< Point<2> > * xi, SurfaceElementIndex elnr,
+					    NgArray< Point<3> > * x,
+					    NgArray< Mat<3,2> > * dxdxi);
+
+  template <int DIM_SPACE, typename T>
+  void CalcMultiPointSurfaceTransformation (SurfaceElementIndex elnr, int n,
+                                            const T * xi, size_t sxi,
+                                            T * x, size_t sx,
+                                            T * dxdxi, size_t sdxdxi);
+
+  DLL_HEADER void CalcMultiPointElementTransformation (NgArray< Point<3> > * xi, ElementIndex elnr,
+					    NgArray< Point<3> > * x,
+					    NgArray< Mat<3,3> > * dxdxi);
+
+  template <typename T>
+  void CalcMultiPointElementTransformation (ElementIndex elnr, int n,
+                                            const T * xi, size_t sxi,
+                                            T * x, size_t sx,
+                                            T * dxdxi, size_t sdxdxi);
+
+
+
+
+private:
+
+  template <typename T>
+  DLL_HEADER void CalcSegmentTransformation (const T & xi, SegmentIndex segnr,
+				  Point<3,T> * x = NULL, Vec<3,T> * dxdxi = NULL, bool * curved = NULL);
+
+  DLL_HEADER void CalcSurfaceTransformation (Point<2> xi, SurfaceElementIndex elnr,
+				  Point<3> * x = NULL, Mat<3,2> * dxdxi = NULL, bool * curved = NULL);
+
+  DLL_HEADER void CalcElementTransformation (Point<3> xi, ElementIndex elnr,
+				  Point<3> * x = NULL, Mat<3,3> * dxdxi = NULL, // bool * curved = NULL,
+                                  void * buffer = NULL, bool valid = 0);
+
+
+
+
+
+
+  class SegmentInfo
+  {
+  public:
+    SegmentIndex elnr;
+    int order;
+    int nv;
+    int ndof;
+    int edgenr;
+  };
+
+  template <typename T>
+  void CalcElementShapes (SegmentInfo &  elnr, T xi, TFlatVector<T> shapes) const;
+  void GetCoefficients (SegmentInfo & elnr, NgArray<Vec<3> > & coefs) const;
+  template <typename T>
+  void CalcElementDShapes (SegmentInfo & elnr, T xi, TFlatVector<T> dshapes) const;
+
+
+  class ElementInfo
+  {
+  public:
+    ElementIndex elnr;
+    int order;
+    int nv;
+    int ndof;
+    int nedges;
+    int nfaces;
+    int edgenrs[12];
+    int facenrs[6];
+    Mat<3> hdxdxi;
+    Vec<3> hcoefs[10]; // enough for second order tets
+
+    void SetEdges (FlatArray<T_EDGE> edges)
+    {
+      nedges = edges.Size();
+      for (int i = 0; i < edges.Size(); i++)
+        edgenrs[i] = edges[i];
+    }
+    
+    auto GetEdges() const
+    { return FlatArray(nedges, edgenrs); }
+
+    void SetFaces (FlatArray<T_FACE> faces)
+    {
+      nfaces = faces.Size();
+      for (int i = 0; i < faces.Size(); i++)
+        facenrs[i] = faces[i];
+    }
+
+    auto GetFaces() const
+    { return FlatArray(nfaces, facenrs); }
+  };
+
+  template <typename T>
+  void CalcElementShapes (ElementInfo & info, Point<3,T> xi, TFlatVector<T> shapes) const;
+  void GetCoefficients (ElementInfo & info, Vec<3> * coefs) const;
+  template <typename T>  
+  void CalcElementDShapes (ElementInfo & info, const Point<3,T> xi, MatrixFixWidth<3,T> & dshapes) const;
+
+  template <typename T>
+  bool EvaluateMapping (ElementInfo & info, const Point<3,T> xi, Point<3,T> & x, Mat<3,3,T> & jac) const;  
+  
+  class SurfaceElementInfo
+  {
+  public:
+    SurfaceElementIndex elnr;
+    int order;
+    int nv;
+    int ndof;
+    NgArrayMem<int,4> edgenrs;
+    int facenr;
+
+    void SetEdges (FlatArray<T_EDGE> edges)
+    {
+      edgenrs.SetSize(edges.Size());
+      for (int i = 0; i < edges.Size(); i++)
+        edgenrs[i] = edges[i];
+    }
+    
+  };
+
+  template <typename T>
+  void CalcElementShapes (SurfaceElementInfo & elinfo, const Point<2,T> xi, TFlatVector<T> shapes) const;
+  template <int DIM_SPACE>
+  void GetCoefficients (SurfaceElementInfo & elinfo, NgArray<Vec<DIM_SPACE> > & coefs) const;
+  template <typename T>
+  void CalcElementDShapes (SurfaceElementInfo & elinfo, const Point<2,T> xi, MatrixFixWidth<2,T> & dshapes) const;
+
+  template <int DIM_SPACE, typename T>
+  bool EvaluateMapping (SurfaceElementInfo & info, const Point<2,T> xi, Point<DIM_SPACE,T> & x, Mat<DIM_SPACE,2,T> & jac) const;  
+};
+
+} //namespace netgen
+#endif // NETGEN_CURVEDELEMS_HPP

netgen/include/meshing/delaunay2d.hpp

@@ -0,0 +1,73 @@
+#include "meshing.hpp"
+
+namespace netgen
+{
+
+  static inline Point<2> P2( Point<3> p )
+  {
+    return {p[0], p[1]};
+  }
+
+  static inline Point<3> P3( Point<2> p )
+  {
+    return {p[0], p[1], 0};
+  }
+
+  class DelaunayTrig
+  {
+    PointIndex pnums[3];
+    Point<2> c;
+
+  public:
+    double r;
+    double rad2;
+    DelaunayTrig () = default;
+    DelaunayTrig (PointIndex p1, PointIndex p2, PointIndex p3)
+    {
+      pnums[0] = p1;
+      pnums[1] = p2;
+      pnums[2] = p3;
+    }
+
+    PointIndex & operator[] (int j) { return pnums[j]; }
+    const PointIndex & operator[] (int j) const { return pnums[j]; }
+
+    void CalcCenter (FlatArray<Point<2>, PointIndex> points);
+
+    Point<2> Center() const { return c; }
+    double Radius2() const { return rad2; }
+    Box<2> BoundingBox() const { return Box<2> (c-Vec<2>(r,r), c+Vec<2>(r,r)); }
+
+    mutable PointIndex visited_pi = PointIndex::INVALID; //  -1;
+  };
+
+  class DelaunayMesh
+  {
+    ngcore::ClosedHashTable<PointIndices<2>, IVec<2>> edge_to_trig;
+    Array<DelaunayTrig> trigs;
+    unique_ptr<DelaunayTree<2>> tree;
+    Array<Point<2>, PointIndex> & points;
+
+    Array<int> closeels;
+    Array<int> intersecting;
+    Array<PointIndices<2>> edges;
+
+    int GetNeighbour( int eli, int edge );
+
+    void SetNeighbour( int eli, int edge );
+
+    void UnsetNeighbours( int eli );
+
+    void AppendTrig( PointIndex pi0, PointIndex pi1, PointIndex pi2 );
+
+    public:
+    DelaunayMesh( Array<Point<2>, PointIndex> & points_, Box<2> box  );
+
+    void CalcIntersecting( PointIndex pi_new );
+    void CalcWeights( PointIndex pi_new, std::map<PointIndex, double> & weights );
+    void AddPoint( PointIndex pi_new );
+    Array<DelaunayTrig> & GetElements() { return trigs; }
+    unique_ptr<Mesh> GetMesh(PointIndex pi_new); // for debugging purposes
+  };
+
+} // namespace netgen

netgen/include/meshing/fieldlines.hpp

@@ -0,0 +1,103 @@
+#ifndef FIELDLINES_HPP_INCLUDED
+#define FIELDLINES_HPP_INCLUDED
+
+namespace netgen
+{
+
+class RKStepper
+{
+private:
+  Array<double> c,b;
+  TABLE<double> *a;
+  int steps;
+  int order;
+
+  double tolerance;
+
+  Array<Vec<3>> K;
+
+  int stepcount;
+
+  double h;
+  double startt;
+  double startt_bak;
+  Point<3> startval;
+  Point<3> startval_bak;
+
+  bool adaptive;
+  int adrun;
+  Point<3> valh;
+
+  int notrestarted;
+
+public:
+
+  DLL_HEADER ~RKStepper();
+
+  RKStepper(int type = 0);
+
+  void SetTolerance(const double tol){tolerance = tol;}
+
+  void StartNextValCalc(const Point<3> & astartval, const double astartt, const double ah, const bool aadaptive = false);
+
+  bool GetNextData(Point<3> & val, double & t, double & ah);
+
+  bool FeedNextF(const Vec<3> & f);
+};
+
+
+
+
+class FieldLineCalc
+{
+private:
+  const Mesh & mesh;
+
+  typedef std::function<bool (int elnr, const double *, Vec<3> &)> VectorFunction;
+
+  const VectorFunction & func;
+  RKStepper stepper;
+
+  Array<double> values;
+  Array<Point<3>> pstart, pend;
+
+  double maxlength;
+
+  int maxpoints;
+
+  int direction;
+
+  Point3d pmin, pmax;
+  double rad;
+
+  double critical_value;
+
+  bool randomized;
+
+  double thickness;
+
+public:
+  DLL_HEADER FieldLineCalc(const Mesh & amesh, const VectorFunction & afunc,
+		const double rel_length, const int amaxpoints = -1,
+		const double rel_thickness = -1, const double rel_tolerance = -1, const int rk_type = 0, const int adirection = 0);
+
+  DLL_HEADER ~FieldLineCalc();
+
+  void SetCriticalValue(const double val) { critical_value = val; }
+
+  void Randomized(void) { randomized = true; }
+  void NotRandomized(void) { randomized = false; }
+
+  DLL_HEADER void Calc(const Point<3> & startpoint, Array<Point<3>> & points, Array<double> & vals, Array<bool> & drawelems, Array<int> & dirstart);
+
+  DLL_HEADER void GenerateFieldLines(Array<Point<3>> & potential_startpoints, const int numlines);
+
+  const auto & GetPStart() const { return pstart; }
+  const auto & GetPEnd() const { return pend; }
+  const auto & GetValues() const { return values; }
+  const auto GetThickness() const { return thickness; }
+};
+
+} // namespace netgen
+
+#endif // VSFIELDLINES_HPP_INCLUDED

netgen/include/meshing/findip.hpp

@@ -0,0 +1,198 @@
+#ifndef NETGEN_FINDIP_HPP
+#define NETGEN_FINDIP_HPP
+
+// find inner point
+
+namespace netgen
+{
+
+inline void Minimize (const NgArray<Vec3d> & a,
+		      const NgArray<double> & c,
+		      int * act, 
+		      Vec<3> & x, double & f,
+		      int * sol)
+{
+  int act1[4];
+  Mat<3> m, inv;
+  Vec<3> rs, xmax, center;
+
+  f = 1e99;
+
+  for (int j = 0; j < 5; j++)
+    {
+      for (int hk = 0, k = 0; hk < 4; hk++)
+	{
+	  if (hk == j) k++;
+	  act1[hk] = act[k];
+	  k++;
+	}
+
+      for (int k = 0; k < 3; k++)
+	{
+	  m(k, 0) = a[act1[0]].X() - a[act1[k+1]].X();
+	  m(k, 1) = a[act1[0]].Y() - a[act1[k+1]].Y();
+	  m(k, 2) = a[act1[0]].Z() - a[act1[k+1]].Z();
+	  rs(k) = c[act1[k+1]] - c[act1[0]];
+	}
+
+      /*
+      (*testout) << "act1 = "
+		 << act1[0] << " "
+		 << act1[1] << " "
+		 << act1[2] << " "
+		 << act1[3] << endl;
+      (*testout) << "Det = " << Det(m) << endl;
+      */
+
+      if (fabs (Det (m)) > 1e-10)
+	{
+	  CalcInverse (m, inv);
+	  xmax = inv * rs;
+	  
+	  double fmax = -1e10;
+	  for (int k = 0; k < 5; k++)
+	    {
+	      double hd = 
+		xmax(0) * a[act[k]].X() + xmax(1) * a[act[k]].Y() + xmax(2) * a[act[k]].Z() + c[act[k]];
+	      if (hd > fmax) fmax = hd;
+	    }
+
+	  if (fmax < f)
+	    {
+	      f = fmax;
+	      x = xmax;
+	      for (int k = 0; k < 4; k++)
+		sol[k] = act1[k];
+	    }
+	}
+    }
+}
+
+
+
+
+template <typename POINTArray, typename FACEArray>
+inline int FindInnerPoint (POINTArray & points,
+			   FACEArray & faces,
+			   Point3d & p)
+{
+  static int timer = NgProfiler::CreateTimer ("FindInnerPoint");
+  NgProfiler::RegionTimer reg (timer);
+
+  NgArray<Vec3d> a;
+  NgArray<double> c;
+  Mat<3> m, inv;
+  Vec<3> rs, x = 0.0, center;
+  double f;
+
+  int nf = faces.Size();
+
+  // minimize_x  max_i  a_i x + c_i
+
+  a.SetSize (nf+4);
+  c.SetSize (nf+4);
+
+  for (int i = 0; i < nf; i++)
+    {
+      Point3d p1 = points[faces[i][0]];
+      a[i] = Cross (points[faces[i][1]] - p1,
+		    points[faces[i][2]] - p1);
+      a[i] /= a[i].Length();
+      c[i] = - (a[i].X() * p1.X() + a[i].Y() * p1.Y() + a[i].Z() * p1.Z());
+    }
+
+  /*
+  center = 0;
+  for (int i = 0; i < points.Size(); i++)
+    center += Vec<3> (points[i]);
+  center /= points.Size();
+  */
+
+  center = 0;
+  for (int i = 0; i < faces.Size(); i++)
+    for (int j = 0; j < 3; j++)
+      center += Vec<3> (points[faces[i][j]]);
+  center /= (3*faces.Size());
+
+
+  // (*testout) << "center = " << center << endl;
+
+  double hmax = 0;
+  for (int i = 0; i < nf; i++)
+    {
+      // const Element2d & el = faces[i];
+      // (*testout) << "el[" << i << "] = " << el << endl;
+      for (int j : Range(3))
+	{
+	  double hi = Dist (points[faces[i][j%3]],
+			    points[faces[i][(j+1)%3]]);
+	  if (hi > hmax) hmax = hi;
+	}
+    }
+  
+  // (*testout) << "hmax = " << hmax << endl;
+  
+  a[nf] = Vec<3> (1, 0, 0);
+  c[nf] = -center(0) - hmax;
+  a[nf+1] = Vec<3> (0, 1, 0);
+  c[nf+1] = -center(1) - hmax;
+  a[nf+2] = Vec<3> (0, 0, 1);
+  c[nf+2] = -center(2) - hmax;
+  a[nf+3] = Vec<3> (-1, -1, -1);
+  c[nf+3] = center(0)+center(1)+center(2)-3*hmax;
+
+  /*
+  (*testout) << "findip, a now = " << endl << a << endl;
+  (*testout) << "findip, c now = " << endl << c << endl;
+  */
+
+  int act[5] = { 0, nf, nf+1, nf+2, nf+3 };
+  int sol[4];
+
+  while (1)
+    {
+      /*
+      (*testout) << "try ";
+      for (int j = 0; j < 5; j++)
+	(*testout)  << act[j] << " ";
+      */
+
+      Minimize (a, c, act, x, f, sol);
+
+      /*
+      (*testout) << endl << "sol = ";
+      for (int j = 0; j < 4; j++)
+	(*testout)  << sol[j] << " ";
+
+      (*testout) << " fmin = " << f << endl;
+      */
+      for (int j = 0; j < 4; j++) act[j] = sol[j];
+      
+      bool found = 0;
+      double maxval = f;
+      for (int j = 0; j < nf; j++)
+	{
+	  double val = x(0) * a[j].X() + x(1) * a[j].Y() + x(2) * a[j].Z() + c[j];
+	  if (val > maxval + hmax * 1e-6)
+	    {
+	      found = 1;
+	      maxval = val;
+	      act[4] = j;
+	    }
+	}
+      
+      // (*testout) << "maxval = " << maxval << endl;
+      if (!found) break;
+    }
+  
+  // cout << "converged, f = " << f << endl;
+  
+  p = Point3d (x(0), x(1), x(2));
+  // (*testout) << "findip, f = " << f << ", hmax = " << hmax << endl;
+  return (f < -1e-5 * hmax);
+}
+
+} // namespace netgen
+#endif // FILE_FINDINNERPOINT_HPP
+
+