Update to latest version of QuantumControl

Author: goerz

Project.toml

@@ -4,6 +4,7 @@ authors = ["Michael Goerz <mail@michaelgoerz.net>"]
 version = "0.1.0-dev"
 
 [deps]
+AppleAccelerate = "13e28ba4-7ad8-5781-acae-3021b1ed3924"
 DisplayAs = "0b91fe84-8a4c-11e9-3e1d-67c38462b6d6"
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 DocumenterCitations = "daee34ce-89f3-4625-b898-19384cb65244"
@@ -31,29 +32,30 @@ UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
 Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 
 [compat]
+AppleAccelerate = "0.4.0"
 DisplayAs = "0.1.6"
-Documenter = "1.4"
+Documenter = "1.8"
 DocumenterCitations = "1.3"
-DocumenterInterLinks = "0.2"
-GRAPE = "0.6.2"
-GRAPELinesearchAnalysis = "0.7.0"
+DocumenterInterLinks = "1.0"
+GRAPE = "0.7.5"
+GRAPELinesearchAnalysis = "0.7.2"
 Glob = "1.3"
 JuliaFormatter = "1.0"
-Krotov = "0.6.2"
-LineSearches = "7.2"
+Krotov = "0.7.2"
+LineSearches = "7.3"
 LinearAlgebra = "1"
-Literate = "2.16"
-LiveServer = "1.2"
+Literate = "2.20"
+LiveServer = "1.4"
 Optim = "1.7"
 Plots = "1.39"
-QuantumControl = "0.9.1"
-QuantumControlTestUtils = "0.3.0"
-QuantumPropagators = "0.7.6"
+QuantumControl = "0.11.1"
+QuantumControlTestUtils = "0.3.1"
+QuantumPropagators = "0.8.3"
 SafeTestsets = "0.1"
 SparseArrays = "1.10"
 TOML = "1"
 Test = "1"
-TwoQubitWeylChamber = "0.1.3"
-UnicodePlots = "3.6"
+TwoQubitWeylChamber = "0.2.1"
+UnicodePlots = "3.7.1"
 Zygote = "0.6"
-julia = "1.10"
+julia = "1.11"

docs/src/refs.bib

