# Aggregierte Zeitreihendaten

Die `Timeseries`-Datenfunktion im ENLYZE Power BI Connector ermöglicht das Abfragen von Maschinendaten innerhalb eines definierten Zeitraums.

Dieses Tutorial zeigt, wie Zeitreihendaten basierend auf anderen Datenstrukturen, die Zeiträume definieren (z. B. Produktionsaufträge), abgefragt und aggregiert werden, um Key Performance Indicators (KPIs) zu berechnen.

### Anwendungsfall: Berechnung der spezifischen Energie pro Produktionsauftrag

Hier wird der Prozess zur Berechnung des **spezifischen Energie** für jeden Auftrag in einem Werk mit fünf Produktionslinien beschrieben. Dazu werden Maschinenvariablen benötigt, die Folgendes messen:

* **Linien-Durchsatz** (verarbeitete Produktmenge)
* **Wirkleistung** (Energieverbrauch pro Produktionslinie)

#### **Schrittübersicht**

1. Zeitreihendaten für Durchsatz und Wirkleistung während jedes Produktionsauftrags abfragen.
2. Die Daten aggregieren, um die Gesamtproduktionsmenge und den gesamten Energieverbrauch pro Auftrag zu erhalten.

Anschließend lässt sich die spezifische Energie berechnen:

## 1. Erforderliche Daten importieren

Folgende Elemente aus dem ENLYZE Power BI Connector werden benötigt:

* Die `Timeseries`-Funktion
* Die `Variables`-Tabelle
* Die `Production Runs`-Tabelle

{% hint style="warning" %}
**Hinweis**\
Die `Production Runs`-Tabelle ist spezifisch für dieses Beispiel. Jede Tabelle mit separaten `start`- und `end`-Zeitstempeln kann stattdessen verwendet werden.
{% endhint %}

## 2. Relevante Variablen filtern

Bevor Zeitreihendaten abgefragt werden, müssen die relevanten Maschinenvariablen gefiltert werden.

* Eine Kopie der `Variables`-Tabelle erstellen und `FilteredVariables` nennen.
* Die Tabelle filtern und nur die für die Analyse relevanten Variablen beibehalten.
* Die Variablen nach `display_name` sortieren

## 3. Zeitreihendaten pro Auftrag abfragen

Als Nächstes wird eine modifizierte Version der `Production Runs`-Tabelle erstellt, die eine zusätzliche Spalte für Zeitreihendaten enthält.

{% hint style="success" %}
**Tipp**\
Vorher die `Production Runs`-Tabelle filtern, um nur relevante Läufe einzubeziehen. Dies reduziert die Verarbeitungszeit.
{% endhint %}

### **3.1. Hilfsfunktion `fxGetMachineVariables` erstellen**

Da jeder Auftrag einer bestimmten Maschine zugeordnet ist, wird eine Funktion benötigt, um die korrekten Variablen für jede Maschine abzurufen.

1. Eine leere Abfrage erstellen und `fxGetMachineVariables` nennen.
2. Eine Power Query M-Funktion definieren, die `FilteredVariables` basierend auf der Maschinen-UUID filtert:

   ```powerquery
   = (machine as text) as table =>
       let 
           SelectedVariables = Table.SelectRows(FilteredVariables, each [machine] = machine)
       in
           SelectedVariables
   ```

### **3.2. Hilfsfunktion `fxTimeseriesForRuns` erstellen**

Nun wird eine Funktion definiert, die die `Timeseries`-Abfrage auf jede Zeile der `Production Runs`-Tabelle anwendet.

1. Eine leere Abfrage erstellen und `fxTimeseriesForRuns` nennen.
2. Eine Power Query M-Funktion definieren, die Zeitreihendaten für jeden Auftrag abruft:

   ```powerquery
   = (runs as table) as table =>
       let
           TimeseriesForRuns = Table.AddColumn(
               runs, 
               "timeseries", 
               each Record.ToList(
                   Timeseries(
                       fxGetMachineVariables([machine]), 
                       [start] as datetimezone, 
                       [end] as datetimezone, 
                       "1h", 
                       "avg"
                   ){0}
               ){0}
           )
       in
           TimeseriesForRuns
   ```

### **3.3. Tabelle `TimeseriesPerProductionRun` erstellen**

1. Eine leere Abfrage erstellen und `TimeseriesPerProductionRun` nennen.
2. Die `fxTimeseriesForRuns`-Funktion auf die `Production Runs`-Tabelle anwenden:

   ```powerquery
   = fxTimeseriesForRuns(#"Production Runs")
   ```

Die resultierende `TimeseriesPerProductionRun`-Tabelle enthält alle Aufträge mit einer zusätzlichen **timeseries**-Spalte, in der die zugehörigen Zeitreihendaten gespeichert sind.

## 4. Zeitreihendaten für Visualisierungen aggregieren

Nun werden die abgerufenen Zeitreihendaten aggregiert, um **Gesamt-Durchsatz** und **Gesamtenergieverbrauch** pro Auftrag zu berechnen.

### **4.1. Aggregationsfunktion `fxAggregateTimeseries` erstellen**

Diese Funktion verwendet die `TimeseriesPerProductionRun`-Tabelle und aggregiert die Werte in zusätzlichen Spalten.

In diesem Beispiel wird `List.Sum` zur Aggregation genutzt. Alternativ können Methoden wie `average`, `min`, `max`, `first` oder `last` verwendet werden.

1. Eine leere Abfrage erstellen und `fxAggregateTimeseries` nennen.
2. Eine Power Query M-Funktion definieren, die aggregierte Werte berechnet:

   ```powerquery
   = (RunsWithTimeseries as table) =>
       let
           AggregatedThroughput = Table.AddColumn(
               RunsWithTimeseries, 
               "total_throughput", 
               each List.Sum(Table.Column([timeseries], Table.ColumnNames([timeseries]){1}))
           ),
           AggregatedEnergy = Table.AddColumn(
               AggregatedThroughput, 
               "total_energy", 
               each List.Sum(Table.Column([timeseries], Table.ColumnNames([timeseries]){2}))
           ),

           // Set column types to number
           ResultWithTypes = Table.TransformColumnTypes(AggregatedEnergy, {
               {"total_throughput", type number},
               {"total_energy", type number}
           })
       in 
           ResultWithTypes

   ```

### **4.2. Aggregationsfunktion anwenden**

Die `fxAggregateTimeseries`-Funktion auf `TimeseriesPerProductionRun` anwenden:

```powerquery
= fxAggregateTimeseries(Quelle)
```

{% hint style="success" %}
**Glückwunsch!**\
Du hast erfolgreich Zeitreihendaten für jeden Auftrag abgefragt und die Werte aggregiert
{% endhint %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.enlyze.com/integrations/power-bi/tutorials/aggregierte-zeitreihendaten.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.