Учебники / 0841558_16EA1_federico_milano_power_system_modelling_and_scripting

Fig. C.4 Transient response of windup and anti-windup limiters

straightforward.1 The issue consists in that the output w of lead-lags or PI controllers is an explicit function of the input y, whose first time derivative, in some cases, cannot be determined. Figure C.5 shows some common solutions for implementing an anti-windup limiter of a PI controller. Figure C.5.e is the most precise model, which is also the most complex.

Script C.1 Implementation of Windup and Anti-Windup

Limiters

The object of the scripts below is to define a vector, say self.z, whose elements are 1 if the associated state variable is not saturated and belongs to an on-line element; and 0 otherwise. Thus, self.z is a copy of the status array self.u if no state variable is saturated.

The following code implements the windup limiter. The input arguments are the DAE system (dae) and the names of the state variable (x), of the maximum and minimum value (xmax and xmin, respectively) and of the saturation status (z).

1 Di culties arises whenever the transfer function has the same number of poles and zeros.

Fig. C.5 PI controller: (a) basic PI scheme without hard limits, (b) windup limiter,

(c) limited integrator, (d) tracking anti-windup, and (e) integrator clamping

def windup(self, dae, x, xmax, xmin, z):

sumz = sum(self. dict [z]) self. dict [z] = matrix(self.u) zmax = matrix(self.u)

zmin = matrix(self.u)

for idx, item in enumerate(self. dict [x]): if dae.x[item] >= self. dict [xmax][idx]:

dae.f[item] = 0

dae.x[item] = self. dict [xmax][idx]

dae.x[item] = self. dict [xmin][idx] self. dict [z][idx] = 0

zmin[idx] = 0

if sumz != sum(zmax) or sumz != sum(zmin): dae.factorize = True

A similar method can be used for limiting algebraic variables. The last line of the previous code is needed to impose a re-factorization of the system Jacobian matrix. If a state variable reaches a limit, its value is constant. Thus, if a variable has a position k in the system Jacobian matrix AC , then one has to set to zero the entire kth row and kth column. Only the diagonal element (k, k) of the matrix AC has to be non-zero to avoid singularity. Since AC = [[f x, f y ]; [gx, gy ]], the saturation of the state variable with index k corresponds to set to zero the k-th row of f x and f y and the k-th column of f x and gx and to assign a non-zero value to the element (k, k) of f x. The following code is an e cient way to do that (it is assumed that the function is a method of the class system.DAE).

def set Ac(self, idx):

H = spmatrix(1.0, idx, idx, (self.ny, self.ny))

I = spdiag([1.0]*self.ny) - H

self.Gy = I * (self.Gy * I) + H self.Fy = self.Fy * I

self.Gx = I * self.Gx

The following code does the same as the previous one, but it is less e cient (about 5 times slower):

def set Ac(self, idx):

self.Gy[idx, :] = 0 self.Gy[:, idx] = 0

self.Gy += spmatrix(1.0, idx, idx, (self.ny, self.ny), ’d’) self.Fy[:, idx] = 0.0

self.Gx[idx, :] = 0.0

# needed to maintain the minimum sparsity level self.Gy = sparse(self.Gy)

self.Fy = sparse(self.Fy) self.Gx = sparse(self.Gx)

The di erence in the e ciency of the previous functions is typical of scripting languages. In fact, matrix initialization, indexing and operations are obtained through interfaces to external libraries. Since the bottleneck are the calls to the external library, the less the number of calls, the faster the resulting code.

The following method implements an anti-windup limiter. The main difference with the previous method is the check on the sign of the di erential equation, i.e., the state variable time derivative.

def anti windup(self, dae, x, xmax, xmin, z):

sumz = sum(self. dict [z]) self. dict [z] = matrix(self.u) zmax = matrix(self.u)

zmin = matrix(self.u)

for idx, item in enumerate(self. dict [x]):

if dae.x[item] >= self. dict [xmax][idx] and \ dae.f[item] > 0:

dae.f[item] = 0

self. dict [z][idx] = 0 zmax[idx] = 0

dae.x[item] = self. dict [xmax][idx]

elif dae.x[item] <= self. dict [xmin][idx] and \ dae.f[item] < 0:

dae.f[item] = 0

self. dict [z][idx] = 0 zmin[idx] = 0

dae.x[item] = self. dict [xmin][idx] if sumz != sum(zmax) or sumz != sum(zmin):

dae.factorize = True

Table D.2 Static generator data

D.4 Dynamic Data

Tables D.5 and D.6 show the synchronous machine and automatic voltage regulator data used throughout this book, unless otherwise indicated. Dynamic shaft data used in Example 15.5 are shown in Table D.7. Turbine governor data used in Example 16.1 are depicted in Table D.8. Power System stabilizer data used in Example 16.3 are shown in Table D.9.

D.5 FACTS Data

SVC Type I and Type II data used in Example 19.1 are depicted in Tables D.10 and D.11.

The data of the detailed STATCOM device used in Example 19.2 are as follows.

Dc nodes: The dc networks is composed of two dc nodes with Vdc,n = 10 kV. One of the node is the ground (v = 0).

Parallel RC: G = 0.0017 S, C = 0.0432 F.

VSC device: rT = 0.02 pu, xT = 0.1 pu, imax = 1.2 pu.

STATCOM regulators: vdcref = 1.06 pu, vacref = 1.0563 pu, T1 = T2 = Tac =

Tdc = 0.01 s, K = 100 pu/pu, KD = 0, KI = 5 rad/pu/s, KP = 10 rad/pu, Kac = Kdc = 1 pu/pu, mmax = 3, mmin = 0.5, αmax = π rad, αmin = −π rad.

D.6 Wind Turbine Data

Wind turbine data used in Example 20.4 of Chapter 20 are given below.

Mechanical data: ngen = 40, npole = 4, nblade = 3, ηGB = 1/89, Ht = 1.5 MWs/MVA, Hm = 0.5 MWs/MVA, Ks = 1 pu, ρ = 1.225 kg/m3, R = 35 m, Tp = 3 s, and Kp = 10 rad/pu.

528 D IEEE 14-Bus System Data

Non-controlled speed wind turbine data: rr = 0.01 pu, rs = 0.01 pu, xμ = 3.0 pu, xr = 0.08 pu, and xs = 0.1 pu.

Doubly-fed asynchronous generator data: KV = 10 pu/pu/s, T = 0.01 s, rr = 0.01 pu, rs = 0.01 pu, xμ = 3.0 pu, xr = 0.08 pu, and xs = 0.1 pu.

Direct-drive synchronous machine data: Kdc = Kds = 1.0 pu/pu, Kqc = 200 pu/pu, Tdc = Tds = Tqc = Tqs = 0.01 s, ψp = 1.2 pu, rs = 0.01, pu, xd = 1.0, and xq = 0.8 pu.