Project LSO Draft Code for Single Allocation Hub and Spoke Network Design

PROJECT LSO DRAFT
// This is the code for Single Allocation Hub and Spoke Network Design for the model
described in:
// Pirkul, H., Schilling, D.A. 1998. An efficient procedure for designing single
allocation hub
// and spoke systems. Management Science, 44(1), 235-242.
#include<stdio.h>
#include<conio.h>
#include<iostream>
#include<fstream>
#include<iosfwd>
#include<string>
#include <deque>
#include <sstream>
#include <time.h>
#include <stdlib.h>
#include <ilcplex/ilocplex.h>
#include <ilconcert/ilosys.h>
ILOSTLBEGIN
typedef IloArray<IloNumArray> TwoDMatrix;

typedef IloArray<TwoDMatrix> ThreeDMatrix;
//typedef IloArray<ThreeDMatrix> FourDMatrix;
int main(int argc, char **argv)

{
IloEnv env;
int N;//N=no. of nodes
//IloNum c_collect=1, c_distribute=1, c_tranship=0.90;//per unit costs of
shipping
ThreeDMatrix cost(env);//flow data between pairs of nodes

TwoDMatrix haultime(env); //haul time from one node to another
TwoDMatrix dist(env);//distance data between pairs of nodes
IloNumArray TC(env);
int T;
try
{
///////// DATA FILE READING //////////
const char* data_filename = "Data_HS_CAB_10node.dat";

if (argc > 1)
{
data_filename = argv[1];
}
fstream datafile;
datafile.open(data_filename,ios::in);
if (!datafile)
{
cerr << "ERROR: could not open file " << data_filename << " for
reading" << endl;
cerr << "usage: " << argv[0] << " <datafile>" << endl;
throw(-1);
}
datafile >> cost >> haultime >> dist >> TC;
N = 20;
cout<<"Number of nodes = "<<N<<endl;
cout<<"Fleet size = "<<T<<endl;
T=6; //number of trucks (fleet size)
/*IloBool consistentData = (lambda.getSize() == dist.getSize());

if (!consistentData)
{
cerr << "ERROR: data file '" << data_filename << "' contains
inconsistent data" << endl;
throw(-1);
}*/
datafile.close();
ofstream fout;
fout.open("Final Project.txt");
fout<<"Number of nodes = "<<N<<endl;

fout<<"Fleet size = "<<T<<endl;
//=================Declare Variables===============================
typedef IloArray<IloBoolVarArray> array2d;//Creating a 2d array of x
variables
typedef IloArray<array2d> array3d;//Creating a 3d array of x variables
array3d x(env, N);//xijkm
IloNumVarArray lambda(env, T);

IloNumArray lambdav(env, T, 0, IloInfinity, ILOFLOAT);
typedef IloArray<IloBoolArray> arr2d;//Creating a 2d array of x

variables
typedef IloArray<array2d> arr3d;//Creating a 3d array of x variables
typedef IloArray<array3d> arr4d;
arr3d xv(env, N);
for (int i=0; i<N; i++)

{
x[i]= array2d(env, N);
xv[i]= arr2d(env, N);
for (int j=0;j<N;j++)

{
x[i][j]=IloBoolArray(env, N);
xv[i][j]=IloBoolVarArray(env, N);
}
}
//IloNumVar M(env, 0,IloInfinity, ILOFLOAT);

IloModel modelP(env);
IloModel modelPR(env);
IloModel modelPL(env);
IloModel modelPF(env);
IloModel GBPP(env);
IloCplex cplexP(modelP);
IloCplex cplexPR(modelPR);
IloCplex cplexPL(modelPL);
IloCplex cplexPF(modelPF);
IloCplex CGBPP(GBPP);
//=======================================================================

{
x[j]=array2d(env, N);
xv[j]=arr2d(env, N);
for (int k=0;k<N;k++)
{
x[j][k]=IloBoolVarArray(env, N);
xv[j][k]=IloBoolArray(env, N);
}
}
IloNum UB = IloInfinity; IloNum LB = 0; int q=1;
//Declarations
made=================================================================================
//IloModel model(env);
cout<<"-1"<<endl;
IloExpr ObjP(env); // Creates an expression with the name Obj

(Objective)
for (int i=0;i<N;i++)

{
{
{
ObjP+=cost[i][j][k]*x[i][j][k];
}
}
}
modelP.add(IloMinimize(env, ObjP));
cplexP.solve();
//Constraint 1: pickups
for(int j=N/2;j<N; j++)
{
IloExpr SumP(env);
for(int i=0;i<N/2;i++)
{
for(int k=0;k<T;k++)
{
SumP+ = x[i][j][k];
}
}
modelP.add(SumP==1);
SumP.end();
}
cout<<"-0.5"<<endl;
//Constraint 2: deliveries
{
IloExpr SumP(env);
{
{
SumP+ = x[i][j][k];
}
}
SumP.end();
}
cout<<"1"<<endl;
//Constraint 3: time capacity
{
IloExpr SumL(env);
for(int i=0; i<N/2; i++)
{
for(int j=N/2; j<N; j++)
{
SumL+= haultime[i][j][k]*x[i][j][k];
}
}
modelP.add(SumL<=TC[k]);
SumL.end();
}
cout<<"1.5"<<endl;
//==================================================================================JU
NK==============================================================
//PR
IloExpr ObjPR (env);
for(int k=0; k<T; k++)
{
IloExpr SumT(env);
{
{
SumT+= haultime[i][j][k]*x[i][j][k];
}
}
ObjPR+=lambda[k]*(SumT-TC[k]);
}
{
{
{
ObjPR+=cost[i][j][k]*x[i][j][k];
}
}
}
modelPR.add(IloMinimize(env, ObjPR));
cplexPR.solve();
//====================================================================================
DONE TILL HERE=========================================
//PL
for(int i=0;i<N;i++)
{
for(int j=0;j<N;j++)
{
{
IloExpr SumX(env);
for(int m=0;m<N;m++)
{
SumX+=x[i][j][k][m];
}
//model.add(SumX==z[i][k]);
Obj2=Obj2+(z[i][k]-SumX)*betav[i][j][k];
SumX.end();
}
}
}
cout<<"2"<<endl;
//Constraint 5: for {i in 1..N}{j in 1..N}{m in 1..N}:sum {k in

1..N}(x[i][j][k][m])=z[j][m];
{
{
for (int m=0;m<N;m++)
{
IloExpr SumX(env);
for(int k=0;k<N;k++)
{
}
Obj2=Obj2+(z[j][m]-SumX)*gammav[i][j][m];
//model.add(SumX==z[j][m]);
SumX.end();
}
}
}
//the extra constraint added for feasibility

{
{
IloExpr sumkm(env);
for(int k=0; k<N; k++)
{
for(int m=0; m<N; m++)
{
sumkm= sumkm+x[i][j][k][m];
}
}
model2.add(sumkm==1);
sumkm.end();
}
}
IloModel model3(env);
IloExpr TotObj(env);
TotObj=Obj1+Obj2;
//====================================================================================
=============================================
//PF
IloExpr ObjPF(env);
{
for(int p=0;p<N;p++)
{
ObjPF=ObjPF+(z[i][k]-SumX)*betav[i][j][k];
}
}
cout<<"2"<<endl;

1..N}(x[i][j][k][m])=z[j][m];
{
{
{
IloExpr SumX(env);
{
}
SumX.end();
}
}
}

