高速铁路动车交路计划、运行图的优化规划问题

陈烛_江说

已于 2022-05-16 17:15:35 修改

阅读量3.2k

点赞数 10

分类专栏：出行规划文章标签： python 动态规划矩阵交通物流

于 2022-05-16 17:11:56 首次发布

本文链接：https://blog.csdn.net/BaoJY_0915/article/details/124803319

版权

出行规划专栏收录该内容

3 篇文章 1 订阅

订阅专栏

感谢课程组老师的精彩授课与指导，题目来自课程组，仅作为学习记录使用！

仅供参考，欢迎共同探讨！

一、动车组交路优化

某个区域路网中有A、B和C三个高速铁路车站，A-B和B-C间距离分别为400km和900km，动车所1、2和3分别为车站A、B和C提供服务。提供列车时刻表中列车航空线图表示，横坐标为时间，纵坐标为列车空间位置。
假设所有交路均使用同一种车型（CRH380AL），各动车所配置动车组数量无限制，检修能力无限制，动车组一级检修的修程为4000+400km和48h，最小立折时间为20分钟。
根据上述条件，请以动车组数最少为目标，编制动车组交路计划。

# coding=utf-8

import pandas as pd
import numpy as np
from scipy.optimize import minimize
import cplex
from cplex.exceptions import CplexError

df = pd.read_csv(r'E:\包包包\接续图01变量.csv', encoding='gbk')
# print(df)

c_table = []
c_sum = 0
for i in range(26):
    line_i = np.array(df.iloc[i])
    line_i = line_i.tolist()
    c_table.append(line_i)
    c_sum += sum(line_i)
    # print(line_i)
# print(c_table)

x_table = [[1.0 for i in range(26)] for j in range(26)]

my_obj = [1.0 for i in range(77)]
my_ctype = 'I' * 77
my_ub = [1 for i in range(77)]
my_lb = [0 for i in range(77)]
my_colnames = [
				'''自己添加'''
               ]
my_rhs = [1 for i in range(35)]
my_rownames = ['r1', 'r2', 'r3', 'r4', 'r5', 'r6', 'r7', 'r8', 'r9', 'r10',
               'r11', 'r12', 'r13', 'r14', 'r15', 'r16', 'r17', 'r18', 'r19', 'r20',
               'r21', 'r22', 'r23', 'r24', 'r25', 'r26', 'r27', 'r28', 'r29', 'r30',
               'r31', 'r32', 'r33', 'r34', 'r35'
               ]
my_sense = 'L' * 35


def populatebyrow(prob):
    prob.objective.set_sense(prob.objective.sense.maximize)
    prob.variables.add(obj=my_obj, lb=my_lb, ub=my_ub,
                       types=my_ctype, names=my_colnames)
    rows = [  # ---行约束---
        '''自己添加'''
        # ---列约束---
        '''自己添加'''
    ]
    print(len(rows))
    prob.linear_constraints.add(lin_expr=rows, senses=my_sense,
                                rhs=my_rhs, names=my_rownames)


my_prob = cplex.Cplex()
handle = populatebyrow(my_prob)
my_prob.solve()
print(my_prob.solution.get_objective_value())
x = my_prob.solution.get_values()
print(x)

for i in range(len(x)):
    if x[i] != 0:
        print(my_colnames[i])

~~-----------------------------------------------------------~~

二、沪宁城际铁路周期列车运行图编制

沪宁城际铁路是一条连接南京市和上海市的一条铁路线，包含 21 个高速铁路车站，其上运行速度为 300km/h 的高速列车，相关的信息给出。
根据上述条件，编制一张可行的周期列车运行图，要求：
1）列车在各区间内运行冗余时间为 1min，列车的停站时间介于 2~8min。
2）列车的起车附加时分为 2min，停车附加时分为 3min。
3）列车在各车站的到达、出发间隔时间为 3min。
4）列车在各车站最多被1 列列车越行，列车在各车站最多越行 1 列列车。
5）如若不满足列车运行约束，列车可在无停站作业车站额外新增停站作业。

第一步

# coding=utf-8

import pandas as pd
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import random

matplotlib.rc('font', family='MicroSoft YaHei', weight='bold')

pd.set_option('display.max_columns', 20)  # 显示省略号内容,最多的行数
pd.set_option('display.width', 150)

df = pd.read_csv(r'E:\包包包\全过程_冗余.csv', encoding='gbk')
df.set_index(["车次"], inplace=True)
# print(df.head(5))

# 1.停站附加时间处理
df_yx = df.loc[:, df.columns.str.startswith('运行')]
df_zh = df.loc[:, df.columns.str.startswith('站号')]

