update docs for new package structure

Author: maltezfaria

docs/make.jl

@@ -15,13 +15,13 @@ makedocs(;
     ),
     pages=[
         "WavePropBase" => "index.md",
-        "Utils module" => "utils.md",
-        "Geometry module" => "geometry.md",
-        "Interpolation module" => "interpolation.md",
-        "Integration module" => "integration.md",
-        "Mesh module" => "mesh.md",
-        "Trees module" => "trees.md",
-        "IO module" => "io.md",
+        "Utils" => "utils.md",
+        "Geometry" => "geometry.md",
+        "Interpolation" => "interpolation.md",
+        "Integration" => "integration.md",
+        "Meshes" => "mesh.md",
+        "Trees" => "trees.md",
+        "IO" => "io.md",
         "References" => "references.md"
     ],
 )

docs/src/geometry.md

@@ -1,9 +1,8 @@
-# [Geometry module](@id geometry-section)
+# [Geometry](@id geometry-section)
 
 ```@meta
-CurrentModule = WavePropBase.Geometry
+CurrentModule = WavePropBase
 ```
-
 ## Overview
 
 The `Geometry` module is of fundamental importance as it defines the interface
@@ -86,15 +85,9 @@ Furthremore, domains can be used to index parts of a mesh, as described in the
 The `AbstractReferenceShape{N}` type describes singleton types representing
 (fixed) geometrical shapes in `N` dimensions. Concrete subtypes include
 [`ReferenceLine`](@ref), [`ReferenceTriangle`](@ref), [`ReferenceSquare`](@ref),
-and the [`ReferenceTetrahedron`](@ref). 
+and the [`ReferenceTetrahedron`](@ref).
 
 Various interpolation and integration routines can then be efficiently defined
 on these singleton types, and more complex interpolation/integration over more
 complex elements can be carried out by combining the routines on the reference
 element with a parametrization of the complex element.
-
-## Index
-
-```@index
-Modules = [Geometry]
-```

docs/src/index.md

@@ -14,17 +14,10 @@ quadratures, etc. It is essentially a factorization of code that was being
 duplicated across different packages. *Unless you are developing a package, there
 is little reason for you to depend directly on `WavePropBase`.*
 
-## Interface
+## Package structure
 
-The methods which are to be extended by other packages are defined at
-the top-level module (`WavePropBase`), and are grouped for convenience in the
-global variable [`INTERFACE`](@ref). You can automatically import/export all
-the interface methods using [`@import_interface`](@ref) and
-[`@export_interface`](@ref).
-
-## Submodules
-
-Most of the functionality has been organized inside the following sub-modules:
+The package consists of a single module, and has no exported structures. The
+code has been physically organized into the following subfolders:
 
 - [Utils](@ref utils-section)
 - [Geometry](@ref geometry-section)
@@ -34,9 +27,6 @@ Most of the functionality has been organized inside the following sub-modules:
 - [Mesh](@ref mesh-section)
 - [IO](@ref io-section)
 
-Refer to each module's documentation for further information on how to use them,
-as well as to an index of their methods/structures.
-
 ## Index
 
 ```@index

docs/src/integration.md

@@ -1,21 +1,20 @@
 # [Integration module](@id integration-section)
 
+
+```@meta
+CurrentModule = WavePropBase
+```
+
 ## Overview
 
 The `Integration` module provides various quadrature rules and routines for
-integrating functions defined over [`AbstractReferenceShape`](@ref
-Geometry.AbstractReferenceShape)s. Quadrature rules are expected to inherit from
+integrating functions defined over [`AbstractReferenceShape`](@ref AbstractReferenceShape)s. Quadrature rules are expected to inherit from
 the `AbstractQuadratureRule{D}`, which describes a set of nodes and weights used
 to integrate a function over a reference domain `D<:AbstractReferenceShape`.
 Subtypes of `AbstractQuadratureRule` should implement at least
 `(::AbstractQuadratureRule)()` returning the nodes and weights.
 
-The
-`Integration` module defines various quadrature rules such as
-
-```@index
-Modules = [WavePropBase.Integration]
-```
+The `Integration` module defines various quadrature rules such as ...
 
 ## Regular integration rules
 

docs/src/interpolation.md

@@ -1,4 +1,4 @@
-# [Interpolation module](@id interpolation-section)
+# [Interpolation](@id interpolation-section)
 
 ```@meta
 CurrentModule = WavePropBase
@@ -8,15 +8,14 @@ CurrentModule = WavePropBase
 
 The `Interpolation` module defines an interface for talking about polynomial
 spaces and interpolation. The central concept of this module is that of an
-[`AbstractElement{D,T}`](@ref Interpolation.AbstractElement), which maps points
-on a reference domain (of type [`<:AbstractReferenceShape`](@ref
-Geometry.AbstractReferenceShape)) to values of type `T`. The `AbstractElement`
+[`AbstractElement{D,T}`](@ref AbstractElement), which maps points
+on a reference domain (of type [`<:AbstractReferenceShape`](@ref AbstractReferenceShape)) to values of type `T`. The `AbstractElement`
 interface expects the methods `(el::AbstractElement)(u)`, which evaluates the
 underlying interpolant at the (reference) coordinate `u`, and `jacobian(el,u)`,
 which computes the jacobian at the (reference) coordinate `u`.
 
 `AbstractElement`s are commonly used to describe functions over
