ngsolve 6.2.2404.post109.dev0__cp39-cp39-win_amd64.whl → 6.2.2406.post112.dev1__cp39-cp39-win_amd64.whl

netgen/include/sparsematrix.hpp

@@ -8,6 +8,9 @@
 /**************************************************************************/
 
 
+#include "vvector.hpp"
+#include "basematrix.hpp"
+
 namespace ngla
 {
 
@@ -149,6 +152,9 @@ namespace ngla
     void CalcBalancing ();
     const Partitioning & GetBalancing() const { return balance; } 
 
+    void EmbedHeight (size_t starti, size_t newheight);
+    void EmbedWidth (size_t starti, size_t newwidth);
+    
     ostream & Print (ostream & ost) const;
 
     virtual Array<MemoryUsage> GetMemoryUsage () const;    
@@ -233,6 +239,11 @@ namespace ngla
       return *this;
     }
 
+    virtual shared_ptr<BaseSparseMatrix> CreateSparseMatrix() const override 
+    {
+      return dynamic_pointer_cast<BaseSparseMatrix>(const_cast<BaseSparseMatrix*>(this)->shared_from_this());
+    }
+
     virtual shared_ptr<BaseJacobiPrecond> CreateJacobiPrecond (shared_ptr<BitArray> inner = nullptr) const 
     {
       throw Exception ("BaseSparseMatrix::CreateJacobiPrecond");
@@ -333,6 +344,8 @@ namespace ngla
     { 
       return asvec; 
     }
+
+    // tuple<int,int> EntryShape() const { return { entry_height, entry_width }; }
     
     FlatVector<TSCAL> GetRowValue (int row, int j)
     {
@@ -340,9 +353,10 @@ namespace ngla
       return FlatVector<TSCAL> (entry_size, p);
     }
     
-    FlatMatrix<TSCAL> GetRowValueMat (int row, int j)
+    FlatMatrix<TSCAL> GetRowValueMat (int row, int j) const
     {
-      TSCAL * p = asvec(entry_size * (firsti[row] + j)).Data(0);
+      // TSCAL * p = asvec(entry_size * (firsti[row] + j)).Data(0);
+      TSCAL * p = &asvec(entry_size * (firsti[row] + j));
       return FlatMatrix<TSCAL> (entry_height, entry_width, p);
     }
   };
@@ -547,7 +561,7 @@ namespace ngla
     virtual tuple<int,int> EntrySizes() const override { return { ngbla::Height<TM>(), ngbla::Width<TM>() }; }
     
     shared_ptr<BaseSparseMatrix>
-      CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(Trans(TM()))>>(const Array<int>&, int)> & creator) const;
+      CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(ngbla::Trans(TM()))>>(const Array<int>&, int)> & creator) const;
 
   public:
     using BaseMatrix::GetMemoryTracer;
@@ -608,37 +622,13 @@ namespace ngla
     { return { string("SparseMatrix")+typeid(TM).name(), this->Height(), this->Width() }; }
     
     virtual shared_ptr<BaseJacobiPrecond>
-      CreateJacobiPrecond (shared_ptr<BitArray> inner) const override
-    {
-      // if constexpr(mat_traits<TM>::HEIGHT != mat_traits<TM>::WIDTH) return nullptr;
-      if constexpr(ngbla::Height<TM>() != ngbla::Width<TM>()) return nullptr;
-      else if constexpr(ngbla::Height<TM>() > MAX_SYS_DIM) {
-	  throw Exception(string("MAX_SYS_DIM = ")+to_string(MAX_SYS_DIM)+string(", need ")+to_string(mat_traits<TM>::HEIGHT));
-	  return nullptr;
-	}
-      else return make_shared<JacobiPrecond<TM,TV_ROW,TV_COL>> (*this, inner);
-    }
+      CreateJacobiPrecond (shared_ptr<BitArray> inner) const override;
     
     virtual shared_ptr<BaseBlockJacobiPrecond>
       CreateBlockJacobiPrecond (shared_ptr<Table<int>> blocks,
                                 const BaseVector * constraint = 0,
                                 bool parallel = 1,
-                                shared_ptr<BitArray> freedofs = NULL) const override
-    { 
-      // if constexpr(mat_traits<TM>::HEIGHT != mat_traits<TM>::WIDTH) return nullptr;
-      if constexpr(ngbla::Height<TM>() != ngbla::Width<TM>()) return nullptr;
-      else if constexpr(ngbla::Height<TM>() > MAX_SYS_DIM) {
-	  throw Exception(string("MAX_SYS_DIM = ")+to_string(MAX_SYS_DIM)+string(", need ")+to_string(ngbla::Height<TM>()));
-	  return nullptr;
-	}
-      else
-        // return make_shared<BlockJacobiPrecond<TM,TV_ROW,TV_COL>> (*this, blocks, parallel);
-
-        return make_shared<BlockJacobiPrecond<TM,TV_ROW,TV_COL>>
-          ( dynamic_pointer_cast<const SparseMatrix>
-            (this->shared_from_this()),
-            blocks, parallel);
-    }
+                                shared_ptr<BitArray> freedofs = NULL) const override;
 
     virtual shared_ptr<BaseMatrix> InverseMatrix (shared_ptr<BitArray> subset = nullptr) const override;
     virtual shared_ptr<BaseMatrix> InverseMatrix (shared_ptr<const Array<int>> clusters) const override;
