（MATLAB代码分享，可运行）基于改进遗传算法的柔性作业车间调度优化研究

运筹不帷幄

已于 2022-02-26 11:23:34 修改

阅读量6k

点赞数 15

文章标签： matlab 开发语言算法

于 2022-01-04 21:23:34 首次发布

本文链接：https://blog.csdn.net/c__batcoder/article/details/122311620

版权

问题描述

柔性加工车间，一个工件的单个工序的加工机床可以由多台机床完成，一个机床可以加工多种工件。

多目标优化的时候，加权系数暂定a=1,b=1;
a+b=1，a=0.6或0.7或,0.8
单目标的时候
a=0,b=1;（只考虑能耗最小，不在乎时间的长短。）
a=1,b=0; （只考虑加工时间最短，不在乎加工能耗多少）

变量定义与注解

（定值，取值范围确定的，可由案例中看到具体的，工件种类，每种工件的加工工序即加工步骤，每个工件的单个加工工序可由多台候选中的1台来完成，机床的空载与待机功率确定不变。工件的单步加工能耗，加工时间，对刀时间，空闲等待时间的不同，具体取值受限于可选用的机床不同而不同）

$i, j, m$ 分别表示工件种类序号，工件工序序号，机床序号，是中间过程值。 $I, J, M$ 表示所有的工件，工序机床的所有集合。i定值，取值范围确定，m定值，取值范围确定，j的取值范围受限于i的变化
${{n}_{i}}$ 表示工件 $i$ 的加工个数的序号中间过程值，取值范围受限于 ${{N}_{i}}$ ，
${{N}_{i}}$ 表示工件 $i$ 的加工总量，定值，取值范围受限于i的变化
${{n}_{ij}}ij$ 中间值， ${{N}_{ij}}ij$ 定值，受限于i
${{N}_{im}}$ 机床 ${{M}_{m}}$ 上被加工的第i种工件加工总量
${{O}_{ij}}$ 工件i的工序的第j道加工工序,可由符合条件的多台机床完成。定值受限于i,j的变化。
${{N}_{m}}$ 表示机床m可执行的所有工件的所有工序总集合{ ${{O}_{ij}}$ } ，定值，受限于i,j,m
${{M}_{ij}}$ 工件工序 ${{o}_{ij}}$ 可选的机器集合，定值，受限于i,j,

${{t}^{c}}_{ijm}$ 是机床m单个工序 ${{O}_{ij}}$ 的总加工时间,定值，取值范围受限于i,j,m的个体差异,
${{T}^{c}}_{ijm}$ 工件工序 ${{o}_{ij}}$ 在机床 ${{M}_{m}}$ 上整体加工时间. 受限于 ${{t}^{c}}_{ijm}$ 与数量的差异
${{E}_{ijm}}$ 工件工序 ${{o}_{ij}}$ 在机床 ${{M}_{m}}$ 上加工阶段能耗，定值，取值范围受限于i,j,m的差异，
${{E}^{c}}_{m}$ 机床 ${{M}_{m}}$ 所有工件的阶段总能耗，受限于 ${{E}_{ijm}}$ 与数量的限制
${{t}^{u}}_{ijm}$ 单个工件的单个工序 ${{o}_{ij}}$ 在机床 ${{M}_{m}}$ 上加工之前需要对刀时间，定值，取值范围受限于i,j,m
${{T}^{u}}_{ijm}$ 所有工件工序 ${{o}_{ij}}$ 在机床 ${{M}_{m}}$ 上加工之前需要对刀时间，受限于 ${{t}^{u}}_{ijm}$
与数量
$P_{m}^{\text{u}}$ 机床 ${{M}_{m}}$ 的空载功率定值，取值范围受限于m的取值范围
${{E}^{w}}_{m}$ 机床 ${{M}_{m}}$ 的空载能耗定值，取值范围受限于m的变化
$P_{m}^{w}$ 机床 ${{M}_{m}}$ 的待机功率定值，取值范围受限于m的取值范围
${{T}^{w}}_{ijm}$ 单个工件单工序 ${{o}_{ij}}$ 在机床 ${{M}_{m}}$ 上的空闲待机时间，受限于开始装夹时刻，结束拆家时刻，加工时间，与对刀时间。
${{E}^{w}}_{m}$ 机床 ${{M}_{m}}$ 的待机能耗，受限于待机功率与待机时间。
$S_{{{T}_{m}}}^{k}$ 在机床 ${{M}_{m}}$ 加工第k件工件的开始装夹时刻
$C_{{{T}_{m}}}^{k}$ 在机床 ${{M}_{m}}$ 加工第k件工件的结束拆夹时刻
$g_{m}^{k}$ 在机床 ${{M}_{m}}$ 加工第k件工序之前需要对刀•

