aggheuristics.h

#ifndef __AGGHEURISTICS_H__
#define __AGGHEURISTICS_H__

#include "../heuristics.h"
#include "../../../../data_structures/bm/functors.h"
#include "../../../../data_structures/precs/slopes.h"
#include <map>
#include <typeinfo>

using namespace std;



namespace delphos {

//void mycallback(const double& percentage);

class HReb : public SchedulingHeuristic {
    private:
        double _rx;
        double _ry;
        double _rz;
        string _agg_sched_name;
        string _desagg_sched_name;      
        Precedence* _prec;
        SlopePrecedence* _agg_prec;
        
        Schedule* _agg_schedule;
        Schedule* _desagg_schedule;
        
        BlockModel* _agg_bm;
        SchedulingInstance* _agg_si;
        
        double _slope_ang;
        const unsigned int _nblevels;
        double _agg_obj;
        double _obj;
        double _gap;
        vector<RelativeCoordinatesIndex>*  _patterni;
        
        bool RunAggregation();
        bool RunDesAggregation();
        int _last_period;
        unsigned int _numthread;
        bool _verbose;
        
        unsigned int _swh_window_size[2];
        unsigned int _swh_sub_window_size[2];
        unsigned int _swh_step[2];
                
    public:
        HReb(delphos::SchedulingInstance& si,const double& slope_ang,const unsigned int& nblevels 
#ifndef NO_GUROBI
            ,const string& agg_sched_name=Scheduler::GUROBI_SlidingTimeWindowHeuristic
            ,const string& desagg_sched_name=Scheduler::GUROBI_SlidingTimeWindowHeuristic
#else
            ,const string& agg_sched_name=Scheduler::CBC_SlidingTimeWindowHeuristic
            ,const string& desagg_sched_name=Scheduler::CBC_SlidingTimeWindowHeuristic
#endif
            ,const double& rx=0.0,const double& ry=0.0,const double& rz=0.0);
            /*HReb(delphos::SchedulingInstance& si,const double& slope_ang,const unsigned int& nblevels 
            ,const vector<double>& pattern
            ,const string& agg_sched_name=Scheduler::GUROBI_SlidingTimeWindowHeuristic
            ,const string& desagg_sched_name=Scheduler::GUROBI_SlidingTimeWindowHeuristic
            ,const double& rx=0.0,const double& ry=0.0,const double& rz=0.0);*/
    /*  HReb(delphos::SchedulingInstance& si 
            ,const string& agg_sched_name=Scheduler::GUROBI_SlidingTimeWindowHeuristic
            ,const string& desagg_sched_name=Scheduler::GUROBI_SlidingTimeWindowHeuristic
            ,const double& rx=0.0,const double& ry=0.0,const double& rz=0.0);   */

        virtual ~HReb();

        bool Run();

        void SetGap(const float& gap);

        void SetSTWHParam(const unsigned int & window_size, const unsigned int & sub_window_size,const unsigned int & step,const bool& backward=true);
        
        double GetObjective();

        double GetAggregatedObjective();

        void SetLastFixedPeriod(const unsigned int& lastperiod);

        delphos::BlockModel& GetAggregatedModel();

        void SetNumThread(const unsigned int& nthread);

        void SetVerbose();
};

#ifndef DOXYGEN 

class HDiv2 : public SchedulingHeuristic {
private:
    //const double& _delta; 
    string _agg_sched_name;
    string _desagg_sched_name;  
    unsigned int _swh_win_size;
            
    Schedule* _agg_schedule;
    unsigned int _nb_aggreg_sub_part;
    vector<int> _period_unit;
    
    SchedulingInstance* _agg_si;
    
    double _agg_obj;
    double _obj;
    double _gap;
    bool _use_min_time;
    
    bool RunAggregation();
    bool RunDesAggregation();   
    
public:
    HDiv2(delphos::SchedulingInstance& si
#ifndef NO_GUROBI
        ,const string& agg_sched_name=Scheduler::GUROBI_SlidingTimeWindowHeuristic
        ,const string& desagg_sched_name=Scheduler::GUROBI_SlidingTimeWindowHeuristic
#else
        ,const string& agg_sched_name=Scheduler::CBC_SlidingTimeWindowHeuristic
        ,const string& desagg_sched_name=Scheduler::CBC_SlidingTimeWindowHeuristic
#endif
        , bool bUseMinTime=false);

    virtual ~HDiv2();

    virtual bool Run();

    void SetGap(const float& gap);
    
    void SetSWHWindowSize(const unsigned int& ws);

    double GetObjective();

    double GetAggregatedObjective();
};
#endif


/*class HDiv : public SchedulingHeuristic {
private:
    unsigned int _nb_div_part;
    const double& _delta;
    const unsigned int _tmin;       
    
class AggregatedSchedulingInstance : public SchedulingInstance {    

private:
    
    const unsigned int _period_unit;
    const unsigned int _last_period_unit;
    const unsigned int _start_period;
    
    
    
public:
    vector<BlockIndexType> _corresp;

    AggregatedSchedulingInstance(delphos::SchedulingInstance& si,const unsigned int& period_unit_value,const unsigned int& last_period_unit_value,const unsigned int& startperiod);
    AggregatedSchedulingInstance(delphos::BlockModel & bm, const unsigned int & horizon,const unsigned int& period_unit_value,const unsigned int& last_period_unit_value,const unsigned int& startperiod, const double discount_rate = 0.0);
    
    virtual ~AggregatedSchedulingInstance();
    const unsigned int& GetPeriodUnit() const;
    const unsigned int& GetLastPeriodUnit() const;
    const unsigned int& GetStartPeriod() const;
    
    
    
    virtual void Report();
};  
    AggregatedSchedulingInstance* AggregateTime(SchedulingInstance& si,const unsigned int& startperiod);
    bool RunAggregatedInstance(AggregatedSchedulingInstance& si);
    
public:
    const unsigned int& GetTMin() const;
    HDiv(delphos::SchedulingInstance& si,const unsigned int& nb_div_part,const unsigned int& tmin,const double& delta=0.0);
    virtual bool Run();
};*/




/*class MinPeriodHeur: public Heuristic {
private:    
    vector<double> _capacities;
    string _weight_attr;
    Schedule * _schedule;
    double _obj_val;
    double _mipgap;
public:
    MinPeriodHeur(SchedulingInstance& si,const string& attribute,const vector<double>& capacities);
    virtual bool Run();
    double GetObjValue();
    const Schedule&  GetSchedule(); 
    void SetGap(const float& gap);
};*/

}
#endif