⚙️ Flexible Job Shop Scheduler

➕ Add Machine

➕ Add Job Type

Job ID	Job Type Name	Batches Processed	Value Added Time (PT)	Non-Value Added Time (ST)	Queue Wait Time	Total Flow Time	Tardiness (Lateness)	Tardy Batches	Efficiency (VA / Flow %)

📥 Download Guide as PDF

1. Foundational Systems: Job Shop vs. Flexible Job Shop

A Standard Job Shop Scheduling Problem (JSP) is characterized by a set of discrete jobs that must be processed on a set of unique machines. Each job has a strictly defined, linear sequence of operations (a routing matrix). Each operation in a standard Job Shop must be processed on one specific pre-allocated machine, resulting in strict machine routing constraints and localized bottlenecks.

A Flexible Job Shop Scheduling Problem (FJSS/FJSSP) generalizes the standard model by introducing machine routing flexibility. In an FJSS, a single operation of a job can be processed on any machine selected from a set of feasible candidate machines (resources), often with different processing and setup durations. This creates two distinct decision-making dimensions:

• Machine Assignment (Routing): Choosing which feasible machine should process each operation of each active job to balance machine workloads.
• Operations Sequencing (Prioritisation): Determining the processing sequence (dispatching queue) for multiple jobs waiting at the same machine center to optimize metrics like tardiness or makespan.

2. Operational Input Fields & System Variables

Every input field within this application maps directly into the discrete-event scheduling algorithms. The system variables are defined below:

3. Decision Rules & Custom Priority Equations

A. Machine Routing Assignment Logic

When a job finishes an operation and needs to route to its next step, the Machine Assignment Rule resolves which feasible resource to route to:

• Least Queue Length (LQL): Routes the job to the feasible machine which presently has the lowest total process work backlog (sum of remaining processing times of all waiting jobs). Balances loading.
• First Available / Random (FA): Selects a feasible machine with the minimum current timeline value, or routes randomly if multiple are free.
• Absolute Shortest Process Time (SPT): Routes strictly to the machine that has the lowest raw processing speed for this operation, regardless of the active queue backlog at that machine.

B. Operations Sequencing (Priority) Rules

When a machine finishes its current operation and has a queue of multiple waiting jobs, the dispatching engine ranks the jobs. The job returning the lowest priority score is dispatched first:

C. High-Resolution Glossary of Core Dispatching Variables

To master custom priority equations, coordinators must understand the exact formulation and manufacturing importance of each variable token:

• LWKR / RW (Least Work Remaining / Remaining Work Content):
  Formulation: RW = Sum(Average Feasible Process Time of all remaining operations)
  Summates the work workload remaining in a job's route. By prioritizing jobs with smaller RW values, the shop acts to purge almost-completed jobs rapidly to free up inventory space (Least Work Remaining dispatching).
• SL (Slack Time Remaining):
  Formulation: Slack = DueDate - CurrentTime - RemainingWorkContent
  Represents the absolute safety buffer before a job goes late.
  • Positive Slack (SL > 0): The job is ahead of schedule; it has surplus buffer time.
  • Zero Slack (SL = 0): The job is on schedule; any delay will cause it to miss its due date.
  • Negative Slack (SL < 0): The job is already running late (past due). Minimal Slack Time (MST) dispatching ranks negative slack values first to minimize maximum tardiness.
• RO (Remaining Operations Count):
  Formulation: RO = TotalOperations - CurrentOperationIndex
  Represents the number of physical machines a job must still visit. Useful for sorting jobs that are near completion from those that have just entered the shop floor.
• FDD (Flow Due Date):
  Formulation: Flow_DueDate = ArrivalTime + (Alpha * PT)
  Sets step-wise milestones rather than a single massive end deadline. Alpha acts as an operation-spacing factor, distributing buffer margins linearly across the sequence routing matrix to prevent downstream bottlenecks.
• LTWC / LTWRK (Least Total Work Content):
  Formulation: LTWC = Sum(Average Feasible Process Time of all operation steps from start to finish)
  The raw baseline manufacturing time profile of a job type. Distinguishes small custom orders from large, complex, resource-heavy parts.
