In previous lessons you learned how the Nichols plot represents the open-loop frequency response \( L(j\omega) \) in a phase–magnitude (in dB) plane, and how closed-loop properties such as gain crossover and phase margin can be read directly from it. In this lesson we focus on the sensitivity function \( S(j\omega) \), which measures how strongly the closed-loop system reacts to reference, disturbance, and model perturbations as a function of frequency.

For a unity-feedback loop, the sensitivity is defined by \( S(s) = \frac{1}{1+L(s)} \), where \( L(s) = C(s)G(s) \) is the loop transfer function of controller \( C(s) \) and plant \( G(s) \). The complementary sensitivity \( T(s) = \frac{L(s)}{1+L(s)} \) describes how the output tracks the reference. On the Nichols chart, closed-loop performance and robustness requirements are often expressed as bounds on the peak sensitivity \( M_S = \sup_{\omega} |S(j\omega)| \).

flowchart TD
  P["Plant model G(s)"] --> C["Controller C(s)"]
  C --> L["Loop L(s) = C(s) * G(s)"]
  L --> FREQ["Compute L(jw)"]
  FREQ --> NICH["Plot (phase, 20log10|L|)"]
  NICH --> SREAD["Interpret S(jw) and T(jw)"]
  SREAD --> SPEC["Check sensitivity specs: Ms, bandwidth, margins"]
        

Our goal is to obtain explicit mathematical relationships that allow us to compute and visualize sensitivity directly on the Nichols chart, and to use these relationships when choosing and tuning controllers in robotic and mechatronic systems.

Consider a standard unity-feedback configuration. Let \( R(s) \) be the reference input and \( Y(s) \) the output. The error is \( E(s) = R(s) - Y(s) \), the controller output is \( U(s) = C(s)E(s) \), and the plant output is \( Y(s) = G(s)U(s) \). Eliminating intermediate variables,

\[ \begin{aligned} Y(s) &= G(s)C(s)\bigl(R(s) - Y(s)\bigr) = L(s)\bigl(R(s) - Y(s)\bigr), \\ Y(s)\bigl(1 + L(s)\bigr) &= L(s)R(s), \\ \frac{Y(s)}{R(s)} &= \frac{L(s)}{1 + L(s)}. \end{aligned} \]

The complementary sensitivity function (closed-loop transfer from reference to output) is therefore

\[ T(s) = \frac{L(s)}{1 + L(s)}. \]

The sensitivity function is defined as

\[ S(s) = \frac{1}{1 + L(s)}. \]

The two functions satisfy the fundamental identity

\[ S(s) + T(s) = \frac{1}{1 + L(s)} + \frac{L(s)}{1 + L(s)} = 1. \]

In the frequency domain, we evaluate them on the imaginary axis: \( S(j\omega) = \frac{1}{1 + L(j\omega)} \) and \( T(j\omega) = \frac{L(j\omega)}{1 + L(j\omega)} \). Large loop gain \( |L(j\omega)| \) tends to make \( |S(j\omega)| \) small (good disturbance rejection) but can also lead to poor robustness if the Nyquist plot approaches the critical point \( -1 + j0 \).

Let us first understand sensitivity in the Nyquist plane before mapping it to the Nichols chart. Denote \( L(j\omega) = x(\omega) + j\,y(\omega) \), i.e., \( x(\omega) = \Re\{L(j\omega)\} \) and \( y(\omega) = \Im\{L(j\omega)\} \). Then

\[ S(j\omega) = \frac{1}{1 + L(j\omega)} = \frac{1}{1 + x(\omega) + j\,y(\omega)}. \]

The magnitude of the sensitivity is

\[ |S(j\omega)| = \frac{1}{\sqrt{\bigl(1 + x(\omega)\bigr)^2 + y(\omega)^2}}. \]

Fix a constant value \( M_S > 0 \) and consider all points in the Nyquist plane that satisfy \( |S(j\omega)| = M_S \). Squaring both sides:

\[ M_S^2 = \frac{1}{\bigl(1 + x(\omega)\bigr)^2 + y(\omega)^2} \quad \Longrightarrow \quad \bigl(1 + x(\omega)\bigr)^2 + y(\omega)^2 = \frac{1}{M_S^2}. \]

This is the equation of a circle in the Nyquist plane with

• center at \( \bigl(-1,\,0\bigr) \), and
• radius \( \frac{1}{M_S} \).

