completely remove submodule structure

- there is only a single module now `WavePropBase` where everything resides
- remove the clumsy `interface` idea
- nothing is exported. You must now `import WavePropBase` and manually control what you want to use
- adapt tests and code accordingly
- small cleanups

Author: maltezfaria

Project.toml

@@ -6,7 +6,6 @@ version = "0.1.4"
 [deps]
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-OrderedCollections = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
@@ -15,7 +14,6 @@ Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 
 [compat]
 AbstractTrees = "0.3"
-OrderedCollections = "1"
 RecipesBase = "1.1"
 Requires = "1"
 StaticArrays = "1.2"

src/Geometry/Geometry.jl

@@ -1,71 +1,13 @@
-"""
-    module Geometry
+#=
 
-Module defining basic geometrical concepts.
-"""
-module Geometry
+Definition of basic geometrical concepts.
 
-import Base: ==, length, in, iterate, getindex, lastindex, isempty, eltype, keys
-import Base: union, setdiff, intersect, issubset
+=#
 
-using StaticArrays
-using LinearAlgebra
-using OrderedCollections
-using AbstractTrees
-using RecipesBase
-using Printf
-using Statistics:median
-
-using WavePropBase
-using WavePropBase.Utils
-
-WavePropBase.@import_interface
+# import Base: ==, length, in, iterate, getindex, lastindex, isempty, eltype, keys
+# import Base: union, setdiff, intersect, issubset
 
 include("point.jl")
 include("referenceshapes.jl")
 include("entities.jl")
 include("domain.jl")
-
-export
-    # abstract types
-    AbstractReferenceShape,
-    AbstractEntity,
-    AbstractParametricBody,
-    # types
-    ElementaryEntity,
-    ParametricEntity,
-    ParametricCurve,
-    Domain,
-    ReferencePoint,
-    ReferenceLine,
-    ReferenceTriangle,
-    ReferenceTetrahedron,
-    ReferenceSquare,
-    ReferenceHyperCube,
-    Point2D,
-    Point3D,
-    # functions
-    clear_entities!,
-    entities,
-    tag,
-    key,
-    assertequaldim,
-    boundary,
-    skeleton,
-    internal_boundary,
-    external_boundary,
-    measure,
-    vertices,
-    line,
-    new_tag,
-    global_add_entity!,
-    index_range,
-    parent,
-    container,
-    loc2glob,
-    points,
-    # global variables
-    TAGS,
-    ENTITIES
-
-end # module

src/Geometry/domain.jl

@@ -153,7 +153,7 @@ function Base.issubset(Ω1::Domain, Ω2::Domain)
 end
 
 """
-    boundary(Ω)
+    boundary(Ω::Domain)
 
 Return a domain comprising the external boundary of Ω.
 

src/Geometry/entities.jl

@@ -22,6 +22,17 @@ Integer tag used to idetify geometrical entities.
 """
 tag(e::AbstractEntity) = e.tag
 
+"""
+    geometric_dimension(x::AbstractEntity)
+    geometric_dimension(Ω::Domain)
+
+Number of degrees of freedom necessary to locally represent the geometrical
+object. For example, lines have geometric dimension of 1 (whether in `ℝ²` or in
+`ℝ³`), while surfaces have geometric dimension of 2.
+
+When the argument is a `Domain`, return the largest geometric dimension
+encoutered.
+"""
 geometric_dimension(e::AbstractEntity) = e.dim
 
 boundary(e::AbstractEntity) = e.boundary
