Property Names of Activities and Relationships

What the technical names such as relStartTimestamp, absStartTimestamp, transDur and aggProp.quantity mean, in which unit their values come, which label the details table shows for them and which shorter names Minerva gets.

The Analyzer and Minerva read the same process data from Noreja. Each activity and relationship comes with properties that have technical names such as relStartTimestamp, transDur or aggProp.quantity. You may see these names in Minerva's answers and in the steps it shows while it works, or when you work with Noreja's interfaces. This page explains what each name means, in which unit its value comes and which label the details table shows for it. For the ideas behind the figures, see From Events to Process Model: What Is Aggregated Where and Quantities and Cardinalities.

Where the Names Appear

Data	What it contains	How the names look
Graph data	The process graph: all activities and relationships of a process model, a case model or a case, with the key figures of each. The Analyzer draws the graph from it, and Minerva reads it with its graph tools.	One field per property, for example `relStartTimestamp`. Minerva gets shorter names; see "Names in Minerva" below.
Property lists	All properties of one activity, one relationship or the whole graph, including the source data. The details table under the graph shows this list with readable labels; Minerva reads the same list when it looks into one element.	Name and suffix, for example `relStartTimestamp.avg`. The suffixes are explained below.

Units and Formats

Relative times and durations (names starting with rel, transDur, cycleTime): whole seconds. 86400 is one day. The details table converts them into days, hours and minutes.

Absolute times (names starting with abs): date and time in ISO 8601, in UTC, for example `2022-02-17T06:00:00Z`. The details table shows them in your browser's time zone.

Quantities and cardinalities: whole numbers. Percentages: 0 to 100.

Yes/no properties: true or false.

IDs: activities and relationships are identified by technical IDs. Minerva gets short numbers instead (0, 1, 2 …), which Noreja translates back when Minerva asks for details of an element.

Properties without a value are left out, so an activity without a change time stamp has no absChangeTimestamp.

Single and Aggregated Values

In a case, every activity is one execution with one value per property. In a case model or the process model, an activity stands for many executions, so its times come as a summary: in the graph data as an object such as {"avg": 14804362.0}, in property lists as one entry per suffix:

Suffix	Meaning
`.default`	The single value, in a case or for a property that isn't aggregated.
`.min`, `.max`	The smallest and the largest value of all executions.
`.avg`	The average of all executions. See Average Time Calculation.
`.sum`	The total of all executions, for example of all transition durations of a relationship.
`.stats`	For a property from the source data: its most frequent values and how often they occur.

The graph data carries only the average of the times; the property list of an element adds minimum, maximum and, where it makes sense, the sum.

Activities

Name	Meaning	Label in the details table
`id`	The technical ID of the activity.	Technical ID
`type`	The name of the activity, for example "Bestellung erstellt". Start and end have no name; their property list repeats the technical ID here.	Type
`relStartTimestamp`	Time from the start of the case to the start of this activity, in seconds. 0 for the start of the case.	Start time (rel.), Start time (avg./rel.) …
`absStartTimestamp`	Date and time the activity started: the start time stamp of its object.	Start time (abs.), Start time (avg./abs.) …
`relChangeTimestamp`, `absChangeTimestamp`	The same for the change time stamp, if the object has one. See Timestamps: Formats, Preview and Distribution.	Change timestamp (rel.), Change timestamp (abs.), Change time (avg./abs.) …
`batching`	`true` if the activity was executed for several cases at once. In the process model: if any of its executions was.	Batching included?
`batching.partially`	Case model only: `true` if only some executions of the activity were batched.	Partial batching included?
`reworkAmount`	How often the activity was executed again later in the case (Rework).	Rework count
`behavior`	What kind of activity this is in the graph; see "Behavior and Features" below.	Not shown
`intermediate`	Start and end only: `true` for an intermediate start or end, where objects join or leave a case that is already running, for example an item added to an order later.	Is intermediate?
`unexpected`	Start and end only: `true` for an unexpected start or end, where cases start or end at an activity the perspective doesn't expect.	Unexpected?

Counts on Activities (aggProp)

In a case model and the process model, every activity has an aggProp object with counts:

Name	Meaning	Label in the details table
`aggProp.quantity`	How often the activity was executed in the cases you're looking at. Batched executions count once.	Object count (abs.)
`aggProp.startingObjectsQuantity`	How many executions of the activity start a case unexpectedly.	Not shown
`aggProp.pausedObjectsQuantity`	How many executions of the activity end a case unexpectedly. The Process view shows these numbers on the activity instead of red start and end circles.	Not shown

Relationships

Name	Meaning	Label in the details table
`id`	The technical ID of the relationship.	Technical ID
`source`, `target`	The IDs of the first and the second activity.	Not shown
`transDur`	The transition duration: from the start of the first to the start of the second activity, in seconds. Negative if the second activity started earlier. See Positive and Negative Times.	Transition time, Transition time (avg.) …
`behavior`	What kind of relationship this is; see "Behavior and Features" below.	Not shown
`features`	A list of flags that describe the relationship further; see "Behavior and Features" below.	One yes/no row per flag, for example Process violation present

Counts and Cardinalities on Relationships (aggProp)