Thus, constant-sensitivity loci in the Nyquist plane are simply circles around \( -1 + j0 \). The smaller the radius, the larger the sensitivity level \( M_S \). For a given closed-loop design, the peak sensitivity \( M_S \) is determined by the smallest distance between the Nyquist curve of \( L(j\omega) \) and the critical point \( -1 + j0 \).

This geometric picture is central: if the Nyquist curve passes very close to \( -1 + j0 \), then \( |1 + L(j\omega)| \) becomes small and \( |S(j\omega)| \) becomes large, indicating poor robustness and high amplification of disturbances or modeling errors at those frequencies.

The Nichols chart displays \( L(j\omega) \) by plotting the phase \( \varphi(\omega) = \arg L(j\omega) \) on the horizontal axis and the magnitude in decibels \( M_{\mathrm{dB}}(\omega) = 20\log_{10}|L(j\omega)| \) on the vertical axis. Let us write

\[ L(j\omega) = |L(j\omega)|\,e^{j\varphi(\omega)}. \]

Using the complex representation, we have

\[ 1 + L(j\omega) = 1 + |L(j\omega)|\bigl(\cos\varphi(\omega) + j\sin\varphi(\omega)\bigr), \]

so that

\[ \begin{aligned} |1 + L(j\omega)|^2 &= \bigl(1 + |L(j\omega)|\cos\varphi(\omega)\bigr)^2 + \bigl(|L(j\omega)|\sin\varphi(\omega)\bigr)^2 \\ &= 1 + |L(j\omega)|^2 + 2|L(j\omega)|\cos\varphi(\omega). \end{aligned} \]

Therefore the sensitivity magnitude is

\[ |S(j\omega)|^2 = \frac{1}{1 + |L(j\omega)|^2 + 2|L(j\omega)|\cos\varphi(\omega)}. \]

For a given sensitivity level \( M_S \), the corresponding constant-sensitivity locus on the Nichols chart satisfies

\[ \frac{1}{M_S^2} = 1 + |L(j\omega)|^2 + 2|L(j\omega)|\cos\varphi(\omega). \]

For fixed \( \varphi \), this is a quadratic equation in \( |L| \):

\[ |L|^2 + 2\cos\varphi\,|L| + \Bigl(1 - \frac{1}{M_S^2}\Bigr) = 0. \]

Solving for \( |L| \):

\[ |L| = -\cos\varphi \pm \sqrt{\cos^2\varphi - \Bigl(1 - \frac{1}{M_S^2}\Bigr)}. \]

Only positive roots are physically meaningful. Converting \( |L| \) to decibels via \( 20\log_{10}|L| \) yields the constant-sensitivity contour in the Nichols plane. Standard Nichols charts used in control engineering textbooks and software include a family of such contours for various values of \( |T(j\omega)| \) and \( |S(j\omega)| \), precomputed using the above relationship.

The peak sensitivity is defined as

\[ M_S = \sup_{\omega \in \mathbb{R}} |S(j\omega)|. \]

On the Nichols chart, this corresponds to the highest constant-sensitivity contour that the locus \( L(j\omega) \) touches. The peak sensitivity plays several roles:

• Disturbance amplification: frequencies where \( |S(j\omega)| > 1 \) correspond to disturbance components that are amplified by feedback rather than attenuated.
• Model uncertainty: for multiplicative plant uncertainty, small values of \( |S(j\omega)| \) give robustness against relative model errors at that frequency.
• Closed-loop dynamics: large \( M_S \) is associated with underdamped closed-loop poles (large overshoot) and poor stability margins; moderate \( M_S \) suggests better damping and robustness.

Typical design guidelines in classical single-input single-output (SISO) control are to keep \( M_S \) below about \( 2 \) (approximately 6 dB). Values between \( 1.3 \) and \( 1.8 \) are often preferred for high-performance servo systems, balancing fast tracking, disturbance rejection, and robustness to modeling errors.

In Nichols-chart design, one often draws the \( M_S \)-contour corresponding to the chosen robustness level and then shapes \( L(j\omega) \) (via gain and compensator structure) so that the open-loop locus remains outside this contour for all frequencies.

Consider a simplified rotational joint of a robotic manipulator with inertia \( J \) and viscous friction \( B \). Neglecting elasticity and Coulomb friction, the linearized equation of motion about an operating point is

\[ J\ddot{\theta}(t) + B\dot{\theta}(t) = \tau_m(t), \]

