Merge branch 'master' into kam/fastsparsity

Author: KnutAM

src/Dofs/DofHandler.jl

@@ -210,7 +210,13 @@ function celldofs!(global_dofs::Vector{Int}, dh::DofHandler, i::Int)
     unsafe_copyto!(global_dofs, 1, dh.cell_dofs, dh.cell_dofs_offset[i], length(global_dofs))
     return global_dofs
 end
-function celldofs!(global_dofs::Vector{Int}, sdh::SubDofHandler, i::Int)
+function celldofs!(global_dofs::AbstractVector{Int}, dh::AbstractDofHandler, i::Int)
+    @assert isclosed(dh)
+    @assert length(global_dofs) == ndofs_per_cell(dh, i)
+    copyto!(global_dofs, 1, dh.cell_dofs, dh.cell_dofs_offset[i], length(global_dofs))
+    return global_dofs
+end
+function celldofs!(global_dofs::AbstractVector{Int}, sdh::SubDofHandler, i::Int)
     @assert i in sdh.cellset
     return celldofs!(global_dofs, sdh.dh, i)
 end
@@ -226,7 +232,7 @@ function celldofs(dh::AbstractDofHandler, i::Int)
     return celldofs!(zeros(Int, ndofs_per_cell(dh, i)), dh, i)
 end
 
-function cellnodes!(global_nodes::Vector{Int}, dh::DofHandler, i::Union{Int, <:AbstractCell})
+function cellnodes!(global_nodes::AbstractVector{Int}, dh::DofHandler, i::Union{Int, <:AbstractCell})
     return cellnodes!(global_nodes, get_grid(dh), i)
 end
 

src/Grid/grid.jl

@@ -425,7 +425,7 @@ get_coordinate_type(::Grid{dim, C, T}) where {dim, C, T} = Vec{dim, T} # Node is
 This function takes the local vertex representation (a `VertexIndex`) and looks up the unique global id (an `Int`).
 """
 toglobal(grid::AbstractGrid, vertexidx::VertexIndex) = vertices(getcells(grid, vertexidx[1]))[vertexidx[2]]
-toglobal(grid::AbstractGrid, vertexidx::Vector{VertexIndex}) = unique(toglobal.((grid,), vertexidx))
+toglobal(grid::AbstractGrid, vertexidx::AbstractVector{VertexIndex}) = unique(toglobal.((grid,), vertexidx))
 
 """
     Ferrite.getspatialdim(grid::AbstractGrid)
@@ -465,7 +465,7 @@ Returns either all `cells::Collection{C<:AbstractCell}` of a `<:AbstractGrid` or
 Whereas the last option tries to call a `cellset` of the `grid`. `Collection` can be any indexable type, for `Grid` it is `Vector{C<:AbstractCell}`.
 """
 @inline getcells(grid::AbstractGrid) = grid.cells
-@inline getcells(grid::AbstractGrid, v::Union{Int, Vector{Int}}) = grid.cells[v]
+@inline getcells(grid::AbstractGrid, v::Union{Int, AbstractVector{Int}}) = grid.cells[v]
 @inline getcells(grid::AbstractGrid, setname::String) = grid.cells[collect(getcellset(grid, setname))]
 "Returns the number of cells in the `<:AbstractGrid`."
 @inline getncells(grid::AbstractGrid) = length(grid.cells)
@@ -483,7 +483,7 @@ The last option tries to call a `nodeset` of the `<:AbstractGrid`. `Collection{N
 to a Node.
 """
 @inline getnodes(grid::AbstractGrid) = grid.nodes
-@inline getnodes(grid::AbstractGrid, v::Union{Int, Vector{Int}}) = grid.nodes[v]
+@inline getnodes(grid::AbstractGrid, v::Union{Int, AbstractVector{Int}}) = grid.nodes[v]
 @inline getnodes(grid::AbstractGrid, setname::String) = grid.nodes[collect(getnodeset(grid, setname))]
 "Returns the number of nodes in the grid."
 @inline getnnodes(grid::AbstractGrid) = length(grid.nodes)
@@ -584,14 +584,15 @@ end
 
 Mutate `x` to the coordinates of the cell corresponding to `idx` or `cell`.
 """
-@inline function getcoordinates!(x::Vector{Vec{dim, T}}, grid::AbstractGrid, cell::AbstractCell) where {dim, T}
+@propagate_inbounds function getcoordinates!(x::AbstractVector{Vec{dim, T}}, grid::AbstractGrid, cell::AbstractCell) where {dim, T}
     node_ids = get_node_ids(cell)
-    @inbounds for i in 1:length(x)
-        x[i] = get_node_coordinate(grid, node_ids[i])
+    @boundscheck checkbounds(x, keys(node_ids))
+    @inbounds for (i, node_id) in pairs(node_ids)
+        x[i] = get_node_coordinate(grid, node_id)
     end
     return x
 end
-@inline function getcoordinates!(x::Vector{Vec{dim, T}}, grid::AbstractGrid, cellid::Int) where {dim, T}
+@inline function getcoordinates!(x::AbstractVector{Vec{dim, T}}, grid::AbstractGrid, cellid::Int) where {dim, T}
     cell = getcells(grid, cellid)
     return getcoordinates!(x, grid, cell)
 end
@@ -604,16 +605,15 @@ Return the coordinate of the `n`th node in `grid`
 """
 get_node_coordinate(grid, n) = get_node_coordinate(getnodes(grid, n))
 
