netgen-mesher 6.2.2505.post48.dev0__cp313-cp313-win_amd64.whl → 6.2.2506.post48.dev0__cp313-cp313-win_amd64.whl

netgen/include/core/simd_generic.hpp

@@ -48,6 +48,13 @@ namespace ngcore
       return k;
   }
 
+  constexpr size_t LargestPowerOfTwo (size_t x)
+  {
+    size_t y = 1;
+    while (2*y <= x) y *= 2;
+    return y;
+  }
+  
 
   template <typename T, int N=GetDefaultSIMDSize()> class SIMD;
 
@@ -89,7 +96,8 @@ namespace ngcore
   template <int N>
   class alignas(GetLargestNativeSIMDPart(N)*sizeof(int64_t)) SIMD<mask64,N>
   {
-    static constexpr int N1 = GetLargestNativeSIMDPart(N);
+    // static constexpr int N1 = GetLargestNativeSIMDPart(N);
+    static constexpr size_t N1 = LargestPowerOfTwo(N-1);
     static constexpr int N2 = N-N1;
 
     SIMD<mask64,N1> lo;
@@ -111,6 +119,113 @@ namespace ngcore
     }
 
 
+  ////////////////////////////////////////////////////////////////////////////
+  // int32
+
+  template<>
+  class SIMD<int32_t,1>
+  {
+    int32_t data;
+
+  public:
+    static constexpr int Size() { return 1; }
+    SIMD () {}
+    SIMD (const SIMD &) = default;
+    SIMD & operator= (const SIMD &) = default;
+    // SIMD (int val) : data{val} {}
+    SIMD (int32_t val) : data{val} {}
+    SIMD (size_t val) : data(val) {}
+    explicit SIMD (std::array<int32_t, 1> arr) : data{arr[0]} {}
+    
+
+    
+    int32_t operator[] (int i) const { return ((int32_t*)(&data))[i]; }
+    auto Data() const { return data; }
+    static SIMD FirstInt(int32_t n0=0) { return {n0}; }
+    template <int I>
+    int32_t Get()
+    {
+      static_assert(I==0);
+      return data;
+    }
+  };
+
+  template<int N>
+  class alignas(GetLargestNativeSIMDPart(N)*sizeof(int64_t)) SIMD<int32_t,N>
+  {
+    // static constexpr int N1 = GetLargestNativeSIMDPart(N);
+    static constexpr size_t N1 = LargestPowerOfTwo(N-1);        
+    static constexpr int N2 = N-N1;
+
+    SIMD<int32_t,N1> lo;
+    SIMD<int32_t,N2> high;
+
+  public:
+    static constexpr int Size() { return N; }
+
+    SIMD () {}
+    SIMD (const SIMD &) = default;
+    SIMD & operator= (const SIMD &) = default;
+
+    // SIMD (int val) : lo{val}, high{val} { ; }
+    SIMD (int32_t val) : lo{val}, high{val} { ; }
+    SIMD (size_t val) : lo{val}, high{val} { ; }
+    SIMD (int32_t * p) : lo{p}, high{p+N1} { ; }
+    
+    SIMD (SIMD<int32_t,N1> lo_, SIMD<int32_t,N2> high_) : lo(lo_), high(high_) { ; }
+
+    explicit SIMD( std::array<int32_t, N> arr )
+        : lo(detail::array_range<N1>(arr, 0)),
+          high(detail::array_range<N2>(arr, N1))
+      {}
+
+
+    template<typename ...T>
+    explicit SIMD(const T... vals)
+      : lo(detail::array_range<N1>(std::array<int32_t, N>{vals...}, 0)),
+        high(detail::array_range<N2>(std::array<int32_t, N>{vals...}, N1))
+      {
+        static_assert(sizeof...(vals)==N, "wrong number of arguments");
+      }
+
+
+    template<typename T, typename std::enable_if<std::is_convertible<T, std::function<int32_t(int)>>::value, int>::type = 0>
+      SIMD (const T & func)
+    {
+      for(auto i : IntRange(N1))
+          lo[i] = func(i);
+      for(auto i : IntRange(N2))
+          high[i] = func(N1+i);
+    }
+    
+    auto Lo() const { return lo; }
+    auto Hi() const { return high; }
+
+    int32_t operator[] (int i) const { return ((int32_t*)(&lo))[i]; }
+
+    void Store (int32_t * p) { lo.Store(p); high.Store(p+N1); }
+
+    
+    /*
+    operator tuple<int32_t&,int32_t&,int32_t&,int32_t&> ()
+    { return tuple<int32_t&,int32_t&,int32_t&,int32_t&>((*this)[0], (*this)[1], (*this)[2], (*this)[3]); }
+    */
+
+    /*
+    static SIMD FirstInt() { return { 0, 1, 2, 3 }; }
+    */
+    static SIMD FirstInt(int32_t n0=0) { return {SIMD<int32_t,N1>::FirstInt(n0), SIMD<int32_t,N2>::FirstInt(n0+N1)}; }
+    template <int I>
+    int32_t Get()
+    {
+      static_assert(I>=0 && I<N, "Index out of range");
+      if constexpr(I<N1) return lo.template Get<I>();
+      else               return high.template Get<I-N1>();
+    }
+  };
+
+
+
   ////////////////////////////////////////////////////////////////////////////
   // int64
 
