ngsolve 6.2.2506.post216.dev0__cp314-cp314-manylinux_2_28_x86_64.whl

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/recursive_pol_trig.hpp

@@ -0,0 +1,492 @@
+#ifndef FILE_RECURSIVE_POL_TRIG
+#define FILE_RECURSIVE_POL_TRIG
+
+
+#include "recursive_pol.hpp"
+
+namespace ngfem
+{
+
+  /**
+     Computes face shape functions for triangles.
+   
+  */
+  class TrigShapesInnerLegendre
+  {
+  public:
+    /// compute shape functions in factored form $\varphi_{ij} = u_i v_j$
+    template <typename Sx, typename Sy, typename T>
+    INLINE static void CalcSplitted (int n, Sx x, Sy y, T & val1, T & val2)
+    {
+      LegendrePolynomial leg;
+
+      Sx bub1 = (1-x-y)*(1+x-y);
+      leg.EvalScaledMult (n-3, x, 1-y, bub1, val1); 
+      leg.EvalMult (n-3, 2*y-1, y, val2);
+    }
+
+
+    template <int n, typename Sx, typename Sy, typename T>
+    INLINE static void CalcSplitted (Sx x, Sy y, T & val1, T & val2)
+    {
+      Sx bub1 = (1-x-y)*(1+x-y);
+      // ScaledLegendrePolynomialMult (n-3, x, 1-y, bub1, val1); 
+      // LegendrePolynomialFO<n-3>::EvalScaledMult (x, 1-y, bub1, val1); 
+      LegendrePolynomial leg;
+      leg.EvalScaledMultFO<n-3> (x, 1-y, bub1, val1);
+
+      // LegendrePolynomialMult (n-3, 2*y-1, y, val2);
+      // LegendrePolynomialFO<n-3>::EvalMult (2*y-1, y, val2);
+      leg.EvalMultFO<n-3> (2*y-1, y, val2);
+    }
+
+
+    /// computes all shape functions
+    template < typename Sx, typename Sy, typename T>
+    static int Calc (int n, Sx x, Sy y, T & values)
+    {
+      ArrayMem<Sx, 20> polx(n-2), poly(n-2);
+
+      ScaledLegendrePolynomial (n-3, x, 1-y, polx);
+      LegendrePolynomial (n-3, 2*y-1, poly);
+      Sx bub = y * (1-x-y) * (1+x-y);
+
+      int ii = 0;
+      for (int i = 0; i <= n-3; i++)
+	for (int j = 0; j <= n-3-i; j++)
+	  values[ii++] = bub * polx[i] * poly[j];
+
+      return ii;
+    }
+
+    template <int n, typename Sx, typename Sy, typename T>
+    static int Calc (Sx x, Sy y, T & values)
+    {
+      // ArrayMem<Sx, 20> polx(n-2), poly(n-2);
+      Sx polx[n], poly[n];
+
+      /*
+	ScaledLegendrePolynomial (n-3, x, 1-y, polx);
+	LegendrePolynomial (n-3, 2*y-1, poly);
+	Sx bub = y * (1-x-y) * (1+x-y);
+      */
+      CalcSplitted<n> (x, y, polx, poly);
+      int ii = 0;
+      for (int i = 0; i <= n-3; i++)
+	for (int j = 0; j <= n-3-i; j++)
+	  values[ii++] = /* bub * */ polx[i] * poly[j];
+
+      return ii;
+    }
+
+
+
+
+
+    /// computes all shape functions
+    template <typename Sx, typename Sy, typename Sf, typename T>
+    static int CalcMult (int n, Sx x, Sy y, Sf & fac, T & values)
+    {
+      ArrayMem<Sx, 20> polx(n-2), poly(n-2);
+
+      ScaledLegendrePolynomial (n-3, x, 1-y, polx);
+      LegendrePolynomial (n-3, 2*y-1, poly);
+
+      Sx bub = fac * y * (1-x-y) * (1+x-y);
+
+      int ii = 0;
+      for (int i = 0; i <= n-3; i++)
+	for (int j = 0; j <= n-3-i; j++)
+	  values[ii++] = bub * polx[i] * poly[j];
+
+      return ii;
+    }
+
+
+  };
+
+
+  /**
+     Compute triangular face shape functions.
+     Shape functions are $L_2$-orthogonal Jacobi polynomials
+  */
+  class TrigShapesInnerJacobi
+  {
+  public:
+    /// computes all base functions
+    template <typename Sx, typename Sy, typename T>
+    static int Calc (int n, Sx x, Sy y, T & values)
+    {
+      int ii = 0;
+      ArrayMem<Sx, 20> polx(n+1), poly(n+1);
+
+      Sx bub = y * (1-x-y) * (1+x-y);
+      ScaledJacobiPolynomial (n-3, x, 1-y, 2, 2, polx);
+
+      for (int ix = 0; ix <= n-3; ix++)
+	{
+	  JacobiPolynomial (n-3, 2*y-1, 2*ix+5, 2, poly);
+	  for (int j = 0; j <= n-3-ix; j++)
+	    values[ii++] = bub * polx[ix] * poly[j];
+	}
+      return ii;
+    }
+
+
+  };
+
+
+  //*************************************MONOMIAL EXTENSION***********************************************************
+
+    /**
+       Compute triangle edge-shape functions.
+
+       functions vanish on upper two edges
+
+       x,y: coordinates in triangle (-1, 0), (1, 0), (0, 1)
+
+       f_i (x, 0) = IntegratedLegendrePol_i (x)
+
+       f_i ... pol of order i
+
+       Monomial extension:
+    */
+  class TrigExtensionMonomial
+  {
+  public:
+    /// computes function on triangle
+    template <class Sx, class Sy, class T>
+    inline static int CalcTrigExt (int n, Sx x, Sy y, T & values)
+    {
+      Sy fy = (1-y)*(1-y);
+      Sx p3 = 0;
+      Sx p2 = -1;
+      Sx p1 = x;
+
+      for (int j=2; j<=n; j++)
+	{
+	  p3=p2; p2=p1;
+	  p1=( (2*j-3) * x * p2 - (j-3) * fy * p3) / j;
+	  values[j-2] = p1;
+	}
+      return n-1;
+    }
+
+
+    /// computes derivates on triangle, values must be $N \times 2$ matrix
+    template <class T>
+    inline static int CalcTrigExtDeriv (int n, double x, double y, T & values)
+    {
+      double fy = (1-y)*(1-y);
+      double p3 = 0, p3x = 0, p3y = 0;
+      double p2 = -1, p2x = 0, p2y = 0;
+      double p1 = x, p1x = 1, p1y = 0;
+
+      for (int j=2; j<=n; j++)
+	{
+	  p3=p2; p3x = p2x; p3y = p2y;
+	  p2=p1; p2x = p1x; p2y = p1y;
+	  double c1 = (2.0*j-3) / j;
+	  double c2 = (j-3.0) / j;
+
+	  p1  = c1 * x * p2 - c2 * fy * p3;
+	  p1x = c1 * p2 + c1 * x * p2x - c2 * fy * p3x;
+	  p1y = c1 * x * p2y - (c2 * 2 * (y-1) * p3 + c2 * fy * p3y);
+	  values (j-2, 0) = p1x;
+	  values (j-2, 1) = p1y;
+	}
+      return n-1;
+    }
+
+    /// computes values on edge
+    template <class Sx, class T>
+    inline static int Calc (int n, Sx x, T & values)
+    {
+      Sx p3 = 0;
+      Sx p2 = -1;
+      Sx p1 = x;
+
+      for (int j=2; j<=n; j++)
+	{
+	  p3=p2; p2=p1;
+	  p1=( (2*j-3) * x * p2 - (j-3) * p3) / j;
+	  values[j-2] = p1;
+	}
+      return n-1;
+
+    }
+
+    /// computes derivatives on edge
+    template <class T>
+    inline static int CalcDeriv (int n, double x, T & values)
+    {
+      double p1 = 1.0, p2 = 0.0, p3;
+
+      for (int j=1; j<=n-1; j++)
+	{
+	  p3 = p2; p2 = p1;
+	  p1 = ((2.0*j-1.0)*x*p2 - (j-1.0)*p3) / j;
+	  values[j-1] = p1;
+	}
+      return n-1;
+  
+    }
+  };
+
+
+  // ***********************  OPTIMAL EXTENSION  *****************************************
+  /**
+     Evaluete optimal edge-shape function.
+     on triangle (with coordinates (-1,0),(1,0),(0,1))
+     $$
+     \varphi_i:=\frac{1}{y}\int_{x-y}^{x+y}C_{i-1}^{-1/2}(s)ds
+     $$
+     vanishes on other both edges
+     Computed by recurrence
+     $$
+     {\varphi}_i:=
+     p_n(x,y) = a_n p_{n-4}} + b_n x p_{n-3} + (c_n + d_n (x*x-y*y)) p_{n-2}} + e_n x p_{n-1}}
+     $$
+  */
+  class TrigExtensionOptimal
+  {
+    enum { SIZE = 1000 };
+    static double coefs[SIZE][5];
+    static bool initialized;
+  public:
+
+    TrigExtensionOptimal ();
+
+    template <class Sx, class Sy, class T>
+    inline static int CalcTrigExt (int p, Sx x, Sy y, T & values)
+    {
+      Sx p1(0.0), p2(0.0), p3(0.0), p4(0.0), p5(0.0);
+      Sx bub = (1.+x-y)*(x+y-1);
+      switch(p)
+	{
+	default:
+	case 5:
+
+	  {
+	    p5 = -1./24. * bub*x * (-9.+21.*x*x-14.*y+35.*y*y);
+	    values[3] = p5;
+	  }
+
+	case 4:
+
+	  {
+	    p4 = -0.125 * bub * (-1.+5.*x*x-2.*y+3.*y*y);
+	    values[2] = p4;
+	  }
+
+	case 3:
+
+	  {
+	    p3 = -0.5 * bub * x;
+	    values[1] = p3;
+	  }
+
+	case 2:
+
+	  {
+	    p2 = -0.5 * bub;
+	    values[0] = p2;
+	  }
+	case 1:
+	case 0:
+	  ;
+	}
+
+      for (int j = 6; j <= p; j++)
+	{
+	  p1 = 
+	    -coefs[j-6][0] * p2 
+	    + coefs[j-6][1] * x * p3 
+	    - (coefs[j-6][2]+coefs[j-6][3]*(x*x-y*y)) * p4 
+	    + coefs[j-6][4] * x * p5;
+	  p2 = p3; p3 = p4; p4 = p5; p5 = p1;
+	  values[j-2] = p1;
+	}
+
+      return p-1;
+    }
+
+    template <class T>
+    inline static int CalcTrigExtDeriv (int n, double x, double y, T & values)
+    {
+      ArrayMem<AutoDiff<2>,10> ad_values(n-1);
+      AutoDiff<2> ad_x(x, 0);
+      AutoDiff<2> ad_y(y, 1);
+
+      CalcTrigExt (n, ad_x, ad_y, ad_values);
+
+      for (int i = 0; i < n-1; i++)
+	for (int j = 0; j < 2; j++)
+	  values(i,j) = ad_values[i].DValue(j);
+      return n-1;
+    }
+
+
+    template <class Sx, class T>
+    inline static int Calc (int n, Sx x, T & values)
+    {
+      Sx y = 0.0;
+      return CalcTrigExt (n, x, y, values);
+    }
+
+    template <class T>
+    inline static int CalcDeriv (int n, double x, T & values)
+    {
+      return CalcTrigExtDeriv (n, x, 0.0, values);
+    }
+  };
+
+
+
+  // ************************ MINIMAL EXTENSION *************************
+
+
+  /**
+     .......
+  */
+  class TrigExtensionMin
+  {
+  public:
+    template <class Sx, class Sy, class T>
+    inline static int CalcTrigExt (int n, Sx x, Sy y, T & values)
+    {
+#ifdef ABC
+      //    TrigExtensionOptimal::CalcTrigExt (n, x, y, values);
+
+      ArrayMem<Sx, 20> polx(n+1);
+
+      const IntegrationRule & rule =
+	GetIntegrationRules().SelectIntegrationRule (ET_SEGM, n+2);
+
+      Sx bub = (1-x-y) * (1+x-y);
+      for (int i = 0; i <= n-2; i++)
+	values[i] = 0;
+
+      for (int i = 0; i < rule.GetNIP(); i++)
+	{
+	  const IntegrationPoint & ip = rule.GetIP(i);
+
+	  Sx hx = x + y * (2.0*ip(0)-1.0);
+			 
+	  JacobiPolynomial (n-2, hx, 1, 1, polx);
+	  // LegendrePolynomial (n-2, hx, polx);
+
+	  Sx fac = bub * ip.Weight(); //  / (z*z);
+
+	  for (int j = 0; j <= n-2; j++)
+	    values[j] += fac * polx[j];
+	}
+
+
+
+      // IntegratedLegendreMonomialExt::CalcTrigExt (n, x, y, values);
+
+      /*
+	Sy fy = (1-y)*(1-y);
+	Sx p3 = 0;
+	Sx p2 = -1;
+	Sx p1 = x;
+
+	for (int j=2; j<=n; j++)
+	{
+        p3=p2; p2=p1;
+        p1=( (2*j-3) * x * p2 - (j-3) * fy * p3) / j;
+	values[j-2] = p1;
+	}
+      */
+
+      /*
+	Sx fac = 1;
+	for (int j = n-2; j >= 0; j--)
+	{
+        values[j] = fac * values[j];
+        fac = fac * (1-y);
+	}
+      */
+
+      for (int j = 0; j < n-3; j++)
+	values[j] *= VertexExtensionOptimal<2>::Calc (n-2-j, 1-y);
+
+      return n-1;
+#endif
+
+      if (y == 0.0) y += 1e-8;
+      ArrayMem<Sx, 20> pol1(n+2), pol2(n+2);
+      JacobiPolynomial (n+1, x-y, 1, 1, pol1);
+      JacobiPolynomial (n+1, x+y, 1, 1, pol2);
+      for (int i = 0; i <= n-2; i++)
+	values[i] = (pol2[i+1]-pol1[i+1]) / (2*y);
+
+      /*
+	ScaledJacobiPolynomial (n-2, x, 1-y, 2, 2, values);
+	for (int i = 0; i < n-1; i++)
+	values[i] *= 0.5 * (i+4) * (1-x*x);
+      */
+
+
+
+      LowEnergyVertexPolynomials2D (n, 1-2*y, pol1);
+      for (int i = 0; i <= n-2; i++)
+	values[i] *= pol1[n-2-i] * (1-x-y) * (1+x-y);
+
+      return n-1;
+    }
+
+    template <class T>
+    inline static int CalcTrigExtDeriv (int n, double x, double y, T & values)
+    {
+      ArrayMem<AutoDiff<2>,10> ad_values(n-1);
+      AutoDiff<2> ad_x(x, 0);
+      AutoDiff<2> ad_y(y, 1);
+
+      CalcTrigExt (n, ad_x, ad_y, ad_values);
+
+      for (int i = 0; i < n-1; i++)
+	for (int j = 0; j < 2; j++)
+	  values(i,j) = ad_values[i].DValue(j);
+      return n-1;
+    }
+
+
+
+    template <class Sx, class T>
+    inline static int Calc (int n, Sx x, T & values)
+    {
+      /*
+	Sx y = 0.0;
+	CalcTrigExt (n, x, y, values);
+      */
+
+      JacobiPolynomial (n-2, x, 2, 2, values);
+      for (int i = 0; i < n-1; i++)
+	values[i] *= 0.5 * (i+4) * (1-x*x);
+
+      return n-1;
+
+    }
+
+    template <class T>
+    inline static int CalcDeriv (int n, double x, T & values)
+    {
+      ArrayMem<AutoDiff<1>,10> ad_values(n-1);
+      AutoDiff<1> ad_x(x, 0);
+
+      Calc (n, ad_x, ad_values);
+
+      for (int i = 0; i < n-1; i++)
+	values[i] = ad_values[i].DValue(0);
+      return n-1;
+
+      // return CalcTrigExtDeriv (n, x, 0.0, values);
+    }
+  };
+
+
+}
+
+#endif

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/reorderedfespace.hpp

