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

这篇具有很好参考价值的文章主要介绍了高速铁路动车交路计划、运行图的优化规划问题。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

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

仅供参考,欢迎共同探讨!

一、动车组交路优化

某个区域路网中有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)如若不满足列车运行约束,列车可在无停站作业车站额外新增停站作业。文章来源地址https://www.toymoban.com/news/detail-433587.html

  • 第一步
# 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)

到了这里,关于高速铁路动车交路计划、运行图的优化规划问题的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 高速SAR ADC 关键技术研究和实现(三):DAC阵列的优化

    目前,由于SAR逻辑越来越像数字化发展,比较器和开关电容阵列的功耗成为了SAR ADC功耗优化的核心问题。 低功耗 SAR ADC 主要应用于中低精度(一般不超过10bit)、低速(采样率一般不超过1MS/s)的应用场合中。在这种精度和采样速度条件下,SAR ADC 内部的DAC的匹配精度在现今的制造

    2024年02月12日
    浏览(40)
  • SQL优化之EXPLAIN执行计划

    从今天开始本系列文章就带各位小伙伴学习数据库技术。 数据库技术是Java开发中必不可少的一部分知识内容。也是非常重要的技术。本系列教程由浅入深, 全面讲解数据库体系。 非常适合零基础的小伙伴来学习。 全文大约 【1965】字 ,不说废话,只讲可以让你学到技术、明

    2024年02月07日
    浏览(65)
  • 【MySQL】从执行计划了解MySQL优化策略

    在MySQL中,执行计划是优化器根据查询语句生成的一种重要的数据结构,它描述了如何通过组合底层操作实现查询的逻辑。当我们编写一条SQL语句时,MySQL会自动对其进行优化,并生成最优的执行计划以实现更快的查询速度。 各位精通MySQL的大佬们,像往常一样,我们经常会遇

    2024年02月16日
    浏览(33)
  • 玩转MySQL之SQL优化之EXPLAIN执行计划

    从今天开始本系列文章就带各位小伙伴学习数据库技术。 数据库技术是Java开发中必不可少的一部分知识内容。也是非常重要的技术。本系列教程由浅入深, 全面讲解数据库体系。 非常适合零基础的小伙伴来学习。 全文大约 【1965】字 ,不说废话,只讲可以让你学到技术、明

    2024年02月08日
    浏览(53)
  • 新星计划 Electron+vue2 桌面应用 2 搭建及运行

    基础内容:新星计划 Electron+vue2 桌面应用 1 基础_lsswear的博客-CSDN博客 根据使用过的经验和官网的描述,大概可以有四种方式: 自己创建项目(仅使用npm) 用Electron脚手架 HBuilder编译为web,再用Electron编译 vue脚手架,安装Electron,再编译 这次挨个试下,看哪个方便。第三种试

    2024年02月06日
    浏览(45)
  • kettle—bat文件Windows任务计划程序自动运行定时设置

    1.用kettle新建一个作业 2.把作业保存到你电脑上的任意文件夹内 3.新建一个bat文件(新建一个文本文档,后缀改为bat,右键编辑打开) 4.只需要改这三个地方,别的地方不用动 1.这个是你电脑kettle的安装路径 2.这个是你kettle作业的路径 3.这个是你kettle日志的路径(自己新建一个

    2024年02月01日
    浏览(60)
  • 性能优化和可伸缩性策略:如何制定优化和可伸缩性策略并实施计划

    作者:禅与计算机程序设计艺术 随着互联网业务的不断发展,应用场景也越来越多样化、功能更加复杂、业务规模扩张速度越来越快,如何应对不断变化的业务环境和用户需求,保证服务质量,确保业务持续运行?性能优化和可伸缩性策略(POPS)就是为了解决这些问题而生

    2024年02月09日
    浏览(37)
  • 15天学习MySQL计划-SQL优化/视图(进阶篇)-第八天

    1.插入数据(insert) 1.批量插入 2.手动提交事务 3.主键顺序插入 4.大批量插入数据 如果一次性需要插入大批量数据,使用insert语句插入性能较低,此时可以使用MySQL数据库提供的load指令来进插入 方法如下。 2.主键优化 1.数据组织方式 2.页分裂 页可以为空,也可以填充一半,

    2023年04月26日
    浏览(52)
  • Hive执行计划之什么是hiveSQL向量化模式及优化详解

    Hive开启向量化模式也是hiveSQL优化方法中的一种,可以提升hive查询速率,也叫hive矢量化。 问题1:那么什么是hive向量化模式呢? 问题2:hive向量化什么情况下可以被使用,或者说它有哪些使用场景呢? 问题3:如何查看hive向量化使用的相关信息? hive向量化模式是hive的一个特

    2024年02月08日
    浏览(44)
  • AI时代下的智能商品计划如何助力服装企业实现库存精准优化

    在AI时代,智能商品计划为服装企业实现库存精准优化提供了强大的支持。以下是AI在这方面的关键作用和助力手段: 1. 数据驱动的需求预测: AI利用大数据和机器学习技术,分析历史销售数据、市场趋势、季节性变化等多方面信息,实现更准确的需求预测。这有助于企业根

    2024年01月21日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包