@@ -785,24 +775,12 @@ namespace ngla
       this->AddElementMatrixSymmetric (dnums1, elmat, use_atomic);
     }
     
-    virtual shared_ptr<BaseJacobiPrecond> CreateJacobiPrecond (shared_ptr<BitArray> inner) const override
-    { 
-      return make_shared<JacobiPrecondSymmetric<TM,TV>> (*this, inner);
-    }
-
+    virtual shared_ptr<BaseJacobiPrecond> CreateJacobiPrecond (shared_ptr<BitArray> inner) const override;
     virtual shared_ptr<BaseBlockJacobiPrecond>
       CreateBlockJacobiPrecond (shared_ptr<Table<int>> blocks,
                                 const BaseVector * constraint = 0,
                                 bool parallel  = 1,
-                                shared_ptr<BitArray> freedofs = NULL) const override
-    { 
-      // return make_shared<BlockJacobiPrecondSymmetric<TM,TV>> (*this, blocks);
-      return make_shared<BlockJacobiPrecondSymmetric<TM,TV>>
-        ( dynamic_pointer_cast<const SparseMatrixSymmetric>
-          (this->shared_from_this()),
-          blocks);
-    }
-
+                                shared_ptr<BitArray> freedofs = NULL) const override;
 
     virtual shared_ptr<BaseSparseMatrix> Restrict (const SparseMatrixTM<double> & prol,
 					 shared_ptr<BaseSparseMatrix> cmat = nullptr) const override;
@@ -875,6 +853,10 @@ namespace ngla
   [[deprecated("Use sparsematrix->CreateTranspose() instead!")]]            
   NGS_DLL_HEADER shared_ptr<SparseMatrixTM<double>> TransposeMatrix (const SparseMatrixTM<double> & mat);
 
+  NGS_DLL_HEADER shared_ptr<SparseMatrixTM<double>>
+  MatAdd (double sa, const SparseMatrixTM<double> & mata,
+          double sb, const SparseMatrixTM<double> & matb);
+  
   NGS_DLL_HEADER shared_ptr<SparseMatrixTM<double>>
   MatMult (const SparseMatrixTM<double> & mata, const SparseMatrixTM<double> & matb);
   NGS_DLL_HEADER shared_ptr<SparseMatrixTM<Complex>>

netgen/include/sparsematrix_dyn.hpp

@@ -8,6 +8,8 @@
 /**************************************************************************/
 
 
