def initialize(self):
ObjectInterruption.initialize(self)
# signal used to initiate the generator of the Router
self.isCalled=self.env.event()
# list that holds all the objects that can receive
self.pendingObjects=[]
self.calledOperator=[]
# list of the operators that may handle a machine at the current simulation time
self.candidateOperators=[]
# list of criteria
self.multipleCriterionList=[]
# TODO: find out which must be the default for the scheduling Rule
self.schedulingRule='WT'
# flag used to check if the Router is initialised
self.isInitialized=True
self.invoked=False
self.criticalPending=[]
self.preemptiveOperators=[]
self.toBeSignalled=[]
self.conflictingOperators=[]
self.conflictingEntities=[]
self.conflictingStations=[]
self.occupiedReceivers=[]
self.entitiesWithOccupiedReceivers=[]
def __init__(self, victim=None, shiftPattern=[], endUnfinished=False, receiveBeforeEndThreshold=0.0,**kw):
ObjectInterruption.__init__(self,victim)
self.type='ShiftScheduler'
self.shiftPattern=shiftPattern
self.endUnfinished=endUnfinished #flag that shows if half processed Jobs should end after the shift ends
# if the end of shift is below this threshold then the victim is on shift but does not accept new entities
self.receiveBeforeEndThreshold=receiveBeforeEndThreshold
def __init__(self, id="", name="", victim=None, distribution=None, index=0, repairman=None, **kw):
ObjectInterruption.__init__(self, id, name, victim=victim)
self.rngTTF = RandomNumberGenerator(self, distribution.get("TTF", {"Fixed": {"mean": 100}}))
self.rngTTR = RandomNumberGenerator(self, distribution.get("TTR", {"Fixed": {"mean": 10}}))
self.name = "F" + str(index)
self.repairman = repairman # the resource that may be needed to fix the failure
# if now resource is needed this will be "None"
self.type = "PeriodicMaintenance"
def __init__(self, id='', name='', operatedMachine=None):
ObjectInterruption.__init__(self, id, name, victim=operatedMachine)
self.type = "Broker"
# variables that have to do with timing
self.timeOperationStarted = 0
self.timeLastOperationEnded = 0
self.timeWaitForOperatorStarted = 0
self.waitForOperator = False
def __init__(self, id='',name='',victim=None, distribution=None, index=0, repairman=None,**kw):
ObjectInterruption.__init__(self,id,name,victim=victim)
self.rngTTF=RandomNumberGenerator(self, distribution.get('TTF',{'Fixed':{'mean':100}}))
self.rngTTR=RandomNumberGenerator(self, distribution.get('TTR',{'Fixed':{'mean':10}}))
self.name="F"+str(index)
self.repairman=repairman # the resource that may be needed to fix the failure
# if now resource is needed this will be "None"
self.type="PeriodicMaintenance"
def __init__(self, id='',name='', operatedMachine=None):
ObjectInterruption.__init__(self,id,name,victim=operatedMachine)
self.type = "Broker"
# variables that have to do with timing
self.timeOperationStarted = 0
self.timeLastOperationEnded = 0
self.timeWaitForOperatorStarted=0
self.waitForOperator=False
def initialize(self):
ObjectInterruption.initialize(self)
self.timeLastOperationEnded=0
self.timeOperationStarted=0
self.timeWaitForOperatorStarted=0
self.waitForOperator=False
# Broker events
self.isCalled=self.env.event()
self.resourceAvailable=self.env.event()
def initialize(self):
ObjectInterruption.initialize(self)
self.timeLastOperationEnded = 0
self.timeOperationStarted = 0
self.timeWaitForOperatorStarted = 0
self.waitForOperator = False
# Broker events
self.isCalled = self.env.event()
self.resourceAvailable = self.env.event()
def __init__(self, victim=None, distribution=None, index=0, repairman=None, offshift=False,
deteriorationType='constant',**kw):
#Process.__init__(self)
ObjectInterruption.__init__(self,victim)
if distribution:
self.distType=distribution.get('distributionType','No') # the distribution that the failure duration follows
self.MTTF=distribution.get('MTTF',60) # the MTTF
self.MTTR=distribution.get('MTTR',5) # the MTTR
self.availability=distribution.get('availability',100) # the availability
else:
self.distType='No'
self.MTTF=60
self.MTTR=5
self.availability=100
self.name="F"+str(index)
self.repairman=repairman # the resource that may be needed to fix the failure
# if now resource is needed this will be "None"
self.type="Failure"
self.id=0
# shows how the time to failure is measured
# 'constant' means it counts not matter the state of the victim
# 'onShift' counts only if the victim is onShift
# 'working' counts only working time
self.deteriorationType=deteriorationType
if(self.distType=="Availability"):
# --------------------------------------------------------------
# the following are used if we have availability defined
# (as in plant) the erlang is a special case of Gamma.
# To model the Mu and sigma (that is given in plant)
# as alpha and beta for gamma you should do the following:
# beta=(sigma^2)/Mu
# alpha=Mu/beta
# --------------------------------------------------------------
self.AvailabilityMTTF=self.MTTR*(float(availability)/100)/(1-(float(availability)/100))
self.sigma=0.707106781185547*self.MTTR
self.theta=(pow(self.sigma,2))/float(self.MTTR)
self.beta=self.theta
self.alpha=(float(self.MTTR)/self.theta)
self.rngTTF=RandomNumberGenerator(self, "Exp")
self.rngTTF.avg=self.AvailabilityMTTF
self.rngTTR=RandomNumberGenerator(self, "Erlang")
self.rngTTR.alpha=self.alpha
self.rngTTR.beta=self.beta
else:
# --------------------------------------------------------------
# if the distribution is fixed
# --------------------------------------------------------------
self.rngTTF=RandomNumberGenerator(self, self.distType)
self.rngTTF.mean=self.MTTF
self.rngTTR=RandomNumberGenerator(self, self.distType)
self.rngTTR.mean=self.MTTR
# flag used to identify if the time between failures should be counted while the victim is off-shift
self.offshift=offshift
def __init__(self, id='', name='', victim=None, shiftPattern=[], endUnfinished=False, receiveBeforeEndThreshold=0.0,
thresholdTimeIsOnShift=True,**kw):
ObjectInterruption.__init__(self,victim=victim)
self.type='ShiftScheduler'
self.shiftPattern=shiftPattern
self.endUnfinished=endUnfinished #flag that shows if half processed Jobs should end after the shift ends
# if the end of shift is below this threshold then the victim is on shift but does not accept new entities
self.receiveBeforeEndThreshold=receiveBeforeEndThreshold
# flag that shows if the threshold time is counted as off-shift or waiting
self.thresholdTimeIsOnShift=thresholdTimeIsOnShift
def __init__(self, id='',name='',victim=None, distribution={},
endUnfinished=True,offShiftAnticipation=0,**kw):
ObjectInterruption.__init__(self,id,name,victim=victim)
self.rngTTB=RandomNumberGenerator(self, distribution.get('TTB',{'Fixed':{'mean':100}}))
self.rngTTR=RandomNumberGenerator(self, distribution.get('TTR',{'Fixed':{'mean':10}}))
self.type="Break"
# end current wip before going to break
self.endUnfinished=endUnfinished
# if the break is close to end of shift below a limit it will be suspended
self.offShiftAnticipation=offShiftAnticipation
def __init__(self, id='', name='', operatedMachine=None):
ObjectInterruption.__init__(self, id, name, victim=operatedMachine)
self.type = "Broker"
# variables that have to do with timing
self.timeOperationStarted = 0
self.timeLastOperationEnded = 0
self.timeWaitForOperatorStarted = 0
self.waitForOperator = False
# flag that shows if broker was called to request or release operator.
# Machine updates this before calling the broker
self.invokeType = 'request'
def __init__(self, id='',name='', operatedMachine=None):
ObjectInterruption.__init__(self,id,name,victim=operatedMachine)
self.type = "Broker"
# variables that have to do with timing
self.timeOperationStarted = 0
self.timeLastOperationEnded = 0
self.timeWaitForOperatorStarted=0
self.waitForOperator=False
# flag that shows if broker was called to request or release operator.
# Machine updates this before calling the broker
self.invokeType='request'
def __init__(self, id=id, name=None, start=None, stop=None, interval=None,
duration=None, method=None, argumentDict=None):
ObjectInterruption.__init__(self)
self.id=id
self.name=name
self.start=start #the time that the generator will be activated for the first time
self.stop=stop #the time that the generator will stop to trigger events
self.interval=interval #the interval that the generator sleeps
self.duration=duration #the duration that the generation is awake (this is not active for now)
self.method=method #the method to be invoked
self.argumentDict=argumentDict #the arguments of the method given in a dict
def __init__(self, victim=None, start=0, duration=1, endStatus='interrupted',**kw):
'''
interrupted : the maintenance starts immediately
loaded : the maintenance starts as soon as the victim has ended processing
emptied : the maintenance starts as soon as the victim is empty
'''
self.type="ScheduledMaintenance"
ObjectInterruption.__init__(self,victim)
self.start=start
self.duration=duration
# the victim can be 'interrupted', 'loaded' or 'emptied' when the maintenance interruption happens
self.endStatus=endStatus
def __init__(self):
ObjectInterruption.__init__(self)
self.type = "Router"
self.isInitialized=False
self.isActivated=False
self.candidateOperators=[]
# list of objects to be signalled by the Router
self.toBeSignalled=[]
# flag to notify whether the router is already invoked
self.invoked=False
self.preemptiveOperators=[] # list of preemptiveOperators that should preempt their machines
self.criticalQueues=[]
self.pending=[] # list of entities that require operators now
def __init__(self):
ObjectInterruption.__init__(self)
self.type = "Router"
self.isInitialized=False
self.isActivated=False
self.candidateOperators=[]
# list of objects to be signalled by the Router
self.toBeSignalled=[]
# flag to notify whether the router is already invoked
self.invoked=False
self.preemptiveOperators=[] # list of preemptiveOperators that should preempt their machines
self.criticalQueues=[]
self.pending=[] # list of entities that require operators now
from Globals import G
G.RouterList.append(self)
def initialize(self):
ObjectInterruption.initialize(self)
# signal used to initiate the generator of the Router
self.isCalled=self.env.event()
# lists that hold all the objects that can receive
self.pendingMachines=[]
self.pendingQueues=[]
# list of the operators that may handle a machine at the current simulation time
self.candidateOperators=[]
# flag used to check if the Router is initialised
self.isInitialized=True
self.invoked=False
self.preemptiveOperators=[]
self.toBeSignalled=[]
self.criticalQueues=[]
self.pending=[] # list of entities that require operators now
def initialize(self):
ObjectInterruption.initialize(self)
# signal used to initiate the generator of the Router
self.isCalled = self.env.event()
# lists that hold all the objects that can receive
self.pendingMachines = []
self.pendingQueues = []
# list of the operators that may handle a machine at the current simulation time
self.candidateOperators = []
# flag used to check if the Router is initialised
self.isInitialized = True
self.invoked = False
self.preemptiveOperators = []
self.toBeSignalled = []
self.criticalQueues = []
self.pending = [] # list of entities that require operators now
def __init__(self, victim=None, distribution=None, index=0, repairman=None):
#Process.__init__(self)
ObjectInterruption.__init__(self,victim)
if distribution:
self.distType=distribution.get('distributionType','No') # the distribution that the failure duration follows
self.MTTF=distribution.get('MTTF',60) # the MTTF
self.MTTR=distribution.get('MTTR',5) # the MTTR
self.availability=distribution.get('availability',100) # the availability
else:
self.distType='No'
self.MTTF=60
self.MTTR=5
self.availability=100
self.name="F"+str(index)
self.repairman=repairman # the resource that may be needed to fix the failure
# if now resource is needed this will be "None"
self.type="Failure"
self.id=0
if(self.distType=="Availability"):
# --------------------------------------------------------------
# the following are used if we have availability defined
# (as in plant) the erlang is a special case of Gamma.
# To model the Mu and sigma (that is given in plant)
# as alpha and beta for gamma you should do the following:
# beta=(sigma^2)/Mu
# alpha=Mu/beta
# --------------------------------------------------------------
self.AvailabilityMTTF=self.MTTR*(float(availability)/100)/(1-(float(availability)/100))
self.sigma=0.707106781185547*self.MTTR
self.theta=(pow(self.sigma,2))/float(self.MTTR)
self.beta=self.theta
self.alpha=(float(self.MTTR)/self.theta)
self.rngTTF=RandomNumberGenerator(self, "Exp")
self.rngTTF.avg=self.AvailabilityMTTF
self.rngTTR=RandomNumberGenerator(self, "Erlang")
self.rngTTR.alpha=self.alpha
self.rngTTR.beta=self.beta
else:
# --------------------------------------------------------------
# if the distribution is fixed
# --------------------------------------------------------------
self.rngTTF=RandomNumberGenerator(self, self.distType)
self.rngTTF.mean=self.MTTF
self.rngTTR=RandomNumberGenerator(self, self.distType)
self.rngTTR.mean=self.MTTR
def __init__(self, id=id, name=None, start=0, stop=float('inf'), interval=1,
duration=0, method=None, argumentDict={}, **kw):
ObjectInterruption.__init__(self)
self.id=id
self.name=name
self.start=float(start) #the time that the generator will be activated for the first time
self.stop=float(stop) #the time that the generator will stop to trigger events
self.interval=float(interval) #the interval that the generator sleeps
self.duration=float(duration) #the duration that the generation is awake (this is not active for now)
self.method=method #the method to be invoked
self.argumentDict=argumentDict #the arguments of the method given in a dict
from Globals import G
G.EventGeneratorList.append(self)
self.method=method
if isinstance(method, basestring):
import Globals
self.method=Globals.getMethodFromName(method)
def __init__(self,
id='',
name='',
victim=None,
shiftPattern=[],
endUnfinished=False,
receiveBeforeEndThreshold=0.0,
thresholdTimeIsOnShift=True,
**kw):
ObjectInterruption.__init__(self, victim=victim)
self.type = 'ShiftScheduler'
self.shiftPattern = shiftPattern
self.endUnfinished = endUnfinished #flag that shows if half processed Jobs should end after the shift ends
# if the end of shift is below this threshold then the victim is on shift but does not accept new entities
self.receiveBeforeEndThreshold = receiveBeforeEndThreshold
# flag that shows if the threshold time is counted as off-shift or waiting
self.thresholdTimeIsOnShift = thresholdTimeIsOnShift
def __init__(self,
id='',
name='',
victim=None,
start=0,
duration=1,
endStatus='interrupted',
**kw):
'''
interrupted : the maintenance starts immediately
loaded : the maintenance starts as soon as the victim has ended processing
emptied : the maintenance starts as soon as the victim is empty
'''
self.type = "ScheduledMaintenance"
ObjectInterruption.__init__(self, victim=victim)
self.start = start
self.duration = duration
# the victim can be 'interrupted', 'loaded' or 'emptied' when the maintenance interruption happens
self.endStatus = endStatus
def __init__(self, id='',name='',victim=None, distribution={}, index=0, repairman=None, offshift=False,
deteriorationType='constant',
waitOnTie=False,**kw):
ObjectInterruption.__init__(self,id,name,victim=victim)
self.rngTTF=RandomNumberGenerator(self, distribution.get('TTF',{'Fixed':{'mean':100}}))
self.rngTTR=RandomNumberGenerator(self, distribution.get('TTR',{'Fixed':{'mean':10}}))
self.name="F"+str(index)
self.repairman=repairman # the resource that may be needed to fix the failure
# if now resource is needed this will be "None"
self.type="Failure"
# shows how the time to failure is measured
# 'constant' means it counts not matter the state of the victim
# 'onShift' counts only if the victim is onShift
# 'working' counts only working time
self.deteriorationType=deteriorationType
# flag used to identify if the time between failures should be counted while the victim is off-shift
self.offshift=offshift
# flag to show if the failure will wait on tie with other events before interrupting the victim
self.waitOnTie=waitOnTie
def __init__(self,
id='',
name='',
victim=None,
distribution={},
endUnfinished=True,
offShiftAnticipation=0,
**kw):
ObjectInterruption.__init__(self, id, name, victim=victim)
self.rngTTB = RandomNumberGenerator(
self, distribution.get('TTB', {'Fixed': {
'mean': 100
}}))
self.rngTTR = RandomNumberGenerator(
self, distribution.get('TTR', {'Fixed': {
'mean': 10
}}))
self.type = "Break"
# end current wip before going to break
self.endUnfinished = endUnfinished
# if the break is close to end of shift below a limit it will be suspended
self.offShiftAnticipation = offShiftAnticipation
def __init__(self,
id=id,
name=None,
start=0,
stop=float('inf'),
interval=1,
duration=0,
method=None,
argumentDict={},
**kw):
ObjectInterruption.__init__(self)
self.id = id
self.name = name
self.start = float(
start
) #the time that the generator will be activated for the first time
self.stop = float(
stop) #the time that the generator will stop to trigger events
# negative stop means infinity
if self.stop < 0:
self.stop = float('inf')
self.interval = float(
interval) #the interval that the generator sleeps
self.duration = float(
duration
) #the duration that the generation is awake (this is not active for now)
self.method = method #the method to be invoke
self.argumentDict = argumentDict
# if the argumentDict is passed as string convert it to dict
if isinstance(self.argumentDict, basestring):
import ast
self.argumentDict = ast.literal_eval(self.argumentDict)
from Globals import G
G.EventGeneratorList.append(self)
self.method = method
if isinstance(method, basestring):
import Globals
self.method = Globals.getMethodFromName(method)
def __init__(self,sorting=False):
ObjectInterruption.__init__(self)
self.type = "Router"
self.isInitialized=False
self.isActivated=False
self.candidateOperators=[]
self.multipleCriterionList=[]
self.schedulingRule='WT'
# boolean flag to check whether the Router should perform sorting on operators and on pendingEntities
self.sorting=sorting
# list of objects to be signalled by the Router
self.toBeSignalled=[]
# flag to notify whether the router is already invoked
self.invoked=False
self.criticalPending=[] # list of critical entities that are pending
self.preemptiveOperators=[] # list of preemptiveOperators that should preempt their machines
self.conflictingOperators=[] # list with the operators that have candidateEntity with conflicting candidateReceivers
self.conflictingEntities=[] # entities with conflictingReceivers
self.conflictingStations=[] # stations with conflicting operators
self.occupiedReceivers=[] # occupied candidateReceivers of a candidateEntity
self.entitiesWithOccupiedReceivers=[] # list of entities that have no available receivers
def initialize(self):
ObjectInterruption.initialize(self)
self.remainingBreakPattern=list(self.breakPattern)
self.waitingSignal=False
def initialize(self):
ObjectInterruption.initialize(self)
self.remainingShiftPattern=list(self.shiftPattern)
# self.victimEndedLastProcessing=self.env.event()
self.waitingSignal=False
def initialize(self):
ObjectInterruption.initialize(self)
self.readData()
self.FDC=FutureDemandCreator()
def __init__(self, victim=None, shiftPattern=[], endUnfinished=False):
ObjectInterruption.__init__(self,victim)
self.type='ShiftScheduler'
self.shiftPattern=shiftPattern
self.endUnfinished=endUnfinished #flag that shows if half processed Jobs should end after the shift ends
def initialize(self):
ObjectInterruption.initialize(self)
self.remainingShiftPattern=list(self.shiftPattern)
def initialize(self):
ObjectInterruption.initialize(self)
# self.victimEndedLastProcessing=self.env.event()
self.waitingSignal=False
# not used yet
self.victimIsEmptyBeforeMaintenance=self.env.event()
def __init__(self, id=id, name=None, argumentDict={}):
ObjectInterruption.__init__(self)
self.id=id
self.name=name
self.argumentDict=argumentDict #the arguments of the method given in a dict
self.initialize()
def initialize(self):
ObjectInterruption.initialize(self)
self.readData()
self.FDC=FutureDemandCreator()
from Globals import G
G.AllocationManagementList.append(self)
def __init__(self, victim=None, start=0, duration=1):
ObjectInterruption.__init__(self,victim)
self.start=start
self.duration=duration
def initialize(self):
ObjectInterruption.initialize(self)
self.readData()
self.FDC = FutureDemandCreator()
from Globals import G
G.AllocationManagementList.append(self)
def __init__(self, id=id, name=None, argumentDict={}):
ObjectInterruption.__init__(self)
self.id = id
self.name = name
self.argumentDict = argumentDict #the arguments of the method given in a dict
self.initialize()
def initialize(self):
ObjectInterruption.initialize(self)
self.victimStartsProcess = self.env.event()
self.victimEndsProcess = self.env.event()
def initialize(self):
ObjectInterruption.initialize(self)
self.remainingShiftPattern = list(self.shiftPattern)
# self.victimEndedLastProcessing=self.env.event()
self.waitingSignal = False
def initialize(self):
ObjectInterruption.initialize(self)
# self.victimEndedLastProcessing=self.env.event()
self.waitingSignal = False
# not used yet
self.victimIsEmptyBeforeMaintenance = self.env.event()
def initialize(self):
ObjectInterruption.initialize(self)
self.remainingBreakPattern = list(self.breakPattern)
self.waitingSignal = False
def initialize(self):
ObjectInterruption.initialize(self)
self.victimStartsProcess = self.env.event()
self.victimEndsProcess = self.env.event()