SUMOVehicleParameter.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-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
/****************************************************************************/
// Structure representing possible vehicle parameter
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <utils/common/Parameterised.h>
#include <utils/common/RGBColor.h>
#include <utils/common/SUMOTime.h>
#include <utils/common/SUMOVehicleClass.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class OutputDevice;
class OptionsCont;
 
 
// ===========================================================================
// value definitions
// ===========================================================================
const int VEHPARS_COLOR_SET = 1;
const int VEHPARS_VTYPE_SET = 2;
const int VEHPARS_DEPARTLANE_SET = 2 << 1;
const int VEHPARS_DEPARTPOS_SET = 2 << 2;
const int VEHPARS_DEPARTSPEED_SET = 2 << 3;
const int VEHPARS_END_SET = 2 << 4;
const int VEHPARS_NUMBER_SET = 2 << 5;
const int VEHPARS_PERIOD_SET = 2 << 6;
const int VEHPARS_VPH_SET = 2 << 7;
const int VEHPARS_PROB_SET = 2 << 8;
const int VEHPARS_POISSON_SET = 2 << 9;
const int VEHPARS_ROUTE_SET = 2 << 10;
const int VEHPARS_ARRIVALLANE_SET = 2 << 11;
const int VEHPARS_ARRIVALPOS_SET = 2 << 12;
const int VEHPARS_ARRIVALSPEED_SET = 2 << 13;
const int VEHPARS_LINE_SET = 2 << 14;
const int VEHPARS_FROM_TAZ_SET = 2 << 15;
const int VEHPARS_TO_TAZ_SET = 2 << 16;
const int VEHPARS_FORCE_REROUTE = 2 << 17;
const int VEHPARS_PERSON_CAPACITY_SET = 2 << 18;
const int VEHPARS_PERSON_NUMBER_SET = 2 << 19;
const int VEHPARS_CONTAINER_NUMBER_SET = 2 << 20;
const int VEHPARS_DEPARTPOSLAT_SET = 2 << 21;
const int VEHPARS_ARRIVALPOSLAT_SET = 2 << 22;
const int VEHPARS_VIA_SET = 2 << 23;
const int VEHPARS_SPEEDFACTOR_SET = 2 << 24;
const int VEHPARS_DEPARTEDGE_SET = 2 << 25;
const int VEHPARS_ARRIVALEDGE_SET = 2 << 26;
const int VEHPARS_CALIBRATORSPEED_SET = 2 << 27;
const int VEHPARS_JUNCTIONMODEL_PARAMS_SET = 2 << 28;
const int VEHPARS_CFMODEL_PARAMS_SET = 2 << 29;
const int VEHPARS_PARKING_BADGES_SET = 2 << 30;
 
const int STOP_INDEX_END = -1;
const int STOP_INDEX_FIT = -2;
 
const int STOP_START_SET = 1;
const int STOP_END_SET = 2;
const int STOP_DURATION_SET = 2 << 1;
const int STOP_UNTIL_SET = 2 << 2;
const int STOP_EXTENSION_SET = 2 << 3;
const int STOP_TRIGGER_SET = 2 << 4;
const int STOP_PARKING_SET = 2 << 5;
const int STOP_EXPECTED_SET = 2 << 6;
const int STOP_CONTAINER_TRIGGER_SET = 2 << 7;
const int STOP_EXPECTED_CONTAINERS_SET = 2 << 8;
const int STOP_TRIP_ID_SET = 2 << 9;
const int STOP_LINE_SET = 2 << 10;
const int STOP_SPEED_SET = 2 << 11;
const int STOP_SPLIT_SET = 2 << 12;
const int STOP_JOIN_SET = 2 << 13;
const int STOP_ARRIVAL_SET = 2 << 14;
const int STOP_PERMITTED_SET = 2 << 15;
const int STOP_ENDED_SET = 2 << 16;
const int STOP_STARTED_SET = 2 << 17;
const int STOP_POSLAT_SET = 2 << 18;
const int STOP_ONDEMAND_SET = 2 << 19;
const int STOP_JUMP_SET = 2 << 20;
 
