┌────────────────────────────────────────────────────────────────┐
│                    WAREHOUSE LAYOUT ZONES                      │
│  ┌────────────┐  ┌────────────┐  ┌────────────┐  ┌─────────┐  │
│  │   RECEIVING│  │  PUT-AWAY  │  │  STORAGE   │  │PICKING  │  │
│  │    DOCK    │  │   ZONE     │  │   ZONES    │  │  ZONES  │  │
│  │            │  │            │  │ ┌────────┐ │  │ ┌─────┐ │  │
│  │ - Unload   │  │ - VAS     │  │ │ FAST   │ │  │ │A-Frame│ │  │
│  │ - QC       │  │ - Label   │  │ │ movers │ │  │ │Pick   │ │  │
│  │ - Count    │  │ - Sort    │  │ └────────┘ │  │ └─────┘ │  │
│  └────────────┘  └────────────┘  │ ┌────────┐ │  └─────────┘  │
│                                  │ │SLOW   │ │  ┌─────────┐  │
│                                  │ │movers │ │  │PACKING  │  │
│                                  │ └────────┘ │  │ & SHIP  │  │
│                                  └────────────┘  └─────────┘  │
└────────────────────────────────────────────────────────────────┘

def calculate_optimal_warehouse_layout(orders, storage_locations, constraints):
    """
    Calculate optimal slotting to minimize picker travel distance

    Uses ABC Analysis + Cube Movement + Co-location
    """
    # 1. Rank items by velocity (ABC classification)
    abc_classification = classify_items_by_velocity(orders)

    # 2. Apply storage rules
    slotting_strategy = {
        'A_items': {
            'location': 'Golden Zone (waist to shoulder height)',
            'density': 'High-velocity pick locations near shipping',
            'rule': 'Fastest movers, closest to shipping'
        },
        'B_items': {
            'location': 'Silver Zone (easy reach)',
            'density': 'Medium-velocity throughout warehouse',
            'rule': 'Medium movers, secondary locations'
        },
        'C_items': {
            'location': 'Bulk storage, upper levels, distant areas',
            'density': 'Low-velocity, cheapest storage',
            'rule': 'Slow movers, furthest from shipping'
        }
    }

    # 3. Apply family grouping (items ordered together)
    family_groups = identify_co_ordered_items(orders)

    # 4. Calculate cube movement considerations
    cube_assignment = assign_by_cube_velocity(orders, storage_locations)

    # 5. Calculate total travel distance (before vs after)
    travel_reduction = calculate_travel_improvement(
        before_layout,
        after_layout,
        orders
    )

    return {
        'optimal_slotting': combine_strategies(abc_classification, family_groups, cube_assignment),
        'expected_travel_reduction': travel_reduction,
        'space_utilization': calculate_space_utilization(after_layout)
    }

def calculate_travel_improvement(before, after, orders):
    """
    Calculate percentage reduction in travel distance
    using actual order patterns
    """
    before_distance = sum(calculate_travel_path(order, before) for order in orders)
    after_distance = sum(calculate_travel_path(order, after) for order in orders)

    return {
        'before_meters_per_order': before_distance / len(orders),
        'after_meters_per_order': after_distance / len(orders),
        'improvement_percent': (before_distance - after_distance) / before_distance * 100
    }

class DynamicSlottingOptimizer:
    """
    Automated slotting optimization using historical order data
    """

    def __init__(self, warehouse_config, historical_orders):
        self.config = warehouse_config
        self.orders = historical_orders

    def calculate_slot_score(self, item, location):
        """
        Calculate slot score: lower = better location for item

        Factors:
        - Item velocity (picks per month)
        - Travel distance from location
        - Ergonomic score (waist level = best)
        - Cube size (larger items need lower/bigger locations)
        """
        velocity_score = 1000 / (1 + item['picks_per_month'])
        distance_score = location['distance_to_shipping'] * 10
        ergonomic_score = self._ergonomic_penalty(location['height_level'])
        cube_score = self._cube_mismatch_penalty(item['cube'], location['capacity'])

        total_score = velocity_score + distance_score + ergonomic_score + cube_score
        return total_score

    def optimize_slotting(self, constraints):
        """
        Optimize slotting assignment using Hungarian algorithm or greedy approach
        """
        # 1. Rank all item-location combinations
        all_scores = []
        for item in self.items:
            for location in self.available_locations:
                score = self.calculate_slot_score(item, location)
                all_scores.append((item, location, score))

        # 2. Sort by score (lowest = best match)
        all_scores.sort(key=lambda x: x[2])

        # 3. Assign greedily respecting constraints
        assignment = {}
        used_locations = set()

        for item, location, score in all_scores:
            if item['id'] not in assignment and location['id'] not in used_locations:
                if self._meets_constraints(item, location, constraints):
                    assignment[item['id']] = location['id']
                    used_locations.add(location['id'])

        return assignment

