several bugfixes

CHANGELOG.md

@@ -1,7 +1,9 @@
 # CHANGES
 
-## next version
+## v1.0.0
   - doc improvements
+  - several bugfixes regarding finite elements defined on subgrids
+  - integrate now reacts on regions parameter and has proper docstrings
 
 ## v0.8.1 November 5, 2024
   - fixed dimension in nodevals output (xdim was determined wrongly and caused huge arrays)

Project.toml

@@ -1,7 +1,7 @@
 name = "ExtendableFEMBase"
 uuid = "12fb9182-3d4c-4424-8fd1-727a0899810c"
 authors = ["Christian Merdon <merdon@wias-berlin.de>"]
-version = "0.8.1"
+version = "1.0.0"
 
 [deps]
 DiffResults = "163ba53b-c6d8-5494-b064-1a9d43ac40c5"

src/dofmaps.jl

@@ -476,59 +476,86 @@ function init_dofmap_from_pattern!(FES::FESpace{Tv, Ti, FEType, APT}, DM::Type{<
     colstarts[end] = dofmap_totallength + 1
 
     if FES.broken
-        FES[DM] = SerialVariableTargetAdjacency(colstarts)
-        return FES[DM]
-    end
-
-    colentries = zeros(Ti, dofmap_totallength)
-    xItemDofs = VariableTargetAdjacency{Ti}(colentries, colstarts)
+        xItemDofs = SerialVariableTargetAdjacency(colstarts)
+    else
 
-    cpattern::Array{DofMapPatternSegment, 1} = dofmap4EG[1].segments
-    l::Int = 0
-    offset::Int = 0
-    pos::Int = 0
-    q::Int = 0
-    item_with_interiordofs::Int = 0
-    for subitem in 1:nsubitems
-        itemEG = xItemGeometries[subitem]
-        item = sub2sup(subitem)
-        if length(EG) > 1
-            iEG = findfirst(isequal(itemEG), EG)
-        end
-        cpattern = dofmap4EG[iEG].segments
-        l = length(cpattern)
-        if has_interiordofs[iEG]
-            item_with_interiordofs += 1
-        end
-        for c in 1:ncomponents
-            offset = (c - 1) * offset4component
-            for k in 1:l
-                q = cpattern[k].ndofs
-                if cpattern[k].type <: DofTypeNode && cpattern[k].each_component
-                    for n in 1:nnodes4EG[iEG]
+        colentries = zeros(Ti, dofmap_totallength)
+        xItemDofs = VariableTargetAdjacency{Ti}(colentries, colstarts)
+
+        cpattern::Array{DofMapPatternSegment, 1} = dofmap4EG[1].segments
+        l::Int = 0
+        offset::Int = 0
+        pos::Int = 0
+        q::Int = 0
+        item_with_interiordofs::Int = 0
+        for subitem in 1:nsubitems
+            itemEG = xItemGeometries[subitem]
+            item = sub2sup(subitem)
+            if length(EG) > 1
+                iEG = findfirst(isequal(itemEG), EG)
+            end
+            cpattern = dofmap4EG[iEG].segments
+            l = length(cpattern)
+            if has_interiordofs[iEG]
+                item_with_interiordofs += 1
+            end
+            for c in 1:ncomponents
+                offset = (c - 1) * offset4component
+                for k in 1:l
+                    q = cpattern[k].ndofs
+                    if cpattern[k].type <: DofTypeNode && cpattern[k].each_component
+                        for n in 1:nnodes4EG[iEG]
+                            for m in 1:q
+                                pos += 1
+                                xItemDofs.colentries[pos] = xItemNodes[n, item] + offset + (m - 1) * nnodes
+                            end
+                        end
+                        offset += nnodes * q
+                    elseif cpattern[k].type <: DofTypeFace && cpattern[k].each_component
+                        for n in 1:nfaces4EG[iEG]
+                            for m in 1:q
+                                pos += 1
+                                xItemDofs.colentries[pos] = xItemFaces[n, item] + offset + (m - 1) * nfaces
+                            end
+                        end
+                        offset += nfaces * q
+                    elseif cpattern[k].type <: DofTypeEdge && cpattern[k].each_component
+                        for n in 1:nedges4EG[iEG]
+                            for m in 1:q
+                                pos += 1
+                                xItemDofs.colentries[pos] = xItemEdges[n, item] + offset + (m - 1) * nedges
+                            end
+                        end
+                        offset += nedges * q
+                    elseif cpattern[k].type <: DofTypeInterior && cpattern[k].each_component
                         for m in 1:q
                             pos += 1
-                            xItemDofs.colentries[pos] = xItemNodes[n, item] + offset + (m - 1) * nnodes
+                            xItemDofs.colentries[pos] = sub2sup(item_with_interiordofs) + offset
+                            offset += nitems
                         end
                     end
-                    offset += nnodes * q
-                elseif cpattern[k].type <: DofTypeFace && cpattern[k].each_component
+                end
+            end
+            offset = ncomponents * offset4component
+            for k in 1:l
+                q = cpattern[k].ndofs
+                if cpattern[k].type <: DofTypeFace && !cpattern[k].each_component
                     for n in 1:nfaces4EG[iEG]
                         for m in 1:q
                             pos += 1
                             xItemDofs.colentries[pos] = xItemFaces[n, item] + offset + (m - 1) * nfaces
                         end
                     end
                     offset += nfaces * q
-                elseif cpattern[k].type <: DofTypeEdge && cpattern[k].each_component
+                elseif cpattern[k].type <: DofTypeEdge && !cpattern[k].each_component
                     for n in 1:nedges4EG[iEG]
                         for m in 1:q
                             pos += 1
                             xItemDofs.colentries[pos] = xItemEdges[n, item] + offset + (m - 1) * nedges
                         end
                     end
                     offset += nedges * q
-                elseif cpattern[k].type <: DofTypeInterior && cpattern[k].each_component
+                elseif cpattern[k].type <: DofTypeInterior && !cpattern[k].each_component
                     for m in 1:q
                         pos += 1
                         xItemDofs.colentries[pos] = sub2sup(item_with_interiordofs) + offset
@@ -537,37 +564,10 @@ function init_dofmap_from_pattern!(FES::FESpace{Tv, Ti, FEType, APT}, DM::Type{<
                 end
             end
         end
-        offset = ncomponents * offset4component
-        for k in 1:l
-            q = cpattern[k].ndofs
-            if cpattern[k].type <: DofTypeFace && !cpattern[k].each_component
-                for n in 1:nfaces4EG[iEG]
-                    for m in 1:q
-                        pos += 1
-                        xItemDofs.colentries[pos] = xItemFaces[n, item] + offset + (m - 1) * nfaces
-                    end
-                end
-                offset += nfaces * q
-            elseif cpattern[k].type <: DofTypeEdge && !cpattern[k].each_component
-                for n in 1:nedges4EG[iEG]
-                    for m in 1:q
-                        pos += 1
-                        xItemDofs.colentries[pos] = xItemEdges[n, item] + offset + (m - 1) * nedges
-                    end
-                end
-                offset += nedges * q
-            elseif cpattern[k].type <: DofTypeInterior && !cpattern[k].each_component
-                for m in 1:q
-                    pos += 1
-                    xItemDofs.colentries[pos] = sub2sup(item_with_interiordofs) + offset
-                    offset += nitems
-                end
-            end
-        end
     end
-
     FES[DM] = xItemDofs
 
+
     if FES.dofgrid !== FES.xgrid
         ## assume parent relation between xgrid and dofgrid
         @assert FES.dofgrid[ParentGrid] == FES.xgrid "xgrid is not the parent grid of dofgrid !!!"

src/fedefs/h1_p3.jl

@@ -201,8 +201,8 @@ function get_basis(::Type{<:AssemblyType}, ::Type{H1P3{ncomponents, edim}}, ::Ty
 end
 
 # we need to change the ordering of the face dofs on faces that have a negative orientation sign
-function get_basissubset(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1P3{ncomponents, edim}, APT}, EG::Type{<:Triangle2D}) where {ncomponents, edim, Tv, Ti, APT}
-    xCellFaceSigns = FE.dofgrid[CellFaceSigns]
+function get_basissubset(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1P3{ncomponents, edim}, APT}, EG::Type{<:Triangle2D}, xgrid) where {ncomponents, edim, Tv, Ti, APT}
+    xCellFaceSigns = xgrid[CellFaceSigns]
     nfaces::Int = num_faces(EG)
     return function closure(subset_ids::Array{Int, 1}, cell)
         for j in 1:nfaces
@@ -223,8 +223,8 @@ function get_basissubset(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1P3{ncomponents,
 end
 
 # we need to change the ordering of the face dofs on faces that have a negative orientation sign
-function get_basissubset(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1P3{ncomponents, edim}, APT}, EG::Type{<:Tetrahedron3D}) where {ncomponents, edim, Tv, Ti, APT}
-    xCellEdgeSigns = FE.dofgrid[CellEdgeSigns]
+function get_basissubset(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1P3{ncomponents, edim}, APT}, EG::Type{<:Tetrahedron3D}, xgrid) where {ncomponents, edim, Tv, Ti, APT}
+    xCellEdgeSigns = xgrid[CellEdgeSigns]
     nedges::Int = num_edges(EG)
     return function closure(subset_ids::Array{Int, 1}, cell)
         for j in 1:nedges

src/fedefs/h1_pk.jl

@@ -290,11 +290,11 @@ end
 
 
 ## if order > 2 on Triangl2D we need to change the ordering of the face dofs on faces that have a negative orientation sign
-function get_basissubset(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1Pk{ncomponents, edim, order}, APT}, EG::Type{<:Triangle2D}) where {ncomponents, edim, order, Tv, Ti, APT}
+function get_basissubset(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1Pk{ncomponents, edim, order}, APT}, EG::Type{<:Triangle2D}, xgrid) where {ncomponents, edim, order, Tv, Ti, APT}
     if order < 3
         return NothingFunction # no reordering needed
     end
-    xCellFaceSigns = FE.dofgrid[CellFaceSigns]
+    xCellFaceSigns = xgrid[CellFaceSigns]
     nfaces::Int = num_faces(EG)
     ndofs_for_f::Int = order - 1
     ndofs_for_c = get_ndofs(ON_CELLS, H1Pk{1, edim, order}, EG)

src/fedefs/h1v_br.jl

@@ -148,9 +148,9 @@ function get_basis(AT::Type{ON_CELLS}, FEType::Type{H1BR{2}}, EG::Type{<:Quadril
     end
 end
 
-function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1BR{2}, APT}, ::Type{<:Triangle2D}) where {Tv, Ti, APT}
-    xFaceNormals::Array{Tv, 2} = FE.dofgrid[FaceNormals]
-    xCellFaces = FE.dofgrid[CellFaces]
+function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1BR{2}, APT}, ::Type{<:Triangle2D}, xgrid) where {Tv, Ti, APT}
+    xFaceNormals::Array{Tv, 2} = xgrid[FaceNormals]
+    xCellFaces = xgrid[CellFaces]
     return function closure(coefficients::Array{<:Real, 2}, cell)
         fill!(coefficients, 1.0)
         coefficients[1, 7] = xFaceNormals[1, xCellFaces[1, cell]]
