ngsolve 6.2.2502__cp311-cp311-win_amd64.whl → 6.2.2601__cp311-cp311-win_amd64.whl

netgen/include/sparsefactorization_interface.hpp

@@ -0,0 +1,159 @@
+#ifndef SPARSEFACTORIZATION_INTERFACE_HPP
+#define SPARSEFACTORIZATION_INTERFACE_HPP
+
+#include "basevector.hpp"
+#include "sparsecholesky.hpp"
+#include "sparsematrix.hpp"
+#include "../ngstd/python_ngstd.hpp"
+
+namespace ngla {
+
+  void ExportSparseFactorizationInterface(py::module &m);
+
+struct MapInnerDofs {
+  shared_ptr<BitArray> inner;
+  shared_ptr<const Array<int>> cluster;
+  Array<int> project;
+  Array<int> embed;
+  size_t size = 0;
+
+  MapInnerDofs() {}
+
+  void Init(shared_ptr<BitArray> ainner,
+               shared_ptr<const Array<int>> acluster = nullptr)
+  {
+    inner = ainner;
+    cluster = acluster;
+    if (!inner && !cluster) {
+      size = 0;
+      return;
+    }
+    if (inner) {
+      size = inner->NumSet();
+      project.SetSize(size);
+      embed.SetSize(inner->Size());
+      int j = 0;
+      for (int i = 0; i < inner->Size(); i++) {
+        if ((*inner)[i]) {
+          project[j] = i;
+          embed[i] = j++;
+        } else
+          embed[i] = -1;
+      }
+      return;
+    }
+
+    int j = 0;
+    for (int i = 0; i < cluster->Size(); i++) {
+      if ((*cluster)[i]) {
+        project.Append(i);
+        embed.Append(j++);
+      } else {
+        embed.Append(-1);
+      }
+    }
+    size = project.Size();
+  }
+
+  operator bool() const { return inner || cluster; }
+
+  template <typename T>
+  void Project(FlatVector<T> dst, FlatVector<T> src) const {
+    for (size_t i = 0; i < project.Size(); i++)
+      dst[i] = src[project[i]];
+  }
+
+  template <typename T> void Embed(T &dst, const T &src) const {
+    for (size_t i : Range(embed)) {
+      if (embed[i] >= 0)
+        dst[i] = src[embed[i]];
+      else
+        dst[i] = 0.0;
+    }
+  }
+
+  template <typename T>
+  void EmbedAdd(FlatVector<T> dst, FlatVector<T> src, T scale) const {
+    for (size_t i : Range(embed))
+      if (embed[i] >= 0)
+        dst[i] += scale * src[embed[i]];
+  }
+
+  template <typename T>
+  shared_ptr<SparseMatrixTM<T>>
+  ProjectMatrix(shared_ptr<const SparseMatrixTM<T>> m) {
+    Array<int> rowi, coli;
+    Array<T> vals;
+    // auto &dofs = *inner;
+
+    auto vals_ori = m->GetValues();
+
+    auto &cluster_array = *cluster;
+    auto &inner_bitarray = *inner;
+    auto is_used = [this, &inner_bitarray, &cluster_array](int i, int j) {
+      if (inner)
+        return inner_bitarray[i] && inner_bitarray[j];
+      return cluster_array[i] == cluster_array[j];
+    };
+
+    for (auto i : project)
+      for (auto j : m->GetRowIndices(i))
+        if (is_used(i, j)) {
+          rowi.Append(embed[i]);
+          coli.Append(embed[j]);
+          vals.Append(vals_ori[m->GetPosition(i, j)]);
+        }
+
+    auto res = SparseMatrixTM<T>::CreateFromCOO(rowi, coli, vals,
+                                                project.Size(), project.Size());
+    res->SetSPD(m->IsSPD());
+    return res;
+  }
+};
+
+class SparseFactorizationInterface : public SparseFactorization {
+protected:
+  shared_ptr<const BaseSparseMatrix> inner_mat;
+  shared_ptr<BaseVector> inner_rhs, inner_solution;
+  MapInnerDofs map_inner_dofs;
+  bool is_complex = false;
+  bool is_symmetric = false;
+  bool is_symmetric_storage = false;
+  bool is_analyzed = false;
+  int width, height, inner_width, inner_height;
+
+public:
+  SparseFactorizationInterface() = delete;
+  SparseFactorizationInterface(shared_ptr<const BaseMatrix> m,
+                               shared_ptr<BitArray> ainner = nullptr,
+                               shared_ptr<const Array<int>> acluster = nullptr);
+
+  virtual ~SparseFactorizationInterface() {}
+
+  void SetSubset(shared_ptr<BitArray> inner, shared_ptr<const Array<int>> cluster) override;
+
+  AutoVector CreateRowVector() const override {
+    return make_unique<VVector<double>>(Width());
+  }
+
+  AutoVector CreateColVector() const override {
+    return make_unique<VVector<double>>(Height());
+  }
+
+  shared_ptr<const BaseSparseMatrix> GetInnerMatrix() const {
+    return inner_mat;
+  }
+
+  void MultAdd(double s, const BaseVector &x, BaseVector &y) const override;
+  void MultAdd(Complex s, const BaseVector &x, BaseVector &y) const override;
+
+  virtual void Update() override;
+
+  virtual void Analyze() {}
+  virtual void Factor() {}
+  virtual void Solve(const BaseVector &rhs, BaseVector &solution) const = 0;
+};
+
+} // namespace ngla
+
+#endif // SPARSEFACTORIZATION_INTERFACE_HPP

