def test_parallel_map_fw_prop_step_loky(transmon_xgate_system):
"""Test optimization with parallel_map parameter, using loky."""
objectives, pulse_options, tlist = transmon_xgate_system
krotov.parallelization.USE_LOKY = True
log = io.StringIO()
opt_result_loky = krotov.optimize_pulses(
objectives,
pulse_options,
tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
info_hook=partial(krotov.info_hooks.print_debug_information, out=log),
iter_stop=1,
skip_initial_forward_propagation=True,
parallel_map=(
krotov.parallelization.parallel_map,
krotov.parallelization.parallel_map,
krotov.parallelization.parallel_map_fw_prop_step,
),
)
tau1_loky = abs(opt_result_loky.tau_vals[0][0])
tau2_loky = abs(opt_result_loky.tau_vals[0][1])
assert abs(tau1_loky - 0.9693) < 1e-3
assert abs(tau2_loky - 0.7743) < 1e-3
krotov.parallelization.USE_LOKY = False
# in order to be pickleable, all functions must be defined in a module
# (transmon_xgate_system_mod)
H = transmon_xgate_system_mod.transmon_hamiltonian()
pulse_options = {
H[1][1]: dict(lambda_a=1, update_shape=transmon_xgate_system_mod.S)
}
psi0, psi1 = transmon_xgate_system_mod.logical_basis(H)
objectives = krotov.gate_objectives(
basis_states=[psi0, psi1], gate=qutip.operators.sigmax(), H=H
)
try:
opt_result = krotov.optimize_pulses(
objectives,
pulse_options,
tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
iter_stop=1,
skip_initial_forward_propagation=True,
parallel_map=(
krotov.parallelization.parallel_map,
krotov.parallelization.parallel_map,
krotov.parallelization.parallel_map_fw_prop_step,
),
)
tau1 = abs(opt_result.tau_vals[0][0])
tau2 = abs(opt_result.tau_vals[0][1])
assert abs(tau1_loky - tau1) < 1e-12
assert abs(tau2_loky - tau2) < 1e-12
except RuntimeError:
# parallelization without LOKY doesn't work on all platforms
pass
def test_zero_iterations(iter_stop, simple_state_to_state_system):
objectives, pulse_options, tlist = simple_state_to_state_system
with io.StringIO() as log_fh:
result = krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
store_all_pulses=True,
info_hook=krotov.info_hooks.print_table(
J_T=krotov.functionals.J_T_re, out=log_fh
),
iter_stop=iter_stop,
skip_initial_forward_propagation=True,
)
log = log_fh.getvalue()
assert len(log.splitlines()) == 2
assert result.message == 'Reached 0 iterations'
assert len(result.guess_controls) == 1 # one control field
assert len(result.guess_controls) == len(result.optimized_controls)
assert len(result.guess_controls[0]) == len(result.tlist)
assert len(result.optimized_controls[0]) == len(result.tlist)
for (c1, c2) in zip(result.guess_controls, result.optimized_controls):
assert np.all(c1 == c2)
for pulses_for_iteration in result.all_pulses:
for pulse in pulses_for_iteration:
# the pulses are defined on the *intervals* of tlist
assert len(pulse) == len(result.tlist) - 1
def test_infohook_chaining(transmon_ham_and_states):
"""Test that transmon_ham_and_states and info_hooks get chained together
correctly. This tests a whole bunch of implementation details:
- return values from multiple info_hooks combine in tuple
- return value None (from modify_params_after_iter) gets ignored
- shared_data gets passed along through multiple hooks
- shared_data is cleared in each iteration
"""
H, psi0, psi1 = transmon_ham_and_states
obj = krotov.Objective(initial_state=psi0, target=psi1, H=H)
tlist = np.array([0, 0.01, 0.02])
pulse_options = {H[1][1]: dict(lambda_a=1, update_shape=1)}
stdout = io.StringIO()
def adjust_lambda_a(**args):
λₐ = args['lambda_vals'][0]
args['lambda_vals'][0] *= 0.5
if 'messages' not in args['shared_data']:
args['shared_data']['messages'] = []
args['shared_data']['messages'].append(
'λₐ: %s → %s' % (λₐ, args['lambda_vals'][0])
)
def print_fidelity(**args):
F_re = np.average(np.array(args['tau_vals']).real)
print("Iteration %d: \tF = %f" % (args['iteration'], F_re))
return F_re
def print_messages(**args):
if 'messages' in args['shared_data']:
message = "; ".join(
[msg for msg in args['shared_data']['messages']]
)
print("\tmsg: " + message)
return message
with contextlib.redirect_stdout(stdout):
oct_result = krotov.optimize_pulses(
[obj],
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
info_hook=krotov.info_hooks.chain(print_fidelity, print_messages),
modify_params_after_iter=adjust_lambda_a,
iter_stop=2,
)
assert len(oct_result.info_vals) == 3
assert isinstance(oct_result.info_vals[1], tuple)
assert len(oct_result.info_vals[1]) == 2
assert abs(oct_result.info_vals[1][0] - 0.001978333994757067) < 1e-8
assert oct_result.info_vals[1][1] == 'λₐ: 0.5 → 0.25'
assert 'Iteration 0: \tF = 0.000000' in stdout.getvalue()
assert 'msg: λₐ: 1.0 → 0.5' in stdout.getvalue()
assert 'Iteration 1: \tF = 0.001978' in stdout.getvalue()
assert 'msg: λₐ: 0.5 → 0.25' in stdout.getvalue()
def test_complex_control_rejection():
"""Test that complex controls are rejected"""
H0 = qutip.Qobj(0.5 * np.diag([-1, 1]))
H1 = qutip.Qobj(np.mat([[1, 2], [3, 4]]))
psi0 = qutip.Qobj(np.array([1, 0]))
psi1 = qutip.Qobj(np.array([0, 1]))
def eps0(t, args):
return 0.2 * np.exp(1j * t)
def S(t):
"""Shape function for the field update"""
return krotov.shapes.flattop(
t, t_start=0, t_stop=5, t_rise=0.3, t_fall=0.3, func='sinsq'
)
H = [H0, [H1, eps0]]
objectives = [krotov.Objective(initial_state=psi0, target=psi1, H=H)]
pulse_options = {H[1][1]: dict(lambda_a=5, update_shape=S)}
tlist = np.linspace(0, 5, 500)
with pytest.raises(ValueError) as exc_info:
krotov.optimize_pulses(
objectives,
pulse_options,
tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
iter_stop=0,
)
assert 'all controls must be real-valued' in str(exc_info.value)
def S2(t):
"""Shape function for the field update"""
return 2.0 * krotov.shapes.flattop(
t, t_start=0, t_stop=5, t_rise=0.3, t_fall=0.3, func='sinsq'
)
def test_print_table_custom_header(request, simple_state_to_state_system):
"""Test print_table with custom col_formats."""
objectives, pulse_options, tlist = simple_state_to_state_system
testdir = Path(os.path.splitext(request.module.__file__)[0])
with io.StringIO() as log_fh:
krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
store_all_pulses=True,
info_hook=krotov.info_hooks.print_table(
J_T=krotov.functionals.J_T_re,
col_headers=(
'iteration',
' final time functional',
' running cost (pulse {l})',
' total running cost',
' total functional',
' change in final time functional',
' change in total functional',
' seconds for iteration',
),
show_g_a_int_per_pulse=True,
out=log_fh,
),
iter_stop=1,
skip_initial_forward_propagation=True,
)
log = log_fh.getvalue()
expected_log = (testdir /
'custom_header_out.txt').read_text(encoding='utf8')
for (ln, ln_e) in zip(log.splitlines(), expected_log.splitlines()):
# we have to remove the secs in the last column (not stable)
assert ln[:-2] == ln_e[:-2]
def test_numpy_controls(numpy_control_system):
"""Test optimization with numpy array controls.
Test the resolution of https://github.com/qucontrol/krotov/issues/79
"""
tlist, objectives, pulse_options = numpy_control_system
opt_result = krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_ss,
check_convergence=krotov.convergence.Or(
krotov.convergence.value_below('1e-3', name='J_T'),
krotov.convergence.check_monotonic_error,
),
iter_stop=0,
skip_initial_forward_propagation=True,
)
assert opt_result.message == 'Reached 0 iterations'
ax.set_ylabel('Population')
plt.show()
proj_G = psi_0 * psi_0.dag()
proj_GHZ = target_state * target_state.dag()
if SHOW_PLOTS and not CONTINUE_FROM:
guess_dynamics = objectives[0].mesolve(norm_t_list, e_ops=[proj_G, proj_GHZ])
plot_population(guess_dynamics)
opt_result = krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=norm_t_list,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
# info_hook=krotov.info_hooks.print_table(J_T=krotov.functionals.J_T_re),
# info_hook=krotov.info_hooks.chain(krotov.info_hooks.print_debug_information, print_fidelity),
info_hook=print_fidelity,
# check_convergence=krotov.convergence.check_monotonic_error,
iter_stop=40,
continue_from=Result.load(OPT_RESULT_DUMP, objectives=objectives) if CONTINUE_FROM else None
)
dump_file_name = OPT_RESULT_DUMP if not CONTINUE_FROM else OPT_RESULT_DUMP + "_1"
opt_result.dump(dump_file_name)
print(opt_result)
if SHOW_PLOTS:
plot_pulse(opt_result.optimized_controls[0], norm_t_list, "Optimised $\Omega$")
plot_pulse(opt_result.optimized_controls[1], norm_t_list, "Optimised $\Delta$")
qutip.ket("0"), qutip.ket("0"),
qutip.ket("0")),
target=qutip.tensor(qutip.ket("0"), qutip.ket("1"),
qutip.ket("1"), qutip.ket("1"),
qutip.ket("1"), qutip.ket("1"),
qutip.ket("1")),
H=H)
]
opt_result = krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_ss,
info_hook=krotov.info_hooks.print_table(J_T=krotov.functionals.J_T_ss),
check_convergence=krotov.convergence.Or(
krotov.convergence.value_below('5e-3', name='J_T'),
krotov.convergence.check_monotonic_error,
),
store_all_pulses=True,
)
plot_iterations(opt_result)
from numpy import linalg as npla
def eigenvalues(A):
eigenValues, eigenVectors = npla.eig(A)
idx = np.argsort(eigenValues)
eigenValues = eigenValues[idx]
plt.legend()
fig.savefig('EField6cells.png')
# NBVAL_IGNORE_OUTPUT
# the DensityMatrixODEPropagator is not sufficiently exact to guarantee that
# you won't get slightly different results in the optimization when
# running this on different systems
opt_result = krotov.optimize_pulses(
objectives,
pulse_options,
tlist,
iter_stop=20000,
propagator=krotov.propagators.DensityMatrixODEPropagator(atol=1e-10,
rtol=1e-8),
chi_constructor=chis_qubit,
info_hook=krotov.info_hooks.chain(
krotov.info_hooks.print_debug_information, print_qubit_error),
check_convergence=krotov.convergence.Or(
krotov.convergence.value_below('5e-3', name='J_T'),
krotov.convergence.check_monotonic_error,
),
store_all_pulses=True,
)
plot_iterations(opt_result)
opt_result
from numpy import linalg as npla
def optimize(self):
# We can now call any Python lib to
# perform pulse optimization (marshalling the options/parameters if required)
# For example, one can use Qutip pulse optimization:
# Notes about data types:
# - targerU: flatten (row-by-row) U matrix into a 1-D array of complex numbers
# - H0: string-type representation of the static Hamiltonian:
# e.g.: 0.123 Z0Z1
# - Hops: array of strings represent terms on the Hamiltonian which can be controlled.
# Depending on the specific library we use for pulse optimization,
# we may need to marshal these data types accordingly.
# Run the optimization
H = self.construct_hamiltonian()
tlist = np.arange(0.0, self.tMax, self.dt)
# TODO: this should be an IR transformation option
def S(t):
"""Shape function for the field update"""
return krotov.shapes.flattop(
t,
t_start=0,
t_stop=self.tMax,
t_rise=self.tMax / self.rise_fall_coeff,
t_fall=self.tMax / self.rise_fall_coeff,
func=self.func_name)
pulse_options = {H[1][1]: dict(lambda_a=self.lambda_a, update_shape=S)}
print('Krotov: Target Unitary Object:')
print(self.targetObj())
objectives = krotov.gate_objectives(
# Target is the unitary: i.e. transform all states -> expected result.
basis_states=self.logical_basis(),
gate=self.targetObj(),
H=H)
opt_result = krotov.optimize_pulses(
objectives,
pulse_options,
tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_ss,
info_hook=krotov.info_hooks.print_table(
J_T=krotov.functionals.J_T_ss),
check_convergence=krotov.convergence.Or(
krotov.convergence.value_below('1e-3', name='J_T'),
krotov.convergence.check_monotonic_error,
),
store_all_pulses=True,
)
plotFile = self.plot_control_field_iterations(opt_result)
print(opt_result)
print('*************************************************')
print('**Plot of control field iterations is saved to:**')
print(plotFile)
print('*************************************************')
pulse = opt_result.optimized_controls[0]
return (0.0, pulse)
def test_reject_invalid_shapes():
"""Test that invalid control shapes are rejected"""
H0 = qutip.Qobj(0.5 * np.diag([-1, 1]))
H1 = qutip.Qobj(np.mat([[1, 2], [3, 4]]))
psi0 = qutip.Qobj(np.array([1, 0]))
psi1 = qutip.Qobj(np.array([0, 1]))
def eps0(t, args):
return 0.2
H = [H0, [H1, eps0]]
objectives = [krotov.Objective(initial_state=psi0, target=psi1, H=H)]
tlist = np.linspace(0, 5, 500)
def S_complex(t):
"""Shape function for the field update"""
return 1j * krotov.shapes.flattop(
t, t_start=0, t_stop=5, t_rise=0.3, t_fall=0.3, func='sinsq'
)
def S_negative(t):
"""Shape function for the field update"""
return -1 * krotov.shapes.flattop(
t, t_start=0, t_stop=5, t_rise=0.3, t_fall=0.3, func='sinsq'
)
def S_large(t):
"""Shape function for the field update"""
return 2 * krotov.shapes.flattop(
t, t_start=0, t_stop=5, t_rise=0.3, t_fall=0.3, func='sinsq'
)
with pytest.raises(ValueError) as exc_info:
pulse_options = {H[1][1]: dict(lambda_a=5, update_shape=S_complex)}
krotov.optimize_pulses(
objectives,
pulse_options,
tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
iter_stop=0,
)
assert 'must be real-valued' in str(exc_info.value)
with pytest.raises(ValueError) as exc_info:
pulse_options = {H[1][1]: dict(lambda_a=5, update_shape=S_negative)}
krotov.optimize_pulses(
objectives,
pulse_options,
tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
iter_stop=0,
)
assert 'must have values in the range [0, 1]' in str(exc_info.value)
with pytest.raises(ValueError) as exc_info:
pulse_options = {H[1][1]: dict(lambda_a=5, update_shape=S_large)}
krotov.optimize_pulses(
objectives,
pulse_options,
tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
iter_stop=0,
)
assert 'must have values in the range [0, 1]' in str(exc_info.value)
def test_continue_optimization(
simple_state_to_state_system, request, tmpdir, caplog
):
"""Big integration test for a simple optimization, with various
uses of `continue_from`. This covers a lot of edge cases not covered by the
example notebooks.
"""
objectives, pulse_options, tlist = simple_state_to_state_system
dumpfile = str(tmpdir.join("oct_result_{iter:03d}.dump"))
logfile = str(tmpdir.join("oct.log"))
testdir = os.path.splitext(request.module.__file__)[0]
logfile_expected = os.path.join(testdir, 'oct.log')
with open(logfile, 'w', encoding='utf8') as log_fh:
# initial optimization
with caplog.at_level(logging.WARNING):
oct_result1 = krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
store_all_pulses=True,
info_hook=krotov.info_hooks.print_table(
J_T=krotov.functionals.J_T_re, out=log_fh
),
check_convergence=krotov.convergence.Or(
krotov.convergence.check_monotonic_error,
krotov.convergence.dump_result(dumpfile, every=2),
),
iter_stop=3,
skip_initial_forward_propagation=True,
# not officially supported, but should work in this case
)
assert (
"You should not use `skip_initial_forward_propagation`"
in caplog.text
)
assert len(oct_result1.iters) == 4 # 0 ... 3
assert len(oct_result1.iter_seconds) == 4
assert len(oct_result1.info_vals) == 4
assert len(oct_result1.all_pulses) == 4
assert len(oct_result1.states) == 1
assert "3 iterations" in oct_result1.message
# another 2 iterations
oct_result2 = krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
store_all_pulses=True,
info_hook=krotov.info_hooks.print_table(
J_T=krotov.functionals.J_T_re, out=log_fh
),
check_convergence=krotov.convergence.Or(
krotov.convergence.check_monotonic_error,
krotov.convergence.dump_result(dumpfile, every=2),
),
continue_from=oct_result1,
iter_stop=5,
)
assert len(oct_result2.iters) == 6 # 0 ... 5
assert len(oct_result2.iter_seconds) == 6
assert len(oct_result2.info_vals) == 6
assert len(oct_result2.all_pulses) == 6
assert len(oct_result2.states) == 1
assert "5 iterations" in oct_result2.message
# and 2 more (skipping initial propagation)
oct_result3 = krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
store_all_pulses=True,
info_hook=krotov.info_hooks.print_table(
J_T=krotov.functionals.J_T_re, out=log_fh
),
check_convergence=krotov.convergence.Or(
krotov.convergence.check_monotonic_error,
krotov.convergence.dump_result(dumpfile, every=2),
),
continue_from=oct_result2,
iter_stop=7,
skip_initial_forward_propagation=True,
)
assert len(oct_result3.iters) == 8 # 0 ... 7
assert len(oct_result3.iter_seconds) == 8
assert len(oct_result3.info_vals) == 8
assert len(oct_result3.all_pulses) == 8
assert len(oct_result3.states) == 1
assert "7 iterations" in oct_result3.message
# no-op: already anough iterations
oct_result4 = krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
store_all_pulses=True,
info_hook=krotov.info_hooks.print_table(
J_T=krotov.functionals.J_T_re, out=log_fh
),
check_convergence=krotov.convergence.Or(
krotov.convergence.check_monotonic_error,
krotov.convergence.dump_result(dumpfile, every=2),
),
continue_from=oct_result3,
iter_stop=5, # < 7 in oct_result3
skip_initial_forward_propagation=True,
)
assert len(oct_result4.iters) == 8 # 0 ... 7
assert len(oct_result4.iter_seconds) == 8
assert len(oct_result4.info_vals) == 8
assert len(oct_result4.all_pulses) == 8
assert len(oct_result4.states) == 1
assert "7 iterations" in oct_result4.message
assert (
oct_result4.start_local_time_str
== oct_result3.start_local_time_str
)
assert oct_result4.iters == oct_result3.iters
assert oct_result4.message == oct_result3.message
# fmt: off
# check the combined log file
if not os.path.isfile(logfile_expected):
copyfile(logfile, logfile_expected)
with open(logfile, encoding='utf8') as fh1, open(logfile_expected, encoding='utf8') as fh2:
for line1 in fh1:
line2 = next(fh2)
assert line1[:65] == line2[:65]
# fmt: on
# continue from an incomplete dump file
with caplog.at_level(logging.WARNING):
result = krotov.result.Result.load(
str(tmpdir.join("oct_result_004.dump"))
)
assert 'Result.objectives contains control placeholders' in caplog.text
with pytest.raises(ValueError) as exc_info:
oct_result5 = krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
store_all_pulses=True,
check_convergence=krotov.convergence.Or(
krotov.convergence.check_monotonic_error,
krotov.convergence.dump_result(dumpfile, every=2),
),
continue_from=result,
iter_stop=7,
skip_initial_forward_propagation=True,
)
assert "objectives must remain unchanged" in str(exc_info.value)
result = krotov.result.Result.load(
str(tmpdir.join("oct_result_004.dump")), objectives=objectives
)
assert result.iters[-1] == 4
oct_result5 = krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
store_all_pulses=True,
info_hook=krotov.functionals.J_T_re,
check_convergence=krotov.convergence.Or(
krotov.convergence.check_monotonic_error,
krotov.convergence.dump_result(dumpfile, every=2),
),
continue_from=result,
iter_stop=7,
skip_initial_forward_propagation=True,
)
assert oct_result5.iters == oct_result3.iters
assert len(oct_result5.iter_seconds) == 8
assert len(oct_result5.info_vals) == 8
assert len(oct_result5.all_pulses) == 8
assert "7 iterations" in oct_result5.message
Δ = np.max(
np.abs(
oct_result5.optimized_controls[-1]
- oct_result3.optimized_controls[-1]
)
)
assert Δ < 1e-10
# broken continuation: different number of objectives
result_with_extra_objective = deepcopy(result)
result_with_extra_objective.objectives.append(
deepcopy(result.objectives[0])
)
with pytest.raises(ValueError) as exc_info:
krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
continue_from=result_with_extra_objective,
)
assert "number of objectives must be the same" in str(exc_info.value)
# broken continuation: different value for store_all_pulses
with pytest.raises(ValueError) as exc_info:
krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
continue_from=result,
store_all_pulses=False,
)
assert "store_all_pulses parameter cannot be changed" in str(
exc_info.value
)
# broken continuation: different time units
result_with_scaled_tlist = deepcopy(result)
result_with_scaled_tlist.objectives = result.objectives
result_with_scaled_tlist.tlist *= 2
with pytest.raises(ValueError) as exc_info:
krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
continue_from=result_with_scaled_tlist,
store_all_pulses=True,
)
assert "same time grid" in str(exc_info.value)
# broken continuation: changed nt
result_with_changed_nt = deepcopy(result)
result_with_changed_nt.objectives = result.objectives
result_with_changed_nt.tlist = np.linspace(0, 5, 1000)
with pytest.raises(ValueError) as exc_info:
krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
continue_from=result_with_changed_nt,
store_all_pulses=True,
)
assert "same time grid" in str(exc_info.value)
# incongruent controls
result_with_incongruent_pulse = deepcopy(result)
result_with_incongruent_pulse.objectives = result.objectives
result_with_incongruent_pulse.optimized_controls[0] = np.stack(
[result.optimized_controls[0], result.optimized_controls[0]]
).flatten()
with pytest.raises(ValueError) as exc_info:
krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
continue_from=result_with_incongruent_pulse,
store_all_pulses=True,
)
assert "optimized_controls and tlist are incongruent" in str(
exc_info.value
)
# passing complete garbage to `continue_from`
with pytest.raises(ValueError) as exc_info:
krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
continue_from=result.objectives[0],
store_all_pulses=True,
)
assert "only possible from a Result object" in str(exc_info.value)
plot_population(guess_dynamics[1])
pulse_options = {H[1][1]: dict(lambda_a=1, update_shape=S)}
opt_result = krotov.optimize_pulses(
objectives,
pulse_options,
tlist,
propagator=krotov.propagators.expm,
chi_constructor=krotov.functionals.chis_re,
info_hook=krotov.info_hooks.print_table(
J_T=krotov.functionals.J_T_re,
show_g_a_int_per_pulse=True,
unicode=False,
),
check_convergence=krotov.convergence.Or(
krotov.convergence.value_below(1e-3, name='J_T'),
krotov.convergence.delta_below(1e-5),
krotov.convergence.check_monotonic_error,
),
iter_stop=5,
parallel_map=(
krotov.parallelization.parallel_map,
krotov.parallelization.parallel_map,
krotov.parallelization.parallel_map_fw_prop_step,
),
)
plot_pulse(opt_result.optimized_controls[0], tlist)
plot_spectrum(opt_result.optimized_controls[0], tlist, xlim=(0, 40))
