/** Destructor. */
~Worker() {
if ( handle ) {
handle.kill();
handle.join();
}
if ( cplex.getImpl() ) {
cplex.userfunction(USERACTION_REMOVECALLBACK, 0, NULL, 0, 0, NULL);
cplex.end();
}
rng.end();
x.end();
obj.end();
model.end();
}
int main()
{
clock_t start,finish;
double totaltime;
start=clock();
try{
/************************************变量初始化******************************************/
for(IloInt i=0;i<NG;++i)
{
P[i]=IloNumVarArray(env,NT,0,IloInfinity,ILOFLOAT);
S3[i]=IloNumVarArray(env,NT,0,IloInfinity,ILOFLOAT);
deta[i]=10;
}
/************************************数据读取******************************************/
ifstream input_wind("wind_scenarios.txt",ios::in);//误差场景，由蒙特卡洛方法生成
output<<endl<<"error sceanrios:"<<endl;
for(IloInt w=0;w<NW;++w)
{
Pwind[w]=IloNumArray(env,NT);
for(IloInt t=0;t<NT;++t)
{
input_wind>>Pwind[w][t];
output<<Pwind[w][t]<<" ";
}
output<<endl;
}
input_wind.close();
ifstream input_commitment("uc.txt",ios::in);//机组启停状态
output<<endl<<"Unit State:"<<endl;
if(!input_commitment)
{
cerr<<"uc.txt is not exist!!!"<<endl;
}
for(IloInt i=0;i<NG;++i)
{
I[i]=IloNumArray(env,NT);
for(IloInt t=0;t<NT;++t)
{
input_commitment>>I[i][t];
output<<I[i][t]<<" ";
}
output<<endl;
}
input_commitment.close();
ifstream input_preoutput("Ppower.txt",ios::in);//预测场景下出力
output<<endl<<"power of forecast sceanrios:"<<endl;
if(!input_preoutput)
{
cerr<<"Ppower.txt is not exist"<<endl;
}
for(IloInt i=0;i<NG;++i)
{
Pre[i]=IloNumArray(env,NT);
for(IloInt t=0;t<NT;++t)
{
input_preoutput>>Pre[i][t];
output<<Pre[i][t]<<" ";
}
output<<endl;
}
input_preoutput.close();
ifstream input_load("load.txt",ios::in);//读取负荷信息
output<<endl<<"Load:"<<endl;
if(!input_load)
{
cerr<<"load.txt is not exist!!!"<<endl;
}
for(IloInt t=0; t<NT; ++t)
{
input_load>>Pload[t];
output<<Pload[t]<<" ";
}
input_load.close();
ifstream input_BFile("Brach_File.txt",ios::in);//读取风电支路信息:起点，终点，电阻，电抗以及潮流上限
output<<endl<<"Information of Branch:"<<endl;
if(!input_BFile)
{
output<<"Brach_File.txt is not exist!!!"<<endl;
}
for(IloInt k=0; k<Branch; ++k)
{
Info_Branch[k]=IloNumArray(env,5);
for(IloInt h=0; h<5; ++h)
{
input_BFile>>Info_Branch[k][h];
output<<Info_Branch[k][h]<<" ";
}
output<<endl;
}
input_BFile.close();
ifstream input_unitinfo("unit_information.txt",ios::in);//读入机组信息
output<<endl<<"Unit Information:"<<endl;
if(!input_unitinfo)
{
cerr<<"unit_information.txt is not exist!!!"<<endl;
}
for(IloInt i=0;i<NG;++i)
{
Unit[i]=IloNumArray(env,12);//12条信息:结点、Pmin、Pmax、MinOn、MinOff、RU、RD、Startup Cost、c、b、a、price;
for(IloInt k=0; k<12; ++k)
{
input_unitinfo>>Unit[i][k];
output<<Unit[i][k]<<" ";
}
output<<endl;
}
input_unitinfo.close();
output<<endl<<endl<<"deta:"<<endl;
for(IloInt i=0;i<NG;i++)
{
deta[i]=Unit[i][5]/10;
output<<deta[i]<<" ";
}
ifstream input_wind_locate("wind_locate.txt",ios::in);//风场分布
output<<endl<<"wind locate:"<<endl;
if(!input_wind_locate)
{
cerr<<"wind_locate is not exist!!!"<<endl;
}
for(IloInt k=0; k<Node; ++k)
{
input_wind_locate>>Sw[k];
output<<Sw[k]<<" ";
}
input_wind_locate.close();
ifstream input_load_locate("load_locate.txt",ios::in);//负荷分布
output<<endl<<"load locate:"<<endl;
if(!input_load_locate)
{
cerr<<"load_locate is not exist!!!"<<endl;
}
for(IloInt k=0; k<Node; ++k)
{
input_load_locate>>Sw[k];
output<<Sw[k]<<" ";
}
input_load_locate.close();
/////给矩阵B0赋值
for(IloInt k=0; k<Node-1; ++k)//非对角线
{
B0[k]=IloNumArray(env,Node-1);
for(IloInt h=0; h<Node-1; ++h)
{
if(k==h)
continue;
else
{
IloInt temp;
IloInt b=0;
for(; b<Branch; ++b)
{
if((Info_Branch[b][0]-1==k && Info_Branch[b][1]-1==h)
|| (Info_Branch[b][0]-1==h && Info_Branch[b][1]-1==k))
{
temp=b;
break;
}
}
if(b==Branch)
B0[k][h]=0;
else
B0[k][h]= -1.0/Info_Branch[temp][3];
}
}
}
for(IloInt k=0; k<Node-1; ++k)//对角线
{
B0[k][k]=0;
for(IloInt h=0; h<Node-1; ++h)
{
if(k!=h)
{
B0[k][k]+=B0[k][h];
}
}
IloNum last=0;
IloInt b=0;
IloInt temp;
for(;b<Branch;++b)
{
if((Info_Branch[b][0]-1==k && Info_Branch[b][1]-1==Node-1)
|| (Info_Branch[b][0]-1==Node-1 && Info_Branch[b][1]-1==k))
{
temp=b;
break;
}
}
if(b==Branch)
last=0;
else
last=-1.0/Info_Branch[temp][3];
B0[k][k]+=last;
B0[k][k]=-1*B0[k][k];
}
/////赋值完毕
for(IloInt k=0; k<Node-1; ++k)
B0l[k]=IloNumArray(env,Node-1);
IloInvert(B0,B0l,Node-1);//求逆矩阵
/************************************模型******************************************/
IloNumExpr Cost(env);
for(IloInt t=0;t<NT;++t)
{
Cost+=(S1[t]+S2[t]);
for(IloInt i=0;i<NG;++i)
{
Cost+=S3[i][t];
}
}
for(IloInt h=0;h<Branch;++h)
{
Cost+=(S4[h]+S5[h]);
}
Check_Model.add(IloMinimize(env,Cost));//目标函数
for(IloInt i=0; i<NG; ++i)//机组出力上下限约束
for(IloInt t=0; t<NT; ++t)
{
Check_Model.add(P[i][t]<=Unit[i][2]*I[i][t]);
Check_Model.add(P[i][t]>=Unit[i][1]*I[i][t]);
}
// for(IloInt i=0; i<NG; ++i)//机组爬坡约束,应该可以不用考虑
// for(IloInt t=1; t<NT; ++t)
// {
// Check_Model.add(P[i][t]-P[i][t-1]<=(1-I[i][t]*(1-I[i][t-1]))*Unit[i][5]+I[i][t]*(1-I[i][t-1])*Unit[i][1]);
// Check_Model.add(P[i][t-1]-P[i][t]<=(1-I[i][t-1]*(1-I[i][t]))*Unit[i][6]+I[i][t-1]*(1-I[i][t])*Unit[i][1]);
// }
for(IloInt t=0; t<NT; ++t)//机组功率平衡约束
{
IloNumExpr fire(env);
IloNum wind(0);
for(IloInt i=0; i<NG; ++i)
{
fire+=P[i][t];
}
for(IloInt w=0;w<NW;++w)
{
wind+=Pwind[w][t];
}
Check_Model.add(fire+S1[t]-S2[t]==Pload[t]-wind);
fire.end();
}
for(IloInt i=0;i<NG;++i)//机组出力爬坡约束
for(IloInt t=0;t<NT;++t)
{
Check_Model.add(P[i][t]-Pre[i][t]-S3[i][t]<=deta[i]);
Check_Model.add(P[i][t]-Pre[i][t]+S3[i][t]>=-deta[i]);
}
/************************************安全约束******************************************/
for(IloInt t=0; t<NT; ++t)
{
IloExprArray Pf(env,Branch);//潮流
IloExprArray Psp(env,Node-1);//注入功率
IloExprArray Theta(env,Node);//相角
Theta[Node-1]=IloExpr(env);
for(IloInt k=0; k<Node-1; ++k)
{
Psp[k]=IloExpr(env);
IloInt i=0;
for(;i<NG;++i)
{
if(Unit[i][0]-1==k)break;
}
if(i<NG)
{
Psp[k] +=P[i][t];
}
if(Sw[k]>=0)
{
Psp[k] +=Pwind[ Sw[k] ][t];
}
Psp[k] -= Sl[k]*Pload[t];
}
IloMutiply(B0l,Psp,Theta,Node-1);
//计算潮流
for(IloInt h=0; h<Branch; ++h)
{
Pf[h]=IloExpr(env);
Pf[h]+=(Theta[(IloInt)Info_Branch[h][0]-1]-Theta[(IloInt)Info_Branch[h][1]-1])/Info_Branch[h][3];
Check_Model.add(Pf[h]-S4[h]<=Info_Branch[h][4]);
Check_Model.add(Pf[h]+S5[h]>=-Info_Branch[h][4]);
}
Pf.end();
Psp.end();
Theta.end();
}
/************************************模型求解及输出******************************************/
Check_Cplex.solve();
if(Check_Cplex.getStatus() == IloAlgorithm::Infeasible)
output<< "No Solution" << endl;
output<<endl<<"Cost:"<<Check_Cplex.getObjValue()<<endl;
// for(IloInt i=0; i<NG; ++i)
// {
// for(IloInt t=0; t<NT; ++t)
// {
// output<<"机组 "<<i+1<<" 第 "<<t+1<<" 时段状态:"<<Check_Cplex.getValue(I[i][t])<<" 出力:";
// output<<Check_Cplex.getValue(P[i][t])<<endl;
// }
// output<<endl;
// }
Check_Model.end();
Check_Cplex.end();
env.end();
}
catch(IloException& ex)//异常捕获
{
output<<"Error: "<<ex<<endl;
}
catch(...)
{
output<<"Error: Unknown exception caught!" << endl;
}
finish=clock();
totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
output<<"totaltime: "<<totaltime<<"s"<<endl<<endl;
output.close();
return 0;
}
int main()
{
clock_t start,finish;
double totaltime;
start=clock();
try
{
output<<">>>>>>>>>>>>>>数据区<<<<<<<<<<<<<<<"<<endl;
define_data(env);//首先初始化全局变量
output<<">>>>>>>>>>>>>>数据区结束<<<<<<<<<<<<<<<"<<endl;
/*************************************************************目标函数*******************************************************/
IloNumExpr Cost(env);
for(IloInt i=0; i<NG; ++i) //运行成本及其线性化（青华姐论文）
for(IloInt l=0; l<NL; ++l)
for(IloInt t=0; t<NT; ++t)
{
Master_Model.add(Deta[i][l][t]<=Z[i][l+1]-Z[i][l]);
}
for(IloInt i=0; i<NG; ++i)
for(IloInt t=0; t<NT; ++t)
{
IloNumExpr Deta_Sum(env);
for(IloInt l=0; l<NL; ++l)
{
Deta_Sum+=Deta[i][l][t];
}
Master_Model.add(P[i][t]==Deta_Sum+Unit[i][1]*I[i][t]);
Deta_Sum.end();
}
for(IloInt i=0; i<NG; ++i)
{
for(IloInt t=0; t<NT; ++t)
{
IloNumExpr f1(env);
f1+=(Unit[i][10]+Unit[i][9]*Unit[i][1]+Unit[i][8]*Unit[i][1]*Unit[i][1])*I[i][t];
for(IloInt l=0; l<NL; ++l)
f1+=Betaa[i][l]*Deta[i][l][t];
Cost+=f1*Unit[i][11];
f1.end();
}
}
for(IloInt i=0; i<NG; ++i)//开机成本
for(IloInt t=1; t<NT; ++t)
{
Cost+=Unit[i][11]*Unit[i][7]*I[i][t]*(1-I[i][t-1]);
}
for(IloInt i=0; i<NG; ++i)//停机成本
for(IloInt t=1; t<NT; ++t)
{
Cost+=Unit[i][11]*Unit[i][7]*I[i][t-1]*(1-I[i][t]);
}
Master_Model.add(IloMinimize(env,Cost));
/********************************************************机组出力上下限约束**************************************************/
for(IloInt i=0; i<NG; ++i)
for(IloInt t=0; t<NT; ++t)
{
Master_Model.add(P[i][t]<=Unit[i][2]*I[i][t]);//最好分开写
Master_Model.add(P[i][t]>=Unit[i][1]*I[i][t]);
}
/*********************************************************机组爬坡约束******************************************************/
for(IloInt i=0; i<NG; ++i)
for(IloInt t=1; t<NT; ++t)
{
Master_Model.add(P[i][t]-P[i][t-1]<=(1-I[i][t]*(1-I[i][t-1]))*Unit[i][5]+I[i][t]*(1-I[i][t-1])*Unit[i][1]);
Master_Model.add(P[i][t-1]-P[i][t]<=(1-I[i][t-1]*(1-I[i][t]))*Unit[i][6]+I[i][t-1]*(1-I[i][t])*Unit[i][1]);
}
/*********************************************************机组功率平衡约束**************************************************/
for(IloInt t=0; t<NT; ++t)
{
IloNumExpr fire(env);
IloNum wind(0);
for(IloInt i=0; i<NG; ++i)
{
fire+=P[i][t];
}
for(IloInt w=0;w<NW;++w)
{
wind+=Pwind[t][w];
}
Master_Model.add(fire==Pload[t]-wind);
fire.end();
}
/**********************************************************备用约束********************************************************/
for(IloInt t=0; t<NT; ++t) //条件不全
{
IloNumExpr expr(env);
for(IloInt i=0; i<NG; ++i)
{
expr+=Unit[i][2]*I[i][t];
}
Master_Model.add(expr>=R[t]+Pload[t]);
}
/**********************************************************安全约束********************************************************/
////求每个节点的注入功率
for(IloInt t=0; t<NT; ++t)
{
IloExprArray Pf(env,Branch);//潮流
IloExprArray Psp(env,Node-1);//注入功率
IloExprArray Theta(env,Node);//相角
Theta[Node-1]=IloExpr(env);
for(IloInt k=0; k<Node-1; ++k)
{
Psp[k]=IloExpr(env);
IloInt i=0;
for(;i<NG;++i)
{
if(Unit[i][0]-1==k)break;
}
if(i<NG)
{
Psp[k] +=P[i][t];
}
if(Sw[k]>=0)
Psp[k] += Pwind[t][ Sw[k] ] ;
Psp[k] -= Sl[k]*Pload[t];
}
IloMutiply(B0l,Psp,Theta,Node-1);
//计算潮流
for(IloInt h=0; h<Branch; ++h)
{
Pf[h]=IloExpr(env);
Pf[h]+=(Theta[(IloInt)Info_Branch[h][0]-1]-Theta[(IloInt)Info_Branch[h][1]-1])/Info_Branch[h][3];
Master_Model.add(Pf[h]<=Info_Branch[h][4]);
Master_Model.add(Pf[h]>=-Info_Branch[h][4]);
}
Pf.end();
Psp.end();
Theta.end();
}
/************************************************************最小开机时间约束*****************************************************/
for(IloInt i=0; i<NG; ++i)
{
IloNumExpr expr1(env);
for(IloInt t=0; t<=Unit[i][3]-1; ++t)
{
expr1+=I[i][t];
}
Master_Model.add((expr1-I[i][0]*Unit[i][3])>=0);
expr1.end();
for(IloInt t=1; t<=NT-Unit[i][3]; ++t)
{
IloNumExpr expr2(env);
for(IloInt k=t; k<=t+Unit[i][3]-1; ++k)
{
expr2+=I[i][k];
}
Master_Model.add(expr2>=Unit[i][3]*(I[i][t]-I[i][t-1]));
expr2.end();
}
for(IloInt t=NT-(IloInt)Unit[i][3]+1; t<=NT-1; ++t)
{
IloNumExpr expr2(env);
for(IloInt h=t; h<=NT-1; ++h)
{
expr2+=(I[i][h]-(I[i][t]-I[i][t-1]));
}
Master_Model.add(expr2>=0);
expr2.end();
}
}
/*******************************************************最小停机时间约束******************************************************/
for(IloInt i=0; i<NG; ++i)
{
IloNumExpr expr1(env);
for(IloInt t=0; t<=Unit[i][4]-1; ++t)
{
expr1+=(1-I[i][t]);
}
Master_Model.add((expr1-(1-I[i][0])*Unit[i][4])>=0);
expr1.end();
for(IloInt t=1; t<=NT-Unit[i][4]; ++t)
{
IloNumExpr expr1(env);
for(IloInt k=t; k<=t+Unit[i][4]-1; ++k)
{
expr1+=(1-I[i][k]);
}
Master_Model.add(expr1>=Unit[i][4]*(I[i][t-1]-I[i][t]));
expr1.end();
}
for(IloInt t=NT-(IloInt)Unit[i][4]+1; t<=NT-1; ++t)
{
IloNumExpr expr2(env);
for(IloInt h=t; h<=NT-1; ++h)
{
expr2+=(1-I[i][h]-(I[i][t-1]-I[i][t]));
}
Master_Model.add(expr2>=0);
expr2.end();
}
}
/*******************************************************以下是场景相关约束******************************************************/
for(IloInt s=0;s<Set;++s)
{
for(IloInt t=0;t<NT;++t)//功率平衡约束
{
IloNumExpr fire(env);
for(IloInt i=0; i<NG; ++i)
{
fire+=Ps[s][i][t];
}
IloNum wind(0);
for(IloInt w=0;w<NW;++w)
wind+=Pswind[s][t][w];
Master_Model.add(fire==Pload[t]-wind);
fire.end();
}
for(IloInt i=0; i<NG; ++i)//机组出力上下限约束
for(IloInt t=0; t<NT; ++t)
{
Master_Model.add(Ps[s][i][t]<=Unit[i][2]*I[i][t]);//最好分开写
Master_Model.add(Ps[s][i][t]>=Unit[i][1]*I[i][t]);
}
for(IloInt i=0; i<NG; ++i)//建议行为约束
for(IloInt t=0; t<NT; ++t)
{
Master_Model.add(Ps[s][i][t]-P[i][t]<=ddtt);
Master_Model.add(-Ps[s][i][t]+P[i][t]<=ddtt);
}
for(IloInt t=0; t<NT; ++t)//安全约束
{
IloExprArray Pf(env,Branch);//潮流
IloExprArray Psp(env,Node-1);//注入功率
IloExprArray Theta(env,Node);//相角
Theta[Node-1]=IloExpr(env);
for(IloInt k=0; k<Node-1; ++k)
{
Psp[k]=IloExpr(env);
IloInt i=0;
for(;i<NG;++i)
{
if(Unit[i][0]-1==k)break;
}
if(i<NG)
{
Psp[k] +=Ps[s][i][t];
}
if(Sw[k]>=0)
Psp[k] += Pswind[s][t][ Sw[k] ];
Psp[k] -= Sl[k]*Pload[t];
}
IloMutiply(B0l,Psp,Theta,Node-1);
//计算潮流
for(IloInt h=0; h<Branch; ++h)
{
Pf[h]=IloExpr(env);
Pf[h]+=(Theta[(IloInt)Info_Branch[h][0]-1]-Theta[(IloInt)Info_Branch[h][1]-1])/Info_Branch[h][3];
Master_Model.add(Pf[h]<=Info_Branch[h][4]);
Master_Model.add(Pf[h]>=-Info_Branch[h][4]);
}
Pf.end();
Psp.end();
Theta.end();
}
}
Master_Cplex.solve();
/************************************************************输出显示过程**************************************************/
if (Master_Cplex.getStatus() == IloAlgorithm::Infeasible)//输出结果
output << "No Solution" << endl;
output<<"Cost:"<<Master_Cplex.getObjValue()<<endl;
for(IloInt i=0; i<NG; ++i)
{
for(IloInt t=0; t<NT; ++t)
{
output<<"机组 "<<i+1<<" 第 "<<t+1<<" 时段状态:"<<Master_Cplex.getValue(I[i][t])<<" 出力:";
output<<Master_Cplex.getValue(P[i][t])<<endl;
}
output<<endl;
}
Master_Model.end();
Master_Cplex.end();
env.end();
}
catch(IloException& ex)//异常捕获
{
cerr<<"Error: "<<ex<<endl;
}
catch(...)
{
cerr << "Error: Unknown exception caught!" << endl;
}
finish=clock();
totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
output<<"totaltime: "<<totaltime<<"s"<<endl<<endl;
output.close();
return 0;
}
/********************************************程序入口**********************************************/
int main()
{
clock_t start,finish;
double totaltime;
start=clock();
time_t nowTime=time(0);
struct tm* nowTimeStruct=localtime(&nowTime);//时间统计及打印系统时间
output<<"系统当前时间："<<1900+nowTimeStruct->tm_year<<"."<<nowTimeStruct->tm_mon+1<<"."<<
nowTimeStruct->tm_mday<<" "<<nowTimeStruct->tm_hour<<":"<<nowTimeStruct->tm_min<<":"
<<nowTimeStruct->tm_sec<<endl;
try
{
output<<">>>>>>>>>>>>>>>>>>>>>>>>>数据区<<<<<<<<<<<<<<<<<<<<"<<endl;
define_data(env);//首先初始化全局变量
output<<">>>>>>>>>>>>>>>>>>>>>>>>>/数据区<<<<<<<<<<<<<<<<<<<"<<endl<<endl;
/******************************************主问题目标函数*****************************************************/
IloNumExpr Cost(env);
for(IloInt i=0;i<NG;++i)//运行成本及其线性化
for(IloInt l=0;l<NL;++l)
for(IloInt t=0;t<NT;++t)
{
Master_Model.add(Deta[i][l][t]<=Z[i][l+1]-Z[i][l]);
}
for(IloInt i=0;i<NG;++i)
for(IloInt t=0;t<NT;++t)
{
IloNumExpr Deta_Sum(env);
for(IloInt l=0;l<NL;++l)
{
Deta_Sum+=Deta[i][l][t];
}
Master_Model.add(P[i][t]==Deta_Sum+Unit[i][1]*I[i][t]);
Deta_Sum.end();
}
for(IloInt i=0;i<NG;++i)
{
for(IloInt t=0;t<NT;++t)
{
IloNumExpr f1(env);
f1+=(Unit[i][10]+Unit[i][9]*Unit[i][1]+Unit[i][8]*Unit[i][1]*Unit[i][1])*I[i][t];
for(IloInt l=0;l<NL;++l)
f1+=Betaa[i][l]*Deta[i][l][t];
Cost+=f1*Unit[i][11];
f1.end();
}
}
for(IloInt i=0; i<NG; ++i)//开机成本
for(IloInt t=1; t<NT; ++t)
{
Cost+=Unit[i][11]*Unit[i][7]*I[i][t]*(1-I[i][t-1]);
}
for(IloInt i=0; i<NG; ++i)//停机成本
for(IloInt t=1; t<NT; ++t)
{
Cost+=Unit[i][11]*Unit[i][7]*I[i][t-1]*(1-I[i][t]);
}
Master_Model.add(IloMinimize(env,Cost));
Cost.end();
/*******************************************机组出力上下限约束*********************************************/
for(IloInt i=0; i<NG; ++i)
for(IloInt t=0; t<NT; ++t)
{
Master_Model.add(P[i][t]<=Unit[i][2]*I[i][t]);
Master_Model.add(P[i][t]>=Unit[i][1]*I[i][t]);
}
/*********************************************机组爬坡约束**************************************************/
for(IloInt i=0; i<NG; ++i)
for(IloInt t=1; t<NT; ++t)
{
Master_Model.add(P[i][t]-P[i][t-1]<=(1-I[i][t]*(1-I[i][t-1]))*
Unit[i][5]+I[i][t]*(1-I[i][t-1])*Unit[i][1]);
Master_Model.add(P[i][t-1]-P[i][t]<=(1-I[i][t-1]*(1-I[i][t]))*
Unit[i][6]+I[i][t-1]*(1-I[i][t])*Unit[i][1]);
}
/**********************************************机组功率平衡约束**********************************************/
for(IloInt t=0; t<NT; ++t)
{
IloNumExpr fire(env);
IloNum wind(0);
for(IloInt i=0; i<NG; ++i)
{
fire+=P[i][t];
}
for(IloInt w=0;w<NW;++w)
{
wind+=Pwind[t][w];
}
Master_Model.add(fire==Pload[t]-wind);
fire.end();
}
/*************************************************备用约束************************************************/
for(IloInt t=0; t<NT; ++t)
{
IloNumExpr expr(env);
for(IloInt i=0;i<NG;++i)
{
expr+=Unit[i][2]*I[i][t];
}
Master_Model.add(expr>=Pload[t]+R[t]);
expr.end();
}
/*******************************************最小开机时间约束********************************************/
for(IloInt i=0; i<NG; ++i)
{
IloNumExpr expr1(env);
for(IloInt t=0; t<=Unit[i][3]-1; ++t)
{
expr1+=I[i][t];
}
Master_Model.add((expr1-I[i][0]*Unit[i][3])>=0);
expr1.end();
for(IloInt t=1; t<=NT-Unit[i][3]; ++t)
{
IloNumExpr expr2(env);
for(IloInt k=t; k<=t+Unit[i][3]-1; ++k)
{
expr2+=I[i][k];
}
Master_Model.add(expr2>=Unit[i][3]*(I[i][t]-I[i][t-1]));
expr2.end();
}
for(IloInt t=NT-(IloInt)Unit[i][3]+1; t<=NT-1; ++t)
{
IloNumExpr expr2(env);
for(IloInt h=t; h<=NT-1; ++h)
{
expr2+=(I[i][h]-(I[i][t]-I[i][t-1]));
}
Master_Model.add(expr2>=0);
expr2.end();
}
}
/***********************************************最小停机时间约束******************************************/
for(IloInt i=0; i<NG; ++i)
{
IloNumExpr expr1(env);
for(IloInt t=0; t<=Unit[i][4]-1; ++t)
{
expr1+=(1-I[i][t]);
}
Master_Model.add((expr1-(1-I[i][0])*Unit[i][4])>=0);
expr1.end();
for(IloInt t=1; t<=NT-Unit[i][4]; ++t)
{
IloNumExpr expr1(env);
for(IloInt k=t; k<=t+Unit[i][4]-1; ++k)
{
expr1+=(1-I[i][k]);
}
Master_Model.add(expr1>=Unit[i][4]*(I[i][t-1]-I[i][t]));
expr1.end();
}
for(IloInt t=NT-(IloInt)Unit[i][4]+1; t<=NT-1; ++t)
{
IloNumExpr expr2(env);
for(IloInt h=t; h<=NT-1; ++h)
{
expr2+=(1-I[i][h]-(I[i][t-1]-I[i][t]));
}
Master_Model.add(expr2>=0);
expr2.end();
}
}
/*************************************************安全约束*********************************************/
IloInvert(env,B0,B0l,Node-1);//求逆矩阵
for(int t=0;t<NT;++t)//校验所有时段的所有支路的潮流
{
IloNumExprArray Psp(env,Node-1);//注入功率
IloExprArray Theta(env,Node);//相角
Theta[Node-1]=IloExpr(env);
for(IloInt k=0; k<Node-1; ++k)//校验了所有结点的潮流
{
Psp[k]=IloNumExpr(env);
IloInt i=0;
for(;i<NG;++i)
{
if(Unit[i][0]-1==k)break;
}
if(i<NG)
Master_Model.add(P_dual[t][k]==P[i][t]);
else
Master_Model.add(P_dual[t][k]==0);
Psp[k] += P_dual[t][k];
if(Sw[k]>=0)
Psp[k] += Pwind[t][ Sw[k] ];
Psp[k] -= Sl[k]*Pload[t];
}
IloMutiply(env,B0l,Psp,Theta,Node-1);
//计算潮流
for(IloInt h=0; h<Branch; ++h)
{
Master_Model.add(PL[t][h]==(Theta[(IloInt)Info_Branch[h][0]-1]-
Theta[(IloInt)Info_Branch[h][1]-1])/Info_Branch[h][3]);
Master_Model.add(PL[t][h]<=Info_Branch[h][4]);
Master_Model.add(-PL[t][h]<=Info_Branch[h][4]);
}
Psp.end();
Theta.end();
}
// Master_Cplex.extract(Master_Model);
Master_Cplex.solve();
if (Master_Cplex.getStatus() == IloAlgorithm::Infeasible)//输出结果
{
output<<"Master Problem Have No Solution"<<endl;
goto lable2;
}
/**********************************************输出显示过程**********************************************/
output<<"Cost:"<<Master_Cplex.getObjValue()<<endl;
for(IloInt t=0;t<NT;++t)
{
output<<"时段 "<<t+1<<" 机组的启停(I)：";
output<<endl;
for(IloInt i=0;i<NG;++i)
{
output<<Master_Cplex.getValue(I[i][t])<<" ";
}
output<<endl;
output<<"时段 "<<t+1<<" 机组的出力(P)：";
output<<endl;
for(IloInt i=0;i<NG;++i)
{
output<<Master_Cplex.getValue(P[i][t])<<" ";
}
output<<endl;
output<<"时段 "<<t+1<<" 线路潮流(PL)：";
output<<endl;
for(IloInt b=0;b<Branch;++b)
{
output<<Master_Cplex.getValue(PL[t][b])<<" ";
}
output<<endl<<endl<<endl;
}
Master_Model.end();
Master_Cplex.end();
env.end();
}
catch(IloException& ex)//异常捕获
{
output<<"Error: "<<ex<<endl;
}
catch(...)
{
output<<"Error: Unknown exception caught!" << endl;
}
lable2:
finish=clock();
totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
output<<"totaltime: "<<totaltime<<"s"<<endl<<endl;
output.close();
return 0;
}
/**************************************************程序入口****************************************************/
int main()
{
clock_t start,finish;
double totaltime;
start=clock();
try
{
define_data(env);//首先初始化全局变量
IloInvert(env,B0,B0l,Node-1);//求逆矩阵
/*************************************************************主问题目标函数*******************************************************/
IloNumExpr Cost(env);
for(IloInt w=0;w<NW;++w)
{
Cost+=detaPw[w];
}
Master_Model.add(IloMinimize(env,Cost));
//Master_Model.add(IloMaximize(env,Cost));//目标函数二先一
Cost.end();
/********************************************************机组出力上下限约束**************************************************/
IloNumExpr expr1(env),expr2(env);
for(IloInt i=0;i<NG;++i)
{
expr1+=detaP[i];
}
for(IloInt w=0;w<NW;++w)
{
expr2+=detaPw[w];
}
Master_Model.add(expr1==expr2);
expr1.end();
expr2.end();
for(IloInt i=0;i<NG;++i)
{
Master_Model.add(detaP[i]>=Unit[i][1]*u[i]-P1[i]);
Master_Model.add(detaP[i]<=Unit[i][2]*u[i]-P1[i]);
Master_Model.add(detaP[i]>=-detaa[i]);
Master_Model.add(detaP[i]<=detaa[i]);
}
IloNumExprArray detaP_node(env,Node-1),detaPw_node(env,Node-1);
IloNumExprArray Theta(env,Node);
for(IloInt b=0;b<Node-1;++b)
{
detaP_node[b]=IloNumExpr(env);
detaPw_node[b]=IloNumExpr(env);
IloInt i=0;
for(;i<NG;++i)
{
if(Unit[i][0]==b-1)break;
}
if(i<NG)
{
detaP_node[b]+=detaP[i];
}
else
{
detaP_node[b]+=0;
}
if(Sw[b]>=0)
{
detaPw_node[b]+=detaPw[ Sw[b] ];
}
else
{
detaPw_node[b]+=0;
}
}
for(IloInt b=0;b<Node-1;++b)
{
Theta[b]=IloNumExpr(env);
for(IloInt k=0;k<Node-1;++k)
{
Theta[b]+=B0l[b][k]*(detaP_node[k]+detaPw_node[k]);
}
}
Theta[Node-1]=IloNumExpr(env);
for(IloInt h=0;h<Branch;++h)
{
IloNumExpr exprTheta(env);//莫明其妙的错误
exprTheta+=(Theta[(IloInt)Info_Branch[h][0]-1]-Theta[(IloInt)Info_Branch[h][1]-1]);
Master_Model.add(exprTheta<=Info_Branch[h][3]*(Info_Branch[h][4]-PL[h]));
Master_Model.add(exprTheta>=Info_Branch[h][3]*(-Info_Branch[h][4]-PL[h]));
exprTheta.end();
//两个相减的节点顺序没有影响么？
}
Theta.end();
detaP_node.end();
detaPw_node.end();
Master_Cplex.extract(Master_Model);
Master_Cplex.solve();
if (Master_Cplex.getStatus() == IloAlgorithm::Infeasible)//输出结果
{
output<<"Master Problem Have No Solution"<<endl;
goto lable2;
}
/************************************************************输出显示过程**************************************************/
output<<endl<<"Min/Max:"<<Master_Cplex.getObjValue()<<endl;
lable2:
Master_Model.end();
Master_Cplex.end();
env.end();
}
catch(IloException& ex)//异常捕获
{
output<<"Error: "<<ex<<endl;
}
catch(...)
{
output<<"Error: Unknown exception caught!" << endl;
}
finish=clock();
totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
output<<"totaltime: "<<totaltime<<"s"<<endl<<endl;
output.close();
return 0;
}
/**************************************************程序入口****************************************************/
int main()
{
clock_t start,finish;
double totaltime;
start=clock();
try
{
define_data(env);//首先初始化全局变量
/*************************************************************主问题目标函数*******************************************************/
IloNumExpr Cost(env);
for(IloInt i=0;i<NG;++i)//运行成本及其线性化
for(IloInt l=0;l<NL;++l)
for(IloInt t=0;t<NT;++t)
{
Master_Model.add(Deta[i][l][t]<=Z[i][l+1]-Z[i][l]);
}
for(IloInt i=0;i<NG;++i)
for(IloInt t=0;t<NT;++t)
{
IloNumExpr Deta_Sum(env);
for(IloInt l=0;l<NL;++l)
{
Deta_Sum+=Deta[i][l][t];
}
Master_Model.add(P[i][t]==Deta_Sum+Unit[i][1]*I[i][t]);
Deta_Sum.end();
}
for(IloInt i=0;i<NG;++i)
{
for(IloInt t=0;t<NT;++t)
{
IloNumExpr f1(env);
f1+=(Unit[i][10]+Unit[i][9]*Unit[i][1]+Unit[i][8]*Unit[i][1]*Unit[i][1])*I[i][t];
for(IloInt l=0;l<NL;++l)
f1+=Betaa[i][l]*Deta[i][l][t];
Cost+=f1*Unit[i][11];
f1.end();
}
}
for(IloInt i=0; i<NG; ++i)//开机成本
for(IloInt t=1; t<NT; ++t)
{
Cost+=Unit[i][11]*Unit[i][7]*I[i][t]*(1-I[i][t-1]);
}
for(IloInt i=0; i<NG; ++i)//停机成本
for(IloInt t=1; t<NT; ++t)
{
Cost+=Unit[i][11]*Unit[i][7]*I[i][t-1]*(1-I[i][t]);
}
Master_Model.add(IloMinimize(env,Cost));
Cost.end();
/********************************************************机组出力上下限约束**************************************************/
for(IloInt i=0; i<NG; ++i)
for(IloInt t=0; t<NT; ++t)
{
Master_Model.add(P[i][t]<=Unit[i][2]*I[i][t]);
Master_Model.add(P[i][t]>=Unit[i][1]*I[i][t]);
}
/*********************************************************机组爬坡约束******************************************************/
for(IloInt i=0; i<NG; ++i)
for(IloInt t=1; t<NT; ++t)
{
Master_Model.add(P[i][t]-P[i][t-1]<=(1-I[i][t]*(1-I[i][t-1]))*Unit[i][5]+I[i][t]*(1-I[i][t-1])*Unit[i][1]);
Master_Model.add(P[i][t-1]-P[i][t]<=(1-I[i][t-1]*(1-I[i][t]))*Unit[i][6]+I[i][t-1]*(1-I[i][t])*Unit[i][1]);
}
/*********************************************************机组功率平衡约束**************************************************/
for(IloInt t=0; t<NT; ++t)
{
IloNumExpr fire(env);
IloNum wind(0);
for(IloInt i=0; i<NG; ++i)
{
fire+=P[i][t];
}
for(IloInt w=0;w<NW;++w)
{
wind+=Pwind[t][w];
}
Master_Model.add(fire==Pload[t]-wind);
fire.end();
}
/**********************************************************备用约束********************************************************/
for(IloInt t=0; t<NT; ++t)
{
IloNumExpr expr(env);
for(IloInt i=0;i<NG;++i)
{
expr+=Unit[i][2]*I[i][t];
}
Master_Model.add(expr>=Pload[t]+R[t]);
expr.end();
}
/***********************************************************最小开机时间约束*************************************************/
for(IloInt i=0; i<NG; ++i)
{
IloNumExpr expr1(env);
for(IloInt t=0; t<=Unit[i][3]-1; ++t)
{
expr1+=I[i][t];
}
Master_Model.add((expr1-I[i][0]*Unit[i][3])>=0);
expr1.end();
for(IloInt t=1; t<=NT-Unit[i][3]; ++t)
{
IloNumExpr expr2(env);
for(IloInt k=t; k<=t+Unit[i][3]-1; ++k)
{
expr2+=I[i][k];
}
Master_Model.add(expr2>=Unit[i][3]*(I[i][t]-I[i][t-1]));
expr2.end();
}
for(IloInt t=NT-(IloInt)Unit[i][3]+1; t<=NT-1; ++t)
{
IloNumExpr expr2(env);
for(IloInt h=t; h<=NT-1; ++h)
{
expr2+=(I[i][h]-(I[i][t]-I[i][t-1]));
}
Master_Model.add(expr2>=0);
expr2.end();
}
}
/*******************************************************最小停机时间约束**************************************************/
for(IloInt i=0; i<NG; ++i)
{
IloNumExpr expr1(env);
for(IloInt t=0; t<=Unit[i][4]-1; ++t)
{
expr1+=(1-I[i][t]);
}
Master_Model.add((expr1-(1-I[i][0])*Unit[i][4])>=0);
expr1.end();
for(IloInt t=1; t<=NT-Unit[i][4]; ++t)
{
IloNumExpr expr1(env);
for(IloInt k=t; k<=t+Unit[i][4]-1; ++k)
{
expr1+=(1-I[i][k]);
}
Master_Model.add(expr1>=Unit[i][4]*(I[i][t-1]-I[i][t]));
expr1.end();
}
for(IloInt t=NT-(IloInt)Unit[i][4]+1; t<=NT-1; ++t)
{
IloNumExpr expr2(env);
for(IloInt h=t; h<=NT-1; ++h)
{
expr2+=(1-I[i][h]-(I[i][t-1]-I[i][t]));
}
Master_Model.add(expr2>=0);
expr2.end();
}
}
/************************************************************开始整个迭代过程***************************************************************/
IloInvert(B0,B0l,Node-1);//求逆矩阵
IloInt while_interator=0;
IloBool first_cut_is_add;
while(1)
{
first_cut_is_add=IloFalse;
output<<"主问题迭代次数："<<while_interator++<<endl;
Master_Cplex.extract(Master_Model);
Master_Cplex.solve();
if (Master_Cplex.getStatus() == IloAlgorithm::Infeasible)//输出结果
output<<"Master Problem Have No Solution"<<endl;
else
output<<"Master Problem Have Solution, the objective value is: "<<Master_Cplex.getObjValue()<<endl<<endl;
for(IloInt i=0; i<NG; ++i)//保存机组启停状态
{
Master_Cplex.getValues(I[i],u[i]);
Master_Cplex.getValues(P[i],P1[i]);
}
/*****************************************************主问题安全约束********************************************************/
for(IloInt t=0;t<NT;++t)//主问题安全约束的校验
{
output<<"Master Problem Security Constraint Check:"<<t+1<<endl;
IloNumVarArray C1(env,Branch,0,IloInfinity,ILOFLOAT),C2(env,Branch,0,IloInfinity,ILOFLOAT);
IloNumExprArray PL(env,Branch);//各条支路的潮流
IloNumVarArray P_dual(env,Node-1);
IloRangeArray range(env,Node-1);
for(IloInt h=0;h<Branch;++h)
{
C1[h]=IloNumVar(env);
C2[h]=IloNumVar(env);
PL[h]=IloNumVar(env);
}
IloModel Master_Model_Security(env);
IloNumExpr obj(env);//目标函数
for(IloInt h=0;h<Branch;++h)
{
obj+=(C1[h]+C2[h]);
}
Master_Model_Security.add(IloMinimize(env,obj));
obj.end();
IloNumExprArray Psp(env,Node-1);//注入功率
IloExprArray Theta(env,Node);//相角
Theta[Node-1]=IloExpr(env);
for(IloInt k=0; k<Node-1; ++k)//校验了所有结点的潮流
{
P_dual[k]=IloNumVar(env);
Psp[k]=IloNumExpr(env);
IloInt i=0;
for(;i<NG;++i)
{
if(Unit[i][0]-1==k)break;
}
if(i<NG)
range[k]=IloRange::IloRange(env,P1[i][t],P_dual[k],P1[i][t]);
else
range[k]=IloRange::IloRange(env,0,P_dual[k],0);
Master_Model_Security.add(range[k]);
Psp[k] += P_dual[k];
if(Sw[k]>=0)
Psp[k] += Pwind[t][ Sw[k] ];
Psp[k] -= Sl[k]*Pload[t];
}
IloMutiply(B0l,Psp,Theta,Node-1);
//计算潮流
for(IloInt h=0; h<Branch; ++h)
{
PL[h]=IloNumExpr(env);
PL[h]+=(Theta[(IloInt)Info_Branch[h][0]-1]-Theta[(IloInt)Info_Branch[h][1]-1])/Info_Branch[h][3];
Master_Model_Security.add(PL[h]-C1[h]<=Info_Branch[h][4]);
Master_Model_Security.add(-PL[h]-C2[h]<=Info_Branch[h][4]);
}
Psp.end();
Theta.end();
IloCplex Master_Security_Cplex(Master_Model_Security);
Master_Security_Cplex.solve();
if (Master_Security_Cplex.getStatus() == IloAlgorithm::Infeasible)//输出结果
output << "Master_Security_Problem Have No Solution"<<endl;
else
output<<"Master_Security_Problem Have Solution, the objective value is: "<<Master_Security_Cplex.getObjValue()<<endl<<endl;
if(Master_Security_Cplex.getObjValue()>limit)
{
IloNumExpr cut(env);
cut+=Master_Security_Cplex.getObjValue();
for(IloInt i=0;i<NG;++i)
{
if(Unit[i][0]-1>=Node-1)//最后一个结点没算
continue;
else
cut+=Master_Security_Cplex.getDual(range[(IloInt)Unit[i][0]-1])*(P[i][t]-P1[i][t]);//+(I[i][t]-u[i][t]));
//仅仅对功率进行调整
}
Master_Model.add(cut<=0);
cut.end();
first_cut_is_add=IloTrue;
}
C1.end();//清理
C2.end();
PL.end();
P_dual.end();
range.end();
Master_Model_Security.end();
Master_Security_Cplex.end();
}
if(first_cut_is_add==IloTrue)
{
output<<"主问题安全约束越限，返回主问题>>>"<<endl;
continue;//如果有添加割，则重新开始
}
/****************************************************************场景的校验****************************************************************/
IloInt s=0;
IloBool second_cut_is_add=IloFalse;
for(; s<set; ++s)//场景的校验
{
output<<"Num_Senario_Iterator（场景）:"<<s+1<<endl;
IloNumVarArray S1S(env,NT,0,IloInfinity,ILOFLOAT),S2S(env,NT,0,IloInfinity,ILOFLOAT);//第二阶段松弛变量
//S3S(env,NT,0,IloInfinity,ILOFLOAT),S4S(env,NT,0,IloInfinity,ILOFLOAT);
IloArray<IloNumVarArray> S5S(env,NG);
for(IloInt i=0; i<NG; ++i)
S5S[i]=IloNumVarArray(env,NT,0.0,IloInfinity,ILOFLOAT);
second_cut_is_add=IloFalse;
IloModel Sub_Model(env,"Sub_Model");
/********************************子问题目标函数**************************************/
IloNumExpr VS(env);
for(IloInt t=0; t<NT; ++t)
{
VS+=(S1S[t]+S2S[t]);
for(IloInt i=0; i<NG; ++i)
VS+=S5S[i][t];
}
Sub_Model.add(IloMinimize(env,VS));
VS.end();
/*****************************子问题系统平衡约束*********************************/
for(IloInt t=0; t<NT; ++t)
{
IloNumExpr expr1(env);
for(IloInt i=0; i<NG; ++i)
expr1+=PS[i][t];
expr1+=S1S[t]-S2S[t];
IloNum wind(0);
for(IloInt w=0;w<NW;++w)
wind+=Pswind[s][t][w];
Sub_Model.add(expr1==Pload[t]-wind);
expr1.end();
}
/***************************子问题建议行为约束*************************************/
IloArray<IloRangeArray> ramp1(env,NG),ramp2(env,NG);
for(IloInt i=0; i<NG; ++i)//绝对值转化为两个约束
{
ramp1[i]=IloRangeArray(env,NT);
ramp2[i]=IloRangeArray(env,NT);
for(IloInt t=0; t<NT; ++t)
{
ramp1[i][t]=IloRange::IloRange(env,-IloInfinity,PS[i][t]-S5S[i][t],detaa+P1[i][t],"ramp1");
ramp2[i][t]=IloRange::IloRange(env,-IloInfinity,-PS[i][t]-S5S[i][t],detaa-P1[i][t],"ramp2");
Sub_Model.add(ramp1[i][t]);
Sub_Model.add(ramp2[i][t]);
}
}
/**************************子问题机组出力上下限约束*******************************/
IloArray<IloRangeArray> range_limit1(env,NG),range_limit2(env,NG);
for(IloInt i=0; i<NG; ++i)
{
range_limit1[i]=IloRangeArray(env,NT);
range_limit2[i]=IloRangeArray(env,NT);
for(IloInt t=0; t<NT; ++t)
{
range_limit1[i][t]=IloRange::IloRange(env,-IloInfinity,PS[i][t],Unit[i][2]*u[i][t],"power_limits1");
range_limit2[i][t]=IloRange::IloRange(env,-IloInfinity,-PS[i][t],-Unit[i][1]*u[i][t],"power_limits2");
Sub_Model.add(range_limit1[i][t]);
Sub_Model.add(range_limit2[i][t]);
}
}
/*************************************添加割************************************/
IloCplex Sub_Cplex(Sub_Model);
label1:
Sub_Cplex.extract(Sub_Model);
Sub_Cplex.solve();
IloNum objvalue(Sub_Cplex.getObjValue());
if(Sub_Cplex.getStatus() == IloAlgorithm::Infeasible)//输出结果
{
output<< "Senario_Sub_Problem No Solution" << endl;
output << "场景 "<< s+1 <<" 无解,跳出循环，主问题无解……"<<endl;
}
else
output<<"Senario_Sub_Problem Have Solution, and objective is: "<<objvalue<<endl<<endl;
if(objvalue>limit)//返回主问题
{
IloNumExpr expr(env);
expr+=objvalue;
for(IloInt i=0;i<NG;++i)
for(IloInt t=0;t<NT;++t)
{
expr+=/*0.1**/(Sub_Cplex.getDual(range_limit1[i][t])*Unit[i][2]-Sub_Cplex.getDual(range_limit2[i][t])*Unit[i][1])
*(I[i][t]-u[i][t]);//+/*0.1**//*(Sub_Cplex.getDual(ramp1[i][t])-Sub_Cplex.getDual(ramp2[i][t]))*(P[i][t]-P1[i][t]);*/
}
Master_Model.add(expr<=0);
range_limit1.end();
range_limit2.end();
ramp1.end();
ramp2.end();
expr.end();
output<<"场景校验子问题不满足，返回主问题>>>"<<endl;
break;//跳出场景校验子问题
}
else//否则开始安全校验
{
IloNumArray2 PS1(env,NG);//提取相应场景下的出力
for(IloInt i=0;i<NG;++i)
{
PS1[i]=IloNumArray(env,NT);
Sub_Cplex.getValues(PS[i],PS1[i]);
}
for(IloInt t=0;t<NT;++t)//对所有时段进行安全校核
{
output<<"Sub Problem Security Constraint Check:"<<t+1<<endl;
IloNumVarArray C1(env,Branch,0,IloInfinity,ILOFLOAT),C2(env,Branch,0,IloInfinity,ILOFLOAT);
IloNumExprArray PL(env,Branch);
IloNumVarArray P_dual(env,Node-1);
IloRangeArray range(env,Node-1);
for(IloInt l=0;l<Branch;++l)
{
C1[l]=IloNumVar(env);
C2[l]=IloNumVar(env);
PL[l]=IloNumExpr(env);
}
IloModel SubModel_Security(env);//只是局部变量
IloNumExpr obj(env);//目标函数
for(IloInt l=0;l<Branch;++l)
obj+=C1[l]+C2[l];
SubModel_Security.add(IloMinimize(env,obj));
obj.end();
IloNumExprArray Psp(env,Node-1);//注入功率
IloExprArray Theta(env,Node);//相角
Theta[Node-1]=IloExpr(env);
for(IloInt k=0; k<Node-1; ++k)//求Psp
{
P_dual[k]=IloNumVar(env);
Psp[k]=IloNumExpr(env);
IloInt i=0;
for(;i<NG;++i)
{
if(Unit[i][0]-1==k)break;
}
if(i<NG)
range[k]=IloRange::IloRange(env,PS1[i][t],P_dual[k],PS1[i][t]);
else
range[k]=IloRange::IloRange(env,0,P_dual[k],0);
SubModel_Security.add(range[k]);
Psp[k] += P_dual[k];
if(Sw[k]>=0)
Psp[k] += Pswind[s][t][ Sw[k] ];
Psp[k] -= Sl[k]*Pload[t];
}
IloMutiply(B0l,Psp,Theta,Node-1);
//计算潮流
for(IloInt h=0; h<Branch; ++h)
{
PL[h]=IloNumExpr(env);
PL[h]+=(Theta[(IloInt)Info_Branch[h][0]-1]-Theta[(IloInt)Info_Branch[h][1]-1])/Info_Branch[h][3];
SubModel_Security.add(PL[h]-C1[h]<=Info_Branch[h][4]);
SubModel_Security.add(-PL[h]-C2[h]<=Info_Branch[h][4]);
}
IloCplex Senario_Security_Cplex(SubModel_Security);
Senario_Security_Cplex.solve();
IloNum security_objvalue(Senario_Security_Cplex.getObjValue());
Psp.end();
Theta.end();
PL.end();
if (Senario_Security_Cplex.getStatus() == IloAlgorithm::Infeasible)//输出结果
output<<"Senario_Security_Problem one No Solution" << endl;
else
output<<"Senario_Security_Problem Have Solution, and objective is: "<<security_objvalue<<endl<<endl;
if(security_objvalue>limit)
{
IloNumExpr cut(env);
cut+=security_objvalue;
for(IloInt i=0;i<NG;++i)
{
if(Unit[i][0]-1>=Node-1)
continue;
else
cut+=Senario_Security_Cplex.getDual(range[(IloInt)Unit[i][0]-1])*(PS[i][t]-PS1[i][t]);//安全约束割
}
Sub_Model.add(cut<=0);
cut.end();
second_cut_is_add=IloTrue;
}
C1.end();
C2.end();
PL.end();
P_dual.end();
range.end();
SubModel_Security.end();
Senario_Security_Cplex.end();
}
if(second_cut_is_add==IloTrue)//返回当前场景校验
{
output<<"goto label1，场景校验子问题安全约束越限，返回当前子问题>>>"<<endl;
second_cut_is_add=IloFalse;
goto label1;
}
PS1.end();
}
Sub_Model.end();
Sub_Cplex.end();
}
if(s==set)break;
}
/************************************************************输出显示过程**************************************************/
output<<"Cost:"<<Master_Cplex.getObjValue()<<endl;
for(IloInt i=0; i<NG; ++i)
{
for(IloInt t=0; t<NT; ++t)
{
output<<"机组 "<<i+1<<" 第 "<<t+1<<" 时段状态:"<<Master_Cplex.getValue(I[i][t])<<" 出力:";
output<<Master_Cplex.getValue(P[i][t])<<endl;
}
output<<endl;
}
Master_Model.end();
Master_Cplex.end();
env.end();
}
catch(IloException& ex)//异常捕获
{
output<<"Error: "<<ex<<endl;
}
catch(...)
{
output<<"Error: Unknown exception caught!" << endl;
}
finish=clock();
totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
output<<"totaltime: "<<totaltime<<"s"<<endl<<endl;
output.close();
return 0;
}
/** Create a new worker.
* The constructor mainly does the following:
* - create an IloCplex instance that refers to a remote worker,
* - load the model in <code>modelfile</code>,
* - setup parameters depending on this worker's index,
* - start an asynchronous solve.
* If anything fails then an exception will be thrown.
* @param env The environment used for instantiating Ilo* objects.
* @param i The index of the worker to be created. This also
* determines the parameter settings to use in this worker.
* @param s A pointer to the global solve state.
* @param transport The transport name for the IloCplex constructor.
* @param argc The argument count for the IloCplex constructor.
* @param argv The array of transport arguments for the IloCplex
* constructor.
* @param modelfile Name of the model to be loaded into the worker.
* @param output The output mode.
* @param objdiff The minimal difference between so that two
* consecutive objective function values are considered
* different.
*/
Worker(IloEnv env, int i, SolveState *s, char const *transport,
int argc, char const **argv, char const *modelfile,
OUTPUT output, double objdiff)
: idx(i), state(s), model(env), cplex(0), handle(0),
primal(IloInfinity), dual(-IloInfinity),
obj(env), x(env), rng(env), infoHandler(this), outb(idx), outs(&outb)
{
try {
// Create remote object, setup output and load the model.
cplex = IloCplex(model, transport, argc, argv);
switch (output) {
case OUTPUT_SILENT:
// Disable output on the output and warning stream.
cplex.setOut(env.getNullStream());
cplex.setWarning(env.getNullStream());
break;
case OUTPUT_PREFIXED:
// Redirect output to our custom stream.
cplex.setOut(outs);
cplex.setWarning(outs);
break;
case OUTPUT_LOG:
// Nothing to do here. By default output is enabled.
break;
}
cplex.importModel(model, modelfile, obj, x, rng);
if ( obj.getSense() == IloObjective::Minimize ) {
primal = -IloInfinity;
dual = IloInfinity;
}
// We set the thread count for each solver to 1 so that we do not
// run into problems if multiple solves are performed on the same
// machine.
cplex.setParam(IloCplex::Param::Threads, 1);
// Each worker runs with a different random seed. This way we
// get different paths through the tree even if the other
// parameter settings are the same.
cplex.setParam(IloCplex::Param::RandomSeed, idx);
// Apply parameter settings.
for (class ParamValue const *vals = settings[idx % NUMSETTINGS].values;
vals->isValid(); ++vals)
vals->apply(cplex);
// Install callback and set objective change.
int status = cplex.userfunction (USERACTION_ADDCALLBACK,
0, NULL, 0, 0, NULL);
if ( status )
throw status;
IloCplex::Serializer s;
s.add(objdiff);
status = cplex.userfunction (USERACTION_CHANGEOBJDIFF,
s.getRawLength(), s.getRawData(),
0, 0, NULL);
if ( status )
throw status;
// Register the handler that will process info messages sent
// from the worker.
cplex.setRemoteInfoHandler(&infoHandler);
// Everything is setup. Launch the asynchronous solve.
handle = cplex.solve(true);
} catch (...) {
// In case of an exception we need to take some special
// cleanup actions. Note that if we get here then the
// solve cannot have been started and we don't need to
// kill or join the asynchronous solve.
if ( cplex.getImpl() )
cplex.end();
rng.end();
x.end();
obj.end();
model.end();
throw;
}
}
/**************************************************程序入口****************************************************/
int main()
{
clock_t start,finish;
double totaltime;
start=clock();
time_t nowTime=time(0);
struct tm* nowTimeStruct=localtime(&nowTime);//打印系统时间
// output<<"系统当前时间："<<1900+nowTimeStruct->tm_year<<"."<<nowTimeStruct->tm_mon+1<<"."<<
// nowTimeStruct->tm_mday<<" "<<nowTimeStruct->tm_hour<<":"<<nowTimeStruct->tm_min<<":"<<nowTimeStruct->tm_sec<<endl;
try
{
// output<<">>>>>>>>>>>>>>>>>>>>>>>>>数据区<<<<<<<<<<<<<<<<<<<<"<<endl;
define_data(env);//首先初始化全局变量
// output<<">>>>>>>>>>>>>>>>>>>>>>>>>/数据区<<<<<<<<<<<<<<<<<<<"<<endl<<endl;
IloInvert(env,B0,B0l,Node-1);//求逆矩阵
//在此创建两种形式的目标函数
IloNumExpr Cost(env);//目标函数
for(IloInt w=0;w<NW;++w)
{
Cost+=detaPw[w];
}
IloObjective min(env,Cost,IloObjective::Sense::Minimize,"min");
IloObjective max(env,Cost,IloObjective::Sense::Maximize,"max");
Master_Model.add(min);
// Master_Model.add(IloMaximize(env,Cost));//目标函数二选一
Cost.end();
IloNumExpr expr1(env),expr2(env);//功率平衡约束
for(IloInt i=0;i<NG;++i)
{
expr1+=detaP[i];
}
for(IloInt w=0;w<NW;++w)
{
expr2+=detaPw[w];
}
Master_Model.add(expr1+expr2==0);
expr1.end();
expr2.end();
for(IloInt i=0;i<NG;++i)//机组可调节范围
{
Master_Model.add(detaP[i]>=Unit[i][1]*u[i]-P1[i]);
Master_Model.add(detaP[i]<=Unit[i][2]*u[i]-P1[i]);
Master_Model.add(detaP[i]>=-detaa[i]);
Master_Model.add(detaP[i]<=detaa[i]);
}
IloNumExprArray detaP_node(env,Node-1),detaPw_node(env,Node-1);//安全约束，实际上安全约束影响不大
IloNumExprArray Theta(env,Node);
for(IloInt b=0;b<Node-1;++b)
{
detaP_node[b]=IloNumExpr(env);
detaPw_node[b]=IloNumExpr(env);
IloInt i=0;
for(;i<NG;++i)
{
if(Unit[i][0]==b-1)break;
}
if(i<NG)
{
detaP_node[b]+=detaP[i];
}
if(Sw[b]>=0)
{
detaPw_node[b]+=detaPw[ Sw[b] ];
}
}
for(IloInt b=0;b<Node-1;++b)
{
Theta[b]=IloNumExpr(env);
for(IloInt k=0;k<Node-1;++k)
{
Theta[b]+=B0l[b][k]*(detaP_node[k]+detaPw_node[k]);
}
}
Theta[Node-1]=IloNumExpr(env);
for(IloInt h=0;h<Branch;++h)
{
IloNumExpr exprTheta(env);//莫明其妙的错误
exprTheta+=(Theta[(IloInt)Info_Branch[h][0]-1]-Theta[(IloInt)Info_Branch[h][1]-1]);
Master_Model.add(exprTheta<=Info_Branch[h][3]*(Info_Branch[h][4]-PL[h]));
Master_Model.add(exprTheta>=Info_Branch[h][3]*(-Info_Branch[h][4]-PL[h]));
exprTheta.end();
//两个相减的节点顺序没有影响么？
}
Theta.end();
detaP_node.end();
detaPw_node.end();
Master_Cplex.extract(Master_Model);
Master_Cplex.solve();
if (Master_Cplex.getStatus() == IloAlgorithm::Infeasible)//输出结果
{
output<<"Master Problem Have No Solution"<<endl;
goto lable2;
}
/************************************************************输出显示过程**************************************************/
// output/*<<endl<<"Min:"*/<<Master_Cplex.getObjValue()<<endl;
Master_Model.remove(min);
Master_Model.add(max);
Master_Cplex.extract(Master_Model);
Master_Cplex.solve();
if (Master_Cplex.getStatus() == IloAlgorithm::Infeasible)//输出结果
{
output<<"Master Problem Have No Solution"<<endl;
goto lable2;
}
output/*<<endl<<"Max:"*/<<Master_Cplex.getObjValue()<<endl<<endl;;
// output<<endl<<"常规机组出力调整量:"<<endl;
// for(IloInt i=0;i<NG;++i)
// {
// output<<Master_Cplex.getValue(detaP[i])<<" ";
// }
// output<<endl<<"风电机组出力调整量:"<<endl;
// for(IloInt i=0;i<NW;++i)
// {
// output<<Master_Cplex.getValue(detaPw[i])<<" ";
// }
// output<<endl;
lable2:
Master_Model.end();
Master_Cplex.end();
env.end();
}
catch(IloException& ex)//异常捕获
{
output<<"Error: "<<ex<<endl;
}
catch(...)
{
output<<"Error: Unknown exception caught!" << endl;
}
finish=clock();
totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
output<<"totaltime: "<<totaltime<<"s"<<endl<<endl;
output.close();
return 0;
}