{
{
IloExpr sumkm(env);
{
{
}
}
sumkm.end();
}
}
TotObj=Obj1+Obj2;
//====================================================================================
===============================================
cout<<"2.5"<<endl;
model1.add(IloMinimize(env, Obj1));
cplex1.solve();
cplex2.solve();
//float v= cplex.getObjValue();
{
for (int
j=0;j<N;j++)
{z_val[i][j] = cplex1.getValue(z[i][j]);
for
(int k=0;k<N;k++)
{
x_val[i][j][k][m]=cplex2.getValue(x[i][j][k][m]);
cout<<x_val[i][j][k][m];
}
}
}
}
//IloCplex cplex(model);
//IloCplex cplex1(Model1);
//dont be fooled this part can be done away with
float d=1;
float Z=
//while loop
while(q<50)
{
cout<<"UB"<<UB<<endl;
cout<<"LB"<<LB<<endl;
tk=d*(Z-cplex1.getValue()-
q++;
}//ends here
//=============================================================================
=
cout<<"Last"<<LB<<endl;
//c=cplex1.getValue(MObj);
{
{
alphav[i]=cplex1.getValue(alpha[i]);
{
betav[i][j][k]=cplex1.getValue(beta[i][j][k]);
gammav[i][j][k]=cplex1.getValue(gamma[i][j][k]);
}
}
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++
model1.end();
model2.end();
//solving the MODEL
if(LB<Zlr)
{
LB=Zlr;
}
if(UB>Z)
{
UB=Z;
}
cout << "Minimum Cost = " << Z << endl;
fout << "Minimum Cost = " << Z << endl;
}// while ends here
// Print results
fout<<"Nodes \t Hubs: "<<endl;

{
{
if (cplex.getValue(z[i][k]) > 1-eps)
{
fout<<i+1<<"\t"<<k+1<<endl;
cout<<i+1<<"\t"<<k+1<<endl;
z_val[i][k] = 1;
}
else
{
z_val[i][k] = 0;
}
}
}
cout<<"i j k m x[i][j][k][m]" << endl;

fout<<"i j k m x[i][j][k][m]" << endl;
{
{
{
{
if (cplex.getValue(x[i][j][k][m]) > 1-eps)
{
x_val[i][j][k][m] = 1;
cout<<i+1<<" "<<j+1<<" "<<k+1<<"
"<<m+1<<" "<<cplex.getValue(x[i][j][k][m])<<endl;
fout<<i+1<<" "<<j+1<<" "<<k+1<<"
}
else
{
x_val[i][j][k][m] = 0;
}
}
}
}
}
//model.end();
env.end();
}//end of of try block

