# roseau.load_flow#

Welcome to the API reference of Roseau Load Flow.

For the most part, public classes and functions can be imported directly from this module.

See Package Contents below for a list of available classes and functions.

## Package Contents#

### Classes#

 RoseauLoadFlowExceptionCode Error codes used by Roseau Load Flow. AbstractBranch This is an abstract class for all the branches (lines, switches and transformers) of the network. AbstractLoad An abstract class of an electric load. Bus An electrical bus. Control A class to store the important values of a control. CurrentLoad A constant current load. Element An abstract class of an element in an Electrical network. FlexibleParameter This class stores the required data to make a flexible parameter. Ground This element defines the ground. ImpedanceLoad A constant impedance load. Line An electrical line PI model with series impedance and optional shunt admittance. LineParameters A class to store the line parameters of lines PotentialRef A potential reference. PowerLoad A constant power load. Projection This class defines the projection on the feasible circle for a flexible load. Switch A general purpose switch branch. Transformer A generic transformer model. TransformerParameters A class to store the parameters of the transformers. VoltageSource A voltage source. ElectricalNetwork Electrical network class.

### Functions#

 show_versions(→ None) Print system and python environment information.

### Attributes#

 __author__ __copyright__ __credits__ __email__ __license__ __maintainer__ __status__ __url__ Q_ ureg __version__

Bases: Exception

Base exception for Roseau Load Flow.

Parameters:
• msg – A text description that provides the reason of the exception and potential solution.

• code – The code that identifies the reason of the exception.

Bases: enum.Enum

Error codes used by Roseau Load Flow.

A method to convert a string into an error code enumerated type.

Parameters:

string – The string depicted the error code. If a good element is given

Returns:

The enumerated type value corresponding with string.

class AbstractBranch(id: Id, bus1: Bus, bus2: Bus, *, phases1: str, phases2: str, geometry: Optional[Union[Point, LineString]] = None, **kwargs: Any)#

This is an abstract class for all the branches (lines, switches and transformers) of the network.

AbstractBranch constructor.

Parameters:
• id – A unique ID of the branch in the network branches.

• phases1 – The phases of the first extremity of the branch.

• phases2 – The phases of the second extremity of the branch.

• bus1 – The bus to connect the first extremity of the branch to.

• bus2 – The bus to connect the second extremity of the branch to.

• geometry – The geometry of the branch.

property res_currents: tuple[Q_, Q_]#

The load flow result of the branch currents (A).

property res_powers: tuple[Q_, Q_]#

The load flow result of the branch powers (VA).

property res_potentials: tuple[Q_, Q_]#

The load flow result of the branch potentials (V).

property res_voltages: tuple[Q_, Q_]#

The load flow result of the branch voltages (V).

classmethod from_dict(data: JsonDict) Self#

Create an element from a dictionary.

to_dict() #

Return the element information as a dictionary format.

results_from_dict(data: JsonDict) None#

Fill an element with the provided results’ dictionary.

class AbstractLoad(id: Id, bus: Bus, *, phases: Optional[str] = None, **kwargs: Any)#

An abstract class of an electric load.

Parameters:
• id – A unique ID of the load in the network loads.

• bus – The bus to connect the load to.

• phases – The phases of the load. A string like "abc" or "an" etc. The order of the phases is important. For a full list of supported phases, see the class attribute allowed_phases. All phases of the load, except "n", must be present in the phases of the connected bus. By default, the phases of the bus are used.

property is_flexible: bool#

Whether the load is flexible or not. Only PowerLoad can be flexible.

property voltage_phases: list[str]#

The phases of the load voltages.

property res_currents: Q_#

property res_potentials: Q_#

property res_voltages: Q_#

property res_powers: Q_#

allowed_phases#

The allowed phases for a load are the same as for a bus.

disconnect() None#

Disconnect this load from the network. It cannot be used afterwards.

classmethod from_dict(data: JsonDict) #

Create an element from a dictionary.

results_from_dict(data: JsonDict) None#

Fill an element with the provided results’ dictionary.

class Bus(id: Id, *, phases: str, geometry: Optional[Point] = None, potentials: Optional[Sequence[complex]] = None, **kwargs: Any)#

An electrical bus.

Bus constructor.

Parameters:
• id – A unique ID of the bus in the network buses.

• phases – The phases of the bus. A string like "abc" or "an" etc. The order of the phases is important. For a full list of supported phases, see the class attribute Bus.allowed_phases.

• geometry – An optional geometry of the bus; a Point that represents the x-y coordinates of the bus.

• potentials – An optional list of initial potentials of each phase of the bus.

• ground – The ground of the bus.

property potentials: Q_#

The potentials of the bus (V).

property res_potentials: Q_#

The load flow result of the bus potentials (V).

property res_voltages: Q_#

The load flow result of the bus voltages (V).

If the bus has a neutral, the voltages are phase-neutral voltages for existing phases in the order [Van, Vbn, Vcn]. If the bus does not have a neutral, phase-phase voltages are returned in the order [Vab, Vbc, Vca].

property voltage_phases: list[str]#

The phases of the voltages.

allowed_phases#

The allowed phases for a bus are:

• P-P-P or P-P-P-N: "abc", "abcn"

• P-P or P-P-N: "ab", "bc", "ca", "abn", "bcn", "can"

• P-N: "an", "bn", "cn"

classmethod from_dict(data: JsonDict) Self#

Create an element from a dictionary.

to_dict() #

Return the element information as a dictionary format.

results_from_dict(data: JsonDict) None#

Fill an element with the provided results’ dictionary.

class Control(type: ControlType, u_min: float, u_down: float, u_up: float, u_max: float, alpha: float = DEFAULT_ALPHA)#

A class to store the important values of a control.

Control constructor.

Parameters:
• type

The type of the control:
• "constant": no control is applied;

• "p_max_u_production": control the maximum production active power of the load (inverter) based on the voltage $$P^{\max}_{\mathrm{prod}}(U)$$;

• "p_max_u_consumption": control the maximum consumption active power of the load based on the voltage $$P^{\max}_{\mathrm{cons}}(U)$$;

