The above results show two producers, one with a huge backlog and one with a small backlog, both receiving the same number of orders. To plot the two delivery delays click on the producer tab in the Subscript Control and highlight both US and THEM (or click the All button). Now select delivery delay into the Workbench, and click on the Graph tool .
Here we have two widely divergent values for delivery delay, yet people continue to place the same number of orders with both producers. What we need is a connection from product availability to shipments by the producer to the amount ordered from each producer.
Assuming that the producers are not working together, the only mechanism for shifting demand must come from consumer behavior. Of the producer's activity, the only one directly observable by the customer is delivery delay. We can change the model so that customers' new purchases are allocated more favorably to the supplier with the shortest lead time.
In order to do this we need to partially introduce Subscripting into the demand side of the model. We have already created two parallel flows of people and products in this part of the model, and the Subscripting will be applied only to the order and shipment portion of this sector.
Note that initial causes have been hidden to make this diagram more readable. The new structure, shown in the lower left hand corner, determines the relative attractiveness of the two companies from delivery delay. On the basis of attractiveness, a fraction of total orders, given by the committal producer fraction, is allocated to each producer. The remaining structure is unchanged, except that Subscripts have been added to a number of the equations. The affected equations in the consumption sector are:
average delivery delay = SUM(delivery delay[producer!] * production[producer!]) / SUM(production[producer!])
Units: Year
Average delivery delay is computed as the average over the different producers weighted by production.
| committal producer fraction[producer] = |
| relative attractiveness[producer]/ |
| SUM(relative attractiveness[producer!]) |
Units: Dmnl
completions = SUM(new shipments[producer!])/product per customer
Units: Person/Year
| New Backlog[producer] = INTEG( |
| new orders[producer] - new shipments[producer], |
| new orders[producer] * norm delivery delay) |
Units: Gadget
| new orders[producer] = committals * product per customer * |
| committal producer fraction[producer] |
Units: Gadget/Year
| new shipments[producer] = total shipments[producer] * |
| New Backlog[producer]/total backlog[producer] |
Units: Gadget/Year
The computation of shipments for both new and replacement product is parallel to the original formulation, but specific to a producer. Once a customer is in with a producer, the customer sticks with that producer.
| Product In Use[producer] = INTEG( |
| new shipments[producer] + replacement shipments[producer] - replacement orders[producer], |
| Customers * committal producer fraction[producer] * |
| product per customer) |
Units: Gadget
rel attractiveness lookup ((0,5),(1,1),(2,0.5),(5,0) )
Units: Dmnl
| relative attractiveness[producer] = ACTIVE INITIAL( |
| rel attractiveness lookup(delivery delay[producer]/ |
| average delivery delay),1) |
Units: Dmnl
The function ACTIVE INITIAL is used here to prevent a simultaneous initialization problem. The initialization of the production sector requires that orders be known. But without the above ACTIVE INITIAL function the computation of orders requires that Backlog be initialized. In order to break an initial value simultaneous equation it is usually most useful to set some variable to its neutral value. In this case the natural variable to set is relative attractiveness (since it has a neutral value of 1).
| Replacement Backlog[producer] = INTEG( |
| replacement orders[producer] - replacement shipments[producer], |
| replacement orders[producer] * norm delivery delay) |
Units: Gadget
| replacement orders[producer] = Product In Use[producer]/ |
| average life product |
Units: Gadget/Year
replacement shipments[producer] = total shipments[producer] * Replacement Backlog[producer]/total backlog[producer]
Units: Gadget/Year
total backlog[producer] = New Backlog[producer] + Replacement Backlog[producer]
Units: Gadget
total orders[producer] = new orders[producer] + replacement orders[producer]
Units: Gadget/Year
total shipments[producer] = production[producer]
Units: Gadget/Year
| Waiting Customers = INTEG( |
| committals - completions, |
| SUM(New Backlog[producer!])/product per customer) |
These modified equations include both equations to which Subscripts have been added to all variables, and equations containing some Subscripted variables. There are a number of SUM functions used to go from looking at one production sector to all production sectors.
In the production sector we need to redo the equation for orders received as
orders received[producer] = total orders[producer]
All of the logic for allocating demand is now done in the consumption sector. One important note is that no equation depends on the number of production sectors. This model can be modified to include additional production sectors by simply changing the equation for producer subscript range definition.
When this model is simulated using the base parameters the behavior is precisely the same as the previous model, since the relative attractiveness of each firm is identical. Changing time to adjust capacity[US] to 2, however, produces dramatically different results.
Here the simulation was run for 10 years to show the long term results. Slowing down the adjustment of capacity does very little to smooth out the adjustment process. Instead, demand shifts to the other supplier, who ends up with nearly twice the final market. In this case if we look at delivery delay and committal producer fraction for the two suppliers we see:
There is a persistent difference in delivery delay, and it is interesting how long we lose market share. Even as our delivery delay falls, so does theirs. Furthermore, because they are growing more quickly than us, average delivery delay falls very quickly as well.
