def choose_best_meca_task(tasks, mecanic):
# Task that can be done
filtered_tasks = list(filter(lambda t: t.block.module.can_work(
end_date_calc(max(t.meca_start, mecanic.next_freeTime), datetime.timedelta(minutes=Task.kitting)),
end_date_calc(
max(t.meca_start, mecanic.next_freeTime),
datetime.timedelta(minutes=t.meca + Task.kitting)), State.meca), tasks))
filtered_tasks.sort(key=lambda t: max(t.meca_start, mecanic.next_freeTime))
if len(filtered_tasks) == 0:
return None
# raise Exception
# Order by starttime
return filtered_tasks[0]
def do_meca(self, resource):
self.kitting_start = max(resource.next_freeTime, self.meca_start)
self.state = State.oc
self.kitting_end = end_date_calc(
self.kitting_start, datetime.timedelta(minutes=Task.kitting))
self.meca_start = self.kitting_end
endTime = end_date_calc(self.meca_start,
datetime.timedelta(minutes=self.meca))
self.oc_start = endTime
self.meca_end = endTime
self.block.module.inc(self.meca_start, self.meca_end)
self.meca_resource = resource
resource.next_freeTime = endTime
def best_start(self, start_, duration):
start = start_
index_1 = int((start - self.start).total_seconds() / 60)
end = end_date_calc(start, duration=duration)
index_2 = int((end - self.start).total_seconds() / 60)
i = index_1
while i < index_2:
if self.nb_op[i] == 2:
start = self.start + datetime.timedelta(minutes=i)
end = end_date_calc(start, duration=duration)
#index_1 = int((start - self.start).total_seconds() / 60)
index_2 = int((end - self.start).total_seconds() / 60)
i = i + 1
return start
def do_oc(self, resource):
self.oc_start = max(resource.next_freeTime, self.oc_start)
self.state = State.finished
endTime = end_date_calc(self.oc_start,
datetime.timedelta(minutes=self.oc))
self.oc_end = endTime
resource.next_freeTime = endTime
self.block.module.inc(self.oc_start, endTime)
for t in self.next:
t.pending_prec = t.pending_prec - 1
def choose_best_oc_task(tasks, control):
# Task that can be done
filtered_tasks = list(filter(lambda t: t.block.module.can_work(max(t.oc_start, control.next_freeTime),
end_date_calc(max(t.oc_start, control.next_freeTime),
datetime.timedelta(
minutes=t.oc)), State.oc),
tasks))
filtered_tasks.sort(key=lambda t: max(t.oc_start, control.next_freeTime))
if len(filtered_tasks) == 0:
return None
# raise Exception
# Order by starttime
return filtered_tasks[0]
def solve():
timeOUEST, req_matOUEST, req_taskOUEST = extract_tasks_from_excel(pathOUEST)
timeEST, req_matEST, req_taskEST = extract_tasks_from_excel(pathEST)
add_next2req_task(req_taskEST)
add_next2req_task(req_taskOUEST)
est = Module("EST")
ouest = Module("OUEST")
ms1 = Bloc("MS1")
ms2 = Bloc("MS2")
ms3 = Bloc("MS3")
ms4 = Bloc("MS4")
fov = Bloc("FOV")
gtw = Bloc("GTW")
ouest.addBloc(ms1)
ouest.addBloc(ms4)
ouest.addBloc(gtw)
est.addBloc(ms2)
est.addBloc(ms3)
est.addBloc(fov)
addTask2bloc(timeEST, req_matEST, req_taskEST, ms1, ms2, ms3, ms4, fov, gtw)
addTask2bloc(timeOUEST, req_matOUEST, req_taskOUEST, ms1, ms2, ms3, ms4, fov, gtw)
# for t in gtw.tasks:
# print(t.name, [a.name for a in t.next], [a.name for a in t.previous], t.pending_prec)
# get max_date
max_date = datetime.datetime(year=2018, month=1, day=1)
for i in ms1.tasks + ms2.tasks + ms3.tasks + ms4.tasks + fov.tasks + gtw.tasks:
if i.min_start > max_date:
max_date = i.min_start
max_date = start1_of_date(max_date)
est.start = max_date
ouest.start = max_date
# Init ressources
mecanics = [Resource("r1", Rtype.meca), Resource("r2", Rtype.meca), Resource('r3', Rtype.meca)]
control = Resource("r1", Rtype.oc)
for operator in mecanics:
operator.next_freeTime = max_date
control.next_freeTime = max_date
#
#
# # la liste des tâche à faire
ready_to_do = [ms1.tasks.pop(0), ms2.tasks.pop(0), ms3.tasks.pop(0), ms4.tasks.pop(0),
fov.tasks.pop(0), gtw.tasks.pop(0)]
for t in ready_to_do:
t.meca_start = max(max_date, t.min_start)
t.state = State.meca
i = 0
meca_w = 0
oc_w = 0
solution = []
while len(ready_to_do) != 0:
i = i + 1
# print(i)
# Filter meca resource by next_free_time
mecanics.sort(key=lambda x: x.next_freeTime)
# Try to find a meca task to do
task_found = False
iter = 0
task = None
remaining_meca_tasks = list(filter(lambda x: x.state == State.meca, ready_to_do))
if len(remaining_meca_tasks) > 0:
# print("remaining_meca_tasks " + str(len(remaining_meca_tasks)))
while task is None and iter < len(mecanics):
mecanic = mecanics[iter]
iter = iter + 1
task = choose_best_meca_task(remaining_meca_tasks, mecanic)
# Do meca task found
if task is not None:
task.do_meca(mecanic)
if iter == len(mecanics) and task is None:
# Todo
# print("case except")
for t in remaining_meca_tasks:
t.meca_start = t.block.module.best_start(
end_date_calc(t.meca_start, datetime.timedelta(minutes=Task.kitting)),
datetime.timedelta(minutes=t.meca))
# Try to find an oc task to do
remaining_oc_tasks = list(filter(lambda x: x.state == State.oc, ready_to_do))
if len(remaining_oc_tasks) > 0:
# print("remaining_oc_tasks " + str(len(remaining_oc_tasks)))
task = choose_best_oc_task(remaining_oc_tasks, control)
if task is not None:
task.do_oc(control)
# Ajout des prochaines tâche mais attention 1 tâche peuvent avoir plusieurs précédents
# Dans ce cas ça marche plus
for t in task.next:
if t.pending_prec == 0:
t.meca_start = max(task.oc_end, t.min_start)
ready_to_do.append(t)
t.state = State.meca
# Remove the task done
ready_to_do.remove(task)
solution.append(task)
else:
# print("case except oc")
for t in remaining_oc_tasks:
t.oc_start = t.block.module.best_start(t.oc_start, datetime.timedelta(minutes=t.oc))
for sol in solution:
print(sol)
print("makespan: " + str(makespan(solution)))
print("nb task done : {0}".format(len(solution)))
# Check
est.check()
ouest.check()
return convert_solution_to_df(solution)