roseau.load_flow.converters¶

This module provides helper functions to convert from one representation to another.

Available functions:

convert between phasor and symmetrical components
convert potentials to voltages

Attributes¶

`ALPHA`	Phasor rotation operator alpha, which rotates a phasor vector counterclockwise by 120
`A`	"A" matrix: transformation matrix from phasor to symmetrical components.

Functions¶

`phasor_to_sym`(→ roseau.load_flow.typing.ComplexArray)	Compute the symmetrical components (0, +, -) from the phasor components (a, b, c).
`sym_to_phasor`(→ roseau.load_flow.typing.ComplexArray)	Compute the phasor components (a, b, c) from the symmetrical components (0, +, -).
`series_phasor_to_sym`(→ pandas.Series)	Compute the symmetrical components (0, +, -) from the phasor components (a, b, c) of a series.
`calculate_voltages`(...)	Calculate the voltages between phases given the potentials of each phase.
`calculate_voltage_phases`(→ list[str])	Calculate the composite phases of the voltages given the phases of an element.

Module Contents¶

ALPHA¶

Phasor rotation operator alpha, which rotates a phasor vector counterclockwise by 120 degrees when multiplied by it.

Type:: complex

A¶

“A” matrix: transformation matrix from phasor to symmetrical components.

Type:: ndarray[complex]

phasor_to_sym(v_abc: Sequence[complex]) → ComplexArray¶: Compute the symmetrical components (0, +, -) from the phasor components (a, b, c).

sym_to_phasor(v_012: Sequence[complex]) → ComplexArray¶: Compute the phasor components (a, b, c) from the symmetrical components (0, +, -).

series_phasor_to_sym(s_abc: Series) → Series¶

Compute the symmetrical components (0, +, -) from the phasor components (a, b, c) of a series.

Parameters:: s_abc – Series of phasor components (voltage, current, …). The series must have a multi-index with a ‘phase’ level containing the phases in order (a -> b -> c).
Returns:: Series of the symmetrical components representing the input phasor series. The series has a multi-index with the phase level replaced by a ‘sequence’ level of values (‘zero’, ‘pos’, ‘neg’).

Example

Say we have a pandas series of three-phase voltages of every bus in the network:

>>> voltage
bus_id  phase
vs      an       200000000000.0+0.00000000j
        bn      -10000.000000-17320.508076j
        cn      -10000.000000+17320.508076j
bus     an       19999.00000095+0.00000000j
        bn       -9999.975000-17320.464775j
        cn       -9999.975000+17320.464775j
Name: voltage, dtype: complex128

We can get the zero, positive, and negative sequences of the voltage using:

>>> voltage_sym_components = series_phasor_to_sym(voltage)
>>> voltage_sym_components
bus_id  sequence
bus     zero        3.183231e-12-9.094947e-13j
        pos         1.999995e+04+3.283594e-12j
        neg        -1.796870e-07-2.728484e-12j
vs      zero        5.002221e-12-9.094947e-13j
        pos         2.000000e+04+3.283596e-12j
        neg        -1.796880e-07-1.818989e-12j
Name: voltage, dtype: complex128

We can now access each sequence of the symmetrical components individually:

>>> voltage_sym_components.loc[:, "zero"]  # get zero sequence values
bus_id
bus     3.183231e-12-9.094947e-13j
vs      5.002221e-12-9.094947e-13j
Name: voltage, dtype: complex128

calculate_voltages(potentials: ComplexArrayLike1D, phases: str) → Q_[ComplexArray]¶

Calculate the voltages between phases given the potentials of each phase.

Parameters:

potentials – Array of the complex potentials of each phase.
phases – String of the phases in order. If a neutral exists, it must be the last.

Returns:

Array of the voltages between phases. If a neutral exists, the voltages are Phase-Neutral. Otherwise, the voltages are Phase-Phase.

Example

>>> potentials = 230 * np.array([1, np.exp(-2j * np.pi / 3), np.exp(2j * np.pi / 3), 0], dtype=np.complex128)
>>> calculate_voltages(potentials, "abcn")
array([ 230.  +0.j        , -115.-199.18584287j, -115.+199.18584287j]) <Unit('volt')>
>>> potentials = np.array([230, 230 * np.exp(-2j * np.pi / 3)], dtype=np.complex128)
>>> calculate_voltages(potentials, "ab")
array([345.+199.18584287j]) <Unit('volt')>
>>> calculate_voltages(np.array([230, 0], dtype=np.complex128), "an")
array([230.+0.j]) <Unit('volt')>

calculate_voltage_phases(phases: str) → list[str]¶

Calculate the composite phases of the voltages given the phases of an element.

Parameters:: phases – String of the phases in order. If a neutral exists, it must be the last.
Returns:: List of the composite phases of the voltages.

Example

>>> calculate_voltage_phases("an")
['an']
>>> calculate_voltage_phases("ab")
['ab']
>>> calculate_voltage_phases("abc")
['ab', 'bc', 'ca']
>>> calculate_voltage_phases("abcn")
['an', 'bn', 'cn']