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

netgen/include/analytic_integrals.hpp

@@ -0,0 +1,10 @@
+#include <bla.hpp>
+
+namespace ngsbem
+{
+  using namespace ngbla;
+
+  NGS_DLL_HEADER double LaplaceSL_Triangle (Vec<3> a, Vec<3> b, Vec<3> c, Vec<3> x);
+  NGS_DLL_HEADER double LaplaceDL_Triangle (Vec<3> a, Vec<3> b, Vec<3> c, Vec<3> x);
+}
+

netgen/include/basematrix.hpp

@@ -106,6 +106,12 @@ namespace ngla
       Mult (v, res);
       return res;
     }
+    virtual AutoVector EvaluateTrans(BaseVector & v) const 
+    {
+      auto res = CreateRowVector();
+      MultTrans (v, res);
+      return res;
+    }
     
     /// y = matrix * x. 
     virtual void Mult (const BaseVector & x, BaseVector & y) const;

netgen/include/bdbequations.hpp

@@ -229,6 +229,26 @@ namespace ngfem
       Cast(fel).CalcMappedDShape (mip, Trans(mat));
     }
 
+
+    static int DimRef() { return D-1; } 
+    
+    template <typename IP, typename MAT>
+    static void GenerateMatrixRef (const FiniteElement & fel, const IP & ip,
+                                   MAT && mat, LocalHeap & lh)
+    {
+      Cast(fel).CalcDShape (ip, Trans(mat));
+    }
+
+    template <typename MIP, typename MAT>
+    static void CalcTransformationMatrix (const MIP & mip,
+                                          MAT & mat, LocalHeap & lh)
+    {
+      mat = Trans(static_cast<const MappedIntegrationPoint<D-1,D>&>(mip).GetJacobianInverse());
+    }
+
+
+    
+
     static void GenerateMatrixSIMDIR (const FiniteElement & fel,
                                       const SIMD_BaseMappedIntegrationRule & mir,
                                       BareSliceMatrix<SIMD<double>> mat)
@@ -2324,6 +2344,39 @@ namespace ngfem
         mat.Rows(DIM_SPC*i, DIM_SPC*(i+1)).Cols(fel.GetRange(i)) = Trans(hmat);
     }
 
