Please help me in deciding the objective function. The present objective works but if I want to change the objective function to minimize (sum (i in arcs)weight[i]*primPath[i] + sum (i in arcs) weight[i]*backPath[i]+TP) . The Cplex gives no solution
//Parameters
int n=...;
range nodes=1..n;
int source=...;
int destination=...;
int relocDestination=...;
int s = ... ; //Total number of subcarriers in a link
range w = 1 ..s ;
range w1 = 1 .. (s-2);
range w2 = 1 .. (s-1);
int B = ... ; //Bandwidth
int G = ... ; //Guard
int req=...;
range M=1..req;
tuple edge {
int sourceNode;
int destNode;
}
range modrange=1..4;
range modrange1=1..3;
{edge} arcs with sourceNode in nodes,destNode in nodes=...;
int weight[arcs]=...;
int initPrimSpec[M][w][arcs]=...;
int initBackSpec[M][w][arcs]=...;
int initPrimPath[M][arcs]=...;
int initBackPath[M][arcs]=...;
int initStreams[M][arcs]=...;
int delta=20000;
int o[modrange] = ...;
float demand=...;
float X[modrange]=...;
int degree[nodes]=...;
float EBVT[modrange]=...;
//decision variables
dvar boolean primPath[arcs];
dvar boolean backPath[arcs];
dvar boolean specPrim[w][arcs];
dvar boolean specBack[w][arcs];
dvar boolean S[arcs];
dvar int lp;
dvar int lb;
dvar boolean pu[modrange];
dvar boolean bu[modrange];
dvar int ps;
dvar int bs;
dvar float BA;
dvar float PA;
dvar float BOXC;
dvar float POXC;
dvar float PBVT;
dvar float BBVT;
dvar float TP;
dvar int TPI;
dvar int gain;
/** Objective Function**/
minimize (sum (i in arcs)weight[i]*primPath[i] + sum (i in arcs) weight[i]*backPath[i]) ;
constraints {
PrimaryFlowConserv:
forall (i in nodes) {
if (i==source)
sum (<i,j> in arcs) primPath[<i,j>] - sum (<j,i> in arcs) primPath[<j,i>] == 1;
else if (i==destination)
sum (<i,j> in arcs) primPath[<i,j>] - sum (<j,i> in arcs) primPath[<j,i>] == -1;
else
sum (<i,j> in arcs) primPath[<i,j>] - sum (<j,i> in arcs) primPath[<j,i>] == 0;
}
NoOverlap:
forall (i in nodes, j in nodes) {
sum (<i,j> in arcs) primPath[<i,j>] + sum (<i,j> in arcs) backPath[<i,j>] <= 1;
}
CapacityAllocationConstraintforPrimaryPath:
forall(<i,j> in arcs) {
(primPath[<i,j>] == 1) => (sum(k in w) specPrim[k][<i,j>] == ps );
}
SpectrumContiguityCons:
forall(k in w2) {
forall(<i,j> in arcs){
(specPrim[k][<i,j>] - specPrim[k+1][<i,j>] - 1) * (-s) >= sum (i1 in w1) specPrim[i1][<i,j>] ;
}
}
NonoverlappingSpecCons:
forall(k1 in M) {
forall (<i,j> in arcs, k in w) {
(initPrimSpec[k1][k][<i,j>] ) * (specPrim[k][<i,j>] ) <= 0 ;
}
}
PathSelectionCons1:
forall (<i,j> in arcs) {
sum(k in w) specPrim[k][<i,j>] <= primPath[<i,j>] * s ;
}
PathSelectionCons2:
forall(<i,j> in arcs) {
primPath[<i,j>] <= sum(k in w) specPrim[k][<i,j>];
}
SpectrumContinuityCons01:
forall(<i,j> in arcs) {
forall(<i1,j1> in arcs) {
if (<i,j> != <i1,j1>){
(primPath[<i,j>] - primPath[<i1,j1>] == 0) => (sum(k in w) specPrim[k][<i,j>] - sum(k in w) specPrim[k][<i1,j1>] == 0 );
}
}
}
CapacityAllocationConstraint1B:
forall(<i,j> in arcs) {
(backPath[<i,j>] == 1) => (sum(k in w) specBack[k][<i,j>] == bs );
}
SpectrumContiguityConsB:
forall(k in w2) {
forall(<i,j> in arcs){
(specBack[k][<i,j>] - specBack[k+1][<i,j>] - 1) * (-s) >= sum (i1 in w1) specBack[i1][<i,j>] ;
}
}
NonoverlappingSpecConsB:
forall(k1 in M) {
forall (<i,j> in arcs, k in w) {
(initBackSpec[k1][k][<i,j>] ) * (specBack[k][<i,j>] ) <= 0 ;
}
}
PathSelectionCons1B:
forall (<i,j> in arcs) {
sum(k in w) specBack[k][<i,j>] <= backPath[<i,j>] * s ;
}
PathSelectionCons2B:
forall(<i,j> in arcs) {
backPath[<i,j>] <= sum(k in w) specBack[k][<i,j>];
}
NoOverlapSpectrum:
forall(<i,j> in arcs,k in w) {
specBack[k][<i,j>] + specPrim[k][<i,j>] <= 1 ;
}
SpectrumContinuityCons02:
forall(<i,j> in arcs) {
forall(<i1,j1> in arcs) {
if (<i,j> != <i1,j1>){
(backPath[<i,j>] - backPath[<i1,j1>] == 0) => (sum(k in w) specBack[k][<i,j>] - sum(k in w) specBack[k][<i1,j1>] == 0 );
}
}
}
Distinct:
forall(k in M) {
forall (k1 in w){
forall (<i,j> in arcs) {
initPrimSpec[k] [k1] [<i,j>] + specPrim [k1] [<i,j>] <= 1;
}
}
}
BackupSharing:
forall(k1 in M) {
forall (k in arcs){
(primPath[k] + initPrimPath[k1][k] <=1) => (backPath[k] + initBackPath[k1][k]<=2);
}
}
MergeNonDiverging:
if(req >1) {
forall (m in M) {
forall (k in arcs) {
S[k] == backPath[k] * initStreams[m][k];
}
}
}
//Modulation format equations
LengthofPrimPath:
lp ==sum (k in arcs)(primPath[k]* weight[k]) ;
LengthofBackPath:
lb==sum (k in arcs)(backPath[k]* weight[k]) ;
SelectOneModulationforPrimary:
lp-o[1] >=0 => pu[1] == 1; //path lengths g.t. 4000
lp-o[4] <=0 => pu[4] == 1; //path lengths l.t. 500
forall (i in modrange) {
lp-o[i] ==0 => pu[i] == 1; //path lengths e.q. o[i]
}
forall (i in modrange) {
(1-pu[i])*delta >= lp-o[i];
}
sum (k in modrange)pu[k] == 1 ;
SelectOneModulationforbackup:
lb-o[1] >=0 => bu[1] == 1; //path lengths g.t. 4000
lb-o[4] <=0 => bu[4] == 1; //path lengths l.t. 500
forall (i in modrange) {
lb-o[i] ==0 => bu[i] == 1; //path lengths e.q. o[i]
}
forall (i in modrange) {
(1-bu[i])*delta >= lb-o[i];
}
sum (k in modrange)bu[k] == 1 ;
NumofCarriers1:
forall(i in modrange) {
pu[i] == 1 => ps == (ceil(demand/X[i]) + G);
}
NumofCarriers2:
forall(i in modrange) {
bu[i] == 1 => bs == (ceil(demand/X[i]) + G);
}
AmplifierPower:
PA == sum (k in arcs) primPath[k] * (ps/s) * (floor(weight[k]/80 + 1)*100);
BA == sum (k in arcs) backPath[k] * (bs/s) * (floor(weight[k]/80 + 1)*100);
PowerOpticalCrossConnect:
POXC == sum (<i,j> in arcs) primPath[<i,j>] * ((ps/s) * (85*degree[j]+100*9+150));
BOXC == sum (<i,j> in arcs) backPath[<i,j>] * ((bs/s) * (85*degree[j]+100*9+150));
PowerBandwidthVariableTransponder:
forall(i in modrange) {
pu[i] == 1 => PBVT == EBVT[i];
}
forall(i in modrange) {
bu[i] == 1 => BBVT == EBVT[i];
}
TotalPower:
TP == (PA + POXC + PBVT+ BA + BOXC + BBVT)/1000;
TotalGain:
gain == sum (i in arcs) weight[i]*S[i] ;
}
------------------------------
Sougata Das
------------------------------