Update objective_engine.py

objective_engine.py

@@ -1,31 +1,13 @@
 # objective_engine.py
 
-"""
-This module implements the ObjectiveEngine for the VTU Automated Timetable Generator.
-It handles ONLY SOFT CONSTRAINTS by adding weighted penalties to the solver's objective function.
-
-Responsibilities:
-- Define penalties for undesirable schedules (e.g., gaps, late core classes).
-- Create auxiliary variables to calculate complex metrics (like daily span).
-- Sum all weighted penalties and set the Minimization objective.
-
-This module is optional and pluggable. It does not enforce hard rules.
-"""
-
-from typing import List, Dict
-from ortools.sat.python import cp_model
 from collections import defaultdict
-
-# Import project-specific modules
-from models import Task, Faculty, Section, Room, SubjectType
-import constants as const
-# Type hint for the ConstraintEngine
+from typing import List, Dict, Any
+from ortools.sat.python import cp_model
+from models import Task, Faculty, Section, SubjectType
 from constraint_engine import ConstraintEngine
+import constants as const
 
 class ObjectiveEngine:
-    """
-    Manages soft constraints and the optimization objective.
-    """
     def __init__(
         self,
         model: cp_model.CpModel,
@@ -33,20 +15,15 @@ class ObjectiveEngine:
         tasks: List[Task],
         faculties: List[Faculty],
         sections: List[Section],
-        rooms: List[Room],
+        rooms: List[Any],
         weights: Dict[str, int] = None
     ):
-        """
-        Initializes the ObjectiveEngine.
-        """
         self.model = model
         self.ce = constraint_engine
         self.tasks = tasks
         self.faculties = faculties
         self.sections = sections
-        self.rooms = rooms
-
-        # Default weights if none provided
+        
         self.weights = weights or {
             "subject_repetition": 10,
             "morning_core": 5,
@@ -56,12 +33,33 @@ class ObjectiveEngine:
             "isolated_afternoon": 100,
             "campus_movement": 3,
             "faculty_load_balance": 1,
-            "no_first_hour_free": 0, # Disabled intentionally
+            "no_first_hour_free": 0,
             "pack_morning": 50,
             "avoid_late_afternoon": 40
         }
         
         self.penalties: List[cp_model.IntVar] = []
