DC System Modelling¶

DC node¶

The AC node is modeled using voltage \(U_d\) where [1]:

(1)¶\[\begin{split}\begin{align} P_{net}^{dc} &= P_{flow}^{dc} \\ P_{net}^{dc} &= P_{cn_d} + \sum \gamma_{rg_d}P_{rg_d} - P_{l_d} \\ P_{flow}^{dc} &= U_d \sum_{\substack{f \in \mathcal{N}_{dc} \\ f \neq d}} \left( (U_d-U_f) \cdot p_{e} \cdot \left(\frac{1}{R_{df}} \right) \right), \left\{ R_{df} \neq 0 \right\} \qquad \forall d \in \mathcal{N}_{dc} \end{align}\end{split}\]

(2)¶\[U_{min} \leq U_{d} \leq U_{max} \qquad \forall d \in \mathcal{N}_{dc}\]

\(U_d\) is the voltage magnitude in pu
\(P_{rg}\) is the active power injection of renewable generation in pu
\(P_{cn}\) is the active power injection of converter in pu
\(P_l\) is the active power demand in pu

Class Reference: pyflow_acdc.Classes.Node_DC

class Node_DC(node_type, kV_base, Voltage_0=1, Power_Gained=0, Power_load=0, name=None, Umin=0.95, Umax=1.05, x_coord=None, y_coord=None, S_base=100)¶

DC bus in the network.

Parameters:

node_type (str) – Bus type: 'Slack', 'P', 'Droop', or 'PAC' (stored as type).
kV_base (float) – Base voltage in kV.
Voltage_0 (float, optional) – Initial voltage magnitude in pu (stored as V_ini).
Power_Gained (float, optional) – Active power injection in pu (stored as PGi).
Power_load (float, optional) – Active power demand in pu (stored as PLi via load factors).
name (str, optional) – Bus identifier.
Umin (float, optional) – Minimum voltage magnitude in p.u.
Umax (float, optional) – Maximum voltage magnitude in p.u.
x_coord (float, optional) – x-coordinate, preferably in longitude decimal format.
y_coord (float, optional) – y-coordinate, preferably in latitude decimal format.
S_base (float)

price¶

Nodal energy price when the bus belongs to a price zone.

Type:: float

PLi_factor¶

Time-series/scenario load scaling factor.

Type:: float

PLi_inv_factor¶

Investment-period load scaling factor.

Type:: float

Example Usage:

import pyflow_acdc as pyf
# Create an DC node
pyf.initialize_pyflowacdc()
node = pyf.Node_DC('P', 1, 0,0,525,name='Bus1')

DC line¶

(3)¶\[\begin{split}p_{e}=\begin{cases} 1, &\text{for asymmetrical monopolar} \\ 2, &\text{for symmetrical monopolar or bipolar} \\ \end{cases}\end{split}\]

(4)¶\[\begin{split}\begin{align} P_{from,d}=&U_d(U_d-U_f) p_{e} \left(\frac{1}{R_{df}} \right) \\ P_{to,f}=&U_f(U_f-U_d)p_{e} \left(\frac{1}{R_{df}} \right) \\ -P_{e, rating} \leq& P_{to/from} \leq P_{e,rating} \qquad \forall e \in \mathcal{B}_{dc} \end{align}\end{split}\]

Class Reference: pyflow_acdc.Classes.Line_DC

class Line_DC(fromNode, toNode, r=0.001, MW_rating=9999, Length_km=1, polarity=Polarity.MONOPOLAR, name=None, N_cables=1, Cable_type=CableType.CUSTOM, S_base=100)¶

DC transmission line or cable.

Parameters:

fromNode (Node_DC) – Starting bus of the line.
toNode (Node_DC) – Ending bus of the line.
r (float, optional) – Resistance in pu.
MW_rating (float, optional) – MW rating of one cable.
km (float, optional) – Length of the line in km (stored as Length_km).
polarity (str, optional) – Polarity: 'm' (monopolar), 'b' (bipolar), or 'sm' (symmetric monopolar).
name (str, optional) – Line identifier.
N_cables (int, optional) – Number of parallel cables (stored as np_line).
Cable_type (str, optional) – Cable type from the built-in database, or 'Custom'.
S_base (float, optional) – Per-unit power base in MVA.
Length_km (float)

Example Usage:

import pyflow_acdc as pyf
# Create an AC node
pyf.initialize_pyflowacdc()
node1 = pyf.Node_DC('Slack', 1, 0,0,525,name='Bus1')
node2 = pyf.Node_DC('P', 1, 0,0,525,name='Bus2')
# In pu
line_1 = pyf.Line_DC(node1, node2, r=0.01, MW_rating=100, N_cables=1, name='Line1')
# Or by cable type in database
line_2 = pyf.Line_DC(node1, node2, S_base=100, Length_km=100, Cable_type='NREL_525kV_2500mm2')

DC line expansion¶

The expanded branch object is inside the Line_DC class.

The expanded branch \(e\) is modelled as:

(5)¶\[\begin{split}\begin{align} P_{from,d}=&U_d(U_d-U_f) p_{e} \left(\frac{n_e}{R_{df}} \right) \\ P_{to,f}=&U_f(U_f-U_d)p_{e} \left(\frac{n_e}{R_{df}} \right) \\ -P_{e, rating} \leq& P_{to/from} \leq P_{e,rating} \qquad \forall e \in \mathcal{E}_{dc} \end{align}\end{split}\]

DCDC converter¶

The DCDC converter is modelled very simply, with the set power injected into the toNode and the power drawn from the fromNode. To include losses there is a simple resistive model. For power flow calculations the power injected in either node is kept constant as the losses are pre calculated with the assumption of \(V_{to} = 1 pu\).

(6)¶\[\begin{split}P_{from} + P_{to} + P_{loss} = 0 \\ P_{loss} = \left(\frac{P_{to}}{V_{to}}\right)^2 \cdot R\end{split}\]

(7)¶\[P_{net}^{dc} += \sum P_{DCDC_{from}} + \sum P_{DCDC_{to}}\]

(8)¶\[\begin{split}\text{DCDC converter}\qquad & \begin{cases} P_{DCDC_{from}}, & \text{if } d \text{ is } \textit{from node} \text{ of } DCDC \\ P_{DCDC_{to}}, & \text{if } d \text{ is } \textit{to node} \text{ of } DCDC \end{cases}\end{split}\]

Class Reference: pyflow_acdc.Classes.DCDC_converter

Key attributes:

Attribute	Type	Description
`fromNode`	Node_DC	The starting node
`toNode`	Node_DC	The ending node
`R`	float	Resistance of the converter
`P_set`	float	Power set point of the converter
`MW_rating`	float	Power rating of the converter
`name`	str	Name of the converter
`geometry`	str	Geometry of the converter

Example Usage:

import pyflow_acdc as pyf
# Create an AC node
pyf.initialize_pyflowacdc()
grid = pyf.Grid(S_base=100)
node1 = pyf.Node_DC('Slack', 1, 0,0,525,name='Bus1')
node2 = pyf.Node_DC('P', 1, 0,0,525,name='Bus2')  
conv = pyf.add_DCDC_converter(grid,node1 , node2 ,Pset=0.1, r=0.0001, MW_rating=99999,name='DCDC1')

Inputs can be given in MW or pu. For pu use the r and Pset parameters. For MW use the R_Ohm and P_MW parameters.

References