def initialize(self):
Queue.initialize(self)
# if the station shares resources and the capacity is not defined in this
# then read it from some other of the sharing stations
if not self.intervalCapacity and self.sharedResources:
for stationId in self.sharedResources.get('stationIds', []):
import dream.simulation.Globals as Globals
station = Globals.findObjectById(stationId)
if station.intervalCapacity:
self.intervalCapacity = station.intervalCapacity
break
# initialize variables
self.remainingIntervalCapacity = list(self.intervalCapacity)
for i in range(self.intervalCapacityStart):
self.remainingIntervalCapacity.pop(0)
self.isLocked = True
self.utilisationDict = [
] # a list of dicts for the utilization results
self.detailedWorkPlan = [] # a list of dicts to keep detailed data
from dream.simulation.Globals import G
if hasattr(G, 'CapacityStationList'):
G.CapacityStationList.append(self)
else:
G.CapacityStationList = []
G.CapacityStationList.append(self)
def __init__(self, id, name, requireFullProject =False, capacity=float("inf"), isDummy=False,
schedulingRule="FIFO", gatherWipStat=False, notRequiredOperations=[],**kw):
Queue.__init__(self, id, name, capacity=capacity)
self.isLocked=True
self.requireFullProject=requireFullProject # flag that shows if here the whole project is assembled
from dream.simulation.Globals import G
if hasattr(G, 'CapacityStationBufferList'):
G.CapacityStationBufferList.append(self)
else:
G.CapacityStationBufferList=[]
G.CapacityStationBufferList.append(self)
self.notRequiredOperations=notRequiredOperations # operations that are not required to be assembled
def initialize(self):
Queue.initialize(self)
import dream.simulation.Globals as Globals
# identify the notRequiredOperations
# input gives only stationId, buffer and exit should be identified
notRequiredOperations=[]
for id in self.notRequiredOperations:
station=Globals.findObjectById(id)
notRequiredOperations.append(station.id)
bufferId=station.previous[0].id
notRequiredOperations.append(bufferId)
exitId=station.next[0].id
notRequiredOperations.append(exitId)
self.notRequiredOperations=notRequiredOperations
self.isLocked=True
def __init__(self, id, name, capacity=float("inf"), intervalCapacity=[], schedulingRule="FIFO", gatherWipStat=False,
sharedResources={}, intervalCapacityStart=0,intervalCapacityExceptions={},
notProcessOutsideThreshold=False,**kw):
Queue.__init__(self, id, name, capacity=capacity)
# a list that holds the capacity (manhours) that is available in each interval
self.intervalCapacity=intervalCapacity
# a list that holds the capacity (manhours) that is available in each interval for the remaining time
self.remainingIntervalCapacity=list(self.intervalCapacity)
# blocks the entry of the capacity station, so that it can be manipulated to accept only in certain moments of simulation time
self.isLocked=True
# dict that holds information if station shares workpower with some other station
self.sharedResources=sharedResources
self.intervalCapacityStart=intervalCapacityStart
self.intervalCapacityExceptions=intervalCapacityExceptions
self.notProcessOutsideThreshold=int(notProcessOutsideThreshold)
def initialize(self):
Queue.initialize(self)
import dream.simulation.Globals as Globals
# identify the notRequiredOperations
# input gives only stationId, buffer and exit should be identified
notRequiredOperations = []
for id in self.notRequiredOperations:
station = Globals.findObjectById(id)
notRequiredOperations.append(station.id)
bufferId = station.previous[0].id
notRequiredOperations.append(bufferId)
exitId = station.next[0].id
notRequiredOperations.append(exitId)
self.notRequiredOperations = notRequiredOperations
self.isLocked = True
def __init__(self,
id,
name,
requireFullProject=False,
capacity=float("inf"),
isDummy=False,
schedulingRule="FIFO",
gatherWipStat=False,
notRequiredOperations=[],
**kw):
Queue.__init__(self, id, name, capacity=capacity)
self.isLocked = True
self.requireFullProject = requireFullProject # flag that shows if here the whole project is assembled
from dream.simulation.Globals import G
if hasattr(G, 'CapacityStationBufferList'):
G.CapacityStationBufferList.append(self)
else:
G.CapacityStationBufferList = []
G.CapacityStationBufferList.append(self)
self.notRequiredOperations = notRequiredOperations # operations that are not required to be assembled
def initialize(self):
Queue.initialize(self)
# if the station shares resources and the capacity is not defined in this
# then read it from some other of the sharing stations
if not self.intervalCapacity and self.sharedResources:
for stationId in self.sharedResources.get('stationIds',[]):
import dream.simulation.Globals as Globals
station=Globals.findObjectById(stationId)
if station.intervalCapacity:
self.intervalCapacity=station.intervalCapacity
break
# initialize variables
self.remainingIntervalCapacity=list(self.intervalCapacity)
for i in range(self.intervalCapacityStart):
self.remainingIntervalCapacity.pop(0)
self.isLocked=True
self.utilisationDict=[] # a list of dicts for the utilization results
self.detailedWorkPlan=[] # a list of dicts to keep detailed data
from dream.simulation.Globals import G
if hasattr(G, 'CapacityStationList'):
G.CapacityStationList.append(self)
else:
G.CapacityStationList=[]
G.CapacityStationList.append(self)
def __init__(self,
id,
name,
capacity=float("inf"),
intervalCapacity=[],
schedulingRule="FIFO",
gatherWipStat=False,
sharedResources={},
intervalCapacityStart=0,
intervalCapacityExceptions={},
notProcessOutsideThreshold=False,
**kw):
Queue.__init__(self, id, name, capacity=capacity)
# a list that holds the capacity (manhours) that is available in each interval
self.intervalCapacity = intervalCapacity
# a list that holds the capacity (manhours) that is available in each interval for the remaining time
self.remainingIntervalCapacity = list(self.intervalCapacity)
# blocks the entry of the capacity station, so that it can be manipulated to accept only in certain moments of simulation time
self.isLocked = True
# dict that holds information if station shares workpower with some other station
self.sharedResources = sharedResources
self.intervalCapacityStart = intervalCapacityStart
self.intervalCapacityExceptions = intervalCapacityExceptions
self.notProcessOutsideThreshold = int(notProcessOutsideThreshold)
def canAccept(self, callerObject=None):
if self.isLocked:
return False
return Queue.canAccept(self)
def canAccept(self, callerObject=None):
if self.isLocked:
return False
return Queue.canAccept(self)
"isDummy": {
"id": "isDummy",
"type": "string",
"_class": "Dream.Property",
"_default": "0"
},
"schedulingRule": {
"id":
"schedulingRule",
"type":
"string",
"name":
"Scheduling Rule",
"description":
"Scheduling Rule, one of %s" %
(" ".join(Queue.getSupportedSchedulingRules())),
"choice":
[(rule, rule) for rule in Queue.getSupportedSchedulingRules()],
"_class":
"Dream.Property",
"_default":
"FIFO"
},
"capacity": {
"id": "capacity",
"type": "number",
"name": "Capacity",
"_class": "Dream.Property",
"_default": 1
},
"numberOfReplications": {
["Manual", "MT-Load-Processing"]],
"_class": "Dream.Property",
"_default": "MT-Load-Processing"
},
"isDummy": {
"id": "isDummy",
"type": "string",
"_class": "Dream.Property",
"_default": "0"
},
"schedulingRule": {
"id": "schedulingRule",
"type": "string",
"name": "Scheduling Rule",
"description": "Scheduling Rule, one of %s" % (" ".join(
Queue.getSupportedSchedulingRules())),
"choice": [(rule, rule) for rule in Queue.getSupportedSchedulingRules()],
"_class": "Dream.Property",
"_default": "FIFO"
},
"capacity": {
"id": "capacity",
"type": "number",
"name": "Capacity",
"_class": "Dream.Property",
"_default": 1
},
"numberOfReplications": {
"id": "numberOfReplications",
"name": "Number of replications",
"type": "number",
