Reference

DPsim Python bindings

The Python bindings provide access to most of the DPsim features implemented in C++. It is possible to run powerflow, quasi-static, dynamic phasor and electromagnetic transient simulations and to parameterize all components of the network from Python.

class dpsimpy.Attribute
class dpsimpy.AttributeComplex
derive_imag(self: dpsimpy.AttributeComplex) → dpsimpy.AttributeReal
derive_mag(self: dpsimpy.AttributeComplex) → dpsimpy.AttributeReal
derive_phase(self: dpsimpy.AttributeComplex) → dpsimpy.AttributeReal
derive_real(self: dpsimpy.AttributeComplex) → dpsimpy.AttributeReal
derive_scaled(self: dpsimpy.AttributeComplex, arg0: complex) → dpsimpy.AttributeComplex
get(self: dpsimpy.AttributeComplex) → complex
set(self: dpsimpy.AttributeComplex, arg0: complex) → None
class dpsimpy.AttributeComplexDyn
set_reference(self: dpsimpy.AttributeComplexDyn, arg0: dpsimpy.AttributeComplex) → None
class dpsimpy.AttributeComplexStat
class dpsimpy.AttributeMatrix
derive_coeff(self: dpsimpy.AttributeMatrix, arg0: int, arg1: int) → dpsimpy.AttributeReal
get(self: dpsimpy.AttributeMatrix) → numpy.ndarray[numpy.float64[m, n]]
set(self: dpsimpy.AttributeMatrix, arg0: numpy.ndarray[numpy.float64[m, n]]) → None
class dpsimpy.AttributeMatrixComp
derive_coeff(self: dpsimpy.AttributeMatrixComp, arg0: int, arg1: int) → dpsimpy.AttributeComplex
get(self: dpsimpy.AttributeMatrixComp) → numpy.ndarray[numpy.complex128[m, n]]
set(self: dpsimpy.AttributeMatrixComp, arg0: numpy.ndarray[numpy.complex128[m, n]]) → None
class dpsimpy.AttributeMatrixCompDyn
set_reference(self: dpsimpy.AttributeMatrixCompDyn, arg0: dpsimpy.AttributeMatrixComp) → None
class dpsimpy.AttributeMatrixCompStat
class dpsimpy.AttributeMatrixDyn
set_reference(self: dpsimpy.AttributeMatrixDyn, arg0: dpsimpy.AttributeMatrix) → None
class dpsimpy.AttributeMatrixStat
class dpsimpy.AttributeReal
derive_scaled(self: dpsimpy.AttributeReal, arg0: float) → dpsimpy.AttributeReal
get(self: dpsimpy.AttributeReal) → float
set(self: dpsimpy.AttributeReal, arg0: float) → None
class dpsimpy.AttributeRealDyn
set_reference(self: dpsimpy.AttributeRealDyn, arg0: dpsimpy.AttributeReal) → None
class dpsimpy.AttributeRealStat
class dpsimpy.AttributeString
get(self: dpsimpy.AttributeString) → str
set(self: dpsimpy.AttributeString, arg0: str) → None
class dpsimpy.AttributeStringDyn
set_reference(self: dpsimpy.AttributeStringDyn, arg0: dpsimpy.AttributeString) → None
class dpsimpy.AttributeStringStat
class dpsimpy.CIMReader
loadCIM(self: dpsimpy.CIMReader, arg0: float, arg1: List[str], arg2: dpsimpy.Domain, arg3: dpsimpy.PhaseType, arg4: dpsimpy.GeneratorType) → dpsimpy.SystemTopology
class dpsimpy.CSVReader
assignLoadProfile(self: dpsimpy.CSVReader, arg0: dpsimpy.SystemTopology, arg1: float, arg2: float, arg3: float, arg4: dpsimpy.CSVReaderMode, arg5: dpsimpy.CSVReaderFormat) → None
class dpsimpy.CSVReaderFormat

Members:

HHMMSS

SECONDS

HOURS

MINUTES

HHMMSS = <CSVReaderFormat.HHMMSS: 0>
HOURS = <CSVReaderFormat.HOURS: 2>
MINUTES = <CSVReaderFormat.MINUTES: 3>
SECONDS = <CSVReaderFormat.SECONDS: 1>
property name
property value
class dpsimpy.CSVReaderMode

Members:

AUTO

MANUAL

AUTO = <CSVReaderMode.AUTO: 0>
MANUAL = <CSVReaderMode.MANUAL: 1>
property name
property value
class dpsimpy.DirectLinearSolverConfiguration
get_btf(self: dpsimpy.DirectLinearSolverConfiguration) → dpsimpy.use_btf
get_fill_in_reduction_method(self: dpsimpy.DirectLinearSolverConfiguration) → dpsimpy.fill_in_reduction_method
get_partial_refactorization_method(self: dpsimpy.DirectLinearSolverConfiguration) → dpsimpy.partial_refactorization_method
get_scaling_method(self: dpsimpy.DirectLinearSolverConfiguration) → dpsimpy.scaling_method
set_btf(self: dpsimpy.DirectLinearSolverConfiguration, arg0: dpsimpy.use_btf) → None
set_fill_in_reduction_method(self: dpsimpy.DirectLinearSolverConfiguration, arg0: dpsimpy.fill_in_reduction_method) → None
set_partial_refactorization_method(self: dpsimpy.DirectLinearSolverConfiguration, arg0: dpsimpy.partial_refactorization_method) → None
set_scaling_method(self: dpsimpy.DirectLinearSolverConfiguration, arg0: dpsimpy.scaling_method) → None
class dpsimpy.DirectLinearSolverImpl

Members:

Undef

DenseLU

SparseLU

KLU

CUDADense

CUDASparse

CUDAMagma

CUDADense = <DirectLinearSolverImpl.CUDADense: 4>
CUDAMagma = <DirectLinearSolverImpl.CUDAMagma: 6>
CUDASparse = <DirectLinearSolverImpl.CUDASparse: 5>
DenseLU = <DirectLinearSolverImpl.DenseLU: 3>
KLU = <DirectLinearSolverImpl.KLU: 1>
SparseLU = <DirectLinearSolverImpl.SparseLU: 2>
Undef = <DirectLinearSolverImpl.Undef: 0>
property name
property value
class dpsimpy.Domain

Members:

SP

DP

EMT

DP = <Domain.DP: 1>
EMT = <Domain.EMT: 2>
SP = <Domain.SP: 0>
property name
property value
class dpsimpy.GeneratorType

Members:

PVNode

TransientStability

IdealVoltageSource

SG3OrderVBR

SG4OrderVBR

SG5OrderVBR

SG6aOrderVBR

SG6bOrderVBR

FullOrderVBR

FullOrder

NONE

FullOrder = <GeneratorType.FullOrder: 4>
FullOrderVBR = <GeneratorType.FullOrderVBR: 5>
IdealVoltageSource = <GeneratorType.IdealVoltageSource: 1>
NONE = <GeneratorType.NONE: 14>
PVNode = <GeneratorType.PVNode: 0>
SG3OrderVBR = <GeneratorType.SG3OrderVBR: 10>
SG4OrderVBR = <GeneratorType.SG4OrderVBR: 9>
SG5OrderVBR = <GeneratorType.SG5OrderVBR: 8>
SG6aOrderVBR = <GeneratorType.SG6aOrderVBR: 6>
SG6bOrderVBR = <GeneratorType.SG6bOrderVBR: 7>
TransientStability = <GeneratorType.TransientStability: 3>
property name
property value
class dpsimpy.IdentifiedObject
attr(self: dpsimpy.IdentifiedObject, name: str) → dpsimpy.Attribute
name(self: dpsimpy.IdentifiedObject) → str
print_attribute(self: dpsimpy.IdentifiedObject, attribute_name: str) → None
print_attribute_list(self: dpsimpy.IdentifiedObject) → None
class dpsimpy.Interface
class dpsimpy.LogLevel

