API Reference

z_plane_analysis.discreteResponseTool.cli

Command-line interface for z_plane_analysis.discreteResponseTool.

The CLI preserves the original one-shot discrete-response workflow while adding an optional sphinx-skel helper for generating conservative, GitHub Pages friendly Sphinx documentation files.

Supported entry points:

• python -m z_plane_analysis.discreteResponseTool.cli

• python z_plane_analysis/discreteResponseTool/cli.py

Historical no-subcommand usage is preserved. For example, the following still routes to the run workflow:

python -m z_plane_analysis.discreteResponseTool.cli --example37

The explicit form is also supported:

python -m z_plane_analysis.discreteResponseTool.cli run --example37

z_plane_analysis.discreteResponseTool.cli.build_parser()

Build the command-line parser.

Return type:

ArgumentParser

z_plane_analysis.discreteResponseTool.cli.main(argv=None)

Run the discreteResponseTool command-line interface.

Parameters:

argv (list[str] | None)

Return type:

int

z_plane_analysis.discreteResponseTool.apis

class z_plane_analysis.discreteResponseTool.apis.RunRequest(example37: 'bool' = False, plant_num: 'Optional[List[float]]' = None, plant_den: 'Optional[List[float]]' = None, T: 'Optional[float]' = None, Kp: 'Optional[float]' = None, Ki: 'Optional[float]' = None, Kd: 'Optional[float]' = None, K: 'Optional[float]' = None, Ti: 'Optional[float]' = None, Td: 'Optional[float]' = None, ctrl_numz: 'Optional[List[float]]' = None, ctrl_denz: 'Optional[List[float]]' = None, input: 'str' = 'step', amp: 'float' = 1.0, N: 'int' = 60, cl_poles: 'Optional[List[complex]]' = None, two_dof: 'bool' = False, t_design: 'str' = 'dc', t_beta: 'float' = 0.85, t_numz: 'Optional[List[float]]' = None, t_denz: 'Optional[List[float]]' = None, pre_numz: 'Optional[List[float]]' = None, pre_denz: 'Optional[List[float]]' = None, matplotlib: 'Optional[str]' = None, csv: 'Optional[str]' = None, pzmap: 'Optional[str]' = None, rlocus: 'Optional[str]' = None, plotly_step: 'Optional[str]' = None, plotly_pz: 'Optional[str]' = None, plotly_rl: 'Optional[str]' = None, kmin: 'float' = 0.0, kmax: 'float' = 20.0, rlocus_log: 'bool' = False, rclip: 'float' = 2.5, pzclip: 'float' = 2.0, panel: 'Optional[str]' = None, outdir: 'str' = 'out', print_tf: 'bool' = False)

Bases: object

Parameters:

• example37 (bool)

• plant_num (List[float] | None)

• plant_den (List[float] | None)

• T (float | None)

• Kp (float | None)

• Ki (float | None)

• Kd (float | None)

• K (float | None)

• Ti (float | None)

• Td (float | None)

• ctrl_numz (List[float] | None)

• ctrl_denz (List[float] | None)

• input (str)

• amp (float)

• N (int)

• cl_poles (List[complex] | None)

• two_dof (bool)

• t_design (str)

• t_beta (float)

• t_numz (List[float] | None)

• t_denz (List[float] | None)

• pre_numz (List[float] | None)

• pre_denz (List[float] | None)

• matplotlib (str | None)

• csv (str | None)

• pzmap (str | None)

• rlocus (str | None)

• plotly_step (str | None)

• plotly_pz (str | None)

• plotly_rl (str | None)

• kmin (float)

• kmax (float)

• rlocus_log (bool)

• rclip (float)

• pzclip (float)

• panel (str | None)

• outdir (str)

• print_tf (bool)

K: float | None = None

Kd: float | None = None

Ki: float | None = None

Kp: float | None = None

N: int = 60

T: float | None = None

Td: float | None = None

Ti: float | None = None

amp: float = 1.0

cl_poles: List[complex] | None = None

csv: str | None = None

ctrl_denz: List[float] | None = None

ctrl_numz: List[float] | None = None

example37: bool = False

input: str = 'step'

kmax: float = 20.0

kmin: float = 0.0

