DPsim
Loading...
Searching...
No Matches
DP_Ph3_SynchronGeneratorVBR_Deprecated.cpp
Go to the documentation of this file.
1/* Copyright 2017-2021 Institute for Automation of Complex Power Systems,
2 * EONERC, RWTH Aachen University
3 *
4 * This Source Code Form is subject to the terms of the Mozilla Public
5 * License, v. 2.0. If a copy of the MPL was not distributed with this
6 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 *********************************************************************************/
8
9#include <dpsim-models/DP/DP_Ph3_SynchronGeneratorVBR.h>
10
11using namespace CPS;
12
13DP::Ph3::SynchronGeneratorVBR::SynchronGeneratorVBR(
14 String name, Real nomPower, Real nomVolt, Real nomFreq, Int poleNumber,
15 Real nomFieldCur, Real Rs, Real Ll, Real Lmd, Real Lmd0, Real Lmq,
16 Real Lmq0, Real Rfd, Real Llfd, Real Rkd, Real Llkd, Real Rkq1, Real Llkq1,
17 Real Rkq2, Real Llkq2, Real inertia, Logger::Level logLevel)
19 : SynchronGeneratorBase(name, nomPower, nomVolt, nomFreq, poleNumber,
20 nomFieldCur, Rs, Ll, Lmd, Lmd0, Lmq, Lmq0, Rfd,
21 Llfd, Rkd, Llkd, Rkq1, Llkq1, Rkq2, Llkq2, inertia,
22 logLevel) {
24 mRs = Attribute<Real>::create("Rs", mAttributes, 0);
25 mLl = Attribute<Real>::create("Ll", mAttributes, 0);
26 mOmMech = Attribute<Real>::create("w_r", mAttributes, 0);
27 mElecTorque = Attribute<Real>::create("T_e", mAttributes, 0);
28 mMechTorque = Attribute<Real>::create("T_m", mAttributes, 0);
29}
30
31void DP::Ph3::SynchronGeneratorVBR::addExciter(Real Ta, Real Ka, Real Te,
32 Real Ke, Real Tf, Real Kf,
33 Real Tr, Real Lad, Real Rfd) {
34 mExciter = Exciter(Ta, Ka, Te, Ke, Tf, Kf, Tr, Lad, Rfd);
35 mExciter.initialize(1, 1);
36
37 mHasExciter = true;
38}
39
40void DP::Ph3::SynchronGeneratorVBR::addGovernor(Real Ta, Real Tb, Real Tc,
41 Real Fa, Real Fb, Real Fc,
42 Real K, Real Tsr, Real Tsm,
43 Real Tm_init, Real PmRef) {
44 mTurbineGovernor = TurbineGovernor(Ta, Tb, Tc, Fa, Fb, Fc, K, Tsr, Tsm);
45 mTurbineGovernor.initialize(PmRef, Tm_init);
46 mHasTurbineGovernor = true;
47}
48
49void DP::Ph3::SynchronGeneratorVBR::initialize(
50 Real om, Real dt, Real initActivePower, Real initReactivePower,
51 Real initTerminalVolt, Real initVoltAngle, Real initMechPower) {
52
53 mSystemOmega = om;
54 mSystemTimeStep = dt;
55
56 mResistanceMat = Matrix::Zero(3, 3);
57 mResistanceMat << **mRs, 0, 0, 0, **mRs, 0, 0, 0, **mRs;
58
59 //Dynamic mutual inductances
60 mDLmd = 1. / (1. / mLmd + 1. / mLlfd + 1. / mLlkd);
61
62 if (mNumDampingWindings == 2) {
63 mDLmq = 1. / (1. / mLmq + 1. / mLlkq1 + 1. / mLlkq2);
64 } else {
65 mDLmq = 1. / (1. / mLmq + 1. / mLlkq1);
66 K1a = Matrix::Zero(2, 1);
67 K1 = Matrix::Zero(2, 1);
68 }
69
70 mLa = (mDLmq + mDLmd) / 3.;
71 mLb = (mDLmd - mDLmq) / 3.;
72
73 LD0 << (**mLl + mLa), -mLa / 2, -mLa / 2, -mLa / 2, **mLl + mLa, -mLa / 2,
74 -mLa / 2, -mLa / 2, **mLl + mLa;
75
76 // steady state per unit initial value
77 initStatesInPerUnit(initActivePower, initReactivePower, initTerminalVolt,
78 initVoltAngle, initMechPower);
79
80 mThetaMech2 = mThetaMech + PI / 2;
81 mThetaMech = mThetaMech + PI / 2;
82 mTheta0 = mThetaMech2;
83 **mMechTorque = -**mMechTorque;
84 mIq = -mIq;
85 mId = -mId;
86
87 CalculateAuxiliarConstants(dt * mBase_OmElec);
88
89 if (mNumDampingWindings == 2) {
90 mPsimq = mDLmq * (mPsikq1 / mLlkq1 + mPsikq2 / mLlkq2 + mIq);
91 } else {
92 mPsimq = mDLmq * (mPsikq1 / mLlkq1 + mIq);
93 }
94
95 mPsimd = mDLmd * (mPsifd / mLlfd + mPsikd / mLlkd + mId);
96
97 mDqStatorCurrents << mIq, mId;
98
99 mPsikq1kq2 << mPsikq1, mPsikq2;
100 mPsifdkd << mPsifd, mPsikd;
101
102 CalculateAuxiliarVariables(0);
103
104 E_r_vbr_DP = dq0ToAbcTransform(mThetaMech, h_qdr(1), h_qdr(0), 0);
105
106 K_DP << K, Matrix::Zero(3, 3), Matrix::Zero(3, 3), K;
107
108 mVabc = dq0ToAbcTransform(mThetaMech, mVd, mVq, mV0);
109 mIabc = dq0ToAbcTransform(mThetaMech, mId, mIq, mI0);
110
111 mDVabc = K_DP * mIabc + E_r_vbr_DP + E_r_vbr_DP2;
112
113 CalculateLandR(0, dt * mBase_OmElec);
114}
115
116void DP::Ph3::SynchronGeneratorVBR::mnaStep(Matrix &systemMatrix,
117 Matrix &rightVector,
118 Matrix &leftVector, Real time) {
119 stepInPerUnit(mSystemOmega, mSystemTimeStep, time, mNumericalMethod);
120
121 // Update current source accordingly
122 if (terminalNotGrounded(0)) {
123 Math::addToVectorElement(rightVector, matrixNodeIndex(0),
124 Complex(mISourceEq(0), mISourceEq(3)));
125 }
126 if (terminalNotGrounded(1)) {
127 Math::addToVectorElement(rightVector, matrixNodeIndex(1),
128 Complex(mISourceEq(1), mISourceEq(4)));
129 }
130 if (matrixNodeIndex(2) >= 0) {
131 Math::addToVectorElement(rightVector, matrixNodeIndex(2),
132 Complex(mISourceEq(2), mISourceEq(5)));
133 }
134
135 //Update Equivalent Resistance
136 Int systemSize = systemMatrix.rows();
137 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(0), matrixNodeIndex(0),
138 mConductanceMat(0, 0));
139 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(0), matrixNodeIndex(1),
140 mConductanceMat(0, 1));
141 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(0), matrixNodeIndex(2),
142 mConductanceMat(0, 2));
143 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(1), matrixNodeIndex(0),
144 mConductanceMat(1, 0));
145 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(1), matrixNodeIndex(1),
146 mConductanceMat(1, 1));
147 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(1), matrixNodeIndex(2),
148 mConductanceMat(1, 2));
149 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(2), matrixNodeIndex(0),
150 mConductanceMat(2, 0));
151 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(2), matrixNodeIndex(1),
152 mConductanceMat(2, 1));
153 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(2), matrixNodeIndex(2),
154 mConductanceMat(2, 2));
155
156 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(0) + systemSize,
157 matrixNodeIndex(0), mConductanceMat(3, 0));
158 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(0) + systemSize,
159 matrixNodeIndex(1), mConductanceMat(3, 1));
160 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(0) + systemSize,
161 matrixNodeIndex(2), mConductanceMat(3, 2));
162 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(1) + systemSize,
163 matrixNodeIndex(0), mConductanceMat(4, 0));
164 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(1) + systemSize,
165 matrixNodeIndex(1), mConductanceMat(4, 1));
166 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(1) + systemSize,
167 matrixNodeIndex(2), mConductanceMat(4, 2));
168 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(2) + systemSize,
169 matrixNodeIndex(0), mConductanceMat(5, 0));
170 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(2) + systemSize,
171 matrixNodeIndex(1), mConductanceMat(5, 1));
172 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(2) + systemSize,
173 matrixNodeIndex(2), mConductanceMat(5, 2));
174
175 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(0),
176 matrixNodeIndex(0) + systemSize,
177 mConductanceMat(0, 3));
178 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(0),
179 matrixNodeIndex(1) + systemSize,
180 mConductanceMat(0, 4));
181 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(0),
182 matrixNodeIndex(2) + systemSize,
183 mConductanceMat(0, 5));
184 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(1),
185 matrixNodeIndex(0) + systemSize,
186 mConductanceMat(1, 3));
187 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(1),
188 matrixNodeIndex(1) + systemSize,
189 mConductanceMat(1, 4));
190 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(1),
191 matrixNodeIndex(2) + systemSize,
192 mConductanceMat(1, 5));
193 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(2),
194 matrixNodeIndex(0) + systemSize,
195 mConductanceMat(2, 3));
196 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(2),
197 matrixNodeIndex(1) + systemSize,
198 mConductanceMat(2, 4));
199 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(2),
200 matrixNodeIndex(2) + systemSize,
201 mConductanceMat(2, 5));
202
203 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(0) + systemSize,
204 matrixNodeIndex(0) + systemSize,
205 mConductanceMat(3, 3));
206 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(0) + systemSize,
207 matrixNodeIndex(1) + systemSize,
208 mConductanceMat(3, 4));
209 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(0) + systemSize,
210 matrixNodeIndex(2) + systemSize,
211 mConductanceMat(3, 5));
212 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(1) + systemSize,
213 matrixNodeIndex(0) + systemSize,
214 mConductanceMat(4, 3));
215 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(1) + systemSize,
216 matrixNodeIndex(1) + systemSize,
217 mConductanceMat(4, 4));
218 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(1) + systemSize,
219 matrixNodeIndex(2) + systemSize,
220 mConductanceMat(4, 5));
221 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(2) + systemSize,
222 matrixNodeIndex(0) + systemSize,
223 mConductanceMat(5, 3));
224 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(2) + systemSize,
225 matrixNodeIndex(1) + systemSize,
226 mConductanceMat(5, 4));
227 Math::addToMatrixElement(systemMatrix, matrixNodeIndex(2) + systemSize,
228 matrixNodeIndex(2) + systemSize,
229 mConductanceMat(5, 5));
230
231 // TODO find solution without SystemModel
232 // system.updateLuFactored();
233
234 if (mLogLevel != Logger::Level::off) {
235 Matrix logValues(statorCurrents().rows() + dqStatorCurrents().rows() + 3,
236 1);
237 logValues << statorCurrents() * mBase_I, dqStatorCurrents(),
238 electricalTorque(), rotationalSpeed(), rotorPosition();
239 SPDLOG_LOGGER_DEBUG(mLog, time, logValues);
240 }
241}
242
243void DP::Ph3::SynchronGeneratorVBR::stepInPerUnit(Real om, Real dt, Real time,
244 NumericalMethod numMethod) {
245
246 // Calculate mechanical variables with euler
247 if (mHasTurbineGovernor == true) {
248 ** = -mTurbineGovernor.step(**mOmMech, 1, 300e6 / 555e6, dt);
249 }
250
251 **mElecTorque = (mPsimd * mIq - mPsimq * mId);
252 **mOmMech =
253 **mOmMech + dt * (1. / (2. * mH) * (**mElecTorque - **mMechTorque));
254 mThetaMech = mThetaMech + dt * ((**mOmMech - 1) * mBase_OmMech);
255 mThetaMech2 = mThetaMech2 + dt * (**mOmMech * mBase_OmMech);
256
257 mPsikq1kq2 << mPsikq1, mPsikq2;
258 mPsifdkd << mPsifd, mPsikd;
259
260 CalculateLandR(time, dt * mBase_OmElec);
261
262 CalculateAuxiliarVariables(time);
263
264 E_r_vbr_DP = dq0ToAbcTransform(mThetaMech, h_qdr(1), h_qdr(0), 0);
265 K_DP << K, Matrix::Zero(3, 3), Matrix::Zero(3, 3), K;
266
267 R_eq_DP = Var1 + K_DP;
268 E_eq_DP = Var2 * mIabc + mDVabc - mVabc + E_r_vbr_DP + E_r_vbr_DP2;
269
270 mConductanceMat = (R_eq_DP * mBase_Z).inverse();
271 mISourceEq = R_eq_DP.inverse() * E_eq_DP * mBase_I;
272}
273
274void DP::Ph3::SynchronGeneratorVBR::mnaCompPostStep(Matrix &rightVector,
275 Matrix &leftVector,
276 Real time) {
277 Real dt = mSystemTimeStep;
278
279 if (terminalNotGrounded(0)) {
280 mVaRe =
281 Math::complexFromVectorElement(leftVector, matrixNodeIndex(0)).real();
282 mVaIm =
283 Math::complexFromVectorElement(leftVector, matrixNodeIndex(0)).imag();
284 } else {
285 mVaRe = 0;
286 mVaIm = 0;
287 }
288 if (terminalNotGrounded(1)) {
289 mVbRe =
290 Math::complexFromVectorElement(leftVector, matrixNodeIndex(1)).real();
291 mVbIm =
292 Math::complexFromVectorElement(leftVector, matrixNodeIndex(1)).imag();
293 } else {
294 mVbRe = 0;
295 mVbIm = 0;
296 }
297 if (matrixNodeIndex(2) >= 0) {
298 mVcRe =
299 Math::complexFromVectorElement(leftVector, matrixNodeIndex(2)).real();
300 mVcIm =
301 Math::complexFromVectorElement(leftVector, matrixNodeIndex(2)).imag();
302 } else {
303 mVcRe = 0;
304 mVcIm = 0;
305 }
306
307 mVabc << mVaRe / mBase_V, mVbRe / mBase_V, mVcRe / mBase_V, mVaIm / mBase_V,
308 mVbIm / mBase_V, mVcIm / mBase_V;
309
310 mVq = abcToDq0Transform(mThetaMech, mVaRe, mVbRe, mVcRe, mVaIm, mVbIm,
311 mVcIm)(0);
312 mVd = abcToDq0Transform(mThetaMech, mVaRe, mVbRe, mVcRe, mVaIm, mVbIm,
313 mVcIm)(1);
314 mV0 = abcToDq0Transform(mThetaMech, mVaRe, mVbRe, mVcRe, mVaIm, mVbIm,
315 mVcIm)(2);
316
317 if (mHasExciter == true) {
318 mVfd = mExciter.step(mVd, mVq, 1, dt);
319 }
320
321 mIabc = R_eq_DP.inverse() * (mVabc - E_eq_DP);
322
323 mIaRe = mIabc(0);
324 mIbRe = mIabc(1);
325 mIcRe = mIabc(2);
326 mIaIm = mIabc(3);
327 mIbIm = mIabc(4);
328 mIcIm = mIabc(5);
329 mIq_hist = mIq;
330 mId_hist = mId;
331 mIq = abcToDq0Transform(mThetaMech, mIaRe, mIbRe, mIcRe, mIaIm, mIbIm,
332 mIcIm)(0);
333 mId = abcToDq0Transform(mThetaMech, mIaRe, mIbRe, mIcRe, mIaIm, mIbIm,
334 mIcIm)(1);
335 mI0 = abcToDq0Transform(mThetaMech, mIaRe, mIbRe, mIcRe, mIaIm, mIbIm,
336 mIcIm)(2);
337
338 // Calculate rotor flux likanges
339 if (mNumDampingWindings == 2) {
340
341 mDqStatorCurrents << mIq, mId;
342
343 mPsikq1kq2 = E1 * mIq + E2 * mPsikq1kq2 + E1 * mIq_hist;
344 mPsifdkd = F1 * mId + F2 * mPsifdkd + F1 * mId_hist + F3 * mVfd;
345
346 mPsikq1 = mPsikq1kq2(0);
347 mPsikq2 = mPsikq1kq2(1);
348 mPsifd = mPsifdkd(0);
349 mPsikd = mPsifdkd(1);
350
351 } else {
352
353 mDqStatorCurrents << mIq, mId;
354
355 mPsikq1 = E1_1d * mIq + E2_1d * mPsikq1 + E1_1d * mIq_hist;
356 mPsifdkd = F1 * mId + F2 * mPsifdkd + F1 * mId_hist + F3 * mVfd;
357
358 mPsifd = mPsifdkd(0);
359 mPsikd = mPsifdkd(1);
360 }
361
362 // Calculate dynamic flux likages
363 if (mNumDampingWindings == 2) {
364 mPsimq = mDLmq * (mPsikq1 / mLlkq1 + mPsikq2 / mLlkq2 + mIq);
365 } else {
366 mPsimq = mDLmq * (mPsikq1 / mLlkq1 + mIq);
367 }
368
369 mPsimd = mDLmd * (mPsifd / mLlfd + mPsikd / mLlkd + mId);
370
371 mDVabc = K_DP * mIabc + E_r_vbr_DP + E_r_vbr_DP2;
372}
373
374void DP::Ph3::SynchronGeneratorVBR::CalculateAuxiliarVariables(Real time) {
375
376 if (mNumDampingWindings == 2) {
377 c21_omega = -**mOmMech * mDLmq / mLlkq1;
378 c22_omega = -**mOmMech * mDLmq / mLlkq2;
379 c13_omega = **mOmMech * mDLmd / mLlfd;
380 c14_omega = **mOmMech * mDLmd / mLlkd;
381
382 K1a << c11, c12, c21_omega, c22_omega;
383 K1b << c15, 0;
384 K1 = K1a * E1 + K1b;
385 } else {
386 c21_omega = -**mOmMech * mDLmq / mLlkq1;
387 c13_omega = **mOmMech * mDLmd / mLlfd;
388 c14_omega = **mOmMech * mDLmd / mLlkd;
389
390 K1a << c11, c21_omega;
391 K1b << c15, 0;
392 K1 = K1a * E1_1d + K1b;
393 }
394
395 K2a << c13_omega, c14_omega, c23, c24;
396 K2b << 0, c25;
397 K2 = K2a * F1 + K2b;
398
399 K << K1, K2, Matrix::Zero(2, 1), 0, 0, 0;
400
401 mKrs_teta << 2. / 3. * cos(mThetaMech2),
402 2. / 3. * cos(mThetaMech2 - 2. * M_PI / 3.),
403 2. / 3. * cos(mThetaMech2 + 2. * M_PI / 3.), 2. / 3. * sin(mThetaMech2),
404 2. / 3. * sin(mThetaMech2 - 2. * M_PI / 3.),
405 2. / 3. * sin(mThetaMech2 + 2. * M_PI / 3.), 1. / 3., 1. / 3., 1. / 3.;
406
407 // mKrs_teta_inv = mKrs_teta.inverse();
408 mKrs_teta_inv << cos(mThetaMech2), sin(mThetaMech2), 1.,
409 cos(mThetaMech2 - 2. * M_PI / 3.), sin(mThetaMech2 - 2. * M_PI / 3.), 1,
410 cos(mThetaMech2 + 2. * M_PI / 3.), sin(mThetaMech2 + 2. * M_PI / 3.), 1.;
411
412 K = mKrs_teta_inv * K * mKrs_teta;
413
414 if (mNumDampingWindings == 2) {
415 //h_qdr = K1a*E2*mPsikq1kq2 + K1a*E1*mIq + K2a*F2*mPsifdkd + K2a*F1*mId + (K2a*F3 + C26)*mVfd;
416 h_qdr =
417 K1a * E2 * mPsikq1kq2 + K2a * F2 * mPsifdkd + (K2a * F3 + C26) * mVfd;
418 } else {
419 h_qdr = K1a * E2_1d * mPsikq1 + K1a * E1_1d * mIq + K2a * F2 * mPsifdkd +
420 K2a * F1 * mId + (K2a * F3 + C26) * mVfd;
421 }
422
423 Matrix Knew = Matrix::Zero(3, 3);
424 Knew << K1a * E1, K2a * F1, Matrix::Zero(2, 1), 0, 0, 0;
425 Knew = mKrs_teta_inv * Knew * mKrs_teta;
426
427 Matrix KDPnew = Matrix::Zero(6, 6);
428 KDPnew << Knew, Matrix::Zero(3, 3), Matrix::Zero(3, 3), Knew;
429
430 E_r_vbr_DP2 = KDPnew * mIabc;
431}
432
433void DP::Ph3::SynchronGeneratorVBR::CalculateAuxiliarConstants(Real dt) {
434 b11 = (mRkq1 / mLlkq1) * (mDLmq / mLlkq1 - 1);
435 b13 = mRkq1 * mDLmq / mLlkq1;
436 b31 = (mRfd / mLlfd) * (mDLmd / mLlfd - 1);
437 b32 = mRfd * mDLmd / (mLlfd * mLlkd);
438 b33 = mRfd * mDLmd / mLlfd;
439 b41 = mRkd * mDLmd / (mLlfd * mLlkd);
440 b42 = (mRkd / mLlkd) * (mDLmd / mLlkd - 1);
441 b43 = mRkd * mDLmd / mLlkd;
442
443 c23 = mDLmd * mRfd / (mLlfd * mLlfd) * (mDLmd / mLlfd - 1) +
444 mDLmd * mDLmd * mRkd / (mLlkd * mLlkd * mLlfd);
445 c24 = mDLmd * mRkd / (mLlkd * mLlkd) * (mDLmd / mLlkd - 1) +
446 mDLmd * mDLmd * mRfd / (mLlfd * mLlfd * mLlkd);
447 c25 = (mRfd / (mLlfd * mLlfd) + mRkd / (mLlkd * mLlkd)) * mDLmd * mDLmd;
448 c26 = mDLmd / mLlfd;
449
450 if (mNumDampingWindings == 2) {
451 b12 = mRkq1 * mDLmq / (mLlkq1 * mLlkq2);
452 b21 = mRkq2 * mDLmq / (mLlkq1 * mLlkq2);
453 b22 = (mRkq2 / mLlkq2) * (mDLmq / mLlkq2 - 1);
454 b23 = mRkq2 * mDLmq / mLlkq2;
455 c11 = mDLmq * mRkq1 / (mLlkq1 * mLlkq1) * (mDLmq / mLlkq1 - 1) +
456 mDLmq * mDLmq * mRkq2 / (mLlkq2 * mLlkq2 * mLlkq1);
457 c12 = mDLmq * mRkq2 / (mLlkq2 * mLlkq2) * (mDLmq / mLlkq2 - 1) +
458 mDLmq * mDLmq * mRkq1 / (mLlkq1 * mLlkq1 * mLlkq2);
459 c15 =
460 (mRkq1 / (mLlkq1 * mLlkq1) + mRkq2 / (mLlkq2 * mLlkq2)) * mDLmq * mDLmq;
461
462 Ea << 2 - dt * b11, -dt * b12, -dt * b21, 2 - dt * b22;
463 E1b << dt * b13, dt * b23;
464 E1 = Ea.inverse() * E1b;
465
466 E2b << 2 + dt * b11, dt * b12, dt * b21, 2 + dt * b22;
467 E2 = Ea.inverse() * E2b;
468 } else {
469 c11 = mDLmq * mRkq1 / (mLlkq1 * mLlkq1) * (mDLmq / mLlkq1 - 1);
470 c15 = (mRkq1 / (mLlkq1 * mLlkq1)) * mDLmq * mDLmq;
471
472 E1_1d = (1 / (2 - dt * b11)) * dt * b13;
473 E2_1d = (1 / (2 - dt * b11)) * (2 + dt * b11);
474 }
475
476 Fa << 2 - dt * b31, -dt * b32, -dt * b41, 2 - dt * b42;
477 F1b << dt * b33, dt * b43;
478 F1 = Fa.inverse() * F1b;
479
480 F2b << 2 + dt * b31, dt * b32, dt * b41, 2 + dt * b42;
481
482 F2 = Fa.inverse() * F2b;
483
484 F3b << 2 * dt, 0;
485 F3 = Fa.inverse() * F3b;
486
487 C26 << 0, c26;
488}
489
490void DP::Ph3::SynchronGeneratorVBR::CalculateLandR(Real time, Real dt) {
491 Matrix L1_Re(3, 3);
492 Matrix L1_Im(3, 3);
493 Matrix Re_R(3, 3);
494 Matrix Im_R(3, 3);
495 Matrix Re_L(3, 3);
496 Matrix Im_L(3, 3);
497 Matrix Re_R2(3, 3);
498 Matrix Im_R2(3, 3);
499 Matrix Re_L2(3, 3);
500 Matrix Im_L2(3, 3);
501
502 Real b_Re = cos(2 * **mOmMech * mBase_OmMech * time);
503 Real b_Im = sin(2 * **mOmMech * mBase_OmMech * time);
504 Real c_Re = cos(2 * mThetaMech2 - 2 * 1 * mBase_OmMech * time - 2 * mTheta0);
505 Real c_Im = sin(2 * mThetaMech2 - 2 * 1 * mBase_OmMech * time - 2 * mTheta0);
506
507 Real a = 2 * (mTheta0);
508
509 L1_Re << cos(a), cos(-2. * PI / 3 + a), cos(2. * PI / 3 + a),
510 cos(-2 * PI / 3 + a), cos(-4 * PI / 3 + a), cos(a), cos(2 * PI / 3 + a),
511 cos(a), cos(4 * PI / 3 + a);
512 L1_Re = mLb * L1_Re;
513 L1_Im << sin(a), sin(-2. * PI / 3 + a), sin(2. * PI / 3 + a),
514 sin(-2 * PI / 3 + a), sin(-4 * PI / 3 + a), sin(a), sin(2 * PI / 3 + a),
515 sin(a), sin(4 * PI / 3 + a);
516 L1_Im = mLb * L1_Im;
517
518 Re_R =
519 mResistanceMat + (2 * **mOmMech + 1) / 2. * (L1_Re * b_Im + L1_Im * b_Re);
520 Im_R = LD0 - (2 * **mOmMech + 1) / 2. * (L1_Re * b_Re - L1_Im * b_Im);
521 Re_L = LD0 - 1. / 2. * (L1_Re * b_Re - L1_Im * b_Im);
522 Im_L = -1. / 2. * (L1_Re * b_Im + L1_Im * b_Re);
523 Re_R2 = 1. / 2. * (2 * **mOmMech - 1) * (L1_Im * c_Re + L1_Re * c_Im);
524 Im_R2 = -1. / 2. * (2 * **mOmMech - 1) * (L1_Re * c_Re - L1_Im * c_Im);
525 Re_L2 = -1. / 2. * (L1_Re * c_Re - L1_Im * c_Im);
526 Im_L2 = -1. / 2. * (L1_Im * c_Re + L1_Re * c_Im);
527
528 R_EQ << Re_R + Re_R2, -Im_R + Im_R2, Im_R + Im_R2, Re_R - Re_R2;
529 L_EQ << Re_L + Re_L2, -Im_L + Im_L2, Im_L + Im_L2, Re_L - Re_L2;
530
531 A = -L_EQ.inverse() * R_EQ;
532 B = L_EQ.inverse();
533 Var1 = B.inverse() * ((2 / dt) * Matrix::Identity(6, 6) - A);
534 Var2 = -B.inverse() * ((2 / dt) * Matrix::Identity(6, 6) + A);
535}
536
537Matrix DP::Ph3::SynchronGeneratorVBR::abcToDq0Transform(Real theta, Real aRe,
538 Real bRe, Real cRe,
539 Real aIm, Real bIm,
540 Real cIm) {
541 // Balanced case
542 Complex alpha(cos(2. / 3. * PI), sin(2. / 3. * PI));
543 Complex thetaCompInv(cos(-theta), sin(-theta));
544 MatrixComp AbcToPnz(3, 3);
545 AbcToPnz << 1, 1, 1, 1, alpha, pow(alpha, 2), 1, pow(alpha, 2), alpha;
546 AbcToPnz = (1. / 3.) * AbcToPnz;
547
548 MatrixComp abcVector(3, 1);
549 abcVector << Complex(aRe, aIm), Complex(bRe, bIm), Complex(cRe, cIm);
550
551 MatrixComp pnzVector(3, 1);
552 pnzVector = AbcToPnz * abcVector * thetaCompInv;
553
554 Matrix dq0Vector(3, 1);
555 dq0Vector << pnzVector(1, 0).real(), -pnzVector(1, 0).imag(), 0;
556
557 return dq0Vector;
558}
559
560Matrix DP::Ph3::SynchronGeneratorVBR::dq0ToAbcTransform(Real theta, Real d,
561 Real q, Real zero) {
562 // Balanced case
563 Complex alpha(cos(2. / 3. * PI), sin(2. / 3. * PI));
564 Complex thetaComp(cos(theta), sin(theta));
565 MatrixComp PnzToAbc(3, 3);
566 PnzToAbc << 1, 1, 1, 1, pow(alpha, 2), alpha, 1, alpha, pow(alpha, 2);
567
568 MatrixComp pnzVector(3, 1);
569 pnzVector << 0, Complex(q, -d), Complex(0, 0);
570
571 MatrixComp abcCompVector(3, 1);
572 abcCompVector = PnzToAbc * pnzVector * thetaComp;
573
574 Matrix abcVector(6, 1);
575 abcVector << abcCompVector(0, 0).real(), abcCompVector(1, 0).real(),
576 abcCompVector(2, 0).real(), abcCompVector(0, 0).imag(),
577 abcCompVector(1, 0).imag(), abcCompVector(2, 0).imag();
578
579 return abcVector;
580}
CPS::Base::SynchronGenerator::mSystemOmega
Real mSystemOmega
Simulation angular system speed.
Definition Base_SynchronGenerator.h:79
CPS::Base::SynchronGenerator::mRkq1
Real mRkq1
q-axis damper resistance 1 Rkq1 [Ohm]
Definition Base_SynchronGenerator.h:124
CPS::Base::SynchronGenerator::mLmd
Real mLmd
d-axis mutual inductance Lmd [H]
Definition Base_SynchronGenerator.h:106
CPS::Base::SynchronGenerator::mBase_I
Real mBase_I
base stator current peak
Definition Base_SynchronGenerator.h:176
CPS::Base::SynchronGenerator::mHasExciter
Bool mHasExciter
Determines if Exciter is activated.
Definition Base_SynchronGenerator.h:302
CPS::Base::SynchronGenerator::mMechTorque
const Attribute< Real >::Ptr mMechTorque
mechanical torque
Definition Base_SynchronGenerator.h:217
CPS::Base::SynchronGenerator::mLmq
Real mLmq
q-axis mutual inductance Lmq [H]
Definition Base_SynchronGenerator.h:108
CPS::Base::SynchronGenerator::mExciter
std::shared_ptr< Base::Exciter > mExciter
Signal component modelling voltage regulator and exciter.
Definition Base_SynchronGenerator.h:409
CPS::Base::SynchronGenerator::mLlfd
Real mLlfd
field leakage inductance Llfd [H]
Definition Base_SynchronGenerator.h:112
CPS::Base::SynchronGenerator::mLlkd
Real mLlkd
d-axis damper leakage inductance Llkd [H]
Definition Base_SynchronGenerator.h:120
CPS::Base::SynchronGenerator::mBase_Z
Real mBase_Z
base stator impedance
Definition Base_SynchronGenerator.h:180
CPS::Base::SynchronGenerator::mRs
const Attribute< Real >::Ptr mRs
stator resistance Rs [Ohm]
Definition Base_SynchronGenerator.h:138
CPS::Base::SynchronGenerator::mResistanceMat
Matrix mResistanceMat
resistance matrix
Definition Base_SynchronGenerator.h:205
CPS::Base::SynchronGenerator::mTurbineGovernor
std::shared_ptr< Signal::TurbineGovernor > mTurbineGovernor
Signal component modelling governor control and steam turbine (legacy)
Definition Base_SynchronGenerator.h:401
CPS::Base::SynchronGenerator::mLlkq1
Real mLlkq1
q-axis damper leakage inductance 1 Llkq1 [H]
Definition Base_SynchronGenerator.h:126
CPS::Base::SynchronGenerator::mRkd
Real mRkd
d-axis damper resistance Rkd [Ohm]
Definition Base_SynchronGenerator.h:118
CPS::Base::SynchronGenerator::mRfd
Real mRfd
field resistance Rfd [Ohm]
Definition Base_SynchronGenerator.h:110
CPS::Base::SynchronGenerator::mBase_OmElec
Real mBase_OmElec
base electrical angular frequency
Definition Base_SynchronGenerator.h:182
CPS::Base::SynchronGenerator::mLl
const Attribute< Real >::Ptr mLl
leakage inductance Ll [H]
Definition Base_SynchronGenerator.h:140
CPS::Base::SynchronGenerator::mBase_OmMech
Real mBase_OmMech
base mechanical angular frequency
Definition Base_SynchronGenerator.h:184
CPS::Base::SynchronGenerator::mRkq2
Real mRkq2
q-axis damper resistance 2 Rkq2 [Ohm]
Definition Base_SynchronGenerator.h:130
CPS::Base::SynchronGenerator::mNumDampingWindings
Int mNumDampingWindings
Number of damping windings in q.
Definition Base_SynchronGenerator.h:101
CPS::Base::SynchronGenerator::mBase_V
Real mBase_V
base stator voltage (phase-to-ground peak)
Definition Base_SynchronGenerator.h:172
CPS::Base::SynchronGenerator::mOmMech
const Attribute< Real >::Ptr mOmMech
rotor speed omega_r
Definition Base_SynchronGenerator.h:221
CPS::Base::SynchronGenerator::mHasTurbineGovernor
Bool mHasTurbineGovernor
Determines if legacy TurbineGovernor is activated.
Definition Base_SynchronGenerator.h:296
CPS::Base::SynchronGenerator::mLlkq2
Real mLlkq2
q-axis damper leakage inductance 2 Llkq2 [H]
Definition Base_SynchronGenerator.h:132
CPS::Base::SynchronGenerator::mElecTorque
const Attribute< Real >::Ptr mElecTorque
electrical torque
Definition Base_SynchronGenerator.h:229
CPS::DP::Ph3::SynchronGeneratorVBR::mnaCompPostStep
void mnaCompPostStep(Matrix &rightVector, Matrix &leftVector, Real time)
Retrieves calculated voltage from simulation for next step.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.cpp:274
CPS::DP::Ph3::SynchronGeneratorVBR::mVaIm
Real mVaIm
Interface voltage phase a _ Imaginary part.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:55
CPS::DP::Ph3::SynchronGeneratorVBR::R_EQ
Matrix R_EQ
Equivalent stator resistance matrix.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:96
CPS::DP::Ph3::SynchronGeneratorVBR::mVbIm
Real mVbIm
Interface voltage phase b _ Imaginary part.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:59
CPS::DP::Ph3::SynchronGeneratorVBR::mPsimd
Real mPsimd
Magnetizing flux linkage in d axis.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:81
CPS::DP::Ph3::SynchronGeneratorVBR::mIbIm
Real mIbIm
Interface current phase b _ Imaginary part.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:72
CPS::DP::Ph3::SynchronGeneratorVBR::LD0
Matrix LD0
Constant part of equivalent stator inductance.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:92
CPS::DP::Ph3::SynchronGeneratorVBR::mIbRe
Real mIbRe
Interface current phase b _ Real part.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:70
CPS::DP::Ph3::SynchronGeneratorVBR::mIcIm
Real mIcIm
Interface current phase c _ Imaginary part.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:76
CPS::DP::Ph3::SynchronGeneratorVBR::R_eq_DP
Matrix R_eq_DP
Equivalent VBR resistance matrix.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:98
CPS::DP::Ph3::SynchronGeneratorVBR::E_eq_DP
Matrix E_eq_DP
Equivalent VBR voltage source vector.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:100
CPS::DP::Ph3::SynchronGeneratorVBR::mnaStep
void mnaStep(Matrix &systemMatrix, Matrix &rightVector, Matrix &leftVector, Real time)
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.cpp:116
CPS::DP::Ph3::SynchronGeneratorVBR::mKrs_teta_inv
Matrix mKrs_teta_inv
Inverse Park Transformation Matrix.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:117
CPS::DP::Ph3::SynchronGeneratorVBR::mIaRe
Real mIaRe
Interface current phase a _ Real part.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:66
CPS::DP::Ph3::SynchronGeneratorVBR::mVbRe
Real mVbRe
Interface voltage phase b _ Real part.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:57
CPS::DP::Ph3::SynchronGeneratorVBR::mVaRe
Real mVaRe
Interface voltage phase a _ Real part.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:53
CPS::DP::Ph3::SynchronGeneratorVBR::mConductanceMat
Matrix mConductanceMat
Equivalent Stator Conductance Matrix.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:120
CPS::DP::Ph3::SynchronGeneratorVBR::mVcRe
Real mVcRe
Interface voltage phase c _ Real part.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:61
CPS::DP::Ph3::SynchronGeneratorVBR::stepInPerUnit
void stepInPerUnit(Real om, Real dt, Real time, NumericalMethod numMethod)
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.cpp:243
CPS::DP::Ph3::SynchronGeneratorVBR::mIcRe
Real mIcRe
Interface current phase c _ Real part.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:74
CPS::DP::Ph3::SynchronGeneratorVBR::mIaIm
Real mIaIm
Interface current phase a _ Imaginary part.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:68
CPS::DP::Ph3::SynchronGeneratorVBR::mIq_hist
Real mIq_hist
stator current in q axis (last time step)
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:111
CPS::DP::Ph3::SynchronGeneratorVBR::dq0ToAbcTransform
Matrix dq0ToAbcTransform(Real theta, Real d, Real q, Real zero)
dq to abc
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.cpp:560
CPS::DP::Ph3::SynchronGeneratorVBR::abcToDq0Transform
Matrix abcToDq0Transform(Real theta, Real aRe, Real bRe, Real cRe, Real aIm, Real bIm, Real cIm)
abc to dq
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.cpp:537
CPS::DP::Ph3::SynchronGeneratorVBR::addGovernor
void addGovernor(Real Ta, Real Tb, Real Tc, Real Fa, Real Fb, Real Fc, Real K, Real Tsr, Real Tsm, Real Tm_init, Real PmRef)
Function to initialize Governor and Turbine.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.cpp:40
CPS::DP::Ph3::SynchronGeneratorVBR::initialize
void initialize(Matrix frequencies) override
Initialize components with correct network frequencies.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:203
CPS::DP::Ph3::SynchronGeneratorVBR::addExciter
void addExciter(Real Ta, Real Ka, Real Te, Real Ke, Real Tf, Real Kf, Real Tr, Real Lad, Real Rfd)
Function to initialize Exciter.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.cpp:31
CPS::DP::Ph3::SynchronGeneratorVBR::mPsimq
Real mPsimq
Magnetizing flux linkage in q axis.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:79
CPS::DP::Ph3::SynchronGeneratorVBR::mISourceEq
Matrix mISourceEq
Equivalent Stator Current Source.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:122
CPS::DP::Ph3::SynchronGeneratorVBR::mVcIm
Real mVcIm
Interface voltage phase c _ Imaginary part.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:63
CPS::DP::Ph3::SynchronGeneratorVBR::SynchronGeneratorVBR
SynchronGeneratorVBR(String name, Real nomPower, Real nomVolt, Real nomFreq, Int poleNumber, Real nomFieldCur, Real Rs, Real Ll, Real Lmd, Real Lmd0, Real Lmq, Real Lmq0, Real Rfd, Real Llfd, Real Rkd, Real Llkd, Real Rkq1, Real Llkq1, Real Rkq2, Real Llkq2, Real inertia, Logger::Level logLevel=Logger::Level::off)
FIXME: SynchronGeneratorBase does not exist!
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.cpp:13
CPS::DP::Ph3::SynchronGeneratorVBR::L_EQ
Matrix L_EQ
Equivalent stator inductance matrix.
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:94
CPS::DP::Ph3::SynchronGeneratorVBR::mId_hist
Real mId_hist
stator current in d axis (last time step)
Definition DP_Ph3_SynchronGeneratorVBR_Deprecated.h:113
CPS::IdentifiedObject::mAttributes
AttributeList::Ptr mAttributes
Attribute List.
Definition IdentifiedObject.h:22
CPS::Logger::Level
spdlog::level::level_enum Level
Definition Logger.h:33
CPS::Math::complexFromVectorElement
static Complex complexFromVectorElement(const Matrix &mat, Matrix::Index row, Int maxFreq=1, Int freqIdx=0)
Definition MathUtils.cpp:94
CPS::Math::addToVectorElement
static void addToVectorElement(Matrix &mat, Matrix::Index row, Complex value, Int maxFreq=1, Int freqIdx=0)
Definition MathUtils.cpp:83
CPS::Math::addToMatrixElement
static void addToMatrixElement(SparseMatrixRow &mat, Matrix::Index row, Matrix::Index column, Complex value, Int maxFreq=1, Int freqIdx=0)
Definition MathUtils.cpp:130
CPS::SimPowerComp< Complex >::matrixNodeIndex
UInt matrixNodeIndex(UInt nodeIndex)
Definition SimPowerComp.cpp:45
CPS::SimPowerComp< Complex >::terminalNotGrounded
Bool terminalNotGrounded(UInt index)
Definition SimPowerComp.cpp:112
CPS::TopologicalPowerComp::mLogLevel
Logger::Level mLogLevel
Component logger control for internal variables.
Definition TopologicalPowerComp.h:36
PI
#define PI
Definition Definitions.h:43
M_PI
#define M_PI
Definition Definitions.h:41
CPS::Matrix
Eigen::Matrix< Real, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor > Matrix
Dense matrix for real numbers.
Definition Definitions.h:81
CPS::String
std::string String
Definition Definitions.h:65
CPS::Real
double Real
Definition Definitions.h:62
CPS::Int
int Int
Definition Definitions.h:61
CPS::Complex
std::complex< Real > Complex
Definition Definitions.h:63
CPS::MatrixComp
Eigen::Matrix< Complex, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor > MatrixComp
Dense matrix for complex numbers.
Definition Definitions.h:84
CPS::NumericalMethod
NumericalMethod
Definition Definitions.h:112