Update objective_engine.py

objective_engine.py

@@ -108,7 +108,7 @@ class ObjectiveEngine:
         self._avoid_late_heavy_subjects()
         self._minimize_faculty_gaps()
         self._minimize_campus_movement()
-        self._penalize_first_hour_free()
+        self._pack_morning_session()
         self._minimize_student_gaps()
 
         # Summation of all penalties
@@ -457,63 +457,51 @@ class ObjectiveEngine:
                         self.penalties.append(both_occupied * max(1, weight // 2))
 
     def _penalize_first_hour_free(self):
+    def _pack_morning_session(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.
-
-        Rewritten to reuse cached day booleans and daily slot vars for efficiency.
+        Penalizes any free slot in the first 4 hours (morning session) for any section.
+        This strongly forces the solver to pack the morning tightly, leaving afternoons free if necessary,
+        and completely eliminating gaps in the first 4 hours.
         """
-        weight = self.weights.get("no_first_hour_free", 20)
-        if weight == 0:
-            return
+        weight = self.weights.get("pack_morning", 500)
+        if weight == 0: return
 
-        # Group tasks by parent section (merge batches into parent)
-        tasks_by_parent = defaultdict(list)
+        from collections import defaultdict
+        tasks_by_sec = defaultdict(list)
         for task in self.tasks:
-            sid = task.section.section_id
-            parent = sid.split('-')[0] if '-' in sid else sid
-            tasks_by_parent[parent].append(task)
+            tasks_by_sec[task.section.section_id].append(task)
 
-        for sec_id, sec_tasks in tasks_by_parent.items():
-            # Ensure day booleans exist
-            for task in sec_tasks:
-                self._ensure_day_bools(task)
+        for sec_id, sec_tasks in tasks_by_sec.items():
+            if not sec_tasks: continue
 
             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]
-
-                    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)
-
-                if not starts_at_first:
-                    continue
-
-                # 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())
-
-                # 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)
-
-                self.penalties.append(first_free * weight)
+                for slot in range(4): # First 4 hours
+                    abs_slot = day * const.NUM_TEACHING_SLOTS_PER_DAY + slot
+                    slot_covs = []
+                    
+                    for task in sec_tasks:
+                        start_var = self.ce.task_vars[task.task_id][0]
+                        cov = self.model.NewBoolVar(f"morn_cov_{task.task_id}_s{abs_slot}")
+                        b1 = self.model.NewBoolVar(f"mb1_{task.task_id}_s{abs_slot}")
+                        b2 = self.model.NewBoolVar(f"mb2_{task.task_id}_s{abs_slot}")
+                        
+                        self.model.Add(start_var <= abs_slot).OnlyEnforceIf(b1)
+                        self.model.Add(start_var > abs_slot).OnlyEnforceIf(b1.Not())
+                        self.model.Add(start_var + task.duration > abs_slot).OnlyEnforceIf(b2)
+                        self.model.Add(start_var + task.duration <= abs_slot).OnlyEnforceIf(b2.Not())
+                        
+                        self.model.AddBoolAnd([b1, b2]).OnlyEnforceIf(cov)
+                        self.model.AddBoolOr([b1.Not(), b2.Not()]).OnlyEnforceIf(cov.Not())
+                        slot_covs.append(cov)
+                        
+                    is_active = self.model.NewBoolVar(f"morn_act_{sec_id}_d{day}_s{slot}")
+                    self.model.AddBoolOr(slot_covs).OnlyEnforceIf(is_active)
+                    for c in slot_covs:
+                        self.model.AddImplication(is_active.Not(), c.Not())
+                        
+                    # We penalize if is_active is False
+                    is_free = self.model.NewBoolVar(f"morn_free_{sec_id}_d{day}_s{slot}")
+                    self.model.Add(is_active == 0).OnlyEnforceIf(is_free)
+                    self.model.Add(is_active == 1).OnlyEnforceIf(is_free.Not())
+                    
+                    self.penalties.append(is_free * weight)