MSDetectorControl.h

Go to the documentation of this file.

/****************************************************************************/
// Detectors container; responsible for string and output generation
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright 2001-2010 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 MSDetectorControl_h
#define MSDetectorControl_h


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

#include <string>
#include <vector>
#include <utils/common/NamedObjectCont.h>
#include <microsim/output/MSE2Collector.h>
#include <microsim/output/MS_E2_ZS_CollectorOverLanes.h>
#include <microsim/output/MSE3Collector.h>
#include <microsim/output/MSInductLoop.h>
#include <microsim/output/MSRouteProbe.h>

#ifdef _MESSAGES
#include <microsim/output/MSMsgInductLoop.h>
#endif

#ifdef HAVE_MESOSIM
#include <mesosim/MEInductLoop.h>
#endif


// ===========================================================================
// class declarations
// ===========================================================================
class MSMeanData_Harmonoise;


// ===========================================================================
// class definitions
// ===========================================================================
class MSDetectorControl {
public:

#ifdef _MESSAGES
    typedef NamedObjectCont< MSMsgInductLoop*> MsgLoopDict;
#endif

    typedef NamedObjectCont< MSInductLoop*> LoopDict;

    typedef NamedObjectCont< MSE2Collector*> E2Dict;

    typedef NamedObjectCont< MSE3Collector*> E3Dict;

    typedef NamedObjectCont< MS_E2_ZS_CollectorOverLanes* > E2ZSOLDict;

    typedef NamedObjectCont< MSRouteProbe* > RouteProbeDict;

#ifdef HAVE_MESOSIM
    typedef NamedObjectCont< MEInductLoop*> MELoopDict;
#endif


    typedef std::vector< MSInductLoop*> LoopVect;

    typedef std::vector< MSE2Collector*> E2Vect;

    typedef std::vector< MSE3Collector*> E3Vect;

    typedef std::vector< MS_E2_ZS_CollectorOverLanes* > E2ZSOLVect;

#ifdef HAVE_MESOSIM
    typedef std::vector< MEInductLoop*> MELoopVect;
#endif


public:
    MSDetectorControl() throw();


    ~MSDetectorControl() throw();


    void close(SUMOTime step) throw(IOError);



#ifdef _MESSAGES

    void add(MSMsgInductLoop *msgl, OutputDevice& device, int splInterval) throw(ProcessError);
#endif

    void add(MSInductLoop *il, OutputDevice& device, int splInterval) throw(ProcessError);


    void add(MSE2Collector *e2, OutputDevice& device, int splInterval) throw(ProcessError);


    void add(MS_E2_ZS_CollectorOverLanes *e2ol, OutputDevice& device,
             int splInterval) throw(ProcessError);


    void add(MSE3Collector *e3, OutputDevice& device, int splInterval) throw(ProcessError);


    void add(MSRouteProbe *vp, OutputDevice& device, SUMOTime frequency, SUMOTime begin) throw(ProcessError);


#ifdef HAVE_MESOSIM

    void add(MEInductLoop *il, OutputDevice& device, int splInterval) throw(ProcessError);
#endif




    void add(MSE2Collector *e2) throw(ProcessError);


    void add(MS_E2_ZS_CollectorOverLanes *e2ol) throw(ProcessError);


    void add(MSMeanData_Harmonoise *mn) throw();



    void addDetectorAndInterval(MSDetectorFileOutput* det,
                                OutputDevice *device,
                                SUMOTime interval, SUMOTime begin=-1) throw();




    const LoopDict &getInductLoops() const throw() {
        return myLoops;
    }


    const E2Dict &getE2Detectors() const throw() {
        return myE2Detectors;
    }


    const E3Dict &getE3Detectors() const throw() {
        return myE3Detectors;
    }


    const E2ZSOLDict &getE2OLDetectors() const throw() {
        return myE2OverLanesDetectors;
    }



    void updateDetectors(SUMOTime step) throw();


    void writeOutput(SUMOTime step, bool closing) throw(IOError);


protected:

#ifdef _MESSAGES
    MsgLoopDict myMsgLoops;
#endif

    typedef std::pair< MSDetectorFileOutput*, OutputDevice* > DetectorFilePair;

    typedef std::vector< DetectorFilePair > DetectorFileVec;

    typedef std::pair<SUMOTime, SUMOTime> IntervalsKey;

    typedef std::map< IntervalsKey, DetectorFileVec > Intervals;

    struct detectorEquals : public std::binary_function< DetectorFilePair, MSDetectorFileOutput*, bool > {
        bool operator()(const DetectorFilePair& pair, const MSDetectorFileOutput* det) const throw() {
            return pair.first == det;
        }
    };

protected:

    LoopDict myLoops;

    E2Dict myE2Detectors;

    E3Dict myE3Detectors;

    E2ZSOLDict myE2OverLanesDetectors;

    RouteProbeDict myRouteProbeDetectors;

#ifdef HAVE_MESOSIM
    MELoopDict myMesoLoops;
#endif


    Intervals myIntervals;

    std::map<IntervalsKey, SUMOTime> myLastCalls;

    std::vector<MSMeanData_Harmonoise*> myHarmonoiseDetectors;


private:
    MSDetectorControl(const MSDetectorControl&);

    MSDetectorControl& operator=(const MSDetectorControl&);


};


#endif

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