Merge pull request #304 from FourierFlows/ncc/add-doctests

Add some doctests

Author: navidcy

docs/src/diagnostics.md

@@ -6,7 +6,7 @@ functionality.
 ```@meta
 DocTestSetup = quote
     using FourierFlows
-    using LinearAlgebra: mul!
+    using LinearAlgebra: mul!, ldiv!
     nx, Lx = 32, 2.0
     grid = OneDGrid(nx, Lx)
     struct Params <: AbstractParams
@@ -28,6 +28,10 @@ DocTestSetup = quote
     prob = FourierFlows.Problem(equation, stepper, dt, grid, vars, params)
     u0 = @. cos(π * grid.x)
     mul!(prob.sol, grid.rfftplan, u0)
+    function energy(prob)
+        ldiv!(prob.vars.u, grid.rfftplan, prob.sol)
+        return sum(prob.vars.u.^2) * prob.grid.dx
+    end
 end
 ```
 
@@ -36,7 +40,6 @@ using FourierFlows, Plots
 
 using LinearAlgebra: mul!
 
-Plots.scalefontsizes(1.25)
 Plots.default(lw=3)
 
 nx, Lx = 32, 2.0
@@ -101,8 +104,22 @@ and then we create a [`Diagnostic`](@ref) using the
 [`Diagnostic`](@ref Diagnostic(calc, prob; freq=1, nsteps=100, ndata=ceil(Int, (nsteps+1)/freq)))
 constructor. Say we want to save energy every 2 time-steps, then:
 
-```@example 3
+```jldoctest; output = false
 E = Diagnostic(energy, prob, freq=2, nsteps=200)
+
+# output
+
+Diagnostic
+  ├─── calc: energy
+  ├─── prob: FourierFlows.Problem{DataType, Vector{ComplexF64}, Float64, Vector{Float64}}
+  ├─── data: 101-element Vector{Float64}
+  ├────── t: 101-element Vector{Float64}
+  ├── steps: 101-element Vector{Int64}
+  ├─── freq: 2
+  └────── i: 1
+```
+```@example 3
+E = Diagnostic(energy, prob, freq=2, nsteps=200) #hide
 ```
 
 Now, when we step forward the problem we provide the diagnostic as the second positional 

docs/src/output.md

@@ -4,6 +4,42 @@ To save output we use [`Output`](@ref). Let's see how we can use the example dev
 in [Problem](@ref problem_docs) and [Diagnostics](@ref diagnostics_docs) sections to
 demonstrate how we can save some output to disk and then load it.
 
+```@meta
+DocTestSetup = quote
+    using FourierFlows
+    using LinearAlgebra: mul!, ldiv!
+    nx, Lx = 32, 2.0
+    grid = OneDGrid(nx, Lx)
+    struct Params <: AbstractParams
+    α :: Float64
+    end
+    params = Params(0.1)
+    struct Vars <: AbstractVars
+        u :: Array{Float64,1}
+    uh :: Array{Complex{Float64}, 1}
+    end
+    vars = Vars(zeros(Float64, (grid.nx,)), zeros(Complex{Float64}, (grid.nkr,)))
+    L = - params.α * ones(grid.nkr)
+    function calcN!(N, sol, t, clock, vars, params, grid)
+    @. N = 0
+    return nothing
+    end
+    equation = FourierFlows.Equation(L, calcN!, grid)
+    stepper, dt = "ForwardEuler", 0.02
+    prob = FourierFlows.Problem(equation, stepper, dt, grid, vars, params)
+    u0 = @. cos(π * grid.x)
+    mul!(prob.sol, grid.rfftplan, u0)
+    function energy(prob)
+        ldiv!(prob.vars.u, grid.rfftplan, prob.sol)
+        return sum(prob.vars.u.^2) * prob.grid.dx
+    end
+    E = Diagnostic(energy, prob, freq=2, nsteps=200)
+    filepath = "."
+    filename = joinpath(filepath, "simplestpde.jld2")
+    get_uh(prob) = prob.sol
+end
+```
+
 ```@setup 4
 using FourierFlows, Plots
 
@@ -68,10 +104,23 @@ that we want to output and a function what takes `prob` as its argument and
 returns the corresponding value of that field. For this example, let's save
 the energy `E` and the state vector `sol`.
 
-```@example 4
+```jldoctest; output = false, filter = r"path:.*"
 get_uh(prob) = prob.sol
 
 out = Output(prob, filename, (:uh, get_uh), (:E, energy))