netgen/include/sparsematrix.hpp

@@ -258,7 +258,7 @@ namespace ngla
       throw Exception ("BaseSparseMatrix::CreateBlockJacobiPrecond");
     }
 
-    virtual shared_ptr<BaseSparseMatrix> CreateTranspose() const
+    virtual shared_ptr<BaseSparseMatrix> CreateTranspose(bool sorted = true) const
     {
       throw Exception ("BaseSparseMatrix::CreateTranspose");      
     }
@@ -561,7 +561,7 @@ namespace ngla
     virtual tuple<int,int> EntrySizes() const override { return { ngbla::Height<TM>(), ngbla::Width<TM>() }; }
     
     shared_ptr<BaseSparseMatrix>
-      CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(ngbla::Trans(TM()))>>(const Array<int>&, int)> & creator) const;
+      CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(ngbla::Trans(TM()))>>(const Array<int>&, int)> & creator, bool sorted) const;
 
   public:
     using BaseMatrix::GetMemoryTracer;
@@ -619,7 +619,7 @@ namespace ngla
 
 
     BaseMatrix::OperatorInfo GetOperatorInfo () const override
-    { return { string("SparseMatrix")+typeid(TM).name(), this->Height(), this->Width() }; }
+    { return { string("SparseMatrix")+typeid(TM).name()+" (nze="+ToString(this->NZE())+")", this->Height(), this->Width() }; }
     
     virtual shared_ptr<BaseJacobiPrecond>
       CreateJacobiPrecond (shared_ptr<BitArray> inner) const override;
@@ -638,11 +638,11 @@ namespace ngla
     
     virtual shared_ptr<BaseSparseMatrix> Reorder (const Array<size_t> & reorder) const override;
     
-    virtual shared_ptr<BaseSparseMatrix> CreateTranspose() const override
+    virtual shared_ptr<BaseSparseMatrix> CreateTranspose(bool sorted) const override
     {
       return this->CreateTransposeTM
         ( [](const Array<int> & elsperrow, int width) -> shared_ptr<SparseMatrixTM<decltype(Trans(TM()))>>
-          { return make_shared<SparseMatrix<decltype(Trans(TM())), TV_COL, TV_ROW>> (elsperrow, width); } );
+          { return make_shared<SparseMatrix<decltype(Trans(TM())), TV_COL, TV_ROW>> (elsperrow, width); }, sorted );
     }
 
     virtual shared_ptr<BaseMatrix> DeleteZeroElements(double tol) const override;
@@ -669,6 +669,20 @@ namespace ngla
       for (size_t j = first; j < last; j++)
         vec[colpi[j]] += Trans(datap[j]) * el; 
     }
