swheuristics.h

#ifndef __SWHEURISTICS_H__
#define __SWHEURISTICS_H__

#include "heuristics.h"

#include "../fractional_scheduler/fractional_scheduler.h"
#include "../../../data_structures/bm/functors.h"
#ifndef NO_GUROBI
    #include "gurobi_model.h"
    #include "../ipscheduler/gurobimipscheduler.h"
#endif
#ifdef CBC
    #include "cbc_model.h"
    #include "../ipscheduler/cbcmipscheduler.h"
#endif
#include <map>
#include <typeinfo>

using namespace std;



namespace delphos {

//void mycallback(const double& percentage);

class SlidingTimeWindowHeuristic : public SchedulingHeuristic {
private:
    unsigned int _window_size;
    unsigned int _sub_window_size;
    unsigned int _step;
    bool _verbose;
    string _path;
    Model::Emphasis _emph;
    float _gap; 
    Model::OptimizationSense _sense;
    unsigned int _numthread;
    double _subpb_timelimit;
    bool _bno_output;
    
protected :
    string _sched_name;
    const unsigned int GetWindowSize() const;
    const unsigned int GetSubWindowSize() const;
    const unsigned int GetStep() const;
     
    SchedulingInstance* GenerateWindowInstance(
        BlockSelection & win_bs, 
        unsigned int & from,  
        unsigned int & end,
        map<string, double> & tonnages);
    
    void CopyToFullSchedule(
        SchedulingInstance * winsi,
        const Schedule & winsch,  
        unsigned int from, 
        unsigned to, 
        map<string, double> & tonnages);
    
    
public:
    SlidingTimeWindowHeuristic(
        delphos::SchedulingInstance & si, 
        const unsigned int & window_size, 
        const unsigned int & sub_window_size,
        const unsigned int & step,
#ifndef NO_GUROBI
        const string& sched_name=Scheduler::GUROBI_MIPScheduler);
#else
        const string& sched_name=Scheduler::CBC_MIPScheduler);
#endif

    SlidingTimeWindowHeuristic(
        SchedulingInstance & si, 
        const unsigned int & window_size, 
        const unsigned int & sub_window_size,
#ifndef NO_GUROBI
        const string& sched_name=Scheduler::GUROBI_MIPScheduler);
#else
        const string& sched_name=Scheduler::CBC_MIPScheduler);
#endif
    
    SlidingTimeWindowHeuristic(
        delphos::SchedulingInstance & si,
        const unsigned int & window_size,
#ifndef NO_GUROBI
        const string& sched_name=Scheduler::GUROBI_MIPScheduler);
#else
        const string& sched_name=Scheduler::CBC_MIPScheduler);
#endif

    virtual bool Run();


    void SetVerbose();

    void SetVerbose(const string & path);

    void SetSupPBTimeLimit(const double& tlimit);
    
    const bool GetVerbose() const;

    const string GetPath() const;

    void SetGap(const float & gap);

    const float GetGap() const;

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

    const Model::Emphasis GetEmphasis() const;

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

    const Model::OptimizationSense GetSense() const;

    const string & GetLogFileName() const;

    void SetNumThread(const unsigned int& nthread);

    void SetNoOutput();

};


class SlidingTimeWindowHeuristicRelaxed: public SlidingTimeWindowHeuristic {
protected:
    
    bool RelaxSecondWindowVariables(MIPScheduler& mip, const unsigned int & from, const unsigned int & to, const unsigned int & current);


public:
    SlidingTimeWindowHeuristicRelaxed(
        delphos::SchedulingInstance & si, 
        const unsigned int & window_size, 
        const unsigned int & sub_window_size,
        const unsigned int & step,
        const string& sched_name=Scheduler::GUROBI_MIPScheduler);
    
    SlidingTimeWindowHeuristicRelaxed(
        delphos::SchedulingInstance & si, 
        const unsigned int & window_size, 
        const unsigned int & sub_window_size,
        const string& sched_name=Scheduler::GUROBI_MIPScheduler);
    
    SlidingTimeWindowHeuristicRelaxed(
        delphos::SchedulingInstance & si,
        const unsigned int & window_size,
        const string& sched_name=Scheduler::GUROBI_MIPScheduler);

    virtual bool Run();

    //bool Create(MIPScheduler & mip, const bool relax = false);
    
};

class NewmanHeuristic: public SlidingTimeWindowHeuristicRelaxed {
private:
    bool _bz;
    bool SetUserConstraintsAndPenalizations(
        MIPScheduler* mip, 
        const unsigned int & big_window_to, 
        const unsigned int & sub_window_to, 
        const unsigned int & current_from , 
        map<string,double> & duals );
    map<string,double> GetDualMap(FractionalScheduler& lp);

public:
    NewmanHeuristic(
        delphos::SchedulingInstance & si,
        const unsigned int & sub_window_size,
        const unsigned int & step,
        const string& sched_name=Scheduler::GUROBI_MIPScheduler);

    NewmanHeuristic(
        delphos::SchedulingInstance & si,
        const unsigned int & step,
        const string& sched_name=Scheduler::GUROBI_MIPScheduler);

    virtual bool Run();
    
    void SetBZ();

};

#ifndef DOXYGEN
class SlidingTimeWindowHeuristicRegret: public SlidingTimeWindowHeuristic {
protected:
    vector<double> _esperate_times;
    
public:
    SlidingTimeWindowHeuristicRegret(
        delphos::SchedulingInstance & si, 
        const unsigned int & window_size, 
        const unsigned int & sub_window_size,
        const unsigned int & step,
        const vector<double>& esperate_times,
        const string& sched_name=Scheduler::GUROBI_MIPScheduler);
    
    virtual bool Run();
    
};
#endif

}
#endif