Update app.py

app.py

@@ -74,15 +74,16 @@ def optimize_staffing(
     
     # Parameters
     BEDS_PER_STAFF = float(beds_per_staff)
-    STANDARD_PERIOD_DAYS = 30  # Standard 4-week period
+    STANDARD_PERIOD_DAYS = 30  # Standard month period (changed from 28 to 30)
     
-    # Scale MAX_HOURS_PER_STAFF based on the ratio of actual days to standard period
-    BASE_MAX_HOURS = float(max_hours_per_staff)  # This is for a 28-day period
+    # Scale MAX_HOURS_PER_STAFF based on the ratio of actual days to standard month
+    BASE_MAX_HOURS = float(max_hours_per_staff)  # This is for a 30-day period
     MAX_HOURS_PER_STAFF = BASE_MAX_HOURS * (num_days / STANDARD_PERIOD_DAYS)
     
     # Log the adjustment for transparency
-    original_results = f"Input max hours per staff (28-day period): {BASE_MAX_HOURS}\n"
-    original_results += f"Adjusted max hours for {num_days}-day period: {MAX_HOURS_PER_STAFF:.1f}\n\n"
+    original_results = f"Input max hours per staff (30-day period): {BASE_MAX_HOURS}\n"
+    original_results += f"Adjusted max hours for {num_days}-day period: {MAX_HOURS_PER_STAFF:.1f}\n"
+    original_results += f"(Adjustment ratio: {num_days}/{STANDARD_PERIOD_DAYS} = {(num_days/STANDARD_PERIOD_DAYS):.2f})\n\n"
     
     HOURS_PER_CYCLE = float(hours_per_cycle)
     REST_DAYS_PER_WEEK = int(rest_days_per_week)
@@ -224,13 +225,15 @@ def optimize_staffing(
     
     # Use exact_staff_count if provided, otherwise estimate
     if exact_staff_count is not None and exact_staff_count > 0:
-        # When exact staff count is provided, only create that many staff in the model
+        # When exact staff count is provided, use it regardless of minimum required
+        if exact_staff_count < min_staff_estimate:
+            original_results += f"\nWarning: Provided staff count ({exact_staff_count}) is below estimated minimum ({min_staff_estimate:.1f}). Solution may not be feasible.\n"
         estimated_staff = exact_staff_count
-        num_staff_to_create = exact_staff_count  # Only create exactly this many staff
+        num_staff_to_create = exact_staff_count
     else:
         # Add some buffer for constraints like rest days and shift changes
         estimated_staff = max(min_staff_estimate, max_staff_needed + 1)
-        num_staff_to_create = int(estimated_staff)  # Create the estimated number of staff
+        num_staff_to_create = int(estimated_staff)
     
     def optimize_schedule(num_staff, time_limit=600):
         try:
@@ -250,35 +253,59 @@ def optimize_staffing(
             # Total hours worked by all staff
             total_hours = pl.LpVariable("total_hours", lowBound=0)
             
-            # CRITICAL CHANGE: Remove coverage violation variables - make coverage a hard constraint
-            # CRITICAL CHANGE: Remove overtime variables - make overtime a hard constraint
+            # Individual staff hours variables for balancing
+            staff_hours = pl.LpVariable.dicts("staff_hours", range(1, num_staff+1), lowBound=0)
             
-            # Objective function now only focuses on minimizing staff count and total hours
-            model += (
-                10**10 * pl.lpSum(staff_used[s] for s in range(1, num_staff+1)) +
-                1 * total_hours
-            )
+            # Objective function modification for exact staff count
+            if exact_staff_count is not None:
+                # When exact staff count is specified, focus on balancing hours between staff
+                avg_hours = total_staff_hours / num_staff
+                model += pl.lpSum(staff_hours[s] for s in range(1, num_staff+1))
+                
+                # Add penalty for deviation from average
+                for s in range(1, num_staff+1):
+                    model += staff_hours[s] >= avg_hours * 0.8  # Each staff must get at least 80% of average hours
+                    model += staff_hours[s] <= avg_hours * 1.2  # Each staff must not exceed 120% of average hours
+            else:
+                # Original objective for minimizing staff and total hours
+                model += 10**10 * pl.lpSum(staff_used[s] for s in range(1, num_staff+1)) + total_hours
             
-            # Link total_hours to the sum of all hours worked
-            model += total_hours == pl.lpSum(x[(s, d, shift['id'])] * shift['duration'] 
-                         for s in range(1, num_staff+1) 
-                         for d in range(1, num_days+1) 
-                         for shift in possible_shifts)
-        
-            # Link staff_used variable with shift assignments
+            # Link staff_hours to actual hours worked
             for s in range(1, num_staff+1):
-                model += pl.lpSum(x[(s, d, shift['id'])] 
-                                 for d in range(1, num_days+1) 
-                                 for shift in possible_shifts) <= num_days * staff_used[s]
-                
-                # If staff is used, they must work at least one shift
-                model += pl.lpSum(x[(s, d, shift['id'])] 
-                                 for d in range(1, num_days+1) 
-                                 for shift in possible_shifts) >= staff_used[s]
+                model += staff_hours[s] == pl.lpSum(x[(s, d, shift['id'])] * shift['duration'] 
+                                                  for d in range(1, num_days+1) 
+                                                  for shift in possible_shifts)
             
-            # Maintain staff ordering (to avoid symmetrical solutions)
-            for s in range(1, num_staff):
-                model += staff_used[s] >= staff_used[s+1]
+            # Link total_hours to sum of staff_hours
+            model += total_hours == pl.lpSum(staff_hours[s] for s in range(1, num_staff+1))
+            
+            # When exact staff count is provided, ensure all staff are used
+            if exact_staff_count is not None:
+                for s in range(1, num_staff+1):
+                    # Ensure each staff works at least some minimum shifts
+                    min_shifts = max(1, int(num_days / (num_staff * 2)))  # At least this many shifts per staff
+                    model += pl.lpSum(x[(s, d, shift['id'])] 
+                                    for d in range(1, num_days+1) 
+                                    for shift in possible_shifts) >= min_shifts
+                    
+                    # Maximum shifts per staff (to prevent overloading)
+                    max_shifts = int(num_days * 0.8)  # At most 80% of days
+                    model += pl.lpSum(x[(s, d, shift['id'])] 
+                                    for d in range(1, num_days+1) 
+                                    for shift in possible_shifts) <= max_shifts
+            else:
+                # Original staff usage constraints
+                for s in range(1, num_staff+1):
+                    model += pl.lpSum(x[(s, d, shift['id'])] 
+                                     for d in range(1, num_days+1) 
+                                     for shift in possible_shifts) <= num_days * staff_used[s]
+                    model += pl.lpSum(x[(s, d, shift['id'])] 
+                                     for d in range(1, num_days+1) 
+                                     for shift in possible_shifts) >= staff_used[s]
+                
+                # Maintain staff ordering only when not using exact staff count
+                for s in range(1, num_staff):
+                    model += staff_used[s] >= staff_used[s+1]
             
             # Each staff works at most one shift per day
             for s in range(1, num_staff+1):
@@ -305,12 +332,12 @@ def optimize_staffing(
             # HARD CONSTRAINT: No overtime allowed - strict limit at MAX_HOURS_PER_STAFF
             for s in range(1, num_staff+1):
                 # Calculate total hours worked by this staff
-                staff_hours = pl.lpSum(x[(s, d, shift['id'])] * shift['duration'] 
+                staff_hours_value = pl.lpSum(x[(s, d, shift['id'])] * shift['duration'] 
                              for d in range(1, num_days+1) 
                                       for shift in possible_shifts)
                 
                 # STRICT constraint: No overtime allowed
-                model += staff_hours <= MAX_HOURS_PER_STAFF
+                model += staff_hours_value <= MAX_HOURS_PER_STAFF
         
             # HARD CONSTRAINT: Full coverage required
             for d in range(1, num_days+1):
@@ -388,21 +415,28 @@ def optimize_staffing(
     if exact_staff_count is not None and exact_staff_count > 0:
         # If exact staff count is specified, only try with that count
         staff_count = int(exact_staff_count)
-        results = f"Using exactly {staff_count} staff as specified...\n"
+        results = original_results  # Include the hours adjustment information
+        results += f"\nUsing exactly {staff_count} staff as specified"
+        if staff_count < min_staff_estimate:
+            results += f" (Warning: This is below estimated minimum of {min_staff_estimate:.1f})"
+        results += "...\n"
         
         # Try to solve with exactly this many staff
         schedule, objective = optimize_schedule(staff_count)
         
         if schedule is None:
             results += f"Failed to find a feasible solution with exactly {staff_count} staff.\n"
-            results += "Try increasing the staff count.\n"
+            if staff_count < min_staff_estimate:
+                results += f"This is likely because the staff count is below the estimated minimum of {min_staff_estimate:.1f}.\n"
+            results += "Try increasing the staff count or adjusting other parameters.\n"
             return results, None, None, None, None
     else:
         # Start from theoretical minimum and work up
         min_staff = max(1, int(theoretical_min_staff))  # Start from theoretical minimum
         max_staff = int(min_staff_estimate) + 5  # Allow some buffer
         
-        results = f"Theoretical minimum staff needed: {theoretical_min_staff:.1f}\n"
+        results = original_results  # Include the hours adjustment information
+        results += f"Theoretical minimum staff needed: {theoretical_min_staff:.1f}\n"
         results += f"Searching for minimum staff count starting from {min_staff}...\n"
         
         # Try each staff count from min to max
@@ -435,19 +469,39 @@ def optimize_staffing(
         total_hours = staff_shifts['duration'].sum()
         staff_hours[s] = total_hours
     
-    # After calculating staff hours, filter out staff with 0 hours before displaying
-    active_staff_hours = {s: hours for s, hours in staff_hours.items() if hours > 0}
+    # Handle staff hours display based on whether exact count was specified
+    if exact_staff_count is not None:
+        # When exact count is specified, show all staff including those with 0 hours
+        active_staff_hours = staff_hours
+    else:
+        # Otherwise, only show active staff
+        active_staff_hours = {s: hours for s, hours in staff_hours.items() if hours > 0}
     
     results += "\nStaff Hours:\n"
+    total_active_hours = sum(active_staff_hours.values())
+    avg_hours = total_active_hours / len(active_staff_hours) if active_staff_hours else 0
+    
     for staff_id, hours in active_staff_hours.items():
         utilization = (hours / MAX_HOURS_PER_STAFF) * 100
-        results += f"Staff {staff_id}: {hours} hours ({utilization:.1f}% utilization)\n"
+        deviation_from_avg = ((hours - avg_hours) / avg_hours * 100) if avg_hours > 0 else 0
+        results += f"Staff {staff_id}: {hours:.1f} hours ({utilization:.1f}% utilization)"
+        if exact_staff_count is not None:
+            results += f" [Deviation from avg: {deviation_from_avg:+.1f}%]"
+        results += "\n"
+        
         # Add overtime information
         if hours > MAX_HOURS_PER_STAFF:
             overtime = hours - MAX_HOURS_PER_STAFF
             overtime_percent = (overtime / MAX_HOURS_PER_STAFF) * 100
             results += f"  Overtime: {overtime:.1f} hours ({overtime_percent:.1f}%)\n"
     
+    if exact_staff_count is not None:
+        results += f"\nWorkload Distribution Stats:\n"
+        results += f"Average hours per staff: {avg_hours:.1f}\n"
+        if active_staff_hours:
+            max_deviation = max(abs((hours - avg_hours) / avg_hours * 100) for hours in active_staff_hours.values()) if avg_hours > 0 else 0
+            results += f"Maximum deviation from average: {max_deviation:.1f}%\n"
+    
     # Use active_staff_hours for average utilization calculation
     active_staff_count = len(active_staff_hours)
     avg_utilization = sum(active_staff_hours.values()) / (active_staff_count * MAX_HOURS_PER_STAFF) * 100