#   robust_model
#
#  Definitions:   
#    LTE - denotes line terminating equipment    
#    R   - denotes a regenerator        
#    A   - denotes an optical amplifier   
#   
#  Objective:  Determine the number of LTEs, Rs, and As and   
#              and their locations in the network   
#   
#  Assumptions:   
#    1.  The (o,d) demand pairs are distinct   
#    2.  We use an arc-path model with demand-splitting   
#    3.  This model does not permit pass-throughts   
#        Post-processing will be used to determine pass-throughs   
#    4   A LTE models an interface at a node, i.e. a path that passes    
#        through a node requires two LTEs    
#    5.  Demands are in DS3s   
#    6.  1 lambda = 192 DS3    
#    7.  1 fiber has 80 channels (2 lambdas per channel)   
#    8.  1 R = 1 channel (2 lambdas)   
#    9.  1 A = 80 channels   
#   10.  1 LTE = 1 channel (2 lambdas)   


set PW;                # for the piece-wise regret function   
# parameters for the regret function (see run_robust.txt)
param B;
param H :=    B/4; 
param K :=      H;
param G := 0.25*H;

set E;                 # the set of links   
set N;                 # the set of nodes   
set S;                 # the set of scenarios   
set D within {N,N};    # the set of demands   
set P;                 # the set of paths   
set J {D} within {P};  # the set of paths that can be used to satisfy   
                       # demand (o,d)   
set Adj {N} within {E};# the set of links adjacent to node n   
   
set PLTE {N} within {P};   # the set of paths that have a LTE at node n   
   
set L {E} within {P};  # paths using link e   
   
param r {D,S};         # the amount of demand for (o,d) in scenario s   
                       # units are DS3s   
   
param ModLTE;          # the number of circuits that a LTE can handle   
param ModR;            # the number of circuits that an R can handle   
param ModA;            # the number of circuits that an A can handle   
param costLTE;         # the cost of one LTE   
param costR;           # the cost of one R    
param costA;           # the cost of one A   
param cap {E};	       # the max number of fibers in link e   
param reach;           # number of spans between regens   
param nospans;         # distance between amplifers (kilometers)   
param dist {E};        # dist[e] denotes the length of link e (kilometers)   
param RonL {e in E} := floor((dist[e]-1)/(reach*nospans));   
                       # RonL[e] denotes the number of regens on link e    
                       # per channel   
param AonL {e in E} := floor((dist[e]-1)/reach)-RonL[e];   
                       # AonL[e] denotes the number of amplifers on link e   
                       # per fiber   
   
#-----------------Problem SCENARIO----------------------------------------- 
 
var x   {P,S} >= 0;            # x[p,s]   denotes the number of circuits   
                               # assigned to path p in scenario s   
   
var LTE {N,S} >= 0;            # LTE[n,s] denotes the number of LTEs    
                               # at node n in scenario s   
   
var eLTE{E,S} >= 0;            # eLTE[e,s] is half the number of LTEs   
			       # needed on edge e in scenario s   
   
var A  {E,S} >= 0;             # A[e,s]  denotes the number of As needed   
                               # on link e in scenario s   
   
var R {E,S}  >= 0;             # R[e,s] denotes the number of Rs needed   
                               # on link e in scenario s   
   
var Fiber {E, S} integer >= 0; # Fiber[e,s] denotes the number of fibers needed   
                               # on link e for scenario s   
   
var Channel {E, S} integer >= 0; # Channel[e,s] denotes the number of   
                                 # channels needed on link e for scenario s   
   
var Z {E, S} >= 0;             # Z[e] is the number of circuits assigned   
                               # to link e for scenario s   
                             
param delta {S};               # used to prevent objective accumulation  
 
minimize costs: sum {n in N, s in S} delta[s]*costLTE*LTE[n,s] +   
                sum {e in E, s in S} delta[s]*(costA*A[e,s] + costR*R[e,s]);   
subject to Demands {(o,d) in D, s in S}:   
  sum {p in J[o,d]} x[p,s] = r[o,d,s];   
   
