Calculated Channels

Overview

Calculated Channels in Sift enable real-time transformation of time-series sensor data for precise anomaly detection, root cause analysis, and predictive maintenance. Engineers can extract actionable insights by applying expressions defined using CEL (Common Expression Language) directly to raw telemetry streams, known as Channels. This allows you to define custom metrics, derive new signals, or apply logic without modifying the original data. Sift supports the following two types of transformations that work across all supported data types:

• Stateless transformations: Stateless transformations process each data point independently, making them ideal for real-time computations like unit conversions or threshold checks.
• Stateful transformations: Stateful transformations retain context over time, enabling engineers to analyze historical trends, detect gradual system degradation, identify performance shifts, and uncover evolving failure patterns.

Settings

To create a Calculated Channel, you must define its properties (settings), including which Assets it applies to, which Channels it uses, and the logic (expression) it follows. The following table describes each setting available when creating a Calculated Channel:

Expression syntax

Calculated Channels are defined by expressions written in Common Expression Language (CEL). These expressions describe how raw telemetry should be transformed, using logic that is evaluated on each incoming row of data. An expression can include references to input Channels (for example, $1), constants, operators, and functions. Expressions may return numeric or string results and are used to compute derived values, apply thresholds, or combine multiple inputs in real time.

This section explains how expressions work in Sift, including how to reference Channels, use timestamps, apply math and logic, and work with built-in and User-defined Functions. Examples are provided using the CreateCalculatedChannel REST API endpoint to illustrate how expressions are structured when programmatically defining a Calculated Channel.

Channel references

When configuring a Calculated Channel, each selected input Channel is automatically assigned a shorthand variable such as $1, $2, $3, and so on, based on the order in which the Channels are chosen in the input Channels field. These variables act as placeholders in the expression editor and can be used to define transformation logic using CEL.

...
"queryConfiguration": {
  "sel": {
    "expression": "$1 * 1.8 + 32",
    "expressionChannelReferences": [
      {
        "channelReference": "$1",
        "channelIdentifier": "TEMPERATURE.CELSIUS"
      }
    ]
  }
}
...

Current t timestamp (ms)

When defining the expression of a Calculated Channel, the special variable t is always available. It represents the timestamp of the current telemetry point, expressed in milliseconds. This can be used in conjunction with functions like previous() to calculate time-based metrics such as sampling rate. Below is a focused example of the queryConfiguration section that computes the time difference between consecutive data points. This example maps $1 to a pressure Channel and calculates the time delta between the current and previous telemetry point. The rest of the request payload is omitted for clarity.

...
"queryConfiguration": {
  "sel": {
    "expression": "t - previous(t)",
    "expressionChannelReferences": [
      {
        "channelReference": "$1",
        "channelIdentifier": "PRESSURE.PSI"
      }
    ]
  }
}
...

Static scalar values

Calculated Channels support static scalar values such as numbers, strings, and booleans. These constants can be embedded directly in CEL expressions to define fixed thresholds, nominal baselines, or comparison values. The following example demonstrates how to subtract a static numeric value (100) from the input Channel $1 within a Calculated Channel expression.

"queryConfiguration": {
  "sel": {
    "expression": "$1 - 100",
    "expressionChannelReferences": [
      {
        "channelReference": "$1",
        "channelIdentifier": "PRESSURE.PSI"
      }
    ]
  }
}

Mathematical operators

Calculated Channels support standard arithmetic (+, -, *, /), comparison (>, <, >=, <=, ==, !=), boolean (!, &&, ||), and ternary (? :) operators in CEL expressions. These allow you to define rich, row-wise transformations across telemetry data. The following examples use the CreateCalculatedChannel REST API endpoint to demonstrate how these operators can be applied.

Arithmetic

You can use arithmetic operators to combine numeric Channels using +, -, *, and /. For powers and remainders, use the pow() and mod() functions respectively. In the example below, the voltage and current input Channels are assigned to $1 and $2, and multiplied to calculate power.

