doxygen/html/PYexportHeuristics_8h_source.html

/*

Copyright (c) 2019 Gouvernement du Qu�bec


SPDX-License-Identifier: LiLiQ-R-1.1

License-Filename: LICENSES/EN/LiLiQ-R11unicode.txt

*/


#ifndef PYEXPORTHEURISTICS_H_INCLUDED

#define PYEXPORTHEURISTICS_H_INCLUDED


#include "FMTOperatingArea.h"

#include "FMTOperatingAreaScheduler.h"

#include "FMTOperatingAreaClusterer.h"

#include "FMTOperatingAreaScheme.h"

#include "FMTOperatingAreaCluster.h"

//#include "FMTLpHeuristicMtHandler.h"

#include "FMTLpSolver.h"

#include "PYdefinitions.h"

#include "boost/python.hpp"

#include "FMTpythonpickle.h"


namespace Python

{

void exportHeuristics()

{

    namespace bp = boost::python;

    bp::object HeuristicsModule(bp::handle<>(bp::borrowed(PyImport_AddModule("FMT.Heuristics"))));

    bp::scope().attr("Heuristics") = HeuristicsModule;

    bp::scope HeuristicsModule_scope = HeuristicsModule;

    bp::scope().attr("__doc__") = ".. module:: Heuristics\n"

        "\n"

        "   :platform: Unix, Windows\n"

        "   :synopsis: Module used for Heuristics.\n"

        "\n";

    #ifdef FMTWITHOSI


    /*bp::class_<Heuristics::FMTLpHeuristicMtHandler>("FMTlpheuristicmthandler", "@DocString(FMTLpHeuristicMtHandler)")

        //.def(bp::init<std::vector<Heuristics::FMTOperatingAreaScheduler>&>())

        //.def(bp::init<std::vector<Heuristics::FMTOperatingAreaClusterer>&>())

        .def(bp::init<boost::python::list&,const double&>())

        .def("initialSolve", &Heuristics::FMTLpHeuristicMtHandler::initialSolve,

                    "@DocString(FMTLpHeuristicMtHandler::initialSolve)")

        .def("greedySolve", &Heuristics::FMTLpHeuristicMtHandler::greedySolve,

                    "@DocString(FMTLpHeuristicMtHandler::greedySolve)");*/


    bp::class_<Heuristics::FMTOperatingArea>("FMToperatingarea", "@DocString(FMTOperatingArea)")

        .def(bp::init<const Core::FMTMask&, const double&>())

        .def_pickle(FMT_pickle_suite<Heuristics::FMTOperatingArea>())

        .def("getneighbors", &Heuristics::FMTOperatingArea::getNeighbors,

            "@DocString(FMTOperatingArea::getneighbors)")

        .def("setneighbors", &Heuristics::FMTOperatingArea::setNeighbors,

            "@DocString(FMTOperatingArea::setneighbors)")

        .def("getmask", &Heuristics::FMTOperatingArea::getMask,

            "@DocString(FMTOperatingArea::getmask)")

        .def("getneihgborsperimeter", &Heuristics::FMTOperatingArea::getNeighborsPerimeter,

            "@DocString(FMTOperatingArea::getneihgborsperimeter)");


    definePyList<Heuristics::FMTOperatingArea>();


    bp::class_<Heuristics::FMTOperatingAreaScheme,bp::bases<Heuristics::FMTOperatingArea>>("FMToperatingareascheme", "@DocString(FMTOperatingAreaScheme)")

        .def(bp::init<const Heuristics::FMTOperatingArea&,const size_t&,const size_t&,

            const size_t&, const size_t&, const size_t&, const size_t&, double>())

        .def("presolve", &Heuristics::FMTOperatingAreaScheme::preSolve,

            "@DocString(FMTOperatingAreaScheme::preSolve)");


    definePyList<Heuristics::FMTOperatingAreaScheme>();


    bp::class_<Heuristics::FMTOperatingAreaClusterBinary,bp::bases<Heuristics::FMTOperatingArea>>("FMToperatingareaclusterbinary", "@DocString(FMTOperatingAreaClusterBinary)");


    definePyList<Heuristics::FMTOperatingAreaClusterBinary>();


    bp::class_<Heuristics::FMTOperatingAreaCluster>("FMToperatingareacluster", "@DocString(FMTOperatingAreaCluster)")

        .def(bp::init<const Heuristics::FMTOperatingAreaCluster&,const double&, const double&>())

        .def("getfilteredcluster",&Heuristics::FMTOperatingAreaCluster::getFilteredCluster,

             "@DocString(FMTOperatingAreaCluster::getfilteredcluster)")

        .def("getallmasks",&Heuristics::FMTOperatingAreaCluster::getAllMasks,

             "@DocString(FMTOperatingAreaCluster::getallmasks)")

        .def("getcentroid", &Heuristics::FMTOperatingAreaCluster::getCentroid,

            "@DocString(FMTOperatingAreaCluster::getcentroid)")

        .def("setminimalarea",&Heuristics::FMTOperatingAreaCluster::setMinimalArea,

             "@DocString(FMTOperatingAreaCluster::setminimalarea)")

        .def("setmaximalarea",&Heuristics::FMTOperatingAreaCluster::setMaximalArea,

             "@DocString(FMTOperatingAreaCluster::setmaximalarea)");


    definePyList<Heuristics::FMTOperatingAreaCluster>();


    bp::class_<Heuristics::FMTLpHeuristic, bp::bases<Core::FMTObject, Models::FMTLpSolver>>("FMTlpheuristic", "@DocString(Heuristics::FMTLpHeuristic)");


    bp::class_<Heuristics::FMTOperatingAreaClusterer, bp::bases<Heuristics::FMTLpHeuristic>>("Heuristics::FMToperatingareaclusterer", "@DocString(FMTOperatingAreaClusterer)")

        .def("initialsolve", &Heuristics::FMTOperatingAreaClusterer::initialSolve,

            "@DocString(FMTOperatingAreaClusterer::initialsolve)")

        .def("branchnboundsolve", &Heuristics::FMTOperatingAreaClusterer::branchNBoundSolve,

            "@DocString(FMTOperatingAreaClusterer::branchnboundsolve)")

        .def("setnumberofsimulationpass", &Heuristics::FMTOperatingAreaClusterer::setNumberOfSimulationPass,

            "@DocString(FMTOperatingAreaClusterer::setnumberofsimulationpass)")

        .def("getsolution", &Heuristics::FMTOperatingAreaClusterer::getSolution,

            "@DocString(FMTOperatingAreaClusterer::getsolution)");


    definePyList<Heuristics::FMTOperatingAreaClusterer>();


    bp::class_<Heuristics::FMTOperatingAreaScheduler, bp::bases<Heuristics::FMTLpHeuristic>>("Heuristics::FMToperatingareascheduler", "@DocString(FMTOperatingAreaScheduler)")

        .def("initialsolve", &Heuristics::FMTOperatingAreaScheduler::initialSolve,

            "@DocString(FMTOperatingAreaScheduler::initialsolve)")

        .def("branchnboundsolve", &Heuristics::FMTOperatingAreaScheduler::branchNBoundSolve,

            "@DocString(FMTOperatingAreaScheduler::branchnboundsolve)")

        .def("getsolution", &Heuristics::FMTOperatingAreaScheduler::getSolution,

            "@DocString(FMToperatingareaheuristic::getsolution)")

        .def("setasprimal", &Heuristics::FMTOperatingAreaScheduler::setAsPrimal,

            "@DocString(FMTOperatingAreaScheduler::setasprimal)")

        .def("setproportionofset", &Heuristics::FMTOperatingAreaScheduler::setProportionOfSet,

            "@DocString(FMTOperatingAreaScheduler::setproportionofset)");


    definePyList<Heuristics::FMTOperatingAreaScheduler>();

    #endif

    }

}

