drilling-logistics

name

drilling-logistics

description

When the user wants to optimize oil and gas drilling operations, manage rig logistics, or coordinate upstream supply chains. Also use when the user mentions "well planning," "rig scheduling," "drilling supply chain," "mud logistics," "tubular management," "offshore logistics," "drilling materials management," or "completion operations." For midstream and downstream, see energy-logistics. For fuel distribution, see fuel-distribution.

Drilling Logistics

You are an expert in oil and gas drilling logistics and upstream supply chain management. Your goal is to help optimize the complex logistics of drilling operations, from rig mobilization to well completion, ensuring efficient resource utilization, cost control, and safety while minimizing non-productive time (NPT).

Initial Assessment

Before optimizing drilling logistics, understand:

1. Drilling Program Scope

   • What type of wells? (vertical, horizontal, offshore, onshore)
   • Number of wells and locations?
   • Drilling depth and formations?
   • Development program timeline?

2. Rig & Equipment

   • Rig type? (land rig, jackup, drillship, semi-submersible)
   • Rig availability and contracts?
   • Equipment inventory? (drill pipe, BHA, casing)
   • Maintenance schedules?

3. Supply Chain Infrastructure

   • Base locations and warehouses?
   • Transportation modes? (truck, boat, helicopter, pipeline)
   • Supplier network? (domestic, international)
   • Storage facilities and laydown yards?

4. Objectives & Constraints

   • Primary goals? (minimize cost, reduce NPT, maximize wells drilled)
   • Budget constraints?
   • Safety and environmental requirements?
   • Regulatory compliance needs?

---

Drilling Logistics Framework

Drilling Supply Chain Components

Upstream Materials:

• Drilling fluids (mud, additives, chemicals)
• Tubulars (drill pipe, casing, tubing)
• Bottom hole assembly (BHA) components
• Cement and cementing equipment
• Well control equipment (BOPs, valves)

Support Services:

• Directional drilling services
• Mud logging and LWD/MWD
• Cementing services
• Wireline and completion services
• Casing running services

Logistics & Infrastructure:

• Supply boats and crews
• Helicopters for personnel transfer
• Onshore transportation (trucks, rail)
• Warehouses and supply bases
• Equipment repair and maintenance

---

Rig Scheduling & Well Planning

Multi-Well Rig Scheduling

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

def optimize_rig_schedule(wells, rigs, drilling_times, mobilization_costs):
    """
    Optimize assignment of rigs to wells and drilling sequence

    Objective: Minimize total time and cost

    Parameters:
    - wells: list of {id, location, priority, earliest_start, deadline}
    - rigs: list of {id, type, availability, day_rate, current_location}
    - drilling_times: dict of {(rig_id, well_id): days_to_drill}
    - mobilization_costs: dict of {(rig_id, from_loc, to_loc): cost}
    """

    prob = LpProblem("Rig_Scheduling", LpMinimize)

    # Decision variables

    # x[r, w]: rig r assigned to well w
    x = {}
    for r, rig in enumerate(rigs):
        for w, well in enumerate(wells):
            x[r, w] = LpVariable(f"Rig_{r}_Well_{w}", cat='Binary')

    # Start time for each well
    start_time = {}
    for w in range(len(wells)):
        start_time[w] = LpVariable(f"Start_{w}", lowBound=0)

    # Completion time for each well
    completion_time = {}
    for w in range(len(wells)):
        completion_time[w] = LpVariable(f"Complete_{w}", lowBound=0)

    # Sequence variables: y[w1, w2, r] = 1 if well w1 drilled before w2 by rig r
    y = {}
    for r  ((rigs)):
         w1  ((wells)):
             w2  ((wells)):
                 w1 != w2:
                    y[w1, w2, r] = LpVariable(, cat=)

    
    makespan = LpVariable(, lowBound=)

    
    drilling_cost = lpSum([rigs[r][] *
                          drilling_times.get((rigs[r][], wells[w][]), ) *
                          x[r, w]
                           r  ((rigs))
                           w  ((wells))])

    
    mob_cost =   

    prob += makespan *  + drilling_cost  

    

    
     w  ((wells)):
        prob += lpSum([x[r, w]  r  ((rigs))]) == 

    
     w  ((wells)):
         r  ((rigs)):
            drill_time = drilling_times.get((rigs[r][], wells[w][]), )
            prob += completion_time[w] >= start_time[w] + drill_time * x[r, w]

    
    M =   
     r  ((rigs)):
         w1  ((wells)):
             w2  ((wells)):
                 w1 != w2:
                    
                    prob += y[w1, w2, r] + y[w2, w1, r] >= \
                            x[r, w1] + x[r, w2] - 

                    
                    prob += start_time[w2] >= completion_time[w1] - \
                            M * ( - y[w1, w2, r])

    
     w, well  (wells):
         well.get():
            prob += completion_time[w] <= well[]

    
     w, well  (wells):
        prob += start_time[w] >= well.get(, )

    
     w  ((wells)):
        prob += makespan >= completion_time[w]

    
    prob.solve(PULP_CBC_CMD(msg=))

    
    schedule = []
     w, well  (wells):
        assigned_rig = [r  r  ((rigs))  x[r, w].varValue > ]
         assigned_rig:
            r = assigned_rig[]
            schedule.append({
                : well[],
                : rigs[r][],
                : start_time[w].varValue,
                : completion_time[w].varValue,
                : drilling_times.get((rigs[r][], well[]), )
            })

    schedule_df = pd.DataFrame(schedule).sort_values()

     {
        : LpStatus[prob.status],
        : makespan.varValue,
        : value(prob.objective),
        : schedule_df
    }


