Scheduling Logic of the Production Scheduler Asprova

2011/05/11

生産スケジューラAsprova

The production scheduler Asprova, after the order list or operation list generation phase, generates operation input instructions and operation output instructions in the command execution phase by executing the order explosion command while referencing the BOM. Subsequently, the order assignment/pegging command generates operation usage instructions to perform resource allocation.

Planning Process Flow

Order List or Operation List Generation Phase

In Asprova, generating an order list from the order table is called order collection, and generating an operation list from the operation table is called operation collection. Both are stored in the parent planning parameters.

  1. Order Collection (Prepare for assignment): Collect from the order table into the order list
  2. Order Filtering (Filter orders): Filter from the order list
  3. Unassignment (Unassign all): Set operations in the operation list to unassigned

Operation filtering is set in the operation filtering condition formula of the parent planning parameters.

  1. Operation Collection (Upload operations): Collect from the operation table into the operation list
  2. Operation Filtering (Filter operations): Filter from the operation list
  3. Unassignment (Unassign all): Set operations in the operation list to unassigned

The reason the "operation collection" command is not required before the order assignment/pegging command in the default planning parameters is that the operations generated by the order explosion command are already stored in the operation list within the default planning parameters (the parent command object), eliminating the need to retrieve them again from the operation table.

Command Execution Phase

In Order Explosion (Explode orders), the auto-replenishment function references the manufacturing BOM to fulfill the order list. It generates production orders (MPS) as replenishment orders (children) to cover shortages in the operation input instructions of sales orders, and further generates production orders as replenishment orders (grandchildren) to cover shortages in the operation input instructions of the MPS.
Then, operation input instructions and operation output instructions are generated for the registered orders and replenishment orders stored in the order list.
Pegging between orders involves linking the first process operation (operation input instruction) of the current order with the final process operation (operation output instruction) of the preceding order. This applies to replenishment orders generated by auto-replenishment or production orders connected via the manufacturing BOM even without auto-replenishment.

  1. Generate replenishment orders through auto-replenishment by referencing the BOM
  2. Generate an operation list from the order list (operation input instructions and operation output instructions)
  3. Pegging between orders

In Order Assignment/Pegging (Assign/peg orders), operation usage instructions are generated while considering dispatching rules and resource evaluation properties, and operations are assigned from the operation list. Initially, tentative assignments are made to all candidate resources, followed by final assignments to the resource with the highest evaluation score.

  1. Order Assignment/Pegging (Assign/peg orders): Generate operation usage instructions from the operation list and assign them

Pegging between orders is performed twice—during order explosion and order assignment/pegging—because there are cases where re-pegging is necessary based on assignment results (e.g., when there is a minimum inventory level, pegging is shifted leftward by the minimum inventory amount). schedulingcommand

Meaning of Unassignment

After generating operations through order explosion and assigning them via order assignment/pegging, if manual plan adjustments (e.g., quantity changes) or performance input updates (e.g., adding values to parameters) occur, rescheduling with the operation status remaining "assigned" will yield the same results as before because the order explosion command does not affect operations with an "assigned" status.
Thus, unassignment is used to reset the operation status to "unassigned," allowing the creation of an updated schedule through order explosion and order assignment/pegging.
In other words, unassignment does not delete performance data entered for operations (e.g., actual quantities or acquisition dates) but is necessary to reassign based on that performance data.

  1. If the assignment flag of an operation in the order list is "assigned" during order explosion, no new operations are generated, so unassignment is always required before order explosion.
  2. Operation usage instructions are generated through order assignment/pegging, resulting in operations with an "assigned" status.
  3. Entering actual quantities or acquisition dates for operations does not automatically update the schedule.
  4. Generate an operation list through operation collection and filtering, then reset the operation status to "unassigned" via unassignment.
  5. Order assignment/pegging reflects the performance data entered in step 3 into the schedule.

Relationships Between Orders, Operations, Tasks, and Instructions

In Make-to-Order (MTO) production, the confirmed sales order shipping schedule directly becomes the demand (Master Production Schedule, MPS). In Make-to-Stock (MTS) production, the demand for MRP must be separately imported based on confirmed sales orders.
task

Reassignment Forward After Overall Backward