$C_{ijm}^{k}$ 用来判断在机床 ${{M}_{m}}$ 上加工的工件工序j是否是工件i的工序 ${{O}_{ij}}$ ${{M}_{ij}}\in \{{{O}_{ij}}\}$
${{x}_{ijm}}$ 用来判断 ${{N}_{m}}$ 表示机床m可执行的所有工件的所有工序总集合{ ${{O}_{ij}}$ } ${{O}_{ij}}\in {{N}_{m}}=\{{{O}_{ij}}\}$
${{y}_{ijm}}h_{m}^{k}\in \left\{ 0,1 \right\}$ 中间变量
$g_{m}^{k}$ 用来判断，是否需要换刀，受限于中间变量 ${{y}_{ijm}}h_{m}^{k}$

${{x}_{ijm}},g_{m}^{k},G_{ijm}^{k}\in \left\{ \left. 0,1 \right\} \right.$
在这里插入图片描述

调度过程中的机床能耗由工序加工能耗、对刀能耗、机床空闲等待能耗三部分构成。

柔性车削加工车间分批调度总能耗 E 是车间机床消耗电能之和，计算公式如下
$E=\sum\limits_{m=1}^{M}{{{E}_{m}}}=\sum\limits_{m=1}^{M}{(E_{m}^{c}}+E_{m}^{t}+E_{m}^{i})$ （1）
总完工时间 ${{T}_{C}}=\underset{\forall m}{\mathop{\max }}\,C_{{{T}_{m}}}^{{{K}_{m}}}$ $m\in [1,M]$ （2）

单台机床能耗与时间具体分析如下

工序加工阶段

加工能耗：在第m台机床上加工第i种工件的第j到工序。
$E_{m}^{c}=\sum\limits_{i=1}^{I}{\sum\limits_{j=1}^{{{L}_{i}}}{\sum\limits_{{{n}_{i}}=1}^{{{N}_{i}}}{{{n}_{ij}}\times {{E}_{ijm}}}}}\times {{x}_{ijm}}$ （3）
注意： ${x}_{ijm}=1 ,if , {O}_{ij} \in {N}_{m}$

是给定值。 ${{N}_{ij}}$ 为给定值
单位加工时间 ${{t}^{c}}_{ijm}$ 为给定值
总加工时间 $T_{ijm}^{c}=\sum\limits_{i=1}^{I}{\sum\limits_{j=1}^{{{L}_{i}}}{\sum\limits_{{{n}_{i}}}^{{{N}_{i}}}{{{n}_{ij}}\times {{t}^{c}}_{ijm}}}}\times {{x}_{ijm}}$ （4）

对刀阶段

能耗。此此时刻机床处于空载状态，运用空载功率与空载时间。
$E_{m}^{u}=P_{m}^{u}\left( \sum\limits_{i}^{I}{\sum\limits_{j}^{{{L}_{i}}}{G_{ijm}^{k}\times {{x}_{ijm}}\times }}g_{m}^{k}\times {{t}^{\text{u}}}_{ijm} \right)$ （5）

注意： $t_{ijm}^{u}$ 为给定值。
在这里插入图片描述
当机床 ${{M}_{m}}$ 上加工，由于同一种工件毛坯料尺寸的相似性，当工件的代加工工序属于机床m的加工序列集合即 ${{O}_{ij}}\in {{N}_{m}}$ ，并且是该批工件的第1个工件即$$ ${{n}_{i}}=1$ ，两个条件都满足的时候，机床才会产生对刀能耗。其余条件下，本机床不会产生这种能耗
对刀时间总时间
$T_{ijm}^{u}=\sum\limits_{i=1}^{I}{\sum\limits_{j=1}^{{{L}_{i}}}{{{x}_{ijm}}\times g_{m}^{k}}}\times t_{ijm}^{u}$ （6）

