Core

Simulation, solvers, logging and the attribute system.

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 Attribute: Bases: pybind11_object

class AttributeComplex

Bases: Attribute

derive_imag(self: AttributeComplex) → AttributeReal

derive_mag(self: AttributeComplex) → AttributeReal

derive_phase(self: AttributeComplex) → AttributeReal

derive_real(self: AttributeComplex) → AttributeReal

derive_scaled(self: AttributeComplex, arg0: SupportsComplex | SupportsFloat | SupportsIndex) → AttributeComplex

get(self: AttributeComplex) → complex

set(self: AttributeComplex, arg0: SupportsComplex | SupportsFloat | SupportsIndex) → None

class AttributeComplexDyn

Bases: AttributeComplex

set_reference(self: AttributeComplexDyn, arg0: AttributeComplex) → None

class AttributeComplexStat: Bases: AttributeComplex

class AttributeMatrix

Bases: Attribute

derive_coeff(self: AttributeMatrix, arg0: SupportsInt | SupportsIndex, arg1: SupportsInt | SupportsIndex) → AttributeReal

get(self: AttributeMatrix) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']

set(self: AttributeMatrix, arg0: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, n]']) → None

class AttributeMatrixComp

Bases: Attribute

derive_coeff(self: AttributeMatrixComp, arg0: SupportsInt | SupportsIndex, arg1: SupportsInt | SupportsIndex) → AttributeComplex

get(self: AttributeMatrixComp) → Annotated[numpy.typing.NDArray[numpy.complex128], '[m, n]']

set(self: AttributeMatrixComp, arg0: Annotated[numpy.typing.ArrayLike, numpy.complex128, '[m, n]']) → None

class AttributeMatrixCompDyn

Bases: AttributeMatrixComp

set_reference(self: AttributeMatrixCompDyn, arg0: AttributeMatrixComp) → None

class AttributeMatrixCompStat: Bases: AttributeMatrixComp

class AttributeMatrixDyn

Bases: AttributeMatrix

set_reference(self: AttributeMatrixDyn, arg0: AttributeMatrix) → None

class AttributeMatrixStat: Bases: AttributeMatrix

class AttributeReal

Bases: Attribute

derive_scaled(self: AttributeReal, arg0: SupportsFloat | SupportsIndex) → AttributeReal

get(self: AttributeReal) → float

set(self: AttributeReal, arg0: SupportsFloat | SupportsIndex) → None

class AttributeRealDyn

Bases: AttributeReal

set_reference(self: AttributeRealDyn, arg0: AttributeReal) → None

class AttributeRealStat: Bases: AttributeReal

class AttributeString

Bases: Attribute

get(self: AttributeString) → str

set(self: AttributeString, arg0: str) → None

class AttributeStringDyn

Bases: AttributeString

set_reference(self: AttributeStringDyn, arg0: AttributeString) → None

class AttributeStringStat: Bases: AttributeString

class CIMReader

Bases: pybind11_object

loadCIM(self: CIMReader, arg0: SupportsFloat | SupportsIndex, arg1: collections.abc.Sequence[str], arg2: Domain, arg3: PhaseType, arg4: GeneratorType) → SystemTopology

set_extnet_voltage_target_unit(self: CIMReader, unit: CIMReaderVoltageTargetUnit) → None

class CIMReaderVoltageTargetUnit

Bases: pybind11_object

Members:

Auto

PerUnit

Absolute

Absolute = <CIMReaderVoltageTargetUnit.Absolute: 2>

Auto = <CIMReaderVoltageTargetUnit.Auto: 0>

PerUnit = <CIMReaderVoltageTargetUnit.PerUnit: 1>

CIMReaderVoltageTargetUnit.name -> str

property value

class CSVReader

Bases: pybind11_object

assignLoadProfile(self: CSVReader, arg0: SystemTopology, arg1: SupportsFloat | SupportsIndex, arg2: SupportsFloat | SupportsIndex, arg3: SupportsFloat | SupportsIndex, arg4: CSVReaderMode, arg5: CSVReaderFormat) → None

class CSVReaderFormat

Bases: pybind11_object

Members:

HHMMSS

SECONDS

HOURS

MINUTES

HHMMSS = <CSVReaderFormat.HHMMSS: 0>

HOURS = <CSVReaderFormat.HOURS: 2>

