class Agent():
def __init__(self,
name,
pose=Pose(),
size=(1.0, 1.0, 1.0),
capabilities=[],
movement_speed=0.1):
# Tuple contain the x,y,z coordinates of the agent
self.pose = pose # Rospy pose data structure, used in Unity to determine space
self.name = name # Name of this particular agent, needs to be unique
self.size = size # the x,y,z size of the agent
self.task_queue = TaskQueue()
self.capabilities = capabilities
self.status = ""
self.current_action = "idle"
self.movement_speed = movement_speed
self.is_at_task = False
self.ros_controller = ROSController()
def get_pose(self):
return self.pose
## TODO, fill in this with a custom message.
def get_message(self):
pass
def add_task(self, task):
self.task_queue.enqueue(task)
def get_task(self):
return self.task_queue.peek()
def set_current_task(self, task):
self.is_at_task = False
self.task_queue.prioritise(task)
def update_status(self):
if self.task_queue.is_empty():
self.status = "%s is idle." % self.name
else:
task_name = self.task_queue.peek().name
self.status = "%s is %s task[ %s ] currently." % (
self.name, self.current_action, task_name)
def get_status(self):
self.update_status()
return self.status
def go_to_current_task(self):
if self.pose.position == self.task_queue.peek().pose.position:
print("Agent %s is currently at the it's current task!" %
self.name)
self.is_at_task = True
return True
self.current_action = "moving to task"
self.move_towards_target(self.task_queue.peek().pose.position)
return False
def move_towards_target(self, target_pos):
target_diff_x = target_pos.x - self.pose.position.x
target_diff_y = target_pos.y - self.pose.position.y
target_diff_z = target_pos.z - self.pose.position.z
self.pose.position.x += self.get_move_vector(target_diff_x)
self.pose.position.y += self.get_move_vector(target_diff_y)
self.pose.position.z += self.get_move_vector(target_diff_z)
direction_y = math.atan2(self.get_move_vector(target_diff_y),
self.get_move_vector(target_diff_x))
quat = quaternion_from_euler(0, direction_y, 0)
self.pose.orientation.x = quat[0]
self.pose.orientation.y = quat[1]
self.pose.orientation.z = quat[2]
self.pose.orientation.w = quat[3]
def get_move_vector(self, target_x):
if abs(target_x) > self.movement_speed:
if target_x < 0:
return -self.movement_speed
else:
return self.movement_speed
return target_x
def complete_current_task(self):
if self.task_queue.peek().is_completed():
print("Current task %s being done by %s has been completed." %
(self.task_queue.peek().name, self.name))
self.ros_controller.publish_string_update_message(
"%s has been completed by %s" %
(self.task_queue.peek().name, self.name))
self.task_queue.dequeue()
self.is_at_task = False
self.current_action = "completed task"
return True
print "Current task %s has not yet been completed by agent %s." % (
self.task_queue.peek().name, self.name)
return False
# OVERRIDE THIS FUNCTION WITH SPECIFIC AGENT FUNCTION
def do_work(self):
pass
class Mediator:
def __init__(self, p1=0.4, p2=0.5, iteration_count=100000):
self.iteration_count = iteration_count
self.task_in_system_count = 0
self.current_tick = 0
self.handled_count = 0
self.refused_count = 0
self.states = []
self.p1 = p1
self.source = Source()
self.queue = TaskQueue(2)
self.handlers = [
Handler(p1, LemerGenerator(209715120, 3, 7)),
Handler(p2, LemerGenerator(209715120, 3, 7))
]
def run(self):
self.queue.tick()
for i in range(self.iteration_count):
self.tick()
counter = Counter(self.states)
for key in counter.keys():
counter[key] = counter[key] / self.iteration_count
print('P{0} = {1}'.format(key, counter[key]))
Loch = self.queue.sum_of_sizes / self.iteration_count
Lc = self.task_in_system_count / self.iteration_count
A = self.handled_count / self.iteration_count
Кkan2 = self.handlers[1].total_task_count / self.iteration_count
print()
print('Potk = {0}'.format(self.refused_count /
self.source.total_task_count))
print('Pбл = 0')
print('Loch = {0}'.format(Loch))
print('Lc = {0}'.format(Lc))
print('Q = {0}'.format(self.handled_count /
self.source.total_task_count))
print('A = {0}'.format(A))
print('Woch = {0}'.format(Loch / A))
# print('Wc = {0}'.format(Lc/A))
print('Wc = {0}'.format(1 / (1 - self.p1) + (Loch + Кkan2) / A))
print('Ккан1 = {0}'.format(self.handlers[0].total_task_count /
self.iteration_count))
print('Ккан2 = {0}'.format(Кkan2))
def tick(self):
self.current_tick += 1
handler_result = self.handlers[1].tick()
if handler_result is not None:
self.handled_count += 1
if len(self.queue) > 0:
task = self.queue.dequeue()
self.handlers[1].set_task(task)
handler_result = self.handlers[0].tick()
if handler_result is not None:
if not self.handlers[1].is_busy():
self.handlers[1].set_task(handler_result)
else:
if self.queue.has_place():
self.queue.enqueue(handler_result)
else:
self.refused_count += 1
source_result = self.source.tick()
if source_result is not None:
if not self.handlers[0].is_busy():
self.handlers[0].set_task(source_result)
else:
self.refused_count += 1
self.queue.tick()
state = '{0}{1}{2}{3}'.format(str(self.source), str(self.handlers[0]),
str(self.queue), str(self.handlers[1]))
self.states.append(state)
self.task_in_system_count += len(self.queue) + len(
self.handlers[0]) + len(self.handlers[1])
class Mediator:
def __init__(self, p=0.75, p1=0.8, p2=0.5, iteration_count=100000):
self.current_tick = 0
self.handled_tasks = []
self.states = []
self.iteration_count = iteration_count
self.busy_count = 0
self.source = Source(p, LemerGenerator(209715120, 3, 7))
self.queue = TaskQueue(2)
self.handlers = [
Handler(p1, LemerGenerator(209715120, 3, 7)),
Handler(p2, LemerGenerator(209715120, 3, 7))
]
def run(self):
for i in range(self.iteration_count):
self.tick()
state_count = len(self.states)
counter = Counter(self.states)
for key in counter.keys():
counter[key] = counter[key] / state_count
print('P {0} = {1}'.format(key, counter[key]))
print('Loch = {0}'.format(self.queue.sum_of_sizes / len(self.states)))
print('A = {0}'.format(len(self.handled_tasks) / len(self.states)))
print('Kkan = {0}'.format(self.busy_count / len(self.states)))
def tick(self):
self.current_tick += 1
for handler in self.handlers:
handler_result = handler.tick()
if handler_result is not None:
self.handled_tasks.append(handler_result)
for handler in self.handlers:
if len(self.queue) == 0:
break
if not handler.is_busy():
task = self.queue.dequeue()
handler.set_task(task)
if not self.source.blocked:
source_result = self.source.tick()
if source_result is not None:
if self.queue.has_place():
self.queue.enqueue(source_result)
else:
self.source.block(source_result)
else:
if self.queue.has_place():
task = self.source.unblock()
self.queue.enqueue(task)
for handler in self.handlers:
if len(self.queue) == 0:
break
if not handler.is_busy():
task = self.queue.dequeue()
handler.set_task(task)
self.queue.tick()
if self.handlers[0].is_busy():
self.busy_count += 1
elif self.handlers[1].is_busy():
self.busy_count += 1
state = '{0}{1}{2}'.format(
str(self.source), str(self.queue),
''.join(map(lambda h: str(h), self.handlers)))
self.states.append(state)
