gurobimipscheduler.h

#ifndef __GUROBIMIPSCHEDULER_H__
#define __GUROBIMIPSCHEDULER_H__

#include <algorithm>
#include <string>
#include <sstream>
#include <map>
#include <typeinfo>
#include "named.h"
#include "mip_scheduler.h"
#include "gurobi_model.h"
#include "../../../problems/scheduling/filtering.h"
#include <iostream>


namespace delphos{ 

class GurobiMIPScheduler : public MIPScheduler {
private:
    GurobiModel* _gmodel;
    
    bool CreateGoalFunction();
    bool CreateCoreConstraints();
    
    bool _bmodelcreated;
    
    void ApplyPrecedenceConstraint(const PrecedenceConstraint& pc);
    void ApplyAttributeSumConstraint(const AttributeSumConstraint& asc);
    void ApplyAttributeAvgConstraint(const AttributeAvgConstraint& asc);
    void ApplyDoNotMineBeforeConstraint(const DoNotMineBeforeConstraint& dc);
    void ApplyForceMiningByConstraint(const ForceMiningByConstraint& fc);
    void ApplyDoNotSendToConstraint(const DoNotSendToConstraint& dnsc);
    void ApplyGeometricConstraint(const GeometricConstraint& gc);
    void ApplyMinExtractPeriodConstraint(const MinExtractPeriodConstraint& mepc);
    void ApplyBlockSelectionPrecedenceConstraint(const BlockSelectionPrecedenceConstraint& bsprc);
    
    BlockIndexType* _index_in_bs;
    bool _buser_constraintscreated;

    BlockIndexType ProcVarId(
    const BlockIndexType & block_index, 
    const unsigned int & period, 
    const unsigned int & destination);
    
    Variable& ProcVar(
        const BlockIndexType& block_index, 
        const unsigned int& period, 
        const unsigned int& destination);
        
    unsigned long _nb_prec; 
    
    inline void unsigned_to_decimal( unsigned long number, char* buffer )
    {
        if( number == 0 )
        {
            *buffer++ = '0';
        }
        else
        {
            char* p_first = buffer;
            while( number != 0 )
            {
                *buffer++ = '0' + number % 10;
                number /= 10;
            }
            reverse( p_first, buffer );
        }
        *buffer = '\0';
    }   
    
public:

    bool SetSchedule();
    
    #ifndef DOXYGEN
    Variable& StockVar(
        const unsigned int& stock_index, 
        const unsigned int& period, 
        const unsigned int& destination);

    LinearExpr RealProcVar(
        const BlockIndexType& block_index, 
        const unsigned int& period, 
        const unsigned int& destination);
    #endif
    
    GurobiMIPScheduler(delphos::SchedulingInstance & si);
    
    virtual ~GurobiMIPScheduler();
    
    virtual bool Run();
    
    #ifndef DOXYGEN

    void Optimize();
    #endif
    
    const delphos::Schedule & GetSchedule();
        
    bool CreateModel(); 
    
    bool CreateVariables();

    bool CreateUserConstraints();

    void WriteLP(const string outfile);
    
    void WriteSol(const string outfile);
    //void WriteInfeasibleLP(const string outfile);
    
    GurobiModel& GetMathematicalModel();
    
    double GetObjValue();
    
    const double GetDual(const string& cname); 
    
    double GetMIPGap();

};




}
#endif