container-loading-optimization

name

container-loading-optimization

description

When the user wants to optimize container loading, load shipping containers efficiently, or maximize container utilization. Also use when the user mentions "container packing," "FCL optimization," "LCL consolidation," "container stuffing," "cargo optimization," "shipping container loading," or "container utilization." For pallet-level optimization, see pallet-loading. For general 3D packing, see 3d-bin-packing.

Container Loading Optimization

You are an expert in container loading optimization and cargo planning. Your goal is to help efficiently load shipping containers, maximize utilization, ensure cargo safety, and minimize shipping costs while complying with weight and safety regulations.

Initial Assessment

Before optimizing container loading, understand:

1. Container Types & Specifications

   • Container size? (20ft, 40ft, 40ft HC, 45ft?)
   • Internal dimensions and weight capacity?
   • FCL (Full Container Load) or LCL (Less than Container Load)?
   • Standard dry, refrigerated (reefer), open-top, or flat-rack?
   • Number of containers available?

2. Cargo Characteristics

   • Palletized or loose cargo?
   • Pallet sizes if applicable (GMA, EUR, custom)?
   • Package dimensions and weights?
   • Stackability and fragility?
   • Temperature requirements?

3. Loading Constraints

   • Weight distribution requirements?
   • Axle weight limits for trucking?
   • Loading sequence (LIFO/FIFO)?
   • Multi-destination shipments?
   • Securing and bracing requirements?

4. Optimization Objectives

   • Minimize number of containers?
   • Maximize utilization of each container?
   • Minimize shipping costs?
   • Ensure even weight distribution?
   • Optimize for specific loading sequence?

---

Container Loading Framework

Standard Container Dimensions

20ft Standard Dry Container

• External: 20' L x 8' W x 8'6" H (6.1m x 2.4m x 2.6m)
• Internal: 19'4" x 7'8" x 7'10" (5.9m x 2.35m x 2.39m)
• Capacity: 1,172 cu ft (33.2 m³)
• Max Gross Weight: 67,200 lbs (30,480 kg)
• Tare Weight: ~5,000 lbs (2,300 kg)
• Payload: ~62,000 lbs (28,180 kg)

40ft Standard Dry Container

• External: 40' L x 8' W x 8'6" H (12.2m x 2.4m x 2.6m)
• Internal: 39'6" x 7'8" x 7'10" (12.03m x 2.35m x 2.39m)
• Capacity: 2,390 cu ft (67.7 m³)
• Max Gross Weight: 67,200 lbs (30,480 kg)
• Tare Weight: ~8,200 lbs (3,750 kg)
• Payload: ~59,000 lbs (26,730 kg)

40ft High Cube (HC) Container

• External: 40' L x 8' W x 9'6" H (12.2m x 2.4m x 2.9m)
• Internal: 39'6" x 7'8" x 8'10" (12.03m x 2.35m x 2.69m)
• Capacity: 2,694 cu ft (76.3 m³)
• Max Gross Weight: 67,200 lbs (30,480 kg)
• Tare Weight: ~8,800 lbs (4,000 kg)
• Payload: ~58,400 lbs (26,480 kg)

45ft High Cube Container

• External: 45' L x 8' W x 9'6" H (13.72m x 2.4m x 2.9m)
• Internal: 44'6" x 7'8" x 8'10" (13.55m x 2.35m x 2.69m)
• Capacity: 3,043 cu ft (86.1 m³)
• Max Gross Weight: 67,200 lbs (30,480 kg)
• Payload: ~58,000 lbs (26,300 kg)

Key Loading Principles

1. Weight Distribution

• Distribute weight evenly along container length
• Target: <2% weight difference between front/back
• Consider axle weight limits for trucking
• Avoid concentrated loads

2. Center of Gravity

• Keep COG low (bottom 1/3 of container)
• Maintain lateral balance (side-to-side)
• Longitudinal balance (front-to-back)

