Genetic Algorithm for Economic Dispatch

🎯 Lab Objectives

• Formulate the Economic Dispatch problem mathematically.
• Represent generator powers as a chromosome.
• Define a generation-cost objective function.
• Handle generator limits and power-balance constraints.
• Use a penalty function for infeasible solutions.
• Implement a simplified Genetic Algorithm in MATLAB.
• Track the best cost across generations.

1. Economic Dispatch Problem

Economic Dispatch determines the generator outputs that satisfy demand at minimum operating cost.

subject to:

2. Two-Generator System

Consider two thermal generators.

Load demand:

3. Generator Cost Functions

Assume quadratic fuel-cost functions:

Use:

4. Total Operating Cost

The optimization goal is:

5. Power-Balance Constraint

Ignoring transmission losses in this educational example:

Therefore:

6. Chromosome Representation

One GA chromosome represents one candidate dispatch:

Example:

This solution satisfies:

7. Why Do We Need a Penalty?

A randomly generated chromosome may not satisfy power balance.

Example:

We penalize such infeasible solutions.

8. Penalty Function

Define the power mismatch:

Then define a penalized objective:

where λ is a large penalty coefficient.

9. Fitness Function

For a minimization problem, one possible fitness is:

10. GA Parameters

popSize = 40;
maxGen  = 100;

Pc = 0.8;
Pm = 0.1;

lambda = 1000;

where:

• Pc = crossover probability
• Pm = mutation probability
• lambda = penalty coefficient

11. Generate Initial Population

P1min = 50;
P1max = 200;

P2min = 50;
P2max = 180;

population = zeros(popSize,2);

population(:,1) = ...
    P1min + rand(popSize,1)*(P1max-P1min);

population(:,2) = ...
    P2min + rand(popSize,1)*(P2max-P2min);

12. Evaluate One Candidate

For chromosome:

calculate:

13. MATLAB Cost Evaluation

P1 = population(i,1);
P2 = population(i,2);

C1 = 0.004*P1^2 + 5.3*P1 + 500;
C2 = 0.006*P2^2 + 5.5*P2 + 400;

cost = C1 + C2;

mismatch = P1 + P2 - Pload;

penCost = cost + lambda*mismatch^2;

14. Tournament Selection

A simple selection method is tournament selection.

i1 = randi(popSize);
i2 = randi(popSize);

if penCostVec(i1) < penCostVec(i2)
    parent = population(i1,:);
else
    parent = population(i2,:);
end

15. Arithmetic Crossover

For parents p₁ and p₂:

alpha = rand;

child1 = alpha*parent1 + ...
         (1-alpha)*parent2;

child2 = (1-alpha)*parent1 + ...
         alpha*parent2;

16. Mutation

A simple Gaussian mutation can be used:

where r is a random normal variable.

sigmaMut = 10;

if rand < Pm
    child1(1) = child1(1) + sigmaMut*randn;
end

if rand < Pm
    child1(2) = child1(2) + sigmaMut*randn;
end

17. Enforce Generator Limits

After crossover and mutation, clip the offspring:

child1(1) = min(max(child1(1),P1min),P1max);
child1(2) = min(max(child1(2),P2min),P2max);

child2(1) = min(max(child2(1),P1min),P1max);
child2(2) = min(max(child2(2),P2min),P2max);

18. Elitism

Keep the best solution from the current generation:

[bestCost,bestIdx] = min(penCostVec);

elite = population(bestIdx,:);

19. Complete GA Logic

20. Complete MATLAB Program

clear; clc; close all;

% ------------------------------------------------
% Genetic Algorithm for Economic Dispatch
% Two-generator educational example
% ------------------------------------------------

Pload = 250;

% Generator limits
P1min = 50;
P1max = 200;

P2min = 50;
P2max = 180;

% GA parameters
popSize = 40;
maxGen  = 100;

Pc = 0.8;
Pm = 0.1;

sigmaMut = 10;

lambda = 1000;

% ------------------------------------------------
% Initial population
% ------------------------------------------------

population = zeros(popSize,2);

population(:,1) = ...
    P1min + rand(popSize,1)*(P1max-P1min);

population(:,2) = ...
    P2min + rand(popSize,1)*(P2max-P2min);

bestHist = zeros(maxGen,1);

% ------------------------------------------------
% GA loop
% ------------------------------------------------