@@ -172,7 +172,7 @@ @article{GoerzQ2022
 
 
 @article{GoerzPRA2015,
-    Author = {Goerz, Michael H. and Gualdi, Giulia and Reich, Daniel M. and Koch, Christiane P. and Motzoi, Felix and Whaley, K. Birgitta and Vala, Ji\vr\'i and Müller, Matthias M. and Montangero, Simone and Calarco, Tommaso},
+    Author = {Goerz, Michael H. and Gualdi, Giulia and Reich, Daniel M. and Koch, Christiane P. and Motzoi, Felix and Whaley, K. Birgitta and Vala, Jiří and Müller, Matthias M. and Montangero, Simone and Calarco, Tommaso},
     Title = {Optimizing for an arbitrary perfect entangler. II. Application},
     Journal = pra,
     Year = {2015},

examples/grape_state_to_state/simple_state_to_state.jl

@@ -43,14 +43,13 @@ datadir(names...) = joinpath(@__DIR__, names...)
 
 using QuantumControl
 using QuantumPropagators: ExpProp
+using AppleAccelerate #hide
 
 using Test #src
 
 # ## Two-level Hamiltonian
 
-# We consider the Hamiltonian $\op{H}_{0} = - \frac{\omega}{2} \op{\sigma}_{z}$, representing a simple qubit with energy level splitting $\omega$ in the basis $\{\ket{0},\ket{1}\}$. The control field $\epsilon(t)$ is assumed to couple via the Hamiltonian $\op{H}_{1}(t) = \epsilon(t) \op{\sigma}_{x}$ to the qubit, i.e., the control field effectively drives transitions between both qubit states.
-#
-# We we will use
+# We consider the Hamiltonian ``\op{H}_{0} = - \frac{\omega}{2} \op{\sigma}_{z}``, representing a simple qubit with energy level splitting ``\omega`` in the basis ``\{\ket{0},\ket{1}\}``. The control field ``\epsilon(t)`` is assumed to couple via the Hamiltonian ``\op{H}_{1}(t) = \epsilon(t) \op{\sigma}_{x}`` to the qubit, i.e., the control field effectively drives transitions between both qubit states.
 
 ϵ(t) = 0.2 * QuantumControl.Shapes.flattop(t, T=5, t_rise=0.3, func=:blackman);
 
@@ -74,10 +73,7 @@ end;
 H = tls_hamiltonian();
 @test length(H.ops) == 2 #src
 
-# The control field here switches on from zero at $t=0$ to it's maximum amplitude
-# 0.2 within the time period 0.3 (the switch-on shape is half a [Blackman pulse](https://en.wikipedia.org/wiki/Window_function#Blackman_window)).
-# It switches off again in the time period 0.3 before the
-# final time $T=5$). We use a time grid with 500 time steps between 0 and $T$:
+# The control field here switches on from zero at ``t=0`` to it's maximum amplitude 0.2 within the time period 0.3 (the switch-on shape is half a [Blackman pulse](https://en.wikipedia.org/wiki/Window_function#Blackman_window)). It switches off again in the time period 0.3 before the final time ``T=5``). We use a time grid with 500 time steps between 0 and ``T``:
 
 tlist = collect(range(0, 5, length=500));
 
@@ -115,15 +111,15 @@ using LinearAlgebra #src
 @test dot(ket(0), ket(1)) ≈ 0 #src
 #-
 
-# The physical objective of our optimization is to transform the initial state $\ket{0}$ into the target state $\ket{1}$ under the time evolution induced by the Hamiltonian $\op{H}(t)$.
+# The physical objective of our optimization is to transform the initial state ``\ket{0}`` into the target state ``\ket{1}`` under the time evolution induced by the Hamiltonian ``\op{H}(t)``.
 
 trajectories = [Trajectory(initial_state=ket(0), generator=H, target_state=ket(1))];
 
 #-
 @test length(trajectories) == 1 #src
 #-
 
-# The full control problem includes this trajectory, information about the time grid for the dynamics, and the functional to be used (the square modulus of the overlap $\tau$ with the target state in this case).
+# The full control problem includes this trajectory, information about the time grid for the dynamics, and the functional to be used (the square modulus of the overlap ``\tau`` with the target state in this case).
 
 using QuantumControl.Functionals: J_T_sm
 
@@ -142,7 +138,7 @@ problem = ControlProblem(
 
 # ## Simulate dynamics under the guess field
 
-# Before running the optimization procedure, we first simulate the dynamics under the guess field $\epsilon_{0}(t)$. The following solves equation of motion for the defined trajective, which contains the initial state $\ket{\Psi_{\init}}$ and the Hamiltonian $\op{H}(t)$ defining its evolution.
+# Before running the optimization procedure, we first simulate the dynamics under the guess field ``\epsilon_{0}(t)``. The following solves equation of motion for the defined trajectory, which contains the initial state ``\ket{\Psi_{\init}}`` and the Hamiltonian ``\op{H}(t)`` defining its evolution.
 
 
 guess_dynamics = propagate_trajectory(
@@ -166,43 +162,30 @@ display(fig) #src
 
 # ## Optimization with LBFGSB
 
-# In the following we optimize the guess field $\epsilon_{0}(t)$ such that the intended state-to-state transfer $\ket{\Psi_{\init}} \rightarrow \ket{\Psi_{\tgt}}$ is solved.
+# In the following we optimize the guess field ``\epsilon_{0}(t)`` such that the intended state-to-state transfer ``\ket{\Psi_{\init}} \rightarrow \ket{\Psi_{\tgt}}`` is solved.
 
-# The GRAPE package performs the optimization by calculating the gradient of $J_T$ with respect to the values of the control field at each point in time. This gradient is then fed into a backend solver that calculates an appropriate update based on that gradient.
+# The GRAPE package performs the optimization by calculating the gradient of ``J_T`` with respect to the values of the control field at each point in time. This gradient is then fed into a backend solver that calculates an appropriate update based on that gradient.
 
 using GRAPE
 
-# By default, this backend is [LBFGSB.jl](https://github.com/Gnimuc/LBFGSB.jl), a wrapper around the true and tested [L-BFGS-B Fortran library](http://users.iems.northwestern.edu/%7Enocedal/lbfgsb.html). L-BFGS-B is a pseudo-Hessian method: it efficiently estimates the second-order Hessian from the gradient information. The search direction determined from that Hessian dramatically improves convergence compared to using the gradient directly as a search direction. The L-BFGS-B method performs its own linesearch to determine how far to go in the search direction.
-
-# It can be quite instructive to see how the improvement in the pseudo-Hessian search direction compares to the gradient, how the linesearch finds an appropriate step width. For this purpose, we have a [GRAPELinesearchAnalysis](https://github.com/JuliaQuantumControl/GRAPELinesearchAnalysis.jl) package that automatically generates plots in every iteration of the optimization showing the linesearch behavior
-
-using GRAPELinesearchAnalysis
-
-# We feed this into the optimization as part of the `info_hook`.
+# By default, this backend is [`LBFGSB.jl`](https://github.com/Gnimuc/LBFGSB.jl), a wrapper around the true and tested [L-BFGS-B Fortran library](http://users.iems.northwestern.edu/%7Enocedal/lbfgsb.html). L-BFGS-B is a pseudo-Hessian method: it efficiently estimates the second-order Hessian from the gradient information. The search direction determined from that Hessian dramatically improves convergence compared to using the gradient directly as a search direction. The L-BFGS-B method performs its own linesearch to determine how far to go in the search direction.
 
 opt_result_LBFGSB = @optimize_or_load(
     datadir("TLS", "GRAPE_opt_result_LBFGSB.jld2"),
     problem;
     method=GRAPE,
     prop_method=ExpProp,
-    info_hook=(
-        GRAPELinesearchAnalysis.plot_linesearch(datadir("TLS", "Linesearch", "LBFGSB")), #md
-        GRAPELinesearchAnalysis.plot_linesearch(datadir("TLS", "Linesearch", "LBFGSB")), #nb
-        GRAPE.print_table,
-    )
 );
 #-
 @test opt_result_LBFGSB.J_T < 1e-3 #src
 #-
 
-# When going through this tutorial locally, the [generated images for the linesearch](https://github.com/JuliaQuantumControl/GRAPE.jl/tree/data-dump/TLS/Linesearch/LBFGSB) can be found in `datadir("TLS", "Linesearch, "LBFGS")`
-
 opt_result_LBFGSB
 
 # We can plot the optimized field:
 
 #-
-fig = plot_control(opt_result_LBFGSB.optimized_controls[1], tlist)
+fig = plot_control(opt_result_LBFGSB.optimized_controls[1], tlist)  # This is test
 #md fig |> DisplayAs.PNG #hide
 display(fig) #src
 #-
@@ -212,7 +195,7 @@ display(fig) #src
 
 # Our GRAPE implementation includes the analytic gradient of the optimization functional `J_T_sm`. Thus, we only had to pass the functional itself to the optimization. More generally, for functionals where the analytic gradient is not known, semi-automatic differentiation can be used to determine it automatically. For illustration, we may re-run the optimization forgoing the known analytic gradient and instead using an automatically determined gradient.
 
-# As shown in Goerz et al., arXiv:2205.15044, by evaluating the gradient of ``J_T`` via a chain rule in the propagated states, the dependency of the gradient on the final time functional is pushed into the boundary condition for the backward propagation, ``|χ_k⟩ = -∂J_T/∂⟨ϕ_k|``. For functionals that can be written in terms of the overlaps ``τ_k`` of the forward-propagated states and target states, such as the `J_T_sm` used here, a further chain rule leaves derivatives of `J_T` with respect to the overlaps ``τ_k``, which are easily obtained via automatic differentiation. The `optimize` function takes an optional parameter `chi` that may be passed a function to calculate ``|χ_k⟩``. A suitable function can be obained using
+# As shown in Goerz et al., arXiv:2205.15044, by evaluating the gradient of ``J_T`` via a chain rule in the propagated states, the dependency of the gradient on the final time functional is pushed into the boundary condition for the backward propagation, ``|χ_k⟩ = -∂J_T/∂⟨ϕ_k|``. For functionals that can be written in terms of the overlaps ``τ_k`` of the forward-propagated states and target states, such as the `J_T_sm` used here, a further chain rule leaves derivatives of `J_T` with respect to the overlaps ``τ_k``, which are easily obtained via automatic differentiation. The `optimize` function takes an optional parameter `chi` that may be passed a function to calculate ``|χ_k⟩``. A suitable function can be obtained using
 
 using QuantumControl.Functionals: make_chi
 
@@ -232,26 +215,21 @@ opt_result_LBFGSB_via_χ
 
 # ## Optimization with Optim.jl
 
-# As an alternative to the default L-BFGS-B backend, we can also use any of the gradient-based optimizers in [Optiml.jl](https://github.com/JuliaNLSolvers/Optim.jl). This also gives full control over the linesearch method.
+# As an alternative to the default L-BFGS-B backend, we can also use any of the gradient-based optimizers in [`Optim.jl`](https://github.com/JuliaNLSolvers/Optim.jl). This also gives full control over the linesearch method.
 
 import Optim
 import LineSearches
 
-# Here, we use the LBFGS implementation that is part of Optim (which is not exactly the same as L-BFGS-B; "B" being the variant of LBFGS with optional additional bounds on the control) with a Hager-Zhang linesearch
+# Here, we use the LBFGS implementation that is part of `Optim` (which is not exactly the same as L-BFGS-B; "B" being the variant of LBFGS with optional additional bounds on the control) with a Hager-Zhang linesearch
 
 opt_result_OptimLBFGS = @optimize_or_load(
     datadir("TLS", "GRAPE_opt_result_OptimLBFGS.jld2"),
     problem;
     method=GRAPE,
-    info_hook=(
-        GRAPELinesearchAnalysis.plot_linesearch(datadir("TLS", "Linesearch", "OptimLBFGS")), #md
-        GRAPELinesearchAnalysis.plot_linesearch(datadir("TLS", "Linesearch", "OptimLBFGS")), #nb
-        GRAPE.print_table,
-    ),
     optimizer=Optim.LBFGS(;
         alphaguess=LineSearches.InitialStatic(alpha=0.2),
         linesearch=LineSearches.HagerZhang(alphamax=2.0)
-    )
+    ),
 );
 
 #-
@@ -267,13 +245,13 @@ fig = plot_control(opt_result_OptimLBFGS.optimized_controls[1], tlist)
 #md fig |> DisplayAs.PNG #hide
 display(fig) #src
 
-# We can see that the choice of linesearch parameters in particular strongly influence the convergence and the resulting field. Play around with different methods and parameters, and compare the different [plots generated by `GRAPELinesearchAnalysis`](https://github.com/JuliaQuantumControl/GRAPE.jl/tree/data-dump/TLS/Linesearch/OptimLBFGS)!
+# We can see that the choice of linesearch parameters in particular strongly influence the convergence and the resulting field. Play around with different methods and parameters!
 #
 # Empirically, we find the default L-BFGS-B to have a very well-behaved linesearch.
 
 # ## Simulate the dynamics under the optimized field
 
-# Having obtained the optimized control field, we can simulate the dynamics to verify that the optimized field indeed drives the initial state $\ket{\Psi_{\init}} = \ket{0}$ to the desired target state $\ket{\Psi_{\tgt}} = \ket{1}$.
+# Having obtained the optimized control field, we can simulate the dynamics to verify that the optimized field indeed drives the initial state ``\ket{\Psi_{\init}} = \ket{0}`` to the desired target state ``\ket{\Psi_{\tgt}} = \ket{1}``.
 
 using QuantumControl.Controls: substitute
 

examples/perfect_entanglers/perfect_entanglers.jl

@@ -41,6 +41,7 @@
 #md import DisplayAs #hide
 datadir(names...) = joinpath(@__DIR__, names...);
 using Test #src
+using AppleAccelerate #hide
 
 # This example illustrates the optimization towards a perfectly entangling
 # two-qubit gate for a system of two transmon qubits with a shared transmission

examples/rho_3states/rho_3states.jl

@@ -48,6 +48,8 @@ datadir(names...) = joinpath(@__DIR__, names...);
 using QuantumControl
 using LinearAlgebra
 using Serialization
+using AppleAccelerate #hide
+
 using SparseArrays
 #-
 using Plots

src/run_examples.jl

@@ -142,6 +142,7 @@ function run_example(
             @info "skip converting `$(_shrinkuser(file))` to .ipynb file (up to date)."
         else
             _run(_script_run_notebook(folder); threads)
+            run(`jupyter trust $nbfile`; wait=true)
         end
     end
 end

tutorials/krotov_pulse_parameterization/krotov_pulse_parameterization.jl

@@ -55,6 +55,7 @@ using QuantumControl.PulseParameterizations:
     ParameterizedAmplitude
 using QuantumPropagators: ExpProp
 using LinearAlgebra
+using AppleAccelerate #hide
 
 #-
 using Test #src