MSEmitter.h

Go to the documentation of this file.

/****************************************************************************/
// A vehicle emitting device
/****************************************************************************/
// 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 MSEmitter_h
#define MSEmitter_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>


// ===========================================================================
// class declarations
// ===========================================================================
class MSNet;
class MSLane;


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

    virtual ~MSEmitter() throw();


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

        virtual ~MSEmitterChild() { }

        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:
        MSEmitter &myParent;

        MSVehicleControl &myVehicleControl;

        RandomDistributor<const MSRoute*> myRouteDist;

        RandomDistributor<MSVehicleType*> myVTypeDist;

        mutable SUMOReal myTimeOffset;

    private:
        MSEmitterChild(const MSEmitterChild&);

        MSEmitterChild& operator=(const MSEmitterChild&);

    };


public:
    bool childCheckEmit(MSEmitterChild *child);

    size_t getActiveChildIndex() const;

    void setActiveChild(MSEmitterChild *child);


protected:
    class MSEmitter_FileTriggeredChild
                : public MSTriggeredXMLReader, public MSEmitterChild, public Command {
    public:
        MSEmitter_FileTriggeredChild(MSNet &net,
                                     const std::string &aXMLFilename, MSEmitter &parent, MSVehicleControl &vc) throw();

        ~MSEmitter_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();

        void buildAndScheduleFlowVehicle();

    protected:
        bool myHaveNext;

        SUMOReal myFlow;

        bool myHaveInitialisedFlow;

        int myRunningID;

        SUMOTime myBeginTime;

    private:
        MSEmitter_FileTriggeredChild(const MSEmitter_FileTriggeredChild&);

        MSEmitter_FileTriggeredChild& operator=(const MSEmitter_FileTriggeredChild&);


    };

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

protected:
    MSNet &myNet;

    MSLane *myDestLane;

    SUMOReal myPos;

    MSEmitterChild *myFileBasedEmitter;

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

    MSEmitterChild *myActiveChild;

private:
    MSEmitter(const MSEmitter&);

    MSEmitter& operator=(const MSEmitter&);


};


#endif

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