ngsolve 6.2.2504.post44.dev0__cp311-cp311-win_amd64.whl → 6.2.2601__cp311-cp311-win_amd64.whl

netgen/include/sparsematrix_impl.hpp

@@ -355,6 +355,23 @@ namespace ngla
       AddRowTransToVector (i, s*fx(i), fy);
 
     timer.AddFlops (this->NZE());
+
+
+    /*
+    static Timer t("SparseMatrix::MultTransAdd"); RegionTimer reg(t);
+    t.AddFlops (this->NZE()*sizeof(TV_ROW)*sizeof(TV_COL)/sqr(sizeof(double)));
+
+    ParallelForRange
+      (balance, [&] (IntRange myrange)
+       {
+         FlatVector<TVY> fx = x.FV<TVY>(); 
+         FlatVector<TVX> fy = y.FV<TVX>(); 
+
+         for (auto i : myrange)
+           AddRowTransToVectorAtomic (i, s*fx(i), fy);
+       });
+    */
+    
   }
 
 
@@ -460,21 +477,69 @@ namespace ngla
   DeleteZeroElements(double tol) const
   {
     static Timer t("SparseMatrix::DeleteZeroElements"); RegionTimer reg(t);
-    Array<int> indi, indj;
-    Array<TM> val;
-    for (auto i : Range(this->Height()))
+    size_t h = this->Height();
+    size_t w = this->Width();
+    Array<int> cnt(h);
+    Array<bool> keep(data.Size());
+    cnt = 0;
+    keep = false;
+    ParallelForRange( h, [&](IntRange r)
       {
-        for (auto j : Range(firsti[i], firsti[i+1]))
-          {
+        for (auto i : r)
+          for (auto j : Range(firsti[i], firsti[i+1]))
             if (ngbla::L2Norm2(data[j]) > tol*tol)
+            {
+              keep[j] = true;
+              cnt[i]++;
+            }
+      }, 5*TaskManager::GetNumThreads());
+
+    auto matrix = make_shared<SparseMatrix<TM>> (cnt, w);
+    cnt = 0;
+
+    ParallelForRange( h, [&](IntRange r)
+      {
+        for (auto i : r)
+        {
+          auto cols = matrix->GetRowIndices(i);
+          auto vals = matrix->GetRowValues(i);
+          int icol = 0;
+          // size_t firsti_new = matrix->firsti[i];
+          for (auto j : Range(firsti[i], firsti[i+1]))
+            if (keep[j])
               {
-                indi.Append (i);
-                indj.Append (colnr[j]);
-                val.Append (data[j]);
+                cols[icol] = colnr[j];
+                vals[icol] = data[j];
+                icol++;
               }
-          }
-      }
-    return this->CreateFromCOO(indi, indj, val, this->Height(), this->Width());
+        }
+      }, 5*TaskManager::GetNumThreads());
+    return matrix;
+
+    /*
+      // needs parallelization and testing
+    Array<int> cnt(this->Height());
+    cnt = 0;
+    size_t cnt0 = 0;
+    for (auto i : Range(this->Height()))
+      for (auto j : Range(firsti[i], firsti[i+1]))
+        if (ngbla::L2Norm2(data[j]) > tol*tol)
+          cnt[i]++;
+        else
+          cnt0++;
+
+    cout << "zero-els = " << cnt0 << endl;
+
+
+    auto matrix = make_shared<SparseMatrix<TM>> (cnt, this->Width());
+
+    for (auto i : Range(this->Height()))
+      for (auto j : Range(firsti[i], firsti[i+1]))
+        if (ngbla::L2Norm2(data[j]) > tol*tol)
+          (*matrix)(i, colnr[i]) =  data[j];
+
+    return matrix;
+    */
   }
 
   template <class TM>
@@ -707,36 +772,38 @@ namespace ngla
   
   template <class TM>
   shared_ptr<BaseSparseMatrix> SparseMatrixTM<TM> ::
-  CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(ngbla::Trans(TM()))>>(const Array<int>&,int)> & creator) const
+  CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(ngbla::Trans(TM()))>>(const Array<int>&,int)> & creator,
+                     bool sorted) const
   {
     Array<int> cnt(this->Width());
     cnt = 0;
     ParallelFor (this->Height(), [&] (int i)
-                 {
-                   for (int c : this->GetRowIndices(i))
-                     AsAtomic (cnt[c]) ++;
-                 });
-
+    {
+      for (int c : this->GetRowIndices(i))
+        AsAtomic (cnt[c]) ++;
+    });
+    
     auto trans = creator(cnt, this->Height());
 
     cnt = 0;
     ParallelFor (this->Height(), [&] (int i)
-                 {
-                   for (int ci : Range(this->GetRowIndices(i)))
-                     {
-                       int c = this->GetRowIndices(i)[ci];
-                       int pos = AsAtomic(cnt[c])++;
-                       trans -> GetRowIndices(c)[pos] = i;
-                       trans -> GetRowValues(c)[pos] = Trans(this->GetRowValues(i)[ci]);
-                     }
-                 });
-
-    ParallelFor (trans->Height(), [&] (int r)
-                 {
-                   auto rowvals = trans->GetRowValues(r);
-                   BubbleSort (trans->GetRowIndices(r),
-                               FlatArray(rowvals.Size(), rowvals.Data()));
-                 });
+    {
+      for (int ci : Range(this->GetRowIndices(i)))
+        {
+          int c = this->GetRowIndices(i)[ci];
+          int pos = AsAtomic(cnt[c])++;
+          trans -> GetRowIndices(c)[pos] = i;
+          trans -> GetRowValues(c)[pos] = Trans(this->GetRowValues(i)[ci]);
+        }
+    });
+    
+    if (sorted)
+      ParallelFor (trans->Height(), [&] (int r)
+      {
+        auto rowvals = trans->GetRowValues(r);
+        BubbleSort (trans->GetRowIndices(r),
+                    FlatArray(rowvals.Size(), rowvals.Data()));
+      });
 
     return trans;
   }

