def first_time_step():
# compute first time step
# estimate the minimum time step
if not system.DAE.nx:
freq = 1.0
elif system.DAE.nx == 1:
B = matrix(system.DAE.Gx)
linsolve(system.DAE.Gy, B)
As = system.DAE.Fx - system.DAE.Fy * B
freq = abs(As[0, 0])
else:
freq = 40.0
if freq > system.Settings.freq:
freq = float(system.Settings.freq)
if not freq: freq = 40.0
# set the minimum time step
deltaT = abs(system.Settings.tf - system.Settings.t0)
Tstep = 1 / freq
system.Settings.deltatmax = min(5 * Tstep, deltaT / 100.0)
system.Settings.deltat = min(Tstep, deltaT / 100.0)
system.Settings.deltatmin = min(Tstep / 64, system.Settings.deltatmax / 20)
if system.Settings.fixt:
if system.Settings.tstep <= 0:
print('Fixed time step is negative or zero')
print('Automatic time step has been set')
system.Settings.fixt = False
elif system.Settings.tstep < system.Settings.deltatmin:
print('Fixed time step is less than estimated minimum time step')
system.Settings.deltat = system.Settings.tstep
else:
system.Settings.deltat = system.Settings.tstep
return system.Settings.deltat
def test_pcg():
'Test function for projected CG.'
n = 10
m = 4
H = sprandsym(n,n)
A = sp_rand(m,n,0.9)
x0 = matrix(1,(n,1))
b = A*x0
c = matrix(1.0,(n,1))
x_pcg = pcg(H,c,A,b,x0)
Lhs1 = sparse([H,A])
Lhs2 = sparse([A.T,spmatrix([],[],[],(m,m))])
Lhs = sparse([[Lhs1],[Lhs2]])
rhs = -matrix([c,spmatrix([],[],[],(m,1))])
rhs2 = copy(rhs)
linsolve(Lhs,rhs)
#print rhs[:10]
sol = solvers.qp(H,c,A=A,b=b)
print ' cvxopt qp| pCG'
print matrix([[sol['x']],[x_pcg]])
print 'Dual variables:'
print sol['y']
print 'KKT equation residuals:'
print H*sol['x'] + c + A.T*sol['y']
def linsolve(A,b):
aLocal = A.tocoo()
AC = cvxopt.spmatrix(aLocal.data.tolist(),aLocal.row.tolist(), aLocal.col.tolist())
bLocal = cvxopt.matrix(copy.deepcopy(b))
umfpack.linsolve(AC,bLocal)
bLocal = np.array(bLocal).flatten()
return bLocal
def test_pcg():
'Test function for projected CG.'
n = 10
m = 4
H = sprandsym(n, n)
A = sp_rand(m, n, 0.9)
x0 = matrix(1, (n, 1))
b = A * x0
c = matrix(1.0, (n, 1))
x_pcg = pcg(H, c, A, b, x0)
Lhs1 = sparse([H, A])
Lhs2 = sparse([A.T, spmatrix([], [], [], (m, m))])
Lhs = sparse([[Lhs1], [Lhs2]])
rhs = -matrix([c, spmatrix([], [], [], (m, 1))])
rhs2 = copy(rhs)
linsolve(Lhs, rhs)
#print rhs[:10]
sol = solvers.qp(H, c, A=A, b=b)
print ' cvxopt qp| pCG'
print matrix([[sol['x']], [x_pcg]])
print 'Dual variables:'
print sol['y']
print 'KKT equation residuals:'
print H * sol['x'] + c + A.T * sol['y']
def minG(A, r, G=None):
'Find y that minimize the norm(r - A.T*y)'
if G is None:
Lhs = A * A.T
rhs = A * r
cp = copy(rhs)
linsolve(Lhs, rhs)
return rhs
def minG(A,r,G= None):
'Find y that minimize the norm(r - A.T*y)'
if G is None:
Lhs = A*A.T
rhs = A*r
cp = copy(rhs)
linsolve(Lhs,rhs)
return rhs
def state_matrix():
Gyx = matrix(system.DAE.Gx)
linsolve(sparse(system.DAE.Gy), Gyx)
I = []
J = []
for i in range(system.DAE.nx):
I.append(i)
J.append(i)
return system.DAE.Fx - system.DAE.Fy * Gyx - spmatrix(1e-6, I, J)
def project(A,r,G = None, fA = None):
'Project r to null(A) by solving the normal equation AA.t v = Ar.'
m,n = A.size
if G is None:
G = spmatrix([1]*n,range(n),range(n))
Lhs1 = sparse([G,A])
Lhs2 = sparse([A.T, spmatrix([],[],[],(m,m))])
Lhs = sparse([[Lhs1],[Lhs2]])
rhs = matrix([r,spmatrix([],[],[],(m,1))])
linsolve(Lhs,rhs)
return rhs[:n]
def project(A, r, G=None, fA=None):
'Project r to null(A) by solving the normal equation AA.t v = Ar.'
m, n = A.size
if G is None:
G = spmatrix([1] * n, range(n), range(n))
Lhs1 = sparse([G, A])
Lhs2 = sparse([A.T, spmatrix([], [], [], (m, m))])
Lhs = sparse([[Lhs1], [Lhs2]])
rhs = matrix([r, spmatrix([], [], [], (m, 1))])
linsolve(Lhs, rhs)
return rhs[:n]
def linsolve(self, A, b):
"""
Solve linear equation set ``Ax = b`` and store the solutions in ``b``.
Parameters
----------
A
Sparse matrix
b
RHS of the equation
Returns
-------
None
"""
if self.sparselib == 'umfpack':
umfpack.linsolve(A, b)
return b
elif self.sparselib == 'klu':
klu.linsolve(A, b)
return b
elif self.sparselib in ('spsolve', 'cupy'):
ccs = A.CCS
size = A.size
data = np.array(ccs[2]).reshape((-1, ))
indices = np.array(ccs[1]).reshape((-1, ))
indptr = np.array(ccs[0]).reshape((-1, ))
A = csc_matrix((data, indices, indptr), shape=size)
if self.sparselib == 'spsolve':
x = spsolve(A, b)
return matrix(x)
elif self.sparselib == 'cupy':
# delayed import for startup speed
import cupy as cp # NOQA
from cupyx.scipy.sparse import csc_matrix as csc_cu # NOQA
from cupyx.scipy.sparse.linalg.solve import lsqr as cu_lsqr # NOQA
cu_A = csc_cu(A)
cu_b = cp.array(np.array(b).reshape((-1, )))
x = cu_lsqr(cu_A, cu_b)
return matrix(cp.asnumpy(x[0]))
def linsolve(self, A, b):
"""
Solve linear equation set ``Ax = b`` and store the solutions in ``b``.
Parameters
----------
A
Sparse matrix
b
RHS of the equation
Returns
-------
None
"""
if self.sparselib == 'umfpack':
return umfpack.linsolve(A, b)
elif self.sparselib == 'klu':
return klu.linsolve(A, b)
def spike_inference(fluor, sigma=None, gamma=None, mode="correct",
verbose=False):
"""
Infer the most likely discretized spike train underlying a fluorescence
trace.
Parameters
----------
fluor : ndarray
One dimensional array containing the fluorescence intensities with
one entry per time-bin.
sigma : float, optional
Standard deviation of the noise distribution. If no value is given,
then sigma is estimated from the data.
gamma : float, optional
Gamma is 1 - timestep/tau, where tau is the time constant of the AR(1)
process. If no value is given, then gamma is estimated from the data.
mode : {'correct', 'robust'}, optional
The method for estimating sigma. The 'robust' method overestimates the
noise by assuming that gamma = 1. Default: 'correct'.
verbose : bool, optional
Whether to print status updates. Default: False.
Returns
-------
inference : ndarray of float
The inferred normalized spike count at each time-bin. Values are
normalized to the maximium value over all time-bins.
fit : ndarray of float
The inferred denoised fluorescence signal at each time-bin.
parameters : dict
Dictionary with values for 'sigma', 'gamma', and 'baseline'.
References
----------
* Pnevmatikakis et al. 2015. Submitted (arXiv:1409.2903).
* Machado et al. 2015. Submitted.
* Vogelstein et al. 2010. Journal of Neurophysiology. 104(6): 3691-3704.
"""
try:
import cvxopt.umfpack as umfpack
from cvxopt import matrix, spdiag
import picos
except ImportError:
raise ImportError('Spike inference requires picos package.')
if verbose:
sys.stdout.write('Spike inference...')
if sigma is None or gamma is None:
gamma, sigma = estimate_parameters([fluor], gamma, sigma, mode)
# Make spike generating matrix (eye, but with -g on diag below main diag)
gen = spdiag([1 for step in range(fluor.size)])
for step in range(fluor.size):
if step > 0:
gen[step, step - 1] = -gamma
# Use spike generating matrix to initialize other constraint variables
gen_vec = gen * matrix(np.ones(fluor.size))
gen_ones = matrix(np.ones(fluor.size))
umfpack.linsolve(gen, gen_ones)
# Initialize variables in our problem
prob = picos.Problem()
calcium_fit = prob.add_variable('calcium_fit', fluor.size)
init_calcium = prob.add_variable('init_calcium', 1)
baseline = prob.add_variable('baseline', 1)
# Define constraints and objective
prob.add_constraint(init_calcium > 0)
prob.add_constraint(gen * calcium_fit > 0)
res = abs(matrix(fluor.astype(float)) - calcium_fit - baseline - gen_ones *
init_calcium)
prob.add_constraint(res < sigma * np.sqrt(fluor.size))
prob.set_objective('min', calcium_fit.T * gen_vec)
# Run solver
start_time = time.time()
try:
prob.solve(solver='mosek', verbose=False)
except ImportError:
warn('MOSEK is not installed. Spike inference may be VERY slow!')
prob.solver_selection()
prob.solve(verbose=False)
if verbose:
sys.stdout.write("done!\n" +
"Status: " + prob.status +
"; Value: " + str(prob.obj_value()) +
"; Time: " + str(time.time() - start_time) +
"; Baseline = " + str(baseline.value) + "\n")
# Return calcium model fit and spike inference
fit = np.squeeze(np.asarray(calcium_fit.value)[np.arange(0, fluor.size)] +
baseline.value)
inference = np.squeeze(np.asarray(gen * matrix(fit)))
parameters = {'gamma': gamma, 'sigma': sigma,
'baseline': baseline.value[0]}
return inference, fit, parameters
def spike_inference(fluor,
sigma=None,
gamma=None,
mode="correct",
verbose=False):
"""
Infer the most likely discretized spike train underlying a fluorescence
trace.
Parameters
----------
fluor : ndarray
One dimensional array containing the fluorescence intensities with
one entry per time-bin.
sigma : float, optional
Standard deviation of the noise distribution. If no value is given,
then sigma is estimated from the data.
gamma : float, optional
Gamma is 1 - timestep/tau, where tau is the time constant of the AR(1)
process. If no value is given, then gamma is estimated from the data.
mode : {'correct', 'robust'}, optional
The method for estimating sigma. The 'robust' method overestimates the
noise by assuming that gamma = 1. Default: 'correct'.
verbose : bool, optional
Whether to print status updates. Default: False.
Returns
-------
inference : ndarray of float
The inferred normalized spike count at each time-bin. Values are
normalized to the maximium value over all time-bins.
fit : ndarray of float
The inferred denoised fluorescence signal at each time-bin.
parameters : dict
Dictionary with values for 'sigma', 'gamma', and 'baseline'.
References
----------
* Pnevmatikakis et al. 2015. Submitted (arXiv:1409.2903).
* Machado et al. 2015. Submitted.
* Vogelstein et al. 2010. Journal of Neurophysiology. 104(6): 3691-3704.
"""
try:
import cvxopt.umfpack as umfpack
from cvxopt import matrix, spdiag
import picos
except ImportError:
raise ImportError('Spike inference requires picos package.')
if verbose:
sys.stdout.write('Spike inference...')
if sigma is None or gamma is None:
gamma, sigma = estimate_parameters([fluor], gamma, sigma, mode)
# Make spike generating matrix (eye, but with -g on diag below main diag)
gen = spdiag([1 for step in range(fluor.size)])
for step in range(fluor.size):
if step > 0:
gen[step, step - 1] = -gamma
# Use spike generating matrix to initialize other constraint variables
gen_vec = gen * matrix(np.ones(fluor.size))
gen_ones = matrix(np.ones(fluor.size))
umfpack.linsolve(gen, gen_ones)
# Initialize variables in our problem
prob = picos.Problem()
calcium_fit = prob.add_variable('calcium_fit', fluor.size)
init_calcium = prob.add_variable('init_calcium', 1)
baseline = prob.add_variable('baseline', 1)
# Define constraints and objective
prob.add_constraint(init_calcium > 0)
prob.add_constraint(gen * calcium_fit > 0)
res = abs(
matrix(fluor.astype(float)) - calcium_fit - baseline -
gen_ones * init_calcium)
prob.add_constraint(res < sigma * np.sqrt(fluor.size))
prob.set_objective('min', calcium_fit.T * gen_vec)
# Run solver
start_time = time.time()
try:
prob.solve(solver='mosek', verbose=False)
except ImportError:
warn('MOSEK is not installed. Spike inference may be VERY slow!')
prob.solver_selection()
prob.solve(verbose=False)
if verbose:
sys.stdout.write("done!\n" + "Status: " + prob.status + "; Value: " +
str(prob.obj_value()) + "; Time: " +
str(time.time() - start_time) + "; Baseline = " +
str(baseline.value) + "\n")
# Return calcium model fit and spike inference
fit = np.squeeze(
np.asarray(calcium_fit.value)[np.arange(0, fluor.size)] +
baseline.value)
inference = np.squeeze(np.asarray(gen * matrix(fit)))
parameters = {
'gamma': gamma,
'sigma': sigma,
'baseline': baseline.value[0]
}
return inference, fit, parameters
# 计算雅可比矩阵
if system.Settings.method == 1: # 采用欧拉法
system.DAE.Ac = sparse([[identica - h * system.DAE.Fx, system.DAE.Gx], [-h * system.DAE.Fy, system.DAE.Gy]])
system.DAE.tn = system.DAE.x - xa - h * system.DAE.f
elif system.Settings.method == 2: # 采用隐式梯形法
system.DAE.Ac = sparse(
[[identica - h * 0.5 * system.DAE.Fx, system.DAE.Gx], [-h * 0.5 * system.DAE.Fy, system.DAE.Gy]])
system.DAE.tn = system.DAE.x - xa - h * 0.5 * (system.DAE.f + fn)
# 限幅器
system.Avr2.windup('td')
gg = -matrix([system.DAE.tn, system.DAE.g])
linsolve(system.DAE.Ac, gg)
inc = gg
# if system.DAE.factorize:
# F = symbolic(system.DAE.Ac)
# system.DAE.factorize = False
# inc = -matrix([system.DAE.tn, system.DAE.g])
# try:
# umfsolve(system.DAE.Ac, numeric(system.DAE.Ac, F), inc)
# except ArithmeticError:
# print('Singular matrix')
# iteration = iter_max+1
# except ValueError:
# F = symbolic(system.DAE.Ac)
# try:
# umfsolve(system.DAE.Ac, numeric(system.DAE.Ac, F), inc)
def sssa(datafile):
start = clock()
system.Bus._init_data()
system.PV._init_data()
system.PQ._init_data()
system.SW._init_data()
system.Shunt._init_data()
system.Line._init_data()
system.Syn6._init_data()
system.Avr1._init_data()
system.Avr2._init_data()
system.Tg1._init_data()
system.Ind3._init_data()
# system.Pss1._init_data()
case = open(datafile)
for each_line in case:
data = each_line.split()
if data[0] == 'Bus':
bus = data[0] + '_' + str(data[1])
Vb = float(data[2])
bus_case = {'bus': bus, 'Vb': Vb}
system.Bus.add(idx=bus, **bus_case)
if data[0] == 'PV':
bus = 'Bus_' + str(data[1])
Sn = float(data[2])
Vn = float(data[3])
Pg = float(data[4])
V0 = float(data[5])
qgmax = float(data[6])
qgmin = float(data[7])
Vmax = float(data[8])
Vmin = float(data[9])
PV_case = {
'bus': bus,
'Sn': Sn,
'Vn': Vn,
'Pg': Pg,
'V0': V0,
'qgmax': qgmax,
'qgmin': qgmin,
'Vmax': Vmax,
'Vmin': Vmin
}
system.PV.add(**PV_case)
if data[0] == 'PQ':
bus = 'Bus_' + str(data[1])
Sn = float(data[2])
Vn = float(data[3])
Pl = float(data[4])
Ql = float(data[5])
Vmax = float(data[6])
Vmin = float(data[7])
z = float(data[8])
PQ_case = {
'bus': bus,
'Sn': Sn,
'Vn': Vn,
'Pl': Pl,
'Ql': Ql,
'Vmax': Vmax,
'Vmin': Vmin,
'z': z
}
system.PQ.add(**PQ_case)
if data[0] == 'SW':
bus = 'Bus_' + str(data[1])
Sn = float(data[2])
Vn = float(data[3])
V0 = float(data[4])
Va = float(data[5])
qgmax = float(data[6])
qgmin = float(data[7])
Vmax = float(data[8])
Vmin = float(data[9])
SW_case = {
'bus': bus,
'Sn': Sn,
'Vn': Vn,
'V0': V0,
'Va': Va,
'qgmax': qgmax,
'qgmin': qgmin,
'Vmax': Vmax,
'Vmin': Vmin
}
system.SW.add(**SW_case)
if data[0] == 'Shunt':
bus = 'Bus_' + str(data[1])
Sn = float(data[2])
Vn = float(data[3])
fn = float(data[4])
g = float(data[5])
b = float(data[6])
Shunt_case = {
'bus': bus,
'Sn': Sn,
'Vn': Vn,
'fn': fn,
'g': g,
'b': b
}
system.Shunt.add(**Shunt_case)
if data[0] == 'Line':
f_bus = 'Bus_' + str(data[1])
to_bus = 'Bus_' + str(data[2])
Sn = float(data[3])
Vn = float(data[4])
fn = float(data[5])
l = float(data[6])
kT = float(data[7])
r = float(data[8])
x = float(data[9])
b = float(data[10])
tap_ratio = float(data[11])
theta = float(data[12])
Imax = float(data[13])
Pmax = float(data[14])
Smax = float(data[15])
Line_case = {
'f_bus': f_bus,
'to_bus': to_bus,
'Sn': Sn,
'Vn': Vn,
'fn': fn,
'l': l,
'kT': kT,
'r': r,
'x': x,
'b': b,
'tap_ratio': tap_ratio,
'theta': theta,
'Imax': Imax,
'Pmax': Pmax,
'Smax': Smax
}
system.Line.add(**Line_case)
if data[0] == 'Syn6':
bus = 'Bus_' + str(data[1])
Sn = float(data[2])
Vn = float(data[3])
fn = float(data[4])
m_model = float(data[5])
xl = float(data[6])
ra = float(data[7])
xd = float(data[8])
xd1 = float(data[9])
xd2 = float(data[10])
Td01 = float(data[11])
Td02 = float(data[12])
xq = float(data[13])
xq1 = float(data[14])
xq2 = float(data[15])
Tq01 = float(data[16])
Tq02 = float(data[17])
M = float(data[18]) # M = 2H
D = float(data[19])
Syn6_case = {
'bus': bus,
'Sn': Sn,
'Vn': Vn,
'fn': fn,
'm_model': m_model,
'xl': xl,
'ra': ra,
'xd': xd,
'xd1': xd1,
'xd2': xd2,
'Td01': Td01,
'Td02': Td02,
'xq': xq,
'xq1': xq1,
'xq2': xq2,
'Tq01': Tq01,
'Tq02': Tq02,
'M': M,
'D': D
}
system.Syn6.add(**Syn6_case)
if data[0] == 'Avr2':
bus = 'Bus_' + str(data[1])
Type = float(data[2])
vrmax = float(data[3])
vrmin = float(data[4])
Ka = float(data[5])
Ta = float(data[6])
Kf = float(data[7])
Tf = float(data[8])
Ke = float(data[9])
Te = float(data[10])
Tr = float(data[11])
Ae = float(data[12])
Be = float(data[13])
Avr2_case = {
'bus': bus,
'Type': Type,
'vrmax': vrmax,
'vrmin': vrmin,
'Ka': Ka,
'Ta': Ta,
'Kf': Kf,
'Tf': Tf,
'Ke': Ke,
'Te': Te,
'Tr': Tr,
'Ae': Ae,
'Be': Be
}
system.Avr2.add(**Avr2_case)
if data[0] == 'Avr1':
bus = 'Bus_' + str(data[1])
Type = float(data[2])
vrmax = float(data[3])
vrmin = float(data[4])
K0 = float(data[5])
T1 = float(data[6])
T2 = float(data[7])
T3 = float(data[8])
T4 = float(data[9])
Te = float(data[10])
Tr = float(data[11])
Ae = float(data[12])
Be = float(data[13])
Avr1_case = {
'bus': bus,
'Type': Type,
'vrmax': vrmax,
'vrmin': vrmin,
'K0': K0,
'T1': T1,
'T2': T2,
'T3': T3,
'T4': T4,
'Te': Te,
'Tr': Tr,
'Ae': Ae,
'Be': Be
}
system.Avr1.add(**Avr1_case)
if data[0] == 'Tg1':
bus = 'Bus_' + str(data[1])
Type = float(data[2])
wref0 = float(data[3])
R = float(data[4])
Pmax = float(data[5])
Pmin = float(data[6])
Ts = float(data[7])
Tc = float(data[8])
T3 = float(data[9])
T4 = float(data[10])
T5 = float(data[11])
Tg1_case = {
'bus': bus,
'Type': Type,
'wref0': wref0,
'R': R,
'Pmax': Pmax,
'Pmin': Pmin,
'Ts': Ts,
'Tc': Tc,
'T3': T3,
'T4': T4,
'T5': T5
}
system.Tg1.add(**Tg1_case)
if data[0] == 'Ind3':
bus = 'Bus_' + str(data[1])
Sn = float(data[2])
Vn = float(data[3])
fn = float(data[4])
type = float(data[5])
rs = float(data[7])
xs = float(data[8])
rr1 = float(data[9])
xr1 = float(data[10])
rr2 = float(data[11])
xr2 = float(data[12])
xm = float(data[13])
Hm = float(data[14])
a1 = float(data[15])
b = float(data[16])
c = float(data[17])
tup = float(data[18])
sup = float(data[6])
allow = float(data[19])
Ind3_case = {
'bus': bus,
'Sn': Sn,
'Vn': Vn,
'fn': fn,
'type': type,
'sup': sup,
'xs': xs,
'rs': rs,
'rr1': rr1,
'xr1': xr1,
'rr2': rr2,
'xr2': xr2,
'xm': xm,
'Hm': Hm,
'a1': a1,
'b': b,
'c': c,
'allow': allow
}
system.Ind3.add(**Ind3_case)
case.close()
# Bus
system.Bus._xy_index()
system.Bus._bus_index()
system.Bus._list2matrix()
system.Bus.yinit(system.DAE)
# PV
system.PV._bus_index()
system.PV._list2matrix()
system.PV.base(Vb=system.Bus.Vb[system.PV.a])
system.PV.yinit(system.DAE)
system.PV._matrix2list()
# PQ
system.PQ._bus_index()
system.PQ._list2matrix()
system.PQ.base(Vb=system.Bus.Vb[system.PQ.a])
system.PQ.yinit(system.DAE)
system.PQ._matrix2list()
# SW
system.SW._bus_index()
system.SW.yinit(system.DAE)
# Shunt
system.Shunt._bus_index()
system.Shunt._list2matrix()
system.Shunt.base(Vb=system.Bus.Vb[system.Shunt.a])
system.Shunt._matrix2list()
# Line
system.Line._bus_index()
system.Line.build_y()
# 测试Ind3
system.Ind3._bus_index()
system.Ind3._list2matrix()
system.Ind3.base(Sb=system.Settings.mva, Vb=system.Bus.Vb[system.Ind3.a])
system.Ind3.setdata()
# print(system.Ind3.__dict__)
system.Ind3._dxy_index()
# system.Ind3._matrix2list()
# print(system.Ind3.__dict__)
# system.DAE.Y = sparse(system.DAE.Y)
# print(system.DAE.Y)
# system.Line.gcall()
# system.PQ.gcall()
# system.Shunt.gcall()
# system.PV.gcall()
# system.SW.gcall()
# print(system.DAE.g)
# print(system.DAE.y)
def calcInc():
global F
system.Line.gcall()
system.PQ.gcall()
system.Shunt.gcall()
system.PV.gcall()
system.SW.gcall()
system.Ind3.gcall()
system.Line.Gycall()
system.Shunt.Gycall()
system.PV.Gycall()
system.SW.Gycall()
system.Ind3.Gycall()
system.Ind3.fcall()
system.DAE.Fx = matrix(0.0, (system.DAE.nx, system.DAE.nx))
system.DAE.Fy = matrix(0.0, (system.DAE.nx, system.DAE.ny))
system.DAE.Gx = matrix(0.0, (system.DAE.ny, system.DAE.nx))
system.Ind3.Fxcall()
system.PV.Fxcall()
system.SW.Fxcall()
system.DAE.Gy = sparse(system.DAE.Gy)
system.DAE.Fx = sparse(system.DAE.Fx)
system.DAE.Fy = sparse(system.DAE.Fy)
system.DAE.Gx = sparse(system.DAE.Gx)
A = sparse([[system.DAE.Fx, system.DAE.Gx],
[system.DAE.Fy, system.DAE.Gy]])
inc = matrix([system.DAE.f, system.DAE.g])
if system.DAE.factorize:
F = symbolic(
A
) # 重新排列A矩阵以减少填充并执行LU分解，返回为可以传递的不透明 C object到umfpack.numeric（）。
system.DAE.factorize = False
try:
N = numeric(A, F)
solve(A, N, inc)
except:
print('unexpect')
F = symbolic(A)
solve(A, numeric(A, F), inc)
return inc
if system.DAE.nx != 0:
system.DAE.f = matrix(1.0, (system.DAE.nx, 1))
system.DAE.x = matrix(1.0, (system.DAE.nx, 1))
system.DAE.Fx = matrix(0.0, (system.DAE.nx, system.DAE.nx))
system.DAE.Fy = matrix(0.0, (system.DAE.nx, system.DAE.ny))
system.DAE.Gx = matrix(0.0, (system.DAE.ny, system.DAE.nx))
system.DAE.Gy = matrix(0.0, (system.DAE.ny, system.DAE.ny))
system.Ind3.xinit()
system.DAE.g = np.array(system.DAE.g)
iteration = 1
iter_max = system.Settings.iter
convergence = True # 收敛
tol = system.Settings.error
cycle = True
err = []
# main loop
while cycle or (max(abs(system.DAE.g)) > tol and iteration <= iter_max):
inc = calcInc()
cycle = False
for i in range(system.DAE.nx):
system.DAE.x[i] = system.DAE.x[i] - inc[i]
for i in range(system.DAE.ny):
system.DAE.y[i] = system.DAE.y[i] - inc[i + system.DAE.nx]
err.append(max(abs(system.DAE.g)))
print('第%i次迭代最大误差为：<%f>' % (iteration, err[iteration - 1]))
iteration += 1
system.DAE.g = np.array(system.DAE.g)
# stop if the error increases too much
if iteration > iter_max:
print('Reached maximum number of iterations')
convergence = False
# 结束时间
finish = clock()
t = finish - start
print('潮流计算运行时间：%f' % t)
for i in range(system.DAE.ny):
system.DAE.y[i] = round(system.DAE.y[i], 5)
# 计算Pl和Ql
system.DAE.g = matrix(0.0, (system.DAE.ny, 1))
# print(system.DAE.g)
system.PQ.gcall()
system.Shunt.gcall()
system.DAE._list2matrix()
system.Bus.Pl = system.DAE.g[system.Bus.a]
# print(system.Bus.Pl)
system.Bus.Ql = system.DAE.g[system.Bus.v]
# print(system.Bus.Ql)
# 计算Pg 和 Qg
system.Line.gcall()
system.PQ.gcall()
system.Shunt.gcall()
system.DAE._list2matrix()
system.Bus.Pg = system.DAE.g[system.Bus.a]
system.Bus.Qg = system.DAE.g[system.Bus.v]
# print('Bus.Pg、Qg')
# print(system.Bus.Pg)
# print(system.Bus.Qg)
nx_old = system.DAE.nx
# 测试Syn6
system.Syn6._bus_index()
system.Syn6._dxy_index()
# 测试Avr
system.Avr1._bus_index()
system.Avr2._bus_index()
system.Avr1.getbus()
system.Avr2.getbus()
system.Avr2._dxy_index()
system.Avr1._dxy_index()
# 测试Tg1
system.Tg1._bus_index()
system.Tg1._dxy_index()
system.Tg1.getbus()
# 重新生成对应维度的x, y, g, f
newx = [0] * (system.DAE.nx - nx_old)
system.DAE.x = list(system.DAE.x)
system.DAE.f = list(system.DAE.f)
system.DAE.x.extend(newx)
system.DAE.f.extend(newx)
system.DAE.y = list(system.DAE.y)
system.DAE.g = list(system.DAE.g)
# 重新生成雅可比矩阵
system.DAE.Gy = matrix(0.0, (system.DAE.ny, system.DAE.ny))
system.DAE.Fx = matrix(0.0, (system.DAE.nx, system.DAE.nx))
system.DAE.Fy = matrix(0.0, (system.DAE.nx, system.DAE.ny))
system.DAE.Gx = matrix(0.0, (system.DAE.ny, system.DAE.nx))
newy = [0] * (system.DAE.ny - system.Bus.n * 2)
system.DAE.y.extend(newy)
system.DAE.g.extend(newy)
system.DAE.y = matrix(system.DAE.y)
# 测试Syn6 setx0
system.Syn6._list2matrix()
system.Syn6.base(Vb=system.Bus.Vb[system.Syn6.a])
system.Syn6.setx0()
# print('Syn6 setx0')
# print(system.DAE.x)
# 测试Avr setx0
system.Avr1._list2matrix()
system.Avr2._list2matrix()
# system.Avr1.base(Vb=system.Bus.Vb[system.Avr1.a])
# system.Avr2.base(Vb=system.Bus.Vb[system.Avr2.a])
system.Avr1.setx0()
system.Avr2.setx0()
# print('Avr setx0')
# print(system.DAE.y)
# 测试Tg1
system.Tg1._list2matrix()
system.DAE._list2matrix()
system.Tg1.base()
system.Tg1.setx0()
# system.Tg1._matrix2list()
# system.Tg1.pmech = matrix(system.Tg1.pmech)
# print(system.Tg1.pmech)
# print(system.Tg1.__dict__)
# print(system.DAE.f)
# print(system.DAE.x)
# print(system.DAE.y)
# 重新生成微分代数方程和雅可比矩阵
system.DAE.g = matrix(0.0, (system.DAE.ny, 1))
# call
system.DAE._list2matrix()
system.Line.gcall()
system.PQ.gcall()
system.Shunt.gcall()
system.Syn6.gcall()
system.Avr1.gcall()
system.Avr2.gcall()
system.Tg1.gcall()
system.Ind3.gcall()
system.PV.gcall()
system.SW.gcall()
system.Line.Gycall()
system.PQ.Gycall()
system.Shunt.Gycall()
system.Syn6.Gycall()
system.Avr1.Gycall()
system.Avr2.Gycall()
system.Tg1.Gycall()
system.Ind3.Gycall()
system.PV.Gycall()
system.SW.Gycall()
system.Syn6.fcall()
system.Avr1.fcall()
system.Avr2.fcall()
system.Tg1.fcall()
system.Ind3.fcall()
# print(system.DAE.f)
system.Syn6.Fxcall()
system.Avr1.Fxcall()
system.Avr2.Fxcall()
system.Tg1.Fxcall()
system.Ind3.Fxcall()
system.DAE.Gy = sparse(system.DAE.Gy)
system.DAE.Fx = sparse(system.DAE.Fx)
system.DAE.Fy = sparse(system.DAE.Fy)
system.DAE.Gx = sparse(system.DAE.Gx)
# print(system.DAE.Fx.V)
# print(system.DAE.Fx.V)
# 生成状态矩阵
def state_matrix():
Gyx = matrix(system.DAE.Gx)
linsolve(sparse(system.DAE.Gy), Gyx)
I = []
J = []
for i in range(system.DAE.nx):
I.append(i)
J.append(i)
return system.DAE.Fx - system.DAE.Fy * Gyx - spmatrix(1e-6, I, J)
Gyx = matrix(system.DAE.Gx)
linsolve(sparse(system.DAE.Gy), Gyx)
# state_matrix()
As = state_matrix()
# print(As)
# As = sparse(As)
# 计算特征值
# cvxopt
def eigs():
As = state_matrix()
return eigvals(As)
eigen = eigs()
# print(matrix(eigs()))
# numpy
# w = np.linalg.eigvals(As)
# w = matrix(w)
# print(np.linalg.eigvals(As))
# scipy
w, v = linalg.eig(As)
# w = matrix(w)
# a = w[0]
# print(matrix(w))
# print(a)
for i in range(system.DAE.nx):
w[i] = round(w[i], 5)
print(w[i])
# 计算参与因子
# set_printoptions(threshold = 'nan')
def compute_eig(As):
mu, N = eig(matrix(As))
N = matrix(N)
n = len(mu)
idx = range(n)
W = matrix(spmatrix(1.0, idx, idx, (n, n), N.typecode))
gesv(N, W)
pf = mul(abs(W.T), abs(N))
b = matrix(1.0, (1, n))
WN = b * pf
pf = pf.T
for item in idx:
mur = mu[item].real
mui = mu[item].imag
mu[item] = complex(round(mur, 5), round(mui, 5))
pf[item, :] /= WN[item]
return pf
# print(pf)
return As, Gyx
pf = compute_eig(As)
# print(pf)
w = w.T
sio.savemat('eig.mat', {'eig': w, 'pf': pf})
f = open('indpf.txt', 'w+')
for i in range(system.DAE.nx):
pfrow = []
for j in range(system.DAE.nx):
p = str(round(pf[i, j], 12))
# pfrow.append(round(pf[i, j], 12))
f.write(p + ' ')
f.write('\n')
# f.writelines(pfrow)
# print(pfrow)
f.close()
def spike_inference(fluor, sigma=None, gamma=None, mode="correct",
ar_order=2, psd_opts=None, verbose=False):
"""
Infer the most likely discretized spike train underlying a fluorescence
trace.
Parameters
----------
fluor : ndarray
One dimensional array containing the fluorescence intensities with
one entry per time-bin.
sigma : float, optional
Standard deviation of the noise distribution. If no value is given,
then sigma is estimated from the data.
gamma : float, optional
Gamma is 1 - timestep/tau, where tau is the time constant of the AR(1)
process. If no value is given, then gamma is estimated from the data.
mode : {'correct', 'robust', 'psd'}, optional
The method for estimating sigma. The 'robust' method overestimates
the noise by assuming that gamma = 1. The 'psd' method estimates
sigma from the PSD of the fluorescence data. Default: 'correct'.
ar_order : int, optional
Autoregressive model order. Only implemented for 'psd' method.
Default: 2
psd_opts : dictionary
Dictionary of options for the psd method; if None, default options
will be used. Default: None
verbose : bool, optional
Whether to print status updates. Default: False.
Returns
-------
inference : ndarray of float
The inferred normalized spike count at each time-bin. Values are
normalized to the maximium value over all time-bins.
fit : ndarray of float
The inferred denoised fluorescence signal at each time-bin.
parameters : dict
Dictionary with values for 'sigma', 'gamma', and 'baseline'.
References
----------
* Pnevmatikakis et al. 2015. Submitted (arXiv:1409.2903).
* Machado et al. 2015. Submitted.
* Vogelstein et al. 2010. Journal of Neurophysiology. 104(6): 3691-3704.
"""
try:
import cvxopt.umfpack as umfpack
from cvxopt import matrix, spdiag, spmatrix, solvers
import picos
except ImportError:
raise ImportError('Spike inference requires picos package.')
if verbose:
sys.stdout.write('Spike inference...')
if psd_opts is None:
opts = default_psd_opts()
else:
opts = psd_opts
if sigma is None or gamma is None:
gamma, sigma = estimate_parameters(
[fluor], gamma, sigma, mode, ar_order, psd_opts)
# Initialize variables in our problem
prob = picos.Problem()
if mode == "psd":
T = len(fluor)
# construct deconvolution matrix (sp = gen*c)
gen = spmatrix(1., range(T), range(T), (T, T))
for i in range(ar_order):
gen = gen + spmatrix(
float(-gamma[i]), range(i+1, T), range(T-i-1), (T, T))
gr = np.roots(np.concatenate([np.array([1]), -gamma.flatten()]))
# decay vector for initial fluorescence
gd_vec = np.max(gr)**np.arange(T)
gen_vec = gen * matrix(np.ones(fluor.size))
# Define variables
calcium_fit = prob.add_variable('calcium_fit', fluor.size)
baseline = prob.add_variable('baseline', 1)
if opts['bas_nonneg']:
b_lb = 0
else:
b_lb = np.min(fluor)
prob.add_constraint(baseline >= b_lb)
init_calcium = prob.add_variable('init_calcium', 1)
prob.add_constraint(init_calcium >= 0)
# Add constraints
prob.add_constraint(gen * calcium_fit >= 0)
res = abs(matrix(fluor.astype(float)) - calcium_fit -
baseline*matrix(np.ones(fluor.size)) -
matrix(gd_vec) * init_calcium)
else:
# Make spike generating matrix
# (eye, but with -g on diag below main diag)
gen = spdiag([1 for step in range(fluor.size)])
for step in range(fluor.size):
if step > 0:
gen[step, step - 1] = -gamma
# Use spike generating matrix to initialize other constraint variables
gen_vec = gen * matrix(np.ones(fluor.size))
gen_ones = matrix(np.ones(fluor.size))
umfpack.linsolve(gen, gen_ones)
# Initialize variables in our problem
calcium_fit = prob.add_variable('calcium_fit', fluor.size)
init_calcium = prob.add_variable('init_calcium', 1)
baseline = prob.add_variable('baseline', 1)
# Define constraints and objective
prob.add_constraint(init_calcium > 0)
prob.add_constraint(gen * calcium_fit > 0)
res = abs(matrix(fluor.astype(float)) - calcium_fit -
baseline -
gen_ones * init_calcium)
prob.add_constraint(res < sigma * np.sqrt(fluor.size))
prob.set_objective('min', calcium_fit.T * gen_vec)
# Run solver
start_time = time.time()
try:
prob.solve(solver='mosek', verbose=False)
except ImportError:
warn('MOSEK is not installed. Spike inference may be VERY slow!')
prob.solver_selection()
prob.solve(verbose=False)
if verbose:
sys.stdout.write("done!\n" +
"Status: " + prob.status +
"; Value: " + str(prob.obj_value()) +
"; Time: " + str(time.time() - start_time) +
"; Baseline = " + str(baseline.value) + "\n")
# if problem in infeasible due to low noise value then project onto the
# cone of linear constraints with cvxopt
if mode == "psd" and prob.status in [
'prim_infeas_cer', 'dual_infeas_cer', 'primal infeasible']:
warn("Original problem infeasible. "
"Adjusting noise level and re-solving")
# setup quadratic problem with cvxopt
solvers.options['show_progress'] = verbose
ind_rows = range(T)
ind_cols = range(T)
vals = np.ones(T)
cnt = 2 # no of constraints (init_calcium and baseline)
ind_rows += range(T)
ind_cols += [T]*T
vals = np.concatenate((vals, np.ones(T)))
ind_rows += range(T)
ind_cols += [T+cnt-1]*T
vals = np.concatenate((vals, np.squeeze(gd_vec)))
P = spmatrix(vals, ind_rows, ind_cols, (T, T+cnt))
H = P.T*P
Py = P.T*matrix(fluor.astype(float))
sol = solvers.qp(
H, -Py, spdiag([-gen, -spmatrix(1., range(cnt), range(cnt))]),
matrix(0., (T+cnt, 1)))
xx = sol['x']
fit = np.array(xx[:T])
inference = np.array(gen*matrix(fit))
fit = np.squeeze(fit)
baseline = np.array(xx[T+1]) + b_lb
init_calcium = np.array(xx[-1])
sigma = np.linalg.norm(
fluor-fit-init_calcium*gd_vec-baseline)/np.sqrt(T)
parameters = {'gamma': gamma, 'sigma': sigma,
'baseline': baseline}
else:
# Return calcium model fit and spike inference
fit = np.squeeze(
np.asarray(calcium_fit.value)[np.arange(0, fluor.size)] +
baseline.value)
inference = np.squeeze(np.asarray(gen * matrix(fit)))
parameters = {'gamma': gamma, 'sigma': sigma,
'baseline': baseline.value[0]}
return inference, fit, parameters
def state_matrix():
Gyx = matrix(system.DAE.Gx)
linsolve(system.DAE.Gy, Gyx)
return system.DAE.Fx - system.DAE.Fy * Gyx
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('双馈风力发电机初始化完成')
K.V = Kn.V
return K
A = spmatrix([10, 3, 5, -2, 5, 2], [0, 2, 1, 2, 2, 3], [0, 0, 1, 1, 2, 3])
P = amd.order(A)
print(P)
V = [2, 3, 3, -1, 4, 4, -3, 1, 2, 2, 6, 1]
I = [0, 1, 0, 2, 4, 1, 2, 3, 4, 2, 1, 4]
J = [0, 0, 1, 1, 1, 2, 2, 2, 2, 3, 4, 4]
A = spmatrix(V, I, J)
B = matrix(1.0, (5, 1))
umfpack.linsolve(A, B)
print(B)
VA = [2, 3, 3, -1, 4, 4, -3, 1, 2, 2, 6, 1]
VB = [4, 3, 3, -1, 4, 4, -3, 1, 2, 2, 6, 2]
I = [0, 1, 0, 2, 4, 1, 2, 3, 4, 2, 1, 4]
J = [0, 0, 1, 1, 1, 2, 2, 2, 2, 3, 4, 4]
A = spmatrix(VA, I, J)
B = spmatrix(VB, I, J)
x = matrix(1.0, (5, 1))
Fs = umfpack.symbolic(A)
FA = umfpack.numeric(A, Fs)
FB = umfpack.numeric(B, Fs)
umfpack.solve(A, FA, x)
umfpack.solve(B, FB, x)
umfpack.solve(A, FA, x, trans='T')
