Update objective_engine.py

objective_engine.py

@@ -56,7 +56,9 @@ class ObjectiveEngine:
             "isolated_afternoon": 100,
             "campus_movement": 3,
             "faculty_load_balance": 1,
-            "no_first_hour_free": 50
+            "no_first_hour_free": 0, # Disabled intentionally
+            "pack_morning": 50,
+            "avoid_late_afternoon": 40
         }
         
         self.penalties: List[cp_model.IntVar] = []
@@ -76,6 +78,9 @@ class ObjectiveEngine:
         self._penalize_isolated_afternoon_classes()
         self._minimize_campus_movement()
         self._penalize_first_hour_free()
+        
+        self._penalize_empty_morning_slots()
+        self._penalize_late_afternoon_slots()
 
         # Summation of all penalties
         if self.penalties:
@@ -177,14 +182,9 @@ class ObjectiveEngine:
                 self.penalties.append(is_last_slot * weight)
 
     def _minimize_faculty_gaps(self):
-        """
-        Penalizes 'idle spans' for faculty.
-        We approximate this by minimizing (Daily End Time - Daily Start Time - Total Teaching Duration).
-        """
-        weight = self.weights.get("faculty_gaps", 0)
+        weight = self.weights.get("faculty_gaps", 30)
         if weight == 0: return
 
-        # Group tasks by faculty
         tasks_by_faculty = {f.id: [] for f in self.faculties}
         faculty_ids_set = {f.id for f in self.faculties}
         for task in self.tasks:
@@ -195,69 +195,58 @@ class ObjectiveEngine:
                     tasks_by_faculty[fid].append(task)
 
         for faculty_id, f_tasks in tasks_by_faculty.items():
-            if not f_tasks:
-                continue
+            if not f_tasks: continue
 
             for day in range(const.NUM_WORKING_DAYS):
-                day_offset_start = day * const.NUM_TEACHING_SLOTS_PER_DAY
-                day_offset_end = (day + 1) * const.NUM_TEACHING_SLOTS_PER_DAY
-
-                # Variables to track if faculty is active on this day, and their start/end
-                day_active = self.model.NewBoolVar(f"active_{faculty_id}_{day}")
-                day_start = self.model.NewIntVar(day_offset_start, day_offset_end, f"start_{faculty_id}_{day}")
-                day_end = self.model.NewIntVar(day_offset_start, day_offset_end, f"end_{faculty_id}_{day}")
-                
-                task_on_day_lits = []
-                total_duration_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"dur_{faculty_id}_{day}")
-                
-                durations_sum = []
-
-                for task in f_tasks:
-                    t_start = self.ce.task_vars[task.task_id][0]
-                    t_end = self.ce.task_vars[task.task_id][1]
+                slot_occupied = []
+                for s in range(const.NUM_TEACHING_SLOTS_PER_DAY):
+                    abs_slot = day * const.NUM_TEACHING_SLOTS_PER_DAY + s
                     
-                    is_on_day = self.model.NewBoolVar(f"{task.task_id}_on_day_{day}")
+                    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)
                     
-                    t_day = self.model.NewIntVar(0, const.NUM_WORKING_DAYS - 1, f"t_day_{task.task_id}_{day}")
-                    self.model.AddDivisionEquality(t_day, t_start, const.NUM_TEACHING_SLOTS_PER_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)
                     