@@ -162,9 +162,9 @@ function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1BR{2}, APT}, :
     end
 end
 
-function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1BR{2}, APT}, ::Type{<:Quadrilateral2D}) where {Tv, Ti, APT}
-    xFaceNormals::Array{Tv, 2} = FE.dofgrid[FaceNormals]
-    xCellFaces = FE.dofgrid[CellFaces]
+function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1BR{2}, APT}, ::Type{<:Quadrilateral2D}, xgrid) where {Tv, Ti, APT}
+    xFaceNormals::Array{Tv, 2} = xgrid[FaceNormals]
+    xCellFaces = xgrid[CellFaces]
     return function closure(coefficients::Array{<:Real, 2}, cell)
         fill!(coefficients, 1.0)
         coefficients[1, 9] = xFaceNormals[1, xCellFaces[1, cell]]
@@ -178,8 +178,8 @@ function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1BR{2}, APT}, :
     end
 end
 
-function get_coefficients(::Type{<:ON_FACES}, FE::FESpace{Tv, Ti, H1BR{2}, APT}, ::Type{<:Edge1D}) where {Tv, Ti, APT}
-    xFaceNormals::Array{Tv, 2} = FE.dofgrid[FaceNormals]
+function get_coefficients(::Type{<:ON_FACES}, FE::FESpace{Tv, Ti, H1BR{2}, APT}, ::Type{<:Edge1D}, xgrid) where {Tv, Ti, APT}
+    xFaceNormals::Array{Tv, 2} = xgrid[FaceNormals]
     return function closure(coefficients::Array{<:Real, 2}, face)
         # multiplication of face bubble with normal vector of face
         fill!(coefficients, 1.0)