+    static int DimRef() { return DIM_SPC*DIM_ELEMENT; } 
+    
+    template <typename IP, typename MAT>
+    static void GenerateMatrixRef (const FiniteElement & bfel, const IP & ip,
+                                   MAT && mat, LocalHeap & lh)
+    {
+      HeapReset hr(lh);
+      auto & fel = static_cast<const VectorFiniteElement&> (bfel);
+      auto & feli = static_cast<const ScalarFiniteElement<DIM_ELEMENT>&> (fel[0]);
+      FlatMatrix<> hmat(feli.GetNDof(), DIM_ELEMENT, lh);
+      feli.CalcDShape(ip, hmat);
+      int ndof = feli.GetNDof();
+      mat.Rows(DIM_SPACE*DIM_ELEMENT).Cols(DIM_SPC*ndof) = 0.0;
+      for (int i = 0; i < DIM_SPACE; i++)
+        mat.Rows(i*DIM_ELEMENT, (i+1)*DIM_ELEMENT).Cols(i*ndof,(i+1)*ndof)
+          = Trans(hmat);
+    }
+
+    template <typename MIP, typename MAT>
+    static void CalcTransformationMatrix (const MIP & mip,
+                                          MAT & mat, LocalHeap & lh)
+    {
+      FlatMatrix<> hmat(DIM_SPC, DIM_ELEMENT, lh);      
+      hmat = Trans(static_cast<const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPC>&>(mip).GetJacobianInverse());
+      mat.Rows(DIM_DMAT).Cols(DIM_ELEMENT*DIM_SPC) = 0.0;
+      for (int i = 0; i < DIM_SPACE; i++)
+        mat.Rows(i*DIM_SPC, (i+1)*DIM_SPC).Cols(i*DIM_ELEMENT, (i+1)*DIM_ELEMENT) = hmat;
+    }
+    
+
+
+
+
     
     static void GenerateMatrixSIMDIR (const FiniteElement & bfel,
                                       const SIMD_BaseMappedIntegrationRule & mir,
@@ -2730,9 +2783,11 @@ namespace ngfem
   extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradVectorH1<2> >;
   extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradVectorH1<3> >;
 
+  extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradientBoundary<1> >;
   extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradientBoundary<2> >;
   extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradientBoundary<3> >;
 
+  extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradBoundaryVectorH1<1> >;
   extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradBoundaryVectorH1<2> >;
   extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradBoundaryVectorH1<3> >;
 

netgen/include/bem_diffops.hpp

@@ -0,0 +1,475 @@
+#ifndef DIFFOPS_HPP
+#define DIFFOPS_HPP
+
+#include <bla.hpp>
+#include <scalarfe.hpp>
+#include <hcurlfe.hpp>
+#include <hdivfe.hpp>
+#include <diffop_impl.hpp>
+
+
+namespace ngsbem
+{
+  using namespace ngbla;
+  using namespace ngfem;
+
+
+  class DiffOpBoundaryRot : public DiffOp<DiffOpBoundaryRot>
+  {
+  public:
+    enum { DIM = 1 };
+    enum { DIM_SPACE = 3 };
+    enum { DIM_ELEMENT = 2 };
+    enum { DIM_DMAT = 3 };
+    enum { DIFFORDER = 1 };
+
+    static bool SupportsVB (VorB checkvb) { return checkvb==BND; }
+    
+    static string Name() { return "boundaryrot"; }
+    
+    static const ScalarFiniteElement<2> & Cast (const FiniteElement & fel) 
+    { return static_cast<const ScalarFiniteElement<2>&> (fel); }
+
+    ///
+    // mat is 3 x ndof
+    template <typename AFEL, typename MIP, typename MAT>
+    static void GenerateMatrix (const AFEL & fel, const MIP & mip,
+				MAT & mat, LocalHeap & lh)
+    {
+      Cast(fel).CalcMappedDShape (mip, Trans(mat));
+      for (int i = 0; i < fel.GetNDof(); i++)
+        {
+          Vec<3> grad = mat.Col(i);
+          mat.Col(i) = Cross(mip.GetNV(), grad);
+        }
+    }
+
+    static int DimRef() { return 2; } 
+    
+    template <typename IP, typename MAT>
+    static void GenerateMatrixRef (const FiniteElement & fel, const IP & ip,
+                                   MAT && mat, LocalHeap & lh)
+    {
+      Cast(fel).CalcDShape (ip, Trans(mat));
+    }
+
+    template <typename MIP, typename MAT>
+    static void CalcTransformationMatrix (const MIP & bmip,
+                                          MAT & mat, LocalHeap & lh)
+    {
+      auto & mip = static_cast<const MappedIntegrationPoint<2,3>&>(bmip); 
+      Vec<3> nv = mip.GetNV();
+      mat = Trans(mip.GetJacobianInverse());
+
+      for (int j = 0; j < 2; j++)
+        mat.Col(j) = Cross(nv, Vec<3> (mat.Col(j)));
+    }
+    
+
+    /// mat is (ndof*3) x mip.Size()
+    static void GenerateMatrixSIMDIR (const FiniteElement & fel,
+                                      const SIMD_BaseMappedIntegrationRule & mir,
+                                      BareSliceMatrix<SIMD<double>> mat)
+    {
+      Cast(fel).CalcMappedDShape (mir, mat);
+
+      for (int j = 0; j < mir.Size(); j++)
+        {
+          Vec<3,SIMD<double>> nv = static_cast<const SIMD<ngfem::MappedIntegrationPoint<3,3>>&>(mir[j]).GetNV();
+          for (int i = 0; i < fel.GetNDof(); i++)
+            {
+              Vec<3,SIMD<double>> grad = mat.Col(j).Range(3*i, 3*i+3);
+              mat.Col(j).Range(3*i,3*i+3) = Cross(nv, grad);
+            }
+        }
+    }
+  };
+
+
+
+
+  class DiffOpRotatedTrace : public DiffOp<DiffOpRotatedTrace>
+  {
+  public:
+    enum { DIM = 1 };
+    enum { DIM_SPACE = 3 };
+    enum { DIM_ELEMENT = 2 };
+    enum { DIM_DMAT = 3 };
+    enum { DIFFORDER = 1 };
+
+    static string Name() { return "rotatedtrace"; }
+    static int DimRef() { return 2; }
+
+    static const HCurlFiniteElement<2> & Cast (const FiniteElement & fel) 
+    { return static_cast<const HCurlFiniteElement<2>&> (fel); }
+
+    // mat is 2 x ndof
+    template <typename IP, typename MAT>
+    static void GenerateMatrixRef (const FiniteElement & fel, const IP & ip,
+                                    MAT && mat, LocalHeap & lh)
+    {
+        Cast(fel).CalcShape (ip, Trans(mat));
+    }
+
+    ///
+    // mat is 3 x ndof
+    template <typename AFEL, typename MIP, typename MAT>
+    static void GenerateMatrix (const AFEL & fel, const MIP & mip,
+				MAT & mat, LocalHeap & lh)
+    {
+      Cast(fel).CalcMappedShape (mip, Trans(mat));
+      for (int i = 0; i < fel.GetNDof(); i++)
+        {
+          Vec<3> shape = mat.Col(i);
+          mat.Col(i) = Cross(mip.GetNV(), shape);
+        }
+    }
+
+    // mat is 3 x 2
+    template <typename MIP, typename MAT>
+    static void CalcTransformationMatrix (const MIP & bmip,
+                                          MAT & mat, LocalHeap & lh)
+    {
+        auto & mip = static_cast<const MappedIntegrationPoint<2,3>&>(bmip);
+        Vec<3> nv = mip.GetNV();
+        mat = Trans(mip.GetJacobianInverse());
+
+        for (int j = 0; j < 2; j++)
+          mat.Col(j) = Cross(nv, Vec<3> (mat.Col(j)));
+    }
+
+    /// mat is (ndof*3) x mip.Size()
+    static void GenerateMatrixSIMDIR (const FiniteElement & fel,
+                                      const SIMD_BaseMappedIntegrationRule & mir,
+                                      BareSliceMatrix<SIMD<double>> mat)
+    {
+      Cast(fel).CalcMappedShape (mir, mat);
+
+      for (int j = 0; j < mir.Size(); j++)
+        {
+          Vec<3,SIMD<double>> nv = static_cast<const SIMD<ngfem::MappedIntegrationPoint<2,3>>&>(mir[j]).GetNV();
+          for (int i = 0; i < fel.GetNDof(); i++)
+            {
+              Vec<3,SIMD<double>> shape = mat.Col(j).Range(3*i, 3*i+3);
+              mat.Col(j).Range(3*i,3*i+3) = Cross(nv, shape);
+            }
+        }
+    }
+  };
+
+  // rotated + scalar
+  class DiffOpHelmholtz : public DiffOp<DiffOpHelmholtz>
+  {
+  public:
+    enum { DIM = 1 };
+    enum { DIM_SPACE = 3 };
+    enum { DIM_ELEMENT = 2 };
+    enum { DIM_DMAT = 4 };
+    enum { DIFFORDER = 1 };
+
+    static string Name() { return "Helmholtz"; }
+    static int DimRef() { return 3; }
+
+    static const ScalarFiniteElement<2> & Cast (const FiniteElement & fel) 
+    { return static_cast<const ScalarFiniteElement<2>&> (fel); }
+
+    // mat is 3xndof
+    template <typename IP, typename MAT>
+    static void GenerateMatrixRef (const FiniteElement & fel, const IP & ip,
+                                    MAT && mat, LocalHeap & lh)
+    {
+        auto matvec = mat.Rows(0,2);
+        Cast(fel).CalcDShape (ip, Trans(matvec));
+        Cast(fel).CalcShape(ip, mat.Row(2));
+    }
+
+    ///
+    // mat is 4 x ndof
+    template <typename AFEL, typename MIP, typename MAT>
+    static void GenerateMatrix (const AFEL & fel, const MIP & mip,
+				MAT & mat, LocalHeap & lh)
+    {
+      // mat.AddSize(4, fel.GetNDof()) = 0.0;
+      auto matvec = mat.Rows(0,3);
+      Cast(fel).CalcMappedDShape (mip, Trans(matvec));
+      for (int i = 0; i < fel.GetNDof(); i++)
+        {
+          Vec<3> grad = matvec.Col(i);
+          matvec.Col(i) = Cross(mip.GetNV(), grad);
+        }
+      // *testout << "mat1 = " << mat << endl;
+      // mat.AddSize(4, fel.GetNDof()) = 0.0;
+      Cast(fel).CalcShape(mip.IP(), mat.Row(3));
+      // *testout << "scalar mat = " << endl << mat << mat;
+      // *testout << "mat2 = " << mat << endl;      
+    }
+
+    // mat is 4x3
+    template <typename MIP, typename MAT>
+    static void CalcTransformationMatrix (const MIP & bmip,
+                                          MAT & mat, LocalHeap & lh)
+    {
+      auto & mip = static_cast<const MappedIntegrationPoint<2,3>&>(bmip); 
+      Vec<3> nv = mip.GetNV();
+      mat = 0.0;
+      mat.Rows(0,3).Cols(0,2) = Trans(mip.GetJacobianInverse());
+      auto gradmat = mat.Rows(0,3).Cols(0,2);
+      for (int j = 0; j < 2; j++)
+        gradmat.Col(j) = Cross(nv, Vec<3> (gradmat.Col(j)));
+
+      mat(3,2) = 1.0;
+    }
+
+    /// mat is (ndof*4) x mip.Size()
+    static void GenerateMatrixSIMDIR (const FiniteElement & fel,
+                                      const SIMD_BaseMappedIntegrationRule & mir,
+                                      BareSliceMatrix<SIMD<double>> mat)
+    {
+      Cast(fel).CalcMappedDShape (mir, mat.Rows(0, 3*fel.GetNDof()));
+
+      for (int j = 0; j < mir.Size(); j++)
+        {
+          Vec<3,SIMD<double>> nv = static_cast<const SIMD<ngfem::MappedIntegrationPoint<3,3>>&>(mir[j]).GetNV();
+	  for (int i = fel.GetNDof()-1; i >= 0; i--)
+            {
+	      Vec<3,SIMD<double>> grad = mat.Col(j).Range(3*i, 3*i+3);
+              mat.Col(j).Range(4*i,4*i+3) = Cross(nv, grad);
+            }
+        }
+      // *testout << "simd mat1 = " << endl << mat.AddSize(4*fel.GetNDof(), mir.Size()) << endl;            
+      // mat.AddSize(4*fel.GetNDof(), mir.Size()) = SIMD<double>(0.0);
+      Cast(fel).CalcShape (mir.IR(), mat.RowSlice(3,4));
+    }
+  };
+
+
+
+  // rotated 
+  class DiffOpMaxwell : public DiffOp<DiffOpMaxwell>
+  {
+  public:
+    enum { DIM = 1 };
+    enum { DIM_SPACE = 3 };
+    enum { DIM_ELEMENT = 2 };
+    enum { DIM_DMAT = 4 };
+    enum { DIFFORDER = 1 };
+
+    static string Name() { return "Maxwell"; }
+    static int DimRef() { return 3; }
+
+    static const HCurlFiniteElement<2> & Cast (const FiniteElement & fel) 
+    { return static_cast<const HCurlFiniteElement<2>&> (fel); }
+
+    // mat is 3 x ndof
+    template <typename IP, typename MAT>
+    static void GenerateMatrixRef (const FiniteElement & fel, const IP & ip,
+                                    MAT && mat, LocalHeap & lh)
+    {
+      // auto matvec = mat.Rows(0,2);
+        Cast(fel).CalcShape (ip, Trans(mat));
+        Cast(fel).CalcCurlShape(ip, Trans(mat.Rows(2,3)));
+    }
+
+    ///
+    // mat is 4 x ndof
+    template <typename AFEL, typename MIP, typename MAT>
+    static void GenerateMatrix (const AFEL & fel, const MIP & mip,
+				MAT & mat, LocalHeap & lh)
+    {
+      // mat.AddSize(4, fel.GetNDof()) = 0.0;
+      auto matvec = mat.Rows(0,3);
+      Cast(fel).CalcMappedShape (mip, Trans(matvec));
+      for (int i = 0; i < fel.GetNDof(); i++)
+        {
+          Vec<3> shape = matvec.Col(i);
+          matvec.Col(i) = Cross(mip.GetNV(), shape);
+        }
+      // *testout << "mat1 = " << mat << endl;
+      // mat.AddSize(4, fel.GetNDof()) = 0.0;      
+      mat.Row(3) =
+        1.0/mip.GetJacobiDet() * 
+	Cast(fel).GetCurlShape(mip.IP(),lh).Col(0);
+      // *testout << "scalar mat = " << endl << mat << mat;
+      // *testout << "mat2 = " << mat << endl;      
+    }
+
+    // mat is 4x3
+    template <typename MIP, typename MAT>
+    static void CalcTransformationMatrix (const MIP & bmip,
+                                          MAT & mat, LocalHeap & lh)
+    {
+      auto & mip = static_cast<const MappedIntegrationPoint<2,3>&>(bmip);
+      Vec<3> nv = mip.GetNV();
+      mat = 0.0;
+      mat.Rows(0,3).Cols(0,2) = Trans(mip.GetJacobianInverse());
+      auto matvec = mat.Rows(0,3).Cols(0,2);
+      for (int j = 0; j < 2; j++)
+        matvec.Col(j) = Cross(nv, Vec<3> (matvec.Col(j)));
+
+      mat(3,2) = 1.0 / mip.GetJacobiDet();
+    }
+
+    /// mat is (ndof*4) x mip.Size()
+    static void GenerateMatrixSIMDIR (const FiniteElement & fel,
+                                      const SIMD_BaseMappedIntegrationRule & mir,
+                                      BareSliceMatrix<SIMD<double>> mat)
+    {
+      Cast(fel).CalcMappedShape (mir, mat.Rows(0, 3*fel.GetNDof()));
+      for (int j = 0; j < mir.Size(); j++)
+        {
+          Vec<3,SIMD<double>> nv = static_cast<const SIMD<ngfem::MappedIntegrationPoint<2,3>>&>(mir[j]).GetNV();
+          for (int i = fel.GetNDof()-1; i >= 0; i--)
+            {
+              Vec<3,SIMD<double>> shape = mat.Col(j).Range(3*i, 3*i+3);
+              mat.Col(j).Range(4*i,4*i+3) = Cross(nv, shape);
+              // mat.Col(j).Range(4*i+3,4*i+4) = SIMD<double>(0.0);
+            }
+        }
+      // *testout << "simd mat1 = " << endl << mat.AddSize(4*fel.GetNDof(), mir.Size()) << endl;            
+      // mat.AddSize(4*fel.GetNDof(), mir.Size()) = SIMD<double>(0.0);
+      
+      constexpr size_t BS=16;
+      LocalHeapMem<BS*SIMD<double>::Size()*sizeof(SIMD<MappedIntegrationPoint<2,2>>)+64> lh("genmatlh");
+      FE_ElementTransformation<2,2> trafo2d(fel.ElementType());
+      for (size_t first = 0; first < mir.Size(); first += BS)
+        {
+          HeapReset hr(lh);
+          size_t next = std::min(first+BS, mir.Size());
+          SIMD_MappedIntegrationRule<2,2> mir2d(mir.IR().Range(first, next), trafo2d, lh);
+          Cast(fel).CalcMappedCurlShape (mir2d, mat.RowSlice(3,4).Cols(first, next));
+        }
+      for (size_t i = 0; i < mir.Size(); i++)
+        mat.Col(i).Slice(3,4).Range(fel.GetNDof()) *= 1.0 / mir[i].GetJacobiDet();
+      // *testout << "simd mat2 = " << endl << mat.AddSize(4*fel.GetNDof(), mir.Size()) << endl;      
+    }
+
+    using DiffOp<DiffOpMaxwell>::ApplySIMDIR;
+    static void ApplySIMDIR (const FiniteElement & fel, const SIMD_BaseMappedIntegrationRule & mir,
+                             BareSliceVector<Complex> x, BareSliceMatrix<SIMD<Complex>> y)
+    {
+      Cast(fel).Evaluate (mir, x, y.Rows(3));
+      for (int j = 0; j < mir.Size(); j++)
+        {
+          Vec<3,SIMD<double>> nv = static_cast<const SIMD<ngfem::MappedIntegrationPoint<2,3>>&>(mir[j]).GetNV();
+          Vec<3,SIMD<Complex>> shape = y.Col(j).Range(0,3);
+          y.Col(j).Range(0,3) = Cross(nv, shape);
+        }
+      y.Row(3).Range(mir.Size()) = SIMD<Complex>(0.0);
+      // TODO: curl part
+    }
+  };
+
+
+
+
+
+
+  // copied from ngsolve/fem/hdiv_equations.hpp, DiffOpIdHDivSurface
+  class DiffOpMaxwellNew : public DiffOp<DiffOpMaxwellNew>
+  {
+  public:
+    enum { DIM = 1 };
+    enum { DIM_SPACE = 3 };
+    enum { DIM_ELEMENT = 2 };
+    enum { DIM_DMAT = 4 };
+    enum { DIFFORDER = 1 };
+
+    static string Name() { return "Maxwell"; }
+    static int DimRef() { return 3; }
+    
+    static const HDivFiniteElement<2> & Cast (const FiniteElement & fel) 
+    { return static_cast<const HDivFiniteElement<2>&> (fel); }
+
+    // mat is 3xndof
+    template<typename IP, typename MAT>
+    static void GenerateMatrixRef (const FiniteElement & fel, const IP & ip,
+                                   MAT && mat, LocalHeap & lh)
+    {
+      auto matvec = mat.Rows(0,2); // 2D vector field
+      Cast(fel).CalcShape (ip, Trans(matvec));
+      Cast(fel).CalcDivShape (ip, mat.Row(2)); //divergence
+    }
+
+    ///
+    // mat is 4 x ndof
+    template <typename AFEL, typename MIP, typename MAT>
+    static void GenerateMatrix (const AFEL & fel, const MIP & mip,
+				MAT & mat, LocalHeap & lh)
+    {
+      auto matvec = mat.Rows(0,3);
+      matvec = (1.0 / mip.GetJacobiDet()) *mip.GetJacobian () * 
+        Trans (Cast(fel).GetShape(mip.IP(),lh));
+
+      mat.Row(3) =
+        1.0/mip.GetJacobiDet() * 
+	Cast(fel).GetDivShape(mip.IP(),lh).Col(0);
+    }
+
+    // mat is 4x3
+    template <typename MIP, typename MAT>
+    static void CalcTransformationMatrix (const MIP & bmip,
+                                          MAT & mat, LocalHeap & lh)
+    {
+        auto & mip = static_cast<const MappedIntegrationPoint<2,3>&>(bmip);
+        mat = 0.0;
+        mat.Rows(0,3).Cols(0,2) = (1.0 / mip.GetJacobiDet()) * mip.GetJacobian();
+        mat(3,2) = 1.0 / mip.GetJacobiDet();
+    }
+
+    /// mat is (ndof*4) x mip.Size()
+    static void GenerateMatrixSIMDIR (const FiniteElement & fel,
+                                      const SIMD_BaseMappedIntegrationRule & mir,
+                                      BareSliceMatrix<SIMD<double>> mat)
+    {
+      Cast(fel).CalcMappedShape (mir, mat.Rows(0, 3*fel.GetNDof()));
+      for (int j = 0; j < mir.Size(); j++)
+        {
+          for (int i = fel.GetNDof()-1; i >= 0; i--)
+            {
+              Vec<3,SIMD<double>> shape = mat.Col(j).Range(3*i, 3*i+3);
+              mat.Col(j).Range(4*i,4*i+3) = shape;
+            }
+        }
+
+      Cast(fel).CalcMappedDivShape (mir, mat.RowSlice(3, 4));
+      /*
+      constexpr size_t BS=16;
+      LocalHeapMem<BS*SIMD<double>::Size()*sizeof(SIMD<MappedIntegrationPoint<2,2>>)+64> lh("genmatlh");
+      FE_ElementTransformation<2,2> trafo2d(fel.ElementType());
+      for (size_t first = 0; first < mir.Size(); first += BS)
+        {
+          HeapReset hr(lh);
+          size_t next = std::min(first+BS, mir.Size());
+          SIMD_MappedIntegrationRule<2,2> mir2d(mir.IR().Range(first, next), trafo2d, lh);
+          Cast(fel).CalcMappedDivShape (mir2d, mat.RowSlice(3,4).Cols(first, next));
+        }
+      for (size_t i = 0; i < mir.Size(); i++)
+        mat.Col(i).Slice(3,4).Range(fel.GetNDof()) *= 1.0 / mir[i].GetJacobiDet();
+      */
+    }
+
+    using DiffOp<DiffOpMaxwellNew>::ApplySIMDIR;
+    static void ApplySIMDIR (const FiniteElement & fel, const SIMD_BaseMappedIntegrationRule & mir,
+                             BareSliceVector<Complex> x, BareSliceMatrix<SIMD<Complex>> y)
+    {
+      Vector<> xr(fel.GetNDof()), xi(fel.GetNDof());
+      Matrix<SIMD<double>> valr(3,mir.Size()), vali(3, mir.Size());
+
+      xr = Real(x);
+      xi = Imag(x);
+      Cast(fel).Evaluate (mir, xr, valr);
+      Cast(fel).Evaluate (mir, xi, vali);
+      
+      for (int j = 0; j < mir.Size(); j++)
+        for (int k = 0; k < 3; k ++)
+          y(k,j) = SIMD<Complex> (valr(k,j), vali(k,j));
+      y.Row(3).Range(mir.Size()) = SIMD<Complex>(0.0);
+    }
+  };
+
+
+  
+}
+
+
+#endif

netgen/include/bilinearform.hpp

@@ -915,7 +915,7 @@ namespace ngcomp
   };
 
 
