예제 #1
0
 def run(self, forward=True):
     """
     used in DejaVu/scenarioInterface/animationGUI.py animClip.makeAndRunMAA
     """
     if len(self.maas) == 0:
         #print "no actors"
         return
     initialize()
     redraw = self.redrawActor
     actors = self.actors
     afterAnimation = self.afterAnimation
     start = self.firstPosition
     end = self.lastPosition
     if redraw:
         redraw.object.stopAutoRedraw()
         proc = RedrawActorProcess(redraw)
         activate(proc, proc.execute(), at=start, prior=True)
         #print 'activated redraw',
     for actor in actors:
         if actor == redraw: continue
         proc = ActorProcess(actor)
         activate(proc, proc.execute(), at=start, prior=True)
     simulate(until=end)
     #self.currentFrame = self.endFrame
     if forward:
         #self.currentFrame = self.endFrame
         self.currentFrame = end
     else:
         self.currentFrame = start
     # call callback after animation completes
     for f in afterAnimation:
         f()
     #self.afterAnimation_cb()
     if redraw:
         redraw.object.startAutoRedraw()
 def run(self, forward=True):
     """
     used in DejaVu/scenarioInterface/animationGUI.py animClip.makeAndRunMAA
     """
     if len(self.maas)==0:
         #print "no actors"
         return
     initialize()
     redraw = self.redrawActor
     actors = self.actors
     afterAnimation = self.afterAnimation
     start = self.firstPosition
     end = self.lastPosition
     if redraw:
         redraw.object.stopAutoRedraw()
         proc = RedrawActorProcess(redraw)
         activate(proc, proc.execute(), at=start, prior=True)
         #print 'activated redraw', 
     for actor in actors:
         if actor == redraw:continue
         proc = ActorProcess(actor)
         activate(proc, proc.execute(), at=start, prior=True)
     simulate(until=end)
     #self.currentFrame = self.endFrame
     if forward:
         #self.currentFrame = self.endFrame
         self.currentFrame = end
     else:
        self.currentFrame = start
     # call callback after animation completes
     for f in afterAnimation:
         f()
     #self.afterAnimation_cb()
     if redraw:
         redraw.object.startAutoRedraw()
예제 #3
0
def main():
 
    #create an empty list to store all the objects in   
    G.ObjList=[]
    
    #user inputs the id of the JSON file
    topologyId=raw_input("give the path to the CMSD file\n")
    try:
        G.CMSDFile=open(str(topologyId), "r")
    except IOError:
        print "no such file. The programm is terminated"
        sys.exit()

    start=time.time()   #start counting execution time 
    
    #read the input from the CMSD file and create the line
    G.InputData=G.CMSDFile.read()
    G.CMSDData=parseString(G.InputData)
    readGeneralInput()
    readResources()
    readProcessIdentifiersSequence()
    readProcesses()
    setPredecessorIDs()
    setSuccessorIDs()
    setTopology()     
         
    #run the experiment (replications)          
    for i in range(G.numberOfReplications):
        print "start run number "+str(i+1) 
        G.seed+=1
        G.Rnd=Random(G.seed)             
        initialize()                        #initialize the simulation 
        initializeObjects()
        activateObjects()                            
        simulate(until=G.maxSimTime)      #start the simulation
        
        #carry on the post processing operations for every object in the topology       
        for j in range(len(G.ObjList)):
            G.ObjList[j].postProcessing(G.maxSimTime) 
            
        #output trace to excel
        if(G.trace=="Yes"):
            G.traceFile.save('trace'+str(i+1)+'.xls')
            G.traceIndex=0    #index that shows in what row we are
            G.sheetIndex=1    #index that shows in what sheet we are
            G.traceFile = xlwt.Workbook()     #create excel file
            G.traceSheet = G.traceFile.add_sheet('sheet '+str(G.sheetIndex), cell_overwrite_ok=True)  #create excel sheet
    
    G.outputSheet.write(G.outputIndex,0, "Execution Time")
    G.outputSheet.write(G.outputIndex,1, str(time.time()-start)+" seconds")
    G.outputIndex+=2 
        
    #output data to excel for every object in the topology         
    for j in range(len(G.ObjList)):
        G.ObjList[j].outputResultsXL(G.maxSimTime)            

    G.outputFile.save("output.xls")      
    print "execution time="+str(time.time()-start) 
