ngsolve 6.2.2502__cp311-cp311-win_amd64.whl → 6.2.2601__cp311-cp311-win_amd64.whl

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
+
+
+
+
 
 
 

netgen/include/contact.hpp

@@ -89,6 +89,7 @@ namespace ngcomp
     shared_ptr<CoefficientFunction> cf;
     shared_ptr<FESpace> fes;
     Array<ProxyFunction*> trial_proxies;
+    Array<CoefficientFunction*> cf_gridfunctions;
     bool deformed;
 
   public:
@@ -123,6 +124,9 @@ namespace ngcomp
     shared_ptr<CoefficientFunction> cf;
     shared_ptr<FESpace> fes;
     Array<ProxyFunction*> trial_proxies, test_proxies;
+    Array<CoefficientFunction*> cf_gridfunctions;
+    Array<shared_ptr<CoefficientFunction>> dcf_dtest;  // derivatives by test-functions
+    Matrix<shared_ptr<CoefficientFunction>> ddcf_dtest_dtrial;  // derivatives by test- and trial-functions
     bool deformed;
   public:
     ContactIntegrator(shared_ptr<CoefficientFunction> _cf,
@@ -187,6 +191,10 @@ namespace ngcomp
     const auto& GetIntegrators(bool def) const { return def ? deformed_integrators : undeformed_integrators; }    
     shared_ptr<FESpace> GetFESpace() const { return fes; }
     tuple<FlatArray<Vec<3>>, FlatArray<Vec<3>>> GetDrawingPairs() { return {primary_points, secondary_points}; }
+    auto GetCArgs() {
+      return std::make_tuple(master, other, draw_pairs, volume, element_boundary);
+    }
+    void DoArchive(Archive& ar);
   };
 
   template<int DIM>

netgen/include/diagonalmatrix.hpp

@@ -47,6 +47,10 @@ namespace ngla
       Mult (v, res);
       return res;
     }
+    AutoVector EvaluateTrans(BaseVector & v) const override
+    {
+      return this->Evaluate(v);
+    }
     
   };
 
@@ -144,6 +148,8 @@ namespace ngla
 
     FlatTensor<3> GetBlockDiag () const { return blockdiag; }
     FlatMatrix<bool> GetNonZeroPattern() const { return nonzero; }
+    FlatTable<int> GetSparseMatrix() const { return sparse; }
+    FlatTable<int> GetSparseMatrixTrans() const { return sparseT; }
   };
 
 }

netgen/include/diffop_impl.hpp

@@ -312,10 +312,12 @@ namespace ngfem
   
   template <typename DIFFOP>
   void T_DifferentialOperator<DIFFOP> ::