matplotlib: str | None = None

outdir: str = 'out'

panel: str | None = None

plant_den: List[float] | None = None

plant_num: List[float] | None = None

plotly_pz: str | None = None

plotly_rl: str | None = None

plotly_step: str | None = None

pre_denz: List[float] | None = None

pre_numz: List[float] | None = None

print_tf: bool = False

pzclip: float = 2.0

pzmap: str | None = None

rclip: float = 2.5

rlocus: str | None = None

rlocus_log: bool = False

t_beta: float = 0.85

t_denz: List[float] | None = None

t_design: str = 'dc'

t_numz: List[float] | None = None

two_dof: bool = False

z_plane_analysis.discreteResponseTool.app

class z_plane_analysis.discreteResponseTool.app.DiscreteResponseApp(request)

Bases: object

Parameters:

request (RunRequest)

run(*, matplotlib=None, csv=None, pzmap=None, rlocus=None, plotly_step=None, plotly_pz=None, plotly_rl=None, panel=None, outdir='out')

Parameters:

• matplotlib (str | None)

• csv (str | None)

• pzmap (str | None)

• rlocus (str | None)

• plotly_step (str | None)

• plotly_pz (str | None)

• plotly_rl (str | None)

• panel (str | None)

• outdir (str)

Return type:

Dict

class z_plane_analysis.discreteResponseTool.app.SystemData(T: 'float', G_num: 'np.ndarray', G_den: 'np.ndarray', Gd_num: 'np.ndarray', Gd_den: 'np.ndarray', plant_desc: 'str', ctrl_desc: 'str')

Bases: object

Parameters:

• T (float)

• G_num (numpy.ndarray)

• G_den (numpy.ndarray)

• Gd_num (numpy.ndarray)

• Gd_den (numpy.ndarray)

• plant_desc (str)

• ctrl_desc (str)

G_den: numpy.ndarray

G_num: numpy.ndarray

Gd_den: numpy.ndarray

Gd_num: numpy.ndarray

T: float

ctrl_desc: str

plant_desc: str

z_plane_analysis.discreteResponseTool.core

z_plane_analysis.discreteResponseTool.core.analog_pid_to_positional_q(K, Ti, Td, T)

Parameters:

• K (float)

• Ti (float)

• Td (float)

• T (float)

Return type:

Tuple[numpy.ndarray, numpy.ndarray]

z_plane_analysis.discreteResponseTool.core.cont2disc_zoh(num_s, den_s, T)

Parameters:

• num_s (Sequence[float])

• den_s (Sequence[float])

• T (float)

Return type:

Tuple[numpy.ndarray, numpy.ndarray]

z_plane_analysis.discreteResponseTool.core.diophantine_place(Np, Dp, A_des)

Parameters:

• Np (numpy.ndarray)

• Dp (numpy.ndarray)

• A_des (numpy.ndarray)

z_plane_analysis.discreteResponseTool.core.feedback_cl_q(numL, denL)

Parameters:

• numL (numpy.ndarray)

• denL (numpy.ndarray)

Return type:

Tuple[numpy.ndarray, numpy.ndarray]

z_plane_analysis.discreteResponseTool.core.filt_lti_q(bq, aq, x)

Parameters:

• bq (numpy.ndarray)

• aq (numpy.ndarray)

• x (numpy.ndarray)

Return type:

numpy.ndarray

z_plane_analysis.discreteResponseTool.core.make_controller_from_kwargs(**kwargs)

Return type:

Tuple[numpy.ndarray | None, numpy.ndarray | None, str]

z_plane_analysis.discreteResponseTool.core.pid_positional_q(Kp, Ki, Kd)

Parameters:

• Kp (float)

• Ki (float)

• Kd (float)

Return type:

Tuple[numpy.ndarray, numpy.ndarray]

z_plane_analysis.discreteResponseTool.core.poly_add_q(a, b)

Parameters:

• a (numpy.ndarray)

• b (numpy.ndarray)

Return type:

numpy.ndarray

z_plane_analysis.discreteResponseTool.core.poly_conv_q(a, b)

Parameters:

• a (numpy.ndarray)

• b (numpy.ndarray)

Return type:

numpy.ndarray

z_plane_analysis.discreteResponseTool.core.poly_eval_q_at1(p)

Parameters:

p (numpy.ndarray)

Return type:

float

z_plane_analysis.discreteResponseTool.core.roots_from_desc(cdesc)

Parameters:

cdesc (numpy.ndarray)

Return type:

numpy.ndarray

z_plane_analysis.discreteResponseTool.core.series_q(num1, den1, num2, den2)

Parameters:

• num1 (numpy.ndarray)

• den1 (numpy.ndarray)

• num2 (numpy.ndarray)

• den2 (numpy.ndarray)

Return type:

Tuple[numpy.ndarray, numpy.ndarray]

z_plane_analysis.discreteResponseTool.core.step_metrics(y, tol=0.02)

Parameters:

• y (numpy.ndarray)

• tol (float)

Return type:

Dict[str, float | None]

z_plane_analysis.discreteResponseTool.core.zpoly_from_q(qcoef, m)

Parameters:

• qcoef (numpy.ndarray)

• m (int)

Return type:

numpy.ndarray

z_plane_analysis.discreteResponseTool.core.zroots_from_q(qcoef)

Parameters:

qcoef (numpy.ndarray)

Return type:

numpy.ndarray

z_plane_analysis.discreteResponseTool.design

z_plane_analysis.discreteResponseTool.design.autoscale_square(ax, r)

Parameters:

r (float)

z_plane_analysis.discreteResponseTool.design.panel_plot(step_k, step_y, numT_q, denT_q, numL_q, denL_q, path=None, rclip=2.5, pzclip=2.0, metrics=None)

Parameters:

• path (str | None)

• rclip (float)

• pzclip (float)

• metrics (Dict | None)

z_plane_analysis.discreteResponseTool.design.plotly_pz(numT_q, denT_q, path, clip=2.0)

z_plane_analysis.discreteResponseTool.design.plotly_rlocus(numL_q, denL_q, path, Kmin=0.0, Kmax=20.0, NK=400, logscale=False, rclip=2.5)

z_plane_analysis.discreteResponseTool.design.plotly_step(k, y, path, title='Response')

z_plane_analysis.discreteResponseTool.design.pretty_q(name, num, den)

Parameters:

name (str)

Return type:

str

z_plane_analysis.discreteResponseTool.design.pzmap(numT_q, denT_q, path=None, clip=2.0, title='Closed-loop T(z)')

Parameters:

• path (str | None)

• clip (float)

• title (str)

z_plane_analysis.discreteResponseTool.design.root_locus(numL_q, denL_q, Kmin=0.0, Kmax=20.0, NK=400, logscale=False, rclip=2.5, path=None, title='Root Locus of L(z)=K·Gd(z)G(z)')

Parameters:

• Kmin (float)

• Kmax (float)

• NK (int)

• logscale (bool)

• rclip (float)

• path (str | None)

• title (str)

z_plane_analysis.discreteResponseTool.design.unit_circle(ax, radius=1.0, **kw)

z_plane_analysis.discreteResponseTool.io

z_plane_analysis.discreteResponseTool.io.parse_coeffs(vals)

Parse list of numbers, respecting Python literals (e.g., 1e-3).

Parameters:

vals (List[str])

Return type:

List[float]

z_plane_analysis.discreteResponseTool.io.parse_complex_list(vals)

Parse list like [‘0.8’,’0.7+0.2j’,’0.7-0.2j’] into complex numbers.

Parameters:

vals (List[str])

z_plane_analysis.discreteResponseTool.utils

z_plane_analysis.discreteResponseTool.utils.ensure_dir(path)

Parameters:

path (str)

Return type:

None

z_plane_analysis.discreteResponseTool.utils.normalize_out_path(path, outdir)

Parameters:

• path (str | None)

• outdir (str)

Return type:

str | None

z_plane_analysis.discreteResponseTool.utils.timeit(label)

Parameters:

label (str)

Return type:

Callable

z_plane_analysis.discreteResponseTool.utils.with_outdir_policy(func)

Decorator: normalizes known output kwargs using –outdir policy.

Parameters:

func (Callable[[...], Any])

Return type:

Callable[[…], Any]