def gen_baseline(
data: types.ChartAxis, formatter: Dict[str, Any],
device: device_info.DrawerBackendInfo
) -> List[drawing_objects.LineData]:
"""Generate the baseline associated with the chart.
Stylesheets:
- The `baseline` style is applied.
Args:
data: Chart axis data to draw.
formatter: Dictionary of stylesheet settings.
device: Backend configuration.
Returns:
List of `LineData` drawing objects.
"""
style = {
'alpha': formatter['alpha.baseline'],
'zorder': formatter['layer.baseline'],
'linewidth': formatter['line_width.baseline'],
'linestyle': formatter['line_style.baseline'],
'color': formatter['color.baseline']
}
baseline = drawing_objects.LineData(
data_type=types.DrawingLine.BASELINE,
channels=data.channels,
xvals=[types.AbstractCoordinate.LEFT, types.AbstractCoordinate.RIGHT],
yvals=[0, 0],
ignore_scaling=True,
styles=style)
return [baseline]
def gen_barrier(misc_data: types.NonPulseTuple) \
-> List[Union[drawing_objects.LineData, drawing_objects.TextData]]:
r"""Generate a barrier from provided relative barrier instruction..
The `barrier` style is applied.
Args:
misc_data: Snapshot instruction data to draw.
Returns:
List of `TextData` drawing objects.
"""
if not isinstance(misc_data.inst, pulse.instructions.RelativeBarrier):
return []
style = {'alpha': PULSE_STYLE['formatter.alpha.barrier'],
'zorder': PULSE_STYLE['formatter.layer.barrier'],
'linewidth': PULSE_STYLE['formatter.line_width.barrier'],
'linestyle': PULSE_STYLE['formatter.line_style.barrier'],
'color': PULSE_STYLE['formatter.color.barrier']}
lines = []
for chan in misc_data.inst.channels:
line = drawing_objects.LineData(data_type='Barrier',
channel=chan,
x=misc_data.t0,
y=None,
styles=style)
lines.append(line)
return lines
def gen_barrier(
data: types.BarrierInstruction, formatter: Dict[str, Any],
device: device_info.DrawerBackendInfo
) -> List[drawing_objects.LineData]:
"""Generate the barrier from provided relative barrier instruction.
Stylesheets:
- The `barrier` style is applied.
Args:
data: Barrier instruction data to draw.
formatter: Dictionary of stylesheet settings.
device: Backend configuration.
Returns:
List of `LineData` drawing objects.
"""
style = {
'alpha': formatter['alpha.barrier'],
'zorder': formatter['layer.barrier'],
'linewidth': formatter['line_width.barrier'],
'linestyle': formatter['line_style.barrier'],
'color': formatter['color.barrier']
}
line = drawing_objects.LineData(
data_type=types.DrawingLine.BARRIER,
channels=data.channels,
xvals=[data.t0, data.t0],
yvals=[types.AbstractCoordinate.BOTTOM, types.AbstractCoordinate.TOP],
styles=style)
return [line]
def gen_baseline(channel_data: types.ChannelTuple) \
-> List[drawing_objects.LineData]:
r"""Generate baseline associated with the channel.
The `baseline` style is applied.
Args:
channel_data: Channel data to draw.
Returns:
List of `LineData` drawing objects.
"""
style = {'alpha': PULSE_STYLE['formatter.alpha.baseline'],
'zorder': PULSE_STYLE['formatter.layer.baseline'],
'linewidth': PULSE_STYLE['formatter.line_width.baseline'],
'linestyle': PULSE_STYLE['formatter.line_style.baseline'],
'color': PULSE_STYLE['formatter.color.baseline']}
baseline = drawing_objects.LineData(data_type='BaseLine',
channel=channel_data.channel,
x=None,
y=0,
styles=style)
return [baseline]
def test_line_data(self):
"""Test for LineData."""
data1 = drawing_objects.LineData(data_type='baseline',
channel=pulse.DriveChannel(0),
x=np.array([0, 1, 2]),
y=np.array([0, 0, 0]),
meta={'test_val': 0},
offset=0,
visible=True,
styles={'color': 'red'})
data2 = drawing_objects.LineData(data_type='baseline',
channel=pulse.DriveChannel(0),
x=np.array([0, 1, 2]),
y=np.array([0, 0, 0]),
meta={'test_val': 1},
offset=1,
visible=False,
styles={'color': 'blue'})
self.assertEqual(data1, data2)
def test_line_data_equivalent_with_abstract_coordinate(self):
"""Test for LineData with abstract coordinate."""
xs = [types.AbstractCoordinate.LEFT, types.AbstractCoordinate.RIGHT]
ys = [types.AbstractCoordinate.TOP, types.AbstractCoordinate.BOTTOM]
data1 = drawing_objects.LineData(data_type='test',
xvals=xs,
yvals=ys,
channels=self.ch_d0,
meta=self.meta1,
ignore_scaling=True,
styles=self.style1)
data2 = drawing_objects.LineData(data_type='test',
xvals=xs,
yvals=ys,
channels=self.ch_d1,
meta=self.meta2,
ignore_scaling=True,
styles=self.style2)
self.assertEqual(data1, data2)
def test_line_data_equivalent(self):
"""Test for LineData."""
xs = [0, 1, 2]
ys = [3, 4, 5]
data1 = drawing_objects.LineData(data_type='test',
xvals=xs,
yvals=ys,
channels=self.ch_d0,
meta=self.meta1,
ignore_scaling=True,
styles=self.style1)
data2 = drawing_objects.LineData(data_type='test',
xvals=xs,
yvals=ys,
channels=self.ch_d1,
meta=self.meta2,
ignore_scaling=True,
styles=self.style2)
self.assertEqual(data1, data2)
def setUp(self) -> None:
super().setUp()
self.style = stylesheet.QiskitPulseStyle()
self.device = device_info.OpenPulseBackendInfo(
name='test',
dt=1,
channel_frequency_map={
pulse.DriveChannel(0): 5.0,
pulse.MeasureChannel(0): 7.0,
pulse.ControlChannel(0): 5.0,
},
qubit_channel_map={
0: [
pulse.DriveChannel(0),
pulse.MeasureChannel(0),
pulse.AcquireChannel(0),
pulse.ControlChannel(0)
]
})
# objects
self.short_pulse = drawing_objects.LineData(
data_type=types.DrawingWaveform.REAL,
xvals=[0, 0, 1, 4, 5, 5],
yvals=[0, 0.5, 0.5, 0.5, 0.5, 0],
channels=[pulse.DriveChannel(0)])
self.long_pulse = drawing_objects.LineData(
data_type=types.DrawingWaveform.REAL,
xvals=[8, 8, 9, 19, 20, 20],
yvals=[0, 0.3, 0.3, 0.3, 0.3, 0],
channels=[pulse.DriveChannel(1)])
self.abstract_hline = drawing_objects.LineData(
data_type=types.DrawingLine.BASELINE,
xvals=[
types.AbstractCoordinate.LEFT, types.AbstractCoordinate.RIGHT
],
yvals=[0, 0],
channels=[pulse.DriveChannel(0)])
def gen_filled_waveform_stepwise(data: types.PulseInstruction,
formatter: Dict[str, Any],
device: device_info.DrawerBackendInfo
) -> List[drawing_objects.LineData]:
"""Generate filled area objects of the real and the imaginary part of waveform envelope.
The curve of envelope is not interpolated nor smoothed and presented
as stepwise function at each data point.
Stylesheets:
- The `fill_waveform` style is applied.
Args:
data: Waveform instruction data to draw.
formatter: Dictionary of stylesheet settings.
device: Backend configuration.
Returns:
List of `LineData` drawing objects.
"""
fill_objs = []
# generate waveform data
parsed = _parse_waveform(data)
channel = data.inst.channel
qubit = device.get_qubit_index(channel)
if qubit is None:
qubit = 'N/A'
resolution = formatter['general.vertical_resolution']
# phase modulation
if formatter['control.apply_phase_modulation']:
ydata = np.asarray(parsed.yvals, dtype=np.complex) * np.exp(1j * data.frame.phase)
else:
ydata = np.asarray(parsed.yvals, dtype=np.complex)
# stepwise interpolation
xdata = np.concatenate((parsed.xvals, [parsed.xvals[-1] + 1]))
ydata = np.repeat(ydata, 2)
re_y = np.real(ydata)
im_y = np.imag(ydata)
time = np.concatenate(([xdata[0]], np.repeat(xdata[1:-1], 2), [xdata[-1]]))
# setup style options
style = {'alpha': formatter['alpha.fill_waveform'],
'zorder': formatter['layer.fill_waveform'],
'linewidth': formatter['line_width.fill_waveform'],
'linestyle': formatter['line_style.fill_waveform']}
color_code = types.ComplexColors(*formatter[_fill_waveform_color(channel)])
# create real part
if np.any(re_y):
# data compression
re_valid_inds = _find_consecutive_index(re_y, resolution)
# stylesheet
re_style = {'color': color_code.real}
re_style.update(style)
# metadata
re_meta = {'data': 'real', 'qubit': qubit}
re_meta.update(parsed.meta)
# active xy data
re_xvals = time[re_valid_inds]
re_yvals = re_y[re_valid_inds]
# object
real = drawing_objects.LineData(data_type=types.DrawingWaveform.REAL,
channels=channel,
xvals=re_xvals,
yvals=re_yvals,
fill=True,
meta=re_meta,
styles=re_style)
fill_objs.append(real)
# create imaginary part
if np.any(im_y):
# data compression
im_valid_inds = _find_consecutive_index(im_y, resolution)
# stylesheet
im_style = {'color': color_code.imaginary}
im_style.update(style)
# metadata
im_meta = {'data': 'imag', 'qubit': qubit}
im_meta.update(parsed.meta)
# active xy data
im_xvals = time[im_valid_inds]
im_yvals = im_y[im_valid_inds]
# object
imag = drawing_objects.LineData(data_type=types.DrawingWaveform.IMAG,
channels=channel,
xvals=im_xvals,
yvals=im_yvals,
fill=True,
meta=im_meta,
styles=im_style)
fill_objs.append(imag)
return fill_objs
