Exemple #1
0
 def generate(self, number, interval):
     rv = Random(self.SEED)
     for i in range(number):
         c = Customer(name="Customer%02d" % (i,))
         Simulation.activate(c, c.visit(timeInBank=12.0))
         t = rv.expovariate(1.0 / interval)
         yield Simulation.hold, self, t
def model():
    Simulation.initialize()
    c1 = Customer(name="Klaus")
    Simulation.activate(c1, c1.visit(timeInBank=10.0), delay=5.0)
    c2 = Customer(name="Tony")
    Simulation.activate(c2, c2.visit(timeInBank=8.0), delay=2.0)
    c3 = Customer(name="Evelyn")
    Simulation.activate(c3, c3.visit(timeInBank=20.0), delay=12.0)
    Simulation.simulate(until=400.0)
Exemple #3
0
 def visit(self, timeInBank=0):
     arrive = Simulation.now()
     print("%7.4f %s: Here I am " % (Simulation.now(), self.name))
     yield Simulation.request, self, counter
     wait = Simulation.now() - arrive
     print("%7.4f %s: Waited %6.3f" % (Simulation.now(),
                                       self.name, wait))
     tib = counterRV.expovariate(1.0 / timeInBank)
     yield Simulation.hold, self, tib
     yield Simulation.release, self, counter
     print("%7.4f %s: Finished" % (Simulation.now(), self.name))
Exemple #4
0
def pytest_funcarg__sim(request):
    if request.param == 'default':
        return Simulation.Simulation()
    elif request.param == 'step':
        return SimulationStep.SimulationStep()
    elif request.param == 'trace':
        return SimulationTrace.SimulationTrace()
    elif request.param == 'rt':
        return SimulationRT.SimulationRT()
    elif request.param.startswith('global'):
        if request.param.endswith('default'):
            Globals.sim = Simulation.Simulation()
        elif request.param.endswith('step'):
            Globals.sim = SimulationStep.SimulationStep()
        elif request.param.endswith('trace'):
            Globals.sim = SimulationTrace.SimulationTrace()
        elif request.param.endswith('rt'):
            Globals.sim = SimulationRT.SimulationRT()
        return Globals.sim
Exemple #5
0
def model(counterseed=3939393):
    global counter, counterRV
    counter = Simulation.Resource(name="Clerk", capacity=2)  # Lcapacity
    counterRV = Random(counterseed)
    Simulation.initialize()
    sourceseed = 1133
    source = Source(seed=sourceseed)
    Simulation.activate(source, source.generate(5, 10.0), 0.0)
    Simulation.simulate(until=400.0)
Exemple #6
0
    neuron_producing = Neuron('inhibitory', i, in_settings, 'off')
    if inhi == 'on':
        inhibitory.append(neuron_producing)
        for inhibitee in random.sample(excitatory_a+excitatory_b, 20):
            inhibitee.connect(neuron_producing)
            neuron_producing.connect(inhibitee)


all_neuron = excitatory_a + excitatory_b + inhibitory + downstream + noise
duration = 2400


for i in range(duration):
    for neuron in all_neuron:
        event = Event(name = 'update')
        simpy.activate(event, event.update(neuron), delay = i)
print("simulation scheduled.")

simpy.simulate(until = duration+0.0)
print("simulation done.")

#ex_spikes_number = 0.0
#for i in excitatory_a+excitatory_b:
    #ex_spikes_number += i.spikes_number

#ds_spikes_number = 0.0
#for i in downstream:
    #ds_spikes_number += i.spikes_number

#print ds_spikes_number/ex_spikes_number
 def visit(self, timeInBank=0):
     print("%7.4f %s: Here I am" % (Simulation.now(), self.name))
     yield Simulation.hold, self, timeInBank
     print("%7.4f %s: I must leave" % (Simulation.now(), self.name))
Exemple #8
0
	def go(self):
		print("{0} {1} Starting".format(sim.now(), self.name))
		yield sim.hold, self, 100.0
		print("{0} {1} Arrived".format(sim.now(), self.name))
Exemple #9
0
sim1.py