-  CalcTransformationMatrix (const BaseMappedIntegrationPoint & mip,
+  CalcTransformationMatrix (const BaseMappedIntegrationPoint & bmip,
                             SliceMatrix<double> trans,
                             LocalHeap & lh) const
   {
+    const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE> & mip =
+      static_cast<const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE>&> (bmip);
     DIFFOP::CalcTransformationMatrix(mip, trans, lh);    
   }
   

netgen/include/diffopwithfactor.hpp

@@ -0,0 +1,123 @@
+#ifndef DIFFOPWITHFACTOR_HPP
+#define DIFFOPWITHFACTOR_HPP
+
+
+
+namespace ngsbem
+{
+  using namespace ngfem;
+
+  class DifferentialOperatorWithFactor : public DifferentialOperator
+  {
+    shared_ptr<DifferentialOperator> diffop;
+    shared_ptr<CoefficientFunction> factor;
+
+  public:
+    DifferentialOperatorWithFactor (shared_ptr<DifferentialOperator> adiffop,
+                                    shared_ptr<CoefficientFunction> afactor)
+      : DifferentialOperator(afactor->Dimensions()[0], 1, adiffop->VB(), adiffop->DiffOrder()),
+        diffop(adiffop), factor(afactor)
+    {
+      ;
+    }
+
+    int DimRef() const override { return diffop->DimRef(); }
+
+    virtual IntRange UsedDofs(const FiniteElement & fel) const override { return diffop->UsedDofs(fel); }
+
+    auto BaseDiffOp() const { return diffop; }
+
+    void CalcMatrix (const FiniteElement & fel,
+                     const BaseMappedIntegrationPoint & mip,
+                     BareSliceMatrix<double,ColMajor> mat, 
+                     LocalHeap & lh) const override
+    {
+      FlatMatrix<double,ColMajor> hmat(diffop->Dim(), fel.GetNDof(), lh);
+      diffop -> CalcMatrix (fel, mip, hmat, lh);
+
+      auto dims = factor->Dimensions();      
+      FlatMatrix<double> factorx(dims[0], dims[1], lh);
+      factor->Evaluate (mip, factorx.AsVector());
+
+      IntRange used = diffop->UsedDofs(fel);
+      mat.Cols(used) = factorx * hmat.Cols(used);
+    }
+    
+    void CalcMatrix (const FiniteElement & fel,
+                     const SIMD_BaseMappedIntegrationRule & mir,
+                     BareSliceMatrix<SIMD<double>> mat) const override
+    {
+      // *testout << "CalcMatrix SIMD" << endl;      
+      Matrix<SIMD<double>> hmat (fel.GetNDof()*diffop->Dim(), mir.Size());
+      // hmat = SIMD<double>(0.0);
+      diffop -> CalcMatrix (fel, mir, hmat);
+
+      Matrix<SIMD<double>> fac(factor->Dimension(), mir.Size());
+      factor -> Evaluate (mir, fac);
+
+      auto dims = factor -> Dimensions();
+
+      mat.Rows(fel.GetNDof()*dims[1]).Cols(mir.Size()) = SIMD<double>(0.0);
+      
+      for (size_t i = 0; i < mir.Size(); i++)
+        for (size_t j = 0; j < dims[0]; j++)
+          for (size_t k = 0; k < dims[1]; k++)
+            mat.Col(i).Slice(j,dims[0]) += fac(j*dims[1]+k, i) * hmat.Col(i).Slice(k, dims[1]);
+    }
+    
+
+    void CalcMatrix (const FiniteElement & fel,
+                     const IntegrationPoint & ip,
+                     BareSliceMatrix<double,ColMajor> mat,
+                     LocalHeap & lh) const override
+    {
+      diffop -> CalcMatrix(fel, ip, mat, lh);
+      /*
+      *testout << "calcmatrix mip" << endl
+               << mat.Rows(Dim()).Cols(fel.GetNDof()) << endl;
+      */
+    }
+
+    void CalcTransformationMatrix (const BaseMappedIntegrationPoint & mip,
+                                   SliceMatrix<double> trans,
+                                   LocalHeap & lh) const override
+    {
+      HeapReset hr(lh);
+      auto dims = factor->Dimensions();
+      
+      FlatMatrix<double> factorx(dims[0], dims[1], lh);
+      factor->Evaluate (mip, factorx.AsVector());
+
+      FlatMatrix<double> basetrans(diffop->Dim(), diffop->DimRef(), lh);
+      diffop -> CalcTransformationMatrix(mip, basetrans, lh);
+
+      trans = factorx * basetrans;
+      // *testout << "trans = " << trans << endl;
+    }
+
+
+    void Apply (const FiniteElement & fel,
+                const SIMD_BaseMappedIntegrationRule & mir,
+                BareSliceVector<double> x, 
+                BareSliceMatrix<SIMD<double>> flux) const override
+    {
+      auto dims = factor->Dimensions();
+
+      Matrix<SIMD<double>> tmpflux(dims[1], mir.Size());
+      Matrix<SIMD<double>> factorx(dims[0]*dims[1], mir.Size());
+      
+      diffop -> Apply (fel, mir, x, tmpflux);
+      factor -> Evaluate (mir, factorx);
+      flux.Rows(0, dims[0]).Cols(0, mir.Size()) = SIMD<double>(0.0);
+      for (int i = 0; i < dims[0]; i++)
+        for (int j = 0; j < dims[1]; j++)
+          flux.Row(i).Range(mir.Size()) += pw_mult(factorx.Row(i*dims[1]+j), tmpflux.Row(j));
+    }
+
+    
+  };
+
+
+}
+
+#endif

netgen/include/elementbyelement.hpp

@@ -131,10 +131,13 @@ namespace ngla
   {
     size_t h, w;
     Matrix<SCAL> matrix;
-    Table<int> col_dnums;
-    Table<int> row_dnums;
+    Table<int> col_dnums;   // output
+    Table<int> row_dnums;   // input
     bool disjoint_rows, disjoint_cols;
     Table<int> row_coloring, col_coloring;
+    bool output_onto = false;
+    bool output_matrix = false;
+    bool output_matrix_trans = false;
   public:
     ConstantElementByElementMatrix (size_t ah, size_t aw, Matrix<SCAL> amatrix,
                                     Table<int> acol_dnums, Table<int> arow_dnums);
@@ -157,7 +160,10 @@ namespace ngla
     FlatTable<int> GetColDNums() const { return col_dnums; }
 
     FlatTable<int> GetRowColoring() const { return row_coloring; }    
-    FlatTable<int> GetColColoring() const { return col_coloring; }    
+    FlatTable<int> GetColColoring() const { return col_coloring; }
+
+    bool OutputMatrix() const { return output_matrix; }
+    bool OutputMatrixTrans() const { return output_matrix_trans; } 
   };
 
   class NGS_DLL_HEADER StructuredElementByElementMatrix : public BaseMatrix

netgen/include/expr.hpp

@@ -291,9 +291,9 @@ namespace ngbla
   struct undefined_size
     {
       undefined_size() = default;
-      undefined_size(size_t s) { }
+      INLINE undefined_size(size_t s) { }
       template <int S>
-      explicit constexpr undefined_size(IC<S> s) { }
+      INLINE explicit constexpr undefined_size(IC<S> s) { }
   };
   
   inline ostream & operator<< (ostream & ost, undefined_size s) { ost << "undefined"; return ost; }
@@ -515,7 +515,7 @@ namespace ngbla
         }
 
 
