Calculate Phase
Overview
The Calculate phase is where the Process List Manager and PIN Manager resolve payroll or absence logic. This is the most configuration-sensitive stage of the lifecycle and the place where most business-rule defects actually become visible.
Calculate Sequence
Run Control Options During Calculate
| Option | What it does |
|---|---|
| Calculate | Processes payees in error, suspended payees, payees marked Recalculate or Uncancel, and payees with iterative triggers unless frozen |
| Recalculate All | Deletes existing calculations and recalculates the full selected population, including frozen payees |
| Freeze | Prevents later triggers and late positive input from changing already calculated payees |
| Un-freeze | Returns frozen payees to the normal calculated state so later Calculate runs can update them |
How Payees Are Processed
The engine calculates one payee at a time, calendar by calendar. If a calendar is segmented, the system calculates each segment for that payee before moving to the next calendar or the next payee. This sequencing matters because accumulators and downstream values are updated in that same logical order.
What The Engine Loads First
The engine begins by loading process-level data into arrays from sources such as:
- pay entity
- pay group
- eligibility group
- calendar
- process list
It then loads payee-level data from sources such as Job, Person, Compensation, Overrides, and Positive Input.
Key Arrays And Structures
| Item | Role |
|---|---|
PINV | Holds resolved values during calculation |
PINW | Holds working accumulator and intermediate values |
| Process Stat / Segment Stat | Supply the current payee and segment context |
| Result tables | Receive final values after array processing completes |
Resolution Behavior
The engine checks element eligibility, then the Process List Manager calls the PIN Manager in process-list order. If an element depends on other elements, the PIN Manager resolves those recursively and stores the results in arrays before returning control to the next process-list element.
This is why a single wrong system element, override, or formula can create widespread downstream variance.
What Recalculates On Later Runs
After the first full Calculate run, later iterations usually process:
- payees that were placed in error during a previous run
- payees in suspended status
- payees for whom you manually set a process indicator such as Recalculate or Uncancel
- payees with iterative triggers, unless they are frozen
Freeze And Unfreeze Strategy
Freeze is useful late in the pay cycle when you want to stop absorbing iterative changes and focus on clearing blocking errors. While a payee is frozen:
- later iterative triggers are ignored
- later positive input is ignored
- the triggers are still retained so the payee can be brought back into scope if unfrozen later
If you run Recalculate All, frozen payees are recalculated anyway.
Review And Diagnostic Tools
The delivered review flow after Calculate normally uses:
- the Log File for batch-level health
- Processing Statistics for payee counts by status
- Payee Messages for errors and warnings
- Results pages for business validation
- Element Resolution Chain when a specific PIN must be traced
The trace chain and tuning statistics are expensive and should be used intentionally, not on every cycle.
Key Takeaways
- Calculate is process-list driven, array-based, and recursive.
- Iterative processing is what makes preliminary payroll runs efficient.
- Effective diagnostics depend on tracing the failing payee, segment, section, PIN, and upstream source value.