コード例 #1
0
 def removeEntity(self, entity):
     activeEntity=Machine.removeEntity(self, entity)
     if self.state==-1:
         activeEntity.status='Bad'
     else:
         self.numGoodParts+=1
     return activeEntity
コード例 #2
0
 def removeEntity(self, entity):
     activeEntity = Machine.removeEntity(self, entity)
     if self.state == -1:
         activeEntity.status = 'Bad'
     else:
         self.numGoodParts += 1
     return activeEntity
コード例 #3
0
ファイル: CompoundMachine.py プロジェクト: goodhobak/dream
 def removeEntity(self,entity=None):
     # run the default method  
     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
コード例 #4
0
 def removeEntity(self, entity=None):
     # run the default method
     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
コード例 #5
0
ファイル: CompoundMachine.py プロジェクト: goodhobak/dream
 def getEntity(self):
     activeEntity=Machine.getEntity(self)
     for queue in G.InternalQueueList:
         station=queue.next[0]
         # do not send the signal if it is already triggered
         if not queue.canDispose.triggered:
             self.sendSignal(receiver=queue, signal=queue.canDispose, sender=station)
     return activeEntity
コード例 #6
0
 def getEntity(self):
     activeEntity = Machine.getEntity(self)
     for queue in G.InternalQueueList:
         station = queue.next[0]
         # do not send the signal if it is already triggered
         if not queue.canDispose.triggered:
             self.sendSignal(receiver=queue,
                             signal=queue.canDispose,
                             sender=station)
     return activeEntity
コード例 #7
0
# define the objects of the model
S = BatchSource('S',
                'Source',
                interArrivalTime={'Fixed': {
                    'mean': 1.5
                }},
                entity='Dream.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
                      }})
M3 = Machine('M3', 'Machine3', processingTime={'Fixed': {'mean': 1}})
E = Exit('E', 'Exit')

# define the predecessors and successors for the objects
S.defineRouting([Q])
Q.defineRouting([S], [BD])
BD.defineRouting([Q], [M1])
コード例 #8
0
from dream.simulation.imports import Machine, Source, Exit, Part, Queue, NonStarvingEntry
from dream.simulation.Globals import runSimulation

#define the objects of the model
NS = NonStarvingEntry('NS1', 'Entry', entityData={'_class': 'Dream.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):
    # add all the objects in a list
    objectList = [NS, M1, M2, M3, Q2, Q3, E]
    # set the length of the experiment
    maxSimTime = 480

    solutionList = []

    for i in range(1, 10):
コード例 #9
0
    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])
M2.defineRouting(predecessorList=[Q2], successorList=[QA])
M3.defineRouting(predecessorList=[Q3], successorList=[QA])
QA.defineRouting(predecessorList=[M1, M2, M3], successorList=[MA])
MA.defineRouting(predecessorList=[QA], successorList=[E])
E.defineRouting(predecessorList=[MA])

P1 = Part('P1', 'P1', currentStation=QB)
P2 = Part('P2', 'P2', currentStation=QB)
コード例 #10
0
ファイル: BufferAllocation.py プロジェクト: goodhobak/dream
from dream.simulation.imports import Machine, Source, Exit, Part, Queue, NonStarvingEntry
from dream.simulation.Globals import runSimulation

