MSCalibrator.h

Go to the documentation of this file.

/****************************************************************************/
// Calibrates the number of vehicles on a lane
/****************************************************************************/
// 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 MSCalibrator_h
#define MSCalibrator_h


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

#include <string>
#include <vector>
#include <utils/common/Command.h>
#include "MSTriggeredXMLReader.h"
#include "MSTrigger.h"
#include <utils/common/RandomDistributor.h>

#include <netload/NLDetectorBuilder.h>


// ===========================================================================
// class declarations
// ===========================================================================
class MSNet;
class MSLane;
class NLDetectorBuilder;
class MSInductLoop;


// ===========================================================================
// class definitions
// ===========================================================================
class MSCalibrator : public MSTrigger {
public:
    MSCalibrator(const std::string &id, MSNet &net, MSLane* destLane,
                 SUMOReal pos, const std::string &file) throw();

    virtual ~MSCalibrator() throw();


public:
    class MSCalibratorChild {
    public:
        MSCalibratorChild(MSCalibrator &parent, MSVehicleControl &vc)
                : myParent(parent), myVehicleControl(vc), myTimeOffset(0) { }

        virtual ~MSCalibratorChild() { }

        const MSRoute *getRndRoute() const {
            return myRouteDist.get();
        }

        const std::vector<const MSRoute*> &getAllRoutes() const {
            return myRouteDist.getVals();
        }

        MSVehicleType *getRndVType() const {
            return myVTypeDist.get();
        }

        bool hasRoutes() const {
            return myRouteDist.getOverallProb()!=0;
        }

        bool hasVTypes() const {
            return myVTypeDist.getOverallProb()!=0;
        }

        SUMOReal computeOffset(SUMOReal flow) const {
            SUMOReal freq = (SUMOReal)(1. / (flow / 3600.));
            SUMOReal ret = freq;
            myTimeOffset += (freq - (SUMOTime) ret);
            if (myTimeOffset>1) {
                myTimeOffset -= 1;
                ret += 1;
            }
            if (ret==0) { // !!! check what to do in this case (more than one vehicle/s)
                ret = 1;
            }
            return ret;
        }

        RandomDistributor<const MSRoute*> &getRouteDist() {
            return myRouteDist;
        }

    protected:
        MSCalibrator &myParent;

        MSVehicleControl &myVehicleControl;

        RandomDistributor<const MSRoute*> myRouteDist;

        RandomDistributor<MSVehicleType*> myVTypeDist;

        mutable SUMOReal myTimeOffset;

    private:
        MSCalibratorChild(const MSCalibratorChild&);

        MSCalibratorChild& operator=(const MSCalibratorChild&);


    };

public:
    bool childCheckEmit(MSCalibratorChild *child);

    size_t getActiveChildIndex() const;

    void setActiveChild(MSCalibratorChild *child);


protected:
    class MSCalibrator_FileTriggeredChild
                : public MSTriggeredXMLReader, public MSCalibratorChild, public Command {
    public:
        MSCalibrator_FileTriggeredChild(MSNet &net,
                                        const std::string &aXMLFilename, MSCalibrator &parent, MSVehicleControl &vc) throw();

        ~MSCalibrator_FileTriggeredChild() throw();

        bool processNextEntryReaderTriggered();



        SUMOTime execute(SUMOTime currentTime) throw(ProcessError);


        SUMOReal getLoadedFlow() const;

    protected:


        virtual void myStartElement(SumoXMLTag element,
                                    const SUMOSAXAttributes &attrs) throw(ProcessError);

        void inputEndReached();

        // !!! seee
        bool nextRead();
        //TM
    public:
        void buildAndScheduleFlowVehicle() {
            buildAndScheduleFlowVehicle(-1);
        }
        void buildAndScheduleFlowVehicle(SUMOReal speed);

    protected:
        bool myHaveNext;

        SUMOReal myFlow;

        bool myHaveInitialisedFlow;

        int myRunningID;

        SUMOTime myBeginTime;


    private:
        MSCalibrator_FileTriggeredChild(const MSCalibrator_FileTriggeredChild&);

        MSCalibrator_FileTriggeredChild& operator=(const MSCalibrator_FileTriggeredChild&);

    };

public:
    void schedule(MSCalibratorChild *child, MSVehicle *v, SUMOReal speed);

    //TM
    NLDetectorBuilder myDb;
    MSInductLoop * myIL;
    SUMOReal myToCalibrate;
    SUMOTime myInterval;
    SUMOReal myNumVehicles;
    int myDebugLevel;
    std::string myDebugFilesBaseName;

    static void updateCalibrator(std::string name, int time, SUMOReal count);

protected:
    MSNet &myNet;

    MSLane *myDestLane;

    SUMOReal myPos;


    MSCalibratorChild *myFileBasedCalibrator;

    std::map<MSCalibratorChild*, std::pair<MSVehicle*, SUMOReal> > myToEmit;

    MSCalibratorChild *myActiveChild;


    SUMOTime execute(SUMOTime currentTime) throw(ProcessError);
    static std::map<std::string, MSCalibrator*> calibratorMap;


private:
    MSCalibrator(const MSCalibrator&);

    MSCalibrator& operator=(const MSCalibrator&);


};


#endif

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