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

netgen/include/csg/polyhedra.hpp

@@ -0,0 +1,121 @@
+#ifndef FILE_POLYHEDRA
+#define FILE_POLYHEDRA
+
+
+/**************************************************************************/
+/* File:   polyhedra.hh                                                   */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   19. Mar. 2000                                                  */
+/**************************************************************************/
+
+namespace netgen
+{
+
+  /*
+
+  Polyhedral primitive
+  
+  */
+
+  class Polyhedra : public Primitive
+  {
+    class Face {
+    public:
+      int pnums[3];
+      int planenr;
+
+      int inputnr;
+
+      Box<3> bbox;
+      //    Point<3> center;
+      Vec<3> v1, v2;   // edges
+      Vec<3> w1, w2;   // pseudo-inverse
+      Vec<3> n;        // normal to face
+      Vec<3> nn;       // normed normal
+
+      Face () { ; }
+      Face (int pi1, int pi2, int pi3, 
+	    const NgArray<Point<3> > & points,
+	    int ainputnr);
+    };
+
+    NgArray<Point<3> > points;
+    NgArray<Face> faces;
+    NgArray<Plane*> planes;
+    Box<3> poly_bbox;
+
+    double eps_base1;
+
+  public:
+    Polyhedra ();
+    virtual ~Polyhedra () override;
+    static Primitive * CreateDefault ();
+
+    virtual INSOLID_TYPE BoxInSolid (const BoxSphere<3> & box) const override;
+    virtual INSOLID_TYPE PointInSolid (const Point<3> & p,
+				       double eps) const override;
+    virtual INSOLID_TYPE VecInSolidNew (const Point<3> & p,
+                                        const Vec<3> & v,
+                                        double eps, bool printing = false) const;
+    virtual INSOLID_TYPE VecInSolidOld (const Point<3> & p,
+				     const Vec<3> & v,
+				     double eps) const;
+    
+    virtual INSOLID_TYPE VecInSolid (const Point<3> & p,
+				     const Vec<3> & v,
+				     double eps) const override;
+
+    virtual INSOLID_TYPE VecInSolid2 (const Point<3> & p,
+				      const Vec<3> & v1,
+				      const Vec<3> & v2,
+				      double eps) const override;
+    
+    virtual INSOLID_TYPE VecInSolid3 (const Point<3> & p,
+				      const Vec<3> & v1,
+				      const Vec<3> & v2,
+				      double eps) const override;
+
+    virtual INSOLID_TYPE VecInSolid4 (const Point<3> & p,
+				      const Vec<3> & v,
+				      const Vec<3> & v2,
+				      const Vec<3> & m,
+				      double eps) const override;
+    
+    virtual void GetTangentialSurfaceIndices (const Point<3> & p, 
+					      NgArray<int> & surfind, double eps) const override;
+
+
+    virtual void GetTangentialVecSurfaceIndices2 (const Point<3> & p, const Vec<3> & v1, const Vec<3> & v2,
+						  NgArray<int> & surfind, double eps) const override;
+
+    virtual void CalcSpecialPoints (NgArray<Point<3> > & pts) const override;
+    virtual void AnalyzeSpecialPoint (const Point<3> & pt, 
+				      NgArray<Point<3> > & specpts) const override;
+    virtual Vec<3> SpecialPointTangentialVector (const Point<3> & p, int s1, int s2) const override;
+
+    virtual int GetNSurfaces() const override
+    { return planes.Size(); }
+    virtual Surface & GetSurface (int i) override
+    { return *planes[i]; }
+    virtual const Surface & GetSurface (int i) const override
+    { return *planes[i]; }
+
+    virtual void GetPrimitiveData (const char *& classname, NgArray<double> & coeffs) const override;
+    virtual void SetPrimitiveData (NgArray<double> & coeffs) override;
+
+    virtual void Reduce (const BoxSphere<3> & box) override;
+    virtual void UnReduce () override;
+
+    int AddPoint (const Point<3> & p);
+    int AddFace (int pi1, int pi2, int pi3, int inputnum);
+
+    void GetPolySurfs(NgArray < NgArray<int> * > & polysurfs);
+  
+  protected:
+    int FaceBoxIntersection (int fnr, const BoxSphere<3> & box) const;
+    //  void CalcData();
+  };
+
+}
+
+#endif