• "q_u": control the reactive power based on the voltage $$Q(U)$$.

• u_min – The minimum voltage i.e. the one the control reached the maximum action.

• u_down – The voltage which starts to trigger the control (lower value).

• u_up – The voltage which starts to trigger the control (upper value).

• u_max – The maximum voltage i.e. the one the control reached its maximum action.

• alpha – An approximation factor used by the family function (soft clip). The bigger the factor is the closer the function is to the non-differentiable function.

property u_min: Q_#

The minimum voltage i.e. the one the control reached the maximum action.

property u_down: Q_#

The voltage which starts to trigger the control (lower value).

property u_up: Q_#

TThe voltage which starts to trigger the control (upper value).

property u_max: Q_#

The maximum voltage i.e. the one the control reached its maximum action.

property alpha: float#

An approximation factor used by the family function (soft clip). The bigger the factor is the closer the function is to the non-differentiable function.

classmethod constant() Self#

Create a constant control i.e no control.

classmethod p_max_u_production(u_up: float, u_max: float, alpha: float = DEFAULT_ALPHA) Self#

Create a control of the type "p_max_u_production".

Parameters:
• u_up – The voltage norm that triggers the control. A voltage higher than this value signals to the controller to start to reduce the production active power. On the figure, a normalised version $$U^{\mathrm{up}\,\mathrm{norm.}}$$ is used.

• u_max – The maximum norm voltage i.e. the one the control reached its maximum action. A voltage higher than this value signals to the controller to set the production active power to its minimal value. On the figure, a normalised version $$U^{\max\,\mathrm{norm.}}$$ is used.

• alpha – A factor used to soften the control function (soft clip) to make it more differentiable. The bigger alpha is, the closer the function is to the non-differentiable function. This parameter is noted $$\alpha$$ on the figure.

Returns:

The "p_max_u_production" control using the provided parameters.

classmethod p_max_u_consumption(u_min: float, u_down: float, alpha: float = DEFAULT_ALPHA) Self#

Create a control of the type "p_max_u_consumption".

Parameters:
• u_min – The minimum voltage norm i.e. the one the control reached its maximum action. A voltage lower than this value signals to the controller to set the consumption active power to its minimal value. On the figure, a normalised version $$U^{\min\,\mathrm{norm.}}$$ is used.

• u_down – The voltage norm that triggers the control. A voltage lower than this value signals to the controller to start to reduce the consumption active power. On the figure, a normalised version $$U^{\mathrm{down}\,\mathrm{norm.}}$$ is used.

• alpha – A factor used to soften the control function (soft clip) to make it more differentiable. The bigger alpha is, the closer the function is to the non-differentiable function. This parameter is noted $$\alpha$$ on the figure.

Returns:

The "p_max_u_consumption" control using the provided parameters.

classmethod q_u(u_min: float, u_down: float, u_up: float, u_max: float, alpha: float = DEFAULT_ALPHA) Self#

Create a control of the type "q_u".

Parameters:
• u_min – The minimum voltage norm i.e. the one the control reached its maximum action. A voltage lower than this value signals to the controller to set the reactive power to its maximal capacitive value. On the figure, a normalised version $$U^{\min\,\mathrm{norm.}}$$ is used.

• u_down – The voltage that triggers the capacitive reactive power control. A voltage lower than this value signals to the controller to start to increase the capacitive reactive power. On the figure, a normalised version $$U^{\mathrm{down}\,\mathrm{norm.}}$$ is used.

• u_up – The voltage that triggers the inductive reactive power control. A voltage higher than this value signals to the controller to start to increase the inductive reactive power. On the figure, a normalised version $$U^{\mathrm{up}\,\mathrm{norm.}}$$ is used.

• u_max – The minimum voltage i.e. the one the control reached its maximum action. A voltage lower than this value signals to the controller to set the reactive power to its maximal inductive value. On the figure, a normalised version $$U^{\max\,\mathrm{norm.}}$$ is used.

• alpha – A factor used to soften the control function (soft clip) to make it more differentiable. The bigger alpha is, the closer the function is to the non-differentiable function. This parameter is noted $$\alpha$$ on the figure.

Returns:

The "q_u" control using the provided parameters.

classmethod from_dict(data: JsonDict) Self#

Create an element from a dictionary.

to_dict() #

Return the element information as a dictionary format.

results_from_dict(data: JsonDict) NoReturn#

Fill an element with the provided results’ dictionary.

class CurrentLoad(id: Id, bus: Bus, *, currents: , phases: Optional[str] = None, **kwargs: Any)#

Bases: AbstractLoad

The equations are the following (star loads):

$\begin{split}I_{\mathrm{abc}} &= \mathrm{constant} \\ I_{\mathrm{n}} &= -\sum_{p\in\{\mathrm{a},\mathrm{b},\mathrm{c}\}}I_{p}\end{split}$

$\begin{split}I_{\mathrm{ab}} &= \mathrm{constant} \\ I_{\mathrm{bc}} &= \mathrm{constant} \\ I_{\mathrm{ca}} &= \mathrm{constant}\end{split}$

Parameters:
• id – A unique ID of the load in the network loads.

• bus – The bus to connect the load to.

• currents – List of currents for each phase (Amps).

• phases – The phases of the load. A string like "abc" or "an" etc. The order of the phases is important. For a full list of supported phases, see the class attribute allowed_phases. All phases of the load, except "n", must be present in the phases of the connected bus. By default, the phases of the bus are used.

property currents: Q_#

The currents of the load (Amps).

to_dict() #

Return the element information as a dictionary format.

class Element(id: Id, **kwargs: Any)#

An abstract class of an element in an Electrical network.

Element constructor.

Parameters:

id – A unique ID of the element in the network. Two elements of the same type cannot have the same ID.

property network: Optional[ElectricalNetwork]#

Return the network the element belong to (if any).

allowed_phases: ClassVar[frozenset[str]]#

The allowed phases for this element type.

It is a frozen set of strings like "abc" or "an" etc. The order of the phases is important. For a full list of supported phases, use print(<Element class>.allowed_phases).

class FlexibleParameter(control_p: Control, control_q: Control, projection: Projection, s_max: float)#