-      if (TB::IsLinear())
+      if constexpr (TB::IsLinear())
 	{
 	  if (T::IsLinear())
 	    {
@@ -573,9 +573,6 @@ namespace ngbla
 
     enum { COL_MAJOR = 0 };  // matrix is stored col-major
 
-    void Dump (ostream & ost) const { ost << "Matrix"; }
-
-
 
     template<typename TOP, typename TB>
     INLINE auto & Assign (const Expr<TB> & v)
@@ -735,6 +732,11 @@ namespace ngbla
     {
       return (*this) *= (1./s);
     }
+
+
+    void Dump (ostream & ost) const
+    { ost << "Matexpr (h=" << Height() << ", w=" << Width() << ")"; }
+    
   };
 
 
@@ -838,6 +840,7 @@ namespace ngbla
   {
     TA a;
   public:
+    MinusExpr (const MinusExpr&) = default;
     MinusExpr (TA aa) : a(aa) { ; }
 
     template <typename ...I>
@@ -850,7 +853,10 @@ namespace ngbla
     INLINE auto Width() const { return a.Width(); }
     INLINE TA A() const { return a; }
 
-    static constexpr bool IsLinear() { return TA::IsLinear(); } 
+    static constexpr bool IsLinear() { return TA::IsLinear(); }
+    void Dump (ostream & ost) const
+    { ost << "-("; a.Dump(ost); ost << ")"; }
+    
   };
 
   template <typename TA>
@@ -934,6 +940,7 @@ namespace ngbla
   public:
     static constexpr bool IsLinear() { return TA::IsLinear(); }
 
+    ScaleExpr (const ScaleExpr&) = default;
     INLINE ScaleExpr (TA aa, TS as) : a(aa), s(as) { ; }
     
     // INLINE auto operator() (size_t i) const { return s * a(i); }
@@ -1492,8 +1499,39 @@ namespace ngbla
   }
 
 
