Update to DelaunayTriangulation 1.0 (#53)

Author: DanielVandH

Project.toml

@@ -16,7 +16,7 @@ SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 [compat]
 ChunkSplitters = "0.1, 1.0, 2.0"
 CommonSolve = "0.2"
-DelaunayTriangulation = "0.7, 0.8"
+DelaunayTriangulation = "1.0"
 PreallocationTools = "0.4"
 PrecompileTools = "1.2"
 SciMLBase = "1, 2"

README.md

@@ -26,19 +26,19 @@ If this package doesn't suit what you need, you may like to review some of the o
  As a very quick demonstration, here is how we could solve a diffusion equation with Dirichlet boundary conditions on a square domain using the standard `FVMProblem` formulation; please see the docs for more information.
 
 ```julia
-using FiniteVolumeMethod, DelaunayTriangulation, CairoMakie, DifferentialEquations
+using FiniteVolumeMethod, DelaunayTriangulation, CairoMakie, OrdinaryDiffEq
 a, b, c, d = 0.0, 2.0, 0.0, 2.0
 nx, ny = 50, 50
 tri = triangulate_rectangle(a, b, c, d, nx, ny, single_boundary=true)
 mesh = FVMGeometry(tri)
 bc = (x, y, t, u, p) -> zero(u)
 BCs = BoundaryConditions(mesh, bc, Dirichlet)
 f = (x, y) -> y ≤ 1.0 ? 50.0 : 0.0
-initial_condition = [f(x, y) for (x, y) in each_point(tri)]
+initial_condition = [f(x, y) for (x, y) in DelaunayTriangulation.each_point(tri)]
 D = (x, y, t, u, p) -> 1 / 9
 final_time = 0.5
 prob = FVMProblem(mesh, BCs; diffusion_function=D, initial_condition, final_time)
-sol = solve(prob, saveat=0.001)
+sol = solve(prob, Tsit5(), saveat=0.001)
 u = Observable(sol.u[1])
 fig, ax, sc = tricontourf(tri, u, levels=0:5:50, colormap=:matter)
 tightlimits!(ax)

docs/liveserver.jl

@@ -6,6 +6,11 @@ import LiveServer
 withenv("LIVESERVER_ACTIVE" => "true") do
     LiveServer.servedocs(;
         launch_browser=true,
+        foldername=joinpath(repo_root, "docs"),
+        include_dirs=[joinpath(repo_root, "src")],
+        skip_dirs=[joinpath(repo_root, "docs/src/tutorials"),
+            joinpath(repo_root, "docs/src/wyos"),
+            joinpath(repo_root, "docs/src/figures"),
+        ],
     )
-end
-
+end

docs/src/figures/gray_scott_patterns.mp4

@@ -37,7 +37,7 @@ TriangleProperties
 
 # `BoundaryConditions`: Defining boundary conditions
 
-Once a mesh is defined, you need to associate each part of the boundary with a set of boundary nodes. Since you have a `Triangulation`, the boundary of the mesh already meets the necessary assumptions made by this package about the boundary; these assumptions are simply that they match the specification of a boundary [here in DelaunayTriangulation.jl's docs](https://SciML.github.io/DelaunayTriangulation.jl/dev/boundary_handling/#Boundary-Specification) (for example, the boundary points connect, the boundary is positively oriented, etc.).
+Once a mesh is defined, you need to associate each part of the boundary with a set of boundary nodes. Since you have a `Triangulation`, the boundary of the mesh already meets the necessary assumptions made by this package about the boundary; these assumptions are simply that they match the specification of a boundary [here in DelaunayTriangulation.jl's docs](https://juliageometry.github.io/DelaunayTriangulation.jl/dev/manual/boundaries/) (for example, the boundary points connect, the boundary is positively oriented, etc.).
 
 You can specify boundary conditions using `BoundaryConditions`, whose docstring is below; the fields of `BoundaryConditions` are not public API, only this wrapper is.
 

docs/src/figures/maze_solution_1.mp4

@@ -29,28 +29,20 @@ tc = DisplayAs.withcontext(:displaysize => (15, 80), :limit => true); #hide
 # one part for each boundary condition. This is accomplished 
 # by providing a single vector for each part of the boundary as follows
 # (and as described in DelaunayTriangulation.jl's documentation),
-# where we also `refine!` the mesh to get a better mesh. 
+# where we also `refine!` the mesh to get a better mesh. For the arc, 
+# we use the `CircularArc` so that the mesh knows that it is triangulating 
+# a certain arc in that area.
 using DelaunayTriangulation, FiniteVolumeMethod, ElasticArrays
 using ReferenceTests, Bessels, FastGaussQuadrature, Cubature #src
-n = 50
+
 α = π / 4
-## The bottom edge 
-x₁ = [0.0, 1.0]
-y₁ = [0.0, 0.0]
-## The arc 
-r₂ = fill(1, n)
-θ₂ = LinRange(0, α, n)
-x₂ = @. r₂ * cos(θ₂)
-y₂ = @. r₂ * sin(θ₂)
-## The upper edge 
-x₃ = [cos(α), 0.0]
-y₃ = [sin(α), 0.0]
-## Now combine and create the mesh 
-x = [x₁, x₂, x₃]
-y = [y₁, y₂, y₃]
-boundary_nodes, points = convert_boundary_points_to_indices(x, y; existing_points=ElasticMatrix{Float64}(undef, 2, 0))
+points = [(0.0, 0.0), (1.0, 0.0), (cos(α), sin(α))]
+bottom_edge = [1, 2]
+arc = CircularArc((1.0, 0.0), (cos(α), sin(α)), (0.0, 0.0))
+upper_edge = [3, 1]
+boundary_nodes = [bottom_edge, [arc], upper_edge]
 tri = triangulate(points; boundary_nodes)
-A = get_total_area(tri)
+A = get_area(tri)
 refine!(tri; max_area=1e-4A)
 mesh = FVMGeometry(tri)
 
@@ -74,7 +66,7 @@ BCs = BoundaryConditions(mesh, (lower_bc, arc_bc, upper_bc), types)
 # specifying the diffusion function as a constant. 
 f = (x, y) -> 1 - sqrt(x^2 + y^2)
 D = (x, y, t, u, p) -> one(u)
-initial_condition = [f(x, y) for (x, y) in each_point(tri)]
+initial_condition = [f(x, y) for (x, y) in DelaunayTriangulation.each_point(tri)]
 final_time = 0.1
 prob = FVMProblem(mesh, BCs; diffusion_function=D, initial_condition, final_time)
 
@@ -89,12 +81,18 @@ flux = (x, y, t, α, β, γ, p) -> (-α, -β)
 # has the best performance for these problems.
 using OrdinaryDiffEq, LinearSolve
 sol = solve(prob, TRBDF2(linsolve=KLUFactorization()), saveat=0.01, parallel=Val(false))
+ind = findall(DelaunayTriangulation.each_point_index(tri)) do i #hide
+    !DelaunayTriangulation.has_vertex(tri, i) #hide
+end #hide
+using Test #hide
+@test sol[ind, :] ≈ reshape(repeat(initial_condition, length(sol)), :, length(sol))[ind, :] # make sure that missing vertices don't change #hide
 sol |> tc #hide
 
 #-
 using CairoMakie
 fig = Figure(fontsize=38)
 for (i, j) in zip(1:3, (1, 6, 11))
+    local ax
     ax = Axis(fig[1, i], width=600, height=600,
         xlabel="x", ylabel="y",
         title="t = $(sol.t[j])",
@@ -145,7 +143,7 @@ function exact_solution(x, y, t, A, ζ, f, α) #src
     return s #src
 end #src
 function compare_solutions(sol, tri, α, f) #src
-    n = DelaunayTriangulation.num_solid_vertices(tri) #src
+    n = DelaunayTriangulation.num_points(tri) #src
     x = zeros(n, length(sol)) #src
     y = zeros(n, length(sol)) #src
     u = zeros(n, length(sol)) #src
@@ -162,6 +160,7 @@ end #src
 x, y, u = compare_solutions(sol, tri, α, f) #src
 fig = Figure(fontsize=64) #src
 for i in eachindex(sol) #src
+    local ax
     ax = Axis(fig[1, i], width=600, height=600) #src
     tricontourf!(ax, tri, sol.u[i], levels=0:0.01:1, colormap=:matter) #src
     ax = Axis(fig[2, i], width=600, height=600) #src

docs/src/figures/mean_exit_time_template_1.png

@@ -36,7 +36,7 @@ BCs = BoundaryConditions(mesh, bc, Dirichlet)
 
 # We can now define the actual PDE. We start by defining the initial condition and the diffusion function. 
 f = (x, y) -> y ≤ 1.0 ? 50.0 : 0.0
-initial_condition = [f(x, y) for (x, y) in each_point(tri)]
+initial_condition = [f(x, y) for (x, y) in DelaunayTriangulation.each_point(tri)]
 D = (x, y, t, u, p) -> 1 / 9
 
 # We can now define the problem:
@@ -50,17 +50,19 @@ prob.flux_function
 # where $(\alpha, \beta, \gamma)$ defines the approximation to $u$ via $u(x, y) = \alpha x + \beta y + \gamma$ so that 
 # $\grad u(\vb x, t) = (\alpha,\beta)^{\mkern-1.5mu\mathsf{T}}$.
 
-# To now solve the problem, we simply use `solve`. When no algorithm 
-# is provided, as long as DifferentialEquations is loaded (instead of e.g. 
-# OrdinaryDiffEq), the algorithm is chosen automatically. Moreover, note that, 
+# To now solve the problem, we simply use `solve`. Note that, 
 # in the `solve` call below, multithreading is enabled by default.
-using DifferentialEquations
-sol = solve(prob, saveat=0.05)
+# (If you don't know what algorithm to consider, do `using DifferentialEquations` instead 
+# and simply call `solve(prob, saveat=0.05)` so that the algorithm is chosen automatically instead 
+# of using `Tsit5()`.)
+using OrdinaryDiffEq
+sol = solve(prob, Tsit5(), saveat=0.05)
 sol |> tc #hide
 
 # To visualise the solution, we can use `tricontourf!` from Makie.jl. 
 fig = Figure(fontsize=38)
 for (i, j) in zip(1:3, (1, 6, 11))
+    local ax
     ax = Axis(fig[1, i], width=600, height=600,
         xlabel="x", ylabel="y",
         title="t = $(sol.t[j])",
@@ -88,7 +90,7 @@ function exact_solution(x, y, t) #src
     end #src
 end #src
 function compare_solutions(sol, tri) #src
-    n = DelaunayTriangulation.num_solid_vertices(tri) #src
+    n = DelaunayTriangulation.num_points(tri) #src
     x = zeros(n, length(sol)) #src
     y = zeros(n, length(sol)) #src
     u = zeros(n, length(sol)) #src
@@ -103,6 +105,7 @@ end #src
 x, y, u = compare_solutions(sol, tri) #src
 fig = Figure(fontsize=64) #src
 for i in eachindex(sol) #src
+    local ax
     ax = Axis(fig[1, i], width=600, height=600) #src
     tricontourf!(ax, tri, sol.u[i], levels=0:5:50, colormap=:matter) #src
     ax = Axis(fig[2, i], width=600, height=600) #src