def test_seconds_to_samples(self):
"""Test samples to time"""
config = self.backend.configuration()
config.dt = 0.1
with pulse.build(self.backend):
samples = pulse.seconds_to_samples(10)
self.assertTrue(isinstance(samples, int))
self.assertEqual(pulse.seconds_to_samples(10), 100)
def test_seconds_to_samples_array(self):
"""Test time to samples (array format)."""
config = self.backend.configuration()
config.dt = 0.1
with pulse.build(self.backend):
times = np.array([10, 20, 30])
samples = pulse.seconds_to_samples(times)
self.assertTrue(np.issubdtype(samples.dtype, np.integer))
np.testing.assert_allclose(pulse.seconds_to_samples(times), np.array([100, 200, 300]))
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))
from qiskit import pulse
from qiskit.circuit import Parameter
# 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