#include <ilsched/iloscheduler.h>  
#include <time.h>  
#include <ilsolver/ilctrace.h> 
 
#define IlcTraceConstraint  ((IlcUInt)  2) 
#define IlcTraceProcess     ((IlcUInt)  4) 
#define IlcTraceVars         ((IlcUInt)  8) 
#define IlcTraceFail        ((IlcUInt)  16) 
#define IlcTraceNoEvent     ((IlcUInt)  32) 
#define IlcTraceAllEvents    ((IlcUInt)  31)  

/* an example of how to organise customised search:
see lines 84 - 455, where I am defining various functions,
as well as lines 1486 - 1502, where I am using them.
To use the code, compile it and type VrpSched52.exe, then 
supply all the necessary input, including the example data file
test.dat, which is a 5x5 job shop instance. */

ILOSTLBEGIN  
 
IloUnaryResourceArray unarResources;  
IloActivityArray activities; 
IloNumVarArray selected; 
IloNumVarArray costOnResource, selectedMachinesVarArr; 
IloNumVarArray minStart, maxEnd; 
IloArray< IloAltResConstraint > alternativeArr; 
IloArray <IloConstraint> AddedConstraintsArr; 
int GlobalNumberOfAddedConstraints; 
int ReadFirstSolutionFromFile; 
unsigned int GlobSeed; 
 
bool activateAltVRPCriterion = false; 
 
IloInt SetupActivityDuration;  
IloInt TeardownActivityDuration;  
IloInt NbMachines;  
IloInt MinTransition; 
IloInt SummedDurationSaved = 0; 
IloInt SummedDuration = 0; 
IloInt NbCustomers;  
IloInt BasicTimeLimit;   
unsigned int BasicFailLimit;// = 100000;   
IloInt TrueCost; 
//IloInt Criterion,CriterionOld; 
IloInt HorizonGlob, OriginGlob; 
//IloInt DesiredNbMachinesUsed; 
IloInt DiffNb,SameNb, PrecedenceNb; 
 
IloBool VRPFlag = IloTrue; 
 
IloNum SpeedParameter; 
IloNumVar CriterionVar; 
 
char * Problem; 
char * StandFormatFile; 
char SolFile[128]; 
char ProblemTransformed[128]; 
IloInt NbFailsSummed;  
IloInt GlobalVarTimeLimit; 
IloInt NbChoicePointsSummed;  
IloInt LastNbOfMachinesUsed = 0;  
IloInt DiscrepancyCount;  
  
IloInt  ResourceSelector,  
        ResourceConstraintSelector,  
		PossibleResourceSelector,  
		ActivitySelector;  
  
IloInt NbActPerTour;   
//the maximum number of activities per tour (setup + all the customers + teardown)  
IloInt NbAct;          
//the overall number of activities (both setup/teardown and the actual customer visits)  
  
IloNum** VrpData; 
IloInt** TransMatrRead;   
IloInt* Capacities; 
IloInt* DiffArr; 
IloInt* SameArr; 
IloInt* PrecedenceArr; 


// for the different search goals below (see lines
 
IlcBool maxCapacitySelector(IlcResource& resource, 
			    const IlcAltResConstraint alternative) { 
 if (!alternative.isResourceSelected()) { 
   IlcInt max = 0; 
   for (IlcPossibleAltResIterator ite(alternative); 
			          ite.ok(); 
				  ++ite) { 
     IlcInt cap = ite.getCapacity(); 
     if (cap > max) { 
       max = cap; 
       resource = *ite; 
     } 
   } 
   return IlcTrue; 
 } 
 return IlcFalse; 
} 
 
IlcBool randResourceSelector(IlcResource& resource, 
			     const IlcAltResConstraint alternative) { 
  if (!alternative.isResourceSelected()) { 
    IlcInt max = 0; 
    IlcInt ctr = 0; 
  for (IlcPossibleAltResIterator ite(alternative); 
    ite.ok(); 
    ++ite) { 
   ctr++; 
  } 
  IlcInt index = rand()*ctr/(1+RAND_MAX); 
  ctr = 0; 
  for (IlcPossibleAltResIterator ite_(alternative); 
    ite_.ok(); 
    ++ite_) { 
   if (ctr==index) { 
    resource = *ite_; 
    return IlcTrue; 
   } 
   ctr++; 
  } 
 } 
 return IlcFalse; 
} 
 
 
IlcBool minPossibleSelector(IlcAltResConstraint& alternative, 
       const IlcAltResSet resources) { 
 IlcInt min = IlcIntMax; 
 IlcBool ok = IlcFalse; 
 for (IlcAltResConstraintIterator ite(resources); 
   ite.ok(); 
   ++ite) { 
  IlcInt nb = (*ite).getNumberOfPossible(); 
  if (nb > 1 && nb < min) { 
   ok = IlcTrue; 
   min = nb; 
   alternative = *ite; 
  } 
 } 
 return ok; 
} 
 
IlcBool randPossibleSelector(IlcAltResConstraint& alternative, 
       const IlcAltResSet resources) { 
 IlcBool ok = IlcFalse; 
 IlcInt ctr = 0; 
 for (IlcAltResConstraintIterator ite(resources); 
   ite.ok(); 
   ++ite) { 
  if ((*ite).getNumberOfPossible() > 1) ctr++; 
 } 
 
 IlcInt index = rand()*ctr/(1+RAND_MAX); 
 
 ctr = 0; 
 for (IlcAltResConstraintIterator ite_(resources); 
   ite_.ok(); 
   ++ite_) { 
  if (index == ctr) { 
   ok = IlcTrue; 
   alternative = *ite_; 
  } 
  ctr++; 
 } 
 return ok; 
} 
 
              
ILOCPGOALWRAPPER1(MyAssignAlternative, solver, IlcSchedule, sched) { 
// return IlcAssignAlternative(sched, maxCapacitySelector, minPossibleSelector); 
 return IlcAssignAlternative(sched, randResourceSelector, minPossibleSelector); 
} 
 
/////////////////////////////////////////////////////////////////// 
// 
// TEXTURE CHOICE POINT FOR SCHEDULING WITH ALTERNATIVES 
// 
/////////////////////////////////////////////////////////////////// 

//see Solver 5.1 User Manual for a detailed description
 
class AltTextureGoalI : public IlcGoalI { 
private: 
  IlcSchedule _schedule; 
 
protected: 
  IlcResourceTexture chooseResource(); 
  IlcBool choosePair(IlcResourceTexture, 
                     IlcResourceConstraint&, 
                     IlcResourceConstraint&, IlcFloat&); 
  IlcBool chooseSequence(IlcResourceConstraint&, 
                         IlcResourceConstraint&, 
                         IlcResourceConstraint, 
                         IlcResourceConstraint); 
  IlcBool calcBiasedSlack(IlcResourceConstraint, 
                          IlcResourceConstraint, 
                          IlcFloat&, IlcFloat&); 
  IlcBool chooseAlternative(IlcResourceTexture, 
                            IlcResourceConstraint&, IlcFloat&); 
 
public: 
  AltTextureGoalI(IlcSchedule s)  
    : IlcGoalI(s.getSolver()), _schedule(s) {} 
  ~AltTextureGoalI() {} 
 
  virtual IlcGoal execute(); 
}; 
 
IlcGoal AltTextureGoalI::execute() { 
 
//  cout<<"execute"<<endl; 
  IlcResourceTexture selectedTexture = chooseResource(); 
  while(0 != selectedTexture.getImpl()) { 
 
    IlcResourceConstraint rctA, rctB, rctC; 
    IlcFloat maxPairCriticality = 0; 
    IlcFloat altCriticality = 0; 
    IlcBool pairFound = choosePair(selectedTexture,  
                                   rctA, rctB, maxPairCriticality); 
    IlcBool altFound = chooseAlternative(selectedTexture,  
                                         rctC, altCriticality); 
 
    if (!pairFound && !altFound) { 
      // If neither a pair nor an alternative is found, then 
      // there are no commitments that this goal can make at 
      // the critical point. 
      selectedTexture.setNoCommitmentsAtCriticalPoint(); 
      selectedTexture = chooseResource(); 
    } 
    else { 
      if (!pairFound ||  
          (altFound && (maxPairCriticality <= altCriticality)))  
        return IlcAnd(IlcTryNotPossible(rctC.getResource(),  
                                        rctC.getAlternative()), 
                      this); 
      else { 
        IlcResourceConstraint before, after; 
        IlcBool sequenceOK = chooseSequence(before, after, 
                                            rctA, rctB); 
        assert(sequenceOK); 
  
        return IlcAnd(IlcTrySetSuccessor(before, after), this); 
      } 
    } 
  } 
//  cout<<"end execute"<<endl; 
 
  return 0; 
} 
 
 
IlcResourceTexture AltTextureGoalI::chooseResource() { 
 
//  cout<<"choose res"<<endl; 
  IlcResourceTexture selectedTexture = 0; 
  IlcFloat criticality = 0; 
 
  for(IlcResourceIterator iter(_schedule); iter.ok(); ++iter) { 
//   cout<<"point1"<<endl; 
    if ((*iter).isDiscreteResource()) { 
//   cout<<*iter<<endl; 
       IlcDiscreteResource res = (IlcDiscreteResource) (*iter); 
      IlcResourceTexture texture = res.getTextureMeasurement(); 
//   cout<<"point2"<<endl; 
//      cout<<texture.getMaxCriticality()<<endl; 
//   cout<<"point2_"<<endl; 
 
      if (texture.getMaxCriticality() > criticality) { 
//   cout<<"point3"<<endl; 
        selectedTexture = texture; 
//   cout<<"point4"<<endl; 
        criticality = texture.getMaxCriticality(); 
//   cout<<"point5"<<endl; 
      } 
    } 
  } 
 
//  cout<<"end choose res"<<endl; 
  return selectedTexture; 
} 
 