where \( \theta(t) \) is the joint angle and \( \tau_m(t) \) is the control torque produced by the motor. Taking Laplace transforms and assuming zero initial conditions,

\[ \Theta(s)\bigl(Js^2 + Bs\bigr) = \tau_m(s), \quad G(s) = \frac{\Theta(s)}{\tau_m(s)} = \frac{1}{Js^2 + Bs} = \frac{1}{Js\bigl(s + B/J\bigr)}. \]

A proportional-derivative (PD) position controller has the form \( C(s) = K_p + K_d s \). The open-loop transfer function is

\[ L(s) = C(s)G(s) = \frac{K_d s + K_p}{Js^2 + Bs}. \]

For a given choice of \( K_p \) and \( K_d \), we can compute \( L(j\omega) \), plot its Nichols locus, and evaluate \( S(j\omega) = \frac{1}{1+L(j\omega)} \). The frequency at which \( |S(j\omega)| \) attains its maximum contributes strongly to overshoot and resonant behavior in the joint response.

A typical design workflow for such a servo is:

1. Choose initial gains to achieve desired bandwidth on the Nichols plot.
2. Read off phase and gain margins and an approximate peak sensitivity \( M_S \) using the sensitivity contours.
3. Adjust \( K_p \) and \( K_d \) (or add lead/lag elements) to keep \( M_S \) below the specified level while satisfying tracking performance.

In robotics software stacks, this kind of analysis is often performed offline using linear models extracted from simulation tools (e.g., MATLAB Robotics System Toolbox, Python roboticstoolbox, or C++/ROS dynamics libraries) and then used to tune low-level controllers that run in real time.

The following Python script uses the python-control library (and optionally the roboticstoolbox ecosystem) to compute the Nichols plot and peak sensitivity of the robotic joint servo example. It can be integrated into a robotics pipeline for offline analysis of joint controllers.

import numpy as np
import control  # python-control library (classical control tools)
from control import matlab

# Approximate robotic joint: J = 0.01 kg m^2, B = 0.1 N m s/rad
J = 0.01
B = 0.1

# G(s) = 1 / (J s^2 + B s) = 100 / (s (s + 10))
numG = [100.0]
denG = [1.0, 10.0, 0.0]
G = matlab.tf(numG, denG)

# PD controller C(s) = Kd s + Kp
Kp = 20.0
Kd = 1.0
C = matlab.tf([Kd, Kp], [1.0])

# Loop transfer, sensitivity, complementary sensitivity
L = C * G
S = control.feedback(control.tf([1.0], [1.0]), L)  # 1 / (1 + L)
T = control.feedback(L, control.tf([1.0], [1.0]))  # L / (1 + L)

# Frequency grid for analysis
omega = np.logspace(-1, 3, 400)  # 0.1 to 100 rad/s

# Frequency response of S(jw)
magS, phaseS, omega_out = control.freqresp(S, omega)
magS = magS.flatten()  # python-control returns 3D arrays

Ms = float(np.max(magS))
Ms_dB = 20.0 * np.log10(Ms)
print("Peak sensitivity Ms = {:.3f} ({:.2f} dB)".format(Ms, Ms_dB))

# Nichols plot of L(jw)
control.nichols_plot(L, omega)
# In an interactive environment, you can overlay constant-S contours
# using control.nichols_grid() or by precomputing the curves.
      

In a robotics context, one can obtain \( G(s) \) by linearizing a nonlinear manipulator model (for example, using Python roboticstoolbox) around a configuration and then invoking the above pipeline to evaluate Nichols-based sensitivity and robustness metrics.

In C++, one typically combines std::complex (for frequency response) with linear algebra libraries such as Eigen and robotics frameworks such as ROS (ros_control, gazebo_ros_control) or Orocos. The code below computes \( L(j\omega) \) and \( S(j\omega) \) over a logarithmic grid and reports the peak sensitivity. Nichols-plot data can be exported and visualized with tools like gnuplot or Python.

#include <iostream>
#include <vector>
#include <complex>
#include <cmath>

