/*********************************************
 * OPL 12.6.0.0 Model
 * Author: paolucci
 * Creation Date: 11/apr/2015 at 16:08:50
 *********************************************/
string instance = ...;
int n=...;
int m=...;

range rjob=1..n;
range rjobz=0..n;

range rmach=1..m;

tuple JobMach {
int job;
int mach;
float pr;
float en;
};

tuple JobDati {
int job;
float dd;
float w;
float rel;
};

tuple Setups {
int mach;
int job1;
int job2;
float tset;
};

{JobMach} JobMachineData = ...;
{JobDati} JobData=...;
{Setups} SSD=...;

tuple MIJind {
 int m;
 int i;
 int j;
};

tuple Elig {
int job;
int mach;
};

tuple DatiNorm {
 string ist;
 float Tmin;
 float DeltaT;
 float Emin;
 float DeltaE;
 float Smin;
 float DeltaS;
};

{DatiNorm} Norm = ...; // data for nomalization (computed having run the model for optimizing each single objective separately)

{MIJind} XMIJ = {<im.mach,im.job,jm.job> | im in JobMachineData, jm in JobMachineData: im.job!=jm.job && im.mach==jm.mach}
          union {<jm.mach,0,jm.job> | jm in JobMachineData} 
          union {<jm.mach,jm.job,n+1> | jm in JobMachineData};
          
{Elig} YJM = {<im.job,im.mach> | im in JobMachineData};

float BS[rmach];
float B[rmach];
float RMAX;

// normalization factors (available after running model for each single objective)
float Tmin;
float DeltaT;
float Emin;
float DeltaE;
float Smin;
float DeltaS;

// computation of Big-M and assigmnet of normalization factors
execute {

	for(var mm in rmach) BS[mm] =  0;
	
	for(var ss in SSD) {			
				if (ss.tset> BS[ss.mach]) BS[ss.mach] = ss.tset;
	}
	
   for(var mm in rmach){
	 	B[mm] = n*BS[mm];
	 	}
	
	for(var jm in JobMachineData) {
	  B[jm.mach]=B[jm.mach]+jm.pr;
	}
	RMAX=0;
	for(var jd in JobData) { 
	if(jd.rel>RMAX) RMAX=jd.rel;
}
	 for(var mm in rmach){
	 	B[mm] = B[mm]+RMAX;
	 	}
	 	
	 for(var nn in Norm){
	 	if(nn.ist == instance)	{
	 		 	Tmin=nn.Tmin;
				DeltaT=nn.DeltaT;
 				Emin=nn.Emin;
 				DeltaE=nn.DeltaE;
 				Smin=nn.Smin;
 				DeltaS=nn.DeltaS;
	 	} 
	 }		
}

// cplex parameter
execute PARAMS {
  cplex.tilim = 3600;
  cplex.epGap=5.0e-3;
}

float pi1=0.6;
float pi3=0.05;
float pi2=0.35;
//------------------VARIABLES--------------------------------------------
dvar boolean x[XMIJ]; // sequencing vars
dvar boolean y[YJM]; // assignment vars
dvar float+ c[rjobz]; // completion time
dvar float+ t[rjob]; // tardiness
dvar float+ TT; // total tardiness
dvar float+ EC; // total energy cons
dvar float+ SC; // total setup time
//-----------------------------------------------------------------------

minimize
 pi1*(TT-Tmin)/DeltaT + pi2*(EC-Emin)/DeltaE+pi3*(SC-Smin)/DeltaS;

 
subject to
{
TT == sum(j in JobData)(j.w*t[j.job]) ;
EC==sum(mij in XMIJ, jm in JobMachineData: jm.mach==mij.m && jm.job==mij.j)(jm.en*x[mij]);
SC==sum(mij in XMIJ, ss in SSD: ss.mach==mij.m && ss.job1==mij.i && ss.job2==mij.j)(ss.tset*x[mij]);

// (7)
forall (jm in YJM)
	Pred: sum (mij in XMIJ: mij.j==jm.job && mij.m==jm.mach) (x[mij]) == y[jm];
// (8)
forall (jm in YJM)
	Succ: sum ( mij in XMIJ: mij.i==jm.job && mij.m==jm.mach) (x[mij]) == y[jm];
// (9)
forall(j in rjob)
  Ass: sum(jm in YJM : jm.job == j) (y[jm])==1;
	
// (10)
forall(mc in rmach)
  SingleStart: sum(mij in XMIJ: mij.i==0 && mij.m==mc)(x[mij]) <= 1;
  
// (11)
 forall(jd in JobData) release: c[jd.job]>= jd.rel + 
      sum(jm in YJM, jmd in JobMachineData: jm.job==jd.job && jmd.job==jd.job && jm.mach==jmd.mach)(jmd.pr*y[jm]); 
  
// (12)
forall(i in JobData) tardiness: t[i.job] >= c[i.job]-i.dd;

// (13)
 forall(ss in SSD, jm in JobMachineData: jm.job==ss.job2 && jm.mach==ss.mach)
     disg:c[ss.job2] >= c[ss.job1] + jm.pr - B[ss.mach]*(1-x[<ss.mach,ss.job1,ss.job2>]) +ss.tset;
     
// (14)
Zerostart: c[0]== 0;

}