机床空闲等待阶段（此时机床属于待机状态。具体能耗值为待机功率与待机时间）

机床空闲等待时间为
$T_{ijm}^{w}=C_{{{T}_{m}}}^{{{N}_{i}}}-S_{{{T}_{m}}}^{1}-T_{ijm}^{c}-T_{ijm}^{u}$ （7）

因此机床空闲等待能耗的计算公式为
$E_{m}^{w}=p_{m}^{st}\times T_{ijm}^{w}$ （8）

约束条件

（1）机床的加工必须满足前一个工件加工完成后，下一个工件方可开始加工。
$C_{{{T}_{m}}}^{{{n}_{\text{i}}}\text{ }}\le S_{{{T}_{m}}}^{{{n}_{i}}+1}$ ${{n}_{i}}\in \left[ 1,{{N}_{i}} \right]$ $m\in \left[ 1,M \right]$
（2）同一个工件的加工必须满足前一道工序加工完成后，下一道才能开始加工。
$\sum\limits_{m=1}^{M}{\sum\limits_{i=1}^{I}{\sum\limits_{{{n}_{i}}=1}^{{{N}_{i}}}{\left( C_{{{T}_{m}}}^{{{n}_{i}}}{{x}_{ijm}} \right)\le }}}\sum\limits_{m=1}^{M}{\sum\limits_{i=1}^{I}{\sum\limits_{{{n}_{i}}=1}^{{{N}_{i}}}{{}}\left( S_{{{T}_{m}}}^{{{n}_{i}}}{{x}_{i(j+1)m}} \right)}}$ ； $m\in \left[ 1,M \right]$ $i\in \left[ 1,I \right]$ ${{n}_{i}}\in \left[ 1,{{N}_{i}} \right]$ $j\in [1,{{L}_{i}}]$
（3）同一台机床同一时刻只能加工一种工件的一道工序。
$\sum\limits_{i=1}^{I}{\sum\limits_{j=1}^{{{L}_{i}}}{G_{ijm}^{k}=1}}$ $i\in [1,I]$ $j\in \left[ 1,{{L}_{i}} \right]$ $m\in \left[ 1,M \right]$ $k\in [1,{{N}_{im}}]$
（4）批量的工件的任意工序一旦开始加工，中途不能被打断。
$\sum\limits_{m=1}^{M}{\sum\limits_{{{n}_{i}}=1}^{{{N}_{i}}}{G_{ijm}^{k}=1}}$ $i\in [1,I]$ ${{n}_{i}}\in \left[ 1,{{N}_{i}} \right]$ $m\in \left[ 1,M \right]$ $k\in [1,{{N}_{im}}]$
（5）同一种工件的同种加工工序的工序只能选择一台机床加工。
$\sum\limits_{m=1}^{M}{{{x}_{ijm}}=1}$ $i\in [1,I]$ $j\in \left[ 1,{{L}_{i}} \right]$ $m\in \left[ 1,M \right]$
（6）工件必须在到达之后才能开始加工。
$\underset{\forall i}{\mathop{\text{min}}}\,\left( \sum\limits_{m=1}^{M}{\sum\limits_{{{n}_{i}}=1}^{{{N}_{i}}}{\left( S_{{{T}_{m}}}^{{{n}_{i}}}\times {{x}_{ijm}}\times G_{ijm}^{k} \right)}} \right)\ge {{A}_{i}}$
（7）工件必须在工件交货期之前完工。
$\underset{\forall i}{\mathop{\text{max}}}\,\left( \sum\limits_{m=1}^{M}{\sum\limits_{{{n}_{i}}=1}^{{{N}_{i}}}{\left( C_{{{T}_{m}}}^{{{n}_{i}}}\times {{x}_{ijm}}\times G_{ijm}^{k} \right)}} \right)\le {{B}_{i}}$
（8）工件的单工序加工数量之和必须等于该工件的加工批量。
$\sum\limits_{i=1}^{I}{\sum\limits_{{{n}_{i}}=1}^{{{N}_{i}}}{{{n}_{ij}}=\sum\limits_{i=1}^{I}{{{N}_{i}}}}}$ $i\in [1,I]$ ${{n}_{i}}\in \left[ 1,{{N}_{i}} \right]$
（9）0-1 变量约束。
${{x}_{ijm}},g_{m}^{k},G_{ijm}^{k}\in \left\{ \left. 0,1 \right\} \right.$ 中间变量 ${{y}_{ijm}}h_{m}^{k}\in \left\{ 0,1 \right\}$