3. Load Securing

• Secure cargo to prevent shifting
• Use dunnage, airbags, straps, or bracing
• Fill voids to minimize movement
• Consider dynamic forces during transport

4. Loading Sequence

• LIFO (Last In, First Out) for single destination
• FIFO (First In, First Out) for multi-drop
• Heavy items at bottom, light on top
• Fragile items protected

---

Mathematical Formulation

Container Loading Problem

Decision Variables:

• x_i, y_i, z_i = position of item i in container
• c_i = container number assigned to item i
• o_i = orientation of item i
• used_j = 1 if container j is used

Objective Functions:

1. Minimize containers: Minimize Σ used_j

2. Minimize cost: Minimize Σ (cost_j × used_j) + Σ (shipping_cost_i × c_i)

3. Maximize utilization: Maximize (Σ volume_loaded) / (Σ container_capacity)

Constraints:

1. Non-overlap within container
2. Weight capacity per container
3. Weight distribution balance
4. Loading sequence if required
5. Axle weight limits
6. Cargo compatibility (chemicals, food, etc.)

---

Algorithms and Solution Methods

Palletized Cargo Loading

class PalletizedContainerLoader:
    """
    Container loading optimizer for palletized cargo

    Handles standard pallets loaded into containers
    """

    def __init__(self, container_type='40HC'):
        """
        Initialize with container type

        Parameters:
        - container_type: '20', '40', '40HC', '45HC'
        """

        # Container internal dimensions (inches)
        containers = {
            '20': {'L': 232, 'W': 92, 'H': 94, 'capacity': 62000, 'cost': 1.0},
            '40': {'L': 474, 'W': 92, 'H': 94, 'capacity': 59000, 'cost': 1.5},
            '40HC': {'L': 474, 'W': 92, 'H': 106, 'capacity': 58400, 'cost': 1.6},
            '45HC': {'L': 534, 'W': 92, 'H': 106, 'capacity': 58000, 'cost': }
        }

         container_type   containers:
             ValueError()

        .container_type = container_type
        .container_dims = containers[container_type]
        .pallets = []
        .solution = 

     ():
        
         i  (quantity):
            pid =   pallet_id  quantity >   pallet_id  
            .pallets.append({
                : pid,
                : (length, width, height),
                : weight
            })

     ():
        

        
        sorted_pallets = (.pallets,
                               key= p: p[][] * p[][] * p[][],
                               reverse=)

        containers = []

         pallet  sorted_pallets:
            placed = 

            
             container  containers:
                 ._try_place_pallet(container, pallet, allow_rotation, double_stack):
                    placed = 
                    

            
              placed:
                new_container = {
                    : [],
                    : ,
                    : [],
                    : ._create_empty_grid()
                }

                 ._try_place_pallet(new_container, pallet, allow_rotation, double_stack):
                    containers.append(new_container)
                :
                    ()

        
        .solution = ._calculate_solution_metrics(containers)
         .solution

     ():
        

        L, W, H = .container_dims[], .container_dims[], .container_dims[]
        max_weight = .container_dims[]

        
         container[] + pallet[] > max_weight:
             

        
        orientations = [(pallet[][], pallet[][], pallet[][], )]
         allow_rotation:
            orientations.append((pallet[][], pallet[][], pallet[][], ))

        
         l, w, h, rotated  orientations:
            
             x  (, (L - l) + , ):  
                 y  (, (W - w) + , ):
                     ._check_space_available(container[], x, y, , l, w, h):
                        
                        ._occupy_space(container[], x, y, , l, w, h)
                        container[].append(pallet)
                        container[] += pallet[]
                        container[].append({
                            : pallet,
                            : (x, y, ),
                            : (l, w, h),
                            : rotated,
                            : 
                        })
                         

        
         double_stack:
             l, w, h, rotated  orientations:
                
                 pos  container[]:
                     pos[] == :
                        base_x, base_y, base_z = pos[]
                        base_l, base_w, base_h = pos[]

                        
                         (l <= base_l  w <= base_w 
                            base_z + base_h + h <= H):

                            stack_z = base_z + base_h

                             ._check_space_available(container[],
                                                          base_x, base_y, stack_z,
                                                          l, w, h):
                                
                                ._occupy_space(container[],
                                                  base_x, base_y, stack_z,
                                                  l, w, h)
                                container[].append(pallet)
                                container[] += pallet[]
                                container[].append({
                                    : pallet,
                                    : (base_x, base_y, stack_z),
                                    : (l, w, h),
                                    : rotated,
                                    : 
                                })
                                 

         

     ():
        
        
        L = (.container_dims[] / )
        W = (.container_dims[] / )
        H = (.container_dims[] / )
         [[[  _  (H)]  _  (W)]  _  (L)]

     ():
        
        x_cells = (x / )
        y_cells = (y / )
        z_cells = (z / )
        l_cells = ((l + ) / )
        w_cells = ((w + ) / )
        h_cells = ((h + ) / )

        :
             i  (x_cells, x_cells + l_cells):
                 j  (y_cells, y_cells + w_cells):
                     k  (z_cells, z_cells + h_cells):
                         i >= (grid)  j >= (grid[])  k >= (grid[][]):
                             
                         grid[i][j][k]:
                             
             
        :
             

     ():
        
        x_cells = (x / )
        y_cells = (y / )
        z_cells = (z / )
        l_cells = ((l + ) / )
        w_cells = ((w + ) / )
        h_cells = ((h + ) / )

         i  (x_cells, (x_cells + l_cells, (grid))):
             j  (y_cells, (y_cells + w_cells, (grid[]))):
                 k  (z_cells, (z_cells + h_cells, (grid[][]))):
                    grid[i][j][k] = 

     ():
        

        L = .container_dims[]
        W = .container_dims[]
        H = .container_dims[]
        container_volume = L * W * H

        solution = {
            : (containers),
            : .container_type,
            : []
        }

         idx, cont  (containers):
            
            volume_used = (
                pos[][] * pos[][] * pos[][]
                 pos  cont[]
            )

            utilization = (volume_used / container_volume * )

            solution[].append({
                : idx,
                : (cont[]),
                : cont[],
                : volume_used,
                : utilization,
                : cont[]
            })

         solution

     ():
        

          .solution:
            ()
            

        ( * )
        ()
        ( * )
        ()
        ()
        ()
        ()

         cont  .solution[]:
            ()
            ()
            ()
            ()
            ()



 __name__ == :
    
    loader = PalletizedContainerLoader(container_type=)

    
    loader.add_pallet(, , , , quantity=, pallet_id=)

    
    loader.add_pallet(, , , , quantity=, pallet_id=)

    
    solution = loader.optimize_loading(allow_rotation=, double_stack=)

    
    loader.print_solution()

