 |
Eclipse SUMO - Simulation of Urban MObility
|
Go to the documentation of this file.
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) {
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 <<
"'.";
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;
1020 ss <<
"Incomplete positional specification for E2Detector '" <<
id <<
"'."
1021 <<
"\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
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()) {
A train stop (alias for bus stop)
virtual void openJunction(const SUMOSAXAttributes &attrs)
opens a junction for processing
void addWAUTSwitch(const std::string &wautid, SUMOTime when, const std::string &to)
Adds a WAUT switch step to a previously built WAUT.
void initTrafficLightLogic(const std::string &id, const std::string &programID, TrafficLightType type, SUMOTime offset)
Begins the reading of a traffic lights logic.
bool myHaveSeenInternalEdge
whether the loaded network contains internal lanes
const std::vector< std::string > getStringVector(int attr) const
Tries to read given attribute assuming it is a string vector.
Parameterised myLastEdgeParameters
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
void updateParameter(const std::map< std::string, std::string > &mapArg)
Adds or updates all given parameters from the map.
Information on vClass specific stop offsets at lane end.
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
MSLane * getLaneChecking(const std::string &laneID, SumoXMLTag type, const std::string &detid)
Returns the named lane.
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.
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
#define WRITE_WARNING(msg)
void addRequest(const SUMOSAXAttributes &attrs)
adds a request item to the current junction logic
static StringBijection< LinkState > LinkStates
link states
Representation of a lane in the micro simulation.
virtual void addNeigh(const std::string id)
Adds a neighbor to the current lane.
The link is controlled by a tls which is off and blinks, has to brake.
virtual std::string getString(int id) const =0
Returns the string-value of the named (by its enum-value) attribute.
void parseAndBeginParkingArea(MSNet &net, const SUMOSAXAttributes &attrs)
Parses his values and builds a parking area.
Interface for building edges.
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.
The base class for an intersection.
bool myLefthand
whether the loaded network was built for left hand traffic
ShapeContainer & getShapeContainer()
Returns the shapes container.
void addE3Entry(const std::string &lane, double pos, bool friendlyPos)
Builds an entry point of an e3 detector.
static const Position INVALID
used to indicate that a position is valid
parameter associated to a certain key
bool hasNext()
returns the information whether further substrings exist
std::string myCurrentDistrictID
The id of the current district.
bool myHaveSeenNeighs
whether the loaded network contains explicit neighbor lanes
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
void addAccess(MSNet &net, const SUMOSAXAttributes &attrs)
Parses the values and adds an access point to the currently parsed stopping place.
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<>
a source within a district (connection road)
The simulated network and simulation perfomer.
NLTriggerBuilder & myTriggerBuilder
The trigger builder to use.
alternative tag for e2 detector
void closeJunctionLogic()
Ends the building of a junction logic (row-logic)
virtual void addInstantE1Detector(const SUMOSAXAttributes &attrs)
Builds an e1 detector using the given specification.
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.
virtual void addRouteProbeDetector(const SUMOSAXAttributes &attrs)
Builds a routeProbe-detector using the given specification.
void beginE3Detector(const SUMOSAXAttributes &attrs)
Starts building of an e3 detector using the given specification.
void setLocation(const SUMOSAXAttributes &attrs)
Parses network location description.
begin/end of the description of a single lane
virtual void inform(std::string msg, bool addType=true)
adds a new error to the list
virtual void addE2Detector(const SUMOSAXAttributes &attrs)
Builds an e2 detector using the given specification.
link,node: the traffic light id responsible for this link
virtual void addCrossingEdges(const std::vector< std::string > &)
add the crossingEdges in a crossing edge if present
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
void addDistrictEdge(const SUMOSAXAttributes &attrs, bool isSource)
void addParam(const SUMOSAXAttributes &attrs)
void addDistrict(const SUMOSAXAttributes &attrs)
void addOutgoing(MSEdge *edge)
static OptionsCont & getOptions()
Retrieves the options.
std::string next()
returns the next substring when it exists. Otherwise the behaviour is undefined
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.
const double SUMO_const_laneWidth
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)
Builds trigger objects for microsim.
foe visibility distance of a link
void setJunctions(MSJunction *from, MSJunction *to)
void addIncoming(MSEdge *edge)
std::vector< std::string > LaneIdVector
void parseAndAddLotEntry(const SUMOSAXAttributes &attrs)
Parses his values and adds a lot entry to current parking area.
virtual void openWAUT(const SUMOSAXAttributes &attrs)
bool myNetIsLoaded
whether the location element was already loadee
void addPhase(const SUMOSAXAttributes &attrs)
adds a phase to the traffic lights logic currently build
LinkDirection
The different directions a link between two lanes may take (or a stream between two edges)....
std::vector< Parameterised * > myLastParameterised
virtual void closeEdge()
Closes the process of building an edge.
a single phase description
LinkState parseLinkState(const std::string &state)
Parses the given character into an enumeration typed link state.
SUMOTime getSUMOTimeReporting(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
NLEdgeControlBuilder & myEdgeControlBuilder
The edge builder to use.
A parking space for a single vehicle within a parking area.
void addStopOffsets(const std::map< SVCPermissions, double > &stopOffsets)
process a stopOffset element (originates either from the active edge or lane).
JunctionGraph myJunctionGraph
static bool init(OptionsCont &oc)
Initialises the processing and the final instance using the given options.
const std::string & getActiveSubKey() const
Returns the active sub key.
virtual void myEndElement(int element)
Called when a closing tag occurs.
The abstract direction of a link.
void addLink(MSLink *link)
Delayed initialization.
static StringBijection< LinkDirection > LinkDirections
link directions
SumoXMLTag
Numbers representing SUMO-XML - element names.
bool myHaveWarnedAboutInvalidTLType
an edge based mean data detector
MSTrafficLightLogic * getActive() const
void addConnection(const SUMOSAXAttributes &attrs)
adds a connection
void closeJunction(const std::string &basePath)
Closes (ends) the processing of the current junction.
weights: time range begin
Builder of microsim-junctions and tls.
void parseAndBuildStoppingPlace(MSNet &net, const SUMOSAXAttributes &attrs, const SumoXMLTag element)
Parses the values and builds a stopping places for busses, trains or container vehicles.
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.
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
NLDiscreteEventBuilder myActionBuilder
A builder for object actions.
virtual void addEdgeLaneMeanData(const SUMOSAXAttributes &attrs, int objecttype)
Builds edge or lane base mean data collector using the given specification.
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic,...
begin/end of the description of a neighboring lane
int getNumberOfLoadedPhases() const
return the number of phases loaded so far (for error reporting)
MSTLLogicControl::TLSLogicVariants & getTLLogic(const std::string &id) const
Returns a previously build tls logic.
const std::map< std::string, std::string > & getParametersMap() const
Returns the inner key/value map.
TLSLogicVariants & get(const std::string &id) const
Returns the variants of a named tls.
void parseAndBuildLaneSpeedTrigger(MSNet &net, const SUMOSAXAttributes &attrs, const std::string &base)
Parses his values and builds a lane speed trigger.
LinkDirection parseLinkDir(const std::string &dir)
Parses the given character into an enumeration typed link direction.
void addAction(const SUMOSAXAttributes &attrs, const std::string &basePath)
Builds an action and saves it for further use.
void addLink(MSLink *link, MSLane *lane, int pos)
Whether vehicles must keep the junction clear.
static const GeoConvHelper & getFinal()
the coordinate transformation for writing the location element and for tracking the original coordina...
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
void closeLane()
Closes the building of a lane; The edge is completely described by now and may not be opened again.
void setPermissionsFound()
Labels the network to contain vehicle class permissions.
static MsgHandler * getWarningInstance()
Returns the instance to add warnings to.
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.
description of a logic request within the junction
virtual void closeTrafficLightLogic(const std::string &basePath)
Ends the building of a traffic lights logic.
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
T get(const std::string &str) const
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....
std::string myCurrentWAUTID
The id of the currently processed WAUT.
virtual void addE1Detector(const SUMOSAXAttributes &attrs)
Builds an e1 detector using the given specification.
NLJunctionControlBuilder & myJunctionControlBuilder
The junction builder to use.
void closePolygon()
ensures that the last position equals the first
static RGBColor parseColor(std::string coldef)
Parses a color information.
void initialize(const std::vector< MSLane * > *lanes)
Initialize the edge.
NLHandler(const std::string &file, MSNet &net, NLDetectorBuilder &detBuilder, NLTriggerBuilder &triggerBuilder, NLEdgeControlBuilder &edgeBuilder, NLJunctionControlBuilder &junctionBuilder)
Constructor.
A class that stores a 2D geometrical boundary.
void addWAUT(SUMOTime refTime, const std::string &id, const std::string &startProg)
Adds a WAUT definition.
double getLength() const
Returns the lane's length.
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.
virtual void myEndElement(int element)
Called when a closing tag occurs.
begin/end of the description of an edge
void addLane(const SUMOSAXAttributes &attrs)
adds a lane to the previously opened edge
static StringBijection< PersonMode > PersonModeValues
person modes
A point in 2D or 3D with translation and scaling methods.
virtual ~NLHandler()
Destructor.
MSJunction * retrieve(const std::string id)
try to retrieve junction by id
void addApproachingLane(MSLane *lane, bool warnMultiCon)
A road/street connecting two junctions.
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.
void addWAUTJunction(const SUMOSAXAttributes &attrs)
void addParam(const std::string &key, const std::string &value)
Adds a parameter.
The parent class for traffic light logics.
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.
a lane based mean data detector
MSStoppingPlace * getCurrentStop()
bool myCurrentIsInternalToSkip
Information whether the currently parsed edge is internal and not wished, here.
virtual void endStoppingPlace()
End a stopping place.
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.
trigger: the time of the step
SUMOTime string2time(const std::string &r)
void endE3Detector()
Builds of an e3 detector using collected values.
MSTLLogicControl & getTLLogicControlToUse() const
Returns the used tls control.
MSNet & myNet
The net to fill (preinitialised)
static bool gUsingInternalLanes
Information whether the simulation regards internal lanes.
begin/end of the description of an edge restriction
a traffic assignment zone
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.
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...
void addIncomingLane(MSLane *lane, MSLink *viaLink)
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
void addE3Entry(const SUMOSAXAttributes &attrs)
Adds an entry to the currently processed e3 detector.
NLDetectorBuilder & myDetectorBuilder
The detector builder to use.
alternative tag for e3 detector
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
a sink within a district (connection road)
const PositionVector & getShape() const
Returns this lane's shape.
void closeWAUT(const std::string &wautid)
Closes loading of a WAUT.
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.
std::string myCurrentTypeID
The id of the currently processed edge type.
void initJunctionLogic(const SUMOSAXAttributes &attrs)
begins the reading of a junction row logic
virtual void addVTypeProbeDetector(const SUMOSAXAttributes &attrs)
Builds a vtype-detector using the given specification.
link: the index of the link within the traffic light
void ignoreLinkIndex(int pos)
root element of a network file
const std::string & getFileName() const
returns the current file name
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 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.
const SVCPermissions SVCAll
all VClasses are allowed
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
virtual SumoXMLNodeType getNodeType(bool &ok) const =0
Returns the value of the named attribute.
Parser and container for routes during their loading.
std::string getCurrentE3ID() const
Returns the id of the currently built e3 detector.
The definition of a periodic event.
connectio between two lanes
std::map< SVCPermissions, double > parseStopOffsets(const SUMOSAXAttributes &attrs, bool &ok)
Extract stopOffsets from attributes of stopOffset element.
void initJunctionLogic(const std::string &id)
Initialises a junction logic.
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
Storage for all programs of a single tls.
void beginEdgeParsing(const SUMOSAXAttributes &attrs)
begins the processing of an edge
virtual void endE3Detector()
Builds of an e3 detector using collected values.
void clearParameter()
Clears the parameter map.
maximum duration of a phase
void parseAndBuildChargingStation(MSNet &net, const SUMOSAXAttributes &attrs)
Parses his values and builds a charging station.
virtual void endParkingArea()
End a parking area.
void initTrafficLightLogic(const SUMOSAXAttributes &attrs)
begins the reading of a traffic lights logic
std::string reportCurrentEdgeOrLane() const
Return info about currently processed edge or lane.
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 MSEdge * closeEdge()
Closes the building of an edge; The edge is completely described by now and may not be opened again.
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
void parseAndBuildRerouter(MSNet &net, const SUMOSAXAttributes &attrs, const std::string &base)
Parses his values and builds a rerouter.
static std::string getJunctionIDFromInternalEdge(const std::string internalEdge)
return the junction id when given an edge of type internal, crossing or WalkingArea
void addE3Exit(const std::string &lane, double pos, bool friendlyPos)
Builds an exit point of an e3 detector.
the edges crossed by a pedestrian crossing
void addRestriction(const std::string &id, const SUMOVehicleClass svc, const double speed)
Adds a restriction for an edge type.
virtual SumoXMLEdgeFunc getEdgeFunc(bool &ok) const =0
Returns the value of the named attribute.
virtual std::string getStringSecure(int id, const std::string &def) const =0
Returns the string-value of the named (by its enum-value) attribute.
static MsgHandler * getErrorInstance()
Returns the instance to add errors to.
roundabout defined in junction
An access point for a train stop.
alternative tag for e1 detector
bool myAmParsingTLLogicOrJunction
internal information whether a tls-logic is currently read
void buildVaporizer(const SUMOSAXAttributes &attrs)
Builds a vaporization.
A calibrator placed over edge.
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...
Encapsulated SAX-Attributes.
edge: the shape in xml-definition
const std::string & getID() const
Returns the id.
void addWAUTSwitch(const SUMOSAXAttributes &attrs)
bool myHaveSeenAdditionalSpeedRestrictions
whether additional files contained type-specific speed limits
double myNetworkVersion
the loaded network version
Builds detectors for microsim.
const std::string & getActiveKey() const
Returns the active key.
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.
An instantenous induction loop.
void addLogicItem(int request, const std::string &response, const std::string &foes, bool cont)
Adds a logic item.
void parseLanes(const std::string &junctionID, const std::string &def, std::vector< MSLane * > &into, bool &ok)
void parseAndBuildCalibrator(MSNet &net, const SUMOSAXAttributes &attrs, const std::string &base)
Parses his values and builds a mesoscopic or microscopic calibrator.
begin/end of the description of a junction
void addRoundabout(const SUMOSAXAttributes &attrs)
void addE3Exit(const SUMOSAXAttributes &attrs)
Adds an exit to the currently processed e3 detector.