-                    self.model.Add(t_day == day).OnlyEnforceIf(is_on_day)
-                    self.model.Add(t_day != day).OnlyEnforceIf(is_on_day.Not())
-
-                    task_on_day_lits.append(is_on_day)
-
-                    # Update min start and max end for the day ONLY if task is on this day
-                    self.model.Add(day_start <= t_start).OnlyEnforceIf(is_on_day)
-                    self.model.Add(day_end >= t_end).OnlyEnforceIf(is_on_day)
-                    
-                    # Accumulate duration
-                    dur_term = self.model.NewIntVar(0, task.duration, f"dur_term_{task.task_id}_{day}")
-                    self.model.Add(dur_term == task.duration).OnlyEnforceIf(is_on_day)
-                    self.model.Add(dur_term == 0).OnlyEnforceIf(is_on_day.Not())
-                    durations_sum.append(dur_term)
-
-                # If no tasks on this day, force active to false
-                self.model.Add(sum(task_on_day_lits) > 0).OnlyEnforceIf(day_active)
-                self.model.Add(sum(task_on_day_lits) == 0).OnlyEnforceIf(day_active.Not())
-                
-                # --- FIX: Use Python sum() inside Add() instead of self.model.Sum() ---
-                self.model.Add(total_duration_on_day == sum(durations_sum))
-
-                span = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"span_{faculty_id}_{day}")
-                self.model.Add(span == day_end - day_start).OnlyEnforceIf(day_active)
-                self.model.Add(span == 0).OnlyEnforceIf(day_active.Not())
-                
-                idle_time = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"idle_{faculty_id}_{day}")
-                self.model.Add(idle_time == span - total_duration_on_day).OnlyEnforceIf(day_active)
-                self.model.Add(idle_time == 0).OnlyEnforceIf(day_active.Not())
-
-                self.penalties.append(idle_time * weight)
+                    self.penalties.append(is_gap * weight)
 
     def _minimize_student_gaps(self):
-        """
-        Penalizes 'idle spans' for students (sections).
-        """
-        weight = self.weights.get("student_gaps", 10)
+        weight = self.weights.get("student_gaps", 100)
         if weight == 0: return
 
         tasks_by_section = defaultdict(list)
@@ -265,59 +254,55 @@ class ObjectiveEngine:
             tasks_by_section[task.section.section_id].append(task)
 
         for sec_id, s_tasks in tasks_by_section.items():
-            if not s_tasks:
-                continue
+            if not s_tasks: continue
 
             for day in range(const.NUM_WORKING_DAYS):
-                day_offset_start = day * const.NUM_TEACHING_SLOTS_PER_DAY
-                day_offset_end = (day + 1) * const.NUM_TEACHING_SLOTS_PER_DAY
-
-                day_active = self.model.NewBoolVar(f"sec_active_{sec_id}_{day}")
-                day_start = self.model.NewIntVar(day_offset_start, day_offset_end, f"sec_start_{sec_id}_{day}")
-                day_end = self.model.NewIntVar(day_offset_start, day_offset_end, f"sec_end_{sec_id}_{day}")
-                
-                task_on_day_lits = []
-                total_duration_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"sec_dur_{sec_id}_{day}")
-                
-                durations_sum = []
-
-                for task in s_tasks:
-                    t_start = self.ce.task_vars[task.task_id][0]
-                    t_end = self.ce.task_vars[task.task_id][1]
-                    
-                    is_on_day = self.model.NewBoolVar(f"sec_{task.task_id}_on_day_{day}")
+                slot_occupied = []
+                for s in range(const.NUM_TEACHING_SLOTS_PER_DAY):
+                    abs_slot = day * const.NUM_TEACHING_SLOTS_PER_DAY + s
                     
-                    t_day = self.model.NewIntVar(0, const.NUM_WORKING_DAYS - 1, f"sec_t_day_{task.task_id}_{day}")
-                    self.model.AddDivisionEquality(t_day, t_start, const.NUM_TEACHING_SLOTS_PER_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)
                     
-                    self.model.Add(t_day == day).OnlyEnforceIf(is_on_day)
-                    self.model.Add(t_day != day).OnlyEnforceIf(is_on_day.Not())
-
-                    task_on_day_lits.append(is_on_day)
-
-                    # Update min start and max end for the day ONLY if task is on this day
-                    self.model.Add(day_start <= t_start).OnlyEnforceIf(is_on_day)
-                    self.model.Add(day_end >= t_end).OnlyEnforceIf(is_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)
                     
