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

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

@@ -0,0 +1,240 @@
+#ifndef NGS_CUDA_PROFILER_HPP
+#define NGS_CUDA_PROFILER_HPP
+
+#include <algorithm>
+#include <core/profiler.hpp>
+#include "cuda_ngstd.hpp"
+
+namespace ngs_cuda
+{
+  using ngcore::Array;
+  extern int gpu_clock;
+
+#ifdef __CUDACC__
+  // #define NGS_CUDA_DEVICE_TIMERS
+#ifdef NGS_CUDA_DEVICE_TIMERS
+  constexpr int N_MAX_DEVICE_TIMERS = 16;
+  struct DevTraceData {
+    unsigned long long start[N_MAX_DEVICE_TIMERS];
+    unsigned long long stop[N_MAX_DEVICE_TIMERS];
+    unsigned short start_smid[N_MAX_DEVICE_TIMERS];
+    unsigned short stop_smid[N_MAX_DEVICE_TIMERS];
+    union UserData {
+      double d;
+      float f[2];
+      unsigned u[2];
+    } data;
+    unsigned blockNr;
+  };
+
+  struct DevTimerData {
+    unsigned long long time[N_MAX_DEVICE_TIMERS];
+  };
+
+  struct DevTraceBlockData {
+    unsigned long long start;
+    unsigned long long stop;
+    unsigned start_smid;
+    unsigned stop_smid;
+  };
+
+  constexpr int N_MAX_TRACER_OBJECTS = 1024*1024;
+  constexpr int N_MAX_BLOCKS = 65*1024;
+  extern __device__ DevTimerData d_timer_data[];
+  extern __device__ DevTraceData d_trace_data[];
+  extern __device__ DevTraceBlockData d_block_data[];
+  extern Array<DevTimerData> timer_data;
+  extern Array<DevTraceData> trace_data;
+  extern Array<DevTraceBlockData> block_data;
+
+
+  __device__ inline unsigned GetSMID() {
+    unsigned ret;
+    asm("mov.u32 %0, %smid;" : "=r"(ret) );
+    return ret;
+  }
+
+  struct DeviceBlockRegionTracer {
+    int blockNr, threadNr;
+    __device__ DeviceBlockRegionTracer(int nblocks, int blockNr_, int threadNr_)
+      : blockNr(blockNr_), threadNr(threadNr_)
+    {
+      if(threadNr == 0)
+      {
+        d_block_data[blockNr].start = clock64();
+        d_block_data[blockNr].start_smid = GetSMID();
+        if(blockNr == 0)
+        {
+          d_trace_data[N_MAX_TRACER_OBJECTS].blockNr = nblocks;
+        }
+      }
+      __syncwarp();
+    }
+
+    __device__ ~DeviceBlockRegionTracer()
+    {
+      d_block_data[blockNr].stop = clock64();
+      d_block_data[blockNr].stop_smid = GetSMID();
+    }
+  };
+
+  struct DeviceRegionTimer
+  {
+    int timer_nr, id;
+
+    __device__ DeviceRegionTimer( int timer_nr_, int id_=-1)
+      : timer_nr(timer_nr_), id(id_ == -1 ? blockIdx.x : id_)
+    {
+      if(threadIdx.x ==0)
+        atomicAdd(&d_timer_data[id].time[timer_nr], -clock64());
+    }
+
+    __device__ ~DeviceRegionTimer()
+    {
+      if(threadIdx.x ==0)
+        atomicAdd(&d_timer_data[id].time[timer_nr], clock64());
+    }
+
+  };
+
+  struct DeviceRegionTracer
+  {
+    int timer_nr, id;
+    bool active;
+    DevTraceData::UserData & data;
+
+    __device__ DeviceRegionTracer( const DeviceBlockRegionTracer & tr, int timer_nr_, int id_)
+      : active(tr.threadNr == 0), timer_nr(timer_nr_), id(id_), data(d_trace_data[id_].data)
+    {
+      if(active)
+      {
+        d_trace_data[id].start[timer_nr] = clock64();
+        d_trace_data[id].start_smid[timer_nr] = GetSMID();
+        d_trace_data[id].blockNr = tr.blockNr;
+      }
+    }
+
+    __device__ ~DeviceRegionTracer()
+    {
+      if(active)
+      {
+        d_trace_data[id].stop[timer_nr] = clock64();
+        d_trace_data[id].stop_smid[timer_nr] = GetSMID();
+      }
+    }
+
+  };
+#else
+  struct DeviceBlockRegionTracer
+  {
+    __device__ DeviceBlockRegionTracer( int , int, int ) {}    
+  };
+  struct DeviceRegionTimer
+  {
+    __device__ DeviceRegionTimer( int , int ) {}
+  };
+  struct DeviceRegionTracer
+  {
+    // __device__ DeviceRegionTracer( bool active_, int timer_nr_, int id_) {}
+    __device__ DeviceRegionTracer( const DeviceBlockRegionTracer & tr, int timer_nr_, int id_) { }  
+  };
+#endif // NGS_CUDA_DEVICE_TIMERS
+
+#endif // __CUDACC__
+
+
+  namespace detail {
+  struct GPUTimerUserData
+  {
+    int timernr;
+    bool is_start;
+  };
+
+  // encode UserData directly in void* pointer (8 bytes available)
+  inline void * EncodeCallbackData( bool start, int nr )
+  {
+    static_assert(sizeof(GPUTimerUserData) <= sizeof(void*), "cannot encode UserData in void*");
+    GPUTimerUserData data{nr, start};
+    return *reinterpret_cast<void**>(&data);
+  }
+
+  inline void CUDART_CB Callback(cudaStream_t stream, cudaError_t status, void *userData)
+  {
+    const GPUTimerUserData & ud = *reinterpret_cast<GPUTimerUserData*>(&userData);
+    if(!ngcore::trace) return;
+    if(ud.is_start)
+      ngcore::trace->StartGPU(ud.timernr);
+    else
+      ngcore::trace->StopGPU(ud.timernr);
+  }
+
+  inline void CUDART_CB CallbackKernelStart(cudaStream_t stream, cudaError_t status, void *userData)
+  {
+    ngcore::TTimePoint & t = *reinterpret_cast<ngcore::TTimePoint*>(userData);
+    t = ngcore::GetTimeCounter();
+  }
+
+  inline void StartGPUTimer(int nr) {
+    cudaStreamAddCallback(0, Callback, EncodeCallbackData(true, nr), 0);
+  }
+
+  inline void StopGPUTimer(int nr) {
+    cudaStreamAddCallback(0, Callback, EncodeCallbackData(false, nr), 0);
+  }
+  } // namspace detail
+
+  class CudaRegionTimer
+  {
+    const ngcore::Timer<> & timer;
+    bool is_already_stopped = false;
+    ngcore::TTimePoint t_kernel_start;
+
+    static bool is_cuda_timer_enabled;
+
+  public:
+    CudaRegionTimer (ngcore::Timer<> & atimer) : timer(atimer) {
+      timer.Start();
+      if(is_cuda_timer_enabled)
+        detail::StartGPUTimer(timer);
+#ifdef NGS_CUDA_DEVICE_TIMERS
+      cudaStreamAddCallback(0, detail::CallbackKernelStart, &t_kernel_start, 0);
+#endif // NGS_CUDA_DEVICE_TIMERS
+    }
+    ~CudaRegionTimer ()
+    {
+      if(!is_already_stopped)
+        Stop();
+    }
+    CudaRegionTimer() = delete;
+    CudaRegionTimer(const CudaRegionTimer &) = delete;
+    CudaRegionTimer(CudaRegionTimer &&) = delete;
+    void operator=(const CudaRegionTimer &) = delete;
+    void operator=(CudaRegionTimer &&) = delete;
+
+    void Stop() {
+      if(is_cuda_timer_enabled)
+        detail::StopGPUTimer(timer);
+#ifdef NGS_CUDA_DEVICE_TIMERS
+      ProcessTracingData();
+#endif // NGS_CUDA_DEVICE_TIMERS
+      timer.Stop();
+      is_already_stopped = true;
+    }
+
+    void ProcessTracingData();
+
+    ngcore::TTimePoint TimeD2H( long long ticks )
+    {
+      double t_seconds = 1.0*ticks/gpu_clock + 1e-6; // add 1us for kernel startup
+      return t_kernel_start + t_seconds / ngcore::seconds_per_tick;
+    }
+
+    static void SetCudaTimer(bool enabled){
+      is_cuda_timer_enabled = enabled;
+    }
+  };
+
+  void TimeProfiler();
+}
+
+#endif // NGS_CUDA_PROFILER_HPP

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

