def test_substitution_with_existing(self):
"""Test that substituting one parameter with an existing parameter works."""
schedule = pulse.Schedule()
schedule += pulse.SetFrequency(self.alpha, DriveChannel(self.qubit))
schedule.assign_parameters({self.alpha: 1e9*self.qubit})
self.assertEqual(schedule.instructions[0][1].frequency, 1e9*self.qubit)
schedule.assign_parameters({self.qubit: 2})
self.assertEqual(float(schedule.instructions[0][1].frequency), 2e9)
def test_substitution(self):
"""Test Parameter substitution (vs bind)."""
schedule = pulse.Schedule()
schedule += pulse.SetFrequency(self.alpha, DriveChannel(0))
schedule.assign_parameters({self.alpha: 2*self.beta})
self.assertEqual(schedule.instructions[0][1].frequency, 2*self.beta)
schedule.assign_parameters({self.beta: self.freq / 2})
self.assertEqual(float(schedule.instructions[0][1].frequency), self.freq)
def test_frequency(self):
"""Test parse frequency."""
sched = pulse.Schedule()
sched = sched.insert(0, pulse.ShiftFrequency(1.0, pulse.DriveChannel(0)))
sched = sched.insert(5, pulse.SetFrequency(5.0, pulse.DriveChannel(0)))
ch_events = events.ChannelEvents.load_program(sched, pulse.DriveChannel(0))
ch_events.set_config(dt=0.1, init_frequency=3.0, init_phase=0)
frames = list(ch_events.get_frame_changes())
inst_data0 = frames[0]
self.assertAlmostEqual(inst_data0.frame.freq, 1.0)
inst_data1 = frames[1]
self.assertAlmostEqual(inst_data1.frame.freq, 1.0)
def test_frequency(self):
"""Test parse frequency."""
sched = pulse.Schedule()
sched = sched.insert(0, pulse.ShiftFrequency(1.0,
pulse.DriveChannel(0)))
sched = sched.insert(5, pulse.SetFrequency(5.0, pulse.DriveChannel(0)))
events = ChannelEvents.load_program(sched, pulse.DriveChannel(0))
events.init_frequency = 3.0
frames = list(events.get_frame_changes())
_, frame, _ = frames[0]
self.assertAlmostEqual(frame.freq, 1.0)
_, frame, _ = frames[1]
self.assertAlmostEqual(frame.freq, 1.0)
def test_straight_schedule_bind(self):
"""Nothing fancy, 1:1 mapping."""
schedule = pulse.Schedule()
schedule += pulse.SetFrequency(self.alpha, DriveChannel(0))
schedule += pulse.ShiftFrequency(self.gamma, DriveChannel(0))
schedule += pulse.SetPhase(self.phi, DriveChannel(1))
schedule += pulse.ShiftPhase(self.theta, DriveChannel(1))
schedule.assign_parameters({self.alpha: self.freq, self.gamma: self.shift,
self.phi: self.phase, self.theta: -self.phase})
insts = assemble(schedule, self.backend).experiments[0].instructions
GHz = 1e9 # pylint: disable=invalid-name
self.assertEqual(float(insts[0].frequency*GHz), self.freq)
self.assertEqual(float(insts[1].frequency*GHz), self.shift)
self.assertEqual(float(insts[2].phase), self.phase)
self.assertEqual(float(insts[3].phase), -self.phase)
def test_parameter_attribute_schedule(self):
"""Test the ``parameter`` attributes."""
schedule = pulse.Schedule()
self.assertFalse(schedule.is_parameterized())
schedule += pulse.SetFrequency(self.alpha, DriveChannel(0))
self.assertEqual(schedule.parameters, {self.alpha})
schedule += pulse.ShiftFrequency(self.gamma, DriveChannel(0))
self.assertEqual(schedule.parameters, {self.alpha, self.gamma})
schedule += pulse.SetPhase(self.phi, DriveChannel(1))
self.assertTrue(schedule.is_parameterized())
self.assertEqual(schedule.parameters, {self.alpha, self.gamma, self.phi})
schedule.assign_parameters({self.phi: self.alpha, self.gamma: self.shift})
self.assertEqual(schedule.parameters, {self.alpha})
schedule.assign_parameters({self.alpha: self.beta})
self.assertEqual(schedule.parameters, {self.beta})
schedule.assign_parameters({self.beta: 10})
self.assertFalse(schedule.is_parameterized())
def test_with_function(self):
"""Test ParameterExpressions formed trivially in a function."""
def get_frequency(variable):
return 2*variable
def get_shift(variable):
return variable - 1
schedule = pulse.Schedule()
schedule += pulse.SetFrequency(get_frequency(self.alpha), DriveChannel(0))
schedule += pulse.ShiftFrequency(get_shift(self.gamma), DriveChannel(0))
schedule.assign_parameters({self.alpha: self.freq / 2, self.gamma: self.shift + 1})
insts = schedule.instructions
self.assertEqual(float(insts[0][1].frequency), self.freq)
self.assertEqual(float(insts[1][1].frequency), self.shift)
def test_multiple_parameters(self):
"""Expressions of parameters with partial assignment."""
schedule = pulse.Schedule()
schedule += pulse.SetFrequency(self.alpha + self.beta, DriveChannel(0))
schedule += pulse.ShiftFrequency(self.gamma + self.beta, DriveChannel(0))
schedule += pulse.SetPhase(self.phi, DriveChannel(1))
# Partial bind
delta = 1e9
schedule.assign_parameters({self.alpha: self.freq - delta})
schedule.assign_parameters({self.beta: delta})
schedule.assign_parameters({self.gamma: self.shift - delta})
schedule.assign_parameters({self.phi: self.phase})
insts = schedule.instructions
self.assertEqual(float(insts[0][1].frequency), self.freq)
self.assertEqual(float(insts[1][1].frequency), self.shift)
self.assertEqual(float(insts[2][1].phase), self.phase)
