Update objective_engine.py

objective_engine.py

@@ -59,28 +59,62 @@ class ObjectiveEngine:
         
         self.penalties: List[cp_model.IntVar] = []
 
+        # Pre-computed day booleans (shared across soft constraints)
+        # task_day_bools[task_id][day] = BoolVar "is task on this day?"
+        self._task_day_bools: Dict[str, Dict[int, cp_model.IntVar]] = {}
+        self._task_day_vars: Dict[str, cp_model.IntVar] = {}
+        self._daily_slot_vars: Dict[str, cp_model.IntVar] = {}
+
+    def _ensure_day_bools(self, task: 'Task'):
+        """Lazily create and cache per-task day booleans & daily slot vars."""
+        tid = task.task_id
+        if tid in self._task_day_bools:
+            return
+
+        start_var = self.ce.task_vars[tid][0]
+
+        # Day index (0..NUM_WORKING_DAYS-1) for this task
+        day_var = self.model.NewIntVar(
+            0, const.NUM_WORKING_DAYS - 1, f"dayvar_{tid}")
+        self.model.AddDivisionEquality(
+            day_var, start_var, const.NUM_TEACHING_SLOTS_PER_DAY)
+        self._task_day_vars[tid] = day_var
+
+        # Daily slot index (0..NUM_TEACHING_SLOTS_PER_DAY-1)
+        daily_slot = self.model.NewIntVar(
+            0, const.NUM_TEACHING_SLOTS_PER_DAY - 1, f"dslot_{tid}")
+        self.model.AddModuloEquality(
+            daily_slot, start_var, const.NUM_TEACHING_SLOTS_PER_DAY)
+        self._daily_slot_vars[tid] = daily_slot
+
+        # Per-day boolean
+        day_bools = {}
+        for day in range(const.NUM_WORKING_DAYS):
+            b = self.model.NewBoolVar(f"{tid}_onday{day}")
+            self.model.Add(day_var == day).OnlyEnforceIf(b)
+            self.model.Add(day_var != day).OnlyEnforceIf(b.Not())
+            day_bools[day] = b
+        self._task_day_bools[tid] = day_bools
+
     def build_objective(self):
         """
         Applies all configured soft constraints and sets the minimization objective.
+        All constraints are designed to scale linearly with task count.
         """
-        print("Building Objective Function...")
+        print(f"Building Objective Function ({len(self.tasks)} tasks)...")
         
         self._minimize_subject_repetition()
         self._prioritize_morning_core_subjects()
         self._avoid_late_heavy_subjects()
-        
-        # Disable highly expensive constraints for massive math (large datasets)
-        if len(self.tasks) <= 100:
-            self._minimize_faculty_gaps()
-            self._minimize_campus_movement()
-            self._penalize_first_hour_free()
-        else:
-            print(f"Skipping expensive soft constraints due to massive math (Tasks: {len(self.tasks)})")
+        self._minimize_faculty_gaps()
+        self._minimize_campus_movement()
+        self._penalize_first_hour_free()
 
         # Summation of all penalties
         if self.penalties:
             total_cost = sum(self.penalties)
             self.model.Minimize(total_cost)
+            print(f"  → {len(self.penalties)} penalty terms added.")
         else:
             self.model.Minimize(0)
 
@@ -142,10 +176,8 @@ class ObjectiveEngine:
 
         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)
+                self._ensure_day_bools(task)
+                daily_slot = self._daily_slot_vars[task.task_id]
 
                 # Penalty if daily_slot >= afternoon_start_index
                 is_afternoon = self.model.NewBoolVar(f"is_afternoon_{task.task_id}")
@@ -165,10 +197,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.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)
+                self._ensure_day_bools(task)
+                daily_slot = self._daily_slot_vars[task.task_id]
 
                 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)
@@ -178,89 +208,81 @@ class ObjectiveEngine:
 
     def _minimize_faculty_gaps(self):
         """
-        Penalizes 'idle spans' for faculty.
-        We approximate this by minimizing (Daily End Time - Daily Start Time - Total Teaching Duration).
+        Penalizes 'idle spans' for faculty using an O(N) approach.
+
+        Instead of tracking min-start / max-end per faculty per day
+        (which requires O(tasks_per_faculty × days) auxiliary variables
+        with conditional min/max), we use a simpler counting approach:
+
+        For each faculty on each day, count the number of tasks scheduled.
+        If count >= 2, the span necessarily introduces potential gaps.
+        The penalty is proportional to (count - 1) since that's the
+        maximum number of gaps possible. The actual gap size is left
+        to the solver's domain reduction.
         """
         weight = self.weights.get("faculty_gaps", 0)
         if weight == 0: return
 
         # Group tasks by faculty
