Metric glossary
Every metric Quodsi reports, in plain language, with how to read it and how it's worked out. Use it when a client asks, "What exactly does that number mean?"
How to use this page
Each section covers one part of your model. The filter in your browser (Ctrl+F or Cmd+F) is the fastest way to find a metric.
- Whole process
- Activities
- Resources
- Entities
- Connectors
- Generators
- Requirements
- States
- Activity and entity pairs
- Generator and entity pairs
- Values per period
- Moment-by-moment values
Most metrics are reported across all replications. The results usually show the mean, and many also give the standard deviation, lowest and highest value. The statistics window is the run after the warm-up.
Tables are wide. Scroll sideways on a small screen. Where Unit says Fraction, the value runs from 0 to 1, so 0.85 means 85%. Times use the unit you pick in Show time in.
Some reading notes use the words RESOURCE, CAPACITY, BOTH and NONE. Those are the values behind the Constrained by column in Flow Analytics.
Whole process
Figures for the whole scenario.
Keeping up
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Did the system keep up? | Whether the whole process kept pace with arrivals, had spare capacity, fell behind and only drained after arrivals stopped, or stayed overloaded to the end. | A bottleneck verdict here means at least one step could not keep up; the activity table's bottleneck rank says which. | The worst verdict among the flow entity types (helpers excluded), each judged from its own arrivals against its departures; the verdict most replications gave. | Label |
| Verdict agreement | The share of replications that gave the process the verdict shown. | At 1.0 every replication agreed. | Replications giving the reported verdict, divided by all replications. | Fraction, 0 to 1 |
| Verdict set by | The entity type whose flow gave the whole-process verdict. | Empty when the model has a single flow entity type. Otherwise it is the type that fared worst, and the one to look at first. | The flow entity type with the most severe verdict, ties broken by higher average WIP then name. | Label |
| System flow basis | Whether the whole-process arrival and completion curve could be drawn for all entities together. | PER_TYPE when the model joins, splits or creates entities; then one combined curve would miscount, so read each entity type's curve instead. | POOLED when no entity was created by, or consumed or split by, an action in any replication; otherwise PER_TYPE. | Label |
Flow
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Entities created | How many entities entered the process in the statistics window (created after the warm-up). | Set by your generators. If throughput is far below this, the process cannot keep up with the arrival rate. | Count of entities produced by all generators after the warm-up. Helper entity types (carts, pallets) are left out. | Count |
| Total throughput | How many entities reached the end of the process in the statistics window (exited after the warm-up). | This is the headline output number. Compare it with entities created; a large gap means work is still stuck inside the process. | Count of entities that left by reaching the end of their flow. Entities consumed by a join, replaced by a split or disposed are not counted. Helper entity types (carts, pallets) are left out. | Count |
| Entities still in progress | How many entities were still inside the process when the run ended. | A number that keeps growing as you lengthen the run means the process is falling behind and queues are building without limit. With a warm-up it includes entities that arrived during the warm-up, so completed plus in progress can exceed created. | Count of entities still inside the process at the end of the run, whenever they arrived. Helper entity types (carts, pallets) are left out. | Entities |
| Total consumed | How many entities were absorbed by joins into combined entities. | Non-zero only when the model joins entities; these are not completions. | Sum of consumed entities over every entity type. | Count |
| Total disposed | How many entities were removed before finishing, by dispose steps. | Scrap, losses or abandonment; these are not completions. | Sum of disposed entities over every entity type. | Count |
| Average entities in the process | How many entities were inside the process at once, on average. | High values mean crowding. This is work in progress, and reducing it usually shortens cycle time. | Time-weighted average of the number of entities present. Helper entity types (carts, pallets) are left out. | Entities |
| Average cycle time | How long a typical entity took to get through the process. | The number most people care about. Break it down with the entity time splits to see how much of it was waiting rather than working. It reads low while many entities are still unfinished, because only completed entities have a cycle time to average. | Each entity type's average time in system, weighted by how many of that type completed, divided by the total completed. Helper entity types (carts, pallets) are left out. | Time |
| Average time in system | How long a typical entity was present anywhere in the process. | The same number as average cycle time: the engine assigns them from one calculation. If you see both, they are not two measurements to compare. | Identical to average cycle time; the scenario aggregator assigns the same value to both. Helper entity types (carts, pallets) are left out. | Time |
Cost
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Total cost | What the whole process cost over the statistics window. | Compare across scenarios. For cost per finished entity by type, see Direct and Fully loaded cost per entity in the entity results. Costs accrue over the statistics window, except a fixed cost, which is always counted in full. | Total activity cost plus total resource cost. | Currency |
| Total activity cost | What the work steps cost over the statistics window. | Only meaningful if you set costs on activities. Zero means no activity costs were configured. Costs accrue over the statistics window, except a fixed cost, which is always counted in full. | Sum of fixed, processing and operational costs across all activities. | Currency |
| Total resource cost | What the people and equipment cost over the statistics window. | Only meaningful if you set costs on resources. Compare with activity cost to see where the money goes. Costs accrue over the statistics window. | Sum of seize, utilization and idle costs across all resources. | Currency |
Activities
Figures for each step in the process.
Keeping up
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Did this step keep up? | Whether this step kept pace with the work sent to it, had spare capacity, fell behind and only caught up after arrivals stopped, or stayed overloaded to the end. | Overloaded or Fell behind means work piled up at this step. It does not say why: read What limits this step to see whether the step's own capacity or a resource it seizes is the reason. | The verdict most replications gave, judged from the step's cumulative arrivals and completions over the statistics window. | Label |
| Verdict agreement | The share of replications that gave this step the verdict shown. | At 1.0 every replication agreed. Low agreement means the picture changes run to run, so do not act on one verdict alone. | Replications giving the reported verdict, divided by all replications. | Fraction, 0 to 1 |
Throughput
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Completed here | How many entities finished at this step and moved on. | A count over the statistics window, not a rate. Compare across steps to follow where volume drops. | Count of entities released from this step. | Count |
| Times started | How many times this step began working on an entity. | Includes work still in progress at the end of the run, so it can exceed the number completed. | Count of entities that took up capacity at this step. | Count |
| Entities entering here | How many entities first entered the whole process at this step. | Non-zero only for steps fed by a generator or that create their own work. This is NOT how many entities passed through; for that use times started or the number completed. | Count of entities whose entry point into the model was this step. | Count |
Capacity and utilization
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Share of time active | The share of the run during which this step was doing something. | Differs from utilization when capacity is above 1. A step with three slots that always has exactly one busy is fully active but only a third utilized. | Time with at least one slot occupied, divided by the time the step was tracked. Reported as a fraction from 0 to 1. From output schema 1.14 an entity sitting out a repair does not count as occupying a slot; from 1.18 neither does an entity that is done and blocked in its slot. | Fraction, 0 to 1 |
| Being worked on, average | How many entities were actually being processed here, on average. | Compare with capacity to see spare room. This counts only entities in the step itself, not those waiting in either queue. | Time-weighted average of the number of entities in the step. | Entities |
| Bottleneck rank | Where this step sits in the worst-first list of constraints. | Rank 1 is the place to look first. Steps with an identified constraint come first, ordered by how much work sat at them; the rest follow by verdict. | Steps whose constraint is not NONE, by mean total contents; then the rest by verdict severity and cycle time; ties by name. | Count |
| Utilization | How much of this step's capacity was in use. | Values near 1 mean the step is saturated and is a strong bottleneck candidate. Low utilization next to a high share-of-time-active means the step is oversized: it is always doing something, but never much. | Processing time, including a capture still open at the horizon, divided by the capacity the step actually offered. From output schema 1.2 that denominator follows any work schedule, so time off shift does not count as idle capacity. Time held for entities still travelling here is excluded. From output schema 1.14 a repair is left out of both sides: time an entity sat through it is not work, and a failed slot is not offered capacity. From output schema 1.15 a slot that works past its shift counts as offered while it does. From output schema 1.18 a slot held by an entity that is done and waiting for room downstream is blocked, not work: it is left out of processing time. | Fraction, 0 to 1 |
| Requirement waited for most | The resource requirement this step's entities spent the most time waiting for. | When What limits this step is RESOURCE or BOTH, this is the thing to relieve. It is named even for a healthy step, so read it with What limits this step. | The requirement with the largest total wait credited to this step, most replications. | Label |
| Resources behind that requirement | The resources the requirement above can take, separated by semicolons. | A single name is the usual case; several names mean the requirement accepts alternatives. | Every resource in the requirement's clause tree, in tree order. | Label |
| What limits this step | Whether the limit on this step is its own capacity, a resource it seizes, both, or neither. | RESOURCE means entities held a slot here while waiting for the requirement named in Requirement waited for most; adding capacity to this step will not help. CAPACITY means the step's own capacity is saturated. BOTH means relieving one alone will not move throughput. NONE means nothing here is saturated. | RESOURCE when at least half the slot time was spent waiting for a requirement, or that requirement was itself overloaded, while own utilization stayed below 85%. CAPACITY when own utilization reached 85% and the requirement had slack. BOTH when both held. | Label |
| Constraint agreement | The share of replications that gave this step the constraint label shown. | Low agreement means the limiting factor moved between runs. | Replications giving the reported label, divided by all replications. | Fraction, 0 to 1 |
| Being worked on, peak | The most entities processed here at the same time. | If this never reaches the configured capacity, some of the capacity was never used by any run condition. | Highest number of entities in the step at any moment. | Entities |
| Own-capacity utilization | How busy this step's own capacity was, not counting time spent waiting for a resource. | Compare with Capacity Utilization: a big gap between the two is slot time held while waiting for a resource. Near 1 means the step itself is saturated. | Slot time (including a capture still open at the horizon) minus resource wait, divided by available capacity time. From output schema 1.14 repairs are left out of both sides, as they are for utilization. | Fraction, 0 to 1 |
| Capacity held for arrivals | The share of this step's capacity held open for entities that were still travelling here. | Directly comparable with utilization, since both use the same denominator. Add them to see how much capacity was truly spoken for. | Time capacity was held for entities in transit, divided by the same capacity denominator utilization uses. | Fraction, 0 to 1 |
| Slot time spent waiting for a resource | Of the time entities held a slot at this step, the share spent waiting for a resource. | Values near 1 mean the step's capacity was mostly held idle by entities waiting for something else. That is the signature of a resource constraint, not a capacity one. | Total resource wait credited to visits here, divided by total slot time (including a capture still open at the horizon). | Fraction, 0 to 1 |
| Entities at this step, average | How many entities were anywhere at this step at once, counting both queues and the work itself. | The fullest single picture of how crowded this step was. Break it into the inbound queue, being-worked-on and outbound queue figures to see where the crowding sits. | Time-weighted average of inbound queue plus in-process plus outbound queue, including a visit still open at the horizon (counted up to the end of the run). An entity still travelling here adds nothing. | Entities |
Time
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Statistics window length | How long the statistics window was, in clock time. | The same for every step. It is the length of the run after the warm-up, not a measure of this step's uptime or availability. With no warm-up it equals the run length. | The simulation end time minus the end of the warm-up. | Time |
| Time at this step, per entity | How long a typical entity spent at this step, from arriving to finishing. | This is per entity, not a run total, despite what older reports suggested. It covers queuing plus processing. Time spent stuck after finishing is reported separately as blocked time. | Queue time plus processing time of each completed visit, measured from request to the end of the work (so it also includes any time a slot was held while the entity travelled here), divided by the number of entities released. Completed visits only: an entity still at the step when the run ends is left out. From output schema 1.18 a wait the entity sat out at the previous step is not counted here (it is that step's blocked time), and time blocked in the slot after the work is not cycle time. | Time |
| Queue time, per entity | How long a typical entity waited in line before this step took it. | The direct congestion signal for this step. When it dominates cycle time, this step lacks capacity. | Total time entities spent here waiting for this step's capacity, divided by the number of entities taken in. Only waits that ended count: an entity still waiting when the run ends is left out. From output schema 1.18 a wait sat out at the previous step (this step has no inbound queue) is that step's blocked time, not queue time here. | Time |
| Total capacity-time held for arrivals | The total time this step's capacity sat reserved for entities that had not arrived yet. | A run total. This time is billed at the idle rate, not the working rate, because nothing is being processed while a slot is merely held. | Sum of the time capacity was reserved ahead of arrivals. | Time |
| Capacity-time held per entity | How long a slot here sat reserved for a typical entity before it arrived. | Rises with the travel time on the connections feeding this step. Long reservations waste capacity that nothing is using. | Total reserved-in-transit time divided by the number of entities served. | Time |
| Blocked time, per entity | How long a typical entity sat here after finishing, unable to move on because the next step had no room. | Blocking points at a constraint DOWNSTREAM, not at this step. Look one step further along the flow. It happens after the work is done, so it is not part of cycle time. It counts the wait in the outbound queue and, when there is no room there or no outbound queue at all, the wait in the entity's own slot. Before output schema 1.18 the wait in the slot read as processing time and utilization, and the next step also counted it as its own queue time. | Total time entities spent done here and waiting for room downstream, in the outbound queue or in their slot, divided by the number of entities released. Completed visits only: an entity still blocked when the run ends is left out. | Time |
| Time in failure | How long this step was broken down and unable to work. | Only non-zero when you configured failures. Unlike the other time figures here, this is a run total, not a per-entity average. Each slot counts on its own, so with several slots this can pass the length of the run. | Total time each slot spent in a failed state during the run, added up. | Time |
| Failures | How many times a slot at this step broke down. | Only non-zero when you configured failures. Each slot fails on its own, so a step with three slots can fail three times as often. Time in failure divided by this is the average repair. | Count of failures that began in the statistics window. A failure already open when the warm-up ends adds time but no count. | Count |
| Interruptions | How many times a failure took a slot from an entity at this step. | Fewer than failures when some failures hit an empty slot. One entity hit twice counts twice, so this is a count of interruptions, not of entities. | Count of failures that found an entity in the slot, whether it was working, waiting for a resource or blocked. | Count |
| Processing time, per entity | How long a typical entity was actually being worked on here. | Per entity, not a run total, despite the name. This is the only part of cycle time that adds value. | Total processing time of completed visits divided by the number of entities released. Completed visits only: an entity still being worked on when the run ends is left out. | Time |
| Resource wait, per entity | How long a typical entity waited here for a person or piece of equipment to become free. | When this is large the constraint is the resource, not this step's capacity. It happens inside the step's processing time, so do not add the two together. | Total time entities spent waiting for a resource here, divided by the number of entities served. | Time |
Queues
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Inbound queue, average | How many entities were waiting to enter this step, on average. | Sustained values above 1 mean arrivals outpace this step. Read it next to utilization: a long queue at a busy step is the clearest bottleneck signature there is. | Time-weighted average of the inbound queue count over the statistics window. Counted from the entity's arrival, not from when it reserved its place. | Entities |
| Inbound queue, peak | The most entities that were ever waiting to enter this step at once. | Use this, not the average, when sizing physical waiting space. The average hides short pile-ups. | Highest number of entities waiting in the inbound queue at any moment. Counts entities that waited; an instantaneous transit (an entity that passes through the queue to a free slot without waiting) does not count. | Entities |
| Inbound queue fullness | How full the waiting line into this step was, on average. | Near 1 means the line was usually full, so arriving entities were often held upstream. Zero when no queue is configured. | Average inbound queue contents divided by the inbound queue size. This is a contents ratio, not a share of time. | Fraction, 0 to 1 |
| Outbound queue, average | How many finished entities were waiting to leave this step, on average. | Anything above zero means work is finishing here faster than the next step can take it. The constraint is downstream, not here. | Time-weighted average of the outbound queue count over the statistics window. | Entities |
| Outbound queue, peak | The most finished entities that were ever waiting to leave at once. | A high peak with a low average means downstream stalls in bursts. | Highest number of finished entities waiting in the outbound queue at any moment. Counts entities that waited; an instantaneous transit (an entity that leaves the moment it finishes) does not count. | Entities |
| Outbound queue fullness | How full the exit line from this step was, on average. | Near 1 means finished work had nowhere to go, which blocks this step from starting anything new. | Average outbound queue contents divided by the outbound queue size. A contents ratio, not a share of time. | Fraction, 0 to 1 |
Cost
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Fixed cost | The one-off cost of having this step at all. | Scales with the step's capacity, so doubling capacity doubles it. Zero unless configured. | The configured fixed cost multiplied by the step's capacity. | Currency |
| Operational cost | The cost of keeping this step running, charged by time. | Charged at a working rate for each unit of capacity while a Delay runs on it, and an idle rate for each other unit on shift. A unit held by an entity that isn't being worked on is billed as idle: one waiting for a resource, a Join, a blocked exit, a repair, or an entity still travelling. Off-shift capacity costs nothing. | Working rate times working unit-hours, plus idle rate times idle unit-hours. | Currency |
| Processing cost | The cost of the work this step did, charged per entity. | Rises directly with volume. Zero unless configured. | The configured per-entity cost multiplied by entities served. | Currency |
| Total cost | Everything this step cost over the statistics window. | Divide by the number completed for a cost per entity, which compares better across steps of different sizes. Costs accrue over the statistics window, except a fixed cost, which is always counted in full. | Fixed cost plus processing cost plus operational cost. | Currency |
Setup
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Capacity | How many entities this step can work on at the same time. | This is the capacity you configured, not what a work schedule made available. For a scheduled step it is the Nominal capacity you set. | The step's nominal capacity, as set in the model. | Entities |
| Inbound queue size | How many entities can wait to enter this step. | Zero means there is no waiting line: an entity reserves a slot at the step before it even starts moving there. | The inbound queue size set in the model. | Entities |
| Outbound queue size | How many finished entities can wait here before moving on. | When this fills, entities that have finished cannot leave, and the step stops taking new work. That shows up as blocked time. | The outbound queue size set in the model. | Entities |
Resources
Figures for each pool of people or equipment.
Throughput
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Captures | How many times this resource was actually taken up by work. | The number of jobs it started. Multiply by the average hold to get the total busy time. | Count of successful acquisitions of this resource. | Count |
| Requests | How many times work asked for this resource. | Compare with captures. A gap means some requests were still waiting when the run ended. | Count of requests made for this resource. | Count |
Capacity and utilization
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Share of time active | The share of the run during which this resource was doing something. | Differs from utilization when capacity is above 1. A resource with three units that always has exactly one busy is fully active but only a third utilized. Reported as a fraction from 0 to 1. | Time with at least one unit in use, divided by the window length. | Fraction, 0 to 1 |
| Utilization | How much of this resource's available capacity was in use. | Values near 1 mean the resource is saturated and is likely limiting throughput. If the resource works a schedule, off-shift hours are not counted against it here. | Busy time, including a hold still open at the horizon, divided by the capacity the schedule actually offered. From output schema 1.2 this denominator follows the work schedule, so an off-shift hour is absent capacity rather than idle capacity. From output schema 1.15 a unit that works past its shift counts as offered while it does, so this can't pass 100%. | Fraction, 0 to 1 |
| Units in use, average | How many units of this resource were in use at once, on average. | An average, so its own maximum is the largest average across replications, NOT a peak. For the real peak use peak units in use; on a bursty resource the two differ enormously. | Time-weighted average number of units in use. | Entities |
| Utilization against full staffing | How much of this resource was in use, measured against full staffing for the whole statistics window rather than against its schedule. | Equal to the scheduled utilization above when the resource works no schedule. It's usually lower, since a schedule offers less than full staffing, but it can be higher when the schedule peaks above the Nominal capacity, and then it can pass 100%. A large gap means the resource is busy on shift but off shift for much of the run. | Busy time divided by the configured capacity multiplied by the run length, ignoring any schedule. | Fraction, 0 to 1 |
| Units in use, peak | The most units of this resource in use at the same moment. | The true peak within a replication. Use this, not the average, to answer how many units were busy at the worst moment. | Highest number of units in use at any instant. | Entities |
Time
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Hold time, per capture | How long this resource was held each time it was taken, on average. | An average per finished hold, not a run total. A hold still open when the run ends isn't in it, though it does count toward utilization. | Total time of the holds that finished, divided by how many finished. | Time |
| Wait time, per request | How long work waited for this resource each time it asked, on average. | An average per request, not a run total. Large values mean this resource is a constraint, and adding capacity here usually shortens cycle time. | Total waiting time divided by the number of requests. | Time |
Queues
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Longest queue for this resource | The most pieces of work ever waiting for this resource at once. | A peak, not an average, despite the plain name. It is each replication's worst moment, so its own maximum is the worst peak seen in any replication. | Highest number of requests waiting at any instant. A request granted the moment it is made never queues, so a resource that is never short shows 0. | Entities |
Cost
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Idle cost | The cost of the time this resource was available but unused. | High idle cost next to low utilization is the classic sign of over-provisioning. Only on-shift idle time is charged; a resource that is off shift costs nothing. | The configured idle rate multiplied by the idle unit-hours: each scheduled unit not in use, for as long as it sat unused. | Currency |
| Seize cost | The cost charged each time this resource was taken up. | Rises with the number of captures. Zero unless configured. | The configured per-capture cost multiplied by the number of captures. | Currency |
| Total cost | Everything this resource cost over the statistics window. | Compare across resources to see which ones dominate spend before changing any capacity. Costs accrue over the statistics window, except a fixed cost, which is always counted in full. | Seize cost plus busy cost plus idle cost. | Currency |
| Busy cost | The cost of the time this resource spent working. | Rises with hold time. Zero unless configured. | The configured busy rate multiplied by the hours held. | Currency |
Setup
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Capacity offered | How much resource time was actually available across the run, counting only on-shift hours. | The schedule as written. It is the denominator behind utilization, which also counts any unit that works past its shift. Equal to capacity times the window length when no schedule is set. | The scheduled capacity added up over the statistics window, in clock time multiplied by units. | Time |
Entities
Figures for each entity type: the things that flow through your process.
Counts
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Created | How many of this entity type entered the process. | Counts everything that entered, whether or not it finished. Set by your generators, so this is the demand the process faced. | Count of all entities of this type, finished and unfinished. | Count |
| Completed | How many of this entity type reached the end of the process. | Compare with created. A persistent shortfall means the process cannot absorb the arrival rate. Entities consumed by a join, replaced by a split or removed by a dispose are counted separately, not here. | Count of entities of this type that left by reaching the end of their flow. | Count |
| Still in progress | How many of this entity type were still inside when the run ended. | If this grows as you lengthen the run, the process is unstable rather than merely warming up. | Created minus every departure (completed, consumed, split or disposed). | Entities |
| Consumed | How many of this entity type were absorbed by a join into a combined entity. | Parts that became an assembly show up here rather than as completed. They left this type's flow, so they are not still in progress. | Count of entities of this type that left because a join consumed them. | Count |
| Split | How many of this entity type were replaced by the pieces a split created. | The pieces are counted under their own entity type. | Count of entities of this type that left because a split replaced them. | Count |
| Disposed | How many of this entity type were removed before finishing, by a dispose step. | Scrap, rework losses or patients who left without treatment. A number you did not expect here usually means a branch sends work to a dispose step more often than intended. | Count of entities of this type removed by a dispose action. | Count |
| Completion rate | Completions in the statistics window per unit of time, over the whole window from the end of the warm-up to the end of the run. | A rate the process actually sustained across the window: if work stopped early, the idle end counts too. With no warm-up the window starts at time zero. | Completions after the warm-up divided by (the run length minus the warm-up). | Rate |
Work in process
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Average work in progress | How many of this entity type were inside the process at once, on average. | Averaged over the statistics window, so an entity type that only appears late reads low. Work in progress, completion rate and time in the process move together: cut one and the others follow. | Time-weighted average count of this type present, divided by the length of the statistics window. | Entities |
| Peak work in progress | The most of this entity type inside the process at the same time. | Use this, not the average, to size physical space and queue limits. | Highest simultaneous count of this type in the statistics window. When one entity leaves at the same instant another arrives, the leaving one is counted out first, so a hand-over is not a peak. | Entities |
| Lowest work in progress | The fewest of this entity type inside the process at any instant. | Almost always zero, because the count starts at zero before the first entity arrives. It rarely tells you anything useful. | Lowest simultaneous count of this type at any instant. | Entities |
Time
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Time in the process | How long this entity type spent in the process from start to finish. | The five time splits below divide this up completely, with no overlap and nothing left over, so they always add back to this number. Start here, then find which split dominates. | Total time from entry to exit, divided by the number that completed. Unfinished entities are excluded. Counts completed entities only. | Time |
| Time being worked on | How long this entity type spent actually being processed. | The only split that adds value. If it is a small share of time in the process, most of the delay is avoidable. | Total time held by an activity's capacity, divided by the number that completed. | Time |
| Time waiting in queues | How long this entity type spent waiting to get into a step. | When this dominates, the constraint is capacity at a work step. Look at step utilization to find which one. | Total time spent in an inbound queue, divided by the number that completed. | Time |
| Time waiting for a resource | How long this entity type spent waiting for a person or piece of equipment to become free. | When this dominates, add resource capacity rather than step capacity. It is counted separately from processing, not inside it. | Total time a resource request was blocked, divided by the number that completed. | Time |
| Time moving | How long this entity type spent travelling between steps. | Zero unless connections have move times set. The column name says connecting but every label calls it moving; they are the same thing. | Total time riding a connector, divided by the number that completed. | Time |
| Time blocked | How long this entity type sat finished at a step but unable to move on, because the next step had no room. | Blocking points at a downstream constraint, not at the step where it shows up. Look one step further along the flow. | Total time spent done but not yet taken onward, divided by the number that completed. | Time |
| Gap between completions | How long passed between one entity finishing and the next. | Averaged within each replication first, so it shows the typical pace. Use the overall gap instead if you care about how much that pace varied. | Mean time between consecutive completions within a replication, then averaged across replications. | Time |
| Gap between completions, all pooled | The same gap between completions, but pooling every individual gap from every replication. | Its average matches the per-replication figure, but its spread is much wider because it keeps the variation between individual completions instead of averaging it away. Use it to see burstiness. | Every consecutive completion gap from every replication, pooled. | Time |
Share of time
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Percent being worked on | The share of time in the process that was actual processing. | Often surprisingly small. Under about 10 percent means the process is mostly waiting. Reported on a 0 to 100 scale. | Total processing time divided by total time in the process, times 100. A pooled ratio, not an average of per-entity percentages. | Percent, 0 to 100 |
| Percent waiting in queues | The share of time in the process spent waiting to get into a step. | The largest of the five shares usually names the kind of fix the process needs. The five always add to 100. | Total queue time divided by total time in the process, times 100. | Percent, 0 to 100 |
| Percent waiting for a resource | The share of time in the process spent waiting for a resource. | When this is the largest share, add resource capacity rather than step capacity. | Total resource wait divided by total time in the process, times 100. | Percent, 0 to 100 |
| Percent moving | The share of time in the process spent travelling between steps. | Zero unless connections have move times set. | Total moving time divided by total time in the process, times 100. | Percent, 0 to 100 |
| Percent blocked | The share of time in the process spent stuck after finishing a step. | Any substantial share means a downstream step or queue limit is backing work up. | Total blocked time divided by total time in the process, times 100. | Percent, 0 to 100 |
Cost
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Direct cost per entity | What one finished entity of this type cost in the work it actually used: per-entity charges, activity hours while it was being worked on, resource seizes and resource hours. | Moves when the process changes. Excludes idle and fixed costs; see Fully loaded cost per entity. | Costs charged to departed entities of this type, divided by departed entities of this type (completed, consumed, split or disposed). | Currency |
| Fully loaded cost per entity | This type's share of everything the run cost, including idle resources and fixed costs, per finished entity. | Per-type shares add up to Total cost. The gap above Direct cost is what spare capacity and overhead cost per unit. | Every cost this type's entities incurred, plus its share of activity fixed cost (by entities), activity idle cost (by processing time) and resource idle cost (by busy hours), divided by departed entities of this type. | Currency |
Keeping up
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Did this type keep up? | Whether this entity type's flow kept pace with its arrivals, had spare capacity, fell behind and only drained after arrivals stopped, or stayed overloaded to the end. | Judged on arrivals of this type against every way it left, so a type consumed by a join can still keep pace. The whole-process verdict is the worst verdict among the flow types. | The verdict most replications gave, judged from cumulative arrivals of this type against its cumulative departures over the statistics window. | Label |
| Verdict agreement | The share of replications that gave this entity type the verdict shown. | At 1.0 every replication agreed. | Replications giving the reported verdict, divided by all replications. | Fraction, 0 to 1 |
| Role in flow | Whether this entity type is work flowing through the process or a helper that supports it. | Helper types (carts, tokens, staff modelled as entities) are left out of the whole-process verdict. Set it on the entity type in the model. | The entity type's role setting, FLOW or HELPER. | Label |
Connectors
Figures for each path between steps.
Throughput
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Traversals | How many times entities travelled along this connection. | Compare with the throughput of the activity the connection leaves. A much lower count means most entities took a different route. | Count of entities that entered this connector during the run. | Count |
Capacity and utilization
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Average entities in transit | How many entities were moving along this connection at once, on average. | Rises when travel time is long or the connection is busy. Entities in transit are counted as work in progress. | Time-weighted average of the number of entities on this connector, with a ride still going at the end of the run counted up to the end. | Entities |
| Peak entities in transit | The most entities that were moving along this connection at the same time. | A peak far above the average means arrivals to this connection come in bursts. | Maximum number of entities simultaneously on this connector, including any still riding at the end of the run. | Entities |
Time
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Average travel time | How long a single entity took to move along this connection, on average. | Zero unless the connection has a move time set. When set, this adds directly to how long entities take to get through the whole process. | Travel time of the rides that finished, divided by how many finished. A ride still going at the end of the run isn't in it. | Time |
| Longest travel time | The longest any single entity took to move along this connection. | A value far above the average means travel time varies, which usually points at a distribution rather than a fixed move time. | Maximum travel time across the rides that finished. | Time |
| Total travel time | The combined time all entities spent moving along this connection. | Only meaningful when the connection has a move time set. Zero means travel is instant, which is the default. | Sum of each entity's travel time along this connector, including a ride still going at the end of the run, up to the end. | Time |
Generators
Figures for each source of arrivals.
Throughput
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Creation rate | How many entities this generator created per unit of time. | Measured over the statistics window (the run after the warm-up), not up to the last creation. A generator that stops early or hits its entity cap reads lower than the rate it was configured with. | Entities created divided by the total available clock. | Rate |
| Entities created | How many entities this generator created in the statistics window (after the warm-up). | Compare with the entity type's total to see how much of the work came from this generator. An entity that has to wait to enter its first activity is still counted here; that wait is reported on the entity and the activity, not the generator. | Count of entities whose origin is this generator. | Entities |
Time
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Average gap between arrivals | How long passed, on average, between one creation moment and the next. | A batch created at the same instant counts once. For a calendar pattern or a schedule this is the realized gap, which can differ from anything you typed. Empty when the generator fired fewer than twice. | Mean gap between consecutive distinct creation moments within a replication, then averaged across replications. | Time |
| First creation | The clock time at which this generator created its first entity. | Check it against the start delay or schedule you set. Empty means the generator never fired in that replication. | Earliest creation time among this generator's entities. | Time |
| Last creation | The clock time at which this generator created its last entity. | Well before the end of the run means the generator ran out of occurrences, hit its entity cap, or its schedule ended. Empty means it never fired. | Latest creation time among this generator's entities. | Time |
| Longest gap between arrivals | The longest time between one creation moment and the next. | A value far above the average means the generator went quiet for a while, which is normal for a calendar pattern with off-hours. | Maximum gap between consecutive distinct creation moments. | Time |
| Shortest gap between arrivals | The shortest time between one creation moment and the next. | Zero cannot occur here, because entities created at the same instant count as one moment. A very small value means arrivals bunched up. | Minimum gap between consecutive distinct creation moments. | Time |
Requirements
Figures for each resource requirement: what a step asks for when it needs a resource.
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Hold per seize | How long the resources stayed seized per request, on average. | A long hold across several steps (seize here, release later) is what makes a small resource pool the constraint of a whole process. | Mean of release time minus seize time over released requests. | Time |
| Requests holding | How many granted requests were holding resources at once, on average. | Compare with the pool's capacity to see how full it ran. | Time-weighted mean of the seized-not-released count over the statistics window. | Entities |
| Wait per request | How long a request waited before it was granted, on average. | The direct cost of this requirement being busy. Read it with the activity's resource wait share to see which step pays it. | Mean of seize time minus request time over granted requests. | Time |
| Requests waiting | How many requests were waiting for this requirement at once, on average. | Sustained values above zero mean the requirement is a queue in its own right. | Time-weighted mean of the pending request count over the statistics window. | Entities |
| Peak requests waiting | The most requests that were waiting at any one moment. | A high peak with a low average means bursts, not a steady shortage. | Maximum of the pending request count over the statistics window. | Entities |
| Resources | The resources this requirement can take, separated by semicolons. | One name is the usual case; several mean the requirement accepts alternatives. | Every resource in the requirement's clause tree, in tree order. | Label |
| Releases | How many granted requests were released again. | Fewer than seizes means some entities still held the resources at the end. | Count of seized requests that were released. | Count |
| Requests | How many times an entity asked for this requirement. | Compare with seizes; a gap at run end is work still waiting. | Count of seize attempts recorded on this requirement. | Count |
| Seizes | How many requests were granted. | Fewer than requests means some entities were still waiting at the end. | Count of requests that received their resources. | Count |
| Did this requirement keep up? | Whether grants kept pace with requests, or requests piled up. | Overloaded or Fell behind here means this requirement is a constraint for every step that seizes it. | The verdict most replications gave, judged from cumulative requests and grants over the statistics window. | Label |
| Verdict agreement | The share of replications that gave this requirement the verdict shown. | At 1.0 every replication agreed. | Replications giving the reported verdict, divided by all replications. | Fraction, 0 to 1 |
States
Figures for each state variable in the model.
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Number of changes | How many times this state changed value during the run. | A state that never changes usually means the condition driving it was never met. For a state attached to entities, this is an average per entity rather than a whole-run count. | Count of value changes recorded for this state. | Count |
| Final value | What this state was set to when the run ended. | For a state attached to entities this is not one entity's value: it is the average across entities for a number, the fraction that were true for a yes-or-no state, and the most common value for a category. For a yes-or-no state, read the percent-of-time-true instead if you want to know how often the condition held. | The value at the end of the run, or for entity states the pooled value at exit across all entities of that type. | Count |
| Highest value | The highest value this state reached. | Use the overall column, not the average, when sizing anything that has to cope with the worst case. | Maximum value observed for this state. | Count |
| Lowest value | The lowest value this state reached. | Two columns: the average lowest across replications, and the lowest seen in any single replication. | Minimum value observed for this state. | Count |
| Most common value | The value this state held most often. | Only meaningful for states that hold categories rather than numbers. Within a replication it is the value held for the longest time; across replications it is the one that won most often. | The category that appears most often across replications. | Label |
| Percent of time true | The share of the run during which this state was true. | Only meaningful for yes-or-no states. This, not the final value, is how you judge how often a condition held. Reported on a 0 to 100 scale. | Time the state was true divided by the window length, times 100. | Percent, 0 to 100 |
| Time-weighted average | The average value of this state, counting each value for as long as it held. | The right average for a numeric state. A plain average over changes would over-count brief spikes. Only meaningful for number states. | The state value added up over time, divided by the length of the run. | Count |
Activity and entity pairs
The same activity, split by entity type. Use these to see what each kind of work does at one step.
Counts and contents
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Visits served | How many times this step served this particular entity type. | Counted when the step took the entity up, not when it arrived, so entities still queuing at the end are not included. | Count of visits of this entity type that the step began serving. | Count |
| Visits completed | How many of those visits finished at this step. | A gap against visits served means work of this type was still in progress here when the run ended. | Count of visits of this type that finished at this step. | Count |
| Being worked on, average | How many of this entity type were being processed here, on average. | Summing this across every entity type gives the step's own figure. | Time-weighted average count of this type inside the step, including a visit still open at the horizon. | Entities |
| Inbound queue, average | How many of this entity type were waiting to enter this step, on average. | Compare entity types at the same step to see which kind of work is queuing. Note the column name shortens queue to q here, unlike the activity family. | Time-weighted average count of this type in the step's inbound queue, including a visit still open at the horizon. | Entities |
| Outbound queue, average | How many of this entity type were waiting to leave this step, on average. | Above zero means this type finishes here faster than the next step takes it. | Time-weighted average count of this type in the step's outbound queue, including a visit still open at the horizon. | Entities |
| At this step, average | How many of this entity type were anywhere at this step, counting both queues and the work itself. | Compare entity types to see which one occupies the step most. | Time-weighted average of this type in the inbound queue, in the step, and in the outbound queue, including a visit still open at the horizon. | Entities |
Average time
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Time at this step, per visit | How long this entity type took to get through this one step, on average. | Covers queuing plus processing. Time stuck after finishing is reported separately as blocked time. Compare the same step across entity types to see which work it handles slowly. | Request to the end of the work of each completed visit of this type (queue plus processing, plus any time a slot was held while it travelled here), divided by the visits that completed. Completed visits only. From output schema 1.18 a wait sat out at the previous step, and time blocked in the slot after the work, are not counted. | Time |
| Queue time, per visit | How long this entity type waited to get into this step, on average. | The congestion this step imposes on this particular kind of work. | Total queue time for this type divided by the visits taken in. Only waits that ended count. | Time |
| Resource wait, per visit | How long this entity type waited here for a resource, on average. | When this is large for one entity type only, that type competes for a resource the others do not need. | Total resource wait for this type divided by visits served. | Time |
| Processing time, per visit | How long this entity type was actually worked on here, on average. | The part of the visit that adds value. | Total processing time of this type's completed visits divided by the visits that completed. Completed visits only. | Time |
| Blocked time, per visit | How long this entity type sat here after finishing, unable to move on, on average. | Caused by the NEXT step having no room, not by this one. Averaged over visits that completed. | Total blocked time for this type divided by the visits that completed. Completed visits only. | Time |
| Failure time, per visit | How much breakdown time this entity type sat through here, on average. | Only non-zero when you configured failures. A failure on an empty slot belongs to no entity, so entity types need not add up to the step's time in failure. | Time entities of this type spent without a slot because of a failure, divided by visits served. | Time |
Total time
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Time at this step, all visits | The combined time this entity type spent getting through this step. | A genuine total across every visit, unlike the average beside it. Useful for seeing which entity type consumes the most of a step. | Sum of request-to-release time across the completed visits of this type. A visit still open when the run ends is left out. | Time |
| Queue time, all visits | The combined time this entity type spent waiting to enter this step. | A run total across every visit of this type. | Sum of queue time across the visits of this type whose wait ended. An entity still waiting when the run ends is left out. | Time |
| Resource wait, all visits | The combined time this entity type spent waiting for a resource here. | A run total across every visit of this type. | Sum of resource wait time across all visits of this type. | Time |
| Processing time, all visits | The combined time this step spent working on this entity type. | Also the basis on which shared step costs are split between entity types. | Sum of processing time across the completed visits of this type. A visit still being worked on when the run ends is left out. | Time |
| Blocked time, all visits | The combined time this entity type spent stuck here after finishing. | A run total. Large values point at a downstream constraint. | Sum of blocked time across the visits of this type that left. An entity still blocked when the run ends is left out. | Time |
| Failure time, all visits | The breakdown time entities of this type sat through at this step. | Measured, not shared out. It runs from losing a slot to getting one back, which on a step with several slots can be shorter than the repair. A failure on an empty slot belongs to no entity, so entity types need not add up to the step's time in failure. | Time entities of this type spent without a slot because of a failure. | Time |
Cost
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Fixed cost share | The part of this step's fixed cost charged to this entity type. | Split in proportion to how many visits each type made. | The step's fixed cost apportioned by this type's share of visits. | Currency |
| Processing cost share | The processing cost this entity type ran up at this step. | Exact rather than apportioned: it is the per-entity rate times this type's visits. | The configured per-entity cost multiplied by visits served. | Currency |
| Operational cost share | The part of this step's running cost charged to this entity type. | Split in proportion to processing time. | The step's operational cost apportioned by this type's share of processing time. | Currency |
| Total cost share | Everything this entity type cost at this step. | Divide by visits served for a cost per visit, which compares entity types fairly. | Fixed plus processing plus operational cost shares. | Currency |
Generator and entity pairs
The same generator, split by entity type.
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Average gap between arrivals | How long passed, on average, between creation moments of this type. | A batch counts once. Empty when fewer than two creation moments of this type occurred. | Mean gap between consecutive distinct creation moments of this type within a replication, then averaged across replications. | Time |
| Creation rate | How many entities of this type this generator created per unit of time. | Measured over the statistics window (the run after the warm-up). | Entities of this type created divided by the total available clock. | Rate |
| Entities created | How many entities of this type this generator created. | Adding up a generator's rows gives its total. Only a schedule that names a type per row, or a generator whose template changes, makes this differ from the generator's own row. Per-replication rows include a zero for replications where this generator made none of this type, so their average can be lower than this summary, which averages only the replications where the type appeared. | Count of entities of this type whose origin is this generator. | Entities |
| First creation | The clock time at which the first entity of this type was created here. | Empty means none of this type was created in that replication. | Earliest creation time among this generator's entities of this type. | Time |
| Last creation | The clock time at which the last entity of this type was created here. | Empty means none of this type was created in that replication. | Latest creation time among this generator's entities of this type. | Time |
| Longest gap between arrivals | The longest time between creation moments of this type. | A long gap is normal for a scheduled or calendar-driven type that arrives in sessions. | Maximum gap between consecutive distinct creation moments of this type. | Time |
| Shortest gap between arrivals | The shortest time between creation moments of this type. | Entities created at the same instant count as one moment, so this is never zero. | Minimum gap between consecutive distinct creation moments of this type. | Time |
Values per period
How a measure changed over the run. The run is cut into periods, and each point is averaged across replications.
Activities
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Entities at the step, per period | How many entities were at this step during each stretch of the run, averaged across replications. | Each point is one period. A line that keeps rising means work is building up at the step; a flat line means it is keeping pace. A wide gap between min and max means the replications disagree, so run more of them before trusting the shape. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Time-weighted average count at the step within each period, then the mean, spread, lowest and highest of that value across replications. | Entities |
| Fixed cost, per period | The step's one-time fixed cost, booked in the first period of the run, averaged across replications. | The whole fixed cost lands in the first period, so this series is a single spike at the start and zero after. It exists so the period costs sum to the run's total. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | The activity's fixed cost placed in the first period, zero in every later period, then summarised across replications. | Currency |
| Inbound queue, per period | How many entities were waiting to enter this step during each stretch of the run, averaged across replications. | A queue that climbs period after period and never comes back down means the step cannot keep up over the long run. Look at its capacity or at what it waits for. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Time-weighted average inbound queue count within each period, then summarised across replications. | Entities |
| Operational cost, per period | What running this step cost during each stretch of the run, from its active and idle time, averaged across replications. | Driven by the step's active/idle split: busy periods accrue the active rate, quiet periods the idle rate. A quiet period that still costs a lot points at an expensive idle rate. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Working unit-hours within each period at the active hourly rate plus idle unit-hours at the idle rate, then summarised across replications. | Currency |
| Outbound queue, per period | How many entities were waiting to leave this step during each stretch of the run, averaged across replications. | A filling outbound queue points at a constraint further down the flow, not at this step. Follow the connection to find it. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Time-weighted average outbound queue count within each period, then summarised across replications. | Entities |
| Processing cost, per period | What this step's per-entity processing charges added up to during each stretch of the run, averaged across replications. | Follows the step's volume: a period that starts more entities costs more. Pair it with the step's contents or throughput series to separate price from volume. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Cost per entity processed times the entities captured within each period, then summarised across replications. | Currency |
| Total cost, per period | Everything this step cost during each stretch of the run, averaged across replications. | The sum of the fixed, processing and operational series. The first period carries the whole fixed cost, so a spike at the start is normal, not a data problem. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Fixed plus processing plus operational cost within each period, then summarised across replications. | Currency |
| In process by type, per period | The average number of this type being worked on at this step in each stretch of the run. | Read it beside the waiting line for the same type: in process is who is being served, waiting is who is not yet. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Time-weighted average number of this type inside the step during each period, then summarised across replications. | Entities |
| Waiting by type, per period | The average number of this type waiting to get into this step in each stretch of the run. | A type whose line keeps rising is being outpaced at this step; when only one type builds up, look at priorities or routing for it. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Time-weighted average number of this type in the step's inbound queue during each period, then summarised across replications. | Entities |
| Completions by type, per period | How many entities of this type finished at this step in each stretch of the run, averaged across replications. | Compare entity types at the same step: a type whose completions dip while another's hold steady is losing out for the step's capacity. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Count of this type's completions at this step within each period, then summarised across replications. The periods add up to the completed count. | Count |
Entities
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Completions, per period | How many entities of this type finished in each stretch of the run, averaged across replications. | A steady line means the process delivers at an even pace. A low start is the process filling up; if the early periods look very different, set a warm-up: periods that start before its end are flagged and left out of the run's figures. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Count of completions of this type within each period, then summarised across replications. The periods add up to the completed count. | Count |
| Work in progress, per period | How many entities of this type were inside the process during each stretch of the run, averaged across replications. | Work in progress that keeps rising means entities arrive faster than they finish. Look for the step whose queue grows at the same time. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Time-weighted average count of this type present within each period, then summarised across replications. | Entities |
Resources
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Units in use, per period | How many units of this resource were in use during each stretch of the run, averaged across replications. | Compare with the resource's capacity. Periods that sit at capacity are when work waited for this resource; a line well below capacity means spare units. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Time-weighted average number of units in use within each period, then summarised across replications. | Entities |
| Idle cost, per period | What this resource's idle time cost during each stretch of the run, averaged across replications. | The mirror of the busy-cost series: the quietest periods cost the most. A standing idle charge is the price of keeping capacity available whether or not it is used. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Idle time within each period at the idle hourly rate, then summarised across replications. | Currency |
| Seize cost, per period | What seizing this resource cost during each stretch of the run, averaged across replications. | Follows demand: every capture of the resource books one seize charge. Pair it with the units-in-use series to separate price from volume. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Cost per seize times the captures within each period, then summarised across replications. | Currency |
| Total cost, per period | Everything this resource cost during each stretch of the run, averaged across replications. | The sum of the seize, busy and idle series. Compare resources to see which one dominates spend, and when. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Seize plus busy plus idle cost within each period, then summarised across replications. | Currency |
| Busy cost, per period | What this resource's busy time cost during each stretch of the run, averaged across replications. | Tracks utilization: periods where more units were in use cost more. Pair it with the units-in-use series to see the volume behind the spend. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Busy time within each period at the busy hourly rate, then summarised across replications. | Currency |
Generators
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Creations, per period | How many entities this generator created in each stretch of the run, averaged across replications. | The shape should follow the generator's configured pattern or schedule. Drawn beside completions per period, a widening gap means arrivals are outrunning the process. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Count of entities created by this generator within each period, a batch counting as its size, then summarised across replications. The periods add up to the entities created. | Count |
States
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| State value, per period | The average value of this state during each stretch of the run, averaged across replications. | Shows when a state changes over the run, for example a counter that climbs or a flag that switches on. For a true/false state the value is the share of the period it was true. When the run has a warm-up, each period that starts before its end carries a warmup flag (the warmup column, present only then). Those periods are shown but are not counted in the run's figures. | Time-weighted average of the state within each period, then summarised across replications. | Count |
Moment-by-moment values
What happened at each moment. These come from the first replication, so they show one example run rather than an average.
Whole process
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Cumulative arrivals | How many entities had entered the process by that moment. | A trace from the first replication only; pair it with cumulative completions. | Running count of entity arrivals. | Entities |
| Cumulative completions | How many entities had left the process by that moment. Drawn only when the model does not join, split or create entities. | A trace from the first replication only; the gap to arrivals is work in process. | Running count of entity exits. | Entities |
Activities
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Cumulative arrivals | How many entities had asked to enter this step by that moment. | A trace from the first replication only. Drawn against cumulative completions, the vertical gap is the work waiting or in progress. | Running count of requests to enter the step. | Entities |
| Cumulative completions | How many entities had left this step by that moment. | A trace from the first replication only. If the curve runs parallel to arrivals the step keeps up; a widening gap is a backlog. | Running count of releases from the step. | Entities |
| Entities at the step | How many entities were at this step at that exact moment. | A step trace from the first replication only, so read it as one example run rather than an average. Flat stretches mean the step was idle; a rising staircase means work is piling up. | Instantaneous count at the step, recorded at each change. | Entities |
| Entities in the inbound queue | How many entities were waiting to enter this step at that moment. | First replication only. A queue that climbs and never comes back down means the step cannot keep up over the long run. | Instantaneous inbound queue count, recorded at each change. | Entities |
| Entities in the outbound queue | How many entities were waiting to leave this step at that moment. | First replication only. A filling outbound queue points at a constraint further down the flow, not at this step. | Instantaneous outbound queue count, recorded at each change. | Entities |
Entities
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Cumulative arrivals | How many entities of this type had entered the process by that moment. | A trace from the first replication only; pair it with this type's cumulative departures. | Running count of arrivals of this entity type. | Entities |
| Cumulative departures | How many entities of this type had left its flow by that moment, however they left. | A trace from the first replication only. The gap to arrivals is this type's work in process; a widening gap is a backlog. | Running count of departures of this entity type (completed, consumed, split or disposed). | Entities |
Resources
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Units of the resource in use | How many units of this resource were in use at that moment. | First replication only. Compare the plateau height with the resource's capacity to see whether it ever ran out. | Instantaneous count of seized units, recorded at each change. | Entities |
Generators
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Created at this instant | How many entities this generator created at that moment. | Matches the generator's entities-per-creation setting, or the row quantity of a schedule. Entities created at the same moment are one row. | Count of entities created by this generator at exactly this clock time. | Entities |
| Cumulative creations | How many entities this generator had created by that moment, in the first replication. | Each step is one firing; its height is how many entities it created. Long flat stretches are gaps between arrivals; drawn against an activity's cumulative arrivals, it shows how soon work reaches the first step. | Running count of entities created by this generator, one row per distinct creation instant. | Entities |
Requirements
| Metric | What it means | How to read it | How it is calculated | Unit |
|---|---|---|---|---|
| Requests waiting | How many requests were waiting for this requirement at that exact moment. | A trace from the first replication only. A rising staircase is a shortage building; a flat zero means the requirement never queued. | Instantaneous pending request count, recorded at each change. | Entities |