+  /* ************************* OuterProduct ********************** */
+  
+  template <class TA, class TB>
+  class OuterProductExpr : public Expr<OuterProductExpr<TA,TB>>
+  {
+    TA a;
+    TB b;
+  public:
+    OuterProductExpr (TA aa, TB ab) : a(aa), b(ab) { ; }
 
+    // INLINE auto operator() (size_t i) const { return a[i] * b(i); }  
+    INLINE auto operator() (size_t i, size_t j) const { return a[i] * b[j]; }
 
+    INLINE auto View() const { return *this; }
+    INLINE auto Shape() const
+    {
+      return tuple<size_t,size_t> (a.Size(), b.Width());
+    }
+    
+    INLINE const auto A() const { return a; }
+    INLINE const auto B() const { return b; }
+    INLINE auto Height() const { return a.Size(); }
+    INLINE auto Width() const { return b.Size(); }
+
+    static constexpr bool IsLinear() { return false; }         
+  };
+
+
+  template <typename TA, typename TB>
+  INLINE auto OuterProduct (const Expr<TA> & a, const Expr<TB> & b)
+  {
+    return OuterProductExpr (a.View(), b.View());
+  }
 
 
 

netgen/include/fespace.hpp

@@ -256,7 +256,7 @@ ANY                  1 1 1 1 | 15
 
     virtual void UpdateDofTables() { ; } 
     virtual void UpdateCouplingDofArray() { ; } 
-
+    virtual void UpdateFreeDofs();
     /// update element coloring
     virtual void FinalizeUpdate();
 
@@ -448,7 +448,8 @@ ANY                  1 1 1 1 | 15
     virtual void GetDofNrs (NodeId ni, Array<DofId> & dnums) const;
     BitArray GetDofs (const Region & reg) const;
     Table<int> CreateDofTable (VorB vorb) const;
-
+    virtual void SelectDofs (const string & name, BitArray & dofs) const;
+                  
     /// get coupling types of dofs
     virtual void GetDofCouplingTypes (int elnr, Array<COUPLING_TYPE> & dnums) const;
     
@@ -531,8 +532,13 @@ ANY                  1 1 1 1 | 15
     void SetDefinedOnBoundary (const BitArray & defon)
      { SetDefinedOn(BND,defon); }
 
+    const Array<bool> & GetDefinedOn (VorB vb) const { return definedon[vb]; }
+
     ///
     void SetDirichletBoundaries (const BitArray & dirbnds);
+    const BitArray & GetDirichletBoundaries (VorB vb) const { return dirichlet_constraints[vb]; }
+
+
     /// Get reference element for tet, prism, trig, etc ..
     // const FiniteElement & GetFE (ELEMENT_TYPE type) const;
 
@@ -640,7 +646,7 @@ ANY                  1 1 1 1 | 15
     /// Set multigrid prolongation
     // void SetProlongation (ngmg::Prolongation * aprol)
     // { prol = aprol; }
-    virtual void SetHarmonicProlongation (shared_ptr<BilinearForm> bfa);
+    virtual void SetHarmonicProlongation (shared_ptr<BilinearForm> bfa, string inverse);
 
     /// returns function-evaluator
     shared_ptr<DifferentialOperator> GetEvaluator (VorB vb = VOL) const
@@ -1109,6 +1115,7 @@ ANY                  1 1 1 1 | 15
 
     /// copies dofcoupling from components
     void UpdateCouplingDofArray() override;
+    virtual void UpdateFreeDofs() override;
     
     void SetDefinedOn (VorB vb, const BitArray& defon) override;
 
