def __init__(self, run_number):
self.env = simpy.Environment()
self.patient_counter = 0
self.receptionist = simpy.Resource(self.env,
capacity=g.number_of_receptionists)
self.nurse = simpy.Resource(self.env, capacity=g.number_of_nurses)
# If we want a queue where higher priority entities are seen first,
# then the resource they queue for needs to be a PriorityResource
self.ed_doctor = simpy.PriorityResource(
self.env, capacity=g.number_of_ed_doctors)
self.acu_doctor = simpy.PriorityResource(
self.env, capacity=g.number_of_acu_doctors)
self.run_number = run_number
self.mean_q_time_registration = 0
self.mean_q_time_triage = 0
self.mean_q_time_ed_assessment = 0
self.mean_q_time_acu_assessment = 0
self.results_df = pd.DataFrame()
self.results_df["P_ID"] = []
self.results_df["Q_Time_Registration"] = []
self.results_df["Q_Time_Triage"] = []
self.results_df["Q_Time_ED_Assessment"] = []
self.results_df["Q_Time_ACU_Assessment"] = []
self.results_df.set_index("P_ID", inplace=True)
def __init__(self, env, CAPACITY1, CAPACITY2, CAPACITY3, CAPACITY4,
CAPACITY5):
self.env = env
self.res_step1_tools = simpy.PriorityResource(env, capacity=CAPACITY1)
self.res_step2_tools = simpy.PriorityResource(env, capacity=CAPACITY2)
self.res_step3_tools = simpy.PriorityResource(env, capacity=CAPACITY3)
self.res_step4_tools = simpy.PriorityResource(env, capacity=CAPACITY4)
self.res_step5_tools = simpy.PriorityResource(env, capacity=CAPACITY5)
def __init__(self, simpy_env, id_num):
self.simpy_env = simpy_env
self.name = id_num
self.queues = {
'north': simpy.PriorityResource(simpy_env, 1),
'south': simpy.PriorityResource(simpy_env, 1),
'east': simpy.PriorityResource(simpy_env, 1),
'west': simpy.PriorityResource(simpy_env, 1)
}
self.direction = (random.random() > 0.5) # True is North
self.light_change_time = 0.
self.accrued_reward = 0.
self.time_trigger = -1
self.sojourn_time = -1
return
def __init__(self, nr_resources=1, priority=False, *args, **kwargs):
super().__init__(*args, **kwargs)
"""Initialization"""
self.resource = (simpy.PriorityResource(
self.env, capacity=nr_resources) if priority else simpy.Resource(
self.env, capacity=nr_resources))
def __init__(self, env, num_landingstrips):
self.env = env
self.runway = simpy.PriorityResource(env, num_landingstrips)
self.num_landingstrips = num_landingstrips
self.snowplows = simpy.Resource(env, numPlows)
self.plowingMachine = env.process(self.snowplow())
self.deicetruckResource = simpy.Resource(env, numDeiceTrucks)
def messageDAG(self, D):
messages = {
v: simpy.PriorityResource(self.env, capacity=D.out_degree(v))
for v in D.nodes if D.out_degree(v) > 0
}
for v in D.nodes:
if D.out_degree(v) == 0:
messages[v] = None
for M in D.nodes:
source, dest, idx = M
method = D.nodes[M].get("method", None)
packet_stats = D.nodes[M].get("packet_stats", False)
sync = D.nodes[M].get("sync", True)
message_size = D.nodes[M]["message_size"]
self.env.process(
self.DAGsend(source,
dest,
message_size,
messages[M],
D.out_degree(M),
[messages[x] for x in D.predecessors(M)],
packet_stats=packet_stats,
id=M,
method=method,
sync=sync))
def __init__(self, env, ncajas, estacionamientos):
self.abierto = True
self.parking = simpy.PriorityResource(
env, capacity=estacionamientos
) # Estacionamiento es una priorityResource
self.cajas = [] # Lista de cajas
self.env = env # simpy
for i in range(ncajas):
self.cajas.append(Cola(env, SuperMercado.id_caja,
self)) # Agregamos las cajas
SuperMercado.id_caja += 1
self.C = sum([len(i.cola)
for i in self.cajas]) # Valor C del enunciado
self.productos = dict(
) # diccionario con todos los productos y sus cantidades del super
for i in productos:
for j in productos[i]:
self.productos[j] = productos[i][j]["cantidad"]
self.tipos = dict() # Diccionario con productos y su cantidad comprada
self.clientes = [] # Lista de Clientes
self.ganancias = 0 # Ganancias Totales
self.llegada_cliente = 0
self.clientes_id = 0
self.abre_caja = 1000000000000 # Valor muy grande para no interferir en el programa
self.gasto = deque() # gasto por cada cliente que pasa por el super
self.tiempo = deque() # tiempo por cada cliente que pasa por el super
self.cola = deque() # tiempo que pasa en la cola cada cliente
def __init__(self, env, sim_params, replication, arrival_data):
# Extra Stuff
self.env = env
self.directory = sim_params.directory
# Input_data
self.curr_repl = replication
self.input_data = deepcopy(sim_params)
self.replication = replication
# random streams
self.rand_arrivals = np.random.RandomState()
self.rand_other = np.random.RandomState()
self.rand_arrivals.seed(replication)
self.rand_other.seed(replication)
# Resource
self.scan_resource = simpy.PriorityResource(
env, self.input_data.arrParams.capacity)
# Results
self.patient_results = []
self.arr_queue_results = {
'day': [],
'initial_arrival': [],
'end_queue': []
}
def __init__(self, env, nbTasks, nbNodes_stg1, nbNodes_stg2, data1, data2):
self.data1 = data1
self.data2 = data2
self.env = env
self.nbTasks = nbTasks
self.nbNodes_stg1 = nbNodes_stg1
self.nbNodes_stg2 = nbNodes_stg2
self.nodeDict_stg1 = {}
for cpu in range(self.nbNodes_stg1):
self.nodeDict_stg1["cpu%d"%cpu] = simpy.Resource(self.env, capacity=1)
self.nodeDict_stg2 = {}
for gpu in range(self.nbNodes_stg2):
self.nodeDict_stg2["gpu%d"%gpu] = simpy.PriorityResource(self.env, capacity=1)
self.sysTime = [0 for i in range(self.nbTasks+2)]
self.departedStg1 = []
self.departedStg2 = 0
self.action1 = self.env.process(self.stg1Runner())
self.action2 = self.env.process(self.stg2Runner())
self.totalTime = None
def __init__(self, id, env, location, power, Number_of_chargers):
self.env = env
self.capacity = Number_of_chargers
self.plugs = simpy.PriorityResource(self.env, capacity=Number_of_chargers)
self.id = id
self.location = location
self.power = power # kwh/min
self.queue = []
def __init__(self, env):
self.state = True
self.env = env
self.waiters = simpy.PriorityResource(self.env,
capacity=waiterCapacity)
self.cookers = simpy.Resource(self.env, capacity=cookerCapacity)
self.env.process(self.restaurantState())
self.env.process(self.customerArrive())
def __init__(self, env, size):
self.env = env
self.size = size
self.space = simpy.PriorityResource(
env, capacity=size) # roundabout resource
self.lock = simpy.Resource(env,
capacity=1) # mutex for resources below
self.next_exit = ('north', 9999) # { 'dir' }
self.occupying_cars = [] # { 'exit_dir' : time of exit }
def __init__(self, env, level, capacity=1, frequency=1, centre=1):
self.env = env
self.level = level
self.capacity = capacity # Max number of seats
self.seats = simpy.PriorityResource(self.env, capacity=capacity)
self.frequency = frequency # Hours per week
self.centre_id = centre # Centre ID
self.queue_array = [] # Array of Members in class and wait list
self.outgoing_edges = []
self.incoming_edges = []
self.last_accepted_member = None
self.last_accepted_centre = None
def __init__(self, env, mu, c, scheduler):
self.env = env
# Start the run process everytime an instance is created.
self.c = c
self.handled = 0
if scheduler == "FIFO":
self.server = simpy.Resource(env, self.c)
elif scheduler == "SJF":
self.server = simpy.PriorityResource(env, self.c)
else:
raise Exception("Unknown scheduler type.")
def __init__(self, env, name, food_ready, out_pipe,
hostToGuestInteractionTime, num_of_conversations):
self.env = env
self.name = name
self.food_ready = food_ready
self.out_pipe = out_pipe
self.hostToGuestInteractionTime = hostToGuestInteractionTime
self.conversation = simpy.PriorityResource(
env, capacity=num_of_conversations)
self.guests = []
self.guests_notified = False
self.timeSpentTalking = 0
def __init__(self, router_id, env, poisson_mean, num_packets):
self.router_id = router_id
self.env = env
self.router_links = []
self.poisson_mean = poisson_mean
self.num_packets = num_packets
self.num_packets_delivered = 0
self.packet_queue = simpy.PriorityResource(self.env, capacity=1)
# These are the packets that have been sucessfully transmitted.
self.packets = {}
self.env.process(self.generate_packet())
def __init__(self, env, latency, max_hosts = 100):
self.next_available_address = 1
self.channel = simpy.Resource(env)
self.node_list_access = simpy.PriorityResource(env, capacity = 1) # Para evitar conflito entre send_broadcast e check_lease
self.env = env
self.timeout = env.timeout
self.latency = latency
self.max_hosts = max_hosts
self.full_capacity = False
# DHCP Simples
self.default_lease_time = 40
self.addr_list = [{'node':None, 'lease':0} for i in range(self.max_hosts)] # O índice da lista serve como 'IP'
self.node_list = [] # Usamos esta lista para fazer broadcasts e checar empréstimos
def __init__(self, env, lamb, mu, n_servers, n_clients):
self.env = env
# Start the run process everytime an instance is created.
#Capacity is the amount of servers n, standard Queue is FIFO
self.mu = mu
self.lamb = lamb
self.n_servers = n_servers
self.n_clients = n_clients
self.server = simpy.PriorityResource(env, capacity=n_servers)
self.action = env.process(self.arriving(env, lamb, mu, self.server))
self.waiting_times = []
self.server_times = []
def schedule(env):
global __running__
global day_time
#Res symbolisiert die frei zur Verfügung stehende Abfüll-Anlage
#Bei Wartungsarbeiten wird so die Maschine blockiert
res = simpy.PriorityResource(env, capacity=1)
#Queque
que_check = simpy.Container(env, capacity=100)
que_fill = simpy.Container(env, capacity=FILLING_SATIONS)
que_done = simpy.Container(env)
que_rejected = simpy.Container(env)
que_removed = simpy.Container(env)
#Offset damit scheduling Funktioniert
offset = 60 - (day_time.second % 60) if day_time.second % 60 > 0 else 0
logging.debug(
f"Wartet {offset} Sekunden bis mit den Scheduling begonnen wird")
yield env.timeout(offset)
update_time(env)
while True:
logging.debug(
f"Datum:{day_time}|Queue_Check:{que_check.level}|Queue_Fill:{que_fill.level}|Queue_Done:{que_done.level}|Queue_Rej:{que_rejected.level}"
)
weekday = day_time.isoweekday()
time = day_time.shift(minutes=VARIANCE_MEAN).format("HH:mm:ss")
#Status
if time in status.index:
if not pd.isnull(status.loc[time][weekday]):
if status.loc[time][weekday] == "r":
env.process(
proc_start_processes(env, res, que_check, que_fill,
que_done, que_rejected,
que_removed))
else:
env.process(proc_end_processes(env))
#Wartung
if time in maintenance.index:
if not pd.isnull(maintenance.loc[time][weekday]):
time = int(maintenance.loc[time][weekday])
env.process(proc_maintenance(env, time, res))
yield env.timeout(60)
update_time(env)
def __init__(self, node, *args, **kwargs):
super().__init__(*args, **kwargs)
"""Initialization"""
waiting_area_resources = 100
self.waiting_area = {
node: simpy.Resource(self.env, capacity=waiting_area_resources),
}
departure_resources = 4
self.departure = {
node: simpy.PriorityResource(self.env,
capacity=departure_resources),
}
def simulate():
env = simpy.Environment()
runways = simpy.PriorityResource(env, capacity=2)
gen = PlaneGenerator(env, runways)
env.run(until=SIM_TIME)
gen.planes.sort(key=lambda x: x.arrival_time)
landing_means = take_means(gen.planes, "landing")
takeoff_means = take_means(gen.planes, "takeoff")
return landing_means, takeoff_means
def __init__(self, env, conf, net, id=None, layer=None, logger=None):
self.env = env
self.conf = conf
self.layer = layer
self.net = net
self.logger = logger
self.id = id or random_string(self.conf["misc"]["id_len"])
self.max_capacity = 100
# Resource queue to model congestion
self.resource_queue = simpy.PriorityResource(
self.env, capacity=self.max_capacity)
self.queue = []
def test_resource_with_priority_queue(env):
def process(env, delay, resource, priority, res_time):
yield env.timeout(delay)
req = resource.request(priority=priority)
yield req
assert env.now == res_time
yield env.timeout(5)
resource.release(req)
resource = simpy.PriorityResource(env, capacity=1)
env.process(process(env, 0, resource, 2, 0))
env.process(process(env, 2, resource, 3, 10))
env.process(process(env, 2, resource, 3, 15)) # Test equal priority
env.process(process(env, 4, resource, 1, 5))
env.run()
def __init__(self, env, host, gathering, name, in_pipe,
guest_interaction_time, num_of_conversations, max_hunger):
self.env = env
self.host = host
self.gathering = gathering
self.name = name
self.in_pipe = in_pipe
self.guest_interaction_time = guest_interaction_time
self.conversation = simpy.PriorityResource(
env, capacity=num_of_conversations)
self.food_ready = False
self.hunger = 0
self.max_hunger = max_hunger
self.ate_food = False
self.waiting_time = 1
self.timeSpentTalking = 0
def set_up_resources(self):
"""
Set up:
self.resources: A dictionary of resource objects
self.resources_available: A dictionary of count of resources available
self.resources_occupied: A dictionary of count of resources occupied
"""
# Set up resources
for key, value in self._params.resource_numbers.items():
# Store resource objects in a dictionary
# Set up dictionaries of available and occupied
self.resources_available[key] = value
self.resources_occupied[key] = 0
if value > 0:
self.resources[key] = simpy.PriorityResource(
self._env, capacity=value)
def __init__(self, vehSeatCapacity, rollingStockType, simEnv):
assert (vehSeatCapacity >
0), "vehSeatCapacity (%s) must be positive" % vehSeatCapacity
self.doorServiceRateMean = Parameter.boardAlightServiceTimesPerVehicle[
rollingStockType]
self.rollingStockType = rollingStockType
self.cabin = CabinResource(simEnv, vehSeatCapacity)
self.door = simpy.PriorityResource(simEnv, capacity=1)
#log book of ridership at arrival (before doors open)
self.totalRidershipAtArrival = dict()
self.auxiliaryRidershipAtArrival = dict()
self.trackedRidershipAtArrival = dict()
def Simulation(env, clinic, workerSchedule, patientSchedule, outfile):
global patientCount
global patientCompleted
resources = [
simpy.PriorityResource(env, 1) for _ in range(len(clinic.stations))
]
patientCount = len(patientSchedule.patients)
patientCompleted = 0
for i in range(len(workerSchedule.healthcare)):
env.process(
workerRun(env, workerSchedule.healthcare[i], clinic, resources))
for i in range(len(patientSchedule.patients)):
env.process(
patientRun(env, patientSchedule.patients[i], clinic, resources,
patientSchedule))
env.run(until=(endTime - startTime) + 1)
#Clinic Statistics From Simulation Run
# Average Time in Clinic
averageClinicTime = 0
for person in patientSchedule.patients:
averageClinicTime = averageClinicTime + person.completionTime
averageClinicTime = averageClinicTime / (len(patientSchedule.patients))
# Average Idle time for a patient
averageDownTime = 0
for person in patientSchedule.patients:
averageDownTime = averageDownTime + (person.completionTime -
person.timeInService)
print(person.completionTime)
personwait = {
"Name": "personWaitTime",
"patientName": person.name,
"startTime": (person.completionTime - person.timeInService)
}
db[patientSchedule.date + "result"].insert_one(personwait)
averageDownTime = averageDownTime / (len(patientSchedule.patients))
#write statistics to DB
clinicStats = {
"Name": "clinicStats",
"averageClinicTime": averageClinicTime,
"averageDownTime": averageDownTime
}
db[patientSchedule.date + "result"].insert_one(clinicStats)
def test_sorted_queue_maxlen(env):
"""Requests must fail if more than *maxlen* requests happen
concurrently."""
resource = simpy.PriorityResource(env, capacity=10)
resource.put_queue.maxlen = 1
def process(env, resource):
resource.request(priority=1)
try:
resource.request(priority=1)
pytest.fail('Expected a RuntimeError')
except RuntimeError as e:
assert e.args[0] == 'Cannot append event. Queue is full.'
yield env.timeout(0)
env.process(process(env, resource))
env.run()
def __init__(self, env, id):
self.id = id
self.speed = building_group.speed
self.acceleration = building_group.acceleration
self.jerk = building_group.jerk
self.carCapacity = building_group.carCapacity
self.passengerTransferTime = building_group.passengerTransferTime
self.doorOpeningTime = building_group.doorOpeningTime
self.doorClosingTime = building_group.doorClosingTime
# car start running at floor_id=0
self.carPosition = 0
# so first destination is floor_id=0:
self.destination_floor_id = 0
# car up: (run direction = 1) car down: (run direction = -1)
# initial runDirection is up:
self.runDirection = 1
# floor where car will go when is empty:
self.returnFloor = 0
# car have capacity limit. This is limiter:
self.carUsage = simpy.PriorityResource(env,
capacity=self.carCapacity)
# buffor for avoid once again loaading of passengers just served:
self.just_inside = []
#self.doorOpened = env.process(doorOpened(env))
self.doorOpened_reactivate = env.event()
# caches for simulation run:
self.passengersInCar = []
self.passengersInCarDest = []
# cache for statistics:
self.carDepartures = []
# cache for movement beetween floors:
# - simulation time
# - actual car height in building
# - actual speed
# - actual acceleration
# - actual jerk
self.carMovement = [[], [], [], [], []]
# avarage car load factor for in current simulation:
self.avgClfValue = 0
def test_sorted_queue_maxlen(env):
"""Requests must fail if more than *maxlen* requests happen
concurrently."""
resource = simpy.PriorityResource(env, capacity=1)
resource.put_queue.maxlen = 1
def process(env, resource):
# The first request immediately triggered and does not enter the queue.
resource.request(priority=1)
# The second request is enqueued.
resource.request(priority=1)
try:
# The third request will now fail.
resource.request(priority=1)
pytest.fail('Expected a RuntimeError')
except RuntimeError as e:
assert e.args[0] == 'Cannot append event. Queue is full.'
yield env.timeout(0)
env.process(process(env, resource))
env.run()
