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

netgen/include/meshing/findip2.hpp

@@ -0,0 +1,103 @@
+#ifndef NETGEN_FINDIP2_HPP
+#define NETGEN_FINDIP2_HPP
+
+// find inner point
+
+namespace netgen
+{
+
+template <typename POINTArray, typename FACEArray>
+inline int FindInnerPoint2 (POINTArray & points,
+			    FACEArray & faces,
+			    Point3d & p)
+{
+  static int timer = NgProfiler::CreateTimer ("FindInnerPoint2");
+  NgProfiler::RegionTimer reg (timer);
+
+  NgArray<Vec3d> a;
+  NgArray<double> c;
+  Mat<3> m, inv;
+  Vec<3> rs, x, pmin;
+
+  int nf = faces.Size();
+
+  a.SetSize (nf);
+  c.SetSize (nf);
+
+  for (int i = 0; i < nf; i++)
+    {
+      Point3d p1 = points.Get(faces[i][0]);
+      a[i] = Cross (points.Get(faces[i][1]) - p1,
+		    points.Get(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());
+    }
+
+
+  x = 0;
+  
+  
+  double hmax = 0;
+  for (int i = 0; i < nf; i++)
+    {
+      const Element2d & el = faces[i];
+      for (int j = 1; j <= 3; j++)
+	{
+	  double hi = Dist (points.Get(el.PNumMod(j)),
+			    points.Get(el.PNumMod(j+1)));
+	  if (hi > hmax) hmax = hi;
+	}
+    }
+
+  double fmin = 0;
+
+  for (int i1 = 1; i1 <= nf; i1++)
+    for (int i2 = i1+1; i2 <= nf; i2++)
+      for (int i3 = i2+1; i3 <= nf; i3++)
+        for (int i4 = i3+1; i4 <= nf; i4++)
+          {
+	    m(0, 0) = a.Get(i1).X() - a.Get(i2).X();
+	    m(0, 1) = a.Get(i1).Y() - a.Get(i2).Y();
+	    m(0, 2) = a.Get(i1).Z() - a.Get(i2).Z();
+	    rs(0) = c.Get(i2) - c.Get(i1);
+
+	    m(1, 0) = a.Get(i1).X() - a.Get(i3).X();
+	    m(1, 1) = a.Get(i1).Y() - a.Get(i3).Y();
+	    m(1, 2) = a.Get(i1).Z() - a.Get(i3).Z();
+	    rs(1) = c.Get(i3) - c.Get(i1);
+
+	    m(2, 0) = a.Get(i1).X() - a.Get(i4).X();
+	    m(2, 1) = a.Get(i1).Y() - a.Get(i4).Y();
+	    m(2, 2) = a.Get(i1).Z() - a.Get(i4).Z();
+	    rs(2) = c.Get(i4) - c.Get(i1);
+
+
+	    if (fabs (Det (m)) > 1e-10)
+	      {
+		CalcInverse (m, inv);
+		x = inv * rs;
+
+		double f = -1e10;
+		for (int i = 0; i < nf; i++)
+		  {
+		    double hd = 
+		      x(0) * a[i].X() + x(1) * a[i].Y() + x(2) * a[i].Z() + c[i];
+		    if (hd > f) f = hd;
+		    if (hd > fmin) break;
+		  }
+
+		if (f < fmin)
+		  {
+		    fmin = f;
+		    pmin = x;
+		  }
+	      }
+          }
+
+  p = Point3d (pmin(0), pmin(1), pmin(2));
+  (*testout) << "fmin = " << fmin << endl;
+  return (fmin < -1e-3 * hmax);
+}
+
+} // namespace netgen
+#endif // NETGEN_FINDIP2_HPP

netgen/include/meshing/geomsearch.hpp

@@ -0,0 +1,69 @@
+#ifndef NETGEN_GEOMSEARCH_HPP
+#define NETGEN_GEOMSEARCH_HPP
+
+/**************************************************************************/
+/* File:   geomsearch.hh                                                  */
+/* Author: Johannes Gerstmayr                                             */
+/* Date:   19. Nov. 97                                                    */
+/**************************************************************************/
+
+#include "meshtype.hpp"
+
+namespace netgen
+{
+
+class FrontPoint3;
+class FrontFace;
+class MiniElement2d;
+
+  /// class for quick access of 3D-elements; class cannot delete elements, but only append
+class GeomSearch3d
+{
+
+public:
+  ///
+  GeomSearch3d();
+  ///
+  virtual ~GeomSearch3d();
+
+  ///
+  void Init (Array <FrontPoint3,PointIndex> *pointsi, NgArray <FrontFace> *facesi);
+
+  ///get elements max extension
+  void ElemMaxExt(Point3d& minp, Point3d& maxp, const MiniElement2d& elem);
+  
+  ///get minimum coordinates of two points ->p2
+  void MinCoords(const Point3d& p1, Point3d& p2);
+
+  ///get minimum coordinates of two points ->p2
+  void MaxCoords(const Point3d& p1, Point3d& p2);
+
+  ///create a hashtable from an existing array of triangles
+  ///sizei = number of pieces in one direction
+  void Create();
+
+  ///add new element to Hashtable
+  void AddElem(const MiniElement2d& elem, INDEX elemnum);
+
+  ///GetLocal faces in sphere with radius xh and middlepoint p
+  void GetLocals(NgArray<MiniElement2d> & locfaces,  NgArray<INDEX> & findex,
+		 INDEX fstind, const Point3d& p0, double xh);
+
+private:
+  
+  NgArray <FrontFace> *faces; // Pointers to Arrays in Adfront
+  Array <FrontPoint3,PointIndex> *points;
+
+  NgArray <NgArray <int>*> hashtable;
+
+  Point3d minext; //extension of Hashdomain
+  Point3d maxext;
+  Point3d maxextreal;
+  Vec3d elemsize;  //size of one Hash-Element
+
+  threeint size; // size of Hashtable in each direction
+  int reset;
+  int hashcount;
+};
+} // namespace netgen
+#endif // NETGEN_GEOMSEARCH_HPP

netgen/include/meshing/global.hpp

@@ -0,0 +1,54 @@
+#ifndef NETGEN_GLOBAL_HPP
+#define NETGEN_GLOBAL_HPP
+
+
+/**************************************************************************/
+/* File:   global.hh                                                      */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   01. Okt. 95                                                    */
+/**************************************************************************/
+
+/*
+  global functions and variables
+*/
+
+#include <mydefs.hpp>
+
+namespace netgen
+{
+  using namespace ngcore;
+  ///
+  DLL_HEADER extern double GetTime ();
+  DLL_HEADER extern void ResetTime ();
+
+  ///
+  DLL_HEADER extern int testmode;
+
+  /// calling parameters
+  // extern Flags parameters;
+
+  // extern DLL_HEADER MeshingParameters mparam;
+
+  DLL_HEADER extern mutex tcl_todo_mutex;
+
+
+  class DebugParameters;
+  class Mesh;
+
+  DLL_HEADER extern string ngdir;
+  DLL_HEADER extern DebugParameters debugparam;
+  DLL_HEADER extern bool verbose;
+
+  DLL_HEADER extern int h_argc;
+  DLL_HEADER extern char ** h_argv;
+
+
+  DLL_HEADER extern weak_ptr<Mesh> global_mesh;
+  DLL_HEADER void SetGlobalMesh (shared_ptr<Mesh> m);
+
+  // global communicator for netgen (dummy if no MPI)
+  // extern DLL_HEADER NgMPI_Comm ng_comm;
+  
+} // namespace netgen
+
+#endif // NETGEN_GLOBAL_HPP

netgen/include/meshing/hpref_hex.hpp

@@ -0,0 +1,330 @@
+// SZ 
+
+// HP_HEX  ... no refinement
+int refhex_splitedges[][3] =
+  {
+      { 0, 0, 0 }
+  };
+HPREF_ELEMENT_TYPE refhex_newelstypes[] =
+  {
+    HP_HEX,
+    HP_NONE,
+  };
+int refhex_newels[][8] =
+  {
+    { 1, 2, 3, 4, 5, 6, 7, 8 }
+  };
+HPRef_Struct refhex =
+  {
+    HP_HEX,
+    refhex_splitedges, 
+    0, 0,
+    refhex_newelstypes, 
+    refhex_newels
+  };
+
+// HP_HEX_1F  ... face (1 - 4 - 3 -2) singular 
+int refhex_1f_0e_0v_splitedges[][3] =
+  {
+    { 1, 5, 9 },
+    { 2, 6, 10 },
+    { 3, 7, 11 },
+    { 4, 8, 12 }, 
+    { 0, 0, 0 }
+  };
+HPREF_ELEMENT_TYPE refhex_1f_0e_0v_newelstypes[] =
+  {
+    HP_HEX,
+    HP_HEX_1F_0E_0V,
+    HP_NONE,
+  };
+int  refhex_1f_0e_0v_newels[][8] =
+  {
+    { 9, 10, 11, 12, 5, 6, 7, 8 }, 
+    { 1, 2, 3, 4, 9, 10, 11, 12}  
+ }; 
+HPRef_Struct refhex_1f_0e_0v =
+  {
+    HP_HEX,
+    refhex_1f_0e_0v_splitedges, 
+    0, 0,
+    refhex_1f_0e_0v_newelstypes, 
+    refhex_1f_0e_0v_newels
+  };
+
+
+
+
+
+// HP_HEX_1FA_1FB  ... face (1 - 4 - 3 -2) and face (1-2-6-5) singular 
+int refhex_1fa_1fb_0e_0v_splitedges[][3] =
+  {
+    { 1, 5, 9 },
+    { 2, 6, 10 },
+    { 3, 7, 11 },
+    { 4, 8, 12 },
+    { 1, 4, 13 },
+    { 2, 3, 14 },  
+    { 6, 7, 15 }, 
+    { 5, 8, 16 }, 
+    { 0, 0, 0 }
+  };
+
+int refhex_1fa_1fb_0e_0v_splitfaces[][4] =
+  {
+    { 2, 3, 6, 17 },
+    { 1, 4, 5, 18 },
+    { 0, 0, 0, 0 },
+  };
+HPREF_ELEMENT_TYPE refhex_1fa_1fb_0e_0v_newelstypes[] =
+  {
+    HP_HEX,
+    HP_HEX_1F_0E_0V,
+    HP_HEX_1F_0E_0V, 
+    HP_HEX_1FA_1FB_0E_0V, 
+    HP_NONE,
+  };
+int  refhex_1fa_1fb_0e_0v_newels[][8] =
+  {
+    {18, 17, 11, 12, 16, 15, 7, 8}, 
+    {13, 14, 3, 4, 18, 17, 11, 12},
+    { 5, 6, 10, 9, 16, 15, 17, 18}, 
+    { 1, 2, 14, 13, 9, 10, 17, 18} 
+  }; 
+HPRef_Struct refhex_1fa_1fb_0e_0v =
+  {
+    HP_HEX,
+    refhex_1fa_1fb_0e_0v_splitedges, 
+    refhex_1fa_1fb_0e_0v_splitfaces, 0,
+    refhex_1fa_1fb_0e_0v_newelstypes, 
+    refhex_1fa_1fb_0e_0v_newels
+  };
+
+
+
+// Refine Dummies 
+  // HP_HEX_0E_1V
+  int refhex_0e_1v_splitedges[][3] =
+    {
+      { 0, 0, 0 }
+    };
+  HPREF_ELEMENT_TYPE refhex_0e_1v_newelstypes[] =
+    {
+      HP_TET_0E_1V,
+      HP_TET,
+      HP_TET,
+      HP_TET,
+      HP_TET,
+      HP_TET,
+      HP_NONE,
+    };
+  int refhex_0e_1v_newels[][8] =
+    {
+      { 1, 5, 2, 4 },
+      { 7, 3, 6, 8 },
+      { 2, 8, 5, 6 },
+      { 2, 8, 6, 3 },
+      { 2, 8, 3, 4 },
+      { 2, 8, 4, 5 },
+    };
+  HPRef_Struct refhex_0e_1v =
+    {
+      HP_HEX,
+      refhex_0e_1v_splitedges, 
+      0, 0,
+      refhex_0e_1v_newelstypes, 
+      refhex_0e_1v_newels
+    };
+
+
+
+// Refine Dummies 
+  // HP_HEX_1E_1V
+  int refhex_1e_1v_splitedges[][3] =
+    {
+      { 0, 0, 0 }
+    };
+  HPREF_ELEMENT_TYPE refhex_1e_1v_newelstypes[] =
+    {
+      HP_TET_1E_1VA,
+      HP_TET,
+      HP_TET_0E_1V,
+      HP_TET_0E_1V,
+      HP_TET_0E_1V,
+      HP_TET_0E_1V,
+      HP_NONE,
+    };
+  int refhex_1e_1v_newels[][8] =
+    {
+      // { 1, 5, 2, 4 }, 
+      { 1, 2, 4, 5 },
+      { 7, 3, 6, 8 },
+      { 2, 8, 5, 6 },
+      { 2, 8, 6, 3 },
+      { 2, 8, 3, 4 },
+      { 2, 8, 4, 5 },
+    };
+  HPRef_Struct refhex_1e_1v =
+    {
+      HP_HEX,
+      refhex_1e_1v_splitedges, 
+      0, 0,
+      refhex_1e_1v_newelstypes, 
+      refhex_1e_1v_newels
+    };
+
+
+// Refine Dummies 
+  // HP_HEX_3E_0V
+  int refhex_3e_0v_splitedges[][3] =
+    {
+      { 0, 0, 0 }
+    };
+  HPREF_ELEMENT_TYPE refhex_3e_0v_newelstypes[] =
+    {
+      HP_TET_1E_1VA,
+      HP_TET_1E_1VA,
+      HP_TET_1E_1VA,
+      HP_TET_0E_1V,
+      HP_TET,
+      HP_NONE,
+    };
+  int refhex_3e_0v_newels[][8] =
+    {
+      { 1, 2, 3, 6 },
+      { 1, 4, 8, 3 },
+      { 1, 5, 6, 8 },
+      { 1, 6, 3, 8 },
+      { 3, 8, 6, 7 },
+    };
+  HPRef_Struct refhex_3e_0v =
+    {
+      HP_HEX,
+      refhex_3e_0v_splitedges, 
+      0, 0,
+      refhex_3e_0v_newelstypes, 
+      refhex_3e_0v_newels
+    };
+
+
+
+// Refine Dummies 
+  // HP_HEX_1E_0V 
+  int refhex_1e_0v_splitedges[][3] =
+    {
+      { 0, 0, 0 }
+    };
+
+  HPREF_ELEMENT_TYPE refhex_1e_0v_newelstypes[] =
+    {
+      HP_PRISM_SINGEDGE,         // HP_PRISM_SINGEDGE_H1,
+      HP_PRISM,
+      HP_NONE,
+    };
+  int refhex_1e_0v_newels[][8] =
+    {
+      { 1, 4, 5, 2, 3, 6 },
+      { 5, 4, 8, 6, 3, 7 },
+    };
+  HPRef_Struct refhex_1e_0v =
+    {
+      HP_HEX,
+      refhex_1e_0v_splitedges, 
+      0, 0,
+      refhex_1e_0v_newelstypes, 
+      refhex_1e_0v_newels
+    };
+
+
+
+
+
+
+// HP_HEX  ... no refinement
+int refhex7_splitedges[][3] =
+  {
+      { 0, 0, 0 }
+  };
+HPREF_ELEMENT_TYPE refhex7_newelstypes[] =
+  {
+    HP_HEX7,
+    HP_NONE,
+  };
+int refhex7_newels[][8] =
+  {
+    { 1, 2, 3, 4, 5, 6, 7 }
+  };
+HPRef_Struct refhex7 =
+  {
+    HP_HEX7,
+    refhex7_splitedges, 
+    0, 0,
+    refhex7_newelstypes, 
+    refhex7_newels
+  };
+
+// HP_HEX_1FA  ... face (1 - 4 - 3 -2) singular 
+int refhex7_1fa_splitedges[][3] =
+  {
+    { 1, 5, 8 },
+    { 2, 6, 9 },
+    { 3, 7, 10 },
+    { 4, 7, 11 }, 
+    { 0, 0, 0 }
+  };
+HPREF_ELEMENT_TYPE refhex7_1fa_newelstypes[] =
+  {
+    HP_HEX_1F_0E_0V,
+    HP_HEX7,
+    HP_NONE,
+  };
+int  refhex7_1fa_newels[][8] =
+  {
+    { 1, 2, 3, 4, 8, 9, 10, 11 },
+    { 8, 9, 10, 11, 5, 6, 7 }
+ }; 
+HPRef_Struct refhex7_1fa =
+  {
+    HP_HEX7,
+    refhex7_1fa_splitedges, 
+    0, 0,
+    refhex7_1fa_newelstypes, 
+    refhex7_1fa_newels
+  };
+
+
+
+
+// HP_HEX_1FB  ... face (5,6,7) singular 
+int refhex7_1fb_splitedges[][3] =
+  {
+    { 5, 1, 8 },
+    { 6, 2, 9 },
+    { 7, 3, 10 },
+    { 7, 4, 11 }, 
+    { 0, 0, 0 }
+  };
+HPREF_ELEMENT_TYPE refhex7_1fb_newelstypes[] =
+  {
+    HP_HEX,
+    HP_HEX7_1FB,
+    HP_NONE,
+  };
+int  refhex7_1fb_newels[][8] =
+  {
+    { 1, 2, 3, 4, 8, 9, 10, 11 },
+    { 8, 9, 10, 11, 5, 6, 7 }
+ }; 
+HPRef_Struct refhex7_1fb =
+  {
+    HP_HEX7,
+    refhex7_1fb_splitedges, 
+    0, 0,
+    refhex7_1fb_newelstypes, 
+    refhex7_1fb_newels
+  };
+
+
+
+
+