include custom_instance_parser and totorial files and further finetuning

Author: RobbertReijnen

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 AI for Decision Making @TU/e
+Copyright (c) 2024 AI for Decision Making @TU/e
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

configs/cp_sat.toml

@@ -3,6 +3,7 @@ problem_instance = "/fjsp/1_Brandimarte/Mk01.fjs"
 
 [solver]
 time_limit = 3600       # time limit for the OR-tools CP-SAT solver, in seconds
+model = "fjsp"          # model to use, either 'jsp', 'fsp', fjsp' or 'fjsp_sdst'
 
 [output]
 show_gantt = true       # draw ganttchart of found solution

data_parsers/custom_instance_parser.py

@@ -0,0 +1,136 @@
+from scheduling_environment.job import Job
+from scheduling_environment.machine import Machine
+from scheduling_environment.operation import Operation
+from scheduling_environment.jobShop import JobShop
+
+
+def parse(processing_info, instance_name="custom_problem_instance"):
+
+    # Initialize JobShop
+    jobShop = JobShop()
+    jobShop.set_instance_name(instance_name)
+
+    # Configure Machines based on nr_machines in processing_info
+    number_total_machines = processing_info["nr_machines"]
+    for machine_id in range(0, number_total_machines):
+        jobShop.add_machine(Machine(machine_id))
+    jobShop.set_nr_of_machines(number_total_machines)
+
+    # Configure jobs, operations, and processing times
+    for job_info in processing_info["jobs"]:
+        job = Job(job_id=job_info["job_id"])
+
+        for operation_info in job_info["operations"]:
+            operation = Operation(job, job_info["job_id"], operation_info["operation_id"])
+
+            # Convert machine names (e.g., "machine_1") to numeric IDs for compatibility
+            for machine_key, processing_time in operation_info["processing_times"].items():
+                machine_id = int(machine_key.split("_")[1])-1
+                operation.add_operation_option(machine_id, processing_time)
+
+            job.add_operation(operation)
+            jobShop.add_operation(operation)
+        jobShop.add_job(job)
+    jobShop.set_nr_of_jobs(len(processing_info["jobs"]))
+
+    # Configure precedence relations between operations
+    precedence_relations = {}
+    for job_info in processing_info["jobs"]:
+        for op_info in job_info["operations"]:
+            if op_info["predecessor"] is not None:
+                operation = jobShop.get_operation(op_info["operation_id"])
+                predecessor_operation = jobShop.get_operation(op_info["predecessor"])
+                operation.add_predecessors([predecessor_operation])
+                precedence_relations[op_info["operation_id"]] = [predecessor_operation]
+            else:
+                precedence_relations[op_info["operation_id"]] = []
+
+    # Configure sequence-dependent setup times for each machine and operation pair
+    setup_times = processing_info["sequence_dependent_setup_times"]
+    sequence_dependent_setup_times = {}
+
+    for machine_key, setup_matrix in setup_times.items():
+        machine_id = int(machine_key.split("_")[1])-1  # Convert machine_1 to machine ID 1
+        machine_setup_times = {}
+
+        # Map the setup times for all pairs of operations
+        for i in range(len(setup_matrix)):
+            for j in range(len(setup_matrix[i])):
+                if i != j:  # Ignore setup times for the same operation (i == j)
+                    if i not in machine_setup_times:
+                        machine_setup_times[i] = {}
+                    machine_setup_times[i][j] = setup_matrix[i][j]
+
+        sequence_dependent_setup_times[machine_id] = machine_setup_times
+
+    # Add the precedence relations and sequence-dependent setup times to the JobShop
+    jobShop.add_precedence_relations_operations(precedence_relations)
+    jobShop.add_sequence_dependent_setup_times(sequence_dependent_setup_times)
+
+    return jobShop
+
+
+if __name__ == "__main__":
+    processing_info = {
+        "instance_name": "custom_problem_instance",
+        "nr_machines": 2,
+        "jobs": [
+            {"job_id": 0, "operations": [
+                {"operation_id": 0, "processing_times": {"machine_1": 10, "machine_2": 20}, "predecessor": None},
+                {"operation_id": 1, "processing_times": {"machine_1": 25, "machine_2": 19}, "predecessor": 0}
+            ]},
+            {"job_id": 1, "operations": [
+                {"operation_id": 2, "processing_times": {"machine_1": 23, "machine_2": 21}, "predecessor": None},
+                {"operation_id": 3, "processing_times": {"machine_1": 12, "machine_2": 24}, "predecessor": 2}
+            ]},
+            {"job_id": 2, "operations": [
+                {"operation_id": 4, "processing_times": {"machine_1": 37, "machine_2": 21}, "predecessor": None},
+                {"operation_id": 5, "processing_times": {"machine_1": 23, "machine_2": 34}, "predecessor": 4}
+            ]}
+        ],
+        "sequence_dependent_setup_times": {
+            "machine_1": [
+                [0, 25, 30, 35, 40, 45],
+                [25, 0, 20, 30, 40, 50],
+                [30, 20, 0, 10, 15, 25],
+                [35, 30, 10, 0, 5, 10],
+                [40, 40, 15, 5, 0, 20],
+                [45, 50, 25, 10, 20, 0]
+            ],
+            "machine_2": [
+                [0, 21, 30, 35, 40, 45],
+                [21, 0, 10, 25, 30, 40],
+                [30, 10, 0, 5, 15, 25],
+                [35, 25, 5, 0, 10, 20],
+                [40, 30, 15, 10, 0, 25],
+                [45, 40, 25, 20, 25, 0]
+            ]
+        }
+    }
+
+    jobShopEnv = parse(processing_info)
+    print('Job shop setup complete')
+
+    # TEST GA:
+    # from solution_methods.GA.src.initialization import initialize_run
+    # from solution_methods.GA.run_GA import run_GA
+    # import multiprocessing
+    #
+    # parameters = {"instance": {"problem_instance": "custom_problem_instance"},
+    #              "algorithm": {"population_size": 8, "ngen": 10, "seed": 5, "indpb": 0.2, "cr": 0.7, "mutiprocessing": True},
+    #              "output": {"logbook": True}
+    #             }
+    #
+    # pool = multiprocessing.Pool()
+    # population, toolbox, stats, hof = initialize_run(jobShopEnv, pool, **parameters)
+    # makespan, jobShopEnv = run_GA(jobShopEnv, population, toolbox, stats, hof, **parameters)
+
+    # TEST CP_SAT:
+    from solution_methods.CP_SAT.run_cp_sat import run_CP_SAT
+    parameters = {"instance": {"problem_instance": "custom_fjsp_sdst"},
+                  "solver": {"time_limit": 3600},
+                  "output": {"logbook": True}
+                  }
+
+    jobShopEnv = parse(processing_info)
+    results, jobShopEnv = run_CP_SAT(jobShopEnv, **parameters)

