Correct Way To Verify The Compensator When Plant is Cont. & Comp. is Discrete #1235

Your physical intuition is correct: the real plant remains continuous. However, for sample-to-sample analysis of a digitally controlled loop, you still need a discrete equivalent of the plant.

That conversion does not mean the physical plant becomes discrete. c2d(Gp, Ts, method="zoh") represents the map from one sampling instant to the next under the assumption that the controller output is held constant between updates by a zero-order hold.

The construction in the question:

T_s = ct.feedback(Gp * Gc)
T_z = ct.c2d(T_s, Ts, method="zoh")

first creates a fully continuous closed loop, in which Gc acts continuously, and only then samples that closed loop. It therefore does not represent a digital controller operating every Ts seconds.

As written, both Gp and Gc are continuous-time systems because neither was created with a discrete timebase. If Gc is a continuous-time controller prototype that you want to implement digitally, sample the components separately and close the loop afterward:

import control as ct

k = 5.4
Ts = 0.003

Gp = ct.tf([1740], [0.25, 1, 0])
Gc = ct.tf([k, 250], [1, k * 50])

# Exact sample-to-sample plant model for a zero-order-held input
Gp_z = ct.c2d(Gp, Ts, method="zoh")

# Example controller discretization; use the method chosen in your design
Gc_z = ct.c2d(Gc, Ts, method="bilinear")

# Sampled-data closed loop at the sampling instants
T_z = ct.feedback(Gp_z * Gc_z, 1)

If the controller was designed directly in discrete time, define Gc_z with dt=Ts and do not discretize it again:

Gc_z = ct.tf(num_z, den_z, Ts)
T_z = ct.feedback(Gp_z * Gc_z, 1)

python-control deliberately rejects an expression such as:

Gp * Gc_z

with ValueError: Systems have incompatible timebases, because a continuous plant and discrete controller cannot be represented as one ordinary LTI transfer-function product without explicitly modeling the sampler and hold.

For your numerical values, the two approaches are measurably different:

sample(closed analog loop) poles:
0.8052, 0.6931 +/- 0.2560j

sampled plant + digital controller poles:
0.8173, 0.7330 +/- 0.3326j

The ZOH plant model is sufficient when you only need behavior at the controller's sampling instants. To inspect behavior between samples, model delays, or simulate a nonlinear continuous plant, use a sampled-data simulation that integrates the plant between controller updates. The python-control documentation includes an example of that approach:

https://python-control.readthedocs.io/en/latest/examples/simulating_discrete_nonlinear.html

One small plotting detail: response.time is measured in seconds, not sample indices. Either label it as time:

plt.xlabel("Time (s)")

or plot against an explicit sample index:

import numpy as np

sample_index = np.arange(response.time.size)
plt.stem(sample_index, response.outputs)
plt.xlabel("Sample index k")