┌─────────────────────────────────────────────────────────────┐
│                    PROJECT CHARTER                          │
├─────────────────────────────────────────────────────────────┤
│ Project Title:                                              │
│ Problem Statement:                                          │
│                                                             │
│ Current State: [Metric] - Baseline measurement             │
│ Desired State: [Metric] - Target improvement                │
│ Gap: [Desired - Current]                                   │
│                                                             │
│ Business Case:                                              │
│ - Estimated savings: $XXX,XXX annually                     │
│ - Customer impact: [description]                           │
│                                                             │
│ Scope: IN | OUT                                             │
│ - IN: [what's included]                                    │
│ - OUT: [what's excluded]                                   │
│                                                             │
│ Timeline: XX weeks                                          │
│ Team: [roles and members]                                  │
└─────────────────────────────────────────────────────────────┘

                      ORDER PICKING ERRORS
                            │
        ┌───────────────────┼───────────────────┐
        │                   │                   │
    PEOPLE              METHODS            EQUIPMENT
        │                   │                   │
   Training unclear      No standard      Scanner issues
   Fatigue              work              Battery problems
   Language barriers    Unclear          Wrong item master
                        procedures

def automation_roi_analysis(current_ops, automation_solution, volumes):
    """
    Calculate ROI for warehouse automation investment

    Returns: Payback period, NPV, IRR
    """
    # Current costs
    current_labor_cost = volumes['annual_orders'] * current_ops['cost_per_order']
    current_space_cost = current_ops['sqft'] * current_ops['cost_per_sqft']

    # Automation costs
    capital_investment = automation_solution['total_cost']
    operating_cost = automation_solution['annual_maintenance']

    # Automation benefits
    labor_reduction = automation_solution['labor_reduction_rate']  # e.g., 0.5 = 50%
    space_reduction = automation_solution['space_reduction_rate']  # e.g., 0.3 = 30%

    automated_labor_cost = current_labor_cost * (1 - labor_reduction)
    automated_space_cost = current_space_cost * (1 - space_reduction)

    # Annual savings
    annual_savings = (current_labor_cost + current_space_cost) - \
                     (automated_labor_cost + automated_space_cost + operating_cost)

    # Payback period
    payback_years = capital_investment / annual_savings

    # NPV (10-year horizon, 10% discount rate)
    discount_rate = 0.10
    npv = -capital_investment
    for year in range(1, 11):
        npv += annual_savings / ((1 + discount_rate) ** year)

    return {
        'annual_savings': annual_savings,
        'payback_years': payback_years,
        'npv_10yr': npv,
        'recommendation': 'GO' if payback_years < 3 else 'EVALUATE' if payback_years < 5 else 'NO-GO'
    }

import numpy as np
from scipy.optimize import minimize

def optimize_dc_locations(customers, demand, num_dcs, constraints):
    """
    Optimize DC locations to minimize weighted distance

    Customers: list of (lat, lng) tuples
    Demand: list of annual demand per customer
    num_dcs: number of DCs to locate
    """

    def objective_function(dc_locations_flat):
        """Total weighted distance"""
        dc_locations = dc_locations_flat.reshape((num_dcs, 2))

        total_distance = 0
        for i, customer in enumerate(customers):
            # Find nearest DC
            distances = [haversine_distance(customer, dc)
                        for dc in dc_locations]
            nearest_distance = min(distances)

            # Weight by demand
            total_distance += nearest_distance * demand[i]

        return total_distance

    # Initial guess: geographic center
    initial_guess = np.array([
        [np.mean([c[0] for c in customers]),
         np.mean([c[1] for c in customers])]
    ] * num_dcs).flatten()

    # Bounds: lat/lng constraints
    bounds = [(min(c[0] for c in customers), max(c[0] for c in customers)),
              (min(c[1] for c in customers), max(c[1] for c in customers))] * num_dcs

    # Optimize
    result = minimize(objective_function, initial_guess, bounds=bounds)

    return {
        'optimal_locations': result.x.reshape((num_dcs, 2)),
        'total_weighted_distance': result.fun
    }

def haversine_distance(coord1, coord2):
    """
    Calculate great circle distance between two points
    on Earth (in kilometers)
    """
    lat1, lon1 = np.radians(coord1)
    lat2, lon2 = np.radians(coord2)

    dlat = lat2 - lat1
    dlon = lon2 - lon1

    a = np.sin(dlat/2)**2 + np.cos(lat1) * np.cos(lat2) * np.sin(dlon/2)**2
    c = 2 * np.arcsin(np.sqrt(a))
    r = 6371  # Earth radius in km

    return c * r

┌─────────────────────────────────────────────────────────────┐
│                    STANDARD WORK SHEET                      │
├─────────────────────────────────────────────────────────────┤
│ Process: ORDER PICKING        Station: Zone A    Rev: 3.0   │
├─────────────────────────────────────────────────────────────┤
│ STEP                      │ KEY POINTS          │ TIME      │
├───────────────────────────┼─────────────────────┼───────────┤
│ 1. Receive pick ticket    │ - Verify order #    │ 5 sec     │
│                           │ - Check for special │           │
│                           │   instructions      │           │
├───────────────────────────┼─────────────────────┼───────────┤
│ 2. Scan location          │ - Confirm location  │ 3 sec     │
│                           │ - Verify SKU        │           │
├───────────────────────────┼─────────────────────┼───────────┤
│ 3. Pick quantity          │ - Verify qty        │ 15 sec    │
│                           │ - Check condition   │           │
├───────────────────────────┼─────────────────────┼───────────┤
│ 4. Confirm & place        │ - Scan confirm      │ 5 sec     │
│                           │ - Place in tote     │           │
├───────────────────────────┼─────────────────────┼───────────┤
│ TOTAL TIME                │                     │ 28 sec    │
├───────────────────────────┴─────────────────────┴───────────┤
│ TOOLS: Scanner, Pick Cart, Safety Knife                    │
│ PPE: Safety Vest, Steel Toe Boots                          │
│ QUALITY CHECK: Verify item # matches pick ticket           │
└─────────────────────────────────────────────────────────────┘

                         ┌─────────────────────┐
                         │   PERFECT ORDER     │
                         │   Rate (95%+)       │
                         └──────────┬──────────┘
                ┌────────────────────┼────────────────────┐
                ▼                    ▼                    ▼
        ┌───────────────┐    ┌───────────────┐    ┌───────────────┐
        │   ON-TIME     │    │   COMPLETE    │    │   DAMAGE-     │
        │ DELIVERY      │    │   (Fill Rate) │    │   FREE        │
        │   (98%+)      │    │   (99%+)      │    │   (99.5%+)    │
        └───────┬───────┘    └───────┬───────┘    └───────┬───────┘
                │                    │                    │
                └────────────────────┼────────────────────┘
                                     ▼
                         ┌─────────────────────────────┐
                         │   WAREHOUSE OPERATIONS      │
                         │  ┌─────────────────────┐    │
                         │  │ Productivity (lines/ │    │
                         │  │ hour) - 150+        │    │
                         │  ├─────────────────────┤    │
                         │  │ Accuracy (pick rate) │    │
                         │  │ - 99.9%             │    │
                         │  ├─────────────────────┤    │
                         │  │ Cycle Time (hrs)    │    │
                         │  │ - <2 hrs            │    │
                         │  └─────────────────────┘    │
                         └─────────────────────────────┘

┌────────┐     ┌────────┐     ┌────────┐     ┌────────┐
 │RECEIVE│────▶│ PUT-   │────▶│STORAGE │────▶│  PICK  │
 │  8h   │     │ AWAY  │     │ 24h    │     │  2h    │
 │  1pc  │  ⬤  │  4h   │  ⬤  │        │  ⬤  │ 1.5h   │
 └────────┘     └────────┘     └────────┘     └────────┘
     │              │              │              │
     │ 0.5h         │ 0.25h        │ 1h           │ 0.75h
     ▼              ▼              ▼              ▼
┌────────┐     ┌────────┐     ┌────────┐     ┌────────┐
 │  PACK  │────▶│ SHIP   │
 │  1h   │     │  4h   │
 │ 0.5h  │     │  2h   │
 └────────┘     └────────┘

⬤ = Inventory queue (days)
Total Lead Time: ~43 hours
Value Added Time: ~14 hours (33%)

Kanban Quantity = (Daily Demand × Lead Time) × (1 + Safety Factor) / Container Size

OEE = Availability × Performance × Quality