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

netgen/include/diagonalmatrix.hpp

@@ -0,0 +1,154 @@
+#ifndef FILE_NGS_DIAGONALMATRIX
+#define FILE_NGS_DIAGONALMATRIX
+
+
+
+#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; }
+
+    virtual shared_ptr<BaseSparseMatrix> CreateSparseMatrix() const override;
+    
+    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_);
+    DiagonalMatrix(shared_ptr<VVector<TM>> diag_);
+    virtual ~DiagonalMatrix();
+    
+    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;
+
+    virtual shared_ptr<BaseSparseMatrix> CreateSparseMatrix() 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<bool> nonzero;
+    Table<int> sparse, sparseT; // sparse non-zero pattern
+  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 Mult (const BaseVector & x, BaseVector & y) const override;    
+    void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;
+    void MultTrans (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<bool> GetNonZeroPattern() const { return nonzero; }
+  };
+
+}
+
+
+
+#endif
+

netgen/include/dump.hpp

@@ -248,7 +248,7 @@ namespace ngstd
 
   template<typename DT, NODE_TYPE NT>
   void packaged_buffered_send(int rank, int np, DT* a, typename key_trait<NT>::TKEY* b, int n, int pkg_size, int p,
-			      Array<NG_MPI_Request> & requests)
+			      NgMPI_Requests & requests)
   {
     // NG_MPI_Datatype mpi_type_array = MPIT<DT>::mpi_type;
     NG_MPI_Datatype mpi_type_array = GetMPIType<DT>();
@@ -800,7 +800,7 @@ namespace ngstd
  
     if(rank == 0)
       {
-	Array<NG_MPI_Request> requests;
+	NgMPI_Requests requests;
 	//packaged_send
 	packaged_buffered_send<DT,NT>(rank, np, array, array_keys, base_array_size, pkg_size, 1, requests);
 
@@ -836,7 +836,7 @@ namespace ngstd
 
 	for(int j=0;(n_pkg-1)*pkg_size+j < n;j++)
 	  f(end_keys[j], end[j]);      
-	MyMPI_WaitAll (requests);
+	requests.WaitAll();
 	// free(end);
 	// free(end_keys);
       }
@@ -853,10 +853,10 @@ namespace ngstd
 	else //regular
 	  {
 	    //cout << "rank " << rank << " sends to " << rank+1 << " then gets from " << p_in1 << "/" << p_in2 << " and sends to " << p_out << endl;
-	    Array<NG_MPI_Request> requests;
+	    NgMPI_Requests requests;
 	    packaged_buffered_send<DT,NT>(rank, np, array, array_keys, base_array_size, pkg_size, rank+1, requests);
 	    merge_in_in_out<DT,NT>(pkg_size, rank, np, p_in1, p_in2, p_out);
-	    MyMPI_WaitAll (requests);
+	    requests.WaitAll();
 	  }
       }
     else

netgen/include/eigen.hpp

@@ -7,6 +7,9 @@
 /* Date:   5. Jul. 96                                                     */
 /**************************************************************************/
 
