airline-cargo-optimization

name

airline-cargo-optimization

description

When the user wants to optimize airline cargo operations, manage air freight, or improve cargo revenue. Also use when the user mentions "air cargo optimization," "cargo capacity management," "freight yield management," "ULD optimization," "cargo routing," "air freight network," or "belly cargo management." For passenger operations, see hotel-inventory-management (for yield management concepts). For tour operations, see tour-operations.

Airline Cargo Optimization

You are an expert in airline cargo operations and air freight optimization. Your goal is to help maximize cargo revenue through optimal capacity allocation, pricing, routing, and handling while balancing passenger operations and operational constraints.

Initial Assessment

Before optimizing airline cargo, understand:

1. Cargo Operation Type

   • Cargo carrier type? (all-cargo, passenger belly, combi, freighter)
   • Network structure? (hub-and-spoke, point-to-point, regional)
   • Primary lanes and markets?
   • Freight forwarder relationships?

2. Capacity & Resources

   • Fleet composition and cargo capacity?
   • ULD (Unit Load Device) inventory?
   • Cargo handling facilities?
   • Warehouse and storage capacity?

3. Cargo Mix

   • Commodity types? (general cargo, express, special cargo)
   • Revenue contribution by type?
   • Special handling requirements? (perishables, pharma, dangerous goods)
   • E-commerce vs. traditional freight?

4. Objectives & Challenges

   • Primary goals? (revenue, yield, load factor)
   • Current pain points? (capacity utilization, pricing, operations)
   • Passenger vs. cargo priority?
   • Technology systems? (CMS, revenue management)

---

Airline Cargo Framework

Cargo Categories

General Cargo:

• Standard freight
• No special requirements
• Most flexible for capacity planning

Express & E-commerce:

• Time-sensitive shipments
• Priority handling
• Higher yield potential

Special Cargo:

• Perishables (flowers, seafood, produce)
• Pharmaceuticals (temperature-controlled)
• Dangerous goods (IATA regulations)
• Live animals
• Valuable cargo (jewelry, electronics)

Dimensional & Heavy Cargo:

• Oversized shipments
• Requires special ULDs or floor loading
• Aircraft compatibility constraints

---

Cargo Capacity Management

Belly Capacity Allocation

import numpy as np
import pandas as pd
from pulp import *

def optimize_cargo_capacity_allocation(flight, cargo_bookings, passenger_bags,
                                      available_capacity):
    """
    Optimize cargo allocation for passenger flight belly capacity

    Parameters:
    - flight: flight details (route, aircraft type, departure time)
    - cargo_bookings: list of cargo booking requests with rates
    - passenger_bags: expected passenger baggage (priority)
    - available_capacity: total cargo hold capacity (weight and volume)
    """

    prob = LpProblem("Cargo_Allocation", LpMaximize)

    # Variables: accept booking b (binary) and quantity
    accept = {}
    quantity = {}

    for b, booking in enumerate(cargo_bookings):
        accept[b] = LpVariable(f"Accept_{b}", cat='Binary')
        quantity[b] = LpVariable(f"Quantity_{b}",
                                lowBound=0,
                                upBound=booking['pieces'])

    # Objective: maximize cargo revenue
    revenue = lpSum([booking['rate_per_kg'] * booking['weight_per_piece'] *
                    quantity[b]
                    for b, booking in enumerate(cargo_bookings)])

    prob += revenue

    # Constraints

    # Weight capacity
    total_weight = (
        passenger_bags['weight'] +
        lpSum([booking['weight_per_piece'] * quantity[b]
              for b, booking in enumerate(cargo_bookings)])
    )
    prob += total_weight <= available_capacity['weight_kg']

    
    total_volume = (
        passenger_bags[] +
        lpSum([booking[] * quantity[b]
               b, booking  (cargo_bookings)])
    )
    prob += total_volume <= available_capacity[]

    
     b, booking  (cargo_bookings):
         booking.get(, ):
            
            prob += quantity[b] == booking[] * accept[b]
        :
            
            prob += quantity[b] <= booking[] * accept[b]

    
    

    
    prob.solve(PULP_CBC_CMD(msg=))

    
    accepted_bookings = []
    total_revenue = 
    total_cargo_weight = 

     b, booking  (cargo_bookings):
         quantity[b].varValue > :
            pieces_accepted = quantity[b].varValue
            weight = booking[] * pieces_accepted
            revenue_booking = booking[] * weight

            accepted_bookings.append({
                : booking[],
                : booking[],
                : booking[],
                : pieces_accepted,
                : weight,
                : revenue_booking,
                : booking[]
            })

            total_revenue += revenue_booking
            total_cargo_weight += weight

     {
        : LpStatus[prob.status],
        : value(prob.objective),
        : pd.DataFrame(accepted_bookings),
        : total_cargo_weight,
        : passenger_bags[],
        : total_cargo_weight + passenger_bags[],
        : (total_cargo_weight + passenger_bags[]) /
                               available_capacity[]
    }


