ngsolve 6.2.2506.post74.dev0__cp314-cp314-macosx_10_15_universal2.whl

netgen/include/contact.hpp

@@ -0,0 +1,235 @@
+#ifndef NGSOLVE_CONTACT_HPP
+#define NGSOLVE_CONTACT_HPP
+
+// #include <comp.hpp>
+#include "gridfunction.hpp"
+#include "bilinearform.hpp"
+
+namespace ngcomp
+{
+  template<int DIM>
+  struct ContactPair
+  {
+    ElementId primary_el, secondary_el;
+    IntegrationPoint primary_ip, secondary_ip;
+  };
+
+  class GapFunction : public CoefficientFunctionNoDerivative
+  {
+  protected:
+    shared_ptr<GridFunction> displacement;
+    shared_ptr<MeshAccess> ma;
+    Region master;
+    Region other;
+    double h;
+    bool both_sides;
+
+  public:
+    GapFunction( shared_ptr<MeshAccess> ma_, Region primary_, Region secondary_)
+      : CoefficientFunctionNoDerivative(ma_->GetDimension()),
+        ma(ma_), master(primary_), other(secondary_)
+    { }
+
+    virtual void Update(shared_ptr<GridFunction> gf, int intorder_, double h_,
+                        bool both_sides) = 0;
+    void Draw();
+  };
+
+  template <int DIM>
+  class T_GapFunction : public GapFunction
+  {
+    unique_ptr<netgen::BoxTree<DIM, int>> searchtree;
+  public:
+    T_GapFunction( shared_ptr<MeshAccess> mesh_, Region primary_, Region secondary_)
+      : GapFunction(mesh_, primary_, secondary_)
+    { }
+
+    void Update(shared_ptr<GridFunction> gf, int intorder_, double h, bool both_sides) override;
+
+    const netgen::BoxTree<DIM, int>& GetSearchTree() { return *searchtree; }
+
+    using GapFunction::Evaluate;
+    double Evaluate (const BaseMappedIntegrationPoint & ip) const override
+    {
+      throw Exception("Scalar evaluate of GapFunction called");
+    }
+
+    void Evaluate(const BaseMappedIntegrationPoint & ip,
+                  FlatVector<> result) const override;
+
+    void Evaluate(const BaseMappedIntegrationRule & mir,
+                  BareSliceMatrix<> result) const override;
+
+    optional<ContactPair<DIM>> CreateContactPair(const MappedIntegrationPoint<DIM-1, DIM>& mip, LocalHeap& lh, bool both_sides) const;
+  };
+
+  template<int DIM>
+  class DisplacedNormal : public CoefficientFunctionNoDerivative
+  {
+    shared_ptr<GridFunction> displacement;
+  public:
+    DisplacedNormal()
+      : CoefficientFunctionNoDerivative(DIM, false),
+        displacement(nullptr) {}
+
+    void Update(shared_ptr<GridFunction> _displacement)
+    { displacement = _displacement; }
+
+    using CoefficientFunctionNoDerivative::Evaluate;
+    double Evaluate(const BaseMappedIntegrationPoint& ip) const override
+    {
+      throw Exception("1dim eval called for Normal");
+    }
+
+    void Evaluate(const BaseMappedIntegrationPoint& ir, FlatVector<> values) const override;
+  };
+
+  class ContactEnergy
+  {
+    shared_ptr<CoefficientFunction> cf;
+    shared_ptr<FESpace> fes;
+    Array<ProxyFunction*> trial_proxies;
+    Array<CoefficientFunction*> cf_gridfunctions;
+    bool deformed;
+
+  public:
+    ContactEnergy(shared_ptr<CoefficientFunction> _cf,
+                  bool _deformed=false);
+
+    bool IsDeformed() const { return deformed; }
+
+    double CalcEnergy(const FiniteElement& m_fel,
+                      const FiniteElement& s_fel,
+                      const BaseMappedIntegrationRule& m_mir,
+                      FlatVector<double> elx,
+                      LocalHeap& lh);
+
+    void ApplyAdd(const FiniteElement& m_fel,
+                  const FiniteElement& s_fel,
+                  const BaseMappedIntegrationRule& m_mir,
+                  FlatVector<double> elx,
+                  FlatVector<double> ely,
+                  LocalHeap& lh);
+
+    void CalcLinearizedAdd(const FiniteElement& m_fel,
+                           const FiniteElement& s_fel,
+                           const BaseMappedIntegrationRule& m_mir,
+                           FlatVector<double> elx,
+                           FlatMatrix<double> elmat,
+                           LocalHeap& lh);
+  };
+
+  class ContactIntegrator
+  {
+    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,
+                      bool _deformed);
+
+    bool IsDeformed() const { return deformed; }
+
+    void ApplyAdd(const FiniteElement& m_fel,
+                  const FiniteElement& s_fel,
+                  const BaseMappedIntegrationRule& m_mir,
+                  FlatVector<double> elx,
+                  FlatVector<double> ely,
+                  LocalHeap& lh);
+
+    void CalcLinearizedAdd(const FiniteElement& m_fel,
+                           const FiniteElement& s_fel,
+                           const BaseMappedIntegrationRule& m_mir,
+                           FlatVector<double> elx,
+                           FlatMatrix<double> elmat,
+                           LocalHeap& lh);
+  };
+
+
+  class ContactBoundary : public std::enable_shared_from_this<ContactBoundary>,
+                          netgen::UserVisualizationObject
+  {
+    shared_ptr<GapFunction> gap;
+    shared_ptr<CoefficientFunction> normal;
+    Region master, other;
+    Array<shared_ptr<ContactEnergy>> energies, undeformed_energies, deformed_energies;
+    Array<shared_ptr<ContactIntegrator>> integrators, undeformed_integrators, deformed_integrators;
+    shared_ptr<FESpace> fes_displacement;
+    shared_ptr<FESpace> fes;
+
+    // For visualization only
+    bool draw_pairs = false;
+    Array<Vec<3>> primary_points;
+    Array<Vec<3>> secondary_points;
+    bool volume, element_boundary;
+  public:
+    void Draw();
+    ContactBoundary(Region _master, Region _other, bool draw_pairs = false, bool _volume=false, bool element_boundary=false);
+
+    ~ContactBoundary();
+
+    void AddEnergy(shared_ptr<CoefficientFunction> form,
+                   bool deformed=false);
+    void AddIntegrator(shared_ptr<CoefficientFunction> form,
+                       bool deformed=false);
+
+    // Update search tree for gap function, if bf is not
+    // nullptr, update SpecialElements of bf
+    void Update(shared_ptr<GridFunction> gf,
+                shared_ptr<BilinearForm> bf,
+                int intorder, double h, bool both_sides);
+
+    shared_ptr<CoefficientFunction> Gap() const { return gap; }
+    shared_ptr<CoefficientFunction> Normal() const { return normal; }
+    const auto& GetEnergies() const { return energies; }
+    const auto& GetEnergies(bool def) const { return def ? deformed_energies : undeformed_energies; }    
+    const auto& GetIntegrators() const { return integrators; }
+    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}; }
+  };
+
+  template<int DIM>
+  class MPContactElement : public SpecialElement
+  {
+    // ContactPair<DIM> pair;
+    ElementId primary_ei, secondary_ei;
+    IntegrationRule primary_ir, secondary_ir;
+    shared_ptr<ContactBoundary> cb;
+    FESpace* fes;
+    GridFunction* deformation;
+  public:
+    MPContactElement(ElementId primary_ei, ElementId secondary_ei,
+                     IntegrationRule primary_ir, IntegrationRule secondary_ir,
+                     shared_ptr<ContactBoundary> _cb,
+                     GridFunction* deformation);
+
+    void GetDofNrs(Array<DofId>& dnums) const override;
+
+    double Energy(FlatVector<double> elx,
+                  LocalHeap& lh) const override;
+
+    void Apply(FlatVector<double> elx,
+               FlatVector<double> ely,
+               LocalHeap& lh) const override;
+
+    void CalcElementMatrix(FlatMatrix<double> elmat,
+                           LocalHeap& lh) const override;
+
+    
+    void CalcLinearizedElementMatrix(FlatVector<double> elx,
+                                     FlatMatrix<double> elmat,
+                                     LocalHeap& lh) const override;
+
+    shared_ptr<ContactBoundary> GetContactBoundary() const
+    { return cb; }
+  };
+
+  
+} // namespace ngcomp
+
+#endif // NGSOLVE_CONTACT_HPP

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