sys, pltmag, pltphs, shrmag, shrphs, shrfrq, secsys,

ovlout, ovlinp, clear=True):

# Save up the keyword arguments

kwargs = dict(

plot_magnitude=pltmag, plot_phase=pltphs,

share_magnitude=shrmag, share_phase=shrphs, share_frequency=shrfrq,

overlay_outputs=ovlout, overlay_inputs=ovlinp

)

# Create the response

if isinstance(sys, ct.FrequencyResponseData):

response = sys

else:

response = ct.frequency_response(sys)

# Look for cases where there are no data to plot

if not pltmag and not pltphs:

return None

# Plot the frequency response

plt.figure()

out = response.plot(**kwargs)

# Check the shape

if ovlout and ovlinp:

assert out.shape == (pltmag + pltphs, 1)

elif ovlout:

assert out.shape == (pltmag + pltphs, sys.ninputs)

elif ovlinp:

assert out.shape == (sys.noutputs * (pltmag + pltphs), 1)

else:

assert out.shape == (sys.noutputs * (pltmag + pltphs), sys.ninputs)

# Make sure all of the outputs are of the right type

nlines_plotted = 0

for ax_lines in np.nditer(out, flags=["refs_ok"]):

for line in ax_lines.item() or []:

assert isinstance(line, mpl.lines.Line2D)

nlines_plotted += 1

# Make sure number of plots is correct

nlines_expected = response.ninputs * response.noutputs * \

(2 if pltmag and pltphs else 1)

assert nlines_plotted == nlines_expected

# Save the old axes to compare later

old_axes = plt.gcf().get_axes()

# Add additional data (and provide info in the title)

if secsys:

newsys = ct.rss(

4, sys.noutputs, sys.ninputs, strictly_proper=True)

ct.frequency_response(newsys).plot(**kwargs)

# Make sure we have the same axes

new_axes = plt.gcf().get_axes()

assert new_axes == old_axes

# Make sure every axes has multiple lines

for ax in new_axes:

assert len(ax.get_lines()) > 1

# Update the title so we can see what is going on

fig = out[0, 0][0].axes.figure

fig.suptitle(

fig._suptitle._text +

f" [{sys.noutputs}x{sys.ninputs}, pm={pltmag}, pp={pltphs},"

f" sm={shrmag}, sp={shrphs}, sf={shrfrq}]", # TODO: ", "

# f"oo={ovlout}, oi={ovlinp}, ss={secsys}]", # TODO: add back

fontsize='small')

# Get rid of the figure to free up memory

if clear:

# Default response: limits should be the same across rows

out = manual_response.plot()

axs = ct.get_plot_axes(out)

for i in range(manual_response.noutputs):

for j in range(1, manual_response.ninputs):

# Everything in the same row should have the same limits

assert axs[i*2, 0].get_ylim() == axs[i*2, j].get_ylim()

assert axs[i*2 + 1, 0].get_ylim() == axs[i*2 + 1, j].get_ylim()

# Different rows have different limits

assert axs[0, 0].get_ylim() != axs[2, 0].get_ylim()

# Define a couple of systems for testing

sys1 = ct.tf([1], [1, 2, 1], name='sys1')

sys2 = ct.tf([1, 0.2], [1, 1, 3, 1, 1], name='sys2')

sys3 = ct.tf([0.2, 0.1], [1, 0.1, 0.3, 0.1, 0.1], name='sys3')

# Create a plot for the first system, with custom styles

lines_default = plt_fcn(sys1)

# Now create a plot using *fmt customization

lines_fmt = plt_fcn(sys2, None, 'r--')

assert lines_fmt.reshape(-1)[0][0].get_color() == 'r'

assert lines_fmt.reshape(-1)[0][0].get_linestyle() == '--'

# Add a third plot using keyword customization

lines_kwargs = plt_fcn(sys3, color='g', linestyle=':')

assert lines_kwargs.reshape(-1)[0][0].get_color() == 'g'

# Basic SISO Bode plot

plt.figure()

# ct.frequency_response(sys_siso).plot()

sys1 = ct.tf([1], [1, 2, 1], name='sys1')

sys2 = ct.tf([1, 0.2], [1, 1, 3, 1, 1], name='sys2')

response = ct.frequency_response([sys1, sys2])

ct.bode_plot(response, initial_phase=0)

if savefigs:

plt.savefig('freqplot-siso_bode-default.png')

# Basic MIMO Bode plot

plt.figure()

sys_mimo = ct.tf(

[[[1], [0.1]], [[0.2], [1]]],

[[[1, 0.6, 1], [1, 1, 1]], [[1, 0.4, 1], [1, 2, 1]]], name="sys_mimo")

ct.frequency_response(sys_mimo).plot()

if savefigs:

plt.savefig('freqplot-mimo_bode-default.png')

# Magnitude only plot, with overlayed inputs and outputs

plt.figure()

ct.frequency_response(sys_mimo).plot(

plot_phase=False, overlay_inputs=True, overlay_outputs=True)

if savefigs:

plt.savefig('freqplot-mimo_bode-magonly.png')

# Phase only plot

plt.figure()

ct.frequency_response(sys_mimo).plot(plot_magnitude=False)

# Singular values plot

plt.figure()

ct.singular_values_response(sys_mimo).plot()

if savefigs:

plt.savefig('freqplot-mimo_svplot-default.png')

# Nichols chart

plt.figure()

ct.nichols_plot(response)

if savefigs:

proc = ct.tf([1], [1, 1, 1], name="process")

ctrl = ct.tf([100], [1, 5], name="control")

plt.figure()

ct.gangof4_plot(proc, ctrl)

if savefigs:

sys = ct.rss(2, 1, 1)

# If we pass a single system, should get back a single system

result = response_cmd(sys)

assert isinstance(result, return_type)

# Save the results from a single plot

lines_single = result.plot()

# If we pass a list of systems, we should get back a list

result = response_cmd([sys, sys, sys])

assert isinstance(result, list)

assert len(result) == 3

assert all([isinstance(item, return_type) for item in result])

# Make sure that plot works

lines_list = result.plot()

if response_cmd == ct.frequency_response:

assert lines_list.shape == lines_single.shape

assert len(lines_list.reshape(-1)[0]) == \

3 * len(lines_single.reshape(-1)[0])

else:

assert lines_list.shape[0] == 3 * lines_single.shape[0]

# If we pass a singleton list, we should get back a list

result = response_cmd([sys])

assert isinstance(result, list)

assert len(result) == 1

# Default sharing should share along rows and cols for mag and phase

lines = ct.bode_plot(manual_response)

axs = ct.get_plot_axes(lines)

for i in range(axs.shape[0]):

for j in range(axs.shape[1]):

# Share y limits along rows

assert axs[i, j].get_ylim() == axs[i, 0].get_ylim()

# Share x limits along columns

assert axs[i, j].get_xlim() == axs[-1, j].get_xlim()

# Sharing along y axis for mag but not phase

plt.figure()

lines = ct.bode_plot(manual_response, share_phase='none')

axs = ct.get_plot_axes(lines)

for i in range(int(axs.shape[0] / 2)):

for j in range(axs.shape[1]):

if i != 0:

# Different rows are different

assert axs[i*2 + 1, 0].get_ylim() != axs[1, 0].get_ylim()

elif j != 0:

# Different columns are different

assert axs[i*2 + 1, j].get_ylim() != axs[i*2 + 1, 0].get_ylim()

# Turn off sharing for magnitude and phase

plt.figure()

lines = ct.bode_plot(manual_response, sharey='none')

axs = ct.get_plot_axes(lines)

for i in range(int(axs.shape[0] / 2)):

for j in range(axs.shape[1]):

if i != 0:

# Different rows are different

assert axs[i*2, 0].get_ylim() != axs[0, 0].get_ylim()

assert axs[i*2 + 1, 0].get_ylim() != axs[1, 0].get_ylim()

elif j != 0:

# Different columns are different

assert axs[i*2, j].get_ylim() != axs[i*2, 0].get_ylim()

assert axs[i*2 + 1, j].get_ylim() != axs[i*2 + 1, 0].get_ylim()

# Turn off sharing in x axes

plt.figure()

lines = ct.bode_plot(manual_response, sharex='none')

if plot_type == 'svplot':

response = ct.singular_values_response(ct.rss(2, 1, 1))

else:

response = ct.frequency_response(ct.rss(2, 1, 1))

lines = response.plot(plot_type=plot_type)

if plot_type == 'bode':

assert lines.shape == (2, 1)

else:

# Utility function to check visible limits

def _get_visible_limits(ax):

xticks = np.array(ax.get_xticks())

limits = ax.get_xlim()

return np.array([min(xticks[xticks >= limits[0]]),

max(xticks[xticks <= limits[1]])])

# Generate a test response with a fixed set of limits

response = ct.singular_values_response(

ct.tf([1], [1, 2, 1]), np.logspace(-1, 1))

# Generate a plot without overridding the limits

lines = plt_fcn(response)

ax = ct.get_plot_axes(lines)

np.testing.assert_allclose(

_get_visible_limits(ax.reshape(-1)[0]), np.array([0.1, 10]))

# Now reset the limits

lines = plt_fcn(response, omega_limits=(1, 100))

ax = ct.get_plot_axes(lines)

np.testing.assert_allclose(

if plt_fcn == ct.bode_plot:

# Turning off both magnitude and phase

with pytest.raises(ValueError, match="no data to plot"):

ct.bode_plot(

manual_response, plot_magnitude=False, plot_phase=False)

# Specifying frequency parameters with response data

response = ct.singular_values_response(ct.rss(2, 1, 1))

with pytest.warns(UserWarning, match="`omega_num` ignored "):

plt_fcn(response, omega_num=100)

with pytest.warns(UserWarning, match="`omega` ignored "):

plt_fcn(response, omega=np.logspace(-2, 2))

# Bad frequency limits

with pytest.raises(ValueError, match="invalid limits"):