const double MIN_STOP_LENGTH = 2 * POSITION_EPS;
 
 
// ===========================================================================
// enum definitions
// ===========================================================================
enum class DepartDefinition {
    GIVEN,
    TRIGGERED,
    CONTAINER_TRIGGERED,
    NOW,
    SPLIT,
    BEGIN,
    DEF_MAX
};
 
 
enum class DepartLaneDefinition {
    DEFAULT,
    GIVEN,
    RANDOM,
    FREE,
    ALLOWED_FREE,
    BEST_FREE,
    FIRST_ALLOWED
};
 
 
enum class DepartPosDefinition {
    DEFAULT,
    GIVEN,
    GIVEN_VEHROUTE,
    RANDOM,
    FREE,
    BASE,
    LAST,
    RANDOM_FREE,
    RANDOM_LOCATION,
    SPLIT_FRONT,
    STOP
};
 
 
enum class DepartPosLatDefinition {
    DEFAULT,
    GIVEN,
    GIVEN_VEHROUTE,
    RIGHT,
    CENTER,
    LEFT,
    RANDOM,
    FREE,
    RANDOM_FREE
};
 
 
enum class DepartSpeedDefinition {
    DEFAULT,
    GIVEN,
    GIVEN_VEHROUTE,
    RANDOM,
    MAX,
    DESIRED,
    LIMIT,
    LAST,
    AVG
};
 
 
enum class RouteIndexDefinition {
    DEFAULT,
    GIVEN,
    RANDOM,
};
 
 
enum class ArrivalLaneDefinition {
    DEFAULT = 0,
    CURRENT = 1,
    GIVEN = 2,
    RANDOM = 3,
    FIRST_ALLOWED = 4
};
 
 
enum class ArrivalPosDefinition {
    DEFAULT,
    GIVEN,
    RANDOM,
    CENTER,
    MAX
};
 
 
enum class ArrivalPosLatDefinition {
    DEFAULT,
    GIVEN,
    RIGHT,
    CENTER,
    LEFT
};
 
 
enum class ArrivalSpeedDefinition {
    DEFAULT,
    GIVEN,
    CURRENT
};
 
 
// ===========================================================================
// struct definitions
// ===========================================================================
class SUMOVehicleParameter : public Parameterised {
public:
    SUMOVehicleParameter();
 
    virtual ~SUMOVehicleParameter();
 
    class Stop : public Parameterised {
    public:
        virtual ~Stop() {}
 
        void write(OutputDevice& dev, const bool close = true, const bool writeTagAndParents = true) const;
 
        std::vector<std::string> getStoppingPlaceIDs() const;
 
        std::vector<std::string> getTriggers() const;
 
        std::string edge;
 
        std::string lane;
 
        std::string busstop;
 
        std::string containerstop;
 
        std::string parkingarea;
 
        std::string chargingStation;
 
        std::string overheadWireSegment;
 
        double startPos = 0.;
 
        double endPos = 0.;
 
        SUMOTime arrival = -1;
 
        SUMOTime duration = -1;
 
        SUMOTime until = -1;
 
        SUMOTime extension = -1;
 
        SUMOTime waitUntil = -1;
 
        bool triggered = false;
 
        bool containerTriggered = false;
 
        bool joinTriggered = false;
 
        ParkingType parking = ParkingType::ONROAD;
 
        std::set<std::string> awaitedPersons;
 
        std::set<std::string> permitted;
 
        std::set<std::string> awaitedContainers;
 
        bool friendlyPos = false;
 
        std::string actType;
 
        std::string tripId;
 
        std::string line;
 
        std::string split;
 
        std::string join;
 
        double speed = 0.;
 
        double posLat = INVALID_DOUBLE;
 
        bool onDemand = false;
 
        SUMOTime jump = -1;
 
        mutable SUMOTime started = -1;
 
        mutable SUMOTime ended = -1;
 
        std::vector<std::tuple<std::string, double, double> > accessPos;
 
        int index = 0;
 
        int parametersSet = 0;
 
        bool collision = false;
 
        int getFlags() const;
    };
 
 
    bool wasSet(int what) const {
        return (parametersSet & what) != 0;
    }
 
    void write(OutputDevice& dev, const OptionsCont& oc, const SumoXMLTag altTag = SUMO_TAG_VEHICLE, const std::string& typeID = "") const;
 
    bool defaultOptionOverrides(const OptionsCont& oc, const std::string& optionName) const;
 
 
    static bool parseDepart(const std::string& val, const std::string& element, const std::string& id,
                            SUMOTime& depart, DepartDefinition& dd, std::string& error, const std::string& attr = "departure");
 
    static bool parseDepartLane(const std::string& val, const std::string& element, const std::string& id,
                                int& lane, DepartLaneDefinition& dld, std::string& error);
 