@@ -0,0 +1,160 @@
+#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;
+    }
+    AutoVector EvaluateTrans(BaseVector & v) const override
+    {
+      return this->Evaluate(v);
+    }
+    
+  };
+
+
+  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; }
+    FlatTable<int> GetSparseMatrix() const { return sparse; }
+    FlatTable<int> GetSparseMatrixTrans() const { return sparseT; }
+  };
+
+}
+
+
+
+#endif
+

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

@@ -0,0 +1,276 @@
+#ifndef FILE_DIFFERENTIALOPERATOR
+#define FILE_DIFFERENTIALOPERATOR
+
+/*********************************************************************/
+/* File:   differentialoperator.hpp                                  */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   24. Nov. 2009                                             */
+/*********************************************************************/
+
+#include "finiteelement.hpp"
+#include "intrule.hpp"
+
+
+namespace ngfem
+{
+
+  /**
+     Differential Operator.
+     Base-class for run-time polymorphismus.
+     Provides application and transpose-application
+  */
+  class DifferentialOperator
+  {
+  private:
+    int dim;
+    int blockdim;
+    Array<int> dimensions;
+    
+    int vsdim;    // symmetric 3x3 matrix has dim=9, but vector-space dim=6
+    optional<Matrix<>> vsembedding;
+  protected:
+    VorB vb;
+    int difforder;
+  public:
+    /*
+    [[deprecated("Use DifferentialOperator(int,int,VorB,int) instead")]]
+    NGS_DLL_HEADER DifferentialOperator(int adim, int ablockdim, bool boundary, int adifforder)
+      : dim(adim), blockdim(ablockdim), vb(boundary ? BND : VOL),  difforder(adifforder)
+     {
+       if (blockdim == 1)
+         dimensions = Array<int> ( { dim } );
+       else
+         dimensions = Array<int> ( { dim/blockdim, blockdim });
+     }
+    */
+    NGS_DLL_HEADER DifferentialOperator(int adim, int ablockdim, VorB avb, int adifforder)
+      : dim(adim), blockdim(ablockdim), vb(avb), difforder(adifforder)
+    { 
+      if (blockdim == 1)
+        dimensions = Array<int> ( { dim } );
+      else if (dim == 1)
+        dimensions = Array<int> ( { blockdim } );
+      else
+        dimensions = Array<int> ( { dim/blockdim, blockdim });
+
+      vsdim = dim;
+    }
+    /// destructor
+    NGS_DLL_HEADER virtual ~DifferentialOperator () = default;
+
+    virtual void DoArchive(Archive & ar) { ; }
+
+    void SetDimensions (const Array<int> & adims) { dimensions = adims; }
+    void SetVectorSpaceEmbedding (Matrix <> emb)
+    { vsembedding = emb; vsdim = emb.Width(); }
+    optional<FlatMatrix<>> GetVSEmbedding() const { return vsembedding; }
+    
+    ///
+    NGS_DLL_HEADER virtual string Name() const; // { return typeid(*this).name(); }
+    /// dimension of range
+    int Dim() const { return dim; }
+    int VSDim() const { return vsdim; }
+    const Array<int> & Dimensions() const { return dimensions; }
+    /// number of copies of finite element by BlockDifferentialOperator
+    int BlockDim() const { return blockdim; }
+    /// does it live on the boundary ?
+    bool Boundary() const { return vb == BND; }
+    VorB VB() const { return vb; }
+
+    virtual bool SupportsVB (VorB checkvb) const { return checkvb == vb; }
+    virtual shared_ptr<DifferentialOperator> GetTrace() const
+    {
+      return nullptr;
+      // throw Exception("GetTrace not overloaded for DifferentialOperator"+string(typeid(*this).name()));
+    }
+    /// total polynomial degree is reduced by this order (i.e. minimal difforder)
+    int DiffOrder() const { return difforder; } 
+
+    virtual IntRange UsedDofs(const FiniteElement & fel) const { return IntRange(0, fel.GetNDof()); }
+
+    virtual bool operator== (const DifferentialOperator & diffop2) const { return false; }
+
+    /// calculates the matrix
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & fel,
+		const BaseMappedIntegrationPoint & mip,
+		BareSliceMatrix<double,ColMajor> mat,   
+		LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & bfel,
+		const BaseMappedIntegrationPoint & bmip,
+		BareSliceMatrix<Complex,ColMajor> mat, 
+		LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & fel,
+		const BaseMappedIntegrationRule & mir,
+		BareSliceMatrix<double,ColMajor> mat,   
+		LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & fel,
+		const BaseMappedIntegrationRule & mir,
+		BareSliceMatrix<Complex,ColMajor> mat,   
+		LocalHeap & lh) const;
+    
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & fel,
+		const SIMD_BaseMappedIntegrationRule & mir,
+		BareSliceMatrix<SIMD<double>> mat) const;
+
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & fel,
+		const SIMD_BaseMappedIntegrationRule & mir,
+		BareSliceMatrix<SIMD<Complex>> mat) const;
+
+    /// Bmat = vs-embedding * BmatVS    (if vs-embedding is set)
+    NGS_DLL_HEADER virtual void
+    CalcMatrixVS (const FiniteElement & fel,
+                  const BaseMappedIntegrationPoint & mip,
+                  SliceMatrix<double,ColMajor> mat,   
+                  LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual void
+    CalcLinearizedMatrix (const FiniteElement & fel,
+                          const BaseMappedIntegrationRule & mir,
+                          BareSliceVector<double> x,
+                          SliceMatrix<double,ColMajor> mat,   
+                          LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual bool IsNonlinear() const { return false; }
+
+    // second derivative of \sum_ipt wprime * B(u) 
+    NGS_DLL_HEADER virtual void
+    CalcHessianAdd (const FiniteElement & fel,
+                    const BaseMappedIntegrationRule & mir,
+                    SliceMatrix<> wprime,
+                    BareSliceVector<> elvecu,
+                    SliceMatrix<> hessian,   
+                    LocalHeap & lh) const { ; } 
+    
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+	   const BaseMappedIntegrationPoint & mip,
+	   BareSliceVector<double> x, 
+	   FlatVector<double> flux,
+	   LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+	   const BaseMappedIntegrationPoint & mip,
+	   BareSliceVector<Complex> x, 
+	   FlatVector<Complex> flux,
+	   LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+	   const BaseMappedIntegrationRule & mir,
+	   BareSliceVector<double> x, 
+	   BareSliceMatrix<double> flux,
+	   LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+	   const BaseMappedIntegrationRule & mir,
+	   BareSliceVector<Complex> x, 
+	   BareSliceMatrix<Complex> flux,
+	   LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & bfel,
+	   const SIMD_BaseMappedIntegrationRule & bmir,
+	   BareSliceVector<double> x, 
+	   BareSliceMatrix<SIMD<double>> flux) const;
+
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & bfel,
+	   const SIMD_BaseMappedIntegrationRule & bmir,
+	   BareSliceVector<Complex> x, 
+	   BareSliceMatrix<SIMD<Complex>> flux) const;
+
+    
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+		const BaseMappedIntegrationPoint & mip,
+		FlatVector<double> flux,
+		BareSliceVector<double> x, 
+		LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+		const BaseMappedIntegrationPoint & mip,
+		FlatVector<Complex> flux,
+		BareSliceVector<Complex> x, 
+		LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+		const BaseMappedIntegrationRule & mir,
+		FlatMatrix<double> flux,
+		BareSliceVector<double> x, 
+		LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+		const BaseMappedIntegrationRule & mir,
+		FlatMatrix<Complex> flux,
+		BareSliceVector<Complex> x, 
+		LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual void
+    AddTrans (const FiniteElement & bfel,
+              const SIMD_BaseMappedIntegrationRule & bmir,
+              BareSliceMatrix<SIMD<double>> flux,
+              BareSliceVector<double> x) const;
+
+    NGS_DLL_HEADER virtual void
+    AddTrans (const FiniteElement & bfel,
+              const SIMD_BaseMappedIntegrationRule & bmir,
+              BareSliceMatrix<SIMD<Complex>> flux,
+              BareSliceVector<Complex> x) const;
+
+
+    NGS_DLL_HEADER virtual void
+    ApplyLinearizedTrans (const FiniteElement & fel,
+                          const BaseMappedIntegrationRule & mir,
+                          SliceVector<double> elveclin,
+                          FlatMatrix<double> flux,
+                          BareSliceVector<double> x, 
+                          LocalHeap & lh) const
+    {
+      ApplyTrans (fel, mir, flux, x, lh);
+    }
+
+
+    /// calculates matrix on reference element
+    
+    // dimension on refelement (e.g. 2 for surface gradient)
+    NGS_DLL_HEADER virtual int DimRef() const;
+    
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & fel,
+                const IntegrationPoint & ip,
+                BareSliceMatrix<double,ColMajor> mat,
+                LocalHeap & lh) const;
+    
+    NGS_DLL_HEADER virtual void
+    CalcTransformationMatrix (const BaseMappedIntegrationPoint & mip,
+                              SliceMatrix<double> trans,
+                              LocalHeap & lh) const;
+    
+    NGS_DLL_HEADER virtual shared_ptr<CoefficientFunction> DiffShape (shared_ptr<CoefficientFunction> proxy,
+                                                       shared_ptr<CoefficientFunction> dir,
+                                                       bool Eulerian = false) const;
+
+    NGS_DLL_HEADER virtual list<tuple<string,double>> Timing (const FiniteElement & fel, const BaseMappedIntegrationRule & mir) const;
+  };
+
+  
+
+}
+
+
+
+#endif