cherry-pick from readWIPseperatelly. new method outputRoute that prints the...

cherry-pick from readWIPseperatelly. new method outputRoute that prints the route of each job on the same excell file as the outputTrace method does.

dream/simulation/LineGenerationJSON.py

@@ -87,6 +87,7 @@ from MachineManagedJob import MachineManagedJob
 from QueueManagedJob import QueueManagedJob
 from ShiftScheduler import ShiftScheduler
 
+import PrintRoute
 from CapacityStation import CapacityStation
 from CapacityStationExit import CapacityStationExit
 from CapacityStationBuffer import CapacityStationBuffer
@@ -128,11 +129,11 @@ def createObjects():
     edges = json_data['edges']                      # read from the dictionary the dicts with key 'edges'
 
 
-    # -----------------------------------------------------------------------
-    #                getSuccesorList method to get the successor 
-    #                       list of object with ID = id
-    #                         XXX slow implementation
-    # -----------------------------------------------------------------------
+    '''
+    getSuccesorList method to get the successor 
+    list of object with ID = id
+    XXX slow implementation
+    '''
     def getSuccessorList(node_id, predicate=lambda source, destination, edge_data: True):
       successor_list = []                           # dummy variable that holds the list to be returned
       for source, destination, edge_data in edges.values(): # for all the values in the dictionary edges
@@ -143,9 +144,9 @@ def createObjects():
       # prevents Topology10 to work if this sort is not used.
       successor_list.sort()
       return successor_list
-    # -----------------------------------------------------------------------
-    #                define the lists of each object type
-    # -----------------------------------------------------------------------
+    '''
+    define the lists of each object type
+    '''
     G.SourceList=[]
     G.MachineList=[]
     G.ExitList=[]
@@ -182,11 +183,11 @@ def createObjects():
     G.CapacityStationExitList=[]
     G.CapacityStationControllerList=[]
 
-    # -----------------------------------------------------------------------
-    #                loop through all the model resources 
-    #      search for repairmen and operators in order to create them
-    #                   read the data and create them
-    # -----------------------------------------------------------------------
+    '''
+    loop through all the model resources 
+    search for repairmen and operators in order to create them
+    read the data and create them
+    '''
 
     for (element_id, element) in nodes.iteritems():                 # use an iterator to go through all the nodes
         element['id'] = element_id                                  # create a new entry for the element (dictionary)
@@ -194,7 +195,7 @@ def createObjects():
         for k in ('element_id', 'top', 'left'):
           element.pop(k, None)
                                                                     # with key 'id' and value the the element_id
-        resourceClass = element.pop('_class')          # get the class type of the element
+        resourceClass = element.pop('_class')                       # get the class type of the element
         if resourceClass=='Dream.Repairman':                        # check the object type
             id = element.get('id', 'not found')                     # get the id of the element
             name = element.get('name', id)                          # get the name of the element / default 'not_found'
@@ -242,11 +243,11 @@ def createObjects():
             G.OperatorsList.append(O)                               # add the operator to the RepairmanList
             G.OperatorManagedJobsList.append(O)
             G.ModelResourceList.append(O) 
-    # -----------------------------------------------------------------------
-    #                loop through all the model resources 
-    #          search for operatorPools in order to create them
-    #                   read the data and create them
-    # -----------------------------------------------------------------------
+    '''
+    loop through all the model resources 
+    search for operatorPools in order to create them
+    read the data and create them
+    '''
     for (element_id, element) in nodes.iteritems():                 # use an iterator to go through all the nodes
                                                                     # the key is the element_id and the second is the 
                                                                     # element itself 
@@ -273,10 +274,10 @@ def createObjects():
             for operator in operatorsList:
                 operator.coreObjectIds=OP.coreObjectIds        		# update the list of objects that the operators operate
             G.OperatorPoolsList.append(OP)                          # add the operatorPool to the RepairmanList
