- 92 Views
- Uploaded on
- Presentation posted in: General

Discrete Event Systems Simulation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Discrete Event Systems Simulation

Queuing systems

Inventory model

Insurance risk model

Repair problem

Stock price model

- Time variable t: the amount of simulated time that has elapsed.
- Counter variables: a count of number of times that certain events have occurred by time t.
- System state (SS) variables: State of the system at time t.

- A system with just one server where the customers (jobs) arrive according to a Poisson process (with rate λ).
- If the server is free at that moment, the customer enters the service or else joins the waiting queue.
- When the server completes serving a customer, the next customer waiting in line enters the service (the customer who has waited the longest – the first in/first out rule).
- If there are no waiting customer, the server remains free until the next customer’s arrival.
- The amount of time taken by server to complete service for a customer is a random variable with probability distribution G (for M/M/1 queues,G = exponential dist. function).
- All the service times are independent of each other.

- Assume that after a fixed time T, no customers are allowed to enter the system, although the server completes servicing all those that are already in the system at time T.
- Performance parameters:
- The average time a customer spends in the system (W).
- The average time past T that the last customer departs – the average time at which the server finally becomes idle.

Simulation variables

- Time variables : t (current time)
- Counter variables : NA – the # of arrivals by time t;
ND – the # of departures by time t.

- System state variables : n – the # of customers in the
system at time t.

- Event-list: EL = tA, tD.
tA is the time of next arrival (after t) and tD is the service completion time of customer presently being served. If there is no customer presently being served, then tD is set equal to infinity.

- The output variables that will be collected are:
A(i) – the arrival time of customer i;

D(i) – the departure time of customer i; and

Tp -- the time past T that the last customer departs.

Initialize:

- Set t = 0, NA = 0, ND = 0.
- Set SS = 0.
- Generate T0, and set tA = T0, tD = ∞.
- To update the system, we move along the time axis until we encounter the next event. The “next event” is decided by comparing tAand tD, and choosing the smaller value.
- Every time a customer starts service at the server, we generate a random variable Y with a distribution G to obtain the service time for that customer and use it to obtain tD.

t = time variable; SS = n; EL = tA, tD.

Case I:

- Reset t = tA (we move along to time tA).
- Reset NA = NA + 1 (since there is a new arrival at time tA)
- Reset n = n + 1 (because there is one more customer in the system).
- Generate Tt. And reset tA = Tt (this is the time for next arrival).

- If n = 1, generate Y and reset tD = t + Y (because the system had been empty and so we need to generate the service time of the new customer).
- Collect output data A(NA) = t (because customer NA arrived at time t).

Case II:

- Reset t = tD (we move along to time tD).
- Reset ND = ND + 1 (since there is a departure at time tD)
- Reset n = n - 1 (one customer is left the system).
- If n = 0, reset tD= ∞; otherwise generate Y and reset tD = t + Y .
- Collect output data D(ND) = t (because customer ND departed at time t).

Case III: min (tA, tD) > T; n > 0.

- Reset t = tD.
- Reset ND = ND + 1.
- Reset n = n - 1.
- If n > 0, generate Y and reset tD = t + Y .
- Collect output data D(ND) = t.
Case IV: min (tA, tD) > T; n = 0.

- Collect output data Tp = max (t - T, 0).

- Two-server system in which customers arrive according to a Poisson process.
- Suppose that each arrival must first be served by server 1 and upon completion of service at 1, the customer goes over to server 2.
- This system is called tandem or sequential queuing system.
- Upon arrival the customer will either enter service with server 1 if that server is free, or join the queue for server 1 otherwise.

- When the customer completes the service at server 1, then (s/)he either enters the service with server 2 if that server is free, or else it joins its queue.
- After being served at server 2 the customer departs the system.
- The service times at server i have distribution Gi, i = 1, 2.
- We are interested in the distribution of time that a customer spends at both servers. That is, W and WQ at server 1 and server 2.

List of variables

- Time variable: t
- System state (SS) variable: (n1, n2) where ni is the number of customers at server i.
- Counter variables:
NA – the # of arrivals by time t;

ND – the # of departures by time t.

- Output variables:
A1(i) – the arrival time of customer i;

A2(i) – the arrival time of customer i at server 2;

D(i) – the departure time of customer i;

- Event list: tA, t1, t2
where tA is the time of next arrival; ti is the service completion time of customer presently being served by server i, (i = 1, 2). If there are no customer presently at server i, then ti = ∞, (i = 1, 2).

- The event list always consists of these three variables: tA, t1, t2.

Initialize