@@ -145,7 +260,8 @@ namespace ngcore
   template<int N>
   class alignas(GetLargestNativeSIMDPart(N)*sizeof(int64_t)) SIMD<int64_t,N>
   {
-    static constexpr int N1 = GetLargestNativeSIMDPart(N);
+    // static constexpr int N1 = GetLargestNativeSIMDPart(N);
+    static constexpr size_t N1 = LargestPowerOfTwo(N-1);        
     static constexpr int N2 = N-N1;
 
     SIMD<int64_t,N1> lo;
@@ -209,6 +325,7 @@ namespace ngcore
     }
   };
 
+  
 
   ////////////////////////////////////////////////////////////////////////////
   // double
@@ -262,7 +379,8 @@ namespace ngcore
   template<int N>
   class alignas(GetLargestNativeSIMDPart(N)*sizeof(double)) SIMD<double, N>
   {
-    static constexpr int N1 = GetLargestNativeSIMDPart(N);
+    // static constexpr int N1 = GetLargestNativeSIMDPart(N);
+    static constexpr size_t N1 = LargestPowerOfTwo(N-1);    
     static constexpr int N2 = N-N1;
 
     SIMD<double, N1> lo;
@@ -314,7 +432,7 @@ namespace ngcore
 
     template<typename ...T>
     explicit SIMD(const T... vals)
-    : lo(detail::array_range<N1>(std::array<double, N>{vals...}, 0)),
+      : lo(detail::array_range<N1>(std::array<double, N>{vals...}, 0)),
       high(detail::array_range<N2>(std::array<double, N>{vals...}, N1))
       {
         static_assert(sizeof...(vals)==N, "wrong number of arguments");
@@ -327,8 +445,8 @@ namespace ngcore
       high.Store(p+N1, mask.Hi());
     }
 
-    auto Lo() const { return lo; }
-    auto Hi() const { return high; }
+    NETGEN_INLINE auto Lo() const { return lo; }
+    NETGEN_INLINE auto Hi() const { return high; }
 
     double operator[] (int i) const { return ((double*)(&lo))[i]; }
 
@@ -642,7 +760,11 @@ namespace ngcore
     reciprocal square root 
     Quake III algorithm, or intrinsics 
    */
+  //
+#ifndef __CUDACC__
   NETGEN_INLINE double rsqrt (double x) { return 1.0/sqrt(x); }
+#endif
+  
   template <int N>  
   SIMD<double,N> rsqrt (SIMD<double,N> x)
   {
@@ -661,6 +783,29 @@ namespace ngcore
   }
 
 
+
+  
+  template <typename T, int N>
+  auto Min (SIMD<T,N> a, SIMD<T,N> b)
+  {
+    if constexpr (N==1)
+      return SIMD<T,1> (std::min(a[0], b[0]));
+    else
+      return SIMD<T,N> (Min(a.Lo(), b.Lo()), Min(a.Hi(), b.Hi()));
+  }
+  
+  template <typename T, int N>
+  auto Max (SIMD<T,N> a, SIMD<T,N> b)
+  {
+    if constexpr (N==1)
+      return SIMD<T,1> (std::max(a[0], b[0]));
+    else
+      return SIMD<T,N> (Max(a.Lo(), b.Lo()), Max(a.Hi(), b.Hi()));
+  }
+  
+
+
+  
   
   template <typename T, int N>
   ostream & operator<< (ostream & ost, SIMD<T,N> simd)
@@ -862,6 +1007,42 @@ namespace ngcore
                              FMAddSub(a.Hi(), b.Hi(), c.Hi()));
     }
   }