-        tasks_by_faculty = {f.id: [] for f in self.faculties}
+        tasks_by_faculty = defaultdict(list)
         faculty_ids_set = {f.id for f in self.faculties}
         for task in self.tasks:
             parts = task.faculty.id.split('_')
             fids = parts if len(parts) > 1 and all(p in faculty_ids_set for p in parts) else [task.faculty.id]
             for fid in fids:
-                if fid in tasks_by_faculty:
+                if fid != "DUMMY_STAFF":
                     tasks_by_faculty[fid].append(task)
 
         for faculty_id, f_tasks in tasks_by_faculty.items():
-            if not f_tasks:
+            if len(f_tasks) < 2:
                 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 = []
+            # Ensure day booleans exist for all tasks of this faculty
+            for task in f_tasks:
+                self._ensure_day_bools(task)
 
+            for day in range(const.NUM_WORKING_DAYS):
+                # Collect "is on day" booleans for this faculty's tasks
+                on_day_bools = []
                 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]
-                    
-                    is_on_day = self.model.NewBoolVar(f"{task.task_id}_on_day_{day}")
-                    
-                    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)
-                    
-                    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)
+                    on_day_bools.append(
+                        self._task_day_bools[task.task_id][day])
+
+                # Count tasks on this day
+                count_on_day = self.model.NewIntVar(
+                    0, len(f_tasks),
+                    f"fgap_cnt_{faculty_id}_d{day}")
+                self.model.Add(count_on_day == sum(on_day_bools))
+
+                # Penalize if there's more than 1 task (potential gaps)
+                # Penalty = max(0, count - 1) * weight
+                # Since count >= 0, we can use: penalty_val = count - 1
+                # clamped to 0 via a helper var
+                gap_potential = self.model.NewIntVar(
+                    0, len(f_tasks),
+                    f"fgap_pot_{faculty_id}_d{day}")
+                self.model.AddMaxEquality(
+                    gap_potential, [count_on_day - 1, 0])
+
+                self.penalties.append(gap_potential * weight)
 
     def _minimize_campus_movement(self):
         """
         Penalizes consecutive tasks for a section that are in different buildings.
+
+        Rewritten to O(N) by only checking adjacent-period pairs on the same day
+        instead of all O(N²) task pairs.
+
+        For each section and each day, for each pair of adjacent teaching slots,
+        check if the tasks in those slots are in different buildings.
         """
         weight = self.weights.get("campus_movement", 0)
         if weight == 0: return
         
         unique_buildings = sorted(list(set(r.building for r in self.rooms)))
+        if len(unique_buildings) <= 1:
+            return  # Only one building — no campus movement possible
+
         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]
 
@@ -269,38 +291,98 @@ class ObjectiveEngine:
             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]
-                    
-                    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}")
-                    
-                    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)
+            if len(sec_tasks) < 2:
+                continue
 
-                    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())
+            # Ensure day booleans exist
+            for task in sec_tasks:
+                self._ensure_day_bools(task)
 
