MSNet.h

Go to the documentation of this file.

/****************************************************************************/
// The simulated network and simulation perfomer
/****************************************************************************/
// 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 MSNet_h
#define MSNet_h


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

#include <typeinfo>
#include <vector>
#include <map>
#include <string>
#include <fstream>
#include <iostream>
#include <cmath>
#include <iomanip>
#include "MSVehicleControl.h"
#include "MSPersonControl.h"
#include "MSEventControl.h"
#include <utils/geom/Boundary.h>
#include <utils/geom/Position2D.h>
#include <utils/common/SUMOTime.h>
#include <microsim/trigger/MSBusStop.h>
#include <utils/common/UtilExceptions.h>

#ifdef _MESSAGES
#include <utils/common/NamedObjectCont.h>
#endif

// ===========================================================================
// class declarations
// ===========================================================================
class MSEdge;
class MSEdgeControl;
class MSJunctionControl;
class MSEmitControl;
class MSRouteLoaderControl;
class MSVehicle;
class MSRoute;
class MSLane;
class MSTLLogicControl;
class MSTrigger;
class MSDetectorControl;
class ShapeContainer;
class BinaryInputDevice;
class MSRouteLoader;
class MSEdgeWeightsStorage;
class SUMOVehicle;
#ifdef _MESSAGES
class MSMessageEmitter;
#endif


// ===========================================================================
// class definitions
// ===========================================================================
class MSNet {
public:
    enum SimulationState {
        SIMSTATE_RUNNING,
        SIMSTATE_END_STEP_REACHED,
        SIMSTATE_NO_FURTHER_VEHICLES,
        SIMSTATE_CONNECTION_CLOSED,
        SIMSTATE_ERROR_IN_SIM,
        SIMSTATE_TOO_MANY_VEHICLES
    };


public:
    static MSNet* getInstance() throw(ProcessError);


    MSNet(MSVehicleControl *vc, MSEventControl *beginOfTimestepEvents,
          MSEventControl *endOfTimestepEvents, MSEventControl *emissionEvents,
          ShapeContainer *shapeCont=0) throw(ProcessError);


    virtual ~MSNet() throw();


    void closeBuilding(MSEdgeControl *edges, MSJunctionControl *junctions,
                       MSRouteLoaderControl *routeLoaders, MSTLLogicControl *tlc,
                       std::vector<SUMOTime> stateDumpTimes, std::vector<std::string> stateDumpFiles) throw();


    static void clearAll();


    int simulate(SUMOTime start, SUMOTime stop);


    void simulationStep();


    void closeSimulation(SUMOTime start);


    SimulationState simulationState(SUMOTime stopTime) const throw();


    static std::string getStateMessage(SimulationState state) throw();


    SUMOTime getCurrentTimeStep() const;


    void writeOutput();


    bool logSimulationDuration() const throw();




    void preSimStepOutput() const throw();


    void postSimStepOutput() const throw();
    //}



#ifdef HAVE_MESOSIM


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


    unsigned int loadState(BinaryInputDevice &bis) throw();
#endif


    MSVehicleControl &getVehicleControl() throw() {
        return *myVehicleControl;
    }


    MSPersonControl &getPersonControl() throw();


    MSEdgeControl &getEdgeControl() throw() {
        return *myEdges;
    }


    MSEmitControl &getEmitControl() throw() {
        return *myEmitter;
    }


    MSDetectorControl &getDetectorControl() throw() {
        return *myDetectorControl;
    }


    MSTLLogicControl &getTLSControl() throw() {
        return *myLogics;
    }


    MSJunctionControl &getJunctionControl() throw() {
        return *myJunctions;
    }


    MSEventControl &getBeginOfTimestepEvents() throw() {
        return *myBeginOfTimestepEvents;
    }


    MSEventControl &getEndOfTimestepEvents() throw() {
        return *myEndOfTimestepEvents;
    }


    MSEventControl &getEmissionEvents() throw() {
        return *myEmissionEvents;
    }


    ShapeContainer &getShapeContainer() throw() {
        return *myShapeContainer;
    }


    MSEdgeWeightsStorage &getWeightsStorage() throw();