catch (IloException& ex)
{
cerr << "Error: " << ex << endl;
}
catch (...)
{
cerr << "Error" << endl;
}
return 0;
}
A SECOND VERSION
// This is the code for Single Allocation Hub and Spoke Network Design for the model
described in:
// Pirkul, H., Schilling, D.A. 1998. An efficient procedure for designing single
allocation hub
// and spoke systems. Management Science, 44(1), 235-242.
#include<stdio.h>
#include<conio.h>
#include<iostream>
#include<fstream>
#include<iosfwd>
#include<string>
#include <deque>
#include <sstream>
#include <time.h>
#include <stdlib.h>
#include <ilcplex/ilocplex.h>
#include <ilconcert/ilosys.h>
ILOSTLBEGIN
typedef IloArray<IloNumArray> TwoDMatrix;

typedef IloArray<TwoDMatrix> ThreeDMatrix;
//typedef IloArray<ThreeDMatrix> FourDMatrix;
int main(int argc, char **argv)

{
IloEnv env;
int N;//N=no. of nodes
TwoDMatrix haultime(env); //haul time from one node to another

TwoDMatrix dist(env);//distance data between pairs of nodes
int T;
try
{
///////// DATA FILE READING //////////
const char* data_filename = "Project LSO Data.dat";

if (argc > 1)
{
data_filename = argv[1];
}
fstream datafile;
datafile.open(data_filename,ios::in);
if (!datafile)
{
cerr << "ERROR: could not open file " << data_filename << " for
reading" << endl;
cerr << "usage: " << argv[0] << " <datafile>" << endl;
throw(-1);
}
datafile >> dist >> haultime;
N = 20;
cout<<"Number of nodes = "<<N<<endl;
cout<<"Fleet size = "<<T<<endl;
IloNumArray TC(env,100); //in case infinite values
datafile.close();
ofstream fout;
fout.open("Final Project.txt");

fout<<"Fleet size = "<<T<<endl;
T=100; //number of trucks (fleet size)
//=================Declare Variables===============================
typedef IloArray<IloBoolVarArray> array2d;//Creating a 2d array of x
variables
array3d x(env, N);//xijkm
IloNumVarArray lambda(env, T);

IloNumArray lv(env, T, 0, IloInfinity, ILOFLOAT);
for(int k=0; k<T;k++)
{
lv(k)=0;
}
typedef IloArray<IloBoolArray> arr2d;//Creating a 2d array of x

variables
typedef IloArray<array2d> arr3d;//Creating a 3d array of x variables
typedef IloArray<array3d> arr4d;
arr3d xv(env, N);

{
x[i]= array2d(env, N);
xv[i]= arr2d(env, N);

{
x[i][j]=IloBoolArray(env, N);
xv[i][j]=IloBoolVarArray(env, N);
}
}
IloModel modelP(env);
IloModel modelPL(env);
IloModel modelPF(env);
IloModel GBPP(env);
IloCplex cplexP(modelP);
IloCplex cplexPL(modelPL);
IloCplex cplexPF(modelPF);
IloCplex CGBPP(GBPP);
//=======================================================================
{
x[j]=array2d(env, N);
xv[j]=arr2d(env, N);
{
x[j][k]=IloBoolVarArray(env, N);
xv[j][k]=IloBoolArray(env, N);
}
}
IloNumArray cf(env,100, 3,5,ILOINT);

for(int i=1; i<=6; i++)
{
cf(i)=3;
}
for(int i=7; i<9;i++)
{
cf(i)=4;
}
for(int i=9; i<100;i++)
{
cf(i)=5;
}
//Declarations
made=================================================================================
IloExpr ObjP(env); // Creates an expression with the name Obj

(Objective)
for (int k=0;k<3;k++)

{
{
{
ObjP+=dist[i][j]*x[i][j][k]*cf[k];
}
}
}
modelP.add(IloMinimize(env, ObjP));
//cplexP.solve();
//Constraint 1: pickups
{
IloExpr SumP(env);
{
{
SumP+ = x[i][j][k];
}
}
SumP.end();
}
//Constraint 2: deliveries
{
IloExpr SumP(env);
{
{
SumP+ = x[i][j][k];
}
}
SumP.end();
}
//Constraint 3: time capacity
{
IloExpr SumL(env);
{
{
SumL+= haultime[i][j]*x[i][j][k];
}
}
SumL.end();
}//=====================================
cplexP.solve();
//cout<<"1.5"<<endl;
//==================================================================================JU
NK==============================================================
//PL
Array2d y(env,N);
arr2d yv(env, N);
for (int i=0,; i<N; i)
{
y[i]=IloBoolVarArray(env,N);
yv[i]=IloBoolArray(env,N);
}
IloExpr ObjPL (env);

for(int k=0; k<T; k++)
{
IloExpr SumT(env);
IloExpr SumU(env);
{
{
SumT+= haultime[i][j]*y[i][j];
SumU+=dist[i][j]*cf[k]*y[i][j];
}
}
ObjPL+=SumU+ lambda[k]*(SumT-TC[k]);
SumU.end();
SumT.end();
}
/*for (int i=0;i<N;i++)

{
{
{
ObjPL+=dist[i][j]*cf[k]*x[i][j][k];
}
}
}*/
modelPL.add(IloMinimize(env, ObjPL));
//Constraint 1
{
IloExpr SumL(env);
{
{
SumL+= haultime[i][j]*x[i][j][k];
}
}
SumL.end();
}
cplexPL.solve();
//====================================================================================
======
//PF
{
{
{
IloExpr SumX(env);
for(int m=0;m<N;m++)
{
}
//model.add(SumX==z[i][k]);
Obj2=Obj2+(z[i][k]-SumX)*betav[i][j][k];
SumX.end();
}
}
}
cout<<"2"<<endl;

1..N}(x[i][j][k][m])=z[j][m];
{
{
{
IloExpr SumX(env);
{
}
SumX.end();
}
}
}

{
{
IloExpr sumkm(env);
{
{
}
}
sumkm.end();
}
}
TotObj=Obj1+Obj2;
//====================================================================================
=============================================
//GBPP
IloBoolVarArray a(env,T);
IloBoolArray av(env,T);
array2d z(env,T);
arr2d zv(env,T);
for(int i=0; i<N; i++)

{
z[i]=IloBoolVarArray(env,T);
zv[i]=IloBoolArray(env,T);
}
IloExpr ObjGBPP(env);
{
ObjGBPP=ObjGBPP+ cf[k]*TC[k]*a[k];
}
GBPP.add(IloMinimize(env, ObjGBPP));

1..N}(x[i][j][k][m])=z[j][m];
{
IloExpr SumX(env);
for (int p=0;p<N/2;p++) //p denotes D-P pair
{
SumX+= z[k][p];
}
GBPP.add(SumX==1);
SumX.end();
}
IloNumArray hault(env,N/2);
//Constraint 2: Time capacity
for (int k=0; k<T; k++)
{
IloExpr SumH(env);
for( int p=0;p<N/2;p++)
{
SumH+= hault[p]*z[k][p];
}
GBPP.add(SumH<=TC[k]*y[k]);
SumH.end();
}
//============================================done till here=======PL still