@@ -0,0 +1,81 @@
+#ifndef FILE_REORDERED_
+#define FILE_REORDERED_
+
+/*********************************************************************/
+/* File:   reordered.hpp                                         */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   Jun 2019                                                  */
+/*********************************************************************/
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+
+ // A reordered wrapper class for fespaces 
+
+  class ReorderedFESpace : public FESpace
+  {
+  protected:
+    Array<DofId> dofmap;
+    shared_ptr<FESpace> space;
+    shared_ptr<Table<DofId>> clusters;
+    
+  public:
+    ReorderedFESpace (shared_ptr<FESpace> space, const Flags & flags);
+    
+    virtual ~ReorderedFESpace () { ; }
+
+    virtual void Update() override;
+
+    virtual void FinalizeUpdate() override;
+
+    ProxyNode MakeProxyFunction (bool testfunction,
+                                 const function<shared_ptr<ProxyFunction>(shared_ptr<ProxyFunction>)> & addblock) const override
+    {
+      return GetBaseSpace()->MakeProxyFunction (testfunction, addblock);
+    }
+    
+    virtual string GetClassName() const override { return "Reordered" + space->GetClassName(); }
+    shared_ptr<FESpace> GetBaseSpace() const { return space; }
+    
+    virtual FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;
+
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+    virtual void GetDofNrs (NodeId ni, Array<DofId> & dnums) const override;
+
+    auto GetClusters() const { return clusters; }
+
+    
+    virtual SymbolTable<shared_ptr<DifferentialOperator>> GetAdditionalEvaluators () const override
+    { return space->GetAdditionalEvaluators (); }
+
+    [[deprecated("Use GetDofNrs(NODE_TYPE(NT_VERTEX,nr) instead")]]    
+    virtual void GetVertexDofNrs (int vnr,  Array<DofId> & dnums) const override;
+
+    [[deprecated("Use GetDofNrs(NODE_TYPE(NT_EDGE,nr) instead")]]        
+    virtual void GetEdgeDofNrs (int ednr, Array<DofId> & dnums) const override;
+    
+    virtual void GetFaceDofNrs (int fanr, Array<DofId> & dnums) const override;
+    
+    virtual void GetInnerDofNrs (int elnr, Array<DofId> & dnums) const override
+    { space->GetInnerDofNrs(elnr, dnums); }
+
+    virtual void VTransformMR (ElementId ei,
+			       SliceMatrix<double> mat, TRANSFORM_TYPE tt) const override
+    { space-> VTransformMR(ei, mat, tt); }
+    virtual void VTransformMC (ElementId ei,
+                               SliceMatrix<Complex> mat, TRANSFORM_TYPE tt) const override
+    { space->VTransformMC (ei, mat, tt); }
+    virtual void VTransformVR (ElementId ei,
+                               SliceVector<double> vec, TRANSFORM_TYPE tt) const override
+    { space->VTransformVR(ei, vec, tt); }
+    virtual void VTransformVC (ElementId ei, 
+                               SliceVector<Complex> vec, TRANSFORM_TYPE tt) const override
+    { space->VTransformVC(ei, vec, tt); }    
+  };
+
+}
+
+
+#endif // FILE_REORDERED_

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/sample_sort.hpp