#define the objects of the model
NS=NonStarvingEntry('NS1','Entry',entityData={'_class':'Dream.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):
    # add all the objects in a list
    objectList=[NS,M1,M2,M3,Q2,Q3,E]  
    # set the length of the experiment  
    maxSimTime=480
    
    solutionList=[]
    
    for i in range(1,10):
コード例 #11
0
 def initialize(self):
     Machine.initialize(self)
     self.numGoodParts=0
     self.state=1
コード例 #12
0
from dream.simulation.imports import Machine, Queue, Exit, Part, ExcelHandler  
from dream.simulation.Globals import runSimulation, G

#define the objects of the model 
Q=Queue('Q1','Queue', capacity=1)
M=Machine('M1','Machine', processingTime={'Fixed':{'mean':0.25}})
E=Exit('E1','Exit')  
P1=Part('P1', 'Part1', currentStation=Q)

#define predecessors and successors for the objects    
Q.defineRouting(successorList=[M])
M.defineRouting(predecessorList=[Q],successorList=[E])
E.defineRouting(predecessorList=[M])

def main(test=0):
    # add all the objects in a list
    objectList=[Q,M,E,P1]  
    # set the length of the experiment  
    maxSimTime=float('inf')
    # call the runSimulation giving the objects and the length of the experiment
    runSimulation(objectList, maxSimTime, trace='Yes')

    # calculate metrics
    working_ratio = (M.totalWorkingTime/G.maxSimTime)*100

    # return results for the test
    if test:
        return {"parts": E.numOfExits,
        "simulationTime":E.timeLastEntityLeft,
      "working_ratio": working_ratio}
コード例 #13
0
ファイル: ParallelServers3.py プロジェクト: PanosBarlas/dream
#the custom queue
class SelectiveQueue(Queue):
    #override so that it chooses receiver according to priority
    def selectReceiver(self,possibleReceivers=[]):
        # 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
       
#define the objects of the model
S=Source('S','Source', interArrivalTime={'Fixed':{'mean':0.5}}, entity='Dream.Part')
Q=SelectiveQueue('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}}})

#create priority attribute in the Machines
M1.priority=10
M2.priority=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])
コード例 #14
0
ファイル: CompoundMachine.py プロジェクト: goodhobak/dream
 def canAccept(self, callerObject=None):
     # do not start processing unless there are enough parts 
     # (i.e. equal to the number of processes) in the compound machine
     if not self.countInternalParts()==len(G.InternalProcessList):
         return False
     return Machine.canAccept(self, callerObject)  
コード例 #15
0
ファイル: fleetManpy.py プロジェクト: royemanuel/Metrics
from dream.simulation.imports import Source, Queue, Machine, Exit
from dream.simulation.Globals import runSimulation

# This is the baby step to building a complicated model of the behavior
# of a fleet of systems with multiple stakeholders.
# The baby step includes:
#     A source to generate students
#     A Queue for students to wait for a flight
#     A machine (aircraft) to give students time
#     An exit for graduated students

# The source is API for Aviation Preflight Indocrination
API = Source('API', 'Source', interArrivalTime={'Fixed': {'mean': 0.5}},
             entity='Dream.Part')
RR = Queue('ReadyRoom', 'Queue', capacity=1)
AC = Machine('AC1', 'Machine', processingTime={'Fixed': {'mean': 0.25}})
E = Exit('The Fleet', 'The Fleet')

# The predecessors and successors for the objects
API.defineRouting(successorList=[RR])
RR.defineRouting(predecessorList=[API], successorList=[AC])
AC.defineRouting(predecessorList=[RR], successorList=[E])
E.defineRouting(predecessorList=[AC])

def main(test=0):
    # add all the objects in a list
    objectList=[API, RR, AC, E]
    # set the length of the experiment
    maxSimTime = 1440.0
    # call the runSimulation giving the objects and the length of the
    # experiment
コード例 #16
0
        if possibleReceivers[0].canAccept():
            return possibleReceivers[0]
        elif possibleReceivers[1].canAccept():
            return possibleReceivers[1]
        return None


#define the objects of the model
S = Source('S',
           'Source',
           interArrivalTime={'Fixed': {
               'mean': 0.5
           }},
           entity='Dream.Part')
Q = SelectiveQueue('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
                    }
                }
            })
コード例 #17
0
from dream.simulation.imports import Machine, BatchSource, Exit, Batch, BatchDecomposition, Queue, G 
from dream.simulation.imports import simulate, activate, initialize

# define the objects of the model
S=BatchSource('S','Source',interarrivalTime={'distributionType':'Fixed','mean':0.5}, entity='Dream.Batch', batchNumberOfUnits=4)
Q=Queue('Q','StartQueue',capacity=100000)
BD=BatchDecomposition('BC', 'BatchDecomposition', numberOfSubBatches=4, processingTime={'distributionType':'Fixed','mean':1})
M=Machine('M','Machine',processingTime={'distributionType':'Fixed','mean':0.5})
E=Exit('E','Exit')
# add all the objects in the G.ObjList so that they can be easier accessed later
G.ObjList=[S,Q,BD,M,E]
# define the predecessors and successors for the objects
S.defineRouting([Q])
Q.defineRouting([S],[BD])
BD.defineRouting([Q],[M])
M.defineRouting([BD],[E])
E.defineRouting([M])

def main():
    # initialize the simulation (SimPy method)
    initialize()
    # initialize all the objects
    for object in G.ObjList:
        object.initialize()
    # activate all the objects
    for object in G.ObjList:
        activate(object,object.run())
    # set G.maxSimTime 1440.0 minutes (1 day)
    G.maxSimTime=1440.0
    # run the simulation
    simulate(until=G.maxSimTime)
コード例 #18
0
 def postProcessing(self):
     Machine.postProcessing(self, MaxSimtime=maxSimTime)
     self.GoodExits.append(self.numGoodParts)
コード例 #19
0
 def canAccept(self, callerObject=None):
     # do not start processing unless there are enough parts
     # (i.e. equal to the number of processes) in the compound machine
     if not self.countInternalParts() == len(G.InternalProcessList):
         return False
     return Machine.canAccept(self, callerObject)
