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

netgen/include/meshing/meshfunc.hpp

@@ -0,0 +1,47 @@
+#ifndef FILE_MESHFUNC
+#define FILE_MESHFUNC
+
+/**************************************************************************/
+/* File:   meshfunc.hpp                                                   */
+/* Author: Johannes Gerstmayr, Joachim Schoeberl                          */
+/* Date:   26. Jan. 98                                                    */
+/**************************************************************************/
+
+#include <mydefs.hpp>
+#include "meshing3.hpp"
+#include "meshtype.hpp"
+
+namespace netgen
+{
+/*
+  Functions for mesh-generations strategies
+ */
+
+class Mesh;
+// class CSGeometry;
+
+/// Build tet-mesh
+DLL_HEADER MESHING3_RESULT MeshVolume (const MeshingParameters & mp, Mesh& mesh3d);
+
+/// Build mixed-element mesh
+// MESHING3_RESULT MeshMixedVolume (MeshingParameters & mp, Mesh& mesh3d);
+
+/// Optimize tet-mesh
+DLL_HEADER MESHING3_RESULT OptimizeVolume (const MeshingParameters & mp, Mesh& mesh3d);
+//			       const CSGeometry * geometry = NULL);
+
+DLL_HEADER void RemoveIllegalElements (Mesh & mesh3d, int domain = 0);
+DLL_HEADER void ConformToFreeSegments (Mesh & mesh3d, int domain);
+
+
+enum MESHING_STEP { 
+  MESHCONST_ANALYSE = 1,
+  MESHCONST_MESHEDGES = 2,
+  MESHCONST_MESHSURFACE = 3,
+  MESHCONST_OPTSURFACE = 4,
+  MESHCONST_MESHVOLUME = 5,
+  MESHCONST_OPTVOLUME = 6
+};
+} // namespace netgen
+
+#endif

netgen/include/meshing/meshing.hpp

@@ -0,0 +1,63 @@
+#ifndef FILE_MESHING
+#define FILE_MESHING
+
+#include "../include/myadt.hpp"
+#include "../include/gprim.hpp"
+#include "../include/linalg.hpp"
+#include "../include/opti.hpp"
+
+
+namespace netgen
+{
+  // extern int printmessage_importance;
+
+  // class CSGeometry;
+  using namespace std;
+  class NetgenGeometry;
+}
+  
+  
+// #include "msghandler.hpp"
+// #include "meshtype.hpp"
+// #include "localh.hpp"
+// #include "topology.hpp"
+// #include "meshclass.hpp"
+// #include "global.hpp"
+
+#include "meshtool.hpp"
+
+#include "ruler2.hpp"
+#include "adfront2.hpp"
+
+
+#include "meshing2.hpp"
+#include "improve2.hpp"
+
+
+#include "geomsearch.hpp"
+#include "adfront3.hpp"
+#include "ruler3.hpp"
+
+#include "findip.hpp"
+#include "findip2.hpp"
+
+#include "meshing3.hpp"
+#include "improve3.hpp"
+
+#include "curvedelems.hpp"
+#include "clusters.hpp"
+#include "meshfunc.hpp"
+
+#include "bisect.hpp"
+#include "hprefinement.hpp"
+
+#include "specials.hpp"
+#include "validate.hpp"
+#include "basegeom.hpp"
+#include "surfacegeom.hpp"
+
+#include "paralleltop.hpp"
+
+
+
+#endif

netgen/include/meshing/meshing2.hpp