@@ -253,9 +253,9 @@ function get_basis(AT::Type{ON_CELLS}, ::Type{H1BR{3}}, EG::Type{<:Hexahedron3D}
 end
 
 
-function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1BR{3}, APT}, ::Type{<:Tetrahedron3D}) where {Tv, Ti, APT}
-    xFaceNormals::Array{Tv, 2} = FE.dofgrid[FaceNormals]
-    xCellFaces::Adjacency{Ti} = FE.dofgrid[CellFaces]
+function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1BR{3}, APT}, ::Type{<:Tetrahedron3D}, xgrid) where {Tv, Ti, APT}
+    xFaceNormals::Array{Tv, 2} = xgrid[FaceNormals]
+    xCellFaces::Adjacency{Ti} = xgrid[CellFaces]
     return function closure(coefficients::Array{<:Real, 2}, cell)
         # multiplication with normal vectors
         fill!(coefficients, 1.0)
@@ -276,8 +276,8 @@ function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1BR{3}, APT}, :
 end
 
 
-function get_coefficients(::Type{<:ON_FACES}, FE::FESpace{Tv, Ti, H1BR{3}, APT}, ::Type{<:Triangle2D}) where {Tv, Ti, APT}
-    xFaceNormals::Array{Tv, 2} = FE.dofgrid[FaceNormals]
+function get_coefficients(::Type{<:ON_FACES}, FE::FESpace{Tv, Ti, H1BR{3}, APT}, ::Type{<:Triangle2D}, xgrid) where {Tv, Ti, APT}
+    xFaceNormals::Array{Tv, 2} = xgrid[FaceNormals]
     return function closure(coefficients::Array{<:Real, 2}, face)
         # multiplication of face bubble with normal vector of face
         fill!(coefficients, 1.0)