예제 #4
0
def main():
    start = time.time()
    parser = CustomArgsParser(optFlags=['--verify'])
    parser.parse(sys.argv[1:])
    if len(parser.getPosArgs()) < 1:
        print 'python sim.py <config dir> --verify'
        sys.exit(-1)
    path = parser.getPosArg(0)
    configFile = '%s/__config__' % path
    configs = Configuration()
    configs.read(configFile)

    if parser.getOption('--verify'):
        configs['system.should.verify'] = True

    #simulation init
    #logging.basicConfig(level=logging.DEBUG)
    logging.config.fileConfig('%s/__logcfg__' % path)
    logger = logging.getLogger(__name__)
    #simpy initialize
    initialize()
    #system initialize
    RTI.initialize(configs)
    txnGenCls = loadClass(configs['txn.gen.impl'])
    txnGen = txnGenCls(configs)
    systemCls = loadClass(configs['system.impl'])
    system = systemCls(configs)
    for txn, at in txnGen.generate():
        system.schedule(txn, at)
    system.start()
    #pdb.set_trace()
    #simulate
    logger.info('\n#####  START SIMULATION  #####\n')
    simulate(until=configs.get('simulation.duration', 600000))
    logger.info('simulated time: %s' % now())
    logger.info('\n#####  END  #####\n')

    ##verify
    try:
        if parser.getOption('--verify'):
            logger.info('\n#####  START VERIFICATION  #####\n')
            v = Verifier()
            v.check(system)
            logger.info('VERIFICATION SUCCEEDS\n')
            logger.info('\n#####  END  #####\n')
    except:
        logger.error('Verification failed.')

    #get profile
    logger.info('\n#####  PROFILING RESULTS  #####\n')
    system.profile()
    #system.printMonitor()
    logger.info('\n#####  END  #####\n')

    end = time.time()
    logger.info('\n#####  SIMULATION TIME: %s seconds  #####\n' %
                (end - start))
예제 #5
0
def main():
    start = time.time()
    parser = CustomArgsParser(optFlags=['--verify'])
    parser.parse(sys.argv[1:])
    if len(parser.getPosArgs()) < 1:
        print 'python sim.py <config dir> --verify'
        sys.exit(-1)
    path = parser.getPosArg(0)
    configFile = '%s/__config__' %path
    configs = Configuration()
    configs.read(configFile)

    if parser.getOption('--verify'):
        configs['system.should.verify'] = True

    #simulation init
    #logging.basicConfig(level=logging.DEBUG)
    logging.config.fileConfig('%s/__logcfg__' %path)
    logger = logging.getLogger(__name__)
    #simpy initialize
    initialize()
    #system initialize
    RTI.initialize(configs)
    txnGenCls = loadClass(configs['txn.gen.impl'])
    txnGen = txnGenCls(configs)
    systemCls = loadClass(configs['system.impl'])
    system = systemCls(configs)
    for txn, at in txnGen.generate():
        system.schedule(txn, at)
    system.start()
    #pdb.set_trace()
    #simulate
    logger.info('\n#####  START SIMULATION  #####\n')
    simulate(until=configs.get('simulation.duration', 600000))
    logger.info('simulated time: %s' %now())
    logger.info('\n#####  END  #####\n')

    ##verify
    try:
        if parser.getOption('--verify'):
            logger.info('\n#####  START VERIFICATION  #####\n')
            v = Verifier()
            v.check(system)
            logger.info('VERIFICATION SUCCEEDS\n')
            logger.info('\n#####  END  #####\n')
    except:
        logger.error('Verification failed.')

    #get profile
    logger.info('\n#####  PROFILING RESULTS  #####\n')
    system.profile()
    #system.printMonitor()
    logger.info('\n#####  END  #####\n')

    end = time.time()
    logger.info('\n#####  SIMULATION TIME: %s seconds  #####\n' %(end - start))