int main() {
    using std::complex;
    using std::vector;

    const double J = 0.01;
    const double B = 0.1;
    const double Kp = 20.0;
    const double Kd = 1.0;

    auto G = [J, B](double w) {
        complex<double> s(0.0, w);
        return 1.0 / (J * s * s + B * s);
    };

    auto C = [Kp, Kd](double w) {
        complex<double> s(0.0, w);
        return Kd * s + Kp;
    };

    // Logarithmic frequency grid: 0.1 to 100 rad/s
    vector<double> omega;
    const int N = 400;
    const double logw_min = std::log10(0.1);
    const double logw_max = std::log10(100.0);
    for (int k = 0; k < N; ++k) {
        double alpha = static_cast<double>(k) / static_cast<double>(N - 1);
        double logw = logw_min + alpha * (logw_max - logw_min);
        omega.push_back(std::pow(10.0, logw));
    }

    double Ms = 0.0;

    for (std::size_t k = 0; k < omega.size(); ++k) {
        double w = omega[k];
        complex<double> L = C(w) * G(w);
        complex<double> S = 1.0 / (1.0 + L);
        double magS = std::abs(S);
        if (magS > Ms) {
            Ms = magS;
        }

        // Export Nichols data: phase (deg), magnitude (dB)
        double phase_deg = std::arg(L) * 180.0 / M_PI;
        double mag_db = 20.0 * std::log10(std::abs(L));
        std::cout << phase_deg << " " << mag_db << std::endl;
    }

    std::cerr << "Peak sensitivity Ms = " << Ms << std::endl;
    return 0;
}
      

In a ROS-based robotic controller, such a utility can be used offline to evaluate how changes in PD gains for a joint trajectory controller affect Nichols-based sensitivity and robustness, before deploying parameters to the real robot via ros_control.

For Java-based control and robotics frameworks (for example on embedded controllers or simulation back-ends), the Apache Commons Math library (org.apache.commons.math3.complex.Complex) and matrix libraries such as EJML are commonly used. The following code illustrates Nichols and sensitivity computation for our joint servo model.

import org.apache.commons.math3.complex.Complex;

public class NicholsSensitivity {

    private static final double J = 0.01;
    private static final double B = 0.1;
    private static final double Kp = 20.0;
    private static final double Kd = 1.0;

    static Complex G(double w) {
        Complex s = new Complex(0.0, w);
        return Complex.ONE.divide(
                s.multiply(s).multiply(J).add(s.multiply(B))
        );
    }

    static Complex C(double w) {
        Complex s = new Complex(0.0, w);
        return s.multiply(Kd).add(Kp);
    }

    public static void main(String[] args) {
        int N = 400;
        double logwMin = Math.log10(0.1);
        double logwMax = Math.log10(100.0);

        double Ms = 0.0;

        for (int k = 0; k < N; ++k) {
            double alpha = (double) k / (double) (N - 1);
            double logw = logwMin + alpha * (logwMax - logwMin);
            double w = Math.pow(10.0, logw);

            Complex L = C(w).multiply(G(w));
            Complex S = Complex.ONE.divide(Complex.ONE.add(L));
            double magS = S.abs();
            if (magS > Ms) {
                Ms = magS;
            }

            double phaseDeg = Math.toDegrees(L.getArgument());
            double magDb = 20.0 * Math.log10(L.abs());
            System.out.printf("%f %f%n", phaseDeg, magDb);
        }

        System.err.printf("Peak sensitivity Ms = %.3f%n", Ms);
    }
}
      

Java-based robotics frameworks (for example, custom simulation engines or JVM-based middleware) can embed such analysis routines to automatically check whether candidate controller gains satisfy Nichols-based sensitivity limits before deployment.

MATLAB is widely used in control and robotics, with the Control System Toolbox and Robotics System Toolbox providing built-in functions to obtain linear models from complex robotic manipulators. The script below computes Nichols plots and peak sensitivity for the PD-controlled joint.

% MATLAB script for Nichols-based sensitivity analysis

s = tf('s');

J = 0.01;
B = 0.1;
G = 1 / (J * s^2 + B * s);     % Joint dynamics

Kp = 20;
Kd = 1;
C = Kd * s + Kp;               % PD controller

L = C * G;
S = feedback(1, L);            % S(s) = 1 / (1 + L)
T = feedback(L, 1);            % T(s) = L / (1 + L)

w = logspace(-1, 3, 400);
[magS, phaseS] = bode(S, w);
magS = squeeze(magS);
Ms = max(magS);
Ms_dB = 20 * log10(Ms);

fprintf('Peak sensitivity Ms = %.3f (%.2f dB)\n', Ms, Ms_dB);

figure;
nichols(L, w);
grid on;
title('Nichols Plot of L(s) for Robotic Joint Servo');

