書籍にコードを割り当てる-PowerEconomic Dispatch（3）：ネットワークセキュリティの制約を考慮したEconomic Dispatch Model

理論

本の中の例の予備知識

説明：

import numpy as np
#A节点与发电机组关联矩阵
"""
    发电机组1，发电机组2，发电机组3
节点1
节点2
节点3
"""
A=np.array([[1,1,0],[0,0,1],[0,0,0]])

#B节点与负荷关联矩阵
"""
     节点2负荷，节点3负荷
节点1
节点2
节点3
"""

B=np.array([[0,0],[1,0],[0,1]])

#S为节点与支路关联矩阵。其支路始节点对应元素为1，终节点对应-1
""" 
    支路12 ，支路13，支路23 
节点1 
节点2  
节点3   

"""
S=np.array([[1,1,0],
   [-1,0,1],
   [0,-1,-1]])

#X为支路电抗矩阵，它是一个对角阵，对角元素为各支路电抗值，其余元素为0
X=np.array([[0.25,0,0],
   [0,0.25,0],
   [0,0,0.25]])

テキスト-本の例

ネットワークの制約に関係なく

ネットワークの制約を考慮する

テキスト-本の計算例を解く

目的関数を図に示します

この写真を見ずに、頭を使って
ネットワークセキュリティの制約について考えます。名前が示すように、それは通常のスケジューリングであり、同時にトレンドは制約、KCL、KVLなどを満たしています。

したがって、最適化の目標は従来の経済的派遣の最適化の目標であり、
制約はそれぞれであることが理解できます。

この式は、入力電力=負荷を制約します。
不等式制約、発電機セットの上限と下限。
方程式制約パワーフローはKCL、KVLを満たします。（トランスファーファクターアルゴリズムを介してパワーフローを見つけると、パワーフロー自体がKCL、KVLを満たします）、これは、パワーフローに変換する方程式の制約の上限と下限です。

パワーフローのトランスファーファクターアルゴリズム

#Node power net input vector Pinj = [PG1、PG2、PG3-PD3]

#SFマトリックスの形式は次のとおりです。ノードに電力を注入する場合、電力は参照ノードから流れる必要があります。
参照ノードを1とします。

-	ノード1が1つの電力を注入すると、	ノード2が1つの電力を注入するとき	ノード3が1つの電力を注入するとき
ブランチ1-2	0（ノード1からの流入と参照ノード1からの流出、つまり、ブランチ1-2を使用しないでください）	-2/3このとき、現在の方向は2が1を指し、1-2とは逆なので、-です。図によると、値2/3が得られます。	-1/3
2回ブランチ1-3	0	-1/3、現在の方向は3対1です	-2/3
ブランチ2-3	0	1/3	-1/3

潮流方程式を取得します

次のように展開して、図3-5の傾向を取得します。

 PD3 = 800
 PL12 = -(2 / 3) * PG2 - (1 / 3) * PG3 + (1 / 3) * PD3
 PL13 = (-(1 / 3) * PG2 - (2 / 3) * PG3 + (2 / 3) * PD3) * 0.05
 PL23 = (1 / 3) * PG2 - (1 / 3) * PG3 + (1 / 3) * PD3

プログラミング言語：python

import numpy as np
from scipy import  optimize as opt
import numpy as np
from scipy.optimize import minimize
# 目标函数
def objective(x): #=原文中的mincost 
    p11=x[0]
    p12=x[1]
    p13=x[2]
    p21=x[3]
    p22=x[4]
    p23=x[5]
    p31=x[6]
    p32=x[7]
    p33=x[8]

    return (40*p11+50*p12+57.5*p13+43.75*p21+46.25*p22+48.75*p23+55.8*p31+57*p32+58.2*p33)

# 约束条件
def constraint1(x):  #等式约束
   pI11 = x[0]
   pI12 = x[1]
   pI13 = x[2]
   pI21 = x[3]
   pI22 = x[4]
   pI23 = x[5]
   pI31 = x[6]
   pI32 = x[7]
   pI33 = x[8]
   PG1 = 100 + pI11 + pI12 + pI13
   PG2 = 100 + pI21 + pI22 + pI23
   PG3 = 50 + pI31 + pI32 + pI33

   return pI11+pI12+pI13+pI21+pI22+pI23+pI31+pI32+pI33-550
   #return PG1+PG2+PG3-800


#上下限
pI11=(0,200)
pI12 = (0,200)
pI13 = (0,100)
pI21 = (0,100)
pI22 = (0,100)
pI23 = (0,100)
pI31 =(0,50)
pI32 = (0,50)
pI33 = (0,50)

