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

netgen/include/meshing/msghandler.hpp

@@ -0,0 +1,62 @@
+#ifndef FILE_MSGHANDLER
+#define FILE_MSGHANDLER
+
+/**************************************************************************/
+/* File:   msghandler.hh                                                  */
+/* Author: Johannes Gerstmayr                                             */
+/* Date:   20. Nov. 99                                                    */
+/**************************************************************************/
+
+#include <general/mystring.hpp>
+
+
+namespace netgen
+{
+
+  extern void PrintDot(char ch = '.');
+
+
+  //Message Pipeline:
+
+  //importance: importance of message: 1=very important, 3=middle, 5=low, 7=unimportant
+  extern DLL_HEADER void PrintMessage(int importance, 
+			   const MyStr& s1, const MyStr& s2=MyStr());
+  extern DLL_HEADER void PrintMessage(int importance, 
+			   const MyStr& s1, const MyStr& s2, const MyStr& s3, const MyStr& s4=MyStr());
+  extern DLL_HEADER void PrintMessage(int importance, 
+			   const MyStr& s1, const MyStr& s2, const MyStr& s3, const MyStr& s4, 
+			   const MyStr& s5, const MyStr& s6=MyStr(), const MyStr& s7=MyStr(), const MyStr& s8=MyStr());
+
+  // CR without line-feed
+  extern DLL_HEADER void PrintMessageCR(int importance, 
+			     const MyStr& s1, const MyStr& s2="", const MyStr& s3="", const MyStr& s4="", 
+			     const MyStr& s5="", const MyStr& s6="", const MyStr& s7="", const MyStr& s8="");
+  extern DLL_HEADER void PrintFnStart(const MyStr& s1, const MyStr& s2="", const MyStr& s3="", const MyStr& s4="", 
+			   const MyStr& s5="", const MyStr& s6="", const MyStr& s7="", const MyStr& s8="");
+  extern DLL_HEADER void PrintWarning(const MyStr& s1, const MyStr& s2="", const MyStr& s3="", const MyStr& s4="", 
+			   const MyStr& s5="", const MyStr& s6="", const MyStr& s7="", const MyStr& s8="");
+  extern DLL_HEADER void PrintError(const MyStr& s1, const MyStr& s2="", const MyStr& s3="", const MyStr& s4="", 
+			 const MyStr& s5="", const MyStr& s6="", const MyStr& s7="", const MyStr& s8="");
+  extern DLL_HEADER void PrintFileError(const MyStr& s1, const MyStr& s2="", const MyStr& s3="", const MyStr& s4="", 
+			     const MyStr& s5="", const MyStr& s6="", const MyStr& s7="", const MyStr& s8="");
+  extern DLL_HEADER void PrintSysError(const MyStr& s1, const MyStr& s2="", const MyStr& s3="", const MyStr& s4="", 
+			    const MyStr& s5="", const MyStr& s6="", const MyStr& s7="", const MyStr& s8="");
+  extern DLL_HEADER void PrintUserError(const MyStr& s1, const MyStr& s2="", const MyStr& s3="", const MyStr& s4="", 
+			     const MyStr& s5="", const MyStr& s6="", const MyStr& s7="", const MyStr& s8="");
+  extern DLL_HEADER void PrintTime(const MyStr& s1="", const MyStr& s2="", const MyStr& s3="", const MyStr& s4="", 
+			const MyStr& s5="", const MyStr& s6="", const MyStr& s7="", const MyStr& s8="");
+
+
+
+
+  inline void PushStatusF(const std::string& s)
+  {
+    PushStatus (s);
+    PrintFnStart(s);
+  }
+
+}
+
+
+#endif
+

netgen/include/meshing/paralleltop.hpp