コード例 #20
0
from dream.simulation.imports import Machine, Source, Exit, Part, Repairman, Queue, Failure
from dream.simulation.Globals import runSimulation

#define the objects of the model
R = Repairman('R1', 'Bob')
S = Source('S1',
           'Source',
           interarrivalTime={'Exp': {
               'mean': 0.5
           }},
           entity='Dream.Part')
M1 = Machine('M1',
             'Machine1',
             processingTime={
                 'Normal': {
                     'mean': 0.25,
                     'stdev': 0.1,
                     'min': 0.1,
                     'max': 1
                 }
             })
M2 = Machine('M2',
             'Machine2',
             processingTime={
                 'Normal': {
                     'mean': 1.5,
                     'stdev': 0.3,
                     'min': 0.5,
                     'max': 5
                 }
             })
Q = Queue('Q1', 'Queue')
コード例 #21
0
ファイル: CompoundMachine.py プロジェクト: goodhobak/dream
 def haveToDispose(self, callerObject=None):
     for object in G.InternalProcessList:
         # if there is one other machine processing return False
         if object.isProcessing:
             return False
     return Machine.haveToDispose(self, callerObject)  
コード例 #22
0
ファイル: AssemblyLine.py プロジェクト: PanosBarlas/dream
from dream.simulation.imports import Machine, Source, Exit, Part, Frame, Assembly, Failure
from dream.simulation.Globals import runSimulation

#define the objects of the model
Frame.capacity=4 
Sp=Source('SP','Parts', interArrivalTime={'Fixed':{'mean':0.5}}, entity='Dream.Part')
Sf=Source('SF','Frames', interArrivalTime={'Fixed':{'mean':2}}, entity='Dream.Frame')
M=Machine('M','Machine', processingTime={'Fixed':{'mean':0.25}})
A=Assembly('A','Assembly', processingTime={'Fixed':{'mean':2}})
E=Exit('E1','Exit')  

F=Failure(victim=M, distribution={'TTF':{'Fixed':{'mean':60.0}},'TTR':{'Fixed':{'mean':5.0}}})

#define predecessors and successors for the objects    
Sp.defineRouting([A])
Sf.defineRouting([A])
A.defineRouting([Sp,Sf],[M])
M.defineRouting([A],[E])
E.defineRouting([M])

def main(test=0):
    # add all the objects in a list
    objectList=[Sp,Sf,M,A,E,F]  
    # 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=(A.totalWorkingTime/maxSimTime)*100
    
コード例 #23
0
 def haveToDispose(self, callerObject=None):
     for object in G.InternalProcessList:
         # if there is one other machine processing return False
         if object.isProcessing:
             return False
     return Machine.haveToDispose(self, callerObject)
コード例 #24
0
#define the objects of the model
Frame.capacity = 4
Sp = Source('SP',
            'Parts',
            interArrivalTime={'Fixed': {
                'mean': 0.5
            }},
            entity='Dream.Part')
Sf = Source('SF',
            'Frames',
            interArrivalTime={'Fixed': {
                'mean': 2
            }},
            entity='Dream.Frame')
M = Machine('M', 'Machine', processingTime={'Fixed': {'mean': 0.25}})
A = Assembly('A', 'Assembly', processingTime={'Fixed': {'mean': 2}})
E = Exit('E1', 'Exit')