@@ -287,9 +287,9 @@ function get_coefficients(::Type{<:ON_FACES}, FE::FESpace{Tv, Ti, H1BR{3}, APT},
     end
 end
 
-function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1BR{3}, APT}, ::Type{<:Hexahedron3D}) where {Tv, Ti, APT}
-    xFaceNormals::Array{Tv, 2} = FE.dofgrid[FaceNormals]
-    xCellFaces::Adjacency{Ti} = FE.dofgrid[CellFaces]
+function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1BR{3}, APT}, ::Type{<:Hexahedron3D}, xgrid) where {Tv, Ti, APT}
+    xFaceNormals::Array{Tv, 2} = xgrid[FaceNormals]
+    xCellFaces::Adjacency{Ti} = xgrid[CellFaces]
     return function closure(coefficients::Array{<:Real, 2}, cell)
         # multiplication with normal vectors
         fill!(coefficients, 1.0)
@@ -316,8 +316,8 @@ function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1BR{3}, APT}, :
 end
 
 
-function get_coefficients(::Type{<:ON_FACES}, FE::FESpace{Tv, Ti, H1BR{3}, APT}, ::Type{<:Quadrilateral2D}) where {Tv, Ti, APT}
-    xFaceNormals::Array{Tv, 2} = FE.dofgrid[FaceNormals]
+function get_coefficients(::Type{<:ON_FACES}, FE::FESpace{Tv, Ti, H1BR{3}, APT}, ::Type{<:Quadrilateral2D}, xgrid) where {Tv, Ti, APT}
+    xFaceNormals::Array{Tv, 2} = xgrid[FaceNormals]
     return function closure(coefficients::Array{<:Real, 2}, face)
         # multiplication of face bubble with normal vector of face
         fill!(coefficients, 1.0)