+#include "sparsematrix.hpp"
+
 namespace ngla
 {
 

netgen/include/sparsematrix_impl.hpp

@@ -155,6 +155,44 @@ namespace ngla
     : SparseMatrixTM<TM> (std::move(agraph))
   { ; }
  
+
+
+  template <class TM, class TV_ROW, class TV_COL>  
+  shared_ptr<BaseJacobiPrecond> SparseMatrix<TM,TV_ROW,TV_COL> :: 
+  CreateJacobiPrecond (shared_ptr<BitArray> inner) const
+  {
+    // if constexpr(mat_traits<TM>::HEIGHT != mat_traits<TM>::WIDTH) return nullptr;
+    if constexpr(ngbla::Height<TM>() != ngbla::Width<TM>()) return nullptr;
+    else if constexpr(ngbla::Height<TM>() > MAX_SYS_DIM) {
+      throw Exception(string("MAX_SYS_DIM = ")+to_string(MAX_SYS_DIM)+string(", need ")+to_string(mat_traits<TM>::HEIGHT));
+      return nullptr;
+    }
+    else return make_shared<JacobiPrecond<TM,TV_ROW,TV_COL>> (*this, inner);
+  }
+  
+  template <class TM, class TV_ROW, class TV_COL>    
+  shared_ptr<BaseBlockJacobiPrecond> SparseMatrix<TM,TV_ROW,TV_COL> :: 
+  CreateBlockJacobiPrecond (shared_ptr<Table<int>> blocks,
+                            const BaseVector * constraint,
+                            bool parallel,
+                            shared_ptr<BitArray> freedofs) const
+  { 
+    // if constexpr(mat_traits<TM>::HEIGHT != mat_traits<TM>::WIDTH) return nullptr;
+    if constexpr(ngbla::Height<TM>() != ngbla::Width<TM>()) return nullptr;
+    else if constexpr(ngbla::Height<TM>() > MAX_SYS_DIM) {
+      throw Exception(string("MAX_SYS_DIM = ")+to_string(MAX_SYS_DIM)+string(", need ")+to_string(ngbla::Height<TM>()));
+      return nullptr;
+    }
+    else
+      // return make_shared<BlockJacobiPrecond<TM,TV_ROW,TV_COL>> (*this, blocks, parallel);
+      
+      return make_shared<BlockJacobiPrecond<TM,TV_ROW,TV_COL>>
+        ( dynamic_pointer_cast<const SparseMatrix>
+          (this->shared_from_this()),
+          blocks, parallel);
+  }
+  
+
   
   template <class TM, class TV_ROW, class TV_COL>
   void SparseMatrix<TM,TV_ROW,TV_COL> ::
@@ -602,7 +640,7 @@ namespace ngla
   
   template <class TM>
   shared_ptr<BaseSparseMatrix> SparseMatrixTM<TM> ::
-  CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(Trans(TM()))>>(const Array<int>&,int)> & creator) const
+  CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(ngbla::Trans(TM()))>>(const Array<int>&,int)> & creator) const
   {
     Array<int> cnt(this->Width());
     cnt = 0;
@@ -750,7 +788,34 @@ namespace ngla
   {
     ; 
   }
+  
+
+  template <class TM, class TV>
+  shared_ptr<BaseJacobiPrecond>
+  SparseMatrixSymmetric<TM,TV> :: CreateJacobiPrecond (shared_ptr<BitArray> inner) const 
+  { 
+    return make_shared<JacobiPrecondSymmetric<TM,TV>> (*this, inner);
+  }
+  
 
+  template <class TM, class TV>  
+  shared_ptr<BaseBlockJacobiPrecond>
+  SparseMatrixSymmetric<TM,TV> :: CreateBlockJacobiPrecond (shared_ptr<Table<int>> blocks,
+                                                            const BaseVector * constraint,
+                                                            bool parallel,
+                                                            shared_ptr<BitArray> freedofs) const
+  { 
+    // return make_shared<BlockJacobiPrecondSymmetric<TM,TV>> (*this, blocks);
+    return make_shared<BlockJacobiPrecondSymmetric<TM,TV>>
+      ( dynamic_pointer_cast<const SparseMatrixSymmetric>
+        (this->shared_from_this()),
+        blocks);
+  }
+  
+
+
+
+  
   template <class TM, class TV>
   void SparseMatrixSymmetric<TM,TV> :: 
   MultAdd (double s, const BaseVector & x, BaseVector & y) const

netgen/include/special_matrix.hpp

@@ -7,143 +7,12 @@
 /* Date:   14 Mar. 02                                                     */
 /* ************************************************************************/
 
+#include "basematrix.hpp"
+#include "vvector.hpp"
+
 namespace ngla
 {
 
-
-  class NGS_DLL_HEADER Projector : public BaseMatrix
-  {
-    shared_ptr<BitArray> bits;
-    bool keep_values;
-  public:
-    // projector on true / false bits
-    Projector (shared_ptr<BitArray> abits, bool akeep_values = true)
-      : bits(abits), keep_values(akeep_values) { ; }
-    
-    virtual bool IsComplex() const override { return false; } 
-
-    virtual int VHeight() const override { return bits->Size(); }
-    virtual int VWidth() const override { return bits->Size(); }
-
-    virtual void Mult (const BaseVector & x, BaseVector & y) const override;    
-    virtual void MultTrans (const BaseVector & x, BaseVector & y) const override;
-    virtual void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;    
-    virtual void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
-    virtual void Project (BaseVector & x) const;
-    virtual void SetValues (BaseVector & x, double val) const;
-
-    bool KeepValues() const { return keep_values; }
-    shared_ptr<BitArray> Mask() const { return bits; }
-    
-    AutoVector CreateRowVector() const override
-    { throw Exception("CreateRowVector not implemented for Projector!"); }
-    AutoVector CreateColVector() const override
-    { throw Exception("CreateColVector not implemented for Projector!"); }
-
-    AutoVector Evaluate(BaseVector & v) const override
-    {
-      auto res = v.CreateVector();
-      Mult (v, res);
-      return res;
-    }
-    
-  };
-
-
-  template <typename TM=double>
-  class NGS_DLL_HEADER DiagonalMatrix : public BaseMatrix
-  {
-    shared_ptr<VVector<TM>> diag;
-  public:
-    // typedef typename mat_traits<TM>::TV_ROW TV_ROW;
-    // typedef typename mat_traits<TM>::TV_COL TV_COL;
-    typedef typename mat_traits<TM>::TSCAL TSCAL;
-    
-    DiagonalMatrix(size_t h)
-      : diag(make_shared<VVector<TM>>(h)) { }
-    DiagonalMatrix(const VVector<TM> & diag_)
-      : diag(make_shared<VVector<TM>>(diag_)) { } 
-    DiagonalMatrix(shared_ptr<VVector<TM>> diag_)
-      : diag(diag_) { } 
-    
-    bool IsComplex() const override { return false; } 
-    TM & operator() (size_t i) { return (*diag)(i); }
-    const TM & operator() (size_t i) const { return (*diag)(i); }
-    int VHeight() const override { return diag->Size(); }
-    int VWidth() const override { return diag->Size(); }
-
-    BaseVector & AsVector() override { return *diag; }
-    const BaseVector & AsVector() const override { return *diag; }
-    ostream & Print (ostream & ost) const override;
-    
-    AutoVector CreateRowVector () const override;
-    AutoVector CreateColVector () const override;
-
-    void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;    
-    void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
-
-    shared_ptr<BaseMatrix> InverseMatrix (shared_ptr<BitArray> subset = nullptr) const override;
-  };
-
-
-  template <typename TM=double>  
-  class BlockDiagonalMatrix : public BaseMatrix
-  {
-    Tensor<3,TM> blockdiag;  
-    int blocks, dimy, dimx;
-  public:
-    // typedef double TSCAL;
-    
-    BlockDiagonalMatrix(Tensor<3,TM> _blockdiag);
-    bool IsComplex() const override { return ngbla::IsComplex<TM>(); } 
-
-    int VHeight() const override { return blocks*dimy; }
-    int VWidth() const override { return blocks*dimx; }
-
-    ostream & Print (ostream & ost) const override;
-    
-    AutoVector CreateRowVector () const override;
-    AutoVector CreateColVector () const override;
-
-    void Mult (const BaseVector & x, BaseVector & y) const override;    
-    void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;    
-    void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
-
-    shared_ptr<BaseMatrix> InverseMatrix (shared_ptr<BitArray> subset = nullptr) const override;
-  };
-
-  // blocks is inner-most dimension of tensor and vectors
-  class BlockDiagonalMatrixSoA : public BaseMatrix
-  {
-    Tensor<3> blockdiag;  
-    int blocks, dimy, dimx;
-    Matrix<double> nonzero;
-  public:
-    typedef double TSCAL;
-    
-    BlockDiagonalMatrixSoA(Tensor<3> _blockdiag);
-    bool IsComplex() const override { return false; } 
-
-    int VHeight() const override { return blocks*dimy; }
-    int VWidth() const override { return blocks*dimx; }
-
-    ostream & Print (ostream & ost) const override;
-    virtual BaseMatrix::OperatorInfo GetOperatorInfo () const override;
-    
-    AutoVector CreateRowVector () const override;
-    AutoVector CreateColVector () const override;
-
-    void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;    
-    void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
-    // shared_ptr<BaseMatrix> InverseMatrix (shared_ptr<BitArray> subset = nullptr) const override;
-
-    FlatTensor<3> GetBlockDiag () const { return blockdiag; }
-    FlatMatrix<double> GetNonZeroPattern() const { return nonzero; }
-  };
-
-
-  
-
   // Convert RowMajor to ColMajor matrix (stored as vector)
   class TransposeVector : public BaseMatrix
   {
@@ -230,6 +99,7 @@ namespace ngla
 
     virtual void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;
     virtual void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
+    virtual shared_ptr<BaseSparseMatrix> CreateSparseMatrix() const override;    
   };
 
 
@@ -269,6 +139,9 @@ namespace ngla
     shared_ptr<BaseMatrix> GetMatrix() const { return mat; }
     IntRange GetRange() const { return range; }
 
+    virtual shared_ptr<BaseSparseMatrix> CreateSparseMatrix() const override;
+    
+    
     /*
     virtual shared_ptr<BaseMatrix> CreateDeviceMatrix() const override
     {

netgen/include/statushandler.hpp

@@ -19,6 +19,13 @@ namespace ngstd
     static void SetTerminate(void);
     static void UnSetTerminate(void);
     static bool ShouldTerminate(void);
+
+    class Region
+    {
+    public:
+      Region(const char * str) { PushStatus(str); }
+      ~Region() { PopStatus(); }
+    };
   };
 
 }

netgen/include/symbolicintegrator.hpp

@@ -72,7 +72,8 @@ public:
 
   NGS_DLL_HEADER shared_ptr<ProxyFunction> Deriv() const;
   NGS_DLL_HEADER shared_ptr<ProxyFunction> Trace() const;
-  NGS_DLL_HEADER shared_ptr<ProxyFunction> Primary() const { return primaryproxy; }
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction> Primary() const override
+  { return primaryproxy; }
   
   NGS_DLL_HEADER shared_ptr<ProxyFunction> Dt() const;  
   NGS_DLL_HEADER shared_ptr<ProxyFunction> AntiDt() const;

netgen/include/tensorcoefficient.hpp

@@ -191,77 +191,79 @@ namespace ngfem {
         optimize_identities(string, const Array<shared_ptr<CoefficientFunction>>& cfs,
                             const map<string, bool> &options);
 
-        class LeviCivitaCoefficientFunction
-            : public T_CoefficientFunction<LeviCivitaCoefficientFunction> {
-          using BASE = T_CoefficientFunction<LeviCivitaCoefficientFunction>;
 
-          int dim = 0;
-          MultiIndex mi{};
+        // class LeviCivitaCoefficientFunction
+        //     : public T_CoefficientFunction<LeviCivitaCoefficientFunction> {
+        //   using BASE = T_CoefficientFunction<LeviCivitaCoefficientFunction>;
 
-        public:
-          LeviCivitaCoefficientFunction() = default;
+        //   int dim = 0;
+        //   MultiIndex mi{};
 
-          LeviCivitaCoefficientFunction(int adim);
+        // public:
+        //   LeviCivitaCoefficientFunction() = default;
 
-          virtual void TraverseTree(const function<void(CoefficientFunction &)> &func) override {
-            func(*this);
-          }
+        //   LeviCivitaCoefficientFunction(int adim);
 
-          virtual string GetDescription() const override { return string("Levi-Civita Symbol"); }
+        //   virtual void TraverseTree(const function<void(CoefficientFunction &)> &func) override {
+        //     func(*this);
+        //   }
 
-          virtual void DoArchive(Archive &ar) override;
+        //   virtual string GetDescription() const override { return string("Levi-Civita Symbol"); }
 
-          virtual void GenerateCode(Code &code, FlatArray<int> inputs, int index) const override {
-            GenerateCode(code, inputs, index, false);
-          }
+        //   virtual void DoArchive(Archive &ar) override;
 
-          virtual void GenerateCode(Code &code, FlatArray<int> inputs, int index,
-                                    bool skip_zeroes = true) const;
+        //   virtual void GenerateCode(Code &code, FlatArray<int> inputs, int index) const override {
+        //     GenerateCode(code, inputs, index, false);
+        //   }
 
-          virtual void NonZeroPattern(const class ProxyUserData &ud,
-                                      FlatVector<AutoDiffDiff<1,NonZero>> values) const override;
+        //   virtual void GenerateCode(Code &code, FlatArray<int> inputs, int index,
+        //                             bool skip_zeroes = true) const;
 
-          virtual void NonZeroPattern(const class ProxyUserData &ud,
-                                      FlatArray<FlatVector<AutoDiffDiff<1,NonZero>>> input,
-                                      FlatVector<AutoDiffDiff<1,NonZero>> values) const override;
+        //   virtual void NonZeroPattern(const class ProxyUserData &ud,
+        //                               FlatVector<AutoDiffDiff<1,NonZero>> values) const override;
 
-          using BASE::Evaluate;
-          using typename BASE::T_DJC;
+        //   virtual void NonZeroPattern(const class ProxyUserData &ud,
+        //                               FlatArray<FlatVector<AutoDiffDiff<1,NonZero>>> input,
+        //                               FlatVector<AutoDiffDiff<1,NonZero>> values) const override;
 
-          virtual double Evaluate(const BaseMappedIntegrationPoint &ip) const override;
+        //   using BASE::Evaluate;
+        //   using typename BASE::T_DJC;
 
-          template<typename MIR, typename T, ORDERING ORD>
-          void T_Evaluate(const MIR &ir, BareSliceMatrix<T, ORD> values) const
-          {
-            auto val = T(0.0);
-            values.AddSize(Dimension(), ir.Size()) = val;
-            auto ir_size = ir.Size();
-            for (size_t I: Range(Dimension())) {
-              const auto I_array = split(I, mi);
-              if (is_even_iota_permutation(I_array.begin(), I_array.end()))
-                val = 1.0;
-              else if (is_odd_iota_permutation(I_array.begin(), I_array.end()))
-                val = -1.0;
-              else
-                continue;
-              for (auto q: Range(ir_size))
-                values(I, q) = val;
-            }
-          }
+        //   virtual double Evaluate(const BaseMappedIntegrationPoint &ip) const override;
 
-          template<typename MIR, typename T, ORDERING ORD>
-          void T_Evaluate(const MIR &ir, FlatArray<BareSliceMatrix<T, ORD>> input,
-                          BareSliceMatrix<T, ORD> values) const
-          {
-            T_Evaluate(ir, values);
-          }
+        //   template<typename MIR, typename T, ORDERING ORD>
+        //   void T_Evaluate(const MIR &ir, BareSliceMatrix<T, ORD> values) const
+        //   {
+        //     auto val = T(0.0);
+        //     values.AddSize(Dimension(), ir.Size()) = val;
+        //     auto ir_size = ir.Size();
+        //     for (size_t I: Range(Dimension())) {
+        //       const auto I_array = split(I, mi);
+        //       cout << "check I: " << I_array << endl;
+        //       if (is_even_iota_permutation(I_array.begin(), I_array.end()))
+        //         val = 1.0;
+        //       else if (is_odd_iota_permutation(I_array.begin(), I_array.end()))
+        //         val = -1.0;
+        //       else
+        //         continue;
+        //       for (auto q: Range(ir_size))
+        //         values(I, q) = val;
+        //     }
+        //   }
 
+        //   template<typename MIR, typename T, ORDERING ORD>
+        //   void T_Evaluate(const MIR &ir, FlatArray<BareSliceMatrix<T, ORD>> input,
+        //                   BareSliceMatrix<T, ORD> values) const
+        //   {
+        //     T_Evaluate(ir, values);
+        //   }
 
-          shared_ptr<CoefficientFunction> Diff(const CoefficientFunction *var,
-                                               shared_ptr<CoefficientFunction> dir) const override;
 
-          shared_ptr<CoefficientFunction> DiffJacobi(const CoefficientFunction *var, T_DJC & cache) const override;
-        };
+        //   shared_ptr<CoefficientFunction> Diff(const CoefficientFunction *var,
+        //                                        shared_ptr<CoefficientFunction> dir) const override;
+
+        //   shared_ptr<CoefficientFunction> DiffJacobi(const CoefficientFunction *var, T_DJC & cache) const override;
+        // };
 
         class EinsumCoefficientFunction
             : public T_CoefficientFunction<EinsumCoefficientFunction>

netgen/include/tpdiffop.hpp

@@ -25,6 +25,7 @@ namespace ngfem
     virtual IntRange UsedDofs(const FiniteElement & fel) const override { return IntRange(0, fel.GetNDof()); }
 
     virtual bool operator== (const TPDifferentialOperator & diffop2) const { return false; }
+    virtual bool operator== (const DifferentialOperator & diffop2) const override { return false; }
     
     shared_ptr<DifferentialOperator> & GetEvaluators( int num)
     {

netgen/include/tpintrule.hpp

@@ -46,6 +46,8 @@ namespace ngfem
     { throw Exception("TPMappedIntegrationRule::Range not implemented"); }
     virtual SliceMatrix<> GetPoints() const
     { throw Exception("TPMappedIntegrationRule::GetPoints not implemented"); }
+    virtual SliceMatrix<> GetNormals() const
+    { throw Exception("TPMappedIntegrationRule::GetNormals not implemented"); }
     virtual void ComputeNormalsAndMeasure (ELEMENT_TYPE et, int facetnr)
     { throw Exception("TPMappedIntegrationRule::ComputeNormalsAndMeasure not implemented"); }
     virtual bool IsComplex() const