Inventory: number of flow units contained
Flow Rate(COGS & R): rate at which process is delivering
output (unit/time)
eg: In _ year, there were
Littles Law I = R x T
Inventory Turns = 1/Flow time = 1/T = (turns/time)
Per-Unit Inventory Costs = Annual Inventory Costs/Annual
Inventory Turns
Capacity-(unit/time)
Bottleneck-resource with smallest capacity.
Flow Rate (unit/time)- Minimum{Available Input, Demand,
Process Capacity}
Demand Constrained- demand is lower than supply
Supply Constrained- demand exceeds supply
Time to fulfill X Units = X/Flow Rate Utilization = Flow Rate/
Capacity
Implied Utilization = demand/capacity (can exceed 100% /
bottleneck has highest utilization)
Flow Unit Minute of Work
Each worker has 60min/hr
Demand (unit/hour) Process (min/unit) D x P (Min/hr)
Processing Time = Activity time= Service Time
Capacity = Number of Resources/Processing Time
Time to Finish X in an empty process
Time through empty process + (X-1)/Flow Rate
Sum of Processing Times + (X-1)*Cycle Time
Cycle Time = 1/Flow Rate
Buffer Or Suffer
Capacity = (B)/(S+B*p) =
(Amount processed between 2 stops)/(duration of stop
+ (time to produce [time/unit] *Amount processed between 2
stops)
If there is a process that can only work a 10 hours out of 12
then the capacity calculated of system is based on the 10 hours
worked.
Cost of Direct Labor = Total Wages per unit time/ Flow Rate
(p*wage rate)/utilization
Idle Time = Cycle time*#of workers at resource (n)-
Processing time at (n) check if per unit
Labor Utilization= LaborContent/LaborContent+Idle Time
Labor Content = sum of all processing with labor
Pooling
Multiple resources into one megaresource.
Operations can use pooling to reduce customer
waiting time
Reduce amount of workers while maintaining same
responsiveness
Pooling benefits are lower when systems pooled are
not independent.
Appointment systems can reduce variability in the
arrival process.
Shortest-Processing Time Minimizes average waiting
time and flow time.
Multiple Flow Units
1 worker = 60 min/hr check how many hours/day etc..
Demand = units/hr Processing Time = Min/unit
D*P = min/hr
Capacity Given Batch Size =
(Batch Size)/(SetUp Time + (Batch Size*Processing Time))
Set Up Time includes all set ups (time)
Processing Time (time/units) - all production time
1/P is maximum capacity
Capacity At Assembly = unit/time*workers
*Flow rate = Capacity at Assembly (target=assembly cap)
If setup occurs at bottleneck increase batch size
If set up occurs at non bottleneck decrease batch size
Recommended Batch = (Flow Rate x Setup Time) / (1-(Flow
Rate*Processing Time))
Flow Rate Minimum{Available Input, Demand, Process Capacity}
Capacity with Mixed Batches = (Batch Size/Set Up+(B1*P1)+
(B2+P2)
Multiple Batches Average inventory = (1/2) x Batch size x (1- Flow
rate x Processing time)
Average Inventory w/batching = 1/2*(Batch size)*(1-Flow
rate*Processing time)
EOQ Model
Average Inventory = 1/2*Order Quantity
Inventory Cost [per unit time] = 1/2*Order Quantity*h(inventory cost)
I/R = Time of supply Q/R= Order Cycle
Set Up Costs [per unit time] = Set Up Costs/Length of order cycle
K*R/Q
C(Q) = K*R/Q + 1/2*h*Q
EOC = sqrt(2*set up costs*flow rate/holding cost)
sqrt(2*K*R/holding cost)
holding cost %*Purchase Price*Time Conversion
Cost per Unit time when ordering Q* = C(Q*) = sqrt(2*K*R*h)
Cost Per Unit = C(Q*)/R
EOC With Discounts
Flow Rate*Price/unit + C(Q*)
Flow Rate*Price/unit*(1-%Discount) + C(Order Size)
C(Order Size) = holding + R*K/Q
How many orders placed = R/EOQ
Queues
Utilization: Flow Rate/Capacity = p/a
Coefficient of Variation = CV = Standard Deviation/Mean
Flow time = Time in queue + Processing time
Inventory = Inventory in Queue + Inventory Processing
Time in Queue =
(p/m)*(Utilization^(sqrt(2*(m+1))-1)/1-Utilization)*(CVa^2+CVp^2/2)
Average Inventory is = (Tq + p)/a
Utilization = p/(a*m)
a = time/unit p = time/unit capacity of each server = 1/p
Flow Rate = 1/a (unit/time)
Capacity = m/p
Inventory in Queue = Tq/a Inventory Processing = p/a
Total Inventory = Iq+Ip
Probabilities
Maximin: maximum minimum payoff of outcomes
Maximax: maximum maximum payoff of outcomes
Expected Profit: likely outcome weighted against probabilities
EVPI (Expected Value of Perfect Information): the difference in
profit between expected profit (without perfect information)
and what could be earned with perfect information
EVSI (Expected Value of Sample Information): the difference
between the expected profit with the test and the expected profit
without the test. EVSI = 0 if your subsequent actions do not
depend on
Probabilities

Monthly turns = Avg. monthly flow rate / Inventory

Prior Probabilities Pr(B) -initial probability assessment

Weekly turns = Avg. weekly flow rate / Inventory

Yearly turns = Avg. annual flow rate / Inventory
Posterior (Conditional) Probabilities Pr(A|B) - probability
that A happens given that B occurs

Daily turns = Avg. daily flow rate / Inventory

Joint Probabilities Pr(A&B) - probability that both events A
and B occur
Bayes Rule Pr(A|B)=Pr(A&B)/Pr(B) - links prior, joint and
posterior probabilities
EVSI = EVPI if the test is perfectly diagnostic, that is when
the test never makes a mistake,
Pr(A)=Pr(A|B)*Pr(B)+Pr(A|C)*(1Pr(C)) ~ 1-P(C)=P(B)

gross margin
(selling price-purchase cost)

Setup times, then capacity

depends on the production
schedule:
Capacity + as batch size +
Inventory + as batch size +
Utilization may + as batch size +
Tradeoff between capacity and
inventory

Key Principles

Inspect for quality is most val. in front of bottleneck.

Buffer or Suffer inventory can be used to decouple

Large batches = problematic when bad quality

the supply process from demand, thereby restoring the
flow rate to the level achievable the absence of

Large batches can lead to wasted capacity.

Firms should adopt quality at the source
variability.

Inspect quality when an item is produced.

Pooling does not change utilization, simply

Rework = reduce bottleneck capacity

decreases time in queue with the same amount of
labor
Pooling- Total Arrival Rate= CV/a1+CV/a2
Interarrival Time=1/Total Arrival Rate
Blocking: prevented from completing its work.

Inspect 1st item in a batch

Starving: it could work but it lacks inputs to work on.
Blocking and starving at a non-bottleneck resource
might not reduce the flow rate
Blocking and starving at a bottleneck resource
reduces the flow rate (add inventory to the process so
Regular that you dont block the bottleneck)
Variability can reduce capacity without buffers.
Shortest processing time minimizes the average
waiting time and flow time.

Sample
Perfect