The theory
Many computational software tools available contain optimization functions. The algorithm may be thought of intuitively as minimizing the difference between the solution of the function that describes the system, and the desired outcome. The problem may be represented mathematically as:

Minimize _χ,ξ,ξ such that:

Subject to the constraints:

One popular algorithm that is used to solve constrained multi-objective optimization problems is sequential quadratic programming (SQP)[1]. The SQP algorithm may be thought of as a modified form of Newton's method and converges in relatively few iterations. This algorithm is implemented in MATLAB's fgoalattain function and simplifies the development of an optimization routine.

Software implementation
The SQP algorithm implemented in MATLAB's fgoalattain function has input arguments that include the function to be optimized, initial values, goals, goal weights, constraints, and a variety of options to display the goal attainment progress or exit condition. To implement the function "fgoalattain" in MATLAB, the following form may be used:

[x, fval, attainfactor] = fgoalattain(fun, x0, goal, weight, A, b, Aeq, beq, lb, ub, nonlcon, options)

Using a controller design example, the input argument fun is a MATLAB function that may return parameters such as overshoot, rise time, and some measure of robustness of a closed loop switchmode power supply. The input argument x0 are the initial controller values and may be calculated using standard rules of thumb [2]. The weights may be chosen according to the relative importance of the design goals. For equal weighting of the design goals, set the variable weight equal to absolute value of the goal vector. If a weight is set equal to zero it will be treated as a hard constraint and the solver will prioritize that goal.

The input arguments A, b, Aeq, beq, lb, up, and nonlcon are constraints as described in the previous section. The values for the constraints depend on the design space the designer is able to work within. If a constraint is to be ignored, a set of braces "[]" may be entered in its place. The input argument options allows several internal parameters of the solver to be printed to the command window. Using this feature can be useful to check the progress of a particular computation.

For illustrative purposes, consider the following simple example, where the goals are pole locations. Let a system be described by the transfer function:

where a is some design parameter.

Let the design goal be to have the system poles at s = –1 rps, –10 rps, and –100 rps. This may be done using the following code:

function a = root_loc

a0 = 1; % Initial guess for a
goal = [-100 -10 -1]; % Pole placement goal
weight = abs(goal); % Equal weighting of goals
options = optimset('LargeScale', 'off', 'Display', 'iter', 'GoalsExactAchieve', 3); [a,fval,attainfactor] = fgoalattain(@sysfun,...
    a0,goal,weight,[],[],[],[],[],[],[],[]) % Optimization function
    function r = sysfun(a) % System function
        sys_den = [1 111 1110 a]; % Denominator of system transfer function
        r = roots(sys_den); % Calculate the poles of the system
    end
end

After the program executes the code above, the following appears in the MATLAB command window:

Optimization terminated: magnitude of directional derivative in search
direction less than 2*options.TolFun and maximum constraint violation
is less than options.TolCon.
Active inequalities (to within options.TolCon = 1e-006):
   lower    upper   ineqlin    ineqnonlin
                             1
                             2
                             3

a = 1000.00000002537

fval = -100.000000000003
         -9.99999999996868
         -1.00000000002847

attainfactor = 3.77294549557555e-013

Here we see that the program terminated because it could not make significant headway in performing additional iterations. Note that very small attainment factors indicate that the goals are almost exactly met. Beyond that consideration, positive values indicate underachievement; and negative values indicate overachievement. In this case, the design objectives were met for all practical purposes.

For more information on the function fgoalattain, refer to The Mathworks website (www.mathworks.com). To see the MATLAB code that implements the fgoalattain algorithm, simply type "type fgoalattain" at the MATLAB command line prompt.

Design example
As an example of how powerful this approach can be, assume a buck regulator with type 2 controller is to be designed with the following specifications:

Maximum overshoot ≤5 percent
Rise time ≤100 microseconds

The controller must also be robust, having gain and phase margins on the order of 10 dB, and 53 degrees, respectively.

Let's use the National Semiconductor LM2657, an adjustable 200-to-500 kHz sychronous buck regulator. It's a dual-channel voltage-mode controlled type for high-current applications. The LM2657 requires only n-channel FETs for both the upper and lower positions of each stage. It has the following parameters and operating conditions:

Assume that the transient performance is of greater importance than robustness and is weighted appropriately. A multi-objective optimization routine that incorporates the disc margin measure of gain and phase margin (i.e., disk margin is a measure of robustness based on the Nyquist plot and a disc centered at the point –1, 0) is then executed. The routine generates the following numbers:

It then calculates the component values: R₂ = 42.3 kilohms, R₃ = 7.52 kilohms, C₂ = 2.36 pF, C₃ = 1.99 nF

The loop gain, and system transient response are shown in figures 2 and 3, respectively.

Note that the design goals have been underachieved. At this point the designer may choose to either try meeting the goals using type 3 compensation, reconsider the importance and therefore the weights of the given specifications, or simply accept the given design. Typically, the designer will accept the results of an initial paper design since the measured results invariably deviate from those calculated.

Summary
Given a set of requirements, the variables in a system model may be adjusted to meet those requirements using multi-objective optimization. The MATLAB function fgoalattain faciliates this optimization. Applications of such routines are far reaching and may be extended to any area of power electronics.

About the author
Joel Steenis, a circuit design engineer for National Semiconductor, has degrees in electrical engineering and mathematics from the University of Arizona in Tucson. He is currently pursuing a masters degree in electrical engineering at the University of Southern California.

References
[1] Gembicki, F.W., "Vector Optimization for Control with Performance and Parameter Sensitivity Indices," Ph.D. Dissertation, Case Western Reserve Univ., Cleveland, OH 1974

[2] Steenis, Joel, "Compensating Voltage Mode Buck Regulators," Power Management Designline 2006