    bool addBusStop(MSBusStop* busStop) throw() {
        if (myBusStopDict.find(busStop->getID()) == myBusStopDict.end()) {
            myBusStopDict[busStop->getID()] = busStop;
            return true;
        }
        return false;
    }


    MSBusStop *getBusStop(const std::string &id) throw() {
        BusStopDictType::iterator it = myBusStopDict.find(id);
        if (it == myBusStopDict.end()) {
            return 0;
        }
        return it->second;
    }


    std::string getBusStopID(const MSLane* lane, const SUMOReal pos) throw() {
        for (BusStopDictType::iterator it = myBusStopDict.begin(); it != myBusStopDict.end(); ++it) {
            MSBusStop *stop = it->second;
            if (&stop->getLane() == lane && fabs(stop->getEndLanePosition() - pos) < POSITION_EPS) {
                return stop->getID();
            }
        }
        return "";
    }




    enum VehicleState {
        VEHICLE_STATE_BUILT,
        VEHICLE_STATE_DEPARTED,
        VEHICLE_STATE_STARTING_TELEPORT,
        VEHICLE_STATE_ENDING_TELEPORT,
        VEHICLE_STATE_ARRIVED
    };


    class VehicleStateListener {
    public:
        VehicleStateListener() throw() { }

        virtual ~VehicleStateListener() throw() { }

        virtual void vehicleStateChanged(const MSVehicle * const vehicle, VehicleState to) throw() = 0;

    };


    void addVehicleStateListener(VehicleStateListener *listener) throw();


    void removeVehicleStateListener(VehicleStateListener *listener) throw();


    void informVehicleStateListener(const MSVehicle * const vehicle, VehicleState to) throw();


    class EdgeWeightsProxi {
    public:
        EdgeWeightsProxi(const MSEdgeWeightsStorage &vehKnowledge,
                         const MSEdgeWeightsStorage &netKnowledge)
                : myVehicleKnowledge(vehKnowledge), myNetKnowledge(netKnowledge) {}


        ~EdgeWeightsProxi() {}


        SUMOReal getTravelTime(const MSEdge * const e, const SUMOVehicle * const v, SUMOReal t) const;


        SUMOReal getEffort(const MSEdge * const e, const SUMOVehicle * const v, SUMOReal t) const;

    private:
        const MSEdgeWeightsStorage &myVehicleKnowledge;

        const MSEdgeWeightsStorage &myNetKnowledge;

    };


#ifdef _MESSAGES
    typedef NamedObjectCont< MSMessageEmitter* > MsgEmitterDict;

    // TODO
    MSMessageEmitter *getMsgEmitter(const std::string& whatemit);

    void createMsgEmitter(std::string& id,
                          std::string& file,
                          const std::string& base,
                          std::string& whatemit,
                          bool reverse,
                          bool table,
                          bool xy,
                          SUMOReal step);
#endif

protected:
    static MSNet* myInstance;

    MSRouteLoaderControl *myRouteLoaders;

    SUMOTime myStep;




    MSVehicleControl *myVehicleControl;
    MSPersonControl *myPersonControl;
    MSEdgeControl* myEdges;
    MSJunctionControl* myJunctions;
    MSTLLogicControl *myLogics;
    MSEmitControl* myEmitter;
    MSDetectorControl *myDetectorControl;
    MSEventControl *myBeginOfTimestepEvents;
    MSEventControl *myEndOfTimestepEvents;
    MSEventControl *myEmissionEvents;
    ShapeContainer *myShapeContainer;
    MSEdgeWeightsStorage *myEdgeWeights;




    bool myLogExecutionTime;

    bool myLogStepNumber;

    long mySimStepBegin, mySimStepEnd, mySimStepDuration;

    long mySimBeginMillis;

    long myVehiclesMoved;
    //}




    std::vector<SUMOTime> myStateDumpTimes;
    std::vector<std::string> myStateDumpFiles;


    int myTooManyVehicles;


    typedef std::map< std::string, MSBusStop* > BusStopDictType;
    BusStopDictType myBusStopDict;

    std::vector<VehicleStateListener*> myVehicleStateListeners;


#ifdef _MESSAGES
    MsgEmitterDict myMsgEmitter;

    std::vector<MSMessageEmitter*> msgEmitVec;
#endif


private:
    MSNet(const MSNet&);

    MSNet& operator=(const MSNet&);


};


#endif

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