bnds=(pI11,pI12,pI13,pI21,pI22,pI23,pI31,pI32,pI33)

# 约束条件
def constraint2(x):  #不等式约束 线路PL12 《=300
    pI11 = x[0]
    pI12 = x[1]
    pI13 = x[2]
    pI21 = x[3]
    pI22 = x[4]
    pI23 = x[5]
    pI31 = x[6]
    pI32 = x[7]
    pI33 = x[8]
    PD3=800
    PG1 = 100 + pI11 + pI12 + pI13
    PG2 = 100 + pI21 + pI22 + pI23
    PG3 = 50 + pI31 + pI32 + pI33
    PL12 = -(2 / 3) * PG2 - (1 / 3) * PG3 + (1 / 3) * PD3
    return 300-np.abs(PL12)


# 约束条件
def constraint3(x):  #不等式约束 不等式约束 线路PL13 《=300
    pI11 = x[0]
    pI12 = x[1]
    pI13 = x[2]
    pI21 = x[3]
    pI22 = x[4]
    pI23 = x[5]
    pI31 = x[6]
    pI32 = x[7]
    pI33 = x[8]
    PD3=800
    PG1 = 100 + pI11 + pI12 + pI13
    PG2 = 100 + pI21 + pI22 + pI23
    PG3 = 50 + pI31 + pI32 + pI33
    PL13 = (-(1 / 3) * PG2 - (2 / 3) * PG3 + (2 / 3) * PD3) * 0.05
    return 300-np.abs(PL13)

# 约束条件
def constraint4(x):  #不等式约束 不等式约束 线路PL23 《=330
    pI11 = x[0]
    pI12 = x[1]
    pI13 = x[2]
    pI21 = x[3]
    pI22 = x[4]
    pI23 = x[5]
    pI31 = x[6]
    pI32 = x[7]
    pI33 = x[8]
    PD3=800
    PG1 = 100 + pI11 + pI12 + pI13
    PG2 = 100 + pI21 + pI22 + pI23
    PG3 = 50 + pI31 + pI32 + pI33
    PL23 = (1 / 3) * PG2 - (1 / 3) * PG3 + (1 / 3) * PD3
    return 330-np.abs(PL23)


con1 = {
    
    'type': 'eq', 'fun': constraint1}
con2 = {
    
    'type': 'ineq', 'fun': constraint2}
con3 = {
    
    'type': 'ineq', 'fun': constraint3}
con4 = {
    
    'type': 'ineq', 'fun': constraint4}
cons = ([con1,con2,con3,con4])  # 4个约束条件

if __name__ =='__main__':
   # 初始值
   x0 = np.random.uniform(10, 400, 9)
   # 计算
   solution = minimize(objective, x0, method='SLSQP',
                       bounds=bnds, constraints=cons)
   x = solution.x

   pI11 = x[0]
   pI12 = x[1]
   pI13 = x[2]
   pI21 = x[3]
   pI22 = x[4]
   pI23 = x[5]
   pI31 = x[6]
   pI32 = x[7]
   pI33 = x[8]
   #
   PG1 = 100 + pI11 + pI12 + pI13
   PG2 = 100 + pI21 + pI22 + pI23
   PG3 = 50 + pI31 + pI32 + pI33

   PL13 = 0.5 * ((0.01 + 0.01) * (PG3 - 800) + 0.01 * PG2) / (0.01 + 0.01 + 0.01)
   PL12 = ((0.01 + 0.01) * PG2 + 0.01 * (PG3 - 800)) / (0.01 + 0.01 + 0.01)
   PL23 = ((0.01 + 0.01) * (PG3 - 800) + 0.01 * PG1) / (0.01 + 0.01 + 0.01)

   print('PG1',PG1)
   print('PG2', PG2)
   print('PG3', PG3)
   print('PL13',np.abs(PL13))
   print('PL12',np.abs(PL12))
   print("PL23",np.abs(PL23))

結果を図に示します。このコードは、本に記載されている方法よりもはるかに単純です。

最適化アルゴリズムをもっと見る

Pythonは、制約のある数理最適化問題（非線形計画法、粒子群、遺伝的、差分進化）を解決します。

ここに画像の説明を挿入します
難易度：トレンドを探すためのトランスファーファクター法を理解する

ここに画像の説明を挿入します
著者：電気-YudengWu。書くのは簡単ではありません。この記事が良いと思われる場合は、いいねとサポートをお願いします。