#endif

FMTLpSolver.h

FMTOperatingAreaCluster.h

FMTOperatingAreaClusterer.h

FMTOperatingAreaScheduler.h

FMTOperatingAreaScheme.h

FMTOperatingArea.h

FMTpythonpickle.h

PYdefinitions.h

Heuristics::FMTOperatingAreaCluster::getCentroid
FMTOperatingAreaClusterBinary getCentroid() const
Return the centroid binary of the cluster.
Definition: FMTOperatingAreaCluster.h:80

Heuristics::FMTOperatingAreaCluster::setMinimalArea
void setMinimalArea(const double &newminimalarea)
Set the minimal area of the cluster.

Heuristics::FMTOperatingAreaCluster::getFilteredCluster
FMTOperatingAreaCluster getFilteredCluster(const Core::FMTMask &filterMask) const
Return a cluster with the binaries not falling in a mask definition removed, which can reduce the num...

Heuristics::FMTOperatingAreaCluster::setMaximalArea
void setMaximalArea(const double &newmaximalarea)
Set the potential maximal area of the cluster.

Heuristics::FMTOperatingAreaCluster::getAllMasks
std::vector< Core::FMTMask > getAllMasks() const
Return all the masks contained by the cluster, including the operating area centroid.

Heuristics::FMTOperatingAreaClusterer::getSolution
std::vector< FMTOperatingAreaCluster > getSolution() const
Return the clustering solution with cleaned operating clusters.