+
+    void AddRowTransToVectorAtomic (int row, TVY el, FlatVector<TVX> vec) const
+    {
+      size_t first = firsti[row];
+      size_t last = firsti[row+1];
+
+      const ColIdx * colpi = colnr.Addr(0);
+      const TM * datap = data.Addr(0);
+
+      for (size_t j = first; j < last; j++)
+        // vec[colpi[j]] += Trans(datap[j]) * el;
+        AtomicAdd (vec[colpi[j]], Trans(datap[j]) * el);
+    }
+
     
     ///
     void AddRowConjTransToVector (int row, TVY el, FlatVector<TVX> vec) const
@@ -858,9 +872,9 @@ namespace ngla
           double sb, const SparseMatrixTM<double> & matb);
   
   NGS_DLL_HEADER shared_ptr<SparseMatrixTM<double>>
-  MatMult (const SparseMatrixTM<double> & mata, const SparseMatrixTM<double> & matb);
+  MatMult (const SparseMatrixTM<double> & mata, const SparseMatrixTM<double> & matb, bool sort_output = true);
   NGS_DLL_HEADER shared_ptr<SparseMatrixTM<Complex>>
-  MatMult (const SparseMatrixTM<Complex> & mata, const SparseMatrixTM<Complex> & matb);
+  MatMult (const SparseMatrixTM<Complex> & mata, const SparseMatrixTM<Complex> & matb, bool sort_output = true);
 
 #ifdef GOLD
 #include <sparsematrix_spec.hpp>

netgen/include/sparsematrix_dyn.hpp

@@ -42,20 +42,19 @@ namespace ngla
           fm = matvec(i);
         }
     }
-
+    
     virtual int VHeight() const override { return size; }
     virtual int VWidth() const override { return width; }
-
+    
     virtual void Mult (const BaseVector & x, BaseVector & y) const override;
     virtual void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;
-
+    
     AutoVector CreateRowVector() const override
-    { throw Exception("CreateRowVector not implemented for SparseMatrixDynamic!"); }
+    { return make_unique<VVector<TSCAL>> (VWidth()); }
     AutoVector CreateColVector() const override
-    { throw  Exception("CreateColVector not implemented for SparseMatrixDynamic!"); }
-
+    { return make_unique<VVector<TSCAL>> (VHeight()); }
+    
     virtual tuple<int,int> EntrySizes() const override { return { bh, bw }; }
-
   };
   
 

netgen/include/sparsematrix_impl.hpp

@@ -51,28 +51,94 @@ namespace ngla
                  FlatArray<TM> val, size_t h, size_t w)
   {
     static Timer t("SparseMatrix::CreateFromCOO"); RegionTimer r(t);
-    Array<int> cnt(h);
+    static Timer t1("SparseMatrix::CreateFromCOO 1");
+    static Timer t2("SparseMatrix::CreateFromCOO 2");
+    static Timer t3("SparseMatrix::CreateFromCOO 3");
 
     /*
-    cnt = 0;
-    for (auto i : indi) cnt[i]++;
-    */
+    {
+    Array<int> cnt(h);
 
+    t1.Start();
     DynamicTable<int> tab(h);
     for (size_t i = 0; i < indi.Size(); i++)
       tab.AddUnique(indi[i], indj[i]);
+    t1.Stop();
     for (size_t i = 0; i < h; i++)
       cnt[i] = tab.EntrySize(i);
     
     auto matrix = make_shared<SparseMatrix<TM>> (cnt, w);
+    t2.Start();
     for (auto k : ngstd::Range(indi))
       matrix->CreatePosition(indi[k], indj[k]);
+    t2.Stop();
     matrix->SetZero();
 
+    t3.Start();
     for (auto k : ngstd::Range(indi))
       (*matrix)(indi[k], indj[k]) += val[k];
+    t3.Stop();
+    // return matrix;
+    }
+    */
+    
+    Array<int> cnt(h);
+    cnt = 0;
+    for (auto i : indi)
+      cnt[i]++;
+    
+    Table<int> tab(cnt);
+    cnt = 0;
+    
+    for (auto [i,j] : Zip(indi, indj))
+      tab[i][cnt[i]++] = j;
 
-    return matrix;
+    cnt = 0;
+    // for (int i = 0; i < tab.Size(); i++)
+    ParallelFor (tab.Size(), [&] (size_t i)
+      {
+        QuickSort (tab[i]);
+
+        int prev = -1;
+        for (auto j : tab[i])
+          {
+            if (j != prev) cnt[i]++;
+            prev = j;
+          }
+      });
+    
+    auto matrix = make_shared<SparseMatrix<TM>> (cnt, w);
+    t2.Start();
+    // for (auto k : ngstd::Range(indi))
+    // matrix->CreatePosition(indi[k], indj[k]);
+
+    cnt = 0;
+    for (int i = 0; i < tab.Size(); i++)
+      {
+        int prev = -1;
+        for (auto j : tab[i])
+          {
+            auto cols = matrix->GetRowIndices(i);
+            if (j != prev)
+              cols[cnt[i]++] = j;
+            prev = j;
+          }
+      }
+    
+    t2.Stop();
+    matrix->SetZero();
+
+    t3.Start();
+    /*
+    for (auto k : ngstd::Range(indi))
+      (*matrix)(indi[k], indj[k]) += val[k];
+    */
+    ParallelFor (indi.Size(), [&](size_t k)
+    {
+      AtomicAdd ( (*matrix)(indi[k], indj[k]),  val[k]);
+    });
+    t3.Stop();
+    return matrix;    
   }
   
 