• 🎯 How Multi-Criteria Decision Making (MCDM) Rules Work (High-Level Steps):
  MCDM rules (SAW, TOPSIS, COPRAS) optimize queue sequencing by evaluating jobs against multiple, often conflicting manufacturing criteria simultaneously.
  1. Matrix Formulation: When a machine becomes free, a decision matrix is built where each waiting job is an alternative (row), and active parameters (PT, ST, DD, RO, SL, RW) are the criteria (columns).
  2. Value Normalization to Rank: Because criteria use different physical units (e.g. minutes for process times vs counts for remaining steps), the system **normalizes all values into a uniform [0, 1] scale** to make them comparable:
     • Vector Normalization (TOPSIS default): Divides each coordinate by the square root of the sum of squares of all values in the column.
     • Linear Max-Min Normalization (SAW default): Maps values linearly so that the worst coordinate becomes 0 and the best becomes 1.
     • Linear Sum Normalization (COPRAS default): Divides each coordinate by the absolute sum of all values in the column.
     • Goal-Based Cost Inversion: Cost variables (like process time to minimize) are mathematically inverted during normalization so that a higher normalized value always indicates a better, more urgent decision.
  3. Weight Normalization: The engine automatically normalizes your active criteria weights to sum to exactly 1.00, ensuring mathematical consistency.
  4. Weighted Assessment: The engine applies the normalized weights to the standardized matrix and computes final performance scores:
     • SAW: Sums the weighted standardized values directly (Simple Additive Weighting).
     • TOPSIS: Measures the geometric distance of each job from the mathematically Ideal Best Solution and the Ideal Worst Solution, ranking jobs closest to the best and farthest from the worst.
     • COPRAS: Ranks jobs based on the complex relative significance of beneficial (maximizing) and non-beneficial (minimizing) criteria indices.
  5. Optimal Selection: Ranks all waiting jobs based on their normalized scores and dispatches the job with the highest performance score first.
• ⚙️ How User-Defined Custom priority Rules Work (High-Level Steps):
  The Custom Arithmetic Equation Builder lets you craft personalized queue sequencing priorities by writing standard algebraic expressions.
  1. Equation Compilation: Construct a priority expression using variables (PT, ST, DD, RO, SL, RW) and operators (+, -, *, /, parentheses) using the point-and-click builder card. Ex: 1.5 * PT - 0.5 * SL.
  2. Real-Time Parameter Injection: Every time a machine finishes a task and evaluates its backlog, the engine injects current numeric values (adjusted for active batches and worker productivity coefficients) into the variables for each waiting job.
  3. Score Computation: Evaluates the mathematical formula safely in a local JavaScript execution environment to generate a unique numeric score for each job.
  4. No-Normalization Ranking: Unlike MCDM, standard dispatching rules and custom arithmetic equations **evaluate jobs individually without cross-normalizing values**. Ranks are assigned simply by sorting these raw computed scores in **ascending order (the lowest score gets prioritized and dispatched first)**, just like standard SPT or EDD rules.

4. Performance Dashboards & KPIs

Once the discrete-event simulator compiles the timeline, it populates the Output Dashboard:

• Makespan (C_max): The absolute calendar completion time of the very last operation of all scheduled jobs. This represents the total production horizon.
• Mean Flow Time: The average time taken by a job type from its starting operation release until its final operation completion: FlowTime = CompletionTime - ReleaseTime.
• Mean Tardiness: The average delay of all tardy jobs compared to their customer deadlines: Tardiness = Max(0, CompletionTime - DueDate).
• Value-Adding (VA) vs. Non-Value-Adding (NVA) Ratio: Compiles total busy machine processing hours (VA) against transition setups and scheduled maintenance downtime (NVA) to highlight efficiency gaps.
• Production Gantt Chart: A timeline plot depicting machine allocations. Light blue represents busy processing blocks, light red shows setup times, and dark grey represents non-value-add maintenance down intervals.
• Resource Allocation Details & Utilization Chart: Standardized grid tracking busy, setup, maintenance, and idle durations per machine center to pinpoint shop bottlenecks.