Commit HW 1 Sloan

MV3302ClassCode/src/mv3302/Customer.java

@@ -18,6 +18,8 @@ public class Customer extends Entity {
     
     /**
      * constructor method that assigns values of serviceTime and renegeTime to each customer
+     * @param serviceTime
+     * @param renegeTime
      */
     public Customer(double serviceTime, double renegeTime) {
         super("Customer");

MV3302ClassCode/src/mv3302/CustomerArrivalProcess.java

@@ -4,6 +4,7 @@
  */
 package mv3302;
 
+import simkit.Entity;
 import simkit.random.RandomVariate;
 
 /**
@@ -21,6 +22,13 @@ public final class CustomerArrivalProcess extends ArrivalProcess {
 
     private int numberofArrivals;
 
+    /**
+     * Zero-argument constructor
+     */
+    public CustomerArrivalProcess() {
+        super();
+    }
+    
     /**
      * Constructor method that instantiates renege times and service times for
      * each customer arrival
@@ -47,7 +55,13 @@ public final class CustomerArrivalProcess extends ArrivalProcess {
         waitDelay("Arrival", 0.0, customer);
         numberofArrivals += 1;
     }
+/**
+     * Does nothing, since this is only to be "heard"
+     * @param customer
 
+     */
+    public void doArrival(Customer customer) {
+    }
     /**
      * @return the serviceTimeGenerator
      */

MV3302ClassCode/src/mv3302/Part.java

+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package mv3302;
+
+import simkit.Entity;
+
+/**
+ *
+ * @author dansl
+ */
+public class Part extends Entity{
+    private double totalDelayInQueue; 
+    private int next;
+    
+    public Part(){
+        super();
+    }
+    
+    public Part(int next){
+        super();
+        this.next = next;
+        this.totalDelayInQueue = 0.0;
+    }
+    
+    public double getTotalDelayInQueue() {
+        return this.totalDelayInQueue;
+    }
+    
+    public void advance() {
+        this.next += 1;
+    }
+
+    public void incrementDelayInQueue(double incrementDelay) {
+        this.totalDelayInQueue += incrementDelay;
+    }
+}
+

MV3302ClassCode/src/mv3302/PartArrivalProcess.java

+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package mv3302;
+
+import simkit.random.RandomVariate;
+
+/**
+ *
+ * @author dansl
+ */
+public class PartArrivalProcess extends ArrivalProcess{
+
+    /**
+     * Zero-argument constructor
+     */
+    public PartArrivalProcess() {
+        super();
+    }
+
+    /**
+     * Instantiate with the given parameters
+     *
+     * @param interarrivalTimes Given inter arrival times
+     */
+    public PartArrivalProcess(RandomVariate interarrivalTimes) {
+        super(interarrivalTimes);
+    }
+
+    /**
+     * Schedule next Arrival<br>
+     * Schedule Arrival(index)
+     */
+    @Override
+    public void doArrival() {
+        super.doArrival();
+        Part part = new Part();
+        waitDelay("Arrival", 0.0, part, 0);
+    }
+
+}

MV3302ClassCode/src/mv3302/ServerWithReneges.java

@@ -133,13 +133,14 @@ public final class ServerWithReneges extends SimEntityBase {
     public void doStartService() {
         Customer customer = queue.first();
         SortedSet<Customer> oldQueue = getQueue();
+        queue.remove(customer);
         firePropertyChange("queue", oldQueue, getQueue());
         int oldNumberAvailableServers = getNumberAvailableServers();
         numberAvailableServers -= 1;
         firePropertyChange("numberAvailableServers", oldNumberAvailableServers, getNumberAvailableServers());
-        interrupt("renege", customer);
         delayInQueueServed = customer.getElapsedTime();
         firePropertyChange("delayInQueueServed", getDelayInQueueServed());
+        interrupt("Renege", customer);
         waitDelay("EndService", serviceTimeGenerator, customer);
     }
 
@@ -149,12 +150,15 @@ public final class ServerWithReneges extends SimEntityBase {
      * delayInQueueReneged values as elapsedTime
      */
     public void doRenege(Customer customer) {
+        delayInQueueReneged = customer.getElapsedTime();
+        firePropertyChange("delayInQueueReneged", getDelayInQueueReneged());
+        SortedSet<Customer> oldQueue = getQueue();
         queue.remove(customer);
+        firePropertyChange("queue", oldQueue, getQueue());
         double oldNumberReneges = getNumberReneges();
         numberReneges += 1;
         firePropertyChange("numberReneges", oldNumberReneges, getNumberReneges());
-        delayInQueueReneged = customer.getElapsedTime();
-        firePropertyChange("delayInQueueReneged", getDelayInQueueReneged());
+
     }
 
     /**

MV3302ClassCode/src/mv3302/TransferLineComponent.java

+package mv3302;
+
+import simkit.*;
+import java.util.*;
+import static simkit.Priority.HIGHER;
+import simkit.random.RandomVariate;
+
+public class TransferLineComponent extends SimEntityBase {
+
+    private int[] totalNumberMachines;
+    private RandomVariate[] processingTimeGenerator;
+    protected int[] numberAvailableMachines;
+    protected List<SortedSet<Part>> queue;
+    protected double[] delayInQueue;
+    protected double[] timeAtStation;
+    protected double totalDelayInQueue;
+    protected double totalTimeInSystem;
+
+    /**
+     * Instantiate an EntityServer with the given titalNumberServers and
+     * serviceTimeGenerator. Note: should call <code>this()</code> to ensure
+     * that <code>queue</code> is instantiated
+     *
+     * @param processingTimeGenerator
+     * @param totalNumberMachines
+     */
+    public TransferLineComponent(RandomVariate[] processingTimeGenerator, int[] totalNumberMachines) {
+        
+        this();
+        this.setProcessingTimeGenerator(processingTimeGenerator);
+        this.setTotalNumberMachines(totalNumberMachines);
+        numberAvailableMachines = totalNumberMachines.clone();
+        delayInQueue = new double[totalNumberMachines.length];
+        timeAtStation = new double[totalNumberMachines.length];
+        queue = new ArrayList<SortedSet<Part>>();
+        for (int station = 0; station < totalNumberMachines.length; ++station) {
+            queue.add(new TreeSet<>());
+        }
+    }
+
+    public TransferLineComponent() {
+        super();
+
+    }
+
+    @Override
+    public void reset() {
+        super.reset();
+        numberAvailableMachines = getTotalNumberMachines().clone();
+        Arrays.fill(delayInQueue, Double.NaN);
+        Arrays.fill(timeAtStation, Double.NaN);
+        //queue.clear();
+    }
+
+    public void doRun() {
+        totalDelayInQueue = Double.NaN;
+        totalTimeInSystem = Double.NaN;
+        firePropertyChange("totalDelayInQueue", getTotalDelayInQueue());
+        firePropertyChange("totalDelayInSystem", getTotalTimeInSystem());
+        firePropertyChange("numberAvailableMachines", getNumberAvailableMachines());
+        waitDelay("Init", 0.0, HIGHER, 0);
+    }
+
+    public void doInit(int i) {
+        this.numberAvailableMachines[i] = totalNumberMachines[i];
+        fireIndexedPropertyChange(i, "numberAvailableMachines", getNumberAvailableMachines(i));
+        queue.get(i).clear();
+        fireIndexedPropertyChange(i, "queue", getQueue(i));
+        double[] oldDelayInQueue = getDelayInQueue().clone();
+        delayInQueue[i] = Double.NaN;
+        firePropertyChange("delayInQueue", oldDelayInQueue, getDelayInQueue());
+        double[] oldTimeAtStation = getTimeAtStation().clone();
+        timeAtStation[i] = Double.NaN;
+        firePropertyChange("timeAtStation", oldTimeAtStation, getTimeAtStation());
+        if (i < totalNumberMachines.length - 1) {
+            waitDelay("Init", 0.0, HIGHER, i + 1);
+        }
+    }
+
+    public void doArrival(Part part, int station) {
+        part.stampTime();
+        SortedSet<Part> oldQueue = getQueue(station);
+        queue.get(station).add(part);
+        fireIndexedPropertyChange(station, "queue", oldQueue, getQueue(station));
+        if (numberAvailableMachines[station] > 0) {
+            waitDelay("StartService", 0.0, Priority.HIGH, station);
+        }
+    }
+
+    public void doStartProcessing(int station) {
+        SortedSet<Part> oldQueue = queue.get(station);
+        Part part = oldQueue.first();
+        //fireIndexedPropertyChange(station, "queue", oldQueue, getQueue(station));
+        int[] oldNumberAvailableMachines = getNumberAvailableMachines().clone();
+        oldNumberAvailableMachines[station]--;
+        fireIndexedPropertyChange(station, "numberAvailableMachines", oldNumberAvailableMachines[station], getNumberAvailableMachines()[station]);
+        double[] oldDelayInQueue = getDelayInQueue().clone();
+        delayInQueue[station] = part.getElapsedTime();
+        firePropertyChange("delayInQueue", oldDelayInQueue, getDelayInQueue());
+        part.incrementDelayInQueue(oldDelayInQueue[station]);
+        waitDelay("EndProcessing", getProcessingTimeGenerator()[station].generate(), Priority.HIGH, part, station);
+        //add state condition changes
+    }
+
+    public void doEndProcessing(Part part, int station) {
+        int[] oldNumberAvailableMachines = getNumberAvailableMachines().clone();
+        getNumberAvailableMachines()[station]++;
+        fireIndexedPropertyChange(station, "numberAvailableMachines", oldNumberAvailableMachines[station], getNumberAvailableMachines()[station]);
+        double[] oldTimeAtStation = getTimeAtStation().clone();
+        timeAtStation[station] = part.getElapsedTime();
+        firePropertyChange("timeAtStation", oldTimeAtStation, getTimeAtStation());
+        if (station < totalNumberMachines.length) {
+            waitDelay("Arrival", 0.0, part, station + 1);
+        }
+        if (station == totalNumberMachines.length - 1) {
+            waitDelay("PartComplete", 0.0, part);
+        }
+        if (!queue.get(station).isEmpty()) {
+            waitDelay("StartProcessing", 0.0, station);
+        }
+        //add property changes portions
+    }
+
+    public void doPartComplete(Part part) {
+        totalTimeInSystem = part.getAge();
+        totalDelayInQueue = part.getTotalDelayInQueue();
+    }
+
+    /**
+     * @return the totalNumberMachines
+     */
+    public int[] getTotalNumberMachines() {
+        return totalNumberMachines.clone();
+    }
+    
+    public int getTotalNumberMachines(int station){
+        return totalNumberMachines[station];
+    }
+
+    /**
+     * @return the processingTimeGenerator
+     */
+    public RandomVariate[] getProcessingTimeGenerator() {
+        return processingTimeGenerator.clone();
+    }
+    
+    public RandomVariate getProcessingTimeGenerator(int station){
+        return processingTimeGenerator[station];
+    }
+
+    /**
+     * @return the numberAvailableMachines
+     */
+    public int[] getNumberAvailableMachines() {
+        return numberAvailableMachines.clone();
+    }
+
+    public int getNumberAvailableMachines(int station) {
+        return numberAvailableMachines[station];
+    }
+
+    public SortedSet<Part> getQueue(int station) {
+        return new TreeSet<>(queue.get(station));
+    }
+
+    public List<SortedSet<Part>> getQueue() {
+        List<SortedSet<Part>> queueListCopy = new ArrayList<>();
+        for (int station = 0; station < queue.size(); ++station) {
+            queueListCopy.add(getQueue(station));
+        }
+        return queueListCopy;
+    }
+
+    public double[] getDelayInQueue() {
+        return delayInQueue.clone();
+    }
+    
+    public double getDelayInQueue(int station) {
+        return delayInQueue[station];
+    }
+
+    /**
+     * @return the timeAtStation
+     */
+    public double[] getTimeAtStation() {
+        return timeAtStation.clone();
+    }
+    
+    public double getTimeAtStation(int station) {
+        return timeAtStation[station];
+    }
+
+    /**
+     * @return the totalDelayInQueue
+     */
+    public double getTotalDelayInQueue() {
+        return totalDelayInQueue;
+    }
+
+    /**
+     * @return the totalTimeInSystem
+     */
+    public double getTotalTimeInSystem() {
+        return totalTimeInSystem;
+    }
+
+    private void setTotalNumberMachines(int[] totalNumberMachines) {
+        this.totalNumberMachines = totalNumberMachines;
+    }
+
+    private void setProcessingTimeGenerator(RandomVariate[] processingTimeGenerator) {
+        this.processingTimeGenerator = processingTimeGenerator;
+    }
+
+}

MV3302ClassCode/src/mv3302/run/RunTransferLineComponent.java

+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Main.java to edit this template
+ */
+package mv3302.run;
+
+import mv3302.PartArrivalProcess;
+import mv3302.TransferLineComponent;
+import simkit.Schedule;
+import simkit.random.RandomVariate;
+import simkit.random.RandomVariateFactory;
+import simkit.stat.MultipleSimpleStatsTimeVarying;
+import simkit.stat.SimpleStatsTimeVarying;
+import simkit.util.SimplePropertyDumper;
+
+/**
+ *
+ * @author dansl
+ */
+public class RunTransferLineComponent {
+
+    /**
+     * @param args the command line arguments
+     */
+    public static void main(String[] args) {
+        int[] totalNumberMachines = {5, 4, 2};
+        RandomVariate[] processingTimeGenerator = {RandomVariateFactory.getInstance("Gamma", 3.2, 2.3),
+            RandomVariateFactory.getInstance("Uniform", 4.5, 6.7),
+            RandomVariateFactory.getInstance("Exponential", 3.0)};
+        RandomVariate interarrivalTimeGenerator = RandomVariateFactory.getInstance("Exponential", 1.7);
+        TransferLineComponent transferLineComponent = new TransferLineComponent(processingTimeGenerator, totalNumberMachines);
+        PartArrivalProcess arrivalProcess = new PartArrivalProcess(interarrivalTimeGenerator);
+
+//        Part part = new Part();
+//        System.out.println(part);
+//        part.incrementDelayInQueue(10);
+//        System.out.println(part.getTotalDelayInQueue());
+
+        System.out.println(arrivalProcess);
+  
+        System.out.println(transferLineComponent.getQueue().size());
+        System.out.println(transferLineComponent);
+
+//        for (IntArrivalProcess intArrivalProcess : arrivalProcess) {
+//            intArrivalProcess.addSimEventListener(twoCustomerTypes);
+//        }
+
+//        SimplePropertyDumper simplePropertyDumper = new SimplePropertyDumper();
+////        twoCustomerTypes.addPropertyChangeListener(simplePropertyDumper);
+//
+//        MultipleSimpleStatsTimeVarying delayInQueueStat = new MultipleSimpleStatsTimeVarying("delayInQueue");
+//        SimpleStatsTimeVarying numberAvailableMachinesStat = new SimpleStatsTimeVarying("numberAvailableMachines");
+//
+////        transferLineComponent.addPropertyChangeListener(numberInQueueStat);
+//        transferLineComponent.addPropertyChangeListener(numberAvailableMachinesStat);
+//
+//        Schedule.setVerbose(false);
+//
+//        Schedule.stopOnEvent(10000, "EndProcessing");
+//
+//        Schedule.reset();
+////        twoCustomerTypes.waitDelay("Arrival", 1.2, LOW,  0);
+////        twoCustomerTypes.waitDelay("Arrival", 1.2, 1);
+//        Schedule.startSimulation();
+//
+//        System.out.printf("%nSimulation ended at time %,.2f%n%n", Schedule.getSimTime());
+//
+//        for (int i = 0; i < 2; ++i) {
+//            System.out.printf("Avg # in queue type %d: %,.4f%n", i,
+//                    delayInQueueStat.getMean(i));
+//        }
+//        double utilization = 1.0 - numberAvailableMachinesStat.getMean();// / transferLineComponent.getTotalNumberServers();
+//        System.out.printf("Avg utilization: %,.4f%n", utilization);
+    }
+    }
+