MSVehicleType.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2025 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
/****************************************************************************/
// The car-following model and parameter
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <cassert>
#include <map>
#include <string>
#include <microsim/cfmodels/MSCFModel.h>
#include <utils/common/SUMOTime.h>
#include <utils/common/StdDefs.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/common/RandHelper.h>
#include <utils/vehicle/SUMOVTypeParameter.h>
#include <utils/common/RGBColor.h>
#include <utils/emissions/EnergyParams.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSLane;
class MSCFModel;
class SUMOVTypeParameter;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSVehicleType {
public:
    MSVehicleType(const SUMOVTypeParameter& parameter);
 

    virtual ~MSVehicleType();
 

    bool wasSet(long long int what) const {
        return (myParameter.parametersSet & what) != 0;
    }
 


    const std::string& getID() const {
        return myParameter.id;
    }
 

    int getNumericalID() const {
        return myIndex;
    }
 

    double getLength() const {
        return myParameter.length;
    }
 

    double getLengthWithGap() const {
        return myParameter.length + myParameter.minGap;
    }
 

    double getMinGap() const {
        return myParameter.minGap;
    }

    double getMinGapLat() const {
        return myParameter.minGapLat;
    }
 

    inline const MSCFModel& getCarFollowModel() const {
        return *myCarFollowModel;
    }
 

    inline MSCFModel& getCarFollowModel() {
        return *myCarFollowModel;
    }
 
 
    inline LaneChangeModel getLaneChangeModel() const {
        return myParameter.lcModel;
    }
 

    double getMaxSpeed() const {
        return myParameter.maxSpeed;
    }

    double getDesiredMaxSpeed() const {
        return myParameter.desiredMaxSpeed;
    }
 

    double computeChosenSpeedDeviation(SumoRNG* rng, const double minDev = -1.) const;
 

    double getDefaultProbability() const {
        return myParameter.defaultProbability;
    }
 

    SUMOVehicleClass getVehicleClass() const {
        return myParameter.vehicleClass;
    }
 

    SUMOEmissionClass getEmissionClass() const {
        return myParameter.emissionClass;
    }
 

    inline double getMass() const {
        return myEnergyParams.getDouble(SUMO_ATTR_MASS);
    }
 

    const RGBColor& getColor() const {
        return myParameter.color;
    }
 

    const std::vector<std::string>& getParkingBadges() const {
        return myParameter.parkingBadges;
    }
 

    const Distribution_Parameterized& getSpeedFactor() const {
        return myParameter.speedFactor;
    }
 

    SUMOTime getActionStepLength() const {
        return myParameter.actionStepLength;
    }
 

    double getActionStepLengthSecs() const {
        return myCachedActionStepLengthSecs;
    }
 

    double getImpatience() const {
        return myParameter.impatience;
    }

 
 


    double getWidth() const {
        return myParameter.width;
    }

    double getSeatingWidth() const {
        return myParameter.seatingWidth >= 0 ? myParameter.seatingWidth : myParameter.width;
    }

    double getHeight() const {
        return myParameter.height;
    }

    SUMOVehicleShape getGuiShape() const {
        return myParameter.shape;
    }

    std::string getOSGFile() const {
        return myParameter.osgFile;
    }
 

    std::string getImgFile() const {
        return myParameter.imgFile;
    }
 

    int getPersonCapacity() const {
        return myParameter.personCapacity;
    }
 

    int getContainerCapacity() const {
        return myParameter.containerCapacity;
    }

    SUMOTime getLoadingDuration(const bool isPerson) const {
        return isPerson ? myParameter.boardingDuration : myParameter.loadingDuration;
    }

    SUMOTime getBoardingDuration(const bool isPerson) const {
        return isPerson ? myParameter.boardingDuration : myParameter.loadingDuration;
    }

    double getBoardingFactor() const {
        return myParameter.boardingFactor;
    }
 

    double getMaxSpeedLat() const {
        return myParameter.maxSpeedLat;
    }

    const LatAlignmentDefinition& getPreferredLateralAlignment() const {
        return myParameter.latAlignmentProcedure;
    }

    double getPreferredLateralAlignmentOffset() const {
        return myParameter.latAlignmentOffset;
    }

    double getFrontSeatPos() const {
        return myParameter.frontSeatPos;
    }

 


    void setAccel(double accel);

    void setDecel(double decel);

    void setEmergencyDecel(double emergencyDecel);

    void setApparentDecel(double apparentDecel);

    void setMaxAccelProfile(std::vector<std::pair<double, double> > accelProfile);

    void setDesAccelProfile(std::vector<std::pair<double, double> > accelProfile);

    void setImperfection(double imperfection);

    void setTau(double tau);

    void setLength(const double& length);
 

    void setHeight(const double& height);
 

    void setMinGap(const double& minGap);
 

    void setMinGapLat(const double& minGapLat);

    void setMaxSpeed(const double& maxSpeed);

    void setMaxSpeedLat(const double& maxSpeedLat);

    void setVClass(SUMOVehicleClass vclass);

    void setGUIShape(SUMOVehicleShape shape);
 

    void setDefaultProbability(const double& prob);
 

    void setSpeedFactor(const double& factor);
 

    void setSpeedDeviation(const double& dev);
 

    void setActionStepLength(const SUMOTime actionStepLength, bool resetActionOffset);
 

    void setEmissionClass(SUMOEmissionClass eclass);
 

    void setMass(double mass);
 

    void setColor(const RGBColor& color);
 

    void setParkingBadges(const std::vector<std::string>& badges);
 

    void setWidth(const double& width);
 

    void setShape(SUMOVehicleShape shape);

    void setBoardingDuration(SUMOTime duration, bool isPerson = true);

    void setImpatience(const double impatience);

    void setPreferredLateralAlignment(const LatAlignmentDefinition& latAlignment, double latAlignmentOffset = 0.0);

    void setScale(double value);

    void setLcContRight(const std::string& value);
 
 


    static MSVehicleType* build(SUMOVTypeParameter& from, const std::string& fileName = "");

    SUMOTime getEntryManoeuvreTime(const int angle) const;
    SUMOTime getExitManoeuvreTime(const int angle) const;
 

    MSVehicleType* buildSingularType(const std::string& id) const;
 

    MSVehicleType* duplicateType(const std::string& id, bool persistent) const;
 

    bool isVehicleSpecific() const {
        return myOriginalType != nullptr;
    }
 

    const std::string& getOriginalID() const {
        return myOriginalType != nullptr ? myOriginalType->getID() : getID();
    }
 
 
    const SUMOVTypeParameter& getParameter() const {
        return myParameter;
    }

    void check();

    inline const EnergyParams* getEmissionParameters() const {
        return &myEnergyParams;
    }
 
private:
    SUMOVTypeParameter myParameter;
 
    const EnergyParams myEnergyParams;

    double myCachedActionStepLengthSecs;

    bool myWarnedActionStepLengthTauOnce;
    bool myWarnedActionStepLengthBallisticOnce;
    bool myWarnedStepLengthTauOnce;

    const int myIndex;

    MSCFModel* myCarFollowModel;

    const MSVehicleType* myOriginalType;

    static int myNextIndex;
 
 
private:
    MSVehicleType(const MSVehicleType&) = delete;

    MSVehicleType& operator=(const MSVehicleType&) = delete;
};