MINUTES = <CSVReaderFormat.MINUTES: 3>

SECONDS = <CSVReaderFormat.SECONDS: 1>

CSVReaderFormat.name -> str

property value

class CSVReaderMode

Bases: pybind11_object

Members:

AUTO

MANUAL

AUTO = <CSVReaderMode.AUTO: 0>

MANUAL = <CSVReaderMode.MANUAL: 1>

CSVReaderMode.name -> str

property value

class CouplingMethod

Bases: pybind11_object

Members:

DELAY

EXTRAPOLATION_ZOH

EXTRAPOLATION_LINEAR

DELAY = <CouplingMethod.DELAY: 0>

EXTRAPOLATION_LINEAR = <CouplingMethod.EXTRAPOLATION_LINEAR: 2>

EXTRAPOLATION_ZOH = <CouplingMethod.EXTRAPOLATION_ZOH: 1>

CouplingMethod.name -> str

property value

class DataLoggerInterface

Bases: pybind11_object

log_attribute(*args, **kwargs)

Overloaded function.

log_attribute(self: dpsimpy.DataLoggerInterface, name: str, attr: dpsimpy.Attribute, max_cols: typing.SupportsInt | typing.SupportsIndex = 0, max_rows: typing.SupportsInt | typing.SupportsIndex = 0) -> None
log_attribute(self: dpsimpy.DataLoggerInterface, names: collections.abc.Sequence[str], attr: dpsimpy.Attribute) -> None
log_attribute(self: dpsimpy.DataLoggerInterface, arg0: collections.abc.Sequence[str], arg1: str, arg2: CPS::IdentifiedObject) -> None

class DirectLinearSolverConfiguration

Bases: pybind11_object

get_btf(self: DirectLinearSolverConfiguration) → use_btf

get_fill_in_reduction_method(self: DirectLinearSolverConfiguration) → fill_in_reduction_method

get_partial_refactorization_method(self: DirectLinearSolverConfiguration) → partial_refactorization_method

get_scaling_method(self: DirectLinearSolverConfiguration) → scaling_method

set_btf(self: DirectLinearSolverConfiguration, arg0: use_btf) → None

set_fill_in_reduction_method(self: DirectLinearSolverConfiguration, arg0: fill_in_reduction_method) → None

set_partial_refactorization_method(self: DirectLinearSolverConfiguration, arg0: partial_refactorization_method) → None

set_scaling_method(self: DirectLinearSolverConfiguration, arg0: scaling_method) → None

class DirectLinearSolverImpl

Bases: pybind11_object

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>

DirectLinearSolverImpl.name -> str

property value

class Domain

Bases: pybind11_object

Members:

SP

DP

EMT

DP = <Domain.DP: 1>

EMT = <Domain.EMT: 2>

SP = <Domain.SP: 0>

Domain.name -> str

property value

class GeneratorType

Bases: pybind11_object

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>

GeneratorType.name -> str

property value

class IdentifiedObject

Bases: pybind11_object

attr(self: IdentifiedObject, name: str) → Attribute

name(self: IdentifiedObject) → str

print_attribute(self: IdentifiedObject, attribute_name: str) → None

print_attribute_list(self: IdentifiedObject) → None

class Interface: Bases: pybind11_object

class LogLevel

Bases: pybind11_object

Members:

trace

debug

info

warn

err

critical

off

critical = <LogLevel.critical: 5>

debug = <LogLevel.debug: 1>

err = <LogLevel.err: 4>

info = <LogLevel.info: 2>

LogLevel.name -> str

off = <LogLevel.off: 6>

trace = <LogLevel.trace: 0>

property value

warn = <LogLevel.warn: 3>

class Logger

Bases: DataLoggerInterface

static get_log_dir() → str

static set_log_dir(arg0: str) → None

log_attribute(*args, **kwargs)

Overloaded function.

log_attribute(self: dpsimpy.Logger, name: str, attr: dpsimpy.Attribute, max_cols: typing.SupportsInt | typing.SupportsIndex = 0, max_rows: typing.SupportsInt | typing.SupportsIndex = 0) -> None
log_attribute(self: dpsimpy.Logger, names: collections.abc.Sequence[str], attr: dpsimpy.Attribute) -> None
log_attribute(self: dpsimpy.Logger, name: str, attr: str, comp: CPS::IdentifiedObject, rows_max: typing.SupportsInt | typing.SupportsIndex = 0, cols_max: typing.SupportsInt | typing.SupportsIndex = 0) -> None
log_attribute(self: dpsimpy.Logger, arg0: collections.abc.Sequence[str], arg1: str, arg2: CPS::IdentifiedObject) -> None

class MNAStateSpaceExtractor

Bases: pybind11_object

get_discrete_state_matrix(self: MNAStateSpaceExtractor) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']

get_state_count(self: MNAStateSpaceExtractor) → int

get_time_step(self: MNAStateSpaceExtractor) → float

is_initialized(self: MNAStateSpaceExtractor) → bool

class Math

Bases: pybind11_object

static single_phase_parameter_to_three_phase(arg0: SupportsFloat | SupportsIndex) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']

static single_phase_power_to_three_phase(arg0: SupportsFloat | SupportsIndex) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']

static single_phase_variable_to_three_phase(arg0: SupportsComplex | SupportsFloat | SupportsIndex) → Annotated[numpy.typing.NDArray[numpy.complex128], '[m, n]']

class PhaseType

Bases: pybind11_object

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>

PhaseType.name -> str

property value

class PowerflowBusType

Bases: pybind11_object

Members:

PV

PQ

VD

None

None = <PowerflowBusType.None: 3>

PQ = <PowerflowBusType.PQ: 1>

PV = <PowerflowBusType.PV: 0>

VD = <PowerflowBusType.VD: 2>

PowerflowBusType.name -> str

property value

class RealTimeDataLogger

Bases: DataLoggerInterface

log_attribute(*args, **kwargs)

Overloaded function.

log_attribute(self: dpsimpy.RealTimeDataLogger, name: str, attr: dpsimpy.Attribute, max_cols: typing.SupportsInt | typing.SupportsIndex = 0, max_rows: typing.SupportsInt | typing.SupportsIndex = 0) -> None
log_attribute(self: dpsimpy.RealTimeDataLogger, names: collections.abc.Sequence[str], attr: dpsimpy.Attribute) -> None
log_attribute(self: dpsimpy.RealTimeDataLogger, name: str, attr: str, comp: CPS::IdentifiedObject, rows_max: typing.SupportsInt | typing.SupportsIndex = 0, cols_max: typing.SupportsInt | typing.SupportsIndex = 0) -> None
log_attribute(self: dpsimpy.RealTimeDataLogger, names: collections.abc.Sequence[str], attr: str, comp: CPS::IdentifiedObject) -> None

class RealTimeSimulation

Bases: Simulation

add_logger(self: RealTimeSimulation, arg0: DPsim::DataLoggerInterface) → None

name(self: RealTimeSimulation) → str

run(self: RealTimeSimulation, arg0: SupportsInt | SupportsIndex) → None

set_domain(self: RealTimeSimulation, arg0: Domain) → None

set_final_time(self: RealTimeSimulation, arg0: SupportsFloat | SupportsIndex) → None

set_solver(self: RealTimeSimulation, arg0: Solver) → None

set_system(self: RealTimeSimulation, arg0: CPS::SystemTopology) → None

set_time_step(self: RealTimeSimulation, arg0: SupportsFloat | SupportsIndex) → None

class SimPowerCompComplex

Bases: TopologicalPowerComp

connect(self: dpsimpy.SimPowerCompComplex, arg0: collections.abc.Sequence[CPS::SimNode<std::complex<double> >]) → None

get_terminal(self: SimPowerCompComplex, index: SupportsInt | SupportsIndex) → CPS::SimTerminal<std::complex<double> >

set_intf_current(self: SimPowerCompComplex, arg0: Annotated[numpy.typing.ArrayLike, numpy.complex128, '[m, n]']) → None

set_intf_voltage(self: SimPowerCompComplex, arg0: Annotated[numpy.typing.ArrayLike, numpy.complex128, '[m, n]']) → None

class SimPowerCompReal

Bases: TopologicalPowerComp

connect(self: dpsimpy.SimPowerCompReal, arg0: collections.abc.Sequence[CPS::SimNode<double>]) → None

get_terminal(self: SimPowerCompReal, index: SupportsInt | SupportsIndex) → CPS::SimTerminal<double>

set_intf_current(self: SimPowerCompReal, arg0: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, n]']) → None