data_parsers/parser_fajsp.py

@@ -6,7 +6,8 @@
 from scheduling_environment.operation import Operation
 
 
-def parse(JobShop, instance, from_absolute_path=False):
+def parse_fajsp(JobShop, instance, from_absolute_path=False):
+    JobShop.set_instance_name(instance)
     if not from_absolute_path:
         base_path = Path(__file__).parent.parent.absolute()
         data_path = base_path.joinpath('data' + instance)

data_parsers/parser_fjsp.py

@@ -6,7 +6,9 @@
 from scheduling_environment.operation import Operation
 
 
-def parse(JobShop, instance, from_absolute_path=False):
+def parse_fjsp(JobShop, instance, from_absolute_path=False):
+    JobShop.set_instance_name(instance)
+
     if not from_absolute_path:
         base_path = Path(__file__).parent.parent.absolute()
         data_path = base_path.joinpath('data' + instance)
@@ -60,7 +62,7 @@ def parse(JobShop, instance, from_absolute_path=False):
             JobShop.add_job(job)
             job_id += 1
 
-    # add also the operations without precedence operations to the precendence relations dictionary
+    # add also the operations without precedence operations to the precedence relations dictionary
     for operation in JobShop.operations:
         if operation.operation_id not in precedence_relations.keys():
             precedence_relations[operation.operation_id] = []
@@ -81,12 +83,9 @@ def parse(JobShop, instance, from_absolute_path=False):
     return JobShop
 
 
