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

netgen/include/meshing/hprefinement.hpp

@@ -0,0 +1,366 @@
+#ifndef FILE_HPREFINEMENT
+#define FILE_HPREFINEMENT
+
+/**************************************************************************/
+/* File:   hprefinement.hh                                                */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   27. Oct. 2000                                                  */
+/**************************************************************************/
+
+/*
+  HP Refinement
+*/
+
+#include "bisect.hpp"
+#include "meshtype.hpp"
+
+namespace netgen
+{
+
+
+enum HPREF_ELEMENT_TYPE {
+  HP_NONE=0,
+
+  HP_SEGM = 1,
+  HP_SEGM_SINGCORNERL,
+  HP_SEGM_SINGCORNERR,
+  HP_SEGM_SINGCORNERS,
+
+  HP_TRIG = 10,
+  HP_TRIG_SINGCORNER,
+  HP_TRIG_SINGCORNER12,
+  HP_TRIG_SINGCORNER123,
+  HP_TRIG_SINGCORNER123_2D,   // not rotational symmetric
+  HP_TRIG_SINGEDGE = 20,
+  HP_TRIG_SINGEDGECORNER1,   // E = 100, V = 100
+  HP_TRIG_SINGEDGECORNER2,   // E = 100, V = 010
+  HP_TRIG_SINGEDGECORNER12,  // E = 100, V = 110
+  HP_TRIG_SINGEDGECORNER3,
+  HP_TRIG_SINGEDGECORNER13,
+  HP_TRIG_SINGEDGECORNER23,
+  HP_TRIG_SINGEDGECORNER123,
+  HP_TRIG_SINGEDGES = 30,
+  HP_TRIG_SINGEDGES2,
+  HP_TRIG_SINGEDGES3,
+  HP_TRIG_SINGEDGES23,
+  HP_TRIG_3SINGEDGES = 40,
+
+  HP_TRIG_ALFELD,
+  HP_TRIG_POWELL,
+  
+  HP_QUAD = 50,
+  HP_QUAD_SINGCORNER,
+  HP_DUMMY_QUAD_SINGCORNER,
+  HP_QUAD_SINGEDGE,
+  HP_QUAD_0E_2VA,  // V = 1100
+  HP_QUAD_0E_2VB,  // V = 1010
+  HP_QUAD_0E_3V,
+  HP_QUAD_0E_4V,
+
+  // one edge: marked edge is always edge from vertex 1 to vertex 2 (E = 1000)
+  HP_QUAD_1E_1VA,  // vertex on beginning of edge: V = 1000
+  HP_QUAD_1E_1VB,  // vertex on end of edge: V = 0100
+  HP_QUAD_1E_1VC,  // V = 0010
+  HP_QUAD_1E_1VD,  // V = 0001
+
+  HP_QUAD_1E_2VA,  // V = 1100
+  HP_QUAD_1E_2VB,  // V = 1010
+  HP_QUAD_1E_2VC,  // V = 1001
+  HP_QUAD_1E_2VD,  // V = 0110
+  HP_QUAD_1E_2VE,  // V = 0101
+  HP_QUAD_1E_2VF,  // V = 0011
+
+  HP_QUAD_1E_3VA,  // V = 1110
+  HP_QUAD_1E_3VB,  // V = 1101
+  HP_QUAD_1E_3VC,  // V = 1011
+  HP_QUAD_1E_3VD,  // V = 0111
+
+  HP_QUAD_1E_4V,   // V = 1111
+
+
+  HP_QUAD_2E,      // E = 1001, V = 1000
+  HP_QUAD_2E_1VA,  // E = 1001, V = 1100
+  HP_QUAD_2E_1VB,  // E = 1001, V = 1010
+  HP_QUAD_2E_1VC,  // E = 1001, V = 1001
+  HP_QUAD_2E_2VA,  // E = 1001, V = 1110
+  HP_QUAD_2E_2VB,  // E = 1001, V = 1101
+  HP_QUAD_2E_2VC,  // E = 1001, V = 1011
+  HP_QUAD_2E_3V,   // E = 1001, V = 1111
+
+  HP_QUAD_2EB_0V,   // E = 1010, V = 0000
+  HP_QUAD_2EB_1VA,  // E = 1010, V = 1000
+  HP_QUAD_2EB_1VB,  // E = 1010, V = 0100
+  HP_QUAD_2EB_2VA,  // E = 1010, V = 1100
+  HP_QUAD_2EB_2VB,  // E = 1010, V = 1010
+  HP_QUAD_2EB_2VC,  // E = 1010, V = 1001
+  HP_QUAD_2EB_2VD,  // E = 1010, V = 0101
+  HP_QUAD_2EB_3VA,  // E = 1010, V = 1110
+  HP_QUAD_2EB_3VB,  // E = 1010, V = 1101
+
+  HP_QUAD_2EB_4V,
+
+
+  HP_QUAD_3E,      // E = 1101, V = 1100
+  HP_QUAD_3E_3VA,  // E = 1101, V = 1110
+  HP_QUAD_3E_3VB,  // E = 1101, V = 1101
+  HP_QUAD_3E_4V,   // E = 1101, V = 1111
+
+  HP_QUAD_4E,
+
+
+  HP_TET = 100,     // no singular vertex/edge
+  HP_NONETET,       // make void
+  HP_TET_0E_1V,     // V1
+  HP_TET_0E_2V,     // V1,2
+  HP_TET_0E_3V,     // V1,2,3  
+  HP_TET_0E_4V,     // V1,2,3,4
+  HP_TET_1E_0V = 200,   // E1-2
+  HP_TET_1E_1VA,    // V1
+  HP_TET_1E_1VB,    // V3
+  HP_TET_1E_2VA,    // V1,2
+  HP_TET_1E_2VB,    // V1,3
+  HP_TET_1E_2VC,    // V1,4
+  HP_TET_1E_2VD,    // V3,4
+  HP_TET_1E_3VA,    // V1,2,3
+  HP_TET_1E_3VB,    // V1,3,4
+  HP_TET_1E_4V,     // V1,2,3,4
+
+
+  // 2 connected edges, additionally marked Vs
+  HP_TET_2EA_0V = 220,    // E1-2, E1-3
+  HP_TET_2EA_1VA,   // V2
+  HP_TET_2EA_1VB,   // V3
+  HP_TET_2EA_1VC,   // V4
+  HP_TET_2EA_2VA,   // V2,3
+  HP_TET_2EA_2VB,   // V2,4
+  HP_TET_2EA_2VC,   // V3,4
+  HP_TET_2EA_3V,    // V2,3,4
+
+  // 2 opposite edges
+  HP_TET_2EB_0V = 230,    // E1-2, E3-4
+  HP_TET_2EB_1V,    // V1
+  HP_TET_2EB_2VA,   // V1,2
+  HP_TET_2EB_2VB,   // V1,3
+  HP_TET_2EB_2VC,   // V1,4
+  HP_TET_2EB_3V,    // V1,2,3
+  HP_TET_2EB_4V,    // V1,2,3,4
+
+  HP_TET_3EA_0V = 400,  // E1-2, E1-3, E1-4, 3 edges connected
+  HP_TET_3EA_1V,        // V2
+  HP_TET_3EA_2V,        // V2,3
+  HP_TET_3EA_3V,        // V2,3,4
+
+  HP_TET_3EB_0V = 420,  // E1-2, E1-4, E2-3  3 edges chain
+  HP_TET_3EB_1V,        // 
+  HP_TET_3EB_2V,        // 
+  HP_TET_3EC_0V = 430,  // 3 edges chain, alter
+  HP_TET_3EC_1V,        // 3 edges chain, alter
+  HP_TET_3EC_2V,        // 3 edges chain, alter
+  HP_TET_3ED_3V,        // 3 edges in a loop  e12, e13, e23     NEW .. done
+
+
+  HP_TET_1F_0E_0V = 500,  // 1 singular face
+  HP_TET_1F_0E_1VA,       // 1 sing vertex in face (V2)          FIX ... (needs HEX7)
+  HP_TET_1F_0E_1VB,       // 1 sing vertex not in face (V1)
+  HP_TET_1F_0E_2V,        // 2 sing vertex in face (V2,V3)       NEW .. done
+  HP_TET_1F_0E_3V,        // 3 sing vertex in face (V2,V3,V4)    NEWNEW 
+  HP_TET_1F_1EA_0V,       // 1 sing edge not in face
+  HP_TET_1F_1EB_0V,       // 1 sing edge in face
+  HP_TET_1F_1E_1VA,       // 1 sing edge in face e23, sing vert 2        NEW  done
+  HP_TET_1F_1E_1VB,       // 1 sing edge in face e24, sing vert 2        NEW  done
+  HP_TET_1F_1E_2VA,      //  1 sing edge not in face (e12), sing v2,v3      NEW  done
+  HP_TET_1F_1E_2VB,       // 1 sing edge not in face (e12), sing v2,v4      NEW  done
+  HP_TET_1F_1E_2VC,       // 1 sing edge not in face (e12), sing v3,v4      NEW
+  HP_TET_1F_1EA_3V,        // 1 sing edge out of face e12, sing v2, v3, v4    NEWNEW   WIP, need Pyramid with 1 sing trig-face
+  HP_TET_1F_1E_3V,        // 1 sing edge in face e23, sing v2, v3, v4       NEWNEW  done
+  HP_TET_1F_2Eoo_3V,      // 2e out of face: f234, e12, e13, v1,v2,v3       NEWNEW
+  HP_TET_1F_2E_0VA,       // edge6 && fedge3  .. 1 in face, 1 not in face    NEW done
+  HP_TET_1F_2E_0VB,       // edge6 && fedge2  .. 1 in face, 1 not in face    NEW done
+  HP_TET_1F_2E_1V,        // e4,e5 (E23,E24), V2                            NEW NEW         WIP
+  HP_TET_1F_2E_3V,        // e4,e5 (E23,E24), V2,V3,V4                     NEW NEW  done
+
+  HP_TET_2F_0E_0V = 600,  // 2 singular faces
+  HP_TET_2F_0E_1V,      // 2 singular faces f234, f134, sing point V4     NEW
+  HP_TET_2F_1E_0VA,  // 2 singular faces, sing edge e4               NEW  done 
+  HP_TET_2F_1E_0VB,  // 2 singular faces, sing edge e5               NEW  done
+
+  HP_TET_2F_1E_3VA,  // 2 singular faces f234,f134, e23, v2,v3,v4        NEW3
+  HP_TET_2F_1E_4VA,  // 2 singular faces f234,f134, e23, v2,v3,v4        NEW3  
+  
+  HP_TET_3F_0E_0V = 700,  // 3 singular faces, no additional points or edges  NEW   done 
+
+  HP_TET_ALFELD,
+  
+  HP_PRISM = 1000,
+  HP_PRISM_SINGEDGE,
+  HP_PRISM_SINGEDGE_V12,
+  HP_PRISM_SINGEDGE_H1,
+  HP_PRISM_SINGEDGE_H12,
+
+  HP_PRISM_1FA_0E_0V,     // 1 singular trig face
+  HP_PRISM_2FA_0E_0V,     // 2 singular trig faces
+  HP_PRISM_1FB_0E_0V,     // 1 singular quad face  1-2-4-5
+
+  HP_PRISM_1FB_1EA_0V,     // 1 singular quad face, edge is 1-4
+  HP_PRISM_1FA_1E_0V,       
+  HP_PRISM_2FA_1E_0V, 
+  HP_PRISM_1FA_1FB_0E_0V, 
+  HP_PRISM_2FA_1FB_0E_0V,
+  HP_PRISM_1FA_1FB_1EA_0V, 
+  HP_PRISM_1FA_1FB_1EB_0V, 
+  HP_PRISM_2FA_1FB_1EA_0V,
+  HP_PRISM_1FB_1EC_0V, 
+  HP_PRISM_1FA_1FB_1EC_0V, 
+  HP_PRISM_2FA_1FB_1EC_0V,
+  HP_PRISM_1FB_2EA_0V, 
+  HP_PRISM_1FA_1FB_2EA_0V, 
+  HP_PRISM_2FA_1FB_2EA_0V,
+  HP_PRISM_1FB_2EB_0V,
+  HP_PRISM_1FA_1FB_2EB_0V,  
+  HP_PRISM_1FA_1FB_2EC_0V, 
+  HP_PRISM_2FA_1FB_2EB_0V, 
+  HP_PRISM_1FB_3E_0V, 
+  HP_PRISM_1FA_1FB_3E_0V, 
+  HP_PRISM_2FA_1FB_3E_0V, 
+  HP_PRISM_2FB_0E_0V, 
+  HP_PRISM_1FA_2FB_0E_0V, 
+  HP_PRISM_2FA_2FB_0E_0V,
+  HP_PRISM_2FB_1EC_0V, 
+  HP_PRISM_1FA_2FB_1EC_0V,
+  HP_PRISM_1FA_2FB_1EB_0V,
+  HP_PRISM_2FA_2FB_1EC_0V,
+  HP_PRISM_2FB_3E_0V, 
+  HP_PRISM_1FA_2FB_3E_0V, 
+  HP_PRISM_2FA_2FB_3E_0V, 
+  HP_PRISM_1FA_2E_0V, 
+  HP_PRISM_2FA_2E_0V,
+  HP_PRISM_3E_0V, 
+  HP_PRISM_1FA_3E_0V, 
+  HP_PRISM_2FA_3E_0V,  
+  HP_PRISM_3FB_0V, 
+  HP_PRISM_1FA_3FB_0V, 
+  HP_PRISM_2FA_3FB_0V,  
+  HP_PRISM_3E_4EH,
+  
+ 
+
+  /*  HP_PRISM_1FB_1EA_0V,     // 1 singular quad face, edge is 1-4
+  HP_PRISM_1FB_1EB_0V,     // 1 singular quad face, edge is 2-5
+  HP_PRISM_2F_0E_0V,      // 2 singular quad faces
+  */
+
+  HP_PYRAMID = 2000,
+  HP_PYRAMID_0E_1V,
+  HP_PYRAMID_EDGES,
+  HP_PYRAMID_1FB_0E_0V,   // 1 trig face F125
+  HP_PYRAMID_1FB_0E_1VA,  // 1 trig face, top vertex
+
+  HP_HEX = 3000,
+  HP_HEX_0E_1V,
+  HP_HEX_1E_1V,
+  HP_HEX_1E_0V,
+  HP_HEX_3E_0V,
+  HP_HEX_1F_0E_0V,
+  HP_HEX_1FA_1FB_0E_0V,
+
+  HP_HEX7 = 3100,
+  HP_HEX7_1FA,      // singular quad face 1,2,3,4
+  HP_HEX7_1FB       // singular trig face 5,6,7
+};
+
+
+
+struct HPRef_Struct {
+  HPREF_ELEMENT_TYPE geom;
+  int (*splitedges)[3];
+  int (*splitfaces)[4];
+  int (*splitelements)[5];
+  HPREF_ELEMENT_TYPE * neweltypes;
+  int (*newels)[8];
+};
+
+
+
+
+class HPRefElement
+{
+private:
+  void Reset(void);
+
+public:
+  HPRefElement (); 
+  HPRefElement(Element & el);
+  HPRefElement(Element2d & el);
+  HPRefElement(Segment & el);	
+  HPRefElement(HPRefElement & el);
+
+  void SetType( HPREF_ELEMENT_TYPE t);
+  // HPRefElement(HPRefElement & el, HPREF_ELEMENT_TYPE t); 
+	       
+  /* HPRefElement(HPRefElement & el, HPREF_ELEMENT_TYPE t)
+  { 
+    type = t; 
+    HPRef_Struct * hprs = Get_HPRef_Struct(t);
+    for (int i=0; i<np ; i++) 
+      {
+	pnums[i] = el[i];
+	for(int l=0; l<np; l++) param[i][l] = el.param[i][l]; 
+      }
+    switch(hprs->geom)
+      {
+      case HP_SEGM: np=2; sing_edge_left=0; sing_edge_right=0; break; 
+      case HP_QUAD: np=4; break; 
+      case HP_TRIG: np=3; break; 
+      case HP_HEX: np=8; break; 
+      case HP_PRISM: np=6; break;
+      case HP_TET: np=4; break; 
+      case HP_PYRAMID: np=5; break; 
+      }
+    index = el.index; 
+    levelx = el.levelx; 
+    levely = el.levely; 
+    levelz = el.levelz; 
+    type = el.type; 
+    coarse_elnr = el.coarse_elnr;
+    singedge_left = el.singedge_left; 
+    singedge_right = el.singedge_left; 
+    } */ 
+  
+  HPREF_ELEMENT_TYPE type;
+  PointIndex pnums[8];
+  double param[8][3];
+  int index;
+  int si;
+  int levelx;
+  int levely;
+  int levelz;
+  int np; 
+  int coarse_elnr;  // issue (JS): same class is for ElementIndex, SurfaceElementIndex, SegmentIndex 
+  int domin, domout; // he: needed for segment!! in 3d there should be surf1, surf2!!
+  // int coarse_hpelnr; 
+  PointIndex & operator[](int i) { return(pnums[i]);}
+  PointIndex & PNumMod(int i) { return pnums[(i-1) % np]; };
+  PointIndex & PNum(int i) {return pnums[(i-1)]; };
+  int GetIndex () const { return index; }; 
+  double singedge_left, singedge_right; 
+  auto PNums() const { return FlatArray<const PointIndex>(np, &pnums[0]); }
+
+  //  EdgePointGeomInfo epgeominfo[2];
+  
+};
+
+
+enum SplittingType { SPLIT_HP, SPLIT_ALFELD, SPLIT_POWELL};
+
+DLL_HEADER extern void HPRefinement (Mesh & mesh, Refinement * ref, SplittingType split, int levels,
+			  double fac1=0.125, bool setorders=true, bool ref_level = false);
+
+inline void HPRefinement (Mesh & mesh, Refinement * ref, int levels,
+			  double fac1=0.125, bool setorders=true, bool ref_level = false)
+{
+  HPRefinement (mesh, ref, SPLIT_HP, levels, fac1, setorders, ref_level);
+}
+
+} // namespace netgen
+#endif
+

