class MachineManagedJob(MachineJobShop): # ======================================================================= # initialise the MachineManagedJob # ======================================================================= def initialize(self): MachineJobShop.initialize(self) self.type="MachineManagedJob" # holds the Entity that is to be obtained and will be updated by canAcceptAndIsRequested self.entityToGet=None #=========================================================================== # create an operatorPool if needed #=========================================================================== def createOperatorPool(self,operatorPool): #create an empty Operator Pool. This will be updated by canAcceptAndIsRequested id = self.id+'_OP' name=self.objName+'_operatorPool' self.operatorPool=OperatorPool(id, name, operatorsList=[]) from Globals import G G.OperatorPoolsList.append(self.operatorPool) #=========================================================================== # create router if needed #=========================================================================== def createRouter(self): #create a Router from Globals import G if not G.RouterList: self.router=RouterManaged() G.RouterList[0]=self.router # otherwise set the already existing router as the machines Router else: self.router=G.RouterList[0] #=========================================================================== # initialize broker if needed #=========================================================================== def initializeOperatorPool(self): self.operatorPool.initialize() self.operatorPool.operators=[] #=========================================================================== # initialize broker if needed #=========================================================================== def initializeBroker(self): self.broker.initialize() self.env.process(self.broker.run()) #=========================================================================== # initialize router if needed #=========================================================================== def initializeRouter(self): if not self.router.isInitialized: self.router.initialize() if not self.router.isActivated: self.env.process(self.router.run()) self.router.isActivated=True # ======================================================================= # checks if the Queue can accept an entity # TODO: cannot check here if the station in the route of the entity that will be received (if any) # as the giver (QueueManagedJob) will be sorted from giver.haveToDispose in self.canAcceptAndIsRequested method # ======================================================================= def canAccept(self, callerObject=None): activeObject=self.getActiveObject() activeObjectQueue=activeObject.getActiveObjectQueue() #return according to the state of the Queue return len(activeObjectQueue)<activeObject.capacity\ and activeObject.checkIfMachineIsUp()\ and not activeObject.entryIsAssignedTo() # ======================================================================= # checks if the Queue can accept an specific Entity # it checks also the next station of the Entity # and returns true only if the active object is the next station # ======================================================================= def canAcceptEntity(self, callerEntity=None): activeObject=self.getActiveObject() activeObjectQueue=activeObject.getActiveObjectQueue() thecallerentity=callerEntity if (thecallerentity!=None): # if the machine's Id is in the list of the entity's next stations if activeObject.id in thecallerentity.remainingRoute[0].get('stationIdsList',[]): #return according to the state of the Queue return len(activeObjectQueue)<activeObject.capacity\ and activeObject.checkIfMachineIsUp() return False # ======================================================================= # checks if the Machine can accept an entity and there is an entity in # some possible giver waiting for it # also updates the giver to the one that is to be taken # ======================================================================= def canAcceptAndIsRequested(self,callerObject=None): # get active and giver objects activeObject=self.getActiveObject() activeObjectQueue=self.getActiveObjectQueue() # giverObject=activeObject.getGiverObject() giverObject=callerObject assert giverObject, 'there must be a caller for canAcceptAndIsRequested' giverObjectQueue=giverObject.getActiveObjectQueue() # if the multOperationTypeList of the machine contains Load or Setup if (activeObject.operatorPool!='None' and (any(type=='Load' for type in activeObject.multOperationTypeList)\ or any(type=='Setup' for type in activeObject.multOperationTypeList))): if giverObject.haveToDispose(activeObject): if activeObject.checkIfActive() and len(activeObjectQueue)<activeObject.capacity\ and activeObject.checkOperator(giverObject): if not giverObject.exitIsAssignedTo(): giverObject.assignExitTo(activeObject) elif giverObject.exitIsAssignedTo()!=activeObject: return False # update entityToGet activeObject.entityToGet=giverObjectQueue[0] #make the operators List so that it holds only the manager of the current order activeObject.operatorPool.operators=[giverObjectQueue[0].manager] # read the load time of the machine activeObject.readLoadTime(giverObject) return True else: return False # if the multOperationTypeList contains only Processing elif (activeObject.operatorPool!='None' and any(type=='Processing' for type in activeObject.multOperationTypeList)): if giverObject.haveToDispose(activeObject): # the operator must not be available for the object to receive the entity # the exit of the giver should not be assigned # the manager must not be available for the entity to be delivered # the operator to the machine while he is not needed for receiving the entity if activeObject.checkIfActive() and len(activeObjectQueue)<activeObject.capacity: # the entityToGet should be updated activeObject.entityToGet=giverObjectQueue[0] #make the operators List so that it holds only the manager of the current order activeObject.operatorPool.operators=[giverObjectQueue[0].manager] # read the load time of the machine activeObject.readLoadTime(giverObject) return True else: return False else: # the operator doesn't have to be present for the loading of the machine as the load operation # is not assigned to operators if activeObject.checkIfActive() and len(activeObjectQueue)<activeObject.capacity and giverObject.haveToDispose(activeObject): # update entityToGet activeObject.entityToGet=giverObject.getActiveObjectQueue()[0] activeObject.readLoadTime(giverObject) return activeObject.checkIfActive() and len(activeObjectQueue)<activeObject.capacity and giverObject.haveToDispose(activeObject) # ======================================================================= # to be called by canAcceptAndIsRequested and check for the operator # ======================================================================= def checkOperator(self,callerObject=None): #, candidateEntity=None): assert callerObject!=None, 'checkOperator must have a caller for MachineManagedJob' activeObject=self.getActiveObject() # giverObject=activeObject.getGiverObject() giverObject=callerObject giverObjectQueue=giverObject.getActiveObjectQueue() if giverObjectQueue[0].manager: manager=giverObjectQueue[0].manager # TODO: consider using a caller in this case return manager.checkIfResourceIsAvailable(activeObject) else: return True # if candidateEntity: # if candidateEntity.manager: # manager=candidateEntity.manager # return manager.checkIfResourceIsAvailable() # else: # return True # return False # ======================================================================= # identifies the Entity to be obtained so that # getEntity gives it to removeEntity as argument # ======================================================================= def identifyEntityToGet(self): # ToDecide # maybe we should work this way in all CoreObjects??? return self.entityToGet
class MachineManagedJob(MachineJobShop): # ======================================================================= # initialise the MachineManagedJob # ======================================================================= def initialize(self): MachineJobShop.initialize(self) self.type = "MachineManagedJob" # holds the Entity that is to be obtained and will be updated by canAcceptAndIsRequested self.entityToGet = None #=========================================================================== # create an operatorPool if needed #=========================================================================== def createOperatorPool(self, operatorPool): #create an empty Operator Pool. This will be updated by canAcceptAndIsRequested id = self.id + '_OP' name = self.objName + '_operatorPool' self.operatorPool = OperatorPool(id, name, operatorsList=[]) from Globals import G G.OperatorPoolsList.append(self.operatorPool) #=========================================================================== # create router if needed #=========================================================================== def createRouter(self): #create a Router from Globals import G if not G.RouterList: self.router = RouterManaged() G.RouterList[0] = self.router # otherwise set the already existing router as the machines Router else: self.router = G.RouterList[0] #=========================================================================== # initialize broker if needed #=========================================================================== def initializeOperatorPool(self): self.operatorPool.initialize() self.operatorPool.operators = [] #=========================================================================== # initialize broker if needed #=========================================================================== def initializeBroker(self): self.broker.initialize() self.env.process(self.broker.run()) #=========================================================================== # initialize router if needed #=========================================================================== def initializeRouter(self): if not self.router.isInitialized: self.router.initialize() if not self.router.isActivated: self.env.process(self.router.run()) self.router.isActivated = True # ======================================================================= # checks if the Queue can accept an entity # TODO: cannot check here if the station in the route of the entity that will be received (if any) # as the giver (QueueManagedJob) will be sorted from giver.haveToDispose in self.canAcceptAndIsRequested method # ======================================================================= def canAccept(self, callerObject=None): activeObject = self.getActiveObject() activeObjectQueue = activeObject.getActiveObjectQueue() #return according to the state of the Queue return len(activeObjectQueue)<activeObject.capacity\ and activeObject.checkIfMachineIsUp()\ and not activeObject.entryIsAssignedTo() # ======================================================================= # checks if the Queue can accept an specific Entity # it checks also the next station of the Entity # and returns true only if the active object is the next station # ======================================================================= def canAcceptEntity(self, callerEntity=None): activeObject = self.getActiveObject() activeObjectQueue = activeObject.getActiveObjectQueue() thecallerentity = callerEntity if (thecallerentity != None): # if the machine's Id is in the list of the entity's next stations if activeObject.id in thecallerentity.remainingRoute[0].get( 'stationIdsList', []): #return according to the state of the Queue return len(activeObjectQueue)<activeObject.capacity\ and activeObject.checkIfMachineIsUp() return False # ======================================================================= # checks if the Machine can accept an entity and there is an entity in # some possible giver waiting for it # also updates the giver to the one that is to be taken # ======================================================================= def canAcceptAndIsRequested(self, callerObject=None): # get active and giver objects activeObject = self.getActiveObject() activeObjectQueue = self.getActiveObjectQueue() # giverObject=activeObject.getGiverObject() giverObject = callerObject assert giverObject, 'there must be a caller for canAcceptAndIsRequested' giverObjectQueue = giverObject.getActiveObjectQueue() # if the multOperationTypeList of the machine contains Load or Setup if (activeObject.operatorPool!='None' and (any(type=='Load' for type in activeObject.multOperationTypeList)\ or any(type=='Setup' for type in activeObject.multOperationTypeList))): if giverObject.haveToDispose(activeObject): if activeObject.checkIfActive() and len(activeObjectQueue)<activeObject.capacity\ and activeObject.checkOperator(giverObject): if not giverObject.exitIsAssignedTo(): giverObject.assignExitTo(activeObject) elif giverObject.exitIsAssignedTo() != activeObject: return False # update entityToGet activeObject.entityToGet = giverObjectQueue[0] #make the operators List so that it holds only the manager of the current order activeObject.operatorPool.operators = [ giverObjectQueue[0].manager ] # read the load time of the machine activeObject.readLoadTime(giverObject) return True else: return False # if the multOperationTypeList contains only Processing elif (activeObject.operatorPool != 'None' and any(type == 'Processing' for type in activeObject.multOperationTypeList)): if giverObject.haveToDispose(activeObject): # the operator must not be available for the object to receive the entity # the exit of the giver should not be assigned # the manager must not be available for the entity to be delivered # the operator to the machine while he is not needed for receiving the entity if activeObject.checkIfActive( ) and len(activeObjectQueue) < activeObject.capacity: # the entityToGet should be updated activeObject.entityToGet = giverObjectQueue[0] #make the operators List so that it holds only the manager of the current order activeObject.operatorPool.operators = [ giverObjectQueue[0].manager ] # read the load time of the machine activeObject.readLoadTime(giverObject) return True else: return False else: # the operator doesn't have to be present for the loading of the machine as the load operation # is not assigned to operators if activeObject.checkIfActive( ) and len(activeObjectQueue ) < activeObject.capacity and giverObject.haveToDispose( activeObject): # update entityToGet activeObject.entityToGet = giverObject.getActiveObjectQueue( )[0] activeObject.readLoadTime(giverObject) return activeObject.checkIfActive( ) and len(activeObjectQueue ) < activeObject.capacity and giverObject.haveToDispose( activeObject) # ======================================================================= # to be called by canAcceptAndIsRequested and check for the operator # ======================================================================= def checkOperator(self, callerObject=None): #, candidateEntity=None): assert callerObject != None, 'checkOperator must have a caller for MachineManagedJob' activeObject = self.getActiveObject() # giverObject=activeObject.getGiverObject() giverObject = callerObject giverObjectQueue = giverObject.getActiveObjectQueue() if giverObjectQueue[0].manager: manager = giverObjectQueue[0].manager # TODO: consider using a caller in this case return manager.checkIfResourceIsAvailable(activeObject) else: return True # if candidateEntity: # if candidateEntity.manager: # manager=candidateEntity.manager # return manager.checkIfResourceIsAvailable() # else: # return True # return False # ======================================================================= # identifies the Entity to be obtained so that # getEntity gives it to removeEntity as argument # ======================================================================= def identifyEntityToGet(self): # ToDecide # maybe we should work this way in all CoreObjects??? return self.entityToGet