set_intf_voltage(self: SimPowerCompReal, arg0: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, n]']) → None

class SimTerminalComplex: Bases: TopologicalTerminal

class SimTerminalReal: Bases: TopologicalTerminal

class Simulation

Bases: pybind11_object

add_event(self: Simulation, arg0: DPsim::Event) → None

add_interface(self: Simulation, interface: DPsim::Interface) → None

add_logger(self: Simulation, arg0: DPsim::DataLoggerInterface) → None

do_frequency_parallelization(self: Simulation, arg0: bool) → None

do_init_from_nodes_and_terminals(self: Simulation, arg0: bool) → None

do_split_subnets(self: Simulation, arg0: bool) → None

do_state_space_extraction(self: Simulation, value: bool = True) → None

do_steady_state_init(self: Simulation, arg0: bool) → None

do_system_matrix_recomputation(self: Simulation, arg0: bool) → None

get_idobj_attr(self: Simulation, comp: str, attr: str) → Attribute

get_pf_base_apparent_power_fallback(self: Simulation) → float

get_pf_keep_last_solution(self: Simulation) → bool

get_pf_max_iterations(self: Simulation) → int

get_pf_solver_base_voltage_loose_tolerance(self: Simulation) → float

get_pf_solver_base_voltage_strict_tolerance(self: Simulation) → float

get_pf_solver_enforce_q_limits(self: Simulation) → bool

get_pf_solver_use_sparse(self: Simulation) → bool

get_state_space_extractor(self: Simulation, solver_index: SupportsInt | SupportsIndex = 0) → MNAStateSpaceExtractor

log_attribute(self: Simulation, name: str, attr: Attribute) → None

log_idobj_attribute(self: Simulation, comp: str, attr: str) → None

log_lu_times(self: Simulation) → None

name(self: Simulation) → str

next(self: Simulation) → float

run(self: Simulation) → None

set_direct_linear_solver_configuration(self: Simulation, arg0: DirectLinearSolverConfiguration) → None

set_direct_solver_implementation(self: Simulation, arg0: DirectLinearSolverImpl) → None

set_domain(self: Simulation, arg0: Domain) → None

set_final_time(self: Simulation, arg0: SupportsFloat | SupportsIndex) → None

set_pf_base_apparent_power_fallback(self: Simulation, arg0: SupportsFloat | SupportsIndex) → None

set_pf_keep_last_solution(self: Simulation, arg0: bool) → None

set_pf_max_iterations(self: Simulation, arg0: SupportsInt | SupportsIndex) → None

set_pf_solver_base_voltage_loose_tolerance(self: Simulation, arg0: SupportsFloat | SupportsIndex) → None

set_pf_solver_base_voltage_strict_tolerance(self: Simulation, arg0: SupportsFloat | SupportsIndex) → None

set_pf_solver_enforce_q_limits(self: Simulation, arg0: bool) → None

set_pf_solver_use_sparse(self: Simulation, arg0: bool) → None

set_solver(self: Simulation, arg0: Solver) → None

set_solver_component_behaviour(self: Simulation, arg0: SolverBehaviour) → None

set_system(self: Simulation, arg0: CPS::SystemTopology) → None

set_system_matrix_recomputation_mode(self: Simulation, mode: SystemMatrixRecomputationMode) → None

set_tearing_components(self: Simulation, arg0: collections.abc.Sequence[CPS::IdentifiedObject]) → None

set_time_step(self: Simulation, arg0: SupportsFloat | SupportsIndex) → None

start(self: Simulation) → None

stop(self: Simulation) → None

class Solver

Bases: pybind11_object

Members:

MNA

DAE

NRP

DAE = <Solver.DAE: 1>

MNA = <Solver.MNA: 0>

NRP = <Solver.NRP: 2>

Solver.name -> str

property value

class SolverBehaviour

Bases: pybind11_object

Members:

Initialization

Simulation

Initialization = <SolverBehaviour.Initialization: 0>

Simulation = <SolverBehaviour.Simulation: 1>

SolverBehaviour.name -> str

property value

class StateSpaceAnalysisFrame

Bases: pybind11_object

Members:

Native

GlobalDQ0

GlobalDQ0 = <StateSpaceAnalysisFrame.GlobalDQ0: 1>

Native = <StateSpaceAnalysisFrame.Native: 0>