@@ -59,9 +70,16 @@ Base.hash(ent::AbstractEntity,h::UInt)= hash((geometric_dimension(ent),abs(tag(e
 function normal(ent::AbstractEntity, u)
     s = tag(ent) |> sign
     jac::SMatrix = jacobian(ent, u)
-    s*normal(jac)
+    s*_normal(jac)
 end
-function normal(jac::SMatrix{N,M}) where {N,M}
+
+"""
+    _normal(jac::SMatrix{M,N})
+
+Given a an `M` by `N` matrix representing the jacobian of a codimension one
+object, compute the normal vector.
+"""
+function _normal(jac::SMatrix{N,M}) where {N,M}
     msg = "computing the normal vector requires the element to be of co-dimension one."
     @assert (N - M == 1) msg
     if M == 1 # a line in 2d

src/Geometry/referenceshapes.jl

@@ -11,8 +11,20 @@ examples of concrete subtypes.
 """
 abstract type AbstractReferenceShape{N} end
 
+"""
+    ambient_dimension(x)
+
+Dimension of the ambient space where `x` lives. For geometrical objects this can
+differ from its [`geometric_dimension`](@ref); for example a triangle in `ℝ³` has
+ambient dimension `3` but geometric dimension `2`, while a curve in `ℝ³` has
+ambient dimension 3 but geometric dimension 1.
+"""
 ambient_dimension(::SType{<:AbstractReferenceShape{N}}) where {N}    = N
+
+
 geometric_dimension(::SType{<:AbstractReferenceShape{N}}) where {N}  = N
+
+
 dimension(::SType{<:AbstractReferenceShape{N}}) where {N}  = N
 
 """

src/IO/IO.jl

@@ -1,29 +1 @@
-module IO
-
-using StaticArrays
-using Printf
-using RecipesBase
-using OrderedCollections
-using Requires # for conditional loading of vtkIO
-
-using WavePropBase
-using WavePropBase.Utils
-using WavePropBase.Geometry
-using WavePropBase.Trees
-using WavePropBase.Integration
-using WavePropBase.Interpolation
-using WavePropBase.Mesh
-
-WavePropBase.@import_interface
-
 include("plotsIO.jl")
-
-function __init__()
-    # if WriteVTK is available, include vtkIO
-    @require WriteVTK="64499a7a-5c06-52f2-abe2-ccb03c286192" begin
-        @info "including vtkIO.jl from WavePropBase/IO"
-        include("vtkIO.jl")
-    end
-end
-
-end # module

src/IO/vtkIO.jl

@@ -94,7 +94,7 @@ function _vtk_cells(mesh::GenericMesh)
     # Loop on `AbstractElement`
     for (E,tags) in elements(mesh)
         # Export only the cells of the largest geometrical dimension
-        if geometric_dimension(E) == ambient_dimension(mesh)
+        if domain_dimension(E) == ambient_dimension(mesh)
             append!(cells,  _vtk_cells(tags, E))
         end
     end
@@ -104,7 +104,7 @@ end
 """
     const etype_to_vtk_cell_type
 
-OrderedDictionary mapping internal element types to a tuple containing:
+Dictionary mapping internal element types to a tuple containing:
     - the corresponding `WriteVTK` cell types (following the convention
     chosen by `VTK`, see below);
     - the indices in the `elements` column that defines the element.
@@ -130,7 +130,7 @@ See VTK specification [Fig. 2] on
 - VTK_WEDGE (=13)
 - VTK_PYRAMID (=14)
 """
-const etype_to_vtk_cell_type = OrderedDict(
+const etype_to_vtk_cell_type = Dict(
     SVector{3,Float64} => (VTKCellTypes.VTK_VERTEX, collect(1:1)),
     LagrangeLine{2,SVector{3,Float64}} => (VTKCellTypes.VTK_LINE, collect(1:2)),
     LagrangeTriangle{3,SVector{2,Float64}} => (VTKCellTypes.VTK_TRIANGLE, collect(1:3)),

src/Integration/Integration.jl

@@ -1,59 +1,11 @@
-"""
-    module Integration
-
+#=
 Methods for integrating over instances of [`AbstractReferenceShape`](@ref).
 
 Besides some standard quadrature rules used to integrate smooth functions, it also defines
 singular integration routines useful for (weakly) singular integrands.
-"""
-module Integration
-
-using StaticArrays
-using LinearAlgebra
-
-using WavePropBase.Utils
-using WavePropBase.Geometry
-using WavePropBase.Interpolation
-
-# import all methods in WavePropBase.INTERFACE_METHODS
-using WavePropBase
-WavePropBase.@import_interface
-
-export
-    # abstract types
-    AbstractQuadratureRule,
-    AbstractSingularityHandler,
-    # types
-    Gauss,
-    Trapezoidal,
-    TrapezoidalOpen,
-    Fejer,
-    TensorProductQuadrature,
-    Kress,
-    KressR,
-    KressP,
-    IMT,
-    Duffy,
-    SingularQuadratureRule,
-    CustomQuadratureRule,
-    CustomLineQuadratureRule,
-    CustomTriangleQuadratureRule,
-    CustomSquareQuadratureRule,
-    CustomTetrahedronQuadratureRule,
-    # functions
-    integrate,
-    qnodes,
-    qweights,
-    qnormals,
-    integration_measure,
-    qrule_for_reference_shape,
-    singular_weights,
-    singular_quadrature,
-    TensorProductSingularityHandler
+=#
 
 include("quadrulestables.jl")
 include("quadrule.jl")
 include("singularityhandler.jl")
 include("singularquadrule.jl")
-
-end

src/Integration/quadrule.jl

@@ -12,6 +12,11 @@ following methods:
 """
 abstract type AbstractQuadratureRule{D} end
 
+"""
+    domain(f)
+
+Given a function-like object `f: Ω → R`, return `Ω`.
+"""
 domain(q::AbstractQuadratureRule{D}) where {D} = D()
 
 """

src/Integration/singularityhandler.jl

@@ -18,6 +18,12 @@ end
 IMT(;a=1,p=1) = IMT{a,p}()
 
 domain(::IMT) = ReferenceLine()
+
+"""
+    image(f)
+
+The a function-like object `f: Ω → R`, return `R`.
+"""
 image(::IMT)  = ReferenceLine()
 
 function (f::IMT{A,P})(x) where {A,P}