Example #1
0
def schedule_paper_drop(obj, contact_type, reminder_type, delay):

    # add to summary of paper given out
    if reminder_type == 'pq' and oo.record_paper_summary:

        for key, value in obj.rep.paper_summary.items():
            value[str(getattr(obj,
                              key))][math.floor(obj.rep.env.now / 24)] += 1

        for key, value in obj.rep.paper_totals.items():
            value[str(getattr(obj, key))] += 1

    output_type = contact_type + "_" + reminder_type + "_posted"  # use this as output key

    if oo.record_posted:
        obj.rep.output_data[output_type].append(
            oo.generic_output(obj.rep.reps, obj.district.district, obj.la,
                              obj.lsoa, obj.digital, obj.hh_type, obj.hh_id,
                              obj.env.now))

    if delay > 0:
        start_delayed(obj.env, obj.receive_reminder(reminder_type), delay)
    else:
        obj.env.process(obj.receive_reminder(reminder_type))

    yield obj.env.timeout(0)
Example #2
0
def light():
    """
   This generator function simulates state changes of the traffic light.  For
   simplicity, the light is either green or red--there is no yellow state.
   """
    global env, light

    while True:

        # Section 4.2.1: Change the light to green.

        light = 'green'
        print("\nThe light turned green at time %.3f." % env.now)

        # If there are cars in the queue, schedule a departure event:
        if len(queue):

            # Generate departure delay as a random draw from triangular
            # distribution:
            delay = random.triangular(left=t_depart_left,
                                      mode=t_depart_mode,
                                      right=t_depart_right)

            start_delayed(env, departure(), delay=delay)

        # Schedule event that will turn the light red:
        yield env.timeout(t_green)

        # Section 4.2.2: Change the light to red.
        light = 'red'
        print("\nThe light turned red at time %.3f." % env.now)

        # Schedule event that will turn the light green:
        yield env.timeout(t_red)
Example #3
0
def test_start_delayed(env):
    def pem(env):
        assert env.now == 5
        yield env.timeout(1)

    start_delayed(env, pem(env), delay=5)
    env.run()
Example #4
0
def test_start_delayed(env):
    def pem(env):
        assert env.now == 5
        yield env.timeout(1)

    start_delayed(env, pem(env), delay=5)
    env.run()
Example #5
0
 def message(self,
             source,
             dest,
             message_size,
             start_time,
             id=None,
             method=None,
             sync=True,
             packet_stats=False):
     if start_time == 0:
         self.env.process(
             self.send(source,
                       dest,
                       message_size,
                       id=id,
                       method=method,
                       sync=sync,
                       packet_stats=packet_stats))
     else:
         start_delayed(
             self.env,
             self.send(route,
                       message_size,
                       id=id,
                       method=method,
                       sync=sync,
                       packet_stats=packet_stats), start_time)
Example #6
0
 def __init__(self, env, events):
     self.events = events
     self.assistant = simpy.Resource(env, CAPACITY)
     self.requestCount = 0
     self.toRecord = False
     i = 0
     for e in self.events:
         i += 1
         start_delayed(env, self.accident(env, i), e)
Example #7
0
 def runBq(self, with_preempt):
     self.process = self.env.process(self.runBqHelper(with_preempt))
     start_delayed(self.env, self.inject_failure(), INITIAL_FAILURE_DELAY)
     self.env.process(self.monitorWorkDone())
     self.savedJobs = self.allJobs[:]
     while True:
         try:
             yield self.process
             self.env.exit()
         except simpy.Interrupt as e:
             self.process.interrupt(e.cause)
Example #8
0
	def cloudletSpaceShared(self):
		
		for cloudlet in self._resourceList:
				
			cloudlet._processingTime = cloudlet._cloudletLength/(cloudlet._numberOfPes*cloudlet.vm.mips) 
			cloudlet._remainingTime = cloudlet._processingTime

			if cloudlet.submissionTime == 0:
				self._context.process(cloudlet._process(self._context))
				cloudlet.status = 1
			else:
				start_delayed(self._context,cloudlet._process(self._context),cloudlet._submissionTime)
				cloudlet.status = 1
Example #9
0
    def load_schedule(self, regular_sche, extra_sche):
        # schedule personel shifts
        t = tu.time_sec("2015-12-14 00:00:00")
        prev = 0
        for i in range(77):
            for day in regular_sche:
                for h in day:
                    delta = h - prev
                    if delta > 0:
                        for j in range(delta):
                            start_delayed(self.env, self.assistent_join(),
                                          t - self.zeroTime)
                            prev += 1
                    if delta < 0:
                        for j in range(-delta):
                            start_delayed(self.env, self.assistent_leave(),
                                          t - self.zeroTime)
                            prev -= 1
                    t += 3600

        for e in extra_sche:
            t = tu.time_sec(e[0] + " 00:00:00")
            for i in range(e[1]):
                start_delayed(self.env, self.assistent_join(),
                              t - self.zeroTime)
            t = tu.time_sec(e[0] + " 23:59:59")
            for i in range(e[1]):
                start_delayed(self.env, self.assistent_leave(),
                              t - self.zeroTime)

        self.extraEvents = len(extra_sche)
        self.regular_sche = regular_sche