left================================================================================
cout<<"2.5"<<endl;
cplex1.solve();
cplex2.solve();
//float v= cplex.getObjValue();
{
for (int
j=0;j<N;j++)
{z_val[i][j] = cplex1.getValue(z[i][j]);
for
(int k=0;k<N;k++)
{
x_val[i][j][k][m]=cplex2.getValue(x[i][j][k][m]);
cout<<x_val[i][j][k][m];
}
}
}
}
//IloCplex cplex(model);
//IloCplex cplex1(Model1);
//dont be fooled this part can be done away with
float d=1;
float Z=
//while loop
while(q<50)
{
cout<<"UB"<<UB<<endl;
cout<<"LB"<<LB<<endl;
tk=d*(Z-cplex1.getValue()-
q++;
}//ends here
//=============================================================================
=
cout<<"Last"<<LB<<endl;
//c=cplex1.getValue(MObj);
{
{
alphav[i]=cplex1.getValue(alpha[i]);
{
betav[i][j][k]=cplex1.getValue(beta[i][j][k]);
gammav[i][j][k]=cplex1.getValue(gamma[i][j][k]);
}
}
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++
model1.end();
model2.end();
//solving the MODEL

if(LB<Zlr)
{
LB=Zlr;
}
if(UB>Z)
{
UB=Z;
}
cout << "Minimum Cost = " << Z << endl;
fout << "Minimum Cost = " << Z << endl;
}// while ends here
// Print results
fout<<"Nodes \t Hubs: "<<endl;

{
{
if (cplex.getValue(z[i][k]) > 1-eps)
{
fout<<i+1<<"\t"<<k+1<<endl;
cout<<i+1<<"\t"<<k+1<<endl;
z_val[i][k] = 1;
}
else
{
z_val[i][k] = 0;
}
}
}
cout<<"i j k m x[i][j][k][m]" << endl;

fout<<"i j k m x[i][j][k][m]" << endl;
{
{
{
{
if (cplex.getValue(x[i][j][k][m]) > 1-eps)
{
x_val[i][j][k][m] = 1;
cout<<i+1<<" "<<j+1<<" "<<k+1<<"
fout<<i+1<<" "<<j+1<<" "<<k+1<<"
}
else
{
x_val[i][j][k][m] = 0;
}
}
}
}
}
//model.end();
env.end();
}//end of of try block

