OrdonnancementCorrectif/src/OrdoCorr/Solver/TrackPlansILP/SolutionPoolManager.cpp

#include "SolutionPoolManager.hpp"
#include <iterator>

namespace solverlib {
    std::vector<TrackPlan> SolutionPoolManager::getTrackPlansFromSolution(SASolution& sol, bool withTrash)
    {
        std::vector<TrackPlan> trackPlans;
        trackPlans.reserve(STFMockInstance::tracks.size());

        //id plan = id voie
        std::vector<TrackPlan> plans;
        plans.resize(STFMockInstance::tracks.size());
        for(auto& dec : sol.decisions)
        {
            if(!dec.second.excluded)
            {
                plans[dec.second.voie].source = sol.source;
                plans[dec.second.voie].isTrash = false;
                plans[dec.second.voie].track = dec.second.voie;
                plans[dec.second.voie].schedule[dec.first] = dec.second;
            }
            else if(withTrash) {
                TrackPlan trashTrack;
                trashTrack.source = sol.source;
                trashTrack.isTrash = true;
                trashTrack.mock = sol.mock;
                trashTrack.diagCost = 0;
                trashTrack.track = 0;
                trashTrack.schedule[dec.first] = {
                    0,CreneauHoraire(), 0, false, true,0,0,{0,0}
                };
                trashTrack.cost = STFMockInstance::jobs[dec.first]->getPoidsRetard() * MAXIMUM_TIME_OFFSET;
                trackPlans.push_back(trashTrack);
            }
        }
        for(auto& plan : plans)
        {
            if(!plan.schedule.empty())
            {
                plan.mock = sol.mock;
                plan.source = sol.source;
                plan.evaluate();
                trackPlans.push_back(plan);
            }
        }

        return trackPlans;
    }


    std::vector<TrackPlan> SolutionPoolManager::transformSolutionsIntoUniqueTrackPlans()
    {
        std::vector<TrackPlan> trackPlans;
        std::set<TrackPlan> uniqueSchedules;
        unsigned long countD = 0;
        trackPlans.reserve(STFMockInstance::tracks.size() * pool.size() + 1);
        while(!pool.empty())
        {
            auto& sol = pool.back();

            //id plan = id voie
            std::vector<TrackPlan> plans;
            plans.resize(STFMockInstance::tracks.size());
            for(auto& dec : sol.decisions)
            {
                if(!dec.second.excluded)
                {
                    plans[dec.second.voie].isTrash = false;
                    plans[dec.second.voie].track = dec.second.voie;
                    plans[dec.second.voie].schedule[dec.first] = dec.second;
                }
            }
            for(auto& plan : plans)
            {
                if(!plan.schedule.empty())
                {
                    plan.mock = sol.mock;
                    plan.source = sol.source;
                    plan.evaluate();
                    auto inserted = uniqueSchedules.insert(plan);
                    if(!inserted.second)
                    {
                        countD++;
                    }
                }
            }
            pool.pop_back();
        }
        std::move(uniqueSchedules.begin(), uniqueSchedules.end(), std::back_inserter(trackPlans));       

        for(unsigned short job = 0; job < STFMockInstance::jobs.size(); ++job)
        {
            TrackPlan trashTrack;
            trashTrack.isTrash = true;
            trashTrack.diagCost = 0;
            trashTrack.track = 0;
            trashTrack.source = ESourceTrackPlan::Fake;
            trashTrack.schedule[job] = {
                0,CreneauHoraire(), 0, false, true,0,0,{0,0}
            };
            trashTrack.cost = STFMockInstance::jobs[job]->getPoidsRetard() * MAXIMUM_TIME_OFFSET;
            trackPlans.push_back(trashTrack);
        }

        auto nbplan = trackPlans.size();

        loggerlib::Logger::systemNotify(loggerlib::LOGGER_PROGRESS, "Removed " + std::to_string(countD) + " non-unique track schedules");
        loggerlib::Logger::systemNotify(loggerlib::LOGGER_PROGRESS, "Total track plans " + std::to_string(nbplan));

        return trackPlans;
    }

    void SolutionPoolManager::provide(std::vector<SASolution>&& solutions)
    {
        std::move(solutions.begin(), solutions.end(), std::back_inserter(pool));
    }

}