flight = {: , : , : }

cargo_bookings = [
    {: , : , : ,
     : , : ,
     : , : },
    {: , : , : ,
     : , : ,
     : , : },
    {: , : , : ,
     : , : ,
     : , : },
    {: , : , : ,
     : , : ,
     : , : },
]

passenger_bags = {
    : ,  
    :      
}

available_capacity = {
    : ,
    : 
}

result = optimize_cargo_capacity_allocation(flight, cargo_bookings,
                                           passenger_bags, available_capacity)

()
()
(result[])

---

ULD (Unit Load Device) Optimization

ULD Build Optimization

class ULDOptimizer:
    """
    Optimize packing of cargo into ULDs (containers and pallets)
    """

    def __init__(self, uld_types):
        self.uld_types = uld_types  # dict of ULD specs

    def optimize_uld_assignment(self, cargo_pieces, available_ulds):
        """
        Assign cargo to ULDs to minimize ULD usage and maximize weight

        3D bin packing problem
        """
        from pulp import *

        prob = LpProblem("ULD_Assignment", LpMinimize)

        # Variables

        # x[p, u]: assign piece p to ULD u
        x = {}
        for p, piece in enumerate(cargo_pieces):
            for u, uld in enumerate(available_ulds):
                x[p, u] = LpVariable(f"Assign_{p}_{u}", cat='Binary')

        # y[u]: use ULD u
        y = {}
        for u, uld in enumerate(available_ulds):
            y[u] = LpVariable(f"Use_ULD_{u}", cat='Binary')

        # Objective: minimize number of ULDs used
        prob += lpSum([y[u] for u in range(len(available_ulds))])

        # Constraints

        # Each piece assigned to exactly one ULD
        for p in ((cargo_pieces)):
            prob += lpSum([x[p, u]  u  ((available_ulds))]) == 

        
         u, uld  (available_ulds):
            total_weight = lpSum([cargo_pieces[p][] * x[p, u]
                                  p  ((cargo_pieces))])

            prob += total_weight <= uld[] * y[u]

        
         u, uld  (available_ulds):
            total_volume = lpSum([cargo_pieces[p][] * x[p, u]
                                  p  ((cargo_pieces))])

            prob += total_volume <= uld[] * y[u]

        
         p  ((cargo_pieces)):
             u  ((available_ulds)):
                prob += x[p, u] <= y[u]

        
        prob.solve(PULP_CBC_CMD(msg=))

        
        assignments = []
         p, piece  (cargo_pieces):
             u, uld  (available_ulds):
                 x[p, u].varValue > :
                    assignments.append({
                        : piece[],
                        : uld[],
                        : piece[],
                        : piece[]
                    })

        ulds_used = [uld[]  u, uld  (available_ulds)
                     y[u].varValue > ]

         {
            : (ulds_used),
            : ulds_used,
            : pd.DataFrame(assignments),
            : LpStatus[prob.status]
        }

     ():
        

        uld_pieces = assignments[assignments[] == uld[]]

        total_weight = uld_pieces[].()
        total_volume = uld_pieces[].()

         {
            : total_weight / uld[],
            : total_volume / uld[],
            : (uld_pieces)
        }


cargo_pieces = [
    {: , : , : },
    {: , : , : },
    {: , : , : },
    {: , : , : },
    {: , : , : },
]

available_ulds = [
    {: , : , : , : },
    {: , : , : , : },
    {: , : , : , : },
]

optimizer = ULDOptimizer(uld_types={})
result = optimizer.optimize_uld_assignment(cargo_pieces, available_ulds)

()
()

---

Cargo Revenue Management

Dynamic Cargo Pricing

def optimize_cargo_pricing(flight, capacity_remaining, days_to_departure,
                          historical_demand, competitor_rates):
    """
    Dynamic pricing for air cargo based on demand and capacity

    Similar to passenger yield management but with cargo-specific factors

    Parameters:
    - flight: flight details
    - capacity_remaining: available cargo capacity (kg and m3)
    - days_to_departure: booking window remaining
    - historical_demand: historical booking patterns
    - competitor_rates: market rates
    """

    # Calculate recommended rates by commodity type

    rates = {}

    for commodity in ['general', 'express', 'pharma', 'perishable']:
        # Base rate from market
        base_rate = competitor_rates.get(commodity, 2.50)

        # Demand factor
        if days_to_departure <= 3:
            # Close to departure - increase rates if capacity limited
            if capacity_remaining['weight_kg'] < 1000:
                demand_factor = 1.5  # High demand, low capacity
            else:
                demand_factor = 0.8  # Need to fill capacity
        elif days_to_departure <= 7:
            demand_factor = 1.1
        else:
            demand_factor = 1.0

        # Commodity premium
        commodity_premium = {
            'general': 1.0,
            'express': 2.5,
            'pharma': 3.0,
            'perishable': 
        }.get(commodity, )

        
        recommended_rate = base_rate * demand_factor * commodity_premium

        
        min_rate = base_rate * 
        max_rate = base_rate * 

        recommended_rate = (min_rate, (recommended_rate, max_rate))

        rates[commodity] = {
            : recommended_rate,
            : base_rate,
            : demand_factor,
            : commodity_premium
        }

     rates