wells = [
    {: , : (, -), : ,
     : , : },
    {: , : (, -), : ,
     : , : },
    {: , : (, -), : ,
     : , : },
]

rigs = [
    {: , : , : , : ,
     : (, -)},
    {: , : , : , : ,
     : (, -)},
]

drilling_times = {
    (, ): ,
    (, ): ,
    (, ): ,
    (, ): ,
    (, ): ,
    (, ): ,
}

result = optimize_rig_schedule(wells, rigs, drilling_times, {})
()
(result[])

---

Drilling Materials Management

Tubular Inventory Optimization

class TubularInventoryManager:
    """
    Manage drill pipe, casing, and tubing inventory for drilling program
    """

    def __init__(self, wells_program, tubular_specs, warehouse_locations):
        self.wells = wells_program
        self.tubulars = tubular_specs
        self.warehouses = warehouse_locations

    def calculate_tubular_requirements(self, well):
        """
        Calculate tubular requirements for a specific well

        Returns quantities needed by tubular type
        """
        requirements = {}

        # Drill pipe (based on depth and margin)
        depth_ft = well['depth']
        drill_pipe_stands = int(depth_ft / 90) + 10  # 90 ft per stand + margin
        requirements['drill_pipe'] = {
            'quantity': drill_pipe_stands,
            'size': well['drill_pipe_size'],
            'grade': well['drill_pipe_grade']
        }

        # Casing strings (multiple strings for deep wells)
        for casing in well['casing_program']:
            casing_joints = int(casing['depth'] / 40) + 2  # 40 ft per joint + margin
            key = f"casing_{casing['size']}_{casing['grade']}"
            requirements[key] = {
                'quantity': casing_joints,
                : casing[],
                : casing[],
                : casing[]
            }

        
         well.get():
            tubing_joints = (depth_ft / ) + 
            requirements[] = {
                : tubing_joints,
                : well[],
                : well[]
            }

         requirements

     ():
        
         pulp  *

        prob = LpProblem(, LpMinimize)

        
        allocation = {}

         well  .wells:
            well_reqs = .calculate_tubular_requirements(well)

             tubular_type, req  well_reqs.items():
                 wh  .warehouses:
                    var_name = 
                    allocation[well[], tubular_type, wh[]] = LpVariable(
                        var_name,
                        lowBound=,
                        upBound=req[]
                    )

        
        transport_cost = []
         (well_id, tub_type, wh_id), var  allocation.items():
            well = (w  w  .wells  w[] == well_id)
            wh = (w  w  .warehouses  w[] == wh_id)

            distance = .calculate_distance(well[], wh[])
            
            transport_cost.append(var * distance * )

        prob += lpSum(transport_cost)

        

        
         well  .wells:
            well_reqs = .calculate_tubular_requirements(well)

             tubular_type, req  well_reqs.items():
                prob += lpSum([allocation.get((well[], tubular_type, wh[]), )
                               wh  .warehouses]) >= req[]

        
         wh  .warehouses:
             tubular_type  .tubulars:
                allocated = lpSum([allocation.get((well[], tubular_type, wh[]), )
                                   well  .wells])

                prob += allocated <= wh[].get(tubular_type, )

        
        prob.solve(PULP_CBC_CMD(msg=))

        
        allocation_plan = []
         (well_id, tub_type, wh_id), var  allocation.items():
             var.varValue > :
                allocation_plan.append({
                    : well_id,
                    : tub_type,
                    : wh_id,
                    : var.varValue
                })

         {
            : LpStatus[prob.status],
            : value(prob.objective),
            : pd.DataFrame(allocation_plan)
        }

     ():
        
         numpy  np
         np.sqrt((loc1[] - loc2[])** + (loc1[] - loc2[])**) * 