Members:

trace

debug

info

warn

err

critical

off

critical = <LogLevel.critical: 5>
debug = <LogLevel.debug: 1>
err = <LogLevel.err: 4>
info = <LogLevel.info: 2>
property name
off = <LogLevel.off: 6>
trace = <LogLevel.trace: 0>
property value
warn = <LogLevel.warn: 3>
class dpsimpy.Logger
static get_log_dir() → str
log_attribute(*args, **kwargs)

Overloaded function.

  1. log_attribute(self: dpsimpy.Logger, name: str, attr: dpsimpy.Attribute, max_cols: int = 0, max_rows: int = 0) -> None

  2. log_attribute(self: dpsimpy.Logger, names: List[str], attr: dpsimpy.Attribute) -> None

  3. log_attribute(self: dpsimpy.Logger, name: str, attr: str, comp: CPS::IdentifiedObject, rows_max: int = 0, cols_max: int = 0) -> None

  4. log_attribute(self: dpsimpy.Logger, arg0: List[str], arg1: str, arg2: CPS::IdentifiedObject) -> None

static set_log_dir(arg0: str) → None
class dpsimpy.Math
static single_phase_parameter_to_three_phase(arg0: float) → numpy.ndarray[numpy.float64[m, n]]
static single_phase_power_to_three_phase(arg0: float) → numpy.ndarray[numpy.float64[m, n]]
static single_phase_variable_to_three_phase(arg0: complex) → numpy.ndarray[numpy.complex128[m, n]]
class dpsimpy.PhaseType

Members:

A

B

C

ABC

Single

A = <PhaseType.A: 0>
ABC = <PhaseType.ABC: 3>
B = <PhaseType.B: 1>
C = <PhaseType.C: 2>
Single = <PhaseType.Single: 4>
property name
property value
class dpsimpy.PowerflowBusType

Members:

PV

PQ

VD

None

None = <PowerflowBusType.None: 3>
PQ = <PowerflowBusType.PQ: 1>
PV = <PowerflowBusType.PV: 0>
VD = <PowerflowBusType.VD: 2>
property name
property value
class dpsimpy.RealTimeSimulation
add_logger(self: dpsimpy.RealTimeSimulation, arg0: DPsim::DataLogger) → None
name(self: dpsimpy.RealTimeSimulation) → str
run(self: dpsimpy.RealTimeSimulation, arg0: int) → None
set_domain(self: dpsimpy.RealTimeSimulation, arg0: dpsimpy.Domain) → None
set_final_time(self: dpsimpy.RealTimeSimulation, arg0: float) → None
set_solver(self: dpsimpy.RealTimeSimulation, arg0: dpsimpy.Solver) → None
set_system(self: dpsimpy.RealTimeSimulation, arg0: CPS::SystemTopology) → None
set_time_step(self: dpsimpy.RealTimeSimulation, arg0: float) → None
class dpsimpy.SimPowerCompComplex
connect(self: dpsimpy.SimPowerCompComplex, arg0: List[CPS::SimNode<std::complex<double> >]) → None
get_terminal(self: dpsimpy.SimPowerCompComplex, index: int) → CPS::SimTerminal<std::complex<double> >
set_intf_current(self: dpsimpy.SimPowerCompComplex, arg0: numpy.ndarray[numpy.complex128[m, n]]) → None
set_intf_voltage(self: dpsimpy.SimPowerCompComplex, arg0: numpy.ndarray[numpy.complex128[m, n]]) → None
class dpsimpy.SimPowerCompReal
connect(self: dpsimpy.SimPowerCompReal, arg0: List[CPS::SimNode<double>]) → None
get_terminal(self: dpsimpy.SimPowerCompReal, index: int) → CPS::SimTerminal<double>
set_intf_current(self: dpsimpy.SimPowerCompReal, arg0: numpy.ndarray[numpy.float64[m, n]]) → None
set_intf_voltage(self: dpsimpy.SimPowerCompReal, arg0: numpy.ndarray[numpy.float64[m, n]]) → None
class dpsimpy.SimTerminalComplex
class dpsimpy.SimTerminalReal
class dpsimpy.Simulation
add_event(self: dpsimpy.Simulation, arg0: DPsim::Event) → None
add_interface(self: dpsimpy.Simulation, interface: DPsim::Interface) → None
add_logger(self: dpsimpy.Simulation, arg0: DPsim::DataLogger) → None
do_frequency_parallelization(self: dpsimpy.Simulation, arg0: bool) → None
do_init_from_nodes_and_terminals(self: dpsimpy.Simulation, arg0: bool) → None
do_steady_state_init(self: dpsimpy.Simulation, arg0: bool) → None
do_system_matrix_recomputation(self: dpsimpy.Simulation, arg0: bool) → None
get_idobj_attr(self: dpsimpy.Simulation, comp: str, attr: str) → dpsimpy.Attribute
log_attribute(self: dpsimpy.Simulation, name: str, attr: dpsimpy.Attribute) → None
log_idobj_attribute(self: dpsimpy.Simulation, comp: str, attr: str) → None
log_lu_times(self: dpsimpy.Simulation) → None
name(self: dpsimpy.Simulation) → str
next(self: dpsimpy.Simulation) → float
run(self: dpsimpy.Simulation) → None
set_direct_linear_solver_configuration(self: dpsimpy.Simulation, arg0: dpsimpy.DirectLinearSolverConfiguration) → None
set_direct_solver_implementation(self: dpsimpy.Simulation, arg0: dpsimpy.DirectLinearSolverImpl) → None
set_domain(self: dpsimpy.Simulation, arg0: dpsimpy.Domain) → None
set_final_time(self: dpsimpy.Simulation, arg0: float) → None
set_solver(self: dpsimpy.Simulation, arg0: dpsimpy.Solver) → None
set_solver_component_behaviour(self: dpsimpy.Simulation, arg0: dpsimpy.SolverBehaviour) → None
set_system(self: dpsimpy.Simulation, arg0: CPS::SystemTopology) → None
set_tearing_components(self: dpsimpy.Simulation, arg0: List[CPS::IdentifiedObject]) → None
set_time_step(self: dpsimpy.Simulation, arg0: float) → None
start(self: dpsimpy.Simulation) → None
stop(self: dpsimpy.Simulation) → None
class dpsimpy.Solver

Members:

MNA

DAE

NRP

DAE = <Solver.DAE: 1>
MNA = <Solver.MNA: 0>
NRP = <Solver.NRP: 2>
property name
property value
class dpsimpy.SolverBehaviour

Members:

Initialization

Simulation

Initialization = <SolverBehaviour.Initialization: 0>
Simulation = <SolverBehaviour.Simulation: 1>
property name
property value
class dpsimpy.SystemTopology
add(*args, **kwargs)