This class stores the required data to make a flexible parameter.

FlexibleParameter constructor.

Parameters:
• control_p – The control to apply on the active power.

• control_q – The control to apply on the reactive power.

• projection – The projection to use to have a feasible result.

• s_max – The apparent power of the flexible load (VA). It is the radius of the feasible circle.

property s_max: Q_#

The apparent power of the flexible load (VA). It is the radius of the feasible circle.

classmethod constant() Self#

Build flexible parameters for a constant control with a Euclidean projection.

Returns:

A constant control i.e. no control at all. It is an equivalent of the constant power load.

classmethod p_max_u_production(u_up: float, u_max: float, s_max: float, alpha_control: float = Control.DEFAULT_ALPHA, alpha_proj: float = Projection.DEFAULT_ALPHA, epsilon_proj: float = Projection.DEFAULT_EPSILON) Self#

Build flexible parameters for production P(U) control with a Euclidean projection.

Parameters:
• u_up – The voltage upper limit value that triggers the control. If the voltage is greater than this value, the production active power is reduced.

• u_max – The maximum voltage i.e. the one the control reached its maximum action. If the voltage is greater than this value, the production active power is reduced to zero.

• s_max – The apparent power of the flexible inverter (VA). It is the radius of the feasible circle.

• alpha_control – An approximation factor used by the family function (soft clip). The greater, the closer the function are from the non-differentiable function.

• alpha_proj – This value is used to make soft sign function and to build a soft projection function (see the diagram above).

• epsilon_proj – This value is used to make a smooth sqrt function. It is only used in the Euclidean projection.

Returns:

A flexible parameter which performs “p_max_u_production” control.

classmethod p_max_u_consumption(u_min: float, u_down: float, s_max: float, alpha_control: float = Control.DEFAULT_ALPHA, alpha_proj: float = Projection.DEFAULT_ALPHA, epsilon_proj: float = Projection.DEFAULT_EPSILON) Self#

Build flexible parameters for consumption P(U) control with a Euclidean projection.

Parameters:
• u_min – The minimum voltage i.e. the one the control reached the maximum action.

• u_down – The voltage which starts to trigger the control (lower value).

• s_max – The apparent power of the flexible load (VA). It is the radius of the feasible circle.

• alpha_control – An approximation factor used by the family function (soft clip). The greater, the closer the function are from the non-differentiable function.

• alpha_proj – This value is used to make soft sign function and to build a soft projection function.

• epsilon_proj – This value is used to make a smooth sqrt function. It is only used in the Euclidean projection.

Returns:

A flexible parameter which performs “p_max_u_consumption” control.

classmethod q_u(u_min: float, u_down: float, u_up: float, u_max: float, s_max: float, alpha_control: float = Control.DEFAULT_ALPHA, alpha_proj: float = Projection.DEFAULT_ALPHA, epsilon_proj: float = Projection.DEFAULT_EPSILON) Self#

Build flexible parameters for Q(U) control with a Euclidean projection.

Parameters:
• u_min – The minimum voltage i.e. the one the control reached the maximum action.

• u_down – The voltage which starts to trigger the control (lower value).

• u_up – The voltage which starts to trigger the control (upper value).

• u_max – The maximum voltage i.e. the one the control reached its maximum action.

• s_max – The apparent power of the flexible load (VA). It is the radius of the feasible circle.

• alpha_control – An approximation factor used by the family function (soft clip). The greater, the closer the function are from the non-differentiable function.

• alpha_proj – This value is used to make soft sign function and to build a soft projection function.

• epsilon_proj – This value is used to make a smooth sqrt function. It is only used in the Euclidean projection.

Returns:

A flexible parameter which performs “q_u” control.

classmethod pq_u_production(up_up: float, up_max: float, uq_min: float, uq_down: float, uq_up: float, uq_max: float, s_max: float, alpha_control=Control.DEFAULT_ALPHA, alpha_proj=Projection.DEFAULT_ALPHA, epsilon_proj=Projection.DEFAULT_EPSILON) Self#

Build flexible parameters for production P(U) control and Q(U) control with a Euclidean projection.

Parameters:
• up_up – The voltage which starts to trigger the control on the production (upper value).

• up_max – The maximum voltage i.e. the one the control (of production) reached its maximum action.

• uq_min – The minimum voltage i.e. the one the control reached the maximum action (reactive power control)

• uq_down – The voltage which starts to trigger the reactive power control (lower value).

• uq_up – The voltage which starts to trigger the reactive power control (upper value).

• uq_max – The maximum voltage i.e. the one the reactive power control reached its maximum action.

• s_max – The apparent power of the flexible load (VA). It is the radius of the feasible circle.

• alpha_control – An approximation factor used by the family function (soft clip). The greater, the closer the function are from the non-differentiable function.

• alpha_proj – This value is used to make soft sign function and to build a soft projection function.

• epsilon_proj – This value is used to make a smooth sqrt function. It is only used in the Euclidean projection.

Returns:

A flexible parameter which performs “p_max_u_production” control and a “q_u” control.

classmethod pq_u_consumption(up_min: float, up_down: float, uq_min: float, uq_down: float, uq_up: float, uq_max: float, s_max: float, alpha_control: float = Control.DEFAULT_ALPHA, alpha_proj: float = Projection.DEFAULT_ALPHA, epsilon_proj: float = Projection.DEFAULT_EPSILON) Self#

Build flexible parameters for consumption P(U) control and Q(U) control with a Euclidean projection.

Parameters:
• up_min – The minimum voltage i.e. the one the active power control reached the maximum action.

• up_down – The voltage which starts to trigger the active power control (lower value).

• uq_min – The minimum voltage i.e. the one the control reached the maximum action (reactive power control)

• uq_down – The voltage which starts to trigger the reactive power control (lower value).

• uq_up – The voltage which starts to trigger the reactive power control (upper value).

• uq_max – The maximum voltage i.e. the one the reactive power control reached its maximum action.

• s_max – The apparent power of the flexible load (VA). It is the radius of the feasible circle.

• alpha_control – An approximation factor used by the family function (soft clip). The greater, the closer the function are from the non-differentiable function.

