Cleaning up some places where we don't need namedtuples to speed up t…

src/FunctionSpaces.jl

@@ -25,7 +25,7 @@ function _setup_ref_fes(mesh::AbstractMesh, interp_type, q_degree)
   block_names = mesh.element_block_names
   ref_fes = ReferenceFE[]
   for elem_name in mesh.element_types
-    elem_type = elem_type_map[uppercase(elem_name)]
+    elem_type = elem_type_map[uppercase(String(elem_name))]
     ref_fe = ReferenceFE(elem_type{interp_type, q_degree}())
     push!(ref_fes, ref_fe)
   end

src/Meshes.jl

@@ -257,25 +257,25 @@ $(TYPEDFIELDS)
 """
 struct UnstructuredMesh{
   MeshObj,
-  X, 
-  EBlockNames, ETypes, EConns, EMaps, 
-  NMap,
-  NSetNodes,
-  SSetIVs, SSetIMs,
-  EdgeConns, FaceConns
+  ND,
+  RT <: Number,
+  IT <: Integer,
+  EConns,
+  EdgeConns,
+  FaceConns
 } <: AbstractMesh
   mesh_obj::MeshObj
-  nodal_coords::X
-  element_block_names::EBlockNames
-  element_types::ETypes
+  nodal_coords::H1Field{RT, Vector{RT}, ND}
+  element_block_names::Vector{Symbol}
+  element_types::Vector{Symbol}
   element_conns::EConns
-  element_id_maps::EMaps
-  node_id_map::NMap
-  nodeset_nodes::NSetNodes # TODO, we can remove this since we're using sidesets now.
-  sideset_elems::SSetIVs
-  sideset_nodes::SSetIVs
-  sideset_sides::SSetIVs
-  sideset_side_nodes::SSetIMs
+  element_id_maps::Dict{Symbol, Vector{IT}}
+  node_id_map::Vector{IT}
+  nodeset_nodes::Dict{Symbol, Vector{IT}}
+  sideset_elems::Dict{Symbol, Vector{IT}}
+  sideset_nodes::Dict{Symbol, Vector{IT}}
+  sideset_sides::Dict{Symbol, Vector{IT}}
+  sideset_side_nodes::Dict{Symbol, Matrix{IT}}
   # new additions
   edge_conns::EdgeConns
   face_conns::FaceConns
@@ -307,30 +307,32 @@ function UnstructuredMesh(file::FileMesh{T}, create_edges::Bool, create_faces::B
   el_block_ids = element_block_ids(file)
   el_block_names = element_block_names(file)
   el_block_names = Symbol.(el_block_names)
-  el_types = element_type.((file,), el_block_ids)
-  el_types = NamedTuple{tuple(el_block_names...)}(tuple(el_types...))
+  el_types = Symbol.(element_type.((file,), el_block_ids))
   el_conns = element_connectivity.((file,), el_block_ids)
+  # el_conns = Dict(zip(el_block_names, el_conns))
   el_conns = map(Connectivity, el_conns)
   el_conns = NamedTuple{tuple(el_block_names...)}(tuple(el_conns...))
   el_id_maps = element_block_id_map.((file,), el_block_ids)
-  el_id_maps = NamedTuple{tuple(el_block_names...)}(tuple(el_id_maps...))
+  el_id_maps = Dict(zip(el_block_names, el_id_maps))
+  # el_id_maps = NamedTuple{tuple(el_block_names...)}(tuple(el_id_maps...))
 
   # read node id map
-  n_id_map = node_id_map(file)
+  n_id_map = convert.(Int64, node_id_map(file))
 
   # read nodesets
   nset_names = Symbol.(nodeset_names(file))
   nsets = nodesets(file, nodeset_ids(file))
-  nset_nodes = NamedTuple{tuple(nset_names...)}(tuple(nsets...))
+  nset_nodes = Dict(zip(nset_names, nsets))
 
-  # read sidesets
+  # read sidesets 
   sset_names = Symbol.(sideset_names(file))
   ssets = sidesets(file, sideset_ids(file))
 
-  sset_elems = NamedTuple{tuple(sset_names...)}(tuple(map(x -> x[1], ssets)...))
-  sset_nodes = NamedTuple{tuple(sset_names...)}(tuple(map(x -> x[2], ssets)...))
-  sset_sides = NamedTuple{tuple(sset_names...)}(tuple(map(x -> x[3], ssets)...))
-  sset_side_nodes = NamedTuple{tuple(sset_names...)}(tuple(map(x -> x[4], ssets)...))
+  sset_elems = Dict(zip(sset_names, map(x -> x[1], ssets)))
+  sset_nodes = Dict(zip(sset_names, map(x -> x[2], ssets)))
+  sset_sides = Dict(zip(sset_names, map(x -> x[3], ssets)))
+  sset_side_nodes = Dict(zip(sset_names, map(x -> x[4], ssets)))
+
 
   # TODO also add edges/faces for sidesets, this may be tricky...
 

src/Parameters.jl

@@ -4,19 +4,19 @@ abstract type AbstractParameters end
 struct Parameters{
   RT <: Number, # Real type
   RV <: AbstractArray{RT, 1}, # Real vector type
-  ICs <: InitialConditions,
-  DBCs <: DirichletBCs,
+  IV <: AbstractArray{<:Integer, 1},
+  ICFuncs <: NamedTuple,
+  DBCFuncs <: NamedTuple,
   NBCs <: NeumannBCs,
   Phys <: NamedTuple, 
   Props <: NamedTuple, 
   S <: NamedTuple, 
-  # H1Coords, H1
   NDims,
   NH1Fields
 } <: AbstractParameters
   # parameter/solution fields
-  ics::ICs
-  dirichlet_bcs::DBCs
+  ics::InitialConditions{IV, RV, ICFuncs}
+  dirichlet_bcs::DirichletBCs{IV, RV, DBCFuncs}
   neumann_bcs::NBCs
   times::TimeStepper{RV}
   physics::Phys
@@ -57,7 +57,7 @@ function Parameters(
   # for mixed spaces we'll need to do this more carefully
   if isa(physics, AbstractPhysics)
     # syms = keys(values(assembler.dof.H1_vars)[1].fspace.elem_conns)
-    syms = keys(function_space(assembler.dof).elem_conns)
+    syms = keys(function_space(assembler.dof).ref_fes)
     physics = map(x -> physics, syms)
     physics = NamedTuple{tuple(syms...)}(tuple(physics...))
   else
@@ -67,7 +67,7 @@ function Parameters(
 
   if isa(properties, AbstractArray)
     # syms = keys(values(assembler.dof.H1_vars)[1].fspace.elem_conns)
-    syms = keys(function_space(assembler.dof).elem_conns)
+    syms = keys(function_space(assembler.dof).ref_fes)
     properties = map(x -> properties, syms)
     properties = NamedTuple{tuple(syms...)}(tuple(properties...))
   else
@@ -89,6 +89,7 @@ function Parameters(
     )
     NE = size(
       getfield(function_space(assembler.dof).elem_conns, key),
+      # function_space(assembler.dof).elem_conns[key],
       2
     )
 

src/assemblers/SparseMatrixAssembler.jl

@@ -62,6 +62,7 @@ function SparseMatrixAssembler(dof::DofManager)
   for (key, val) in pairs(fspace.ref_fes)
     NQ = ReferenceFiniteElements.num_quadrature_points(val)
     NE = size(getfield(fspace.elem_conns, key), 2)
+    # NE = size(fspace.elem_conns[key], 2)
     field = L2ElementField(zeros(Float64, NQ, NE))
     push!(scalar_quadarature_storage, field)
   end

src/bcs/BoundaryConditions.jl

@@ -80,7 +80,6 @@ function BCBookKeeping(
 
   # get dof index associated with this var
   dof_index = _dof_index_from_var_name(dof, var_name)
-  fspace = function_space(dof)
 
   # get sset specific fields
   all_dofs = reshape(1:length(dof), size(dof))
@@ -94,25 +93,24 @@ function BCBookKeeping(
     conns = getproperty(mesh.element_conns, block_name)
     nodes = sort(unique(conns.data))
     dofs = all_dofs[dof_index, nodes]
-    elements = getproperty(mesh.element_id_maps, block_name)
+    elements = mesh.element_id_maps[block_name]
     # below 2 don't make sense for other mesh entity types
     sides = Vector{Int64}(undef, 0)
     side_nodes = Matrix{Int64}(undef, 0, 0)
   elseif nset_name !== nothing
     # for this case we only setup the "nodes" and "dofs"
     blocks = Vector{Int64}(undef, 0) # TODO we could eventually put the blocks present here
-    nodes = getproperty(mesh.nodeset_nodes, nset_name)
+    nodes = mesh.nodeset_nodes[nset_name]
     dofs = all_dofs[dof_index, nodes]
     elements = Vector{Int64}(undef, 0) # TODO we could eventually put the elements present here
     # below 2 don't make sense for other mesh entity types
     sides = Vector{Int64}(undef, 0)
     side_nodes = Matrix{Int64}(undef, 0, 0)
   elseif sset_name !== nothing
-
-    elements = getproperty(mesh.sideset_elems, sset_name)
-    nodes = getproperty(mesh.sideset_nodes, sset_name)
-    sides = getproperty(mesh.sideset_sides, sset_name)
-    side_nodes = getproperty(mesh.sideset_side_nodes, sset_name)
+    elements = mesh.sideset_elems[sset_name]
+    nodes = mesh.sideset_nodes[sset_name]
+    sides = mesh.sideset_sides[sset_name]
+    side_nodes = mesh.sideset_side_nodes[sset_name]
 
     blocks = Vector{Int64}(undef, 0)
 
@@ -138,41 +136,6 @@ function BCBookKeeping(
   )
 end
 
-function BCBookKeeping(mesh, sset_name::Symbol)
-    # get sset specific fields
-    elements = getproperty(mesh.sideset_elems, sset_name)
-    nodes = getproperty(mesh.sideset_nodes, sset_name)
-    sides = getproperty(mesh.sideset_sides, sset_name)
-    side_nodes = getproperty(mesh.sideset_side_nodes, sset_name)
-
-    blocks = Vector{Int64}(undef, 0)
-
-      # gather the blocks that are present in this sideset
-    # TODO this isn't quite right
-    for (n, val) in enumerate(values(mesh.element_id_maps))
-      # note these are the local elem id to the block, e.g. starting from 1.
-      indices_in_sset = indexin(val, elements)
-      filter!(x -> x !== nothing, indices_in_sset)
-
-      if length(indices_in_sset) > 0
-        append!(blocks, repeat([n], length(indices_in_sset)))
-      end
-    end
-
-    dofs = Vector{Int64}(undef, 0)
-      return BCBookKeeping(
-      blocks, dofs, elements, nodes, sides, side_nodes
-    )
-end
-
-# function Base.show(io::IO, bk::BCBookKeeping)
-#   println(io, "Blocks                    = $(unique(bk.blocks))")
-#   println(io, "Number of active dofs     = $(length(bk.dofs))")
-#   println(io, "Number of active elements = $(length(bk.elements))")
-#   println(io, "Number of active nodes    = $(length(bk.nodes))")
-#   println(io, "Number of active sides    = $(length(bk.sides))")
-# end
-
 """
 $(TYPEDEF)
 $(TYPEDSIGNATURES)

