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
31PYBIND11_DECLARE_HOLDER_TYPE(T, CPS::AttributePointer<T>);
32
33namespace py = pybind11;
34using namespace pybind11::literals;
35
36namespace {
37
38void addEMTDCComponents(py::module_ mEMTDC) {
39 py::class_<CPS::EMT::DC::VoltageSource,
40 std::shared_ptr<CPS::EMT::DC::VoltageSource>,
41 CPS::SimPowerComp<CPS::Real>>(mEMTDC, "VoltageSource",
42 py::multiple_inheritance())
43 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
44 "loglevel"_a = CPS::Logger::Level::off)
45 .def("set_parameters", &CPS::EMT::DC::VoltageSource::setParameters,
46 "voltage"_a)
47 .def("connect", &CPS::EMT::DC::VoltageSource::connect)
48 .def_property_readonly("V_ref",
49 createAttributeGetter<CPS::Real>("V_ref"));
50
51 py::class_<CPS::EMT::DC::CurrentSource,
52 std::shared_ptr<CPS::EMT::DC::CurrentSource>,
53 CPS::SimPowerComp<CPS::Real>>(mEMTDC, "CurrentSource",
54 py::multiple_inheritance())
55 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
56 "loglevel"_a = CPS::Logger::Level::off)
57 .def("set_parameters", &CPS::EMT::DC::CurrentSource::setParameters,
58 "current"_a)
59 .def("connect", &CPS::EMT::DC::CurrentSource::connect)
60 .def_property_readonly("I_ref",
61 createAttributeGetter<CPS::Real>("I_ref"));
62
63 py::class_<CPS::EMT::DC::Resistor, std::shared_ptr<CPS::EMT::DC::Resistor>,
64 CPS::SimPowerComp<CPS::Real>>(mEMTDC, "Resistor",
65 py::multiple_inheritance())
66 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
67 "loglevel"_a = CPS::Logger::Level::off)
68 .def("set_parameters", &CPS::EMT::DC::Resistor::setParameters,
69 "resistance"_a)
70 .def("connect", &CPS::EMT::DC::Resistor::connect)
71 .def_property_readonly("R", createAttributeGetter<CPS::Real>("R"));
72
73 py::class_<CPS::EMT::DC::Capacitor, std::shared_ptr<CPS::EMT::DC::Capacitor>,
74 CPS::SimPowerComp<CPS::Real>>(mEMTDC, "Capacitor",
75 py::multiple_inheritance())
76 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
77 "loglevel"_a = CPS::Logger::Level::off)
78 .def("set_parameters", &CPS::EMT::DC::Capacitor::setParameters,
79 "capacitance"_a)
80 .def("connect", &CPS::EMT::DC::Capacitor::connect)
81 .def_property_readonly("C", createAttributeGetter<CPS::Real>("C"))
82 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
83
84 py::class_<CPS::EMT::DC::Inductor, std::shared_ptr<CPS::EMT::DC::Inductor>,
85 CPS::SimPowerComp<CPS::Real>>(mEMTDC, "Inductor",
86 py::multiple_inheritance())
87 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
88 "loglevel"_a = CPS::Logger::Level::off)
89 .def("set_parameters", &CPS::EMT::DC::Inductor::setParameters,
90 "inductance"_a, "initial_current"_a = 0.0)
91 .def("connect", &CPS::EMT::DC::Inductor::connect)
92 .def_property_readonly("L", createAttributeGetter<CPS::Real>("L"))
93 .def_property_readonly("initial_current",
94 createAttributeGetter<CPS::Real>("i_init"))
95 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
96
97 py::class_<CPS::EMT::DC::PiLine, std::shared_ptr<CPS::EMT::DC::PiLine>,
98 CPS::SimPowerComp<CPS::Real>>(mEMTDC, "PiLine",
99 py::multiple_inheritance())
100 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
101 "loglevel"_a = CPS::Logger::Level::off)
102 .def("set_parameters", &CPS::EMT::DC::PiLine::setParameters,
103 "series_resistance"_a, "series_inductance"_a,
104 "parallel_capacitance"_a = 0.0, "parallel_conductance"_a = 0.0,
105 "initial_current"_a = 0.0)
106 .def("connect", &CPS::EMT::DC::PiLine::connect)
107 .def_property_readonly("series_resistance",
108 createAttributeGetter<CPS::Real>("R_series"))
109 .def_property_readonly("series_inductance",
110 createAttributeGetter<CPS::Real>("L_series"))
111 .def_property_readonly("parallel_capacitance",
112 createAttributeGetter<CPS::Real>("C_parallel"))
113 .def_property_readonly("parallel_conductance",
114 createAttributeGetter<CPS::Real>("G_parallel"))
115 .def_property_readonly("initial_current",
116 createAttributeGetter<CPS::Real>("i_init"));
117}
118
119} // namespace
120
121void addEMTComponents(py::module_ mEMT) {
122 py::class_<CPS::EMT::SimNode, std::shared_ptr<CPS::EMT::SimNode>,
123 CPS::TopologicalNode>(mEMT, "SimNode", py::module_local())
124 .def(py::init<std::string>())
125 .def(py::init<std::string, CPS::PhaseType>())
126 .def(py::init<std::string, CPS::PhaseType,
127 const std::vector<CPS::Complex>>())
128 .def("set_initial_voltage",
129 py::overload_cast<CPS::MatrixComp>(
130 &CPS::EMT::SimNode::setInitialVoltage, py::const_))
131 .def("set_initial_voltage",
132 py::overload_cast<CPS::Complex>(
133 &CPS::EMT::SimNode::setInitialVoltage, py::const_))
134 .def("set_initial_voltage",
135 py::overload_cast<CPS::Complex, int>(
136 &CPS::EMT::SimNode::setInitialVoltage, py::const_))
137 .def_readonly_static("gnd", &CPS::EMT::SimNode::GND);
138
139 py::module_ mEMTDC =
140 mEMT.def_submodule("dc", "scalar electromagnetic-transient DC models");
141 addEMTDCComponents(mEMTDC);
142
143 py::module mEMTPh1 = mEMT.def_submodule(
144 "ph1", "single phase electromagnetic-transient models");
145 addEMTPh1Components(mEMTPh1);
146 py::module mEMTPh3 =
147 mEMT.def_submodule("ph3", "three phase electromagnetic-transient models");
148 addEMTPh3Components(mEMTPh3);
149}
150
151void addEMTPh1Components(py::module_ mEMTPh1) {
152 py::class_<CPS::EMT::Ph1::CurrentSource,
153 std::shared_ptr<CPS::EMT::Ph1::CurrentSource>,
154 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "CurrentSource",
155 py::multiple_inheritance())
156 .def(py::init<std::string>())
157 .def(py::init<std::string, CPS::Logger::Level>())
158 .def("set_parameters", &CPS::EMT::Ph1::CurrentSource::setParameters,
159 "I_ref"_a, "f_src"_a = -1)
160 .def("connect", &CPS::EMT::Ph1::CurrentSource::connect)
161 .def_property("I_ref", createAttributeGetter<CPS::Complex>("I_ref"),
162 createAttributeSetter<CPS::Complex>("I_ref"))
163 .def_property("f_src", createAttributeGetter<CPS::Real>("f_src"),
164 createAttributeSetter<CPS::Real>("f_src"));
165
166 py::class_<CPS::EMT::Ph1::VoltageSource,
167 std::shared_ptr<CPS::EMT::Ph1::VoltageSource>,
168 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "VoltageSource",
169 py::multiple_inheritance())
170 .def(py::init<std::string>())
171 .def(py::init<std::string, CPS::Logger::Level>())
172 .def("set_parameters", &CPS::EMT::Ph1::VoltageSource::setParameters,
173 "V_ref"_a, "f_src"_a = -1)
174 .def("connect", &CPS::EMT::Ph1::VoltageSource::connect)
175 .def_property("V_ref", createAttributeGetter<CPS::Complex>("V_ref"),
176 createAttributeSetter<CPS::Complex>("V_ref"))
177 .def_property("f_src", createAttributeGetter<CPS::Real>("f_src"),
178 createAttributeSetter<CPS::Real>("f_src"));
179
180 py::class_<CPS::EMT::Ph1::Resistor, std::shared_ptr<CPS::EMT::Ph1::Resistor>,
181 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "Resistor",
182 py::multiple_inheritance())
183 .def(py::init<std::string>())
184 .def(py::init<std::string, CPS::Logger::Level>())
185 .def("set_parameters", &CPS::EMT::Ph1::Resistor::setParameters, "R"_a)
186 .def("connect", &CPS::EMT::Ph1::Resistor::connect)
187 .def_property("R", createAttributeGetter<CPS::Real>("R"),
188 createAttributeSetter<CPS::Real>("R"));
189
190 py::class_<CPS::EMT::Ph1::Capacitor,
191 std::shared_ptr<CPS::EMT::Ph1::Capacitor>,
192 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "Capacitor",
193 py::multiple_inheritance())
194 .def(py::init<std::string>())
195 .def(py::init<std::string, CPS::Logger::Level>())
196 .def("set_parameters", &CPS::EMT::Ph1::Capacitor::setParameters, "C"_a)
197 .def("connect", &CPS::EMT::Ph1::Capacitor::connect)
198 .def_property("C", createAttributeGetter<CPS::Real>("C"),
199 createAttributeSetter<CPS::Real>("C"));
200
201 py::class_<CPS::EMT::Ph1::Inductor, std::shared_ptr<CPS::EMT::Ph1::Inductor>,
202 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "Inductor",
203 py::multiple_inheritance())
204 .def(py::init<std::string>())
205 .def(py::init<std::string, CPS::Logger::Level>())
206 .def("set_parameters", &CPS::EMT::Ph1::Inductor::setParameters, "L"_a)
207 .def("connect", &CPS::EMT::Ph1::Inductor::connect)
208 .def_property("L", createAttributeGetter<CPS::Real>("L"),
209 createAttributeSetter<CPS::Real>("L"));
210
211 py::class_<CPS::EMT::Ph1::Switch, std::shared_ptr<CPS::EMT::Ph1::Switch>,
212 CPS::SimPowerComp<CPS::Real>, CPS::Base::Ph1::Switch>(
213 mEMTPh1, "Switch", py::multiple_inheritance())
214 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
215 "loglevel"_a = CPS::Logger::Level::off)
216 .def("set_parameters", &CPS::EMT::Ph1::Switch::setParameters,
217 "open_resistance"_a, "closed_resistance"_a,
218 "closed"_a = false) // cppcheck-suppress assignBoolToPointer
219 .def("open", &CPS::EMT::Ph1::Switch::open)
220 .def("close", &CPS::EMT::Ph1::Switch::close)
221 .def("connect", &CPS::EMT::Ph1::Switch::connect);
222
223 py::class_<CPS::EMT::Ph1::SSN::Full_Serial_RLC,
224 std::shared_ptr<CPS::EMT::Ph1::SSN::Full_Serial_RLC>,
225 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "Full_Serial_RLC",
226 py::multiple_inheritance())
227 .def(py::init<std::string>())
228 .def(py::init<std::string, CPS::Logger::Level>())
229 .def("set_parameters",
230 &CPS::EMT::Ph1::SSN::Full_Serial_RLC::setParameters, "R"_a, "L"_a,
231 "C"_a)
232 .def("connect", &CPS::EMT::Ph1::SSN::Full_Serial_RLC::connect)
233 .def_property("R", createAttributeGetter<CPS::Real>("R"),
234 createAttributeSetter<CPS::Real>("R"))
235 .def_property("L", createAttributeGetter<CPS::Real>("L"),
236 createAttributeSetter<CPS::Real>("L"))
237 .def_property("C", createAttributeGetter<CPS::Real>("C"),
238 createAttributeSetter<CPS::Real>("C"));
239
240 py::class_<CPS::EMT::Ph1::SSNTypeI2T,
241 std::shared_ptr<CPS::EMT::Ph1::SSNTypeI2T>,
242 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "SSNTypeI2T",
243 py::multiple_inheritance())
244 .def(py::init<std::string>())
245 .def(py::init<std::string, CPS::Logger::Level>())
246 .def("set_parameters", &CPS::EMT::Ph1::SSNTypeI2T::setParameters, "A"_a,
247 "B"_a, "C"_a, "D"_a)
248 .def("manual_init", &CPS::EMT::Ph1::SSNTypeI2T::manualInit,
249 "initialState"_a, "initialInput"_a, "initialOldInput"_a,
250 "initCurr"_a, "initVol"_a)
251 .def("connect", &CPS::EMT::Ph1::SSNTypeI2T::connect)
252 .def_property("mA", createAttributeGetter<CPS::Matrix>("mA"),
253 createAttributeSetter<CPS::Matrix>("mA"))
254 .def_property("mB", createAttributeGetter<CPS::Matrix>("mB"),
255 createAttributeSetter<CPS::Matrix>("mB"))
256 .def_property("mC", createAttributeGetter<CPS::Matrix>("mC"),
257 createAttributeSetter<CPS::Matrix>("mC"))
258 .def_property("mD", createAttributeGetter<CPS::Matrix>("mD"),
259 createAttributeSetter<CPS::Matrix>("mD"))
260 .def_property("mdA", createAttributeGetter<CPS::Matrix>("mdA"),
261 createAttributeSetter<CPS::Matrix>("mdA"))
262 .def_property("mdB", createAttributeGetter<CPS::Matrix>("mdB"),
263 createAttributeSetter<CPS::Matrix>("mdB"))
264 .def_property("mdC", createAttributeGetter<CPS::Matrix>("mdC"),
265 createAttributeSetter<CPS::Matrix>("mdC"));
266
267 py::class_<CPS::EMT::Ph1::SSNTypeV2T,
268 std::shared_ptr<CPS::EMT::Ph1::SSNTypeV2T>,
269 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "SSNTypeV2T",
270 py::multiple_inheritance())
271 .def(py::init<std::string>())
272 .def(py::init<std::string, CPS::Logger::Level>())
273 .def("set_parameters", &CPS::EMT::Ph1::SSNTypeV2T::setParameters, "A"_a,
274 "B"_a, "C"_a, "D"_a)
275 .def("manual_init", &CPS::EMT::Ph1::SSNTypeV2T::manualInit,
276 "initialState"_a, "initialInput"_a, "initialOldInput"_a,
277 "initCurr"_a, "initVol"_a)
278 .def("connect", &CPS::EMT::Ph1::SSNTypeV2T::connect)
279 .def_property("mA", createAttributeGetter<CPS::Matrix>("mA"),
280 createAttributeSetter<CPS::Matrix>("mA"))
281 .def_property("mB", createAttributeGetter<CPS::Matrix>("mB"),
282 createAttributeSetter<CPS::Matrix>("mB"))
283 .def_property("mC", createAttributeGetter<CPS::Matrix>("mC"),
284 createAttributeSetter<CPS::Matrix>("mC"))
285 .def_property("mD", createAttributeGetter<CPS::Matrix>("mD"),
286 createAttributeSetter<CPS::Matrix>("mD"))
287 .def_property("mdA", createAttributeGetter<CPS::Matrix>("mdA"),
288 createAttributeSetter<CPS::Matrix>("mdA"))
289 .def_property("mdB", createAttributeGetter<CPS::Matrix>("mdB"),
290 createAttributeSetter<CPS::Matrix>("mdB"))
291 .def_property("mdC", createAttributeGetter<CPS::Matrix>("mdC"),
292 createAttributeSetter<CPS::Matrix>("mdC"));
293}
294
295void addEMTPh3Components(py::module_ mEMTPh3) {
296 py::class_<CPS::EMT::Ph3::VoltageSource,
297 std::shared_ptr<CPS::EMT::Ph3::VoltageSource>,
298 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "VoltageSource",
299 py::multiple_inheritance())
300 .def(py::init<std::string>())
301 .def(py::init<std::string, CPS::Logger::Level>())
302 .def("set_parameters",
303 py::overload_cast<CPS::MatrixComp, CPS::Real>(
304 &CPS::EMT::Ph3::VoltageSource::setParameters),
305 "V_ref"_a, "f_src"_a = 50)
306 .def("connect", &CPS::EMT::Ph3::VoltageSource::connect)
307 .def_property("V_ref", createAttributeGetter<CPS::MatrixComp>("V_ref"),
308 createAttributeSetter<CPS::MatrixComp>("V_ref"))
309 .def_property("f_src", createAttributeGetter<CPS::Real>("f_src"),
310 createAttributeSetter<CPS::Real>("f_src"));
311
312 py::class_<CPS::EMT::Ph3::ControlledVoltageSource,
313 std::shared_ptr<CPS::EMT::Ph3::ControlledVoltageSource>,
314 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "ControlledVoltageSource",
315 py::multiple_inheritance())
316 .def(py::init<std::string>())
317 .def(py::init<std::string, CPS::Logger::Level>())
318 .def("set_parameters",
319 py::overload_cast<CPS::Matrix>(
320 &CPS::EMT::Ph3::ControlledVoltageSource::setParameters),
321 "V_ref"_a)
322 .def("connect", &CPS::EMT::Ph3::ControlledVoltageSource::connect)
323 .def_property("V_ref", createAttributeGetter<CPS::MatrixComp>("V_ref"),
324 createAttributeSetter<CPS::MatrixComp>("V_ref"));
325
326 py::class_<CPS::EMT::Ph3::CurrentSource,
327 std::shared_ptr<CPS::EMT::Ph3::CurrentSource>,
328 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "CurrentSource",
329 py::multiple_inheritance())
330 .def(py::init<std::string>())
331 .def(py::init<std::string, CPS::Logger::Level>())
332 .def("set_parameters",
333 py::overload_cast<CPS::MatrixComp, CPS::Real>(
334 &CPS::EMT::Ph3::CurrentSource::setParameters),
335 "I_ref"_a, "f_src"_a = 50)
336 .def("connect", &CPS::EMT::Ph3::CurrentSource::connect)
337 .def_property("I_ref", createAttributeGetter<CPS::MatrixComp>("I_ref"),
338 createAttributeSetter<CPS::MatrixComp>("V_ref"))
339 .def_property("f_src", createAttributeGetter<CPS::Real>("f_src"),
340 createAttributeSetter<CPS::Real>("f_src"));
341
342 py::class_<CPS::EMT::Ph3::Resistor, std::shared_ptr<CPS::EMT::Ph3::Resistor>,
343 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Resistor",
344 py::multiple_inheritance())
345 .def(py::init<std::string>())
346 .def(py::init<std::string, CPS::Logger::Level>())
347 .def("set_parameters", &CPS::EMT::Ph3::Resistor::setParameters, "R"_a)
348 .def("connect", &CPS::EMT::Ph3::Resistor::connect);
349
350 py::class_<CPS::EMT::Ph3::Capacitor,
351 std::shared_ptr<CPS::EMT::Ph3::Capacitor>,
352 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Capacitor",
353 py::multiple_inheritance())
354 .def(py::init<std::string>())
355 .def(py::init<std::string, CPS::Logger::Level>())
356 .def("set_parameters", &CPS::EMT::Ph3::Capacitor::setParameters, "C"_a)
357 .def("connect", &CPS::EMT::Ph3::Capacitor::connect);
358
359 py::class_<CPS::EMT::Ph3::Inductor, std::shared_ptr<CPS::EMT::Ph3::Inductor>,
360 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Inductor",
361 py::multiple_inheritance())
362 .def(py::init<std::string>())
363 .def(py::init<std::string, CPS::Logger::Level>())
364 .def("set_parameters", &CPS::EMT::Ph3::Inductor::setParameters, "L"_a)
365 .def("connect", &CPS::EMT::Ph3::Inductor::connect);
366
367 py::class_<CPS::EMT::Ph3::NetworkInjection,
368 std::shared_ptr<CPS::EMT::Ph3::NetworkInjection>,
369 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "NetworkInjection",
370 py::multiple_inheritance())
371 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
372 "loglevel"_a = CPS::Logger::Level::off)
373 .def("set_parameters",
374 py::overload_cast<CPS::MatrixComp, CPS::Real>(
375 &CPS::EMT::Ph3::NetworkInjection::setParameters),
376 "V_ref"_a, "f_src"_a = 50)
377 .def("connect", &CPS::EMT::Ph3::NetworkInjection::connect);
378
379 py::class_<CPS::EMT::Ph3::PiLine, std::shared_ptr<CPS::EMT::Ph3::PiLine>,
380 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "PiLine",
381 py::multiple_inheritance())
382 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
383 "loglevel"_a = CPS::Logger::Level::off)
384 .def("set_parameters", &CPS::EMT::Ph3::PiLine::setParameters,
385 "series_resistance"_a, "series_inductance"_a,
386 "parallel_capacitance"_a = zeroMatrix(3),
387 "parallel_conductance"_a = zeroMatrix(3))
388 .def("connect", &CPS::EMT::Ph3::PiLine::connect);
389
390 py::class_<CPS::EMT::Ph3::HalfDecouplingLine,
391 std::shared_ptr<CPS::EMT::Ph3::HalfDecouplingLine>,
392 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "HalfDecouplingLine",
393 py::multiple_inheritance())
394 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
395 "loglevel"_a = CPS::Logger::Level::off)
396 .def("set_parameters", &CPS::EMT::Ph3::HalfDecouplingLine::setParameters,
397 "resistance"_a, "inductance"_a, "capacitance"_a)
398 .def("set_coupling_source",
399 &CPS::EMT::Ph3::HalfDecouplingLine::setCouplingSource,
400 "receiving_volt"_a, "receiving_cur"_a)
401 .def("connect", &CPS::EMT::Ph3::HalfDecouplingLine::connect);
402
403 py::class_<CPS::EMT::Ph3::RXLoad, std::shared_ptr<CPS::EMT::Ph3::RXLoad>,
404 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "RXLoad",
405 py::multiple_inheritance())
406 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
407 "loglevel"_a = CPS::Logger::Level::off)
408 .def("set_parameters", &CPS::EMT::Ph3::RXLoad::setParameters,
409 "active_power"_a, "reactive_power"_a, "volt"_a,
410 // cppcheck-suppress assignBoolToPointer
411 "reactance_in_series"_a = false)
412 .def("connect", &CPS::EMT::Ph3::RXLoad::connect);
413
414 py::class_<CPS::EMT::Ph3::PQLoad, std::shared_ptr<CPS::EMT::Ph3::PQLoad>,
415 CPS::SimPowerComp<CPS::Real>, CPS::MNASyncGenInterface>(
416 mEMTPh3, "PQLoad", py::multiple_inheritance())
417 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
418 "loglevel"_a = CPS::Logger::Level::off)
419 .def("set_parameters", &CPS::EMT::Ph3::PQLoad::setParameters,
420 "active_power"_a, "reactive_power"_a, "nominal_voltage"_a,
421 "minimum_voltage_per_unit"_a = 0.1)
422 .def("connect", &CPS::EMT::Ph3::PQLoad::connect)
423 .def_property("P", createAttributeGetter<CPS::Real>("P"),
424 createAttributeSetter<CPS::Real>("P"))
425 .def_property("Q", createAttributeGetter<CPS::Real>("Q"),
426 createAttributeSetter<CPS::Real>("Q"))
427 .def_property("V_nom", createAttributeGetter<CPS::Real>("V_nom"),
428 createAttributeSetter<CPS::Real>("V_nom"))
429 .def_property("V_min_pu", createAttributeGetter<CPS::Real>("V_min_pu"),
430 createAttributeSetter<CPS::Real>("V_min_pu"))
431 .def_property_readonly("p_inst",
432 createAttributeGetter<CPS::Real>("p_inst"))
433 .def_property_readonly("q_inst",
434 createAttributeGetter<CPS::Real>("q_inst"));
435
436 py::class_<CPS::EMT::Ph3::Shunt, std::shared_ptr<CPS::EMT::Ph3::Shunt>,
437 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Shunt",
438 py::multiple_inheritance())
439 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
440 "loglevel"_a = CPS::Logger::Level::off)
441 .def("set_parameters",
442 static_cast<void (CPS::EMT::Ph3::Shunt::*)(CPS::Real, CPS::Real)>(
443 &CPS::EMT::Ph3::Shunt::setParameters),
444 "G"_a, "B"_a)
445 .def("connect", &CPS::EMT::Ph3::Shunt::connect);
446
447 py::class_<CPS::EMT::Ph3::Switch, std::shared_ptr<CPS::EMT::Ph3::Switch>,
448 CPS::SimPowerComp<CPS::Real>, CPS::Base::Ph3::Switch>(
449 mEMTPh3, "Switch", py::multiple_inheritance())
450 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
451 "loglevel"_a = CPS::Logger::Level::off)
452 .def("set_parameters", &CPS::EMT::Ph3::Switch::setParameters,
453 "open_resistance"_a, "closed_resistance"_a,
454 // cppcheck-suppress assignBoolToPointer
455 "closed"_a = false)
456 .def("open", &CPS::EMT::Ph3::Switch::openSwitch)
457 .def("close", &CPS::EMT::Ph3::Switch::closeSwitch)
458 .def("connect", &CPS::EMT::Ph3::Switch::connect);
459
460 py::class_<CPS::EMT::Ph3::SynchronGeneratorIdeal,
461 std::shared_ptr<CPS::EMT::Ph3::SynchronGeneratorIdeal>,
462 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SynchronGeneratorIdeal",
463 py::multiple_inheritance())
464 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
465 "loglevel"_a = CPS::Logger::Level::off)
466 .def("connect", &CPS::EMT::Ph3::SynchronGeneratorIdeal::connect);
467
468 py::class_<CPS::EMT::Ph3::SynchronGeneratorDQTrapez,
469 std::shared_ptr<CPS::EMT::Ph3::SynchronGeneratorDQTrapez>,
470 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SynchronGeneratorDQTrapez",
471 py::multiple_inheritance())
472 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
473 "loglevel"_a = CPS::Logger::Level::off)
474 .def("set_parameters_operational_per_unit",
475 &CPS::EMT::Ph3::SynchronGeneratorDQTrapez::
476 setParametersOperationalPerUnit,
477 "nom_power"_a, "nom_volt"_a, "nom_freq"_a, "pole_number"_a,
478 "nom_field_cur"_a, "Rs"_a, "Ld"_a, "Lq"_a, "Ld_t"_a, "Lq_t"_a,
479 "Ld_s"_a, "Lq_s"_a, "Ll"_a, "Td0_t"_a, "Tq0_t"_a, "Td0_s"_a,
480 "Tq0_s"_a, "inertia"_a)
481 .def("set_parameters_fundamental_per_unit",
482 &CPS::EMT::Ph3::SynchronGeneratorDQTrapez::
483 setParametersFundamentalPerUnit,
484 "nom_power"_a, "nom_volt"_a, "nom_freq"_a, "pole_number"_a,
485 "nom_field_cur"_a, "Rs"_a, "Ll"_a, "Lmd"_a, "Lmq"_a, "Rfd"_a,
486 "Llfd"_a, "Rkd"_a, "Llkd"_a, "Rkq1"_a, "Llkq1"_a, "Rkq2"_a,
487 "Llkq2"_a, "inertia"_a, "init_active_power"_a,
488 "init_reactive_power"_a, "init_terminal_volt"_a, "init_volt_angle"_a,
489 "init_mech_power"_a)
490#ifdef WITH_JSON
491 .def("apply_parameters_from_json",
492 [](std::shared_ptr<CPS::EMT::Ph3::SynchronGeneratorDQTrapez> syngen,
493 const CPS::String json) {
494 DPsim::Utils::applySynchronousGeneratorParametersFromJson(
495 json::parse(json), syngen);
496 })
497#endif
498 .def("set_initial_values",
499 &CPS::EMT::Ph3::SynchronGeneratorDQTrapez::setInitialValues,
500 "init_active_power"_a, "init_reactive_power"_a,
501 "init_terminal_volt"_a, "init_volt_angle"_a, "init_mech_power"_a);
502
503 py::class_<CPS::EMT::Ph3::VSIVoltageControlVCO,
504 std::shared_ptr<CPS::EMT::Ph3::VSIVoltageControlVCO>,
505 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "VSIVoltageControlVCO",
506 py::multiple_inheritance())
507 .def(py::init<std::string>())
508 .def(py::init<std::string, CPS::Logger::Level>())
509 .def(py::init<std::string, std::string, CPS::Logger::Level, CPS::Bool>(),
510 "uid"_a, "name"_a, "log_level"_a = CPS::Logger::Level::off,
511 py::arg("with_trafo") = false)
512 .def("set_parameters",
513 &CPS::EMT::Ph3::VSIVoltageControlVCO::setParameters, "sys_omega"_a,
514 "vd_ref"_a, "vq_ref"_a)
515 .def("set_controller_parameters",
516 &CPS::EMT::Ph3::VSIVoltageControlVCO::setControllerParameters,
517 "kp_voltage_ctrl"_a, "ki_voltage_ctrl"_a, "kp_curr_ctrl"_a,
518 "ki_curr_ctrl"_a, "omega_nominal"_a)
519 .def("set_transformer_parameters",
520 &CPS::EMT::Ph3::VSIVoltageControlVCO::setTransformerParameters,
521 "nom_voltage_end1"_a, "nom_voltage_end2"_a, "rated_power"_a,
522 "ratio_abs"_a, "ratio_phase"_a, "resistance"_a, "inductance"_a,
523 "omega"_a)
524 .def("set_filter_parameters",
525 &CPS::EMT::Ph3::VSIVoltageControlVCO::setFilterParameters, "lf"_a,
526 "cf"_a, "rf"_a, "rc"_a)
527 .def("set_initial_state_values",
528 &CPS::EMT::Ph3::VSIVoltageControlVCO::setInitialStateValues,
529 "phi_d_init"_a, "phi_q_init"_a, "gamma_d_init"_a, "gamma_q_init"_a)
530 .def("with_control", &CPS::EMT::Ph3::VSIVoltageControlVCO::withControl,
531 "control_on"_a)
532 .def("connect", &CPS::EMT::Ph3::VSIVoltageControlVCO::connect);
533
534 py::class_<CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR,
535 std::shared_ptr<CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>,
536 CPS::Base::ReducedOrderSynchronGenerator<CPS::Real>>(
537 mEMTPh3, "ReducedOrderSynchronGeneratorVBR", py::multiple_inheritance());
538
539 py::class_<CPS::EMT::Ph3::SynchronGenerator3OrderVBR,
540 std::shared_ptr<CPS::EMT::Ph3::SynchronGenerator3OrderVBR>,
541 CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>(
542 mEMTPh3, "SynchronGenerator3OrderVBR", py::multiple_inheritance())
543 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
544 "loglevel"_a = CPS::Logger::Level::off)
545 .def("set_operational_parameters_per_unit",
546 py::overload_cast<CPS::Real, CPS::Real, CPS::Real, CPS::Real,
547 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
548 CPS::Real>(
549 &CPS::EMT::Ph3::SynchronGenerator3OrderVBR::
550 setOperationalParametersPerUnit),
551 "nom_power"_a, "nom_voltage"_a, "nom_frequency"_a, "H"_a, "Ld"_a,
552 "Lq"_a, "L0"_a, "Ld_t"_a, "Td0_t"_a)
553 .def("connect", &CPS::EMT::Ph3::SynchronGenerator3OrderVBR::connect);
554
555 py::class_<CPS::EMT::Ph3::SynchronGenerator4OrderVBR,
556 std::shared_ptr<CPS::EMT::Ph3::SynchronGenerator4OrderVBR>,
557 CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>(
558 mEMTPh3, "SynchronGenerator4OrderVBR", py::multiple_inheritance())
559 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
560 "loglevel"_a = CPS::Logger::Level::off)
561 .def("set_operational_parameters_per_unit",
562 py::overload_cast<CPS::Real, CPS::Real, CPS::Real, CPS::Real,
563 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
564 CPS::Real, CPS::Real, CPS::Real>(
565 &CPS::EMT::Ph3::SynchronGenerator4OrderVBR::
566 setOperationalParametersPerUnit),
567 "nom_power"_a, "nom_voltage"_a, "nom_frequency"_a, "H"_a, "Ld"_a,
568 "Lq"_a, "L0"_a, "Ld_t"_a, "Lq_t"_a, "Td0_t"_a, "Tq0_t"_a)
569 .def("connect", &CPS::EMT::Ph3::SynchronGenerator4OrderVBR::connect);
570
571 py::class_<CPS::EMT::Ph3::SynchronGenerator5OrderVBR,
572 std::shared_ptr<CPS::EMT::Ph3::SynchronGenerator5OrderVBR>,
573 CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>(
574 mEMTPh3, "SynchronGenerator5OrderVBR", py::multiple_inheritance())
575 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
576 "loglevel"_a = CPS::Logger::Level::off)
577 .def("set_operational_parameters_per_unit",
578 py::overload_cast<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::Real, CPS::Real, CPS::Real, CPS::Real>(
582 &CPS::EMT::Ph3::SynchronGenerator5OrderVBR::
583 setOperationalParametersPerUnit),
584 "nom_power"_a, "nom_voltage"_a, "nom_frequency"_a, "H"_a, "Ld"_a,
585 "Lq"_a, "L0"_a, "Ld_t"_a, "Lq_t"_a, "Td0_t"_a, "Tq0_t"_a, "Ld_s"_a,
586 "Lq_s"_a, "Td0_s"_a, "Tq0_s"_a, "Taa"_a)
587 .def("connect", &CPS::EMT::Ph3::SynchronGenerator5OrderVBR::connect);
588
589 py::class_<CPS::EMT::Ph3::SynchronGenerator6aOrderVBR,
590 std::shared_ptr<CPS::EMT::Ph3::SynchronGenerator6aOrderVBR>,
591 CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>(
592 mEMTPh3, "SynchronGenerator6aOrderVBR", py::multiple_inheritance())
593 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
594 "loglevel"_a = CPS::Logger::Level::off)
595 .def("set_operational_parameters_per_unit",
596 py::overload_cast<CPS::Real, CPS::Real, CPS::Real, CPS::Real,
597 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
598 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
599 CPS::Real, CPS::Real, CPS::Real, CPS::Real>(
600 &CPS::EMT::Ph3::SynchronGenerator6aOrderVBR::
601 setOperationalParametersPerUnit),
602 "nom_power"_a, "nom_voltage"_a, "nom_frequency"_a, "H"_a, "Ld"_a,
603 "Lq"_a, "L0"_a, "Ld_t"_a, "Lq_t"_a, "Td0_t"_a, "Tq0_t"_a, "Ld_s"_a,
604 "Lq_s"_a, "Td0_s"_a, "Tq0_s"_a, "Taa"_a)
605 .def("connect", &CPS::EMT::Ph3::SynchronGenerator6aOrderVBR::connect);
606
607 py::class_<CPS::EMT::Ph3::SynchronGenerator6bOrderVBR,
608 std::shared_ptr<CPS::EMT::Ph3::SynchronGenerator6bOrderVBR>,
609 CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>(
610 mEMTPh3, "SynchronGenerator6bOrderVBR", py::multiple_inheritance())
611 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
612 "loglevel"_a = CPS::Logger::Level::off)
613 .def("set_operational_parameters_per_unit",
614 py::overload_cast<CPS::Real, CPS::Real, CPS::Real, CPS::Real,
615 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
616 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
617 CPS::Real, CPS::Real, CPS::Real, CPS::Real>(
618 &CPS::EMT::Ph3::SynchronGenerator6bOrderVBR::
619 setOperationalParametersPerUnit),
620 "nom_power"_a, "nom_voltage"_a, "nom_frequency"_a, "H"_a, "Ld"_a,
621 "Lq"_a, "L0"_a, "Ld_t"_a, "Lq_t"_a, "Td0_t"_a, "Tq0_t"_a, "Ld_s"_a,
622 "Lq_s"_a, "Td0_s"_a, "Tq0_s"_a, "Taa"_a = 0)
623 .def("connect", &CPS::EMT::Ph3::SynchronGenerator6bOrderVBR::connect);
624
625#ifdef WITH_SUNDIALS
626
627 py::class_<CPS::EMT::Ph3::SynchronGeneratorDQODE,
628 std::shared_ptr<CPS::EMT::Ph3::SynchronGeneratorDQODE>,
629 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SynchronGeneratorDQODE",
630 py::multiple_inheritance())
631 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
632 "loglevel"_a = CPS::Logger::Level::off)
633 .def("set_parameters_operational_per_unit",
634 &CPS::EMT::Ph3::SynchronGeneratorDQODE::
635 setParametersOperationalPerUnit,
636 "nom_power"_a, "nom_volt"_a, "nom_freq"_a, "pole_number"_a,
637 "nom_field_cur"_a, "Rs"_a, "Ld"_a, "Lq"_a, "Ld_t"_a, "Lq_t"_a,
638 "Ld_s"_a, "Lq_s"_a, "Ll"_a, "Td0_t"_a, "Tq0_t"_a, "Td0_s"_a,
639 "Tq0_s"_a, "inertia"_a)
640 .def("set_parameters_fundamental_per_unit",
641 &CPS::EMT::Ph3::SynchronGeneratorDQODE::
642 setParametersFundamentalPerUnit,
643 "nom_power"_a, "nom_volt"_a, "nom_freq"_a, "pole_number"_a,
644 "nom_field_cur"_a, "Rs"_a, "Ll"_a, "Lmd"_a, "Lmq"_a, "Rfd"_a,
645 "Llfd"_a, "Rkd"_a, "Llkd"_a, "Rkq1"_a, "Llkq1"_a, "Rkq2"_a,
646 "Llkq2"_a, "inertia"_a, "init_active_power"_a,
647 "init_reactive_power"_a, "init_terminal_volt"_a, "init_volt_angle"_a,
648 "init_mech_power"_a)
649#ifdef WITH_JSON
650 .def("apply_parameters_from_json",
651 [](std::shared_ptr<CPS::EMT::Ph3::SynchronGeneratorDQODE> syngen,
652 const CPS::String json) {
653 DPsim::Utils::applySynchronousGeneratorParametersFromJson(
654 json::parse(json), syngen);
655 })
656#endif
657 .def("set_initial_values",
658 &CPS::EMT::Ph3::SynchronGeneratorDQODE::setInitialValues,
659 "init_active_power"_a, "init_reactive_power"_a,
660 "init_terminal_volt"_a, "init_volt_angle"_a, "init_mech_power"_a);
661
662#endif
663
664 py::class_<CPS::EMT::Ph3::AvVoltageSourceInverterDQ,
665 std::shared_ptr<CPS::EMT::Ph3::AvVoltageSourceInverterDQ>,
666 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "AvVoltageSourceInverterDQ",
667 py::multiple_inheritance())
668 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
669 "loglevel"_a = CPS::Logger::Level::off)
670 .def(py::init<std::string, std::string, CPS::Logger::Level, CPS::Bool>(),
671 "uid"_a, "name"_a, "loglevel"_a = CPS::Logger::Level::off,
672 // cppcheck-suppress assignBoolToPointer
673 "with_trafo"_a = false)
674 .def("set_parameters",
675 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setParameters,
676 "sys_omega"_a, "sys_volt_nom"_a, "p_ref"_a, "q_ref"_a)
677 .def("set_filter_parameters",
678 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setFilterParameters,
679 "Lf"_a, "Cf"_a, "Rf"_a, "Rc"_a)
680 .def("set_controller_parameters",
681 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setControllerParameters,
682 "Kp_pll"_a, "Ki_pll"_a, "Kp_power_ctrl"_a, "Ki_power_ctrl"_a,
683 "Kp_curr_ctrl"_a, "Ki_curr_ctrl"_a, "omega_cutoff"_a)
684 .def("set_transformer_parameters",
685 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setTransformerParameters,
686 "nom_voltage_primary"_a, "nom_voltage_secondary"_a, "rated_power"_a,
687 "ratio_abs"_a, "ratio_phase"_a, "resistance"_a, "inductance"_a,
688 "omega"_a)
689 .def("set_initial_state_values",
690 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setInitialStateValues,
691 "p_init"_a, "q_init"_a, "phi_d_init"_a, "phi_q_init"_a,
692 "gamma_d_init"_a, "gamma_q_init"_a)
693 .def("with_control",
694 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::withControl)
695 .def("connect", &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::connect);
696
697 py::class_<CPS::EMT::Ph3::Transformer,
698 std::shared_ptr<CPS::EMT::Ph3::Transformer>,
699 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Transformer",
700 py::multiple_inheritance())
701 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
702 "loglevel"_a = CPS::Logger::Level::off)
703 .def(py::init<std::string, std::string, CPS::Logger::Level, CPS::Bool>(),
704 "uid"_a, "name"_a, "loglevel"_a = CPS::Logger::Level::off,
705 // cppcheck-suppress assignBoolToPointer
706 "with_resistive_losses"_a = false)
707 .def("set_parameters", &CPS::EMT::Ph3::Transformer::setParameters,
708 "nom_voltage_primary"_a, "nom_voltage_secondary"_a, "rated_power"_a,
709 "ratio_abs"_a, "ratio_phase"_a, "resistance"_a, "inductance"_a)
710 .def("set_reference_winding",
711 &CPS::EMT::Ph3::Transformer::setReferenceWinding,
712 "reference_winding"_a)
713 .def("set_magnetizing_branch",
714 &CPS::EMT::Ph3::Transformer::setMagnetizingBranch,
715 "no_load_current"_a, "no_load_loss"_a)
716 .def("connect", &CPS::EMT::Ph3::Transformer::connect);
717
718 py::class_<CPS::EMT::Ph3::SeriesResistor,
719 std::shared_ptr<CPS::EMT::Ph3::SeriesResistor>,
720 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SeriesResistor",
721 py::multiple_inheritance())
722 .def(py::init<std::string>())
723 .def(py::init<std::string, CPS::Logger::Level>())
724 .def("set_parameters", &CPS::EMT::Ph3::SeriesResistor::setParameters,
725 "R"_a)
726 .def("connect", &CPS::EMT::Ph3::SeriesResistor::connect);
727
728 py::class_<CPS::EMT::Ph3::SeriesSwitch,
729 std::shared_ptr<CPS::EMT::Ph3::SeriesSwitch>,
730 CPS::SimPowerComp<CPS::Real>, CPS::Base::Ph1::Switch>(
731 mEMTPh3, "SeriesSwitch", py::multiple_inheritance())
732 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
733 "loglevel"_a = CPS::Logger::Level::off)
734 .def("set_parameters", &CPS::EMT::Ph3::SeriesSwitch::setParameters,
735 "open_resistance"_a, "closed_resistance"_a,
736 // cppcheck-suppress assignBoolToPointer
737 "closed"_a = false)
738 .def("open", &CPS::EMT::Ph3::SeriesSwitch::open)
739 .def("close", &CPS::EMT::Ph3::SeriesSwitch::close)
740 .def("connect", &CPS::EMT::Ph3::SeriesSwitch::connect);
741
742 py::class_<CPS::EMT::Ph3::SSN::Full_Serial_RLC,
743 std::shared_ptr<CPS::EMT::Ph3::SSN::Full_Serial_RLC>,
744 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Full_Serial_RLC",
745 py::multiple_inheritance())
746 .def(py::init<std::string>())
747 .def(py::init<std::string, CPS::Logger::Level>())
748 .def("set_parameters",
749 &CPS::EMT::Ph3::SSN::Full_Serial_RLC::setParameters, "R"_a, "L"_a,
750 "C"_a)
751 .def("connect", &CPS::EMT::Ph3::SSN::Full_Serial_RLC::connect)
752 .def_property("R", createAttributeGetter<CPS::Matrix>("R"),
753 createAttributeSetter<CPS::Matrix>("R"))
754 .def_property("L", createAttributeGetter<CPS::Matrix>("L"),
755 createAttributeSetter<CPS::Matrix>("L"))
756 .def_property("C", createAttributeGetter<CPS::Matrix>("C"),
757 createAttributeSetter<CPS::Matrix>("C"));
758
759 py::class_<CPS::EMT::Ph3::GenericTwoTerminalVTypeSSN,
760 std::shared_ptr<CPS::EMT::Ph3::GenericTwoTerminalVTypeSSN>,
761 CPS::SimPowerComp<CPS::Real>>(
762 mEMTPh3, "GenericTwoTerminalVTypeSSN", py::multiple_inheritance())
763 .def(py::init<std::string>())
764 .def(py::init<std::string, CPS::Logger::Level>())
765 .def("set_parameters",
766 &CPS::EMT::Ph3::GenericTwoTerminalVTypeSSN::setParameters, "A"_a,
767 "B"_a, "C"_a, "D"_a)
768 .def("connect", &CPS::EMT::Ph3::GenericTwoTerminalVTypeSSN::connect)
769 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
770
771 py::class_<CPS::EMT::Ph3::GenericTwoTerminalITypeSSN,
772 std::shared_ptr<CPS::EMT::Ph3::GenericTwoTerminalITypeSSN>,
773 CPS::SimPowerComp<CPS::Real>>(
774 mEMTPh3, "GenericTwoTerminalITypeSSN", py::multiple_inheritance())
775 .def(py::init<std::string>())
776 .def(py::init<std::string, CPS::Logger::Level>())
777 .def("set_parameters",
778 &CPS::EMT::Ph3::GenericTwoTerminalITypeSSN::setParameters, "A"_a,
779 "B"_a, "C"_a, "D"_a)
780 .def("connect", &CPS::EMT::Ph3::GenericTwoTerminalITypeSSN::connect)
781 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
782
783 py::class_<CPS::EMT::Ph3::PiecewiseLinearInductor,
784 std::shared_ptr<CPS::EMT::Ph3::PiecewiseLinearInductor>,
785 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "PiecewiseLinearInductor",
786 py::multiple_inheritance())
787 .def(py::init<std::string>())
788 .def(py::init<std::string, CPS::Logger::Level>())
789 .def("set_parameters",
790 &CPS::EMT::Ph3::PiecewiseLinearInductor::setParameters,
791 "flux_breakpoints"_a, "current_breakpoints"_a)
792 .def("connect", &CPS::EMT::Ph3::PiecewiseLinearInductor::connect)
793 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
794
795 // -----------------------------------------------------------------------
796 // Grid-following converter models
797 // -----------------------------------------------------------------------
798
799 py::class_<CPS::EMT::Ph3::GFL, std::shared_ptr<CPS::EMT::Ph3::GFL>,
800 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "GFL",
801 py::multiple_inheritance())
802 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
803 "loglevel"_a = CPS::Logger::Level::off)
804 .def(py::init<std::string, std::string, CPS::Logger::Level>(), "uid"_a,
805 "name"_a, "loglevel"_a = CPS::Logger::Level::off)
806 .def("set_parameters", &CPS::EMT::Ph3::GFL::setParameters, "sys_omega"_a,
807 "sys_volt_nom"_a, "p_ref"_a, "q_ref"_a)
808 .def("set_controller_parameters",
809 &CPS::EMT::Ph3::GFL::setControllerParameters, "kp_pll"_a, "ki_pll"_a,
810 "kp_power_ctrl"_a, "ki_power_ctrl"_a, "kp_curr_ctrl"_a,
811 "ki_curr_ctrl"_a, "omega_cutoff"_a)
812 .def("set_filter_parameters", &CPS::EMT::Ph3::GFL::setFilterParameters,
813 "lf"_a, "cf"_a, "rf"_a)
814 .def("set_initial_state_values",
815 &CPS::EMT::Ph3::GFL::setInitialStateValues, "p_init"_a, "q_init"_a,
816 "phi_d_init"_a, "phi_q_init"_a, "gamma_d_init"_a, "gamma_q_init"_a)
817 .def("with_control", &CPS::EMT::Ph3::GFL::withControl, "control_on"_a)
818 .def("connect", &CPS::EMT::Ph3::GFL::connect)
819 .def_property_readonly("vc_d", createAttributeGetter<CPS::Real>("vc_d"))
820 .def_property_readonly("vc_q", createAttributeGetter<CPS::Real>("vc_q"))
821 .def_property_readonly("igrid_d",
822 createAttributeGetter<CPS::Real>("igrid_d"))
823 .def_property_readonly("igrid_q",
824 createAttributeGetter<CPS::Real>("igrid_q"))
825 .def_property_readonly("p_inst",
826 createAttributeGetter<CPS::Real>("p_inst"))
827 .def_property_readonly("q_inst",
828 createAttributeGetter<CPS::Real>("q_inst"))
829 .def_property_readonly("omega_pll",
830 createAttributeGetter<CPS::Real>("omega_pll"))
831 .def_property_readonly("vs_ref",
832 createAttributeGetter<CPS::Matrix>("vs_ref"))
833 .def_property_readonly("vs", createAttributeGetter<CPS::Matrix>("vs"))
834 .def_property_readonly("pll_output",
835 createAttributeGetter<CPS::Matrix>("pll_output"))
836 .def_property_readonly(
837 "powerctrl_inputs",
838 createAttributeGetter<CPS::Matrix>("powerctrl_inputs"))
839 .def_property_readonly(
840 "powerctrl_states",
841 createAttributeGetter<CPS::Matrix>("powerctrl_states"))
842 .def_property_readonly(
843 "powerctrl_outputs",
844 createAttributeGetter<CPS::Matrix>("powerctrl_outputs"));
845
846 py::class_<CPS::EMT::Ph3::SSN_GFL, std::shared_ptr<CPS::EMT::Ph3::SSN_GFL>,
847 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SSN_GFL",
848 py::multiple_inheritance())
849 .def(py::init<std::string, std::string, CPS::Logger::Level>(), "uid"_a,
850 "name"_a, "loglevel"_a = CPS::Logger::Level::off)
851 .def("set_parameters", &CPS::EMT::Ph3::SSN_GFL::setParameters, "lf"_a,
852 "cf"_a, "rf"_a, "rc"_a, "omega_n"_a, "kp_pll"_a, "ki_pll"_a,
853 "omega_cutoff"_a, "p_ref"_a, "q_ref"_a, "kp_power_ctrl"_a,
854 "ki_power_ctrl"_a, "kp_curr_ctrl"_a, "ki_curr_ctrl"_a)
855 .def("connect", &CPS::EMT::Ph3::SSN_GFL::connect)
856 .def("get_state_names", &CPS::EMT::Ph3::SSN_GFL::getLocalStateNames)
857 .def("get_state", &CPS::EMT::Ph3::SSN_GFL::getState)
858 .def("get_state_derivative", &CPS::EMT::Ph3::SSN_GFL::getStateDerivative)
859 .def("get_interface_voltage",
860 &CPS::EMT::Ph3::SSN_GFL::getInterfaceVoltage)
861 .def("get_interface_current",
862 &CPS::EMT::Ph3::SSN_GFL::getInterfaceCurrent)
863 .def_property_readonly("vc_d", createAttributeGetter<CPS::Real>("vc_d"))
864 .def_property_readonly("vc_q", createAttributeGetter<CPS::Real>("vc_q"))
865 .def_property_readonly("irc_d", createAttributeGetter<CPS::Real>("irc_d"))
866 .def_property_readonly("irc_q", createAttributeGetter<CPS::Real>("irc_q"))
867 .def_property_readonly("p_inst",
868 createAttributeGetter<CPS::Real>("p_inst"))
869 .def_property_readonly("q_inst",
870 createAttributeGetter<CPS::Real>("q_inst"))
871 .def_property_readonly("omega_pll",
872 createAttributeGetter<CPS::Real>("omega_pll"));
873
874 py::class_<CPS::EMT::Ph3::SSN_GFL_Split,
875 std::shared_ptr<CPS::EMT::Ph3::SSN_GFL_Split>,
876 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SSN_GFL_Split",
877 py::multiple_inheritance())
878 .def(py::init<std::string, std::string, CPS::Logger::Level>(), "uid"_a,
879 "name"_a, "loglevel"_a = CPS::Logger::Level::off)
880 .def("set_parameters", &CPS::EMT::Ph3::SSN_GFL_Split::setParameters,
881 "lf"_a, "cf"_a, "rf"_a, "rc"_a, "omega_n"_a, "kp_pll"_a, "ki_pll"_a,
882 "omega_cutoff"_a, "p_ref"_a, "q_ref"_a, "kp_power_ctrl"_a,
883 "ki_power_ctrl"_a, "kp_curr_ctrl"_a, "ki_curr_ctrl"_a)
884 .def("connect", &CPS::EMT::Ph3::SSN_GFL_Split::connect)
885
886 // Combined controller + network state.
887 .def("get_state", &CPS::EMT::Ph3::SSN_GFL_Split::getState)
888 .def("get_state_derivative",
889 &CPS::EMT::Ph3::SSN_GFL_Split::getStateDerivative)
890
891 // Split state access.
892 .def("get_controller_state",
893 &CPS::EMT::Ph3::SSN_GFL_Split::getControllerState)
894 .def("get_network_state", &CPS::EMT::Ph3::SSN_GFL_Split::getNetworkState)
895 .def("get_network_state_names",
896 &CPS::EMT::Ph3::SSN_GFL_Split::getLocalStateNames)
897
898 // Electrical interface / delayed forcing.
899 .def("get_interface_voltage",
900 &CPS::EMT::Ph3::SSN_GFL_Split::getInterfaceVoltage)
901 .def("get_interface_current",
902 &CPS::EMT::Ph3::SSN_GFL_Split::getInterfaceCurrent)
903 .def("get_converter_voltage_reference",
904 &CPS::EMT::Ph3::SSN_GFL_Split::getConverterVoltageReference)
905 .def("get_delayed_converter_voltage",
906 &CPS::EMT::Ph3::SSN_GFL_Split::getDelayedConverterVoltage)
907
908 // Controller affine model.
909 .def("get_controller_A", &CPS::EMT::Ph3::SSN_GFL_Split::getControllerA)
910 .def("get_controller_B", &CPS::EMT::Ph3::SSN_GFL_Split::getControllerB)
911 .def("get_controller_C", &CPS::EMT::Ph3::SSN_GFL_Split::getControllerC)
912 .def("get_controller_D", &CPS::EMT::Ph3::SSN_GFL_Split::getControllerD)
913 .def("get_controller_E", &CPS::EMT::Ph3::SSN_GFL_Split::getControllerE)
914 .def("get_controller_F", &CPS::EMT::Ph3::SSN_GFL_Split::getControllerF)
915
916 // Fixed electrical SSN plant.
917 .def("get_network_A", &CPS::EMT::Ph3::SSN_GFL_Split::getNetworkA)
918 .def("get_network_B", &CPS::EMT::Ph3::SSN_GFL_Split::getNetworkB)
919 .def("get_network_C", &CPS::EMT::Ph3::SSN_GFL_Split::getNetworkC)
920 .def("get_network_D", &CPS::EMT::Ph3::SSN_GFL_Split::getNetworkD)
921 .def("get_equivalent_conductance",
922 &CPS::EMT::Ph3::SSN_GFL_Split::getEquivalentConductance)
923
924 // Logged scalar quantities.
925 .def_property_readonly("vc_d", createAttributeGetter<CPS::Real>("vc_d"))
926 .def_property_readonly("vc_q", createAttributeGetter<CPS::Real>("vc_q"))
927 .def_property_readonly("irc_d", createAttributeGetter<CPS::Real>("irc_d"))
928 .def_property_readonly("irc_q", createAttributeGetter<CPS::Real>("irc_q"))
929 .def_property_readonly("p_inst",
930 createAttributeGetter<CPS::Real>("p_inst"))
931 .def_property_readonly("q_inst",
932 createAttributeGetter<CPS::Real>("q_inst"))
933 .def_property_readonly("omega_pll",
934 createAttributeGetter<CPS::Real>("omega_pll"))
935 .def_property_readonly("vinv_ref_a",
936 createAttributeGetter<CPS::Real>("vinv_ref_a"))
937 .def_property_readonly("vinv_ref_b",
938 createAttributeGetter<CPS::Real>("vinv_ref_b"))
939 .def_property_readonly("vinv_ref_c",
940 createAttributeGetter<CPS::Real>("vinv_ref_c"));
941
942 py::class_<CPS::EMT::Ph3::AvVoltSourceInverterStateSpace,
943 std::shared_ptr<CPS::EMT::Ph3::AvVoltSourceInverterStateSpace>,
944 CPS::SimPowerComp<CPS::Real>>(
945 mEMTPh3, "AvVoltSourceInverterStateSpace", py::multiple_inheritance())
946 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
947 "loglevel"_a = CPS::Logger::Level::off)
948 .def(py::init<std::string, std::string, CPS::Logger::Level>(), "uid"_a,
949 "name"_a, "loglevel"_a = CPS::Logger::Level::off)
950 .def("set_parameters",
951 &CPS::EMT::Ph3::AvVoltSourceInverterStateSpace::setParameters,
952 "Lf"_a, "Cf"_a, "Rf"_a, "Rc"_a, "omega_n"_a, "Kp_pll"_a, "Ki_pll"_a,
953 "omega_cutoff"_a, "p_ref"_a, "q_ref"_a, "Kp_power_ctrl"_a,
954 "Ki_power_ctrl"_a, "Kp_curr_ctrl"_a, "Ki_curr_ctrl"_a)
955 .def("connect", &CPS::EMT::Ph3::AvVoltSourceInverterStateSpace::connect)
956 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"))
957 .def_property_readonly("vc_d", createAttributeGetter<CPS::Real>("vc_d"))
958 .def_property_readonly("vc_q", createAttributeGetter<CPS::Real>("vc_q"))
959 .def_property_readonly("irc_d", createAttributeGetter<CPS::Real>("irc_d"))
960 .def_property_readonly("irc_q", createAttributeGetter<CPS::Real>("irc_q"))
961 .def_property_readonly("p_inst",
962 createAttributeGetter<CPS::Real>("p_inst"))
963 .def_property_readonly("q_inst",
964 createAttributeGetter<CPS::Real>("q_inst"))
965 .def_property_readonly("omega_pll",
966 createAttributeGetter<CPS::Real>("omega_pll"));
967
968 py::class_<CPS::EMT::Ph3::SSN_GFM, std::shared_ptr<CPS::EMT::Ph3::SSN_GFM>,
969 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SSN_GFM",
970 py::multiple_inheritance())
971 .def(py::init<std::string, std::string, CPS::Logger::Level>(), "uid"_a,
972 "name"_a, "log_level"_a = CPS::Logger::Level::off)
973 .def("set_parameters", &CPS::EMT::Ph3::SSN_GFM::setParameters, "lf"_a,
974 "cf"_a, "rf"_a, "rc"_a, "nominal_voltage"_a, "omega_nominal"_a,
975 "p_ref"_a, "q_ref"_a, "virtual_inertia"_a, "damping_coefficient"_a,
976 "voltage_droop_gain"_a, "reactive_integral_gain"_a, "kp_voltage"_a,
977 "ki_voltage"_a, "kp_current"_a, "ki_current"_a,
978 "active_damping_gain"_a, "power_filter_cutoff"_a,
979 "delay_bandwidth"_a)
980 .def("set_numerical_linearization_parameters",
981 &CPS::EMT::Ph3::SSN_GFM::setNumericalLinearizationParameters,
982 "relative_step"_a = 1e-6, "absolute_step"_a = 1e-8)
983 .def("set_virtual_impedance",
984 &CPS::EMT::Ph3::SSN_GFM::setVirtualImpedance, "virtual_resistance"_a,
985 "virtual_reactance"_a = 0.0)
986 .def("set_grid_current_feedforward",
987 &CPS::EMT::Ph3::SSN_GFM::setGridCurrentFeedforward, "scale"_a)
988 .def("set_reactive_power_droop",
989 &CPS::EMT::Ph3::SSN_GFM::setReactivePowerDroop, "droop_gain"_a,
990 "cutoff"_a)
991 .def("connect", &CPS::EMT::Ph3::SSN_GFM::connect)
992 .def("get_state_names", &CPS::EMT::Ph3::SSN_GFM::getLocalStateNames)
993 .def("get_state", &CPS::EMT::Ph3::SSN_GFM::getState)
994 .def("get_state_derivative", &CPS::EMT::Ph3::SSN_GFM::getStateDerivative)
995 .def("get_interface_voltage",
996 &CPS::EMT::Ph3::SSN_GFM::getInterfaceVoltage)
997 .def("get_interface_current",
998 &CPS::EMT::Ph3::SSN_GFM::getInterfaceCurrent)
999 .def_property_readonly("p_inst",
1000 createAttributeGetter<CPS::Real>("p_inst"))
1001 .def_property_readonly("q_inst",
1002 createAttributeGetter<CPS::Real>("q_inst"))
1003 .def_property_readonly("omega_gfm",
1004 createAttributeGetter<CPS::Real>("omega_gfm"))
1005 .def_property_readonly("theta_gfm",
1006 createAttributeGetter<CPS::Real>("theta_gfm"))
1007 .def_property_readonly(
1008 "voltage_magnitude_gfm",
1009 createAttributeGetter<CPS::Real>("voltage_magnitude_gfm"))
1010 .def_property_readonly("vc_d", createAttributeGetter<CPS::Real>("vc_d"))
1011 .def_property_readonly("vc_q", createAttributeGetter<CPS::Real>("vc_q"))
1012 .def_property_readonly("i_grid_d",
1013 createAttributeGetter<CPS::Real>("i_grid_d"))
1014 .def_property_readonly("i_grid_q",
1015 createAttributeGetter<CPS::Real>("i_grid_q"))
1016 .def_property_readonly("if_d", createAttributeGetter<CPS::Real>("if_d"))
1017 .def_property_readonly("if_q", createAttributeGetter<CPS::Real>("if_q"))
1018 .def_property_readonly("v_ref_d",
1019 createAttributeGetter<CPS::Real>("v_ref_d"))
1020 .def_property_readonly("v_ref_q",
1021 createAttributeGetter<CPS::Real>("v_ref_q"));
1022
1023 py::class_<CPS::EMT::Ph3::SSN::Capacitor,
1024 std::shared_ptr<CPS::EMT::Ph3::SSN::Capacitor>,
1025 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SSN_Capacitor",
1026 py::multiple_inheritance())
1027 .def(py::init<std::string>())
1028 .def(py::init<std::string, CPS::Logger::Level>())
1029 .def("set_parameters", &CPS::EMT::Ph3::SSN::Capacitor::setParameters,
1030 "C"_a)
1031 .def("connect", &CPS::EMT::Ph3::SSN::Capacitor::connect)
1032 .def_property("C", createAttributeGetter<CPS::Matrix>("C"),
1033 createAttributeSetter<CPS::Matrix>("C"));
1034
1035 py::class_<CPS::EMT::Ph3::GenericFourTerminalVTypeSSN,
1036 std::shared_ptr<CPS::EMT::Ph3::GenericFourTerminalVTypeSSN>,
1037 CPS::SimPowerComp<CPS::Real>>(
1038 mEMTPh3, "GenericFourTerminalVTypeSSN", py::multiple_inheritance())
1039 .def(py::init<std::string>())
1040 .def(py::init<std::string, CPS::Logger::Level>())
1041 .def("set_parameters",
1042 &CPS::EMT::Ph3::GenericFourTerminalVTypeSSN::setParameters, "A"_a,
1043 "B"_a, "C"_a, "D"_a)
1044 .def("connect", &CPS::EMT::Ph3::GenericFourTerminalVTypeSSN::connect)
1045 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
1046}
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
PYBIND11_DECLARE_HOLDER_TYPE
PYBIND11_DECLARE_HOLDER_TYPE(T, CPS::AttributePointer< T >)
addEMTPh1Components
void addEMTPh1Components(py::module_ mEMTPh1)
Definition EMTComponents.cpp:151
addEMTPh3Components
void addEMTPh3Components(py::module_ mEMTPh3)
Definition EMTComponents.cpp:295
addEMTComponents
void addEMTComponents(py::module_ mEMT)
Definition EMTComponents.cpp:121
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:144
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:185
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:164
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::AvVoltageSourceInverterDQ::setTransformerParameters
void setTransformerParameters(Real nomVoltagePrimary, Real nomVoltageSecondary, 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::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::HalfDecouplingLine
One end of a Bergeron travelling-wave line. Two of these replace a single Signal::DecouplingLineEMT_P...
Definition EMT_Ph3_HalfDecouplingLine.h:18
CPS::EMT::Ph3::HalfDecouplingLine::setParameters
void setParameters(Matrix resistance, Matrix inductance, Matrix capacitance)
Line data. Give the parameters of the whole line, not of this half.
Definition EMT_Ph3_HalfDecouplingLine.cpp:29
CPS::EMT::Ph3::HalfDecouplingLine::setCouplingSource
void setCouplingSource(Attribute< Matrix >::Ptr receivingVolt, Attribute< Matrix >::Ptr receivingCur)
Definition EMT_Ph3_HalfDecouplingLine.cpp:48
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::PQLoad::setParameters
void setParameters(Real activePower, Real reactivePower, Real nominalVoltage, Real minimumVoltagePerUnit=0.1)
Sets total three-phase P/Q, nominal line-to-line voltage and voltage floor.
Definition EMT_Ph3_PQLoad.cpp:57
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::setMagnetizingBranch
void setMagnetizingBranch(Real noLoadCurrent, Real noLoadLoss)
Sets the magnetizing branch from the no-load test quantities.
Definition EMT_Ph3_Transformer.h:68
CPS::EMT::Ph3::Transformer::setReferenceWinding
void setReferenceWinding(WindingReference referenceWinding)
Selects the winding the nameplate impedance is referred to.
Definition EMT_Ph3_Transformer.h:73
CPS::EMT::Ph3::Transformer::setParameters
void setParameters(Real nomVoltagePrimary, Real nomVoltageSecondary, 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::setTransformerParameters
void setTransformerParameters(Real nomVoltagePrimary, Real nomVoltageSecondary, 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::VSIVoltageControlVCO::setFilterParameters
void setFilterParameters(Real Lf, Real Cf, Real Rf, Real Rc)
Setter for parameters of filter.
Definition EMT_Ph3_VSIVoltageControlVCO.cpp:163
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:147
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:184
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::MNASyncGenInterface
Interface to be used by synchronous generators.
Definition MNASyncGenInterface.h:17
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:63
CPS::Real
double Real
Definition Definitions.h:60
zeroMatrix
CPS::Matrix zeroMatrix(int dim)
Definition Utils.cpp:11