Root Locus: Designing by Moving the Poles

The map nobody hands you

Imagine you are tuning the cruise control on a car. You have one knob — the gain K — that decides how hard the controller pushes the throttle for a given speed error. Turn K up and the car snaps to the target speed faster, but past some point it starts to surge and overshoot; turn it up further and it oscillates forever or flies off the rails. Somewhere in that knob's travel is the sweet spot. Rung 3 told you *which pole positions* give a smooth, well-damped step response; rung 4 told you the left-half plane is where stable systems live. What neither told you is how the poles move as you turn the knob. Root locus is exactly that movie.

Here is the setup. You have a plant with an open-loop transfer function G(s) (the car, the motor, the heater) and you wrap a unity feedback loop around it with an adjustable gain K in the forward path. The closed-loop transfer function is K·G(s) / (1 + K·G(s)). The poles of *that* — the closed-loop poles, the ones that actually decide your response — are the roots of the characteristic equation 1 + K·G(s) = 0. As you sweep K from 0 to ∞, those roots trace continuous curves in the s-plane. Plot every curve and you have the root locus: the complete atlas of where your design can possibly go, before you build a single thing.

Two conditions that draw every branch

A point s is *on* the root locus if and only if 1 + K·G(s) = 0 for some positive real K. Rewrite that as K·G(s) = −1. Because s is a complex number, this is really two equations at once. The magnitude condition says |K·G(s)| = 1, which just tells you the *value of K* needed at that point — useful later when you read off a gain. The angle condition is the one that draws the picture: the total angle of G(s) must equal −180° (or any odd multiple, ±180°, ±540°, …). A point lives on the locus only if the angles from all the open-loop poles and zeros to that point add up to an odd multiple of 180°.

  angle condition (the shape):   Σ∠(zeros→s)  −  Σ∠(poles→s)  =  ±180°(2m+1)
  magnitude condition (the gain):       K  =  ───────────────────────────────
                                                Π|zeros→s| / Π|poles→s|   (inverted)

         draw the branches with ANGLES,   then label each point with K via MAGNITUDE

You will almost never apply these conditions point-by-point by hand — that is what a computer does. Instead, control engineers distilled them into a handful of sketching rules that let you draw a faithful locus in under a minute on a napkin. Knowing the rules is not nostalgia: it builds the intuition that tells you *which way to nudge a compensator* when MATLAB's plot looks wrong. Let's collect the rules, then put them to work.

The six sketching rules

Let G(s) have n poles and m zeros (always n ≥ m for a real plant). These rules cover everything you need for the worked example and 90% of exam and bench problems.

1. Branches and endpoints. There are n branches. Each starts (K=0) at an open-loop pole and ends (K=∞) at an open-loop zero. The n−m 'extra' branches that have no finite zero to land on run off to infinity along asymptotes.
2. Symmetry. The locus is mirror-symmetric about the real axis, because complex poles always come in conjugate pairs. Draw the top half; the bottom is its reflection.
3. Real-axis segments. A point on the real axis is on the locus if the total number of real poles *and* zeros to its right is odd. Sweep from +∞ leftward and the locus flips on and off at each real pole/zero you cross.
4. Asymptotes. The n−m runaway branches approach straight lines at angles θ = ±180°(2k+1)/(n−m), all radiating from a common point on the real axis called the centroid, σ_a = (Σpoles − Σzeros)/(n−m).
5. Breakaway / break-in points. Where two branches meet on the real axis and then split off into the complex plane (or merge back), gain K is locally maximal (or minimal). Find these by solving dK/ds = 0 on the real-axis segment.
6. jω-axis crossings. Where a branch crosses the imaginary axis, the closed-loop poles are purely oscillatory — that K is the stability limit. Find it with the Routh array (rung 4) or by substituting s = jω into the characteristic equation.

A worked example, start to finish

