MSVehicleControl.h

Go to the documentation of this file.

/****************************************************************************/
// The class responsible for building and deletion of vehicles
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright (C) 2001-2012 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This file is part of SUMO.
//   SUMO 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.
//
/****************************************************************************/
#ifndef MSVehicleControl_h
#define MSVehicleControl_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include <string>
#include <map>
#include <set>
#include "MSGlobals.h"
#include <utils/common/SUMOTime.h>
#include <utils/common/RandomDistributor.h>
#include <utils/common/SUMOVehicleParameter.h>


// ===========================================================================
// class declarations
// ===========================================================================
class SUMOVehicle;
class MSVehicle;
class MSRoute;
class MSVehicleType;
class BinaryInputDevice;
class MSEdge;


// ===========================================================================
// class definitions
// ===========================================================================
class MSVehicleControl {
public:
    typedef std::map<std::string, SUMOVehicle*>::const_iterator constVehIt;

public:
    MSVehicleControl() ;


    virtual ~MSVehicleControl() ;



    virtual SUMOVehicle* buildVehicle(SUMOVehicleParameter* defs, const MSRoute* route,
                                      const MSVehicleType* type) ;




    virtual bool addVehicle(const std::string& id, SUMOVehicle* v) ;


    SUMOVehicle* getVehicle(const std::string& id) const ;


    virtual void deleteVehicle(SUMOVehicle* v) ;


    void scheduleVehicleRemoval(SUMOVehicle* veh) ;


    constVehIt loadedVehBegin() const ;


    constVehIt loadedVehEnd() const ;




    void vehicleDeparted(const SUMOVehicle& v) ;




    unsigned int getLoadedVehicleNo() const {
        return myLoadedVehNo;
    }


    unsigned int getEndedVehicleNo() const {
        return myEndedVehNo;
    }


    unsigned int getRunningVehicleNo() const {
        return myRunningVehNo;
    }


    unsigned int getDepartedVehicleNo() const {
        return myRunningVehNo + myEndedVehNo;
    }


    bool isInQuota(const SUMOReal frac) const {
        if (MSGlobals::gFractions.find(frac) == MSGlobals::gFractions.end()) {
            return (myLoadedVehNo - 1) % 1000 < (unsigned int)(frac * 1000.);
        }
        return (myLoadedVehNo - 1) % MSGlobals::gFractions[frac].second < MSGlobals::gFractions[frac].first;
    }


    int getActiveVehicleCount() const {
        return myLoadedVehNo - (myWaitingForPerson + myEndedVehNo);
    }



    void printMeanWaitingTime(OutputDevice& od) const ;


    void printMeanTravelTime(OutputDevice& od) const ;





    bool addVType(MSVehicleType* vehType) ;


    bool addVTypeDistribution(const std::string& id, RandomDistributor<MSVehicleType*> *vehTypeDistribution) ;


    bool hasVTypeDistribution(const std::string& id) const ;


    MSVehicleType* getVType(const std::string& id = DEFAULT_VTYPE_ID) ;


    void insertVTypeIDs(std::vector<std::string> &into) const ;

    void addWaiting(const MSEdge* const edge, SUMOVehicle* vehicle) ;

    void removeWaiting(const MSEdge* const edge, SUMOVehicle* vehicle) ;

    SUMOVehicle* getWaitingVehicle(const MSEdge* const edge, const std::set<std::string> &lines) ;

    void registerOneWaitingForPerson() {
        myWaitingForPerson++;
    }

    void unregisterOneWaitingForPerson() {
        myWaitingForPerson--;
    }


    virtual void saveState(std::ostream& os) ;

    virtual void loadState(BinaryInputDevice& bis, const SUMOTime offset) ;
    //

    void abortWaiting() ;


private:
    bool checkVType(const std::string& id) ;


protected:

    unsigned int myLoadedVehNo;

    unsigned int myRunningVehNo;

    unsigned int myEndedVehNo;



    SUMOReal myTotalDepartureDelay;

    SUMOReal myTotalTravelTime;



    typedef std::map< std::string, SUMOVehicle* > VehicleDictType;
    VehicleDictType myVehicleDict;



    typedef std::map< std::string, MSVehicleType* > VTypeDictType;
    VTypeDictType myVTypeDict;

    typedef std::map< std::string, RandomDistributor<MSVehicleType*>* > VTypeDistDictType;
    VTypeDistDictType myVTypeDistDict;

    bool myDefaultVTypeMayBeDeleted;

    std::map<const MSEdge* const, std::vector<SUMOVehicle*> > myWaiting;

    unsigned int myWaitingForPerson;


private:
    MSVehicleControl(const MSVehicleControl& s);

    MSVehicleControl& operator=(const MSVehicleControl& s);


};


#endif

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