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

netgen/include/meshing/ruler3.hpp

@@ -0,0 +1,211 @@
+#ifndef FILE_RULER3
+#define FILE_RULER3
+
+namespace netgen
+{
+
+/**
+  3D element generation rule.
+ */
+class vnetrule
+{
+private:
+  /// rule is applicable for quality classes above this value
+  int quality;
+  /// name of rule
+  char * name;
+  /// point coordinates in reference position
+  NgArray<Point3d> points;
+  /// old and new faces in reference numbering
+  NgArray<Element2d> faces;
+  /// additional edges of rule
+  NgArray<twoint> edges;
+
+  /// points of freezone in reference coordinates
+  NgArray<Point3d> freezone;
+  /// points of freezone in reference coordinates if tolcalss to infty
+  NgArray<Point3d> freezonelimit;
+  /// point index, if point equal to mappoint, otherwise 0
+  NgArray<int> freezonepi;
+  /// faces of each convex part of freezone
+  NgArray<NgArray<threeint>*> freefaces;
+  /// set of points of each convex part of freezone
+  NgArray<NgArray<int>*> freesets;
+  /// points of transformed freezone
+  NgArray<Point3d> transfreezone;
+  /// edges of each convex part of freezone
+  NgArray<NgArray<twoint>*> freeedges;
+
+  /// face numbers to be deleted
+  NgArray<int> delfaces;
+  /// elements to be generated
+  NgArray<Element> elements;
+  /// tolerances for points and faces (used ??)
+  NgArray<double> tolerances, linetolerances;
+  /// transformation matrix 
+  DenseMatrix oldutonewu;
+  /// transformation matrix: deviation old point to dev. freezone
+  DenseMatrix * oldutofreezone;
+  /** transformation matrix: deviation old point to dev. freezone, 
+    quality class to infinity */
+  DenseMatrix * oldutofreezonelimit;
+
+  // can be deleted:
+  // BaseMatrix *outf, *outfl;
+
+  /**
+    a point is outside of convex part of freezone, 
+    iff mat * (point, 1) >= 0 for each component (correct ?)
+    */
+  NgArray<DenseMatrix*> freefaceinequ;
+  /// 
+  NgArray<fourint> orientations;
+  /**
+    flags specified in rule-description file:
+    t .. test rule
+    */
+  NgArray<char> flags;
+
+  /**
+    topological distance of face to base element
+    non-connected: > 100  (??) 
+    */
+  NgArray<int> fnearness;
+  NgArray<int> pnearness;
+  int maxpnearness;
+
+  /// number of old points in rule
+  int noldp;
+  /// number of new poitns in rule
+  int noldf;
+  /// box containing free-zone
+public:  
+  // double fzminx, fzmaxx, fzminy, fzmaxy, fzminz, fzmaxz;
+  Box3d fzbox;
+
+public:
+  
+  ///
+  vnetrule ();
+  ///
+  ~vnetrule ();
+  ///
+  int GetNP () const { return points.Size(); }
+  ///
+  int GetNF () const { return faces.Size(); }
+  ///
+  int GetNE () const { return elements.Size(); }
+  ///
+  int GetNO () const { return orientations.Size(); }
+  ///
+  int GetNEd () const { return edges.Size(); }
+  ///
+  int GetNOldP () const { return noldp; }
+  ///
+  int GetNOldF () const { return noldf; }
+  ///
+  int GetNDelF () const { return delfaces.Size(); }
+  ///
+  int GetQuality () const { return quality; }
+  ///
+  int GetFNearness (int fi) const { return fnearness.Get(fi); }
+  ///
+  int GetPNearness (int pi) const { return pnearness.Get(pi); }
+  ///
+  int GetMaxPNearness () const { return maxpnearness; }
+
+
+  ///
+  const Point3d & GetPoint (int i) const { return points.Get(i); }
+  ///
+  const Element2d & GetFace (int i) const { return faces.Get(i); }
+  ///
+  const Element & GetElement (int i) const { return elements.Get(i); }
+  ///
+  const twoint & GetEdge (int i) const { return edges.Get(i); }
+  ///
+  int GetDelFace (int i) const { return delfaces.Get(i); }
+  ///
+  int IsDelFace (int fn) const;
+  
+  ///
+  float CalcPointDist (int pi, const Point3d & p) const;
+  ///
+  double PointDistFactor (int pi) const
+    {
+      return tolerances.Get(pi);
+    }
+  ///
+  void SetFreeZoneTransformation (const Vector & allp,
+				  int tolclass);
+  ///
+  int IsInFreeZone (const Point3d & p) const;
+  /**
+    0 not in free-zone
+    1 in free-zone
+    -1 maybe 
+   */
+  int IsTriangleInFreeZone (const Point3d & p1, const Point3d & p2,
+                            const Point3d & p3, const NgArray<int> & pi, int newone);
+  ///
+  int IsQuadInFreeZone (const Point3d & p1, const Point3d & p2,
+			const Point3d & p3, const Point3d & p4,
+			const NgArray<int> & pi, int newone);
+  ///
+  int IsTriangleInFreeSet (const Point3d & p1, const Point3d & p2,
+                           const Point3d & p3, int fs, const NgArray<int> & pi, int newone);
+
+  ///
+  int IsQuadInFreeSet (const Point3d & p1, const Point3d & p2,
+		       const Point3d & p3, const Point3d & p4,
+		       int fs, const NgArray<int> & pi, int newone);
+  
+  ///
+  int ConvexFreeZone () const;
+  
+  /// if t1 and t2 are neighbourtriangles, NTP returns the opposite Point of t1 in t2
+  int NeighbourTrianglePoint (const threeint & t1, const threeint & t2) const;
+  ///
+  const Point3d & GetTransFreeZone (int i) { return transfreezone.Get(i); }
+
+  ///
+  int GetNP (int fn) const
+  { return faces.Get(fn).GetNP(); }
+  ///
+  PointIndex GetPointNr (int fn, int endp) const
+  { return faces.Get(fn).PNum(endp); }
+  ///
+  PointIndex GetPointNrMod (int fn, int endp) const
+  { return faces.Get(fn).PNumMod(endp); }
+  ///
+  const fourint & GetOrientation (int i) { return orientations.Get(i); }
+
+  ///
+  int TestFlag (char flag) const;
+
+  ///
+  const DenseMatrix & GetOldUToNewU () const { return oldutonewu; }
+  //
+  //  const DenseMatrix & GetOldUToFreeZone () const { return oldutofreezone; }
+  //
+  //  const DenseMatrix & GetOldUToFreeZoneLimit () const 
+  //    { return oldutofreezonelimit; }
+  ///
+  const char * Name () const { return name; }
+  ///
+  void LoadRule (istream & ist);
+
+  ///
+  const NgArray<Point3d> & GetTransFreeZone () { return transfreezone; }
+  ///
+  int TestOk () const;
+
+  ///
+  friend void TestRules ();
+  ///
+  //  friend void Plot3DRule (const ROT3D & r, char key);
+};
+
+} // namespace netgen
+#endif
+

netgen/include/meshing/soldata.hpp

@@ -0,0 +1,141 @@
+#ifndef FILE_SOLDATA
+#define FILE_SOLDATA
+
+#include <myadt.hpp>  // for tAVX
+namespace netgen
+{
+
+  using namespace std;
+  
+  class SolutionData
+  {
+  protected:
+
+    string name;
+    int components;
+    bool iscomplex;
+
+    int multidimcomponent;
+
+  public:
+    SolutionData (const string & aname, 
+                  int acomponents = 1, bool aiscomplex = 0)
+      : name(aname), components(acomponents), iscomplex(aiscomplex)
+    { ; }
+
+    virtual ~SolutionData ()
+    { ; }
+
+    int GetComponents() 
+    { 
+      return components; 
+    }
+
+    bool IsComplex() 
+    {
+      return iscomplex; 
+    }
+
+    virtual bool GetValue (int /* elnr */, 
+                           double /* lam1 */, double /* lam2 */, double /* lam3 */,
+                           double * /* values */) 
+    { 
+      return false; 
+    }
+
+    virtual bool GetValue (int selnr,
+                           const double xref[], const double x[], const double dxdxref[],
+                           double * values) 
+    {
+      return GetValue (selnr, xref[0], xref[1], xref[2], values); 
+    }
+
+    virtual bool GetMultiValue (int elnr, int facetnr, int npts,
+				const double * xref, int sxref,
+				const double * x, int sx,
+				const double * dxdxref, int sdxdxref,
+				double * values, int svalues)
+    {
+      bool res = false;
+      for (int i = 0; i < npts; i++)
+	res = GetValue (elnr, &xref[i*sxref], &x[i*sx], &dxdxref[i*sdxdxref], &values[i*svalues]);
+      return res;
+    }
+
+
+
+    virtual bool GetSurfValue (int /* selnr */, int facetnr, 
+                               double /* lam1 */, double /* lam2 */, 
+                               double * /* values */)
+    { 
+      return false; 
+    }
+
+
+    virtual bool GetSurfValue (int selnr, int facetnr, 
+                               const double xref[], const double x[], const double dxdxref[],
+                               double * values)
+    { 
+      return GetSurfValue (selnr, facetnr, xref[0], xref[1], values); 
+    }
+
+
+    virtual bool GetMultiSurfValue (int selnr, int facetnr, int npts,
+                                    const double * xref, int sxref,
+                                    const double * x, int sx,
+                                    const double * dxdxref, int sdxdxref,
+                                    double * values, int svalues)
+    {
+      bool res = false;
+      for (int i = 0; i < npts; i++)
+	res = GetSurfValue (selnr, facetnr, &xref[i*sxref], &x[i*sx], &dxdxref[i*sdxdxref], &values[i*svalues]);
+      return res;
+    }
+
+    virtual bool GetMultiSurfValue (size_t selnr, size_t facetnr, size_t npts,
+                                    const SIMD<double> * xref,
+                                    const SIMD<double> * x,
+                                    const SIMD<double> * dxdxref,
+                                    SIMD<double> * values)
+    {
+      cerr << "GetMultiSurfVaue not overloaded for SIMD<double>" << endl;
+      return false;
+    }
+    
+    virtual bool GetSegmentValue (int segnr, double xref, double * values)
+    { return false; }
+    
+
+    virtual int GetNumMultiDimComponents ()
+    {
+      return 1;
+    }
+
+    virtual void SetMultiDimComponent (int mc)
+    { 
+      if (mc >= GetNumMultiDimComponents()) mc = GetNumMultiDimComponents()-1;
+      if (mc < 0) mc = 0;
+      multidimcomponent = mc; 
+    }
+  };
+
+
+  class DLL_HEADER MouseEventHandler
+  {
+  public:
+    virtual void DblClick (int elnr, double x, double y, double z) = 0;
+  };
+
+  
+  class DLL_HEADER UserVisualizationObject
+  {
+  public:
+    virtual ~UserVisualizationObject() { ; } 
+    virtual void Draw () = 0;
+  };
+
+  
+}
+
+#endif
+

netgen/include/meshing/specials.hpp

@@ -0,0 +1,17 @@
+#ifndef FILE_SPECIALS
+#define FILE_SPECIALS
+
+/*
+
+  Very special implementations ..
+  
+ */
+
+namespace netgen {
+///
+DLL_HEADER extern void CutOffAndCombine (Mesh & mesh, const Mesh & othermesh);
+
+DLL_HEADER extern void HelmholtzMesh (Mesh & mesh);
+
+} // namespace netgen
+#endif

netgen/include/meshing/surfacegeom.hpp

@@ -0,0 +1,73 @@
+#ifndef FILE_SURFACEGEOM
+#define FILE_SURFACEGEOM
+
+/* *************************************************************************/
+/* File:   surfacegeom.hpp                                                 */
+/* Author: Michael Neunteufel                                              */
+/* Date:   Jun. 2020                                                       */
+/* *************************************************************************/
+
+
+#include <functional>
+
+
+namespace netgen
+{
+
+  class DLL_HEADER SurfaceGeometry : public NetgenGeometry
+  {
+    function<Vec<3>(Point<2>)> func;
+    double eps=1e-4;
+
+  private:
+
+    void CalcHesse(double u, double v, Vec<3>& f_uu, Vec<3>& f_vv, Vec<3>& f_uv) const;
+  public:
+
+    SurfaceGeometry();
+    SurfaceGeometry(function<Vec<3>(Point<2>)> func);
+    SurfaceGeometry(const SurfaceGeometry& geom);
+    SurfaceGeometry& operator =(const SurfaceGeometry& geom)
+    {
+      func = geom.func;
+      eps = geom.eps;
+      return *this;
+    }
+
+    Array<Vec<3>> GetTangentVectors(double u, double v) const;
+
+    void GetTangentVectors(double u, double v, Array<Vec<3>>& tang) const;
+
+
+    virtual Vec<3> GetNormal(int surfind, const Point<3> & p, const PointGeomInfo* gi) const override;
+
+    virtual PointGeomInfo ProjectPoint(int surfind, Point<3> & p) const override;
+    
+    virtual void ProjectPointEdge (int surfind, int surfind2, Point<3> & p,
+                           EdgePointGeomInfo* gi = nullptr) const override;
+    
+    virtual bool ProjectPointGI (int surfind, Point<3> & p, PointGeomInfo & gi) const override;
+
+    virtual bool CalcPointGeomInfo(int surfind, PointGeomInfo& gi, const Point<3> & p3) const override;
+
+    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 override;
+    
+    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 override;
+
+    int GenerateStructuredMesh(shared_ptr<Mesh> & mesh, bool quads, int nx, int ny, bool flip_triangles, const Array<Point<3>>& bbbpts, const Array<string>& bbbnames, const Array<Point<3>>& hppoints, const Array<float>& hpptsfac, const Array<string>& hpbnd, const Array<float>& hpbndfac, Array<double> layer_thickness[4], bool layer_quad);
+
+  };
+  
+}
+   
+
+
+#endif //SURFACEGEOM