Take a classic third-order plant — say a DC motor with a lagging amplifier, the kind of thing you actually meet on a bench: G(s) = 1 / [s(s+2)(s+4)]. Three open-loop poles at s = 0, −2, −4; no finite zeros. So n = 3, m = 0, and all three branches must run to infinity. Let's apply the rules in order.

                      jω
                       |
        K=Kcr → +j2.83 |*           branches break away at s = -0.85,
                       | \          climb, and cross jω-axis at ±j2.83
                       |  \         when K = Kcr = 48  (instability!)
          ────x────x───┴───x──────────►  σ
             -4   -2  -0.85 0
                       |  /
                       | /
              -j2.83 →|*
                       |
   real-axis locus:  [-4,-2]  and  [0 to -inf]   (odd # of poles/zeros to the right)
   asymptotes:  ±60°, 180°   from centroid  σa = -2

1. Real-axis segments. Sweep from the right. Between 0 and −2 there is one pole (at 0) to the right → odd → locus *is* here. Between −2 and −4 there are two poles to the right → even → *not* here. Left of −4 there are three → odd → locus *is* here. So segments are [0, −2] and [−4, −∞).
2. Asymptotes. n−m = 3, so three asymptotes at θ = 60°, 180°, 300°, all leaving the centroid σ_a = (0−2−4)/3 = −2. Two branches will sail up and down at 60°/300°; one runs straight out along the negative real axis at 180°.
3. Breakaway point. On the [0, −2] segment, write K = −s(s+2)(s+4) and solve dK/ds = 0 → 3s² + 12s + 8 = 0 → s = −0.85 (the other root, −3.15, lies on the non-locus segment, so discard it). The two right-hand branches break away here.
4. jω crossing & stability limit. Substitute s = jω into 1 + K·G = s³ + 6s² + 8s + K = 0. Real part: −6ω² + K = 0; imaginary part: −ω³ + 8ω = 0 → ω = √8 = 2.83 rad/s, giving K_cr = 6·8 = 48. Above K = 48 the loop is unstable. (Routh from rung 4 gives the same answer.)

Reading the gain off the map

Now the payoff. Rung 3 taught you that a pair of complex poles at angle β from the negative real axis has a damping ratio ζ = cos β, and that ζ ≈ 0.5 (β = 60°) gives a crisp ~16% overshoot, while ζ ≈ 0.7 (β = 45°) gives the textbook ~5%. Suppose your spec is ζ = 0.5. Draw a ray from the origin at 60° off the negative real axis and find where it crosses the locus. That intersection *is* the closed-loop pole that meets your damping spec. For our plant it lands near s = −0.7 ± j1.2.

To find the gain K that *puts* a pole there, use the magnitude condition — and it has a beautiful graphical form: K = (product of distances from that point to every open-loop pole) ÷ (product of distances to every open-loop zero). Just measure lengths on your sketch and multiply.

  target pole  s* = -0.7 + j1.2   (ζ = 0.5 ray)

  distance s* → pole @ 0 :   |(-0.7)+j1.2|          = 1.39
  distance s* → pole @ -2:   |( 1.3)+j1.2|          = 1.77
  distance s* → pole @ -4:   |( 3.3)+j1.2|          = 3.51

  K = 1.39 × 1.77 × 3.51 / (1)  ≈  8.6

  settling time  ts ≈ 4 / (ζωn) = 4 / |Re(s*)| = 4 / 0.7 ≈ 5.7 s
  (overshoot from ζ=0.5  →  Mp = e^(-πζ/√(1-ζ²)) ≈ 16%)

So K ≈ 8.6 hits ζ = 0.5 — comfortably below the K_cr = 48 stability ceiling, with margin to spare. If instead your spec were a settling time (say t_s ≤ 4 s ⇒ ζω_n ≥ 1 ⇒ real part ≤ −1), you would draw a *vertical* line at σ = −1 and read off the gain where the locus crosses it. Damping spec → a *ray*; settling-time spec → a *vertical line*; natural-frequency spec → a *circle*. The locus turns every time-domain requirement into a region on the map, and the gain is wherever the curve enters that region.

From locus to compensator

What if the locus simply never passes through the pole you want? That happens constantly — the plant's poles are where they are, and a single gain knob can only slide the closed-loop poles *along the existing curves*. This is where root locus becomes a *design* tool rather than just an analysis tool: you reshape the locus by adding poles and zeros of your own. That is precisely what a PID controller or a lead/lag compensator does. Adding a zero *pulls* the locus toward it (into the left-half plane → more stable, more damped); adding a pole *pushes* the locus away (toward instability, but useful for shaping low-frequency behavior).

This is the mindset shift root locus gives you, and why it has survived 75 years of fancier methods. PID tuning by Ziegler–Nichols or by feel asks 'what gains?' and answers by trial. Root locus asks 'where do I want the closed-loop poles to sit?' — choose the spot in the s-plane where the step response you want already lives — and then works *backward* to the controller that lands them there. You design the *answer* first and solve for the knobs second. Combined with the Bode plot and Nyquist criterion you'll meet next, it gives you a complete graphical language for feedback design — one where stability, speed, and damping are all things you can *see* before you ever touch hardware.