IlcBool AltTextureGoalI::choosePair(IlcResourceTexture texture, 
                                    IlcResourceConstraint& rctA, 
                                    IlcResourceConstraint& rctB, 
                                    IlcFloat& maxCriticality) { 
 
// cout<<"choose Pair"<<endl; 
  IlcRCTextureArray rcTextures =  
    texture.getCriticalityOrderedRCTextures(); 
  IlcInt nbRCTextures = rcTextures.getSize(); 
 
  IlcInt i; 
  for(i = 0; i < nbRCTextures - 1;  ++i) { 
 
    IlcFloat c = rcTextures[i].getCriticalContribution(); 
    if (c == 0) 
      return IlcFalse; 
 
    if (!rcTextures[i].hasAlternatives()) { 
      rctA = rcTextures[i].getResourceConstraint(); 
      maxCriticality = c; 
 
      IlcInt j; 
      for(j = i+1; 
          (j < nbRCTextures) && 
           (rcTextures[j].getCriticalContribution() > 0); ++j) { 
 
        if (!rcTextures[j].hasAlternatives()) { 
          rctB = rcTextures[j].getResourceConstraint(); 
  
        if (!rctA.isSucceededBy(rctB) &&  
            !rctB.isSucceededBy(rctA)) { 
            // found the pair to sequence 
            return IlcTrue; 
          } 
        } 
      } 
    } 
  } 
// cout<<"end choose Pair"<<endl; 
 
  return IlcFalse; 
} 
 
IlcBool AltTextureGoalI::chooseSequence( 
                  IlcResourceConstraint& selectedRct1, 
                  IlcResourceConstraint& selectedRct2, 
                  IlcResourceConstraint rctA, 
                  IlcResourceConstraint rctB) { 
 
//  cout<<"sequence"<<endl; 
  IlcFloat biasedSlackBA, biasedSlackAB; 
  if (!calcBiasedSlack(rctA, rctB, 
                       biasedSlackAB, biasedSlackBA)) 
    return IlcFalse; 
 
  selectedRct1 = rctA; 
  selectedRct2 = rctB; 
 
  // pick sequence that preserves the most slack 
  if (biasedSlackAB < biasedSlackBA) { 
    selectedRct1 = rctB; 
    selectedRct2 = rctA; 
  } 
     
//  cout<<"end sequence"<<endl; 
  return IlcTrue; 
} 
 
IlcBool AltTextureGoalI::calcBiasedSlack( 
                        IlcResourceConstraint rctA, 
                        IlcResourceConstraint rctB, 
                        IlcFloat& biasedSlackAB, 
                        IlcFloat& biasedSlackBA) 
{ 
// cout<<"biased slack"<<endl; 
  // The PCPSlack sequencing calculation from: 
  // @InProceedings{Cheng93, 
  //   author = "Smith, S. F. and Cheng, C. C.", 
  //   title = "Slack-based heuristics for constraint satisfaction 
  //           scheduling",  
  //   key = "scheduling", 
  //   year = "1993", 
  //   pages = "139--144", 
  //   booktitle = "Proceedings of the Eleventh National  
  //                Conference on Artificial Intelligence 
  //                (AAAI-93)", 
  // } 
 
  // Returns IlcTrue if the pair has a valid biasedSlack value. 
  // IlcFalse means there is no valid value for this pair (for 
  // example, because they do not overlap).  
 
  IlcActivity actA = rctA.getActivity(); 
  IlcActivity actB = rctB.getActivity(); 
 
  IlcInt estA = actA.getStartMin(); 
  IlcInt lftA = actA.getEndMax(); 
  IlcInt estB = actB.getStartMin(); 
  IlcInt lftB = actB.getEndMax(); 
 
  if ((lftA <= estB) || (lftB <= estA)) 
    // Activities  already sequenced 
    return IlcFalse; 
  
  IlcInt lambda = lftA - estB; 
  IlcInt mu = lftB - estA; 
  IlcInt delta = actA.getProcessingTimeMin() +  
    actB.getProcessingTimeMin(); 
 
  IlcFloat slackAB = mu - delta; 
  IlcFloat slackBA = lambda - delta; 
  IlcFloat rtS; 
   
  // Either (or both) of slackAB and slackBA might be 0! 
  // Assign to 0.1 (note that lambda, delta, and mu are 
  // all integral it is not possible for slackAB or 
  // slackBA to actually be 0.1 by themselves) 
  if (mu == delta) 
    slackAB = 0.1; 
 
  if (lambda == delta) 
    slackBA = 0.1; 
 
  if (slackAB < slackBA) 
    rtS = sqrt(slackAB / slackBA); 
  else 
    rtS = sqrt(slackBA / slackAB); 
 
  biasedSlackAB = slackAB / rtS; 
  biasedSlackBA = slackBA / rtS; 
// cout<<"end biased slack"<<endl; 
 
  return IlcTrue; 
} 
 
IlcBool AltTextureGoalI::chooseAlternative( 
                            IlcResourceTexture texture, 
                            IlcResourceConstraint& altRC, 
                            IlcFloat& criticality) { 
 
// cout<<"chooseAlt"<<endl; 
 
  IlcRCTextureArray rcTextures = 
    texture.getCriticalityOrderedRCTextures(); 
  IlcInt nbRCTextures = rcTextures.getSize(); 
 
  for(IlcInt i = 0; i < nbRCTextures; ++i) { 
    IlcFloat c = rcTextures[i].getCriticalContribution(); 
    if (c == 0) 
      return IlcFalse; 
    if (rcTextures[i].hasAlternatives()) { 
      // rcTextures is sorted in descending order of 
      // criticality so the first rct we find with 
      // alternatives is the one with the highest crit. 
      altRC = rcTextures[i].getResourceConstraint(); 
      criticality = c; 
      return IlcTrue; 
    } 
  } 
// cout<<"end chooseAlt"<<endl; 
 
  return IlcFalse; 
} 
 
 
ILOCPGOALWRAPPER1(AltTextureIloGoal, solver, IloNumVar, cost) { 
  IlcScheduler scheduler(solver); 
  return IlcAnd(IlcGoal(new (solver.getHeap())  
                                AltTextureGoalI(scheduler)), 
                IlcInstantiate(solver.getIntVar(cost))); 
} 
  
inline int myRound(double x) { 
 return (int) (x+0.5); 
} 
 
inline IloNum getEarliestStartTime (IloInt i) {  
 return VrpData[i][3];  
}  
  
inline IloNum getLatestEndTime (IloInt i) {  
 return VrpData[i][4];  
}  
  
inline IloNum getActivityDuration (IloInt i) {  
 return VrpData[i][1];  
}  
 
inline IloNum getDemand (IloInt i) { 
 return VrpData[i][2]; 
} 
 