• alpha_proj – This value is used to make soft sign function and to build a soft projection function.

• epsilon_proj – This value is used to make a smooth sqrt function. It is only used in the Euclidean projection.

Returns:

A flexible parameter which performs “p_max_u_consumption” control and “q_u” control.

classmethod from_dict(data: JsonDict) Self#

Create an element from a dictionary.

to_dict() #

Return the element information as a dictionary format.

results_from_dict(data: JsonDict) NoReturn#

Fill an element with the provided results’ dictionary.

class Ground(id: Id, **kwargs: Any)#

This element defines the ground.

Only buses and lines that have shunt components can be connected to a ground.

1. Connecting to a bus:

To connect a ground to a bus on a given phase, use the Ground.connect() method. This method lets you specify the bus to connect to as well as the phase of the connection. If the bus has a neutral and the phase is not specified, the ground will be connected to the neutral, otherwise, an error will be raised because the phase is needed.

2. Connecting to a line with shunt components:

To connect a ground to a line with shunt components, pass the ground object to the Line constructor. Note that the ground connection is mandatory for shunt lines.

Ground constructor.

Parameters:

id – A unique ID of the ground in the network grounds.

property res_potential: Q_#

The load flow result of the ground potential (V).

property connected_buses: dict[Id, str]#

The bus ID and phase of the buses connected to this ground.

connect(bus: Bus, phase: str = 'n') None#

Connect the ground to a bus on the given phase.

Parameters:
• bus – The bus to connect to.

• phase – The phase of the connection. It must be one of {"a", "b", "c", "n"} and must be present in the bus phases. Defaults to "n".

classmethod from_dict(data: JsonDict) Self#

Create an element from a dictionary.

to_dict() #

Return the element information as a dictionary format.

results_from_dict(data: JsonDict) None#

Fill an element with the provided results’ dictionary.

class ImpedanceLoad(id: Id, bus: Bus, *, impedances: , phases: Optional[str] = None, **kwargs: Any)#

Bases: AbstractLoad

The equations are the following (star loads):

$\begin{split}I_{\mathrm{abc}} &= \frac{\left(V_{\mathrm{abc}}-V_{\mathrm{n}}\right)}{Z_{\mathrm{abc}}} \\ I_{\mathrm{n}} &= -\sum_{p\in\{\mathrm{a},\mathrm{b},\mathrm{c}\}}I_{p}\end{split}$

$\begin{split}I_{\mathrm{ab}} &= \frac{\left(V_{\mathrm{a}}-V_{\mathrm{b}}\right)}{Z_{\mathrm{ab}}} \\ I_{\mathrm{bc}} &= \frac{\left(V_{\mathrm{b}}-V_{\mathrm{c}}\right)}{Z_{\mathrm{bc}}} \\ I_{\mathrm{ca}} &= \frac{\left(V_{\mathrm{c}}-V_{\mathrm{a}}\right)}{Z_{\mathrm{ca}}}\end{split}$

Parameters:
• id – A unique ID of the load in the network loads.

• bus – The bus to connect the load to.

• impedances – List of impedances for each phase (Ohms).

• phases – The phases of the load. A string like "abc" or "an" etc. The order of the phases is important. For a full list of supported phases, see the class attribute allowed_phases. All phases of the load, except "n", must be present in the phases of the connected bus. By default, the phases of the bus are used.

property impedances: Q_#

The impedances of the load (Ohms).

to_dict() #

Return the element information as a dictionary format.

class Line(id: Id, bus1: Bus, bus2: Bus, *, parameters: LineParameters, length: float, phases: Optional[str] = None, ground: Optional[Ground] = None, geometry: Optional[LineString] = None, **kwargs: Any)#

An electrical line PI model with series impedance and optional shunt admittance.

$\begin{split}V_1 &= a \cdot V_2 - b \cdot I_2 + g \cdot V_{\mathrm{g}} \\ I_1 &= c \cdot V_2 - d \cdot I_2 + h \cdot V_{\mathrm{g}} \\ I_{\mathrm{g}} &= f^t \cdot \left(V_1 + V_2 - 2\cdot V_{\mathrm{g}}\right)\end{split}$

where

$\begin{split}a &= \mathcal{I}_4 + \dfrac{1}{2} \cdot Z \cdot Y \\ b &= Z \\ c &= Y + \dfrac{1}{4}\cdot Y \cdot Z \cdot Y \\ d &= \mathcal{I}_4 + \dfrac{1}{2} \cdot Y \cdot Z \\ f &= -\dfrac{1}{2} \cdot \begin{pmatrix} y_{\mathrm{ag}} & y_{\mathrm{bg}} & y_{\mathrm{cg}} & y_{\mathrm{ng}} \end{pmatrix} ^t \\ g &= Z \cdot f \\ h &= 2 \cdot f + \frac{1}{2}\cdot Y \cdot Z \cdot f \\\end{split}$

If the line does not define a shunt admittance, the following simplified equations are used instead:

$\begin{split}\left(V_1 - V_2\right) &= Z \cdot I_1 \\ I_2 &= -I_1\end{split}$

Line constructor.

Parameters:
• id – A unique ID of the line in the network branches.

• bus1 – The first bus (aka “from_bus”) to connect to the line.

• bus2 – The second bus (aka “to_bus”) to connect to the line.

• parameters – The parameters of the line, an instance of LineParameters.

• length – The length of the line in km.

• phases – The phases of the line. A string like "abc" or "an" etc. The order of the phases is important. For a full list of supported phases, see the class attribute allowed_phases. All phases of the line must be present in the phases of both connected buses. By default, the phases common to both buses are used.

• ground – The ground element attached to the line if it has shunt admittance.

• geometry – The geometry of the line i.e. the linestring.

property parameters: LineParameters#

The parameters of the line.

property res_series_power_losses: Q_#

Get the power losses in the series elements of the line (VA).

property res_shunt_power_losses: Q_#

Get the power losses in the shunt elements of the line (VA).

property res_power_losses: Q_#

Get the power losses in the line (VA).

allowed_phases#

The allowed phases for a line are:

• P-P-P or P-P-P-N: "abc", "abcn"

• P-P or P-P-N: "ab", "bc", "ca", "abn", "bcn", "can"

• P or P-N: "a", "b", "c", "an", "bn", "cn"

• N: "n"

to_dict() #

Return the element information as a dictionary format.

class LineParameters(id: Id, z_line: ndarray, y_shunt: Optional[ndarray] = None)#

A class to store the line parameters of lines

LineParameters constructor.

Parameters:
• id – A unique ID of the line parameters, typically its canonical name.

• z_line – The Z matrix of the line (Ohm/km).

• y_shunt – The Y matrix of the line (Siemens/km). This field is optional if the line has no shunt part.

classmethod from_sym(id: Id, model: LineModel, z0: complex, z1: complex, y0: complex, y1: complex, zn: Optional[complex] = None, xpn: Optional[float] = None, bn: Optional[float] = None, bpn: Optional[float] = None) Self#

Create line parameters from sym model.

Parameters:
• id – A unique ID of the line parameters, typically its canonical name.

• model – The required model. It can be SYM or SYM_NEUTRAL. Be careful, it can be downgraded…

• z0 – Impedance - zero sequence - $$r_0+x_0\cdot j$$ (ohms/km)

• z1 – Impedance - direct sequence - $$r_1+x_1\cdot j$$ (ohms/km)

• y0 – Admittance - zero sequence - $$g_0+b_0\cdot j$$ (Siemens/km)

• y1 – Conductance - direct sequence - $$g_1+b_1\cdot j$$ (Siemens/km)

• zn – Neutral impedance - $$r_{\mathrm{n}}+x_{\mathrm{n}}\cdot j$$ (ohms/km)

• xpn – Phase to neutral reactance (ohms/km)

• bn – Neutral susceptance (siemens/km)

• bpn – Phase to neutral susceptance (siemens/km)

Returns:

The created line parameters.

classmethod from_lv_exact(type_name: str, line_type: LineType, conductor_type: ConductorType, isolation_type: IsolationType, section: float, section_neutral: float, height: float, external_diameter: float) Self#

Create line parameters from LV exact model.

Parameters:
• type_name – The name of the “LV exact” type.

• line_type – Overhead or underground.

• conductor_type – Type of the conductor

• isolation_type – Type of insulator.

• section – Surface of the phases (mm²).

• section_neutral – Surface of the neutral (mm²).

• height – Height of the line (m).

• external_diameter – External diameter of the wire (m).

Returns:

The created line parameters.

classmethod from_name_lv(name: str, section_neutral: Optional[float] = None, height: Optional[float] = None, external_diameter: Optional[float] = None) Self#

Method to get the electrical parameters of a LV line from its canonical name. Some hypothesis will be made: the section of the neutral is the same as the other sections, the height and external diameter are pre-defined, and the isolation is PVC.

Parameters:
• name – The name of the line the parameters must be computed. Eg. “S_AL_150”.

• section_neutral – Surface of the neutral (mm²). If None it will be the same as the section of the other phases.

• height – Height of the line (m). If None a default value will be used.

• external_diameter – External diameter of the wire (mm). If None a default value will be used.

Returns:

The corresponding line parameters.

classmethod from_name_mv(name: str) Self#

Method to get the electrical parameters of a MV line from its canonical name.

Parameters:

name – The name of the line the parameters must be computed. Eg. “S_AL_150”.

Returns:

The corresponding line parameters.

classmethod from_dict(data: JsonDict) Self#

Line parameters constructor from dict.

Parameters:

data – The dictionary data of the line parameters.

Returns:

The created line parameters.

to_dict() #

Return the line parameters information as a dictionary format.

results_from_dict(data: JsonDict) None#

Fill an element with the provided results’ dictionary.

class PotentialRef(id: Id, element: Union[Bus, Ground], *, phase: Optional[str] = None, **kwargs: Any)#

A potential reference.

This element will set the reference of the potentials in a network. Only one potential reference per galvanically isolated section of the network can be set. The potential reference can be set on any bus or ground elements. If set on a bus with no neutral and without specifying the phase, the reference will be set as Va + Vb + Vc = 0. For other buses, the default is Vn = 0.

PotentialRef constructor.

Parameters:
• id – A unique ID of the potential reference in the network references.

• element – The bus or ground element to set as a potential reference.

• phase – The phase of the bus to set as a potential reference. Cannot be used with a ground. If the element passed is a bus and the phase is not given, the neutral will be used if the bus has a neutral otherwise the equation Va + Vb + Vc = 0 of the bus sets the potential reference.

property res_current: Q_#

The sum of the currents (A) of the connection associated to the potential reference.

This sum should be equal to 0 after the load flow.

classmethod from_dict(data: JsonDict) Self#

Create an element from a dictionary.

to_dict() #

Return the element information as a dictionary format.

results_from_dict(data: JsonDict) None#

Fill an element with the provided results’ dictionary.

class PowerLoad(id: Id, bus: Bus, *, powers: , phases: Optional[str] = None, flexible_params: Optional[list[FlexibleParameter]] = None, **kwargs: Any)#

Bases: AbstractLoad

The equations are the following (star loads):

$\begin{split}I_{\mathrm{abc}} &= \left(\frac{S_{\mathrm{abc}}}{V_{\mathrm{abc}}-V_{\mathrm{n}}}\right)^{\star} \\ I_{\mathrm{n}} &= -\sum_{p\in\{\mathrm{a},\mathrm{b},\mathrm{c}\}}I_{p}\end{split}$

$\begin{split}I_{\mathrm{ab}} &= \left(\frac{S_{\mathrm{ab}}}{V_{\mathrm{a}}-V_{\mathrm{b}}}\right)^{\star} \\ I_{\mathrm{bc}} &= \left(\frac{S_{\mathrm{bc}}}{V_{\mathrm{b}}-V_{\mathrm{c}}}\right)^{\star} \\ I_{\mathrm{ca}} &= \left(\frac{S_{\mathrm{ca}}}{V_{\mathrm{c}}-V_{\mathrm{a}}}\right)^{\star}\end{split}$