Loose Cargo Loading

def optimize_loose_cargo_loading(items, container_type='40HC'):
    """
    Optimize loading of non-palletized (loose) cargo

    Uses 3D bin packing algorithms
    """

    from skills.three_d_bin_packing import ThreeDimensionalBinPacker

    # Container dimensions
    containers = {
        '20': (232, 92, 94, 62000),
        '40': (474, 92, 94, 59000),
        '40HC': (474, 92, 106, 58400),
        '45HC': (534, 92, 106, 58000)
    }

    L, W, H, max_weight = containers[container_type]

    # Use 3D bin packing
    packer = ThreeDimensionalBinPacker(L, W, H, max_weight)

    for item in items:
        packer.add_item(
            item['length'], item['width'], item['height'],
            item['weight'], item.get('id')
        )

    solution = packer.solve(algorithm='extreme_point', allow_rotation=True)

    return solution

Multi-Destination Loading

def optimize_multi_destination_loading(shipments, container_type='40HC'):
    """
    Optimize container loading for multi-destination shipments

    Ensures items are loaded in reverse delivery order (LIFO)

    Parameters:
    - shipments: list of dicts with 'destination', 'items', 'priority'
    - container_type: container size

    Returns: loading plan with zones
    """

    # Sort shipments by delivery order (last delivery first)
    sorted_shipments = sorted(shipments,
                             key=lambda s: s.get('priority', 0),
                             reverse=True)

    containers = []

    for shipment in sorted_shipments:
        destination = shipment['destination']
        items = shipment['items']

        # Try to add to existing container
        placed = False
        for container in containers:
            # Check if can add zone
            if container['remaining_capacity'] >= sum(i['volume'] for i in items):
                # Add zone
                container['zones'].append({
                    'destination': destination,
                    'items': items
                })
                placed = True
                break

        if not placed:
            # Create new container
            new_container = {
                'zones': [{
                    'destination': destination,
                    'items': items
                }],
                :   
            }
            containers.append(new_container)

     {
        : containers,
        : (containers)
    }