IloModel DefineModel(const IloEnv env,   
                     const IloBool VRPFlag, 
      const IloNumVarArray& costOnResource, 
      IloNumVar& transCostSum,  
      IloNumVarArray& transCostArr,  
      IloNumVarArray& selectedMachines, 
      IloNumVarArray& selMachinesVarArr, 
      IloTransitionParam& ttParam,  
      IloTransitionParam& tcParam,  
      int** arrOfAllowedResources, 
//      IloNumVar& desiredNb, 
      IloSchedulerSolution& solution, 
      ifstream& fin1, 
      ofstream& fout, 
      IloNumVar& makespan, 
      IloNumVar& CriterionVar) {  
  
 IloModel model(env);  
 IloInt i,j;  
 char buffer[128];  
 
 IloNum origin  = OriginGlob; 
 IloNum horizon = HorizonGlob;  
 //we have to extend the horizon by 2 units of time 
 //because our setup and teardown 
 //activities are of duration 1 each (we can't make their durations 0). 
  
 IloSchedulerEnv schedEnv(env);  
 solution = IloSchedulerSolution(env); 
  
 schedEnv.getResourceParam().setCapacityEnforcement(IloHigh);  
 schedEnv.getResourceParam().setPrecedenceEnforcement(IloHigh);  
 schedEnv.setHorizon(horizon);  
 IloRCTextureFactory rcFactory = IloRCTextureProbabilisticFactory(env); 
 schedEnv.getTextureParam().setRCTextureFactory(rcFactory); 
 
 IloTextureCriticalityCalculator critCalc = 
    IloProbabilisticCriticalityCalculator(env); 
 schedEnv.getTextureParam().setCriticalityCalculator(critCalc); 
 
 //Initializing resources 
 unarResources = IloUnaryResourceArray(env,NbMachines); 
  
 for (i = 0;i<NbMachines;i++) {  
  sprintf(buffer,"%d", i+1);    
  unarResources[i] = IloUnaryResource(env, buffer);  
  unarResources[i].setCapacityMax(origin,horizon,1);  
  unarResources[i].setCapacityMin(origin,horizon,0);  
  solution.add(unarResources[i]); 
 }  
  
 //transition times and costs  
 ttParam = IloTransitionParam(env, NbActPerTour, IloFalse);  
 tcParam = IloTransitionParam(env, NbActPerTour, IloFalse);   
  
 for (i = 0; i < NbActPerTour; i++) {  
  for (j = 0; j < NbActPerTour; j++) {  
   ttParam.setValue(i,j,TransMatrRead[i][j]);  
   //fout<<ttParam.getValue(i,j)<<" "; 
   tcParam.setValue(i,j,TransMatrRead[i][j]);  
  }  
  //fout<<endl; 
 }   
  
 SetupActivityDuration = VrpData[0][1]; 
 TeardownActivityDuration = VrpData[0][1]; 
 
 IloTransitionCost enrTrans;  
  
 for (i = 0; i<NbMachines; i++) {  
  IloTransitionTime TTObject = IloTransitionTime(unarResources[i],ttParam);  
  enrTrans = IloTransitionCost(unarResources[i],tcParam);  
  model.add(transCostArr[i]==enrTrans.getCostSumVar());  
 }  
  
 model.add(IloSum(transCostArr) == transCostSum);  
  
 //activities 
 activities = IloActivityArray(env,NbAct); 
  
 //Each activity should have a unique name   
 //and its distinct transition type   
 
  
 //Setup activities. They consume nothing  
  
 IloInt index = 1;  
 for (i = 0;i<NbMachines;i++) {  
  sprintf(buffer, "setup%d",index);  
  activities[i] = IloActivity(env, SetupActivityDuration, 0, buffer);  
  solution.add(activities[i]); 
  index++;  
 }  
   
 //actual activities  
 index = 1;  
 for (i = NbMachines; i<NbAct-NbMachines; i++) {  
  sprintf(buffer,"%d", index);  
  activities[i] = IloActivity(env, getActivityDuration(index), index, buffer);  
  solution.add(activities[i]); 
  index++;  
 }  
  
 //teardown activities. They consume nothing  
 index = 1;  
 for (i = NbAct-NbMachines; i<NbAct; i++) {  
  sprintf(buffer, "teardown%d", index);  
  activities[i] = IloActivity(env, TeardownActivityDuration, NbActPerTour-1, buffer);  
  solution.add(activities[i]); 
  index++;  
 }  
  
 for (i = 0;i<NbMachines;i++) {  
  if (!activateAltVRPCriterion) { 
   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
   //model.add(activities[i].startsAfter(origin));  
   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
   model.add(activities[i].startsAt(origin));  
  } else { 
   model.add(activities[i].startsAt(origin));  
  } 
 }  
 
 index = 1;  
 for (i = NbMachines; i<NbAct-NbMachines; i++) {  
  model.add(activities[i].startsAfter(getEarliestStartTime(index)));  
  model.add(activities[i].endsBefore(getLatestEndTime(index)));  
  index++;  
 }  
 
 for (i = NbAct-NbMachines; i<NbAct; i++) {  
  model.add(activities[i].endsBefore(horizon));  
  if (!VRPFlag)  
   model.add(activities[i].endsBefore(makespan));  
 } 
  
 //Resource constraints  
 IloResourceConstraint rc1,rc2;  
 for (i = 0; i<NbMachines; i++) {  
  rc1 = activities[i].requires(unarResources[i]);  
  rc1.setSetup();  
  model.add(rc1);  
 }  
  
 //Creating an alternative set of unary resources  
 //and taking into consideration capacity constraints 
 
 //so far our capacity constraints are nothing but the number of 
 //tasks per machine, each task having a demand of 1, each resource  
 //having a capacity of NbCustomers. Therefore, capacity is unconstrained. 
 
 selected = IloNumVarArray (env,NbMachines*NbAct,0,1,ILOINT);  
 
 alternativeArr  = IloArray<IloAltResConstraint> (env,NbCustomers);  
 
 //here we scan the input file where for a particular activity 
 //there is a list of indexes of those resources that can perform 
 //the activity 
 
 IloAltResSet ResourcesAltSet(env); 
 for (j=0;j<NbMachines;j++) { 
  ResourcesAltSet.add(unarResources[j]); 
 } 
 
 for (i=NbMachines;i<NbAct-NbMachines;i++) { 
 
  IloAltResConstraint alternative = activities[i].requires(ResourcesAltSet,1);  
  alternativeArr[i-NbMachines] = alternative; 
 
  for (j=0;j<NbMachines;j++) { //iterating over the resources in alt res set 
   IloBool allowedFlag = IloFalse; 
//   cout<<"resource = "<<j<<" "; 
   for (int k=0;k<NbMachines;k++) {//interating over indexes of allowed resources for act_i 
    if (j+1==arrOfAllowedResources[i-NbMachines][k]) { 
     allowedFlag = IloTrue; 
    } 
    if (allowedFlag) break; 
   } 
 
   if (!allowedFlag) { 
//    cout<<"resource "<<j+1<<" disallowed for act "<<i-NbMachines+1<<endl; 
    alternative.setRejected(unarResources[j]); 
   } else { 
//    cout<<"resource "<<j+1<<" allowed for act "<<i-NbMachines+1<<endl; 
   } 
  } 
 
  for (j=0;j<NbMachines;j++) {                           //for machines 
   model.add((alternative.select(unarResources[j])) == 
          (selected[j*NbAct+(i-NbMachines)]==1  
       && selectedMachines[j]==1  
       && selMachinesVarArr[i-NbMachines]==j)); 
  } 
 
  model.add(alternative); 
 } 
 
 //modelling diff-vehicles side constraints; 
 //The 1D array DiffArr contains DiffNb pairs of activities that MUST be on diff vehicles 
 
 for (i=0;i<2*DiffNb;i++) { 
  if (i % 2 != 0) continue; 
  model.add(selMachinesVarArr[DiffArr[i]-1]!=selMachinesVarArr[DiffArr[i+1]-1]); 
 } 
 
 //modelling same-vehicles side constraints; 
 //The 1D array SameArr contains SameNb pairs of activities each of which MUST be on the same vehicle 
 
 for (i=0;i<2*SameNb;i++) { 
  if (i % 2 != 0) continue; 
  model.add(selMachinesVarArr[SameArr[i]-1]==selMachinesVarArr[SameArr[i+1]-1]); 
 } 
 
 //taking into account capacities by means of using the array selected  
 IloExpr expr(env), expr_(env); 
 
 for (j=0;j<NbMachines;j++) { 
  for (int ii=NbMachines;ii<NbAct-NbMachines;ii++) { 
   expr += selected[j*NbAct+(ii-NbMachines)]*getDemand(ii-NbMachines+1); 
  } 
  model.add(expr<=Capacities[j]); 
  expr.remove(selected); 
 } 
 
/* int sum_ = 0; 
 for (i=0;i<NbCustomers;i++) { 
  sum_ += getActivityDuration(i+1); 
 } 
 fout<<" sum_ = "<<sum_<<endl; 
*/ 
 
 //modelling precedence constraints 
 for (i=0;i<2*PrecedenceNb;i++) { 
  if (i % 2 != 0) continue; 
  model.add(activities[PrecedenceArr[i+1]+NbMachines-1]. 
         startsAfterEnd(activities[PrecedenceArr[i]+NbMachines-1])); 
 } 
 
 
 index = 0;  
 for (i = NbAct-NbMachines; i<NbAct; i++) {  
  rc1 = activities[i].requires(unarResources[index]);  
  rc1.setTeardown();  
  model.add(rc1);  
  index++;  
 }  
 
 //this piece of code is for the modified VRP-like criterion 
 //which amounts to minimising the sum of makespans on all machines 
 //for pure VRP the difference will only be in the sum of durations; 
 //for pure JSP it is only meaningful as sum of transition costs on 
 //all machines is trivially equal to 0. 
 
 if (activateAltVRPCriterion) { 
  for (i=0;i<NbMachines;i++) {//machines 
    
   //taking into account setup activities 
   model.add(minStart[i] <= activities[i].getStartVariable()); 
   model.add(maxEnd[i] >= activities[i].getEndVariable()); 
 
   //this is not necessary 
 //  for (j=0;j<NbAct-2*NbMachines;j++) {// actual, real, useful activities 
 //   model.add((alternativeArr[j].select(unarResources[i])) <= 
 //          (minStart[i] <= alternativeArr[j].getActivity().getStartVariable())); 
 //   model.add((alternativeArr[j].select(unarResources[i])) <= 
 //          (maxEnd[i] >= alternativeArr[j].getActivity().getEndVariable())); 
 //  } 
    
   //taking into account teardown activities 
   model.add(minStart[i] <= activities[i+NbAct-NbMachines].getStartVariable()); 
   model.add(maxEnd[i] >= activities[i+NbAct-NbMachines].getEndVariable()); 
 
   model.add(costOnResource[i] == maxEnd[i] - minStart[i]); 
  } 
 
  model.add(CriterionVar == IloSum(costOnResource)); 
 } 
 
 //adding for future extraction by the solver  
 model.add(transCostSum);  
 solution.add(transCostSum); 
 model.add(transCostArr);  
 
 model.add(selectedMachines); 
 model.add(selected); 
 
 model.add(makespan); 
 model.add(costOnResource); 
 model.add(minStart); 
 model.add(maxEnd); 
 model.add(CriterionVar); 
// model.add(IloMinimize(env,CriterionVar)); 
// model.add(IloMinimize(env,makespan)); 
 
 return model;  
}  
 