netgen/include/csg/revolution.hpp

@@ -0,0 +1,180 @@
+#ifndef _REVOLUTION_HPP
+#define _REVOLUTION_HPP
+
+namespace netgen
+{
+
+  class Revolution;
+
+  class RevolutionFace : public Surface
+  {
+  private:
+    bool isfirst, islast;
+    const SplineSeg<2> * spline;
+    bool deletable;
+
+    Point<3> p0;
+    Vec<3> v_axis;
+
+    int id;
+
+    // coefficient for implicizt polynomial
+    mutable Vector spline_coefficient;
+    mutable Vector spline_coefficient_shifted;
+
+
+    NgArray < Vec<2>* > checklines_vec;
+    NgArray < Point<2>* > checklines_start;
+    NgArray < Vec<2>* > checklines_normal;
+  
+  private:
+    void Init (void);
+
+  public:
+    void CalcProj(const Point<3> & point3d, Point<2> & point2d) const;
+    void CalcProj(const Point<3> & point3d, Point<2> & point2d,
+		  const Vec<3> & vector3d, Vec<2> & vector2d) const;
+    void CalcProj0(const Vec<3> & point3d_minus_p0, Point<2> & point2d) const;
+
+  public:
+    RevolutionFace(const SplineSeg<2> & spline_in,
+		   const Point<3> & p,
+		   const Vec<3> & vec,
+		   bool first = false,
+		   bool last = false,
+		   const int id_in = 0);
+
+    RevolutionFace(const NgArray<double> & raw_data);
+    // default constructor for archive
+    RevolutionFace() {}
+
+    ~RevolutionFace();
+
+    virtual void DoArchive(Archive& ar)
+    {
+      Surface::DoArchive(ar);
+      ar & isfirst & islast & spline & deletable & p0 & v_axis & id & spline_coefficient
+        & spline_coefficient_shifted & checklines_vec & checklines_start & checklines_normal;
+    }
+
+    virtual int IsIdentic (const Surface & s2, int & inv, double eps) const; 
+  
+    virtual double CalcFunctionValue (const Point<3> & point) const;
+    virtual void CalcGradient (const Point<3> & point, Vec<3> & grad) const;
+    virtual void CalcHesse (const Point<3> & point, Mat<3> & hesse) const;
+    virtual double HesseNorm () const;
+
+    virtual double MaxCurvature () const;
+    //virtual double MaxCurvatureLoc (const Point<3> & /* c */ , 
+    //				  double /* rad */) const;
+    
+    Point<3> P0() const { return p0; }
+    Vec<3> Axis() const { return v_axis; }
+    
+    virtual void Project (Point<3> & p) const;
+
+    virtual Point<3> GetSurfacePoint () const;
+    virtual void Print (ostream & str) const;
+  
+    virtual void GetTriangleApproximation (TriangleApproximation & tas, 
+					   const Box<3> & boundingbox, 
+					   double facets) const;
+
+    bool BoxIntersectsFace (const Box<3> & box) const;
+    /*
+      bool BoxIntersectsFace (const BoxSphere<2> & box, bool & uncertain) const;
+      bool BoxIntersectsFace (const BoxSphere<3> & box, bool & uncertain) const;
+    */
+
+    const SplineSeg<2> & GetSpline(void) const {return *spline;}
+
+    /* INSOLID_TYPE */ bool PointInFace (const Point<3> & p, const double eps) const;
+
+    void GetRawData(NgArray<double> & data) const;
+
+  };
+
+
+
+  /*
+
+  Primitive of revolution
+  
+  */
+
+
+  class Revolution : public Primitive
+  {
+  private:
+    Point<3> p0,p1;
+    Vec<3> v_axis;
+
+    // 1 ... torus-like
+    // 2 ... sphere-like
+    int type;
+  
+
+    Array<RevolutionFace*> faces;
+    shared_ptr<SplineGeometry<2>> splinegeo;
+
+    mutable int intersecting_face;
+
+  public:
+    Revolution(const Point<3> & p0_in,
+	       const Point<3> & p1_in,
+	       shared_ptr<SplineGeometry<2>> spline_in);
+    // default constructor for archive
+    Revolution() {}
+
+    ~Revolution();
+
+    virtual void DoArchive(Archive& ar)
+    {
+      Primitive::DoArchive(ar);
+      ar & p0 & p1 & v_axis & type & faces & intersecting_face;
+    }
+  
+    /*
+      Check, whether box intersects solid defined by surface.
+
+      return values:
+      0 .. box outside solid \\
+      1 .. box in solid \\
+      2 .. can't decide (allowed, iff box is close to solid)
+    */
+    virtual INSOLID_TYPE BoxInSolid (const BoxSphere<3> & box) const;
+    virtual INSOLID_TYPE PointInSolid (const Point<3> & p,
+				       double eps) const;
+
+    virtual void GetTangentialSurfaceIndices (const Point<3> & p, 
+					      NgArray<int> & surfind, double eps) const;
+    
+    virtual INSOLID_TYPE VecInSolid (const Point<3> & p,
+				     const Vec<3> & v,
+				     double eps) const;
+
+    // checks if lim s->0 lim t->0  p + t(v1 + s v2) in solid
+    virtual INSOLID_TYPE VecInSolid2 (const Point<3> & p,
+				      const Vec<3> & v1,
+				      const Vec<3> & v2,
+				      double eps) const;
+
+    virtual void GetTangentialVecSurfaceIndices2 (const Point<3> & p, const Vec<3> & v1, const Vec<3> & v2,
+						  NgArray<int> & surfind, double eps) const;
+
+    
+    virtual int GetNSurfaces() const;
+    virtual Surface & GetSurface (int i = 0);
+    virtual const Surface & GetSurface (int i = 0) const;
+
+
+    virtual void Reduce (const BoxSphere<3> & box);
+    virtual void UnReduce ();
+  
+	     
+  };
+
+}
+
+
+#endif

