###############################################################################

option show_stats 4;

###############################################################################

param Nrows;
param Ncols;

set col:= 1..Nrows;

param Intensity{1..Nrows, 1..Ncols} >= 0 integer;

data 350_5.dat.min  ;

#------------------------------------------------------------------------------

param maxMonitorUnits;
let maxMonitorUnits := 10;

set NODES := {i in 1..Nrows, j in 1..Ncols, t in 1..maxMonitorUnits } ;

var p{NODES} binary;
var l{NODES} binary;
var d{NODES} binary;
var z{t in 1..maxMonitorUnits} binary;

#------------------------------------------------------------------------------
# monotonicity constraint

subject to GroupActiveMonitors{ t in 1..maxMonitorUnits-1 }:
  z[t] >= z[t+1];

#------------------------------------------------------------------------------
# minimize the number of monitor units (Equation 6)

minimize MinNumMonitorUnits:
  sum { t in 1..maxMonitorUnits } z[t];

#------------------------------------------------------------------------------
#constraining the leaves in any row so they cannot override each other 
# (Equation 1)
# therefore, the beam element cannot be covered at the same time by both a 
# left leaf and a right leaf

subject to LeafConstraint{ (i, j, t) in NODES }:
  p[i, j, t] + l[i, j, t]  + d[i, j, t]  = 1 ;

#------------------------------------------------------------------------------
# ensuring that the leaves have no holes (Equation 2 & 3)

subject to HoleConstraint1{ (i, j, t) in NODES: j < Ncols }:
  p[i, j, t] - p[i, j + 1, t] <= 0;

subject to HoleConstraint2{ (i, j, t) in NODES: j < Ncols }:
  l[i, j+1, t] - l[i, j, t] <= 0;
 
#------------------------------------------------------------------------------
# sum of the desired intesity at time t (Equation 4)

subject to IntensityConstraint { i in 1..Nrows, j in 1..Ncols }:
  sum { t in 1..maxMonitorUnits : (i,j,t) in NODES } 
        d[i, j, t] = Intensity[i, j];

#------------------------------------------------------------------------------
# total number of monitor units (Equation 5)

subject to MonitorUnits { t in 1..maxMonitorUnits }:
  sum { i in 1..Nrows, j in 0..Ncols : (i,j,t) in NODES } 
        d[i,j,t] - z[t]*Nrows*Ncols <= 0;

#------------------------------------------------------------------------------
# equation 11 Leaf collision constraint

subject to DirectionConstraint1{(i,j,t) in NODES: t <maxMonitorUnits}:
  p[i,j,t] - p[i,j,t+1] >= 0;

# equation 12 Leaf collision constraint
subject to DirectionConstraint2 { ( i, j, t) in NODES : t < maxMonitorUnits}:
  l [ i, j, t+1] - l [ i, j, t] >= 0;

# equation 13 Leaf collision constraint
subject to CollisionConstraint{(i,j,t) in NODES: i<Nrows}: 
  l[ i+1, j, t] + p[i,j,t]<=1;

# eqution 14 Leaf collision constraint
subject to CollisionConstraint2{(i,j,t) in NODES: i>1}: 
  l[i-1, j, t] + p[i,j,t]<=1;

#------------------------------------------------------------------------------
objective MinNumMonitorUnits;
option solver cplexamp;
option cplex_options 'clocktype = 2' 'timing=1' 
		'mipdisplay=2' 
		#'integrality = .001' 
		#'uppercutoff=20'
		#'absmipgap=1'
		;
solve;

#------------------------------------------------------------------------------
# print out of results
#display 
# printf "%6s%6s%6s%4sX = %d\n", "row", "left", "right", "", minPositiveWeight;

printf "The minimum number of monitor units (shapes) is %d\n", 
       MinNumMonitorUnits;
for {t in 1..maxMonitorUnits} {
  #print t's value
  if z[t]=1 then{
    printf "Monitor Unit %d\n",t;

    for {i in 1..Nrows}{	for {j in 1..Ncols}
           printf "%6d",d[i,j,t];
	    printf "\n";
    }
  }
}

###############################################################################
###############################################################################

param minMonUnits;

#------------------------------------------------------------------------------
# equation 6' set up the new minimization of number of segments

let minMonUnits:= sum { t in 1..maxMonitorUnits } z[t] ;
var zz{t in 1..minMonUnits} binary;
var g{t in 1..minMonUnits} binary; 

subject to MinMonitorUnits:
  sum {t in 1..minMonUnits} zz[t] <=  minMonUnits;

#------------------------------------------------------------------------------
# I added
set NODES2 := {i in 1..Nrows, j in 1..Ncols, t in 1..minMonUnits } ;
var s{NODES2} binary; # count for switch covered from/ to uncovered
var c{NODES2} binary; # switch to covered position
var u{NODES2} binary; # switch to uncovered position

var dd{NODES2} binary;
for { (i, j, t) in NODES2}
   let dd[i,j,t]:= d[i,j,t];

#------------------------------------------------------------------------------
# Equations to count the number of segments being used

# equation 7 look at two adjacent time steps to see if a leaf moved
subject to Switches1b{(i,j,t) in NODES2: t <minMonUnits}:
  -c[i,j,t] <= dd[i,j,t+1] - dd[i,j,t];
subject to Switches2b{(i,j,t) in NODES2: t <minMonUnits}:
  dd[i,j,t+1] - dd[i,j,t] <= u[i,j,t];

# equation 8 count number of leaves moved
subject to Switching2{(i,j,t) in NODES2: t<minMonUnits}:
  u[i,j,t]+c[i,j,t] = s[i,j,t];

# equation 9
subject to Changes2 {t in 1..minMonUnits}:
  sum {i in 1..Nrows} sum{j in 1..Ncols} s[i,j,t] <= Nrows*Ncols*g[t];

#------------------------------------------------------------------------------
# (Equation 1)
# therefore, the beam element cannot be covered at the same time by both a 
# left leaf and a right leaf

subject to LeafConstraint2{ (i, j, t) in NODES2 }:
  p[i, j, t] + l[i, j, t]  + dd[i, j, t]  = 1 ;

# sum of the desired intesity at time t (Equation 4)

subject to IntensityConstraint2 { i in 1..Nrows, j in 1..Ncols }:
  sum { t in 1..minMonUnits : (i,j,t) in NODES2 } 
        dd[i, j, t] = Intensity[i, j];

#------------------------------------------------------------------------------
# total number of monitor units (Equation 5)

subject to MonitorUnits2 { t in 1..minMonUnits }:
  sum { i in 1..Nrows, j in 0..Ncols : (i,j,t) in NODES2 } 
        dd[i,j,t] - z[t]*Nrows*Ncols <= 0;

#------------------------------------------------------------------------------
# equation 10

minimize MinSegments:
  sum { t in 1..minMonUnits} g[t];

objective MinSegments;
option cplex_options 'clocktype = 2' 'timing=1' 
		'mipdisplay=2' #'integrality = .001' 
		#'uppercutoff=25' #'absmipgap=.3' 
		#'cutpass=-1' 'probe=-1' 
		#'solutionlim=1';
;
solve;

printf "The minimum number of monitor units is %d\n" , MinSegments;

printf "The shape matricies\n";
for {t in 1..minMonUnits} {
   #print t's value
   printf "Shape Matrix %d\n",t;

   for {i in 1..Nrows}{
	  for {j in 1..Ncols}
        printf "%6d",dd[i,j,t];
	  printf "\n";
   }
}

printf "The segments being used are %d\n"; 
display g; 

###############################################################################