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/IdentifiedObject.h>
12#include <dpsim/RealTimeSimulation.h>
13#include <dpsim/Simulation.h>
14#include <dpsim/pybind/EMTComponents.h>
15#include <dpsim/pybind/Utils.h>
16
17#ifdef WITH_JSON
18#include <nlohmann/json.hpp>
19using json = nlohmann::json;
20#endif
21
22namespace py = pybind11;
23using namespace pybind11::literals;
24
25void addEMTComponents(py::module_ mEMT) {
26 py::class_<CPS::EMT::SimNode, std::shared_ptr<CPS::EMT::SimNode>,
27 CPS::TopologicalNode>(mEMT, "SimNode", py::module_local())
28 .def(py::init<std::string>())
29 .def(py::init<std::string, CPS::PhaseType>())
30 .def(py::init<std::string, CPS::PhaseType,
31 const std::vector<CPS::Complex>>())
32 .def("set_initial_voltage",
33 py::overload_cast<CPS::MatrixComp>(
34 &CPS::EMT::SimNode::setInitialVoltage, py::const_))
35 .def("set_initial_voltage",
36 py::overload_cast<CPS::Complex>(
37 &CPS::EMT::SimNode::setInitialVoltage, py::const_))
38 .def("set_initial_voltage",
39 py::overload_cast<CPS::Complex, int>(
40 &CPS::EMT::SimNode::setInitialVoltage, py::const_))
41 .def_readonly_static("gnd", &CPS::EMT::SimNode::GND);
42
43 py::module mEMTPh1 = mEMT.def_submodule(
44 "ph1", "single phase electromagnetic-transient models");
45 addEMTPh1Components(mEMTPh1);
46 py::module mEMTPh3 =
47 mEMT.def_submodule("ph3", "three phase electromagnetic-transient models");
48 addEMTPh3Components(mEMTPh3);
49}
50
51void addEMTPh1Components(py::module_ mEMTPh1) {
52 py::class_<CPS::EMT::Ph1::CurrentSource,
53 std::shared_ptr<CPS::EMT::Ph1::CurrentSource>,
54 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "CurrentSource",
55 py::multiple_inheritance())
56 .def(py::init<std::string>())
57 .def(py::init<std::string, CPS::Logger::Level>())
58 .def("set_parameters", &CPS::EMT::Ph1::CurrentSource::setParameters,
59 "I_ref"_a, "f_src"_a = -1)
60 .def("connect", &CPS::EMT::Ph1::CurrentSource::connect)
61 .def_property("I_ref", createAttributeGetter<CPS::Complex>("I_ref"),
62 createAttributeSetter<CPS::Complex>("I_ref"))
63 .def_property("f_src", createAttributeGetter<CPS::Real>("f_src"),
64 createAttributeSetter<CPS::Real>("f_src"));
65
66 py::class_<CPS::EMT::Ph1::VoltageSource,
67 std::shared_ptr<CPS::EMT::Ph1::VoltageSource>,
68 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "VoltageSource",
69 py::multiple_inheritance())
70 .def(py::init<std::string>())
71 .def(py::init<std::string, CPS::Logger::Level>())
72 .def("set_parameters", &CPS::EMT::Ph1::VoltageSource::setParameters,
73 "V_ref"_a, "f_src"_a = -1)
74 .def("connect", &CPS::EMT::Ph1::VoltageSource::connect)
75 .def_property("V_ref", createAttributeGetter<CPS::Complex>("V_ref"),
76 createAttributeSetter<CPS::Complex>("V_ref"))
77 .def_property("f_src", createAttributeGetter<CPS::Real>("f_src"),
78 createAttributeSetter<CPS::Real>("f_src"));
79
80 py::class_<CPS::EMT::Ph1::Resistor, std::shared_ptr<CPS::EMT::Ph1::Resistor>,
81 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "Resistor",
82 py::multiple_inheritance())
83 .def(py::init<std::string>())
84 .def(py::init<std::string, CPS::Logger::Level>())
85 .def("set_parameters", &CPS::EMT::Ph1::Resistor::setParameters, "R"_a)
86 .def("connect", &CPS::EMT::Ph1::Resistor::connect)
87 .def_property("R", createAttributeGetter<CPS::Real>("R"),
88 createAttributeSetter<CPS::Real>("R"));
89
90 py::class_<CPS::EMT::Ph1::Capacitor,
91 std::shared_ptr<CPS::EMT::Ph1::Capacitor>,
92 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "Capacitor",
93 py::multiple_inheritance())
94 .def(py::init<std::string>())
95 .def(py::init<std::string, CPS::Logger::Level>())
96 .def("set_parameters", &CPS::EMT::Ph1::Capacitor::setParameters, "C"_a)
97 .def("connect", &CPS::EMT::Ph1::Capacitor::connect)
98 .def_property("C", createAttributeGetter<CPS::Real>("C"),
99 createAttributeSetter<CPS::Real>("C"));
100
101 py::class_<CPS::EMT::Ph1::Inductor, std::shared_ptr<CPS::EMT::Ph1::Inductor>,
102 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "Inductor",
103 py::multiple_inheritance())
104 .def(py::init<std::string>())
105 .def(py::init<std::string, CPS::Logger::Level>())
106 .def("set_parameters", &CPS::EMT::Ph1::Inductor::setParameters, "L"_a)
107 .def("connect", &CPS::EMT::Ph1::Inductor::connect)
108 .def_property("L", createAttributeGetter<CPS::Real>("L"),
109 createAttributeSetter<CPS::Real>("L"));
110
111 py::class_<CPS::EMT::Ph1::Switch, std::shared_ptr<CPS::EMT::Ph1::Switch>,
112 CPS::SimPowerComp<CPS::Real>, CPS::Base::Ph1::Switch>(
113 mEMTPh1, "Switch", py::multiple_inheritance())
114 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
115 "loglevel"_a = CPS::Logger::Level::off)
116 .def("set_parameters", &CPS::EMT::Ph1::Switch::setParameters,
117 "open_resistance"_a, "closed_resistance"_a,
118 "closed"_a = false) // cppcheck-suppress assignBoolToPointer
119 .def("open", &CPS::EMT::Ph1::Switch::open)
120 .def("close", &CPS::EMT::Ph1::Switch::close)
121 .def("connect", &CPS::EMT::Ph1::Switch::connect);
122
123 py::class_<CPS::EMT::Ph1::SSN::Full_Serial_RLC,
124 std::shared_ptr<CPS::EMT::Ph1::SSN::Full_Serial_RLC>,
125 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "Full_Serial_RLC",
126 py::multiple_inheritance())
127 .def(py::init<std::string>())
128 .def(py::init<std::string, CPS::Logger::Level>())
129 .def("set_parameters",
130 &CPS::EMT::Ph1::SSN::Full_Serial_RLC::setParameters, "R"_a, "L"_a,
131 "C"_a)
132 .def("connect", &CPS::EMT::Ph1::SSN::Full_Serial_RLC::connect)
133 .def_property("R", createAttributeGetter<CPS::Real>("R"),
134 createAttributeSetter<CPS::Real>("R"))
135 .def_property("L", createAttributeGetter<CPS::Real>("L"),
136 createAttributeSetter<CPS::Real>("L"))
137 .def_property("C", createAttributeGetter<CPS::Real>("C"),
138 createAttributeSetter<CPS::Real>("C"));
139
140 py::class_<CPS::EMT::Ph1::SSNTypeI2T,
141 std::shared_ptr<CPS::EMT::Ph1::SSNTypeI2T>,
142 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "SSNTypeI2T",
143 py::multiple_inheritance())
144 .def(py::init<std::string>())
145 .def(py::init<std::string, CPS::Logger::Level>())
146 .def("set_parameters", &CPS::EMT::Ph1::SSNTypeI2T::setParameters, "A"_a,
147 "B"_a, "C"_a, "D"_a)
148 .def("manual_init", &CPS::EMT::Ph1::SSNTypeI2T::manualInit,
149 "initialState"_a, "initialInput"_a, "initialOldInput"_a,
150 "initCurr"_a, "initVol"_a)
151 .def("connect", &CPS::EMT::Ph1::SSNTypeI2T::connect)
152 .def_property("mA", createAttributeGetter<CPS::Matrix>("mA"),
153 createAttributeSetter<CPS::Matrix>("mA"))
154 .def_property("mB", createAttributeGetter<CPS::Matrix>("mB"),
155 createAttributeSetter<CPS::Matrix>("mB"))
156 .def_property("mC", createAttributeGetter<CPS::Matrix>("mC"),
157 createAttributeSetter<CPS::Matrix>("mC"))
158 .def_property("mD", createAttributeGetter<CPS::Matrix>("mD"),
159 createAttributeSetter<CPS::Matrix>("mD"))
160 .def_property("mdA", createAttributeGetter<CPS::Matrix>("mdA"),
161 createAttributeSetter<CPS::Matrix>("mdA"))
162 .def_property("mdB", createAttributeGetter<CPS::Matrix>("mdB"),
163 createAttributeSetter<CPS::Matrix>("mdB"))
164 .def_property("mdC", createAttributeGetter<CPS::Matrix>("mdC"),
165 createAttributeSetter<CPS::Matrix>("mdC"));
166
167 py::class_<CPS::EMT::Ph1::SSNTypeV2T,
168 std::shared_ptr<CPS::EMT::Ph1::SSNTypeV2T>,
169 CPS::SimPowerComp<CPS::Real>>(mEMTPh1, "SSNTypeV2T",
170 py::multiple_inheritance())
171 .def(py::init<std::string>())
172 .def(py::init<std::string, CPS::Logger::Level>())
173 .def("set_parameters", &CPS::EMT::Ph1::SSNTypeV2T::setParameters, "A"_a,
174 "B"_a, "C"_a, "D"_a)
175 .def("manual_init", &CPS::EMT::Ph1::SSNTypeV2T::manualInit,
176 "initialState"_a, "initialInput"_a, "initialOldInput"_a,
177 "initCurr"_a, "initVol"_a)
178 .def("connect", &CPS::EMT::Ph1::SSNTypeV2T::connect)
179 .def_property("mA", createAttributeGetter<CPS::Matrix>("mA"),
180 createAttributeSetter<CPS::Matrix>("mA"))
181 .def_property("mB", createAttributeGetter<CPS::Matrix>("mB"),
182 createAttributeSetter<CPS::Matrix>("mB"))
183 .def_property("mC", createAttributeGetter<CPS::Matrix>("mC"),
184 createAttributeSetter<CPS::Matrix>("mC"))
185 .def_property("mD", createAttributeGetter<CPS::Matrix>("mD"),
186 createAttributeSetter<CPS::Matrix>("mD"))
187 .def_property("mdA", createAttributeGetter<CPS::Matrix>("mdA"),
188 createAttributeSetter<CPS::Matrix>("mdA"))
189 .def_property("mdB", createAttributeGetter<CPS::Matrix>("mdB"),
190 createAttributeSetter<CPS::Matrix>("mdB"))
191 .def_property("mdC", createAttributeGetter<CPS::Matrix>("mdC"),
192 createAttributeSetter<CPS::Matrix>("mdC"));
193}
194
195void addEMTPh3Components(py::module_ mEMTPh3) {
196 py::class_<CPS::EMT::Ph3::VoltageSource,
197 std::shared_ptr<CPS::EMT::Ph3::VoltageSource>,
198 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "VoltageSource",
199 py::multiple_inheritance())
200 .def(py::init<std::string>())
201 .def(py::init<std::string, CPS::Logger::Level>())
202 .def("set_parameters",
203 py::overload_cast<CPS::MatrixComp, CPS::Real>(
204 &CPS::EMT::Ph3::VoltageSource::setParameters),
205 "V_ref"_a, "f_src"_a = 50)
206 .def("connect", &CPS::EMT::Ph3::VoltageSource::connect)
207 .def_property("V_ref", createAttributeGetter<CPS::MatrixComp>("V_ref"),
208 createAttributeSetter<CPS::MatrixComp>("V_ref"))
209 .def_property("f_src", createAttributeGetter<CPS::Real>("f_src"),
210 createAttributeSetter<CPS::Real>("f_src"));
211
212 py::class_<CPS::EMT::Ph3::ControlledVoltageSource,
213 std::shared_ptr<CPS::EMT::Ph3::ControlledVoltageSource>,
214 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "ControlledVoltageSource",
215 py::multiple_inheritance())
216 .def(py::init<std::string>())
217 .def(py::init<std::string, CPS::Logger::Level>())
218 .def("set_parameters",
219 py::overload_cast<CPS::Matrix>(
220 &CPS::EMT::Ph3::ControlledVoltageSource::setParameters),
221 "V_ref"_a)
222 .def("connect", &CPS::EMT::Ph3::ControlledVoltageSource::connect)
223 .def_property("V_ref", createAttributeGetter<CPS::MatrixComp>("V_ref"),
224 createAttributeSetter<CPS::MatrixComp>("V_ref"));
225
226 py::class_<CPS::EMT::Ph3::CurrentSource,
227 std::shared_ptr<CPS::EMT::Ph3::CurrentSource>,
228 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "CurrentSource",
229 py::multiple_inheritance())
230 .def(py::init<std::string>())
231 .def(py::init<std::string, CPS::Logger::Level>())
232 .def("set_parameters",
233 py::overload_cast<CPS::MatrixComp, CPS::Real>(
234 &CPS::EMT::Ph3::CurrentSource::setParameters),
235 "I_ref"_a, "f_src"_a = 50)
236 .def("connect", &CPS::EMT::Ph3::CurrentSource::connect)
237 .def_property("I_ref", createAttributeGetter<CPS::MatrixComp>("I_ref"),
238 createAttributeSetter<CPS::MatrixComp>("V_ref"))
239 .def_property("f_src", createAttributeGetter<CPS::Real>("f_src"),
240 createAttributeSetter<CPS::Real>("f_src"));
241
242 py::class_<CPS::EMT::Ph3::Resistor, std::shared_ptr<CPS::EMT::Ph3::Resistor>,
243 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Resistor",
244 py::multiple_inheritance())
245 .def(py::init<std::string>())
246 .def(py::init<std::string, CPS::Logger::Level>())
247 .def("set_parameters", &CPS::EMT::Ph3::Resistor::setParameters, "R"_a)
248 .def("connect", &CPS::EMT::Ph3::Resistor::connect);
249
250 py::class_<CPS::EMT::Ph3::Capacitor,
251 std::shared_ptr<CPS::EMT::Ph3::Capacitor>,
252 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Capacitor",
253 py::multiple_inheritance())
254 .def(py::init<std::string>())
255 .def(py::init<std::string, CPS::Logger::Level>())
256 .def("set_parameters", &CPS::EMT::Ph3::Capacitor::setParameters, "C"_a)
257 .def("connect", &CPS::EMT::Ph3::Capacitor::connect);
258
259 py::class_<CPS::EMT::Ph3::Inductor, std::shared_ptr<CPS::EMT::Ph3::Inductor>,
260 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Inductor",
261 py::multiple_inheritance())
262 .def(py::init<std::string>())
263 .def(py::init<std::string, CPS::Logger::Level>())
264 .def("set_parameters", &CPS::EMT::Ph3::Inductor::setParameters, "L"_a)
265 .def("connect", &CPS::EMT::Ph3::Inductor::connect);
266
267 py::class_<CPS::EMT::Ph3::NetworkInjection,
268 std::shared_ptr<CPS::EMT::Ph3::NetworkInjection>,
269 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "NetworkInjection",
270 py::multiple_inheritance())
271 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
272 "loglevel"_a = CPS::Logger::Level::off)
273 .def("set_parameters",
274 py::overload_cast<CPS::MatrixComp, CPS::Real>(
275 &CPS::EMT::Ph3::NetworkInjection::setParameters),
276 "V_ref"_a, "f_src"_a = 50)
277 .def("connect", &CPS::EMT::Ph3::NetworkInjection::connect);
278
279 py::class_<CPS::EMT::Ph3::PiLine, std::shared_ptr<CPS::EMT::Ph3::PiLine>,
280 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "PiLine",
281 py::multiple_inheritance())
282 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
283 "loglevel"_a = CPS::Logger::Level::off)
284 .def("set_parameters", &CPS::EMT::Ph3::PiLine::setParameters,
285 "series_resistance"_a, "series_inductance"_a,
286 "parallel_capacitance"_a = zeroMatrix(3),
287 "parallel_conductance"_a = zeroMatrix(3))
288 .def("connect", &CPS::EMT::Ph3::PiLine::connect);
289
290 py::class_<CPS::EMT::Ph3::RXLoad, std::shared_ptr<CPS::EMT::Ph3::RXLoad>,
291 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "RXLoad",
292 py::multiple_inheritance())
293 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
294 "loglevel"_a = CPS::Logger::Level::off)
295 .def("set_parameters", &CPS::EMT::Ph3::RXLoad::setParameters,
296 "active_power"_a, "reactive_power"_a, "volt"_a,
297 // cppcheck-suppress assignBoolToPointer
298 "reactance_in_series"_a = false)
299 .def("connect", &CPS::EMT::Ph3::RXLoad::connect);
300
301 py::class_<CPS::EMT::Ph3::Shunt, std::shared_ptr<CPS::EMT::Ph3::Shunt>,
302 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Shunt",
303 py::multiple_inheritance())
304 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
305 "loglevel"_a = CPS::Logger::Level::off)
306 .def("set_parameters",
307 static_cast<void (CPS::EMT::Ph3::Shunt::*)(CPS::Real, CPS::Real)>(
308 &CPS::EMT::Ph3::Shunt::setParameters),
309 "G"_a, "B"_a)
310 .def("connect", &CPS::EMT::Ph3::Shunt::connect);
311
312 py::class_<CPS::EMT::Ph3::Switch, std::shared_ptr<CPS::EMT::Ph3::Switch>,
313 CPS::SimPowerComp<CPS::Real>, CPS::Base::Ph3::Switch>(
314 mEMTPh3, "Switch", py::multiple_inheritance())
315 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
316 "loglevel"_a = CPS::Logger::Level::off)
317 .def("set_parameters", &CPS::EMT::Ph3::Switch::setParameters,
318 "open_resistance"_a, "closed_resistance"_a,
319 // cppcheck-suppress assignBoolToPointer
320 "closed"_a = false)
321 .def("open", &CPS::EMT::Ph3::Switch::openSwitch)
322 .def("close", &CPS::EMT::Ph3::Switch::closeSwitch)
323 .def("connect", &CPS::EMT::Ph3::Switch::connect);
324
325 py::class_<CPS::EMT::Ph3::SynchronGeneratorIdeal,
326 std::shared_ptr<CPS::EMT::Ph3::SynchronGeneratorIdeal>,
327 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SynchronGeneratorIdeal",
328 py::multiple_inheritance())
329 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
330 "loglevel"_a = CPS::Logger::Level::off)
331 .def("connect", &CPS::EMT::Ph3::SynchronGeneratorIdeal::connect);
332
333 py::class_<CPS::EMT::Ph3::SynchronGeneratorDQTrapez,
334 std::shared_ptr<CPS::EMT::Ph3::SynchronGeneratorDQTrapez>,
335 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SynchronGeneratorDQTrapez",
336 py::multiple_inheritance())
337 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
338 "loglevel"_a = CPS::Logger::Level::off)
339 .def("set_parameters_operational_per_unit",
340 &CPS::EMT::Ph3::SynchronGeneratorDQTrapez::
341 setParametersOperationalPerUnit,
342 "nom_power"_a, "nom_volt"_a, "nom_freq"_a, "pole_number"_a,
343 "nom_field_cur"_a, "Rs"_a, "Ld"_a, "Lq"_a, "Ld_t"_a, "Lq_t"_a,
344 "Ld_s"_a, "Lq_s"_a, "Ll"_a, "Td0_t"_a, "Tq0_t"_a, "Td0_s"_a,
345 "Tq0_s"_a, "inertia"_a)
346 .def("set_parameters_fundamental_per_unit",
347 &CPS::EMT::Ph3::SynchronGeneratorDQTrapez::
348 setParametersFundamentalPerUnit,
349 "nom_power"_a, "nom_volt"_a, "nom_freq"_a, "pole_number"_a,
350 "nom_field_cur"_a, "Rs"_a, "Ll"_a, "Lmd"_a, "Lmq"_a, "Rfd"_a,
351 "Llfd"_a, "Rkd"_a, "Llkd"_a, "Rkq1"_a, "Llkq1"_a, "Rkq2"_a,
352 "Llkq2"_a, "inertia"_a, "init_active_power"_a,
353 "init_reactive_power"_a, "init_terminal_volt"_a, "init_volt_angle"_a,
354 "init_mech_power"_a)
355#ifdef WITH_JSON
356 .def("apply_parameters_from_json",
357 [](std::shared_ptr<CPS::EMT::Ph3::SynchronGeneratorDQTrapez> syngen,
358 const CPS::String json) {
359 DPsim::Utils::applySynchronousGeneratorParametersFromJson(
360 json::parse(json), syngen);
361 })
362#endif
363 .def("set_initial_values",
364 &CPS::EMT::Ph3::SynchronGeneratorDQTrapez::setInitialValues,
365 "init_active_power"_a, "init_reactive_power"_a,
366 "init_terminal_volt"_a, "init_volt_angle"_a, "init_mech_power"_a);
367
368 py::class_<CPS::EMT::Ph3::VSIVoltageControlVCO,
369 std::shared_ptr<CPS::EMT::Ph3::VSIVoltageControlVCO>,
370 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "VSIVoltageControlVCO",
371 py::multiple_inheritance())
372 .def(py::init<std::string>())
373 .def(py::init<std::string, CPS::Logger::Level>())
374 .def(py::init<std::string, std::string, CPS::Logger::Level, CPS::Bool>(),
375 "uid"_a, "name"_a, "log_level"_a = CPS::Logger::Level::off,
376 py::arg("with_trafo") = false)
377 .def("set_parameters",
378 &CPS::EMT::Ph3::VSIVoltageControlVCO::setParameters, "sys_omega"_a,
379 "vd_ref"_a, "vq_ref"_a)
380 .def("set_controller_parameters",
381 &CPS::EMT::Ph3::VSIVoltageControlVCO::setControllerParameters,
382 "kp_voltage_ctrl"_a, "ki_voltage_ctrl"_a, "kp_curr_ctrl"_a,
383 "ki_curr_ctrl"_a, "omega_nominal"_a)
384 .def("set_transformer_parameters",
385 &CPS::EMT::Ph3::VSIVoltageControlVCO::setTransformerParameters,
386 "nom_voltage_end1"_a, "nom_voltage_end2"_a, "rated_power"_a,
387 "ratio_abs"_a, "ratio_phase"_a, "resistance"_a, "inductance"_a,
388 "omega"_a)
389 .def("set_filter_parameters",
390 &CPS::EMT::Ph3::VSIVoltageControlVCO::setFilterParameters, "lf"_a,
391 "cf"_a, "rf"_a, "rc"_a)
392 .def("set_initial_state_values",
393 &CPS::EMT::Ph3::VSIVoltageControlVCO::setInitialStateValues,
394 "phi_d_init"_a, "phi_q_init"_a, "gamma_d_init"_a, "gamma_q_init"_a)
395 .def("with_control", &CPS::EMT::Ph3::VSIVoltageControlVCO::withControl,
396 "control_on"_a)
397 .def("connect", &CPS::EMT::Ph3::VSIVoltageControlVCO::connect);
398
399 py::class_<CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR,
400 std::shared_ptr<CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>,
401 CPS::Base::ReducedOrderSynchronGenerator<CPS::Real>>(
402 mEMTPh3, "ReducedOrderSynchronGeneratorVBR", py::multiple_inheritance());
403
404 py::class_<CPS::EMT::Ph3::SynchronGenerator3OrderVBR,
405 std::shared_ptr<CPS::EMT::Ph3::SynchronGenerator3OrderVBR>,
406 CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>(
407 mEMTPh3, "SynchronGenerator3OrderVBR", py::multiple_inheritance())
408 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
409 "loglevel"_a = CPS::Logger::Level::off)
410 .def("set_operational_parameters_per_unit",
411 py::overload_cast<CPS::Real, CPS::Real, CPS::Real, CPS::Real,
412 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
413 CPS::Real>(
414 &CPS::EMT::Ph3::SynchronGenerator3OrderVBR::
415 setOperationalParametersPerUnit),
416 "nom_power"_a, "nom_voltage"_a, "nom_frequency"_a, "H"_a, "Ld"_a,
417 "Lq"_a, "L0"_a, "Ld_t"_a, "Td0_t"_a)
418 .def("connect", &CPS::EMT::Ph3::SynchronGenerator3OrderVBR::connect);
419
420 py::class_<CPS::EMT::Ph3::SynchronGenerator4OrderVBR,
421 std::shared_ptr<CPS::EMT::Ph3::SynchronGenerator4OrderVBR>,
422 CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>(
423 mEMTPh3, "SynchronGenerator4OrderVBR", py::multiple_inheritance())
424 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
425 "loglevel"_a = CPS::Logger::Level::off)
426 .def("set_operational_parameters_per_unit",
427 py::overload_cast<CPS::Real, CPS::Real, CPS::Real, CPS::Real,
428 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
429 CPS::Real, CPS::Real, CPS::Real>(
430 &CPS::EMT::Ph3::SynchronGenerator4OrderVBR::
431 setOperationalParametersPerUnit),
432 "nom_power"_a, "nom_voltage"_a, "nom_frequency"_a, "H"_a, "Ld"_a,
433 "Lq"_a, "L0"_a, "Ld_t"_a, "Lq_t"_a, "Td0_t"_a, "Tq0_t"_a)
434 .def("connect", &CPS::EMT::Ph3::SynchronGenerator4OrderVBR::connect);
435
436 py::class_<CPS::EMT::Ph3::SynchronGenerator5OrderVBR,
437 std::shared_ptr<CPS::EMT::Ph3::SynchronGenerator5OrderVBR>,
438 CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>(
439 mEMTPh3, "SynchronGenerator5OrderVBR", py::multiple_inheritance())
440 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
441 "loglevel"_a = CPS::Logger::Level::off)
442 .def("set_operational_parameters_per_unit",
443 py::overload_cast<CPS::Real, CPS::Real, CPS::Real, CPS::Real,
444 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
445 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
446 CPS::Real, CPS::Real, CPS::Real, CPS::Real>(
447 &CPS::EMT::Ph3::SynchronGenerator5OrderVBR::
448 setOperationalParametersPerUnit),
449 "nom_power"_a, "nom_voltage"_a, "nom_frequency"_a, "H"_a, "Ld"_a,
450 "Lq"_a, "L0"_a, "Ld_t"_a, "Lq_t"_a, "Td0_t"_a, "Tq0_t"_a, "Ld_s"_a,
451 "Lq_s"_a, "Td0_s"_a, "Tq0_s"_a, "Taa"_a)
452 .def("connect", &CPS::EMT::Ph3::SynchronGenerator5OrderVBR::connect);
453
454 py::class_<CPS::EMT::Ph3::SynchronGenerator6aOrderVBR,
455 std::shared_ptr<CPS::EMT::Ph3::SynchronGenerator6aOrderVBR>,
456 CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>(
457 mEMTPh3, "SynchronGenerator6aOrderVBR", py::multiple_inheritance())
458 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
459 "loglevel"_a = CPS::Logger::Level::off)
460 .def("set_operational_parameters_per_unit",
461 py::overload_cast<CPS::Real, CPS::Real, CPS::Real, CPS::Real,
462 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
463 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
464 CPS::Real, CPS::Real, CPS::Real, CPS::Real>(
465 &CPS::EMT::Ph3::SynchronGenerator6aOrderVBR::
466 setOperationalParametersPerUnit),
467 "nom_power"_a, "nom_voltage"_a, "nom_frequency"_a, "H"_a, "Ld"_a,
468 "Lq"_a, "L0"_a, "Ld_t"_a, "Lq_t"_a, "Td0_t"_a, "Tq0_t"_a, "Ld_s"_a,
469 "Lq_s"_a, "Td0_s"_a, "Tq0_s"_a, "Taa"_a)
470 .def("connect", &CPS::EMT::Ph3::SynchronGenerator6aOrderVBR::connect);
471
472 py::class_<CPS::EMT::Ph3::SynchronGenerator6bOrderVBR,
473 std::shared_ptr<CPS::EMT::Ph3::SynchronGenerator6bOrderVBR>,
474 CPS::EMT::Ph3::ReducedOrderSynchronGeneratorVBR>(
475 mEMTPh3, "SynchronGenerator6bOrderVBR", py::multiple_inheritance())
476 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
477 "loglevel"_a = CPS::Logger::Level::off)
478 .def("set_operational_parameters_per_unit",
479 py::overload_cast<CPS::Real, CPS::Real, CPS::Real, CPS::Real,
480 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
481 CPS::Real, CPS::Real, CPS::Real, CPS::Real,
482 CPS::Real, CPS::Real, CPS::Real, CPS::Real>(
483 &CPS::EMT::Ph3::SynchronGenerator6bOrderVBR::
484 setOperationalParametersPerUnit),
485 "nom_power"_a, "nom_voltage"_a, "nom_frequency"_a, "H"_a, "Ld"_a,
486 "Lq"_a, "L0"_a, "Ld_t"_a, "Lq_t"_a, "Td0_t"_a, "Tq0_t"_a, "Ld_s"_a,
487 "Lq_s"_a, "Td0_s"_a, "Tq0_s"_a, "Taa"_a = 0)
488 .def("connect", &CPS::EMT::Ph3::SynchronGenerator6bOrderVBR::connect);
489
490#ifdef WITH_SUNDIALS
491
492 py::class_<CPS::EMT::Ph3::SynchronGeneratorDQODE,
493 std::shared_ptr<CPS::EMT::Ph3::SynchronGeneratorDQODE>,
494 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SynchronGeneratorDQODE",
495 py::multiple_inheritance())
496 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
497 "loglevel"_a = CPS::Logger::Level::off)
498 .def("set_parameters_operational_per_unit",
499 &CPS::EMT::Ph3::SynchronGeneratorDQODE::
500 setParametersOperationalPerUnit,
501 "nom_power"_a, "nom_volt"_a, "nom_freq"_a, "pole_number"_a,
502 "nom_field_cur"_a, "Rs"_a, "Ld"_a, "Lq"_a, "Ld_t"_a, "Lq_t"_a,
503 "Ld_s"_a, "Lq_s"_a, "Ll"_a, "Td0_t"_a, "Tq0_t"_a, "Td0_s"_a,
504 "Tq0_s"_a, "inertia"_a)
505 .def("set_parameters_fundamental_per_unit",
506 &CPS::EMT::Ph3::SynchronGeneratorDQODE::
507 setParametersFundamentalPerUnit,
508 "nom_power"_a, "nom_volt"_a, "nom_freq"_a, "pole_number"_a,
509 "nom_field_cur"_a, "Rs"_a, "Ll"_a, "Lmd"_a, "Lmq"_a, "Rfd"_a,
510 "Llfd"_a, "Rkd"_a, "Llkd"_a, "Rkq1"_a, "Llkq1"_a, "Rkq2"_a,
511 "Llkq2"_a, "inertia"_a, "init_active_power"_a,
512 "init_reactive_power"_a, "init_terminal_volt"_a, "init_volt_angle"_a,
513 "init_mech_power"_a)
514#ifdef WITH_JSON
515 .def("apply_parameters_from_json",
516 [](std::shared_ptr<CPS::EMT::Ph3::SynchronGeneratorDQODE> syngen,
517 const CPS::String json) {
518 DPsim::Utils::applySynchronousGeneratorParametersFromJson(
519 json::parse(json), syngen);
520 })
521#endif
522 .def("set_initial_values",
523 &CPS::EMT::Ph3::SynchronGeneratorDQODE::setInitialValues,
524 "init_active_power"_a, "init_reactive_power"_a,
525 "init_terminal_volt"_a, "init_volt_angle"_a, "init_mech_power"_a);
526
527#endif
528
529 py::class_<CPS::EMT::Ph3::AvVoltageSourceInverterDQ,
530 std::shared_ptr<CPS::EMT::Ph3::AvVoltageSourceInverterDQ>,
531 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "AvVoltageSourceInverterDQ",
532 py::multiple_inheritance())
533 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
534 "loglevel"_a = CPS::Logger::Level::off)
535 .def(py::init<std::string, std::string, CPS::Logger::Level, CPS::Bool>(),
536 "uid"_a, "name"_a, "loglevel"_a = CPS::Logger::Level::off,
537 // cppcheck-suppress assignBoolToPointer
538 "with_trafo"_a = false)
539 .def("set_parameters",
540 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setParameters,
541 "sys_omega"_a, "sys_volt_nom"_a, "p_ref"_a, "q_ref"_a)
542 .def("set_filter_parameters",
543 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setFilterParameters,
544 "Lf"_a, "Cf"_a, "Rf"_a, "Rc"_a)
545 .def("set_controller_parameters",
546 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setControllerParameters,
547 "Kp_pll"_a, "Ki_pll"_a, "Kp_power_ctrl"_a, "Ki_power_ctrl"_a,
548 "Kp_curr_ctrl"_a, "Ki_curr_ctrl"_a, "omega_cutoff"_a)
549 .def("set_transformer_parameters",
550 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setTransformerParameters,
551 "nom_voltage_end_1"_a, "nom_voltage_end_2"_a, "rated_power"_a,
552 "ratio_abs"_a, "ratio_phase"_a, "resistance"_a, "inductance"_a,
553 "omega"_a)
554 .def("set_initial_state_values",
555 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::setInitialStateValues,
556 "p_init"_a, "q_init"_a, "phi_d_init"_a, "phi_q_init"_a,
557 "gamma_d_init"_a, "gamma_q_init"_a)
558 .def("with_control",
559 &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::withControl)
560 .def("connect", &CPS::EMT::Ph3::AvVoltageSourceInverterDQ::connect);
561
562 py::class_<CPS::EMT::Ph3::Transformer,
563 std::shared_ptr<CPS::EMT::Ph3::Transformer>,
564 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Transformer",
565 py::multiple_inheritance())
566 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
567 "loglevel"_a = CPS::Logger::Level::off)
568 .def(py::init<std::string, std::string, CPS::Logger::Level, CPS::Bool>(),
569 "uid"_a, "name"_a, "loglevel"_a = CPS::Logger::Level::off,
570 // cppcheck-suppress assignBoolToPointer
571 "with_resistive_losses"_a = false)
572 .def("set_parameters", &CPS::EMT::Ph3::Transformer::setParameters,
573 "nom_voltage_end_1"_a, "nom_voltage_end_2"_a, "rated_power"_a,
574 "ratio_abs"_a, "ratio_phase"_a, "resistance"_a, "inductance"_a)
575 .def("connect", &CPS::EMT::Ph3::Transformer::connect);
576
577 py::class_<CPS::EMT::Ph3::SeriesResistor,
578 std::shared_ptr<CPS::EMT::Ph3::SeriesResistor>,
579 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SeriesResistor",
580 py::multiple_inheritance())
581 .def(py::init<std::string>())
582 .def(py::init<std::string, CPS::Logger::Level>())
583 .def("set_parameters", &CPS::EMT::Ph3::SeriesResistor::setParameters,
584 "R"_a)
585 .def("connect", &CPS::EMT::Ph3::SeriesResistor::connect);
586
587 py::class_<CPS::EMT::Ph3::SeriesSwitch,
588 std::shared_ptr<CPS::EMT::Ph3::SeriesSwitch>,
589 CPS::SimPowerComp<CPS::Real>, CPS::Base::Ph1::Switch>(
590 mEMTPh3, "SeriesSwitch", py::multiple_inheritance())
591 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
592 "loglevel"_a = CPS::Logger::Level::off)
593 .def("set_parameters", &CPS::EMT::Ph3::SeriesSwitch::setParameters,
594 "open_resistance"_a, "closed_resistance"_a,
595 // cppcheck-suppress assignBoolToPointer
596 "closed"_a = false)
597 .def("open", &CPS::EMT::Ph3::SeriesSwitch::open)
598 .def("close", &CPS::EMT::Ph3::SeriesSwitch::close)
599 .def("connect", &CPS::EMT::Ph3::SeriesSwitch::connect);
600
601 py::class_<CPS::EMT::Ph3::SSN::Full_Serial_RLC,
602 std::shared_ptr<CPS::EMT::Ph3::SSN::Full_Serial_RLC>,
603 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "Full_Serial_RLC",
604 py::multiple_inheritance())
605 .def(py::init<std::string>())
606 .def(py::init<std::string, CPS::Logger::Level>())
607 .def("set_parameters",
608 &CPS::EMT::Ph3::SSN::Full_Serial_RLC::setParameters, "R"_a, "L"_a,
609 "C"_a)
610 .def("connect", &CPS::EMT::Ph3::SSN::Full_Serial_RLC::connect)
611 .def_property("R", createAttributeGetter<CPS::Matrix>("R"),
612 createAttributeSetter<CPS::Matrix>("R"))
613 .def_property("L", createAttributeGetter<CPS::Matrix>("L"),
614 createAttributeSetter<CPS::Matrix>("L"))
615 .def_property("C", createAttributeGetter<CPS::Matrix>("C"),
616 createAttributeSetter<CPS::Matrix>("C"));
617
618 py::class_<CPS::EMT::Ph3::GenericTwoTerminalVTypeSSN,
619 std::shared_ptr<CPS::EMT::Ph3::GenericTwoTerminalVTypeSSN>,
620 CPS::SimPowerComp<CPS::Real>>(
621 mEMTPh3, "GenericTwoTerminalVTypeSSN", py::multiple_inheritance())
622 .def(py::init<std::string>())
623 .def(py::init<std::string, CPS::Logger::Level>())
624 .def("set_parameters",
625 &CPS::EMT::Ph3::GenericTwoTerminalVTypeSSN::setParameters, "A"_a,
626 "B"_a, "C"_a, "D"_a)
627 .def("connect", &CPS::EMT::Ph3::GenericTwoTerminalVTypeSSN::connect)
628 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
629
630 py::class_<CPS::EMT::Ph3::GenericTwoTerminalITypeSSN,
631 std::shared_ptr<CPS::EMT::Ph3::GenericTwoTerminalITypeSSN>,
632 CPS::SimPowerComp<CPS::Real>>(
633 mEMTPh3, "GenericTwoTerminalITypeSSN", py::multiple_inheritance())
634 .def(py::init<std::string>())
635 .def(py::init<std::string, CPS::Logger::Level>())
636 .def("set_parameters",
637 &CPS::EMT::Ph3::GenericTwoTerminalITypeSSN::setParameters, "A"_a,
638 "B"_a, "C"_a, "D"_a)
639 .def("connect", &CPS::EMT::Ph3::GenericTwoTerminalITypeSSN::connect)
640 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
641
642 py::class_<CPS::EMT::Ph3::PiecewiseLinearInductor,
643 std::shared_ptr<CPS::EMT::Ph3::PiecewiseLinearInductor>,
644 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "PiecewiseLinearInductor",
645 py::multiple_inheritance())
646 .def(py::init<std::string>())
647 .def(py::init<std::string, CPS::Logger::Level>())
648 .def("set_parameters",
649 &CPS::EMT::Ph3::PiecewiseLinearInductor::setParameters,
650 "flux_breakpoints"_a, "current_breakpoints"_a)
651 .def("connect", &CPS::EMT::Ph3::PiecewiseLinearInductor::connect)
652 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
653
654 py::class_<CPS::EMT::Ph3::AvVoltSourceInverterStateSpace,
655 std::shared_ptr<CPS::EMT::Ph3::AvVoltSourceInverterStateSpace>,
656 CPS::SimPowerComp<CPS::Real>>(
657 mEMTPh3, "AvVoltSourceInverterStateSpace", py::multiple_inheritance())
658 .def(py::init<std::string, CPS::Logger::Level>(), "name"_a,
659 "loglevel"_a = CPS::Logger::Level::off)
660 .def(py::init<std::string, std::string, CPS::Logger::Level>(), "uid"_a,
661 "name"_a, "loglevel"_a = CPS::Logger::Level::off)
662 .def("set_parameters",
663 &CPS::EMT::Ph3::AvVoltSourceInverterStateSpace::setParameters,
664 "Lf"_a, "Cf"_a, "Rf"_a, "Rc"_a, "omega_n"_a, "Kp_pll"_a, "Ki_pll"_a,
665 "omega_cutoff"_a, "p_ref"_a, "q_ref"_a, "Kp_power_ctrl"_a,
666 "Ki_power_ctrl"_a, "Kp_curr_ctrl"_a, "Ki_curr_ctrl"_a)
667 .def("connect", &CPS::EMT::Ph3::AvVoltSourceInverterStateSpace::connect)
668 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"))
669 .def_property_readonly("vc_d", createAttributeGetter<CPS::Real>("vc_d"))
670 .def_property_readonly("vc_q", createAttributeGetter<CPS::Real>("vc_q"))
671 .def_property_readonly("irc_d", createAttributeGetter<CPS::Real>("irc_d"))
672 .def_property_readonly("irc_q", createAttributeGetter<CPS::Real>("irc_q"))
673 .def_property_readonly("p_inst",
674 createAttributeGetter<CPS::Real>("p_inst"))
675 .def_property_readonly("q_inst",
676 createAttributeGetter<CPS::Real>("q_inst"))
677 .def_property_readonly("omega_pll",
678 createAttributeGetter<CPS::Real>("omega_pll"));
679
680 py::class_<CPS::EMT::Ph3::SSN_GFM, std::shared_ptr<CPS::EMT::Ph3::SSN_GFM>,
681 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SSN_GFM",
682 py::multiple_inheritance())
683 .def(py::init<std::string, std::string, CPS::Logger::Level>(), "uid"_a,
684 "name"_a, "log_level"_a = CPS::Logger::Level::off)
685 .def("set_parameters", &CPS::EMT::Ph3::SSN_GFM::setParameters, "lf"_a,
686 "cf"_a, "rf"_a, "rc"_a, "nominal_voltage"_a, "omega_nominal"_a,
687 "p_ref"_a, "q_ref"_a, "virtual_inertia"_a, "damping_coefficient"_a,
688 "voltage_droop_gain"_a, "reactive_integral_gain"_a, "kp_voltage"_a,
689 "ki_voltage"_a, "kp_current"_a, "ki_current"_a,
690 "active_damping_gain"_a, "power_filter_cutoff"_a,
691 "delay_bandwidth"_a)
692 .def("set_numerical_linearization_parameters",
693 &CPS::EMT::Ph3::SSN_GFM::setNumericalLinearizationParameters,
694 "relative_step"_a = 1e-6, "absolute_step"_a = 1e-8)
695 .def("set_virtual_impedance",
696 &CPS::EMT::Ph3::SSN_GFM::setVirtualImpedance, "virtual_resistance"_a,
697 "virtual_reactance"_a = 0.0)
698 .def("set_grid_current_feedforward",
699 &CPS::EMT::Ph3::SSN_GFM::setGridCurrentFeedforward, "scale"_a)
700 .def("set_reactive_power_droop",
701 &CPS::EMT::Ph3::SSN_GFM::setReactivePowerDroop, "droop_gain"_a,
702 "cutoff"_a)
703 .def("connect", &CPS::EMT::Ph3::SSN_GFM::connect)
704 .def("get_state_names", &CPS::EMT::Ph3::SSN_GFM::getLocalStateNames)
705 .def("get_state", &CPS::EMT::Ph3::SSN_GFM::getState)
706 .def("get_state_derivative", &CPS::EMT::Ph3::SSN_GFM::getStateDerivative)
707 .def("get_interface_voltage",
708 &CPS::EMT::Ph3::SSN_GFM::getInterfaceVoltage)
709 .def("get_interface_current",
710 &CPS::EMT::Ph3::SSN_GFM::getInterfaceCurrent)
711 .def_property_readonly("p_inst",
712 createAttributeGetter<CPS::Real>("p_inst"))
713 .def_property_readonly("q_inst",
714 createAttributeGetter<CPS::Real>("q_inst"))
715 .def_property_readonly("omega_gfm",
716 createAttributeGetter<CPS::Real>("omega_gfm"))
717 .def_property_readonly("theta_gfm",
718 createAttributeGetter<CPS::Real>("theta_gfm"))
719 .def_property_readonly(
720 "voltage_magnitude_gfm",
721 createAttributeGetter<CPS::Real>("voltage_magnitude_gfm"))
722 .def_property_readonly("vc_d", createAttributeGetter<CPS::Real>("vc_d"))
723 .def_property_readonly("vc_q", createAttributeGetter<CPS::Real>("vc_q"))
724 .def_property_readonly("i_grid_d",
725 createAttributeGetter<CPS::Real>("i_grid_d"))
726 .def_property_readonly("i_grid_q",
727 createAttributeGetter<CPS::Real>("i_grid_q"))
728 .def_property_readonly("if_d", createAttributeGetter<CPS::Real>("if_d"))
729 .def_property_readonly("if_q", createAttributeGetter<CPS::Real>("if_q"))
730 .def_property_readonly("v_ref_d",
731 createAttributeGetter<CPS::Real>("v_ref_d"))
732 .def_property_readonly("v_ref_q",
733 createAttributeGetter<CPS::Real>("v_ref_q"));
734
735 py::class_<CPS::EMT::Ph3::SSN::Capacitor,
736 std::shared_ptr<CPS::EMT::Ph3::SSN::Capacitor>,
737 CPS::SimPowerComp<CPS::Real>>(mEMTPh3, "SSN_Capacitor",
738 py::multiple_inheritance())
739 .def(py::init<std::string>())
740 .def(py::init<std::string, CPS::Logger::Level>())
741 .def("set_parameters", &CPS::EMT::Ph3::SSN::Capacitor::setParameters,
742 "C"_a)
743 .def("connect", &CPS::EMT::Ph3::SSN::Capacitor::connect)
744 .def_property("C", createAttributeGetter<CPS::Matrix>("C"),
745 createAttributeSetter<CPS::Matrix>("C"));
746
747 py::class_<CPS::EMT::Ph3::GenericFourTerminalVTypeSSN,
748 std::shared_ptr<CPS::EMT::Ph3::GenericFourTerminalVTypeSSN>,
749 CPS::SimPowerComp<CPS::Real>>(
750 mEMTPh3, "GenericFourTerminalVTypeSSN", py::multiple_inheritance())
751 .def(py::init<std::string>())
752 .def(py::init<std::string, CPS::Logger::Level>())
753 .def("set_parameters",
754 &CPS::EMT::Ph3::GenericFourTerminalVTypeSSN::setParameters, "A"_a,
755 "B"_a, "C"_a, "D"_a)
756 .def("connect", &CPS::EMT::Ph3::GenericFourTerminalVTypeSSN::connect)
757 .def_property_readonly("x", createAttributeGetter<CPS::Matrix>("x"));
758}
addEMTPh1Components
void addEMTPh1Components(py::module_ mEMTPh1)
Definition EMTComponents.cpp:51
addEMTPh3Components
void addEMTPh3Components(py::module_ mEMTPh3)
Definition EMTComponents.cpp:195
addEMTComponents
void addEMTComponents(py::module_ mEMT)
Definition EMTComponents.cpp:25
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:44
CPS::Base::Ph1::Switch::setParameters
void setParameters(Real openResistance, Real closedResistance, Bool closed=false)
Definition Base_Ph1_Switch.h:36
CPS::Base::Ph1::Switch::open
void open()
Open switch.
Definition Base_Ph1_Switch.h:46
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
Dynamic Phasor Three-Phase Switch.
Definition Base_Ph3_Switch.h:17
CPS::Base::Ph3::Switch::setParameters
void setParameters(Matrix openResistance, Matrix closedResistance, Bool closed=false)
Definition Base_Ph3_Switch.h:35
CPS::Base::SynchronGenerator::setInitialValues
void setInitialValues(Real initActivePower, Real initReactivePower, Real initTerminalVolt, Real initVoltAngle, Real initMechPower)
Definition Base_SynchronGenerator.cpp:216
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::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_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:877
CPS::EMT::Ph3::SSN_GFM::getInterfaceCurrent
Matrix getInterfaceCurrent() const
Definition EMT_Ph3_SSN_GFM.cpp:887
CPS::EMT::Ph3::SSN_GFM::getInterfaceVoltage
Matrix getInterfaceVoltage() const
Definition EMT_Ph3_SSN_GFM.cpp:885
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:875
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::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:265
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