-                    dur_term = self.model.NewIntVar(0, task.duration, f"sec_dur_term_{task.task_id}_{day}")
-                    self.model.Add(dur_term == task.duration).OnlyEnforceIf(is_on_day)
-                    self.model.Add(dur_term == 0).OnlyEnforceIf(is_on_day.Not())
-                    durations_sum.append(dur_term)
-
-                self.model.Add(sum(task_on_day_lits) > 0).OnlyEnforceIf(day_active)
-                self.model.Add(sum(task_on_day_lits) == 0).OnlyEnforceIf(day_active.Not())
-                
-                self.model.Add(total_duration_on_day == sum(durations_sum))
-
-                span = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"sec_span_{sec_id}_{day}")
-                self.model.Add(span == day_end - day_start).OnlyEnforceIf(day_active)
-                self.model.Add(span == 0).OnlyEnforceIf(day_active.Not())
-                
-                idle_time = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"sec_idle_{sec_id}_{day}")
-                self.model.Add(idle_time == span - total_duration_on_day).OnlyEnforceIf(day_active)
-                self.model.Add(idle_time == 0).OnlyEnforceIf(day_active.Not())
-
-                self.penalties.append(idle_time * weight)
+                    self.penalties.append(is_gap * weight)
 
     def _penalize_isolated_afternoon_classes(self):
         """
@@ -435,47 +420,101 @@ class ObjectiveEngine:
                     self.penalties.append(penalty_active * weight)
 
     def _penalize_first_hour_free(self):
-        """
-        Strongly penalizes having the first hour (period index 0) free for any
-        section on any day. The solver will avoid this unless there is genuinely
-        no other feasible assignment.
+        # 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
 
-        Since tasks never cross day boundaries, a task covers period 0 of a day
-        if and only if its start_var equals that day's first absolute slot index.
+    def _penalize_empty_morning_slots(self):
         """
-        weight = self.weights.get("no_first_hour_free", 20)
-        if weight == 0:
-            return
+        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
 
-        # Group tasks by section
         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():
-            for day in range(const.NUM_WORKING_DAYS):
-                # The absolute slot index for period 0 of this day
-                first_slot = day * const.NUM_TEACHING_SLOTS_PER_DAY
-
-                # For each task, create a bool: does it start at exactly first_slot?
-                starts_at_first = []
-                for task in sec_tasks:
-                    start_var = self.ce.task_vars[task.task_id][0]
+        for sec_id, s_tasks in tasks_by_section.items():
+            if not s_tasks: continue
 
-                    at_first = self.model.NewBoolVar(f"at1st_{task.task_id}_d{day}")
-                    self.model.Add(start_var == first_slot).OnlyEnforceIf(at_first)
-                    self.model.Add(start_var != first_slot).OnlyEnforceIf(at_first.Not())
-                    starts_at_first.append(at_first)
+            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)
+
+    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
 
-                # any_at_first = True if at least one task starts at period 0
-                any_at_first = self.model.NewBoolVar(f"any_at1st_{sec_id}_d{day}")
-                self.model.AddBoolOr(starts_at_first).OnlyEnforceIf(any_at_first)
-                for lit in starts_at_first:
-                    self.model.AddImplication(any_at_first.Not(), lit.Not())
+        tasks_by_section = defaultdict(list)
+        for task in self.tasks:
+            tasks_by_section[task.section.section_id].append(task)
 
-                # Penalty when the first hour IS free (no task at period 0)
-                first_free = self.model.NewBoolVar(f"first_free_{sec_id}_d{day}")
-                self.model.Add(first_free == 1).OnlyEnforceIf(any_at_first.Not())
-                self.model.Add(first_free == 0).OnlyEnforceIf(any_at_first)
+        for sec_id, s_tasks in tasks_by_section.items():
+            if not s_tasks: continue
 
-                self.penalties.append(first_free * weight)
+            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)