% In Robotics System Toolbox, a more realistic G(s) can be obtained by:
% robot = importrobot('someRobot.urdf');
% linSys = linearize(robotSimModel, operatingPoint);
% and then L = C * linSys for Nichols analysis.
      

In Simulink, one can construct the full joint servo loop (including saturation and sensor dynamics), linearize the model around an operating point, and then automatically generate Nichols plots and sensitivity information using tools like Linear Analysis Tool.

Mathematica can also be used to compute Nichols data and sensitivity functions for symbolic or numeric plants. The code below constructs the PD-controlled joint servo, generates Nichols coordinates, and evaluates the peak sensitivity.

(* Wolfram Mathematica code for Nichols-based sensitivity *)

J = 0.01;
B = 0.1;
Kp = 20.0;
Kd = 1.0;

L[s_] := (Kd*s + Kp)/(J*s^2 + B*s);

wRange = Table[10^x, {x, -1, 3, 0.01}];

loopResp = Table[
   Module[{w = wVal, Ljw, Sjw},
    Ljw = L[I*w];
    Sjw = 1/(1 + Ljw);
    {
     Arg[Ljw]*180/Pi,             (* phase in degrees *)
     20*Log10[Abs[Ljw]],          (* magnitude in dB *)
     Abs[Sjw]                     (* |S(jw)| *)
     }
    ],
   {wVal, wRange}
   ];

phaseDeg = loopResp[[All, 1]];
magDb = loopResp[[All, 2]];
sensMag = loopResp[[All, 3]];

Ms = Max[sensMag];
MsDb = 20*Log10[Ms];

Print["Peak sensitivity Ms = ", Ms, " (", MsDb, " dB)"];

ListLinePlot[
  Transpose[{phaseDeg, magDb}],
  Frame -> True,
  FrameLabel -> {"phase (deg)", "20 log10|L(jw)|"},
  PlotRange -> All
]
      

Symbolic manipulation in Mathematica can also be used to derive closed-form expressions for \( S(s) \) and constant-sensitivity contours for simple loop shapes, providing additional analytical insight beyond numerical Nichols plots.

Problem 1 (Constant-Sensitivity Circle in Nyquist Plane). Let \( L(j\omega) = x(\omega) + j\,y(\omega) \) and \( S(j\omega) = \frac{1}{1+L(j\omega)} \). Show that the locus of points where \( |S(j\omega)| = M_S \) is a circle in the Nyquist plane with center \( \bigl(-1,0\bigr) \) and radius \( \frac{1}{M_S} \).

Solution. From the definition,

\[ S(j\omega) = \frac{1}{1 + x(\omega) + j\,y(\omega)}. \]

Thus

\[ |S(j\omega)| = \frac{1}{\sqrt{\bigl(1 + x(\omega)\bigr)^2 + y(\omega)^2}}. \]

Imposing \( |S(j\omega)| = M_S \) and squaring gives

\[ M_S^2 = \frac{1}{\bigl(1 + x(\omega)\bigr)^2 + y(\omega)^2} \quad \Longrightarrow \quad \bigl(x(\omega) + 1\bigr)^2 + y(\omega)^2 = \frac{1}{M_S^2}. \]

This is exactly the equation of a circle centered at \( (-1,0) \) with radius \( \frac{1}{M_S} \). The Nyquist curve of \( L(j\omega) \) must stay outside this circle if \( |S(j\omega)| \leq M_S \) for all frequencies.

Problem 2 (Sensitivity from Nichols Coordinates). Suppose at some frequency \( \omega_0 \) the Nichols plot of \( L(j\omega) \) passes through a point with magnitude \( |L(j\omega_0)| = 4 \) and phase \( \varphi(\omega_0) = -140^\circ \). Compute \( |S(j\omega_0)| \).

Solution. Using the formula

\[ |S(j\omega)|^2 = \frac{1}{1 + |L(j\omega)|^2 + 2|L(j\omega)|\cos\varphi(\omega)}, \]

we substitute \( |L| = 4 \) and \( \varphi = -140^\circ \), noting that \( \cos(-140^\circ) = \cos(140^\circ) \):

\[ \begin{aligned} |S(j\omega_0)|^2 &= \frac{1}{1 + 4^2 + 2\cdot 4 \cos(-140^\circ)} \\ &= \frac{1}{1 + 16 + 8 \cos(140^\circ)}. \end{aligned} \]

Since \( \cos(140^\circ) \approx -0.766 \), we obtain