F = Failure(victim=M,
            distribution={
                'TTF': {
                    'Fixed': {
                        'mean': 60.0
                    }
                },
                'TTR': {
                    'Fixed': {
                        'mean': 5.0
                    }
                }
コード例 #25
0
 def canAccept(self, callerObject=None):
     if self.locked:
         return False
     if self.state==0:
         return False
     return Machine.canAccept(self, callerObject)   
コード例 #26
0
            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)

#define predecessors and successors for the objects
Q1.defineRouting(successorList=[M])
コード例 #27
0
ファイル: ClearBatchLines.py プロジェクト: PanosBarlas/dream
from dream.simulation.imports import Machine, Source, Exit, Batch, BatchDecomposition,\
                            BatchSource, BatchReassembly, Queue, LineClearance, ExcelHandler, ExcelHandler 
from dream.simulation.Globals import runSimulation

# define the objects of the model
S=BatchSource('S','Source',interArrivalTime={'Fixed':{'mean':1.5}}, entity='Dream.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}})
M3=Machine('M3','Machine3',processingTime={'Fixed':{'mean':1}})
E=Exit('E','Exit')

# define the predecessors and successors for the objects
S.defineRouting([Q])
Q.defineRouting([S],[BD])
BD.defineRouting([Q],[M1])
M1.defineRouting([BD],[Q1])
Q1.defineRouting([M1],[M2])
M2.defineRouting([Q1],[BRA])
BRA.defineRouting([M2],[M3])
M3.defineRouting([BRA],[E])
E.defineRouting([M3])

def main(test=0):

    # add all the objects in a list
    objectList=[S,Q,BD,M1,Q1,M2,BRA,M3,E]  
    # set the length of the experiment  
コード例 #28
0
ファイル: ParallelServers3.py プロジェクト: mmariani/dream
 def getEntity(self):
     activeEntity=Machine.getEntity(self)        #call the parent method to get the entity
     part=self.getActiveObjectQueue()[0]         #retrieve the obtained part
     part.machineId=self.id                      #create an attribute to the obtained part and give it the value of the object's id
     return activeEntity                         #return the entity obtained
コード例 #29
0
 def canAccept(self, callerObject=None):
     if self.locked:
         return False
     if self.state == 0:
         return False
     return Machine.canAccept(self, callerObject)
コード例 #30
0
from dream.simulation.imports import Machine, Source, Exit, Part, Repairman, Queue, Failure
from dream.simulation.Globals import runSimulation

#define the objects of the model
R = Repairman('R1', 'Bob')
S = Source('S1',
           'Source',
           interArrivalTime={'Fixed': {
               'mean': 0.5
           }},
           entity='Dream.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,
コード例 #31
0
 def initialize(self):
     Machine.initialize(self)
     self.numGoodParts = 0
     self.state = 1
コード例 #32
0
ファイル: TwoServers.py プロジェクト: mmariani/dream
from dream.simulation.imports import Machine, Source, Exit, Part, G, Repairman, Queue, Failure 
from dream.simulation.imports import simulate, activate, initialize

#define the objects of the model
R=Repairman('R1', 'Bob')
S=Source('S1','Source', interarrivalTime={'distributionType':'Fixed','mean':0.5}, entity='Dream.Part')
M1=Machine('M1','Machine1', processingTime={'distributionType':'Fixed','mean':0.25})
Q=Queue('Q1','Queue')
M2=Machine('M2','Machine2', processingTime={'distributionType':'Fixed','mean':1.5})
E=Exit('E1','Exit')  

#create failures
F1=Failure(victim=M1, distribution={'distributionType':'Fixed','MTTF':60,'MTTR':5}, repairman=R) 
F2=Failure(victim=M2, distribution={'distributionType':'Fixed','MTTF':40,'MTTR':10}, repairman=R)

G.ObjList=[S,M1,M2,E,Q]   #add all the objects in G.ObjList so that they can be easier accessed later
G.MachineList=[M1,M2]

G.ObjectInterruptionList=[F1,F2]     #add all the objects in G.ObjList so that they can be easier accessed later

#define predecessors and successors for the objects    
S.defineRouting([M1])
M1.defineRouting([S],[Q])
Q.defineRouting([M1],[M2])
M2.defineRouting([Q],[E])
E.defineRouting([M2])

def main():
    initialize()                        #initialize the simulation (SimPy method)
    
    #initialize all the objects
コード例 #33
0
 def postProcessing(self):
     Machine.postProcessing(self, MaxSimtime=maxSimTime)
     self.GoodExits.append(self.numGoodParts)
コード例 #34
0
    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)
    
#define predecessors and successors for the objects    
Q1.defineRouting(successorList=[M])
コード例 #35
0
ファイル: fleetManpy.py プロジェクト: royemanuel/Metrics
# of a fleet of systems with multiple stakeholders.
# The baby step includes:
#     A source to generate students
#     A Queue for students to wait for a flight
#     A machine (aircraft) to give students time
#     An exit for graduated students

# The source is API for Aviation Preflight Indocrination
API = Source('API',
             'Source',
             interArrivalTime={'Fixed': {
                 'mean': 0.5
             }},
             entity='Dream.Part')
RR = Queue('ReadyRoom', 'Queue', capacity=1)
AC = Machine('AC1', 'Machine', processingTime={'Fixed': {'mean': 0.25}})
E = Exit('The Fleet', 'The Fleet')

# The predecessors and successors for the objects
API.defineRouting(successorList=[RR])
RR.defineRouting(predecessorList=[API], successorList=[AC])
AC.defineRouting(predecessorList=[RR], successorList=[E])
E.defineRouting(predecessorList=[AC])


def main(test=0):
    # add all the objects in a list
    objectList = [API, RR, AC, E]
    # set the length of the experiment
    maxSimTime = 1440.0
    # call the runSimulation giving the objects and the length of the