编码方式与数据设置

机床序号m=[1,10]
工件种类序号i=[1,5]
i=1时候， $j\in {{L}_{1}}=\{1,2,3\}$
I=2 $j\in {{L}_{2}}=\{1,2,34\}$
i=3, $j\in {{L}_{3}}=\{1,2,3\}$
i=4， $j\in {{L}_{4}}=\{1,2,34\}$
i=5 $j\in {{L}_{5}}=\{1,2,34\}$
双层编码结构。基于工件加工工序编码与对应的工序分配的机床编码。
示例:染色体基因段 (工序排列基因段，选用机床排列段)
工序总集 $\text{ }\!\!\{\!\!\text{ }{{O}_{11}}{{O}_{12}}{{O}_{13}}{{O}_{21}}{{O}_{22}}{{O}_{23}}{{O}_{24}}{{O}_{31}}{{O}_{32}}{{O}_{33}}{{O}_{41}}{{O}_{42}}{{O}_{43}}{{O}_{44}}{{O}_{51}}{{O}_{52}}{{O}_{53}}{{O}_{54}}\}$
工序染色体基因段1 1 1 2 2 2 2 3 3 3 4 4 4 4 5 5 5 5
对应加工工序的选用机床分配染色体基因段1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 注解：每种加工工序的可选机床机床集合中的排位，比如 ${{O}_{21}}$ 可选用机床集合{ ${{M}_{01}}{{M}_{02}}{{M}_{03}}{{M}_{04}}$ }, 对应的1就是可选机床集合中的第1台即 ${{M}_{01}}$

表2机床信息

1.车床

机床 ${{M}_{m}}$	机床类别	机床型号	待机功率/W	空载功率/W
${{M}_{01}}$	数控车床	CHK560	1626	2102
${{M}_{02}}$	数控车床	CHK460	1072	1556
${{M}_{03}}$	数控车床	C2-6150K	241	2836
${{M}_{04}}$	数控车床	C2-6150HK/1	284	1253

2.铣床

${{M}_{05}}$	数控铣床	XK5032	85	961
${{M}_{06}}$	数控铣床		134	1048
${{M}_{07}}$	数控铣床	X5032	85	850

钻床

${{M}_{08}}$	数控钻床	ZXK50	421	653
${{M}_{09}}$	数控钻床	ZHL765	574	826

4,磨床

${{M}_{10}}$	数控磨床—内磨	M131W	81	709
${{M}_{10}}$	数控磨床—外磨	M131W	81	1723

表3工件加工信息表

工件种类 $i$	加工数量 ${{N}_{i}}$	到达时间 ${{A}_{i}}$ /S	交货期 ${{D}_{i}}$ /S
1	80	0	600000
2	150	2800	600000
3	100	1740	600000
4	180	3750	600000
5	300	860	600000

表4工件加工能耗/时间信息表

工件种类	工序编号	工序名称	加工机床	工序加工能耗	工序加工时间	对刀时间
${{I}_{1}}$	${{O}_{11}}$	车削	${{M}_{03}}$	3762132	589	68
			${{M}_{04}}$	3356324	815	78
	${{O}_{12}}$	铣削	${{M}_{05}}$	185473	185	81
			${{M}_{06}}$	208950	171	77
	${{O}_{13}}$	数控钻	${{M}_{08}}$	489007	475	78

${{O}_{21}}$	车削	${{M}_{01}}$	4431457	1532	103
		${{M}_{02}}$	4387694	1768	64
		${{M}_{03}}$	4922201	1178	78
		${{M}_{04}}$	4417923	1501	91
${{O}_{22}}$	铣削	${{M}_{05}}$	949708	261	76
		${{M}_{07}}$	985683	234	87
${{O}_{23}}$	数控钻	${{M}_{08}}$	786297	476	99
		${{M}_{09}}$	972452	413	114
${{O}_{24}}$	数控磨-外磨	${{M}_{10}}$	326605	415	37

