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

netgen/include/csg/specpoin.hpp

@@ -0,0 +1,194 @@
+#ifndef FILE_SPECPOIN
+#define FILE_SPECPOIN
+
+
+/**************************************************************************/
+/* File:   specpoin.hpp                                                   */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   01. Okt. 95                                                    */
+/**************************************************************************/
+
+namespace netgen
+{
+
+  // extern DLL_HEADER MeshingParameters mparam;
+
+  /*
+
+  Special Point Calculation
+  
+  */
+
+  class Surface;
+  class Solid;
+
+  /// Special point.
+  class SpecialPoint
+  {
+  public:
+    /// coordinates
+    Point<3> p;
+    /// tangential to edge
+    Vec<3> v;
+    ///
+    int layer;
+    /// point must be used in mesh 
+    bool unconditional; 
+
+    /// surfaces defining edge 
+    int s1, s2;
+    /// if s1 and s2 are only representatives, then these are the original indices
+    int s1_orig, s2_orig;
+    int nr;
+    ///
+    SpecialPoint () : p(0,0,0), v(0,0,0), layer(0), unconditional(0), s1(0), s2(0), s1_orig(0), s2_orig(0)
+    { ; }
+
+    ///
+    SpecialPoint (const SpecialPoint & sp2);
+
+    ///
+    SpecialPoint & operator= (const SpecialPoint & sp2);
+  
+    ///
+    void Print (ostream & str) const;
+
+
+    int GetLayer() const { return layer; }
+
+    ///
+    bool HasSurfaces (int as1, int as2) const
+    {
+      return ( (s1 == as1 && s2 == as2) || (s1 == as2 && s2 == as1) );
+    }
+  };
+
+  inline ostream & operator<< (ostream & ost, const SpecialPoint & sp)
+  {
+    sp.Print (ost);
+    return ost;
+  }
+
+
+
+
+  ///
+  class SpecialPointCalculation
+  {
+  private:
+    ///
+    const CSGeometry * geometry;
+    ///
+    NgArray<MeshPoint> * points;
+    ///
+    NgArray<long int> boxesinlevel;
+
+    ///
+    double size;
+    ///
+    double relydegtest;   // maximal dimension of bisection interval for
+    /// test of degeneration parameters
+    double cpeps1, epeps1, epeps2, epspointdist2;
+
+    double ideps;
+
+  public: 
+
+    ///
+    SpecialPointCalculation (); 
+  
+    ///
+    void SetIdEps(const double epsin) {ideps = epsin;}
+
+    ///
+    void CalcSpecialPoints (const CSGeometry & ageometry, 
+			    NgArray<MeshPoint> & points);
+    ///
+    void AnalyzeSpecialPoints (const CSGeometry & geometry, 
+			       NgArray<MeshPoint> & points, 
+			       NgArray<SpecialPoint> & specpoints);
+
+  protected:
+    ///
+    void CalcSpecialPointsRec (const Solid * sol, int layer,
+			       const BoxSphere<3> & box, 
+			       int level, 
+			       bool calccp, bool calcep);
+
+
+    ///
+    bool CrossPointNewtonConvergence (const Surface * f1, const Surface * f2, 
+				      const Surface * f3, const BoxSphere<3> & box);  
+    ///
+    bool CrossPointDegenerated (const Surface * f1, const Surface * f2,
+				const Surface * f3, const BoxSphere<3> & box) const;
+    ///
+    void CrossPointNewton (const Surface * f1, const Surface * f2, 
+			   const Surface * f3, Point<3> & p);
+  
+    bool EdgeNewtonConvergence (const Surface * f1, const Surface * f2, 
+				const Point<3> & p);  
+    ///
+    bool EdgeDegenerated (const Surface * f1, const Surface * f2,
+			  const BoxSphere<3> & box) const;
+    ///
+    void EdgeNewton (const Surface * f1, const Surface * f2, 
+		     Point<3> & p);
+    ///
+    bool IsEdgeExtremalPoint (const Surface * f1, const Surface * f2, 
+			      const Point<3> & p, Point<3> & pp, double rad);
+
+
+
+    /*
+   ///
+   bool ExtremalPointPossible (const Surface * f1, const Surface * f2, 
+   int dir, const BoxSphere<3> & box);
+   ///
+   bool ExtremalPointDegenerated (const Surface * f1, const Surface * f2, 
+   int dir, const BoxSphere<3> & box);
+   ///
+   bool ExtremalPointNewtonConvergence (const Surface * f1, const Surface * f2, 
+   int dir, const BoxSphere<3> & box);
+    */
+    ///
+    void ExtremalPointNewton (const Surface * f1, const Surface * f2, 
+			      int dir, Point<3> & p);
+
+
+    ///
+    bool AddPoint (const Point<3> & p, int layer);
+
+    void ComputeExtremalPoints (const Plane * plane, 
+				const QuadraticSurface * quadric, 
+				NgArray<Point<3> > & pts);
+
+    void ComputeExtremalPoints (const Sphere * sphere1, 
+				const Sphere * sphere2, 
+				NgArray<Point<3> > & pts);
+
+    bool ComputeExtremalPoints (const RevolutionFace * rev1, 
+				const RevolutionFace * rev2, 
+				NgArray<Point<3> > & pts);
+
+    void ComputeCrossPoints (const Plane * plane1, 
+			     const Plane * plane2, 
+			     const Plane * plane3, 
+			     NgArray<Point<3> > & pts);
+
+    void ComputeCrossPoints (const Plane * plane1, 
+			     const Plane * plane2, 
+			     const QuadraticSurface * quadratic, 
+			     NgArray<Point<3> > & pts);
+
+    void ComputeCrossPoints (const Sphere * sphere1, 
+			     const Sphere * sphere2, 
+			     const Sphere * sphere3, 
+			     NgArray<Point<3> > & pts);
+  };
+
+}
+
+#endif
+
+

netgen/include/csg/spline3d.hpp

@@ -0,0 +1,99 @@
+namespace netgen
+{
+
+  ///
+  class splinesegment3d
+  {
+    ///
+    Point<3> p1, p2, p3;
+  
+  public:
+    ///
+    splinesegment3d (const Point<3> & ap1, const Point<3> & ap2, 
+		     const Point<3> & ap3);
+    ///
+    void Evaluate (double t, Point<3> & p) const;
+    ///
+    void EvaluateTangent (double t, Vec<3> & tang) const;
+    ///
+    const Point<3> & P1() const { return p1; }
+    ///
+    const Point<3> & P2() const { return p2; }
+    ///
+    const Point<3> & P3() const { return p3; }
+  };
+
+  ///
+  class spline3d
+  {
+    ///
+    NgArray<splinesegment3d *> segments;
+  
+  public:
+    ///
+    spline3d () { };
+    ///
+    void AddSegment (const Point<3> & ap1, const Point<3> & ap2, const Point<3> & ap3);
+    ///
+    int GetNumSegments () const { return segments.Size(); }
+    ///
+    double ProjectToSpline (Point<3> & p) const;
+    ///
+    double ProjectToSpline (Point<3> & p, double t) const;
+    ///
+    void Evaluate (double t, Point<3> & p) const;
+    ///
+    void EvaluateTangent (double t, Vec<3> & tang) const;
+    ///
+    const Point<3> & P1(int i) const { return segments.Get(i)->P1(); }
+    ///
+    const Point<3> & P2(int i) const { return segments.Get(i)->P2(); }
+    ///
+    const Point<3> & P3(int i) const { return segments.Get(i)->P3(); }
+  };
+  
+  ///
+  class splinetube : public Surface
+  {
+    ///
+    const spline3d & middlecurve;
+    ///
+    double r;
+    ///  Vec<3> ex, ey, ez;
+    Vec<2> e2x, e2y;
+    ///
+    Point<3> cp;
+  
+  public:
+    ///
+    splinetube (const spline3d & amiddlecurve, double ar);
+  
+    ///
+    virtual void DefineTangentialPlane (const Point<3> & ap1, const Point<3> & ap2);
+    ///
+    virtual void ToPlane (const Point<3> & p, Point<2> & pplain, double h, int & zone) const;
+    ///
+    virtual void FromPlane (const Point<2> & pplain, Point<3> & p, double h) const;
+    ///
+    virtual void Project (Point<3> & p) const;
+
+    //  virtual int RootInBox (const box3d & box) const { return 0; }
+    /// 0 .. no, 1 .. yes, 2 .. maybe
+
+    virtual int BoxInSolid (const BoxSphere<3> & box) const;
+    /// 0 .. no, 1 .. yes, 2 .. maybe
+
+    virtual double CalcFunctionValue (const Point<3> & point) const;
+    ///
+    virtual void CalcGradient (const Point<3> & point, Vec<3> & grad) const;
+    ///
+    virtual double HesseNorm () const { return 0.5 / r; }
+    ///
+    virtual Point<3> GetSurfacePoint () const;
+    ///
+    virtual void Print (ostream & str) const;
+  };  
+
+
+}
+

netgen/include/csg/splinesurface.hpp

@@ -0,0 +1,85 @@
+#ifndef FILE_SPLINESURFACE
+#define FILE_SPLINESURFACE
+
+
+namespace netgen
+{
+  class SplineSurface  : public  OneSurfacePrimitive
+  {
+  protected:
+    NgArray<GeomPoint<3>> geompoints;
+    NgArray<shared_ptr<SplineSeg<3>>> splines;
+    NgArray<string> bcnames;
+    NgArray<double> maxh;
+    shared_ptr<OneSurfacePrimitive> baseprimitive;
+    shared_ptr<NgArray<shared_ptr<OneSurfacePrimitive>>> cuts;
+    shared_ptr<NgArray<shared_ptr<OneSurfacePrimitive>>> all_cuts;
+    
+  public:
+    SplineSurface(shared_ptr<OneSurfacePrimitive> abaseprimitive, shared_ptr<NgArray<shared_ptr<OneSurfacePrimitive>>> acuts) :
+      OneSurfacePrimitive(), baseprimitive(abaseprimitive), cuts(acuts)
+    { ; }
+    // default constructor for archive
+    SplineSurface() {}
+    virtual ~SplineSurface() { ; }
+    
+    const auto & GetSplines() const { return splines; }
+    int GetNSplines() const { return splines.Size(); }
+    const NgArray<GeomPoint<3>>& GetPoints() const { return geompoints; }
+    string GetSplineType(const int i) const { return splines[i]->GetType(); }
+    SplineSeg<3> & GetSpline(const int i) { return *splines[i]; }
+    const SplineSeg<3> & GetSpline(const int i) const { return *splines[i]; }
+    int GetNP() const { return geompoints.Size(); }
+    const GeomPoint<3> & GetPoint(int i) const { return geompoints[i]; }
+    string GetBCName(int i) const { return bcnames[i]; }
+    string GetBCNameOf(Point<3> p1, Point<3> p2) const;
+    
+    DLL_HEADER void AppendPoint(const Point<3> & p, const double reffac = 1., const bool hpref=false);
+    void AppendSegment(shared_ptr<SplineSeg<3>> spline, string & bcname, double amaxh = -1);
+
+    const shared_ptr<NgArray<shared_ptr<OneSurfacePrimitive>>> CreateCuttingSurfaces();
+    const shared_ptr<NgArray<shared_ptr<OneSurfacePrimitive>>> GetCuts() const { return all_cuts; }
+    const shared_ptr<OneSurfacePrimitive> GetBase() const { return baseprimitive; }
+    
+    virtual void Project (Point<3> & p3d) const { baseprimitive->Project(p3d); }
+    virtual double CalcFunctionValue (const Point<3> & point) const
+    { return baseprimitive->CalcFunctionValue (point); }
+    virtual void CalcGradient (const Point<3> & point, Vec<3> & grad) const
+    { baseprimitive->CalcGradient (point,grad); }
+    virtual double HesseNorm () const
+    { return baseprimitive->HesseNorm(); }
+    virtual Point<3> GetSurfacePoint () const
+    { return baseprimitive->GetSurfacePoint(); }
+    virtual void CalcSpecialPoints(NgArray<Point<3>> & pts) const
+    { baseprimitive->CalcSpecialPoints(pts); }
+
+    virtual INSOLID_TYPE BoxInSolid(const BoxSphere<3> & box) const
+    { return baseprimitive->BoxInSolid(box); }
+
+    virtual void DoArchive(Archive& ar)
+    {
+      ar & geompoints & splines & bcnames & maxh & baseprimitive & cuts & all_cuts;
+    }
+    
+    /*
+    virtual void Project (Point<3> & p3d) const;
+    virtual double CalcFunctionValue (const Point<3> & point) const;
+    virtual void CalcGradient (const Point<3> & point, Vec<3> & grad) const;
+    virtual double HesseNorm () const;
+    virtual Point<3> GetSurfacePoint () const;
+    virtual void CalcSpecialPoints(NgArray<Point<3>> & pts) const;
+
+    virtual INSOLID_TYPE BoxInSolid(const BoxSphere<3> & box) const;
+
+    */
+    
+    virtual void Print (ostream & str) const;
+    
+    
+  };
+
+
+
+}
+
+#endif