Data Science analysis toolkit

[jaapschoutenalliander]

At Alliander we have developed several application extending the Power Grid Model.
Our packages add Data Science features in Python and provide an interface to the PGM. With our packages, you can:

• Visualize the power grid in an intuitive and interactive way
• Simulate grid behavior under different scenarios
• Apply graph algorithms to build advanced data-science applications
• And much more

---

IMPORTANT NOTE:
We are exploring the options to add this as an extension to the power-grid-model suite and would like to connect to possible users within the community. Please reply to this discussion if you are interested! Additionally, please include your organization name and a short description of how you will be using this.

---

Examples from our readme:

from alliander_python_grid.model.grids.graph import GraphGrid
from alliander_python_grid.model.arrays import (
    LineArray,
    TransformerArray,
    NodeArray,
    SymLoadArray,
    SourceArray
)
 
grid = GraphGrid.empty()
 
# This defines a a circle with 4 rails of 10kV and a 400V rail (12)
# (OS) 1 -- 2 -- 3 -(NOP)- 4 -- 5 -- 1 (OS)
#           | (trafo)
#           12
 
# Add Substations
substation = NodeArray(
    id=[1],
    u_rated=[10_500.0],
)
grid.append(substation)
 
# Add Lines
lines = LineArray(
    id=[6, 7, 8, 9, 10],
    from_status=[1, 1, 0, 1, 1],
    to_status=[1, 1, 0, 1, 1],
    from_node=[1, 2, 3, 4, 1],
    to_node=[2, 3, 4, 5, 5],
    i_n=[200.0] * 5,
    r1=[0.1] * 5,
    x1=[0.03] * 5,
    c1=[0.0] * 5,
    tan1=[0.0] * 5,
)
grid.append(lines)
 
# Add a transformer
trafo = TransformerArray.empty(1)
trafo.id = 11
trafo.from_status = 1
trafo.to_status = 1
trafo.from_node = 2
trafo.to_node = 12
trafo.u1 = [10_500]
trafo.u2 = [400]
trafo.sn = [30e6]
trafo.clock = [12]
trafo.uk = [0.203]
trafo.pk = [100e3]
 
grid.append(trafo)
 
# Add Nodes
nodes = NodeArray(
    id=[2, 3, 4, 5, 12],
    u_rated=[10_500.0] * 4 + [400.0],
)
grid.append(nodes)
 
# Loads
loads = SymLoadArray(
    id=[13, 14, 15, 16],
    node=[2, 3, 4, 5],
    type=[1] * 4,
    p_specified=[1_000_000.0] * 4,
    q_specified=[1_000_000.0] * 4,
    status=[1] * 4,
)
grid.append(loads)
 
# Add Source
source = SourceArray(id=[17], node=[1], status=[1], u_ref=[1])
grid.append(source)

Doing loadflow calcultations using this grid

When a grid has been created a loadflow calculation can be executed on it.
This functionality is provided by the ApgPowerGridModel interface.

from alliander_python_grid.load_flow import ApgPowerGridModel
apg_pgm = ApgPowerGridModel(grid=grid)
apg_pgm.create_input_from_grid()
output = apg_pgm.calculate_power_flow()
output

Adding elements to an existing grid

You can modify an existing grid, for example when simulating a change in the network.
All changes between the grid representation are managed.

new_line= LineArray(
    id=[-1],
    from_status=[1],
    to_status=[1],
    from_node=[2],
    to_node=[5],
    i_n=[200.0] ,
    r1=[0.1],
    x1=[0.03] ,
    c1=[0.0],
    tan1=[0.0] ,
)
grid.add_branch(new_line)

Visualize a grid

There's a module that uses cytoscape.js to visualize a grid in your browser

...
grid.visualize()

Or with coordinates:

Creating a grid using the Generator

Another option is to create a random Grid using the RadialGridGenerator.
This can create a topologically sound grid, without cycles (radial).

During initialisation of the RadialGridGenerator the grid_class should be provided.
The generator can also be seeded to create reproducable results.