@@ -167,7 +233,8 @@ namespace ngla
       throw Exception(string("MAX_SYS_DIM = ")+to_string(MAX_SYS_DIM)+string(", need ")+to_string(mat_traits<TM>::HEIGHT));
       return nullptr;
     }
-    else return make_shared<JacobiPrecond<TM,TV_ROW,TV_COL>> (*this, inner);
+    else return make_shared<JacobiPrecond<TM,TV_ROW,TV_COL>> ( dynamic_pointer_cast<SparseMatrix>
+                                                               (const_cast<SparseMatrix*>(this)->shared_from_this()), inner);
   }
   
   template <class TM, class TV_ROW, class TV_COL>    
@@ -288,6 +355,23 @@ namespace ngla
       AddRowTransToVector (i, s*fx(i), fy);
 
     timer.AddFlops (this->NZE());
+
+
+    /*
+    static Timer t("SparseMatrix::MultTransAdd"); RegionTimer reg(t);
+    t.AddFlops (this->NZE()*sizeof(TV_ROW)*sizeof(TV_COL)/sqr(sizeof(double)));
+
+    ParallelForRange
+      (balance, [&] (IntRange myrange)
+       {
+         FlatVector<TVY> fx = x.FV<TVY>(); 
+         FlatVector<TVX> fy = y.FV<TVX>(); 
+
+         for (auto i : myrange)
+           AddRowTransToVectorAtomic (i, s*fx(i), fy);
+       });
+    */
+    
   }
 
 
@@ -393,21 +477,69 @@ namespace ngla
   DeleteZeroElements(double tol) const
   {
     static Timer t("SparseMatrix::DeleteZeroElements"); RegionTimer reg(t);
-    Array<int> indi, indj;
-    Array<TM> val;
-    for (auto i : Range(this->Height()))
+    size_t h = this->Height();
+    size_t w = this->Width();
+    Array<int> cnt(h);
+    Array<bool> keep(data.Size());
+    cnt = 0;
+    keep = false;
+    ParallelForRange( h, [&](IntRange r)
       {
-        for (auto j : Range(firsti[i], firsti[i+1]))
-          {
+        for (auto i : r)
+          for (auto j : Range(firsti[i], firsti[i+1]))
             if (ngbla::L2Norm2(data[j]) > tol*tol)
+            {
+              keep[j] = true;
+              cnt[i]++;
+            }
+      }, 5*TaskManager::GetNumThreads());
+
+    auto matrix = make_shared<SparseMatrix<TM>> (cnt, w);
+    cnt = 0;
+
+    ParallelForRange( h, [&](IntRange r)
+      {
+        for (auto i : r)
+        {
+          auto cols = matrix->GetRowIndices(i);
+          auto vals = matrix->GetRowValues(i);
+          int icol = 0;
+          // size_t firsti_new = matrix->firsti[i];
+          for (auto j : Range(firsti[i], firsti[i+1]))
+            if (keep[j])
               {
-                indi.Append (i);
-                indj.Append (colnr[j]);
-                val.Append (data[j]);
+                cols[icol] = colnr[j];
+                vals[icol] = data[j];
+                icol++;
               }
-          }
-      }
-    return this->CreateFromCOO(indi, indj, val, this->Height(), this->Width());
+        }
+      }, 5*TaskManager::GetNumThreads());
+    return matrix;
+
+    /*
+      // needs parallelization and testing
+    Array<int> cnt(this->Height());
+    cnt = 0;
+    size_t cnt0 = 0;
+    for (auto i : Range(this->Height()))
+      for (auto j : Range(firsti[i], firsti[i+1]))
+        if (ngbla::L2Norm2(data[j]) > tol*tol)
+          cnt[i]++;
+        else
+          cnt0++;
+
+    cout << "zero-els = " << cnt0 << endl;
+
+
+    auto matrix = make_shared<SparseMatrix<TM>> (cnt, this->Width());
+
+    for (auto i : Range(this->Height()))
+      for (auto j : Range(firsti[i], firsti[i+1]))
+        if (ngbla::L2Norm2(data[j]) > tol*tol)
+          (*matrix)(i, colnr[i]) =  data[j];
+
+    return matrix;
+    */
   }
 
   template <class TM>