-                    penalty_active = self.model.NewBoolVar(f"move_pen_{t1.task_id}_{t2.task_id}")
-                    self.model.AddBoolAnd([is_consecutive, diff_building]).OnlyEnforceIf(penalty_active)
-                    
-                    self.penalties.append(penalty_active * weight)
+            # For each day, for each pair of adjacent slots, check if two
+            # different tasks from this section occupy them and are in
+            # different buildings.
+            for day in range(const.NUM_WORKING_DAYS):
+                day_offset = day * const.NUM_TEACHING_SLOTS_PER_DAY
+
+                for slot in range(const.NUM_TEACHING_SLOTS_PER_DAY - 1):
+                    abs_slot = day_offset + slot
+                    next_abs_slot = day_offset + slot + 1
+
+                    # Find tasks that could be at abs_slot and next_abs_slot
+                    # A task covers abs_slot if start <= abs_slot < start + dur
+                    # For efficiency, we check start_var constraints
+
+                    tasks_at_slot = []
+                    tasks_at_next = []
+
+                    for task in sec_tasks:
+                        start_var = self.ce.task_vars[task.task_id][0]
+                        # Task covers abs_slot if start == abs_slot (for dur=1)
+                        # or start <= abs_slot < start + dur (for dur>1)
+                        # We use a bool to detect coverage
+                        cov = self.model.NewBoolVar(
+                            f"cov_{task.task_id}_s{abs_slot}")
+                        self.model.Add(
+                            start_var <= abs_slot).OnlyEnforceIf(cov)
+                        self.model.Add(
+                            start_var + task.duration > abs_slot).OnlyEnforceIf(cov)
+                        self.model.Add(
+                            start_var > abs_slot).OnlyEnforceIf(cov.Not())
+                        tasks_at_slot.append((task, cov))
+
+                        cov_next = self.model.NewBoolVar(
+                            f"cov_{task.task_id}_s{next_abs_slot}")
+                        self.model.Add(
+                            start_var <= next_abs_slot).OnlyEnforceIf(cov_next)
+                        self.model.Add(
+                            start_var + task.duration > next_abs_slot
+                        ).OnlyEnforceIf(cov_next)
+                        self.model.Add(
+                            start_var > next_abs_slot
+                        ).OnlyEnforceIf(cov_next.Not())
+                        tasks_at_next.append((task, cov_next))
+
+                    # For each pair (one at slot, one at next_slot, different tasks),
+                    # check if they're in different buildings.
+                    # To keep this tractable, we only penalize if ANY task at slot
+                    # and ANY task at next_slot are in different buildings.
+                    # We approximate: penalize if slot is occupied AND next_slot is
+                    # occupied (movement required regardless of building).
+                    # This is a much cheaper O(1)-per-slot approximation.
+                    if tasks_at_slot and tasks_at_next:
+                        any_at_slot = self.model.NewBoolVar(
+                            f"any_{sec_id}_d{day}_s{slot}")
+                        any_at_next = self.model.NewBoolVar(
+                            f"any_{sec_id}_d{day}_s{slot + 1}")
+
+                        self.model.AddBoolOr(
+                            [c for _, c in tasks_at_slot]
+                        ).OnlyEnforceIf(any_at_slot)
+                        for _, c in tasks_at_slot:
+                            self.model.AddImplication(
+                                any_at_slot.Not(), c.Not())
+
+                        self.model.AddBoolOr(
+                            [c for _, c in tasks_at_next]
+                        ).OnlyEnforceIf(any_at_next)
+                        for _, c in tasks_at_next:
+                            self.model.AddImplication(
+                                any_at_next.Not(), c.Not())
+
+                        # Movement penalty: both slots occupied = potential
+                        # building change (simplified — exact building check
+                        # was O(n²) and is too expensive for large models)
+                        both_occupied = self.model.NewBoolVar(
+                            f"bothocc_{sec_id}_d{day}_s{slot}")
+                        self.model.AddBoolAnd(
+                            [any_at_slot, any_at_next]
+                        ).OnlyEnforceIf(both_occupied)
+                        self.model.AddBoolOr(
+                            [any_at_slot.Not(), any_at_next.Not()]
+                        ).OnlyEnforceIf(both_occupied.Not())
+
+                        # Use a reduced weight since this is an approximation
+                        self.penalties.append(both_occupied * max(1, weight // 2))
 
     def _penalize_first_hour_free(self):
         """
@@ -308,19 +390,24 @@ class ObjectiveEngine:
         section on any day. The solver will avoid this unless there is genuinely
         no other feasible assignment.
 
-        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.
+        Rewritten to reuse cached day booleans and daily slot vars for efficiency.
         """
         weight = self.weights.get("no_first_hour_free", 20)
         if weight == 0:
             return
 
-        # Group tasks by section
-        tasks_by_section = defaultdict(list)
+        # Group tasks by parent section (merge batches into parent)
+        tasks_by_parent = defaultdict(list)
         for task in self.tasks:
-            tasks_by_section[task.section.section_id].append(task)
+            sid = task.section.section_id
+            parent = sid.split('-')[0] if '-' in sid else sid
+            tasks_by_parent[parent].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_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
@@ -330,20 +417,31 @@ class ObjectiveEngine:
                 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())
+                    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)
+                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)
+                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)