-[`AbstractReferenceShape`](@ref Geometry.AbstractReferenceShape)s, and such
+[`AbstractReferenceShape`](@ref AbstractReferenceShape)s, and such
 functions can in turn be used to describe more complex geometrical shapes used
 e.g. in a mesh. By composing a function representation on a reference element
 with the representation of the element itself as a map from the reference
@@ -34,7 +33,7 @@ package).
 
 One of the simplest `AbstractElement`s is the `LagrangeElement{D,T,Np}`, which
 defines a polynomial mapping the `Np` reference nodes on `D` to `Np` values of
-type `T`. The [`reference_nodes`](@ref Interpolation.reference_nodes) depend
+type `T`. The [`reference_nodes`](@ref reference_nodes) depend
 only on `D` and `Np` (and therefore on the type of the element). We use the same
 convention as *Gmsh* to define the order of the reference nodes on the various
 reference shapes; see [node
@@ -49,7 +48,7 @@ be created using:
 using WavePropBase, Plots
 plotlyjs() # hide
 pts = (1,1),(2,2),(1.5,3)
-el  = Interpolation.LagrangeTriangle(pts)
+el  = WavePropBase.LagrangeTriangle(pts)
 plot(el)
 savefig("el1.png")
 ```
@@ -61,27 +60,22 @@ parametrization and the jacobian at any point on the reference element (not just
 the reference nodes):
 
 ```@example triangle-element
-u = Geometry.Point2D(0.25,0.25)
-@show el(u), jacobian(el,u)
+u = WavePropBase.Point2D(0.25,0.25)
+@show el(u), WavePropBase.jacobian(el,u)
 ```
 
 If the triangle is instead in three dimensions, it suffices to pass
 three-dimensional points:
 
 ```@example triangle-element
 pts = (1,1,0),(2,2,1),(1.5,3,1)
-el  = Interpolation.LagrangeTriangle(pts)
+el  = WavePropBase.LagrangeTriangle(pts)
 plot(el)
 savefig("el2.png")
 ```
 
 ![triangular element](el2.png)
 
 Very similar constructs can be used to work higher order (curved) triangles, or
-with other `LagrangeElements` such as [`LagrangeSquare`](@ref
-Interpolation.LagrangeSquare) or [`LagrangeTetrahedron`](@ref
-Interpolation.LagrangeTetrahedron); see their docstrings for more details.
-
-```@index
-Modules = [WavePropBase.Interpolation]
-```
+with other `LagrangeElements` such as [`LagrangeSquare`](@ref LagrangeSquare) or
+[`LagrangeTetrahedron`](@ref); see their docstrings for more details.

docs/src/io.md

@@ -1,14 +1,12 @@
 # [IO module](@id io-section)
 
+```@meta
+CurrentModule = WavePropBase
+```
+
 ## Overview
 
 The `IO` module provides various *recipes* for `Plots.jl`, as well functionality
 to export meshes and solutions to `.vtk` format using `WriteVTK`. Note that the
 `vtkIO.jl` file is only loaded if `WriteVTK` is available (i.e. you must type
 `using WriteVTK` for the file to be loaded).
-
-## Index
-
-```@index
-Modules = [WavePropBase.IO]
-```

docs/src/mesh.md

@@ -1,6 +1,10 @@
-# [Mesh module](@id mesh-section)
+# [Mesh](@id mesh-section)
 
-## Overview 
+```@meta
+CurrentModule = WavePropBase
+```
+
+## Overview
 
 ## Mesh structures
 
@@ -20,7 +24,3 @@ using GmshSDK
     #msh  = GmshSDK.meshgen(Ω)
 end
 ```
-
-```@index
-Modules = [WavePropBase.Mesh]
-```

docs/src/references.md

@@ -1,13 +1,5 @@
 # References
 
 ```@autodocs
-Modules = [ WavePropBase, 
-            WavePropBase.Utils, 
-            WavePropBase.Geometry, 
-            WavePropBase.Trees,
-            WavePropBase.Interpolation,
-            WavePropBase.Integration,
-            WavePropBase.Mesh,
-            WavePropBase.IO
-            ]
+Modules = [ WavePropBase ]
 ```

docs/src/trees.md

@@ -11,34 +11,34 @@ tree-like data structures. It relies on
 [AbstractTrees.jl](https://github.com/JuliaCollections/AbstractTrees.jl) for
 various utilities related to traversing trees and tree iterators.
 
-The module defines the concrete type [`ClusterTree`](@ref Trees.ClusterTree)
+The module defines the concrete type [`ClusterTree`](@ref ClusterTree)
 which can be used to partition elements of geometrical nature into a
 hierarchical structure according to an [`AbstractSplitter`](@ref
-Trees.AbstractSplitter). This structure is currently used by the
+AbstractSplitter). This structure is currently used by the
 [HMatrices.jl](https://github.com/WaveProp/HMatrices) and
 [IFGF.jl](https://github.com/WaveProp/IFGF).
 
 Tree-like data structures should inherit from [`AbstractTree`](@ref
-Trees.AbstractTree), and are expected to implement the `children` and `parent`
+AbstractTree), and are expected to implement the `children` and `parent`
 methods. Currently, one concrete implementation of [`AbstracTree`](@ref
-Trees.AbstractTree) is provided by `WavePropBase`: the [`ClusterTree`](@ref
-Trees.ClusterTree).
+AbstractTree) is provided by `WavePropBase`: the [`ClusterTree`](@ref
+ClusterTree).
 
 ## `ClusterTree`
 
-A [`ClusterTree{T,S,D}`](@ref Trees.ClusterTree) is a parametric type used to
+A [`ClusterTree{T,S,D}`](@ref ClusterTree) is a parametric type used to
 hierarchically cluster elements of type `T` into container of type `S`.
 Additionally, each node of the tree has a data field of type `D` (defaults to
-`Nothing`) that can be used to store additional node-specific information. The
+`Nothing`) that can be used to store additional node-specific information. The 
 elements contained in a given node can be retrieved using `elements(node)`,
 which returns an iterable collection of elements of type `T`. 
 
 To construct a `ClusterTree`, you must pass the elements and an
