ieee33粒子群算法无功优化python实现

IEEE33电力系统是一个常见的电力系统模型，用于电力系统稳态分析。在该模型中，无功优化是一个关键问题，可以通过粒子群算法进行优化。

以下是粒子群算法的python实现：

import numpy as np

# 定义电力系统模型
class PowerSystem:
    def __init__(self):
        self.bus = np.array([1, 2, 3, 4, 5, 6, 7])
        self.gen = np.array([1, 2])
        self.load = np.array([3, 4, 5])
        self.line = np.array([[1, 2], [1, 3], [2, 4], [2, 5], [3, 6], [3, 7]])
        self.Y = np.array([[2-2j, -1+1j, -1+1j, 0, 0, 0, 0],
                           [-1+1j, 2-2j, 0, -1+1j, 0, 0, 0],
                           [-1+1j, 0, 2-2j, 0, -1+1j, -1+1j, 0],
                           [0, -1+1j, 0, 2-2j, 0, 0, -1+1j],
                           [0, 0, -1+1j, 0, 2-2j, -1+1j, 0],
                           [0, 0, -1+1j, 0, -1+1j, 2-2j, 0],
                           [0, 0, 0, -1+1j, 0, 0, 1-1j]])

# 定义粒子群算法类
class PSO:
    def __init__(self, power_system, pop_size=20, max_iter=50, w=0.8, c1=2, c2=2, g_max=1, g_min=0):
        self.power_system = power_system
        self.pop_size = pop_size
        self.max_iter = max_iter
        self.w = w
        self.c1 = c1
        self.c2 = c2
        self.g_max = g_max
        self.g_min = g_min

    # 初始化粒子位置和速度
    def init_particles(self):
        self.particles = np.random.uniform(low=self.g_min, high=self.g_max, size=(self.pop_size, len(self.power_system.load)))
        self.velocities = np.random.uniform(low=-self.g_max, high=self.g_max, size=(self.pop_size, len(self.power_system.load)))

    # 计算适应度函数
    def fitness_func(self, particle):
        # 计算无功功率
        Q = np.zeros(len(self.power_system.bus))
        Q[self.power_system.load-1] = particle
        Q[self.power_system.gen-1] = -np.sum(Q[self.power_system.load-1])
        # 计算电压
        V = np.ones(len(self.power_system.bus))
        for i in range(len(self.power_system.bus)):
            for j in range(len(self.power_system.bus)):
                V[i] += self.power_system.Y[i][j] * V[j] * np.conj(self.power_system.Y[i][j])
        # 计算无功损耗
        Q_loss = np.sum(Q * np.imag(np.conj(V) * self.power_system.Y * V))
        # 计算适应度函数
        fitness = Q_loss
        return fitness

    # 粒子群算法主函数
    def run(self):
        self.init_particles()
        pbest = self.particles.copy()
        gbest = self.particles[np.argmin([self.fitness_func(p) for p in self.particles])]
        for i in range(self.max_iter):
            for j in range(self.pop_size):
                self.velocities[j] = self.w * self.velocities[j] \
                                     + self.c1 * np.random.rand() * (pbest[j] - self.particles[j]) \
                                     + self.c2 * np.random.rand() * (gbest - self.particles[j])
                self.particles[j] += self.velocities[j]
                self.particles[j] = np.clip(self.particles[j], self.g_min, self.g_max)
                if self.fitness_func(self.particles[j]) < self.fitness_func(pbest[j]):
                    pbest[j] = self.particles[j].copy()
                    if self.fitness_func(pbest[j]) < self.fitness_func(gbest):
                        gbest = pbest[j].copy()
            print('Iter {}: fitness = {:.4f}'.format(i+1, self.fitness_func(gbest)))
        return gbest

在这个实现中，我们定义了一个`PowerSystem`类来表示IEEE33电力系统模型，其中包括负载、发电机、母线和线路等信息。`PSO`类是粒子群算法的实现，其中`init_particles()`函数用于初始化粒子位置和速度，`fitness_func()`函数用于计算适应度函数，`run()`函数是粒子群算法的主函数。

下面是使用该算法进行无功优化的示例代码：

power_system = PowerSystem()
pso = PSO(power_system)
opt_Q = pso.run()
print('Optimal Q:', opt_Q)

在上面的示例中，我们首先创建了一个`PowerSystem`对象，然后创建了一个`PSO`对象来进行优化。最后，我们输出了优化后的无功功率。