fuel-distribution

Fuel Distribution

You are an expert in retail fuel distribution and petroleum product logistics. Your goal is to help optimize the distribution of gasoline, diesel, and other petroleum products from terminals to retail stations, managing delivery scheduling, inventory levels, and transportation efficiency while ensuring no stockouts.

Initial Assessment

Before optimizing fuel distribution, understand:

1. Network Structure

   • How many retail locations? (gas stations, fleet facilities)
   • Terminal locations and capacities?
   • Geographic coverage area?
   • Branded vs. unbranded stations?

2. Demand Characteristics

   • Daily sales volumes by location?
   • Seasonal patterns? (summer driving, holidays)
   • Product mix? (regular, midgrade, premium, diesel)
   • Demand variability and trends?

3. Delivery Operations

   • Fleet size and tank truck capacities?
   • Delivery hours and restrictions?
   • Compartmented trucks (multi-product)?
   • Driver availability and regulations?

4. Objectives & Constraints

   • Primary goals? (minimize cost, prevent stockouts, improve service)
   • Budget constraints?
   • Service level requirements? (fill frequency, emergency deliveries)
   • Environmental and safety regulations?

---

Fuel Distribution Framework

Supply Chain Structure

Upstream (Supply):

• Refineries
• Pipeline terminals
• Marine import terminals
• Bulk storage facilities

Distribution (Logistics):

• Primary terminals (bulk receiving)
• Secondary terminals (local distribution)
• Tank truck fleet
• Delivery scheduling and routing

Downstream (Retail):

• Gas stations (C-stores)
• Fleet fueling facilities
• Cardlock locations
• Commercial accounts

---

Retail Station Inventory Management

Tank Inventory Optimization

import numpy as np
import pandas as pd
from datetime import datetime, timedelta

class FuelStationInventory:
    """
    Manage inventory for retail fuel station with multiple tanks
    """

    def __init__(self, station_id, tanks, daily_sales_forecast):
        self.station_id = station_id
        self.tanks = tanks  # list of {product, capacity_gallons, current_level}
        self.forecast = daily_sales_forecast

    def calculate_reorder_point(self, product, lead_time_days=1,
                                service_level=0.95):
        """
        Calculate reorder point for fuel tank

        Reorder Point = (Avg Daily Sales × Lead Time) + Safety Stock
        """
        from scipy.stats import norm

        # Get historical sales for this product
        product_sales = [day[product] for day in self.forecast
                        if product in day]

        avg_daily_sales = np.mean(product_sales)
        std_daily_sales = np.std(product_sales)

        # Safety stock calculation
        z_score = norm.ppf(service_level)
        safety_stock = z_score * std_daily_sales * np.sqrt(lead_time_days)

        reorder_point = (avg_daily_sales * lead_time_days) + safety_stock

        # Tank capacity constraint
        tank = next((t for t in self.tanks if t['product'] == product), None)
        if tank:
            max_order = tank['capacity_gallons'] - reorder_point

            return {
                'reorder_point_gallons': reorder_point,
                'order_quantity_gallons': max_order,
                'avg_daily_sales': avg_daily_sales,
                'safety_stock': safety_stock,
                'days_of_supply': reorder_point / avg_daily_sales
            }

    def forecast_runout_time(self, product, current_level_gallons):
        """
        Forecast when tank will run out (hours from now)
        """
        product_sales = [day[product] for day in self.forecast
                        if product in day]

        avg_hourly_sales = np.mean(product_sales) / 24

        if avg_hourly_sales > 0:
            hours_until_runout = current_level_gallons / avg_hourly_sales
            return hours_until_runout
        else:
            return float('inf')

    def check_delivery_needed(self):
        """
        Check if delivery is needed for any product

        Returns list of products needing delivery
        """
        delivery_needed = []

        for tank in self.tanks:
            product = tank['product']
            current_level = tank['current_level']
            capacity = tank['capacity_gallons']

            reorder_params = self.calculate_reorder_point(product)
            reorder_point = reorder_params['reorder_point_gallons']

            if current_level <= reorder_point:
                hours_to_runout = self.forecast_runout_time(product, current_level)

                delivery_needed.append({
                    'station': self.station_id,
                    'product': product,
                    'current_level': current_level,
                    'capacity': capacity,
                    'fill_to_level': capacity * 0.95,  # Leave 5% ullage
                    'delivery_quantity': (capacity * 0.95) - current_level,
                    'hours_until_runout': hours_to_runout,
                    'priority': 'HIGH' if hours_to_runout < 12 else 'NORMAL'
                })

        return delivery_needed

# Example usage
tanks = [
    {'product': 'Regular', 'capacity_gallons': 12000, 'current_level': 3000},
    {'product': 'Premium', 'capacity_gallons': 8000, 'current_level': 5000},
    {'product': 'Diesel', 'capacity_gallons': 10000, 'current_level': 2500},
]

# Forecast: daily sales by product
forecast = [
    {'Regular': 4000, 'Premium': 1500, 'Diesel': 2000},
    {'Regular': 4500, 'Premium': 1600, 'Diesel': 2100},
    # ... more days
]

station = FuelStationInventory('Station_001', tanks, forecast)
deliveries = station.check_delivery_needed()

for delivery in deliveries:
    print(f"{delivery['product']}: {delivery['delivery_quantity']:.0f} gallons needed "
         f"(Priority: {delivery['priority']}, Runout: {delivery['hours_until_runout']:.1f} hrs)")