Example #10
0
 def __init__(self, env, events, capacity=2):
     self.CAPACITY = capacity
     self.events = events
     self.assistant = simpy.Resource(env, self.CAPACITY)
     self.requestCount = 0
     self.toRecord = False
     # move just before the first event
     zeroTime = self.events[0] - 1
     env.run(zeroTime)
     i = 0
     for evnt in self.events:
         i += 1
         start_delayed(env, self.accident(env, Call(evnt, i)),
                       evnt - zeroTime)
Example #11
0
    def __init__(self, env, rep, district, input_data, letter_type):

        self.env = env
        self.rep = rep
        self.district = district
        self.input_data = input_data
        self.letter_type = letter_type

        self.blanket = h.str2bool(self.input_data["blanket"])
        self.targets = self.input_data["targets"]
        self.start_sim_time = h.get_event_time(self)
        self.period = self.input_data["period"]
        # add process to decide who to send letters too...but with a delay

        start_delayed(self.env, self.fu_letter(), self.start_sim_time)
Example #12
0
    def cloudletSpaceShared(self):

        for cloudlet in self._resourceList:

            cloudlet._processingTime = cloudlet._cloudletLength / (
                cloudlet._numberOfPes * cloudlet.vm.mips)
            cloudlet._remainingTime = cloudlet._processingTime

            if cloudlet.submissionTime == 0:
                self._context.process(cloudlet._process(self._context))
                cloudlet.status = 1
            else:
                start_delayed(self._context, cloudlet._process(self._context),
                              cloudlet._submissionTime)
                cloudlet.status = 1
Example #13
0
    def __init__(self, env: simpy.Environment, name):
        self.name = name
        self.light_vertical = True
        self.queue_W = deque()
        self.queue_N = deque()
        self.queue_E = deque()
        self.queue_S = deque()
        self.env = env

        if not manual:
            self.action = env.process(self.run())

        # Schedule first arrival of a car:
        t_first_arrival = np.random.exponential(t_interarrival_mean)
        start_delayed(env, self.arrival(), delay=t_first_arrival)
Example #14
0
def start():
   global env

   while True:

      # If there are cars in the queue, schedule a departure event:
      if len(q1) or len(q2) or len(q3) or len(q4):

         # Generate departure delay as a random draw from triangular
         # distribution:
         delay= random.triangular(left=t_depart_left, mode=t_depart_mode,
           right=t_depart_right)

         start_delayed(env, departure(), delay=delay)
      yield env.timeout(t_green)
      yield env.timeout(t_red)
def light():
   """
   Simulates state changes of the traffic light.
   """
   global env, light
   while True:
      light= 'green'
      print("\nThe light turned green at time %.3f." % env.now)
      if len(queue):
         delay= random.triangular(left=t_depart_left, mode=t_depart_mode,
           right=t_depart_right)
         start_delayed(env, departure(), delay=delay)
      yield env.timeout(t_green)
      light= 'red'
      print("\nThe light turned red at time %.3f."   % env.now)
      yield env.timeout(t_red)
def parent(env):
    print(f'parent start at {env.now}')
    sub_proc = yield start_delayed(
        env, sub(env), delay=3)  # delay 3 unit time, then call sub(env)
    print(f'sub_proc start at {env.now}')
    ret = yield sub_proc  # this yield is necessary to get the sub(env) return
    print(f'parent ret start at {env.now} ret={ret}')
    return ret
Example #17
0
    def switchAndDepart(self):
        """
        This generator function simulates state changes of the traffic light.  For
        simplicity, the light is either green or red--there is no yellow state.
        """

        # Section 4.2.1: Change the light to green.

        self.switch_light()

        # If there are cars in the queue, schedule a departure event:
        if self.light_vertical:
            if len(self.queue_W):
                # Generate departure delay as a random draw from triangular
                # distribution:
                delay = np.random.triangular(left=t_depart_left,
                                             mode=t_depart_mode,
                                             right=t_depart_right)

                start_delayed(self.env,
                              self.departure(self.queue_W),
                              delay=delay)
            if len(self.queue_E):
                # Generate departure delay as a random draw from triangular
                # distribution:
                delay = np.random.triangular(left=t_depart_left,
                                             mode=t_depart_mode,
                                             right=t_depart_right)

                start_delayed(self.env,
                              self.departure(self.queue_E),
                              delay=delay)
        else:
            if len(self.queue_N):
                # Generate departure delay as a random draw from triangular
                # distribution:
                delay = np.random.triangular(left=t_depart_left,
                                             mode=t_depart_mode,
                                             right=t_depart_right)

                start_delayed(self.env,
                              self.departure(self.queue_N),
                              delay=delay)

            if len(self.queue_S):
                # Generate departure delay as a random draw from triangular
                # distribution:
                delay = np.random.triangular(left=t_depart_left,
                                             mode=t_depart_mode,
                                             right=t_depart_right)

                start_delayed(self.env,
                              self.departure(self.queue_S),
                              delay=delay)