Heuristics::FMTOperatingAreaClusterer::setNumberOfSimulationPass
void setNumberOfSimulationPass(const int &pass)
Set the number of passes made by the heuristic to get a better objective or a feasible solution durin...

Heuristics::FMTOperatingAreaClusterer::initialSolve
bool initialSolve() final
Solve the heuristic problem using the fire spread heuristic to get a good initial clustering solution...

Heuristics::FMTOperatingAreaClusterer::branchNBoundSolve
bool branchNBoundSolve() final
Solve the problem using branch and bound on the primal formulation, using the heuristic solution as a...

Heuristics::FMTOperatingAreaScheduler::setAsPrimal
void setAsPrimal()
Set the primal member to true.

Heuristics::FMTOperatingAreaScheduler::branchNBoundSolve
bool branchNBoundSolve() final
Solve the problem using branch and bound on the primal formulation, using the heuristic solution as a...

Heuristics::FMTOperatingAreaScheduler::initialSolve
bool initialSolve() final
Solve the heuristic problem until an initial solution is found for each operating area.

Heuristics::FMTOperatingAreaScheduler::setProportionOfSet
void setProportionOfSet(const double &proportion)
Set the allowed proportion of operating area status change before resolving the problem.

Heuristics::FMTOperatingAreaScheduler::getSolution
std::vector< Core::FMTTimeYieldHandler > getSolution(const std::string &yldname) const
Return the actual solution as a vector of time yield handlers, one per operating area.

Heuristics::FMTOperatingAreaScheme::preSolve
FMTOperatingAreaScheme preSolve(const Core::FMTMask &selectedmask, const std::vector< Core::FMTTheme > &presolvedthemes) const
Return a presolved FMTOperatingAreaScheme using a mask and a subset of the original themes.

Heuristics::FMTOperatingArea
Operating area giving information about its mask, neighbors and neighbors perimeter.
Definition: FMTOperatingArea.h:29

Heuristics::FMTOperatingArea::getNeighborsPerimeter
double getNeighborsPerimeter() const
Return the percentage of perimeter the operating area needs to share with another operating area to b...

Heuristics::FMTOperatingArea::getNeighbors
std::vector< Core::FMTMask > getNeighbors() const
Return a copy of the neighbors masks of the operating area.

Heuristics::FMTOperatingArea::setNeighbors
void setNeighbors(const std::vector< Core::FMTMask > &lneighbors)
Set the neighbors masks of the operating area.

Heuristics::FMTOperatingArea::getMask
Core::FMTMask getMask() const
Return the mask of the operating area.

Python
Definition: PYdefinitions.h:14

Python::exportHeuristics
void exportHeuristics()
Definition: PYexportHeuristics.h:25