예제 #6
0
    def run(self, forward=True):
        """
        used in DejaVu/scenarioInterface/animationPanels.py AnimationPanel.runMAA
        """
        if len(self.actors) == 0:
            #print "no actors"
            return
        initialize()
        redraw = self.redrawActor
        start = 0
        #end = self.endFrame
        self.maxFrame = 0
        maxFrame = self.getLastFrameWithChange()
        if maxFrame is not None:
            self.maxFrame = maxFrame.pos

        end = self.maxFrame
        gui = self.gui
        if gui:
            if not (gui.startFrame == 0 and gui.stopFrame == 1):
                start = gui.startFrame
                end = gui.stopFrame
                self.maxFrame = end + start
        self.moveForward = forward
        if redraw:
            redraw.object.stopAutoRedraw()
            proc = RedrawActorProcess(redraw)
            activate(proc, proc.execute(), at=start, prior=True)
            #print 'activated redraw',
        for actor in self.actors:
            if actor.name != "redraw":
                proc = ActorProcess(actor)
                activate(proc, proc.execute(), at=start, prior=True)
                #print 'activated ', actor.name, action
        #print 'simulate', self.endFrame
        simulate(until=end)
        #self.currentFrame = self.endFrame
        if forward:
            #self.currentFrame = self.endFrame
            self.currentFrame = end
        else:
            self.currentFrame = start
        # call callback after animation completes
        for f in self.afterAnimation:
            f()
        #self.afterAnimation_cb()
        if self.redrawActor:
            vi = self.redrawActor.object
            vi.startAutoRedraw()
    def run(self, forward=True):
        """
        used in DejaVu/scenarioInterface/animationPanels.py AnimationPanel.runMAA
        """
        if len(self.actors)==0:
            #print "no actors"
            return
        initialize()
        redraw = self.redrawActor
        start = 0
        #end = self.endFrame
        self.maxFrame = 0
        maxFrame = self.getLastFrameWithChange()
        if maxFrame is not None:
            self.maxFrame = maxFrame.pos

        end = self.maxFrame
        gui = self.gui
        if gui:
            if not (gui.startFrame == 0 and gui.stopFrame == 1):
                start = gui.startFrame
                end = gui.stopFrame
                self.maxFrame = end + start
        self.moveForward = forward
        if redraw:
            redraw.object.stopAutoRedraw()
            proc = RedrawActorProcess(redraw)
            activate(proc, proc.execute(), at=start, prior=True)
            #print 'activated redraw', 
        for actor in self.actors:
            if actor.name != "redraw":
                proc = ActorProcess(actor)
                activate(proc, proc.execute(), at=start, prior=True)
                #print 'activated ', actor.name, action
        #print 'simulate', self.endFrame
        simulate(until=end)
        #self.currentFrame = self.endFrame
        if forward:
            #self.currentFrame = self.endFrame
            self.currentFrame = end
        else:
           self.currentFrame = start
        # call callback after animation completes
        for f in self.afterAnimation:
            f()
        #self.afterAnimation_cb()
        if self.redrawActor:
            vi = self.redrawActor.object
            vi.startAutoRedraw()
예제 #8
0
def test():
    try:
        numZones = int(sys.argv[1])
        numSNodes = int(sys.argv[2])
    except:
        numZones = 2
        numSNodes = 2
    print numZones, numSNodes
    #initialize
    logging.basicConfig(level=logging.DEBUG)
    configs = {
        'max.num.txns.per.storage.node' : 1,
        'nw.latency.within.zone' : ('fixed', 0),
        'nw.latency.cross.zone' : ('fixed', 0),
    }
    groups = {}
    for i in range(numSNodes):
        groups[i] = 128
    configs['dataset.groups'] = groups
    configs['num.zones'] = numZones
    configs['num.storage.nodes.per.zone'] = numSNodes
    initialize()
    RTI.initialize(configs)
    system = BaseSystem(configs)
    #txn generation
    curr = 0
    for i in range(TEST_NUM_TXNS):
        txnID = i
        zoneID = random.randint(0, configs['num.zones'] - 1)
        gid = random.randint(0, numSNodes - 1)
        txn = FakeTxn(txnID, zoneID, gid)
        at = curr + RandInterval.get(
            'expo', TEST_TXN_ARRIVAL_PERIOD / TEST_NUM_TXNS).next()
        curr  = at
        system.schedule(txn, at)
        logging.info('txnID=%s, zoneID=%s, gids=%s at=%s'
                     %(txnID, zoneID, txn.gids, at))
    #start simulation
    system.start()
    simulate(until=2 * TEST_TXN_ARRIVAL_PERIOD)

    #profile
    system.profile()
    #calculate m/m/s loss rate
    lambd = float(TEST_NUM_TXNS) / TEST_TXN_ARRIVAL_PERIOD
    mu = 1 / float(100)
    print erlangLoss(lambd / numZones / numSNodes, mu, 1)
    print erlangLoss(lambd / numZones, mu, numSNodes)
