Queue objects updated

dream/simulation/ExitJobShop.py

@@ -34,6 +34,15 @@ from Exit import Exit
 # the ExitJobShop object
 # ===========================================================================
 class ExitJobShop(Exit):
+    # =======================================================================
+    # parses inputs if they are given in a dictionary
+    # =======================================================================       
+    def parseInputs(self, inputsDict):
+        Exit.parseInputs(self, inputsDict)
+        from Globals import G
+        G.ExitJobShopList.append(self)
+    
+    
     # =======================================================================
     # set all the objects in previous
     # =======================================================================

dream/simulation/LineGenerationJSON.py

@@ -292,77 +292,12 @@ def createObjects():
             G.ObjList.append(S)
             
         elif objClass in ['Dream.Machine', 'Dream.BatchScrapMachine', 'Dream.M3', 'Dream.MachineJobShop',
-                          'Dream.MachineManagedJob', 'Dream.MouldAssembly']:
+                          'Dream.MachineManagedJob', 'Dream.MouldAssembly', 'Dream.Exit', 'Dream.ExitJobShop', 
+                          'Dream.Queue', 'Dream.RoutingQueue', 'Dream.QueueJobShop', 'Dream.QueueManagedJob']:
             objectType=Globals.getClassFromName(objClass)
             coreObject=objectType(inputsDict=element)
             coreObject.nextIds=getSuccessorList(element['id'])           # update the nextIDs list of the machine
-                                   
-        elif objClass=='Dream.Exit':
-            id=element.get('id', 'not found')
-            name=element.get('name', 'not found')
-            E=Exit(id, name)
-            G.ExitList.append(E)
-            G.ObjList.append(E)
-            
-        elif objClass=='Dream.ExitJobShop':
-            id=element.get('id', 'not found')
-            name=element.get('name', 'not found')
-            E=ExitJobShop(id, name)
-            G.ExitJobShopList.append(E)
-            G.ExitList.append(E)
-            G.ObjList.append(E)
-            
-        elif objClass=='Dream.Queue':
-            id=element.get('id', 'not found')
-            name=element.get('name', 'not found')
-            capacity=int(element.get('capacity') or 1)
-            isDummy=bool(int(element.get('isDummy') or 0))
-            schedulingRule=element.get('schedulingRule', 'FIFO')
-            gatherWipStat=bool(int(element.get('gatherWipStat', 0)))
-            Q=Queue(id, name, capacity, isDummy, schedulingRule=schedulingRule, gatherWipStat=gatherWipStat)
-            Q.nextIds=getSuccessorList(id)
-            G.QueueList.append(Q)
-            G.ObjList.append(Q)
-        
-        elif objClass=='Dream.RoutingQueue':
-            id=element.get('id', 'not found')
-            name=element.get('name', 'not found')
-            capacity=int(element.get('capacity') or 1)
-            isDummy=bool(int(element.get('isDummy') or 0))
-            schedulingRule=element.get('schedulingRule', 'FIFO')
-            gatherWipStat=bool(int(element.get('gatherWipStat', 0)))
-            level=int(element.get('level') or 1)
-            Q=RoutingQueue(id, name, capacity, isDummy, schedulingRule=schedulingRule, gatherWipStat=gatherWipStat, level=level)
-            Q.nextIds=getSuccessorList(id)
-            G.QueueList.append(Q)
-            G.RoutingQueueList.append(Q)
-            G.ObjList.append(Q)
-            
-        elif objClass=='Dream.QueueJobShop':
-            id=element.get('id', 'not found')
-            name=element.get('name', 'not found')
-            capacity=int(element.get('capacity') or 1)
-            isDummy=bool(int(element.get('isDummy') or 0))
-            schedulingRule=element.get('schedulingRule', 'FIFO')
-            Q=QueueJobShop(id, name, capacity, isDummy, schedulingRule=schedulingRule)
-            Q.nextIds=getSuccessorList(id)
-            G.QueueList.append(Q)
-            G.QueueJobShopList.append(Q)
-            G.ObjList.append(Q)
-            
-        elif objClass=='Dream.QueueManagedJob':
-            id=element.get('id', 'not found')
-            name=element.get('name', 'not found')
-            capacity=int(element.get('capacity') or 1)
-            isDummy=bool(int(element.get('isDummy') or 0))
-            schedulingRule=element.get('schedulingRule', 'FIFO')
-            Q=QueueManagedJob(id, name, capacity, isDummy, schedulingRule=schedulingRule)
-            Q.nextIds=getSuccessorList(id)
-            G.QueueList.append(Q)
-            G.QueueManagedJobList.append(Q)
-            G.QueueJobShopList.append(Q)
-            G.ObjList.append(Q)
-                       
+                                                                                                    
         elif objClass=='Dream.QueueLIFO':
             id=element.get('id', 'not found')
             name=element.get('name', 'not found')

dream/simulation/Queue.py

@@ -37,27 +37,63 @@ class Queue(CoreObject):
     #===========================================================================
     # the __init__ method of the Queue
     #===========================================================================
-    def __init__(self, id, name, capacity=1, isDummy=False, schedulingRule="FIFO", level=None, gatherWipStat=False):
-        CoreObject.__init__(self, id, name)
-#         Process.__init__(self)
-        # used for the routing of the entities
-        self.predecessorIndex=0     # holds the index of the predecessor from which the Queue will take an entity next
-        self.successorIndex=0       # holds the index of the successor where the Queue will dispose an entity next
+    def __init__(self, id='', name='', capacity=1, isDummy=False, schedulingRule="FIFO", level=None, gatherWipStat=False, inputsDict={}):
         self.type="Queue"           # String that shows the type of object
-        #     holds the capacity of the Queue
+        if inputsDict:
+            CoreObject.__init__(self,inputsDict=inputsDict)
+        else:
+            CoreObject.__init__(self, id, name)
+            # used for the routing of the entities
+            #     holds the capacity of the Queue
+            if capacity>0:
+                self.capacity=capacity
+            else:
+                self.capacity=float("inf")
+    
+            #     No failures are considered for the Queue        
+    
+            self.isDummy=isDummy                    #Boolean that shows if it is the dummy first Queue
+            self.schedulingRule=schedulingRule      #the scheduling rule that the Queue follows
+            self.multipleCriterionList=[]           #list with the criteria used to sort the Entities in the Queue
+            SRlist = [schedulingRule]
+            if schedulingRule.startswith("MC"):     # if the first criterion is MC aka multiple criteria
+                SRlist = schedulingRule.split("-")  # split the string of the criteria (delimiter -)
+                self.schedulingRule=SRlist.pop(0)   # take the first criterion of the list
+                self.multipleCriterionList=SRlist   # hold the criteria list in the property multipleCriterionList
+     
+            for scheduling_rule in SRlist:
+              if scheduling_rule not in self.getSupportedSchedulingRules():
+                raise ValueError("Unknown scheduling rule %s for %s" %
+                  (scheduling_rule, id))
+    
+            self.gatherWipStat=gatherWipStat
+            # Will be populated by an event generator
+            self.wip_stat_list = []
+            # trigger level for the reallocation of operators
+            if level:
+                assert level<=self.capacity, "the level cannot be bigger than the capacity of the queue"
+            self.level=level
+            
+    # =======================================================================
+    # parses inputs if they are given in a dictionary
+    # =======================================================================       
+    def parseInputs(self, inputsDict):
+        CoreObject.parseInputs(self, inputsDict)
+        from Globals import G
+        G.QueueList.append(self)
+        # holds the capacity of the Queue
+        capacity=int(inputsDict.get('capacity') or 1)
         if capacity>0:
             self.capacity=capacity
         else:
             self.capacity=float("inf")
 
-        #     No failures are considered for the Queue        
-
-        self.isDummy=isDummy                    #Boolean that shows if it is the dummy first Queue
-        self.schedulingRule=schedulingRule      #the scheduling rule that the Queue follows
+        self.isDummy=bool(int(inputsDict.get('isDummy') or 0))                    #Boolean that shows if it is the dummy first Queue
+        self.schedulingRule=inputsDict.get('schedulingRule', 'FIFO')                                        #the scheduling rule that the Queue follows
         self.multipleCriterionList=[]           #list with the criteria used to sort the Entities in the Queue