///////////////////////////////////////////////////////////////////////////////  
//  
// PRINTING SOLUTIONS  
//  
///////////////////////////////////////////////////////////////////////////////  
 
void PrintSolution(const IloSolver solver,   
       const IloNumVarArray costOnResource, 
       const IloBool VRPFlag, 
       const IloNumVar transCostSum,   
       const IloNumVarArray transCostArr,  
       const IloNumVarArray selectedMachines,  
       ofstream& fout,  
       ofstream& fout1,  
       ofstream& fout2,  
       const IloInt SolutionNb,  
       const IloInt NbFailsSummed,  
       const IloInt NbChoicePointsSummed, 
       IloBool LastSolution, 
       const IloNumVar makespan, 
       int& NbMachinesUsed, 
       bool isIntermediateOutputPointReached) 
{  
 
 IlcScheduler scheduler(solver);  
 IloEnv env = solver.getEnv();  
 NbMachinesUsed = 0;  
 
 const IloAny ACTIVITY_PRINTED = (IloAny)1;  
 if (LastSolution) { 
  fout1<<GlobalVarTimeLimit<<" "<<NbFailsSummed<<" "<<SolutionNb-1 
    <<" "<<LastNbOfMachinesUsed<<" "<<TrueCost<<" "; 
 } else { 
 
  fout2 <<Problem<<endl;  
  fout2 <<TrueCost<<endl;  
 
  //output tours 
 
  for (IlcUnaryResourceIterator ur_(scheduler); ur_.ok(); ++ur_) { 
   IlcUnaryResource machine =*ur_; 
   IlcInt index = machine.getSetupVar().getValue(); 
//   fout<<"index = "<<index<<endl; 
   IlcInt sink = machine.getTeardownIndex(); 
//   fout<<"sink = "<<sink<<endl; 
   IlcInt source = machine.getSetupIndex(); 
//   fout<<"source = "<<source<<endl; 
   IloBool notEmpty = IloFalse, vehIndexWritten = IloFalse; 
    
   while (index != sink) { 
    IlcResourceConstraint task = machine.getSequenceRC(index); 
    index = task.getNextVar().getValue(); 
 
    if (index != sink && task.getPrevVar().getValue() !=source) { 
    if (!vehIndexWritten) { 
      vehIndexWritten = IloTrue; 
    } 
    notEmpty = IloTrue; 
    } 
   } 
   if (notEmpty) NbMachinesUsed++; 
  } 
  fout2<<NbMachinesUsed<<endl; 
  fout << "Solution: "<<NbMachinesUsed<<"/"<<TrueCost<<endl;  
  fout << endl; 
 
  if (isIntermediateOutputPointReached) fout1<<NbMachinesUsed<<" "<<TrueCost<<" ";  
   
 
  for (IlcUnaryResourceIterator ur_I(scheduler); ur_I.ok(); ++ur_I) { 
   IlcUnaryResource machine =*ur_I; 
   fout<<endl<<"machine "<<machine.getName()<<endl; 
   IlcInt index = machine.getSetupVar().getValue(); 
   IlcInt sink = machine.getTeardownIndex(); 
   IlcInt source = machine.getSetupIndex(); 
   IloBool notEmpty = IloFalse, vehIndexWritten = IloFalse; 
    
   while (index != sink) { 
    IlcResourceConstraint task = machine.getSequenceRC(index); 
    fout<<"\t"<<"task "<<task.getActivity()<<endl; 
    index = task.getNextVar().getValue(); 
 
    if (index != sink && task.getPrevVar().getValue() !=source) { 
    if (!vehIndexWritten) { 
      fout2<<machine.getName(); 
      vehIndexWritten = IloTrue; 
    } 
    fout2<<" "<<task.getActivity().getName(); 
    notEmpty = IloTrue; 
    } 
   } 
   if (notEmpty) fout2<<" -1"<<endl; 
  } 
 
   fout<<endl;  
   fout << "Number of fails             : " << solver.getNumberOfFails()<<endl;  
   fout << "Number of choice points     : " << solver.getNumberOfChoicePoints()<<endl;  
   fout << "Number of constraints       : " << solver.getNumberOfConstraints()<<endl;  
   fout << "Elapsed time since creation : " << solver.getTime()<<endl;  
 
   fout<<endl;  
//  fout<<"The sums of transition costs on each machine: "<<endl;  
 
  if (VRPFlag || activateAltVRPCriterion) { 
 
//   for (int i = 0; i<NbMachines; i++) {  
//   fout<<"transCostArr["<<i<<"]: min = "<<solver.getIntVar(transCostArr[i]).getMin()  
 //    <<" max = "<<solver.getIntVar(transCostArr[i]).getMax()<<endl; 
   //if (solver.getIntVar(transCostArr[i]).getMin()!=0) NbMachinesUsed++;  
//   } 
  } 
  
//  fout<<"The sums of operation durations on each machine: "<<endl;  
//  for (int i = 0;i<NbMachines;i++) { 
//  fout<<"costOnResource["<<i<<"]: min = "<<solver.getIntVar(costOnResource[i]).getMin()  
//   <<" max = "<<solver.getIntVar(costOnResource[i]).getMax()<<endl; 
//  } 
 
//  fout<<"min starts on each machine: "<<endl;  
//  for (i = 0;i<NbMachines;i++) { 
//  fout<<"minStart["<<i<<"]: min = "<<solver.getIntVar(minStart[i]).getMin()  
//   <<" max = "<<solver.getIntVar(minStart[i]).getMax()<<endl; 
//  } 
//  fout<<"max ends on each machine: "<<endl;  
//  for (i = 0;i<NbMachines;i++) { 
//  fout<<"maxEnd["<<i<<"]: min = "<<solver.getIntVar(maxEnd[i]).getMin()  
//   <<" max = "<<solver.getIntVar(maxEnd[i]).getMax()<<endl; 
//  } 
  
/*  fout<<"selected: "<<endl;  
  for (i = 0;i<NbMachines;i++) {//machines 
   for (int j = NbMachines; j<NbAct-NbMachines; j++) { 
   fout<<"selected["<<i*NbAct+j<<"]: min = "<<solver.getIntVar(selected[i*NbAct+j-NbMachines]).getMin()  
    <<" max = "<<solver.getIntVar(selected[i*NbAct+j-NbMachines]).getMax()<<endl; 
   } 
 
  } 
  fout<<"selMachinesVarArr: "<<endl;  
  for (int j = NbMachines; j<NbAct-NbMachines; j++) { 
  fout<<"selMachinesVarArr["<<j-NbMachines+1<<"]: min = "<<solver.getIntVar(selectedMachinesVarArr[j-NbMachines]).getMin()  
   <<" max = "<<solver.getIntVar(selectedMachinesVarArr[j-NbMachines]).getMax()<<endl; 
  } 
*/   
 LastNbOfMachinesUsed = NbMachinesUsed; 
  
 if (VRPFlag) { 
 
  fout<<endl;  
  fout<<"The sum of transition costs on all machines: "  
   <<" min = "<<solver.getIntVar(transCostSum).getMin()  
   <<" max = "<<solver.getIntVar(transCostSum).getMax()<<endl;  
 } 
 
 if (SolutionNb==1) { 
  fout1<<NbMachinesUsed<<" "<<TrueCost<<" "; 
 } 
 } 
 
}  
 
 
void ReadInSideConstraints(char * buf,  
         IloInt*& Array,  
         IloInt& NumberOfTasks, 
         FILE*& fin,  
         ofstream& fout) { 
 
 
 char buf_read[30]; 
 
 fscanf(fin,"%s",&buf_read); 
 if (strcmp(buf_read,buf)) { 
  cout<<"There should be "<<buf<<" keyword in input file"<<endl; 
  exit(1); 
 } 
 
 fscanf(fin,"%Ld",&NumberOfTasks); 
 
 Array = new IloInt [2*NumberOfTasks]; 
 
 for (int i=0;i<2*NumberOfTasks;i++) { 
  fscanf(fin,"%Ld",&Array[i]); 
 } 
 
} 
 