Example #18
0
    def respond(self, delay=0):
        """represents the hh responding - not the return being received by census"""

        if self.responded is False:

            self.responded = True
            self.resp_time = self.env.now
            # add to hh response event log

            self.output_data['Respond'].append(response(self.rep.reps,
                                                        self.district.input_data["LA"],
                                                        self.digital,
                                                        self.hh_type,
                                                        self.resp_time))

            if self.delay == 0:  # digital
                self.env.process(censusv2.ret_rec(self, self.rep))
            else:  # paper
                start_delayed(self.env, censusv2.ret_rec(self, self.rep), delay)

            yield self.env.timeout((self.rep.sim_hours) - self.env.now)  # hh does no more (without intervention)
Example #19
0
    def __init__(self, filename, qos=20):
        self.env = simpy.Environment()
        self.capacity = 1
        self.assistant = simpy.Container(self.env, 100, self.capacity)
        self.requestCount = 0
        self.waitAgg = 0
        self.count = 0
        self.qos = qos
        self.aboveQos = 0
        self.sim_data = []
        self.extraEvents = 0
        self.events = CallCenter.load_events(filename)
        self.regular_sche = None

        # schedule calls
        # move just before the first event (operator in service is the first event - before the first call)
        self.zeroTime = tu.time_sec("2015-12-14 00:00:00") - 1
        self.env.run(self.zeroTime)
        i = 0
        for evnt in self.events:
            i += 1
            start_delayed(self.env, self.accident(self.env, Call(evnt, i)),
                          evnt - self.zeroTime)
def simular_turnoscapacidad(cantCajas, tiempoCaja, cantServidores, cantAsientos, tiempoCocina, cantMenus, cantCajasTarjeta, cantCapacidad):

    mes={2 : "FEBRERO", 3: "MARZO", 4: "ABRIL", 5: "MAYO", 6:"JUNIO", 7:"JULIO", 8:"AGOSTO",9:"SEPTIEMBRE",10:"OCTUBRE",11:"NOVIEMBRE", 12:"DICIEMBRE"}

    TOTAL=0

    tiempoCocina=tiempoCocina*60
    tiempoCaja=tiempoCaja*60

    for i in range(2,13):
        d = pd.read_csv("data/CSVs/tablas_simulacion/{}.csv".format(mes[i]), sep =",")
        dato = d.transpose()

        TOTAL11 = dato.loc['11'].sum()
        TOTAL12 = dato.loc['12'].sum()
        TOTAL13 = dato.loc['13'].sum()
        TOTAL14 = dato.loc['14'].sum()

        INTERVALTURNO11 =  (3600 / TOTAL11)
        INTERVALTURNO12 = (3600 / TOTAL12)
        INTERVALTURNO13 = (3600 / TOTAL13)
        INTERVALTURNO14 = (3600 / TOTAL14)

        TOTAL+=TOTAL11+TOTAL12+TOTAL13+TOTAL14

        random.seed(RANDOM_SEED)
        env = simpy.Environment()

        automatic_clerk= MonitoredResource("automatic clerk", env, capacity=cantCajasTarjeta)
        clerk = MonitoredResource("clerk", env, capacity=cantCajas)  # pasar de 2 a 3 cajas mejora muchisimo
        seats = MonitoredResource("seats", env, capacity=cantAsientos)
        server = MonitoredResource("server", env, capacity=cantServidores*2)
        delivery = simpy.Container(env, capacity=150)
        pase=simpy.Container(env, capacity=cantCapacidad)


        env.process(student_capacity_generator(env, 11, "", TOTAL11, INTERVALTURNO11, clerk, automatic_clerk, server, delivery, seats, tiempoCaja, pase, i))

        start_delayed(env, student_capacity_generator(env, 12, "", TOTAL12, INTERVALTURNO12, clerk, automatic_clerk, server, delivery, seats, tiempoCaja, pase, i), 3600)

        start_delayed(env, student_capacity_generator(env, 13, "", TOTAL13, INTERVALTURNO13, clerk, automatic_clerk, server, delivery, seats, tiempoCaja, pase, i), 7200)

        start_delayed(env, student_capacity_generator(env, 14, "", TOTAL14, INTERVALTURNO14, clerk, automatic_clerk, server, delivery, seats, tiempoCaja, pase, i), 10800)

        env.process(door(env,pase,cantCapacidad))
        env.process(kitchen(env, delivery, cantMenus, tiempoCocina))
        env.run(until=25200)

        # name | month | facultad | start_time | end_time | clerk_queue | automatic_clerk_queue | delivery_queue | seating_queue | total_waiting_time | activity_time
        df = None
        df = pd.DataFrame(dataframe, columns=['name', 'turno', 'month', 'facultad', 'start_time', 'end_time', 'clerk_queue', 'automatic_clerk_queue','delivery_queue',
                                              'seating_queue', 'total_waiting_time', 'activity_time'])

        resources.extend([clerk, automatic_clerk, server, seats])

    return df