src/bcs/DirichletBCs.jl

@@ -37,16 +37,14 @@ $(TYPEDFIELDS)
 Internal implementation of dirichlet BCs
 """
 struct DirichletBCContainer{
-  IT <: Integer,
-  VT <: Number,
-  IV <: AbstractArray{IT, 1},
-  VV <: AbstractArray{VT, 1}
+  IV <: AbstractArray{<:Integer, 1},
+  RV <: AbstractArray{<:Number, 1}
 } <: AbstractBCContainer
   dofs::IV
   nodes::IV
-  vals::VV
-  vals_dot::VV
-  vals_dot_dot::VV
+  vals::RV
+  vals_dot::RV
+  vals_dot_dot::RV
 end
 
 """
@@ -212,10 +210,11 @@ function DirichletBCFunction(func)
 end
 
 struct DirichletBCs{
-  BCCaches <: NamedTuple, 
+  IV      <: AbstractArray{<:Integer, 1},
+  RV      <: AbstractArray{<:Number, 1},
   BCFuncs <: NamedTuple
 }
-  bc_caches::BCCaches
+  bc_caches::Vector{DirichletBCContainer{IV, RV}}
   bc_funcs::BCFuncs
 end
 
@@ -237,13 +236,16 @@ function DirichletBCs(mesh, dof, dirichlet_bcs)
     update_dofs!(dof, temp_dofs)
   end
 
