ConstraintsGenerator.h

Go to the documentation of this file.

/*
        This file is part of the EnergyOptimizatorOfRoboticCells program.

        EnergyOptimizatorOfRoboticCells is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation, either version 3 of the License, or
        (at your option) any later version.

        EnergyOptimizatorOfRoboticCells is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with EnergyOptimizatorOfRoboticCells. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef HLIDAC_PES_CONSTRAINTS_GENERATOR_H
#define HLIDAC_PES_CONSTRAINTS_GENERATOR_H

#include <cassert>
#include <map>
#include <vector>
#include <utility>
#include "RoboticLine.h"
#include "Shared/PrecalculatedMapping.h"
#include "ILPModel/ILPModel.h"
#include "ILPSolver/VariableMappingILP.h"

class ConstraintsGenerator {
        public:
                ConstraintsGenerator() : mCycleTime(0.0), mConstraintsCounter(0ul), mLine(nullptr), mMapping(nullptr) { }
                ConstraintsGenerator(Robot* r, const PrecalculatedMapping* m) : mConstraintsCounter(0ul) { reset(r,m); }
                ConstraintsGenerator(const RoboticLine& l, const PrecalculatedMapping* m) : mConstraintsCounter(0ul) { reset(l,m); }

                void reset();
                void reset(Robot* r, const PrecalculatedMapping* m);
                void reset(const RoboticLine& l, const PrecalculatedMapping* m);

                uint64_t moveConstraintsToModel(ILPModel& m);

                void addEnergyFunctions1(const map1to1& d, const map1to1& W, const map2to1& x, const map2to1& z);
                void addEnergyFunctions2(const map1to1& d, const map1to1& W, const map2to1& y);
                void addEnergyFunctions(const map1to1& d, const map1to1& W, const map2to1& x, const map2to1& z, const map2to1& y);

                void addUniquePointSelection(const map2to1& x);
                void addUniquePowerModeSelection(const map2to1& z);
                void addUniqueModeSelection(const map2to1& x, map2to1& z);

                void addFlowConstraints(const map2to1& x, const map2to1& y);

                void addFixedPrecedences(const map1to1& s, const map1to1& d);
                void addPrecedenceSelectionConstraints(const map2to1& y, const map2to1& w);
                void addSelectablePrecedences(const map1to1& s, const map1to1& d, const map2to1& w);
                void addAllPrecedences(const map1to1& s, const map1to1& d, const map2to1& y, const map2to1& w);

                void addMinimalDurationConstraints1(const map1to1& d, const map2to1& z);
                void addMinimalDurationConstraints2(const map1to1& d, const map2to1& y);
                void addMaximalDurationConstraints2(const map1to1& d, const map2to1& y);
                void addDurationConstraints(const map1to1& d, const map2to1& z, const map2to1& y);

                void addTimeLags(const map1to1& s, bool allRequired = true);
                void addSpatialCompatibilityConstraints(const map2to1& x);
                void addCollisions(const map1to1& s, const map1to1& d, const map2to1& x, const map2to1& y, const map4toN& c);
                void addGlobalConstraints(const map1to1& s, const map1to1& d, const map2to1& x, const map2to1& y, const map4toN& c);

                void addEnergyFunction(const map1to1& d, const map1to1& W, Location *loc, RobotPowerMode *pwrm);
                void addEnergyFunction(const map1to1& d, const map1to1& W, Movement* mv);
                void addSelectedPrecedences(const map1to1& s, const map1to1& d, const std::vector<Movement*>& mvs);
                void addCollisionResolution(const map1to1& s, const map1to1& d, uint32_t i, uint32_t j, int32_t multipleOfCycleTime);

        private:
                void initializeDataStructures();
                void addConstraint(SparseMatrix<double>::Row& row, Operator op, const double& b, std::string conDesc = "");

                double mCycleTime;
                uint64_t mConstraintsCounter;

                RoboticLine const* mLine;
                std::vector<Robot*> mRobots;
                const PrecalculatedMapping* mMapping;
                std::vector<StaticActivity*> mStaticActivities;
                std::vector<DynamicActivity*> mDynamicActivities;

                SparseMatrix<double> mA;
                std::vector<Operator> mOp;
                std::vector<double> mB;
                std::vector<std::string> mConDesc;
};

#endif