-
+  // template <int DIM_ELEMENT, int DIM_SPACE>
   class ApplyIntegrationPoints : public BaseMatrix
   {
     Array<shared_ptr<CoefficientFunction>> coefs;
@@ -952,6 +952,9 @@ namespace ngcomp
     size_t GetDimX() const { return dimx; }
     size_t GetDimY() const { return dimy; }
     size_t GetNIP() const { return nip; }
+
+    FlatMatrix<double> GetPoints() const { return points; }
+    FlatMatrix<double> GetNormals() const { return normals; }
   };  
   
 

netgen/include/bspline.hpp

@@ -13,6 +13,7 @@ namespace ngstd
 
   class BSpline 
   {
+    shared_ptr<BSpline> diff = nullptr;
     int order;
     Array<double> t;
     Array<double> c;
@@ -48,6 +49,7 @@ namespace ngstd
     NGS_DLL_HEADER SIMD<double> operator() (SIMD<double> x) const;
     // NGS_DLL_HEADER SIMD<Complex> operator() (SIMD<Complex> x) const;
     
+    int GetOrder() const { return order; }
     friend ostream & operator<< (ostream & ost, const BSpline & sp);
   };
 

netgen/include/code_generation.hpp

@@ -57,7 +57,7 @@ namespace ngfem
 
     string pointer;
 