\[ |S(j\omega_0)|^2 \approx \frac{1}{1 + 16 - 6.128} = \frac{1}{10.872}, \quad |S(j\omega_0)| \approx 0.303. \]

Thus at this frequency the closed-loop sensitivity is significantly below unity, meaning disturbances at this frequency are attenuated.

Problem 3 (Nichols-Based Sensitivity Constraint). For a unity-feedback system, a design specification may require \( M_S \leq 2 \) (i.e., \( |S(j\omega)| \leq 2 \) for all \( \omega \)). What is the corresponding radius of the forbidden circle around \( -1 + j0 \) in the Nyquist plane, and how does this translate qualitatively to the Nichols chart?

Solution. For \( M_S = 2 \), the constant-sensitivity circle has radius

\[ r = \frac{1}{M_S} = \frac{1}{2} = 0.5, \]

centered at \( -1 + j0 \). The Nyquist curve must remain outside this circle (i.e., the minimum distance from \( -1 + j0 \) must be at least \( 0.5 \)). On the Nichols chart, this requirement corresponds to staying outside the \( M_S = 2 \) constant-sensitivity contour. As the loop gain or phase is altered, one must check that the Nichols locus does not penetrate this contour.

Problem 4 (Effect of Loop Gain on Sensitivity Near Crossover). Assume that for some controller, the Nichols locus of \( L(j\omega) \) passes close to the point \( (-180^\circ, 0\ \mathrm{dB}) \). Explain qualitatively what this implies about the sensitivity function and robustness.

Solution. The point \( (-180^\circ, 0\ \mathrm{dB}) \) corresponds to \( L(j\omega) = -1 + j0 \) in the Nyquist plane, since zero dB means \( |L| = 1 \) and phase \( -180^\circ \) means \( L = -1 \). At this point,

\[ S(j\omega) = \frac{1}{1 + L(j\omega)} = \frac{1}{1 - 1} = \infty, \]

so the sensitivity would be unbounded and the closed loop unstable. If the locus passes very close to this point, then \( |1 + L(j\omega)| \) becomes small and \( |S(j\omega)| \) becomes very large. This indicates high sensitivity to disturbances and model errors in a narrow frequency band around the crossover frequency, and small uncertainties could push the Nyquist curve inside the \( M_S \) circle, leading to instability. Thus one seeks a Nichols design in which the locus at crossover stays safely away from \( (-180^\circ, 0\ \mathrm{dB}) \).

Problem 5 (Design Iteration Based on Sensitivity in Nichols Plot). Sketch a feedback design loop that uses Nichols plots to iteratively adjust a controller \( C(s) \) until a target peak sensitivity \( M_S^\ast \) is met, while maintaining desired bandwidth.

Solution (design flow).

flowchart TD
  ST["Start: initial controller C(s)"] --> NICH["Compute Nichols curve of L(s)"]
  NICH --> READ["Read Ms from sensitivity contours"]
  READ --> DEC["Is Ms <= Ms_target and bandwidth OK?"]
  DEC -->|yes| DONE["Accept controller"]
  DEC -->|no| ADJ["Adjust C(s): gain, lead/lag, or filters"]
  ADJ --> NICH
        

This iterative procedure is implemented in many control design tools where the engineer interactively moves or reshapes the Nichols locus and observes how \( M_S \), bandwidth, and stability margins change in real time.

In this lesson we connected the sensitivity function \( S(s) = \frac{1}{1+L(s)} \) and the complementary sensitivity \( T(s) = \frac{L(s)}{1+L(s)} \) to the Nichols representation of the loop transfer function \( L(j\omega) \). We derived explicit formulas for \( |S(j\omega)| \) in terms of the magnitude and phase of \( L(j\omega) \), and we showed that constant-sensitivity loci are circles in the Nyquist plane centered at \( -1 + j0 \), and appear as characteristic curves on the Nichols chart.

The peak sensitivity \( M_S \) was highlighted as a key scalar measure of robustness and disturbance amplification. Using a robotic joint servo example, we illustrated how Nichols-based sensitivity constraints guide controller tuning. Multi-language implementations in Python, C++, Java, MATLAB/Simulink, and Mathematica demonstrated how Nichols plots and sensitivity functions can be computed and integrated into modern robotic and control engineering workflows.

In subsequent chapters on stability margins and robust performance, these sensitivity-based interpretations will be combined with classical gain and phase margins to form a more complete picture of frequency-domain robustness trade-offs.