${{O}_{31}}$	车削	${{M}_{01}}$	2992184	717	46
		${{M}_{02}}$	3174087	923	47
		${{M}_{03}}$	3042597	745	53
		${{M}_{04}}$	2975382	789	45
${{O}_{32}}$	车削	${{M}_{01}}$	452937	110	22
		${{M}_{02}}$	440618	146	17
		${{M}_{03}}$	446235	121	19
		${{M}_{04}}$	426837	135	15
${{O}_{33}}$	铣	${{M}_{06}}$	73826	67	39
		${{M}_{07}}$	68819	58	43

${{O}_{41}}$	车	${{M}_{01}}$	523763	166	89
		${{M}_{02}}$	458283	193	71
		${{M}_{03}}$	500921	166	69
		${{M}_{04}}$	473815	169	63
${{O}_{42}}$	车	${{M}_{01}}$	661014	216	68
		${{M}_{02}}$	651601	287	47
		${{M}_{03}}$	656023	230	53
		${{M}_{04}}$	614314	245	46
${{O}_{43}}$	外磨	${{M}_{10}}$	326605	415	33
${{O}_{44}}$	内磨	${{M}_{10}}$	401115	187	17

${{O}_{51}}$	车	${{M}_{01}}$	4431457	1532	49
		${{M}_{02}}$	4387694	1768	56
		${{M}_{03}}$	4922201	1178	51
${{O}_{52}}$	铣	${{M}_{05}}$	73826	43	43
		${{M}_{07}}$	68819	59	57
${{O}_{52}}$	钻	${{M}_{09}}$	786297	476	97
${{O}_{54}}$	外磨	${{M}_{10}}$	204288	168	46

改进遗传算法（代码以及参考资料可以私信评论邮箱获取）

在这个问题中涉及到的变量种类较多，较为复杂，这里介绍一种比较新颖的数据传递方式。在matlab中将所有的常量打包放进一个global变量中，在函数调用时，直接申请使用全局变量。这样可以避免函数定义写的非常长非常乱。对开发过程具有较好效果。缺点是，使用全局变量会导致速度变慢。
在这里插入图片描述

优化过程示意图

在这里插入图片描述

结果展示

在这里插入图片描述

// 函数的主程序入口
%% 清空环境
clc
clear
close all

%% 模型参数
load data
global Global info
Global.M = 11;
Global.I = 5;
Global.m_power = M_power;

% Ai=zeros(5,1);
% Ni=ones(5,1);

Global.Ni = Ni;
Global.Ai = Ai;
Global.Di = Di;
% Global.fault = [4 50000]; %第一个是机器编号，第二个是故障时间

Global.Ni(5)=130;
Global.xishu=[0,1];
Global.fun = @(x) fun(x);%改成fun1就是有故障的。
init_data();

nVar = 0;
for i=1:Global.I
    nVar = nVar+info(i).num_gongxu;
end

%% 遗传算法参数
maxgen=300;                         %进化代数
sizepop=50;                       %种群规模
k1=7e+8;                      %交叉概率
k2=4e+8;                  %变异概率

%% 个体初始化
individuals=struct('fitness',zeros(1,sizepop), 'chrom',[]);  %种群结构体
avgfitness=[];                                               %种群平均适应度
bestfitness=[];                                              %种群最佳适应度
bestchrom=[];                                                %适应度最好染色体
% 初始化种群
for i=1:sizepop
    individuals.chrom(i,:)=Code();       %随机产生个体
    x=individuals.chrom(i,:);
    individuals.fitness(i)=Global.fun(x);                     %个体适应度
end

%找最好的染色体
[bestfitness bestindex]=min(individuals.fitness);
bestchrom=individuals.chrom(bestindex,:);  %最好的染色体
avgfitness=sum(individuals.fitness)/sizepop; %染色体的平均适应度
% 记录每一代进化中最好的适应度和平均适应度
trace=[];

