tutorial notebook working again

src/problems.jl

@@ -5,141 +5,22 @@ abstract Problem
 abstract BoundaryProblem <: Problem
 abstract FieldProblem <: Problem
 
-get_equations(pr::Problem) = pr.equations
-
-function get_dimension(pr::Type{Problem})
-    throw("Unable to determine problem dimension for problem $pr")
+function get_equations(problem::Problem)
+    problem.equations
 end
 
-function get_equation(pr::Type{Problem}, el::Type{Element})
-    throw("Could not find corresponding equation for element $el in problem $pr")
+function get_unknown_field_dimension(problem::Problem)
+    problem.unknown_field_dimension
 end
 
-"""
-Add new element to problem
-"""
-function add_element!(problem::Problem, element::Element)
-    equation = get_equation(typeof(problem), typeof(element))
-    push!(problem.equations, equation(element))
+function get_unknown_field_name(problem::Problem)
+    problem.unknown_field_name
 end
+
+""" Add new element to problem. """
 function Base.push!(problem::Problem, element::Element)
-    equation = get_equation(typeof(problem), typeof(element))
-    push!(problem.equations, equation(element))
-end
-
-"""
-Return total number of basis functions in problem
-"""
-function get_number_of_basis_functions(pr::Problem)
-    conn = Int[]
-    for eq in get_equations(pr)
-        append!(conn, get_connectivity(eq))
-    end
-    length(unique(conn))
-end
-
-"""
-Problem matrix size dimension
-"""
-function get_matrix_dimension(pr::Problem)
-    get_dimension(typeof(pr))*get_number_of_basis_functions(pr)
-end
-
-"""
-Assign global dofs for element. This doesn't do any reordering.
-"""
-function set_global_dofs!(pr::Problem)
-    #ndim = get_dimension(pr)*get_number_of_basis_functions(pr)
-    #ndim = get_matrix_dimension(pr)
-    dim = get_dimension(typeof(pr))
-    nconn = get_number_of_basis_functions(pr)
-    ndim = dim*nconn
-    Logging.debug("Problem (matrix) dimension: $ndim")
-    gdofs = reshape(collect(1:ndim), dim, nconn)
-    for eq in get_equations(pr)
-        lconn = get_connectivity(eq)
-        gconn = gdofs[:, lconn][:]
-        set_global_dofs!(eq, gconn)
-    end
-end
-
-""" Return unique list of connectivity (i.e. node ids). """
-function get_connectivity(problem::Problem)
-    connectivity = Int[]
-    for equation in get_equations(problem)
-        element = get_element(equation)
-        append!(connectivity, get_connectivity(element))
-    end
-    connectivity = unique(connectivity)
-    return connectivity
-end
-
-"""
-Calculate global dofs for equations, maybe using some bandwidth
-minimizing or fill reducing algorithm
-"""
-function calculate_global_dofs(pr::Problem)
-    conn = get_connectivity(pr)
-    dim = get_dimension(typeof(pr))
-    ndofs = dim*length(conn)
-    Logging.debug("total dofs: $ndofs")
-
-    mconn = maximum(conn)
-    gdofs = reshape(collect(1:mconn), dim, mconn)
-    dofmap = Dict{Int64, Array{Int64, 1}}()
-    for (i, c) in enumerate(conn)
-        dofmap[c] = gdofs[:, i]
-    end
-    return dofmap
-end
-
-"""
-Assign global dofs for equations.
-"""
-function assign_global_dofs!(pr::Problem, dofmap)
-    for eq in get_equations(pr)
-        el = get_element(eq)
-        c = get_connectivity(el)
-        #gdofs = [dofmap[ci] for ci in c]
-        gdofs = Int64[]
-        for ci in c
-            append!(gdofs, dofmap[ci])
-        end
-        set_global_dofs!(eq, gdofs)
-    end
-end
-
-function get_lhs(pr::Problem, t::Float64)
-    I = Int64[]
-    J = Int64[]
-    V = Float64[]
-    dim = get_dimension(typeof(pr))
-    for eq in filter(has_lhs, get_equations(pr))
-        dofs = get_global_dofs(eq)
-        lhs = integrate_lhs(eq, t)
-        for (li, i) in enumerate(dofs)
-            for (lj, j) in enumerate(dofs)
-                push!(I, i)
-                push!(J, j)
-                push!(V, lhs[li, lj])
-            end
-        end
-    end
-    return I, J, V
-end
-
-function get_rhs(pr::Problem, t::Float64)
-    I = Int64[]
-    V = Float64[]
-    dim = get_dimension(typeof(pr))
-    for eq in filter(has_rhs, get_equations(pr))
-        dofs = get_global_dofs(eq)
-        rhs = integrate_rhs(eq, t)
-        for (li, i) in enumerate(dofs)
-            push!(I, i)
-            push!(V, rhs[li])
-        end
-    end
-    return I, V
+    element_type = typeof(element)
+    equation_type = problem.element_mapping[element_type]
+    push!(problem.equations, equation_type(element))
 end