void ReadInSolutions(IloModel& model,  
      int NbVeh,  
      int NbVis, 
      ifstream& fin,  
      ofstream& fout) { 
 
////////////////////////////////////////////////////////////////////////////////////// 
// 
// solutions to be read in have to be in output format of project VisualiseSolution 
// 
////////////////////////////////////////////////////////////////////////////////////// 
 
 int ctrMax = NbVis+2*NbVeh; 
 double x,y; 
 int ctr = 0, ctrConstr = 0; 
 int visID1 = 0, visID2 = 0, vehID = 0; 
 int vehID_ = 0; 
 int ctr_ = 0; 
 while (ctr<ctrMax) { 
   
  fin>>vehID>>visID1>>x>>y; 
 
  if (visID1!=0) { 
//   cout<<visID1<<" on resource "<<vehID<<endl; 
   AddedConstraintsArr[ctrConstr] = alternativeArr[visID1-1].select(unarResources[vehID-1]); 
   ctrConstr++; 
   if (visID2!=0) { 
//    cout<<visID2<<", "<<visID1<<" on resource "<<vehID<<endl; 
    AddedConstraintsArr[ctrConstr] = activities[NbVeh+visID1-1].startsAfterEnd(activities[NbVeh+visID2-1]); 
    ctrConstr++; 
   } 
   visID2 = visID1; 
  } else { 
   visID2 = 0;    
  } 
  ctr++; 
 } 
 
 GlobalNumberOfAddedConstraints = ctrConstr; 
 for (int i=0;i<GlobalNumberOfAddedConstraints;i++) { 
  model.add(AddedConstraintsArr[i]); 
 } 
 
} 
 
void processComments(FILE* infile, char * & problem, int& ctr, char *& type) { 
  
 char buf[80000]; 
 
 int i; 
 ctr = 0; 
 while (true) { 
  fgets(buf,80000,infile); 
  if (buf[0]!='#') { 
   type = buf; 
   ctr++; 
   break; 
  } else { 
   ctr++; 
  } 
 } 
 fclose(infile); 
 
 if ((infile=fopen(problem,"r"))==NULL) { 
  cout<<"Couldn't open"<<problem<<endl; 
 } 
 for (i=0;i<ctr;i++) { 
  fgets(buf,80000,infile); 
 } 
} 
 
///////////////////////////////////////////////////////////////////////////////  
//  
// MAIN FUNCTION  
//  
///////////////////////////////////////////////////////////////////////////////  
 