%% 进化开始
h = waitbar(0,'正在优化中。。。');
for i=1:maxgen
    waitbar(i/maxgen,h);
    %自适应修改交叉变异概率
    pcross=k1/(avgfitness-bestfitness);                      %交叉概率
    pmutation=k2/(avgfitness-bestfitness);                  %变异概率
    
    % 选择操作
    individuals=Select(individuals,sizepop);
    avgfitness=sum(individuals.fitness)/sizepop;
    % 交叉操作
    individuals.chrom=Cross(pcross,individuals.chrom,sizepop);
    % 变异操作
    individuals.chrom=Mutation(pmutation,individuals.chrom,sizepop);
    
    % 计算适应度
    for j=1:sizepop
        x=individuals.chrom(j,:);
        individuals.fitness(j)=Global.fun(x);
    end
    
    %找到最小和最大适应度的染色体及它们在种群中的位置
    [newbestfitness,newbestindex]=min(individuals.fitness);
    [worestfitness,worestindex]=max(individuals.fitness);
    % 代替上一次进化中最好的染色体
    if bestfitness>newbestfitness
        bestfitness=newbestfitness;
        bestchrom=individuals.chrom(newbestindex,:);
        
        figure(1)
        hold off
        plot(1,1)
        draw
        pause(0.01)
    end
    individuals.chrom(worestindex,:)=bestchrom;
    individuals.fitness(worestindex)=bestfitness;
    
    avgfitness=sum(individuals.fitness)/sizepop;
    trace=[trace;avgfitness bestfitness]; %记录每一代进化中最好的适应度和平均适应度
end
close(h);
%进化结束