Created by Jakub Konka on 2011-04-20.
Copyright (c) 2011 University of Strathclyde. All rights reserved.
"""

import sys
import os
import SimPy.SimulationTrace as sim

class Car(sim.Process):
	def __init__(self, name, cc):
		sim.Process.__init__(self, name=name)
		self.cc = cc
		
	def go(self):
		print("{0} {1} Starting".format(sim.now(), self.name))
		yield sim.hold, self, 100.0
		print("{0} {1} Arrived".format(sim.now(), self.name))


if __name__ == '__main__':
	sim.initialize()
	car1 = Car("Car1", 2000)
	sim.activate(car1, car1.go(), at=6.0)
	car2 = Car("Car2", 1600)
	sim.activate(car2, car2.go())
	sim.simulate(until=200)
	print("Current time is {0}".format(sim.now()))

Exemple #10
0
class Client(Simulation.Process):
    def __init__(self, name):
        Simulation.Process.__init__(self, name)

    def getServed(self, tank):
        yield (Simulation.get, self, tank, 10), (Simulation.hold, self, 1.5)
        if self.acquired(tank):
            print("%s got 10 %s" % (self.name, tank.unitName))
        else:
            print("%s reneged" % self.name)


class Filler(Simulation.Process):
    def __init__(self, name):
        Simulation.Process.__init__(self, name)

    def fill(self, tank):
        for i in range(3):
            yield Simulation.hold, self, 1
            yield Simulation.put, self, tank, 10


Simulation.initialize()
tank = Simulation.Level(name="Tank", unitName="gallons")
for i in range(2):
    c = Client("Client %s" % i)
    Simulation.activate(c, c.getServed(tank))
f = Filler("Tanker")
Simulation.activate(f, f.fill(tank))
Simulation.simulate(until=10)
if __name__ == "__main__":
    import random as r
    r.seed(1234567)

    class Test(Process):
        def run(self):
            while self.sim.now() < until:
                yield hold, self, r.uniform(1, 10)

    class Waiter(Process):
        def run(self, evt):
            def gt30():
                return self.sim.now() > 30

            yield waituntil, self, gt30
            print("now() is past 30")
            self.sim.stopSimulation()

    until = 100
    s = SimulationTrace()
    s.initialize()
    evt = SimEvent(sim=s)
    t = Test("Test1", sim=s)
    s.activate(t, t.run())
    t2 = Test("Test2", sim=s)
    s.activate(t2, t2.run())
    w = Waiter("Waiter", sim=s)
    s.activate(w, w.run(evt=evt))
    stepper(whichsim=s)
        Simulation.trace.ttext("<%s> has arrived" % self.name)


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

    def breakBus(self, interval):

        while True:
            Simulation.trace.ttext("Breakdown process waiting for %s" %
                                   interval)
            yield Simulation.hold, self, interval
            if self.bus.terminated():
                break
            Simulation.trace.ttext("Breakdown of %s" % self.bus.name)
            self.interrupt(self.bus)


print("\n\n+++test_interrupt")
Simulation.initialize()
b = Bus("Bus 1")
Simulation.trace.ttext("Start %s" % b.name)
Simulation.activate(b, b.operate(repairduration=20))
br = Breakdown(b)
Simulation.trace.ttext("Start the Breakdown process for %s" % b.name)
Simulation.activate(br, br.breakBus(200))
Simulation.trace.start = 100
print(Simulation.simulate(until=4000))
Exemple #13
0
if __name__ == "__main__":
    import random as r
    r.seed(1234567)

    class Test(Process):
        def run(self):
            while self.sim.now() < until:
                yield hold,self,r.uniform(1,10)

    class Waiter(Process):
        def run(self,evt):
            def gt30():
                return self.sim.now() > 30

            yield waituntil,self,gt30
            print("now() is past 30")
            self.sim.stopSimulation()

    until = 100
    s = SimulationTrace()
    s.initialize()
    evt = SimEvent(sim=s)
    t=Test("Test1", sim=s)
    s.activate(t,t.run())
    t2=Test("Test2", sim=s)
    s.activate(t2,t2.run())
    w=Waiter("Waiter", sim=s)
    s.activate(w,w.run(evt=evt))
    stepper(whichsim=s)
Exemple #14
0
import unittest

if __debug__:
    import SimPy.SimulationTrace as Sim
else:
    import SimPy.Simulation as Sim

import pyprt.sim.layout as layout
import pyprt.sim.vehicle as vehicle

Sim.initialize()


class StationTest(unittest.TestCase):
    def setUp(self):
        self.s = layout.Station(ID=1,
                                length=68,
                                max_speed=100,
                                x=0,
                                y=0,
                                label='',
                                v_adv_time=0.5,
                                unload_size=3,
                                queue_size=3,
                                load_size=3,
                                storage_size=5,
                                policy='QUEUE')

    def test_advance_queue_no_vehicles(self):
        # No vehicles, no change
        q = self.s.queue