Assemblers/fill!

docs/make.jl

@@ -36,6 +36,7 @@ makedocs(;
         "Function spaces"     => "function_spaces.md",
         "Functions"           => "functions.md",
         "Meshes"              => "meshes.md",
+        "Parameters"          => "parameters.md",
         "Physics"             => "physics.md"
     ],
 )

docs/src/assemblers.md

@@ -7,32 +7,38 @@ This section describes the assemblers that are currently available and their abs
 
 All assemblers must possess at minimum a ```DofManager```.
 
-## Abstract Interface
+## Matrices
 ```@autodocs
 Modules = [FiniteElementContainers]
-Pages = ["Assemblers.jl"]
-Order = [:type, :function]
+Pages = ["Matrix.jl"]
+Order = [:function]
 ```
 
-## Abstract Interface - CPU Specialization
+## Matrix Action
 ```@autodocs
 Modules = [FiniteElementContainers]
-Pages = ["CPUGeneral.jl"]
-Order = [:type, :function]
+Pages = ["MatrixAction.jl"]
+Order = [:function]
 ```
 
+## Scalar
+```@autodocs
+Modules = [FiniteElementContainers]
+Pages = ["Scalar.jl"]
+Order = [:function]
+```
 
-## Abstract Interface - GPU Specialization
+## Vector
 ```@autodocs
 Modules = [FiniteElementContainers]
-Pages = ["GPUGeneral.jl"]
-Order = [:type, :function]
+Pages = ["Vector.jl"]
+Order = [:function]
 ```
 
-## SparsityPattern
+## Abstract Interface
 ```@autodocs
 Modules = [FiniteElementContainers]
-Pages = ["SparsityPattern.jl"]
+Pages = ["Assemblers.jl"]
 Order = [:type, :function]
 ```
 
