rebase complete (fixes free phase loss)

src/problem_solvers.jl

@@ -40,7 +40,7 @@ function solve!(
     #         fids = fidelity(prob)
     #         println("\nInitial Fidelities: $fids")
     #     elseif state_type == :unitary
-    #         fids = unitary_fidelity(prob)
+    #         fids = unitary_rollout_fidelity(prob)
     #         println("\nInitial Fidelity: $fids")
 
 

src/problem_templates/quantum_state_sampling_problem.jl

@@ -16,12 +16,12 @@ function QuantumStateSamplingProblem(
     control_name::Symbol=:a,
     timestep_name::Symbol=:Δt,
     a_bound::Float64=1.0,
-    a_bounds=fill(a_bound, length(systems[1].G_drives)),
+    a_bounds=fill(a_bound, systems[1].n_drives),
     a_guess::Union{Matrix{Float64},Nothing}=nothing,
     da_bound::Float64=Inf,
-    da_bounds::Vector{Float64}=fill(da_bound, length(systems[1].G_drives)),
+    da_bounds::Vector{Float64}=fill(da_bound, systems[1].n_drives),
     dda_bound::Float64=1.0,
-    dda_bounds::Vector{Float64}=fill(dda_bound, length(systems[1].G_drives)),
+    dda_bounds::Vector{Float64}=fill(dda_bound, systems[1].n_drives),
     Δt_min::Float64=0.5 * Δt,
     Δt_max::Float64=1.5 * Δt,
     drive_derivative_σ::Float64=0.01,
@@ -40,14 +40,12 @@ function QuantumStateSamplingProblem(
     if !isnothing(init_trajectory)
         traj = init_trajectory
     else
-        n_drives = length(systems[1].G_drives)
-
         traj = initialize_trajectory(
             ψ_goals,
             ψ_inits,
             T,
             Δt,
-            n_drives,
+            systems[1].n_drives,
             (a_bounds, da_bounds, dda_bounds);
             state_name=state_name,
             control_name=control_name,
@@ -92,12 +90,12 @@ function QuantumStateSamplingProblem(
         for name ∈ names
             if piccolo_options.integrator == :pade
                 state_integrator = QuantumStatePadeIntegrator(
-                    system, name, control_name, traj;
+                    name, control_name, system, traj;
                     order=piccolo_options.pade_order
                 )
             elseif piccolo_options.integrator == :exponential
                 state_integrator = QuantumStateExponentialIntegrator(
-                    system, name, control_name, traj
+                    name, control_name, system, traj
                 )
             else
                 error("integrator must be one of (:pade, :exponential)")
@@ -165,9 +163,9 @@ end
     sys1_state_names = [n for n ∈ state_names if endswith(string(n), "1")]
 
     # Separately compute all unique initial and goal state fidelities
-    init = [fidelity(prob.trajectory, sys1, state_symb=n) for n in sys1_state_names]
+    init = [rollout_fidelity(prob.trajectory, sys1, state_symb=n) for n in sys1_state_names]
     solve!(prob, max_iter=20)
-    final = [fidelity(prob.trajectory, sys1, state_symb=n) for n in sys1_state_names]
+    final = [rollout_fidelity(prob.trajectory, sys1, state_symb=n) for n in sys1_state_names]
     @test all(final .> init)
 
     # Check that a_guess can be used
@@ -188,9 +186,9 @@ end
         robustness=false
     )
     solve!(prob_default, max_iter=20)
-    final_default = fidelity(prob_default.trajectory, sys1)
+    final_default = rollout_fidelity(prob_default.trajectory, sys1)
     # Pick any initial state
-    final_robust = fidelity(prob.trajectory, sys1, state_symb=state_names[1])
+    final_robust = rollout_fidelity(prob.trajectory, sys1, state_symb=state_names[1])
     @test final_robust > final_default
 end
 
@@ -216,8 +214,8 @@ end
     state_names = [n for n ∈ prob.trajectory.names if startswith(string(n), string(state_name))]
     sys1_state_names = [n for n ∈ state_names if endswith(string(n), "1")]
 
-    init = [fidelity(prob.trajectory, sys1, state_symb=n) for n in sys1_state_names]
+    init = [rollout_fidelity(prob.trajectory, sys1, state_symb=n) for n in sys1_state_names]
     solve!(prob, max_iter=20)
-    final = [fidelity(prob.trajectory, sys1, state_symb=n) for n in sys1_state_names]
+    final = [rollout_fidelity(prob.trajectory, sys1, state_symb=n) for n in sys1_state_names]
     @test all(final .> init)
 end

src/problem_templates/unitary_minimum_time_problem.jl

@@ -184,9 +184,9 @@ end
     )
 
     # Soft fidelity constraint
-    final_fidelity = minimum([0.99, unitary_fidelity(prob)])
+    final_fidelity = minimum([0.99, unitary_rollout_fidelity(prob)])
     mintime_prob = UnitaryMinimumTimeProblem(
-        prob, 
+        prob,
         final_fidelity=final_fidelity,
         phase_operators=phase_operators
     )
@@ -198,7 +198,7 @@ end
 
     # Quick check for using default fidelity
     @test UnitaryMinimumTimeProblem(
-        prob, 
+        prob,
         final_fidelity=final_fidelity,
         phase_operators=phase_operators
     ) isa QuantumControlProblem

src/problem_templates/unitary_smooth_pulse_problem.jl

@@ -337,7 +337,7 @@ end
 end
 @testitem "Free phase Y gate using X" begin
     using Random
-    Random.seed!(1234)
+    # Random.seed!(1234)
     phase_name = :ϕ
     phase_operators = [PAULIS[:Z]]
 
@@ -350,7 +350,7 @@ end
     )
 
     before = prob.trajectory.global_data[phase_name]
-    solve!(prob, max_iter=100)
+    solve!(prob, max_iter=50)
     after = prob.trajectory.global_data[phase_name]
 
     @test before ≠ after