 Welcome to another Oploplanar video. This time we'll be looking at the cheap time scheduling example, one of the examples in Oploplanar 6.2. So let's open the example, and let's open a data set. In this example, we have to assign tasks, which you can see here. We have 24 tasks in this small data set, to machines and to a starting time. So as you can see, we have two machines here in this data set, a green and a yellow machine. And for each of the tasks, we have to decide on which of those two machines it will run. And remember that the machines have a certain capacity. For example, the green machine and also the yellow machine have a capacity of about 2,500 resources per time period, per minute, basically. And we need to make sure that when we put multiple tasks on the same machine, that they can handle the requirements of each task. So each task has a certain number of resources that it requires. So big tasks might, for example, require 2,000 resources. So then there's still room to run another task at the same time on the same machine, which as long as that other task doesn't consume more than 500 resources. The second thing we need to decide for each task is when do we start this task. So each task has a starting, has a certain duration. As you can see here, for example, task 0 takes about 10 time units. And task in the second task, task 1 takes about over 20 time units, as you can see here. And we can schedule them at any time as long as the task is scheduled between the from and the to limits. So they're currently all set at their from limit. But you can see, for example, this first task, this is the to limit, that little dot is the to limit. We can actually move it out in time towards the end. We can't move it out until the end of the time zone, so into the evening. But we can schedule it a little bit later in the morning. So these time periods, actually, they resemble the hours of a day. So let's see how we can do that. Let's solve this a little bit, right? So now we have a solution. What we see here is that you can see on the bottom the capacity. And you can see, for example, I'll just take another visualization of this problem. I'll group them by machine. You can see, for example, the green machine at the beginning, it has the first three time periods. It's not being used. As soon as it's been used by this first task here, you can see that the capacity goes down. The available capacity goes down because it's being used, not entirely, but mostly by that task. You can see as the second, the task number one here also is added, that the capacity goes down even more. This actually is quite clear that the second task is using far less resources. Only the difference between these two points, right? But you can see that that's still fine. You can see that that no point of capacity goes below zero. So it is never used more than that's available. So we don't have any hard constraints broken anymore. We did have that if we just ran it very, very quickly. Oh, we have to run it very, very quickly, apparently, right? Still too slow. But if you look closely, you will see that the hard constraints were temporarily broken. And then the capacity is overused, of course. Now, that being said, that's quite simple. It's a form of cloud balancing, although we have this extra parameter where we can actually the task sooner or later into during the day period. But then, of course, there's another constraint. There's a soft constraint too. The soft constraint is about the price, the power price, right? So the price of electricity of power for big companies, it actually fluctuates during the day. So for example, at the middle of the night, it's actually quite cheap to buy electricity or it used to be, depends on the electricity infrastructure of the country, of course. But for example, between five and nine, eight o'clock, you really, it's really expensive to buy electricity because everybody is using electricity at that time. So the price goes up a lot, as you can see here, right? So normally the price is below 500 and then all of a sudden it's 2000 during those hours. So you don't want to be scheduling tasks during those hours because you don't want to be consuming electricity at that point in time, okay? So if you optimize a little bit more, what you can see is we will find better and better solutions which basically lower our power costs over time, okay? So that's basically the example. Let me just show you a bigger data set to show that we can handle bigger data sets too, right? So this is a bigger data set. I'll just first with ungrouped. You can see that if you give it some time, it's improving it and it's pushing more and more tasks away from these expensive hours, of course, right? You can also see that on the capacity of the machines, there are more and more machines have lots of capacity when it's too expensive to run them. Now the interesting thing, of course, what we can do is let me just change the grouping again. We can see that over here, we can see it even more than it's really trying to not use these hours when it's very expensive to use electricity. And of course, we can scale to even much bigger problems than these, we have far bigger data sets. As you can see, have up to 40 data sets. Thanks for watching this demonstration. If you want to know more about Oploplaner, just go to the website oploplaner.org. And if you want to try this example yourself, just download the zip and zip it and run the examples. Thanks for watching. Bye.