def setup(self, job_generator):
self.tasks = sim.Queue(fill=[
Task(job_generator=job_generator,
job=self,
name='Task ' + str(self.sequence_number()) + '.')
for _ in range(job_generator.number_of_tasks_dist())
],
name='tasks.')
self.task_in_execution = sim.Queue(name='task_in_execution.')
self.slack = start_slack
self.an_slack = sim.Animate(x0=90, text='', fontsize0=12, anchor='se')
self.an_label = sim.Animate(x0=50,
text=str(self.sequence_number()),
fontsize0=12,
anchor='se')
self.an_execute_bar = sim.Animate(x0=100, rectangle0=(0, 0, 70, 12))
self.an_execute_text = sim.Animate(x0=100,
text='',
fontsize0=12,
anchor='sw',
textcolor0='white',
offsetx0=2,
offsety0=1)
self.an_due = sim.Animate(line0=(0, -1, 0, 13))
self.enter(self.tasks[0].group.jobs)
if self.tasks.head().group.idle_machines:
self.tasks.head().group.idle_machines.head().activate()
self.enter(plant)
def setup(self, job_select_method, number_of_machines, fraction,
file_name):
'''
Initialize with scheduling strategy, machine numbers
'''
if job_select_method.lower() == 'fifo':
self.job_select = self.job_select_fifo
else:
raise AssertionError('wrong selection method:', job_select_method)
self.fraction = fraction
self.machines = [
Machine(group=self, name=self.name() + ' Machine.')
for _ in range(number_of_machines)
]
self.idle_machines = sim.Queue(self.name() + '.idle_machines')
self.jobs = sim.Queue(self.name() + '.jobs')
self.config_file = file_name
self.price_list = []
# read price information from file into list (format: string)
with open(self.config_file, encoding='utf-8') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
self.price_list.append((row['Date'], row['Euro']))
def init():
global queue_vessels_in_network
global queue_vessels_waiting_lock
global queue_vessels_waiting_segment
global queue_vessels_waiting_crossroad
global queue_vessels_waiting_bridge
queue_vessels_in_network = sim.Queue(name="Vessels in network")
queue_vessels_waiting_bridge = sim.Queue(name="Vessels waiting at bridges")
queue_vessels_waiting_crossroad = sim.Queue(
name="Vessels waiting at crossroad")
queue_vessels_waiting_lock = sim.Queue(name="Vessels waiting at locks")
queue_vessels_waiting_segment = sim.Queue(
name="Vessels waiting at segments")
def setup(self, job_select_method, fraction, number_of_machines, color):
if job_select_method.lower() == 'fifo':
self.job_select = self.job_select_fifo
elif job_select_method.lower() == 'min_slack':
self.job_select = self.job_select_min_slack
else:
raise AssertionError('wrong selection_method:', job_select_method)
self.machines = [Machine(group=self, name=self.name() + '.') for _ in range(number_of_machines)]
self.fraction = fraction
self.color = color
self.jobs = sim.Queue(self.name() + '.jobs')
self.idle_machines = sim.Queue(self.name() + '.idle_machines')
def setup(self, job_generator):
self.tasks = sim.Queue(fill=[
Task(job_generator=job_generator,
job=self,
name='Task ' + str(self.sequence_number()) + '.')
for _ in range(job_generator.number_of_tasks_dist())
],
name='tasks.')
self.task_in_execution = sim.Queue(name='task_in_execution.')
self.slack = start_slack
self.an_slack = sim.AnimateText(
x=90,
y=self.y,
text=lambda job, t: '{:7.2f}'.format(job.slack_t(t)),
textcolor=lambda job, t: 'white'
if job.slack_t(t) < 0 else '50%gray',
fontsize=12,
text_anchor='se',
arg=self)
self.an_label = sim.AnimateText(text=str(self.sequence_number()),
x=50,
y=self.y,
fontsize=12,
text_anchor='se')
self.an_execute = sim.AnimateRectangle(
spec=(0, 0, 72, 12),
x=100,
y=self.y,
fillcolor=lambda job, t: '' if job.tasks[
0].start_execution is None else job.tasks[0].group.color,
text=lambda job, t: '' if job.tasks[
0].start_execution is None else job.tasks[0].machine.name(),
textcolor='white',
text_anchor='sw',
arg=self)
self.an_due = sim.AnimateLine(
spec=(0, -1, 0, 13),
x=lambda job, t: 200 + job.due_t(t) * scale_x,
y=self.y,
layer=-1,
arg=self)
self.an_tasks = sim.AnimateQueue(queue=self.tasks,
x=200,
y=self.y,
direction='e',
arg=self)
self.enter(self.tasks[0].group.jobs)
if self.tasks.head().group.idle_machines:
self.tasks.head().group.idle_machines.head().activate()
self.enter(plant)
def setup(self, job_generator):
self.tasks = sim.Queue(fill=[
Task(job_generator=job_generator,
job=self,
name='Task ' + str(self.sequence_number()) + '.')
for _ in range(job_generator.number_of_tasks_dist())
],
name='tasks.')
self.task_in_execution = sim.Queue(name='task_in_execution.')
self.slack = start_slack
self.enter(self.tasks[0].group.jobs)
if self.tasks.head().group.idle_machines:
self.tasks.head().group.idle_machines.head().activate()
self.enter(plant)
def setup(self, job_generator):
self.tasks = sim.Queue(fill=[
Task(job_generator=job_generator,
job=self,
name='Task ' + str(self.sequence_number()) + '.')
for _ in range(job_generator.number_of_tasks_dist)
],
name='tasks.') # Fill in the job tasks
self.task_in_execution = sim.Queue(name='task_in_execution')
self.enter(self.tasks[0].group.jobs) # Add job to a group list
if self.tasks.head().group.idle_machines:
self.tasks.head().group.idle_machines.head().activate(
) # Activate the first idle machine of the group
self.enter(plant)
def setup(self, sensitivity, busyness):
self.state = sim.State((self.name() + ".state"), value="red")
self.vehiclesQueue = sim.Queue(self.name() + ".queue")
self.movementSensorSensitivity = sensitivity
self.movementState = sim.State(self.name() + ".movementState",
value='movement')
self.busyness = busyness
def generate_graph(self):
"""LETS SCREAM IT OUT"""
for fairway in self.fairway_sections_list:
start_pair = None
for node in fairway.nodes:
end_pair = (node.x, node.y)
if not self.graph.has_node(end_pair):
self.graph.add_node(end_pair,
artwork=node,
pos=end_pair,
fairway=fairway)
elif type(node).__name__ != 'Node':
self.graph.nodes()[end_pair]['artwork'] = node
if start_pair is not None:
self.graph.add_edge(
start_pair,
end_pair,
fairway=fairway,
# length=Utilities.haversine(start_pair, end_pair),
time=Utilities.haversine(start_pair, end_pair) /
fairway.speed)
start_pair = end_pair
for node in self.graph.nodes:
neighbors = list(self.graph.neighbors(node))
if len(neighbors) > 2:
crossroad = CrossRoad(node)
crossroad.draw()
self.graph.nodes()[node]['artwork'] = crossroad
neighbors = sorted(
neighbors,
key=lambda element: angle_between_points(node, element))
for neighbor in neighbors:
crossroad.intersections[neighbor] = sim.Queue(
"Crossroad at " + str(node) + " => " + str(neighbor))
# nx.draw(self.graph, pos=nx.get_node_attributes(self.graph, 'pos'), node_size=1, alpha=0.5, node_color="blue",
# with_labels=False)
# plt.axis('scaled')
# plt.show()
for traject_name, trajectory in GlobalVars.trajectories_dict.items():
start_section_ref = trajectory.section_ref_1
end_section_ref = trajectory.section_ref_2
start_point = (trajectory.lon1, trajectory.lat1)
end_point = (trajectory.lon2, trajectory.lat2)
start_node = get_closest_node_in_section(
start_point, self.fairway_sections_dict[start_section_ref])
end_node = get_closest_node_in_section(
end_point, self.fairway_sections_dict[end_section_ref])
trajectory_nodes_tmp = nx.bidirectional_shortest_path(
self.graph, (start_node.x, start_node.y),
(end_node.x, end_node.y))
for trajectory_node in trajectory_nodes_tmp:
trajectory.nodes.append(
self.graph.nodes()[trajectory_node]['artwork'])
self.graph.nodes()[trajectory_node]['artwork'].useful = True
for node in self.graph.nodes:
self.graph.nodes()[node]['artwork'].init_node(self.graph)
def test33():
class X(sim.Component):
def process(self):
yield self.hold(1)
s1.set(1)
yield self.hold(1)
s1.set(2)
s2.set('red')
yield self.hold(2)
s1.set(30)
class Y(sim.Component):
def process(self):
while True:
yield self.wait((s1,lambda x, component, state: x/2>self.env.now()))
yield self.hold(1.5)
class Z(sim.Component):
def process(self):
while True:
yield self.wait((s2,lambda x, component, state: x in ("red","yellow")))
yield self.hold(1.5)
env=sim.Environment(trace=True)
env.print_info()
s1=sim.State(name='s.',value=0)
s2=sim.State(name='s.',value='green')
s3=sim.State(name='s.')
q=sim.Queue('q.')
x=X()
y=Y()
z=Z()
env.run(10)
def test1():
print('test1')
class X(sim.Component):
def __init__(self, extra=1, *args, **kwargs):
sim.Component.__init__(self, *args, **kwargs)
self.extra = extra
def process(self):
while True:
yield self.hold(1)
pass
def action2(self):
for i in range(5):
yield self.hold(25)
yield self.hold(1)
def actionx(self):
pass
class Y(sim.Component):
def process(self):
x[3].reactivate(process=x[3].action2(), at=30)
x[4].cancel()
yield self.hold(0.5)
yield self.standby()
yield self.activate(process=self.action2(0.3))
def action2(self, param):
yield self.hold(param)
class Monitor(sim.Component):
def process(self):
while sim.now() < 30:
yield self.standby()
de = sim.Environment(trace=True)
q = sim.Queue()
x = [0]
for i in range(10):
x.append(X(name='x.', at=i * 5))
# x[i+1].activate(at=i*5,proc=x[i+1].action())
x[i + 1].enter(q)
x[6].suppress_trace(True)
i = 0
for c in q:
print(c._name)
i = i + 1
if i == 4:
x[1].leave(q)
x[5].leave(q)
x[6].leave(q)
y = Y(name='y')
# y.activate(at=20)
sim.run(till=35)
def test2():
de=sim.Environment()
print('test2')
x=[None]
q=[None]
for i in range(5):
x.append(sim.Component(name='x.'))
q.append(sim.Queue(name='q.'))
y=sim.Component(name='y')
x[1].enter(q[1])
y.enter(q[1])
x[1].enter(q[2])
x[2].enter(q[2])
x[2].enter(q[1])
x[3].enter(q[2])
q[1].print_statistics()
q[2].print_statistics()
q[1].union(q[2],'my union').print_statistics()
q[1].difference(q[2],'my difference').print_statistics()
q[1].intersect(q[2],'my intersect').print_statistics()
q[1].copy('my copy').print_statistics()
# q[1].move('my move').print_statistics()
q[1].print_statistics()
print (q[1])
yy=q[1].component_with_name('y')
ii=q[1].index(y)
print(yy,ii)
def __init__(self, var_name, env, *args, **kwargs):
"""
extend `sim.Component.__init__()`, override name variable,
setup Machine specific attributes
Args:
var_name (str): name of the machine
env (EnvironmentPlus): salabim_plus simulation environment
*arg, **kwargs: sim.Component specific default attributes
"""
sim.Component.__init__(self, name=var_name, *args, **kwargs)
self.var_name = self._name.replace(
'.', '_') # unique name of that specific machine
self.queue = sim.Queue(self.var_name +
'_queue') # queue of entities to work on
self.in_queue = sim.State(
self.var_name + '_in_queue'
) # trigger state to work on an entity, NOTE that the default state is FALSE
self.state = sim.State(self.var_name + '_status',
value='idle') # machine status
self.time_remaining = 0 # time until machine finishes entity being process
self.env = env
env.objs[self._name] = self
def test46():
class Y(sim.Component):
pass
class X(sim.Component):
def process(self):
x=0
for i in range(10):
q.add(Y())
print ('q.length=', q.length())
if i==3:
monx.monitor(False)
monx.tally(x)
if i==6:
monx.monitor(True)
yield self.hold(1)
x += 1
env = sim.Environment()
env.beep()
monx = sim.MonitorTimestamp('monx')
q = sim.Queue('q')
X()
env.run(20)
print(monx.xt())
print(q.length.xt())
def test5():
print('test5')
class X1(sim.Component):
def process(self):
while True:
while True:
yield self.request(r1,
2,
5,
r2,
greedy=True,
fail_at=de.now() + 6)
if not self.request_failed()():
break
yield self.hold(1)
self.release(r1, r2)
yield self.passivate()
class X2(sim.Component):
def process(self):
while True:
yield self.request((r1, 3), (r2, 1, 1))
yield self.hold(1)
self.release(r1)
yield self.passivate()
class X3(sim.Component):
def process(self):
while True:
yield self.request(r1, r2)
yield self.hold(1)
self.release(r1, r2)
yield self.passivate()
class Y(sim.Component):
# def __init__(self,*args,**kwargs):
# sim.Component.__init__(self,*args,**kwargs)
def process(self):
yield self.hold(3)
x1.cancel()
yield self.hold(10)
r2.capacity(1)
pass
de = sim.Environment(trace=True)
q = sim.Queue(name='q')
r1 = sim.Resource(name='r1', capacity=3)
r2 = sim.Resource(name='r2', capacity=0)
r3 = sim.Resource(name='r3', capacity=1)
x1 = X1()
x2 = X2()
x3 = X3()
y = Y(name='y')
sim.run(till=21)
def setup(self):
self.queue = sim.Queue()
self.credits = QUANTUM
self.sparse = False
self.qid = UNCLAIMED
self.packetCounter = 0.0
self.activateCounter = 0.0
self.totalQueueDelay = 0.0
def test42():
class Rij(sim.Queue):
pass
class Komponent(sim.Component):
pass
class Reg(sim.Monitor):
pass
env=sim.Environment(trace=True)
q1=sim.Queue('q1')
q2=sim.Queue('q2')
for i in range(15):
c = sim.Component(name='c.')
if i < 10:
q1.add_sorted(c, priority=i)
if i > 5:
q2.add_sorted(c, priority=i+100)
env.run(1000)
del q1[1]
print('length',q1.length.number_of_entries())
print('length_of_stay',q1.length_of_stay.number_of_entries())
q1.print_info()
q2.print_info()
(q1 - q2).print_info()
(q2 - q1).print_info()
(q1 & q2).print_info()
(q1 | q2).print_info()
(q2 | q1).print_info()
(q1 ^ q2).print_info()
q3=sim.Queue(name='q3',fill=q1)
q4=sim.Queue(name='q4',fill=q1)
print('before')
q3.print_info()
del q3[-1:-4:-1]
print('after')
q3.print_info()
q4.pop(3)
for c in q3:
print(c.name(),c.count(q2),c.count(),q4.count(c),c.queues())
def test25():
de=sim.Environment()
q=sim.Queue('q')
c={}
for i in range(8):
c[i]=sim.Component(name='c.')
c[i].enter(q)
print(q)
for c in q:
c.priority(q,-c.sequence_number())
print(q)
def __init__(self, var_name, env, *args, **kwargs):
"""
extend `sim.Component.__init__()`, override name variable,
setup EntityTracker specific attributes
Args:
var_name (str): name of the entity
env (EnvironmentPlus): salabim_plus simulation environment
*arg, **kwargs: sim.Component specific default attributes
"""
sim.Component.__init__(self, name='track.' + var_name, *args, **kwargs)
self.wip = sim.Queue(self._name + '_wip')
self.complete = sim.Queue(self._name + '_complete')
self.wip_count = sim.State(self._name + '_wip_count', value=0)
self.complete_count = sim.State(self._name + '_complete_count',
value=0)
self.env = env
env._add_env_objectlist(self)
def init_node(self, graph):
if self.useful:
sim.Component.__init__(self)
coordinate = (self.x, self.y)
neighbors = list(graph.neighbors(coordinate))
if len(neighbors) != 2:
print("Well well well, WE ARE F****D")
self.left = neighbors[0]
self.right = neighbors[1]
self.key_in[left] = sim.Resource(
name="Lock at " + str(coordinate) + " => left key in")
self.key_in[right] = sim.Resource(
name="Lock at " + str(coordinate) + " => right key in")
self.wait_in[left] = sim.Queue(name="Lock at " + str(coordinate) +
" => left queue in")
self.wait_in[right] = sim.Queue(name="Lock at " + str(coordinate) +
" => right queue in")
self.key_out = sim.Resource(name="Lock at " + str(coordinate) +
" => key out")
def setup(self, v):
self.x = env.x_dis()
self.y = env.y_dis()
self.v = v
self.orders = sim.Queue(self.name() + '.orders')
self.color = ('red', 'blue', 'green', 'purple', 'black',
'pink')[self.sequence_number()]
self.pic_driver = sim.Animate(circle0=10,
x0=self.x,
y0=self.y,
fillcolor0='',
linecolor0=self.color,
linewidth0=2)
def test13():
de=sim.Environment()
q=sim.Queue()
for i in range(10):
c=sim.Component(name='c.')
q.add(c)
print(q)
for c in q:
print (c.name())
for i in range(20):
print(i,q[i].name())
def __init__(self, var_name, env, *args, **kwargs):
"""
extend `sim.Component.__init__()`, override name variable,
setup EntityTracker specific attributes
Args:
var_name (str): name of the entity
env (EnvironmentPlus): salabim_plus simulation environment
*arg, **kwargs: sim.Component specific default attributes
"""
sim.Component.__init__(self, name='track.' + var_name, *args, **kwargs)
# this is the same line of code that is in the EntityGenerator class
self.wip = sim.Queue(
self._name + '_wip'
) # this is defining queues of all these names. they will all be prepended with 'tracker.' because self includes the tracker portion because this function is called by the EntityGenerator
self.complete = sim.Queue(self._name + '_complete')
self.wip_count = sim.State(self._name + '_wip_count', value=0)
self.complete_count = sim.State(self._name + '_complete_count',
value=0)
self.env = env
env.objs[self._name] = self
def __init__(self, system, position=0, direction=0, t_move=10, t_open=2, t_close=2,
t_enter=2, t_exit=2, *args, **kwargs):
sim.Component.__init__(self, *args, **kwargs)
self.position = floors[position] # starting position (level) of the elevator
self.max_load = Elevator.MAX_LOAD
self.occupants = sim.Queue(name=f"occupants in lift")
self.system = Elevator.LOGIC[system]
# simulation constants defaults given
self.direction = direction
self.t_move = t_move
self.t_open = t_open
self.t_close = t_close
self.t_enter = t_enter
self.t_exit = t_exit
# elevator doors start off closed
self.is_open = False
def test6():
print('test6')
class X(sim.Component):
def process(self):
yield self.passivate()
yield self.hold(1)
de=sim.Environment(trace=True)
x=X()
print (x.status()())
q=sim.Queue(name='Queue.')
q.name('Rij.')
print (q.name())
q.clear()
env.run(till=10)
x.reactivate()
env.run()
def __init__(self, var_name, env, *args, **kwargs):
"""
extend `sim.Component.__init__()`, override name variable,
setup Storage specific attributes
Args:
var_name (str): name of the storage location
env (EnvironmentPlus): salabim_plus simulation environment
"""
sim.Component.__init__(self,
name=var_name + '_storage',
*args,
**kwargs)
self.queue = sim.Queue(self._name + '_queue') # storage queue
self.count = sim.State(self._name + '_count',
value=0) # quantity inside storage queue
self.env = env
env.objs[self._name] = self
def __init__(self, var_name, env, kanban_attr, *args, **kwargs):
"""
extend `sim.Component.__init__()`, override name variable,
setup Kanban specific attributes
Args:
var_name (str): name of the kanban storage location
env (EnvironmentPlus): salabim_plus simulation environment
kanban_attr (dict): dictionary mapping out characteristics of the
kanban, must follow standard kanban_attr
dictionary formatting (see kanban_attr
variable documentation)
*arg, **kwargs: sim.Component specific default attributes
"""
sim.Component.__init__(self,
name=var_name + '_kanban',
*args,
**kwargs)
self.order_gen = kanban_attr[
'order_gen'] # EntityGenerator to order entities from
self.order_point = kanban_attr[
'order_point'] # threshold in which an order shall be made
self.order_qty = kanban_attr['order_qty'] # quantity of an order
self.init_qty = kanban_attr[
'init_qty'] # initial quantity to order at beginning of simulation
self.warmup_time = kanban_attr[
'warmup_time'] # time to wait in beginning of simulation before evaluating whether an order should be made
self.queue = sim.Queue(self._name + '_queue') # kanban queue
self.count = sim.State(
self._name + '_count',
value=0) # state indicating how many entities are in kanban queue
self.on_order = sim.State(
self._name + '_on_order',
value=0) # state indicating how many entities are on order
self.total_inv = sim.State(
self._name + '_total_inv',
value=0) # sum of entities on order and entities in kanban queue
self.env = env
env.objs[self._name] = self
def test34():
class X(sim.Component):
def process(self):
try:
yield self.hold(-1)
except sim.SalabimError:
yield self.hold(1)
s1.set(1)
yield self.hold(1)
s1.set(2)
s2.set('red')
yield self.hold(2)
s1.set(30)
class Y(sim.Component):
def process(self):
while True:
yield self.wait((s1,'$==2'))
yield self.hold(1.5)
class Z(sim.Component):
def process(self):
while True:
yield self.wait((s2,'"$" in ("red","yellow")'),all=True)
yield self.hold(1.5)
env=sim.Environment(trace=True)
env.print_info()
s1=sim.State(name='s.',value=0)
s2=sim.State(name='s.',value='green')
s3=sim.State(name='s.')
s1.name('piet')
q=sim.Queue('q.')
x=X()
y=Y()
z=Z()
env.run(10)
s1.print_statistics()
def test44():
import newqueue
import newerqueue
import newcomponent
class X(sim.Component):
def process(self):
yield self.hold(10,mode='ok')
if self == x1:
yield self.passivate()
yield self.hold(10,urgent=True)
class Y(sim.Component):
def setup(self, a='a'):
print('a=',a)
def process(self, text):
print('-->',text)
yield self.request((res, 4), fail_at=15)
x1.activate(mode=5)
env=sim.Environment(trace=True)
res = sim.Resource()
x0=X()
x1=X(name='')
x2=X(name=',')
z=newcomponent.NewComponent()
q0=sim.Queue()
q1=newqueue.NewQueue()
q2=newerqueue.NewerQueue()
Y(process='process', text='Hello')
q0.add(x1)
q1.add(x1)
q2.add(x1)
env.run(50)
env.print_trace_header()
def test31():
class X(sim.Component):
def process(self):
yield self.hold(1)
s1.set()
yield self.hold(2)
s1.reset()
yield self.hold(2)
y.print_info()
s1.trigger()
class Y(sim.Component):
def process(self):
while True:
yield self.wait(s1,(s2,'red'),(s2,'green'),s3)
yield self.hold(1.5)
env=sim.Environment(trace=True)
env.print_info()
s1=sim.State(name='s.')
s2=sim.State(name='s.')
s3=sim.State(name='s.')
q=sim.Queue('q.')
x=X()
y=Y()
env.run(10)
print('value at ',env.now(),s1.get())
print (s1.value.xduration())
print(s1.value.tx())
print(env)
print(y)
print(q)
print(s1)
s1.print_info()
s2.print_info()
