RoboticLine.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_ROBOTIC_LINE_H
#define HLIDAC_PES_ROBOTIC_LINE_H

#include <cassert>
#include <algorithm>
#include <iostream>
#include <stdint.h>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <unordered_set>
#include <utility>
#include "SolverConfig.h"
#include "Shared/Exceptions.h"

class Activity;
class Location;
class DynamicActivity;
class StaticActivity;
class RobotPowerMode;
class LocationDependentPowerConsumption;
class Robot;
class RoboticLine;

class ActivityMode {
        public:
                ActivityMode() { };
                virtual uint32_t id() const = 0;
                virtual Activity* baseParent() const = 0;
                virtual ~ActivityMode() { };
};

class Activity {
        public:
                Activity(const uint32_t& aid) : mAid(aid), mLastInCycle(false), mParent(nullptr) { }
                uint32_t aid() const { return mAid; }
                std::string name() const { return mName; }
                std::string description() const { return mDescription; }
                bool lastInCycle() const { return mLastInCycle; }
                std::vector<Activity*> successors() const { return mSuccessors; }
                std::vector<Activity*> predecessors() const { return mPredecessors; }
                double minAbsDuration() const { return mMinAbsDuration; }
                double maxAbsDuration() const { return mMaxAbsDuration; }
                virtual bool mandatory() const = 0;
                virtual bool optional() const = 0;
                virtual size_t numberOfModes() const = 0;
                virtual Robot* parent() const = 0;
                virtual ~Activity() { }
        protected:
                void name(const std::string& name) { mName = name; }
                void description(const std::string& description) { mDescription = description; }
                void lastInCycle(const bool& lastInCycle) { mLastInCycle = lastInCycle; }
                void addSuccessor(Activity* successor) { mSuccessors.push_back(successor); }
                void addPredecessor(Activity* predecessor) { mPredecessors.push_back(predecessor); }
                void minAbsDuration(const double& minAbsDuration) { mMinAbsDuration = minAbsDuration; }
                void maxAbsDuration(const double& maxAbsDuration) { mMaxAbsDuration = maxAbsDuration; }

                virtual void parent(Robot* parent) = 0;
                virtual void freeAllocatedMemory() = 0;

                uint32_t mAid;
                bool mLastInCycle;
                std::string mName;
                std::string mDescription;
                std::vector<Activity*> mSuccessors;
                std::vector<Activity*> mPredecessors;
                double mMinAbsDuration;
                double mMaxAbsDuration;

                Robot *mParent;

                friend class Robot;
};

struct Monomial {
        int32_t degree;
        double coeff;
};

class Movement : public ActivityMode {
        public:
                Movement(const uint32_t& mid) : mMid(mid), mFrom(nullptr), mTo(nullptr), mParent(nullptr) { }
                virtual uint32_t id() const { return mMid; }
                uint32_t mid() const { return mMid; }
                Location* from() const { return mFrom; }
                Location* to() const { return mTo; }
                double minDuration() const { return mMinDuration; }
                double maxDuration() const { return mMaxDuration; }
                std::vector<Monomial> energyFunction() const { return mEnergyFunction; }
                double energyConsumption(const double& duration) const;
                DynamicActivity* parent() const { return mParent; }
                virtual Activity* baseParent() const { return (Activity*) mParent; }
                virtual ~Movement() = default;
        private:
                void from(Location* from) { mFrom = from; }
                void to(Location* to) { mTo = to; }
                void minDuration(const double& minDuration) { mMinDuration = minDuration; }
                void maxDuration(const double& maxDuration) { mMaxDuration = maxDuration; }
                void addMonomial(const Monomial& m) { mEnergyFunction.push_back(m); }
                void parent(DynamicActivity* parent) { mParent = parent; }

                uint32_t mMid;
                Location *mFrom;
                Location *mTo;
                double mMinDuration;
                double mMaxDuration;
                std::vector<Monomial> mEnergyFunction;

                DynamicActivity* mParent;

                friend class XmlReader;
                friend class DynamicActivity;
                friend class Robot;
};

class Location : public ActivityMode {
        public:
                Location(const uint32_t& lid = 0) : mLid(lid), mParent(nullptr) { }
                virtual uint32_t id() const { return mLid; }
                uint32_t lid() const { return mLid; }
                uint32_t point() const { return mPoint; }
                std::vector<LocationDependentPowerConsumption> locationDependentPowerConsumption() const {
                        return mLocationDependentPowerConsumption;
                }
                std::vector<Movement*> enteringMovements() const { return mEnteringMovements; }
                std::vector<Movement*> leavingMovements() const { return mLeavingMovements; }
                double inputPower(RobotPowerMode* m) const;
                double energyConsumption(const double& duration, RobotPowerMode* m) const;
                StaticActivity* parent() const { return mParent; }
                virtual Activity* baseParent() const { return (Activity*) mParent; }
                virtual ~Location() = default;
        private:
                void lid(const uint32_t& lid) { mLid = lid; }
                void point(const uint32_t& point) { mPoint = point; }
                void addLocationDependentPowerConsumption(const LocationDependentPowerConsumption& ldpc) {
                        mLocationDependentPowerConsumption.push_back(ldpc);
                }
                void enteringMovements(const std::vector<Movement*>& enteringMovements) { mEnteringMovements = enteringMovements; }
                void leavingMovements(const std::vector<Movement*>& leavingMovements) { mLeavingMovements = leavingMovements; }
                void parent(StaticActivity *parent);

                uint32_t mLid;
                uint32_t mPoint;
                std::vector<LocationDependentPowerConsumption> mLocationDependentPowerConsumption;
                std::vector<Movement*> mEnteringMovements;
                std::vector<Movement*> mLeavingMovements;

                StaticActivity *mParent;

                friend class XmlReader;
                friend class StaticActivity;
};

class DynamicActivity: public Activity {
        public:
                DynamicActivity(const uint32_t& aid) : Activity(aid) { }
                std::vector<Movement*> movements() const { return mMovements; }
                Movement* findMovement(const uint32_t& mid) const;
                StaticActivity* predecessor() const { return cessor("prede"); }
                StaticActivity* successor() const { return cessor("suc"); }
                virtual bool mandatory() const;
                virtual bool optional() const { return !mandatory(); }
                virtual size_t numberOfModes() const { return mMovements.size(); }
                virtual Robot* parent() const { return mParent; }
                virtual ~DynamicActivity() = default;
        private:
                void addMovement(Movement* mv) { mMovements.push_back(mv); }
                virtual void parent(Robot* parent);
                StaticActivity* cessor(const std::string& prefix) const;
                virtual void freeAllocatedMemory();

                std::vector<Movement*> mMovements;

                friend class XmlReader;
};

class StaticActivity : public Activity {
        public:
                StaticActivity(const uint32_t& aid) : Activity(aid) { }
                std::vector<Location*> locations() const { return mLocations; }
                Location* findLocation(const uint32_t& lid) const;
                double inputPower(const uint32_t& lid, const uint32_t& pid) const;
                double energyConsumption(double duration, const uint32_t& lid, const uint32_t& pid) const;
                virtual bool mandatory() const { return true; }
                virtual bool optional() const { return false; }
                virtual size_t numberOfModes() const { return mLocations.size(); }
                virtual Robot* parent() const { return mParent; }
                virtual ~StaticActivity() = default;
        private:
                void addLocation(Location* p) { mLocations.push_back(p); }
                virtual void parent(Robot* parent);
                void findMovementsForLocations();
                virtual void freeAllocatedMemory();

                std::vector<Location*> mLocations;

                friend class XmlReader;
                friend class Robot;
                friend class ParallelHeuristicSolver;
};

class RobotPowerMode {
        public:
                RobotPowerMode(const uint32_t& pid) : mPid(pid), mExpectedInputPower(-1), mParent(nullptr) { }
                uint32_t pid() const { return mPid; }
                std::string name() const { return mName; }
                std::string description() const { return mDescription; }
                double minimalDelay() const { return mMinimalDelay; }
                double expectedInputPower() const { return mExpectedInputPower; }
                Robot* parent() const { return mParent; }
        private:
                void pid(const uint32_t& pid) { mPid = pid; }
                void name(const std::string& name) { mName = name; }
                void description(const std::string& description) { mDescription = description; }
                void minimalDelay(const double& delay) { mMinimalDelay = delay; }
                void expectedInputPower(const double& expectedInputPower) { mExpectedInputPower = expectedInputPower; }
                void parent(Robot *parent) { mParent = parent; }

                uint32_t mPid;
                std::string mName;
                std::string mDescription;
                double mMinimalDelay;
                double mExpectedInputPower;

                Robot *mParent;

                friend class XmlReader;
                friend class Robot;
};

class LocationDependentPowerConsumption {
        public:
                LocationDependentPowerConsumption(const RobotPowerMode * rpm) : mPowerMode(rpm), mParent(nullptr) { }
                const RobotPowerMode* robotPowerMode() const { return mPowerMode; }
                double inputPower() const { return mInputPower; }
                Location *parent() const { return mParent; }
        private:
                void inputPower(const double& inputPower) { mInputPower = inputPower; }
                void parent(Location *parent) { mParent = parent; }

                const RobotPowerMode* mPowerMode;
                double mInputPower;

                Location *mParent;

                friend class XmlReader;
                friend class Location;
};

class Robot {
        public:
                Robot() : mParent(nullptr) { }
                std::string name() const { return mName; }
                std::string description() const { return mDescription; }
                std::vector<Activity*> activities() const { return mActivities; }
                std::vector<RobotPowerMode*> powerModes() const { return mRobotModes; }
                RobotPowerMode* fastestPowerSavingMode() const;
                RoboticLine* parent() const { return mParent; }
        private:
                void name(const std::string& name) { mName = name; }
                void description(const std::string& description) { mDescription = description; }
                void addActivity(Activity *a) { mActivities.push_back(a); }
                void addPowerMode(RobotPowerMode* m) { mRobotModes.push_back(m); }
                void parent(RoboticLine* parent);
                void setActivitiesRelations(const std::map<uint32_t, Location*>& pointToLocation,
                                const std::map<Movement*, std::pair<uint32_t, uint32_t>>& movementToPoints);
                void freeAllocatedMemory();

                std::string mName;
                std::string mDescription;
                std::vector<Activity*> mActivities;
                std::vector<RobotPowerMode*> mRobotModes;

                RoboticLine* mParent;

                friend class XmlReader;
                friend class RoboticLine;
};

class TimeLag {
        public:
                TimeLag(Activity* f, Activity* t, double l, int32_t h) : mFrom(f), mTo(t), mLength(l), mHeight(h) { }
                Activity* from() const { return mFrom; }
                Activity* to() const { return mTo; }
                double length() const { return mLength; }
                int32_t height() const { return mHeight; }
        private:
                void from(Activity* from) { mFrom = from; }
                void to(Activity* to) { mTo = to; }
                void length(const double& length) { mLength = length; }
                void height(const int32_t& height) { mHeight = height; }

                Activity *mFrom;
                Activity *mTo;
                double mLength;
                int32_t mHeight;
};

class InterRobotOperation {
        public:
                InterRobotOperation(const uint32_t& oid) : mOid(oid), mParent(nullptr) { }
                uint32_t oid() const { return mOid; }
                std::string name() const { return mName; }
                std::string description() const { return mDescription; }
                std::vector<TimeLag> timeLags() const { return mTimeLags; }
                std::vector<std::pair<Location*, Location*>> spatialCompatibility() const { return mSpatialCompatibility; }
                RoboticLine* parent() const { return mParent; }
        private:
                void name(const std::string& name) { mName = name; }
                void description(const std::string& description) { mDescription = description; }
                void addTimeLag(const TimeLag& lag) { mTimeLags.push_back(lag); }
                void addSpatialCompatibilityPair(Location *l1, Location *l2) { mSpatialCompatibility.emplace_back(l1, l2); }
                void parent(RoboticLine* parent) { mParent = parent; }

                uint32_t mOid;
                std::string mName;
                std::string mDescription;
                std::vector<TimeLag> mTimeLags;
                std::vector<std::pair<Location*, Location*>> mSpatialCompatibility;

                RoboticLine* mParent;

                friend class XmlReader;
                friend class RoboticLine;
};

class RoboticLine {
        public:
                RoboticLine();
                RoboticLine(const RoboticLine& l);
                RoboticLine& operator=(const RoboticLine& l);
                std::string name() const { return mName; }
                std::string description() const { return mDescription; }
                std::vector<Robot*> robots() const { return mRobots; }
                std::vector<InterRobotOperation*> interRobotOperations() const { return mInterRobotOperations; }
                std::vector<std::pair<ActivityMode*, ActivityMode*>> collisions() const { return mCollisions; }
                double productionCycleTime() const { return mProductionCycleTime; }
                ~RoboticLine();
        private:
                void name(const std::string& name) { mName = name; }
                void description(const std::string& description) { mDescription = description; }
                void addRobot(Robot* r) { mRobots.push_back(r); }
                void addInterRobotOperation(InterRobotOperation* op) { mInterRobotOperations.push_back(op); }
                void addCollision(const std::pair<ActivityMode*, ActivityMode*>& collision) { mCollisions.push_back(collision); }
                void productionCycleTime(const double& productionCycleTime) { mProductionCycleTime = productionCycleTime; }

                void setParentOfChildren(RoboticLine *rl);
                void initialiseDataStructures(const std::map<uint32_t, Location*>& pointToLocation,
                                const std::map<Movement*, std::pair<uint32_t, uint32_t>>& movementToPoints);
                void copyDataStructures(const RoboticLine& r);
                void freeAllocatedMemory();

                int64_t *mRefCounter;
                std::string mName;
                std::string mDescription;
                std::vector<Robot*> mRobots;
                std::vector<InterRobotOperation*> mInterRobotOperations;
                std::vector<std::pair<ActivityMode*, ActivityMode*>> mCollisions;
                double mProductionCycleTime;

                static std::map<int64_t*, std::set<RoboticLine*>> liveInstances;

                friend class XmlReader;
};

#endif