StateSpaceAnalysisFrame.name -> str

property value

class StateSpaceModalAnalysis

Bases: pybind11_object

get_continuous_eigenvalues(self: StateSpaceModalAnalysis) → Annotated[numpy.typing.NDArray[numpy.complex128], '[m, 1]']

get_discrete_eigenvalues(self: StateSpaceModalAnalysis) → Annotated[numpy.typing.NDArray[numpy.complex128], '[m, 1]']

get_left_eigenvectors(self: StateSpaceModalAnalysis) → Annotated[numpy.typing.NDArray[numpy.complex128], '[m, n]']

get_participation_factors(self: StateSpaceModalAnalysis) → Annotated[numpy.typing.NDArray[numpy.complex128], '[m, n]']

get_right_eigenvectors(self: StateSpaceModalAnalysis) → Annotated[numpy.typing.NDArray[numpy.complex128], '[m, n]']

get_state_names(self: StateSpaceModalAnalysis) → list[str]

set_analysis_frame(self: StateSpaceModalAnalysis, arg0: StateSpaceAnalysisFrame) → None

set_global_dq0_frame(self: StateSpaceModalAnalysis, omega: SupportsFloat | SupportsIndex, theta0: SupportsFloat | SupportsIndex = 0.0) → None

update(self: StateSpaceModalAnalysis) → None

class SystemMatrixRecomputationMode

Bases: pybind11_object

Members:

Auto

Enabled

Disabled

Auto = <SystemMatrixRecomputationMode.Auto: 0>

Disabled = <SystemMatrixRecomputationMode.Disabled: 2>

Enabled = <SystemMatrixRecomputationMode.Enabled: 1>

SystemMatrixRecomputationMode.name -> str

property value

class SystemTopology

Bases: pybind11_object

add(self: SystemTopology, arg0: object) → None: Deprecated alias for add_component and add_node.

add_component(*args, **kwargs)

Overloaded function.

add_component(self: dpsimpy.SystemTopology, arg0: CPS::IdentifiedObject) -> None
add_component(self: dpsimpy.SystemTopology, arg0: collections.abc.Sequence[CPS::IdentifiedObject]) -> None

add_components(self: SystemTopology, arg0: collections.abc.Sequence[CPS::IdentifiedObject]) → None

add_node(self: SystemTopology, arg0: CPS::TopologicalNode) → None

add_tear_component(self: SystemTopology, arg0: CPS::IdentifiedObject) → None

component(self: SystemTopology, arg0: str) → CPS::TopologicalPowerComp

connect_component(*args, **kwargs)

Overloaded function.

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

init_with_powerflow(self: SystemTopology, systemPF: SystemTopology, domain: Domain) → None

list_idobjects(self: SystemTopology) → dict[str, str]

node(*args, **kwargs)

Overloaded function.

node(self: dpsimpy.SystemTopology, arg0: str) -> CPS::TopologicalNode
node(self: dpsimpy.SystemTopology, arg0: typing.SupportsInt | typing.SupportsIndex) -> CPS::TopologicalNode

remove_component(self: SystemTopology, arg0: str) → None

render_to_file(self: SystemTopology, arg0: str) → None

property components

property components_at_node

property nodes

property tear_components

class TopologicalNode

Bases: IdentifiedObject

initial_single_voltage(self: TopologicalNode, phase_type: PhaseType = <PhaseType.Single: 4>) → complex

class TopologicalPowerComp: Bases: IdentifiedObject

class TopologicalTerminal

Bases: IdentifiedObject

set_power(*args, **kwargs)

Overloaded function.

set_power(self: dpsimpy.TopologicalTerminal, arg0: typing.SupportsComplex | typing.SupportsFloat | typing.SupportsIndex) -> None
set_power(self: dpsimpy.TopologicalTerminal, arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.complex128, “[m, n]”]) -> None

class fill_in_reduction_method

Bases: pybind11_object

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>

fill_in_reduction_method.name -> str

property value

class partial_refactorization_method

Bases: pybind11_object

Members:

no_partial_refactorization

factorization_path

refactorization_restart

factorization_path = <partial_refactorization_method.factorization_path: 1>

partial_refactorization_method.name -> str

no_partial_refactorization = <partial_refactorization_method.no_partial_refactorization: 0>

refactorization_restart = <partial_refactorization_method.refactorization_restart: 2>