Parameters:
• id – A unique ID of the load in the network loads.

• bus – The bus to connect the load to.

• powers – List of power for each phase (VA).

• phases – The phases of the load. A string like "abc" or "an" etc. The order of the phases is important. For a full list of supported phases, see the class attribute allowed_phases. All phases of the load, except "n", must be present in the phases of the connected bus. By default, the phases of the bus are used.

• flexible_params – A list of FlexibleParameters object, one for each phase. When provided, the load is considered as flexible (or controllable) and the parameters are used to compute the flexible power of the load.

property is_flexible: bool#

Whether the load is flexible or not. Only PowerLoad can be flexible.

property powers: Q_#

The powers of the load (VA).

property res_flexible_powers: Q_#

to_dict() #

Return the element information as a dictionary format.

results_from_dict(data: JsonDict) None#

Fill an element with the provided results’ dictionary.

class Projection(type: ProjectionType, alpha: float = DEFAULT_ALPHA, epsilon: float = DEFAULT_EPSILON)#

This class defines the projection on the feasible circle for a flexible load.

Projection constructor.

Parameters:
• type

The type of the projection. It can be:
• "euclidean": for an Euclidean projection on the feasible space;

• "keep_p": for maintaining a constant P;

• "keep_q": for maintaining a constant Q.

• alpha – This value is used to make soft sign function and to build a soft projection function.

• epsilon

This value is used to make a smooth sqrt function. It is only used in the Euclidean projection.

$\sqrt{S} = \sqrt{\varepsilon \times \exp\left(\frac{-{|S|}^2}{\varepsilon}\right) + {|S|}^2}$

property alpha: float#

This value is used to make soft sign function and to build a soft projection function.

property epsilon: float#

This value is used to make a smooth sqrt function. It is only used in the Euclidean projection.

classmethod from_dict(data: JsonDict) Self#

Create an element from a dictionary.

to_dict() #

Return the element information as a dictionary format.

results_from_dict(data: JsonDict) NoReturn#

Fill an element with the provided results’ dictionary.

class Switch(id: Id, bus1: Bus, bus2: Bus, *, phases: Optional[str] = None, geometry: Optional[Point] = None, **kwargs: Any)#

A general purpose switch branch.

Switch constructor.

Parameters:
• id – A unique ID of the switch in the network branches.

• bus1 – Bus to connect to the switch.

• bus2 – Bus to connect to the switch.

• phases – The phases of the switch. A string like "abc" or "an" etc. The order of the phases is important. For a full list of supported phases, see the class attribute allowed_phases. All phases of the switch must be present in the phases of both connected buses. By default, the phases common to both buses are used.

• geometry – The geometry of the switch.

allowed_phases#

The allowed phases for a switch are:

• P-P-P or P-P-P-N: "abc", "abcn"

• P-P or P-P-N: "ab", "bc", "ca", "abn", "bcn", "can"

• P or P-N: "a", "b", "c", "an", "bn", "cn"

• N: "n"

class Transformer(id: Id, bus1: Bus, bus2: Bus, *, parameters: TransformerParameters, tap: float = 1.0, phases1: Optional[str] = None, phases2: Optional[str] = None, geometry: Optional[Point] = None, **kwargs: Any)#

A generic transformer model.

The model parameters and windings type are defined in the parameters.

Transformer constructor.

Parameters:
• id – A unique ID of the transformer in the network branches.

• bus1 – Bus to connect the first extremity of the transformer.

• bus2 – Bus to connect the first extremity of the transformer.

• tap – The tap of the transformer, for example 1.02.

• parameters – The parameters of the transformer.

• phases1 – The phases of the first extremity of the transformer. A string like "abc" or "abcn" etc. The order of the phases is important. For a full list of supported phases, see the class attribute allowed_phases. All phases must be present in the connected bus. By default determined from the transformer windings.

• phases2 – The phases of the second extremity of the transformer. See phases1.

• geometry – The geometry of the transformer.

property tap: float#

The tap of the transformer, for example 1.02.

property parameters: TransformerParameters#

The parameters of the transformer.

allowed_phases#

The allowed phases for a transformer are:

• P-P-P or P-P-P-N: "abc", "abcn"

Note

Only 3-phase transformers are currently supported.

to_dict() #

Return the element information as a dictionary format.

class TransformerParameters(id: Id, windings: str, uhv: float, ulv: float, sn: float, p0: float, i0: float, psc: float, vsc: float)#

A class to store the parameters of the transformers.

TransformerParameters constructor.

Parameters:
• id – A unique ID of the transformer parameters, typically its canonical name.

• windings – The type of windings such as “Dyn11”

• uhv – Phase-to-phase nominal voltages of the high voltages side (V)

• ulv – Phase-to-phase nominal voltages of the low voltages side (V)

• sn – The nominal power of the transformer (VA)

• p0 – Losses during off-load test (W)

• i0 – Current during off-load test (%)

• psc – Losses during short circuit test (W)

• vsc – Voltages on LV side during short circuit test (%)

property uhv: Q_#

Phase-to-phase nominal voltages of the high voltages side (V)

property ulv: Q_#

Phase-to-phase nominal voltages of the low voltages side (V)

property sn: Q_#

The nominal power of the transformer (VA)

property p0: Q_#

property i0: float#

property psc: Q_#

Losses during short circuit test (W)

property vsc: float#

Voltages on LV side during short circuit test (%)

classmethod from_name(name: str, windings: str) Self#

Construct TransformerParameters from name and windings.

Parameters:
• name – The name of the transformer parameters, such as “160kVA” or “H61_50kVA”.

• windings – The type of windings such as “Dyn11”.

Returns:

The constructed transformer parameters.

to_zyk() tuple[Q_, Q_, float, float]#

Compute the transformer parameters z2, ym, k and orientation mandatory for some models.

Where:
• z2: The series impedance of the transformer (Ohms).

• ym: The magnetizing admittance of the transformer (Siemens).

• k: The transformation ratio.

• orientation: 1 for direct winding, -1 for reverse winding.

Returns:

The parameters (z2, ym, k, orientation).

classmethod from_dict(data: JsonDict) Self#

