DPsim
Loading...
Searching...
No Matches
EMT_Ph3_Transformer.cpp
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/EMT/EMT_Ph3_Transformer.h>
10
11using namespace CPS;
12
13EMT::Ph3::Transformer::Transformer(String uid, String name,
14 Logger::Level logLevel,
15 Bool withResistiveLosses)
16 : Base::Ph3::Transformer(mAttributes),
17 CompositePowerComp<Real>(uid, name, true, true, logLevel) {
18 mPhaseType = PhaseType::ABC;
19 if (withResistiveLosses)
20 setVirtualNodeNumber(3);
21 else
22 setVirtualNodeNumber(2);
23
24 setTerminalNumber(2);
25
26 SPDLOG_LOGGER_INFO(mSLog, "Create {} {}", this->type(), name);
27 **mIntfVoltage = Matrix::Zero(3, 1);
28 **mIntfCurrent = Matrix::Zero(1, 1);
29}
30
32SimPowerComp<Real>::Ptr EMT::Ph3::Transformer::clone(String name) {
33 auto copy = Transformer::make(name, mLogLevel);
34 copy->setParameters(mNominalVoltageEnd1, mNominalVoltageEnd2, mRatedPower,
35 std::abs(**mRatio), std::arg(**mRatio), mResistance,
36 mInductance);
37 return copy;
38}
39
40void EMT::Ph3::Transformer::setParameters(Real nomVoltageEnd1,
41 Real nomVoltageEnd2, Real ratedPower,
42 Real ratioAbs, Real ratioPhase,
43 Matrix resistance,
44 Matrix inductance) {
45
46 Base::Ph3::Transformer::setParameters(nomVoltageEnd1, nomVoltageEnd2,
47 ratedPower, ratioAbs, ratioPhase,
48 resistance, inductance);
49
50 SPDLOG_LOGGER_INFO(
51 mSLog, "Nominal Voltage End 1 = {} [V] Nominal Voltage End 2 = {} [V]",
52 mNominalVoltageEnd1, mNominalVoltageEnd2);
53 SPDLOG_LOGGER_INFO(mSLog, "Rated Apparent Power = {} [VA]", mRatedPower);
54 SPDLOG_LOGGER_INFO(mSLog, "Tap Ratio = {} [ ] Phase Shift = {} [deg]",
55 std::abs(**mRatio), std::arg(**mRatio));
56
57 mParametersSet = true;
58}
59
60void EMT::Ph3::Transformer::createSubComponents() {
61 if (mSubCompCreated)
62 return;
63 mSubCompCreated = true;
64
65 // Switch terminals so terminal 0 is always the higher-voltage side.
66 if (Math::abs(**mRatio) < 1.) {
67 **mRatio = 1. / **mRatio;
68 std::shared_ptr<SimTerminal<Real>> tmp = mTerminals[0];
69 mTerminals[0] = mTerminals[1];
70 mTerminals[1] = tmp;
71 Real tmpVolt = mNominalVoltageEnd1;
72 mNominalVoltageEnd1 = mNominalVoltageEnd2;
73 mNominalVoltageEnd2 = tmpVolt;
74 SPDLOG_LOGGER_INFO(mSLog, "Switching terminals to have first terminal at "
75 "higher voltage side. Updated parameters: ");
76 SPDLOG_LOGGER_INFO(
77 mSLog, "Nominal Voltage End 1 = {} [V] Nominal Voltage End 2 = {} [V]",
78 mNominalVoltageEnd1, mNominalVoltageEnd2);
79 SPDLOG_LOGGER_INFO(mSLog, "Tap Ratio = {} [ ] Phase Shift = {} [deg]",
80 std::abs(**mRatio), std::arg(**mRatio));
81 }
82
83 // Create series sub components
84 mSubInductor =
85 std::make_shared<EMT::Ph3::Inductor>(**mName + "_ind", mLogLevel);
86 mSubInductor->setParameters(mInductance);
87 addMNASubComponent(mSubInductor, MNA_SUBCOMP_TASK_ORDER::TASK_BEFORE_PARENT,
88 MNA_SUBCOMP_TASK_ORDER::TASK_BEFORE_PARENT, true);
89
90 if (mNumVirtualNodes == 3) {
91 mSubResistor =
92 std::make_shared<EMT::Ph3::Resistor>(**mName + "_res", mLogLevel);
93 addMNASubComponent(mSubResistor, MNA_SUBCOMP_TASK_ORDER::TASK_BEFORE_PARENT,
94 MNA_SUBCOMP_TASK_ORDER::TASK_BEFORE_PARENT, true);
95 mSubResistor->setParameters(mResistance);
96 mSubResistor->connect({node(0), mVirtualNodes[2]});
97 mSubInductor->connect({mVirtualNodes[2], mVirtualNodes[0]});
98 } else {
99 mSubInductor->connect({node(0), mVirtualNodes[0]});
100 }
101
102 // Create parallel sub components (three-phase power)
103 Real pSnub = P_SNUB_TRANSFORMER * mRatedPower;
104
105 // A snubber conductance is added on the higher voltage side
106 Real snubberResistance1 = std::pow(std::abs(mNominalVoltageEnd1), 2) / pSnub;
107 mSnubberResistance1 =
108 Math::singlePhaseParameterToThreePhase(snubberResistance1);
109 mSubSnubResistor1 =
110 std::make_shared<EMT::Ph3::Resistor>(**mName + "_snub_res1", mLogLevel);
111 mSubSnubResistor1->setParameters(mSnubberResistance1);
112 mSubSnubResistor1->connect({node(0), EMT::SimNode::GND});
113 SPDLOG_LOGGER_INFO(
114 mSLog,
115 "Snubber Resistance 1 (connected to higher voltage side {}) = {} [Ohm]",
116 node(0)->name(), Logger::matrixToString(mSnubberResistance1));
117 addMNASubComponent(mSubSnubResistor1,
118 MNA_SUBCOMP_TASK_ORDER::TASK_BEFORE_PARENT,
119 MNA_SUBCOMP_TASK_ORDER::TASK_BEFORE_PARENT, true);
120
121 // A snubber conductance is added on the lower voltage side
122 Real snubberResistance2 = std::pow(std::abs(mNominalVoltageEnd2), 2) / pSnub;
123 mSnubberResistance2 =
124 Math::singlePhaseParameterToThreePhase(snubberResistance2);
125 mSubSnubResistor2 =
126 std::make_shared<EMT::Ph3::Resistor>(**mName + "_snub_res2", mLogLevel);
127 mSubSnubResistor2->setParameters(mSnubberResistance2);
128 mSubSnubResistor2->connect({node(1), EMT::SimNode::GND});
129 SPDLOG_LOGGER_INFO(
130 mSLog,
131 "Snubber Resistance 2 (connected to lower voltage side {}) = {} [Ohm]",
132 node(1)->name(), Logger::matrixToString(mSnubberResistance2));
133 addMNASubComponent(mSubSnubResistor2,
134 MNA_SUBCOMP_TASK_ORDER::TASK_BEFORE_PARENT,
135 MNA_SUBCOMP_TASK_ORDER::TASK_BEFORE_PARENT, true);
136
137 // LV-side snubber capacitor created here; its omega-dependent value is set in initializeParentFromNodesAndTerminals().
138 mSubSnubCapacitor2 =
139 std::make_shared<EMT::Ph3::Capacitor>(**mName + "_snub_cap2", mLogLevel);
140 mSubSnubCapacitor2->connect({node(1), EMT::SimNode::GND});
141 addMNASubComponent(mSubSnubCapacitor2,
142 MNA_SUBCOMP_TASK_ORDER::TASK_BEFORE_PARENT,
143 MNA_SUBCOMP_TASK_ORDER::TASK_BEFORE_PARENT, true);
144}
145
146void EMT::Ph3::Transformer::initializeParentFromNodesAndTerminals(
147 Real frequency) {
148 // Set initial voltage of virtual node in between
149 mVirtualNodes[0]->setInitialVoltage(initialSingleVoltage(1) * **mRatio);
150
151 // Static calculations from load flow data
152 Real omega = 2. * PI * frequency;
153
154 Real qSnub = Q_SNUB_TRANSFORMER * mRatedPower;
155
156 // // A snubber capacitance is added to higher voltage side (not used as capacitor at high voltage side made it worse)
157 // Real snubberCapacitance1 = qSnub / std::pow(std::abs(mNominalVoltageEnd1),2) / omega;
158 // mSnubberCapacitance1 = Math::singlePhaseParameterToThreePhase*(snubberCapacitance1);
159 // mSubSnubCapacitor1 = std::make_shared<EMT::Ph3::Capacitor>(**mName + "_snub_cap1", mLogLevel);
160 // mSubSnubCapacitor1->setParameters(mSnubberCapacitance1);
161 // mSubSnubCapacitor1->connect({ node(0), EMT::SimNode::GND });
162 // SPDLOG_LOGGER_INFO(mSLog, "Snubber Capacitance 1 (connected to higher voltage side {}) = \n{} [F] \n ", node(0)->name(), Logger::matrixToString(mSnubberCapacitance1));
163 // mSubComponents.push_back(mSubSnubCapacitor1);
164
165 Real snubberCapacitance2 =
166 qSnub / std::pow(std::abs(mNominalVoltageEnd2), 2) / omega;
167 mSnubberCapacitance2 =
168 Math::singlePhaseParameterToThreePhase(snubberCapacitance2);
169 mSubSnubCapacitor2->setParameters(mSnubberCapacitance2);
170 SPDLOG_LOGGER_INFO(
171 mSLog,
172 "Snubber Capacitance 2 (connected to lower voltage side {}) = {} [F]",
173 node(1)->name(), Logger::matrixToString(mSnubberCapacitance2));
174 MatrixComp impedance = MatrixComp::Zero(3, 3);
175 impedance << Complex(mResistance(0, 0), omega * mInductance(0, 0)),
176 Complex(mResistance(0, 1), omega * mInductance(0, 1)),
177 Complex(mResistance(0, 2), omega * mInductance(0, 2)),
178 Complex(mResistance(1, 0), omega * mInductance(1, 0)),
179 Complex(mResistance(1, 1), omega * mInductance(1, 1)),
180 Complex(mResistance(1, 2), omega * mInductance(1, 2)),
181 Complex(mResistance(2, 0), omega * mInductance(2, 0)),
182 Complex(mResistance(2, 1), omega * mInductance(2, 1)),
183 Complex(mResistance(2, 2), omega * mInductance(2, 2));
184
185 SPDLOG_LOGGER_INFO(mSLog,
186 "Resistance (referred to higher voltage side) = {} [Ohm]",
187 Logger::matrixToString(mResistance));
188 SPDLOG_LOGGER_INFO(mSLog,
189 "Inductance (referred to higher voltage side) = {} [H]",
190 Logger::matrixToString(mInductance));
191 SPDLOG_LOGGER_INFO(mSLog,
192 "Reactance (referred to higher voltage side) = {} [Ohm]",
193 Logger::matrixToString(omega * mInductance));
194
195 MatrixComp vInitABC = MatrixComp::Zero(3, 1);
196 vInitABC(0, 0) =
197 RMS3PH_TO_PEAK1PH *
198 (mVirtualNodes[0]->initialSingleVoltage() - initialSingleVoltage(0));
199 vInitABC(1, 0) = vInitABC(0, 0) * SHIFT_TO_PHASE_B;
200 vInitABC(2, 0) = vInitABC(0, 0) * SHIFT_TO_PHASE_C;
201
202 MatrixComp iInit = impedance.inverse() * vInitABC;
203 **mIntfCurrent = iInit.real();
204 **mIntfVoltage = vInitABC.real();
205
206 if (mNumVirtualNodes == 3)
207 mVirtualNodes[2]->setInitialVoltage(initialSingleVoltage(0));
208
209 SPDLOG_LOGGER_INFO(
210 mSLog,
211 "\n--- Initialization from powerflow ---"
212 "\nVoltage across: {:s}"
213 "\nCurrent: {:s}"
214 "\nTerminal 0 voltage: {:s}"
215 "\nTerminal 1 voltage: {:s}"
216 "\nVirtual Node 1 voltage: {:s}"
217 "\n--- Initialization from powerflow finished ---",
218 Logger::matrixToString(**mIntfVoltage),
219 Logger::matrixToString(**mIntfCurrent),
220 Logger::phasorToString(RMS3PH_TO_PEAK1PH * initialSingleVoltage(0)),
221 Logger::phasorToString(RMS3PH_TO_PEAK1PH * initialSingleVoltage(1)),
222 Logger::phasorToString(RMS3PH_TO_PEAK1PH *
223 mVirtualNodes[0]->initialSingleVoltage()));
224}
225
226void EMT::Ph3::Transformer::mnaParentInitialize(
227 Real omega, Real timeStep, Attribute<Matrix>::Ptr leftVector) {
228 SPDLOG_LOGGER_INFO(
229 mSLog,
230 "\nTerminal 0 connected to {:s} = sim node {:d}"
231 "\nTerminal 1 connected to {:s} = sim node {:d}",
232 mTerminals[0]->node()->name(), mTerminals[0]->node()->matrixNodeIndex(),
233 mTerminals[1]->node()->name(), mTerminals[1]->node()->matrixNodeIndex());
234}
235
236void EMT::Ph3::Transformer::mnaCompApplySystemMatrixStamp(
237 SparseMatrixRow &systemMatrix) {
238 // Ideal transformer equations
239 if (terminalNotGrounded(0)) {
240 Math::setMatrixElement(
241 systemMatrix, mVirtualNodes[0]->matrixNodeIndex(PhaseType::A),
242 mVirtualNodes[1]->matrixNodeIndex(PhaseType::A), -1.);
243 Math::setMatrixElement(
244 systemMatrix, mVirtualNodes[0]->matrixNodeIndex(PhaseType::B),
245 mVirtualNodes[1]->matrixNodeIndex(PhaseType::B), -1.);
246 Math::setMatrixElement(
247 systemMatrix, mVirtualNodes[0]->matrixNodeIndex(PhaseType::C),
248 mVirtualNodes[1]->matrixNodeIndex(PhaseType::C), -1.);
249
250 Math::setMatrixElement(systemMatrix,
251 mVirtualNodes[1]->matrixNodeIndex(PhaseType::A),
252 mVirtualNodes[0]->matrixNodeIndex(PhaseType::A), 1.);
253 Math::setMatrixElement(systemMatrix,
254 mVirtualNodes[1]->matrixNodeIndex(PhaseType::B),
255 mVirtualNodes[0]->matrixNodeIndex(PhaseType::B), 1.);
256 Math::setMatrixElement(systemMatrix,
257 mVirtualNodes[1]->matrixNodeIndex(PhaseType::C),
258 mVirtualNodes[0]->matrixNodeIndex(PhaseType::C), 1.);
259 }
260 if (terminalNotGrounded(1)) {
261 Math::setMatrixElement(systemMatrix, matrixNodeIndex(1, 0),
262 mVirtualNodes[1]->matrixNodeIndex(PhaseType::A),
263 (**mRatio).real());
264 Math::setMatrixElement(systemMatrix, matrixNodeIndex(1, 1),
265 mVirtualNodes[1]->matrixNodeIndex(PhaseType::B),
266 (**mRatio).real());
267 Math::setMatrixElement(systemMatrix, matrixNodeIndex(1, 2),
268 mVirtualNodes[1]->matrixNodeIndex(PhaseType::C),
269 (**mRatio).real());
270 Math::setMatrixElement(systemMatrix,
271 mVirtualNodes[1]->matrixNodeIndex(PhaseType::A),
272 matrixNodeIndex(1, 0), -(**mRatio).real());
273 Math::setMatrixElement(systemMatrix,
274 mVirtualNodes[1]->matrixNodeIndex(PhaseType::B),
275 matrixNodeIndex(1, 1), -(**mRatio).real());
276 Math::setMatrixElement(systemMatrix,
277 mVirtualNodes[1]->matrixNodeIndex(PhaseType::C),
278 matrixNodeIndex(1, 2), -(**mRatio).real());
279 }
280
281 // Add subcomps to system matrix
282 for (auto subcomp : mSubComponents)
283 if (auto mnasubcomp = std::dynamic_pointer_cast<MNAInterface>(subcomp))
284 mnasubcomp->mnaApplySystemMatrixStamp(systemMatrix);
285
286 if (terminalNotGrounded(0)) {
287 SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})",
288 Logger::complexToString(Complex(-1.0, 0)),
289 mVirtualNodes[0]->matrixNodeIndex(PhaseType::A),
290 mVirtualNodes[1]->matrixNodeIndex(PhaseType::A));
291 SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})",
292 Logger::complexToString(Complex(-1.0, 0)),
293 mVirtualNodes[0]->matrixNodeIndex(PhaseType::B),
294 mVirtualNodes[1]->matrixNodeIndex(PhaseType::B));
295 SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})",
296 Logger::complexToString(Complex(-1.0, 0)),
297 mVirtualNodes[0]->matrixNodeIndex(PhaseType::C),
298 mVirtualNodes[1]->matrixNodeIndex(PhaseType::C));
299
300 SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})",
301 Logger::complexToString(Complex(1.0, 0)),
302 mVirtualNodes[1]->matrixNodeIndex(PhaseType::A),
303 mVirtualNodes[0]->matrixNodeIndex(PhaseType::A));
304 SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})",
305 Logger::complexToString(Complex(1.0, 0)),
306 mVirtualNodes[1]->matrixNodeIndex(PhaseType::B),
307 mVirtualNodes[0]->matrixNodeIndex(PhaseType::B));
308 SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})",
309 Logger::complexToString(Complex(1.0, 0)),
310 mVirtualNodes[1]->matrixNodeIndex(PhaseType::C),
311 mVirtualNodes[0]->matrixNodeIndex(PhaseType::C));
312 }
313 if (terminalNotGrounded(1)) {
314 SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})",
315 Logger::complexToString(**mRatio), matrixNodeIndex(1, 0),
316 mVirtualNodes[1]->matrixNodeIndex(PhaseType::A));
317 SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})",
318 Logger::complexToString(**mRatio), matrixNodeIndex(1, 1),
319 mVirtualNodes[1]->matrixNodeIndex(PhaseType::B));
320 SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})",
321 Logger::complexToString(**mRatio), matrixNodeIndex(1, 2),
322 mVirtualNodes[1]->matrixNodeIndex(PhaseType::C));
323
324 SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})",
325 Logger::complexToString(-**mRatio),
326 mVirtualNodes[1]->matrixNodeIndex(PhaseType::A),
327 matrixNodeIndex(1, 0));
328 SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})",
329 Logger::complexToString(-**mRatio),
330 mVirtualNodes[1]->matrixNodeIndex(PhaseType::B),
331 matrixNodeIndex(1, 1));
332 SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})",
333 Logger::complexToString(-**mRatio),
334 mVirtualNodes[1]->matrixNodeIndex(PhaseType::C),
335 matrixNodeIndex(1, 2));
336 }
337}
338
339void EMT::Ph3::Transformer::mnaParentAddPreStepDependencies(
340 AttributeBase::List &prevStepDependencies,
341 AttributeBase::List &attributeDependencies,
342 AttributeBase::List &modifiedAttributes) {
343 prevStepDependencies.push_back(mIntfCurrent);
344 prevStepDependencies.push_back(mIntfVoltage);
345 modifiedAttributes.push_back(mRightVector);
346}
347
351
352void EMT::Ph3::Transformer::mnaParentAddPostStepDependencies(
353 AttributeBase::List &prevStepDependencies,
354 AttributeBase::List &attributeDependencies,
355 AttributeBase::List &modifiedAttributes,
356 Attribute<Matrix>::Ptr &leftVector) {
357 attributeDependencies.push_back(leftVector);
358 modifiedAttributes.push_back(mIntfVoltage);
359 modifiedAttributes.push_back(mIntfCurrent);
360}
361
362void EMT::Ph3::Transformer::mnaParentPostStep(
363 Real time, Int timeStepCount, Attribute<Matrix>::Ptr &leftVector) {
364 mnaCompUpdateVoltage(**leftVector);
365 mnaCompUpdateCurrent(**leftVector);
366}
367
368void EMT::Ph3::Transformer::mnaCompUpdateCurrent(const Matrix &leftVector) {
369 **mIntfCurrent = mSubInductor->intfCurrent();
370}
371
372void EMT::Ph3::Transformer::mnaCompUpdateVoltage(const Matrix &leftVector) {
373 // v1 - v0
374 **mIntfVoltage = Matrix::Zero(3, 1);
375 if (terminalNotGrounded(1)) {
376 (**mIntfVoltage)(0, 0) =
377 Math::realFromVectorElement(leftVector, matrixNodeIndex(1, 0));
378 (**mIntfVoltage)(1, 0) =
379 Math::realFromVectorElement(leftVector, matrixNodeIndex(1, 1));
380 (**mIntfVoltage)(2, 0) =
381 Math::realFromVectorElement(leftVector, matrixNodeIndex(1, 2));
382 }
383 if (terminalNotGrounded(0)) {
384 (**mIntfVoltage)(0, 0) =
385 (**mIntfVoltage)(0, 0) -
386 Math::realFromVectorElement(leftVector, matrixNodeIndex(0, 0));
387 (**mIntfVoltage)(1, 0) =
388 (**mIntfVoltage)(1, 0) -
389 Math::realFromVectorElement(leftVector, matrixNodeIndex(0, 1));
390 (**mIntfVoltage)(2, 0) =
391 (**mIntfVoltage)(2, 0) -
392 Math::realFromVectorElement(leftVector, matrixNodeIndex(0, 2));
393 }
394}
CPS::Base::Ph3::Transformer::mNominalVoltageEnd1
Real mNominalVoltageEnd1
Nominal voltage of primary side.
Definition Base_Ph3_Transformer.h:20
CPS::Base::Ph3::Transformer::mNominalVoltageEnd2
Real mNominalVoltageEnd2
Nominal voltage of secondary side.
Definition Base_Ph3_Transformer.h:22
CPS::Base::Ph3::Transformer::mRatio
const Attribute< Complex >::Ptr mRatio
Transformer ratio.
Definition Base_Ph3_Transformer.h:32
CPS::Base::Ph3::Transformer::mResistance
Matrix mResistance
Resistance [Ohm].
Definition Base_Ph3_Transformer.h:26
CPS::Base::Ph3::Transformer::mInductance
Matrix mInductance
Inductance [H].
Definition Base_Ph3_Transformer.h:28
CPS::Base::Ph3::Transformer::mRatedPower
Real mRatedPower
Rated Apparent Power [VA].
Definition Base_Ph3_Transformer.h:24
CPS::CompositePowerComp< Real >::addMNASubComponent
void addMNASubComponent(typename SimPowerComp< Real >::Ptr subc, MNA_SUBCOMP_TASK_ORDER preStepOrder, MNA_SUBCOMP_TASK_ORDER postStepOrder, Bool contributeToRightVector)
Definition CompositePowerComp.cpp:21
CPS::CompositePowerComp< Real >::mnaCompApplyRightSideVectorStamp
void mnaCompApplyRightSideVectorStamp(Matrix &rightVector) override
Definition CompositePowerComp.cpp:85
CPS::CompositePowerComp< Real >::CompositePowerComp
CompositePowerComp(String uid, String name, Bool hasPreStep, Bool hasPostStep, Logger::Level logLevel)
Definition CompositePowerComp.h:38
CPS::EMT::Ph3::Transformer::mnaParentAddPreStepDependencies
void mnaParentAddPreStepDependencies(AttributeBase::List &prevStepDependencies, AttributeBase::List &attributeDependencies, AttributeBase::List &modifiedAttributes) override
Add MNA pre step dependencies.
Definition EMT_Ph3_Transformer.cpp:339
CPS::EMT::Ph3::Transformer::Transformer
Transformer(String uid, String name, Logger::Level logLevel=Logger::Level::off, Bool withResistiveLosses=false)
Defines UID, name and logging level.
Definition EMT_Ph3_Transformer.cpp:13
CPS::EMT::Ph3::Transformer::mnaParentPostStep
void mnaParentPostStep(Real time, Int timeStepCount, Attribute< Matrix >::Ptr &leftVector) override
MNA post step operations.
Definition EMT_Ph3_Transformer.cpp:362
CPS::EMT::Ph3::Transformer::mnaCompApplySystemMatrixStamp
void mnaCompApplySystemMatrixStamp(SparseMatrixRow &systemMatrix) override
Stamps system matrix.
Definition EMT_Ph3_Transformer.cpp:236
CPS::EMT::Ph3::Transformer::mnaCompUpdateVoltage
void mnaCompUpdateVoltage(const Matrix &leftVector) override
Updates internal voltage variable of the component.
Definition EMT_Ph3_Transformer.cpp:372
CPS::EMT::Ph3::Transformer::clone
SimPowerComp< Real >::Ptr clone(String name) override
DEPRECATED: Delete method.
Definition EMT_Ph3_Transformer.cpp:32
CPS::EMT::Ph3::Transformer::initializeParentFromNodesAndTerminals
void initializeParentFromNodesAndTerminals(Real frequency) override
Initializes component from power flow data.
Definition EMT_Ph3_Transformer.cpp:146
CPS::EMT::Ph3::Transformer::createSubComponents
void createSubComponents() override
Constructs and registers MNA subcomponents; idempotent.
Definition EMT_Ph3_Transformer.cpp:60
CPS::EMT::Ph3::Transformer::mnaParentPreStep
void mnaParentPreStep(Real time, Int timeStepCount) override
MNA pre step operations.
Definition EMT_Ph3_Transformer.cpp:348
CPS::EMT::Ph3::Transformer::mnaCompUpdateCurrent
void mnaCompUpdateCurrent(const Matrix &leftVector) override
Updates internal current variable of the component.
Definition EMT_Ph3_Transformer.cpp:368
CPS::EMT::Ph3::Transformer::mnaParentAddPostStepDependencies
void mnaParentAddPostStepDependencies(AttributeBase::List &prevStepDependencies, AttributeBase::List &attributeDependencies, AttributeBase::List &modifiedAttributes, Attribute< Matrix >::Ptr &leftVector) override
Add MNA post step dependencies.
Definition EMT_Ph3_Transformer.cpp:352
CPS::EMT::Ph3::Transformer::setParameters
void setParameters(Real nomVoltageEnd1, Real nomVoltageEnd2, Real ratedPower, Real ratioAbs, Real ratioPhase, Matrix resistance, Matrix inductance)
Defines component parameters.
Definition EMT_Ph3_Transformer.cpp:40
CPS::EMT::Ph3::Transformer::mnaParentInitialize
void mnaParentInitialize(Real omega, Real timeStep, Attribute< Matrix >::Ptr leftVector) override
Initializes internal variables of the component.
Definition EMT_Ph3_Transformer.cpp:226
CPS::IdentifiedObject::mName
const Attribute< String >::Ptr mName
Human readable name.
Definition IdentifiedObject.h:26
CPS::IdentifiedObject::uid
String uid()
Returns unique id.
Definition IdentifiedObject.h:61
CPS::IdentifiedObject::type
String type()
Get component type (cross-platform)
Definition IdentifiedObject.h:63
CPS::IdentifiedObject::mAttributes
AttributeList::Ptr mAttributes
Attribute List.
Definition IdentifiedObject.h:22
CPS::MNASimPowerComp< Real >::mRightVector
Attribute< Matrix >::Ptr mRightVector
Definition MNASimPowerComp.h:26
CPS::Math::singlePhaseParameterToThreePhase
static Matrix singlePhaseParameterToThreePhase(Real parameter)
To convert single phase parameters to symmetrical three phase ones.
Definition MathUtils.cpp:211
CPS::SimPowerComp< Real >::mIntfCurrent
const Attribute< MatrixVar< Real > >::Ptr mIntfCurrent
Definition SimPowerComp.h:47
CPS::SimPowerComp< Real >::mTerminals
SimTerminal< Real >::List mTerminals
Definition SimPowerComp.h:21
CPS::SimPowerComp< Real >::node
SimNode< Real >::Ptr node(UInt index)
Definition SimPowerComp.cpp:37
CPS::SimPowerComp< Real >::mIntfVoltage
const Attribute< MatrixVar< Real > >::Ptr mIntfVoltage
Definition SimPowerComp.h:45
CPS::SimPowerComp< Real >::mVirtualNodes
SimNode< Real >::List mVirtualNodes
Definition SimPowerComp.h:23
CPS::SimPowerComp< Real >::mSubComponents
std::vector< std::shared_ptr< SimPowerComp< Real > > > mSubComponents
Definition SimPowerComp.h:33
CPS::TopologicalPowerComp::mLogLevel
Logger::Level mLogLevel
Component logger control for internal variables.
Definition TopologicalPowerComp.h:36
CPS::TopologicalPowerComp::mNumVirtualNodes
UInt mNumVirtualNodes
Determines the number of virtual or internal Nodes.
Definition TopologicalPowerComp.h:32
CPS::TopologicalPowerComp::mParametersSet
bool mParametersSet
Flag indicating that parameters are set via setParameters() function.
Definition TopologicalPowerComp.h:41
CPS::TopologicalPowerComp::mSLog
Logger::Log mSLog
Component logger.
Definition TopologicalPowerComp.h:34
Generated by doxygen 1.13.2