netgen/include/statushandler.hpp

@@ -3,27 +3,27 @@
 
 namespace ngstd
 {
-
+  
   /** Access to statusbar. (and more)
    */
 
   class NGS_DLL_HEADER BaseStatusHandler
-  {
-  public:
-    static void PushStatus (const char * str);
+    {
+    public:
+    static void PushStatus (const std::string& str);
     static void PopStatus ();
     static void SetThreadPercentage (double percent);
-
+    
     static void GetStatus (string & str, double & percent);
-
+    
     static void SetTerminate(void);
     static void UnSetTerminate(void);
     static bool ShouldTerminate(void);
-
+    
     class Region
     {
     public:
-      Region(const char * str) { PushStatus(str); }
+      Region(const string& str) { PushStatus(str); }
       ~Region() { PopStatus(); }
     };
   };

netgen/include/thdivfe_impl.hpp

@@ -235,6 +235,7 @@ namespace ngfem
   CalcMappedDivShape (const SIMD_BaseMappedIntegrationRule & bmir, 
                       BareSliceMatrix<SIMD<double>> divshapes) const
   {
+    /*
     auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIM>&> (bmir);
     for (size_t i = 0; i < mir.Size(); i++)
       {
@@ -246,6 +247,29 @@ namespace ngfem
                                    divshapesi(j) = val;
                                  }));
       }
+    */
+    Iterate<4-DIM>
+      ([this,&bmir,divshapes](auto CODIM)
+      {
+        constexpr int DIMSPACE = DIM+CODIM.value;
+        if (bmir.DimSpace() == DIMSPACE)
+          {
+            // cout << "use new div, dim " << DIMSPACE << endl;
+             auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIMSPACE>&> (bmir);
+             for (size_t i = 0; i < mir.Size(); i++)
+               {
+                 auto divshapesi = divshapes.Col(i);
+                 auto invJ = 1.0/mir[i].GetJacobiDet();
+                 static_cast<const FEL*> (this) ->                 
+                   T_CalcShape (GetTIPGrad<DIM>(mir[i].IP()),
+                                SBLambda ([divshapesi,invJ] (size_t j, THDiv2DivShape<DIM,SIMD<double>> val)
+                                          {
+                                            divshapesi(j) = invJ*val.Get(); 
+                                          }));
+               }
+           }
+       });
+   
   }
 
   template <class FEL, ELEMENT_TYPE ET>
@@ -384,6 +408,8 @@ namespace ngfem
   EvaluateDiv (const SIMD_BaseMappedIntegrationRule & bmir, BareSliceVector<> coefs,
                BareVector<SIMD<double>> values) const
   {
+    /*
+    cout << "evaldiv, simd" << endl
     auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIM>&> (bmir);
     for (size_t i = 0; i < mir.Size(); i++)
       {
@@ -399,6 +425,46 @@ namespace ngfem
                                  }));
         values(i) = sum;
       }
+    */
+
+    /*
+    Iterate<4-DIM>
+      ([this,&bmir,coefs,values](auto CODIM)
+      {
+        constexpr int DIMSPACE = DIM+CODIM.value;
+        if (bmir.DimSpace() == DIMSPACE)
+          {
+            auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIMSPACE>&> (bmir);
+            for (size_t i = 0; i < mir.Size(); i++)
+               {
+                 SIMD<double> sum(0.0);                 
+                 static_cast<const FEL*> (this) ->                 
+                   T_CalcShape (GetTIPGrad<DIM>(mir[i].IP()),
+                                SBLambda ([=,&sum] (size_t j, THDiv2DivShape<DIM,SIMD<double>> divshape)
+                                          {
+                                            // auto vshape = HDiv2DivShapeNew (s); 
+                                            // shapesi.Range(j*vshape.Size(), (j+1)*vshape.Size()) = vshape;
+                                            // divshapesi(j) = HDiv2DivShapeNew (s);
+                                            sum += coefs(j) * divshape.Get();                                            
+                                          }));
+                 values(i) = 1/mir[i].GetJacobiDet() * sum;
+               }
+           }
+       });
+    */
+
+    auto & mir = bmir;
+    for (size_t i = 0; i < mir.Size(); i++)
+      {
+        SIMD<double> sum(0.0);                 
+        static_cast<const FEL*> (this) ->                 
+          T_CalcShape (GetTIPGrad<DIM>(mir[i].IP()),
+                       SBLambda ([=,&sum] (size_t j, THDiv2DivShape<DIM,SIMD<double>> divshape)
+                       {
+                         sum += coefs(j) * divshape.Get();                                            
+                       }));
+        values(i) = 1/mir[i].GetJacobiDet() * sum;
+      }
   }
   
   template <class FEL, ELEMENT_TYPE ET>

netgen/include/tscalarfe.hpp

@@ -36,7 +36,7 @@ namespace ngfem
     INLINE T_ScalarFiniteElement () { ; }
     // virtual ~T_ScalarFiniteElement() { ; }
 
-    HD virtual ELEMENT_TYPE ElementType() const final { return ET; }
+    HD virtual ELEMENT_TYPE ElementType() const final override { return ET; }
     // HD NGS_DLL_HEADER virtual int Dim () const override { return DIM; }