-        SRlist = [schedulingRule]
-        if schedulingRule.startswith("MC"):     # if the first criterion is MC aka multiple criteria
-            SRlist = schedulingRule.split("-")  # split the string of the criteria (delimiter -)
+        SRlist = [self.schedulingRule]
+        if self.schedulingRule.startswith("MC"):     # if the first criterion is MC aka multiple criteria
+            SRlist = self.schedulingRule.split("-")  # split the string of the criteria (delimiter -)
             self.schedulingRule=SRlist.pop(0)   # take the first criterion of the list
             self.multipleCriterionList=SRlist   # hold the criteria list in the property multipleCriterionList
  
@@ -66,9 +102,10 @@ class Queue(CoreObject):
             raise ValueError("Unknown scheduling rule %s for %s" %
               (scheduling_rule, id))
 
-        self.gatherWipStat=gatherWipStat
+        self.gatherWipStat=bool(int(inputsDict.get('gatherWipStat', 0)))
         # Will be populated by an event generator
         self.wip_stat_list = []
+        level=int(inputsDict.get('level') or 1)
         # trigger level for the reallocation of operators
         if level:
             assert level<=self.capacity, "the level cannot be bigger than the capacity of the queue"

dream/simulation/QueueJobShop.py

@@ -32,6 +32,15 @@ from Queue import Queue
 # the QueueJobShop object
 # ===========================================================================
 class QueueJobShop(Queue):
+    
+    # =======================================================================
+    # parses inputs if they are given in a dictionary
+    # =======================================================================       
+    def parseInputs(self, inputsDict):
+        Queue.parseInputs(self, inputsDict)
+        from Globals import G
+        G.QueueJobShopList.append(self)
+    
     # =======================================================================
     # set all the objects in previous and next
     # =======================================================================

dream/simulation/QueueManagedJob.py

@@ -41,12 +41,23 @@ class NoCallerError(Exception):
 # ===========================================================================
 class QueueManagedJob(QueueJobShop):
     
-    def __init__(self, id, name, capacity=1, isDummy=False, schedulingRule="FIFO"):
-        QueueJobShop.__init__(self, id=id, name=name,capacity=capacity, isDummy=isDummy, schedulingRule=schedulingRule)
+    def __init__(self, id='', name='', capacity=1, isDummy=False, schedulingRule="FIFO", inputsDict={}):
+        if inputsDict:
+            QueueJobShop.__init__(self,inputsDict=inputsDict)
+        else:       
+            QueueJobShop.__init__(self, id=id, name=name,capacity=capacity, isDummy=isDummy, schedulingRule=schedulingRule)
         # variable used by the sortEntities method 
-        #     to identify the object it will be sorting for (manager.checkIfResourceIsAvailable(self.objectSortingFor))
+        # to identify the object it will be sorting for (manager.checkIfResourceIsAvailable(self.objectSortingFor))
         self.objectSortingFor=None
         
+    # =======================================================================
+    # parses inputs if they are given in a dictionary
+    # =======================================================================       
+    def parseInputs(self, inputsDict):
+        QueueJobShop.parseInputs(self, inputsDict)
+        from Globals import G
+        G.QueueManagedJobList.append(self)
+        
     # =======================================================================
     # set all the objects in previous and next
     # =======================================================================

dream/simulation/RoutingQueue.py

@@ -33,6 +33,15 @@ from Queue import Queue
 #                            the Queue object
 # ===========================================================================
 class RoutingQueue(Queue):
+    
+    # =======================================================================
+    # parses inputs if they are given in a dictionary
+    # =======================================================================       
+    def parseInputs(self, inputsDict):
+        Queue.parseInputs(self, inputsDict)
+        from Globals import G
+        G.RoutingQueueList.append(self)
+
     # =======================================================================
     # checks if the Queue can dispose an entity to the following object
     # it checks also who called it and returns TRUE