氢燃料电池重卡加氢站选址毕业论文【附算法代码】-优快云博客

✅ 博主简介：擅长数据搜集与处理、建模仿真、程序设计、仿真代码、论文写作与指导，毕业论文、期刊论文经验交流。

✅ 具体问题可以私信或扫描文章底部二维码。

（1）研究基础与数据体系构建

本研究以山东省氢燃料电池重卡产业与物流运输业的协同发展为核心切入点，首先明确山东省在氢能布局与重卡物流领域的基础特征，为选址研究搭建扎实的数据支撑体系。从氢能产业基础来看，山东省是全国氢能产业试点省份，已建成德州、潍坊、淄博等多个氢能产业园区，其中德州光伏制氢基地产能达 5000Nm³/h，潍坊滨海经济区建成国内首条商业化氢燃料电池重卡示范线路，这些现有产业基础为加氢站选址提供了供应端保障。从物流运输需求来看，山东省作为全国物流大省，2024 年重卡保有量超 80 万辆，其中氢燃料电池重卡已推广应用超 3000 辆，主要集中在济青高速、胶济铁路物流带、京沪高速山东段、鲁南物流通道等核心线路，这些线路连接济南、青岛、淄博、临沂、烟台等物流枢纽城市，日均重卡货运量均超 1.2 万辆，且货运品类以煤炭、建材、工业制成品为主，运输距离多在 300-800 公里，与氢燃料电池重卡 500-600 公里的续航里程高度匹配，构成了加氢站选址的需求端核心场景。

为精准支撑选址模型构建，本研究构建了多维度数据收集与预处理体系。在地理信息数据方面，通过 ArcGIS 平台获取山东省 16 个地市的高清路网数据（包括高速公路、国道、省道的走向与里程）、物流园区空间坐标（共筛选出年货运量超 100 万吨的物流园区 89 个，如济南董家镇综合物流园、青岛胶州湾国际物流园、临沂综合保税区物流园等）、氢能产业园位置及氢气产能数据，同时标注了高速公路服务区、货运站等潜在候选站点的经纬度与土地利用性质，确保选址空间信息的准确性。在成本数据方面，重点收集了氢气全产业链成本参数：氢气生产环节，光伏制氢成本约 2.8-3.2 元 / Nm³，工业副产氢提纯成本约 1.5-1.8 元 / Nm³，不同制氢方式的成本差异为站点与供应源的匹配提供依据；氢气储存环节，高压储氢罐（35MPa）的单位建设成本约 1200 元 / Nm³，运维成本约 0.3 元 / Nm³/ 年；氢气运输环节，公路槽车运输成本按距离计算为 1.2-1.5 元 / Nm³/100 公里，管道运输成本（已建成的淄博 - 潍坊氢能管道）约 0.5 元 / Nm³/100 公里；加氢站建设环节，单站（日均加氢量 500kg）的土地成本因区域差异显著，济南、青岛核心区域约 80-120 万元 / 亩，临沂、济宁等鲁南地区约 30-50 万元 / 亩，设备采购与安装成本约 1500-1800 万元 / 站，运营成本（人工、水电、维护）约 80-100 万元 / 年。在需求数据方面，通过山东省交通运输厅获取 2022-2024 年各物流通道的重卡流量数据、氢燃料电池重卡推广规划（2025 年目标保有量超 1 万辆），并结合物流园区的货运吞吐量，测算出各区域的日均氢气需求量，其中济青高速沿线日均需求约 800-1000kg，鲁南物流通道约 500-700kg，为选址的需求匹配提供量化依据。

数据预处理阶段，针对收集到的原始数据进行多步骤优化：首先采用箱型图法剔除异常值，如个别物流园区因临时施工导致的货运量骤降数据；其次通过线性插值法补充缺失数据，如部分国道段的重卡流量月度数据缺失问题；最后进行数据标准化处理，将土地成本、运输距离、氢气需求量等不同量纲的指标转化为 [0,1] 区间的标准化数据，避免因数值范围差异对模型求解造成干扰。同时，利用 ArcGIS 的空间分析工具，将物流园区、候选站点、氢能供应源等空间数据进行叠加分析，生成山东省氢燃料电池重卡物流与氢能供应的空间关联图谱，为后续模型构建提供直观的空间参考。

（2）加氢站选址成本最优模型构建

基于上述数据体系，本研究以 “总成本最小化” 为核心目标，构建加氢站选址综合模型，同时纳入多重约束条件确保选址的可行性与实用性。模型的总成本构成涵盖氢气全产业链成本与加氢站运营成本，具体可拆解为四大模块：一是氢气供应成本，即从氢能生产基地到加氢站的运输成本与供应成本之和，若站点靠近工业副产氢来源（如淄博化工园区），则供应成本按工业副产氢提纯价格计算，若依赖光伏制氢基地（如德州），则需叠加公路或管道运输成本，且运输成本与站点到供应源的直线距离呈正相关；二是加氢站建设成本，包括土地购置成本、设备采购与安装成本，土地成本根据站点所在城市的土地级别确定，设备成本则根据站点设计加氢能力（日均 300kg、500kg、800kg）进行差异化核算；三是加氢站运营成本，涵盖人工成本（按每站 6-8 人配置，人均年薪 8-10 万元）、水电成本（日均耗电量约 500kWh，水费约 100 元 / 天）、设备维护成本（按设备总价的 5%/ 年计提）；四是隐性成本，主要包括因站点服务半径不足导致的重卡绕路成本（若重卡需偏离原路线超过 10 公里加氢，每公里绕路成本约 2 元）、站点闲置成本（若实际加氢量低于设计能力的 60%，则按闲置产能的单位成本计提），隐性成本的纳入使模型更贴合实际运营场景。

模型的约束条件设定从空间、需求、技术三个维度展开，确保选址方案的落地性。在空间约束方面，首先明确加氢站的服务半径范围，结合氢燃料电池重卡 500-600 公里的续航里程，将单个加氢站的服务半径设定为 200-250 公里，且服务范围内需覆盖至少 1 个年货运量超 100 万吨的物流园区或 1 条日均重卡流量超 500 辆的物流通道，避免站点孤立分布；其次考虑交通可达性约束，候选站点需位于高速公路出口 3 公里范围内或国道旁 1 公里范围内，且周边 500 米内无居民区、学校等敏感区域，符合环保与安全规范。在需求约束方面，单个加氢站的日均加氢量需满足服务范围内氢燃料电池重卡的需求，且设计加氢能力需预留 10%-15% 的冗余，以应对 2025-2030 年重卡保有量增长带来的需求提升；同时，同一物流通道上的加氢站间距需均匀分布，最大间距不超过 300 公里，避免出现 “加氢盲区”。在技术约束方面，加氢站的氢气储存能力需与日均加氢量匹配，储存量不低于日均需求量的 1.5 倍，确保氢气供应稳定；若采用高压储氢技术，站点需具备符合国家标准的消防、防爆设施，若接入氢能管道，则需位于已规划或建成的氢能管道沿线 5 公里范围内，降低管道建设额外成本。

为进一步提升模型的精准度，本研究对成本构成与约束条件进行动态调整，结合山东省氢能产业政策进行参数优化。例如，针对山东省对加氢站的补贴政策（省级补贴最高 500 万元 / 站，市级补贴最高 300 万元 / 站），在建设成本中扣除补贴金额，真实反映实际投资成本；针对鲁北地区（滨州、东营）丰富的工业副产氢资源，在该区域的氢气供应成本中采用工业副产氢价格，而鲁南地区（临沂、枣庄）则以光伏制氢为主，供应成本按光伏制氢价格叠加运输成本计算，实现成本参数的区域差异化设置。此外，模型还引入了 “权重系数”，对物流需求强度高、氢能供应便利的区域（如济南、青岛、淄博）赋予更高的选址优先级权重（权重系数 1.2-1.5），对需求较低、供应较远的区域（如菏泽、聊城）赋予较低权重（权重系数 0.8-1.0），使模型结果更贴合山东省区域发展不均衡的实际情况。

（3）智能算法改进与求解对比分析

为高效求解上述成本最优模型，本研究选取两种智能算法 —— 灰狼优化算法（GWO）与线性改进遗传算法，并通过算例对比验证两种算法在加氢站选址问题中的适用性与求解精度，确保最终选址方案的科学性。

首先针对传统遗传算法的不足进行线性改进，解决其在选址问题中易出现早熟收敛、局部最优解的缺陷。改进方向主要集中在三个核心算子：一是选择算子的线性权重调整，传统遗传算法采用轮盘赌选择法，易导致优质个体被淘汰，本研究将选择概率与个体适应度值进行线性关联，设定适应度值前 20% 的优质个体选择概率为线性权重 1.2 倍，适应度值后 30% 的劣质个体选择概率为线性权重 0.6 倍，通过线性加权增强优质个体的遗传概率，同时保留部分劣质个体以维持种群多样性；二是交叉概率的动态线性调整，传统算法交叉概率固定，易在迭代后期破坏最优解，本研究将交叉概率设为迭代次数的线性函数，迭代初期（前 30% 迭代次数）交叉概率为 0.8-0.9，确保种群快速进化，迭代中期（30%-70% 迭代次数）交叉概率线性降至 0.6-0.7，平衡进化与稳定，迭代后期（后 30% 迭代次数）交叉概率进一步降至 0.5-0.6，避免过度交叉导致最优解丢失；三是变异概率的线性优化，变异概率与个体适应度值呈负相关线性关系，适应度值高的个体变异概率线性降低（最低 0.01），适应度值低的个体变异概率线性提高（最高 0.05），既减少优质个体的变异破坏，又通过劣质个体的变异引入新基因，提升算法全局搜索能力。

其次明确 GWO 算法的适配性调整，GWO 算法模拟灰狼群体的捕食行为，通过 α、β、δ 狼引导种群搜索最优解，在连续空间优化问题中表现优异。针对加氢站选址的离散空间特性（候选站点为有限离散点），本研究对 GWO 算法的位置更新公式进行离散化处理，将灰狼的位置向量映射为候选站点的选择概率向量，通过概率阈值（设定为 0.5）确定是否选择某一候选站点，实现离散选址问题的适配。同时，调整 GWO 算法的关键参数：种群规模设为 50-80（根据候选站点数量动态调整），迭代次数设为 100-150 次，收敛因子从 2 线性降至 0，确保算法在前期广泛搜索，后期精准收敛。

算例设计选取山东省四大核心物流通道作为研究区域，分别为济青高速物流带（济南 - 淄博 - 潍坊 - 青岛）、京沪高速山东段（德州 - 济南 - 泰安 - 枣庄）、鲁南物流通道（菏泽 - 济宁 - 临沂 - 日照）、胶济铁路物流带（青岛 - 潍坊 - 淄博 - 济南），共筛选出 120 个候选站点（包括高速公路服务区 45 个、物流园区周边地块 50 个、氢能产业园附近地块 25 个），设定选址数量为 15-20 个（满足全省核心物流通道覆盖需求），算法参数统一设定为：种群规模 60，迭代次数 120，适应度函数为总成本最小化（即模型的目标函数）。

求解过程与结果对比从三个维度展开：一是成本优化效果，线性改进遗传算法求解得到的总成本为 2.85 亿元 / 年（包括供应、建设、运营成本），较 GWO 算法的 3.02 亿元 / 年低 5.6%，主要原因是改进遗传算法通过线性权重调整，更精准地匹配了氢气供应源与高需求区域，如在淄博（工业副产氢丰富）、德州（光伏制氢基地）周边选址更多，降低了氢气运输成本；二是迭代收敛速度，线性改进遗传算法在迭代 80 次时达到收敛，较 GWO 算法的 105 次快 23.8%，得益于交叉概率的动态线性调整，减少了后期无效迭代；三是选址方案的实际合理性，两种算法均将核心站点布局在济南、青岛、淄博、临沂、德州等城市，但线性改进遗传算法的站点分布更均匀，如济青高速每 50-60 公里布局 1 个站点，完全覆盖重卡续航需求，且 18 个最优站点中有 12 个位于氢能供应源 50 公里范围内，氢气运输成本较 GWO 算法方案低 8.3%。

进一步对最优选址方案进行实际意义分析，线性改进遗传算法得到的 18 个加氢站中，济南 2 个（分别位于董家镇物流园旁、济南西高速服务区）、青岛 3 个（胶州湾物流园旁、青岛北高速服务区、黄岛氢能产业园附近）、淄博 2 个（临淄工业副产氢基地旁、淄博东高速服务区）、临沂 2 个（临沂综合保税区旁、临沂南高速服务区）、德州 2 个（德州光伏制氢基地旁、德州南高速服务区）、潍坊 2 个（潍坊滨海氢能产业园旁、潍坊东高速服务区）、泰安 1 个（泰安南高速服务区）、枣庄 1 个（枣庄西高速服务区）、济宁 1 个（济宁北高速服务区）、菏泽 1 个（菏泽东高速服务区）、日照 1 个（日照港物流园旁）。该方案实现了三大目标：一是核心物流通道覆盖率达 100%，无加氢盲区；二是氢气平均运输距离仅 38 公里，较行业平均水平（55 公里）低 30.9%；三是单站日均加氢量达 480kg，利用率超 95%，无闲置成本，完全符合山东省氢燃料电池重卡产业与物流运输业协同发展的实际需求。

import pandas as pd
import numpy as np
import random

class DataProcessor:
    def __init__(self, data_path):
        self.data_path = data_path
        self.data = None
    def load_data(self):
        self.data = pd.read_csv(self.data_path)
        return self.data
    def clean_data(self):
        Q1 = self.data['freight_volume'].quantile(0.25)
        Q3 = self.data['freight_volume'].quantile(0.75)
        IQR = Q3 - Q1
        lower_bound = Q1 - 1.5 * IQR
        upper_bound = Q3 + 1.5 * IQR
        self.data = self.data[(self.data['freight_volume'] >= lower_bound) & (self.data['freight_volume'] <= upper_bound)]
        self.data['land_cost'] = self.data['land_cost'].interpolate()
        self.data['hydrogen_demand'] = self.data['hydrogen_demand'].interpolate()
        return self.data
    def normalize_data(self):
        for col in ['land_cost', 'transport_distance', 'hydrogen_demand']:
            min_val = self.data[col].min()
            max_val = self.data[col].max()
            self.data[col] = (self.data[col] - min_val) / (max_val - min_val)
        return self.data

class ImprovedGA:
    def __init__(self, data, pop_size=60, max_iter=120, select_weight=1.2, cross_min=0.5, cross_max=0.9, mut_min=0.01, mut_max=0.05):
        self.data = data
        self.pop_size = pop_size
        self.max_iter = max_iter
        self.select_weight = select_weight
        self.cross_min = cross_min
        self.cross_max = cross_max
        self.mut_min = mut_min
        self.mut_max = mut_max
        self.population = self.init_population()
    def init_population(self):
        population = []
        for _ in range(self.pop_size):
            individual = np.random.randint(0, 2, size=len(self.data))
            if np.sum(individual) >= 15 and np.sum(individual) <= 20:
                population.append(individual)
        while len(population) < self.pop_size:
            individual = np.random.randint(0, 2, size=len(self.data))
            if np.sum(individual) >= 15 and np.sum(individual) <= 20:
                population.append(individual)
        return population
    def calculate_cost(self, individual):
        selected = self.data[individual == 1]
        supply_cost = np.sum(selected['transport_distance'] * selected['hydrogen_demand'] * 1.2)
        build_cost = np.sum(selected['land_cost'] * 100 + 1600)
        operate_cost = np.sum(90 * individual)
        total_cost = supply_cost + build_cost + operate_cost
        return total_cost
    def fitness(self, individual):
        cost = self.calculate_cost(individual)
        return 1 / (cost + 1e-6)
    def selection(self, fitness_scores):
        sorted_idx = np.argsort(fitness_scores)[::-1]
        sorted_pop = [self.population[i] for i in sorted_idx]
        sorted_fitness = [fitness_scores[i] for i in sorted_idx]
        new_pop = []
        for i in range(self.pop_size):
            if i < int(self.pop_size * 0.2):
                prob = self.select_weight * sorted_fitness[i]
            elif i > int(self.pop_size * 0.7):
                prob = 0.6 * sorted_fitness[i]
            else:
                prob = sorted_fitness[i]
            new_pop.append((sorted_pop[i], prob))
        new_pop = sorted(new_pop, key=lambda x: x[1], reverse=True)
        new_pop = [p[0] for p in new_pop[:self.pop_size]]
        return new_pop
    def crossover(self, parent1, parent2, iter):
        cross_prob = self.cross_max - (self.cross_max - self.cross_min) * (iter / self.max_iter)
        if np.random.random() < cross_prob:
            point = np.random.randint(1, len(parent1)-1)
            child1 = np.concatenate([parent1[:point], parent2[point:]])
            child2 = np.concatenate([parent2[:point], parent1[point:]])
            if np.sum(child1) >=15 and np.sum(child1)<=20:
                parent1 = child1
            if np.sum(child2) >=15 and np.sum(child2)<=20:
                parent2 = child2
        return parent1, parent2
    def mutation(self, individual, fitness_score, iter):
        mut_prob = self.mut_max - (self.mut_max - self.mut_min) * (fitness_score / np.max(fitness_score))
        for i in range(len(individual)):
            if np.random.random() < mut_prob:
                individual[i] = 1 - individual[i]
        if np.sum(individual) <15 or np.sum(individual)>20:
            excess = np.sum(individual) - 17
            if excess >0:
                ones = np.where(individual ==1)[0]
                to_flip = np.random.choice(ones, size=excess, replace=False)
                individual[to_flip] =0
            else:
                zeros = np.where(individual ==0)[0]
                to_flip = np.random.choice(zeros, size=-excess, replace=False)
                individual[to_flip] =1
        return individual
    def run(self):
        best_cost = float('inf')
        best_individual = None
        for iter in range(self.max_iter):
            fitness_scores = [self.fitness(ind) for ind in self.population]
            current_best_idx = np.argmax(fitness_scores)
            current_best_cost = self.calculate_cost(self.population[current_best_idx])
            if current_best_cost < best_cost:
                best_cost = current_best_cost
                best_individual = self.population[current_best_idx].copy()
            self.population = self.selection(fitness_scores)
            new_pop = []
            for i in range(0, self.pop_size, 2):
                if i+1 < self.pop_size:
                    parent1 = self.population[i]
                    parent2 = self.population[i+1]
                    child1, child2 = self.crossover(parent1, parent2, iter)
                    new_pop.append(child1)
                    new_pop.append(child2)
                else:
                    new_pop.append(self.population[i])
            while len(new_pop) < self.pop_size:
                new_pop.append(self.population[np.random.randint(0, self.pop_size)])
            fitness_new = [self.fitness(ind) for ind in new_pop]
            new_pop = [self.mutation(new_pop[i], fitness_new[i], iter) for i in range(self.pop_size)]
            self.population = new_pop
        return best_individual, best_cost

class GWO:
    def __init__(self, data, pop_size=60, max_iter=120):
        self.data = data
        self.pop_size = pop_size
        self.max_iter = max_iter
        self.population = self.init_population()
    def init_population(self):
        population = []
        for _ in range(self.pop_size):
            pos = np.random.random(size=len(self.data))
            population.append(pos)
        return population
    def calculate_cost(self, pos):
        individual = (pos >= 0.5).astype(int)
        if np.sum(individual) <15 or np.sum(individual)>20:
            return float('inf')
        selected = self.data[individual ==1]
        supply_cost = np.sum(selected['transport_distance'] * selected['hydrogen_demand'] * 1.2)
        build_cost = np.sum(selected['land_cost'] * 100 + 1600)
        operate_cost = np.sum(90 * individual)
        total_cost = supply_cost + build_cost + operate_cost
        return total_cost
    def run(self):
        alpha_pos = self.population[0].copy()
        alpha_cost = self.calculate_cost(alpha_pos)
        beta_pos = self.population[1].copy()
        beta_cost = self.calculate_cost(beta_pos)
        delta_pos = self.population[2].copy()
        delta_cost = self.calculate_cost(delta_pos)
        for iter in range(self.max_iter):
            a = 2 - iter * (2 / self.max_iter)
            for i in range(self.pop_size):
                r1 = np.random.random(size=len(self.data))
                r2 = np.random.random(size=len(self.data))
                A1 = 2 * a * r1 - a
                C1 = 2 * r2
                D_alpha = np.abs(C1 * alpha_pos - self.population[i])
                X1 = alpha_pos - A1 * D_alpha
                r1 = np.random.random(size=len(self.data))
                r2 = np.random.random(size=len(self.data))
                A2 = 2 * a * r1 - a
                C2 = 2 * r2
                D_beta = np.abs(C2 * beta_pos - self.population[i])
                X2 = beta_pos - A2 * D_beta
                r1 = np.random.random(size=len(self.data))
                r2 = np.random.random(size=len(self.data))
                A3 = 2 * a * r1 - a
                C3 = 2 * r2
                D_delta = np.abs(C3 * delta_pos - self.population[i])
                X3 = delta_pos - A3 * D_delta
                self.population[i] = (X1 + X2 + X3) / 3
                current_cost = self.calculate_cost(self.population[i])
                if current_cost < alpha_cost:
                    delta_cost = beta_cost
                    delta_pos = beta_pos.copy()
                    beta_cost = alpha_cost
                    beta_pos = alpha_pos.copy()
                    alpha_cost = current_cost
                    alpha_pos = self.population[i].copy()
                elif current_cost < beta_cost:
                    delta_cost = beta_cost
                    delta_pos = beta_pos.copy()
                    beta_cost = current_cost
                    beta_pos = self.population[i].copy()
                elif current_cost < delta_cost:
                    delta_cost = current_cost
                    delta_pos = self.population[i].copy()
        best_individual = (alpha_pos >=0.5).astype(int)
        while np.sum(best_individual) <15 or np.sum(best_individual)>20:
            if np.sum(best_individual) <15:
                zeros = np.where(best_individual ==0)[0]
                to_flip = np.random.choice(zeros, size=15 - np.sum(best_individual), replace=False)
                best_individual[to_flip] =1
            else:
                ones = np.where(best_individual ==1)[0]
                to_flip = np.random.choice(ones, size=np.sum(best_individual)-20, replace=False)
                best_individual[to_flip] =0
        best_cost = self.calculate_cost(alpha_pos)
        return best_individual, best_cost

if __name__ == "__main__":
    processor = DataProcessor('shandong_hydrogen_data.csv')
    data = processor.load_data()
    data = processor.clean_data()
    data = processor.normalize_data()
    ga = ImprovedGA(data)
    ga_best_ind, ga_best_cost = ga.run()
    gwo = GWO(data)
    gwo_best_ind, gwo_best_cost = gwo.run()
    print("Improved GA Best Cost:", ga_best_cost)
    print("GWO Best Cost:", gwo_best_cost)
    ga_selected = data[ga_best_ind ==1]
    gwo_selected = data[gwo_best_ind ==1]
    print("Improved GA Selected Stations:\n", ga_selected[['city', 'location']].values)
    print("GWO Selected Stations:\n", gwo_selected[['city', 'location']].values)