DPsim
Loading...
Searching...
No Matches
Reader.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 <CIMExceptions.hpp>
10#include <CIMModel.hpp>
11#include <IEC61970.hpp>
12#include <memory>
13
14#define READER_CPP
15#include <dpsim-models/CIM/Reader.h>
16
17using namespace CPS;
18using namespace CPS::CIM;
19
20using CIMPP::String;
21using CIMPP::UnitMultiplier;
22
23Reader::Reader(String name, Logger::Level logLevel,
24 Logger::Level componentLogLevel) {
25 mSLog = Logger::get(name + "_CIM", logLevel);
26
27 mModel = new CIMModel();
28 mModel->setDependencyCheckOff();
29 mComponentLogLevel = componentLogLevel;
30}
31
32Reader::~Reader() { delete mModel; }
33
34SystemTopology Reader::loadCIM(Real systemFrequency,
35 const std::list<CPS::String> &filenamesString,
36 Domain domain, PhaseType phase,
37 GeneratorType genType) {
38 std::list<fs::path> filenames;
39 for (auto f : filenamesString)
40 filenames.emplace_back(f);
41
42 return loadCIM(systemFrequency, filenames, domain, phase, genType);
43}
44
45// #### shunt component settings ####
47void Reader::setShuntCapacitor(Real v) {
48 mShuntCapacitorValue = v;
49 mSetShuntCapacitor = true;
50}
51
52void Reader::setShuntConductance(Real v) {
53 mShuntConductanceValue = v;
54 mSetShuntConductance = true;
55}
56
58void Reader::useProtectionSwitches(Bool value) {
59 mUseProtectionSwitches = value;
60}
61
62void Reader::setExtnetVoltageTargetUnit(VoltageTargetUnit unit) {
63 mExtnetVoltageTargetUnit = unit;
64}
65
66Real Reader::unitValue(Real value, CIMPP::UnitMultiplier mult) {
67 switch (mult) {
68 case UnitMultiplier::p:
69 value *= 1e-12;
70 break;
71 case UnitMultiplier::n:
72 value *= 1e-9;
73 break;
74 case UnitMultiplier::micro:
75 value *= 1e-6;
76 break;
77 case UnitMultiplier::m:
78 value *= 1e-3;
79 break;
80 case UnitMultiplier::c:
81 value *= 1e-2;
82 break;
83 case UnitMultiplier::d:
84 value *= 1e-1;
85 break;
86 case UnitMultiplier::k:
87 value *= 1e3;
88 break;
89 case UnitMultiplier::M:
90 value *= 1e6;
91 break;
92 case UnitMultiplier::G:
93 value *= 1e9;
94 break;
95 case UnitMultiplier::T:
96 value *= 1e12;
97 break;
98 default:
99 break;
100 }
101 return value;
102}
103
104Bool Reader::isSupportedConductingEquipment(BaseClass *obj) const {
105 if (!obj)
106 return false;
107
108 if (dynamic_cast<CIMPP::ACLineSegment *>(obj))
109 return true;
110
111 if (dynamic_cast<CIMPP::EnergyConsumer *>(obj))
112 return true;
113
114 if (dynamic_cast<CIMPP::PowerTransformer *>(obj))
115 return true;
116
117 if (dynamic_cast<CIMPP::SynchronousMachine *>(obj))
118 return true;
119
120 if (dynamic_cast<CIMPP::ExternalNetworkInjection *>(obj))
121 return true;
122
123 if (dynamic_cast<CIMPP::EquivalentShunt *>(obj))
124 return true;
125
126 if (dynamic_cast<CIMPP::Disconnector *>(obj))
127 return true;
128
129 if (dynamic_cast<CIMPP::Breaker *>(obj))
130 return true;
131
132 return false;
133}
134
135TopologicalPowerComp::Ptr Reader::mapComponent(BaseClass *obj) {
136 if (CIMPP::ACLineSegment *line = dynamic_cast<CIMPP::ACLineSegment *>(obj))
137 return mapACLineSegment(line);
138 if (CIMPP::EnergyConsumer *consumer =
139 dynamic_cast<CIMPP::EnergyConsumer *>(obj))
140 return mapEnergyConsumer(consumer);
141 if (CIMPP::PowerTransformer *trans =
142 dynamic_cast<CIMPP::PowerTransformer *>(obj))
143 return mapPowerTransformer(trans);
144 if (CIMPP::SynchronousMachine *syncMachine =
145 dynamic_cast<CIMPP::SynchronousMachine *>(obj))
146 return mapSynchronousMachine(syncMachine);
147 if (CIMPP::ExternalNetworkInjection *extnet =
148 dynamic_cast<CIMPP::ExternalNetworkInjection *>(obj))
149 return mapExternalNetworkInjection(extnet);
150 if (CIMPP::EquivalentShunt *shunt =
151 dynamic_cast<CIMPP::EquivalentShunt *>(obj))
152 return mapEquivalentShunt(shunt);
153 if (CIMPP::Disconnector *disc = dynamic_cast<CIMPP::Disconnector *>(obj))
154 return mapDisconnector(disc);
155 if (CIMPP::Breaker *cb = dynamic_cast<CIMPP::Breaker *>(obj))
156 return mapBreaker(cb);
157 return nullptr;
158}
159
160void Reader::addFiles(const fs::path &filename) {
161 if (!mModel->addCIMFile(filename.string()))
162 SPDLOG_LOGGER_ERROR(mSLog, "Failed to read file {}", filename);
163}
164
165void Reader::addFiles(const std::list<fs::path> &filenames) {
166 for (auto filename : filenames)
167 addFiles(filename);
168}
169
170void Reader::parseFiles() {
171 try {
172 mModel->parseFiles();
173 } catch (...) {
174 SPDLOG_LOGGER_ERROR(mSLog, "Failed to parse CIM files");
175 return;
176 }
177
178 SPDLOG_LOGGER_INFO(
179 mSLog,
180 "#### List of TopologicalNodes, associated Terminals and Equipment");
181 for (auto obj : mModel->Objects) {
182 if (CIMPP::TopologicalNode *topNode =
183 dynamic_cast<CIMPP::TopologicalNode *>(obj)) {
184 if (mDomain == Domain::EMT)
185 processTopologicalNode<Real>(topNode);
186 else
187 processTopologicalNode<Complex>(topNode);
188 }
189 }
190
191 // Collect voltage state variables associated to nodes that are used
192 // for various components.
193 SPDLOG_LOGGER_INFO(mSLog,
194 "#### List of Node voltages and Terminal power flow data");
195 for (auto obj : mModel->Objects) {
196 // Check if object is of class SvVoltage
197 if (CIMPP::SvVoltage *volt = dynamic_cast<CIMPP::SvVoltage *>(obj)) {
198 processSvVoltage(volt);
199 }
200 // Check if object is of class SvPowerFlow
201 else if (CIMPP::SvPowerFlow *flow =
202 dynamic_cast<CIMPP::SvPowerFlow *>(obj)) {
203 processSvPowerFlow(flow);
204 }
205 }
206
207 SPDLOG_LOGGER_INFO(mSLog, "#### Create other components");
208 for (auto obj : mModel->Objects) {
209
210 // Check if object is not TopologicalNode, SvVoltage or SvPowerFlow
211 if (!dynamic_cast<CIMPP::TopologicalNode *>(obj) &&
212 !dynamic_cast<CIMPP::SvVoltage *>(obj) &&
213 !dynamic_cast<CIMPP::SvPowerFlow *>(obj)) {
214
215 if (CIMPP::IdentifiedObject *idObj =
216 dynamic_cast<CIMPP::IdentifiedObject *>(obj)) {
217
218 // Check if object is already in equipment list
219 const auto &rid = cimString(idObj->mRID);
220 if (mPowerflowEquipment.find(rid) == mPowerflowEquipment.end()) {
221 TopologicalPowerComp::Ptr comp = mapComponent(obj);
222 if (comp)
223 mPowerflowEquipment.insert(std::make_pair(comp->uid(), comp));
224 }
225 }
226 }
227 }
228
229 SPDLOG_LOGGER_INFO(mSLog, "#### Check topology for unconnected components");
230 for (auto pfe : mPowerflowEquipment) {
231 auto c = pfe.second;
232
233 if (mDomain == Domain::EMT) {
234 if (SimPowerComp<Real>::Ptr powercomp =
235 std::dynamic_pointer_cast<SimPowerComp<Real>>(c)) {
236 if (powercomp->terminalNumberConnected() < powercomp->terminalNumber())
237 throw InvalidTopology();
238 }
239 } else {
240 if (SimPowerComp<Complex>::Ptr powercomp =
241 std::dynamic_pointer_cast<SimPowerComp<Complex>>(c)) {
242 if (powercomp->terminalNumberConnected() < powercomp->terminalNumber())
243 throw InvalidTopology();
244 }
245 }
246 }
247}
248
249SystemTopology Reader::loadCIM(Real systemFrequency, const fs::path &filename,
250 Domain domain, PhaseType phase,
251 GeneratorType genType) {
252 mFrequency = systemFrequency;
253 mOmega = 2 * PI * mFrequency;
254 mDomain = domain;
255 mPhase = phase;
256 mGeneratorType = genType;
257 addFiles(filename);
258 parseFiles();
259 return systemTopology();
260}
261
262SystemTopology Reader::loadCIM(Real systemFrequency,
263 const std::list<fs::path> &filenames,
264 Domain domain, PhaseType phase,
265 GeneratorType genType) {
266 mFrequency = systemFrequency;
267 mOmega = 2 * PI * mFrequency;
268 mDomain = domain;
269 mPhase = phase;
270 mGeneratorType = genType;
271 addFiles(filenames);
272 parseFiles();
273 return systemTopology();
274}
275
276void Reader::processSvVoltage(CIMPP::SvVoltage *volt) {
277 CIMPP::TopologicalNode *node = volt->TopologicalNode;
278 if (!node) {
279 SPDLOG_LOGGER_WARN(
280 mSLog, "SvVoltage references missing Topological Node, ignoring");
281 return;
282 }
283 const auto &nodeRid = cimString(node->mRID);
284 auto search = mPowerflowNodes.find(nodeRid);
285 if (search == mPowerflowNodes.end()) {
286 SPDLOG_LOGGER_WARN(mSLog,
287 "SvVoltage references Topological Node {}"
288 " missing from mTopNodes, ignoring",
289 nodeRid);
290 return;
291 }
292
293 Real voltageAbs = Reader::unitValue(volt->v.value, UnitMultiplier::k);
294
295 try {
296 SPDLOG_LOGGER_INFO(mSLog, " Angle={}", (float)volt->angle.value);
297 } catch (ReadingUninitializedField *e) {
298 volt->angle.value = 0;
299 std::cerr << "Uninitialized Angle for SVVoltage at "
300 << volt->TopologicalNode->name << ".Setting default value of "
301 << volt->angle.value << std::endl;
302 }
303 Real voltagePhase = volt->angle.value * PI / 180;
304 mPowerflowNodes[nodeRid]->setInitialVoltage(
305 std::polar<Real>(voltageAbs, voltagePhase));
306
307 SPDLOG_LOGGER_INFO(
308 mSLog, "Node {} MatrixNodeIndex {}: {} V, {} deg",
309 mPowerflowNodes[nodeRid]->uid(),
310 mPowerflowNodes[nodeRid]->matrixNodeIndex(),
311 std::abs(mPowerflowNodes[nodeRid]->initialSingleVoltage()),
312 std::arg(mPowerflowNodes[nodeRid]->initialSingleVoltage()) * 180 / PI);
313}
314
315void Reader::processSvPowerFlow(CIMPP::SvPowerFlow *flow) {
316 if (!flow) {
317 SPDLOG_LOGGER_WARN(mSLog, "Cannot process null SvPowerFlow, ignoring");
318 return;
319 }
320
321 CIMPP::Terminal *term = flow->Terminal;
322
323 if (!term) {
324 SPDLOG_LOGGER_WARN(mSLog,
325 "SvPowerFlow references missing Terminal, ignoring");
326 return;
327 }
328
329 const auto &terminalRid = cimString(term->mRID);
330 auto terminalIt = mPowerflowTerminals.find(terminalRid);
331
332 if (terminalIt == mPowerflowTerminals.end() || !terminalIt->second) {
333 SPDLOG_LOGGER_WARN(mSLog,
334 "SvPowerFlow references Terminal {} missing from "
335 "mPowerflowTerminals, ignoring",
336 terminalRid);
337 return;
338 }
339
340 terminalIt->second->setPower(
341 Complex(Reader::unitValue(flow->p.value, UnitMultiplier::M),
342 Reader::unitValue(flow->q.value, UnitMultiplier::M)));
343
344 SPDLOG_LOGGER_INFO(mSLog, "Terminal {}: {} W + j {} Var", terminalRid,
345 terminalIt->second->singleActivePower(),
346 terminalIt->second->singleReactivePower());
347}
348
349SystemTopology Reader::systemTopology() {
350 SystemTopology system(mFrequency);
351
352 for (auto comp : mPowerflowEquipment) {
353 system.addComponent(comp.second);
354 // TODO support Real
355 if (SimPowerComp<Complex>::Ptr powercomp =
356 std::dynamic_pointer_cast<SimPowerComp<Complex>>(comp.second)) {
357 for (auto term : powercomp->topologicalTerminals()) {
358 TopologicalNode::Ptr node = term->topologicalNodes();
359 //TopologicalNode::Ptr node = powercomp->topologicalTerminals().back()->topologicalNodes();
360 if (system.mComponentsAtNode.find(node) ==
361 system.mComponentsAtNode.end()) {
362 TopologicalPowerComp::List complist;
363 complist.push_back(powercomp);
364 system.mComponentsAtNode.insert(std::make_pair(node, complist));
365 } else {
366 system.mComponentsAtNode[node].push_back(powercomp);
367 }
368 }
369 }
370 }
371
372 system.mNodes.resize(mPowerflowNodes.size());
373
374 for (auto node : mPowerflowNodes) {
375 // The index of the node in the list should not matter anymore
376 //system.mNodes[node.second->matrixNodeIndex()] = node.second;
377 system.addNodeAt(node.second, node.second->matrixNodeIndex());
378 }
379
380 return system;
381}
382
383Matrix::Index Reader::mapTopologicalNode(String mrid) {
384 auto search = mPowerflowNodes.find(mrid);
385 if (search == mPowerflowNodes.end()) {
386 return -1;
387 }
388 return search->second->matrixNodeIndex();
389}
390
391TopologicalPowerComp::Ptr
392Reader::mapEnergyConsumer(CIMPP::EnergyConsumer *consumer) {
393 const auto &consumerName = cimString(consumer->name);
394 const auto &consumerRid = cimString(consumer->mRID);
395
396 SPDLOG_LOGGER_INFO(mSLog, " Found EnergyConsumer {}", consumerName);
397 if (mDomain == Domain::EMT) {
398 if (mPhase == PhaseType::ABC) {
399 return std::make_shared<EMT::Ph3::RXLoad>(consumerRid, consumerName,
400 mComponentLogLevel);
401 } else {
402 SPDLOG_LOGGER_INFO(mSLog, " RXLoad for EMT not implemented yet");
403 return std::make_shared<DP::Ph1::RXLoad>(consumerRid, consumerName,
404 mComponentLogLevel);
405 }
406 } else if (mDomain == Domain::SP) {
407 auto load = std::make_shared<SP::Ph1::Load>(consumerRid, consumerName,
408 mComponentLogLevel);
409
410 // Seed P/Q from SSH when present; this makes SSH win over any
411 // SvPowerFlow data (skip if no SSH file was loaded at all, so the
412 // SV-derived terminal-power fallback still applies).
413 if (consumer->p.initialized || consumer->q.initialized) {
414 Real p = 0;
415 Real q = 0;
416 if (consumer->p.initialized)
417 p = unitValue(consumer->p.value, UnitMultiplier::M);
418 if (consumer->q.initialized)
419 q = unitValue(consumer->q.value, UnitMultiplier::M);
420 Real baseVoltage = determineBaseVoltageAssociatedWithEquipment(consumer);
421 load->setParameters(p, q, baseVoltage);
422 }
423
424 load->modifyPowerFlowBusType(
425 PowerflowBusType::
426 PQ); // for powerflow solver set as PQ component as default
427 return load;
428 } else {
429 if (mUseProtectionSwitches)
430 return std::make_shared<DP::Ph1::RXLoadSwitch>(consumerRid, consumerName,
431 mComponentLogLevel);
432 else
433 return std::make_shared<DP::Ph1::RXLoad>(consumerRid, consumerName,
434 mComponentLogLevel);
435 }
436}
437
438TopologicalPowerComp::Ptr Reader::mapACLineSegment(CIMPP::ACLineSegment *line) {
439 const auto &lineName = cimString(line->name);
440 const auto &lineRid = cimString(line->mRID);
441
442 SPDLOG_LOGGER_INFO(mSLog,
443 " Found ACLineSegment {} r={} x={} bch={} gch={}",
444 lineName, (float)line->r.value, (float)line->x.value,
445 (float)line->bch.value, (float)line->gch.value);
446
447 Real resistance = line->r.value;
448 Real inductance = line->x.value / mOmega;
449
450 // By default there is always a small conductance to ground to
451 // avoid problems with floating nodes.
452 Real capacitance = mShuntCapacitorValue;
453 Real conductance = mShuntConductanceValue;
454
455 if (line->bch.value > 1e-9 && !mSetShuntCapacitor)
456 capacitance = Real(line->bch.value / mOmega);
457
458 if (line->gch.value > 1e-9 && !mSetShuntConductance)
459 conductance = Real(line->gch.value);
460
461 Real baseVoltage = determineBaseVoltageAssociatedWithEquipment(line);
462
463 if (mDomain == Domain::EMT) {
464 if (mPhase == PhaseType::ABC) {
465 Matrix res_3ph = CPS::Math::singlePhaseParameterToThreePhase(resistance);
466 Matrix ind_3ph = CPS::Math::singlePhaseParameterToThreePhase(inductance);
467 Matrix cap_3ph = CPS::Math::singlePhaseParameterToThreePhase(capacitance);
468 Matrix cond_3ph =
469 CPS::Math::singlePhaseParameterToThreePhase(conductance);
470
471 auto cpsLine = std::make_shared<EMT::Ph3::PiLine>(lineRid, lineName,
472 mComponentLogLevel);
473 cpsLine->setParameters(res_3ph, ind_3ph, cap_3ph, cond_3ph);
474 return cpsLine;
475 } else {
476 SPDLOG_LOGGER_INFO(mSLog, " PiLine for EMT not implemented yet");
477 auto cpsLine = std::make_shared<DP::Ph1::PiLine>(lineRid, lineName,
478 mComponentLogLevel);
479 cpsLine->setParameters(resistance, inductance, capacitance, conductance);
480 return cpsLine;
481 }
482 } else if (mDomain == Domain::SP) {
483 auto cpsLine = std::make_shared<SP::Ph1::PiLine>(lineRid, lineName,
484 mComponentLogLevel);
485 cpsLine->setParameters(resistance, inductance, capacitance, conductance);
486 cpsLine->setBaseVoltage(baseVoltage);
487 return cpsLine;
488 } else {
489 auto cpsLine = std::make_shared<DP::Ph1::PiLine>(lineRid, lineName,
490 mComponentLogLevel);
491 cpsLine->setParameters(resistance, inductance, capacitance, conductance);
492 return cpsLine;
493 }
494}
495
496TopologicalPowerComp::Ptr
497Reader::mapPowerTransformer(CIMPP::PowerTransformer *trans) {
498 const auto &transRid = cimString(trans->mRID);
499 if (trans->PowerTransformerEnd.size() != 2) {
500 SPDLOG_LOGGER_WARN(
501 mSLog,
502 "PowerTransformer {} does not have exactly two windings, ignoring",
503 cimString(trans->name));
504 return nullptr;
505 }
506 SPDLOG_LOGGER_INFO(mSLog, "Found PowerTransformer {}",
507 cimString(trans->name));
508
509 // assign transformer ends
510 CIMPP::PowerTransformerEnd *end1 = nullptr, *end2 = nullptr;
511 for (auto end : trans->PowerTransformerEnd) {
512 if (end->Terminal->sequenceNumber == 1)
513 end1 = end;
514 else if (end->Terminal->sequenceNumber == 2)
515 end2 = end;
516 else
517 return nullptr;
518 }
519
520 // setting default values for non-set resistances and reactances
521 SPDLOG_LOGGER_INFO(mSLog, " PowerTransformerEnd_1 {}",
522 cimString(end1->name));
523 SPDLOG_LOGGER_INFO(mSLog, " Srated={} Vrated={}",
524 (float)end1->ratedS.value, (float)end1->ratedU.value);
525 try {
526 SPDLOG_LOGGER_INFO(mSLog, " R={}", (float)end1->r.value);
527 } catch (ReadingUninitializedField *e1) {
528 end1->r.value = 1e-12;
529 SPDLOG_LOGGER_WARN(mSLog,
530 " Uninitialized value for PowerTrafoEnd1 setting "
531 "default value of R={}",
532 (float)end1->r.value);
533 }
534 try {
535 SPDLOG_LOGGER_INFO(mSLog, " X={}", (float)end1->x.value);
536 } catch (ReadingUninitializedField *e1) {
537 end1->x.value = 1e-12;
538 SPDLOG_LOGGER_WARN(mSLog,
539 " Uninitialized value for PowerTrafoEnd1 setting "
540 "default value of X={}",
541 (float)end1->x.value);
542 }
543 SPDLOG_LOGGER_INFO(mSLog, " PowerTransformerEnd_2 {}",
544 cimString(end2->name));
545 SPDLOG_LOGGER_INFO(mSLog, " Srated={} Vrated={}",
546 (float)end2->ratedS.value, (float)end2->ratedU.value);
547 try {
548 SPDLOG_LOGGER_INFO(mSLog, " R={}", (float)end2->r.value);
549 } catch (ReadingUninitializedField *e1) {
550 end2->r.value = 1e-12;
551 SPDLOG_LOGGER_WARN(mSLog,
552 " Uninitialized value for PowerTrafoEnd2 setting "
553 "default value of R={}",
554 (float)end2->r.value);
555 }
556 try {
557 SPDLOG_LOGGER_INFO(mSLog, " X={}", (float)end2->x.value);
558 } catch (ReadingUninitializedField *e1) {
559 end2->x.value = 1e-12;
560 SPDLOG_LOGGER_WARN(mSLog,
561 " Uninitialized value for PowerTrafoEnd2 setting "
562 "default value of X={}",
563 (float)end2->x.value);
564 }
565
566 if (end1->ratedS.value != end2->ratedS.value) {
567 SPDLOG_LOGGER_WARN(
568 mSLog,
569 " PowerTransformerEnds of {} come with distinct rated power values. "
570 "Using rated power of PowerTransformerEnd_1.",
571 cimString(trans->name));
572 }
573 Real ratedPower = unitValue(end1->ratedS.value, UnitMultiplier::M);
574 Real voltageNode1 = unitValue(end1->ratedU.value, UnitMultiplier::k);
575 Real voltageNode2 = unitValue(end2->ratedU.value, UnitMultiplier::k);
576
577 Real ratioAbsNominal = voltageNode1 / voltageNode2;
578 Real ratioAbs = ratioAbsNominal;
579
580 // use normalStep from RatioTapChanger
581 if (end1->RatioTapChanger) {
582 ratioAbs =
583 voltageNode1 / voltageNode2 *
584 (1 + (end1->RatioTapChanger->normalStep -
585 end1->RatioTapChanger->neutralStep) *
586 end1->RatioTapChanger->stepVoltageIncrement.value / 100);
587 }
588
589 // if corresponding SvTapStep available, use instead tap position from there
590 if (end1->RatioTapChanger) {
591 for (auto obj : mModel->Objects) {
592 auto tapStep = dynamic_cast<CIMPP::SvTapStep *>(obj);
593 if (tapStep && tapStep->TapChanger == end1->RatioTapChanger) {
594 ratioAbs =
595 voltageNode1 / voltageNode2 *
596 (1 + (tapStep->position - end1->RatioTapChanger->neutralStep) *
597 end1->RatioTapChanger->stepVoltageIncrement.value / 100);
598 }
599 }
600 }
601
602 // TODO: To be extracted from cim class
603 Real ratioPhase = 0;
604
605 // Calculate resistance and inductance referred to higher voltage side
606 Real resistance = 0;
607 Real inductance = 0;
608 if (voltageNode1 >= voltageNode2 && abs(end1->x.value) > 1e-12) {
609 inductance = end1->x.value / mOmega;
610 resistance = end1->r.value;
611 } else if (voltageNode1 >= voltageNode2 && abs(end2->x.value) > 1e-12) {
612 inductance = end2->x.value / mOmega * std::pow(ratioAbsNominal, 2);
613 resistance = end2->r.value * std::pow(ratioAbsNominal, 2);
614 } else if (voltageNode2 > voltageNode1 && abs(end2->x.value) > 1e-12) {
615 inductance = end2->x.value / mOmega;
616 resistance = end2->r.value;
617 } else if (voltageNode2 > voltageNode1 && abs(end1->x.value) > 1e-12) {
618 inductance = end1->x.value / mOmega / std::pow(ratioAbsNominal, 2);
619 resistance = end1->r.value / std::pow(ratioAbsNominal, 2);
620 }
621
622 if (mDomain == Domain::EMT) {
623 if (mPhase == PhaseType::ABC) {
624 Matrix resistance_3ph =
625 CPS::Math::singlePhaseParameterToThreePhase(resistance);
626 Matrix inductance_3ph =
627 CPS::Math::singlePhaseParameterToThreePhase(inductance);
628 Bool withResistiveLosses = resistance > 0;
629 auto transformer = std::make_shared<EMT::Ph3::Transformer>(
630 transRid, cimString(trans->name), mComponentLogLevel,
631 withResistiveLosses);
632 transformer->setParameters(voltageNode1, voltageNode2, ratedPower,
633 ratioAbs, ratioPhase, resistance_3ph,
634 inductance_3ph);
635 return transformer;
636 } else {
637 SPDLOG_LOGGER_INFO(mSLog, " Transformer for EMT not implemented yet");
638 return nullptr;
639 }
640 } else if (mDomain == Domain::SP) {
641 auto transformer = std::make_shared<SP::Ph1::Transformer>(
642 transRid, cimString(trans->name), mComponentLogLevel);
643 transformer->setParameters(voltageNode1, voltageNode2, ratedPower, ratioAbs,
644 ratioPhase, resistance, inductance);
645 Real baseVolt = voltageNode1 >= voltageNode2 ? voltageNode1 : voltageNode2;
646 transformer->setBaseVoltage(baseVolt);
647 return transformer;
648 } else {
649 Bool withResistiveLosses = resistance > 0;
650 auto transformer = std::make_shared<DP::Ph1::Transformer>(
651 transRid, cimString(trans->name), mComponentLogLevel,
652 withResistiveLosses);
653 transformer->setParameters(voltageNode1, voltageNode2, ratedPower, ratioAbs,
654 ratioPhase, resistance, inductance);
655 return transformer;
656 }
657}
658
659TopologicalPowerComp::Ptr
660Reader::mapSynchronousMachine(CIMPP::SynchronousMachine *machine) {
661 const auto &machineName = cimString(machine->name);
662 const auto &machineRid = cimString(machine->mRID);
663
664 SPDLOG_LOGGER_INFO(mSLog, " Found Synchronous machine {}", machineName);
665
666 if (mDomain == Domain::DP) {
667 SPDLOG_LOGGER_INFO(mSLog, " Create generator in DP domain.");
668 if (mGeneratorType == GeneratorType::TransientStability ||
669 mGeneratorType == GeneratorType::SG6aOrderVBR ||
670 mGeneratorType == GeneratorType::SG6bOrderVBR ||
671 mGeneratorType == GeneratorType::SG4OrderVBR ||
672 mGeneratorType == GeneratorType::SG3OrderVBR ||
673 mGeneratorType == GeneratorType::SG4OrderPCM ||
674 mGeneratorType == GeneratorType::SG4OrderTPM ||
675 mGeneratorType == GeneratorType::SG6OrderPCM) {
676
677 Real ratedPower = unitValue(machine->ratedS.value, UnitMultiplier::M);
678 Real ratedVoltage = unitValue(machine->ratedU.value, UnitMultiplier::k);
679
680 for (auto obj : mModel->Objects) {
681 // Check if object is not TopologicalNode, SvVoltage or SvPowerFlow
682 if (CIMPP::SynchronousMachineTimeConstantReactance *genDyn =
683 dynamic_cast<CIMPP::SynchronousMachineTimeConstantReactance *>(
684 obj)) {
685 if (cimString(genDyn->SynchronousMachine->mRID) == machineRid) {
686 // stator
687 Real Rs = genDyn->statorResistance.value;
688 Real Ll = genDyn->statorLeakageReactance.value;
689
690 // reactances
691 Real Ld = genDyn->xDirectSync.value;
692 Real Lq = genDyn->xQuadSync.value;
693 Real Ld_t = genDyn->xDirectTrans.value;
694 Real Lq_t = genDyn->xQuadTrans.value;
695 Real Ld_s = genDyn->xDirectSubtrans.value;
696 Real Lq_s = genDyn->xQuadSubtrans.value;
697
698 // time constants
699 Real Td0_t = genDyn->tpdo.value;
700 Real Tq0_t = genDyn->tpqo.value;
701 Real Td0_s = genDyn->tppdo.value;
702 Real Tq0_s = genDyn->tppqo.value;
703
704 // inertia
705 Real H = genDyn->inertia.value;
706
707 // not available in CIM -> set to 0, as actually no impact on machine equations
708 Int poleNum = 0;
709 Real nomFieldCurr = 0;
710
711 if (mGeneratorType == GeneratorType::TransientStability) {
712 SPDLOG_LOGGER_DEBUG(mSLog,
713 " GeneratorType is TransientStability.");
714 auto gen = DP::Ph1::SynchronGeneratorTrStab::make(
715 machineRid, machineName, mComponentLogLevel);
716 gen->setStandardParametersPU(ratedPower, ratedVoltage, mFrequency,
717 Ld_t, H);
718 return gen;
719 } else if (mGeneratorType == GeneratorType::SG6aOrderVBR) {
720 SPDLOG_LOGGER_DEBUG(
721 mSLog, " GeneratorType is SynchronGenerator6aOrderVBR.");
722 auto gen = std::make_shared<DP::Ph1::SynchronGenerator6aOrderVBR>(
723 machineRid, machineName, mComponentLogLevel);
724 gen->setOperationalParametersPerUnit(
725 ratedPower, ratedVoltage, mFrequency, H, Ld, Lq, Ll, Ld_t,
726 Lq_t, Td0_t, Tq0_t, Ld_s, Lq_s, Td0_s, Tq0_s);
727 return gen;
728 } else if (mGeneratorType == GeneratorType::SG6bOrderVBR) {
729 SPDLOG_LOGGER_DEBUG(
730 mSLog, " GeneratorType is SynchronGenerator6bOrderVBR.");
731 auto gen = std::make_shared<DP::Ph1::SynchronGenerator6bOrderVBR>(
732 machineRid, machineName, mComponentLogLevel);
733 gen->setOperationalParametersPerUnit(
734 ratedPower, ratedVoltage, mFrequency, H, Ld, Lq, Ll, Ld_t,
735 Lq_t, Td0_t, Tq0_t, Ld_s, Lq_s, Td0_s, Tq0_s);
736 return gen;
737 } else if (mGeneratorType == GeneratorType::SG5OrderVBR) {
738 SPDLOG_LOGGER_DEBUG(
739 mSLog, " GeneratorType is SynchronGenerator5OrderVBR.");
740 auto gen = std::make_shared<DP::Ph1::SynchronGenerator5OrderVBR>(
741 machineRid, machineName, mComponentLogLevel);
742 gen->setOperationalParametersPerUnit(
743 ratedPower, ratedVoltage, mFrequency, H, Ld, Lq, Ll, Ld_t,
744 Lq_t, Td0_t, Tq0_t, Ld_s, Lq_s, Td0_s, Tq0_s, 0.0);
745 return gen;
746 } else if (mGeneratorType == GeneratorType::SG4OrderVBR) {
747 SPDLOG_LOGGER_DEBUG(
748 mSLog, " GeneratorType is SynchronGenerator4OrderVBR.");
749 auto gen = std::make_shared<DP::Ph1::SynchronGenerator4OrderVBR>(
750 machineRid, machineName, mComponentLogLevel);
751 gen->setOperationalParametersPerUnit(ratedPower, ratedVoltage,
752 mFrequency, H, Ld, Lq, Ll,
753 Ld_t, Lq_t, Td0_t, Tq0_t);
754 return gen;
755 } else if (mGeneratorType == GeneratorType::SG3OrderVBR) {
756 SPDLOG_LOGGER_DEBUG(
757 mSLog, " GeneratorType is SynchronGenerator3OrderVBR.");
758 auto gen = std::make_shared<DP::Ph1::SynchronGenerator3OrderVBR>(
759 machineRid, machineName, mComponentLogLevel);
760 gen->setOperationalParametersPerUnit(ratedPower, ratedVoltage,
761 mFrequency, H, Ld, Lq, Ll,
762 Ld_t, Td0_t);
763 return gen;
764 } else if (mGeneratorType == GeneratorType::SG4OrderPCM) {
765 SPDLOG_LOGGER_DEBUG(
766 mSLog, " GeneratorType is SynchronGenerator4OrderPCM.");
767 auto gen = std::make_shared<DP::Ph1::SynchronGenerator4OrderPCM>(
768 machineRid, machineName, mComponentLogLevel);
769 gen->setOperationalParametersPerUnit(ratedPower, ratedVoltage,
770 mFrequency, H, Ld, Lq, Ll,
771 Ld_t, Lq_t, Td0_t, Tq0_t);
772 return gen;
773 } else if (mGeneratorType == GeneratorType::SG4OrderTPM) {
774 SPDLOG_LOGGER_DEBUG(
775 mSLog, " GeneratorType is SynchronGenerator4OrderTPM.");
776 auto gen = std::make_shared<DP::Ph1::SynchronGenerator4OrderTPM>(
777 machineRid, machineName, mComponentLogLevel);
778 gen->setOperationalParametersPerUnit(ratedPower, ratedVoltage,
779 mFrequency, H, Ld, Lq, Ll,
780 Ld_t, Lq_t, Td0_t, Tq0_t);
781 return gen;
782 } else if (mGeneratorType == GeneratorType::SG6OrderPCM) {
783 SPDLOG_LOGGER_DEBUG(
784 mSLog, " GeneratorType is SynchronGenerator6OrderPCM.");
785 auto gen = std::make_shared<DP::Ph1::SynchronGenerator6OrderPCM>(
786 machineRid, machineName, mComponentLogLevel);
787 gen->setOperationalParametersPerUnit(
788 ratedPower, ratedVoltage, mFrequency, H, Ld, Lq, Ll, Ld_t,
789 Lq_t, Td0_t, Tq0_t, Ld_s, Lq_s, Td0_s, Tq0_s);
790 return gen;
791 }
792 }
793 }
794 }
795 } else if (mGeneratorType == GeneratorType::IdealVoltageSource) {
796 SPDLOG_LOGGER_DEBUG(mSLog, " GeneratorType is IdealVoltageSource.");
797 return std::make_shared<DP::Ph1::SynchronGeneratorIdeal>(
798 machineRid, machineName, mComponentLogLevel);
799 } else if (mGeneratorType == GeneratorType::None) {
800 throw SystemError("GeneratorType is None. Specify!");
801 } else {
802 throw SystemError("GeneratorType setting unfeasible.");
803 }
804 } else if (mDomain == Domain::SP) {
805 SPDLOG_LOGGER_INFO(mSLog, " Create generator in SP domain.");
806 if (mGeneratorType == GeneratorType::TransientStability ||
807 mGeneratorType == GeneratorType::SG6aOrderVBR ||
808 mGeneratorType == GeneratorType::SG6bOrderVBR ||
809 mGeneratorType == GeneratorType::SG5OrderVBR ||
810 mGeneratorType == GeneratorType::SG4OrderVBR ||
811 mGeneratorType == GeneratorType::SG3OrderVBR) {
812
813 Real ratedPower = unitValue(machine->ratedS.value, UnitMultiplier::M);
814 Real ratedVoltage = unitValue(machine->ratedU.value, UnitMultiplier::k);
815
816 for (auto obj : mModel->Objects) {
817 // Check if object is not TopologicalNode, SvVoltage or SvPowerFlow
818 if (CIMPP::SynchronousMachineTimeConstantReactance *genDyn =
819 dynamic_cast<CIMPP::SynchronousMachineTimeConstantReactance *>(
820 obj)) {
821 if (cimString(genDyn->SynchronousMachine->mRID) == machineRid) {
822 // stator
823 Real Rs = genDyn->statorResistance.value;
824 Real Ll = genDyn->statorLeakageReactance.value;
825
826 // reactances
827 Real Ld = genDyn->xDirectSync.value;
828 Real Lq = genDyn->xQuadSync.value;
829 Real Ld_t = genDyn->xDirectTrans.value;
830 Real Lq_t = genDyn->xQuadTrans.value;
831 Real Ld_s = genDyn->xDirectSubtrans.value;
832 Real Lq_s = genDyn->xQuadSubtrans.value;
833
834 // time constants
835 Real Td0_t = genDyn->tpdo.value;
836 Real Tq0_t = genDyn->tpqo.value;
837 Real Td0_s = genDyn->tppdo.value;
838 Real Tq0_s = genDyn->tppqo.value;
839
840 // inertia
841 Real H = genDyn->inertia.value;
842
843 // not available in CIM -> set to 0, as actually no impact on machine equations
844 Int poleNum = 0;
845 Real nomFieldCurr = 0;
846
847 if (mGeneratorType == GeneratorType::TransientStability) {
848 SPDLOG_LOGGER_DEBUG(mSLog,
849 " GeneratorType is TransientStability.");
850 auto gen = SP::Ph1::SynchronGeneratorTrStab::make(
851 machineRid, machineName, mComponentLogLevel);
852 gen->setStandardParametersPU(ratedPower, ratedVoltage, mFrequency,
853 Ld_t, H);
854 return gen;
855 } else if (mGeneratorType == GeneratorType::SG6aOrderVBR) {
856 SPDLOG_LOGGER_DEBUG(
857 mSLog, " GeneratorType is SynchronGenerator6aOrderVBR.");
858 auto gen = std::make_shared<SP::Ph1::SynchronGenerator6aOrderVBR>(
859 machineRid, machineName, mComponentLogLevel);
860 gen->setOperationalParametersPerUnit(
861 ratedPower, ratedVoltage, mFrequency, H, Ld, Lq, Ll, Ld_t,
862 Lq_t, Td0_t, Tq0_t, Ld_s, Lq_s, Td0_s, Tq0_s);
863 return gen;
864 } else if (mGeneratorType == GeneratorType::SG6bOrderVBR) {
865 SPDLOG_LOGGER_DEBUG(
866 mSLog, " GeneratorType is SynchronGenerator6bOrderVBR.");
867 auto gen = std::make_shared<SP::Ph1::SynchronGenerator6bOrderVBR>(
868 machineRid, machineName, mComponentLogLevel);
869 gen->setOperationalParametersPerUnit(
870 ratedPower, ratedVoltage, mFrequency, H, Ld, Lq, Ll, Ld_t,
871 Lq_t, Td0_t, Tq0_t, Ld_s, Lq_s, Td0_s, Tq0_s);
872 return gen;
873 } else if (mGeneratorType == GeneratorType::SG5OrderVBR) {
874 SPDLOG_LOGGER_DEBUG(
875 mSLog, " GeneratorType is SynchronGenerator5OrderVBR.");
876 auto gen = std::make_shared<SP::Ph1::SynchronGenerator5OrderVBR>(
877 machineRid, machineName, mComponentLogLevel);
878 gen->setOperationalParametersPerUnit(
879 ratedPower, ratedVoltage, mFrequency, H, Ld, Lq, Ll, Ld_t,
880 Lq_t, Td0_t, Tq0_t, Ld_s, Lq_s, Td0_s, Tq0_s, 0.0);
881 return gen;
882 } else if (mGeneratorType == GeneratorType::SG4OrderVBR) {
883 SPDLOG_LOGGER_DEBUG(
884 mSLog, " GeneratorType is SynchronGenerator4OrderVBR.");
885 auto gen = std::make_shared<SP::Ph1::SynchronGenerator4OrderVBR>(
886 machineRid, machineName, mComponentLogLevel);
887 gen->setOperationalParametersPerUnit(ratedPower, ratedVoltage,
888 mFrequency, H, Ld, Lq, Ll,
889 Ld_t, Lq_t, Td0_t, Tq0_t);
890 return gen;
891 } else if (mGeneratorType == GeneratorType::SG3OrderVBR) {
892 SPDLOG_LOGGER_DEBUG(
893 mSLog, " GeneratorType is SynchronGenerator3OrderVBR.");
894 auto gen = std::make_shared<SP::Ph1::SynchronGenerator3OrderVBR>(
895 machineRid, machineName, mComponentLogLevel);
896 gen->setOperationalParametersPerUnit(ratedPower, ratedVoltage,
897 mFrequency, H, Ld, Lq, Ll,
898 Ld_t, Td0_t);
899 return gen;
900 }
901 }
902 }
903 }
904 } else if (mGeneratorType == GeneratorType::PVNode) {
905 SPDLOG_LOGGER_DEBUG(mSLog, " GeneratorType is PVNode.");
906 for (auto obj : mModel->Objects) {
907 if (CIMPP::GeneratingUnit *genUnit =
908 dynamic_cast<CIMPP::GeneratingUnit *>(obj)) {
909 for (auto syncGen : genUnit->RotatingMachine) {
910 if (cimString(syncGen->mRID) == machineRid) {
911 // Check whether relevant input data are set, otherwise set default values
912 Real setPointActivePower = 0;
913 Real setPointVoltage = 0;
914 Real maximumReactivePower = 1e12;
915 PowerflowBusType busType = PowerflowBusType::PV;
916 try {
917 setPointActivePower =
918 unitValue(genUnit->initialP.value, UnitMultiplier::M);
919 SPDLOG_LOGGER_INFO(mSLog, " setPointActivePower={}",
920 setPointActivePower);
921 } catch (ReadingUninitializedField *e) {
922 std::cerr
923 << "Uninitalized setPointActivePower for GeneratingUnit "
924 << machineName << ". Using default value of "
925 << setPointActivePower << std::endl;
926 }
927 if (machine->RegulatingControl) {
928 setPointVoltage =
929 unitValue(machine->RegulatingControl->targetValue.value,
930 UnitMultiplier::k);
931 SPDLOG_LOGGER_INFO(mSLog, " setPointVoltage={}",
932 setPointVoltage);
933 } else {
934 // No RegulatingControl -> not voltage-regulating; map as PQ instead of guessing a PV voltage.
935 busType = PowerflowBusType::PQ;
936 SPDLOG_LOGGER_INFO(
937 mSLog,
938 " No RegulatingControl for {}, mapping as PQ generator",
939 machineName);
940 }
941 try {
942 maximumReactivePower =
943 unitValue(machine->maxQ.value, UnitMultiplier::M);
944 SPDLOG_LOGGER_INFO(mSLog, " maximumReactivePower={}",
945 maximumReactivePower);
946 } catch (ReadingUninitializedField *e) {
947 std::cerr
948 << "Uninitalized maximumReactivePower for GeneratingUnit "
949 << machineName << ". Using default value of "
950 << maximumReactivePower << std::endl;
951 }
952
953 auto gen = std::make_shared<SP::Ph1::SynchronGenerator>(
954 machineRid, machineName, mComponentLogLevel);
955 gen->setParameters(
956 unitValue(machine->ratedS.value, UnitMultiplier::M),
957 unitValue(machine->ratedU.value, UnitMultiplier::k),
958 setPointActivePower, setPointVoltage, busType);
959 gen->setBaseVoltage(
960 unitValue(machine->ratedU.value, UnitMultiplier::k));
961 return gen;
962 }
963 }
964 }
965 }
966 SPDLOG_LOGGER_INFO(mSLog, "no corresponding initial power for {}",
967 machineName);
968 return std::make_shared<SP::Ph1::SynchronGenerator>(
969 machineRid, machineName, mComponentLogLevel);
970 } else if (mGeneratorType == GeneratorType::None) {
971 throw SystemError("GeneratorType is None. Specify!");
972 } else {
973 throw SystemError("GeneratorType setting unfeasible.");
974 }
975 } else {
976 SPDLOG_LOGGER_INFO(mSLog, " Create generator in EMT domain.");
977 if (mGeneratorType == GeneratorType::FullOrder ||
978 mGeneratorType == GeneratorType::FullOrderVBR ||
979 mGeneratorType == GeneratorType::SG3OrderVBR ||
980 mGeneratorType == GeneratorType::SG4OrderVBR ||
981 mGeneratorType == GeneratorType::SG6aOrderVBR ||
982 mGeneratorType == GeneratorType::SG6bOrderVBR) {
983
984 Real ratedPower = unitValue(machine->ratedS.value, UnitMultiplier::M);
985 Real ratedVoltage = unitValue(machine->ratedU.value, UnitMultiplier::k);
986
987 for (auto obj : mModel->Objects) {
988 // Check if object is not TopologicalNode, SvVoltage or SvPowerFlow
989 if (CIMPP::SynchronousMachineTimeConstantReactance *genDyn =
990 dynamic_cast<CIMPP::SynchronousMachineTimeConstantReactance *>(
991 obj)) {
992 if (cimString(genDyn->SynchronousMachine->mRID) == machineRid) {
993
994 // stator
995 Real Rs = genDyn->statorResistance.value;
996 Real Ll = genDyn->statorLeakageReactance.value;
997
998 // reactances
999 Real Ld = genDyn->xDirectSync.value;
1000 Real Lq = genDyn->xQuadSync.value;
1001 Real Ld_t = genDyn->xDirectTrans.value;
1002 Real Lq_t = genDyn->xQuadTrans.value;
1003 Real Ld_s = genDyn->xDirectSubtrans.value;
1004 Real Lq_s = genDyn->xQuadSubtrans.value;
1005
1006 // time constants
1007 Real Td0_t = genDyn->tpdo.value;
1008 Real Tq0_t = genDyn->tpqo.value;
1009 Real Td0_s = genDyn->tppdo.value;
1010 Real Tq0_s = genDyn->tppqo.value;
1011
1012 // inertia
1013 Real H = genDyn->inertia.value;
1014
1015 // not available in CIM -> set to 0, as actually no impact on machine equations
1016 Int poleNum = 0;
1017 Real nomFieldCurr = 0;
1018
1019 if (mGeneratorType == GeneratorType::FullOrder) {
1020 SPDLOG_LOGGER_DEBUG(mSLog, " GeneratorType is FullOrder.");
1021 auto gen = std::make_shared<EMT::Ph3::SynchronGeneratorDQTrapez>(
1022 machineRid, machineName, mComponentLogLevel);
1023 gen->setParametersOperationalPerUnit(
1024 ratedPower, ratedVoltage, mFrequency, poleNum, nomFieldCurr,
1025 Rs, Ld, Lq, Ld_t, Lq_t, Ld_s, Lq_s, Ll, Td0_t, Tq0_t, Td0_s,
1026 Tq0_s, H);
1027 return gen;
1028 } else if (mGeneratorType == GeneratorType::FullOrderVBR) {
1029 SPDLOG_LOGGER_DEBUG(mSLog, " GeneratorType is FullOrderVBR.");
1030 auto gen = std::make_shared<EMT::Ph3::SynchronGeneratorVBR>(
1031 machineRid, machineName, mComponentLogLevel);
1032 gen->setBaseAndOperationalPerUnitParameters(
1033 ratedPower, ratedVoltage, mFrequency, poleNum, nomFieldCurr,
1034 Rs, Ld, Lq, Ld_t, Lq_t, Ld_s, Lq_s, Ll, Td0_t, Tq0_t, Td0_s,
1035 Tq0_s, H);
1036 return gen;
1037 } else if (mGeneratorType == GeneratorType::SG6aOrderVBR) {
1038 SPDLOG_LOGGER_DEBUG(
1039 mSLog, " GeneratorType is SynchronGenerator6aOrderVBR.");
1040 auto gen =
1041 std::make_shared<EMT::Ph3::SynchronGenerator6aOrderVBR>(
1042 machineRid, machineName, mComponentLogLevel);
1043 gen->setOperationalParametersPerUnit(
1044 ratedPower, ratedVoltage, mFrequency, H, Ld, Lq, Ll, Ld_t,
1045 Lq_t, Td0_t, Tq0_t, Ld_s, Lq_s, Td0_s, Tq0_s);
1046 return gen;
1047 } else if (mGeneratorType == GeneratorType::SG6bOrderVBR) {
1048 SPDLOG_LOGGER_DEBUG(
1049 mSLog, " GeneratorType is SynchronGenerator6bOrderVBR.");
1050 auto gen =
1051 std::make_shared<EMT::Ph3::SynchronGenerator6bOrderVBR>(
1052 machineRid, machineName, mComponentLogLevel);
1053 gen->setOperationalParametersPerUnit(
1054 ratedPower, ratedVoltage, mFrequency, H, Ld, Lq, Ll, Ld_t,
1055 Lq_t, Td0_t, Tq0_t, Ld_s, Lq_s, Td0_s, Tq0_s);
1056 return gen;
1057 } else if (mGeneratorType == GeneratorType::SG5OrderVBR) {
1058 SPDLOG_LOGGER_DEBUG(
1059 mSLog, " GeneratorType is SynchronGenerator5OrderVBR.");
1060 auto gen = std::make_shared<EMT::Ph3::SynchronGenerator5OrderVBR>(
1061 machineRid, machineName, mComponentLogLevel);
1062 gen->setOperationalParametersPerUnit(
1063 ratedPower, ratedVoltage, mFrequency, H, Ld, Lq, Ll, Ld_t,
1064 Lq_t, Td0_t, Tq0_t, Ld_s, Lq_s, Td0_s, Tq0_s, 0.0);
1065 return gen;
1066 } else if (mGeneratorType == GeneratorType::SG4OrderVBR) {
1067 SPDLOG_LOGGER_DEBUG(
1068 mSLog, " GeneratorType is SynchronGenerator4OrderVBR.");
1069 auto gen = std::make_shared<EMT::Ph3::SynchronGenerator4OrderVBR>(
1070 machineRid, machineName, mComponentLogLevel);
1071 gen->setOperationalParametersPerUnit(ratedPower, ratedVoltage,
1072 mFrequency, H, Ld, Lq, Ll,
1073 Ld_t, Lq_t, Td0_t, Tq0_t);
1074 return gen;
1075 } else if (mGeneratorType == GeneratorType::SG3OrderVBR) {
1076 SPDLOG_LOGGER_DEBUG(
1077 mSLog, " GeneratorType is SynchronGenerator3OrderVBR.");
1078 auto gen = std::make_shared<EMT::Ph3::SynchronGenerator3OrderVBR>(
1079 machineRid, machineName, mComponentLogLevel);
1080 gen->setOperationalParametersPerUnit(ratedPower, ratedVoltage,
1081 mFrequency, H, Ld, Lq, Ll,
1082 Ld_t, Td0_t);
1083 return gen;
1084 }
1085 }
1086 }
1087 }
1088 } else if (mGeneratorType == GeneratorType::IdealVoltageSource) {
1089 SPDLOG_LOGGER_DEBUG(mSLog, " GeneratorType is IdealVoltageSource.");
1090 return std::make_shared<EMT::Ph3::SynchronGeneratorIdeal>(
1091 machineRid, machineName, mComponentLogLevel,
1092 GeneratorType::IdealVoltageSource);
1093 } else if (mGeneratorType == GeneratorType::IdealCurrentSource) {
1094 SPDLOG_LOGGER_DEBUG(mSLog, " GeneratorType is IdealCurrentSource.");
1095 return std::make_shared<EMT::Ph3::SynchronGeneratorIdeal>(
1096 machineRid, machineName, mComponentLogLevel,
1097 GeneratorType::IdealCurrentSource);
1098 } else if (mGeneratorType == GeneratorType::None) {
1099 throw SystemError("GeneratorType is None. Specify!");
1100 } else {
1101 throw SystemError("GeneratorType setting unfeasible.");
1102 }
1103 }
1104 return nullptr;
1105}
1106
1107TopologicalPowerComp::Ptr
1108Reader::mapExternalNetworkInjection(CIMPP::ExternalNetworkInjection *extnet) {
1109 SPDLOG_LOGGER_INFO(mSLog, "Found External Network Injection {}",
1110 cimString(extnet->name));
1111
1112 Real baseVoltage = determineBaseVoltageAssociatedWithEquipment(extnet);
1113
1114 if (mDomain == Domain::EMT) {
1115 if (mPhase == PhaseType::ABC) {
1116 return std::make_shared<EMT::Ph3::NetworkInjection>(
1117 extnet->mRID, extnet->name, mComponentLogLevel);
1118 } else {
1119 throw SystemError(
1120 "Mapping of ExternalNetworkInjection for EMT::Ph1 not existent!");
1121 return nullptr;
1122 }
1123 } else if (mDomain == Domain::SP) {
1124 if (mPhase == PhaseType::Single) {
1125 auto cpsextnet = std::make_shared<SP::Ph1::NetworkInjection>(
1126 extnet->mRID, extnet->name, mComponentLogLevel);
1127 cpsextnet->modifyPowerFlowBusType(
1128 PowerflowBusType::
1129 VD); // for powerflow solver set as VD component as default
1130 cpsextnet->setBaseVoltage(baseVoltage);
1131
1132 try {
1133 if (extnet->RegulatingControl) {
1134 // targetValueUnitMultiplier is uninitialized if unset, so Auto guesses by magnitude
1135 Real rawTarget = extnet->RegulatingControl->targetValue.value;
1136 Bool perUnit;
1137 switch (mExtnetVoltageTargetUnit) {
1138 case VoltageTargetUnit::PerUnit:
1139 perUnit = true;
1140 break;
1141 case VoltageTargetUnit::Absolute:
1142 perUnit = false;
1143 break;
1144 case VoltageTargetUnit::Auto:
1145 default:
1146 perUnit = std::abs(rawTarget) >= 0.5 && std::abs(rawTarget) <= 1.5;
1147 break;
1148 }
1149 Real voltageSetPoint = perUnit
1150 ? rawTarget * baseVoltage
1151 : unitValue(rawTarget, UnitMultiplier::k);
1152 SPDLOG_LOGGER_INFO(mSLog, " Voltage set-point={}",
1153 voltageSetPoint);
1154 cpsextnet->setParameters(voltageSetPoint);
1155 } else {
1156 SPDLOG_LOGGER_INFO(
1157 mSLog, " No voltage set-point defined. Using 1 per unit.");
1158 cpsextnet->setParameters(1. * baseVoltage);
1159 }
1160 } catch (ReadingUninitializedField *e) {
1161 std::cerr << "Ignore incomplete RegulatingControl" << std::endl;
1162 }
1163
1164 return cpsextnet;
1165 } else {
1166 throw SystemError(
1167 "Mapping of ExternalNetworkInjection for SP::Ph3 not existent!");
1168 return nullptr;
1169 }
1170 } else {
1171 if (mPhase == PhaseType::Single) {
1172 return std::make_shared<DP::Ph1::NetworkInjection>(
1173 extnet->mRID, extnet->name, mComponentLogLevel);
1174 } else {
1175 throw SystemError(
1176 "Mapping of ExternalNetworkInjection for DP::Ph3 not existent!");
1177 return nullptr;
1178 }
1179 }
1180}
1181
1182TopologicalPowerComp::Ptr
1183Reader::mapEquivalentShunt(CIMPP::EquivalentShunt *shunt) {
1184 SPDLOG_LOGGER_INFO(mSLog, "Found shunt {}", cimString(shunt->name));
1185
1186 Real baseVoltage = determineBaseVoltageAssociatedWithEquipment(shunt);
1187
1188 auto cpsShunt = std::make_shared<SP::Ph1::Shunt>(shunt->mRID, shunt->name,
1189 mComponentLogLevel);
1190 cpsShunt->setParameters(shunt->g.value, shunt->b.value);
1191 cpsShunt->setBaseVoltage(baseVoltage);
1192 return cpsShunt;
1193}
1194
1195TopologicalPowerComp::Ptr Reader::mapDisconnector(CIMPP::Disconnector *disc) {
1196
1197 SPDLOG_LOGGER_INFO(mSLog, "Found Disconnector {} with status {}",
1198 cimString(disc->name), (bool)disc->open.value);
1199
1200 Real openResistance = 1e12;
1201 Real closedResistance = 1e-6;
1202
1203 Bool status = disc->open.value;
1204
1205 if (mPhase == PhaseType::ABC) {
1206 Matrix openResistance3Ph =
1207 CPS::Math::singlePhaseParameterToThreePhase(openResistance);
1208 Matrix closedResistance3Ph =
1209 CPS::Math::singlePhaseParameterToThreePhase(closedResistance);
1210
1211 if (mDomain == Domain::EMT) {
1212 auto cpsSwitch = std::make_shared<EMT::Ph3::Switch>(
1213 disc->mRID, disc->name, mComponentLogLevel);
1214
1215 cpsSwitch->setParameters(openResistance3Ph, closedResistance3Ph);
1216
1217 if (status == true) {
1218 cpsSwitch->openSwitch();
1219 } else {
1220 cpsSwitch->closeSwitch();
1221 }
1222
1223 return cpsSwitch;
1224 } else if (mDomain == Domain::DP) {
1225 SPDLOG_LOGGER_INFO(mSLog,
1226 "Mapping of Disconnector for DP::Ph3 not existent!");
1227
1228 return nullptr;
1229 } else {
1230 SPDLOG_LOGGER_INFO(mSLog,
1231 "Mapping of Disconnector for SP::Ph3 not existent!");
1232 return nullptr;
1233 }
1234 } else {
1235 std::shared_ptr<CPS::TopologicalPowerComp> topoSwitch;
1236 std::shared_ptr<CPS::Base::Ph1::Switch> cpsSwitch;
1237
1238 if (mDomain == Domain::EMT) {
1239 auto sw = std::make_shared<EMT::Ph1::Switch>(disc->mRID, disc->name,
1240 mComponentLogLevel);
1241 cpsSwitch = sw;
1242 topoSwitch = sw;
1243 } else if (mDomain == Domain::DP) {
1244 auto sw = std::make_shared<DP::Ph1::Switch>(disc->mRID, disc->name,
1245 mComponentLogLevel);
1246 cpsSwitch = sw;
1247 topoSwitch = sw;
1248 } else {
1249 auto sw = std::make_shared<SP::Ph1::Switch>(disc->mRID, disc->name,
1250 mComponentLogLevel);
1251 cpsSwitch = sw;
1252 topoSwitch = sw;
1253 }
1254
1255 cpsSwitch->setParameters(openResistance, closedResistance);
1256 if (status) {
1257 cpsSwitch->open();
1258 } else {
1259 cpsSwitch->close();
1260 }
1261
1262 return topoSwitch;
1263 }
1264}
1265
1266TopologicalPowerComp::Ptr Reader::mapBreaker(CIMPP::Breaker *cb) {
1267 SPDLOG_LOGGER_INFO(mSLog, "Found Breaker {} with status {}",
1268 cimString(cb->name), (bool)cb->open.value);
1269
1270 Real openResistance = 1e12;
1271 Real closedResistance = 1e-6;
1272
1273 Bool status = cb->open.value;
1274
1275 if (mPhase == PhaseType::ABC) {
1276 Matrix openResistance3Ph =
1277 CPS::Math::singlePhaseParameterToThreePhase(openResistance);
1278 Matrix closedResistance3Ph =
1279 CPS::Math::singlePhaseParameterToThreePhase(closedResistance);
1280
1281 if (mDomain == Domain::EMT) {
1282 auto cpsSwitch = std::make_shared<EMT::Ph3::Switch>(cb->mRID, cb->name,
1283 mComponentLogLevel);
1284
1285 cpsSwitch->setParameters(openResistance3Ph, closedResistance3Ph);
1286
1287 if (status == true) {
1288 cpsSwitch->openSwitch();
1289 } else {
1290 cpsSwitch->closeSwitch();
1291 }
1292
1293 return cpsSwitch;
1294 } else if (mDomain == Domain::DP) {
1295 SPDLOG_LOGGER_INFO(mSLog, "Mapping of Breaker for DP::Ph3 not existent!");
1296
1297 return nullptr;
1298 } else {
1299 SPDLOG_LOGGER_INFO(mSLog, "Mapping of Breaker for SP::Ph3 not existent!");
1300 return nullptr;
1301 }
1302 } else {
1303 std::shared_ptr<CPS::TopologicalPowerComp> topoSwitch;
1304 std::shared_ptr<CPS::Base::Ph1::Switch> cpsSwitch;
1305
1306 if (mDomain == Domain::EMT) {
1307 auto sw = std::make_shared<EMT::Ph1::Switch>(cb->mRID, cb->name,
1308 mComponentLogLevel);
1309 cpsSwitch = sw;
1310 topoSwitch = sw;
1311 } else if (mDomain == Domain::DP) {
1312 auto sw = std::make_shared<DP::Ph1::Switch>(cb->mRID, cb->name,
1313 mComponentLogLevel);
1314 cpsSwitch = sw;
1315 topoSwitch = sw;
1316 } else {
1317 auto sw = std::make_shared<SP::Ph1::Switch>(cb->mRID, cb->name,
1318 mComponentLogLevel);
1319 cpsSwitch = sw;
1320 topoSwitch = sw;
1321 }
1322
1323 cpsSwitch->setParameters(openResistance, closedResistance);
1324 if (status) {
1325 cpsSwitch->open();
1326 } else {
1327 cpsSwitch->close();
1328 }
1329
1330 return topoSwitch;
1331 }
1332}
1333
1334Real Reader::determineBaseVoltageAssociatedWithEquipment(
1335 CIMPP::ConductingEquipment *equipment) {
1336 Real baseVoltage = 0;
1337
1338 // first look for baseVolt object to determine baseVoltage
1339 for (auto obj : mModel->Objects) {
1340 if (CIMPP::BaseVoltage *baseVolt =
1341 dynamic_cast<CIMPP::BaseVoltage *>(obj)) {
1342 for (auto comp : baseVolt->ConductingEquipment) {
1343 if (cimString(comp->name) == cimString(equipment->name)) {
1344 baseVoltage =
1345 unitValue(baseVolt->nominalVoltage.value, UnitMultiplier::k);
1346 }
1347 }
1348 }
1349 }
1350 // as second option take baseVoltage of topologicalNode where equipment is connected to
1351 if (baseVoltage == 0) {
1352 for (auto obj : mModel->Objects) {
1353 if (CIMPP::TopologicalNode *topNode =
1354 dynamic_cast<CIMPP::TopologicalNode *>(obj)) {
1355 for (auto term : topNode->Terminal) {
1356 if (cimString(term->ConductingEquipment->name) ==
1357 cimString(equipment->name)) {
1358 baseVoltage = unitValue(topNode->BaseVoltage->nominalVoltage.value,
1359 UnitMultiplier::k);
1360 }
1361 }
1362 }
1363 }
1364 }
1365
1366 return baseVoltage;
1367}
1368
1369template <typename VarType>
1370void Reader::processTopologicalNode(CIMPP::TopologicalNode *topNode) {
1371 // Add this node to global node list and assign simulation node incrementally.
1372
1373 if (!topNode) {
1374 SPDLOG_LOGGER_WARN(mSLog, "Cannot process null TopologicalNode, ignoring");
1375 return;
1376 }
1377
1378 Bool hasSupportedEquipment = false;
1379
1380 for (auto term : topNode->Terminal) {
1381 if (!term || !term->ConductingEquipment)
1382 continue;
1383
1384 if (isSupportedConductingEquipment(term->ConductingEquipment)) {
1385 hasSupportedEquipment = true;
1386 break;
1387 }
1388 }
1389
1390 if (!hasSupportedEquipment) {
1391 SPDLOG_LOGGER_WARN(
1392 mSLog,
1393 "Skipping TopologicalNode {} ({}) because it has no terminals "
1394 "connected to supported equipment",
1395 cimString(topNode->name), cimString(topNode->mRID));
1396 return;
1397 }
1398
1399 int matrixNodeIndex = Int(mPowerflowNodes.size());
1400 const auto &nodeRid = cimString(topNode->mRID);
1401 mPowerflowNodes[nodeRid] = SimNode<VarType>::make(
1402 nodeRid, cimString(topNode->name), matrixNodeIndex, mPhase);
1403
1404 if (mPhase == PhaseType::ABC) {
1405 SPDLOG_LOGGER_INFO(
1406 mSLog, "TopologicalNode {} phase A as simulation node {} ", nodeRid,
1407 mPowerflowNodes[nodeRid]->matrixNodeIndex(PhaseType::A));
1408 SPDLOG_LOGGER_INFO(
1409 mSLog, "TopologicalNode {} phase B as simulation node {}", nodeRid,
1410 mPowerflowNodes[nodeRid]->matrixNodeIndex(PhaseType::B));
1411 SPDLOG_LOGGER_INFO(
1412 mSLog, "TopologicalNode {} phase C as simulation node {}", nodeRid,
1413 mPowerflowNodes[nodeRid]->matrixNodeIndex(PhaseType::C));
1414 } else
1415 SPDLOG_LOGGER_INFO(mSLog,
1416 "TopologicalNode id: {}, name: {} as simulation node {}",
1417 nodeRid, cimString(topNode->name),
1418 mPowerflowNodes[nodeRid]->matrixNodeIndex());
1419
1420 for (auto term : topNode->Terminal) {
1421 if (!term) {
1422 SPDLOG_LOGGER_WARN(
1423 mSLog, "TopologicalNode {} contains a null Terminal, ignoring",
1424 nodeRid);
1425 continue;
1426 }
1427
1428 const auto &termRid = cimString(term->mRID);
1429 auto cpsTerm = SimTerminal<VarType>::make(termRid);
1430 mPowerflowTerminals.insert(std::make_pair(termRid, cpsTerm));
1431 cpsTerm->setNode(
1432 std::dynamic_pointer_cast<SimNode<VarType>>(mPowerflowNodes[nodeRid]));
1433
1434 if (!term->sequenceNumber.initialized)
1435 term->sequenceNumber = 1;
1436
1437 SPDLOG_LOGGER_INFO(mSLog, " Terminal {}, sequenceNumber {}", termRid,
1438 (int)term->sequenceNumber);
1439
1440 // Try to process Equipment connected to Terminal.
1441 CIMPP::ConductingEquipment *equipment = term->ConductingEquipment;
1442 if (!equipment) {
1443 SPDLOG_LOGGER_WARN(mSLog, "Terminal {} has no Equipment, ignoring!",
1444 termRid);
1445 continue;
1446 }
1447
1448 // Unsupported Equipment check
1449 if (!isSupportedConductingEquipment(equipment)) {
1450 SPDLOG_LOGGER_WARN(
1451 mSLog,
1452 "Terminal {} references unsupported ConductingEquipment {}, ignoring",
1453 termRid, cimString(equipment->mRID));
1454 continue;
1455 }
1456
1457 // Insert Equipment if it does not exist in the map and add reference to Terminal.
1458 // This could be optimized because the Equipment is searched twice.
1459 const auto &equipmentRid = cimString(equipment->mRID);
1460 if (mPowerflowEquipment.find(equipmentRid) == mPowerflowEquipment.end()) {
1461 TopologicalPowerComp::Ptr comp = mapComponent(equipment);
1462 if (comp) {
1463 mPowerflowEquipment.insert(std::make_pair(equipmentRid, comp));
1464 } else {
1465 SPDLOG_LOGGER_WARN(mSLog, "Could not map equipment {}", equipmentRid);
1466 continue;
1467 }
1468 }
1469
1470 auto pfEquipment = mPowerflowEquipment.at(equipmentRid);
1471 if (pfEquipment == nullptr) {
1472 SPDLOG_LOGGER_ERROR(mSLog, "Equipment {} is null in equipment list",
1473 equipmentRid);
1474 throw SystemError("Equipment is null in equipment list.");
1475 }
1476 std::dynamic_pointer_cast<SimPowerComp<VarType>>(pfEquipment)
1477 ->setTerminalAt(std::dynamic_pointer_cast<SimTerminal<VarType>>(
1478 mPowerflowTerminals[termRid]),
1479 term->sequenceNumber - 1);
1480
1481 SPDLOG_LOGGER_INFO(mSLog, " Added Terminal {} to Equipment {}",
1482 termRid, equipmentRid);
1483 }
1484}
1485
1486template void
1487Reader::processTopologicalNode<Real>(CIMPP::TopologicalNode *topNode);
1488template void
1489Reader::processTopologicalNode<Complex>(CIMPP::TopologicalNode *topNode);
CPS::CIM::Reader::setShuntConductance
void setShuntConductance(Real v)
set shunt conductance value
Definition Reader.cpp:52
CPS::CIM::Reader::loadCIM
SystemTopology loadCIM(Real systemFrequency, const fs::path &filename, Domain domain=Domain::DP, PhaseType phase=PhaseType::Single, GeneratorType genType=GeneratorType::None)
Parses data from CIM files into the CPS data structure.
Definition Reader.cpp:249
CPS::CIM::Reader::useProtectionSwitches
void useProtectionSwitches(Bool value=true)
If set, some components like loads include protection switches.
Definition Reader.cpp:58
CPS::CIM::Reader::Reader
Reader(String name, Logger::Level logLevel=Logger::Level::info, Logger::Level componentLogLevel=Logger::Level::off)
Definition Reader.cpp:23
CPS::CIM::Reader::setShuntCapacitor
void setShuntCapacitor(Real v)
set shunt capacitor value
Definition Reader.cpp:47
CPS::Math::singlePhaseParameterToThreePhase
static Matrix singlePhaseParameterToThreePhase(Real parameter)
To convert single phase parameters to symmetrical three phase ones.
Definition MathUtils.cpp:224
Generated by doxygen 1.13.2