subject to xtoZ {e in E, s in S}:   
  sum {p in L[e]} x[p,s] = Z[e,s];   
     
subject to LTEsOnEdge1 {e in E, s in S}:   
  Z[e,s] <= ModLTE*eLTE[e,s];   
   
subject to LTEsAtNode {n in N, s in S}:   
  sum {e in Adj[n]} eLTE[e,s] = LTE[n,s];   
   
subject to FsOnLink1 {e in E, s in S}:   
  Z[e,s] <= ModA*Fiber[e,s];   
   
subject to CsOnLink1 {e in E, s in S}:   
  Z[e,s] <= ModR*Channel[e,s];   
   
subject to FtoA {e in E, s in S}:   
  AonL[e] * Fiber[e,s] = A[e,s];   
   
subject to CtoR {e in E, s in S}:   
  RonL[e] * Channel[e,s] = R[e,s];   
   
subject to FiberCapacity {e in E, s in S}:   
  Fiber[e,s] <=  cap[e];   
   
#-----------------Problem MEANVALUE---------------------------------------- 
 
param Prob {S};         # Prob[s] is the probability that scenario s   
                        # occurs   
param EVr {D}; 
param Budget {1..3};

var EVETerm               >= 0;
var EVx       {P}         >= 0; 
var EVLTE     {N}         >= 0; 
var EVeLTE    {E}         >= 0; 
var EVA       {E}         >= 0; 
var EVR       {E}         >= 0; 
var EVFiber   {E} integer >= 0; 
var EVChannel {E} integer >= 0; 
var EVZ       {E}         >= 0; 
 
minimize EVcosts: EVETerm;

subject to EVETermConst: 
  EVETerm = sum {n in N} costLTE*EVLTE[n] +   
            sum {e in E} (costA*EVA[e] + costR*EVR[e]);   

subject to EVBudget {b in {1..3}}:   EVETerm <= Budget[b];

subject to EVDemandConst {(o,d) in D}:   
  sum {p in J[o,d]} EVx[p] = EVr[o,d];   
   
subject to EVxtoZ {e in E}:   
  sum {p in L[e]} EVx[p] = EVZ[e];   
     
subject to EVLTEsOnEdge1 {e in E}:   
  EVZ[e] <= ModLTE*EVeLTE[e];   
   
subject to EVLTEsAtNode {n in N}:   
  sum {e in Adj[n]} EVeLTE[e] = EVLTE[n];   
   
subject to EVFsOnLink1 {e in E}:   
  EVZ[e] <= ModA*EVFiber[e];   
   
subject to EVCsOnLink1 {e in E}:   
  EVZ[e] <= ModR*EVChannel[e];   
   
subject to EVFtoA {e in E}:   
  AonL[e] * EVFiber[e] = EVA[e];   
   
subject to EVCtoR {e in E}:   
  RonL[e] * EVChannel[e] = EVR[e];   
   
subject to EVFiberCapacity {e in E}:   
  EVFiber[e] <=  cap[e];   
   
#-----------------Problem STOCHASTIC--------------------------------------- 
 
param SPPenalty;

var SPETerm               >= 0;
var SPx       {P}         >= 0; 
var SPLTE     {N}         >= 0; 
var SPeLTE    {E}         >= 0; 
var SPA       {E}         >= 0; 
var SPR       {E}         >= 0; 
var SPFiber   {E} integer >= 0; 
var SPChannel {E} integer >= 0; 
var SPZ       {E}         >= 0; 
var SPZTerm               >= 0;
var SPzp      {D,S}       >= 0;
var SPzm      {D,S}       >= 0;

minimize SPcosts: SPETerm + SPZTerm;

subject to SPETermConst: 
  SPETerm = sum {n in N} costLTE*SPLTE[n] +   
            sum {e in E} (costA*SPA[e] + costR*SPR[e]);   

subject to SPBudget {b in {1..3}}:   SPETerm <= Budget[b];

subject to SPDemands {(o,d) in D, s in S}:   
  sum {p in J[o,d]} SPx[p] = r[o,d,s] - SPzp[o,d,s] + SPzm[o,d,s];   
   
subject to SPxtoZ {e in E}:   
  sum {p in L[e]} SPx[p] = SPZ[e];   
     
subject to SPLTEsOnEdge1 {e in E}:   
  SPZ[e] <= ModLTE*SPeLTE[e];   
   
subject to SPLTEsAtNode {n in N}:   
  sum {e in Adj[n]} SPeLTE[e] = SPLTE[n];   
   
subject to SPFsOnLink1 {e in E}:   
  SPZ[e] <= ModA*SPFiber[e];   
   
subject to SPCsOnLink1 {e in E}:   
  SPZ[e] <= ModR*SPChannel[e];   
   
subject to SPFtoA {e in E}:   
  AonL[e] * SPFiber[e] = SPA[e];   
   
subject to SPCtoR {e in E}:   
  RonL[e] * SPChannel[e] = SPR[e];   
   
subject to SPFiberCapacity {e in E}:   
  SPFiber[e] <=  cap[e];   
   
subject to SPZTermConst:
  SPZTerm = SPPenalty * sum {s in S} Prob[s]*
       (sum {(o,d) in D} (SPzp[o,d,s] + SPzm[o,d,s]));

#-----------------Problem ROBUSTOPTIMIZATION------------------------------- 
param slopep {PW};
param slopem {PW};
 
var ROETerm               >= 0;
var ROx       {P}         >= 0; 
var ROLTE     {N}         >= 0; 
var ROeLTE    {E}         >= 0; 
var ROA       {E}         >= 0; 
var ROR       {E}         >= 0; 
var ROFiber   {E} integer >= 0; 
var ROChannel {E} integer >= 0; 
var ROZ       {E}         >= 0; 
var ROzp      {D,S}       >= 0;
var ROzm      {D,S}       >= 0;
var ROzppw    {D,S,PW}    >= 0, <= H;
var ROzmpw    {D,S,PW}    >= 0, <= H;

minimize Regret:  sum {(o,d) in D, s in S} Prob[s]*
      (sum {pw in PW} (slopep[pw]*ROzppw[o,d,s,pw] +
                       slopem[pw]*ROzmpw[o,d,s,pw] ) );

subject to ROETermConst: 
  ROETerm = sum {n in N} costLTE*ROLTE[n] +   
            sum {e in E} (costA*ROA[e] + costR*ROR[e]);   

subject to ROBudget {b in {1..3}}:   ROETerm <= Budget[b];

subject to RODemands {(o,d) in D, s in S}:   
  sum {p in J[o,d]} ROx[p] = r[o,d,s] - ROzp[o,d,s] + ROzm[o,d,s];   
   
subject to ROxtoZ {e in E}:   
  sum {p in L[e]} ROx[p] = ROZ[e];   
     
subject to ROLTEsOnEdge1 {e in E}:   
  ROZ[e] <= ModLTE*ROeLTE[e];   
   
subject to ROLTEsAtNode {n in N}:   
  sum {e in Adj[n]} ROeLTE[e] = ROLTE[n];   
   
subject to ROFsOnLink1 {e in E}:   
  ROZ[e] <= ModA*ROFiber[e];   
   
subject to ROCsOnLink1 {e in E}:   
  ROZ[e] <= ModR*ROChannel[e];   
   
subject to ROFtoA {e in E}:   
  AonL[e] * ROFiber[e] = ROA[e];   
   
subject to ROCtoR {e in E}:   
  RonL[e] * ROChannel[e] = ROR[e];   
   
subject to ROFiberCapacity {e in E}:   
  ROFiber[e] <=  cap[e];   

subject to Piecewise1 {(o,d) in D, s in S}:
  sum {pw in PW} ROzppw[o,d,s,pw] = ROzp[o,d,s];

subject to Piecewise2 {(o,d) in D, s in S}:
  sum {pw in PW} ROzmpw[o,d,s,pw] = ROzm[o,d,s];

#-----------------Problem WORSTCASE---------------------------------------- 

