def _draw_opaque_waveform(
init_time: int,
duration: int,
pulse_shape: str,
pnames: List[str],
meta: Dict[str, Any],
channel: pulse.channels.PulseChannel,
formatter: Dict[str, Any],
) -> List[Union[drawings.LineData, drawings.BoxData, drawings.TextData]]:
"""A private function that generates drawings of stepwise pulse lines.
Args:
init_time: Time when the opaque waveform starts.
duration: Duration of opaque waveform. This can be None or ParameterExpression.
pulse_shape: String that represents pulse shape.
pnames: List of parameter names.
meta: Metadata dictionary of the waveform.
channel: Channel associated with the waveform to draw.
formatter: Dictionary of stylesheet settings.
Returns:
List of drawings.
"""
fill_objs = []
fc, ec = formatter['color.opaque_shape']
# setup style options
box_style = {
'zorder': formatter['layer.fill_waveform'],
'alpha': formatter['alpha.opaque_shape'],
'linewidth': formatter['line_width.opaque_shape'],
'linestyle': formatter['line_style.opaque_shape'],
'facecolor': fc,
'edgecolor': ec
}
if duration is None or isinstance(duration, circuit.ParameterExpression):
duration = formatter['box_width.opaque_shape']
box_obj = drawings.BoxData(data_type=types.WaveformType.OPAQUE,
channels=channel,
xvals=[init_time, init_time + duration],
yvals=[
-0.5 * formatter['box_height.opaque_shape'],
0.5 * formatter['box_height.opaque_shape']
],
meta=meta,
ignore_scaling=True,
styles=box_style)
fill_objs.append(box_obj)
# parameter name
func_repr = '{func}({params})'.format(func=pulse_shape,
params=', '.join(pnames))
text_style = {
'zorder': formatter['layer.annotate'],
'color': formatter['color.annotate'],
'size': formatter['text_size.annotate'],
'va': 'bottom',
'ha': 'center'
}
text_obj = drawings.TextData(
data_type=types.LabelType.OPAQUE_BOXTEXT,
channels=channel,
xvals=[init_time + 0.5 * duration],
yvals=[0.5 * formatter['box_height.opaque_shape']],
text=func_repr,
ignore_scaling=True,
styles=text_style)
fill_objs.append(text_obj)
return fill_objs
def gen_waveform_max_value(
data: types.PulseInstruction, formatter: Dict[str, Any],
device: device_info.DrawerBackendInfo) -> List[drawings.TextData]:
"""Generate the annotation for the maximum waveform height for
the real and the imaginary part of the waveform envelope.
Maximum values smaller than the vertical resolution limit is ignored.
Stylesheets:
- The `annotate` style is applied.
Args:
data: Waveform instruction data to draw.
formatter: Dictionary of stylesheet settings.
device: Backend configuration.
Returns:
List of `TextData` drawings.
"""
if data.is_opaque:
return []
style = {
'zorder': formatter['layer.annotate'],
'color': formatter['color.annotate'],
'size': formatter['text_size.annotate'],
'ha': 'center'
}
# only pulses.
if isinstance(data.inst, instructions.Play):
# pulse
operand = data.inst.pulse
if isinstance(operand, pulse.ParametricPulse):
pulse_data = operand.get_waveform()
else:
pulse_data = operand
xdata = np.arange(pulse_data.duration) + data.t0
ydata = pulse_data.samples
else:
return []
# phase modulation
if formatter['control.apply_phase_modulation']:
ydata = np.asarray(ydata, dtype=complex) * np.exp(
1j * data.frame.phase)
else:
ydata = np.asarray(ydata, dtype=complex)
texts = []
# max of real part
re_maxind = np.argmax(np.abs(ydata.real))
if np.abs(ydata.real[re_maxind]) > 0.01:
# generator shows only 2 digits after the decimal point.
if ydata.real[re_maxind] > 0:
max_val = u'{val:.2f}\n\u25BE'.format(val=ydata.real[re_maxind])
re_style = {'va': 'bottom'}
else:
max_val = u'\u25B4\n{val:.2f}'.format(val=ydata.real[re_maxind])
re_style = {'va': 'top'}
re_style.update(style)
re_text = drawings.TextData(data_type=types.LabelType.PULSE_INFO,
channels=data.inst.channel,
xvals=[xdata[re_maxind]],
yvals=[ydata.real[re_maxind]],
text=max_val,
styles=re_style)
texts.append(re_text)
# max of imag part
im_maxind = np.argmax(np.abs(ydata.imag))
if np.abs(ydata.imag[im_maxind]) > 0.01:
# generator shows only 2 digits after the decimal point.
if ydata.imag[im_maxind] > 0:
max_val = u'{val:.2f}\n\u25BE'.format(val=ydata.imag[im_maxind])
im_style = {'va': 'bottom'}
else:
max_val = u'\u25B4\n{val:.2f}'.format(val=ydata.imag[im_maxind])
im_style = {'va': 'top'}
im_style.update(style)
im_text = drawings.TextData(data_type=types.LabelType.PULSE_INFO,
channels=data.inst.channel,
xvals=[xdata[im_maxind]],
yvals=[ydata.imag[im_maxind]],
text=max_val,
styles=im_style)
texts.append(im_text)
return texts
def gen_ibmq_latex_waveform_name(
data: types.PulseInstruction, formatter: Dict[str, Any],
device: device_info.DrawerBackendInfo) -> List[drawings.TextData]:
r"""Generate the formatted instruction name associated with the waveform.
Channel name and ID string are removed and the rotation angle is expressed in units of pi.
The controlled rotation angle associated with the CR pulse name is divided by 2.
Note that in many scientific articles the controlled rotation angle implies
the actual rotation angle, but in IQX backend the rotation angle represents
the difference between rotation angles with different control qubit states.
For example:
- 'X90p_d0_abcdefg' is converted into 'X(\frac{\pi}{2})'
- 'CR90p_u0_abcdefg` is converted into 'CR(\frac{\pi}{4})'
Stylesheets:
- The `annotate` style is applied.
Notes:
This generator can convert pulse names used in the IQX backends.
If pulses are provided by the third party providers or the user defined,
the generator output may be the as-is pulse name.
Args:
data: Waveform instruction data to draw.
formatter: Dictionary of stylesheet settings.
device: Backend configuration.
Returns:
List of `TextData` drawings.
"""
if data.is_opaque:
return []
style = {
'zorder': formatter['layer.annotate'],
'color': formatter['color.annotate'],
'size': formatter['text_size.annotate'],
'va': 'center',
'ha': 'center'
}
if isinstance(data.inst, pulse.instructions.Acquire):
systematic_name = 'Acquire'
latex_name = None
elif isinstance(data.inst, instructions.Delay):
systematic_name = data.inst.name or 'Delay'
latex_name = None
elif isinstance(data.inst.channel, pulse.channels.MeasureChannel):
systematic_name = 'Measure'
latex_name = None
else:
systematic_name = data.inst.pulse.name or data.inst.pulse.__class__.__name__
template = r'(?P<op>[A-Z]+)(?P<angle>[0-9]+)?(?P<sign>[pm])_(?P<ch>[dum])[0-9]+'
match_result = re.match(template, systematic_name)
if match_result is not None:
match_dict = match_result.groupdict()
sign = '' if match_dict['sign'] == 'p' else '-'
if match_dict['op'] == 'CR':
# cross resonance
if match_dict['ch'] == 'u':
op_name = r'{\rm CR}'
else:
op_name = r'\overline{\rm CR}'
# IQX name def is not standard. Echo CR is annotated with pi/4 rather than pi/2
angle_val = match_dict['angle']
frac = Fraction(int(int(angle_val) / 2), 180)
if frac.numerator == 1:
angle = r'\pi/{denom:d}'.format(denom=frac.denominator)
else:
angle = r'{num:d}/{denom:d} \pi'.format(
num=frac.numerator, denom=frac.denominator)
else:
# single qubit pulse
op_name = r'{{\rm {}}}'.format(match_dict['op'])
angle_val = match_dict['angle']
if angle_val is None:
angle = r'\pi'
else:
frac = Fraction(int(angle_val), 180)
if frac.numerator == 1:
angle = r'\pi/{denom:d}'.format(denom=frac.denominator)
else:
angle = r'{num:d}/{denom:d} \pi'.format(
num=frac.numerator, denom=frac.denominator)
latex_name = r'{}({}{})'.format(op_name, sign, angle)
else:
latex_name = None
text = drawings.TextData(data_type=types.LabelType.PULSE_NAME,
channels=data.inst.channel,
xvals=[data.t0 + 0.5 * data.inst.duration],
yvals=[-formatter['label_offset.pulse_name']],
text=systematic_name,
latex=latex_name,
ignore_scaling=True,
styles=style)
return [text]
def gen_frame_symbol(
data: types.PulseInstruction, formatter: Dict[str, Any],
device: device_info.DrawerBackendInfo) -> List[drawings.TextData]:
"""Generate a frame change symbol with instruction meta data from provided frame instruction.
Stylesheets:
- The `frame_change` style is applied.
- The symbol type in unicode is specified in `formatter.unicode_symbol.frame_change`.
- The symbol type in latex is specified in `formatter.latex_symbol.frame_change`.
Args:
data: Frame change instruction data to draw.
formatter: Dictionary of stylesheet settings.
device: Backend configuration.
Returns:
List of `TextData` drawings.
"""
if data.frame.phase == 0 and data.frame.freq == 0:
return []
style = {
'zorder': formatter['layer.frame_change'],
'color': formatter['color.frame_change'],
'size': formatter['text_size.frame_change'],
'va': 'center',
'ha': 'center'
}
program = []
for inst in data.inst:
if isinstance(
inst,
(instructions.SetFrequency, instructions.ShiftFrequency)):
try:
program.append('{}({:.2e} Hz)'.format(inst.__class__.__name__,
inst.frequency))
except TypeError:
# parameter expression
program.append('{}({})'.format(inst.__class__.__name__,
inst.frequency.name))
elif isinstance(inst,
(instructions.SetPhase, instructions.ShiftPhase)):
try:
program.append('{}({:.2f} rad.)'.format(
inst.__class__.__name__, inst.phase))
except TypeError:
# parameter expression
program.append('{}({})'.format(inst.__class__.__name__,
inst.phase.name))
meta = {
'total phase change': data.frame.phase,
'total frequency change': data.frame.freq,
'program': ', '.join(program),
't0 (cycle time)': data.t0,
't0 (sec)': data.t0 * data.dt if data.dt else 'N/A'
}
text = drawings.TextData(data_type=types.SymbolType.FRAME,
channels=data.inst[0].channel,
xvals=[data.t0],
yvals=[0],
text=formatter['unicode_symbol.frame_change'],
latex=formatter['latex_symbol.frame_change'],
ignore_scaling=True,
meta=meta,
styles=style)
return [text]
def gen_formatted_frame_values(
data: types.PulseInstruction, formatter: Dict[str, Any],
device: device_info.DrawerBackendInfo) -> List[drawings.TextData]:
"""Generate the formatted virtual Z rotation label and the frequency change label
from provided frame instruction.
Phase value is placed on top of the symbol, and frequency value is placed below the symbol.
See :py:func:`gen_formatted_phase` and :py:func:`gen_formatted_freq_mhz` for details.
Stylesheets:
- The `frame_change` style is applied.
- The `annotate` style is applied for font size.
Args:
data: Frame change instruction data to draw.
formatter: Dictionary of stylesheet settings.
device: Backend configuration.
Returns:
List of `TextData` drawings.
"""
texts = []
_max_denom = 10
_unit = 'MHz'
style = {
'zorder': formatter['layer.frame_change'],
'color': formatter['color.frame_change'],
'size': formatter['text_size.annotate'],
'ha': 'center'
}
# phase value
if data.frame.phase != 0:
plain_phase, latex_phase = _phase_to_text(formatter=formatter,
phase=data.frame.phase,
max_denom=_max_denom,
flip=True)
phase_style = {'va': 'center'}
phase_style.update(style)
phase = drawings.TextData(
data_type=types.LabelType.FRAME,
channels=data.inst[0].channel,
xvals=[data.t0],
yvals=[formatter['label_offset.frame_change']],
text='VZ({phase})'.format(phase=plain_phase),
latex=r'{{\rm VZ}}({phase})'.format(phase=latex_phase),
ignore_scaling=True,
styles=phase_style)
texts.append(phase)
# frequency value
if data.frame.freq != 0:
plain_freq, latex_freq = _freq_to_text(formatter=formatter,
freq=data.frame.freq,
unit=_unit)
freq_style = {'va': 'center'}
freq_style.update(style)
freq = drawings.TextData(
data_type=types.LabelType.FRAME,
channels=data.inst[0].channel,
xvals=[data.t0],
yvals=[2 * formatter['label_offset.frame_change']],
text=u'\u0394f = {freq}'.format(freq=plain_freq),
latex=r'\Delta f = {freq}'.format(freq=latex_freq),
ignore_scaling=True,
styles=freq_style)
texts.append(freq)
return texts
def gen_frame_symbol(
data: types.PulseInstruction, formatter: Dict[str, Any],
device: device_info.DrawerBackendInfo) -> List[drawings.TextData]:
"""Generate a frame change symbol with instruction meta data from provided frame instruction.
Stylesheets:
- The `frame_change` style is applied.
- The symbol type in unicode is specified in `formatter.unicode_symbol.frame_change`.
- The symbol type in latex is specified in `formatter.latex_symbol.frame_change`.
Args:
data: Frame change instruction data to draw.
formatter: Dictionary of stylesheet settings.
device: Backend configuration.
Returns:
List of `TextData` drawings.
"""
if data.frame.phase == 0 and data.frame.freq == 0:
return []
style = {
"zorder": formatter["layer.frame_change"],
"color": formatter["color.frame_change"],
"size": formatter["text_size.frame_change"],
"va": "center",
"ha": "center",
}
program = []
for inst in data.inst:
if isinstance(
inst,
(instructions.SetFrequency, instructions.ShiftFrequency)):
try:
program.append(
f"{inst.__class__.__name__}({inst.frequency:.2e} Hz)")
except TypeError:
# parameter expression
program.append(f"{inst.__class__.__name__}({inst.frequency})")
elif isinstance(inst,
(instructions.SetPhase, instructions.ShiftPhase)):
try:
program.append(
f"{inst.__class__.__name__}({inst.phase:.2f} rad.)")
except TypeError:
# parameter expression
program.append(f"{inst.__class__.__name__}({inst.phase})")
meta = {
"total phase change": data.frame.phase,
"total frequency change": data.frame.freq,
"program": ", ".join(program),
"t0 (cycle time)": data.t0,
"t0 (sec)": data.t0 * data.dt if data.dt else "N/A",
}
text = drawings.TextData(
data_type=types.SymbolType.FRAME,
channels=data.inst[0].channel,
xvals=[data.t0],
yvals=[0],
text=formatter["unicode_symbol.frame_change"],
latex=formatter["latex_symbol.frame_change"],
ignore_scaling=True,
meta=meta,
styles=style,
)
return [text]