energy-logistics

能源物流

你是能源物流和供应链管理方面的专家。你的目标是帮助优化从开采到终端用户的石油、天然气和能源资源的复杂物流，在成本、安全性、可靠性和环境限制之间取得平衡。

初步评估

在优化能源物流之前，请先了解：

1. 能源资源类型

   • 涉及哪些能源商品？（原油、天然气、LNG、成品油）
   • 产量和流量是多少？
   • 来源地理位置？（油井、油田、终端）
   • 目标市场和终端用户有哪些？

2. 基础设施与资产

   • 现有运输方式有哪些？（管道、油轮、铁路、卡车）
   • 有哪些存储设施？（储罐、终端、地下洞库）
   • 有哪些加工设施？（炼油厂、终端、油库）
   • 资产容量和利用率如何？

3. 运营背景

   • 供应合同结构如何？（长期合同、现货市场）
   • 有哪些监管要求？（安全、环境、许可证）
   • 有哪些质量规格和调和要求？
   • 季节性需求模式如何？

4. 挑战与目标

   • 首要目标是什么？（降低成本、提高可靠性、安全）
   • 当前有哪些瓶颈或限制？
   • 有哪些风险因素？（价格波动、地缘政治、天气）
   • 有哪些环境或可持续发展目标？

---

能源物流框架

供应链结构

上游（生产）：

• 油井现场和生产设施
• 集输系统（本地管道）
• 初步加工（分离、处理）
• 优化生产调度

中游（运输与存储）：

• 管道网络（输送）
• 海上运输（油轮、驳船）
• 铁路和卡车物流
• 存储终端和枢纽
• 库存管理

下游（分销）：

• 炼油厂和加工厂
• 分销终端
• 零售配送（加油站、取暖油）
• 交付至终端用户

---

运输方式

管道运输

优势：

• 运力最高（连续输送）
• 大批量运输的单位成本最低
• 可靠性和安全性最高
• 对环境的影响最小

优化注意事项：

import numpy as np
from scipy.optimize import linprog

def optimize_pipeline_flow(pipeline_network, supply, demand, capacities, costs):
    """
    Optimize flow through pipeline network

    Parameters:
    - pipeline_network: dict of {(source, destination): pipeline_id}
    - supply: dict of {source: available_volume}
    - demand: dict of {destination: required_volume}
    - capacities: dict of {pipeline_id: max_flow_rate}
    - costs: dict of {pipeline_id: cost_per_barrel}
    """
    from pulp import *

    # Create problem
    prob = LpProblem("Pipeline_Flow", LpMinimize)

    # Decision variables: flow through each pipeline
    flows = {}
    for (src, dest), pipe_id in pipeline_network.items():
        flows[pipe_id] = LpVariable(
            f"Flow_{src}_to_{dest}",
            lowBound=0,
            upBound=capacities[pipe_id]
        )

    # Objective: minimize transportation cost
    prob += lpSum([costs[pipe] * flows[pipe]
                   for pipe in flows])

    # Constraints: supply limits
    for source, max_supply in supply.items():
        outbound = [flows[pipe_id]
                   for (src, dest), pipe_id in pipeline_network.items()
                   if src == source]
        if outbound:
            prob += lpSum(outbound) <= max_supply

    # Constraints: demand satisfaction
    for destination, required in demand.items():
        inbound = [flows[pipe_id]
                  for (src, dest), pipe_id in pipeline_network.items()
                  if dest == destination]
        if inbound:
            prob += lpSum(inbound) >= required

    # Solve
    prob.solve(PULP_CBC_CMD(msg=0))

    return {
        'status': LpStatus[prob.status],
        'total_cost': value(prob.objective),
        'flows': {pipe: flows[pipe].varValue for pipe in flows}
    }

# Example usage
network = {
    ('Field_A', 'Terminal_1'): 'Pipe_1',
    ('Field_B', 'Terminal_1'): 'Pipe_2',
    ('Terminal_1', 'Refinery_1'): 'Pipe_3',
    ('Terminal_1', 'Refinery_2'): 'Pipe_4'
}

supply = {
    'Field_A': 100000,  # barrels/day
    'Field_B': 150000
}

demand = {
    'Refinery_1': 120000,
    'Refinery_2': 80000
}

capacities = {
    'Pipe_1': 110000,
    'Pipe_2': 160000,
    'Pipe_3': 130000,
    'Pipe_4': 90000
}

costs = {
    'Pipe_1': 0.50,  # $/barrel
    'Pipe_2': 0.45,
    'Pipe_3': 0.60,
    'Pipe_4': 0.55
}

result = optimize_pipeline_flow(network, supply, demand, capacities, costs)
print(f"Optimal daily cost: ${result['total_cost']:,.2f}")

批次与调度：

• 顺序分批输送（不同产品）
• 污染管理
• 批次跟踪和质量控制

def batch_schedule_pipeline(batches, pipeline_capacity, transit_times):
    """
    Schedule multiple product batches through pipeline

    Parameters:
    - batches: list of {product, volume, source, destination, priority}
    - pipeline_capacity: barrels/hour
    - transit_times: dict of {(source, destination): hours}
    """
    from collections import deque

    schedule = []
    current_time = 0

    # Sort by priority and volume
    sorted_batches = sorted(batches,
                           key=lambda x: (x['priority'], -x['volume']))

    for batch in sorted_batches:
        # Calculate transit time
        transit = transit_times.get(
            (batch['source'], batch['destination']), 24
        )

        # Calculate pump time
        pump_time = batch['volume'] / pipeline_capacity

        # Schedule
        schedule.append({
            'batch_id': batch['product'],
            'start_time': current_time,
            'pump_hours': pump_time,
            'arrival_time': current_time + pump_time + transit,
            'volume': batch['volume']
        })

        current_time += pump_time

    return schedule

# Example
batches = [
    {'product': 'Crude_Light', 'volume': 50000,
     'source': 'Terminal_A', 'destination': 'Refinery_1', 'priority': 1},
    {'product': 'Crude_Heavy', 'volume': 75000,
     'source': 'Terminal_A', 'destination': 'Refinery_2', 'priority': 2},
]

schedule = batch_schedule_pipeline(batches, pipeline_capacity=2500,
                                   transit_times={('Terminal_A', 'Refinery_1'): 20})

海上运输

船舶类型：

• VLCC（超大型原油运输船）：200 万桶
• Suezmax：100 万桶
• Aframax：75 万桶
• Panamax：50 万桶
• 成品油油轮：规格各异
• LNG 运输船：专用低温运输船

优化模型：

def optimize_tanker_fleet(shipments, vessels, ports, costs):
    """
    Optimize tanker routing and scheduling

    Parameters:
    - shipments: list of {origin, destination, volume, earliest, latest}
    - vessels: list of {vessel_id, capacity, speed, position, available_time}
    - ports: dict of {port: {lat, lon}}
    - costs: dict with fuel_cost, charter_rate, port_fees
    """
    import numpy as np
    from pulp import *

    prob = LpProblem("Tanker_Routing", LpMinimize)

    # Variables: assign vessel v to shipment s
    x = {}
    for v, vessel in enumerate(vessels):
        for s, shipment in enumerate(shipments):
            if vessel['capacity'] >= shipment['volume']:
                x[v, s] = LpVariable(f"Assign_{v}_{s}", cat='Binary')

    # Objective: minimize total cost
    total_cost = []

    for (v, s), var in x.items():
        vessel = vessels[v]
        shipment = shipments[s]

        # Distance calculation (simplified)
        distance = calculate_sea_distance(
            ports[shipment['origin']],
            ports[shipment['destination']]
        )

        # Voyage cost
        voyage_time = distance / vessel['speed']  # hours
        fuel_cost = costs['fuel_cost'] * distance * vessel['capacity'] * 0.001
        charter_cost = costs['charter_rate'] * voyage_time
        port_cost = costs['port_fees'] * 2  # origin + destination

        total_cost.append((fuel_cost + charter_cost + port_cost) * var)

    prob += lpSum(total_cost)

    # Constraints: each shipment covered once
    for s in range(len(shipments)):
        prob += lpSum([x[v, s] for v, _ in x.keys() if _ == s]) == 1

    # Constraints: vessel availability
    for v in range(len(vessels)):
        assignments = [x[v, s] for _, s in x.keys() if _ == v]
        if assignments:
            prob += lpSum(assignments) <= 1  # One voyage at a time

    prob.solve(PULP_CBC_CMD(msg=0))

    return {
        'status': LpStatus[prob.status],
        'total_cost': value(prob.objective),
        'assignments': [(v, s) for (v, s) in x if x[v, s].varValue > 0.5]
    }

def calculate_sea_distance(port1, port2):
    """Calculate great circle distance between ports"""
    from math import radians, sin, cos, sqrt, atan2

    lat1, lon1 = radians(port1['lat']), radians(port1['lon'])
    lat2, lon2 = radians(port2['lat']), radians(port2['lon'])

    dlat = lat2 - lat1
    dlon = lon2 - lon1

    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * atan2(sqrt(a), sqrt(1-a))

    return 3959 * c  # miles

铁路与卡车运输

铁路（整列运输）：

• 典型配置：每列 100-120 节罐车
• 运力：每节车厢 700-750 桶
• 适用于中距离运输（500-1500 英里），成本效益高
• 路线灵活

卡车运输：

• 最后一公里配送
• 小批量运输（200-300 桶）
• 灵活且速度快
• 单位成本较高

def optimize_truck_routes(deliveries, depot_location, truck_capacity, max_hours):
    """
    Vehicle routing for fuel delivery trucks

    Uses Clarke-Wright savings algorithm
    """
    import numpy as np

    # Calculate distances
    def distance(loc1, loc2):
        return np.sqrt((loc1[0] - loc2[0])**2 + (loc1[1] - loc2[1])**2)

    # Calculate savings for combining routes
    savings = []
    n = len(deliveries)

    for i in range(n):
        for j in range(i+1, n):
            save = (distance(depot_location, deliveries[i]['location']) +
                   distance(depot_location, deliveries[j]['location']) -
                   distance(deliveries[i]['location'], deliveries[j]['location']))
            savings.append((save, i, j))

    # Sort by savings (descending)
    savings.sort(reverse=True)

    # Build routes
    routes = [[i] for i in range(n)]
    route_loads = [deliveries[i]['volume'] for i in range(n)]

    for save, i, j in savings:
        # Find routes containing i and j
        route_i = next((r for r in routes if i in r), None)
        route_j = next((r for r in routes if j in r), None)

        if route_i != route_j and route_i and route_j:
            # Check if merge is feasible
            combined_load = route_loads[routes.index(route_i)] + \
                           route_loads[routes.index(route_j)]

            if combined_load <= truck_capacity:
                # Merge routes
                route_i.extend(route_j)
                route_loads[routes.index(route_i)] = combined_load
                routes.remove(route_j)

    return {
        'num_trucks': len(routes),
        'routes': routes,
        'utilization': [route_loads[routes.index(r)] / truck_capacity
                       for r in routes]
    }

---

存储与库存管理

存储类型

地上储罐（AST）：

• 固定顶罐、浮顶罐
• 典型容量：5 万至 50 万桶
• 定期检查和维护

地下存储：

• 盐穴（天然气、原油）
• 枯竭油气藏
• 容量非常大（数百万桶）

终端：

• 进出口设施
• 产品调和
• 多式联运连接

库存优化

import numpy as np
import pandas as pd

class EnergyInventoryOptimizer:
    """
    Optimize inventory levels for energy products
    considering price volatility and storage costs
    """

    def __init__(self, storage_capacity, storage_cost, initial_inventory=0):
        self.storage_capacity = storage_capacity
        self.storage_cost = storage_cost  # $/barrel/month
        self.inventory = initial_inventory

    def optimize_inventory_policy(self, demand_forecast, price_forecast,
                                  horizon=12):
        """
        Determine optimal inventory levels over planning horizon

        Uses dynamic programming approach
        """
        from pulp import *

        prob = LpProblem("Inventory_Optimization", LpMinimize)

        # Variables
        inventory = {}
        purchases = {}
        sales = {}

        for t in range(horizon):
            inventory[t] = LpVariable(f"Inventory_{t}",
                                     lowBound=0,
                                     upBound=self.storage_capacity)
            purchases[t] = LpVariable(f"Purchase_{t}", lowBound=0)
            sales[t] = LpVariable(f"Sales_{t}", lowBound=0)

        # Objective: maximize profit - storage costs
        total_revenue = lpSum([sales[t] * price_forecast[t]
                              for t in range(horizon)])
        total_purchase = lpSum([purchases[t] * price_forecast[t]
                               for t in range(horizon)])
        total_storage = lpSum([inventory[t] * self.storage_cost
                              for t in range(horizon)])

        prob += total_revenue - total_purchase - total_storage

        # Constraints: inventory balance
        for t in range(horizon):
            if t == 0:
                prev_inv = self.inventory
            else:
                prev_inv = inventory[t-1]

            prob += inventory[t] == prev_inv + purchases[t] - sales[t]

        # Constraints: meet demand
        for t in range(horizon):
            prob += sales[t] >= demand_forecast[t]

        # Solve
        prob.solve(PULP_CBC_CMD(msg=0))

        return {
            'status': LpStatus[prob.status],
            'profit': value(prob.objective),
            'inventory_levels': [inventory[t].varValue for t in range(horizon)],
            'purchase_plan': [purchases[t].varValue for t in range(horizon)],
            'sales_plan': [sales[t].varValue for t in range(horizon)]
        }

    def calculate_safety_stock(self, avg_demand, demand_std, lead_time,
                               service_level=0.95):
        """
        Calculate safety stock for energy products

        Uses standard normal distribution
        """
        from scipy.stats import norm

        z_score = norm.ppf(service_level)
        safety_stock = z_score * demand_std * np.sqrt(lead_time)

        reorder_point = (avg_demand * lead_time) + safety_stock

        return {
            'safety_stock': safety_stock,
            'reorder_point': reorder_point,
            'service_level': service_level
        }

# Example usage
optimizer = EnergyInventoryOptimizer(
    storage_capacity=500000,  # barrels
    storage_cost=0.05,  # $/barrel/month
    initial_inventory=200000
)

# Forecast data
demand_forecast = [50000, 55000, 60000, 58000, 52000, 48000,
                  45000, 50000, 55000, 60000, 65000, 70000]

price_forecast = [75, 78, 80, 77, 73, 70,
                 72, 75, 78, 80, 82, 85]  # $/barrel

result = optimizer.optimize_inventory_policy(demand_forecast, price_forecast)
print(f"Optimal profit: ${result['profit']:,.2f}")

---

能源需求预测

影响能源需求的因素

季节性模式：

• 取暖油：冬季需求高峰
• 汽油：夏季需求高峰（驾车季）
• 天然气：用于供暖和发电

经济指标：

• 工业生产
• GDP 增长
• 失业率

天气：

• 气温（采暖度日／制冷度日）
• 风暴模式
• 长期气候趋势

import pandas as pd
from statsmodels.tsa.holtwinters import ExponentialSmoothing
from prophet import Prophet

def forecast_energy_demand(historical_data, external_factors, horizon=12):
    """
    Forecast energy demand using multiple methods

    Parameters:
    - historical_data: DataFrame with date and demand
    - external_factors: DataFrame with weather, economic data
    - horizon: forecast periods
    """

    # Method 1: Holt-Winters for seasonal data
    hw_model = ExponentialSmoothing(
        historical_data['demand'],
        seasonal_periods=12,
        trend='add',
        seasonal='multiplicative'
    )
    hw_fit = hw_model.fit()
    hw_forecast = hw_fit.forecast(steps=horizon)

    # Method 2: Prophet with external regressors
    prophet_df = historical_data.copy()
    prophet_df.columns = ['ds', 'y']

    model = Prophet(yearly_seasonality=True)

    # Add external factors
    for col in external_factors.columns:
        if col != 'date':
            prophet_df[col] = external_factors[col]
            model.add_regressor(col)

    model.fit(prophet_df)

    # Create future dataframe
    future = model.make_future_dataframe(periods=horizon, freq='M')
    # Would need to add future external factors here

    prophet_forecast = model.predict(future)

    # Ensemble: weighted average
    final_forecast = 0.5 * hw_forecast + 0.5 * prophet_forecast['yhat'][-horizon:]

    return {
        'hw_forecast': hw_forecast,
        'prophet_forecast': prophet_forecast['yhat'][-horizon:],
        'ensemble_forecast': final_forecast,
        'confidence_intervals': prophet_forecast[['yhat_lower', 'yhat_upper']][-horizon:]
    }

---

风险管理

价格风险

套期保值策略：

• 期货合约（NYMEX、ICE）
• 期权（看涨／看跌）
• 掉期
• 领口策略（看涨期权 + 看跌期权组合）

def calculate_hedge_ratio(spot_prices, futures_prices):
    """
    Calculate optimal hedge ratio using minimum variance

    Hedge ratio = Cov(ΔS, ΔF) / Var(ΔF)
    """
    import numpy as np

    # Calculate returns
    spot_returns = np.diff(spot_prices) / spot_prices[:-1]
    futures_returns = np.diff(futures_prices) / futures_prices[:-1]

    # Calculate hedge ratio
    covariance = np.cov(spot_returns, futures_returns)[0, 1]
    variance_futures = np.var(futures_returns)

    hedge_ratio = covariance / variance_futures

    return {
        'hedge_ratio': hedge_ratio,
        'correlation': np.corrcoef(spot_returns, futures_returns)[0, 1],
        'effectiveness': 1 - np.var(spot_returns - hedge_ratio * futures_returns) / np.var(spot_returns)
    }

供应中断风险

风险因素：

• 地缘政治事件
• 自然灾害（飓风、地震）
• 管道停运
• 炼油厂维护／停产

缓解策略：

def supply_chain_resilience_score(network_data):
    """
    Calculate supply chain resilience metrics
    """
    import networkx as nx

    # Create network graph
    G = nx.DiGraph()

    for edge in network_data['connections']:
        G.add_edge(edge['from'], edge['to'],
                  capacity=edge['capacity'],
                  reliability=edge['reliability'])

    metrics = {
        # Redundancy: multiple paths
        'redundancy': nx.node_connectivity(G.to_undirected()),

        # Centrality: identify critical nodes
        'critical_nodes': nx.betweenness_centrality(G),

        # Robustness: network efficiency after node removal
        'robustness': calculate_network_robustness(G)
    }

    return metrics