Create an element from a dictionary.

to_dict() #

Return the element information as a dictionary format.

results_from_dict(data: JsonDict) NoReturn#

Fill an element with the provided results’ dictionary.

class VoltageSource(id: Id, bus: Bus, *, voltages: , phases: Optional[str] = None, **kwargs: Any)#

A voltage source.

The voltage equations are the following:

For a Star (wye) connected source:

$\begin{split}\left(V_{\mathrm{a}}-V_{\mathrm{n}}\right) &= U_{\mathrm{an}} \\ \left(V_{\mathrm{b}}-V_{\mathrm{n}}\right) &= U_{\mathrm{bn}} \\ \left(V_{\mathrm{c}}-V_{\mathrm{n}}\right) &= U_{\mathrm{cn}}\end{split}$

For a Delta connected source:

$\begin{split}\left(V_{\mathrm{a}}-V_{\mathrm{b}}\right) &= U_{\mathrm{ab}} \\ \left(V_{\mathrm{b}}-V_{\mathrm{c}}\right) &= U_{\mathrm{bc}} \\ \left(V_{\mathrm{c}}-V_{\mathrm{a}}\right) &= U_{\mathrm{ca}}\end{split}$

Where $U$ is the voltage and $V$ is the node potential.

Voltage source constructor.

Parameters:
• id – A unique ID of the voltage source in the network sources.

• bus – The bus of the voltage source.

• voltages – The voltages of the source. They will be fixed on the connected bus. If the source has a neutral connection, the voltages are the phase-to-neutral voltages, otherwise they are the phase-to-phase voltages.

• phases – The phases of the source. A string like "abc" or "an" etc. The order of the phases is important. For a full list of supported phases, see the class attribute allowed_phases. All phases of the source, except "n", must be present in the phases of the connected bus. By default, the phases of the bus are used.

property voltages: Q_#

The voltages of the source (V).

property voltage_phases: list[str]#

The phases of the source voltages.

property res_currents: Q_#

The load flow result of the source currents (A).

property res_potentials: Q_#

The load flow result of the source potentials (V).

property res_powers: ndarray#

The load flow result of the source powers (VA).

allowed_phases#

The allowed phases for a voltage source are the same as for a bus.

disconnect() None#

Disconnect this voltage source from the network. It cannot be used afterwards.

classmethod from_dict(data: JsonDict) Self#

Create an element from a dictionary.

to_dict() #

Return the element information as a dictionary format.

results_from_dict(data: JsonDict) None#

Fill an element with the provided results’ dictionary.

class ElectricalNetwork(buses: Union[list[Bus], dict[Id, Bus]], branches: Union[list[AbstractBranch], dict[Id, AbstractBranch]], loads: Union[list[AbstractLoad], dict[Id, AbstractLoad]], sources: Union[list[VoltageSource], dict[Id, VoltageSource]], grounds: Union[list[Ground], dict[Id, Ground]], potential_refs: Union[list[PotentialRef], dict[Id, PotentialRef]], **kwargs)#

Electrical network class.

This class represents an electrical network, its elements, and their connections. After creating the network, the load flow algorithm can be run on it using the solve_load_flow() method.

Parameters:
• buses – The buses of the network. Either a list of buses or a dictionary of buses with their IDs as keys. Buses are the nodes of the network. They connect other elements such as loads and sources. Buses can be connected together with branches.

• branches – The branches of the network. Either a list of branches or a dictionary of branches with their IDs as keys. Branches are the elements that connect two buses together. They can be lines, transformers, or switches.

• loads – The loads of the network. Either a list of loads or a dictionary of loads with their IDs as keys. There are three types of loads: constant power, constant current, and constant impedance.

• sources – The sources of the network. Either a list of sources or a dictionary of sources with their IDs as keys. A network must have at least one source. Note that two sources cannot be connected with a switch.

• grounds – The grounds of the network. Either a list of grounds or a dictionary of grounds with their IDs as keys. LV networks typically have one ground element connected to the neutral of the main source bus (secondary of the MV/LV transformer). HV networks may have one or more grounds connected to the shunt components of their lines.

• potential_refs – The potential references of the network. Either a list of potential references or a dictionary of potential references with their IDs as keys. As the name suggests, this element defines the reference of potentials of the network. A potential reference per galvanically isolated section of the network is expected. A potential reference can be connected to a bus or to a ground.

DEFAULT_PRECISION#

The default precision needed for the convergence of the load flow algorithm. At each iteration, the solver computes the residuals of the equations of the problem. When the maximum of the absolute values of the residuals vector is lower than the provided precision, the solver stops. Default is 1e-6.

Type:

float

DEFAULT_MAX_ITERATIONS#

Maximum number of iterations to perform the load flow analysis. The solver stops when this number of iterations is reached. Default is 20.

Type:

int

DEFAULT_BASE_URL#

Base URL of the Roseau Load Flow API endpoint.

Type:

str

buses#

Dictionary of buses of the network indexed by their IDs. Also available as a GeoDataFrame.

Type:

dict[Id, Bus]

branches#

Dictionary of branches of the network indexed by their IDs. Also available as a GeoDataFrame.

Type:

Dictionary of loads of the network indexed by their IDs. Also available as a DataFrame.

Type:
sources#

Dictionary of voltage sources of the network indexed by their IDs. Also available as a DataFrame.

Type:
grounds#

Dictionary of grounds of the network indexed by their IDs. Also available as a DataFrame.

Type:

dict[Id, Ground]

potential_refs#

Dictionary of potential references of the network indexed by their IDs. Also available as a DataFrame.

Type:
res_info#

Dictionary containing solver information on the last run of the load flow analysis. Empty if the load flow analysis has not been run yet. Example:

{
"resolution_method": "newton",
"precision": 1e-06,
"max_iterations": 20,
"warm_start": True,
"status": "success",
"iterations": 2,
"final_precision": 1.8595619621919468e-07
}

Type:

JsonDict

property buses_frame: GeoDataFrame#

The buses of the network as a geo dataframe.

property branches_frame: GeoDataFrame#

The branches of the network as a geo dataframe.

The loads of the network as a dataframe.

