RODFDetector.h

Go to the documentation of this file.

/****************************************************************************/
// Class representing a detector within the DFROUTER
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright (C) 2001-2011 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This program 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 2 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef RODFDetector_h
#define RODFDetector_h


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

#include <map>
#include <string>
#include <vector>
#include <map>
#include <utils/common/SUMOTime.h>
#include <utils/common/RandomDistributor.h>
#include "RODFRouteCont.h"


// ===========================================================================
// class declarations
// ===========================================================================
class RODFRouteCont;
class RODFDetectorFlows;
class ROEdge;
class RODFEdge;
class RODFDetectorCon;
class RODFNet;
struct RODFRouteDesc;
class OutputDevice;


// ===========================================================================
// enumerations
// ===========================================================================
enum RODFDetectorType {
    TYPE_NOT_DEFINED = 0,

    DISCARDED_DETECTOR,

    BETWEEN_DETECTOR,

    SOURCE_DETECTOR,
    SINK_DETECTOR
};


// ===========================================================================
// class definitions
// ===========================================================================
class RODFDetector {
public:
    RODFDetector(const std::string& id, const std::string& laneID,
                 SUMOReal pos, const RODFDetectorType type) throw();


    RODFDetector(const std::string& id, const RODFDetector& f) throw();


    ~RODFDetector() throw();




    const std::string& getID() const throw() {
        return myID;
    };


    const std::string& getLaneID() const throw() {
        return myLaneID;
    };


    std::string getEdgeID() const throw() {
        return myLaneID.substr(0, myLaneID.rfind('_'));
    }


    SUMOReal getPos() const throw() {
        return myPosition;
    };


    RODFDetectorType getType() const throw() {
        return myType;
    };


    void setType(RODFDetectorType type);
    void addRoute(RODFRouteDesc& nrd);
    void addRoutes(RODFRouteCont* routes);
    bool hasRoutes() const;
    const std::vector<RODFRouteDesc> &getRouteVector() const;
    void addPriorDetector(RODFDetector* det);
    void addFollowingDetector(RODFDetector* det);
    const std::vector<RODFDetector*> &getPriorDetectors() const;
    const std::vector<RODFDetector*> &getFollowerDetectors() const;



    bool writeEmitterDefinition(const std::string& file,
                                const std::map<size_t, RandomDistributor<size_t>* > &dists,
                                const RODFDetectorFlows& flows,
                                SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset,
                                bool includeUnusedRoutes, SUMOReal scale,
                                bool insertionsOnly, SUMOReal defaultSpeed) const;
    bool writeRoutes(std::vector<std::string> &saved,
                     OutputDevice& out);
    void writeSingleSpeedTrigger(const std::string& file,
                                 const RODFDetectorFlows& flows,
                                 SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset,
                                 SUMOReal defaultSpeed);
    void writeEndRerouterDetectors(const std::string& file);

    void buildDestinationDistribution(const RODFDetectorCon& detectors,
                                      const RODFDetectorFlows& flows,
                                      SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset,
                                      const RODFNet& net,
                                      std::map<size_t, RandomDistributor<size_t>* > &into,
                                      int maxFollower) const;

    void computeSplitProbabilities(const RODFNet* net, const RODFDetectorCon& detectors,
                                   const RODFDetectorFlows& flows,
                                   SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset);

    const std::vector<std::map<RODFEdge*, SUMOReal> > &getSplitProbabilities() const {
        return mySplitProbabilities;
    }

protected:
    int getFlowFor(const ROEdge* edge, SUMOTime time) const;
    SUMOReal computeDistanceFactor(const RODFRouteDesc& rd) const;


protected:
    std::string myID;
    std::string myLaneID;
    SUMOReal myPosition;
    RODFDetectorType myType;
    RODFRouteCont* myRoutes;
    std::vector<RODFDetector*> myPriorDetectors, myFollowingDetectors;
    std::vector<std::map<RODFEdge*, SUMOReal> > mySplitProbabilities;
    std::map<std::string, RODFEdge*> myRoute2Edge;


private:
    RODFDetector(const RODFDetector& src);

    RODFDetector& operator=(const RODFDetector& src);

};


class RODFDetectorCon {
public:
    RODFDetectorCon();
    ~RODFDetectorCon();
    bool addDetector(RODFDetector* dfd);
    void removeDetector(const std::string& id);
    bool detectorsHaveCompleteTypes() const;
    bool detectorsHaveRoutes() const;
    const std::vector<RODFDetector*> &getDetectors() const;
    void save(const std::string& file) const;
    void saveAsPOIs(const std::string& file) const;
    void saveRoutes(const std::string& file) const;

    const RODFDetector& getDetector(const std::string& id) const;
    const RODFDetector& getAnyDetectorForEdge(const RODFEdge* const edge) const;

    bool knows(const std::string& id) const;
    void writeEmitters(const std::string& file,
                       const RODFDetectorFlows& flows,
                       SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset,
                       const RODFNet& net,
                       bool writeCalibrators, bool includeUnusedRoutes,
                       SUMOReal scale, int maxFollower,
                       bool insertionsOnly);

    void writeEmitterPOIs(const std::string& file,
                          const RODFDetectorFlows& flows);

    void writeSpeedTrigger(const RODFNet* const net, const std::string& file,
                           const RODFDetectorFlows& flows,
                           SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset);

    void writeValidationDetectors(const std::string& file,
                                  bool includeSources, bool singleFile, bool friendly);
    void writeEndRerouterDetectors(const std::string& file);

    int getAggFlowFor(const ROEdge* edge, SUMOTime time, SUMOTime period,
                      const RODFDetectorFlows& flows) const;

    void guessEmptyFlows(RODFDetectorFlows& flows);

    void mesoJoin(const std::string& nid, const std::vector<std::string> &oldids);


protected:
    void clearDists(std::map<size_t, RandomDistributor<size_t>* > &dists) const throw();


protected:
    std::vector<RODFDetector*> myDetectors;
    std::map<std::string, RODFDetector*> myDetectorMap;
    std::map<std::string, std::vector<RODFDetector*> > myDetectorEdgeMap;

private:
    RODFDetectorCon(const RODFDetectorCon& src);

    RODFDetectorCon& operator=(const RODFDetectorCon& src);

};


#endif

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