MSCalibrator.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2005-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Calibrates the flow on an edge by removing an inserting vehicles
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <vector>
#include <utils/common/Command.h>
#include <microsim/MSRouteHandler.h>
#include <microsim/output/MSMeanData_Net.h>
#include <microsim/output/MSDetectorFileOutput.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class OutputDevice;
class MSRouteProbe;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSCalibrator : public MSRouteHandler, public Command, public MSDetectorFileOutput {
public:
    MSCalibrator(const std::string& id,
                 MSEdge* const edge,
                 MSLane* const lane,
                 MSJunction* const node,
                 const double pos,
                 const std::string& aXMLFilename,
                 const std::string& outputFilename,
                 const SUMOTime freq, const double length,
                 const MSRouteProbe* probe,
                 const double invalidJamThreshold,
                 const std::string& vTypes,
                 const bool local,
                 const bool addLaneMeanData);
 
    virtual ~MSCalibrator();
 
    void writeXMLOutput(OutputDevice& dev, SUMOTime startTime, SUMOTime stopTime);
 
 
    void writeXMLDetectorProlog(OutputDevice& dev) const;
 
    virtual SUMOTime execute(SUMOTime currentTime);
 
    static void cleanup();
 
    static const std::map<std::string, MSCalibrator*>& getInstances() {
        return myInstances;
    }
 
    struct AspiredState {
        AspiredState() : begin(-1), end(-1), q(-1.), v(-1.), vehicleParameter(0) {}
        SUMOTime begin;
        SUMOTime end;
        double q;
        double v;
        SUMOVehicleParameter* vehicleParameter;
    };
 
    AspiredState getCurrentStateInterval() const;
 
    const MSEdge* getEdge() const {
        return myEdge;
    }
 
    const MSLane* getLane() const {
        return myLane;
    }
 
    const MSRouteProbe* getRouteProbe() const {
        return myProbe;
    }
 
    inline virtual int passed() const {
        // calibrator measures at start of segment
        // vehicles drive to the end of an edge by default so they count as passed
        // but vaporized vehicles do not count
        // if the calibrator is located on a short edge, the vehicles are
        // vaporized on the next edge so we cannot rely on myEdgeMeanData.nVehVaporized
        return myEdgeMeanData.nVehEntered + myEdgeMeanData.nVehDeparted - myClearedInJam - myRemoved;
    }
 
    int getInserted() const {
        return myEdgeMeanData.nVehDeparted;
    }
 
    int getRemoved() const {
        return myClearedInJam + myRemoved;
    }
 
    void setFlow(SUMOTime begin, SUMOTime end, double vehsPerHour, double speed, SUMOVehicleParameter vehicleParameter);
 
protected:
    class CalibratorCommand : public Command {
    public:
        CalibratorCommand(MSCalibrator* cali) :
            myCalibrator(cali) {}
 
        SUMOTime execute(SUMOTime currentTime) {
            return myCalibrator->execute(currentTime);
        }
 
        SUMOTime shiftTime(SUMOTime currentTime, SUMOTime execTime, SUMOTime newTime);
 
    private:
        MSCalibrator* myCalibrator;
    };
 
 
 
 
    virtual void myStartElement(int element,
                                const SUMOSAXAttributes& attrs);
 
    virtual void myEndElement(int element);
 
 
 
    class VehicleRemover : public MSMoveReminder {
    public:
        VehicleRemover(MSLane* const lane, MSCalibrator* const parent, const bool undo = false) :
            MSMoveReminder(parent->getID(), lane, true), myParent(parent), myUndoCalibration(undo) {}
 
 
 
        virtual bool notifyEnter(SUMOTrafficObject& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane = nullptr);
 
        virtual bool notifyLeave(SUMOTrafficObject& veh, double lastPos, Notification reason, const MSLane* enteredLane = nullptr);
 
        void disable() {
            myParent = nullptr;
        }
 
    private:
        MSCalibrator* myParent;
        const bool myUndoCalibration;
    };
    friend class GUICalibrator;
 
    // @return whether the current state is active (GUI)
    bool isActive() const {
        return myAmActive;
    }
 
protected:
 
    void intervalEnd();
 
    bool isCurrentStateActive(SUMOTime time);
 
    bool tryEmit(MSLane* lane, MSVehicle* vehicle);
 
    void init();
 
    int totalWished() const;
 
    double currentFlow() const;
 
    double currentSpeed() const;
 
    /* @brief returns whether the lane is jammed although it should not be
     * @param[in] lane The lane to check or all for negative values
     */
    bool invalidJam(int laneIndex) const;
 
    inline int inserted() const {
        return myInserted;
    }
    inline int removed() const {
        return myRemoved;
    }
    inline int clearedInJam() const {
        return myClearedInJam;
    }
 
    /* @brief returns the number of vehicles (of the current type) that still
     * fit on the given lane
     * @param[in] lane The lane to check (return the maximum of all lanes for negative values)
     */
    int remainingVehicleCapacity(int laneIndex) const;
 
    virtual void reset();
 
    virtual void updateMeanData();
 
    bool scheduleRemoval(SUMOTrafficObject* veh) {
        return myToRemove.insert(veh->getID()).second;
    }
 
 
    bool removePending();
 
    std::string getNewVehicleID();
 
protected:
    MSEdge* const myEdge;
    MSLane* const myLane;
    MSJunction* const myNode;
    const double myPos;
    const MSRouteProbe* const myProbe;
    MSMeanData_Net myMeanDataParent;
    std::vector<MSMeanData_Net::MSLaneMeanDataValues*> myLaneMeanData;
    MSMeanData_Net::MSLaneMeanDataValues myEdgeMeanData;
 
    std::vector<AspiredState> myIntervals;
    std::vector<AspiredState>::const_iterator myCurrentStateInterval;
 
    std::vector<VehicleRemover*> myVehicleRemovers;
 
    std::set<std::string> myToRemove;
 
    OutputDevice* myOutput;
 
    SUMOTime myFrequency;
    int myRemoved;
    int myInserted;
    int myClearedInJam;
    bool mySpeedIsDefault;
    bool myDidSpeedAdaption;
    bool myDidInit;
    double myDefaultSpeed;
    bool myHaveWarnedAboutClearingJam;
 
    bool myAmActive;
 
    double myInvalidJamThreshold;
 
    bool myAmLocal;
 
    bool myHaveInvalidJam;
 
    /* @brief objects which need to live longer than the MSCalibrator
     * instance which created them */
    static std::vector<MSMoveReminder*> myLeftoverReminders;
    static std::vector<SUMOVehicleParameter*> myLeftoverVehicleParameters;
    static std::map<std::string, MSCalibrator*> myInstances;
 
};