src/fedefs/h1v_p1teb.jl

@@ -253,9 +253,9 @@ function get_basis(AT::Type{ON_CELLS}, ::Type{H1P1TEB{3}}, EG::Type{<:Tetrahedro
     end
 end
 
-function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1P1TEB{3}, APT}, ::Type{<:Tetrahedron3D}) where {Tv, Ti, APT}
-    xEdgeTangents::Array{Tv, 2} = FE.dofgrid[EdgeTangents]
-    xCellEdges = FE.dofgrid[CellEdges]
+function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1P1TEB{3}, APT}, ::Type{<:Tetrahedron3D}, xgrid) where {Tv, Ti, APT}
+    xEdgeTangents::Array{Tv, 2} = xgrid[EdgeTangents]
+    xCellEdges = xgrid[CellEdges]
     return function closure(coefficients::Array{<:Real, 2}, cell)
         fill!(coefficients, 1.0)
         for e in 1:6, k in 1:2
@@ -265,9 +265,9 @@ function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, H1P1TEB{3}, APT}
     end
 end
 
-function get_coefficients(::Type{<:ON_FACES}, FE::FESpace{Tv, Ti, H1P1TEB{3}, APT}, ::Type{<:Triangle2D}) where {Tv, Ti, APT}
-    xEdgeTangents::Array{Tv, 2} = FE.dofgrid[EdgeTangents]
-    xFaceEdges = FE.dofgrid[FaceEdges]
+function get_coefficients(::Type{<:ON_FACES}, FE::FESpace{Tv, Ti, H1P1TEB{3}, APT}, ::Type{<:Triangle2D}, xgrid) where {Tv, Ti, APT}
+    xEdgeTangents::Array{Tv, 2} = xgrid[EdgeTangents]
+    xFaceEdges = xgrid[FaceEdges]
     return function closure(coefficients::Array{<:Real, 2}, face)
         fill!(coefficients, 1.0)
         for e in 1:3, k in 1:2

src/fedefs/hcurl_n0.jl

@@ -144,8 +144,8 @@ function get_basis(::Type{ON_CELLS}, ::Type{HCURLN0{3}}, ::Type{<:Tetrahedron3D}
     end
 end
 
-function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, <:HCURLN0, APT}, EG::Type{<:AbstractElementGeometry2D}) where {Tv, Ti, APT}
-    xCellFaceSigns = FE.dofgrid[CellFaceSigns]
+function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, <:HCURLN0, APT}, EG::Type{<:AbstractElementGeometry2D}, xgrid) where {Tv, Ti, APT}
+    xCellFaceSigns = xgrid[CellFaceSigns]
     nfaces = num_faces(EG)
     return function closure(coefficients, cell)
         # multiplication with normal vector signs
@@ -156,8 +156,8 @@ function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, <:HCURLN0, APT},
     end
 end
 
-function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, <:HCURLN0, APT}, EG::Type{<:AbstractElementGeometry3D}) where {Tv, Ti, APT}
-    xCellEdgeSigns = FE.dofgrid[CellEdgeSigns]
+function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, <:HCURLN0, APT}, EG::Type{<:AbstractElementGeometry3D}, xgrid) where {Tv, Ti, APT}
+    xCellEdgeSigns = xgrid[CellEdgeSigns]
     nedges = num_edges(EG)
     return function closure(coefficients, cell)
         # multiplication with normal vector signs