+        
+        # Precompute common variables for extreme efficiency
+        self.t_day = {}
+        self.t_dstart = {}
+        self.t_dend = {}
+        
+        for task in self.tasks:
+            start_var = self.ce.task_vars[task.task_id][0]
+            
+            day = self.model.NewIntVar(0, const.NUM_WORKING_DAYS - 1, f"t_{task.task_id}_day")
+            self.model.AddDivisionEquality(day, start_var, const.NUM_TEACHING_SLOTS_PER_DAY)
+            self.t_day[task.task_id] = day
+            
+            d_start = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY - 1, f"t_{task.task_id}_dstart")
+            self.model.AddModuloEquality(d_start, start_var, const.NUM_TEACHING_SLOTS_PER_DAY)
+            self.t_dstart[task.task_id] = d_start
+            
+            # Note: End slot could reach NUM_TEACHING_SLOTS_PER_DAY (which means it ends at the very end of the day)
+            d_end = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"t_{task.task_id}_dend")
+            self.model.Add(d_end == d_start + task.duration)
+            self.t_dend[task.task_id] = d_end
 
     def build_objective(self):
         """
@@ -90,14 +88,9 @@ class ObjectiveEngine:
             self.model.Minimize(0)
 
     def _minimize_subject_repetition(self):
-        """
-        Penalizes scheduling the same theory subject multiple times on the same day
-        for a specific section.
-        """
         weight = self.weights.get("subject_repetition", 0)
         if weight == 0: return
 
-        # Group tasks by (section, subject)
         tasks_by_sec_sub = {}
         for task in self.tasks:
             if task.subject.subject_type == SubjectType.THEORY:
@@ -107,52 +100,32 @@ class ObjectiveEngine:
                 tasks_by_sec_sub[key].append(task)
 
         for (sec_id, sub_code), subject_tasks in tasks_by_sec_sub.items():
-            if len(subject_tasks) < 2:
-                continue
+            if len(subject_tasks) < 2: continue
 
-            # Compare every pair
             for i in range(len(subject_tasks)):
                 for j in range(i + 1, len(subject_tasks)):
                     t1 = subject_tasks[i]
                     t2 = subject_tasks[j]
                     
-                    start_var_1 = self.ce.task_vars[t1.task_id][0]
-                    start_var_2 = self.ce.task_vars[t2.task_id][0]
-
-                    # Create variables representing the day index (0-4)
-                    day_1 = self.model.NewIntVar(0, const.NUM_WORKING_DAYS - 1, f"day_{t1.task_id}")
-                    day_2 = self.model.NewIntVar(0, const.NUM_WORKING_DAYS - 1, f"day_{t2.task_id}")
+                    day_1 = self.t_day[t1.task_id]
+                    day_2 = self.t_day[t2.task_id]
 
-                    # Helper: day = start_slot // slots_per_day
-                    self.model.AddDivisionEquality(day_1, start_var_1, const.NUM_TEACHING_SLOTS_PER_DAY)
-                    self.model.AddDivisionEquality(day_2, start_var_2, const.NUM_TEACHING_SLOTS_PER_DAY)
-
-                    # Reify: are they on the same day?
                     same_day = self.model.NewBoolVar(f"same_day_{t1.task_id}_{t2.task_id}")
                     self.model.Add(day_1 == day_2).OnlyEnforceIf(same_day)
                     self.model.Add(day_1 != day_2).OnlyEnforceIf(same_day.Not())
 
-                    # Add penalty
                     self.penalties.append(same_day * weight)
 
     def _prioritize_morning_core_subjects(self):
-        """
-        Penalizes Core subjects if they are scheduled after the lunch break.
-        """
         weight = self.weights.get("morning_core", 0)
         if weight == 0: return
 
-        # Assume slots 0-3 are morning, 4-7 are afternoon
         afternoon_start_index = 4 
 
         for task in self.tasks:
             if task.subject.is_core and task.subject.subject_type == SubjectType.THEORY:
-                start_var = self.ce.task_vars[task.task_id][0]
-                
-                daily_slot = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY - 1, f"daily_slot_{task.task_id}")
-                self.model.AddModuloEquality(daily_slot, start_var, const.NUM_TEACHING_SLOTS_PER_DAY)
+                daily_slot = self.t_dstart[task.task_id]
 
-                # Penalty if daily_slot >= afternoon_start_index
                 is_afternoon = self.model.NewBoolVar(f"is_afternoon_{task.task_id}")
                 self.model.Add(daily_slot >= afternoon_start_index).OnlyEnforceIf(is_afternoon)
                 self.model.Add(daily_slot < afternoon_start_index).OnlyEnforceIf(is_afternoon.Not())
@@ -160,9 +133,6 @@ class ObjectiveEngine:
                 self.penalties.append(is_afternoon * weight)
 
     def _avoid_late_heavy_subjects(self):
-        """
-        Penalizes Heavy subjects if they are scheduled in the very last slot of the day.
-        """
         weight = self.weights.get("late_heavy", 0)
         if weight == 0: return
 
@@ -170,11 +140,8 @@ class ObjectiveEngine:
 
         for task in self.tasks:
             if task.subject.is_heavy:
-                start_var = self.ce.task_vars[task.task_id][0]
+                daily_slot = self.t_dstart[task.task_id]
                 
-                daily_slot = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY - 1, f"daily_slot_heavy_{task.task_id}")
-                self.model.AddModuloEquality(daily_slot, start_var, const.NUM_TEACHING_SLOTS_PER_DAY)
-
                 is_last_slot = self.model.NewBoolVar(f"is_last_slot_{task.task_id}")
                 self.model.Add(daily_slot == last_slot_index).OnlyEnforceIf(is_last_slot)
                 self.model.Add(daily_slot != last_slot_index).OnlyEnforceIf(is_last_slot.Not())
@@ -198,52 +165,37 @@ class ObjectiveEngine:
             if not f_tasks: continue
 
             for day in range(const.NUM_WORKING_DAYS):
-                slot_occupied = []
-                for s in range(const.NUM_TEACHING_SLOTS_PER_DAY):
-                    abs_slot = day * const.NUM_TEACHING_SLOTS_PER_DAY + s
+                min_start_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"fac_{faculty_id}_min_s_d{day}")
+                max_end_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"fac_{faculty_id}_max_e_d{day}")
+                
+                start_vars = [const.NUM_TEACHING_SLOTS_PER_DAY]
+                end_vars = [0]
+                total_duration = 0
+                
+                for task in f_tasks:
+                    is_on_day = self.model.NewBoolVar(f"fac_{faculty_id}_on_d{day}_t{task.task_id}")
+                    t_day = self.t_day[task.task_id]
+                    self.model.Add(t_day == day).OnlyEnforceIf(is_on_day)
+                    self.model.Add(t_day != day).OnlyEnforceIf(is_on_day.Not())
                     
-                    task_covers = []
-                    for task in f_tasks:
-                        covers = self.model.NewBoolVar(f"fac_{faculty_id}_covers_{abs_slot}_{task.task_id}")
-                        start_var = self.ce.task_vars[task.task_id][0]
-                        min_start = max(abs_slot - task.duration + 1, day * const.NUM_TEACHING_SLOTS_PER_DAY)
-                        max_start = abs_slot
-                        
-                        eq_lits = []
-                        for p in range(min_start, max_start + 1):
-                            is_p = self.model.NewBoolVar(f"fac_{faculty_id}_t_{task.task_id}_s_{p}")
-                            self.model.Add(start_var == p).OnlyEnforceIf(is_p)
-                            self.model.Add(start_var != p).OnlyEnforceIf(is_p.Not())
-                            eq_lits.append(is_p)
-                            
-                        self.model.AddBoolOr(eq_lits).OnlyEnforceIf(covers)
-                        for lit in eq_lits:
-                            self.model.AddImplication(covers.Not(), lit.Not())
-                            
-                        task_covers.append(covers)
-                        
-                    is_occupied = self.model.NewBoolVar(f"fac_{faculty_id}_occ_{abs_slot}")
-                    self.model.AddBoolOr(task_covers).OnlyEnforceIf(is_occupied)
-                    for lit in task_covers:
-                        self.model.AddImplication(is_occupied.Not(), lit.Not())
-                        
-                    slot_occupied.append(is_occupied)
+                    start_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, "")
+                    self.model.Add(start_on_day == self.t_dstart[task.task_id]).OnlyEnforceIf(is_on_day)
+                    self.model.Add(start_on_day == const.NUM_TEACHING_SLOTS_PER_DAY).OnlyEnforceIf(is_on_day.Not())
+                    start_vars.append(start_on_day)
                     
-                for s in range(1, const.NUM_TEACHING_SLOTS_PER_DAY - 1):
-                    has_before = self.model.NewBoolVar(f"fac_{faculty_id}_before_{day}_{s}")
-                    self.model.AddBoolOr(slot_occupied[:s]).OnlyEnforceIf(has_before)
-                    for lit in slot_occupied[:s]:
-                        self.model.AddImplication(has_before.Not(), lit.Not())
-                        
-                    has_after = self.model.NewBoolVar(f"fac_{faculty_id}_after_{day}_{s}")
-                    self.model.AddBoolOr(slot_occupied[s+1:]).OnlyEnforceIf(has_after)
-                    for lit in slot_occupied[s+1:]:
-                        self.model.AddImplication(has_after.Not(), lit.Not())
-                        
-                    is_gap = self.model.NewBoolVar(f"fac_{faculty_id}_is_gap_{day}_{s}")
-                    self.model.AddBoolAnd([slot_occupied[s].Not(), has_before, has_after]).OnlyEnforceIf(is_gap)
+                    end_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, "")
+                    self.model.Add(end_on_day == self.t_dend[task.task_id]).OnlyEnforceIf(is_on_day)
+                    self.model.Add(end_on_day == 0).OnlyEnforceIf(is_on_day.Not())
+                    end_vars.append(end_on_day)
                     
-                    self.penalties.append(is_gap * weight)
+                    total_duration += task.duration * is_on_day
+                    
+                self.model.AddMinEquality(min_start_on_day, start_vars)
+                self.model.AddMaxEquality(max_end_on_day, end_vars)
+                
+                gap = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"fac_{faculty_id}_gap_d{day}")
+                self.model.AddMaxEquality(gap, [0, max_end_on_day - min_start_on_day - total_duration])
+                self.penalties.append(gap * weight)
 
     def _minimize_student_gaps(self):
         weight = self.weights.get("student_gaps", 100)
@@ -257,62 +209,43 @@ class ObjectiveEngine:
             if not s_tasks: continue
 
             for day in range(const.NUM_WORKING_DAYS):
-                slot_occupied = []
-                for s in range(const.NUM_TEACHING_SLOTS_PER_DAY):
-                    abs_slot = day * const.NUM_TEACHING_SLOTS_PER_DAY + s
+                min_start_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"sec_{sec_id}_min_s_d{day}")
+                max_end_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"sec_{sec_id}_max_e_d{day}")
+                
+                start_vars = [const.NUM_TEACHING_SLOTS_PER_DAY]
+                end_vars = [0]
+                total_duration = 0
+                
+                for task in s_tasks:
+                    is_on_day = self.model.NewBoolVar(f"sec_{sec_id}_on_d{day}_t{task.task_id}")
+                    t_day = self.t_day[task.task_id]
+                    self.model.Add(t_day == day).OnlyEnforceIf(is_on_day)
+                    self.model.Add(t_day != day).OnlyEnforceIf(is_on_day.Not())
+                    
+                    start_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, "")
+                    self.model.Add(start_on_day == self.t_dstart[task.task_id]).OnlyEnforceIf(is_on_day)
+                    self.model.Add(start_on_day == const.NUM_TEACHING_SLOTS_PER_DAY).OnlyEnforceIf(is_on_day.Not())
+                    start_vars.append(start_on_day)
                     
-                    task_covers = []
-                    for task in s_tasks:
-                        covers = self.model.NewBoolVar(f"sec_{sec_id}_covers_{abs_slot}_{task.task_id}")
-                        start_var = self.ce.task_vars[task.task_id][0]
-                        min_start = max(abs_slot - task.duration + 1, day * const.NUM_TEACHING_SLOTS_PER_DAY)
-                        max_start = abs_slot
-                        
-                        eq_lits = []
-                        for p in range(min_start, max_start + 1):
-                            is_p = self.model.NewBoolVar(f"sec_{sec_id}_t_{task.task_id}_s_{p}")
-                            self.model.Add(start_var == p).OnlyEnforceIf(is_p)
-                            self.model.Add(start_var != p).OnlyEnforceIf(is_p.Not())
-                            eq_lits.append(is_p)
-                            
-                        self.model.AddBoolOr(eq_lits).OnlyEnforceIf(covers)
-                        for lit in eq_lits:
-                            self.model.AddImplication(covers.Not(), lit.Not())
-                            
-                        task_covers.append(covers)
-                        
-                    is_occupied = self.model.NewBoolVar(f"sec_{sec_id}_occ_{abs_slot}")
-                    self.model.AddBoolOr(task_covers).OnlyEnforceIf(is_occupied)
-                    for lit in task_covers:
-                        self.model.AddImplication(is_occupied.Not(), lit.Not())
-                        
-                    slot_occupied.append(is_occupied)
+                    end_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, "")
+                    self.model.Add(end_on_day == self.t_dend[task.task_id]).OnlyEnforceIf(is_on_day)
+                    self.model.Add(end_on_day == 0).OnlyEnforceIf(is_on_day.Not())
+                    end_vars.append(end_on_day)
                     
-                for s in range(1, const.NUM_TEACHING_SLOTS_PER_DAY - 1):
-                    has_before = self.model.NewBoolVar(f"sec_{sec_id}_before_{day}_{s}")
-                    self.model.AddBoolOr(slot_occupied[:s]).OnlyEnforceIf(has_before)
-                    for lit in slot_occupied[:s]:
-                        self.model.AddImplication(has_before.Not(), lit.Not())
-                        
-                    has_after = self.model.NewBoolVar(f"sec_{sec_id}_after_{day}_{s}")
-                    self.model.AddBoolOr(slot_occupied[s+1:]).OnlyEnforceIf(has_after)
-                    for lit in slot_occupied[s+1:]:
-                        self.model.AddImplication(has_after.Not(), lit.Not())
-                        
-                    is_gap = self.model.NewBoolVar(f"sec_{sec_id}_is_gap_{day}_{s}")
-                    self.model.AddBoolAnd([slot_occupied[s].Not(), has_before, has_after]).OnlyEnforceIf(is_gap)
+                    total_duration += task.duration * is_on_day
                     
-                    self.penalties.append(is_gap * weight)
+                self.model.AddMinEquality(min_start_on_day, start_vars)
+                self.model.AddMaxEquality(max_end_on_day, end_vars)
+                
+                gap = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"sec_{sec_id}_gap_d{day}")
+                self.model.AddMaxEquality(gap, [0, max_end_on_day - min_start_on_day - total_duration])
+                self.penalties.append(gap * weight)
 
     def _penalize_isolated_afternoon_classes(self):
-        """
-        Penalizes sections having only 1 or 2 classes (slots) after lunch.
-        Students would rather have either no afternoon classes or a full afternoon.
-        """
         weight = self.weights.get("isolated_afternoon", 10)
         if weight == 0: return
 
-        afternoon_start_index = 4 # Index for slots after lunch
+        afternoon_start_index = 4 
         
         tasks_by_section = defaultdict(list)
         for task in self.tasks:
@@ -323,13 +256,8 @@ class ObjectiveEngine:
                 afternoon_duration_sum = []
                 
                 for task in s_tasks:
-                    start_var = self.ce.task_vars[task.task_id][0]
-                    
-                    daily_slot = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY - 1, f"daily_slot_{task.task_id}_{day}")
-                    self.model.AddModuloEquality(daily_slot, start_var, const.NUM_TEACHING_SLOTS_PER_DAY)
-                    
-                    t_day = self.model.NewIntVar(0, const.NUM_WORKING_DAYS - 1, f"t_day_{task.task_id}_aft_{day}")
-                    self.model.AddDivisionEquality(t_day, start_var, const.NUM_TEACHING_SLOTS_PER_DAY)
+                    daily_slot = self.t_dstart[task.task_id]
+                    t_day = self.t_day[task.task_id]
                     
                     is_on_day = self.model.NewBoolVar(f"is_on_day_{task.task_id}_{day}_aft")
                     self.model.Add(t_day == day).OnlyEnforceIf(is_on_day)
@@ -339,7 +267,6 @@ class ObjectiveEngine:
                     self.model.Add(daily_slot >= afternoon_start_index).OnlyEnforceIf(is_afternoon)
                     self.model.Add(daily_slot < afternoon_start_index).OnlyEnforceIf(is_afternoon.Not())
 
-                    # Task is on this day AND in the afternoon
                     is_on_day_and_afternoon = self.model.NewBoolVar(f"is_on_day_and_afternoon_{task.task_id}_{day}")
                     self.model.AddBoolAnd([is_on_day, is_afternoon]).OnlyEnforceIf(is_on_day_and_afternoon)
                     
@@ -348,88 +275,73 @@ class ObjectiveEngine:
                     self.model.Add(dur_term == 0).OnlyEnforceIf(is_on_day_and_afternoon.Not())
                     
                     afternoon_duration_sum.append(dur_term)
-                    
-                total_afternoon_dur = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"tot_aft_dur_{sec_id}_{day}")
-                if afternoon_duration_sum:
-                    self.model.Add(total_afternoon_dur == sum(afternoon_duration_sum))
-                else:
-                    self.model.Add(total_afternoon_dur == 0)
-                    
-                # We want to penalize if total_afternoon_dur is 1 or 2.
-                is_dur_1 = self.model.NewBoolVar(f"is_dur_1_{sec_id}_{day}")
-                self.model.Add(total_afternoon_dur == 1).OnlyEnforceIf(is_dur_1)
-                self.model.Add(total_afternoon_dur != 1).OnlyEnforceIf(is_dur_1.Not())
-
-                is_dur_2 = self.model.NewBoolVar(f"is_dur_2_{sec_id}_{day}")
-                self.model.Add(total_afternoon_dur == 2).OnlyEnforceIf(is_dur_2)
-                self.model.Add(total_afternoon_dur != 2).OnlyEnforceIf(is_dur_2.Not())
-
-                is_isolated = self.model.NewBoolVar(f"is_isolated_{sec_id}_{day}")
-                self.model.AddBoolOr([is_dur_1, is_dur_2]).OnlyEnforceIf(is_isolated)
-                self.model.AddBoolAnd([is_dur_1.Not(), is_dur_2.Not()]).OnlyEnforceIf(is_isolated.Not())
+
+                total_aft_duration = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"total_aft_dur_sec{sec_id}_d{day}")
+                self.model.Add(total_aft_duration == sum(afternoon_duration_sum))
+
+                is_isolated = self.model.NewBoolVar(f"is_isolated_aft_sec{sec_id}_d{day}")
+                
+                is_gt_0 = self.model.NewBoolVar(f"aft_gt_0_sec{sec_id}_d{day}")
+                self.model.Add(total_aft_duration > 0).OnlyEnforceIf(is_gt_0)
+                self.model.Add(total_aft_duration == 0).OnlyEnforceIf(is_gt_0.Not())
+                
+                is_le_2 = self.model.NewBoolVar(f"aft_le_2_sec{sec_id}_d{day}")
+                self.model.Add(total_aft_duration <= 2).OnlyEnforceIf(is_le_2)
+                self.model.Add(total_aft_duration > 2).OnlyEnforceIf(is_le_2.Not())
+
+                self.model.AddBoolAnd([is_gt_0, is_le_2]).OnlyEnforceIf(is_isolated)
                 
                 self.penalties.append(is_isolated * weight)
 
     def _minimize_campus_movement(self):
-        """
-        Penalizes consecutive tasks for a section that are in different buildings.
-        """
-        weight = self.weights.get("campus_movement", 0)
+        weight = self.weights.get("campus_movement", 3)
         if weight == 0: return
-        
-        unique_buildings = sorted(list(set(r.building for r in self.rooms)))
-        building_to_id = {b: i for i, b in enumerate(unique_buildings)}
-        room_idx_to_building_id = [building_to_id[r.building] for r in self.rooms]
 
         tasks_by_section = defaultdict(list)
         for task in self.tasks:
             tasks_by_section[task.section.section_id].append(task)
-
-        for sec_id, sec_tasks in tasks_by_section.items():
-            if len(sec_tasks) < 2: continue
             
-            for i in range(len(sec_tasks)):
-                for j in range(len(sec_tasks)):
-                    if i == j: continue
-                    t1 = sec_tasks[i]
-                    t2 = sec_tasks[j]
-
-                    t1_end = self.ce.task_vars[t1.task_id][1]
-                    t2_start = self.ce.task_vars[t2.task_id][0]
+        for sec_id, s_tasks in tasks_by_section.items():
+            if len(s_tasks) < 2: continue
+            
+            for i in range(len(s_tasks)):
+                for j in range(i + 1, len(s_tasks)):
+                    t1 = s_tasks[i]
+                    t2 = s_tasks[j]
                     
-                    is_consecutive = self.model.NewBoolVar(f"consec_{t1.task_id}_{t2.task_id}")
-                    self.model.Add(t1_end == t2_start).OnlyEnforceIf(is_consecutive)
-                    self.model.Add(t1_end != t2_start).OnlyEnforceIf(is_consecutive.Not())
-
-                    b1_var = self.model.NewIntVar(0, len(unique_buildings), f"bld_{t1.task_id}")
-                    b2_var = self.model.NewIntVar(0, len(unique_buildings), f"bld_{t2.task_id}")
+                    start1 = self.ce.task_vars[t1.task_id][0]
+                    end1 = self.ce.task_vars[t1.task_id][1]
+                    room1 = self.ce.task_vars[t1.task_id][3]
                     
-                    room_var_1 = self.ce.task_vars[t1.task_id][3]
-                    room_var_2 = self.ce.task_vars[t2.task_id][3]
-
-                    self.model.AddElement(room_var_1, room_idx_to_building_id, b1_var)
-                    self.model.AddElement(room_var_2, room_idx_to_building_id, b2_var)
-
-                    diff_building = self.model.NewBoolVar(f"diff_bld_{t1.task_id}_{t2.task_id}")
-                    self.model.Add(b1_var != b2_var).OnlyEnforceIf(diff_building)
-                    self.model.Add(b1_var == b2_var).OnlyEnforceIf(diff_building.Not())
-
-                    penalty_active = self.model.NewBoolVar(f"move_pen_{t1.task_id}_{t2.task_id}")
-                    self.model.AddBoolAnd([is_consecutive, diff_building]).OnlyEnforceIf(penalty_active)
+                    start2 = self.ce.task_vars[t2.task_id][0]
+                    end2 = self.ce.task_vars[t2.task_id][1]
+                    room2 = self.ce.task_vars[t2.task_id][3]
+                    
+                    is_consecutive_1_2 = self.model.NewBoolVar(f"cons_{t1.task_id}_{t2.task_id}")
+                    self.model.Add(end1 == start2).OnlyEnforceIf(is_consecutive_1_2)
+                    self.model.Add(end1 != start2).OnlyEnforceIf(is_consecutive_1_2.Not())
                     
-                    self.penalties.append(penalty_active * weight)
+                    is_consecutive_2_1 = self.model.NewBoolVar(f"cons_{t2.task_id}_{t1.task_id}")
+                    self.model.Add(end2 == start1).OnlyEnforceIf(is_consecutive_2_1)
+                    self.model.Add(end2 != start1).OnlyEnforceIf(is_consecutive_2_1.Not())
+                    
+                    are_consecutive = self.model.NewBoolVar(f"are_cons_{t1.task_id}_{t2.task_id}")
+                    self.model.AddBoolOr([is_consecutive_1_2, is_consecutive_2_1]).OnlyEnforceIf(are_consecutive)
+                    self.model.AddBoolAnd([is_consecutive_1_2.Not(), is_consecutive_2_1.Not()]).OnlyEnforceIf(are_consecutive.Not())
+                    
+                    same_room = self.model.NewBoolVar(f"same_room_{t1.task_id}_{t2.task_id}")
+                    self.model.Add(room1 == room2).OnlyEnforceIf(same_room)
+                    self.model.Add(room1 != room2).OnlyEnforceIf(same_room.Not())
+                    
+                    move_penalty = self.model.NewBoolVar(f"move_{t1.task_id}_{t2.task_id}")
+                    self.model.AddBoolAnd([are_consecutive, same_room.Not()]).OnlyEnforceIf(move_penalty)
+                    
+                    self.penalties.append(move_penalty * weight)
 
     def _penalize_first_hour_free(self):
-        # DISABLED: This constraint forces the solver to place classes at 8:45 every day to avoid a penalty. 
-        # Since sections don't always have enough classes to fill all 5 days completely, forcing a class 
-        # at the start of every day causes the remaining classes to be scattered, leading to unavoidable gaps!
         pass
 
     def _penalize_empty_morning_slots(self):
-        """
-        Penalizes any empty slot in the first 4 hours (slots 0, 1, 2, 3) for students.
-        This forces the solver to pack classes tightly into the morning.
-        """
         weight = self.weights.get("pack_morning", 50)
         if weight == 0: return
 
@@ -440,81 +352,43 @@ class ObjectiveEngine:
         for sec_id, s_tasks in tasks_by_section.items():
             if not s_tasks: continue
 
-            for day in range(const.NUM_WORKING_DAYS):
-                for s in range(4): # 0, 1, 2, 3
-                    abs_slot = day * const.NUM_TEACHING_SLOTS_PER_DAY + s
-                    
-                    task_covers = []
-                    for task in s_tasks:
-                        covers = self.model.NewBoolVar(f"sec_{sec_id}_m_covers_{abs_slot}_{task.task_id}")
-                        start_var = self.ce.task_vars[task.task_id][0]
-                        min_start = max(abs_slot - task.duration + 1, day * const.NUM_TEACHING_SLOTS_PER_DAY)
-                        max_start = abs_slot
-                        
-                        eq_lits = []
-                        for p in range(min_start, max_start + 1):
-                            is_p = self.model.NewBoolVar(f"sec_{sec_id}_m_t_{task.task_id}_s_{p}")
-                            self.model.Add(start_var == p).OnlyEnforceIf(is_p)
-                            self.model.Add(start_var != p).OnlyEnforceIf(is_p.Not())
-                            eq_lits.append(is_p)
-                            
-                        self.model.AddBoolOr(eq_lits).OnlyEnforceIf(covers)
-                        for lit in eq_lits:
-                            self.model.AddImplication(covers.Not(), lit.Not())
-                            
-                        task_covers.append(covers)
-                        
-                    is_occupied = self.model.NewBoolVar(f"sec_{sec_id}_m_occ_{abs_slot}")
-                    self.model.AddBoolOr(task_covers).OnlyEnforceIf(is_occupied)
-                    for lit in task_covers:
-                        self.model.AddImplication(is_occupied.Not(), lit.Not())
-                        
-                    # Penalize if NOT occupied
-                    self.penalties.append(is_occupied.Not() * weight)
+            morning_overlaps = []
+            for task in s_tasks:
+                d_start = self.t_dstart[task.task_id]
+                d_end = self.t_dend[task.task_id]
+                
+                capped_start = self.model.NewIntVar(0, 4, "")
+                self.model.AddMinEquality(capped_start, [d_start, 4])
+                
+                capped_end = self.model.NewIntVar(0, 4, "")
+                self.model.AddMinEquality(capped_end, [d_end, 4])
+                
+                overlap = self.model.NewIntVar(0, 4, "")
+                self.model.Add(overlap == capped_end - capped_start)
+                morning_overlaps.append(overlap)
+                
+            # Total morning slots are 20 (5 days * 4 slots)
+            total_slots = const.NUM_WORKING_DAYS * 4
+            empty_slots = self.model.NewIntVar(0, total_slots, f"sec_{sec_id}_empty_morning")
+            self.model.Add(empty_slots == total_slots - sum(morning_overlaps))
+            
+            self.penalties.append(empty_slots * weight)
 
     def _penalize_late_afternoon_slots(self):
-        """
-        Penalizes any class scheduled in the last 2 slots of the day (slots 6, 7).
-        This encourages classes to end by 3:30 PM (after slot 5).
-        """
         weight = self.weights.get("avoid_late_afternoon", 40)
         if weight == 0: return
 
-        tasks_by_section = defaultdict(list)
         for task in self.tasks:
-            tasks_by_section[task.section.section_id].append(task)
-
-        for sec_id, s_tasks in tasks_by_section.items():
-            if not s_tasks: continue
-
-            for day in range(const.NUM_WORKING_DAYS):
-                for s in range(6, const.NUM_TEACHING_SLOTS_PER_DAY): # 6, 7
-                    abs_slot = day * const.NUM_TEACHING_SLOTS_PER_DAY + s
-                    
-                    task_covers = []
-                    for task in s_tasks:
-                        covers = self.model.NewBoolVar(f"sec_{sec_id}_la_covers_{abs_slot}_{task.task_id}")
-                        start_var = self.ce.task_vars[task.task_id][0]
-                        min_start = max(abs_slot - task.duration + 1, day * const.NUM_TEACHING_SLOTS_PER_DAY)
-                        max_start = abs_slot
-                        
-                        eq_lits = []
-                        for p in range(min_start, max_start + 1):
-                            is_p = self.model.NewBoolVar(f"sec_{sec_id}_la_t_{task.task_id}_s_{p}")
-                            self.model.Add(start_var == p).OnlyEnforceIf(is_p)
-                            self.model.Add(start_var != p).OnlyEnforceIf(is_p.Not())
-                            eq_lits.append(is_p)
-                            
-                        self.model.AddBoolOr(eq_lits).OnlyEnforceIf(covers)
-                        for lit in eq_lits:
-                            self.model.AddImplication(covers.Not(), lit.Not())
-                            
-                        task_covers.append(covers)
-                        
-                    is_occupied = self.model.NewBoolVar(f"sec_{sec_id}_la_occ_{abs_slot}")
-                    self.model.AddBoolOr(task_covers).OnlyEnforceIf(is_occupied)
-                    for lit in task_covers:
-                        self.model.AddImplication(is_occupied.Not(), lit.Not())
-                        
-                    # Penalize if OCCUPIED
-                    self.penalties.append(is_occupied * weight)
+            d_start = self.t_dstart[task.task_id]
+            d_end = self.t_dend[task.task_id]
+            
+            capped_start = self.model.NewIntVar(6, const.NUM_TEACHING_SLOTS_PER_DAY, "")
+            self.model.AddMaxEquality(capped_start, [d_start, 6])
+            
+            capped_end = self.model.NewIntVar(6, const.NUM_TEACHING_SLOTS_PER_DAY, "")
+            self.model.AddMaxEquality(capped_end, [d_end, 6])
+            
+            overlap = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY - 6, "")
+            self.model.Add(overlap == capped_end - capped_start)
+            
+            self.penalties.append(overlap * weight)