var WCETerm               >= 0;
var WCx       {P}         >= 0; 
var WCLTE     {N}         >= 0; 
var WCeLTE    {E}         >= 0; 
var WCA       {E}         >= 0; 
var WCR       {E}         >= 0; 
var WCFiber   {E} integer >= 0; 
var WCChannel {E} integer >= 0; 
var WCZ       {E}         >= 0; 
var WCMAXS                >= 0;
var WCzp      {D,S}       >= 0;
var WCzm      {D,S}       >= 0;


minimize WCcosts: WCMAXS;

subject to WCETermConst: 
  WCETerm = sum {n in N} costLTE*WCLTE[n] +   
            sum {e in E} (costA*WCA[e] + costR*WCR[e]);   

subject to WCBudget {b in {1..3}}:   WCETerm <= Budget[b];

subject to WCDemands {(o,d) in D, s in S}:   
  sum {p in J[o,d]} WCx[p] = r[o,d,s] - WCzp[o,d,s] + WCzm[o,d,s];   
   
subject to WCxtoZ {e in E}:   
  sum {p in L[e]} WCx[p] = WCZ[e];   
     
subject to WCLTEsOnEdge1 {e in E}:   
  WCZ[e] <= ModLTE*WCeLTE[e];   
   
subject to WCLTEsAtNode {n in N}:   
  sum {e in Adj[n]} WCeLTE[e] = WCLTE[n];   
   
subject to WCFsOnLink1 {e in E}:   
  WCZ[e] <= ModA*WCFiber[e];   
   
subject to WCCsOnLink1 {e in E}:   
  WCZ[e] <= ModR*WCChannel[e];   
   
subject to WCFtoA {e in E}:   
  AonL[e] * WCFiber[e] = WCA[e];   
   
subject to WCCtoR {e in E}:   
  RonL[e] * WCChannel[e] = WCR[e];   
   
subject to WCFiberCapacity {e in E}:   
  WCFiber[e] <=  cap[e];   
   
subject to WCMAXSConst {s in S}:
  WCMAXS >= WCETerm + 
    SPPenalty * (sum {(o,d) in D} (WCzp[o,d,s] + WCzm[o,d,s]));

#-----------------Problem UNDERPROVISION----------------------------------- 
 
#  Model to determine under and over provisioning 
 
var uLTE      {E,S} >= 0; 
var oLTE      {E,S} >= 0; 
var uLTETotal {S}   >= 0; 
var oLTETotal {S}   >= 0; 
var uR        {E,S} >= 0; 
var oR        {E,S} >= 0; 
var uRTotal   {S}   >= 0; 
var oRTotal   {S}   >= 0; 
var uA        {E,S} >= 0; 
var oA        {E,S} >= 0; 
var uATotal   {S}   >= 0; 
var oATotal   {S}   >= 0; 
 
minimize under: sum {s in S} delta[s]* 
(costLTE*uLTETotal[s] + costR*uRTotal[s] + costA*uATotal[s]); 
 
subject to uoLTE {e in E, s in S}: 
  eLTE[e,s] = ROeLTE[e] + uLTE[e,s] - oLTE[e,s]; 
 
subject to uoR   {e in E, s in S}: 
  R[e,s] = ROR[e] + uR[e,s] - oR[e,s]; 
 
subject to uoA   {e in E, s in S}: 
  A[e,s] = ROA[e] + uA[e,s] - oA[e,s]; 
 
subject to uLTETotalConst {s in S}: 
  uLTETotal[s] = sum {e in E} 2*uLTE[e,s]; 
 
subject to oLTETotalConst {s in S}: 
  oLTETotal[s] = sum {e in E} 2*oLTE[e,s]; 
 
subject to uRTotalConst {s in S}: 
  uRTotal[s] = sum {e in E} uR[e,s]; 
 
subject to oRTotalConst {s in S}: 
  oRTotal[s] = sum {e in E} oR[e,s]; 
 
subject to uATotalConst {s in S}: 
  uATotal[s] = sum {e in E} uA[e,s]; 
 
subject to oATotalConst {s in S}: 
  oATotal[s] = sum {e in E} oA[e,s];