netgen/include/csg/singularref.hpp

@@ -0,0 +1,84 @@
+#ifndef FILE_SINGULARREF
+#define FILE_SINGULARREF
+
+/**************************************************************************/
+/* File:   singularref.hh                                                 */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   25. Sep. 99                                                    */
+/**************************************************************************/
+
+namespace netgen
+{
+
+
+  /**
+     Control for local refinement
+  */
+
+
+
+  /**
+     Singular Face.
+     Causes a boundary layer mesh refinement.
+     All elements in subdomain domnr will get a boundary layer
+     on faces sharing the solid sol
+  */
+  class DLL_HEADER SingularFace 
+  {
+  public:
+    int domnr;
+    const Solid *sol;
+    double factor; 
+    // NgArray<Point<3> > points;
+    // NgArray<INDEX_2> segms;
+  public:
+    SingularFace (int adomnr, const Solid * asol, double sf)
+      : domnr(adomnr), sol(asol), factor(sf) { ; }
+    const Solid * GetSolid() const { return sol; }
+    int GetDomainNr () const { return domnr; }
+  };
+
+
+  ///
+  class DLL_HEADER SingularEdge
+  {
+  public:
+    double beta;
+    int domnr;
+    const CSGeometry& geom;
+    const Solid *sol1, *sol2;
+    NgArray<Point<3> > points;
+    NgArray<INDEX_2> segms;
+    double factor; 
+
+    double maxhinit;
+  public:
+    SingularEdge (double abeta, int adomnr, 
+		  const CSGeometry & ageom,
+		  const Solid * asol1, const Solid * asol2, double sf,
+		  const double maxh_at_initialization = -1);
+    void FindPointsOnEdge (class Mesh & mesh);
+    void SetMeshSize (class Mesh & mesh, double globalh);
+  };
+
+
+  ///
+  class DLL_HEADER SingularPoint
+  {
+  public:
+    double beta;
+    const Solid *sol1, *sol2, *sol3;
+    NgArray<Point<3> > points;
+    double factor; 
+ 
+  public:
+    SingularPoint (double abeta, const Solid * asol1, const Solid * asol2,
+		   const Solid * asol3, double sf);
+    void FindPoints (class Mesh & mesh);
+    void SetMeshSize (class Mesh & mesh, double globalh);
+  };
+
+}
+
+
+#endif

netgen/include/csg/solid.hpp

@@ -0,0 +1,295 @@
+#ifndef FILE_SOLID
+#define FILE_SOLID
+
+/**************************************************************************/
+/* File:   solid.hh                                                       */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   1. Dez. 95                                                     */
+/**************************************************************************/
+
+#include <functional>
+
+namespace netgen 
+{
+
+  
+  /*
+    
+  Constructive Solid Model (csg)
+  
+  */
+  
+
+
+
+  class Solid;
+  
+  class SolidIterator
+  {
+  public:
+    SolidIterator () { ; }
+    virtual ~SolidIterator () { ; }
+    virtual void Do (Solid * sol) = 0;
+  };
+
+
+  inline INSOLID_TYPE Intersection (INSOLID_TYPE ina, INSOLID_TYPE inb)
+  {
+    if (ina == IS_INSIDE && inb == IS_INSIDE) return IS_INSIDE;
+    if (ina == IS_OUTSIDE || inb == IS_OUTSIDE) return IS_OUTSIDE;
+    return DOES_INTERSECT;
+  }
+  
+  inline INSOLID_TYPE Union (INSOLID_TYPE ina, INSOLID_TYPE inb)
+  {
+    if (ina == IS_INSIDE || inb == IS_INSIDE) return IS_INSIDE;
+    if (ina == IS_OUTSIDE && inb == IS_OUTSIDE) return IS_OUTSIDE;
+    return DOES_INTERSECT;
+  }
+
+  inline INSOLID_TYPE Complement (INSOLID_TYPE in)
+  {
+    if (in == IS_INSIDE) return IS_OUTSIDE;
+    if (in == IS_OUTSIDE) return IS_INSIDE;
+    return DOES_INTERSECT;
+  }
+
+  class Solid
+  {
+  public:
+  
+    typedef enum optyp1 { TERM, TERM_REF, SECTION, UNION, SUB, ROOT /*, DUMMY */ } optyp;
+  
+  private:
+    char * name;
+    Primitive * prim;
+    Solid * s1, * s2;
+  
+    optyp op;
+    bool visited;
+    double maxh;
+    int num_surfs;
+
+    // static int cntnames;
+
+  public:
+    Solid (Primitive * aprim);
+    Solid (optyp aop, Solid * as1, Solid * as2 = NULL);
+    // default constructor for archive
+    Solid () {}
+    ~Solid ();
+
+    void DoArchive(Archive& archive)
+    {
+      archive & name & prim & s1 & s2 & visited & maxh & num_surfs;
+      if(archive.Output())
+        archive << int(op);
+      else
+        {
+          int iop;
+          archive & iop;
+          op = optyp(iop);
+        }
+    }
+    const char * Name () const { return name; }
+    void SetName (const char * aname);
+
+    Solid * Copy (class CSGeometry & geom) const;
+    void Transform (Transformation<3> & trans);
+
+  
+    void IterateSolid (SolidIterator & it, bool only_once = 0);
+
+  
+    void Boundaries (const Point<3> & p, NgArray<int> & bounds) const;
+    int NumPrimitives () const;
+    void GetSurfaceIndices (NgArray<int> & surfind) const;
+    void GetSurfaceIndices (IndexSet & iset) const;
+
+    void GetTangentialSurfaceIndices (const Point<3> & p, NgArray<int> & surfids, double eps) const;
+    void GetTangentialSurfaceIndices2 (const Point<3> & p, const Vec<3> & v, NgArray<int> & surfids, double eps) const;
+    void GetTangentialSurfaceIndices3 (const Point<3> & p, const Vec<3> & v, const Vec<3> & v2, NgArray<int> & surfids, double eps) const;
+
+    void ForEachSurface (const std::function<void(Surface*,bool)> & lambda, bool inv = false) const;
+
+    Primitive * GetPrimitive ()
+    { return (op == TERM || op == TERM_REF) ? prim : NULL; }
+    const Primitive * GetPrimitive () const
+    { return (op == TERM || op == TERM_REF) ? prim : NULL; }
+
+    Solid * S1() { return s1; }
+    Solid * S2() { return s2; }
+
+    // geometric tests
+
+    INSOLID_TYPE PointInSolid (const Point<3> & p, double eps) const;
+    INSOLID_TYPE VecInSolid (const Point<3> & p, const Vec<3> & v, double eps) const;
+
+    // checks if lim s->0 lim t->0  p + t(v1 + s v2) in solid
+    INSOLID_TYPE VecInSolid2 (const Point<3> & p, const Vec<3> & v1,
+                              const Vec<3> & v2, double eps) const;
+
+    
+    bool IsIn (const Point<3> & p, double eps = 1e-6) const;
+    bool IsStrictIn (const Point<3> & p, double eps = 1e-6) const;
+    bool VectorIn (const Point<3> & p, const Vec<3> & v, double eps = 1e-6) const;
+    bool VectorStrictIn (const Point<3> & p, const Vec<3> & v, double eps = 1e-6) const;
+  
+    bool VectorIn2 (const Point<3> & p, const Vec<3> & v1, const Vec<3> & v2,
+		    double eps) const;
+    /*
+    bool VectorIn2Rec (const Point<3> & p, const Vec<3> & v1, const Vec<3> & v2,
+		       double eps) const;
+    */
+    bool VectorStrictIn2 (const Point<3> & p, const Vec<3> & v1, const Vec<3> & v2,
+                          double eps) const;
+
+    /// compute localization in point p
+    unique_ptr<Solid> TangentialSolid (const Point<3> & p, NgArray<int> & surfids, double eps) const;
+
+    /// compute localization in point p tangential to vector t
+    unique_ptr<Solid> TangentialSolid2 (const Point<3> & p, const Vec<3> & t,
+                                        NgArray<int> & surfids, double eps) const;
+
+    /** compute localization in point p, with second order approximation to edge
+	p + s t + s*s/2 t2 **/
+    unique_ptr<Solid> TangentialSolid3 (const Point<3> & p, const Vec<3> & t, const Vec<3> & t2, 
+                                        NgArray<int> & surfids, double eps) const;
+
+
+
+    /** tangential solid, which follows the edge
+	p + s t + s*s/2 t2
+	with second order, and the neighbouring face
+	p + s t + s*s/2 t2 + r m
+	with first order
+    **/
+    unique_ptr<Solid> TangentialEdgeSolid (const Point<3> & p, const Vec<3> & t, const Vec<3> & t2, 
+                                           const Vec<3> & m, 
+                                           NgArray<int> & surfids, double eps) const;
+
+
+    void CalcOnePrimitiveSpecialPoints (const Box<3> & box, NgArray<Point<3> > & pts) const;
+
+    ///
+    int Edge (const Point<3> & p, const Vec<3> & v, double eps) const;
+    ///
+    int OnFace (const Point<3> & p, const Vec<3> & v, double eps) const;
+    ///
+    void Print (ostream & str) const;
+    ///
+    void CalcSurfaceInverse ();
+    ///
+    Solid * GetReducedSolid (const BoxSphere<3> & box) const;
+  
+
+    void SetMaxH (double amaxh)
+    { maxh = amaxh; }
+    double GetMaxH () const
+    { return maxh; }
+
+    void GetSolidData (ostream & ost, int first = 1) const;
+    static Solid * CreateSolid (istream & ist, const SymbolTable<Solid*> & solids);
+
+
+    static shared_ptr<BlockAllocator> ball;
+    void * operator new(size_t /* s */) 
+    {
+      return ball->Alloc();
+    }
+
+    void operator delete (void * p)
+    {
+      ball->Free (p);
+    }
+
+
+  protected:
+    ///
+
+    void RecBoundaries (const Point<3> & p, NgArray<int> & bounds, 
+			int & in, int & strin) const;
+    ///
+    void RecTangentialSolid (const Point<3> & p, Solid *& tansol, NgArray<int> & surfids, 
+                             bool & in, bool & strin, double eps) const;
+
+    void RecTangentialSolid2 (const Point<3> & p, const Vec<3> & vec, 
+			      Solid *& tansol, NgArray<int> & surfids, 
+			      bool & in, bool & strin, double eps) const;
+    ///
+    void RecTangentialSolid3 (const Point<3> & p, const Vec<3> & vec,const Vec<3> & vec2, 
+			      Solid *& tansol, NgArray<int> & surfids, 
+			      bool & in, bool & strin, double eps) const;
+    ///
+    void RecTangentialEdgeSolid (const Point<3> & p, const Vec<3> & t, const Vec<3> & t2, 
+				 const Vec<3> & m, 
+				 Solid *& tansol, NgArray<int> & surfids, 
+				 bool & in, bool & strin, double eps) const;
+
+    ///
+    void RecEdge (const Point<3> & p, const Vec<3> & v,
+		  bool & in, bool & strin, int & faces, double eps) const;
+    ///
+    void CalcSurfaceInverseRec (int inv);
+    ///
+    Solid * RecGetReducedSolid (const BoxSphere<3> & box, INSOLID_TYPE & in) const;
+    ///
+    void RecGetSurfaceIndices (NgArray<int> & surfind) const;
+    void RecGetTangentialSurfaceIndices (const Point<3> & p, NgArray<int> & surfids, double eps) const;
+    void RecGetTangentialSurfaceIndices2 (const Point<3> & p, const Vec<3> & v, NgArray<int> & surfids, double eps) const;
+    void RecGetTangentialSurfaceIndices3 (const Point<3> & p, const Vec<3> & v, const Vec<3> & v2, 
+					  NgArray<int> & surfids, double eps) const;
+    void RecGetTangentialEdgeSurfaceIndices (const Point<3> & p, const Vec<3> & v, const Vec<3> & v2, const Vec<3> & m,
+					     NgArray<int> & surfids, double eps) const;
+    void RecGetSurfaceIndices (IndexSet & iset) const;
+
+    void RecCalcOnePrimitiveSpecialPoints (NgArray<Point<3> > & pts) const;
+
+    friend class SolidIterator;
+    friend class ClearVisitedIt;
+    friend class RemoveDummyIterator;
+    friend class CSGeometry;
+  };
+
+
+  inline ostream & operator<< (ostream & ost, const Solid & sol)
+  {
+    sol.Print (ost);
+    return ost;
+  }
+
+
+
+
+
+
+  class ReducePrimitiveIterator : public SolidIterator
+  {
+    BoxSphere<3> box;
+  public:
+    ReducePrimitiveIterator (const BoxSphere<3> & abox)
+      : SolidIterator(), box(abox) { ; }
+    virtual ~ReducePrimitiveIterator () { ; }
+    virtual void Do (Solid * sol)
+    {
+      if (sol -> GetPrimitive())
+	sol -> GetPrimitive() -> Reduce (box);
+    }
+  };
+
+
+  class UnReducePrimitiveIterator : public SolidIterator
+  {
+  public:
+    UnReducePrimitiveIterator () { ; }
+    virtual ~UnReducePrimitiveIterator () { ; }
+    virtual void Do (Solid * sol)
+    {
+      if (sol -> GetPrimitive())
+	sol -> GetPrimitive() -> UnReduce ();
+    }
+  };
+
+}
+
+#endif