Welcome. Thanks for having me. My talk was actually about one o'clock this afternoon,
but I'll jump in now. This is the right – am I too loud? It's fine. Okay. Well, I am Nicholas
from Germany living in Amsterdam. I'm co-founder of CITA, Energy Flexibility, and we co-founded
the FlexMeasures project. I will briefly talk about the FlexMeasures project. Last time
at Boston, we also had to talk about some specifics. I like to introduce a project with
some specific applications. So last year, we talked about our Vehicle to Grid implementation,
where we use flex measures and home assistant. And today also, I'll go more on the developer
perspective as a developer, you would actually work with flex measures. I only have 15 minutes,
so I will fly over it a bit. Don't worry. I mean, let's not read every line of code.
It's just to give you an impression. How would it be like? With flex measures as an introduction,
we have been focusing on behind-the-meter optimization. So that's these other things
you find behind-the-meter. So there's enough complexity to run an optimization and find
the best running times for the things that are flexible here, which are usually EV charging,
batteries. And today, we talk about hot water storage. These things are not exactly behind-the-meter,
but they matter as well. In Netherlands, we have congestion on the grid that influences the
optimization of what you're doing. It's a constraint and dynamic energy prices. So then,
it becomes quite interesting as a problem. Right. So very briefly, flex measures is a platform
that takes in a lot of data, like meter data or prices, all these things. And it gives you the best
timing for your flexible assets as a very simplified picture of what it is. We have used it in a
couple of areas, like I mentioned, bi-directional charging, in industry, in water sanitation,
and now we're working on smart heating as well. Here's a little look on our dynamic visualization
of what flex measures knows at any given time. So this is from the VEP UI of flex measures. You
can replay what happened, what data flex measures knew, and what forecast it knew. But I want to
spend 10 minutes, have this very brief tour. What if you were an energy startup? Let's say you work
with smart heating, and you want to have the smart scheduling for your e-boiler, as an example.
So these are things you would like to do. I will go through each of those. And I'll touch upon a
couple of ways to interact with flex measures. You're writing your own flex measures, plug-in.
There's a Python client, there's a command line interface, of course, there's an API. And I'll
just, while I go through this list, everything will be touched for illustration, what are the
things you can do. The brief picture would be that there's a house where there's the e-boiler,
so your energy asset, with temperature readings. There's a flex measure server over here in the
cloud. And all of these things are going to happen. So there's a little bit of an architecture diagram,
but what we'll try to touch here. So the flex measures client will send temperature,
it will ask the server to compute a schedule for the boiler. There's a data platform where we can
get the prices. We'll have a cron tab because we will have to do some stuff just regularly.
And let's keep that in mind. So this is the very first step. You don't have to read everything,
but I'm just showing that we provide a cookie cutter template so you can quickly get up to
speed, have your own code structure. So you choose a name and a description and you say,
yeah, please give me the API blueprint. Blueprint is a word from the Flask system because flex
measures is a Flask application. And you get some kind of boilerplate like this.
And that's a boiler. This is the one endpoint we're doing here. What if we want to create a new
customer for this project? This is a lot of code. This is basically the endpoint we wrote as an
example. I'm not going to read everything. Basically, this is how you plug it in. It's going to be
plugged in flex measures and available as an endpoint. We're creating a user and an account.
And maybe this is the most interesting. So this is basically your business objects.
I will go a little deeper here. This is the same code roughly. So we're creating the boiler as an
asset. We're creating a couple of sensors. Here's two examples a bit bigger where we really define,
we tell flex measures how to handle this. What kind of units are we handling and the event resolution
and so that flex measures know what to do with them when data arrives. Schedules have to be made.
And then if that happened, if somebody called this endpoint and your account was made and you
would end up in the flex measures UI, you can see them here.
Next step, let's say we measure the temperature locally. You have your own sensor
and you want the temperature data to end up in flex measures as well.
Then here's a small example how to use the flex measures client. Basically, it provides you with
some nice code to work with more easily, but it actually uses the flex measures API in the background.
For fun, we actually had the temperature reading in Fahrenheit, which we say when we send it to
flex measures, the data is actually to be stored in Celsius and will automatically get it right.
So this is where a lot of work goes, as you can imagine.
But otherwise, this is just sending this reading. There's not much more.
You'll do this regularly from your local script that runs on your Raspberry Pi,
whatever you're doing there locally. One more step. So there's some external information we need.
Temperature is a local reading from your local asset. Prices are a good example of information
from some other third parties that just has to also be collected in flex measures.
One other example is weather forecasts. In this example, I'm showing that we actually wrote
a plugin for that. So we're cloning this plugin we wrote.
NSEU is the organization of European transmission system operators, and they provide a data platform
so you can get various things like prices, but also just a head allocations for all the transmission zones.
And so we say we want the Dutch transmission zone. Please give me the prices for that.
I'll talk and we configure everything. And actually then this is the command.
So through flex measures CLI, this plugin has registered a group of commands,
for instance, to import a head prices. Also, all of this is public how we wrote the plugin.
So if you call this regularly, let's say one time per day, you'll have the next day head prices
always in your system. Small visualization of one day of prices in the flex measures CLI.
Excuse me. Okay, now I'm not sure how much time do I have.
Eight minutes. All right, that's not too bad. But the main part now is you want to actually
tell flex measures to give you an optimized schedule for your boiler.
And here I'll show, I could do that via the flex measures client as well, but I'll just show
how to use the API directly. This is not so interesting, of course, you have to have an
authentication token. But I have to spend a bit more time here. A lot of time we spend when we
made flex measures is how you configure the problem. How do you tell flex measures
the constraints of the problem in the back flex measures will actually take your information
about your setup and your problem. Basically, you could call that business rules,
and really translate that dynamically into a linear program. So flex measures contains,
I think three different algorithms, basically, we have one that's focusing on storage based
problems. And that's what we also use for heat, heat batteries, we call them. We have one for,
if you just want to allocate processes. But it's a very important part for developing a new
application that you can tell the flex measures server, this is how I want you to treat this
problem. Here's the constraint you don't know about, or here's a local thing you don't know about.
And that's where we're working on two things, the flex model and flex context. So flex context
would be, well, these are the prices that are relevant. We also have a project where we don't
use prices, but we use the CO2 signal, the CO2 content of the grid that is anticipated.
But the flex model is a bit more detailed. So this is not all the things you can do.
But basically, wishing, well, the state of charge of this heat battery is this many kilowatt
hours. So that's local knowledge you have. Here's some constraints. I can't go under this.
We don't want to go under this. And also, here's a target for you. In the morning,
I need to have this much energy content in my battery. I think this could also be a percentage.
We're pretty flexible there. Some other constraints. You can see how these translate
actually into constraints of a problem. And then you call our API to say, well, for this,
the fill rate that I want a schedule for that, please start. And that will actually trigger
a scheduling job. And then flex motors will usually pass this on to a worker. So we, in our
implementations, we have a web worker and computation workers that will handle those. And then you
can call this, get endpoint to check if your computation is ready. It will usually not be
ready after three seconds, but soon after. And then, yeah, you get your values here.
So then you can implement these settings locally. You can, let's say you ask for a schedule for
12 hours, then your local gateway has the plan for 12 hours. If there's anything that changes
on the ground, you just ask for a new one. You'll update as we go. So that's general behavior.
I'm almost done with, with a, you know, two of the force here. One thing we want to maybe do is
in flex measures have a nice dashboard that has the most crucial data on top of each other for
some inspection. And then, well, you can actually put that on the boiler asset. And then you,
in flex measures, you have these nicely stacked, right? You want to see what you've been using
for optimization on top. Although this comes from a different asset. This is something for everybody.
All the assets can use this. And we use, as you remember, we had like four sensors or so that
are relevant, but we just decided these two other ones we want to see. So we can easily see that
in a period of low prices, flex measures has tried to, you know, fill the, fill the boiler at those
times. Some signal here. I'll skip over this a bit because, yeah, I originally had a 25 minutes idea
about this. Just as very quickly, we also noticed it's very important to also do some reporting.
In flex measures, give some logic about that, that you combine some sensor data so you get
the outputs of what happened, for instance, like costs. You know, that's very important. Sorry.
And that can become a C like a minus well that you regularly say, okay, now the day has happened,
we optimize as we could. Let's calculate how much energy costs we had here. So combine just the
prices and the fill rate, which happened. But we also saw already that's that's many more interesting
computations that people want. So this is a very simple multiplication. But we've made a pretty
complicated architecture so you can actually have a lot of bring a couple sensors together
for a new result that even can be used further in your next optimization or so. It's a very
flexible system we've built here. And this is the project website. From there, you'll find the
the GitHub, you find the read the docs, you'll find more information like I was interviewed for
Python podcast where maybe I go into more detail. The mailing list contact, everything's there.
You can also just write me directly, of course, if you're interested in doing something yourself
and joining our TSC, the technical steering committee, everybody's welcome. And that's it.
Yeah, there's lots of things to do, of course, I've touched upon a couple things,
applications like vehicle to grid or smart heating and industry. But the roadway is still,
of course, filled. There's so so much things in the energy behind the meter and a bit above to
optimize. Thanks. We have time for question, then.
If someone wants to ask one question,
you said that you create a linear program. And what solver do you use to solve this program?
What kind of solver? Yeah, we have we work with two solvers now.
You could, of course, also use Cplex, but we've used two open source ones.
All right, now they don't come to my head. Sorry.
Hi. Yeah, we switched to that one. And we had a different one before that are both possible.
So you can just those are shipped with a Docker image even so you can just configure that which
one you want to use. But you can also we use pyomo as a representation for the problem. So
everything that works with pyomo, which is you can use that as well.
Thank you so much.