def test_t1(self):
"""
Run the simulator with thermal relaxatoin noise.
Then verify that the calculated T1 matches the t1
parameter.
"""
# 25 numbers ranging from 1 to 200, linearly spaced
num_of_gates = (np.linspace(1, 200, 15)).astype(int)
gate_time = 0.11
qubits = [0]
circs, xdata = t1_circuits(num_of_gates, gate_time, qubits)
expected_t1 = 10
error = thermal_relaxation_error(expected_t1, 2*expected_t1, gate_time)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, 'id')
# TODO: Include SPAM errors
backend = qiskit.Aer.get_backend('qasm_simulator')
shots = 100
backend_result = qiskit.execute(
circs, backend,
shots=shots,
backend_options={'max_parallel_experiments': 0},
noise_model=noise_model).result()
initial_t1 = expected_t1
initial_a = 1
initial_c = 0
T1Fitter(backend_result, xdata, qubits,
fit_p0=[initial_a, initial_t1, initial_c],
fit_bounds=([0, 0, -1], [2, expected_t1*1.2, 1]))
def test_t1(self):
"""
Run the simulator with amplitude damping noise.
Then verify that the calculated T1 matches the amplitude damping
parameter.
"""
# 25 numbers ranging from 1 to 200, linearly spaced
num_of_gates = (np.linspace(1, 200, 25)).astype(int)
gate_time = 0.11
num_of_qubits = 2
qubit = 0
circs, xdata = t1_circuits(num_of_gates, gate_time, num_of_qubits,
qubit)
expected_t1 = 10
gamma = 1 - np.exp(-gate_time / expected_t1)
error = amplitude_damping_error(gamma)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, 'id')
# TODO: Include SPAM errors
backend = qiskit.Aer.get_backend('qasm_simulator')
shots = 300
backend_result = qiskit.execute(circs,
backend,
shots=shots,
backend_options={
'max_parallel_experiments': 0
},
noise_model=noise_model).result()
initial_t1 = expected_t1
initial_a = 1
initial_c = 0
fit = T1Fitter(backend_result,
shots,
xdata,
num_of_qubits,
qubit,
fit_p0=[initial_a, initial_t1, initial_c],
fit_bounds=([0, 0, -1], [2, expected_t1 * 1.2, 1]))
self.assertAlmostEqual(fit.time,
expected_t1,
delta=20,
msg='Calculated T1 is inaccurate')
self.assertTrue(
fit.time_err < 30,
'Confidence in T1 calculation is too low: ' + str(fit.time_err))
def main():
# Get backends
IBMQ.load_account()
provider = IBMQ.get_provider(hub="ibm-q-ornl", group="anl", project="chm168")
backend = provider.get_backend("ibmq_burlington")
plugin_backend = Quac.get_backend("fake_burlington_density_simulator", t1=True, t2=True, meas=False, zz=False)
# Get calibration circuits
hardware_properties = FakeBurlington().properties()
num_gates = np.linspace(10, 500, 30, dtype='int')
qubits = list(range(len(backend.properties().qubits)))
t1_circs, t1_delay = t1_circuits(num_gates,
hardware_properties.gate_length('id', [0]) * 1e9,
qubits)
t2_circs, t2_delay = t2_circuits((num_gates / 2).astype('int'),
hardware_properties.gate_length('id', [0]) * 1e9,
qubits)
# Formulate real noise model
real_noise_model = QuacNoiseModel(
t1_times=[1234, 2431, 2323, 2222, 3454],
t2_times=[12000, 14000, 14353, 20323, 30232]
)
# Formulate initial guess noise model (only same order of magnitude)
guess_noise_model = QuacNoiseModel(
t1_times=[1000, 1000, 1000, 1000, 1000],
t2_times=[10000, 10000, 10000, 10000, 10000]
)
# Calculate calibration circuit reference results
reference_job = execute(t1_circs + t2_circs, plugin_backend,
quac_noise_model=real_noise_model,
optimization_level=0)
reference_result = reference_job.result()
# Calculate optimized noise model
new_noise_model = optimize_noise_model_ng(
guess_noise_model=guess_noise_model,
circuits=t1_circs + t2_circs,
backend=plugin_backend,
reference_result=reference_result,
loss_function=angle_objective_function
)
# Show original noise model and optimized noise model
print(f"Original noise model: {real_noise_model}")
print(f"New noise model: {new_noise_model}")
def t1_circuit_execution(
) -> Tuple[qiskit.result.Result, np.array, List[int], float]:
"""
Create T1 circuits and simulate them.
Returns:
* Backend result.
* xdata.
* Qubits for the T1 measurement.
* T1 that was used in the circuits creation.
"""
# 15 numbers ranging from 1 to 200, linearly spaced
num_of_gates = (np.linspace(1, 200, 15)).astype(int)
gate_time = 0.11
qubits = [0]
circs, xdata = t1_circuits(num_of_gates, gate_time, qubits)
t1_value = 10
error = thermal_relaxation_error(t1_value, 2 * t1_value, gate_time)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, 'id')
# TODO: Include SPAM errors
backend = qiskit.Aer.get_backend('qasm_simulator')
shots = 100
backend_result = qiskit.execute(circs,
backend,
shots=shots,
seed_simulator=SEED,
backend_options={
'max_parallel_experiments': 0
},
noise_model=noise_model,
optimization_level=0).result()
return backend_result, xdata, qubits, t1_value
from qiskit.ignis.characterization.coherence import T1Fitter, T2StarFitter, T2Fitter
from qiskit.ignis.characterization.coherence import t1_circuits, t2_circuits, t2star_circuits
from qiskit import IBMQ, compile
# Measure the value of T1 (relaxation) time
# 12 numbers ranging from 10 to 1000, logarithmically spaced
# extra point at 1500
num_of_gates = np.append((np.logspace(1, 3, 12)).astype(int), np.array([1500]))
gate_time = 0.1 # time of running a single gate
# Select the qubits whose T1 are to be measured
qubits = [0]
# Generate experiments
circs, xdata = t1_circuits(num_of_gates, gate_time, qubits)
# Run the simulator
# IBMQ.backends()
#[
# <IBMQBackend('ibmqx4') from IBMQ()>,
# <IBMQBackend('ibmqx2') from IBMQ()>,
# <IBMQBackend('ibmq_16_melbourne') from IBMQ()>,
# <IBMQBackend('ibmq_qasm_simulator') from IBMQ()>
# ]
# IBMQ device information:
# https://www.research.ibm.com/ibm-q/technology/devices/#ibmqx4
backend = qiskit.Aer.get_backend('qasm_simulator')
shots = 1024
backend_result = qiskit.execute(circs, backend, shots=shots).result()