flight = {: , : , : }

capacity_remaining = {
    : ,
    : 
}

competitor_rates = {
    : ,
    : ,
    : ,
    : 
}

rates = optimize_cargo_pricing(flight, capacity_remaining, days_to_departure=,
                               historical_demand={}, competitor_rates=competitor_rates)

 commodity, rate_info  rates.items():
    (
         )

---

Cargo Network Optimization

Multi-Leg Cargo Routing

def optimize_cargo_routing(shipments, flight_network, connecting_times):
    """
    Optimize routing of cargo shipments through flight network

    Parameters:
    - shipments: list of cargo shipments with origin/destination
    - flight_network: available flights with capacity and timing
    - connecting_times: minimum connection times at each airport
    """
    from pulp import *
    import networkx as nx

    prob = LpProblem("Cargo_Routing", LpMaximize)

    # Build network graph
    G = nx.DiGraph()

    for flight in flight_network:
        G.add_edge(flight['origin'], flight['destination'],
                  flight_id=flight['id'],
                  capacity=flight['cargo_capacity_kg'],
                  departure_time=flight['departure_time'],
                  arrival_time=flight['arrival_time'])

    # Variables: route shipment s on flight f
    x = {}

    for s, shipment in enumerate(shipments):
        # Find all possible paths from origin to destination
        try:
            paths = list(nx.all_simple_paths(G, shipment['origin'],
                                            shipment['destination'],
                                            cutoff=3))  # Max 3 legs

            for path_idx, path in enumerate(paths):
                # Check if path is feasible (timing)
                feasible = True
                # Would need to check connection times here

                if feasible:
                    x[s, path_idx] = LpVariable(,
                                               cat=)
        :
              

    
    revenue = []
     (s, path_idx), var  x.items():
        shipment = shipments[s]
        
        revenue.append(shipment[] * var)

    prob += lpSum(revenue)

    

    
     s  ((shipments)):
        routes = [x[s, p]  (s_, p)  x.keys()  s_ == s]
         routes:
            prob += lpSum(routes) <= 

    
    

    
    prob.solve(PULP_CBC_CMD(msg=))

    
    selected_routes = []
     (s, path_idx), var  x.items():
         var.varValue > :
            shipment = shipments[s]
            selected_routes.append({
                : shipment[],
                : shipment[],
                : shipment[],
                : shipment[],
                : shipment[]
            })

     {
        : value(prob.objective),
        : selected_routes
    }

---

Special Cargo Handling

Temperature-Controlled Cargo

class TemperatureControlledCargo:
    """
    Manage pharmaceutical and perishable cargo requiring temp control
    """

    def __init__(self, aircraft_cool_chain_capacity):
        self.cool_chain_capacity = aircraft_cool_chain_capacity

    def validate_pharma_shipment(self, shipment):
        """
        Validate pharmaceutical shipment meets requirements

        - Temperature range
        - Packaging qualification
        - Lane approval
        - Handling certification
        """

        requirements = {
            'temp_range': shipment.get('required_temp_range', (2, 8)),  # °C
            'packaging': shipment.get('packaging_type'),
            'lane_approved': shipment.get('lane_approved', False),
            'gdp_certified': shipment.get('gdp_certified', False)  # Good Distribution Practice
        }

        validation_result = {
            'approved': True,
            'issues': []
        }

        # Check temperature capability
        temp_min, temp_max = requirements['temp_range']
        if temp_min < 2 or temp_max > 8:
            if not self.cool_chain_capacity.get('active_containers'):
                validation_result['approved'] = False
                validation_result[].append(
                    
                )

        
         requirements[]   [, ]:
            validation_result[] = 
            validation_result[].append()

        
          requirements[]:
            validation_result[] = 
            validation_result[].append()

         validation_result

     ():
        

        
         shipment  pharma_shipments:
            shipment[] = (
                shipment.get(, ) *  +
                shipment.get(, ) *  +
                shipment.get(, ) * 
            )

        sorted_shipments = (pharma_shipments,
                                 key= x: x[],
                                 reverse=)

        allocated = []
        capacity_used = 

         shipment  sorted_shipments:
             capacity_used + shipment[] <= .cool_chain_capacity[]:
                allocated.append(shipment)
                capacity_used += shipment[]

         {
            : allocated,
            : capacity_used / .cool_chain_capacity[]
        }