-    # -----------------------------------------------------------------------
-    #                    loop through all the elements    
-    #                    read the data and create them
-    # -----------------------------------------------------------------------
+    '''
+    loop through all the elements    
+    read the data and create them
+    '''
     for (element_id, element) in nodes.iteritems():
         element = element.copy()
         element['id'] = element_id
@@ -1411,7 +1412,10 @@ def main(argv=[], input_data=None):
             
         #carry on the post processing operations for every model resource in the topology       
         for model_resource in G.ModelResourceList:
-            model_resource.postProcessing()       
+            model_resource.postProcessing()
+            
+        # added for debugging, print the Route of the Jobs on the same G.traceFile
+        PrintRoute.outputRoute()
             
         #output trace to excel      
         if(G.trace=="Yes"):

dream/simulation/OperatorRouter.py

@@ -537,26 +537,6 @@ class Router(ObjectInterruption):
         if self.candidateOperators:
             candidateList=self.candidateOperators
             self.activeQSorter(criterion=self.schedulingRule,candList=candidateList)
-
-    def findCandidateReceiverFor(self, entity):
-        # initiate the local list variable available receivers
-        availableReceivers=[x for x in entity.candidateReceivers\
-                                        if not x in self.occupiedReceivers]
-        # and pick the object that is waiting for the most time
-        if availableReceivers:
-            # find the receiver that waits the most
-            availableReceiver=entity.currentStation.selectReceiver(availableReceivers)
-            self.occupiedReceivers.append(availableReceiver)
-        # if there is no available receiver add the entity to the entitiesWithOccupiedReceivers list
-        else:
-            self.entitiesWithOccupiedReceivers.append(entity)
-            availableReceiver=None
-        # if the sorting flag is not set then the sorting of each queue must prevail in case of operators conflict
-        if not self.sorting and not availableReceiver and bool(availableReceivers):
-            availableReceiver=entity.currentStation.selectReceiver(self.candidateReceivers)
-            if not entity in self.conflictingEntities:
-                self.conflictingEntities.append(entity)
-        return availableReceiver
          
     #=======================================================================
     # Find candidate entities and their receivers

dream/simulation/PrintRoute.py

