| name | distribution-center-network |
| description | When the user wants to design distribution center networks, optimize DC placement and flows, or configure multi-echelon distribution systems. Also use when the user mentions "DC network design," "distribution network optimization," "multi-echelon distribution," "regional DC placement," "distribution strategy," "fulfillment network design," or "supply chain network configuration." For warehouse location, see warehouse-location-optimization. For general facility location, see facility-location-problem. |
Distribution Center Network Design
You are an expert in distribution center network design and multi-echelon supply chain optimization. Your goal is to help design optimal distribution networks that minimize total costs while meeting service requirements, considering flows from plants through DCs to customers.
Initial Assessment
Before designing DC networks, understand:
-
Network Structure
- Current network configuration?
- Single-echelon (DCs → customers only)?
- Multi-echelon (plants → DCs → customers)?
- Direct shipments allowed? (plants → customers)
- Cross-docking operations?
-
Facility Tiers
- Manufacturing plants/sources?
- Regional distribution centers (RDCs)?
- Local distribution centers (LDCs)?
- Forward stocking locations (FSLs)?
- Customer locations?
-
Product Characteristics
- Product variety (SKUs)?
- Product families or categories?
- Storage requirements (ambient, refrigerated, hazmat)?
- Value density (value per volume/weight)?
- Shelf life and perishability?
-
Flow Patterns
- Where do products originate? (domestic plants, imports, suppliers)
- Where is demand? (customers, markets, retail stores)
- Volume by lane (origin-destination pairs)?
- Seasonal patterns?
- Growth projections?
-
Cost Structure
- Plant/source costs (production, handling)?
- DC fixed costs (lease, capital, setup)?
- DC operating costs (handling, labor, utilities)?
- Transportation costs (inbound, inter-DC, outbound)?
- Inventory costs (working inventory, safety stock)?
- Service penalty costs (late delivery, lost sales)?
Distribution Network Design Framework
Network Configuration Options
1. Direct Shipment (0-Echelon)
Plants/Sources → Customers
- Pros: No intermediate handling, lowest transit time
- Cons: High transportation costs for small shipments
- Best for: High-value, time-sensitive, large orders
2. Single-Echelon (1-Echelon)
Plants/Sources → Distribution Centers → Customers
- Pros: Consolidation benefits, economies of scale
- Cons: Additional handling, inventory at DCs
- Best for: Most B2B and retail distribution
3. Two-Echelon (2-Echelon)
Plants → Regional DCs → Local DCs → Customers
- Pros: Better market coverage, faster delivery
- Cons: More complex, higher inventory, more facilities
- Best for: Large geographic areas, high service requirements
4. Hybrid Network
Plants ─→ Regional DCs ─→ Customers
└─→ Direct ────────┘
- Pros: Flexibility, optimize by product/customer
- Cons: Complex planning and execution
- Best for: Differentiated service strategies
Key Design Decisions
Strategic (Long-term):
- Number of echelons
- Number and location of DCs
- DC sizes and capacities
- Technology and automation levels
- Ownership (own vs. outsource/3PL)
Tactical (Medium-term):
- Product-DC assignments
- Customer-DC assignments
- Inventory positioning
- Transportation modes
- Seasonality strategies
Operational (Short-term):
- Order fulfillment assignments
- Replenishment decisions
- Vehicle routing
- Load consolidation
Mathematical Formulations
Multi-Echelon DC Network Design Model
Sets:
- P: Plants/sources
- D: Potential DC locations
- C: Customers
- K: Products
Parameters:
- f_d: Fixed cost to open DC d
- Q_d: Capacity of DC d
- c_{pd}: Unit cost from plant p to DC d
- c_{dc}: Unit cost from DC d to customer c
- c_{pc}: Unit cost from plant p directly to customer c (if allowed)
- d_{ck}: Demand of customer c for product k
- α_k: Unit inventory cost for product k at DC
- s_{pk}: Supply/production capacity of plant p for product k
Decision Variables:
- y_d ∈ {0,1}: 1 if DC d is opened
- x_{pdk}: Flow of product k from plant p to DC d
- z_{dck}: Flow of product k from DC d to customer c
- w_{pck}: Flow of product k from plant p directly to customer c (if direct shipping allowed)
Objective Function:
Minimize:
DC fixed costs:
Σ_d f_d × y_d
+ Inbound transportation (plant → DC):
Σ_p Σ_d Σ_k c_{pd} × x_{pdk}
+ Outbound transportation (DC → customer):
Σ_d Σ_c Σ_k c_{dc} × z_{dck}
+ Direct shipment costs (if allowed):
Σ_p Σ_c Σ_k c_{pc} × w_{pck}
+ DC inventory costs:
Σ_d Σ_k α_k × (Σ_c z_{dck})
Constraints:
1. Demand satisfaction:
Σ_d z_{dck} + Σ_p w_{pck} = d_{ck}, ∀c ∈ C, ∀k ∈ K
2. DC capacity:
Σ_c Σ_k z_{dck} ≤ Q_d × y_d, ∀d ∈ D
3. Flow balance at DCs:
Σ_p x_{pdk} = Σ_c z_{dck}, ∀d ∈ D, ∀k ∈ K
4. Plant capacity:
Σ_d x_{pdk} + Σ_c w_{pck} ≤ s_{pk}, ∀p ∈ P, ∀k ∈ K
5. Serve only from open DCs:
z_{dck} ≤ M × y_d, ∀d ∈ D, ∀c ∈ C, ∀k ∈ K
where M is a large constant (customer demand sum)
6. Non-negativity and binary:
y_d ∈ {0,1}, ∀d ∈ D
x_{pdk}, z_{dck}, w_{pck} ≥ 0
Service-Level Constrained Model
Additional Parameters:
- T_c: Maximum acceptable delivery time for customer c
- t_{dc}: Delivery time from DC d to customer c
- SL: Minimum service level (e.g., 95% of demand met within time)
Service Constraints:
1. Each customer must be within service time of at least one DC:
Σ_{d: t_{dc} ≤ T_c} y_d ≥ 1, ∀c ∈ C
2. Or aggregate service level:
Σ_c Σ_{d: t_{dc} ≤ T_c} z_{dck} ≥ SL × Σ_c d_{ck}, ∀k ∈ K
Solution Methods
1. Multi-Echelon MIP Model
from pulp import *
import numpy as np
import pandas as pd
def solve_dc_network_design(plants, dcs, customers, products,
dc_costs, capacities, inbound_costs,
outbound_costs, demands,
plant_capacities=None, allow_direct=False):
"""
Solve multi-echelon DC network design problem
Args:
plants: list of plant IDs
dcs: list of potential DC IDs
customers: list of customer IDs
products: list of product IDs
dc_costs: dict {dc_id: fixed_cost}
capacities: dict {dc_id: capacity}
inbound_costs: dict {(plant, dc, product): cost}
outbound_costs: dict {(dc, customer, product): cost}
demands: dict {(customer, product): demand}
plant_capacities: optional dict {(plant, product): capacity}
allow_direct: allow direct plant-to-customer shipments
Returns:
optimal network design solution
"""
prob = LpProblem("DC_Network_Design", LpMinimize)
y = LpVariable.dicts("DC", dcs, cat='Binary')
x = {}
for p in plants:
for d in dcs:
for k in products:
x[p,d,k] = LpVariable(f"inbound_{p}_{d}_{k}",
lowBound=0, cat='Continuous')
z = {}
for d in dcs:
for c customers:
k products:
z[d,c,k] = LpVariable(,
lowBound=, cat=)
w = {}
allow_direct:
p plants:
c customers:
k products:
w[p,c,k] = LpVariable(,
lowBound=, cat=)
fixed_cost_expr = lpSum([dc_costs[d] * y[d] d dcs])
inbound_expr = lpSum([
inbound_costs.get((p,d,k), ) * x[p,d,k]
p plants d dcs k products
])
outbound_expr = lpSum([
outbound_costs.get((d,c,k), ) * z[d,c,k]
d dcs c customers k products
])
prob += fixed_cost_expr + inbound_expr + outbound_expr,
c customers:
k products:
(c, k) demands:
allow_direct:
prob += (
lpSum([z[d,c,k] d dcs]) +
lpSum([w[p,c,k] p plants]) ==
demands[c,k],
)
:
prob += (
lpSum([z[d,c,k] d dcs]) == demands[c,k],
)
d dcs:
prob += (
lpSum([z[d,c,k]
c customers k products]) <=
capacities[d] * y[d],
)
d dcs:
k products:
prob += (
lpSum([x[p,d,k] p plants]) ==
lpSum([z[d,c,k] c customers]),
)
plant_capacities:
p plants:
k products:
(p, k) plant_capacities:
allow_direct:
prob += (
lpSum([x[p,d,k] d dcs]) +
lpSum([w[p,c,k] c customers]) <=
plant_capacities[p,k],
)
:
prob += (
lpSum([x[p,d,k] d dcs]) <=
plant_capacities[p,k],
)
d dcs:
c customers:
k products:
(c, k) demands:
M = demands[c,k]
prob += (
z[d,c,k] <= M * y[d],
)
time
start_time = time.time()
prob.solve(PULP_CBC_CMD(msg=, timeLimit=))
solve_time = time.time() - start_time
LpStatus[prob.status] [, ]:
open_dcs = [d d dcs y[d].varValue > ]
inbound_flows = {}
p plants:
d dcs:
k products:
x[p,d,k].varValue > :
inbound_flows[p,d,k] = x[p,d,k].varValue
outbound_flows = {}
d dcs:
c customers:
k products:
z[d,c,k].varValue > :
outbound_flows[d,c,k] = z[d,c,k].varValue
dc_utilization = {}
d open_dcs:
total_flow = (z[d,c,k].varValue
c customers k products)
dc_utilization[d] = (total_flow / capacities[d]) *
total_fixed = (dc_costs[d] d open_dcs)
total_inbound = (
inbound_costs.get((p,d,k), ) * x[p,d,k].varValue
p plants d dcs k products
)
total_outbound = (
outbound_costs.get((d,c,k), ) * z[d,c,k].varValue
d dcs c customers k products
)
{
: LpStatus[prob.status],
: value(prob.objective),
: total_fixed,
: total_inbound,
: total_outbound,
: open_dcs,
: (open_dcs),
: inbound_flows,
: outbound_flows,
: dc_utilization,
: solve_time
}
:
{
: LpStatus[prob.status],
: solve_time
}
__name__ == :
plants = [, , ]
dcs = [, , , , ]
customers = [ i (, )]
products = [, , ]
dc_costs = {
: , : , : ,
: , :
}
capacities = {
: , : , : ,
: , :
}
np.random.seed()
inbound_costs = {}
p plants:
d dcs:
k products:
inbound_costs[p,d,k] = np.random.uniform(, )
outbound_costs = {}
d dcs:
c customers:
k products:
outbound_costs[d,c,k] = np.random.uniform(, )
demands = {}
c customers:
k products:
demands[c,k] = np.random.uniform(, )
plant_capacities = {}
p plants:
k products:
plant_capacities[p,k] =
(*)
()
(*)
()
()
()
()
()
result = solve_dc_network_design(
plants, dcs, customers, products,
dc_costs, capacities,
inbound_costs, outbound_costs, demands,
plant_capacities
)
()
()
()
()
()
(
)
(
)
(
)
()
dc result[]:
(
)
()
()
count =
(d, c, k), flow result[].items():
count >= :
()
count +=
2. Network Flow Optimization
def optimize_network_flows(open_dcs, plants, customers, products,
inbound_costs, outbound_costs, demands,
dc_capacities, plant_capacities):
"""
Optimize flows through given DC network
Given fixed DC locations, optimize product flows
Args:
open_dcs: list of open DC locations
plants, customers, products: network nodes
costs, demands, capacities: network parameters
Returns:
optimal flow pattern
"""
prob = LpProblem("Network_Flow", LpMinimize)
x = {}
for p in plants:
for d in open_dcs:
for k in products:
x[p,d,k] = LpVariable(f"inbound_{p}_{d}_{k}",
lowBound=0, cat='Continuous')
z = {}
for d in open_dcs:
for c in customers:
for k in products:
z[d,c,k] = LpVariable(f"outbound_{d}_{c}_{k}",
lowBound=0, cat='Continuous')
prob += (
lpSum([inbound_costs.get((p,d,k), 0) * x[p,d,k]
for p in plants for d in open_dcs for k in products]) +
lpSum([outbound_costs.get((d,c,k), ) * z[d,c,k]
d open_dcs c customers k products]),
)
c customers:
k products:
(c, k) demands:
prob += (
lpSum([z[d,c,k] d open_dcs]) == demands[c,k],
)
d open_dcs:
prob += (
lpSum([z[d,c,k] c customers k products]) <=
dc_capacities[d],
)
d open_dcs:
k products:
prob += (
lpSum([x[p,d,k] p plants]) ==
lpSum([z[d,c,k] c customers]),
)
p plants:
k products:
(p, k) plant_capacities:
prob += (
lpSum([x[p,d,k] d open_dcs]) <=
plant_capacities[p,k],
)
prob.solve(PULP_CBC_CMD(msg=))
LpStatus[prob.status] [, ]:
inbound_flows = {
(p,d,k): x[p,d,k].varValue
p plants d open_dcs k products
x[p,d,k].varValue >
}
outbound_flows = {
(d,c,k): z[d,c,k].varValue
d open_dcs c customers k products
z[d,c,k].varValue >
}
{
: LpStatus[prob.status],
: value(prob.objective),
: inbound_flows,
: outbound_flows
}
{: LpStatus[prob.status]}
Heuristic Approaches
1. Clustering-Based DC Selection
from sklearn.cluster import KMeans
def clustering_based_dc_selection(customer_locations, customer_demands,
potential_dc_locations, num_dcs):
"""
Use demand-weighted clustering to select DC locations
Args:
customer_locations: array of customer coordinates
customer_demands: customer demand weights
potential_dc_locations: candidate DC coordinates
num_dcs: number of DCs to select
Returns:
selected DC indices
"""
weights = (customer_demands / customer_demands.min()).astype(int)
weighted_locations = []
for i, loc in enumerate(customer_locations):
weighted_locations.extend([loc] * weights[i])
weighted_locations = np.array(weighted_locations)
kmeans = KMeans(n_clusters=num_dcs, random_state=42)
kmeans.fit(weighted_locations)
cluster_centers = kmeans.cluster_centers_
selected_dcs = []
for center in cluster_centers:
distances = [np.linalg.norm(center - dc_loc)
for dc_loc in potential_dc_locations]
nearest_dc = np.argmin(distances)
if nearest_dc not in selected_dcs:
selected_dcs.append(nearest_dc)
while len(selected_dcs) < num_dcs:
best_dc = None
best_total_dist = float('inf')
for dc_idx in ((potential_dc_locations)):
dc_idx selected_dcs:
total_dist = (
customer_demands[i] *
np.linalg.norm(potential_dc_locations[dc_idx] - customer_locations[i])
i ((customer_locations))
)
total_dist < best_total_dist:
best_total_dist = total_dist
best_dc = dc_idx
best_dc :
selected_dcs.append(best_dc)
:
selected_dcs
2. Iterative Location-Allocation
def iterative_location_allocation(potential_dcs, customers, demands,
transport_costs, dc_costs, capacities,
num_dcs, max_iterations=50):
"""
Iterative heuristic: alternate between location and allocation
Args:
potential_dcs: list of potential DC locations
customers: list of customers
demands: customer demands
transport_costs: outbound transport costs
dc_costs: DC fixed costs
capacities: DC capacities
num_dcs: number of DCs to open
max_iterations: maximum iterations
Returns:
heuristic solution
"""
current_dcs = random.sample(potential_dcs, num_dcs)
def allocate_customers(dcs):
"""Allocate each customer to nearest DC with capacity"""
assignments = {}
remaining_capacity = {d: capacities[d] for d in dcs}
sorted_customers = sorted(customers,
key=lambda c: demands[c],
reverse=True)
for c in sorted_customers:
best_dc = None
min_cost = float('inf')
for d in dcs:
if remaining_capacity[d] >= demands[c]:
cost = transport_costs.get((d, c), float('inf'))
if cost < min_cost:
min_cost = cost
best_dc = d
if best_dc:
assignments[c] = best_dc
remaining_capacity[best_dc] -= demands[c]
else:
best_dc = (dcs, key= d: transport_costs.get((d,c), ()))
assignments[c] = best_dc
assignments
():
fixed = (dc_costs[d] d dcs)
transport = (
transport_costs.get((assignments[c], c), ) * demands[c]
c customers c assignments
)
fixed + transport
best_dcs = current_dcs.copy()
best_assignments = allocate_customers(current_dcs)
best_cost = calculate_cost(current_dcs, best_assignments)
iteration (max_iterations):
current_assignments = allocate_customers(current_dcs)
improved =
open_dc current_dcs:
closed_dc potential_dcs:
closed_dc current_dcs:
test_dcs = [d d != open_dc closed_dc
d current_dcs]
test_assignments = allocate_customers(test_dcs)
test_cost = calculate_cost(test_dcs, test_assignments)
test_cost < best_cost - :
best_cost = test_cost
best_dcs = test_dcs.copy()
best_assignments = test_assignments
current_dcs = test_dcs
improved =
improved:
improved:
{
: best_dcs,
: best_assignments,
: best_cost,
:
}
Complete DC Network Solver
class DCNetworkSolver:
"""
Comprehensive Distribution Center Network Design Solver
"""
def __init__(self):
self.plants = None
self.dcs = None
self.customers = None
self.products = None
self.loaded = False
def load_problem(self, network_data):
"""
Load network design problem
Args:
network_data: dict with all problem data
- plants, dcs, customers, products
- costs, capacities, demands
"""
self.plants = network_data['plants']
self.dcs = network_data['dcs']
self.customers = network_data['customers']
self.products = network_data.get('products', ['Product1'])
self.dc_costs = network_data['dc_costs']
self.capacities = network_data['capacities']
self.inbound_costs = network_data['inbound_costs']
self.outbound_costs = network_data['outbound_costs']
self.demands = network_data['demands']
self.plant_capacities = network_data.get('plant_capacities')
.loaded =
()
()
()
()
()
()
():
.loaded:
ValueError()
()
solve_dc_network_design(
.plants, .dcs, .customers, .products,
.dc_costs, .capacities,
.inbound_costs, .outbound_costs,
.demands, .plant_capacities,
allow_direct
)
():
()
NotImplementedError()
():
pandas pd
results = []
num_dcs dc_counts:
()
results.append({
: num_dcs,
: ,
: ,
:
})
pd.DataFrame(results)
():
matplotlib.pyplot plt
coordinates :
()
__name__ == :
network_data = {
: [, ],
: [, , , ],
: [ i (, )],
: [, ],
: {
: , : ,
: , :
},
: {
: , : ,
: , :
},
: {},
: {},
: {},
: {}
}
np.random.seed()
p network_data[]:
d network_data[]:
k network_data[]:
network_data[][p,d,k] = np.random.uniform(, )
d network_data[]:
c network_data[]:
k network_data[]:
network_data[][d,c,k] = np.random.uniform(, )
c network_data[]:
k network_data[]:
network_data[][c,k] = np.random.uniform(, )
p network_data[]:
k network_data[]:
network_data[][p,k] =
solver = DCNetworkSolver()
solver.load_problem(network_data)
solution = solver.solve_exact()
()
()
()
()
()
()
Tools & Libraries
Python Libraries
- PuLP/Pyomo: MIP modeling
- OR-Tools: Network optimization
- NetworkX: Network analysis
- scikit-learn: Clustering
- pandas/numpy: Data handling
Commercial Software
- Llamasoft: Network design platform
- SAP IBP: Integrated planning
- Blue Yonder: Supply chain suite
- AIMMS: Optimization modeling
Common Challenges & Solutions
Challenge: Large-Scale Networks
Solution: Decomposition, aggregation, heuristics
Challenge: Multi-Product Complexity
Solution: Product aggregation, ABC analysis
Challenge: Dynamic Demand
Solution: Stochastic models, robust optimization
Challenge: Service Requirements
Solution: Service-level constraints, penalty costs
Output Format
Network Configuration:
- Total Cost: $X
- Open DCs: Y locations
- Capacity utilization: Z%
- Service level: W%
Questions to Ask
- Network scope? (regional, national, global)
- Current vs. greenfield design?
- Number of plants/sources?
- Product variety and characteristics?
- Demand locations and volumes?
- Service requirements?
- Cost structure?
- Planning horizon?
Related Skills
- facility-location-problem: General location theory
- warehouse-location-optimization: Warehouse specifics
- hub-location-problem: Hub networks
- network-flow-optimization: Flow optimization
- inventory-routing-problem: Integrated inventory-routing
- multi-echelon-inventory: Inventory positioning