@@ -42,3 +48,10 @@ Modules = [FiniteElementContainers]
 Pages = ["SparseMatrixAssembler.jl"]
 Order = [:type, :function]
 ```
+
+## SparsityPattern
+```@autodocs
+Modules = [FiniteElementContainers]
+Pages = ["SparsityPattern.jl"]
+Order = [:type, :function]
+```

docs/src/parameters.md

@@ -0,0 +1,6 @@
+# Parameters
+```@autodocs
+Modules = [FiniteElementContainers]
+Pages = ["Parameters.jl"]
+Order = [:type, :function]
+```

docs/src/physics.md

@@ -1 +1,6 @@
-# Physics
+# Physics
+```@autodocs
+Modules = [FiniteElementContainers]
+Pages = ["Physics.jl"]
+Order = [:type, :function]
+```

src/assemblers/Assemblers.jl

@@ -175,30 +175,6 @@ function update_field!(U, asm::AbstractAssembler, Uu, Ubc)
   return nothing
 end
 
-"""
-$(TYPEDSIGNATURES)
-"""
-function _zero_storage(asm::AbstractAssembler, ::Val{:energy})
-  # fill!(asm.residual_storage.vals, zero(eltype(asm.residual_storage.vals)))
-  for val in values(asm.scalar_quadarature_storage)
-    fill!(val, zero(eltype(val)))
-  end
-end
-
-"""
-$(TYPEDSIGNATURES)
-"""
-function _zero_storage(asm::AbstractAssembler, ::Val{:residual})
-  fill!(asm.residual_storage.vals, zero(eltype(asm.residual_storage.vals)))
-end
-
-"""
-$(TYPEDSIGNATURES)
-"""
-function _zero_storage(asm::AbstractAssembler, ::Val{:stiffness_action})
-  fill!(asm.stiffness_action_storage.vals, zero(eltype(asm.stiffness_action_storage.vals)))
-end
-
 # some utilities
 include("SparsityPattern.jl")
 
@@ -211,4 +187,3 @@ include("MatrixAction.jl")
 include("MatrixAndVector.jl")
 include("Scalar.jl")
 include("Vector.jl")
-# include("ResidualAndStiffness.jl")

src/assemblers/Matrix.jl

@@ -1,6 +1,6 @@
 # Top level methods
-function assemble!(assembler, Uu, p, val_sym::Val{:mass}, ::Type{H1Field})
-  _zero_storage(assembler, val_sym)
+function assemble!(assembler, Uu, p, ::Val{:mass}, ::Type{H1Field})
+  fill!(assembler.mass_storage, zero(eltype(assembler.mass_storage)))
   fspace = assembler.dof.H1_vars[1].fspace
   t = current_time(p.times)
   dt = time_step(p.times)
@@ -23,8 +23,8 @@
   end
 end
 
-function assemble!(assembler, Uu, p, val_sym::Val{:stiffness}, ::Type{H1Field})
-  _zero_storage(assembler, val_sym)
+function assemble!(assembler, Uu, p, ::Val{:stiffness}, ::Type{H1Field})
+  fill!(assembler.stiffness_storage, zero(eltype(assembler.stiffness_storage)))
   fspace = assembler.dof.H1_vars[1].fspace
   t = current_time(p.times)
   dt = time_step(p.times)

src/assemblers/MatrixAction.jl

@@ -1,15 +1,15 @@
 # Top level method
-assemble!(assembler, Uu, p, Vu, ::Val{:hvp}, type::Type{H1Field}) = 
-assemble!(assembler, Uu, p, Vu, Val{:stiffness_action}(), type)
+assemble!(assembler, Uu, p, Vu, val::Val{:hvp}, type::Type{H1Field}) = 
+assemble!(assembler, Uu, p, Vu, val, type)
 
 # TODO below isn't exactly right...
 # we're going to need some additional scratch storage for 
 # the full field of Vu
-function assemble!(assembler, Uu, p, Vu, val_sym::Val{:stiffness_action}, ::Type{H1Field})
+function assemble!(assembler, Uu, p, Vu, ::Val{:stiffness_action}, ::Type{H1Field})
+  fill!(assembler.stiffness_action_storage, zero(eltype(assembler.stiffness_action_storage)))
   fspace = assembler.dof.H1_vars[1].fspace
   t = current_time(p.times)
   Δt = time_step(p.times)
-  _zero_storage(assembler, val_sym)
   update_bcs!(p)
   update_field_unknowns!(p.h1_field, assembler.dof, Uu)
   update_field_unknowns!(p.h1_hvp, assembler.dof, Vu)
@@ -22,7 +22,7 @@
     ref_fe = values(fspace.ref_fes)[b]
     backend = _check_backends(assembler, p.h1_field, p.h1_coords, state_old, state_new, conns)
     _assemble_block_matrix_action!(
-      assembler.residual_storage, block_physics, ref_fe, 
+      assembler.stiffness_action_storage, block_physics, ref_fe, 
       p.h1_field, p.h1_hvp, p.h1_coords, state_old, state_new, props, t, Δt,
       conns, b, stiffness,
       backend

src/assemblers/MatrixAndVector.jl

@@ -1,9 +1,10 @@
 # Top level method
 function assemble!(assembler, Uu, p, val_sym::Val{:residual_and_stiffness}, ::Type{H1Field})
+  fill!(assembler.residual_storage, zero(eltype(assembler.residual_storage)))
+  fill!(assembler.stiffness_storage, zero(eltype(assembler.stiffness_storage)))
   fspace = assembler.dof.H1_vars[1].fspace
   t = current_time(p.times)
   dt = time_step(p.times)
-  _zero_storage(assembler, val_sym)
   update_bcs!(p)
   update_field_unknowns!(p.h1_field, assembler.dof, Uu)
   for (b, (conns, block_physics, state_old, state_new, props)) in enumerate(zip(
@@ -150,13 +151,13 @@ KA.@kernel function _assemble_block_matrix_and_vector_kernel!(
   end
 end
 
-"""
-$(TYPEDSIGNATURES)
-Assembly method for a block labelled as block_id. This is a GPU agnostic implementation
-using KernelAbstractions and Atomix for eliminating race conditions
+# """
+# $(TYPEDSIGNATURES)
+# Assembly method for a block labelled as block_id. This is a GPU agnostic implementation
+# using KernelAbstractions and Atomix for eliminating race conditions
 
-TODO add state variables and physics properties
-"""
+# TODO add state variables and physics properties
+# """
 function _assemble_block_matrix_and_vector!(
   residual_field::F1, stiffness_field::F2, pattern::Patt, 
   physics::Phys, ref_fe::R,

src/assemblers/Scalar.jl

@@ -1,8 +1,7 @@
-function assemble!(assembler, Uu, p, val_sym::Val{:energy}, ::Type{H1Field})
+function assemble!(assembler, Uu, p, ::Val{:energy}, ::Type{H1Field})
   fspace = assembler.dof.H1_vars[1].fspace
   t = current_time(p.times)
   Δt = time_step(p.times)
-  _zero_storage(assembler, val_sym)
   update_bcs!(p)
   update_field_unknowns!(p.h1_field, assembler.dof, Uu)
   for (b, (field, conns, block_physics, state_old, state_new, props)) in enumerate(zip(
@@ -22,7 +21,7 @@
     )
   end
 
-
+  # TODO need to eventually sum that all up somewhere
 end
 
 # CPU Implementation

src/assemblers/SparseMatrixAssembler.jl

@@ -87,13 +87,6 @@ function Base.show(io::IO, asm::SparseMatrixAssembler)
   println(io, "  ", asm.dof)
 end
 
-# below methods used to make type stable dispatch for _assemble_element! resuse for
-# stiffness/mass/damping matrix value storage
-_get_storage(asm::SparseMatrixAssembler, ::Val{:damping}) = asm.damping_storage
-_get_storage(asm::SparseMatrixAssembler, ::Val{:mass}) = asm.mass_storage
-_get_storage(asm::SparseMatrixAssembler, ::Val{:stiffness}) = asm.stiffness_storage
-
-# TODO add symbol to interface for name of storage array to assemble into
 """
 $(TYPEDSIGNATURES)
 Specialization of of ```_assemble_element!``` for ```SparseMatrixAssembler```.
@@ -251,16 +244,3 @@ function _update_dofs!(assembler::SparseMatrixAssembler, dirichlet_dofs::T) wher
 
   return nothing
 end
-
-function _zero_storage(asm::SparseMatrixAssembler, ::Val{:mass})
-  fill!(asm.mass_storage, zero(eltype(asm.mass_storage)))
-end
-
-function _zero_storage(asm::SparseMatrixAssembler, ::Val{:residual_and_stiffness})
-  _zero_storage(asm, Val{:residual}())
-  fill!(asm.stiffness_storage, zero(eltype(asm.stiffness_storage)))
-end
-
-function _zero_storage(asm::SparseMatrixAssembler, ::Val{:stiffness})
-  fill!(asm.stiffness_storage, zero(eltype(asm.stiffness_storage)))
-end

src/assemblers/Vector.jl

@@ -1,13 +1,13 @@
 # Top level method
 
-assemble!(assembler, Uu, p, ::Val{:gradient}, type::Type{H1Field}) = 
-assemble!(assembler, Uu, p, Val{:residual}(), type)
+assemble!(assembler, Uu, p, val::Val{:gradient}, type::Type{H1Field}) = 
+assemble!(assembler, Uu, p, val, type)
 
-function assemble!(assembler, Uu, p, val_sym::Val{:residual}, ::Type{H1Field})
+function assemble!(assembler, Uu, p, ::Val{:residual}, ::Type{H1Field})
+  fill!(assembler.residual_storage, zero(eltype(assembler.residual_storage)))
   fspace = assembler.dof.H1_vars[1].fspace
   t = current_time(p.times)
   Δt = time_step(p.times)
-  _zero_storage(assembler, val_sym)
   update_bcs!(p)
   update_field_unknowns!(p.h1_field, assembler.dof, Uu)
   for (b, (conns, block_physics, state_old, state_new, props)) in enumerate(zip(

src/fields/Fields.jl

@@ -17,6 +17,12 @@ $(TYPEDSIGNATURES)
 """
 Base.eltype(::Type{AbstractField{T, N, NF, Vals, SymIDMap}}) where {T, N, NF, Vals, SymIDMap} = T
 
+"""
+$(TYPEDSIGNATURES)
+"""
+Base.fill!(field::AbstractField{T, N, NF, V, S}, v::T) where {T, N, NF, V, S} = 
+fill!(field.vals, v)
+
 """
 $(TYPEDSIGNATURES)
 """