for lie in range(len(df_yx.columns)):  # 选取某列
    for hang in range(len(df.iloc[:, 2 * lie + 1])):  # 选取某行
        if df.iloc[hang, 2 * lie + 2] == 1:
            try:
                df.iloc[hang, 2 * lie + 1] += 3
                df.iloc[hang, 2 * lie + 3] += 2
            except IndexError:
                continue
            # print(df.iloc[hang,2*lie+1])

print(df.head(10))


# df.to_csv(r'E:\包包包\全过程_起停.csv',encoding='gbk')


# 2.区间运行时间计算

class Arcs():
    '''时空弧
    k：列车序号
    place_i：出发站点
    place_j：到达站点
    time_t：出发时间
    time_s：到达时间
    '''

    def __init__(self, k, place_i, place_j, time_t, time_s):
        self.train_num = k
        self.o_place = place_i
        self.d_place = place_j
        self.o_time = time_t
        self.d_time = time_s

        self.arcs_x = 1
        self.arcs_cost = self.d_time - self.o_time


arcs_list = []
for hang in range(len(df.index)):  # 选取某车的行
    for lie_1 in range(len(df_zh.columns)):  # 选取某起点站号的列
        for lie_2 in range(len(df_zh.columns)):  # 选取某终点站号的列
            if int(df_zh.columns[lie_2].strip('站号')) == int(df_zh.columns[lie_1].strip('站号'))+1:  # 相邻站间运行过程
                for t_min in range(sum(df.iloc[hang, 1:2 * lie_1 + 1:2]), 120-sum(df.iloc[hang, 2 * lie_2 + 3::2])):
                # 遍历离散化的分钟，space_time =[前置时间，120-后置时间]
                    if t_min + sum(df.iloc[hang, 2 * lie_1 + 1:2 * lie_2 + 1:2]) <= 120:
                        # 时空弧对象
                        arcs_1 = Arcs(int(df.index[hang].strip('G')),
                                      int(df_zh.columns[lie_1].strip('站号')), int(df_zh.columns[lie_2].strip('站号')),
                                      t_min, t_min + sum(df.iloc[hang, 2 * lie_1 + 1:2 * lie_2 + 1:2]))
                        print(arcs_1.__dict__)
                        arcs_list.append(arcs_1)

            elif int(df_zh.columns[lie_2].strip('站号')) == int(df_zh.columns[lie_1].strip('站号')) \
                    and 2 < int(df_zh.columns[lie_2].strip('站号')) < 12:  # 同站停站过程
                for t_min in range(sum(df.iloc[hang, 1:2 * lie_1 + 1:2]), 120-sum(df.iloc[hang, 2 * lie_2 + 3::2])):
                # 遍历离散化的分钟，space_time =[前置时间，120-后置时间]
                    if t_min + 1 <= 120:
                        # 时空弧对象
                        arcs_1 = Arcs(int(df.index[hang].strip('G')),
                                      int(df_zh.columns[lie_1].strip('站号')), int(df_zh.columns[lie_2].strip('站号')),
                                      t_min, t_min + 1)
                        print(arcs_1.__dict__)
                        arcs_list.append(arcs_1)


print(len(arcs_list))


arcs_x_pd = pd.DataFrame(columns=['train_num','o_place','d_place','o_time','d_time','arcs_x'])
arcs_cost_pd = pd.DataFrame(columns=['train_num','o_place','d_place','o_time','d_time','arcs_x'])
for i in range(len(arcs_list)):
    arcs_x_pd.loc[i]=[arcs_list[i].train_num,
                   arcs_list[i].o_place,arcs_list[i].d_place,
                   arcs_list[i].o_time,arcs_list[i].d_time,
                   arcs_list[i].arcs_x]

    arcs_cost_pd.loc[i]=[arcs_list[i].train_num,
                   arcs_list[i].o_place,arcs_list[i].d_place,
                   arcs_list[i].o_time,arcs_list[i].d_time,
                   arcs_list[i].arcs_cost]

# print(arcs_x_pd)
# print(arcs_cost_pd)

# arcs_x_pd.to_csv(r'E:\包包包\全过程_arcs_x.csv',encoding='gbk')
# arcs_cost_pd.to_csv(r'E:\包包包\全过程_arcs_cost.csv',encoding='gbk')

第二步

# coding=utf-8

import pandas as pd
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import random

matplotlib.rc('font', family='MicroSoft YaHei', weight='bold')

pd.set_option('display.max_columns', 30)  # 显示省略号内容,最多的行数
pd.set_option('display.width', 150)

