def test_disassemble_single_schedule(self):
"""Test disassembling a single schedule.
"""
d0 = pulse.DriveChannel(0)
d1 = pulse.DriveChannel(1)
with pulse.build(self.backend) as sched:
with pulse.align_right():
pulse.play(pulse.library.Constant(10, 1.0), d0)
pulse.set_phase(1.0, d0)
pulse.shift_phase(3.11, d0)
pulse.set_frequency(1e9, d0)
pulse.shift_frequency(1e7, d0)
pulse.delay(20, d0)
pulse.delay(10, d1)
pulse.play(pulse.library.Constant(8, 0.1), d1)
pulse.measure_all()
qobj = assemble(sched, backend=self.backend, shots=2000)
scheds, run_config_out, _ = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.memory_slots, 2)
self.assertEqual(run_config_out.shots, 2000)
self.assertEqual(run_config_out.memory, False)
self.assertEqual(run_config_out.meas_level, 2)
self.assertEqual(run_config_out.meas_lo_freq,
self.backend.defaults().meas_freq_est)
self.assertEqual(run_config_out.qubit_lo_freq,
self.backend.defaults().qubit_freq_est)
self.assertEqual(run_config_out.rep_time, 99)
self.assertEqual(len(scheds), 1)
self.assertEqual(scheds[0], sched)
def test_set_frequency(self):
"""Test set frequency instruction."""
d0 = pulse.DriveChannel(0)
with pulse.build() as schedule:
pulse.set_frequency(1e9, d0)
reference = pulse.Schedule()
reference += instructions.SetFrequency(1e9, d0)
self.assertEqual(schedule, reference)
def test_disassemble_multiple_schedules(self):
"""Test disassembling multiple schedules, all should have the same config.
"""
d0 = pulse.DriveChannel(0)
d1 = pulse.DriveChannel(1)
with pulse.build(self.backend) as sched0:
with pulse.align_right():
pulse.play(pulse.library.Constant(10, 1.0), d0)
pulse.set_phase(1.0, d0)
pulse.shift_phase(3.11, d0)
pulse.set_frequency(1e9, d0)
pulse.shift_frequency(1e7, d0)
pulse.delay(20, d0)
pulse.delay(10, d1)
pulse.play(pulse.library.Constant(8, 0.1), d1)
pulse.measure_all()
with pulse.build(self.backend) as sched1:
with pulse.align_right():
pulse.play(pulse.library.Constant(8, 0.1), d0)
pulse.play(pulse.library.Waveform([0., 1.]), d1)
pulse.set_phase(1.1, d0)
pulse.shift_phase(3.5, d0)
pulse.set_frequency(2e9, d0)
pulse.shift_frequency(3e7, d1)
pulse.delay(20, d1)
pulse.delay(10, d0)
pulse.play(pulse.library.Constant(8, 0.4), d1)
pulse.measure_all()
qobj = assemble([sched0, sched1], backend=self.backend, shots=2000)
scheds, run_config_out, _ = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.memory_slots, 2)
self.assertEqual(run_config_out.shots, 2000)
self.assertEqual(run_config_out.memory, False)
self.assertEqual(len(scheds), 2)
self.assertEqual(scheds[0], sched0)
self.assertEqual(scheds[1], sched1)
def output(data):
print("We have F: ", data.F, " nT")
N_delta = 2
N = int(math.log(data.T_2 * 10 ** (-6) / data.t_init) / math.log(2))-N_delta
multiplier = 30
# Ramsey experiment parameters
detuning_max_MHz = data.const * data.F_max * data.F_degree / (2 * math.pi) / MHz / multiplier
detuning_min_MHz = data.const * data.F_min * data.F_degree / (2 * math.pi) / MHz / multiplier
detuning_MHz = data.const * data.F * data.F_degree / (2 * math.pi) / MHz / multiplier
delta_min_det_MHz = -0.05 - 0.02 - 0.12 - 0.22
delta_max_det_MHz = -0.05 - 0.05 - 0.05 - 0.12 - 0.20
detuning_MHz = (detuning_min_MHz+delta_min_det_MHz) + (detuning_max_MHz+delta_max_det_MHz - (detuning_min_MHz+delta_min_det_MHz))*(detuning_MHz - detuning_min_MHz)/(detuning_max_MHz-detuning_min_MHz)
times = [data.t_init*2**(i) for i in range(N)]
# Drive parameters
# The drive amplitude for pi/2 is simply half the amplitude of the pi pulse
drive_amp = pi_amp / 2
# x_90 is a concise way to say pi_over_2; i.e., an X rotation of 90 degrees
with pulse.build(backend) as x90_pulse:
drive_duration = get_closest_multiple_of_16(pulse.seconds_to_samples(drive_duration_sec))
drive_sigma = pulse.seconds_to_samples(drive_sigma_sec)
drive_chan = pulse.drive_channel(qubit)
pulse.play(pulse.Gaussian(duration=drive_duration,
amp=drive_amp,
sigma=drive_sigma,
name='x90_pulse'), drive_chan)
# create schedules for Ramsey experiment
ramsey_schedules = []
ramsey_frequency = round(precise_qubit_freq + detuning_MHz * MHz, 6) # need ramsey freq in Hz
for time in times:
with pulse.build(backend=backend, default_alignment='sequential',
name=f"det = {detuning_MHz} MHz") as ramsey_schedule:
drive_chan = pulse.drive_channel(qubit)
pulse.set_frequency(ramsey_frequency, drive_chan)
pulse.call(x90_pulse)
pulse.delay(get_closest_multiple_of_16(pulse.seconds_to_samples(time*multiplier)), drive_chan)
pulse.call(x90_pulse)
pulse.measure(qubits=[qubit], registers=[pulse.MemorySlot(mem_slot)])
ramsey_schedules.append(ramsey_schedule)
# Execution settings
num_shots = data.num_of_repetitions
job = backend.run(ramsey_schedules,
meas_level=1,
meas_return='single',
shots=num_shots)
job_monitor(job)
ramsey_results = job.result(timeout=120)
ramsey_values = {}
for i in range(len(times)):
iq_data = ramsey_results.get_memory(i)[:, qubit] * scale_factor
ramsey_values[times[i]]=int(round(sum(map(classify, iq_data)) / num_shots))
'''
times = [data.t_init * 2 ** (i) for i in range(N, N+N_delta)]
# create schedules for Ramsey experiment
ramsey_schedules = []
ramsey_frequency = round(precise_qubit_freq + detuning_MHz * MHz, 6) # need ramsey freq in Hz
for time in times:
with pulse.build(backend=backend, default_alignment='sequential',
name=f"det = {detuning_MHz} MHz") as ramsey_schedule:
drive_chan = pulse.drive_channel(qubit)
pulse.set_frequency(ramsey_frequency, drive_chan)
pulse.call(x90_pulse)
pulse.delay(get_closest_multiple_of_16(pulse.seconds_to_samples(time * multiplier)), drive_chan)
pulse.call(x90_pulse)
pulse.measure(qubits=[qubit], registers=[pulse.MemorySlot(mem_slot)])
ramsey_schedules.append(ramsey_schedule)
# Execution settings
num_shots = data.num_of_repetitions
job = backend.run(ramsey_schedules,
meas_level=1,
meas_return='single',
shots=num_shots)
job_monitor(job)
ramsey_results = job.result(timeout=120)
for i in range(len(times)):
iq_data = ramsey_results.get_memory(i)[:, qubit] * scale_factor
ramsey_values[times[i]] = int(round(sum(map(classify, iq_data)) / num_shots))
#'''
print(ramsey_values)
return ramsey_values
#print(output(data))
# Drive pulse parameters (us = microseconds)
drive_sigma_sec = 0.075 * us # This determines the actual width
drive_duration_sec = drive_sigma_sec * 8 # This is a truncating parameter, because
# gaussians don't have a natural
drive_amp = 0.05 # finite length
# Creare il programma di base
# Start with drive pulse acting on the drive channel
freq = Parameter('freq')
with pulse.build(backend=backend, default_alignment='sequential',
name='Frequency sweep') as sweep_sched:
drive_duration = get_closest_multiple_of_16(pulse.seconds_to_samples(drive_duration_sec))
drive_sigma = pulse.seconds_to_samples(drive_sigma_sec)
drive_chan = pulse.drive_channel(qubit)
pulse.set_frequency(freq, drive_chan)
# Drive pulse samples
pulse.play(pulse.Gaussian(duration=drive_duration,
sigma=drive_sigma,
amp=drive_amp,
name='freq_sweep_excitation_pulse'), drive_chan)
# Define our measurement pulse
pulse.measure(qubits=[qubit], registers=[pulse.MemorySlot(mem_slot)])
# Create the frequency settings for the sweep (MUST BE IN HZ)
frequencies_Hz = frequencies_GHz*GHz
schedules = [sweep_sched.assign_parameters({freq : f}, inplace=False)
for f in frequencies_Hz]
schedules[0].draw() #Argomento backend=backend