property value

class scaling_method

Bases: pybind11_object

Members:

no_scaling

sum_scaling

max_scaling

max_scaling = <scaling_method.max_scaling: 2>

scaling_method.name -> str

no_scaling = <scaling_method.no_scaling: 0>

sum_scaling = <scaling_method.sum_scaling: 1>

property value

class use_btf

Bases: pybind11_object

Members:

no_btf

do_btf

do_btf = <use_btf.do_btf: 1>

use_btf.name -> str

no_btf = <use_btf.no_btf: 0>

property value

Base Models

base models

class MNASyncGenInterface

Bases: pybind11_object

set_max_iterations(self: MNASyncGenInterface, max_iter: SupportsInt | SupportsIndex) → None

set_tolerance(self: MNASyncGenInterface, tolerance: SupportsFloat | SupportsIndex) → None

class ReducedOrderSynchronGeneratorComplex

Bases: SimPowerCompComplex

add_exciter(*args, **kwargs)

Overloaded function.

add_exciter(self: dpsimpy.base.ReducedOrderSynchronGeneratorComplex, exciter: CPS::Base::Exciter, parameters: CPS::Base::ExciterParameters) -> None
add_exciter(self: dpsimpy.base.ReducedOrderSynchronGeneratorComplex, exciter: CPS::Base::Exciter) -> None
add_exciter(self: dpsimpy.base.ReducedOrderSynchronGeneratorComplex, Ta: typing.SupportsFloat | typing.SupportsIndex, Ka: typing.SupportsFloat | typing.SupportsIndex, Te: typing.SupportsFloat | typing.SupportsIndex, Ke: typing.SupportsFloat | typing.SupportsIndex, Tf: typing.SupportsFloat | typing.SupportsIndex, Kf: typing.SupportsFloat | typing.SupportsIndex, Tr: typing.SupportsFloat | typing.SupportsIndex) -> None

add_governor(*args, **kwargs)

Overloaded function.

add_governor(self: dpsimpy.base.ReducedOrderSynchronGeneratorComplex, governor: CPS::Signal::TurbineGovernorType1) -> None
add_governor(self: dpsimpy.base.ReducedOrderSynchronGeneratorComplex, T3: typing.SupportsFloat | typing.SupportsIndex, T4: typing.SupportsFloat | typing.SupportsIndex, T5: typing.SupportsFloat | typing.SupportsIndex, Tc: typing.SupportsFloat | typing.SupportsIndex, Ts: typing.SupportsFloat | typing.SupportsIndex, R: typing.SupportsFloat | typing.SupportsIndex, Pmin: typing.SupportsFloat | typing.SupportsIndex, Pmax: typing.SupportsFloat | typing.SupportsIndex, OmRef: typing.SupportsFloat | typing.SupportsIndex, TmRef: typing.SupportsFloat | typing.SupportsIndex) -> None

add_governor_and_turbine(*args, **kwargs)

Overloaded function.

add_governor_and_turbine(self: dpsimpy.base.ReducedOrderSynchronGeneratorComplex, governor: CPS::Base::Governor, gov_params: CPS::Base::GovernorParameters, turbine: CPS::Base::Turbine, turbine_params: CPS::Base::TurbineParameters) -> None
add_governor_and_turbine(self: dpsimpy.base.ReducedOrderSynchronGeneratorComplex, governor: CPS::Base::Governor, turbine: CPS::Base::Turbine) -> None

add_pss(*args, **kwargs)

Overloaded function.

add_pss(self: dpsimpy.base.ReducedOrderSynchronGeneratorComplex, pss: CPS::Base::PSS, parameters: CPS::Base::PSSParameters) -> None
add_pss(self: dpsimpy.base.ReducedOrderSynchronGeneratorComplex, pss: CPS::Base::PSS) -> None

scale_inertia_constant(self: ReducedOrderSynchronGeneratorComplex, scaling_factor: SupportsFloat | SupportsIndex) → None

set_base_parameters(self: ReducedOrderSynchronGeneratorComplex, nom_power: SupportsFloat | SupportsIndex, nom_voltage: SupportsFloat | SupportsIndex, nom_frequency: SupportsFloat | SupportsIndex) → None