catch (IloException& ex)
{
cerr << "Error: " << ex << endl;
}
catch (...)
{
cerr << "Error" << endl;
}
return 0;
}

Project LSO Draft Code for Single Allocation Hub and Spoke Network Design

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Project LSO Draft Code for Single Allocation Hub and Spoke Network Design

Uploaded by

Copyright:

Available Formats

PROJECT LSO DRAFT

typedef IloArray<IloNumArray> TwoDMatrix;

int main(int argc, char **argv)

ThreeDMatrix cost(env);//flow data between pairs of nodes

const char* data_filename = "Data_HS_CAB_10node.dat";

/*IloBool consistentData = (lambda.getSize() == dist.getSize());

fout<<"Number of nodes = "<<N<<endl;

IloNumVarArray lambda(env, T);

typedef IloArray<IloBoolArray> arr2d;//Creating a 2d array of x

for (int i=0; i<N; i++)

for (int j=0;j<N;j++)

//IloNumVar M(env, 0,IloInfinity, ILOFLOAT);

for (int j=0;j<N;j++)

IloNum UB = IloInfinity; IloNum LB = 0; int q=1;

IloExpr ObjP(env); // Creates an expression with the name Obj

for (int i=0;i<N;i++)

//Constraint 3: time capacity

//Constraint 5: for {i in 1..N}{j in 1..N}{m in 1..N}:sum {k in

//the extra constraint added for feasibility

//Constraint 5: for {i in 1..N}{j in 1..N}{m in 1..N}:sum {k in

//the extra constraint added for feasibility

for (int m=0;m<N;m++)

//solving the MODEL

cout << "Minimum Cost = " << Z << endl;

fout << "Minimum Cost = " << Z << endl;

}// while ends here

fout<<"Nodes \t Hubs: "<<endl;

for (int i=0;i<N;i++)

cout<<"i j k m x[i][j][k][m]" << endl;

}//end of of try block

typedef IloArray<IloNumArray> TwoDMatrix;

int main(int argc, char **argv)

TwoDMatrix haultime(env); //haul time from one node to another

const char* data_filename = "Project LSO Data.dat";

datafile >> dist >> haultime;

fout<<"Number of nodes = "<<N<<endl;

IloNumVarArray lambda(env, T);

typedef IloArray<IloBoolArray> arr2d;//Creating a 2d array of x

for (int i=0; i<N; i++)

for (int j=0;j<N;j++)

IloNumArray cf(env,100, 3,5,ILOINT);

IloExpr ObjP(env); // Creates an expression with the name Obj

for (int k=0;k<3;k++)

//Constraint 3: time capacity

IloExpr ObjPL (env);

/*for (int i=0;i<N;i++)

//Constraint 5: for {i in 1..N}{j in 1..N}{m in 1..N}:sum {k in

//the extra constraint added for feasibility

for(int i=0; i<N; i++)

//Constraint 1: for {i in 1..N}{j in 1..N}{m in 1..N}:sum {k in

//============================================done till here=======PL still

for (int m=0;m<N;m++)

//solving the MODEL

cout << "Minimum Cost = " << Z << endl;

fout << "Minimum Cost = " << Z << endl;

}// while ends here

fout<<"Nodes \t Hubs: "<<endl;

for (int i=0;i<N;i++)

cout<<"i j k m x[i][j][k][m]" << endl;

}//end of of try block

You might also like