@@ -640,36 +772,38 @@ namespace ngla
   
   template <class TM>
   shared_ptr<BaseSparseMatrix> SparseMatrixTM<TM> ::
-  CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(ngbla::Trans(TM()))>>(const Array<int>&,int)> & creator) const
+  CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(ngbla::Trans(TM()))>>(const Array<int>&,int)> & creator,
+                     bool sorted) const
   {
     Array<int> cnt(this->Width());
     cnt = 0;
     ParallelFor (this->Height(), [&] (int i)
-                 {
-                   for (int c : this->GetRowIndices(i))
-                     AsAtomic (cnt[c]) ++;
-                 });
-
+    {
+      for (int c : this->GetRowIndices(i))
+        AsAtomic (cnt[c]) ++;
+    });
+    
     auto trans = creator(cnt, this->Height());
 
     cnt = 0;
     ParallelFor (this->Height(), [&] (int i)
-                 {
-                   for (int ci : Range(this->GetRowIndices(i)))
-                     {
-                       int c = this->GetRowIndices(i)[ci];
-                       int pos = AsAtomic(cnt[c])++;
-                       trans -> GetRowIndices(c)[pos] = i;
-                       trans -> GetRowValues(c)[pos] = Trans(this->GetRowValues(i)[ci]);
-                     }
-                 });
-
-    ParallelFor (trans->Height(), [&] (int r)
-                 {
-                   auto rowvals = trans->GetRowValues(r);
-                   BubbleSort (trans->GetRowIndices(r),
-                               FlatArray(rowvals.Size(), rowvals.Data()));
-                 });
+    {
+      for (int ci : Range(this->GetRowIndices(i)))
+        {
+          int c = this->GetRowIndices(i)[ci];
+          int pos = AsAtomic(cnt[c])++;
+          trans -> GetRowIndices(c)[pos] = i;
+          trans -> GetRowValues(c)[pos] = Trans(this->GetRowValues(i)[ci]);
+        }
+    });
+    
+    if (sorted)
+      ParallelFor (trans->Height(), [&] (int r)
+      {
+        auto rowvals = trans->GetRowValues(r);
+        BubbleSort (trans->GetRowIndices(r),
+                    FlatArray(rowvals.Size(), rowvals.Data()));
+      });
 
     return trans;
   }
@@ -794,7 +928,8 @@ namespace ngla
   shared_ptr<BaseJacobiPrecond>
   SparseMatrixSymmetric<TM,TV> :: CreateJacobiPrecond (shared_ptr<BitArray> inner) const 
   { 
-    return make_shared<JacobiPrecondSymmetric<TM,TV>> (*this, inner);
+    return make_shared<JacobiPrecondSymmetric<TM,TV>> ( dynamic_pointer_cast<SparseMatrixSymmetric>
+                                                        (const_cast<SparseMatrixSymmetric*>(this)->shared_from_this()), inner);
   }
   
 

netgen/include/special_matrix.hpp

@@ -182,6 +182,8 @@ namespace ngla
 
     virtual void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;
     virtual void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
