Delete OR_tools.py

OR_tools.py

@@ -1,148 +0,0 @@
-# importing required modules
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import pandas as pd
-import chart_studio.plotly as py
-import plotly.figure_factory as ff
-import datetime
-from datetime import timedelta
-import time
-import copy
-
-#importing OR-tools solver
-import collections
-from ortools.sat.python import cp_model
-
-def gantt_for_OR(df,method):
-    title_chart = 'Job shop Schedule - using '+ method
-    fig = ff.create_gantt(df, index_col='Resource', show_colorbar=True, group_tasks=True, showgrid_x=True, title=title_chart)
-    return fig
-
-def or_fn(input_file):
-    xls = pd.ExcelFile(input_file)
-    df1 = pd.read_excel(xls, 'Machines Sequence',index_col = 0)
-    df2 = pd.read_excel(xls, 'Processing Time',index_col = 0)
-    
-    jobs_data =[]
-
-    for ind in df1.index:
-        lists = []
-        for col in df1:
-            lists.append((df1[col][ind],df2[col][ind]))
-        jobs_data.append(lists)
-
-    model = cp_model.CpModel()
-    machines_count = 1 + max(task[0] for job in jobs_data for task in job)
-    all_machines = range(machines_count)
-    # Computes horizon dynamically as the sum of all durations.
-    horizon = sum(task[1] for job in jobs_data for task in job)
-
-    # Named tuple to store information about created variables.
-    task_type = collections.namedtuple('task_type', 'start end interval')
-    # Named tuple to manipulate solution information.
-    assigned_task_type = collections.namedtuple('assigned_task_type',
-                                                'start job index duration')
-
-    # Creates job intervals and add to the corresponding machine lists.
-    all_tasks = {}
-    machine_to_intervals = collections.defaultdict(list)
-
-    for job_id, job in enumerate(jobs_data):
-        for task_id, task in enumerate(job):
-            machine = task[0]
-            duration = task[1]
-            suffix = '_%i_%i' % (job_id, task_id)
-            start_var = model.NewIntVar(0, horizon, 'start' + suffix)
-            end_var = model.NewIntVar(0, horizon, 'end' + suffix)
-            interval_var = model.NewIntervalVar(start_var, duration, end_var,
-                                                'interval' + suffix)
-            all_tasks[job_id, task_id] = task_type(start=start_var,
-                                                end=end_var,
-                                                interval=interval_var)
-            machine_to_intervals[machine].append(interval_var)
-            
-    # Create and add disjunctive constraints.
-    for machine in all_machines:
-        model.AddNoOverlap(machine_to_intervals[machine])
-
-    # Precedences inside a job.
-    for job_id, job in enumerate(jobs_data):
-        for task_id in range(len(job) - 1):
-            model.Add(all_tasks[job_id, task_id +
-                                1].start >= all_tasks[job_id, task_id].end)
-
-    # Makespan objective.
-    obj_var = model.NewIntVar(0, horizon, 'makespan')
-    model.AddMaxEquality(obj_var, [
-        all_tasks[job_id, len(job) - 1].end
-        for job_id, job in enumerate(jobs_data)
-    ])
-    model.Minimize(obj_var)
-
-    start_time = time.time()
-
-    solver = cp_model.CpSolver()
-    status = solver.Solve(model)
-
-    print("--- %s seconds ---" % (time.time() - start_time))
-
-    if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
-        print('Solution:')
-        # Create one list of assigned tasks per machine.
-        assigned_jobs = collections.defaultdict(list)
-        for job_id, job in enumerate(jobs_data):
-            for task_id, task in enumerate(job):
-                machine = task[0]
-                assigned_jobs[machine].append(
-                    assigned_task_type(start=solver.Value(
-                        all_tasks[job_id, task_id].start),
-                                    job=job_id,
-                                    index=task_id,
-                                    duration=task[1]))
-
-        # Create per machine output lines.
-        output = ''
-        for machine in all_machines:
-            # Sort by starting time.
-            assigned_jobs[machine].sort()
-            sol_line_tasks = 'Machine ' + str(machine) + ': '
-            sol_line = '           '
-
-            for assigned_task in assigned_jobs[machine]:
-                name = 'job_%i_task_%i' % (assigned_task.job,
-                                        assigned_task.index)
-                # Add spaces to output to align columns.
-                sol_line_tasks += '%-15s' % name
-
-                start = assigned_task.start
-                duration = assigned_task.duration
-                sol_tmp = '[%i,%i]' % (start, start + duration)
-                # Add spaces to output to align columns.
-                sol_line += '%-15s' % sol_tmp
-
-            sol_line += '\n'
-            sol_line_tasks += '\n'
-            output += sol_line_tasks
-            output += sol_line
-
-        # Finally print the solution found.
-        print(f'Optimal Schedule Length: {solver.ObjectiveValue()}')
-        op = "Optimal Schedule Length : "+ str(solver.ObjectiveValue())
-        #print(output)
-    else:
-        print('No solution found.')
-        op = "No solution found."
-    #Solution df:
-    df = []
-    for machine in all_machines:
-        for task in assigned_jobs[machine]:
-            df.append(dict(Task='Machine %s'%(machine), Start='2020-02-01 %s'%(str(timedelta(seconds=int(task[0])))), \
-                                Finish='2020-02-01 %s'%(str(timedelta(seconds=int(task[0]+task[3])))),Resource='Job %s'%(task[1])))
-
-    method = 'OR Tools'
-    fig = gantt_for_OR(df,method)
-    fig.show()
-    df_data = pd.DataFrame(df)
-    
-    return op,gantt_for_OR(df,method),df_data