예제 #9
0
def test():
    try:
        numZones = int(sys.argv[1])
        numSNodes = int(sys.argv[2])
    except:
        numZones = 2
        numSNodes = 2
    print numZones, numSNodes
    #initialize
    logging.basicConfig(level=logging.DEBUG)
    configs = {
        'max.num.txns.per.storage.node': 1,
        'nw.latency.within.zone': ('fixed', 0),
        'nw.latency.cross.zone': ('fixed', 0),
    }
    groups = {}
    for i in range(numSNodes):
        groups[i] = 128
    configs['dataset.groups'] = groups
    configs['num.zones'] = numZones
    configs['num.storage.nodes.per.zone'] = numSNodes
    initialize()
    RTI.initialize(configs)
    system = BaseSystem(configs)
    #txn generation
    curr = 0
    for i in range(TEST_NUM_TXNS):
        txnID = i
        zoneID = random.randint(0, configs['num.zones'] - 1)
        gid = random.randint(0, numSNodes - 1)
        txn = FakeTxn(txnID, zoneID, gid)
        at = curr + RandInterval.get(
            'expo', TEST_TXN_ARRIVAL_PERIOD / TEST_NUM_TXNS).next()
        curr = at
        system.schedule(txn, at)
        logging.info('txnID=%s, zoneID=%s, gids=%s at=%s' %
                     (txnID, zoneID, txn.gids, at))
    #start simulation
    system.start()
    simulate(until=2 * TEST_TXN_ARRIVAL_PERIOD)

    #profile
    system.profile()
    #calculate m/m/s loss rate
    lambd = float(TEST_NUM_TXNS) / TEST_TXN_ARRIVAL_PERIOD
    mu = 1 / float(100)
    print erlangLoss(lambd / numZones / numSNodes, mu, 1)
    print erlangLoss(lambd / numZones, mu, numSNodes)
예제 #10
0
def testRTI():
    print '\n>>> testRTI\n'
    configs = {
        'nw.latency.within.zone' : ('uniform', 10, {'lb' : 5, 'ub' : 15}),
        'nw.latency.cross.zone' : ('norm', 100,
                                   {'lb' : 50, 'ub' : 150, 'sigma' : 100}),
    }
    initialize()
    RTI.initialize(configs)
    server0 = Server('zone0/server')
    server1 = Server('zone1/server')
    client = Client('zone0/client', [server0, server1])
    server0.start()
    server1.start()
    client.start()
    simulate(until=1000)
예제 #11
0
def test(nodeadlock=True):
    logging.basicConfig(level=logging.DEBUG)
    initialize()
    tanks = []
    threads = []
    for i in range(NUM_TANKS):
        tank = Tank(i)
        tank.value = TOTAL_FLOW / NUM_TANKS
        tanks.append(tank)
    tanks[0].value += (TOTAL_FLOW - TOTAL_FLOW / NUM_TANKS * NUM_TANKS)
    for i in range(NUM_FLOWERS):
        flow = Flow(i, tanks, nodeadlock)
        flow.start()
        threads.append(flow)
    for i in range(NUM_CHECKERS):
        if i == 0:
            checker = Checker(i, tanks, True)
        elif i == 1:
            checker = Checker(i, tanks, not nodeadlock)
        else:
            checker = Checker(i, tanks, False)
        checker.start()
        threads.append(checker)
    simulate(until=10 * OPERATION_TIME)
    verifyTanks(tanks)
    verifyThreads(threads)
    print 'TEST PASSED'
    print('numFlowTxns=%s, numCheckTxns=%s, numUpFlowTxns=%s' %
          (numFlowTxns, numCheckTxns, numUpFlowTxns))
    print(
        'numAbortedFlowTxns=%s, numAbortedCheckTxns=%s, numAbortedUpFlowTxns=%s'
        % (numAbortedFlowTxns, numAbortedCheckTxns, numAbortedUpFlowTxns))
    for thread in threads:
        runTime, std, histo, count = \
                thread.monitor.getElapsedStats('.*txn')
        waitTime, std, histo, count = \
                thread.monitor.getElapsedStats('.*%s'%LockThread.LOCK_BLOCK_KEY)
        print '%s runtime=%s, waittime=%s' % (thread.ID, runTime, waitTime)
