MESegment.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2001-2018 German Aerospace Center (DLR) and others.
// This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v20.html
// SPDX-License-Identifier: EPL-2.0
/****************************************************************************/
// A single mesoscopic segment (cell)
/****************************************************************************/
#ifndef MESegment_h
#define MESegment_h


// ===========================================================================
// included modules
// ===========================================================================
#include <config.h>

#include <vector>
#include <utils/common/Named.h>
#include <utils/common/SUMOTime.h>


// ===========================================================================
// class declarations
// ===========================================================================
class MSEdge;
class MSLink;
class MSMoveReminder;
class MSVehicleControl;
class MEVehicle;
class BinaryInputDevice;
class OutputDevice;


// ===========================================================================
// class definitions
// ===========================================================================
class MESegment : public Named {
public:
    MESegment(const std::string& id,
              const MSEdge& parent, MESegment* next,
              double length, double speed,
              int idx,
              SUMOTime tauff, SUMOTime taufj,
              SUMOTime taujf, SUMOTime taujj,
              double jamThresh,
              bool multiQueue, bool junctionControl);


    typedef std::vector<MEVehicle*> Queue;
    typedef std::vector<Queue> Queues;

    void addDetector(MSMoveReminder* data);

    void removeDetector(MSMoveReminder* data);

    void prepareDetectorForWriting(MSMoveReminder& data);

    bool hasSpaceFor(const MEVehicle* veh, SUMOTime entryTime, bool init = false) const;

    bool initialise(MEVehicle* veh, SUMOTime time);

    int getCarNumber() const;

    inline int numQueues() const {
        return (int)myCarQues.size();
    }
    inline const Queue& getQueue(int index) const {
        assert(index < (int)myCarQues.size());
        return myCarQues[index];
    }

    inline int getIndex() const {
        return myIndex;
    }

    inline MESegment* getNextSegment() const {
        return myNextSegment;
    }

    inline double getLength() const {
        return myLength;
    }

    inline double getBruttoOccupancy() const {
        return myOccupancy;
    }


    inline double getRelativeOccupancy() const {
        return myOccupancy / myCapacity;
    }

    inline double getRelativeJamThreshold() const {
        return myJamThreshold / myCapacity;
    }

    double getMeanSpeed(bool useCache) const;

    inline double getMeanSpeed() const {
        return getMeanSpeed(true);
    }


    void writeVehicles(OutputDevice& of) const;

    MEVehicle* removeCar(MEVehicle* v, SUMOTime leaveTime, MESegment* next);

    MSLink* getLink(const MEVehicle* veh, bool tlsPenalty = false) const;

    bool isOpen(const MEVehicle* veh) const;

    void send(MEVehicle* veh, MESegment* next, SUMOTime time);

    void receive(MEVehicle* veh, SUMOTime time, bool isDepart = false, bool afterTeleport = false);


    bool vaporizeAnyCar(SUMOTime currentTime);

    inline const MSEdge& getEdge() const {
        return myEdge;
    }


    void setSpeed(double newSpeed, SUMOTime currentTime, double jamThresh = DO_NOT_PATCH_JAM_THRESHOLD);

    SUMOTime getEventTime() const;

    inline double getEventTimeSeconds() const {
        return STEPS2TIME(getEventTime());
    }

    inline double getLastHeadwaySeconds() const {
        return STEPS2TIME(myLastHeadway);
    }

    inline double getEntryBlockTimeSeconds() const {
        return STEPS2TIME(myEntryBlockTime);
    }


    void saveState(OutputDevice& out);

    void loadState(std::vector<std::string>& vehIDs, MSVehicleControl& vc, const SUMOTime blockTime, const int queIdx);


    std::vector<const MEVehicle*> getVehicles() const;


    double getFlow() const;


    static inline bool isInvalid(const MESegment* segment) {
        return segment == 0 || segment == &myVaporizationTarget;
    }

    SUMOTime getNextInsertionTime(SUMOTime earliestEntry) const;

    inline bool free() const {
        return myOccupancy <= myJamThreshold;
    }

    inline int remainingVehicleCapacity(const double vehLength) const {
        if (myOccupancy == 0. && myCapacity < vehLength) {
            // even small segments can hold at least one vehicle
            return 1;
        }
        return (int)((myCapacity - myOccupancy) / vehLength);
    }

    inline SUMOTime getEntryBlockTime() const {
        return myEntryBlockTime;
    }

    inline void setEntryBlockTime(SUMOTime entryBlockTime) {
        myEntryBlockTime = entryBlockTime;
    }

    inline SUMOTime getMinimumHeadwayTime() const {
        return myTau_ff;
    }

    static const double DO_NOT_PATCH_JAM_THRESHOLD;

    void addReminders(MEVehicle* veh) const;

    SUMOTime getLinkPenalty(const MEVehicle* veh) const;

    double getTLSCapacity(const MEVehicle* veh) const;

private:
    void updateDetectorsOnLeave(MEVehicle* v, SUMOTime currentTime, MESegment* next);

    bool overtake();

    SUMOTime getTimeHeadway(const MESegment* pred, const MEVehicle* veh);

    void setSpeedForQueue(double newSpeed, SUMOTime currentTime,
                          SUMOTime blockTime, const std::vector<MEVehicle*>& vehs);

    SUMOTime newArrival(const MEVehicle* const v, double newSpeed, SUMOTime currentTime);

    bool hasBlockedLeader() const;

    void recomputeJamThreshold(double jamThresh);

    double jamThresholdForSpeed(double speed, double jamThresh) const;

    bool limitedControlOverride(const MSLink* link) const;

    double getMaxPenaltySeconds() const;

    static bool useMultiQueue(bool multiQueue, const MSEdge& parent);

    inline SUMOTime tauWithVehLength(SUMOTime tau, double lengthWithGap) const {
        return tau + (SUMOTime)(lengthWithGap / myTau_length);
    }

private:
    const MSEdge& myEdge;

    MESegment* myNextSegment;

    const double myLength;

    const int myIndex;

    const SUMOTime myTau_ff, myTau_fj, myTau_jf, myTau_jj;
    double myTau_length;

    double myA, myB;

    const double myHeadwayCapacity;

    const double myCapacity;

    double myOccupancy;

    const bool myJunctionControl;

    const bool myTLSPenalty;

    const bool myMinorPenalty;

    double myJamThreshold;

    std::vector<MSMoveReminder*> myDetectorData;

    Queues myCarQues;

    std::map<const MSEdge*, std::vector<int> > myFollowerMap;

    std::vector<SUMOTime> myBlockTimes;

    /* @brief The block time for vehicles who wish to enter this segment.
     * @note since we do not know which queue will be used there is only one
     * value for all queues */
    SUMOTime myEntryBlockTime;

    SUMOTime myLastHeadway;

    /* @brief segment for signifying vaporization. This segment has invalid
     * data and should only be used as a unique pointer */
    static MSEdge myDummyParent;
    static MESegment myVaporizationTarget;

    mutable double myMeanSpeed;

    mutable SUMOTime myLastMeanSpeedUpdate;

private:
    MESegment(const MESegment&);

    MESegment& operator=(const MESegment&);

    MESegment(const std::string& id);
};


#endif

/****************************************************************************/