@@ -0,0 +1,163 @@
+#ifndef NETGEN_MESHING2_HPP
+#define NETGEN_MESHING2_HPP
+
+/**************************************************************************/
+/* File:   meshing2.hpp                                                   */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   01. Okt. 95                                                    */
+/**************************************************************************/
+
+
+#include "adfront2.hpp"
+#include "ruler2.hpp"
+#include "basegeom.hpp"
+
+namespace netgen
+{
+
+
+enum MESHING2_RESULT
+{
+  MESHING2_OK = 0,
+  MESHING2_GIVEUP = 1
+};
+
+
+/*
+   
+The basis class for 2D mesh generation. 
+Has the method GenerateMesh
+
+For surface mesh generation, or non-Euklidean meshing,
+derive from Meshing2, and replace transformation.
+
+*/
+
+class Meshing2
+{
+  /// the current advancing front
+  AdFront2 adfront;
+  /// rules for mesh generation
+  Array<unique_ptr<netrule>> rules;
+  /// statistics
+  NgArray<int> ruleused, canuse, foundmap;
+  /// 
+  Box<3> boundingbox;
+  ///
+  double starttime;
+  ///
+  double maxarea;
+
+  Vec3d ex, ey, ez;
+  Point<3> p1, p2;
+
+  const NetgenGeometry& geo;
+
+public:
+  ///
+  DLL_HEADER Meshing2 (const NetgenGeometry& geo,
+                       const MeshingParameters & mp,
+                       const Box<3> & aboundingbox);
+
+  ///
+  DLL_HEADER virtual ~Meshing2 ();
+
+  /// Load rules, either from file, or compiled rules
+  void LoadRules (const char * filename, bool quad);
+
+  /// 
+  DLL_HEADER MESHING2_RESULT GenerateMesh (Mesh & mesh, const MeshingParameters & mp, double gh, int facenr, int layer=1);
+
+  DLL_HEADER void Delaunay (Mesh & mesh, int domainnr, const MeshingParameters & mp);
+  DLL_HEADER void BlockFillLocalH (Mesh & mesh, const MeshingParameters & mp);
+
+
+  ///
+  DLL_HEADER int AddPoint (const Point3d & p, PointIndex globind, MultiPointGeomInfo * mgi = NULL,
+		 bool pointonsurface = true);
+  DLL_HEADER PointIndex GetGlobalIndex(int pi) const;
+
+  ///
+  DLL_HEADER void AddBoundaryElement (INDEX i1, INDEX i2,
+			   const PointGeomInfo & gi1, const PointGeomInfo & gi2);
+  
+  ///
+  void SetStartTime (double astarttime);
+
+  ///
+  void SetMaxArea (double amaxarea);
+
+protected:
+  ///
+  virtual void StartMesh ();
+  ///
+  virtual void EndMesh ();
+  ///
+  virtual double CalcLocalH (const Point<3> & p, double gh) const;
+
+  ///
+  virtual void DefineTransformation (const Point<3> & p1, const Point<3> & p2,
+				     const PointGeomInfo * geominfo1,
+				     const PointGeomInfo * geominfo2);
+  ///
+  virtual void TransformToPlain (const Point<3> & locpoint, const MultiPointGeomInfo &  geominfo,
+				 Point<2> & plainpoint, double h, int & zone);
+  /// return 0 .. ok
+  /// return >0 .. cannot transform point to true surface
+  virtual int TransformFromPlain (const Point<2>& plainpoint,
+				  Point<3> & locpoint, 
+				  PointGeomInfo & geominfo, 
+				  double h);
+  
+  /// projects to surface
+  /// return 0 .. ok
+  virtual int BelongsToActiveChart (const Point3d & p, 
+				    const PointGeomInfo & gi);
+
+  /// computes geoinfo data for line with respect to
+  /// selected chart
+  virtual int ComputePointGeomInfo (const Point3d & p, 
+				    PointGeomInfo & gi);
+
+  /// Tries to select unique geominfo on active chart
+  /// return 0: success
+  /// return 1: failed
+  virtual int ChooseChartPointGeomInfo (const MultiPointGeomInfo & mpgi, 
+					PointGeomInfo & pgi);
+
+
+
+  /*
+    tests, whether endpoint (= 1 or 2) of line segment p1-p2
+    is inside of the selected chart. The endpoint must be on the
+    chart
+   */
+  virtual int IsLineVertexOnChart (const Point3d & p1, const Point3d & p2,
+				   int endpoint, const PointGeomInfo & geominfo);
+
+  /*
+    get (projected) boundary of current chart
+   */
+  virtual void GetChartBoundary (NgArray<Point<2>> & points, 
+				 NgArray<Point<3>> & points3d,
+				 NgArray<INDEX_2> & lines, double p) const;
+
+  virtual double Area () const;
+
+
+/** Applies 2D rules.
+ Tests all 2D rules */
+  int ApplyRules (NgArray<Point<2>> & lpoints, 
+		  NgArray<int> & legalpoints,
+		  int maxlegalpoint,
+		  NgArray<INDEX_2> & llines,
+		  int maxlegelline,
+		  NgArray<Element2d> & elements, NgArray<INDEX> & dellines,
+		  int tolerance,
+		  const MeshingParameters & mp);
+  
+
+};
+} // namespace netgen
+
+#endif // NETGEN_MESHING2_HPP

netgen/include/meshing/meshing3.hpp