src/fedefs/hcurl_n1.jl

@@ -104,8 +104,8 @@ function get_basis(::Type{ON_CELLS}, ::Type{HCURLN1{2}}, ::Type{<:Triangle2D})
     end
 end
 
-function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, <:HCURLN1, APT}, EG::Type{<:AbstractElementGeometry2D}) where {Tv, Ti, APT}
-    xCellFaceSigns = FE.dofgrid[CellFaceSigns]
+function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, <:HCURLN1, APT}, EG::Type{<:AbstractElementGeometry2D}, xgrid) where {Tv, Ti, APT}
+    xCellFaceSigns = xgrid[CellFaceSigns]
     nfaces = num_faces(EG)
     return function closure(coefficients, cell)
         # multiplication with normal vector signs (only RT0)

src/fedefs/hdiv_bdm1.jl

@@ -203,8 +203,8 @@ function get_basis(::Type{ON_CELLS}, ::Type{HDIVBDM1{3}}, ::Type{<:Tetrahedron3D
 end
 
 
-function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, <:HDIVBDM1, APT}, EG::Type{<:AbstractElementGeometry2D}) where {Tv, Ti, APT}
-    xCellFaceSigns::Union{VariableTargetAdjacency{Int32}, Array{Int32, 2}} = FE.dofgrid[CellFaceSigns]
+function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, <:HDIVBDM1, APT}, EG::Type{<:AbstractElementGeometry2D}, xgrid) where {Tv, Ti, APT}
+    xCellFaceSigns::Union{VariableTargetAdjacency{Int32}, Array{Int32, 2}} = xgrid[CellFaceSigns]
     nfaces::Int = num_faces(EG)
     dim::Int = dim_element(EG)
     return function closure(coefficients::Array{<:Real, 2}, cell::Int)
@@ -218,9 +218,8 @@ function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, <:HDIVBDM1, APT}
 end
 
 
-function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, <:HDIVBDM1, APT}, EG::Type{<:AbstractElementGeometry3D}) where {Tv, Ti, APT}
-    xCellFaceSigns::Union{VariableTargetAdjacency{Int32}, Array{Int32, 2}} = FE.dofgrid[CellFaceSigns]
-    xCellFaceOrientations::Union{VariableTargetAdjacency{Int32}, Array{Int32, 2}} = FE.dofgrid[CellFaceOrientations]
+function get_coefficients(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, <:HDIVBDM1, APT}, EG::Type{<:AbstractElementGeometry3D}, xgrid) where {Tv, Ti, APT}
+    xCellFaceSigns::Union{VariableTargetAdjacency{Int32}, Array{Int32, 2}} = xgrid[CellFaceSigns]
     nfaces::Int = num_faces(EG)
     dim::Int = dim_element(EG)
     return function closure(coefficients::Array{<:Real, 2}, cell::Int)
@@ -238,8 +237,8 @@ end
 # the RT0 and those two BDM1 face functions are chosen
 # such that they reflect the two moments with respect to the second and third node
 # of the global face enumeration
-function get_basissubset(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, <:HDIVBDM1, APT}, EG::Type{<:AbstractElementGeometry3D}) where {Tv, Ti, APT}
-    xCellFaceOrientations = FE.dofgrid[CellFaceOrientations]
+function get_basissubset(::Type{ON_CELLS}, FE::FESpace{Tv, Ti, <:HDIVBDM1, APT}, EG::Type{<:AbstractElementGeometry3D}, xgrid) where {Tv, Ti, APT}
+    xCellFaceOrientations = xgrid[CellFaceOrientations]
     nfaces::Int = num_faces(EG)
     orientation = xCellFaceOrientations[1, 1]
     shift4orientation1::Array{Int, 1} = [1, 0, 1, 2]