Let me start off by saying that we're really glad to be here, and I'm joined today so far
of how much I heard a lot of great talks, and I think it's great what we're doing here.
I really believe that through sharing software and knowledge together, that's a really
essential part in the challenges we're facing in the energy transition, but with all
this great thinking power, building data-driven applications, I think we can do great
things together, and I want to start off a little bit by asking you in the room what
you're back on this, so I'm on the by show of hands, see a little bit about which people
we have here, so we're going to talk about loadflow calculations and modeling the energy
grid, so for the people here in the audience, how many people of you have worked with
energy grid, modeling them, doing loadflow calculations, so I see some hands, so if we
talk about loadflow and sometimes we try to give really simple examples, but sometimes it
will be a little bit more in depth, but we'll keep interesting for all I hope.
So let's start with where this journey started, and the story for today, it actually started
five years ago, when TICE and I were working at a project at Aliander, and in this project
we are simulating the energy grid, so we are trying to see what effects we can expect for
the coming 40 years on the grid, and to do this we were developing a Python library,
which can model that, but over time we were switching teams, so we worked in all the teams,
but we thought, well, the things we were building then, they would really be useful in this
team as well, so we started sharing some code within Aliander in the source, and over time
other teams came along and it thought, oh, that's pretty cool, we want to use that as well,
so we started maturing the software, and that's how we built like an inner source library
for modeling the energy grid, and then five years later, we're standing here, and this
project has now become quite some bigger thing, at least in our eyes, and we're launching
it today, officially talking for the first time about it in this setting, yeah, thank you,
as an addition to the public model suite, so that's already a project within Aliander,
and we're adding a new package focused on data science applications, and that's what we're
going to talk about today, show some examples and show some applications we're using
it for, so let me start off by the base and that's the pougat model, so give a little bit
of background about that, because that's really important part of what we're doing, it's
really high performing load flow engine, developed in C++, which we use to model loads
on a network, we are not developing the core of the pougat models, so don't add two difficult
questions about physics, but we're using it, so we are involved in data science projects,
which really depend on having such a fast engine, so we have learned over time how that
can be used in different data science applications and both additions were needed and we're
now adding to that software, so what are we doing in that, so this is a really simple
application about an energy grid, but in the basis it's what we are modeling, and that's
how energy is going through the electricity network, and we work at Aliander, so we are working
at a distribution system operator, and we want to manage this grid on the shorter, on the
long term, and make sure that it stays within bounds, everybody stays happy and keeps
connected to the electricity grid, and that means we're modeling how this network is
evolving, and we'll simplify a lot in the story, so we'll talk about how nodes and lines
are connecting components in this grid, and we want to see whether they will be overloaded
in the future short term or long term, so what happens when, for example, lines get overloaded
they heat up, they become less efficient, which is of course not good in the first sense,
but in the end they will also break if they get overloaded, and when we put too much energy
through the grid, also the voltages for customers they get out of bounds, so they become
dysfunctional, so as data scientists at Aliander and so far engineers at Aliander will continue
to see developing applications which try to manage this for the organization, so that means,
for example, looking on the short term, so we're forecasting the next 24 or 48 hours on the
network, and for example, using things like we saw before about solar forecast for the short
term, and see what will happen to the energy grid tomorrow, and have ways to manage that if we
expect overloads, put the intenders on the short term and electricity market, for example, to prevent
that, and we do that by simulating, so simulations will be the key of what we're doing,
so we do a lot of simulations daily in which we approach all different scenarios on the electricity
grid and make changes to that grid, so if you look a little bit more into the future than
we're also working on how can we manage maintenance on the network or outages on the network,
so when things in the network fail, we need to go through all the different combinations of how we
would be able to solve like an outage in the network to keep everybody connected, and again,
that takes a lot of simulations interfacing that the network changing the network and seeing what
would be the impact, and then the situation as it is today is that we have a lot of new customers
or existing customers who want to use more electricity, and that, frankly, puts a big stress on
our network, and we are not always able to manage that, so we are continuously looking to find solutions,
flexibility in the grid to keep those customers still being able to be connected and making
forecast on how likely it will be, that solar farm needs to be disconnected for a couple of hours
in the year, and simulating on a large scale with that as well, life in tooling for people at
all the other who are responsible for that. And then last but not least, because that's
what Ty's is doing at his team, but also I saw the talk of at the earlier, we're looking
like the energy scenarios for 2050, 2060, and simulating like 40 years in the future, so you
can imagine if we want to calculate all those scenarios, well, we have a very powerful
engine which is able to do that, and now we're adding the interfacing options to that as well.
So we're going to go a little bit more into the nitty-gritty details of how this load flow
works, and then we're going to show how the package does this. In the essence, this is what
the Pougat model interface looks like, so this is a JSON interface towards the rate, towards the
load flow, which gives you output also in a array manner, and this is what already as it was
available in the Pougat model, and what we now build is a wrapper to really easily interact with this,
and to ask questions which are from a data science sense, very interesting about this,
so we want to ask questions about how this network is connected, which parts of it can be filtered
out, are interesting, is it overloaded, and what if we change something? So those are the things
we're focusing on with this package, and we would summarize that as preparation of the network,
interpretation of the outputs, and simulating that to close the loop. So I'm going to go a
little bit faster because I want to give some time also to ties, so it's, in essence, this is
the summary, it's a Python wrapper, which is, doesn't add a lot of dependencies, so it takes
Pougat model, adds a NumPy, has a managing of the grid output, and we also add that worst work
X to simulate the graph of the network, and with that I want to give it over to my colleague
to show you how that works, and look like.
Yes. Thank you. I'll just hold this one. So yeah, just to get into the more technical part of our
application, just to get back to what we were simulating, nodes, lines, and transformers,
you can represent them in two ways, either as a graph, which is quite natural, I guess, or as a
race, what we were already doing in the power grid model, and both can answer different questions.
So the race, you can use mainly for the load flow questions, or specific properties of specific
assets in the network, and the graph is mainly used for asking questions like connection topology
questions, and that, yeah, as a, yeah, just said, for one we used just rust work X, which is a
variant of a network X, if for those familiar with it, and the other one uses a numpy structure
the race, which was already present in the power grid model. So back to the questions like the
graph questions like this, these can be easily asked for my graph, and so we have methods like
these on our, in our package to find out which node is connected to another node, so for example,
the first node is connected to the four node, but it's not connected to the 10 node, or if you
ask the question like, what are the components within this network? This is one component on the
left side, and the 10, 11, 12 nodes is another component, and these can be very useful in our
data science applications. And then on the other hand, we have the array questions, so power flow
analysis or state estimation, we build an interface to the power grid model, application that was
already there, and so it's easy to interact with it, and it will update the results from the
power flow into our data science application that you're developing, made it a bit more easier in
our opinion, and another other features we added are filtering values, so the goal here is really
to make the life of the data scientist a bit more easier. The the power grid model is really
as a calculation core, and we are trying to make the experience for the data scientist a bit
easier, so we added things like filtering, updating values, and inheritance of, of, of,
detox data types, or for example, there's a line array on the right there, but you can add custom
fields to the array, or defaults, and you can even create your own complete custom array,
but it's all in under the hood, it's still non-pirease, so that won't affect performance, for example.
And then one question we you have, you might have is like, how do you manage both
representation at the same time, so that's also something that we added, we summarize them,
or we combine them both in one great object, and then we added functions to that object to
manage both representation, so there's a grass attribute, which contains the graph, the rougher
x graph, and then these are all the below that, they're all the arrays, and whenever a node is added,
it's both added to the graph, for example, and also added to the node array, and the save goes
for branches, or activating, or deactivating branches, so that makes it easier to also make a
dynamic grid, and simulate dynamic grid, add node to the grid, delete node for the grid, and then
see what that does, does for load flows, and stuff like that. That's basically our application,
and we hope we can find new people to join us in managing these building these applications,
and a comfort route, so thank you for joining us, and listening to our tour talk.
Yes.
Does the power of model only save nodes and versus the central component, or can you also,
if you have, like, smart, and the things from consumers, can you set to perform the model?
So I think that's part of, let me see the question.
So the question, I think if I summarise correctly, is can we also use measured data
into the network to inform the network? So that revolves a little bit more about the calculation
course, so it has different parts, so one part is the load flow engine, which is doing the physical
calculations of the load flow, but it also has a state estimation part in which you can input
measurements, and give them probabilities, so it's more like a statistical calculation,
and that's where we use it as well with measurements of, yeah, all points in the network.
Yep.
Do you use your correct to make the dynamic simulations as in the course of the simulation
in the change of the grid, or do you have this option of the simulation change of the
course?
No, we actually do dynamic simulation, so what we are, for example, in my project,
doing is simulating 10 years ahead, and we actually, during runtime, we simulate adding new
clients to the grid, so that will build new lines, new nodes, and then we do new flow,
it will sometimes cause congestion, then we have to replace lines with thicker lines,
or stuff like that, so in the runtime, during runtime, we're changing the grid, updating it,
and then seeing the results, any other questions?
How long does it take us to run a simulation?
I think it depends entirely on what you build in your own simulation, so we are doing, in my project,
we're simulating a lot of the work that Aliander is doing, so all kinds of congestion management
strategies and all kinds of ways of adding clients, so that's, yeah, we simulate 10 years in
about five hours or something a little bit, this now.
Yeah, so I'm not really sure I can repeat the question, but to answer the question, at least,
the power grid model is really designed for performance, so it's really fast in quick and
calculating all these things through, so it's entirely possible to, I think, get a quick answer,
but you have to build the simulation yourself.
So for low voltage grid, you mean, yeah, so we are using it also in low voltage, so it's focused on low
and medium voltage, so for us as a distributed.
Yeah, so the question is, is there a specific Dutch network model in this or not,
you should see this as like a general definition of how a network can be modeled, and we internally,
at Aliander, of course, modeling our network, but you can model every network you want in this,
whether it's low voltage, medium voltage in, yeah, the only other data is not included in the
project. And maybe also to add on the question about performance, so of course, it depends on the
use case, so I sort of talked about some strategic use cases, for example, ties is one where, yeah,
the speed is mainly cost concern, but it's also used in operation, operational,
where, of course, it is much more of the essence, yeah.
How badly will it go wrong if you use incomplete data, so we can get a little bit there, reverse end,
but there's not a click to provide margin, so I'm doing, is that completely useless all now, if I can
use a little bit, and what kind of incomplete data do you need?
The street map has fair round the grid, but no, there's gaps in things where people don't
want to show you. Okay, yeah, so the question is how this, the model handle, incomplete data,
and find it a little bit of a difficult question, but I'm going to try to answer, so I think
on one hand, on one hand, for the physical modeling, of course, it handles the data as it is
presented and has the power grid model has some validation options to make sure that it's
at least valid for the calculation, and then whatever you put in, it will work with, but for
example, we also have projects where we don't exactly know everything of the data, for example,
switching options in the network, we're not quite sure of, and then we actually use like the
status summation we were talking about, which can handle and certainly in the better way,
or we can simulate, for example, the different options, and see which is most likely, so there's
different ways of handling it, but it depends on what kind of data is missing, I think.
Thanks, iTunes, thanks! Thank you!