Example #21
0
    def household_returns(self, delay=0):
        """represents the hh returning their form - not the return being counted as a response by census"""

        if not self.return_sent:

            self.return_sent = True
            self.resp_time = self.env.now
            # add to hh response event log
            if oo.record_return_sent:
                self.output_data['Return_sent'].append(oo.generic_output(self.rep.reps,
                                                                         self.district.district,
                                                                         self.la,
                                                                         self.lsoa,
                                                                         self.digital,
                                                                         self.hh_type,
                                                                         self.hh_id,
                                                                         self.resp_time))

            if self.calc_delay() == 0:  # digital
                self.env.process(hq.ret_rec(self, self.rep))
            else:  # paper
                start_delayed(self.env, hq.ret_rec(self, self.rep), delay)

            yield self.env.timeout(0)  # hh does no more (without intervention)
Example #22
0
    def __init__(self, rep, env, district, input_data, co_id):

        self.rep = rep
        self.env = env
        self.district = district
        self.input_data = input_data
        self.co_id = co_id

        self.rnd = self.rep.rnd
        self.action_plan = []
        self.start_date = dt.datetime.strptime((self.input_data['start_date']),
                                               '%Y, %m, %d').date()
        self.end_date = dt.datetime.strptime((self.input_data['end_date']),
                                             '%Y, %m, %d').date()
        self.has_pq = h.str2bool(self.input_data['has_pq'])
        self.has_postcard = h.str2bool(self.input_data['has_postcard'])
        self.start_sim_time = h.get_entity_time(
            self)  # self.co_start_time()  # the sim time the co starts work
        self.end_sim_time = h.get_entity_time(
            self, "end")  # self.co_end_time()  # the sim time the co ends work

        self.active_time = []  # as above but for active time
        # start work at correct time
        start_delayed(self.env, self.co_working_test(), self.start_sim_time)
def parent(env):
    sub_proc = yield start_delayed(env, sub(env), delay=3)
    ret = yield sub_proc
    return ret
Example #24
0
  return e.between_green(count)

  

print("\nSimulation of Cars Arriving at Intersection Controlled by a Traffic "
  "Light\n\n")

# Initialize environment:
env= simpy.Environment()

# Schedule first change of the traffic light:
env.process(light())

# Schedule first arrival of a car:
t_first_arrival= random.exponential(t_interarrival_mean)
start_delayed(env, arrival(), delay=t_first_arrival)

# Schedule first statistical monitoring event:
env.process(monitor())

# Let the simulation run for specified time:
env.run(until=end_time)

e.save_model()

# Section 6: Report statistics.

print("\n\n      *** Statistics ***\n\n")

print("Mean number of cars waiting: %.3f"
  % (Q_stats.cars_waiting / float(Q_stats.count)))
Example #25
0
 def delayed_exec(self, delay, func, *args, **kwargs):
     func = ensure_generator(self.env, func, *args, **kwargs)
     start_delayed(self.env, func, delay=delay)
# 3 - Coupon cost
# 4 - orders that took more than 2 hours to deliver

print("Policy %s:" % (POLICY))

#### MAIN LOOP
week = 1
while week < 101:
    #### Set simulation environment
    env = simpy.Environment()
    drone_company = DroneCompany(env)

    ############################## Rate changes schedule ############################################
    for i in range(0, 5):
        mult = i * 24
        start_delayed(env, drone_company.changeRate(1), ((5 + mult) * 60))
        start_delayed(env, drone_company.changeRate(2), (10 + mult) * (60))
        start_delayed(env, drone_company.changeRate(3), (16 + mult) * (60))
        if i != 4:
            start_delayed(env, drone_company.changeRate(4), (22 + mult) * (60))
        else:
            start_delayed(env, drone_company.changeRate(5), (22 + mult) * 60)
    ############################## Rate changes schedule ############################################

    env.process(ordersArrival(env, drone_company))
    env.run()  # the simulation will run until all orders have been processed.

    # calculate how much days, hours and minutes the simulation was running.
    days = np.floor(env.now / (60 * 24))
    hours = np.floor((env.now / 60) - (days * 24))
    minutes = ((env.now / 60) - (days * 24) - hours) * 60
Example #27
0
    def start_fu(self):

        hh_list = sorted(list(self.input_data['households'].keys()))
        delay = min([self.input_data['households'][hh]['FU_start_time'] for hh in hh_list])
        start_delayed(self.env, censusv2.start_fu(self.env, self), delay)
        last_return_count = returned_books_count
        last_return_time = books_return_time

        daily_return_times.append(
            today_return_time / (today_return_count * ONE_DAY) if today_return_count > 0 else 0)

        daily_lost_patience.append(lost_patience_counts - last_lost_patience)
        last_lost_patience = lost_patience_counts

        yield env.timeout(ONE_DAY)


# Process for random addition of books
env.process(book_generator(env, available_books, book_names))

start_delayed(env, dailyReporter(env), delay=ONE_DAY - 1)

print("Starting simulation")
env.run(until=RUN_DURATION)
print("Simulation completed")