@@ -1140,7 +1147,8 @@ ANY                  1 1 1 1 | 15
     void GetEdgeDofNrs (int ednr, Array<DofId> & dnums) const override;
     void GetFaceDofNrs (int fanr, Array<DofId> & dnums) const override;
     void GetInnerDofNrs (int elnr, Array<DofId> & dnums) const override;
-
+    void SelectDofs (const string & name, BitArray & dofs) const override;
+    
     void SolveM(CoefficientFunction * rho, BaseVector & vec, Region * definedon,
                         LocalHeap & lh) const override;
     void ApplyM(CoefficientFunction * rho, BaseVector & vec, Region * definedon,

netgen/include/gridfunction.hpp

@@ -157,16 +157,16 @@ namespace ngcomp
     int GetMultiDim () const { return multidim; }
 
     /// increase multidim and copy vec to new component
-    void AddMultiDimComponent (BaseVector & vec);
+    void AddMultiDimComponent (BaseVector & vec, bool copy = true);
   
     int GetLevelUpdated() const { return level_updated; }
     ///
 
     // const FESpace & GetFESpace() const { return *fespace; }
     ///
-    shared_ptr<FESpace> GetFESpace() const { return fespace; }
+    const shared_ptr<FESpace> & GetFESpace() const { return fespace; }
     ///
-    shared_ptr<MeshAccess> GetMeshAccess() const { return fespace->GetMeshAccess(); }
+    const shared_ptr<MeshAccess> & GetMeshAccess() const { return fespace->GetMeshAccess(); }
     ///
     virtual string GetClassName () const
     {

netgen/include/h1amg.hpp

@@ -1,13 +1,28 @@
-#ifndef H1AMG_HPP_
-#define H1AMG_HPP_
+#ifndef H1AMGxx_HPP_
+#define H1AMGxx_HPP_
 
 // #include <la.hpp>
 #include <basematrix.hpp>
 #include <sparsematrix.hpp>
+#include <preconditioner.hpp>
 
 namespace ngcomp
 {
   using namespace ngla;
+
+
+
+  struct H1AMG_Parameters
+  {
+    int verbose = 0;
+    int smoothing_steps = 3;
+    int coarsenings_per_level = 3; // number of binary coarsenings per level
+    bool block_smoother = true;    // block or point smoother ?
+    bool use_smoothed_prolongation = true;
+    int max_coarse = 10;
+    int max_level = 20;
+  };
+
   
   template <class SCAL>
   class NGS_DLL_HEADER H1AMG_Matrix : public ngla::BaseMatrix
@@ -25,6 +40,7 @@ namespace ngcomp
                   ngcore::FlatArray<ngcore::IVec<2>> e2v,
                   ngcore::FlatArray<double> edge_weights,
                   ngcore::FlatArray<double> vertex_weights,
+                  const H1AMG_Parameters & param,                  
                   size_t level);
 
     virtual int VHeight() const override { return size; }
@@ -36,6 +52,73 @@ namespace ngcomp
 
     virtual void Mult (const ngla::BaseVector & b, ngla::BaseVector & x) const override;
   };
+
+
+
+
+
+  template <class SCAL>
+  class H1AMG_Preconditioner : public Preconditioner
+  {
+    shared_ptr<BitArray> freedofs;
+    shared_ptr<H1AMG_Matrix<SCAL>> mat;
+
+    ParallelHashTable<IVec<2>,double> edge_weights_ht;
+    ParallelHashTable<IVec<1>,double> vertex_weights_ht;
+    
+    H1AMG_Parameters param;
+    
+  public:
+
+    static shared_ptr<Preconditioner> CreateBF (shared_ptr<BilinearForm> bfa, const Flags & flags, const string & name)
+    {
+      if (bfa->GetFESpace()->IsComplex())
+        return make_shared<H1AMG_Preconditioner<Complex>> (bfa, flags, name);
+      else
+        return make_shared<H1AMG_Preconditioner<double>> (bfa, flags, name);
+    }
+
+    static DocInfo GetDocu ();    
+
+    H1AMG_Preconditioner (shared_ptr<BilinearForm> abfa, const Flags & aflags,
+                          const string aname = "H1AMG_cprecond")
+      : Preconditioner (abfa, aflags, aname)
+    {
+      if (is_same<SCAL,double>::value)
+        cout << IM(3) << "Create H1AMG" << endl;
+      else
+        cout << IM(3) << "Create H1AMG, complex" << endl;
+      
+      param.verbose = int(flags.GetNumFlag("verbose", 0));
+      param.smoothing_steps = int(flags.GetNumFlag("smoothingsteps", 1));    
+      param.use_smoothed_prolongation = flags.GetDefineFlagX("smoothedprolongation").IsMaybeTrue();
+      param.max_coarse = int(flags.GetNumFlag("maxcoarse", 10));
+      param.max_level = int(flags.GetNumFlag("maxlevel", 20));
+    }
+
+    virtual void InitLevel (shared_ptr<BitArray> _freedofs) override
+    {
+      freedofs = _freedofs;
+    }
+
+    virtual void FinalizeLevel (const BaseMatrix * matrix) override;
+
+    virtual void AddElementMatrix (FlatArray<int> dnums,
+                                   FlatMatrix<SCAL> elmat,
+                                   ElementId id,
+                                   LocalHeap & lh) override;
+
+    virtual void Update () override { ; }
+
+    virtual const BaseMatrix & GetMatrix() const override 
+    {
+      return *mat;
+    }
+
+  };
+
+
+  
 }
 
 #endif // H1AMG_HPP_

