Scheduling Synchronized Multi-Spindle Operations in EDGEBIC

Synchronized machine scheduling exists for one physical reality: some machines cannot work independently because they are bolted to the same motion. Three drill heads ganged on one gantry, twin welding robots on one frame, a filling line with slaved stations: all must start at the same instant and stop at the same instant. This walkthrough shows how EDGEBIC by User Solutions schedules exactly that case, with every hour and timestamp shown. It belongs to our worked examples series, where the engine is judged by its arithmetic.

The Physical Picture: One Gantry, Three Heads

A job shop builds large structural frames. One routing step, multi-spindle drilling, must put 300 precision holes through a single workpiece using three drill heads mounted on one gantry. The gantry moves as one unit. You cannot run head 1 on Monday and head 2 on Tuesday; either all three run, or none do.

The master data mirrors the physics:

All three share one day shift: Monday to Friday, 08:00 to 16:00, 8 hours per day. The drilling step is configured on the lead head with 8.0 hours of run time per frame plus a 0.5-hour rig-up, and the two other heads are attached to the step as dependent parallel work centers. That dependent flag is the whole trick: it tells the engine these are mirrors to be copied, not competitors to be scheduled.

The order: one frame, due Friday.

Two Kinds of Parallel, One Critical Difference

Before the walkthrough, the distinction that decides everything:

Independent parallel says "these machines can share the work if they are all free." Dependent parallel says "these machines are physically one thing." Choosing the wrong model produces either impossible schedules (mirrors placed on different days) or phantom bottlenecks (mirrors blocking a search they should never participate in). This is a place where finite capacity logic needs to know when not to apply itself.

Step 1: The Lead Head Gets a Real Schedule

The planner schedules the order. The engine walks the routing, reaches the drilling step, and recognizes the parallel configuration. It splits the attached work centers into the lead (DRILL-HEAD-1) and the dependents (HEAD-2 and HEAD-3), and because there are no independent parallels in the mix, it runs a completely ordinary capacity search for the lead head only.

The workload: 8.0 hours per frame x 1 frame + 0.5 setup = 8.5 hours. Monday's shift holds 8.0. So the allocator places 8.0 hours on Monday (08:00 to 16:00) and spills the final 0.5 hours to Tuesday morning (08:00 to 08:30). The lead head's schedule:

Note the setup provenance stamp. EDGEBIC records where every setup number came from; here the head had no prior job, so the routing's own 0.5-hour rig-up applied. That audit trail matters more in the sequence-dependent setup scenarios covered in the paint shop changeover walkthrough.

Step 2: The Mirrors Are Copied, Not Scheduled

Now the engine loops over the two dependent heads and creates each schedule by copying the parent, resource row by resource row:

• Start and end timestamps: copied exactly. Monday 08:00 and Tuesday 08:30, identical on all three.
• Allocated hours: multiplied by the head's factor.
• Setup: mirrored one-to-one, never scaled (the heads rig together; rig-up is one physical event).
• Setup provenance on the mirrors: stamped "mirrored from parent," so anyone auditing later can see these rows were copies, not independent placements.

For DRILL-HEAD-2 (factor 1.0) the mirror is an exact twin: 8.0 hours Monday, 0.5 Tuesday, 8.50 tracked. For DRILL-HEAD-3 the factor changes the bookkeeping but not the clock:

Read that third column twice, because it is the heart of the model. The factor scales work recorded, not time elapsed. The older head works 50 percent harder to keep pace with the gantry, so it logs 12.75 hours of effort across the identical Monday-to-Tuesday span. Its end time never moves, because physically it stops when the gantry stops.

Step 3: Over-Capacity, On Purpose

Here is the part that makes capacity purists flinch, and it is deliberate: DRILL-HEAD-3's Monday allocation is 12.0 hours against an 8.0-hour shift. The mirroring step skips the capacity validation that every normal allocation must pass, because a dependent head is not competing for time; it is physically committed the moment the parent is.

EDGEBIC does not hide this. The over-capacity condition on dependent mirrors is documented behavior with its own audit check, so a planner reviewing utilization reports can distinguish "this machine is double-booked by mistake" from "this mirror is carrying its factor." Honest over-capacity beats silent misrepresentation.

The Result: Three Bars, One Clock

The committed schedule contains three operation rows, all referencing the same routing step:

DRILL-HEAD-1  Mon 08:00 ████████████████████ 16:00 | Tue 08:00 ██ 08:30
DRILL-HEAD-2  Mon 08:00 ████████████████████ 16:00 | Tue 08:00 ██ 08:30
DRILL-HEAD-3  Mon 08:00 ████████████████████ 16:00 | Tue 08:00 ██ 08:30

              ↑ all three start together                ↑ all three finish together

On the Job Gantt you see three bars of identical length, stacked in the three work center rows. Hover the mirror bars and the setup reason reads "mirrored from parent." The order's start and end update to Monday 08:00 and Tuesday 08:30, and the synchronization is not a happy accident of the search: it is structurally guaranteed, because two of the three schedules are copies of the first.

Verification is one query away for the skeptical: select the three operation rows and confirm identical start and end timestamps and a single shared routing step reference; select the resource rows and confirm HEAD-3 carries 12.0 and 0.75 hours where the parent carries 8.0 and 0.5.

What This Run Proves

Six behaviors you can verify from this single one-frame order:

1. The dependent flag changes the algorithm, not just a label. Mirrors never enter the capacity search; only the lead head is placed against real shift capacity.
2. Synchronization is structural. All three schedules carry identical start and end timestamps because two of them are copies, not because a search happened to line up.
3. Factors scale effort, never elapsed time. The factor-1.5 head records 12.75 tracked hours across the same Monday-to-Tuesday span as the parent's 8.50.
4. Setup is one physical event. Rig-up hours are mirrored one-to-one and never multiplied by a factor, because the heads rig together.
5. Every mirror is auditable. The setup provenance stamp reads "mirrored from parent" on both dependent rows, so no one mistakes a copy for an independent placement.
6. Over-capacity on mirrors is visible and intentional. The capacity ledger shows the 12-hour Monday allocation openly instead of hiding the factor's cost.

Variations Worth Trying

A faster head instead of a slower one. Set HEAD-2's factor to 0.5 and its mirror records 4.0 hours Monday and 0.25 Tuesday (4.25 tracked), with the time span unchanged. Factors express relative effort in either direction.

Quantity three instead of one. The parent's workload becomes 8 x 3 + 0.5 = 24.5 hours, spread Monday through Thursday morning. The mirrors copy all four daily allocations with identical timestamps: three heads working Monday to Thursday 08:30 in lockstep. One field changed; the synchronization scales along.

A fourth, truly independent head. Add DRILL-HEAD-4 configured as independent parallel and the engine's behavior changes fundamentally: now it searches for a slot where the lead and the independent head both have simultaneous free capacity, and only after both are placed do the two dependent mirrors copy on. If HEAD-4 is booked Monday, the whole group slides to Tuesday, mirrors included. That all-or-nothing search is the independent model doing its job.

Back-to-back frames and changeover. Schedule a second frame of a different product right behind the first, and the lead head's next setup is resolved against the sequence-dependent setup matrix (what ran last on this head decides the changeover), while the mirrors continue to inherit their setup from the parent. The mechanics of that matrix get their own changeover sequencing walkthrough.

Why Model It This Way at All?

The lazy alternative is to schedule only the lead head and pretend the other two do not exist. That works until you look at a utilization report, a labor plan, or a costing rollup and find two-thirds of your gantry's effort missing. The dependent parallel model keeps the mirrors visible everywhere (Gantt, capacity ledger, tracked hours) while making it structurally impossible for them to drift out of sync with the machine they are bolted to. And when the gantry breaks mid-job, the breakdown reschedule walkthrough shows how logged hours on all three heads survive the replan.

Ganged and slaved equipment is common in exactly the industries User Solutions has served since 1991: aerospace and defense (BAE Systems, the US Navy), heavy equipment (GE, Cummins), and job shops in between. EDGEBIC's dependent parallel model is the current generation of that experience; if you are on RMDB today, the upgrade path is documented.

Have a gantry, a slaved line, or a multi-head machine that your current scheduler pretends is three separate resources? Contact US and we will model it as one, with your numbers.