+
+    virtual shared_ptr<BaseSparseMatrix> CreateSparseMatrix() const override;    
   };
 
 

netgen/include/statushandler.hpp

@@ -3,27 +3,27 @@
 
 namespace ngstd
 {
-
+  
   /** Access to statusbar. (and more)
    */
 
   class NGS_DLL_HEADER BaseStatusHandler
-  {
-  public:
-    static void PushStatus (const char * str);
+    {
+    public:
+    static void PushStatus (const std::string& str);
     static void PopStatus ();
     static void SetThreadPercentage (double percent);
-
+    
     static void GetStatus (string & str, double & percent);
-
+    
     static void SetTerminate(void);
     static void UnSetTerminate(void);
     static bool ShouldTerminate(void);
-
+    
     class Region
     {
     public:
-      Region(const char * str) { PushStatus(str); }
+      Region(const string& str) { PushStatus(str); }
       ~Region() { PopStatus(); }
     };
   };

netgen/include/symbolicintegrator.hpp

@@ -604,6 +604,7 @@ public:
 
   class SymbolicFacetLinearFormIntegrator : public FacetLinearFormIntegrator
   {
+  protected:
     shared_ptr<CoefficientFunction> cf;
     Array<ProxyFunction*> proxies;
     Array<CoefficientFunction*> cache_cfs;
@@ -614,7 +615,7 @@ public:
     SIMD_IntegrationRule simd_ir;   // if non-empty use this integration-rule
 
   public:
-    SymbolicFacetLinearFormIntegrator (shared_ptr<CoefficientFunction> acf, VorB avb);
+    NGS_DLL_HEADER SymbolicFacetLinearFormIntegrator (shared_ptr<CoefficientFunction> acf, VorB avb);
 
     virtual VorB VB() const override { return vb; }
     virtual bool BoundaryForm() const override { return vb == BND; }

netgen/include/tangentialfacetfespace.hpp

@@ -16,34 +16,22 @@ namespace ngcomp
   class NGS_DLL_HEADER TangentialFacetFESpace : public FESpace
   {
   protected:
-    /// Level
-    // int level;
-    /// Number of Facets
-    // int nfacets;
-    /// 
-    // int ncfacets;
-    ///
-    // int nel;
-
     Array<int> first_facet_dof;
     Array<int> first_inner_dof;  // for highest_order_dc
-    // int ndof_lo;
 
     int rel_order;
 
     Array<IVec<2> > order_facet;
     Array<bool> fine_facet;
 
-    // int ndof;
-    // Array<int> ndlevel;
     bool var_order;
     bool print;
 
     bool highest_order_dc;
     bool hide_highest_order_dc;
+    bool all_dofs_together;
     
   public:
-    ///
     TangentialFacetFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, 
                             bool parseflags = false );
 
@@ -61,20 +49,11 @@ namespace ngcomp
     virtual void SetOrder (NodeId ni, int order) override;
     virtual int GetOrder (NodeId ni) const override;
 
-    
-    // virtual size_t GetNDof() const throw() override { return ndof; }
-    // virtual size_t GetNDofLevel ( int i ) const override { return ndlevel[i]; }
-
     virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
 
-    // virtual int GetNDofLowOrder () const
-    // { return ndof_lo; }
 
     virtual FiniteElement & GetFE(ElementId ei, Allocator & lh) const override;
     
-    // virtual const FiniteElement & GetFE ( int elnr, LocalHeap & lh ) const;
-    // virtual const FiniteElement & GetSFE ( int selnr, LocalHeap & lh ) const;
-
     virtual void GetFacetDofNrs (int felnr, Array<DofId> & dnums) const;
 
     virtual int GetNFacetDofs (int felnr) const;
@@ -90,6 +69,12 @@ namespace ngcomp
     virtual IVec<2> GetFacetOrder(int fnr) const;
 
     virtual int GetFirstFacetDof(int fanr) const;
+    const auto & GetFirstFacetDof() const { return first_facet_dof; }
+
+    IntRange GetFacetDofs (int nr) const
+    { 
+      return IntRange (first_facet_dof[nr], first_facet_dof[nr+1]); 
+    }
 
     virtual bool UsesHighestOrderDiscontinuous() const {return highest_order_dc;};