Baselining

Flexibility is the ability to deviate from normal consumption/production behaviour based on a signal. In order to offer flexibility, we therefore need to define this normal behaviour, which we call the "baseline".

Understanding Baselining

Baselining is crucial because it defines what "normal" operation looks like for your site or resource. While perfect prediction is impossible, we expect baselines to be reasonable estimates based on historical data, weather forecasts, and operational knowledge.

Some deviation between baseline and actual operation is expected, but significant discrepancies can affect your market participation and compensation. The platform tracks baseline accuracy and provides feedback to help improve predictions.

Requirements

Baselining needs to happen on both the level of the site, as well as the resource(s). The Powernaut platform thus expects you to submit baselines for both.

warning

You won't be able to offer flexibility if you haven't reported a baseline for both the resource, and its site for the time window in which you wish to offer flexibility.

Frequency and Length

Baselines have to be reported

• every 15 minutes,
• for the next hour,
• for every quarter hour of the day.

Example

Before 12:00 the baselines values for 12:00-13:00 (12:00, 12:15, 12:30, 12:45) have to be sent. This applies to every hour of the day.

Granularity

Baselining is done with a granularity of 15 minutes (a quarter-hour). This means that you need to have a prediction of consumption/production behaviour for the hours, in intervals of 15 minutes.

Timing

We strongly recommend reporting baselines for the next 24 hours and continuously updating them with your latest predictions. While not strictly required, providing longer-term forecasts significantly improves your chances of being activated, as it:

• Gives the platform more opportunities to find matching flexibility needs
• Allows for better optimization of your resources
• Increases the likelihood of your bids being selected

The absolute minimum requirement is having a baseline for the specific time window in which you want to offer flexibility.

Power type

The power type indicates the type of baseline power you're reporting. This can be either active power (kW) or reactive power (kVAR).

More information on the difference can be found here.

Default

The default power is active power, reported in kW.

Reporting baselines

Let's have a look at how to report an actual baseline.

note

In these examples, we'll report on a site level. You can modify them to resource-level reporting by replacing connection-point with resource in the URL path.

Python

import requests
import json

url = "https://api.powernaut.io/v1/connect/sites/<uuid>/baseline"

payload = json.dumps({
  "start": "2024-07-01T14:00:00Z",
  "values": [
    "1",
    "1",
    "2",
    "2"
  ]
})
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer <token>'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

JavaScript

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");
myHeaders.append("Authorization", "Bearer <token>");

const raw = JSON.stringify({
  "start": "2024-07-01T14:00:00Z",
  "values": [
    "1",
    "1",
    "2",
    "2"
  ]
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("https://api.powernaut.io/v1/connect/sites/<uuid>/baseline", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

Java

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"start\":\"2024-07-01T14:00:00Z\",\"values\":[\"1\",\"1\",\"2\",\"2\"]}");
Request request = new Request.Builder()
  .url("https://api.powernaut.io/v1/connect/sites/<uuid>/baseline")
  .method("POST", body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("Authorization", "Bearer <token>")
  .build();
Response response = client.newCall(request).execute();

Go

package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://api.powernaut.io/v1/connect/sites/<uuid>/baseline"
  method := "POST"

  payload := strings.NewReader(`{"start":"2024-07-01T14:00:00Z","values":["1","1","2","2"]}`)

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")
  req.Header.Add("Accept", "application/json")
  req.Header.Add("Authorization", "Bearer <token>")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

C#

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://api.powernaut.io/v1/connect/sites/<uuid>/baseline");
request.Headers.Add("Accept", "application/json");
request.Headers.Add("Authorization", "Bearer <token>");
var content = new StringContent("{\"start\":\"2024-07-01T14:00:00Z\",\"values\":[\"1\",\"1\",\"2\",\"2\"]}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

cURL

curl --location 'https://api.powernaut.io/v1/connect/sites/<uuid>/baseline' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'Authorization: Bearer <token>' \
--data '{"start":"2024-07-01T14:00:00Z","values":["1","1","2","2"]}'

In this practical example, we've reported the baseline for a site starting at 2PM, for the next 4 quarter-hours. In essence, this tells the platform that you expect the site to:

1. Consume 0.5kWh in the next 30 minutes (1kW each quarter-hour)
2. Consume 1kWh in the 30 minutes thereafter (2kW each quarter-hour)

We have left out the type of power, making it default to active power (in kW).

In the next section, we learn how to report deviations from this baseline using bids.