Overloaded function.

  1. add(self: dpsimpy.SystemTopology, arg0: CPS::IdentifiedObject) -> None

  2. add(self: dpsimpy.SystemTopology, arg0: List[CPS::IdentifiedObject]) -> None

add_tear_component(self: dpsimpy.SystemTopology, arg0: CPS::IdentifiedObject) → None
component(self: dpsimpy.SystemTopology, arg0: str) → CPS::TopologicalPowerComp
property components
property components_at_node
connect_component(*args, **kwargs)

Overloaded function.

  1. connect_component(self: dpsimpy.SystemTopology, arg0: CPS::SimPowerComp<double>, arg1: List[CPS::SimNode<double>]) -> None

  2. connect_component(self: dpsimpy.SystemTopology, arg0: CPS::SimPowerComp<std::complex<double> >, arg1: List[CPS::SimNode<std::complex<double> >]) -> None

init_with_powerflow(self: dpsimpy.SystemTopology, systemPF: dpsimpy.SystemTopology, domain: dpsimpy.Domain) → None
list_idobjects(self: dpsimpy.SystemTopology) → Dict[str, str]
node(*args, **kwargs)

Overloaded function.

  1. node(self: dpsimpy.SystemTopology, arg0: str) -> CPS::TopologicalNode

  2. node(self: dpsimpy.SystemTopology, arg0: int) -> CPS::TopologicalNode

property nodes
render_to_file(self: dpsimpy.SystemTopology, arg0: str) → None
property tear_components
class dpsimpy.TopologicalNode
initial_single_voltage(self: dpsimpy.TopologicalNode, phase_type: dpsimpy.PhaseType = <PhaseType.Single: 4>) → complex
class dpsimpy.TopologicalPowerComp
class dpsimpy.TopologicalTerminal
set_power(*args, **kwargs)

Overloaded function.

  1. set_power(self: dpsimpy.TopologicalTerminal, arg0: complex) -> None

  2. set_power(self: dpsimpy.TopologicalTerminal, arg0: numpy.ndarray[numpy.complex128[m, n]]) -> None

class dpsimpy.fill_in_reduction_method

Members:

amd

amd_nv

amd_ra

colamd

amd = <fill_in_reduction_method.amd: 0>
amd_nv = <fill_in_reduction_method.amd_nv: 1>
amd_ra = <fill_in_reduction_method.amd_ra: 2>
colamd = <fill_in_reduction_method.colamd: 3>
property name
property value
class dpsimpy.partial_refactorization_method

Members:

no_partial_refactorization

factorization_path

refactorization_restart

factorization_path = <partial_refactorization_method.factorization_path: 1>
property name
no_partial_refactorization = <partial_refactorization_method.no_partial_refactorization: 0>
refactorization_restart = <partial_refactorization_method.refactorization_restart: 2>
property value
class dpsimpy.scaling_method

Members:

no_scaling

sum_scaling

max_scaling

max_scaling = <scaling_method.max_scaling: 2>
property name
no_scaling = <scaling_method.no_scaling: 0>
sum_scaling = <scaling_method.sum_scaling: 1>
property value
class dpsimpy.use_btf

Members:

no_btf

do_btf

do_btf = <use_btf.do_btf: 1>
property name
no_btf = <use_btf.no_btf: 0>
property value

Dynamic Phasor / SFA Models

dynamic phasor models

class dpsimpy.dp.SimNode
gnd = <dpsimpy.dp.SimNode object>
set_initial_voltage(*args, **kwargs)

Overloaded function.

  1. set_initial_voltage(self: dpsimpy.dp.SimNode, arg0: numpy.ndarray[numpy.complex128[m, n]]) -> None

  2. set_initial_voltage(self: dpsimpy.dp.SimNode, arg0: complex) -> None

  3. set_initial_voltage(self: dpsimpy.dp.SimNode, arg0: complex, arg1: int) -> None

single_voltage(self: dpsimpy.dp.SimNode, phase_type: dpsimpy.PhaseType = <PhaseType.Single: 4>) → complex

single phase dynamic phasor models