After assigning operations backward, they are reassigned forward starting from the morning based on their start dates and times. In composite planning parameters, it’s necessary to align the hierarchical structure of child planning parameters: "Explode orders from the order list to create operations" and "Filter the operation list and assign operations."
backforward
The meaning of StartOfNextDay(ME.Production Start DateTime, 0) is "the start of the day 0 days after (NextDay) the production start date/time," which returns the start-of-business time of the production start date/time of the assigned operation. In other words, "reassign the entire backward-assigned operations forward, but do not assign before the start-of-business time—assign from the morning of that day."
For example, StartOfNextMonth would mean "the start of the month 0 months later," referring to the first day of the current month.
If you want to start in the morning but add a 15-minute buffer for a warm-up period, shift it like this: AdvanceAlongResourceWorkingTime(ME.Main Resource, StartOfNextDay(ME.Production Start DateTime, 0), 15M).
When reassigning forward, operations assigned backward are reassigned in order of earliest start date/time.
reschedule

Backward Only for Upstream Processes After Overall Forward

When a bottleneck exists in the production process, forward assignment causes wait times in upstream processes, so only the upstream processes are reassigned backward.
By filtering operations to include only upstream processes before unassignment, it prevents downstream operations from being unassigned as well.
bottleneck

Pegging Between Orders in the Scheduler

In MRP’s demand explosion, production and purchase orders are generated, which is the same in the scheduler. However, orders generate operations composed of input instructions, usage instructions, and output instructions. Within the same order, the output instruction of the current process operation is pegged to the input instruction of the subsequent process operation. For pegging between orders, the output instruction of the final process of the current order is pegged to the input instruction of the first process of the subsequent order.
This enables the scheduler’s unique function of "sequencing and aligning orders = pegging orders together and assigning them to resources." An order list is generated from orders (MPS), an operation list is generated from the order list, and pegging is performed based on FIFO of order due dates. However, the sequence can also be manipulated by defining a sort expression for pegging, such as prioritizing orders with available material inventory.
Timing of Pegging Between Orders
The general flow of scheduling logic consists of the following two patterns, with pegging between orders occurring twice: during "order explosion" and "order assignment/pegging."

  1. Order Collection ⇒ Order Filtering ⇒ Unassignment ⇒ Order Explosion ⇒ Order Assignment/Pegging
    • Collect orders from the order table and generate an order list in the parent planning parameters
    • Generate operations and create an operation list in the parent planning parameters
  2. Operation Collection ⇒ Operation Filtering ⇒ Unassignment ⇒ Order Assignment/Pegging
    • Collect operations from the operation table and generate an operation list in the parent planning parameters

This two-step process is due to the need to create a schedule considering the minimum inventory level in the manufacturing BOM, which is referenced during order assignment/pegging:

  1. Pegging of orders during order explosion (shortages or excesses of raw materials are identified at this point)
  2. Re-pegging during order assignment/pegging while referencing the minimum inventory level in the manufacturing BOM

Pegging Object Table and Operation Table

Orders generated as a result of rescheduling are materialized in the form of a Pegging Object Table (Peg table), where operations are pegged together via the pegging object class, specifically as the pegging of output instructions and input instructions.
During order explosion:

  1. Generate operations (input instructions and output instructions) from orders
  2. Peg them using pegging objects

This process is executed by preparing lists of operation input instructions and operation output instructions for each item, sorting those lists, and pegging them from the top.
The "Sort Expression for Operation Input Instructions During Pegging" and "Sort Expression for Operation Output Instructions During Pegging" in the item class specify the sorting method for these lists, allowing changes to the pegging order, which is typically based on FIFO of order due dates.
The pegging object table is a collection of mappings between operation output instructions and operation input instructions, making it suitable for referencing materials or work-in-progress pegged 1-to-N per order. In contrast, the operation table is better suited for aggregating operations per resource assigned via operation usage instructions.

Planning from Downstream, Performance from Upstream