netgen/include/h1lumping.hpp

@@ -25,6 +25,12 @@ namespace ngcomp
 
 
     void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+    void GetVertexDofNrs (int vnr, Array<int> & dnums) const override;
+    void GetEdgeDofNrs (int ednr, Array<int> & dnums) const override;
+    void GetFaceDofNrs (int fanr, Array<int> & dnums) const override;
+    void GetInnerDofNrs (int elnr, Array<int> & dnums) const override;
+
+
     
     FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;
 

netgen/include/hcurl_equations.hpp

@@ -643,6 +643,17 @@ namespace ngfem
     enum { DIM_DMAT = 1 };
     enum { DIFFORDER = 1 };
 
+    static string Name() { return "curl"; }
+
+    static const FEL & Cast(const FiniteElement & fel)
+    {
+        return static_cast<const FEL&> (fel);
+    }
+
+    
+    static int DimRef() { return 1; }
+
+    
     static constexpr bool SUPPORT_PML = true;
     template <typename AFEL, typename MIP, typename MAT>
     static void GenerateMatrix (const AFEL & fel, const MIP & mip,
@@ -651,6 +662,22 @@ namespace ngfem
       mat = 1.0/mip.GetJacobiDet() * 
 	Trans (static_cast<const FEL&>(fel).GetCurlShape(mip.IP(),lh));
     }
+    
+    template<typename IP, typename MAT>
+    static void GenerateMatrixRef (const FiniteElement & fel, const IP & ip,
+                                   MAT && mat, LocalHeap & lh)
+    {
+      Cast(fel).CalcCurlShape (ip, Trans(mat));
+    }
+
+    template <typename MIP, typename MAT>
+    static void CalcTransformationMatrix (const MIP & mip,
+                                          MAT & mat, LocalHeap & lh)
+    {
+      // auto & mip = static_cast<const MappedIntegrationPoint<D-1,D>&>(bmip);
+      mat = 1./mip.GetJacobiDet();
+    }
+    
 
     static void GenerateMatrixSIMDIR (const FiniteElement & fel,
                                       const SIMD_BaseMappedIntegrationRule & mir,
@@ -701,6 +728,8 @@ public:
   enum { DIM_DMAT = 3 };
   enum { DIFFORDER = 1 };
 
+  static string Name() { return "curl"; }
+  
     static constexpr bool SUPPORT_PML = true;
   static const FEL & Cast (const FiniteElement & fel) 
   { return static_cast<const FEL&> (fel); }