...
"queryConfiguration": {
  "sel": {
    "expression": "$1 * $2",
    "expressionChannelReferences": [
      { "channelReference": "$1", 
        "channelIdentifier": "VOLTAGE.VOLTS" 
      },
      { "channelReference": "$2", 
        "channelIdentifier": "CURRENT.AMPERES" 
      }
    ]
  }
}
...

Boolean and comparison

You can combine multiple logical and comparison operators to define complex conditions. In the example below, two Channels are used: temperature and pressure. Temperature is assigned to $1, and pressure to $2. The expression checks whether the temperature is between 20 and 30 degrees Celsius and whether the pressure is between 90 and 110 PSI. If all conditions are met, the result is true.

...
"queryConfiguration": {
  "sel": {
    "expression": "$1 >= 20 && $1 <= 30 && $2 >= 90 && $2 <= 110",
    "expressionChannelReferences": [
      { "channelReference": "$1", 
        "channelIdentifier": "TEMPERATURE.CELSIUS" 
      },
      { "channelReference": "$2", 
        "channelIdentifier": "PRESSURE.PSI" 
      }
    ]
  }
}
...

Ternary

The ternary operator uses the syntax condition ? option_1 : option_2 to return one of two values based on a boolean condition. In the example below, the temperature Channel is assigned to $1. The expression checks whether the temperature is greater than 30°C. If the condition is true, it returns High; otherwise, it returns Normal.

...
"queryConfiguration": {
  "sel": {
    "expression": "$1 > 30 ? 'High' : 'Normal'",
    "expressionChannelReferences": [
      { "channelReference": "$1", 
        "channelIdentifier": "TEMPERATURE.CELSIUS" 
      }
    ]
  }
}
...

Combining multiple time series with different timestamps

When an expression involves multiple time series, such as $1 + $2, Sift must join those series to compute each result. In typical systems, this would require exact timestamp matches between data points, meaning any values without aligned timestamps would be excluded from the calculation.

Sift uses an As Of join strategy to handle timestamp differences. Instead of requiring perfect alignment, it evaluates each unique timestamp across all input Channels and uses the most recent available value from each series as of that point in time. This approach allows expressions to compute meaningful results even when data streams arrive at different rates or with gaps. The example expression below adds the energy usage from two systems, regardless of whether their telemetry points are recorded at the exact same times.

...
"queryConfiguration": {
  "sel": {
    "expression": "$1 + $2",
    "expressionChannelReferences": [
      { "channelReference": "$1", 
        "channelIdentifier": "ENERGY.SYSTEM1.KWH" 
      },
      { "channelReference": "$2", 
        "channelIdentifier": "ENERGY.SYSTEM2.KWH" 
      }
    ]
  }
}
...

Functions

Calculated Channels support a wide range of functions that can be used in expressions to process and analyze time-series data. These functions allow you to transform raw inputs, evaluate conditions, and compute derived values in real time. They are organized into several categories based on the type of data or operation they target. You can view the full list of available functions directly in the expression editor when creating or editing a Calculated Channel.

Math functions

These functions handle numeric calculations including trigonometry, rounding, powers, roots, logarithms, and bitwise operations. They are used to transform or compare numerical input values directly within expressions.

String fuctions

These functions allow you to manipulate and evaluate string values. You can check for substrings, match regular expressions, and calculate string length.

List functions

These functions operate on lists, such as checking whether a list contains a specific value. Useful when working with sets of known values.

Iteration functions

These functions apply an expression conditionally based on a logical test. They are used to include or exclude results based on a dynamic condition.

Stateful functions

These functions compute values over time using rolling windows or past data. They are used to calculate moving averages, rates of change, or time-based aggregates.

User-defined Functions

User-defined Functions in Sift are reusable Common Expression Language (CEL) expressions that can be used in both Calculated Channels and Rules. They allow teams to define shared logic in one place and reference it across multiple expressions to ensure consistency and reduce duplication. To learn more, see User-defined Functions.

Other

These functions provide utility behavior such as accessing the current timestamp or converting data types like enum or numeric formats.