int main(int argc, char* argv[]) {  
  
  try {  
  
 IloEnv env;  
  
 if (argc>15 || argc<14) {  
  cout<<endl;  
  cout<<"Usage A: <file_name>.exe <data_file_name> <sol_file_name>\n"; 
  cout<<"         <resfile1_name> <resfile2_name> <resfile3_name>\n";  
  cout<<"         ResourceSelector <1..4> ResConstrSelector <1..4>\n";  
  cout<<"         AltResSelector <1..4> DiscrepancyCount <1,2,..> TimeLimit <s> FailLimit <int>\n";  
  cout<<"         OutputStartFlag<1/0> ReadInFirstSolution<1> RandSeed\n"; 
  cout<<endl; 
  cout<<"Usage B: <file_name>.exe <data_file_name>\n"; 
  cout<<"         <resfile1_name> <resfile2_name> <resfile3_name>\n";  
  cout<<"         ResourceSelector <1..4> ResConstrSelector <1..4>\n";  
  cout<<"         AltResSelector <1..4> DiscrepancyCount <1,2,..> TimeLimit <s> FailLimit <int>\n";  
  cout<<"         OutputStartFlag<1/0> ReadInFirstSolution<0> RandSeed\n"; 
  return 0;  
 }  
 
 ofstream fout,fout1,fout2;  
 ifstream fin1;  
 FILE* fin; 
 IloBool startFlag; 
  
 if (argc==15) { 
  startFlag = atoi(argv[12]); 
  Problem = argv[1]; 
  if ((fin=fopen(Problem,"r"))==NULL) { 
   cout<<"Couldn't open "<<Problem<<endl; 
  } 
 
  fin1.open(argv[2], ios::in);  
  sprintf(SolFile,argv[2]); 
 
  fout.open(argv[3], ios::out); 
 
  if (!fin1) {   
    env.out() << endl; 
    env.out() << "File " << SolFile <<" not found or not specified"<<endl;  
    env.end();  
    return 0;  
  }  
 
  if (startFlag) {  
   fout1.open(argv[4], ios::out);  
  } else { 
   fout1.open(argv[4], ios::app);  
  } 
 
  StandFormatFile = argv[5]; 
 
 } else { //argc==12 only 
  startFlag = atoi(argv[11]); 
  Problem = argv[1]; 
 
  if ((fin=fopen(Problem,"r"))==NULL) { 
   cout<<"Couldn't open "<<Problem<<endl; 
  } 
  fout.open(argv[2], ios::out); 
 
  if (startFlag) {  
   fout1.open(argv[3], ios::out);  
  } else { 
   fout1.open(argv[3], ios::app);  
  } 
 
  StandFormatFile = argv[4]; 
 
 } 
 
    if (!fin) {   
      env.out() << endl; 
      env.out() << "File " << Problem <<" not found or not specified"<<endl;  
      env.end();  
      return 0;  
    }  
 
 cout<<endl; 
 cout<<Problem<<" is being solved by Scheduler"<<endl; 
 
 
    if (!fout) {   
      env.out() << endl; 
      env.out() << "Cannot open file 1: "<<fout<<" for output" << endl;  
      env.end();  
      return 0;  
    }  
 
 if (!fout1) {   
   env.out() << endl; 
   env.out() << "Cannot open file 2: "<<fout1<<" for output" << endl;  
   env.end();  
   return 0;  
 }  
 
 fout2.open(StandFormatFile, ios::out); 
 
 if (!fout2) {   
   env.out() << endl; 
   env.out() << "Cannot open file 3: "<<fout2<<" for output" << endl;  
   env.end();  
   return 0;  
 }  
 
 int ctr = 0; 
 char * TypeOfProb; 
 processComments(fin,Problem,ctr,TypeOfProb); 
 
 if (TypeOfProb[0]=='V' && 
  TypeOfProb[1]=='R' && 
  TypeOfProb[2]=='P') { 
  VRPFlag = IloTrue; 
 } else { 
  VRPFlag = IloFalse; 
 } 
 
 fscanf(fin,"%Ld",&NbMachines); 
 fscanf(fin,"%Ld",&NbCustomers); 
 
 fout<<"TypeOfProblem              : "<<TypeOfProb;  
 fout<<"NbMachines                 : "<<NbMachines<<endl;  
 fout<<"NbCustomers                : "<<NbCustomers<<endl;  
 
 if (argc==15) ResourceSelector = atoi(argv[6]);  
 else ResourceSelector = atoi(argv[5]);  
 fout<<"ResourceSelector           : "<<ResourceSelector<<endl;   
 
 if (argc==15) ResourceConstraintSelector = atoi(argv[7]);  
 else ResourceConstraintSelector = atoi(argv[6]);  
 fout<<"ResourceConstraintSelector : "<<ResourceConstraintSelector<<endl;   
 
 if (argc==15) PossibleResourceSelector = atoi(argv[8]);  
 else PossibleResourceSelector = atoi(argv[7]); 
 fout<<"PossibleResourceSelector   : "<<PossibleResourceSelector<<endl;   
 
 if (argc==15) DiscrepancyCount = atoi(argv[9]);  
 else DiscrepancyCount = atoi(argv[8]);  
 fout<<"DiscrepancyCount           : "<<DiscrepancyCount<<endl;   
 
 if (argc==15) BasicTimeLimit = atoi(argv[10]);  
 else BasicTimeLimit = atoi(argv[9]);   
 fout<<"BasicTimeLimit             : "<<BasicTimeLimit<<endl;   
 
 if (argc==15) BasicFailLimit = (unsigned int) atof(argv[11]);  
 else BasicFailLimit = (unsigned int) atof(argv[10]);   
 fout<<"BasicFailLimit             : "<<BasicFailLimit<<endl;   
 
 if (argc==15) ReadFirstSolutionFromFile = atoi(argv[13]); 
 else ReadFirstSolutionFromFile = atoi(argv[12]); 
 fout<<"ReadFirstSolutionFromFile  : "<<ReadFirstSolutionFromFile<<endl;   
 
 if (argc==15) GlobSeed = (unsigned int) atof(argv[14]); 
 else GlobSeed = (unsigned int) atof(argv[13]); 
 fout<<"GlobSeed : "<<GlobSeed<<endl;   
 
 srand(GlobSeed); 
  
 if (ReadFirstSolutionFromFile && argc==14) { 
  cout<<"Type VrpSched51.exe and check input parameters"<<endl; 
  return 0; 
 } 
 
 if (!ReadFirstSolutionFromFile && argc==15) { 
  cout<<"Type VrpSched51.exe and check input parameters"<<endl; 
  return 0; 
 }  
  
 IloResourceSelector rSel;  
 if (ResourceSelector==1) rSel = IloSelResMinGlobalSlack; //default  
 if (ResourceSelector==2) rSel = IloSelResMinLocalSlack;  
 if (ResourceSelector==3) rSel = IloSelResSequenceMinGlobalSlack;  
 if (ResourceSelector==4) rSel = IloSelResSequenceMinLocalSlack;  
  
 IloResourceConstraintSelector rcSel;  
 if (ResourceConstraintSelector==1) rcSel = IloSelFirstRCMinEndMax; //default  
 if (ResourceConstraintSelector==2) rcSel = IloSelFirstRCMinStartMax;  
 if (ResourceConstraintSelector==3) rcSel = IloSelLastRCMaxEndMin;  
 if (ResourceConstraintSelector==4) rcSel = IloSelLastRCMaxStartMin;  
  
 IloResourceSelector prSel;  
 if (PossibleResourceSelector==1) prSel = IloSelResMinGlobalSlack;  
 if (PossibleResourceSelector==2) prSel = IloSelResMinLocalSlack;  
 if (PossibleResourceSelector==3) prSel = IloSelResMinCapacity;  
 if (PossibleResourceSelector==4) prSel = IloSelAltRes; //default  
 
 
 NbAct = NbCustomers + 2 + 2*(NbMachines - 1);   
 NbActPerTour = NbCustomers + 2;   
 
 fscanf(fin,"%Lf",&SpeedParameter); 
 //SpeedParameter = SpeedParameter*160.9/60; //decameters per minute 
 fout<<"SpeedParameter = "<<SpeedParameter<<endl; 
 
 ctr = 0; 
 
 /////////////////////////////////////////////////////////////////////////////  
    //  
    // Reading in data from the data file that is in format of note 760 
    //  
    /////////////////////////////////////////////////////////////////////////////  
 
 IloInt i;  
 
 //We use the TransMatrRead matrix to store the read in data 
 IloInt size = NbActPerTour; 
 
 TransMatrRead = new (env) IloInt * [size]; 
 VrpData = new (env) IloNum * [NbCustomers+1]; 
 
 Capacities = new (env) IloInt [NbMachines]; 
 
 for (i=0;i<size;i++) { 
  TransMatrRead[i] = new IloInt [size]; 
 } 
 for (i=0;i<size;i++) { 
  for (int j=0;j<size;j++) { 
   TransMatrRead[i][j]=0; 
  } 
 } 
 for (i=0;i<size;i++) { 
  VrpData[i] = new IloNum [NbMachines+7]; 
 } 
 for (i=0;i<size;i++) { 
  for (int j=0;j<NbMachines+7;j++) { 
   VrpData[i][j] = 0; 
  } 
 } 
 
 VrpData[0][0] = 0; //id of depot is 0; 
 VrpData[0][1] = 1; //setup & teardown durations; 
 VrpData[0][2] = 1; //demand; 
  
 fscanf(fin,"%Lf",&VrpData[0][3]); 
 fscanf(fin,"%Lf",&VrpData[0][4]); 
 fscanf(fin,"%Lf",&VrpData[0][5]); 
 fscanf(fin,"%Lf",&VrpData[0][6]); 
 
 //fin>>VrpData[0][3]>>VrpData[0][4]>>VrpData[0][5]>>VrpData[0][6]; 
 
 int** arrayOfAllowedVehicles; 
 arrayOfAllowedVehicles = new int* [NbCustomers]; 
 for (i=0;i<NbCustomers;i++) { 
  arrayOfAllowedVehicles[i] = new int [NbMachines]; 
 } 
 for (i=0;i<NbCustomers;i++) { 
  for (int j=0;j<NbMachines;j++) {  
   arrayOfAllowedVehicles[i][j] = -1; 
  } 
 } 
 
 char postcode1[30], postcode2[30]; 
 
 for (i=1;i<=NbCustomers;i++) { 
  for (int j=0;j<3;j++)  
   fscanf(fin,"%Lf",&VrpData[i][j]); 
   fscanf(fin,"%s%s",&postcode1,&postcode2); 
  for (j=3;j<7;j++)  
   fscanf(fin,"%Lf",&VrpData[i][j]); 
  IloNum index = 0; 
  IloInt ctr = 0; 
  while(index!=-1) { 
   fscanf(fin,"%Lf",&index); 
   VrpData[i][ctr+7] = index; 
   ctr++; 
  } 
 } 
 
 for (i=1;i<=NbCustomers;i++) { 
  for (int j=7;j<NbMachines+7;j++) { 
   if (VrpData[i][j]==0) break; 
   arrayOfAllowedVehicles[i-1][j-7] = VrpData[i][j]; 
  } 
 } 
 
 for (i=0;i<size-1;i++) { 
  for (int j=0;j<size-1;j++) { 
   fscanf(fin,"%Ld",&TransMatrRead[i][j]); //from fin we read in the transformed distance matrix and vrp file 
  } 
 } 
 
//////////////////////////////////////////////////////////////////////// 
// statistics 
//////////////////////////////////////////////////////////////////////// 
 IloNum** matr; 
 matr = new (env) IloNum * [size]; 
 for (i=0;i<size;i++) { 
  matr[i] = new (env) IloNum [size]; 
 } 
 for (i=0;i<size;i++) { 
  for (int j=0;j<size;j++) { 
   matr[i][j]=0; 
  } 
 } 
 
 for (i=0;i<size-1;i++) { 
  for (int j=0;j<size-1;j++) { 
   matr[i][j] = TransMatrRead[i][j]; 
  } 
 } 
 double averDist = 0; 
 for (i=0;i<size-1;i++) { 
  for (int j=0;j<size-1;j++) { 
   averDist += matr[i][j]; 
  } 
 } 
 averDist = 2*averDist/(NbCustomers+1)/NbCustomers; 
 //outputting statistics into file fout1 
 
 double averDur = 0; 
 for (i=1;i<=NbCustomers;i++) { 
  averDur += VrpData[i][1]/NbCustomers; 
 } 
 
 //checking rho 
 fout1<<SpeedParameter*averDur/averDist<<" "; 
 
 //checking slack 
 IloNum aver_norm_slack = 0; 
 for (i=0;i<NbCustomers;i++) { 
  aver_norm_slack += (VrpData[i][4] - VrpData[i][1] - VrpData[i][3])/(VrpData[i][4] - VrpData[i][3])/NbCustomers; 
 } 
 fout1<<aver_norm_slack<<" "; 
 
 ctr = 0; 
 IloNum veh_per_act = 0; 
 for (i=0;i<NbCustomers;i++) { 
  for (int j=0;j<NbMachines;j++) { 
   if (arrayOfAllowedVehicles[i][j]==-1) break; 
   else ctr++; 
  } 
  veh_per_act = ctr/NbCustomers; 
 } 
 
 //checking spec 
 fout1<<veh_per_act<<" "; 
  
 fout1<<averDist<<" "<<averDur<<" "<<SpeedParameter<<" "<<(double) (averDist/SpeedParameter)<<" "; 
 
///////////////////////////////////////////////////////////////////////// 
 
 for (i=0;i<size-1;i++) { 
  TransMatrRead[i][size-1] = TransMatrRead[i][0]; 
 } 
 
 for (i=0;i<size-1;i++) { 
  TransMatrRead[size-1][i] = TransMatrRead[0][i]; 
 } 
  
/* for (i=0;i<size;i++) { 
  for (int j=0;j<size;j++) { 
   fout<<TransMatrRead[i][j]<<" "; 
  } 
  fout<<endl; 
 } 
 
 for (i=0;i<NbCustomers+1;i++) { 
  for (int j=0;j<NbMachines+7;j++) { 
   fout<<VrpData[i][j]<<" "; 
  } 
  fout<<endl; 
 } 
*/ 
 for (i=0;i<size;i++) { 
  for (int j=0;j<size;j++) { 
   TransMatrRead[i][j] = myRound(TransMatrRead[i][j]/SpeedParameter); 
  } 
 } 
 
 OriginGlob = VrpData[0][3];  //time measured in minutes from midnight 
 HorizonGlob = VrpData[0][4]; 
 
 for (i=0;i<NbMachines;i++) { 
  int rubbish; 
  fscanf(fin,"%d%Ld",&rubbish,&Capacities[i]); 
//  fout<<"Capacities["<<i+1<<"] = "<<Capacities[i]<<endl; 
 } 
 
 IloInt count = 0,ii = 0; 
 
 char buf1[30]; 
 
 for (i=0;i<3;i++) { 
  if (i==0) { 
   strcpy(buf1,"Diff"); 
   ReadInSideConstraints((char *) buf1,DiffArr,DiffNb,fin,fout); 
  } 
  if (i==1) { 
   strcpy(buf1,"Same"); 
   ReadInSideConstraints((char *) buf1,SameArr,SameNb,fin,fout); 
  } 
  if (i==2) { 
   strcpy(buf1,"Precedence"); 
   ReadInSideConstraints((char *) buf1,PrecedenceArr,PrecedenceNb,fin,fout); 
  } 
 } 
 
 //transCostSum variable is to store the sum of transition  
 //costs on all machines (more precisely, on all unary  
 //resources associated with machines);  
 //An element of the transCostArr array stores the sum of transition  
 //costs on a particular machine (more precisely, on the   
 //respective unary resource  
 
 IloNumVar transCostSum(env,0,IloInfinity,ILOINT);  
 IloNumVarArray transCostArr(env,NbMachines,0,IloInfinity,ILOINT);  
 IloSchedulerSolution solution(env);  
 IloTransitionParam ttParam, tcParam;  
 IloNumVar makespan(env,0,IloInfinity,ILOINT); 
 CriterionVar = IloNumVar(env,0,IloInfinity,ILOINT); 
 minStart = IloNumVarArray(env,NbMachines,0,IloInfinity,ILOINT); 
 maxEnd = IloNumVarArray(env,NbMachines,0,HorizonGlob,ILOINT); 
 costOnResource = IloNumVarArray(env,NbMachines,0,IloInfinity,ILOINT); 
 
 
 //these two var arrays are necessary to post side constraints 
 selectedMachinesVarArr = IloNumVarArray (env,NbAct-2*NbMachines,0,NbMachines,ILOINT); 
 IloNumVarArray selectedMachines(env,NbMachines,0,1,ILOINT); 
 
 //this array is necessary when reading in the first solution 
 //found by Dispatcher and using this solution, so far, 
 //as the upper bound only.  
 AddedConstraintsArr = IloArray<IloConstraint> (env,10000);  
 
 IloModel model; 
 
 model = DefineModel(env, VRPFlag, 
                          costOnResource, 
        transCostSum,   
        transCostArr,  
        selectedMachines, 
        selectedMachinesVarArr, 
        ttParam,  
        tcParam,  
        arrayOfAllowedVehicles, 
        solution, 
        fin1, 
        fout,makespan, CriterionVar);  
 
 if (ReadFirstSolutionFromFile) ReadInSolutions(model,NbMachines,NbCustomers,fin1,fout); 
 
    // Algorithm  
 IloSolver solver(model);  
 IlcScheduler scheduler(solver);  
 
 solver.setTraceMode(IlcTrue); 
  IlcPrintTrace trace(solver,IlcTraceFail); 
  solver.setTrace(trace); 
 
  IloGoal goal; 
 
 //The Search Goal  
 if (!activateAltVRPCriterion) { 
//  goal = IloRankForward(env,rSel,rcSel) &&IloAssignAlternative(env,prSel); 
//  goal = IloRankForward(env,rSel,rcSel) &&IloAssignAlternative(env,prSel); 
//  goal = MyAssignAlternative(env,scheduler)&&IloRankForward(env,rSel,rcSel) ; 
//  goal = IloAssignAlternative(env,prSel) && IloRankForward(env,rSel,rcSel) && IloSetTimesForward(env); 
  goal = AltTextureIloGoal(env,makespan); 
 } else { 
  if (VRPFlag) { 
   goal = IloAssignAlternative(env,prSel) && IloRankForward(env,rSel,rcSel) && IloSetTimesForward(env); 
  } else { 
   goal = IloRankForward(env,rSel,rcSel) && IloSetTimesForward(env) && IloAssignAlternative(env,prSel); 
  } 
 } 
  
 //Applying LDS  
// goal = IloApply (env, goal, IloLDSEvaluator(env, DiscrepancyCount));  
  
  
 //these are needed for storing statistics: #backtracks, #choice points, time, etc. 
 NbFailsSummed = 0;  
 NbChoicePointsSummed = 0;  
 
 struct tm *ptr;  
 time_t lt;  
  
  
 clock_t start,finish;  
 start = clock();  
  
 lt = time(NULL);  
 ptr = localtime(&lt);  
 fout<<asctime(ptr);  
 cout<<asctime(ptr);  
 
 IloBool LastSolution = IloFalse; 
 
 ///////////////////////////////////////////////////////////// 
 // 
 // Searching for solutions 
 // 
 ///////////////////////////////////////////////////////////// 
 
 IloConstraint additionalConstraint; 
 
 if (VRPFlag) { 
 
  if (solver.solve(IloLimitSearch(env, goal, IloTimeLimit(env, BasicTimeLimit)))) { //if there is a solution  
   finish = clock()-start;  
   fout<<endl;  
   fout<<"****************** Solution 1 ******************"<<endl;  
 
   TrueCost = solver.getIntVar(transCostSum).getMin();  
 
   if (activateAltVRPCriterion) { 
    TrueCost = solver.getIntVar(CriterionVar).getMin(); 
   } 
 
   int NbMachinesUsed; 
   PrintSolution(solver,costOnResource,VRPFlag,transCostSum,transCostArr, selectedMachines, 
              fout,fout1,fout2,1,NbFailsSummed, 
        NbChoicePointsSummed,LastSolution,makespan,NbMachinesUsed, false);  
   fout2.close(); 
   env.out()<<endl;  
   env.out()<<"Solution 1 : "<<NbMachinesUsed<<"/"<<TrueCost<<endl;  
   env.out()<<endl;  
   solver.printInformation();  
   NbFailsSummed += solver.getNumberOfFails();  
   NbChoicePointsSummed += solver.getNumberOfChoicePoints();  
  } else {  
   solver.out() << "No Solutions: Insolubility or CPU-Time Expiry" << endl;  
   lt = time(NULL);  
   ptr = localtime(&lt);  
   fout<<asctime(ptr);  
   cout<<asctime(ptr);  
   fout.close();  
//   fout1<<endl; 
   fout1.close();  
   fout2<<"0"<<endl; 
   fout2.close(); 
   fclose(fin); 
   env.end();  
   return -1; 
  }  
 
 
  if (ReadFirstSolutionFromFile) { 
   for (i=0;i<GlobalNumberOfAddedConstraints;i++) { 
    model.remove(AddedConstraintsArr[i]); 
   } 
  } 
 
  IloInt SolutionCtr = 2;  
 
  IloNum TimeSpent = (double) finish / CLOCKS_PER_SEC;  
  cout<<"TimeSpent : "<<TimeSpent<<endl;  
  
  IloNum TimeLimit = BasicTimeLimit - TimeSpent;  
  cout<<"TimeLimit : "<<TimeLimit<<endl;  
  
  start = clock();  
 
  if (activateAltVRPCriterion) { 
   additionalConstraint = IloConstraint(CriterionVar <= solver.getIntVar(CriterionVar).getMin()-1); 
  } else { 
   additionalConstraint = IloConstraint(transCostSum <= solver.getIntVar(transCostSum).getMin()-1); 
  } 
 
  while (TimeLimit>0 && solver.solve(IloAddConstraint(additionalConstraint) 
            && IloLimitSearch(env, goal, IloTimeLimit(env,TimeLimit)))) {  
   fout<<endl;  
   fout<<"****************** Solution "<<SolutionCtr<<" ******************"<<endl;  
    
   TrueCost = solver.getIntVar(transCostSum).getMin();  
    
   if (activateAltVRPCriterion) { 
    TrueCost = solver.getIntVar(CriterionVar).getMin(); 
   } 
 
   finish = clock();  
   TimeSpent += (double) (finish - start) / CLOCKS_PER_SEC;  
   TimeLimit = BasicTimeLimit - TimeSpent;  
 
   int NbMachinesUsed; 
   fout2.open(StandFormatFile, ios::out); 
   PrintSolution(solver,costOnResource,VRPFlag,transCostSum,transCostArr, selectedMachines, 
        fout,fout1,fout2,SolutionCtr,NbFailsSummed, 
        NbChoicePointsSummed,LastSolution,makespan,NbMachinesUsed, IloFalse);  
   fout2.close(); 
 
   env.out()<<endl;  
   env.out()<<"Solution "<<SolutionCtr<<" : "<<NbMachinesUsed<<"/"<<TrueCost<<endl;  
   
   env.out()<<endl;  
   solver.printInformation();  
   NbFailsSummed += solver.getNumberOfFails();  
   NbChoicePointsSummed += solver.getNumberOfChoicePoints();  
   cout<<"TimeSpent : "<<TimeSpent<<endl;  
   cout<<"TimeLimit : "<<TimeLimit<<endl;  
 
   start = finish;  
   SolutionCtr++;  
   if (activateAltVRPCriterion) { 
    additionalConstraint = IloConstraint(CriterionVar <= solver.getIntVar(CriterionVar).getMin()-1); 
   } else { 
    additionalConstraint = IloConstraint(transCostSum <= solver.getIntVar(transCostSum).getMin()-1); 
   } 
 
  }  
  
  cout<<"No More Solutions"<<endl;  
  LastSolution = IloTrue; 
 
  int NbMachinesUsed; 
  PrintSolution(solver,costOnResource,VRPFlag,transCostSum,transCostArr, selectedMachines, 
       fout,fout1,fout2,SolutionCtr,NbFailsSummed, 
       NbChoicePointsSummed,LastSolution,makespan,NbMachinesUsed,false);  
 } else { 
 
  if (solver.solve(IloLimitSearch(env, goal, IloTimeLimit(env, BasicTimeLimit)))) { //if there is a solution  
   finish = clock()-start;  
   fout<<endl;  
   fout<<"****************** Solution 1 ******************"<<endl;  
 
   TrueCost = solver.getIntVar(makespan).getMin()  
           - SetupActivityDuration  
           - TeardownActivityDuration;  
 
   if (activateAltVRPCriterion) { 
    TrueCost = solver.getIntVar(CriterionVar).getMin(); 
   } 
 
   // - since we have non-zero duration teardowns and setups for every job.  
   int NbMachinesUsed; 
   PrintSolution(solver,costOnResource,VRPFlag,makespan,transCostArr, selectedMachines, 
        fout,fout1,fout2, 1,NbFailsSummed, 
        NbChoicePointsSummed,LastSolution,makespan,NbMachinesUsed,false);  
 
   fout2.close(); 
    
   env.out()<<endl;  
   env.out()<<"Solution 1 : "<<NbMachinesUsed<<"/"<<TrueCost<<endl;  
   env.out()<<endl;  
   solver.printInformation();  
   NbFailsSummed += solver.getNumberOfFails();  
   NbChoicePointsSummed += solver.getNumberOfChoicePoints();  
  } else {  
   solver.out() << "No Solutions: Insolubility or CPU-Time Expiry" << endl;  
   lt = time(NULL);  
   ptr = localtime(&lt);  
   fout<<asctime(ptr);  
   cout<<asctime(ptr);  
   fout.close();  
   fout1<<endl; 
   fout1.close();  
   fout2<<"0"<<endl; 
   fout2.close(); 
   fclose(fin); 
   env.end();  
   return -1; 
  }  
 
  if (ReadFirstSolutionFromFile) { 
   for (i=0;i<GlobalNumberOfAddedConstraints;i++) { 
    model.remove(AddedConstraintsArr[i]); 
   } 
  } 
 
  IloInt SolutionCtr = 2;  
 
  IloNum TimeSpent = (double) finish / CLOCKS_PER_SEC;  
  cout<<"TimeSpent : "<<TimeSpent<<endl;  
 
  IloNum TimeLimit = BasicTimeLimit - TimeSpent;  
  cout<<"TimeLimit : "<<TimeLimit<<endl;  
  
  IloInt FailsLeft = BasicFailLimit - NbFailsSummed; 
  cout<<"FailsLeft = "<<FailsLeft<<endl; 
 
  start = clock();  
  // subsequent solutions of less cost 
 
  if (activateAltVRPCriterion) { 
   additionalConstraint = (CriterionVar <= solver.getIntVar(CriterionVar).getMin()-1); 
  } else { 
   additionalConstraint = (makespan <= solver.getIntVar(makespan).getMin()-1); 
  } 
 
//  while (TimeLimit>0 && solver.solve(IloAddConstraint(additionalConstraint) 
//            && IloLimitSearch(env, goal, IloTimeLimit(env,TimeLimit)))) {  
   
 
//  while (FailsLeft>0 && solver.solve(IloAddConstraint(additionalConstraint) 
//            && IloLimitSearch(env, goal, IloTimeLimit(env,FailsLeft)))) {  
 
  while (solver.solve(IloAddConstraint(additionalConstraint) && goal)) { 
   fout<<endl;  
   fout<<"****************** Solution "<<SolutionCtr<<" ******************"<<endl;  
//   TrueCost = solver.getIntVar(makespan).getMin() 
//           - SetupActivityDuration  
//           - TeardownActivityDuration; 
 
   TrueCost = solver.getIntVar(makespan).getMin()  
           - SetupActivityDuration  
           - TeardownActivityDuration;  
 
   if (activateAltVRPCriterion) { 
    TrueCost = solver.getIntVar(CriterionVar).getMin(); 
   } 
 
//   TrueCost = solver.getIntVar(CriterionVar).getMin(); 
 
//   fout<<"CriterionVar = "<<solver.getIntVar(CriterionVar).getMin()<<endl; 
   //- since we have non-zero duration teardowns and setups for every job.     
    
   fout2.open(StandFormatFile, ios::out); 
   int NbMachinesUsed; 
   PrintSolution(solver,costOnResource,VRPFlag,transCostSum,transCostArr, selectedMachines, 
        fout,fout1,fout2, SolutionCtr,NbFailsSummed, 
        NbChoicePointsSummed,LastSolution,makespan,NbMachinesUsed,false);  
 
   fout2.close(); 
   env.out()<<endl;  
   env.out()<<"Solution "<<SolutionCtr<<" : "  
     <<NbMachinesUsed<<"/"<<TrueCost<<endl;  
   
   env.out()<<endl;  
   solver.printInformation();  
   NbFailsSummed += solver.getNumberOfFails();  
   NbChoicePointsSummed += solver.getNumberOfChoicePoints();  
 
   finish = clock();  
   TimeSpent += (double) (finish - start) / CLOCKS_PER_SEC;  
   cout<<"TimeSpent : "<<TimeSpent<<endl;  
   TimeLimit = BasicTimeLimit - TimeSpent;  
   cout<<"TimeLimit : "<<TimeLimit<<endl;  
   GlobalVarTimeLimit = TimeLimit; 
   FailsLeft -= solver.getNumberOfFails(); 
   cout<<"FailsLeft : "<<FailsLeft<<endl;  
   start = finish;  
   SolutionCtr++;  
   if (activateAltVRPCriterion) { 
    additionalConstraint = IloConstraint(CriterionVar <= solver.getIntVar(CriterionVar).getMin()-1); 
   } else { 
    additionalConstraint = IloConstraint(makespan <= solver.getIntVar(makespan).getMin()-1); 
   } 
  }  
  
  cout<<"No More Solutions"<<endl;  
  cout<<solver.getNumberOfFails()<<" fails since last solution"<<endl; 
  NbFailsSummed += solver.getNumberOfFails(); 
 
  LastSolution = IloTrue; 
  int NbMachinesUsed; 
  PrintSolution(solver,costOnResource,VRPFlag,transCostSum,transCostArr, selectedMachines, 
       fout,fout1,fout2, SolutionCtr,NbFailsSummed, 
       NbChoicePointsSummed,LastSolution,makespan,NbMachinesUsed,false);  
 } 
 
 fout1<<endl; 
 lt = time(NULL);  
 ptr = localtime(&lt);  
 fout<<asctime(ptr);  
 cout<<asctime(ptr);  
 fout.close();  
 fout1.close();  
     
  } catch (IloException& exc) {  
    cout << exc << endl;  
  }  
  return 0;  
}