netgen/include/meshing/improve2.hpp

@@ -0,0 +1,178 @@
+#ifndef NETGEN_IMPROVE2_HPP
+#define NETGEN_IMPROVE2_HPP
+
+#include "meshtype.hpp"
+
+namespace netgen
+{
+
+inline void AppendEdges( const Element2d & elem, PointIndex pi, Array<std::tuple<PointIndex,PointIndex>> & edges )
+{
+  for (int j = 0; j < 3; j++)
+  {
+      PointIndex pi0 = elem[j];
+      PointIndex pi1 = elem[(j+1)%3];
+      if (pi1 < pi0) Swap(pi0, pi1);
+      if(pi0==pi)
+          edges.Append(std::make_tuple(pi0, pi1));
+  }
+}
+
+inline void AppendEdges( const Element & elem, PointIndex pi, Array<std::tuple<PointIndex,PointIndex>> & edges )
+{
+  static constexpr int tetedges[6][2] =
+  { { 0, 1 }, { 0, 2 }, { 0, 3 },
+      { 1, 2 }, { 1, 3 }, { 2, 3 } };
+
+  if(elem.Flags().fixed)
+      return;
+  for (int j = 0; j < 6; j++)
+  {
+      PointIndex pi0 = elem[tetedges[j][0]];
+      PointIndex pi1 = elem[tetedges[j][1]];
+      if (pi1 < pi0) Swap(pi0, pi1);
+      if(pi0==pi)
+          edges.Append(std::make_tuple(pi0, pi1));
+  }
+}
+
+template<typename T_PI2SEI>
+void BuildEdgeList( const Mesh & mesh, const T_PI2SEI & elementsonnode, Array<std::tuple<PointIndex, PointIndex>> & edges )
+{
+  // static_assert(is_same_v<TINDEX, ElementIndex>||is_same_v<TINDEX,SurfaceElementIndex>, "Invalid type for TINDEX");
+  static Timer tbuild_edges("Build edges"); RegionTimer reg(tbuild_edges);
+
+  int ntasks = 4*ngcore::TaskManager::GetMaxThreads();
+  Array<Array<std::tuple<PointIndex,PointIndex>>> task_edges(ntasks);
+
+  ParallelFor(IntRange(ntasks), [&] (int ti)
+    {
+      auto myrange = mesh.Points().Range().Split(ti, ntasks);
+      ArrayMem<std::tuple<PointIndex,PointIndex>, 100> local_edges;
+      for (auto pi : myrange)
+      {
+        local_edges.SetSize(0);
+
+        for(auto ei : elementsonnode[pi])
+        {
+            const auto & elem = mesh[ei];
+            if (elem.IsDeleted()) continue;
+
+            AppendEdges(elem, pi, local_edges);
+        }
+        QuickSort(local_edges);
+
+        auto edge_prev = std::make_tuple<PointIndex, PointIndex>(PointIndex::INVALID, PointIndex::INVALID);
+
+        for(auto edge : local_edges)
+            if(edge != edge_prev)
+            {
+                task_edges[ti].Append(edge);
+                edge_prev = edge;
+            }
+      }
+    }, ntasks);
+
+  int num_edges = 0;
+  for (auto & edg : task_edges)
+      num_edges += edg.Size();
+  edges.SetAllocSize(num_edges);
+  for (auto & edg : task_edges)
+      edges.Append(edg);
+}
+
+
+class Neighbour
+{
+  int nr[3];
+  int orient[3];
+
+public:
+  Neighbour () { ; }
+
+  void SetNr (int side, int anr) { nr[side] = anr; }
+  int GetNr (int side) { return nr[side]; }
+
+  void SetOrientation (int side, int aorient) { orient[side] = aorient; }
+  int GetOrientation (int side) { return orient[side]; }
+};
+
+///
+class MeshOptimize2d
+{
+  int faceindex = 0;
+  int improveedges = 0;
+  double metricweight = 0.;
+  int writestatus = 1;
+  Mesh& mesh;
+  const NetgenGeometry& geo;
+public:
+  ///
+  MeshOptimize2d(Mesh& amesh) : mesh(amesh), geo(*mesh.GetGeometry())
+  {}
+  virtual ~MeshOptimize2d() { ; }
+  ///
+  DLL_HEADER void ImproveMesh (const MeshingParameters & mp);
+  DLL_HEADER void ImproveMeshJacobian (const MeshingParameters & mp);
+  DLL_HEADER void ImproveVolumeMesh ();
+  DLL_HEADER void ProjectBoundaryPoints(NgArray<int> & surfaceindex, 
+			     const NgArray<Point<3>* > & from, NgArray<Point<3>* > & dest);
+
+  DLL_HEADER bool EdgeSwapping (const int usemetric, Array<Neighbour> &neighbors, Array<bool> &swapped,
+                                const SurfaceElementIndex t1, const int edge, const int t, Array<int,PointIndex> &pdef, const bool check_only=false);
+  DLL_HEADER void EdgeSwapping (int usemetric);
+  DLL_HEADER void CombineImprove ();
+  DLL_HEADER void SplitImprove ();
+
+  DLL_HEADER void GenericImprove ();
+
+
+  void SetFaceIndex (int fi) { faceindex = fi; }
+  void SetImproveEdges (int ie) { improveedges = ie; }
+  void SetMetricWeight (double mw) { metricweight = mw; }
+  void SetWriteStatus (int ws) { writestatus = ws; }
+
+
+  /// liefert zu einem 3d-Punkt die geominfo (Dreieck) und liefert 1, wenn erfolgreich, 
+  /// 0, wenn nicht (Punkt ausserhalb von chart)
+  ///
+
+  void CheckMeshApproximation (Mesh & mesh);
+
+
+  ///
+  friend class Opti2SurfaceMinFunction;
+  ///
+  friend class Opti2EdgeMinFunction;
+  ///
+  friend double Opti2FunctionValueGrad (const Vector & x, Vector & grad);
+  ///
+  friend double Opti2EdgeFunctionValueGrad (const Vector & x, Vector & grad);
+
+
+
+};
+
+
+extern void CalcTriangleBadness (double x2, double x3, double y3, 
+				 double metricweight,
+				 double h, double & badness, 
+				 double & g1x, double & g1y);
+
+
+
+
+extern double CalcTriangleBadness (const Point<3> & p1, 
+				   const Point<3> & p2, 
+				   const Point<3> & p3,
+				   double metricweight,
+				   double h);
+
+extern double CalcTriangleBadness (const Point<3> & p1, 
+				   const Point<3> & p2, 
+				   const Point<3> & p3,
+				   const Vec<3> & n,
+				   double metricweight,
+				   double h);
+} // namespace netgen
+#endif // NETGEN_IMPROVE2_HPP