-[`AbstractSplitter`](@ref Trees.AbstractSplitter) implementing the desired
+[`AbstractSplitter`](@ref AbstractSplitter) implementing the desired
 splitting strategy and stopping criterion: concrete subtypes of
 `AbstractSplitter` should implement the
-[`should_split(clt,spl::AbstractSplitter)`](@ref Trees.should_split) and
-[`split!(clt,splt::AbstractSplitter)`](@ref Trees.split!) methods. Refer to the documentation
+[`should_split(clt,spl::AbstractSplitter)`](@ref should_split) and
+[`split!(clt,splt::AbstractSplitter)`](@ref split!) methods. Refer to the documentation
 of each concrete subtype of `AbstractSplitter` (you can type
 `subtypes(AbstractSplitter)` to see what they are) for more information about
 the available splitting strategies and parameters.
@@ -47,9 +47,9 @@ An example of how to construct a `ClusterTree` is shown below:
 
 ```@example cluster-tree
 using WavePropBase
-pts = rand(Geometry.Point2D,100)
-splitter = Trees.GeometricMinimalSplitter(nmax=5)
-clt = Trees.ClusterTree(pts,splitter)
+pts = rand(WavePropBase.Point2D,100)
+splitter = WavePropBase.CardinalitySplitter(nmax=5)
+clt = WavePropBase.ClusterTree(pts,splitter)
 ```
 
 `clt` now represents the root of the tree. To visualize `clt` as a node, you can
@@ -59,7 +59,7 @@ of `clt`, you can do:
 ```@example cluster-tree
 using Plots
 plotlyjs() # hide
-plot(WavePropBase.IO.PlotTree(),clt;predicate=Trees.isleaf)
+plot(WavePropBase.PlotTree(),clt;predicate=WavePropBase.isleaf)
 savefig("clt1.png")
 ```
 
@@ -68,16 +68,16 @@ savefig("clt1.png")
 Changing the clustering strategy is as simple as:
 
 ```@example cluster-tree
-splitter = Trees.DyadicSplitter(nmax=5)
-clt = Trees.ClusterTree(pts,splitter)
-plot(WavePropBase.IO.PlotTree(),clt)
+splitter = WavePropBase.DyadicSplitter(nmax=5)
+clt = WavePropBase.ClusterTree(pts,splitter)
+plot(WavePropBase.PlotTree(),clt)
 savefig("clt2.png")
 ```
 
 ![cluster tree](clt2.png)
 
 In the example above the elements were simply points, which were sorted into
-container of [`HyperRectangle`](@ref Interpolation.HyperRectangle) type according to
+container of [`HyperRectangle`](@ref HyperRectangle) type according to
 their coordinates. You can sort elements of other types as long as they
 implement the `center` method; for instance, you may build a `ClusterTree` of
 triangle elements as long as you extend the method `center` from `WavePropBase`
@@ -89,10 +89,5 @@ permuted internally so each node of the tree stores a contiguous subset of
 `ClusterTree` object. Passing the keyword argument `copy_elements=false` will
 skip the `deepcopy`, and mutate instead the `els` argument passed. The
 permutation of `els` performed during the tree construction can be recovered
-using [`loc2glob`](@ref Trees.loc2glob).
+using [`loc2glob`](@ref loc2glob).
 
-## Index
-
-```@index
-Modules = [WavePropBase.Trees]
-```

docs/src/utils.md

@@ -1,11 +1,8 @@
 # [Utils module](@id utils-section)
 
-The `Utils` module provides a place to define auxiliary/convenience
-functions and structures that do not naturally fit into the other modules. These
-functions/structures are indexed below:
-
-## Index
+```@meta
+CurrentModule = WavePropBase
+```
 
-```@index
-Modules = [WavePropBase.Utils]
-```
+The `Utils` module provides a place to define auxiliary/convenience
+functions and structures that do not naturally fit into the other modules.