I do not think this points to a zoh bug by itself. The important detail is that the code discretizes the open-loop transfer function Ls and then closes the loop in discrete time.

For the numbers in the example, that produces a discrete closed-loop pole well outside the unit circle with zoh. I get approximately:

zoh closed-loop poles:      -30.52, 0.9797, 0.4996
bilinear closed-loop poles:  -0.844, 0.9797, 0.4992

So the failed step_response is consistent with an unstable discrete-time closed loop. You can check this directly with something like:

process_fdbk = ct.feedback(ct.c2d(Ls, Ts=T, method="zoh"), 1)
print(ct.poles(process_fdbk))

Conceptually, zoh is modeling a zero-order hold at the input of a continuous-time system. It is not usually the right way to discretize a PID controller multiplied into the plant and then close the loop afterward. If the goal is a digital-control model, I would discretize the plant with zoh, discretize/design the controller separately, and then close the loop. If the goal is only the sampled equivalent of the already-closed continuous-time system, sample fdbk_Ls instead of Ls:

process_fdbk = ct.c2d(fdbk_Ls, Ts=T, method="zoh")

Those are different systems, which is why the zoh and bilinear results here should not be expected to behave the same.

@AMBRA7592,

thank you for your time for looking into this.

Point 1.
As you stated, because a particular pole is well beyond within the unit circle (equivalent to RHP in continuous time), the process is unstable. If this is the case, why not just plot the system with its unstable response as any other system that is unstable versus generating an exception?

Point 2.
So, from your response, one should perform the continuous to discrete time conversion only after closing the loop when performing a step response test? Is this the go to process?

Tbh, for me this is a little odd since it is ok to perform the open-loop (L(s)) continuous to discrete time conversion in the case when you want to perform the root locus test.

Again, appreciate your feedback and your time.

Thank you.

Following up with my previous response, I have a question regarding the following transfer function - see figure. The plant requires having a 'zoh' transfer function just prior to it - the compensator D(z) doesn't. If I was to design a compensator in the time domain, series it with the plant, then apply unity feedback, and then finally converting it to the discrete time domain, would that bypass applying the 'zoh' to only the plant versus to the entire closed loop transfer function?

Maybe I am not understanding. Can you please advise.

Here is the test script:

def root_locus_plot(plant):

    """
        Pass in the Open Loop L(s) Gain Transfer Function

        L(s) = G(s)*Gc(s)
    """

    plt.style.use('dark_background')
    ct.root_locus_plot(plant, color='red', grid=True )

    # Plot custom circles on both sides of the imaginary axis (e.g., constant w_n = 2 and w_n = 4)
    theta = np.linspace(0, 2 * np.pi, 100)

    r = 1

    x = r * np.cos(theta)
    y = r * np.sin(theta)
    plt.plot(x, y, 'c--')#, label=f'$\omega_n = {r}$') #---

    plt.show()

# 1. Test in the continuous time domain

# Plant
plant = ct.tf([0.6], [1, 0.02, 0])
root_locus_plot(plant) 

# Compensator - Zero cancels pole close to imag. axis
#                         and added pole at s = -4
K = 18
Gc = ct.tf([K, 0.02*K], [1, 4])
Ls = ct.series(plant, Gc)

# Close the loop
Ls = ct.series(plant, Gc)
Ls_fdbk = ct.feedback(Ls, 1)

# Get step response
plt.style.use('dark_background')
response = ct.step_response(Ls_fdbk, np.linspace(0, 7.0, 500), return_x=True)
response.plot(plot_inputs='overlay', title='System Step Response')

# Plot compensator + plant in closed loop
plt.grid(True)
plt.xlim(-0.01, xmax=7)
plt.ylim(-0.05, ymax=1.2)
plt.show()

Thanks, those are good questions. I would separate three different uses that are easy to mix together here.

1. Why an exception instead of just plotting the unstable response?

In principle, yes, an unstable discrete system can be plotted. In this specific case the unstable pole is very large in magnitude, about -30.5. That means the response grows roughly like (-30.5)**k, so it becomes enormous after only a few samples. If step_response is choosing the time base automatically, it can run into numerical or time-vector issues rather than producing a useful plot. If you pass a short explicit discrete-time vector, you may be able to inspect the first few samples, but the response will blow up very quickly.

So I would treat the exception as possibly a usability/error-message issue, but the underlying control result is still: the discrete closed loop created by ct.feedback(ct.c2d(Ls, T, method="zoh"), 1) is unstable.

2. Should you always discretize only after closing the loop?

No, not always. It depends what system you are trying to model.

If you want the sampled response of the already-designed continuous closed loop, then this is appropriate:

process_fdbk = ct.c2d(Ls_fdbk, T, method="zoh")

But that is not the same as modeling an implemented digital controller.

For a digital controller, the usual block diagram is closer to:

D(z) -> zero-order hold / DAC -> G(s) -> sampler / ADC

In that case, the plant gets the ZOH discretization, while the controller is already discrete, or is discretized separately using whatever method you intend to implement. Schematically:

Gz = ct.c2d(plant, T, method="zoh")
Dz = ct.c2d(Gc, T, method="bilinear")  # if starting from an analog compensator
Lz = ct.series(Dz, Gz)
process_fdbk = ct.feedback(Lz, 1)

If your compensator is already D(z), then you would use that directly instead of applying c2d to it.

3. Why is open-loop conversion OK for root locus?

Root locus is indeed based on the open-loop transfer function. The issue is not "open loop vs closed loop" by itself. The issue is whether the open-loop transfer function you discretized represents the physical digital loop you intend.

For digital root locus, the open-loop object should usually be something like:

Lz = D(z) * G_zoh(z)

where G_zoh(z) is the ZOH-equivalent plant. That is different from applying c2d(..., method="zoh") to the combined continuous-time Gc(s) * G(s) and then closing feedback afterward. The latter puts the hold interpretation around the combined continuous-time open-loop transfer function, which is generally not the same physical structure as a digital compensator driving a held plant input.

So yes: if you close the continuous loop first and then discretize, you bypass the detail that the ZOH belongs at the plant input. That can be useful for comparing sampled behavior of a continuous design, but it is not the model I would use to validate an actual digital compensator implementation.