def run(self, run_input, **options):
"""
Run the Tphi backend
"""
self.options.update_options(**options)
shots = 1000
t1_circuits = []
t2ramsey_circuits = []
for circ in run_input:
if circ.metadata["composite_metadata"][0]["experiment_type"] == "T1":
t1_circuits.append(circ)
elif circ.metadata["composite_metadata"][0]["experiment_type"] == "T2Ramsey":
t2ramsey_circuits.append(circ)
else:
raise ValueError("Illegal name for circuit in Tphi")
job_t1 = self._internal_backends["T1"].run(run_input=t1_circuits, shots=shots)
job_t2ramsey = self._internal_backends["T2*"].run(run_input=t2ramsey_circuits, shots=shots)
final_results = job_t1.result().results + job_t2ramsey.result().results
result_for_fake = Result(
backend_name="Tphi backend",
backend_version="0",
qobj_id="0",
job_id="0",
success=True,
results=final_results,
status="JobStatus.DONE",
)
return FakeJob(self, result_for_fake)
def run(self, run_input, **options):
result = {
"backend_name": "Dummmy backend",
"backend_version": "0",
"qobj_id": uuid.uuid4().hex,
"job_id": uuid.uuid4().hex,
"success": True,
"results": [],
}
return FakeJob(backend=self, result=Result.from_dict(result))
def run(self, run_input, **options):
"""Run the restless backend."""
self.options.update_options(**options)
shots = self.options.get("shots")
meas_level = self.options.get("meas_level")
result = {
"backend_name": f"{self.__class__.__name__}",
"backend_version": "0",
"qobj_id": 0,
"job_id": 0,
"success": True,
"results": [],
}
self._compute_outcome_probabilities(run_input)
if run_input[0].num_qubits != 2:
raise DataProcessorError(f"{self.__class__.__name__} is a two qubit mock device.")
prev_outcome, state_strings = "00", self._get_state_strings(2)
# Setup the list of dicts where each dict corresponds to a circuit.
sorted_memory = [{"memory": [], "metadata": circ.metadata} for circ in run_input]
for _ in range(shots):
for circ_idx, _ in enumerate(run_input):
probs = self._precomputed_probabilities[(circ_idx, prev_outcome)]
# Generate the next shot dependent on the pre-computed probabilities.
outcome = self._rng.choice(state_strings, p=probs)
# Append the single shot to the memory of the corresponding circuit.
sorted_memory[circ_idx]["memory"].append(hex(int(outcome, 2)))
prev_outcome = outcome
for idx, circ in enumerate(run_input):
counts = {}
for key1, key2 in zip(["00", "01", "10", "11"], ["0x0", "0x1", "0x2", "0x3"]):
counts[key1] = sorted_memory[idx]["memory"].count(key2)
run_result = {
"shots": shots,
"success": True,
"header": {"metadata": circ.metadata},
"meas_level": meas_level,
"data": {
"counts": counts,
"memory": sorted_memory[idx]["memory"],
},
}
result["results"].append(run_result)
return FakeJob(self, Result.from_dict(result))
def run(self, run_input: List[QuantumCircuit], **options) -> FakeJob:
"""
Run the IQ backend.
Args:
run_input(List[QuantumCircuit]): A list of QuantumCircuit for which the backend will generate
data for.
**options: Experiment options. the options that are supported in this backend are
'meas_level' and 'meas_return'.
'meas_level': To generate data in the IQ plain, 'meas_level' should be assigned 1 or
MeasLevel.KERNELED. If 'meas_level' is 2 or MeasLevel.CLASSIFIED, the generated data
will be in the form of 'counts'.
'meas_return': This option will only take effect if 'meas_level' = MeasLevel.CLASSIFIED.
It can get either MeasReturnType.AVERAGE or MeasReturnType.SINGLE. For the value
MeasReturnType.SINGLE the data of each shot will be stored in the result. For
MeasReturnType.AVERAGE, an average of all the shots will be calculated and stored
in the result.
Returns:
FakeJob: A job that contains the simulated data.
"""
self.options.update_options(**options)
shots = self.options.get("shots")
meas_level = self.options.get("meas_level")
result = {
"backend_name": f"{self.__class__.__name__}",
"backend_version": "0",
"qobj_id": "0",
"job_id": "0",
"success": True,
"results": [],
}
prob_list = self.experiment_helper.compute_probabilities(run_input)
for prob, circ in zip(prob_list, run_input):
run_result = {
"shots": shots,
"success": True,
"header": {"metadata": circ.metadata},
"meas_level": meas_level,
}
run_result["data"] = self._generate_data(prob, circ)
result["results"].append(run_result)
return FakeJob(self, Result.from_dict(result))
def run(self, run_input, **options):
"""Run the IQ backend."""
self.options.update_options(**options)
shots = self.options.get("shots")
meas_level = self.options.get("meas_level")
meas_return = self.options.get("meas_return")
result = {
"backend_name": f"{self.__class__.__name__}",
"backend_version": "0",
"qobj_id": 0,
"job_id": 0,
"success": True,
"results": [],
}
for circ in run_input:
run_result = {
"shots": shots,
"success": True,
"header": {
"metadata": circ.metadata
},
"meas_level": meas_level,
}
prob = self._compute_probability(circ)
if meas_level == MeasLevel.CLASSIFIED:
ones = np.sum(self._rng.binomial(1, prob, size=shots))
run_result["data"] = {"counts": {"1": ones, "0": shots - ones}}
else:
phase = self._iq_phase(circ)
memory = self._draw_iq_shots(prob, shots, phase)
if meas_return == "avg":
memory = np.average(np.array(memory), axis=0).tolist()
run_result["data"] = {"memory": memory}
result["results"].append(run_result)
return FakeJob(self, Result.from_dict(result))
def run(self, run_input, **kwargs):
"""Hard-coded experiment result generation based on the series definition."""
results = []
shots = kwargs.get("shots", 1024)
series_defs = cr_hamiltonian_analysis.CrossResonanceHamiltonianAnalysis.__series__
filter_kwargs_list = [sdef.filter_kwargs for sdef in series_defs]
for test_circ in run_input:
metadata = {
"control_state": test_circ.metadata["control_state"],
"meas_basis": test_circ.metadata["meas_basis"],
}
curve_ind = filter_kwargs_list.index(metadata)
xval = test_circ.metadata["xval"]
expv = series_defs[curve_ind].fit_func(xval, **self.fit_func_args)
popl = 0.5 * (1 - expv)
one_count = int(np.round(shots * popl))
results.append({
"shots": shots,
"success": True,
"header": {
"metadata": test_circ.metadata
},
"data": {
"counts": {
"0": shots - one_count,
"1": one_count
}
},
})
result = {
"backend_name": self.name(),
"backend_version": self.configuration().backend_version,
"qobj_id": "12345",
"job_id": "12345",
"success": True,
"results": results,
}
return FakeJob(backend=self, result=Result.from_dict(result))
def run(self, run_input, **options):
results = []
for circ, cnt in zip(run_input, counts):
results.append(
{
"shots": -1,
"success": True,
"header": {"metadata": circ.metadata},
"data": {"counts": cnt},
}
)
res = {
"backend_name": "backend",
"backend_version": "0",
"qobj_id": uuid.uuid4().hex,
"job_id": uuid.uuid4().hex,
"success": True,
"results": results,
}
return FakeJob(backend=self, result=Result.from_dict(res))
def run(self, run_input, **options):
"""
Run the T2Ramsey backend
"""
self.options.update_options(**options)
shots = self.options.get("shots")
result = {
"backend_name": "T2Ramsey backend",
"backend_version": "0",
"qobj_id": 0,
"job_id": 0,
"success": True,
"results": [],
}
for circ in run_input:
nqubits = circ.num_qubits
qubit_indices = {bit: idx for idx, bit in enumerate(circ.qubits)}
clbit_indices = {bit: idx for idx, bit in enumerate(circ.clbits)}
counts = dict()
if self._readout0to1 is None:
ro01 = np.zeros(nqubits)
else:
ro01 = self._readout0to1
if self._readout1to0 is None:
ro10 = np.zeros(nqubits)
else:
ro10 = self._readout1to0
for _ in range(shots):
if self._initial_prob_plus is None:
prob_plus = np.ones(nqubits)
else:
prob_plus = self._initial_prob_plus.copy()
clbits = np.zeros(circ.num_clbits, dtype=int)
for op, qargs, cargs in circ.data:
qubit = qubit_indices[qargs[0]]
if op.name == "delay":
delay = op.params[0]
t2ramsey = self._t2ramsey[
qubit] * self._conversion_factor
freq = self._freq[qubit]
prob_plus[qubit] = (
self._a_param[qubit] * np.exp(-delay / t2ramsey) *
np.cos(2 * np.pi * freq * delay + self._phi[qubit])
+ self._b_param[qubit])
if op.name == "measure":
# we measure in |+> basis which is the same as measuring |0>
meas_res = self._rng.binomial(
1,
(1 - prob_plus[qubit]) * (1 - ro10[qubit]) +
prob_plus[qubit] * ro01[qubit],
)
clbit = clbit_indices[cargs[0]]
clbits[clbit] = meas_res
clstr = ""
for clbit in clbits[::-1]:
clstr = clstr + str(clbit)
if clstr in counts:
counts[clstr] += 1
else:
counts[clstr] = 1
result["results"].append({
"shots": shots,
"success": True,
"header": {
"metadata": circ.metadata
},
"data": {
"counts": counts
},
})
return FakeJob(self, Result.from_dict(result))
def run(self, run_input, **options):
"""
Run the T2Hahn backend
"""
self.options.update_options(**options)
shots = self.options.get("shots")
result = {
"backend_name": "T2Hahn backend",
"backend_version": "0",
"qobj_id": 0,
"job_id": 0,
"success": True,
"results": [],
}
for circ in run_input:
nqubits = circ.num_qubits
qubit_indices = {bit: idx for idx, bit in enumerate(circ.qubits)}
clbit_indices = {bit: idx for idx, bit in enumerate(circ.clbits)}
counts = dict()
for _ in range(shots):
qubit_state = self._qubit_initialization(
nqubits=nqubits
) # for parallel need to make an array
clbits = np.zeros(circ.num_clbits, dtype=int)
for op, qargs, cargs in circ.data:
qubit = qubit_indices[qargs[0]]
# The noise will only be applied if we are in the XY plane.
if op.name == "delay":
delay = op.params[0]
t2hahn = self._t2hahn[qubit]
freq = self._frequency[qubit]
qubit_state[qubit] = self._delay_gate(
qubit_state=qubit_state[qubit],
delay=delay,
t2hahn=t2hahn,
frequency=freq,
)
elif op.name == "rx":
qubit_state[qubit] = self._rx_gate(qubit_state[qubit], op.params[0])
elif op.name == "measure":
meas_res = self._measurement_gate(qubit_state[qubit])
clbit = clbit_indices[cargs[0]]
clbits[clbit] = meas_res
clstr = ""
for clbit in clbits[::-1]:
clstr = clstr + str(clbit)
if clstr in counts:
counts[clstr] += 1
else:
counts[clstr] = 1
result["results"].append(
{
"shots": shots,
"success": True,
"header": {"metadata": circ.metadata},
"data": {"counts": counts},
}
)
return FakeJob(self, Result.from_dict(result))
def run(self, run_input, **options):
"""
Run the T1 backend
"""
self.options.update_options(**options)
shots = self.options.get("shots")
result = {
"backend_name": "T1 backend",
"backend_version": "0",
"qobj_id": "0",
"job_id": "0",
"success": True,
"results": [],
}
for circ in run_input:
nqubits = circ.num_qubits
qubit_indices = {bit: idx for idx, bit in enumerate(circ.qubits)}
clbit_indices = {bit: idx for idx, bit in enumerate(circ.clbits)}
counts = dict()
if self._readout0to1 is None:
ro01 = np.zeros(nqubits)
else:
ro01 = self._readout0to1
if self._readout1to0 is None:
ro10 = np.zeros(nqubits)
else:
ro10 = self._readout1to0
for _ in range(shots):
if self._initial_prob1 is None:
prob1 = np.zeros(nqubits)
else:
prob1 = self._initial_prob1.copy()
clbits = np.zeros(circ.num_clbits, dtype=int)
for op, qargs, cargs in circ.data:
qubit = qubit_indices[qargs[0]]
if op.name == "x":
prob1[qubit] = 1 - prob1[qubit]
elif op.name == "delay":
delay = op.params[0]
prob1[qubit] = prob1[qubit] * np.exp(
-delay / self._t1[qubit])
elif op.name == "measure":
meas_res = self._rng.binomial(
1, prob1[qubit] * (1 - ro10[qubit]) +
(1 - prob1[qubit]) * ro01[qubit])
clbit = clbit_indices[cargs[0]]
clbits[clbit] = meas_res
prob1[qubit] = meas_res
clstr = ""
for clbit in clbits[::-1]:
clstr = clstr + str(clbit)
if clstr in counts:
counts[clstr] += 1
else:
counts[clstr] = 1
result["results"].append({
"shots": shots,
"success": True,
"header": {
"metadata": circ.metadata
},
"data": {
"counts": counts
},
})
return FakeJob(backend=self, result=Result.from_dict(result))