for gen = 1:maxGen

    costVec    = zeros(popSize,1);
    penCostVec = zeros(popSize,1);

    % --------------------------------------------
    % Evaluate population
    % --------------------------------------------

    for i = 1:popSize

        P1 = population(i,1);
        P2 = population(i,2);

        C1 = 0.004*P1^2 + 5.3*P1 + 500;
        C2 = 0.006*P2^2 + 5.5*P2 + 400;

        cost = C1 + C2;

        mismatch = P1 + P2 - Pload;

        penCost = ...
            cost + lambda*mismatch^2;

        costVec(i) = cost;
        penCostVec(i) = penCost;

    end

    % --------------------------------------------
    % Best solution
    % --------------------------------------------

    [bestPenCost,bestIdx] = min(penCostVec);

    elite = population(bestIdx,:);

    bestHist(gen) = bestPenCost;

    % --------------------------------------------
    % Create new population
    % --------------------------------------------

    newPopulation = zeros(size(population));

    newPopulation(1,:) = elite;

    k = 2;

    while k <= popSize

        % ----------------------------------------
        % Tournament selection for Parent 1
        % ----------------------------------------

        i1 = randi(popSize);
        i2 = randi(popSize);

        if penCostVec(i1) < penCostVec(i2)
            parent1 = population(i1,:);
        else
            parent1 = population(i2,:);
        end

        % ----------------------------------------
        % Tournament selection for Parent 2
        % ----------------------------------------

        i1 = randi(popSize);
        i2 = randi(popSize);

        if penCostVec(i1) < penCostVec(i2)
            parent2 = population(i1,:);
        else
            parent2 = population(i2,:);
        end

        % ----------------------------------------
        % Crossover
        % ----------------------------------------

        if rand < Pc

            alpha = rand;

            child1 = ...
                alpha*parent1 + ...
                (1-alpha)*parent2;

            child2 = ...
                (1-alpha)*parent1 + ...
                alpha*parent2;

        else

            child1 = parent1;
            child2 = parent2;

        end

        % ----------------------------------------
        % Mutation
        % ----------------------------------------

        for j = 1:2

            if rand < Pm
                child1(j) = ...
                    child1(j) + sigmaMut*randn;
            end

            if rand < Pm
                child2(j) = ...
                    child2(j) + sigmaMut*randn;
            end

        end

        % ----------------------------------------
        % Generator limits
        % ----------------------------------------

        child1(1) = ...
            min(max(child1(1),P1min),P1max);

        child1(2) = ...
            min(max(child1(2),P2min),P2max);

        child2(1) = ...
            min(max(child2(1),P1min),P1max);

        child2(2) = ...
            min(max(child2(2),P2min),P2max);

        % ----------------------------------------
        % Store offspring
        % ----------------------------------------

        newPopulation(k,:) = child1;

        if k+1 <= popSize
            newPopulation(k+1,:) = child2;
        end

        k = k + 2;

    end

    population = newPopulation;

end

% ------------------------------------------------
% Final evaluation
% ------------------------------------------------

finalPenCost = zeros(popSize,1);
finalCost    = zeros(popSize,1);

for i = 1:popSize

    P1 = population(i,1);
    P2 = population(i,2);

    C1 = 0.004*P1^2 + 5.3*P1 + 500;
    C2 = 0.006*P2^2 + 5.5*P2 + 400;

    finalCost(i) = C1 + C2;

    mismatch = P1 + P2 - Pload;

    finalPenCost(i) = ...
        finalCost(i) + lambda*mismatch^2;

end

[~,idx] = min(finalPenCost);

Pbest = population(idx,:);

P1best = Pbest(1);
P2best = Pbest(2);

C1best = ...
    0.004*P1best^2 + 5.3*P1best + 500;

C2best = ...
    0.006*P2best^2 + 5.5*P2best + 400;

totalCost = C1best + C2best;

mismatch = P1best + P2best - Pload;

% ------------------------------------------------
% Display results
% ------------------------------------------------

fprintf('Best Economic Dispatch Solution\n\n')

fprintf('P1 = %.4f MW\n',P1best)
fprintf('P2 = %.4f MW\n',P2best)

fprintf('Total Generation = %.4f MW\n', ...
        P1best+P2best)

fprintf('Load Demand = %.4f MW\n',Pload)

fprintf('Power Mismatch = %.6f MW\n\n', ...
        mismatch)

fprintf('Generation Cost = %.4f\n', ...
        totalCost)

% ------------------------------------------------
% Convergence curve
% ------------------------------------------------

figure

plot(1:maxGen,bestHist,'LineWidth',1.6)

grid on

xlabel('Generation')
ylabel('Best Penalized Cost')

title('GA Convergence for Economic Dispatch')

21. Understanding the Convergence Curve

The graph:

should generally decrease as better solutions are discovered.

22. Why the Penalty Coefficient Matters

If λ is too small:

If λ is very large:

23. Experiment 1 — Change the Load

Try:

Pload = 200;
Pload = 250;
Pload = 300;

Compare generator outputs and total generation cost.

24. Experiment 2 — Change Population Size

popSize = 10;
popSize = 40;
popSize = 100;

25. Experiment 3 — Change Mutation Probability

Pm = 0.01;
Pm = 0.10;
Pm = 0.40;

Observe convergence and variability between runs.

26. Engineering Improvement

For this two-generator problem, power balance can also be enforced directly:

Then only P₁ needs to be optimized.

27. Extension to Power Losses

A more realistic Economic Dispatch includes transmission losses:

Then the chromosome and objective evaluation must also account for system losses.

28. From Economic Dispatch to OPF

Economic Dispatch mainly focuses on active-power generation and cost.

Optimal Power Flow adds network variables and constraints:

with constraints such as:

29. Lab Tasks

1. Define generator cost functions.
2. Generate the initial population.
3. Calculate power mismatch for each chromosome.
4. Implement the penalty function.
5. Implement tournament selection.
6. Implement arithmetic crossover.
7. Implement mutation and generator limits.
8. Plot the convergence curve.
9. Record the final P₁ and P₂.
10. Verify power balance manually.
11. Change load demand and repeat the experiment.
12. Change population and mutation parameters.
13. Explain how this problem can be extended to OPF.

📝 Review Questions

1. What is the objective of Economic Dispatch?
2. What does one chromosome represent?
3. Why is a penalty function required?
4. What happens if λ is too small?
5. What is tournament selection?
6. Why do we use mutation?
7. Why is elitism useful?
8. How do generator limits affect the search?
9. How can power balance be enforced directly?
10. What additional constraints appear in OPF?