sns.set(style="darkgrid")
df = pd.DataFrame({
    'time': np.arange(RUN_DURATION//ONE_DAY),
    'total books': daily_total_book_counts,
    'borrowed_books': daily_borrowed_counts,
    'Average return times': daily_return_times,
    'Daily patience lost': daily_lost_patience})

print(df[:15])
Example #29
0
def parent(env):
    # Pay attention to the additional yield needed for the helper process.
    sub_proc = yield start_delayed(env, sub(env), delay=3)
    ret = yield sub_proc
    print(ret, env.now)
    return ret
Example #30
0
    def __init__(self, env, events, capacity=2, qos=20):
        self.CAPACITY = capacity
        self.events = events
        self.assistant = simpy.Container(env, 100,self.CAPACITY)
        self.requestCount = 0
        self.toRecord = False
        self.waitAgg = 0
        self.count = 0
        self.qos = qos
        self.aboveQos = 0

        #schedule calls
        # move just before the first event
        zeroTime = self.events[0] - 1
        env.run(zeroTime)
        i = 0
        for evnt in self.events:
            i += 1
            start_delayed(env, self.accident(env, Call(evnt, i)), evnt - zeroTime)

        #schedule personel shifts
        endTime = self.events[-1]
        t = tu.time("2015-12-14 00:00:00")
        while tu.sec(t) < endTime:
            # mon-fri +1, 10-19
            for i in range(5):
                t = tu.plusHours(t,9)
                start_delayed(env, self.assistent_join(env), tu.sec(t) - zeroTime)

                t = tu.plusHours(t,1)
                #one more mon - fri, 10-14
                start_delayed(env, self.assistent_join(env), tu.sec(t) - zeroTime)
                t = tu.plusHours(t,4)
                start_delayed(env, self.assistent_leave(env), tu.sec(t) - zeroTime)

                t = tu.plusHours(t,5)
                start_delayed(env, self.assistent_leave(env), tu.sec(t) - zeroTime)
                t = tu.plusHours(t,5)

            # sat-sun +1, 10-18
            for i in range(2):
                t = tu.plusHours(t,10)
                start_delayed(env, self.assistent_join(env), tu.sec(t) - zeroTime)
                t = tu.plusHours(t,9)
                start_delayed(env, self.assistent_leave(env), tu.sec(t) - zeroTime)
                t = tu.plusHours(t,5)

random.seed([1, 2, 3])

TOTAL_TIME = 300.0
ARRIVAL_RATE = 0.2
t_green= 30.0; t_red= 40.0
t_depart_left= 1.6; t_depart_mode= 2.0; t_depart_right= 2.4
queue= deque()
arrival_count= departure_count= 0

Q_stats= Struct(count=0, cars_waiting=0)
W_stats= Struct(count=0, waiting_time=0.0)

# Run the simulation
print("\nSimulation started!\n\n")

env= simpy.Environment()
env.process(light())
start_delayed(env, arrival(), delay=random.exponential(1.0 / ARRIVAL_RATE))
env.process(monitor())
env.run(until=TOTAL_TIME)

# Report statistics.
print("\n\n ======== Statistics =======\n\n")
print("Mean number of cars waiting: %.3f"
  % (Q_stats.cars_waiting / float(Q_stats.count)))
print("Mean waiting time (seconds): %.3f"
  % (W_stats.waiting_time / float(W_stats.count)))

import math
import simpy
from simpy.util import start_delayed

from environment import ForwardableRealtimeEnvironment

from systems.producers import CogenerationUnit, PeakLoadBoiler
from systems.storages import HeatStorage, ElectricalInfeed
from systems.consumers import ThermalConsumer, ElectricalConsumer

# initialize real-time environment
env = ForwardableRealtimeEnvironment(
    initial_time=0, factor=1.0/3600.0, strict=False)

# initialize power systems
heat_storage = HeatStorage(env=env)
electrical_infeed = ElectricalInfeed()
cu = CogenerationUnit(env=env, heat_storage=heat_storage, electrical_infeed=electrical_infeed)
plb = PeakLoadBoiler(env=env, heat_storage=heat_storage)
thermal_consumer = ThermalConsumer(env=env, heat_storage=heat_storage)
electrical_consumer = ElectricalConsumer(env=env, electrical_infeed=electrical_infeed)

# add power system to simulation environment
env.process(thermal_consumer.update())
env.process(electrical_consumer.update())
env.process(cu.update())

# start plb 10h after simulation start
start_delayed(env, plb.update(), 10 * 3600)
    def checkin_book(self, book):
        '''
        Process function to check in a book
        
        PARAMETERS:-
            book (Book object) : The book to be returned
        '''
        # global LOGS_ENABLED
        if(LOGS_ENABLED):
            print("Day %03d Student %s is reading %s" %
                  (self.env.now//ONE_DAY, self.name, book.name))
        reading_time = random.normalvariate(BOOKS_RETURN_MEAN, BOOKS_RETURN_SD)
        if(reading_time < ONE_HOUR):  # Reading time is dependent on a random normal distribution
            reading_time = ONE_HOUR
        yield self.env.timeout(reading_time)

        if((env.now % ONE_DAY) < OPENING_TIME):  # If Library is not yet open
            yield self.env.timeout(random.uniform(OPENING_TIME, CLOSING_TIME) - self.env.now % ONE_DAY)
        elif((self.env.now % ONE_DAY) > CLOSING_TIME):  # Library is closed
            yield self.env.timeout(ONE_DAY + (random.uniform(OPENING_TIME, CLOSING_TIME)) - self.env.now % ONE_DAY)
        if(self.env.now % ONE_WEEK >= SUNDAY):  # It's sunday!
            yield env.timeout(ONE_DAY + random.uniform(OPENING_TIME, CLOSING_TIME) - self.env.now % ONE_DAY)

        if(LOGS_ENABLED):
            print("Day %03d Student %s is returning %s" %
                  (self.env.now//ONE_DAY, self.name, book.name))
        book.status = Status.RETURNING
        # Checking if book is lost
        with counter.request() as req:
            # Wait for counter to be free or until patience runs out
            results = yield req | env.timeout(self.patience)
            if(req not in results):  # We lost patience
                if(LOGS_ENABLED):
                    print("Day %03d Student %s lost patience while returning book %s. They will be back in an hour" % (
                        self.env.now//ONE_DAY, self.name, book.name))
                global lost_patience_counts
                lost_patience_counts += 1
                self.free.succeed
                self.free = self.env.event()
                if(env.now > book.due_date):
                    yield self.env.process(self.checkin_book(book))
                else:  # If book is not due today, return back tomorrow
                    yield start_delayed(env, self.checkin_book(book), delay=ONE_DAY)
                return None

            if(random.random() < PROB_LOSE_TRESHOLD):  # Probability that the book is lost
                if(LOGS_ENABLED):
                    print("Day %03d Student %s lost the book %s" %
                          (self.env.now//ONE_DAY, self.name, book.name))
                book.status = Status.LOST
                global books_lost_count
                books_lost_count += 1

            if(book.status == Status.LOST):  # If book is lost
                yield self.env.timeout(random.randint(LOST_TIME_MIN, LOST_TIME_MAX))
            elif(book.due_date >= self.env.now):  # If returning on time
                yield self.env.timeout(random.randint(CHECKIN_MIN_TIME, CHECKIN_MAX_TIME))
            else:  # If returning late
                yield self.env.timeout(random.randint(LATE_CHECKIN_MIN, LATE_CHECKIN_MAX))

            if(book.status != Status.LOST):
                book.resouce.release(book.req)
                book.status = Status.AVAILABLE
                global returned_books_count
                returned_books_count += 1
                global books_return_time
                books_return_time += env.now - book.due_date
            self.books_borrowed.remove(book)
        self.free.succeed()  # The student is now free
        self.free = self.env.event()
Example #34
0
    #including : think about the last_jobend
    if len(running_jobs[j.user_id]) == 0:
        user_info[j.user_id]['last_jobend'] = env.now


def job_process(j):
    job_submit(j)
    yield env.timeout(j.wait_time)
    job_start(j)
    yield env.timeout(j.run_time)
    job_end(j)


from simpy.util import start_delayed
for j in data:
    start_delayed(env, job_process(j), j.submit_time)

#TODO:DEL dataframe

#print(users)
#for user in users:
#print("User %s with %s campaigns:" %(user.uid,len(user.campaign_deque)))
#for campaign in user.campaign_deque:
#print(campaign)
#for job in campaign.jobs:
#print(job)

#if arguments['--verbose'] == True:
#system.set_monitor(system_monitor(system,env,FileBackend(env,'csim_system.log')))
#ubackend=FileBackend(env,'csim_users.log')
#for u in users:
Example #35
0
file_csv = open("equal.txt", "a+")

print("\nSimulation of Cars Arriving at Intersection Controlled by a Traffic\n\n")

# Total number of seconds to be simulated:
end_time= float(argv[1])

# Initialize environment:
env= simpy.Environment()

# Schedule first change of the traffic light:
env.process(start())

# Schedule first arrival of a car:
t_first_arrival= random.exponential(t_interarrival_mean)
start_delayed(env, arrival(), delay=t_first_arrival)

# Schedule first statistical monitoring event:
env.process(monitor())

# Let the simulation run for specified time:
env.run(until=end_time)


# Section 6: Report statistics.

print("\n\n      *** Statistics ***\n\n")

print("Mean number of cars waiting: %.3f"
  % (Q_stats.cars_waiting / float(Q_stats.count)))
Example #36
0
def set_action(tasks):
    for task in tasks:
        if delays[task.id] > 0:
            task.action = start_delayed(task.env, task.run(), delays[task.id])
        else:
            task.action = env.process(task.run())
Example #37
0
    def receive_reminder(self, reminder_type):
        # a reminder has been received. This determines the outcome fo that reminder and if it was worthwhile.

        if oo.record_reminder_received:
            self.rep.output_data[reminder_type + '_received'].append(oo.reminder_received(self.rep.reps,
                                                                                          self.district.district,
                                                                                          self.la,
                                                                                          self.lsoa,
                                                                                          self.digital,
                                                                                          self.hh_type,
                                                                                          self.hh_id,
                                                                                          self.env.now,
                                                                                          reminder_type))
        # set resp according to type of hh and reminder
        if not self.resp_planned and reminder_type == 'pq' and self.engaged:
            self.paper_allowed = True
            self.resp_level = 100  # so this assumes if you provide paper to those engaged they will respond

        elif not self.resp_planned:
            behaviour = self.default_behaviour()
            # and get relevant figures
            try:
                response_data = self.input_data["behaviours"][reminder_type][behaviour]
            except:
                pass
            self.resp_level = response_data["response"]
            if self.rep.total_ad_instances > 0:
                self.help_level = response_data["help"]
            else:
                self.help_level = 0

        # recorded if wasted, unnecessary or successful
        if self.responded:

            if oo.record_reminder_wasted:
                self.rep.output_data[reminder_type + '_wasted'].append(oo.reminder_wasted(self.rep.reps,
                                                                                          self.district.district,
                                                                                          self.la,
                                                                                          self.lsoa,
                                                                                          self.digital,
                                                                                          self.hh_type,
                                                                                          self.hh_id,
                                                                                          self.env.now,
                                                                                          reminder_type))
        elif self.resp_planned:

            if oo.record_reminder_unnecessary:
                self.rep.output_data[reminder_type + '_unnecessary'].append(oo.reminder_unnecessary(self.rep.reps,
                                                                                                    self.district.district,
                                                                                                    self.la,
                                                                                                    self.lsoa,
                                                                                                    self.digital,
                                                                                                    self.hh_type,
                                                                                                    self.hh_id,
                                                                                                    self.env.now,
                                                                                                    reminder_type))
        # now move on to the relevant action based on extracted values
        reminder_test = self.rnd.uniform(0, 100)

        if not self.resp_planned and reminder_test <= self.resp_level:
            if oo.record_reminder_success:
                self.rep.output_data[reminder_type + '_success'].append(oo.reminder_success(self.rep.reps,
                                                                                            self.district.district,
                                                                                            self.la,
                                                                                            self.lsoa,
                                                                                            self.digital,
                                                                                            self.hh_type,
                                                                                            self.hh_id,
                                                                                            self.env.now,
                                                                                            reminder_type))
            # change to a start delayed at appropriate time depending on day....
            delay = h.get_time_of_return(self.env.now, self.rep)
            # yield self.env.process(self.household_returns(self.calc_delay()))

            ##########
            # if this is a pq, but a digital household, calculate if the household retunrs via paper or digital?
            # Or assume use preferred method for now?
            # could use paper first paper prop to set this? so set digital to true or false...
            ##########

            start_delayed(self.env, self.household_returns(self.calc_delay()), delay)
            yield self.env.timeout(0)

        elif not self.resp_planned and (self.resp_level < reminder_test <= self.resp_level + self.help_level):
            # call for help...needs to be based on appropriate distribution...not a hardcoded uniform function!
            # also may not do this if intend to respond?
            yield self.env.timeout(self.rnd.uniform(0, 8))

            if oo.record_do_nothing:
                self.output_data[reminder_type + '_contact'].append(oo.generic_output(self.rep.reps,
                                                                                     self.district.district,
                                                                                     self.la,
                                                                                     self.lsoa,
                                                                                     self.digital,
                                                                                     self.hh_type,
                                                                                     self.hh_id,
                                                                                     self.env.now))

            yield self.env.process(self.contact())
        else:
            # nowt
            if oo.record_do_nothing:
                self.output_data[reminder_type + '_failed'].append(oo.generic_output(self.rep.reps,
                                                                                     self.district.district,
                                                                                     self.la,
                                                                                     self.lsoa,
                                                                                     self.digital,
                                                                                     self.hh_type,
                                                                                     self.hh_id,
                                                                                     self.env.now))

        yield self.env.timeout(0)
    def __init__(self, rep, name):
        # values fed into class
        self.rep = rep
        self.district = name

        # created by and belong too the class
        self.rnd = self.rep.rnd
        self.env = self.rep.env
        self.input_data = self.rep.input_data['districts'][name]
        self.households = []  # list of household objects in the district
        self.district_co = []  # list of CO assigned to the district
        self.letters = []  # list of letters to be sent to hh in the district
        self.total_households = 0  # count of total including those not represented by objects
        # self.return_rate = 0  #
        self.travel_dist = 0  # average travel distance between hh for district
        self.early_responders = 0  # records number of hh who return prior to first interaction
        self.postal_delay = self.input_data['postal_delay']
        self.total_responses = 0

        if self.input_data["census officer"]:
            self.create_co()
        if self.input_data["letter_phases"]:
            self.create_letterphases(
            )  # set processes to start the sending of letters
        try:
            self.first_visit = min(
                [co.start_sim_time for co in self.district_co])
        except ValueError as e:
            # if no visits then set to end of sim
            self.first_visit = self.rep.sim_hours

        try:
            self.first_letter = min(
                [letter.start_sim_time for letter in self.letters])
        except ValueError as e:
            # if no letters then set to end of sim
            self.first_letter = self.rep.sim_hours

        if self.district_co:
            self.first_interaction = min(
                self.first_visit,
                self.first_letter)  # time of first interaction
            start_delayed(self.env, FFU.start_fu(self.env, self),
                          math.floor(self.first_visit / 24) * 24)
        else:
            self.first_interaction = 0

        # create households that exist in the district
        self.create_households()
        # randomise list -  so ignore priority
        self.rnd.shuffle(self.households)
        try:
            self.hh_area = self.input_data['district_area'] / len(
                self.households)
            self.initial_hh_sep = 2 * (math.sqrt(self.hh_area / math.pi))
        except ZeroDivisionError as e:
            warning_detail = ("Zero division error in run: ", self.rep.run,
                              ", rep: ", self.rep.reps, " for district: ",
                              self.district, ". HH separation set to zero")
            # write out a warning here but don't stop the sim just set the dist to zero
            if oo.record_warnings:
                self.rep.output_data['Warnings'].append(
                    oo.warnings(self.rep.reps, e, warning_detail))

            self.initial_hh_sep = 0

        self.env.process(self.av_travel_dist())
        self.env.process(self.start_hh())

        start_delayed(self.env, self.non_response(),
                      self.rep.sim_hours - 0.0000001)
Example #39
0
	def cloudletTimeShared(self):
		
		processTimes = {}
		resourceListStart = []
		resourceListDelayed = []
		
		for cloudlet in self._resourceList:		
			if cloudlet._submissionTime == 0:
				processTimes[cloudlet] = cloudlet._cloudletLength/(cloudlet._numberOfPes*cloudlet._vm.mips)
				cloudlet._remainingTime = cloudlet._cloudletLength/(cloudlet._numberOfPes*cloudlet._vm.mips)
				resourceListStart.append(cloudlet)
				cloudlet.status = 1
			else:
				resourceListDelayed.append(cloudlet)			
		
			time = 0
		
		while len(processTimes) == 0:
			time += 100

			dummyList = list(resourceListDelayed)

			for cloudlet in dummyList:
					if time >= cloudlet._submissionTime:
						processTimes[cloudlet] = cloudlet._cloudletLength/(cloudlet._numberOfPes*cloudlet._vm.mips)
						cloudlet._remainingTime = cloudlet._cloudletLength/(cloudlet._numberOfPes*cloudlet._vm.mips)
						resourceListDelayed.remove(cloudlet)
						cloudlet.status = 1
		
		while True:
			
			dummyList = list(resourceListDelayed)

			for cloudlet in dummyList:
					
				if time >= cloudlet._submissionTime:
					processTimes[cloudlet] = cloudlet._cloudletLength/(cloudlet._numberOfPes*cloudlet._vm.mips)
					cloudlet._remainingTime = cloudlet._cloudletLength/(cloudlet._numberOfPes*cloudlet._vm.mips)
					resourceListDelayed.remove(cloudlet)
			
			keys = processTimes.keys()
			
			for i in keys:
				
				dummyList = list(resourceListDelayed)

				for cloudlet in dummyList:
					
					if time >= cloudlet._submissionTime:
						processTimes[cloudlet] = cloudlet._cloudletLength/(cloudlet._numberOfPes*cloudlet._vm.mips)
						cloudlet._remainingTime = cloudlet._cloudletLength/(cloudlet._numberOfPes*cloudlet._vm.mips)
						resourceListDelayed.remove(cloudlet)

				if time == 0:
					self._context.process(i._process(self._context,100))
				else:
					start_delayed(self._context,i._process(self._context,100),time)
				
				processTimes[i] -= 100

				if processTimes[i] <= 0:
					del processTimes[i]
				
				time += 100
			
			if len(processTimes) == 0:
				if len(resourceListDelayed) == 0:
					break	
				else:
					time += 100
Example #40
0
    N=user_info[j.user_id]['usercount']
    user_info[j.user_id]['usermean']=user_info[j.user_id]['usermean']*N/(N+1) + j.run_time /(N+1)
    #including : think about the last_jobend
    if len(running_jobs[j.user_id])==0:
        user_info[j.user_id]['last_jobend']=env.now

def job_process(j):
    job_submit(j)
    yield env.timeout(j.wait_time)
    job_start(j)
    yield env.timeout(j.run_time)
    job_end(j)

from simpy.util import start_delayed
for j in data:
    start_delayed(env,job_process(j),j.submit_time)

#TODO:DEL dataframe

#print(users)
#for user in users:
    #print("User %s with %s campaigns:" %(user.uid,len(user.campaign_deque)))
    #for campaign in user.campaign_deque:
        #print(campaign)
        #for job in campaign.jobs:
            #print(job)

#if arguments['--verbose'] == True:
    #system.set_monitor(system_monitor(system,env,FileBackend(env,'csim_system.log')))
    #ubackend=FileBackend(env,'csim_users.log')
    #for u in users: