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

netgen/include/meshing/adfront3.hpp

@@ -0,0 +1,332 @@
+#ifndef FILE_ADFRONT3
+#define FILE_ADFRONT3
+
+/**************************************************************************/
+/* File:   adfront3.hh                                                    */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   01. Okt. 95                                                    */
+/**************************************************************************/
+
+/*
+  Advancing front class for volume meshing
+*/
+
+#include <gprim/geomobjects.hpp>
+#include <gprim/adtree.hpp>
+#include "meshtype.hpp"
+#include "geomsearch.hpp"
+
+namespace netgen
+{
+
+/// Point in advancing front
+class FrontPoint3
+{
+  /// coordinates
+  Point<3> p;           
+  /// global node index
+  PointIndex globalindex;   
+  /// number of faces connected to point 
+  int nfacetopoint;    
+  /// distance to original boundary
+  int frontnr;
+  /// 
+  PointIndex cluster;
+public:
+  ///
+  FrontPoint3 ();
+  ///
+  FrontPoint3 (const Point<3> & ap, PointIndex agi);
+  
+  ///
+  const Point<3> & P () const
+  { return p; }
+  ///
+  PointIndex GlobalIndex () const
+  { return globalindex; }
+  
+  ///
+  void AddFace ()
+  { nfacetopoint++; }
+
+  /// if last face is removed, then point is invalidated
+  void RemoveFace()
+  { 
+    nfacetopoint--;
+    if (nfacetopoint == 0) nfacetopoint = -1;
+  }
+  
+  ///
+  bool Valid () const
+  { return nfacetopoint >= 0; }
+
+  ///
+  void DecFrontNr (int afrontnr)
+  {
+    if (frontnr > afrontnr) frontnr = afrontnr;
+  }
+  
+  ///
+  int FrontNr () const
+  { return frontnr; }
+
+  ///
+  friend class AdFront3;
+};
+
+
+
+class MiniElement2d
+{
+protected:
+  int np;
+  PointIndex pnum[4]; // can be global or local nums
+  bool deleted;
+public:
+  MiniElement2d ()
+  { np = 3; deleted = 0; }
+  MiniElement2d (int anp)
+  { np = anp; deleted = 0; }
+
+  int GetNP() const { return np; }
+  PointIndex & operator[] (int i) { return pnum[i]; }
+  const PointIndex operator[] (int i) const { return pnum[i]; }
+
+  const PointIndex PNum (int i) const { return pnum[i-1]; }
+  PointIndex & PNum (int i) { return pnum[i-1]; }
+  const PointIndex PNumMod (int i) const { return pnum[(i-1)%np]; }
+  auto PNums() { return FlatArray<PointIndex> (np, &pnum[0]); }
+  auto PNums() const { return FlatArray<const PointIndex> (np, &pnum[0]); }
+  void Delete () { deleted = true; for (PointIndex & p : pnum) p.Invalidate(); }
+  bool IsDeleted () const { return deleted; }
+};
+
+
+inline ostream & operator<<(ostream  & s, const MiniElement2d & el)
+{
+  s << "np = " << el.GetNP();
+  for (int j = 0; j < el.GetNP(); j++)
+    s << " " << el[j];
+  return s;
+}
+
+
+
+
+/// Face in advancing front
+class FrontFace
+{
+private:
+  ///
+  MiniElement2d f;
+  ///
+  int qualclass;
+  ///
+  char oldfront;
+  ///
+  int hashvalue;
+  ///
+  PointIndex cluster;
+  
+public:
+  ///
+  FrontFace ();
+  ///
+  FrontFace (const MiniElement2d & af);
+  ///
+  const MiniElement2d & Face () const
+  { return f; }
+  
+  ///
+  int QualClass () const
+  { return qualclass; }
+
+  ///
+  void IncrementQualClass ()
+  { qualclass++; }
+
+  ///
+  void ResetQualClass ()
+  {
+    if (qualclass > 1)
+      {
+	qualclass = 1;
+	oldfront = 0;
+      }
+  }
+  
+  ///
+  bool Valid () const
+  { return !f.IsDeleted(); }
+
+  ///
+  void Invalidate ();
+
+  ///
+  int HashValue() const 
+  { return hashvalue; }
+
+  ///
+  void SetHashValue(int hv) 
+  { hashvalue = hv; }
+
+  ///
+  friend class AdFront3;
+
+  PointIndex Cluster () const { return cluster; }
+};  
+
+
+
+
+/// Advancing front, 3D.
+class AdFront3
+{
+  ///
+  // NgArray<FrontPoint3, PointIndex::BASE, PointIndex> points;
+  Array<FrontPoint3, PointIndex> points
+;
+  ///
+  NgArray<FrontFace> faces;
+  ///
+  Array<PointIndex> delpointl;
+  
+  /// which points are connected to pi ?
+  // TABLE<PointIndex, PointIndex::BASE> * connectedpairs;
+  unique_ptr<DynamicTable<PointIndex, PointIndex>> connectedpairs;
+  
+  /// number of total front faces;
+  int nff;
+  /// number of quads in front
+  int nff4; 
+  
+  ///
+  double vol;
+  
+  ///
+  GeomSearch3d hashtable;
+  
+  /// 
+  int hashon;
+
+  ///
+  int hashcreated;
+  
+  /// counter for rebuilding internal tables
+  int rebuildcounter;
+  /// last base element
+  int lasti;
+  /// minimal selection-value of baseelements
+  int minval;
+  Array<PointIndex, PointIndex> invpindex;
+  Array<char, PointIndex> pingroup;
+  
+  ///
+  class BoxTree<3> * facetree;
+public:
+  
+  ///
+  AdFront3 ();
+  ///
+  ~AdFront3 ();
+  ///
+  void GetPoints (NgArray<Point<3> > & apoints) const;
+  ///
+  int GetNP() const 
+  { return points.Size(); }
+  ///
+  const Point<3> & GetPoint (PointIndex pi) const
+  { return points[pi].P(); }
+  ///
+  int GetNF() const
+  { return nff; }
+  /// 1-based
+  const MiniElement2d & GetFace (int i) const
+  { return faces[i-1].Face(); }
+  const auto & Faces() const { return faces; }
+  ///
+  void Print () const;
+  ///
+  bool Empty () const
+  { return nff == 0; }
+  ///
+  bool Empty (int elnp) const
+  {
+    if (elnp == 4)
+      return (nff4 == 0);
+    return (nff - nff4 == 0);
+  }
+  ///
+  int SelectBaseElement ();
+
+  ///
+  void CreateTrees ();
+
+  ///
+  void GetIntersectingFaces (const Point<3> & pmin, const Point<3> & pmax, 
+			     NgArray<int> & ifaces) const;
+
+  bool PointInsideGroup(const Array<PointIndex, PointIndex> &grouppindex,
+                        const Array<MiniElement2d>& groupfaces) const;
+
+  ///
+  void GetFaceBoundingBox (int i, Box3d & box) const;
+
+  ///
+  int GetLocals (int baseelement,
+		 Array<Point3d, PointIndex> & locpoints,
+                 Array<MiniElement2d> & locfaces,   // local index
+                 Array<PointIndex, PointIndex> & pindex,
+                 Array<INDEX> & findex,
+		 INDEX_2_HASHTABLE<int> & connectedpairs,
+                 float xh,
+		 float relh,
+		 INDEX& facesplit);
+  
+  ///
+  void GetGroup (int fi,
+                 Array<MeshPoint, PointIndex> & grouppoints,
+                 Array<MiniElement2d> & groupelements,
+                 Array<PointIndex, PointIndex> & pindex,
+                 Array<INDEX> & findex);
+
+  ///
+  void DeleteFace (INDEX fi);
+  ///
+  PointIndex AddPoint (const Point<3> & p, PointIndex globind);
+  ///
+  INDEX AddFace (const MiniElement2d & e);
+  ///
+  INDEX AddConnectedPair (PointIndices<2> pair);
+  ///
+  void IncrementClass (INDEX fi)
+  { faces[fi-1].IncrementQualClass(); }
+
+  ///
+  void ResetClass (INDEX fi)
+  { faces[fi-1].ResetQualClass(); }
+
+  ///
+  void SetStartFront (int baseelnp = 0);
+
+  /// is Point p inside Surface ?
+  bool Inside (const Point<3> & p) const;
+  /// both points on same side ?
+  int SameSide (const Point<3> & lp1, const Point<3> & lp2, 
+		const NgArray<int> * testfaces = NULL) const;
+
+
+  ///
+  PointIndex GetGlobalIndex (PointIndex pi) const
+  { return points[pi].GlobalIndex(); }
+  ///
+  double Volume () const
+  { return vol; }
+
+
+private:
+  void RebuildInternalTables();
+};
+
+} // namespace netgen
+#endif

netgen/include/meshing/basegeom.hpp

@@ -0,0 +1,370 @@
+#ifndef FILE_BASEGEOM
+#define FILE_BASEGEOM
+
+/**************************************************************************/
+/* File:   basegeom.hpp                                                   */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   23. Aug. 09                                                    */
+/**************************************************************************/
+
+#include <gprim/geomobjects.hpp>
+#include <gprim/transform3d.hpp>
+
+#include "meshtype.hpp"
+#include "meshclass.hpp"
+
+struct Tcl_Interp;
+
+namespace netgen
+{
+  class Refinement;
+
+  struct ShapeProperties
+  {
+    optional<string> name;
+    optional<Vec<4>> col;
+    double maxh = 1e99;
+    double hpref = 0;  // number of hp refinement levels (will be multiplied by factor later)
+    int layer = 1;
+    optional<bool> quad_dominated;
+    optional<Array<double>> partition;
+    void Merge(const ShapeProperties & prop2)
+    {
+      if (!name && prop2.name) name = prop2.name;
+      if (!col && prop2.col) col = prop2.col;
+      if (!partition && prop2.partition) partition = prop2.partition;
+      maxh = min2(maxh, prop2.maxh);
+      hpref = max2(hpref, prop2.hpref);
+      if(!quad_dominated.has_value()) quad_dominated = prop2.quad_dominated;
+      layer = max(layer, prop2.layer);
+    }
+
+    string GetName() const { return name ? *name : "default"; }
+    Vec<4> GetColor() { return col ? *col : Vec<4>{0., 1., 0., 1.}; }
+
+    void DoArchive(Archive& ar);
+  };
+
+  class GeometryShape;
+
+  struct ShapeIdentification
+  {
+    GeometryShape * from;
+    GeometryShape * to;
+    optional<Transformation<3>> trafo;
+    Identifications::ID_TYPE type;
+    string name = "";
+  };
+
+  class DLL_HEADER GeometryShape
+  {
+  public:
+    int nr = -1;
+    int layer = 1;
+    ShapeProperties properties;
+    Array<ShapeIdentification> identifications;
+    GeometryShape * primary;
+    optional<Transformation<3>> primary_to_me = nullopt;
+
+    virtual ~GeometryShape() {}
+    virtual bool IsMappedShape( const GeometryShape & other, const Transformation<3> & trafo, double tolerance ) const;
+  };
+
+
+  class DLL_HEADER GeometryVertex : public GeometryShape
+  {
+  public:
+    virtual Point<3> GetPoint() const = 0;
+    virtual bool IsMappedShape( const GeometryShape & other, const Transformation<3> & trafo, double tolerance ) const override;
+  };
+
+  class DLL_HEADER GeometryEdge : public GeometryShape
+  {
+  protected:
+      GeometryVertex *start, *end;
+  public:
+    // Neighboring domains in 2d
+    // In 3d unused, EXCEPT for free floating edges in a domain,
+    // then both are pointing to the containing domain
+    int domin=-1, domout=-1;
+
+    GeometryEdge( GeometryVertex &start_, GeometryVertex &end_ )
+        : start(&start_), end(&end_)
+    {}
+
+    virtual const GeometryVertex& GetStartVertex() const { return *start; }
+    virtual const GeometryVertex& GetEndVertex() const { return *end; }
+    virtual GeometryVertex& GetStartVertex() { return *start; }
+    virtual GeometryVertex& GetEndVertex() { return *end; }
+    virtual double GetLength() const = 0;
+    virtual Point<3> GetCenter() const = 0;
+    virtual Point<3> GetPoint(double t) const = 0;
+    // Calculate parameter step respecting edges sag value
+    virtual double CalcStep(double t, double sag) const = 0;
+    virtual bool IsDegenerated(double tol = 1e-10) const {
+      return GetLength() < tol;
+    }
+    virtual void ProjectPoint(Point<3>& p, EdgePointGeomInfo* gi) const = 0;
+    virtual void PointBetween(const Point<3>& p1,
+                              const Point<3>& p2,
+                              double secpoint,
+                              const EdgePointGeomInfo& gi1,
+                              const EdgePointGeomInfo& gi2,
+                              Point<3>& newp,
+                              EdgePointGeomInfo& newgi) const
+    {
+      newp = p1 + secpoint * (p2-p1);
+      newgi = gi1;
+      ProjectPoint(newp, &newgi);
+    }
+    virtual Vec<3> GetTangent(double t) const = 0;
+    virtual bool IsMappedShape( const GeometryShape & other, const Transformation<3> & trafo, double tolerance ) const override;
+    virtual void Divide(const MeshingParameters & mparam, const Mesh & mesh, Array<Point<3>> & points, Array<double> & params);
+  };
+
+  class DLL_HEADER GeometryFace : public GeometryShape
+  {
+  public:
+    Array<GeometryEdge*> edges;
+    int domin=-1, domout=-1;
+
+    virtual Point<3> GetCenter() const = 0;
+    virtual size_t GetNBoundaries() const = 0;
+    virtual Array<Segment> GetBoundary(const Mesh& mesh) const = 0;
+
+    virtual PointGeomInfo Project(Point<3>& p) const = 0;
+    // Project point using geo info. Fast if point is close to
+    // parametrization in geo info.
+    virtual bool ProjectPointGI(Point<3>& p, PointGeomInfo& gi) const =0;
+    virtual bool CalcPointGeomInfo(const Point<3>& p, PointGeomInfo& gi) const
+    {
+      auto pnew = p;
+      gi = Project(pnew);
+      return (p-pnew).Length() < 1e-10 * GetBoundingBox().Diam() ;
+    }
+    virtual Point<3> GetPoint(const PointGeomInfo& gi) const = 0;
+    virtual void CalcEdgePointGI(const GeometryEdge& edge,
+                                 double t,
+                                 EdgePointGeomInfo& egi) const = 0;
+    virtual Box<3> GetBoundingBox() const = 0;
+
+    // Get curvature in point from local coordinates in PointGeomInfo
+    virtual double GetCurvature(const PointGeomInfo& gi) const = 0;
+
+    virtual void RestrictH(Mesh& mesh, const MeshingParameters& mparam) const = 0;
+    virtual Vec<3> GetNormal(const Point<3>& p, const PointGeomInfo* gi = nullptr) const = 0;
+
+    virtual void PointBetween(const Point<3>& p1,
+                              const Point<3>& p2,
+                              double secpoint,
+                              const PointGeomInfo& gi1,
+                              const PointGeomInfo& gi2,
+                              Point<3>& newp,
+                              PointGeomInfo& newgi) const
+    {
+      newp = p1 + secpoint * (p2-p1);
+      newgi.trignum = gi1.trignum;
+      /*
+      newgi.u = 0.5 * (gi1.u + gi1.u);
+      newgi.v = 0.5 * (gi1.v + gi2.v);
+      */
+      newgi.u = gi1.u + secpoint*(gi2.u - gi1.u);
+      newgi.v = gi1.v + secpoint*(gi2.v - gi1.v);
+      if(!ProjectPointGI(newp, newgi))
+        newgi = Project(newp);
+    }
+
+    virtual bool IsMappedShape( const GeometryShape & other, const Transformation<3> & trafo, double tolerance ) const override;
+    virtual bool IsConnectingCloseSurfaces() const;
+
+  protected:
+    void RestrictHTrig(Mesh& mesh,
+                       const PointGeomInfo& gi0,
+                       const PointGeomInfo& gi1,
+                       const PointGeomInfo& gi2,
+                       const MeshingParameters& mparam,
+                       int depth = 0, double h = 0.) const;
+  };
+
+  class DLL_HEADER GeometrySolid : public GeometryShape
+  {
+  public:
+    Array<GeometryEdge*> free_edges; // edges with no adjacent face
+  };
+
+  class DLL_HEADER NetgenGeometry
+  {
+    unique_ptr<Refinement> ref;
+  protected:
+    Array<unique_ptr<GeometryVertex>> vertices;
+    Array<unique_ptr<GeometryEdge>> edges;
+    Array<unique_ptr<GeometryFace>> faces;
+    Array<unique_ptr<GeometrySolid>> solids;
+    Array<std::pair<Point<3>, double>> restricted_h;
+    Box<3> bounding_box;
+    int dimension = 3;
+
+  public:
+
+    NetgenGeometry()
+    {
+      ref = make_unique<Refinement>(*this);
+    }
+    virtual ~NetgenGeometry () { ; }
+
+    size_t GetNVertices() const { return vertices.Size(); }
+    size_t GetNEdges() const { return edges.Size(); }
+    size_t GetNFaces() const { return faces.Size(); }
+    size_t GetNSolids() const { return solids.Size(); }
+
+    const GeometrySolid & GetSolid(int i) const { return *solids[i]; }
+    const GeometryFace & GetFace(int i) const { return *faces[i]; }
+    const GeometryEdge & GetEdge(int i) const { return *edges[i]; }
+    const GeometryVertex & GetVertex(int i) const { return *vertices[i]; }
+
+    auto Solids() const { return FlatArray{solids}; }
+    auto Faces() const { return FlatArray{faces}; }
+    auto Edges() const { return FlatArray{edges}; }
+    auto Vertices() const { return FlatArray{vertices}; }
+
+    virtual Array<const GeometryVertex*> GetFaceVertices(const GeometryFace& face) const { return Array<const GeometryVertex*>{}; }
+
+    void Clear();
+
+    virtual int GenerateMesh (shared_ptr<Mesh> & mesh, MeshingParameters & mparam);
+
+    void RestrictH(const Point<3>& pnt, double maxh)
+    {
+      restricted_h.Append({pnt, maxh});
+    }
+
+    virtual const Refinement & GetRefinement () const
+    {
+      return *ref;
+    }
+
+    virtual void DoArchive(Archive&)
+  { throw NgException("DoArchive not implemented for " + Demangle(typeid(*this).name())); }
+
+    virtual Mesh::GEOM_TYPE GetGeomType() const { return Mesh::NO_GEOM; }
+    virtual void ProcessIdentifications();
+    virtual void Analyse(Mesh& mesh,
+                         const MeshingParameters& mparam) const;
+    virtual void FindEdges(Mesh& mesh, const MeshingParameters& mparam) const;
+    virtual void MeshSurface(Mesh& mesh, const MeshingParameters& mparam) const;
+    virtual bool MeshFace(Mesh& mesh, const MeshingParameters& mparam,
+                     int nr, FlatArray<int, PointIndex> glob2loc) const;
+    virtual void MapSurfaceMesh( Mesh & mesh, const GeometryFace & dst, std::map<tuple<PointIndex, int>, PointIndex> & mapto) const;
+    virtual void OptimizeSurface(Mesh& mesh, const MeshingParameters& mparam) const;
+
+    virtual void FinalizeMesh(Mesh& mesh) const;
+
+    virtual PointGeomInfo ProjectPoint (int surfind, Point<3> & p) const
+    {
+      if(surfind <= faces.Size() && surfind > 0)
+        return faces[surfind-1]->Project(p);
+      return PointGeomInfo();
+    }
+
+  virtual void ProjectPointEdge (int surfind, int surfind2, Point<3> & p, EdgePointGeomInfo* gi = nullptr) const
+  {
+    if(gi && gi->edgenr < edges.Size() && gi->edgenr >= 0)
+      edges[gi->edgenr]->ProjectPoint(p, gi);
+  }
+
+    virtual bool CalcPointGeomInfo(int surfind, PointGeomInfo& gi, const Point<3> & p3) const
+    {
+      return faces[surfind-1]->CalcPointGeomInfo(p3, gi);
+    }
+    virtual bool ProjectPointGI (int surfind, Point<3> & p, PointGeomInfo & gi) const
+    {
+      if(surfind > 0 && surfind <= faces.Size())
+        return faces[surfind-1]->ProjectPointGI(p, gi);
+      return false;
+    }
+
+    virtual Vec<3> GetNormal(int surfind, const Point<3> & p, const PointGeomInfo* gi = nullptr) const
+    {
+      if(surfind > 0 && surfind <= faces.Size())
+        return faces[surfind-1]->GetNormal(p, gi);
+      else
+        return {0., 0., 0.};
+    }
+
+    virtual void PointBetween (const Point<3> & p1,
+                               const Point<3> & p2, double secpoint,
+                               int surfi,
+                               const PointGeomInfo & gi1,
+                               const PointGeomInfo & gi2,
+                               Point<3> & newp,
+                               PointGeomInfo & newgi) const
+    {
+      if(faces.Size() >= surfi && surfi > 0)
+        {
+          faces[surfi-1]->PointBetween(p1, p2, secpoint, gi1, gi2, newp, newgi);
+          return;
+        }
+      newp = p1 + secpoint * (p2-p1);
+    }
+
+    virtual void PointBetweenEdge(const Point<3> & p1,
+                                  const Point<3> & p2, double secpoint,
+                                  int surfi1, int surfi2,
+                                  const EdgePointGeomInfo & ap1,
+                                  const EdgePointGeomInfo & ap2,
+                                  Point<3> & newp,
+                                  EdgePointGeomInfo & newgi) const
+    {
+      if(ap1.edgenr < edges.Size() && ap1.edgenr >= 0)
+        {
+          edges[ap1.edgenr]->PointBetween(p1, p2, secpoint,
+                                          ap1, ap2, newp, newgi);
+          return;
+        }
+      newp = p1+secpoint*(p2-p1);
+    }
+
+    virtual Vec<3> GetTangent(const Point<3> & p, int surfi1,
+                              int surfi2,
+                              const EdgePointGeomInfo & egi) const
+    {
+      throw Exception("Base geometry get tangent called");
+    }
+
+    virtual void Save (const filesystem::path & filename) const;
+    virtual void SaveToMeshFile (ostream & /* ost */) const { ; }
+  };
+
+
+
+
+
+  class DLL_HEADER GeometryRegister
+  {
+  public:
+    virtual ~GeometryRegister();
+    virtual NetgenGeometry * Load (const filesystem::path & filename) const = 0;
+    virtual NetgenGeometry * LoadFromMeshFile (istream & /* ist */, string) const { return NULL; }
+    virtual class VisualScene * GetVisualScene (const NetgenGeometry * /* geom */) const
+    { return NULL; }
+    virtual void SetParameters (Tcl_Interp * /* interp */) { ; }
+  };
+
+  class DLL_HEADER GeometryRegisterArray : public NgArray<GeometryRegister*>
+  {
+  public:
+    virtual ~GeometryRegisterArray()
+    {
+      for (int i = 0; i < Size(); i++)
+        delete (*this)[i];
+    }
+
+    virtual shared_ptr<NetgenGeometry> LoadFromMeshFile (istream & ist) const;
+  };
+
+  DLL_HEADER GeometryRegisterArray& GeometryRegister();
+}
+
+
+
+#endif