netgen/include/meshing/improve3.hpp

@@ -0,0 +1,151 @@
+#ifndef FILE_IMPROVE3
+#define FILE_IMPROVE3
+
+namespace netgen
+{
+
+
+///
+class MeshOptimize3d
+{
+  Mesh & mesh;
+  const MeshingParameters & mp;
+  OPTIMIZEGOAL goal = OPT_QUALITY;
+  double min_badness = 0;
+
+  bool HasBadElement(FlatArray<ElementIndex> els);
+  bool HasIllegalElement(FlatArray<ElementIndex> els);
+  bool NeedsOptimization(FlatArray<ElementIndex> els);
+
+public:
+
+  MeshOptimize3d (Mesh & m, const MeshingParameters & amp, OPTIMIZEGOAL agoal = OPT_QUALITY) :
+      mesh(m), mp(amp), goal(agoal) { ; }
+
+  void SetGoal(OPTIMIZEGOAL agoal) { goal = agoal; }
+  void SetMinBadness(double badness) { min_badness = badness; }
+
+  tuple<double, double, int> UpdateBadness();
+
+  double CombineImproveEdge (
+            Table<ElementIndex, PointIndex> & elements_of_point,
+            PointIndex pi0, PointIndex pi1,
+            FlatArray<bool, PointIndex> is_point_removed, bool check_only=false);
+
+  void CombineImprove ();
+
+  void SplitImprove ();
+  double SplitImproveEdge (Table<ElementIndex,PointIndex> & elementsonnode, NgArray<PointIndices<3>> &locfaces, double badmax, PointIndex pi1, PointIndex pi2, PointIndex ptmp, bool check_only=false);
+
+  void SplitImprove2 ();
+  double SplitImprove2Element (ElementIndex ei, const Table<ElementIndex, PointIndex> & elements_of_point, bool check_only);
+  
+
+  double SwapImproveEdge (const TBitArray<ElementIndex> * working_elements, Table<ElementIndex,PointIndex> & elementsonnode, INDEX_3_HASHTABLE<int> & faces, PointIndex pi1, PointIndex pi2, bool check_only=false);
+  void SwapImprove (const TBitArray<ElementIndex> * working_elements = NULL);
+  void SwapImproveSurface (const TBitArray<ElementIndex> * working_elements = NULL,
+			   const NgArray< idmap_type* > * idmaps = NULL);
+  void SwapImprove2 (bool conform_segments = false);
+  double SwapImprove2 (ElementIndex eli1, int face, Table<ElementIndex, PointIndex> & elementsonnode, DynamicTable<SurfaceElementIndex, PointIndex> & belementsonnode, bool conform_segments, bool check_only=false );
+
+  void ImproveMesh() { mesh.ImproveMesh(mp, goal); }
+
+  double 
+  CalcBad (const Mesh::T_POINTS & points, const Element & elem, double h)
+  {
+    if (elem.GetType() == TET)
+      return CalcTetBadness (points[elem[0]], points[elem[1]],  
+			     points[elem[2]], points[elem[3]], h, mp);  
+    return 0;
+  }
+
+
+  double GetLegalPenalty()
+  {
+    return goal == OPT_LEGAL ? 1e15 : 1e6;
+  }
+
+};
+
+
+inline double 
+CalcBad (const Mesh::T_POINTS & points, const Element & elem, double h, const MeshingParameters & mp)
+{
+  if (elem.GetType() == TET)
+    return CalcTetBadness (points[elem[0]], points[elem[1]],  
+			   points[elem[2]], points[elem[3]], h, mp);  
+  return 0;
+}
+
+
+
+extern int WrongOrientation (const Mesh::T_POINTS & points, const Element & el);
+
+
+/* Functional depending of inner point inside triangular surface */
+
+
+class MinFunctionSum : public MinFunction
+{
+protected:
+  NgArray<MinFunction*> functions;
+ 
+public:
+  
+  virtual double Func (const Vector & x) const;
+  virtual void Grad (const Vector & x, Vector & g) const;
+  virtual double FuncGrad (const Vector & x, Vector & g) const;
+  virtual double FuncDeriv (const Vector & x, const Vector & dir, double & deriv) const;
+  virtual double GradStopping (const Vector & x) const;
+
+  void AddFunction(MinFunction & fun);
+  
+  const MinFunction & Function(int i) const;
+  MinFunction & Function(int i);  
+};
+  
+
+class PointFunction1 : public MinFunction
+{
+  Mesh::T_POINTS & points;
+  const NgArray<PointIndices<3>> & faces;
+  const MeshingParameters & mp;
+  double h;
+public:
+  PointFunction1 (Mesh::T_POINTS & apoints, 
+		  const NgArray<PointIndices<3>> & afaces,
+		  const MeshingParameters & amp,
+		  double ah);
+  
+  virtual double Func (const Vector & x) const;
+  virtual double FuncDeriv (const Vector & x, const Vector & dir, double & deriv) const;
+  virtual double FuncGrad (const Vector & x, Vector & g) const;
+  virtual double GradStopping (const Vector & x) const;
+};
+
+class JacobianPointFunction : public MinFunction
+{
+public:
+  Mesh::T_POINTS & points;
+  const Array<Element, ElementIndex> & elements;
+  TABLE<INDEX> elementsonpoint;
+  PointIndex actpind;
+
+  bool onplane;
+  Vec<3> nv;
+  
+public:
+  JacobianPointFunction (Mesh::T_POINTS & apoints, 
+			 const Array<Element, ElementIndex> & aelements);
+  virtual ~JacobianPointFunction () { ; }
+  virtual void SetPointIndex (PointIndex aactpind);
+  virtual double Func (const Vector & x) const;
+  virtual double FuncGrad (const Vector & x, Vector & g) const;
+  virtual double FuncDeriv (const Vector & x, const Vector & dir, double & deriv) const;
+
+  inline void SetNV(const Vec<3> & anv) {nv = anv; onplane = true;}
+  inline void UnSetNV(void) {onplane = false;}
+};
+
+} // namespace netgen
+#endif