Queuing System Simulation Solution | Time Oriented System Simulation Tutorial Solution

In a manufacturing system, parts are being made at a rate of one every 6 minutes. They are two types A and B and are mixed randomly with about 10 percent of type B. A separate inspector is assigned to examine each type of parts. The inspection of a part takes a mean time of 4 minutes with a standard deviation of 2 minutes, but part B takes a mean time 20 minutes and a standard deviation of 10 minutes. Both inspectors reject about 10% of the parts they inspect. Simulate the system for total of 50 type A parts accepted and determine, idle time of inspectors and average time a part spends in system.

The program to simulate such a system in Java is given below:

//Simulated time oriented system, @author: Jivan Nepali, Kathmandu  
import java.io.DataOutputStream;  
 import java.io.FileNotFoundException;  
 import java.io.FileOutputStream;  
 import java.io.IOException;  
 import java.util.Random;  
 public class QueuingSystem {  
      public static double minSrvA = 3.44562824;  
   public static double minSrvB = 17.22814142;  
   public static double maxSrvA = 4.55371716;  
   public static double maxSrvB = 22.77185858;  
   public static double diffSrvA = 1.108743433;  
   public static double diffSrvB = 5.543717165;  
   public static int qA = 0, qB = 0;  
   public static String arrival;  
   public static double idleA = 0, idleB = 0, waitA = 0, waitB = 0;  
   public static double srvTimeA = 0, srvTimeB = 0, sTA = 0, sTB = 0;  
   public static boolean busyA = false;  
   public static boolean busyB = false;  
   public static int acceptedA = 0;  
   public static int acceptedB = 0;  
   public static int completedA = 0;  
   public static int completedB = 0;  
   public static double tAvailA = 0, tAvailB = 0;  
   public static Random random = new Random();  
   public static int time = 6;  
   public static double rSA = 0, rSB = 0;  
   public static double rSA_prev = 0, rSB_prev = 0;  
   public static double acceptA = 0;  
   public static double acceptB = 0;  
   /**  
    * @param args the command line arguments : none  
    */  
   public static void main(String[] args) throws FileNotFoundException, IOException {  
     FileOutputStream fos = new FileOutputStream("SimulatedOutput1.csv");  
     DataOutputStream dos = new DataOutputStream(fos);  
     dos.write(("Timer" + "," + "Rand_Num(Arrival)" + "," + "Arrival" + "," + "Queue A" + "," + "Queue B" + "," + "Rand_Num(A)" + "," + "Rand_Num(B)" + ","+ "Service_time(A)" + "," + "Service_time(B)" + "," + "Idle Time(A)" + "," + "Idle Time(B)" + "," + "Waiting_time(A)" + "," + "Waiting_time(B)" + "," + "Rand_Num(Acccepted_A)" + "," + "Rand_Num(Accepted_B)" + "," + "Accepted_Num(A)"+ "," +"Accepted_Num(B)" + "\n").getBytes());  
     dos.write((0 + "," + " " + "," + "" + "," + 0 + "," + 0 + "," + "" + "," + "" + ","+ 0 + "," + 0 + "," + 0 + "," + 0 + "," + 0 + "," + 0 + "," + ""+ "," + "" + "," + 0 + "," + 0 + "\n").getBytes());  
     while(acceptedA < 51){  
       double r = random.nextDouble();  
       tAvailA = tAvailB = 6;  
       if (r < 0.9) {  
         arrival = "A";  
         if (busyA) {   
              qA++;  
           processA();  
         } else {  
           rSA_prev = rSA;  
           rSA = random.nextDouble();  
           srvTimeA = minSrvA + diffSrvA * rSA;  
           sTA = srvTimeA;  
           processA();  
         }  
         processB();  
       } else {  
         arrival = "B";  
         if (busyB) { qB++; processB();  
         } else {  
           rSB_prev = rSB;  
           rSB = random.nextDouble();  
           srvTimeB = minSrvB + diffSrvB * rSB;  
           sTB = srvTimeB;  
           processB();  
         }  
         processA();  
       }  
       double rnA = 0;  
       if (rSA == rSA_prev) { rnA = 0;  
       } else { rnA = rSA;  
       }  
       double rnB = 0;  
       if (rSB == rSB_prev) { rnB = 0;  
       } else { rnB = rSB;  
       }  
       if(arrival == "A")  
            dos.write((time + "," + r + "," + arrival + "," + qA + "," + qB + "," + rnA + "," + "" + ","      + sTA + "," + srvTimeB + "," + idleA + "," + idleB + "," + waitA + "," + waitB + "," + acceptA + "," + "" + "," + acceptedA + "," + acceptedB + "\n").getBytes());  
       else  
            dos.write((time + "," + r + "," + arrival + "," + qA + "," + qB + "," + "" + "," + rnB + ","      + sTA + "," + srvTimeB + "," + idleA + "," + idleB + "," + waitA + "," + waitB + "," + "" + "," + acceptB + "," + acceptedA + "," + acceptedB + "\n").getBytes());  
       time += 6;  
       rSA_prev = rSA;  
       rSB_prev = rSB;  
     }  
     dos.flush();  
     dos.close();  
     fos.close();  
   }  
 /**  
  * This function handles part A  
  */  
   public static void processA() {  
     if (srvTimeA > tAvailA) {  
       srvTimeA -= tAvailA;  
       busyA = true;  
       tAvailA = 0;  
     } else {  
       if (srvTimeA > 0) {  
         completedA++;  
         acceptA = random.nextDouble();  
         if (acceptA < 0.9) {  
           acceptedA++;  
         }  
       }  
       tAvailA -= srvTimeA;  
       busyA = false;  
       srvTimeA = 0;  
       while (tAvailA > 0) {  
         processQueueA();  
       }  
       waitA += qA * 6;  
     }  
   }  
 /**  
  * This function handles part B  
  */  
   public static void processB() {  
     if (srvTimeB > tAvailB) {  
       srvTimeB -= tAvailB;  
       busyB = true;  
       tAvailB = 0;  
     } else {  
       if (srvTimeB > 0) {  
         completedB++;  
         acceptB = random.nextDouble();  
         if (acceptB < 0.9) {  
           acceptedB++;  
         }  
       }  
       tAvailB -= srvTimeB;  
       busyB = false;  
       srvTimeB = 0;  
       while (tAvailB > 0) {  
         processQueueB();  
       }  
       waitB += qB * 6;  
     }  
   }  
   /**  
    * This function process the queue for part B  
    */  
   public static void processQueueA() {  
     if (qA == 0) {  
       idleA += tAvailA;  
       tAvailA = 0;  
       busyA = false;  
     } else {  
       qA--;  
       rSA_prev = rSA;  
       rSA = random.nextDouble();  
       srvTimeA = minSrvA + diffSrvA * rSA;  
       if (srvTimeA > tAvailA) {  
         srvTimeA -= tAvailA;  
         tAvailA = 0;  
         busyA = true;  
       } else {  
         if (srvTimeA > 0) {  
           completedA++;  
           acceptA = random.nextDouble();  
           if (acceptA < 0.9) {  
             acceptedA++;  
           }  
           tAvailA -= srvTimeA;  
           srvTimeA = 0;  
           busyA = false;  
         }  
       }  
     }  
   }  
   /**  
    * This function process the queue for part B  
    */  
   public static void processQueueB() {  
     if (qB == 0) {  
       idleB += tAvailB;  
       tAvailB = 0;  
       busyB = false;  
     } else {  
       qB--;  
       rSB_prev = rSB;  
       rSB = random.nextDouble();  
       srvTimeB = minSrvB + diffSrvB * rSB;  
       if (srvTimeB > tAvailB) {  
         srvTimeB -= tAvailB;  
         tAvailB = 0;  
         busyB = true;  
       } else {  
         if (srvTimeB > 0) {  
           completedB++;  
           acceptB = random.nextDouble();  
           if (acceptB < 0.9) {  
             acceptedB++;  
           }  
           tAvailB -= srvTimeB;  
           srvTimeB = 0;  
           busyB = false;  
         }  
       }  
     }  
   }  
 }  

Download the Solution

Enjoy Simulating !!!!


No comments :

Post a Comment