df = pd.read_csv(r'E:\包包包\全过程_起停2.csv', encoding='gbk')
df.set_index(["车次"], inplace=True)


# print(df)


def get_train_timeplace():
    # 1.停站时间
    df_yx = df.loc[:, df.columns.str.startswith('到达')]
    df_zh = df.loc[:, df.columns.str.startswith('离开')]

    stop_time = 4
    for lie in range(len(df_zh.columns) - 1):  # 选取某列
        for hang in range(len(df.iloc[:, 2 * lie + 1])):  # 选取某行
            # 2.到站时间
            df.iloc[hang, 2 * lie + 1] = df.iloc[hang, 2 * lie] + df.iloc[hang, 2 * lie + 1]
            # 1.离站时间
            if df.iloc[hang, 2 * lie + 2] == 0:
                df.iloc[hang, 2 * lie + 2] = df.iloc[hang, 2 * lie + 1]
            elif df.iloc[hang, 2 * lie + 2] == 1:
                df.iloc[hang, 2 * lie + 2] = df.iloc[hang, 2 * lie + 1] + stop_time

    print(df.head(5))
    # df.to_csv(r'E:\包包包\全过程_2min.csv',encoding='gbk')

    for lie_1 in range(1, len(df.columns) - 2, 2):  # 选取某起点站号的列
        st_yuexing = []
        st_all = []
        for hang in range(len(df.index)):  # 选取某车的行

            hang_time = list(range(df.iloc[hang, lie_1], df.iloc[hang, lie_1 + 1] + 1))
            st_yuexing.append(hang_time)
        print('车站', int((lie_1 + 1) / 2 + 1), ':', st_yuexing)
        # print('车站', int((lie_1 + 1) / 2 + 1),':')

        for i in range(len(st_yuexing)):
            for j in range(i + 1, len(st_yuexing)):
                if j != 1:
                    for k in range(j + 1, len(st_yuexing)):
                        if k != i and k != j:
                            if list(set(st_yuexing[i]).intersection(st_yuexing[j])) == st_yuexing[i] \
                                    and list(set(st_yuexing[i]).intersection(st_yuexing[k])) == st_yuexing[i]:
                                print(i, '被越', j, k)
                            elif list(set(st_yuexing[i]).intersection(st_yuexing[j])) == st_yuexing[j] \
                                    and list(set(st_yuexing[i]).intersection(st_yuexing[k])) == st_yuexing[k]:
                                print(i, '越', j, k)


def draw_train_way():
    '''画列车运行时空图'''
    station = [1]
    for i in range(20):
        station.append(2 * (i + 2))
        station.append(2 * (i + 2) + 1)

    plt.figure(dpi=300)
    for i in range(df.shape[0]):
        x = df.iloc[i, :]
        y = station
        plt.plot(x, y, label=f'G{i + 1}')
        plt.xlabel('时间')
        plt.ylabel('站点')

    y_1 = range(1, 23, 2)
    y_2 = range(2, 46, 4)
    plt.yticks(y_2, y_1)
    plt.title(f'列车运行时空路径')
    plt.text(x=0.5, y=20, s='包包包', fontsize=20, color='gray', alpha=0.2)
    plt.legend(loc='lower right', fontsize='small')
    plt.show()


# draw_train_way()

df_2 = pd.read_csv(r'E:\包包包\全过程_2min.csv', encoding='gbk')
df_2.set_index(["车次"], inplace=True)
print(df_2)

time_table_1=[]
time_table_2=[]
for hang in range(len(df_2.index)):
    time_list_1=[]
    time_list_2=[]
    for t in df_2.iloc[hang,:]:
        # print(t)
        time_list_1.append(t)
        time_list_2.append(t+180)
    time_table_1.append(time_list_1)
    time_table_2.append(time_list_1)
    time_table_2.append(time_list_2)


place_list=[1]
for p in range(19):
    place_list.append(p+2)
    place_list.append(p+2)
place_list.append(21)
print(place_list)


def draw_train_way(time_table, place_table):
    '''画列车运行时空图'''
    plt.figure(dpi=200)
    for i in range(len(time_table)):
        x = time_table[i]
        y = place_table
        # plt.plot(x, y, label=f'G{i + 1}')
        plt.plot(x, y)
        plt.xlabel('时间')
        plt.ylabel('站点')

    y_1 = range(1, 23, 2)
    plt.yticks(y_1, y_1)
    plt.title(f'多周期列车运行时空图')
    plt.text(x=0.5, y=20, s='包包包', fontsize=20, color='gray', alpha=0.2)
    plt.legend(loc='lower right', fontsize='small')
    plt.show()

draw_train_way(time_table_2,place_list)