    static bool parseDepartPos(const std::string& val, const std::string& element, const std::string& id,
                               double& pos, DepartPosDefinition& dpd, std::string& error);
 
    static bool parseDepartPosLat(const std::string& val, const std::string& element, const std::string& id,
                                  double& pos, DepartPosLatDefinition& dpd, std::string& error);
 
    static bool parseDepartSpeed(const std::string& val, const std::string& element, const std::string& id,
                                 double& speed, DepartSpeedDefinition& dsd, std::string& error);
 
    static bool parseRouteIndex(const std::string& val, const std::string& element, const std::string& id,
                                const SumoXMLAttr attr,
                                int& edgeIndex, RouteIndexDefinition& rid, std::string& error);
 
    static bool parseArrivalLane(const std::string& val, const std::string& element, const std::string& id,
                                 int& lane, ArrivalLaneDefinition& ald, std::string& error);
 
    static bool parseArrivalPos(const std::string& val, const std::string& element, const std::string& id,
                                double& pos, ArrivalPosDefinition& apd, std::string& error);
 
    static bool parseArrivalPosLat(const std::string& val, const std::string& element, const std::string& id,
                                   double& pos, ArrivalPosLatDefinition& apd, std::string& error);
 
 
    static bool parseArrivalSpeed(const std::string& val, const std::string& element, const std::string& id,
                                  double& speed, ArrivalSpeedDefinition& asd, std::string& error);
 
    static double interpretEdgePos(double pos, double maximumValue, SumoXMLAttr attr, const std::string& id, bool silent = false);
 
    static bool parsePersonModes(const std::string& modes, const std::string& element, const std::string& id, SVCPermissions& modeSet, std::string& error);
 
    static void parseStopTriggers(const std::vector<std::string>& triggers, bool expectTrigger, Stop& stop);
 
    static ParkingType parseParkingType(const std::string& value);
 
    SumoXMLTag tag;
 
    std::string id;
 
    std::string routeid;
 
    std::string vtypeid;
 
    mutable RGBColor color;
 
    SUMOTime depart;
 
    DepartDefinition departProcedure;
 
    int departLane;
 
    DepartLaneDefinition departLaneProcedure;
 
    double departPos;
 
    DepartPosDefinition departPosProcedure;
 
    double departPosLat;
 
    DepartPosLatDefinition departPosLatProcedure;
 
    double departSpeed;
 
    DepartSpeedDefinition departSpeedProcedure;
 
    int departEdge;
 
    RouteIndexDefinition departEdgeProcedure;
 
 
    int arrivalLane;
 
    ArrivalLaneDefinition arrivalLaneProcedure;
 
    double arrivalPos;
 
    ArrivalPosDefinition arrivalPosProcedure;
 
    double arrivalPosLat;
 
    ArrivalPosLatDefinition arrivalPosLatProcedure;
 
    double arrivalSpeed;
 
    ArrivalSpeedDefinition arrivalSpeedProcedure;
 
    int arrivalEdge;
 
    RouteIndexDefinition arrivalEdgeProcedure;
 
 
    int repetitionNumber;
 
    int repetitionsDone;
 
    SUMOTime repetitionOffset;
 
    SUMOTime repetitionTotalOffset;
 
    double repetitionProbability;
 
    double poissonRate;
 
    SUMOTime repetitionEnd;
 
 
    mutable std::string line;
 
    std::string fromTaz;
 
    std::string toTaz;
 
    mutable std::vector<Stop> stops;
 
    mutable std::vector<std::string> via;
 
    mutable std::vector <std::string> parkingBadges;
 
    int personNumber;
 
    int containerNumber;
 
    double speedFactor;
 
    double calibratorSpeed;
 
    int insertionChecks;
 
    mutable int parametersSet;
 
public:
    void incrementFlow(double scale, SumoRNG* rng = nullptr);
 
protected:
    std::string getDepart() const;
 
    std::string getDepartLane() const;
 
    std::string getDepartPos() const;
 
    std::string getDepartPosLat() const;
 
    std::string getDepartSpeed() const;
 
    std::string getDepartEdge() const;
 
    std::string getArrivalLane() const;
 
    std::string getArrivalPos() const;
 
    std::string getArrivalPosLat() const;
 
    std::string getArrivalSpeed() const;
 
    std::string getArrivalEdge() const;
 
    std::string getInsertionChecks() const;
 
    bool areInsertionChecksValid(const std::string& value) const;
 
    void parseInsertionChecks(const std::string& value);
};