63 myNet(net), myActionBuilder(net),
64 myCurrentIsInternalToSkip(false),
65 myDetectorBuilder(detBuilder), myTriggerBuilder(triggerBuilder),
66 myEdgeControlBuilder(edgeBuilder), myJunctionControlBuilder(junctionBuilder),
67 myAmParsingTLLogicOrJunction(false), myCurrentIsBroken(false),
68 myHaveWarnedAboutInvalidTLType(false),
69 myHaveSeenInternalEdge(false),
70 myHaveSeenNeighs(false),
71 myHaveSeenAdditionalSpeedRestrictions(false),
74 myNetIsLoaded(false) {
281 myAmParsingTLLogicOrJunction =
false;
307 if (from ==
nullptr) {
308 WRITE_ERROR(
"Unknown from-node '" + it->second.first +
"' for edge '" + it->first +
"'.");
312 WRITE_ERROR(
"Unknown to-node '" + it->second.second +
"' for edge '" + it->first +
"'.");
315 if (edge !=
nullptr) {
364 WRITE_ERROR(
"Edge '" +
id +
"' has an invalid type.");
393 if (!crossingEdges.empty()) {
394 std::vector<std::string> crossingEdgesVector;
397 crossingEdgesVector.push_back(edges.
next());
447 if (shape.size() < 2) {
448 WRITE_ERROR(
"Shape of lane '" +
id +
"' is broken.\n Can not build according edge.");
453 if (permissions !=
SVCAll) {
463 WRITE_ERROR(
"Another lane with the id '" +
id +
"' exists.");
491 if (shape.size() > 2) {
501 WRITE_ERROR(
"An unknown or invalid junction type occurred in junction '" +
id +
"'.");
506 std::vector<MSLane*> incomingLanes;
509 std::vector<MSLane*> internalLanes;
519 WRITE_ERROR(e.what() + std::string(
"\n Can not build according junction."));
528 const std::string& def, std::vector<MSLane*>& into,
bool& ok) {
531 std::string laneID = st.
next();
536 if (lane ==
nullptr) {
537 WRITE_ERROR(
"An unknown lane ('" + laneID +
"') was tried to be set as incoming to junction '" + junctionID +
"'.");
541 into.push_back(lane);
646 if (request >= 0 && response.length() > 0) {
691 WRITE_ERROR(
"Traffic light '" +
id +
"' has unknown type '" + typeS +
"'.");
744 std::string phaseTypeString;
745 bool transient_notdecisional_bit;
752 transient_notdecisional_bit =
false;
754 if (phaseTypeString.find(
"decisional") != std::string::npos) {
755 transient_notdecisional_bit =
false;
756 }
else if (phaseTypeString.find(
"transient") != std::string::npos) {
757 transient_notdecisional_bit =
true;
759 MsgHandler::getWarningInstance()->
inform(
"SOTL_ATTL_TYPE_DECISIONAL nor SOTL_ATTL_TYPE_TRANSIENT. Assuming phase type as SUMOSOTL_TagAttrDefinitions::SOTL_ATTL_TYPE_TRANSIENT");
760 transient_notdecisional_bit =
false;
762 commit_bit = (phaseTypeString.find(
"commit") != std::string::npos);
764 if (phaseTypeString.find(
"target") != std::string::npos) {
765 std::string delimiter(
" ,;");
773 std::string::size_type firstPos = targetLanesString.find_first_not_of(delimiter, 0);
775 std::string::size_type pos = targetLanesString.find_first_of(delimiter, firstPos);
777 while (std::string::npos != pos || std::string::npos != firstPos) {
779 targetLanesVector.push_back(targetLanesString.substr(firstPos, pos - firstPos));
782 firstPos = targetLanesString.find_first_not_of(delimiter, pos);
785 pos = targetLanesString.find_first_of(delimiter, firstPos);
788 myJunctionControlBuilder.
addPhase(duration, state, nextPhases, minDuration, maxDuration, name, transient_notdecisional_bit, commit_bit, &targetLanesVector);
825 friendlyPos, vTypes);
862 WRITE_WARNING(
"VTypeProbes are deprecated. Use fcd-output devices (assigned to the vType) instead.");
910 const std::string
id = attrs.
get<std::string>(
SUMO_ATTR_ID,
nullptr, ok);
912 const std::string toLane = attrs.
getOpt<std::string>(
SUMO_ATTR_TO,
id.c_str(), ok,
"");
917 const double length = attrs.
getOpt<
double>(
SUMO_ATTR_LENGTH,
id.c_str(), ok, std::numeric_limits<double>::max());
922 WRITE_WARNING(
"Ignoring deprecated argument 'cont' for E2 detector '" +
id +
"'");
928 double endPosition = attrs.
getOpt<
double>(
SUMO_ATTR_ENDPOS,
id.c_str(), ok, std::numeric_limits<double>::max());
934 bool lanesGiven = lanes !=
"";
935 bool laneGiven = lane !=
"";
936 if (!(lanesGiven || laneGiven)) {
938 WRITE_WARNING(
"Trying to specify detector's lane by the given id since the argument 'lane' is missing.")
942 bool lengthGiven = length != std::numeric_limits<double>::max();
943 bool posGiven = position != std::numeric_limits<double>::max();
944 bool endPosGiven = endPosition != std::numeric_limits<double>::max();
945 bool lsaGiven = lsaid !=
"";
946 bool toLaneGiven = toLane !=
"";
949 std::vector<MSLane*> clanes;
952 std::string seps =
" ,\t\n";
956 std::string nextLaneID = st.
next();
958 if (nextLaneID.find_first_of(seps) != nextLaneID.npos) {
962 clanes.push_back(clane);
964 if (clanes.size() == 0) {
965 throw InvalidArgument(
"Malformed argument 'lanes' for E2Detector '" +
id +
"'.\nSpecify 'lanes' as a sequence of lane-IDs seperated by whitespace or comma (',')");
968 WRITE_WARNING(
"Ignoring argument 'lane' for E2Detector '" +
id +
"' since argument 'lanes' was given.\n" 969 "Usage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]");
972 WRITE_WARNING(
"Ignoring argument 'length' for E2Detector '" +
id +
"' since argument 'lanes' was given.\n" 973 "Usage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]");
978 WRITE_WARNING(
"Missing argument 'pos' for E2Detector '" +
id +
"'. Assuming detector start == lane start of lane '" + clanes[0]->getID() +
"'.");
982 endPosition = clanes[clanes.size() - 1]->getLength();
983 WRITE_WARNING(
"Missing argument 'endPos' for E2Detector '" +
id +
"'. Assuming detector end == lane end of lane '" + clanes[clanes.size() - 1]->getID() +
"'.");
988 std::stringstream ss;
989 ss <<
"Missing argument 'lane' for E2Detector '" <<
id <<
"'." 990 <<
"\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
997 if (endPosGiven && lengthGiven) {
998 std::stringstream ss;
999 ss <<
"Ignoring argument 'endPos' for E2Detector '" <<
id <<
"' since argument 'pos' was given." 1000 <<
"\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
1002 endPosition = std::numeric_limits<double>::max();
1004 if (!lengthGiven && !endPosGiven) {
1005 std::stringstream ss;
1006 ss <<
"Missing arguments 'length'/'endPos' for E2Detector '" <<
id <<
"'. Assuming detector end == lane end of lane '" << lane <<
"'.";
1008 endPosition = clane->getLength();
1010 }
else if (endPosGiven) {
1013 std::stringstream ss;
1014 ss <<
"Missing arguments 'length'/'pos' for E2Detector '" <<
id <<
"'. Assuming detector start == lane start of lane '" << lane <<
"'.";
1018 std::stringstream ss;
1019 if (lengthGiven && fabs(length - clane->getLength()) >
NUMERICAL_EPS) {
1020 ss <<
"Incomplete positional specification for E2Detector '" <<
id <<
"'." 1021 <<
"\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
1024 endPosition = clane->getLength();
1026 ss <<
"Missing arguments 'pos'/'endPos' for E2Detector '" <<
id <<
"'. Assuming that the detector covers the whole lane '" << lane <<
"'.";
1048 throw InvalidArgument(
"The detector '" +
id +
"' refers to an unknown lsa '" + lsaid +
"'.");
1050 if (frequency != -1) {
1051 WRITE_WARNING(
"Ignoring argument 'frequency' for E2Detector '" +
id +
"' since argument 'tl' was given.");
1057 MSLane* cToLane =
nullptr;
1063 std::string filename;
1074 haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold,
1075 vTypes, friendlyPos, showDetector,
1080 haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold,
1081 vTypes, friendlyPos, showDetector,
1095 const std::string file = attrs.
get<std::string>(
SUMO_ATTR_FILE,
id.c_str(), ok);
1104 frequency, haltingSpeedThreshold, haltingTimeThreshold, vTypes, openEntry);
1150 const std::string file = attrs.
get<std::string>(
SUMO_ATTR_FILE,
id.c_str(), ok);
1151 const std::string type = attrs.
getOpt<std::string>(
SUMO_ATTR_TYPE,
id.c_str(), ok,
"performance");
1159 int detectPersons = 0;
1160 for (std::string mode :
StringTokenizer(detectPersonsString).getVector()) {
1164 WRITE_ERROR(
"Invalid person mode '" + mode +
"' in edgeData definition '" +
id +
"'");
1172 excludeEmpty[0] !=
't' && excludeEmpty[0] !=
'T' && excludeEmpty[0] !=
'1' && excludeEmpty[0] !=
'x',
1173 excludeEmpty ==
"defaults", withInternal, trackVehicles, detectPersons,
1174 maxTravelTime, minSamples, haltingSpeedThreshold, vtypes,
1188 const std::string toID = attrs.
get<std::string>(
SUMO_ATTR_TO,
nullptr, ok);
1211 if (from ==
nullptr) {
1212 WRITE_ERROR(
"Unknown from-edge '" + fromID +
"' in connection.");
1216 if (to ==
nullptr) {
1217 WRITE_ERROR(
"Unknown to-edge '" + toID +
"' in connection.");
1220 if (fromLaneIdx < 0 || fromLaneIdx >= (
int)from->getLanes().size() ||
1221 toLaneIdx < 0 || toLaneIdx >= (int)to->
getLanes().size()) {
1222 WRITE_ERROR(
"Invalid lane index in connection from '" + from->getID() +
"' to '" + to->
getID() +
"'.");
1225 MSLane* fromLane = from->getLanes()[fromLaneIdx];
1236 if ((tlLinkIdx < 0 || tlLinkIdx >= (
int)logic->getCurrentPhaseDef().getState().size())
1240 "' in connection controlled by '" + tlID +
"'");
1252 if (via ==
nullptr) {
1254 "') should be set as a via-lane for lane '" + toLane->
getID() +
"'.");
1261 link =
new MSLink(fromLane, toLane, via, dir, state, length, foeVisibilityDistance, keepClear, logic, tlLinkIdx);
1262 if (via !=
nullptr) {
1325 WRITE_WARNING(
"no valid geo projection loaded from network. fcd-output.geo will not work");
1347 sink->
initialize(
new std::vector<MSLane*>());
1353 source->
initialize(
new std::vector<MSLane*>());
1356 for (std::vector<std::string>::const_iterator i = desc.begin(); i != desc.end(); ++i) {
1359 if (edge ==
nullptr) {
1372 if (shape.size() != 0) {
1373 if (!
myNet.
getShapeContainer().
addPolygon(
myCurrentDistrictID,
"taz", color, 0, 0,
"",
false, shape,
false,
false, 1.0)) {
1394 if (succ !=
nullptr) {
1411 for (std::vector<std::string>::iterator it = edgeIDs.begin(); it != edgeIDs.end(); ++it) {
1413 if (edge ==
nullptr) {
1414 WRITE_ERROR(
"Unknown edge '" + (*it) +
"' in roundabout");
1453 if (lane ==
nullptr) {
1454 WRITE_ERROR(
"Lane '" + laneID +
"' to place poi '" + poiID +
"' on is not known.");
1460 if (lanePos < 0 || lanePos > lane->
getLength()) {
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
void parseAndAddLotEntry(const SUMOSAXAttributes &attrs)
Parses his values and adds a lot entry to current parking area.
static MsgHandler * getWarningInstance()
Returns the instance to add warnings to.
void parseAndBuildCalibrator(MSNet &net, const SUMOSAXAttributes &attrs, const std::string &base)
Parses his values and builds a mesoscopic or microscopic calibrator.
void beginE3Detector(const SUMOSAXAttributes &attrs)
Starts building of an e3 detector using the given specification.
void initTrafficLightLogic(const std::string &id, const std::string &programID, TrafficLightType type, SUMOTime offset)
Begins the reading of a traffic lights logic.
SumoXMLTag
Numbers representing SUMO-XML - element names.
static MsgHandler * getErrorInstance()
Returns the instance to add errors to.
void addWAUTJunction(const SUMOSAXAttributes &attrs)
Builds detectors for microsim.
virtual void myEndElement(int element)
Called when a closing tag occurs.
virtual void addE2Detector(const SUMOSAXAttributes &attrs)
Builds an e2 detector using the given specification.
static RGBColor parseColor(std::string coldef)
Parses a color information.
alternative tag for e1 detector
bool myCurrentIsInternalToSkip
Information whether the currently parsed edge is internal and not wished, here.
Whether vehicles must keep the junction clear.
a source within a district (connection road)
void addAccess(MSNet &net, const SUMOSAXAttributes &attrs)
Parses the values and adds an access point to the currently parsed stopping place.
Storage for all programs of a single tls.
std::string next()
returns the next substring when it exists. Otherwise the behaviour is undefined
void buildInstantInductLoop(const std::string &id, const std::string &lane, double pos, const std::string &device, bool friendlyPos, const std::string &vTypes)
Builds an instantenous induction and adds it to the net.
MSLane * getLaneChecking(const std::string &laneID, SumoXMLTag type, const std::string &detid)
Returns the named lane.
root element of a network file
begin/end of the description of a junction
virtual MSEdge * closeEdge()
Closes the building of an edge; The edge is completely described by now and may not be opened again...
begin/end of the description of a single lane
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
bool myHaveWarnedAboutInvalidTLType
virtual void openWAUT(const SUMOSAXAttributes &attrs)
void beginEdgeParsing(const std::string &id, const SumoXMLEdgeFunc function, const std::string &streetName, const std::string &edgeType, int priority, const std::string &bidi, double distance)
Begins building of an MSEdge.
void addSuccessor(MSEdge *edge, const MSEdge *via=nullptr)
Adds an edge to the list of edges which may be reached from this edge and to the incoming of the othe...
void addIncoming(MSEdge *edge)
A calibrator placed over edge.
void openJunction(const std::string &id, const std::string &key, const SumoXMLNodeType type, const Position pos, const PositionVector &shape, const std::vector< MSLane *> &incomingLanes, const std::vector< MSLane *> &internalLanes)
Begins the processing of the named junction.
a traffic assignment zone
connectio between two lanes
The base class for an intersection.
void addE3Entry(const std::string &lane, double pos, bool friendlyPos)
Builds an entry point of an e3 detector.
const double SUMO_const_laneWidth
static std::string getJunctionIDFromInternalEdge(const std::string internalEdge)
return the junction id when given an edge of type internal, crossing or WalkingArea ...
const std::string & getFileName() const
returns the current file name
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
void addLink(MSLink *link)
Delayed initialization.
virtual void addVTypeProbeDetector(const SUMOSAXAttributes &attrs)
Builds a vtype-detector using the given specification.
void addRoundabout(const SUMOSAXAttributes &attrs)
NLDetectorBuilder & myDetectorBuilder
The detector builder to use.
void parseAndBuildChargingStation(MSNet &net, const SUMOSAXAttributes &attrs)
Parses his values and builds a charging station.
foe visibility distance of a link
void parseAndBuildRerouter(MSNet &net, const SUMOSAXAttributes &attrs, const std::string &base)
Parses his values and builds a rerouter.
void closeJunctionLogic()
Ends the building of a junction logic (row-logic)
void ignoreLinkIndex(int pos)
weights: time range begin
link,node: the traffic light id responsible for this link
void addStopOffsets(const std::map< SVCPermissions, double > &stopOffsets)
process a stopOffset element (originates either from the active edge or lane).
std::map< SVCPermissions, double > parseStopOffsets(const SUMOSAXAttributes &attrs, bool &ok)
Extract stopOffsets from attributes of stopOffset element.
void addIncomingLane(MSLane *lane, MSLink *viaLink)
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
void buildRouteProbe(const std::string &id, const std::string &edge, SUMOTime frequency, SUMOTime begin, const std::string &device, const std::string &vTypes)
Builds a routeProbe and adds it to the net.
double getLength() const
Returns the lane's length.
const PositionVector & getShape() const
Returns this lane's shape.
static bool dictionary(const std::string &id, MSEdge *edge)
Inserts edge into the static dictionary Returns true if the key id isn't already in the dictionary...
virtual void addE1Detector(const SUMOSAXAttributes &attrs)
Builds an e1 detector using the given specification.
NLHandler(const std::string &file, MSNet &net, NLDetectorBuilder &detBuilder, NLTriggerBuilder &triggerBuilder, NLEdgeControlBuilder &edgeBuilder, NLJunctionControlBuilder &junctionBuilder)
Constructor.
void initialize(const std::vector< MSLane *> *lanes)
Initialize the edge.
void addLink(MSLink *link, MSLane *lane, int pos)
void beginEdgeParsing(const SUMOSAXAttributes &attrs)
begins the processing of an edge
maximum duration of a phase
const std::string & getID() const
Returns the id.
virtual bool addPolygon(const std::string &id, const std::string &type, const RGBColor &color, double layer, double angle, const std::string &imgFile, bool relativePath, const PositionVector &shape, bool geo, bool fill, double lineWidth, bool ignorePruning=false)
Builds a polygon using the given values and adds it to the container.
const std::string & getActiveSubKey() const
Returns the active sub key.
static StringBijection< LinkState > LinkStates
link states
bool hasNext()
returns the information whether further substrings exist
const SVCPermissions SVCAll
all VClasses are allowed
std::string myCurrentDistrictID
The id of the current district.
begin/end of the description of an edge restriction
A parking space for a single vehicle within a parking area.
void closeWAUT(const std::string &wautid)
Closes loading of a WAUT.
void parseAndBeginParkingArea(MSNet &net, const SUMOSAXAttributes &attrs)
Parses his values and builds a parking area.
void buildVTypeProbe(const std::string &id, const std::string &vtype, SUMOTime frequency, const std::string &device)
Builds a vTypeProbe and adds it to the net.
virtual void endE3Detector()
Builds of an e3 detector using collected values.
void endE3Detector()
Builds of an e3 detector using collected values.
bool myAmParsingTLLogicOrJunction
internal information whether a tls-logic is currently read
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list...
SUMOTime getSUMOTimeReporting(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
virtual SumoXMLEdgeFunc getEdgeFunc(bool &ok) const =0
Returns the value of the named attribute.
A class that stores a 2D geometrical boundary.
#define WRITE_WARNING(msg)
The simulated network and simulation perfomer.
static OptionsCont & getOptions()
Retrieves the options.
int getNumberOfLoadedPhases() const
return the number of phases loaded so far (for error reporting)
virtual std::string getString(int id) const =0
Returns the string-value of the named (by its enum-value) attribute.
void parseLanes(const std::string &junctionID, const std::string &def, std::vector< MSLane *> &into, bool &ok)
void closeJunction(const std::string &basePath)
Closes (ends) the processing of the current junction.
MSTLLogicControl::TLSLogicVariants & getTLLogic(const std::string &id) const
Returns a previously build tls logic.
LinkDirection
The different directions a link between two lanes may take (or a stream between two edges)...
bool myHaveSeenAdditionalSpeedRestrictions
whether additional files contained type-specific speed limits
void addE3Exit(const std::string &lane, double pos, bool friendlyPos)
Builds an exit point of an e3 detector.
void addParam(const SUMOSAXAttributes &attrs)
an edge based mean data detector
void addDistrict(const SUMOSAXAttributes &attrs)
static StringBijection< LinkDirection > LinkDirections
link directions
virtual MSLane * addLane(const std::string &id, double maxSpeed, double length, const PositionVector &shape, double width, SVCPermissions permissions, int index, bool isRampAccel, const std::string &type)
Adds a lane to the current edge.
void addApproachingLane(MSLane *lane, bool warnMultiCon)
A road/street connecting two junctions.
void setLocation(const SUMOSAXAttributes &attrs)
Parses network location description.
The definition of a periodic event.
MSStoppingPlace * getCurrentStop()
virtual void openJunction(const SUMOSAXAttributes &attrs)
opens a junction for processing
NLEdgeControlBuilder & myEdgeControlBuilder
The edge builder to use.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
void updateParameter(const std::map< std::string, std::string > &mapArg)
Adds or updates all given parameters from the map.
void addE3Entry(const SUMOSAXAttributes &attrs)
Adds an entry to the currently processed e3 detector.
Encapsulated SAX-Attributes.
An instantenous induction loop.
void addE3Exit(const SUMOSAXAttributes &attrs)
Adds an exit to the currently processed e3 detector.
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
Builder of microsim-junctions and tls.
ShapeContainer & getShapeContainer()
Returns the shapes container.
A point in 2D or 3D with translation and scaling methods.
virtual void endParkingArea()
End a parking area.
parameter associated to a certain key
virtual void closeTrafficLightLogic(const std::string &basePath)
Ends the building of a traffic lights logic.
void addWAUTSwitch(const SUMOSAXAttributes &attrs)
JunctionGraph myJunctionGraph
void addRequest(const SUMOSAXAttributes &attrs)
adds a request item to the current junction logic
void setPermissionsFound()
Labels the network to contain vehicle class permissions.
T get(const std::string &str) const
Position getLanePos(const std::string &poiID, const std::string &laneID, double lanePos, double lanePosLat)
get position for a given laneID (Has to be implemented in all child)
void addConnection(const SUMOSAXAttributes &attrs)
adds a connection
std::string myCurrentTypeID
The id of the currently processed edge type.
void parseAndBuildLaneSpeedTrigger(MSNet &net, const SUMOSAXAttributes &attrs, const std::string &base)
Parses his values and builds a lane speed trigger.
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic, in MSLink and GNEInternalLane.
void addAction(const SUMOSAXAttributes &attrs, const std::string &basePath)
Builds an action and saves it for further use.
static bool init(OptionsCont &oc)
Initialises the processing and the final instance using the given options.
SUMOTime string2time(const std::string &r)
roundabout defined in junction
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
void addRestriction(const std::string &id, const SUMOVehicleClass svc, const double speed)
Adds a restriction for an edge type.
void parseAndBuildStoppingPlace(MSNet &net, const SUMOSAXAttributes &attrs, const SumoXMLTag element)
Parses the values and builds a stopping places for busses, trains or container vehicles.
MSJunction * retrieve(const std::string id)
try to retrieve junction by id
std::string reportCurrentEdgeOrLane() const
Return info about currently processed edge or lane.
void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
edge: the shape in xml-definition
bool myHaveSeenInternalEdge
whether the loaded network contains internal lanes
LinkDirection parseLinkDir(const std::string &dir)
Parses the given character into an enumeration typed link direction.
static bool gUsingInternalLanes
Information whether the simulation regards internal lanes.
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
void addParam(const std::string &key, const std::string &value)
Adds a parameter.
begin/end of the description of a neighboring lane
std::string getCurrentE3ID() const
Returns the id of the currently built e3 detector.
virtual SumoXMLNodeType getNodeType(bool &ok) const =0
Returns the value of the named attribute.
void buildInductLoop(const std::string &id, const std::string &lane, double pos, SUMOTime splInterval, const std::string &device, bool friendlyPos, const std::string &vTypes)
Builds an e1 detector and adds it to the net.
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
virtual void addNeigh(const std::string id)
Adds a neighbor to the current lane.
void addOutgoing(MSEdge *edge)
description of a logic request within the junction
const std::vector< int > getOptIntVector(int attr, const char *objectid, bool &ok, bool report=true) const
convenience function to avoid the default argument and the template stuff at getOpt<> ...
MSTLLogicControl & getTLLogicControlToUse() const
Returns the used tls control.
begin/end of the description of an edge
void addWAUTJunction(const std::string &wautid, const std::string &tls, const std::string &proc, bool synchron)
Adds a tls to the list of tls to be switched by the named WAUT.
void createEdgeLaneMeanData(const std::string &id, SUMOTime frequency, SUMOTime begin, SUMOTime end, const std::string &type, const bool useLanes, const bool withEmpty, const bool printDefaults, const bool withInternal, const bool trackVehicles, const int detectPersons, const double maxTravelTime, const double minSamples, const double haltSpeed, const std::string &vTypes, const std::string &device)
Creates edge based mean data collector using the given specification.
std::string myCurrentWAUTID
The id of the currently processed WAUT.
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
a lane based mean data detector
trigger: the time of the step
virtual void addInstantE1Detector(const SUMOSAXAttributes &attrs)
Builds an e1 detector using the given specification.
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue, bool report=true) const
Tries to read given attribute assuming it is an int.
std::vector< std::string > LaneIdVector
virtual void closeEdge()
Closes the process of building an edge.
virtual void addRouteProbeDetector(const SUMOSAXAttributes &attrs)
Builds a routeProbe-detector using the given specification.
virtual void endStoppingPlace()
End a stopping place.
A train stop (alias for bus stop)
void addLane(const SUMOSAXAttributes &attrs)
adds a lane to the previously opened edge
bool myHaveSeenNeighs
whether the loaded network contains explicit neighbor lanes
void closeLane()
Closes the building of a lane; The edge is completely described by now and may not be opened again...
a sink within a district (connection road)
virtual MSEdge * buildEdge(const std::string &id, const SumoXMLEdgeFunc function, const std::string &streetName, const std::string &edgeType, const int priority, const double distance)
Builds an edge instance (MSEdge in this case)
the edges crossed by a pedestrian crossing
virtual ~NLHandler()
Destructor.
void beginE3Detector(const std::string &id, const std::string &device, SUMOTime splInterval, double haltingSpeedThreshold, SUMOTime haltingTimeThreshold, const std::string &vTypes, bool openEntry)
Stores temporary the initial information about an e3 detector to build.
void addPhase(SUMOTime duration, const std::string &state, const std::vector< int > &nextPhases, SUMOTime min, SUMOTime max, const std::string &name)
Adds a phase to the currently built traffic lights logic.
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
NLTriggerBuilder & myTriggerBuilder
The trigger builder to use.
double myNetworkVersion
the loaded network version
void initJunctionLogic(const std::string &id)
Initialises a junction logic.
The link is controlled by a tls which is off and blinks, has to brake.
static std::string checkForRelativity(const std::string &filename, const std::string &basePath)
Returns the path from a configuration so that it is accessable from the current working directory...
bool myNetIsLoaded
whether the location element was already loadee
void addWAUT(SUMOTime refTime, const std::string &id, const std::string &startProg)
Adds a WAUT definition.
std::vector< Parameterised * > myLastParameterised
SUMOTime getOptSUMOTimeReporting(int attr, const char *objectid, bool &ok, SUMOTime defaultValue, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
virtual std::string getStringSecure(int id, const std::string &def) const =0
Returns the string-value of the named (by its enum-value) attribute.
virtual void inform(std::string msg, bool addType=true)
adds a new error to the list
const std::vector< std::string > getStringVector(int attr) const
Tries to read given attribute assuming it is a string vector.
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
void addPhase(const SUMOSAXAttributes &attrs)
adds a phase to the traffic lights logic currently build
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
void addDistrictEdge(const SUMOSAXAttributes &attrs, bool isSource)
MSNet & myNet
The net to fill (preinitialised)
static const GeoConvHelper & getFinal()
the coordinate transformation for writing the location element and for tracking the original coordina...
LinkState parseLinkState(const std::string &state)
Parses the given character into an enumeration typed link state.
The abstract direction of a link.
void setJunctions(MSJunction *from, MSJunction *to)
void buildE2Detector(const std::string &id, MSLane *lane, double pos, double endPos, double length, const std::string &device, SUMOTime frequency, SUMOTime haltingTimeThreshold, double haltingSpeedThreshold, double jamDistThreshold, const std::string &vTypes, bool friendlyPos, bool showDetector, MSTLLogicControl::TLSLogicVariants *tlls=0, MSLane *toLane=0)
Builds a new E2 detector and adds it to the net's detector control. Also performs some consistency ch...
const std::map< std::string, std::string > & getParametersMap() const
Returns the inner key/value map.
static StringBijection< PersonMode > PersonModeValues
person modes
The parent class for traffic light logics.
NLDiscreteEventBuilder myActionBuilder
A builder for object actions.
void addWAUTSwitch(const std::string &wautid, SUMOTime when, const std::string &to)
Adds a WAUT switch step to a previously built WAUT.
link: the index of the link within the traffic light
Parameterised myLastEdgeParameters
TLSLogicVariants & get(const std::string &id) const
Returns the variants of a named tls.
virtual void addCrossingEdges(const std::vector< std::string > &)
add the crossingEdges in a crossing edge if present
virtual void myEndElement(int element)
Called when a closing tag occurs.
MSTrafficLightLogic * getActive() const
virtual void addEdgeLaneMeanData(const SUMOSAXAttributes &attrs, int objecttype)
Builds edge or lane base mean data collector using the given specification.
Builds trigger objects for microsim.
void initJunctionLogic(const SUMOSAXAttributes &attrs)
begins the reading of a junction row logic
bool myLefthand
whether the loaded network was built for left hand traffic
An access point for a train stop.
void closePolygon()
ensures that the last position equals the first
Representation of a lane in the micro simulation.
void buildVaporizer(const SUMOSAXAttributes &attrs)
Builds a vaporization.
a single phase description
alternative tag for e3 detector
const std::string & getActiveKey() const
Returns the active key.
NLJunctionControlBuilder & myJunctionControlBuilder
The junction builder to use.
alternative tag for e2 detector
Parser and container for routes during their loading.
void initTrafficLightLogic(const SUMOSAXAttributes &attrs)
begins the reading of a traffic lights logic
static const Position INVALID
used to indicate that a position is valid
Interface for building edges.
void addLogicItem(int request, const std::string &response, const std::string &foes, bool cont)
Adds a logic item.
void clearParameter()
Clears the parameter map.
Information on vClass specific stop offsets at lane end.