Fix syntax to pass Lint test (#4)

Lint test pass now. No changes to functionality.

src/FEMBase.jl

@@ -3,6 +3,9 @@
 
 module FEMBase
 
+macro lintpragma(s)
+end
+
 import Base: getindex, setindex!, convert, length, size, isapprox,
              similar, start, first, next, done, last, endof, vec,
              ==, +, -, *, /, haskey, copy, push!, isempty, empty!,
@@ -31,19 +34,18 @@ include("elements_lagrange.jl")
 include("integrate.jl")
 include("problems.jl")
 include("assembly.jl")
+export assemble_prehook!, assemble_posthook!
 
 export FieldProblem, BoundaryProblem, Problem, Element, Assembly
 export Poi1, Seg2, Seg3, Tri3, Tri6, Tri7, Quad4, Quad8, Quad9,
        Tet4, Tet10, Pyr5, Wedge6, Wedge15, Hex8, Hex20, Hex27
-export update!, add_elements!, add!, get_gdofs, group_by_element_type,
+export add_elements!, add!, get_gdofs, group_by_element_type,
        get_unknown_field_name, get_unknown_field_dimension,
        get_integration_points, initialize!, assemble!
-export DCTI, DVTI, DCTV, DVTV, CCTI, CVTI, CCTV, CVTV
-export add_elements!
 export SparseMatrixCOO, SparseVectorCOO, Node, BasisInfo,
        IP, AbstractProblem, IntegrationPoint, AbstractField
 export is_field_problem, is_boundary_problem, get_elements,
-       get_connectivity, assemble_prehook!, assemble_posthook!,
+       get_connectivity,
        get_parent_field_name, get_reference_coordinates,
        get_assembly, get_nonzero_rows, get_nonzero_columns,
        eval_basis!, get_basis, get_dbasis, grad!,

src/assembly.jl

@@ -11,11 +11,9 @@ function isapprox(a1::Assembly, a2::Assembly)
     return T
 end
 
-function assemble_prehook!
-end
+function assemble_prehook!(::Problem, time) end
 
-function assemble_posthook!
-end
+function assemble_posthook!(::Problem, time) end
 
 function assemble!(problem::Problem, time=0.0; auto_initialize=true)
     if !isempty(problem.assembly)
@@ -34,17 +32,13 @@ function assemble!(problem::Problem, time=0.0; auto_initialize=true)
             end
         end
     end
-    if method_exists(assemble_prehook!, Tuple{typeof(problem), Float64})
-        assemble_prehook!(problem, time)
-    end
+    assemble_prehook!(problem, time)
     assemble!(get_assembly(problem), problem, get_elements(problem), time)
-    if method_exists(assemble_posthook!, Tuple{typeof(problem), Float64})
-        assemble_posthook!(problem, time)
-    end
+    assemble_posthook!(problem, time)
     return true
 end
 
-function assemble!{P}(assembly::Assembly, problem::Problem{P}, element::Element, time)
+function assemble!{P}(::Assembly, ::Problem{P}, element::Element, time)
     warn("One must define assemble! function for problem of type $P. Not doing anything.")
     return nothing
 end
@@ -70,7 +64,7 @@ function assemble_mass_matrix!(problem::Problem, time)
 end
 
 function assemble_mass_matrix!{Basis}(problem::Problem, elements::Vector{Element{Basis}}, time)
-    nnodes = length(Basis)
+    nnodes = length(first(elements))
     dim = get_unknown_field_dimension(problem)
     M = zeros(nnodes, nnodes)
     N = zeros(1, nnodes)

src/elements.jl

@@ -30,42 +30,51 @@ function Element{E<:AbstractBasis}(::Type{E}, connectivity::Vector{Int})
 end
 
 """
-    length(element::Element)
+    length(element)
 
-Return the number of nodes in element.
+Return the length of basis (number of nodes).
 """
-function length{B}(element::Element{B})
-    return length(B)
+function length(element::Element)
+    return length(element.properties)
 end
 
-function size{B}(element::Element{B})
-    return size(B)
+"""
+    size(element)
+
+Return the size of basis (dim, nnodes).
+"""
+function size(element::Element)
+    return size(element.properties)
 end
 
-function getindex(element::Element, field_name::AbstractString)
+function getindex(element::Element, field_name::String)
     return element.fields[field_name]
 end
 
 function setindex!{T<:AbstractField}(element::Element, data::T, field_name)
     element.fields[field_name] = data
 end
 
-function get_element_type{E}(element::Element{E})
+function get_element_type{E}(::Element{E})
     return E
 end
 
 function get_element_id{E}(element::Element{E})
     return element.id
 end
 
-function is_element_type{E}(element::Element{E}, element_type)
+function is_element_type{E}(::Element{E}, element_type)
     return E === element_type
 end
 
 function filter_by_element_type(element_type, elements)
     return Iterators.filter(element -> is_element_type(element, element_type), elements)
 end
 
+function get_connectivity(element::Element)
+    return element.connectivity
+end
+
 """
     group_by_element_type(elements::Vector{Element})
 
@@ -109,25 +118,51 @@ function (element::Element)(field_name::String)
     return element[field_name]
 end
 
-#""" Return a Field object from element and interpolate in time direction.
-#Examples
-#--------
-#>>> element = Element(Seg2, [1, 2])
-#>>> data1 = Dict(1 => 1.0, 2 => 2.0)
-#>>> data2 = Dict(1 => 2.0, 2 => 3.0)
-#>>> update!(element, "my field", 0.0 => data1, 1.0 => data2)
-#>>> element("my field", 0.5)
-#"""
-function (element::Element)(field_name::String, time::Float64)
+"""
+    interpolate(element, field_name, time)
+
+Interpolate field `field_name` from element at given `time`.
+
+# Example
+```
+element = Element(Seg2, [1, 2])
+data1 = Dict(1 => 1.0, 2 => 2.0)
+data2 = Dict(1 => 2.0, 2 => 3.0)
+update!(element, "my field", 0.0 => data1)
+update!(element, "my field", 1.0 => data2)
+interpolate(element, "my field", 0.5)
+
+# output
+
+(1.5, 2.5)
+
+```
+"""
+function interpolate(element::Element, field_name::String, time::Float64)
     field = element[field_name]
     result = interpolate(field, time)
     if isa(result, Dict)
-        return tuple((result[i] for i in get_connectivity(element))...)
+        connectivity = get_connectivity(element)
+        return tuple((result[i] for i in connectivity)...)
     else
         return result
     end
 end
 
+function get_basis{B}(element::Element{B}, ip, time)
+    T = typeof(first(ip))
+    N = zeros(T, 1, length(element))
+    eval_basis!(B, N, tuple(ip...))
+    return N
+end
+
+function get_dbasis{B}(element::Element{B}, ip, time)
+    T = typeof(first(ip))
+    dN = zeros(T, size(element)...)
+    eval_dbasis!(B, dN, tuple(ip...))
+    return dN
+end
+
 function (element::Element)(ip, time::Float64=0.0)
     return get_basis(element, ip, time)
 end
@@ -186,29 +221,33 @@ end
 
 function (element::Element)(field_name::String, ip, time::Float64)
     field = element[field_name]
-    return element(field, ip, time)
+    return interpolate(element, field, ip, time)
 end
 
-function (element::Element)(field::DCTI, ip, time::Float64)
+@lintpragma("Ignore unused ip")
+@lintpragma("Ignore unused element")
+function interpolate(element::Element, field::DCTI, ip, time::Float64)
     return field.data
 end
 
-function (element::Element)(field::DCTV, ip, time::Float64)
+function interpolate(element::Element, field::DCTV, ip, time::Float64)
     return interpolate(field, time)
 end
 
-function (element::Element)(field::CVTV, ip, time::Float64)
+function interpolate(element::Element, field::CVTV, ip, time::Float64)
     return field(ip, time)
 end
 
-function (element::Element){F<:AbstractField}(field::F, ip, time::Float64)
+function interpolate{F<:AbstractField}(element::Element, field::F, ip, time::Float64)
     field_ = interpolate(field, time)
     basis = element(ip, time)
     n = length(element)
     if isa(field_, Tuple)
         m = length(field_)
         if n != m
-            error("Error when trying to interpolate field $field at coords $ip and time $time: element length is $n and field length is $m, f = Nᵢfᵢ makes no sense!")
+            error("Error when trying to interpolate field $field at coords $ip ",
+                  "and time $time: element length is $n and field length is $m, ",
+                  "f = Nᵢfᵢ makes no sense!")
         end
         return sum(field_[i]*basis[i] for i=1:n)
     else
@@ -248,15 +287,11 @@ function haskey(element::Element, field_name)
     return haskey(element.fields, field_name)
 end
 
-function get_connectivity(element::Element)
-    return element.connectivity
-end
-
 function get_integration_points{E}(element::Element{E})
     # first time initialize default integration points
     if length(element.integration_points) == 0
         ips = get_integration_points(element.properties)
-        if E in (Poi1, Seg2, Seg3, NSeg)
+        if E in (Seg2, Seg3, NSeg)
             element.integration_points = [IP(i, w, (xi,)) for (i, (w, xi)) in enumerate(ips)]
         else
             element.integration_points = [IP(i, w, xi) for (i, (w, xi)) in enumerate(ips)]
@@ -270,7 +305,7 @@ of integration scheme mainly for mass matrix.
 """
 function get_integration_points{E}(element::Element{E}, change_order::Int)
     ips = get_integration_points(element.properties, Val{change_order})
-    if E in (Poi1, Seg2, Seg3, NSeg)
+    if E in (Seg2, Seg3, NSeg)
         return [IP(i, w, (xi,)) for (i, (w, xi)) in enumerate(ips)]
     else
         return [IP(i, w, xi) for (i, (w, xi)) in enumerate(ips)]
@@ -299,3 +334,10 @@ function inside{E}(element::Element{E}, X, time)
     xi = get_local_coordinates(element, X, time)
     return inside(E, xi)
 end
+
+## Convenience functions
+
+# element("displacement", 0.0)
+function (element::Element)(field_name::String, time::Float64)
+    return interpolate(element, field_name, time)
+end

src/elements_lagrange.jl

@@ -24,8 +24,9 @@ function get_integration_order(element::Poi1)
     return 1
 end
 
+@lintpragma("Ignore unused order")
 function get_integration_points(element::Poi1, order::Int64)
-    return [ (1.0, 0.0) ]
+    return [ (1.0, (0.0, )) ]
 end
 
 function size(::Type{Poi1})
@@ -40,20 +41,6 @@ function FEMBasis.get_reference_element_coordinates(::Type{Poi1})
     Vector{Float64}[[0.0]]
 end
 
-function get_basis{B}(element::Element{B}, ip, time)
-    T = typeof(first(ip))
-    N = zeros(T, 1, length(B))
-    eval_basis!(B, N, tuple(ip...))
-    return N
-end
-
-function get_dbasis{B}(element::Element{B}, ip, time)
-    T = typeof(first(ip))
-    dN = zeros(T, size(B)...)
-    eval_dbasis!(B, dN, tuple(ip...))
-    return dN
-end
-
 function inside(::Union{Type{Seg2}, Type{Seg3}, Type{Quad4}, Type{Quad8},
                         Type{Quad9}, Type{Pyr5}, Type{Hex8}, Type{Hex20},
                         Type{Hex27}}, xi)

src/fields.jl

@@ -41,16 +41,23 @@ function update!(f::DCTI, data)
     f.data = data
 end
 
+@lintpragma("Ignore unused time")
 """
-    interpolate(f::DCTI, args...)
+    interpolate(f::DCTI, time)
 
 Interpolate constant, time-invariant DCTI field in time direction. That is
 trivially only the data itself.
 """
-function interpolate(f::DCTI, args...)
+function interpolate(f::DCTI, time)
     return f.data
 end
 
+@lintpragma("Ignore unused i")
+"""
+    getindex(f::DCTI, i)
+
+Return `i`th item from constant field. Trivially the data itself.
+"""
 function getindex(f::DCTI, i::Int64)
     return f.data
 end
@@ -76,11 +83,12 @@ function update!(f::DVTI, data)
 end
 
 """
-    interpolate(f::DVTI, t)
+    interpolate(f::DVTI, time)
 
 Interpolate variable, time-invariant DVTI field in time direction.
 """
-function interpolate{N,T}(f::DVTI{N,T}, t)
+function interpolate{N,T}(f::DVTI{N,T}, time)
+    # time
     return f.data
 end
 
@@ -96,12 +104,12 @@ function interpolate(a, b)
 end
 
 """
-    interpolate(f::DVTI, t, B)
+    interpolate(f::DVTI, time, basis)
 
 Interpolate variable, time-invariant DVTI field in time and spatial direction.
 """
-function interpolate{N,T}(f::DVTI{N,T}, t, B)
-    return sum(f.data[i]*B[i] for i=1:N)
+function interpolate{N,T}(f::DVTI{N,T}, time, basis)
+    return interpolate(f.data, basis)
 end
 
 ## DISCRETE, CONSTANT, TIME VARIANT
@@ -203,8 +211,7 @@ function interpolate{N,T}(field::DVTV{N,T}, time)
             y0 = field.data[i-1].second
             y1 = field.data[i].second
             f = (time-t0)/(t1-t0)
-            new_data = tuple((f*y0[i] + (1-f)*y1[i] for i=1:N)...)
-            return new_data
+            return map((a,b) -> f*a + (1-f)*b, y0, y1)
         end
     end
 end
@@ -222,7 +229,7 @@ At last, find the correct bin and use linear interpolation
 """
 function interpolate{N,T}(field::DVTV{N,T}, time, basis)
     data = interpolate(field, time)
-    return sum(data[i]*basis[i] for i=1:N)
+    return interpolate(basis, data)
 end
 
 """

src/integrate.jl

@@ -52,5 +52,5 @@ end
 
 # All good codes needs a special case. Here we have it: Poi1
 function get_integration_points(element::Poi1)
-    [ (1.0, 0.0) ]
+    [ (1.0, (0.0,) ) ]
 end