---

Common Challenges & Solutions

Challenge: Cube Out vs. Weight Out

Problem:

• Container full by volume but under weight limit (cube out)
• OR hit weight limit with space remaining (weight out)
• Inefficient use of capacity

Solutions:

• Mix dense and light cargo for balance
• Calculate cubic weight ratio
• Use appropriatecontainer size for cargo density
• Consider consolidation with other shipments
• For heavy cargo: use smaller containers or ship by weight
• For light cargo: maximize volume usage

Challenge: Weight Distribution

Problem:

• Uneven weight distribution
• Axle weight violations
• Container instability

Solutions:

• Calculate weight per linear foot
• Target even distribution (±2% variance)
• Place heavy items in middle/bottom
• Use load planning software
• Balance left/right, front/back
• Consider trucking axle limits

Challenge: Mixed Pallet Sizes

Problem:

• GMA and EUR pallets don't pack well together
• Wasted space between different sizes

Solutions:

• Group similar pallet sizes
• Load largest pallets first
• Use filler cargo for gaps
• Consider separate containers for different pallet types
• Optimize pallet patterns before containerization

---

Output Format

Container Loading Plan

Summary:

• Shipment: Order #12345
• Containers Required: 2 x 40ft HC
• Total Pallets: 22
• Total Weight: 48,500 lbs
• Average Utilization: 87%

Container 1 - 40ft HC:

• Pallets Loaded: 11
• Weight: 24,800 lbs (42% of capacity)
• Volume Utilization: 89%
• Weight Distribution: Front 48%, Rear 52% ✓

Loading Pattern:

[Front]                [Rear]
Row 1: P1 P2 P3 P4    P5 P6
Row 2: P7 P8 P9       P10 P11

Container 2 - 40ft HC:

• Pallets Loaded: 11
• Weight: 23,700 lbs (41% of capacity)
• Volume Utilization: 85%
• Weight Distribution: Front 51%, Rear 49% ✓

Securing Requirements:

• Stretch wrap all pallets
• Use load bars between rows
• Airbags for void spaces
• Secure doors with seal #ABC123

---

Questions to Ask

1. What container size are you using? (20ft, 40ft, 40ft HC, 45ft HC)
2. Are items palletized or loose cargo?
3. What are the pallet dimensions and weights?
4. Is there a weight limit or distribution requirement?
5. Is this single destination or multi-drop delivery?
6. Any special cargo (fragile, hazmat, temperature-controlled)?
7. Loading sequence requirements (LIFO/FIFO)?

---

Related Skills

• pallet-loading: For pallet-level optimization before container loading
• 3d-bin-packing: For loose cargo packing
• vehicle-loading-optimization: For truck loading
• load-building-optimization: For order consolidation
• freight-optimization: For shipping cost optimization