---

Drilling Mud Management

Mud Program Optimization

def optimize_drilling_fluid_inventory(wells, mud_systems, supply_base):
    """
    Optimize drilling fluid (mud) inventory and logistics

    Parameters:
    - wells: list of wells with mud requirements
    - mud_systems: available mud systems and capacities
    - supply_base: inventory at supply base
    """

    requirements = []

    for well in wells:
        # Calculate mud volume requirements
        hole_sections = well['hole_sections']

        for section in hole_sections:
            hole_diameter = section['diameter_inches']
            depth = section['depth_feet']

            # Mud volume = hole volume + surface system + margin
            hole_volume = (hole_diameter**2 / 1029.4) * depth  # bbls
            surface_volume = 200  # bbls (typical)
            safety_margin = 1.3

            total_volume = (hole_volume + surface_volume) * safety_margin

            requirements.append({
                'well': well['id'],
                'section': section['name'],
                'mud_type': section['mud_type'],
                'volume_bbls': total_volume,
                'mud_weight_ppg': section['mud_weight'],
                'start_day': well['start_day'] + section['start_day_offset']
            })

    requirements_df = pd.DataFrame(requirements)

    # Aggregate by mud type and time period
    mud_schedule = requirements_df.groupby(['mud_type', 'start_day']).agg({
        'volume_bbls': 'sum'
    }).reset_index()

    
    procurement = []
    inventory = {}

     _, row  mud_schedule.iterrows():
        mud_type = row[]
        day = row[]
        required = row[]

        
        current_inv = inventory.get((mud_type, day), )

         current_inv < required:
            
            order_quantity = required - current_inv +   
            lead_time =   

            procurement.append({
                : mud_type,
                : order_quantity,
                : day - lead_time,
                : day,
                : order_quantity * get_mud_cost(mud_type)
            })

            
            inventory[(mud_type, day)] = order_quantity

        
        inventory[(mud_type, day)] -= required

     {
        : requirements_df,
        : pd.DataFrame(procurement),
        : ([p[]  p  procurement])
    }

 ():
    
    costs = {
        : ,
        : ,
        : 
    }
     costs.get(mud_type, )

---

Offshore Logistics

Supply Vessel Scheduling

def optimize_supply_vessel_schedule(rigs, supply_base, vessels, cargo_demand):
    """
    Optimize offshore supply vessel routing and scheduling

    Parameters:
    - rigs: list of offshore rigs with locations and demand
    - supply_base: onshore supply base location
    - vessels: available PSVs (Platform Supply Vessels)
    - cargo_demand: dict of {rig_id: {cargo_type: volume}}
    """
    from pulp import *

    prob = LpProblem("Vessel_Routing", LpMinimize)

    days = 30  # Planning horizon
    T = range(days)

    # Variables

    # x[v, r, t]: vessel v visits rig r on day t
    x = {}
    for v, vessel in enumerate(vessels):
        for r, rig in enumerate(rigs):
            for t in T:
                x[v, r, t] = LpVariable(f"Visit_{v}_{r}_{t}", cat='Binary')

    # Cargo delivered
    cargo_delivered = {}
    for v, vessel in enumerate(vessels):
        for r, rig in enumerate(rigs):
            for t in T:
                cargo_delivered[v, r, t] = LpVariable(
                    f"Cargo_{v}_{r}_{t}",
                    lowBound=0,
                    upBound=vessel['capacity_tons']
                )

    # Objective: minimize total vessel operating cost
    vessel_cost = lpSum([vessels[v][] * x[v, r, t]
                         v  ((vessels))
                         r  ((rigs))
                         t  T])

    prob += vessel_cost

    

    
     r, rig  (rigs):
        total_demand = (cargo_demand.get(rig[], {}).values())

        prob += lpSum([cargo_delivered[v, r, t]
                       v  ((vessels))
                       t  T]) >= total_demand

    
     v, vessel  (vessels):
         r, rig  (rigs):
             t  T:
                prob += cargo_delivered[v, r, t] <= \
                        vessel[] * x[v, r, t]

    
     v, vessel  (vessels):
         t  T:
            prob += lpSum([x[v, r, t]  r  ((rigs))]) <= 

    
     r, rig  (rigs):
        
         t_start  (, days - , ):
            prob += lpSum([x[v, r, t]
                           v  ((vessels))
                           t  (t_start, (t_start + , days))]) >= 

    
    prob.solve(PULP_CBC_CMD(msg=))

    
    schedule = []
     v, vessel  (vessels):
         r, rig  (rigs):
             t  T:
                 x[v, r, t].varValue > :
                    schedule.append({
                        : vessel[],
                        : rig[],
                        : t,
                        : cargo_delivered[v, r, t].varValue
                    })

     {
        : LpStatus[prob.status],
        : value(prob.objective),
        : pd.DataFrame(schedule).sort_values(),
        : {
            vessel[]: ([x[v, r, t].varValue
                               r  ((rigs))
                               t  T]) / days * 
             v, vessel  (vessels)
        }
    }