-function cellnodes!(global_nodes::Vector{Int}, grid::AbstractGrid, i::Int)
+function cellnodes!(global_nodes::AbstractVector{Int}, grid::AbstractGrid, i::Int)
     cell = getcells(grid, i)
     _cellnodes!(global_nodes, cell)
     return global_nodes
 end
-function _cellnodes!(global_nodes::Vector{Int}, cell::AbstractCell)
+function _cellnodes!(global_nodes::AbstractVector{Int}, cell::AbstractCell)
     @assert length(global_nodes) == nnodes(cell)
-    @inbounds for i in 1:length(global_nodes)
-        global_nodes[i] = cell.nodes[i]
-    end
+    node_ids = get_node_ids(cell)
+    copyto!(global_nodes, node_ids)
     return global_nodes
 end
 

test/test_grid_dofhandler_vtk.jl

@@ -182,6 +182,14 @@ end
 
     @test getcells(grid, "cell_set") == [getcells(grid, 1)]
 
+    # cellnodes via empty DofHandler
+    nodeids = zeros(Int, 9)
+    dh = DofHandler(grid)
+    close!(dh)
+    Ferrite.cellnodes!(nodeids, dh, 1)
+    # Note that the return types typically differ (Vector vs Tuple)
+    @test all(nodeids .== Ferrite.get_node_ids(getcells(grid, 1)))
+
     # CellIterator on a grid without DofHandler
     grid = generate_grid(Triangle, (4, 4))
     n = 0
@@ -546,7 +554,6 @@ end
         Line((6, 7)),
     ]
     nodes = [Node(coord) for coord in zeros(Vec{2, Float64}, 18)]
-    grid = Grid(cells, nodes)
     @test_throws ErrorException ExclusiveTopology(grid)
     # topology = ExclusiveTopology(grid)
     # @test_throws ArgumentError Ferrite.facetskeleton(topology, grid)
@@ -585,7 +592,7 @@ end
     @test Set(Ferrite.getstencil(stars, quadgrid, VertexIndex(5, 4))) == Set([VertexIndex(4, 2), VertexIndex(4, 4), VertexIndex(5, 1), VertexIndex(5, 3), VertexIndex(7, 1), VertexIndex(7, 3), VertexIndex(8, 2), VertexIndex(8, 4), VertexIndex(4, 3), VertexIndex(5, 4), VertexIndex(7, 2), VertexIndex(8, 1)])
     @test Set(Ferrite.toglobal.((quadgrid,), Ferrite.getstencil(stars, quadgrid, VertexIndex(1, 1)))) == Set([1, 2, 5])
     @test Set(Ferrite.toglobal.((quadgrid,), Ferrite.getstencil(stars, quadgrid, VertexIndex(2, 1)))) == Set([2, 1, 6, 3])
-    @test Set(Ferrite.toglobal.((quadgrid,), Ferrite.getstencil(stars, quadgrid, VertexIndex(5, 4)))) == Set([10, 6, 9, 11, 14])
+    @test Set(Ferrite.toglobal(quadgrid, collect(Ferrite.getstencil(stars, quadgrid, VertexIndex(5, 4))))) == Set([10, 6, 9, 11, 14])
 
     face_skeleton = Ferrite.facetskeleton(topology, quadgrid)
     @test Set(face_skeleton) == Set(
@@ -707,6 +714,16 @@ end
     close!(dh)
     @test celldofs(dh, 1) == [1, 2, 3, 4, 5, 6, 7, 9, 8, 10]
     @test celldofs(dh, 2) == [2, 11, 3, 12, 13, 15, 14, 7, 6, 16]
+    # Should also agree with the remaining celldofs API
+    dofs = zeros(Int, 10)
+    celldofs!(dofs, dh, 1)
+    @test dofs == celldofs(dh, 1)
+    celldofs!(dofs, dh, 2)
+    @test dofs == celldofs(dh, 2)
+    celldofs!(view(dofs, :), dh, 1)
+    @test dofs == celldofs(dh, 1)
+    celldofs!(view(dofs, :), dh, 2)
+    @test dofs == celldofs(dh, 2)
 
     ## Lagrange{RefTriangle,3}
     # First dof per position per triangle
@@ -723,6 +740,16 @@ end
     close!(dh)
     @test celldofs(dh, 1) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17, 18, 15, 16, 19, 20]
     @test celldofs(dh, 2) == [3, 4, 21, 22, 5, 6, 23, 24, 25, 26, 29, 30, 27, 28, 13, 14, 11, 12, 31, 32]
+    # Should also agree with the remaining celldofs API
+    dofs = zeros(Int, 20)
+    celldofs!(dofs, dh, 1)
+    @test dofs == celldofs(dh, 1)
+    celldofs!(dofs, dh, 2)
+    @test dofs == celldofs(dh, 2)
+    celldofs!(view(dofs, :), dh, 1)
+    @test dofs == celldofs(dh, 1)
+    celldofs!(view(dofs, :), dh, 2)
+    @test dofs == celldofs(dh, 2)
 end
 
 @testset "vectorization layer compat" begin