@@ -0,0 +1,172 @@
+#ifndef FILE_PARALLELTOP
+#define FILE_PARALLELTOP
+
+namespace netgen
+{
+
+
+  class ParallelMeshTopology
+  {
+    const Mesh & mesh;
+
+    /**
+       mapping from local to distant vertex number
+       each row of the table corresponds to one vertex
+       each row contains a list of pairs (procnr, dist_vnum)
+    */
+    
+    DynamicTable<int> loc2distvert;
+    DynamicTable<int> loc2distedge, loc2distface;
+
+    Array<int> glob_vert;
+
+    // will get rid of them
+    NgArray<int> glob_edge, glob_face;
+    NgArray<int> glob_el, glob_surfel, glob_segm;
+
+    bool is_updated;
+
+  public:
+
+    ParallelMeshTopology (const Mesh & amesh);
+    ~ParallelMeshTopology ();
+
+    void Reset ();
+    void Print() const;
+
+    
+    void UpdateCoarseGrid();
+    // [[deprecated("should not need it anymore")]]                    
+    // void UpdateCoarseGridGlobal();
+    void IdentifyVerticesAfterRefinement();
+    void EnumeratePointsGlobally ();
+        
+    void AddDistantProc    (PointIndex pi, int proc) { loc2distvert.AddUnique (pi-IndexBASE<PointIndex>(), proc); }
+    void AddDistantFaceProc (int edge, int proc) { loc2distface.AddUnique (edge, proc); }
+    void AddDistantEdgeProc (int face, int proc) { loc2distedge.AddUnique (face, proc); }
+    
+    FlatArray<int> GetDistantProcs (PointIndex pi) const { return loc2distvert[pi-IndexBASE<PointIndex>()]; }
+    FlatArray<int> GetDistantFaceProcs (int locnum) const { return loc2distface[locnum]; }
+    FlatArray<int> GetDistantEdgeProcs (int locnum) const { return loc2distedge[locnum]; }
+
+
+    
+    auto & L2G (PointIndex pi) { return glob_vert[pi-IndexBASE<PointIndex>()]; } 
+    auto L2G (PointIndex pi) const { return glob_vert[pi-IndexBASE<PointIndex>()]; } 
+
+
+    /// set number of local vertices, reset sizes of loc2dist_vert, isexchangevert...
+    void SetNV (int anv);
+    void SetNV_Loc2Glob (int anv);
+    void SetNE (int ane);
+    void SetNSE (int anse);
+    void SetNSegm (int anseg);
+
+    [[deprecated("Use AddDistantFaceProc instead!")]]                
+    void SetDistantFaceNum (int dest, int locnum) { loc2distface.AddUnique (locnum-1, dest); }
+    [[deprecated("Use AddDistantProc instead!")]]                
+    void SetDistantPNum    (int dest, int locnum) { loc2distvert.AddUnique (locnum-1, dest); }
+    [[deprecated("Use AddDistantEdgeProc instead!")]]                
+    void SetDistantEdgeNum (int dest, int locnum) { loc2distedge.AddUnique (locnum-1, dest); }
+
+    [[deprecated("Use GetDistantFaceProcx instead!")]]                    
+    FlatArray<int> GetDistantFaceNums (int locnum) const { return loc2distface[locnum]; }
+    [[deprecated("Use GetDistantEdgeProcx instead!")]]
+    FlatArray<int> GetDistantEdgeNums (int locnum) const { return loc2distedge[locnum]; }
+
+
+    
+    [[deprecated("Use L2G(pi) instead!")]]                
+    void SetLoc2Glob_Vert   (int locnum, int globnum) { glob_vert[locnum-1] = globnum; }
+    [[deprecated("Try to avoid global enumration!")]]                
+    void SetLoc2Glob_Edge   (int locnum, int globnum) { glob_edge[locnum-1] = globnum; }
+    [[deprecated("Try to avoid global enumration!")]]                
+    void SetLoc2Glob_Face   (int locnum, int globnum) { glob_face[locnum-1] = globnum; }
+    // [[deprecated("Try to avoid global enumration!")]]                
+    void SetLoc2Glob_VolEl  (int locnum, int globnum) { glob_el[locnum-1] = globnum; }
+    // [[deprecated("Try to avoid global enumration!")]]                
+    void SetLoc2Glob_SurfEl (int locnum, int globnum) { glob_surfel[locnum-1] = globnum; }
+    // [[deprecated("Try to avoid global enumration!")]]                
+    void SetLoc2Glob_Segm   (int locnum, int globnum) { glob_segm[locnum-1] = globnum; }
+
+    // [[deprecated("Try to avoid global enumration!")]]                    
+    int GetGlobalPNum    (PointIndex locnum) const { return glob_vert[locnum-IndexBASE<PointIndex>()]; }
+    [[deprecated("Try to avoid global enumration!")]]                
+    int GetGlobalEdgeNum (int locnum) const { return glob_edge[locnum-1]; }
+    [[deprecated("Try to avoid global enumration!")]]                
+    int GetGlobalFaceNum (int locnum) const { return glob_face[locnum-1]; }
+    [[deprecated("Try to avoid global enumration!")]]                
+    int GetGlobalElNum   (int locnum) const { return glob_el[locnum-1]; }
+    [[deprecated("Try to avoid global enumration!")]]                
+    int GetGlobalSElNum  (int locnum) const { return glob_surfel[locnum-1]; }
+
+    
+
+    // [[deprecated("Use GetDistantPNums(locnum).Size() instead!")]]            
+    int GetNDistantPNums (int locpnum) const { return loc2distvert[locpnum-1].Size(); }
+
+    // [[deprecated("Use GetDistantFaceNums(locnum).Size() instead!")]]                
+    int GetNDistantFaceNums (int locfacenum) const { return loc2distface[locfacenum-1].Size(); }
+
+    // [[deprecated("Use GetDistantEdgeNums(locnum).Size() instead!")]]                    
+    int GetNDistantEdgeNums ( int locedgenum) const { return loc2distedge[locedgenum-1].Size(); }
+
+    // [[deprecated("Use GetDistantPNums(locnum) -> FlatArray instead!")]]                
+    void GetDistantPNums (int locpnum, int * distpnums ) const
+    {
+      for (int i = 0; i < loc2distvert[locpnum-1].Size(); i++ )
+	distpnums[i] = loc2distvert[locpnum-1][i];
+    } 
+
+    // [[deprecated("Use GetDistantFaceNums(locnum) -> FlatArray instead!")]]                    
+    void GetDistantFaceNums (int locfacenum, int * distfacenums ) const
+    {
+      for ( int i = 0; i < loc2distface[locfacenum-1].Size(); i++ )
+	distfacenums[i] = loc2distface[locfacenum-1][i];
+    } 
+
+    // [[deprecated("Use GetDistantFaceNums(locnum) -> FlatArray instead!")]]                        
+    void GetDistantFaceNums (int locfacenum, NgArray<int> & distfacenums ) const
+    {
+      // distfacenums = loc2distface[locfacenum-1];
+      auto loc = loc2distface[locfacenum-1];
+      distfacenums.SetSize (loc.Size());
+      for (int i = 0; i < loc.Size(); i++)
+        distfacenums[i] = loc[i];
+    }
+
+    // [[deprecated("Use GetDistantEdgeNums(locnum) -> FlatArray instead!")]]                            
+    void GetDistantEdgeNums (int locedgenum, int * distedgenums ) const
+    {
+      for (int i = 0; i < loc2distedge[locedgenum-1].Size(); i++ )
+	distedgenums[i] = loc2distedge[locedgenum-1][i];
+    } 
+
+    // [[deprecated("Use GetDistantEdgeNums(locnum) -> FlatArray instead!")]]                                
+    void GetDistantEdgeNums (int locedgenum, NgArray<int> & distedgenums ) const
+    {
+      // distedgenums = loc2distedge[locedgenum-1];
+      auto loc = loc2distedge[locedgenum-1];
+      distedgenums.SetSize (loc.Size());
+      for (int i = 0; i < loc.Size(); i++)
+        distedgenums[i] = loc[i];
+    } 
+
+    [[deprecated("Use GetDistantProcs(..)!")]]                    
+    FlatArray<int> GetDistantPNums (int locnum) const { return loc2distvert[locnum]; }
+
+
+    
+    [[deprecated("Use GetDistantProcs(..).Contains instead!")]]                
+    bool IsExchangeVert (int dest, int vnum) const
+    {
+      return loc2distvert[vnum-1].Contains (dest);
+    }
+  };
+
+}
+
+
+
+
+#endif