-  dirichlet_bcs = NamedTuple{tuple(syms...)}(tuple(dirichlet_bcs...))
+  # dirichlet_bcs = NamedTuple{tuple(syms...)}(tuple(dirichlet_bcs...))
 
   return DirichletBCs(dirichlet_bcs, dirichlet_bc_funcs)
 end
 
 function Adapt.adapt_structure(to, bcs::DirichletBCs)
-  return DirichletBCs(adapt(to, bcs.bc_caches), adapt(to, bcs.bc_funcs))
+  return DirichletBCs(
+    map(x -> adapt(to, x), bcs.bc_caches),
+    adapt(to, bcs.bc_funcs)
+  )
 end
 
 function Base.length(bcs::DirichletBCs)

src/bcs/NeumannBCs.jl

@@ -25,8 +25,8 @@ $(TYPEDEF)
 $(TYPEDSIGNATURES)
 $(TYPEDFIELDS)
 """
-function NeumannBC(var_name::String, sset_name::Symbol, func::Function)
-  return NeumannBC{typeof(func)}(Symbol(var_name), Symbol(sset_name), func)
+function NeumannBC(var_name::String, sset_name::String, func::Function)
+  return NeumannBC(Symbol(var_name), Symbol(sset_name), func)
 end
 
 """
@@ -37,10 +37,9 @@ Internal implementation of dirichlet BCs
 """
 struct NeumannBCContainer{
   IT <: Integer,
-  VT <: Union{<:Number, <:SVector},
   IV <: AbstractArray{IT, 1},
   IM <: AbstractArray{IT, 2},
-  VV <: AbstractArray{VT, 2},
+  RV <: AbstractArray{<:Union{<:Number, <:SVector}, 2},
   C1, # TODO specialize
   C2, # TODO specialize
   RE <: ReferenceFE
@@ -52,7 +51,7 @@ struct NeumannBCContainer{
   sides::IV
   surface_conns::C2
   ref_fe::RE
-  vals::VV
+  vals::RV
 end
 
 function Adapt.adapt_structure(to, bc::NeumannBCContainer)
@@ -118,7 +117,10 @@ function _update_bc_values!(bc::NeumannBCContainer, func, X, t, backend::KA.Back
   kernel!(bc, func, X, t, ndrange=size(bc.vals))
 end
 
-struct NeumannBCs{BCCaches, BCFuncs}
+struct NeumannBCs{
+  BCCaches <: NamedTuple, 
+  BCFuncs  <: NamedTuple
+}
   bc_caches::BCCaches
   bc_funcs::BCFuncs
 end