예제 #12
0
def test(nodeadlock=True):
    logging.basicConfig(level=logging.DEBUG)
    initialize()
    tanks = []
    threads = []
    for i in range(NUM_TANKS):
        tank = Tank(i)
        tank.value = TOTAL_FLOW / NUM_TANKS
        tanks.append(tank)
    tanks[0].value += (TOTAL_FLOW - TOTAL_FLOW / NUM_TANKS * NUM_TANKS)
    for i in range(NUM_FLOWERS):
        flow = Flow(i, tanks, nodeadlock)
        flow.start()
        threads.append(flow)
    for i in range(NUM_CHECKERS):
        if i == 0:
            checker = Checker(i, tanks, True)
        elif i == 1:
            checker = Checker(i, tanks, not nodeadlock)
        else:
            checker = Checker(i, tanks, False)
        checker.start()
        threads.append(checker)
    simulate(until=10 * OPERATION_TIME)
    verifyTanks(tanks)
    verifyThreads(threads)
    print 'TEST PASSED'
    print ('numFlowTxns=%s, numCheckTxns=%s, numUpFlowTxns=%s'
           %(numFlowTxns, numCheckTxns, numUpFlowTxns))
    print ('numAbortedFlowTxns=%s, numAbortedCheckTxns=%s, numAbortedUpFlowTxns=%s'
           %(numAbortedFlowTxns, numAbortedCheckTxns, numAbortedUpFlowTxns))
    for thread in threads:
        runTime, std, histo, count = \
                thread.monitor.getElapsedStats('.*txn')
        waitTime, std, histo, count = \
                thread.monitor.getElapsedStats('.*%s'%LockThread.LOCK_BLOCK_KEY)
        print '%s runtime=%s, waittime=%s' %(thread.ID, runTime, waitTime)
예제 #13
0
Q2.defineRouting([M2])

argumentDict={'from':'Q2','to':'E1','safetyStock':70,'consumption':20}
EG=EventGenerator(id="EV", name="ExcessEntitiesMover" ,start=60, interval=60, method=Globals.moveExcess, argumentDict=argumentDict)
G.ObjList=[S,M1,M2,E,Q1,Q2,EG]

initialize()                        #initialize the simulation (SimPy method)
    
for object in G.ObjList:
    object.initialize()

for object in G.ObjList:
    activate(object, object.run())
    
G.maxSimTime=400
simulate(until=G.maxSimTime)    #run the simulation

#carry on the post processing operations for every object in the topology       
for object in G.ObjList:
    object.postProcessing()

ExcelHandler.outputTrace('TRACE')

print "the system produced", E.numOfExits, "parts"
print "the waiting ratio of", M1.objName,  "is", (M1.totalWaitingTime/G.maxSimTime)*100, "%"
print "the waiting ratio of", M2.objName,  "is", (M2.totalWaitingTime/G.maxSimTime)*100, "%"




예제 #14
0
class Federation(Process):

    def fight(self):                # simulate Federation operations
        print('Three %s attempting to escape!' % (target.name))
        while True:
            if random.randint(0, 10) < 2:  # check for hit on player
                target.damage += 1         # hit! increment damage to player
                if target.damage <= 5:     # target survives
                    print('Ha! %s hit! Damage= %i' %
                          (target.name, target.damage))
                else:
                    if (target.lives - 1) == 0:
                        print('No more %s left!' % (target.name))
                    else:
                        print('Now only %i %s left!' % (target.lives - 1,
                                                        target.name))

            yield hold, self, 1


initialize()
gameOver = 100
# create a Player object named "Romulans"
target = Player(lives=3, name='Romulans')
activate(target, target.life())
# create a Federation object
shooter = Federation()
activate(shooter, shooter.fight())
simulate(until=gameOver)
print(target.message)
                          options.profile,
                          options.rate))

    w = Watcher(options.max_wait, options.instance_type, options.latency,
                options.as_period,
                options.as_breach_duration,
                options.as_min_size,
                options.as_max_size,
                options.as_cooldown,
                options.as_lower_threshold,
                options.as_lower_breach_scale_increment,
                options.as_upper_threshold,
                options.as_upper_breach_scale_increment)
    activate(w, w.execute())

    simulate(until=options.duration)
    Server.total()
    Server.total_capacity.observe(len(Server.busy) + len(Server.idle))

    print
    print "server utilization                      :%6.2f%%" % Watcher.cpu_utilization.timeAverage()
    count = 0
    for i, y in itertools.izip(itertools.count(), sorted(Server.time_in_system.yseries())):
        count = i + 1
        if y > 30.0:
            break
    print "percentage of requests served within 30s:%6.2f%%" % (count * 100.0 / (Server.jobs_timed_out + Server.jobs_processed))
    print "percentage timed out (%3d seconds)      :%6.2f%%" % (options.max_wait, Server.jobs_timed_out * 100.00 / (Server.jobs_timed_out + Server.jobs_processed))
    print "server time wasted                      :%6.2f%%" % (Server.server_time_wasted * 100.0 / Server.server_time_used)
    print "mean time in system (seconds)           : %.2f" % Server.time_in_system.mean()
    print "total jobs processed                    : %d" % Server.jobs_processed
예제 #16
0
                tripleft = self.interruptLeft  # time to finish the trip
                self.interruptReset()  # end interrupt state
                reactivate(br, delay=repairduration)  # restart breakdown br
                yield hold, self, repairduration  # delay for repairs
                print('Bus repaired at %s' % now())
            else:
                break  # no more breakdowns, bus finished trip
        print('Bus has arrived at %s' % now())


class Breakdown(Process):
    def __init__(self, myBus):
        Process.__init__(self, name='Breakdown ' + myBus.name)
        self.bus = myBus

    def breakBus(self, interval):  # process execution method
        while True:
            yield hold, self, interval  # breakdown interarrivals
            if self.bus.terminated():
                break
            self.interrupt(self.bus)  # breakdown to myBus


initialize()
b = Bus('Bus')  # create a bus object
activate(b, b.operate(repairduration=20, triplength=1000))
br = Breakdown(b)  # create breakdown br to bus b
activate(br, br.breakBus(300))
simulate(until=4000)
print('SimPy: No more events at time %s' % now())
예제 #17
0
 def __init__(self, epidemic_params):
     """The constructor of the class.
        Full params' list:
         - nr_individuals: number of individuals in the population
         - initial_infects: number of infects at the start of the simulation
         - initial_immunes: number of immunes at the start of the simulation
         - infect_prob: probability of getting infected after a contact with an infect
         - contact_rate: rate of the contact between individuals
         - recover_rate: rate of recover from infection
         - immune_after_recovery: if true, individuals becomes immunes after recovery
         - immunization_vanish_rate: if not zero, immunization is temporary with given rate
         - death_rate: rate of death caused by epidemic
         - newborn_can_be_infect: if true, newborn can be infect
         - newborn_can_be_immune: if true, newborn can be immune
         - newborn_prob: probability that a new individual born after a contact
         - natural_death_prob: probability of death not caused by epidemic
         - run_time: time duration of the simulation
         - debug: show more info about the running simulation
         - process_debug: show more info about SimPy processes during the simulation
         - progress: show a progress indicator during the simulation
         - stats: show some stats at the end of the simulation
         - plot: show a plot representing the evolution of the population at the end of the simulation
     """
     # setting up the epidemic's parameters with metaprogramming
     for param in epidemic_params:
         self.__dict__[param] = epidemic_params.get(param)
     # setting the uninitialized parameters to their default values
     self.check_and_set_default_value(['initial_immunes', 'recover_rate', 'death_rate', 'immunization_vanish_rate', 'newborn_prob', 'natural_death_prob'], ['immune_after_recovery', 'newborn_can_be_immune', 'newborn_can_be_infect', 'debug', 'process_debug', 'progress', 'stats', 'plot'])
     # setting the random number generator using the python standard one
     self.rng = random.Random()
     # checking some features of the model from parameters passed to the constructor
     self.model_has_immunization = self.model_has_immunization()
     self.model_immunization_is_permanent = self.model_immunization_is_permanent()
     self.model_has_recovering = self.model_has_recovering()
     self.model_has_death = self.model_has_death()
     self.model_has_vital_dynamics = self.model_has_vital_dynamics()
     self.model_newborns_always_susceptibles = self.model_newborns_always_susceptibles()
     self.model_has_new_susceptibles = self.model_has_new_susceptibles()
     self.model_has_new_infects = self.model_has_new_infects()
     # initialize the population counters
     self.total_infects = self.initial_infects
     self.total_immunes = self.initial_immunes
     self.total_susceptibles = self.nr_individuals - self.initial_infects - self.initial_immunes
     self.total_newborns = 0
     self.total_natural_deaths = 0
     self.total_deaths = 0
     # setting up the monitors for watching interesting variables
     self.m_suscettibili = Monitor(name="Suscettibili", ylab="suscettibili")
     self.m_suscettibili.append([0, self.total_susceptibles])
     self.m_infetti = Monitor(name="Infetti", ylab='infetti')
     self.m_infetti.append([0, self.initial_infects])
     if self.model_has_immunization:
         self.m_immuni = Monitor(name="Immuni", ylab='immuni')
         self.m_immuni.append([0, self.initial_immunes])
     # setting up the array of all the individuals partecipating to the simulation
     self.all_individuals = []
     # initialize the simulation environment (time, events, ...)
     initialize()
     for i in range(self.nr_individuals):
         # add individuals to the simulation with the specified health_status
         if i >= (self.nr_individuals - self.initial_infects):
             ind = self.Individual(self, ind_id=i, health_status='infect')
         elif i >= (self.nr_individuals - self.initial_infects -
                 self.initial_immunes):
             ind = self.Individual(self, ind_id=i, health_status='immune')
         else:
             ind = self.Individual(self, ind_id=i)
         # activate it with function live()
         activate(ind, ind.live(), at=0.0)
     self.start_time = time.time()
     if self.process_debug:
         self.show_processes_status()
     # start the simulation
     simulate(until=self.run_time)
     self.stop_time = time.time()
     if self.process_debug:
         self.show_processes_status()
     # show final stats if required by params
     if self.stats:
         self.show_stats()
     # show plot if required by params
     if self.plot:
         self.show_plot()