+
+
+
+
+  template <int BASE, typename Tuple, std::size_t ... Is>
+  auto subtuple (const Tuple& tup, std::index_sequence<Is...>)
+  {
+    return std::make_tuple(std::get<BASE+Is>(tup)...);
+  }
+  
+  template <typename ...Args, typename T, int M>
+  auto Concat (std::tuple<SIMD<T,M>, Args...> tup)
+  {
+    constexpr size_t N = std::tuple_size<std::tuple<SIMD<T,M>, Args...>>();
+    
+    if constexpr (N == 1)
+      return get<0>(tup);
+    else
+      {
+        static constexpr size_t N1 = LargestPowerOfTwo(N-1);
+        static constexpr int N2 = N-N1;
+        
+        auto SEQ1 = std::make_index_sequence<N1>();
+        auto sub1 = subtuple<0>(tup, SEQ1);
+        
+        auto SEQ2 = std::make_index_sequence<N2>();
+        auto sub2 = subtuple<N1>(tup, SEQ2);
+      
+        auto S1 = Concat(sub1);
+        auto S2 = Concat(sub2);
+        return SIMD<T,S1.Size()+S2.Size()>(S1, S2);
+      }
+  }
+  
+
+  
 }
 
 

netgen/include/core/simd_math.hpp

@@ -57,7 +57,7 @@ namespace ngcore
   template <int N>
   auto sincos (SIMD<double,N> x)
   {
-    auto y = round(x / (M_PI/2));
+    auto y = round((2/M_PI) * x);
     auto q = lround(y);
   
     auto [s1,c1] = sincos_reduced(x - y * (M_PI/2));
@@ -151,7 +151,7 @@ namespace ngcore
     // x = ldexp( x, n );
   }
 
-
+  /*
   inline auto Test1 (SIMD<double> x)
   {
     return myexp(x);
@@ -171,6 +171,7 @@ namespace ngcore
   {
     return sincos(x);
   }
+  */
   
 }
 

netgen/include/core/statushandler.hpp

@@ -0,0 +1,37 @@
+#ifndef NETGEN_CORE_STATUSHANDLER
+#define NETGEN_CORE_STATUSHANDLER
+
+#include <string>
+#include "utils.hpp"
+
+namespace ngcore
+{
+  
+  class NGCORE_API multithreadt
+  {
+  public:
+    int pause;
+    int testmode;
+    int redraw;
+    int drawing;
+    int terminate;
+    int running;
+    double percent;
+    const char * task;
+    bool demorunning;
+    std::string * tcl_todo = new std::string("");  // tcl commands set from parallel thread
+    multithreadt();
+  };
+
+  NGCORE_API extern volatile multithreadt multithread;
+
+  
+  extern NGCORE_API void SetStatMsg(const std::string& s);
+
+  extern NGCORE_API void PushStatus(const std::string& s);
+  extern NGCORE_API void PushStatusF(const std::string& s);
+  extern NGCORE_API void PopStatus();
+  extern NGCORE_API void SetThreadPercent(double percent);
+  extern NGCORE_API void GetStatus(std::string & s, double & percentage);
+}
+#endif

netgen/include/core/table.hpp

@@ -262,14 +262,14 @@ namespace ngcore
     const MemoryTracer& GetMemoryTracer() const { return mt; }
 
   private:
-    size_t GetMemUsage() const { return size == 0 ? 0 : sizeof(T)*index[size] + sizeof(IndexType) * size+1; }
+    NETGEN_INLINE size_t GetMemUsage() const { return size == 0 ? 0 : sizeof(T)*index[size] + sizeof(IndexType) * size+1; }
     MemoryTracer mt;
   };
 
 
   /// Print table
   template <class T, typename IndexType>
-  inline ostream & operator<< (ostream & s, const Table<T,IndexType> & table)
+  inline ostream & operator<< (ostream & s, FlatTable<T,IndexType> table)
   {
     for (auto i : table.Range())
       {

netgen/include/core/taskmanager.hpp

@@ -94,10 +94,14 @@ namespace ngcore
     NGCORE_API void StartWorkers();
     NGCORE_API void StopWorkers();
 
-    void SuspendWorkers(int asleep_usecs = 1000 )
+    bool IsSleeping() const { return sleep; }
+
+    int SuspendWorkers(int asleep_usecs = 1000 )
       {
+        int old_sleep_usecs = sleep_usecs;
         sleep_usecs = asleep_usecs;
         sleep = true;
+        return old_sleep_usecs;
       }
     void ResumeWorkers() { sleep = false; }
 
@@ -179,6 +183,35 @@ namespace ngcore
     }
   };
 