netgen/include/meshing/python_mesh.hpp

@@ -0,0 +1,206 @@
+#ifndef NETGEN_MESHING_PYTHON_MESH_HPP
+#define NETGEN_MESHING_PYTHON_MESH_HPP
+
+#include <core/python_ngcore.hpp>
+
+#include "meshing.hpp"
+
+namespace netgen
+{
+  // TODO: Clarify a lot of these parameters
+  static string meshingparameter_description = R"delimiter(
+Meshing Parameters
+-------------------
+
+maxh: float = 1e10
+  Global upper bound for mesh size.
+
+grading: float = 0.3
+  Mesh grading how fast the local mesh size can change.
+
+meshsizefilename: str = None
+  Load meshsize from file. Can set local mesh size for points
+  and along edges. File must have the format:
+
+    nr_points
+    x1, y1, z1, meshsize
+    x2, y2, z2, meshsize
+    ...
+    xn, yn, zn, meshsize
+
+    nr_edges
+    x11, y11, z11, x12, y12, z12, meshsize
+    ...
+    xn1, yn1, zn1, xn2, yn2, zn2, meshsize
+
+segmentsperedge: float = 1.
+  Minimal number of segments per edge.
+
+quad_dominated: bool = False
+  Quad-dominated surface meshing.
+
+blockfill: bool = True
+  Do fast blockfilling.
+
+filldist: float = 0.1
+  Block fill up to distance
+
+delaunay: bool = True
+  Use delaunay meshing.
+
+delaunay2d : bool = True
+  Use delaunay meshing for 2d geometries.
+
+Optimization Parameters
+-----------------------
+
+optimize3d: str = "cmdmustm"
+  3d optimization strategy:
+    m .. move nodes
+    M .. move nodes, cheap functional
+    s .. swap faces
+    c .. combine elements
+    d .. divide elements
+    p .. plot, no pause
+    P .. plot, Pause
+    h .. Histogramm, no pause
+    H .. Histogramm, pause
+
+optsteps3d: int = 3
+  Number of 3d optimization steps.
+
+optimize2d: str = "smcmSmcmSmcm"
+  2d optimization strategy:
+    s .. swap, opt 6 lines/node
+    S .. swap, optimal elements
+    m .. move nodes
+    p .. plot, no pause
+    P .. plot, pause
+    c .. combine
+
+optsteps2d: int = 3
+  Number of 2d optimization steps.
+
+elsizeweight: float = 0.2
+  Weight of element size w.r.t. element shape in optimization.
+
+)delimiter";
+
+inline void CreateMPfromKwargs(MeshingParameters& mp, py::kwargs kwargs, bool throw_if_not_all_parsed=true)
+  {
+    if(kwargs.contains("optimize3d"))
+      mp.optimize3d = py::cast<string>(kwargs.attr("pop")("optimize3d"));
+    if(kwargs.contains("optsteps3d"))
+      mp.optsteps3d = py::cast<int>(kwargs.attr("pop")("optsteps3d"));
+    if(kwargs.contains("optimize2d"))
+      mp.optimize2d = py::cast<string>(kwargs.attr("pop")("optimize2d"));
+    if(kwargs.contains("optsteps2d"))
+      mp.optsteps2d = py::cast<int>(kwargs.attr("pop")("optsteps2d"));
+    if(kwargs.contains("opterrpow"))
+      mp.opterrpow = py::cast<double>(kwargs.attr("pop")("opterrpow"));
+    if(kwargs.contains("blockfill"))
+      mp.blockfill = py::cast<bool>(kwargs.attr("pop")("blockfill"));
+    if(kwargs.contains("filldist"))
+      mp.filldist = py::cast<double>(kwargs.attr("pop")("filldist"));
+    if(kwargs.contains("safety"))
+      mp.safety = py::cast<double>(kwargs.attr("pop")("safety"));
+    if(kwargs.contains("relinnersafety"))
+      mp.relinnersafety = py::cast<double>(kwargs.attr("pop")("relinnersafety"));
+    if(kwargs.contains("uselocalh"))
+      mp.uselocalh = py::cast<bool>(kwargs.attr("pop")("uselocalh"));
+    if(kwargs.contains("grading"))
+      mp.grading = py::cast<double>(kwargs.attr("pop")("grading"));
+    if(kwargs.contains("delaunay"))
+      mp.delaunay = py::cast<bool>(kwargs.attr("pop")("delaunay"));
+    if(kwargs.contains("delaunay2d"))
+      mp.delaunay2d = py::cast<bool>(kwargs.attr("pop")("delaunay2d"));
+    if(kwargs.contains("maxh"))
+      mp.maxh = py::cast<double>(kwargs.attr("pop")("maxh"));
+    if(kwargs.contains("minh"))
+      mp.minh = py::cast<double>(kwargs.attr("pop")("minh"));
+    if(kwargs.contains("meshsizefilename"))
+      mp.meshsizefilename = py::cast<string>(kwargs.attr("pop")("meshsizefilename"));
+    if(kwargs.contains("startinsurface"))
+      mp.startinsurface = py::cast<bool>(kwargs.attr("pop")("startinsurface"));
+    if(kwargs.contains("checkoverlap"))
+      mp.checkoverlap = py::cast<bool>(kwargs.attr("pop")("checkoverlap"));
+    if(kwargs.contains("checkoverlappingboundary"))
+      mp.checkoverlappingboundary = py::cast<bool>(kwargs.attr("pop")("checkoverlappingboundary"));
+    if(kwargs.contains("checkchartboundary"))
+      mp.checkchartboundary = py::cast<bool>(kwargs.attr("pop")("checkchartboundary"));
+    if(kwargs.contains("curvaturesafety"))
+      mp.curvaturesafety = py::cast<double>(kwargs.attr("pop")("curvaturesafety"));
+    if(kwargs.contains("segmentsperedge"))
+      mp.segmentsperedge = py::cast<double>(kwargs.attr("pop")("segmentsperedge"));
+    if(kwargs.contains("parthread"))
+      mp.parthread = py::cast<bool>(kwargs.attr("pop")("parthread"));
+    if(kwargs.contains("elsizeweight"))
+      mp.elsizeweight = py::cast<double>(kwargs.attr("pop")("elsizeweight"));
+    if(kwargs.contains("perfstepsstart"))
+      mp.perfstepsstart = py::cast<int>(kwargs.attr("pop")("perfstepsstart"));
+    if(kwargs.contains("perfstepsend"))
+      mp.perfstepsend = py::cast<int>(kwargs.attr("pop")("perfstepsend"));
+    if(kwargs.contains("giveuptol2d"))
+      mp.giveuptol2d = py::cast<int>(kwargs.attr("pop")("giveuptol2d"));
+    if(kwargs.contains("giveuptol"))
+      mp.giveuptol = py::cast<int>(kwargs.attr("pop")("giveuptol"));
+    if(kwargs.contains("giveuptolopenquads"))
+      mp.giveuptolopenquads = py::cast<int>(kwargs.attr("pop")("giveuptolopenquads"));
+    if(kwargs.contains("maxoutersteps"))
+      mp.maxoutersteps = py::cast<int>(kwargs.attr("pop")("maxoutersteps"));
+    if(kwargs.contains("starshapeclass"))
+      mp.starshapeclass = py::cast<int>(kwargs.attr("pop")("starshapeclass"));
+    if(kwargs.contains("baseelnp"))
+      mp.baseelnp = py::cast<int>(kwargs.attr("pop")("baseelnp"));
+    if(kwargs.contains("sloppy"))
+      mp.sloppy = py::cast<int>(kwargs.attr("pop")("sloppy"));
+    if(kwargs.contains("badellimit"))
+      mp.badellimit = py::cast<double>(kwargs.attr("pop")("badellimit"));
+    if(kwargs.contains("check_impossible"))
+      mp.check_impossible = py::cast<bool>(kwargs.attr("pop")("check_impossible"));
+    if(kwargs.contains("only3D_domain_nr"))
+      mp.only3D_domain_nr = py::cast<int>(kwargs.attr("pop")("only3D_domain_nr"));
+    if(kwargs.contains("secondorder"))
+      mp.secondorder = py::cast<bool>(kwargs.attr("pop")("secondorder"));
+    if(kwargs.contains("elementorder"))
+      mp.elementorder = py::cast<int>(kwargs.attr("pop")("elementorder"));
+    if(kwargs.contains("quad"))
+      {
+        cout << "WARNING: Meshing parameter 'quad' is deprecated, use 'quad_dominated' instead!" << endl;
+        mp.quad = py::cast<bool>(kwargs.attr("pop")("quad"));
+      }
+    if(kwargs.contains("quad_dominated"))
+      mp.quad = py::cast<bool>(kwargs.attr("pop")("quad_dominated"));
+    if(kwargs.contains("try_hexes"))
+      mp.try_hexes = py::cast<bool>(kwargs.attr("pop")("try_hexes"));
+    if(kwargs.contains("inverttets"))
+      mp.inverttets = py::cast<bool>(kwargs.attr("pop")("inverttets"));
+    if(kwargs.contains("inverttrigs"))
+      mp.inverttrigs = py::cast<bool>(kwargs.attr("pop")("inverttrigs"));
+    if(kwargs.contains("autozrefine"))
+      mp.autozrefine = py::cast<bool>(kwargs.attr("pop")("autozrefine"));
+    if(kwargs.contains("parallel_meshing"))
+      mp.parallel_meshing = py::cast<bool>(kwargs.attr("pop")("parallel_meshing"));
+    if(kwargs.contains("nthreads"))
+      mp.nthreads = py::cast<int>(kwargs.attr("pop")("nthreads"));
+    if(kwargs.contains("closeedgefac"))
+      mp.closeedgefac = py::cast<optional<double>>(kwargs.attr("pop")("closeedgefac"));
+
+    if(kwargs.contains("boundary_layers"))
+    {
+      auto layers = py::list(kwargs.attr("pop")("boundary_layers"));
+      for(auto layer : layers)
+        mp.boundary_layers.Append(py::cast<BoundaryLayerParameters>(layer));
+    }
+
+    if(kwargs.size())
+    {
+      if(throw_if_not_all_parsed)
+        throw Exception(string("Not all kwargs given to GenerateMesh could be parsed:") + string(py::str(kwargs)));
+      mp.geometrySpecificParameters = CreateFlagsFromKwArgs(kwargs);
+    }
+  }
+} // namespace netgen
+
+#endif // NETGEN_MESHING_PYTHON_MESH_HPP
+ 

