DPsim
Loading...
Searching...
No Matches
EMTComponents.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.h>
10#include <dpsim-models/CSVReader.h>
11#include <dpsim-models/EMT/EMT_DC_Capacitor.h>
12#include <dpsim-models/EMT/EMT_DC_CurrentSource.h>
13#include <dpsim-models/EMT/EMT_DC_Inductor.h>
14#include <dpsim-models/EMT/EMT_DC_PiLine.h>
15#include <dpsim-models/EMT/EMT_DC_Resistor.h>
16#include <dpsim-models/EMT/EMT_DC_VoltageSource.h>
17#include <dpsim-models/EMT/EMT_Ph3_GFL.h>
18#include <dpsim-models/EMT/EMT_Ph3_SSN_GFL.h>
19#include <dpsim-models/EMT/EMT_Ph3_SSN_GFL_Split.h>
20#include <dpsim-models/IdentifiedObject.h>
21#include <dpsim/RealTimeSimulation.h>
22#include <dpsim/Simulation.h>
23#include <dpsim/pybind/EMTComponents.h>
24#include <dpsim/pybind/Utils.h>
25
26#ifdef WITH_JSON
27#include <nlohmann/json.hpp>
28using json = nlohmann::json;
29#endif
30
31namespace py = pybind11;
32using namespace pybind11::literals;
33
34namespace {
35
36void addEMTDCComponents(py::module_ mEMTDC) {
37 py::class_<CPS::EMT::DC::VoltageSource,
38 std::shared_ptr<CPS::EMT::DC::VoltageSource>,
39 CPS::SimPowerComp<CPS::Real>>(mEMTDC, "VoltageSource",
40 py::multiple_inheritance())
41 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
42 "loglevel"_a = CPS::Logger::Level::off)
43 .def("set_parameters", &CPS::EMT::DC::VoltageSource::setParameters,
44 "voltage"_a)
45 .def("connect", &CPS::EMT::DC::VoltageSource::connect)
46 .def_property_readonly("V_ref",
47 createAttributeGetter<CPS::Real>("V_ref"));
48
49 py::class_<CPS::EMT::DC::CurrentSource,
50 std::shared_ptr<CPS::EMT::DC::CurrentSource>,
51 CPS::SimPowerComp<CPS::Real>>(mEMTDC, "CurrentSource",
52 py::multiple_inheritance())
53 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
54 "loglevel"_a = CPS::Logger::Level::off)
55 .def("set_parameters", &CPS::EMT::DC::CurrentSource::setParameters,
56 "current"_a)
57 .def("connect", &CPS::EMT::DC::CurrentSource::connect)
58 .def_property_readonly("I_ref",
59 createAttributeGetter<CPS::Real>("I_ref"));
60
61 py::class_<CPS::EMT::DC::Resistor, std::shared_ptr<CPS::EMT::DC::Resistor>,
62 CPS::SimPowerComp<CPS::Real>>(mEMTDC, "Resistor",
63 py::multiple_inheritance())
64 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
65 "loglevel"_a = CPS::Logger::Level::off)
66 .def("set_parameters", &CPS::EMT::DC::Resistor::setParameters,
67 "resistance"_a)
68 .def("connect", &CPS::EMT::DC::Resistor::connect)
69 .def_property_readonly("R", createAttributeGetter<CPS::Real>("R"));
70
71 py::class_<CPS::EMT::DC::Capacitor, std::shared_ptr<CPS::EMT::DC::Capacitor>,
72 CPS::SimPowerComp<CPS::Real>>(mEMTDC, "Capacitor",
73 py::multiple_inheritance())
74 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
75 "loglevel"_a = CPS::Logger::Level::off)
76 .def("set_parameters", &CPS::EMT::DC::Capacitor::setParameters,
77 "capacitance"_a)
78 .def("connect", &CPS::EMT::DC::Capacitor::connect)
79 .def_property_readonly("C", createAttributeGetter<CPS::Real>("C"))
80 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
81
82 py::class_<CPS::EMT::DC::Inductor, std::shared_ptr<CPS::EMT::DC::Inductor>,
83 CPS::SimPowerComp<CPS::Real>>(mEMTDC, "Inductor",
84 py::multiple_inheritance())
85 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
86 "loglevel"_a = CPS::Logger::Level::off)
87 .def("set_parameters", &CPS::EMT::DC::Inductor::setParameters,
88 "inductance"_a, "initial_current"_a = 0.0)
89 .def("connect", &CPS::EMT::DC::Inductor::connect)
90 .def_property_readonly("L", createAttributeGetter<CPS::Real>("L"))
91 .def_property_readonly("initial_current",
92 createAttributeGetter<CPS::Real>("i_init"))
93 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
94
95 py::class_<CPS::EMT::DC::PiLine, std::shared_ptr<CPS::EMT::DC::PiLine>,
96 CPS::SimPowerComp<CPS::Real>>(mEMTDC, "PiLine",
97 py::multiple_inheritance())
98 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
99 "loglevel"_a = CPS::Logger::Level::off)
100 .def("set_parameters", &CPS::EMT::DC::PiLine::setParameters,
101 "series_resistance"_a, "series_inductance"_a,
102 "parallel_capacitance"_a = 0.0, "parallel_conductance"_a = 0.0,
103 "initial_current"_a = 0.0)
104 .def("connect", &CPS::EMT::DC::PiLine::connect)
105 .def_property_readonly("series_resistance",
106 createAttributeGetter<CPS::Real>("R_series"))
107 .def_property_readonly("series_inductance",
108 createAttributeGetter<CPS::Real>("L_series"))
109 .def_property_readonly("parallel_capacitance",
110 createAttributeGetter<CPS::Real>("C_parallel"))
111 .def_property_readonly("parallel_conductance",
112 createAttributeGetter<CPS::Real>("G_parallel"))
113 .def_property_readonly("initial_current",
114 createAttributeGetter<CPS::Real>("i_init"));
115}
116
117} // namespace
118
119void addEMTComponents(py::module_ mEMT) {
120 py::class_<CPS::EMT::SimNode, std::shared_ptr<CPS::EMT::SimNode>,
121 CPS::TopologicalNode>(mEMT, "SimNode", py::module_local())
122 .def(py::init<std::string>())
123 .def(py::init<std::string, CPS::PhaseType>())
124 .def(py::init<std::string, CPS::PhaseType,
125 const std::vector<CPS::Complex>>())
126 .def("set_initial_voltage",
127 py::overload_cast<CPS::MatrixComp>(
128 &CPS::EMT::SimNode::setInitialVoltage, py::const_))
129 .def("set_initial_voltage",
130 py::overload_cast<CPS::Complex>(
131 &CPS::EMT::SimNode::setInitialVoltage, py::const_))
132 .def("set_initial_voltage",
133 py::overload_cast<CPS::Complex, int>(
134 &CPS::EMT::SimNode::setInitialVoltage, py::const_))
135 .def_readonly_static("gnd", &CPS::EMT::SimNode::GND);
136
137 py::module_ mEMTDC =
138 mEMT.def_submodule("dc", "scalar electromagnetic-transient DC models");
139 addEMTDCComponents(mEMTDC);
140
141 py::module mEMTPh1 = mEMT.def_submodule(
142 "ph1", "single phase electromagnetic-transient models");
143 addEMTPh1Components(mEMTPh1);
144 py::module mEMTPh3 =
145 mEMT.def_submodule("ph3", "three phase electromagnetic-transient models");
146 addEMTPh3Components(mEMTPh3);
147}
148
149void addEMTPh1Components(py::module_ mEMTPh1) {
150 py::class_<CPS::EMT::Ph1::CurrentSource,
151 std::shared_ptr<CPS::EMT::Ph1::CurrentSource>,
152 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "CurrentSource",
153 py::multiple_inheritance())
154 .def(py::init<std::string>())
155 .def(py::init<std::string, CPS::Logger::Level>())
156 .def("set_parameters", &CPS::EMT::Ph1::CurrentSource::setParameters,
157 "I_ref"_a, "f_src"_a = -1)
158 .def("connect", &CPS::EMT::Ph1::CurrentSource::connect)
159 .def_property("I_ref", createAttributeGetter<CPS::Complex>("I_ref"),
160 createAttributeSetter<CPS::Complex>("I_ref"))
161 .def_property("f_src", createAttributeGetter<CPS::Real>("f_src"),
162 createAttributeSetter<CPS::Real>("f_src"));
163
164 py::class_<CPS::EMT::Ph1::VoltageSource,
165 std::shared_ptr<CPS::EMT::Ph1::VoltageSource>,
166 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "VoltageSource",
167 py::multiple_inheritance())
168 .def(py::init<std::string>())
169 .def(py::init<std::string, CPS::Logger::Level>())
170 .def("set_parameters", &CPS::EMT::Ph1::VoltageSource::setParameters,
171 "V_ref"_a, "f_src"_a = -1)
172 .def("connect", &CPS::EMT::Ph1::VoltageSource::connect)
173 .def_property("V_ref", createAttributeGetter<CPS::Complex>("V_ref"),
174 createAttributeSetter<CPS::Complex>("V_ref"))
175 .def_property("f_src", createAttributeGetter<CPS::Real>("f_src"),
176 createAttributeSetter<CPS::Real>("f_src"));
177
178 py::class_<CPS::EMT::Ph1::Resistor, std::shared_ptr<CPS::EMT::Ph1::Resistor>,
179 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "Resistor",
180 py::multiple_inheritance())
181 .def(py::init<std::string>())
182 .def(py::init<std::string, CPS::Logger::Level>())
183 .def("set_parameters", &CPS::EMT::Ph1::Resistor::setParameters, "R"_a)
184 .def("connect", &CPS::EMT::Ph1::Resistor::connect)
185 .def_property("R", createAttributeGetter<CPS::Real>("R"),
186 createAttributeSetter<CPS::Real>("R"));
187
188 py::class_<CPS::EMT::Ph1::Capacitor,
189 std::shared_ptr<CPS::EMT::Ph1::Capacitor>,
190 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "Capacitor",
191 py::multiple_inheritance())
192 .def(py::init<std::string>())
193 .def(py::init<std::string, CPS::Logger::Level>())
194 .def("set_parameters", &CPS::EMT::Ph1::Capacitor::setParameters, "C"_a)
195 .def("connect", &CPS::EMT::Ph1::Capacitor::connect)
196 .def_property("C", createAttributeGetter<CPS::Real>("C"),
197 createAttributeSetter<CPS::Real>("C"));
198
199 py::class_<CPS::EMT::Ph1::Inductor, std::shared_ptr<CPS::EMT::Ph1::Inductor>,
200 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "Inductor",
201 py::multiple_inheritance())
202 .def(py::init<std::string>())
203 .def(py::init<std::string, CPS::Logger::Level>())
204 .def("set_parameters", &CPS::EMT::Ph1::Inductor::setParameters, "L"_a)
205 .def("connect", &CPS::EMT::Ph1::Inductor::connect)
206 .def_property("L", createAttributeGetter<CPS::Real>("L"),
207 createAttributeSetter<CPS::Real>("L"));
208
209 py::class_<CPS::EMT::Ph1::Switch, std::shared_ptr<CPS::EMT::Ph1::Switch>,
210 CPS::SimPowerComp<CPS::Real>, CPS::Base::Ph1::Switch>(
211 mEMTPh1, "Switch", py::multiple_inheritance())
212 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
213 "loglevel"_a = CPS::Logger::Level::off)
214 .def("set_parameters", &CPS::EMT::Ph1::Switch::setParameters,
215 "open_resistance"_a, "closed_resistance"_a,
216 "closed"_a = false) // cppcheck-suppress assignBoolToPointer
217 .def("open", &CPS::EMT::Ph1::Switch::open)
218 .def("close", &CPS::EMT::Ph1::Switch::close)
219 .def("connect", &CPS::EMT::Ph1::Switch::connect);
220
221 py::class_<CPS::EMT::Ph1::SSN::Full_Serial_RLC,
222 std::shared_ptr<CPS::EMT::Ph1::SSN::Full_Serial_RLC>,
223 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "Full_Serial_RLC",
224 py::multiple_inheritance())
225 .def(py::init<std::string>())
226 .def(py::init<std::string, CPS::Logger::Level>())
227 .def("set_parameters",
228 &CPS::EMT::Ph1::SSN::Full_Serial_RLC::setParameters, "R"_a, "L"_a,
229 "C"_a)
230 .def("connect", &CPS::EMT::Ph1::SSN::Full_Serial_RLC::connect)
231 .def_property("R", createAttributeGetter<CPS::Real>("R"),
232 createAttributeSetter<CPS::Real>("R"))
233 .def_property("L", createAttributeGetter<CPS::Real>("L"),
234 createAttributeSetter<CPS::Real>("L"))
235 .def_property("C", createAttributeGetter<CPS::Real>("C"),
236 createAttributeSetter<CPS::Real>("C"));
237
238 py::class_<CPS::EMT::Ph1::SSNTypeI2T,
239 std::shared_ptr<CPS::EMT::Ph1::SSNTypeI2T>,
240 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "SSNTypeI2T",
241 py::multiple_inheritance())
242 .def(py::init<std::string>())
243 .def(py::init<std::string, CPS::Logger::Level>())
244 .def("set_parameters", &CPS::EMT::Ph1::SSNTypeI2T::setParameters, "A"_a,
245 "B"_a, "C"_a, "D"_a)
246 .def("manual_init", &CPS::EMT::Ph1::SSNTypeI2T::manualInit,
247 "initialState"_a, "initialInput"_a, "initialOldInput"_a,
248 "initCurr"_a, "initVol"_a)
249 .def("connect", &CPS::EMT::Ph1::SSNTypeI2T::connect)
250 .def_property("mA", createAttributeGetter<CPS::Matrix>("mA"),
251 createAttributeSetter<CPS::Matrix>("mA"))
252 .def_property("mB", createAttributeGetter<CPS::Matrix>("mB"),
253 createAttributeSetter<CPS::Matrix>("mB"))
254 .def_property("mC", createAttributeGetter<CPS::Matrix>("mC"),
255 createAttributeSetter<CPS::Matrix>("mC"))
256 .def_property("mD", createAttributeGetter<CPS::Matrix>("mD"),
257 createAttributeSetter<CPS::Matrix>("mD"))
258 .def_property("mdA", createAttributeGetter<CPS::Matrix>("mdA"),
259 createAttributeSetter<CPS::Matrix>("mdA"))
260 .def_property("mdB", createAttributeGetter<CPS::Matrix>("mdB"),
261 createAttributeSetter<CPS::Matrix>("mdB"))
262 .def_property("mdC", createAttributeGetter<CPS::Matrix>("mdC"),
263 createAttributeSetter<CPS::Matrix>("mdC"));
264
265 py::class_<CPS::EMT::Ph1::SSNTypeV2T,
266 std::shared_ptr<CPS::EMT::Ph1::SSNTypeV2T>,
267 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "SSNTypeV2T",
268 py::multiple_inheritance())
269 .def(py::init<std::string>())
270 .def(py::init<std::string, CPS::Logger::Level>())
271 .def("set_parameters", &CPS::EMT::Ph1::SSNTypeV2T::setParameters, "A"_a,
272 "B"_a, "C"_a, "D"_a)
273 .def("manual_init", &CPS::EMT::Ph1::SSNTypeV2T::manualInit,
274 "initialState"_a, "initialInput"_a, "initialOldInput"_a,
275 "initCurr"_a, "initVol"_a)
276 .def("connect", &CPS::EMT::Ph1::SSNTypeV2T::connect)
277 .def_property("mA", createAttributeGetter<CPS::Matrix>("mA"),
278 createAttributeSetter<CPS::Matrix>("mA"))
279 .def_property("mB", createAttributeGetter<CPS::Matrix>("mB"),
280 createAttributeSetter<CPS::Matrix>("mB"))
281 .def_property("mC", createAttributeGetter<CPS::Matrix>("mC"),
282 createAttributeSetter<CPS::Matrix>("mC"))
283 .def_property("mD", createAttributeGetter<CPS::Matrix>("mD"),
284 createAttributeSetter<CPS::Matrix>("mD"))
285 .def_property("mdA", createAttributeGetter<CPS::Matrix>("mdA"),
286 createAttributeSetter<CPS::Matrix>("mdA"))
287 .def_property("mdB", createAttributeGetter<CPS::Matrix>("mdB"),
288 createAttributeSetter<CPS::Matrix>("mdB"))
289 .def_property("mdC", createAttributeGetter<CPS::Matrix>("mdC"),
290 createAttributeSetter<CPS::Matrix>("mdC"));
291}
292
293void addEMTPh3Components(py::module_ mEMTPh3) {
294 py::class_<CPS::EMT::Ph3::VoltageSource,
295 std::shared_ptr<CPS::EMT::Ph3::VoltageSource>,
296 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "VoltageSource",
297 py::multiple_inheritance())
298 .def(py::init<std::string>())
299 .def(py::init<std::string, CPS::Logger::Level>())
300 .def("set_parameters",
301 py::overload_cast<CPS::MatrixComp, CPS::Real>(
302 &CPS::EMT::Ph3::VoltageSource::setParameters),
303 "V_ref"_a, "f_src"_a = 50)
304 .def("connect", &CPS::EMT::Ph3::VoltageSource::connect)
305 .def_property("V_ref", createAttributeGetter<CPS::MatrixComp>("V_ref"),
306 createAttributeSetter<CPS::MatrixComp>("V_ref"))
307 .def_property("f_src", createAttributeGetter<CPS::Real>("f_src"),
308 createAttributeSetter<CPS::Real>("f_src"));
309
310 py::class_<CPS::EMT::Ph3::ControlledVoltageSource,
311 std::shared_ptr<CPS::EMT::Ph3::ControlledVoltageSource>,
312 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "ControlledVoltageSource",
313 py::multiple_inheritance())
314 .def(py::init<std::string>())
315 .def(py::init<std::string, CPS::Logger::Level>())
316 .def("set_parameters",
317 py::overload_cast<CPS::Matrix>(
318 &CPS::EMT::Ph3::ControlledVoltageSource::setParameters),
319 "V_ref"_a)
320 .def("connect", &CPS::EMT::Ph3::ControlledVoltageSource::connect)
321 .def_property("V_ref", createAttributeGetter<CPS::MatrixComp>("V_ref"),
322 createAttributeSetter<CPS::MatrixComp>("V_ref"));
323
324 py::class_<CPS::EMT::Ph3::CurrentSource,
325 std::shared_ptr<CPS::EMT::Ph3::CurrentSource>,
326 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "CurrentSource",
327 py::multiple_inheritance())
328 .def(py::init<std::string>())
329 .def(py::init<std::string, CPS::Logger::Level>())
330 .def("set_parameters",
331 py::overload_cast<CPS::MatrixComp, CPS::Real>(
332 &CPS::EMT::Ph3::CurrentSource::setParameters),
333 "I_ref"_a, "f_src"_a = 50)
334 .def("connect", &CPS::EMT::Ph3::CurrentSource::connect)
335 .def_property("I_ref", createAttributeGetter<CPS::MatrixComp>("I_ref"),
336 createAttributeSetter<CPS::MatrixComp>("V_ref"))
337 .def_property("f_src", createAttributeGetter<CPS::Real>("f_src"),
338 createAttributeSetter<CPS::Real>("f_src"));
339
340 py::class_<CPS::EMT::Ph3::Resistor, std::shared_ptr<CPS::EMT::Ph3::Resistor>,
341 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Resistor",
342 py::multiple_inheritance())
343 .def(py::init<std::string>())
344 .def(py::init<std::string, CPS::Logger::Level>())
345 .def("set_parameters", &CPS::EMT::Ph3::Resistor::setParameters, "R"_a)
346 .def("connect", &CPS::EMT::Ph3::Resistor::connect);
347
348 py::class_<CPS::EMT::Ph3::Capacitor,
349 std::shared_ptr<CPS::EMT::Ph3::Capacitor>,
350 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Capacitor",
351 py::multiple_inheritance())
352 .def(py::init<std::string>())
353 .def(py::init<std::string, CPS::Logger::Level>())
354 .def("set_parameters", &CPS::EMT::Ph3::Capacitor::setParameters, "C"_a)
355 .def("connect", &CPS::EMT::Ph3::Capacitor::connect);
356
357 py::class_<CPS::EMT::Ph3::Inductor, std::shared_ptr<CPS::EMT::Ph3::Inductor>,
358 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Inductor",
359 py::multiple_inheritance())
360 .def(py::init<std::string>())
361 .def(py::init<std::string, CPS::Logger::Level>())
362 .def("set_parameters", &CPS::EMT::Ph3::Inductor::setParameters, "L"_a)
363 .def("connect", &CPS::EMT::Ph3::Inductor::connect);
364
365 py::class_<CPS::EMT::Ph3::NetworkInjection,
366 std::shared_ptr<CPS::EMT::Ph3::NetworkInjection>,
367 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "NetworkInjection",
368 py::multiple_inheritance())
369 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
370 "loglevel"_a = CPS::Logger::Level::off)
371 .def("set_parameters",
372 py::overload_cast<CPS::MatrixComp, CPS::Real>(
373 &CPS::EMT::Ph3::NetworkInjection::setParameters),
374 "V_ref"_a, "f_src"_a = 50)
375 .def("connect", &CPS::EMT::Ph3::NetworkInjection::connect);
376
377 py::class_<CPS::EMT::Ph3::PiLine, std::shared_ptr<CPS::EMT::Ph3::PiLine>,
378 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "PiLine",
379 py::multiple_inheritance())
380 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
381 "loglevel"_a = CPS::Logger::Level::off)
382 .def("set_parameters", &CPS::EMT::Ph3::PiLine::setParameters,
383 "series_resistance"_a, "series_inductance"_a,
384 "parallel_capacitance"_a = zeroMatrix(3),
385 "parallel_conductance"_a = zeroMatrix(3))
386 .def("connect", &CPS::EMT::Ph3::PiLine::connect);
387
388 py::class_<CPS::EMT::Ph3::RXLoad, std::shared_ptr<CPS::EMT::Ph3::RXLoad>,
389 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "RXLoad",
390 py::multiple_inheritance())
391 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
392 "loglevel"_a = CPS::Logger::Level::off)
393 .def("set_parameters", &CPS::EMT::Ph3::RXLoad::setParameters,
394 "active_power"_a, "reactive_power"_a, "volt"_a,
395 // cppcheck-suppress assignBoolToPointer
396 "reactance_in_series"_a = false)
397 .def("connect", &CPS::EMT::Ph3::RXLoad::connect);
398
399 py::class_<CPS::EMT::Ph3::Shunt, std::shared_ptr<CPS::EMT::Ph3::Shunt>,
400 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Shunt",
401 py::multiple_inheritance())
402 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
403 "loglevel"_a = CPS::Logger::Level::off)
404 .def("set_parameters",
405 static_cast<void (CPS::EMT::Ph3::Shunt::*)(CPS::Real, CPS::Real)>(
406 &CPS::EMT::Ph3::Shunt::setParameters),
407 "G"_a, "B"_a)
408 .def("connect", &CPS::EMT::Ph3::Shunt::connect);
409
410 py::class_<CPS::EMT::Ph3::Switch, std::shared_ptr<CPS::EMT::Ph3::Switch>,
411 CPS::SimPowerComp<CPS::Real>, CPS::Base::Ph3::Switch>(
412 mEMTPh3, "Switch", py::multiple_inheritance())
413 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
414 "loglevel"_a = CPS::Logger::Level::off)
415 .def("set_parameters", &CPS::EMT::Ph3::Switch::setParameters,
416 "open_resistance"_a, "closed_resistance"_a,
417 // cppcheck-suppress assignBoolToPointer
418 "closed"_a = false)
419 .def("open", &CPS::EMT::Ph3::Switch::openSwitch)
420 .def("close", &CPS::EMT::Ph3::Switch::closeSwitch)
421 .def("connect", &CPS::EMT::Ph3::Switch::connect);
422
423 py::class_<CPS::EMT::Ph3::SynchronGeneratorIdeal,
424 std::shared_ptr<CPS::EMT::Ph3::SynchronGeneratorIdeal>,
425 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SynchronGeneratorIdeal",
426 py::multiple_inheritance())
427 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
428 "loglevel"_a = CPS::Logger::Level::off)
429 .def("connect", &CPS::EMT::Ph3::SynchronGeneratorIdeal::connect);
430
431 py::class_<CPS::EMT::Ph3::SynchronGeneratorDQTrapez,
432 std::shared_ptr<CPS::EMT::Ph3::SynchronGeneratorDQTrapez>,
433 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SynchronGeneratorDQTrapez",
434 py::multiple_inheritance())
435 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
436 "loglevel"_a = CPS::Logger::Level::off)
437 .def("set_parameters_operational_per_unit",
438 &CPS::EMT::Ph3::SynchronGeneratorDQTrapez::
439 setParametersOperationalPerUnit,
440 "nom_power"_a, "nom_volt"_a, "nom_freq"_a, "pole_number"_a,
441 "nom_field_cur"_a, "Rs"_a, "Ld"_a, "Lq"_a, "Ld_t"_a, "Lq_t"_a,
442 "Ld_s"_a, "Lq_s"_a, "Ll"_a, "Td0_t"_a, "Tq0_t"_a, "Td0_s"_a,
443 "Tq0_s"_a, "inertia"_a)
444 .def("set_parameters_fundamental_per_unit",
445 &CPS::EMT::Ph3::SynchronGeneratorDQTrapez::
446 setParametersFundamentalPerUnit,
447 "nom_power"_a, "nom_volt"_a, "nom_freq"_a, "pole_number"_a,
448 "nom_field_cur"_a, "Rs"_a, "Ll"_a, "Lmd"_a, "Lmq"_a, "Rfd"_a,
449 "Llfd"_a, "Rkd"_a, "Llkd"_a, "Rkq1"_a, "Llkq1"_a, "Rkq2"_a,
450 "Llkq2"_a, "inertia"_a, "init_active_power"_a,
451 "init_reactive_power"_a, "init_terminal_volt"_a, "init_volt_angle"_a,
452 "init_mech_power"_a)
453#ifdef WITH_JSON
454 .def("apply_parameters_from_json",
455 [](std::shared_ptr<CPS::EMT::Ph3::SynchronGeneratorDQTrapez> syngen,
456 const CPS::String json) {
457 DPsim::Utils::applySynchronousGeneratorParametersFromJson(
458 json::parse(json), syngen);
459 })
460#endif
461 .def("set_initial_values",
462 &CPS::EMT::Ph3::SynchronGeneratorDQTrapez::setInitialValues,
463 "init_active_power"_a, "init_reactive_power"_a,
464 "init_terminal_volt"_a, "init_volt_angle"_a, "init_mech_power"_a);
465
466 py::class_<CPS::EMT::Ph3::VSIVoltageControlVCO,
467 std::shared_ptr<CPS::EMT::Ph3::VSIVoltageControlVCO>,
468 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "VSIVoltageControlVCO",
469 py::multiple_inheritance())
470 .def(py::init<std::string>())
471 .def(py::init<std::string, CPS::Logger::Level>())
472 .def(py::init<std::string, std::string, CPS::Logger::Level, CPS::Bool>(),
473 "uid"_a, "name"_a, "log_level"_a = CPS::Logger::Level::off,
474 py::arg("with_trafo") = false)
475 .def("set_parameters",
476 &CPS::EMT::Ph3::VSIVoltageControlVCO::setParameters, "sys_omega"_a,
477 "vd_ref"_a, "vq_ref"_a)
478 .def("set_controller_parameters",
479 &CPS::EMT::Ph3::VSIVoltageControlVCO::setControllerParameters,
480 "kp_voltage_ctrl"_a, "ki_voltage_ctrl"_a, "kp_curr_ctrl"_a,
481 "ki_curr_ctrl"_a, "omega_nominal"_a)
482 .def("set_transformer_parameters",
483 &CPS::EMT::Ph3::VSIVoltageControlVCO::setTransformerParameters,
484 "nom_voltage_end1"_a, "nom_voltage_end2"_a, "rated_power"_a,
485 "ratio_abs"_a, "ratio_phase"_a, "resistance"_a, "inductance"_a,
486 "omega"_a)
487 .def("set_filter_parameters",
488 &CPS::EMT::Ph3::VSIVoltageControlVCO::setFilterParameters, "lf"_a,
489 "cf"_a, "rf"_a, "rc"_a)
490 .def("set_initial_state_values",
491 &CPS::EMT::Ph3::VSIVoltageControlVCO::setInitialStateValues,
492 "phi_d_init"_a, "phi_q_init"_a, "gamma_d_init"_a, "gamma_q_init"_a)
493 .def("with_control", &CPS::EMT::Ph3::VSIVoltageControlVCO::withControl,
494 "control_on"_a)
495 .def("connect", &CPS::EMT::Ph3::VSIVoltageControlVCO::connect);
496
497 py::class_<CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR,
498 std::shared_ptr<CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>,
499 CPS::Base::ReducedOrderSynchronGenerator<CPS::Real>>(
500 mEMTPh3, "ReducedOrderSynchronGeneratorVBR", py::multiple_inheritance());
501
502 py::class_<CPS::EMT::Ph3::SynchronGenerator3OrderVBR,
503 std::shared_ptr<CPS::EMT::Ph3::SynchronGenerator3OrderVBR>,
504 CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>(
505 mEMTPh3, "SynchronGenerator3OrderVBR", py::multiple_inheritance())
506 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
507 "loglevel"_a = CPS::Logger::Level::off)
508 .def("set_operational_parameters_per_unit",
509 py::overload_cast<CPS::Real, CPS::Real, CPS::Real, CPS::Real,
510 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
511 CPS::Real>(
512 &CPS::EMT::Ph3::SynchronGenerator3OrderVBR::
513 setOperationalParametersPerUnit),
514 "nom_power"_a, "nom_voltage"_a, "nom_frequency"_a, "H"_a, "Ld"_a,
515 "Lq"_a, "L0"_a, "Ld_t"_a, "Td0_t"_a)
516 .def("connect", &CPS::EMT::Ph3::SynchronGenerator3OrderVBR::connect);
517
518 py::class_<CPS::EMT::Ph3::SynchronGenerator4OrderVBR,
519 std::shared_ptr<CPS::EMT::Ph3::SynchronGenerator4OrderVBR>,
520 CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>(
521 mEMTPh3, "SynchronGenerator4OrderVBR", py::multiple_inheritance())
522 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
523 "loglevel"_a = CPS::Logger::Level::off)
524 .def("set_operational_parameters_per_unit",
525 py::overload_cast<CPS::Real, CPS::Real, CPS::Real, CPS::Real,
526 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
527 CPS::Real, CPS::Real, CPS::Real>(
528 &CPS::EMT::Ph3::SynchronGenerator4OrderVBR::
529 setOperationalParametersPerUnit),
530 "nom_power"_a, "nom_voltage"_a, "nom_frequency"_a, "H"_a, "Ld"_a,
531 "Lq"_a, "L0"_a, "Ld_t"_a, "Lq_t"_a, "Td0_t"_a, "Tq0_t"_a)
532 .def("connect", &CPS::EMT::Ph3::SynchronGenerator4OrderVBR::connect);
533
534 py::class_<CPS::EMT::Ph3::SynchronGenerator5OrderVBR,
535 std::shared_ptr<CPS::EMT::Ph3::SynchronGenerator5OrderVBR>,
536 CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>(
537 mEMTPh3, "SynchronGenerator5OrderVBR", py::multiple_inheritance())
538 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
539 "loglevel"_a = CPS::Logger::Level::off)
540 .def("set_operational_parameters_per_unit",
541 py::overload_cast<CPS::Real, CPS::Real, CPS::Real, CPS::Real,
542 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
543 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
544 CPS::Real, CPS::Real, CPS::Real, CPS::Real>(
545 &CPS::EMT::Ph3::SynchronGenerator5OrderVBR::
546 setOperationalParametersPerUnit),
547 "nom_power"_a, "nom_voltage"_a, "nom_frequency"_a, "H"_a, "Ld"_a,
548 "Lq"_a, "L0"_a, "Ld_t"_a, "Lq_t"_a, "Td0_t"_a, "Tq0_t"_a, "Ld_s"_a,
549 "Lq_s"_a, "Td0_s"_a, "Tq0_s"_a, "Taa"_a)
550 .def("connect", &CPS::EMT::Ph3::SynchronGenerator5OrderVBR::connect);
551
552 py::class_<CPS::EMT::Ph3::SynchronGenerator6aOrderVBR,
553 std::shared_ptr<CPS::EMT::Ph3::SynchronGenerator6aOrderVBR>,
554 CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>(
555 mEMTPh3, "SynchronGenerator6aOrderVBR", py::multiple_inheritance())
556 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
557 "loglevel"_a = CPS::Logger::Level::off)
558 .def("set_operational_parameters_per_unit",
559 py::overload_cast<CPS::Real, CPS::Real, CPS::Real, CPS::Real,
560 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
561 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
562 CPS::Real, CPS::Real, CPS::Real, CPS::Real>(
563 &CPS::EMT::Ph3::SynchronGenerator6aOrderVBR::
564 setOperationalParametersPerUnit),
565 "nom_power"_a, "nom_voltage"_a, "nom_frequency"_a, "H"_a, "Ld"_a,
566 "Lq"_a, "L0"_a, "Ld_t"_a, "Lq_t"_a, "Td0_t"_a, "Tq0_t"_a, "Ld_s"_a,
567 "Lq_s"_a, "Td0_s"_a, "Tq0_s"_a, "Taa"_a)
568 .def("connect", &CPS::EMT::Ph3::SynchronGenerator6aOrderVBR::connect);
569
570 py::class_<CPS::EMT::Ph3::SynchronGenerator6bOrderVBR,
571 std::shared_ptr<CPS::EMT::Ph3::SynchronGenerator6bOrderVBR>,
572 CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>(
573 mEMTPh3, "SynchronGenerator6bOrderVBR", py::multiple_inheritance())
574 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
575 "loglevel"_a = CPS::Logger::Level::off)
576 .def("set_operational_parameters_per_unit",
577 py::overload_cast<CPS::Real, CPS::Real, CPS::Real, CPS::Real,
578 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
579 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
580 CPS::Real, CPS::Real, CPS::Real, CPS::Real>(
581 &CPS::EMT::Ph3::SynchronGenerator6bOrderVBR::
582 setOperationalParametersPerUnit),
583 "nom_power"_a, "nom_voltage"_a, "nom_frequency"_a, "H"_a, "Ld"_a,
584 "Lq"_a, "L0"_a, "Ld_t"_a, "Lq_t"_a, "Td0_t"_a, "Tq0_t"_a, "Ld_s"_a,
585 "Lq_s"_a, "Td0_s"_a, "Tq0_s"_a, "Taa"_a = 0)
586 .def("connect", &CPS::EMT::Ph3::SynchronGenerator6bOrderVBR::connect);
587
588#ifdef WITH_SUNDIALS
589
590 py::class_<CPS::EMT::Ph3::SynchronGeneratorDQODE,
591 std::shared_ptr<CPS::EMT::Ph3::SynchronGeneratorDQODE>,
592 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SynchronGeneratorDQODE",
593 py::multiple_inheritance())
594 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
595 "loglevel"_a = CPS::Logger::Level::off)
596 .def("set_parameters_operational_per_unit",
597 &CPS::EMT::Ph3::SynchronGeneratorDQODE::
598 setParametersOperationalPerUnit,
599 "nom_power"_a, "nom_volt"_a, "nom_freq"_a, "pole_number"_a,
600 "nom_field_cur"_a, "Rs"_a, "Ld"_a, "Lq"_a, "Ld_t"_a, "Lq_t"_a,
601 "Ld_s"_a, "Lq_s"_a, "Ll"_a, "Td0_t"_a, "Tq0_t"_a, "Td0_s"_a,
602 "Tq0_s"_a, "inertia"_a)
603 .def("set_parameters_fundamental_per_unit",
604 &CPS::EMT::Ph3::SynchronGeneratorDQODE::
605 setParametersFundamentalPerUnit,
606 "nom_power"_a, "nom_volt"_a, "nom_freq"_a, "pole_number"_a,
607 "nom_field_cur"_a, "Rs"_a, "Ll"_a, "Lmd"_a, "Lmq"_a, "Rfd"_a,
608 "Llfd"_a, "Rkd"_a, "Llkd"_a, "Rkq1"_a, "Llkq1"_a, "Rkq2"_a,
609 "Llkq2"_a, "inertia"_a, "init_active_power"_a,
610 "init_reactive_power"_a, "init_terminal_volt"_a, "init_volt_angle"_a,
611 "init_mech_power"_a)
612#ifdef WITH_JSON
613 .def("apply_parameters_from_json",
614 [](std::shared_ptr<CPS::EMT::Ph3::SynchronGeneratorDQODE> syngen,
615 const CPS::String json) {
616 DPsim::Utils::applySynchronousGeneratorParametersFromJson(
617 json::parse(json), syngen);
618 })
619#endif
620 .def("set_initial_values",
621 &CPS::EMT::Ph3::SynchronGeneratorDQODE::setInitialValues,
622 "init_active_power"_a, "init_reactive_power"_a,
623 "init_terminal_volt"_a, "init_volt_angle"_a, "init_mech_power"_a);
624
625#endif
626
627 py::class_<CPS::EMT::Ph3::AvVoltageSourceInverterDQ,
628 std::shared_ptr<CPS::EMT::Ph3::AvVoltageSourceInverterDQ>,
629 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "AvVoltageSourceInverterDQ",
630 py::multiple_inheritance())
631 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
632 "loglevel"_a = CPS::Logger::Level::off)
633 .def(py::init<std::string, std::string, CPS::Logger::Level, CPS::Bool>(),
634 "uid"_a, "name"_a, "loglevel"_a = CPS::Logger::Level::off,
635 // cppcheck-suppress assignBoolToPointer
636 "with_trafo"_a = false)
637 .def("set_parameters",
638 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setParameters,
639 "sys_omega"_a, "sys_volt_nom"_a, "p_ref"_a, "q_ref"_a)
640 .def("set_filter_parameters",
641 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setFilterParameters,
642 "Lf"_a, "Cf"_a, "Rf"_a, "Rc"_a)
643 .def("set_controller_parameters",
644 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setControllerParameters,
645 "Kp_pll"_a, "Ki_pll"_a, "Kp_power_ctrl"_a, "Ki_power_ctrl"_a,
646 "Kp_curr_ctrl"_a, "Ki_curr_ctrl"_a, "omega_cutoff"_a)
647 .def("set_transformer_parameters",
648 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setTransformerParameters,
649 "nom_voltage_end_1"_a, "nom_voltage_end_2"_a, "rated_power"_a,
650 "ratio_abs"_a, "ratio_phase"_a, "resistance"_a, "inductance"_a,
651 "omega"_a)
652 .def("set_initial_state_values",
653 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setInitialStateValues,
654 "p_init"_a, "q_init"_a, "phi_d_init"_a, "phi_q_init"_a,
655 "gamma_d_init"_a, "gamma_q_init"_a)
656 .def("with_control",
657 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::withControl)
658 .def("connect", &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::connect);
659
660 py::class_<CPS::EMT::Ph3::Transformer,
661 std::shared_ptr<CPS::EMT::Ph3::Transformer>,
662 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Transformer",
663 py::multiple_inheritance())
664 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
665 "loglevel"_a = CPS::Logger::Level::off)
666 .def(py::init<std::string, std::string, CPS::Logger::Level, CPS::Bool>(),
667 "uid"_a, "name"_a, "loglevel"_a = CPS::Logger::Level::off,
668 // cppcheck-suppress assignBoolToPointer
669 "with_resistive_losses"_a = false)
670 .def("set_parameters", &CPS::EMT::Ph3::Transformer::setParameters,
671 "nom_voltage_end_1"_a, "nom_voltage_end_2"_a, "rated_power"_a,
672 "ratio_abs"_a, "ratio_phase"_a, "resistance"_a, "inductance"_a)
673 .def("connect", &CPS::EMT::Ph3::Transformer::connect);
674
675 py::class_<CPS::EMT::Ph3::SeriesResistor,
676 std::shared_ptr<CPS::EMT::Ph3::SeriesResistor>,
677 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SeriesResistor",
678 py::multiple_inheritance())
679 .def(py::init<std::string>())
680 .def(py::init<std::string, CPS::Logger::Level>())
681 .def("set_parameters", &CPS::EMT::Ph3::SeriesResistor::setParameters,
682 "R"_a)
683 .def("connect", &CPS::EMT::Ph3::SeriesResistor::connect);
684
685 py::class_<CPS::EMT::Ph3::SeriesSwitch,
686 std::shared_ptr<CPS::EMT::Ph3::SeriesSwitch>,
687 CPS::SimPowerComp<CPS::Real>, CPS::Base::Ph1::Switch>(
688 mEMTPh3, "SeriesSwitch", py::multiple_inheritance())
689 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
690 "loglevel"_a = CPS::Logger::Level::off)
691 .def("set_parameters", &CPS::EMT::Ph3::SeriesSwitch::setParameters,
692 "open_resistance"_a, "closed_resistance"_a,
693 // cppcheck-suppress assignBoolToPointer
694 "closed"_a = false)
695 .def("open", &CPS::EMT::Ph3::SeriesSwitch::open)
696 .def("close", &CPS::EMT::Ph3::SeriesSwitch::close)
697 .def("connect", &CPS::EMT::Ph3::SeriesSwitch::connect);
698
699 py::class_<CPS::EMT::Ph3::SSN::Full_Serial_RLC,
700 std::shared_ptr<CPS::EMT::Ph3::SSN::Full_Serial_RLC>,
701 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Full_Serial_RLC",
702 py::multiple_inheritance())
703 .def(py::init<std::string>())
704 .def(py::init<std::string, CPS::Logger::Level>())
705 .def("set_parameters",
706 &CPS::EMT::Ph3::SSN::Full_Serial_RLC::setParameters, "R"_a, "L"_a,
707 "C"_a)
708 .def("connect", &CPS::EMT::Ph3::SSN::Full_Serial_RLC::connect)
709 .def_property("R", createAttributeGetter<CPS::Matrix>("R"),
710 createAttributeSetter<CPS::Matrix>("R"))
711 .def_property("L", createAttributeGetter<CPS::Matrix>("L"),
712 createAttributeSetter<CPS::Matrix>("L"))
713 .def_property("C", createAttributeGetter<CPS::Matrix>("C"),
714 createAttributeSetter<CPS::Matrix>("C"));
715
716 py::class_<CPS::EMT::Ph3::GenericTwoTerminalVTypeSSN,
717 std::shared_ptr<CPS::EMT::Ph3::GenericTwoTerminalVTypeSSN>,
718 CPS::SimPowerComp<CPS::Real>>(
719 mEMTPh3, "GenericTwoTerminalVTypeSSN", py::multiple_inheritance())
720 .def(py::init<std::string>())
721 .def(py::init<std::string, CPS::Logger::Level>())
722 .def("set_parameters",
723 &CPS::EMT::Ph3::GenericTwoTerminalVTypeSSN::setParameters, "A"_a,
724 "B"_a, "C"_a, "D"_a)
725 .def("connect", &CPS::EMT::Ph3::GenericTwoTerminalVTypeSSN::connect)
726 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
727
728 py::class_<CPS::EMT::Ph3::GenericTwoTerminalITypeSSN,
729 std::shared_ptr<CPS::EMT::Ph3::GenericTwoTerminalITypeSSN>,
730 CPS::SimPowerComp<CPS::Real>>(
731 mEMTPh3, "GenericTwoTerminalITypeSSN", py::multiple_inheritance())
732 .def(py::init<std::string>())
733 .def(py::init<std::string, CPS::Logger::Level>())
734 .def("set_parameters",
735 &CPS::EMT::Ph3::GenericTwoTerminalITypeSSN::setParameters, "A"_a,
736 "B"_a, "C"_a, "D"_a)
737 .def("connect", &CPS::EMT::Ph3::GenericTwoTerminalITypeSSN::connect)
738 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
739
740 py::class_<CPS::EMT::Ph3::PiecewiseLinearInductor,
741 std::shared_ptr<CPS::EMT::Ph3::PiecewiseLinearInductor>,
742 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "PiecewiseLinearInductor",
743 py::multiple_inheritance())
744 .def(py::init<std::string>())
745 .def(py::init<std::string, CPS::Logger::Level>())
746 .def("set_parameters",
747 &CPS::EMT::Ph3::PiecewiseLinearInductor::setParameters,
748 "flux_breakpoints"_a, "current_breakpoints"_a)
749 .def("connect", &CPS::EMT::Ph3::PiecewiseLinearInductor::connect)
750 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
751
752 // -----------------------------------------------------------------------
753 // Grid-following converter models
754 // -----------------------------------------------------------------------
755
756 py::class_<CPS::EMT::Ph3::GFL, std::shared_ptr<CPS::EMT::Ph3::GFL>,
757 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "GFL",
758 py::multiple_inheritance())
759 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
760 "loglevel"_a = CPS::Logger::Level::off)
761 .def(py::init<std::string, std::string, CPS::Logger::Level>(), "uid"_a,
762 "name"_a, "loglevel"_a = CPS::Logger::Level::off)
763 .def("set_parameters", &CPS::EMT::Ph3::GFL::setParameters, "sys_omega"_a,
764 "sys_volt_nom"_a, "p_ref"_a, "q_ref"_a)
765 .def("set_controller_parameters",
766 &CPS::EMT::Ph3::GFL::setControllerParameters, "kp_pll"_a, "ki_pll"_a,
767 "kp_power_ctrl"_a, "ki_power_ctrl"_a, "kp_curr_ctrl"_a,
768 "ki_curr_ctrl"_a, "omega_cutoff"_a)
769 .def("set_filter_parameters", &CPS::EMT::Ph3::GFL::setFilterParameters,
770 "lf"_a, "cf"_a, "rf"_a)
771 .def("set_initial_state_values",
772 &CPS::EMT::Ph3::GFL::setInitialStateValues, "p_init"_a, "q_init"_a,
773 "phi_d_init"_a, "phi_q_init"_a, "gamma_d_init"_a, "gamma_q_init"_a)
774 .def("with_control", &CPS::EMT::Ph3::GFL::withControl, "control_on"_a)
775 .def("connect", &CPS::EMT::Ph3::GFL::connect)
776 .def_property_readonly("vc_d", createAttributeGetter<CPS::Real>("vc_d"))
777 .def_property_readonly("vc_q", createAttributeGetter<CPS::Real>("vc_q"))
778 .def_property_readonly("igrid_d",
779 createAttributeGetter<CPS::Real>("igrid_d"))
780 .def_property_readonly("igrid_q",
781 createAttributeGetter<CPS::Real>("igrid_q"))
782 .def_property_readonly("p_inst",
783 createAttributeGetter<CPS::Real>("p_inst"))
784 .def_property_readonly("q_inst",
785 createAttributeGetter<CPS::Real>("q_inst"))
786 .def_property_readonly("omega_pll",
787 createAttributeGetter<CPS::Real>("omega_pll"))
788 .def_property_readonly("vs_ref",
789 createAttributeGetter<CPS::Matrix>("vs_ref"))
790 .def_property_readonly("vs", createAttributeGetter<CPS::Matrix>("vs"))
791 .def_property_readonly("pll_output",
792 createAttributeGetter<CPS::Matrix>("pll_output"))
793 .def_property_readonly(
794 "powerctrl_inputs",
795 createAttributeGetter<CPS::Matrix>("powerctrl_inputs"))
796 .def_property_readonly(
797 "powerctrl_states",
798 createAttributeGetter<CPS::Matrix>("powerctrl_states"))
799 .def_property_readonly(
800 "powerctrl_outputs",
801 createAttributeGetter<CPS::Matrix>("powerctrl_outputs"));
802
803 py::class_<CPS::EMT::Ph3::SSN_GFL, std::shared_ptr<CPS::EMT::Ph3::SSN_GFL>,
804 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SSN_GFL",
805 py::multiple_inheritance())
806 .def(py::init<std::string, std::string, CPS::Logger::Level>(), "uid"_a,
807 "name"_a, "loglevel"_a = CPS::Logger::Level::off)
808 .def("set_parameters", &CPS::EMT::Ph3::SSN_GFL::setParameters, "lf"_a,
809 "cf"_a, "rf"_a, "rc"_a, "omega_n"_a, "kp_pll"_a, "ki_pll"_a,
810 "omega_cutoff"_a, "p_ref"_a, "q_ref"_a, "kp_power_ctrl"_a,
811 "ki_power_ctrl"_a, "kp_curr_ctrl"_a, "ki_curr_ctrl"_a)
812 .def("connect", &CPS::EMT::Ph3::SSN_GFL::connect)
813 .def("get_state_names", &CPS::EMT::Ph3::SSN_GFL::getLocalStateNames)
814 .def("get_state", &CPS::EMT::Ph3::SSN_GFL::getState)
815 .def("get_state_derivative", &CPS::EMT::Ph3::SSN_GFL::getStateDerivative)
816 .def("get_interface_voltage",
817 &CPS::EMT::Ph3::SSN_GFL::getInterfaceVoltage)
818 .def("get_interface_current",
819 &CPS::EMT::Ph3::SSN_GFL::getInterfaceCurrent)
820 .def_property_readonly("vc_d", createAttributeGetter<CPS::Real>("vc_d"))
821 .def_property_readonly("vc_q", createAttributeGetter<CPS::Real>("vc_q"))
822 .def_property_readonly("irc_d", createAttributeGetter<CPS::Real>("irc_d"))
823 .def_property_readonly("irc_q", createAttributeGetter<CPS::Real>("irc_q"))
824 .def_property_readonly("p_inst",
825 createAttributeGetter<CPS::Real>("p_inst"))
826 .def_property_readonly("q_inst",
827 createAttributeGetter<CPS::Real>("q_inst"))
828 .def_property_readonly("omega_pll",
829 createAttributeGetter<CPS::Real>("omega_pll"));
830
831 py::class_<CPS::EMT::Ph3::SSN_GFL_Split,
832 std::shared_ptr<CPS::EMT::Ph3::SSN_GFL_Split>,
833 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SSN_GFL_Split",
834 py::multiple_inheritance())
835 .def(py::init<std::string, std::string, CPS::Logger::Level>(), "uid"_a,
836 "name"_a, "loglevel"_a = CPS::Logger::Level::off)
837 .def("set_parameters", &CPS::EMT::Ph3::SSN_GFL_Split::setParameters,
838 "lf"_a, "cf"_a, "rf"_a, "rc"_a, "omega_n"_a, "kp_pll"_a, "ki_pll"_a,
839 "omega_cutoff"_a, "p_ref"_a, "q_ref"_a, "kp_power_ctrl"_a,
840 "ki_power_ctrl"_a, "kp_curr_ctrl"_a, "ki_curr_ctrl"_a)
841 .def("connect", &CPS::EMT::Ph3::SSN_GFL_Split::connect)
842
843 // Combined controller + network state.
844 .def("get_state", &CPS::EMT::Ph3::SSN_GFL_Split::getState)
845 .def("get_state_derivative",
846 &CPS::EMT::Ph3::SSN_GFL_Split::getStateDerivative)
847
848 // Split state access.
849 .def("get_controller_state",
850 &CPS::EMT::Ph3::SSN_GFL_Split::getControllerState)
851 .def("get_network_state", &CPS::EMT::Ph3::SSN_GFL_Split::getNetworkState)
852 .def("get_network_state_names",
853 &CPS::EMT::Ph3::SSN_GFL_Split::getLocalStateNames)
854
855 // Electrical interface / delayed forcing.
856 .def("get_interface_voltage",
857 &CPS::EMT::Ph3::SSN_GFL_Split::getInterfaceVoltage)
858 .def("get_interface_current",
859 &CPS::EMT::Ph3::SSN_GFL_Split::getInterfaceCurrent)
860 .def("get_converter_voltage_reference",
861 &CPS::EMT::Ph3::SSN_GFL_Split::getConverterVoltageReference)
862 .def("get_delayed_converter_voltage",
863 &CPS::EMT::Ph3::SSN_GFL_Split::getDelayedConverterVoltage)
864
865 // Controller affine model.
866 .def("get_controller_A", &CPS::EMT::Ph3::SSN_GFL_Split::getControllerA)
867 .def("get_controller_B", &CPS::EMT::Ph3::SSN_GFL_Split::getControllerB)
868 .def("get_controller_C", &CPS::EMT::Ph3::SSN_GFL_Split::getControllerC)
869 .def("get_controller_D", &CPS::EMT::Ph3::SSN_GFL_Split::getControllerD)
870 .def("get_controller_E", &CPS::EMT::Ph3::SSN_GFL_Split::getControllerE)
871 .def("get_controller_F", &CPS::EMT::Ph3::SSN_GFL_Split::getControllerF)
872
873 // Fixed electrical SSN plant.
874 .def("get_network_A", &CPS::EMT::Ph3::SSN_GFL_Split::getNetworkA)
875 .def("get_network_B", &CPS::EMT::Ph3::SSN_GFL_Split::getNetworkB)
876 .def("get_network_C", &CPS::EMT::Ph3::SSN_GFL_Split::getNetworkC)
877 .def("get_network_D", &CPS::EMT::Ph3::SSN_GFL_Split::getNetworkD)
878 .def("get_equivalent_conductance",
879 &CPS::EMT::Ph3::SSN_GFL_Split::getEquivalentConductance)
880
881 // Logged scalar quantities.
882 .def_property_readonly("vc_d", createAttributeGetter<CPS::Real>("vc_d"))
883 .def_property_readonly("vc_q", createAttributeGetter<CPS::Real>("vc_q"))
884 .def_property_readonly("irc_d", createAttributeGetter<CPS::Real>("irc_d"))
885 .def_property_readonly("irc_q", createAttributeGetter<CPS::Real>("irc_q"))
886 .def_property_readonly("p_inst",
887 createAttributeGetter<CPS::Real>("p_inst"))
888 .def_property_readonly("q_inst",
889 createAttributeGetter<CPS::Real>("q_inst"))
890 .def_property_readonly("omega_pll",
891 createAttributeGetter<CPS::Real>("omega_pll"))
892 .def_property_readonly("vinv_ref_a",
893 createAttributeGetter<CPS::Real>("vinv_ref_a"))
894 .def_property_readonly("vinv_ref_b",
895 createAttributeGetter<CPS::Real>("vinv_ref_b"))
896 .def_property_readonly("vinv_ref_c",
897 createAttributeGetter<CPS::Real>("vinv_ref_c"));
898
899 py::class_<CPS::EMT::Ph3::AvVoltSourceInverterStateSpace,
900 std::shared_ptr<CPS::EMT::Ph3::AvVoltSourceInverterStateSpace>,
901 CPS::SimPowerComp<CPS::Real>>(
902 mEMTPh3, "AvVoltSourceInverterStateSpace", py::multiple_inheritance())
903 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
904 "loglevel"_a = CPS::Logger::Level::off)
905 .def(py::init<std::string, std::string, CPS::Logger::Level>(), "uid"_a,
906 "name"_a, "loglevel"_a = CPS::Logger::Level::off)
907 .def("set_parameters",
908 &CPS::EMT::Ph3::AvVoltSourceInverterStateSpace::setParameters,
909 "Lf"_a, "Cf"_a, "Rf"_a, "Rc"_a, "omega_n"_a, "Kp_pll"_a, "Ki_pll"_a,
910 "omega_cutoff"_a, "p_ref"_a, "q_ref"_a, "Kp_power_ctrl"_a,
911 "Ki_power_ctrl"_a, "Kp_curr_ctrl"_a, "Ki_curr_ctrl"_a)
912 .def("connect", &CPS::EMT::Ph3::AvVoltSourceInverterStateSpace::connect)
913 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"))
914 .def_property_readonly("vc_d", createAttributeGetter<CPS::Real>("vc_d"))
915 .def_property_readonly("vc_q", createAttributeGetter<CPS::Real>("vc_q"))
916 .def_property_readonly("irc_d", createAttributeGetter<CPS::Real>("irc_d"))
917 .def_property_readonly("irc_q", createAttributeGetter<CPS::Real>("irc_q"))
918 .def_property_readonly("p_inst",
919 createAttributeGetter<CPS::Real>("p_inst"))
920 .def_property_readonly("q_inst",
921 createAttributeGetter<CPS::Real>("q_inst"))
922 .def_property_readonly("omega_pll",
923 createAttributeGetter<CPS::Real>("omega_pll"));
924
925 py::class_<CPS::EMT::Ph3::SSN_GFM, std::shared_ptr<CPS::EMT::Ph3::SSN_GFM>,
926 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SSN_GFM",
927 py::multiple_inheritance())
928 .def(py::init<std::string, std::string, CPS::Logger::Level>(), "uid"_a,
929 "name"_a, "log_level"_a = CPS::Logger::Level::off)
930 .def("set_parameters", &CPS::EMT::Ph3::SSN_GFM::setParameters, "lf"_a,
931 "cf"_a, "rf"_a, "rc"_a, "nominal_voltage"_a, "omega_nominal"_a,
932 "p_ref"_a, "q_ref"_a, "virtual_inertia"_a, "damping_coefficient"_a,
933 "voltage_droop_gain"_a, "reactive_integral_gain"_a, "kp_voltage"_a,
934 "ki_voltage"_a, "kp_current"_a, "ki_current"_a,
935 "active_damping_gain"_a, "power_filter_cutoff"_a,
936 "delay_bandwidth"_a)
937 .def("set_numerical_linearization_parameters",
938 &CPS::EMT::Ph3::SSN_GFM::setNumericalLinearizationParameters,
939 "relative_step"_a = 1e-6, "absolute_step"_a = 1e-8)
940 .def("set_virtual_impedance",
941 &CPS::EMT::Ph3::SSN_GFM::setVirtualImpedance, "virtual_resistance"_a,
942 "virtual_reactance"_a = 0.0)
943 .def("set_grid_current_feedforward",
944 &CPS::EMT::Ph3::SSN_GFM::setGridCurrentFeedforward, "scale"_a)
945 .def("set_reactive_power_droop",
946 &CPS::EMT::Ph3::SSN_GFM::setReactivePowerDroop, "droop_gain"_a,
947 "cutoff"_a)
948 .def("connect", &CPS::EMT::Ph3::SSN_GFM::connect)
949 .def("get_state_names", &CPS::EMT::Ph3::SSN_GFM::getLocalStateNames)
950 .def("get_state", &CPS::EMT::Ph3::SSN_GFM::getState)
951 .def("get_state_derivative", &CPS::EMT::Ph3::SSN_GFM::getStateDerivative)
952 .def("get_interface_voltage",
953 &CPS::EMT::Ph3::SSN_GFM::getInterfaceVoltage)
954 .def("get_interface_current",
955 &CPS::EMT::Ph3::SSN_GFM::getInterfaceCurrent)
956 .def_property_readonly("p_inst",
957 createAttributeGetter<CPS::Real>("p_inst"))
958 .def_property_readonly("q_inst",
959 createAttributeGetter<CPS::Real>("q_inst"))
960 .def_property_readonly("omega_gfm",
961 createAttributeGetter<CPS::Real>("omega_gfm"))
962 .def_property_readonly("theta_gfm",
963 createAttributeGetter<CPS::Real>("theta_gfm"))
964 .def_property_readonly(
965 "voltage_magnitude_gfm",
966 createAttributeGetter<CPS::Real>("voltage_magnitude_gfm"))
967 .def_property_readonly("vc_d", createAttributeGetter<CPS::Real>("vc_d"))
968 .def_property_readonly("vc_q", createAttributeGetter<CPS::Real>("vc_q"))
969 .def_property_readonly("i_grid_d",
970 createAttributeGetter<CPS::Real>("i_grid_d"))
971 .def_property_readonly("i_grid_q",
972 createAttributeGetter<CPS::Real>("i_grid_q"))
973 .def_property_readonly("if_d", createAttributeGetter<CPS::Real>("if_d"))
974 .def_property_readonly("if_q", createAttributeGetter<CPS::Real>("if_q"))
975 .def_property_readonly("v_ref_d",
976 createAttributeGetter<CPS::Real>("v_ref_d"))
977 .def_property_readonly("v_ref_q",
978 createAttributeGetter<CPS::Real>("v_ref_q"));
979
980 py::class_<CPS::EMT::Ph3::SSN::Capacitor,
981 std::shared_ptr<CPS::EMT::Ph3::SSN::Capacitor>,
982 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SSN_Capacitor",
983 py::multiple_inheritance())
984 .def(py::init<std::string>())
985 .def(py::init<std::string, CPS::Logger::Level>())
986 .def("set_parameters", &CPS::EMT::Ph3::SSN::Capacitor::setParameters,
987 "C"_a)
988 .def("connect", &CPS::EMT::Ph3::SSN::Capacitor::connect)
989 .def_property("C", createAttributeGetter<CPS::Matrix>("C"),
990 createAttributeSetter<CPS::Matrix>("C"));
991
992 py::class_<CPS::EMT::Ph3::GenericFourTerminalVTypeSSN,
993 std::shared_ptr<CPS::EMT::Ph3::GenericFourTerminalVTypeSSN>,
994 CPS::SimPowerComp<CPS::Real>>(
995 mEMTPh3, "GenericFourTerminalVTypeSSN", py::multiple_inheritance())
996 .def(py::init<std::string>())
997 .def(py::init<std::string, CPS::Logger::Level>())
998 .def("set_parameters",
999 &CPS::EMT::Ph3::GenericFourTerminalVTypeSSN::setParameters, "A"_a,
1000 "B"_a, "C"_a, "D"_a)
1001 .def("connect", &CPS::EMT::Ph3::GenericFourTerminalVTypeSSN::connect)
1002 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
1003}
EMT_DC_Capacitor.h
EMT_DC_CurrentSource.h
EMT_DC_Inductor.h
EMT_DC_PiLine.h
EMT_DC_Resistor.h
EMT_DC_VoltageSource.h
EMT_Ph3_GFL.h
EMT_Ph3_SSN_GFL.h
EMT_Ph3_SSN_GFL_Split.h
addEMTPh1Components
void addEMTPh1Components(py::module_ mEMTPh1)
Definition EMTComponents.cpp:149
addEMTPh3Components
void addEMTPh3Components(py::module_ mEMTPh3)
Definition EMTComponents.cpp:293
addEMTComponents
void addEMTComponents(py::module_ mEMT)
Definition EMTComponents.cpp:119
CPS::Base::Ph1::Capacitor::setParameters
void setParameters(Real capacitance)
Sets model specific parameters.
Definition Base_Ph1_Capacitor.h:26
CPS::Base::Ph1::Inductor::setParameters
void setParameters(Real inductance)
Sets model specific parameters.
Definition Base_Ph1_Inductor.h:26
CPS::Base::Ph1::Resistor::setParameters
void setParameters(Real resistance)
Definition Base_Ph1_Resistor.h:26
CPS::Base::Ph1::Switch
Dynamic Phasor Three-Phase Switch.
Definition Base_Ph1_Switch.h:18
CPS::Base::Ph1::Switch::close
void close()
Close switch.
Definition Base_Ph1_Switch.h:58
CPS::Base::Ph1::Switch::setParameters
void setParameters(Real openResistance, Real closedResistance, Bool closed=false)
Definition Base_Ph1_Switch.h:38
CPS::Base::Ph1::Switch::open
void open()
Open switch.
Definition Base_Ph1_Switch.h:60
CPS::Base::Ph3::Capacitor::setParameters
void setParameters(Matrix capacitance)
Sets model specific parameters.
Definition Base_Ph3_Capacitor.h:26
CPS::Base::Ph3::Inductor::setParameters
void setParameters(Matrix inductance)
Sets model specific parameters.
Definition Base_Ph3_Inductor.h:26
CPS::Base::Ph3::PiLine::setParameters
void setParameters(Matrix seriesResistance, Matrix seriesInductance, Matrix parallelCapacitance=Matrix::Zero(3, 3), Matrix parallelConductance=Matrix::Zero(3, 3)) const
Definition Base_Ph3_PiLine.h:36
CPS::Base::Ph3::Resistor::setParameters
void setParameters(Matrix resistance)
Sets model specific parameters.
Definition Base_Ph3_Resistor.h:25
CPS::Base::Ph3::Switch
Common base for three-phase switches.
Definition Base_Ph3_Switch.h:19
CPS::Base::Ph3::Switch::setParameters
void setParameters(Matrix openResistance, Matrix closedResistance, Bool closed=false)
Definition Base_Ph3_Switch.h:38
CPS::Base::SynchronGenerator::setInitialValues
void setInitialValues(Real initActivePower, Real initReactivePower, Real initTerminalVolt, Real initVoltAngle, Real initMechPower)
Definition Base_SynchronGenerator.cpp:216
CPS::EMT::DC::Capacitor::setParameters
void setParameters(Real capacitance)
Definition EMT_DC_Capacitor.cpp:18
CPS::EMT::DC::Inductor::setParameters
void setParameters(Real inductance, Real initialCurrent=0.0)
Definition EMT_DC_Inductor.cpp:19
CPS::EMT::DC::PiLine::setParameters
void setParameters(Real seriesResistance, Real seriesInductance, Real parallelCapacitance=0.0, Real parallelConductance=0.0, Real initialCurrent=0.0)
Definition EMT_DC_PiLine.cpp:30
CPS::EMT::DC::Resistor::setParameters
void setParameters(Real resistance)
Definition EMT_DC_Resistor.cpp:18
CPS::EMT::Ph1::CurrentSource
Ideal current source model.
Definition EMT_Ph1_CurrentSource.h:23
CPS::EMT::Ph1::CurrentSource::setParameters
void setParameters(Complex currentRef, Real srcFreq=-1)
Definition EMT_Ph1_CurrentSource.cpp:29
CPS::EMT::Ph1::SSN::Full_Serial_RLC
Full_Serial_RLC.
Definition EMT_Ph1_SSN_Full_Serial_RLC.h:38
CPS::EMT::Ph1::SSN::Full_Serial_RLC::setParameters
void setParameters(Real resistance, Real inductance, Real capacitance)
Definition EMT_Ph1_SSN_Full_Serial_RLC.cpp:207
CPS::EMT::Ph1::SSNTypeI2T
SSNTypeI2T Model for a one phase, two terminal I-type SSN component which can be represented using a ...
Definition EMT_Ph1_SSNTypeI2T.h:22
CPS::EMT::Ph1::SSNTypeI2T::setParameters
void setParameters(const Matrix A, const Matrix B, const Matrix C, const Matrix D)
Definition EMT_Ph1_SSNTypeI2T.cpp:25
CPS::EMT::Ph1::SSNTypeI2T::manualInit
void manualInit(Matrix initialState, Matrix initialInput, Matrix initialOldInput, Real initCurrent, Real initVoltage)
Definition EMT_Ph1_SSNTypeI2T.cpp:223
CPS::EMT::Ph1::SSNTypeV2T
SSNTypeV2T Model for a one phase, two terminal V-type SSN component which can be represented using a ...
Definition EMT_Ph1_SSNTypeV2T.h:22
CPS::EMT::Ph1::SSNTypeV2T::manualInit
void manualInit(Matrix initialState, Matrix initialInput, Matrix initialOldInput, Real initCurrent, Real initVoltage)
Definition EMT_Ph1_SSNTypeV2T.cpp:210
CPS::EMT::Ph1::SSNTypeV2T::setParameters
void setParameters(const Matrix A, const Matrix B, const Matrix C, const Matrix D)
Definition EMT_Ph1_SSNTypeV2T.cpp:24
CPS::EMT::Ph1::VoltageSource
Ideal Voltage source model.
Definition EMT_Ph1_VoltageSource.h:26
CPS::EMT::Ph1::VoltageSource::setParameters
void setParameters(Complex voltageRef, Real srcFreq=-1)
Definition EMT_Ph1_VoltageSource.cpp:24
CPS::EMT::Ph3::AvVoltSourceInverterStateSpace::setParameters
void setParameters(Real lf, Real cf, Real rf, Real rc, Real omegaN, Real kpPLL, Real kiPLL, Real omegaCutoff, Real pRef, Real qRef, Real kpPowerCtrl, Real kiPowerCtrl, Real kpCurrCtrl, Real kiCurrCtrl)
Definition EMT_Ph3_AvVoltSourceInverterStateSpace.cpp:55
CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setControllerParameters
void setControllerParameters(Real Kp_pll, Real Ki_pll, Real Kp_powerCtrl, Real Ki_powerCtrl, Real Kp_currCtrl, Real Ki_currCtrl, Real Omega_cutoff)
Setter for parameters of control loops.
Definition EMT_Ph3_AvVoltageSourceInverterDQ.cpp:143
CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setTransformerParameters
void setTransformerParameters(Real nomVoltageEnd1, Real nomVoltageEnd2, Real ratedPower, Real ratioAbs, Real ratioPhase, Real resistance, Real inductance, Real omega)
Setter for parameters of transformer.
Definition EMT_Ph3_AvVoltageSourceInverterDQ.cpp:115
CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setInitialStateValues
void setInitialStateValues(Real pInit, Real qInit, Real phi_dInit, Real phi_qInit, Real gamma_dInit, Real gamma_qInit)
Setter for initial values applied in controllers.
Definition EMT_Ph3_AvVoltageSourceInverterDQ.cpp:184
CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setFilterParameters
void setFilterParameters(Real Lf, Real Cf, Real Rf, Real Rc)
Setter for parameters of filter.
Definition EMT_Ph3_AvVoltageSourceInverterDQ.cpp:163
CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setParameters
void setParameters(Real sysOmega, Real sysVoltNom, Real Pref, Real Qref)
Setter for gengit eral parameters of inverter.
Definition EMT_Ph3_AvVoltageSourceInverterDQ.cpp:96
CPS::EMT::Ph3::CurrentSource
Ideal current source model.
Definition EMT_Ph3_CurrentSource.h:25
CPS::EMT::Ph3::CurrentSource::setParameters
void setParameters(MatrixComp currentRef, Real srcFreq=50.0)
Setter for reference current.
Definition EMT_Ph3_CurrentSource.cpp:32
CPS::EMT::Ph3::GFL::setInitialStateValues
void setInitialStateValues(Real pInit, Real qInit, Real phiDInit, Real phiQInit, Real gammaDInit, Real gammaQInit)
Definition EMT_Ph3_GFL.cpp:236
CPS::EMT::Ph3::GFL::setFilterParameters
void setFilterParameters(Real lf, Real cf, Real rf)
Filter parameters. No Rc exists in this model.
Definition EMT_Ph3_GFL.cpp:200
CPS::EMT::Ph3::GFL::setControllerParameters
void setControllerParameters(Real kpPLL, Real kiPLL, Real kpPowerCtrl, Real kiPowerCtrl, Real kpCurrCtrl, Real kiCurrCtrl, Real omegaCutoff)
Controller parameters.
Definition EMT_Ph3_GFL.cpp:148
CPS::EMT::Ph3::GFL::setParameters
void setParameters(Real sysOmega, Real sysVoltNom, Real pRef, Real qRef)
General operating parameters.
Definition EMT_Ph3_GFL.cpp:116
CPS::EMT::Ph3::GFL::withControl
void withControl(Bool controlOn)
Definition EMT_Ph3_GFL.h:173
CPS::EMT::Ph3::GenericTwoTerminalITypeSSN
Concrete generic three-phase, two-terminal I-type SSN component.
Definition EMT_Ph3_GenericTwoTerminalITypeSSN.h:18
CPS::EMT::Ph3::GenericTwoTerminalVTypeSSN
Concrete generic three-phase, two-terminal V-type SSN component.
Definition EMT_Ph3_GenericTwoTerminalVTypeSSN.h:18
CPS::EMT::Ph3::NetworkInjection::setParameters
void setParameters(MatrixComp voltageRef, Real srcFreq=50.0)
Setter for reference voltage parameters.
Definition EMT_Ph3_NetworkInjection.cpp:46
CPS::EMT::Ph3::PiecewiseLinearInductor
Three-phase, two-terminal, piecewise-linear flux-state inductor.
Definition EMT_Ph3_PiecewiseLinearInductor.h:34
CPS::EMT::Ph3::PiecewiseLinearInductor::setParameters
void setParameters(const std::vector< Real > &fluxBreakpoints, const std::vector< Real > &currentBreakpoints)
Definition EMT_Ph3_PiecewiseLinearInductor.cpp:21
CPS::EMT::Ph3::RXLoad::setParameters
void setParameters(Matrix activePower, Matrix reactivePower, Real volt, bool reactanceInSeries=false)
Definition EMT_Ph3_RXLoad.cpp:59
CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR
Base class for EMT VBR simplefied synchronous generator models.
Definition EMT_Ph3_ReducedOrderSynchronGeneratorVBR.h:20
CPS::EMT::Ph3::SSN::Capacitor::setParameters
void setParameters(Matrix capacitance)
Definition EMT_Ph3_SSN_Capacitor.cpp:21
CPS::EMT::Ph3::SSN::Full_Serial_RLC
Full_Serial_RLC.
Definition EMT_Ph3_SSN_Full_Serial_RLC.h:32
CPS::EMT::Ph3::SSN::Full_Serial_RLC::setParameters
void setParameters(const Matrix &resistance, const Matrix &inductance, const Matrix &capacitance)
Definition EMT_Ph3_SSN_Full_Serial_RLC.cpp:20
CPS::EMT::Ph3::SSN_GFL_Split
Partitioned three-phase grid-following inverter.
Definition EMT_Ph3_SSN_GFL_Split.h:48
CPS::EMT::Ph3::SSN_GFL_Split::getState
Matrix getState() const
Combined state in the same logical order as the former monolithic GFL: 8 controller states followed b...
Definition EMT_Ph3_SSN_GFL_Split.cpp:660
CPS::EMT::Ph3::SSN_GFL_Split::getControllerB
Matrix getControllerB() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:713
CPS::EMT::Ph3::SSN_GFL_Split::getNetworkB
Matrix getNetworkB() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:725
CPS::EMT::Ph3::SSN_GFL_Split::getControllerD
Matrix getControllerD() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:717
CPS::EMT::Ph3::SSN_GFL_Split::getDelayedConverterVoltage
Matrix getDelayedConverterVoltage() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:707
CPS::EMT::Ph3::SSN_GFL_Split::getConverterVoltageReference
Matrix getConverterVoltageReference() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:703
CPS::EMT::Ph3::SSN_GFL_Split::getControllerC
Matrix getControllerC() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:715
CPS::EMT::Ph3::SSN_GFL_Split::getEquivalentConductance
Matrix getEquivalentConductance() const
Constant SSN Norton conductance G = mW.
Definition EMT_Ph3_SSN_GFL_Split.cpp:744
CPS::EMT::Ph3::SSN_GFL_Split::getControllerF
Matrix getControllerF() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:721
CPS::EMT::Ph3::SSN_GFL_Split::getControllerA
Matrix getControllerA() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:711
CPS::EMT::Ph3::SSN_GFL_Split::getNetworkState
Matrix getNetworkState() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:673
CPS::EMT::Ph3::SSN_GFL_Split::getNetworkD
Matrix getNetworkD() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:736
CPS::EMT::Ph3::SSN_GFL_Split::getInterfaceVoltage
Matrix getInterfaceVoltage() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:695
CPS::EMT::Ph3::SSN_GFL_Split::getLocalStateNames
std::vector< String > getLocalStateNames() const override final
Definition EMT_Ph3_SSN_GFL_Split.cpp:46
CPS::EMT::Ph3::SSN_GFL_Split::getControllerE
Matrix getControllerE() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:719
CPS::EMT::Ph3::SSN_GFL_Split::getInterfaceCurrent
Matrix getInterfaceCurrent() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:699
CPS::EMT::Ph3::SSN_GFL_Split::setParameters
void setParameters(Real lf, Real cf, Real rf, Real rc, Real omegaN, Real kpPLL, Real kiPLL, Real omegaCutoff, Real pRef, Real qRef, Real kpPowerCtrl, Real kiPowerCtrl, Real kpCurrCtrl, Real kiCurrCtrl)
Configure the filter, PLL, power controller and current controller.
Definition EMT_Ph3_SSN_GFL_Split.cpp:87
CPS::EMT::Ph3::SSN_GFL_Split::getControllerState
Matrix getControllerState() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:669
CPS::EMT::Ph3::SSN_GFL_Split::getStateDerivative
Matrix getStateDerivative() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:675
CPS::EMT::Ph3::SSN_GFL_Split::getNetworkA
Matrix getNetworkA() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:723
CPS::EMT::Ph3::SSN_GFL_Split::getNetworkC
Matrix getNetworkC() const
Definition EMT_Ph3_SSN_GFL_Split.cpp:734
CPS::EMT::Ph3::SSN_GFL::getInterfaceVoltage
Matrix getInterfaceVoltage() const
Definition EMT_Ph3_SSN_GFL.cpp:623
CPS::EMT::Ph3::SSN_GFL::getLocalStateNames
std::vector< String > getLocalStateNames() const override final
Definition EMT_Ph3_SSN_GFL.cpp:36
CPS::EMT::Ph3::SSN_GFL::getInterfaceCurrent
Matrix getInterfaceCurrent() const
Definition EMT_Ph3_SSN_GFL.cpp:625
CPS::EMT::Ph3::SSN_GFL::setParameters
void setParameters(Real lf, Real cf, Real rf, Real rc, Real omegaN, Real kpPLL, Real kiPLL, Real omegaCutoff, Real pRef, Real qRef, Real kpPowerCtrl, Real kiPowerCtrl, Real kpCurrCtrl, Real kiCurrCtrl)
Configure the GFL filter, PLL, power loop and current loop.
Definition EMT_Ph3_SSN_GFL.cpp:54
CPS::EMT::Ph3::SSN_GFL::getStateDerivative
Matrix getStateDerivative() const
Definition EMT_Ph3_SSN_GFL.cpp:617
CPS::EMT::Ph3::SSN_GFL::getState
Matrix getState() const
Definition EMT_Ph3_SSN_GFL.cpp:615
CPS::EMT::Ph3::SSN_GFM::setNumericalLinearizationParameters
void setNumericalLinearizationParameters(Real relativeStep, Real absoluteStep)
Configure finite-difference steps for local linearization.
Definition EMT_Ph3_SSN_GFM.cpp:182
CPS::EMT::Ph3::SSN_GFM::getStateDerivative
Matrix getStateDerivative() const
Definition EMT_Ph3_SSN_GFM.cpp:1085
CPS::EMT::Ph3::SSN_GFM::getInterfaceCurrent
Matrix getInterfaceCurrent() const
Definition EMT_Ph3_SSN_GFM.cpp:1095
CPS::EMT::Ph3::SSN_GFM::getInterfaceVoltage
Matrix getInterfaceVoltage() const
Definition EMT_Ph3_SSN_GFM.cpp:1093
CPS::EMT::Ph3::SSN_GFM::setReactivePowerDroop
void setReactivePowerDroop(Real droopGain, Real cutoff)
Opt-in proportional Q-V droop replacing the integral excitation. droopGain is Dq [V/var]; cutoff [rad...
Definition EMT_Ph3_SSN_GFM.cpp:210
CPS::EMT::Ph3::SSN_GFM::getState
Matrix getState() const
Definition EMT_Ph3_SSN_GFM.cpp:1083
CPS::EMT::Ph3::SSN_GFM::setParameters
void setParameters(Real lf, Real cf, Real rf, Real rc, Real nominalVoltage, Real omegaN, Real pRef, Real qRef, Real virtualInertia, Real dampingCoefficient, Real voltageDroopGain, Real reactiveIntegralGain, Real kpVoltage, Real kiVoltage, Real kpCurrent, Real kiCurrent, Real activeDampingGain, Real powerFilterCutoff, Real delayBandwidth)
Configure the GFM model.
Definition EMT_Ph3_SSN_GFM.cpp:96
CPS::EMT::Ph3::SSN_GFM::getLocalStateNames
std::vector< String > getLocalStateNames() const override final
Definition EMT_Ph3_SSN_GFM.cpp:58
CPS::EMT::Ph3::SSN_GFM::setGridCurrentFeedforward
void setGridCurrentFeedforward(Real scale)
Scale on the voltage-loop grid-current feedforward (default 1).
Definition EMT_Ph3_SSN_GFM.cpp:206
CPS::EMT::Ph3::SSN_GFM::setVirtualImpedance
void setVirtualImpedance(Real virtualResistance, Real virtualReactance=0.0)
Opt-in virtual output impedance Zv = Rv + jXv, subtracted from the EMF reference across the filter cu...
Definition EMT_Ph3_SSN_GFM.cpp:197
CPS::EMT::Ph3::Shunt::setParameters
void setParameters(Real conductance, Real susceptance)
Set shunt specific parameters.
Definition EMT_Ph3_Shunt.cpp:22
CPS::EMT::Ph3::Switch::closeSwitch
void closeSwitch() override
Definition EMT_Ph3_Switch.cpp:162
CPS::EMT::Ph3::Switch::openSwitch
void openSwitch() override
Definition EMT_Ph3_Switch.cpp:107
CPS::EMT::Ph3::SynchronGenerator3OrderVBR
Voltage-Behind-Reactance (VBR) implementation of 3rd order synchronous generator model.
Definition EMT_Ph3_SynchronGenerator3OrderVBR.h:20
CPS::EMT::Ph3::SynchronGenerator4OrderVBR
Voltage-Behind-Reactance (VBR) implementation of 4th order synchronous generator model.
Definition EMT_Ph3_SynchronGenerator4OrderVBR.h:20
CPS::EMT::Ph3::SynchronGenerator5OrderVBR
Voltage-Behind-Reactance (VBR) implementation of 5th type 2 order synchronous generator model Ref: Mi...
Definition EMT_Ph3_SynchronGenerator5OrderVBR.h:21
CPS::EMT::Ph3::SynchronGenerator6aOrderVBR
Voltage-Behind-Reactance (VBR) implementation of 6th order synchronous generator model Marconato's mo...
Definition EMT_Ph3_SynchronGenerator6aOrderVBR.h:21
CPS::EMT::Ph3::SynchronGenerator6bOrderVBR
Voltage-Behind-Reactance (VBR) implementation of 6th order synchronous generator model Anderson - Fou...
Definition EMT_Ph3_SynchronGenerator6bOrderVBR.h:21
CPS::EMT::Ph3::SynchronGeneratorIdeal
Ideal voltage source representing a synchronous generator.
Definition EMT_Ph3_SynchronGeneratorIdeal.h:21
CPS::EMT::Ph3::Transformer
Transformer that includes an inductance and resistance.
Definition EMT_Ph3_Transformer.h:24
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::VSIVoltageControlVCO::setParameters
void setParameters(Real sysOmega, Real VdRef, Real VqRef)
Setter for general parameters of the component.
Definition EMT_Ph3_VSIVoltageControlVCO.cpp:102
CPS::EMT::Ph3::VSIVoltageControlVCO::setFilterParameters
void setFilterParameters(Real Lf, Real Cf, Real Rf, Real Rc)
Setter for parameters of filter.
Definition EMT_Ph3_VSIVoltageControlVCO.cpp:162
CPS::EMT::Ph3::VSIVoltageControlVCO::setControllerParameters
void setControllerParameters(Real Kp_voltageCtrl, Real Ki_voltageCtrl, Real Kp_currCtrl, Real Ki_currCtrl, Real Omega_nominal)
Setter for parameters of control loops.
Definition EMT_Ph3_VSIVoltageControlVCO.cpp:146
CPS::EMT::Ph3::VSIVoltageControlVCO::setInitialStateValues
void setInitialStateValues(Real phi_dInit, Real phi_qInit, Real gamma_dInit, Real gamma_qInit)
Setter for initial values applied in controllers.
Definition EMT_Ph3_VSIVoltageControlVCO.cpp:183
CPS::EMT::Ph3::VSIVoltageControlVCO::setTransformerParameters
void setTransformerParameters(Real nomVoltageEnd1, Real nomVoltageEnd2, Real ratedPower, Real ratioAbs, Real ratioPhase, Real resistance, Real inductance, Real omega)
Setter for parameters of transformer.
Definition EMT_Ph3_VSIVoltageControlVCO.cpp:118
CPS::EMT::Ph3::VoltageSource
Ideal Voltage source model.
Definition EMT_Ph3_VoltageSource.h:29
CPS::EMT::Ph3::VoltageSource::setParameters
void setParameters(MatrixComp voltageRef, Real srcFreq=50.0)
Setter for reference voltage and frequency with a sine wave generator.
Definition EMT_Ph3_VoltageSource.cpp:26
CPS::EMT::SSNComp::setParameters
void setParameters(const Matrix &A, const Matrix &B, const Matrix &C, const Matrix &D)
Definition EMT_SSNComp.cpp:36
CPS::SimNode< Real >::GND
static Ptr GND
Definition SimNode.h:35
CPS::SimPowerComp
Base class for all components that are transmitting power.
Definition SimPowerComp.h:17
CPS::SimPowerComp< Real >::connect
void connect(typename SimNode< Real >::List nodes)
Definition SimPowerComp.cpp:269
CPS::TopologicalNode::setInitialVoltage
void setInitialVoltage(MatrixComp voltage) const
Definition TopologicalNode.cpp:17
createAttributeGetter
py::cpp_function createAttributeGetter(const std::string name)
Definition Utils.h:27
createAttributeSetter
py::cpp_function createAttributeSetter(const std::string name)
Definition Utils.h:20
CPS::String
std::string String
Definition Definitions.h:65
CPS::Real
double Real
Definition Definitions.h:62
zeroMatrix
CPS::Matrix zeroMatrix(int dim)
Definition Utils.cpp:11