+  class SuspendTaskManager
+  {
+    int old_sleep_usecs = 0;
+    bool old_sleep = false;
+    TaskManager * tm = nullptr;
+
+  public:
+    SuspendTaskManager(int asleep_usecs=1000)
+      : tm(task_manager)
+    {
+      if(!tm)
+          return;
+
+      old_sleep = tm->IsSleeping();
+      old_sleep_usecs = tm->SuspendWorkers(asleep_usecs);
+    }
+
+    ~SuspendTaskManager()
+    {
+      if(!tm)
+          return;
+
+      if(old_sleep) // restore old sleep time
+          tm->SuspendWorkers(old_sleep_usecs);
+      else
+          tm->ResumeWorkers();
+    }
+  };
+
   NETGEN_INLINE int TasksPerThread (int tpt)
   {
     // return task_manager ? tpt*task_manager->GetNumThreads() : 1;

netgen/include/include/netgen_version.hpp

@@ -1,9 +1,9 @@
 #ifndef NETGEN_VERSION_HPP_INCLUDED
 #define NETGEN_VERSION_HPP_INCLUDED
-#define NETGEN_VERSION "6.2.2505-48-gdf5d2ec7"
+#define NETGEN_VERSION "6.2.2506-48-g8263c0bc"
 #define NETGEN_VERSION_MAJOR 6
 #define NETGEN_VERSION_MINOR 2
-#define NETGEN_VERSION_PATCH 2505
+#define NETGEN_VERSION_PATCH 2506
 #define NETGEN_VERSION_TWEAK 48
-#define NETGEN_VERSION_HASH "gdf5d2ec7"
+#define NETGEN_VERSION_HASH "g8263c0bc"
 #endif // NETGEN_VERSION_HPP_INCLUDED

netgen/include/meshing/basegeom.hpp

@@ -42,10 +42,7 @@ namespace netgen
     string GetName() const { return name ? *name : "default"; }
     Vec<4> GetColor() { return col ? *col : Vec<4>{0., 1., 0., 1.}; }
 
-    void DoArchive(Archive& ar)
-    {
-        ar & name & col & maxh & hpref & layer;
-    }
+    void DoArchive(Archive& ar);
   };
 
   class GeometryShape;

netgen/include/meshing/global.hpp

@@ -31,23 +31,6 @@ namespace netgen
 
   DLL_HEADER extern mutex tcl_todo_mutex;
 
-  class DLL_HEADER multithreadt
-  {
-  public:
-    int pause;
-    int testmode;
-    int redraw;
-    int drawing;
-    int terminate;
-    int running;
-    double percent;
-    const char * task;
-    bool demorunning;
-    string * tcl_todo = new string("");  // tcl commands set from parallel thread
-    multithreadt();
-  };
-
-  DLL_HEADER extern volatile multithreadt multithread;
 
   class DebugParameters;
   class Mesh;

netgen/include/meshing/hpref_tet.hpp

@@ -4184,6 +4184,47 @@ HPRef_Struct reftet_3f_0e_0v =
 
 
 
+
+// HP_TET_ALFELD
+int reftet_Alfeld_splitedges[][3] =
+{
+  { 0, 0, 0 }
+};
+int reftet_Alfeld_splitfaces[][4] =
+{
+  { 0, 0, 0, 0 }
+};
+
+int reftet_Alfeld_splitelements[][5] =
+  {
+    { 1, 2, 3, 4, 5},
+    { 0 }
+  };
+
+HPREF_ELEMENT_TYPE reftet_Alfeld_newelstypes[] =
+{
+  HP_TET, HP_TET, HP_TET, HP_TET,
+  HP_NONE, 
+};
+
+int reftet_Alfeld_newels[][8] =
+{
+  { 1, 2, 3, 5 }, 
+  { 1, 4, 2, 5 }, 
+  { 1, 3, 4, 5 },
+  { 3, 2, 4, 5 }
+};
+HPRef_Struct reftet_Alfeld =
+{
+  HP_TET,
+  reftet_Alfeld_splitedges, 
+  reftet_Alfeld_splitfaces,
+  reftet_Alfeld_splitelements,  
+  reftet_Alfeld_newelstypes,
+  reftet_Alfeld_newels
+};
+
+
 /*
 
 */

netgen/include/meshing/hprefinement.hpp

