> For the complete documentation index, see [llms.txt](https://docs.enlyze.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.enlyze.com/integrations/power-bi/tutorials/aggregierte-zeitreihendaten.md).

# 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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.