Scribd
Upload
4 views5 pages

Ex12

The document outlines the implementation of a Continuous Genetic Algorithm for optimizing energy dispatch in a smart grid, focusing on minimizing operational costs, balancing supply and demand, and reducing carbon emissions. It details the algorithm's steps, including population initialization, fitness evaluation, selection, crossover, and mutation, along with Python code for execution. The results indicate a successful reduction in emissions and costs through the prioritization of renewable energy sources over coal.

Uploaded by

MNBVCXZ
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
4 views5 pages

Ex12

The document outlines the implementation of a Continuous Genetic Algorithm for optimizing energy dispatch in a smart grid, focusing on minimizing operational costs, balancing supply and demand, and reducing carbon emissions. It details the algorithm's steps, including population initialization, fitness evaluation, selection, crossover, and mutation, along with Python code for execution. The results indicate a successful reduction in emissions and costs through the prioritization of renewable energy sources over coal.

Uploaded by

MNBVCXZ
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 5

Ex.

No : 12 CONTINUOUS GENETIC ALGORITHM


Date: 27.03.2025

Aim:
To implement a Continuous Genetic Algorithm (GA) for optimizing energy dispatch in a
smart grid, ensuring real-time power distribution from multiple energy sources while minimizing
operational costs, balancing supply with demand, and reducing carbon emissions in compliance
with environmental regulations.

Algorithm:
1) Initialize a population with random power allocations.
2) Evaluate fitness based on cost, emissions, and demand balance.
3) Select the best candidates probabilistically.
4) Apply crossover to generate new solutions.
5) Mutate offspring to introduce diversity.
6) Repeat for multiple generations and plot results.

Code:
import numpy as np
import matplotlib.pyplot as plt

# Define parameters
generators = ["Solar", "Wind", "Coal"]
costs = np.array([0, 0, 50])
emissions = np.array([0, 0, 80])
demand = 500
pop_size = 50
num_generations = 100
mutation_rate = 0.1

# Initialize population
def initialize_population(size):
return np.random.rand(size, len(generators)) * demand / len(generators)
# Fitness function
def fitness(individual):
total_cost = np.sum(individual * costs)
total_emissions = np.sum(individual * emissions)
penalty = abs(np.sum(individual) - demand) * 1000
return -(total_cost + total_emissions + penalty)

# Selection
def select(pop):
scores = np.array([fitness(ind) for ind in pop])
probabilities = np.exp(scores - np.max(scores))
probabilities /= probabilities.sum()
return pop[np.random.choice(len(pop), size=len(pop)//2, p=probabilities)]

# Crossover
def crossover(parents):
offspring = []
for i in range(0, len(parents), 2):
if i + 1 < len(parents):
point = np.random.randint(1, len(generators))
child1 = np.hstack((parents[i][:point], parents[i+1][point:]))
child2 = np.hstack((parents[i+1][:point], parents[i][point:]))
offspring.extend([child1, child2])
return np.array(offspring)

# Mutation
def mutate(offspring):
for i in range(len(offspring)):
if np.random.rand() < mutation_rate:
idx = np.random.randint(len(generators))
offspring[i][idx] += np.random.uniform(-10, 10)
offspring[i][idx] = max(0, offspring[i][idx])
return offspring

# Evolutionary process with cost and emission tracking


def genetic_algorithm():
population = initialize_population(pop_size)
best_fitness_values = []
cost_list, emissions_list, generation_list = [], [], []
for gen in range(num_generations):
parents = select(population)
offspring = crossover(parents)
population = np.vstack((parents, mutate(offspring)))
best_solution = max(population, key=fitness)
total_cost = np.sum(best_solution * costs)
total_emissions = np.sum(best_solution * emissions)
cost_list.append(total_cost)
emissions_list.append(total_emissions)
generation_list.append(gen)
best_fitness_values.append(-fitness(best_solution))
return best_solution, best_fitness_values, cost_list, emissions_list, generation_list

# Run optimization
optimal_distribution, fitness_progress, cost_data, emissions_data, generations =
genetic_algorithm()
print("Optimal Power Distribution (MWh):", optimal_distribution)

# Visualization
plt.figure(figsize=(12, 5))

# Optimization Progress Graph


plt.subplot(1, 3, 1)
plt.plot(range(num_generations), fitness_progress, label="Total Cost & Emissions", color='blue')
plt.xlabel("Generation")
plt.ylabel("Fitness (Negative Cost & Emissions)")
plt.title("Optimization Progress")
plt.legend()
plt.grid(True)

# Final Power Distribution Graph


plt.subplot(1, 3, 2)
plt.bar(generators, optimal_distribution, color=['gold', 'blue', 'black'])
plt.xlabel("Energy Source")
plt.ylabel("Power Generated (MWh)")
plt.title("Final Power Distribution")
plt.grid(axis='y', linestyle='--', alpha=0.7)

# Scatter Plot: Cost vs. Emissions


plt.subplot(1, 3, 3)
scatter = plt.scatter(cost_data, emissions_data, c=generations, cmap="viridis", edgecolors='black')
plt.colorbar(scatter, label="Generations")
plt.xlabel("Total Cost ($)")
plt.ylabel("Total Emissions (kg CO2)")
plt.title("Cost vs. Emissions")
plt.grid(True, linestyle="--", alpha=0.5)
plt.tight_layout()
plt.show()

Output:
Inference:
The emission analysis shows that coal is the only source contributing to CO₂ emissions since solar
and wind have zero emissions. Initially, emissions were high due to heavy coal usage, but as the
optimization progressed, the algorithm prioritized renewables, reducing emissions. The final power
distribution shows a balanced mix, with solar and wind taking a larger share, leading to both cost
and emission reductions. This demonstrates a successful trade-off between minimizing emissions
and keeping costs low while meeting energy demand efficiently.

You might also like