@@ -0,0 +1,123 @@
+#ifndef FILE_MESHING3
+#define FILE_MESHING3
+
+#include "meshclass.hpp"
+#include "adfront3.hpp"
+#include "ruler3.hpp"
+
+namespace netgen
+{
+
+enum MESHING3_RESULT
+{
+  MESHING3_OK = 0,
+  MESHING3_GIVEUP = 1,
+  MESHING3_NEGVOL = 2,
+  MESHING3_OUTERSTEPSEXCEEDED = 3,
+  MESHING3_TERMINATE = 4,
+  MESHING3_BADSURFACEMESH = 5
+};
+
+
+/// 3d volume mesh generation
+class Meshing3
+{
+  /// current state of front
+  unique_ptr<AdFront3> adfront;
+  /// 3d generation rules
+  Array<unique_ptr<vnetrule>> rules;
+  /// counts how often a rule is used
+  Array<int> ruleused, canuse, foundmap;
+  /// describes, why a rule is not applied
+  Array<string> problems;
+  /// tolerance criterion
+  double tolfak;
+public:
+  /// 
+  Meshing3 (const string & rulefilename); 
+  /// 
+  Meshing3 (const char ** rulep);
+  ///
+  virtual ~Meshing3 ();
+  
+  ///
+  void LoadRules (const char * filename, const char ** prules);
+  ///
+  MESHING3_RESULT GenerateMesh (Mesh & mesh, const MeshingParameters & mp);
+  
+  ///
+  int ApplyRules (Array<Point3d, PointIndex> & lpoints,
+                  Array<int, PointIndex> & allowpoint,
+		  Array<MiniElement2d> & lfaces, INDEX lfacesplit,
+		  INDEX_2_HASHTABLE<int> & connectedpairs,
+		  NgArray<Element> & elements,
+		  NgArray<INDEX> & delfaces, int tolerance, 
+		  double sloppy, int rotind1,
+		  float & retminerr);
+  
+  ///
+  PointIndex AddPoint (const Point3d & p, PointIndex globind);
+  ///
+  void AddBoundaryElement (const Element2d & elem);
+  ///
+  void AddBoundaryElement (const MiniElement2d & elem);
+  ///
+  int AddConnectedPair (const INDEX_2 & pair);
+  
+  ///
+  void BlockFill (Mesh & mesh, double gh);
+  ///
+  void BlockFillLocalH (Mesh & mesh, const MeshingParameters & mp);
+
+  /// uses points of adfront, and puts new elements into mesh
+  void Delaunay (Mesh & mesh, int domainnr, const MeshingParameters & mp);
+  ///
+  friend class PlotVolMesh;
+  ///
+  friend void TestRules ();
+};
+
+
+
+
+/// status of mesh generation
+class MeshingStat3d
+{
+public:
+  ///
+  MeshingStat3d ();
+  ///
+  int cntsucc;
+  ///
+  int cnttrials;
+  ///
+  int cntelem;
+  ///
+  int nff;
+  ///
+  int qualclass;
+  ///
+  double vol0;
+  ///
+  double vol;
+  ///
+  double h;
+  ///
+  int problemindex;
+};
+
+
+
+
+
+/*
+template <typename POINTArray, typename FACEArray>
+extern int FindInnerPoint (POINTArray & grouppoints,
+			   FACEArray & groupfaces,
+			   Point3d & p);
+
+*/
+
+} // namespace netgen
+
+#endif

netgen/include/meshing/meshtool.hpp

@@ -0,0 +1,90 @@
+#ifndef NETGEN_MESHTOOL_HPP
+#define NETGEN_MESHTOOL_HPP
+
+// #include "../general/ngarray.hpp"
+// #include "../gprim/geom3d.hpp"
+// #include "../gprim/geomobjects.hpp"
+
+#include "meshtype.hpp"
+#include "meshclass.hpp"
+
+namespace netgen {
+///
+extern void MeshQuality2d (const Mesh & mesh);
+
+///
+extern void MeshQuality3d (const Mesh & mesh,
+			   NgArray<int> * inclass = NULL);
+
+///
+extern void SaveEdges (const Mesh & mesh, 
+		       const char * geomfile, 
+		       double h, 
+		       char * filename);
+
+///
+extern void SaveSurfaceMesh (const Mesh & mesh,
+			     double h,
+			     char * filename);
+/*
+///
+extern void Save2DMesh (
+         const Mesh & mesh2d,
+	 const NgArray<class SplineSegment*> * splines,
+         ostream & outfile);
+*/
+
+class Surface;
+///
+extern void SaveVolumeMesh (
+         const NgArray<Point3d> & points,
+         const NgArray<Element> & elements,
+         const NgArray<Element> & volelements,
+         const NgArray<Surface*> & surfaces,
+         char * filename);
+
+///
+void SaveVolumeMesh (const Mesh & mesh, 
+		     const class NetgenGeometry & geometry,
+		     char * filename);
+
+///
+extern int CheckCode ();
+
+
+///
+extern double CalcTetBadness (const Point3d & p1, const Point3d & p2,
+			      const Point3d & p3, const Point3d & p4, 
+			      double h,
+			      const MeshingParameters & mp);
+///
+extern double CalcTetBadnessGrad (const Point3d & p1, const Point3d & p2,
+				  const Point3d & p3, const Point3d & p4, 
+				  double h, int pi,
+				  Vec<3> & grad,
+				  const MeshingParameters & mp);
+
+
+/** Calculates volume of an element.
+  The volume of the tetrahedron el is computed
+ */
+// extern double CalcVolume (const NgArray<Point3d> & points,
+//        const Element & el);  
+
+/** The total volume of all elements is computed.
+  This function calculates the volume of the mesh */
+extern double CalcVolume (const NgArray<Point3d> & points, 
+	const NgArray<Element> & elements);
+
+///
+extern int CheckSurfaceMesh (const Mesh & mesh);
+
+///
+extern int CheckSurfaceMesh2 (const Mesh & mesh);
+///
+extern int CheckMesh3D (const Mesh & mesh);
+///
+extern void RemoveProblem (Mesh & mesh, int domainnr);
+
+} // namespace netgen
+#endif // NETGEN_MESHTOOL_HPP