@@ -189,6 +189,8 @@ enum HPREF_ELEMENT_TYPE {
   
   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,

netgen/include/meshing/meshtype.hpp

@@ -1334,6 +1334,7 @@ namespace netgen
     auto PNums() const { return FlatArray<const PointIndex> (GetNP(), &pnums[0]); }
     auto PNums() { return FlatArray<PointIndex> (GetNP(), &pnums[0]); }
     
+    auto Vertices() const { return FlatArray<const PointIndex> (2, &pnums[0]); }
     
     ELEMENT_TYPE GetType() const
     {

netgen/include/meshing/msghandler.hpp

@@ -45,13 +45,16 @@ namespace netgen
 			     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="");
-  extern DLL_HEADER void SetStatMsg(const MyStr& s);
 
-  extern DLL_HEADER void PushStatus(const MyStr& s);
-  extern DLL_HEADER void PushStatusF(const MyStr& s);
-  extern DLL_HEADER void PopStatus();
-  extern DLL_HEADER void SetThreadPercent(double percent);
-  extern DLL_HEADER void GetStatus(MyStr & s, double & percentage);
+
+
+
+  inline void PushStatusF(const std::string& s)
+  {
+    PushStatus (s);
+    PrintFnStart(s);
+  }
+
 }
 
 

netgen/include/meshing/topology.hpp

@@ -390,7 +390,7 @@ inline short int MeshTopology :: GetNEdges (ELEMENT_TYPE et)
       // default:
       // cerr << "Ng_ME_GetNEdges, illegal element type " << et << endl;
     }
-  return -99;
+  return 0;
 }
 
 
@@ -431,7 +431,7 @@ inline short int MeshTopology :: GetNFaces (ELEMENT_TYPE et)
       return 6;
 
     default:
-      return -99;
+      return 0;
       // default:
       // cerr << "Ng_ME_GetNVertices, illegal element type " << et << endl;
     }

netgen/include/nginterface.h

@@ -353,10 +353,11 @@ extern "C" {
 
   DLL_HEADER void RunParallel ( void * (*fun)(void *), void * in);
 
-  DLL_HEADER void Ng_PushStatus (const char * str);
+  #define NG_STATUS_USES_STD_STRING
+  DLL_HEADER void Ng_PushStatus (const std::string& str);
   DLL_HEADER void Ng_PopStatus ();
   DLL_HEADER void Ng_SetThreadPercentage (double percent);
-  DLL_HEADER void Ng_GetStatus (char ** str, double & percent);
+  DLL_HEADER void Ng_GetStatus (std::string& str, double & percent);
 
   DLL_HEADER void Ng_SetTerminate(void);
   DLL_HEADER void Ng_UnSetTerminate(void);

netgen/include/occ/occ_utils.hpp

@@ -71,6 +71,20 @@ namespace netgen
         return gp_Pnt(p(0), p(1), p(2));
     }
 
+    inline void CheckValidPropertyType(const TopoDS_Shape & shape)
+    {
+        switch (shape.ShapeType())
+        {
+          case TopAbs_SOLID:
+          case TopAbs_FACE:
+          case TopAbs_EDGE:
+          case TopAbs_VERTEX:
+            break;
+          default:
+            throw Exception("Cannot query properties of compound shapes - setting properties sets property on all highest dimension subshape type");
+        }
+    }
+
     DLL_HEADER Box<3> GetBoundingBox( const TopoDS_Shape & shape );
 
     struct OCCIdentification
@@ -152,6 +166,10 @@ namespace netgen
       {
         return SubShapes(TopAbs_SOLID);
       }
+      ListOfShapes Shells() const
+      {
+        return SubShapes(TopAbs_SHELL);
+      }
       ListOfShapes Faces() const
       {
         return SubShapes(TopAbs_FACE);
@@ -199,6 +217,14 @@ namespace netgen
       return sub;
     }
 
+    inline ListOfShapes GetShells(const TopoDS_Shape & shape)
+    {
+      ListOfShapes sub;
+      for (TopExp_Explorer e(shape, TopAbs_SHELL); e.More(); e.Next())
+        sub.push_back(e.Current());
+      return sub;
+    }
+
     inline ListOfShapes GetFaces(const TopoDS_Shape & shape)
     {
       ListOfShapes sub;

netgen/include/occ/occgeom.hpp

@@ -146,6 +146,14 @@ namespace netgen
 
     static ShapeProperties& GetProperties(const TopoDS_Shape& shape)
     {
+      try
+        {
+          CheckValidPropertyType(shape);
+        }
+      catch(Exception& e)
+        {
+          cerr << "WARNING: " << e.what() << endl;
+        }
       auto index = OCCGeometry::global_shape_property_indices.FindIndex(shape);
       if(index > 0)
         return OCCGeometry::global_shape_properties