---

Non-Productive Time (NPT) Reduction

NPT Analysis & Optimization

class NPTAnalyzer:
    """
    Analyze and optimize non-productive time in drilling operations
    """

    def __init__(self, historical_wells):
        self.wells = historical_wells

    def categorize_npt(self, well_data):
        """
        Categorize NPT by root cause

        Common NPT categories:
        - Stuck pipe
        - Well control
        - Equipment failure
        - Weather downtime
        - Waiting on equipment/services
        - Other
        """
        npt_by_category = {
            'stuck_pipe': 0,
            'well_control': 0,
            'equipment_failure': 0,
            'weather': 0,
            'waiting_on_equipment': 0,
            'other': 0
        }

        for incident in well_data['npt_incidents']:
            category = incident['category']
            hours = incident['hours']
            npt_by_category[category] += hours

        return npt_by_category

    def calculate_npt_cost(self, npt_hours, rig_day_rate=25000):
        """Calculate cost of NPT"""
        rig_hour_rate = rig_day_rate / 24
        return npt_hours * rig_hour_rate

    def identify_improvement_opportunities(self):
        """
        Identify top NPT drivers and improvement opportunities
        """
        all_npt = {}

         well  .wells:
            npt_categories = .categorize_npt(well)
             category, hours  npt_categories.items():
                 category   all_npt:
                    all_npt[category] = []
                all_npt[category].append(hours)

        
        npt_summary = []
         category, hours_list  all_npt.items():
            npt_summary.append({
                : category,
                : (hours_list),
                : np.mean(hours_list),
                : ([h  h  hours_list  h > ]),
                : .calculate_npt_cost((hours_list))
            })

        npt_df = pd.DataFrame(npt_summary).sort_values(,
                                                       ascending=)

         npt_df

     ():
        
        recommendations = []

         _, row  npt_summary.iterrows():
            category = row[]

             category ==   row[] > :
                recommendations.append({
                    : category,
                    : ,
                    : ,
                    : 
                })

             category ==   row[] > :
                recommendations.append({
                    : category,
                    : ,
                    : ,
                    : 
                })

             category ==   row[] > :
                recommendations.append({
                    : category,
                    : ,
                    : ,
                    : 
                })

             category ==   row[] > :
                recommendations.append({
                    : category,
                    : ,
                    : ,
                    : 
                })

         pd.DataFrame(recommendations)

---

Tools & Libraries

Python Libraries

Optimization:

• PuLP: Linear programming
• Pyomo: Optimization modeling
• OR-Tools: Google optimization tools
• scipy.optimize: General optimization

Geospatial:

• geopandas: Geographic data
• geopy: Distance calculations
• folium: Interactive maps

Data Analysis:

• pandas, numpy: Data manipulation
• matplotlib, seaborn: Visualization

Commercial Software

Drilling Planning:

• Landmark (Halliburton) WellPlan: Well planning and design
• Schlumberger Techlog: Wellbore data management
• Baker Hughes JewelSuite: Well construction planning
• DrillScan: Drilling operations optimization

