Skip to content

Vergelijkende analyses in Flux

Dit document beschrijft hoe je met Flux queries verschillende testruns of configuraties kunt vergelijken in Grafana.

Meerdere runs vergelijken

Multi-run dashboard met Grafana variabele

Eerst moet je een multi-select variabele in Grafana maken die beschikbare runIDs ophaalt:

import "influxdata/influxdb/v1"
v1.measurementTagValues(bucket: "Bries", measurement: "Wspeed", tag: "runID")

Vervolgens kun je deze variabele gebruiken in je queries:

// Haal windsnelheidsdata op voor meerdere runs
multiple_runs = from(bucket: "Bries")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r._measurement == "Wspeed")
  |> filter(fn: (r) => contains(value: r.runID, set: ${Runs}))  // Filtert op geselecteerde runIDs
  |> filter(fn: (r) => r._field == "value")
  |> map(fn: (r) => ({r with _value: float(v: r._value)}))
  |> aggregateWindow(every: 100ms, fn: mean, createEmpty: true)
  |> map(fn: (r) => ({
      _value: r._value,
      _time: r._time,
      _field: "Windsnelheid",
      run: r.runID  // Voegt runID toe als label voor in de grafiek
    }))
  |> yield(name: "multiple_runs_comparison")

Simultane weergave van verschillende parameters

Om verschillende parameters van meerdere runs te vergelijken:

// Functie om een parameter op te halen voor een specifieke run
getParameter = (measurement, runIdentifier, displayName) => {
  from(bucket: "Bries")
    |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
    |> filter(fn: (r) => r._measurement == measurement and r.runID == runIdentifier)
    |> filter(fn: (r) => r._field == "value")
    |> map(fn: (r) => ({
        _value: float(v: r._value),
        _time: r._time,
        _field: displayName,
        run: runIdentifier
      }))
}

// Haal dezelfde parameter op voor verschillende runs
param_run1 = getParameter(measurement: "Wspeed", runIdentifier: "173", displayName: "Run 173")
param_run2 = getParameter(measurement: "Wspeed", runIdentifier: "174", displayName: "Run 174")

// Combineer de resultaten
union(tables: [param_run1, param_run2])
  |> yield(name: "parameter_comparison")

Vergelijken van verschillende configuraties

Deze query vergelijkt het vermogen bij verschillende configuraties:

// Functie om vermogen te berekenen voor een specifieke run configuratie
powerCalc = (runIdentifier, configName) => {
  torque = from(bucket: "Bries")
    |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
    |> filter(fn: (r) => r._measurement == "Rtorque" and r.runID == runIdentifier)
    |> filter(fn: (r) => r._field == "value")
    |> map(fn: (r) => ({r with _value: float(v: r._value)}))
    |> aggregateWindow(every: 1s, fn: mean, createEmpty: false)

  speed = from(bucket: "Bries")
    |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
    |> filter(fn: (r) => r._measurement == "Rspeed" and r.runID == runIdentifier)
    |> filter(fn: (r) => r._field == "value")
    |> map(fn: (r) => ({r with _value: float(v: r._value)}))
    |> aggregateWindow(every: 1s, fn: mean, createEmpty: false)

  return join(
    tables: {torque: torque, speed: speed},
    on: ["_time"]
  )
    |> map(fn: (r) => ({
        _time: r._time,
        _value: r._value_torque * (r._value_speed * 0.10472),  // 0.10472 = 2π/60
        config: configName,
        _field: "Power"
      }))
}

// Bereken vermogen voor twee verschillende runs en vergelijk ze
run1 = powerCalc(runIdentifier: "173", configName: "Configuratie A")
run2 = powerCalc(runIdentifier: "174", configName: "Configuratie B")

union(tables: [run1, run2])
  |> yield(name: "config_comparison")

Statistische vergelijking van runs

Deze query berekent statistische kenmerken voor meerdere runs:

// Functie om statistieken te genereren voor een run
runStats = (runIdentifier, configName) => {
  from(bucket: "Bries")
    |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
    |> filter(fn: (r) => r._measurement == "Rtorque" and r.runID == runIdentifier)
    |> filter(fn: (r) => r._field == "value")
    |> map(fn: (r) => ({r with _value: float(v: r._value)}))
    |> window(every: inf)  // Groepeer alle punten
    |> mean()  // Bereken gemiddelde
    |> map(fn: (r) => ({r with config: configName, stat: "mean"}))
}

// Bereken statistieken voor meerdere runs
stats1 = runStats(runIdentifier: "173", configName: "Configuratie A")
stats2 = runStats(runIdentifier: "174", configName: "Configuratie B")
stats3 = runStats(runIdentifier: "175", configName: "Configuratie C")

union(tables: [stats1, stats2, stats3])
  |> yield(name: "statistical_comparison")

Vergelijking van TSR vs vermogen

Voor het vergelijken van de relatie tussen TSR en vermogen voor verschillende configuraties:

// Functie om TSR en vermogen voor een specifieke run te berekenen
tsrVsPower = (runIdentifier, configName, bladRadius) => {
  // Haal windsnelheid op
  wspeed = from(bucket: "Bries")
    |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
    |> filter(fn: (r) => r._measurement == "Wspeed" and r.runID == runIdentifier)
    |> filter(fn: (r) => r._field == "value")
    |> map(fn: (r) => ({r with _value: float(v: r._value)}))
    |> aggregateWindow(every: 1s, fn: mean, createEmpty: false)

  // Haal rotorsnelheid op
  rspeed = from(bucket: "Bries")
    |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
    |> filter(fn: (r) => r._measurement == "Rspeed" and r.runID == runIdentifier)
    |> filter(fn: (r) => r._field == "value")
    |> map(fn: (r) => ({r with _value: float(v: r._value)}))
    |> aggregateWindow(every: 1s, fn: mean, createEmpty: false)

  // Haal koppel op
  torque = from(bucket: "Bries")
    |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
    |> filter(fn: (r) => r._measurement == "Rtorque" and r.runID == runIdentifier)
    |> filter(fn: (r) => r._field == "value")
    |> map(fn: (r) => ({r with _value: float(v: r._value)}))
    |> aggregateWindow(every: 1s, fn: mean, createEmpty: false)

  // Join alle data
  return join(
    tables: {wspeed: wspeed, rspeed: rspeed, torque: torque},
    on: ["_time"]
  )
    |> map(fn: (r) => {
        // Bereken TSR
        tsr = r._value_wspeed > 0.1 ? 
              (r._value_rspeed * 2.0 * 3.14159 * bladRadius) / (60.0 * r._value_wspeed) : 0

        // Bereken vermogen
        power = r._value_torque * (r._value_rspeed * 2.0 * 3.14159 / 60.0)

        return {
          _time: r._time,
          tsr: tsr,
          power: power,
          config: configName
        }
      })
}

// Bereken voor verschillende configuraties
data1 = tsrVsPower(runIdentifier: "173", configName: "Configuratie A", bladRadius: 0.65)
data2 = tsrVsPower(runIdentifier: "174", configName: "Configuratie B", bladRadius: 0.65)

// Combineer resultaten
union(tables: [data1, data2])
  |> yield(name: "tsr_power_comparison")

Dashboard visualisatie tips

Bij het vergelijken van verschillende runs:

  1. Gebruik verschillende kleuren voor elke run om ze gemakkelijk te onderscheiden
  2. Normaliseer de tijdas indien nodig om runs met verschillende duur beter te vergelijken
  3. Voeg duidelijke labels toe die de configuratieverschillen aangeven
  4. Gebruik scatterplots voor het vergelijken van relaties tussen variabelen (bijv. TSR vs vermogen)
  5. Voeg statistieken toe zoals gemiddelden, maxima en standaarddeviaties