@@ -0,0 +1,105 @@
+#ifndef SAMPLE_SORT_HPP_
+#define SAMPLE_SORT_HPP_
+
+/**************************************************************************/
+/* File:   sample_sort.hpp                                                */
+/* Author: Bernd Schwarzenbacher, Joachim Schoeberl                       */
+/* Date:   Nov 2017                                                       */
+/**************************************************************************/
+
+#include <random>
+
+namespace ngstd
+{
+
+  template <typename T, typename TI>
+void SampleSortI(FlatArray<T> data, FlatArray<TI> index)
+{
+  static Timer Tsample_sort("Sample Sort");
+  RegionTimer Rsample_sort(Tsample_sort);
+
+  size_t n = index.Size();
+  int nr_buckets = ngstd::TaskManager::GetNumThreads();
+  int sample_size = nr_buckets-1;
+  int over_sample = 10;
+  int over_sample_size = over_sample * sample_size;
+
+  Array<TI> over_sampled_ind(over_sample_size);
+
+  std::random_device rd;
+  std::mt19937 engine(rd());
+  std::uniform_int_distribution<int> dist(0, index.Size()-1);
+  for (auto i : Range(over_sample_size))
+    over_sampled_ind[i] = index[dist(engine)];
+  
+  QuickSortI(data, over_sampled_ind);
+
+  Array<TI> sample_ind(sample_size);
+  for (auto i : Range(sample_size)) {
+    sample_ind[i] = over_sampled_ind[i * over_sample];
+  }
+
+  Array<int> bucket_of_ind(n);
+  ParallelFor(n, [&] (auto i) {
+      int start = 0;
+      int end = sample_size-1;
+      int mid = (start+end)/2;
+      while (start <= end) {
+        mid = (start+end)/2;
+        if (data[sample_ind[mid]] < data[i]) {
+          start = mid + 1;
+          continue;
+        }
+        else if (data[sample_ind[mid]] > data[i]) {
+          end = mid - 1;
+          continue;
+        }
+        else { break; }
+      }
+      if (start > end) {
+        bucket_of_ind[i] = start;
+      }
+      else {
+        bucket_of_ind[i] = mid;
+      }
+    });
+
+  static Timer T3_2("Sample Sort - inverse index bucket map");
+  T3_2.Start();
+  ngstd::TableCreator<int> buckets_creator(nr_buckets);
+  for (; !buckets_creator.Done(); buckets_creator++) {
+    ParallelForRange (n, [&] (IntRange r)
+                      {
+                        ngstd::TableCreator<int> mycreator(nr_buckets);
+                        for (; !mycreator.Done(); mycreator++)                      
+                          for (auto i : r)
+                            mycreator.Add (bucket_of_ind[i], i);
+
+                        auto mytab = mycreator.MoveTable();
+                        for (auto i : Range(nr_buckets))
+                          buckets_creator.Add (i, mytab[i]);
+                      });
+  }
+  
+  auto table = buckets_creator.MoveTable();
+  T3_2.Stop();
+
+  static Timer T4("Sample Sort - sort buckets");
+  T4.Start();
+  ParallelFor(nr_buckets, [&] (auto bucket) {
+    QuickSortI(data, table[bucket]);
+  });
+  T4.Stop();
+
+  size_t start = 0;
+  for (size_t bucket = 0; bucket < table.Size(); ++bucket) {
+    size_t end = start+table[bucket].Size();
+    index.Range(start, end) = table[bucket];
+    start = end;
+  }
+}
+
+
+} 
+
+#endif  // SAMPLE_SORT_HPP_