+
+# output
+
+Output
+  ├──── prob: FourierFlows.Problem{DataType, Vector{ComplexF64}, Float64, Vector{Float64}}
+  ├──── path: ./simplestpde.jld2
+  └── fields: Dict{Symbol, Function}(:uh => get_uh, :E => energy)
+```
+
+```@example 4
+get_uh(prob) = prob.sol #hide
+
+out = Output(prob, filename, (:uh, get_uh), (:E, energy)) #hide
 ```
 
 Note that we haven't saved anything to disk yet!

src/diagnostics.jl

@@ -124,4 +124,3 @@ show(io::IO, d::Diagnostic{T, N}) where {T, N} =
                "  ├── steps: ", summary(d.steps), '\n', 
                "  ├─── freq: ", d.freq, '\n', 
                "  └────── i: ", d.i)
-           

src/output.jl

@@ -158,3 +158,9 @@ function savediagnostic(diag, diagname, filename)
 
   return nothing
 end
+
+show(io::IO, out::Output) =
+     print(io, "Output\n",
+               "  ├──── prob: ", summary(out.prob), '\n', 
+               "  ├──── path: ", out.path, '\n', 
+               "  └── fields: ", out.fields)

test/runtests.jl

@@ -267,7 +267,7 @@ for dev in devices
 
     g = OneDGrid(dev, nx, Lx)
     σ = 0.5
-    f1 = @. exp(-g.x^2/(2σ^2))
+    f1 = @. exp(-g.x^2 / 2σ^2)
     @test test_parsevalsum2(f1, g; realvalued=true)  # Real valued f with rfft
     @test test_parsevalsum2(f1, g; realvalued=false) # Real valued f with fft
 
@@ -355,16 +355,19 @@ for dev in devices
 
     get_sol(prob) = prob.sol
     diag = Diagnostic(get_sol, prob)
+    out = Output(prob, "output.jld2")
 
     @test repr(prob1.params) == "Parameters\n  ├───── parameter: κ1 -> Float64\n  ├───── parameter: κ2 -> Float64\n  └───── parameter: func -> Function\n"
     @test repr(prob2.params) == "Parameters\n  ├───── parameter: κ1 -> Float64\n  ├───── parameter: func -> Function\n  └───── parameter: κ2 -> Float64\n"
 
     if dev == CPU()
       @test repr(prob.vars) == "Variables\n  ├───── variable: c -> 128-element Vector{Float64}\n  ├───── variable: cx -> 128-element Vector{Float64}\n  ├───── variable: ch -> 65-element Vector{ComplexF64}\n  └───── variable: cxh -> 65-element Vector{ComplexF64}\n"
       @test repr(diag) == "Diagnostic\n  ├─── calc: get_sol\n  ├─── prob: FourierFlows.Problem{DataType, Vector{ComplexF64}, Float64, Vector{Int64}}\n  ├─── data: 101-element Vector{Vector{ComplexF64}}\n  ├────── t: 101-element Vector{Float64}\n  ├── steps: 101-element Vector{Int64}\n  ├─── freq: 1\n  └────── i: 1"
+      @test repr(out) == "Output\n  ├──── prob: FourierFlows.Problem{DataType, Vector{ComplexF64}, Float64, Vector{Int64}}\n  ├──── path: output.jld2\n  └── fields: Dict{Symbol, Function}()"
     else
       @test repr(prob.vars) == "Variables\n  ├───── variable: c -> 128-element " * string(ArrayType(dev)) * "{Float64, 1, CUDA.Mem.DeviceBuffer}\n  ├───── variable: cx -> 128-element " * string(ArrayType(dev)) * "{Float64, 1, CUDA.Mem.DeviceBuffer}\n  ├───── variable: ch -> 65-element " * string(ArrayType(dev)) * "{ComplexF64, 1, CUDA.Mem.DeviceBuffer}\n  └───── variable: cxh -> 65-element " * string(ArrayType(dev)) * "{ComplexF64, 1, CUDA.Mem.DeviceBuffer}\n"
       @test repr(diag) == "Diagnostic\n  ├─── calc: get_sol\n  ├─── prob: FourierFlows.Problem{DataType, " * string(ArrayType(dev)) * "{ComplexF64, 1, CUDA.Mem.DeviceBuffer}, Float64, " * string(ArrayType(dev)) * "{Int64, 1, CUDA.Mem.DeviceBuffer}}\n  ├─── data: 101-element Vector{" * string(ArrayType(dev)) * "{ComplexF64, 1, CUDA.Mem.DeviceBuffer}}\n  ├────── t: 101-element Vector{Float64}\n  ├── steps: 101-element Vector{Int64}\n  ├─── freq: 1\n  └────── i: 1"
+      @test repr(out) == "Output\n  ├──── prob: FourierFlows.Problem{DataType, CuArray{ComplexF64, 1, CUDA.Mem.DeviceBuffer}, Float64, CuArray{Int64, 1, CUDA.Mem.DeviceBuffer}}\n  ├──── path: output.jld2\n  └── fields: Dict{Symbol, Function}()"
     end
     @test repr(prob.eqn) == "Equation\n  ├──────── linear coefficients: L\n  │                              ├───type: Int64\n  │                              └───size: (65,)\n  ├───────────── nonlinear term: calcN!()\n  └─── type of state vector sol: ComplexF64"
     @test repr(prob.clock) == "Clock\n  ├─── timestep dt: 0.01\n  ├────────── step: 0\n  └──────── time t: 0.0"