예제 #18
0
파일: model.py 프로젝트: bloodearnest/deal
 def run(self, *a, **kw):
     kw['until'] = kw.get('until', getattr(self, 'runtime', 100))
     self.runtime = kw['until']
     initialize()      
     self.start(*a, **kw)
     simulate(*a, **kw)
예제 #19
0
    interval=60,
    method=Globals.moveExcess,
    argumentDict=argumentDict,
)
G.ObjList = [S, M1, M2, E, Q1, Q2, EG]

initialize()  # initialize the simulation (SimPy method)

for object in G.ObjList:
    object.initialize()

for object in G.ObjList:
    activate(object, object.run())

G.maxSimTime = 400
simulate(until=G.maxSimTime)  # run the simulation

# carry on the post processing operations for every object in the topology
for object in G.ObjList:
    object.postProcessing()

ExcelHandler.outputTrace("TRACE")

print(("the system produced", E.numOfExits, "parts"))
print((
    "the waiting ratio of",
    M1.objName,
    "is",
    (M1.totalWaitingTime / G.maxSimTime) * 100,
    "%",
))
예제 #20
0
            # excess of demand over current stock amount
            if dd > stock.amount:  # can't supply requested amount
                yield get, self, stock, stock.amount
                # supply all available amount
                self.stockout += ds
                # add unsupplied demand to self.stockout
                print('day %6.4f, demand = %6.4f, shortfall = %6.4f' %
                      (now(), dd, -ds))
            else:  # can supply requested amount
                yield get, self, stock, dd
                print('day %6.4f, supplied %6.4f, now amount = %6.4f' %
                      (now(), dd, stock.amount))


stock = Level(monitored=True)  # 'unbounded' capacity and other defaults

seed(99999)
initialize()

offeror = Deliver()
activate(offeror, offeror.deliver())
requester = Demand()
activate(requester, requester.demand())

simulate(until=49.9)

result = (stock.bufferMon.mean(), requester.stockout)
print('')
print('Summary of results through end of day %6.4f:' % int(now()))
print('average stock = %6.4f, cumulative stockout = %6.4f' % result)
예제 #21
0
from SimPy.Simulation import Process, activate, hold, initialize, simulate


class Customer(Process):
    def buy(self, budget=0):
        print('Here I am at the shops %s' % self.name)
        t = 5.0
        for i in range(4):
            yield hold, self, t
            # executed 4 times at intervals of t time units
            print('I just bought something %s' % self.name)
            budget -= 10.00
        print('All I have left is %s I am going home %s' % (budget, self.name))


initialize()

# create a customer named "Evelyn",
C = Customer(name='Evelyn')

# and activate her with a budget of 100
activate(C, C.buy(budget=100), at=10.0)

