Fix literate examples

Author: nHackel

docs/src/literate/example/algorithm.jl

@@ -21,7 +21,7 @@ include("../../literate/example/example_include_all.jl") #hide
 # We first recall the algorithms we defined for OurRadonreco. We will use iterative methods to reconstruct the first three images from our time series. For more information, refer to the AbstractImageReconstruction documentation.
 # We first prepare our parameters. For this example we will use the Conjugate Gradient Normal Residual solver with 20 iterations and a L2 regularization of 0.001. Furthermore, we will project the final result to positive values:
 pre = RadonPreprocessingParameters(frames = collect(1:3))
-iter_reco = IterativeRadonReconstructionParameters(; shape = size(images)[1:3], angles = angles, iterations = 20, reg = [L2Regularization(0.001), PositiveRegularization()], solver = CGNR);
+iter_reco = IterativeRadonReconstructionParameters(; shape = size(images)[1:3], angles = angles, iterations = 20, reg = [L2Regularization(0.001)], solver = CGNR);
 
 # We can construct the algorithm with our parameters:
 algo_iter = IterativeRadonAlgorithm(IterativeRadonParameters(pre, iter_reco));

docs/src/literate/example/daggerplan.jl

@@ -31,17 +31,19 @@ dict = Dict{Symbol, Any}()
 dict[:shape] = size(images)[1:3]
 dict[:angles] = angles
 dict[:iterations] = 20
-dict[:reg] = [L2Regularization(0.001), PositiveRegularization()]
+dict[:reg] = [L2Regularization(0.001)]
 dict[:solver] = CGNR
 setAll!(plan_dagger, dict)
 
 # To configure the algorithm with resources only available on the worker, such as files or GPU data, we can use the following interface:
 setproperty!(plan_dagger.parameter.algo.parameter.reco, :angles) do
   angles[1:2:end]
 end
+length(plan_dagger.parameter.algo.parameter.reco.angles) == length(1:2:length(angles))
 # The provided function is evaluated solely on the remote worker.
 
 # Once the algorithm is fully configured, we can build and use it as usual:
+setAll!(plan_dagger, dict)
 imag_dagger = reconstruct(build(plan_dagger), sinograms)
 fig = Figure()
 for i = 1:3
@@ -70,19 +72,20 @@ toTOML(stdout, plan_dagger)
 # Additionally, listeners can be attached across workers using the Observable interface on a `DaggerRecoPlan`:
 using Observables
 localVariable = 3
-fun = on(plan_iter.parameter.pre, :frames) do newval
+plan_iter_remote = plan_dagger.parameter.algo
+fun = on(plan_iter_remote.parameter.pre, :frames) do newval
   @info "Number of frames was updated to: $(length(newval))"
   localVariable = length(newval)
 end
-setAll!(plan_iter, :frames, collect(1:42))
+setAll!(plan_iter_remote, :frames, collect(1:42))
 
 # Note: We retain the observable function in the variable `fun` to allow for later removal of the listener. The anonymous function cannot be used directly due to internal listener management in **DaggerImageReconstruction**.
-off(plan_iter.parameter.pre, :frames, fun)
-setAll!(plan_iter, :frames, collect(1:32))
+off(plan_iter_remote.parameter.pre, :frames, fun)
+setAll!(plan_iter_remote, :frames, collect(1:32))
 
 # Since the listener executes on the local worker, updated data must be transferred between workers. If this involves large data, a preprocessing function can be provided to the Observable:
-fun = on(plan_iter.parameter.pre, :frames; preprocessing = length) do newval
+fun = on(plan_iter_remote.parameter.pre, :frames; preprocessing = length) do newval
   @info "Number of frames was updated to: $(newval)"
   localVariable = newval
 end
-setAll!(plan_iter, :frames, collect(1:42))
+setAll!(plan_iter_remote, :frames, collect(1:42))