-if __name__ == "__main__":
-    # add the following to top:
-
-    # for running this code locally
-    import sys
-
-    sys.path.append("../Machine_scheduling_benchmarking/")
-
-    JobShop = parse(r"\fjsp\6_Fattahi\MFJS1.fjs", )
+# if __name__ == "__main__":
+#     from scheduling_environment.jobShop import JobShop
+#     jobShopEnv = JobShop()
+#     jobShopEnv = parse_fjsp(jobShopEnv, '/fjsp/1_brandimarte/Mk01.fjs')
+#     jobShopEnv.update_operations_available_for_scheduling()
+#     print(jobShopEnv.operations_available_for_scheduling)

data_parsers/parser_fjsp_sdst.py

@@ -5,7 +5,8 @@
 from scheduling_environment.operation import Operation
 
 
-def parse(JobShop, instance, from_absolute_path=False):
+def parse_fjsp_sdst(JobShop, instance, from_absolute_path=False):
+    JobShop.set_instance_name(instance)
     if not from_absolute_path:
         base_path = Path(__file__).parent.parent.absolute()
         data_path = base_path.joinpath('data' + instance)

data_parsers/parser_jsp_fsp.py

@@ -6,7 +6,8 @@
 from scheduling_environment.operation import Operation
 
 
-def parse(JobShop, instance, from_absolute_path=False):
+def parse_jsp_fsp(JobShop, instance, from_absolute_path=False):
+    JobShop.set_instance_name(instance)
     if not from_absolute_path:
         base_path = Path(__file__).parent.parent.absolute()
         data_path = base_path.joinpath('data' + instance)

plotting/drawer.py

@@ -39,7 +39,7 @@ def create_colormap():
 
 
 # Plot the Gantt chart of the job shop schedule
-def draw_gantt_chart(JobShop, save=False, filename=None):
+def plot_gantt_chart(JobShop, save=False, filename=None):
     fig, ax = plt.subplots()
     colormap = create_colormap()
 
@@ -84,10 +84,10 @@ def draw_gantt_chart(JobShop, save=False, filename=None):
             )
 
     fig = ax.figure
-    fig.set_size_inches(16, 8)
+    fig.set_size_inches(12, 6)
 
     ax.set_yticks(range(JobShop.nr_of_machines))
-    ax.set_yticklabels([f'M{machine_id}' for machine_id in range(JobShop.nr_of_machines)])
+    ax.set_yticklabels([f'M{machine_id+1}' for machine_id in range(JobShop.nr_of_machines)])
     ax.set_xlabel('Time')
     ax.set_ylabel('Machine')
     ax.set_title('Job Shop Scheduling Gantt Chart')

scheduling_environment/job.py

@@ -7,6 +7,11 @@ def __init__(self, job_id: int):
         self._job_id: int = job_id
         self._operations: List[Operation] = []
 
+    def __repr__(self):
+        return (
+            f"<Job(job_id={self._job_id})>"
+        )
+
     def add_operation(self, operation: Operation):
         """Add an operation to the job."""
         self._operations.append(operation)

scheduling_environment/jobShop.py

@@ -19,7 +19,14 @@ def __init__(self) -> None:
         self._operations_to_be_scheduled: List[Operation] = []
         self._operations_available_for_scheduling: List[Operation] = []
         self._scheduled_operations: List[Operation] = []
-        self._name: str = ""
+        self._instance_name: str = ""
+
+    def __repr__(self):
+        return (
+            f"<JobShop(instance={self._instance_name!r}, "
+            f"jobs={self.nr_of_jobs}, operations={self.nr_of_operations}, "
+            f"machines={self.nr_of_machines})>"
+        )
 
     def reset(self):
         self._scheduled_operations = []
@@ -33,8 +40,7 @@ def reset(self):
         for operation in self._operations:
             operation.reset()
 
-    def __str__(self):
-        return f"Instance {self._name}, {self.nr_of_jobs} jobs, {len(self.operations)} operations, {len(self.machines)} machines"
+        self.update_operations_available_for_scheduling()
 
     def set_nr_of_jobs(self, nr_of_jobs: int) -> None:
         """Set the number of jobs."""
@@ -44,6 +50,10 @@ def set_nr_of_machines(self, nr_of_machines: int) -> None:
         """Set the number of jobs."""
         self._nr_of_machines = nr_of_machines
 
+    def set_instance_name(self, name: str) -> None:
+        """Set the name of the instance."""
+        self._instance_name = name
+
     def add_operation(self, operation) -> None:
         """Add an operation to the environment."""
         self._operations_to_be_scheduled.append(operation)
@@ -74,18 +84,25 @@ def set_operations_available_for_scheduling(self, operations_available_for_sched
         self._operations_available_for_scheduling = operations_available_for_scheduling
 
     def get_job(self, job_id):
-        """Return operation object with operation id."""
-        return next((job for job in self.jobs if job.job_id == job_id), None)
+        """Return operation object with operation id, or None if not found."""
+        job = next((job for job in self.jobs if job.job_id == job_id), None)
+        if job is None:
+            raise ValueError(f"No job found with job_id: {job_id}")
+        return job
 
     def get_operation(self, operation_id):
-        """Return operation object with operation id."""
-        return next((operation for operation in self.operations if operation.operation_id == operation_id), None)
+        """Return operation object with operation id, or None if not found."""
+        operation = next((operation for operation in self.operations if operation.operation_id == operation_id), None)
+        if operation is None:
+            raise ValueError(f"No operation found with operation_id: {operation_id}")
+        return operation
 
     def get_machine(self, machine_id):
-        """Return machine object with machine id."""
-        for machine in self._machines:
-            if machine.machine_id == machine_id:
-                return machine
+        """Return machine object with machine id, or None if not found."""
+        machine = next((machine for machine in self._machines if machine.machine_id == machine_id), None)
+        if machine is None:
+            raise ValueError(f"No machine found with machine_id: {machine_id}")
+        return machine
 
     @property
     def jobs(self) -> List[Job]:
@@ -145,7 +162,7 @@ def precedence_relations_jobs(self) -> Dict[int, List[int]]:
     @property
     def instance_name(self) -> str:
         """Return the name of the instance."""
-        return self._name
+        return self._instance_name
 
     @property
     def makespan(self) -> float:
@@ -190,6 +207,14 @@ def max_flowtime(self) -> float:
                 max_flowtime = flow_time
         return max_flowtime
 
+    def schedule_operation_on_machine(self, operation: Operation, machine_id, duration) -> None:
+        """Schedule an operation on a specific machine."""
+        machine = self.get_machine(machine_id)
+        if machine is None:
+            raise ValueError(
+                f"Invalid machine ID {machine_id}")
+        machine.add_operation_to_schedule(operation, duration, self._sequence_dependent_setup_times)
+
     def schedule_operation_with_backfilling(self, operation: Operation, machine_id, duration) -> None:
         """Schedule an operation"""
         if operation not in self.operations_available_for_scheduling:
@@ -208,15 +233,6 @@ def unschedule_operation(self, operation: Operation) -> None:
         machine.unschedule_operation(operation)
         self.mark_operation_as_available(operation)
 
-    def schedule_operation_on_machine(self, operation: Operation, machine_id, duration) -> None:
-        """Schedule an operation on a specific machine."""
-        machine = self.get_machine(machine_id)
-        if machine is None:
-            raise ValueError(
-                f"Invalid machine ID {machine_id}")
-
-        machine.add_operation_to_schedule(operation, duration, self._sequence_dependent_setup_times)
-
     def mark_operation_as_scheduled(self, operation: Operation) -> None:
         """Mark an operation as scheduled."""
         if operation not in self.operations_available_for_scheduling:
@@ -234,3 +250,16 @@ def mark_operation_as_available(self, operation: Operation) -> None:
         self.scheduled_operations.remove(operation)
         self.operations_available_for_scheduling.append(operation)
         self.operations_to_be_scheduled.append(operation)
+
+    def update_operations_available_for_scheduling(self) -> None:
+        """Update the list of operations available for scheduling."""
+        scheduled_operations = set(self.scheduled_operations)
+        operations_available = [
+            operation
+            for operation in self.operations
+            if operation not in scheduled_operations and all(
+                prec_operation in scheduled_operations
+                for prec_operation in self._precedence_relations_operations[operation.operation_id]
+            )
+        ]
+        self.set_operations_available_for_scheduling(operations_available)