+import Globals
+import xlwt
+from Globals import G
+
+import OrderComponent
+import Mould
+import Order
+import OrderDesign
+
+JOB_SHOP_TECHNOLOGY_SEQ=['CAD','CAM','MILL','EDM','ASSM','MA','INJM','IM' ]
+ORDER_COMPONENT_TYPE_SET=set(['OrderComponent','Design','Mould'])
+
+def sortMachines():
+    for tech in JOB_SHOP_TECHNOLOGY_SEQ:
+        G.MachineList.sort(key=lambda x: x.id.startswith(tech))
+
+def outputRoute():
+    '''            
+        prints the routes of the Jobs through the model as a table 
+        the horizontal axis represents the different stations of the model 
+        the vertical axis represents the time axis (events as points in time)
+        each job will move through the stations for a specific time
+        e.g.
+    
+    time\machines            M1        M2        M3        M4        M5
+                
+    t1                       J1
+    t2                       J1                            J2
+    t3                       J1                 J3         J2
+    t4                       J1                 J3         J2        J4
+    t5                                J2        J3                   J4
+    t6                                J2        J3         J1        J4
+    t7                                J2                   J1
+    
+        TODO: create multiple columns for each machine as one machine can receive more than one jobs at the same time (assembly)
+        or can get an entity when an entity is removed from it (the cell of this machine for the specific time is occupied by the last
+        job accessing it) 
+    '''
+    
+    if G.trace=='Yes':
+        if G.JobList:
+            G.routeSheetIndex=G.sheetIndex+1
+            # add one more sheet to the trace file
+            G.routeTraceSheet=G.traceFile.add_sheet('sheet '+str(G.routeSheetIndex)+' route', cell_overwrite_ok=True)
+            number_of_machines=len(G.MachineList)
+            sortMachines()  # sort the machines according to the priority specified in JOB_SHOP_TECHNOLOGY_SEQ
+            events_list=[]  # list to hold the events of the system
+            # list all events
+            for job in G.JobList:
+                if job.schedule:
+                    for record in job.schedule:
+                        if not record[1] in events_list:
+                            events_list.append(record[1])
+                        if len(record)==3:
+                            if not record[2] in events_list:
+                                events_list.append(record[2])
+            events_list.sort(cmp=None, key=None, reverse=False)     # sort the events
+            number_of_events=len(events_list)                       # keep the total number of events 
+            # create a table number_of_events X number_of_machines
+            G.routeTraceSheet.write(0,0, 'Time/Machines')
+            # write the events in the first column and the machineIDs in the first row
+            for j, event in enumerate(events_list):
+                G.routeTraceSheet.write(j+1,0,float(event))
+            for j, machine in enumerate(G.MachineList):
+                G.routeTraceSheet.write(0, j+1, str(machine.id))
+            # sort the jobs according to their name
+            G.JobList.sort(key=lambda x:x.id)
+            # list of cells to be written
+            cells=[]
+            # orders that have aliases
+            order_aliases=[]
+            # indices of orders
+            order_index=1
+            # indices of jobs
+            job_index=0
+            # for every job in the JobList
+            for job in G.JobList:
+                job_index+=1
+                # choose alias for the job
+                try:
+                    if not job.order in order_aliases:
+                        job.order.alias='O'+str(order_index)
+                        order_index+=1
+                        order_aliases.append(job.order)
+                    job.alias=job.order.alias+'J'+str(job_index)
+                except:
+                    job.alias='J'+str(job_index)
+                if job.schedule:
+                    for record in job.schedule:
+                        # find the station of this step
+                        station=record[0]               # XXX should also hold a list with all the machines G.MachineList?
+                        # find the column corresponding to the machine
+                        if station in G.MachineList:
+                            machine_index=G.MachineList.index(station)
+                            # find the entrance time of this step
+                            entrance_time=record[1]         # the time entity entered station
+                            # find the row corresponding to the event and start placing the name of the Job in the cells
+                            entrance_time_index=events_list.index(entrance_time)
+                            # find the exit time of this step
+                            if len(record)==3:
+                                exit_time=record[2]             # the time the entity exited the station
+                                # find the row corresponding to the event and place the name of the Job in the cell, this is the last cell of this processing
+                                exit_time_index=events_list.index(exit_time)
+                            elif len(record)!=3:
+                                exit_time_index=len(events_list)
+                            # for the rows with indices entrance_time_index to exit_time_index print the id of the Job in the column of the machine_index
+                            for step in range(entrance_time_index,exit_time_index+1, 1):
+                                stepDone=False
+                                # check if the cell is already written, if yes, then modify it adding the new jobs but not overwrite it
+                                if not cells:
+                                    cells.append({'row':step+1,
+                                                  'col':machine_index+1,
+                                                  'job':job.alias})
+                                    G.routeTraceSheet.write(step+1, machine_index+1, job.alias)
+                                    continue
+                                
+                                for cell in cells:
+                                    if cell['row']==step+1 and cell['col']==machine_index+1:
+                                        cell['job']=cell['job']+','+job.alias
+                                        G.routeTraceSheet.write(cell['row'], cell['col'], cell['job'])
+                                        stepDone=True
+                                        break
+                                if not stepDone:
+                                    cells.append({'row':step+1,
+                                                  'col':machine_index+1,
+                                                  'job':job.alias})
+                                    G.routeTraceSheet.write(step+1, machine_index+1, job.alias)
+            # print aliases
+            try:
+                sample_job=next(x for x in G.JobList)
+                if sample_job.__class__.__name__ in ORDER_COMPONENT_TYPE_SET:
+                    G.JobList.sort(key=lambda x:x.order.id)
+            except:
+                pass
+            for j,job in enumerate(G.JobList):
+                if job.schedule:
+                    G.routeTraceSheet.write(number_of_events+2+j, 0, job.id)
+                    G.routeTraceSheet.write(number_of_events+2+j, 1, job.alias)
+