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

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

@@ -0,0 +1,461 @@
+#ifndef TPDIFFOP_HPP
+#define TPDIFFOP_HPP
+
+#include "diffop.hpp"
+
+
+namespace ngfem
+{
+  class TPDifferentialOperator : public DifferentialOperator
+  {
+    ArrayMem<shared_ptr<DifferentialOperator>,2> evaluators;
+  public:
+    NGS_DLL_HEADER TPDifferentialOperator() : DifferentialOperator(1,1,VOL,1) { ; }
+    NGS_DLL_HEADER TPDifferentialOperator(FlatArray<shared_ptr<DifferentialOperator> > aevaluators,int adim,int ablockdim,bool abnd,int adifforder) : DifferentialOperator(adim,ablockdim,abnd ? BND : VOL,adifforder)
+      {
+        evaluators.SetSize( aevaluators.Size() );
+        evaluators = aevaluators;
+      }
+    /// destructor
+    NGS_DLL_HEADER virtual ~TPDifferentialOperator () {}
+
+    virtual shared_ptr<DifferentialOperator> GetTrace() const override { return nullptr; }
+    
+
+    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)
+    {
+      return evaluators[num];
+    }
+      using DifferentialOperator::Apply;
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+        const BaseMappedIntegrationRule & mir,
+        BareSliceVector<double> x, 
+        BareSliceMatrix<double> flux,
+        LocalHeap & lh) const override;
+       
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+        const BaseMappedIntegrationRule & mir,
+        FlatMatrix<double> flux,
+        BareSliceVector<double> x, 
+        LocalHeap & lh) const override;
+    
+    NGS_DLL_HEADER virtual void
+    ApplyY(const FiniteElement &fel,
+        const BaseMappedIntegrationRule & miry,
+        FlatMatrix<double> flux,
+        SliceMatrix<double> x,
+        LocalHeap & lh) const;
+        
+    NGS_DLL_HEADER virtual void
+    ApplyYTrans(const FiniteElement &fel,
+        const BaseMappedIntegrationRule & miry,
+        FlatMatrix<double> flux,
+        SliceMatrix<double> x,
+        LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual void
+    ApplyX(const FiniteElement &fel,
+        const BaseMappedIntegrationRule & mirx,
+        FlatMatrix<double> flux,
+        SliceMatrix<double> x,
+        LocalHeap & lh) const;
+        
+    NGS_DLL_HEADER virtual void
+    ApplyXTrans(const FiniteElement &fel,
+        const BaseMappedIntegrationRule & mirx,
+        FlatMatrix<double> flux,
+        SliceMatrix<double> x,
+        LocalHeap & lh) const;
+
+    /// calculates the matrix
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & fel,
+                const BaseMappedIntegrationPoint & mip,
+                BareSliceMatrix<double,ColMajor> mat,   
+                LocalHeap & lh) const override { throw Exception("2 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & bfel,
+                const BaseMappedIntegrationPoint & bmip,
+                BareSliceMatrix<Complex,ColMajor> mat, 
+                LocalHeap & lh) const override{ throw Exception("3 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & fel,
+                const BaseMappedIntegrationRule & mir,
+                BareSliceMatrix<double,ColMajor> mat,   
+                LocalHeap & lh) const override { throw Exception("4 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & fel,
+                const BaseMappedIntegrationRule & mir,
+                BareSliceMatrix<Complex,ColMajor> mat,   
+                LocalHeap & lh) const override { throw Exception("5 not implemented"); }
+    
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+           const BaseMappedIntegrationPoint & mip,
+           BareSliceVector<double> x, 
+           FlatVector<double> flux,
+           LocalHeap & lh) const override { throw Exception("6 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+           const BaseMappedIntegrationPoint & mip,
+           BareSliceVector<Complex> x, 
+           FlatVector<Complex> flux,
+           LocalHeap & lh) const override { throw Exception("8 not implemented"); }
+    
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+           const BaseMappedIntegrationRule & mir,
+           BareSliceVector<Complex> x, 
+           BareSliceMatrix<Complex> flux,
+           LocalHeap & lh) const override { throw Exception("9 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & bfel,
+        const SIMD_BaseMappedIntegrationRule & bmir,
+        BareSliceVector<double> x, 
+        BareSliceMatrix<SIMD<double>> flux) const override { throw ExceptionNOSIMD("nosimd"); }
+    // LocalHeap & lh) const { throw Exception("not implemented"); }
+    
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+                const BaseMappedIntegrationPoint & mip,
+                FlatVector<double> flux,
+                BareSliceVector<double> x, 
+                LocalHeap & lh) const override { throw Exception("11 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+                const BaseMappedIntegrationPoint & mip,
+                FlatVector<Complex> flux,
+                BareSliceVector<Complex> x, 
+                LocalHeap & lh) const override { throw Exception("12 not implemented"); }
+    
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+                const BaseMappedIntegrationRule & mir,
+                FlatMatrix<Complex> flux,
+                BareSliceVector<Complex> x, 
+                LocalHeap & lh) const override { throw Exception("13 not implemented"); }
+    
+    NGS_DLL_HEADER virtual void
+    AddTrans (const FiniteElement & bfel,
+              const SIMD_BaseMappedIntegrationRule & bmir,
+              BareSliceMatrix<SIMD<double>> flux,
+              BareSliceVector<double> x) const override { throw ExceptionNOSIMD("nosimd"); }
+    // LocalHeap & lh) const;
+  };
+
+  
+  class TPBlockDifferentialOperator : public BlockDifferentialOperator
+  {
+    //ArrayMem<shared_ptr<DifferentialOperator>,2> evaluators;
+    //shared_ptr<DifferentialOperator> diffop;
+    //int blockdim;
+  public:
+    //NGS_DLL_HEADER TPBlockDifferentialOperator() : DifferentialOperator(1,1,VOL,1) { ; }
+    NGS_DLL_HEADER TPBlockDifferentialOperator(shared_ptr<DifferentialOperator> adiffop,int ablockdim) : /*diffop(adiffop), blockdim(ablockdim),*/ BlockDifferentialOperator(adiffop,ablockdim)
+      { ; }
+    /// destructor
+    NGS_DLL_HEADER virtual ~TPBlockDifferentialOperator () {}
+
+    virtual IntRange UsedDofs(const FiniteElement & fel) const override { return IntRange(0, fel.GetNDof()); }
+
+    virtual bool operator== (const DifferentialOperator & diffop2) const override { return false; }
+    
+    //int BlockDim() const { return blockdim; }
+    
+    shared_ptr<DifferentialOperator> & GetEvaluators( int num)
+    {
+      return dynamic_cast<TPDifferentialOperator*>(diffop.get())->GetEvaluators(num);
+    }
+    
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+           const BaseMappedIntegrationRule & mir,
+           BareSliceVector<double> x, 
+           BareSliceMatrix<double> flux,
+           LocalHeap & lh) const override;
+    
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+                const BaseMappedIntegrationRule & mir,
+                FlatMatrix<double> flux,
+                BareSliceVector<double> x, 
+                LocalHeap & lh) const override;
+    
+    NGS_DLL_HEADER virtual void
+    ApplyY(const FiniteElement &fel,
+        const BaseMappedIntegrationRule & miry,
+        FlatMatrix<double> flux,
+        SliceMatrix<double> x,
+        LocalHeap & lh) const;
+        
+    NGS_DLL_HEADER virtual void
+    ApplyYTrans(const FiniteElement &fel,
+        const BaseMappedIntegrationRule & miry,
+        FlatMatrix<double> flux,
+        SliceMatrix<double> x,
+        LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual void
+    ApplyX(const FiniteElement &fel,
+        const BaseMappedIntegrationRule & mirx,
+        FlatMatrix<double> flux,
+        SliceMatrix<double> x,
+        LocalHeap & lh) const;
+        
+    NGS_DLL_HEADER virtual void
+    ApplyXTrans(const FiniteElement &fel,
+                const BaseMappedIntegrationRule & mirx,
+                FlatMatrix<double> flux,
+                SliceMatrix<double> x,
+                LocalHeap & lh) const;
+
+    /// calculates the matrix
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & fel,
+                const BaseMappedIntegrationPoint & mip,
+                BareSliceMatrix<double,ColMajor> mat,   
+                LocalHeap & lh) const override { throw Exception("2 not implemented"); }
+    
+      using BlockDifferentialOperator::CalcMatrix;
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & bfel,
+                const BaseMappedIntegrationPoint & bmip,
+                BareSliceMatrix<Complex,ColMajor> mat, 
+                LocalHeap & lh) const override { throw Exception("3 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & fel,
+                const BaseMappedIntegrationRule & mir,
+                BareSliceMatrix<double,ColMajor> mat,   
+                LocalHeap & lh) const override { throw Exception("4 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & fel,
+                const BaseMappedIntegrationRule & mir,
+                BareSliceMatrix<Complex,ColMajor> mat,   
+                LocalHeap & lh) const override { throw Exception("5 not implemented"); }
+    
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+           const BaseMappedIntegrationPoint & mip,
+           BareSliceVector<double> x, 
+           FlatVector<double> flux,
+           LocalHeap & lh) const override { throw Exception("6 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+           const BaseMappedIntegrationPoint & mip,
+           BareSliceVector<Complex> x, 
+           FlatVector<Complex> flux,
+           LocalHeap & lh) const override { throw Exception("8 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+           const BaseMappedIntegrationRule & mir,
+           BareSliceVector<Complex> x, 
+           BareSliceMatrix<Complex> flux,
+           LocalHeap & lh) const override { throw Exception("9 not implemented"); }
+    
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & bfel,
+        const SIMD_BaseMappedIntegrationRule & bmir,
+        BareSliceVector<double> x, 
+        BareSliceMatrix<SIMD<double>> flux) const override { throw ExceptionNOSIMD("nosimd"); }
+    // LocalHeap & lh) const { throw Exception("not implemented"); }
+    
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+                const BaseMappedIntegrationPoint & mip,
+                FlatVector<double> flux,
+                BareSliceVector<double> x, 
+                LocalHeap & lh) const override { throw Exception("11 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+                const BaseMappedIntegrationPoint & mip,
+                FlatVector<Complex> flux,
+                BareSliceVector<Complex> x, 
+                LocalHeap & lh) const override { throw Exception("12 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+                const BaseMappedIntegrationRule & mir,
+                FlatMatrix<Complex> flux,
+                BareSliceVector<Complex> x, 
+                LocalHeap & lh) const override { throw Exception("13 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    AddTrans (const FiniteElement & bfel,
+              const SIMD_BaseMappedIntegrationRule & bmir,
+              BareSliceMatrix<SIMD<double>> flux,
+              BareSliceVector<double> x) const override { throw ExceptionNOSIMD("nosimd"); }
+    // LocalHeap & lh) const;
+  };
+
+
+
+
+
+
+  class TPBlockDifferentialOperator2 : public BlockDifferentialOperator
+  {
+    //ArrayMem<shared_ptr<DifferentialOperator>,2> evaluators;
+    //shared_ptr<DifferentialOperator> diffop;
+    //int blockdim;
+  public:
+    //NGS_DLL_HEADER TPBlockDifferentialOperator() : DifferentialOperator(1,1,VOL,1) { ; }
+    NGS_DLL_HEADER TPBlockDifferentialOperator2(shared_ptr<DifferentialOperator> adiffop,int ablockdim) : /*diffop(adiffop), blockdim(ablockdim),*/ BlockDifferentialOperator(adiffop,ablockdim)
+      { ; }
+    /// destructor
+    NGS_DLL_HEADER virtual ~TPBlockDifferentialOperator2 () {}
+
+    virtual IntRange UsedDofs(const FiniteElement & fel) const override { return IntRange(0, fel.GetNDof()); }
+
+    virtual bool operator== (const DifferentialOperator & diffop2) const override { return false; }
+    
+    //int BlockDim() const { return blockdim; }
+    
+    shared_ptr<DifferentialOperator> & GetEvaluators( int num)
+    {
+      return dynamic_cast<TPDifferentialOperator*>(diffop.get())->GetEvaluators(num);
+    }
+    
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+           const BaseMappedIntegrationRule & mir,
+           BareSliceVector<double> x, 
+           BareSliceMatrix<double> flux,
+           LocalHeap & lh) const override;
+       
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+                const BaseMappedIntegrationRule & mir,
+                FlatMatrix<double> flux,
+                BareSliceVector<double> x, 
+                LocalHeap & lh) const override;
+    
+    NGS_DLL_HEADER virtual void
+    ApplyY(const FiniteElement &fel,
+        const BaseMappedIntegrationRule & miry,
+        FlatMatrix<double> flux,
+        SliceMatrix<double> x,
+        LocalHeap & lh) const;
+        
+    NGS_DLL_HEADER virtual void
+    ApplyYTrans(const FiniteElement &fel,
+        const BaseMappedIntegrationRule & miry,
+        FlatMatrix<double> flux,
+        SliceMatrix<double> x,
+        LocalHeap & lh) const;
+
+    NGS_DLL_HEADER virtual void
+    ApplyX(const FiniteElement &fel,
+        const BaseMappedIntegrationRule & mirx,
+        FlatMatrix<double> flux,
+        SliceMatrix<double> x,
+        LocalHeap & lh) const;
+        
+    NGS_DLL_HEADER virtual void
+    ApplyXTrans(const FiniteElement &fel,
+        const BaseMappedIntegrationRule & mirx,
+        FlatMatrix<double> flux,
+        SliceMatrix<double> x,
+        LocalHeap & lh) const;
+
+    /// calculates the matrix
+      using BlockDifferentialOperator::CalcMatrix;
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & fel,
+                const BaseMappedIntegrationPoint & mip,
+                BareSliceMatrix<double,ColMajor> mat,   
+                LocalHeap & lh) const override { throw Exception("2 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & bfel,
+                const BaseMappedIntegrationPoint & bmip,
+                BareSliceMatrix<Complex,ColMajor> mat, 
+                LocalHeap & lh) const override { throw Exception("3 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & fel,
+                const BaseMappedIntegrationRule & mir,
+                BareSliceMatrix<double,ColMajor> mat,   
+                LocalHeap & lh) const override { throw Exception("4 not implemented"); }
+    
+    NGS_DLL_HEADER virtual void
+    CalcMatrix (const FiniteElement & fel,
+                const BaseMappedIntegrationRule & mir,
+                BareSliceMatrix<Complex,ColMajor> mat,   
+                LocalHeap & lh) const override { throw Exception("5 not implemented"); }
+    
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+           const BaseMappedIntegrationPoint & mip,
+           BareSliceVector<double> x, 
+           FlatVector<double> flux,
+           LocalHeap & lh) const override { throw Exception("6 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+           const BaseMappedIntegrationPoint & mip,
+           BareSliceVector<Complex> x, 
+           FlatVector<Complex> flux,
+           LocalHeap & lh) const override { throw Exception("8 not implemented"); }
+    
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & fel,
+           const BaseMappedIntegrationRule & mir,
+           BareSliceVector<Complex> x, 
+           BareSliceMatrix<Complex> flux,
+           LocalHeap & lh) const override{ throw Exception("9 not implemented"); }
+    
+    NGS_DLL_HEADER virtual void
+    Apply (const FiniteElement & bfel,
+           const SIMD_BaseMappedIntegrationRule & bmir,
+           BareSliceVector<double> x, 
+           BareSliceMatrix<SIMD<double>> flux) const override { throw ExceptionNOSIMD("nosimd"); }
+    // LocalHeap & lh) const { throw Exception("not implemented"); }
+    
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+                const BaseMappedIntegrationPoint & mip,
+                FlatVector<double> flux,
+                BareSliceVector<double> x, 
+                LocalHeap & lh) const override { throw Exception("11 not implemented"); }
+
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+                const BaseMappedIntegrationPoint & mip,
+                FlatVector<Complex> flux,
+                BareSliceVector<Complex> x, 
+                LocalHeap & lh) const override { throw Exception("12 not implemented"); }
+    
+    NGS_DLL_HEADER virtual void
+    ApplyTrans (const FiniteElement & fel,
+                const BaseMappedIntegrationRule & mir,
+                FlatMatrix<Complex> flux,
+                BareSliceVector<Complex> x, 
+                LocalHeap & lh) const override { throw Exception("13 not implemented"); }
+    
+    NGS_DLL_HEADER virtual void
+    AddTrans (const FiniteElement & bfel,
+              const SIMD_BaseMappedIntegrationRule & bmir,
+              BareSliceMatrix<SIMD<double>> flux,
+              BareSliceVector<double> x) const override { throw ExceptionNOSIMD("nosimd"); }
+    // LocalHeap & lh) const;
+  };
+}
+#endif // TPDIFFOP_HPP

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

@@ -0,0 +1,133 @@
+#ifndef FILE_TPFES
+#define FILE_TPFES
+
+
+#include "fespace.hpp"
+
+
+namespace ngcomp
+{
+  ///////////////////////////////////////////////////////////////////////////////////////
+  class NGS_DLL_HEADER TPHighOrderFESpace : public FESpace
+  {
+    // Number of Elements
+    int nel;
+    //int nsel,nselx,nsely;
+    // Total number of degrees of Freedom
+    int ndof;
+    // Number of meshes (supports only 2 at the moment)
+    int nmeshes;
+    // ndofs in each space
+    Array<int> ndofs;
+    Array<int> nels;
+    Array<int> nfacets;
+    Array<int> first_element_dof;
+    Array<shared_ptr<FESpace>> fespaces;
+    Array<shared_ptr<FESpace>> spaces_y;
+    shared_ptr<FESpace> space_x;
+    Array<shared_ptr<MeshAccess>> meshes;
+    bool element_wise;
+    double nelsyinverse;
+  public:
+    INLINE int GetIndex( FlatArray<int> indices) const 
+    {
+      return indices[0]*nels[1] + indices[1];
+    }    
+    INLINE int GetIndex( int index0,int index1) const 
+    {
+      return index0*nels[1] + index1;
+    }
+    INLINE void GetIndices( int index, FlatArray<int> indices) const 
+    {
+      indices[0] = int(index*nelsyinverse);
+      indices[1] = index-nels[1]*indices[0];
+    }    
+    INLINE const shared_ptr<FESpace> & Space(int i) const {
+      if(i == -1)
+        return space_x;
+      else
+        if (spaces_y.Size() == 1)
+          return spaces_y[0];
+        else
+          return spaces_y[i];
+    }
+    INLINE const Array<shared_ptr<FESpace> > & Spaces(int i) const 
+    {
+      fespaces[0] = space_x;
+      if(spaces_y.Size() == 1)
+        fespaces[1] = spaces_y[0];
+      else 
+        fespaces[1] = spaces_y[i];
+      return fespaces;
+    }
+    int GetNMeshes() {return nmeshes;}
+    TPHighOrderFESpace (FlatArray<shared_ptr<FESpace>> spaces, const Flags & flags, bool parseflags=false, Array<int> * el_counts = nullptr);
+    
+    TPHighOrderFESpace (shared_ptr<FESpace> space_x,FlatArray<shared_ptr<FESpace>> spaces_y, const Flags & flags, bool parseflags=false);
+
+    virtual SymbolTable<shared_ptr<DifferentialOperator>> GetAdditionalEvaluators () const override;
+    ///
+    virtual ~TPHighOrderFESpace ();
+  
+    virtual string GetClassName () const override
+    {
+      return "TPHighOrderFESpace";
+    }
+    const Array<int> & GetNels() const
+    {
+      return nels;
+    }
+    const Array<int> & GetNFacets() const
+    {
+      return nfacets;
+    }    
+    ///
+    void FinalizeUpdate() override;
+    void Update() override;
+    /// 
+    virtual void UpdateDofTables() override;
+    ///
+    virtual void UpdateCouplingDofArray() override;    
+    ///
+    virtual size_t GetNDof () const throw() override;
+    ///
+    virtual size_t GetNDofLevel (int level) const override;
+    ///
+    virtual FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;
+
+    ngfem::ElementTransformation & GetTrafo (ElementId ei, Allocator & lh) const;
+
+    using FESpace::GetFE;
+    // virtual const FiniteElement & GetFE (ElementId ei, LocalHeap & lh) const;
+    template <ELEMENT_TYPE ET>
+      FiniteElement & T_GetFE (int elnr, Allocator & alloc) const;
+
+    void GetSliceDofNrs(ngfem::ElementId ei, int direction, ngstd::Array<int>& dnums ,LocalHeap & lh) const;
+    ///
+    virtual int GetSpatialDimension() const override { return space_x->GetSpatialDimension() + spaces_y[0]->GetSpatialDimension();}
+    ///
+    virtual void GetDofRanges (ElementId ei, Array<IntRange> & dranges) const;
+    
+    virtual void GetDofNrs(ngfem::ElementId ei, ngstd::Array<int>& dnums) const override;
+    ///
+    virtual shared_ptr<Table<int>> CreateSmoothingBlocks (const Flags & precflags) const override;
+    /// 
+    void ReduceToXSpace(shared_ptr<GridFunction> gf_in, shared_ptr<GridFunction> gf_out,LocalHeap & lh,const function<void(shared_ptr<FESpace>,const FiniteElement &, const ElementTransformation & ,FlatVector<>,FlatVector<>,LocalHeap&)> & func);
+    void ProlongateFromXSpace(shared_ptr<GridFunction> gf_in, shared_ptr<GridFunction> gf_out, LocalHeap & lh);
+
+    virtual void SolveM (CoefficientFunction * rho, BaseVector & vec, Region * region,
+                         LocalHeap & lh) const override;
+  };
+
+    extern void IterateElementsTP (const FESpace & fes, 
+                VorB vb, 
+                LocalHeap & clh, 
+                const function<void(ElementId,ElementId,LocalHeap&)> & func);
+    extern void Transfer2StdMesh(const GridFunction * gfutp, GridFunction* gfustd,LocalHeap & lh);
+    extern void Transfer2TPMesh(const CoefficientFunction * cfstd, GridFunction* gfutp,LocalHeap & lh);
+
+    
+}
+
+
+#endif