etheuristics.h

#ifndef __ETHEURISTICS_H__
#define __ETHEURISTICS_H__

#include "../heuristics.h"
#ifndef NO_GUROBI
    #include "../../fractional_scheduler/bz/gurobi_bz.h"
    #include "gurobi_model.h"
#endif
#ifdef CBC
    #include "../../fractional_scheduler/bz/cbc_bz.h"
    #include "cbc_model.h"
#endif
#include <algorithm>
#include <vector>
//#include <typeinfo>

using namespace std;



namespace delphos {

class FractionalScheduleToSchedule: public SchedulingHeuristic {
public:
    FractionalScheduleToSchedule(delphos::SchedulingInstance & si);
};  

class RankedFractionalScheduleToSchedule: public FractionalScheduleToSchedule {
protected:
    vector<double> _exptime;
public:
    RankedFractionalScheduleToSchedule(delphos::SchedulingInstance & si,const vector<double>& exptime);
    ~RankedFractionalScheduleToSchedule();
};  

//void mycallback(const double& percentage);

class TopoHeuristic: public RankedFractionalScheduleToSchedule {
private: 
    //bool _bUseET;
    //vector<int> _tmin;
    BlockIndexType _nb_blk_with_exptime_in_horizon;
    
    typedef struct node {
        set<BlockIndexType> precedenceSet;
        set<BlockIndexType> succSet;
        BlockIndexType number;
        float w;
    }Node;
    
    typedef struct ress{
        set<unsigned int> index;
        string attr;
        float min;
        float max;
        unsigned int period;
    }Ress;

    vector<Node>* CreateGraph();
    BlockIndexType* TopoSort();
    
public:
    TopoHeuristic(delphos::SchedulingInstance & si,const vector<double>& exptime);//,const bool bUseET=true);
    
    ~TopoHeuristic();

    bool Run();

};

#ifndef ACADEMIC

class ETDelta: public RankedFractionalScheduleToSchedule {
private: 
    const float _delta;
    Model::OptimizationSense _optimization_sense;
    Model::Emphasis _mip_emphasis;
    float _mipgap;
    string _logfile;
    string _sched_name;
public:
    ETDelta(delphos::SchedulingInstance& si,const vector<double>& exptime,float delta=0.5
#ifndef NO_GUROBI
        ,const string& sched_name=Scheduler::GUROBI_MIPScheduler);
#else 
        ,const string& sched_name=Scheduler::CBC_MIPScheduler);
#endif

    bool Run();

    void SetOptimizationSense(const Model::OptimizationSense& sense);

    void SetLogFile(const string& name);

    void SetGap(const float& gap);

    void SetMIPEmphasis(const Model::Emphasis& emphasis);
};  

class ETInc: public RankedFractionalScheduleToSchedule {
private: 
    Model::OptimizationSense _optimization_sense;
    Model::Emphasis _mip_emphasis;
    float _mipgap;
    string _logfile;
    const unsigned int _windowsize;
    const float _delta;
    const unsigned int _step;
    string _sched_name;
public:
    ETInc(delphos::SchedulingInstance& si
        ,const vector<double>& exptime
        ,const unsigned int windowsize=1
        , const float delta=0.5
        , const unsigned int step=1
#ifndef NO_GUROBI
        ,const string& sched_name=Scheduler::GUROBI_MIPScheduler);
#else
        ,const string& sched_name=Scheduler::CBC_MIPScheduler);
#endif


    bool Run();

    void SetOptimizationSense(const Model::OptimizationSense& sense);

    void SetLogFile(const string& name);

    void SetGap(const float& gap);

    void SetMIPEmphasis(const Model::Emphasis& emphasis);
};  
#endif

class BZHeuristic: public SchedulingHeuristic { 
public:
    BZHeuristic(delphos::SchedulingInstance& si,delphos::FinalPitSolver* fps=NULL);

    virtual ~BZHeuristic();

    virtual bool Run();

    bool RunBZ(unsigned int nbitermax=1000000);

    void SetMipAsPitSolver();

    double* GetRelaxedSol();

    double* GetRelaxedDecisionSol();
    
    vector<double> GetExpectedTime();

    bool SetExpectedTime(const string& column);

    bool ExpectedTimeToTextFile(const char * exptime_file) const;
    
    bool RunTopoHeur();//const bool& TE=true);
    
#ifndef ACADEMIC
    bool RunETInc(const unsigned int& windowsize=1, const float& delta=0.5, const unsigned int& step=1
#ifndef NO_GUROBI
                    ,const string& sched_name=Scheduler::GUROBI_MIPScheduler);
#else
                    ,const string& sched_name=Scheduler::CBC_MIPScheduler);
#endif

    bool RunETDelta(const float& delta=0.5
#ifndef NO_GUROBI
                    ,const string& sched_name=Scheduler::GUROBI_MIPScheduler);
#else
                    ,const string& sched_name=Scheduler::CBC_MIPScheduler);
#endif
#endif

    void SetHeurParameters(const unsigned int& windowsize, const float& delta, const unsigned int& step);
    
    bool CheckRelaxedSol();
    
    bool RelaxedSolToTextFile(const char * relsol_file, const char* stocks_file="") ;

    void SetGap(const double & gap);

    const double GetGap() const;

    void SetEmphasis(const Model::Emphasis & emph);

    const Model::Emphasis GetEmphasis() const;
    
    double GetRelaxedObj();

    unsigned int GetNBIterationsBZ();
    
    const map<string,double>& GetBZDuals();
    
    bool IsFeasible();

    
private:

    BZ* _pflpsolver;
    
    bool _use_mip_as_pitsolver;
    
    unsigned int _nb_iterations_bz;
    double _relobjvalue;
    
    vector<double> _exptime;
    unsigned int* _tmin;
    
    //bool _stocks; 
    
    unsigned int _K;
    float _delta;
    unsigned int _eps;
    bool _TEIncParameterIsSet;
    
    Model::Emphasis _emph;
    double _gap;
    Model::OptimizationSense _sense;
    string _logfile;
    
    double _max_cost;
    SchedulingInstance &  GetInstance();
    //map<BlockIndexType,bool> _assigned_vars;
    
    bool _optimized;
};



#endif
}