When orders are pegged 1-to-1, lot consolidation becomes invalid because if lot sizes differ between processes, the pegging of orders inevitably becomes 1-to-N—a simple reason.
I once passionately explained, based on my real-world experience in furniture production in Bali (The Need for Manufacturing Instructions Linking Planning and Performance), that failing to manufacture and record performance based on sales orders leads to production at the discretion of the factory floor, disconnecting sales and manufacturing. In such cases, discrepancies arise between planned and actual performance.
In make-to-order production like furniture making in Bali, the shortfall must be produced before shipping to meet the sales order quantity. However, delays in a repetitive production plan (a batch of orders) created based on sales orders do not necessarily need to be recovered on an order (instruction) basis; they can be completed as delayed and compensated by subsequent orders.
The difference between MRP and a scheduler lies in infinite capacity loading versus finite capacity leveling. From the perspective of handling discrepancies between plans and performance, MRP is driven by the quantity of the master production schedule, with production order quantities determined to meet that schedule. In contrast, the scheduler has a function to automatically adjust subsequent order quantities based on performance.
MRP, often called a "push system," relies on the master production schedule based on the finished product’s completion date as a prerequisite, and post-adjustment of planned quantities based on performance is not effective. The scheduler, however, can automatically adjust planned quantities based on post-performance data.
This is possible because manufacturing order quantities generated from downstream (sales orders) are overwritten by performance input from upstream (initial processes). Two reasons enable this:
First, the scheduler offers an MRP function for generating orders (auto-replenishment) against demand (MPS) that, unlike MRP’s lot consolidation method, generates production orders 1-to-1 while maintaining pegging from sales orders. This 1-to-1 pegging allows adjustment of planned quantities based on actual performance.
Second, performance in the scheduler is entered at the operation level, and all operations have a quantity-fixed level (Impact of Performance Input/Correction on Operation and Order Status). Operations with a high quantity-fixed level that have performance entered determine the quantities of preceding and subsequent operations within the same order.
This works when the master configuration is set to one product with multiple processes (one order with multiple operations).

Contradiction Between 1-to-1 Pegging and Lot Consolidation

The scheduler’s master setup can be broadly divided into two types:

  1. One item, one process (1 order, 1 operation)
  2. One item, multiple processes (1 order, multiple operations)

In production management systems, performance is typically entered per order (manufacturing instruction). While the scheduler allows performance input per order, it is usually done per operation after process explosion.
However, if the master is set to one item per process, one order generates one operation, making the performance input unit the same for both.
Whether work-in-progress inventory is considered depends on the presence or absence of auto-replenishment settings for work-in-progress (inventory allocation), not on the master setup.
To reflect upstream operation performance in downstream planned quantities, the master must either be set to one item with multiple processes with operations pegged within the same order, or one item per process with auto-replenishment set to 1-to-1.
In cases of 1-to-N auto-replenishment, upstream planned quantities are met by pegging to a different downstream order, preventing the overwriting of planned quantities with performance.
Since upstream performance quantities are reflected in downstream planned quantities, this is effective only during forward planning.
Contradiction Between 1-to-1 Pegging and Lot Consolidation
Pegging 1-to-1 means aligning with the lot size of either the preceding or subsequent process, rendering the lot size setting ineffective.
Setting different lot sizes for work-in-progress inevitably results in 1-to-N pegging, making it impossible to adjust preceding and subsequent processes based on performance quantities.
For plan-performance discrepancies to be reflected in downstream planned quantities, orders must not be pegged to other sales orders.

Optimization Metrics

The core functions of the scheduling logic are generating operations from orders and pegging them (order explosion) and assigning operations to resources (order assignment/pegging), achieved through the following two commands:

Order Explosion

  1. Generate operations (operation input instructions and operation output instructions)
  2. Generate orders for shortages in input instructions via auto-replenishment
  3. Peg the input instruction of the order’s first process to the output instruction of the final process of the preceding order

Order Assignment/Pegging

  1. Tentative Assignment: Master usage instructions and dispatching rules
  2. Resource Evaluation: 11 standard evaluation formulas + additional evaluation formulas
  3. Final Assignment

Optimization is generally measured by improvements in utilization rates or lead times, with the following adjustment parameters considered:

  1. Resource Evaluation (selection of alternative resources)
  2. Assignment Direction (TOC centered on bottlenecks)
  3. Operation Splitting (wait time reduction)
  4. Overlap Method (wait time reduction)
  5. Operation Sequence (reduction of setup frequency, conversion of internal setups to external setups, prioritization of operations with available materials)

Optimization policies vary by factory, but adjusting these parameters influences the tendency of operation assignments during schedule creation, enabling the generation of uniquely optimized schedules tailored to each factory.

Adjusting Operation Assignment to Resources via Resource Evaluation

Within order assignment/pegging, resource evaluation is performed based on tentative assignments to resources, followed by final assignments.

Applying Only Resource Priority from Manufacturing BOM

By selecting "Priority Resource" (typically "Maximum Evaluation Resource") in the assigned resource property, assignments are made only to the resource with the highest priority in the manufacturing BOM.

Assigning to Alternative Resources When the Highest-Priority Resource is Full

By setting 1 to "Weight – Resource Priority" in resource evaluation weights, assignments prioritize the resource with the highest priority, switching to alternative resources only when it’s full.

