def selectReceiver(self, possibleReceivers=[]):
# if all the possibleReceivers have the same priority work as cycle
priorityList = []
for element in possibleReceivers:
priorityList.append(element.priority)
if len(priorityList):
if priorityList.count(priorityList[0]) == len(priorityList):
return Queue.selectReceiver(possibleReceivers)
# else sort the receivers according to their priority
possibleReceivers.sort(key=lambda x: x.priority, reverse=True)
if possibleReceivers[0].canAccept():
return possibleReceivers[0]
elif possibleReceivers[1].canAccept():
return possibleReceivers[1]
return None
BatchReassembly,
Queue,
)
from manpy.simulation.Globals import runSimulation
# define the objects of the model
S = BatchSource(
"S",
"Source",
interArrivalTime={"Fixed": {
"mean": 1.5
}},
entity="manpy.Batch",
batchNumberOfUnits=100,
)
Q = Queue("Q", "StartQueue", capacity=100000)
BD = BatchDecomposition(
"BC",
"BatchDecomposition",
numberOfSubBatches=4,
processingTime={"Fixed": {
"mean": 1
}},
)
M1 = Machine("M1", "Machine1", processingTime={"Fixed": {"mean": 0.5}})
Q1 = Queue("Q1", "Queue1", capacity=2)
M2 = Machine("M2", "Machine2", processingTime={"Fixed": {"mean": 1}})
BRA = BatchReassembly(
"BRA",
"BatchReassembly",
numberOfSubBatches=4,
from manpy.simulation.imports import Source, Queue, Machine, Exit
from manpy.simulation.Globals import runSimulation
# define the objects of the model
S = Source(
"S1", "Source", interArrivalTime={"Fixed": {"mean": 0.5}}, entity="manpy.Part"
)
Q = Queue("Q1", "Queue", capacity=1)
M = Machine("M1", "Machine", processingTime={"Fixed": {"mean": 0.25}})
E = Exit("E1", "Exit")
# define predecessors and successors for the objects
S.defineRouting(successorList=[Q])
Q.defineRouting(predecessorList=[S], successorList=[M])
M.defineRouting(predecessorList=[Q], successorList=[E])
E.defineRouting(predecessorList=[M])
def main(test=0):
# add all the objects in a list
objectList = [S, Q, M, E]
# set the length of the experiment
maxSimTime = 1440.0
# call the runSimulation giving the objects and the length of the experiment
runSimulation(objectList, maxSimTime)
# calculate metrics
working_ratio = (M.totalWorkingTime / maxSimTime) * 100
# return results for the test
if test:
def canAccept(self, callerObject=None):
# if the next machine holds a part return false
if len(self.next[0].getActiveObjectQueue()):
return False
# else use the default Queue logic
return Queue.canAccept(self, callerObject)
activeEntity = Machine.removeEntity(self, entity)
# count the number of parts in the server.
# If it is empty have one internal queue to signal the queue before the compound object
if not self.countInternalParts():
self.sendSignal(receiver=QB, signal=QB.canDispose, sender=Q1)
return activeEntity
# returns the number of internal parts in the server
def countInternalParts(self):
totalParts = 0
for object in G.InternalProcessList + G.InternalQueueList:
totalParts += len(object.getActiveObjectQueue())
return totalParts
QB = Queue("QB", "QueueBefore", capacity=float("inf"))
Q1 = InternalQueue("Q1", "Q1", capacity=1)
M1 = InternalProcess("M1", "M1", processingTime={"Exp": {"mean": 1}})
Q2 = InternalQueue("Q2", "Q2", capacity=1)
M2 = InternalProcess("M2", "M2", processingTime={"Exp": {"mean": 1}})
Q3 = InternalQueue("Q3", "Q3", capacity=1)
M3 = InternalProcess("M3", "M3", processingTime={"Exp": {"mean": 1}})
QA = Queue("QA", "QueueAfter", capacity=float("inf"))
MA = Machine("MA", "MachineAfter", processingTime={"Exp": {"mean": 1}})
E = Exit("E", "Exit")
QB.defineRouting(successorList=[Q1, Q2, Q3])
Q1.defineRouting(predecessorList=[QB], successorList=[M1])
Q2.defineRouting(predecessorList=[QB], successorList=[M2])
Q3.defineRouting(predecessorList=[QB], successorList=[M3])
M1.defineRouting(predecessorList=[Q1], successorList=[QA])
for i in range(refillLevel):
# calculate the id and name of the new part
partId = "P" + str(G.numOfParts)
partName = "Part" + str(G.numOfParts)
# create the Part
P = Part(partId, partName, currentStation=buffer)
# set the part as WIP
setWIP([P])
G.numOfParts += 1
# else do nothing
else:
print(("buffer has", numInQueue, "parts. No need to bring more"))
# define the objects of the model
Q = Queue("Q1", "Queue", capacity=float("inf"))
M = Machine("M1", "Machine", processingTime={"Fixed": {"mean": 6}})
E = Exit("E1", "Exit")
EV = EventGenerator(
"EV",
"EntityCreator",
start=0,
stop=float("inf"),
interval=20,
method=balanceQueue,
argumentDict={
"buffer": Q,
"refillLevel": 5
},
)
from manpy.simulation.imports import Machine, Source, Exit, Part, Queue, Failure
from manpy.simulation.Globals import runSimulation
# define the objects of the model
S = Source(
"S", "Source", interArrivalTime={"Fixed": {"mean": 0.5}}, entity="manpy.Part"
)
Q = Queue("Q", "Queue", capacity=float("inf"))
M1 = Machine("M1", "Milling1", processingTime={"Fixed": {"mean": 0.25}})
M2 = Machine("M2", "Milling2", processingTime={"Fixed": {"mean": 0.25}})
E = Exit("E1", "Exit")
F = Failure(
victim=M1,
distribution={"TTF": {"Fixed": {"mean": 60.0}}, "TTR": {"Fixed": {"mean": 5.0}}},
)
# define predecessors and successors for the objects
S.defineRouting([Q])
Q.defineRouting([S], [M1, M2])
M1.defineRouting([Q], [E])
M2.defineRouting([Q], [E])
E.defineRouting([M1, M2])
def main(test=0):
# add all the objects in a list
objectList = [S, Q, M1, M2, E, F]
# set the length of the experiment
maxSimTime = 1440.0
# call the runSimulation giving the objects and the length of the experiment
def canAccept(self, callerObject=None):
if self.locked:
return False
return Queue.canAccept(self, callerObject)
Queue,
LineClearance,
ExcelHandler,
ExcelHandler,
)
from manpy.simulation.Globals import runSimulation
# define the objects of the model
S = BatchSource(
"S",
"Source",
interArrivalTime={"Fixed": {"mean": 1.5}},
entity="manpy.Batch",
batchNumberOfUnits=100,
)
Q = Queue("Q", "StartQueue", capacity=100000)
BD = BatchDecomposition(
"BC",
"BatchDecomposition",
numberOfSubBatches=4,
processingTime={"Fixed": {"mean": 1}},
)
M1 = Machine("M1", "Machine1", processingTime={"Fixed": {"mean": 0.5}})
Q1 = LineClearance("Q1", "Queue1", capacity=2)
M2 = Machine("M2", "Machine2", processingTime={"Fixed": {"mean": 4}})
BRA = BatchReassembly(
"BRA",
"BatchReassembly",
numberOfSubBatches=4,
processingTime={"Fixed": {"mean": 0}},
)
# set this as predecessor and break
else:
for buffer in possiblePredecessors:
if not buffer == machine.previous[0]:
machine.previous[0] = buffer
break
# if canDispose is not triggered in the predecessor send it
if not machine.previous[0].canDispose.triggered:
# a succeed function on an event must always take attributes the transmitter and the time of the event
succeedTuple = (machine, G.env.now)
machine.previous[0].canDispose.succeed(succeedTuple)
print((G.env.now, "from now on the machine will take from", machine.previous[0].id))
# define the objects of the model
Q1 = Queue("Q1", "Queue1", capacity=float("inf"))
Q2 = Queue("Q2", "Queue2", capacity=float("inf"))
M = Machine("M1", "Machine", processingTime={"Fixed": {"mean": 3}})
E = Exit("E1", "Exit")
P1 = Part("P1", "Part1", currentStation=Q1)
entityList = []
for i in range(5): # create the WIP in a loop
Q1PartId = "Q1_P" + str(i)
Q1PartName = "Q1_Part" + str(i)
PQ1 = Part(Q1PartId, Q1PartName, currentStation=Q1)
entityList.append(PQ1)
Q2PartId = "Q2_P" + str(i)
Q2PartName = "Q2_Part" + str(i)
PQ2 = Part(Q2PartId, Q2PartName, currentStation=Q2)
entityList.append(PQ2)
Source,
Exit,
Part,
Repairman,
Queue,
Failure,
)
from manpy.simulation.Globals import runSimulation
# define the objects of the model
R = Repairman("R1", "Bob")
S = Source(
"S1", "Source", interArrivalTime={"Fixed": {"mean": 0.5}}, entity="manpy.Part"
)
M1 = Machine("M1", "Machine1", processingTime={"Fixed": {"mean": 0.25}})
Q = Queue("Q1", "Queue")
M2 = Machine("M2", "Machine2", processingTime={"Fixed": {"mean": 1.5}})
E = Exit("E1", "Exit")
# create failures
F1 = Failure(
victim=M1,
distribution={"TTF": {"Fixed": {"mean": 60.0}}, "TTR": {"Fixed": {"mean": 5.0}}},
repairman=R,
)
F2 = Failure(
victim=M2,
distribution={"TTF": {"Fixed": {"mean": 40.0}}, "TTR": {"Fixed": {"mean": 10.0}}},
repairman=R,
)
# define predecessors and successors for the objects
from manpy.simulation.imports import (
Machine,
Source,
Exit,
Part,
Queue,
NonStarvingEntry,
)
from manpy.simulation.Globals import runSimulation
# define the objects of the model
NS = NonStarvingEntry("NS1", "Entry", entityData={"_class": "manpy.Part"})
M1 = Machine("M1", "Machine1", processingTime={"Exp": {"mean": 1}})
Q2 = Queue("Q2", "Queue2")
M2 = Machine("M2", "Machine2", processingTime={"Exp": {"mean": 3}})
Q3 = Queue("Q3", "Queue3")
M3 = Machine("M3", "Machine3", processingTime={"Exp": {"mean": 5}})
E = Exit("E1", "Exit")
# define predecessors and successors for the objects
NS.defineRouting(successorList=[M1])
M1.defineRouting(predecessorList=[NS], successorList=[Q2])
Q2.defineRouting(predecessorList=[M1], successorList=[M2])
M2.defineRouting(predecessorList=[Q2], successorList=[Q3])
Q3.defineRouting(predecessorList=[M2], successorList=[M3])
M3.defineRouting(predecessorList=[Q3], successorList=[E])
E.defineRouting(predecessorList=[M3])
def main(test=0):