signalRouter and sortEntitiesForReceiver methods added

dream/simulation/CoreObject.py

@@ -348,24 +348,11 @@ class CoreObject(Process):
                     return False
                 receiver=activeObject.selectReceiver(possibleReceivers)
                 receiversGiver=activeObject
-
-            #------------------------------------------------------------------------------ 
-            # if an operator is not assigned to the receiver then do not signal the receiver but the Router
-            try:
-                if not receiver.assignedOperator:
-                    if any(type=='Load' or type=='Setup' for type in receiver.multOperationTypeList):
-                        from Globals import G
-                        if not G.Router.invoked:
-                            #===================================================================
-#                             # TESTING
-#                             print now(), self.id,' '*50, 'signalling router'
-                            #===================================================================
-                            G.Router.invoked=True
-                            G.Router.isCalled.signal(now())
-                        return False
-            except:
-                pass
-            #------------------------------------------------------------------------------ 
+            # sorting the entities of the object for the receiver
+            activeObject.sortEntitiesForReceiver(receiver)
+            # signalling the Router if the receiver is operated and not assigned an operator
+            if activeObject.signalRouter(receiver):
+                return False
 
             activeObject.receiver=receiver
             activeObject.receiver.giver=activeObject
@@ -395,6 +382,34 @@ class CoreObject(Process):
                 receiver=object                                 # set the receiver as the longest waiting possible receiver
         return receiver
     
+    #===========================================================================
+    #  signalRouter method
+    #===========================================================================
+    def signalRouter(self, receiver=None):
+        # if an operator is not assigned to the receiver then do not signal the receiver but the Router
+        try:
+            if not receiver.assignedOperator:
+                if receiver.isLoadRequested():
+                    from Globals import G
+                    if not G.Router.invoked:
+                        #===================================================================
+#                         # TESTING
+#                         print now(), self.id,' '*50, 'signalling router'
+                        #===================================================================
+                        G.Router.invoked=True
+                        G.Router.isCalled.signal(now())
+                    return True
+            else:
+                return False
+        except:
+            return False
+    
+    #===========================================================================
+    # sort the entities of the queue for the receiver
+    #===========================================================================
+    def sortEntitiesForReceiver(self, receiver=None):
+        pass
+    
     #===========================================================================
     # find possible givers
     #===========================================================================

dream/simulation/Machine.py

@@ -689,6 +689,13 @@ class Machine(CoreObject):
                     return False
                 return True
     
+    #===========================================================================
+    # return whether Load or setup Requested
+    #===========================================================================
+    def isLoadRequested(self):
+        activeObject=self.getActiveObject()
+        return any(type=='Load' or type=='Setup' for type in activeObject.multOperationTypeList)
+    
     # =======================================================================
     # to be called by canAcceptAndIsRequested and check for the operator
     # =======================================================================    

dream/simulation/QueueManagedJob.py

@@ -100,68 +100,31 @@ class QueueManagedJob(QueueJobShop):
 #         return len(activeObjectQueue)>0\
 #                 and (thecaller in activeObject.next)\
 #                 and thecaller.isInRoute(activeObject)
-
-
+    
     #===========================================================================
-    # signalReceiver Method
+    #  signalRouter method
     #===========================================================================
-    def signalReceiver(self):
-#         print now(), self.id, 'trying to signal receiver'
-        activeObject=self.getActiveObject()
-        possibleReceivers=[]
-        for object in [x for x in self.next if x.canAccept(activeObject)]:
-            possibleReceivers.append(object)
-        if possibleReceivers:
-            receiver=activeObject.selectReceiver(possibleReceivers)
-            receiversGiver=activeObject
-            # perform the checks that canAcceptAndIsRequested used to perform and update assignExit and operatorPool
-            while not receiver.canAcceptAndIsRequested(receiversGiver):
-#                 print 'removing receiver from possibleReceivrs', receiver.id
-                possibleReceivers.remove(receiver)
-                if not possibleReceivers:
-                    receiversGiver=None
-                    receiver=None
-                    return False
-                receiver=activeObject.selectReceiver(possibleReceivers)
-                receiversGiver=activeObject
-            #------------------------------------------------------------------------------ 
-            # TODO: if the receiver is already assigned an operator then the giver should sort for that manager
-            from Globals import G
-            for operator in G.OperatorsList:
-                if operator.isAssignedTo()==receiver:
-                    activeObject.sortEntitiesForOperator(operator)
-                    break
-            #------------------------------------------------------------------------------ 
-            # if an operator is not assigned to the receiver then do not signal the receiver but the Router
-            # TODO: identifyEntityToGet needs giver defined but here is not yet defined for Machines and machineJobShops 
-            try:
-                if receiver.identifyEntityToGet().manager:
-                    if any(type=='Load' or type=='Setup' for type in receiver.multOperationTypeList):
-                        if receiver.identifyEntityToGet().manager.isAssignedTo()!=receiver:
-                            from Globals import G
-                            if not G.Router.invoked:
-                                #===================================================================
-    #                             # TESTING
-#                                 print now(), self.id,' '*50, 'signalling router'
-                                #===================================================================
-                                G.Router.invoked=True
-                                G.Router.isCalled.signal(now())
-                            return False
-            except:
-                pass
-            activeObject.receiver=receiver
-            activeObject.receiver.giver=activeObject
-            #===================================================================
-# #             # TESTING
-#             print now(), self.id,' '*50, 'signalling receiver', self.receiver.id
-            #===================================================================
-            # assign the entry of the receiver
-            activeObject.receiver.assignEntryTo()
-            activeObject.receiver.isRequested.signal(activeObject)
-            return True
-        return False
+    def signalRouter(self, receiver=None):
+        # if an operator is not assigned to the receiver then do not signal the receiver but the Router
+        # TODO: identifyEntityToGet needs giver defined but here is not yet defined for Machines and machineJobShops 
+        try:
+            if receiver.identifyEntityToGet().manager:
+                if receiver.isLoadRequested():
+                    if receiver.identifyEntityToGet().manager.isAssignedTo()!=receiver:
+                        from Globals import G
+                        if not G.Router.invoked:
+                            #===================================================================
+#                             # TESTING
+#                             print now(), self.id,' '*50, 'signalling router'
+                            #===================================================================
+                            G.Router.invoked=True
+                            G.Router.isCalled.signal(now())
+                        return True
+            else:
+                return False
+        except:
+            return False
         
-
     # =======================================================================
     # override the default method so that Entities 
     # that have the manager available go in front
@@ -195,4 +158,16 @@ class QueueManagedJob(QueueJobShop):
             activeObjectQueue.sort(key=lambda x: x.manager==operator and x.managerAvailable, reverse=True)
         else:
             # added for testing
-            print 'there must be a caller defined for this kind of Queue sorting'
+            print 'there must be a caller defined for this kind of Queue sorting'
\ No newline at end of file
+    
+    #===========================================================================
+    # sort the entities of the queue for the receiver
+    #===========================================================================
+    def sortEntitiesForReceiver(self, receiver=None):
+        # TODO: if the receiver is already assigned an operator then the giver should sort for that manager
+        activeObject=self.getActiveObject()
+        from Globals import G
+        for operator in G.OperatorsList:
+            if operator.isAssignedTo()==receiver:
+                activeObject.sortEntitiesForOperator(operator)
+                break
\ No newline at end of file