RoboticLine.h

Go to the documentation of this file.

/*
        This file is part of the GeneratorOfDatasets program.

        GeneratorOfDatasets 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.

        GeneratorOfDatasets 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 GeneratorOfDatasets. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef HLIDAC_PES_ROBOTIC_LINE_H
#define HLIDAC_PES_ROBOTIC_LINE_H

#include <iostream>
#include <stdint.h>
#include <sstream>
#include <string>
#include <vector>
#include <utility>
#include "ProjectParameters.h"

struct Monomial {
        int32_t degree;
        double coeff;
};

enum ActivityType {
        IN, OUT, INNER, WAIT, MOVEMENT,
};

template <class T>
std::string numberToString(const T& number)     {
        std::ostringstream ss;
        ss<<number;
        return ss.str();
}

class Movement {
        public:
                Movement(const uint32_t& from, const uint32_t& to, const ProjectParameters& par);

                uint32_t from() const { return mFrom; }
                uint32_t to() const { return mTo; }
                double minDuration() const { return mMinDuration; }
                double maxDuration() const { return mMaxDuration; }
                std::vector<Monomial> energyFunction() const { return mEnergyFunction; }
        private:
                uint32_t mFrom;
                uint32_t mTo;
                double mMinDuration;
                double mMaxDuration;
                std::vector<Monomial> mEnergyFunction;
};

class RobotPowerMode {
        public:
                RobotPowerMode(const uint32_t& pid, const double& delay) : mPid(pid), mMinimalDelay(delay), mExpectedInputPower(-1.0) { }

                uint32_t pid() const { return mPid; }
                void pid(const uint32_t& pid) { mPid = pid; }
                void powerSaveModeName(const std::string& name) { mName = name; }
                std::string powerSaveModeName() const { return mName; }
                double minimalDelay() const { return mMinimalDelay; }
                double expectedInputPower() const { return mExpectedInputPower; }
                void expectedInputPower(const double& expectedInputPower) { mExpectedInputPower = expectedInputPower; }
        private:
                uint32_t mPid;
                std::string mName;
                double mMinimalDelay;
                double mExpectedInputPower;
};

class LocationDependentPowerConsumption {
        public:
                LocationDependentPowerConsumption(RobotPowerMode* mode, const uint32_t& modeIdx, const ProjectParameters& par);

                RobotPowerMode* robotModeRef() const { return mMode; }
                double inputPower() const { return mInputPower; }
        private:
                RobotPowerMode *mMode;
                double mInputPower;
};

class Location {
        public:
                Location(const uint32_t& point, const std::vector<RobotPowerMode*>& robotModes, const ProjectParameters& par);

                uint32_t point() const { return mPoint; }
                std::vector<LocationDependentPowerConsumption> locationDependentPowerConsumption() const {
                        return mLocationDependentPowerConsumption;
                }
        private:
                uint32_t mPoint;
                std::vector<LocationDependentPowerConsumption> mLocationDependentPowerConsumption;
};

class Activity {
        public:
                Activity(const uint32_t& aid, const ActivityType& type) : mAid(aid), mType(type),
                                mMinAbsDuration(std::numeric_limits<double>::max()), mMaxAbsDuration(std::numeric_limits<double>::min()) { }

                uint32_t aid() const { return mAid; }
                ActivityType type() const { return mType; }
                void successors(const std::vector<Activity*>& successors) { mSuccessors = successors; }
                void addSuccessor(Activity* successor) { mSuccessors.push_back(successor); }
                std::vector<Activity*> successors() const { return mSuccessors; }
                void predecessors(const std::vector<Activity*>& predecessors) { mPredecessors = predecessors; }
                void addPredecessor(Activity* predecessor) { mPredecessors.push_back(predecessor); }
                std::vector<Activity*> predecessors() const { return mPredecessors; }
                void minAbsDuration(const double& minAbsDuration) { mMinAbsDuration = minAbsDuration; }
                double minAbsDuration() const { return mMinAbsDuration; }
                void maxAbsDuration(const double& maxAbsDuration) { mMaxAbsDuration = maxAbsDuration; }
                double maxAbsDuration() const { return mMaxAbsDuration; }
                virtual size_t numberOfModes() const = 0;

                virtual ~Activity() { }
        private:
                Activity(const Activity&) = delete;
                Activity& operator=(const Activity&) = delete;
        protected:
                uint32_t mAid;
                ActivityType mType;
                std::vector<Activity*> mSuccessors;
                std::vector<Activity*> mPredecessors;
                double mMinAbsDuration;
                double mMaxAbsDuration;
};

class StaticActivity : public Activity {
        public:
                StaticActivity(const uint32_t& aid, uint32_t& fromPoint, const ActivityType& type,
                                const std::vector<RobotPowerMode*>& robotModes, const ProjectParameters& par);

                std::vector<Location*> locations() const { return mLocations; }
                virtual size_t numberOfModes() const override { return mLocations.size(); }

                virtual ~StaticActivity() override;
        private:
                std::vector<Location*> mLocations;
};

class DynamicActivity: public Activity {
        public:
                DynamicActivity(const uint32_t& aid, StaticActivity* fromActivity,
                                StaticActivity* toActivity, const ProjectParameters& par);

                std::vector<Movement*> movements() const { return mMovements; }
                virtual size_t numberOfModes() const override { return mMovements.size(); }

                virtual ~DynamicActivity() override;
        private:
                std::vector<Movement*> mMovements;
};

class Robot {
        private:
                struct mCompositeBlock {
                        std::vector<StaticActivity*> in, w, out;
                        std::vector<DynamicActivity*> mv;
                        std::vector<StaticActivity*> con1, con2;
                };

        public:
                Robot(uint32_t& fromActivityId, uint32_t& fromPointId, const uint32_t& numberOfInputs, const uint32_t& numberOfOutputs, const ProjectParameters& par);

                std::vector<Activity*> activities() const { return mActivities; }
                std::vector<RobotPowerMode*> robotModes() const { return mRobotModes; }

                double lowerBoundOfCycleTime() const;

                ~Robot();
        private:

                Robot(const Robot&) = delete;
                Robot& operator=(const Robot&) = delete;


                mCompositeBlock createSerialSequence(uint32_t& fromActivityId, uint32_t& fromPointId) const;
                mCompositeBlock createAssemblyBlock(uint32_t& fromActivityId, uint32_t& fromPointId, const uint32_t& numberOfInputs) const;
                mCompositeBlock createDisassemblyBlock(uint32_t& fromActivityId, uint32_t& fromPointId, const uint32_t& numberOfOutputs) const;
                mCompositeBlock createComplexBlockHelper(uint32_t& fromActivityId, uint32_t& fromPointId, const uint32_t& numberOfSeq, const std::string& op) const;

                mCompositeBlock createBlockOfOperations(uint32_t& fromActivityId, uint32_t& fromPointId, const ActivityType& t1,
                                const ActivityType& t2, const Interval<uint32_t>& numSeq, const Interval<uint32_t>& seqLength) const;
                void connect(uint32_t& fromActivityId, mCompositeBlock& b, const std::vector<StaticActivity*>& from,
                                const std::vector<StaticActivity*>& to, bool fullyConnected = true) const;

                mCompositeBlock mergeBlocks(const std::vector<mCompositeBlock>& blocks) const;


                ProjectParameters mParameters;
                std::vector<Activity*> mActivities;
                std::vector<RobotPowerMode*> mRobotModes;
};

class TimeLag {
        public:
                TimeLag(Activity* from, Activity* to, const double& length, const int32_t& height)
                        : mFrom(from), mTo(to), mLength(length), mHeight(height) { }

                Activity* from() const { return mFrom; }
                Activity* to() const { return mTo; }
                double length() const { return mLength; }
                int32_t height() const { return mHeight; }
        private:
                Activity *mFrom;
                Activity *mTo;
                double mLength;
                int32_t mHeight;
};

class Pair {
        public:
                Pair(Activity* activity1, const uint32_t& mode1, Activity* activity2, const uint32_t& mode2) :
                        mActivity1(activity1), mActivity2(activity2), mMode1(mode1), mMode2(mode2) { }

                Activity* activity1() const { return mActivity1; }
                uint32_t mode1() const { return mMode1; }
                Activity* activity2() const { return mActivity2; }
                uint32_t mode2() const { return mMode2; }

                bool operator==(const Pair& p) const;

        private:

                Activity *mActivity1;
                Activity *mActivity2;
                uint32_t mMode1;
                uint32_t mMode2;
};

namespace std {
        template <>
        struct hash<Pair>       {
                size_t operator() (const Pair& p) const {
                        hash<Activity*> ptrHash;
                        hash<uint32_t> modeHash;
                        return ptrHash(p.activity1())^ptrHash(p.activity2())^modeHash(p.mode1())^modeHash(p.mode2());
                }
        };
}

class InterRobotOperation {
        public:
                InterRobotOperation(uint32_t oid, Activity* out, Activity* in, const ProjectParameters& par);

                uint32_t oid() const { return mOid; }
                std::string name() const { return mName; }
                void name(const std::string& name) { mName = name; }
                std::vector<TimeLag> timeLags() const { return mTimeLags; }
                void timeLags(const std::vector<TimeLag>& timeLags) { mTimeLags = timeLags; }
                std::vector<Pair> spatialCompatibility() const { return mSpatialCompatibility; }

        private:

                void generateSpatialCompatibilityPairs(Activity* a1, Activity* a2);

                uint32_t mOid;
                std::string mName;
                std::vector<TimeLag> mTimeLags;
                std::vector<Pair> mSpatialCompatibility;
};

class RoboticLine {
        public:
                RoboticLine(const ProjectParameters& par);

                std::vector<Robot*> robots() const { return mRobots; }
                std::vector<InterRobotOperation> interRobotOperations() const { return mInterRobotOperations; }
                std::vector<Pair> collisions() const { return mCollisions; }
                double productionCycleTime() const { return mProductionCycleTime; }
                std::vector<std::string> warnings() const { return mWarnings; }

                ~RoboticLine();
        private:
                RoboticLine(const RoboticLine&) = delete;
                RoboticLine& operator=(const RoboticLine&) = delete;

                void generateCollisions(const ProjectParameters& par);
                void calculateProductionCycleTime(const ProjectParameters& par);

                std::vector<Robot*> mRobots;
                std::vector<InterRobotOperation> mInterRobotOperations;
                std::vector<Pair> mCollisions;
                double mProductionCycleTime;

                std::vector<std::string> mWarnings;
};

#endif