-    NGS_DLL_HEADER string AddPointer(const void *p );
+    NGS_DLL_HEADER string AddPointer(const void *p, string name = "", string type = "void *", string qualifiers = "");
 
     void AddLinkFlag(string flag);
 
@@ -287,7 +287,7 @@ namespace ngfem
   }
 
   std::filesystem::path CreateTempDir();
-  unique_ptr<SharedLibrary> CompileCode(const std::vector<std::variant<filesystem::path, string>> &codes, const std::vector<string> &link_flags, bool keep_files = false );
+  unique_ptr<SharedLibrary> CompileCode(const std::vector<std::variant<filesystem::path, string>> &codes, const std::vector<string> &link_flags, bool keep_files = false, optional<string> compiler = nullopt, optional<string> linker = nullopt);
   namespace detail {
       string GenerateL2ElementCode(int order);
   }

netgen/include/complex_wrapper.hpp

@@ -1,15 +1,17 @@
 #ifndef COMPLEX_WRAPPER
 #define COMPLEX_WRAPPER
 
+
+
 #include <complex>
 
+
 #ifdef USE_MYCOMPLEX
 #include <mycomplex.hpp>
 #endif
 
 
 
-
 // #ifdef __clang__
 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
 namespace std
@@ -25,18 +27,44 @@ namespace std
 
 
 
+
 namespace ngcore
 {
+  
 #ifdef USE_MYCOMPLEX
   typedef ngstd::MyComplex<double> Complex;
   using std::fabs;
-  inline double fabs (Complex v) { return ngstd::abs (v); }
+  INLINE double fabs (Complex v) { return ngstd::abs (v); }
 #else
   typedef std::complex<double> Complex;
   using std::fabs;
   inline double fabs (Complex v) { return std::abs (v); }
 #endif
+  
+}
+
+
+#if defined(__CUDA_ARCH__)
+namespace ngcore
+{
+  __device__ inline Complex conj(Complex a)
+  {
+    return Complex (a.real(), -a.imag());
+  }
+
+  __device__ inline Complex operator+ (Complex a, Complex b) {
+    return Complex(a.real()+b.real(), a.imag()+b.imag());
+  }
+  __device__ inline Complex& operator+= (Complex& a, Complex b) {
+    a = a+b;
+    return a;
+  }
 }
+#endif
+
+
+
+