property sources_frame: DataFrame#

The sources of the network as a dataframe.

property grounds_frame: DataFrame#

The grounds of the network as a dataframe.

property potential_refs_frame: DataFrame#

The potential references of the network as a dataframe.

property res_buses: DataFrame#

The load flow results of the network buses.

The results are returned as a dataframe with the following index:
• bus_id: The id of the bus.

• phase: The phase of the bus (in {'a', 'b', 'c', 'n'}).

and the following columns:
• potential: The complex potential of the bus (in Volts) for the given phase.

property res_buses_voltages: DataFrame#

The load flow results of the complex voltages of the buses (V).

The voltages are computed from the potentials of the buses. If the bus has a neutral, the voltage is the line-to-neutral voltage. Otherwise, the voltage is the line-to-line voltage. The result dataframe has a phase index that depicts this behavior.

The results are returned as a dataframe with the following index:
• bus_id: The id of the bus.

• phase: The phase of the bus (in {'an', 'bn', 'cn', 'ab', 'bc', 'ca'}).

and the following columns:
• voltage: The complex voltage of the bus (in Volts) for the given phase.

property res_branches: DataFrame#

The load flow results of the network branches.

The results are returned as a dataframe with the following index:
• branch_id: The id of the branch.

• phase: The phase of the branch (in {'a', 'b', 'c', 'n'}).

and the following columns:
• current1: The complex current of the branch (in Amps) for the given phase at the

first bus.

• current2: The complex current of the branch (in Amps) for the given phase at the

second bus.

• power1: The complex power of the branch (in VoltAmps) for the given phase at the

first bus.

• power2: The complex power of the branch (in VoltAmps) for the given phase at the

second bus.

• potential1: The complex potential of the first bus (in Volts) for the given phase.

• potential2: The complex potential of the second bus (in Volts) for the given phase.

property res_lines_losses: DataFrame#

The load flow results of the complex power losses of the network lines.

To get the active power losses, use the real part of the complex power losses.

The results are returned as a dataframe with the following index:
• line_id: The id of the line.

• phase: The phase of the line (in {'a', 'b', 'c', 'n'}).

and the following columns:
• series_losses: The complex power losses of the line (in VoltAmps) for the given

phase due to the series and mutual impedances.

• shunt_losses: The complex power losses of the line (in VoltAmps) for the given

phase due to the shunt admittances.

• total_losses: The complex power losses of the line (in VoltAmps) for the given

phase due to the series and mutual impedances and the shunt admittances. This is the sum of the series and shunt losses. It is equal to the power flow through the line; for any line, series_losses + shunt_losses == power1 + power2 is always true.

The results are returned as a dataframe with the following index:

• phase: The phase of the load (in {'a', 'b', 'c', 'n'}).

and the following columns:
• current: The complex current of the load (in Amps) for the given phase.

• power: The complex power of the load (in VoltAmps) for the given phase.

• potential: The complex potential of the load (in Volts) for the given phase.

The load flow results of the complex voltages of the loads (V).

The results are returned as a dataframe with the following index:

• phase: The phase of the load (in {'an', 'bn', 'cn'} for wye loads and in

{'ab', 'bc', 'ca'} for delta loads.).

and the following columns:
• voltage: The complex voltage of the load (in Volts) for the given phase.

The load flow results of the flexible powers of the “flexible” loads.

The results are returned as a dataframe with the following index:

• phase: The phase of the load (in {'a', 'b', 'c', 'n'}).

and the following columns:
• power: The complex flexible power of the load (in VoltAmps) for the given phase.

property res_sources: DataFrame#

The load flow results of the network sources.

The results are returned as a dataframe with the following index:
• source_id: The id of the source.

• phase: The phase of the source (in {'a', 'b', 'c', 'n'}).

and the following columns:
• current: The complex current of the source (in Amps) for the given phase.

• power: The complex power of the source (in VoltAmps) for the given phase.

• potential: The complex potential of the source (in Volts) for the given phase.

property res_grounds: DataFrame#

The load flow results of the network grounds.

The results are returned as a dataframe with the following index:
• ground_id: The id of the ground.

and the following columns:
• potential: The complex potential of the ground (in Volts).

property res_potential_refs: DataFrame#

The load flow results of the network potential references.

The results are returned as a dataframe with the following index:
• potential_ref_id: The id of the potential reference.

and the following columns:
• current: The complex current of the potential reference (in Amps). If the load flow

converged, this should be zero.

classmethod from_element(initial_bus: Bus) Self#

Construct the network from only one element and add the others automatically.

Parameters:

initial_bus – Any bus of the network.

solve_load_flow(auth: Union[tuple[str, str], HTTPBasicAuth], base_url: str = DEFAULT_BASE_URL, precision: float = DEFAULT_PRECISION, max_iterations: int = DEFAULT_MAX_ITERATIONS, warm_start: bool = DEFAULT_WARM_START) int#

Solve the load flow for this network (Requires internet access).

Execute a Newton algorithm for load flow calculation. To get the results of the load flow for the whole network, use the different res_ properties (e.g. print(net.res_buses). To get the results for a specific element, use the element directly (e.g. print(net.buses["bus1"].res_potentials)

Parameters:

• base_url – The base url to request the load flow solver.

• precision – Precision needed for the convergence.

• max_iterations – The maximum number of allowed iterations.

• warm_start – Should we use the values of potentials of the last successful load flow result (if any)?

Returns:

The number of iterations taken.

classmethod from_dict(data: JsonDict) Self#

Construct an electrical network from a dict created with to_dict().

Parameters:

data – The dictionary containing the network data.

Returns:

The constructed network.

to_dict() #

Convert the electrical network to a dictionary.

results_from_dict(data: JsonDict) None#

Load the results of a load flow from a dict created by results_to_dict().

The results are stored in the network elements.

Parameters:

data – The dictionary containing the results as returned by the solver.

classmethod from_dgs(path: StrPath) Self#

Construct an electrical network from json DGS file (PowerFactory).

Parameters:

path – The path to the network DGS data file.

Returns:

The constructed network.

show_versions() None#

Print system and python environment information.