set_initial_values(self: ReducedOrderSynchronGeneratorComplex, init_complex_electrical_power: SupportsComplex | SupportsFloat | SupportsIndex, init_mechanical_power: SupportsFloat | SupportsIndex, init_complex_terminal_voltage: SupportsComplex | SupportsFloat | SupportsIndex) → None

set_model_as_norton_source(self: ReducedOrderSynchronGeneratorComplex, model_as_norton_source: bool) → None

class ReducedOrderSynchronGeneratorReal

Bases: SimPowerCompReal

add_exciter(*args, **kwargs)

Overloaded function.

add_exciter(self: dpsimpy.base.ReducedOrderSynchronGeneratorReal, exciter: CPS::Base::Exciter, parameters: CPS::Base::ExciterParameters) -> None
add_exciter(self: dpsimpy.base.ReducedOrderSynchronGeneratorReal, exciter: CPS::Base::Exciter) -> None
add_exciter(self: dpsimpy.base.ReducedOrderSynchronGeneratorReal, Ta: typing.SupportsFloat | typing.SupportsIndex, Ka: typing.SupportsFloat | typing.SupportsIndex, Te: typing.SupportsFloat | typing.SupportsIndex, Ke: typing.SupportsFloat | typing.SupportsIndex, Tf: typing.SupportsFloat | typing.SupportsIndex, Kf: typing.SupportsFloat | typing.SupportsIndex, Tr: typing.SupportsFloat | typing.SupportsIndex) -> None

add_governor(*args, **kwargs)

Overloaded function.

add_governor(self: dpsimpy.base.ReducedOrderSynchronGeneratorReal, governor: CPS::Signal::TurbineGovernorType1) -> None
add_governor(self: dpsimpy.base.ReducedOrderSynchronGeneratorReal, T3: typing.SupportsFloat | typing.SupportsIndex, T4: typing.SupportsFloat | typing.SupportsIndex, T5: typing.SupportsFloat | typing.SupportsIndex, Tc: typing.SupportsFloat | typing.SupportsIndex, Ts: typing.SupportsFloat | typing.SupportsIndex, R: typing.SupportsFloat | typing.SupportsIndex, Pmin: typing.SupportsFloat | typing.SupportsIndex, Pmax: typing.SupportsFloat | typing.SupportsIndex, OmRef: typing.SupportsFloat | typing.SupportsIndex, TmRef: typing.SupportsFloat | typing.SupportsIndex) -> None

add_governor_and_turbine(*args, **kwargs)

Overloaded function.

add_governor_and_turbine(self: dpsimpy.base.ReducedOrderSynchronGeneratorReal, governor: CPS::Base::Governor, gov_params: CPS::Base::GovernorParameters, turbine: CPS::Base::Turbine, turbine_params: CPS::Base::TurbineParameters) -> None
add_governor_and_turbine(self: dpsimpy.base.ReducedOrderSynchronGeneratorReal, governor: CPS::Base::Governor, turbine: CPS::Base::Turbine) -> None

add_pss(*args, **kwargs)

Overloaded function.

add_pss(self: dpsimpy.base.ReducedOrderSynchronGeneratorReal, pss: CPS::Base::PSS, parameters: CPS::Base::PSSParameters) -> None
add_pss(self: dpsimpy.base.ReducedOrderSynchronGeneratorReal, pss: CPS::Base::PSS) -> None

scale_inertia_constant(self: ReducedOrderSynchronGeneratorReal, scaling_factor: SupportsFloat | SupportsIndex) → None

set_base_parameters(self: ReducedOrderSynchronGeneratorReal, nom_power: SupportsFloat | SupportsIndex, nom_voltage: SupportsFloat | SupportsIndex, nom_frequency: SupportsFloat | SupportsIndex) → None

set_initial_values(self: ReducedOrderSynchronGeneratorReal, init_complex_electrical_power: SupportsComplex | SupportsFloat | SupportsIndex, init_mechanical_power: SupportsFloat | SupportsIndex, init_complex_terminal_voltage: SupportsComplex | SupportsFloat | SupportsIndex) → None

set_model_as_norton_source(self: ReducedOrderSynchronGeneratorReal, model_as_norton_source: bool) → None

class Switch: Bases: pybind11_object

class SwitchPh3: Bases: pybind11_object

Events

events

class Event: Bases: pybind11_object

class SwitchEvent: Bases: Event

class SwitchEvent3Ph: Bases: Event