netgen/include/meshing/ruler2.hpp

@@ -0,0 +1,172 @@
+#ifndef FILE_NETRULE
+#define FILE_NETRULE
+
+namespace netgen
+{
+///
+class netrule
+{
+private:
+  ///
+  typedef struct tf 
+  { float f1, f2, f3; }   threefloat;
+  
+  class threeint 
+  { 
+  public: int i1, i2, i3; 
+    threeint() { } 
+    threeint(int ai1, int ai2, int ai3) 
+    { i1 = ai1; i2 = ai2; i3 = ai3; } 
+  };
+
+
+  ///
+  int quality;
+  ///
+  string name;
+  ///
+  NgArray<Point<2>> points;
+  ///
+  NgArray<INDEX_2> lines;
+  ///
+  NgArray<Point<2>> freezone, freezonelimit;
+  ///
+  NgArray<NgArray<Point<2>>> freezone_i;
+  ///
+  NgArray<Point<2>> transfreezone;
+
+  ///
+  NgArray<int> dellines;
+  ///
+  NgArray<Element2d> elements;
+  ///
+  NgArray<threefloat> tolerances, linetolerances;
+  ///
+  NgArray<threeint> orientations;
+  ///
+  DenseMatrix oldutonewu, oldutofreearea, oldutofreearealimit;
+  ///
+  NgArray<DenseMatrix> oldutofreearea_i;
+  ///
+  MatrixFixWidth<3> freesetinequ;
+
+  ///
+  NgArray<Vec<2>> linevecs;
+
+  ///
+  int noldp, noldl;
+  ///
+  float fzminx, fzmaxx, fzminy, fzmaxy;
+
+  /// topological distance of line to base element
+  NgArray<int> lnearness;
+
+public:
+
+  ///
+  netrule ();
+  ///
+  ~netrule();
+
+  ///
+  int GetNP () const { return points.Size(); }
+  ///
+  int GetNL () const { return lines.Size(); }
+  ///
+  int GetNE () const { return elements.Size(); }
+  ///
+  int GetNOldP () const { return noldp; }
+  ///
+  int GetNOldL () const { return noldl; }
+  ///
+  int GetNDelL () const { return dellines.Size(); }
+  ///
+  int GetNOrientations () const { return orientations.Size(); }
+  ///
+  int GetQuality () const { return quality; }
+  ///
+  int GetLNearness (int li) const { return lnearness.Get(li); }
+
+  ///
+  const Point<2>& GetPoint (int i) const { return points.Get(i); }
+  ///
+  const INDEX_2 & GetLine (int i) const { return lines.Get(i); }
+  ///
+  const Element2d & GetElement (int i) const { return elements.Get(i); }
+  ///
+  const threeint & GetOrientation (int i) const { return orientations.Get(i); }
+  ///
+  int GetDelLine (int i) const { return dellines.Get(i); }
+  ///
+  const NgArray<int> & GetDelLines() const { return dellines; }
+  ///
+  void GetFreeZone (NgArray<Point<2>> & afreearea);
+  ///
+
+  double CalcPointDist (int pi, const Point<2> & p) const
+  {
+    double dx = p[0] - points.Get(pi)[0];
+    double dy = p[1] - points.Get(pi)[1];
+    const threefloat * tfp = &tolerances.Get(pi);
+    return tfp->f1 * dx * dx + tfp->f2 * dx * dy + tfp->f3 * dy * dy;
+  }
+
+  ///
+  float CalcLineError (int li, const Vec<2>& v) const;
+
+  ///
+  void SetFreeZoneTransformation (const Vector & u, int tolclass);
+
+  ///
+  bool IsInFreeZone (const Point<2> & p) const
+  {
+    if (p[0] < fzminx || p[0] > fzmaxx ||
+	p[1] < fzminy || p[1] > fzmaxy) return 0;
+
+    for (int i = 0; i < transfreezone.Size(); i++)
+      {
+	if (freesetinequ(i, 0) * p[0] + 
+	    freesetinequ(i, 1) * p[1] +
+	    freesetinequ(i, 2) > 0) return 0;
+      }
+    return 1;
+  }
+
+  ///
+  int IsLineInFreeZone (const Point<2> & p1, const Point<2> & p2) const
+  {
+    if ( (p1[0] > fzmaxx && p2[0] > fzmaxx) ||
+         (p1[0] < fzminx && p2[0] < fzminx) ||
+         (p1[1] > fzmaxy && p2[1] > fzmaxy) ||
+         (p1[1] < fzminy && p2[1] < fzminy) ) return 0;
+    return IsLineInFreeZone2 (p1, p2);
+  }
+  ///
+  int IsLineInFreeZone2 (const Point<2> & p1, const Point<2> & p2) const;
+  ///
+  int ConvexFreeZone () const;
+  ///
+  const NgArray<Point<2>> & GetTransFreeZone () { return transfreezone; }
+
+  ///
+  int GetPointNr (int ln, int endp) const { return lines.Get(ln).I(endp); }
+
+  ///
+  const DenseMatrix & GetOldUToNewU () const { return oldutonewu; }
+  ///
+  const DenseMatrix & GetOldUToFreeArea () const { return oldutofreearea; }
+  ///
+  const string & Name () const { return name; }
+
+  ///
+  void LoadRule (istream & ist);
+};
+
+
+
+/** Draws 2D rules.
+    Visual testing of 2D meshing rules */
+extern void DrawRules ();
+} // namespace netgen
+#endif
+