- Set t = 0, NA = 0, ND = 0.
- Set SS = 0.
- Generate T0, and set tA = T0, t1 = ∞, t2 = ∞.
- As always, we move along the time axis until we reach the time for the next event. Depending on what this next event is, we consider different cases.
- As we did previously, let Yi refer to a random variable having distribution Gi, i= 1, 2, which will be used to calculate t1, t2.

Case I: tA = min{tA, t1, t2}

- Reset t = tA,
- Reset NA = NA + 1 (since there is a new arrival at time tA)
- Reset n1 = n1 + 1 (because there is one more customer in the system and that customer is with server 1).
- Generate Tt , and reset tA = Tt (this is the time for next arrival).
- If n1 = 1, generate Y1 and reset t1 = t + Y1.
- Collect output data A1(NA) = t (because customer NA arrived at time t at server 1).

Case II: t1 < tA, t1 <= t2.

- Reset t = t1.
- Reset n1 = n1 – 1; n2 = n2 + 1.
- If n1 = 0, reset t1 = ∞; otherwise generate Y1 and reset t1 = t + Y1.
- If n2= 1, generate Y2, and reset t2 = t + Y2.
- Collect the output data A2(NA – n1) = t.

Case III: t2 < tA, t2 < t1.

- Reset t = t2.
- Reset ND = ND + 1.
- Reset n2 = n2 – 1.
- If n2 = 0, reset t2 = ∞; otherwise generate Y2, and reset t2 = t + Y2.
- Collect the output data D(ND) = t.

- Upon arrival the customer has three options:
- The customer will join the queue if both servers are busy;
- Enter service with server 1 if that server is free; or
- Enter service with server 2 otherwise.
- When the customer completes the service with any server, that customer departs the system.
- The system follows the first-in-first-out principle. So the customer waiting the longest will enter the service next.
- The service time distribution at server i is Gi, i = 1, 2.

- We want to know the average time spent in the system by each customer, and the number of services provided by each server.
- Since there are multiple servers, it is obvious that the customers may not depart the system in the same order as they arrive. Why?
- However, we note that the customer enter service in order of their arrival. How?
- To keep track of which customer is leaving the system, we will have number each arriving customer. So the first arrival is customer 1, and so on.

- Suppose that customers i and j are being served by servers 1 and 2 respectively, where i < j, and that there are n – 2 > 0 others waiting in the queue (LQ = n – 2).
- Since customer j is being served, all customers with numbers less than j would have entered service before j.
- Also, no customer whose number is higher than j could yet have completed service.
- So queue is formed of customers with numbers j + 1, j + 2, …j + n – 2.

List of variables:

- Time variable: t
- System State (SS) variable: (n, i1, i2)
where n is the number of customers in the system; customer i1 is with server 1 and i2 is with server 2.

SS= {0} when the system is empty. SS = (1, j, 0) or (1, 0, j) when the only customer is j and (s/)he is being served by server 1 or 2 respectively.

- Counter variables:
NA – number of arrivals by time t;

Cj – the number of customers served by server j, j = 1, 2.

- Event list: tA, t1, t2
where tA is the time of next arrival; ti is the service completion time of customer presently being served by server i, (i = 1, 2). If there are no customer presently at server i, then ti = ∞, (i = 1, 2).

The event list always consists of these three variables: tA, t1, t2.

Initialize

- Set t = 0, NA = 0, C1 = 0, C2 = 0.
- Set SS = {0}.
- Generate T0, set tA = T0, t1 = ∞, t2 = ∞.
- As always, we move along the time axis until we reach the time for the next event. Depending on what this next event is, we consider different cases.
- As we did previously, let Yi refer to a random variable having distribution Gi, i = 1, 2, which will be used to calculate t1, t2.

Case I: SS = (n, i1, i2), tA = min{tA, t1, t2}

- Reset t = tA.
- Reset NA = NA + 1.
- Generate Tt, and reset tA = t + Tt.
- Collect and the output data A(NA) = t.
- If SS= {0}, Reset SS = (1, NA, 0), Generate Y1, and reset t1 = t + Y1.
- If SS = (1, j, 0), Reset SS = (2, j, NA), Generate Y2, and reset t2 = t + Y2.
- If SS= (1, 0, j), Reset SS = (2, NA, j), Generate Y1, and reset t1 = t + Y1.

Case II: SS = (n, i1, i2), t1 < tA, t1 <= t2.

- Reset t = t1.
- Reset C1 = C1 + 1.
- Collect the output data D(i1) = t.
- If n = 1: Reset SS= {0}, Reset t1 = ∞.
- If n = 2: Reset SS = (1, 0, i2), Reset t1 = ∞.
- If n > 2: Let m = max{i1, i2} and Reset SS = (n – 1, m + 1, i2), Generate Y1 and reset t1 = t + Y1.

Case III: SS = (n, i1, i2), t2 < tA, t2 <= t1.

- Reset t = t2.
- Reset C2 = C2 + 1.
- Collect the output data D(i2) = t.
- If n = 1: Reset SS= {0}, Reset t2 = ∞.
- If n = 2: Reset SS = (1, i1, 0), Reset t2 = ∞.
- If n > 2: Let m = max{i1, i2} and Reset SS = (n – 1, i1, m + 1), Generate Y2 and reset t2 = t + Y2.

- A retailer has to decide inventory for a specialty product which he sells at a rate of Rs. r per piece.
- Customers for this product come to the retailer at a Poisson rate of λ. And demand from each of these customers is also random with a probability distribution G.
- In order to meet this demand, the retailer needs to have enough inventory. However, just enough!
- Let at any given time, the inventory level be x pieces. Accordingly, the retailer decides whether to place an order to the supplier or not.
- Suppose that the retailer decides to follow a (s, S) inventory policy. What is (s, S) policy?

- Cost of ordering y pieces from supplier costs Rs. c(y); and it takes L time periods for the order to reach the retailer.
- Additionally, the retailer has to pay Rs. h per piece per unit time to the warehouse where this product is stored.
- If a customer orders more than what is there in the inventory, then the amount on hand is sold and rest is lost. As against?
- We want to estimate, using simulation, the retailer’s profit over a finite time horizon of T time units.

List of variables

- Time variable: t
- System State variable: (x, y)
where x is the amount of inventory on hand, and y is the amount on order.

- Counter variables:
C, the total amount of ordering cost by time t;

H, the total amount of inventory holding costs by t;

R, the total amount of revenue earned by time t;

- Event list: Consists of either a customer or order arriving. Let the times for these events be
t0, the arrival time of the next customer;

t1, the time at which the order being filled will be delivered. If there is no outstanding order then we can take the value of t1 to be ∞.

- Updating the system is done by considering the event that takes place earlier. We are presently at time t.

Case I: t0 < t1

- Reset H = H + (t0 – t)xh. (Since between time t and t0 we incur a holding cost.)
- Reset t = t0.
- Generate D, a random variable having distribution G. D is the demand of the customer that arrived at time t0.
- Let w = min{D, x} be the amount of order that can be filled. The inventory after filling the order is x – w.
- Reset R = R + wr.
- Reset x = x – w.

Case I: t0 < t1 – continued.

- If x < s, and y = 0, then reset y = S – x. t1= t + L.
- Generate the next arrival time of the customer. How?

Case II: t1 <= t0.

- Reset H = H + (t1 – t)xh.
- Reset t = t1.
- Reset C = C + c(y).
- Reset x = x + y.
- Reset y = 0; t1 = ∞.

- Suppose that for an insurance company, there are plenty of policyholders. These numerous policyholders, register insurance claim at a Poisson rate of λ, and each claim amount is a random variable with a probability distribution G.
- Suppose that new customers sign-up as policyholders at a Poisson rate ν.
- Additionally, each existing policyholder remains with the company for an exponentially distributed time with rate µ.
- Assume that for each policyholder, the fixed insurance premium is Rs. p per unit time.

- Assume that the insurance company has n0 customers right now and has a capital of c0 > 0.
- We are interested in estimating, using simulation, the probability that the firm doesn’t go bankrupt within a time window of T time units.

List of variables:

- Time variable: t.
- System State variable: (n, c)
where n is the # of customers (policyholders) and c is the firm’s capital at this time.

- Event list: Three types of events –
- A new customer joining as policyholder;
- A policyholder discontinuing with the company;
- A claim filed by a policyholder.

- Notice that all the event times will be exponentially distributed. Why?
- The time for next event, is the minimum amongst these three events is also a exponentially distributed random variable. Why?
- The “minimum” variable has a rate of
- To determine when the next event takes place, we generate a random number X which is exponentially distributed with the above rate. tE = t + X.
- This will tell us when the next event is.
- We also have to know what the next event is.

- The next event would be:
A new policyholder, with probability:

A lost policyholder, with probability: and

A filed claim with a probability:

- Hence we generate a discrete random variable J such that:
- Lastly, we also generate a random variable Y with a probability distribution G for the amount of claim.

- Output variable: I, where:
- Initialize:
t = 0, c = c0, n = n0.

Generate X and initialize tE = X.

- Updating is done by moving along the time axis to the next event and by checking if the elapsed time is past T.

Case I: tE > T.

- Set I = 1 and end the run.

Case II: tE <= T.

- Reset c = c + np(tE – t).
- Reset t = tE.
- Generate J:
- If J = 1, Reset n = n + 1.
- If J = 2, Reset n = n – 1.
- If J = 3, Generate Y. If Y > c, then Reset I = 0 and end the run. Otherwise Reset c = c – Y.
- Generate X: Reset tE = t + X.

- A system needs n working machines to be operational.
- To prevent system breakdown because of machine unavailability, additional machines are kept as spares.
- The system “crashes” when no spares are available for a failed machine.
- Whenever a machine breaks down, it is immediately replaced by a spare and is itself sent to repair facility.
- Repairs are done by a single person who repairs failed machines one at a time.

- Once repairs are completed on a machine, it becomes available as a spare to be used when the next machine fails.
- All repair times are independent random variables having the common distribution function G.
- The time between two failures for a machine is also a random variable with a distribution function F.
- There are n + s machines that are available. Out of these, n are put to use and s are kept as spares.
- We are interested in simulating this system to approximate expected time at which system crashes.

List of variables:

- Time variable: t.
- System State variable: SS = r (the # of machines that are down at time t).
- Event list:
- Machine breaks down;
- Machine repair is completed.
- To know when the next event is going to take place, we need to know when each of the currently functional machines is going to fail.

- We also need to know when the repairs on a machine will be completed, if there is a machine under repair.
- The event of machine failure is, in fact, the event where we encounter the first machine failure.
- So from the list of machine failure times, we need to find the minimum value. And this minimum failure time is the next instance of machine failure event.

- Event list:
where ti’s are the times, in order, at which n machines presently in use will fail. And t* is the time at which the machine currently under repairs will become operational. If there is no machine currently being repaired, t* = ∞.

Initialize

- Set t = 0; r = 0; t* = ∞.
- Generate X1, X2, … Xn, independent random variables each having distribution F. Order these values and let ti be the smallest one, i = 1,…n.
- Set Event list: ti, t*;
Without loss of generality, let ti = t1.

Case I: t1 < t*

- Reset t = t1.
- Reset r = r + 1 (because this event is a failure event).
- If r = s + 1, stop this run and the collect the output data T = t (run has to be stopped because now s + 1 machines are down and no spares are available).
- If r < s + 1, Generate a random variable X with probability distribution F. This represents working time of the spare that will now be put into use. Reorder t1, t2, … tn-1, t + X and let ti be the ith smallest of these.

Case I: t1 < t*– continued

- If r = 1, generate a random variable Y having distribution function G and reset t* = t + Y (Since the machine that just now failed is the only machine under repairs, the repair person can start working on it immediately. Y will be the repair time).

Case II: t* <= t1.

- Reset t = t*.
- Reset r = r – 1.
- If r > 0, Generate a random variable Y having probability distribution G to represent the repair time of the machine that just entered service and; Reset t* = t + Y.
- If r = 0, Reset t*= ∞.

- Let S(t) be the price of a stock at time t, and S(0) be the stock price at time t = 0 (or present time).
- Let the term µ be the drift parameter which represents time-linear growth in the stock returns; and σ be the volatility of the stock.
- Then the stock price model can be developed as an extension of a random walk model (what is this?), where instead of the condition of same distance covered in a small interval, we say that the return on stock investment is same over a small time interval.

- In the standard Ito form, the stock price dynamics is represented as:
- The term dS(t)/S(t) can be thought of as the differential return of the stock.
- z is the standard Weiner process such that:

- Following stochastic calculus, we get the expected value stock price from today’s stock price using the following expression:
which shows that the stock price model is essentially a log-normal process.

- is called as growth rate.

Simulation of stock prices

- A continuous-time price process can be simulated by taking a series of small time periods and then stepping the process forward period by period.
- There are two ways to achieve this.
- First method uses linear version of the stock price model.
- Second method uses the log – (multiplicative) – form of the stock price model.

First method

- We take the basic time period length to be Δt and set S(t0) = S0, a given initial price at time t = t0.
- The corresponding simulation equation is:

First method

- This is a multiplicative model and the random coefficient is normal rather than log-normal.
- So this simulation method does not produce the log-normal price distributions that are characteristics of the underlying Ito process.

Second method

- We use the log – form. In discrete time the model is:
- This is also a multiplicative model, but now the random coefficient is log-normal.
- The two methods are different; but it can be shown that their differences tend to cancel over a long run. Hence in practice, either method is about as good as the other.

- So if we know today’s price of the stock, we can estimate, using simulation, the stock price N days later by: