70 myNet(net), myActionBuilder(net),
71 myCurrentIsInternalToSkip(false),
72 myDetectorBuilder(detBuilder), myTriggerBuilder(triggerBuilder),
73 myEdgeControlBuilder(edgeBuilder), myJunctionControlBuilder(junctionBuilder),
74 myAmInTLLogicMode(false), myCurrentIsBroken(false),
75 myHaveWarnedAboutDeprecatedLanes(false),
76 myLastParameterised(0),
77 myHaveSeenInternalEdge(false),
78 myHaveSeenNeighs(false),
79 myHaveSeenAdditionalSpeedRestrictions(false),
82 myNetIsLoaded(false) {
287 if (edge != 0 && from != 0 && to != 0) {
329 }
else if (
id[0] ==
':') {
338 WRITE_ERROR(
"Edge '" +
id +
"' has an invalid type.");
384 if (!crossingEdges.empty()) {
385 std::vector<std::string> crossingEdgesVector;
388 crossingEdgesVector.push_back(edges.
next());
433 if (shape.size() < 2) {
434 WRITE_ERROR(
"Shape of lane '" +
id +
"' is broken.\n Can not build according edge.");
439 if (permissions !=
SVCAll) {
449 WRITE_ERROR(
"Another lane with the id '" +
id +
"' exists.");
475 if (shape.size() > 2) {
484 WRITE_ERROR(
"An unknown or invalid junction type occured in junction '" +
id +
"'.");
489 std::vector<MSLane*> incomingLanes;
492 std::vector<MSLane*> internalLanes;
502 WRITE_ERROR(e.what() + std::string(
"\n Can not build according junction."));
511 const std::string& def, std::vector<MSLane*>& into,
bool& ok) {
514 std::string laneID = st.
next();
520 WRITE_ERROR(
"An unknown lane ('" + laneID +
"') was tried to be set as incoming to junction '" + junctionID +
"'.");
524 into.push_back(lane);
629 if (request >= 0 && response.length() > 0) {
673 WRITE_ERROR(
"Traffic light '" +
id +
"' has unknown type '" + typeS +
"'");
716 std::string phaseTypeString;
717 bool transient_notdecisional_bit;
724 transient_notdecisional_bit =
false;
726 if (phaseTypeString.find(
"decisional") != std::string::npos) {
727 transient_notdecisional_bit =
false;
728 }
else if (phaseTypeString.find(
"transient") != std::string::npos) {
729 transient_notdecisional_bit =
true;
731 MsgHandler::getWarningInstance()->
inform(
"SOTL_ATTL_TYPE_DECISIONAL nor SOTL_ATTL_TYPE_TRANSIENT. Assuming phase type as SUMOSOTL_TagAttrDefinitions::SOTL_ATTL_TYPE_TRANSIENT");
732 transient_notdecisional_bit =
false;
734 commit_bit = (phaseTypeString.find(
"commit") != std::string::npos);
736 if (phaseTypeString.find(
"target") != std::string::npos) {
737 std::string delimiter(
" ,;");
745 std::string::size_type firstPos = targetLanesString.find_first_not_of(delimiter, 0);
747 std::string::size_type pos = targetLanesString.find_first_of(delimiter, firstPos);
749 while (std::string::npos != pos || std::string::npos != firstPos) {
751 targetLanesVector.push_back(targetLanesString.substr(firstPos, pos - firstPos));
754 firstPos = targetLanesString.find_first_not_of(delimiter, pos);
757 pos = targetLanesString.find_first_of(delimiter, firstPos);
797 friendlyPos, vTypes);
883 const std::string toLane = attrs.
getOpt<std::string>(
SUMO_ATTR_TO,
id.c_str(), ok,
"");
892 const bool showDetector =
true;
895 WRITE_WARNING(
"Ignoring deprecated argument 'cont' for E2 detector '" +
id +
"'");
907 bool lanesGiven = lanes !=
"";
908 bool laneGiven = lane !=
"";
909 if (!(lanesGiven || laneGiven)) {
911 WRITE_WARNING(
"Trying to specify detector's lane by the given id since the argument 'lane' is missing.")
918 bool lsaGiven = lsaid !=
"";
919 bool toLaneGiven = toLane !=
"";
922 std::vector<MSLane*> clanes;
925 std::string seps =
" ,\t\n";
929 std::string nextLaneID = st.
next();
931 if (nextLaneID.find_first_of(seps) != nextLaneID.npos) {
935 clanes.push_back(clane);
937 if (clanes.size() == 0) {
938 throw InvalidArgument(
"Malformed argument 'lanes' for E2Detector '" +
id +
"'.\nSpecify 'lanes' as a sequence of lane-IDs seperated by whitespace or comma (',')");
941 WRITE_WARNING(
"Ignoring argument 'lane' for E2Detector '" +
id +
"' since argument 'lanes' was given.\n" 942 "Usage combinations for positional specification: [lane, pos, length], [endLane/lane, endPos, length], or [lanes, pos, endPos]");
945 WRITE_WARNING(
"Ignoring argument 'length' for E2Detector '" +
id +
"' since argument 'lanes' was given.\n" 946 "Usage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]");
951 WRITE_WARNING(
"Missing argument 'pos' for E2Detector '" +
id +
"'. Assuming detector start == lane start of lane '" + clanes[0]->getID() +
"'.");
955 endPosition = clanes[clanes.size() - 1]->getLength();
956 WRITE_WARNING(
"Missing argument 'endPos' for E2Detector '" +
id +
"'. Assuming detector end == lane end of lane '" + clanes[clanes.size() - 1]->getID() +
"'.");
961 std::stringstream ss;
962 ss <<
"Missing argument 'lane' for E2Detector '" <<
id <<
"'." 963 <<
"\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
970 if (endPosGiven && lengthGiven) {
971 std::stringstream ss;
972 ss <<
"Ignoring argument 'endPos' for E2Detector '" <<
id <<
"' since argument 'pos' was given." 973 <<
"\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
977 if (!lengthGiven && !endPosGiven) {
978 std::stringstream ss;
979 ss <<
"Missing arguments 'length'/'endPos' for E2Detector '" <<
id <<
"'. Assuming detector end == lane end of lane '" << lane <<
"'.";
981 endPosition = clane->getLength();
983 }
else if (endPosGiven) {
986 std::stringstream ss;
987 ss <<
"Missing arguments 'length'/'pos' for E2Detector '" <<
id <<
"'. Assuming detector start == lane start of lane '" << lane <<
"'.";
991 std::stringstream ss;
992 if (lengthGiven && fabs(length - clane->getLength()) >
NUMERICAL_EPS) {
993 ss <<
"Incomplete positional specification for E2Detector '" <<
id <<
"'." 994 <<
"\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
997 endPosition = clane->getLength();
999 ss <<
"Missing arguments 'pos'/'endPos' for E2Detector '" <<
id <<
"'. Assuming that the detector covers the whole lane '" << lane <<
"'.";
1021 throw InvalidArgument(
"The detector '" +
id +
"' refers to an unknown lsa '" + lsaid +
"'.");
1023 if (frequency != -1) {
1024 WRITE_WARNING(
"Ignoring argument 'frequency' for E2Detector '" +
id +
"' since argument 'tl' was given.");
1036 std::string filename;
1047 haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold,
1048 vTypes, friendlyPos, showDetector,
1053 haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold,
1054 vTypes, friendlyPos, showDetector,
1068 const std::string file = attrs.
get<std::string>(
SUMO_ATTR_FILE,
id.c_str(), ok);
1076 frequency, haltingSpeedThreshold, haltingTimeThreshold, vTypes);
1121 const std::string file = attrs.
get<std::string>(
SUMO_ATTR_FILE,
id.c_str(), ok);
1122 const std::string type = attrs.
getOpt<std::string>(
SUMO_ATTR_TYPE,
id.c_str(), ok,
"performance");
1134 excludeEmpty[0] !=
't' && excludeEmpty[0] !=
'T' && excludeEmpty[0] !=
'1' && excludeEmpty[0] !=
'x',
1135 excludeEmpty ==
"defaults", withInternal, trackVehicles,
1136 maxTravelTime, minSamples, haltingSpeedThreshold, vtypes,
1169 WRITE_ERROR(
"Unknown from-edge '" + fromID +
"' in connection");
1174 WRITE_ERROR(
"Unknown to-edge '" + toID +
"' in connection");
1177 if (fromLaneIdx < 0 || fromLaneIdx >= (
int)from->getLanes().size() ||
1178 toLaneIdx < 0 || toLaneIdx >= (int)to->
getLanes().size()) {
1179 WRITE_ERROR(
"Invalid lane index in connection from '" + from->getID() +
"' to '" + to->
getID() +
"'.");
1182 MSLane* fromLane = from->getLanes()[fromLaneIdx];
1193 if ((tlLinkIdx < 0 || tlLinkIdx >= (
int)logic->getCurrentPhaseDef().getState().size())
1194 && logic->getLogicType() !=
"railSignal" 1195 && logic->getLogicType() !=
"railCrossing") {
1197 "' in connection controlled by '" + tlID +
"'");
1204 double length = fromLane->
getShape()[-1].distanceTo(toLane->
getShape()[0]);
1212 "') should be set as a via-lane for lane '" + toLane->
getID() +
"'.");
1217 link =
new MSLink(fromLane, toLane, via, dir, state, length, foeVisibilityDistance, keepClear, logic, tlLinkIdx);
1281 WRITE_WARNING(
"no valid geo projection loaded from network. fcd-output.geo will not work");
1303 sink->
initialize(
new std::vector<MSLane*>());
1309 source->
initialize(
new std::vector<MSLane*>());
1312 for (std::vector<std::string>::const_iterator i = desc.begin(); i != desc.end(); ++i) {
1324 if (shape.size() != 0) {
1363 for (std::vector<std::string>::iterator it = edgeIDs.begin(); it != edgeIDs.end(); ++it) {
1366 WRITE_ERROR(
"Unknown edge '" + (*it) +
"' in roundabout");
1406 WRITE_ERROR(
"Lane '" + laneID +
"' to place poi '" + poiID +
"' on is not known.");
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 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.
void addSuccessor(MSEdge *edge)
Adds an edge to the list of edges which may be reached from this edge and to the incoming of the othe...
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.
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...
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 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.
begin/end of the description of a single lane
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
virtual void openWAUT(const SUMOSAXAttributes &attrs)
void addIncoming(MSEdge *edge)
virtual MSEdge * buildEdge(const std::string &id, const MSEdge::EdgeBasicFunction function, const std::string &streetName, const std::string &edgeType, const int priority)
Builds an edge instance (MSEdge in this case)
a traffic assignment zone
void beginE3Detector(const std::string &id, const std::string &device, SUMOTime splInterval, double haltingSpeedThreshold, SUMOTime haltingTimeThreshold, const std::string &vTypes)
Stores temporary the initial information about an e3 detector to build.
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)
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)
weights: time range begin
link,node: the traffic light id responsible for this link
The edge is a macroscopic connector (source/sink)
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.
const std::string & getActiveSubKey() const
Returns the active sub key.
static StringBijection< LinkState > LinkStates
link states
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
EdgeBasicFunction
Defines possible edge types.
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.
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.
The purpose of the edge is not known.
void openJunction(const std::string &id, const std::string &key, const SumoXMLNodeType type, double x, double y, const PositionVector &shape, const std::vector< MSLane *> &incomingLanes, const std::vector< MSLane *> &internalLanes)
Begins the processing of the named junction.
#define WRITE_WARNING(msg)
The simulated network and simulation perfomer.
static OptionsCont & getOptions()
Retrieves the options.
bool myAmInTLLogicMode
internal information whether a tls-logic is currently read
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
void addApproachingLane(MSLane *lane, bool warnMultiCon)
A road/street connecting two junctions.
void setLocation(const SUMOSAXAttributes &attrs)
Parses network location description.
void addPhase(SUMOTime duration, const std::string &state, SUMOTime min, SUMOTime max)
Adds a phase to the currently built traffic lights logic.
The definition of a periodic event.
virtual void openJunction(const SUMOSAXAttributes &attrs)
opens a junction for processing
NLEdgeControlBuilder & myEdgeControlBuilder
The edge builder to use.
The edge is a district edge.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
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.
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
virtual bool addPolygon(const std::string &id, const std::string &type, const RGBColor &color, double layer, double angle, const std::string &imgFile, const PositionVector &shape, bool fill, bool ignorePruning=false)
Builds a polygon using the given values and adds it to the container.
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
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
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.
virtual std::vector< std::string > getStringVector(int attr) const =0
Tries to read given attribute assuming it is a string vector.
void addParameter(const std::string &key, const std::string &value)
Adds a parameter.
std::string myCurrentWAUTID
The id of the currently processed WAUT.
The edge is a pedestrian walking area (a special type of internal edge)
virtual void myEndElement(int element)
Called when a closing tag occurs.
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.
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
a sink within a district (connection road)
the edges crossed by a pedestrian crossing
virtual ~NLHandler()
Destructor.
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 edge is a normal street.
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.
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.
The edge is a pedestrian crossing (a special type of internal edge)
virtual std::string getStringSecure(int id, const std::string &def) const =0
Returns the string-value of the named (by its enum-value) attribute.
void inform(std::string msg, bool addType=true)
adds a new error to the list
virtual MSLane * addLane(const std::string &id, double maxSpeed, double length, const PositionVector &shape, double width, SVCPermissions permissions, int index, bool isRampAccel)
Adds a lane to the current edge.
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...
The parent class for traffic light logics.
void beginEdgeParsing(const std::string &id, const MSEdge::EdgeBasicFunction function, const std::string &streetName, const std::string &edgeType, int priority)
Begins building of an MSEdge.
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
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
The edge is an internal edge.
bool myLefthand
whether the loaded network was built for left hand traffic
Parameterised * myLastParameterised
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.
Position getLanePos(const std::string &poiID, const std::string &laneID, double lanePos)
get position for a given laneID