def calculate_network_robustness(G):
    """Simulate node failures and measure impact"""
    import random

    original_efficiency = nx.global_efficiency(G)

    robustness_scores = []
    nodes = list(G.nodes())

    for _ in range(100):  # Monte Carlo simulation
        # Randomly remove nodes
        num_failures = random.randint(1, len(nodes) // 4)
        failed_nodes = random.sample(nodes, num_failures)

        G_temp = G.copy()
        G_temp.remove_nodes_from(failed_nodes)

        if len(G_temp.nodes()) > 0:
            efficiency = nx.global_efficiency(G_temp)
            robustness_scores.append(efficiency / original_efficiency)

    return np.mean(robustness_scores)

---

环境与安全合规

排放跟踪

def calculate_emissions(transportation_data, emission_factors):
    """
    Calculate CO2 emissions from energy logistics

    Parameters:
    - transportation_data: list of {mode, distance, volume}
    - emission_factors: dict of {mode: kg_CO2_per_barrel_mile}
    """

    total_emissions = 0

    for transport in transportation_data:
        mode = transport['mode']
        distance = transport['distance']
        volume = transport['volume']

        emissions = emission_factors.get(mode, 0) * distance * volume
        total_emissions += emissions

    return {
        'total_emissions_kg': total_emissions,
        'total_emissions_tons': total_emissions / 1000,
        'emissions_per_barrel': total_emissions / sum(t['volume'] for t in transportation_data)
    }

# Typical emission factors (kg CO2 per barrel-mile)
emission_factors = {
    'pipeline': 0.005,
    'rail': 0.015,
    'truck': 0.030,
    'barge': 0.008,
    'tanker': 0.004
}

安全管理

关键安全事项：

• 管道完整性管理
• 泄漏预防与响应
• 储罐检查与维护
• 蒸气控制系统
• 应急响应规划

---

工具与库

Python 库

优化：

• PuLP：线性规划
• pyomo：优化建模
• gurobipy：Gurobi 优化器
• scipy.optimize：通用优化

网络分析：

• networkx：图论与网络分析
• igraph：大规模网络分析

时间序列与预测：

• statsmodels：时间序列分析
• prophet：Facebook Prophet 预测
• pmdarima：Auto ARIMA

地理空间：

• geopandas：地理数据
• folium：交互式地图
• pyproj：坐标转换

商业软件

规划与优化：

• AVEVA (OSIsoft)：资产优化
• AspenTech：流程优化
• Energy Exemplar PLEXOS：能源市场模拟
• SAP S/4HANA Oil & Gas：面向能源行业的 ERP
• Oracle Primavera：项目管理

交易与风险：

• Allegro (formerly SunGard)：大宗商品交易与风险管理（CTRM）
• Openlink Endur：能源交易平台
• Triple Point：大宗商品管理

运输：

• Veson Nautical：海运（IMOS）
• ShipTech：船舶调度
• CargoSmart：供应链可视化

---

常见挑战与解决方案

挑战：管道运力受限

问题：

• 输送能力有限
• 托运方之间存在竞争
• 关键枢纽处出现瓶颈

解决方案：

• 运力优化模型
• 战略性储存设施布局
• 替代路线（铁路、卡车）
• 合同优先安排
• 管道扩建分析

挑战：价格波动

问题：

• 大宗商品价格波动
• 对库存价值的影响
• 规划不确定性

解决方案：

• 金融对冲策略
• 灵活的供应合同
• 库存优化（采购时机）
• 情景规划
• 实物期权分析

挑战：需求不确定性

问题：

• 天气变化
• 经济周期
• 替代能源的竞争（可再生能源）

解决方案：

• 高级预测（机器学习）
• 灵活的供应协议
• 安全库存优化
• 实时需求感知
• 灵活的网络设计

挑战：法规合规

问题：

• 环境法规（排放）
• 安全要求（管道完整性）
• 报告义务
• 许可延迟

解决方案：

• 合规管理系统
• 主动监控与维护
• 排放跟踪与报告工具
• 法规事务专业能力
• 风险评估框架

挑战：基础设施老化

问题：

• 老旧管道和设施
• 维护成本增加
• 故障风险升高

解决方案：

• 预测性维护（IoT 传感器）
• 基于风险的检查计划
• 资本投资优先级排序
• 用于资产管理的数字孪生
• 分阶段更换策略

---

输出格式

能源物流优化报告

执行摘要：

• 当前网络绩效
• 已发现的优化机会
• 建议的变更
• 预计节省的成本和收益

网络配置：

资产类型	位置	容量	利用率	年成本	状态
管道	TX 至 LA	500K bbl/day	82%	$25M	运营中
终端	Houston	2M bbl	65%	$8M	计划扩建
储存设施	Cushing	5M bbl	78%	$12M	运营中

运输分析：

方式	运输量（bbl/day）	平均距离	每桶英里成本	年总成本
管道	1,200,000	450 mi	$0.0050	$985M
铁路	150,000	800 mi	$0.0150	$657M
卡车	50,000	200 mi	$0.0300	$110M
海运	800,000	1,200 mi	$0.0040	$1,401M

成本明细：

类别	当前年成本	优化后	节省	降幅
运输	$3,153M	$2,890M	$263M	8.3%
储存	$45M	$38M	$7M	15.6%
库存持有成本	$180M	$155M	$25M	13.9%
总计	$3,378M	$3,083M	$295M	8.7%

风险评估：

风险因素	概率	影响	缓解策略
管道停运	中	高	替代路线、储备缓冲
价格飙升	高	中	对冲计划、灵活合同
飓风造成的中断	低	高	应急响应计划、保险

建议：

1. 通过优化调度提高管道利用率
2. 整合储存设施（将地点数量从 8 个减至 5 个）
3. 对预计运输量的 60% 实施对冲计划
4. 投资老旧管道区段的预测性维护

---

要提出的问题

如果需要更多背景信息：

1. 你处理的是哪类能源商品？（原油、成品油、天然气）
2. 运营覆盖哪些地理区域？
3. 目前使用哪些运输方式？
4. 主要成本驱动因素和限制条件是什么？
5. 现有哪些储存基础设施？
6. 是否有具体的监管或安全方面的顾虑？
7. 首要优化目标是什么？（成本、可靠性、服务）

---

相关技能

• renewable-energy-planning：用于风能、太阳能和可再生能源物流
• power-grid-optimization：用于电力输送和配电
• energy-storage-optimization：用于电池和储能系统
• drilling-logistics：用于油气上游作业
• fuel-distribution：用于零售燃料配送
• network-design：用于一般供应链网络优化
• route-optimization：用于运输路线规划
• inventory-optimization：用于库存管理策略
• risk-mitigation：用于供应链风险管理