from alliander_python_grid.data_source.generator.grid_generators import (
    RadialGridGenerator,
)
from alliander_python_grid.model.grids.graph import GraphGrid
 
grid_generator = RadialGridGenerator(grid_class=GraphGrid)
grid = grid_generator.run(seed=0)

Apply graph algorithms to the grid

When the Grid is of the subclass GraphGrid, a networkit graph is also made.
This graph can be used to apply graph-algorithms to, like find all paths from one node to another.

grid.graphs.active_graph.get_all_paths(56, 41)

[IrenaDk]

Here are my comments for the features in order of most to least important, according to my experience:

• Graph algorithms are very useful features to be added to the PGM, as they can be used for analysis and selections in the network. I will use them.
• Visualisations can be a nice addition and may lead to an increased use of PGM. They can be used both for displaying results to our end users as well as for debugging (nice but not mandatory). So, if available, we would be using this.
• I don't see a large benefit of being able to create a grid, add, and modify elements through this wrapper when the same can be done directly in PGM. Let me know if I am missing something here. We already have an implementation in which we are directly using PGM, so we would need a good reason why to change (and hopefully not too much effort)
• The grid generator is also a nice-to-have feature. I see more use for it by people in academia who do not have access to actual networks. However, in that case, they may also use more IEEE or other standard networks that are commonly used. We won't be using this.

I am working in Alliander, FYI.

[Thijss]

Thank you for sharing!

Most of the above-mentioned features are currently packed into a single package. Before publishing as open source, we'll have to decide on which features to combine/separate. Next week, I am planning to do some research on that. Your input on what you'll (not) be using is helpful there too.

I don't see a large benefit of being able to create a grid, add, and modify elements through this wrapper when the same can be done directly in PGM. Let me know if I am missing something here. We already have an implementation in which we are directly using PGM, so we would need a good reason why to change (and hopefully not too much effort)

To clarify: these classes and function mainly exist to keep both the graph and array representations in sync when changing elements in the grid.

[NielsDirks]

I do agree with @IrenaDk on most parts.

• I have not used graph algorithms so far, but I have used them with PandaPower and I can think of implementations in my current project. So indeed I would use this as well.
• In my opinion visualisations would be very usefull. I would even put this as most important. I was hesitating between using PandaPower and PGM because of the lack of visualisation. (In the end I am very happy I chose PGM because of the speed.) Visualising the grid including node voltages, branch currents, (re)active power flow and component loading would be very helpful.
• I use the Vision converter to create a grid, so I am not familiar with the 'create grid' functions. However, I am currently modifying the 'input_data' array to add components after the grid has been created/loaded from Vision, so the function to add (and maybe remove) components from an existing grid would be a nice one.
• I would not be using the random grid generator as I am able to use Vision. However, as @IrenaDk already mentioned, including some standard IEEE grids would be a nice adition for the use by people who do not have acces to such software.
• Last, for the load flow function. What is the difference/benefit of this function over PGM itself, as it looks similar?

I am currently doing my TU/e Electrical Engineering graduation project at Enexis.

[jaapschoutenalliander]

Thank you for your replies. Indeed what Thijs says the interface through APG provides an easy way to keep modification in sync between representations which can be used in preprocessing or simulations. As Niels says, after loading a grid from a datasource we also do some application specific checks through this interface (ie. remove unconnected components). The combination of graphs and arrays makes this an easy thing to do.

On the part about the load-flow. This provides no extra-functionality but couples the Grid object to the power-grid-model as to make it easy to do modification as mentioned above and then call the power-grid-model.

[TonyXiang8787]

@jaapschoutenalliander @Thijss

The current alliander-python-grid defines its own dataset array including additional attributes. However, this will result in unneeded copy action to real PGM arrays.

In this issue PowerGridModel/power-grid-model#82, we are thinking about to automatically generate the PGM array classes with all the PGM attributes. And also allowing sub-classing for additional attributes. In the backend the additional attributes should be in separate arrays, so that the main attributes will have one-to-one mapping to PGM internals.