bz.h

#ifndef __BZ_H__
#define __BZ_H__
#include <algorithm>
#include "../../../finalpit/pseudoflowfp.h"
#include "../fractional_scheduler.h"

namespace delphos{ 
class BZ : public FractionalScheduler {
    
private:
    virtual void ComputeExpectedTime(const string column);
    
protected:

    SchedulingInstance* _temp_si;
    BlockModel* _fullpit_bm;
    BlockModel* _bm_var;
    Precedence* _fullpit_prec;
    Precedence* _reduced_prec;
    
    FinalPitSolver* _pitsolver;
    unsigned int _cont;
    
    //bool _use_lp_as_pitsolver;
    //GurobiFractionalScheduler*  _lpsolver;
    
    unsigned int _nb_iterations_bz;
    double _relobjvalue;
    double* _reldecsol; 
    double* _relsol;
    
    vector<double> _exptime;
    unsigned int* _tmin;
    //BlockIndexType _nb_blk_with_exptime_in_horizon;
    //Schedule* _schedule;
    
    bool _stocks;   
    
    double _time_finalpit_compute;
    double _time_lp_compute;
    
    unsigned int _K;
    float _delta;
    unsigned int _eps;
    bool _TEIncParameterIsSet;
    CallBackPtr _fp;
    
    unsigned int _emph;
    double _gap;
    int _sense;
    string _logfile;
    
    map<string,double> _duals;
    double _max_cost;
    
    virtual const bool IsStock();
    void init_pitsolver(FinalPitSolver* fps);
    void ChangePenalties(vector<double>, vector<double> );
    //virtual void SetRelaxedSol(GRBModel*,const vector<BlockSelection>&,const bool&);
    
    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(const bool& TE=true);
    BlockIndexType* TopoSort(const bool& TE=true);
    
    class Slack:public Stock{
        private:
            unsigned int _period;
        public:
            Slack(const string & slack_name, const string & tname, const double & tonnage,const unsigned int& period);
            const unsigned int& GetPeriod() const;
    };
    vector<Slack> _slacks;
    
    map<BlockIndexType,bool> _assigned_vars;
    BlockSelection* _bs_to1;
    BlockSelection* _bs_to0;
    BlockSelection* _bs_to;
    BlockSelection* _bs_var;
    bool _feasible;
    void UpdatePitSolver();
    bool _bGeometric;
    bool _optimized;    
    virtual bool SetFractionalSchedule();
    
public:

    BZ(delphos::SchedulingInstance & si,delphos::FinalPitSolver* fps=NULL);

    virtual ~BZ();
    
    virtual bool Run();

    virtual double* GetRelaxedSol();

    virtual double* GetRelaxedDecisionSol();

    virtual bool RelaxedSolToTextFile(const char * relsol_file, const char* stocks_file="") ;
    
    virtual bool CheckRelaxedSol();

    vector<double> GetExpectedTime() const;
    
    virtual bool SetExpectedTime(const string& column);
    
    virtual void StoreExpectedTimeAsAttribute(const string column);
    
    virtual bool ExpectedTimeToTextFile(const char * exptime_file) const;   
    
    

    //virtual void SetSense(const int & emph);
    //const int GetSense() const;

    virtual void SetLogFile(const string& name);
    
    double GetRelaxedObj();

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

    const bool Optimized();
    
    virtual SchedulingInstance &  GetInstance();
};
}
#endif