A standard PID has one problem baked in: the same tuning has to serve two very different jobs, tracking setpoint changes and rejecting disturbances, and what is good for one is often too aggressive for the other. Setpoint weighting is the elegant fix. By scaling how much of the setpoint the proportional and derivative terms are allowed to see, it lets you soften the response to setpoint changes without touching the loop's ability to fight disturbances. This guide explains the beta and gamma weighting factors, how they turn a PID into a two-degree-of-freedom controller, and how they tame proportional kick.
Setpoint weighting in one line: Setpoint weighting introduces factors, commonly called beta and gamma, that scale how much of the setpoint the proportional and derivative terms of a PID respond to, while the integral term still sees the full error. This gives a two-degree-of-freedom controller in which setpoint-tracking behaviour can be softened independently of disturbance-rejection tuning, and it reduces the output kick caused by a setpoint step.
In a conventional PID, every term acts on the error, the difference between setpoint and process variable, and there is a single set of gains that determines everything the loop does. This is what is meant by one degree of freedom: you have one lever, the tuning, and it fixes both how the loop follows a setpoint change and how it rejects a disturbance. The trouble is that these two duties want different things. Good disturbance rejection usually wants fairly assertive proportional and derivative action, but that same assertiveness makes the loop react violently to a setpoint step, producing overshoot and a sharp output kick.
The engineer is then stuck with a compromise. Tune for crisp disturbance rejection and the loop overshoots on setpoint changes; detune to make setpoint changes gentle and the loop becomes lazy at rejecting disturbances. With only one degree of freedom there is no way to have both, because the single tuning cannot distinguish a setpoint change, which the operator caused deliberately, from a disturbance, which the process inflicted and must be fought. Both arrive at the controller as error, and the controller treats them identically.
Setpoint weighting breaks this deadlock by giving the controller a way to tell the two apart at the point where it matters most, the proportional and derivative terms. It does not add a second controller or a separate filter after the fact; it changes what the fast-acting terms respond to, so a setpoint change and a disturbance no longer have to be treated the same way. That is the shift from one degree of freedom to two.
Setpoint weighting inserts two factors into the controller. The proportional term acts not on the full error but on a weighted error, where the setpoint is multiplied by a factor beta, typically between zero and one, before the process variable is subtracted. The derivative term similarly acts on a setpoint weighted by a factor gamma, most often set to zero. The integral term is left alone: it still acts on the true, full error, because integral action is what removes offset and eventually parks the process exactly on setpoint, and weakening that would leave a standing error.
The effect of lowering beta is to soften how hard the proportional term reacts to a setpoint change while leaving its reaction to a disturbance untouched. When the operator moves the setpoint, only beta times that change reaches the proportional term, so the proportional contribution to the resulting output jump is reduced, and the loop approaches the new setpoint with less overshoot. But when a disturbance moves the process variable, the setpoint has not changed, so the weighting is irrelevant and the proportional term responds at full strength. Beta thus gives you a separate lever for setpoint aggressiveness that does not compromise disturbance rejection at all.
Setting gamma to zero has an even sharper purpose. With gamma at zero the derivative term ignores the setpoint entirely and acts only on the process variable, so a step in setpoint produces no derivative response whatsoever, which removes the vicious derivative spike a setpoint step would otherwise cause. Meanwhile the derivative term still reacts fully to the process variable when a disturbance moves it. The pairing of a reduced beta and a zero gamma is what makes a two-degree-of-freedom PID: disturbance rejection is governed by the main gains as before, while the character of the setpoint response is shaped independently by these weights.
The most immediately useful thing setpoint weighting does is tame the output kick that a setpoint step causes. When an operator steps the setpoint, a full-error PID slams its proportional and derivative terms, throwing a sharp spike onto the output that stresses the valve and shocks the process. Lowering beta shrinks the proportional part of that spike and setting gamma to zero removes the derivative part entirely, so the same setpoint change produces a smooth, measured output move instead of a jolt. The loop still gets where it is going, but it arrives without punishing the actuator or overshooting.
It helps to see setpoint weighting alongside its neighbours. It is distinct from derivative filtering, which smooths noise on the measurement and does nothing about setpoint response; setpoint weighting reshapes the response to a clean setpoint change, a different problem. It also generalises the common trick of computing derivative on the measurement instead of error, which is simply the special case of gamma equal to zero. Setpoint weighting exposes that as a tunable factor and adds the proportional weight beta on top, giving fuller and more graduated control over setpoint behaviour than either fix alone.
In a cloud SCADA setting the benefit is easy to confirm on trends, which is where you set the weights. Step the setpoint and watch the output: with weighting applied, the output moves smoothly and the process variable slides into the new value with little or no overshoot, whereas with full-error tuning you see the characteristic spike and overshoot. Across many loops on distributed field assets, being able to review setpoint-change responses remotely lets an engineer tune beta and gamma so operators can move targets without provoking upsets, and lets them catch loops that are still kicking because weighting was never applied. The disturbance-rejection tuning, meanwhile, stays exactly as it was, because that is the whole point of the two-degree-of-freedom structure.
Beta is the factor that scales how much of the setpoint the proportional term sees, and gamma scales how much the derivative term sees. Both are typically between zero and one, and lowering them softens the loop's reaction to setpoint changes. The integral term is left acting on the full error so the process still settles exactly on setpoint. Gamma is very often set to zero to eliminate derivative kick.
It lets you shape the setpoint response independently of the disturbance response. The main PID gains still govern how the loop rejects disturbances, while beta and gamma separately govern how aggressively the loop reacts to a setpoint change. Because a disturbance does not change the setpoint, the weights do not affect it, so you effectively have two separate levers instead of one.
They are related but not identical. A setpoint filter smooths the setpoint signal before it enters the controller, slowing the whole target. Setpoint weighting instead changes how much of the setpoint the proportional and derivative terms respond to, leaving the integral acting on the full error. Weighting gives more precise control over the fast terms specifically, and it is the more common way to build a two-degree-of-freedom PID.
Merobix reads your field devices into a cloud SCADA - the real thing behind these terms, live in days from any browser.