Load-Leveling Assignment

By setting 1 to "Weight – Load Leveling" in resource evaluation weights, assignments are evenly distributed across alternative resources.

Adjusting Operation Assignment to Resources via Additional Evaluation Formulas

Resource Evaluation and Additional Evaluation Formulas

Resource evaluation includes 11 standard properties, allowing assignment methods to vary by resource, but not by output item.

  1. Weight – Load Leveling
  2. Weight – Setup Time Minimization
  3. Weight – Resource Priority
  4. Weight – Wait Time Minimization
  5. Weight – Due Date Delay Minimization
  6. Weight – Production Time Minimization
  7. Weight – Same Order Priority
  8. Weight – Same Item Priority

When condition settings beyond the 11 resource evaluations are needed, additional evaluation formulas can be used alongside standard evaluations. However, since additional evaluations are called before operations are assigned, the following ME TentAssign-based evaluation formulas must be used to perform additional evaluations based on tentative assignment results:

  1. Evaluation Time – Master Usage Instruction (me.TentAssignCurrUseBomInst)
  2. Evaluation Time – Target Operation (me.TentAssignCurrOper)
  3. Evaluation Time – Right Operation (me.TentAssignRightOper)
  4. Evaluation Time – Left Operation (me.TentAssignLeftOper)
  5. Evaluation Time – Target Resource (me.TentAssignCurrRes)

If the target operation at evaluation time is a work-in-progress item (e.g., a pressed part including parent item 51096-BZ010) of product 51096-BZ010, assignments level the load rate calculated by ResourceLoad (same as "Weight – Load Leveling" in resource evaluation). For other operations, resource priority (same as "Weight – Resource Priority" in resource evaluation) is referenced.

  • IF(CheckAllContents_Or(ME.Evaluation Time – Target Operation.Main Output Item.'Parent Item (Recursive)','==','51096-BZ010'),ResourceLoad(ME.Evaluation Time – Target Resource,PROJECT.Assignment Start DateTime,PROJECT.Assignment End DateTime), ME.Evaluation Time – Master Usage Instruction.Resource Priority)
  • CheckAllContents_Or: OR-checks all data (single or multiple) of a property based on a condition
  • ResourceLoad: Calculates load rate from the resource

Prioritize Assignment to the Same Resource if Specification 1 of the Left Operation Matches

Perform resource evaluation so that if the left operation and the current operation have the same Specification 1, the result is 1; otherwise, it’s 0, prioritizing assignment to that resource if Specification 1 matches.

  • 1*IF(GetApplicableSpec(1,ME.Evaluation Time – Target Operation)==GetApplicableSpec(1,ME.Evaluation Time – Left Operation),1,0)
  • GetApplicableSpec: Returns the value of Specification 1 for the operation specified in the second argument when the first argument is Specification (Specification 1). If Specification 1 of the left and current operations doesn’t match, set 1 to consider "Weight – Load Leveling."

Process Overlap Methods

Overlap methods and minimum overlap are set for the subsequent process relative to the current process. If operations are not split into lots, ES or SSEE is set.

  • SSEE (Start-Start End-End) associates the start and end of the preceding and subsequent processes, used when the subsequent process finishes earlier.

Process Overlap Method

  • EES (End-Each-Start) starts the subsequent process midway through the preceding process when the subsequent process is split (Each).

Process Overlap Method

Difference Between Referencing from ME and PROJECT

To reference a specific item object or resource object externally rather than from the currently executing instance, use Project as the base point and reference via child objects.

Display the value of the Code property, the key of the final object (process) of the child objects of the current object in the item table, i.e., the final process code.

  • ME.Child Object[0]

Display the final object (process) of the child objects of the first object in the Item table object (where the key property Code is ProductA).

  • Project.Child Object['Item'].Child Object[1].Child Object[0]
  • Project.Child Object['Item'].Child Object['ProductA'].Child Object[0]

object
Objects are associative arrays, so when referencing item records from PROJECT, specify them by index (number) or Code property value to access property values.
Unlike regular arrays, array indices start from [1], and [0] represents the last property value.

Referencing Specific Resource Material Calc from Project

Reference a resource object with the Code property value "Material Calc" within the resource table, a child object of the Project object.

Obtain a date/time advanced by a specified duration from a specified date/time along the operating hours of a specific resource.

  • AdvanceAlongResourceWorkingTime(PROJECT.Child Object['Resource'].Child Object['Material Calc'],ME.Last Parent Order[1].Due Date,(-1)*(ME.Item.'Material LT'-ME.Item.ProcessLT))
  • AdvanceAlongResourceWorkingTime(Specific Resource, Specified DateTime, Duration to Advance)

Obtaining Planning Base Date from Project

Obtain the number of working days for a specified resource in a given time period.

  • GetWorkingDays(StartOfNextMonth(PROJECT.Planning Base DateTime,0),StartOfNextMonth(PROJECT.Planning Base DateTime,1),ME.Sales Order Plan Object[1].Calendar Reference Resource,24H)
  • GetWorkingDays(Start Date, End Date, Specific Resource, Hours per Day)

Incidentally, the sales order plan object is an array type containing objects such as:

  1. Sales Order Plan Object[1]: Item
  2. Sales Order Plan Object[2]: Customer
  3. Sales Order Plan Object[3]: Type
  4. Sales Order Plan Object[4]: Quantity

Display Formula and Display Reverse Conversion Formula

Virtual property formulas reference other properties within the current object, while display formulas are display conversions for the current object’s own properties. Fixing the time in a display formula makes it Read Only, and a display reverse conversion formula makes the property with the display formula Read Write.
INPUT is the value of the property with the display formula, converted to a string. In this case, FindNumberL(INPUT,1) converts it to a number, meaning the first numeric value in the string (value) that INPUT refers to.

Order Quantity with Comma-Separated Thousands

  • Display Formula: Format(ME.Qty,'#,###')
  • Display Reverse Conversion Formula: FindNumberL(INPUT,1)

Set Due Date Time to 23:59:59

  • Display Formula: DateF(GetYearPart(ME.Latest End DateTime),GetMonthPart(ME.Latest End DateTime),GetDayPart(ME.Latest End DateTime),23,59,59)
  • Display Reverse Conversion Formula: DateF(FindNumberL(INPUT,1),FindNumberL(INPUT,2),FindNumberL(INPUT,3),23,59,59)

Virtual Property Formula and Virtual Property Reverse Conversion Formula

Both ME and HOLDER refer to the current object, but referencing via ME makes it Read Only (user object), while referencing via HOLDER makes it Read Write (owner object).

  1. HOLDER (Current Object)
  2. ME (Current Object)
  3. OTHER (Object paired with ME in a property set to compare two property values)

By entering the string "100 units" (INPUT) into a user-defined property in the order table, the numeric part of the entered string, `FindNumberL(INPUT,1)`, can be copied to "HOLDER.Order Quantity."
object2

ME and OTHER for Comparing Two Properties Within the Same Object

To compare property values of two records (objects) within the same object, use ME and OTHER. For example, in an item’s pegging condition formula property, to peg orders if Specification 1 is the same:

  • ME.Order.Specification1==OTHER.Order.Specification1

TARGET Referring to the First Argument of Internal Functions for Minimum, Maximum, and Sum

TARGET specifies an object as the first argument of internal functions Max, MaxIF, Sum, and SumIF. By specifying TARGET in the second argument onward, TARGET refers to the object in the first argument.

Conditional Sum SUMIF

Since TARGET is the sales order plan object, obtain the total quantity from the sales order plan when the type is "forecast."

  • SumIF(ME.'Parent Item (Recursive)'.Sales Order Plan Object,TARGET.Type=='Forecast',TARGET.Quantity)

Conditional Maximum MAXIF

Since TARGET is the order object, obtain the maximum value of TMP FIN DATE in the order table when the process number is 22.

  • MaxIF('Order',TARGET.'No Process'==22,TARGET.'TMP FIN DATE')

Sum SUM

Since TARGET is orders using this item, calculate the total order quantity in the order table per item.

Sum(ME.'Parent Item (Recursive)'.Orders Using This Item,TARGET.Order Quantity)

StartOfNextDay(Week, Month) Referring to Start DateTime 0 Days, 0 Weeks, or 0 Months Later

When consolidating by day, week, or month during dispatching, "0 days later (0 weeks later, 0 months later) from the due date" means consolidating operations on the same day (week, month).

  • Day Consolidation: StartOfNextDay(ME.Order.Due Date,0) ⇒ The start of 0 days ahead, so today’s assignment start date
  • Week Consolidation: StartOfNextWeek(ME.Order.Due Date,0) ⇒ The first day of 0 weeks ahead, so this week’s first day
  • Month Consolidation: StartOfNextMonth(ME.Order.Due Date,0) ⇒ The first day of 0 months ahead, so this month’s first day