%% 结果显示
[r c]=size(trace);
figure
plot([1:r]',trace(:,2),'r-','LineWidth',2);
title(['函数值曲线  ' '终止代数＝' num2str(maxgen)],'fontsize',12);
xlabel('进化代数','fontsize',12);ylabel('函数值','fontsize',12);
legend('迭代优化曲线')
disp(['函数值:' num2str(bestfitness)]);

// 这里是计算目标函数值的程序代码
function [y,release_time,T_start,T_need,T_end,T_total,T_jiagong,T_duidao,T_kongxian,P_total,P_jiagong,P_duidao,P_kongxian] = fun(x)
nVar = numel(x);
global Global info

%% 从头到尾安排工件进行加工
T_jiagong = 0;
T_duidao = 0;
T_kongxian = 0;
T_start = zeros(Global.I,4); %开工时间
T_need = zeros(Global.I,4); %加工时间
T_end = zeros(Global.I,4); %完工时间
release_time = zeros(1,Global.M); %下一次的可用时间

P_jiagong = 0;
P_duidao = 0;
P_kongxian = 0;

count_gongxu=ones(1,Global.I);
count_gongjian=zeros(1,Global.M); %记录机器使用次数
for i=1:nVar/2
    cur_gongjian = x(i);
    cur_gongxu = count_gongxu(cur_gongjian);
    count_gongxu(cur_gongjian) = count_gongxu(cur_gongjian)+1;
    cur_machine = x(nVar/2+i);
    cur_machine_code = info(cur_gongjian).gongxu(cur_gongxu).bianhao(cur_machine);
    count_gongjian(cur_machine_code) = count_gongjian(cur_machine_code) + 1;
    
    if cur_gongxu==1 %当前工件的首个工序
        if release_time(cur_machine_code)>Global.Ai(cur_gongjian) %当前几床被占用
            T_start(cur_gongjian,cur_gongxu) = release_time(cur_machine_code);
            T_need(cur_gongjian,cur_gongxu) = Global.Ni(cur_gongjian)*sum(info(cur_gongjian).gongxu(cur_gongxu).data(cur_machine,2)) ...
                + info(cur_gongjian).gongxu(cur_gongxu).data(cur_machine,3);
            release_time(cur_machine_code) = release_time(cur_machine_code) + T_need(cur_gongjian,cur_gongxu);
        else %当前机床没有被占用
            T_start(cur_gongjian,cur_gongxu) = Global.Ai(cur_gongjian);
            T_need(cur_gongjian,cur_gongxu) = Global.Ni(cur_gongjian)*sum(info(cur_gongjian).gongxu(cur_gongxu).data(cur_machine,2))  ...
                + info(cur_gongjian).gongxu(cur_gongxu).data(cur_machine,3);
            P_kongxian = P_kongxian + (T_start(cur_gongjian,cur_gongxu)-release_time(cur_machine_code))*Global.m_power(cur_machine,1);
            T_kongxian = T_kongxian+(T_start(cur_gongjian,cur_gongxu)-release_time(cur_machine_code));
            release_time(cur_machine_code) = T_start(cur_gongjian,cur_gongxu) + T_need(cur_gongjian,cur_gongxu);
        end
        T_jiagong = T_jiagong+Global.Ni(cur_gongjian)*sum(info(cur_gongjian).gongxu(cur_gongxu).data(cur_machine,2));
        T_duidao = T_duidao+Global.Ni(cur_gongjian)*sum(info(cur_gongjian).gongxu(cur_gongxu).data(cur_machine,3));
        P_jiagong = P_jiagong + info(cur_gongjian).gongxu(cur_gongxu).data(cur_machine,1)*Global.Ni(cur_gongjian);
        P_duidao = P_duidao + info(cur_gongjian).gongxu(cur_gongxu).data(cur_machine,3)* ...
            Global.m_power(cur_machine_code,2)*Global.Ni(cur_gongjian);
        T_end(cur_gongjian,cur_gongxu) = T_start(cur_gongjian,cur_gongxu) + T_need(cur_gongjian,cur_gongxu);
        
    else %不是首个工序
        if release_time(cur_machine_code)>T_end(cur_gongjian,cur_gongxu-1) %当前几床被占用
            T_start(cur_gongjian,cur_gongxu) = release_time(cur_machine_code);
            T_need(cur_gongjian,cur_gongxu) = Global.Ni(cur_gongjian)*sum(info(cur_gongjian).gongxu(cur_gongxu).data(cur_machine,2)) ...
                + info(cur_gongjian).gongxu(cur_gongxu).data(cur_machine,3);
            release_time(cur_machine_code) = release_time(cur_machine_code) + T_need(cur_gongjian,cur_gongxu);
        else
            T_start(cur_gongjian,cur_gongxu) = T_end(cur_gongjian,cur_gongxu-1);
            T_need(cur_gongjian,cur_gongxu) = Global.Ni(cur_gongjian)*sum(info(cur_gongjian).gongxu(cur_gongxu).data(cur_machine,2)) ...
                + info(cur_gongjian).gongxu(cur_gongxu).data(cur_machine,3);
            P_kongxian = P_kongxian + (T_start(cur_gongjian,cur_gongxu)-release_time(cur_machine_code))*Global.m_power(cur_machine,1);
            T_kongxian = T_kongxian+(T_start(cur_gongjian,cur_gongxu)-release_time(cur_machine_code));
            release_time(cur_machine_code) = T_start(cur_gongjian,cur_gongxu) + T_need(cur_gongjian,cur_gongxu);
        end
        T_jiagong = T_jiagong+T_need(cur_gongjian,cur_gongxu);
        P_jiagong = P_jiagong + info(cur_gongjian).gongxu(cur_gongxu).data(cur_machine,1)*Global.Ni(cur_gongjian);
        T_end(cur_gongjian,cur_gongxu) = T_start(cur_gongjian,cur_gongxu) + T_need(cur_gongjian,cur_gongxu);
    end
end

non_use = Global.M-numel(find(count_gongjian)==0);

T_total = max(release_time);
P_total = P_jiagong + P_duidao + P_kongxian;
xishu = Global.xishu;
y = sum([T_total P_total].*xishu) + non_use*1000000000;

最后，博主专注于论文的复现工作，有兴趣的同学可以私信共同探讨。相关代码已经上传到资源共享，点击我的空间查看分享代码。

运筹不帷幄

关注

15
点赞
踩
80

收藏

觉得还不错? 一键收藏
打赏
36
评论
（MATLAB代码分享，可运行）基于改进遗传算法的柔性作业车间调度优化研究

问题描述柔性加工车间，一个工件的单个工序的加工机床可以由多台机床完成，一个机床可以加工多种工件。多目标优化的时候，加权系数暂定a=1,b=1;a+b=1，a=0.6或0.7或,0.8单目标的时候a=0,b=1;（只考虑能耗最小，不在乎时间的长短。）a=1,b=0; （只考虑加工时间最短，不在乎加工能耗多少）变量定义与注解（定值，取值范围确定的，可由案例中看到具体的，工件种类，每种工件的加工工序即加工步骤，每个工件的单个加工工序可由多台候选中的1台来完成，机床的空载与待机功率确定不变。工件的单
复制链接

扫一扫