Case Aggregate Functions

Functions for aggregating values across all events within the same case.

Understanding Case Aggregates

In process mining, a case represents a single instance of a process (e.g., one order, one ticket, one customer journey). Each case contains multiple events (the individual steps or activities).

Case aggregate functions calculate values across all events in a case, making the result available at each event. This allows you to:

• Calculate total values for a case (e.g., total order amount)
• Find patterns within cases (e.g., count of rework events)
• Compare individual events to case-level statistics

Common Patterns

• Calculate Case Totals:

  caseSum(ItemAmount)           // Total order value
  caseCount()                   // Number of events in case
  caseCountDistinct(Resource)   // Unique resources involved

• Find Extremes:

  caseMin(Timestamp)            // First event time
  caseMax(Timestamp)            // Last event time
  caseMax(Timestamp) - caseMin(Timestamp)   // Total case duration

• Conditional Aggregates:

  caseCountIf(Status == "Error")            // Error count
  caseSumIf(Amount, Activity == "Payment")  // Total payments
  caseAvgIf(Duration, Activity == "Review") // Avg review time

• Compare Event to Case:

  Duration / caseAvg(Duration)  // Is this event faster/slower than average?

Running Aggregates

Running aggregates calculate cumulative values up to and including the current event. As you move through the events in a case chronologically, the running value updates.

This is useful for:

• Tracking cumulative totals (running sum)
• Identifying event position (running count)
• Calculating rolling averages

Running Aggregate Patterns

• Cumulative Totals: Track how a value accumulates over the case:

  caseRunningSum(ItemAmount)   // Cumulative order total at each event

  Event	Amount	caseRunningSum(Amount)
  1	100	100
  2	50	150
  3	75	225

• Event Position: Identify where an event falls in the case sequence:

  caseRunningCount()   // 1, 2, 3, 4...

• Rolling Average: Calculate the average up to the current point:

  caseRunningAvg(Duration)   // Average duration so far

• Position-Based Logic:

  if(caseRunningCount() == 1, "First", 
     if(caseRunningCount() == caseCount(), "Last", "Middle")
  )

Statistical Functions

Statistical functions for analyzing the distribution of values within a case.

• Percentiles: Find where a value falls relative to others in the case. Pass the percentile as a fraction from 0 to 1, so 0.9 means the 90th percentile:

  casePercentile(Duration, 0.5)   // Median duration in this case
  casePercentile(Duration, 0.9)   // 90th percentile

• Variance: Measure how spread out values are:

  caseVariance(Amount)           // Variation within this case

Related topics

• Expressions Overview: all expression functions.