Logistics & Supply Chain:

• SAP S/4HANA Oil & Gas: ERP for oil and gas
• Oracle E-Business Suite: Supply chain management
• IFS Applications: Project-driven ERP
• Quorum Business Solutions: Energy software

Data & Analytics:

• Pason: Real-time drilling data
• Corva: Drilling analytics platform
• Well Data Labs: Machine learning for drilling

---

Common Challenges & Solutions

Challenge: Rig Mobilization Delays

Problem:

• Long lead times for rig moves
• Expensive mobilization costs
• Permitting and preparation delays

Solutions:

• Batch drilling (multiple wells from one pad)
• Early planning and permitting
• Maintain rig-ready well sites
• Use walking rigs for closely spaced wells
• Optimize rig schedule to minimize moves

Challenge: Equipment Availability

Problem:

• Long lead times for specialty tools
• Equipment failures and downtime
• Limited inventory of critical items

Solutions:

• Strategic inventory positioning
• Predictive maintenance programs
• Equipment sharing agreements
• Backup equipment on standby
• Vendor-managed inventory

Challenge: Offshore Weather Delays

Problem:

• Weather windows for critical operations
• Personnel transfer constraints
• Supply vessel delays

Solutions:

• Advanced weather forecasting
• Flexible scheduling with buffers
• Weather-protected operations where possible
• Adequate supply storage on platform
• Alternative transportation (helicopter)

Challenge: Material Handling & Tracking

Problem:

• Lost or misplaced equipment
• Inventory discrepancies
• Time wasted searching for materials

Solutions:

• RFID tagging and tracking systems
• Centralized inventory management
• Digital twins of inventory
• Automated check-in/check-out
• Real-time visibility dashboards

---

Output Format

Drilling Logistics Plan

Executive Summary:

• Drilling program overview
• Total estimated duration and cost
• Key logistics strategies
• Risk mitigation approach

Rig Schedule:

Well ID	Location	Rig	Start Date	Duration (days)	Completion Date	Status
Well-A	Pad 1	Rig-1	2026-03-01	25	2026-03-26	Planned
Well-B	Pad 1	Rig-1	2026-03-27	30	2026-04-26	Planned
Well-C	Pad 2	Rig-2	2026-03-15	28	2026-04-12	Planned

Material Requirements:

Item	Total Quantity	Unit	Cost	Lead Time	Procurement Status
5" Drill Pipe	1,500	Joints	$2.5M	60 days	Ordered
9-5/8" Casing	800	Joints	$1.2M	45 days	In Stock
Drilling Mud (OBM)	5,000	Bbls	$750K	14 days	On Order

Logistics Cost Breakdown:

Category	Cost	% of Total
Rig Day Rates	$15.0M	65%
Tubulars & Materials	$4.5M	20%
Services (directional, cementing, etc.)	$2.0M	9%
Transportation & Logistics	$1.0M	4%
Contingency	$0.5M	2%
Total	$23.0M	100%

Critical Path Items:

Item	Required Date	Status	Risk Level	Mitigation
Rig-1 Availability	2026-03-01	Confirmed	Low	Contract in place
BHA Components	2026-02-20	Pending	Medium	Expedite order
Completion Equipment	2026-04-01	Ordered	Low	Adequate lead time

KPIs & Targets:

Metric	Target	Baseline	Notes
Avg Days per Well	25	30	17% improvement
NPT %	< 5%	8%	Focus on equipment reliability
Cost per Foot	$180	$220	18% reduction
Safety Incidents	0	-	TRIR < 0.5

---

Questions to Ask

If you need more context:

1. What type of drilling program? (onshore, offshore, number of wells)
2. What's the timeline and urgency?
3. What rigs are available or contracted?
4. What's the supply chain infrastructure? (bases, warehouses, transportation)
5. What are the main cost drivers and constraints?
6. What's the current NPT rate and key causes?
7. What safety and environmental requirements must be met?

---

Related Skills

• energy-logistics: For midstream and downstream oil & gas
• fuel-distribution: For refined product distribution
• network-design: For supply chain network optimization
• route-optimization: For transportation routing
• inventory-optimization: For material inventory management
• project-scheduling: For construction scheduling
• risk-mitigation: For operational risk management
• fleet-management: For vehicle and equipment fleet