Finalize optimizer with shift type / partial&bulk work type etc

src/config/optimization_config.py

@@ -220,8 +220,16 @@ def get_cost_list_per_emp_shift():
         print(f"using default value for cost list per emp shift")
         shift_cost_df = extract.read_shift_cost_data()
         #question - Important : there is multiple type of employment type in terms of the cost
-        #1 -. unicef 2 - humanizer
-        return {"UNICEF Fixed term":{1:43,2:43,3:64},"Humanizer":{1:27,2:27,3:41}}
+        #Shift 1 = normal, 2 = evening, 3 = overtime 
+        return {"UNICEF Fixed term":{1:43.27,2:43.27,3:64.91},"Humanizer":{1:27.94,2:27.94,3:41.91}}
+
+def shift_code_to_name():
+    shift_code_to_name_dict = {
+        1: "normal",
+        2: "evening",
+        3: "overtime"
+    }
+    return shift_code_to_name_dict
 
 COST_LIST_PER_EMP_SHIFT = get_cost_list_per_emp_shift()
 # print("cost list per emp shift",COST_LIST_PER_EMP_SHIFT)
@@ -285,16 +293,29 @@ TEAM_REQ_PER_PRODUCT = get_team_requirements(PRODUCT_LIST)
 print("team requirements per product:", TEAM_REQ_PER_PRODUCT)
 
 
-MAX_EMPLOYEE_PER_TYPE_ON_DAY = {  # Not available information
-    "UNICEF Fixed term": {
-        t: 8 for t in DATE_SPAN
-    },  # EDIT: e.g., {'x': {1:5,2:5,...}, 'y':{1:6,...}}
-    "Humanizer": {t: 6 for t in DATE_SPAN},
-}
+def get_max_employee_per_type_on_day():
+    try:
+        max_employee_per_type_on_day = dashboard.max_employee_per_type_on_day
+        return max_employee_per_type_on_day
+    except Exception as e:
+        print(f"using default value for max employee per type on day")
+        max_employee_per_type_on_day = {
+            "UNICEF Fixed term": {
+                t: 8 for t in DATE_SPAN
+            },
+            "Humanizer": {
+                t: 10 for t in DATE_SPAN
+            }
+        }
+        return max_employee_per_type_on_day
+
+MAX_EMPLOYEE_PER_TYPE_ON_DAY = get_max_employee_per_type_on_day()
+print("max employee per type on day",MAX_EMPLOYEE_PER_TYPE_ON_DAY)
+
 # available employee but for fixed in shift 1, it is mandatory employment
 
 MAX_HOUR_PER_PERSON_PER_DAY = 14  # legal standard
-MAX_HOUR_PER_SHIFT_PER_PERSON = {1: 7, 2: 7, 3: 3}  # work_shifts_timing.csv #Need to be fixed
+MAX_HOUR_PER_SHIFT_PER_PERSON = {1: 7.5, 2: 7.5, 3: 5} #1 = normal, 2 = evening, 3 = overtime
 def get_per_product_speed():
     try:
         streamlit_per_product_speed = dashboard.per_product_speed
@@ -344,3 +365,34 @@ DAILY_WEEKLY_SCHEDULE = "daily"  # daily or weekly ,this needs to be implemented
 #   "none"      - Purely demand-driven scheduling (cost-efficient)
 FIXED_STAFF_CONSTRAINT_MODE = "priority"  # Recommended: "priority" for realistic business model
 
+
+def get_payment_mode_config():
+    """
+    Get payment mode configuration - try from streamlit session state first, then default values
+    Payment modes:
+    - "bulk": If employee works any hours in shift, pay for full shift hours
+    - "partial": Pay only for actual hours worked
+    """
+    try:
+        # Try to get from streamlit session state (from Dataset Metadata page)
+        import streamlit as st
+        if hasattr(st, 'session_state') and 'payment_mode_config' in st.session_state:
+            print(f"Using payment mode config from streamlit session: {st.session_state.payment_mode_config}")
+            return st.session_state.payment_mode_config
+    except Exception as e:
+        print(f"Could not get payment mode config from streamlit session: {e}")
+    
+    # Default payment mode configuration
+    # Shift 1: bulk, Shift 2: bulk (evening), Shift 3: partial (overtime)
+    print(f"Loading default payment mode configuration")
+    payment_mode_config = {
+        1: "bulk",      # Regular shift - bulk payment
+        2: "bulk",      # Evening shift - bulk payment  
+        3: "partial"    # Overtime shift - partial payment
+    }
+    
+    return payment_mode_config
+
+PAYMENT_MODE_CONFIG = get_payment_mode_config()
+print("Payment mode configuration:", PAYMENT_MODE_CONFIG)
+

src/models/optimizer_new_aug14.py

@@ -28,6 +28,7 @@ from src.config.optimization_config import (
     DAILY_WEEKLY_SCHEDULE,           # 'daily' or 'weekly' (여기선 weekly로 모델링)
     FIXED_STAFF_CONSTRAINT_MODE,     # not used in fixed-team model (동시 투입이라 무의미)
     TEAM_REQ_PER_PRODUCT,            # {emp_type: {product: team_size}} from Kits_Calculation.csv
+    PAYMENT_MODE_CONFIG,             # {shift: 'bulk'/'partial'} payment mode configuration
     KIT_LINE_MATCH_DICT,
     EVENING_SHIFT_MODE,
     EVENING_SHIFT_DEMAND_THRESHOLD,
@@ -197,12 +198,47 @@ def solve_fixed_team_weekly():
                     T[p, ell, s, t] = solver.NumVar(0, Hmax_s[s], f"T_{p}_{ell[0]}_{ell[1]}_s{s}_d{t}")
                     U[p, ell, s, t] = solver.NumVar(0, INF,       f"U_{p}_{ell[0]}_{ell[1]}_s{s}_d{t}")
 
-    # --- Objective: total labor cost + hierarchy timing penalty ---
-    # Primary objective: minimize labor cost
-    total_cost = solver.Sum(
-        cost[e][s] * TEAM_REQ_PER_PRODUCT[e][p] * T[p, ell, s, t]
-        for e in E for s in S for p in P for ell in L for t in D
-    )
+    # Note: Binary variables for bulk payment are now created inline in the cost calculation
+
+    # --- Objective: total labor cost with payment modes + hierarchy timing penalty ---
+    print(f"Payment mode configuration: {PAYMENT_MODE_CONFIG}")
+    
+    # Build cost terms based on payment mode
+    cost_terms = []
+    
+    for e in E:
+        for s in S:
+            payment_mode = PAYMENT_MODE_CONFIG.get(s, "partial")  # Default to partial if not specified
+            
+            if payment_mode == "partial":
+                # Partial payment: pay for actual hours worked
+                for p in P:
+                    for ell in L:
+                        for t in D:
+                            cost_terms.append(cost[e][s] * TEAM_REQ_PER_PRODUCT[e][p] * T[p, ell, s, t])
+            
+            elif payment_mode == "bulk":
+                # Bulk payment: if employees work ANY hours in a shift, pay them for FULL shift hours
+                # BUT only pay the employees who actually work, not all employees of that type
+                for p in P:
+                    for ell in L:
+                        for t in D:
+                            # Calculate actual employees working: TEAM_REQ_PER_PRODUCT[e][p] employees work T[p,ell,s,t] hours
+                            # For bulk payment: if T[p,ell,s,t] > 0, pay TEAM_REQ_PER_PRODUCT[e][p] employees for full shift
+                            # We need a binary variable for each (e,s,p,ell,t) combination
+                            # But we can use the existing logic: if T > 0, then those specific employees get bulk pay
+                            
+                            # Create binary variable for this specific work assignment
+                            work_binary = solver.BoolVar(f"work_{e}_s{s}_{p}_{ell[0]}{ell[1]}_d{t}")
+                            
+                            # Link work_binary to T[p,ell,s,t]: work_binary = 1 if T > 0
+                            solver.Add(T[p, ell, s, t] <= Hmax_s[s] * work_binary)
+                            solver.Add(work_binary * 0.001 <= T[p, ell, s, t])
+                            
+                            # Cost: pay the specific working employees for full shift hours
+                            cost_terms.append(cost[e][s] * Hmax_s[s] * TEAM_REQ_PER_PRODUCT[e][p] * work_binary)
+    
+    total_cost = solver.Sum(cost_terms)
     
     # Secondary objective: encourage earlier production of dependencies (soft constraint)
     # Small weight (0.01) to prioritize hierarchy without overwhelming cost optimization
@@ -290,6 +326,8 @@ def solve_fixed_team_weekly():
             )
     # (if needed, evening(3) after usual(1): sum(...)_s=3 ≤ sum(...)_s=1)
     
+    # 7.5) Bulk payment linking constraints are now handled inline in the cost calculation
+    
     # 8) *** HIERARCHY DEPENDENCY CONSTRAINTS ***
     # For subkits with prepack dependencies: dependencies should be produced before or same time
     print("\n[HIERARCHY] Adding dependency constraints...")