---

Tools & Libraries

Python Libraries

Optimization:

• PuLP: Linear programming
• OR-Tools: Google optimization tools
• networkx: Network routing and flow

3D Packing:

• py3dbp: 3D bin packing
• Custom algorithms for ULD optimization

Data Analysis:

• pandas, numpy: Data manipulation
• matplotlib: Visualization

Commercial Software

Cargo Management Systems (CMS):

• IBS iCargo: Comprehensive cargo management
• Mercator: Cargo revenue management
• Champ Cargosystems: Cargo IT solutions
• Smartkargo: Cloud-based cargo platform

Revenue Management:

• Pros Revenue Management: Pricing optimization
• Accelya: Cargo revenue optimization

Operations:

• SITA: Cargo operations and tracking
• Descartes: Cargo forwarding software
• CargoWise: Freight forwarding platform

ULD Management:

• Unilode: ULD pooling and management
• Nordisk Aviation Products: ULD tracking
• Jettainer: ULD solutions

---

Common Challenges & Solutions

Challenge: Capacity Forecasting

Problem:

• Passenger bag volumes uncertain
• Last-minute cargo bookings
• No-shows and cancellations

Solutions:

• Historical passenger bag analysis
• Seasonal adjustment factors
• Dynamic capacity release
• Overbooking strategies
• Real-time capacity updates

Challenge: Belly vs. Freighter Economics

Problem:

• Fixed costs of freighter operations
• Belly capacity as byproduct
• Market rate pressure

Solutions:

• Network optimization (belly + freighter)
• Freighter utilization targeting (>80%)
• Truck-to-freighter crossover analysis
• Wet-lease flexibility
• Asset-light models (charters)

Challenge: ULD Positioning

Problem:

• ULDs in wrong locations
• High repositioning costs
• ULD shortages at key stations

Solutions:

• ULD flow optimization models
• Empty ULD repositioning planning
• ULD pooling agreements
• Strategic ULD inventory positioning
• Alternative packaging solutions

Challenge: E-commerce Integration

Problem:

• Small shipments, high volume
• Speed requirements
• Deconsolidation needs

Solutions:

• Dedicated e-commerce products
• Hub deconsolidation facilities
• Express handling procedures
• Integration with integrators
• Premium pricing for speed

---

Output Format

Airline Cargo Performance Report

Executive Summary:

• Network cargo performance
• Revenue and yield trends
• Capacity utilization
• Key opportunities

Flight Performance:

Flight	Route	Aircraft	Capacity (kg)	Cargo Loaded	PAX Bags	Utilization	Revenue	Yield ($/kg)
AA100	JFK-LAX	B777	5,000	3,200	1,200	88%	$8,960	$2.80
AA200	LAX-NRT	B777	5,000	4,100	800	98%	$18,450	$4.50
AA300	ORD-LHR	B787	3,500	2,400	900	94%	$9,600	$4.00

Cargo Mix:

Commodity	Weight (tons)	Revenue	Yield ($/kg)	% of Revenue
General Cargo	450	$1,125,000	$2.50	42%
Express	120	$960,000	$8.00	36%
Pharmaceuticals	45	$360,000	$8.00	13%
Perishables	80	$240,000	$3.00	9%
Total	695	$2,685,000	$3.86	100%

ULD Utilization:

ULD Type	Quantity	Avg Weight Util	Avg Volume Util	Turns per Month
AKE	250	82%	68%	12
PMC	150	88%	75%	10
PGA	80	79%	71%	8

Recommendations:

1. Increase pharma capacity on LAX-NRT (high yield lane)
2. Improve ULD volume utilization through better load planning
3. Launch e-commerce express product for JFK-LAX
4. Renegotiate rates with top 3 freight forwarders
5. Add freighter service on ORD-PVG (strong demand)

---

Questions to Ask

If you need more context:

1. What type of cargo operation? (all-cargo, belly, combi)
2. What's the network structure and key lanes?
3. What cargo mix and commodity types?
4. What are current yield and load factor metrics?
5. What systems are in place? (CMS, revenue management)
6. What are the main challenges? (capacity, pricing, operations)
7. What special cargo capabilities exist? (pharma, perishables, etc.)

---

Related Skills

• network-design: For cargo network optimization
• route-optimization: For cargo routing
• inventory-optimization: For ULD inventory management
• hotel-inventory-management: For revenue management concepts
• 3d-bin-packing: For ULD loading optimization
• container-loading-optimization: For cargo packing
• demand-forecasting: For cargo demand forecasting
• fleet-management: For freighter fleet management