+
+#include "basematrix.hpp"
+
 namespace ngla
 {
 

netgen/include/elementbyelement.hpp

@@ -11,6 +11,10 @@
    Element by element matrix
 */
 
+
+#include "basematrix.hpp"
+#include "blockjacobi.hpp"
+
 namespace ngla
 {
 
@@ -145,6 +149,8 @@ namespace ngla
     
     virtual AutoVector CreateRowVector () const override;
     virtual AutoVector CreateColVector () const override;
+
+    virtual shared_ptr<BaseSparseMatrix> CreateSparseMatrix() const override;
     
     FlatMatrix<SCAL> GetMatrix() const { return matrix; }
     FlatTable<int> GetRowDNums() const { return row_dnums; }

netgen/include/elementtopology.hpp

@@ -14,9 +14,6 @@
 namespace ngfem
 {
   using namespace ngbla;
-  // using ngcore::INT;
-
-
   
   /*
     Toplogy of reference elements

netgen/include/expr.hpp

@@ -9,8 +9,9 @@
 
 #include <core/array.hpp>
 #include <core/localheap.hpp>
-// #include <core/exception.hpp>
+#include <core/exception.hpp>
 
+#include <cstddef>
 #include <ngs_stdcpp_include.hpp>  // for INLINE
 #include "complex_wrapper.hpp"
 
@@ -28,15 +29,18 @@ template <typename T>
 struct SafeIndex
 {
   T i;
-  SafeIndex(T ai) : i(ai) { };
-  operator T() const { return i; }
-  auto operator++() { return ++i; }
-  auto operator++(int) { return i++; }
+  INLINE SafeIndex(T ai) : i(ai) { };
+  INLINE operator T() const { return i; }
+  INLINE auto operator++() { return ++i; }
+  INLINE auto operator++(int) { return i++; }
 };
 
-template <typename T>
-struct IsSafe<SafeIndex<T>> {
-  constexpr operator bool() const { return true; } };
+namespace ngcore
+{
+  template <typename T>
+  struct IsSafe<SafeIndex<T>> {
+    constexpr operator bool() const { return true; } };
+} // namespace ngcore
 
 /*
 namespace std {
@@ -262,6 +266,7 @@ namespace ngbla
     explicit constexpr undefined_size(IC<S> s) : size(s) { }
     explicit constexpr operator size_t() const { return size; }
     explicit constexpr operator int() const { return size; }    
+    explicit constexpr operator ptrdiff_t() const { return size; }
   };
 
     

netgen/include/fespace.hpp

@@ -12,7 +12,12 @@
 #include <finiteelement.hpp>
 #include <diffop.hpp>
 #include <symbolicintegrator.hpp>   // for ProxyFunction
-#include <la.hpp>
+
+#include <basevector.hpp>
+#include <basematrix.hpp>
+
+// #include <paralleldofs.hpp>
+
 
 #include "ngsobject.hpp"
 
@@ -283,14 +288,7 @@ ANY                  1 1 1 1 | 15
       order_policy = op;
     }
     
-    virtual void SetOrder (ELEMENT_TYPE et, TORDER order)
-    {
-      if (order_policy == CONSTANT_ORDER || order_policy == OLDSTYLE_ORDER)
-        order_policy = NODE_TYPE_ORDER;
-      et_bonus_order[et] = order - this->order;
-
-      timestamp = 0;  // rerun first_update
-    }
+    virtual void SetOrder (ELEMENT_TYPE et, TORDER order);
 
     virtual void SetOrder (NodeId ni, int order); 
     virtual int GetOrder (NodeId ni) const; 
@@ -924,7 +922,7 @@ ANY                  1 1 1 1 | 15
   class NGS_DLL_HEADER NonconformingFESpace : public FESpace
   {
     ///
-    Array<int> ndlevel;
+    // Array<int> ndlevel;
 
   public:
     NonconformingFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, bool parseflags=false);
@@ -938,7 +936,7 @@ ANY                  1 1 1 1 | 15
 
     virtual FiniteElement & GetFE (ElementId ei, Allocator & lh) const override;
     ///
-    virtual size_t GetNDof () const throw() override;
+    // virtual size_t GetNDof () const throw() override;
     ///
     virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
   };
@@ -949,7 +947,7 @@ ANY                  1 1 1 1 | 15
   class NGS_DLL_HEADER NonconformingSurfaceFESpace : public FESpace
   {
     ///
-    Array<int> ndlevel;
+    // Array<int> ndlevel;
 
   public:
     NonconformingSurfaceFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, bool parseflags=false);
@@ -963,7 +961,7 @@ ANY                  1 1 1 1 | 15
 
     virtual FiniteElement & GetFE (ElementId ei, Allocator & lh) const override;
     ///
-    virtual size_t GetNDof () const throw() override;
+    // virtual size_t GetNDof () const throw() override;
     ///
     virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
   };
@@ -1433,7 +1431,7 @@ namespace ngcore
   template<>
   struct MPI_typetrait<ngcomp::COUPLING_TYPE>
   {
-    static NG_MPI_Datatype MPIType () 
+    static auto MPIType () 
     { 
       static_assert ( (sizeof(ngcomp::COUPLING_TYPE) == sizeof(char)) ||
                       (sizeof(ngcomp::COUPLING_TYPE) == sizeof(int)) );

netgen/include/finiteelement.hpp

@@ -71,7 +71,7 @@ namespace ngfem
     /// the name of the element family
     virtual string ClassName() const;
 
-    virtual void SetVertexNumbers (FlatArray<int> vnums);
+    virtual FiniteElement * SetVertexNumbers (FlatArray<int> vnums);
     
     virtual IntegrationRule GetIR (int order) const;
 
@@ -103,13 +103,12 @@ namespace ngfem
   {
   protected:
     /// pointers to the components
-    // ArrayMem<const FiniteElement*,10> fea;
-    FlatArray<const FiniteElement*> fea;
+    FlatArray<FiniteElement*> fea;
     bool all_the_same{true};
 
   public:
     /// initialize with pointers to components, copy pointers
-    CompoundFiniteElement (FlatArray<const FiniteElement*> afea);
+    CompoundFiniteElement (FlatArray<FiniteElement*> afea);
 
     HD virtual ELEMENT_TYPE ElementType() const override { return fea[0]->ElementType(); }
     /// number of components
@@ -130,10 +129,11 @@ namespace ngfem
     /// the name of the element family
     virtual string ClassName() const override { return "CompoundFiniteElement"; }
     
-    virtual void SetVertexNumbers (FlatArray<int> vnums) override
+    virtual CompoundFiniteElement * SetVertexNumbers (FlatArray<int> vnums) override
     {
       for (auto pfel : fea)
-        const_cast<FiniteElement*>(pfel) -> SetVertexNumbers(vnums);
+        pfel -> SetVertexNumbers(vnums);
+      return this;
     }
 
     HD virtual bool ComplexShapes() const override;
@@ -174,7 +174,7 @@ namespace ngfem
     /// the name of the element family
     virtual string ClassName() const override { return "VectorFiniteElement"; }
 
-    virtual void SetVertexNumbers (FlatArray<int> vnums) override;
+    virtual VectorFiniteElement * SetVertexNumbers (FlatArray<int> vnums) override;
 
     virtual void Print (ostream & ost) const override;
 

netgen/include/globalspace.hpp

@@ -31,8 +31,8 @@ namespace ngcomp
       ELEMENT_TYPE type;
       bool complex;
     public:
-      FE(int adim, ELEMENT_TYPE atype, bool acomplex)
-        : FiniteElement(adim, 5), type(atype), complex(acomplex) { };
+      FE(int adim, int aorder, ELEMENT_TYPE atype, bool acomplex)
+        : FiniteElement(adim, aorder), type(atype), complex(acomplex) { };
       ELEMENT_TYPE ElementType() const override { return type; }
       bool ComplexShapes() const override { return complex; }
       
@@ -64,7 +64,33 @@ namespace ngcomp
                   BareSliceVector<Complex> x, 
                   FlatVector<Complex> flux,
                   LocalHeap & lh) const override;
+
+      void Apply (const FiniteElement & fel,
+                  const BaseMappedIntegrationRule & mir,
+                  BareSliceVector<double> x, 
+                  BareSliceMatrix<double> flux,
+                  LocalHeap & lh) const override;
+
+      void ApplyTrans (const FiniteElement & fel,
+                       const BaseMappedIntegrationRule & mir,
+                       FlatMatrix<double> flux,
+                       BareSliceVector<double> x, 
+                       LocalHeap & lh) const override;
+
+      void CalcMatrix (const FiniteElement & fel,
+                       const SIMD_BaseMappedIntegrationRule & mir,
+                       BareSliceMatrix<SIMD<double>> mat) const override;
+
+      void Apply (const FiniteElement & bfel,
+                  const SIMD_BaseMappedIntegrationRule & bmir,
+                  BareSliceVector<double> x, 
+                  BareSliceMatrix<SIMD<double>> flux) const override;
+      
       
+      void AddTrans (const FiniteElement & bfel,
+                     const SIMD_BaseMappedIntegrationRule & bmir,
+                     BareSliceMatrix<SIMD<double>> flux,
+                     BareSliceVector<double> x) const override;
     };
 
     

netgen/include/gridfunction.hpp

@@ -28,6 +28,7 @@ namespace ngcomp
     GridFunctionCoefficientFunction (shared_ptr<DifferentialOperator> adiffop,
                                      shared_ptr<DifferentialOperator> atrace_diffop = nullptr,
 				     shared_ptr<DifferentialOperator> attrace_diffop = nullptr,
+				     shared_ptr<DifferentialOperator> atttrace_diffop = nullptr,                                     
                                      int acomp = 0);
   public:
     GridFunctionCoefficientFunction () = default;
@@ -36,6 +37,7 @@ namespace ngcomp
                                      shared_ptr<DifferentialOperator> adiffop,
                                      shared_ptr<DifferentialOperator> atrace_diffop = nullptr,
 				     shared_ptr<DifferentialOperator> attrace_diffop = nullptr,
+				     shared_ptr<DifferentialOperator> atttrace_diffop = nullptr,
                                      int acomp = 0);
     GridFunctionCoefficientFunction (shared_ptr<GridFunction> agf, 
                                      shared_ptr<BilinearFormIntegrator> abfi, int acomp = 0);
@@ -83,6 +85,7 @@ namespace ngcomp
     virtual shared_ptr<CoefficientFunction>
       Diff (const CoefficientFunction * var, shared_ptr<CoefficientFunction> dir) const override;
 
+    shared_ptr<CoefficientFunction> Primary() const override;
     shared_ptr<GridFunctionCoefficientFunction> GetTrace() const;
   };
 
@@ -226,6 +229,7 @@ namespace ngcomp
     }
 
     shared_ptr<CoefficientFunction> Operator (shared_ptr<DifferentialOperator> diffop) const override;
+    shared_ptr<CoefficientFunction> Operator (const string& name) const override;
     
     
     ///

netgen/include/h1amg.hpp

@@ -1,7 +1,9 @@
 #ifndef H1AMG_HPP_
 #define H1AMG_HPP_
 
-#include <la.hpp>
+// #include <la.hpp>
+#include <basematrix.hpp>
+#include <sparsematrix.hpp>
 
 namespace ngcomp
 {

netgen/include/h1hofe.hpp

@@ -139,7 +139,7 @@ namespace ngfem
     virtual bool DualityMassDiagonal () const override
     {
       return (ET == ET_SEGM) || (ET == ET_TRIG) || (ET == ET_QUAD)
-        || (ET == ET_HEX) || (ET == ET_TET); 
+        || (ET == ET_HEX) || (ET == ET_TET) || (ET == ET_POINT);
     }
   };
 

netgen/include/hcurlhdivfes.hpp

@@ -9,6 +9,8 @@
 
 
 #include "fespace.hpp"
+#include <sparsematrix.hpp>
+
 
 namespace ngcomp
 {

netgen/include/hcurlhofespace.hpp

@@ -9,6 +9,7 @@
 
 #include "fespace.hpp"
 #include "h1hofespace.hpp"
+#include <sparsematrix.hpp>
 
 namespace ngcomp
 {
@@ -23,7 +24,7 @@ namespace ngcomp
   protected:
 
     typedef short TORDER;
-
+    
     // Level
     int level;
     Array<DofId> first_edge_dof;
@@ -58,7 +59,7 @@ namespace ngcomp
     bool usegrad;  
     bool var_order; 
   
-    int ndof;
+    // int ndof;
     int nedfine; 
     int uniform_order_inner;
     int uniform_order_face; 
@@ -95,7 +96,7 @@ namespace ngcomp
     ///
     virtual void DoArchive (Archive & archive) override;
     ///
-    virtual size_t GetNDof () const throw() override;
+    // virtual size_t GetNDof () const throw() override;
     virtual void SetOrder (NodeId ni, int order) override;
     virtual int GetOrder (NodeId ni) const override;
     using FESpace::GetOrder;

netgen/include/hdivfes.hpp

@@ -19,7 +19,7 @@ namespace ngcomp
   class RaviartThomasFESpace : public FESpace
   {
     ///
-    Array<int> ndlevel;
+    // Array<int> ndlevel;
   public:
     ///
     /*
@@ -42,9 +42,9 @@ namespace ngcomp
 
     virtual FiniteElement & GetFE (ElementId ei, Allocator & lh) const override;
     ///
-    virtual size_t GetNDof () const throw() override;
+    // virtual size_t GetNDof () const throw() override;
     ///
-    virtual size_t GetNDofLevel (int level) const override;
+    // virtual size_t GetNDofLevel (int level) const override;
 
     ///
     virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;

netgen/include/hdivhosurfacefespace.hpp

@@ -15,7 +15,7 @@ namespace ngcomp
   {
   protected:
     
-    int ndof;
+    // int ndof;
     
     Array<DofId> first_facet_dof;
     Array<DofId> first_inner_dof;
@@ -28,7 +28,7 @@ namespace ngcomp
     Array<bool> fine_facet; 
     Array<bool> boundary_facet; 
  
-    Array<int> ndlevel;
+    // Array<int> ndlevel;
     int uniform_order_inner; 
     int uniform_order_facet; 
 
@@ -64,7 +64,7 @@ namespace ngcomp
     virtual void UpdateDofTables() override; 
     virtual void UpdateCouplingDofArray() override;   
     
-    virtual size_t GetNDof () const throw() override;
+    // virtual size_t GetNDof () const throw() override;
     
     virtual FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;            
 

netgen/include/integratorcf.hpp

@@ -59,6 +59,11 @@ namespace ngfem
     
     NGS_DLL_HEADER virtual shared_ptr<BilinearFormIntegrator> MakeBilinearFormIntegrator() const;
     NGS_DLL_HEADER virtual shared_ptr<LinearFormIntegrator> MakeLinearFormIntegrator() const;
+
+    NGS_DLL_HEADER virtual shared_ptr<Integral> CreateSameIntegralType (shared_ptr<CoefficientFunction> _cf)
+    {
+      return make_shared<Integral> (_cf, dx);
+    }    
   };
   
   inline Integral operator* (double fac, const Integral & cf)
@@ -99,7 +104,7 @@ namespace ngfem
       CoefficientFunction::T_Transform transform;
       transform.replace = replace;
       for (auto & icf : icfs)
-        repl->icfs += make_shared<Integral> (icf->cf->Transform(transform), icf->dx);
+        repl->icfs += icf->CreateSameIntegralType (icf->cf->Transform(transform));
       return repl;
     }
 
@@ -131,7 +136,7 @@ namespace ngfem
     {
       auto deriv = make_shared<SumOfIntegrals>();
       for (auto & icf : icfs)
-        deriv->icfs += make_shared<Integral> (icf->cf->Diff(var.get(), dir), icf->dx);
+        deriv->icfs += icf->CreateSameIntegralType (icf->cf->Diff(var.get(), dir));
       return deriv;
     }
 
@@ -158,17 +163,17 @@ namespace ngfem
             {
             case VOL:
               if (icf->dx.element_vb == VOL)
-                deriv->icfs += make_shared<Integral> ( icf->cf->Diff(&shape, dir) + divdir*icf->cf, icf->dx);
+                deriv->icfs += icf->CreateSameIntegralType ( icf->cf->Diff(&shape, dir) + divdir*icf->cf);
               else
                 throw Exception("In DiffShape: for vb=VOL only element_vb=VOL implemented!");
               break;
             case BND:
               if (icf->dx.element_vb == VOL)
-                deriv->icfs += make_shared<Integral> ( icf->cf->Diff(&shape, dir) + sdivdir*icf->cf, icf->dx);
+                deriv->icfs += icf->CreateSameIntegralType ( icf->cf->Diff(&shape, dir) + sdivdir*icf->cf);
               else if (icf->dx.element_vb == BND && dir->Dimension() == 3)
-                deriv->icfs += make_shared<Integral> ( icf->cf->Diff(&shape, dir) + bsdivdir*icf->cf, icf->dx);
+                deriv->icfs += icf->CreateSameIntegralType ( icf->cf->Diff(&shape, dir) + bsdivdir*icf->cf);
               else if (icf->dx.element_vb == BND && dir->Dimension() == 2)
-                deriv->icfs += make_shared<Integral> ( icf->cf->Diff(&shape, dir), icf->dx);
+                deriv->icfs += icf->CreateSameIntegralType ( icf->cf->Diff(&shape, dir));
               else
                 throw Exception("In DiffShape: for vb=BND something went wrong!");
               break;
@@ -185,7 +190,7 @@ namespace ngfem
     {
       auto compiled = make_shared<SumOfIntegrals>();
       for (auto & icf : icfs)
-        compiled->icfs += make_shared<Integral> (::ngfem::Compile (icf->cf, realcompile, 2, wait, keep_files), icf->dx);
+        compiled->icfs += icf->CreateSameIntegralType (::ngfem::Compile (icf->cf, realcompile, 2, wait, keep_files));
       return compiled;
     }
 
@@ -207,14 +212,14 @@ namespace ngfem
   inline auto operator* (double fac, SumOfIntegrals c1)
   {
     SumOfIntegrals faccf;
-    for (auto & ci : c1.icfs) faccf.icfs += make_shared<Integral>(fac*(*ci));
+    for (auto & ci : c1.icfs) faccf.icfs += ci->CreateSameIntegralType(fac*(ci->cf));
     return faccf;
   }
 
   inline auto operator* (Complex fac, SumOfIntegrals c1)
   {
     SumOfIntegrals faccf;
-    for (auto & ci : c1.icfs) faccf.icfs += make_shared<Integral>(fac*(*ci));
+    for (auto & ci : c1.icfs) faccf.icfs += ci->CreateSameIntegralType(fac*(ci->cf));
     return faccf;
   }