Name	Meaning	Label in the details table
`aggProp.quantity`	How many executions of the first activity took this relationship.	Object count (abs.)
`aggProp.quantityPercent`	The same as a share of all executions of the first activity, 0 to 100.	Relations (rel.)
`aggProp.minin`, `aggProp.maxin`	Inbound cardinality: from how many executions of the first activity one execution of the second comes, smallest and largest.	Inbound cardinality (min.), Inbound cardinality (max.)
`aggProp.minout`, `aggProp.maxout`	Outbound cardinality: to how many executions of the second activity one execution of the first leads, smallest and largest.	Outbound cardinality (min.), Outbound cardinality (max.)
`aggProp.positive.`, `aggProp.negative.`	Case model only: quantity and cardinalities of the executions with a positive or a negative transition duration.	Number of paths with positive times, Inbound cardinality (max.) for positive times …
`aggProp.pathDurationLimitAggProp`	Process model only, when you choose Positive or Negative under Limit path duration to:: quantity and cardinalities of the executions with such a transition duration.	Not shown

A cardinality written as 1 : 0 .. 3 in the graph is minin = maxin = 1, minout = 0 and maxout = 3. See Quantities and Cardinalities.

Behavior and Features

behavior says what kind of element it is:

Value	Meaning
`CAUSES`	A recorded activity, or a relationship in the order the perspective expects. Most elements have this value.
`VIOLATION`	A relationship that belongs to a Disarray, Negligence or Rework. Only in the graph data when Violation patterns are switched on.
`HYPOTHETICAL`	An optional activity or a hypothetical path: expected, but not taken by the cases.
`OMITTED`	An omitted activity or path: expected and required, but not taken by the cases.

features lists flags of a relationship. In the property list, each flag is a yes/no entry of its own:

Feature	Entry in the property list	Meaning
`VIOLATION`	`violation`: Process violation present	Cases on this relationship are involved in a violation.
`DISARRAY`, `NEGLIGENCE`, `REWORK`	`disarray`, `negligence`, `rework`: Associated with process pattern …	The violation pattern the relationship belongs to. See Process Patterns: Disarray, Negligence, Rework and Allowed Deviations.
`SIMPLIFICATION`, `REORDER`	`simplification`, `reorder`: Associated with process pattern …	A skip along a shortcut or a step back along a backjump: allowed deviations, not violations.
`CAUSES_HYPOTHETICAL`	`hypothetical`: Hypothetical behavior present	An expected relationship that cases bypass, around a Negligence or a Disarray. With Positive or Negative chosen under Limit path duration to:, also a relationship without such times.
`CAUSES_HYPOTHETICAL_NEGLIGENCE`, `CAUSES_HYPOTHETICAL_DISARRAY`	Not shown	The same, named by the pattern that bypasses the relationship.
`PATH_DURATION_LIMIT`	Not shown	The relationship has executions with a negative transition duration, so Limit path duration to: changes its figures.

Properties of the Whole Graph

Without a selected element, the details table shows properties of the whole process model, case model or case:

Name	Meaning	Label in the details table
`caseQuantity`	Number of cases. Process model only.	Case amount
`variantQuantity`	Number of variants. Process model only.	Variant amount
`activityQuantity`	Number of activities in the graph.	Activity amount
`cycleTime`	Cycle time: from the start to the end of a case, in seconds. In a model with `.min`, `.avg` and `.max`.	Cycle time, Cycle time (avg.) …
`violation`, `batching`	`true` if the graph contains a violation or a batched activity.	Process violation present, Batching included?

Properties from Your Source Data

The columns you added to an object as properties come with the activity:

prop.<ID>: a column of the object. The ID identifies the column; its name, table and schema come with the entry, and the details table shows the column name. In a case the entry has the value (.default), in a model its most frequent values (.stats).

source.prop.<ID>: on a relationship, a column of the first activity's object, so you can see which values lead to this relationship.

idPart.<column>: in a case, the value of a column that is part of the object's ID.

Names in Minerva

Minerva's graph tools get the same graph data, with shorter names and short numbers as IDs, plus a short summary of the graph. In a case, relationships come without features. Property lists keep the full names with suffixes.

Name in the graph data	Name in Minerva's graph tools
`relStartTimestamp`, `absStartTimestamp`	`relStart`, `absStart`
`relChangeTimestamp`, `absChangeTimestamp`	`relChange`, `absChange`
`reworkAmount`	`rework`
`aggProp`	`aggregation`
`transDur` in a case model or the process model	`duration` (in a case: `transDur`)

All other names, as well as units and formats, are the same.

Example

An activity and a relationship from the process model of an insurance claims process, as the graph data contains them:

{
  "id": "e70948b2-e486-46dd-ad15-833665e6fff4",
  "type": "Schaden final bearbeiten",
  "behavior": "CAUSES",
  "batching": false,
  "relStartTimestamp": { "avg": 14804362.0 },
  "aggProp": {
    "quantity": 18561,
    "startingObjectsQuantity": 0,
    "pausedObjectsQuantity": 7077
  }
}
{
  "id": "19630203-4f46-4e42-ab40-e80818ba600f",
  "source": "4a06a79d-a2b3-42d5-a530-a0a9da102f37",
  "target": "e70948b2-e486-46dd-ad15-833665e6fff4",
  "behavior": "CAUSES",
  "transDur": { "avg": 7699242.0 },
  "aggProp": {
    "quantity": 11617, "quantityPercent": 100.0,
    "minin": 0, "maxin": 43, "minout": 1, "maxout": 1
  }
}

"Schaden final bearbeiten" was executed 18,561 times, on average about 171 days (14,804,362 seconds) after the start of its case. After 7,077 of these executions, the case ended unexpectedly. The relationship leads to it from "Schadenregulierung abschließen": all 11,617 executions of that activity took it, and "Schaden final bearbeiten" started on average about 89 days (7,699,242 seconds) later. The cardinality 0 .. 43 : 1 says that up to 43 completed claim settlements lead into one final processing, and some final processings have none.