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