def gcall(self):
for i in range(system.Statcom.n):
system.DAE.g[self.a[i]] += system.DAE.y[self.v[i]]*system.DAE.y[self.v[i]]*self.gsh[i] - \
system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*i+1] * \
(self.gsh[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]) + \
self.bsh[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]))
system.DAE.g[self.v[i]] += -system.DAE.y[self.v[i]]*system.DAE.y[self.v[i]]*self.bsh[i] - \
system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*i+1] * \
(self.gsh[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]) - \
self.bsh[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]))
system.DAE.g[2*system.Bus.n+2*i] = system.DAE.y[2*system.Bus.n+2*i+1]*system.DAE.y[2*system.Bus.n+2*i+1]*self.gsh[i] - \
system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*i+1] * \
(self.gsh[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]) - \
self.bsh[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]))
system.DAE.g[2*system.Bus.n+2*i+1] = system.DAE.y[self.v[i]] - self.Vref[i]
def Gycall(self):
system.DAE._list2matrix()
delta = system.DAE.x[self.delta]
ag = system.DAE.y[self.a]
vg = mul(self.u, system.DAE.y[self.v])
ss = sin(delta - ag)
cc = cos(delta - ag)
M1 = mul(vg, (mul(self.c1, cc) - mul(self.c3, ss)))
M2 = mul(-vg, (mul(self.c2, cc) + mul(self.c1, ss)))
M3 = -(mul(self.c1, ss) + mul(self.c3, cc))
M4 = (mul(self.c2, ss) - mul(self.c1, cc))
self.J11 = mul(vg,
(mul(self.Id - M2, cc) - mul(mul(M1 + self.Iq, ss))))
self.J12 = mul(-self.Id, ss) - mul(self.Iq, cc) - mul(
vg, (mul(M3, ss) + mul(M4, cc)))
self.J21 = mul(vg, mul(M2 - self.Id, ss) - mul(M1 + self.Iq, cc))
self.J22 = mul(-self.Id, cc) + mul(self.Iq, ss) - mul(
vg,
mul(M3, cc) - mul(M4, ss))
system.DAE.Gy = system.DAE.Gy -spmatrix(self.u, self.a, self.p, (system.DAE.ny, system.DAE.ny)) \
- spmatrix(self.u, self.v, self.q, (system.DAE.ny, system.DAE.ny)) \
- spmatrix([1]*self.n, self.p, self.p, (system.DAE.ny, system.DAE.ny)) \
- spmatrix([1] * self.n, self.q, self.q, (system.DAE.ny, system.DAE.ny)) \
- spmatrix(self.J11, self.p, self.a, (system.DAE.ny, system.DAE.ny)) \
- spmatrix(self.J12, self.p, self.v, (system.DAE.ny, system.DAE.ny)) \
- spmatrix(self.J21, self.q, self.a, (system.DAE.ny, system.DAE.ny)) \
- spmatrix(self.J22, self.q, self.v, (system.DAE.ny, system.DAE.ny)) \
- spmatrix([1] * self.n, self.pm, self.pm, (system.DAE.ny, system.DAE.ny)) \
- spmatrix([1] * self.n, self.vf, self.vf, (system.DAE.ny, system.DAE.ny)) \
def gcall(self):
if self.n == 0:
return
slip = system.DAE.x[self.slip]
V = mul(self.u, system.DAE.y[self.v]) # 后续得修改
t = system.DAE.y[self.a]
st = sin(t)
ct = cos(t)
Vr = mul(V, st)
Vm = mul(V, ct)
e1r = system.DAE.x[self.e1r]
e1m = system.DAE.x[self.e1m]
a03 = mul(self.rs, self.rs) + mul(self.x1, self.x1)
a13 = div(self.rs, a03)
a23 = div(self.x1, a03)
a33 = self.x0 - self.x1
Im = mul(-a23, -Vr - e1r + mul(a13, (Vm - e1m)))
Ir = mul(a13, -Vr - e1r) + mul(a23, Vm - e1m)
system.DAE.g = system.DAE.g \
+ spmatrix(mul(-Vr, Ir)+mul(Vm, Im), self.a, matrix(0, (self.n, 1)), (system.DAE.ny, 1)) \
+ spmatrix(mul(Vr, Im) + mul(Vm, Ir), self.v, matrix(0, (self.n, 1)), (system.DAE.ny, 1))
def gcall(self):
system.DAE._list2matrix()
delta = system.DAE.x[self.delta]
omega = system.DAE.x[self.omega]
e1q = system.DAE.x[self.e1q]
e1d = system.DAE.x[self.e1d]
e2q = system.DAE.x[self.e2q]
e2d = system.DAE.x[self.e2d]
ag = system.DAE.y[self.a]
vg = mul(self.u, system.DAE.y[self.v])
ss = sin(delta - ag)
cc = cos(delta - ag)
self.Id = mul(-vg, (mul(self.c1, ss) + mul(self.c3, cc)))
self.Iq = mul(vg, (mul(self.c2, ss) - mul(self.c1, cc)))
self.Id = self.Id + mul(self.c1, e2d) + mul(self.c3, e2q)
self.Iq = self.Iq - mul(self.c2, e2d) + mul(self.c1, e2q)
ones = [0] * self.n
system.DAE.g = system.DAE.g -\
spmatrix(system.DAE.y[self.p], self.a, ones, (system.DAE.ny, 1)) - \
spmatrix(system.DAE.y[self.q], self.v, ones, (system.DAE.ny, 1)) + \
spmatrix(mul(vg, (mul(self.Id, ss)+mul(self.Iq, cc)))-system.DAE.y[self.p], self.p, ones, (system.DAE.ny, 1)) + \
spmatrix(mul(vg, (mul(self.Id, cc) - mul(self.Iq, ss)))-system.DAE.y[self.q], self.q, ones, (system.DAE.ny, 1)) + \
spmatrix(mul(self.u, (self.pm0 - system.DAE.y[self.pm])), self.pm, ones, (system.DAE.ny, 1)) + \
spmatrix(mul(self.u, (self.vf0 - system.DAE.y[self.vf])), self.vf, ones, (system.DAE.ny, 1))
def fcall(self):
rad = 2 * math.pi * system.Settings.freq
delta = system.DAE.x[self.delta]
omega = system.DAE.x[self.omega]
ag = system.DAE.y[self.a]
vg = mul(self.u, system.DAE.y[self.v])
ss = sin(delta - ag)
cc = cos(delta - ag)
e1q = system.DAE.x[self.e1q]
e1d = system.DAE.x[self.e1d]
e2q = system.DAE.x[self.e2q]
e2d = system.DAE.x[self.e2d]
iM = div(self.u, self.M)
# 更新Vf 和Pm
system.DAE.f = matrix(system.DAE.f)
Vf = system.DAE.y[self.vf] + mul(self.Komega, omega - matrix(
1, (self.n, 1))) - mul(self.KP, system.DAE.y[self.p] - self.Pg0)
system.DAE.f[self.delta] = mul(
rad, mul(self.u, omega - matrix(1, (self.n, 1))))
system.DAE.f[self.omega] = mul(
system.DAE.y[self.pm] - system.DAE.y[self.p] -
mul(self.ra,
mul(self.Id, self.Id) + mul(self.Iq, self.Iq)) -
mul(self.D, omega - 1), iM)
# print('sss')
# print(mul(self.D, omega-1))
# print(mul(system.DAE.y[self.pm]-system.DAE.y[self.p]-mul(self.ra, mul(self.Id, self.Id)+mul(self.Iq, self.Iq))-mul(self.D, omega-1), iM))
gd = div(mul(mul(self.xd2, self.Td02), self.xd - self.xd1),
mul(self.xd1, self.Td01))
gq = div(mul(mul(self.xq2, self.Tq02), self.xq - self.xq1),
mul(self.xq1, self.Tq01))
a1 = div(self.u, self.Td02)
a2 = mul(a1, self.xd1 - self.xd2 + gd)
a3 = div(mul(self.u, self.Taa), mul(self.Td01, self.Td02))
a4 = div(self.u, self.Td01)
a5 = mul(a4, self.xd - self.xd1 - gd)
a6 = mul(a4, 1 - div(self.Taa, self.Td01))
b1 = div(self.u, self.Tq02)
b2 = mul(b1, self.xq1 - self.xq2 + gq)
b3 = div(self.u, self.Tq01)
b4 = mul(b3, self.xq - self.xq1 - gq)
system.DAE.f[self.e1q] = -mul(a4, self.synsat()) - mul(
a5, self.Id) + mul(a6, Vf)
# print(self.synsat())
system.DAE.f[self.e1d] = mul(-b3, e1d) + mul(b4, self.Iq)
system.DAE.f[self.e2q] = mul(-a1, e2q) + mul(a1, e1q) - mul(
a2, self.Id) + mul(a3, Vf)
system.DAE.f[self.e2d] = mul(-b1, e2d) + mul(b1, e1d) + mul(
b2, self.Iq)
def gcall(self):
for i in range(system.Sssc.n):
#Pi
system.DAE.g[self.a[i]] -= system.DAE.y[self.v[i]]*system.DAE.y[self.v[i]]*self.gse[i] - \
system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(self.gse[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i]) + \
self.bse[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i])) - \
system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i+1] * \
(self.gse[i] * cos(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]) + \
self.bse[i] * sin(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]))
#Qi
system.DAE.g[self.v[i]] -= -system.DAE.y[self.v[i]]*system.DAE.y[self.v[i]]*self.bse[i] - \
system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(self.gse[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i]) - \
self.bse[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i])) - \
system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i+1] * \
(self.gse[i] * sin(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]) - \
self.bse[i] * cos(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]))
#Pj
system.DAE.g[system.Bus.n-system.Sssc.n+i] -= system.DAE.y[2*system.Bus.n-system.Sssc.n+i]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i]*self.gse[i] - \
system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]) + \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i])) + \
system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) + \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#Qj
system.DAE.g[2*system.Bus.n-system.Sssc.n+i] -= -system.DAE.y[2*system.Bus.n-system.Sssc.n+i]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i]*self.bse[i] - \
system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]) - \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i])) + \
system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] * \
(self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) - \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#PE
system.DAE.g[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i] = -system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i+1] * \
(self.gse[i] * cos(system.DAE.y[self.a[i]] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) - \
self.bse[i] * sin(system.DAE.y[self.a[i]] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i])) + \
system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) - \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] -system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#F
system.DAE.g[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] = system.DAE.y[2*system.Bus.n-system.Sssc.n+i]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i]*self.gse[i] - \
system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]) + \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i])) + \
system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) + \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i])) - \
self.Pref[i]
def gcall(self):
if self.n == 0:
return
omega_m = system.DAE.x[self.omega_m]
idr = system.DAE.x[self.idr]
iqr = system.DAE.x[self.iqr]
pwa = system.DAE.y[self.pwa]
V = system.DAE.y[self.v]
t = system.DAE.y[self.a]
st = sin(t)
ct = cos(t)
rs = self.rs
rr = self.rr
xm = self.xm
as1 = rs**2 + self.dat1**2
a13 = div(rs, as1)
a23 = div(self.dat1, as1)
a33 = self.dat2
vds = mul(-V, st)
vqs = mul(V, ct)
ids = mul(-a13, vds - mul(xm, iqr)) - mul(a23, vqs + mul(xm, idr))
iqs = mul(a23, vds - mul(xm, iqr)) - mul(a13, vqs + mul(xm, idr))
ones = matrix(1.0, (self.n, 1))
vdr = mul(-rr, idr) + mul(ones - omega_m, mul(a33, iqr) + mul(xm, iqs))
vqr = mul(-rr, iqr) - mul(ones - omega_m, mul(a33, idr) + mul(xm, ids))
p = mul(vds, ids) + mul(vqs, iqs) + mul(vdr, idr) + mul(vqr, iqr)
q = div(mul(-V, mul(xm, idr) + V), self.dat1)
xomega = system.DAE.x[self.omega_m]
xomega1 = matrix(0.0, (self.n, 1))
for i in range(self.n):
xomega1[i] = max([min([2 * xomega[i] - 1, 1]), 0])
pwa1 = mul(self.u, mul(self.Sn, div(xomega1,
system.Settings.mva))) - pwa
ones = [0] * self.n
system.DAE.g = system.DAE.g - \
spmatrix(mul(self.u, p), self.a, ones, (system.DAE.ny, 1)) - \
spmatrix(mul(self.u, q), self.v, ones, (system.DAE.ny, 1)) + \
spmatrix(mul(self.u, self.dat6)-system.DAE.y[self.vref], self.vref, ones, (system.DAE.ny, 1)) + \
spmatrix(pwa1, self.pwa, ones, (system.DAE.ny, 1))
def build_y(self):
for i in range(len(self.tap_ratio)):
if self.tap_ratio[i] == 0:
self.tap_ratio[i] = 1
# print(self.tap_ratio)
# chrg = np.mat(self.b) * 0.5
# chrg = chrg.T
#
# print(chrg)
chrg = np.array(np.zeros((len(self.b), 1), complex))
for i in range(len(self.x)):
chrg[i] = complex(0.0, self.b[i] * 0.5)
#print(chrg)
#zeros = [0] * len(self.x)
#y = matrix(zeros, (len(self.x), 1, complex))
y = np.array(np.zeros((len(self.x), 1), complex))
for i in range(len(self.x)):
y[i] = 1.0 / complex(self.r[i], self.x[i])
#print(y)
ts = np.array(np.zeros((len(self.theta), 1), complex))
for i in range(len(self.theta)):
ts[i] = complex(
self.tap_ratio[i] * cos(self.theta[i] * math.pi / 180),
self.tap_ratio[i] * sin(self.theta[i] * math.pi / 180))
#print(ts)
ts2 = ts * ts.conj()
#print(ts2)
y1 = -y / ts.conj()
#print(y1)
self.Y = spmatrix(y1, self.af, self.at, (system.Bus.n, system.Bus.n)) +\
spmatrix(y1, self.at, self.af, (system.Bus.n, system.Bus.n)) +\
spmatrix(y/ts2 + chrg, self.af, self.af, (system.Bus.n, system.Bus.n)) +\
spmatrix(y + chrg, self.at, self.at, (system.Bus.n, system.Bus.n))
system.DAE.Y = self.Y
system.DAE.Y_G = self.Y.real()
system.DAE.Y_B = self.Y.imag()
print(system.DAE.Y_G)
print(system.DAE.Y_B)
def fcall(self):
if self.n == 0:
return
slip = system.DAE.x[self.slip]
u = self.u # 后续得修改
Wn = 2 * 3.1415926 * system.Settings.freq * u
V = mul(self.u, system.DAE.y[self.v]) # 后续得修改
t = system.DAE.y[self.a]
st = sin(t)
ct = cos(t)
Vr = mul(V, st)
Vm = mul(V, ct)
i2Hm = mul(u, self.i2Hm)
Tm = self.A + mul(slip, self.B + mul(slip, self.C))
e1r = system.DAE.x[self.e1r]
e1m = system.DAE.x[self.e1m]
a03 = mul(self.rs, self.rs) + mul(self.x1, self.x1)
a13 = div(self.rs, a03)
a23 = div(self.x1, a03)
a33 = self.x0 - self.x1
Im = mul(-a23, -Vr - e1r + mul(a13, (Vm - e1m)))
Ir = mul(a13, -Vr - e1r) + mul(a23, Vm - e1m)
A = mul(-Wn, slip, e1r) - div(e1m - mul(a33, Ir), self.T10)
system.DAE.f[self.slip] = mul(Tm - mul(e1r, Ir) - mul(e1m, Im), i2Hm)
system.DAE.f[self.e1r] = mul(Wn, slip, e1m) - div(
e1r + mul(a33, Im), self.T10)
system.DAE.f[self.e1m] = mul(-Wn, slip, e1r) - div(
e1m - mul(a33, Ir), self.T10)
def Gycall(self):
if self.n == 0:
return
slip = system.DAE.x[self.slip]
V = mul(self.u, system.DAE.y[self.v]) # 后续得修改
t = system.DAE.y[self.a]
st = sin(t)
ct = cos(t)
Vr = mul(V, st)
Vm = mul(V, ct)
e1r = system.DAE.x[self.e1r]
e1m = system.DAE.x[self.e1m]
a03 = mul(self.rs, self.rs) + mul(self.x1, self.x1)
a13 = div(self.rs, a03)
a23 = div(self.x1, a03)
a33 = self.x0 - self.x1
Im = mul(-a23, -Vr - e1r + mul(a13, (Vm - e1m)))
Ir = mul(a13, -Vr - e1r) + mul(a23, Vm - e1m)
Am = mul(a23, Vm) - mul(a13, Vr)
Ar = mul(-a13, Vm) - mul(a23, Vr)
Bm = mul(a23, st) + mul(a13, ct)
Br = mul(-a13, st) + mul(a23, ct)
system.DAE.Gy = system.DAE.Gy \
+ spmatrix(mul(-Vm, Ir)-mul(Vr, Ar)-mul(Vr, Im)+mul(Vm, Am), self.a, self.a, (system.DAE.ny, system.DAE.ny)) \
+ spmatrix(mul(-st, Ir)-mul(Vr, Br)+mul(ct, Im)+mul(Vm, Bm), self.a, self.v, (system.DAE.ny, system.DAE.ny)) \
+ spmatrix(mul(Vm, Im)+mul(Vr, Am)-mul(Vr, Ir)+mul(Vm, Ar), self.v, self.a,
(system.DAE.ny, system.DAE.ny)) \
+ spmatrix(mul(st, Im)+mul(Vr, Bm)+mul(ct, Ir)+mul(Vm, Br), self.v, self.v,
(system.DAE.ny, system.DAE.ny))
def Fxcall(self):
if self.n == 0:
return
slip = system.DAE.x[self.slip]
u = self.u # 后续得修改
z = matrix(0, (self.n, 1))
for i in range(self.n):
if slip[i] < 1 or self.allow[i]:
z[i] = 1
else:
z[i] = 0
Wn = 2 * 3.1415926 * system.Settings.freq * u
V = mul(self.u, system.DAE.y[self.v]) # 后续得修改
t = system.DAE.y[self.a]
st = sin(t)
ct = cos(t)
Vr = mul(V, st)
Vm = mul(V, ct)
i2Hm = mul(u, self.i2Hm, z)
km = self.B + mul(2 * self.C, slip)
e1r = system.DAE.x[self.e1r]
e1m = system.DAE.x[self.e1m]
a03 = mul(self.rs, self.rs) + mul(self.x1, self.x1)
a13 = div(self.rs, a03)
a23 = div(self.x1, a03)
a33 = self.x0 - self.x1
Im = mul(-a23, -Vr - e1r + mul(a13, (Vm - e1m)))
Ir = mul(a13, -Vr - e1r) + mul(a23, Vm - e1m)
Am = mul(a23, Vm) - mul(a13, Vr)
Ar = mul(-a13, Vm) - mul(a23, Vr)
Bm = mul(a23, st) + mul(a13, ct)
Br = mul(-a13, st) + mul(a23, ct)
is3 = self.slip
er3 = self.e1r
em3 = self.e1m
iu = matrix(0, (self.n, 1))
for i in range(self.n):
if self.u[i] == 1:
iu[i] = 0
else:
iu[i] = 1
system.DAE.Fx = system.DAE.Fx \
+ spmatrix(mul(km, i2Hm)-iu, is3, is3, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(mul(-Ir+mul(e1r, a13)-mul(e1m, a23), i2Hm), is3, er3, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(mul(-Im+mul(e1r, a23)-mul(e1m, a13), i2Hm), is3, em3, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(mul(z, Wn, e1m), er3, is3, (system.DAE.nx, system.DAE.nx)) \
- spmatrix(div(1+mul(a33, a23), self.T10), er3, er3, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(mul(Wn, slip)+div(mul(a33, a13), self.T10), er3, em3, (system.DAE.nx, system.DAE.nx)) \
- spmatrix(mul(z, Wn, e1r), em3, is3, (system.DAE.nx, system.DAE.nx)) \
- spmatrix(mul(Wn, slip)+div(mul(a33, a13), self.T10), em3, er3, (system.DAE.nx, system.DAE.nx)) \
- spmatrix(div(1+mul(a33, a23), self.T10), em3, em3, (system.DAE.nx, system.DAE.nx))
system.DAE.Gx = system.DAE.Gx \
+ spmatrix(mul(a13, Vr)+mul(a23, Vm), self.a, er3, (system.DAE.ny, system.DAE.nx)) \
+ spmatrix(mul(a23, Vr) - mul(a13, Vm), self.a, em3, (system.DAE.ny, system.DAE.nx)) \
+ spmatrix(mul(a23, Vr) - mul(a13, Vm), self.v, er3, (system.DAE.ny, system.DAE.nx)) \
- spmatrix(mul(a13, Vr) + mul(a23, Vm), self.v, em3, (system.DAE.ny, system.DAE.nx))
system.DAE.Fy = system.DAE.Fy \
- spmatrix(mul(mul(e1r, Ar)+mul(e1m, Am), i2Hm), is3, self.a, (system.DAE.nx, system.DAE.ny)) \
- spmatrix(div(mul(a33, Am), self.T10), er3, self.a, (system.DAE.nx, system.DAE.ny)) \
+ spmatrix(div(mul(a33, Ar), self.T10), em3, self.a, (system.DAE.nx, system.DAE.ny)) \
- spmatrix(mul(mul(e1r, Br) + mul(e1m, Bm), i2Hm), is3, self.v, (system.DAE.nx, system.DAE.ny)) \
- spmatrix(div(mul(a33, Bm), self.T10), er3, self.v, (system.DAE.nx, system.DAE.ny)) \
+ spmatrix(div(mul(a33, Br), self.T10), em3, self.v, (system.DAE.nx, system.DAE.ny))
print('a')
def Gycall(self):
# for i in range(system.Bus.n):
# for j in range(2*system.Statcom.n):
# Gy[i][system.Bus.n+j] = 0
for i in range(system.Statcom.n):
system.DAE.Gy[2*system.Bus.n+2*i, :] = 0
system.DAE.Gy[:, 2*system.Bus.n+2*i] = 0
system.DAE.Gy[2*system.Bus.n+2*i+1, :] = 0
system.DAE.Gy[:, 2*system.Bus.n+2*i+1] = 0
# system.DAE.Gy[2 * system.Bus.n + 2 * i, 2 * system.Bus.n + 2 * i] = 1
# system.DAE.Gy[2 * system.Bus.n + 2 * i + 1, 2 * system.Bus.n + 2 * i + 1] = 1
for i in range(system.Statcom.n):
#Pi/vi
system.DAE.Gy[self.a[i],self.v[i]] += 2.0 * system.DAE.y[self.v[i]]*self.gsh[i] - system.DAE.y[2*system.Bus.n+2*i+1] * \
(self.gsh[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]) + \
self.bsh[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]))
#system.DAE.Gy[self.a[i], self.v[i]] = system.DAE.Gy[self.a[i],self.v[i]]*system.DAE.y[self.v[i]]
#Qi/vi
system.DAE.Gy[self.v[i],self.v[i]] += -2.0 * system.DAE.y[self.v[i]] * self.bsh[i] - system.DAE.y[2*system.Bus.n+2*i+1] * \
(self.gsh[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]) - \
self.bsh[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]))
#system.DAE.Gy[self.v[i], self.v[i]] = system.DAE.Gy[self.v[i],self.v[i]]*system.DAE.y[self.v[i]]
#PE/vi
system.DAE.Gy[2*system.Bus.n+2*i,self.v[i]] += -system.DAE.y[2*system.Bus.n+2*i+1] * \
(self.gsh[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]) - \
self.bsh[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]))
#system.DAE.Gy[2 * system.Bus.n + 2 * i, self.v[i]] = system.DAE.Gy[2*system.Bus.n+2*i,self.v[i]]*system.DAE.y[self.v[i]]
#Vi/vi
system.DAE.Gy[2*system.Bus.n+2*i+1,self.v[i]] += 1
#system.DAE.Gy[2 * system.Bus.n + 2 * i + 1, self.v[i]] = system.DAE.Gy[2*system.Bus.n+2*i+1,self.v[i]]*system.DAE.y[self.v[i]]
#Pi/ai
system.DAE.Gy[self.a[i],self.a[i]] -= system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*i+1] * \
(-self.gsh[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]) + \
self.bsh[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]))
#Qi/ai
system.DAE.Gy[self.v[i],self.a[i]] -= system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*i+1] * \
(self.gsh[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]) + \
self.bsh[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]))
# PE/ai
system.DAE.Gy[2 * system.Bus.n + 2*i,self.a[i]] -= system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*i+1] * \
(-self.gsh[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]) - \
self.bsh[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]))
# Vi/ai
system.DAE.Gy[2 * system.Bus.n + 2*i+1,self.a[i]] += 0
#Pi/ash
system.DAE.Gy[self.a[i],2 * system.Bus.n + 2 * i] -= system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*i+1] * \
(self.gsh[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]) - \
self.bsh[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]))
#Pi/vsh
system.DAE.Gy[self.a[i],2 * system.Bus.n + 2 * i + 1] -= system.DAE.y[self.v[i]] * \
(self.gsh[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]) + \
self.bsh[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]))
#system.DAE.Gy[self.a[i], 2 * system.Bus.n + 2 * i + 1] = system.DAE.Gy[self.a[i],2 * system.Bus.n + 2 * i + 1]*system.DAE.y[2*system.Bus.n+2*i+1]
#Qi/ash
system.DAE.Gy[self.v[i],2 * system.Bus.n + 2 * i] -= system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*i+1] * \
((-self.gsh[i])*cos(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]) - \
self.bsh[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]))
#Qi/vsh
system.DAE.Gy[self.v[i],2 * system.Bus.n + 2 * i + 1] -= system.DAE.y[self.v[i]] * \
(self.gsh[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]) - \
self.bsh[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]))
#system.DAE.Gy[self.v[i], 2 * system.Bus.n + 2 * i + 1] = system.DAE.Gy[self.v[i],2 * system.Bus.n + 2 * i + 1]*system.DAE.y[2 * system.Bus.n + 2 * i + 1]
#PE/ash
system.DAE.Gy[2 * system.Bus.n + 2 * i,2 * system.Bus.n + 2 * i] -= system.DAE.y[self.v[i]] * system.DAE.y[2*system.Bus.n+2*i+1] * \
(self.gsh[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]) + \
self.bsh[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]))
#PE/vsh
system.DAE.Gy[2 * system.Bus.n + 2 * i,2 * system.Bus.n + 2 * i + 1] += 2.0 * system.DAE.y[2*system.Bus.n+2*i+1]*self.gsh[i] - system.DAE.y[self.v[i]] * \
(self.gsh[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]) - \
self.bsh[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[2*system.Bus.n+2*i]))
#system.DAE.Gy[2 * system.Bus.n + 2 * i, 2 * system.Bus.n + 2 * i + 1] = system.DAE.Gy[2 * system.Bus.n + 2 * i,2 * system.Bus.n + 2 * i + 1]*system.DAE.y[2*system.Bus.n+2*i+1]
#Vi/ash
system.DAE.Gy[2 * system.Bus.n + 2 * i + 1,2 * system.Bus.n + 2 * i] += 0
#Vi/vsh
system.DAE.Gy[2 * system.Bus.n + 2 * i + 1,2 * system.Bus.n + 2 * i + 1] += 0
def fcall(self):
if self.n == 0:
return
omega_m = system.DAE.x[self.omega_m]
theta_p = system.DAE.x[self.theta_p]
idr = system.DAE.x[self.idr]
iqr = system.DAE.x[self.iqr]
vw = system.DAE.x[system.Wind.vw[self.wind]]
rho = system.Wind.rho[self.wind]
pwa = system.DAE.y[self.pwa]
V = system.DAE.y[self.v]
t = system.DAE.y[self.a]
st = sin(t)
ct = cos(t)
rs = self.rs
xs = self.xs
rr = self.rr
xr = self.xr
xm = self.xm
i2Hm = mul(self.u, self.dat3)
Kp = self.Kp
Tp = self.Tp
Kv = self.Kv
Te = self.Te
R = self.dat4
A = self.dat5
ng = self.ng
as1 = rs**2 + self.dat1**2
a13 = div(rs, as1)
a23 = div(self.dat1, as1)
a33 = self.dat2
vds = mul(-V, st)
vqs = mul(V, ct)
ids = mul(-a13, vds - mul(xm, iqr)) - mul(a23, vqs + mul(xm, idr))
iqs = mul(a23, vds - mul(xm, iqr)) - mul(a13, vqs + mul(xm, idr))
# wind speed in m/s
notu = matrix(0, (self.n, 1))
for i in range(self.n):
if self.u[i] == 1:
notu[i] = 0
else:
notu[i] = 1
iomega = 1 / (omega_m + notu)
Vw = mul(vw, system.Wind.vwn[self.wind])
Pw = div(
mul(
ng,
system.Dfig.windpower(rho, Vw, A, R, notu + omega_m, theta_p,
1)), mul(system.Settings.mva, 1e6))
# mechanical torque
Tm = mul(Pw, iomega)
# motion equation
system.DAE.f[self.omega_m] = mul(
Tm - mul(xm,
mul(iqr, ids) - mul(idr, iqs)), i2Hm)
# speed control equation
system.DAE.f[self.iqr] = mul(
self.u,
div(
-div(mul((xs + xm), mul(pwa, iomega)), mul(V, xm)) - iqr -
self.dat7, Te))
# voltage control equation
system.DAE.f[self.idr] = mul(
self.u,
mul(Kv, (V - system.DAE.y[self.vref])) - div(V, xm) - idr)
# pitch control equation
contex = decimal.getcontext()
contex.rounding = decimal.ROUND_05UP
phi = matrix(0.0, (self.n, 1))
for i in range(self.n):
phi[i] = round(Decimal(1000 * (notu[i] + omega_m[i] - 1))) / 1000
system.DAE.f[self.theta_p] = div(mul(self.u,
mul(Kp, phi) - theta_p), Tp)
# anti-windup limiter
system.Dfig.windup(idx=self.iqr,
xmax=self.dat8,
xmin=self.dat9,
type='f')
system.Dfig.windup(idx=self.idr,
xmax=self.dat10,
xmin=self.dat11,
type='f')
system.Dfig.windup(idx=self.theta_p,
xmax=[float('inf')] * self.n,
xmin=[0] * self.n,
type='f')
def Gycall(self):
for i in range(system.Sssc.n):
system.DAE.Gy[2 * system.Bus.n + 2 * system.Statcom.n +
2 * i, :] = 0
system.DAE.Gy[:,
2 * system.Bus.n + 2 * system.Statcom.n + 2 * i] = 0
system.DAE.Gy[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i +
1, :] = 0
system.DAE.Gy[:, 2 * system.Bus.n + 2 * system.Statcom.n + 2 * i +
1] = 0
for i in range(system.Sssc.n):
#Pi/vi
system.DAE.Gy[self.a[i],self.v[i]] -= 2*system.DAE.y[self.v[i]]*self.gse[i] - system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(self.gse[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i]) + \
self.bse[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i])) - \
system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i+1] * \
(self.gse[i] * cos(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]) + \
self.bse[i] * sin(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]))
#Qi/vi
system.DAE.Gy[self.v[i],self.v[i]] -= -2*system.DAE.y[self.v[i]]*self.bse[i] - system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(self.gse[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i]) - \
self.bse[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i])) - \
system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i+1] * \
(self.gse[i] * sin(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]) - \
self.bse[i] * cos(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]))
#Pj/vi
system.DAE.Gy[2*system.Bus.n-system.Sssc.n+i, self.v[i]] -= -system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]) + \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]))
#Qi/vj
system.DAE.Gy[system.Bus.n - system.Sssc.n + i, self.v[i]] -= -system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]) - \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]))
#PE/vi
system.DAE.Gy[2*system.Bus.n+2*system.Statcom.n+2*i,self.v[i]] += -system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i+1] * \
(self.gse[i] * cos(system.DAE.y[self.a[i]] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) - \
self.bse[i] * sin(system.DAE.y[self.a[i]] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#F/vi
system.DAE.Gy[2*system.Bus.n+2*system.Statcom.n+2*i+1,self.v[i]] += -system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]) + \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]))
#Pi/ai
system.DAE.Gy[self.a[i],self.a[i]] -= -system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(-self.gse[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i]) + \
self.bse[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i])) - \
system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i+1] * \
(-self.gse[i] * sin(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]) + \
self.bse[i] * cos(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]))
#Qi/ai
system.DAE.Gy[self.v[i],self.a[i]] -= -system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(self.gse[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i]) + \
self.bse[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i])) - \
system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i+1] * \
(self.gse[i] * cos(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]) + \
self.bse[i] * sin(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]))
#Pj/ai
system.DAE.Gy[system.Bus.n-system.Sssc.n+i, self.a[i]] -= -system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]) - \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]))
#Qj/ai
system.DAE.Gy[2*system.Bus.n - system.Sssc.n + i, self.a[i]] -= -system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(-self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]) - \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]))
# PE/ai
system.DAE.Gy[2 * system.Bus.n + 2*system.Statcom.n+2*i,self.a[i]] += -system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i+1] * \
(-self.gse[i] * sin(system.DAE.y[self.a[i]] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) - \
self.bse[i] * cos(system.DAE.y[self.a[i]] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
# F/ai
system.DAE.Gy[2 * system.Bus.n + 2*system.Statcom.n+2*i+1,self.a[i]] += -system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]) - \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]))
#Pi/vj
system.DAE.Gy[self.a[i], 2*system.Bus.n - system.Sssc.n + i] -= -system.DAE.y[self.v[i]] * \
(self.gse[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i]) + \
self.bse[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i]))
#Qi/vj
system.DAE.Gy[self.v[i], 2 * system.Bus.n - system.Sssc.n + i] -= -system.DAE.y[self.v[i]] * \
(self.gse[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i]) - \
self.bse[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i]))
#Pj/vj
system.DAE.Gy[system.Bus.n - system.Sssc.n + i, 2 * system.Bus.n - system.Sssc.n + i] -= 2*system.DAE.y[2*system.Bus.n-system.Sssc.n+i]*self.gse[i] - system.DAE.y[self.v[i]] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]) + \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i])) + \
system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) + \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#Qj/vj
system.DAE.Gy[2*system.Bus.n - system.Sssc.n + i, 2 * system.Bus.n - system.Sssc.n + i] -= -2*system.DAE.y[2*system.Bus.n-system.Sssc.n+i]*self.bse[i] -system.DAE.y[self.v[i]] * \
(self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]) - \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i])) + \
system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] * \
(self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) - \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#PE/vj
system.DAE.Gy[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i, 2 * system.Bus.n - system.Sssc.n + i] += system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) - \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] -system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#F/vj
system.DAE.Gy[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1, 2 * system.Bus.n - system.Sssc.n + i] += 2*system.DAE.y[2*system.Bus.n-system.Sssc.n+i]*self.gse[i] - system.DAE.y[self.v[i]] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]) + \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i])) + \
system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) + \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#Pi/aj
system.DAE.Gy[self.a[i], system.Bus.n - system.Sssc.n + i] -= -system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(self.gse[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i]) - \
self.bse[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i]))
#Qi/aj
system.DAE.Gy[self.v[i], system.Bus.n - system.Sssc.n + i] -= -system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(-self.gse[i]*cos(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i]) - \
self.bse[i]*sin(system.DAE.y[self.a[i]]-system.DAE.y[system.Bus.n-system.Sssc.n+i]))
#Pj/aj
system.DAE.Gy[system.Bus.n - system.Sssc.n + i, system.Bus.n - system.Sssc.n + i] -= -system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(-self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]) + \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i])) + \
system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] * \
(-self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) + \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#Qj/aj
system.DAE.Gy[2*system.Bus.n - system.Sssc.n + i, system.Bus.n - system.Sssc.n + i] -= -system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]) + \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i])) + \
system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) + \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#PE/aj
system.DAE.Gy[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i, system.Bus.n - system.Sssc.n + i] += system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] * \
(-self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) - \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] -system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#F/aj
system.DAE.Gy[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1, system.Bus.n - system.Sssc.n + i] += -system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n-system.Sssc.n+i] * \
(-self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i]) + \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i]-self.a[i])) + \
system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] * \
(-self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) + \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#Pi/vse
system.DAE.Gy[self.a[i], 2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] -= -system.DAE.y[self.v[i]] * \
(self.gse[i] * cos(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]) + \
self.bse[i] * sin(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]))
#Qi/vse
system.DAE.Gy[self.v[i], 2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] -= -system.DAE.y[self.v[i]] * \
(self.gse[i] * sin(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]) - \
self.bse[i] * cos(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]))
#Pj/vse
system.DAE.Gy[system.Bus.n - system.Sssc.n + i, 2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] -= system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) + \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#Qj/vse
system.DAE.Gy[2*system.Bus.n - system.Sssc.n + i, 2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] -= system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * \
(self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) - \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#PE/vse
system.DAE.Gy[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i, 2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] += -system.DAE.y[self.v[i]] * \
(self.gse[i] * cos(system.DAE.y[self.a[i]] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) - \
self.bse[i] * sin(system.DAE.y[self.a[i]] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i])) + \
system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) - \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] -system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#F/vse
system.DAE.Gy[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1, 2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] += system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * \
(self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) + \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#Pi/ase
system.DAE.Gy[self.a[i], 2 * system.Bus.n + 2 * system.Statcom.n + 2 * i] -= -system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i+1] * \
(self.gse[i] * sin(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]) - \
self.bse[i] * cos(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]))
#Qi/ase
system.DAE.Gy[self.v[i], 2 * system.Bus.n + 2 * system.Statcom.n + 2 * i] -= -system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i+1] * \
(-self.gse[i] * cos(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]) - \
self.bse[i] * sin(system.DAE.y[self.a[i]] - system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i]))
#Pj/ase
system.DAE.Gy[system.Bus.n - system.Sssc.n + i, 2 * system.Bus.n + 2 * system.Statcom.n + 2 * i] -= system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] * \
(self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) - \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#Qj/ase
system.DAE.Gy[2*system.Bus.n - system.Sssc.n + i, 2 * system.Bus.n + 2 * system.Statcom.n + 2 * i] -=system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] * \
(-self.gse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) - \
self.bse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#PE/ase
system.DAE.Gy[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i, 2 * system.Bus.n + 2 * system.Statcom.n + 2 * i] += -system.DAE.y[self.v[i]]*system.DAE.y[2*system.Bus.n+2*system.Statcom.n+2*i+1] * \
(self.gse[i] * sin(system.DAE.y[self.a[i]] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) + \
self.bse[i] * cos(system.DAE.y[self.a[i]] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i])) + \
system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] * \
(self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) + \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] -system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
#F/ase
system.DAE.Gy[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1, 2 * system.Bus.n + 2 * system.Statcom.n + 2 * i] += system.DAE.y[2 * system.Bus.n - system.Sssc.n + i] * system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i + 1] * \
(self.gse[i] * sin(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]) - \
self.bse[i] * cos(system.DAE.y[system.Bus.n - system.Sssc.n + i] - system.DAE.y[2 * system.Bus.n + 2 * system.Statcom.n + 2 * i]))
def Fxcall(self):
if self.n == 0:
return
omega_m = system.DAE.x[self.omega_m]
theta_p = system.DAE.x[self.theta_p]
idr = system.DAE.x[self.idr]
iqr = system.DAE.x[self.iqr]
vw = system.DAE.x[system.Wind.vw[self.wind]]
rho = system.Wind.rho[self.wind]
pwa = system.DAE.y[self.pwa]
V = system.DAE.y[self.v]
t = system.DAE.y[self.a]
st = sin(t)
ct = cos(t)
rs = self.rs
xs = self.xs
rr = self.rr
xr = self.xr
xm = self.xm
i2Hm = mul(self.u, self.dat3)
Kp = self.Kp
Tp = self.Tp
Kv = self.Kv
Te = self.Te
R = self.dat4
A = self.dat5
ng = self.ng
as1 = rs**2 + self.dat1**2
a13 = div(rs, as1)
a23 = div(self.dat1, as1)
a33 = self.dat2
vds = mul(-V, st)
vqs = mul(V, ct)
ids = mul(-a13, vds - mul(xm, iqr)) - mul(a23, vqs + mul(xm, idr))
iqs = mul(a23, vds - mul(xm, iqr)) - mul(a13, vqs + mul(xm, idr))
vdr = mul(-rr, idr) + mul(1 - omega_m, mul(a33, iqr) + mul(xm, iqs))
vqr = mul(-rr, iqr) - mul(1 - omega_m, mul(a33, idr) + mul(xm, ids))
notu = matrix(0, (self.n, 1))
for i in range(self.n):
if self.u[i] == 1:
notu[i] = 0
else:
notu[i] = 1
iomega = 1 / (omega_m + notu)
Vwrate = system.Wind.vwn[self.wind]
Vw = mul(vw, Vwrate)
dPwdx = div(
system.Dfig.windpower(rho, Vw, A, R, notu + omega_m, theta_p, 2),
mul(system.Settings.mva, 1e6))
Pw = div(
mul(
ng,
system.Dfig.windpower(rho, Vw, A, R, notu + omega_m, theta_p,
1)), mul(system.Settings.mva, 1e6))
# mechanical torque
Tm = mul(Pw, iomega)
iqrsign = [1.0] * self.n
w21 = 2 * omega_m - 1
if len(w21) == 1:
if (w21[0] <= 0) or (w21[0] >= 1):
iqrsign = -1
else:
for i in range(len(w21)):
if (w21[i] <= 0) or (w21[i] >= 1):
iqrsign[i] = -1
w211 = matrix(0.0, (len(w21), 1))
for i in range(len(w21)):
w211[i] = min(w21[i], 1)
Tsp1 = div(mul(self.Sn, mul(w211, iomega)), system.Settings.mva)
Tsp = matrix(0.0, (len(Tsp1), 1))
for i in range(len(Tsp1)):
Tsp[i] = max(Tsp1[i], 0)
slip = 1 - omega_m
iqr_min = div(-self.Sn, system.Settings.mva)
# df / dy
idsv = mul(a13, st) - mul(a23, ct)
idst = mul(a13, vqs) - mul(a23, vds)
iqsv = mul(-a23, st) - mul(a13, ct)
iqst = mul(-a23, vqs) - mul(a13, vds)
ot = mul(mul(xm, i2Hm), mul(idr, iqst) - mul(iqr, idst))
ov = mul(mul(xm, i2Hm), mul(idr, iqsv) - mul(iqr, idsv))
iqrv = div(mul(xs + xm, Tsp), mul(Te, mul(V, mul(V, xm))))
system.DAE.Fy = system.DAE.Fy \
+ spmatrix(ot, self.omega_m, self.a, (system.DAE.nx, system.DAE.ny)) \
+ spmatrix(ov, self.omega_m, self.v, (system.DAE.nx, system.DAE.ny))
# dg / dx
idsidr = mul(-a23, xm)
idsiqr = mul(a13, xm)
iqsidr = mul(-a13, xm)
iqsiqr = mul(-a23, xm)
vdridr = -rr + mul(slip, mul(xm, iqsidr))
vdriqr = mul(slip, (a33 + mul(xm, iqsiqr)))
vqriqr = -rr - mul(slip, mul(xm, idsiqr))
vqridr = mul(-slip, (a33 + mul(xm, idsidr)))
vdrom = -(mul(a33, iqr) + mul(xm, iqs))
vqrom = mul(a33, idr) + mul(xm, ids)
pidr = mul(vds, idsidr) + mul(vqs, iqsidr) + mul(
idr, vdridr) + vdr + mul(iqr, vqridr)
piqr = mul(vds, idsiqr) + mul(vqs, iqsiqr) + mul(
idr, vdriqr) + vqr + mul(iqr, vqriqr)
pom = mul(idr, vdrom) + mul(iqr, vqrom)
qidr = div(mul(-xm, V), self.dat1)
system.DAE.Gx = system.DAE.Gx - spmatrix(mul(
self.u, pom), self.a, self.omega_m, (system.DAE.ny, system.DAE.nx))
# df / dx
oidr = mul(mul(xm, i2Hm), mul(idr, iqsidr) + iqs - mul(iqr, idsidr))
oiqr = mul(mul(xm, i2Hm), mul(idr, iqsiqr) - ids - mul(iqr, idsiqr))
# mechanical equation
dPwdx1 = matrix(0.0, (self.n, 1))
dPwdx2 = matrix(0.0, (self.n, 1))
for i in range(self.n):
dPwdx1[i] = dPwdx[i]
dPwdx2[i] = dPwdx[self.n * 1 + i]
omedome = -notu + mul(mul(ng, dPwdx1) - Tm, mul(i2Hm, iomega))
omedwind = mul(Vwrate, mul(ng, mul(dPwdx2), mul(i2Hm, iomega)))
system.DAE.Fx = system.DAE.Fx + spmatrix(omedome, self.omega_m, self.omega_m, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(omedwind, self.omega_m, system.Wind.vw[self.wind], (system.DAE.nx, system.DAE.nx))
# pitch angle control equation
z = matrix(0, (self.n, 1))
for i in range(self.n):
if (theta_p[i] > 0) and (self.u[i]):
z[i] = 1
dPwdx3 = matrix(0.0, (self.n, 1))
for i in range(self.n):
dPwdx3[i] = dPwdx[self.n * 2 + i]
ones = matrix(1, (self.n, 1))
omedtheta = mul(mul(z, ng), mul(dPwdx3, mul(i2Hm, iomega)))
system.DAE.Fx = system.DAE.Fx - spmatrix(div(ones, Tp), self.theta_p, self.theta_p, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(div(mul(z, Kp), Tp), self.theta_p, self.omega_m, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(omedtheta, self.omega_m, self.theta_p, (system.DAE.nx, system.DAE.nx))
# speed control equation
kiqr = div(mul(-matrix(iqrsign), (xs + xm)), mul(V, mul(xm, Te)))
tspo = 2 * div(self.Sn, system.Settings.mva)
iqrp = div(mul(-(xs + xm), iomega), mul(V, mul(xm, Te)))
iqrw = div(mul((xs + xm), mul(pwa, mul(iomega, iomega))),
mul(V, mul(xm, Te)))
for i in range(len(Tsp)):
if (Tsp[i] == 0) & (w21[i] >= 1):
tspo[i] = 0
iqr_max = self.dat8
iqr_min = self.dat9
z = matrix(0, (self.n, 1))
for i in range(self.n):
if (iqr[i] < iqr_max[i]) and (iqr[i] > iqr_min[i]):
if self.u[i]:
z[i] = 1
system.DAE.Fx = system.DAE.Fx - spmatrix(div(ones, Te), self.iqr, self.iqr, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(mul(z, iqrw), self.iqr, self.omega_m, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(mul(z, oiqr), self.omega_m, self.iqr, (system.DAE.nx, system.DAE.nx))
system.DAE.Fy = system.DAE.Fy + spmatrix(mul(z, iqrv), self.iqr, self.v, (system.DAE.nx, system.DAE.ny)) \
+ spmatrix(mul(z, iqrp), self.iqr, self.pwa, (system.DAE.nx, system.DAE.ny))
system.DAE.Gx = system.DAE.Gx - spmatrix(mul(
z, piqr), self.a, self.iqr, (system.DAE.ny, system.DAE.nx))
# voltage control equation
idr_max = self.dat10
idr_min = self.dat11
z = matrix(0, (self.n, 1))
for i in range(self.n):
if (idr[i] < idr_max[i]) and (idr[i] > idr_min[i]):
if self.u[i]:
z[i] = 1
system.DAE.Fx = system.DAE.Fx + spmatrix([-1]*self.n, self.idr, self.idr, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(mul(z, oidr), self.omega_m, self.idr, (system.DAE.nx, system.DAE.nx))
system.DAE.Fy = system.DAE.Fy + spmatrix(mul(z, Kv-1/xm), self.idr, self.v, (system.DAE.nx, system.DAE.ny)) \
- spmatrix(mul(z, Kv), self.idr, self.vref, (system.DAE.nx, system.DAE.ny))
system.DAE.Gx = system.DAE.Gx - spmatrix(mul(z, pidr), self.a, self.idr, (system.DAE.ny, system.DAE.nx)) \
- spmatrix(mul(z, qidr), self.v, self.idr, (system.DAE.ny, system.DAE.nx))
# power reference equation
z = matrix(0, (self.n, 1))
for i in range(self.n):
if (omega_m[i] < 1) and (omega_m[i] > 0.5):
z[i] = 1
system.DAE.Gx = system.DAE.Gx + spmatrix(
2 * mul(z, self.Sn) / system.Settings.mva, self.pwa, self.omega_m,
(system.DAE.ny, system.DAE.nx))
def Gycall(self):
if self.n == 0:
return
omega_m = system.DAE.x[self.omega_m]
idr = system.DAE.x[self.idr]
iqr = system.DAE.x[self.iqr]
pwa = system.DAE.y[self.pwa]
V = system.DAE.y[self.v]
t = system.DAE.y[self.a]
st = sin(t)
ct = cos(t)
rs = self.rs
rr = self.rr
xm = self.xm
as1 = rs**2 + self.dat1**2
a13 = div(rs, as1)
a23 = div(self.dat1, as1)
a33 = self.dat2
vds = mul(-V, st)
vqs = mul(V, ct)
ids = mul(-a13, vds - mul(xm, iqr)) - mul(a23, vqs + mul(xm, idr))
iqs = mul(a23, vds - mul(xm, iqr)) - mul(a13, vqs + mul(xm, idr))
vdr = mul(-rr, idr) + mul(1 - omega_m, mul(a33, iqr) + mul(xm, iqs))
vqr = mul(-rr, iqr) + mul(1 - omega_m, mul(a33, idr) + mul(xm, ids))
pv = mul(-ids, st) + mul(iqs, ct)
pt = mul(-ids, vqs) + mul(iqs, vds)
idsv = mul(a13, st) - mul(a23, ct)
idst = mul(a13, vqs) - mul(a23, vds)
iqsv = mul(-a23, st) - mul(a13, ct)
iqst = mul(-a23, vqs) - mul(a13, vds)
k = mul(1 - omega_m, xm)
vdrv = mul(k, iqsv)
vdrt = mul(k, iqst)
vqrv = mul(-k, idsv)
vqrt = mul(-k, idst)
j11 = mul(vds, idst) + mul(vqs, iqst) + mul(vdrt, idr) + mul(
vqrt, iqr) + pt
j12 = mul(vds, idsv) + mul(vqs, iqsv) + mul(vdrv, idr) + mul(
vqrv, iqr) + pv
j22 = div(-(mul(xm, idr) + 2 * V), self.dat1)
ones = [0] * self.n
system.DAE.Gy = system.DAE.Gy - \
spmatrix(mul(self.u, j11), self.a, self.a, (system.DAE.ny, system.DAE.ny)) - \
spmatrix(mul(self.u, j12), self.a, self.v, (system.DAE.ny, system.DAE.ny)) - \
spmatrix(mul(self.u, j22), self.v, self.v, (system.DAE.ny, system.DAE.ny)) - \
spmatrix([1] * self.n, self.vref, self.vref, (system.DAE.ny, system.DAE.ny)) - \
spmatrix([1] * self.n, self.pwa, self.pwa, (system.DAE.ny, system.DAE.ny))
def setx0(self):
if self.n == 0:
return
check = 1
Pc = system.Bus.Pg[self.a]
Qc = system.Bus.Qg[self.a]
Vc = system.DAE.y[self.v]
ac = system.DAE.y[self.a]
vds = mul(-Vc, sin(ac)) # 角度还是弧度
vqs = mul(Vc, cos(ac))
rho = system.Wind.rho[self.wind]
ones = matrix(1, (self.n, 1))
# 常数
# xs + xm
self.dat1 = self.xs + self.xm
self.dat2 = self.xr + self.xm
self.dat3 = div(ones, mul(2 * ones, self.Hm))
self.dat4 = div(
mul(4 * math.pi * system.Settings.freq * self.R, self.nGB),
self.np)
self.dat5 = math.pi * mul(self.R, self.R)
self.dat6 = Vc
self.dat8 = mul(div(-self.pmin, self.xm), self.dat1)
self.dat9 = mul(div(-self.pmax, self.xm), self.dat1)
self.dat10 = -mul(div(div(ones, self.xm) + self.qmin, self.xm),
self.dat1)
self.dat11 = -mul(div(div(ones, self.xm) + self.qmax, self.xm),
self.dat1)
# 初始化状态变量
for i in range(self.n):
# 参数
Vds = vds[i]
Vqs = vqs[i]
Rs = self.rs[i]
Rr = self.rr[i]
Xm = self.xm[i]
x1 = self.dat1[i]
x2 = self.dat2[i]
Pg = Pc[i]
Qg = Qc[i]
# 转子速度
Pci = Pc[i] * system.Settings.mva
if (Pci < self.Sn[i]) & (Pc[i] > 0):
omega = 0.5 * Pc[i] * system.Settings.mva / self.Sn + 0.5
elif Pci >= self.Sn[i]:
omega = 1
else:
omega = 0.5
slip = 1 - omega
iqr = -x1 * self.Sn * (
2 * omega - 1) / Vc[i] / Xm / system.Settings.mva / omega
A = [[-Rs, Vqs], [x1, -Vds]]
B = [Vds - Xm * iqr, Qg]
A = sparse(A)
B = matrix(B)
umfpack.linsolve(A, B)
# B = numpy.array(B)
# Is = numpy.linalg.solve(A, B)
ids = B[0]
iqs = B[1]
idr = -(Vqs + Rs * iqs + x1 * ids) / Xm
vdr = -Rr * idr + slip * (x2 * iqr + Xm * iqs)
vqr = -Rr * iqr - slip * (x2 * idr + Xm * ids)
jac = matrix(0.0, (6, 6))
eqn = matrix(1.0, (6, 1))
inc = matrix(1.0, (6, 1))
x = matrix(0.0, (6, 1))
x[0] = ids
x[1] = iqs
x[2] = idr
x[3] = iqr
x[4] = vdr
x[5] = vqr
rows = [0, 0, 0, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5]
cols = [0, 1, 3, 0, 1, 2, 2, 4, 3, 5, 0, 1, 2]
vals = [
-Rs, x1, Xm, -x1, -Rs, -Xm, -Rr, -1, -Rr, -1, Vds, Vqs,
-Xm * Vc[i] / x1
]
jac0 = spmatrix(vals, rows, cols, (6, 6), 'd')
# jac0 = jac + spmatrix(-Rs, [0], [0], (6, 6))
# jac0 = jac + spmatrix(x1, [0], [1], (6, 6))
# jac0 = jac + spmatrix(Xm, [0], [3], (6, 6))
# jac0 = jac + spmatrix(-x1, [1], [0], (6, 6))
# jac0 = jac + spmatrix(-Rs, [1], [1], (6, 6))
# jac0 = jac + spmatrix(-Xm, [1], [2], (6, 6))
# jac0 = jac + spmatrix(-Rr, [2], [2], (6, 6))
# jac0 = jac + spmatrix(-1, [2], [4], (6, 6))
# jac0 = jac + spmatrix(-Rr, [3], [3], (6, 6))
# jac0 = jac + spmatrix(-1, [3], [5], (6, 6))
# jac0 = jac + spmatrix(Vds, [4], [0], (6, 6))
# jac0 = jac + spmatrix(Vqs, [4], [1], (6, 6))
# jac0 = jac + spmatrix(-Xm*Vc[i]/x1, [5], [2], (6, 6))
k = x1 * self.Sn[i] / Vc[i] / Xm / system.Settings.mva
iter = 0
while max(abs(eqn)) > 1e-8:
if iter > 20:
print('双馈风力发电机%i初始化失败' % i)
check = 0
break
eqn[0] = -Rs * x[0] + x1 * x[1] + Xm * x[3] - Vds
eqn[1] = -Rs * x[1] - x1 * x[0] - Xm * x[2] - Vqs
eqn[2] = -Rr * x[2] + slip * (x2 * x[3] + Xm * x[1]) - x[4]
eqn[3] = -Rr * x[3] - slip * (x2 * x[2] + Xm * x[0]) - x[5]
eqn[4] = Vds * x[0] + Vqs * x[1] + x[4] * x[2] + x[5] * x[
3] - Pg
eqn[5] = -Xm * Vc[i] * x[2] / x1 - Vc[i] * Vc[i] / x1 - Qg
rows = [2, 2, 3, 3, 4, 4, 4, 4]
cols = [1, 3, 0, 2, 2, 3, 4, 5]
vals = [
slip[i] * Xm, slip[i] * x2, -slip[i] * Xm, -slip[i] * x2,
x[4], x[5], x[2], x[3]
]
jac = jac0 + spmatrix(vals, rows, cols, (6, 6), 'd')
# jac = jac + spmatrix(slip * Xm, [2], [1], (6, 6))
# jac = jac + spmatrix(slip * x2, [2], [3], (6, 6))
# jac = jac + spmatrix(-slip * Xm, [3], [0], (6, 6))
# jac = jac + spmatrix(-slip * x2, [3], [2], (6, 6))
# jac = jac + spmatrix(x[4], [4], [2], (6, 6))
# jac = jac + spmatrix(x[5], [4], [3], (6, 6))
# jac = jac + spmatrix(x[2], [4], [4], (6, 6))
# jac = jac + spmatrix(x[3], [4], [5], (6, 6))
jac = sparse(jac)
umfpack.linsolve(jac, eqn)
#inc = -numpy.linalg.solve(jac, eqn)
x = x - eqn
iter = iter + 1
ids = x[0]
iqs = x[1]
idr = x[2]
iqr = x[3]
vdr = x[4]
vqr = x[5]
if iqr > self.dat8[i]:
print(
'Warning: Dfig %i at Bus %s : iqr is over its max limit' %
(i, self.a[i]))
check = 0
if iqr < self.dat9[i]:
print(
'Warning: Dfig %i at Bus %s : iqr is under its min limit' %
(i, self.a[i]))
check = 0
if idr > self.dat10[i]:
print(
'Warning: Dfig %i at Bus %s : idr is over its max limit' %
(i, self.a[i]))
check = 0
if idr < self.dat11[i]:
print(
'Warning: Dfig %i at Bus %s : idr is under its min limit' %
(i, self.a[i]))
check = 0
# theta_p
contex = decimal.getcontext()
contex.rounding = decimal.ROUND_05UP
theta = self.Kp * round(Decimal(1000 * (omega[i] - 1))) / 1000
theta = max([theta[0], 0])
# wind turbine state variables
system.DAE.x[self.idr[i]] = idr
system.DAE.x[self.iqr[i]] = iqr
system.DAE.x[self.omega_m[i]] = omega
system.DAE.x[self.theta_p[i]] = theta
# Vref
Kv = self.Kv[i]
if Kv == 0: # 没有电压控制
self.dat6 = 0
else:
self.dat6 = Vc[i] - (idr + Vc[i] / Xm) / Kv
self.dat7 = -k * max([min([2 * omega[i] - 1, 1]), 0
]) / omega[i] - iqr
# electric torque
Tel = Xm * (iqr * ids - idr * iqs)
if Pg < 0:
print('** Turbine power is negative at Bus %i' % self.a[i])
print('Wind speed % i can not be initialized.' % self.wind[i])
system.DAE.x[system.Wind.vw[self.wind[i]]] = 1
continue
# wind power [MW]
Pw = Tel * omega * system.Settings.mva * 1e6 / self.ng
# wind speed
iter = 0
incvw = matrix(1.0, (1, 1))
eqnvw = [1]
R = self.dat4[i]
AA = self.dat5[i]
# initial guess wind speed
vw = 0.9 * system.Wind.vwn[self.wind[i]]
while abs(incvw[0]) > 1e-7:
if iter > 50:
print(
'**Initialization of wind speed %i failed(converge problem)'
% self.wind[i])
print('Tip: Try increasing the nominal wind speed')
check = 0
break
output = system.Dfig.windpower(rho[i], vw, AA, R, omega, theta,
1)
eqnvw = output - Pw
jacvw = system.Dfig.windpower(rho[i], vw, AA, R, omega, theta,
2)
# incvw = -numpy.linalg.solve(jacvw[2], eqnvw)
incvw = -eqnvw / jacvw[1]
vw = vw + incvw[0]
iter = iter + 1
# average initial wind speed
system.DAE.x[system.Wind.vw[
self.wind[i]]] = vw / system.Wind.vwn[self.wind[i]]
# find and delete static generators
for bj in range(self.n):
for bk in range(system.PV.n):
if self.u[bj] * self.a[bj] == system.PV.a[bk]:
idx = 'PV_' + str(bk + 1)
system.PV.remove(idx)
for bk in range(system.SW.n):
if self.u[bj] * self.a[bj] == system.SW.a[bk]:
system.SW.remove(idx='SW_1')
system.DAE.x[self.idr] = mul(self.u, system.DAE.x[self.idr])
system.DAE.x[self.iqr] = mul(self.u, system.DAE.x[self.iqr])
system.DAE.x[self.omega_m] = mul(self.u, system.DAE.x[self.omega_m])
system.DAE.x[self.theta_p] = mul(self.u, system.DAE.x[self.theta_p])
system.DAE.y[self.vref] = mul(self.u, self.dat6)
xomega = system.DAE.x[self.omega_m]
xomega1 = matrix(0.0, (self.n, 1))
for i in range(self.n):
xomega1[i] = max([min([2 * xomega[i] - 1, 1]), 0])
system.DAE.y[self.pwa] = mul(self.Sn, div(xomega1,
system.Settings.mva))
if not check:
print('双馈风力发电机初始化失败')
else:
print('双馈风力发电机初始化完成')
def dfcall(self, x):
dfvec = mul(mul(self.A, self.omega), cos(self.omega * x + self.phi))
return sum(dfvec)
def Fxcall(self):
delta = system.DAE.x[self.delta]
omega = system.DAE.x[self.omega]
ag = system.DAE.y[self.a]
vg = mul(self.u, system.DAE.y[self.v])
ss = sin(delta - ag)
cc = cos(delta - ag)
e1q = system.DAE.x[self.e1q]
e1d = system.DAE.x[self.e1d]
e2q = system.DAE.x[self.e2q]
e2d = system.DAE.x[self.e2d]
iM = div(self.u, self.M)
M1 = mul(vg, (mul(self.c1, cc) - mul(self.c3, ss)))
M2 = mul(-vg, (mul(self.c2, cc) + mul(self.c1, ss)))
M3 = -(mul(self.c1, ss) + mul(self.c3, cc))
M4 = (mul(self.c2, ss) - mul(self.c1, cc))
rad = 2 * math.pi * system.Settings.freq
Wn = self.u * rad # print(Wn)
# print(mul(iM, self.D)+matrix(1, (self.n, 1))-self.u)
system.DAE.Fx = system.DAE.Fx - spmatrix(matrix(1, (self.n, 1))-self.u, self.delta, self.delta, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(Wn, self.delta, self.omega, (system.DAE.nx, system.DAE.nx)) \
- spmatrix(mul(iM, self.D)+matrix(1, (self.n, 1))-self.u, self.omega, self.omega, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(mul(mul(2*self.ra, mul(self.Id, M1)+mul(self.Iq, M2)), iM), self.omega, self.delta, (system.DAE.nx, system.DAE.nx))
system.DAE.Fy = system.DAE.Fy \
- spmatrix(mul(mul(2 * self.ra, mul(self.Id, M1) + mul(self.Iq, M2)), iM), self.omega, self.a, (system.DAE.nx, system.DAE.ny)) \
- spmatrix(mul(mul(2 * self.ra, mul(self.Id, M3) + mul(self.Iq, M4)), iM), self.omega, self.v, (system.DAE.nx, system.DAE.ny)) \
- spmatrix(iM, self.omega, self.p, (system.DAE.nx, system.DAE.ny)) \
+ spmatrix(iM, self.omega, self.pm, (system.DAE.nx, system.DAE.ny))
system.DAE.Gx = system.DAE.Gx + spmatrix(self.J11, self.p, self.delta,(system.DAE.ny, system.DAE.nx)) \
+ spmatrix(self.J21, self.q, self.delta, (system.DAE.ny, system.DAE.nx))
Gp1 = mul(vg, (mul(self.c3, ss) + mul(self.c1, cc)))
Gp2 = mul(vg, (mul(self.c1, ss) - mul(self.c2, cc)))
Gq1 = mul(vg, (mul(self.c3, cc) - mul(self.c1, ss)))
Gq2 = mul(vg, (mul(self.c1, cc) + mul(self.c2, ss)))
N1 = mul(
mul(-2 * self.ra,
mul(self.Id, self.c3) + mul(self.Iq, self.c1)), iM)
N2 = mul(
mul(-2 * self.ra,
mul(self.Id, self.c1) - mul(self.Iq, self.c2)), iM)
gd = div(mul(mul(self.xd2, self.Td02), self.xd - self.xd1),
mul(self.xd1, self.Td01))
gq = div(mul(mul(self.xq2, self.Tq02), self.xq - self.xq1),
mul(self.xq1, self.Tq01))
a1 = div(self.u, self.Td02)
a2 = mul(a1, self.xd1 - self.xd2 + gd)
a3 = div(mul(self.u, self.Taa), mul(self.Td01, self.Td02))
a4 = div(self.u, self.Td01)
a5 = mul(a4, self.xd - self.xd1 - gd)
a6 = mul(a4, 1 - div(self.Taa, self.Td01))
b1 = div(self.u, self.Tq02)
b2 = mul(b1, self.xq1 - self.xq2 + gq)
b3 = div(self.u, self.Tq01)
b4 = mul(b3, self.xq - self.xq1 - gq)
a = []
for i in range(self.n):
if self.u[i] == 1:
a.append(0)
else:
a.append(1)
a = matrix(a)
system.DAE.Fx = system.DAE.Fx + spmatrix(N1, self.omega, self.e2q, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(N2, self.omega, self.e2d, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(mul(a5, M1), self.e1q, self.delta, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(mul(a6, self.Komega), self.e1q, self.omega, (system.DAE.nx, system.DAE.nx)) \
- spmatrix(mul(a4, self.synsat2())+a, self.e1q, self.e1q, (system.DAE.nx, system.DAE.nx)) \
- spmatrix(mul(a5, self.c3), self.e1q, self.e2q, (system.DAE.nx, system.DAE.nx)) \
- spmatrix(mul(a5, self.c1), self.e1q, self.e2d, (system.DAE.nx, system.DAE.nx)) \
- spmatrix(mul(b4, M2), self.e1d, self.delta, (system.DAE.nx, system.DAE.nx)) \
- spmatrix(b3+a, self.e1d, self.e1d, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(mul(b4, self.c1), self.e1d, self.e2q, (system.DAE.nx, system.DAE.nx)) \
- spmatrix(mul(b4, self.c2), self.e1d, self.e2d, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(mul(a2, M1), self.e2q, self.delta, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(mul(a3, self.Komega), self.e2q, self.omega, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(a1, self.e2q, self.e1q, (system.DAE.nx, system.DAE.nx)) \
- spmatrix(a1+mul(a2, self.c3)+a, self.e2q, self.e2q, (system.DAE.nx, system.DAE.nx)) \
- spmatrix(mul(a2, self.c1), self.e2q, self.e2d, (system.DAE.nx, system.DAE.nx)) \
- spmatrix(mul(b2, M2), self.e2d, self.delta, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(b1, self.e2d, self.e1d, (system.DAE.nx, system.DAE.nx)) \
+ spmatrix(mul(b2, self.c1), self.e2d, self.e2q, (system.DAE.nx, system.DAE.nx)) \
- spmatrix(b1+mul(b2, self.c2)+a, self.e2d, self.e2d, (system.DAE.nx, system.DAE.nx))
system.DAE.Fy = system.DAE.Fy \
+ spmatrix(a6, self.e1q, self.vf, (system.DAE.nx, system.DAE.ny)) \
+ spmatrix(a3, self.e2q, self.vf, (system.DAE.nx, system.DAE.ny)) \
- spmatrix(mul(a5, M1), self.e1q, self.a, (system.DAE.nx, system.DAE.ny)) \
- spmatrix(mul(a5, M3), self.e1q, self.v, (system.DAE.nx, system.DAE.ny)) \
+ spmatrix(mul(b4, M2), self.e1d, self.a, (system.DAE.nx, system.DAE.ny)) \
+ spmatrix(mul(b4, M4), self.e1d, self.v, (system.DAE.nx, system.DAE.ny)) \
- spmatrix(mul(a2, M1), self.e2q, self.a, (system.DAE.nx, system.DAE.ny)) \
- spmatrix(mul(a2, M3), self.e2q, self.v, (system.DAE.nx, system.DAE.ny)) \
+ spmatrix(mul(b2, M2), self.e2d, self.a, (system.DAE.nx, system.DAE.ny)) \
+ spmatrix(mul(b2, M4), self.e2d, self.v, (system.DAE.nx, system.DAE.ny)) \
- spmatrix(mul(a6, self.KP), self.e1q, self.p, (system.DAE.nx, system.DAE.ny)) \
- spmatrix(mul(a3, self.KP), self.e2q, self.p, (system.DAE.nx, system.DAE.ny))
system.DAE.Gx = system.DAE.Gx + spmatrix(Gp1, self.p, self.e2q, (system.DAE.ny, system.DAE.nx)) \
+ spmatrix(Gp2, self.p, self.e2d, (system.DAE.ny, system.DAE.nx)) \
+ spmatrix(Gq1, self.q, self.e2q, (system.DAE.ny, system.DAE.nx)) \
+ spmatrix(Gq2, self.q, self.e2d, (system.DAE.ny, system.DAE.nx))
