NLJunctionControlBuilder.h

Go to the documentation of this file.

/****************************************************************************/
// Builder of microsim-junctions and tls
/****************************************************************************/
// 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 NLJunctionControlBuilder_h
#define NLJunctionControlBuilder_h


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

#include <string>
#include <vector>
#include <microsim/MSJunction.h>
#include <microsim/MSRightOfWayJunction.h>
#include <microsim/MSJunctionControl.h>
#include <utils/geom/Position2D.h>
#include <utils/geom/Position2DVector.h>
#include <microsim/traffic_lights/MSSimpleTrafficLightLogic.h>
#include <microsim/traffic_lights/MSActuatedTrafficLightLogic.h>
#include <microsim/MSBitSetLogic.h>
#include <microsim/traffic_lights/MSTLLogicControl.h>
#include <utils/common/UtilExceptions.h>


// ===========================================================================
// class declarations
// ===========================================================================
class OptionsCont;


// ===========================================================================
// class definitions
// ===========================================================================
class NLJunctionControlBuilder {
private:
    typedef std::vector<MSLane*> LaneVector;

public:
    NLJunctionControlBuilder(MSNet &net, OptionsCont &oc) throw();


    virtual ~NLJunctionControlBuilder() throw();


    void openJunction(const std::string &id, const std::string &key,
                      const std::string &type, SUMOReal x, SUMOReal y,
                      const Position2DVector &shape) throw(InvalidArgument);


    void addIncomingLane(MSLane *lane) throw();


#ifdef HAVE_INTERNAL_LANES

    void addInternalLane(MSLane *lane) throw();
#endif


    void addJunctionShape(const Position2DVector &shape) throw();


    void closeJunction() throw(InvalidArgument, ProcessError);


    MSJunctionControl *build() const throw();


    void initIncomingLanes() throw();


    void initJunctionLogic(const std::string &id, int requestSize, int laneNumber) throw();


    void addLogicItem(int request, const std::string &response,
                      const std::string &foes, bool cont) throw(InvalidArgument);


    void initTrafficLightLogic(const std::string &id, const std::string &programID,
                               const std::string &type, int offset, SUMOReal detectorOffset) throw();


    void addPhase(SUMOTime duration, const std::string &state,
                  int min, int max) throw();


    void setRequestSize(int size) throw();


    void setLaneNumber(int size) throw();


    void setKey(const std::string &key) throw();


    void setSubKey(const std::string &subkey) throw();


    void setOffset(int val) throw();


    MSTLLogicControl::TLSLogicVariants &getTLLogic(const std::string &id)
    const throw(InvalidArgument);


    MSTLLogicControl *buildTLLogics() const throw(ProcessError);


    virtual void closeTrafficLightLogic() throw(InvalidArgument, ProcessError);


    void closeJunctionLogic() throw(InvalidArgument);


    void closeJunctions(NLDetectorBuilder &db) throw();


    void addParam(const std::string &key, const std::string &value) throw();


    const std::string &getActiveID() const throw();


    const std::string &getActiveKey() const throw();


    const std::string &getActiveSubKey() const throw();


    MSTLLogicControl &getTLLogicControlToUse() const throw();


protected:
    MSJunctionLogic *getJunctionLogicSecure() throw(InvalidArgument);


protected:

    virtual MSJunction *buildNoLogicJunction() throw();


    virtual MSJunction *buildLogicJunction() throw(InvalidArgument);


#ifdef HAVE_INTERNAL_LANES

    virtual MSJunction *buildInternalJunction() throw();
#endif


protected:
    enum JunctionType {
        TYPE_UNKNOWN = 0,
        TYPE_NOJUNCTION,
        TYPE_RIGHT_BEFORE_LEFT,
        TYPE_PRIORITY_JUNCTION,
        TYPE_DEAD_END,
        TYPE_INTERNAL
    };


protected:
    MSNet &myNet;

    SUMOTime myOffset;

    std::string myLogicType;

    MSBitsetLogic::Logic *myActiveLogic;

    MSBitsetLogic::Foes *myActiveFoes;

    std::bitset<64> myActiveConts;

    MSSimpleTrafficLightLogic::Phases myActivePhases;

    int myRequestSize;

    int myLaneNumber;

    int myRequestItemNumber;

    mutable MSJunctionControl *myJunctions;

    LaneVector myActiveIncomingLanes;

#ifdef HAVE_INTERNAL_LANES
    LaneVector myActiveInternalLanes;
#endif

    std::string myActiveID;

    std::string myActiveKey, myActiveSubKey;

    JunctionType myType;

    Position2D myPosition;

    SUMOTime myAbsDuration;

    Position2DVector myShape;


    struct TLInitInfo {
        MSTrafficLightLogic *logic;
        std::map<std::string, std::string> params;
    };

    std::vector<TLInitInfo> myJunctions2PostLoadInit;


    SUMOReal myDetectorOffset;

    SUMOReal myStdDetectorPositions;

    SUMOReal myStdDetectorLengths;

    int myStdLearnHorizon;

    int myStdDecisionHorizon;

    SUMOReal myStdDeltaLimit;

    int myStdTCycle;

    // @brief Default maximum gap  (actuated)
    SUMOReal myStdActuatedMaxGap;

    // @brief Default passing time (actuated)
    SUMOReal myStdActuatedPassingTime;

    // @brief Default maximum gap (actuated)
    SUMOReal myStdActuatedDetectorGap;


    mutable MSTLLogicControl *myLogicControl;


    typedef std::map<std::string, std::string> StringParameterMap;

    StringParameterMap myAdditionalParameter;


    std::map<std::string, MSJunctionLogic*> myLogics;

    bool myCurrentHasError;


private:
    NLJunctionControlBuilder(const NLJunctionControlBuilder &s);

    NLJunctionControlBuilder &operator=(const NLJunctionControlBuilder &s);

};


#endif

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