class dpsimpy.dp.ph1.AvVoltageSourceInverterDQ
connect(self: dpsimpy.dp.ph1.AvVoltageSourceInverterDQ, arg0: List[dpsimpy.dp.SimNode]) → None
set_controller_parameters(self: dpsimpy.dp.ph1.AvVoltageSourceInverterDQ, Kp_pll: float, Ki_pll: float, Kp_power_ctrl: float, Ki_power_ctrl: float, Kp_curr_ctrl: float, Ki_curr_ctrl: float, omega_cutoff: float) → None
set_filter_parameters(self: dpsimpy.dp.ph1.AvVoltageSourceInverterDQ, Lf: float, Cf: float, Rf: float, Rc: float) → None
set_initial_state_values(self: dpsimpy.dp.ph1.AvVoltageSourceInverterDQ, p_init: float, q_init: float, phi_d_init: float, phi_q_init: float, gamma_d_init: float, gamma_q_init: float) → None
set_parameters(self: dpsimpy.dp.ph1.AvVoltageSourceInverterDQ, sys_omega: float, sys_volt_nom: float, p_ref: float, q_ref: float) → None
set_transformer_parameters(self: dpsimpy.dp.ph1.AvVoltageSourceInverterDQ, nom_voltage_end_1: float, nom_voltage_end_2: float, rated_power: float, ratio_abs: float, ratio_phase: float, resistance: float, inductance: float) → None
with_control(self: dpsimpy.dp.ph1.AvVoltageSourceInverterDQ, arg0: bool) → None
class dpsimpy.dp.ph1.Capacitor
property C
connect(self: dpsimpy.dp.ph1.Capacitor, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.Capacitor, C: float) → None
class dpsimpy.dp.ph1.CurrentSource
property I_ref
connect(self: dpsimpy.dp.ph1.CurrentSource, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.CurrentSource, I_ref: complex) → None
class dpsimpy.dp.ph1.Inductor
property L
connect(self: dpsimpy.dp.ph1.Inductor, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.Inductor, L: float) → None
class dpsimpy.dp.ph1.Inverter
connect(self: dpsimpy.dp.ph1.Inverter, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.Inverter, carrier_harms: List[int], modul_harms: List[int], input_voltage: float, ratio: float, phase: float) → None
class dpsimpy.dp.ph1.NetworkInjection
connect(self: dpsimpy.dp.ph1.NetworkInjection, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.NetworkInjection, V_ref: complex, f_src: float = 0) → None
class dpsimpy.dp.ph1.PiLine
connect(self: dpsimpy.dp.ph1.PiLine, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.PiLine, series_resistance: float, series_inductance: float, parallel_capacitance: float = 0, parallel_conductance: float = 0) → None
class dpsimpy.dp.ph1.RXLoad
connect(self: dpsimpy.dp.ph1.RXLoad, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.RXLoad, active_power: float, reactive_power: float, volt: float) → None
class dpsimpy.dp.ph1.ReducedOrderSynchronGeneratorVBR
class dpsimpy.dp.ph1.Resistor
property R
connect(self: dpsimpy.dp.ph1.Resistor, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.Resistor, R: float) → None
class dpsimpy.dp.ph1.Switch
close(self: dpsimpy.dp.ph1.Switch) → None
connect(self: dpsimpy.dp.ph1.Switch, arg0: List[dpsimpy.dp.SimNode]) → None
open(self: dpsimpy.dp.ph1.Switch) → None
set_parameters(self: dpsimpy.dp.ph1.Switch, open_resistance: float, closed_resistance: float, closed: bool = False) → None
class dpsimpy.dp.ph1.SynchronGenerator3OrderVBR
connect(self: dpsimpy.dp.ph1.SynchronGenerator3OrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator3OrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Td0_t: float) → None
class dpsimpy.dp.ph1.SynchronGenerator4OrderPCM
connect(self: dpsimpy.dp.ph1.SynchronGenerator4OrderPCM, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator4OrderPCM, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float) → None
class dpsimpy.dp.ph1.SynchronGenerator4OrderTPM
connect(self: dpsimpy.dp.ph1.SynchronGenerator4OrderTPM, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator4OrderTPM, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float) → None
class dpsimpy.dp.ph1.SynchronGenerator4OrderVBR
connect(self: dpsimpy.dp.ph1.SynchronGenerator4OrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator4OrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float) → None
class dpsimpy.dp.ph1.SynchronGenerator5OrderVBR
connect(self: dpsimpy.dp.ph1.SynchronGenerator5OrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator5OrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float, Ld_s: float, Lq_s: float, Td0_s: float, Tq0_s: float, Taa: float) → None
class dpsimpy.dp.ph1.SynchronGenerator6OrderPCM
connect(self: dpsimpy.dp.ph1.SynchronGenerator6OrderPCM, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator6OrderPCM, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float, Ld_s: float, Lq_s: float, Td0_s: float, Tq0_s: float, Taa: float = 0) → None
class dpsimpy.dp.ph1.SynchronGenerator6aOrderVBR
connect(self: dpsimpy.dp.ph1.SynchronGenerator6aOrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator6aOrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float, Ld_s: float, Lq_s: float, Td0_s: float, Tq0_s: float, Taa: float) → None
class dpsimpy.dp.ph1.SynchronGenerator6bOrderVBR
connect(self: dpsimpy.dp.ph1.SynchronGenerator6bOrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator6bOrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float, Ld_s: float, Lq_s: float, Td0_s: float, Tq0_s: float, Taa: float = 0) → None
class dpsimpy.dp.ph1.SynchronGeneratorTrStab
connect(self: dpsimpy.dp.ph1.SynchronGeneratorTrStab, arg0: List[dpsimpy.dp.SimNode]) → None
set_fundamental_parameters_PU(self: dpsimpy.dp.ph1.SynchronGeneratorTrStab, nom_power: float, nom_volt: float, nom_freq: float, Ll: float, Lmd: float, Llfd: float, H: float, D: float = 0) → None
set_initial_values(self: dpsimpy.dp.ph1.SynchronGeneratorTrStab, elec_power: complex, mech_power: float) → None
set_model_flags(self: dpsimpy.dp.ph1.SynchronGeneratorTrStab, convert_with_omega_mech: bool) → None
set_reference_omega(self: dpsimpy.dp.ph1.SynchronGeneratorTrStab, ref_omega_name: str = 'w_r', ref_omage_comp: dpsimpy.IdentifiedObject, ref_delta_name: str = 'delta_r', ref_delta_comp: dpsimpy.IdentifiedObject) → None
set_standard_parameters_PU(self: dpsimpy.dp.ph1.SynchronGeneratorTrStab, nom_power: float, nom_volt: float, nom_freq: float, Xpd: float, inertia: float, Rs: float = 0, D: float = 0) → None
class dpsimpy.dp.ph1.Transformer
connect(self: dpsimpy.dp.ph1.Transformer, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(*args, **kwargs)

Overloaded function.

  1. set_parameters(self: dpsimpy.dp.ph1.Transformer, nom_voltage_end_1: float, nom_voltage_end_2: float, ratio_abs: float, ratio_phase: float, resistance: float, inductance: float) -> None

  2. set_parameters(self: dpsimpy.dp.ph1.Transformer, nom_voltage_end_1: float, nom_voltage_end_2: float, rated_power: float, ratio_abs: float, ratio_phase: float, resistance: float, inductance: float) -> None

class dpsimpy.dp.ph1.VoltageSource
property V_ref
connect(self: dpsimpy.dp.ph1.VoltageSource, arg0: List[dpsimpy.dp.SimNode]) → None
property f_src
set_parameters(self: dpsimpy.dp.ph1.VoltageSource, V_ref: complex, f_src: float = 0) → None
class dpsimpy.dp.ph1.VoltageSourceNorton
connect(self: dpsimpy.dp.ph1.VoltageSourceNorton, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.VoltageSourceNorton, V_ref: complex, f_src: float = -1) → None
class dpsimpy.dp.ph1.varResSwitch
close(self: dpsimpy.dp.ph1.varResSwitch) → None
connect(self: dpsimpy.dp.ph1.varResSwitch, arg0: List[dpsimpy.dp.SimNode]) → None
open(self: dpsimpy.dp.ph1.varResSwitch) → None
set_init_parameters(self: dpsimpy.dp.ph1.varResSwitch, time_step: float) → None
set_parameters(self: dpsimpy.dp.ph1.varResSwitch, open_resistance: float, closed_resistance: float, closed: bool = False) → None

single phase dynamic phasor models

class dpsimpy.dp.ph1.AvVoltageSourceInverterDQ
connect(self: dpsimpy.dp.ph1.AvVoltageSourceInverterDQ, arg0: List[dpsimpy.dp.SimNode]) → None
set_controller_parameters(self: dpsimpy.dp.ph1.AvVoltageSourceInverterDQ, Kp_pll: float, Ki_pll: float, Kp_power_ctrl: float, Ki_power_ctrl: float, Kp_curr_ctrl: float, Ki_curr_ctrl: float, omega_cutoff: float) → None
set_filter_parameters(self: dpsimpy.dp.ph1.AvVoltageSourceInverterDQ, Lf: float, Cf: float, Rf: float, Rc: float) → None
set_initial_state_values(self: dpsimpy.dp.ph1.AvVoltageSourceInverterDQ, p_init: float, q_init: float, phi_d_init: float, phi_q_init: float, gamma_d_init: float, gamma_q_init: float) → None
set_parameters(self: dpsimpy.dp.ph1.AvVoltageSourceInverterDQ, sys_omega: float, sys_volt_nom: float, p_ref: float, q_ref: float) → None
set_transformer_parameters(self: dpsimpy.dp.ph1.AvVoltageSourceInverterDQ, nom_voltage_end_1: float, nom_voltage_end_2: float, rated_power: float, ratio_abs: float, ratio_phase: float, resistance: float, inductance: float) → None
with_control(self: dpsimpy.dp.ph1.AvVoltageSourceInverterDQ, arg0: bool) → None
class dpsimpy.dp.ph1.Capacitor
property C
connect(self: dpsimpy.dp.ph1.Capacitor, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.Capacitor, C: float) → None
class dpsimpy.dp.ph1.CurrentSource
property I_ref
connect(self: dpsimpy.dp.ph1.CurrentSource, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.CurrentSource, I_ref: complex) → None
class dpsimpy.dp.ph1.Inductor
property L
connect(self: dpsimpy.dp.ph1.Inductor, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.Inductor, L: float) → None
class dpsimpy.dp.ph1.Inverter
connect(self: dpsimpy.dp.ph1.Inverter, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.Inverter, carrier_harms: List[int], modul_harms: List[int], input_voltage: float, ratio: float, phase: float) → None
class dpsimpy.dp.ph1.NetworkInjection
connect(self: dpsimpy.dp.ph1.NetworkInjection, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.NetworkInjection, V_ref: complex, f_src: float = 0) → None
class dpsimpy.dp.ph1.PiLine
connect(self: dpsimpy.dp.ph1.PiLine, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.PiLine, series_resistance: float, series_inductance: float, parallel_capacitance: float = 0, parallel_conductance: float = 0) → None
class dpsimpy.dp.ph1.RXLoad
connect(self: dpsimpy.dp.ph1.RXLoad, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.RXLoad, active_power: float, reactive_power: float, volt: float) → None
class dpsimpy.dp.ph1.ReducedOrderSynchronGeneratorVBR
class dpsimpy.dp.ph1.Resistor
property R
connect(self: dpsimpy.dp.ph1.Resistor, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.Resistor, R: float) → None
class dpsimpy.dp.ph1.Switch
close(self: dpsimpy.dp.ph1.Switch) → None
connect(self: dpsimpy.dp.ph1.Switch, arg0: List[dpsimpy.dp.SimNode]) → None
open(self: dpsimpy.dp.ph1.Switch) → None
set_parameters(self: dpsimpy.dp.ph1.Switch, open_resistance: float, closed_resistance: float, closed: bool = False) → None
class dpsimpy.dp.ph1.SynchronGenerator3OrderVBR
connect(self: dpsimpy.dp.ph1.SynchronGenerator3OrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator3OrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Td0_t: float) → None
class dpsimpy.dp.ph1.SynchronGenerator4OrderPCM
connect(self: dpsimpy.dp.ph1.SynchronGenerator4OrderPCM, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator4OrderPCM, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float) → None
class dpsimpy.dp.ph1.SynchronGenerator4OrderTPM
connect(self: dpsimpy.dp.ph1.SynchronGenerator4OrderTPM, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator4OrderTPM, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float) → None
class dpsimpy.dp.ph1.SynchronGenerator4OrderVBR
connect(self: dpsimpy.dp.ph1.SynchronGenerator4OrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator4OrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float) → None
class dpsimpy.dp.ph1.SynchronGenerator5OrderVBR
connect(self: dpsimpy.dp.ph1.SynchronGenerator5OrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator5OrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float, Ld_s: float, Lq_s: float, Td0_s: float, Tq0_s: float, Taa: float) → None
class dpsimpy.dp.ph1.SynchronGenerator6OrderPCM
connect(self: dpsimpy.dp.ph1.SynchronGenerator6OrderPCM, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator6OrderPCM, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float, Ld_s: float, Lq_s: float, Td0_s: float, Tq0_s: float, Taa: float = 0) → None
class dpsimpy.dp.ph1.SynchronGenerator6aOrderVBR
connect(self: dpsimpy.dp.ph1.SynchronGenerator6aOrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator6aOrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float, Ld_s: float, Lq_s: float, Td0_s: float, Tq0_s: float, Taa: float) → None
class dpsimpy.dp.ph1.SynchronGenerator6bOrderVBR
connect(self: dpsimpy.dp.ph1.SynchronGenerator6bOrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.dp.ph1.SynchronGenerator6bOrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float, Ld_s: float, Lq_s: float, Td0_s: float, Tq0_s: float, Taa: float = 0) → None
class dpsimpy.dp.ph1.SynchronGeneratorTrStab
connect(self: dpsimpy.dp.ph1.SynchronGeneratorTrStab, arg0: List[dpsimpy.dp.SimNode]) → None
set_fundamental_parameters_PU(self: dpsimpy.dp.ph1.SynchronGeneratorTrStab, nom_power: float, nom_volt: float, nom_freq: float, Ll: float, Lmd: float, Llfd: float, H: float, D: float = 0) → None
set_initial_values(self: dpsimpy.dp.ph1.SynchronGeneratorTrStab, elec_power: complex, mech_power: float) → None
set_model_flags(self: dpsimpy.dp.ph1.SynchronGeneratorTrStab, convert_with_omega_mech: bool) → None
set_reference_omega(self: dpsimpy.dp.ph1.SynchronGeneratorTrStab, ref_omega_name: str = 'w_r', ref_omage_comp: dpsimpy.IdentifiedObject, ref_delta_name: str = 'delta_r', ref_delta_comp: dpsimpy.IdentifiedObject) → None
set_standard_parameters_PU(self: dpsimpy.dp.ph1.SynchronGeneratorTrStab, nom_power: float, nom_volt: float, nom_freq: float, Xpd: float, inertia: float, Rs: float = 0, D: float = 0) → None
class dpsimpy.dp.ph1.Transformer
connect(self: dpsimpy.dp.ph1.Transformer, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(*args, **kwargs)

Overloaded function.

  1. set_parameters(self: dpsimpy.dp.ph1.Transformer, nom_voltage_end_1: float, nom_voltage_end_2: float, ratio_abs: float, ratio_phase: float, resistance: float, inductance: float) -> None

  2. set_parameters(self: dpsimpy.dp.ph1.Transformer, nom_voltage_end_1: float, nom_voltage_end_2: float, rated_power: float, ratio_abs: float, ratio_phase: float, resistance: float, inductance: float) -> None

class dpsimpy.dp.ph1.VoltageSource
property V_ref
connect(self: dpsimpy.dp.ph1.VoltageSource, arg0: List[dpsimpy.dp.SimNode]) → None
property f_src
set_parameters(self: dpsimpy.dp.ph1.VoltageSource, V_ref: complex, f_src: float = 0) → None
class dpsimpy.dp.ph1.VoltageSourceNorton
connect(self: dpsimpy.dp.ph1.VoltageSourceNorton, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.dp.ph1.VoltageSourceNorton, V_ref: complex, f_src: float = -1) → None
class dpsimpy.dp.ph1.varResSwitch
close(self: dpsimpy.dp.ph1.varResSwitch) → None
connect(self: dpsimpy.dp.ph1.varResSwitch, arg0: List[dpsimpy.dp.SimNode]) → None
open(self: dpsimpy.dp.ph1.varResSwitch) → None
set_init_parameters(self: dpsimpy.dp.ph1.varResSwitch, time_step: float) → None
set_parameters(self: dpsimpy.dp.ph1.varResSwitch, open_resistance: float, closed_resistance: float, closed: bool = False) → None

Electromagnetic Transient Models

electromagnetic-transient models

class dpsimpy.emt.SimNode
gnd = <dpsimpy.emt.SimNode object>
set_initial_voltage(*args, **kwargs)

Overloaded function.

  1. set_initial_voltage(self: dpsimpy.emt.SimNode, arg0: numpy.ndarray[numpy.complex128[m, n]]) -> None

  2. set_initial_voltage(self: dpsimpy.emt.SimNode, arg0: complex) -> None

  3. set_initial_voltage(self: dpsimpy.emt.SimNode, arg0: complex, arg1: int) -> None

single phase electromagnetic-transient models

class dpsimpy.emt.ph1.Capacitor
property C
connect(self: dpsimpy.emt.ph1.Capacitor, arg0: List[dpsimpy.emt.SimNode]) → None
set_parameters(self: dpsimpy.emt.ph1.Capacitor, C: float) → None
class dpsimpy.emt.ph1.CurrentSource
property I_ref
connect(self: dpsimpy.emt.ph1.CurrentSource, arg0: List[dpsimpy.emt.SimNode]) → None
property f_src
set_parameters(self: dpsimpy.emt.ph1.CurrentSource, I_ref: complex, f_src: float = -1) → None
class dpsimpy.emt.ph1.Inductor
property L
connect(self: dpsimpy.emt.ph1.Inductor, arg0: List[dpsimpy.emt.SimNode]) → None
set_parameters(self: dpsimpy.emt.ph1.Inductor, L: float) → None
class dpsimpy.emt.ph1.Resistor
property R
connect(self: dpsimpy.emt.ph1.Resistor, arg0: List[dpsimpy.emt.SimNode]) → None
set_parameters(self: dpsimpy.emt.ph1.Resistor, R: float) → None
class dpsimpy.emt.ph1.VoltageSource
property V_ref
connect(self: dpsimpy.emt.ph1.VoltageSource, arg0: List[dpsimpy.emt.SimNode]) → None
property f_src
set_parameters(self: dpsimpy.emt.ph1.VoltageSource, V_ref: complex, f_src: float = -1) → None

single phase electromagnetic-transient models

class dpsimpy.emt.ph1.Capacitor
property C
connect(self: dpsimpy.emt.ph1.Capacitor, arg0: List[dpsimpy.emt.SimNode]) → None
set_parameters(self: dpsimpy.emt.ph1.Capacitor, C: float) → None
class dpsimpy.emt.ph1.CurrentSource
property I_ref
connect(self: dpsimpy.emt.ph1.CurrentSource, arg0: List[dpsimpy.emt.SimNode]) → None
property f_src
set_parameters(self: dpsimpy.emt.ph1.CurrentSource, I_ref: complex, f_src: float = -1) → None
class dpsimpy.emt.ph1.Inductor
property L
connect(self: dpsimpy.emt.ph1.Inductor, arg0: List[dpsimpy.emt.SimNode]) → None
set_parameters(self: dpsimpy.emt.ph1.Inductor, L: float) → None
class dpsimpy.emt.ph1.Resistor
property R
connect(self: dpsimpy.emt.ph1.Resistor, arg0: List[dpsimpy.emt.SimNode]) → None
set_parameters(self: dpsimpy.emt.ph1.Resistor, R: float) → None
class dpsimpy.emt.ph1.VoltageSource
property V_ref
connect(self: dpsimpy.emt.ph1.VoltageSource, arg0: List[dpsimpy.emt.SimNode]) → None
property f_src
set_parameters(self: dpsimpy.emt.ph1.VoltageSource, V_ref: complex, f_src: float = -1) → None

(Quasi) Static / RMS Models

static phasor models

single phase static phasor models

class dpsimpy.sp.ph1.AvVoltageSourceInverterDQ
connect(self: dpsimpy.sp.ph1.AvVoltageSourceInverterDQ, arg0: List[dpsimpy.dp.SimNode]) → None
set_controller_parameters(self: dpsimpy.sp.ph1.AvVoltageSourceInverterDQ, Kp_pll: float, Ki_pll: float, Kp_power_ctrl: float, Ki_power_ctrl: float, Kp_curr_ctrl: float, Ki_curr_ctrl: float, omega_cutoff: float) → None
set_filter_parameters(self: dpsimpy.sp.ph1.AvVoltageSourceInverterDQ, Lf: float, Cf: float, Rf: float, Rc: float) → None
set_initial_state_values(self: dpsimpy.sp.ph1.AvVoltageSourceInverterDQ, p_init: float, q_init: float, phi_d_init: float, phi_q_init: float, gamma_d_init: float, gamma_q_init: float) → None
set_parameters(self: dpsimpy.sp.ph1.AvVoltageSourceInverterDQ, sys_omega: float, sys_volt_nom: float, p_ref: float, q_ref: float) → None
set_transformer_parameters(self: dpsimpy.sp.ph1.AvVoltageSourceInverterDQ, nom_voltage_end_1: float, nom_voltage_end_2: float, rated_power: float, ratio_abs: float, ratio_phase: float, resistance: float, inductance: float) → None
with_control(self: dpsimpy.sp.ph1.AvVoltageSourceInverterDQ, arg0: bool) → None
class dpsimpy.sp.ph1.Capacitor
property C
connect(self: dpsimpy.sp.ph1.Capacitor, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.sp.ph1.Capacitor, C: float) → None
class dpsimpy.sp.ph1.Inductor
property L
connect(self: dpsimpy.sp.ph1.Inductor, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.sp.ph1.Inductor, L: float) → None
class dpsimpy.sp.ph1.Load
connect(self: dpsimpy.sp.ph1.Load, arg0: List[dpsimpy.dp.SimNode]) → None
modify_power_flow_bus_type(self: dpsimpy.sp.ph1.Load, bus_type: dpsimpy.PowerflowBusType) → None
set_parameters(self: dpsimpy.sp.ph1.Load, active_power: float, reactive_power: float, nominal_voltage: float) → None
class dpsimpy.sp.ph1.NetworkInjection
connect(self: dpsimpy.sp.ph1.NetworkInjection, arg0: List[dpsimpy.dp.SimNode]) → None
modify_power_flow_bus_type(self: dpsimpy.sp.ph1.NetworkInjection, bus_type: dpsimpy.PowerflowBusType) → None
set_base_voltage(self: dpsimpy.sp.ph1.NetworkInjection, base_voltage: float) → None
set_parameters(*args, **kwargs)

Overloaded function.

  1. set_parameters(self: dpsimpy.sp.ph1.NetworkInjection, voltage_set_point: float) -> None

  2. set_parameters(self: dpsimpy.sp.ph1.NetworkInjection, V_ref: complex, f_src: float = 0) -> None

class dpsimpy.sp.ph1.PiLine
connect(self: dpsimpy.sp.ph1.PiLine, arg0: List[dpsimpy.dp.SimNode]) → None
set_base_voltage(self: dpsimpy.sp.ph1.PiLine, base_voltage: float) → None
set_parameters(self: dpsimpy.sp.ph1.PiLine, R: float, L: float, C: float = -1, G: float = -1) → None
class dpsimpy.sp.ph1.ReducedOrderSynchronGeneratorVBR
class dpsimpy.sp.ph1.Resistor
property R
connect(self: dpsimpy.sp.ph1.Resistor, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.sp.ph1.Resistor, R: float) → None
class dpsimpy.sp.ph1.Shunt
connect(self: dpsimpy.sp.ph1.Shunt, arg0: List[dpsimpy.dp.SimNode]) → None
set_base_voltage(self: dpsimpy.sp.ph1.Shunt, base_voltage: float) → None
set_parameters(self: dpsimpy.sp.ph1.Shunt, G: float, B: float) → None
class dpsimpy.sp.ph1.Switch
close(self: dpsimpy.sp.ph1.Switch) → None
connect(self: dpsimpy.sp.ph1.Switch, arg0: List[dpsimpy.dp.SimNode]) → None
open(self: dpsimpy.sp.ph1.Switch) → None
set_parameters(self: dpsimpy.sp.ph1.Switch, open_resistance: float, closed_resistance: float, closed: bool = False) → None
class dpsimpy.sp.ph1.SynchronGenerator
connect(self: dpsimpy.sp.ph1.SynchronGenerator, arg0: List[dpsimpy.dp.SimNode]) → None
get_apparent_power(self: dpsimpy.sp.ph1.SynchronGenerator) → complex
modify_power_flow_bus_type(self: dpsimpy.sp.ph1.SynchronGenerator, bus_type: dpsimpy.PowerflowBusType) → None
set_base_voltage(self: dpsimpy.sp.ph1.SynchronGenerator, base_voltage: float) → None
set_parameters(self: dpsimpy.sp.ph1.SynchronGenerator, rated_apparent_power: float, rated_voltage: float, set_point_active_power: float, set_point_voltage: float, powerflow_bus_type: dpsimpy.PowerflowBusType, set_point_reactive_power: float = 0) → None
class dpsimpy.sp.ph1.SynchronGenerator3OrderVBR
connect(self: dpsimpy.sp.ph1.SynchronGenerator3OrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.sp.ph1.SynchronGenerator3OrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Td0_t: float) → None
class dpsimpy.sp.ph1.SynchronGenerator4OrderVBR
connect(self: dpsimpy.sp.ph1.SynchronGenerator4OrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.sp.ph1.SynchronGenerator4OrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float) → None
class dpsimpy.sp.ph1.SynchronGenerator5OrderVBR
connect(self: dpsimpy.sp.ph1.SynchronGenerator5OrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.sp.ph1.SynchronGenerator5OrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float, Ld_s: float, Lq_s: float, Td0_s: float, Tq0_s: float, Taa: float) → None
class dpsimpy.sp.ph1.SynchronGenerator6aOrderVBR
connect(self: dpsimpy.sp.ph1.SynchronGenerator6aOrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.sp.ph1.SynchronGenerator6aOrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float, Ld_s: float, Lq_s: float, Td0_s: float, Tq0_s: float, Taa: float) → None
class dpsimpy.sp.ph1.SynchronGenerator6bOrderVBR
connect(self: dpsimpy.sp.ph1.SynchronGenerator6bOrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.sp.ph1.SynchronGenerator6bOrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float, Ld_s: float, Lq_s: float, Td0_s: float, Tq0_s: float, Taa: float = 0) → None
class dpsimpy.sp.ph1.SynchronGeneratorTrStab
connect(self: dpsimpy.sp.ph1.SynchronGeneratorTrStab, arg0: List[dpsimpy.dp.SimNode]) → None
set_initial_values(self: dpsimpy.sp.ph1.SynchronGeneratorTrStab, elec_power: complex, mech_power: float) → None
set_model_flags(self: dpsimpy.sp.ph1.SynchronGeneratorTrStab, convert_with_omega_mech: bool) → None
set_reference_omega(self: dpsimpy.sp.ph1.SynchronGeneratorTrStab, ref_omega_name: str = 'w_r', ref_omage_comp: dpsimpy.IdentifiedObject, ref_delta_name: str = 'delta_r', ref_delta_comp: dpsimpy.IdentifiedObject) → None
set_standard_parameters_PU(self: dpsimpy.sp.ph1.SynchronGeneratorTrStab, nom_power: float, nom_volt: float, nom_freq: float, Xpd: float, inertia: float, Rs: float = 0, D: float = 0) → None
class dpsimpy.sp.ph1.Transformer
connect(self: dpsimpy.sp.ph1.Transformer, arg0: List[dpsimpy.dp.SimNode]) → None
set_base_voltage(self: dpsimpy.sp.ph1.Transformer, base_voltage: float) → None
set_parameters(*args, **kwargs)

Overloaded function.

  1. set_parameters(self: dpsimpy.sp.ph1.Transformer, nom_voltage_end_1: float, nom_voltage_end_2: float, ratio_abs: float, ratio_phase: float, resistance: float, inductance: float) -> None

  2. set_parameters(self: dpsimpy.sp.ph1.Transformer, nom_voltage_end_1: float, nom_voltage_end_2: float, rated_power: float, ratio_abs: float, ratio_phase: float, resistance: float, inductance: float) -> None

class dpsimpy.sp.ph1.VoltageSource
property V_ref
connect(self: dpsimpy.sp.ph1.VoltageSource, arg0: List[dpsimpy.dp.SimNode]) → None
property f_src
set_parameters(self: dpsimpy.sp.ph1.VoltageSource, V_ref: complex, f_src: float = 0) → None
class dpsimpy.sp.ph1.varResSwitch
close(self: dpsimpy.sp.ph1.varResSwitch) → None
connect(self: dpsimpy.sp.ph1.varResSwitch, arg0: List[dpsimpy.dp.SimNode]) → None
open(self: dpsimpy.sp.ph1.varResSwitch) → None
set_init_parameters(self: dpsimpy.sp.ph1.varResSwitch, time_step: float) → None
set_parameters(self: dpsimpy.sp.ph1.varResSwitch, open_resistance: float, closed_resistance: float, closed: bool = False) → None

single phase static phasor models

class dpsimpy.sp.ph1.AvVoltageSourceInverterDQ
connect(self: dpsimpy.sp.ph1.AvVoltageSourceInverterDQ, arg0: List[dpsimpy.dp.SimNode]) → None
set_controller_parameters(self: dpsimpy.sp.ph1.AvVoltageSourceInverterDQ, Kp_pll: float, Ki_pll: float, Kp_power_ctrl: float, Ki_power_ctrl: float, Kp_curr_ctrl: float, Ki_curr_ctrl: float, omega_cutoff: float) → None
set_filter_parameters(self: dpsimpy.sp.ph1.AvVoltageSourceInverterDQ, Lf: float, Cf: float, Rf: float, Rc: float) → None
set_initial_state_values(self: dpsimpy.sp.ph1.AvVoltageSourceInverterDQ, p_init: float, q_init: float, phi_d_init: float, phi_q_init: float, gamma_d_init: float, gamma_q_init: float) → None
set_parameters(self: dpsimpy.sp.ph1.AvVoltageSourceInverterDQ, sys_omega: float, sys_volt_nom: float, p_ref: float, q_ref: float) → None
set_transformer_parameters(self: dpsimpy.sp.ph1.AvVoltageSourceInverterDQ, nom_voltage_end_1: float, nom_voltage_end_2: float, rated_power: float, ratio_abs: float, ratio_phase: float, resistance: float, inductance: float) → None
with_control(self: dpsimpy.sp.ph1.AvVoltageSourceInverterDQ, arg0: bool) → None
class dpsimpy.sp.ph1.Capacitor
property C
connect(self: dpsimpy.sp.ph1.Capacitor, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.sp.ph1.Capacitor, C: float) → None
class dpsimpy.sp.ph1.Inductor
property L
connect(self: dpsimpy.sp.ph1.Inductor, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.sp.ph1.Inductor, L: float) → None
class dpsimpy.sp.ph1.Load
connect(self: dpsimpy.sp.ph1.Load, arg0: List[dpsimpy.dp.SimNode]) → None
modify_power_flow_bus_type(self: dpsimpy.sp.ph1.Load, bus_type: dpsimpy.PowerflowBusType) → None
set_parameters(self: dpsimpy.sp.ph1.Load, active_power: float, reactive_power: float, nominal_voltage: float) → None
class dpsimpy.sp.ph1.NetworkInjection
connect(self: dpsimpy.sp.ph1.NetworkInjection, arg0: List[dpsimpy.dp.SimNode]) → None
modify_power_flow_bus_type(self: dpsimpy.sp.ph1.NetworkInjection, bus_type: dpsimpy.PowerflowBusType) → None
set_base_voltage(self: dpsimpy.sp.ph1.NetworkInjection, base_voltage: float) → None
set_parameters(*args, **kwargs)

Overloaded function.

  1. set_parameters(self: dpsimpy.sp.ph1.NetworkInjection, voltage_set_point: float) -> None

  2. set_parameters(self: dpsimpy.sp.ph1.NetworkInjection, V_ref: complex, f_src: float = 0) -> None

class dpsimpy.sp.ph1.PiLine
connect(self: dpsimpy.sp.ph1.PiLine, arg0: List[dpsimpy.dp.SimNode]) → None
set_base_voltage(self: dpsimpy.sp.ph1.PiLine, base_voltage: float) → None
set_parameters(self: dpsimpy.sp.ph1.PiLine, R: float, L: float, C: float = -1, G: float = -1) → None
class dpsimpy.sp.ph1.ReducedOrderSynchronGeneratorVBR
class dpsimpy.sp.ph1.Resistor
property R
connect(self: dpsimpy.sp.ph1.Resistor, arg0: List[dpsimpy.dp.SimNode]) → None
set_parameters(self: dpsimpy.sp.ph1.Resistor, R: float) → None
class dpsimpy.sp.ph1.Shunt
connect(self: dpsimpy.sp.ph1.Shunt, arg0: List[dpsimpy.dp.SimNode]) → None
set_base_voltage(self: dpsimpy.sp.ph1.Shunt, base_voltage: float) → None
set_parameters(self: dpsimpy.sp.ph1.Shunt, G: float, B: float) → None
class dpsimpy.sp.ph1.Switch
close(self: dpsimpy.sp.ph1.Switch) → None
connect(self: dpsimpy.sp.ph1.Switch, arg0: List[dpsimpy.dp.SimNode]) → None
open(self: dpsimpy.sp.ph1.Switch) → None
set_parameters(self: dpsimpy.sp.ph1.Switch, open_resistance: float, closed_resistance: float, closed: bool = False) → None
class dpsimpy.sp.ph1.SynchronGenerator
connect(self: dpsimpy.sp.ph1.SynchronGenerator, arg0: List[dpsimpy.dp.SimNode]) → None
get_apparent_power(self: dpsimpy.sp.ph1.SynchronGenerator) → complex
modify_power_flow_bus_type(self: dpsimpy.sp.ph1.SynchronGenerator, bus_type: dpsimpy.PowerflowBusType) → None
set_base_voltage(self: dpsimpy.sp.ph1.SynchronGenerator, base_voltage: float) → None
set_parameters(self: dpsimpy.sp.ph1.SynchronGenerator, rated_apparent_power: float, rated_voltage: float, set_point_active_power: float, set_point_voltage: float, powerflow_bus_type: dpsimpy.PowerflowBusType, set_point_reactive_power: float = 0) → None
class dpsimpy.sp.ph1.SynchronGenerator3OrderVBR
connect(self: dpsimpy.sp.ph1.SynchronGenerator3OrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.sp.ph1.SynchronGenerator3OrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Td0_t: float) → None
class dpsimpy.sp.ph1.SynchronGenerator4OrderVBR
connect(self: dpsimpy.sp.ph1.SynchronGenerator4OrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.sp.ph1.SynchronGenerator4OrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float) → None
class dpsimpy.sp.ph1.SynchronGenerator5OrderVBR
connect(self: dpsimpy.sp.ph1.SynchronGenerator5OrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.sp.ph1.SynchronGenerator5OrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float, Ld_s: float, Lq_s: float, Td0_s: float, Tq0_s: float, Taa: float) → None
class dpsimpy.sp.ph1.SynchronGenerator6aOrderVBR
connect(self: dpsimpy.sp.ph1.SynchronGenerator6aOrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.sp.ph1.SynchronGenerator6aOrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float, Ld_s: float, Lq_s: float, Td0_s: float, Tq0_s: float, Taa: float) → None
class dpsimpy.sp.ph1.SynchronGenerator6bOrderVBR
connect(self: dpsimpy.sp.ph1.SynchronGenerator6bOrderVBR, arg0: List[dpsimpy.dp.SimNode]) → None
set_operational_parameters_per_unit(self: dpsimpy.sp.ph1.SynchronGenerator6bOrderVBR, nom_power: float, nom_voltage: float, nom_frequency: float, H: float, Ld: float, Lq: float, L0: float, Ld_t: float, Lq_t: float, Td0_t: float, Tq0_t: float, Ld_s: float, Lq_s: float, Td0_s: float, Tq0_s: float, Taa: float = 0) → None
class dpsimpy.sp.ph1.SynchronGeneratorTrStab
connect(self: dpsimpy.sp.ph1.SynchronGeneratorTrStab, arg0: List[dpsimpy.dp.SimNode]) → None
set_initial_values(self: dpsimpy.sp.ph1.SynchronGeneratorTrStab, elec_power: complex, mech_power: float) → None
set_model_flags(self: dpsimpy.sp.ph1.SynchronGeneratorTrStab, convert_with_omega_mech: bool) → None
set_reference_omega(self: dpsimpy.sp.ph1.SynchronGeneratorTrStab, ref_omega_name: str = 'w_r', ref_omage_comp: dpsimpy.IdentifiedObject, ref_delta_name: str = 'delta_r', ref_delta_comp: dpsimpy.IdentifiedObject) → None
set_standard_parameters_PU(self: dpsimpy.sp.ph1.SynchronGeneratorTrStab, nom_power: float, nom_volt: float, nom_freq: float, Xpd: float, inertia: float, Rs: float = 0, D: float = 0) → None
class dpsimpy.sp.ph1.Transformer
connect(self: dpsimpy.sp.ph1.Transformer, arg0: List[dpsimpy.dp.SimNode]) → None
set_base_voltage(self: dpsimpy.sp.ph1.Transformer, base_voltage: float) → None
set_parameters(*args, **kwargs)

Overloaded function.

  1. set_parameters(self: dpsimpy.sp.ph1.Transformer, nom_voltage_end_1: float, nom_voltage_end_2: float, ratio_abs: float, ratio_phase: float, resistance: float, inductance: float) -> None

  2. set_parameters(self: dpsimpy.sp.ph1.Transformer, nom_voltage_end_1: float, nom_voltage_end_2: float, rated_power: float, ratio_abs: float, ratio_phase: float, resistance: float, inductance: float) -> None

class dpsimpy.sp.ph1.VoltageSource
property V_ref
connect(self: dpsimpy.sp.ph1.VoltageSource, arg0: List[dpsimpy.dp.SimNode]) → None
property f_src
set_parameters(self: dpsimpy.sp.ph1.VoltageSource, V_ref: complex, f_src: float = 0) → None
class dpsimpy.sp.ph1.varResSwitch
close(self: dpsimpy.sp.ph1.varResSwitch) → None
connect(self: dpsimpy.sp.ph1.varResSwitch, arg0: List[dpsimpy.dp.SimNode]) → None
open(self: dpsimpy.sp.ph1.varResSwitch) → None
set_init_parameters(self: dpsimpy.sp.ph1.varResSwitch, time_step: float) → None
set_parameters(self: dpsimpy.sp.ph1.varResSwitch, open_resistance: float, closed_resistance: float, closed: bool = False) → None