simulate(until=100.0)
예제 #22
0
def main():

    #create an empty list to store all the objects in
    G.ObjList = []

    #user inputs the id of the JSON file
    topologyId = raw_input("give the path to the CMSD file\n")
    try:
        G.CMSDFile = open(str(topologyId), "r")
    except IOError:
        print "no such file. The programm is terminated"
        sys.exit()

    start = time.time()  #start counting execution time

    #read the input from the CMSD file and create the line
    G.InputData = G.CMSDFile.read()
    G.CMSDData = parseString(G.InputData)
    readGeneralInput()
    readResources()
    readProcessIdentifiersSequence()
    readProcesses()
    setPredecessorIDs()
    setSuccessorIDs()
    setTopology()

    #run the experiment (replications)
    for i in range(G.numberOfReplications):
        print "start run number " + str(i + 1)
        G.seed += 1
        G.Rnd = Random(G.seed)
        initialize()  #initialize the simulation
        initializeObjects()
        activateObjects()
        simulate(until=G.maxSimTime)  #start the simulation

        #carry on the post processing operations for every object in the topology
        for j in range(len(G.ObjList)):
            G.ObjList[j].postProcessing(G.maxSimTime)

        #output trace to excel
        if (G.trace == "Yes"):
            G.traceFile.save('trace' + str(i + 1) + '.xls')
            G.traceIndex = 0  #index that shows in what row we are
            G.sheetIndex = 1  #index that shows in what sheet we are
            G.traceFile = xlwt.Workbook()  #create excel file
            G.traceSheet = G.traceFile.add_sheet(
                'sheet ' + str(G.sheetIndex),
                cell_overwrite_ok=True)  #create excel sheet

    G.outputSheet.write(G.outputIndex, 0, "Execution Time")
    G.outputSheet.write(G.outputIndex, 1,
                        str(time.time() - start) + " seconds")
    G.outputIndex += 2

    #output data to excel for every object in the topology
    for j in range(len(G.ObjList)):
        G.ObjList[j].outputResultsXL(G.maxSimTime)

    G.outputFile.save("output.xls")
    print "execution time=" + str(time.time() - start)
예제 #23
0
                  (now(), [x.weight for x in self.got]))
            yield hold, self, 11


class Widget(Lister):
    def __init__(self, weight=0):
        self.weight = weight


widgbuf = []
for i in range(10):
    widgbuf.append(Widget(5))

initialize()

buf = Store(capacity=11, initialBuffered=widgbuf, monitored=True)

for i in range(3):  # define and activate 3 producer objects
    p = ProducerD()
    activate(p, p.produce())

for i in range(3):  # define and activate 3 consumer objects
    c = ConsumerD()
    activate(c, c.consume())

simulate(until=50)

print('LenBuffer: %s' % buf.bufferMon)  # length of buffer
print('getQ: %s' % buf.getQMon)  # length of getQ
print('putQ %s' % buf.putQMon)  # length of putQ
예제 #24
0
def main():
    initialize()
    testAlarm()
    testThread()
    simulate(until=1000)
    testTanjanAlgo()
예제 #25
0
from SimPy.Simulation import Process, activate, initialize, hold, now, simulate


class Message(Process):
    """A simple Process"""

    def __init__(self, i, len):
        Process.__init__(self, name='Message' + str(i))
        self.i = i
        self.len = len

    def go(self):
        print('%s %s %s' % (now(), self.i, 'Starting'))
        yield hold, self, 100.0
        print('%s %s %s' % (now(), self.i, 'Arrived'))


initialize()
p1 = Message(1, 203)   # new message
activate(p1, p1.go())  # activate it
p2 = Message(2, 33)
activate(p2, p2.go(), at=6.0)
simulate(until=200)
print('Current time is %s' % now())  # will print 106.0
예제 #26
0
        print('%s car %s done by %s' % (now(), self.name, whichWash))


class CarGenerator(Process):
    def generate(self):
        i = 0
        while True:
            yield hold, self, 2
            c = Car('%d' % i)
            activate(c, c.lifecycle())
            i += 1


washtime = 5
initialize()

# put four cars into the queue of waiting cars
for j in range(1, 5):
    c = Car(name='%d' % -j)
    activate(c, c.lifecycle())

waitingCars = Store(capacity=40)
for i in range(2):
    cw = Carwash('Carwash %s' % i)
    activate(cw, cw.lifecycle())

cg = CarGenerator()
activate(cg, cg.generate())
simulate(until=30)
print('waitingCars %s' % [x.name for x in waitingCars.theBuffer])